Execute trabalhos de processamento do SageMaker Clarify para análise de preconceito e explicabilidade

Os exemplos a seguir mostram como configurar a análise de desvio e a análise de explicabilidade para um conjunto de dados tabular no formato CSV. Nesses exemplos, o conjunto de dados de entrada tem quatro colunas de atributos e uma coluna de rótulo binário, Target. O conteúdo do conjunto de dados é o seguinte: O valor do rótulo 1 indica um 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
...

Esse objeto DataConfig especifica o conjunto de dados de entrada e onde armazenar a saída. O parâmetro s3_data_input_path pode ser um URI de um arquivo de conjunto de dados ou um prefixo de URI do Amazon S3. Se você fornecer um prefixo de URI do S3, o job de processamento do SageMaker Clarify coleta recursivamente todos os arquivos do Amazon S3 localizados sob o prefixo. O valor do s3_output_path deve ser um prefixo de URI do S3 para manter os resultados da análise. O SageMaker usa o s3_output_path durante a compilação e não pode usar o valor de um parâmetro, propriedade, expressão ou ExecutionVariable do SageMaker Pipeline que é usado durante o runtime. O exemplo de código a seguir mostra como especificar uma configuração de dados para a amostra de conjunto de dados de entrada 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,
)

Como calcular todas as métricas de desvio pré-treinamento para um conjunto de dados CSV

O exemplo de código a seguir mostra como configurar um BiasConfig objeto para medir o desvio da entrada da amostra anterior em relação a amostras com um valor 0 de Gender.

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

O exemplo de código a seguir mostra como usar uma instrução de execução para iniciar um trabalho de processamento do SageMaker Clarify que calcula todas as métricas de desvio pré-treinamento para um conjunto de dados de entrada.

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

Como alternativa, você pode escolher quais métricas calcular atribuindo uma lista de métricas de desvio pré-treinamento ao parâmetro métodos. Por exemplo, a substituição de methods="all" por methods=["CI", "DPL"] instrui o processador do SageMaker Clarify a calcular somente o desequilíbrio de classes e a diferença nas proporções dos rótulos.

Como calcular todas as métricas de desvio pós-treinamento para um conjunto de dados CSV

Você pode calcular as métricas de desvio pré-treinamento antes do treinamento. No entanto, para calcular as métricas de desvio pós-treinamento, você deve ter um modelo treinado. O exemplo de saída a seguir é de um modelo de classificação binária que gera dados no formato CSV. Neste exemplo de saída, cada linha contém duas colunas. A primeira coluna contém o rótulo previsto e a segunda coluna contém o valor de probabilidade desse rótulo.

0,0.028986845165491
1,0.825382471084594
...

No exemplo de configuração a seguir, o objeto ModelConfig instrui o trabalho a implantar o modelo do SageMaker em um endpoint efêmero. O endpoint usa uma instância de inferência ml.m4.xlarge. Como os parâmetros content_type e não accept_type estão definidos, eles usam automaticamente o valor do parâmetro dataset_type, que é text/csv.

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

O exemplo de configuração a seguir usa um objeto ModelPredictedLabelConfig com um índice de rótulo de 0. Isso instrui o trabalho de processamento do SageMaker Clarify a localizar o rótulo previsto na primeira coluna da saída do modelo. O trabalho de processamento usa indexação com base em zero neste exemplo.

predicted_label_config = clarify.ModelPredictedLabelConfig(
    label=0,
)

Combinado com o exemplo de configuração anterior, o exemplo de código a seguir inicia um trabalho de processamento do SageMaker Clarify para calcular todas as métricas de desvio pós-treinamento.

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",
)

Da mesma forma, você pode escolher quais métricas calcular atribuindo uma lista de métricas de desvio pós-treinamento ao parâmetro methods. Como exemplo, substituir methods=“all” por methods=["DPPL", "DI"] para calcular somente a diferença nas proporções positivas em rótulos previstos e o impacto díspar.

Como calcular todas as métricas de desvio para um conjunto de dados CSV

