1. Présentation
Dans cet atelier, vous allez utiliser AI Platform Notebooks pour créer et entraîner un modèle permettant d'identifier les transactions frauduleuses, et comprendre les prédictions du modèle avec le SDK Explainable AI. La détection des fraudes est un type de détection d'anomalies spécifique aux services financiers. Elle présente des défis intéressants pour les modèles de ML: des ensembles de données intrinsèquement déséquilibrés et la nécessité d'expliquer les résultats d'un modèle.
Objectifs de l'atelier
Vous allez apprendre à effectuer les opérations suivantes :
- Gérer les ensembles de données déséquilibrés
- Créer et évaluer un modèle de détection de fraude à l'aide de tf.keras dans AI Platform Notebooks
- Utiliser le SDK Explainable AI à partir du notebook pour comprendre pourquoi le modèle a classé les transactions comme frauduleuses
- Déployer le modèle sur AI Platform avec des explications, et obtenir des prédictions et des explications à partir du modèle déployé
Le coût total d'exécution de cet atelier sur Google Cloud est d'environ 1 $.
2. Pourquoi détecter les fraudes ?
La détection d'anomalies peut être adaptée au machine learning, car il est souvent difficile d'écrire une série d'instructions basées sur des règles pour identifier les anomalies dans les données. La détection de fraudes est un type de détection d'anomalies qui présente deux défis intéressants en matière de machine learning:
- Ensembles de données très déséquilibrés: les anomalies étant des anomalies, il n'y en a pas beaucoup. Le ML fonctionne mieux lorsque les ensembles de données sont équilibrés. Les choses peuvent donc devenir compliquées lorsque les anomalies représentent moins de 1% de vos données.
- Nécessité d'expliquer les résultats: si vous recherchez une activité frauduleuse, il est probable que vous souhaitiez savoir pourquoi un système a signalé une activité frauduleuse plutôt que de vous contenter de le croire sur parole. Les outils d'explicabilité peuvent vous y aider.
3. Configurer votre environnement
Pour suivre cet atelier de programmation, vous aurez besoin d'un projet Google Cloud Platform dans lequel la facturation est activée. Pour créer un projet, suivez ces instructions.
Étape 1: Activez l'API Cloud AI Platform Models
Accédez à la section Modèles AI Platform de Cloud Console, puis cliquez sur "Activer" si elle n'est pas déjà activée.
Étape 2: Activez l'API Compute Engine
Accédez à Compute Engine et cliquez sur Activer si ce n'est pas déjà fait. Vous en aurez besoin pour créer votre instance de notebook.
Étape 3: Créez une instance AI Platform Notebooks
Accédez à la section AI Platform Notebooks de la console Cloud, puis cliquez sur Nouvelle instance. Sélectionnez ensuite le type d'instance TensorFlow Enterprise 2.1 sans GPU:
Utilisez les options par défaut, puis cliquez sur Créer. Une fois l'instance créée, sélectionnez Ouvrir JupyterLab:
Lorsque vous ouvrez l'instance, sélectionnez le notebook Python 3 dans le lanceur:
Étape 4: Importez les packages Python
Créez une cellule et importez les bibliothèques que nous utiliserons dans cet atelier de programmation:
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. Télécharger et traiter les données
Nous allons utiliser cet ensemble de données généré de façon synthétique à partir de Kaggle pour entraîner notre modèle. L'ensemble de données d'origine comprend 6,3 millions de lignes, dont 8 000 sont des transactions frauduleuses, soit seulement 0,1% de l'ensemble de données complet.
Étape 1: Téléchargez l'ensemble de données Kaggle et lisez-le avec Pandas
Nous avons mis l'ensemble de données Kaggle à votre disposition dans Google Cloud Storage. Vous pouvez le télécharger en exécutant la commande gsutil suivante dans votre notebook Jupyter:
!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .
Lisons maintenant l'ensemble de données sous la forme d'un DataFrame Pandas et prévisualisons-le:
data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()
L'aperçu devrait ressembler à ceci:
Étape 2: Prendre en compte les données déséquilibrées
Comme indiqué ci-dessus, l'ensemble de données contient actuellement 99,9% d'exemples non frauduleux. Si nous entraînons un modèle sur les données telles quelles, il y a de fortes chances que le modèle atteigne une précision de 99,9% en devinant que chaque transaction n'est pas frauduleuse, simplement parce que 99,9% des données ne sont pas frauduleuses.
Il existe plusieurs approches pour traiter les données déséquilibrées. Nous allons utiliser une technique appelée sous-échantillonnage. Le sous-échantillonnage consiste à n'utiliser qu'un faible pourcentage de la classe majoritaire lors de l'entraînement. Dans ce cas, le terme "non frauduleux" est la classe majoritaire puisqu'elle représente 99,9% des données.
Pour sous-échantillonner notre ensemble de données, nous allons prendre environ 8 000 exemples frauduleux et un échantillon aléatoire d'environ 31 000 cas non frauduleux. Ainsi, l'ensemble de données obtenu comportera 25% de cas de fraude, contre 0,1% auparavant.
Divisez d'abord les données en deux DataFrames, un pour la fraude et un pour la non fraude (nous l'utiliserons plus tard dans l'atelier de programmation, au cours du déploiement du modèle):
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
Ensuite, prenez un échantillon aléatoire des cas non frauduleux. Nous utilisons 0,005 %, car cela nous permettra de répartir à 25h/75 les transactions frauduleuses / non frauduleuses. Cela vous permet de reconstituer les données et de les mélanger. Pour simplifier les choses, nous supprimerons également quelques colonnes que nous n'utiliserons pas pour l'entraînement:
# 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()
L'ensemble de données est désormais bien plus équilibré. Toutefois, si nous remarquons que notre modèle converge d'une justesse d'environ 75 %, il y a de fortes chances qu'il devine "non frauduleux" dans tous les cas.
Étape 3: Répartir les données en ensembles d'entraînement et en ensembles de test
La dernière chose à faire avant de créer le modèle est de diviser les données. Nous allons utiliser une répartition entraînement/test de 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 et S. L'axelsson. "PaySim: A Financial Mobile Money Simulator for Fraud Detection". Dans: The 28th European Modeling and Simulation Symposium-EMSS, Larnaca, Chypre. 2016
5. Créer, entraîner et évaluer un modèle tf.keras
Nous allons utiliser l'API tf.keras de TensorFlow pour la compilation. Le code du modèle présenté dans cette section est basé sur ce tutoriel issu de la documentation TensorFlow. Nous allons d'abord normaliser les données, puis créer et entraîner notre modèle en utilisant le paramètre class_weight pour tenir compte du déséquilibre de données restant.
Étape 1: Normalisez les données
Lorsque vous entraînez un modèle sur des données numériques, il est important de normaliser les données, surtout si chaque colonne se situe dans une plage différente. Cela peut aider à éviter l'explosion de la perte pendant l'entraînement. Nous pouvons normaliser nos données comme suit:
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)
Examinons ensuite nos données normalisées:
train_set
Étape 2: Déterminez la pondération des classes
Lors du sous-échantillonnage des données, nous souhaitions conserver un sous-ensemble des transactions non frauduleuses afin de ne pas perdre d'informations sur ces transactions. C'est pourquoi nous n'avons pas réussi à équilibrer les données. Comme l'ensemble de données est toujours déséquilibré et que nous voulons avant tout identifier correctement les transactions frauduleuses, nous voulons que notre modèle accorde plus de poids aux exemples frauduleux de notre ensemble de données.
Le paramètre Keras class_weight nous permet de spécifier précisément la pondération que nous voulons donner aux exemples de chaque classe, en fonction de leur fréquence d'apparition dans l'ensemble de données:
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}
Nous utiliserons cette variable lors de l'entraînement du modèle à l'étape suivante.
Étape 3: Entraînez et évaluez le modèle
Nous créerons notre modèle à l'aide de l'API Keras Sequential Model, qui nous permet de définir notre modèle sous la forme d'une pile de couches. Nous allons suivre un certain nombre de métriques pendant l'entraînement, ce qui nous aidera à comprendre les performances de notre modèle sur chaque classe de l'ensemble de données.
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
Ensuite, nous définirons quelques variables globales à utiliser pendant l'entraînement, ainsi que des paramètres d'arrêt prématuré.
EPOCHS = 100
BATCH_SIZE = 512
early_stopping = tf.keras.callbacks.EarlyStopping(
monitor='val_auc',
verbose=1,
patience=10,
mode='max',
restore_best_weights=True)
Enfin, nous allons appeler la fonction que nous avons définie ci-dessus pour créer notre modèle:
model = make_model()
model.summary()
Nous pouvons entraîner notre modèle avec la méthode fit(), en transmettant les paramètres définis ci-dessus:
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'entraînement prend quelques minutes.
Étape 4: Visualiser les métriques du modèle
Maintenant que nous disposons d'un modèle entraîné, voyons ses performances en traçant différentes métriques au cours de nos époques d'entraînement:
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)
Vos graphiques doivent se présenter comme suit (mais ils ne seront pas exactement identiques):
Étape 5: Imprimez une matrice de confusion
Une matrice de confusion est un bon moyen de visualiser les performances d'un modèle dans l'ensemble de données de test. Pour chaque classe, nous affichons le pourcentage d'exemples de test que notre modèle a prédits correctement et de manière incorrecte. scikit-learn dispose de quelques utilitaires pour créer et tracer des matrices de confusion, que nous allons utiliser ici.
Au début du notebook, nous avons importé l'utilitaire confusion_matrix. Pour l'utiliser, nous allons d'abord créer une liste des prédictions de notre modèle. Ici, nous arrondissons les valeurs renvoyées par notre modèle de sorte que cette liste corresponde à notre liste d'étiquettes de vérité terrain:
predicted = model.predict(test_set)
y_pred = []
for i in predicted.tolist():
y_pred.append(int(round(i[0])))
Nous sommes maintenant prêts à alimenter la méthode confusion_matrix avec nos étiquettes de vérité terrain:
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
Nous obtenons le nombre absolu des prédictions correctes et incorrectes de notre modèle sur notre ensemble de test. Le nombre en haut à gauche indique le nombre d'exemples de notre ensemble de test que notre modèle a correctement prédits comme non frauduleux. Le nombre en bas à droite indique combien d'entre eux ont été correctement prédits comme frauduleux (ce chiffre est le plus important pour nous). Vous pouvez constater qu'elle a correctement prédit la majorité des échantillons pour chaque classe.
Pour faciliter la visualisation, nous avons adapté la fonction plot_confusion_matrix de la documentation Scikit-learn. Définissez cette fonction ici:
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')
Et créer le tracé en lui transmettant les données de notre modèle. Nous définissons normalize sur True afin que la matrice de confusion affiche le nombre de prédictions correctes et incorrectes sous forme de pourcentages:
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
Le résultat devrait ressembler à ceci (les chiffres exacts peuvent varier):
Ici,nous pouvons voir que notre modèle a correctement prédit environ 85% des 1 594 transactions frauduleuses issues de notre ensemble de test. Notez que cet atelier n'est pas axé sur la qualité du modèle. Si vous déployez un modèle de détection des fraudes en production, vous souhaiterez probablement obtenir une précision supérieure à 85% pour la classe de fraude. L'objectif de cet atelier est de vous présenter les outils permettant d'expliquer les modèles entraînés sur des ensembles de données déséquilibrés.
Nous allons ensuite utiliser le SDK Explainable AI pour identifier les fonctionnalités sur lesquelles notre modèle s'appuie pour effectuer ces prédictions.
6. Utiliser le SDK Explainable AI
Le SDK Explainable AI fournit des méthodes utilitaires pour obtenir des explications sur votre modèle. Il est préinstallé dans les instances de notebook TensorFlow AI Platform. Notez que nous l'avons importé dans notre notebook au début de l'atelier. Avec le SDK, nous pouvons obtenir des attributions de caractéristiques à partir de notre modèle dans l'instance de notebook, ce qui signifie que nous n'avons pas besoin de déployer notre modèle dans le cloud pour l'utiliser.
Dans cette section, nous allons exporter le modèle que nous venons d'entraîner en tant que SavedModel Tensorflow, puis pointer le SDK vers les ressources de modèle enregistrées pour obtenir des explications.
Étape 1: Exportez le modèle entraîné
Commençons par enregistrer le modèle dans un répertoire de notre instance de notebook:
model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)
Si vous actualisez la vue du dossier dans la barre latérale gauche de votre notebook, vous devriez voir un nouveau répertoire appelé fraud_model/ créé.
Étape 2: Obtenez des métadonnées d'explications avec le SDK
Nous allons maintenant pointer le SDK Explainable AI vers ce répertoire. Cette opération générera les métadonnées nécessaires pour obtenir des explications sur le modèle. La méthode get_metadata() affiche les métadonnées que le SDK déduit de votre modèle, comme les noms d'entrée:
model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)
L'explicabilité nous aide à répondre à la question suivante : "Pourquoi notre modèle a-t-il pensé qu'il s'agissait d'une fraude ?"
Étape 3: Spécifier la référence de notre modèle
Pour les données tabulaires, le service Explainable AI renvoie les valeurs d'attribution pour chaque caractéristique. Ces valeurs indiquent l'impact d'une caractéristique particulière sur la prédiction. Imaginons que le montant d'une transaction spécifique pousse notre modèle à augmenter sa probabilité de fraude de 0,2%. Vous pensez peut-être à "0,2% par rapport à quoi ??". Cela nous amène au concept de référence.
La référence de notre modèle est essentiellement ce avec laquelle il est comparé. Nous sélectionnons la valeur de référence pour chaque caractéristique de notre modèle. Par conséquent, la prédiction de référence devient la valeur prédite par notre modèle lorsque les caractéristiques sont définies à cette valeur de référence.
Le choix d'une référence dépend de la tâche de prédiction à résoudre. Pour les caractéristiques numériques, il est courant d'utiliser la valeur médiane de chaque caractéristique de votre ensemble de données comme référence. Toutefois, dans le cas de la détection de fraudes, ce n'est pas exactement ce que nous voulons. Nous souhaitons avant tout expliquer les cas dans lesquels notre modèle identifie une transaction comme frauduleuse. Cela signifie que le cas de référence par rapport auquel nous voulons effectuer la comparaison concerne les transactions non frauduleuses.
Pour tenir compte de cela, nous allons utiliser comme référence les valeurs médianes des transactions non frauduleuses de notre ensemble de données. Nous pouvons obtenir la médiane en utilisant le DataFrame not_fraud_sample que nous avons extrait ci-dessus et en l'adaptant aux entrées attendues de notre modèle:
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)
Notez qu'il n'est pas nécessaire de spécifier une référence. Si nous ne le faisons pas, le SDK utilisera 0 comme référence pour chaque valeur d'entrée attendue par notre modèle. Dans notre cas d'utilisation de détection de fraudes, il est judicieux de spécifier une référence. Nous allons le faire ci-dessous:
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'exécution de la méthode save_metadata() ci-dessus a créé un fichier appelé explanation_metadata.json dans le répertoire de notre modèle. Dans votre notebook, accédez au répertoire fraude_model/ pour vérifier que le fichier a bien été créé. Il contient des métadonnées que le SDK utilisera pour générer des attributions de caractéristiques.
Étape 4: Obtenez des explications sur le modèle
Nous sommes maintenant prêts à obtenir des attributions de caractéristiques pour des exemples individuels. Pour ce faire, nous allons d'abord créer une référence locale à notre modèle à l'aide du SDK:
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig()
)
Maintenant, obtenons des prédictions et des explications sur notre modèle à partir d'un exemple de transaction qui devrait être classée comme frauduleuse:
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'exécution de cette commande devrait créer une visualisation semblable à celle-ci:
Dans cet exemple, le solde initial du compte avant la transaction était le principal indicateur de fraude.La prédiction de notre modèle a ainsi augmenté de plus de 0, 5 par rapport à la référence. Le montant de la transaction, le solde obtenu dans le compte de destination et l'étape ont été les prochains indicateurs importants. Dans l'ensemble de données, l'étape représente une unité de temps (1 pas correspond à 1 heure). Les valeurs d'attribution peuvent également être négatives.
L'erreur d'approximation qui est imprimée au-dessus des visualisations vous permet de savoir à quel point vous pouvez faire confiance à l'explication. En général, une erreur supérieure à 5% signifie que vous ne pourrez peut-être pas vous fier aux attributions de caractéristiques. N'oubliez pas que la qualité de vos explications dépend des données d'entraînement et du modèle que vous avez utilisés. Si vous améliorez vos données d'entraînement ou votre modèle, ou si vous essayez une autre référence pour le modèle, vous pouvez réduire l'erreur d'approximation.
Vous pouvez aussi réduire cette erreur en augmentant le nombre d'étapes utilisées dans votre méthode d'explication. Vous pouvez modifier cela avec le SDK en ajoutant un paramètre path_count à votre configuration d'explication (la valeur par défaut est 10 si vous ne spécifiez pas cette option):
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)
Explainable AI vous permet d'effectuer bien d'autres actions sur ce modèle. Voici quelques idées:
- Nous envoyons de nombreux exemples à notre modèle et calculons la moyenne des valeurs d'attribution pour voir si certaines caractéristiques sont globalement plus importantes. Nous pourrions l'utiliser pour améliorer notre modèle et potentiellement supprimer les caractéristiques qui ne sont pas importantes
- Trouver les faux positifs que notre modèle signale comme des transactions frauduleuses, mais qu'il s'agit de transactions non frauduleuses, et examiner leurs valeurs d'attribution
- Utilisez une référence différente et observez l'impact sur les valeurs d'attribution
🎉 Félicitations ! 🎉
Vous avez appris à tenir compte des données déséquilibrées, à entraîner un modèle TensorFlow à détecter les transactions frauduleuses et à utiliser le SDK Explainable AI pour identifier les fonctionnalités les plus utilisées par votre modèle pour réaliser des prédictions individuelles. Vous pouvez vous arrêter ici si vous le souhaitez. L'utilisation du SDK dans un notebook vise à simplifier le processus de développement de votre modèle en vous donnant accès à des explications avant de le déployer. Une fois que vous avez créé un modèle qui vous convient, il est probable que vous souhaitiez le déployer pour obtenir des prédictions à grande échelle. Si c'est votre cas, passez à l'étape suivante facultative. Si vous avez terminé, passez à l'étape Nettoyage.
7. Facultatif: Déployer le modèle dans AI Platform Prediction
Au cours de cette étape, vous allez apprendre à déployer votre modèle sur AI Platform Prediction.
Étape 1: Copiez le répertoire de votre modèle enregistré dans un bucket Cloud Storage.
Grâce aux étapes précédemment exécutées pour le SDK, vous disposez de tout ce dont vous avez besoin pour déployer votre modèle sur AI Platform. Pour préparer le déploiement, vous devez placer vos éléments SavedModel et vos métadonnées d'explications dans un bucket Cloud Storage que le service Explainable AI peut lire.
Pour ce faire, nous allons définir des variables d'environnement. Renseignez les valeurs ci-dessous avec le nom de votre projet Google Cloud et le nom du bucket que vous souhaitez créer (ils doivent être uniques).
# Update these to your own GCP project and model
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
Nous sommes maintenant prêts à créer un bucket de stockage pour stocker les ressources de modèle TensorFlow exportées. Nous indiquerons à AI Platform ce bucket lorsque nous déploierons le modèle.
Exécutez la commande gsutil suivante depuis votre notebook pour créer un bucket:
!gsutil mb -l 'us-central1' $MODEL_BUCKET
Ensuite, copiez le répertoire de votre modèle local dans ce bucket:
!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations
Étape 2: Déployez le modèle
Nous allons maintenant définir certaines variables que nous utiliserons dans nos commandes de déploiement:
MODEL = 'fraud_detection'
VERSION = 'v1'
model_path = MODEL_BUCKET + '/explanations'
Nous pouvons créer le modèle à l'aide de la commande gcloud suivante:
!gcloud ai-platform models create $MODEL --region=us-central1
Nous sommes maintenant prêts à déployer la première version de ce modèle avec gcloud. Le déploiement de la version prend environ 5 à 10 minutes:
!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
Dans l'option origin, nous transmettons l'emplacement Cloud Storage du modèle enregistré et du fichier de métadonnées. Explainable AI propose actuellement deux méthodes d'explication différentes pour les modèles tabulaires. Ici, nous utilisons
Sampled Shapley. Le paramètre num-paths indique le nombre de chemins échantillonnés pour chaque caractéristique d'entrée. En règle générale, plus le modèle est complexe, plus le nombre d'étapes d'approximation nécessaires pour atteindre une convergence raisonnable est important.
Pour vérifier que votre modèle a bien été déployé, exécutez la commande gcloud suivante:
!gcloud ai-platform versions describe $VERSION --model $MODEL --region=us-central1
L'état doit être READY.
Étape 3: Obtenez des prédictions et des explications à partir du modèle déployé
Pour l'explicabilité, nous tenons surtout à expliquer les cas où notre modèle prédit une fraude. Nous allons envoyer à notre modèle cinq exemples de transactions frauduleuses.
Nous utiliserons la Google Cloud CLI pour obtenir des prédictions. Exécutez le code suivant pour obtenir les index de tous les exemples de fraude de notre ensemble de test:
fraud_indices = []
for i,val in enumerate(test_labels):
if val == 1:
fraud_indices.append(i)
Nous allons ensuite enregistrer cinq exemples au format attendu par notre modèle, puis les écrire dans un fichier:
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)
Nous pouvons envoyer ces cinq exemples à notre modèle à l'aide de gcloud:
!gcloud beta ai-platform explain \
--model=$MODEL \
--version=$VERSION \
--region='us-central1' \
--json-request=prediction.json
Dans la réponse JSON, vous verrez les valeurs d'attribution de chaque caractéristique de ces exemples. La clé example_score pour chaque exemple inclut la prédiction du modèle, qui correspond ici à la probabilité (en pourcentage) qu'une transaction particulière soit frauduleuse.
8. Nettoyage
Si vous souhaitez continuer à utiliser cet ordinateur portable, nous vous recommandons de le désactiver lorsqu'il n'est pas utilisé. À partir de l'interface utilisateur de Notebooks dans Cloud Console, sélectionnez le notebook, puis cliquez sur Arrêter:
Si vous souhaitez supprimer toutes les ressources que vous avez créées au cours de cet atelier, il vous suffit de supprimer l'instance de notebook au lieu de l'arrêter.
À l'aide du menu de navigation de Cloud Console, accédez à "Storage" (Stockage) et supprimez les deux buckets que vous avez créés pour stocker les ressources de votre modèle.