Vai al contenuto principale

Snowflake Snowpark: un'introduzione completa

Fai i primi passi per padroneggiare il machine learning in-database con Snowflake Snowpark.
· 15 min leggi

Scopri con l'IA

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:

  • 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:

  1. Creazione di un ambiente virtuale con le librerie rilevanti.
  2. Ingestione di dati di esempio in Snowflake.
  3. Creazione di una sessione Snowpark per connettersi a Snowflake.
  4. Caricamento dei dati ingeriti nella sessione.

Creare un ambiente virtuale

Per questo tutorial useremo un nuovo ambiente conda:

$ conda create -n snowpark python==3.10 -y
$ conda activate snowpark

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 seaborn

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=snowpark

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

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):

snowflake_dashboard.gif

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:

image.png

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
   },
)

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 Session

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()
'"bexgboost"'

Se il tuo username viene stampato, la tua prima sessione è stata creata con successo!

Caricare i dati ingeriti in una sessione

L'oggetto new_session ha 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_db che abbiamo creato nella sezione precedente:

new_session.sql("USE DATABASE test_db;").collect()
[Row(status='Statement executed successfully.')]

Lo facciamo usando il metodo .sql, che consente di eseguire qualsiasi query compatibile con Snowflake SQL.

Ora possiamo caricare la tabella diamonds di test_db usando il metodo table dell'oggetto sessione:

diamonds_df = new_session.table("diamonds")
diamonds_df.show(5)

Le prime cinque righe del dataset diamonds stampate dai dataframe Snowpark.

Il metodo .show() è l'equivalente di DataFrame.describe() di Pandas e ci mostra che ci siamo collegati correttamente alla tabella.

Esatto: ci siamo solo collegati alla tabella diamonds. L'oggetto diamonds_df non contiene alcun dato, come dimostra la sua dimensione:

import sys
sys.getsizeof(diamonds_df)
48

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:

  1. Creato un ambiente virtuale con le librerie rilevanti.
  2. Ingerito dati di esempio in Snowflake.
  3. 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()

Screenshot 2024-05-03 at 14.18.05.png

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)
snowflake.snowpark.dataframe.DataFrame
result.show()

Il risultato di un'espressione SQL in Snowpark

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:

# The convention is to import it as F
import snowflake.snowpark.functions as F

Tutte le funzioni sotto F (che puoi elencare chiamando dir(F)) specificano come trasformare un DataFrame. Vediamo un esempio:

F.upper(F.col("CUT"))

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:

diamonds_df.show(5)

Le prime cinque righe del dataset diamonds dopo una trasformazione Snowpark non riuscita.

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:

SELECT UPPER(CUT);

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'oggetto diamonds_df. Ci sono tre modi principali per farlo:

  • Per espressioni che trasformano o selezionano colonne, passale dentro .select()
  • Per espressioni che selezionano righe, passale dentro .filter()
  • Per espressioni che creano colonne, passale dentro .with_column()

Dato che la nostra espressione trasforma una colonna, la passeremo a .select():

our_expression = F.upper(F.col("CUT"))
diamonds_df.select(our_expression).show()

Le prime cinque righe del dataset diamonds dopo una trasformazione Snowpark non riuscita.

Abbiamo cambiato con successo i valori!

Scriviamo ora un'espressione che filtra le righe:

diamonds_df.filter(F.col("PRICE") > 10000).count()
5222

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

Il risultato di una trasformazione Snowpark che usa la funzione `.with_column`

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()

Screenshot 2024-05-03 at 14.19.58.png

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.columns
Index(['carat', 'cut', 'color', 'clarity', 'depth', 'table', 'price', 'x', 'y', 'z'], dtype='object')

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()

Uno scatterplot di diamanti vs carati

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()

Una heatmap della matrice di correlazione del dataset diamonds

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()

Un countplot dei tagli 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:

result = new_session.sql(
   """
   SELECT cut, COUNT(*) AS count
     FROM diamonds
    GROUP BY cut;
"""
)

Ora convertiamo e scarichiamo il risultato come DataFrame Pandas:

result_pd = result.to_pandas()
result_pd

Parte di un dataset sui diamanti

Questa volta useremo la funzione plt.bar() per creare il grafico:

plt.bar(x=result_pd["CUT"], height=result_pd["COUNT"])
plt.show()

Di nuovo un countplot dei tagli dei diamanti

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:

list(diamonds_df.schema)
[StructField('CARAT', DecimalType(38, 2), nullable=True),
StructField('CUT', StringType(16777216), nullable=True),
StructField('COLOR', StringType(16777216), nullable=True),
StructField('CLARITY', StringType(16777216), nullable=True),
StructField('DEPTH', DecimalType(38, 1), nullable=True),
StructField('"table"', DecimalType(38, 1), nullable=True),
StructField('PRICE', LongType(), nullable=True),
StructField('X', DecimalType(38, 2), nullable=True),
StructField('Y', DecimalType(38, 2), nullable=True),
StructField('Z', DecimalType(38, 2), nullable=True)]

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.columns
['CARAT', 'CUT', 'COLOR', 'CLARITY', 'DEPTH', 'TABLE_', 'PRICE', 'X', 'Y', 'Z']

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))
[Column("CARAT"),
Column("X"),
Column("Y"),
Column("Z"),
Column("DEPTH"),
Column("TABLE_")]

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

def remove_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)

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

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()

Le prime cinque righe del dataset diamonds ripulito

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 Pipeline

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"]),
}

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
           ),
       ),
   ]
)

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 output

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 snowpark

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)

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)

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 too
from snowflake.ml.modeling.xgboost import XGBRegressor

# Initialize
regressor = XGBRegressor(
   input_cols=cat_cols_encoded + numeric_features,
   label_cols=label_cols,
   output_cols=output_cols,
)

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)

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)

Diamo un'occhiata alle previsioni:

train_preds.select("PRICE", "PRICE_PREDICTED").show(5)

Previsioni generate da XGBoost in Snowpark

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 M

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}")
Train RMSE score for XGBRegressor: 371.9664
Test RMSE score for XGBRegressor: 542.1566

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:

from snowflake.ml.modeling.model_selection import RandomizedSearchCV

rscv = RandomizedSearchCV(
   estimator=XGBRegressor(),
   param_distributions={
       "n_estimators": [2000],
       "max_depth": list(range(3, 13)),
       "learning_rate": np.linspace(0.1, 0.5, num=10),
   },
   n_jobs=-1,
   scoring="neg_mean_squared_error",
   input_cols=numeric_features + cat_cols_encoded,
   label_cols=label_cols,
   output_cols=output_cols,
   n_iter=10,
)

rscv.fit(train_df_transformed)

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:

# Predict
train_preds = rscv.predict(train_df_transformed)
test_preds = rscv.predict(test_df_transformed)
rmse_train = M.mean_squared_error(
   df=train_preds,
   y_true_col_names=label_cols,
   y_pred_col_names=output_cols,
   squared=False,
)

optimal_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 optimal model: {rmse_train:.4f}")
print(f"Test RMSE score for optimal model: {rmse_test:.4f}")
Train RMSE score for optimal model: 224.2405
Test RMSE score for optimal model: 572.0517

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 Registry
from 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)

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,
)

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"

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"

Per confermare che i modelli siano salvati, puoi chiamare .show_models():

# Confirm the models are added
registry.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:

# 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.columns

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:

Grazie per la lettura!

Bexruz (Bex) Tuychiev

Autore

Bexruz (Bex) Tuychiev

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. 

Argomenti

Correlato