Prepara los metadatos para Explicaciones de IA

Cuando implementes tu modelo, debes enviar un archivo de metadatos de explicación para configurar la solicitud de explicaciones. Este archivo de metadatos debe incluir las entradas y salidas de tu modelo a fin de seleccionar atributos para la solicitud de explicaciones. De manera opcional, también puedes incluir modelos de referencia de entrada y configurar la visualización para los datos de imágenes.

En esta guía, se explica cómo usar el SDK de Explainable AI para crear tu archivo de metadatos de explicación mientras compilas un nuevo modelo con TensorFlow 2.x o TensorFlow 1.15, o mediante un modelo existente de TensorFlow 2.x. Para solicitar explicaciones de un modelo de TensorFlow 1.x existente, debes crear tu archivo de metadatos de explicación de forma manual.

Descripción general de los metadatos de explicación

El archivo de metadatos de explicación es necesario para la implementación del modelo en AI Explanations. Especificar las entradas y salidas de tu modelo te permite seleccionar atributos específicos para la solicitud de explicaciones. Crea un archivo llamado explanation_metadata.json y súbelo a tu bucket de Cloud Storage en el mismo directorio que tu modelo guardado. El SDK de Explainable AI controla este proceso por ti, mientras compilas y guardas el modelo.

También puedes agregar parámetros de configuración opcionales a tu archivo de metadatos de explicación:

Obtén más información acerca del archivo de metadatos de explicación en la referencia de la API.

Instala el SDK de Explainable AI

El SDK de Explainable AI es un SDK de Python que admite modelos creados mediante las siguientes herramientas:

  • TensorFlow 1.15 y TensorFlow 2.x
  • Python 3.7 o una versión posterior

Instala el SDK de Explainable AI:

pip3 install explainable_ai_sdk

Encuentra entradas y salidas con el SDK de Explainable AI

El SDK de Explainable AI te ayuda a encontrar las entradas y salidas cuando compilas o entrenas un modelo de TensorFlow. En cada uno de estos casos, debes compilar tu archivo de metadatos de explicación justo después de compilar el modelo. En el caso de los modelos de Keras y Estimator, el SDK de Explainable AI infiere las entradas y salidas del grafo del modelo.

Antes de guardar el archivo de metadatos, puedes actualizar cualquier valor de entrada y salida que genere el SDK de Explainable AI y agregar campos adicionales, como modelos de referencia de entrada y preferencias de visualización.

Ejemplos del SDK de Explainable AI para TensorFlow 2.x

El SavedModelMetadataBuilder funciona para cualquier modelo guardado que se compiló con TensorFlow 2.x. En este ejemplo, el SDK de Explainable AI crea y sube tu archivo de metadatos de explicación al mismo directorio de bucket de Cloud Storage que tu modelo:

from explainable_ai_sdk.metadata.tf.v2 import SavedModelMetadataBuilder
builder = SavedModelMetadataBuilder(
    model_path)
builder.save_model_with_metadata('gs://my_bucket/model')  # Save the model and the metadata.

De manera opcional, puedes usar la función get_metadata() para comprobar los metadatos que se generan antes de guardarlos y subirlos.

Si usas una función de TensorFlow para guardar y subir tu modelo, puedes usar save_metadata() para compilar y exportar solo los metadatos de explicación:

from explainable_ai_sdk.metadata.tf.v2 import SavedModelMetadataBuilder
# We want to explain 'xai_model' signature.
builder = SavedModelMetadataBuilder(export_path, signature_name='xai_model')
random_baseline = np.random.rand(192, 192, 3)
builder.set_image_metadata(
    'numpy_inputs',
    input_baselines=[random_baseline.tolist()])
builder.save_metadata(export_path)

En este ejemplo, también se muestra cómo establecer un modelo de referencia de entrada para los datos de imágenes con ruido aleatorio como modelo de referencia. Usa un modelo de referencia de entrada que sea el más adecuado para tu conjunto de datos. Como punto de partida, consulta ejemplos de modelos de referencia de AI Explanations. Para actualizar tus metadatos y agregar más campos, usa la función de método set que coincida con tu tipo de datos: set_numeric_metadata(), set_categorical_metadata() o set_image_metadata().

Ejemplos del SDK de Explainable AI para TensorFlow 1.15

El SDK de Explainable AI es compatible con modelos de TensorFlow 1.15 compilados con tf.keras, tf.estimator o tf.Graph.

Keras

El SDK de Explainable AI es compatible modelos de Keras compilados con las API secuenciales y funcionales, así como con modelos personalizados compilados mediante la subclasificación de la clase Model. Obtén más información sobre los diferentes tipos de modelos de Keras.

import tensorflow.compat.v1.keras as keras
from explainable_ai_sdk.metadata.tf.v1 import KerasGraphMetadataBuilder

