1. Panoramica
Questo lab illustra vari strumenti di AI Platform Notebooks per esplorare i dati e creare prototipi di modelli ML.
Cosa imparerai
Al termine del corso sarai in grado di:
- Creare e personalizzare un'istanza di AI Platform Notebooks
- Monitora il codice dei tuoi blocchi note con Git, integrato direttamente in AI Platform Notebooks
- Utilizzare lo strumento What-If nel blocco note
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. Creare un'istanza di AI Platform Notebooks
Per eseguire questo codelab, devi avere un progetto Google Cloud con la fatturazione abilitata. Per creare un progetto, segui le istruzioni riportate qui.
Passaggio 2: attiva l'API Compute Engine
Vai a Compute Engine e seleziona Attiva 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 Blocchi note della piattaforma AI 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. Poi esploreremo le opzioni di personalizzazione. Fai clic sul pulsante Personalizza:
AI Platform Notebooks offre molte opzioni di personalizzazione, tra cui la regione in cui è dipiattamata 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 il disco di avvio, la rete e le autorizzazioni. 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 all'istanza nell'interfaccia utente di Notebook. Seleziona Apri JupyterLab per aprire l'istanza e iniziare a creare prototipi:
Quando apri l'istanza, crea una nuova directory denominata codelab. Questa è la directory in cui lavoreremo durante tutto il lab:
Fai clic sulla directory codelab appena creata facendoci doppio clic sopra, quindi seleziona il blocco note Python 3 dal programma di avvio:
Rinomina il notebook in demo.ipynb o con il 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. Collegare i dati di BigQuery al tuo notebook
BigQuery, il data warehouse di big data di Google Cloud, ha reso molti set di dati disponibili pubblicamente 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 40 anni, tra cui il peso alla nascita del bambino e le informazioni demografiche sui genitori del bambino. Utilizzeremo un sottoinsieme di caratteristiche per prevedere il peso alla nascita di un bambino.
Passaggio 1: scarica i dati BigQuery nel nostro notebook
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,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 caratteristiche dal set di dati originale, oltre al peso del bambino (l'elemento che il nostro modello prevederà). 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()
Vengono visualizzate la media, la deviazione standard, il minimo e altre metriche per le colonne numeriche. Infine, estraiamo alcuni dati dalla colonna booleana che indica il genere 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 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 un po' di pre-elaborazione e dividerlo in set di addestramento e test.
Per prima cosa, eliminiamo le righe con valori null dal set di dati e mischiamo i dati:
df = df.dropna()
df = shuffle(df, random_state=2)
Estrai quindi la colonna dell'etichetta 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 dai un'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 ha un'integrazione diretta con Git, quindi puoi eseguire il controllo della versione direttamente all'interno del tuo ambiente di notebook. Questo supporta 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 l'interfaccia utente.
Passaggio 1: inizializza un repository Git
Nella directory del tuo codelab, seleziona Git e poi Init dalla barra dei menu in alto in JupyterLab:
Quando ti viene chiesto se vuoi creare un repository Git in questa directory, 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 interfaccia utente puoi aggiungere file a un commit, visualizzare le differenze tra i file (ne parleremo più avanti) e eseguire il commit delle modifiche. Iniziamo con l'commit del file del notebook che abbiamo appena aggiunto.
Seleziona la casella accanto al file del notebook demo.ipynb per metterlo in fase di staging 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 applicare le modifiche:
Inserisci il tuo nome e il tuo indirizzo email quando richiesto. Poi 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 avvenuti dopo la pubblicazione di questo lab.
5. Crea e addestra un modello TensorFlow
Utilizzeremo il set di dati sulle nascite di BigQuery 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: 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 è tutto pronto per creare il nostro modello TensorFlow.
Passaggio 2: crea e addestra il modello TensorFlow
Lo creeremo utilizzando l'API del modello tf.keras Sequential, che ci consente di definire il modello come uno stack di strati. 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 vengano registrate 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 vedere la forma e il numero di parametri addestrabili del modello in ogni livello.
Ora è tutto pronto per addestrare il modello. Non dobbiamo fare altro che chiamare il metodo fit(), passandogli 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 in ogni passaggio. Idealmente, vuoi che le perdite di addestramento e convalida entrambe diminuiscano. Tuttavia, ricorda che in questo esempio ci concentriamo maggiormente sugli strumenti per i modelli e i notebook 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 eseguiremo l'iterazione sulle 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 committa le modifiche
Ora che hai apportato alcune modifiche al notebook, puoi provare la funzionalità di confronto Git disponibile nell'interfaccia utente di Git di Notebook. Il notebook demo.ipynb dovrebbe ora trovarsi nella sezione "Modificato" dell'interfaccia utente. Passa il mouse sopra il nome file e fai clic sull'icona della differenza:
In questo modo dovresti riuscire a vedere una differenza delle modifiche, ad esempio la seguente:
Questa volta eseguiremo il commit delle modifiche tramite la riga di comando utilizzando il terminale. Nel menu Git della barra dei menu in alto di JupyterLab, seleziona Comando Git in Terminale. Se hai aperto la scheda Git della barra laterale sinistra mentre esegui i comandi riportati di seguito, potrai vedere le modifiche nell'interfaccia utente di Git.
Nella nuova istanza del terminale, esegui il seguente comando per mettere in fase il file del notebook per il commit:
git add demo.ipynb
Quindi, esegui il seguente comando per eseguire il commit delle modifiche (puoi utilizzare il messaggio di commit che preferisci):
git commit -m "Build and train TF model"
Dovresti quindi vedere il tuo commit più recente 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 set di dati e comprendere meglio l'output dei modelli di ML. Si tratta di uno strumento open source creato dal team PAIR di Google. Sebbene funzioni con qualsiasi tipo di modello, include alcune funzionalità create esclusivamente per la piattaforma Cloud AI.
Lo strumento What-If è preinstallato nelle istanze Cloud AI Platform Notebooks con TensorFlow. Qui lo utilizzeremo per verificare il rendimento complessivo del modello e il suo comportamento sui punti dati del set di test.
Passaggio 1: prepara i dati per lo strumento What-If
Per sfruttare al meglio lo strumento What-If, invieremo esempi del 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 nostro modello ha previsto con i dati empirici reali. Esegui la riga di codice seguente 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: esegui l'istanza dello strumento What-If
Creeremo un'istanza dello strumento What-If passandogli 500 esempi dal set di dati di test concatenato + le etichette basate su dati empirici reali che abbiamo appena creato. Creiamo un'istanza di WitConfigBuilder per configurare lo strumento, passando i dati, la funzione di previsione personalizzata che abbiamo definito sopra, il target (l'elemento che stiamo prevedendo) e il 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:
Nell'asse x puoi vedere i punti dati di test suddivisi in base al valore del peso previsto del modello, weight_pounds.
Passaggio 3: esplora il comportamento del modello con lo strumento What-If
Puoi fare molte cose interessanti con lo strumento What-If. Ne esamineremo solo alcuni qui. Innanzitutto, diamo un'occhiata all'editor dei punti dati. Puoi selezionare qualsiasi punto dati per visualizzarne le funzionalità e modificare i relativi valori. Per iniziare, fai clic su un punto dati:
A sinistra vedrai i valori della funzionalità per il punto dati selezionato. Puoi anche confrontare l'etichetta basata su dati empirici reali del punto dati con il valore previsto dal modello. Nella barra laterale di sinistra, puoi anche modificare i valori delle funzionalità ed eseguire di nuovo 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 facendovi doppio clic sopra e rieseguendo 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, di seguito è riportato 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 indica una maggiore differenza tra il peso previsto e quello effettivo). A quanto pare, con la diminuzione del peso, l'errore del modello aumenta leggermente:
Quindi, seleziona il pulsante Grafici di dipendenza parziale a sinistra. Questo mostra in che modo ogni caratteristica influisce sulla previsione del modello. Ad esempio, con l'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 tuo repository Git locale a GitHub
Infine, impareremo a collegare il repository Git nell'istanza del notebook a un repository nel nostro account GitHub. Se vuoi eseguire questo passaggio, devi avere 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 inizializzarlo con un file README). Nella pagina successiva, segui le istruzioni per eseguire lo push di un repository esistente dalla riga di comando.
Apri una finestra del terminale e aggiungi il nuovo repository come remoto. Sostituisci username nell'URL del repository 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 dei notebook
Successivamente, dovrai autenticarti su GitHub dall'istanza del tuo 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 descritti nella documentazione di GitHub per creare una chiave SSH e poi aggiungere la nuova chiave a GitHub.
Passaggio 3: assicurati di aver collegato correttamente il tuo repository GitHub
Per assicurarti di aver configurato tutto correttamente, esegui git remote -v nel terminale. Il nuovo repository dovrebbe essere elencato come remoto. Una volta visualizzato l'URL del tuo repository GitHub e dopo aver eseguito l'autenticazione su GitHub dal tuo notebook, puoi eseguire il push direttamente su GitHub dall'istanza del notebook.
Per sincronizzare il repository Git del tuo 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 vedere il codice del tuo notebook con i commit precedenti. Se altre persone hanno accesso al tuo repository GitHub e vuoi scaricare le ultime modifiche nel tuo notebook, fai clic sull'icona di download del cloud per sincronizzarle.
Nella scheda Cronologia dell'interfaccia utente di git di Notebooks, puoi vedere se i commit locali sono sincronizzati con GitHub. In questo esempio, origin/master corrisponde al nostro repository su GitHub:
Ogni volta che effettui nuovi commit, fai di nuovo clic sul pulsante di caricamento sul cloud per inviare le modifiche al tuo repository GitHub.
8. Complimenti!
Hai fatto molto in questo lab 👏👏👏
In sintesi, hai imparato a:
- Creare e personalizzare un'istanza di AI Platform Notebook
- Inizializza un repository Git locale in quell'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 del blocco note
- Collega il repository Git del tuo 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 blocco note, quindi seleziona Interrompi:
Se vuoi eliminare tutte le risorse che hai creato in questo lab, elimina l'istanza del notebook anziché interromperla.
Utilizzando il menu di navigazione nella console Cloud, vai a Storage ed elimina entrambi i bucket che hai creato per archiviare gli asset del modello.