O exemplo de configuração a seguir mostra como executar todas as métricas de desvio pré-treinamento e pós-treinamento em um trabalho de processamento do 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 obter um caderno de exemplo com instruções sobre como executar um trabalho de processamento do SageMaker Clarify no SageMaker Studio Classic para detectar vieses, consulte Imparcialidade e explicabilidade com o SageMaker Clarify.

Como calcular valores SHAP para um conjunto de dados CSV

O SageMaker Clarify fornece atribuições de atributos usando o algoritmo KernelSHAP. A análise do SHAP exige o valor ou pontuação de probabilidade em vez do rótulo previsto, portanto, esse objeto ModelPredictedLabelConfig tem índice de probabilidade 1. Isso instrui o trabalho de processamento do SageMaker Clarify a extrair a pontuação de probabilidade da segunda coluna da saída do modelo (usando indexação baseada em zero).

probability_config = clarify.ModelPredictedLabelConfig(
    probability=1,
)

O objeto SHAPConfig fornece parâmetros de análise SHAP. Neste exemplo, o parâmetro de baseline do SHAP é omitido e o valor do parâmetro num_clusters é 1. Isso instrui o processador do SageMaker Clarify a calcular uma amostra de linha de base SHAP com base no agrupamento do conjunto de dados de entrada. Se você quiser escolher o conjunto de dados de linha de base, consulte Linhas de base do SHAP para explicabilidade.

shap_config = clarify.SHAPConfig(
    num_clusters=1,
)

O exemplo de código a seguir inicia um trabalho de processamento do SageMaker Clarify para computar valores SHAP.

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

Para obter um caderno de exemplo com instruções sobre como executar um trabalho de processamento do SageMaker Clarify no SageMaker Studio Classic para calcular valores SHAP, consulte Imparcialidade e explicabilidade com o SageMaker Clarify.

Como calcular gráficos de dependência parcial (PDPs) para um conjunto de dados CSV

O PDPs mostra a dependência da resposta alvo prevista em uma ou mais atributos de entrada de interesse, mantendo todos os outros atributos constantes. Uma linha ascendente, ou curva no PDP, indica que a relação entre o alvo e os atributos de entrada é positiva, e a inclinação indica a força da relação. Uma linha ou curva descendente indica que, se um atributo de entrada diminuir, a variável alvo aumentará. Intuitivamente, você pode interpretar a dependência parcial como a resposta da variável alvo a cada atributo de entrada de interesse.

O exemplo de configuração a seguir refere-se ao uso de um objeto PDPConfig para instruir o trabalho de processamento do SageMaker Clarify a calcular a importância do atributo Income.

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

No exemplo anterior, o parâmetro grid_resolution dividia o intervalo dos valores do atributo Income em buckets 10. O trabalho de processamento do SageMaker Clarify gerará PDPs para Income dividida em 10 segmentos no eixo x. O eixo y mostrará o impacto marginal de Income na variável alvo.

O exemplo de código a seguir inicia um trabalho de processamento do 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 obter um caderno de exemplo com instruções sobre como executar um trabalho de processamento do SageMaker Clarify no SageMaker Studio Classic para calcular PDPs, consulte Explicabilidade com o SageMaker Clarify: gráficos de dependência parcial (PDP).

Como calcular os valores SHAP e PDPs para um conjunto de dados CSV

Você pode computar os valores SHAP e PDPs em um único trabalho de processamento do SageMaker Clarify. No exemplo de configuração a seguir, o parâmetro top_k_features de um novo objeto PDPConfig é definido como 2. Isso instrui o trabalho de processamento do SageMaker Clarify a calcular PDPs para os atributos 2 que têm os maiores valores SHAP globais.

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

O exemplo de código a seguir inicia um trabalho de processamento do SageMaker Clarify para calcular valores SHAP e PDPs.

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

