Ejecutar trabajos de procesamiento de SageMaker Clarify para obtener análisis del sesgo y explicabilidad

Los siguientes ejemplos muestran cómo configurar el análisis del sesgo y el análisis de la explicabilidad para un conjunto de datos tabular en formato CSV. En estos ejemplos, el conjunto de datos entrante tiene cuatro columnas de características y una columna de etiquetas binarias, Target. El contenido del conjunto de datos es el siguiente. Un valor de etiqueta de 1 indica un resultado positivo.

Target,Age,Gender,Income,Occupation
0,25,0,2850,2
1,36,0,6585,0
1,22,1,1759,1
0,48,0,3446,1
...

Este objeto DataConfig especifica el conjunto de datos de entrada y dónde almacenar la salida. El parámetro s3_data_input_path puede ser un URI de un archivo de conjunto de datos o un prefijo URI de Amazon S3. Si proporciona un prefijo URI de S3, el trabajo de procesamiento de SageMaker Clarify recopila de forma recursiva todos los archivos de Amazon S3 ubicados bajo el prefijo. El valor de s3_output_path debe ser un prefijo URI de S3 que contenga los resultados del análisis. SageMaker usa s3_output_path mientras compila y no puede tomar el valor de un parámetro, propiedad, expresión o ExecutionVariable de Canalizaciones de SageMaker que se utilice durante el tiempo de ejecución. En el siguiente ejemplo de código se muestra cómo especificar una configuración de datos para el conjunto de datos de entrada de ejemplo anterior.

data_config = clarify.DataConfig(
    s3_data_input_path=dataset_s3_uri,
    dataset_type='text/csv',
    headers=['Target', 'Age', 'Gender', 'Income', 'Occupation'],
    label='Target',
    s3_output_path=clarify_job_output_s3_uri,
)

Cómo calcular todas las métricas de sesgo previas al entrenamiento para un conjunto de datos CSV

El siguiente ejemplo de código muestra cómo configurar un objeto BiasConfig para medir el sesgo de la entrada de la muestra anterior hacia las muestras con un valor Gender de 0.

bias_config = clarify.BiasConfig(
    label_values_or_threshold=[1],
    facet_name='Gender',
    facet_values_or_threshold=[0],
)

El siguiente ejemplo de código muestra cómo utilizar una instrucción de ejecución para iniciar un trabajo de procesamiento de SageMaker Clarify que calcula todas las métricas de sesgo previas al entrenamiento para un conjunto de datos de entrada.

clarify_processor.run_pre_training_bias(
     data_config=data_config,
    data_bias_config=bias_config,
    methods="all",
)

Como alternativa, puede elegir qué métricas calcular si asigna una lista de métricas de sesgo previas al entrenamiento al parámetro de métodos. Por ejemplo, si sustituye methods="all" por methods=["CI", "DPL"] indica al procesador de SageMaker Clarify que calcule únicamente el Desequilibrio de clases y la Diferencia en las proporciones de las etiquetas.

Cómo calcular todas las métricas de sesgo posteriores al entrenamiento para un conjunto de datos CSV

Puede calcular las métricas de sesgo previas al entrenamiento antes del entrenamiento. Sin embargo, para calcular las métricas de sesgo posteriores al entrenamiento debe tener un modelo entrenado. El siguiente ejemplo de salida proviene de un modelo de clasificación binaria que genera datos en formato CSV. En este ejemplo de salida, cada fila contiene dos columnas. La primera columna contiene la etiqueta predicha y la segunda columna contiene el valor de probabilidad de esa etiqueta.

0,0.028986845165491
1,0.825382471084594
...

En el siguiente ejemplo de configuración, el objeto ModelConfig indica al trabajo que implemente el modelo de SageMaker en un punto de conexión efímero. El punto de conexión utiliza una instancia de inferencia ml.m4.xlarge. Como el parámetro content_type y el parámetro accept_type no están configurados, utilizan automáticamente el valor del parámetrodataset_type, que es text/csv.

model_config = clarify.ModelConfig(
    model_name=your_model,
    instance_type='ml.m4.xlarge',
    instance_count=1,
)

