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á.
# Governança de modelos para gerenciar permissões e monitorar o desempenho do modelo
A governança de modelos é uma estrutura que fornece visibilidade sistemática do desenvolvimento, validação e uso de modelos de machine learning (ML). A Amazon SageMaker AI fornece ferramentas específicas de governança de ML para gerenciar controle, acesso, rastreamento de atividades e relatórios em todo o ciclo de vida do ML.
Gerencie permissões com privilégios mínimos para profissionais de ML usando o Amazon SageMaker Role Manager, crie documentação detalhada do modelo usando Amazon Model Cards e ganhe visibilidade de seus modelos com painéis centralizados usando o Amazon SageMaker Model Dashboard. SageMaker
## Gerente de SageMaker funções da Amazon
Com o Amazon SageMaker Role Manager, os administradores podem definir permissões de usuário com permissões de privilégio mínimo para atividades comuns de aprendizado de máquina. Use o Amazon SageMaker Role Manager para criar e gerenciar funções do IAM baseadas em personas específicas para suas necessidades comerciais.
Para obter mais informações, consulte [Gerente de SageMaker funções da Amazon](role-manager.md).
## Cartões SageMaker modelo Amazon
Use os Amazon SageMaker Model Cards para documentar, recuperar e compartilhar informações essenciais do modelo, desde a concepção até a implantação. Com os cartões de modelo, gerentes de riscos do modelo, cientistas de dados e engenheiros de ML podem criar um registro imutável dos usos pretendidos do modelo, classificações de risco, detalhes do treinamento, resultados da avaliação e muito mais.
Para obter mais informações, consulte [Cartões SageMaker modelo Amazon](model-cards.md).
## Painel de SageMaker modelos da Amazon
O Amazon SageMaker Model Dashboard é uma visão geral visual pré-criada de todos os modelos em sua conta. SageMaker O Model Dashboard integra informações valiosas do Amazon SageMaker Model Monitor, Transform Jobs, Endpoints, ML Lineage Tracking e Amazon CloudWatch para que você possa acessar informações de alto nível do modelo e acompanhar o desempenho do modelo em uma visão unificada.
Para obter mais informações, consulte [Painel de SageMaker modelos da Amazon](model-dashboard.md).
## SageMaker Ativos da Amazon
O Amazon SageMaker Assets é um novo fluxo de trabalho que simplifica a governança de ML. Ele permite que os usuários publiquem, compartilhem e assinem com facilidade ativos de ML e ativos de dados, como grupos de atributos e tabelas do Amazon Redshift.
Os administradores usam DataZone a Amazon para configurar os bancos de dados e a infraestrutura de ML para que os usuários compartilhem ativos no Amazon SageMaker Studio. Após a configuração, os usuários podem compartilhar os ativos entre si, sem sobrecarga adicional do administrador. Para obter mais informações sobre Amazon SageMaker Assets, consulte[Acesso controlado aos ativos com o Amazon SageMaker Assets](sm-assets.md).
# Cartões SageMaker modelo Amazon
**Importante**
O Amazon SageMaker Model Card é integrado ao SageMaker Model Registry. Se você estiver registrando um modelo no Model Registry, poderá usar a integração para adicionar informações de auditoria. Para obter mais informações, consulte [Atualizar os detalhes de uma versão do modelo](model-registry-details.md).
Use os Amazon SageMaker Model Cards para documentar detalhes críticos sobre seus modelos de aprendizado de máquina (ML) em um único local para simplificar a governança e a geração de relatórios. Os cartões de modelo podem ajudá-lo a capturar informações importantes sobre seus modelos em todo o ciclo de vida e a implementar práticas de IA responsável.
Detalhes do catálogo, como o uso pretendido e a classificação de risco de um modelo, detalhes e métricas de treinamento, resultados e observações da avaliação e explicações adicionais, como considerações, recomendações e informações personalizadas. Ao criar cartões de modelo, você pode fazer o seguinte:
+ Fornecer orientação sobre como um modelo deve ser usado.
+ Dar compatibilidade com atividades de auditoria com descrições detalhadas do treinamento e performance do modelo.
+ Comunique como um modelo se destina a apoiar as metas de negócios.
Os cartões de modelo fornecem orientação prescritiva sobre quais informações documentar e incluem campos para informações personalizadas. Após criar um modelo de cartão, você pode exportá-lo para um PDF ou baixá-lo para compartilhar com as partes interessadas relevantes. Qualquer edição que não seja uma atualização do status da aprovação feita em um cartão de modelo resultará em versões adicionais do cartão de modelo para ter um registro imutável das alterações do modelo.
**Topics**
+ [Pré-requisitos](#model-cards-prerequisites)
+ [Usos pretendidos de um modelo](#model-cards-intended-uses)
+ [Classificações de risco](#model-cards-risk-rating)
+ [Esquema JSON de cartões de modelo](#model-cards-json-schema)
+ [Criar um cartão de modelo](model-cards-create.md)
+ [Cartões de modelo](model-cards-manage.md)
+ [Configure o suporte entre contas para Amazon SageMaker Model Cards](model-cards-xaccount.md)
+ [Nível baixo SageMaker APIs para cartões de modelo](model-cards-apis.md)
+ [Cartão modelo FAQs](model-cards-faqs.md)
## Pré-requisitos
Para começar a usar os cartões SageMaker modelo da Amazon, você deve ter permissão para criar, editar, visualizar e exportar cartões modelo.
## Usos pretendidos de um modelo
Especificar os usos pretendidos de um modelo ajuda a garantir que os desenvolvedores e usuários do modelo tenham as informações necessárias para treinar ou implantar o modelo com responsabilidade. Os usos pretendidos de um modelo devem descrever os cenários nos quais o modelo é apropriado para uso, bem como os cenários nos quais o modelo não é recomendado.
Recomendamos incluir:
+ O propósito geral do modelo
+ Casos de uso para os quais o modelo foi destinado
+ Casos de uso para os quais o modelo não foi projetado
+ Suposições feitas ao desenvolver o modelo
Os usos pretendidos de um modelo vão além dos detalhes técnicos e descrevem como um modelo deve ser usado na produção, os cenários nos quais é apropriado usar um modelo e considerações adicionais, como o tipo de dados a ser usado com o modelo ou quaisquer suposições feitas durante o desenvolvimento.
## Classificações de risco
Os desenvolvedores criam modelos de ML para casos de uso com níveis variados de risco. Por exemplo, um modelo que aprova pedidos de empréstimo pode ser um modelo de maior risco do que aquele que detecta a categoria de um e-mail. Dados os diversos perfis de risco de um modelo, os cartões de modelo fornecem um campo para você categorizar a classificação de risco de um modelo.
Essa classificação de risco pode ser `unknown`, `low`, `medium` ou `high`. Use esses campos de classificação de risco para rotular modelos desconhecidos, de baixo, médio ou alto risco e ajudar sua organização a cumprir todas as regras existentes sobre a colocação de determinados modelos em produção.
## Esquema JSON de cartões de modelo
Os detalhes da avaliação de um cartão de modelo devem ser fornecidos no formato JSON. Se você já tiver relatórios de avaliação no formato JSON gerados pelo [SageMaker Clarify](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-processing-job-run.html) ou pelo [SageMaker AI Model Monitor](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-model-quality.html), faça o upload deles para o Amazon S3 e forneça um URI do S3 para analisar automaticamente as métricas de avaliação. Para obter mais informações e exemplos de relatórios, consulte a pasta de [métricas de exemplo](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker_model_governance/example_metrics) no caderno de exemplos de *Amazon SageMaker Model Governance - Model Cards*.
Ao criar um cartão modelo usando o SDK do SageMaker Python, o conteúdo do modelo deve estar no esquema JSON do cartão modelo e ser fornecido como uma string. Forneça conteúdo de modelo semelhante ao seguinte exemplo:
### Arquivo de amostra do esquema JSON do cartão de modelo
```
{
"$schema": "http://json-schema.org/draft-07/schema#",
"$id": "http://json-schema.org/draft-07/schema#",
"title": "SageMakerModelCardSchema",
"description": "Internal model card schema for SageMakerRepositoryService without model_package_details",
"version": "0.1.0",
"type": "object",
"additionalProperties": false,
"properties": {
"model_overview": {
"description": "Overview about the model",
"type": "object",
"additionalProperties": false,
"properties": {
"model_description": {
"description": "description of model",
"type": "string",
"maxLength": 1024
},
"model_creator": {
"description": "Creator of model",
"type": "string",
"maxLength": 1024
},
"model_artifact": {
"description": "Location of the model artifact",
"type": "array",
"maxContains": 15,
"items": {
"type": "string",
"maxLength": 1024
}
},
"algorithm_type": {
"description": "Algorithm used to solve the problem",
"type": "string",
"maxLength": 1024
},
"problem_type": {
"description": "Problem being solved with the model",
"type": "string"
},
"model_owner": {
"description": "Owner of model",
"type": "string",
"maxLength": 1024
}
}
},
"intended_uses": {
"description": "Intended usage of model",
"type": "object",
"additionalProperties": false,
"properties": {
"purpose_of_model": {
"description": "Why the model was developed?",
"type": "string",
"maxLength": 2048
},
"intended_uses": {
"description": "intended use cases",
"type": "string",
"maxLength": 2048
},
"factors_affecting_model_efficiency": {
"type": "string",
"maxLength": 2048
},
"risk_rating": {
"description": "Risk rating for model card",
"$ref": "#/definitions/risk_rating"
},
"explanations_for_risk_rating": {
"type": "string",
"maxLength": 2048
}
}
},
"business_details": {
"description": "Business details of model",
"type": "object",
"additionalProperties": false,
"properties": {
"business_problem": {
"description": "What business problem does the model solve?",
"type": "string",
"maxLength": 2048
},
"business_stakeholders": {
"description": "Business stakeholders",
"type": "string",
"maxLength": 2048
},
"line_of_business": {
"type": "string",
"maxLength": 2048
}
}
},
"training_details": {
"description": "Overview about the training",
"type": "object",
"additionalProperties": false,
"properties": {
"objective_function": {
"description": "the objective function the model will optimize for",
"function": {
"$ref": "#/definitions/objective_function"
},
"notes": {
"type": "string",
"maxLength": 1024
}
},
"training_observations": {
"type": "string",
"maxLength": 1024
},
"training_job_details": {
"type": "object",
"additionalProperties": false,
"properties": {
"training_arn": {
"description": "SageMaker Training job arn",
"type": "string",
"maxLength": 1024
},
"training_datasets": {
"description": "Location of the model datasets",
"type": "array",
"maxContains": 15,
"items": {
"type": "string",
"maxLength": 1024
}
},
"training_environment": {
"type": "object",
"additionalProperties": false,
"properties": {
"container_image": {
"description": "SageMaker training image uri",
"type": "array",
"maxContains": 15,
"items": {
"type": "string",
"maxLength": 1024
}
}
}
},
"training_metrics": {
"type": "array",
"items": {
"maxItems": 50,
"$ref": "#/definitions/training_metric"
}
},
"user_provided_training_metrics": {
"type": "array",
"items": {
"maxItems": 50,
"$ref": "#/definitions/training_metric"
}
},
"hyper_parameters": {
"type": "array",
"items": {
"maxItems": 100,
"$ref": "#/definitions/training_hyper_parameter"
}
},
"user_provided_hyper_parameters": {
"type": "array",
"items": {
"maxItems": 100,
"$ref": "#/definitions/training_hyper_parameter"
}
}
}
}
}
},
"evaluation_details": {
"type": "array",
"default": [],
"items": {
"type": "object",
"required": [
"name"
],
"additionalProperties": false,
"properties": {
"name": {
"type": "string",
"pattern": ".{1,63}"
},
"evaluation_observation": {
"type": "string",
"maxLength": 2096
},
"evaluation_job_arn": {
"type": "string",
"maxLength": 256
},
"datasets": {
"type": "array",
"items": {
"type": "string",
"maxLength": 1024
},
"maxItems": 10
},
"metadata": {
"description": "additional attributes associated with the evaluation results",
"type": "object",
"additionalProperties": {
"type": "string",
"maxLength": 1024
}
},
"metric_groups": {
"type": "array",
"default": [],
"items": {
"type": "object",
"required": [
"name",
"metric_data"
],
"properties": {
"name": {
"type": "string",
"pattern": ".{1,63}"
},
"metric_data": {
"type": "array",
"items": {
"anyOf": [
{
"$ref": "#/definitions/simple_metric"
},
{
"$ref": "#/definitions/linear_graph_metric"
},
{
"$ref": "#/definitions/bar_chart_metric"
},
{
"$ref": "#/definitions/matrix_metric"
}
]
}
}
}
}
}
}
}
},
"additional_information": {
"additionalProperties": false,
"type": "object",
"properties": {
"ethical_considerations": {
"description": "Any ethical considerations that the author wants to provide",
"type": "string",
"maxLength": 2048
},
"caveats_and_recommendations": {
"description": "Caveats and recommendations for people who might use this model in their applications.",
"type": "string",
"maxLength": 2048
},
"custom_details": {
"type": "object",
"additionalProperties": {
"$ref": "#/definitions/custom_property"
}
}
}
}
},
"definitions": {
"source_algorithms": {
"type": "array",
"minContains": 1,
"maxContains": 1,
"items": {
"type": "object",
"additionalProperties": false,
"required": [
"algorithm_name"
],
"properties": {
"algorithm_name": {
"description": "The name of an algorithm that was used to create the model package. The algorithm must be either an algorithm resource in your SageMaker account or an algorithm in AWS Marketplace that you are subscribed to.",
"type": "string",
"maxLength": 170
},
"model_data_url": {
"description": "The Amazon S3 path where the model artifacts, which result from model training, are stored.",
"type": "string",
"maxLength": 1024
}
}
}
},
"inference_specification": {
"type": "object",
"additionalProperties": false,
"required": [
"containers"
],
"properties": {
"containers": {
"description": "Contains inference related information which were used to create model package.",
"type": "array",
"minContains": 1,
"maxContains": 15,
"items": {
"type": "object",
"additionalProperties": false,
"required": [
"image"
],
"properties": {
"model_data_url": {
"description": "The Amazon S3 path where the model artifacts, which result from model training, are stored.",
"type": "string",
"maxLength": 1024
},
"image": {
"description": "Inference environment path. The Amazon EC2 Container Registry (Amazon ECR) path where inference code is stored.",
"type": "string",
"maxLength": 255
},
"nearest_model_name": {
"description": "The name of a pre-trained machine learning benchmarked by Amazon SageMaker Inference Recommender model that matches your model.",
"type": "string"
}
}
}
}
}
},
"risk_rating": {
"description": "Risk rating of model",
"type": "string",
"enum": [
"High",
"Medium",
"Low",
"Unknown"
]
},
"custom_property": {
"description": "Additional property in section",
"type": "string",
"maxLength": 1024
},
"objective_function": {
"description": "objective function that training job is optimized for",
"additionalProperties": false,
"properties": {
"function": {
"type": "string",
"enum": [
"Maximize",
"Minimize"
]
},
"facet": {
"type": "string",
"maxLength": 63
},
"condition": {
"type": "string",
"maxLength": 63
}
}
},
"training_metric": {
"description": "training metric data",
"type": "object",
"required": [
"name",
"value"
],
"additionalProperties": false,
"properties": {
"name": {
"type": "string",
"pattern": ".{1,255}"
},
"notes": {
"type": "string",
"maxLength": 1024
},
"value": {
"type": "number"
}
}
},
"training_hyper_parameter": {
"description": "training hyper parameter",
"type": "object",
"required": [
"name"
],
"additionalProperties": false,
"properties": {
"name": {
"type": "string",
"pattern": ".{1,255}"
},
"value": {
"type": "string",
"pattern": ".{0,255}"
}
}
},
"linear_graph_metric": {
"type": "object",
"required": [
"name",
"type",
"value"
],
"additionalProperties": false,
"properties": {
"name": {
"type": "string",
"pattern": ".{1,255}"
},
"notes": {
"type": "string",
"maxLength": 1024
},
"type": {
"type": "string",
"enum": [
"linear_graph"
]
},
"value": {
"anyOf": [
{
"type": "array",
"items": {
"type": "array",
"items": {
"type": "number"
},
"minItems": 2,
"maxItems": 2
},
"minItems": 1
}
]
},
"x_axis_name": {
"$ref": "#/definitions/axis_name_string"
},
"y_axis_name": {
"$ref": "#/definitions/axis_name_string"
}
}
},
"bar_chart_metric": {
"type": "object",
"required": [
"name",
"type",
"value"
],
"additionalProperties": false,
"properties": {
"name": {
"type": "string",
"pattern": ".{1,255}"
},
"notes": {
"type": "string",
"maxLength": 1024
},
"type": {
"type": "string",
"enum": [
"bar_chart"
]
},
"value": {
"anyOf": [
{
"type": "array",
"items": {
"type": "number"
},
"minItems": 1
}
]
},
"x_axis_name": {
"$ref": "#/definitions/axis_name_array"
},
"y_axis_name": {
"$ref": "#/definitions/axis_name_string"
}
}
},
"matrix_metric": {
"type": "object",
"required": [
"name",
"type",
"value"
],
"additionalProperties": false,
"properties": {
"name": {
"type": "string",
"pattern": ".{1,255}"
},
"notes": {
"type": "string",
"maxLength": 1024
},
"type": {
"type": "string",
"enum": [
"matrix"
]
},
"value": {
"anyOf": [
{
"type": "array",
"items": {
"type": "array",
"items": {
"type": "number"
},
"minItems": 1,
"maxItems": 20
},
"minItems": 1,
"maxItems": 20
}
]
},
"x_axis_name": {
"$ref": "#/definitions/axis_name_array"
},
"y_axis_name": {
"$ref": "#/definitions/axis_name_array"
}
}
},
"simple_metric": {
"description": "metric data",
"type": "object",
"required": [
"name",
"type",
"value"
],
"additionalProperties": false,
"properties": {
"name": {
"type": "string",
"pattern": ".{1,255}"
},
"notes": {
"type": "string",
"maxLength": 1024
},
"type": {
"type": "string",
"enum": [
"number",
"string",
"boolean"
]
},
"value": {
"anyOf": [
{
"type": "number"
},
{
"type": "string",
"maxLength": 63
},
{
"type": "boolean"
}
]
},
"x_axis_name": {
"$ref": "#/definitions/axis_name_string"
},
"y_axis_name": {
"$ref": "#/definitions/axis_name_string"
}
}
},
"axis_name_array": {
"type": "array",
"items": {
"type": "string",
"maxLength": 63
}
},
"axis_name_string": {
"type": "string",
"maxLength": 63
}
}
}
```
# Criar um cartão de modelo
**Importante**
Políticas personalizadas do IAM que permitem que o Amazon SageMaker SageMaker Studio ou o Amazon Studio Classic criem SageMaker recursos da Amazon também devem conceder permissões para adicionar tags a esses recursos. A permissão para adicionar tags aos recursos é necessária porque o Studio e o Studio Classic marcam automaticamente todos os recursos que eles criam. Se uma política do IAM permitir que o Studio e o Studio Classic criem recursos, mas não permitisse a marcação, erros AccessDenied "" podem ocorrer ao tentar criar recursos. Para obter mais informações, consulte [Forneça permissões para marcar recursos de SageMaker IA](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS políticas gerenciadas para Amazon SageMaker AI](security-iam-awsmanpol.md)que dão permissões para criar SageMaker recursos já incluem permissões para adicionar tags ao criar esses recursos.
Você pode criar um Amazon SageMaker Model Card usando o console SageMaker AI ou o SageMaker Python SDK. Também é possível usar as operações da API diretamente. Para obter mais informações sobre as operações de API, consulte [Nível baixo SageMaker APIs para cartões de modelo](model-cards-apis.md).
## Crie um cartão modelo usando o console de SageMaker IA
Acesse o console Amazon SageMaker AI. No painel de navegação, em **Governança**, escolha **Cartões de modelo**. No canto superior direito, escolha **Criar cartão de modelo**.
Siga as quatro etapas no prompt **Criar cartão de modelo** para documentar detalhes sobre seu modelo.
### Etapa 1: insira os detalhes do modelo e o uso pretendido
Se seu modelo for um AWS recurso, especifique o nome exato do modelo nesse campo para preencher automaticamente os detalhes do modelo. Para pesquisar nomes de modelos existentes, consulte **Modelos** no console Amazon SageMaker AI. Cada nome de modelo exclusivo pode ter somente um cartão de modelo associada.
Se seu modelo não for um AWS recurso, forneça um nome exclusivo para seu modelo. Para adicionar um modelo como AWS recurso, consulte [Criar um modelo](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html#realtime-endpoints-deployment-create-model) no *Amazon SageMaker AI Developer Guide*. Como alternativa, você pode adicionar seu modelo como um pacote de modelos usando o [SageMaker AI Marketplace](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-marketplace.html) ou o [SageMaker AI Model Registry](https://docs.aws.amazon.com/sagemaker/latest/dg/model-registry.html).
Para obter mais informações sobre os usos pretendidos, consulte [Usos pretendidos de um modelo](model-cards.md#model-cards-intended-uses). Para obter mais informações sobre classificações de risco, consulte [Classificações de risco](model-cards.md#model-cards-risk-rating).
#### Etapa 2: Inserir detalhes do treinamento
Adicione os detalhes de treinamento, observações de treinamento, conjuntos de dados, hiperparâmetros e detalhes sobre a função objetiva do modelo ao cartão de modelo.
A função objetiva em um cartão de modelo pode ser qualquer função otimizada durante o treinamento. Isso pode incluir, mas não está limitado a, funções de custo, funções de perda ou métricas objetivas. Nesta seção, documente a função objetiva que é mais crítica para treinar seu modelo.
Recomendamos que você catalogue os seguintes atributos da sua função objetiva:
+ Direção de otimização
+ Métrica
+ Description
Por exemplo, você pode minimizar (direção de otimização) a perda de entropia cruzada (métrica) para um problema de classificação binária (descrição) ou maximizar a probabilidade de regressão logística. Além disso, você pode fornecer notas sobre por que escolheu essa função objetiva em vez de outras.
#### Etapa 3: Inserir detalhes da avaliação
Se você tiver relatórios de avaliação existentes gerados pelo SageMaker Clarify ou pelo Model Monitor, forneça um URI do S3 para esses relatórios ou carregue-os manualmente para adicioná-los ao cartão modelo.
Para obter mais informações sobre o SageMaker Clarify, consulte [Executar trabalhos de processamento do SageMaker Clarify para análise de viés e explicabilidade](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-processing-job-run.html).
Para obter mais informações sobre como monitorar o desvio nas métricas de qualidade do modelo usando o Model Monitor, consulte [Monitorar a qualidade do modelo](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-model-quality.html).
Para adicionar seu próprio relatório de avaliação, escolha **Avaliação do cartão de modelo genérico**. Todos os relatórios de avaliação do cartão de modelo devem estar no [Esquema JSON de cartões de modelo](model-cards.md#model-cards-json-schema).
#### Etapa 4: Inserir detalhes adicionais
Adicione campos personalizados de detalhes do cartão de modelo para qualquer informação adicional que você queira abordar no seu cartão de modelo. Por exemplo, você pode incluir o campo personalizado *Linha de negócios* com um valor de *Finanças pessoais*.
#### Salvar modelo de cartão
Após revisar as informações em seu cartão de modelo, escolha **Salvar** no canto inferior direito para salvar seu cartão de modelo.
## Crie um cartão modelo usando o SDK do SageMaker Python
Antes de criar um cartão de modelo, você deve primeiro definir o conteúdo do seu cartão de modelo. Ao usar o SDK do SageMaker Python, o conteúdo do modelo consiste em uma visão geral do modelo, detalhes do treinamento, usos pretendidos, detalhes da avaliação e informações adicionais.
Você pode criar cartões de modelo para:
+ Modelos hospedados na SageMaker IA
+ Pacotes de modelos (modelos) dentro do Registro de SageMaker Modelos
+ Modelos hospedados ou registrados fora da SageMaker IA
Você também pode criar cartões de modelo sem associar nenhum modelo a eles.
Recomendamos adicionar os modelos que você treinou ao Registro de SageMaker modelos. O registro do modelo ajuda você a catalogar modelos e rastrear versões de modelos. Quando você cria um cartão de modelo, as informações sobre o modelo do registro do modelo preenchem automaticamente o cartão de modelo. Você pode editar o cartão de modelo ou adicionar informações a ele após criá-lo.
Para obter mais informações sobre registro do modelo, consulte [Implantação do registro do modelo com o Model Registry](model-registry.md). Para obter informações sobre como criar um cartão de modelo a partir de um registro do modelo, consulte [Crie um cartão de modelo para seu SageMaker modelo no Registro de modelos](#model-cards-sdk-create-model-registry).
**nota**
Para usar cartões modelo com o SDK do SageMaker Python, primeiro você precisa estabelecer uma SageMaker sessão de IA. Para obter mais informações, consulte [Session](https://sagemaker.readthedocs.io/en/stable/api/utility/session.html) na referência da SageMaker API Python SDK.
Para criar um cartão de modelo para modelos que não estão no Registro de SageMaker modelos, consulte[Criar um modelo que não está no registro do modelo](#model-card-sdk-create-model-non-model-registry).
### Criar um modelo que não está no registro do modelo
Use as informações nas seções a seguir para criar um cartão de modelo para um modelo que você não adicionou ao registro do modelo.
#### Etapa 1: Definir a visão geral do modelo
Defina uma visão geral do seu modelo.
```
model_overview = ModelOverview.from_model_name(
model_name=model_name,
sagemaker_session=sagemaker_session,
model_description="A-description-of-your-model",
problem_type="Problem-type", # For example, "Binary Classification"
algorithm_type="Algorithm-type", # For example, "Logistic Regression"
model_creator="Name-of-model-creator",
model_owner="Name-of-model-owner",
)
```
Se seu modelo for um AWS recurso, as informações gerais, como o ARN do modelo, o URI do contêiner de inferência e a localização dos artefatos do modelo no S3, poderão ser recuperadas automaticamente. Imprima os AWS metadados associados com os seguintes comandos:
```
print(model_overview.model_id)
print(model_overview.inference_environment.container_image)
print(model_overview.model_artifact)
```
#### Etapa 2: Definir detalhes do treinamento
Para definir os detalhes de treinamento do seu modelo, você deve primeiro definir sua função objetiva.
```
objective_function = ObjectiveFunction(
function=Function(
function=ObjectiveFunctionEnum.MINIMIZE,
facet=FacetEnum.LOSS,
),
notes="An-explanation-about-objective-function",
)
```
Em seguida, você pode definir os detalhes do treinamento usando a visão geral do modelo, a sessão e a função objetiva existentes. Adicione todas as observações de treinamento aqui.
```
training_details = TrainingDetails.from_model_overview(
model_overview=model_overview,
sagemaker_session=sagemaker_session,
objective_function=objective_function,
training_observations="Model-training-observations",
)
```
Mais uma vez, se seu modelo for um AWS recurso, certos detalhes do treinamento serão preenchidos automaticamente. Imprima o ARN do trabalho de treinamento, o URI do contêiner de treinamento e as métricas de treinamento com os seguintes comandos:
```
print(training_details.training_job_details.training_arn)
print(training_details.training_job_details.training_environment.container_image)
print([{"name": i.name, "value": i.value} for i in training_details.training_job_details.training_metrics])
```
#### Definir detalhes da avaliação
Para definir os detalhes da avaliação do seu modelo, você deve primeiro definir um ou mais grupos de métricas para descrever as métricas usadas em qualquer tarefa de avaliação.
```
my_metric_group = MetricGroup(
name="binary classification metrics",
metric_data=[Metric(name="accuracy", type=MetricTypeEnum.NUMBER, value=0.5)]
)
```
Em seguida, você pode definir os detalhes da avaliação usando métricas de avaliação e os conjuntos de dados para cada trabalho de avaliação. Adicione todas as observações de avaliação aqui e dê um nome exclusivo ao seu trabalho de avaliação.
```
evaluation_details = [
EvaluationJob(
name="Example-evaluation-job",
evaluation_observation="Evaluation-observations",
datasets=["s3://path/to/evaluation/data"],
metric_groups=[my_metric_group],
)
]
```
Se você tiver relatórios de avaliação existentes gerados pelo [SageMaker AI Clarify](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-processing-job-run.html) ou pelo [SageMaker AI Model Monitor](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-model-quality.html), faça o upload deles para o Amazon S3 e forneça um URI do S3 para analisar automaticamente as métricas de avaliação. Para adicionar seu próprio relatório genérico de avaliação do cartão de modelo, forneça um relatório no [formato JSON dos resultados da avaliação](https://docs.aws.amazon.com/sagemaker/latest/dg/model-cards-json-schema.html).
```
report_type = "clarify_bias.json"
example_evaluation_job.add_metric_group_from_json(
f"example_metrics/{report_type}", EvaluationMetricTypeEnum.CLARIFY_BIAS
)
```
#### Etapa 3: Definir usos pretendidos
Defina os usos pretendidos do modelo, incluindo o propósito geral do modelo e os casos de uso para os quais ele foi destinado. Também é recomendável incluir quaisquer fatores que possam afetar a eficácia desse modelo em um caso de uso específico e a classificação de risco do modelo da sua organização. Para ter mais informações, consulte [Usos pretendidos de um modelo](model-cards.md#model-cards-intended-uses) e [Classificações de risco](model-cards.md#model-cards-risk-rating).
```
intended_uses = IntendedUses(
purpose_of_model="Purpose-of-the-model",
intended_uses="The-intended-uses-of-this-model",
factors_affecting_model_efficiency="Any-factors-effecting-model-efficacy",
risk_rating=RiskRatingEnum.LOW,
explanations_for_risk_rating="Explanation-for-low-risk-rating",
)
```
#### Definir informações adicionais
Por fim, você pode adicionar informações personalizadas adicionais ao seu modelo de cartão. Você pode documentar quaisquer considerações éticas, advertências e recomendações sobre o modelo. Você também pode adicionar quaisquer detalhes personalizados na forma de pares chave-valor.
```
additional_information = AdditionalInformation(
ethical_considerations="Any-ethical-considerations",
caveats_and_recommendations="Any-caveats-and-recommendations",
custom_details={"custom details1": "details-value"},
)
```
#### Etapa 4: Criar cartão de modelo
Nomeie seu cartão modelo, defina um cartão modelo e use essa definição para criar um cartão modelo usando o SDK do SageMaker Python.
```
model_card_name = "my-model-card"
my_card = ModelCard(
name=model_card_name,
status=ModelCardStatusEnum.DRAFT,
model_overview=model_overview,
training_details=training_details,
intended_uses=intended_uses,
evaluation_details=evaluation_details,
additional_information=additional_information,
sagemaker_session=sagemaker_session,
)
my_card.create()
```
### Crie um cartão de modelo para seu SageMaker modelo no Registro de modelos
Antes de começar a criar um cartão de modelo, verifique se você criou um grupo de pacotes de modelos e um pacote de modelos. Para obter mais informações sobre o uso do registro do modelo, consulte [Implantação do registro do modelo com o Model Registry](model-registry.md).
**Importante**
Você deve ter permissões para usar as operações no Registro de SageMaker Modelos. Recomendamos o uso de políticas `AmazonSageMakerModelRegistryFullAccess` AWS gerenciadas. Para saber mais sobre a política gerenciada , consulte [AWS Políticas gerenciadas para registro de modelos](security-iam-awsmanpol-model-registry.md).
Use o SDK do SageMaker Python para criar uma placa de modelo para um pacote de modelo no Registro de modelos. SageMaker Um pacote de modelos é um modelo que você treinou. Quando você cria um cartão modelo, o Amazon SageMaker Model Cards importa automaticamente os dados do pacote do modelo para o cartão modelo.
Quando você cria um cartão modelo para um pacote modelo, o Amazon SageMaker Model Card usa a [DescribeModelPackage](https://docs.aws.amazon.com/APIReference/API_DescribeModelPackage.html#API_DescribeModelPackage_ResponseSyntax)operação para adicionar os dados do pacote modelo ao cartão modelo. Veja a seguir exemplos dos campos que podem ser importados de um pacote de modelo para um cartão de modelo:
+ [ModelDataUrl](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelPackageContainerDefinition.html#sagemaker-Type-ModelPackageContainerDefinition-ModelDataUrl)
+ [ModelPackageDescription](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeModelPackage.html#sagemaker-DescribeModelPackage-response-ModelPackageDescription)
+ [ModelPackageGroupName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeModelPackage.html#sagemaker-DescribeModelPackage-response-ModelPackageGroupName)
+ [ModelPackageStatus](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeModelPackage.html#sagemaker-DescribeModelPackage-response-ModelPackageStatus)
+ [ModelPackageVersion](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeModelPackage.html#sagemaker-DescribeModelPackage-response-ModelPackageVersion)
Use o código a seguir para definir o pacote de modelos e criar um cartão de modelo a partir dele:
```
mp_details = ModelPackage.from_model_package_arn(
model_package_arn="example_model_package_arn",
sagemaker_session=sagemaker_session,
)
model_card_name = "example-model-card"
my_card = ModelCard(
name=model_card_name,
status=ModelCardStatusEnum.status,
model_package_details=mp_details,
sagemaker_session=sagemaker_session,
)
my_card.create()
```
Para `status`, você está especificando o status da aprovação do modelo de cartão. Se você não especificar um status, os cartões de SageMaker modelo usarão o valor padrão de`DRAFT`. Se você não especificar uma sessão de SageMaker IA, os SageMaker Model Cards usarão a sessão de SageMaker IA padrão.
É necessário especificar um nome para o modelo e o nome do recurso da Amazon (ARN) do pacote de modelos. Para obter informações sobre como obter o Nome do recurso da Amazon (ARN) para o pacote de modelos, consulte [Visualizar e atualizar os detalhes de uma versão do modelo (Boto3)](model-registry-details.md#model-registry-details-api).
O cartão de modelo que você criou a partir do pacote do modelo pode ter informações ausentes ou imprecisas. Você pode adicionar informações ao cartão de modelo ou editá-lo. Para obter mais informações sobre o gerenciamento de seus cartões de modelo, consulte [Cartões de modelo](model-cards-manage.md).
SageMaker O Model Registry suporta o controle de versão de seus pacotes de modelos. Você pode criar uma versão do pacote do modelo e criar um cartão de modelo para cada versão. As informações dos cartões de modelo das versões anteriores são transferidas para os cartões de modelo criados a partir das versões subsequentes. Por exemplo, você pode ter a versão 1, a versão 2 e a versão 3 de um pacote de modelos. Suponha que você já tenha criado um cartão de modelo para a versão 1, mas não tenha criado um para a versão 2. Se você criar um cartão modelo para a versão 3, os Amazon SageMaker Model Cards transferirão automaticamente as informações do cartão modelo da versão 1 para o cartão modelo da versão 3.
**nota**
Você também pode criar cartões de modelo para pacotes de modelos que não usam versionamento. No entanto, a maioria dos fluxos de trabalho de machine learning envolve várias versões do mesmo modelo, por isso recomendamos fazer o seguinte:
Criar uma versão para cada pacote de modelos
Criar um cartão de modelo para cada versão do pacote de modelos
# Cartões de modelo
Após criar um modelo de cartão, você pode gerenciá-lo. O gerenciamento dos cartões de modelo inclui as seguintes ações:
+ Editar um cartão de modelo
+ Excluir um cartão de modelo
+ Exportação de um modelo de cartão para um PDF
Você pode gerenciar usando o console Amazon SageMaker AI ou o SageMaker Python SDK. Para obter mais informações sobre o uso do SDK do Python, consulte [Amazon SageMaker Model Cards na referência da API](https://sagemaker.readthedocs.io/en/stable/api/governance/model_card.html) do SDK do SageMaker Python.
Por exemplo, notebook usando o SageMaker Python SDK, consulte o notebook de exemplo *[Amazon SageMaker Model Governance - Model Card](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker_model_governance/model_card.ipynb)*.
**Topics**
+ [Editar um cartão de modelo](model-cards-console-edit.md)
+ [Exportar um cartão de modelo](model-cards-console-export.md)
+ [Excluir um cartão de modelo](model-cards-console-delete.md)
# Editar um cartão de modelo
Para editar um modelo de cartão, navegue até o modelo de cartão de sua escolha selecionando seu nome no console do Amazon SageMaker Model Card e escolha **Editar**.
Após salvar um cartão de modelo, não é possível editar o nome do cartão de modelo. Após salvar uma versão do cartão de modelo, você não pode atualizar essa versão do cartão de modelo. Todas as edições que você precisa fazer são salvas como uma versão subsequente para ter um registro imutável das alterações do modelo.
Para visualizar diferentes versões do cartão de modelo, escolha **Ações**, **Selecionar versão** e, em seguida, escolha a versão que você deseja visualizar.
Você pode editar um cartão de modelo usando o método `model_card.update()`. A atualização de um cartão de modelo cria uma nova versão do cartão de modelo para ter um registro imutável das alterações do modelo. Você não pode atualizar o nome de um cartão de modelo.
```
my_card.model_overview.model_description = "updated-model-decription"
my_card.update()
```
# Exportar um cartão de modelo
Siga estas etapas para exportar um modelo de cartão.
1. Acesse o console do Amazon SageMaker Model Card.
1. Escolha o nome do modelo de cartão que você quer exportar.
1. Na visão geral do cartão de modelo, escolha **Ações** e depois **Exportar PDF**.
1. Insira um URI do S3 ou procure os buckets do S3 disponíveis para o PDF do seu modelo de cartão.
1. Se seu modelo de cartão for exportado com sucesso, você pode escolher **Baixar PDF** no banner resultante ou baixar seu PDF diretamente do Amazon S3.
Você pode exportar um cartão modelo no SDK do SageMaker Python especificando um caminho de saída do S3 e exportando o PDF do cartão modelo para ele com os seguintes comandos:
```
s3_output_path = f"s3://{bucket}/{prefix}/export"
pdf_s3_url = my_card.export_pdf(s3_output_path=s3_output_path).delete()
```
# Excluir um cartão de modelo
Siga estas etapas para excluir permanentemente uma ou mais cartas-modelo.
1. Acesse o console Amazon SageMaker Model Cards.
1. Escolha a caixa à esquerda do nome do(s) cartão(ões) que você deseja excluir.
1. Escolha **Excluir** no canto superior direito.
1. Confirme sua solicitação para excluir permanentemente um ou mais cartões.
Você também pode excluir um cartão de modelo ao visualizar a visão geral do cartão de modelo no console, escolhendo **Ações** e, em seguida, **Excluir cartão de modelo**.
No SDK do SageMaker Python, você pode excluir permanentemente um cartão modelo com o seguinte comando:
```
my_card.delete()
```
# Configure o suporte entre contas para Amazon SageMaker Model Cards
Use o suporte entre contas nos Amazon SageMaker Model Cards para compartilhar modelos de cartões entre AWS contas. A conta na qual os cartões de modelo são criados é a *conta do cartão de modelo*. Os usuários na conta do cartão de modelo os compartilham com as *contas compartilhadas*. Os usuários em uma conta compartilhada podem atualizar os cartões modelo ou PDFs criá-los.
Os usuários na conta do cartão modelo compartilham seus cartões-modelo por meio de AWS Resource Access Manager (AWS RAM). AWS RAM ajuda você a compartilhar recursos entre AWS contas. Para obter uma introdução AWS RAM, consulte [O que é AWS Resource Access Manager?](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html)
A seguir está o processo para compartilhar cartões de modelo:
1. Um usuário na conta do cartão de modelo configura o compartilhamento do modelo de cartão entre contas usando o AWS Resource Access Manager.
1. Se os cartões modelo forem criptografados com AWS KMS chaves, o usuário que estiver configurando o compartilhamento de modelos também deverá fornecer AWS KMS permissões aos usuários da conta compartilhada.
1. Um usuário na conta compartilhada aceita o convite para o compartilhamento de recursos.
1. Um usuário na conta compartilhada fornece aos outros usuários permissões para acessar os cartões de modelo.
Se você for um usuário da conta do cartão de modelo, consulte as seguintes seções:
+ [Configurar compartilhamento de cartão de modelo entre contas](#model-cards-xaccount-set-up)
+ [Configurar AWS KMS permissões para a conta compartilhada](#model-cards-xaccount-kms)
+ [Receba respostas para seu convite de compartilhamento de recursos](#model-cards-xaccount-set-up-responses)
Se você for um usuário da conta compartilhada, consulte [Configurar permissões do usuário do IAM para a conta compartilhada](#model-cards-xaccount-shared-account-permissions) sobre como configurar permissões para si mesmo e para os outros usuários na conta.
## Configurar compartilhamento de cartão de modelo entre contas
Use AWS Resource Access Manager (AWS RAM) para conceder aos usuários da sua AWS conta acesso para visualizar ou atualizar modelos de cartões criados em uma AWS conta diferente.
Para configurar o compartilhamento de cartões de modelo, você deve criar um compartilhamento de recursos. Um compartilhamento de recursos especifica:
+ Os recursos que estão sendo compartilhados
+ Quem ou o que tem acesso aos recursos
+ Permissões gerenciadas para os recursos
Para obter mais informações sobre compartilhamentos de recursos, consulte [Termos e conceitos para AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-terms-and-concepts.html). Recomendamos dedicar algum tempo para entender o AWS RAM conceito antes de passar pelo processo de criação de um compartilhamento de recursos.
**Importante**
Você deve ter permissões para criar um compartilhamento de recursos. Para obter mais informações sobre permissões, consulte [Como AWS RAM funciona com o IAM](https://docs.aws.amazon.com/ram/latest/userguide/security-iam-policies.html).
Para procedimentos para criar um compartilhamento de recursos e informações adicionais sobre eles, consulte [Criar um compartilhamento de recursos](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-sharing.html#getting-started-sharing-create).
Ao passar pelo procedimento de criação de um compartilhamento de recursos, você especifica `sagemaker:ModelCard` como o tipo de recurso. Você também deve especificar o Amazon Resource Number (ARN) da política baseada em AWS RAM recursos. Você pode especificar a política padrão ou a política que tem permissões adicionais para criar um PDF do cartão de modelo.
Com a política padrão `AWSRAMPermissionSageMakerModelCards` baseada em recursos, os usuários na conta compartilhada têm permissões para realizar as seguintes operações:
+ [DescribeModelCard](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeModelCard.html)
+ [ListModelCardVersions](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListModelCardVersions.html)
+ [UpdateModelCard](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateModelCard.html)
Com a política `AWSRAMPermissionSageMakerModelCardsAllowExport` baseada em recursos, os usuários na conta compartilhada têm permissões para realizar todas as ações anteriores. Eles também têm permissões para criar um trabalho de exportação de cartão de modelo e descrevê-lo por meio das seguintes operações:
+ [CreateModelCardExportJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelCardExportJob.html)
+ [DescribeModelCardExportJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeModelCardExportJob.html)
Os usuários na conta compartilhada podem criar um trabalho de exportação para gerar um PDF de um cartão de modelo. Eles também podem descrever um trabalho de exportação que foi criado para encontrar o URI do Amazon S3 do PDF.
Cartões de modelo e trabalhos de exportação são recursos. A conta do cartão de modelo é proprietária dos trabalhos de exportação criados por um usuário na conta compartilhada. Por exemplo, um usuário na conta A compartilha o cartão de modelo X com a conta compartilhada B. Um usuário na conta B cria o trabalho de exportação Y para o cartão de modelo X que armazena a saída em um local do Amazon S3 especificado pelo usuário na conta B. Embora a conta B tenha criado a tarefa de exportação Y, ela pertence à conta A.
Cada AWS conta tem cotas de recursos. Para obter informações sobre cotas relacionadas a cartões modelo, consulte [endpoints e cotas do Amazon SageMaker AI](https://docs.aws.amazon.com/general/latest/gr/sagemaker.html#limits_sagemaker).
### Configurar AWS KMS permissões para a conta compartilhada
Se os cartões modelo que você está compartilhando tiverem sido criptografados com AWS Key Management Service chaves, você também precisará compartilhar o acesso às chaves com a conta compartilhada. Caso contrário, os usuários na conta compartilhada não poderá visualizar, atualizar ou exportar os cartões de modelo. Para obter uma visão geral de AWS KMS, consulte [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html).
Para fornecer AWS KMS permissões aos usuários na conta compartilhada, atualize sua política de chaves com a seguinte declaração:
```
{
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::shared-account-id::role/example-IAM-role"
]
},
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt",
]
"Resource": "arn:aws:kms:AWS-Region-of-model-card-account:model-card-account-id:key/AWS KMS-key-id"
"Condition": {
"Bool": {"kms:GrantIsForAWSResource": true },
"StringEquals": {
"kms:ViaService": [
"sagemaker.AWS-Region.amazonaws.com",
"s3.AWS-Region.amazonaws.com"
],
},
"StringLike": {
"kms:EncryptionContext:aws:sagemaker:model-card-arn": "arn:aws:sagemaker:AWS-Region:model-card-account-id:model-card/model-card-name"
}
}
}
```
A instrução anterior fornece aos usuários na conta compartilhada, as permissões `kms:Decrypt` e `kms:GenerateDataKey`. Com `kms:Decrypt`, os usuários podem decifrar os cartões do modelo. Com`kms:GenerateDataKey`, os usuários podem criptografar os cartões modelo que atualizam PDFs ou criam.
### Receba respostas para seu convite de compartilhamento de recursos
Após criar um compartilhamento de recursos, as contas compartilhadas que você especificou no compartilhamento de recursos recebem um convite para participar dele. Elas devem aceitar o convite para acessar os recursos.
Para obter informações sobre como aceitar um convite de compartilhamento de recursos, consulte [Usando AWS recursos compartilhados](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-shared.html) no *Guia do Usuário do AWS Resource Access Manager*.
### Configurar permissões do usuário do IAM para a conta compartilhada
As informações a seguir pressupõem que você aceitou o convite de compartilhamento de recursos da conta do cartão de modelo. Para obter mais informações sobre como aceitar um convite de compartilhamento de recursos, consulte [Usando AWS recursos compartilhados](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-shared.html).
Você e os outros usuários na sua conta usam um perfil do IAM para acessar os cartões de modelo compartilhados da conta do cartão de modelo. Use o modelo a seguir para alterar a política do perfil do IAM. Você pode modificar o modelo para seu próprio caso de uso.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:DescribeModelCard",
"sagemaker:UpdateModelCard",
"sagemaker:CreateModelCardExportJob",
"sagemaker:ListModelCardVersions",
"sagemaker:DescribeModelCardExportJob"
],
"Resource": [
"arn:aws:sagemaker:us-east-1:111122223333:model-card/example-model-card-name-0",
"arn:aws:sagemaker:us-east-1:111122223333:model-card/example-model-card-name-1/*"
]
},
{
"Effect": "Allow",
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket-storing-the-pdf-of-the-model-card/model-card-name/*"
}
]
}
```
------
Para acessar cartões modelo criptografados usando AWS KMS, você deve fornecer aos usuários da sua conta as seguintes AWS KMS permissões.
```
{
"Effect": "Allow",
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt",
],
"Resource": "arn:aws:kms:AWS-Region:AWS-account-id-where-the-model-card-is-created:key/AWS Key Management Service-key-id"
}
```
# Nível baixo SageMaker APIs para cartões de modelo
Você pode criar um Amazon SageMaker Model Card diretamente por meio da SageMaker API ou da interface de linha de AWS comando (AWS CLI).
**nota**
Ao criar um cartão modelo com o nível baixo APIs, o conteúdo deve estar no esquema JSON do cartão modelo e ser fornecido como uma string. Para obter mais informações, consulte [Esquema JSON de cartões de modelo](model-cards.md#model-cards-json-schema).
## SageMaker API
Use os seguintes comandos de SageMaker API para trabalhar com Amazon SageMaker Model Cards:
+ [CreateModelCard](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelCard.html)
+ [DescribeModelCard](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeModelCard.html)
+ [ListModelCards](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListModelCards.html)
+ [ListModelCardVersions](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListModelCardVersions.html)
+ [UpdateModelCard](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateModelCard.html)
+ [CreateModelCardExportJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelCardExportJob.html)
+ [DescribeModelCardExportJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeModelCardExportJob.html)
+ [ListModelCardExportJobs](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListModelCardExportJobs.html)
+ [DeleteModelCard](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModelCard.html)
## AWS CLI
Use os seguintes comandos da AWS CLI para trabalhar com os Amazon SageMaker Model Cards:
+ [create-model-card](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model-card.html)
+ [describe-model-card](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-model-card.html)
+ [list-model-cards](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/list-model-cards.html)
+ [list-model-card-versions](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/list-model-card-versions.html)
+ [update-model-card](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-model-card.html)
+ [create-model-card-export-emprego](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model-card-export-job.html)
+ [describe-model-card-export-emprego](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-model-card-export-job.html)
+ [list-model-card-export-empregos](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/list-model-card-export-jobs.html)
+ [delete-model-card](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-model-card.html)
# Cartão modelo FAQs
Consulte os seguintes itens de perguntas frequentes para obter respostas às perguntas mais frequentes sobre o Amazon SageMaker Model Card.
## P: O que é risco de modelo?
R: Você pode usar modelos para uma variedade de aplicações de negócios, desde a previsão de ataques cibernéticos e a aprovação de pedidos de empréstimo até a detecção da categoria de um e-mail. Cada um desses aplicações assume um nível de risco diferente. Por exemplo, detectar incorretamente um ataque cibernético tem um impacto nos negócios muito maior do que categorizar incorretamente um e-mail. Considerando esses perfis de risco variados de um modelo, você pode usar cartões de modelo para fornecer uma classificação de risco de `low`, `medium` ou `high` para um modelo. Se você não conhece o risco do seu modelo, pode definir o status como `unknown`. Os clientes são responsáveis por atribuir o perfil de risco para cada modelo. Com base na classificação de risco, as organizações podem ter regras diferentes para implantar esses modelos na produção. Para obter mais informações, consulte [Classificações de risco](model-cards.md#model-cards-risk-rating).
## P: Qual é o uso pretendido de um modelo?
O uso pretendido de um modelo descreve como você deve usar o modelo em suas aplicações de produção. Isso vai além dos requisitos técnicos, como o tipo de instância na qual você deve implantar um modelo e, em vez disso, se refere aos tipos de aplicações a serem criados com o modelo, aos cenários nos quais você pode esperar um desempenho razoável do modelo ou ao tipo de dados a ser usado com o modelo. Recomendamos fornecer essas informações no cartão de modelo para uma melhor governança do modelo. Você pode definir um tipo de especificação de modelo no campo de uso pretendido e garantir que os desenvolvedores e consumidores de modelos sigam essa especificação enquanto treinam e implantam seus modelos. Para obter mais informações, consulte [Usos pretendidos de um modelo](model-cards.md#model-cards-intended-uses).
## P: A SageMaker IA preenche automaticamente as informações na minha placa modelo?
Ao criar uma placa de modelo usando o SDK do SageMaker Python ou o AWS console, a SageMaker IA preenche automaticamente as informações sobre seu modelo treinado. Isso inclui detalhes abrangentes do treinamento e todas as informações do modelo que estão disponíveis por meio da chamada de API `describe-model`. Se você trabalha no Amazon SageMaker Studio, pode preencher automaticamente seus cartões modelo chamando a [DescribeModelPackage](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeModelPackage.html)API.
## P: Posso personalizar um modelo de cartão?
Os Amazon SageMaker Model Cards têm uma estrutura definida que não pode ser modificada. Essa estrutura fornece orientação sobre quais informações devem ser capturadas em um cartão de modelo. Embora você não possa alterar a estrutura do cartão de modelo, há alguma flexibilidade introduzida por meio de propriedades personalizadas na seção **Informações adicionais** do cartão de modelo.
## P: Posso editar um modelo de cartão depois de criado?
Os cartões de modelo têm versões associadas a eles. Uma determinada versão do modelo é imutável em todos os atributos, exceto no status do cartão de modelo. Se você fizer outras alterações no cartão modelo, como métricas de avaliação, descrição ou usos pretendidos, a SageMaker IA cria uma nova versão do cartão modelo para refletir as informações atualizadas. Isso é para garantir que um modelo de cartão, uma vez criado, não possa ser adulterado.
Os cartões de modelo são atualizados automaticamente sempre que você faz alterações nas versões do pacote de modelo no catálogo de modelos.
## P: Posso criar cartões de modelo para modelos que não foram treinados usando SageMaker IA?
R: Sim. Você pode criar cartões de modelo para modelos não treinados em SageMaker IA, mas nenhuma informação é preenchida automaticamente no cartão. Você deve fornecer todas as informações necessárias na placa do modelo para modelos que não sejam de SageMaker IA.
## P: Posso exportar ou compartilhar modelos de cartões?
R: Sim. Você pode exportar cada versão de um modelo de cartão para um PDF, baixá-lo e compartilhá-lo.
## P: Preciso registrar meu modelo no Registro de modelo para usar cartões de modelo?
R: Os cartões de modelo podem ser acessados por meio do SageMaker AI Console e do Model Registry. Ao usar o catálogo de modelos, você receberá automaticamente um cartão de modelo para cada versão do seu modelo.
## P: Qual é a diferença entre os cartões de modelo e o Registro de modelo?
R: Os cartões-modelo têm como objetivo fornecer às organizações um mecanismo para documentar quantos detalhes quiserem sobre seu modelo, seguindo as orientações prescritivas da SageMaker IA e fornecendo suas próprias informações personalizadas. Você pode introduzir cartões de modelo logo no início do processo de ML e usá-los para definir o problema comercial que o modelo deve resolver e quaisquer considerações a serem consideradas ao usar o modelo. Depois que um modelo é treinado, você pode preencher o cartão de modelo associado a esse modelo com informações sobre o modelo e como ele foi treinado. Os cartões de modelo são associados a modelos e são imutáveis quando associados a um modelo. Isso garante que o cartão de modelo seja a única fonte confiável de todas as informações relacionadas a um modelo, incluindo como ele foi treinado e como deve ser usado.
O Registro de modelo é um catálogo que armazena metadados sobre seus modelos. Cada entrada no registro do modelo corresponde a uma versão exclusiva do modelo. Essa versão do modelo contém informações sobre o modelo, como onde os artefatos do modelo são armazenados no Amazon S3, qual contêiner é necessário para implantar o modelo e metadados personalizados que devem ser anexados ao modelo. Cada versão do pacote de modelo tem um cartão de modelo associado a ela.
## P: Qual é a diferença entre os cartões de modelo e o catálogo de modelos?
R: Os cartões de modelo são integrados ao objeto catálogo de modelos. Cada versão de um pacote de modelo no catálogo de modelos está vinculada ao cartão do modelo correspondente. Você pode acessar o esquema do cartão modelo para cada versão usando a [ModelPackageModelCard](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelPackageModelCard.html)API.
## P: As versões do cartão de modelo estão relacionadas às versões do modelo no Registro de modelo?
R: Sim, há uma one-to-one relação entre cartões de modelo e modelos no Registro de modelos. Cada versão de modelo armazenada no catálogo de modelos tem exatamente um cartão de modelo correspondente associado a ela.
## P: As placas modelo estão integradas ao SageMaker Model Monitor?
R: Não. Você pode fazer o upload das métricas de desempenho calculadas pelo SageMaker Model Monitor para o cartão de modelo carregando um arquivo de métricas para o Amazon S3 e vinculando-o ao cartão, mas não há integração nativa entre o Model Monitor e os cartões de modelo. Os painéis de modelos são integrados ao Model Monitor. Para obter mais informações sobre painéis de modelos, consulte [Amazon SageMaker Model Dashboard](https://docs.aws.amazon.com/sagemaker/latest/dg/model_dashboard.html).
# Acesso controlado aos ativos com o Amazon SageMaker Assets
Use o Amazon SageMaker Assets para fornecer acesso controlado e regulamentado a *ativos*, modelos ou tabelas de dados pertencentes à sua organização. No SageMaker Assets, usuários de AWS contas diferentes podem criar e compartilhar ativos relacionados a problemas comerciais específicos sem sobrecarga adicional do administrador. Em vez de ter permissões estaticamente vinculadas à sua identidade, os usuários podem fornecer permissões aos ativos que estão usando para seus fluxos de trabalho ativos.
Os ativos são ativos de ML ou ativos de dados. Os ativos de ML são metadados que apontam para grupos de SageMaker recursos da Amazon Feature Store ou grupos de SageMaker modelos do Model Registry. Os ativos de dados são metadados que apontam para tabelas ou tabelas AWS Glue do Amazon Redshift.
Por exemplo, o ativo de um grupo de modelos contém o nome do grupo de modelos e o nome de recurso da Amazon (ARN) para o grupo de pacotes de modelos. O ativo aponta para a coleção subjacente de modelos. O ativo em si pode ser compartilhado entre usuários.
Os usuários podem criar ativos para seus próprios projetos. Eles podem torná-los visíveis para usuários que não são membros dos projetos. Os usuários que não são membros do projeto podem pesquisar os ativos e ler seus metadados. Eles podem usar os metadados para determinar se desejam acessar a fonte de dados subjacente.
Para entender melhor o fluxo de trabalho do SageMaker Assets, imagine que você tenha dois grupos de usuários em sua organização, o Grupo A e o Grupo B. Os usuários do Grupo A estão procurando prever os preços das casas. Eles querem colaborar com os usuários do grupo B que estão em uma conta AWS diferente. Eles têm dados de alojamento armazenados em AWS Glue tabelas. Eles também têm modelos diferentes salvos como pacotes de modelos em um grupo de modelos. Com o SageMaker Assets, os usuários do Grupo A podem compartilhar suas AWS Glue tabelas e pacotes de modelos com os usuários do Grupo B em alguns cliques. Sem a intervenção do administrador, os usuários do grupo A forneceram permissões com escopo aos usuários do grupo B de forma precisa.
Os usuários podem criar ativos e publicá-los para torná-los visíveis em toda a organização. Outros usuários podem solicitar acesso aos ativos.
**Topics**
+ [Configurar SageMaker ativos (guia do administrador)](sm-assets-set-up.md)
+ [Trabalhar com ativos (guia do usuário)](sm-assets-user-guide.md)
# Configurar SageMaker ativos (guia do administrador)
**Importante**
SageMaker Os ativos estão disponíveis somente no Amazon SageMaker Studio. Se você estiver usando o Amazon SageMaker Studio Classic, deverá migrar para o Studio. Para obter mais informações sobre o Studio e o Studio Classic, consulte [Ambientes de aprendizado de máquina oferecidos pela Amazon SageMaker AI](machine-learning-environments.md). Para obter informações sobre migração, consulte [Migração do Amazon SageMaker Studio Classic](studio-updated-migrate.md).
À medida que as necessidades de negócios mudam, seus usuários precisam colaborar de forma eficaz para resolver os problemas de negócios à medida que eles surgirem. Para resolvê-los, os usuários devem compartilhar dados e modelos entre si.
SageMaker O Assets integra o Amazon SageMaker Studio com o Amazon DataZone, um serviço de gerenciamento de dados. SageMaker Assets é uma plataforma que ajuda seus usuários a compartilhar modelos e dados entre si. Você pode usar as informações a seguir para configurar a integração entre SageMaker Assets e Amazon DataZone.
Você cria um DataZone domínio da Amazon para sua linha de negócios ou organização. O *domínio* é o principal recurso da Amazon DataZone. Todos os dados e modelos de seus usuários existem dentro do domínio.
No DataZone domínio da Amazon, um subconjunto de seus usuários trabalha em *projetos* específicos. Um projeto normalmente corresponde a um problema comercial específico. Dentro do projeto, os membros podem criar conjuntos de dados e modelos. Por padrão, os membros do projeto só têm acesso aos dados e modelos dentro do projeto. Eles podem fornecer acesso aos seus dados e modelos para outros usuários dentro da organização.
Dentro do projeto, você cria ambientes. Especificamente para SageMaker Assets, um ambiente é uma coleção de recursos configurados usados para iniciar o Amazon SageMaker Studio. Para obter mais informações sobre a terminologia usada na Amazon DataZone, consulte [Terminologia e conceitos](https://docs.aws.amazon.com/datazone/latest/userguide/datazone-concepts.html).
**Importante**
Dependendo da configuração que você escolher, o Amazon SageMaker Studio usa uma das seguintes opções:
Um domínio de SageMaker IA da Amazon que a Amazon DataZone cria como parte do seu ambiente de SageMaker IA.
Seu domínio de SageMaker IA da Amazon existente que você migra para a Amazon DataZone
Você pode acessar o Studio a partir do domínio Amazon SageMaker AI, mas recomendamos acessá-lo a partir do projeto que você criou. Para obter informações sobre como usar o Studio, consulte [Trabalhar com ativos (guia do usuário)](sm-assets-user-guide.md).
## Configure a Amazon DataZone com um novo domínio de SageMaker IA
Use as etapas na lista a seguir e a documentação que ela faz referência para configurar a Amazon DataZone com um domínio Amazon SageMaker AI criado por ela.
1. Crie um DataZone domínio da Amazon que corresponda à organização ou linha de negócios de seus usuários. Para obter informações sobre a criação de um DataZone domínio da Amazon, consulte [Criar domínios](https://docs.aws.amazon.com/datazone/latest/userguide/create-domain.html).
1. Ative o plano de SageMaker IA na Amazon DataZone. Para obter informações sobre como habilitar o esquema de SageMaker IA, consulte [Habilitar esquemas integrados na AWS conta que possui o domínio da Amazon DataZone ](https://docs.aws.amazon.com/datazone/latest/userguide/working-with-blueprints.html#enable-default-blueprints).
1. Crie um projeto dentro do domínio que corresponda ao problema comercial que os usuários do seu domínio estão resolvendo. Para saber mais sobre como criar um projeto, consulte [Criar um novo projeto](https://docs.aws.amazon.com/datazone/latest/userguide/create-new-project.html).
1. Crie um perfil de ambiente que você possa usar como modelo para criar ambientes de SageMaker IA para seus usuários. Para obter informações sobre como criar um perfil de ambiente, consulte [Criar um perfil de ambiente](https://docs.aws.amazon.com/datazone/latest/userguide/create-environment-profile.html).
1. Crie um ambiente de SageMaker IA. Dentro do projeto, seus usuários usam o ambiente de SageMaker IA para lançar o Amazon SageMaker Studio. No Studio, eles podem criar ativos e usar SageMaker ativos para compartilhá-los. Para obter informações sobre como criar um ambiente, consulte [Criar um novo ambiente](https://docs.aws.amazon.com/datazone/latest/userguide/create-environment-profile.html).
1. Adicione a SageMaker IA como um dos serviços confiáveis da Amazon DataZone. Para adicionar a SageMaker IA como um dos serviços, consulte [Adicionar SageMaker IA como um serviço confiável na AWS conta que possui o DataZone domínio da Amazon](https://docs.aws.amazon.com/datazone/latest/userguide/working-with-blueprints.html#add-sagemaker-as-trusted-service).
## Configure a Amazon DataZone com seu domínio de SageMaker IA
Use as etapas na lista a seguir e a documentação que ela faz referência para configurar a Amazon DataZone com um domínio Amazon SageMaker AI existente.
1. Crie um DataZone domínio da Amazon que corresponda à organização ou linha de negócios de seus usuários. Para obter informações sobre a criação de um DataZone domínio da Amazon, consulte [Criar domínios](https://docs.aws.amazon.com/datazone/latest/userguide/create-domain.html).
1. Ative o plano de SageMaker IA na Amazon DataZone. Para obter informações sobre como habilitar um plano personalizado, consulte [Planos de AWS serviços DataZone personalizados da Amazon](https://docs.aws.amazon.com/datazone/latest/userguide/working-with-custom-blueprint.html).
1. Crie um projeto dentro do domínio que corresponda ao problema comercial que os usuários do seu domínio estão resolvendo. Para saber mais sobre como criar um projeto, consulte [Criar um novo projeto](https://docs.aws.amazon.com/datazone/latest/userguide/create-new-project.html).
1. Habilite a SageMaker IA como um dos serviços confiáveis da Amazon DataZone. Para habilitar a SageMaker IA como um dos serviços, consulte [Adicionar a Amazon SageMaker AI como um serviço confiável na AWS conta que possui o DataZone domínio da Amazon](https://docs.aws.amazon.com/datazone/latest/userguide/working-with-blueprints.html#add-sagemaker-as-trusted-service).
1. Crie DataZone usuários da Amazon dentro do domínio SageMaker AI.
1. Integre usuários existentes ao DataZone domínio da Amazon.
**nota**
Se seus usuários de SageMaker IA forem SSO e seu DataZone domínio da Amazon for SSO, você poderá mapear automaticamente os usuários do domínio Amazon SageMaker AI para o domínio Amazon DataZone.
Para integrar usuários de SageMaker IA existentes, execute o script [Amazon DataZone Import SageMaker AI Domain](https://github.com/aws/amazon-sagemaker-examples/tree/default/%20%20%20ml_ops/sm-datazone_import) em seu ambiente. Você deve passar o nome Região da AWS e o ID da AWS conta do seu domínio Amazon SageMaker AI como argumentos. Veja a seguir um exemplo de AWS CLI comando que executa o script.
```
python example-script Região da AWS 111122223333
```
O script faz o seguinte:
1. Solicita seu ID de domínio do Amazon SageMaker AI.
1. Solicita seu ID de DataZone domínio da Amazon.
1. Solicita seu DataZone projeto na Amazon.
1. Solicita que você especifique os usuários que você está importando.
1. Adiciona tags aos seus usuários e ao domínio Amazon SageMaker AI.
1. Mapeie seus DataZone usuários da Amazon para seus perfis de usuário de SageMaker IA. Para cada perfil de usuário de SageMaker IA, o script solicitará um ID de DataZone usuário da Amazon. Você pode modificar o script para seu próprio caso de uso.
1. Atribui uma função de federação ao ambiente, para que a Amazon DataZone possa acessar seu domínio do Amazon SageMaker AI e migrá-lo.
O script passa por cada usuário no domínio Amazon SageMaker AI e solicita que você especifique o usuário correspondente no DataZone domínio da Amazon. Ele adiciona automaticamente tags para o usuário no DataZone domínio da Amazon aos usuários no domínio de SageMaker IA correspondente. Ele também atualiza o esquema do ambiente personalizado com o mapeamento entre os usuários em cada domínio.
**nota**
O ambiente de SageMaker IA usa a versão mais recente da imagem SageMaker de distribuição. SageMaker As imagens de distribuição de IA têm pacotes de bibliotecas populares para aprendizado de máquina. Para obter mais informações, consulte [SageMaker Política de suporte de imagem do Studio](sagemaker-distribution.md).
Depois de criar o ambiente, você pode criar tabelas AWS Glue e bancos de dados do Amazon Redshift. Para obter mais informações, veja [Consultar dados no Athena ou Amazon Redshift](https://docs.aws.amazon.com/datazone/latest/userguide/query-athena-with-deep-link-in-project.html).
## Como visualizar e modificar as permissões de seus usuários
Depois de criar um ambiente de SageMaker IA, você pode alterar as permissões dos usuários de acordo com as necessidades da sua organização. O esquema de SageMaker IA especifica permissões para todos os seus usuários. Eles podem realizar ações com todos os serviços de SageMaker IA, mas as permissões são reduzidas aos recursos criados no DataZone domínio da Amazon.
**Importante**
O ambiente que você cria usa um perfil do IAM que tem permissões limitadas e limites de permissões. Para alterar as permissões dos seus usuários, você pode modificar ou substituir o limite de permissões. Por exemplo, você pode alterar o limite de permissões se seus usuários precisarem acessar um recurso, como um bucket do Amazon S3 que tenha sido criado dentro do ambiente.
Você pode ver as permissões no ARN da função do IAM usada para criar o domínio de SageMaker IA.
Use o procedimento a seguir para visualizar ou editar as permissões do perfil do IAM para seus usuários.
**Para visualizar ou editar as permissões de seus usuários**
1. Abra o [console do Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker).
1. Escolha **Domínios**.
1. Escolha o nome do domínio que tem o mesmo nome do seu DataZone domínio da Amazon.
1. Escolha **Configurações do domínio**.
1. Em **Perfil de execução**, copie o ARN do perfil de execução.
1. Abra o [console do IAM](https://console.aws.amazon.com/IAM).
1. Escolha **Perfis**.
1. Cole o ARN e exclua tudo, exceto o nome da função após a última barra.
1. Escolha a função para ver as permissões.
1. Em **Permissões**, modifique as políticas de acordo com as necessidades da sua organização.
1. (Opcional) Selecione **Limite de permissões** e escolha **Definir limite de permissões**.
1. Selecione a política a ser usada para o limite de permissões.
# Trabalhar com ativos (guia do usuário)
Use SageMaker Assets para colaborar perfeitamente em projetos de aprendizado de máquina com outras pessoas em sua organização. Com o SageMaker Assets, você e seus colaboradores criam e compartilham modelos e tabelas de dados entre si. Em SageMaker Ativos, esses modelos e tabelas de dados são conhecidos como *ativos*.
SageMaker Assets é um recurso do Amazon SageMaker Studio. Você ou seu administrador criam um ambiente Studio dentro de um DataZone projeto da Amazon. Para obter mais informações sobre como configurar a Amazon DataZone, consulte[Configurar SageMaker ativos (guia do administrador)](sm-assets-set-up.md).
Os ativos são ativos de ML ou ativos de dados. Os ativos de ML são metadados que apontam para o seguinte:
+ Grupos de atributos do arquivo de atributos
+ SageMaker Grupos de modelos de IA
Os grupos de modelos e grupos de atributos subjacentes são as fontes de dados. Se você atualizar um grupo de atributos ou grupo de modelos, o ativo do grupo de modelos ou grupo de atributos será atualizado em um dia.
Os ativos de dados são metadados que apontam para o seguinte:
+ Tabelas do Amazon Redshift
+ AWS Glue tabelas
Para ativos de dados, a fonte de dados é o mecanismo que extrai metadados das tabelas AWS Glue e das tabelas do Amazon Redshift para o ativo. Por exemplo, uma fonte de dados extrai os metadados de uma AWS Glue tabela para o ativo dessa tabela.
Você pode tornar um ativo visível para todos em sua organização publicando-o. Os indivíduos podem revisar os metadados no ativo e solicitar acesso. Se você fornecer acesso, eles terão acesso à fonte subjacente de dados ou tabela de machine learning.
Seu administrador provavelmente lhe deu acesso aos grupos de atributos, grupos de modelos e tabelas. Se ainda não o fizeram, consulte as informações em [Configurar SageMaker ativos (guia do administrador)](sm-assets-set-up.md) para ajudá-lo a começar.
As seções a seguir fornecem informações de referência para grupos de atributos e grupos de modelos.
## Grupos de atributos
A Amazon SageMaker Feature Store fornece um local centralizado para ajudar você a armazenar e gerenciar seus recursos. É um repositório de alto desempenho que você pode usar para engenharia de atributos.
No Feature Store, os atributos são armazenados em um grupo de atributos. Um grupo de atributos é uma coleção de atributos relacionados a um projeto no qual você está trabalhando. Por exemplo, se você estiver trabalhando em um projeto relacionado à previsão de preços de imóveis, um grupo de atributos pode incluir atributos como localização ou número de quartos.
Para obter mais informações sobre como você pode usar grupos de atributos para simplificar o processo de engenharia de atributos, consulte [Criar, armazenar e compartilhar atributos com o arquivo de atributos](feature-store.md).
## Grupos de modelos
Você pode usar grupos de modelos de SageMaker IA no SageMaker Registro de Modelos para organizar e gerenciar diferentes versões dos seus modelos. Você pode comparar as diferentes versões dos modelos para ver qual delas tem melhor desempenho para seu caso de uso. Para obter mais informações sobre o SageMaker Model Registry, consulte[Implantação do registro do modelo com o Model Registry](model-registry.md).
A seguir, há informações básicas sobre o Amazon Redshift e o AWS Glue.
O Amazon Redshift é um serviço de armazenamento de dados em grande escala que fornece desempenho rápido para consultas em grandes conjuntos de dados. Para obter mais informações sobre o Amazon Redshift, consulte [Amazon Redshift sem servidor](https://docs.aws.amazon.com/redshift/latest/gsg/new-user-serverless.html).
AWS Glue é um serviço de extração, transformação, carregamento (ETL) que você pode usar para simplificar o processo de preparação de dados. Para obter mais informações sobre AWS Glue, consulte [O que é AWS Glue?](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html)
Você pode usar o editor SQL para conectar AWS Glue bancos de dados do Amazon Redshift e executar consultas. Você pode compartilhar qualquer tabela criada no editor em SageMaker Assets. Para obter mais informações, consulte [Preparação de dados com SQL no Studio](sagemaker-sql-extension.md).
**Topics**
+ [Terminologia e conceitos](#sm-assets-terminology)
+ [Etapa 1: acessar SageMaker ativos](#sm-assets-access)
+ [Etapa 2: compartilhe ativos e gerencie o acesso a eles](#sm-assets-share)
+ [Etapa 3: gerencie as solicitações de acesso](#sm-assets-manage-requests)
+ [Etapa 4: encontre ativos e solicite acesso a eles](#sm-assets-request-access)
+ [Etapa 5: use um ativo compartilhado em seus fluxos de trabalho de machine learning](#sm-assets-consume)
## Terminologia e conceitos
Antes de começar a usar o SageMaker Assets, é útil se familiarizar com a terminologia e os conceitos a seguir:
+ Ativo: os metadados que apontam para os modelos ou tabelas de dados que você está compartilhando. Você solicita acesso a um ativo de propriedade de outra pessoa ou compartilha seu ativo com outras pessoas. Você e seus colegas de equipe acessam o ativo e a tabela de dados subjacente ou o modelo associado a ele.
+ Ativos subscritos: para solicitar acesso a um ativo, você envia uma solicitação de inscrição. Se sua solicitação for aprovada, o ativo aparecerá em seus ativos subscritos.
+ Ativos próprios: os ativos que você compartilhou com seus colegas de equipe.
+ Catálogo de ativos: os ativos que você compartilhou com toda a sua organização.
## Etapa 1: acessar SageMaker ativos
Acesse SageMaker Ativos para ver seus ativos e compartilhá-los com outras pessoas. Use as seguintes informações para obter ajuda sobre como começar a usá-lo:
Você acessa SageMaker ativos de um *projeto* dentro de um DataZone domínio da Amazon. Um projeto é uma colaboração entre você e os membros da sua equipe. Dentro do projeto, você e os outros membros do projeto têm acesso aos ativos que vocês criam no catálogo de inventário. Você pode publicar os ativos no catálogo publicado para torná-los visíveis para outras pessoas em sua organização.
Essas pessoas podem solicitar acesso ao seu ativo. Se você fornecer acesso, eles poderão acessar a fonte de dados atualizada. Por exemplo, se uma pessoa se inscrever em uma AWS Glue tabela que você atualiza, ela pode acessar a AWS Glue tabela atualizada em tempo real.
Use o procedimento a seguir para acessar SageMaker os ativos.
**Para acessar SageMaker ativos**
1. Abra o DataZone console [da Amazon](https://console.aws.amazon.com/datazone).
1. Selecione **Visualizar domínios**.
1. Ao lado do domínio que contém seu projeto, escolha **Abrir portal de dados**.
1. Em **Ferramentas de análise**, escolha **SageMaker AI Studio**.
1. Escolha **Abrir Amazon SageMaker AI**.
1. Escolha **Ativos**.
Os ativos que foram compartilhados com você estão em **Ativos subscritos**. Os ativos que você e os membros do seu projeto criam estão em **Ativos próprios**. Os ativos que você e os outros membros da sua organização publicaram estão no **Catálogo de ativos**.
## Etapa 2: compartilhe ativos e gerencie o acesso a eles
Depois de criar modelos de machine learning, grupos de atributos ou tabelas de dados, você pode torná-los visíveis para as pessoas que colaboram com você no projeto ou sua organização de forma mais ampla. Você pode responder às solicitações de acesso ao ativo. Se você aprovar a solicitação de um indivíduo, ele poderá modificar a fonte de dados subjacente do ativo.
Ao compartilhar um ativo, você tem duas opções:
+ Publicar no catálogo de ativos: tornar o ativo visível para todos em sua organização
+ Publicar no inventário: tornar o ativo visível para todos que trabalham em seu projeto
Se você publicou seu ativo no catálogo de ativos, as pessoas da sua organização poderão encontrá-lo nele. Eles poderão visualizar os metadados do seu ativo e decidir se querem solicitar acesso a eles. Se você aprovar a solicitação, eles terão acesso à fonte de dados subjacente.
Se você publicar no inventário, você e os outros membros do projeto poderão acessar o ativo sem nenhuma ação adicional.
Os ativos publicados no inventário só aparecem em **Ativos próprios**. Os ativos publicados no catálogo aparecem em **Ativos próprios** e **Catálogo de ativos**.
Ao publicar uma tabela de dados, você deve criar uma fonte de dados que extraia os metadados da AWS Glue tabela subjacente ou da tabela do Amazon Redshift para o ativo. Use os procedimentos a seguir para publicar uma tabela AWS Glue ou uma tabela do Amazon Redshift.
------
#### [ Publish an AWS Glue table ]
Para publicar um ativo em uma AWS Glue tabela, você cria uma fonte de dados para ela e a publica. Uma fonte de dados é o mecanismo que extrai os metadados da AWS Glue tabela para o ativo.
Use o procedimento a seguir para publicar uma AWS Glue tabela.
**Para publicar uma AWS Glue tabela**
1. Navegue até a página inicial de **SageMaker Ativos**.
1. Selecione **Ativos próprios**.
1. Escolha **Visualizar fontes de dados**.
1. Escolha **Criar fonte de dados**.
1. Em **Nome**, especifique um nome para sua fonte de dados.
1. Em **Descrição**, forneça uma descrição.
1. Em **Tipo**, selecione **AWS Glue**.
1. Em **Seleção de dados**, selecione o banco de dados que contém a AWS Glue tabela.
1. Em **Critérios de seleção de tabelas**, especifique o nome da tabela.
**nota**
Embora você possa especificar mais de uma tabela, sugerimos que forneça somente um nome de tabela.
1. Escolha **Próximo**.
1.
+ Em **Publicar ativo no catálogo**, selecione **Sim** para publicar no catálogo de ativos.
+ Em **Publicar ativo no catálogo**, selecione **Não** para publicar no catálogo de ativos.
1. Escolha **Próximo**.
1. Em **Detalhes do ativo**, escolha **Executar em uma programação** ou **Executar sob demanda** para determinar como os metadados da tabela AWS Glue são inseridos no ativo.
1. (Opcional) Se você escolher **Executar em uma programação**, especifique o cronograma que extrai os metadados para o ativo.
1. Escolha **Próximo**.
1. Escolha **Criar**.
1. (Opcional) Se você não criou um cronograma, escolha **Executar** para trazer os metadados da tabela AWS Glue para o ativo.
------
#### [ Publish an Amazon Redshift table ]
Para publicar um ativo para uma tabela do Amazon Redshift, você cria uma fonte de dados para ele e o publica. Uma fonte de dados é o mecanismo que extrai os metadados da tabela do Amazon Redshift para o ativo.
Use o procedimento a seguir para publicar uma tabela do Amazon Redshift.
**Para publicar uma tabela do Amazon Redshift**
1. Navegue até a página inicial de **SageMaker Ativos**.
1. Selecione **Ativos próprios**.
1. Escolha **Visualizar fontes de dados**.
1. Escolha **Criar fonte de dados**.
1. Em **Nome**, especifique um nome para sua fonte de dados.
1. Em **Descrição**, forneça uma descrição.
1. Em **Tipo**, selecione **Amazon Redshift**.
1.
+ Selecione o **Cluster do Redshift**.
1. Para o **cluster do Redshift**, especifique o nome do cluster do Amazon Redshift que contém o banco de dados da tabela.
1. Em **Secret**, especifique o nome do AWS Secrets Manager segredo que contém as credenciais do cluster.
+ Selecione **Redshift sem servidor**.
1. Para o **Grupo de trabalho do Redshift**, especifique o nome do grupo de trabalho do Amazon Redshift que contém o banco de dados da tabela.
1. Em **Segredo**, especifique o nome do AWS Secrets Manager segredo que contém as credenciais do grupo de trabalho.
1. Em **Seleção da fonte de publicação**, selecione o banco de dados que contém a tabela do Amazon Redshift.
1. Em **Critérios de seleção de tabelas**, especifique o nome da tabela.
**nota**
Embora você possa especificar mais de uma tabela, sugerimos que forneça somente um nome de tabela.
1. Escolha **Próximo**.
1.
+ Em **Publicar ativo no catálogo**, selecione **Sim** para publicar no catálogo de ativos.
+ Em **Publicar ativo no catálogo**, selecione **Não** para publicar no catálogo de ativos.
1. Escolha **Próximo**.
1. Em **Detalhes do ativo**, escolha **Executar em uma programação** ou **Executar sob demanda** para determinar como os metadados da tabela do Amazon Redshift são inseridos no ativo.
1. (Opcional) Se você escolher **Executar em uma programação**, especifique o cronograma que extrai os metadados para o ativo.
1. Escolha **Próximo**.
1. Escolha **Criar**.
1. (Opcional) Se você não criou um cronograma, escolha **Executar** para trazer os metadados da tabela do Amazon Redshift para o ativo.
------
Use os procedimentos a seguir para publicar um ativo para um grupo de atributos ou grupo de pacotes de modelos.
------
#### [ Publish a feature group ]
Use o procedimento a seguir para navegar até um grupo de atributos que você criou e publicá-lo em seus ativos próprios ou no catálogo de ativos.
**Para publicar o grupo de atributos em seus próprios ativos ou catálogo de ativos**
1. No Studio, selecione **Dados** na navegação à esquerda.
1. Selecione o grupo de atributos que você está publicando.
1. ![\[\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/sm-assets-publish-icon.png).
1.
+ Selecione **Publicar no catálogo de ativos** para publicar no catálogo de ativos.
+ Selecione **Publicar no inventário** para publicar nos ativos de propriedade do seu grupo.
------
#### [ Publish a model group ]
Use o procedimento a seguir para navegar até um grupo de modelos que você criou e publicá-lo em seus ativos próprios ou no catálogo de ativos.
**Para publicar o grupo de modelos em seus próprios ativos ou no catálogo de ativos**
1. No Studio, selecione **Modelos** na navegação à esquerda.
1. Selecione o grupo de modelos que você deseja publicar.
1. Escolha o ícone ![\[\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/sm-assets-publish-icon.png).
1.
+ Selecione **Publicar no catálogo de ativos** para publicar no catálogo de ativos.
+ Selecione **Publicar no inventário** para publicar nos ativos de propriedade do seu grupo.
------
Use o procedimento a seguir para publicar um ativo de sua propriedade no catálogo de ativos.
**Para publicar um ativo na página SageMaker Ativos**
1. No Studio, navegue até **Ativos**.
1. Selecione **Ativos próprios**.
1. Especifique o nome do seu ativo na barra de pesquisa.
1. Escolha o ativo.
1. Selecione **Publish**.
Você pode usar o seguinte código do SDK do SageMaker Python para publicar um grupo de recursos ou um grupo de pacotes de modelos. O código pressupõe que você já criou o grupo de atributos ou o grupo de pacotes de modelos.
```
from sagemaker.asset import AssetManager
publisher = AssetPublisher()
publisher.publish_to_catalog(name-of-your-feature-group-or-model-package)
```
## Etapa 3: gerencie as solicitações de acesso
Depois de publicar um ativo, talvez os usuários que estão fora do seu projeto queiram acessá-lo. Você pode fornecer, rejeitar ou revogar solicitações de acesso. Você também pode excluir ativos para disponibilizar a fonte de dados subjacente somente para você.
Use o procedimento a seguir para responder às solicitações de assinatura.
**Para aprovar uma solicitação de assinatura**
1. Navegue até a página **SageMaker Ativos**.
1. Escolha **Gerenciar ativos**.
1. Selecione **Solicitações de assinatura recebidas**.
1.
+ (Opcional) Escolha **Aprovar** e forneça o motivo.
+ (Opcional) Escolha **Rejeitar**.
É possível revogar o acesso a um ativo aprovado anteriormente. Se você optar por revogar o acesso, os usuários perderão o acesso ao ativo e à fonte do ativo subjacente. Use o procedimento a seguir para revogar o acesso.
**Para revogar o acesso**
1. Navegue até a página **SageMaker Ativos**.
1. Escolha **Gerenciar ativos**.
1. Selecione **Solicitações de assinatura recebidas**.
1. Selecione a guia **Aprovado**.
1. Escolha **Revogar** ao lado do ativo.
Você também pode cancelar a publicação de ativos, fazendo com que eles apareçam apenas como ativos próprios. Os ativos não ficarão visíveis no catálogo de recursos, mas as pessoas que tiveram solicitações de assinatura aprovadas por você ainda poderão acessá-los.
**Para cancelar a publicação de um ativo**
1. Navegue até a página **SageMaker Ativos**.
1. Em **Ativos próprios**, escolha o ativo cuja publicação será cancelada.
1. Escolha **Cancelar publicação**.
Você também pode excluir ativos na mesma página em que cancela a publicação. A exclusão de um ativo não exclui a fonte de dados. A exclusão do ativo só torna o ativo invisível para os outros membros do seu projeto ou organização.
## Etapa 4: encontre ativos e solicite acesso a eles
Você pode solicitar acesso aos ativos que outros usuários publicaram no catálogo de recursos. Se eles aprovarem a solicitação de assinatura, você terá acesso à fonte de dados subjacente.
Na parte superior da página SageMaker Ativos, você pode especificar uma consulta de pesquisa para encontrar ativos que outros usuários da sua organização publicaram. Você também pode selecionar um tipo de ativo para visualizar todos os ativos publicados desse tipo. Por exemplo, você pode selecionar **Tabela do Glue** para ver todas as tabelas AWS Glue publicadas.
Você também pode visualizar o tipo de ativo diretamente abaixo do nome dele. Veja os nomes disponíveis para os tipos de ativo:
+ Tabela do Redshift
+ Tabela Glue
+ Modelos da
+ Grupo de atributos
**nota**
Os grupos de atributos nos seguintes armazenamentos têm o tipo **Tabela do Glue**:
Off-line
Off-line e online
**Para fazer uma solicitação de assinatura**
1. Navegue até a página **SageMaker Ativos**.
1.
+ Na barra de pesquisa, especifique o nome do ativo e escolha **Pesquisar**.
+ Em **Tipos**, selecione o tipo de ativo e encontre um ativo que você está acessando no catálogo de recursos.
1. Escolha o ativo.
1. Escolha **Assinar**.
1. Forneça um motivo para a solicitação.
1. Selecione **Enviar**.
Sua solicitação de assinatura aparece em **Solicitações de assinatura de saída**, em **Gerenciar solicitações de ativos**. Se o publicador do ativo aprovar sua solicitação, ele aparecerá em **Ativos subscritos**. Agora você pode usar o Amazon Redshift, a AWS Glue tabela ou a fonte de dados de ML em seus fluxos de trabalho de aprendizado de máquina.
## Etapa 5: use um ativo compartilhado em seus fluxos de trabalho de machine learning
Se sua solicitação de assinatura de um ativo for aprovada, você poderá usá-lo em seus fluxos de trabalho de machine learning.
Os grupos de atributos aos quais você recebeu acesso aparecem na sua lista de grupos de atributos no Studio.
Os grupos de modelos aos quais você recebeu acesso aparecem na sua lista de grupos de modelos no Studio. Você pode abrir seu grupo de modelos no registro de modelos em SageMaker Ativos. Use o procedimento a seguir para abrir o grupo de modelos no registro do modelo. **Ativos subscritos**.
**Para abrir um grupo de modelos a partir de SageMaker Ativos**
1. Selecione o grupo de modelos.
1. Escolha **Abrir no registro de modelos**.
Você pode acessar AWS Glue nossas tabelas do Amazon Redshift no Data Wrangler dentro do Canvas. SageMaker SageMaker O Canvas é um aplicativo que permite realizar análise exploratória de dados (EDA) e treinar modelos sem código. Para obter mais informações sobre o SageMaker Canvas, consulte[Amazon SageMaker Canvas](canvas.md).
Você também pode trazer os dados de suas tabelas AWS Glue ou das tabelas do Amazon Redshift para seus notebooks Jupyter usando a extensão SQL. Você pode converter seus dados em dataframes pandas para seus fluxos de trabalho de machine learning. Para obter mais informações, consulte [Preparação de dados com SQL no Studio](sagemaker-sql-extension.md).
# Painel de SageMaker modelos da Amazon
O Amazon SageMaker Model Dashboard é um portal centralizado, acessível a partir do console de SageMaker IA, onde você pode visualizar, pesquisar e explorar todos os modelos em sua conta. Você pode rastrear quais modelos são implantados para inferência e se eles são usados em trabalhos de transformação em lote ou hospedados em endpoints. Se você configurar monitores com o Amazon SageMaker Model Monitor, também poderá acompanhar o desempenho de seus modelos à medida que eles fazem previsões em tempo real com dados ao vivo. Você pode usar o painel para encontrar modelos que violam os limites definidos para qualidade de dados, qualidade do modelo, desvio e explicabilidade. A apresentação abrangente do painel de todos os resultados do seu monitor ajuda você a identificar rapidamente os modelos que não têm essas métricas configuradas.
O Model Dashboard agrega informações relacionadas ao modelo de vários recursos de SageMaker IA. Além dos serviços fornecidos no Model Monitor, você pode visualizar cartões de modelo, visualizar a linhagem do fluxo de trabalho e monitorar o desempenho do seu endpoint. Você não precisa mais classificar registros, consultar em cadernos ou acessar outros AWS serviços para coletar os dados de que precisa. Com uma experiência de usuário coesa e integração aos serviços existentes, o Model Dashboard da SageMaker AI fornece uma solução de governança de out-of-the-box modelos para ajudar você a garantir uma cobertura de qualidade em todos os seus modelos.
**Pré-requisitos**
Para usar o Painel de Modelo, você deve ter um ou mais modelos em sua conta. Você pode treinar modelos usando o Amazon SageMaker AI ou importar modelos que você treinou em outro lugar. Para criar um modelo em SageMaker IA, você pode usar a `CreateModel` API. Para obter mais informações, consulte [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html). Você também pode usar ambientes SageMaker de ML fornecidos pela IA, como o Amazon SageMaker Studio Classic, que fornece modelos de projeto que configuram o treinamento e a implantação de modelos para você. Para obter informações sobre como começar a usar o Studio Classic, consulte [Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.htm).
Embora esse não seja um pré-requisito obrigatório, os clientes obtêm o máximo valor do painel se configurarem trabalhos de monitoramento de modelos usando SageMaker o Model Monitor para modelos implantados em endpoints. Para obter pré-requisitos e instruções sobre como usar o SageMaker Model Monitor, consulte. [Monitoramento da qualidade de dados e modelos com o Amazon SageMaker Model Monitor](model-monitor.md)
## Elementos do Painel de modelo
A visualização do Painel de modelo extrai detalhes de alto nível de cada modelo para fornecer um resumo abrangente de cada modelo na sua conta. Se seu modelo for implantado para inferência, o painel ajudará você a acompanhar o desempenho do modelo e do endpoint em tempo real.
Detalhes importantes a serem destacados nesta página incluem:
+ **Classificação de risco**: um parâmetro especificado pelo usuário do cartão de modelo com um valor **baixo**, **médio** ou **alto**. A classificação de risco do cartão de modelo é uma medida categórica do impacto comercial das predições de modelo. Os modelos são usados para uma variedade de aplicações de negócios, cada um dos quais pressupõe um nível de risco diferente. Por exemplo, detectar incorretamente um ataque cibernético tem um impacto nos negócios muito maior do que categorizar incorretamente um e-mail. Se você não conhece o risco do modelo, pode defini-lo como **desconhecido**. Para obter informações sobre os cartões SageMaker modelo da Amazon, consulte [Cartões modelo](https://docs.aws.amazon.com/sagemaker/latest/dg/model-cards.html).
+ Alertas do Model Monitor: Os alertas do Model Monitor são o foco principal do Model Dashboard, e revisar a documentação existente sobre os vários monitores fornecidos pela SageMaker IA é uma maneira útil de começar. Para obter uma explicação detalhada sobre o recurso SageMaker Model Monitor e exemplos de notebooks, consulte. [Monitoramento da qualidade de dados e modelos com o Amazon SageMaker Model Monitor](model-monitor.md)
O Painel de modelo exibe os valores de status do Model Monitor pelos seguintes tipos de monitor:
+ *Qualidade de dados*: compara dados dinâmicos com dados de treinamento. Se divergirem, as inferências do seu modelo podem não ser mais precisas. Para obter detalhes adicionais sobre o monitor de qualidade de dados, consulte [Qualidade dos dados](model-monitor-data-quality.md).
+ *Qualidade do modelo*: compara as predições que o modelo faz com os rótulos reais de veracidade que o modelo tenta prever. Para obter detalhes adicionais sobre o monitor de Qualidade do modelo, consulte [Qualidade do modelo](model-monitor-model-quality.md).
+ *Desvio de polarização*: compara a distribuição de dados dinâmicos com dados de treinamento, o que também pode causar predições imprecisas. Para obter detalhes adicionais sobre o monitor de Desvio de polarização, consulte [Desvio de polarização para modelos em produção](clarify-model-monitor-bias-drift.md).
+ *Desvio de atributo de atributos*: também conhecido como desvio de explicabilidade. Compara as classificações relativas de seus atributos nos dados de treinamento com os dados dinâmicos, o que também pode ser resultado de uma oscilação de desvio. Para obter detalhes adicionais sobre o monitor de Desvio de atributo de atributos, consulte [Desvio de atribuição de atributos para modelos em produção](clarify-model-monitor-feature-attribution-drift.md).
Cada status do Model Monitor é um dos seguintes valores:
+ **Nenhum**: nenhum monitor está programado
+ **Inativo**: um monitor foi programado, mas foi desativado
+ **OK**: um monitor está programado e está ativo e não encontrou o número necessário de violações em execuções recentes de modelos de monitores para gerar um alerta
+ Hora e data: um monitor ativo gerou um alerta na hora e data especificadas
+ **Endpoint**: os endpoints que hospedam seu modelo para inferência em tempo real. No Painel de modelo, você pode selecionar a coluna de endpoint para visualizar métricas de performance, como utilização de CPU, GPU, disco e memória de seus endpoints em tempo real para ajudar você a monitorar o desempenho de suas instâncias de computação.
+ **Trabalho de transformação em lote**: o trabalho de transformação em lote mais recente executado usando esse modelo. Essa coluna ajuda a determinar se um modelo é usado ativamente para inferência em lote.
+ Detalhes do modelo: cada entrada no painel é vinculada a uma página de detalhes do modelo, na qual você pode se aprofundar em um modelo individual. Você pode acessar o gráfico de linhagem do modelo, que visualiza o fluxo de trabalho desde a preparação dos dados até a implantação e os metadados de cada etapa. Você também pode criar e visualizar o cartão de modelo, revisar os detalhes e o histórico do alerta, avaliar o desempenho de seus endpoints em tempo real e acessar outros detalhes relacionados à infraestrutura.
# Programações e alertas do Model Monitor
Usando o Python SDK, você pode criar um monitor de modelo para qualidade de dados, qualidade do modelo, desvio de polarização ou desvio de atributo de atributos. Para obter mais informações sobre como usar o SageMaker Model Monitor, consulte[Monitoramento da qualidade de dados e modelos com o Amazon SageMaker Model Monitor](model-monitor.md). O Painel de modelo preenche as informações de todos os monitores que você cria em todos os modelos na sua conta. Você pode acompanhar o status de cada monitor, o que indica se o monitor está funcionando conforme o esperado ou falhou devido a um erro interno. Você também pode ativar ou desativar qualquer monitor na própria página de detalhes do modelo. Para obter instruções sobre como visualizar monitores programados de um modelo, consulte [Visualizar monitores programados](model-dashboard-schedule-view.md). Para obter instruções sobre como ativar ou desativar monitores de modelo, consulte [Ativar ou desativar um Model Monitor](model-dashboard-schedule-activate.md).
Um modelo de monitor configurado adequadamente e em execução ativa pode gerar alertas. Nesse caso, as execuções de monitoramento produzem relatórios de violação. Para obter detalhes sobre como os alertas funcionam e como visualizar os resultados dos alertas, o histórico e os links para relatórios de tarefas para depuração, consulte [Visualizar e editar alertas](model-dashboard-alerts.md).
# Visualizar monitores programados
Use o SageMaker Model Monitor para monitorar continuamente seus modelos de aprendizado de máquina em busca de desvios de dados, qualidade do modelo, viés e outros problemas que possam afetar o desempenho do modelo. Depois de configurar os cronogramas de monitoramento, você pode ver os detalhes desses monitores programados por meio do console de SageMaker IA. O seguinte procedimento descreve as etapas para acessar e rever o monitoramento agendado para um modelo específico, incluindo seu status atual:
**Para visualizar os monitoramentos programados de um modelo**
1. Abra o [console de SageMaker IA](https://console.aws.amazon.com/sagemaker/).
1. Escolha **Governança** no painel esquerdo.
1. Escolha **Painel de modelo**.
1. Na seção **Modelos** do Painel de modelo, selecione o nome do modelo dos monitores programados que você deseja visualizar.
1. Visualize os monitores programados na seção **Monitorar a programação**. Você pode revisar o status de cada monitor na coluna **Programação de status**, que é um dos seguintes valores:
+ **Falha**: a programação do monitoramento falhou devido a um problema com a configuração ou configurações (como permissões de usuário incorretas).
+ **Pendente**: o monitor está em processo de ser programado.
+ **Parado**: a programação é interrompida pelo usuário.
+ **Programado**: o agendamento é criado e executado na frequência especificada.
# Ativar ou desativar um Model Monitor
Use o procedimento a seguir para ativar ou desativar o monitoramento de um modelo.
**Para ativar ou desativar um Model Monitor, conclua as seguintes etapas:**
1. Abra o [console de SageMaker IA](https://console.aws.amazon.com/sagemaker/).
1. Escolha **Governança** no painel esquerdo.
1. Escolha **Painel de modelo**.
1. Na seção **Modelos** do Painel de modelos, selecione o nome do modelo do endpoint que você deseja visualizar.
1. Escolha a caixa de rádio ao lado da programação do monitor do alerta que você deseja modificar.
1. (opcional) Escolha **Desativar programação do monitor** se quiser desativar sua programação do monitor.
1. (opcional) Escolha **Ativar programação do monitor** se quiser ativar sua programação do monitor.
# Visualizar e editar alertas
O painel do modelo exibe alertas que você configurou na Amazon CloudWatch. Você pode modificar os critérios de alerta dentro do próprio painel. Os critérios de alerta dependem de dois parâmetros:
+ **Pontos de dados a serem alertados**: dentro do período de avaliação, quantas falhas na execução geram um alerta.
+ **Período de avaliação**: o número das execuções de monitoramento mais recentes a serem consideradas ao avaliar o status do alerta.
A imagem a seguir mostra um exemplo de cenário de uma série de execuções do Model Monitor em que definimos um **período de avaliação** hipotético de 3 e **Pontos de dados a serem alertados** com o valor de alerta de 2. Após cada execução de monitoramento, o número de falhas é contabilizado dentro do **período de avaliação** de 3. Se o número de falhas atingir ou exceder os **Pontos de dados a serem alertados** 2, o monitor emitirá um alerta e permanecerá no status de alerta até que o número de falhas no **período de avaliação** se torne menor que 2 nas iterações subsequentes. Na imagem, as janelas de avaliação ficam vermelhas quando o monitor emite um alerta ou permanece no status de alerta e verdes caso contrário.
Observe que, mesmo que o tamanho da janela de avaliação não tenha atingido o **período de avaliação** de 3, conforme mostrado nas primeiras 2 linhas da imagem, o monitor ainda emitirá um alerta se o número de falhas atingir ou exceder os **Pontos de dados a serem alertados** de 2.
![\[Uma sequência de sete exemplos de execuções de monitoramento.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model_monitor/model-dashboard-alerts-window.png)
Na página de detalhes do monitor, você pode visualizar seu histórico de alertas, editar critérios de alerta existentes e visualizar relatórios de tarefas para ajudá-lo a depurar falhas de alerta. Para obter instruções sobre como visualizar o histórico de alertas ou relatórios de tarefas para execuções de monitoramento com falha, consulte [Exibir histórico de alertas ou relatórios de trabalho](model-dashboard-alerts-view.md). Para instruções sobre como editar os critérios de alerta, consulte [Editar critérios de alerta](model-dashboard-alerts-edit.md).
# Exibir histórico de alertas ou relatórios de trabalho
**Para visualizar o histórico de alertas ou relatórios de trabalhos de execuções com falha, conclua as seguintes etapas:**
1. Abra o [console de SageMaker IA](https://console.aws.amazon.com/sagemaker/).
1. Escolha **Governança** no painel esquerdo.
1. Escolha **Painel de modelo**.
1. Na seção **Modelos** do Painel de modelo, selecione o nome do modelo do histórico de alertas que você deseja visualizar.
1. Na coluna **Nome da Programação**, selecione o nome do monitor do histórico de alertas que você deseja visualizar.
1. Para ver o histórico de alertas, selecione a guia **Histórico de alertas**.
1. (opcional) Para visualizar relatórios de trabalho de monitoramento de execuções, conclua as seguintes etapas:
1. Na guia **Histórico de alertas**, escolha **Exibir execuções** para o alerta que você deseja investigar.
1. Na tabela **Histórico de execução**, escolha **Exibir relatório** da execução de monitoramento que você deseja investigar.
**O relatório exibirá as seguintes informações:**
+ **Funcionalidade**: o atributo de ML definido pelo usuário que é monitorado
+ **Restrição**: a verificação específica no monitor
+ **Detalhes da violação**: informações sobre por que a restrição foi violada
# Editar critérios de alerta
**Para editar um alerta no Painel de modelo, conclua as seguintes etapas:**
1. Abra o [console de SageMaker IA](https://console.aws.amazon.com/sagemaker/).
1. Escolha **Governança** no painel esquerdo.
1. Escolha **Painel de modelo**.
1. Na seção **Modelos** do Painel de modelos, selecione o nome do modelo do endpoint que você deseja visualizar.
1. Escolha a caixa de rádio ao lado da programação do monitor do alerta que você deseja modificar.
1. Escolha **Editar alerta** na seção **Monitorar a programação**.
1. (opcional) Altere **Pontos de dados a serem alertados** se quiser alterar o número de falhas no **período de avaliação** que iniciam um alerta.
1. (opcional) Altere o **período de avaliação** se quiser alterar o número de execuções de monitoramento mais recentes a serem consideradas ao avaliar o status do alerta.
# Visualizar um gráfico de linhagem do modelo
Quando você treina um modelo, o Amazon SageMaker AI cria uma visualização de todo o seu fluxo de trabalho de ML, desde a preparação dos dados até a implantação. Essa visualização é chamada de gráfico de linhagem de modelo. A página a seguir descreve como visualizar um gráfico de linhagem de modelo no console de SageMaker IA.
Os gráficos de linhagem de modelo usa entidades para representar etapas individuais em seu fluxo de trabalho. Por exemplo, um gráfico de linhagem de modelo básico pode ter uma entidade representando seu conjunto de treinamento, associada a uma entidade representando seu trabalho de treinamento, associada a outra entidade representando seu modelo. Além disso, o gráfico armazena informações sobre cada etapa do fluxo de trabalho. Com essas informações, você pode recriar qualquer etapa do fluxo de trabalho ou rastrear a linhagem do modelo e do conjunto de dados. Por exemplo, o SageMaker AI Lineage armazena o URI S3 de suas fontes de dados de entrada com cada trabalho para que você possa realizar análises adicionais das fontes de dados para verificação de conformidade.
Embora o gráfico de linhagem do modelo possa ajudá-lo a visualizar as etapas em fluxos de trabalho individuais, há muitos outros recursos que você pode aproveitar usando o AWS SDK. Por exemplo, com o AWS SDK, você pode criar ou consultar suas entidades. Para obter mais informações sobre o conjunto completo de recursos do SageMaker AI Lineage e exemplos de notebooks, consulte. [Rastreamento SageMaker de linhagem do Amazon ML](lineage-tracking.md)
# Introdução às entidades
O Amazon SageMaker AI cria automaticamente entidades de rastreamento para trabalhos, modelos, pacotes de modelos e endpoints de SageMaker IA, se os dados estiverem disponíveis. Para um fluxo de trabalho básico, suponha que você treine um modelo usando um conjunto de dados. SageMaker A IA gera automaticamente um gráfico de linhagem com três entidades:
+ **Conjunto de dados**: um tipo de artefato, que é uma entidade que representa um objeto ou dados endereçáveis de URI. Um artefato geralmente é uma entrada ou uma saída para um componente ou ação de teste.
+ **TrainingJob**: um tipo de componente experimental, que é uma entidade que representa trabalhos de processamento, treinamento e transformação.
+ **Modelo**: outro tipo de artefato. Assim como o artefato **Conjuntos de dados**, um **modelo** é um objeto endereçável de URI. Nesse caso, é uma saída do componente de **TrainingJob**teste.
Seu gráfico de linhagem de modelo se expande rapidamente se você adicionar etapas adicionais ao seu fluxo de trabalho, como pré-processamento ou pós-processamento de dados, se você implantar seu modelo em um endpoint ou se incluir seu modelo em um pacote de modelos, entre muitas outras possibilidades. Para ver a lista completa de entidades de SageMaker IA, consulte[Rastreamento SageMaker de linhagem do Amazon ML](lineage-tracking.md).
## Propriedades de entidade
Cada nó no gráfico exibe o tipo de entidade, mas você pode escolher as reticências verticais à direita do tipo de entidade para ver detalhes específicos relacionados ao seu fluxo de trabalho. Em nosso gráfico de linhagem barebones anterior, você pode escolher a elipse vertical ao lado para ver valores específicos **DataSet**para as seguintes propriedades (comuns a todas as entidades de artefato):
+ **Nome**: o nome do seu conjunto de dados.
+ **URI de origem**: o local do seu conjunto de dados no Amazon S3.
Para a entidade `TrainingJob`, você pode ver os valores específicos das seguintes propriedades (comuns a todas as entidades `TrialComponent`):
+ **Nome**: o nome do trabalho de treinamento.
+ **ARN do trabalho**: o nome do recurso da Amazon (ARN) do seu trabalho de treinamento.
Para a entidade **Modelo**, você vê as mesmas propriedades listadas, **DataSet**pois ambas são entidades de artefato. Para obter uma lista das entidades e suas propriedades associadas, consulte [Entidades de monitoramento de linhagem](lineage-tracking-entities.md).
## Consultas de entidades
A Amazon SageMaker AI gera automaticamente gráficos de entidades de linhagem à medida que você as usa. No entanto, se você estiver executando várias iterações de um experimento e não quiser visualizar todos os gráficos de linhagem, o AWS SDK pode ajudá-lo a realizar consultas em todos os seus fluxos de trabalho. Por exemplo, você pode consultar suas entidades de linhagem para todos os trabalhos de processamento que usam um endpoint. Ou você pode ver todas as trilhas downstream que usam um artefato. Para obter uma lista de todas as consultas que você pode realizar, consulte [Consultar entidades de linhagem](querying-lineage-entities.md).
## Visualizar um gráfico de linhagem do modelo
**Para visualizar o gráfico de linhagem de um modelo, conclua as seguintes etapas:**
1. Abra o [console de SageMaker IA](https://console.aws.amazon.com/sagemaker/).
1. Escolha **Governança** no painel esquerdo.
1. Escolha **Painel de modelo**.
1. Na seção **Modelos** do Painel do Modelo, selecione o nome do modelo do gráfico de linhagem que você deseja visualizar.
1. Escolha **Visualizar linhagem** na seção **Visão geral do modelo**.
# Visualizar o status do endpoint
Se você quiser usar seu modelo treinado para realizar inferência em dados ativos, implante seu modelo em um endpoint em tempo real. Para garantir a latência adequada de suas predições, você quer garantir que as instâncias que hospedam seu modelo estejam funcionando com eficiência. O atributo de monitoramento de endpoint do Painel de modelo exibe informações em tempo real sobre a configuração do endpoint e ajuda você a monitorar o desempenho do endpoint com métricas.
**Configurações do monitor**
O Model Dashboard tem links para páginas de detalhes de endpoints de SageMaker IA existentes, que exibem gráficos em tempo real das métricas que você pode selecionar na Amazon. CloudWatch Em seu painel, você pode acompanhar essas métricas à medida que seu endpoint está lidando com solicitações de inferência em tempo real. A seguir, algumas métricas que você pode selecionar:
+ `CpuUtilization`: a soma da utilização de Núcleos de CPU individual, com cada um variando de 0% a 100%.
+ `MemoryUtilization`: o percentual de memória de GPU usada pelos contêineres em uma instância variando de 0% a 100%.
+ `DiskUtilization`: o percentual de espaço do disco usado pelos contêineres em uma instância variando de 0% a 100%.
Para ver a lista completa de métricas que você pode visualizar em tempo real, consulte [Métricas de SageMaker IA da Amazon na Amazon CloudWatch](monitoring-cloudwatch.md).
**Configurações de runtime**
O Amazon SageMaker AI oferece suporte à escalabilidade automática (escalabilidade automática) para seus modelos hospedados. O ajuste de escala automático ajusta dinamicamente o número de instâncias provisionadas para um modelo em resposta às alterações no workload. Quando a workload aumenta, o ajuste de escala automático disponibiliza mais instâncias online. Quando a workload diminui, o ajuste de escala automático remove as instâncias desnecessárias para que você não precise pagar pelas instâncias provisionadas que não está usando. Você pode personalizar as seguintes configurações de runtime no Painel de modelo:
+ *Atualizar ponderações*: altere a quantidade de workload atribuída a cada instância com a ponderação numérica. Para obter mais informações sobre a ponderação da instância durante o ajuste de escala automático, consulte [Configurar ponderação de instâncias para o Amazon EC2 Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-mixed-instances-groups-instance-weighting.html).
+ *Atualizar contagem de instância*: altere o número total de instâncias que podem atender seu workload quando aumenta.
Para obter mais informações sobre as configurações de tempo de execução do endpoint, consulte [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html).
**Definições de configuração de endpoint**
As configurações de endpoint exibem as configurações especificadas quando você criou o endpoint. Essas configurações informam à SageMaker IA quais recursos provisionar para seu endpoint. Algumas configurações incluídas são as seguintes:
+ *Captura de dados*: você pode escolher capturar informações sobre as entradas e saídas do seu endpoint. Por exemplo, talvez você queira obter uma amostra do tráfego de entrada para ver se os resultados estão correlacionados com dados de treinamento. Você pode personalizar sua frequência de amostragem, o formato dos dados armazenados e a localização dos dados armazenados no Amazon S3. Para obter mais informações sobre como definir a configuração de captura de dados, consulte [Captura de dados](model-monitor-data-capture.md).
+ *Variantes de produção*: consulte a discussão anterior em *Configurações de runtime*.
+ *Configuração de invocação assíncrona*: se seu endpoint for assíncrono, esta seção inclui o número máximo de solicitações simultâneas enviadas pelo cliente de SageMaker IA ao contêiner modelo, a localização das notificações de sucesso e falha no Amazon S3 e a localização de saída das saídas do endpoint. Para mais informações sobre solicitações assíncronas, consulte [Operações assíncronas do endpoint](async-inference-create-invoke-update-delete.md).
+ *Chave de criptografia*: você pode inserir sua chave de criptografia se quiser criptografar suas saídas.
Para obter mais informações sobre as configurações do endpoint, consulte [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html).
## Visualizar o status e a configuração de um endpoint
**Para visualizar o status e a configuração do endpoint de um modelo, conclua as seguintes etapas:**
1. Abra o [console de SageMaker IA](https://console.aws.amazon.com/sagemaker/).
1. Escolha **Governança** no painel esquerdo.
1. Escolha **Painel de modelo**.
1. Na seção **Modelos** do Painel de Modelos, selecione o nome do modelo do endpoint que você deseja visualizar.
1. Selecione o nome do endpoint na seção **Endpoints**.
# Perguntas frequentes sobre o Painel de Modelos
Consulte os tópicos de perguntas frequentes a seguir para obter respostas às perguntas mais frequentes sobre o Amazon SageMaker Model Dashboard.
## P: O que é o Painel de Modelos?
O Amazon SageMaker Model Dashboard é um repositório centralizado de todos os modelos criados em sua conta. Os modelos geralmente são resultados de trabalhos de SageMaker treinamento, mas você também pode importar modelos treinados em outros lugares e hospedá-los na SageMaker IA. O Model Dashboard fornece uma interface única para administradores de TI, gerentes de risco de modelos e líderes de negócios rastrearem todos os modelos implantados e agregarem dados de vários AWS serviços para fornecer indicadores sobre o desempenho de seus modelos. Você pode visualizar detalhes sobre endpoints de modelos, trabalhos de transformação em lote e trabalhos de monitoramento para obter informações adicionais sobre o desempenho do modelo. A exibição visual do painel ajuda você a identificar rapidamente quais modelos têm monitores ausentes ou inativos, para que você possa garantir que todos os modelos sejam verificados periodicamente quanto a oscilações de dados, oscilações de modelos, oscilações de desvio e oscilações de concessão de atributos. Por fim, o acesso imediato do painel aos detalhes do modelo ajuda você a se aprofundar para acessar logs, informações relacionadas à infraestrutura e recursos para ajudar você a depurar falhas de monitoramento.
## P: Quais são os pré-requisitos para usar o Painel de Modelos?
Você deve ter um ou mais modelos criados em SageMaker IA, treinados em SageMaker IA ou treinados externamente. Embora esse não seja um pré-requisito obrigatório, você obtém o máximo valor do painel se configurar trabalhos de monitoramento de modelos por meio do Amazon SageMaker Model Monitor para modelos implantados em endpoints.
## P: Quem deve usar o Painel de Modelos?
Gerentes de risco de modelos, profissionais de ML, cientistas de dados e líderes de negócios podem obter uma visão geral abrangente dos modelos usando o Painel de Modelos. O painel agrega e exibe dados dos serviços Amazon SageMaker Model Cards, Endpoints e Model Monitor para exibir informações valiosas, como metadados do modelo do cartão e do registro do modelo, endpoints em que os modelos são implantados e insights do monitoramento do modelo.
## P: Como usar o Painel de Modelos?
O Model Dashboard está disponível imediatamente com o Amazon SageMaker AI e não requer nenhuma configuração prévia. No entanto, se você configurou trabalhos de monitoramento de modelos usando o SageMaker Model Monitor e o Clarify, você usa CloudWatch a Amazon para configurar alertas que levantam uma bandeira no painel quando o desempenho do modelo se desvia de uma faixa aceitável. Você pode criar e adicionar novos cartões de modelo ao painel e visualizar todos os resultados de monitoramento associados aos endpoints. No momento, o Painel de Modelos não é compatível com modelos de contas cruzadas.
## P: O que é o Amazon SageMaker Model Monitor?
Com o Amazon SageMaker Model Monitor, você pode selecionar os dados que deseja monitorar e analisar sem escrever nenhum código. SageMaker O Model Monitor permite selecionar dados, como saída de previsão, em um menu de opções e captura metadados, como registro de data e hora, nome do modelo e ponto final, para que você possa analisar as previsões do modelo. Você pode especificar a taxa de amostragem da captura de dados como uma porcentagem do tráfego geral no caso de predições em tempo real de alto volume. Esses dados são armazenados em seu próprio bucket do Amazon S3. Você também pode criptografar esses dados, configurar uma segurança refinada, definir políticas de retenção de dados e implementar mecanismos de controle de acesso para acesso seguro.
## P: Quais tipos de modelos de monitores são compatíveis com a SageMaker IA?
SageMaker O Model Monitor fornece os seguintes tipos de [modelos de monitores](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor.html):
+ *Qualidade dos dados*: monitora a variação na qualidade dos dados.
+ *Qualidade do modelo*: monitore a variação nas métricas de qualidade do modelo, como precisão.
+ *Oscilação de desvio para modelos em produção*: monitore o desvio nas predições do seu modelo comparando a distribuição do treinamento e dos dados ao vivo.
+ *Desvio de concessão de atributos para modelos em produção*: monitore o desvio na concessão de atributos comparando as classificações relativas dos atributos no treinamento e nos dados ao vivo.
## P: Quais métodos de inferência são compatíveis com o SageMaker Model Monitor?
No momento, o Model Monitor oferece apoio apenas a endpoints que hospedam um único modelo e não é compatível com o monitoramento de [endpoints multimodelo](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html).
## P: Como posso começar a usar o SageMaker Model Monitor?
Você pode usar os seguintes recursos para começar a usar o monitoramento de modelos:
+ [Exemplo de caderno com monitor de qualidade de dados](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker_model_monitor/introduction/SageMaker-ModelMonitoring.ipynb)
+ [Exemplo de caderno com monitor de qualidade de modelos](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker_model_monitor/introduction/SageMaker-ModelMonitoring.ipynb)
+ [Exemplo de caderno com monitor de oscilação de desvio](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker_model_monitor/fairness_and_explainability/SageMaker-Model-Monitor-Fairness-and-Explainability.ipynb)
+ [Exemplo de caderno de monitor de desvio de concessão de atributo](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker_model_monitor/fairness_and_explainability/SageMaker-Model-Monitor-Fairness-and-Explainability.ipynb)
Para ver mais exemplos de monitoramento de modelos, consulte o GitHub repositório. [amazon-sagemaker-examples](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker_model_monitor)
## P: Como funciona o Model Monitor?
O Amazon SageMaker Model Monitor monitora automaticamente os modelos de aprendizado de máquina em produção, usando regras para detectar desvios em seu modelo. O Model Monitor notifica você quando surgem problemas de qualidade por meio de alertas. Para saber mais, consulte [Como funciona o Amazon SageMaker Model Monitor](model-monitor.md#model-monitor-how-it-works).
## P. Quando e como você traz seu próprio contêiner (BYOC) para o Model Monitor?
O Model Monitor calcula métricas e estatísticas do modelo somente em dados tabulares. Para casos de uso que não sejam conjuntos de dados tabulares, como imagens ou texto, você pode trazer seus próprios contêineres (BYOC) para monitorar seus dados e modelos. Por exemplo, você pode usar o BYOC para monitorar um modelo de classificação de imagens que usa imagens como entrada e gera uma etiqueta. Para saber mais sobre contratos de contêiner, consulte [Support para seus próprios contêineres com o Amazon SageMaker Model Monitor](model-monitor-byoc-containers.md).
## P: Onde posso encontrar exemplos de BYOC para o Model Monitor?
Você pode encontrar exemplos úteis de BYOC nos links a seguir:
+ [Monitoramento da qualidade de dados e modelos com o Amazon SageMaker Model Monitor](model-monitor.md)
+ [GitHubexemplo de repositório](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker_model_monitor)
+ [Support para seus próprios contêineres com o Amazon SageMaker Model Monitor](model-monitor-byoc-containers.md)
+ [Detectar o desvio de dados na PLN usando o BYOC Model Monitor](https://aws.amazon.com/blogs/machine-learning/detect-nlp-data-drift-using-custom-amazon-sagemaker-model-monitor)
+ [Detectar e analisar predições incorretas em CV](https://aws.amazon.com/blogs//machine-learning/detecting-and-analyzing-incorrect-model-predictions-with-amazon-sagemaker-model-monitor-and-debugger)
## P: Como faço para integrar o Model Monitor com o Pipelines?
Para obter detalhes sobre como integrar o Model Monitor e o Pipelines, consulte O [Amazon Pipelines agora se integra ao SageMaker Model Monitor e ao Clarify](https://aws.amazon.com/about-aws/whats-new/2021/12/amazon-sagemaker-pipelines-integrates-sagemaker-model-monitor-sagemaker-clarify/). SageMaker
Para ver um exemplo, veja o GitHub exemplo de [integração do notebook Pipelines com o Model Monitor e o Clarify](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/model-monitor-clarify-pipelines/sagemaker-pipeline-model-monitor-clarify-steps.ipynb).
## P: Há algum problema de desempenho com o uso de `DataCapture`?
Quando ativada, a captura de dados ocorre de forma assíncrona nos endpoints de IA. SageMaker Para evitar o impacto nas solicitações de inferência, a `DataCapture` 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 `DataCapture` continue capturando solicitações.