Usa Explicaciones de IA con AI Platform Prediction

Esta es una guía general sobre cómo implementar y usar un modelo en AI Platform Prediction con Explicaciones de IA.

Antes de comenzar

Debes completar varios pasos antes de poder entrenar e implementar un modelo en AI Platform:

  • Configura el entorno de desarrollo local.
  • Configura un proyecto de GCP que tenga habilitadas la facturación y las API necesarias.
  • Crea un depósito de Cloud Storage para almacenar el paquete de entrenamiento y el modelo entrenado.

Para configurar el proyecto de GCP, sigue las instrucciones que se proporcionan en los notebooks de muestra.

Guarda un modelo

Si compilas y entrenas el modelo en Keras, debes convertirlo en un Estimador de TensorFlow y, luego, exportarlo a un modelo guardado. En esta sección, nos enfocamos en cómo guardar un modelo. Para ver un ejemplo completo, consulta los notebooks de ejemplo.

Después de compilar, compilar, entrenar y evaluar el modelo de Keras, debes hacer lo siguiente:

  • Convertir el modelo de Keras en un Estimador de TensorFlow mediante tf.keras.estimator.model_to_estimator
  • Proporcionar una función de entrada de entrega mediante tf.estimator.export.build_raw_serving_input_receiver_fn
  • Exportar el modelo como modelo guardado mediante [tf.estimator.export_saved_model]
# Build, compile, train, and evaluate your Keras model
model = tf.keras.Sequential(...)
model.compile(...)
model.fit(...)
model.predict(...)

## Convert your Keras model to an Estimator
keras_estimator = tf.keras.estimator.model_to_estimator(keras_model=model, model_dir='export')

## Define a serving input function appropriate for your model
def serving_input_receiver_fn():
  ...
  return tf.estimator.export.ServingInputReceiver(...)

## Export the SavedModel to Cloud Storage, using your serving input function
export_path = keras_estimator.export_saved_model(
  'gs://' + 'YOUR_BUCKET_NAME',
  serving_input_receiver_fn
).decode('utf-8')

print("Model exported to: ", export_path)

Archivo de metadatos de la explicación

Debes enviar un archivo de metadatos con información sobre las entradas, las salidas y el modelo de referencia, de modo que Explicaciones de IA proporcione explicaciones de las partes correctas del modelo.

  • Identifica los nombres de los tensores de entrada y salida para los que quieres obtener explicaciones. Obtén más información sobre cómo identificar los tensores de entrada y salida.
  • Pasa el modelo de referencia a input_baselines.
  • Especifica "tensorflow" para tu framework.
  • Asígnale un nombre al archivo explanation_metadata.json:
  • Sube el archivo explanation_metadata.json al mismo depósito de Cloud Storage en el que se encuentra el modelo guardado.

En el siguiente ejemplo, se muestra cómo se ve un archivo explanation_metadata.json:

{
    "inputs": {
      "data": {
        "input_tensor_name": "YOUR_INPUT_TENSOR_NAME"
        "input_baselines": [0]
      }
    },
    "outputs": {
      "duration": {
        "output_tensor_name": "YOUR_OUTPUT_TENSOR_NAME"
      }
    },
    "framework": "tensorflow"
}

En este ejemplo, “data” y “duration” son nombres significativos para los tensores de entrada y salida que puedes asignar en el proceso de compilación y entrenamiento del modelo. Los nombres reales de los tensores de entrada y salida tienen el formato name:index. Por ejemplo, x:0 o Placeholder:0.

Para input_baselines, primero especifica un modelo de referencia. En este ejemplo, [0] representa una imagen negra. Obtén más información sobre cómo ajustar los modelos de referencia.

Localiza nombres de tensores de entrada y salida

La mejor manera de encontrar los nombres de los tensores de entrada y salida depende de los tipos de datos de entrada y salida, y de cómo compilas el modelo. Para obtener una explicación más detallada de cada caso, además de ejemplos, consulta la guía sobre cómo preparar metadatos para las explicaciones.

Tipos de datos de entrada Tipo de datos de salida Otros criterios Enfoques recomendados
Numérico o string Numérico Las entradas no están en formato serializado. Las salidas no son datos numéricos tomados como datos categóricos (por ejemplo, ID de clase numéricos). Usa la CLI del modelo guardado para encontrar los nombres de los tensores de entrada y salida. También puedes compilar el archivo de metadatos de explicación mientras se entrena y se guarda el modelo, en el que el programa o el entorno aún tienen acceso al código de entrenamiento.
Cualquier dato serializado Cualquiera Agrega una operación de análisis de TensorFlow a la función de entrada de entrega cuando exportes el modelo. Usa el resultado de la operación de análisis para identificar los tensores de entrada.
Cualquiera Cualquiera El modelo incluye operaciones de procesamiento previo Para obtener los nombres de los tensores de entrada después de los pasos de procesamiento previo, usa la propiedad name de tf.Tensor.
Cualquiera No hay probabilidades, logits ni otros tipos de tensores de punto flotante Debes obtener explicaciones de salidas que no sean probabilidades, logits ni otros tipos de tensores de punto flotante. Inspecciona el grafo con TensorBoard para encontrar los tensores de salida correctos.
Datos no diferenciables Cualquiera Debes usar gradientes integrados, que requieren entradas diferenciables. Codifica las entradas no diferenciables como tensores diferenciables. Agrega los nombres del tensor de entrada original y el tensor de entrada codificado al archivo de metadatos de explicación.

