1. Présentation
Dans cet atelier, vous allez utiliser des notebooks AI Platform 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 avec tf.keras dans AI Platform Notebooks
- Utilisez le SDK Explainable AI dans le 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 sur le modèle déployé
Le coût total d'exécution de cet atelier sur Google Cloud est d'environ 1 $.
2. Pourquoi la détection des fraudes est-elle importante ?
La détection des anomalies peut être un bon candidat pour le machine learning, car il est souvent difficile d'écrire une série d'instructions basées sur des règles pour identifier les valeurs aberrantes dans les données. La détection des fraudes est un type de détection d'anomalies. Elle 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 sont, eh bien, des anomalies. Elles sont donc peu nombreuses. Le ML fonctionne mieux lorsque les ensembles de données sont équilibrés. Les choses peuvent donc se compliquer lorsque les valeurs aberrantes représentent moins de 1 % de vos données.
- Besoin d'expliquer les résultats : si vous recherchez une activité frauduleuse, vous voudrez probablement savoir pourquoi un système a signalé quelque chose comme frauduleux plutôt que de le croire sur parole. Les outils d'explicabilité peuvent vous aider.
3. Configurez 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 la console Cloud, 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 des données
Nous utiliserons cet ensemble de données générées de manière synthétique 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 à peine 0,1 % de l'ensemble des données.
Étape 1 : Téléchargez l'ensemble de données Kaggle et lisez-le avec Pandas
Nous avons mis à votre disposition l'ensemble de données Kaggle 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 .
Ensuite, lisons l'ensemble de données en tant que DataFrame Pandas et prévisualisons-le :
data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()
L'aperçu doit ressembler à ceci :
Étape 2 : Tenir compte des 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 qu'il atteigne une précision de 99,9 % en devinant que chaque transaction n'est pas frauduleuse, simplement parce que 99,9 % des données sont des cas non frauduleux.
Il existe différentes approches pour traiter les données déséquilibrées. Ici, nous allons utiliser une technique appelée sous-échantillonnage. Le sous-échantillonnage consiste à n'utiliser qu'un petit pourcentage de la classe majoritaire lors de l'entraînement. Dans ce cas, "non-frauduleux" est la classe majoritaire, car elle représente 99,9 % des données.
Pour sous-échantillonner notre ensemble de données, nous allons prendre la totalité des ~8 000 exemples de fraude et un échantillon aléatoire de ~31 000 cas de non-fraude. L'ensemble de données obtenu comportera ainsi 25 % de cas de fraude, contre 0,1 % auparavant.
Tout d'abord, divisez les données en deux DataFrames : un pour les fraudes et un pour les non-fraudes (nous les utiliserons plus tard dans l'atelier de programmation lorsque nous déploierons notre modèle) :
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
Ensuite, prélevez un échantillon aléatoire des cas non frauduleux. Nous utilisons 0,005 % pour obtenir une répartition de 25/75 entre les transactions frauduleuses et non frauduleuses. Vous pouvez ensuite regrouper les données et les mélanger. Pour simplifier les choses, nous allons également supprimer 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()
Nous disposons désormais d'un ensemble de données beaucoup plus équilibré. Toutefois, si nous constatons que notre modèle converge autour d'une précision de 75 %, il y a de fortes chances qu'il devine "non frauduleux" dans tous les cas.
Étape 3 : Divisez les données en ensembles d'entraînement et de test
La dernière chose à faire avant de créer notre modèle est de diviser nos données. Nous allons utiliser une division 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, and S. Axelsson. "PaySim : un simulateur d'argent mobile financier pour la détection des fraudes". In: The 28th European Modeling and Simulation Symposium-EMSS, Larnaca, Cyprus. 2016
5. Créer, entraîner et évaluer un modèle tf.keras
Nous allons créer notre modèle à l'aide de l'API tf.keras de TensorFlow. Le code du modèle de cette section s'appuie sur ce tutoriel 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, en particulier si chaque colonne se trouve dans une plage différente. Cela peut aider à éviter que la perte n'explose 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)
Prévisualisons ensuite nos données normalisées :
train_set
Étape 2 : Déterminez les pondérations des classes
Lorsque nous avons sous-échantillonné les données, nous avons quand même voulu 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 rendu les données parfaitement équilibrées. Étant donné que l'ensemble de données est toujours déséquilibré et que nous souhaitons avant tout identifier correctement les transactions frauduleuses, nous voulons que notre modèle accorde plus d'importance aux exemples de fraude dans notre ensemble de données.
Le paramètre class_weight de Keras nous permet de spécifier exactement le poids que nous voulons attribuer aux exemples de chaque classe, en fonction de leur fréquence 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 lorsque nous entraînerons notre modèle à l'étape suivante.
Étape 3 : Entraîner et évaluer le modèle
Nous allons créer notre modèle à l'aide de l'API Keras Sequential Model, qui nous permet de définir notre modèle comme une pile de couches. Nous allons suivre un certain nombre de métriques pendant l'entraînement. Elles nous aideront à comprendre les performances de notre modèle pour chaque classe de notre 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 certains paramètres d'arrêt précoce.
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 appellerons 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 prendra quelques minutes.
Étape 4 : Visualisez les métriques du modèle
Maintenant que nous avons un modèle entraîné, voyons comment il s'est comporté en traçant différentes métriques tout au long 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 ressembler à ce qui suit (mais ne seront pas exactement identiques) :
Étape 5 : Imprimer une matrice de confusion
Une matrice de confusion est un bon moyen de visualiser les performances de notre modèle sur l'ensemble de données de test. Pour chaque classe, il nous indiquera le pourcentage d'exemples de test que notre modèle a prédits correctement et incorrectement. Scikit-learn propose des utilitaires pour créer et représenter des matrices de confusion, que nous allons utiliser ici.
Au début de notre 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 allons arrondir les valeurs renvoyées par notre modèle afin 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 à l'intégrer à la méthode confusion_matrix, ainsi qu'à nos étiquettes de vérité terrain :
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
Elle nous indique le nombre absolu de 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 le nombre de transactions que le modèle a correctement identifiées comme frauduleuses (c'est ce nombre qui nous intéresse le plus). Vous pouvez constater qu'il a prédit correctement la majorité des échantillons pour chaque classe.
Pour faciliter la visualisation, nous avons adapté la fonction plot_confusion_matrix à partir 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')
Créez ensuite le graphique en lui transmettant les données de notre modèle. Nous définissons ici normalize sur True afin que la matrice de confusion affiche le nombre de prédictions correctes et incorrectes sous forme de pourcentage :
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
Le résultat devrait se présenter comme suit (les chiffres exacts peuvent varier) :
Ici,nous pouvons voir que notre modèle a correctement prédit environ 85 % des 1 594 transactions frauduleuses de notre ensemble de test. Notez que cet atelier ne se concentre pas 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 "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 comprendre sur quelles caractéristiques notre modèle s'appuie pour faire 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 notebooks TensorFlow AI Platform. Notez que nous l'avons importé dans notre notebook au début de l'atelier. Grâce au 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 indiquer au SDK les ressources de notre modèle enregistré pour obtenir des explications.
Étape 1 : Exportez le modèle entraîné
Commençons par enregistrer notre 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 l'affichage des dossiers dans la barre latérale de gauche de votre notebook, vous devriez voir un nouveau répertoire nommé fraud_model/.
Étape 2 : Obtenez les métadonnées d'explication avec le SDK
Ensuite, nous allons pointer le SDK Explainable AI vers ce répertoire. Cette opération génère 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 considéré 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 fonctionne en renvoyant des valeurs d'attribution pour chaque caractéristique. Ces valeurs indiquent dans quelle mesure une caractéristique particulière a affecté la prédiction. Supposons que le montant d'une transaction spécifique ait entraîné une augmentation de 0,2 % de la probabilité de fraude prédite par notre modèle. Vous vous demandez 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 à quoi il se compare. Nous sélectionnons la valeur de référence pour chaque caractéristique de notre modèle. La prédiction de référence devient alors la valeur que notre modèle prédit lorsque les caractéristiques sont définies sur la référence.
Le choix d'une référence dépend de la tâche de prédiction que vous résolvez. 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 des fraudes, ce n'est pas exactement ce que nous voulons. Nous nous efforçons avant tout d'expliquer les cas où notre modèle identifie une transaction comme frauduleuse. Cela signifie que le cas de référence que nous voulons comparer est celui des transactions non frauduleuses.
Pour en tenir compte, nous utiliserons les valeurs médianes des transactions non frauduleuses de notre ensemble de données comme référence. Nous pouvons obtenir la médiane en utilisant le DataFrame not_fraud_sample que nous avons extrait ci-dessus et en la mettant à l'échelle pour qu'elle corresponde 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. Sinon, 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 la détection des fraudes, il est logique de spécifier une référence, ce que nous ferons 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 nommé explanation_metadata.json dans le répertoire de notre modèle. Dans votre notebook, accédez au répertoire fraud_model/ pour vérifier que le fichier a été créé. Il contient des métadonnées que le SDK utilisera pour générer des attributions de caractéristiques.
Étape 4 : Obtenir des explications sur le modèle
Nous sommes maintenant prêts à obtenir des attributions de caractéristiques sur 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()
)
Ensuite, 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, ce qui a fait passer la prédiction de notre modèle au-dessus de la référence de plus de 0,5. Le montant de la transaction, le solde résultant du compte de destination et l'étape étaient les indicateurs les plus importants ensuite. Dans l'ensemble de données, "step" représente une unité de temps (1 step = 1 heure). Les valeurs d'attribution peuvent également être négatives.
L'erreur d'approximation affichée au-dessus des visualisations vous indique dans quelle mesure vous pouvez faire confiance à l'explication. En général, une erreur supérieure à 5 % signifie que vous ne pouvez pas vous fier aux attributions des fonctionnalités. 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. Vous pouvez réduire l'erreur d'approximation en améliorant vos données d'entraînement ou votre modèle, ou en essayant une autre référence de modèle.
Vous pouvez également réduire cette erreur en augmentant le nombre d'étapes utilisées dans votre méthode d'explication. Vous pouvez modifier cette valeur avec le SDK en ajoutant un paramètre path_count à votre configuration d'explication (la valeur par défaut est 10 si vous ne la spécifiez pas) :
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)
Vous pouvez faire beaucoup plus avec Explainable AI sur ce modèle. Voici quelques idées :
- Envoyer de nombreux exemples à notre modèle et faire la moyenne des valeurs d'attribution pour voir si certaines caractéristiques sont plus importantes dans l'ensemble. Nous pourrions l'utiliser pour améliorer notre modèle et éventuellement supprimer les caractéristiques qui ne sont pas importantes.
- Identifier les faux positifs que notre modèle signale comme des transactions frauduleuses, mais qui ne le sont pas, et examiner leurs valeurs d'attribution
- Utiliser une autre référence et voir 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 pour détecter les transactions frauduleuses et à utiliser le SDK Explainable AI pour identifier les caractéristiques sur lesquelles votre modèle s'appuie le plus pour effectuer des prédictions individuelles. Vous pouvez vous arrêter là si vous le souhaitez. L'utilisation du SDK dans un notebook est destinée à simplifier le processus de développement de votre modèle en vous donnant accès à des explications avant de déployer un modèle. Une fois que vous avez créé un modèle qui vous convient, vous souhaitez probablement le déployer pour obtenir des prédictions à grande échelle. Si c'est votre cas, passez à l'étape facultative suivante. Si vous avez terminé, passez à l'étape Nettoyage.
7. Facultatif : Déployer le modèle sur AI Platform Prediction
Dans 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 du SDK que nous avons exécutées précédemment, 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'explication 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 (il doit être unique au niveau mondial).
# 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 ce bucket à AI Platform lorsque nous déploierons le modèle.
Exécutez cette commande gsutil depuis votre notebook pour créer un bucket :
!gsutil mb -l 'us-central1' $MODEL_BUCKET
Copiez ensuite votre répertoire de modèles local dans ce bucket :
!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations
Étape 2 : Déployer le modèle
Ensuite, nous allons 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 notre première version de ce modèle avec gcloud. Le déploiement de la version prendra 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'indicateur origin, nous transmettons l'emplacement Cloud Storage de notre 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 général, plus le modèle est complexe, plus il faut d'étapes d'approximation pour atteindre une convergence raisonnable.
Pour vérifier que votre modèle a été correctement 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 : Obtenir des prédictions et des explications sur le modèle déployé
Pour l'explicabilité, nous nous intéressons principalement à l'explication des cas où notre modèle prédit une fraude. Nous enverrons cinq exemples de test à notre modèle, qui sont tous des 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 et 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 le JSON de réponse, vous verrez les valeurs d'attribution pour chaque caractéristique dans ces exemples. La clé example_score de chaque exemple inclut la prédiction du modèle, qui correspond ici au pourcentage de probabilité qu'une transaction donnée soit frauduleuse.
8. Nettoyage
Si vous souhaitez continuer à utiliser ce notebook, nous vous recommandons de le désactiver quand vous ne vous en servez pas. À partir de l'interface utilisateur de Notebooks dans la console Cloud, sélectionnez le notebook et cliquez sur Arrêter :
Si vous souhaitez supprimer toutes les ressources que vous avez créées dans cet atelier, supprimez simplement l'instance de notebook au lieu de l'arrêter.
À l'aide du menu de navigation de la console Cloud, accédez à "Stockage" et supprimez les deux buckets que vous avez créés pour stocker les composants de votre modèle.