Experimente o Snowflake com notebooks¶
O Snowflake Notebooks é um ambiente de desenvolvimento que é possível usar com outros recursos do Snowflake. Este tópico mostra como aproveitar outros recursos do Snowflake nos notebooks.
Snowpark Python em notebooks¶
A biblioteca do Snowpark fornece uma API intuitiva para consulta e processamento de dados em um pipeline de dados. Usando a biblioteca Snowpark, é possível criar aplicativos que processam dados no Snowflake sem mover os dados para o sistema em que o código do aplicativo é executado. Você também pode automatizar a transformação e o processamento de dados escrevendo procedimentos armazenados e programando esses procedimentos como tarefas no Snowflake.
Você pode usar o Snowpark para consultar e processar dados em escala no Snowflake escrevendo o código do Snowpark em uma célula Python de seu notebook.
Exemplo de uso¶
O Snowpark Python vem pré-instalado no ambiente Snowflake Notebooks. O exemplo a seguir usa a biblioteca Snowpark em um notebook para ler em um arquivo CSV e uma tabela Snowflake e exibir seu conteúdo como saída.
No notebook, adicione uma célula Python, usando o atalho de teclado ou selecionando + Python. Snowflake Notebooks e Snowpark oferecem suporte a Python 3.9.
Configure uma sessão de Snowpark. Em notebooks, a variável do contexto de sessão é pré-configurada. Você pode usar o método
get_active_session
para obter a variável do contexto de sessão:from snowflake.snowpark.context import get_active_session session = get_active_session()
Use o Snowpark para carregar um arquivo CSV em um Snowpark DataFrame de um local de estágio. Este exemplo usa um estágio chamado
tastybyte_stage
.df = session.read.options({"infer_schema":True}).csv('@TASTYBYTE_STAGE/app_order.csv')
Carregue uma tabela Snowflake existente,
app_order
, ao Snowpark DataFrame.df = session.table("APP_ORDER")
Mostre o Snowpark DataFrame.
df
Nota
Fora do ambiente do Snowflake Notebooks, é necessário chamar df.show()
para imprimir o DataFrame. Nos Snowflake Notebooks, os DataFrames são avaliados imediatamente quando o df
é impresso. O DataFrame é impresso como uma exibição DataFrame interativa do Streamlit (st.dataframe). A saída de DataFrames é limitada a 10.000 linhas ou 8 MB, o que for menor.
Limitações do Snowpark¶
Um notebook Snowflake cria uma sessão Snowpark, para que você possa usar a maioria dos métodos disponíveis em uma classe de sessão Snowpark. Entretanto, como um notebook é executado dentro do Snowflake e não em seu ambiente de desenvolvimento local, você não pode usar os seguintes métodos:
session.add_import
session.add_packages
session.add_requirements
Algumas operações do Snowpark Python não funcionam com SPROCs. Para uma lista completa de operações, consulte Limitações do procedimento armazenado do Python.
Dica
Visualize mais exemplos de notebooks que usam Snowpark:
Nota
Esses guias de início rápido são mostrados apenas como exemplos. Seguir o exemplo pode exigir direitos adicionais sobre dados, produtos ou serviços de terceiros que não são de propriedade ou fornecidos pela Snowflake. A Snowflake não garante a precisão desses exemplos.
Streamlit em notebooks¶
Streamlit é uma biblioteca Python de código aberto que facilita a criação e o compartilhamento de aplicativos da Web personalizados para aprendizado de máquina e ciência de dados. Você pode criar aplicativos de dados interativos com o Streamlit diretamente em seu notebook. É possível testar e desenvolver seu aplicativo diretamente em um notebook. O Streamlit vem pré-instalado nos notebooks, para que você possa começar rapidamente.
Exemplo de uso¶
O Streamlit vem pré-instalado com o ambiente dos Snowflake Notebooks. O exemplo nesta seção cria um aplicativo de dados interativo usando o Streamlit.
Importação das bibliotecas necessárias
import streamlit as st import pandas as pd
Primeiro, crie alguns dados de exemplo para o aplicativo.
species = ["setosa"] * 3 + ["versicolor"] * 3 + ["virginica"] * 3 measurements = ["sepal_length", "sepal_width", "petal_length"] * 3 values = [5.1, 3.5, 1.4, 6.2, 2.9, 4.3, 7.3, 3.0, 6.3] df = pd.DataFrame({"species": species,"measurement": measurements,"value": values}) df
Configure seu controle deslizante interativo na biblioteca Streamlit.
st.markdown("""# Interactive Filtering with Streamlit! :balloon: Values will automatically cascade down the notebook cells""") value = st.slider("Move the slider to change the filter value 👇", df.value.min(), df.value.max(), df.value.mean(), step = 0.3 )
Por fim, mostre uma tabela filtrada com base no valor do controle deslizante.
df[df["value"]>value].sort_values("value")
Você pode interagir com o aplicativo em tempo real a partir do notebook. Veja a tabela filtrada mudar com base no valor definido no controle deslizante.
Dica
Para o exemplo completo, consulte a seção do aplicativo de dados interativos do notebook Histórias de dados visuais com os notebooks Snowflake.
Suporte Streamlit no Notebooks¶
Quando você usa os comandos Streamlit st.map ou st.pydeck_chart, o Mapbox fornece os blocos do mapa ao renderizar o conteúdo do mapa. Mapbox é um aplicativo de terceiros e está sujeito aos Termos das ofertas externas da Snowflake.
Os seguintes elementos do Streamlit não são compatíveis no Notebooks:
-
Não há suporte para as propriedades
page_title
,page_icon
emenu_items
do comandost.set_page_config
. Links de âncora
Ícones de materiais em Markdown
Snowpark ML no Notebooks¶
Snowpark ML é a biblioteca Python que fornece as APIs para o Snowflake ML e o desenvolvimento de modelos personalizados de machine learning no Snowflake. Com o Snowpark ML, é possível desenvolver modelos personalizados usando APIs com base em estruturas populares de ML, definir recursos atualizados automaticamente para treiná-los e armazená-los em um registro de modelos para facilitar a descoberta e a reutilização.
O Container Runtime for ML fornece opções de software e hardware para dar suporte a cargas de trabalho avançadas de ciência de dados e machine learning (aprendizado de máquina). Para obter detalhes sobre o tempo de execução do contêiner, consulte Notebooks no Container Runtime para ML.
Importante
O pacote snowflake-ml-python
e suas dependências devem ser permitidos pela política de pacotes da sua organização.
Exemplo de uso¶
Para usar o ML do Snowpark, instale a biblioteca snowflake-ml-python
em seu notebook:
No notebook, selecione Packages.
Localize a biblioteca snowflake-ml-python e selecione-a para realizar a instalação.
Aqui está um exemplo de como você pode usar a biblioteca de ML do Snowpark para pré-processamento de seus dados:
import snowflake.ml.modeling.preprocessing as pp
# Initialize a StandardScaler object with input and output column names
scaler = pp.StandardScaler(
input_cols=feature_names_input,
output_cols=feature_names_input
)
# Fit the scaler to the dataset
scaler.fit(upsampled_data)
# Transform the dataset using the fitted scaler
scaled_features = scaler.transform(upsampled_data)
scaled_features
Aqui está um exemplo de como você pode usar a biblioteca de ML do Snowpark para treinamento e inferência de modelos:
from snowflake.ml.modeling.ensemble import RandomForestClassifier
# Initialize a RandomForestClassifier object with input, label, and output column names
model = RandomForestClassifier(
input_cols=feature_names_input,
label_cols=label,
output_cols=output_label,
)
# Train the RandomForestClassifier model using the training set
model.fit(training)
# Predict the target variable for the testing set using the trained model
results = model.predict(testing)
Dica
- Para mais exemplos de uso do ML do Snowpark, consulte os seguintes notebooks:
Registro de ML do Snowflake em Notebooks¶
O Snowflake Model Registry permite que você gerencie com segurança os modelos e seus metadados no Snowflake, independentemente da origem. O registro de modelo armazena modelos de aprendizado de máquina como objetos ao nível de esquema de primeira classe no Snowflake para que eles possam ser facilmente encontrados e usados por outras pessoas em sua organização. Você pode criar registros e armazenar modelos neles usando a biblioteca Snowpark ML. Os modelos podem ter diversas versões e você pode designar uma versão como padrão.
Exemplo de uso¶
Para usar o registro de ML do Snowflake, instale a biblioteca snowflake-ml-python
em seu notebook:
Em seu notebook, selecione Packages na parte superior.
Procure pelo pacote snowflake-ml-python e selecione a biblioteca a ser instalada.
Aqui está um exemplo de como você pode usar o registro de ML do Snowflake para registrar um modelo em log:
from snowflake.ml.registry import Registry
# Create a registry and log the model
native_registry = Registry(session=session, database_name=db, schema_name=schema)
# Let's first log the very first model we trained
model_ver = native_registry.log_model(
model_name=model_name,
version_name='V0',
model=regressor,
sample_input_data=X, # to provide the feature schema
)
# Add evaluation metric
model_ver.set_metric(metric_name="mean_abs_pct_err", value=mape)
# Add a description
model_ver.comment = "This is the first iteration of our Diamonds Price Prediction model. It is used for demo purposes."
# Show Models
native_registry.get_model(model_name).show_versions()
Dica
Veja este exemplo de ponta a ponta de como usar o registro de ML do Snowflake.
pandas on Snowflake no notebooks¶
O pandas on Snowflake permite que você execute seu código pandas de forma distribuída diretamente em seus dados no Snowflake. Apenas alterando a instrução de importação e algumas linhas de código, é possível obter a mesma experiência familiar nativa do pandas com os benefícios de escalabilidade e segurança do Snowflake.
Com o pandas on Snowflake, você pode trabalhar com conjuntos de dados muito maiores e evitar o tempo e as despesas de portar seus pipelines do pandas para outras estruturas de Big Data ou provisionar máquinas grandes e caras. Ele executa cargas de trabalho nativamente no Snowflake por meio de transpilação para SQL, permitindo o aproveitamento da paralelização e os benefícios de governança e segurança de dados do Snowflake.
O pandas on Snowflake é fornecido pela API Snowpark pandas como parte da biblioteca Snowpark Python, que permite o processamento de dados escaláveis do código Python dentro da plataforma Snowflake.
Exemplo de uso¶
O Snowpark pandas está disponível no Snowpark Python versão 1.17 e posteriores. O Snowpark Python vem pré-instalado com o ambiente de Snowflake Notebooks.
Para instalar o Modin, selecione
modin
em Packages e certifique-se de que a versão seja 0.28.1 ou posterior.Para definir a versão do pandas, selecione
pandas
em Packages e certifique-se de que a versão seja 2.2.1.
Em uma célula Python, importe Snowpark Python e Modin:
import modin.pandas as pd import snowflake.snowpark.modin.plugin
Crie uma sessão Snowpark:
from snowflake.snowpark.context import get_active_session session = get_active_session()
Comece a usar a Snowpark Python API:
# Create a Snowpark Pandas DataFrame with sample data. df = pd.DataFrame([[1, 'Big Bear', 8],[2, 'Big Bear', 10],[3, 'Big Bear', None], [1, 'Tahoe', 3],[2, 'Tahoe', None],[3, 'Tahoe', 13], [1, 'Whistler', None],['Friday', 'Whistler', 40],[3, 'Whistler', 25]], columns=["DAY", "LOCATION", "SNOWFALL"]) # Drop rows with null values. df.dropna() # Compute the average daily snowfall across locations. df.groupby("LOCATION").mean()["SNOWFALL"]
Dica
Para obter mais exemplos de como usar o pandas on Snowflake, consulte Introdução ao pandas on Snowflake.
Snowflake Python API no Notebooks¶
A Snowflake Python API é uma biblioteca unificada que conecta perfeitamente o Python às cargas de trabalho do Snowflake. O objetivo é fornecer APIs abrangentes para interagir com os recursos do Snowflake em engenharia de dados, Snowpark, Snowpark ML e cargas de trabalho de aplicativos usando uma Python APIde primeira classe.
Você pode usar a Snowflake Python API para gerenciar recursos do Snowflake criando, excluindo ou modificando-os e muito mais. É possível usar Python para executar tarefas que você poderia executar com os comandos SQL do Snowflake.
No Notebooks, a variável do contexto de sessão é pré-configurada. Você pode usar o método get_active_session
para obter a variável do contexto de sessão:
from snowflake.snowpark.context import get_active_session session = get_active_session()
Crie um objeto Root
a partir do qual você possa usar a Snowflake Python API:
from snowflake.core import Root api_root = Root(session)
Aqui está um exemplo de como você pode criar um banco de dados e um esquema usando a Python API:
# Create a database and schema by running the following cell in the notebook: database_ref = api_root.databases.create(Database(name="demo_database"), mode="orreplace") schema_ref = database_ref.schemas.create(Schema(name="demo_schema"), mode="orreplace")Dica
Para obter um exemplo mais detalhado de como usar a API Python do Snowflake, consulte Exemplo de criação de objeto Snowflake usando a API Python em um notebook no Github.