El siguiente ejemplo de configuración utiliza un objeto ModelPredictedLabelConfig con un índice de etiqueta de 0. Esto indica al trabajo de procesamiento de SageMaker Clarify que localice la etiqueta predicha en la primera columna de la salida del modelo. En este ejemplo, el trabajo de procesamiento utiliza la indexación de base cero.

predicted_label_config = clarify.ModelPredictedLabelConfig(
    label=0,
)

En combinación con el ejemplo de configuración anterior, el siguiente ejemplo de código inicia un trabajo de procesamiento de SageMaker Clarify para calcular todas las métricas de sesgo posteriores al entrenamiento.

clarify_processor.run_post_training_bias(
    data_config=data_config,
    data_bias_config=bias_config,
    model_config=model_config,
    model_predicted_label_config=predicted_label_config,
    methods="all",
)

Igualmente, puede elegir qué métricas calcular si asigna una lista de métricas de sesgo posteriores al entrenamiento al parámetro methods. Por ejemplo, sustituya methods=“all” por methods=["DPPL", "DI"] para calcular solo la Diferencia en las proporciones positivas de las etiquetas predichas y el Impacto dispar.

Cómo calcular todas las métricas de sesgo para un conjunto de datos CSV

El siguiente ejemplo de configuración muestra cómo ejecutar todas las métricas de sesgo previas y posteriores al entrenamiento en un trabajo de procesamiento de SageMaker Clarify.

clarify_processor.run_bias(
    data_config=data_config,
     bias_config=bias_config,
     model_config=model_config,
    model_predicted_label_config=predicted_label_config,
    pre_training_methods="all",
    post_training_methods="all",
)

Para ver un ejemplo de cuaderno con instrucciones sobre cómo ejecutar un trabajo de procesamiento de SageMaker Clarify en SageMaker Studio Classic para detectar sesgos, consulte Fairness and Explainability with SageMaker Clarify.

Cómo calcular los valores SHAP para un conjunto de datos CSV

SageMaker Clarify proporciona atribuciones de características mediante el algoritmo KernelSHAP. El análisis SHAP requiere el valor o la puntuación de probabilidad en lugar de la etiqueta predicha, por lo que este objeto ModelPredictedLabelConfig tiene un índice de probabilidad 1. Esto indica al trabajo de procesamiento de SageMaker Clarify que extraiga la puntuación de probabilidad de la segunda columna de la salida del modelo (mediante la indexación basada en cero).

probability_config = clarify.ModelPredictedLabelConfig(
    probability=1,
)

El objeto SHAPConfig proporciona los parámetros de análisis SHAP. En este ejemplo, se omite el parámetro SHAP baseline y el valor del parámetro num_clusters es 1. Esto indica al procesador de SageMaker Clarify que calcule una referencia SHAP en función de la agrupación del conjunto de datos de entrada. Si desea elegir el conjunto de datos de referencia, consulte Referencias SHAP para la explicabilidad.

shap_config = clarify.SHAPConfig(
    num_clusters=1,
)

El siguiente ejemplo de código lanza un trabajo de procesamiento de SageMaker Clarify para calcular valores SHAP.

clarify_processor.run_explainability(
    data_config=data_config,
    model_config=model_config,
    model_scores=probability_config,
    explainability_config=shap_config,
)

Para ver un ejemplo de cuaderno con instrucciones sobre cómo ejecutar un trabajo de procesamiento de SageMaker Clarify en SageMaker Studio Classic para calcular valores SHAP, consulte Fairness and Explainability with SageMaker Clarify.

Cómo calcular los gráficos de dependencia parcial (PDPs) para un conjunto de datos CSV

Los PDPs muestran la dependencia de la respuesta objetivo predicha con respecto a una o más características de entrada de interés y, al mismo tiempo, mantienen constantes todas las demás características. Una línea inclinada hacia arriba, o curva en el PDP, indica que la relación entre el objetivo y las características de entrada es positiva, y la inclinación indica la fortaleza de la relación. Una línea o curva inclinada hacia abajo indica que si una característica de entrada disminuye, la variable objetivo aumenta. De forma intuitiva, puede interpretar la dependencia parcial como la respuesta de la variable objetivo a cada característica de entrada de interés.

