1. Panoramica
In questo lab scoprirai vari strumenti di AI Platform Notebooks per esplorare i tuoi dati e prototipare i modelli ML.
Cosa imparerai
Imparerai a:
- Crea e personalizza un'istanza di AI Platform Notebooks
- Monitora il codice dei tuoi blocchi note con Git, integrato direttamente in AI Platform Notebooks
- Usa lo strumento What-If nel tuo blocco note
Il costo totale per l'esecuzione di questo lab su Google Cloud è di circa $1. I dettagli completi sui prezzi di AI Platform Notebooks sono disponibili qui.
2. Crea un'istanza di AI Platform Notebooks
Per eseguire questo codelab, è necessario un progetto Google Cloud con fatturazione abilitata. Per creare un progetto, segui le istruzioni riportate qui.
Passaggio 2: abilita l'API Compute Engine
Passa 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 blocco note
Vai alla sezione AI Platform Notebooks della console Cloud e fai clic su Nuova istanza. Quindi seleziona il tipo di istanza TensorFlow 2 Enterprise più recente senza GPU:
Assegna un nome all'istanza o utilizza quello predefinito. Successivamente, esploreremo le opzioni di personalizzazione. Fai clic sul pulsante Personalizza:
AI Platform Notebooks offre molte diverse opzioni di personalizzazione, tra cui la regione in cui viene eseguito il deployment dell'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 autorizzazioni. Seleziona Crea per creare la tua istanza. Il completamento dell'operazione richiede alcuni minuti.
Una volta creata l'istanza, vedrai un segno di spunta verde accanto nell'interfaccia utente di Notebooks. Seleziona Apri JupyterLab per aprire l'istanza e iniziare la prototipazione:
Quando apri l'istanza, crea una nuova directory chiamata codelab. Questa è la directory da cui lavoreremo nel corso del lab:
Fai clic sulla directory codelab appena creata, quindi fai doppio clic sulla directory, quindi seleziona il blocco note Python 3 da Avvio app:
Rinomina il blocco note in demo.ipynb o con il nome che preferisci.
Passaggio 4: importa i pacchetti Python
Crea una nuova cella nel blocco note 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. connetti i dati BigQuery al tuo blocco note
BigQuery, il big data warehouse di Google Cloud, ha reso disponibili al pubblico molti set di dati per le tue esplorazioni. 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 40 anni, tra cui il peso alla nascita del bambino e le informazioni demografiche sui genitori del neonato. Utilizzeremo un sottoinsieme di queste caratteristiche per prevedere il peso di un neonato alla nascita.
Passaggio 1: scarica i dati di BigQuery nel 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 semplificare le cose,utilizzeremo solo 10.000 righe del set di dati.
Crea la query e visualizza l'anteprima del DataFrame risultante con il codice seguente. Qui otteniamo 4 caratteristiche dal set di dati originale, insieme al peso del neonato (quello previsto dal nostro modello). Il set di dati risale a molti anni fa, ma per questo modello utilizzeremo solo 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 caratteristiche numeriche nel nostro set di dati, esegui:
df.describe()
Mostra la media, la deviazione standard, il minimo e altre metriche per le colonne numeriche. Infine, prendiamo in considerazione alcuni dati sulla colonna booleana che indica il genere del neonato. Possiamo farlo con il metodo value_counts di Pandas:
df['is_male'].value_counts()
Sembra che il set di dati sia quasi bilanciato 50/50 per genere.
Passaggio 2: prepara il set di dati per l'addestramento
Ora che abbiamo scaricato il set di dati nel blocco note come DataFrame Pandas, possiamo eseguire alcune pre-elaborazione e suddividerlo in set di addestramento e test.
Per prima cosa, eliminiamo le righe con valori null dal set di dati ed eseguiamo lo shuffling dei dati:
df = df.dropna()
df = shuffle(df, random_state=2)
Quindi, estrai la colonna dell'etichetta in una variabile separata e crea un DataFrame con solo le nostre caratteristiche. Poiché is_male è un valore booleano, lo convertiremo in un numero intero in modo che tutti gli input nel nostro modello siano numerici:
labels = df['weight_pounds']
data = df.drop(columns=['weight_pounds'])
data['is_male'] = data['is_male'].astype(int)
Se visualizzi l'anteprima del set di dati eseguendo data.head(), dovresti vedere le quattro funzionalità che utilizzeremo per l'addestramento.
4. Inizializza Git
AI Platform Notebooks ha un'integrazione diretta con Git, quindi puoi eseguire il controllo della versione direttamente nell'ambiente del blocco note. Ciò supporta il commit del codice direttamente nella UI del blocco note o tramite il terminale disponibile in JupyterLab. In questa sezione inizializzeremo un repository Git nel nostro blocco note ed eseguiremo il nostro primo commit tramite la UI.
Passaggio 1: inizializza un repository Git
Dalla directory del codelab, seleziona Git, quindi Init dalla barra dei menu in alto in JupyterLab:
Quando ti viene chiesto se vuoi rendere questa directory un repository Git, seleziona Yes (Sì). Quindi, seleziona l'icona Git sulla barra laterale sinistra per vedere lo stato dei tuoi file e dei commit:
Passaggio 2: esegui il primo commit
In questa UI, puoi aggiungere file a un commit, visualizzare le differenze dei file (ci torneremo in seguito) ed eseguire il commit delle modifiche. Iniziamo eseguendo il commit del file blocco note che abbiamo appena aggiunto.
Seleziona la casella accanto al file del blocco note demo.ipynb per inserirlo in un'area intermedia per il commit (puoi ignorare la directory .ipynb_checkpoints/). Inserisci un messaggio di commit nella casella di testo e fai clic sul segno di spunta per eseguire il commit delle modifiche:
Quando richiesto, inserisci il tuo nome e il tuo indirizzo email. Quindi torna alla scheda Cronologia per vedere il tuo primo commit:
Tieni presente che gli screenshot potrebbero non corrispondere esattamente alla tua UI a causa degli aggiornamenti eseguiti dopo la pubblicazione di questo lab.
5. Crea e addestra un modello TensorFlow
Utilizzeremo il set di dati sulla natalità di BigQuery che abbiamo scaricato sul nostro blocco note per creare un modello che preveda il peso del neonato. In questo lab ci concentreremo sugli strumenti del blocco note, piuttosto che sull'accuratezza del modello stesso.
Passaggio 1: suddividi i dati in set di addestramento e test
Utilizzeremo l'utilità Scikit Learn train_test_split per suddividere 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 siamo pronti a creare il nostro modello TensorFlow.
Passaggio 2: crea e addestra il modello TensorFlow
Per creare questo modello, occorre utilizzare l'API Sequential tf.keras, che consente di definire il modello come stack di strati. Tutto il codice di cui abbiamo bisogno per creare il nostro modello è qui:
model = Sequential([
Dense(64, activation='relu', input_shape=(len(x_train.iloc[0]),)),
Dense(32, activation='relu'),
Dense(1)]
)
Quindi compileremo il modello in modo da addestrarlo. Qui sceglieremo l'ottimizzatore, la funzione di perdita e le metriche del modello da registrare durante l'addestramento. Poiché questo è un modello di regressione (previsione di un valore numerico), come metrica utilizziamo lo scarto quadratico medio anziché l'accuratezza:
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 vedere la forma e il numero di parametri addestrabili del tuo modello su ogni strato.
Ora siamo pronti per addestrare il modello. Basta chiamare il metodo fit(), passandogli i dati e le etichette di addestramento. Utilizzeremo il parametro facoltativo validation_split, che conterrà una parte dei dati di addestramento per convalidare il modello in ogni passaggio. Idealmente, dovresti vedere che la perdita di addestramento e di convalida entrambi diminuisce. Ma ricorda che in questo esempio siamo più concentrati sulla creazione di 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 conoscere le prestazioni del modello, generiamo alcune previsioni di test sui primi 10 esempi dal nostro set di dati di test.
num_examples = 10
predictions = model.predict(x_test[:num_examples])
Quindi eseguiremo l'iterazione sulle previsioni del nostro 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 ed esegui il commit delle modifiche
Ora che hai apportato alcune modifiche al blocco note, puoi provare la funzionalità git diff disponibile nella UI di Notebooks. Il blocco note demo.ipynb ora dovrebbe essere nella sezione "Modificati" dell'interfaccia utente. Passa il mouse sopra il nome del file e fai clic sull'icona delle differenze:
Dovresti quindi essere in grado di vedere le differenze delle modifiche, come quelle che seguono:
Questa volta eseguiremo il commit delle modifiche tramite la riga di comando utilizzando il terminale. Dal 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 seguenti, potrai vedere le modifiche riflesse nell'interfaccia utente Git.
Nella nuova istanza del terminale, esegui questo comando per posizionare temporaneamente il file del blocco note per il commit:
git add demo.ipynb
Quindi, esegui il comando riportato di seguito per eseguire il commit delle modifiche (puoi utilizzare il messaggio di commit che desideri):
git commit -m "Build and train TF model"
Dovresti vedere il commit più recente nella cronologia:
6. Utilizza lo strumento What-If direttamente dal tuo blocco note
Lo strumento What-If è un'interfaccia visiva interattiva progettata per aiutarti a visualizzare i tuoi set di dati e 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 Notebooks di Cloud AI Platform con TensorFlow. Qui lo utilizzeremo per vedere le prestazioni complessive del modello e ispezionarne il comportamento in base ai punti dati del set di test.
Passaggio 1: prepara i dati per lo strumento What-If
Per utilizzare al meglio lo strumento What-If, gli invieremo esempi dal nostro set di test insieme alle etichette basate su dati empirici reali per questi esempi (y_test). In questo modo possiamo confrontare ciò che il modello ha previsto 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 blocco note. A questo scopo, 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 per lo strumento What-If passandogli 500 esempi dal set di dati di test concatenato + le etichette basate su dati di fatto che abbiamo appena creato. Creiamo un'istanza di WitConfigBuilder per configurare lo strumento, trasmettendogli i dati, la funzione di previsione personalizzata definita sopra, insieme al target (l'oggetto della previsione) 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 dei dati di test distribuiti in base al valore di peso previsto del modello, weight_pounds.
Passaggio 3: esplora il comportamento del modello con lo strumento What-If
Ci sono molte cose interessanti che si possono fare con lo strumento What-If. Ne esploreremo solo alcuni qui. Innanzitutto, esaminiamo l'editor dei punti dati. Puoi selezionare qualsiasi punto dati per visualizzarne le caratteristiche e modificarne i valori. Inizia facendo clic su un punto dati qualsiasi:
A sinistra sono visualizzati i valori delle caratteristiche per il punto dati selezionato. Puoi anche confrontare l'etichetta basata su dati di fatto del punto dati con il valore previsto dal modello. Nella barra laterale di 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 cambiare gestation_weeks in 30 per questo punto dati facendo doppio clic su quest'ultimo per eseguire nuovamente la previsione:
Puoi creare tutti i tipi di visualizzazioni personalizzate utilizzando i menu a discesa nella sezione Traccia dello strumento What-If. Ad esempio, ecco un grafico con i modelli peso previsto sull'asse x, età della madre sull'asse y e punti colorati dall'errore di inferenza (più scura significa una differenza maggiore tra il peso previsto e quello effettivo). In questo caso, con la riduzione del peso, l'errore del modello aumenta leggermente:
Quindi, seleziona il pulsante Grafici di dipendenza parziale a sinistra. Questo mostra in che modo ciascuna caratteristica influenza la previsione del modello. Ad esempio, con l'aumento del tempo di gestazione, aumenta anche il peso del neonato previsto dal nostro modello:
Per ulteriori 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, scopriremo come connettere il repository Git nella nostra istanza del blocco note a un repository nel nostro account GitHub. Per eseguire questo passaggio, devi disporre di un account GitHub.
Passaggio 1: crea un nuovo repository su GitHub
Crea un nuovo repository nel tuo account GitHub. Assegnagli un nome e una descrizione, decidi se vuoi che sia pubblico e seleziona Crea repository (non è necessario inizializzarlo con un file README). Nella pagina successiva, seguirai le istruzioni per eseguire il push di un repository esistente dalla riga di comando.
Apri una finestra Terminale e aggiungi il nuovo repository come remoto. Sostituisci username nell'URL del repository riportato di seguito con il tuo nome utente GitHub e your-repo con il nome del repository appena creato:
git remote add origin git@github.com:username/your-repo.git
Passaggio 2: esegui l'autenticazione su GitHub nell'istanza dei tuoi blocchi note
Dovrai poi autenticarti su GitHub dalla tua istanza di blocco note. Questo processo varia a seconda che sia abilitata o meno l'autenticazione a due fattori su GitHub.
Se non sai da dove iniziare, segui i passaggi riportati nella documentazione di GitHub per creare una chiave SSH, quindi aggiungere la nuova chiave a GitHub.
Passaggio 3: assicurati di aver collegato correttamente il repository GitHub
Per assicurarti di avere configurato correttamente tutto, esegui git remote -v nel terminale. Il nuovo repository dovrebbe essere elencato come remoto. Dopo aver visualizzato l'URL del repository GitHub e aver eseguito l'autenticazione su GitHub dal blocco note, puoi eseguire il push direttamente in GitHub dalla tua istanza del blocco note.
Per sincronizzare il repository Git locale del blocco note con il repository GitHub appena creato, fai clic sul pulsante di caricamento nel cloud nella parte superiore della barra laterale di Git:
Aggiorna il repository GitHub. Dovresti vedere il codice del blocco note con i commit precedenti. Se altri utenti hanno accesso al tuo repository GitHub e vuoi visualizzare le modifiche più recenti nel blocco note, fai clic sull'icona di download nel cloud per sincronizzare le modifiche.
Nella scheda History della UI Git di Notebooks, puoi vedere se i tuoi 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 nel cloud per eseguire il push delle modifiche al tuo repository GitHub.
8. Complimenti!
Hai fatto molto in questo lab 👏👏👏
In sintesi, hai imparato a:
- Crea un'istanza di blocco note di AI Platform personalizzata
- Inizializza un repository Git locale in quell'istanza, aggiungi i commit tramite la UI Git o la riga di comando, visualizza le diff git nella UI Git del blocco note
- Crea e addestra un modello TensorFlow 2 semplice
- Utilizza lo strumento What-If nella tua istanza di blocco note
- Connetti il tuo repository Git di blocco note a un repository esterno su GitHub
9. Esegui la pulizia
Se desideri continuare a utilizzare questo blocco note, ti consigliamo di disattivarlo quando non lo usi. Dall'interfaccia utente di Notebooks in Cloud Console, seleziona il blocco note, quindi seleziona Interrompi:
Per eliminare tutte le risorse che hai creato in questo lab, elimina l'istanza del blocco note anziché arrestarla.
Utilizzando il menu di navigazione nella console Cloud, vai a Storage ed elimina i bucket creati per archiviare gli asset del modello.