Implementa modelos y versiones

AI Platform Prediction organiza los modelos entrenados mediante recursos de modelo y versión. Un modelo de AI Platform Prediction es un contenedor para las versiones del modelo de aprendizaje automático.

Para implementar un modelo, crea un recurso del modelo en AI Platform Prediction, crea una versión de ese modelo y, luego, vincula la versión con el archivo del modelo almacenado en Cloud Storage.

Crea un recurso de modelo

En AI Platform Prediction, se usan recursos de modelo para organizar diferentes versiones del modelo.

Crea un recurso de modelo para tus versiones de modelo. En el siguiente comando de la herramienta de línea de comandos de gcloud, reemplaza MODEL_NAME por el nombre que desees para tu modelo. El nombre del modelo debe comenzar con una letra y solo debe contener letras, números y guiones bajos.

Debes crear el modelo en un extremo regional para usar Explicaciones de IA.

gcloud ai-platform models create MODEL_NAME \
  --region us-central1

Consulta la API del modelo de AI Platform Prediction para obtener más detalles.

Crea una versión de modelo

Ahora estás listo para crear una versión de modelo con el modelo entrenado que subiste previamente a Cloud Storage. Cuando crees una versión, especifica los siguientes parámetros:

  • name: Debe ser único en el modelo de AI Platform Prediction.
  • deploymentUri: La ruta al directorio del modelo guardado en Cloud Storage.
  • framework (obligatorio): solo tensorflow
  • runtimeVersion: Usa cualquiera de las siguientes versiones de entorno de ejecución compatibles con Explicaciones de IA 1.14 y 1.15.
  • pythonVersion: Se debe establecer en “3.5” si usas la versión del entorno de ejecución 1.14. Usa “3.7” para la versión 1.15 del entorno de ejecución.
  • machineType (obligatorio): El tipo de máquina virtual que usa AI Platform Prediction para los nodos que entregan predicciones y explicaciones. Selecciona un tipo de máquina compatible con Explicaciones de IA.
  • explanation-method: El tipo de método de atribución de atributos que se usará: “shapley-conmuestreo”, “gradientes-integrados” o “xrai”.
  • Rutas o pasos: Usa --num-paths para Shapley con muestreo y --num-integral-steps para gradientes integrados o XRAI.

Consulta más información sobre cada uno de estos parámetros en la API de entrenamiento y predicción de AI Platform para un recurso de versión.

  1. Establece variables de entorno para almacenar la ruta de acceso al directorio de Cloud Storage en el que se encuentra el modelo guardado, el nombre del modelo, el nombre de la versión y el framework que elegiste.

    MODEL=your_model_name
    MODEL_DIR="gs://your_bucket_name/"
    VERSION=your_version_name
    FRAMEWORK=tensorflow
    
  2. Crea la versión:

    EXPLAIN_METHOD="integrated-gradients"
    gcloud beta ai-platform versions create $VERSION \
    --model $MODEL \
    --origin $MODEL_DIR \
    --runtime-version 1.14 \
    --framework $FRAMEWORK \
    --python-version 3.5 \
    --machine-type n1-standard-4 \
    --explanation-method $EXPLAIN_METHOD \
    --num-integral-steps 25 \
    --region us-central1
    

    La creación de la versión toma unos minutos. Cuando esté lista, verás el siguiente resultado:

    Creating version (this might take a few minutes)......done.
  3. Comprueba el estado de la implementación del modelo y asegúrate de que se haya implementado de manera correcta:

    gcloud ai-platform versions describe $VERSION_NAME \
      --model $MODEL_NAME \
      --region us-central1
    

    Comprueba que el estado sea READY. Deberías ver un resultado similar a este:

    createTime: '2018-02-28T16:30:45Z'
    deploymentUri: gs://your_bucket_name
    framework: TENSORFLOW
    machineType: mls1-c1-m2
    name: projects/your_project_id/models/your_model_name/versions/your_version_name
    pythonVersion: '3.5'
    runtimeVersion: '1.14'
    state: READY