El siguiente ejemplo de configuración sirve para utilizar un objeto PDPConfig para indicar al trabajo de procesamiento de SageMaker Clarify que calcule la importancia de la característica Income.

pdp_config = clarify.PDPConfig(
    features=["Income"],
    grid_resolution=10,
)

En el ejemplo anterior, el parámetro grid_resolution divide el rango de valores de la característica Income en 10 buckets. El trabajo de procesamiento de SageMaker Clarify generará PDPs para Income divididos en 10 segmentos en el eje x. El eje y mostrará el impacto marginal de Income en las predicciones.

El siguiente ejemplo de código lanza un trabajo de procesamiento de SageMaker Clarify para calcular PDPs.

clarify_processor.run_explainability(
    data_config=data_config,
    model_config=model_config,
    model_scores=probability_config,
    explainability_config=pdp_config,
)

Para ver un ejemplo de cuaderno con instrucciones sobre cómo ejecutar un trabajo de procesamiento de SageMaker Clarify en SageMaker Studio Classic para calcular PDPs, consulte Explainability with SageMaker Clarify - Partial Dependence Plots (PDP).

Cómo calcular los valores SHAP y PDPs para un conjunto de datos CSV

Puede calcular los valores SHAP y PDPs en un único trabajo de procesamiento de SageMaker Clarify. En el siguiente ejemplo de configuración, el parámetro top_k_features de un objeto PDPConfig nuevo se establece en 2. Esto indica al trabajo de procesamiento de SageMaker Clarify que calcule los PDPs para las 2 características principales con los valores SHAP globales más altos.

shap_pdp_config = clarify.PDPConfig(
    top_k_features=2,
    grid_resolution=10,
)

El siguiente ejemplo de código lanza un trabajo de procesamiento de SageMaker Clarify para calcular los valores SHAP y PDPs.

clarify_processor.run_explainability(
    data_config=data_config,
    model_config=model_config,
    model_scores=probability_config,
    explainability_config=[shap_config, shap_pdp_config],
)

Los siguientes ejemplos muestran cómo configurar el análisis de sesgo y el análisis de explicabilidad para un conjunto de datos tabular en formato denso de JSON Lines de SageMaker. Para obtener más información, consulte Formato de solicitud JSONLINES. En estos ejemplos, el conjunto de datos entrante tiene los mismos datos que en la sección anterior, pero están en el formato JSON Lines. Cada línea es un objeto JSON válido. La clave Features apunta a una matriz de valores de características, y la clave Label apunta a la etiqueta de verdad fundamental.

{"Features":[25,0,2850,2],"Label":0}
{"Features":[36,0,6585,0],"Label":1}
{"Features":[22,1,1759,1],"Label":1}
{"Features":[48,0,3446,1],"Label":0}
...

En el siguiente ejemplo de configuración, el objeto DataConfigespecifica el conjunto de datos de entrada y dónde almacenar la salida.

data_config = clarify.DataConfig(
    s3_data_input_path=jsonl_dataset_s3_uri,
    dataset_type='application/jsonlines',
    headers=['Age', 'Gender', 'Income', 'Occupation', 'Target'],
    label='Label',
    features='Features',
    s3_output_path=clarify_job_output_s3_uri,
)

En el ejemplo de configuración anterior, el parámetro features se establece en la expresión Features de JMESPath para que el trabajo de procesamiento de SageMaker Clarify pueda extraer la matriz de características de cada registro. El parámetro label se establece en la expresión JMESPath Label para que el trabajo de procesamiento de SageMaker Clarify pueda extraer la etiqueta de verdad fundamental de cada registro. El parámetro s3_data_input_path puede ser un URI de un archivo de conjunto de datos o un prefijo URI de Amazon S3. Si proporciona un prefijo URI de S3, el trabajo de procesamiento de SageMaker Clarify recopila de forma recursiva todos los archivos de S3 ubicados bajo el prefijo. El valor de s3_output_path debe ser un prefijo URI de S3 que contenga los resultados del análisis. SageMaker usa s3_output_path mientras compila y no puede tomar el valor de un parámetro, propiedad, expresión o ExecutionVariable de Canalizaciones de SageMaker que se utilice durante el tiempo de ejecución.