Os exemplos a seguir mostram como configurar a análise de desvio e a análise de explicabilidade para um conjunto de dados tabular no formato denso >SageMaker linhas JSON. Consulte Formato da solicitação JSONLINES para obter mais informações. Nesses exemplos, o conjunto de dados de entrada tem os mesmos dados da seção anterior, mas eles estão no formato JSON Lines. Cada linha é um objeto JSON válido. A chave Features se refere a uma matriz de valores de atributos, e a chave Label se refere ao rótulo de veracidade.

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

No exemplo de configuração a seguir, o objeto DataConfig especifica o conjunto de dados de entrada e onde armazenar a saída.

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,
)

No exemplo de configuração anterior, o parâmetro dos atributos foi definido para a expressão Features do JMESPath, para que o trabalho de processamento do SageMaker Clarify possa extrair a matriz de atributos de cada registro. O parâmetro label é definido como a expressão JMESPath Label para que o trabalho de processamento do SageMaker Clarify possa extrair o rótulo de veracidade de cada registro. O parâmetro s3_data_input_path pode ser um URI de um arquivo de conjunto de dados ou um prefixo de URI do Amazon S3. Se você fornecer um prefixo de URI do S3, o trabalho de processamento do SageMaker Clarify coletará recursivamente todos os arquivos do S3 localizados abaixo do prefixo. O valor do s3_output_path deve ser um prefixo de URI do S3 para manter os resultados da análise. O SageMaker usa o s3_output_path durante a compilação e não pode usar o valor de um parâmetro, propriedade, expressão ou ExecutionVariable do SageMaker Pipeline que é usado durante o runtime.

Você deve ter um modelo treinado para calcular as métricas de desvio pós-treinamento ou a importância do atributo. O exemplo a seguir é de um modelo de classificação binária que gera dados de linhas JSON no formato do exemplo. Cada linha da saída do modelo é um objeto JSON válido. A chave predicted_label refere-se ao rótulo previsto e a chave probability refere-se ao valor da probabilidade.

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

No exemplo de configuração a seguir, o objeto ModelConfig instrui o trabalho de processamento do SageMaker Clarify a implantar o modelo do SageMaker em um endpoint efêmero. O endpoint usa uma instância de inferência ml.m4.xlarge.

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

No exemplo de configuração anterior, os parâmetros content_type e accept_type não estão definidos. Portanto, eles usam automaticamente o valor do parâmetro dataset_type do objeto DataConfig, que é application/jsonlines. O trabalho de processamento do SageMaker Clarify usa o parâmetro content_template para compor a entrada do modelo, substituindo o espaço reservado $features por uma matriz de atributos.

O exemplo de configuração a seguir mostra como definir o parâmetro de rótulo do objeto ModelPredictedLabelConfig para a expressão JMESPath predicted_label. Isso extrairá o rótulo previsto da saída do modelo.

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

O exemplo de configuração a seguir mostra como definir o parâmetro probability do objeto ModelPredictedLabelConfig para a expressão JMESPath probability. Isso extrairá a pontuação da saída do modelo.

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

Para calcular as métricas de desvio e a importância dos atributos para conjuntos de dados no formato linhas JSON, use as mesmas instruções de execução e objetos de configuração da seção anterior para conjuntos de dados CSV. Você pode executar um trabalho de processamento do SageMaker Clarify no SageMaker Studio Classic para detectar vieses e calcular a importância dos atributos. Para obter instruções e um exemplo de caderno, consulte Equidade e explicabilidade com o SageMaker Clarify (formato linhas JSON).

O SageMaker Clarify é compatível com explicações para modelos de processamento de linguagem natural (PLN). Essas explicações ajudam você a entender quais seções do texto são as mais importantes para as predições do seu modelo. Você pode explicar a predição de modelo para uma única instância do conjunto de dados de entrada ou as predições de modelo a partir do conjunto de dados da linha de base. Para entender e visualizar o comportamento de um modelo, você pode especificar vários níveis de granularidade. Para fazer isso, defina o tamanho do segmento de texto, como seus tokens, frases e parágrafos.

