1. Descripción general
En este lab, usarás AI Platform Notebooks para compilar 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 fraude es un tipo de detección de anomalías específica para los servicios financieros y presenta algunos desafíos interesantes para los modelos de AA: conjuntos de datos inherentemente desequilibrados y la necesidad de explicar los resultados de un modelo.
Qué aprenderá
Aprenderás a hacer lo siguiente:
- Cómo controlar conjuntos de datos desequilibrados
- Compila y evalúa un modelo de detección de fraudes con tf.keras en AI Platform Notebooks
- Usa el SDK de Explainable AI desde el notebook para comprender por qué el modelo clasificó las transacciones como fraudulentas.
- Implementa el modelo en AI Platform con explicaciones y obtén predicciones y explicaciones sobre el modelo implementado
El costo total de la ejecución de este lab en Google Cloud es de aproximadamente $1.
2. ¿Por qué es importante la detección de fraudes?
La detección de anomalías puede ser una buena candidata para el aprendizaje automático, ya que suele ser difícil escribir una serie de instrucciones 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 cuando se trata de aprendizaje automático:
- Conjuntos de datos muy desequilibrados: Como las anomalías son, bueno, anomalías, no hay muchas. El AA funciona mejor cuando los conjuntos de datos están equilibrados, por lo que las cosas pueden complicarse cuando los valores atípicos representan menos del 1% de tus datos.
- Necesidad de explicar los resultados: Si buscas actividad fraudulenta, es probable que quieras saber por qué un sistema marcó algo como fraudulento en lugar de simplemente creerle. Las herramientas de explicabilidad pueden ayudarte con esto.
3. Configura 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 sin GPUs:
Usa las opciones predeterminadas y 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 celda nueva 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, lo que representa solo el 0.1% del conjunto de datos completo.
Paso 1: Descarga el conjunto de datos de Kaggle y léelo con Pandas
Pusimos a tu disposición el conjunto de datos de Kaggle 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()
En la vista previa, deberías ver algo como lo siguiente:
Paso 2: Ten en cuenta 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 simplemente porque el 99.9% de los datos son casos no fraudulentos.
Existen diferentes enfoques para abordar los datos desequilibrados. Aquí, usaremos una técnica llamada submuestreo. La reducción de muestreo significa usar solo un pequeño porcentaje de la clase mayoritaria en el entrenamiento. En este caso, "no fraudulento" es la clase mayoritaria, ya que representa el 99.9% de los datos.
Para reducir el tamaño de la muestra de nuestro conjunto de datos, tomaremos los ~8,000 ejemplos de fraude y una muestra aleatoria de ~31,000 casos de no fraude. 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 el fraude y otro para el no fraude (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 que no son de fraude. Usamos el 0 .005% porque esto nos dará una división de 25/75 de transacciones fraudulentas y no fraudulentas. Con eso, puedes volver a unir los datos y mezclarlos. Para simplificar las cosas, también quitaremos algunas columnas que no usaremos 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 converge en torno a un 75% de precisión, es muy probable que esté adivinando "no fraudulenta" en todos los casos.
Paso 3: Divide los datos en conjuntos de entrenamiento y prueba
Lo último que debemos hacer antes de crear nuestro modelo es dividir los datos. Usaremos una división de entrenamiento y prueba del 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 y S. Axelsson. "PaySim: A financial mobile money simulator for fraud detection". En: The 28th European Modeling and Simulation Symposium-EMSS, Larnaca, Cyprus. 2016
5. Crea, entrena y evalúa un modelo de tf.keras
Compilaremos con la API de tf.keras de TensorFlow. El código del modelo de esta sección se basa en este instructivo de la documentación de TensorFlow. Primero, normalizaremos los datos y, luego, compilaremos y entrenaremos nuestro modelo con el parámetro class_weight para tener en cuenta el desequilibrio restante de los datos.
Paso 1: Normaliza los datos
Cuando se entrena un modelo con datos numéricos, es importante normalizar los datos, en especial 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, revisemos la vista previa de nuestros datos normalizados:
train_set
Paso 2: Determina los pesos de las clases
Cuando realizamos un muestreo descendente de los datos, queríamos conservar un subconjunto de las transacciones no fraudulentas para no perder información sobre ellas, por lo que no equilibramos los datos a la perfección. Dado que el conjunto de datos sigue siendo desequilibrado y lo que más nos interesa es identificar correctamente las transacciones fraudulentas, queremos que nuestro modelo asigne más peso a los ejemplos fraudulentos en nuestro conjunto de datos.
El parámetro class_weight de Keras nos permite especificar exactamente cuánto peso queremos darles a los ejemplos de cada clase, según la frecuencia con la que aparecen 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 nuestro modelo en el siguiente paso.
Paso 3: Entrena y evalúa el modelo
Compilaremos nuestro modelo con la API de Keras Sequential Model, que nos permite definir nuestro modelo como una pila de capas. Realizaremos un seguimiento de varias métricas a medida que entrenemos el modelo, lo que nos ayudará a comprender cómo se desempeña en cada clase de nuestro 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 usarlas durante el entrenamiento junto con algunos parámetros de detenció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 crear nuestro modelo:
model = make_model()
model.summary()
Podemos entrenar nuestro modelo con el método fit(), pasando los parámetros definidos anteriormente:
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 cómo se desempeñó trazando varias métricas a lo largo de nuestras épocas 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, se mostrará el porcentaje de ejemplos de prueba que nuestro modelo predijo de forma correcta e incorrecta. Scikit-learn tiene algunas utilidades para crear y graficar 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 que devuelve 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 podemos ingresar esta información 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 las cantidades absolutas de las predicciones correctas e incorrectas de nuestro modelo en el conjunto de prueba. El número de la parte superior izquierda muestra cuántos ejemplos de nuestro conjunto de prueba predijo correctamente nuestro modelo como no fraudulentos. El número que se encuentra en la parte inferior derecha muestra cuántas transacciones predijo correctamente como fraudulentas (este es el número que más nos interesa). Puedes ver que predijo correctamente la mayoría de las muestras para cada clase.
Para que sea más fácil visualizar esto, adaptamos la función plot_confusion_matrix de la documentación 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')
Luego, crea el gráfico pasando los datos de nuestro modelo. Aquí, establecemos normalize en True para que la matriz de confusión muestre la cantidad de predicciones correctas e incorrectas como porcentajes:
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
Deberías ver algo como esto (los números exactos variarán):
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, en este lab, el enfoque no está en la calidad del modelo. Si implementaras un modelo de detección de fraude en producción, probablemente querrías una precisión superior al 85% en la clase de fraude. El objetivo de este lab es presentarte las herramientas para explicar modelos entrenados en conjuntos de datos desequilibrados.
A continuación, usaremos el SDK de Explainable AI para comprender en qué atributos 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 AI Platform de TensorFlow. Ten en cuenta que la importamos en nuestro notebook al comienzo del lab. Con el SDK, podemos obtener atribuciones de características de nuestro modelo dentro de la instancia del notebook, lo que significa que no necesitamos implementar nuestro 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, dirigiremos el SDK a los recursos del modelo guardado para obtener explicaciones.
Paso 1: Exporta el modelo entrenado
Primero, guardemos nuestro modelo en un directorio de la instancia del 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 un directorio nuevo llamado fraud_model/.
Paso 2: Obtén metadatos de explicación con el SDK
A continuación, dirigiremos el SDK de IA explicable a ese directorio. Esto generará los metadatos necesarios para obtener explicaciones del modelo. El método get_metadata() muestra los metadatos que el SDK infiere de tu modelo, como los nombres de las entradas:
model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)
La interpretabilidad nos ayuda a responder la pregunta: "¿Por qué nuestro modelo pensó que esto era un fraude?".
Paso 3: Especifica el valor de referencia de nuestro modelo
En el caso de los datos tabulares, el servicio de Explainable AI devuelve valores de atribución para cada atributo. Estos valores indican cuánto afectó un atributo en particular a la predicción. Supongamos que el importe de una transacción en particular hizo que nuestro modelo aumentara su probabilidad de fraude prevista en un 0.2%. Quizás te preguntes: "¿0.2% en relación con qué?". Esto nos lleva al concepto de modelo de referencia.
El modelo de referencia es, básicamente, el modelo con el que se compara nuestro modelo. Seleccionamos el valor de referencia para cada atributo de nuestro modelo, y la predicción de referencia se convierte, en consecuencia, en el valor que predice nuestro modelo cuando los atributos se establecen en el valor de referencia.
La elección de un modelo de referencia depende de la tarea de predicción que estés resolviendo. Para los atributos numéricos, es común usar el valor de la mediana de cada atributo en tu conjunto de datos como el valor de referencia. Sin embargo, en el caso de la detección de fraude, esto no es exactamente lo que queremos. Nos interesa 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 tener en cuenta esto, usaremos los valores medianos de las transacciones no fraudulentas en nuestro conjunto de datos como referencia. Podemos obtener la mediana con el DataFrame not_fraud_sample que extrajimos anteriormente y ajustarlo para que coincida con las entradas esperadas 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 es necesario especificar un valor de referencia. Si no lo hacemos, el SDK usará 0 como valor de referencia para cada valor de entrada que espera nuestro modelo. En nuestro caso de uso de detección de fraude, tiene sentido especificar un valor de referencia, lo que haremos 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)
La ejecución del método save_metadata() anterior creó un archivo en el directorio de nuestro modelo llamado explanation_metadata.json. En tu notebook, navega al directorio fraud_model/ para confirmar que se creó el archivo. Contiene metadatos que el SDK usará para generar atribuciones de funciones.
Paso 4: Cómo obtener explicaciones del modelo
Ahora sí, ya podemos obtener atribuciones de características 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, obtengamos 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()
Si ejecutas este código, se creará una visualización similar a la siguiente:
En este ejemplo, el saldo inicial de la cuenta antes de que se realizara la transacción fue el mayor indicador de fraude, lo que elevó la predicción de nuestro modelo desde el valor de referencia en 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 equivale a 1 hora). Los valores de atribución también pueden ser negativos.
El "error de aproximación" que se imprime sobre las visualizaciones te permite saber qué tan confiable es la explicación. En general, un error superior al 5% significa que es posible que no puedas confiar en las atribuciones de funciones. Recuerda que tus explicaciones solo son tan buenas como los datos de entrenamiento y el modelo que usaste. Mejorar tus datos de entrenamiento, tu modelo o probar un modelo de referencia diferente puede reducir el error de aproximación.
También puedes disminuir este error aumentando la cantidad de pasos que se usan en tu método de explicación. Puedes cambiar este valor con el SDK agregando un parámetro path_count a la configuración de la 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)
)
Hay muchas más cosas que puedes hacer con la IA explicable 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 usar esta información para mejorar nuestro modelo y, posiblemente, quitar los atributos que no son importantes.
- Encontrar falsos positivos que nuestro modelo marca como fraude, pero que son transacciones no fraudulentas, y examinar sus valores de atribución
- Usa otro modelo de referencia y observa cómo afecta los valores de atribución
🎉 ¡Felicitaciones! 🎉
Aprendiste a tener en cuenta los datos desequilibrados, entrenar un modelo de TensorFlow para detectar transacciones fraudulentas y usar el SDK de Explainable AI para ver en qué atributos se basa más tu modelo para realizar predicciones individuales. Si quieres, puedes detenerte aquí. El uso del SDK en un notebook tiene como objetivo simplificar el proceso de desarrollo del modelo, ya que te brinda acceso a explicaciones antes de implementar un modelo. Es probable que, una vez que hayas creado un modelo con el que estés conforme, quieras implementarlo para obtener predicciones a gran escala. Si es así, continúa con el siguiente paso opcional. Si terminaste, avanza al paso Limpieza.
7. Opcional: Implementa el modelo en AI Platform Prediction
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 recursos de tu modelo guardado y los metadatos de explicación en un bucket de Cloud Storage que el servicio de IA Explicable pueda leer.
Para ello, definiremos algunas variables de entorno. Completa los valores a continuación 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'
Ahora, ya podemos crear un bucket de almacenamiento para guardar los recursos del modelo de TensorFlow que exportamos. Cuando implementemos el modelo, dirigiremos AI Platform a este bucket.
Ejecuta este comando de gsutil desde tu notebook para crear un bucket:
!gsutil mb -l 'us-central1' $MODEL_BUCKET
Luego, copia tu 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
Ahora sí, podemos implementar la primera versión de este modelo con gcloud. La implementación de la versión tardará entre 5 y 10 minutos:
!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 de Cloud Storage de nuestro modelo guardado y el archivo de metadatos. Actualmente, Explainable AI tiene dos métodos de explicación diferentes disponibles para los modelos tabulares. Aquí usamos Sampled Shapley. El parámetro num-paths indica la cantidad de rutas de acceso muestreadas para cada atributo de entrada. En general, cuanto más complejo sea el modelo, más pasos de aproximación se necesitarán para alcanzar una convergencia razonable.
Para confirmar que el 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 sobre el modelo implementado
A los fines de la interpretabilidad, nos interesa más explicar los casos en los que nuestro modelo predice fraude. Enviaremos 5 ejemplos de prueba a nuestro modelo, todos ellos 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 pruebas:
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 de cada atributo en 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 usando este notebook, te recomendamos que lo desactives cuando no lo uses. 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, simplemente borra la instancia del notebook en lugar de detenerla.
En el menú de navegación de la consola de Cloud, navega a Almacenamiento y borra los dos buckets que creaste para almacenar los recursos del modelo.