Debe tener un modelo entrenado para calcular las métricas de sesgo posteriores al entrenamiento de la importancia de las características. El siguiente ejemplo proviene de un modelo de clasificación binaria que genera datos en formato JSON Lines en el formato del ejemplo. Cada fila de la salida del modelo es un objeto JSON válido. La clave predicted_label apunta a la etiqueta predicha y la clave probability apunta al valor de probabilidad.

{"predicted_label":0,"probability":0.028986845165491}
{"predicted_label":1,"probability":0.825382471084594}
...

En el siguiente ejemplo de configuración, un objeto ModelConfig indica al trabajo de procesamiento de SageMaker Clarify que implemente el modelo de SageMaker en un punto de conexión efímero. El punto de conexión utiliza una instancia de inferencia ml.m4.xlarge.

model_config = clarify.ModelConfig(
    model_name=your_model,
    instance_type='ml.m4.xlarge',
    instance_count=1,
    content_template='{"Features":$features}',
)

En el ejemplo de configuración anterior, los parámetros content_type y accept_type no están configurados. Por lo tanto, utilizan automáticamente el valor del parámetro dataset_type del objeto DataConfig, que es application/jsonlines. El trabajo de procesamiento de SageMaker Clarify utiliza el parámetro content_template para componer la entrada del modelo, sustituyendo el marcador de posición $features por un conjunto de características.

El siguiente ejemplo de configuración muestra cómo establecer el parámetro de etiqueta del objeto ModelPredictedLabelConfig en la expresión JMESPath predicted_label. Esto extraerá la etiqueta predicha de la salida del modelo.

predicted_label_config = clarify.ModelPredictedLabelConfig(
    label='predicted_label',
)

El siguiente ejemplo de configuración muestra cómo establecer el parámetro probability del objeto ModelPredictedLabelConfig en la expresión JMESPath probability. Esto extraerá la puntuación de la salida del modelo.

probability_config = clarify.ModelPredictedLabelConfig(
    probability='probability',
)

Para calcular las métricas de sesgo y la importancia de las características de los conjuntos de datos en formato JSON Lines, utilice las mismas instrucciones de ejecución y objetos de configuración que en la sección anterior para los conjuntos de datos CSV. Puede ejecutar un trabajo de procesamiento de SageMaker Clarify en SageMaker Studio Classic para detectar sesgos y calcular la importancia de las características. Para obtener instrucciones y un ejemplo de cuaderno, consulte Fairness and Explainability with SageMaker Clarify (JSON Lines Format).

SageMaker Clarify admite explicaciones para los modelos de procesamiento de lenguaje natural (NLP). Estas explicaciones le ayudan a entender qué secciones del texto son las más importantes para las predicciones del modelo. Puede explicar la predicción del modelo para una sola instancia del conjunto de datos de entrada, o las predicciones del modelo del conjunto de datos de referencia. Para comprender y visualizar el comportamiento de un modelo, puede especificar varios niveles de granularidad. Para ello, defina la longitud del segmento de texto, como sus tokens, oraciones y párrafos.

La explicabilidad del NLP de SageMaker Clarify es compatible con los modelos de clasificación y regresión. También puede usar SageMaker Clarify para explicar el comportamiento del modelo en conjuntos de datos multimodales que contienen elementos textuales, categóricos o numéricos. La explicabilidad del NLP de los conjuntos de datos multimodales puede ayudarle a comprender la importancia de cada característica para la salida del modelo. SageMaker Clarify admite 62 idiomas y puede gestionar texto que incluye varios idiomas.

El siguiente ejemplo muestra un archivo de configuración de análisis que calcula la importancia de las características para el NLP. En este ejemplo, el conjunto de datos entrante es un conjunto de datos tabular en formato CSV, con una columna de etiqueta binaria y dos columnas de características.

0,2,"Flavor needs work"
1,3,"They taste good"
1,5,"The best"
0,1,"Taste is awful"
...

El siguiente ejemplo de configuración muestra cómo especificar un conjunto de datos de entrada en formato CSV y una ruta de datos de salida con el objeto DataConfig.

