1. Panoramica
Questo lab ti guiderà attraverso vari strumenti in AI Platform Notebooks per esplorare i dati e prototipare modelli ML.
Cosa imparerai
Al termine del corso sarai in grado di:
- Crea e personalizza un'istanza di AI Platform Notebooks
- Tieni traccia del codice dei tuoi blocchi note con Git, integrato direttamente in AI Platform Notebooks
- Utilizzare lo strumento What-If all'interno del notebook
Il costo totale per eseguire questo lab su Google Cloud è di circa 1$. Puoi trovare i dettagli completi sui prezzi di AI Platform Notebooks qui.
2. Crea un'istanza di AI Platform Notebooks
Per eseguire questo codelab, devi avere un progetto Google Cloud Platform con la fatturazione abilitata. Per creare un progetto, segui le istruzioni riportate qui.
Passaggio 2: abilita l'API Compute Engine
Vai a Compute Engine e seleziona Abilita se non è già abilitato. Ne avrai bisogno per creare la tua istanza di blocco note.
Passaggio 3: crea un'istanza di Notebooks
Vai alla sezione AI Platform Notebooks della tua console Cloud e fai clic su Nuova istanza. Poi seleziona il tipo di istanza TensorFlow 2 Enterprise più recente senza GPU:
Assegna un nome all'istanza o utilizza quello predefinito. Poi esamineremo le opzioni di personalizzazione. Fai clic sul pulsante Personalizza:
AI Platform Notebooks offre molte opzioni di personalizzazione diverse, tra cui la regione in cui viene implementata l'istanza, il tipo di immagine, le dimensioni della macchina, il numero di GPU e altro ancora. Utilizzeremo i valori predefiniti per la regione e l'ambiente. Per la configurazione della macchina, utilizzeremo una macchina n1-standard-8:
Non aggiungeremo GPU e utilizzeremo i valori predefiniti per disco di avvio, networking e autorizzazione. Seleziona Crea per creare l'istanza. Il completamento dell'operazione richiede alcuni minuti.
Una volta creata l'istanza, vedrai un segno di spunta verde accanto nella UI di Notebook. Seleziona Apri JupyterLab per aprire l'istanza e iniziare la prototipizzazione:
Quando apri l'istanza, crea una nuova directory chiamata codelab. Questa è la directory da cui lavoreremo durante questo lab:
Fai clic sulla directory codelab appena creata facendo doppio clic e poi seleziona il notebook Python 3 dal launcher:
Rinomina il notebook in demo.ipynb o nel nome che preferisci.
Passaggio 4: importa i pacchetti Python
Crea una nuova cella nel notebook e importa le librerie che utilizzeremo in questo codelab:
import pandas as pd
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
import numpy as np
import json
from sklearn.model_selection import train_test_split
from sklearn.utils import shuffle
from google.cloud import bigquery
from witwidget.notebook.visualization import WitWidget, WitConfigBuilder
3. Collega i dati BigQuery al notebook
BigQuery, il data warehouse di big data di Google Cloud, ha reso disponibili pubblicamente molti set di dati per la tua esplorazione. AI Platform Notebooks supporta l'integrazione diretta con BigQuery senza richiedere l'autenticazione.
Per questo lab, utilizzeremo il set di dati sulla natalità. Contiene dati su quasi tutte le nascite negli Stati Uniti in un periodo di tempo di 40 anni, tra cui il peso alla nascita del bambino e informazioni demografiche sui genitori. Utilizzeremo un sottoinsieme delle funzionalità per prevedere il peso di un bambino alla nascita.
Passaggio 1: scarica i dati BigQuery nel nostro blocco note
Utilizzeremo la libreria client Python per BigQuery per scaricare i dati in un DataFrame Pandas. Il set di dati originale è di 21 GB e contiene 123 milioni di righe. Per semplicità,utilizzeremo solo 10.000 righe del set di dati.
Costruisci la query e visualizza l'anteprima del DataFrame risultante con il seguente codice. Qui otteniamo 4 funzionalità dal set di dati originale, insieme al peso del bambino (ciò che il nostro modello prevede). Il set di dati risale a molti anni fa, ma per questo modello utilizzeremo solo i dati successivi al 2000:
query="""
SELECT
weight_pounds,
is_male,
mother_age,
plurality,
gestation_weeks
FROM
publicdata.samples.natality
WHERE year > 2000
LIMIT 10000
"""
df = bigquery.Client().query(query).to_dataframe()
df.head()
Per ottenere un riepilogo delle funzionalità numeriche nel nostro set di dati, esegui:
df.describe()
Mostra la media, la deviazione standard, il minimo e altre metriche per le nostre colonne numeriche. Infine, otteniamo alcuni dati sulla colonna booleana che indica il sesso del bambino. Possiamo farlo con il metodo value_counts di Pandas:
df['is_male'].value_counts()
Sembra che il set di dati sia quasi bilanciato al 50/50 per genere.
Passaggio 2: prepara il set di dati per l'addestramento
Ora che abbiamo scaricato il set di dati nel nostro notebook come DataFrame Pandas, possiamo eseguire alcuni pretrattamenti e suddividerlo in set di addestramento e test.
Per prima cosa, eliminiamo le righe con valori nulli dal set di dati e mescoliamo i dati:
df = df.dropna()
df = shuffle(df, random_state=2)
Successivamente, estrai la colonna delle etichette in una variabile separata e crea un DataFrame con solo le nostre funzionalità. Poiché is_male è un valore booleano, lo convertiremo in un numero intero in modo che tutti gli input del nostro modello siano numerici:
labels = df['weight_pounds']
data = df.drop(columns=['weight_pounds'])
data['is_male'] = data['is_male'].astype(int)
Ora, se visualizzi l'anteprima del nostro set di dati eseguendo data.head(), dovresti vedere le quattro funzionalità che utilizzeremo per l'addestramento.
4. Inizializza Git
AI Platform Notebooks è integrato direttamente con Git, in modo da poter controllare la versione direttamente nell'ambiente del notebook. In questo modo è possibile eseguire il commit del codice direttamente nell'interfaccia utente del notebook o tramite il terminale disponibile in JupyterLab. In questa sezione inizializzeremo un repository Git nel nostro notebook ed eseguiremo il primo commit tramite la UI.
Passaggio 1: inizializza un repository Git
Dalla directory del codelab, seleziona Git e poi Init dalla barra dei menu in alto in JupyterLab:
Quando ti viene chiesto se vuoi che questa directory diventi un repository Git, seleziona Sì. Quindi, seleziona l'icona di Git nella barra laterale sinistra per visualizzare lo stato dei file e dei commit:
Passaggio 2: esegui il primo commit
In questa UI puoi aggiungere file a un commit, visualizzare le differenze tra i file (ne parleremo più avanti) ed eseguire il commit delle modifiche. Iniziamo eseguendo il commit del file del notebook appena aggiunto.
Seleziona la casella accanto al file del notebook demo.ipynb per prepararlo per il commit (puoi ignorare la directory .ipynb_checkpoints/). Inserisci un messaggio di commit nella casella di testo e poi fai clic sul segno di spunta per eseguire il commit delle modifiche:
Inserisci il tuo nome e il tuo indirizzo email quando richiesto. Quindi, torna alla scheda Cronologia per visualizzare il tuo primo commit:
Tieni presente che gli screenshot potrebbero non corrispondere esattamente alla tua UI a causa degli aggiornamenti successivi alla pubblicazione di questo lab.
5. Crea e addestra un modello TensorFlow
Utilizzeremo il set di dati BigQuery sulla natalità che abbiamo scaricato nel nostro notebook per creare un modello che preveda il peso del bambino. In questo lab ci concentreremo sugli strumenti del notebook, anziché sull'accuratezza del modello stesso.
Passaggio 1: dividi i dati in set di addestramento e test
Utilizzeremo l'utilità train_test_split di Scikit Learn per dividere i dati prima di creare il modello:
x,y = data,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
Ora è tutto pronto per creare il modello TensorFlow.
Passaggio 2: crea e addestra il modello TensorFlow
Creeremo questo modello utilizzando l'API del modello tf.keras Sequential, che ci consente di definire il modello come uno stack di livelli. Tutto il codice necessario per creare il modello è qui:
model = Sequential([
Dense(64, activation='relu', input_shape=(len(x_train.iloc[0]),)),
Dense(32, activation='relu'),
Dense(1)]
)
Poi compileremo il modello per poterlo addestrare. Qui sceglieremo l'ottimizzatore, la funzione di perdita e le metriche del modello che vogliamo che il modello registri durante l'addestramento. Poiché si tratta di un modello di regressione (che prevede un valore numerico), utilizziamo l'errore quadratico medio anziché l'accuratezza come metrica:
model.compile(optimizer=tf.keras.optimizers.RMSprop(),
loss=tf.keras.losses.MeanSquaredError(),
metrics=['mae', 'mse'])
Puoi utilizzare la pratica funzione model.summary() di Keras per visualizzare la forma e il numero di parametri addestrabili del modello in ogni livello.
Ora è tutto pronto per addestrare il modello. Tutto ciò che dobbiamo fare è chiamare il metodo fit(), passando i dati di addestramento e le etichette. Qui utilizzeremo il parametro facoltativo validation_split, che conterrà una parte dei dati di addestramento per convalidare il modello a ogni passaggio. Idealmente, vuoi che la perdita di addestramento e di convalida diminuiscano. Tuttavia, ricorda che in questo esempio ci concentriamo maggiormente sugli strumenti per modelli e blocchi note piuttosto che sulla qualità del modello:
model.fit(x_train, y_train, epochs=10, validation_split=0.1)
Passaggio 3: genera previsioni sugli esempi di test
Per vedere il rendimento del nostro modello, generiamo alcune previsioni di test sui primi 10 esempi del nostro set di dati di test.
num_examples = 10
predictions = model.predict(x_test[:num_examples])
Poi itereremo le previsioni del modello, confrontandole con il valore effettivo:
for i in range(num_examples):
print('Predicted val: ', predictions[i][0])
print('Actual val: ',y_test.iloc[i])
print()
Passaggio 4: utilizza git diff e esegui il commit delle modifiche
Ora che hai apportato alcune modifiche al notebook, puoi provare la funzionalità git diff disponibile nella UI git di Notebook. Il blocco note demo.ipynb dovrebbe ora trovarsi nella sezione "Modificati" dell'interfaccia utente. Passa il mouse sopra il nome del file e fai clic sull'icona di diff:
Dovresti visualizzare una differenza delle modifiche, come la seguente:
Questa volta eseguiremo il commit delle modifiche tramite la riga di comando utilizzando Terminale. Nel menu Git nella barra dei menu in alto di JupyterLab, seleziona Comando Git nel terminale. Se la scheda Git della barra laterale sinistra è aperta mentre esegui i comandi riportati di seguito, potrai vedere le modifiche riflesse nella UI di Git.
Nella nuova istanza del terminale, esegui il comando seguente per preparare il file del notebook per il commit:
git add demo.ipynb
Quindi, esegui il comando seguente per eseguire il commit delle modifiche (puoi utilizzare il messaggio di commit che preferisci):
git commit -m "Build and train TF model"
Dovresti visualizzare l'ultimo commit nella cronologia:
6. Utilizzare lo strumento What-If direttamente dal notebook
Lo strumento What-If è un'interfaccia visiva interattiva progettata per aiutarti a visualizzare i tuoi set di dati e a comprendere meglio l'output dei tuoi modelli ML. Si tratta di uno strumento open source creato dal team PAIR di Google. Sebbene funzioni con qualsiasi tipo di modello, ha alcune funzionalità create esclusivamente per Cloud AI Platform.
Lo strumento What-if è preinstallato nelle istanze di Cloud AI Platform Notebooks con TensorFlow. Qui lo utilizzeremo per vedere il rendimento complessivo del modello e per esaminare il suo comportamento sui punti dati del test set.
Passaggio 1: prepara i dati per lo strumento What-If
Per sfruttare al meglio lo strumento What-If, invieremo esempi del nostro test set insieme alle etichette basate su dati di fatto per questi esempi (y_test). In questo modo possiamo confrontare la previsione del nostro modello con i dati di fatto. Esegui la riga di codice riportata di seguito per creare un nuovo DataFrame con i nostri esempi di test e le relative etichette:
wit_data = pd.concat([x_test, y_test], axis=1)
In questo lab, collegheremo lo strumento What-If al modello che abbiamo appena addestrato nel nostro notebook. Per farlo, dobbiamo scrivere una funzione che lo strumento utilizzerà per eseguire questi punti dati di test sul nostro modello:
def custom_predict(examples_to_infer):
preds = model.predict(examples_to_infer)
return preds
Passaggio 2: crea un'istanza dello strumento What-If
Creeremo un'istanza dello strumento What-If Tool passandogli 500 esempi dal set di dati di test concatenato e dalle etichette di verità di base che abbiamo appena creato. Creiamo un'istanza di WitConfigBuilder per configurare lo strumento, trasmettendo i nostri dati, la funzione di previsione personalizzata che abbiamo definito sopra, insieme al nostro target (ciò che stiamo prevedendo) e al tipo di modello:
config_builder = (WitConfigBuilder(wit_data[:500].values.tolist(), data.columns.tolist() + ['weight_pounds'])
.set_custom_predict_fn(custom_predict)
.set_target_feature('weight_pounds')
.set_model_type('regression'))
WitWidget(config_builder, height=800)
Quando viene caricato lo strumento What-If, dovresti vedere una schermata simile a questa:
Sull'asse x, puoi vedere i punti dati di test distribuiti in base al valore del peso previsto del modello, weight_pounds.
Passaggio 3: esplora il comportamento del modello con lo strumento What-If
Con lo strumento What-If puoi fare molte cose interessanti. Ne esploreremo solo alcuni. Innanzitutto, diamo un'occhiata all'editor dei punti dati. Puoi selezionare qualsiasi punto dati per visualizzarne le caratteristiche e modificare i valori delle caratteristiche. Inizia facendo clic su un punto dati:
A sinistra vedrai i valori delle funzionalità per il punto dati selezionato. Puoi anche confrontare l'etichetta basata su dati di fatto di questo punto dati con il valore previsto dal modello. Nella barra laterale sinistra, puoi anche modificare i valori delle caratteristiche ed eseguire nuovamente la previsione del modello per vedere l'effetto di questa modifica sul modello. Ad esempio, possiamo modificare gestation_weeks in 30 per questo punto dati facendo doppio clic e ripetendo la previsione:
Utilizzando i menu a discesa nella sezione del grafico dello strumento What-If, puoi creare tutti i tipi di visualizzazioni personalizzate. Ad esempio, ecco un grafico con il peso previsto dei modelli sull'asse x, l'età della madre sull'asse y e i punti colorati in base all'errore di inferenza (più scuro significa una differenza maggiore tra il peso previsto e quello effettivo). Qui sembra che, man mano che il peso diminuisce, l'errore del modello aumenti leggermente:
Quindi, seleziona il pulsante Grafici di dipendenza parziale a sinistra. Mostra in che modo ogni caratteristica influenza la previsione del modello. Ad esempio, all'aumentare del tempo di gestazione, aumenta anche il peso del bambino previsto dal nostro modello:
Per altre idee di esplorazione con lo strumento What-If, consulta i link all'inizio di questa sezione.
7. (Facoltativo) Connetti il repository Git locale a GitHub
Infine, impareremo a connettere il repository Git nell'istanza del notebook a un repository nel nostro account GitHub. Se vuoi eseguire questo passaggio, devi disporre di un account GitHub.
Passaggio 1: crea un nuovo repository su GitHub
Nel tuo account GitHub, crea un nuovo repository. Assegna un nome e una descrizione, decidi se vuoi che sia pubblico e seleziona Crea repository (non è necessario inizializzare con un file README). Nella pagina successiva, segui le istruzioni per il push di un repository esistente dalla riga di comando.
Apri una finestra del terminale e aggiungi il nuovo repository come repository remoto. Sostituisci username nell'URL del repository riportato di seguito con il tuo nome utente GitHub e your-repo con il nome di quello che hai appena creato:
git remote add origin git@github.com:username/your-repo.git
Passaggio 2: esegui l'autenticazione su GitHub nell'istanza di notebook
Successivamente, dovrai autenticarti su GitHub dall'istanza del notebook. Questa procedura varia a seconda che tu abbia attivato l'autenticazione a due fattori su GitHub.
Se non sai da dove iniziare, segui i passaggi della documentazione di GitHub per creare una chiave SSH e poi aggiungere la nuova chiave a GitHub.
Passaggio 3: assicurati di aver collegato correttamente il repository GitHub
Per assicurarti di aver configurato correttamente le impostazioni, esegui git remote -v nel terminale. Dovresti vedere il nuovo repository elencato come remoto. Una volta visualizzato l'URL del repository GitHub e autenticato l'accesso a GitHub dal notebook, puoi eseguire il push direttamente su GitHub dall'istanza del notebook.
Per sincronizzare il repository Git del notebook locale con il repository GitHub appena creato, fai clic sul pulsante di caricamento sul cloud nella parte superiore della barra laterale di Git:
Aggiorna il repository GitHub e dovresti visualizzare il codice del notebook con i commit precedenti. Se altre persone hanno accesso al tuo repository GitHub e vuoi scaricare le ultime modifiche al tuo notebook, fai clic sull'icona di download dal cloud per sincronizzare le modifiche.
Nella scheda Cronologia dell'interfaccia utente Git di Notebook, puoi vedere se i commit locali sono sincronizzati con GitHub. In questo esempio, origin/master corrisponde al nostro repository su GitHub:
Ogni volta che esegui nuovi commit, fai di nuovo clic sul pulsante di caricamento sul cloud per eseguire il push delle modifiche nel repository GitHub.
8. Complimenti!
Hai fatto molto in questo lab 👏👏👏
Ricapitolando, hai imparato a:
- Crea e personalizza un'istanza di AI Platform Notebook
- Inizializza un repository Git locale in questa istanza, aggiungi commit tramite l'interfaccia utente o la riga di comando di Git, visualizza le differenze di Git nell'interfaccia utente di Git di Notebook
- Crea e addestra un semplice modello TensorFlow 2
- Utilizzare lo strumento What-If all'interno dell'istanza notebook
- Connetti il repository Git del notebook a un repository esterno su GitHub
9. Esegui la pulizia
Se vuoi continuare a utilizzare questo notebook, ti consigliamo di disattivarlo quando non lo usi. Dall'interfaccia utente di Notebooks nella console Cloud, seleziona il notebook, quindi seleziona Interrompi:
Se vuoi eliminare tutte le risorse che hai creato in questo lab, elimina semplicemente l'istanza del notebook anziché arrestarla.
Utilizzando il menu di navigazione della console Cloud, vai a Storage ed elimina entrambi i bucket creati per archiviare gli asset del modello.