Introduction

Bonjour, je suis ingénieur commercial chez Snowflake. J'aimerais partager certaines de mes expériences et expériences avec vous à travers divers articles. Dans cet article, je vais vous montrer comment créer une application à l'aide de Streamlit dans Snowflake pour vérifier le nombre de jetons et estimer les coûts pour Cortex LLM.

Remarque : cet article représente mes opinions personnelles et non celles de Snowflake.

Qu’est-ce que Streamlit dans Snowflake (SiS) ?

Streamlit est une bibliothèque Python qui vous permet de créer des interfaces utilisateur Web avec du code Python simple, éliminant ainsi le besoin de HTML/CSS/JavaScript. Vous pouvez voir des exemples dans la galerie d'applications.

Streamlit dans Snowflake vous permet de développer et d'exécuter des applications Web Streamlit directement sur Snowflake. Il est facile à utiliser avec un simple compte Snowflake et idéal pour intégrer les données des tableaux Snowflake dans les applications Web.

À propos de Streamlit dans Snowflake (documentation officielle de Snowflake)

Qu’est-ce que le cortex de flocon de neige ?

Snowflake Cortex est une suite de fonctionnalités d'IA générative dans Snowflake. Cortex LLM vous permet d'appeler de grands modèles de langage exécutés sur Snowflake à l'aide de fonctions simples en SQL ou Python.

Fonctions du grand modèle de langage (LLM) (Snowflake Cortex) (documentation officielle de Snowflake)

Présentation des fonctionnalités

Image

Remarque : le texte dans l'image est tiré de "The Spider's Thread" de Ryunosuke Akutagawa.

Caractéristiques

• Les utilisateurs peuvent sélectionner un modèle Cortex LLM
• Afficher le nombre de caractères et de jetons pour le texte saisi par l'utilisateur
• Afficher le rapport jetons/caractères
• Calculer le coût estimé en fonction du prix du crédit Snowflake

Remarque : Tableau des tarifs Cortex LLM (PDF)

Conditions préalables

• Compte Snowflake avec accès Cortex LLM
• snowflake-ml-python 1.1.2 ou version ultérieure

Remarque : disponibilité de la région Cortex LLM (documentation officielle de Snowflake)

Code source

import streamlit as st
from snowflake.snowpark.context import get_active_session
import snowflake.snowpark.functions as F

# Get current session
session = get_active_session()

# Application title
st.title("Cortex AI Token Count Checker")

# AI settings
st.sidebar.title("AI Settings")
lang_model = st.sidebar.radio("Select the language model you want to use",
                              ("snowflake-arctic", "reka-core", "reka-flash", 
                              "mistral-large2", "mistral-large", "mixtral-8x7b", "mistral-7b", 
                              "llama3.1-405b", "llama3.1-70b", "llama3.1-8b", 
                              "llama3-70b", "llama3-8b", "llama2-70b-chat", 
                              "jamba-instruct", "gemma-7b")
)

# Function to count tokens (using Cortex's token counting function)
def count_tokens(model, text):
    result = session.sql(f"SELECT SNOWFLAKE.CORTEX.COUNT_TOKENS('{model}', '{text}') as token_count").collect()
    return result[0]['TOKEN_COUNT']

# Token count check and cost calculation
st.header("Token Count Check and Cost Calculation")

input_text = st.text_area("Select a language model from the left pane and enter the text you want to check for token count:", height=200)

# Let user input the price per credit
credit_price = st.number_input("Enter the price per Snowflake credit (in dollars):", min_value=0.0, value=2.0, step=0.01)

# Credits per 1M tokens for each model (as of 2024/8/30, mistral-large2 is not supported)
model_credits = {
    "snowflake-arctic": 0.84,
    "reka-core": 5.5,
    "reka-flash": 0.45,
    "mistral-large2": 1.95,
    "mistral-large": 5.1,
    "mixtral-8x7b": 0.22,
    "mistral-7b": 0.12,
    "llama3.1-405b": 3,
    "llama3.1-70b": 1.21,
    "llama3.1-8b": 0.19,
    "llama3-70b": 1.21,
    "llama3-8b": 0.19,
    "llama2-70b-chat": 0.45,
    "jamba-instruct": 0.83,
    "gemma-7b": 0.12
}

if st.button("Calculate Token Count"):
    if input_text:
        # Calculate character count
        char_count = len(input_text)
        st.write(f"Character count of input text: {char_count}")

        if lang_model in model_credits:
            # Calculate token count
            token_count = count_tokens(lang_model, input_text)
            st.write(f"Token count of input text: {token_count}")

            # Ratio of tokens to characters
            ratio = token_count / char_count if char_count > 0 else 0
            st.write(f"Token count / Character count ratio: {ratio:.2f}")

            # Cost calculation
            credits_used = (token_count / 1000000) * model_credits[lang_model]
            cost = credits_used * credit_price

            st.write(f"Credits used: {credits_used:.6f}")
            st.write(f"Estimated cost: ${cost:.6f}")
        else:
            st.warning("The selected model is not supported by Snowflake's token counting feature.")
    else:
        st.warning("Please enter some text.")

Conclusion

Cette application facilite l'estimation des coûts des charges de travail LLM, en particulier lorsqu'il s'agit de langues comme le japonais, où il existe souvent un écart entre le nombre de caractères et le nombre de jetons. J'espère que cela vous sera utile !

Annonces

Snowflake Quoi de neuf Mises à jour sur X

Je partage les nouveautés de Snowflake sur X. N'hésitez pas à suivre si vous êtes intéressé !

Version anglaise

Snowflake Quoi de neuf Bot (version anglaise)
https://x.com/snow_new_en

Version japonaise

Snowflake Quoi de neuf Bot (version japonaise)
https://x.com/snow_new_jp

Historique des modifications

(20240914) Message initial

Article japonais original

https://zenn.dev/tsubasa_tech/articles/4dd80c91508ec4