nlp_data_config = clarify.DataConfig(
    s3_data_input_path=nlp_dataset_s3_uri,
    dataset_type='text/csv',
    headers=['Target', 'Rating', 'Comments'],
    label='Target',
    s3_output_path=clarify_job_output_s3_uri,
)

En el ejemplo de configuración anterior, el parámetro s3_data_input_path puede ser un URI de un archivo de conjunto de datos o un prefijo URI de Amazon S3. Si proporciona un prefijo URI de S3, el trabajo de procesamiento de SageMaker Clarify recopila de forma recursiva todos los archivos de S3 ubicados bajo el prefijo. El valor de s3_output_path debe ser un prefijo URI de S3 que contenga los resultados del análisis. SageMaker usa s3_output_path mientras compila y no puede tomar el valor de un parámetro, propiedad, expresión o ExecutionVariable de Canalizaciones de SageMaker que se utilice durante el tiempo de ejecución.

El siguiente ejemplo de salida se creó a partir de un modelo de clasificación binaria entrenado en el conjunto de datos de entrada anterior. El modelo de clasificación acepta datos CSV y genera una puntuación única entre 0 y 1.

0.491656005382537
0.569582343101501
...

En el siguiente ejemplo se muestra cómo configurar el objeto ModelConfig para implementar un modelo de SageMaker. En este ejemplo, un punto de conexión efímero implementa el modelo. Este punto de conexión utiliza una instancia de inferencia ml.g4dn.xlarge equipada con una GPU para acelerar la inferencia.

nlp_model_config = clarify.ModelConfig(
    model_name=your_nlp_model_name,
    instance_type='ml.g4dn.xlarge',
    instance_count=1,
)

El siguiente ejemplo muestra cómo configurar el objeto ModelPredictedLabelConfigpara localizar la probabilidad (puntuación) en la primera columna con un índice de 0.

probability_config = clarify.ModelPredictedLabelConfig(
    probability=0,
)

El siguiente ejemplo de configuración SHAP muestra cómo ejecutar un análisis de explicabilidad simbólica mediante un modelo y un conjunto de datos de entrada en inglés.

text_config = clarify.TextConfig(
    language='english',
    granularity='token',
)
nlp_shap_config = clarify.SHAPConfig(
    baseline=[[4, '[MASK]']],
    num_samples=100,
    text_config=text_config,
)

En el ejemplo anterior, el objeto TextConfig activa el análisis de explicabilidad del NLP. El parámetro granularity indica que el análisis debe analizar los tokens. En inglés, cada token es una palabra. Para otros idiomas, consulte la documentación de spaCy sobre tokenización, que SageMaker Clarify utiliza para el procesamiento del NLP. El ejemplo anterior también muestra cómo utilizar un Ratingpromedio de 4 para establecer una instancia de referencia SHAP in situ. Se utiliza un token de máscara especial [MASK] para reemplazar un token (palabra) en Comments.

En el ejemplo anterior, si la instancia es 2,"Flavor needs work", establece la referencia en un Rating promedio de 4 con la siguiente referencia.

4, '[MASK]'

En el ejemplo anterior, el explicador de SageMaker Clarify itera a través de cada token y lo sustituye por la máscara, de la siguiente manera.

2,"[MASK] needs work"

4,"Flavor [MASK] work"

4,"Flavor needs [MASK]"

A continuación, el explicador de SageMaker Clarify enviará cada línea a su modelo para realizar predicciones. Esto es para que el explicador aprenda las predicciones con y sin las palabras enmascaradas. A continuación, el explicador de SageMaker Clarify utiliza esta información para calcular la contribución de cada token.

El siguiente ejemplo de código lanza un trabajo de procesamiento de SageMaker Clarify para calcular valores SHAP.

clarify_processor.run_explainability(
    data_config=nlp_data_config,
    model_config=nlp_model_config,
    model_scores=probability_config,
    explainability_config=nlp_shap_config,
)

Para ver un ejemplo de cuaderno con instrucciones sobre cómo ejecutar un trabajo de procesamiento de SageMaker Clarify en SageMaker Studio Classic para el análisis de explicabilidad del NLP, consulte Explaining Text Sentiment Analysis Using SageMaker Clarify.

SageMaker Clarify genera mapas térmicos que proporcionan información sobre cómo los modelos de visión artificial clasifican y detectan los objetos en las imágenes.