A explicabilidade do PLN do SageMaker Clarify é compatível com os modelos de classificação e regressão. Você também pode usar o SageMaker Clarify para explicar o comportamento do seu modelo em conjuntos de dados multimodais que contêm atributos de texto, categóricos ou numéricos. A explicabilidade da PNL para conjuntos de dados multimodais pode ajudá-lo a entender a importância de cada atributo para a saída do modelo. O SageMaker Clarify é compatível com 62 idiomas e pode lidar com textos que incluem vários idiomas.

O exemplo a seguir mostra um arquivo de configuração de análise para o cálculo da importância do atributo para a PNL. Neste exemplo, o conjunto de dados de entrada é um conjunto de dados tabular no formato CSV, com uma coluna de rótulo binária e duas colunas de atributos.

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

O exemplo de configuração a seguir mostra como especificar um conjunto de dados de entrada no formato CSV e o caminho dos dados de saída usando o 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,
)

No exemplo de configuração anterior, o parâmetro s3_data_input_path pode ser um URI de um arquivo de conjunto de dados ou um prefixo de URI do Amazon S3. Se você fornecer um prefixo de URI do S3, o trabalho de processamento do SageMaker Clarify coletará recursivamente todos os arquivos do S3 localizados abaixo do prefixo. O valor do s3_output_path deve ser um prefixo de URI do S3 para manter os resultados da análise. O SageMaker usa o s3_output_path durante a compilação e não pode usar o valor de um parâmetro, propriedade, expressão ou ExecutionVariable do SageMaker Pipeline que é usado durante o runtime.

O exemplo de saída a seguir foi criado a partir de um modelo de classificação binária treinado no conjunto de dados de entrada anterior. O modelo de classificação aceita dados CSV e gera uma única pontuação entre 0 e 1.

0.491656005382537
0.569582343101501
...

O exemplo a seguir mostra como configurar o objeto ModelConfig para implantar um modelo do SageMaker. Neste exemplo, um endpoint efêmero implanta o modelo. Esse endpoint usa uma instância de inferência ml.g4dn.xlarge equipada com uma GPU, para inferência acelerada.

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

O exemplo a seguir mostra como configurar o objeto ModelPredictedLabelConfig para localizar a probabilidade (pontuação) na primeira coluna com um índice de 0.

probability_config = clarify.ModelPredictedLabelConfig(
    probability=0,
)

O exemplo de configuração SHAP a seguir mostra como executar uma análise de explicabilidade por token usando um modelo e um conjunto de dados de entrada no idioma 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,
)

No exemplo anterior, o objeto TextConfig ativava a análise de explicabilidade da PNL. O parâmetro granularity indica que a análise deve analisar os tokens. Em inglês, cada token é uma palavra. Para outros idiomas, consulte a documentação do spaCy para tokenização, que o SageMaker Clarify usa para o processamento de PNL. O exemplo anterior também mostra como usar uma média Rating de 4 para definir uma instância de linha de base SHAP no local. Um token de máscara especial [MASK] é usado para substituir um token (palavra) em Comments.

No exemplo anterior, se a instância for 2,"Flavor needs work", defina a linha de base como uma média Rating de 4 com a linha de base a seguir.

4, '[MASK]'

No exemplo anterior, o explicador do SageMaker Clarify percorre cada token e o substitui pela máscara, da seguinte maneira:

2,"[MASK] needs work"

4,"Flavor [MASK] work"

4,"Flavor needs [MASK]"

Em seguida, o explicador do SageMaker Clarify enviará cada linha ao seu modelo para fazer predições. Isso é para que o explicador aprenda as predições com e sem as palavras mascaradas. Em seguida, o explicador do SageMaker Clarify usa essas informações para calcular a contribuição de cada token.

O exemplo de código a seguir inicia um trabalho de processamento do SageMaker Clarify para computar 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 obter um caderno de exemplo com instruções sobre como executar um trabalho de processamento do SageMaker Clarify no SageMaker Studio Classic para análises de explicabilidade do PLN, consulte Como explicar a análise de sentimento do texto usando o SageMaker Clarify.