Tipos de máquinas compatibles con las explicaciones

En las solicitudes de Explicaciones de IA, debes implementar la versión del modelo con uno de los siguientes tipos de máquinas, que están disponibles en versión Beta. Si no especificas un tipo de máquina, la implementación fallará.

En la siguiente tabla, se comparan los tipos de máquinas disponibles:

Nombre CPU virtuales Memoria (GB)
n1-standard-2 2 7.5
n1-standard-4 4 15
n1-standard-8 8 30
n1-standard-16 16 60
n1-standard-32 32 120

Estos tipos de máquinas solo están disponibles en los extremos regionales. Obtén más información sobre su compatibilidad con otras funciones de AI Platform Prediction.

Obtén información sobre los precios para cada tipo de máquina. Obtén más información acerca de las especificaciones detalladas de los tipos de máquinas (N1) de Compute Engine en la documentación de Compute Engine.

Establece el formato de los datos de entrada

El formato básico de la predicción en línea es una lista de instancias de datos. Pueden ser listas sin formato de valores o miembros de un objeto JSON, según cómo configuraste las entradas en la aplicación de entrenamiento. Obtén más información sobre cómo dar formato a datos binarios y entradas complejas para la predicción.

En este ejemplo, se muestra un tensor de entrada y una clave de instancia para un modelo de TensorFlow:

{"values": [1, 2, 3, 4], "key": 1}

La composición de la string JSON puede ser compleja, siempre y cuando siga estas reglas:

  • El nivel superior de los datos de instancia debe ser un objeto JSON: un diccionario de pares clave-valor.

  • Los valores individuales en un objeto de instancia pueden ser strings, números o listas. No puedes incorporar objetos JSON.

  • Las listas deben contener solo elementos del mismo tipo (incluidas otras listas). No puedes mezclar valores numéricos y strings.

Debes pasar las instancias de entrada para la predicción en línea como el cuerpo del mensaje de la llamada projects.explain. Obtén más información sobre los requisitos de formato del cuerpo de la solicitud de predicción.

  1. Para enviar la solicitud con gcloud, asegúrate de que el archivo de entrada sea un archivo JSON delimitado por saltos de línea, con cada instancia en forma de objeto JSON, es decir, con una instancia por línea.

    {"values": [1, 2, 3, 4], "key": 1}
    {"values": [5, 6, 7, 8], "key": 2}
    

Solicita predicciones y explicaciones

Solicita tus predicciones y explicaciones:

gcloud beta ai-platform explain \
  --model $MODEL \
  --version $VERSION \
  --json-instances='your-data.txt' \
  --region us-central1

Comprende la respuesta de las explicaciones

Consulta la respuesta de ejemplo completa para obtener detalles sobre los campos de la respuesta de las explicaciones.

Para obtener información sobre cómo analizar las respuestas de las explicaciones, consulta los siguientes notebooks de ejemplo:

Revisa las explicaciones

En el siguiente ejemplo de código, se brinda ayuda para revisar un lote de explicaciones y determinar si es necesario ajustar los modelos de referencia.

En el código, solo tienes que actualizar el valor de la clave de entrada según lo que especificaste en el archivo explanation_metadata.json.