En el siguiente ejemplo de configuración, el conjunto de datos de entrada consta de imágenes JPEG.

cv_data_config = clarify.DataConfig(
    s3_data_input_path=cv_dataset_s3_uri,
    dataset_type="application/x-image",
    s3_output_path=clarify_job_output_s3_uri,
)

En el ejemplo de configuración anterior, el objeto DataConfig contiene una s3_data_input_path establecida en un prefijo URI de Amazon S3. El trabajo de procesamiento de SageMaker Clarify recopila de forma recursiva todos los archivos de imagen situados bajo el prefijo. El parámetro s3_data_input_path puede ser un URI de un archivo de conjunto de datos o un prefijo URI de Amazon S3. Si proporciona un prefijo URI de S3, el trabajo de procesamiento de SageMaker Clarify recopila de forma recursiva todos los archivos de S3 ubicados bajo el prefijo. El valor de s3_output_path debe ser un prefijo URI de S3 que contenga los resultados del análisis. SageMaker usa s3_output_path mientras compila y no puede tomar el valor de un parámetro, propiedad, expresión o ExecutionVariable de Canalizaciones de SageMaker que se utilice durante el tiempo de ejecución.

Cómo explicar un modelo de clasificación de imágenes

El trabajo de procesamiento de SageMaker Clarify explica las imágenes mediante el algoritmo KernelSHAP, que trata la imagen como un conjunto de superpíxeles. Dado que se trata de un conjunto de datos formado por imágenes, el trabajo de procesamiento genera un conjunto de datos de imágenes en el que cada imagen muestra el mapa térmico de los superpíxeles pertinentes.

El siguiente ejemplo de configuración muestra cómo configurar un análisis de explicabilidad mediante un modelo de clasificación de imágenes de SageMaker. Para obtener más información, consulte Image Classification - MXNet.

ic_model_config = clarify.ModelConfig(
    model_name=your_cv_ic_model,
    instance_type="ml.p2.xlarge",
    instance_count=1,
    content_type="image/jpeg",
    accept_type="application/json",
)

En el ejemplo de configuración anterior, un modelo denominado your_cv_ic_model se ha entrenado para que clasifique los animales de las imágenes JPEG de entrada. El objeto ModelConfig del ejemplo anterior indica al trabajo de procesamiento de SageMaker Clarify que implemente el modelo de SageMaker en un punto de conexión efímero. Para acelerar la inferencia, el punto de conexión utiliza una instancia de inferencia ml.p2.xlarge equipada con una GPU.

Después de enviar una imagen JPEG a un punto de conexión, el punto de conexión la clasifica y devuelve una lista de puntuaciones. Cada puntuación corresponde a una categoría. El objeto ModelPredictedLabelConfig proporciona el nombre de cada categoría, de la siguiente manera.

ic_prediction_config = clarify.ModelPredictedLabelConfig(
    label_headers=['bird', 'cat', 'dog'],
)

Un ejemplo de salida para la entrada anterior ['ave','gato','perro'] podría ser 0,3,0,6,0,1, donde 0,3 representa la puntuación de confianza para clasificar una imagen como ave.

El siguiente ejemplo de configuración SHAP muestra cómo generar explicaciones para un problema de clasificación de imágenes. Utiliza un objeto ImageConfig para activar el análisis.

ic_image_config = clarify.ImageConfig(
    model_type="IMAGE_CLASSIFICATION",
    num_segments=20,
    segment_compactness=5,
)

ic_shap_config = clarify.SHAPConfig(
    num_samples=100,
    image_config=ic_image_config,
)

SageMaker Clarify extrae las características mediante el método Simple Linear Iterative Clustering (SLIC) de la biblioteca scikit-learn para la segmentación de imágenes. En el ejemplo de configuración anterior, el parámetro model_type indica el tipo de problema de clasificación de imágenes. El parámetro num_segments estima el número aproximado de segmentos que se etiquetarán en la imagen de entrada. A continuación, el número de segmentos se pasa al parámetro slic n_segments.

