Introducción

Hola, soy ingeniero de ventas en Snowflake. Me gustaría compartir algunas de mis experiencias y experimentos con ustedes a través de varias publicaciones. En este artículo, le mostraré cómo crear una aplicación usando Streamlit en Snowflake para verificar el recuento de tokens y estimar los costos de Cortex LLM.

Nota: Esta publicación representa mis opiniones personales y no las de Snowflake.

¿Qué es Streamlit en Snowflake (SiS)?

Streamlit es una biblioteca de Python que le permite crear interfaces de usuario web con código Python simple, eliminando la necesidad de HTML/CSS/JavaScript. Puedes ver ejemplos en la Galería de aplicaciones.

Streamlit en Snowflake le permite desarrollar y ejecutar aplicaciones web Streamlit directamente en Snowflake. Es fácil de usar con solo una cuenta de Snowflake y excelente para integrar datos de tablas de Snowflake en aplicaciones web.

Acerca de Streamlit en Snowflake (Documentación oficial de Snowflake)

¿Qué es la corteza del copo de nieve?

Snowflake Cortex es un conjunto de funciones de IA generativa en Snowflake. Cortex LLM le permite llamar a modelos de lenguaje grandes que se ejecutan en Snowflake usando funciones simples en SQL o Python.

Funciones del modelo de lenguaje grande (LLM) (Snowflake Cortex) (Documentación oficial de Snowflake)

Descripción general de funciones

Imagen

Nota: El texto de la imagen es de "The Spider's Thread" de Ryunosuke Akutagawa.

Características

• Los usuarios pueden seleccionar un modelo de Cortex LLM
• Mostrar recuentos de caracteres y tokens para el texto ingresado por el usuario
• Mostrar la proporción de tokens a caracteres
• Calcule el costo estimado según el precio del crédito de Snowflake

Nota: tabla de precios de Cortex LLM (PDF)

Requisitos previos

• Cuenta Snowflake con acceso a Cortex LLM
• snowflake-ml-python 1.1.2 o posterior

Nota: Disponibilidad regional de Cortex LLM (Documentación oficial de Snowflake)

Código fuente

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

Conclusión

Esta aplicación facilita la estimación de costos para cargas de trabajo de LLM, especialmente cuando se trata de idiomas como el japonés, donde a menudo hay una brecha entre el recuento de caracteres y el recuento de tokens. ¡Espero que te resulte útil!

Anuncios

Copo de nieve Novedades Actualizaciones en X

Estoy compartiendo las novedades de Snowflake en X. ¡No dudes en seguirnos si estás interesado!

Versión en inglés

Bot de novedades de Snowflake (versión en inglés)
https://x.com/snow_new_en

Versión japonesa

Bot de novedades de Snowflake (versión japonesa)
https://x.com/snow_new_jp

Historial de cambios

(20240914) Publicación inicial

Artículo original japonés

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