1. Panoramica
In questo lab utilizzerai lo strumento What-if per analizzare un modello XGBoost addestrato su dati finanziari. Dopo aver analizzato il modello, ne eseguirai il deployment sul nuovo Vertex AI di Google Cloud.
Cosa imparerai
Al termine del corso sarai in grado di:
- Addestrare un modello XGBoost su un set di dati di mutui pubblici in un blocco note in hosting
- Analizzare il modello utilizzando lo strumento What-if
- Eseguire il deployment del modello XGBoost su Vertex AI
Il costo totale per eseguire questo lab su Google Cloud è di circa 1$.
2. Introduzione a Vertex AI
Questo lab utilizza la più recente offerta di prodotti AI disponibile su Google Cloud. Vertex AI integra le offerte ML di Google Cloud in un'esperienza di sviluppo fluida. In precedenza, i modelli addestrati con AutoML e i modelli personalizzati erano accessibili tramite servizi separati. La nuova offerta combina entrambi in un'unica API, insieme ad altri nuovi prodotti. Puoi anche migrare progetti esistenti su Vertex AI. In caso di feedback, consulta la pagina di supporto.
Vertex AI include molti prodotti diversi per supportare i flussi di lavoro ML end-to-end. Questo lab si concentrerà sui prodotti evidenziati di seguito: Prediction e Notebooks.
3. Una breve introduzione a XGBoost
XGBoost è un framework di machine learning che utilizza alberi decisionali e gradient boosting per creare modelli predittivi. Funziona combinando più alberi decisionali in base al punteggio associato a diversi nodi foglia in un albero.
Il diagramma seguente è una visualizzazione di un semplice modello di albero decisionale che valuta se una partita sportiva deve essere giocata in base alle previsioni del tempo:
Perché utilizziamo XGBoost per questo modello? Sebbene le reti neurali tradizionali abbiano dimostrato di avere il rendimento migliore sui dati non strutturati come immagini e testo, gli alberi decisionali spesso hanno un rendimento estremamente buono sui dati strutturati come il set di dati di mutui che utilizzeremo in questo codelab.
4. Configura l'ambiente
Per eseguire questo codelab, devi avere un progetto della piattaforma Google Cloud con la fatturazione abilitata. Per creare un progetto, segui le istruzioni riportate qui.
Passaggio 1: 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 notebook.
Passaggio 2: abilita l'API Vertex AI
Vai alla sezione Vertex della console Cloud e fai clic su Abilita API Vertex AI.
Passaggio 3: crea un'istanza di Notebooks
Dalla sezione Vertex della console Cloud, fai clic su Notebooks:
Da qui, seleziona Nuova istanza. Quindi seleziona il tipo di istanza TensorFlow Enterprise 2.3 senza GPU:
Utilizza le opzioni predefinite e fai clic su Crea. Una volta creata l'istanza, seleziona Apri JupyterLab.
Passaggio 4: installa XGBoost
Una volta aperta l'istanza di JupyterLab, devi aggiungere il pacchetto XGBoost.
Per farlo, seleziona Terminale dal launcher:
Quindi esegui il comando seguente per installare la versione più recente di XGBoost supportata da Vertex AI:
pip3 install xgboost==1.2
Al termine, apri un'istanza di blocco note Python 3 dal launcher. Ora puoi iniziare a utilizzare il notebook.
Passaggio 5: importa i pacchetti Python
Nella prima cella del blocco note, aggiungi le seguenti importazioni ed esegui la cella. Puoi eseguirla premendo il pulsante Freccia destra nel menu in alto o premendo Comando-Invio:
import pandas as pd
import xgboost as xgb
import numpy as np
import collections
import witwidget
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.utils import shuffle
from witwidget.notebook.visualization import WitWidget, WitConfigBuilder
5. Scarica ed elabora i dati
Utilizzeremo un set di dati di mutui di ffiec.gov per addestrare un modello XGBoost. Abbiamo eseguito un po' di pre-elaborazione sul set di dati originale e abbiamo creato una versione più piccola da utilizzare per addestrare il modello. Il modello prevede se una determinata richiesta di mutuo verrà approvata o meno.
Passaggio 1: scarica il set di dati pre-elaborato
Abbiamo reso disponibile una versione del set di dati in Google Cloud Storage. Puoi scaricarlo eseguendo il seguente comando gsutil nel blocco note Jupyter:
!gsutil cp 'gs://mortgage_dataset_files/mortgage-small.csv' .
Passaggio 2: leggi il set di dati con Pandas
Prima di creare il DataFrame Pandas, creeremo un dict del tipo di dati di ogni colonna in modo che Pandas legga correttamente il set di dati:
COLUMN_NAMES = collections.OrderedDict({
'as_of_year': np.int16,
'agency_code': 'category',
'loan_type': 'category',
'property_type': 'category',
'loan_purpose': 'category',
'occupancy': np.int8,
'loan_amt_thousands': np.float64,
'preapproval': 'category',
'county_code': np.float64,
'applicant_income_thousands': np.float64,
'purchaser_type': 'category',
'hoepa_status': 'category',
'lien_status': 'category',
'population': np.float64,
'ffiec_median_fam_income': np.float64,
'tract_to_msa_income_pct': np.float64,
'num_owner_occupied_units': np.float64,
'num_1_to_4_family_units': np.float64,
'approved': np.int8
})
Poi creeremo un DataFrame, passandogli i tipi di dati specificati sopra. È importante rimescolare i dati nel caso in cui il set di dati originale sia ordinato in un modo specifico. Per farlo, utilizziamo un'utilità sklearn chiamata shuffle, che abbiamo importato nella prima cella:
data = pd.read_csv(
'mortgage-small.csv',
index_col=False,
dtype=COLUMN_NAMES
)
data = data.dropna()
data = shuffle(data, random_state=2)
data.head()
data.head() ci consente di visualizzare in anteprima le prime cinque righe del set di dati in Pandas. Dopo aver eseguito la cella sopra, dovresti vedere qualcosa di simile a questo:
Queste sono le caratteristiche che utilizzeremo per addestrare il modello. Se scorri fino alla fine, vedrai l'ultima colonna approved, che è ciò che stiamo prevedendo. Un valore di 1 indica che una determinata richiesta è stata approvata, mentre 0 indica che è stata rifiutata.
Per visualizzare la distribuzione dei valori approvati / rifiutati nel set di dati e creare un array numpy delle etichette, esegui il comando seguente:
# Class labels - 0: denied, 1: approved
print(data['approved'].value_counts())
labels = data['approved'].values
data = data.drop(columns=['approved'])
Circa il 66% del set di dati contiene richieste approvate.
Passaggio 3: crea una colonna fittizia per i valori categorici
Questo set di dati contiene un mix di valori categorici e numerici, ma XGBoost richiede che tutte le caratteristiche siano numeriche. Invece di rappresentare i valori categorici utilizzando la codifica one-hot, per il modello XGBoost utilizzeremo la funzione get_dummies di Pandas.
get_dummies prende una colonna con più valori possibili e la converte in una serie di colonne, ognuna con solo 0 e 1. Ad esempio, se avessimo una colonna "colore" con i valori possibili "blu" e "rosso", get_dummies la trasformerebbe in due colonne chiamate "color_blue" e "color_red" con tutti i valori booleani 0 e 1.
Per creare colonne fittizie per le caratteristiche categoriche, esegui il codice seguente:
dummy_columns = list(data.dtypes[data.dtypes == 'category'].index)
data = pd.get_dummies(data, columns=dummy_columns)
data.head()
Quando visualizzi l'anteprima dei dati questa volta, vedrai le singole caratteristiche (come purchaser_type mostrata di seguito) suddivise in più colonne:
Passaggio 4: suddivisione dei dati in set di addestramento e test
Un concetto importante nel machine learning è la suddivisione in addestramento / test. Prenderemo la maggior parte dei dati e li utilizzeremo per addestrare il modello, mentre il resto lo metteremo da parte per testare il modello su dati che non ha mai visto prima.
Aggiungi il seguente codice al notebook, che utilizza la funzione train_test_split di Scikit-learn per suddividere i dati:
x,y = data.values,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
Ora puoi creare e addestrare il modello.
6. Crea, addestra e valuta un modello XGBoost
Passaggio 1: definisci e addestra il modello XGBoost
Creare un modello in XGBoost è semplice. Utilizzeremo la classe XGBClassifier per creare il modello e dobbiamo solo passare il parametro objective corretto per la nostra attività di classificazione specifica. In questo caso utilizziamo reg:logistic perché abbiamo un problema di classificazione binaria e vogliamo che il modello restituisca un singolo valore nell'intervallo (0,1): 0 per non approvato e 1 per approvato.
Il codice seguente creerà un modello XGBoost:
model = xgb.XGBClassifier(
objective='reg:logistic'
)
Puoi addestrare il modello con una riga di codice, chiamando il metodo fit() e passandogli i dati e le etichette di addestramento.
model.fit(x_train, y_train)
Passaggio 2: valuta l'accuratezza del modello
Ora possiamo utilizzare il modello addestrato per generare previsioni sui dati di test con la funzione predict().
Poi utilizzeremo la funzione accuracy_score() di Scikit-learn per calcolare l'accuratezza del modello in base al suo rendimento sui dati di test. Passeremo i valori di base insieme ai valori previsti del modello per ogni esempio nel set di test:
y_pred = model.predict(x_test)
acc = accuracy_score(y_test, y_pred.round())
print(acc, '\n')
Dovresti vedere un'accuratezza di circa 87%, ma la tua varierà leggermente perché nel machine learning è sempre presente un elemento di casualità.
Passaggio 3: salva il modello
Per eseguire il deployment del modello, esegui il codice seguente per salvarlo in un file locale:
model.save_model('model.bst')
7. Utilizza lo strumento What-if per interpretare il modello
Passaggio 1: crea la visualizzazione dello strumento What-if
Per connettere lo strumento What-if al modello locale, devi passargli un sottoinsieme degli esempi di test insieme ai valori di base per questi esempi. Creiamo un array Numpy di 500 esempi di test insieme alle relative etichette di base:
num_wit_examples = 500
test_examples = np.hstack((x_test[:num_wit_examples],y_test[:num_wit_examples].reshape(-1,1)))
L'istanza dello strumento What-if è semplice come creare un oggetto WitConfigBuilder e passargli il modello che vuoi analizzare.
Poiché lo strumento What-if si aspetta un elenco di punteggi per ogni classe nel modello (in questo caso 2), utilizzeremo il metodo predict_proba di XGBoost con lo strumento What-if:
config_builder = (WitConfigBuilder(test_examples.tolist(), data.columns.tolist() + ['mortgage_status'])
.set_custom_predict_fn(model.predict_proba)
.set_target_feature('mortgage_status')
.set_label_vocab(['denied', 'approved']))
WitWidget(config_builder, height=800)
Tieni presente che il caricamento della visualizzazione richiede un minuto. Al termine del caricamento, dovresti vedere quanto segue:
L'asse y mostra la previsione del modello, con 1 che indica una previsione approved con un'affidabilità elevata e 0 che indica una previsione denied con un'affidabilità elevata. L'asse x è solo la diffusione di tutti i punti dati caricati.
Passaggio 2: esplora i singoli punti dati
La visualizzazione predefinita nello strumento What-if è la scheda Editor punti dati. Qui puoi fare clic su un singolo punto dati per visualizzarne le caratteristiche, modificare i valori delle caratteristiche e vedere in che modo questa modifica influisce sulla previsione del modello su un singolo punto dati.
Nell'esempio seguente abbiamo scelto un punto dati vicino alla soglia di 0,5. La richiesta di mutuo associata a questo particolare punto dati proviene dal CFPB. Abbiamo modificato questa caratteristica impostandola su 0 e abbiamo anche modificato il valore di agency_code_Department of Housing and Urban Development (HUD) su 1 per vedere cosa sarebbe successo alla previsione del modello se questo prestito provenisse invece dall'HUD:
Come possiamo vedere nella sezione in basso a sinistra dello strumento What-if, la modifica di questa caratteristica ha ridotto significativamente la previsione approved del modello del 32%. Questo potrebbe indicare che l'agenzia da cui proviene un prestito ha un forte impatto sull'output del modello, ma per esserne certi dobbiamo eseguire ulteriori analisi.
Nella parte in basso a sinistra dell'interfaccia utente, possiamo anche vedere il valore di base per ogni punto dati e confrontarlo con la previsione del modello:
Passaggio 3: analisi controfattuale
Poi, fai clic su un punto dati qualsiasi e sposta il cursore Mostra il punto dati controfattuale più vicino verso destra:
Selezionando questa opzione, verrà visualizzato il punto dati con i valori delle caratteristiche più simili a quello originale selezionato, ma la previsione opposta. Puoi quindi scorrere i valori delle caratteristiche per vedere dove i due punti dati differiscono (le differenze sono evidenziate in verde e in grassetto).
Passaggio 4: esamina i grafici di dipendenza parziale
Per vedere in che modo ogni caratteristica influisce sulle previsioni del modello in generale, seleziona la casella Grafici di dipendenza parziale e assicurati che sia selezionata l'opzione Grafici di dipendenza parziale globali:
Qui possiamo vedere che i prestiti provenienti dall'HUD hanno una probabilità leggermente maggiore di essere rifiutati. Il grafico ha questa forma perché il codice dell'agenzia è una caratteristica booleana, quindi i valori possono essere solo esattamente 0 o 1.
applicant_income_thousands è una caratteristica numerica e nel grafico di dipendenza parziale possiamo vedere che un reddito più elevato aumenta leggermente la probabilità che una richiesta venga approvata, ma solo fino a circa 200.000 $. Dopo 200.000 $, questa caratteristica non influisce sulla previsione del modello.
Passaggio 5: esplora il rendimento e l'equità complessivi
Poi, vai alla scheda Rendimento ed equità. Questa scheda mostra le statistiche sul rendimento complessivo dei risultati del modello sul set di dati fornito, incluse matrici di confusione, curve PR e curve ROC.
Seleziona mortgage_status come caratteristica di base per visualizzare una matrice di confusione:
Questa matrice di confusione mostra le previsioni corrette e errate del modello come percentuale del totale. Se sommi i quadrati Actual Yes / Predicted Yes e Actual No / Predicted No, dovresti ottenere la stessa accuratezza del modello (in questo caso circa l'87%, anche se il modello potrebbe variare leggermente perché nell'addestramento dei modelli ML è presente un elemento di casualità).
Puoi anche sperimentare con il cursore della soglia, aumentando e diminuendo il punteggio di classificazione positiva che il modello deve restituire prima di decidere di prevedere approved per il prestito e vedere in che modo questo influisce su accuratezza, falsi positivi e falsi negativi. In questo caso, l'accuratezza è massima intorno a una soglia di 0,55.
Poi, nel menu a discesa Suddividi per a sinistra, seleziona loan_purpose_Home_purchase:
Ora vedrai il rendimento dei due sottoinsiemi di dati: la sezione "0" mostra quando il prestito non è per l'acquisto di una casa, mentre la sezione "1" indica quando il prestito è per l'acquisto di una casa. Controlla l'accuratezza, il tasso di falsi positivi e il tasso di falsi negativi tra le due sezioni per cercare differenze nel rendimento.
Se espandi le righe per esaminare le matrici di confusione, puoi vedere che il modello prevede "approved" per circa il 70% delle richieste di prestito per l'acquisto di una casa e solo il 46% dei prestiti che non sono per l'acquisto di una casa (le percentuali esatte variano a seconda del modello):
Se selezioni Parità demografica dai pulsanti di opzione a sinistra, le due soglie verranno modificate in modo che il modello preveda approved per una percentuale simile di richiedenti in entrambe le sezioni. Qual è l'effetto sull'accuratezza, sui falsi positivi e sui falsi negativi per ogni sezione?
Passaggio 6: esplora la distribuzione delle caratteristiche
Infine, vai alla scheda Caratteristiche nello strumento What-if. Questa scheda mostra la distribuzione dei valori per ogni caratteristica nel set di dati:
Puoi utilizzare questa scheda per assicurarti che il set di dati sia bilanciato. Ad esempio, sembra che pochissimi prestiti nel set di dati provengano dalla Farm Service Agency. Per migliorare l'accuratezza del modello, potremmo prendere in considerazione l'aggiunta di altri prestiti da questa agenzia, se i dati sono disponibili.
Qui abbiamo descritto solo alcune idee per l'esplorazione dello strumento What-if. Non esitare a continuare a utilizzare lo strumento, ci sono molte altre aree da esplorare.
8. Esegui il deployment del modello su Vertex AI
Il modello funziona localmente, ma sarebbe bello se potessimo fare previsioni su di esso da qualsiasi luogo (non solo da questo blocco note). In questo passaggio, ne eseguiremo il deployment sul cloud.
Passaggio 1: crea un bucket Cloud Storage per il modello
Innanzitutto, definiamo alcune variabili di ambiente che utilizzeremo per il resto del codelab. Inserisci i valori di seguito con il nome del progetto cloud Google, il nome del bucket Cloud Storage che vuoi creare (deve essere univoco a livello globale) e il nome della versione per la prima versione del modello:
# Update the variables below to your own Google Cloud project ID and GCS bucket name. You can leave the model name we've specified below:
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
MODEL_NAME = 'xgb_mortgage'
Ora possiamo creare un bucket di archiviazione per archiviare il file del modello XGBoost. Indicheremo questo file a Vertex AI quando eseguiamo il deployment.
Esegui questo comando gsutil dal blocco note per creare un bucket di archiviazione regionale:
!gsutil mb -l us-central1 $MODEL_BUCKET
Passaggio 2: copia il file del modello in Cloud Storage
Poi, copieremo il file del modello salvato XGBoost in Cloud Storage. Esegui il seguente comando gsutil:
!gsutil cp ./model.bst $MODEL_BUCKET
Vai al browser di archiviazione nella console Cloud per verificare che il file sia stato copiato:
Passaggio 3: crea il modello ed esegui il deployment su un endpoint
È quasi tutto pronto per eseguire il deployment del modello sul cloud. In Vertex AI, un modello può contenere più endpoint. Per prima cosa creeremo un modello, poi creeremo un endpoint all'interno di questo modello ed eseguiremo il deployment.
Innanzitutto, utilizza gcloud CLI per creare il modello:
!gcloud beta ai models upload \
--display-name=$MODEL_NAME \
--artifact-uri=$MODEL_BUCKET \
--container-image-uri=us-docker.pkg.dev/cloud-aiplatform/prediction/xgboost-cpu.1-2:latest \
--region=us-central1
Il parametro artifact-uri rimanderà alla posizione di Storage in cui hai salvato il modello XGBoost. Il parametro container-image-uri indica a Vertex AI quale container predefinito utilizzare per la pubblicazione. Al termine del comando, vai alla sezione dei modelli della console Vertex per recuperare l'ID del nuovo modello. Puoi trovarlo qui:
Copia l'ID e salvalo in una variabile:
MODEL_ID = "your_model_id"
Ora è il momento di creare un endpoint all'interno di questo modello. Possiamo farlo con questo comando gcloud:
!gcloud beta ai endpoints create \
--display-name=xgb_mortgage_v1 \
--region=us-central1
Al termine, dovresti vedere la posizione dell'endpoint registrata nell'output del blocco note. Cerca la riga che indica che l'endpoint è stato creato con un percorso simile al seguente: projects/project_ID/locations/us-central1/endpoints/endpoint_ID. Poi sostituisci i valori di seguito con gli ID dell'endpoint creato sopra:
ENDPOINT_ID = "your_endpoint_id"
Per eseguire il deployment dell'endpoint, esegui il comando gcloud riportato di seguito:
!gcloud beta ai endpoints deploy-model $ENDPOINT_ID \
--region=us-central1 \
--model=$MODEL_ID \
--display-name=xgb_mortgage_v1 \
--machine-type=n1-standard-2 \
--traffic-split=0=100
Il deployment dell'endpoint richiede circa 5-10 minuti. Mentre l'endpoint è in fase di deployment, vai alla sezione modelli della console. Fai clic sul modello e dovresti vedere l'endpoint in fase di deployment:
Al termine del deployment, al posto della rotellina di caricamento verrà visualizzato un segno di spunta verde.
Passaggio 4: testa il modello di cui è stato eseguito il deployment
Per assicurarti che il modello di cui è stato eseguito il deployment funzioni, provalo utilizzando gcloud per fare una previsione. Innanzitutto, salva un file JSON con un esempio del set di test:
%%writefile predictions.json
{
"instances": [
[2016.0, 1.0, 346.0, 27.0, 211.0, 4530.0, 86700.0, 132.13, 1289.0, 1408.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0]
]
}
Testa il modello eseguendo questo comando gcloud:
!gcloud beta ai endpoints predict $ENDPOINT_ID \
--json-request=predictions.json \
--region=us-central1
Dovresti vedere la previsione del modello nell'output. Questo particolare esempio è stato approvato, quindi dovresti vedere un valore vicino a 1.
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 create in questo lab, elimina l'istanza del blocco note anziché interromperla.
Per eliminare l'endpoint di cui hai eseguito il deployment, vai alla sezione Endpoint della console Vertex e fai clic sull'icona Elimina:
Per eliminare il bucket di archiviazione, utilizza il menu di navigazione nella console Cloud, vai a Storage, seleziona il bucket e fai clic su Elimina:
