Ejecute SageMaker Clarify Processing Jobs para analizar los sesgos y facilitar la explicación

Los siguientes ejemplos muestran cómo configurar el análisis de sesgos y el análisis de 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 s3_data_input_path parámetro puede ser un archivo URI de conjunto de datos o un URI prefijo de Amazon S3. Si proporciona un URI prefijo S3, el trabajo de procesamiento de SageMaker Clarify recopila de forma recursiva todos los archivos de Amazon S3 ubicados debajo del prefijo. El valor de s3_output_path debe ser un URI prefijo S3 para contener los resultados del análisis. SageMaker usa el valor s3_output_path al compilar y no puede tomar el valor de un parámetro, propiedad o ExecutionVariable expresión de SageMaker Pipeline 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 usar una sentencia de ejecución para lanzar 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 se methods="all" reemplaza por, methods=["CI", "DPL"] se indica al procesador 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 CSV formato. 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 ModelConfig objeto indica al trabajo que despliegue el SageMaker modelo en un punto final 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 SageMaker de Clarify que busque la etiqueta prevista 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 de un CSV conjunto de datos

El siguiente ejemplo de configuración muestra cómo ejecutar todas las métricas de sesgo previas y posteriores al entrenamiento en un solo 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 Equidad y explicabilidad con Clarify. SageMaker

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

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

probability_config = clarify.ModelPredictedLabelConfig(
    probability=1,
)

El objeto proporciona SHAPConfig SHAP parámetros de análisis. En este ejemplo, el SHAP baselinese omite el parámetro y su valor es1. num_clusters Esto indica al procesador SageMaker Clarify que calcule uno SHAP muestra de referencia basada en la agrupación del conjunto de datos de entrada. Si desea elegir el conjunto de datos de referencia, consulte SHAP Líneas de base para la explicabilidad.

shap_config = clarify.SHAPConfig(
    num_clusters=1,
)

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

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

Por ejemplo, un cuaderno con instrucciones sobre cómo ejecutar un trabajo de SageMaker procesamiento de Clarify en SageMaker Studio Classic para calcular SHAP valores, consulte Equidad y explicabilidad con SageMaker Clarify.

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

PDPs muestran la dependencia de la respuesta objetivo prevista 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 una curva en elPDP, indica que la relación entre el objetivo y las entidades de entrada es positiva, y la inclinación indica la fuerza 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 PDPConfig objeto para indicar al trabajo de procesamiento de SageMaker Clarify que calcule la importancia de la función. 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 SageMaker procesamiento de Clarify generará PDPs para Income dividirlo 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 inicia un trabajo de procesamiento SageMaker de 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 SageMaker procesamiento de Clarify en SageMaker Studio Classic para realizar cálculos PDPs, consulte Explicabilidad con SageMaker Clarify: gráficos de dependencia parcial () PDP.

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

Puede calcular ambos SHAP valores y PDPs en un solo trabajo de SageMaker procesamiento de 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 PDPs para las 2 funciones que tienen el mayor tamaño mundial SHAP valores.

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

El siguiente ejemplo de código inicia un trabajo de SageMaker procesamiento de Clarify para calcular ambos SHAP valores 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 > SageMaker JSON Líneas densas. Para obtener más información, consulte JSONLINESformato de solicitud. En estos ejemplos, el conjunto de datos entrante tiene los mismos datos que en la sección anterior, pero están en formato de JSON líneas. Cada línea es un JSON objeto 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 JMESPathexpresión para Features que el trabajo SageMaker de procesamiento Clarify pueda extraer la matriz de características de cada registro. El label parámetro está configurado en forma de JMESPath expresión para Label que el trabajo de SageMaker procesamiento de Clarify pueda extraer la etiqueta Ground Truth de cada registro. El s3_data_input_path parámetro puede ser un archivo URI de conjunto de datos o un URI prefijo de Amazon S3. Si proporciona un URI prefijo S3, el trabajo de procesamiento de SageMaker Clarify recopila de forma recursiva todos los archivos S3 ubicados debajo del prefijo. El valor de s3_output_path debe ser un URI prefijo S3 para contener los resultados del análisis. SageMaker usa el valor s3_output_path al compilar y no puede tomar el valor de un parámetro, propiedad o ExecutionVariable expresión de SageMaker Pipeline 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 de JSON Lines en el formato del ejemplo. Cada fila de la salida del modelo es un JSON objeto 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 ModelConfig objeto indica al trabajo de procesamiento de SageMaker Clarify que despliegue el SageMaker modelo en un punto final 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 SageMaker de procesamiento de Clarify utiliza el content_template parámetro para componer la entrada del modelo sustituyendo el $features marcador de posición por una matriz de características.

El siguiente ejemplo de configuración muestra cómo establecer el parámetro de etiqueta del ModelPredictedLabelConfig objeto en la JMESPath expresiónpredicted_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 probability parámetro del ModelPredictedLabelConfig objeto en la JMESPath expresiónprobability. 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 de JSON líneas, utilice las mismas instrucciones de ejecución y los mismos objetos de configuración que en la sección anterior para los CSV conjuntos de datos. Puede ejecutar un trabajo de procesamiento de SageMaker Clarify en SageMaker Studio Classic para detectar el sesgo y calcular la importancia de las características. Para obtener instrucciones y un ejemplo de cuaderno, consulte Equidad y explicabilidad con SageMaker Clarify (formato de JSON líneas).

SageMaker Clarify admite las explicaciones de los modelos de procesamiento del 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.

SageMaker NLPLa explicabilidad de 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 características textuales, categóricas o numéricas. NLPLa explicabilidad de los conjuntos de datos multimodales puede ayudarlo a comprender la importancia de cada característica para el resultado del modelo. SageMaker Clarify admite 62 idiomas y puede gestionar textos que incluyan varios idiomas.

En el siguiente ejemplo, se muestra un archivo de configuración de análisis para calcular la importancia de las funciones deNLP. En este ejemplo, el conjunto de datos entrante es un conjunto de datos tabular en CSV formato tabular, con una columna de etiquetas binarias y dos columnas de entidades.

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 el CSV formato y la ruta de los datos de salida utilizando el DataConfig objeto.

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 s3_data_input_path parámetro puede ser un archivo URI de conjunto de datos o un URI prefijo de Amazon S3. Si proporciona un URI prefijo S3, el trabajo de procesamiento de SageMaker Clarify recopila de forma recursiva todos los archivos S3 ubicados debajo del prefijo. El valor de s3_output_path debe ser un URI prefijo S3 para contener los resultados del análisis. SageMaker usa el valor s3_output_path al compilar y no puede tomar el valor de un parámetro, propiedad o ExecutionVariable expresión de SageMaker Pipeline 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 CSV datos y genera una puntuación única entre 0 y1.

0.491656005382537
0.569582343101501
...

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

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 SHAP La configuración 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 TextConfig objeto activa el análisis de explicabilidad. NLP El parámetro granularity indica que el análisis debe analizar los tokens. En inglés, cada token es una palabra. Para otros lenguajes, consulte la spaCydocumentación sobre la tokenización, que SageMaker Clarify utiliza para el procesamiento. NLP El ejemplo anterior también muestra cómo usar un promedio Rating de 4 para establecer un valor local SHAP instancia de referencia. 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 recorre en iteración cada token y lo reemplaza por la máscara, de la siguiente manera.

2,"[MASK] needs work"

4,"Flavor [MASK] work"

4,"Flavor needs [MASK]"

