1. Descripción general
En este lab, usarás AI Platform Notebooks para crear y entrenar un modelo que identifique transacciones fraudulentas, y comprenderás las predicciones del modelo con el SDK de Explainable AI. La detección de fraudes es un tipo de detección de anomalías específica de los servicios financieros y presenta algunos desafíos interesantes para los modelos de AA: conjuntos de datos desequilibrados de forma inherente y la necesidad de explicar los resultados de un modelo.
Qué aprenderá
Aprenderás a hacer lo siguiente:
- Maneja conjuntos de datos desequilibrados
- Crear y evaluar un modelo de detección de fraudes con tf.keras en AI Platform Notebooks
- Usar el SDK de Explainable AI desde el notebook para comprender por qué el modelo clasificó las transacciones como fraudulentas
- Implementar el modelo en AI Platform con explicaciones y obtener predicciones y explicaciones en el modelo implementado
El costo total de la ejecución de este lab en Google Cloud es de aproximadamente $1.
2. ¿Por qué elegir la detección de fraudes?
La detección de anomalías puede ser un buen candidato para el aprendizaje automático, ya que suele ser difícil escribir una serie de sentencias basadas en reglas para identificar valores atípicos en los datos. La detección de fraudes es un tipo de detección de anomalías y presenta dos desafíos interesantes en lo que respecta al aprendizaje automático:
- Conjuntos de datos muy desequilibrados: debido a que las anomalías son anomalías, no hay muchas de ellas. El AA funciona mejor cuando los conjuntos de datos están equilibrados, por lo que se puede complicar cuando los valores atípicos constituyen menos del 1% de tus datos.
- Debes explicar los resultados: si buscas actividades fraudulentas, es probable que quieras saber por qué un sistema marcó algo como fraudulento en lugar de solo confiar en su palabra. Las herramientas de explicabilidad pueden ayudar con esto.
3. Cómo configurar tu entorno
Para ejecutar este codelab, necesitarás un proyecto de Google Cloud Platform que tenga habilitada la facturación. Para crear un proyecto, sigue estas instrucciones.
Paso 1: Habilita la API de Cloud AI Platform Models
Navega a la sección Modelos de AI Platform de la consola de Cloud y haz clic en Habilitar si aún no está habilitada.
Paso 2: Habilita la API de Compute Engine
Ve a Compute Engine y selecciona Habilitar si aún no está habilitada. La necesitarás para crear la instancia de notebook.
Paso 3: Crea una instancia de AI Platform Notebooks
Navega a la sección AI Platform Notebooks de la consola de Cloud y haz clic en Instancia nueva. Luego, selecciona el tipo de instancia TensorFlow Enterprise 2.1 without GPUs:
Usa las opciones predeterminadas y, luego, haz clic en Crear. Una vez que se crea la instancia, selecciona Abrir JupyterLab:
Cuando abras la instancia, selecciona el notebook Python 3 en el selector:
Paso 4: Importa paquetes de Python
Crea una nueva celda y, luego, importa las bibliotecas que usaremos en este 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. Descarga y procesa datos
Usaremos este conjunto de datos generado de forma sintética de Kaggle para entrenar nuestro modelo. El conjunto de datos original incluye 6.3 millones de filas, de las cuales 8,000 son transacciones fraudulentas, ¡que solo representa el 0.1% del conjunto de datos completo!
Paso 1: Descarga el conjunto de datos de Kaggle y léelo con Pandas
El conjunto de datos de Kaggle se ha puesto a tu disposición en Google Cloud Storage. Para descargarlo, ejecuta el siguiente comando gsutil en tu notebook de Jupyter:
!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .
A continuación, leamos el conjunto de datos como un DataFrame de Pandas y obtengamos una vista previa:
data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()
Deberías ver algo como esto en la vista previa:
Paso 2: Considerar los datos desequilibrados
Como se mencionó anteriormente, en este momento, el conjunto de datos contiene un 99.9% de ejemplos no fraudulentos. Si entrenamos un modelo con los datos tal como están, es probable que el modelo alcance una exactitud del 99.9% adivinando que cada transacción no es fraudulenta solo porque el 99.9% de los datos no son casos fraudulentos.
Existen varios enfoques diferentes para lidiar con los datos desequilibrados. Aquí usaremos una técnica llamada reducción de muestreo. La reducción de muestreo significa usar solo un pequeño porcentaje de la clase mayoritaria en el entrenamiento. En este caso, "no es fraude" es la clase mayoritaria, ya que representa el 99.9% de los datos.
Para reducir el muestreo de nuestro conjunto de datos, tomaremos alrededor de 8,000 de los ejemplos fraudulentos y una muestra aleatoria de alrededor de 31,000 de los casos no fraudulentos. De esta manera, el conjunto de datos resultante tendrá un 25% de casos de fraude, en comparación con el 0 .1% que teníamos antes.
Primero, divide los datos en dos DataFrames, uno para fraude y otro para no (lo usaremos más adelante en el codelab cuando implementemos nuestro modelo):
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
Luego, toma una muestra aleatoria de los casos no fraudulentos. Usamos un 0 .005%, ya que esto nos brindará una división del 25/75 entre transacciones fraudulentas y no fraudulentas. De esa forma, puedes volver a juntar los datos y mezclarlos. Para simplificar, también quitaremos algunas columnas que no utilizaremos para el entrenamiento:
# 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()
Ahora tenemos un conjunto de datos mucho más equilibrado. Sin embargo, si notamos que nuestro modelo tiene una exactitud de aproximadamente el 75%, es muy probable que adivine que no es un fraude. en todos los casos.
Paso 3: Divide los datos en conjuntos de entrenamiento y prueba
Lo último que debemos hacer antes de crear el modelo es dividir los datos. Usaremos una división de prueba de entrenamiento 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. López-Rojas , A. Elmir y S. Axelsson. “PaySim: Un simulador de dinero financiero para dispositivos móviles para la detección de fraudes”. En: 28o Simposio Europeo de Modelado y Simulación-EMSS, Larnaca, Chipre. 2016
5. Compila, entrena y evalúa un modelo tf.keras
Realizaremos compilaciones con la API de tf.keras de TensorFlow. El código del modelo que aparece en esta sección se basa en este instructivo de la documentación de TensorFlow. Primero, normalizaremos los datos y, luego, crearemos y entrenaremos nuestro modelo con el parámetro class_weight para tener en cuenta el desequilibrio de datos restante.
Paso 1: Normaliza los datos
Cuando se entrena un modelo con datos numéricos, es importante normalizar los datos, especialmente si cada columna se encuentra en un rango diferente. Esto puede ayudar a evitar que la pérdida explote durante el entrenamiento. Podemos normalizar nuestros datos de la siguiente manera:
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)
Luego, obtengamos una vista previa de nuestros datos normalizados:
train_set
Paso 2: Determina los pesos de la clase
Al realizar una reducción de muestreo en los datos, quisimos conservar un subconjunto de las transacciones no fraudulentas para no perder información sobre esas transacciones, por lo que no logramos que los datos estén perfectamente equilibrados. Debido a que el conjunto de datos sigue desequilibrado y lo que más nos importa es identificar correctamente las transacciones fraudulentas, queremos que nuestro modelo dé más importancia a los ejemplos fraudulentos en nuestro conjunto de datos.
El parámetro class_weight de Keras nos permite especificar exactamente cuánto peso queremos dar ejemplos de cada clase, según la frecuencia con la que ocurren en el conjunto de datos:
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}
Usaremos esta variable cuando entrenemos el modelo en el siguiente paso.
Paso 3: Entrena y evalúa el modelo
Compilaremos nuestro modelo con la API del modelo secuencial de Keras, que nos permite definir el modelo como una pila de capas. Realizaremos un seguimiento de una serie de métricas durante el entrenamiento, las cuales nos ayudarán a comprender el rendimiento del modelo en cada clase del conjunto de datos.
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
Luego, definiremos algunas variables globales para usar durante el entrenamiento junto con algunos parámetros de interrupción anticipada.
EPOCHS = 100
BATCH_SIZE = 512
early_stopping = tf.keras.callbacks.EarlyStopping(
monitor='val_auc',
verbose=1,
patience=10,
mode='max',
restore_best_weights=True)
Por último, llamaremos a la función que definimos anteriormente para hacer que nuestro modelo:
model = make_model()
model.summary()
Podemos entrenar nuestro modelo con el método fit() y pasar los parámetros definidos con anterioridad:
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)
El entrenamiento tardará unos minutos en ejecutarse.
Paso 4: Visualiza las métricas del modelo
Ahora que tenemos un modelo entrenado, veamos cuál fue su rendimiento. Para ello, traza varias métricas a lo largo de nuestros ciclos de entrenamiento:
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)
Tus gráficos deberían ser similares a los siguientes (pero no serán exactamente iguales):
Paso 5: Imprime una matriz de confusión
Una matriz de confusión es una buena manera de visualizar el rendimiento de nuestro modelo en el conjunto de datos de prueba. Para cada clase, nos mostrará el porcentaje de ejemplos de prueba que nuestro modelo predijo de forma correcta y incorrecta. scikit-learn tiene algunas utilidades para crear y trazar matrices de confusión, que usaremos aquí.
Al comienzo de nuestro notebook, importamos la utilidad confusion_matrix. Para usarlo, primero crearemos una lista de las predicciones de nuestro modelo. Aquí redondearemos los valores devueltos por nuestro modelo para que esta lista coincida con nuestra lista de etiquetas de verdad fundamental:
predicted = model.predict(test_set)
y_pred = []
for i in predicted.tolist():
y_pred.append(int(round(i[0])))
Ahora estamos listos para ingresarlo en el método confusion_matrix, junto con nuestras etiquetas de verdad fundamental:
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
Esto nos muestra los números absolutos de las predicciones correctas e incorrectas de nuestro modelo en el conjunto de prueba. El número en la parte superior izquierda muestra cuántos ejemplos del conjunto de prueba se predijo correctamente como no fraudulento. El número de la parte inferior derecha muestra cuántas se predijo correctamente como fraudulenta (nos importa más esta cifra). Puedes ver que predijo correctamente la mayoría de las muestras para cada clase.
Para facilitar la visualización, adaptamos la función plot_confusion_matrix de los documentos de scikit-learn. Define esa función aquí:
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')
Y crear el diagrama pasándole los datos de nuestro modelo. Aquí estableceremos normalize en True para que la matriz de confusión muestre la cantidad de predicciones incorrectas y correctas como porcentajes:
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
Deberías ver un resultado similar al siguiente (los números exactos varían):
Aquí podemos ver que nuestro modelo predijo correctamente alrededor del 85% de las 1,594 transacciones fraudulentas de nuestro conjunto de prueba. Ten en cuenta que este lab no se enfoca en la calidad del modelo. Si implementas un modelo de detección de fraudes en producción, es probable que necesites una exactitud superior al 85% en la clase de fraude. El objetivo de este lab es presentarte las herramientas relacionadas con la explicación de los modelos entrenados con conjuntos de datos desequilibrados.
A continuación, usaremos el SDK de Explainable AI para comprender en qué funciones se basa nuestro modelo para realizar estas predicciones.
6. Usa el SDK de Explainable AI
El SDK de Explainable AI proporciona métodos de utilidad para obtener explicaciones sobre tu modelo. Viene preinstalada en las instancias de notebook de TensorFlow AI Platform. Tenga en cuenta que lo importamos en nuestro notebook al comienzo del lab. Con el SDK, podemos obtener atribuciones de atributos de nuestro modelo dentro de la instancia de notebook, lo que significa que no necesitamos implementar el modelo en la nube para usarlo.
En esta sección, exportaremos el modelo que acabamos de entrenar como un modelo guardado de TensorFlow y, luego, apuntaremos el SDK a nuestros recursos del modelo guardados para obtener explicaciones.
Paso 1: Exporta el modelo entrenado
Primero, guardemos el modelo en un directorio de la instancia de notebook:
model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)
Si actualizas la vista de carpetas en la barra lateral izquierda de tu notebook, deberías ver que se creó un directorio nuevo llamado fraud_model/.
Paso 2: Obtén metadatos de explicaciones con el SDK
A continuación, apuntaremos el SDK de Explainable AI hacia ese directorio. Esto generará los metadatos necesarios para obtener explicaciones del modelo. El método get_metadata() muestra los metadatos que el SDK infiere a partir del modelo, como nombres de entrada:
model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)
La explicabilidad nos ayuda a responder la pregunta: “¿Por qué nuestro modelo pensó que se trataba de un fraude?”.
Paso 3: Especificación del modelo de referencia de nuestro modelo
En el caso de los datos tabulares, el servicio de Explainable AI muestra valores de atribución para cada atributo. Estos valores indican en qué medida un atributo en particular afectó la predicción. Digamos que la cantidad de una transacción específica hizo que nuestro modelo aumentara su probabilidad de fraude prevista en un 0.2%. Es posible que estés pensando “0.2% en relación con qué?”. Esto nos lleva al concepto de modelo de referencia.
El modelo de referencia es, en esencia, con lo que se compara. Seleccionamos el valor del modelo de referencia para cada atributo del modelo y, por consiguiente, la predicción del modelo de referencia se convierte en el valor que predice nuestro modelo cuando los atributos se establecen en el modelo de referencia.
Elegir un modelo de referencia depende de la tarea de predicción que resuelvas. Para los atributos numéricos, es común usar la mediana de cada atributo del conjunto de datos como modelo de referencia. Sin embargo, en el caso de la detección de fraudes, esto no es exactamente lo que queremos. Lo más importante es explicar los casos en los que nuestro modelo etiqueta una transacción como fraudulenta. Esto significa que el caso de referencia con el que queremos comparar son las transacciones no fraudulentas.
Para dar cuenta de esto, usaremos los valores de la mediana de las transacciones no fraudulentas en nuestro conjunto de datos como referencia. Podemos obtener la mediana con el DataFrame not_fraud_sample que extrajimos antes y escalarlo para que coincida con las entradas previstas de nuestro modelo:
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)
Ten en cuenta que no necesitamos especificar un modelo de referencia. De lo contrario, el SDK usará 0 como modelo de referencia para cada valor de entrada que espera nuestro modelo. En nuestro caso de uso de detección de fraudes, tiene sentido especificar un modelo de referencia, como se muestra a continuación:
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)
Cuando se ejecutaba el método save_metadata() anterior, se creó un archivo en el directorio de nuestro modelo llamado explanation_metadata.json. En tu notebook, navega al directorio fraudes_model/ para confirmar que se creó el archivo. Contiene metadatos que el SDK usará para generar atribuciones de funciones.
Paso 4: Obtén explicaciones del modelo
Ahora estamos listos para obtener atribuciones de atributos en ejemplos individuales. Para ello, primero crearemos una referencia local a nuestro modelo con el SDK:
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig()
)
A continuación, obtendremos predicciones y explicaciones sobre nuestro modelo a partir de una transacción de ejemplo que debería clasificarse como fraudulenta:
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()
Cuando ejecutes esto, se debería crear una visualización similar a la siguiente:
En este ejemplo, el saldo inicial de la cuenta antes de que se llevara a cabo la transacción fue el mayor indicador de fraude, lo que elevó la predicción de nuestro modelo desde el valor de referencia más de 0.5. El importe de la transacción, el saldo resultante en la cuenta de destino y el paso fueron los siguientes indicadores más importantes. En el conjunto de datos, el “paso” representa una unidad de tiempo (1 paso es 1 hora). Los valores de atribución también pueden ser negativos.
El “error de aproximación” que está impreso sobre las visualizaciones te permite saber cuánto puedes confiar en la explicación. Por lo general, un error superior al 5% significa que tal vez no puedas confiar en las atribuciones de los atributos. Recuerda que tus explicaciones son tan buenas como los datos de entrenamiento y el modelo que usaste. Mejorar los datos de entrenamiento o el modelo, o probar un modelo de referencia diferente puede disminuir el error de aproximación.
También puedes disminuir este error aumentando la cantidad de pasos que utilizas en tu método de explicación. Puedes cambiar esto con el SDK agregando un parámetro path_count a tu configuración de explicación (el valor predeterminado es 10 si no lo especificas):
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)
Puedes hacer mucho más con Explainable AI en este modelo. Estas son algunas ideas:
- Enviar muchos ejemplos a nuestro modelo y promediar los valores de atribución para ver si ciertos atributos son más importantes en general Podríamos usarlo para mejorar nuestro modelo y, posiblemente, quitar los atributos que no son importantes
- Encontrar falsos positivos que nuestro modelo marca como fraude, pero que no son transacciones fraudulentas, y examinar sus valores de atribución
- Usa un modelo de referencia diferente y observa cómo esto afecta los valores de atribución
🎉 ¡Felicitaciones! 🎉
Aprendiste a dar cuenta de los datos desequilibrados, entrenar un modelo de TensorFlow para detectar transacciones fraudulentas y usar el SDK de Explainable AI para ver en qué funciones confía más tu modelo para hacer predicciones individuales. Puedes parar aquí si lo deseas. El objetivo de usar el SDK en un notebook es simplificar el proceso de desarrollo de tu modelo, ya que te brinda acceso a explicaciones antes de implementar un modelo. Es probable que, una vez que hayas compilado un modelo que te guste, quieras implementarlo para obtener predicciones a gran escala. Si crees que este es tu caso, continúa con el próximo paso opcional. Cuando hayas terminado, ve al paso Limpieza.
7. Implementa el modelo en AI Platform Prediction (opcional)
En este paso, aprenderás a implementar tu modelo en AI Platform Prediction.
Paso 1: Copia el directorio del modelo guardado en un bucket de Cloud Storage
Con los pasos del SDK que ejecutamos anteriormente, tienes todo lo que necesitas para implementar tu modelo en AI Platform. Para prepararte para la implementación, deberás colocar los elementos de tu modelo guardado y los metadatos de explicaciones en un bucket de Cloud Storage que el servicio de Explainable AI pueda leer.
Para hacerlo, definiremos algunas variables de entorno. Completa los siguientes valores con el nombre de tu proyecto de Google Cloud y el nombre del bucket que deseas crear (debe ser único a nivel global).
# Update these to your own GCP project and model
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
Ya está todo listo para crear un bucket de almacenamiento y almacenar los elementos exportados del modelo de TensorFlow. Apuntaremos AI Platform hacia este bucket cuando implementemos el modelo.
Ejecuta este comando gsutil desde tu notebook para crear un bucket:
!gsutil mb -l 'us-central1' $MODEL_BUCKET
Luego, copia el directorio del modelo local en ese bucket:
!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations
Paso 2: Implementa el modelo
A continuación, definiremos algunas variables que usaremos en nuestros comandos de implementación:
MODEL = 'fraud_detection'
VERSION = 'v1'
model_path = MODEL_BUCKET + '/explanations'
Podemos crear el modelo con el siguiente comando de gcloud:
!gcloud ai-platform models create $MODEL --region=us-central1
Ya estamos listos para implementar nuestra primera versión de este modelo con gcloud. La versión tardará entre 5 y 10 minutos en implementarse:
!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
En la marca origin, pasamos la ubicación en Cloud Storage del modelo guardado y el archivo de metadatos. En la actualidad, Explainable AI tiene dos métodos de explicación diferentes disponibles para modelos tabulares. Aquí usamos Shapley de muestra. El parámetro num-paths indica la cantidad de rutas muestreadas para cada atributo de entrada. Por lo general, cuanto más complejo sea el modelo, más pasos de aproximación se necesitan para alcanzar una convergencia razonable.
Para confirmar que tu modelo se implementó correctamente, ejecuta el siguiente comando de gcloud:
!gcloud ai-platform versions describe $VERSION --model $MODEL --region=us-central1
El estado debe ser READY.
Paso 3: Obtén predicciones y explicaciones en el modelo implementado
Para los fines de la explicabilidad, lo más importante es explicar los casos en los que nuestro modelo predice fraudes. Enviaremos 5 ejemplos de prueba a nuestro modelo que son todas transacciones fraudulentas.
Usaremos Google Cloud CLI para obtener predicciones. Ejecuta el siguiente código para obtener los índices de todos los ejemplos de fraude de nuestro conjunto de prueba:
fraud_indices = []
for i,val in enumerate(test_labels):
if val == 1:
fraud_indices.append(i)
A continuación, guardaremos 5 ejemplos en el formato que espera nuestro modelo y los escribiremos en un archivo:
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)
Podemos enviar estos cinco ejemplos a nuestro modelo con gcloud:
!gcloud beta ai-platform explain \
--model=$MODEL \
--version=$VERSION \
--region='us-central1' \
--json-request=prediction.json
En el JSON de respuesta, verás los valores de atribución para cada atributo de estos ejemplos. La clave example_score para cada ejemplo incluye la predicción del modelo; en este caso, el porcentaje de probabilidad de que una transacción en particular sea fraudulenta.
8. Limpieza
Si quieres seguir utilizando este bloc de notas, te recomendamos que lo desactives cuando no lo utilices. En la IU de Notebooks de la consola de Cloud, selecciona el notebook y, luego, haz clic en Detener:
Si quieres borrar todos los recursos que creaste en este lab, solo borra la instancia de notebook en lugar de detenerla.
En el menú de navegación de la consola de Cloud, navega a Almacenamiento y borra los buckets que creaste para almacenar tus recursos del modelo.