As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Monitoramento da qualidade de dados e modelos com o Amazon SageMaker Model Monitor O Amazon SageMaker Model Monitor monitora a qualidade dos modelos de aprendizado de máquina de SageMaker IA da Amazon em produção. Com o Model Monitor, você pode configurar: + Monitoramento contínuo com um endpoint em tempo real. + Monitoramento contínuo com um trabalho de transformação em lote que é executado regularmente. + Monitoramento dentro do cronograma para trabalhos assíncronos de transformação em lote. Com o Model Monitor, você pode definir alertas que o notificam quando há desvios na qualidade do modelo. A detecção antecipada e pró-ativa desses desvios permite que você tome medidas corretivas. Você pode tomar ações, como treinar modelos novamente, auditar sistemas de upstream ou corrigir problemas de qualidade sem precisar monitorar modelos manualmente ou criar ferramentas adicionais. É possível usar recursos de monitoramento pré-criados do Model Monitor que não exigem codificação. Você também tem a flexibilidade de monitorar modelos por meio de codificação para fornecer análise personalizada. O Model Monitor fornece os seguintes tipos de monitoramento: + [Qualidade dos dados](model-monitor-data-quality.md) - monitora a variação na qualidade dos dados. + [Qualidade do modelo](model-monitor-model-quality.md) - Monitora a variação nas métricas de qualidade do modelo, como precisão. + [Desvio de polarização para modelos em produção](clarify-model-monitor-bias-drift.md) - Monitora o desvio nas predições do seu modelo. + [Desvio de atribuição de atributos para modelos em produção](clarify-model-monitor-feature-attribution-drift.md) - Monitora a variação na atribuição de atributos. **Topics** + [Monitorar um modelo em produção](how-it-works-model-monitor.md) + [Como funciona o Amazon SageMaker Model Monitor](#model-monitor-how-it-works) + [Captura de dados](model-monitor-data-capture.md) + [Qualidade dos dados](model-monitor-data-quality.md) + [Qualidade do modelo](model-monitor-model-quality.md) + [Desvio de polarização para modelos em produção](clarify-model-monitor-bias-drift.md) + [Desvio de atribuição de atributos para modelos em produção](clarify-model-monitor-feature-attribution-drift.md) + [Programar trabalhos de monitoramento](model-monitor-scheduling.md) + [Contêiner pré-construído Amazon SageMaker Model Monitor](model-monitor-pre-built-container.md) + [Interpretar resultados](model-monitor-interpreting-results.md) + [Visualize resultados para endpoints em tempo real no Amazon Studio SageMaker](model-monitor-interpreting-visualize-results.md) + [Tópicos avançados](model-monitor-advanced-topics.md) + [Monitor de modelo FAQs](model-monitor-faqs.md) # Monitorar um modelo em produção Depois de implantar um modelo em seu ambiente de produção, use o Amazon SageMaker Model Monitor para monitorar continuamente a qualidade dos seus modelos de aprendizado de máquina em tempo real. O Amazon SageMaker Model Monitor permite que você configure um sistema automático de acionamento de alertas quando há desvios na qualidade do modelo, como desvios de dados e anomalias. O Amazon CloudWatch Logs coleta arquivos de log de monitoramento do status do modelo e notifica quando a qualidade do seu modelo atinge determinados limites predefinidos por você. CloudWatch armazena os arquivos de log em um bucket do Amazon S3 que você especificar. A detecção precoce e proativa de desvios do AWS modelo por meio de produtos de monitoramento de modelo permite que você tome medidas imediatas para manter e melhorar a qualidade do modelo implantado. Para obter mais informações sobre os produtos de monitoramento de SageMaker modelos, consulte[Monitoramento da qualidade de dados e modelos com o Amazon SageMaker Model Monitor](model-monitor.md). Para começar sua jornada de aprendizado de máquina com SageMaker IA, cadastre-se em uma AWS conta na [Set Up SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html). ## Como funciona o Amazon SageMaker Model Monitor O Amazon SageMaker Model Monitor monitora automaticamente os modelos de aprendizado de máquina (ML) em produção e notifica você quando ocorrem problemas de qualidade. O Model Monitor usa regras para detectar oscilações em seus modelos e alerta você quando isso acontece. A figura a seguir mostra como esse processo funciona no caso de seu modelo ser implantado em um endpoint em tempo real. ![\[O processo de monitoramento de modelos com o Amazon SageMaker Model Monitor.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model_monitor/mmv2-architecture.png) Você também pode usar o Model Monitor para monitorar um trabalho de transformação de lotes em vez de um endpoint em tempo real. Nesse caso, em vez de receber solicitações em um endpoint e acompanhar as predições, o Model Monitor monitorará as entradas e saídas de inferência. A figura a seguir mostra o processo de monitoramento de um trabalho de transformação de lotes. ![\[O processo de monitoramento de modelos com o Amazon SageMaker Model Monitor.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model_monitor/mmv2-architecture-batch.png) Para ativar o monitoramento de modelo, execute as seguintes etapas: Estas etapas seguem o caminho dos dados por meio dos vários processos de coleta, monitoramento e análise de dados. + Para um endpoint em tempo real, ative o endpoint para capturar dados de solicitações de entrada para um modelo de ML treinado e as predições de modelo resultantes. + Para um trabalho de transformação de lotes, habilite a captura de dados das entradas e saídas da transformação de lotes. + Crie uma linha de base com o conjunto de dados que foi usado para treinar o modelo. A linha de base calcula as métricas e sugere restrições para elas. As predições em tempo real ou em lotes do seu modelo são comparadas às restrições. Elas são relatadas como violações se estiverem fora dos valores condicionados. + Crie uma programação de monitoramento especificando quais dados devem ser coletados, com que frequência devem ser coletados, como analisá-los e quais relatórios devem ser produzidos. + Inspecione os relatórios, que comparam os dados mais recentes com a linha de base. Fique atento a quaisquer violações relatadas, métricas e notificações da Amazon CloudWatch. **Observações** O Model Monitor calcula métricas e estatísticas do modelo somente em dados tabulares. Por exemplo, um modelo de classificação de imagens que usa imagens como entrada e gera um rótulo baseado nessa imagem ainda pode ser monitorado. O Model Monitor seria capaz de calcular métricas e estatísticas para a saída, não para a entrada. Atualmente, o Model Monitor é compatível apenas com endpoints que hospedam um modelo único e não é compatível com o monitoramento de endpoints multimodelo. Para obter informações sobre como usar endpoints multimodelo, consulte [Endpoints multimodelo](multi-model-endpoints.md). O Model Monitor oferece apoio ao monitoramento de pipelines de inferência. No entanto, a captura e análise de dados são feitas para todo o pipeline, não para contêineres individuais no pipeline. Para evitar o impacto nas solicitações de inferência, a Captura de dados interrompe a captura de solicitações em altos níveis de uso do disco. É recomendável que você mantenha a utilização do disco abaixo de 75% para garantir que a captura de dados continue atendendo às solicitações. Se você iniciar o SageMaker Studio em uma Amazon VPC personalizada, deverá criar endpoints de VPC para permitir que o Model Monitor se comunique com o Amazon S3 e. CloudWatch Para obter informações sobre endpoints de VPC, consulte [Endpoints de VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/concepts.html) no *Guia do usuário do Amazon Virtual Private Cloud*. Para obter informações sobre como iniciar o SageMaker Studio em uma VPC personalizada, consulte. [Conectar os cadernos do Studio em uma VPC para recursos externos](studio-notebooks-and-internet-access.md) ### Exemplos de cadernos do Model Monitor Para um exemplo de notebook que mostra o end-to-end fluxo de trabalho usando o Model Monitor com seu endpoint em tempo real, consulte [Introdução ao Amazon SageMaker Model Monitor](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_model_monitor/introduction/SageMaker-ModelMonitoring.html). Para obter um caderno de exemplo que visualiza o arquivo statistics.json para uma execução selecionada em uma programação de monitoramento, consulte [Visualização do Model Monitor](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_model_monitor/visualization/SageMaker-Model-Monitor-Visualize.html). Para obter instruções sobre como criar e acessar instâncias do notebook Jupyter que você pode usar para executar o exemplo em SageMaker IA, consulte. [Instâncias de SageMaker notebook da Amazon](nbi.md) Depois de criar uma instância do notebook e abri-la, escolha a guia **Exemplos de SageMaker IA** para ver uma lista de todas as amostras de SageMaker IA. Para abrir um caderno, escolha a aba **Uso** do caderno e, em seguida, escolha **Criar cópia**. # Captura de dados Para registrar as entradas no seu endpoint e as saídas de inferência do seu modelo implantado no Amazon S3, você pode habilitar um atributo chamado *Captura de dados*. A *Captura de dados* é comumente usada para registrar informações que podem ser usadas para treinamento, depuração e monitoramento. O Amazon SageMaker Model Monitor analisa automaticamente esses dados capturados e compara as métricas desses dados com uma linha de base que você cria para o modelo. Para obter mais informações sobre o Model Monitor, consulte [Monitoramento da qualidade de dados e modelos com o Amazon SageMaker Model Monitor](model-monitor.md). Você pode implementar o *Data Capture* nos modos de monitoramento de modelos em tempo real e em lote usando o SDK do Python AWS SDK para Python (Boto) ou do Python SageMaker . Para um endpoint em tempo real, você especificará sua configuração de *Captura de dados* ao criar seu endpoint. Devido à natureza persistente do seu endpoint em tempo real, você pode configurar opções adicionais para ativar ou desativar a captura de dados em determinados momentos ou alterar a frequência de amostragem. Você também pode optar por criptografar seus dados de inferência. Para uma tarefa de transformação de lotes, você pode ativar a *Captura de dados* se quiser executar o monitoramento do modelo dentro da programação ou o monitoramento contínuo do modelo para trabalhos de transformação de lotes regulares e periódicos. Você especificará sua configuração de *Captura de dados* ao criar seu trabalho de transformação de lotes. Nessa configuração, você tem a opção de ativar a criptografia ou gerar o ID de inferência com sua saída, o que ajuda a combinar os dados capturados com os dados do Ground Truth. # Capturar dados do endpoint em tempo real **nota** Para evitar o impacto nas solicitações de inferência, a Captura de dados interrompe a captura de solicitações em altos níveis de uso do disco. É recomendável que você mantenha a utilização do disco abaixo de 75% para garantir que a captura de dados continue capturando as solicitações. Para capturar dados para seu endpoint em tempo real, você deve implantar um modelo usando serviços de hospedagem de SageMaker IA. Isso exige que você crie um modelo de SageMaker IA, defina uma configuração de endpoint e crie um endpoint HTTPS. As etapas necessárias para ativar a captura de dados são semelhantes, independentemente de você usar o SDK do Python AWS SDK para Python (Boto) ou do SageMaker Python. Se você usa o AWS SDK, defina o [DataCaptureConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataCaptureConfig.html)dicionário, junto com os campos obrigatórios, dentro do [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)método para ativar a captura de dados. Se você usa o SDK do SageMaker Python, importe a [DataCaptureConfig](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html#sagemaker.model_monitor.data_capture_config.DataCaptureConfig)classe e inicialize uma instância dessa classe. Em seguida, transmita esse objeto para o parâmetro `DataCaptureConfig` no método `sagemaker.model.Model.deploy()`. Para usar os trechos de código de processo, substitua o código *italicized placeholder text* no exemplo por suas próprias informações. ## Como habilitar a captura de dados Especifique uma configuração de captura de dados. É possível capturar a carga útil da solicitação, a carga útil da resposta ou ambas com essa configuração. O trecho de código em andamento demonstra como habilitar a captura de dados usando o SDK AI Python e AWS SDK para Python (Boto) o AI SageMaker Python. **nota** Você não precisa usar o Model Monitor para capturar cargas úteis da solicitação ou da resposta. ------ #### [ AWS SDK para Python (Boto) ] Configure os dados que você deseja capturar com o [DataCaptureConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataCaptureConfig.html)dicionário ao criar um endpoint usando o `CreateEndpointConfig` método. Defina `EnableCapture` como o valor booleano True. Além disso, forneça os seguintes parâmetros obrigatórios: + `EndpointConfigName`: nome da configuração do endpoint. Você usará esse nome ao fazer uma solicitação `CreateEndpoint`. + `ProductionVariants`: lista dos modelos que você deseja hospedar nesse endpoint. Defina um tipo de dados de dicionário para cada modelo. + `DataCaptureConfig`: tipo de dados de dicionário em que você especifica um valor inteiro que corresponde à porcentagem inicial de dados a serem amostrados (`InitialSamplingPercentage`), o URI do Amazon S3 em que você deseja que os dados capturados sejam armazenados e uma lista de opções de captura (`CaptureOptions`). Especifique uma `Input` ou `Output` para o `CaptureMode` dentro da lista `CaptureOptions`. Opcionalmente, você pode especificar como a SageMaker IA deve codificar os dados capturados passando argumentos de pares de valores-chave para o dicionário. `CaptureContentTypeHeader` ``` # Create an endpoint config name. endpoint_config_name = '' # The name of the production variant. variant_name = '' # The name of the model that you want to host. # This is the name that you specified when creating the model. model_name = '' instance_type = '' #instance_type='ml.m5.xlarge' # Example # Number of instances to launch initially. initial_instance_count = # Sampling percentage. Choose an integer value between 0 and 100 initial_sampling_percentage = # The S3 URI containing the captured data s3_capture_upload_path = 's3:///' # Specify either Input, Output, or both capture_modes = [ "Input", "Output" ] #capture_mode = [ "Input"] # Example - If you want to capture input only endpoint_config_response = sagemaker_client.create_endpoint_config( EndpointConfigName=endpoint_config_name, # List of ProductionVariant objects, one for each model that you want to host at this endpoint. ProductionVariants=[ { "VariantName": variant_name, "ModelName": model_name, "InstanceType": instance_type, # Specify the compute instance type. "InitialInstanceCount": initial_instance_count # Number of instances to launch initially. } ], DataCaptureConfig= { 'EnableCapture': True, # Whether data should be captured or not. 'InitialSamplingPercentage' : initial_sampling_percentage, 'DestinationS3Uri': s3_capture_upload_path, 'CaptureOptions': [{"CaptureMode" : capture_mode} for capture_mode in capture_modes] # Example - Use list comprehension to capture both Input and Output } ) ``` Para obter mais informações sobre outras opções de configuração de endpoint, consulte a [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)API no [Guia de referência de API do Amazon SageMaker AI Service](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Operations_Amazon_SageMaker_Service.html). ------ #### [ SageMaker Python SDK ] Importe a classe `DataCaptureConfig` do módulo [sagemaker.model\$1monitor](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html). Ative a captura de dados configurando `EnableCapture` com o valor booleano `True`. Opcionalmente, forneça argumentos para os seguintes parâmetros: + `SamplingPercentage`: valor inteiro que corresponde à porcentagem de dados da amostra. Se você não fornecer uma porcentagem de amostragem, a SageMaker IA coletará uma amostra padrão de 20 (20%) dos seus dados. + `DestinationS3Uri`: o URI do Amazon S3 que a SageMaker IA usará para armazenar dados capturados. Se você não fornecer um, a SageMaker IA armazenará os dados capturados em`"s3:/// model-monitor/data-capture"`. ``` from sagemaker.model_monitor import DataCaptureConfig # Set to True to enable data capture enable_capture = True # Optional - Sampling percentage. Choose an integer value between 0 and 100 sampling_percentage = # sampling_percentage = 30 # Example 30% # Optional - The S3 URI of stored captured-data location s3_capture_upload_path = 's3:///' # Specify either Input, Output or both. capture_modes = ['REQUEST','RESPONSE'] # In this example, we specify both # capture_mode = ['REQUEST'] # Example - If you want to only capture input. # Configuration object passed in when deploying Models to SM endpoints data_capture_config = DataCaptureConfig( enable_capture = enable_capture, sampling_percentage = sampling_percentage, # Optional destination_s3_uri = s3_capture_upload_path, # Optional capture_options = ["REQUEST", "RESPONSE"], ) ``` ------ ## Implantar o modelo Implante seu modelo e crie um endpoint HTTPS com `DataCapture` ativado. ------ #### [ AWS SDK para Python (Boto3) ] Forneça a configuração do endpoint para a SageMaker IA. O serviço inicia as instâncias de cálculo de ML e implanta o modelo ou modelos conforme especificado na configuração. Depois de ter seu modelo e configuração de endpoint, use a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) para criar seu endpoint. O nome do endpoint deve ser exclusivo em uma AWS região da sua AWS conta. O recurso abaixo cria um endpoint usando a configuração de endpoint especificada na solicitação. A Amazon SageMaker AI usa o endpoint para provisionar recursos e implantar modelos. ``` # The name of the endpoint. The name must be unique within an AWS Region in your AWS account. endpoint_name = '' # The name of the endpoint configuration associated with this endpoint. endpoint_config_name='' create_endpoint_response = sagemaker_client.create_endpoint( EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name) ``` Para obter mais informações, consulte a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html). ------ #### [ SageMaker Python SDK ] Definir um nome para o endpoint. Esta etapa é opcional. Se você não fornecer um, a SageMaker IA criará um nome exclusivo para você: ``` from datetime import datetime endpoint_name = f"DEMO-{datetime.utcnow():%Y-%m-%d-%H%M}" print("EndpointName =", endpoint_name) ``` Implante seu modelo em um endpoint HTTPS em tempo real com o método `deploy()` integrado do objeto do modelo. Forneça o nome do tipo de instância do Amazon EC2 para implantar esse modelo no campo `instance_type` junto com o número inicial de instâncias nas quais executar o endpoint para o campo `initial_instance_count`: ``` initial_instance_count= # initial_instance_count=1 # Example instance_type='' # instance_type='ml.m4.xlarge' # Example # Uncomment if you did not define this variable in the previous step #data_capture_config = model.deploy( initial_instance_count=initial_instance_count, instance_type=instance_type, endpoint_name=endpoint_name, data_capture_config=data_capture_config ) ``` ------ ## Visualizar os dados capturados Crie um objeto preditor a partir da classe SageMaker Python [SDK](https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html) Predictor. Você usará o objeto retornado pela Classe `Predictor` para invocar seu endpoint em uma etapa futura. Forneça o nome do seu endpoint (definido anteriormente como `endpoint_name`), junto com os objetos serializadores e desserializadores para o serializador e o desserializador, respectivamente. [Para obter informações sobre os tipos de serializadores, consulte a classe [Serializers](https://sagemaker.readthedocs.io/en/stable/api/inference/serializers.html) no SDK do AI SageMaker Python.](https://sagemaker.readthedocs.io/en/stable/index.html) ``` from sagemaker.predictor import Predictor from sagemaker.serializers import from sagemaker.deserializers import predictor = Predictor(endpoint_name=endpoint_name, serializer = , deserializer = ) # Example #from sagemaker.predictor import Predictor #from sagemaker.serializers import CSVSerializer #from sagemaker.deserializers import JSONDeserializer #predictor = Predictor(endpoint_name=endpoint_name, # serializer=CSVSerializer(), # deserializer=JSONDeserializer()) ``` No cenário de exemplo de código em andamento, invocamos o endpoint com exemplos de dados de validação que armazenamos localmente em um arquivo CSV chamado `validation_with_predictions`. Nosso conjunto de validação de amostras contém rótulos para cada entrada. As primeiras linhas da instrução With abrem primeiro o arquivo CSV do conjunto de validação, depois dividem cada linha dentro do arquivo pelo caractere de vírgula `","` e, em seguida, armazenam os dois objetos retornados em um rótulo e variáveis input\$1cols. Para cada linha, a entrada (`input_cols`) é passada para o método `Predictor.predict()` integrado dos objetos da variável preditora (`predictor`). Suponha que o modelo retorne uma probabilidade. As probabilidades variam entre valores inteiros de 0 e 1.0. Se a probabilidade retornada pelo modelo for maior que 80% (0,8), atribuímos à predição um rótulo de valor inteiro de 1. Caso contrário, atribuímos à predição um rótulo de valor inteiro de 0. ``` from time import sleep validate_dataset = "validation_with_predictions.csv" # Cut off threshold of 80% cutoff = 0.8 limit = 200 # Need at least 200 samples to compute standard deviations i = 0 with open(f"test_data/{validate_dataset}", "w") as validation_file: validation_file.write("probability,prediction,label\n") # CSV header with open("test_data/validation.csv", "r") as f: for row in f: (label, input_cols) = row.split(",", 1) probability = float(predictor.predict(input_cols)) prediction = "1" if probability > cutoff else "0" baseline_file.write(f"{probability},{prediction},{label}\n") i += 1 if i > limit: break print(".", end="", flush=True) sleep(0.5) print() print("Done!") ``` Como você habilitou a captura de dados nas etapas anteriores, a carga útil da solicitação e da resposta, além de alguns metadados adicionais, é salva no local do Amazon S3 especificado em `DataCaptureConfig`. A entrega dos dados de captura para o Amazon S3 pode exigir alguns minutos. Visualize dados capturados listando os arquivos de captura de dados armazenados no Amazon S3. O formato do caminho do Amazon S3 é: `s3:///{endpoint-name}/{variant-name}/yyyy/mm/dd/hh/filename.jsonl`. Espere ver arquivos diferentes de diferentes períodos de tempo, organizados com base na hora em que a invocação ocorreu. Execute o seguinte para imprimir o conteúdo de um único arquivo de captura: ``` print("\n".join(capture_file[-3:-1])) ``` Isso retornará um arquivo formatado em linha JSON específico para SageMaker IA. A seguir está um exemplo de resposta retirado de um endpoint em tempo real que invocamos usando dados `csv/text`: ``` {"captureData":{"endpointInput":{"observedContentType":"text/csv","mode":"INPUT", "data":"69,0,153.7,109,194.0,105,256.1,114,14.1,6,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0\n", "encoding":"CSV"},"endpointOutput":{"observedContentType":"text/csv; charset=utf-8","mode":"OUTPUT","data":"0.0254181120544672","encoding":"CSV"}}, "eventMetadata":{"eventId":"aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee","inferenceTime":"2022-02-14T17:25:49Z"},"eventVersion":"0"} {"captureData":{"endpointInput":{"observedContentType":"text/csv","mode":"INPUT", "data":"94,23,197.1,125,214.5,136,282.2,103,9.5,5,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,1\n", "encoding":"CSV"},"endpointOutput":{"observedContentType":"text/csv; charset=utf-8","mode":"OUTPUT","data":"0.07675473392009735","encoding":"CSV"}}, "eventMetadata":{"eventId":"aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee","inferenceTime":"2022-02-14T17:25:49Z"},"eventVersion":"0"} ``` No exemplo a seguir, o objeto `capture_file` é um tipo de lista. Indexe o primeiro elemento da lista para visualizar uma única solicitação de inferência. ``` # The capture_file object is a list. Index the first element to view a single inference request print(json.dumps(json.loads(capture_file[0]), indent=2)) ``` Essa ação retornará uma resposta semelhante à seguinte: Os valores retornados serão diferentes com base na configuração do endpoint, no modelo de SageMaker IA e nos dados capturados: ``` { "captureData": { "endpointInput": { "observedContentType": "text/csv", # data MIME type "mode": "INPUT", "data": "50,0,188.9,94,203.9,104,151.8,124,11.6,8,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0\n", "encoding": "CSV" }, "endpointOutput": { "observedContentType": "text/csv; charset=character-encoding", "mode": "OUTPUT", "data": "0.023190177977085114", "encoding": "CSV" } }, "eventMetadata": { "eventId": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee", "inferenceTime": "2022-02-14T17:25:06Z" }, "eventVersion": "0" } ``` # Capturar dados do trabalho de transformação de lotes As etapas necessárias para ativar a captura de dados para seu trabalho de transformação em lote são semelhantes, independentemente de você usar o SDK do Python AWS SDK para Python (Boto) ou do SageMaker Python. Se você usa o AWS SDK, defina o [DataCaptureConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataCaptureConfig.html)dicionário, junto com os campos obrigatórios, dentro do `CreateTransformJob` método para ativar a captura de dados. Se você usa o SDK SageMaker AI Python, importe a `BatchDataCaptureConfig` classe e inicialize uma instância dessa classe. Em seguida, passe esse objeto para o parâmetro `batch_data_capture_config` da sua instância do trabalho de transformação. Para usar os trechos de código a seguir, substitua o código *italicized placeholder text* no exemplo por suas próprias informações. ## Como habilitar a captura de dados Especifique uma configuração de captura de dados ao iniciar um trabalho de transformação. Se você usa o SDK AWS SDK para Python (Boto3) ou o SageMaker Python, você deve fornecer o `DestinationS3Uri` argumento, que é o diretório em que você deseja que o trabalho de transformação registre os dados capturados. Opcionalmente, você também pode definir os seguintes parâmetros: + `KmsKeyId`: a AWS KMS chave usada para criptografar os dados capturados. + `GenerateInferenceId`: sinalizador booleano que, ao capturar os dados, indica se você deseja que o trabalho de transformação anexe o ID e a hora da inferência à sua saída. Isso é útil para o monitoramento da qualidade do modelo, onde você precisa ingerir os dados do Ground Truth. O ID de inferência e o tempo ajudam a combinar os dados capturados com os dados do Ground Truth. ------ #### [ AWS SDK para Python (Boto3) ] Configure os dados que você deseja capturar com o [DataCaptureConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataCaptureConfig.html)dicionário ao criar um trabalho de transformação usando o `CreateTransformJob` método. ``` input_data_s3_uri = "s3://input_S3_uri" output_data_s3_uri = "s3://output_S3_uri" data_capture_destination = "s3://captured_data_S3_uri" model_name = "model_name" sm_client.create_transform_job( TransformJobName="transform_job_name", MaxConcurrentTransforms=2, ModelName=model_name, TransformInput={ "DataSource": { "S3DataSource": { "S3DataType": "S3Prefix", "S3Uri": input_data_s3_uri, } }, "ContentType": "text/csv", "CompressionType": "None", "SplitType": "Line", }, TransformOutput={ "S3OutputPath": output_data_s3_uri, "Accept": "text/csv", "AssembleWith": "Line", }, TransformResources={ "InstanceType": "ml.m4.xlarge", "InstanceCount": 1, }, DataCaptureConfig={ "DestinationS3Uri": data_capture_destination, "KmsKeyId": "kms_key", "GenerateInferenceId": True, } ) ``` ------ #### [ SageMaker Python SDK ] Importe a classe `BatchDataCaptureConfig` do [sagemaker.model\$1monitor](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html). ``` from sagemaker.transformer import Transformer from sagemaker.inputs import BatchDataCaptureConfig # Optional - The S3 URI of where to store captured data in S3 data_capture_destination = "s3://captured_data_S3_uri" model_name = "model_name" transformer = Transformer(model_name=model_name, ...) transform_arg = transformer.transform( batch_data_capture_config=BatchDataCaptureConfig( destination_s3_uri=data_capture_destination, kms_key_id="kms_key", generate_inference_id=True, ), ... ) ``` ------ ## Como visualizar os dados capturados Depois que o trabalho de transformação for concluído, os dados capturados serão registrados sob o `DestinationS3Uri` que você forneceu com a configuração da captura de dados. Há dois subdiretórios em `DestinationS3Uri`, `/input` e `/output`. Se `DestinationS3Uri` for `s3://my-data-capture`, o trabalho de transformação criará os seguintes diretórios: + `s3://my-data-capture/input`: os dados de entrada capturados para o trabalho de transformação. + `s3://my-data-capture/output`: os dados de saída capturados para o trabalho de transformação. Para evitar a duplicação de dados, os dados capturados nos dois diretórios anteriores são manifestos. Cada manifesto é um arquivo JSONL que contém as localizações dos objetos de fonte no Amazon S3. Um arquivo manifesto pode parecer com o seguinte exemplo: ``` # under "/input" directory [ {"prefix":"s3://input_S3_uri/"}, "dummy_0.csv", "dummy_1.csv", "dummy_2.csv", ... ] # under "/output" directory [ {"prefix":"s3://output_S3_uri/"}, "dummy_0.csv.out", "dummy_1.csv.out", "dummy_2.csv.out", ... ] ``` O trabalho de transformação organiza e rotula esses manifestos com um prefixo *yyyy/mm/dd/hh* S3 para indicar quando eles foram capturados. Isso ajuda o monitor do modelo a determinar a parte apropriada dos dados a serem analisados. Por exemplo, se você iniciar seu trabalho de transformação em 26/08/2022 às 13h UTC, os dados capturados serão rotulados com uma string de prefixo `2022/08/26/13/`. ## InferenceId Geração Ao configurar uma `DataCaptureConfig` para um trabalho de transformação, você pode ativar o sinalizador booleano `GenerateInferenceId`. Essa ação é particularmente útil quando você precisa executar trabalhos de monitoramento da qualidade do modelo e do desvio do modelo, para os quais você precisa de dados do Ground Truth ingeridos pelo usuário. O monitor de modelo depende de um ID de inferência para combinar os dados capturados e os dados do Ground Truth. Para obter detalhes adicionais sobre a ingestão do Ground Truth, consulte [Ingerir rótulos do Ground Truth e mesclá-los com predições](model-monitor-model-quality-merge.md). Quando `GenerateInferenceId` está ativado, a saída da transformação anexa um ID de inferência (um UUID aleatório), bem como o horário de início do trabalho de transformação em UTC para cada registro. Você precisa desses dois valores para executar o monitoramento da qualidade do modelo e do desvio de modelo. Ao criar os dados do Ground Truth, você precisa fornecer o mesmo ID de inferência para corresponder aos dados de saída. Atualmente, esse atributo é compatível com saídas de transformação nos formatos CSV, JSON e JSONL. Se a saída da transformação estiver no formato CSV, o arquivo de saída terá a aparência do seguinte exemplo: ``` 0, 1f1d57b1-2e6f-488c-8c30-db4e6d757861,2022-08-30T00:49:15Z 1, 22445434-0c67-45e9-bb4d-bd1bf26561e6,2022-08-30T00:49:15Z ... ``` As duas últimas colunas são a ID de inferência e o horário de início do trabalho de transformação. Não os modifique. As colunas restantes são as saídas do seu trabalho de transformação. Se a saída da transformação estiver no formato JSON ou JSONL, o arquivo de saída terá a aparência do seguinte exemplo: ``` {"output": 0, "SageMakerInferenceId": "1f1d57b1-2e6f-488c-8c30-db4e6d757861", "SageMakerInferenceTime": "2022-08-30T00:49:15Z"} {"output": 1, "SageMakerInferenceId": "22445434-0c67-45e9-bb4d-bd1bf26561e6", "SageMakerInferenceTime": "2022-08-30T00:49:15Z"} ... ``` Há dois campos anexados que são reservados, `SageMakerInferenceId` e `SageMakerInferenceTime`. Não modifique esses campos se precisar executar o monitoramento da qualidade do modelo ou do desvio de modelo. pois você precisa deles para trabalhos de mesclagem. # Qualidade dos dados O monitoramento de qualidade dos dados monitora automaticamente os modelos de machine learning (ML) em produção e notifica você quando surgem problemas de qualidade de dados. Os modelos de ML em produção têm que fazer predições sobre dados da vida real que não são cuidadosamente curados como a maioria dos conjuntos de dados de treinamento. Se a natureza estatística dos dados que o modelo recebe durante a produção se desviar da natureza dos dados da linha de base nos quais foi treinado, o modelo começa a perder a precisão em suas predições. O Amazon SageMaker Model Monitor usa regras para detectar desvios de dados e alerta você quando isso acontece. Para monitorar a qualidade dos dados, siga estas etapas: + Habilite a captura de dados. Essa ação captura a entrada e a saída de inferência de um endpoint de inferência em tempo real ou de um trabalho de transformação em lote e armazena os dados no Amazon S3. Para obter mais informações, consulte [Captura de dados](model-monitor-data-capture.md). + Crie uma linha de base. Nesta etapa, você executará um trabalho de linha de base que analisa um conjunto de dados de entrada fornecido por você. A linha de base calcula as restrições do esquema de linha de base para cada atributo usando [Deequ](https://github.com/awslabs/deequ), uma biblioteca de código aberto criada no Apache Spark que é usada para medir a qualidade dos dados em conjuntos de dados grandes. Para obter mais informações, consulte [Criar uma linha de base](model-monitor-create-baseline.md). + Defina e programe trabalhos de monitoramento de qualidade dos dados. Para obter informações específicas e exemplos de código de trabalhos de monitoramento da qualidade dos dados, consulte [Programar trabalhos de monitoramento da qualidade dos dados](model-monitor-schedule-data-monitor.md). Para obter informações gerais sobre trabalhos de monitoramento, consulte [Programar trabalhos de monitoramento](model-monitor-scheduling.md). + Opcionalmente, use scripts de pré-processamento e pós-processamento para transformar os dados que saem da sua análise de qualidade dos dados. Para obter mais informações, consulte [Pré-processamento e pós-processamento](model-monitor-pre-and-post-processing.md). + Visualize métricas de qualidade dos dados. Para obter mais informações, consulte [Esquema para estatísticas (arquivo statistics.json)](model-monitor-interpreting-statistics.md). + Integre o monitoramento da qualidade dos dados com a Amazon CloudWatch. Para obter mais informações, consulte [CloudWatch Métricas](model-monitor-interpreting-cloudwatch.md). + Interpretar os resultados de um trabalho de monitoramento. Para obter mais informações, consulte [Interpretar resultados](model-monitor-interpreting-results.md). + Use o SageMaker Studio para permitir o monitoramento da qualidade dos dados e visualizar os resultados se você estiver usando um endpoint em tempo real. Para obter mais informações, consulte [Visualize resultados para endpoints em tempo real no Amazon Studio SageMaker](model-monitor-interpreting-visualize-results.md). **nota** O Model Monitor calcula métricas e estatísticas do modelo somente em dados tabulares. Por exemplo, um modelo de classificação de imagens que usa imagens como entrada e gera um rótulo baseado nessa imagem ainda pode ser monitorado. O Model Monitor seria capaz de calcular métricas e estatísticas para a saída, não para a entrada. **Topics** + [Criar uma linha de base](model-monitor-create-baseline.md) + [Programar trabalhos de monitoramento da qualidade dos dados](model-monitor-schedule-data-monitor.md) + [Esquema para estatísticas (arquivo statistics.json)](model-monitor-interpreting-statistics.md) + [CloudWatch Métricas](model-monitor-interpreting-cloudwatch.md) + [Esquema para violações (arquivo constraint\$1violations.json)](model-monitor-interpreting-violations.md) # Criar uma linha de base Os cálculos da linha de base de estatísticas e restrições são necessários como um padrão em relação ao qual o desvio de dados e outros problemas de qualidade de dados podem ser detectados. O Model Monitor fornece um contêiner interno que oferece a capacidade de sugerir automaticamente as restrições para a entrada JSON simples e CSV. Esse *sagemaker-model-monitor-analyzer*contêiner também fornece uma variedade de recursos de monitoramento de modelos, incluindo validação de restrições em relação a uma linha de base e emissão de métricas da Amazon CloudWatch . Esse contêiner é baseado na versão 3.3.0 do Spark e foi criado com a versão 2.0.2 do [Deequ](https://github.com/awslabs/deequ). Todos os nomes das colunas em seu conjunto de dados de linha de base devem estar em conformidade com o Spark. Para os nomes das colunas, use somente caracteres minúsculos e `_` como o único caractere especial. O conjunto de dados de treinamento usado para treinar o modelo geralmente é um bom conjunto de dados de linha de base. O esquema de dados do conjunto de dados de treinamento e o esquema do conjunto de dados de inferência devem ser uma correspondência exata (o número e a ordem dos atributos). Observe que as prediction/output colunas são consideradas as primeiras colunas no conjunto de dados de treinamento. No conjunto de dados de treinamento, você pode pedir à SageMaker IA que sugira um conjunto de restrições básicas e gere estatísticas descritivas para explorar os dados. Para esse exemplo, faça upload do conjunto de dados de treinamento usado para treinar o modelo pré-treinado incluído neste exemplo. Se você já armazenou o conjunto de dados de treinamento no Amazon S3, poderá apontar diretamente para ele. **Para criar uma linha de base a partir de um conjunto de dados de treinamento** Quando você tiver seus dados de treinamento prontos e armazenados no Amazon S3, inicie um trabalho de processamento básico usando o SDK `DefaultModelMonitor.suggest_baseline(..)` do Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable). Essa ação usa um [Contêiner pré-construído Amazon SageMaker Model Monitor](model-monitor-pre-built-container.md) que gera estatísticas de linha de base e sugere restrições de linha de base para o conjunto de dados e as grava no local `output_s3_uri` especificado. ``` from sagemaker.model_monitor import DefaultModelMonitor from sagemaker.model_monitor.dataset_format import DatasetFormat my_default_monitor = DefaultModelMonitor( role=role, instance_count=1, instance_type='ml.m5.xlarge', volume_size_in_gb=20, max_runtime_in_seconds=3600, ) my_default_monitor.suggest_baseline( baseline_dataset=baseline_data_uri+'/training-dataset-with-header.csv', dataset_format=DatasetFormat.csv(header=True), output_s3_uri=baseline_results_uri, wait=True ) ``` **nota** Se você fornecer os feature/column nomes no conjunto de dados de treinamento como a primeira linha e definir a `header=True` opção conforme mostrado na amostra de código anterior, o SageMaker AI usará o nome do recurso no arquivo de restrições e estatísticas. As estatísticas de linha de base para o conjunto de dados estão contidas no arquivo statistics.json e as restrições de linha de base sugeridas estão contidas no arquivo constraints.json no local especificado com `output_s3_uri`. Arquivos de saída para estatísticas e restrições do conjunto de dados tabular | Nome do arquivo | Description | | --- | --- | | statistics.json | Espera-se que este arquivo tenha estatísticas colunares para cada atributo no conjunto de dados que é analisado. Para obter mais informações sobre o esquema desse arquivo, consulte [Esquema para estatísticas (arquivo statistics.json)](model-monitor-byoc-statistics.md). | | constraints.json | Espera-se que este arquivo tenha as restrições sobre os atributos observados. Para obter mais informações sobre o esquema desse arquivo, consulte [Esquema para restrições (arquivo constraints.json)](model-monitor-byoc-constraints.md). | O [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) fornece funções de conveniência descritas para gerar as estatísticas e restrições básicas. No entanto, se você quiser chamar o trabalho de processamento diretamente para essa finalidade, é necessário definir o mapa `Environment` como mostrado no seguinte exemplo: ``` "Environment": { "dataset_format": "{\"csv\”: { \”header\”: true}", "dataset_source": "/opt/ml/processing/sm_input", "output_path": "/opt/ml/processing/sm_output", "publish_cloudwatch_metrics": "Disabled", } ``` # Programar trabalhos de monitoramento da qualidade dos dados Depois de criar sua linha de base, você pode chamar o método `create_monitoring_schedule()` da sua instância de classe `DefaultModelMonitor` para programar um monitor horário de qualidade dos modelo. As seções a seguir mostram como criar um monitor de qualidade dos modelo para um modelo implantado em um endpoint em tempo real, bem como para um trabalho de transformação de lotes. **Importante** Você pode especificar uma entrada de transformação em lote ou uma entrada de endpoint, mas não ambas, ao criar sua programação de monitoramento. ## Monitoramento da qualidade dos dados para modelos implantados em endpoints em tempo real Para programar um monitor de qualidade dos dados para um endpoint em tempo real, transmita sua instância `EndpointInput` para o argumento `endpoint_input` de sua instância `DefaultModelMonitor`, conforme mostrado no seguinte exemplo de código: ``` from sagemaker.model_monitor import CronExpressionGenerator data_quality_model_monitor = DefaultModelMonitor( role=sagemaker.get_execution_role(), ... ) schedule = data_quality_model_monitor.create_monitoring_schedule( monitor_schedule_name=schedule_name, post_analytics_processor_script=s3_code_postprocessor_uri, output_s3_uri=s3_report_path, schedule_cron_expression=CronExpressionGenerator.hourly(), statistics=data_quality_model_monitor.baseline_statistics(), constraints=data_quality_model_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, endpoint_input=EndpointInput( endpoint_name=endpoint_name, destination="/opt/ml/processing/input/endpoint", ) ) ``` ## Monitoramento da qualidade dos dados para trabalhos de transformação de lotes Para programar um monitor de qualidade dos dados para um trabalho de transformação de lotes, transmita sua instância `BatchTransformInput` para o argumento `batch_transform_input` de sua instância `DefaultModelMonitor`, conforme mostrado no seguinte exemplo de código: ``` from sagemaker.model_monitor import CronExpressionGenerator data_quality_model_monitor = DefaultModelMonitor( role=sagemaker.get_execution_role(), ... ) schedule = data_quality_model_monitor.create_monitoring_schedule( monitor_schedule_name=mon_schedule_name, batch_transform_input=BatchTransformInput( data_captured_destination_s3_uri=s3_capture_upload_path, destination="/opt/ml/processing/input", dataset_format=MonitoringDatasetFormat.csv(header=False), ), output_s3_uri=s3_report_path, statistics= statistics_path, constraints = constraints_path, schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, ) ``` # Esquema para estatísticas (arquivo statistics.json) O contêiner pré-construído do Amazon SageMaker Model Monitor calcula por estatística. column/feature As estatísticas são calculadas para o conjunto de dados da linha de base e também para o conjunto de dados atual que está sendo analisado. ``` { "version": 0, # dataset level stats "dataset": { "item_count": number }, # feature level stats "features": [ { "name": "feature-name", "inferred_type": "Fractional" | "Integral", "numerical_statistics": { "common": { "num_present": number, "num_missing": number }, "mean": number, "sum": number, "std_dev": number, "min": number, "max": number, "distribution": { "kll": { "buckets": [ { "lower_bound": number, "upper_bound": number, "count": number } ], "sketch": { "parameters": { "c": number, "k": number }, "data": [ [ num, num, num, num ], [ num, num ][ num, num ] ] }#sketch }#KLL }#distribution }#num_stats }, { "name": "feature-name", "inferred_type": "String", "string_statistics": { "common": { "num_present": number, "num_missing": number }, "distinct_count": number, "distribution": { "categorical": { "buckets": [ { "value": "string", "count": number } ] } } }, #provision for custom stats } ] } ``` Observe o seguinte: + Os contêineres pré-criados calculam o [esboço KLL](https://datasketches.apache.org/docs/KLL/KLLSketch.html), que é um esboço de quantias compactas. + Por padrão, materializamos a distribuição em 10 buckets. Isso não é configurável no momento. # CloudWatch Métricas Você pode usar o contêiner incorporado Amazon SageMaker Model Monitor para CloudWatch métricas. Quando a `emit_metrics` opção está `Enabled` no arquivo de restrições da linha de base, o SageMaker AI emite essas métricas para cada uma feature/column observada no conjunto de dados no seguinte namespace: + `For real-time endpoints: /aws/sagemaker/Endpoints/data-metric` namespace com dimensões `EndpointName` e `ScheduleName`. + `For batch transform jobs: /aws/sagemaker/ModelMonitoring/data-metric` namespace com dimensão `MonitoringSchedule`. Para campos numéricos, o contêiner integrado emite as seguintes métricas: CloudWatch + Métrica: Max → consulta para `MetricName: feature_data_{feature_name}, Stat: Max` + Métrica: Min → consulta para `MetricName: feature_data_{feature_name}, Stat: Min` + Métrica: Sum → consulta para `MetricName: feature_data_{feature_name}, Stat: Sum` + Métrica: SampleCount → consulta para `MetricName: feature_data_{feature_name}, Stat: SampleCount` + Métrica: Average → consulta para `MetricName: feature_data_{feature_name}, Stat: Average` Para campos numéricos e de string, o contêiner integrado emite as seguintes métricas: CloudWatch + Métrica: Completeness → consulta para `MetricName: feature_non_null_{feature_name}, Stat: Sum` + Métrica: Baseline Drift → consulta para `MetricName: feature_baseline_drift_{feature_name}, Stat: Sum` # Esquema para violações (arquivo constraint\$1violations.json) O arquivo de violações é gerado como a saída de um `MonitoringExecution`, que lista os resultados da avaliação das restrições (especificadas no arquivo constraints.json) em relação ao conjunto de dados atual que foi analisado. O contêiner pré-construído Amazon SageMaker Model Monitor fornece as seguintes verificações de violação. ``` { "violations": [{ "feature_name" : "string", "constraint_check_type" : "data_type_check", | "completeness_check", | "baseline_drift_check", | "missing_column_check", | "extra_column_check", | "categorical_values_check" "description" : "string" }] } ``` Tipos de violações monitoradas | Tipo de verificação de violação | Description | | --- | --- | | data\$1type\$1check | Se os tipos de dados na execução atual não forem os mesmos que no conjunto de dados da linha de base, essa violação será sinalizada. Durante a etapa da linha de base, as restrições geradas sugerem o tipo de dados inferidos para cada coluna. O parâmetro `monitoring_config.datatype_check_threshold` pode ser regulado para ajustar o limite quando for sinalizado como uma violação. | | completeness\$1check | Se a completude (% de itens não nulos) observada na execução atual exceder o limite especificado no limite de completude especificado por atributo, essa violação será sinalizada. Durante a etapa da linha de base, as restrições geradas sugerem um valor de completude. | | baseline\$1drift\$1check | Se a distância de distribuição calculada entre os conjuntos de dados atual e da linha de base for maior do que o limite especificado em `monitoring_config.comparison_threshold`, essa violação será sinalizada. | | missing\$1column\$1check | Se o número de colunas no conjunto de dados atual for menor que o número no conjunto de dados da linha de base, essa violação será sinalizada. | | extra\$1column\$1check | Se o número de colunas no conjunto de dados atual for maior que o número na linha de base, essa violação será sinalizada. | | categorical\$1values\$1check | Se houver mais valores desconhecidos no conjunto de dados atual do que no conjunto de dados da linha de base, essa violação será sinalizada. Esse valor é ditado pelo limite em `monitoring_config.domain_content_threshold`. | # Qualidade do modelo Os trabalhos de monitoramento da qualidade do modelo monitoram o desempenho de um modelo comparando as predições que o modelo faz com os rótulos reais do Ground Truth que o modelo tenta prever. Para fazer isso, o monitoramento da qualidade do modelo mescla dados que são capturados da inferência em tempo real ou em lote com rótulos reais que você armazena em um bucket do Amazon S3 e, em seguida, compara as predições com os rótulos reais. Para medir a qualidade do modelo, o Model Monitor usa métricas que dependem do tipo de problema de ML. Por exemplo, se seu modelo for para um problema de regressão, uma das métricas avaliadas é o erro quadrático médio (mse). Para obter informações sobre todas as métricas usadas para os diferentes tipos de problemas de ML, consulte [Métricas de qualidade do modelo e CloudWatch monitoramento da Amazon](model-monitor-model-quality-metrics.md). O monitoramento da qualidade do modelo segue as mesmas etapas do monitoramento da qualidade dos dados, mas adiciona a etapa adicional de mesclar os rótulos reais do Amazon S3 com as predições capturadas do endpoint de inferência em tempo real ou do trabalho de transformação em lote. Para monitorar a qualidade do modelo, siga estas etapas: + Habilite a captura de dados. Essa ação captura a entrada e a saída de inferência de um endpoint de inferência em tempo real ou de um trabalho de transformação em lote e armazena os dados no Amazon S3. Para obter mais informações, consulte [Captura de dados](model-monitor-data-capture.md). + Crie uma linha de base. Nesta etapa, você executa um trabalho de linha de base que compara as predições de modelo com os rótulos do Ground Truth em um conjunto de dados de linha de base. O trabalho de linha de base cria automaticamente regras e restrições estatísticas básicas que definem os limites em relação aos quais o desempenho do modelo é avaliada. Para obter mais informações, consulte [Criar uma linha de base da qualidade de modelo](model-monitor-model-quality-baseline.md). + Definir e programar trabalhos de monitoramento de qualidade de modelos. Para obter informações específicas e exemplos de código de trabalhos de monitoramento da qualidade dos dados, consulte [Programar trabalhos de monitoramento da qualidade de modelos](model-monitor-model-quality-schedule.md). Para obter informações gerais sobre trabalhos de monitoramento, consulte [Programar trabalhos de monitoramento](model-monitor-scheduling.md). + Ingerir rótulos do Ground Truth que o monitor do modelo se mescla com os dados de predição capturados de um endpoint de inferência em tempo real ou de um trabalho de transformação em lote. Para obter mais informações, consulte [Ingerir rótulos do Ground Truth e mesclá-los com predições](model-monitor-model-quality-merge.md). + Integre o monitoramento da qualidade do modelo com a Amazon CloudWatch. Para obter mais informações, consulte [Monitorando as métricas de qualidade do modelo com CloudWatch](model-monitor-model-quality-metrics.md#model-monitor-model-quality-cw). + Interpretar os resultados de um trabalho de monitoramento. Para obter mais informações, consulte [Interpretar resultados](model-monitor-interpreting-results.md). + Use o SageMaker Studio para permitir o monitoramento da qualidade do modelo e visualizar os resultados. Para obter mais informações, consulte [Visualize resultados para endpoints em tempo real no Amazon Studio SageMaker](model-monitor-interpreting-visualize-results.md). **Topics** + [Criar uma linha de base da qualidade de modelo](model-monitor-model-quality-baseline.md) + [Programar trabalhos de monitoramento da qualidade de modelos](model-monitor-model-quality-schedule.md) + [Ingerir rótulos do Ground Truth e mesclá-los com predições](model-monitor-model-quality-merge.md) + [Métricas de qualidade do modelo e CloudWatch monitoramento da Amazon](model-monitor-model-quality-metrics.md) # Criar uma linha de base da qualidade de modelo Crie um trabalho de linha de base que compare suas predições de modelo com rótulos de veracidade em um conjunto de dados de linha de base que você armazenou no Amazon S3. Normalmente, você usa um conjunto de dados de treinamento como o conjunto de dados de linha de base. O trabalho de linha de base calcula as métricas do modelo e sugere restrições a serem usadas para monitorar a variação da qualidade do modelo. Para criar um trabalho de linha de base, você precisa ter um conjunto de dados que contenha predições do seu modelo junto com rótulos que representem o Ground Truth para seus dados. Para criar um trabalho básico, use a `ModelQualityMonitor` classe fornecida pelo SDK do SageMaker Python e conclua as etapas a seguir. **Para criar uma linha de base de qualidade do modelo** 1. Primeiramente, crie uma instância da classe `ModelQualityMonitor`. O trecho de código a seguir mostra como fazer isso. ``` from sagemaker import get_execution_role, session, Session from sagemaker.model_monitor import ModelQualityMonitor role = get_execution_role() session = Session() model_quality_monitor = ModelQualityMonitor( role=role, instance_count=1, instance_type='ml.m5.xlarge', volume_size_in_gb=20, max_runtime_in_seconds=1800, sagemaker_session=session ) ``` 1. Agora, chame o método `suggest_baseline` do objeto `ModelQualityMonitor` para executar um trabalho de linha de base. O trecho de código a seguir pressupõe que você tenha um conjunto de dados de linha de base que contém predições e rótulos armazenados no Amazon S3. ``` baseline_job_name = "MyBaseLineJob" job = model_quality_monitor.suggest_baseline( job_name=baseline_job_name, baseline_dataset=baseline_dataset_uri, # The S3 location of the validation dataset. dataset_format=DatasetFormat.csv(header=True), output_s3_uri = baseline_results_uri, # The S3 location to store the results. problem_type='BinaryClassification', inference_attribute= "prediction", # The column in the dataset that contains predictions. probability_attribute= "probability", # The column in the dataset that contains probabilities. ground_truth_attribute= "label" # The column in the dataset that contains ground truth labels. ) job.wait(logs=False) ``` 1. Após a conclusão do trabalho de linha de base, é possível visualizar as restrições que o trabalho gerou. Primeiro, obtenha os resultados do trabalho de linha de base chamando o método `latest_baselining_job` do objeto `ModelQualityMonitor`. ``` baseline_job = model_quality_monitor.latest_baselining_job ``` 1. O trabalho de linha de base sugere restrições, que são limites para métricas que modelam medidas de monitoramento. Se uma métrica ultrapassar o limite sugerido, o Model Monitor relata uma violação. Para visualizar as restrições que o trabalho de linha de base gerou, chame o método `suggested_constraints` do trabalho de linha de base. O trecho de código a seguir carrega as restrições de um modelo de classificação binária em um dataframe Pandas. ``` import pandas as pd pd.DataFrame(baseline_job.suggested_constraints().body_dict["binary_classification_constraints"]).T ``` Recomendamos que você visualize as restrições geradas e as modifique conforme necessário antes de usá-las para monitoramento. Por exemplo, se uma restrição for muito agressiva, você poderá receber mais alertas de violações do que gostaria. Se sua restrição contiver números expressos em notação científica, você precisará convertê-los em flutuantes. O exemplo de [script de pré-processamento](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-pre-and-post-processing.html#model-monitor-pre-processing-script) de python a seguir mostra como converter números em notação científica em flutuantes. ``` import csv def fix_scientific_notation(col): try: return format(float(col), "f") except: return col def preprocess_handler(csv_line): reader = csv.reader([csv_line]) csv_record = next(reader) #skip baseline header, change HEADER_NAME to the first column's name if csv_record[0] == “HEADER_NAME”: return [] return { str(i).zfill(20) : fix_scientific_notation(d) for i, d in enumerate(csv_record)} ``` Você pode adicionar seu script de pré-processamento a uma linha de base ou programação de monitoramento como um `record_preprocessor_script`, conforme definido na documentação do [Model Monitor](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html). 1. Quando estiver satisfeito com as restrições, passe-as como parâmetro `constraints` ao criar uma programação de monitoramento. Para obter mais informações, consulte [Programar trabalhos de monitoramento da qualidade de modelos](model-monitor-model-quality-schedule.md). As restrições de linha de base sugeridas estão contidas no arquivo constraints.json no local com o qual você especifica `output_s3_uri`. Para obter informações sobre o esquema desse arquivo no [Esquema para restrições (arquivo constraints.json)](model-monitor-byoc-constraints.md). # Programar trabalhos de monitoramento da qualidade de modelos Depois de criar sua linha de base, você pode chamar o método `create_monitoring_schedule()` da sua instância de classe `ModelQualityMonitor` para programar um monitor horário de qualidade do modelo. As seções a seguir mostram como criar um monitor de qualidade do modelo para um modelo implantado em um endpoint em tempo real, bem como para um trabalho de transformação em lote. **Importante** Você pode especificar uma entrada de transformação em lote ou uma entrada de endpoint, mas não ambas, ao criar sua programação de monitoramento. Ao contrário do monitoramento da qualidade dos dados, você precisa fornecer rótulos do Ground Truth se quiser monitorar a qualidade do modelo. No entanto, os rótulos do Ground Truth podem ser adiados. Para resolver isso, especifique compensações ao criar sua programação de monitoramento. ## Deslocamentos do monitor do modelo Os trabalhos de qualidade do modelo incluem `StartTimeOffset` e `EndTimeOffset`, que são campos do parâmetro `ModelQualityJobInput` do método `create_model_quality_job_definition` que funcionam da seguinte maneira: + `StartTimeOffset` - Se especificado, os trabalhos subtraem esse tempo da hora de início. + `EndTimeOffset` - Se especificado, os trabalhos subtraem esse tempo da hora de término. O formato dos offsets é, por exemplo, - PT7 H, onde 7H é 7 horas. Você pode usar -PT \$1H ou -P\$1D, em que H = horas, D = dias e M = minutos, e \$1 é o número. Além disso, o deslocamento deve estar no [formato de duração ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations). Por exemplo, se seu Ground Truth começar a chegar após 1 dia, mas não for concluído por uma semana, defina `StartTimeOffset` como `-P8D` e `EndTimeOffset` como `-P1D`. Então, se você programar um trabalho para ser executado em `2020-01-09T13:00`, ele analisará os dados entre `2020-01-01T13:00` e `2020-01-08T13:00`. **Importante** A cadência da programação deve ser tal que uma execução termine antes do início da próxima execução, o que permite que o Ground Truth mescle o trabalho e o trabalho de monitoramento da execução até a conclusão. O runtime máximo de uma execução é dividido entre os dois trabalhos, portanto, para um trabalho de monitoramento horário de qualidade do modelo, o valor `MaxRuntimeInSeconds` especificado como parte de `StoppingCondition` não deve ser superior a 1800. ## Monitoramento da qualidade do modelo para modelos implantados em endpoints em tempo real Para programar um monitor de qualidade do modelo para um endpoint em tempo real, transmita sua instância `EndpointInput` para o argumento `endpoint_input` de sua instância `ModelQualityMonitor`, conforme mostrado no seguinte exemplo de código: ``` from sagemaker.model_monitor import CronExpressionGenerator model_quality_model_monitor = ModelQualityMonitor( role=sagemaker.get_execution_role(), ... ) schedule = model_quality_model_monitor.create_monitoring_schedule( monitor_schedule_name=schedule_name, post_analytics_processor_script=s3_code_postprocessor_uri, output_s3_uri=s3_report_path, schedule_cron_expression=CronExpressionGenerator.hourly(), statistics=model_quality_model_monitor.baseline_statistics(), constraints=model_quality_model_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, endpoint_input=EndpointInput( endpoint_name=endpoint_name, destination="/opt/ml/processing/input/endpoint", start_time_offset="-PT2D", end_time_offset="-PT1D", ) ) ``` ## Monitoramento da qualidade do modelo para trabalhos de transformação de lotes Para programar um monitor de qualidade do modelo para um trabalho de transformação em lote, transmita sua instância `BatchTransformInput` para o argumento `batch_transform_input` de sua instância `ModelQualityMonitor`, conforme mostrado no seguinte exemplo de código: ``` from sagemaker.model_monitor import CronExpressionGenerator model_quality_model_monitor = ModelQualityMonitor( role=sagemaker.get_execution_role(), ... ) schedule = model_quality_model_monitor.create_monitoring_schedule( monitor_schedule_name=mon_schedule_name, batch_transform_input=BatchTransformInput( data_captured_destination_s3_uri=s3_capture_upload_path, destination="/opt/ml/processing/input", dataset_format=MonitoringDatasetFormat.csv(header=False), # the column index of the output representing the inference probablity probability_attribute="0", # the threshold to classify the inference probablity to class 0 or 1 in # binary classification problem probability_threshold_attribute=0.5, # look back 6 hour for transform job outputs. start_time_offset="-PT6H", end_time_offset="-PT0H" ), ground_truth_input=gt_s3_uri, output_s3_uri=s3_report_path, problem_type="BinaryClassification", constraints = constraints_path, schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, ) ``` # Ingerir rótulos do Ground Truth e mesclá-los com predições O monitoramento da qualidade do modelo compara as predições que seu modelo faz com rótulos de veracidade para medir a qualidade do modelo. Para que isso funcione, você rotula periodicamente os dados capturados pelo seu trabalho de transformação em lote ou endpoint e os carrega no Amazon S3. Para combinar os rótulos do Ground Truth com os dados de predição capturados, deve haver um identificador exclusivo para cada registro no conjunto de dados. A estrutura de cada registro para dados de veracidade é a seguinte: ``` { "groundTruthData": { "data": "1", "encoding": "CSV" }, "eventMetadata": { "eventId": "aaaa-bbbb-cccc" }, "eventVersion": "0" } ``` Na estrutura `groundTruthData`, `eventId` pode ser uma das seguintes opções: + `eventId`: Esse ID é gerado automaticamente quando um usuário invoca o endpoint. + `inferenceId`: O chamador fornece esse ID ao invocar o endpoint. Se `inferenceId` estiver presente nos registros de dados capturados, o Model Monitor o usará para mesclar os dados capturados com os registros do Ground Truth. Você é responsável por garantir que os registros `inferenceId` do Ground Truth correspondam aos `inferenceId` dos registros capturados. Se `inferenceId` estiver presente nos dados capturados, o Model Monitor usará `eventId` dos registros de dados capturados paca combiná-los com o registro do Ground Truth. Você deve fazer o upload dos dados do Ground Truth em um bucket do Amazon S3 que tenha o mesmo formato de caminho dos dados capturados. **Requisitos de formato de dados** Quando você salva seus dados no Amazon S3, eles devem usar o formato “jsonlines” (.jsonl) e ser salvos usando a seguinte estrutura de nomenclatura: Para saber mais sobre os requisitos do jsonline, consulte [Usar dados de entrada e saída](sms-data.md). ``` s3://amzn-s3-demo-bucket1/prefix/yyyy/mm/dd/hh ``` A data nesse caminho é a data em que o rótulo do Ground Truth é coletado e não precisa corresponder à data em que a inferência foi gerada. Depois de criar e carregar os rótulos do Ground Truth, inclua a localização dos rótulos como parâmetro ao criar o trabalho de monitoramento. Se você estiver usando AWS SDK para Python (Boto3), faça isso especificando a localização dos rótulos do Ground Truth como o `S3Uri` campo do `GroundTruthS3Input` parâmetro em uma chamada para o `create_model_quality_job_definition` método. Se você estiver usando o SDK do SageMaker Python, especifique a localização dos rótulos do Ground Truth como `ground_truth_input` parâmetro na chamada para o objeto`create_monitoring_schedule`. `ModelQualityMonitor` # Métricas de qualidade do modelo e CloudWatch monitoramento da Amazon Os trabalhos de monitoramento da qualidade do modelo calculam métricas diferentes para avaliar a qualidade e o desempenho de seus modelos de machine learning. As métricas específicas calculadas dependem do tipo de problema de ML: regressão, classificação binária ou classificação multiclasse. O monitoramento dessas métricas é crucial para detectar o desvio do modelo ao longo do tempo. As seções a seguir abordam as principais métricas de qualidade do modelo para cada tipo de problema, além de como configurar o monitoramento e os alertas automatizados CloudWatch para monitorar continuamente o desempenho do seu modelo. **nota** O desvio padrão para métricas é fornecido somente quando pelo menos 200 amostras estão disponíveis. O Model Monitor calcula o desvio padrão amostrando aleatoriamente 80% dos dados 5 vezes, calculando a métrica e tirando o desvio padrão para esses resultados. ## Métricas de regressão Veja a seguir um exemplo das métricas que o monitor de qualidade do modelo calcula para um problema de regressão. ``` "regression_metrics" : { "mae" : { "value" : 0.3711832061068702, "standard_deviation" : 0.0037566388129940394 }, "mse" : { "value" : 0.3711832061068702, "standard_deviation" : 0.0037566388129940524 }, "rmse" : { "value" : 0.609248066149471, "standard_deviation" : 0.003079253267651125 }, "r2" : { "value" : -1.3766111872212665, "standard_deviation" : 0.022653980022771227 } } ``` ## Métricas de classificação binária Veja a seguir um exemplo das métricas que o monitor de qualidade do modelo calcula para um problema de classificação binária. ``` "binary_classification_metrics" : { "confusion_matrix" : { "0" : { "0" : 1, "1" : 2 }, "1" : { "0" : 0, "1" : 1 } }, "recall" : { "value" : 1.0, "standard_deviation" : "NaN" }, "precision" : { "value" : 0.3333333333333333, "standard_deviation" : "NaN" }, "accuracy" : { "value" : 0.5, "standard_deviation" : "NaN" }, "recall_best_constant_classifier" : { "value" : 1.0, "standard_deviation" : "NaN" }, "precision_best_constant_classifier" : { "value" : 0.25, "standard_deviation" : "NaN" }, "accuracy_best_constant_classifier" : { "value" : 0.25, "standard_deviation" : "NaN" }, "true_positive_rate" : { "value" : 1.0, "standard_deviation" : "NaN" }, "true_negative_rate" : { "value" : 0.33333333333333337, "standard_deviation" : "NaN" }, "false_positive_rate" : { "value" : 0.6666666666666666, "standard_deviation" : "NaN" }, "false_negative_rate" : { "value" : 0.0, "standard_deviation" : "NaN" }, "receiver_operating_characteristic_curve" : { "false_positive_rates" : [ 0.0, 0.0, 0.0, 0.0, 0.0, 1.0 ], "true_positive_rates" : [ 0.0, 0.25, 0.5, 0.75, 1.0, 1.0 ] }, "precision_recall_curve" : { "precisions" : [ 1.0, 1.0, 1.0, 1.0, 1.0 ], "recalls" : [ 0.0, 0.25, 0.5, 0.75, 1.0 ] }, "auc" : { "value" : 1.0, "standard_deviation" : "NaN" }, "f0_5" : { "value" : 0.3846153846153846, "standard_deviation" : "NaN" }, "f1" : { "value" : 0.5, "standard_deviation" : "NaN" }, "f2" : { "value" : 0.7142857142857143, "standard_deviation" : "NaN" }, "f0_5_best_constant_classifier" : { "value" : 0.29411764705882354, "standard_deviation" : "NaN" }, "f1_best_constant_classifier" : { "value" : 0.4, "standard_deviation" : "NaN" }, "f2_best_constant_classifier" : { "value" : 0.625, "standard_deviation" : "NaN" } } ``` ## Métricas de várias classes Veja a seguir um exemplo das métricas que o monitor de qualidade do modelo calcula para um problema de classificação de várias classes. ``` "multiclass_classification_metrics" : { "confusion_matrix" : { "0" : { "0" : 1180, "1" : 510 }, "1" : { "0" : 268, "1" : 138 } }, "accuracy" : { "value" : 0.6288167938931297, "standard_deviation" : 0.00375663881299405 }, "weighted_recall" : { "value" : 0.6288167938931297, "standard_deviation" : 0.003756638812994008 }, "weighted_precision" : { "value" : 0.6983172269629505, "standard_deviation" : 0.006195912915307507 }, "weighted_f0_5" : { "value" : 0.6803947317178771, "standard_deviation" : 0.005328406973561699 }, "weighted_f1" : { "value" : 0.6571162346664904, "standard_deviation" : 0.004385008075019733 }, "weighted_f2" : { "value" : 0.6384024354394601, "standard_deviation" : 0.003867109755267757 }, "accuracy_best_constant_classifier" : { "value" : 0.19370229007633588, "standard_deviation" : 0.0032049848450732355 }, "weighted_recall_best_constant_classifier" : { "value" : 0.19370229007633588, "standard_deviation" : 0.0032049848450732355 }, "weighted_precision_best_constant_classifier" : { "value" : 0.03752057718081697, "standard_deviation" : 0.001241536088657851 }, "weighted_f0_5_best_constant_classifier" : { "value" : 0.04473443104152011, "standard_deviation" : 0.0014460485504284792 }, "weighted_f1_best_constant_classifier" : { "value" : 0.06286421244683643, "standard_deviation" : 0.0019113576884608862 }, "weighted_f2_best_constant_classifier" : { "value" : 0.10570313141262414, "standard_deviation" : 0.002734216826748117 } } ``` ## Monitorando as métricas de qualidade do modelo com CloudWatch Se você definir o valor de `enable_cloudwatch_metrics` to `True` ao criar o cronograma de monitoramento, os trabalhos de monitoramento de qualidade do modelo enviarão todas as métricas para CloudWatch. As métricas de qualidade do modelo aparecem no seguinte namespace: + Para endpoints em tempo real: `aws/sagemaker/Endpoints/model-metrics` + Criar trabalhos de transformação de lotes: `aws/sagemaker/ModelMonitoring/model-metrics` Para obter uma lista das métricas emitidas, consulte as seções anteriores desta página. Você pode usar CloudWatch métricas para criar um alarme quando uma métrica específica não atinge o limite especificado. Para obter instruções sobre como criar CloudWatch alarmes, consulte [Criar um CloudWatch alarme com base em um limite estático no Guia](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ConsoleAlarms.html) do *CloudWatch usuário*. # Desvio de polarização para modelos em produção O monitoramento de viés do Amazon SageMaker Clarify ajuda cientistas de dados e engenheiros de ML a monitorar regularmente as previsões de viés. À medida que o modelo é monitorado, os clientes podem visualizar relatórios e gráficos exportáveis detalhando o viés no SageMaker Studio e configurar alertas na Amazon CloudWatch para receber notificações se um viés além de um determinado limite for detectado. O desvio pode ser introduzido ou exacerbado nos modelos de ML implantados quando os dados de treinamento são diferentes dos dados que o modelo vê durante a implantação (ou seja, os dados dinâmicos). Esses tipos de mudanças na distribuição de dados dinâmicos podem ser temporários (por exemplo, devido a alguns eventos reais de curta duração) ou permanentes. Em ambos os casos, pode ser importante detectar essas alterações. Por exemplo, os resultados de um modelo para prever preços de casas podem se tornar tendenciosos se as taxas de hipoteca usadas para treinar o modelo diferirem das taxas de hipoteca atuais do mundo real. Com os recursos de detecção de viés no Model Monitor, quando a SageMaker IA detecta um viés além de um determinado limite, ela gera automaticamente métricas que você pode visualizar no SageMaker Studio e por meio de alertas da Amazon CloudWatch. Em geral, medir o viés somente durante a train-and-deploy fase pode não ser suficiente. É possível que, após a implantação do modelo, a distribuição dos dados que o modelo implantado vê (ou seja, os dados dinâmicos) seja diferente da distribuição de dados no conjunto de dados de treinamento. Essa mudança pode introduzir desvios em um modelo ao longo do tempo. A mudança na distribuição de dados dinâmicos pode ser temporária (por exemplo, devido a algum comportamento de curta duração, como as festas de fim de ano) ou permanente. Em ambos os casos, pode ser importante detectar essas mudanças e tomar medidas para reduzir o desvio, quando apropriado. Para detectar essas mudanças, o SageMaker Clarify fornece funcionalidade para monitorar continuamente as métricas de viés de um modelo implantado e gerar alertas automatizados se as métricas excederem um limite. Por exemplo, considere a métrica de desvio da DPPL. Especifique um intervalo permitido de valores A = (amin​, amax​), por exemplo, um intervalo de (-0,1, 0,1), ao qual a DPPL deve pertencer durante a implantação. Qualquer desvio desse intervalo deve gerar um alerta de *desvio detectado*. Com o SageMaker Clarify, você pode realizar essas verificações em intervalos regulares. Por exemplo, você pode definir a frequência das verificações para 2 dias. Isso significa que o SageMaker Clarify calcula a métrica DPPL nos dados coletados durante uma janela de 2 dias. Neste exemplo, Dwin são os dados que o modelo processou durante a última janela de 2 dias. Um alerta será emitido se o valor da DPPL bwin​ calculado em Dwin​ estiver fora de um intervalo permitido A. Essa abordagem para verificar se bwin está fora de A pode ser um pouco ruidosa. Dwin​ pode consistir em muito poucas amostras e pode não ser representativo da distribuição de dados dinâmicos. O pequeno tamanho da amostra significa que o valor do desvio bwin​ calculado sobre Dwin​ pode não ser uma estimativa muito robusta. Na verdade, valores muito altos (ou baixos) de bwin podem ser observados puramente por acaso. Para garantir que as conclusões tiradas dos dados D observados win sejam estatisticamente significativas, o SageMaker Clarify faz uso de intervalos de confiança. Especificamente, ele usa o método Normal Bootstrap Interval para construir um intervalo C= (cmin, cmax) de forma que SageMaker Clarify tenha certeza de que o verdadeiro valor de polarização calculado sobre os dados ativos completos está contido em C com alta probabilidade. Agora, se o intervalo de confiança C se sobrepor ao intervalo permitido A, SageMaker Clarify o interpreta como “é provável que o valor da métrica de viés da distribuição de dados ao vivo esteja dentro do intervalo permitido”. Se C e A forem disjuntos, o SageMaker Clarify tem certeza de que a métrica de viés não está em A e gera um alerta. ## Caderno de exemplo do Model Monitor O Amazon SageMaker Clarify fornece o seguinte exemplo de caderno que mostra como capturar dados de inferência para um endpoint em tempo real, criar uma linha de base para monitorar a evolução do preconceito e inspecionar os resultados: + [Monitorando o desvio de viés e o desvio de atribuição de recursos Amazon Clarify SageMaker — Use o Amazon](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_model_monitor/fairness_and_explainability/SageMaker-Model-Monitor-Fairness-and-Explainability.html) SageMaker Model Monitor para monitorar o desvio de viés e o desvio de atribuição de recursos ao longo do tempo. Este notebook foi verificado para ser executado somente no Amazon SageMaker Studio. Se você precisar de instruções sobre como abrir um notebook no Amazon SageMaker Studio, consulte[Crie ou abra um notebook Amazon SageMaker Studio Classic](notebooks-create-open.md). Caso seja solicitado que você escolha um kernel, escolha **Python 3 (Ciência de dados)**. Os tópicos a seguir contêm os destaques das duas últimas etapas e contêm exemplos de código do caderno de exemplo. **Topics** + [Caderno de exemplo do Model Monitor](#clarify-model-monitor-sample-notebooks-bias-drift) + [Criar uma linha de base de desvio de polarização](clarify-model-monitor-bias-drift-baseline.md) + [Violações do desvio de polarização](clarify-model-monitor-bias-drift-violations.md) + [Parâmetros para monitorar o desvio de polarização](clarify-config-json-monitor-bias-parameters.md) + [Programar trabalhos de monitoramento de desvio de polarização](clarify-model-monitor-bias-drift-schedule.md) + [Inspecionar relatórios para detectar desvios de polarização de dados](clarify-model-monitor-bias-drift-report.md) + [CloudWatch Métricas para análise de desvio de polarização](clarify-model-monitor-bias-drift-cw.md) # Criar uma linha de base de desvio de polarização Depois de configurar sua aplicação para capturar dados de inferência em tempo real ou de transformação em lote, a primeira tarefa para monitorar o desvio de polarização é criar uma linha de base. Isso envolve configurar as entradas de dados, quais grupos são confidenciais, como as predições são capturadas e o modelo e suas métricas de desvio pós-treinamento. Em seguida, você precisa iniciar o trabalho de linha de base. O monitor de desvio de modelo pode detectar o desvio de polarização dos modelos de ML regularmente. Semelhante aos outros tipos de monitoramento, o procedimento padrão para criar um modelo de monitor de polarização é primeiro estabelecer uma linha de base e, em seguida, estabelecer uma programação de monitoramento. ``` model_bias_monitor = ModelBiasMonitor( role=role, sagemaker_session=sagemaker_session, max_runtime_in_seconds=1800, ) ``` O `DataConfig` armazena informações sobre o conjunto de dados a ser analisado (por exemplo, o arquivo do conjunto de dados), seu formato (ou seja, linhas CSV ou JSON), cabeçalhos (se houver) e rótulo. ``` model_bias_baselining_job_result_uri = f"{baseline_results_uri}/model_bias" model_bias_data_config = DataConfig( s3_data_input_path=validation_dataset, s3_output_path=model_bias_baselining_job_result_uri, label=label_header, headers=all_headers, dataset_type=dataset_type, ) ``` A `BiasConfig` é a configuração dos grupos confidenciais no conjunto de dados. Normalmente, o desvio é medido computando uma métrica e comparando-a entre grupos. O grupo de interesse é chamado de *faceta*. Para o desvio pós-treinamento, você também deve levar em consideração o rótulo positivo. ``` model_bias_config = BiasConfig( label_values_or_threshold=[1], facet_name="Account Length", facet_values_or_threshold=[100], ) ``` A `ModelPredictedLabelConfig` especifica como extrair um rótulo previsto da saída do modelo. Neste exemplo, o limite de 0,8 foi escolhido com a expectativa de rotatividade de clientes com frequência. Para saídas mais complicadas, há mais algumas opções, como “rótulo” é o índice, nome ou JMESPath localização do rótulo previsto na carga útil de resposta do endpoint. ``` model_predicted_label_config = ModelPredictedLabelConfig( probability_threshold=0.8, ) ``` A `ModelConfig` é a configuração relacionada ao modelo a ser usado para inferência. Para calcular as métricas de desvio pós-treinamento, o cálculo precisa obter inferências para o nome do modelo fornecido. Para fazer isso, o trabalho de processamento usa o modelo para criar um endpoint efêmero (também conhecido como *endpoint de sombra*). O trabalho de processamento exclui o endpoint de sombra após a conclusão dos cálculos. Essa configuração também é usada pelo monitor de explicabilidade. ``` model_config = ModelConfig( model_name=model_name, instance_count=endpoint_instance_count, instance_type=endpoint_instance_type, content_type=dataset_type, accept_type=dataset_type, ) ``` Agora você pode iniciar o trabalho de definição de linha de base. ``` model_bias_monitor.suggest_baseline( model_config=model_config, data_config=model_bias_data_config, bias_config=model_bias_config, model_predicted_label_config=model_predicted_label_config, ) print(f"ModelBiasMonitor baselining job: {model_bias_monitor.latest_baselining_job_name}") ``` O monitor programado pega automaticamente o nome do trabalho de linha de base e o aguarda antes do início do monitoramento. # Violações do desvio de polarização Os trabalhos de desvio de polarização avaliam as restrições da linha de base fornecidas pela [configuração da linha de base](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelBiasJobDefinition.html#sagemaker-CreateModelBiasJobDefinition-request-ModelBiasBaselineConfig) em relação aos resultados da análise da `MonitoringExecution` atual. Se forem detectadas violações, o trabalho as listará no arquivo *constraint\$1violations.json* no local de saída de execução e marcará o status da execução como [Interpretar resultados](model-monitor-interpreting-results.md). Aqui está o esquema do arquivo de violações do desvio de polarização. + `facet`: O nome da faceta, fornecido pela faceta de configuração da análise de trabalhos de monitoramento `name_or_index`. + `facet_value`: O valor da faceta, fornecido pela faceta de configuração da análise de trabalhos de monitoramento `value_or_threshold`. + `metric_name`: O nome abreviado da métrica de desvio. Por exemplo, “CI” para desequilíbrio de classes. Consulte [Métricas de desvio pré-treinamento](clarify-measure-data-bias.md) para obter os nomes abreviados de cada uma das métricas de desvio pré-treinamento e [Métricas de dados pós-treinamento e desvio do modelo](clarify-measure-post-training-bias.md) para os nomes abreviados de cada uma das métricas de desvio pós-treinamento. + `constraint_check_type`: O tipo de violação monitorada. No momento, somente `bias_drift_check` é compatível. + `description`: Uma mensagem descritiva para explicar a violação. ``` { "version": "1.0", "violations": [{ "facet": "string", "facet_value": "string", "metric_name": "string", "constraint_check_type": "string", "description": "string" }] } ``` Uma métrica de desvio é usada para medir o nível de igualdade em uma distribuição. Um valor próximo de zero indica que a distribuição está mais equilibrada. Se o valor de uma métrica de desvio no arquivo de resultados da análise do trabalho (analysis.json) for pior do que o valor correspondente no arquivo de restrições da linha de base, uma violação será registrada. Por exemplo, se a restrição da linha de base para a métrica de desvio da DPPL for `0.2` e o resultado da análise for `0.1`, nenhuma violação será registrada porque `0.1` está mais próximo de `0` que `0.2`. No entanto, se o resultado da análise for `-0.3`, uma violação será registrada porque está mais longe de `0` do que a restrição da linha de base de `0.2`. ``` { "version": "1.0", "violations": [{ "facet": "Age", "facet_value": "40", "metric_name": "CI", "constraint_check_type": "bias_drift_check", "description": "Value 0.0751544567666083 does not meet the constraint requirement" }, { "facet": "Age", "facet_value": "40", "metric_name": "DPPL", "constraint_check_type": "bias_drift_check", "description": "Value -0.0791244970125596 does not meet the constraint requirement" }] } ``` # Parâmetros para monitorar o desvio de polarização O monitoramento de viés do Amazon SageMaker Clarify reutiliza um subconjunto dos parâmetros usados na configuração de análise do. [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md) Depois de descrever os parâmetros de configuração, este tópico fornece exemplos de arquivos JSON. Esses arquivos são usados para configurar conjuntos de dados de linhas CSV e JSON para monitorá-los quanto a desvios de polarização quando os modelos de machine learning estão em produção. Os parâmetros a seguir devem ser fornecidos em um arquivo JSON. O caminho para esse arquivo JSON deve ser fornecido no parâmetro `ConfigUri` da API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelBiasAppSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelBiasAppSpecification). + `"version"`: (Opcional) Versão do esquema do arquivo de configuração. Se não for fornecida, a versão compatível mais recente será usada. + `"headers"`: (Opcional) Uma lista de nomes de colunas no conjunto de dados. Se o `dataset_type` for `"application/jsonlines"` e `"label"` for especificado, o último cabeçalho se tornará o cabeçalho da coluna do rótulo. + `"label"`: (Opcional) Atributo destino para o modelo a ser usado para *métricas de desvio*. Especificado como nome de coluna ou índice (se o formato do conjunto de dados for CSV) ou como JMESPath (se o formato do conjunto de dados for Linhas JSON). + `"label_values_or_threshold"`: (Opcional) Lista de limites ou valores do rótulo. Indica o resultado positivo usado para métricas de desvio. + `"facet"`: (Opcional) Uma lista atributos confidenciais, chamados de facetas. As facetas são usadas para *métricas de desvio* na forma de pares e incluem o seguinte: + `"name_or_index"`: Nome ou índice da coluna de faceta. + `"value_or_threshold"`: (Opcional) Lista de valores ou limites que a coluna de faceta pode assumir. Indica o grupo confidencial, como o grupo usado para medir o desvio. Se não forem fornecidas, as métricas de desvio serão calculadas como um grupo para cada valor exclusivo (em vez de todos os valores). Se a coluna da faceta for numérica, esse valor limite será aplicado como limite inferior para selecionar o grupo confidencial. + `"group_variable"`: (Opcional) Um nome de coluna ou índice para indicar a variável de grupo a ser usada para a *métrica de desvio* de Disparidade *demográfica condicional*. Os outros parâmetros devem ser fornecidos em `EndpointInput` (para endpoints em tempo real) ou `BatchTransformInput` (para trabalhos de transformação de lotes) da API de [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelBiasJobInput](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelBiasJobInput). + `FeaturesAttribute`: Esse parâmetro é obrigatório se o formato de dados de entrada do endpoint for `"application/jsonlines"`. Ele é JMESPath usado para localizar as colunas de recursos se o formato do conjunto de dados for JSON Lines. + `InferenceAttribute`— Índice ou JMESPath localização na saída do modelo para o atributo alvo a ser usado para monitorar o viés usando métricas de viés. Se não for fornecido no caso CSV `accept_type`, presume-se que a saída do modelo seja um único valor numérico correspondente a uma pontuação ou probabilidade. + `ProbabilityAttribute`— Índice ou JMESPath localização na saída do modelo para probabilidades. Se a saída do modelo for linhas JSON com uma lista de rótulos e probabilidades, por exemplo, o rótulo que corresponde à probabilidade máxima será selecionado para cálculos de desvio. + `ProbabilityThresholdAttribute`: (Opcional) Um valor flutuante para indicar o limite para selecionar o rótulo binário, no caso de classificação binária. O valor padrão é 0,5. ## Exemplos de arquivos de configuração JSON para conjuntos de dados CSV e linhas JSON Veja alguns exemplos dos arquivos JSON usados para configurar conjuntos de dados CSV e linhas JSON para monitorá-los quanto ao desvio de polarização. **Topics** + [Conjuntos de dados de CSV](#clarify-config-json-monitor-bias-parameters-example-csv) + [Conjuntos de dados de linhas JSON](#clarify-config-json-monitor-bias-parameters-example-jsonlines) ### Conjuntos de dados de CSV Considere um conjunto de dados que tenha quatro colunas de atributos e uma coluna de rótulo, em que o primeiro atributo e o rótulo sejam binários, como no exemplo a seguir. ``` 0, 0.5814568701544718, 0.6651538910132964, 0.3138080342665499, 0 1, 0.6711642728531724, 0.7466687034026017, 0.1215477472819713, 1 0, 0.0453256543003371, 0.6377430803264152, 0.3558625219713576, 1 1, 0.4785191813363956, 0.0265841045263860, 0.0376935084990697, 1 ``` Suponha que a saída do modelo tenha duas colunas, onde a primeira é o rótulo previsto e a segunda é a probabilidade, como no exemplo a seguir. ``` 1, 0.5385257417814224 ``` Em seguida, o arquivo de configuração JSON a seguir mostra um exemplo de como esse conjunto de dados CSV pode ser configurado. ``` { "headers": [ "feature_0", "feature_1", "feature_2", "feature_3", "target" ], "label": "target", "label_values_or_threshold": [1], "facet": [{ "name_or_index": "feature_1", "value_or_threshold": [1] }] } ``` O rótulo previsto é selecionado pelo parâmetro `"InferenceAttribute"`. A numeração baseada em zero é usada, então 0 indica a primeira coluna da saída do modelo. ``` "EndpointInput": { ... "InferenceAttribute": 0 ... } ``` Como alternativa, você pode usar parâmetros diferentes para converter valores de probabilidade em rótulos de previsão binários. A numeração baseada em zero é usada: 1 indica a segunda coluna; o valor de `ProbabilityThresholdAttribute` de 0,6 indica que uma probabilidade maior que 0,6 prevê o rótulo binário como 1. ``` "EndpointInput": { ... "ProbabilityAttribute": 1, "ProbabilityThresholdAttribute": 0.6 ... } ``` ### Conjuntos de dados de linhas JSON Considere um conjunto de dados que tenha quatro colunas de atributos e uma coluna de rótulo, em que o primeiro atributo e o rótulo sejam binários, como no exemplo a seguir. ``` {"features":[0, 0.5814568701544718, 0.6651538910132964, 0.3138080342665499], "label":0} {"features":[1, 0.6711642728531724, 0.7466687034026017, 0.1215477472819713], "label":1} {"features":[0, 0.0453256543003371, 0.6377430803264152, 0.3558625219713576], "label":1} {"features":[1, 0.4785191813363956, 0.0265841045263860, 0.0376935084990697], "label":1} ``` Suponha que a saída do modelo tenha duas colunas, onde a primeira é o rótulo previsto e a segunda é a probabilidade. ``` {"predicted_label":1, "probability":0.5385257417814224} ``` Em seguida, o arquivo de configuração JSON a seguir mostra um exemplo de como esse conjunto de dados de linhas JSON pode ser configurado. ``` { "headers": [ "feature_0", "feature_1", "feature_2", "feature_3", "target" ], "label": "label", "label_values_or_threshold": [1], "facet": [{ "name_or_index": "feature_1", "value_or_threshold": [1] }] } ``` Em seguida, o valor do parâmetro `"features"` em `EndpointInput` (para endpoints em tempo real) ou `BatchTransformInput` (para trabalhos de transformação de lotes) é usado para localizar os atributos no conjunto de dados, e o valor do parâmetro `"predicted_label"` seleciona o rótulo previsto na saída do modelo. ``` "EndpointInput": { ... "FeaturesAttribute": "features", "InferenceAttribute": "predicted_label" ... } ``` Como alternativa, você pode converter valores de probabilidade em rótulos de previsão binários usando o valor de parâmetro `ProbabilityThresholdAttribute`. Um valor de 0,6, por exemplo, indica que uma probabilidade maior que 0,6 prediz o rótulo binário como 1. ``` "EndpointInput": { ... "FeaturesAttribute": "features", "ProbabilityAttribute": "probability", "ProbabilityThresholdAttribute": 0.6 ... } ``` # Programar trabalhos de monitoramento de desvio de polarização Depois de criar sua linha de base, você pode chamar o método `create_monitoring_schedule()` da sua instância de classe `ModelBiasModelMonitor` para programar um monitor horário de qualidade do desvio de polarização. As seções a seguir mostram como criar um monitor de desvio de polarização para um modelo implantado em um endpoint em tempo real, bem como para um trabalho de transformação em lotes. **Importante** Você pode especificar uma entrada de transformação em lote ou uma entrada de endpoint, mas não ambas, ao criar sua programação de monitoramento. Ao contrário do monitoramento da qualidade dos dados, você precisa fornecer rótulos do Ground Truth se quiser monitorar a qualidade do modelo. No entanto, os rótulos do Ground Truth podem ser adiados. Para resolver isso, especifique compensações ao criar sua programação de monitoramento. Para obter detalhes sobre como criar deslocamentos de tempo, consulte [Deslocamentos do monitor do modelo](model-monitor-model-quality-schedule.md#model-monitor-model-quality-schedule-offsets). Se você enviou um trabalho de linha de base, o monitor seleciona automaticamente a configuração de análise do trabalho de linha de base. Se você pular a etapa de definição de linha de base ou se o conjunto de dados de captura tiver uma natureza diferente da do conjunto de dados de treinamento, você deverá fornecer a configuração da análise. ## Monitoramento do desvio de polarização para modelos implantados em endpoints em tempo real Para programar um monitor de desvio de polarização para um endpoint em tempo real, transmita sua instância `EndpointInput` para o argumento `endpoint_input` de sua instância `ModelBiasModelMonitor`, conforme mostrado no seguinte exemplo de código: ``` from sagemaker.model_monitor import CronExpressionGenerator model_bias_monitor = ModelBiasModelMonitor( role=sagemaker.get_execution_role(), ... ) model_bias_analysis_config = None if not model_bias_monitor.latest_baselining_job: model_bias_analysis_config = BiasAnalysisConfig( model_bias_config, headers=all_headers, label=label_header, ) model_bias_monitor.create_monitoring_schedule( monitor_schedule_name=schedule_name, post_analytics_processor_script=s3_code_postprocessor_uri, output_s3_uri=s3_report_path, statistics=model_bias_monitor.baseline_statistics(), constraints=model_bias_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, analysis_config=model_bias_analysis_config, endpoint_input=EndpointInput( endpoint_name=endpoint_name, destination="/opt/ml/processing/input/endpoint", start_time_offset="-PT1H", end_time_offset="-PT0H", probability_threshold_attribute=0.8, ), ) ``` ## Monitoramento de desvio de polarização para trabalhos de transformação de lotes Para programar um monitor de desvio de polarização para um trabalho de transformação de Lotes, transmita sua instância `BatchTransformInput` para o argumento `batch_transform_input` de sua instância `ModelBiasModelMonitor`, conforme mostrado no seguinte exemplo de código: ``` from sagemaker.model_monitor import CronExpressionGenerator model_bias_monitor = ModelBiasModelMonitor( role=sagemaker.get_execution_role(), ... ) model_bias_analysis_config = None if not model_bias_monitor.latest_baselining_job: model_bias_analysis_config = BiasAnalysisConfig( model_bias_config, headers=all_headers, label=label_header, ) schedule = model_bias_monitor.create_monitoring_schedule( monitor_schedule_name=schedule_name, post_analytics_processor_script=s3_code_postprocessor_uri, output_s3_uri=s3_report_path, statistics=model_bias_monitor.baseline_statistics(), constraints=model_bias_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, analysis_config=model_bias_analysis_config, batch_transform_input=BatchTransformInput( destination="opt/ml/processing/input", data_captured_destination_s3_uri=s3_capture_path, start_time_offset="-PT1H", end_time_offset="-PT0H", probability_threshold_attribute=0.8 ), ) ``` # Inspecionar relatórios para detectar desvios de polarização de dados Se você não conseguir inspecionar os resultados do monitoramento nos relatórios gerados no SageMaker Studio, poderá imprimi-los da seguinte forma: ``` schedule_desc = model_bias_monitor.describe_schedule() execution_summary = schedule_desc.get("LastMonitoringExecutionSummary") if execution_summary and execution_summary["MonitoringExecutionStatus"] in ["Completed", "CompletedWithViolations"]: last_model_bias_monitor_execution = model_bias_monitor.list_executions()[-1] last_model_bias_monitor_execution_report_uri = last_model_bias_monitor_execution.output.destination print(f'Report URI: {last_model_bias_monitor_execution_report_uri}') last_model_bias_monitor_execution_report_files = sorted(S3Downloader.list(last_model_bias_monitor_execution_report_uri)) print("Found Report Files:") print("\n ".join(last_model_bias_monitor_execution_report_files)) else: last_model_bias_monitor_execution = None print("====STOP==== \n No completed executions to inspect further. Please wait till an execution completes or investigate previously reported failures.") ``` Se houver violações em comparação com a linha de base, elas serão listadas aqui: ``` if last_model_bias_monitor_execution: model_bias_violations = last_model_bias_monitor_execution.constraint_violations() if model_bias_violations: print(model_bias_violations.body_dict) ``` Se seu modelo for implantado em um endpoint em tempo real, você poderá ver visualizações no SageMaker AI Studio dos resultados e CloudWatch métricas da análise escolhendo a guia **Endpoints e clicando duas vezes no endpoint**. # CloudWatch Métricas para análise de desvio de polarização Este guia mostra CloudWatch métricas e suas propriedades que você pode usar para análise de desvio de viés no SageMaker Clarify. As tarefas de monitoramento de desvios de polarização calculam tanto as métricas de [viés antes do treinamento quanto as métricas](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-measure-data-bias.html) de [viés pós-treinamento e as](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-measure-post-training-bias.html) publicam no seguinte namespace: CloudWatch + Para endpoints em tempo real: `aws/sagemaker/Endpoints/bias-metrics` + Criar trabalhos de transformação de lotes: `aws/sagemaker/ModelMonitoring/bias-metrics` O nome da CloudWatch métrica acrescenta o nome abreviado da métrica a. `bias_metric` Por exemplo, `bias_metric_CI` é a métrica de desvio para desequilíbrio de classes (CI). **nota** O `+/- infinity` é publicado como o número de ponto flutuante `+/- 2.348543e108` e os erros, incluindo valores nulos, não são publicados. Cada métrica tem as seguintes propriedades: + `Endpoint`: o nome do endpoint monitorado, se aplicável. + `MonitoringSchedule` O nome da programação para o trabalho de monitoramento. + `BiasStage`: o nome do estágio do trabalho de monitoramento do desvio de polarização. Escolha `Pre-training` ou `Post-Training`. + `Label`: o nome do atributo de destino, fornecido pelo `label` de configuração de análise do trabalho de monitoramento. + `LabelValue`: o valor do atributo de destino, fornecido pelo `label_values_or_threshold` de configuração de análise do trabalho de monitoramento. + `Facet`: o nome da faceta, fornecido pelo `name_of_index` da faceta de configuração da análise do trabalho de monitoramento. + `FacetValue`: o valor da faceta, fornecido pelo `nvalue_or_threshold` da faceta de configuração da análise do trabalho de monitoramento. Para impedir que os trabalhos de monitoramento publiquem métricas, defina `publish_cloudwatch_metrics` como `Disabled` no mapa `Environment` da definição de [trabalhos de desvio de modelo](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelBiasJobDefinition.html). # Desvio de atribuição de atributos para modelos em produção Um desvio na distribuição de dados dinâmicos para modelos em produção pode resultar em um desvio correspondente nos valores de atribuição do atributo, assim como pode causar uma oscilação no desvio ao monitorar as métricas de desvio. O monitoramento de atribuição de recursos do Amazon SageMaker Clarify ajuda cientistas de dados e engenheiros de ML a monitorar regularmente as previsões de variações na atribuição de recursos. À medida que o modelo é monitorado, os clientes podem visualizar relatórios e gráficos exportáveis detalhando as atribuições de recursos no SageMaker Studio e configurar alertas na Amazon CloudWatch para receber notificações se for detectado que os valores de atribuição ultrapassam um determinado limite. Para ilustrar isso com uma situação específica, considere um cenário hipotético de admissões a faculdades. Suponha que observemos os seguintes valores (agregados) de atribuição de valores de atributos nos dados de treinamento e nos dados dinâmicos: Cenário hipotético de admissão à faculdade | Recurso | Atribuição nos dados de treinamento | Atribuição em dados dinâmicos | | --- | --- | --- | | Pontuação SAT | 0,70 | 0.10 | | GPA | 0.50 | 0.20 | | Classificação da classe | 0,05 | 0,70 | A mudança dos dados de treinamento para os dados dinâmicos parece significativa. A classificação de atributos foi completamente revertida. Semelhante ao desvio de polarização, os desvios de atribuição de atributos podem ser causados por uma mudança na distribuição de dados dinâmicos e justificam uma análise mais detalhada do comportamento do modelo nos dados dinâmicos. Novamente, a primeira etapa nesses cenários é disparar um alarme de ocorrência de desvio. Podemos detectar o desvio comparando como a classificação dos atributos individuais mudou dos dados de treinamento para os dados dinâmicos. Além de sermos sensíveis às mudanças na ordem de classificação, também queremos ser sensíveis à pontuação bruta de atribuição dos atributos. Por exemplo, considerando dois atributos que se enquadram na classificação pelo mesmo número de posições, do treinamento aos dados dinâmicos, queremos ser mais sensíveis ao atributo que teve uma pontuação de atribuição mais alta nos dados de treinamento. Com essas propriedades em mente, usamos a pontuação de ganho cumulativo com desconto normalizado (NDCG) para comparar as classificações de atribuições de atributos de treinamento e os dados dinâmicos. Especificamente, suponha que temos o seguinte: + *F= [f1, ..., fm]* é a lista de atributos classificados com relação às pontuações de atribuição nos dados de treinamento, onde *m* é o número total de atributos. Por exemplo, no nosso caso, *F* = [Pontuação SAT, GPA, Classificação]. + *a(f)* é uma função que retorna a pontuação de atribuição do atributo nos dados de treinamento, dado um atributo *f*. Por exemplo, *a*(Pontuação SAT) = 0,70. + *F′= [f′1, ..., f′m]* é a lista de atributos classificados com relação às pontuações de atribuição nos dados dinâmicos. Por exemplo, *F*′ = [Classificação, GPA, Pontuação SAT]. Então, podemos calcular o NDCG como:         NDCG = DCG/iDCG sendo + DCG = ∑1m*a*(*f'i*)/log2​(*i*\$11) + iDCG = ∑1m*a*(*fi*)/log2​(*i*\$11) A quantidade DCG mede se os atributos com alta atribuição nos dados de treinamento também têm uma classificação mais alta na atribuição de atributos calculada nos dados dinâmicos. A quantidade iDCG mede a *pontuação ideal* e é apenas um fator de normalização para garantir que a quantidade final resida na faixa [0, 1], com 1 sendo o melhor valor possível. Um valor NDCG de 1 significa que a classificação de atribuição do atributo nos dados dinâmicos é a mesma que a dos dados de treinamento. Neste exemplo específico, como a classificação mudou bastante, o valor do NDCG é 0,69. No SageMaker Clarify, se o valor do NDCG estiver abaixo de 0,90, emitimos automaticamente um alerta. ## Caderno de exemplo do Model Monitor SageMaker O Clarify fornece o seguinte exemplo de caderno que mostra como capturar dados de inferência para um endpoint em tempo real, criar uma linha de base para monitorar a evolução do viés e inspecionar os resultados: + [Monitorando o desvio de viés e o desvio de atribuição de recursos Amazon Clarify SageMaker — Use o Amazon](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_model_monitor/fairness_and_explainability/SageMaker-Model-Monitor-Fairness-and-Explainability.html) SageMaker Model Monitor para monitorar o desvio de viés e o desvio de atribuição de recursos ao longo do tempo. Este notebook foi verificado para ser executado somente no SageMaker Studio. Se você precisar de instruções sobre como abrir um notebook no SageMaker Studio, consulte[Crie ou abra um notebook Amazon SageMaker Studio Classic](notebooks-create-open.md). Caso seja solicitado que você escolha um kernel, escolha **Python 3 (Ciência de dados)**. Os tópicos a seguir contêm os destaques das duas últimas etapas e contêm exemplos de código do caderno de exemplo. **Topics** + [Caderno de exemplo do Model Monitor](#clarify-model-monitor-sample-notebooks-feature-drift) + [Criar uma linha de base do SHAP para modelos em produção](clarify-model-monitor-shap-baseline.md) + [Violações do desvio de atribuição de atributos do modelo](clarify-model-monitor-model-attribution-drift-violations.md) + [Parâmetros para monitorar o desvio de atribuição](clarify-config-json-monitor-model-explainability-parameters.md) + [Programar trabalhos de monitoramento de desvio de atribuição de atributos](clarify-model-monitor-feature-attribute-drift-schedule.md) + [Inspecionar relatórios de desvio de atribuição de atributos em modelos de produção](clarify-feature-attribute-drift-report.md) + [CloudWatch Métricas para análise de desvio de recursos](clarify-feature-attribute-drift-cw.md) # Criar uma linha de base do SHAP para modelos em produção As explicações são tipicamente contrastivas, ou seja, elas explicam os desvios de uma linha de base. Para obter informações sobre linhas de base de explicabilidade, consulte [Linhas de base do SHAP para explicabilidade](clarify-feature-attribute-shap-baselines.md). Além de fornecer explicações para inferências por instância, o SageMaker Clarify também oferece suporte à explicação global para modelos de ML que ajudam você a entender o comportamento de um modelo como um todo em termos de seus recursos. SageMaker O Clarify gera uma explicação global de um modelo de ML agregando os valores de Shapley em várias instâncias. SageMaker O Clarify oferece suporte às seguintes formas diferentes de agregação, que você pode usar para definir linhas de base: + `mean_abs`: Média dos valores SHAP absolutos para todas as instâncias. + `median`: Média dos valores SHAP para todas as instâncias. + `mean_sq`: Média dos valores SHAP quadráticos para todas as instâncias. Depois de configurar sua aplicação para capturar dados de inferência em tempo real ou de transformação de lotes, a primeira tarefa para monitorar o desvio da atribuição de atributos é criar uma linha de base para comparação. Isso envolve configurar as entradas de dados, quais grupos são confidenciais, como as predições são capturadas e o modelo e suas métricas de desvio pós-treinamento. Em seguida, você precisa iniciar o trabalho de linha de base. O monitor de explicabilidade do modelo pode explicar as predições de um modelo implantado que está produzindo inferências e detectar desvios na atribuição de atributos regularmente. ``` model_explainability_monitor = ModelExplainabilityMonitor( role=role, sagemaker_session=sagemaker_session, max_runtime_in_seconds=1800, ) ``` Neste exemplo, o trabalho de linha de base de explicabilidade compartilha o conjunto de dados de teste com o trabalho de linha de base de desvio, então ele usa o mesmo `DataConfig` e a única diferença é o URI de saída do trabalho. ``` model_explainability_baselining_job_result_uri = f"{baseline_results_uri}/model_explainability" model_explainability_data_config = DataConfig( s3_data_input_path=validation_dataset, s3_output_path=model_explainability_baselining_job_result_uri, label=label_header, headers=all_headers, dataset_type=dataset_type, ) ``` Atualmente, o SageMaker explicador do Clarify oferece uma implementação escalável e eficiente do SHAP, portanto, a configuração de explicabilidade inclui o seguinte: SHAPConfig + `baseline`: Uma lista de linhas (pelo menos uma) ou URI do objeto S3 a ser usada como conjunto de dados de linha de base no algoritmo SHAP do Kernel. O formato deve ser igual ao formato do conjunto de dados. Cada linha deve conter somente o recurso columns/values e omitir a coluna/valores do rótulo. + `num_samples`: Número de amostras a serem usadas no algoritmo SHAP do Kernel. Esse número determina o tamanho do conjunto de dados sintético gerado para calcular os valores SHAP. + agg\$1method: Método de agregação para valores globais de SHAP. Estes são valores válidos: + `mean_abs`: Média dos valores SHAP absolutos para todas as instâncias. + `median`: Média dos valores SHAP para todas as instâncias. + `mean_sq`: Média dos valores SHAP quadráticos para todas as instâncias. + `use_logit`: Indicador de se a função logit deve ser aplicada às predições de modelo. O padrão é `False`. Se o `use_logit` for `True`, os valores SHAP terão unidades logarítmicas de probabilidades. + `save_local_shap_values` (bool): Indicador de se os valores SHAP locais devem ser salvos no local de saída. O padrão é `False`. ``` # Here use the mean value of test dataset as SHAP baseline test_dataframe = pd.read_csv(test_dataset, header=None) shap_baseline = [list(test_dataframe.mean())] shap_config = SHAPConfig( baseline=shap_baseline, num_samples=100, agg_method="mean_abs", save_local_shap_values=False, ) ``` Inicie um trabalho de linha de base. A mesma `model_config` é necessária porque o trabalho de definição de base de explicabilidade precisa criar um endpoint de sombra para obter predições para o conjunto de dados sintéticos gerado. ``` model_explainability_monitor.suggest_baseline( data_config=model_explainability_data_config, model_config=model_config, explainability_config=shap_config, ) print(f"ModelExplainabilityMonitor baselining job: {model_explainability_monitor.latest_baselining_job_name}") ``` # Violações do desvio de atribuição de atributos do modelo Os trabalhos de desvio de atribuição de atributos avaliam as restrições da linha de base fornecidas pela [configuração da linha de base](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelExplainabilityJobDefinition.html#sagemaker-CreateModelExplainabilityJobDefinition-request-ModelExplainabilityBaselineConfig) em relação aos resultados da análise da `MonitoringExecution` atual. Se forem detectadas violações, o trabalho as listará no arquivo *constraint\$1violations.json* no local de saída de execução e marcará o status da execução como [Interpretar resultados](model-monitor-interpreting-results.md). Aqui está o esquema do arquivo de violações do desvio de atribuição de atributos. + `label`: O nome do rótulo, `label_headers` da configuração da análise do trabalho ou um espaço reservado, como `"label0"`. + `metric_name`: O nome do método de análise de explicabilidade. No momento, somente `shap` é compatível. + `constraint_check_type`: O tipo de violação monitorada. No momento, somente `feature_attribution_drift_check` é compatível. + `description`: Uma mensagem descritiva para explicar a violação. ``` { "version": "1.0", "violations": [{ "label": "string", "metric_name": "string", "constraint_check_type": "string", "description": "string" }] } ``` Para cada rótulo na seção `explanations`, os trabalhos de monitoramento calculam a [pontuação nDCG](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.ndcg_score.html) de seus valores globais de SHAP no arquivo de restrições da linha de base e no arquivo de resultados da análise do trabalho (*analysis.json*). Se a pontuação for menor que 0,9, uma violação será registrada. O valor global combinado do SHAP é avaliado, portanto, não há campos `“feature”` na entrada da violação. A saída a seguir fornece um exemplo de várias violações registradas. ``` { "version": "1.0", "violations": [{ "label": "label0", "metric_name": "shap", "constraint_check_type": "feature_attribution_drift_check", "description": "Feature attribution drift 0.7639720923277322 exceeds threshold 0.9" }, { "label": "label1", "metric_name": "shap", "constraint_check_type": "feature_attribution_drift_check", "description": "Feature attribution drift 0.7323763972092327 exceeds threshold 0.9" }] } ``` # Parâmetros para monitorar o desvio de atribuição O monitor de SageMaker explicabilidade Amazon Clarify reutiliza um subconjunto dos parâmetros usados na configuração de análise do. [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md) Os parâmetros a seguir devem ser fornecidos em um arquivo JSON e o caminho deve ser fornecido no parâmetro `ConfigUri` de [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelExplainabilityAppSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelExplainabilityAppSpecification). + `"version"`: (Opcional) Versão do esquema do arquivo de configuração. Se não for fornecida, a versão compatível mais recente será usada. + `"headers"`: (Opcional) Uma lista de nomes de atributos no conjunto de dados. A análise de explicabilidade não exige rótulos. + `"methods"`: Uma lista de métodos e seus parâmetros para as análises e relatórios. Se alguma seção for omitida, ela não será computada. + `"shap"`: (Opcional) Seção sobre o cálculo do valor SHAP. + `"baseline"`: (Opcional) Uma lista de linhas (pelo menos uma) ou um URI de objeto do Amazon Simple Storage Service Amazon S3. Para ser usado como conjunto de dados de linha de base (também conhecido como conjunto de dados em segundo plano) no algoritmo SHAP do Kernel. O formato deve ser igual ao formato do conjunto de dados. Cada linha deve conter somente as colunas (ou valores) dos atributos. Antes de enviar cada linha para o modelo, omita qualquer coluna que deva ser excluída. + `"num_samples"`: Número de amostras a serem usadas no algoritmo SHAP do Kernel. Esse número determina o tamanho do conjunto de dados sintético gerado para calcular os valores SHAP. Se não for fornecido, um trabalho do SageMaker Clarify escolherá o valor com base em uma contagem de recursos. + `"agg_method"`: Método de agregação para valores globais de SHAP. Os valores válidos são os seguintes: + `"mean_abs"`: Média dos valores SHAP absolutos para todas as instâncias. + `"median"`: Média dos valores SHAP para todas as instâncias. + `"mean_sq"`: Média dos valores SHAP quadráticos para todas as instâncias. + `"use_logit"`: (Opcional) Valor boleano para indicar se a função logit deve ser aplicada às predições de modelo. Se o `"use_logit"` for `true`, então os valores SHAP têm unidades logarítmicas de probabilidades. O valor padrão é `false`. + `"save_local_shap_values"`: (Opcional) Valor boleano para indicar se os valores SHAP locais devem ser salvos no local de saída. Use `true` para salvá-los. Use `false` para não salvá-los. O padrão é `false`. + `"predictor"`: (Opcional para endpoint em tempo real, necessária para transformação de lotes) Seção sobre parâmetros do modelo, necessária se as seções `"shap"` e `"post_training_bias"` estiverem presentes. + `"model_name"`: Nome do modelo criado pela `CreateModel` API, com o modo de contêiner como `SingleModel`. + `"instance_type"`: Tipo de instância para o endpoint de sombra. + `"initial_instance_count"`: Contagem de instância para o endpoint de sombra. + `"content_type"`: (Opcional) O formato de entrada do modelo a ser usado para obter inferências com o endpoint de sombra. Os valores válidos são `"text/csv"` para CSV, `"application/jsonlines"` para linhas JSON, `application/x-parquet` para Apache Parquet e `application/x-image` para permitir a explicabilidade do Computer Vision. O valor padrão é o mesmo do formato `dataset_type`. + `"accept_type"`: (Opcional) O formato de *saída* do modelo a ser usado para obter inferências com o endpoint de sombra. Os valores válidos são `"text/csv"` para CSV, `"application/jsonlines"` para linhas JSON. Se omitido, o SageMaker Clarify usa o tipo de dados de resposta dos dados capturados. + `"content_template"`: (Opcional) Uma string de modelo usada para construir a entrada do modelo a partir de instâncias do conjunto de dados. Usado apenas quando o `"content_type"` for `"application/jsonlines"`. O modelo deve ter apenas um espaço reservado, `$features`, que é substituído pela lista de atributos em runtime. Por exemplo, em um dado `"content_template":"{\"myfeatures\":$features}"`, se uma instância (sem rótulo) for `1,2,3`, a entrada do modelo se tornará linhas JSON `'{"myfeatures":[1,2,3]}'`. + `"label_headers"`: (Opcional) Uma lista de valores que o `"label"` assumem no conjunto de dados. Associa as pontuações retornadas pelo endpoint do modelo ou pelo trabalho de transformação de lotes aos valores de rótulo correspondentes. Se for fornecido, o relatório de análise usará os cabeçalhos em vez de espaços reservados, como `“label0”`. Os outros parâmetros devem ser fornecidos em `EndpointInput` (para endpoints em tempo real) ou `BatchTransformInput` (para trabalhos de transformação de lotes) da API de [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelExplainabilityJobInput](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelExplainabilityJobInput). + `FeaturesAttribute`: Esse parâmetro é obrigatório se o formato de dados de entrada do endpoint ou do trabalho em lotes for `"application/jsonlines"`. Ele é JMESPath usado para localizar as colunas de recursos se o formato do conjunto de dados for JSON Lines. + `ProbabilityAttribute`— Índice ou JMESPath localização na saída do modelo para probabilidades. Se a saída do modelo for linhas JSON com uma lista de rótulos e probabilidades, por exemplo, o rótulo que corresponde à probabilidade máxima será selecionado para cálculos de desvio. ## Exemplos de arquivos de configuração JSON para conjuntos de dados CSV e linhas JSON Veja alguns exemplos dos arquivos JSON usados para configurar conjuntos de dados CSV e linhas JSON para monitorá-los quanto ao desvio de atribuição de atributos. **Topics** + [Conjuntos de dados de CSV](#clarify-config-json-monitor-model-explainability-parameters-example-csv) + [Conjuntos de dados de linhas JSON](#clarify-config-json-monitor-model-explainability-parameters-example-jsonlines) ### Conjuntos de dados de CSV Considere um conjunto de dados que tenha três colunas de atributos numéricos, como no exemplo a seguir. ``` 0.5814568701544718, 0.6651538910132964, 0.3138080342665499 0.6711642728531724, 0.7466687034026017, 0.1215477472819713 0.0453256543003371, 0.6377430803264152, 0.3558625219713576 0.4785191813363956, 0.0265841045263860, 0.0376935084990697 ``` Suponha que a saída do modelo tenha duas colunas, onde a primeira é o rótulo previsto e a segunda é a probabilidade, como no exemplo a seguir. ``` 1, 0.5385257417814224 ``` O arquivo de exemplo de configuração JSON a seguir mostra como esse conjunto de dados CSV pode ser configurado. ``` { "headers": [ "feature_1", "feature_2", "feature_3" ], "methods": { "shap": { "baseline": [ [0.4441164946610942, 0.5190374448171748, 0.20722795300473712] ], "num_samples": 100, "agg_method": "mean_abs" } }, "predictor": { "model_name": "my_model", "instance_type": "ml.m5.xlarge", "initial_instance_count": 1 } } ``` O rótulo previsto é selecionado pelo parâmetro `"ProbabilityAttribute"`. A numeração baseada em zero é usada, então 1 indica a segunda coluna da saída do modelo. ``` "EndpointInput": { ... "ProbabilityAttribute": 1 ... } ``` ### Conjuntos de dados de linhas JSON Considere um conjunto de dados que tenha quatro colunas de atributos e uma coluna de rótulo, em que o primeiro atributo e o rótulo sejam binários, como no exemplo a seguir. ``` {"features":[0, 0.5814568701544718, 0.6651538910132964, 0.3138080342665499], "label":0} {"features":[1, 0.6711642728531724, 0.7466687034026017, 0.1215477472819713], "label":1} {"features":[0, 0.0453256543003371, 0.6377430803264152, 0.3558625219713576], "label":1} {"features":[1, 0.4785191813363956, 0.0265841045263860, 0.0376935084990697], "label":1} ``` A entrada do modelo é igual ao formato do conjunto de dados, e a saída do modelo são linhas JSON, como no exemplo a seguir. ``` {"predicted_label":1, "probability":0.5385257417814224} ``` No exemplo a seguir, o arquivo de configuração JSON mostra como esse conjunto de dados de linhas JSON pode ser configurado. ``` { "headers": [ "feature_1", "feature_2", "feature_3" ], "methods": { "shap": { "baseline": [ {"features":[0.4441164946610942, 0.5190374448171748, 0.20722795300473712]} ], "num_samples": 100, "agg_method": "mean_abs" } }, "predictor": { "model_name": "my_model", "instance_type": "ml.m5.xlarge", "initial_instance_count": 1, "content_template":"{\"features\":$features}" } } ``` Então, o valor do parâmetro `"features"` em `EndpointInput` (para endpoints em tempo real) ou `BatchTransformInput` (para trabalhos de transformação de lotes) é usado para localizar os atributos no conjunto de dados, e o valor do parâmetro `"probability"` seleciona o valor de probabilidade na saída do modelo. ``` "EndpointInput": { ... "FeaturesAttribute": "features", "ProbabilityAttribute": "probability", ... } ``` # Programar trabalhos de monitoramento de desvio de atribuição de atributos Depois de criar sua linha de base SHAP, você pode chamar o método `create_monitoring_schedule()` da sua instância de classe `ModelExplainabilityMonitor` para programar um monitor horário de explicabilidade do modelo. As seções a seguir mostram como criar um monitor de explicabilidade do modelo para um modelo implantado em um endpoint em tempo real, bem como para um trabalho de transformação de lotes. **Importante** Você pode especificar uma entrada de transformação em lote ou uma entrada de endpoint, mas não ambas, ao criar sua programação de monitoramento. Se um trabalho de linha de base foi apresentado, o monitor seleciona automaticamente a configuração de análise do trabalho de linha de base. No entanto, se você pular a etapa de definição de linha de base ou se o conjunto de dados de captura tiver uma natureza diferente da do conjunto de dados de treinamento, você precisará fornecer a configuração da análise. A `ModelConfig` é exigida pela `ExplainabilityAnalysisConfig` pelo mesmo motivo que é exigida para o trabalho de linha de base. Observe que somente atributos são necessários para calcular a atribuição de atributos, portanto, você deve excluir o rótulo do Ground Truth. ## Monitoramento do desvio de atribuição de atributos para modelos implantados em endpoints em tempo real Para programar um monitor de explicabilidade do modelo para um endpoint em tempo real, transmita sua instância `EndpointInput` para o argumento `endpoint_input` de sua instância `ModelExplainabilityMonitor`, conforme mostrado no seguinte exemplo de código: ``` from sagemaker.model_monitor import CronExpressionGenerator model_exp_model_monitor = ModelExplainabilityMonitor( role=sagemaker.get_execution_role(), ... ) schedule = model_exp_model_monitor.create_monitoring_schedule( monitor_schedule_name=schedule_name, post_analytics_processor_script=s3_code_postprocessor_uri, output_s3_uri=s3_report_path, statistics=model_exp_model_monitor.baseline_statistics(), constraints=model_exp_model_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, endpoint_input=EndpointInput( endpoint_name=endpoint_name, destination="/opt/ml/processing/input/endpoint", ) ) ``` ## Monitoramento de desvio de atribuição de atributos para trabalhos de transformação de lotes Para programar um monitor de explicabilidade do modelo para um trabalho de transformação de lotes, transmita sua instância `BatchTransformInput` para o argumento `batch_transform_input` de sua instância `ModelExplainabilityMonitor`, conforme mostrado no seguinte exemplo de código: ``` from sagemaker.model_monitor import CronExpressionGenerator model_exp_model_monitor = ModelExplainabilityMonitor( role=sagemaker.get_execution_role(), ... ) schedule = model_exp_model_monitor.create_monitoring_schedule( monitor_schedule_name=schedule_name, post_analytics_processor_script=s3_code_postprocessor_uri, output_s3_uri=s3_report_path, statistics=model_exp_model_monitor.baseline_statistics(), constraints=model_exp_model_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, batch_transform_input=BatchTransformInput( destination="opt/ml/processing/data", model_name="batch-fraud-detection-model", input_manifests_s3_uri="s3://amzn-s3-demo-bucket/batch-fraud-detection/on-schedule-monitoring/in/", excludeFeatures="0", ) ) ``` # Inspecionar relatórios de desvio de atribuição de atributos em modelos de produção Depois que a programação configurada for iniciada por padrão, você precisará aguardar o início da primeira execução e, em seguida, interromper a programação para evitar cobranças. Para inspecionar os relatórios, siga os seguintes códigos: ``` schedule_desc = model_explainability_monitor.describe_schedule() execution_summary = schedule_desc.get("LastMonitoringExecutionSummary") if execution_summary and execution_summary["MonitoringExecutionStatus"] in ["Completed", "CompletedWithViolations"]: last_model_explainability_monitor_execution = model_explainability_monitor.list_executions()[-1] last_model_explainability_monitor_execution_report_uri = last_model_explainability_monitor_execution.output.destination print(f'Report URI: {last_model_explainability_monitor_execution_report_uri}') last_model_explainability_monitor_execution_report_files = sorted(S3Downloader.list(last_model_explainability_monitor_execution_report_uri)) print("Found Report Files:") print("\n ".join(last_model_explainability_monitor_execution_report_files)) else: last_model_explainability_monitor_execution = None print("====STOP==== \n No completed executions to inspect further. Please wait till an execution completes or investigate previously reported failures.") ``` Se houver quaisquer violações em comparação com a linha de base, elas serão listadas aqui: ``` if last_model_explainability_monitor_execution: model_explainability_violations = last_model_explainability_monitor_execution.constraint_violations() if model_explainability_violations: print(model_explainability_violations.body_dict) ``` Se seu modelo for implantado em um endpoint em tempo real, você poderá ver visualizações no SageMaker Studio dos resultados e CloudWatch métricas da análise escolhendo a guia **Endpoints e clicando duas vezes no endpoint**. # CloudWatch Métricas para análise de desvio de recursos Este guia mostra CloudWatch métricas e suas propriedades que você pode usar para análise de desvio de atributos de recursos no SageMaker Clarify. Os trabalhos de monitoramento de desvio de atributos de atributos calculam e publicam dois tipos de métricas: + O valor global do SHAP de cada atributo. **nota** O nome dessa métrica acrescenta o nome do atributo fornecido pela configuração da análise de trabalhos para `feature_`. Por exemplo, `feature_X` é o valor global do SHAP para o atributo `X`. + O `ExpectedValue` da métrica. Essas métricas são publicadas no seguinte CloudWatch namespace: + Para endpoints em tempo real: `aws/sagemaker/Endpoints/explainability-metrics` + Criar trabalhos de transformação de lotes: `aws/sagemaker/ModelMonitoring/explainability-metrics` Cada métrica tem as seguintes propriedades: + `Endpoint`: o nome do endpoint monitorado, se aplicável. + `MonitoringSchedule`: o nome da programação para o trabalho de monitoramento. + `ExplainabilityMethod`: o método usado para calcular os valores de Shapley. Selecione `KernelShap`. + `Label`: o nome fornecido pela configuração `label_headers` da análise de trabalhos ou um espaço reservado como `label0`. + `ValueType`: o tipo do valor retornado pela métrica. Escolha `GlobalShapValues` ou `ExpectedValue`. Para impedir que os trabalhos de monitoramento publiquem métricas, defina `publish_cloudwatch_metrics` como `Disabled` no mapa `Environment` da definição de [trabalhos de explicabilidade de modelo](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelExplainabilityJobDefinition.html). # Programar trabalhos de monitoramento O Amazon SageMaker Model Monitor oferece a capacidade de monitorar os dados coletados de seus endpoints em tempo real. Você pode monitorar seus dados em uma programação recorrente ou pode monitorá-los uma vez, imediatamente. Você pode criar uma programação de monitoramento com a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateMonitoringSchedule.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateMonitoringSchedule.html). Com um cronograma de monitoramento, a SageMaker IA pode começar a processar trabalhos para analisar os dados coletados durante um determinado período. No trabalho de processamento, a SageMaker IA compara o conjunto de dados da análise atual com as estatísticas e restrições básicas que você fornece. Em seguida, a SageMaker IA gera um relatório de violações. Além disso, CloudWatch métricas são emitidas para cada recurso em análise. SageMaker A IA fornece um contêiner pré-construído para realizar análises em conjuntos de dados tabulares. Se preferir, você pode optar por trazer seu próprio contêiner conforme descrito no tópico [Support para seus próprios contêineres com o Amazon SageMaker Model Monitor](model-monitor-byoc-containers.md). Você pode criar uma programação de monitoramento de modelo para seu trabalho de transformação de lotes ou endpoint em tempo real. Use os recursos da linha de base (restrições e estatísticas) para comparar com o tráfego em tempo real ou com as entradas de trabalhos em lotes. **Example atribuições de linha de base** No exemplo a seguir, o conjunto de dados de treinamento usado para treinar o modelo foi carregado no Amazon S3. Se ele já tiver no Amazon S3, você poderá apontar diretamente para ele. ``` # copy over the training dataset to Amazon S3 (if you already have it in Amazon S3, you could reuse it) baseline_prefix = prefix + '/baselining' baseline_data_prefix = baseline_prefix + '/data' baseline_results_prefix = baseline_prefix + '/results' baseline_data_uri = 's3://{}/{}'.format(bucket,baseline_data_prefix) baseline_results_uri = 's3://{}/{}'.format(bucket, baseline_results_prefix) print('Baseline data uri: {}'.format(baseline_data_uri)) print('Baseline results uri: {}'.format(baseline_results_uri)) ``` ``` training_data_file = open("test_data/training-dataset-with-header.csv", 'rb') s3_key = os.path.join(baseline_prefix, 'data', 'training-dataset-with-header.csv') boto3.Session().resource('s3').Bucket(bucket).Object(s3_key).upload_fileobj(training_data_file) ``` **Example programação para análises recorrentes** Se você estiver programando um monitor de modelo para o endpoint em tempo real, use as estatísticas e as restrições de linha de base para comparar com o tráfego em tempo real. O trecho de código a seguir mostra o formato geral que você usa para programar um monitor de modelo para um endpoint em tempo real. Este exemplo programa o monitor do modelo para ser executado de hora em hora. ``` from sagemaker.model_monitor import CronExpressionGenerator from time import gmtime, strftime mon_schedule_name = 'my-model-monitor-schedule-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) my_default_monitor.create_monitoring_schedule( monitor_schedule_name=mon_schedule_name, endpoint_input=EndpointInput( endpoint_name=endpoint_name, destination="/opt/ml/processing/input/endpoint" ), post_analytics_processor_script=s3_code_postprocessor_uri, output_s3_uri=s3_report_path, statistics=my_default_monitor.baseline_statistics(), constraints=my_default_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, ) ``` **Example programação para análise única** Você também pode programar a análise para ser executada uma vez sem repetição, transmitindo argumentos como os seguintes para o método `create_monitoring_schedule`: ``` schedule_cron_expression=CronExpressionGenerator.now(), data_analysis_start_time="-PT1H", data_analysis_end_time="-PT0H", ``` Nesses argumentos, o parâmetro `schedule_cron_expression` programa a análise para ser executada uma vez, imediatamente, com o valor `CronExpressionGenerator.now()`. Para qualquer programação com essa configuração, os parâmetros `data_analysis_start_time` e `data_analysis_end_time` são obrigatórios. Esses parâmetros definem a hora de início e a hora de término de uma janela de análise. Defina esses horários como deslocamentos relativos à hora atual e use o formato de duração ISO 8601. Neste exemplo, os horários `-PT1H` e `-PT0H` definem uma janela entre uma hora no passado e a hora atual. Com essa programação, a análise avalia somente os dados que foram coletados durante a janela especificada. **Example programação para um trabalho de transformação de lotes** O trecho de código a seguir mostra o formato geral que você usa para programar um monitor de modelo para um trabalho de transformação de lotes. ``` from sagemaker.model_monitor import ( CronExpressionGenerator, BatchTransformInput, MonitoringDatasetFormat, ) from time import gmtime, strftime mon_schedule_name = 'my-model-monitor-schedule-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) my_default_monitor.create_monitoring_schedule( monitor_schedule_name=mon_schedule_name, batch_transform_input=BatchTransformInput( destination="opt/ml/processing/input", data_captured_destination_s3_uri=s3_capture_upload_path, dataset_format=MonitoringDatasetFormat.csv(header=False), ), post_analytics_processor_script=s3_code_postprocessor_uri, output_s3_uri=s3_report_path, statistics=my_default_monitor.baseline_statistics(), constraints=my_default_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, ) ``` ``` desc_schedule_result = my_default_monitor.describe_schedule() print('Schedule status: {}'.format(desc_schedule_result['MonitoringScheduleStatus'])) ``` # A expressão cron para monitorar a programação Para fornecer detalhes para a programação de monitoramento, use [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ScheduleConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ScheduleConfig.html), que é uma expressão `cron` que descreve detalhes sobre a programação de monitoramento. O Amazon SageMaker Model Monitor suporta as seguintes `cron` expressões: + Para definir o trabalho para começar a cada hora, use o seguinte: `Hourly: cron(0 * ? * * *)` + Para executar o trabalho diariamente, use o seguinte: `cron(0 [00-23] ? * * *)` + Para executar o trabalho uma vez, imediatamente, use a seguinte palavra-chave: `NOW` Por exemplo, as seguintes expressões `cron` são válidas: + Diariamente às 12:00 UTC: `cron(0 12 ? * * *)` + Diariamente às 00:00 UTC: `cron(0 0 ? * * *)` Para oferecer compatibilidade com a execução a cada 6, 12 horas, o Model Monitoring é compatível com a seguinte expressão: `cron(0 [00-23]/[01-24] ? * * *)` Por exemplo, as seguintes expressões `cron` são válidas: + A cada 12 horas, a partir das 17:00 UTC: `cron(0 17/12 ? * * *)` + A cada duas horas, a partir das 00:00 UTC: `cron(0 0/2 ? * * *)` **Observações** Embora a expressão `cron` esteja definida para iniciar às 17:00 UTC, observe que pode haver um atraso de 0 a 20 minutos do tempo real solicitado para executar a execução. Se você quiser executar em uma programação diária, não forneça esse parâmetro. SageMaker A IA escolhe um horário para correr todos os dias. Atualmente, a SageMaker IA suporta apenas taxas inteiras por hora entre 1 hora e 24 horas. # Configuração de políticas de controle de serviços para programações de monitoramento Você precisa especificar os parâmetros de um trabalho de monitoramento ao criar ou atualizar um agendamento para ele com a [CreateMonitoringSchedule](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateMonitoringSchedule.html)API ou a [UpdateMonitoringSchedule](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateMonitoringSchedule.html)API, respectivamente. Dependendo do seu caso de uso, você pode fazer isso de uma das seguintes maneiras: + Você pode especificar o [MonitoringJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_MonitoringJobDefinition.html)campo de [MonitoringScheduleConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_MonitoringScheduleConfig.html), ao invocar `CreateMonitoringSchedule` ou`UpdateMonitoringSchedule`. Você pode usar isso somente para criar ou atualizar uma programação para um trabalho de monitoramento da qualidade de dados. + Você pode especificar o nome de uma definição de trabalho de monitoramento que você já criou para o campo `MonitoringJobDefinitionName` de `MonitoringScheduleConfig`, ao invocar `CreateMonitoringSchedule` ou`UpdateMonitoringSchedule`. Você pode usar isso para qualquer definição de tarefa criada com uma das seguintes opções APIs: + [CreateDataQualityJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateDataQualityJobDefinition.html) + [CreateModelQualityJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelQualityJobDefinition.html) + [CreateModelBiasJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelBiasJobDefinition.html) + [CreateModelExplainabilityJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelExplainabilityJobDefinition.html) Se você quiser usar o SDK do SageMaker Python para criar ou atualizar agendas, precisará usar esse processo. Os processos mencionados acima são mutuamente exclusivos, ou seja, você pode especificar o campo `MonitoringJobDefinition` ou o campo `MonitoringJobDefinitionName` ao criar ou atualizar as programações de monitoramento. Ao criar uma definição de trabalho de monitoramento ou especificar uma no campo `MonitoringJobDefinition`, você pode definir parâmetros de segurança, como `NetworkConfig` e `VolumeKmsKeyId`. Como administrador, talvez você queira que esses parâmetros sejam sempre definidos com determinados valores, para que os trabalhos de monitoramento sempre sejam executados em um ambiente seguro. Para garantir isso, configure [políticas de controle de serviço](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) apropriadas (SCPs). SCPs são um tipo de política organizacional que você pode usar para gerenciar permissões em sua organização. O exemplo a seguir mostra uma SCP que você pode usar para garantir que os parâmetros de infraestrutura sejam definidos adequadamente ao criar ou atualizar programações de trabalhos de monitoramento. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Deny", "Action": [ "sagemaker:CreateDataQualityJobDefinition", "sagemaker:CreateModelBiasJobDefinition", "sagemaker:CreateModelExplainabilityJobDefinition", "sagemaker:CreateModelQualityJobDefinition" ], "Resource": "arn:*:sagemaker:*:*:*", "Condition": { "Null": { "sagemaker:VolumeKmsKey":"true", "sagemaker:VpcSubnets": "true", "sagemaker:VpcSecurityGroupIds": "true" } } }, { "Effect": "Deny", "Action": [ "sagemaker:CreateDataQualityJobDefinition", "sagemaker:CreateModelBiasJobDefinition", "sagemaker:CreateModelExplainabilityJobDefinition", "sagemaker:CreateModelQualityJobDefinition" ], "Resource": "arn:*:sagemaker:*:*:*", "Condition": { "Bool": { "sagemaker:InterContainerTrafficEncryption": "false" } } }, { "Effect": "Deny", "Action": [ "sagemaker:CreateMonitoringSchedule", "sagemaker:UpdateMonitoringSchedule" ], "Resource": "arn:*:sagemaker:*:*:monitoring-schedule/*", "Condition": { "Null": { "sagemaker:ModelMonitorJobDefinitionName": "true" } } } ] } ``` ------ As duas primeiras regras do exemplo garantem que os parâmetros de segurança estejam sempre definidos para monitorar as definições de trabalho. A regra final exige que qualquer pessoa em sua organização que esteja criando ou atualizando uma programação sempre especifique o campo `MonitoringJobDefinitionName`. Isso garante que ninguém em sua organização possa definir valores inseguros para os parâmetros de segurança especificando o campo `MonitoringJobDefinition` ao criar ou atualizar programações. # Contêiner pré-construído Amazon SageMaker Model Monitor SageMaker A IA fornece uma imagem integrada chamada `sagemaker-model-monitor-analyzer` que fornece uma variedade de recursos de monitoramento de modelos, incluindo sugestão de restrições, geração de estatísticas, validação de restrições em relação a uma linha de base e emissão de métricas da Amazon. CloudWatch Essa imagem é baseada na versão 3.3.0 do Spark e foi criada com a versão 2.0.2 do [Deequ](https://github.com/awslabs/deequ). **nota** Você não pode puxar a imagem `sagemaker-model-monitor-analyzer` incorporada diretamente. Você pode usar a `sagemaker-model-monitor-analyzer` imagem ao enviar um trabalho básico de processamento ou monitoramento usando um dos AWS SDKs. Use o SDK do SageMaker Python (consulte `image_uris.retrieve` o [guia de referência do SDK do AI SageMaker Python](https://sagemaker.readthedocs.io/en/stable/api/utility/image_uris.html)) para gerar o URI da imagem do ECR para você ou especifique o URI da imagem do ECR diretamente. A imagem pré-criada do SageMaker Model Monitor pode ser acessada da seguinte forma: `.dkr.ecr..amazonaws.com/sagemaker-model-monitor-analyzer` Por exemplo: `159807026194.dkr.ecr.us-west-2.amazonaws.com/sagemaker-model-monitor-analyzer` Se você estiver em uma AWS região da China, as imagens pré-criadas do SageMaker Model Monitor podem ser acessadas da seguinte forma: `.dkr.ecr..amazonaws.com.rproxy.govskope.us.cn/sagemaker-model-monitor-analyzer` Para nomes de contas IDs e AWS regiões, consulte [Caminhos de registro do Docker e código de exemplo](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths). Para escrever seu próprio contêiner de análise, consulte o contrato de contêiner descrito em [Programações de monitoramento personalizadas](model-monitor-custom-monitoring-schedules.md). # Interpretar resultados Depois de executar um trabalho de processamento de linha de base e obter estatísticas e restrições para o seu conjunto de dados, você poderá executar trabalhos de monitoramento que calculam estatísticas e listam as violações encontradas em relação às restrições de linha de base. CloudWatch As métricas da Amazon também são relatadas em sua conta por padrão. Para obter informações sobre a visualização dos resultados do monitoramento no Amazon SageMaker Studio, consulte[Visualize resultados para endpoints em tempo real no Amazon Studio SageMaker](model-monitor-interpreting-visualize-results.md). ## Execuções de lista A programação inicia trabalhos de monitoramento nos intervalos especificados. O código a seguir lista as cinco últimas execuções. Se você estiver executando esse código depois de criar a programação por hora, as execuções poderão estar vazias e você poderá ter que esperar até cruzar o limite de horas (em UTC) para ver as execuções serem iniciadas. O código a seguir inclui a lógica de espera. ``` mon_executions = my_default_monitor.list_executions() print("We created a hourly schedule above and it will kick off executions ON the hour (plus 0 - 20 min buffer.\nWe will have to wait till we hit the hour...") while len(mon_executions) == 0: print("Waiting for the 1st execution to happen...") time.sleep(60) mon_executions = my_default_monitor.list_executions() ``` ## Inspecionar uma execução específica Na etapa anterior, você selecionou a execução programada concluída ou com falha mais recente. É possível explorar o que deu certo ou errado. Os estados finais são: + `Completed`: A execução do monitoramento foi concluída e nenhum problema foi encontrado no relatório de violações. + `CompletedWithViolations`: A execução foi concluída, mas foram detectadas violações de restrição. + `Failed`: A execução de monitoramento falhou, possivelmente devido a erro do cliente (por exemplo, problemas de função) ou problemas de infraestrutura. Para identificar a causa, consulte `FailureReason` e `ExitMessage`. ``` latest_execution = mon_executions[-1] # latest execution's index is -1, previous is -2 and so on.. time.sleep(60) latest_execution.wait(logs=False) print("Latest execution status: {}".format(latest_execution.describe()['ProcessingJobStatus'])) print("Latest execution result: {}".format(latest_execution.describe()['ExitMessage'])) latest_job = latest_execution.describe() if (latest_job['ProcessingJobStatus'] != 'Completed'): print("====STOP==== \n No completed executions to inspect further. Please wait till an execution completes or investigate previously reported failures.") ``` ``` report_uri=latest_execution.output.destination print('Report Uri: {}'.format(report_uri)) ``` ## Relatórios gerados por listas Use o código a seguir para listar os relatórios gerados. ``` from urllib.parse import urlparse s3uri = urlparse(report_uri) report_bucket = s3uri.netloc report_key = s3uri.path.lstrip('/') print('Report bucket: {}'.format(report_bucket)) print('Report key: {}'.format(report_key)) s3_client = boto3.Session().client('s3') result = s3_client.list_objects(Bucket=report_bucket, Prefix=report_key) report_files = [report_file.get("Key") for report_file in result.get('Contents')] print("Found Report Files:") print("\n ".join(report_files)) ``` ## Relatório de violações Se houver violações comparadas à linha de base, elas serão geradas no relatório de violações. Use o código a seguir para listar as violações. ``` violations = my_default_monitor.latest_monitoring_constraint_violations() pd.set_option('display.max_colwidth', -1) constraints_df = pd.io.json.json_normalize(violations.body_dict["violations"]) constraints_df.head(10) ``` Isso se aplica somente a conjuntos de dados que contêm dados tabulares. Os arquivos de esquema a seguir especificam as estatísticas calculadas e as violações monitoradas. Arquivos de saída para conjuntos de dados tabulares | Nome do arquivo | Description | | --- | --- | | statistics.json | Contém estatísticas colunares para cada atributo no conjunto de dados que é analisado. Consulte o esquema desse arquivo no próximo tópico. Esse arquivo é criado somente para monitoramento da qualidade dos dados. | | constraint\$1violations.json | Contém uma lista de violações encontradas nesse conjunto atual de dados em comparação com o arquivo de estatísticas e restrições de linha de base especificado nos caminhos `baseline_constaints` e `baseline_statistics`. | Por padrão, [Contêiner pré-construído Amazon SageMaker Model Monitor](model-monitor-pre-built-container.md) salva um conjunto de CloudWatch métricas da Amazon para cada recurso. O código do contêiner pode emitir CloudWatch métricas neste local:`/opt/ml/output/metrics/cloudwatch`. # Visualize resultados para endpoints em tempo real no Amazon Studio SageMaker Se você estiver monitorando um endpoint em tempo real, também poderá visualizar os resultados no Amazon SageMaker Studio. Você pode visualizar os detalhes da execução de qualquer trabalho de monitoramento e criar gráficos que mostrem a linha de base e os valores capturados para qualquer métrica calculada pelo trabalho de monitoramento. **Para visualizar os resultados detalhados de um trabalho de monitoramento** 1. Faça login no Studio. Para obter mais informações, consulte [Visão geral do domínio Amazon SageMaker AI](gs-studio-onboard.md). 1. No painel de navegação à esquerda, selecione o ícone de **Componentes e registros** (![\[Orange paper airplane icon representing email or message sending functionality.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/icons/Components_registries.png)). 1. No menu suspenso, escolha **Endpoints**. ![\[Localização do menu suspenso Endpoints no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model_monitor/mm-studio-endpoints.png) 1. Na guia do endpoint, escolha o tipo de monitoramento do qual você deseja ver os detalhes do trabalho. ![\[A localização da guia Qualidade do modelo na seção MONITORAMENTO DE MODELOS.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model_monitor/mm-studio-model-quality.png) 1. Selecione o nome da execução do trabalho de monitoramento cujos detalhes você deseja visualizar na lista de trabalhos de monitoramento. ![\[A guia Qualidade do modelo da seção MONITORAMENTO DE MODELOS.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model_monitor/mm-studio-job-history.png) 1. A guia **DETALHES DO TRABALHO DE MONITORAMENTO** é aberta com um relatório detalhado do trabalho de monitoramento. ![\[A guia DETALHES DO TRABALHO DE MONITORAMENTO.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model_monitor/mm-studio-job-details.png) Você pode criar um gráfico que exiba a linha de base e as métricas capturadas por um período de tempo. **Para criar um gráfico no SageMaker Studio para visualizar os resultados do monitoramento** 1. Faça login no Studio. Para obter mais informações, consulte [Visão geral do domínio Amazon SageMaker AI](gs-studio-onboard.md). 1. No painel de navegação à esquerda, selecione o ícone de **Componentes e registros** (![\[Orange paper airplane icon representing email or message sending functionality.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/icons/Components_registries.png)). 1. No menu suspenso, escolha **Endpoints**. ![\[Localização do menu suspenso Endpoints no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model_monitor/mm-studio-endpoints.png) 1. Na guia **Endpoint**, escolha o tipo de monitoramento para o qual você deseja criar um gráfico. Este exemplo mostra um gráfico para o tipo de monitoramento de **qualidade do modelo**. ![\[A localização da guia Qualidade do modelo na seção MONITORAMENTO DE MODELOS.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model_monitor/mm-studio-model-quality.png) 1. Escolha **Adicionar gráfico**. ![\[Localização de Adicionar gráfico no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model_monitor/mm-studio-add-chart.png) 1. Na guia **PROPRIEDADES DO GRÁFICO**, escolha o período de tempo, a estatística e a métrica que você deseja representar graficamente. Este exemplo mostra um gráfico para uma **Linha do tempo** de **1 semana**, a **estatística** **média** da e a **métrica** **F1**. ![\[Localização de onde selecionar uma métrica no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model_monitor/mm-studio-chart-properties.png) 1. O gráfico que mostra a linha de base e a estatística da métrica atual que você escolheu na etapa anterior aparece na guia **Endpoint**. ![\[Gráfico de exemplo mostrando a linha de base e a métrica média atual escolhida na etapa anterior.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model_monitor/mm-studio-f1-chart.png) # Tópicos avançados As seções a seguir contêm tarefas mais avançadas que explicam como personalizar o monitoramento usando scripts de pré-processamento e pós-processamento, como criar seu próprio contêiner e como usá-lo CloudFormation para criar um cronograma de monitoramento. **Topics** + [Programações de monitoramento personalizadas](model-monitor-custom-monitoring-schedules.md) + [Crie um cronograma de monitoramento para um endpoint em tempo real com um recurso CloudFormation personalizado](model-monitor-cloudformation-monitoring-schedules.md) # Programações de monitoramento personalizadas Além de usar os mecanismos de monitoramento integrados, é possível criar seus próprios agendamentos e procedimentos de monitoramento personalizados usando scripts de pré-processamento e pós-processamento ou usando ou criando seu próprio contêiner. **Topics** + [Pré-processamento e pós-processamento](model-monitor-pre-and-post-processing.md) + [Support para seus próprios contêineres com o Amazon SageMaker Model Monitor](model-monitor-byoc-containers.md) # Pré-processamento e pós-processamento Você pode usar scripts Python personalizados de pré-processamento e pós-processamento para transformar a entrada do seu monitor de modelo ou estender o código após uma execução bem-sucedida do monitoramento. Faça o upload desses scripts para o Amazon S3 e faça referência a eles ao criar seu monitor de modelo. O exemplo a seguir mostra como personalizar as programações de monitoramento com scripts de pré-processamento e pós-processamento. *user placeholder text*Substitua por suas próprias informações. ``` import boto3, os from sagemaker import get_execution_role, Session from sagemaker.model_monitor import CronExpressionGenerator, DefaultModelMonitor # Upload pre and postprocessor scripts session = Session() bucket = boto3.Session().resource("s3").Bucket(session.default_bucket()) prefix = "demo-sagemaker-model-monitor" pre_processor_script = bucket.Object(os.path.join(prefix, "preprocessor.py")).upload_file("preprocessor.py") post_processor_script = bucket.Object(os.path.join(prefix, "postprocessor.py")).upload_file("postprocessor.py") # Get execution role role = get_execution_role() # can be an empty string # Instance type instance_type = "instance-type" # instance_type = "ml.m5.xlarge" # Example # Create a monitoring schedule with pre and postprocessing my_default_monitor = DefaultModelMonitor( role=role, instance_count=1, instance_type=instance_type, volume_size_in_gb=20, max_runtime_in_seconds=3600, ) s3_report_path = "s3://{}/{}".format(bucket, "reports") monitor_schedule_name = "monitor-schedule-name" endpoint_name = "endpoint-name" my_default_monitor.create_monitoring_schedule( post_analytics_processor_script=post_processor_script, record_preprocessor_script=pre_processor_script, monitor_schedule_name=monitor_schedule_name, # use endpoint_input for real-time endpoint endpoint_input=endpoint_name, # or use batch_transform_input for batch transform jobs # batch_transform_input=batch_transform_name, output_s3_uri=s3_report_path, statistics=my_default_monitor.baseline_statistics(), constraints=my_default_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, ) ``` **Topics** + [Script de pré-processamento](#model-monitor-pre-processing-script) + [Amostragem personalizada](#model-monitor-pre-processing-custom-sampling) + [Script de pós-processamento](#model-monitor-post-processing-script) ## Script de pré-processamento Use scripts de pré-processamento quando precisar transformar as entradas do seu monitor do modelo. Por exemplo, suponha que a saída do seu modelo seja uma matriz `[1.0, 2.1]`. O contêiner Amazon SageMaker Model Monitor só funciona com estruturas JSON tabulares ou achatadas, como. `{“prediction0”: 1.0, “prediction1” : 2.1}` Você pode usar um script de pré-processamento como o seguinte para transformar a matriz na estrutura JSON correta: ``` def preprocess_handler(inference_record): input_data = inference_record.endpoint_input.data output_data = inference_record.endpoint_output.data.rstrip("\n") data = output_data + "," + input_data return { str(i).zfill(20) : d for i, d in enumerate(data.split(",")) } ``` Em outro exemplo, suponha que seu modelo tenha atributos opcionais e você use `-1` para indicar que o atributo opcional tem um valor ausente. Se você tiver um monitor de qualidade de dados, talvez queira remover o `-1` da matriz de valores de entrada para que não seja incluído nos cálculos métricos do monitor. Você pode usar um script como o seguinte para remover esses valores: ``` def preprocess_handler(inference_record): input_data = inference_record.endpoint_input.data return {i : None if x == -1 else x for i, x in enumerate(input_data.split(","))} ``` Seu script de pré-processamento recebe um `inference_record` como única entrada. O trecho de código a seguir mostra um exemplo de um `inference_record`. ``` { "captureData": { "endpointInput": { "observedContentType": "text/csv", "mode": "INPUT", "data": "132,25,113.2,96,269.9,107,,0,0,0,0,0,0,1,0,1,0,0,1", "encoding": "CSV" }, "endpointOutput": { "observedContentType": "text/csv; charset=utf-8", "mode": "OUTPUT", "data": "0.01076381653547287", "encoding": "CSV" } }, "eventMetadata": { "eventId": "feca1ab1-8025-47e3-8f6a-99e3fdd7b8d9", "inferenceTime": "2019-11-20T23:33:12Z" }, "eventVersion": "0" } ``` O trecho de código a seguir mostra a estrutura de classe completa de um `inference_record`. ``` KEY_EVENT_METADATA = "eventMetadata" KEY_EVENT_METADATA_EVENT_ID = "eventId" KEY_EVENT_METADATA_EVENT_TIME = "inferenceTime" KEY_EVENT_METADATA_CUSTOM_ATTR = "customAttributes" KEY_EVENTDATA_ENCODING = "encoding" KEY_EVENTDATA_DATA = "data" KEY_GROUND_TRUTH_DATA = "groundTruthData" KEY_EVENTDATA = "captureData" KEY_EVENTDATA_ENDPOINT_INPUT = "endpointInput" KEY_EVENTDATA_ENDPOINT_OUTPUT = "endpointOutput" KEY_EVENTDATA_BATCH_OUTPUT = "batchTransformOutput" KEY_EVENTDATA_OBSERVED_CONTENT_TYPE = "observedContentType" KEY_EVENTDATA_MODE = "mode" KEY_EVENT_VERSION = "eventVersion" class EventConfig: def __init__(self, endpoint, variant, start_time, end_time): self.endpoint = endpoint self.variant = variant self.start_time = start_time self.end_time = end_time class EventMetadata: def __init__(self, event_metadata_dict): self.event_id = event_metadata_dict.get(KEY_EVENT_METADATA_EVENT_ID, None) self.event_time = event_metadata_dict.get(KEY_EVENT_METADATA_EVENT_TIME, None) self.custom_attribute = event_metadata_dict.get(KEY_EVENT_METADATA_CUSTOM_ATTR, None) class EventData: def __init__(self, data_dict): self.encoding = data_dict.get(KEY_EVENTDATA_ENCODING, None) self.data = data_dict.get(KEY_EVENTDATA_DATA, None) self.observedContentType = data_dict.get(KEY_EVENTDATA_OBSERVED_CONTENT_TYPE, None) self.mode = data_dict.get(KEY_EVENTDATA_MODE, None) def as_dict(self): ret = { KEY_EVENTDATA_ENCODING: self.encoding, KEY_EVENTDATA_DATA: self.data, KEY_EVENTDATA_OBSERVED_CONTENT_TYPE: self.observedContentType, } return ret class CapturedData: def __init__(self, event_dict): self.event_metadata = None self.endpoint_input = None self.endpoint_output = None self.batch_transform_output = None self.ground_truth = None self.event_version = None self.event_dict = event_dict self._event_dict_postprocessed = False if KEY_EVENT_METADATA in event_dict: self.event_metadata = EventMetadata(event_dict[KEY_EVENT_METADATA]) if KEY_EVENTDATA in event_dict: if KEY_EVENTDATA_ENDPOINT_INPUT in event_dict[KEY_EVENTDATA]: self.endpoint_input = EventData(event_dict[KEY_EVENTDATA][KEY_EVENTDATA_ENDPOINT_INPUT]) if KEY_EVENTDATA_ENDPOINT_OUTPUT in event_dict[KEY_EVENTDATA]: self.endpoint_output = EventData(event_dict[KEY_EVENTDATA][KEY_EVENTDATA_ENDPOINT_OUTPUT]) if KEY_EVENTDATA_BATCH_OUTPUT in event_dict[KEY_EVENTDATA]: self.batch_transform_output = EventData(event_dict[KEY_EVENTDATA][KEY_EVENTDATA_BATCH_OUTPUT]) if KEY_GROUND_TRUTH_DATA in event_dict: self.ground_truth = EventData(event_dict[KEY_GROUND_TRUTH_DATA]) if KEY_EVENT_VERSION in event_dict: self.event_version = event_dict[KEY_EVENT_VERSION] def as_dict(self): if self._event_dict_postprocessed is True: return self.event_dict if KEY_EVENTDATA in self.event_dict: if KEY_EVENTDATA_ENDPOINT_INPUT in self.event_dict[KEY_EVENTDATA]: self.event_dict[KEY_EVENTDATA][KEY_EVENTDATA_ENDPOINT_INPUT] = self.endpoint_input.as_dict() if KEY_EVENTDATA_ENDPOINT_OUTPUT in self.event_dict[KEY_EVENTDATA]: self.event_dict[KEY_EVENTDATA][ KEY_EVENTDATA_ENDPOINT_OUTPUT ] = self.endpoint_output.as_dict() if KEY_EVENTDATA_BATCH_OUTPUT in self.event_dict[KEY_EVENTDATA]: self.event_dict[KEY_EVENTDATA][KEY_EVENTDATA_BATCH_OUTPUT] = self.batch_transform_output.as_dict() self._event_dict_postprocessed = True return self.event_dict def __str__(self): return str(self.as_dict()) ``` ## Amostragem personalizada Você também pode aplicar uma estratégia de amostragem personalizada em seu script de pré-processamento. Para fazer isso, configure o contêiner pré-criado original do Model Monitor para ignorar uma porcentagem dos registros de acordo com a taxa de amostragem especificada. No exemplo a seguir, o manipulador coleta amostras de 10% dos registros retornando o registro em 10% das chamadas do manipulador e, caso contrário, uma lista vazia. ``` import random def preprocess_handler(inference_record): # we set up a sampling rate of 0.1 if random.random() > 0.1: # return an empty list return [] input_data = inference_record.endpoint_input.data return {i : None if x == -1 else x for i, x in enumerate(input_data.split(","))} ``` ### Registro personalizado para script de pré-processamento Se o script de pré-processamento retornar um erro, verifique as mensagens de exceção registradas CloudWatch para depuração. Você pode acessar o logger por CloudWatch meio da `preprocess_handler` interface. Você pode registrar todas as informações necessárias do seu script em CloudWatch. Isso pode ser útil ao depurar seu script de pré-processamento. O exemplo a seguir mostra como você pode usar a `preprocess_handler` interface para fazer login em CloudWatch ``` def preprocess_handler(inference_record, logger): logger.info(f"I'm a processing record: {inference_record}") logger.debug(f"I'm debugging a processing record: {inference_record}") logger.warning(f"I'm processing record with missing value: {inference_record}") logger.error(f"I'm a processing record with bad value: {inference_record}") return inference_record ``` ## Script de pós-processamento Use um script de pós-processamento quando quiser estender o código após uma execução de monitoramento bem-sucedida. ``` def postprocess_handler(): print("Hello from post-proc script!") ``` # Support para seus próprios contêineres com o Amazon SageMaker Model Monitor O Amazon SageMaker Model Monitor fornece um contêiner pré-construído com a capacidade de analisar os dados capturados de endpoints ou trabalhos de transformação em lote para conjuntos de dados tabulares. Se quiser trazer seu próprio contêiner, o Model Monitor fornecerá pontos de extensão que você pode aproveitar. Dentro do sistema, ao criar um `MonitoringSchedule`, o Model Monitor acaba iniciando trabalhos de processamento. Por isso, o contêiner precisa estar ciente do contrato de trabalho de processamento documentado no tópico [Como criar um contêiner de processamento (cenário avançado)](build-your-own-processing-container.md). Observe que o Model Monitor inicia o trabalho de processamento em seu nome de acordo com a programação. Ao invocar, o Model Monitor configura variáveis de ambiente adicionais para você, de modo que o contêiner tenha contexto suficiente para processar os dados para essa execução específica da programação agendada. Para obter informações adicionais sobre entradas de contêiner, consulte o [Entradas do contrato de contêiner](model-monitor-byoc-contract-inputs.md). No contêiner, usando as variáveis ou o contexto de ambiente acima, agora é possível analisar o conjunto de dados para o período atual no código personalizado. Uma vez concluída essa análise, é possível optar por emitir os relatórios que serão carregados no bucket do S3. Os relatórios gerados pelo contêiner pré-criado são documentados em [Saídas de contrato do contêiner](model-monitor-byoc-contract-outputs.md). Se você quiser que a visualização dos relatórios funcione no SageMaker Studio, siga o mesmo formato. Também é possível optar por emitir relatórios completamente personalizados. Você também emite CloudWatch métricas do contêiner seguindo as instruções em[CloudWatch Métricas para trazer seus próprios contêineres](model-monitor-byoc-cloudwatch.md). **Topics** + [Entradas do contrato de contêiner](model-monitor-byoc-contract-inputs.md) + [Saídas de contrato do contêiner](model-monitor-byoc-contract-outputs.md) + [CloudWatch Métricas para trazer seus próprios contêineres](model-monitor-byoc-cloudwatch.md) # Entradas do contrato de contêiner A plataforma Amazon SageMaker Model Monitor invoca seu código de contêiner de acordo com um cronograma especificado. Se você optar por escrever seu próprio código de contêiner, as variáveis de ambiente a seguir estarão disponíveis. Nesse contexto, será possível analisar o conjunto de dados atual ou avaliar as restrições se escolher e emitir métricas, se aplicável. As variáveis de ambiente disponíveis são as mesmas para endpoints em tempo real e trabalhos de transformação de lotes, exceto pela variável `dataset_format`. Se você estiver usando um endpoint em tempo real, a variável `dataset_format` oferece apoio às seguintes opções: ``` {\"sagemakerCaptureJson\": {\"captureIndexNames\": [\"endpointInput\",\"endpointOutput\"]}} ``` Se você estiver usando um trabalho de transformação de lotes, o `dataset_format` é compatível com as seguintes opções: ``` {\"csv\": {\"header\": [\"true\",\"false\"]}} ``` ``` {\"json\": {\"line\": [\"true\",\"false\"]}} ``` ``` {\"parquet\": {}} ``` O exemplo de código a seguir mostra o conjunto completo de variáveis de ambiente disponíveis para seu código de contêiner (e usa o formato `dataset_format` para um endpoint em tempo real). ``` "Environment": { "dataset_format": "{\"sagemakerCaptureJson\": {\"captureIndexNames\": [\"endpointInput\",\"endpointOutput\"]}}", "dataset_source": "/opt/ml/processing/endpointdata", "end_time": "2019-12-01T16: 20: 00Z", "output_path": "/opt/ml/processing/resultdata", "publish_cloudwatch_metrics": "Disabled", "sagemaker_endpoint_name": "endpoint-name", "sagemaker_monitoring_schedule_name": "schedule-name", "start_time": "2019-12-01T15: 20: 00Z" } ``` Parâmetros | Nome do parâmetro | Description | | --- | --- | | dataset\$1format | Para um trabalho iniciado a partir de um `MonitoringSchedule` com base em um `Endpoint`, isso é `sageMakerCaptureJson` com os índices de captura `endpointInput`, `endpointOutput` ou ambos. Para um trabalho de transformação de lotes, isso especifica o formato dos dados, seja CSV, JSON ou Parquet. | | dataset\$1source | Se você estiver usando um endpoint em tempo real, o caminho local no qual os dados correspondentes ao período de monitoramento, conforme especificado por `start_time` e `end_time`, estão disponíveis. Nesse caminho, os dados estão disponíveis em ` /{endpoint-name}/{variant-name}/yyyy/mm/dd/hh`. Às vezes, fazemos download mais do que o especificado pelos horários de início e de término. Cabe ao código do contêiner analisar os dados conforme necessário. | | output\$1path | O caminho local para gravar relatórios de saída e outros arquivos. Especifique esse parâmetro na solicitação `CreateMonitoringSchedule` como `MonitoringOutputConfig.MonitoringOutput[0].LocalPath`. É feito upload dele no caminho `S3Uri` especificado em `MonitoringOutputConfig.MonitoringOutput[0].S3Uri`. | | publish\$1cloudwatch\$1metrics | Para um trabalho executado por `CreateMonitoringSchedule`, esse parâmetro é definido como `Enabled`. O contêiner pode escolher gravar o arquivo CloudWatch de saída da Amazon em`[filepath]`. | | sagemaker\$1endpoint\$1name | Se você estiver usando um endpoint em tempo real, o nome do `Endpoint` para o qual esse trabalho programado foi iniciado. | | sagemaker\$1monitoring\$1schedule\$1name | O nome do `MonitoringSchedule` que executou esse trabalho. | | \$1sagemaker\$1endpoint\$1datacapture\$1prefix\$1 | Se você estiver usando um endpoint em tempo real, o prefixo especificado no parâmetro `DataCaptureConfig` do `Endpoint`. O contêiner pode usar isso se precisar acessar diretamente mais dados do que os já baixados pela SageMaker IA no `dataset_source` caminho. | | start\$1time, end\$1time | A janela de tempo para a execução dessa análise. Por exemplo, para um trabalho programado para ser executado às 05:00 UTC e um trabalho executado em 20/02/2020, `start_time` é 2020-02-19T06:00:00Z e `end_time` é 2020-02-20T05:00:00Z | | baseline\$1constraints: | O caminho local do arquivo de restrição de linha de base especificado em ` BaselineConfig.ConstraintResource.S3Uri`. Isso só estará disponível se esse parâmetro tiver sido especificado na solicitação `CreateMonitoringSchedule`. | | baseline\$1statistics | O caminho local para o arquivo de estatísticas da linha de base especificado em `BaselineConfig.StatisticsResource.S3Uri`. Isso só estará disponível se esse parâmetro tiver sido especificado na solicitação `CreateMonitoringSchedule`. | # Saídas de contrato do contêiner O contêiner pode analisar os dados disponíveis no caminho `*dataset_source*` e gravar relatórios para o caminho em `*output_path*.`. O código do contêiner pode gravar qualquer relatório que atenda às suas necessidades. Se você usar a estrutura e o contrato a seguir, determinados arquivos de saída serão tratados especialmente pela SageMaker IA na visualização e na API. Isso se aplica somente a conjuntos de dados tabulares. Arquivos de saída para conjuntos de dados tabulares | Nome do arquivo | Description | | --- | --- | | statistics.json | Espera-se que este arquivo tenha estatísticas colunares para cada atributo no conjunto de dados que é analisado. O esquema para este arquivo está disponível na próxima seção. | | constraints.json | Espera-se que este arquivo tenha as restrições sobre os atributos observados. O esquema para este arquivo está disponível na próxima seção. | | constraints\$1violations.json | Espera-se que este arquivo tenha a lista de violações encontradas nesse conjunto atual de dados em comparação com o arquivo de estatísticas e restrições de linha de base especificado no caminho `baseline_constaints` e `baseline_statistics`. | Além disso, se o `publish_cloudwatch_metrics` valor for código de `"Enabled"` contêiner pode emitir CloudWatch métricas da Amazon neste local:`/opt/ml/output/metrics/cloudwatch`. O esquema para esses arquivos está descrito nas seções a seguir. **Topics** + [Esquema para estatísticas (arquivo statistics.json)](model-monitor-byoc-statistics.md) + [Esquema para restrições (arquivo constraints.json)](model-monitor-byoc-constraints.md) # Esquema para estatísticas (arquivo statistics.json) O esquema definido no arquivo `statistics.json` especifica os parâmetros estatísticos a serem calculados para a linha de base e para os dados capturados. Ele também configura o bucket que deve ser usado pelo [KLL](https://datasketches.apache.org/docs/KLL/KLLSketch.html), um esboço de quantis muito compacto com esquema de compactação lento. ``` { "version": 0, # dataset level stats "dataset": { "item_count": number }, # feature level stats "features": [ { "name": "feature-name", "inferred_type": "Fractional" | "Integral", "numerical_statistics": { "common": { "num_present": number, "num_missing": number }, "mean": number, "sum": number, "std_dev": number, "min": number, "max": number, "distribution": { "kll": { "buckets": [ { "lower_bound": number, "upper_bound": number, "count": number } ], "sketch": { "parameters": { "c": number, "k": number }, "data": [ [ num, num, num, num ], [ num, num ][ num, num ] ] }#sketch }#KLL }#distribution }#num_stats }, { "name": "feature-name", "inferred_type": "String", "string_statistics": { "common": { "num_present": number, "num_missing": number }, "distinct_count": number, "distribution": { "categorical": { "buckets": [ { "value": "string", "count": number } ] } } }, #provision for custom stats } ] } ``` **Observações** As métricas especificadas são reconhecidas pela SageMaker IA em alterações posteriores na visualização. O contêiner pode emitir mais métricas, se necessário. O [esboço KLL](https://datasketches.apache.org/docs/KLL/KLLSketch.html) é o esboço reconhecido. Os contêineres personalizados podem escrever sua própria representação, mas ela não será reconhecida pela SageMaker IA nas visualizações. Por padrão, a distribuição é materializada em 10 buckets. Não é possível alterar esse valor. # Esquema para restrições (arquivo constraints.json) Um arquivo constraints.json é usado para expressar as restrições que um conjunto de dados deve satisfazer. Os contêineres SageMaker do Amazon Model Monitor podem usar o arquivo constraints.json para avaliar os conjuntos de dados. Os contêineres pré-criados fornecem a capacidade de gerar o arquivo constraints.json automaticamente para um conjunto de dados da linha de base. Se você trouxer seu próprio contêiner, será possível fornecê-lo com habilidades semelhantes ou você poderá criar o arquivo constraints.json de alguma outra maneira. Veja a seguir o esquema para o arquivo de restrição que o contêiner pré-criado usa. Ao trazer seus próprios contêineres, é possível adotar o mesmo formato ou melhorá-lo conforme necessário. ``` { "version": 0, "features": [ { "name": "string", "inferred_type": "Integral" | "Fractional" | | "String" | "Unknown", "completeness": number, "num_constraints": { "is_non_negative": boolean }, "string_constraints": { "domains": [ "list of", "observed values", "for small cardinality" ] }, "monitoringConfigOverrides": {} } ], "monitoring_config": { "evaluate_constraints": "Enabled", "emit_metrics": "Enabled", "datatype_check_threshold": 0.1, "domain_content_threshold": 0.1, "distribution_constraints": { "perform_comparison": "Enabled", "comparison_threshold": 0.1, "comparison_method": "Simple"||"Robust", "categorical_comparison_threshold": 0.1, "categorical_drift_method": "LInfinity"||"ChiSquared" } } } ``` O objeto `monitoring_config` contém opções para o trabalho de monitoramento do atributo. A tabela a seguir descreve cada opção. Monitoramento de restrições [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/model-monitor-byoc-constraints.html) # CloudWatch Métricas para trazer seus próprios contêineres Se o `publish_cloudwatch_metrics` valor estiver `Enabled` no `Environment` mapa do `/opt/ml/processing/processingjobconfig.json` arquivo, o código do contêiner emite CloudWatch métricas da Amazon neste local:`/opt/ml/output/metrics/cloudwatch`. O esquema desse arquivo é estreitamente baseado na CloudWatch `PutMetrics` API. O namespace não é especificado aqui. O padrão é o seguinte: + `For real-time endpoints: /aws/sagemaker/Endpoint/data-metrics` + `For batch transform jobs: /aws/sagemaker/ModelMonitoring/data-metrics` No entanto, é possível especificar dimensões. Recomendamos que você adicione as dimensões a seguir no mínimo: + `Endpoint` e `MonitoringSchedule` para endpoints em tempo real + `MonitoringSchedule` para trabalhos de transformação de lotes Os trechos JSON a seguir mostram como definir suas dimensões. Para um endpoint em tempo real, consulte o seguinte trecho JSON, que inclui as dimensões `Endpoint` e `MonitoringSchedule`: ``` { "MetricName": "", # Required "Timestamp": "2019-11-26T03:00:00Z", # Required "Dimensions" : [{"Name":"Endpoint","Value":"endpoint_0"},{"Name":"MonitoringSchedule","Value":"schedule_0"}] "Value": Float, # Either the Value or the StatisticValues field can be populated and not both. "StatisticValues": { "SampleCount": Float, "Sum": Float, "Minimum": Float, "Maximum": Float }, "Unit": "Count", # Optional } ``` Para um trabalho de transformação de lotes, consulte o seguinte trecho JSON, que inclui a dimensão `MonitoringSchedule`: ``` { "MetricName": "", # Required "Timestamp": "2019-11-26T03:00:00Z", # Required "Dimensions" : [{"Name":"MonitoringSchedule","Value":"schedule_0"}] "Value": Float, # Either the Value or the StatisticValues field can be populated and not both. "StatisticValues": { "SampleCount": Float, "Sum": Float, "Minimum": Float, "Maximum": Float }, "Unit": "Count", # Optional } ``` # Crie um cronograma de monitoramento para um endpoint em tempo real com um recurso CloudFormation personalizado Se você estiver usando um endpoint em tempo real, poderá usar um recurso CloudFormation personalizado para criar um cronograma de monitoramento. O recurso personalizado está em Python. Para implantá-lo, consulte a [Implantação do Python Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python-how-to-create-deployment-package.html). ## Recurso personalizado Comece adicionando um recurso personalizado ao seu CloudFormation modelo. Isso apontará para uma função do AWS Lambda que você criará em seguida. Esse recurso permite que você personalize os parâmetros do cronograma de monitoramento. Você pode adicionar ou remover mais parâmetros modificando o CloudFormation recurso e a função Lambda no recurso de exemplo a seguir. ``` { "AWSTemplateFormatVersion": "2010-09-09", "Resources": { "MonitoringSchedule": { "Type": "Custom::MonitoringSchedule", "Version": "1.0", "Properties": { "ServiceToken": "arn:aws:lambda:us-west-2:111111111111:function:lambda-name", "ScheduleName": "YourScheduleName", "EndpointName": "YourEndpointName", "BaselineConstraintsUri": "s3://your-baseline-constraints/constraints.json", "BaselineStatisticsUri": "s3://your-baseline-stats/statistics.json", "PostAnalyticsProcessorSourceUri": "s3://your-post-processor/postprocessor.py", "RecordPreprocessorSourceUri": "s3://your-preprocessor/preprocessor.py", "InputLocalPath": "/opt/ml/processing/endpointdata", "OutputLocalPath": "/opt/ml/processing/localpath", "OutputS3URI": "s3://your-output-uri", "ImageURI": "111111111111.dkr.ecr.us-west-2.amazonaws.com/your-image", "ScheduleExpression": "cron(0 * ? * * *)", "PassRoleArn": "arn:aws:iam::111111111111:role/AmazonSageMaker-ExecutionRole" } } } } ``` ## Código de recurso personalizado do Lambda Esse recurso CloudFormation personalizado usa a AWS biblioteca [Custom Resource Helper](https://github.com/aws-cloudformation/custom-resource-helper), que você pode instalar com o pip usando. `pip install crhelper` Essa função Lambda é invocada CloudFormation durante a criação e exclusão da pilha. Essa função do Lambda é responsável por criar e excluir a programação de monitoramento e usar os parâmetros definidos no recurso personalizado descrito na seção anterior. ``` import boto3 import botocore import logging from crhelper import CfnResource from botocore.exceptions import ClientError logger = logging.getLogger(__name__) sm = boto3.client('sagemaker') # cfnhelper makes it easier to implement a CloudFormation custom resource helper = CfnResource() # CFN Handlers def handler(event, context): helper(event, context) @helper.create def create_handler(event, context): """ Called when CloudFormation custom resource sends the create event """ create_monitoring_schedule(event) @helper.delete def delete_handler(event, context): """ Called when CloudFormation custom resource sends the delete event """ schedule_name = get_schedule_name(event) delete_monitoring_schedule(schedule_name) @helper.poll_create def poll_create(event, context): """ Return true if the resource has been created and false otherwise so CloudFormation polls again. """ schedule_name = get_schedule_name(event) logger.info('Polling for creation of schedule: %s', schedule_name) return is_schedule_ready(schedule_name) @helper.update def noop(): """ Not currently implemented but crhelper will throw an error if it isn't added """ pass # Helper Functions def get_schedule_name(event): return event['ResourceProperties']['ScheduleName'] def create_monitoring_schedule(event): schedule_name = get_schedule_name(event) monitoring_schedule_config = create_monitoring_schedule_config(event) logger.info('Creating monitoring schedule with name: %s', schedule_name) sm.create_monitoring_schedule( MonitoringScheduleName=schedule_name, MonitoringScheduleConfig=monitoring_schedule_config) def is_schedule_ready(schedule_name): is_ready = False schedule = sm.describe_monitoring_schedule(MonitoringScheduleName=schedule_name) status = schedule['MonitoringScheduleStatus'] if status == 'Scheduled': logger.info('Monitoring schedule (%s) is ready', schedule_name) is_ready = True elif status == 'Pending': logger.info('Monitoring schedule (%s) still creating, waiting and polling again...', schedule_name) else: raise Exception('Monitoring schedule ({}) has unexpected status: {}'.format(schedule_name, status)) return is_ready def create_monitoring_schedule_config(event): props = event['ResourceProperties'] return { "ScheduleConfig": { "ScheduleExpression": props["ScheduleExpression"], }, "MonitoringJobDefinition": { "BaselineConfig": { "ConstraintsResource": { "S3Uri": props['BaselineConstraintsUri'], }, "StatisticsResource": { "S3Uri": props['BaselineStatisticsUri'], } }, "MonitoringInputs": [ { "EndpointInput": { "EndpointName": props["EndpointName"], "LocalPath": props["InputLocalPath"], } } ], "MonitoringOutputConfig": { "MonitoringOutputs": [ { "S3Output": { "S3Uri": props["OutputS3URI"], "LocalPath": props["OutputLocalPath"], } } ], }, "MonitoringResources": { "ClusterConfig": { "InstanceCount": 1, "InstanceType": "ml.t3.medium", "VolumeSizeInGB": 50, } }, "MonitoringAppSpecification": { "ImageUri": props["ImageURI"], "RecordPreprocessorSourceUri": props['PostAnalyticsProcessorSourceUri'], "PostAnalyticsProcessorSourceUri": props['PostAnalyticsProcessorSourceUri'], }, "StoppingCondition": { "MaxRuntimeInSeconds": 300 }, "RoleArn": props["PassRoleArn"], } } def delete_monitoring_schedule(schedule_name): logger.info('Deleting schedule: %s', schedule_name) try: sm.delete_monitoring_schedule(MonitoringScheduleName=schedule_name) except ClientError as e: if e.response['Error']['Code'] == 'ResourceNotFound': logger.info('Resource not found, nothing to delete') else: logger.error('Unexpected error while trying to delete monitoring schedule') raise e ``` # Monitor de modelo FAQs Consulte o seguinte FAQs para obter mais informações sobre o Amazon SageMaker Model Monitor. **P: Como o Model Monitor and SageMaker Clarify ajuda os clientes a monitorar o comportamento do modelo?** Os clientes podem monitorar o comportamento do modelo em quatro dimensões: [qualidade dos dados, qualidade](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-data-quality.html) do [modelo, variação](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-model-quality.html) de [polarização e variação](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-model-monitor-bias-drift.html) de [atribuição de recursos](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-model-monitor-feature-attribution-drift.html) por meio do SageMaker Amazon Model Monitor e do Clarify. SageMaker O [Model Monitor](https://aws.amazon.com/sagemaker/model-monitor/) monitora continuamente a qualidade dos modelos de aprendizado de máquina de SageMaker IA da Amazon em produção. Isso inclui monitorar o desvio na qualidade dos dados e nas métricas de qualidade do modelo, como precisão e RMSE. SageMaker O monitoramento de viés do [Clarify](https://aws.amazon.com/sagemaker/clarify/?sagemaker-data-wrangler-whats-new.sort-by=item.additionalFields.postDateTime&sagemaker-data-wrangler-whats-new.sort-order=desc) ajuda cientistas de dados e engenheiros de ML a monitorar o viés na previsão do modelo e na variação da atribuição de recursos. **P: O que acontece em segundo plano quando o Sagemaker Model Monitor é ativado?** O Amazon SageMaker Model Monitor automatiza o monitoramento de modelos, aliviando a necessidade de monitorar os modelos manualmente ou criar qualquer ferramenta adicional. Para automatizar o processo, o Model Monitor oferece a capacidade de criar um conjunto de estatísticas e restrições de linha de base usando os dados com os quais seu modelo foi treinado e, em seguida, configurar uma programação para monitorar as predições feitas em seu endpoint. O Model Monitor usa regras para detectar oscilações em seus modelos e alerta você quando isso acontece. As seguintes etapas descrevem o que acontece quando você habilita o monitoramento do modelo: + **Habilitar o monitoramento do modelo**: para um endpoint em tempo real, é necessário habilitar o endpoint para capturar dados de solicitações de entrada para um modelo de ML implantado e as predições de modelo resultantes. Para um trabalho de transformação de lotes, habilite a captura de dados das entradas e saídas da transformação de lotes. + **Trabalho de processamento de linha de base**: em seguida, crie uma linha de base com o conjunto de dados que foi usado para treinar o modelo. A linha de base calcula as métricas e sugere restrições para elas. Por exemplo, a pontuação de recall do modelo não deve regredir e cair abaixo de 0,571, ou a pontuação de precisão não deve cair abaixo de 1,0. As predições em tempo real ou em lotes do seu modelo são comparadas às restrições e são relatadas como violações se estiverem fora dos valores restritos. + **Trabalho de monitoramento**: em seguida, crie uma programação de monitoramento especificando quais dados devem ser coletados, com que frequência devem ser coletados, como analisá-los e quais relatórios devem ser produzidos. + **Trabalho de mesclagem**: isso só é aplicável se você estiver utilizando o Amazon SageMaker Ground Truth. O Model Monitor compara as predições que seu modelo faz com rótulos de veracidade para medir a qualidade do modelo. Para que isso funcione, você rotula periodicamente os dados capturados pelo seu trabalho de transformação em lote ou endpoint e os carrega no Amazon S3. Depois de criar e carregar os rótulos do Ground Truth, inclua a localização dos rótulos como parâmetro ao criar o trabalho de monitoramento. Quando você usa o Model Monitor para monitorar um trabalho de transformação de lotes em vez de um endpoint em tempo real, em vez de receber solicitações em um endpoint e rastrear as predições, o Model Monitor monitorará as entradas e saídas de inferência. Em uma programação do Model Monitor, o cliente fornece a contagem e o tipo de instâncias que devem ser usadas no trabalho de processamento. Esses recursos permanecem reservados até que a programação seja excluída, independentemente do status da execução atual. **P: O que é captura de dados, por que ela é necessária e como posso habilitá-la?** Para registrar as entradas no endpoint do modelo e as saídas de inferência do modelo implantado no Amazon S3, você pode habilitar um atributo chamado [Captura de dados](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-data-capture.html). Para obter mais detalhes sobre como habilitá-lo para um endpoint em tempo real e um trabalho de transformação de lotes, consulte [Capturar dados do endpoint em tempo real](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-data-capture-endpoint.html) e [Capturar dados do trabalho de transformação de lotes](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-data-capture-batch.html). **P: A habilitação da captura de dados afeta o desempenho de um endpoint em tempo real?** A captura de dados ocorre de forma assíncrona, sem afetar o tráfego de produção. Depois de habilitar a captura de dados, a carga útil da solicitação e da resposta, além de alguns metadados adicionais, será salva no local do Amazon S3 especificado em `DataCaptureConfig`. Observe que pode haver um atraso na propagação dos dados capturados para o Amazon S3. Também é possível visualizar os dados capturados listando os arquivos de captura de dados armazenados no Amazon S3. O formato do caminho do Amazon S3 é: `s3:///{endpoint-name}/{variant-name}/yyyy/mm/dd/hh/filename.jsonl`. A captura de dados do Amazon S3 deve estar na mesma região que a programação do Model Monitor. Você também deve garantir que os nomes das colunas do conjunto de dados da linha de base tenham apenas letras minúsculas e um sublinhado (`_`) como único separador. **P: Por que o Ground Truth é necessário para o monitoramento de modelos?** Os rótulos de veracidade são exigidos pelos seguintes atributos do Model Monitor: + O **monitoramento da qualidade do modelo** compara as predições que seu modelo faz com rótulos de veracidade para medir a qualidade do modelo. + O **monitoramento de desvio do modelo** monitora as predições de desvios. Uma forma pela qual o desvio pode ser introduzido nos modelos de ML implantados é quando os dados usados no treinamento diferem dos dados usados para gerar predições. Isso é especialmente pronunciado se os dados usados para treinamento mudarem com o tempo (como taxas de hipoteca flutuantes) e a predição de modelo não for tão precisa, a menos que o modelo seja retreinado com dados atualizados. Por exemplo, um modelo para prever preços de casas pode ser tendencioso se as taxas de hipoteca usadas para treinar o modelo diferirem das taxas de hipoteca mais atuais do mundo real. **P: Para clientes que usam o Ground Truth para rotulagem, quais são as etapas que posso seguir para monitorar a qualidade do modelo?** O monitoramento da qualidade do modelo compara as predições que seu modelo faz com rótulos de veracidade para medir a qualidade do modelo. Para que isso funcione, você rotula periodicamente os dados capturados pelo seu trabalho de transformação em lote ou endpoint e os carrega no Amazon S3. Além das capturas, a execução do monitoramento do desvio do modelo também requer dados do Ground Truth. Em casos de uso real, os dados do Ground Truth devem ser coletados e enviados regularmente para o local designado do Amazon S3. Para combinar os rótulos do Ground Truth com os dados de predição capturados, deve haver um identificador exclusivo para cada registro no conjunto de dados. Para ver a estrutura de cada registro dos dados do Ground Truth, consulte [Ingerir rótulos de veracidade e mesclá-los com as predições](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-model-quality-merge.html). O exemplo de código a seguir pode ser usado para gerar dados artificiais do Ground Truth para um conjunto de dados tabular. ``` import random def ground_truth_with_id(inference_id): random.seed(inference_id) # to get consistent results rand = random.random() # format required by the merge container return { "groundTruthData": { "data": "1" if rand < 0.7 else "0", # randomly generate positive labels 70% of the time "encoding": "CSV", }, "eventMetadata": { "eventId": str(inference_id), }, "eventVersion": "0", } def upload_ground_truth(upload_time): records = [ground_truth_with_id(i) for i in range(test_dataset_size)] fake_records = [json.dumps(r) for r in records] data_to_upload = "\n".join(fake_records) target_s3_uri = f"{ground_truth_upload_path}/{upload_time:%Y/%m/%d/%H/%M%S}.jsonl" print(f"Uploading {len(fake_records)} records to", target_s3_uri) S3Uploader.upload_string_as_file_body(data_to_upload, target_s3_uri) # Generate data for the last hour upload_ground_truth(datetime.utcnow() - timedelta(hours=1)) # Generate data once a hour def generate_fake_ground_truth(terminate_event): upload_ground_truth(datetime.utcnow()) for _ in range(0, 60): time.sleep(60) if terminate_event.is_set(): break ground_truth_thread = WorkerThread(do_run=generate_fake_ground_truth) ground_truth_thread.start() ``` O exemplo de código a seguir mostra como gerar tráfego artificial para enviar para o endpoint do modelo. Observe o atributo `inferenceId` usado acima para invocar. Se isso estiver presente, ele será usado para juntar dados do Ground Truth (caso contrário, o `eventId` será usado). ``` import threading class WorkerThread(threading.Thread): def __init__(self, do_run, *args, **kwargs): super(WorkerThread, self).__init__(*args, **kwargs) self.__do_run = do_run self.__terminate_event = threading.Event() def terminate(self): self.__terminate_event.set() def run(self): while not self.__terminate_event.is_set(): self.__do_run(self.__terminate_event) def invoke_endpoint(terminate_event): with open(test_dataset, "r") as f: i = 0 for row in f: payload = row.rstrip("\n") response = sagemaker_runtime_client.invoke_endpoint( EndpointName=endpoint_name, ContentType="text/csv", Body=payload, InferenceId=str(i), # unique ID per row ) i += 1 response["Body"].read() time.sleep(1) if terminate_event.is_set(): break # Keep invoking the endpoint with test data invoke_endpoint_thread = WorkerThread(do_run=invoke_endpoint) invoke_endpoint_thread.start() ``` Você deve fazer o upload dos dados do Ground Truth em um bucket do Amazon S3 que tenha o mesmo formato de caminho dos dados capturados, que tem o seguinte formato: `s3:////yyyy/mm/dd/hh` **nota** A data nesse caminho é a data em que o rótulo de veracidade é coletado. Não precisa corresponder à data em que a inferência foi gerada. **P: Como os clientes podem personalizar as programações de monitoramento?** Além de usar os mecanismos de monitoramento integrados, é possível criar suas próprias programações e procedimentos de monitoramento personalizados usando scripts de pré-processamento e pós-processamento ou usando ou criando seu próprio contêiner. É importante observar que os scripts de pré-processamento e pós-processamento só funcionam com trabalhos de qualidade de dados e modelos. A Amazon SageMaker AI fornece a capacidade de monitorar e avaliar os dados observados pelos endpoints do modelo. Para isso, você precisa criar uma linha de base com a qual compare o tráfego em tempo real. Depois que uma linha de base estiver pronta, configure uma programação para avaliar e comparar continuamente com a linha de base. Ao criar uma programação, você pode fornecer o script de pré-processamento e pós-processamento. O exemplo a seguir mostra como personalizar as programações de monitoramento com scripts de pré-processamento e pós-processamento. ``` import boto3, osfrom sagemaker import get_execution_role, Sessionfrom sagemaker.model_monitor import CronExpressionGenerator, DefaultModelMonitor # Upload pre and postprocessor scripts session = Session() bucket = boto3.Session().resource("s3").Bucket(session.default_bucket()) prefix = "demo-sagemaker-model-monitor" pre_processor_script = bucket.Object(os.path.join(prefix, "preprocessor.py")).upload_file("preprocessor.py") post_processor_script = bucket.Object(os.path.join(prefix, "postprocessor.py")).upload_file("postprocessor.py") # Get execution role role = get_execution_role() # can be an empty string # Instance type instance_type = "instance-type" # instance_type = "ml.m5.xlarge" # Example # Create a monitoring schedule with pre and post-processing my_default_monitor = DefaultModelMonitor( role=role, instance_count=1, instance_type=instance_type, volume_size_in_gb=20, max_runtime_in_seconds=3600, ) s3_report_path = "s3://{}/{}".format(bucket, "reports") monitor_schedule_name = "monitor-schedule-name" endpoint_name = "endpoint-name" my_default_monitor.create_monitoring_schedule( post_analytics_processor_script=post_processor_script, record_preprocessor_script=pre_processor_script, monitor_schedule_name=monitor_schedule_name, # use endpoint_input for real-time endpoint endpoint_input=endpoint_name, # or use batch_transform_input for batch transform jobs # batch_transform_input=batch_transform_name, output_s3_uri=s3_report_path, statistics=my_default_monitor.baseline_statistics(), constraints=my_default_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, ) ``` **P: Quais são alguns dos cenários ou casos de uso em que posso aproveitar um script de pré-processamento?** É possível usar scripts de pré-processamento quando precisar transformar as entradas do seu monitor do modelo. Considere os seguintes cenários de exemplo: 1. Script de pré-processamento para transformação de dados. Suponha que a saída do seu modelo seja uma matriz: `[1.0, 2.1]`. O contêiner do Model Monitor funciona apenas com estruturas tabulares ou de JSON simples, como `{“prediction0”: 1.0, “prediction1” : 2.1}`. Você pode usar um script de pré-processamento como o seguinte exemplo para transformar a matriz na estrutura JSON correta: ``` def preprocess_handler(inference_record): input_data = inference_record.endpoint_input.data output_data = inference_record.endpoint_output.data.rstrip("\n") data = output_data + "," + input_data return { str(i).zfill(20) : d for i, d in enumerate(data.split(",")) } ``` 1. Exclua determinados registros dos cálculos de métrica do Model Monitor. Suponha que seu modelo tenha atributos opcionais e você use `-1` para indicar que o atributo opcional tem um valor ausente. Se você tiver um monitor de qualidade de dados, talvez queira remover o `-1` da matriz de valores de entrada para que não seja incluído nos cálculos métricos do monitor. Você pode usar um script como o seguinte para remover esses valores: ``` def preprocess_handler(inference_record): input_data = inference_record.endpoint_input.data return {i : None if x == -1 else x for i, x in enumerate(input_data.split(","))} ``` 1. Aplique uma estratégia de amostragem personalizada. Você também pode aplicar uma estratégia de amostragem personalizada em seu script de pré-processamento. Para fazer isso, configure o contêiner pré-criado original do Model Monitor para ignorar uma porcentagem dos registros de acordo com a taxa de amostragem especificada. No exemplo a seguir, o manipulador coleta amostras de 10% dos registros retornando o registro em 10% das chamadas do manipulador e, caso contrário, uma lista vazia. ``` import random def preprocess_handler(inference_record): # we set up a sampling rate of 0.1 if random.random() > 0.1: # return an empty list return [] input_data = inference_record.endpoint_input.data return {i : None if x == -1 else x for i, x in enumerate(input_data.split(","))} ``` 1. Use o registro personalizado. Você pode registrar todas as informações necessárias do seu script na Amazon CloudWatch. Isso pode ser útil ao depurar seu script de pré-processamento em caso de erro. O exemplo a seguir mostra como você pode usar a `preprocess_handler` interface para fazer login CloudWatch. ``` def preprocess_handler(inference_record, logger): logger.info(f"I'm a processing record: {inference_record}") logger.debug(f"I'm debugging a processing record: {inference_record}") logger.warning(f"I'm processing record with missing value: {inference_record}") logger.error(f"I'm a processing record with bad value: {inference_record}") return inference_record ``` **nota** Quando o script de pré-processamento é executado em dados de transformação de lotes, o tipo de entrada nem sempre é o objeto `CapturedData`. Para dados CSV, o tipo é uma string. Para dados JSON, o tipo é um dicionário Python. **P: Quando posso aproveitar um script de pós-processamento?** Você pode aproveitar um script de pós-processamento como uma extensão após uma execução de monitoramento bem-sucedida. Veja a seguir um exemplo simples, mas você pode executar ou chamar qualquer função comercial que precise ser realizada após uma execução bem-sucedida de monitoramento. ``` def postprocess_handler(): print("Hello from the post-processing script!") ``` **P: Quando devo considerar trazer meu próprio contêiner para o monitoramento de modelos?** SageMaker A IA fornece um contêiner pré-construído para analisar dados capturados de endpoints ou trabalhos de transformação em lote para conjuntos de dados tabulares. No entanto, há cenários em que talvez você queira criar seu próprio contêiner. Considere os seguintes cenários: + Você tem requisitos regulatórios e de conformidade para usar somente os contêineres criados e mantidos internamente em sua organização. + Se quiser incluir algumas bibliotecas de terceiros, você pode colocar um `requirements.txt` arquivo em um diretório local e referenciá-lo usando o `source_dir` parâmetro no [estimador de SageMaker IA](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator), que permite a instalação da biblioteca em tempo de execução. No entanto, se você tiver muitas bibliotecas ou dependências que aumentam o tempo de instalação durante a execução do trabalho de treinamento, talvez queira aproveitar o BYOC. + Seu ambiente não força a conectividade com a Internet (ou Silo), o que impede o download do pacote. + Monitore os dados que estão em formatos de dados que não sejam tabulares, como casos de uso de PNL ou CV. + Quando você precisa de métricas de monitoramento adicionais além das compatíveis com o Model Monitor. **P: Tenho modelos de PNL e CV. Como faço para monitorá-los em busca de desvios de dados?** O contêiner pré-construído da Amazon SageMaker AI oferece suporte a conjuntos de dados tabulares. Se quiser monitorar modelos de PNL e CV, você pode trazer seu próprio contêiner aproveitando os pontos de extensão fornecidos pelo Model Monitor. Para obter mais detalhes sobre os requisitos, consulte [Traga seus próprios contêineres](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-byoc-containers.html). Veja a seguir mais exemplos: + Para obter uma explicação detalhada de como usar o Model Monitor para um caso de uso de visão computacional, consulte [Detectar e analisar predições incorretas](https://aws.amazon.com/blogs/machine-learning/detecting-and-analyzing-incorrect-model-predictions-with-amazon-sagemaker-model-monitor-and-debugger/). + Para um cenário em que o Model Monitor pode ser usado para um caso de uso de PNL, consulte [Detectar desvios de dados de PNL usando o Amazon Model Monitor personalizado](https://aws.amazon.com/blogs/machine-learning/detect-nlp-data-drift-using-custom-amazon-sagemaker-model-monitor/). SageMaker **P: Quero excluir o endpoint do modelo para o qual o Model Monitor foi habilitado, mas não consigo fazer isso porque a programação de monitoramento ainda está ativa. O que devo fazer?** [Se você quiser excluir um endpoint de inferência hospedado na SageMaker IA que tenha o Model Monitor ativado, primeiro você deve excluir o cronograma de monitoramento do modelo (com a `DeleteMonitoringSchedule`[CLI](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-monitoring-schedule.html) ou a API).](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteMonitoringSchedule.html) Em seguida, exclua o endpoint. **P: O SageMaker Model Monitor calcula métricas e estatísticas para entrada?** O Model Monitor calcula métricas e estatísticas para a saída, não para a entrada. **P: O SageMaker Model Monitor oferece suporte a endpoints de vários modelos?** Não, o Model Monitor é compatível apenas com endpoints que hospedam um modelo único e não é compatível com o monitoramento de endpoints multimodelo. **P: O SageMaker Model Monitor fornece dados de monitoramento sobre contêineres individuais em um pipeline de inferência?** O Model Monitor não é compatível com o monitoramento de pipelines de inferência, mas a captura e a análise de dados é feita para todo o pipeline, e não para contêineres individuais no pipeline. **P: O que posso fazer para evitar o impacto nas solicitações de inferência quando a captura de dados é configurada?** Para evitar o impacto nas solicitações de inferência, a Captura de dados interrompe a captura de solicitações em altos níveis de uso do disco. É recomendável que você mantenha a utilização do disco abaixo de 75% para garantir que a captura de dados continue capturando as solicitações. **P: O Amazon S3 Data Capture pode estar em uma AWS região diferente da região na qual o cronograma de monitoramento foi configurado?** Não, a captura de dados do Amazon S3 deve estar na mesma região que a programação de monitoramento. **P: O que é uma linha de base e como faço para criar uma? Posso criar uma linha de base personalizada?** Uma linha de base é usada como referência para comparar predições em tempo real ou em lote do modelo. Ela calcula estatísticas e métricas junto com as restrições sobre elas. Durante o monitoramento, tudo isso é usado em conjunto para identificar violações. Para usar a solução padrão do Amazon SageMaker Model Monitor, você pode aproveitar o [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html) SDK. Especificamente, use o método [suggest\$1baseline](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html#sagemaker.model_monitor.model_monitoring.DefaultModelMonitor.suggest_baseline) da [ModelQualityMonitor](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html#sagemaker.model_monitor.model_monitoring.ModelQualityMonitor)classe [ModelMonitor](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html#sagemaker.model_monitor.model_monitoring.DefaultModelMonitor)or para acionar um trabalho de processamento que calcula as métricas e as restrições da linha de base. O resultado de um trabalho de linha de base são dois arquivos: `statistics.json` e `constraints.json`. O [esquema para estatísticas](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-byoc-statistics.html) e o [esquema para restrições](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-byoc-constraints.html) contêm o esquema dos respectivos arquivos. Recomendamos que você revise as restrições geradas e as modifique antes de usá-las para monitoramento. Com base na sua compreensão do problema empresarial e do domínio, você pode tornar uma restrição mais agressiva ou relaxá-la para controlar o número e a natureza das violações. **P: Quais são as diretrizes para criar um conjunto de dados de linha de base?** O principal requisito para qualquer tipo de monitoramento é ter um conjunto de dados de linha de base usado para calcular métricas e restrições. Normalmente, esse é o conjunto de dados de treinamento usado pelo modelo, mas em alguns casos você pode optar por usar outro conjunto de dados de referência. Os nomes das colunas do conjunto de dados de linha de base devem ser compatíveis com o Spark. Para manter a máxima compatibilidade entre o Spark, CSV, JSON e parquet, é recomendável usar somente letras minúsculas e usar apenas `_` como separador. A inclusão de caracteres especiais, como `“ ”`, pode causar problemas. **P: Quais são os parâmetros `StartTimeOffset` e `EndTimeOffset` e quando eles são usados?** Quando o Amazon SageMaker Ground Truth é necessário para monitorar trabalhos como a qualidade do modelo, você precisa garantir que um trabalho de monitoramento use apenas dados para os quais o Ground Truth está disponível. Os `end_time_offset` parâmetros `start_time_offset` e de [EndpointInput](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html#sagemaker.model_monitor.model_monitoring.EndpointInput)podem ser usados para selecionar os dados que a tarefa de monitoramento usa. O trabalho de monitoramento usa os dados na janela de tempo definida por `start_time_offset` e `end_time_offset`. Esses parâmetros precisam ser especificados no [formato de duração ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations). Veja os seguintes exemplos: + Se os resultados do Ground Truth chegarem 3 dias após as predições terem sido feitas, defina `start_time_offset="-P3D"` e `end_time_offset="-P1D"`, que correspondem a 3 dias e 1 dia, respectivamente. + Se os resultados do Ground Truth chegarem 6 horas após as predições e você tiver uma programação horária, defina `start_time_offset="-PT6H"` e `end_time_offset="-PT1H"`, que correspondem a 6 horas e 1 hora. **P: Posso executar trabalhos de monitoramento “sob demanda”?** Sim, você pode executar trabalhos de monitoramento “sob demanda” executando um trabalho de SageMaker processamento. Para o Batch Transform, o [Pipelines](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-overview.html) tem um [MonitorBatchTransformStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.monitor_batch_transform_step.MonitorBatchTransformStep)que você pode usar para criar um pipeline de SageMaker IA que executa trabalhos de monitoramento sob demanda. O repositório de exemplos de SageMaker IA tem exemplos de código para executar trabalhos de monitoramento [da qualidade dos dados](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker_model_monitor/model_monitor_batch_transform/SageMaker-ModelMonitoring-Batch-Transform-Data-Quality-With-SageMaker-Pipelines-On-Demand.ipynb) e [da qualidade do modelo](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker_model_monitor/model_monitor_batch_transform/SageMaker-ModelMonitoring-Batch-Transform-Model-Quality-With-SageMaker-Pipelines-On-Demand.ipynb) sob demanda. **P: Como configurar o Model Monitor?** Você pode configurar o Model Monitor das seguintes maneiras: + **[Amazon SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/index.html)** — Há um [módulo Model Monitor](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html) que contém classes e funções que ajudam a sugerir linhas de base, criar cronogramas de monitoramento e muito mais. Veja os [exemplos de notebooks Amazon SageMaker Model Monitor](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker_model_monitor) para ver notebooks detalhados que utilizam o SageMaker AI Python SDK para configurar o Model Monitor. + **[Pipelines](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-overview.html)** — Os pipelines são integrados ao Model Monitor por meio do [QualityCheck Step e. [ClarifyCheckStep](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-clarify-check)](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-quality-check) APIs Você pode criar um pipeline de SageMaker IA que contenha essas etapas e que possa ser usado para executar trabalhos de monitoramento sob demanda sempre que o pipeline for executado. + **[Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html)** — Você pode criar um cronograma de monitoramento da qualidade de dados ou modelos junto com cronogramas de viés e explicabilidade do modelo diretamente da interface do usuário, selecionando um endpoint na lista de endpoints de modelo implantados. As Programações para outros tipos de monitoramento podem ser criados selecionando a guia relevante na interface do usuário. + **[SageMaker Painel do modelo](https://docs.aws.amazon.com/sagemaker/latest/dg/model-dashboard.html)** — Você pode ativar o monitoramento em endpoints selecionando um modelo que foi implantado em um endpoint. Na captura de tela a seguir do console de SageMaker IA, um modelo chamado `group1` foi selecionado na seção **Modelos** do **painel Modelo**. Nessa página, você pode criar uma programação de monitoramento e editar, ativar ou desativar as programações e alertas de monitoramento existentes. Para obter um guia passo a passo sobre como visualizar alertas e programações de monitores de modelos, consulte [Exibir programações e alertas do Model Monitor](https://docs.aws.amazon.com/sagemaker/latest/dg/model-dashboard-schedule.html). ![\[Captura de tela do painel de modelos, mostrando a opção de criar uma programação de monitoramento.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-monitoring-faqs-screenshot.png) **P: Como o Model Monitor se integra ao SageMaker Model Dashboard** SageMaker O [Model Dashboard](https://docs.aws.amazon.com/sagemaker/latest/dg/model-dashboard.html) oferece monitoramento unificado em todos os seus modelos, fornecendo alertas automatizados sobre desvios do comportamento esperado e solução de problemas para inspecionar modelos e analisar fatores que afetam o desempenho do modelo ao longo do tempo.