# Build a model.
model = keras.models.Sequential()
model.add(keras.layers.Dense(32, activation='relu', input_dim=10))
model.add(keras.layers.Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', metrics=['accuracy'])
model.fit(
    np.random.random((1, 10)),
    np.random.randint(2, size=(1, 1)),
    epochs=10,
    batch_size=32)

# Set the path to your model.
model_path = MODEL_PATH

# Build the metadata.
builder = KerasGraphMetadataBuilder(model)
builder.save_model_with_metadata(model_path)

Después de compilar el modelo, usa el compilador de metadatos para obtener las entradas y salidas.

Estimador

El SDK de Explainable AI con modelos de Estimator. Para el compilador de metadatos, debes especificar las columnas de atributos de entrada, la función de entrada de entrega y una clave de salida.

import tensorflow.compat.v1 as tf
from explainable_ai_sdk.metadata.tf.v1 import EstimatorMetadataBuilder


# Build a model.
language = tf.feature_column.categorical_column_with_vocabulary_list(
    key='language',
    vocabulary_list=('english', 'korean'),
    num_oov_buckets=1)
language_indicator = tf.feature_column.indicator_column(language)
class_identity = tf.feature_column.categorical_column_with_identity(
    key='class_identity', num_buckets=4)
class_id_indicator = tf.feature_column.indicator_column(class_identity)
age = tf.feature_column.numeric_column(key='age', default_value=0.0)
classifier_dnn = tf.estimator.DNNClassifier(
    hidden_units=[4],
    feature_columns=[age, language_indicator, language_embedding, class_id_indicator])
classifier_dnn.train(input_fn=_train_input_fn, steps=5)

# Build the metadata.
md_builder = EstimatorMetadataBuilder(
    classifier_dnn, [age, language, class_identity],  _get_json_serving_input_fn, 'logits')
model_path = MODEL_PATH

Gráfico

El SDK de Explainable AI también es compatible con modelos de TensorFlow compilados sin las API de Keras o Estimator.

import tensorflow.compat.v1 as tf
from explainable_ai_sdk.metadata.tf.v1 import GraphMetadataBuilder

# Build a model.
sess = tf.Session(graph=tf.Graph())
with sess.graph.as_default():
  x = tf.placeholder(shape=[None, 10], dtype=tf.float32, name='inp')
  weights = tf.constant(1., shape=(10, 2), name='weights')
  bias_weight = tf.constant(1., shape=(2,), name='bias')
  linear_layer = tf.add(tf.matmul(x, weights), bias_weight)
  prediction = tf.nn.relu(linear_layer)

# Build the metadata.
builder = GraphMetadataBuilder(
    session=sess, tags=['serve'])
builder.add_numeric_metadata(x)
builder.add_output_metadata(prediction)
model_path = os.path.join('gs://', 'BUCKET_NAME', 'PATH_TO_MODEL')
builder.save_model_with_metadata(model_path)

Después de compilar el grafo del modelo, debes compilar los metadatos de la explicación con una o más entradas de modelo y una salida. El SDK de Explainable AI proporciona una función para ayudarte a agregar metadatos para cada tipo de entrada: numérica, categórica, de imagen y de texto.

El archivo explanation_metadata.json resultante es similar a este ejemplo:

{
  "outputs": {
    "Relu": {
      "output_tensor_name": "Relu:0"
    }
  },
  "inputs": {
    "inp": {
      "input_tensor_name": "inp:0",
      "encoding": "identity",
      "modality": "numeric"
    }
  },
  "framework": "Tensorflow",
  "tags": [
    "explainable_ai_sdk"
  ]
}

Configuración opcional de metadatos de explicación

Según la configuración predeterminada, el SDK de Explainable AI produce un archivo de metadatos de explicación con solo la información requerida sobre las entradas y salidas del modelo. Antes de guardar el archivo de metadatos de explicación, puedes incluir configuraciones opcionales para los modelos de referencia de entrada y la visualización de imágenes. Como alternativa, puedes editar el archivo de metadatos de explicación una vez creado.

Configura modelo de referencia de entrada

Los modelos de referencia de entrada representan un atributo que no proporciona información adicional. Los modelos de referencia para modelos tabulares pueden ser valores medios, mínimos, máximos o aleatorios en relación con tus datos de entrenamiento. De manera similar, para los modelos de imagen, tus modelos de referencia pueden ser una imagen negra, una imagen blanca, una imagen gris o una imagen con valores aleatorios de píxeles.

Se recomienda comenzar con un modelo de referencia. Si es necesario, puedes cambiar tu modelo de referencia o usar varios modelos de referencia. Consulta ejemplos sobre cómo ajustar tu modelo de referencia.

Configura la visualización de los datos de imágenes

Si trabajas con datos de imágenes, puedes configurar cómo se mostrarán los resultados de explicación agregando una configuración de visualización al archivo de metadatos de explicación. Si no agregas esto, AI Explanations usa la configuración predeterminada.

Consulta los ejemplos de opciones de visualización u obtén más información sobre la configuración en la referencia de la API.

¿Qué sigue?