Introdução

Olá, sou engenheiro de vendas na Snowflake. Eu gostaria de compartilhar algumas de minhas experiências e experimentos com você através de vários posts. Neste artigo, mostrarei como criar um aplicativo usando Streamlit no Snowflake para verificar contagens de tokens e estimar custos para Cortex LLM.

Nota: esta postagem representa minhas opiniões pessoais e não as do Snowflake.

O que é Streamlit em Snowflake (SiS)?

Streamlit é uma biblioteca Python que permite criar UIs da web com código Python simples, eliminando a necessidade de HTML/CSS/JavaScript. Você pode ver exemplos na App Gallery.

Streamlit no Snowflake permite que você desenvolva e execute aplicativos da web Streamlit diretamente no Snowflake. É fácil de usar com apenas uma conta Snowflake e ótimo para integrar dados da tabela Snowflake em aplicativos da web.

Sobre o Streamlit no Snowflake (documentação oficial do Snowflake)

O que é o córtex do floco de neve?

Snowflake Cortex é um conjunto de recursos generativos de IA no Snowflake. Cortex LLM permite chamar grandes modelos de linguagem em execução no Snowflake usando funções simples em SQL ou Python.

Funções do modelo de linguagem grande (LLM) (Snowflake Cortex) (documentação oficial do Snowflake)

Visão geral dos recursos

Imagem

Nota: O texto na imagem é de "The Spider's Thread" de Ryunosuke Akutagawa.

Características

• Os usuários podem selecionar um modelo Cortex LLM
• Exibir contagens de caracteres e tokens para texto inserido pelo usuário
• Mostrar a proporção de tokens para caracteres
• Calcule o custo estimado com base no preço de crédito do Snowflake

Nota: tabela de preços do Cortex LLM (PDF)

Pré-requisitos

• Conta Snowflake com acesso Cortex LLM
• snowflake-ml-python 1.1.2 ou posterior

Nota: disponibilidade da região Cortex LLM (documentação oficial do Snowflake)

Código Fonte

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

Conclusão

Este aplicativo facilita a estimativa de custos para cargas de trabalho LLM, especialmente ao lidar com idiomas como o japonês, onde geralmente há uma lacuna entre a contagem de caracteres e a contagem de tokens. Espero que seja útil para você!

Anúncios

Snowflake Novidades, atualizações no X

Estou compartilhando as atualizações de novidades do Snowflake no X. Fique à vontade para segui-lo se estiver interessado!

Versão em inglês

Snowflake What's New Bot (versão em inglês)
https://x.com/snow_new_en

Versão Japonesa

Snowflake What's New Bot (versão japonesa)
https://x.com/snow_new_jp

Histórico de alterações

(20240914) Postagem inicial

Artigo Original Japonês

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