O SageMaker Clarify gera mapas de calor que fornecem insights sobre como seus modelos de visão computacional classificam e detectam objetos em suas imagens.

No exemplo de configuração a seguir, o conjunto de dados de entrada consiste em imagens 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,
)

No exemplo de configuração anterior, o objeto DataConfig contém um conjunto s3_data_input_path para um prefixo de URI do Amazon S3. O trabalho de processamento do SageMaker Clarify coleta recursivamente todos os arquivos de imagem localizados sob o prefixo. O parâmetro s3_data_input_path pode ser um URI de um arquivo de conjunto de dados ou um prefixo de URI do Amazon S3. Se você fornecer um prefixo de URI do S3, o trabalho de processamento do SageMaker Clarify coletará recursivamente todos os arquivos do S3 localizados abaixo do prefixo. O valor do s3_output_path deve ser um prefixo de URI do S3 para manter os resultados da análise. O SageMaker usa o s3_output_path durante a compilação e não pode usar o valor de um parâmetro, propriedade, expressão ou ExecutionVariable do SageMaker Pipeline que é usado durante o runtime.

Como explicar um modelo de classificação de imagens

O trabalho de processamento do SageMaker Clarify explica as imagens usando o algoritmo KernelSHAP, que trata a imagem como uma coleção de superpixels. Dado um conjunto de dados que consiste em imagens, o trabalho de processamento gera um conjunto de dados de imagens em que cada imagem mostra o mapa de calor dos superpixels relevantes.

O exemplo de configuração a seguir mostra como configurar uma análise de explicabilidade usando um modelo de classificação de imagens do SageMaker. Consulte Classificação de imagens - MXNet para obter mais informações.

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",
)

No exemplo de configuração anterior, um modelo chamado your_cv_ic_model foi treinado para classificar os animais nas imagens JPEG de entrada. O objeto ModelConfig no exemplo anterior instrui o trabalho de processamento do SageMaker Clarify a implantar o modelo do SageMaker em um endpoint efêmero. Para inferência acelerada, o endpoint usa uma instância de inferência ml.p2.xlarge equipada com uma GPU.

Depois que uma imagem JPEG é enviada para um endpoint, o endpoint a classifica e retorna uma lista de pontuações. Cada pontuação refere-se a uma categoria. O objetoModelPredictedLabelConfig fornece o nome de cada categoria da seguinte forma:

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

Um exemplo de saída para a entrada anterior de ['bird','cat','dog'] poderia ser 0,3, 0,6, 0,1, onde 0,3 representa a pontuação de confiança para classificar uma imagem como um pássaro.

O exemplo de configuração SHAP a seguir mostra como gerar explicações para um problema de classificação de imagens. Ele usa um objeto ImageConfig para ativar a análise.

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,
)

O SageMaker Clarify extrai atributos usando o método Agrupamento iterativo linear simples (SLIC) da biblioteca scikit-learn para segmentação de imagens. O exemplo de configuração anterior, o parâmetro model_type, indica o tipo de problema de classificação da imagem. O parâmetro num_segments estima quantos segmentos aproximados serão rotulados na imagem de entrada. Então, o número de segmentos é passado para o parâmetro slic n_segments.

Cada segmento da imagem é considerado um superpixel e os valores SHAP locais são calculados para cada segmento. O parâmetro segment_compactness determina a forma e o tamanho dos segmentos da imagem que são gerados pelo método scikit-image slic. Os tamanhos e formas dos segmentos da imagem são então passados para o parâmetro slic compactness.

O exemplo de código a seguir inicia um trabalho de processamento do SageMaker Clarify para gerar mapas de calor para usas imagens. Valores positivos do mapa de calor mostram que o atributo aumentou a pontuação de confiança na detecção do objeto. Valores negativos indicam que o atributo diminuiu a pontuação de confiança.

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 um caderno de exemplo que usa o SageMaker Clarify para classificar imagens e explicar sua classificação, consulte Explicando a classificação de imagens com o SageMaker Clarify.