Luego, 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. Luego, SageMaker el explicador de Clarify usa esta información para calcular la contribución de cada token.

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

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 realizar un análisis de NLP explicabilidad, consulte Explicación del análisis de opiniones textuales mediante 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 JPEG imágenes.

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 DataConfig objeto contiene un s3_data_input_path conjunto de URI prefijos de Amazon S3. El trabajo de SageMaker procesamiento de Clarify recopila de forma recursiva todos los archivos de imagen ubicados bajo el prefijo. El s3_data_input_path parámetro puede ser un archivo URI de conjunto de datos o un URI prefijo de Amazon S3. Si proporciona un URI prefijo S3, el trabajo de procesamiento de SageMaker Clarify recopila de forma recursiva todos los archivos S3 ubicados debajo del prefijo. El valor de s3_output_path debe ser un URI prefijo S3 para contener los resultados del análisis. SageMaker usa el valor s3_output_path al compilar y no puede tomar el valor de un parámetro, propiedad o ExecutionVariable expresión de SageMaker Pipeline que se utilice durante el tiempo de ejecución.

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

El trabajo SageMaker de procesamiento Clarify explica las imágenes mediante el SHAP algoritmo Kernel, 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 SageMaker imágenes. Para obtener más información, consulte Clasificación de imágenes - 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, se entrenó a un modelo denominadoyour_cv_ic_model, para clasificar los animales en las imágenes de entradaJPEG. El ModelConfig objeto del ejemplo anterior indica al trabajo de procesamiento de SageMaker Clarify que despliegue el SageMaker modelo en un punto final efímero. Para una inferencia acelerada, el punto final utiliza una instancia de ml.p2.xlarge inferencia equipada con un. GPU

Después de enviar una JPEG imagen a un punto final, el punto final 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 SHAP la configuración 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 y es local SHAP los valores 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 inicia un trabajo SageMaker de procesamiento de Clarify para generar mapas térmicos para las 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 usa SageMaker Clarify para clasificar imágenes y explicar su clasificación, consulte Explicación de la clasificación de imágenes con SageMaker Clarify.

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

Un trabajo SageMaker de procesamiento de Clarify permite 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 SageMaker objetos your_cv_od_model se basa en JPEG imágenes para identificar a 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 ModelConfig objeto del ejemplo de configuración anterior indica al trabajo de procesamiento de SageMaker Clarify que despliegue el SageMaker modelo en un punto final efímero. Para obtener imágenes aceleradas, este punto final utiliza una instancia de ml.p2.xlarge inferencia equipada con un. 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 SHAP la configuración muestra cómo generar explicaciones para la detección de un objeto.

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 de análisis.

El siguiente ejemplo de código inicia un trabajo SageMaker de procesamiento de Clarify para generar mapas térmicos para las 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 bloc de notas que usa SageMaker Clarify para detectar objetos en una imagen y explicar sus predicciones, consulte Explicación de los modelos de detección de objetos con Amazon SageMaker Clarify.

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

[
    {
        "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

TimeSeriesDataConfigComunique 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

Se utiliza AsymmetricShapleyValueConfig para definir argumentos para el análisis explicativo del modelo de previsión de series temporales, como la línea base, la dirección, la granularidad 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 AsymmetricShapleyValueConfig configuración indica al procesador SageMaker Clarify cómo calcular las atribuciones de características para un elemento a la vez. La siguiente configuración muestra un ejemplo de definición deAsymmetricShapleyValueConfig.

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 AsymmetricShapleyValueConfig se pasan a la configuración de análisis como una entrada methods con claveasymmetric_shapley_value.

Configuración del modelo

Puede controlar la estructura de la carga útil enviada desde el procesador SageMaker Clarify. En el siguiente ejemplo de código, un objeto de ModelConfig configuración dirige una tarea de explicabilidad de previsión de series temporales a agregar registros mediante la JMESPath sintaxis'{"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 final.

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 inTimeSeriesModelConfig, que se pasa a la configuración de análisis con la clavetime_series_predictor_config, se utiliza para extraer la previsión del modelo a partir de la respuesta del punto final. Por ejemplo, un ejemplo de respuesta por lotes de puntos finales podría ser el siguiente:

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

Si la JMESPath expresión proporcionada 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]]