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 bucket 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

Se admiten TensorFlow 1.15, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 2.10 y 2.11. Usa tf.saved_model.save para guardar modelos en TensorFlow 2.11, pero no lo uses para TensorFlow 1.15.

Obtén más información sobre cómo guardar modelos para usarlos con AI Explanations y cómo usar el SDK de Explainable AI.

Archivo de metadatos de la explicación

Antes de implementar el modelo, debes enviar un archivo de metadatos con información sobre las entradas, los resultados y el modelo de referencia de tu modelo para que AI Explanations proporcione explicaciones para las partes correctas de tu modelo.

Recomendamos usar el SDK de Explainable AI para descubrir de forma automática las entradas y salidas de tu modelo. En la mayoría de los casos, se ahorra tiempo y esfuerzo, ya que el SDK de Explainable AI crea y sube el archivo de metadatos de explicación por ti.

Crea el archivo de metadatos de explicación de forma manual

Si tienes un caso de uso avanzado, es posible que prefieras especificar las entradas y salidas del modelo de forma manual. Para crear manualmente tu archivo de metadatos de explicación, sigue estos pasos:

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. Puedes especificar varios modelos de referencia para proporcionar información adicional. Obtén más información sobre cómo ajustar los modelos de referencia.

Localiza nombres de tensores de entrada y salida de forma manual

En la mayoría de los casos, puedes usar el SDK de Explainable AI para generar las entradas y salidas de tu modelo. Solo necesitas encontrar los nombres de tensores de entrada y salida de forma manual si usas un modelo de TensorFlow 1.15 previamente entrenado.

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 para obtener [información sobre las entradas y salidas][understanding-inputs-outputs].

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 para obtener los nombres de los tensores de entrada.
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 model y model. 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 Google Cloud CLI, 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 AI Explanations.

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 del entorno de ejecución compatibles con AI Explanations: 1.15, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 2.10 y 2.11.
  • pythonVersion: Usa “3.7” para las versiones 1.15 y posteriores 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 AI Platform Training and Prediction 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.15 \
--framework $FRAMEWORK \
--python-version 3.7 \
--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: n1-standard-4
name: projects/your_project_id/models/your_model_name/versions/your_version_name
pythonVersion: '3.7'
runtimeVersion: '1.15'
state: READY

Tipos de máquinas compatibles con las explicaciones

Para las solicitudes de AI Explanations, debes implementar tu versión de modelo con uno de los siguientes tipos de máquina. Si no especificas un tipo de máquina, la implementación fallará.

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

Nombre vCPUs 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

Después de implementar el modelo, puedes usar el SDK de Explainable AI a fin de solicitar explicaciones y visualizar los resultados de las atribuciones de atributos para los datos tabulares y de imágenes:

import explainable_ai_sdk

m = explainable_ai_sdk.load_model_from_ai_platform(PROJECT_ID, MODEL_NAME, VERSION, region=REGION)
explanations = m.explain([instance_dict])
explanations[0].visualize_attributions()

En el caso de los modelos tabulares, las atribuciones se representan en un gráfico de barras. Para los modelos de imagen, las atribuciones se muestran en la imagen de entrada con la misma configuración de visualización que especificaste cuando implementaste el modelo.

Para obtener detalles sobre cada campo en la respuesta de las explicaciones, consulta la respuesta de ejemplo completa en la referencia de la API.

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

TensorFlow 2:

TensorFlow 1.15:

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"
  }

¿Qué sigue?