Como explicar um modelo de detecção de objetos

Um trabalho de processamento do SageMaker Clarify pode detectar e classificar objetos em uma imagem e, em seguida, fornecer uma explicação para o objeto detectado. O processo de explicação ocorre da seguinte forma:

No exemplo de configuração a seguir, um modelo de detecção de objetos do SageMaker your_cv_od_model é treinado em imagens JPEG para identificar os animais nelas.

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",
)

O objeto ModelConfig no exemplo de configuração anterior instrui o trabalho de processamento do SageMaker Clarify a implantar o modelo do SageMaker em um endpoint efêmero. Para a criação de imagem acelerada, este endpoint usa uma instância de inferência ml.p2.xlarge equipada com uma GPU.

No exemplo de configuração a seguir, o objeto ModelPredictedLabelConfig fornece o nome de cada categoria para classificação.

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

O exemplo de configuração SHAP a seguir mostra como gerar explicações para uma detecção 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,
)

No exemplo de configuração anterior, o objeto ImageConfig ativava a análise. O parâmetro model_type indica que o tipo de problema é a detecção de objetos. Para uma descrição detalhada dos outros parâmetros, consulte Arquivos de configuração de análise.

O exemplo de código a seguir inicia um trabalho de processamento do SageMaker Clarify para gerar mapas de calor para usas imagens. Valores positivos do mapa de calor mostram que o atributo aumentou a pontuação de confiança na detecção do objeto. Valores negativos indicam que o atributo diminuiu a pontuação de confiança.

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 um caderno de exemplo que usa o SageMaker Clarify para detectar objetos em uma imagem e explicar suas predições, consulte Explicação dos modelos de detecção de objetos com o Amazon SageMaker Clarify.

Os exemplos a seguir mostram como configurar dados no formato denso JSON do SageMaker para explicar um modelo de previsão de séries temporais. Para obter mais informações sobre a formatação de JSON, consulte Formato da solicitação 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
    },
]

Configuração de dados

Use TimeSeriesDataConfig para que seu trabalho de explicabilidade interprete os dados corretamente a partir do conjunto de dados de entrada passado, conforme mostrado no exemplo de configuração a seguir:

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',
)

Configuração de valor assimétrico de Shapley

Use AsymmetricShapleyValueConfig para definir argumentos para a análise da explicação do modelo de previsão de séries temporais, como linha de base, direção, granularidade e número de amostras. Os valores da linha de base são definidos para todos os três tipos de dados: séries temporais relacionadas, covariáveis estáticas e séries temporais de destino. A configuração AsymmetricShapleyValueConfig informa ao processador do SageMaker Clarify como calcular as atribuições de atributos para um item por vez. A configuração a seguir mostra um exemplo de definição 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"
    },
)

Os valores que você fornece ao AsymmetricShapleyValueConfig são passados para a configuração de análise como uma entrada em methods com a chave asymmetric_shapley_value.

Configuração do modelo

Você pode controlar a estrutura da carga útil enviada pelo processador do SageMaker Clarify. No exemplo de código a seguir, um objeto de configuração ModelConfig direciona um trabalho de explicabilidade de previsão de séries temporais para agregar registros usando a sintaxe do JMESPath em '{"instances": $records}', onde a estrutura de cada registro é definida com o record_template '{"start": $start_time, "target": $target_time_series, "dynamic_feat": $related_time_series, "cat": $static_covariates}'. Observe que $start_time, $target_time_series, $related_time_series e $static_covariates são tokens internos usados para mapear valores de conjuntos de dados para valores de solicitação de endpoint.

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]'}
    )
)

Da mesma forma, o atributo forecast em TimeSeriesModelConfig, passado para a configuração de análise com a chave time_series_predictor_config, é usado para extrair a predição de modelo da resposta do endpoint. Por exemplo, um exemplo de resposta em lote de endpoint pode ser:

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

Se a expressão JMESPath fornecida para forecast for {'predictions[*].mean[:2]'}}, o valor da predição será interpretado da seguinte forma:

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