1. Panoramica
In questo lab utilizzerai AI Platform Notebooks per creare e addestrare un modello per l'identificazione di transazioni fraudolente e comprendere le previsioni del modello con l'SDK Explainable AI. Il rilevamento delle frodi è un tipo di rilevamento di anomalie specifico per i servizi finanziari e presenta alcune sfide interessanti per i modelli ML: set di dati intrinsecamente sbilanciati e necessità di spiegare i risultati di un modello.
Cosa imparerai
Al termine del corso sarai in grado di:
- Gestire set di dati sbilanciati
- Crea e valuta un modello di rilevamento delle frodi con tf.keras in AI Platform Notebooks
- Utilizza l'SDK Explainable AI all'interno del notebook per capire perché il modello ha classificato le transazioni come fraudolente
- Esegui il deployment del modello in AI Platform con le spiegazioni e ottieni previsioni e spiegazioni sul modello di cui è stato eseguito il deployment
Il costo totale per eseguire questo lab su Google Cloud è di circa 1$.
2. Perché il rilevamento delle frodi?
Il rilevamento delle anomalie può essere un buon candidato per il machine learning, poiché spesso è difficile scrivere una serie di istruzioni basate su regole per identificare i valori anomali nei dati. Il rilevamento di frodi è un tipo di rilevamento di anomalie e presenta due sfide interessanti per quanto riguarda il machine learning:
- Set di dati molto sbilanciati: poiché le anomalie sono, beh, anomalie, non sono molte. L'ML funziona meglio quando i set di dati sono bilanciati, quindi le cose possono complicarsi quando i valori anomali costituiscono meno dell'1% dei dati.
- Necessità di spiegare i risultati: se stai cercando attività fraudolente, è probabile che tu voglia sapere perché un sistema ha segnalato qualcosa come fraudolento, anziché fidarti ciecamente. Gli strumenti di spiegabilità possono aiutarti in questo.
3. Configura l'ambiente
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 1: attiva l'API Cloud AI Platform Models
Vai alla sezione Modelli AI Platform della console Cloud e fai clic su Abilita se non è già abilitata.
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 AI Platform Notebooks
Vai alla sezione AI Platform Notebooks della tua console Cloud e fai clic su Nuova istanza. Quindi, seleziona il tipo di istanza TensorFlow Enterprise 2.1 senza GPU:
Utilizza le opzioni predefinite e poi fai clic su Crea. Una volta creata l'istanza, seleziona Apri JupyterLab:
Quando apri l'istanza, seleziona il notebook Python 3 da Avvio app:
Passaggio 4: importa i pacchetti Python
Crea una nuova cella e importa le librerie che utilizzeremo in questo codelab:
import itertools
import numpy as np
import pandas as pd
import tensorflow as tf
import json
import matplotlib as mpl
import matplotlib.pyplot as plt
import explainable_ai_sdk
from sklearn.utils import shuffle
from sklearn.metrics import confusion_matrix
from sklearn.preprocessing import StandardScaler
from tensorflow import keras
from explainable_ai_sdk.metadata.tf.v2 import SavedModelMetadataBuilder
4. Scaricare ed elaborare i dati
Utilizzeremo questo set di dati generato sinteticamente da Kaggle per addestrare il nostro modello. Il set di dati originale include 6,3 milioni di righe, di cui 8000 sono transazioni fraudolente, ovvero solo lo 0,1% dell'intero set di dati.
Passaggio 1: scarica il set di dati Kaggle e leggilo con Pandas
Abbiamo reso disponibile il set di dati Kaggle in Google Cloud Storage. Puoi scaricarlo eseguendo il seguente comando gsutil nel blocco note Jupyter:
!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .
Successivamente, leggiamo il set di dati come DataFrame Pandas e visualizziamone l'anteprima:
data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()
Nell'anteprima dovresti vedere qualcosa di simile a questo:
Passaggio 2: Tieni conto dei dati sbilanciati
Come accennato in precedenza, al momento il set di dati contiene il 99,9% di esempi non fraudolenti. Se addestriamo un modello sui dati così come sono, è probabile che il modello raggiunga un'accuratezza del 99,9% ipotizzando che ogni transazione non sia fraudolenta semplicemente perché il 99,9% dei dati riguarda casi non fraudolenti.
Esistono diversi approcci per gestire i dati sbilanciati. Qui utilizzeremo una tecnica chiamata sottocampionamento. Il sottocampionamento consiste nell'utilizzare solo una piccola percentuale della classe maggioritaria nell'addestramento. In questo caso, "non frode" è la classe maggioritaria, poiché rappresenta il 99,9% dei dati.
Per sottocampionare il nostro set di dati, prenderemo tutti gli 8000 esempi fraudolenti e un campione casuale di 31.000 casi non fraudolenti. In questo modo, il set di dati risultante avrà il 25% di casi di frode, rispetto allo 0,1% precedente.
Innanzitutto, dividi i dati in due DataFrame, uno per le frodi e uno per le non frodi (li utilizzeremo più avanti nel codelab quando eseguiremo il deployment del modello):
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
Poi, prendi un campione casuale dei casi non fraudolenti. Utilizziamo lo 0,005% perché in questo modo otteniamo una suddivisione del 25/75 tra transazioni fraudolente e non fraudolente. In questo modo, puoi ricomporre i dati e riprodurli in ordine casuale. Per semplificare le cose, rimuoveremo anche alcune colonne che non utilizzeremo per l'addestramento:
# Take a random sample of non fraud rows
not_fraud_sample = not_fraud.sample(random_state=2, frac=.005)
# Put it back together and shuffle
df = pd.concat([not_fraud_sample,fraud])
df = shuffle(df, random_state=2)
# Remove a few columns (isFraud is the label column we'll use, not isFlaggedFraud)
df = df.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud'])
# Preview the updated dataset
df.head()
Ora abbiamo un set di dati molto più equilibrato. Tuttavia, se notiamo che il nostro modello converge intorno a un'accuratezza del 75%, è molto probabile che indovini "non frode" in ogni caso.
Passaggio 3: dividi i dati in set di addestramento e test
L'ultima cosa da fare prima di creare il modello è dividere i dati. Utilizzeremo una suddivisione 80/20 per l'addestramento e il test:
train_test_split = int(len(df) * .8)
train_set = df[:train_test_split]
test_set = df[train_test_split:]
train_labels = train_set.pop('isFraud')
test_labels = test_set.pop('isFraud')
*E. A. Lopez-Rojas , A. Elmir e S. Axelsson. "PaySim: A financial mobile money simulator for fraud detection". In: The 28th European Modeling and Simulation Symposium-EMSS, Larnaca, Cipro. 2016
5. Crea, addestra e valuta un modello tf.keras
Utilizzeremo l'API tf.keras di TensorFlow. Il codice del modello in questa sezione si basa su questo tutorial della documentazione di TensorFlow. Innanzitutto, normalizzeremo i dati, poi creeremo e addestreremo il modello utilizzando il parametro class_weight per tenere conto dello squilibrio dei dati rimanenti.
Passaggio 1: normalizza i dati
Quando addestri un modello su dati numerici, è importante normalizzare i dati, soprattutto se ogni colonna rientra in un intervallo diverso. In questo modo è possibile evitare perdite dovute a esplosioni durante l'allenamento. Possiamo normalizzare i nostri dati con quanto segue:
scaler = StandardScaler()
train_set = scaler.fit_transform(train_set) # Only normalize on the train set
test_set = scaler.transform(test_set)
# clip() ensures all values fall within the range [-5,5]
# useful if any outliers remain after normalizing
train_set = np.clip(train_set, -5, 5)
test_set = np.clip(test_set, -5, 5)
Quindi, visualizziamo l'anteprima dei dati normalizzati:
train_set
Passaggio 2: determina i pesi delle classi
Durante il sottocampionamento dei dati, abbiamo voluto conservare un sottoinsieme delle transazioni non fraudolente per non perdere informazioni su queste transazioni, motivo per cui i dati non sono perfettamente bilanciati. Poiché il set di dati è ancora sbilanciato e ci interessa soprattutto identificare correttamente le transazioni fraudolente, vogliamo che il nostro modello assegni un peso maggiore agli esempi fraudolenti nel nostro set di dati.
Il parametro class_weight di Keras ci consente di specificare esattamente il peso che vogliamo assegnare agli esempi di ogni classe, in base alla frequenza con cui si verificano nel set di dati:
weight_for_non_fraud = 1.0 / df['isFraud'].value_counts()[0]
weight_for_fraud = 1.0 / df['isFraud'].value_counts()[1]
class_weight = {0: weight_for_non_fraud, 1: weight_for_fraud}
Utilizzeremo questa variabile quando addestreremo il modello nel passaggio successivo.
Passaggio 3: addestra e valuta il modello
Creeremo il nostro modello utilizzando l'API Keras Sequential Model, che ci consente di definire il modello come una pila di livelli. Durante l'addestramento, monitoreremo una serie di metriche che ci aiuteranno a capire il rendimento del modello per ogni classe del nostro set di dati.
METRICS = [
keras.metrics.TruePositives(name='tp'),
keras.metrics.FalsePositives(name='fp'),
keras.metrics.TrueNegatives(name='tn'),
keras.metrics.FalseNegatives(name='fn'),
keras.metrics.BinaryAccuracy(name='accuracy'),
keras.metrics.Precision(name='precision'),
keras.metrics.Recall(name='recall'),
keras.metrics.AUC(name='auc'),
]
def make_model(metrics = METRICS):
model = keras.Sequential([
keras.layers.Dense(
16, activation='relu',
input_shape=(train_set.shape[-1],)),
keras.layers.Dropout(0.5),
keras.layers.Dense(1, activation='sigmoid'),
])
model.compile(
optimizer=keras.optimizers.Adam(lr=1e-3),
loss=keras.losses.BinaryCrossentropy(),
metrics=metrics)
return model
Quindi, definiremo alcune variabili globali da utilizzare durante l'addestramento insieme ad alcuni parametri di interruzione anticipata.
EPOCHS = 100
BATCH_SIZE = 512
early_stopping = tf.keras.callbacks.EarlyStopping(
monitor='val_auc',
verbose=1,
patience=10,
mode='max',
restore_best_weights=True)
Infine, chiameremo la funzione definita sopra per creare il nostro modello:
model = make_model()
model.summary()
Possiamo addestrare il modello con il metodo fit(), passando i parametri definiti sopra:
results = model.fit(
train_set,
train_labels,
batch_size=BATCH_SIZE,
epochs=EPOCHS,
callbacks = [early_stopping],
validation_data=(test_set, test_labels),
class_weight=class_weight)
L'addestramento richiederà alcuni minuti.
Passaggio 4: visualizza le metriche del modello
Ora che abbiamo un modello addestrato, vediamo il suo rendimento tracciando varie metriche durante i periodi di addestramento:
mpl.rcParams['figure.figsize'] = (12, 10)
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
def plot_metrics(history):
metrics = ['loss', 'auc', 'precision', 'recall']
for n, metric in enumerate(metrics):
name = metric.replace("_"," ").capitalize()
plt.subplot(2,2,n+1)
plt.plot(history.epoch, history.history[metric], color=colors[0], label='Train')
plt.plot(history.epoch, history.history['val_'+metric],
color=colors[0], linestyle="--", label='Val')
plt.xlabel('Epoch')
plt.ylabel(name)
if metric == 'loss':
plt.ylim([0, plt.ylim()[1]])
elif metric == 'auc':
plt.ylim([0.8,1])
else:
plt.ylim([0,1])
plt.legend()
plot_metrics(results)
I grafici dovrebbero essere simili ai seguenti (ma non esattamente identici):
Passaggio 5: stampa una matrice di confusione
Una matrice di confusione è un buon modo per visualizzare il rendimento del modello nel set di dati di test. Per ogni classe, verrà visualizzata la percentuale di esempi di test che il modello ha previsto correttamente e in modo errato. Scikit Learn dispone di alcune utilità per creare e tracciare le matrici di confusione, che utilizzeremo qui.
All'inizio del notebook abbiamo importato l'utilità confusion_matrix. Per utilizzarlo, creiamo prima un elenco delle previsioni del nostro modello. Qui arrotonderemo i valori restituiti dal nostro modello in modo che questo elenco corrisponda al nostro elenco di etichette basate su dati empirici reali:
predicted = model.predict(test_set)
y_pred = []
for i in predicted.tolist():
y_pred.append(int(round(i[0])))
Ora siamo pronti a inserire questi dati nel metodo confusion_matrix, insieme alle etichette basate su dati empirici reali:
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
Ci mostra i numeri assoluti delle previsioni corrette e errate del nostro modello nel nostro set di test. Il numero in alto a sinistra mostra quanti esempi del nostro set di test sono stati previsti correttamente dal nostro modello come non fraudolenti. Il numero in basso a destra indica quanti sono stati previsti correttamente come fraudolenti (questo è il numero che ci interessa di più). Puoi notare che ha previsto correttamente la maggior parte dei campioni per ogni classe.
Per semplificare la visualizzazione, abbiamo adattato la funzione plot_confusion_matrix dalla documentazione di Scikit Learn. Definisci la funzione qui:
def plot_confusion_matrix(cm, classes,
normalize=False,
title='Confusion matrix',
cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
"""
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
if normalize:
cm = np.round(cm.astype('float') / cm.sum(axis=1)[:, np.newaxis], 3)
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, cm[i, j],
horizontalalignment="center",
color="white" if cm[i, j] > thresh else "black")
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
e crea il grafico passando i dati del nostro modello. Impostiamo normalize su True in modo che la matrice di confusione mostri il numero di previsioni corrette e non corrette in percentuale:
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
Dovresti vedere qualcosa di simile a questo (i numeri esatti variano):
Qui possiamo vedere che il nostro modello ha previsto correttamente circa l'85% delle 1594 transazioni fraudolente del nostro set di test. Tieni presente che l'obiettivo di questo lab non è la qualità del modello. Se implementi un modello di rilevamento delle frodi in produzione, probabilmente vorrai un'accuratezza superiore all'85% per la classe frode. Lo scopo di questo lab è presentarti gli strumenti per spiegare i modelli addestrati su set di dati sbilanciati.
Successivamente, utilizzeremo l'SDK Explainable AI per capire su quali funzionalità si basa il nostro modello per fare queste previsioni.
6. Utilizzo dell'SDK Explainable AI
L'SDK Explainable AI fornisce metodi di utilità per ottenere spiegazioni sul tuo modello. È preinstallato nelle istanze di notebook AI Platform TensorFlow. Tieni presente che l'abbiamo importato nel notebook all'inizio del lab. Con l'SDK, possiamo ottenere le attribuzioni delle caratteristiche dal nostro modello all'interno dell'istanza del blocco note, il che significa che non dobbiamo eseguire il deployment del modello nel cloud per utilizzarlo.
In questa sezione, esporteremo il modello appena addestrato come SavedModel di TensorFlow, quindi indirizzeremo l'SDK agli asset del modello salvato per ottenere le spiegazioni.
Passaggio 1: esporta il modello addestrato
Innanzitutto, salviamo il modello in una directory nell'istanza del notebook:
model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)
Se aggiorni la visualizzazione delle cartelle nella barra laterale sinistra del notebook, dovrebbe essere stata creata una nuova directory denominata fraud_model/.
Passaggio 2: ottieni i metadati della spiegazione con l'SDK
A questo punto, indirizzeremo l'SDK Explainable AI a questa directory. In questo modo, verranno generati i metadati necessari per ottenere le spiegazioni del modello. Il metodo get_metadata() mostra i metadati che l'SDK deduce dal modello, come i nomi degli input:
model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)
L'interpretabilità ci aiuta a rispondere alla domanda: "Perché il nostro modello ha ritenuto che si trattasse di una frode?"
Passaggio 3: specifica della baseline del modello
Per i dati tabulari, il servizio Explainable AI funziona restituendo i valori di attribuzione per ogni caratteristica. Questi valori indicano in che misura una determinata caratteristica ha influito sulla previsione. Supponiamo che l'importo di una determinata transazione abbia indotto il nostro modello ad aumentare la probabilità di frode prevista dello 0,2%. Ti starai chiedendo: "0,2% rispetto a cosa?". Questo ci porta al concetto di baseline.
La base di riferimento del nostro modello è essenzialmente ciò con cui viene confrontato. Selezioniamo il valore di base per ogni funzionalità del modello e la previsione di base diventa di conseguenza il valore previsto dal modello quando le funzionalità sono impostate sul valore di base.
La scelta di una baseline dipende dall'attività di previsione che stai risolvendo. Per le caratteristiche numeriche, è comune utilizzare il valore mediano di ogni caratteristica nel set di dati come base di riferimento. Nel caso del rilevamento delle frodi, tuttavia, non è esattamente quello che vogliamo. Ci interessa soprattutto spiegare i casi in cui il nostro modello etichetta una transazione come fraudolenta. Ciò significa che lo scenario di base con cui vogliamo effettuare il confronto è costituito da transazioni non fraudolente.
Per tenere conto di questo aspetto, utilizzeremo come base di riferimento i valori mediani delle transazioni non fraudolente nel nostro set di dati. Possiamo ottenere la mediana utilizzando il DataFrame not_fraud_sample estratto sopra e scalando i dati in modo che corrispondano agli input previsti del nostro modello:
not_fraud_sample = not_fraud_sample.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud', 'isFraud'])
baseline = scaler.transform(not_fraud_sample.values)
baseline = np.clip(baseline, -5, 5)
baseline_values = np.median(baseline, axis=0)
Tieni presente che non è necessario specificare una base di riferimento. In caso contrario, l'SDK utilizzerà 0 come base di riferimento per ogni valore di input previsto dal modello. Nel nostro caso d'uso di rilevamento delle frodi, è opportuno specificare una baseline, come faremo di seguito:
input_name = list(metadata['inputs'])[0]
model_builder.set_numeric_metadata(input_name, input_baselines=[baseline_values.tolist()], index_feature_mapping=df.columns.tolist()[:6])
model_builder.save_metadata(model_dir)
L'esecuzione del metodo save_metadata() riportato sopra ha creato un file denominato explanation_metadata.json nella directory del nostro modello. Nel notebook, vai alla directory fraud_model/ per verificare che il file sia stato creato. Contiene i metadati che l'SDK utilizzerà per generare le attribuzioni delle funzionalità.
Passaggio 4: ottenere spiegazioni del modello
Ora possiamo ottenere le attribuzioni delle funzionalità per i singoli esempi. Per farlo, creiamo prima un riferimento locale al nostro modello utilizzando l'SDK:
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig()
)
Successivamente, otteniamo previsioni e spiegazioni sul nostro modello da una transazione di esempio che deve essere classificata come fraudolenta:
fraud_example = [0.722,0.139,-0.114,-0.258,-0.271,-0.305]
response = local_model.explain([{input_name: fraud_example}])
response[0].visualize_attributions()
L'esecuzione di questo comando dovrebbe creare una visualizzazione simile alla seguente:
In questo esempio, il saldo iniziale dell'account prima della transazione è stato l'indicatore di frode più importante, che ha aumentato la previsione del nostro modello rispetto alla baseline di oltre 0,5. L'importo della transazione, il saldo risultante nell'account di destinazione e il passaggio sono stati i successivi indicatori più importanti. Nel set di dati, lo "step" rappresenta un'unità di tempo (1 step corrisponde a 1 ora). I valori di attribuzione possono anche essere negativi.
L'"errore di approssimazione" stampato sopra le visualizzazioni ti consente di sapere quanto puoi fidarti della spiegazione. In genere, un errore superiore al 5% indica che potresti non essere in grado di fare affidamento sulle attribuzioni delle funzionalità. Ricorda che le spiegazioni sono valide solo in base ai dati di addestramento e al modello che hai utilizzato. Migliorare i dati di addestramento, il modello o provare una baseline del modello diversa può ridurre l'errore di approssimazione.
Potresti anche ridurre questo errore aumentando il numero di passaggi utilizzati nel metodo di spiegazione. Puoi modificare questo valore con l'SDK aggiungendo un parametro path_count alla configurazione della spiegazione (il valore predefinito è 10 se non lo specifichi):
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)
Con Explainable AI puoi fare molto di più con questo modello. Ecco alcune idee:
- Invio di molti esempi al nostro modello e calcolo della media dei valori di attribuzione per verificare se alcune caratteristiche sono più importanti in generale. Potremmo utilizzare queste informazioni per migliorare il nostro modello e potenzialmente rimuovere le funzionalità non importanti
- Individuare i falsi positivi che il nostro modello segnala come frodi, ma che sono transazioni non fraudolente, ed esaminare i relativi valori di attribuzione
- Utilizza una base di riferimento diversa e scopri in che modo influisce sui valori di attribuzione
🎉 Congratulazioni! 🎉
Hai imparato a tenere conto dei dati non bilanciati, ad addestrare un modello TensorFlow per rilevare le transazioni fraudolente e a utilizzare l'SDK Explainable AI per vedere su quali funzionalità si basa maggiormente il modello per fare previsioni individuali. Se vuoi, puoi fermarti qui. L'utilizzo dell'SDK all'interno di un blocco note ha lo scopo di semplificare il processo di sviluppo del modello, consentendoti di accedere alle spiegazioni prima di eseguire il deployment di un modello. Una volta creato un modello che ti soddisfa, probabilmente vorrai eseguirne il deployment per ottenere previsioni su larga scala. Se ti riconosci in questa descrizione, vai al passaggio successivo facoltativo. Se hai finito, vai al passaggio Pulizia.
7. (Facoltativo) Esegui il deployment del modello in AI Platform Prediction
In questo passaggio imparerai a eseguire il deployment del modello su AI Platform Prediction.
Passaggio 1: copia la directory del modello salvato in un bucket Cloud Storage.
Con i passaggi dell'SDK eseguiti in precedenza, hai tutto il necessario per eseguire il deployment del modello su AI Platform. Per prepararti al deployment, devi inserire gli asset SavedModel e i metadati di spiegazione in un bucket Cloud Storage che il servizio Explainable AI può leggere.
Per farlo, definiamo alcune variabili di ambiente. Compila i valori riportati di seguito con il nome del tuo progetto Google Cloud e il nome del bucket che vuoi creare (deve essere univoco a livello globale).
# Update these to your own GCP project and model
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
Ora siamo pronti per creare un bucket di archiviazione per archiviare gli asset del modello TensorFlow esportato. Quando eseguiamo il deployment del modello, AI Platform punterà a questo bucket.
Esegui questo comando gsutil dal notebook per creare un bucket:
!gsutil mb -l 'us-central1' $MODEL_BUCKET
Quindi, copia la directory del modello locale nel bucket:
!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations
Passaggio 2: esegui il deployment del modello
Successivamente, definiamo alcune variabili che utilizzeremo nei comandi di deployment:
MODEL = 'fraud_detection'
VERSION = 'v1'
model_path = MODEL_BUCKET + '/explanations'
Possiamo creare il modello con il seguente comando gcloud:
!gcloud ai-platform models create $MODEL --region=us-central1
Ora siamo pronti per eseguire il deployment della prima versione di questo modello con gcloud. Il deployment della versione richiederà circa 5-10 minuti:
!gcloud beta ai-platform versions create $VERSION \
--model $MODEL \
--origin $model_path \
--runtime-version 2.1 \
--framework TENSORFLOW \
--python-version 3.7 \
--machine-type n1-standard-4 \
--explanation-method 'sampled-shapley' \
--num-paths 10 \
--region=us-central1
Nel flag origin, trasmettiamo la posizione Cloud Storage del modello salvato e del file di metadati. Al momento, l'AI spiegabile offre due diversi metodi di spiegazione per i modelli tabellari. Qui utilizziamo Shapley campionato. Il parametro num-paths indica il numero di percorsi campionati per ogni caratteristica di input. In genere, più complesso è il modello, più passaggi di approssimazione sono necessari per raggiungere una convergenza ragionevole.
Per verificare che il deployment del modello sia stato eseguito correttamente, esegui questo comando gcloud:
!gcloud ai-platform versions describe $VERSION --model $MODEL --region=us-central1
Lo stato deve essere READY.
Passaggio 3: ottieni previsioni e spiegazioni sul modello di cui è stato eseguito il deployment
Ai fini della spiegabilità, ci interessa soprattutto spiegare i casi in cui il nostro modello prevede una frode. Inviamo al nostro modello 5 esempi di test che sono tutte transazioni fraudolente.
Utilizzeremo Google Cloud CLI per ottenere le previsioni. Esegui il seguente codice per ottenere gli indici di tutti gli esempi di frode dal nostro set di test:
fraud_indices = []
for i,val in enumerate(test_labels):
if val == 1:
fraud_indices.append(i)
Successivamente, salveremo 5 esempi nel formato previsto dal nostro modello e li scriveremo in un file:
num_test_examples = 5
instances = []
for i in range(num_test_examples):
ex = test_set[fraud_indices[i]]
instances.append({input_name: ex.tolist()})
with open('prediction.json', 'a') as outputfile:
json.dump({"instances": instances}, outputfile)
Possiamo inviare questi cinque esempi al nostro modello utilizzando gcloud:
!gcloud beta ai-platform explain \
--model=$MODEL \
--version=$VERSION \
--region='us-central1' \
--json-request=prediction.json
Nel JSON di risposta, vedrai i valori di attribuzione per ogni funzionalità in questi esempi. La chiave example_score per ogni esempio include la previsione del modello, in questo caso la probabilità percentuale che una determinata transazione sia fraudolenta.
8. 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.