Einführung

Hallo, ich bin Vertriebsingenieur bei Snowflake. Einige meiner Erfahrungen und Experimente möchte ich in verschiedenen Beiträgen mit Ihnen teilen. In diesem Artikel zeige ich Ihnen, wie Sie mit Streamlit in Snowflake eine App erstellen, um die Anzahl der Token zu überprüfen und die Kosten für Cortex LLM abzuschätzen.

Hinweis: Dieser Beitrag stellt meine persönlichen Ansichten dar und nicht die von Snowflake.

Was ist Streamlit in Snowflake (SiS)?

Streamlit ist eine Python-Bibliothek, die es Ihnen ermöglicht, Web-UIs mit einfachem Python-Code zu erstellen, sodass kein HTML/CSS/JavaScript erforderlich ist. Beispiele finden Sie in der App Gallery.

Streamlit in Snowflake ermöglicht Ihnen die Entwicklung und Ausführung von Streamlit-Webanwendungen direkt auf Snowflake. Es ist einfach mit nur einem Snowflake-Konto zu verwenden und eignet sich hervorragend für die Integration von Snowflake-Tabellendaten in Web-Apps.

Über Streamlit in Snowflake (Offizielle Snowflake-Dokumentation)

Was ist Schneeflocken-Cortex?

Snowflake Cortex ist eine Suite generativer KI-Funktionen in Snowflake. Mit Cortex LLM können Sie mithilfe einfacher Funktionen in SQL oder Python große Sprachmodelle aufrufen, die auf Snowflake ausgeführt werden.

Large Language Model (LLM)-Funktionen (Snowflake Cortex) (Offizielle Snowflake-Dokumentation)

Funktionsübersicht

Bild

Hinweis: Der Text im Bild stammt aus „The Spider's Thread“ von Ryunosuke Akutagawa.

Merkmale

• Benutzer können ein Cortex-LLM-Modell auswählen
• Zeichen- und Tokenanzahl für vom Benutzer eingegebenen Text anzeigen
• Zeigen Sie das Verhältnis von Token zu Zeichen an
• Berechnen Sie die geschätzten Kosten basierend auf den Snowflake-Guthabenpreisen

Hinweis: Cortex LLM-Preistabelle (PDF)

Voraussetzungen

• Snowflake-Konto mit Cortex LLM-Zugriff
• snowflake-ml-python 1.1.2 oder höher

Hinweis: Verfügbarkeit der Cortex LLM-Region (offizielle Snowflake-Dokumentation)

Quellcode

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.")

Abschluss

Diese App erleichtert die Schätzung der Kosten für LLM-Workloads, insbesondere beim Umgang mit Sprachen wie Japanisch, bei denen häufig eine Lücke zwischen der Zeichenanzahl und der Tokenanzahl besteht. Ich hoffe, Sie finden es nützlich!

Ankündigungen

Was gibt es Neues bei Snowflake? Updates auf X

Ich teile die Neuigkeiten von Snowflake zu X. Bitte folgen Sie uns, wenn Sie interessiert sind!

Englische Version

Snowflake What's New Bot (englische Version)
https://x.com/snow_new_en

Japanische Version

Snowflake What's New Bot (japanische Version)
https://x.com/snow_new_jp

Änderungsverlauf

(20240914) Erster Beitrag

Originaler japanischer Artikel

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