{
    "inputs": {
      "YOUR_INPUT_KEY_VALUE": {
        "input_tensor_name": "YOUR_INPUT_TENSOR_NAME"
        "input_baselines": [0]
      }
    ...
}

Por ejemplo, si el valor de la clave de entrada fuera “data”, el mismo valor sería “data” en la línea 4 del siguiente fragmento de código:

def check_explanations(example, mean_tgt_value=None, variance_tgt_value=None):
  passed_test = 0
  total_test = 1
  attribution_vals = example['attributions_by_label'][0]['attributions']['YOUR-INPUT-KEY-VALUE']

  baseline_score = example['attributions_by_label'][0]['baseline_score']
  sum_with_baseline = np.sum(attribution_vals) + baseline_score
  predicted_val = example['attributions_by_label'][0]['example_score']

  # Check 1
  # The prediction at the input is equal to that at the baseline.
  #  Please use a different baseline. Some suggestions are: random input, training
  #  set mean.
  if abs(predicted_val - baseline_score) <= 0.05:
    print('Warning: example score and baseline score are too close.')
    print('You might not get attributions.')
  else:
    passed_test += 1

  # Check 2 (only for models using Integrated Gradient explanations)
  # Ideally, the sum of the integrated gradients must be equal to the difference
  # in the prediction probability at the input and baseline. Any discrepancy in
  # these two values is due to the errors in approximating the integral.
  if explain_method == 'integrated-gradients':
    total_test += 1
    want_integral = predicted_val - baseline_score
    got_integral = sum(attribution_vals)
    if abs(want_integral-got_integral)/abs(want_integral) > 0.05:
        print('Warning: Integral approximation error exceeds 5%.')
        print('Please try increasing the number of integrated gradient steps.')
    else:
        passed_test += 1

  print(passed_test, ' out of ', total_test, ' sanity checks passed.')

Cuando analices las explicaciones, puedes ejecutar estas verificaciones en las atribuciones que recibiste:

for i in attributions_resp['explanations']:
  check_explanations(i)

Usa el error de aproximación para mejorar los resultados

Los métodos de atribución de atributos de Explicaciones de IA (Shapley con muestreo, gradientes integrados y XRAI) se basan en variantes de valores de Shapley. Debido a que los valores de Shapley son muy costosos en términos de procesamiento, Explicaciones de IA proporciona aproximaciones en lugar de valores exactos. Explicaciones de IA muestra un error de aproximación, además de los resultados de la atribución de atributos. Si el error de aproximación supera el 0.05, considera ajustar las entradas para reducir el error.

Para reducir el error de aproximación y acercarte a los valores exactos, debes cambiar las siguientes entradas:

  • Aumenta la cantidad de pasos o de rutas integrales.
  • Cambia los modelos de referencia de entrada que seleccionaste.
  • Agrega más modelos de referencia de entrada. Con los métodos de gradientes integrados y XRAI, el uso de modelos de referencia adicionales aumenta la latencia. El uso de modelos de referencia adicionales con el método de Shapley con muestreo no aumenta la latencia.

Aumenta los pasos o las rutas

Para reducir el error de aproximación, puedes aumentar lo siguiente:

  • La cantidad de rutas para el Shapley con muestreo
  • La cantidad de pasos integrales para los gradientes integrados o XRAI

Debes establecer estos parámetros cuando creas un recurso de versión durante la implementación del modelo.

Ajusta los modelos de referencia

Puedes configurar input_baselines en el archivo explanation_metadata.json. En esta sección, se proporcionan ejemplos de datos tabulares y de imágenes. Los modelos de referencia de entrada pueden representar valores medios, mínimos, máximos o aleatorios en relación con los datos de entrenamiento.

En general, debes hacer lo siguiente:

  • Comienza con un modelo de referencia que represente valores medios.
  • Cambia este modelo de referencia a uno que represente valores aleatorios.
  • Prueba dos modelos de referencia que representen valores mínimos y máximos.
  • Agrega otro modelo de referencia que represente valores aleatorios.

Ejemplo de datos tabulares

Con el siguiente código de Python, se crea el contenido de un archivo de metadatos de explicación para datos tabulares. Puedes usar Shapley con muestreo o gradientes integrados a fin de obtener atribuciones de atributos de los datos tabulares. Este código forma parte del notebook de ejemplo para datos tabulares.

Ten en cuenta que input_baselines es una lista en la que puedes especificar varios modelos de referencia. En este ejemplo, se establece un solo modelo de referencia. El modelo de referencia es una lista de valores medios para los datos de entrenamiento (en este ejemplo, train_data).

explanation_metadata = {
    "inputs": {
      "data": {
        "input_tensor_name": model.input.name,
        "input_baselines": [train_data.median().values.tolist()],
        "encoding": "bag_of_features",
        "index_feature_mapping": train_data.columns.tolist()
      }
    },
    "outputs": {
      "duration": {
        "output_tensor_name": model.output.name
      }
    },
  "framework": "tensorflow"
  }

Para establecer dos modelos de referencia que representen valores mínimos y máximos, configura input_baselines de la siguiente manera: [train_data.min().values.tolist(), train_data.max().values.tolist()]

Ejemplo de datos de imágenes

Con el siguiente código de Python, se crea el contenido de un archivo de metadatos de explicación para datos de imágenes. Puedes usar gradientes integrados a fin de obtener atribuciones de atributos de los datos de imágenes. Este código forma parte del notebook de ejemplo de los datos de imágenes.

Ten en cuenta que input_baselines es una lista en la que puedes especificar varios modelos de referencia. En este ejemplo, se establece un solo modelo de referencia. El modelo de referencia es una lista de valores aleatorios. Usar valores aleatorios en un modelo de referencia de imagen es una buena estrategia si las imágenes del conjunto de datos de entrenamiento contienen mucho blanco y negro.

De lo contrario, establece input_baselines en [0, 1] para representar las imágenes en blanco y negro.

random_baseline = np.random.rand(192,192,3)

explanation_metadata = {
    "inputs": {
      "data": {
        "input_tensor_name": "input_pixels:0",
        "modality": "image",
        "input_baselines": [random_baseline.tolist()]
      }
    },
    "outputs": {
      "probability": {
        "output_tensor_name": "dense/Softmax:0"
      }
    },
  "framework": "tensorflow"
  }

Próximos pasos