Il machine learning tradizionale prevede di spostare i dati dai database verso i luoghi in cui risiedono i modelli. Con il recente boom dell'AI e l'enorme dimensione dei dataset odierni, questo approccio sta diventando sempre più impraticabile.
Terabyte di dati devono essere trasferiti dal database alle applicazioni client per pulizia, analisi e training dei modelli. Questo apparente innocuo viaggio di andata e ritorno spreca risorse preziose. Per questo sempre più aziende scelgono tecnologie in-database per ridurre al minimo il movimento dei dati ed eseguire le operazioni in modo fluido.
Una delle migliori tecnologie in-database sul mercato è Snowpark, offerta da Snowflake Cloud. Snowpark è un insieme di librerie e runtime che ti permette di eseguire in modo sicuro linguaggi di programmazione in Snowflake Cloud per sviluppare pipeline di dati e modelli di machine learning nello stesso ambiente dei tuoi database Snowflake.
In questo tutorial vedremo i fondamenti di Snowpark e come usarlo nei tuoi progetti. Diamo per scontato che tu conosca già SQL e Snowflake: se hai bisogno di un ripasso, puoi seguire il nostro SQL Fundamental Skill Track o leggere questo tutorial su Snowflake per principianti.
Iniziamo!
Perché Snowflake Snowpark?
Snowflake Snowpark è un insieme di librerie e runtime che ti consente di usare in sicurezza linguaggi di programmazione come Python, Java e Scala per elaborare i dati direttamente all'interno della piattaforma cloud di Snowflake.
Questo elimina la necessità di spostare i dati fuori da Snowflake per l'elaborazione, migliorando efficienza e sicurezza. Ecco alcuni dei suoi principali vantaggi:
Elabora i dati in Snowflake: Scrivi codice nel tuo linguaggio preferito per manipolare e analizzare i tuoi database SQL in Snowflake ed eseguilo all'interno degli ambienti sicuri di Snowflake. Questo elimina la necessità di spostare i dati in un altro ambiente.
Prestazioni migliori: Elaborando i dati direttamente in Snowflake, Snowpark può sfruttare l'architettura elastica e serverless della piattaforma per un'elaborazione efficiente.
Costi e overhead tecnologico ridotti: Poiché Snowflake fornisce la maggior parte delle risorse, non devi gestire piattaforme separate per calcolo e storage.
Lavora con ciò che conosci e dove vuoi: Le API di Snowpark ti permettono di connetterti ai tuoi database SQL da qualsiasi ambiente, come Jupyter o VSCode, e creare pipeline di dati e app di ML. La parte migliore è che puoi usare le tue librerie preferite, come Pandas, Scikit-learn, XGBoost, ecc., insieme ai framework di Snowpark.
In poche parole, Snowpark è un modo potente ma semplice per gli sviluppatori di creare pipeline di dati, soluzioni di machine learning e applicazioni data-driven direttamente in Snowflake Cloud.
Primi passi con Snowpark
L'obiettivo finale di questo tutorial è costruire un modello con iperparametri ottimizzati, addestrato su una tabella di un database Snowflake usando Snowpark. Per riuscirci, inizieremo da:
Creazione di un ambiente virtuale con le librerie rilevanti.
Ingestione di dati di esempio in Snowflake.
Creazione di una sessione Snowpark per connettersi a Snowflake.
Caricamento dei dati ingeriti nella sessione.
Creare un ambiente virtuale
Per questo tutorial useremo un nuovo ambiente conda:
Nota a margine: se stai usando un ambiente conda appena installato, dovrai eseguire $conda init prima di attivare l'ambiente snowpark.
Dopo l'attivazione, dobbiamo installare le seguenti librerie:
$ pip install snowflake-snowpark-python #The Snowpark API
$ pip install pandas pyarrow numpy matplotlib seabornOfferto da
Se userai Jupyter, installa anche ipykernel ed esegui il seguente comando per aggiungere l'ambiente che stiamo usando come kernel Jupyter:
$ pip install ipykernel
$ ipython kernel install--user--name=snowparkOfferto da
Ora importiamo alcune librerie generali che ci serviranno lungo il percorso:
import warnings
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
warnings.filterwarnings("ignore")Offerto da
Ingerire dati di esempio in Snowflake
Per questo tutorial useremo il dataset Diamonds di Seaborn: puoi scaricare il file CSV direttamente dal mio GitHub.
Una volta effettuato l'accesso all'app Snowflake, segui la GIF qui sotto per ingerire il dataset in una nuova tabella del database (crea un nuovo account se non ne hai già uno):
In pratica, raramente importerai file CSV come tabelle nei tuoi database Snowflake. Per lo più lavorerai con database esistenti, con diversi livelli di accesso concessi dagli amministratori dei database della tua azienda.
Creare una sessione Snowpark
Ora dobbiamo stabilire una connessione tra l'API di Snowpark e il cloud di Snowflake per interrogare il nostro database. Questa connessione richiede le seguenti credenziali di Snowflake: nome dell'account, username e password.
Nell'immagine qui sotto, ti mostro come recuperare il tuo username e il nome dell'account dalla dashboard di Snowflake:
Crea un file separato chiamato config.py che contiene un unico dizionario chiamato credentials con il seguente formato:
credentials =({"account":"3-4",# Combine 3 and 4 with a hyphen"username":"bexgboost",# Your username in lowercase"password":"your_password",# Your Snowflake password},)Offerto da
Per motivi di sicurezza, salviamo le credenziali in un file separato. Aggiungendo questo file a .gitignore ti assicuri che le credenziali di Snowflake non vengano divulgate per errore.
Ora importiamo il dizionario credentials e la classe Session di Snowpark:
from config import credentials
from snowflake.snowpark import SessionOfferto da
Per stabilire la connessione useremo il metodo Session.builder.configs.create():
connection_parameters ={"account": credentials["account"],"user": credentials["username"],"password": credentials["password"],}
new_session = Session.builder.configs(connection_parameters).create()
new_session.get_current_user()Offerto da
Pesa solo 48 byte quando dovrebbe essere oltre 3 MB. Dedicando un po' di tempo in più capiremo perché succede.
Capire i DataFrame di Snowpark
Finora abbiamo coperto i seguenti passaggi:
Creato un ambiente virtuale con le librerie rilevanti.
Ingerito dati di esempio in Snowflake.
Creata una sessione Snowpark per connettersi a Snowflake.
Parliamo ora dei DataFrame di Snowpark!
I DataFrame di Snowpark sono lazy
I DataFrame di Pandas usano la tua RAM, quindi vivono sulla tua macchina. Al contrario, i DataFrame di Snowpark vivono all'interno della piattaforma cloud di Snowflake, anche se puoi vederne la rappresentazione nel tuo ambiente di sviluppo. I dati restano sul cloud e non devono essere scaricati in locale per eseguire operazioni.
Un altro aspetto importante dei DataFrame di Snowpark è che lavorano in modalità lazy. Significa che non eseguono alcuna operazione sui dati finché non glielo dici esplicitamente.
Invece, costruiscono una rappresentazione logica delle operazioni desiderate che viene poi tradotta in query SQL ottimizzate per l'esecuzione in Snowflake.
Per confronto, Pandas esegue le operazioni immediatamente, cioè in eager execution.
In termini di prestazioni, la valutazione lazy è sempre significativamente più veloce dell'esecuzione eager. Poiché i DataFrame lazy usano le potenti risorse di calcolo elastiche di Snowflake, possono spingere le operazioni a livello di database ed eseguirle molto più rapidamente.
Per capire meglio la differenza tra valutazione lazy ed esecuzione eager, immagina che i nostri dati in Snowflake siano una biblioteca gigantesca. Abbiamo i due scenari seguenti:
Eager execution (DataFrame di Pandas): raccogliamo tutti i libri che ci servono sulla nostra scrivania (macchina locale) e poi li analizziamo uno a uno.
Lazy evaluation (DataFrame di Snowpark): diciamo al bibliotecario (Snowpark) quali libri ci servono e quale analisi vogliamo eseguire, e il bibliotecario recupera e analizza in modo efficiente le informazioni rilevanti.
Quando usare i DataFrame di Snowpark
Dato che Snowpark può convertire in DataFrame Pandas, quando dovremmo usare l'uno o l'altro?
pandas_diamonds = diamonds_df.to_pandas()
pandas_diamonds.head()Offerto da
La risposta dipende in gran parte dalla dimensione del dataset.
Se il tuo dataset è piccolo (come Diamonds), puoi scaricarlo in locale e passarlo a Pandas senza problemi (che è ciò che fa il metodo DataFrame.to_pandas()).
Ma con i dataset di oggi, le cose possono sfuggire di mano rapidamente e potremmo dover aspettare ore per scaricare il database. E ricorda, è un biglietto di andata e ritorno: qualsiasi nuovo dato che vogliamo conservare deve anche essere rimandato su. È per questo che vale la pena imparare l'API dei DataFrame di Snowpark.
In alternativa, il metodo Session.sql() ci consente di eseguire qualsiasi espressione SQL compatibile con Snowflake (vedi l'esempio sotto). Tuttavia, ti consiglio vivamente di padroneggiare l'API dei DataFrame di Snowpark perché contiene molte funzioni integrate per oltre 100 funzioni ed espressioni SQL.
result = new_session.sql("""
SELECT PRICE, CUT FROM DIAMONDS LIMIT 10
""")type(result)Offerto da
Qui la funzione col crea un riferimento alla colonna indicata e restituisce un oggetto Column. Poi .upper() converte in maiuscolo i valori della colonna CUT:
Ma se guardiamo il dataset diamonds, vediamo che i valori nella colonna CUT hanno ancora lettere minuscole. Perché? Ebbene, l'espressione F.upper(F.col("CUT")) è equivalente alla seguente query SQL:
Scopriamo che nel nostro dataset ci sono oltre 5000 diamanti che costano più di 10.000 $. Proviamo anche a creare una colonna:
(
diamonds_df.with_column("PRICE_SQUARED", F.col("PRICE")**2).select("PRICE","PRICE_SQUARED").show(5))Offerto da
Sopra mostriamo che è possibile anche concatenare i metodi: abbiamo una nuova colonna chiamata “PRICE_SQUARED”. Le funzioni dei DataFrame Snowpark sono simili a quelle di Pandas.
In sintesi, se cerchi un'alternativa Snowpark a una funzione di Pandas, la troverai o sotto F o tra i metodi dei DataFrame di Snowpark. Puoi verificarlo chiamando dir(F) o dir(diamonds_df) o leggendo la reference di Snowpark Python.
Eseguire EDA sui DataFrame di Snowpark
Una parte importante dell'exploratory data analysis (EDA) consiste nel creare visualizzazioni. Per fortuna, non ci serve Snowpark per questo perché possiamo continuare a usare il moderno stack dati.
L'idea è questa: poiché l'EDA serve a scoprire tendenze e insight generali, spesso possiamo usare un campione invece dell'intero dataset. Una volta scaricato un campione rappresentativo, possiamo convertirlo in un DataFrame Pandas e usare i fidati Matplotlib o Seaborn.
Iniziamo con la conversione:
sample = diamonds_df.sample(0.25).to_pandas()
sample.head()Offerto da
Qui stiamo scaricando il 25% del dataset come DataFrame Pandas. Convertiamo i nomi delle colonne in minuscolo:
sample.columns =[col.lower()for col in sample.columns]
sample.columnsOfferto da
Ora puoi fare EDA come faresti con qualsiasi dataset. Qui sotto esploriamo alcune idee possibili e partiamo generando uno scatter plot per visualizzare la relazione tra prezzo e carato:
#Remember we imported seaborn as sns
sns.scatterplot(data=sample, x="price", y="carat", s=1)
plt.title("Prezzo dei diamanti vs carati")
plt.show()Offerto da
Ora tracciamo una matrice di correlazione per vedere la correlazione tra ogni coppia di feature numeriche:
corr_matrix = sample.corr(numeric_only=True)
sns.heatmap(corr_matrix, center=0, square=True, annot=True
plt.title("Matrice di correlazione delle feature numeriche dei diamanti")
plt.show()Offerto da
Possiamo anche creare un grafico a barre delle categorie di taglio dei diamanti:
cut_counts = sample.groupby("cut")["cut"].count()
cut_counts.plot(kind="bar")
plt.title("Conteggio per categoria dei tagli dei diamanti")
plt.xlabel("Taglio del diamante")
plt.show()Offerto da
Per confermare che questi grafici saranno più o meno uguali sull'intero dataset, eseguiremo la versione SQL del grafico a barre qui sopra.
Per prima cosa, scriveremo un'espressione SQL per raggruppare il dataset diamonds per CUT:
result = new_session.sql("""
SELECT cut, COUNT(*) AS count
FROM diamonds
GROUP BY cut;
""")Offerto da
Ora convertiamo e scarichiamo il risultato come DataFrame Pandas:
result_pd = result.to_pandas()
result_pdOfferto da
Questa volta useremo la funzione plt.bar() per creare il grafico:
plt.bar(x=result_pd["CUT"], height=result_pd["COUNT"])
plt.show()Offerto da
L'ordine delle barre è diverso ma, affiancandoli, si vede che trasmettono le stesse informazioni.
Addestrare un modello di Machine Learning in Snowpark
Siamo pronti per imparare come addestrare modelli di machine learning in Snowpark!
Inizieremo pulendo il dataset.
Pulire i dati in Snowpark
Per prima cosa assicuriamoci che tutte le colonne abbiano il tipo di dato corretto:
La colonna table ha un nome strano, quindi la convertiremo in maiuscolo TABLE_ (con un underscore finale per evitare conflitti con una parola chiave SQL):
diamonds_df = diamonds_df.with_column_renamed('"table"',"TABLE_")
diamonds_df.columnsOfferto da
Dovremo cambiare il tipo di dato delle feature numeriche da DecimalType a DoubleType perché i decimali non sono ancora supportati in Snowpark.
from snowflake.snowpark.types import DoubleType
numeric_features =["CARAT","X","Y","Z","DEPTH","TABLE_"]for col in numeric_features:
diamonds_df = diamonds_df.with_column(col, diamonds_df[col].cast(DoubleType()))list(diamonds_df.select(*numeric_features))Offerto da
[Column("CARAT"),
Column("X"),
Column("Y"),
Column("Z"),
Column("DEPTH"),
Column("TABLE_")]Offerto da
Nel frammento sopra usiamo di nuovo il metodo .with_column(). Un altro metodo nuovo è .cast(), che fa parte dei metodi dei DataFrame di Snowpark.
Snowpark richiede anche che tutte le feature testuali siano in maiuscolo e senza spazi tra le parole prima di codificarle. Al momento i valori della feature CUT violano questo requisito, quindi lo sistemeremo con trasformazioni di funzione:
import snowflake.snowpark.functions as F
defremove_space_and_upper(df):
df = df.with_column("CUT", F.upper(F.replace(F.col("CUT")," ","_")))return df
diamonds_df = remove_space_and_upper(diamonds_df)Offerto da
I nostri dati ora sono privi di problemi di pulizia. Possiamo salvarli di nuovo come nuova tabella su Snowflake:
diamonds_df.write.mode("overwrite").save_as_table("diamonds_cleaned")Offerto da
Assicurati di aggiungere la modalità overwrite perché potresti dover tornare indietro, modificare alcune operazioni di pulizia e salvare di nuovo.
Preparare i dati per il modeling in Snowpark
In questa sezione affronteremo gli ultimi problemi di pre-processing che potrebbero impedire l'addestramento dei modelli. Carichiamo la tabella pulita della sezione precedente:
clean_df = new_session.table("diamonds_cleaned")
clean_df.show()Offerto da
Ottimo!
Successivamente importeremo i sottomoduli preprocessing e pipeline dallo spazio dei nomi snowflake.ml.
import snowflake.ml.modeling.preprocessing as snowml
from snowflake.ml.modeling.pipeline import PipelineOfferto da
Mentre l'API dei DataFrame di Snowpark è disponibile sotto snowflake.snowpark, i moduli di Snowpark ML sono presenti in snowflake.ml. All'inizio può confondere, prenditi il tempo per abituarti.
Nel codice seguente:
Elenchiamo i nomi delle feature categoriche che devono essere codificate.
Definiamo i nomi per le feature in output perché Snowpark aggiunge le feature codificate come nuove colonne invece di sostituire le vecchie.
Definiamo l'ordine corretto delle categorie ordinali; nel dataset diamonds tutte le categorie hanno un ordine intrinseco, diventando più costose da sinistra a destra.
# List all the features for processing
cat_cols =["CUT","COLOR","CLARITY"]
cat_cols_encoded =["CUT_OE","COLOR_OE","CLARITY_OE"]# We already have numeric_features# List the correct ordering of categorical features
categories ={"CUT": np.array(["IDEAL","PREMIUM","VERY_GOOD","GOOD","FAIR"]),"CLARITY": np.array(["IF","VVS1","VVS2","VS1","VS2","SI1","SI2","I1","I2","I3"]),"COLOR": np.array(["D","E","F","G","H","I","J"]),}Offerto da
Ora siamo pronti a costruire una pipeline simile a una pipeline di Scikit-learn:
# Build the pipeline
preprocessing_pipeline = Pipeline(
steps=[("OE",
snowml.OrdinalEncoder(
input_cols=cat_cols, output_cols=cat_cols_encoded, categories=categories
),),("SS",
snowml.StandardScaler(
input_cols=numeric_features, output_cols=numeric_features
),),])Offerto da
La classe Pipeline accetta un elenco di step, ciascuno una classe di pre-processing. Qui usiamo OrdinalEncoder per codificare le categoriche come 0, 1, 3, ecc. e StandardScaler per normalizzare le feature numeriche.
Infine, salveremo la pipeline in locale con joblib e la testeremo sull'intero dataset:
import joblib
PIPELINE_FILE ="pipeline.joblib"# Pickle locally first
joblib.dump(preprocessing_pipeline, PIPELINE_FILE)
transformed_diamonds_df = preprocessing_pipeline.fit(clean_df).transform(clean_df)# transformed_diamonds_df.show() - commented because of long outputOfferto da
Lo snippet gira senza errori, quindi la nostra pipeline funziona, segnale che possiamo finalmente addestrare un modello.
Addestrare un modello XGBoost in Snowpark
Per addestrare un modello, elencheremo di nuovo i nomi delle feature e del target:
# Define the columns again
cat_cols_encoded =["CUT_OE","COLOR_OE","CLARITY_OE"]
numeric_features =["CARAT","X","Y","Z","DEPTH","TABLE_"]
label_cols =["PRICE"]# Must be a list
output_cols =["PRICE_PREDICTED"]# Required in snowparkOfferto da
Ora suddivideremo i dati usando DataFrame.random_split() e forniremo i pesi per rappresentare la frazione di training e test:
# Split the data
train_df, test_df = diamonds_df.random_split(weights=[0.8,0.2], seed=42)Offerto da
Quindi caricheremo la pipeline e applicheremo fit-transform sia al train che al test.
# Load the pre-processing pipeline locally
pipeline = joblib.load("pipeline.joblib")# Apply it to both dataframes
train_df_transformed = pipeline.fit(train_df).transform(train_df)
test_df_transformed = pipeline.transform(test_df)Offerto da
Sopra, assicurati di chiamare solo .transform() sul test set per evitare leakage.
Successivamente inizializziamo un modello di regressione XGBoost dal sotto-modulo ml.modeling.xgboost:
# Snowpark has models from scikit-learn and lightgbm toofrom snowflake.ml.modeling.xgboost import XGBRegressor
# Initialize
regressor = XGBRegressor(
input_cols=cat_cols_encoded + numeric_features,
label_cols=label_cols,
output_cols=output_cols,)Offerto da
La classe XGBRegressor richiede tutti i nomi di input, tutti i nomi del target e i nomi delle colonne di output. Una volta forniti, chiamiamo .fit() per avviare il training:
# Train
regressor.fit(train_df_transformed)Offerto da
L'addestramento potrebbe essere lento se hai un account Snowflake gratuito con risorse di calcolo limitate e senza GPU.
Una volta terminato il training, possiamo generare le previsioni:
# Predict
train_preds = regressor.predict(train_df_transformed)
test_preds = regressor.predict(test_df_transformed)Offerto da
Diamo un'occhiata alle previsioni:
train_preds.select("PRICE","PRICE_PREDICTED").show(5)Offerto da
Ora dobbiamo misurare quanto bene si è comportato il nostro modello iniziale. Snowpark include dozzine di metriche di Scikit-learn nel suo sottomodulo ml.modeling.metrics, che importiamo come M:
import snowflake.ml.modeling.metrics as MOfferto da
Quindi eseguiamo due volte mean_squared_error per misurare la root mean squared error (RMSE) sia su training che su test (sotto, squared=False restituisce l'RMSE invece dell'MSE):
rmse_train = M.mean_squared_error(
df=train_preds,
y_true_col_names=label_cols,
y_pred_col_names=output_cols,
squared=False,)
rmse_test = M.mean_squared_error(
df=test_preds,
y_true_col_names=label_cols,
y_pred_col_names=output_cols,
squared=False,)print(f"Train RMSE score for XGBRegressor: {rmse_train:.4f}")print(f"Test RMSE score for XGBRegressor: {rmse_test:.4f}")Offerto da
Train RMSE score for XGBRegressor: 371.9664
Test RMSE score for XGBRegressor: 542.1566Offerto da
In media il nostro modello sbaglia di 542 $ e potrebbe anche essere un po' in overfitting perché la differenza tra gli RMSE di training e test è grande.
Ottimizziamo gli iperparametri del modello per affrontare questi problemi.
Tuning degli iperparametri in Snowpark
Attualmente Snowpark offre due classi per il tuning degli iperparametri:
GridSearchCV: ricerca esaustiva di tutte le combinazioni di iperparametri con cross-validation.
RandomizedSearchCV: ricerca casuale su distribuzioni di iperparametri con cross-validation.
XGBoost ha circa una dozzina di iperparametri che possono migliorarne le prestazioni (puoi saperne di più in questo tutorial su come usare XGBoost in Python). Questo ci orienta verso una ricerca randomizzata. Personalmente preferirei usare Optuna, che usa la ricerca bayesiana, ma al momento non abbiamo ancora questa possibilità in Snowpark.
Fissiamo il numero di stimatori a 2000 e ottimizziamo solo i parametri max_depth e learning_rate. rscv ha un parametro predefinito n_iter=10, il che significa che la ricerca verrà eseguita 10 volte, scegliendo ogni volta una combinazione casuale di parametri. Per risultati più accurati, è meglio scegliere un valore più alto per questo parametro.
Ora misuriamo le prestazioni del miglior modello trovato. Il codice è lo stesso di prima ma invece di regressor useremo l'oggetto rscv:
Train RMSE score for optimal model: 224.2405
Test RMSE score for optimal model: 572.0517Offerto da
L'RMSE di training è sceso ma quello di test è persino più alto. Questo indica che siamo ancora in overfitting e dobbiamo ampliare la ricerca includendo altri parametri per potare gli alberi decisionali che XGBoost usa sotto il cofano.
Questa parte la lascio a te.
Salvare il modello migliore in Snowpark
Se chiudiamo la sessione ora, perderemo il modello ottimizzato. Per salvarlo useremo il model registry nativo di Snowpark, uno storage virtuale che puoi usare per salvare qualsiasi modello e i suoi metadati.
Il registry è disponibile come classe Registry e richiede i nomi del database e dello schema della sessione corrente. Richiede anche di assegnare un nome al progetto per evitare conflitti con modelli di altri progetti:
# Set up for Registryfrom snowflake.ml.registry import Registry
# Get the current db and schema name
db_name = new_session.get_current_database()
schema_name = new_session.get_current_schema()# Define global model name for the project
model_name ="diamond_prices_regression"# Initialize a registry to log models
registry = Registry(session=new_session, database_name=db_name, schema_name=schema_name)Offerto da
Useremo il metodo Registry.log_model() per salvare i nostri modelli:
# Get sample data to pass into registry for schema
sample = train_df.select(cat_cols_encoded + numeric_features).limit(50)# Log the first model
v0 = registry.log_model(
model_name=model_name,
version_name="v0",
model=regressor,
sample_input_data=sample,)Offerto da
Possiamo registrare una metrica per il modello con il metodo .set_metric() (possiamo registrare quante metriche vogliamo). Aggiungeremo anche un commento per descrivere il modello:
# Add the models RMSE score
v0.set_metric(metric_name="RMSE", value=rmse_test)# Add a description
v0.comment ="The first model to predict diamond prices"Offerto da
Facciamo lo stesso per il miglior modello trovato con la ricerca random. Quando registri la metrica, non dimenticare di cambiare il valore in optimal_rmse_test.
# Log the optimal model
v1 = registry.log_model(
model_name=model_name,
version_name="v1",
model=regressor,
sample_input_data=sample,)# Add the models RMSE score
v1.set_metric(metric_name="RMSE", value=optimal_rmse_test)# Add a description
v1.comment ="Optimal model found with RandomizedSearchCV"Offerto da
Per confermare che i modelli siano salvati, puoi chiamare .show_models():
# Confirm the models are added
registry.show_models()Offerto da
Per saperne di più su come gestire il registry consulta questa pagina della documentazione per sviluppatori di Snowpark.
Eseguire inferenza in Snowpark
L'inferenza di solito si fa scegliendo il miglior modello dal tuo registry. Possiamo farlo filtrando il risultato di .show_models() o recuperando direttamente il modello con il suo tag di versione, come facciamo sotto:
# Doing inference with the optimal model
optimal_version = registry.get_model(model_name).version("v1")
results = optimal_version.run(test_df, function_name="predict")
results.columnsOfferto da
Il metodo get_model() restituisce un oggetto model generico, diverso da XGBRegressor. Per questo devi chiamare .run() specificando il nome della funzione per eseguire l'inferenza.
Conclusione
In questo tutorial abbiamo coperto un framework end-to-end per addestrare modelli di machine learning in Snowflake Snowpark. Ottimo lavoro!
Siamo partiti da un dataset grezzo e non pulito e siamo arrivati a un modello di regressione XGBoost ottimizzato. Abbiamo eseguito tutte le operazioni su Snowflake Cloud, quindi non abbiamo dovuto usare risorse del sistema.
Abbiamo visto quanto siano efficaci le operazioni in-database quando abbiamo dataset di grandi dimensioni, e che Snowflake Snowpark è uno dei migliori strumenti sul mercato per facilitare questo processo.
Se vuoi saperne di più su Snowpark o Snowflake, dai un'occhiata a queste risorse:
Sono un creator di contenuti sulla data science con oltre 2 anni di esperienza e uno dei più seguiti su Medium. Mi piace scrivere articoli dettagliati su AI e ML con un pizzico di sarcasmo, perché bisogna pur fare qualcosa per renderli un po’ meno noiosi. Ho pubblicato oltre 130 articoli e un corso su DataCamp, con un altro in arrivo. I miei contenuti sono stati visti da oltre 5 milioni di persone, 20.000 delle quali sono diventate follower sia su Medium che su LinkedIn.
Scopri i 15 migliori server MCP remoti che stanno trasformando lo sviluppo AI nel 2026. Scopri come migliorano automazione, ragionamento, sicurezza e velocità dei workflow.
Acquisisci le competenze più richieste per ingerire, pulire e gestire i dati in modo efficiente e per programmare e monitorare le pipeline, distinguendoti nel campo dell'ingegneria dei dati.
Che cos'è Snowflake Snowpark?
Il machine learning tradizionale prevede di spostare i dati dai database verso i luoghi in cui risiedono i modelli. Con il recente boom dell'AI e l'enorme dimensione dei dataset odierni, questo approccio sta diventando sempre più impraticabile.
Terabyte di dati devono essere trasferiti dal database alle applicazioni client per pulizia, analisi e training dei modelli. Questo apparente innocuo viaggio di andata e ritorno spreca risorse preziose. Per questo sempre più aziende scelgono tecnologie in-database per ridurre al minimo il movimento dei dati ed eseguire le operazioni in modo fluido.
Una delle migliori tecnologie in-database sul mercato è Snowpark, offerta da Snowflake Cloud. Snowpark è un insieme di librerie e runtime che ti permette di eseguire in modo sicuro linguaggi di programmazione in Snowflake Cloud per sviluppare pipeline di dati e modelli di machine learning nello stesso ambiente dei tuoi database Snowflake.
In questo tutorial vedremo i fondamenti di Snowpark e come usarlo nei tuoi progetti. Diamo per scontato che tu conosca già SQL e Snowflake: se hai bisogno di un ripasso, puoi seguire il nostro SQL Fundamental Skill Track o leggere questo tutorial su Snowflake per principianti.
Iniziamo!
Perché Snowflake Snowpark?
Snowflake Snowpark è un insieme di librerie e runtime che ti consente di usare in sicurezza linguaggi di programmazione come Python, Java e Scala per elaborare i dati direttamente all'interno della piattaforma cloud di Snowflake.
Questo elimina la necessità di spostare i dati fuori da Snowflake per l'elaborazione, migliorando efficienza e sicurezza. Ecco alcuni dei suoi principali vantaggi:
In poche parole, Snowpark è un modo potente ma semplice per gli sviluppatori di creare pipeline di dati, soluzioni di machine learning e applicazioni data-driven direttamente in Snowflake Cloud.
Primi passi con Snowpark
L'obiettivo finale di questo tutorial è costruire un modello con iperparametri ottimizzati, addestrato su una tabella di un database Snowflake usando Snowpark. Per riuscirci, inizieremo da:
Creare un ambiente virtuale
Per questo tutorial useremo un nuovo ambiente
conda:Nota a margine: se stai usando un ambiente
condaappena installato, dovrai eseguire$conda initprima di attivare l'ambientesnowpark.Dopo l'attivazione, dobbiamo installare le seguenti librerie:
Se userai Jupyter, installa anche
ipykerneled esegui il seguente comando per aggiungere l'ambiente che stiamo usando come kernel Jupyter:Ora importiamo alcune librerie generali che ci serviranno lungo il percorso:
Ingerire dati di esempio in Snowflake
Per questo tutorial useremo il dataset Diamonds di Seaborn: puoi scaricare il file CSV direttamente dal mio GitHub.
Una volta effettuato l'accesso all'app Snowflake, segui la GIF qui sotto per ingerire il dataset in una nuova tabella del database (crea un nuovo account se non ne hai già uno):
In pratica, raramente importerai file CSV come tabelle nei tuoi database Snowflake. Per lo più lavorerai con database esistenti, con diversi livelli di accesso concessi dagli amministratori dei database della tua azienda.
Creare una sessione Snowpark
Ora dobbiamo stabilire una connessione tra l'API di Snowpark e il cloud di Snowflake per interrogare il nostro database. Questa connessione richiede le seguenti credenziali di Snowflake: nome dell'account, username e password.
Nell'immagine qui sotto, ti mostro come recuperare il tuo username e il nome dell'account dalla dashboard di Snowflake:
Crea un file separato chiamato
config.pyche contiene un unico dizionario chiamatocredentialscon il seguente formato:Per motivi di sicurezza, salviamo le credenziali in un file separato. Aggiungendo questo file a
.gitignoreti assicuri che le credenziali di Snowflake non vengano divulgate per errore.Ora importiamo il dizionario
credentialse la classeSessiondi Snowpark:Per stabilire la connessione useremo il metodo
Session.builder.configs.create():Se il tuo username viene stampato, la tua prima sessione è stata creata con successo!
Caricare i dati ingeriti in una sessione
L'oggetto
new_sessionha accesso a tutto ciò che il tuo account possiede in Snowflake (e a ciò a cui hai il permesso di accedere).Il primo passo prima di importare i dati è dire alla sessione che stiamo usando il database
test_dbche abbiamo creato nella sezione precedente:Lo facciamo usando il metodo .sql, che consente di eseguire qualsiasi query compatibile con Snowflake SQL.
Ora possiamo caricare la tabella
diamondsditest_dbusando il metodo table dell'oggetto sessione:Il metodo
.show()è l'equivalente diDataFrame.describe()di Pandas e ci mostra che ci siamo collegati correttamente alla tabella.Esatto: ci siamo solo collegati alla tabella diamonds. L'oggetto
diamonds_dfnon contiene alcun dato, come dimostra la sua dimensione:Pesa solo 48 byte quando dovrebbe essere oltre 3 MB. Dedicando un po' di tempo in più capiremo perché succede.
Capire i DataFrame di Snowpark
Finora abbiamo coperto i seguenti passaggi:
Parliamo ora dei DataFrame di Snowpark!
I DataFrame di Snowpark sono lazy
I DataFrame di Pandas usano la tua RAM, quindi vivono sulla tua macchina. Al contrario, i DataFrame di Snowpark vivono all'interno della piattaforma cloud di Snowflake, anche se puoi vederne la rappresentazione nel tuo ambiente di sviluppo. I dati restano sul cloud e non devono essere scaricati in locale per eseguire operazioni.
Un altro aspetto importante dei DataFrame di Snowpark è che lavorano in modalità lazy. Significa che non eseguono alcuna operazione sui dati finché non glielo dici esplicitamente.
Invece, costruiscono una rappresentazione logica delle operazioni desiderate che viene poi tradotta in query SQL ottimizzate per l'esecuzione in Snowflake.
Per confronto, Pandas esegue le operazioni immediatamente, cioè in eager execution.
In termini di prestazioni, la valutazione lazy è sempre significativamente più veloce dell'esecuzione eager. Poiché i DataFrame lazy usano le potenti risorse di calcolo elastiche di Snowflake, possono spingere le operazioni a livello di database ed eseguirle molto più rapidamente.
Per capire meglio la differenza tra valutazione lazy ed esecuzione eager, immagina che i nostri dati in Snowflake siano una biblioteca gigantesca. Abbiamo i due scenari seguenti:
Quando usare i DataFrame di Snowpark
Dato che Snowpark può convertire in DataFrame Pandas, quando dovremmo usare l'uno o l'altro?
La risposta dipende in gran parte dalla dimensione del dataset.
Se il tuo dataset è piccolo (come Diamonds), puoi scaricarlo in locale e passarlo a Pandas senza problemi (che è ciò che fa il metodo
DataFrame.to_pandas()).Ma con i dataset di oggi, le cose possono sfuggire di mano rapidamente e potremmo dover aspettare ore per scaricare il database. E ricorda, è un biglietto di andata e ritorno: qualsiasi nuovo dato che vogliamo conservare deve anche essere rimandato su. È per questo che vale la pena imparare l'API dei DataFrame di Snowpark.
In alternativa, il metodo
Session.sql()ci consente di eseguire qualsiasi espressione SQL compatibile con Snowflake (vedi l'esempio sotto). Tuttavia, ti consiglio vivamente di padroneggiare l'API dei DataFrame di Snowpark perché contiene molte funzioni integrate per oltre 100 funzioni ed espressioni SQL.Funzioni di trasformazione dei DataFrame di Snowpark
Gran parte del tempo in Snowpark lo passerai usando le sue funzioni di trasformazione. Sono disponibili nel seguente sotto-modulo:
Tutte le funzioni sotto
F(che puoi elencare chiamandodir(F)) specificano come trasformare un DataFrame. Vediamo un esempio:Qui la funzione col crea un riferimento alla colonna indicata e restituisce un oggetto
Column. Poi.upper()converte in maiuscolo i valori della colonna CUT:Ma se guardiamo il dataset diamonds, vediamo che i valori nella colonna
CUThanno ancora lettere minuscole. Perché? Ebbene, l'espressioneF.upper(F.col("CUT"))è equivalente alla seguente query SQL:Cosa manca qui?
Ovviamente la clausola
FROM, che specifica il nome della tabella a cui applicare la trasformazione!Quindi dobbiamo combinare l'espressione
F.upper(F.col("CUT"))con l'oggettodiamonds_df. Ci sono tre modi principali per farlo:.select().filter().with_column()Dato che la nostra espressione trasforma una colonna, la passeremo a
.select():Abbiamo cambiato con successo i valori!
Scriviamo ora un'espressione che filtra le righe:
Scopriamo che nel nostro dataset ci sono oltre 5000 diamanti che costano più di 10.000 $. Proviamo anche a creare una colonna:
Sopra mostriamo che è possibile anche concatenare i metodi: abbiamo una nuova colonna chiamata “PRICE_SQUARED”. Le funzioni dei DataFrame Snowpark sono simili a quelle di Pandas.
In sintesi, se cerchi un'alternativa Snowpark a una funzione di Pandas, la troverai o sotto F o tra i metodi dei DataFrame di Snowpark. Puoi verificarlo chiamando
dir(F)odir(diamonds_df)o leggendo la reference di Snowpark Python.Eseguire EDA sui DataFrame di Snowpark
Una parte importante dell'exploratory data analysis (EDA) consiste nel creare visualizzazioni. Per fortuna, non ci serve Snowpark per questo perché possiamo continuare a usare il moderno stack dati.
L'idea è questa: poiché l'EDA serve a scoprire tendenze e insight generali, spesso possiamo usare un campione invece dell'intero dataset. Una volta scaricato un campione rappresentativo, possiamo convertirlo in un DataFrame Pandas e usare i fidati Matplotlib o Seaborn.
Iniziamo con la conversione:
Qui stiamo scaricando il 25% del dataset come DataFrame Pandas. Convertiamo i nomi delle colonne in minuscolo:
Ora puoi fare EDA come faresti con qualsiasi dataset. Qui sotto esploriamo alcune idee possibili e partiamo generando uno scatter plot per visualizzare la relazione tra prezzo e carato:
Ora tracciamo una matrice di correlazione per vedere la correlazione tra ogni coppia di feature numeriche:
Possiamo anche creare un grafico a barre delle categorie di taglio dei diamanti:
Per confermare che questi grafici saranno più o meno uguali sull'intero dataset, eseguiremo la versione SQL del grafico a barre qui sopra.
Per prima cosa, scriveremo un'espressione SQL per raggruppare il dataset diamonds per CUT:
Ora convertiamo e scarichiamo il risultato come DataFrame Pandas:
Questa volta useremo la funzione
plt.bar()per creare il grafico:L'ordine delle barre è diverso ma, affiancandoli, si vede che trasmettono le stesse informazioni.
Addestrare un modello di Machine Learning in Snowpark
Siamo pronti per imparare come addestrare modelli di machine learning in Snowpark!
Inizieremo pulendo il dataset.
Pulire i dati in Snowpark
Per prima cosa assicuriamoci che tutte le colonne abbiano il tipo di dato corretto:
La colonna
tableha un nome strano, quindi la convertiremo in maiuscoloTABLE_(con un underscore finale per evitare conflitti con una parola chiave SQL):Dovremo cambiare il tipo di dato delle feature numeriche da
DecimalTypeaDoubleTypeperché i decimali non sono ancora supportati in Snowpark.Nel frammento sopra usiamo di nuovo il metodo
.with_column(). Un altro metodo nuovo è.cast(), che fa parte dei metodi dei DataFrame di Snowpark.Snowpark richiede anche che tutte le feature testuali siano in maiuscolo e senza spazi tra le parole prima di codificarle. Al momento i valori della feature
CUTviolano questo requisito, quindi lo sistemeremo con trasformazioni di funzione:I nostri dati ora sono privi di problemi di pulizia. Possiamo salvarli di nuovo come nuova tabella su Snowflake:
Assicurati di aggiungere la modalità
overwriteperché potresti dover tornare indietro, modificare alcune operazioni di pulizia e salvare di nuovo.Preparare i dati per il modeling in Snowpark
In questa sezione affronteremo gli ultimi problemi di pre-processing che potrebbero impedire l'addestramento dei modelli. Carichiamo la tabella pulita della sezione precedente:
Ottimo!
Successivamente importeremo i sottomoduli
preprocessingepipelinedallo spazio dei nomisnowflake.ml.Mentre l'API dei DataFrame di Snowpark è disponibile sotto
snowflake.snowpark, i moduli di Snowpark ML sono presenti insnowflake.ml. All'inizio può confondere, prenditi il tempo per abituarti.Nel codice seguente:
Ora siamo pronti a costruire una pipeline simile a una pipeline di Scikit-learn:
La classe
Pipelineaccetta un elenco di step, ciascuno una classe di pre-processing. Qui usiamoOrdinalEncoderper codificare le categoriche come 0, 1, 3, ecc. eStandardScalerper normalizzare le feature numeriche.Infine, salveremo la pipeline in locale con
joblibe la testeremo sull'intero dataset:Lo snippet gira senza errori, quindi la nostra pipeline funziona, segnale che possiamo finalmente addestrare un modello.
Addestrare un modello XGBoost in Snowpark
Per addestrare un modello, elencheremo di nuovo i nomi delle feature e del target:
Ora suddivideremo i dati usando
DataFrame.random_split()e forniremo i pesi per rappresentare la frazione di training e test:Quindi caricheremo la pipeline e applicheremo fit-transform sia al train che al test.
Sopra, assicurati di chiamare solo
.transform()sul test set per evitare leakage.Successivamente inizializziamo un modello di regressione XGBoost dal
sotto-modulo ml.modeling.xgboost:La classe
XGBRegressorrichiede tutti i nomi di input, tutti i nomi del target e i nomi delle colonne di output. Una volta forniti, chiamiamo.fit()per avviare il training:L'addestramento potrebbe essere lento se hai un account Snowflake gratuito con risorse di calcolo limitate e senza GPU.
Una volta terminato il training, possiamo generare le previsioni:
# Predict
Diamo un'occhiata alle previsioni:
Ora dobbiamo misurare quanto bene si è comportato il nostro modello iniziale. Snowpark include dozzine di metriche di Scikit-learn nel suo sottomodulo
ml.modeling.metrics, che importiamo comeM:Quindi eseguiamo due volte
mean_squared_errorper misurare la root mean squared error (RMSE) sia su training che su test (sotto,squared=Falserestituisce l'RMSE invece dell'MSE):In media il nostro modello sbaglia di 542 $ e potrebbe anche essere un po' in overfitting perché la differenza tra gli RMSE di training e test è grande.
Ottimizziamo gli iperparametri del modello per affrontare questi problemi.
Tuning degli iperparametri in Snowpark
Attualmente Snowpark offre due classi per il tuning degli iperparametri:
GridSearchCV: ricerca esaustiva di tutte le combinazioni di iperparametri con cross-validation.RandomizedSearchCV: ricerca casuale su distribuzioni di iperparametri con cross-validation.XGBoost ha circa una dozzina di iperparametri che possono migliorarne le prestazioni (puoi saperne di più in questo tutorial su come usare XGBoost in Python). Questo ci orienta verso una ricerca randomizzata. Personalmente preferirei usare Optuna, che usa la ricerca bayesiana, ma al momento non abbiamo ancora questa possibilità in Snowpark.
Definiamo ora la ricerca:
Fissiamo il numero di stimatori a 2000 e ottimizziamo solo i parametri
max_depthelearning_rate.rscvha un parametro predefiniton_iter=10, il che significa che la ricerca verrà eseguita 10 volte, scegliendo ogni volta una combinazione casuale di parametri. Per risultati più accurati, è meglio scegliere un valore più alto per questo parametro.Ora misuriamo le prestazioni del miglior modello trovato. Il codice è lo stesso di prima ma invece di
regressoruseremo l'oggettorscv:L'RMSE di training è sceso ma quello di test è persino più alto. Questo indica che siamo ancora in overfitting e dobbiamo ampliare la ricerca includendo altri parametri per potare gli alberi decisionali che XGBoost usa sotto il cofano.
Questa parte la lascio a te.
Salvare il modello migliore in Snowpark
Se chiudiamo la sessione ora, perderemo il modello ottimizzato. Per salvarlo useremo il model registry nativo di Snowpark, uno storage virtuale che puoi usare per salvare qualsiasi modello e i suoi metadati.
Il registry è disponibile come classe
Registrye richiede i nomi del database e dello schema della sessione corrente. Richiede anche di assegnare un nome al progetto per evitare conflitti con modelli di altri progetti:Useremo il metodo
Registry.log_model()per salvare i nostri modelli:Possiamo registrare una metrica per il modello con il metodo
.set_metric()(possiamo registrare quante metriche vogliamo). Aggiungeremo anche un commento per descrivere il modello:Facciamo lo stesso per il miglior modello trovato con la ricerca random. Quando registri la metrica, non dimenticare di cambiare il valore in
optimal_rmse_test.Per confermare che i modelli siano salvati, puoi chiamare
.show_models():Per saperne di più su come gestire il registry consulta questa pagina della documentazione per sviluppatori di Snowpark.
Eseguire inferenza in Snowpark
L'inferenza di solito si fa scegliendo il miglior modello dal tuo registry. Possiamo farlo filtrando il risultato di
.show_models()o recuperando direttamente il modello con il suo tag di versione, come facciamo sotto:Il metodo
get_model()restituisce un oggettomodelgenerico, diverso daXGBRegressor. Per questo devi chiamare.run()specificando il nome della funzione per eseguire l'inferenza.Conclusione
In questo tutorial abbiamo coperto un framework end-to-end per addestrare modelli di machine learning in Snowflake Snowpark. Ottimo lavoro!
Siamo partiti da un dataset grezzo e non pulito e siamo arrivati a un modello di regressione XGBoost ottimizzato. Abbiamo eseguito tutte le operazioni su Snowflake Cloud, quindi non abbiamo dovuto usare risorse del sistema.
Abbiamo visto quanto siano efficaci le operazioni in-database quando abbiamo dataset di grandi dimensioni, e che Snowflake Snowpark è uno dei migliori strumenti sul mercato per facilitare questo processo.
Se vuoi saperne di più su Snowpark o Snowflake, dai un'occhiata a queste risorse:
Grazie per la lettura!