1. Panoramica
In questo lab utilizzerai AI Platform Notebooks per creare e addestrare un modello per identificare le transazioni fraudolente e comprenderai 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 la 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 dall'interno del blocco note per capire perché il modello ha classificato le transazioni come fraudolente
- Esegui il deployment del modello su AI Platform con spiegazioni e ottieni previsioni e spiegazioni sul modello di cui è stato eseguito il deployment
Il costo totale per l'esecuzione di questo lab su Google Cloud è di circa $1.
2. Perché è il rilevamento di attività fraudolente?
Il rilevamento di anomalie può essere un buon candidato per il machine learning, in quanto spesso è difficile scrivere una serie di istruzioni basate su regole per identificare gli outlier nei dati. Il rilevamento delle 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, vere e proprie, non ce ne sono molte. Il 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.
- Devi spiegare i risultati: se sei alla ricerca di attività fraudolente, è probabile che tu voglia sapere perché un sistema ha segnalato un'attività fraudolenta invece di prenderne semplicemente la parola. Gli strumenti di spiegabilità possono essere d'aiuto in questo caso.
3. Configura l'ambiente
Per eseguire questo codelab, è necessario un progetto Google Cloud con fatturazione abilitata. Per creare un progetto, segui le istruzioni riportate qui.
Passaggio 1: abilita l'API Cloud AI Platform Models
Vai alla sezione Modelli di AI Platform della console Cloud e fai clic su Abilita se non è già abilitata.
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 AI Platform Notebooks
Vai alla sezione AI Platform Notebooks della 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 fai clic su Crea. Una volta creata l'istanza, seleziona Apri JupyterLab:
Quando apri l'istanza, seleziona il blocco note 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 modello. Il set di dati originale include 6,3 milioni di righe, 8000 delle quali sono transazioni fraudolente, solo lo 0,1% dell'intero set di dati.
Passaggio 1: scarica il set di dati Kaggle e leggilo con Pandas
Abbiamo reso disponibile per te il set di dati Kaggle in Google Cloud Storage. Puoi scaricarlo eseguendo questo comando gsutil nel tuo blocco note Jupyter:
!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .
Ora leggiamo il set di dati come DataFrame Pandas e visualizziamo 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: tenere conto di uno squilibrio di dati
Come accennato in precedenza, in questo momento il set di dati contiene il 99,9% di esempi non fraudolenti. Se addestriamo un modello sui dati così com'è, è probabile che il modello raggiungerà un'accuratezza del 99,9%, ipotizzando che ogni transazione non sia fraudolenta semplicemente perché il 99,9% dei dati non è un caso fraudolento.
Esistono diversi approcci per gestire i dati non bilanciati. In questo caso utilizzeremo una tecnica chiamata downsampling. Per sottocampionamento si utilizza solo una piccola percentuale della classe di maggioranza per la formazione. In questo caso, "non frode" è la classe di maggioranza poiché rappresenta il 99,9% dei dati.
Per sottocampionare il nostro set di dati, prendiamo tutti circa 8.000 esempi fraudolenti e un campione casuale di circa 31.000 casi di non frode. In questo modo, il set di dati risultante avrà il 25% di casi di frode, rispetto allo 0,1% di prima.
Per prima cosa, suddividi i dati in due DataFrame, uno per attività fraudolente e uno per non frode (lo utilizzeremo più avanti nel codelab durante il deployment del modello):
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
Quindi, scegli un campione casuale dei casi non fraudolenti. Utilizziamo lo 0,005%, perché questo ci darà una suddivisione 25/75 tra transazioni fraudolente e non fraudolente. In questo modo, puoi ricomporre i dati ed eseguire lo shuffling. 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ù bilanciato. Tuttavia, se notiamo che il nostro modello converge di circa il 75% in un'accuratezza, c'è una buona probabilità che il modello sia "non frode" in ogni caso.
Passaggio 3: suddividi i dati in set di addestramento e test
L'ultima cosa da fare prima di creare il modello è la suddivisione dei dati. Utilizzeremo una suddivisione per il test di addestramento 80/20:
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: un simulatore di denaro mobile finanziario per il rilevamento di attività fraudolente." In: The 28th European Modeling and Simulation Symposium-EMSS, Larnaca, Cipro. 2016
5. crea, addestra e valuta un modello tf.keras
Creeremo utilizzando l'API tf.keras di TensorFlow. Il codice del modello in questa sezione è basato su questo tutorial della documentazione di TensorFlow. Innanzitutto, normalizziamo i dati, quindi creeremo e addestreremo il modello utilizzando il parametro class_weight per tenere conto dello squilibrio dei dati rimanente.
Passaggio 1: normalizza i dati
Quando si addestra un modello su dati numerici, è importante normalizzare i dati, soprattutto se ogni colonna rientra in un intervallo diverso. In questo modo è possibile evitare l'esplosione delle perdite durante l'addestramento. 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 le ponderazioni delle classi
Durante il sottocampionamento dei dati, volevamo comunque mantenere un sottoinsieme delle transazioni non fraudolente in modo da non perdere informazioni su queste transazioni, motivo per cui non abbiamo reso i dati perfettamente bilanciati. Poiché il set di dati è ancora sbilanciato e ci interessa di più identificare correttamente le transazioni fraudolente, vogliamo che il nostro modello analizzi maggiormente gli esempi fraudolenti nel nostro set di dati.
Il parametro class_weight di Keras ci consente di specificare esattamente il peso che vogliamo fornire esempi per 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}
Useremo questa variabile quando addestriamo il modello nel passaggio successivo.
Passaggio 3: addestra e valuta il modello
Creeremo il modello utilizzando l'API Keras Sequential Model, che ci consente di definire il modello come uno stack di strati. Tracceremo una serie di metriche durante l'addestramento, che ci aiuteranno a capire le prestazioni del modello su 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
Successivamente, definiremo alcune variabili globali da utilizzare durante l'addestramento, oltre ad alcuni parametri relativi all'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 rendere il modello:
model = make_model()
model.summary()
Possiamo addestrare il modello con il metodo fit(), passando i parametri sopra definiti:
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'esecuzione dell'addestramento richiederà alcuni minuti.
Passaggio 4: visualizza le metriche del modello
Ora che abbiamo un modello addestrato, vediamo le prestazioni del modello tracciando varie metriche durante le epoche 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 saranno esattamente gli stessi):
Passaggio 5: stampa una matrice di confusione
Una matrice di confusione è un buon modo per visualizzare le prestazioni del modello nel set di dati di test. Per ogni classe, verrà mostrata la percentuale di esempi di test che il nostro modello ha previsto in modo corretto ed errato. Scikit-Learn include alcune utilità per creare e tracciare matrici di confusione, che le utilizzeremo qui.
All'inizio del blocco note abbiamo importato l'utilità confusion_matrix. Per utilizzarlo, creeremo prima un elenco delle previsioni del nostro modello. Qui arrotondiamo 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 per inserire questa informazione nel metodo confusion_matrix, insieme alle etichette basate su dati empirici reali:
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
Questo ci mostra i numeri assoluti delle previsioni corrette e non corrette del modello sul nostro set di test. Il numero in alto a sinistra mostra quanti esempi del nostro test hanno impostato il modello correttamente previsto come non fraudolento. Il numero in basso a destra mostra quante sono state previste correttamente come fraudolente (questo numero ci interessa soprattutto). Puoi vedere che ha previsto correttamente la maggior parte dei campioni per ogni classe.
Per semplificare la visualizzazione, abbiamo adattato la funzione plot_confusion_matrix dei documenti di Scikit Learn. Definisci questa 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 dal nostro modello. Stiamo impostando normalize su True qui in modo che la matrice di confusione mostri il numero di previsioni corrette ed errate in percentuale:
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
Dovresti vedere una schermata simile a questa (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'attenzione in questo lab non è sulla qualità del modello: se esegui il deployment di un modello di rilevamento di attività fraudolente in produzione, è probabile che tu voglia una precisione superiore all'85% sulla classe delle frodi. L'obiettivo di questo lab è illustrarti gli strumenti per spiegare i modelli addestrati su set di dati sbilanciati.
Poi useremo 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 modello. È preinstallato nelle istanze blocco note di Tensorflow AI Platform. Tieni presente che lo abbiamo importato nel nostro blocco note all'inizio del lab. Con l'SDK, possiamo ottenere 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 e quindi indirizzeremo l'SDK agli asset del modello salvati per ottenere spiegazioni.
Passaggio 1: esporta il modello addestrato
Per prima cosa, salviamo il modello in una directory della nostra istanza del blocco note:
model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)
Se aggiorni la visualizzazione delle cartelle nella barra laterale sinistra del blocco note, dovresti vedere una nuova directory denominata fraud_model/ creata.
Passaggio 2: recupera i metadati della spiegazione con l'SDK
Successivamente, indirizzeremo l'SDK Explainable AI alla directory corrispondente. In questo modo verranno generati i metadati necessari per ottenere le spiegazioni del modello. Il metodo get_metadata() mostra i metadati dedotti dall'SDK dal tuo modello, come i nomi di input:
model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)
La spiegabilità ci aiuta a rispondere alla domanda: "Perché il nostro modello pensava che si trattasse di una frode?"
Passaggio 3: specifica la base di riferimento 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 particolare caratteristica ha influito sulla previsione. Supponiamo che l'importo di una particolare transazione abbia portato il nostro modello ad aumentare la probabilità di frode prevista dello 0,2%. Potresti pensare "0,2% rispetto a cosa??". Questo ci porta al concetto di base di riferimento.
La base di riferimento per il nostro modello è essenzialmente ciò con cui viene confrontato. Selezioniamo il valore di riferimento per ogni caratteristica del nostro modello e la previsione di base diventa di conseguenza il valore previsto dal modello quando le caratteristiche sono impostate alla base di riferimento.
La scelta di una base di riferimento dipende dall'attività di previsione che stai risolvendo. Per le caratteristiche numeriche, è comune utilizzare il valore mediano di ciascuna caratteristica nel set di dati come riferimento. Nel caso del rilevamento di attività fraudolente, tuttavia, non è esattamente ciò che vogliamo. Ci interessa soprattutto spiegare i casi in cui il nostro modello etichetta una transazione come fraudolenta. Ciò significa che il caso di riferimento con cui vogliamo confrontare sono le transazioni non fraudolente.
Per tenere conto di ciò, utilizzeremo i valori mediani delle transazioni non fraudolente nel nostro set di dati come riferimento. Possiamo ottenere la mediana utilizzando il DataFrame not_fraud_sample estratto in precedenza e scalandolo in modo che corrisponda agli input previsti dal 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 un valore di riferimento. In caso contrario, l'SDK utilizzerà 0 come base per ogni valore di input previsto dal modello. Nel nostro caso d'uso per il rilevamento di attività fraudolente, ha senso specificare una base di riferimento, che noi eseguiremo 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)
Utilizzando il metodo save_metadata() indicato sopra, è stato creato un file nella directory del modello denominato explanation_metadata.json. Nel blocco note, passa alla directory fraud_model/ per confermare che il file è stato creato. Contiene i metadati che l'SDK utilizzerà per generare le attribuzioni delle caratteristiche.
Passaggio 4: recupera le spiegazioni del modello
Ora siamo pronti per ottenere attribuzioni delle caratteristiche su singoli esempi. Per farlo, creeremo innanzitutto 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()
)
Ora raccogliamo previsioni e spiegazioni sul nostro modello a partire 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 il più grande indicatore di attività fraudolenta, facendo aumentare la previsione del nostro modello rispetto alla base di riferimento di oltre 0,5. L'importo della transazione, il saldo risultante nell'account di destinazione e il passaggio sono stati i principali indicatori successivi. Nel set di dati, il "step" rappresenta un'unità di tempo (1 passo equivale a 1 ora). Anche i valori di attribuzione possono essere negativi.
L'"errore di approssimazione" stampato sopra le visualizzazioni ti consente di capire quanto ti fidi della spiegazione. In genere, un errore superiore al 5% significa che potresti non essere in grado di fare affidamento sulle attribuzioni delle caratteristiche. Ricorda che la qualità delle tue spiegazioni dipende dai dati di addestramento e dal modello che hai utilizzato. Migliorare i dati di addestramento o il modello oppure provare una base di riferimento diversa per il modello può ridurre l'errore di approssimazione.
Potresti anche riuscire a ridurre questo errore aumentando il numero di passaggi utilizzati nel metodo di spiegazione. Per cambiare questo comportamento con l'SDK, aggiungi 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)
)
C'è molto altro che puoi fare con Explainable AI su questo modello. Ecco alcune idee:
- Invio di molti esempi al modello e della media dei valori di attribuzione per verificare se determinate caratteristiche sono più importanti nel complesso. In questo modo potremmo migliorare il modello e rimuovere potenzialmente funzionalità non importanti.
- Individuare i falsi positivi che il nostro modello segnala come attività fraudolente, ma che sono transazioni non fraudolente ed esaminare i relativi valori di attribuzione.
- Usa una base di riferimento diversa e scopri come questo influisce sui valori dell'attribuzione
🎉 Complimenti! 🎉
Hai imparato a tenere conto di uno squilibrio di dati, ad addestrare un modello TensorFlow per rilevare transazioni fraudolente e a utilizzare l'SDK Explainable AI per capire su quali funzionalità si basa maggiormente il tuo modello per fare previsioni individuali. Se vuoi, puoi fermarti qui. L'utilizzo dell'SDK in un blocco note ha lo scopo di semplificare il processo di sviluppo del modello, dando accesso alle spiegazioni prima del deployment di un modello. È molto probabile che, una volta creato un modello che ti soddisfa, voglia eseguirne il deployment per ottenere previsioni su larga scala. Se questo è il tuo caso, vai al passaggio successivo facoltativo. Al termine, vai al passaggio Pulizia.
7. (Facoltativo) Eseguire il deployment del modello su AI Platform Prediction
In questo passaggio, imparerai come eseguire il deployment del modello in AI Platform Prediction.
Passaggio 1: copia la directory del modello salvato in un bucket Cloud Storage.
Con i passaggi per l'SDK che abbiamo eseguito in precedenza, hai tutto ciò di cui hai bisogno per eseguire il deployment del tuo modello su AI Platform. Per prepararti al deployment, dovrai inserire gli asset SavedModel e i metadati della spiegazione in un bucket Cloud Storage che il servizio Explainable AI possa leggere.
A questo scopo, definiamo alcune variabili di ambiente. Compila i valori seguenti 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 è tutto pronto per creare un bucket di archiviazione in cui archiviare gli asset del modello esportati da TensorFlow. Puntiamo AI Platform a questo bucket durante il deployment del modello.
Esegui questo comando gsutil dal blocco note 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, definiremo alcune variabili che utilizzeremo nei nostri 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 è tutto pronto per 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, passiamo la posizione di Cloud Storage del modello e del file di metadati salvati. Explainable AI dispone attualmente di due diversi metodi di spiegazione per i modelli tabulari. In questo caso utilizziamo il valore di Shapley campionato. Il parametro num-paths indica il numero di percorsi campionati per ogni caratteristica di input. In genere, più il modello è complesso, maggiori sono i passaggi di approssimazione necessari per raggiungere una convergenza ragionevole.
Per confermare il corretto deployment del modello, esegui il comando gcloud seguente:
!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 di più spiegare i casi in cui il nostro modello prevede attività fraudolente. Invieremo 5 esempi di test al nostro modello che sono tutte transazioni fraudolente.
Utilizzeremo Google Cloud CLI per ottenere le previsioni. Esegui questo codice per ottenere gli indici di tutti gli esempi di attività fraudolente dal nostro set di test:
fraud_indices = []
for i,val in enumerate(test_labels):
if val == 1:
fraud_indices.append(i)
A questo punto salveremo cinque esempi nel formato previsto dal 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 file JSON della risposta, vedrai i valori di attribuzione per ogni caratteristica in questi esempi. La chiave example_score per ogni esempio include la previsione del modello, in questo caso la percentuale di probabilità che una determinata transazione sia fraudolenta.
8. 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.