Cada segmento de la imagen se considera un superpíxel característica y los valores SHAP locales se calculan para cada segmento. El parámetro segment_compactness determina la forma y el tamaño de los segmentos de imagen que se generan con el método slic scikit-image. A continuación, los tamaños y las formas de los segmentos de la imagen se transfieren al parámetro slic compactness.

El siguiente ejemplo de código lanza un trabajo de procesamiento de SageMaker Clarify para generar mapas térmicos para sus imágenes. Los valores positivos del mapa térmico muestran que la característica aumentó la puntuación de confianza a la hora de detectar el objeto. Los valores negativos indican que la característica disminuyó la puntuación de confianza.

clarify_processor.run_explainability(
    data_config=cv_data_config,
    model_config=ic_model_config,
    model_scores=ic_prediction_config,
    explainability_config=ic_shap_config,
)

Para ver un ejemplo de cuaderno que utiliza SageMaker Clarify para clasificar imágenes y explicar su clasificación, consulte Explaining Image Classification with SageMaker Clarify.

Cómo explicar un modelo de detección de objetos

Un trabajo de procesamiento de SageMaker Clarify puede detectar y clasificar los objetos de una imagen y, a continuación, proporcionar una explicación del objeto detectado. El proceso de explicación es el siguiente.

En el siguiente ejemplo de configuración, un modelo de detección de objetos de SageMaker your_cv_od_model se entrena con imágenes JPEG para identificar los animales que aparecen en ellas.

od_model_config = clarify.ModelConfig(
    model_name=your_cv_ic_model,
    instance_type="ml.p2.xlarge",
    instance_count=1,
    content_type="image/jpeg",
    accept_type="application/json",
)

El objeto ModelConfig del ejemplo de configuración anterior indica al trabajo de procesamiento de SageMaker Clarify que implemente el modelo de SageMaker en un punto de conexión efímero. Para acelerar el procesamiento de las imágenes, este punto de conexión utiliza una instancia de inferencia ml.p2.xlarge equipada con una GPU.

En el siguiente ejemplo de configuración, el objeto ModelPredictedLabelConfig proporciona el nombre de cada categoría para su clasificación.

ic_prediction_config = clarify.ModelPredictedLabelConfig(
    label_headers=['bird', 'cat', 'dog'],
)

El siguiente ejemplo de configuración SHAP muestra cómo generar explicaciones para un problema de detección de objetos.

od_image_config = clarify.ImageConfig(
    model_type="OBJECT_DETECTION",
    num_segments=20,
    segment_compactness=5,
    max_objects=5,
    iou_threshold=0.5,
    context=1.0,
)
od_shap_config = clarify.SHAPConfig(
    num_samples=100,
    image_config=image_config,
)

En la configuración del ejemplo anterior, el objeto ImageConfig activa el análisis. El parámetro model_type indica que el tipo de problema es la detección de objetos. Para ver una descripción detallada del resto de parámetros, consulte Archivos de configuración del análisis.

El siguiente ejemplo de código lanza un trabajo de procesamiento de SageMaker Clarify para generar mapas térmicos para sus imágenes. Los valores positivos del mapa térmico muestran que la característica aumentó la puntuación de confianza a la hora de detectar el objeto. Los valores negativos indican que la característica disminuyó la puntuación de confianza.

clarify_processor.run_explainability(
    data_config=cv_data_config,
    model_config=od_model_config,
    model_scores=od_prediction_config,
    explainability_config=od_shap_config,
)

Para ver un ejemplo de cuaderno que utiliza SageMaker Clarify para detectar objetos en una imagen y explicar sus predicciones, consulte Explaining object detection models with Amazon SageMaker Clarify.

Los siguientes ejemplos muestran cómo configurar datos en el formato denso JSON de SageMaker para explicar un modelo de previsión de series temporales. Para obtener más información sobre el formato JSON, consulte Formato de solicitud JSON.

[
    {
        "item_id": "item1",
        "timestamp": "2019-09-11",
        "target_value": 47650.3,
        "dynamic_feature_1": 0.4576,
        "dynamic_feature_2": 0.2164,
        "dynamic_feature_3": 0.1906,
        "static_feature_1": 3,
        "static_feature_2": 4
    },
    {
        "item_id": "item1",
        "timestamp": "2019-09-12",
        "target_value": 47380.3,
        "dynamic_feature_1": 0.4839,
        "dynamic_feature_2": 0.2274,
        "dynamic_feature_3": 0.1889,
        "static_feature_1": 3,
        "static_feature_2": 4
    },
    {
        "item_id": "item2",
        "timestamp": "2020-04-23",
        "target_value": 35601.4,
        "dynamic_feature_1": 0.5264,
        "dynamic_feature_2": 0.3838,
        "dynamic_feature_3": 0.4604,
        "static_feature_1": 1,
        "static_feature_2": 2
    },
]

Configuración de datos

Utilice TimeSeriesDataConfig para comunicar a su trabajo de explicabilidad cómo analizar correctamente los datos del conjunto de datos de entrada pasado, como se muestra en el siguiente ejemplo de configuración:

time_series_data_config = clarify.TimeSeriesDataConfig(
    target_time_series='[].target_value',
    item_id='[].item_id',
    timestamp='[].timestamp',
    related_time_series=['[].dynamic_feature_1', '[].dynamic_feature_2', '[].dynamic_feature_3'],
    static_covariates=['[].static_feature_1', '[].static_feature_2'],
    dataset_format='timestamp_records',
)

Configuración asimétrica de valores de Shapley

Utilice AsymmetricShapleyValueConfig para definir los argumentos del análisis de la explicación del modelo de previsión de series temporales, como la referencia, la dirección, el nivel de detalle y el número de muestras. Los valores de referencia se establecen para los tres tipos de datos: series temporales relacionadas, covariables estáticas y series temporales objetivo. La configuración AsymmetricShapleyValueConfig informa al procesador de SageMaker Clarify cómo calcular las atribuciones de características para un elemento cada vez. La siguiente configuración muestra un ejemplo de definición de AsymmetricShapleyValueConfig.

asymmetric_shapley_value_config = AsymmetricShapleyValueConfig(
    direction="chronological",
    granularity="fine-grained",
    num_samples=10,
    baseline={
        "related_time_series": "zero", 
        "static_covariates": {
            "item1": [0, 0], "item2": [0, 0]
        }, 
        "target_time_series": "zero"
    },
)

Los valores que proporcione a AsymmetricShapleyValueConfig se pasan a la configuración de análisis como una entrada en methods con la clave asymmetric_shapley_value.

Configuración del modelo

Puede controlar la estructura de la carga útil enviada desde el procesador de SageMaker Clarify. En el siguiente ejemplo de código, un objeto de configuración ModelConfig dirige un trabajo de explicabilidad de previsión de series temporales para agregar registros mediante la sintaxis de JMESPath a '{"instances": $records}', donde la estructura de cada registro se define con la siguiente plantilla de registro '{"start": $start_time, "target": $target_time_series, "dynamic_feat": $related_time_series, "cat": $static_covariates}'. Tenga en cuenta que $start_time, $target_time_series, $related_time_series y $static_covariates son símbolos internos que se utilizan para asignar los valores del conjunto de datos a los valores de las solicitudes de punto de conexión.

model_config = clarify.ModelConfig(
    model_name=your_model,
    instance_type='ml.m4.xlarge',
    instance_count=1,
    record_template='{"start": $start_time, "target": $target_time_series, "dynamic_feat": $related_time_series, "cat": $static_covariates}',
    content_template='{"instances": $records}',,
    time_series_model_config=TimeSeriesModelConfig(
        forecast={'forecast': 'predictions[*].mean[:2]'}
    )
)

Del mismo modo, el atributo forecast de TimeSeriesModelConfig que se pasa a la configuración de análisis con la clave time_series_predictor_config, se utiliza para extraer la previsión del modelo de la respuesta del punto de conexión. Este podría ser un ejemplo de respuesta por lotes del punto de conexión:

{
    "predictions": [
        {"mean": [13.4, 3.6, 1.0]}, 
        {"mean": [23.0, 4.7, 3.0]}, 
        {"mean": [3.4, 5.6, 2.0]}
    ]
}

Si la expresión de JMESPath proporcionada por forecast es {'predictions[*].mean[:2]'}}, el valor de la previsión se analiza de la siguiente manera:

[[13.4, 3.6], [23.0, 4.7], [3.4, 5.6]]