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á.
# Modelos de registro de modelos, versões de modelos e grupos de modelos
O SageMaker Model Registry é estruturado como vários grupos de modelos (Package) com pacotes de modelos em cada grupo. Esses grupos de modelos podem, opcionalmente, ser adicionados a uma ou mais coleções. Cada pacote de modelo em um grupo de modelos corresponde a um modelo treinado. A versão de cada pacote de modelo é um valor numérico que começa em 1 e é incrementado com cada novo pacote de modelo adicionado a um grupo de modelos. Por exemplo, se 5 pacotes de modelos forem adicionados a um grupo de modelos, as versões do pacote de modelos serão 1, 2, 3, 4 e 5.
Um pacote de modelo é o modelo real registrado no Registro de modelo como uma entidade versionada. Há dois tipos de pacotes de modelos na SageMaker IA. Um tipo é usado no Marketplace da AWS e o outro é usado no Registro de Modelos. Os pacotes de modelos usados no Marketplace da AWS não são entidades versionáveis e não estão associados a grupos de modelos no Registro de modelos. O Registro de modelo recebe cada novo modelo que você retreina, fornece uma versão e o atribui a um Grupo de Modelos dentro do Registro de modelo. A imagem a seguir mostra um exemplo de um Grupo de modelos com 25 modelos com versão consecutiva. Para obter mais informações sobre pacotes de modelos usados no AWS Marketplace, consulte[Algoritmos e pacotes no AWS Marketplace](sagemaker-marketplace.md).
Os pacotes de modelos usados no Registro de Modelos são versionados e **devem** estar associados a um Grupo de Modelos. O ARN desse tipo de pacote de modelo tem a estrutura: `'arn:aws:sagemaker:region:account:model-package-group/version'`
Os tópicos a seguir mostram como criar e trabalhar com modelos, versões de modelos e grupos de modelos no Registro de modelos.
**Topics**
+ [Criar um grupo de modelos](model-registry-model-group.md)
+ [Excluir um grupo de modelos](model-registry-delete-model-group.md)
+ [Registrar uma versão do modelo](model-registry-version.md)
+ [Exibir grupos e versões de modelos](model-registry-view.md)
+ [Atualizar os detalhes de uma versão do modelo](model-registry-details.md)
+ [Comparar versões do modelo](model-registry-version-compare.md)
+ [Visualizar e gerenciar tags de grupo de modelos e versões de modelo](model-registry-tags.md)
+ [Excluir uma versão do modelo](model-registry-delete-model-version.md)
+ [Constructo de preparação para o ciclo de vida do modelo](model-registry-staging-construct.md)
+ [Atualizar o status da aprovação de um modelo](model-registry-approve.md)
+ [Implantar um modelo a partir do registro com Python](model-registry-deploy.md)
+ [Implantar um modelo no Studio](model-registry-deploy-studio.md)
+ [Detecção entre contas](model-registry-ram.md)
+ [Exibir o histórico de implantações de um modelo](model-registry-deploy-history.md)
+ [Visualizar detalhes da linhagem de modelo no Studio](model-registry-lineage-view-studio.md)
# Criar um grupo de modelos
Um grupo de modelos contém versões de um modelo. Você pode criar um grupo de modelos que rastreie todos os modelos que você treina para resolver um problema específico. Crie um grupo de modelos usando o console do Amazon Studio AWS SDK para Python (Boto3) ou o console do Amazon SageMaker Studio.
## Criar um grupo de modelo (Boto3)
**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.
Para criar um grupo de modelos usando o Boto3, chame a operação de API `create_model_package_group` e especifique um nome e uma descrição como parâmetros. O exemplo a seguir mostra como criar um Grupo de modelos. A resposta da chamada `create_model_package_group` é o Nome do recurso da Amazon (ARN) do novo grupo modelo.
Primeiro, importe os pacotes necessários e configure o cliente SageMaker AI Boto3.
```
import time
import os
from sagemaker import get_execution_role, session
import boto3
region = boto3.Session().region_name
role = get_execution_role()
sm_client = boto3.client('sagemaker', region_name=region)
```
Agora crie o Grupo de modelos.
```
import time
model_package_group_name = "scikit-iris-detector-" + str(round(time.time()))
model_package_group_input_dict = {
"ModelPackageGroupName" : model_package_group_name,
"ModelPackageGroupDescription" : "Sample model package group"
}
create_model_package_group_response = sm_client.create_model_package_group(**model_package_group_input_dict)
print('ModelPackageGroup Arn : {}'.format(create_model_package_group_response['ModelPackageGroupArn']))
```
## Criar um grupo de modelos (Studio ou Studio Classic)
Para criar um grupo de modelos no console do Amazon SageMaker Studio, conclua as etapas a seguir com base no uso do Studio ou do Studio Classic.
------
#### [ Studio ]
1. Abra o console do SageMaker Studio seguindo as instruções em [Iniciar o Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. No painel de navegação à esquerda, selecione **Modelos**.
1. Escolha a guia **Modelos registrados**, se ainda não estiver selecionada.
1. Logo abaixo da etiqueta da guia **Modelos registrados**, escolha **Grupos de modelos**, se ainda não estiver selecionado.
1. Escolha **Registrar** e, em seguida, escolha **Grupo de modelos**.
1. Na caixa de diálogo **Criar grupo de modelos**, insira as informações a seguir:
+ O nome do novo grupo de modelos no campo **Nome do grupo de modelos**.
+ (Opcional) Uma descrição do grupo de modelos no campo **Descrição**.
+ (Opcional) Qualquer par de valores-chave que você queira associar ao grupo de modelos no campo **Tags**. Para obter mais informações sobre o uso de tags, consulte [Marcar recursos da AWS](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) no Guia da *Referência geral da AWS*.
1. Escolha **Registrar grupo de modelos**.
1. (Opcional) Na página **Modelos**, escolha a guia **Modelos registrados** e, em seguida, escolha **Grupos de modelos**. Confirme se seu grupo de modelos recém-criado aparece na lista de grupos de modelos.
------
#### [ Studio Classic ]
1. Faça login no Amazon SageMaker Studio Classic. Para obter mais informações, consulte [Launch Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. No painel de navegação à esquerda, selecione o ícone **Início** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Escolha **Modelos** e, em seguida, **Registro de modelo**.
1. Selecione **Ações** e selecione **Criar grupo de modelos**.
1. Na caixa de diálogo **Criar grupo de modelos**, insira as informações a seguir:
+ Insira o nome do novo grupo de modelos no campo **Nome do grupo de modelos**.
+ (Opcional) Insira uma descrição no campo **Descrição** do Grupo de modelos.
+ (Opcional) Insira os pares de valores-chave que você queira associar ao Grupo de modelos no campo **Tags**. Para obter mais informações sobre o uso de tags, consulte [Marcar recursos da AWS](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) no Guia da *Referência geral da AWS*.
+ (Opcional) Escolha um projeto ao qual associar o Grupo de modelos no campo **Projeto**. Para obter informações sobre projetos, consulte [MLOps Automação com SageMaker projetos](sagemaker-projects.md).
1. Escolha **Criar grupo de modelo**.
------
# Excluir um grupo de modelos
Esse procedimento demonstra como excluir um grupo de modelos no console do Amazon SageMaker Studio. Quando você exclui um grupo de modelos, você perde o acesso às versões do modelo no grupo de modelos.
## Excluir um grupo de modelos (Studio ou Studio Classic)
**Importante**
Você só pode excluir um grupo de modelos vazio. Antes de excluir seu grupo de modelos, remova suas versões de modelo, se houver.
Para excluir um grupo de modelos no console do Amazon SageMaker Studio, conclua as etapas a seguir com base no uso do Studio ou do Studio Classic.
------
#### [ Studio ]
1. Abra o console do SageMaker Studio seguindo as instruções em [Iniciar o Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. No painel de navegação à esquerda, selecione **Modelos**.
1. Escolha a guia **Modelos registrados**, se ainda não estiver selecionada.
1. Logo abaixo da etiqueta da guia **Modelos registrados**, escolha **Grupos de modelos**, se ainda não estiver selecionado.
1. Na lista de grupos de modelos, selecione a caixa de seleção próxima ao nome do grupo de modelos que você deseja excluir.
1. Escolha as reticências verticais acima do canto superior direito da lista de grupos de modelos e, depois, **Excluir**.
1. Na caixa de diálogo **Excluir grupo de modelos**, escolha **Sim, excluir o grupo de modelos**.
1. Escolha **Excluir**.
1. Confirme se seus grupos de modelos excluídos não aparecem mais na sua lista de grupos de modelos.
------
#### [ Studio Classic ]
1. Faça login no Amazon SageMaker Studio Classic. Para obter mais informações, consulte [Launch Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. No painel de navegação à esquerda, selecione o ícone **Início** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Escolha **Modelos** e, em seguida, **Registro de modelo**. Uma lista dos seus grupos de modelos é exibida.
1. Na lista de grupos de modelos, selecione o nome do Grupo de modelos que você deseja excluir.
1. No canto superior direito, escolha **Remover**.
1. No diálogo de confirmação, insira `REMOVE`.
1. Escolha **Remover**.
------
# Registrar uma versão do modelo
Você pode registrar um modelo Amazon SageMaker AI criando uma versão do modelo que especifica o grupo de modelos ao qual ele pertence. Uma versão do modelo deve incluir os respectivos artefatos (os pesos treinados de um modelo) e o respectivo código de inferência.
Um *pipeline de inferência* é um modelo de SageMaker IA composto por uma sequência linear de dois a quinze contêineres que processam solicitações de inferência. Você registra um pipeline de inferência especificando os contêineres e as variáveis de ambiente associadas. Para obter mais informações sobre os pipelines de inferência, consulte [Pipelines de inferência na Amazon AI SageMaker](inference-pipelines.md).
Você pode registrar um modelo com um pipeline de inferência especificando os contêineres e as variáveis de ambiente associadas. Para criar uma versão do modelo com um pipeline de inferência usando o AWS SDK para Python (Boto3) console do Amazon SageMaker Studio ou criando uma etapa em um pipeline de criação de modelos de SageMaker IA, use as etapas a seguir.
**Topics**
+ [Registrar uma versão do modelo (SageMaker AI Pipelines)](#model-registry-pipeline)
+ [Registrar uma versão do modelo (Boto3)](#model-registry-version-api)
+ [Registrar uma versão do modelo (Studio ou Studio Classic)](#model-registry-studio)
+ [Registrar uma versão do modelo de uma conta diferente](#model-registry-version-xaccount)
## Registrar uma versão do modelo (SageMaker AI Pipelines)
Para registrar uma versão do modelo usando um pipeline de criação de modelos de SageMaker IA, crie uma `RegisterModel` etapa em seu pipeline. Para obter mais informações sobre a criação de uma etapa `RegisterModel` de um pipeline, consulte [Etapa 8: definir uma RegisterModel etapa para criar um pacote de modelo](define-pipeline.md#define-pipeline-register).
## Registrar uma versão do modelo (Boto3)
Para registrar uma versão do modelo usando o Boto3, chame a operação de API `create_model_package`.
Primeiro, você configura o dicionário de parâmetros para passar a operação de API `create_model_package`.
```
# Specify the model source
model_url = "s3://your-bucket-name/model.tar.gz"
modelpackage_inference_specification = {
"InferenceSpecification": {
"Containers": [
{
"Image": image_uri,
"ModelDataUrl": model_url
}
],
"SupportedContentTypes": [ "text/csv" ],
"SupportedResponseMIMETypes": [ "text/csv" ],
}
}
# Alternatively, you can specify the model source like this:
# modelpackage_inference_specification["InferenceSpecification"]["Containers"][0]["ModelDataUrl"]=model_url
create_model_package_input_dict = {
"ModelPackageGroupName" : model_package_group_name,
"ModelPackageDescription" : "Model to detect 3 different types of irises (Setosa, Versicolour, and Virginica)",
"ModelApprovalStatus" : "PendingManualApproval"
}
create_model_package_input_dict.update(modelpackage_inference_specification)
```
Em seguida, você chama a operação de API `create_model_package`, passando no dicionário de parâmetros que você acabou de configurar.
```
create_model_package_response = sm_client.create_model_package(**create_model_package_input_dict)
model_package_arn = create_model_package_response["ModelPackageArn"]
print('ModelPackage Version ARN : {}'.format(model_package_arn))
```
## Registrar uma versão do modelo (Studio ou Studio Classic)
Para registrar uma versão do modelo no console do Amazon SageMaker Studio, conclua as etapas a seguir com base no uso do Studio ou do Studio Classic.
------
#### [ Studio ]
1. Abra o console do SageMaker Studio seguindo as instruções em [Iniciar o Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. No painel de navegação à esquerda, selecione **Modelos** no menu.
1. Escolha a guia **Modelos registrados**, se ainda não estiver selecionada.
1. Logo abaixo da guia **Modelos registrados**, escolha **Grupos de modelos** e **Meus modelos**, se ainda não estiverem selecionados.
1. Escolha **Registrar**. Isso abrirá a página do **Registrar modelo**.
1. Siga as instruções fornecidas na página **Registrar modelo**.
1. Depois de analisar suas escolhas, escolha **Registrar**. Assim que concluído, a página de versão do modelo **Visão geral** será aberta.
------
#### [ Studio Classic ]
1. Faça login no Amazon SageMaker Studio Classic. Para obter mais informações, consulte [Launch Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. No painel de navegação à esquerda, selecione o ícone **Início** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Escolha **Modelos** e, em seguida, **Registro de modelo**.
1. Abra o formulário **Registrar versão**. É possível fazer isso de duas formas:
+ Escolha **Ações** e, em seguida, escolha **Criar versão do modelo**.
+ Selecione o nome do grupo de modelos para o qual você deseja criar uma versão do modelo e escolha **Criar versão do modelo**.
1. No formulário **Registrar versão do modelo**, insira as seguintes informações:
+ No menu suspenso **Nome do grupo de pacotes de modelos**, selecione o nome do grupo de modelos.
+ (Opcional) Insira uma descrição para sua versão do modelo.
+ No menu suspenso **Status da aprovação do modelo**, selecione o status da aprovação da versão.
+ (Opcional) No campo **Metadados personalizados**, adicione tags personalizadas como pares de valores-chave.
1. Escolha **Próximo**.
1. No formulário **Especificação de inferência**, insira as seguintes informações:
+ Insira o local da sua imagem de inferência.
+ Insira o local do artefato de dados do modelo.
+ (Opcional) Insira informações sobre as imagens preferidas para trabalhos de inferência em tempo real e transformação, além dos tipos de MIME de entrada e saída compatíveis.
1. Escolha **Próximo**.
1. (Opcional) Forneça detalhes para ajudar nas recomendações de endpoints.
1. Escolha **Próximo**.
1. (Opcional) Escolha as métricas do modelo que você deseja incluir.
1. Escolha **Próximo**.
1. Verifique se as configurações exibidas estão corretas e escolha **Registrar versão do modelo**. Se, posteriormente, você vir uma janela modal com uma mensagem de erro, escolha **Exibir** (ao lado da mensagem) para visualizar a origem do erro.
1. Confirme se a nova versão do modelo aparece na página do grupo de modelos principais.
------
## Registrar uma versão do modelo de uma conta diferente
Para registrar versões de modelo com um grupo de modelos criado por uma AWS conta diferente, você deve adicionar uma política de AWS Identity and Access Management recursos entre contas para habilitar essa conta. Por exemplo, uma AWS conta em sua organização é responsável pelos modelos de treinamento e uma conta diferente é responsável pelo gerenciamento, implantação e atualização dos modelos. Você cria políticas de recursos do IAM e aplica as políticas ao recurso de contas específicas ao qual deseja conceder acesso para esse caso. Para obter mais informações sobre políticas de recursos entre contas em AWS, consulte [Lógica de avaliação de políticas entre contas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html) no Guia do *AWS Identity and Access Management usuário*.
Para permitir a descoberta entre contas e, portanto, que outras contas visualizem grupos de pacotes de modelo por meio da conta do proprietário do recurso, consulte [Detecção entre contas](model-registry-ram.md).
**nota**
Você também deve usar uma chave do KMS para criptografar a ação de [configurar dados de saída](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_OutputDataConfig.html) durante o treinamento para implantação do modelo entre contas.
Para habilitar o registro de modelos entre contas no SageMaker AI, você precisa fornecer uma política de recursos entre contas para o grupo de modelos que contém as versões do modelo. Veja a seguir um exemplo que cria políticas entre contas para o Grupo de Modelos e aplica essas políticas a esse recurso específico.
A configuração a seguir deve ser definida na conta de origem, que registra modelos entre contas em um grupo de modelos. Neste exemplo, a conta de origem é a conta de treinamento de modelos que treinará e, em seguida, registrará o modelo entre contas no Registro do Modelo da conta do Registro do Modelo.
O exemplo pressupõe que você tenha definido anteriormente as seguintes variáveis:
+ `sm_client`— Um cliente SageMaker AI Boto3.
+ `model_package_group_name`: O grupo de modelos ao qual você deseja conceder acesso.
+ `model_package_group_arn`: O ARN do grupo de modelos ao qual você deseja conceder acesso entre contas.
+ `bucket`: O bucket do Amazon S3 em que os artefatos de treinamento de modelos são armazenados.
Para poder implantar um modelo criado em uma conta diferente, o usuário deve ter uma função que tenha acesso às ações de SageMaker IA, como uma função com a política `AmazonSageMakerFullAccess` gerenciada. Para obter informações sobre políticas gerenciadas por SageMaker IA, consulte[AWS políticas gerenciadas para Amazon SageMaker AI](security-iam-awsmanpol.md).
### Políticas de recursos do IAM obrigatórias
O diagrama a seguir captura as políticas necessárias para permitir o registro do modelo entre contas. Conforme mostrado, essas políticas precisam estar ativas durante o treinamento do modelo para registrar adequadamente o modelo na conta do Registro de Modelos.
![\[\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model_registry_cross_account.png)
O Amazon ECR, o Amazon S3 AWS KMS e as políticas são demonstradas nos seguintes exemplos de código.
**Exemplo de política do Amazon ECR**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AddPerm",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": [
"ecr:BatchGetImage",
"ecr:Describe*"
]
}
]
}
```
------
**Exemplo de política do Amazon S3**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AddPerm",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": [
"s3:GetObject",
"s3:GetBucketAcl",
"s3:GetObjectAcl"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
------
** AWS KMS Política de amostra**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AddPerm",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey*"
],
"Resource": "*"
}
]
}
```
------
### Aplicar políticas de recursos às contas
A configuração de política a seguir aplica as políticas abordadas na seção anterior e deve ser colocada na conta de treinamento de modelos.
```
import json
# The Model Registry account id of the Model Group
model_registry_account = "111111111111"
# The model training account id where training happens
model_training_account = "222222222222"
# 1. Create a policy for access to the ECR repository
# in the model training account for the Model Registry account Model Group
ecr_repository_policy = {"Version": "2012-10-17",
"Statement": [{"Sid": "AddPerm",
"Effect": "Allow",
"Principal": {
"AWS": f"arn:aws:iam::{model_registry_account}:root"
},
"Action": [
"ecr:BatchGetImage",
"ecr:Describe*"
]
}]
}
# Convert the ECR policy from JSON dict to string
ecr_repository_policy = json.dumps(ecr_repository_policy)
# Set the new ECR policy
ecr = boto3.client('ecr')
response = ecr.set_repository_policy(
registryId = model_training_account,
repositoryName = "decision-trees-sample",
policyText = ecr_repository_policy
)
# 2. Create a policy in the model training account for access to the S3 bucket
# where the model is present in the Model Registry account Model Group
bucket_policy = {"Version": "2012-10-17",
"Statement": [{"Sid": "AddPerm",
"Effect": "Allow",
"Principal": {"AWS": f"arn:aws:iam::{model_registry_account}:root"
},
"Action": [
"s3:GetObject",
"s3:GetBucketAcl",
"s3:GetObjectAcl"
],
"Resource": [
"arn:aws:s3:::{bucket}/*",
"Resource: arn:aws:s3:::{bucket}"
]
}]
}
# Convert the S3 policy from JSON dict to string
bucket_policy = json.dumps(bucket_policy)
# Set the new bucket policy
s3 = boto3.client("s3")
response = s3.put_bucket_policy(
Bucket = bucket,
Policy = bucket_policy)
# 3. Create the KMS grant for the key used during training for encryption
# in the model training account to the Model Registry account Model Group
client = boto3.client("kms")
response = client.create_grant(
GranteePrincipal=model_registry_account,
KeyId=kms_key_id
Operations=[
"Decrypt",
"GenerateDataKey",
],
)
```
A configuração a seguir precisa ser colocada na conta do Registro do Modelo em que o Grupo de Modelos existe.
```
# The Model Registry account id of the Model Group
model_registry_account = "111111111111"
# 1. Create policy to allow the model training account to access the ModelPackageGroup
model_package_group_policy = {"Version": "2012-10-17",
"Statement": [
{
"Sid": "AddPermModelPackageVersion",
"Effect": "Allow",
"Principal": {"AWS": f"arn:aws:iam::{model_training_account}:root"},
"Action": ["sagemaker:CreateModelPackage"],
"Resource": f"arn:aws:sagemaker:{region}:{model_registry_account}:model-package/{model_package_group_name}/*"
}
]
}
# Convert the policy from JSON dict to string
model_package_group_policy = json.dumps(model_package_group_policy)
# Set the new policy
response = sm_client.put_model_package_group_policy(
ModelPackageGroupName = model_package_group_name,
ResourcePolicy = model_package_group_policy)
```
Por fim, use a ação `create_model_package` a partir da conta de treinamento de modelos para registrar o pacote de modelos entre contas.
```
# Specify the model source
model_url = "s3://{bucket}/model.tar.gz"
#Set up the parameter dictionary to pass to the create_model_package API operation
modelpackage_inference_specification = {
"InferenceSpecification": {
"Containers": [
{
"Image": f"{model_training_account}.dkr.ecr.us-east-2.amazonaws.com/decision-trees-sample:latest",
"ModelDataUrl": model_url
}
],
"SupportedContentTypes": [ "text/csv" ],
"SupportedResponseMIMETypes": [ "text/csv" ],
}
}
# Alternatively, you can specify the model source like this:
# modelpackage_inference_specification["InferenceSpecification"]["Containers"][0]["ModelDataUrl"]=model_url
create_model_package_input_dict = {
"ModelPackageGroupName" : model_package_group_arn,
"ModelPackageDescription" : "Model to detect 3 different types of irises (Setosa, Versicolour, and Virginica)",
"ModelApprovalStatus" : "PendingManualApproval"
}
create_model_package_input_dict.update(modelpackage_inference_specification)
# Create the model package in the Model Registry account
create_model_package_response = sm_client.create_model_package(**create_model_package_input_dict)
model_package_arn = create_model_package_response["ModelPackageArn"]
print('ModelPackage Version ARN : {}'.format(model_package_arn))
```
# Exibir grupos e versões de modelos
Versões e grupos de modelos ajudam você a organizar seus modelos. Você pode ver uma lista das versões do modelo em um grupo de modelos usando o console AWS SDK para Python (Boto3) (Boto3) ou o console do Amazon SageMaker Studio.
## Visualizar uma lista das versões do modelo em um grupo
Você pode visualizar todas as versões do modelo associadas a um grupo de modelos. Se um grupo de modelos representar todos os modelos que você treina para resolver um problema específico de ML, você poderá visualizar todos esses modelos relacionados.
### Visualizar uma lista das versões do modelo em um grupo (Boto3)
Para visualizar as versões de modelo associadas a um grupo de modelos usando o Boto3, chame a operação de API `list_model_packages` e passe o nome do grupo de modelos como o valor do parâmetro `ModelPackageGroupName`. O código a seguir lista as versões do modelo associadas ao grupo de modelos que você criou[Criar um grupo de modelo (Boto3)](model-registry-model-group.md#model-registry-package-group-api).
```
sm_client.list_model_packages(ModelPackageGroupName=model_package_group_name)
```
### Visualizar uma lista das versões do modelo em um grupo (Studio ou Studio Classic)
Para ver uma lista das versões do modelo em um grupo de modelos no console do Amazon SageMaker Studio, conclua as etapas a seguir com base no uso do Studio ou do Studio Classic.
------
#### [ Studio ]
1. Abra o console do SageMaker Studio seguindo as instruções em [Iniciar o Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. No painel de navegação à esquerda, selecione **Modelos** no menu.
1. Escolha a guia **Modelos registrados**, se ainda não estiver selecionada.
1. Logo abaixo da etiqueta da guia **Modelos registrados**, escolha **Grupos de modelos**, se ainda não estiver selecionado.
1. Na lista de grupos de modelos, escolha o colchete angular à esquerda do grupo de modelos que você deseja visualizar.
1. Uma lista das versões do modelo no grupo de modelos aparece.
1. (Opcional) Escolha **Exibir tudo**, se exibido, para ver versões adicionais do modelo.
------
#### [ Studio Classic ]
1. Faça login no Amazon SageMaker Studio Classic. Para obter mais informações, consulte [Launch Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. No painel de navegação à esquerda, selecione o ícone **Início** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Escolha **Modelos** e, em seguida, **Registro de modelo**.
1. Na lista de grupos de modelos, selecione o nome do Grupo de modelos que você deseja visualizar.
1. Uma nova guia aparece com uma lista das versões do modelo no Grupo de modelos.
------
# Atualizar os detalhes de uma versão do modelo
Você pode visualizar e atualizar os detalhes de uma versão específica do modelo usando o console AWS SDK para Python (Boto3) ou o Amazon SageMaker Studio.
**Importante**
A Amazon SageMaker AI integra cartões de modelo ao registro de modelos. Um pacote de modelo registrado no registro de modelos inclui um cartão de modelo simplificado como um componente do pacote do modelo. Para obter mais informações, consulte [Esquema do cartão de modelo do pacote de modelos (Studio)](#model-card-schema).
## Visualizar e atualizar os detalhes de uma versão do modelo (Boto3)
Para visualizar os detalhes de uma versão do modelo usando o Boto3, conclua as etapas a seguir.
1. Chame a operação de API `list_model_packages` para visualizar as versões do modelo em um grupo de modelos.
```
sm_client.list_model_packages(ModelPackageGroupName="ModelGroup1")
```
A resposta é uma lista de resumos de pacotes de modelos. Você pode obter o nome do recurso da Amazon (ARN) das versões do modelo nesta lista.
```
{'ModelPackageSummaryList': [{'ModelPackageGroupName': 'AbaloneMPG-16039329888329896',
'ModelPackageVersion': 1,
'ModelPackageArn': 'arn:aws:sagemaker:us-east-2:123456789012:model-package/ModelGroup1/1',
'ModelPackageDescription': 'TestMe',
'CreationTime': datetime.datetime(2020, 10, 29, 1, 27, 46, 46000, tzinfo=tzlocal()),
'ModelPackageStatus': 'Completed',
'ModelApprovalStatus': 'Approved'}],
'ResponseMetadata': {'RequestId': '12345678-abcd-1234-abcd-aabbccddeeff',
'HTTPStatusCode': 200,
'HTTPHeaders': {'x-amzn-requestid': '12345678-abcd-1234-abcd-aabbccddeeff',
'content-type': 'application/x-amz-json-1.1',
'content-length': '349',
'date': 'Mon, 23 Nov 2020 04:56:50 GMT'},
'RetryAttempts': 0}}
```
1. Chame `describe_model_package` para ver os detalhes da versão do modelo. Você passa o ARN de uma versão do modelo para a qual você obteve na saída da chamada para `list_model_packages`.
```
sm_client.describe_model_package(ModelPackageName="arn:aws:sagemaker:us-east-2:123456789012:model-package/ModelGroup1/1")
```
A saída dessa chamada é um objeto JSON com os detalhes da versão do modelo.
```
{'ModelPackageGroupName': 'ModelGroup1',
'ModelPackageVersion': 1,
'ModelPackageArn': 'arn:aws:sagemaker:us-east-2:123456789012:model-package/ModelGroup/1',
'ModelPackageDescription': 'Test Model',
'CreationTime': datetime.datetime(2020, 10, 29, 1, 27, 46, 46000, tzinfo=tzlocal()),
'InferenceSpecification': {'Containers': [{'Image': '257758044811.dkr.ecr.us-east-2.amazonaws.com/sagemaker-xgboost:1.0-1-cpu-py3',
'ImageDigest': 'sha256:99fa602cff19aee33297a5926f8497ca7bcd2a391b7d600300204eef803bca66',
'ModelDataUrl': 's3://sagemaker-us-east-2-123456789012/ModelGroup1/pipelines-0gdonccek7o9-AbaloneTrain-stmiylhtIR/output/model.tar.gz'}],
'SupportedTransformInstanceTypes': ['ml.m5.xlarge'],
'SupportedRealtimeInferenceInstanceTypes': ['ml.t2.medium', 'ml.m5.xlarge'],
'SupportedContentTypes': ['text/csv'],
'SupportedResponseMIMETypes': ['text/csv']},
'ModelPackageStatus': 'Completed',
'ModelPackageStatusDetails': {'ValidationStatuses': [],
'ImageScanStatuses': []},
'CertifyForMarketplace': False,
'ModelApprovalStatus': 'PendingManualApproval',
'LastModifiedTime': datetime.datetime(2020, 10, 29, 1, 28, 0, 438000, tzinfo=tzlocal()),
'ResponseMetadata': {'RequestId': '12345678-abcd-1234-abcd-aabbccddeeff',
'HTTPStatusCode': 200,
'HTTPHeaders': {'x-amzn-requestid': '212345678-abcd-1234-abcd-aabbccddeeff',
'content-type': 'application/x-amz-json-1.1',
'content-length': '1038',
'date': 'Mon, 23 Nov 2020 04:59:38 GMT'},
'RetryAttempts': 0}}
```
### Esquema do cartão de modelo do pacote de modelos (Studio)
Todos os detalhes relacionados à versão do modelo estão encapsulados no cartão do modelo do pacote de modelos. O cartão modelo de um pacote modelo é um uso especial do Amazon SageMaker Model Card e seu esquema é simplificado. O esquema do cartão de modelo do pacote de modelos é mostrado no menu suspenso expansível a seguir.
#### Esquema do cartão de modelo do pacote de modelos
```
{
"title": "SageMakerModelCardSchema",
"description": "Schema of a model package’s model card.",
"version": "0.1.0",
"type": "object",
"additionalProperties": false,
"properties": {
"model_overview": {
"description": "Overview about the model.",
"type": "object",
"additionalProperties": false,
"properties": {
"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
}
}
}
},
"intended_uses": {
"description": "Intended usage of model.",
"type": "object",
"additionalProperties": false,
"properties": {
"purpose_of_model": {
"description": "Reason 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": "Business problem solved by the model.",
"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 for which the model is optimized.",
"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": "Ethical considerations for model users.",
"type": "string",
"maxLength": 2048
},
"caveats_and_recommendations": {
"description": "Caveats and recommendations for model users.",
"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 the algorithm used to create the model package. The algorithm must be either an algorithm resource in your SageMaker AI account or an algorithm in AWS Marketplace that you are subscribed to.",
"type": "string",
"maxLength": 170
},
"model_data_url": {
"description": "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 used to create model package.",
"type": "array",
"minContains": 1,
"maxContains": 15,
"items": {
"type": "object",
"additionalProperties": false,
"required": [
"image"
],
"properties": {
"model_data_url": {
"description": "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 Elastic 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 an 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.",
"type": "string",
"maxLength": 1024
},
"objective_function": {
"description": "Objective function for which the training job is optimized.",
"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 hyperparameter.",
"type": "object",
"required": [
"name",
"value"
],
"additionalProperties": false,
"properties": {
"name": {
"type": "string",
"pattern": ".{1,255}"
},
"value": {
"type": "string",
"pattern": ".{1,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
}
}
}
```
## Visualizar e atualizar os detalhes de uma versão do modelo (Studio ou Studio Classic)
Para visualizar e atualizar os detalhes de uma versão do modelo, conclua as etapas a seguir com base no uso do Studio ou do Studio Classic. No Studio Classic, você pode atualizar o status de aprovação de uma versão do modelo. Para obter detalhes, consulte [Atualizar o status da aprovação de um modelo](model-registry-approve.md). No Studio, por outro lado, a SageMaker IA cria uma placa de modelo para um pacote de modelo, e a interface de usuário da versão do modelo fornece opções para atualizar detalhes na placa de modelo.
------
#### [ Studio ]
1. Abra o console do SageMaker Studio seguindo as instruções em [Iniciar o Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. No painel de navegação à esquerda, selecione **Modelos** no menu.
1. Escolha a guia **Modelos registrados**, se ainda não estiver selecionada.
1. Logo abaixo da etiqueta da guia **Modelos registrados**, escolha **Grupos de modelos**, se ainda não estiver selecionado.
1. Selecione o nome do grupo de modelos que contém a versão do modelo a ser visualizada.
1. Na lista de versões do modelo, selecione a versão do modelo para visualizar.
1. Escolha uma das guias a seguir.
+ **Treinamento**: para visualizar ou editar detalhes relacionados ao seu trabalho de treinamento, incluindo métricas de desempenho, artefatos, perfil e criptografia do IAM e contêineres. Para obter mais informações, consulte [Adicionar um trabalho de treinamento (Studio)](model-registry-details-studio-training.md).
+ **Avaliar**: para visualizar ou editar detalhes relacionados ao seu trabalho de treinamento, como métricas de desempenho, conjuntos de dados de avaliação e segurança. Para obter mais informações, consulte [Adicionar um trabalho de avaliação (Studio)](model-registry-details-studio-evaluate.md).
+ **Auditoria**: para visualizar ou editar detalhes de alto nível relacionados à finalidade comercial, ao uso, ao risco e aos detalhes técnicos do modelo, como limitações de algoritmo e desempenho. Para obter mais informações, consulte [Atualizar informações de auditoria (governança) (Studio)](model-registry-details-studio-audit.md).
+ **Implantar**: para visualizar ou editar a localização do seu contêiner de imagem de inferência e das instâncias que compõem o endpoint. Para obter mais informações, consulte [Atualizar informações de implantação (Studio)](model-registry-details-studio-deploy.md).
------
#### [ Studio Classic ]
1. Faça login no Amazon SageMaker Studio Classic. Para obter mais informações, consulte [Launch Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. No painel de navegação à esquerda, selecione o ícone **Início** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Escolha **Modelos** e, em seguida, **Registro de modelo**.
1. Na lista de grupos de modelos, selecione o nome do Grupo de modelos que você deseja visualizar.
1. Uma nova guia aparece com uma lista das versões do modelo no Grupo de modelos.
1. Na lista de versões do modelo, selecione o nome da versão do modelo cujos detalhes você deseja visualizar.
1. Na guia da versão do modelo que se abre, escolha uma das seguintes opções para ver detalhes sobre a versão do modelo:
+ **Atividade**: mostra eventos da versão do modelo, como atualizações de status da aprovação.
+ **Qualidade do modelo**: relata métricas relacionadas às verificações de qualidade do modelo do Model Monitor, que comparam as predições de modelo com o Ground Truth. Para obter mais informações sobre as verificações de qualidade do modelo Model Monitor, consulte [Qualidade do modelo](model-monitor-model-quality.md).
+ **Explicabilidade**: relata métricas relacionadas com as atribuições de verificação de atributos do Model Monitor, que comparam as classificações relativas de seus atributos nos dados de treinamento com os dados ao vivo. Para obter mais informações sobre as explicabilidade do modelo Model Monitor, consulte [Desvio de atribuição de atributos para modelos em produção](clarify-model-monitor-feature-attribution-drift.md).
+ **Desvio**: relata métricas relacionadas às verificações de desvio de polarização do Model Monitor, que comparam a distribuição de dados ao vivo com os dados de treinamento. Para obter mais informações sobre as verificações de desvio de polarização do Model Monitor, consulte [Desvio de polarização para modelos em produção](clarify-model-monitor-bias-drift.md).
+ **Recomendador de inferência**: fornece recomendações iniciais de instância para otimizar o desempenho baseado em seu modelo e exemplo de carga útil.
+ **Teste de carga**: executa testes de carga em todos os tipos de instância de sua escolha quando você fornece seus requisitos de produção específicos, como restrições de latência e throughput.
+ **Especificação de inferência**: exibe tipos de instância para seus trabalhos de transformação e inferência em tempo real, e informações sobre seus contêineres do Amazon ECR.
+ **Informações**: mostra informações como o projeto ao qual a versão do modelo está associada, o pipeline que gerou o modelo, o grupo de modelos e o local do modelo no Amazon S3.
------
# Adicionar um trabalho de treinamento (Studio)
**Importante**
Em 30 de novembro de 2023, a experiência anterior do Amazon SageMaker Studio agora se chama Amazon SageMaker Studio Classic. A seção a seguir é específica ao uso da experiência atualizada do Studio. Para obter informações sobre como usar a aplicação do Studio Classic, consulte [Amazon SageMaker Studio Clássico](studio.md).
Você pode adicionar um trabalho de treinamento, criado externamente ou com SageMaker IA, ao seu modelo. **Se você adicionar um trabalho de SageMaker treinamento, a SageMaker IA preencherá previamente os campos de todas as subpáginas na guia Treinar.** Se você adicionar um trabalho de treinamento criado externamente, precisará adicionar detalhes relacionados ao seu trabalho de treinamento manualmente.
**Para adicionar um trabalho de treinamento ao seu pacote de modelo, conclua as etapas a seguir.**
1. Selecione a guia **Treinar**.
1. Escolha **Adicionar**. Se você não vir essa opção, é porque já deve ter um trabalho de treinamento anexado. Se você quiser remover esse trabalho de treinamento, conclua as instruções a seguir para remover um trabalho de treinamento.
1. Você pode adicionar um trabalho de treinamento criado na SageMaker IA ou um trabalho de treinamento criado externamente.
1. Para adicionar um trabalho de treinamento que você criou na SageMaker IA, conclua as etapas a seguir.
1. Escolha **SageMaker AI**.
1. Marque a opção ao lado do trabalho de treinamento que você deseja adicionar.
1. Escolha **Adicionar**.
1. Para adicionar um trabalho de treinamento criado externamente, conclua as etapas a seguir.
1. Escolha **Personalizado**.
1. No campo **Nome**, insira o nome do seu trabalho de treinamento personalizado.
1. Escolha **Adicionar**.
# Remover um trabalho de treinamento (Studio)
Você pode remover um trabalho de treinamento, criado externamente ou com SageMaker IA, do seu modelo concluindo as etapas a seguir.
**Para remover um trabalho de treinamento do pacote de modelo, conclua as etapas a seguir.**
1. Escolha **Treinar**.
1. Escolha o ícone de **engrenagem** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/icons/Settings_squid.png)) na guia **Treinar**.
1. Escolha **Remover** ao lado do seu trabalho de treinamento.
1. Escolha **Sim, eu quero remover **.
1. Selecione **Concluído**.
# Atualizar detalhes do trabalho de treinamento (Studio)
Conclua as etapas a seguir para atualizar os detalhes de um trabalho de treinamento, criado externamente ou com SageMaker IA, associado ao seu modelo.
**Para atualizar (e visualizar) detalhes relacionados ao trabalho de treinamento:**
1. Na guia **Treinar**, visualize o status do trabalho de treinamento. O status é `Complete`, se você adicionou um trabalho de treinamento ao seu pacote de modelos e, `Undefined`, se não tiver adicionado.
1. Para ver detalhes relacionados ao seu trabalho de treinamento, como desempenho, hiperparâmetros e detalhes de identificação, escolha a guia **Treinar**.
1. Para atualizar e visualizar detalhes relacionados ao desempenho do modelo, conclua as etapas a seguir.
1. Escolha **Desempenho** na barra lateral esquerda da guia **Treinar**.
1. Visualize **Métricas** relacionadas ao seu trabalho de treinamento. A página **Desempenho** lista as métricas por nome, valor e quaisquer notas relacionadas à métrica que você tenha adicionado.
1. (Opcional) Para adicionar notas às métricas existentes, conclua as etapas a seguir.
1. Escolha as reticências verticais no canto superior direito da página da versão do modelo e selecione **Editar**.
1. Adicione notas a qualquer uma das métricas listadas.
1. Na parte superior da página da versão do modelo, escolha **Salvar** no banner **Edição da versão do modelo...**.
1. Visualize **Métricas personalizadas** relacionadas ao seu trabalho de treinamento. As métricas personalizadas são formatadas de forma semelhante às métricas.
1. (Opcional) Para adicionar métricas personalizadas, conclua as etapas a seguir.
1. Escolha **Adicionar**.
1. Insira um nome, valor e quaisquer notas opcionais para sua nova métrica.
1. (Opcional) Para remover métricas personalizadas, escolha o ícone de **lixeira** ao lado da métrica que você deseja remover.
1. Na caixa de texto **Observações**, visualize todas as notas que você adicionou relacionadas ao desempenho do seu trabalho de treinamento.
1. (Opcional) Para adicionar ou atualizar observações, conclua as etapas a seguir.
1. Escolha as reticências verticais no canto superior direito da página da versão do modelo e selecione **Editar**.
1. Adicione ou atualize suas notas na caixa de texto **Observações**.
1. Na parte superior da página da versão do modelo, escolha **Salvar** no banner **Edição da versão do modelo...**.
1. Para atualizar e visualizar detalhes relacionados aos artefatos do modelo, conclua as etapas a seguir.
1. Escolha **Artefatos** na barra lateral esquerda da guia **Treinar**.
1. No campo **Localização (URI do S3)**, visualize a localização no Amazon S3 de seus conjuntos de dados de treinamento.
1. No campo **Modelos**, visualize o nome e a localização no Amazon S3 dos artefatos de modelo de outros modelos que você incluiu no trabalho de treinamento.
1. Para atualizar qualquer um dos campos na página **Artefatos**, conclua as etapas a seguir.
1. Escolha as reticências verticais no canto superior direito da página da versão do modelo e selecione **Editar**.
1. Insira novos valores em qualquer um dos campos.
1. Na parte superior da página da versão do modelo, escolha **Salvar** no banner **Edição da versão do modelo...**.
1. Para atualizar e visualizar detalhes relacionados a hiperparâmetros, conclua as etapas a seguir.
1. Escolha **Hiperparâmetros** na barra lateral esquerda da guia **Treinar**.
1. Visualize a SageMaker IA fornecida e os hiperparâmetros personalizados definidos. Cada hiperparâmetro é listado com seu nome e valor.
1. Visualize os hiperparâmetros personalizados que você adicionou.
1. (Opcional) Para adicionar um hiperparâmetro personalizado adicional, conclua as etapas a seguir.
1. Acima do canto superior direito da tabela **Hiperparâmetros personalizados**, escolha **Adicionar**. Um par de novos campos em branco é exibido.
1. Insira o nome e o valor do novo hiperparâmetro personalizado. Esses valores são salvos automaticamente.
1. (Opcional) Para remover um hiperparâmetro personalizado, escolha o ícone de **lixeira** à direita do hiperparâmetro.
1. Para atualizar e visualizar detalhes relacionados ao ambiente de trabalho de treinamento, conclua as etapas a seguir.
1. Escolha **Ambiente** na barra lateral esquerda da guia **Treinar**.
1. Veja os locais de URI do Amazon ECR para qualquer contêiner de trabalho de treinamento adicionado pela SageMaker IA (para um trabalho de SageMaker treinamento) ou por você (para um trabalho de treinamento personalizado).
1. (Opcional) Para adicionar um contêiner de trabalho de treinamento adicional, escolha **Adicionar** e, em seguida, insira o URI do novo contêiner de treinamento.
1. Para atualizar e visualizar o nome do trabalho de treinamento e o nome de recurso da Amazon (ARN) do trabalho de treinamento, conclua as etapas a seguir.
1. Escolha **Detalhes** na barra lateral esquerda da guia **Treinar**.
1. Visualize o nome do trabalho de treinamento e o ARN dele.
# Adicionar um trabalho de avaliação (Studio)
**Importante**
Em 30 de novembro de 2023, a experiência anterior do Amazon SageMaker Studio agora se chama Amazon SageMaker Studio Classic. A seção a seguir é específica ao uso da experiência atualizada do Studio. Para obter informações sobre como usar a aplicação do Studio Classic, consulte [Amazon SageMaker Studio Clássico](studio.md).
Depois de registrar seu modelo, você pode testá-lo com um ou mais conjuntos de dados para avaliar seu desempenho. Você pode adicionar um ou mais trabalhos de avaliação do Amazon S3 ou definir seu próprio trabalho de avaliação inserindo manualmente todos os detalhes. **Se você adicionar um trabalho do Amazon S3, a SageMaker IA preencherá previamente os campos de todas as subpáginas na guia Avaliar.** Se você definir seu próprio trabalho de avaliação, precisará adicionar detalhes relacionados ao seu trabalho de avaliação manualmente.
**Para adicionar seu primeiro trabalho de avaliação ao pacote de modelos, conclua as etapas a seguir.**
1. Escolha a guia **Avaliar**.
1. Escolha **Adicionar**.
1. Você pode adicionar um trabalho de avaliação do Amazon S3 ou um trabalho de avaliação personalizado.
1. Para adicionar um trabalho de avaliação com garantias do Amazon S3, conclua as etapas a seguir.
1. Selecione **S3**.
1. Insira um nome para o trabalho de avaliação.
1. Insira a localização no Amazon S3 para as garantias de saída do trabalho de avaliação.
1. Escolha **Adicionar**.
1. Para adicionar um trabalho de avaliação personalizado, conclua a seguinte etapa:
1. Escolha **Personalizado**.
1. Insira um nome para o trabalho de avaliação.
1. Escolha **Adicionar**.
**Para adicionar um trabalho de avaliação adicional ao pacote de modelos, conclua as etapas a seguir.**
1. Escolha a guia **Avaliar**.
1. Escolha o ícone de **engrenagem** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/icons/Settings_squid.png)) na guia **Treinar**.
1. Na caixa de diálogo, escolha **Adicionar**.
1. Você pode adicionar um trabalho de avaliação do Amazon S3 ou um trabalho de avaliação personalizado.
1. Para adicionar um trabalho de avaliação com garantias do Amazon S3, conclua as etapas a seguir.
1. Selecione **S3**.
1. Insira um nome para o trabalho de avaliação.
1. Insira a localização no Amazon S3 para as garantias de saída do trabalho de avaliação.
1. Escolha **Adicionar**.
1. Para adicionar um trabalho de avaliação personalizado, conclua a seguinte etapa:
1. Escolha **Personalizado**.
1. Insira um nome para o trabalho de avaliação.
1. Escolha **Adicionar**.
# Remover um trabalho de avaliação (Studio)
Você pode remover um trabalho de avaliação, criado externamente ou com SageMaker IA, do seu modelo concluindo as etapas a seguir.
**Para remover um trabalho de avaliação do pacote de modelos, conclua as etapas a seguir.**
1. Escolha a guia **Avaliar**.
1. Escolha o ícone de **engrenagem** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/icons/Settings_squid.png)) na guia **Treinar**.
1. (Opcional) Para encontrar seu trabalho de avaliação na lista, insira um termo de pesquisa na caixa de pesquisa para restringir a lista de opções.
1. Escolha o botão de opção ao lado do trabalho de avaliação.
1. Escolha **Remover **.
1. Escolha **Sim, eu quero remover **.
1. Selecione **Concluído**.
# Atualizar um trabalho de avaliação (Studio)
Conclua as etapas a seguir para atualizar os detalhes de um trabalho de avaliação, criado externamente ou com SageMaker IA, associado ao seu modelo.
**Para atualizar (e visualizar) detalhes relacionados ao trabalho de avaliação:**
1. Na guia **Avaliar**, visualize o status do trabalho de avaliação. O status é `Complete`, se você adicionou um trabalho de avaliação ao seu pacote de modelos e, `Undefined`, se não tiver adicionado.
1. Para ver detalhes relacionados ao seu trabalho de avaliação, como desempenho e localização dos artefatos, escolha a guia **Avaliar**.
1. Para atualizar e visualizar detalhes relacionados ao desempenho do modelo durante a avaliação, conclua as etapas a seguir.
1. Escolha **Desempenho** na barra lateral da guia **Avaliar**.
1. Veja as métricas relacionadas ao seu trabalho de avaliação na lista **Métricas**. A lista **Métricas** exibe as métricas individuais por nome, valor e quaisquer notas relacionadas à métrica que você tenha adicionado.
1. Na caixa de texto **Observações**, visualize todas as notas que você adicionou relacionadas ao desempenho do seu trabalho de avaliação.
1. Para atualizar qualquer um dos campos **Notas** para qualquer métrica ou o campo **Observações**, conclua as etapas a seguir.
1. Escolha as reticências verticais no canto superior direito da página da versão do modelo e selecione **Editar**.
1. Insira notas para qualquer métrica ou na caixa de texto **Observações**.
1. Na parte superior da página da versão do modelo, escolha **Salvar** no banner **Edição da versão do modelo...**.
1. Para atualizar e visualizar detalhes relacionados aos conjuntos de dados do trabalho de avaliação, conclua as etapas a seguir.
1. Escolha **Artefatos** na barra lateral esquerda da página **Avaliar**.
1. Visualize os conjuntos de dados usados em seu trabalho de avaliação.
1. (Opcional) Para adicionar um conjunto de dados, escolha **Adicionar** e insira um URI do Amazon S3 para o conjunto de dados.
1. (Opcional) Para remover um conjunto de dados, escolha o ícone de **lixeira** ao lado do conjunto de dados que você deseja remover.
1. Para ver o nome do trabalho e o ARN do trabalho de avaliação, escolha **Detalhes**.
# Atualizar informações de auditoria (governança) (Studio)
**Importante**
Em 30 de novembro de 2023, a experiência anterior do Amazon SageMaker Studio agora se chama Amazon SageMaker Studio Classic. A seção a seguir é específica ao uso da experiência atualizada do Studio. Para obter informações sobre como usar a aplicação do Studio Classic, consulte [Amazon SageMaker Studio Clássico](studio.md).
Documente detalhes importantes do modelo para ajudar sua organização a estabelecer uma estrutura robusta de governança de modelos. Você e os membros da sua equipe podem consultar esses detalhes para que usem o modelo para os casos de uso apropriados, conheçam o domínio comercial e os proprietários do modelo, além de compreenderem os riscos dele. Você também pode salvar detalhes sobre o desempenho esperado do modelo e os motivos das limitações de desempenho.
**Para visualizar ou atualizar detalhes relacionados à governança do modelo, conclua as etapas a seguir.**
1. Na guia **Auditoria**, visualize o status de aprovação do cartão de modelo. O status pode ser uma das seguintes opções:
+ **Rascunho**: o cartão de modelo ainda é um rascunho.
+ **Aprovação pendente**: o cartão de modelo está aguardando aprovação.
+ **Aprovado**: o cartão de modelo foi aprovado.
1. Para atualizar o status de aprovação do cartão de modelo, escolha o menu suspenso ao lado do status de aprovação e selecione o status de aprovação atualizado.
1. Para atualizar e visualizar detalhes relacionados ao risco do pacote de modelos, conclua as etapas a seguir.
1. Escolha **Risco** na barra lateral esquerda da guia **Auditoria**.
1. Veja a classificação de risco atual e a explicação para a classificação de risco.
1. Para atualizar a classificação ou explicação, conclua as etapas a seguir.
1. Escolha as reticências verticais no canto superior direito da página **Auditoria** e selecione **Editar**.
1. (Opcional) Escolha uma classificação de risco atualizada.
1. (Opcional) Atualize a explicação da classificação de risco.
1. Na parte superior da página da versão do modelo, escolha **Salvar** no banner **Edição da versão do modelo...**.
1. Para atualizar e visualizar detalhes relacionados ao uso do pacote de modelos, conclua as etapas a seguir.
1. Escolha **Uso** na barra lateral esquerda da guia **Auditoria**.
1. Visualize o texto que você adicionou nos seguintes campos:
+ **Tipo de problema**: a categoria do algoritmo de machine learning usada para criar seu modelo.
+ **Tipo de algoritmo**: o algoritmo específico usado para criar seu modelo.
+ **Usos pretendidos**: a aplicação atual do modelo em seu problema comercial.
+ **Fatores que afetam a eficácia do modelo**: notas sobre as limitações de desempenho do seu modelo.
+ **Uso recomendado**: os tipos de aplicações que você pode criar com o modelo, os cenários nos quais você pode esperar um desempenho razoável ou o tipo de dados a ser usado com o modelo.
+ **Considerações éticas**: uma descrição de como seu modelo pode discriminar com base em fatores como idade ou sexo.
1. Para atualizar qualquer um dos campos listados anteriormente, conclua as etapas a seguir.
1. Escolha as reticências verticais no canto superior direito da página da versão do modelo e escolha **Editar**.
1. (Opcional) Use os menus suspensos de **Tipo de problema** e **Tipo de algoritmo** para selecionar novos valores, se necessário.
1. (Opcional) Atualize as descrições de texto nos campos restantes.
1. Na parte superior da página da versão do modelo, escolha **Salvar** no banner **Edição da versão do modelo...**.
1. Para atualizar e visualizar detalhes relacionados às partes interessadas do pacote de modelos, conclua as etapas a seguir.
1. Escolha **Partes interessadas** na barra lateral esquerda da guia **Auditoria**.
1. Visualize o proprietário e o criador do modelo atual, se houver.
1. Para atualizar o proprietário ou criador do modelo, conclua as seguintes etapas:
1. Escolha as reticências verticais no canto superior direito da página da versão do modelo e escolha **Editar**.
1. Atualize os campos do proprietário do modelo ou do criador do modelo.
1. Na parte superior da página da versão do modelo, escolha **Salvar** no banner **Edição da versão do modelo...**.
1. Para atualizar e visualizar detalhes relacionados ao problema comercial que seu pacote de modelos atende, conclua as etapas a seguir.
1. Escolha **Negócios** na barra lateral esquerda da guia **Auditoria**.
1. Visualize as descrições atuais, se houver, do problema comercial que o modelo aborda, das partes interessadas do problema comercial e da linha de negócios.
1. Para atualizar qualquer um dos campos na guia **Negócios**, conclua as etapas a seguir.
1. Escolha as reticências verticais no canto superior direito da página da versão do modelo e escolha **Editar**.
1. Atualize as descrições em qualquer um dos campos.
1. Na parte superior da página da versão do modelo, escolha **Salvar** no banner **Edição da versão do modelo...**.
1. Para atualizar e visualizar a documentação existente (representada como pares de valores-chave) do seu modelo, conclua as etapas a seguir.
1. Escolha **Documentação** na barra lateral esquerda da página **Auditoria**.
1. Visualize pares de valores-chave existentes.
1. Para adicionar um par de valor-chave, conclua as seguintes etapas:
1. Escolha as reticências verticais no canto superior direito da página da versão do modelo e escolha **Editar**.
1. Escolha **Adicionar**.
1. Insira uma nova chave e o valor associado.
1. Na parte superior da página da versão do modelo, escolha **Salvar** no banner **Edição da versão do modelo...**.
1. Para remover um par de valor-chave, conclua as seguintes etapas:
1. Escolha as reticências verticais no canto superior direito da página da versão do modelo e escolha **Editar**.
1. Escolha o ícone de **lixeira** ao lado do par de valor-chave a ser removido.
1. Na parte superior da página da versão do modelo, escolha **Salvar** no banner **Edição da versão do modelo...**.
# Atualizar informações de implantação (Studio)
**Importante**
Em 30 de novembro de 2023, a experiência anterior do Amazon SageMaker Studio agora se chama Amazon SageMaker Studio Classic. A seção a seguir é específica ao uso da experiência atualizada do Studio. Para obter informações sobre como usar a aplicação do Studio Classic, consulte [Amazon SageMaker Studio Clássico](studio.md).
Depois de avaliar o desempenho do modelo e determinar se ele está pronto para uso em cargas de trabalho de produção, você pode alterar o status de aprovação do modelo para iniciar a implantação CI/CD . Para obter mais informações sobre as definições do status de aprovação, consulte [Atualizar o status da aprovação de um modelo](model-registry-approve.md).
**Para visualizar ou atualizar detalhes relacionados à implantação do pacote de modelos, conclua as etapas a seguir.**
1. Na guia **Implantar**, visualize o status de aprovação do pacote de modelos. Os valores possíveis são estes:
+ **Aprovação pendente**: o modelo está registrado, mas ainda não foi aprovado ou rejeitado para implantação.
+ **Aprovado**: o modelo foi aprovado para implantação de CI/CD. Se houver uma EventBridge regra em vigor que inicia a implantação do modelo após um evento de aprovação do modelo, como é o caso de um modelo criado a partir de um modelo de projeto de SageMaker IA, a SageMaker IA também implanta o modelo.
+ **Rejeitado**: o modelo foi rejeitado para implantação.
Se você precisar alterar o status de aprovação, selecione o menu suspenso ao lado do status e escolha o status atualizado.
1. Para atualizar o status de aprovação do pacote de modelos, selecione a lista suspensa ao lado do status de aprovação e escolha o status de aprovação atualizado.
1. Na lista de **contêineres**, veja os contêineres de imagens de inferência.
1. Na lista de **instâncias**, veja as instâncias que compõem seu endpoint de implantação.
# Comparar versões do modelo
Ao gerar versões do modelo, talvez você queira comparar as versões dos modelos visualizando as métricas relevantes de qualidade do modelo side-by-side. Por exemplo, talvez você queira monitorar a precisão comparando os valores do erro quadrático médio (MSE) ou pode decidir remover modelos com performance insatisfatória em medidas selecionadas. O procedimento a seguir mostra como configurar a comparação da versão do modelo no Registro de modelos usando o console do Amazon SageMaker Studio Classic.
## Compare as versões do modelo (Amazon SageMaker Studio Classic)
**nota**
Você só pode comparar as versões do modelo no console Amazon SageMaker Studio Classic.
Para comparar as versões do modelo em um grupo de modelos, conclua as seguintes etapas:
1. Faça login no Studio Classic. Para obter mais informações, consulte [Visão geral do domínio Amazon SageMaker AI](gs-studio-onboard.md).
1. No painel de navegação à esquerda, selecione o ícone **Início** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Escolha **Modelos** e, em seguida, **Registro de modelo**.
1. Na lista de grupos de modelos, selecione o nome do Grupo de modelos que você deseja visualizar. Uma nova guia é aberta com uma lista das versões do modelo no Grupo de modelos.
1. Na lista de versões do modelo, marque as caixas ao lado das versões do modelo que você deseja comparar.
1. Escolha o menu suspenso **Ações** e escolha **Comparar**. Uma listagem das métricas de qualidade do modelo aparece para os modelos selecionados.
# Visualizar e gerenciar tags de grupo de modelos e versões de modelo
O registro de modelo ajuda você a visualizar e gerenciar tags relacionadas aos seus grupos de modelos. Você pode usar tags para categorizar grupos de modelos por finalidade, proprietário, ambiente ou outros critérios. As instruções a seguir mostram como visualizar, adicionar, excluir e editar suas tags no console do Amazon SageMaker Studio.
**nota**
Os pacotes de SageMaker modelos no Registro de Modelos não oferecem suporte a tags — são pacotes de modelos com versão. Em vez disso, você pode adicionar pares de valores-chave usando `CustomerMetadataProperties`. Os grupos de pacotes de modelos no registro do modelo oferecem apoio à marcação com tag.
## Visualizar e gerenciar tags de grupos de modelos
------
#### [ Studio ]
**Para visualizar uma tag de grupo de modelos, conclua as seguintes etapas:**
1. Abra o console do SageMaker Studio seguindo as instruções em [Iniciar o Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. No painel de navegação à esquerda, selecione **Modelos** para exibir uma lista de seus grupos de modelos.
1. Escolha a guia **Modelos registrados**, se ainda não estiver selecionada.
1. Logo abaixo da etiqueta da guia **Modelos registrados**, escolha **Grupos de modelos**, se ainda não estiver selecionado.
1. Na lista de grupos de modelos, selecione o nome do grupo de modelos que você deseja visualizar.
1. Na página do grupo de modelos, selecione a guia **Tags**. Veja as tags associadas ao seu grupo de modelos.
**Para adicionar uma tag de grupo de modelos, conclua as seguintes etapas:**
1. Abra o console do SageMaker Studio seguindo as instruções em [Iniciar o Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. No painel de navegação à esquerda, selecione **Modelos** para exibir uma lista de seus grupos de modelos.
1. Escolha a guia **Modelos registrados**, se ainda não estiver selecionada.
1. Logo abaixo da etiqueta da guia **Modelos registrados**, escolha **Grupos de modelos**, se ainda não estiver selecionado.
1. Na lista de Grupos de modelos, selecione o nome do Grupo de modelos que você deseja editar.
1. Na página do grupo de modelos, selecione a guia **Tags**.
1. Escolha **Adicionar/editar tags**.
1. Acima de **\$1 Adicionar nova tag**, insira sua nova chave no campo **Chave** em branco.
1. (Opcional) Insira seu novo valor no campo **Valor** em branco.
1. Escolha **Confirmar alterações**.
1. Confirme se sua nova tag aparece na seção **Tags** da página **Informações**.
**Para excluir uma tag de grupo de modelos, conclua as seguintes etapas:**
1. Abra o console do SageMaker Studio seguindo as instruções em [Iniciar o Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. No painel de navegação à esquerda, selecione **Modelos** para exibir uma lista de seus grupos de modelos.
1. Escolha a guia **Modelos registrados**, se ainda não estiver selecionada.
1. Logo abaixo da etiqueta da guia **Modelos registrados**, escolha **Grupos de modelos**, se ainda não estiver selecionado.
1. Na lista de Grupos de modelos, selecione o nome do Grupo de modelos que você deseja editar.
1. Na página do grupo de modelos, selecione a guia **Tags**.
1. Escolha **Adicionar/editar tags**.
1. Escolha o ícone de **lixeira** ao lado do par de valor-chave que você deseja remover.
1. Escolha **Confirmar alterações**.
**Para editar uma tag de grupo de modelos, conclua as seguintes etapas:**
1. Abra o console do SageMaker Studio seguindo as instruções em [Iniciar o Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. No painel de navegação à esquerda, selecione **Modelos** para exibir uma lista de seus grupos de modelos.
1. Escolha a guia **Modelos registrados**, se ainda não estiver selecionada.
1. Logo abaixo da etiqueta da guia **Modelos registrados**, escolha **Grupos de modelos**, se ainda não estiver selecionado.
1. Na lista de Grupos de modelos, selecione o nome do Grupo de modelos que você deseja editar.
1. Na página do grupo de modelos, selecione a guia **Tags**.
1. Escolha **Adicionar/editar tags**.
1. Insira um novo valor no campo **Valor** do par de valor-chave que você deseja editar.
1. Escolha **Confirmar alterações**.
------
#### [ Studio Classic ]
**Para visualizar uma tag de grupo de modelos, conclua as seguintes etapas:**
1. Faça login no Amazon SageMaker Studio Classic. Para obter mais informações, consulte [Launch Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. No painel de navegação à esquerda, selecione o ícone **Início** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Escolha **Modelos** e, em seguida, **Registro de modelo**.
1. Na lista de Grupos de modelos, selecione o nome do Grupo de modelos que você deseja editar.
1. Escolha **Informações**.
1. Veja suas tags na seção **Tags** da página **Informações**.
**Para adicionar uma tag de grupo de modelos, conclua as seguintes etapas:**
1. Faça login no Amazon SageMaker Studio Classic. Para obter mais informações, consulte [Visão geral do domínio Amazon SageMaker AI](gs-studio-onboard.md).
1. No painel de navegação à esquerda, selecione o ícone **Início** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Escolha **Modelos** e, em seguida, **Registro de modelo**.
1. Na lista de Grupos de modelos, selecione o nome do Grupo de modelos que você deseja editar.
1. Escolha **Informações**.
1. Se você não tem nenhuma tag, escolha **Adicionar tags**.
1. Se você tem tags preexistentes, escolha **Gerenciar tags** na seção **Tags**. Uma lista das tags do grupo de modelos aparece como pares de valores-chave.
1. Acima de **Adicionar nova tag**, insira sua nova chave no campo **Chave** em branco.
1. (Opcional) Insira seu novo valor no campo **Valor** em branco.
1. Escolha **Confirmar alterações**.
1. Confirme se sua nova tag aparece na seção **Tags** da página **Informações**.
**Para excluir uma tag de grupo de modelos, conclua as seguintes etapas:**
1. Faça login no Amazon SageMaker Studio Classic. Para obter mais informações, consulte [Visão geral do domínio Amazon SageMaker AI](gs-studio-onboard.md).
1. No painel de navegação à esquerda, selecione o ícone **Início** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Escolha **Modelos** e, em seguida, **Registro de modelo**.
1. Na lista de Grupos de modelos, selecione o nome do Grupo de modelos que você deseja editar.
1. Escolha **Informações**.
1. Na seção **Tags**, escolha **Gerenciar tags**. Uma lista das tags do grupo de modelos aparece como pares de valores-chave.
1. Escolha o ícone de **Lixeira** à direita da tag que você deseja remover.
1. Escolha **Confirmar alterações**.
1. Confirme se sua tag removida não aparece na seção **Tags** da página **Informações**.
**Para editar uma tag de grupo de modelos, conclua as seguintes etapas:**
1. Faça login no Amazon SageMaker Studio Classic. Para obter mais informações, consulte [Visão geral do domínio Amazon SageMaker AI](gs-studio-onboard.md).
1. No painel de navegação à esquerda, selecione o ícone **Início** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Escolha **Modelos** e, em seguida, **Registro de modelo**.
1. Na lista de Grupos de modelos, selecione o nome do Grupo de modelos que você deseja editar.
1. Escolha **Informações**.
1. Na seção **Tags**, escolha **Gerenciar tags**. Uma lista das tags do grupo de modelos aparece como pares de valores-chave.
1. Edite qualquer chave ou valor.
1. Escolha **Confirmar alterações**.
1. Confirme se sua tag contém as alterações na seção **Tags** da página **Informações**.
**Para atribuir ou vincular grupo de modelos a um projeto, conclua as seguintes etapas:**
1. Obtenha tags com chave `sagemaker:project-name` e `sagemaker:project-id` para o projeto de SageMaker IA usando a [ListTags](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListTags.html)API.
1. Para aplicar as tags ao seu grupo de pacotes de modelo, escolha um dos métodos a seguir:
+ Se você criar um novo grupo de pacotes de modelos e quiser adicionar tags, passe suas tags da Etapa 1 para a [CreateModelPackageGroup](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackageGroup.html)API.
+ Se você quiser adicionar tags a um grupo de pacotes de modelos existente, use [AddTags](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AddTags.html) APIso.
+ Se você criar seu grupo de pacotes de modelos por meio de Pipelines, use os `pipeline.upsert()` métodos `pipeline.create()` ou ou passe suas tags para a [RegisterModel](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-register-model)etapa.
------
# Excluir uma versão do modelo
Esse procedimento demonstra como excluir uma versão do modelo no console do Amazon SageMaker Studio.
## Excluir uma versão do modelo (Studio ou Studio Classic)
Para excluir uma versão do modelo no console do Amazon SageMaker Studio, conclua as etapas a seguir com base no uso do Studio ou do Studio Classic.
------
#### [ Studio ]
1. Abra o console do SageMaker Studio seguindo as instruções em [Iniciar o Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. No painel de navegação à esquerda, selecione **Modelos** para exibir uma lista de seus grupos de modelos.
1. Escolha a guia **Modelos registrados**, se ainda não estiver selecionada.
1. Logo abaixo da etiqueta da guia **Modelos registrados**, escolha **Grupos de modelos**, se ainda não estiver selecionado.
1. Na lista de grupos de modelos, escolha o colchete angular à esquerda do grupo de modelos que você deseja visualizar.
1. Uma lista das versões do modelo no grupo de modelos aparece. Se você não encontrar a versão do modelo que deseja excluir, escolha **Exibir tudo**.
1. Marque a caixa de seleção ao lado das versões de modelo que você deseja excluir.
1. Escolha as reticências verticais acima do canto superior direito da tabela e selecione **Excluir** (ou **Excluir versão do modelo**, se você estiver na página de detalhes do grupo de modelos).
1. Na caixa de diálogo **Excluir versão do modelo**, escolha **Sim, excluir a versão do modelo**.
1. Escolha **Excluir**.
1. Confirme se as versões excluídas do modelo não aparecem mais no grupo de modelos.
------
#### [ Studio Classic ]
1. Faça login no Amazon SageMaker Studio Classic. Para obter mais informações, consulte [Launch Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. No painel de navegação à esquerda, selecione o ícone **Início** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Escolha **Modelos** e, em seguida, **Registro de modelo**. Uma lista dos seus grupos de modelos é exibida.
1. Na lista de grupos de modelos, selecione o nome do grupo de modelos da versão do modelo que você deseja excluir.
1. Na lista de versões do modelo, selecione o nome da versão do modelo que você deseja excluir.
1. Escolha o menu suspenso **Ações** e escolha **Remover**.
1. No diálogo de confirmação, insira `REMOVE`.
1. Escolha **Remover**.
1. Confirme se a versão do modelo que você removeu não aparece na lista das versões do modelo do grupo de modelos.
------
# Constructo de preparação para o ciclo de vida do modelo
Você pode definir uma série de estágios pelos quais os modelos podem progredir nos fluxos de trabalho e no ciclo de vida com o constructo de preparação do Registro de Modelos. Isso simplifica o rastreamento e o gerenciamento de modelos à medida que eles passam pelos estágios de desenvolvimento, teste e produção. A seguir, forneceremos informações sobre constructos de preparação e como usá-los na governança do seu modelo.
O constructo de preparação permite que você defina uma série de estágios e status pelos quais os modelos progridem. Em cada estágio, personas específicas com as permissões relevantes podem atualizar o status do estágio. À medida que um modelo avança pelos estágios, seus metadados são transmitidos, fornecendo uma visão abrangente do ciclo de vida do modelo. Esses metadados podem ser acessados e analisados por pessoas autorizadas em cada estágio, permitindo a tomada de decisão embasada. Isso inclui os benefícios a seguir.
+ Permissões do ciclo de vida do modelo: defina permissões para que as pessoas designadas atualizem o estado do estágio do modelo e imponham controles de aprovação em pontos de transição essenciais. Os administradores podem atribuir permissões usando políticas e chaves de condição do IAM com a API. Por exemplo, você pode impedir que um cientista de dados atualize a transição do estágio do ciclo de vida do modelo de “Desenvolvimento” para “Produção”. Para obter exemplos, consulte [Configurar exemplos de constructo de preparação](model-registry-staging-construct-set-up.md).
+ Modele eventos do ciclo de vida via Amazon EventBridge - Você pode consumir os eventos do estágio do ciclo de vida usando. EventBridge Isso possibilita que você receba notificações de eventos quando os modelos mudarem de aprovação ou estado de preparação, permitindo a integração com ferramentas de governança de terceiros. Consulte [Receba notificações de eventos para ModelLifeCycle](model-registry-staging-construct-event-bridge.md) para ver um exemplo.
+ Pesquisa com base em campos do ciclo de vida do modelo: você pode pesquisar e filtrar o status do estágio e do estágio usando a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Search.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Search.html).
+ Trilhas de auditoria de eventos do ciclo de vida do modelo: você pode visualizar o histórico de eventos de aprovação e preparação do modelo para as transições do ciclo de vida do modelo.
Os tópicos a seguir explicarão como configurar um constructo de estágio do lado do administrador e como atualizar o status de um estágio do lado do usuário.
**Topics**
+ [Configurar exemplos de constructo de preparação](model-registry-staging-construct-set-up.md)
+ [Atualizar o estágio e o status de um pacote de modelo no Studio](model-registry-staging-construct-update-studio.md)
+ [Exemplo de atualização do estágio e status de um pacote de modelo (Boto3)](model-registry-staging-construct-update-boto3.md)
+ [Invoque ModelLifeCycle usando os exemplos AWS CLI](model-registry-staging-construct-cli.md)
+ [Receba notificações de eventos para ModelLifeCycle](model-registry-staging-construct-event-bridge.md)
# Configurar exemplos de constructo de preparação
Para configurar construções de palco para seu Amazon SageMaker Model Registry, o administrador precisará conceder as permissões relevantes para as funções pretendidas. Os exemplos a seguir mostram como configurar constructos de estágio para vários perfis.
**nota**
Os usuários em um domínio do Amazon SageMaker AI poderão visualizar todos os estágios definidos dentro do domínio, mas só poderão usar aqueles para os quais têm permissões.
Os estágios são definidos pelo parâmetro `ModelLifeCycle` e têm a estrutura a seguir. O administrador configura as permissões que determinam quais perfis podem acessar qual `stage` e qual `stageStatus`. Os usuários que assumem um perfil podem usar o `stage` e o `stageStatus` relevantes e incluir sua própria `stageDescription`.
```
ModelLifeCycle {
stage: String # Required (e.g., Development/QA/Production)
stageStatus: String # Required (e.g., PendingApproval/Approved/Rejected)
stageDescription: String # Optional
}
```
A tabela a seguir contém modelos de constructos de estágio predefinidos do Registro de Modelos. Você pode definir seus próprios constructos de estágio com base em seus casos de uso. É necessário configurar as permissões relevantes para que os usuários possam usá-las.
| Estágio | Status de estágio |
| --- | --- |
| Proposta | PendingApproval |
| Desenvolvimento | InProgress |
| QA | OnHold |
| PreProduction | Aprovado |
| Produção | Rejeitado |
| Arquivado | Descontinuado |
O `ModelLifeCycle` parâmetro pode ser invocado da seguinte APIs forma:
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateModelPackage.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateModelPackage.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeModelPackage.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeModelPackage.html)
------
#### [ Policy for a data scientist role ]
Veja a seguir um exemplo de política do IAM que usa chaves de condição do ciclo de vida do modelo. Você pode modificá-las com base em seus próprios requisitos. Neste exemplo, as permissões do perfil estão limitadas para configurar ou definir o estágio do ciclo de vida do modelo para:
+ Criar ou atualizar um modelo com o estágio `"Development"` e o status `"Approved"`.
+ Atualizar um pacote de modelo com a garantia de qualidade `"QA"` e o status `"PendingApproval"`.
```
{
"Action" : [
"sagemaker:UpdateModelPackage",
"sagemaker:CreateModelPackage"
],
"Resource": [
"*"
],
"Condition": {
"StringEquals": {
"sagemaker:ModelLifeCycle:stage" : "Development"
"sagemaker:ModelLifeCycle:stageStatus" : "Approved"
}
}
},
{
"Action" : [
"sagemaker:UpdateModelPackage"
],
"Resource": [
"*"
],
"Condition": {
"StringEquals": {
"sagemaker:ModelLifeCycle:stage" : "Staging"
"sagemaker:ModelLifeCycle:stageStatus" : "PendingApproval"
}
}
}
```
------
#### [ Policy for a quality assurance specialist ]
Veja a seguir um exemplo de política do IAM que usa chaves de condição do ciclo de vida do modelo. Você pode modificá-las com base em seus próprios requisitos. Neste exemplo, as permissões do perfil estão limitadas para configurar ou definir o estágio do ciclo de vida do modelo para:
+ Atualizar um pacote de modelo com:
+ O estágio `"QA"` e o status `"Approved"` ou `"Rejected"`.
+ O estágio `"Production"` e o status `"PendingApproval"`.
```
{
"Action": [
"sagemaker:UpdateModelPackage"
],
"Resource": [
"*"
],
"Condition": {
"StringEquals": {
"sagemaker:ModelLifeCycle:stage": "Staging",
"sagemaker:ModelLifeCycle:stageStatus": "Approved"
}
}
}, {
"Action": [
"sagemaker:UpdateModelPackage"
],
"Resource": [
"*"
],
"Condition": {
"StringEquals": {
"sagemaker:ModelLifeCycle:stage": "Staging",
"sagemaker:ModelLifeCycle:stageStatus": "Rejected"
}
}
}, {
"Action": [
"sagemaker:UpdateModelPackage"
],
"Resource": [
"*"
],
"Condition": {
"StringEquals": {
"sagemaker:ModelLifeCycle:stage": "Production",
"sagemaker:ModelLifeCycle:stageStatus": "PendingApproval"
}
}
}
```
------
#### [ Policy for lead engineer role ]
Veja a seguir um exemplo de política do IAM que usa chaves de condição do ciclo de vida do modelo. Você pode modificá-las com base em seus próprios requisitos. Neste exemplo, as permissões do perfil estão limitadas para configurar ou definir o estágio do ciclo de vida do modelo para:
+ Atualizar um pacote de modelo com:
+ O estágio `"Production"` e o status `"Approved"` ou `"Rejected"`.
+ O estágio `"Development"` e o status `"PendingApproval"`.
```
{
"Action" : [
"sagemaker:UpdateModelPackage"
],
"Resource": [
"*"
],
"Condition": {
"ForAnyvalue:StringEquals" : {
"sagemaker:ModelLifeCycle:stage" : "Production",
"sagemaker:ModelLifeCycle:stageStatus" : "Approved"
}
}
},
{
"Action" : [
"sagemaker:UpdateModelPackage"
],
"Resource": [
"*"
],
"Condition": {
"StringEquals:" {
"sagemaker:ModelLifeCycle:stage" : "Production"
"sagemaker:ModelLifeCycle:stageStatus" : "Rejected"
}
}
},
{
"Action" : [
"sagemaker:UpdateModelPackage"
],
"Resource": [
"*"
],
"Condition": {
"StringEquals": {
"sagemaker:ModelLifeCycle:stage" : "Development"
"sagemaker:ModelLifeCycle:stageStatus" : "PendingApproval"
}
}
}
```
------
Para receber EventBridge notificações da Amazon sobre qualquer atualização de status do modelo, veja o exemplo em[Receba notificações de eventos para ModelLifeCycle](model-registry-staging-construct-event-bridge.md). Para obter um exemplo de EventBridge carga útil que você pode receber, consulte[SageMaker mudança de estado do pacote modelo](automating-sagemaker-with-eventbridge.md#eventbridge-model-package).
# Atualizar o estágio e o status de um pacote de modelo no Studio
Para usar um constructo de estágio do pacote de modelo, você precisará assumir um perfil de execução com as permissões relevantes. A página a seguir fornece informações sobre como atualizar o status do estágio usando o Amazon SageMaker Studio.
Todos os constructos de estágio definidos no domínio poderão ser visualizados por todos os usuários. Para atualizar um estágio, o administrador precisará configurar as permissões relevantes para você acessá-lo. Para ter informações sobre como fazer isso, consulte [Configurar exemplos de constructo de preparação](model-registry-staging-construct-set-up.md).
O procedimento a seguir levará você à interface de usuário do Studio, na qual você poderá atualizar o estágio do pacote de modelo.
1. Faça login no Amazon SageMaker Studio. Para obter mais informações, consulte [Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, selecione **Modelos**.
1. Encontre seu modelo.
+ Você pode usar as guias para encontrar seus modelos. Por exemplo, escolha as guias **Modelos registrados** ou **Modelos implantáveis**.
+ Você pode usar as opções **Meus modelos** e **Compartilhado comigo** para encontrar modelos que você criou ou aqueles que são compartilhados por você.
1. Marque a caixa de seleção ao lado do modelo que você deseja atualizar.
1. Escolha o ícone **Mais opções**.
1. Escolha **Atualizar ciclo de vida do modelo**. Isso levará você à seção **Atualizar ciclo de vida do modelo**.
1. Conclua as tarefas para atualizar o estágio.
Se você não conseguir atualizar o estágio, será exibido um erro. Seu administrador precisará configurar as permissões para que você faça isso. Para ter informações sobre como configurar permissões, consulte [Configurar exemplos de constructo de preparação](model-registry-staging-construct-set-up.md).
# Exemplo de atualização do estágio e status de um pacote de modelo (Boto3)
Para atualizar o estágio e o status de um pacote de modelo, você precisará assumir um perfil de execução com as permissões relevantes. Veja a seguir um exemplo de como você pode atualizar o status do estágio usando a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateModelPackage.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateModelPackage.html) por meio do AWS SDK para Python (Boto3).
Neste exemplo, as chaves de condição de estágio `"Development"` e de status de estágio `"Approved"` de `ModelLifeCycle` para ação de API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateModelPackage.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateModelPackage.html) foram atribuídas ao seu perfil de execução. Você também pode inserir uma descrição em `stage-description`. Consulte [Configurar exemplos de constructo de preparação](model-registry-staging-construct-set-up.md) para obter mais informações.
```
from sagemaker import get_execution_role, session
import boto3
region = boto3.Session().region_name role = get_execution_role()
sm_client = boto3.client('sagemaker', region_name=region)
model_package_update_input_dict = {
"ModelLifeCycle" : {
"stage" : "Development",
"stageStatus" : "Approved",
"stageDescription" : "stage-description"
}
}
model_package_update_response = sm_client.update_model_package(**model_package_update_input_dict)
```
# Invoque ModelLifeCycle usando os exemplos AWS CLI
Você pode usar a AWS CLI ferramenta para gerenciar seus AWS recursos. Alguns comandos da AWS CLI incluem ações [search](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/cloudsearchdomain/search.html) e [list-actions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/fis/list-actions.html). A página a seguir apresenta exemplos de como usar `ModelPackage` ao utilizar esses comandos. Para ter informações e exemplos sobre como configurar seu constructo de estágio, consulte [Configurar exemplos de constructo de preparação](model-registry-staging-construct-set-up.md).
Os exemplos desta página usam as variáveis a seguir.
+ `region` é a região em que se encontra o pacote de modelo.
+ `stage-name` é o nome do estágio que você definiu.
+ `stage-status` é o nome de status do estágio que você definiu.
A seguir estão exemplos de AWS CLI comandos usando ModelLifeCycle.
Pesquise seus pacotes de modelos com um *stage-name* que você já definiu.
```
aws sagemaker search --region 'region' --resource ModelPackage --search-expression '{"Filters": [{"Name": "ModelLifeCycle.Stage","Value": "stage-name"}]}'
```
Liste as ações associadas a `ModelLifeCycle`.
```
aws sagemaker list-actions --region 'region' --action-type ModelLifeCycle
```
Crie um pacote de modelo com ModelLifeCycle.
```
aws sagemaker create-model-package --model-package-group-name 'model-package-group-name' --source-uri 'source-uri' --region 'region' --model-life-cycle '{"Stage":"stage-name", "StageStatus":"stage-status", "StageDescription":"Your Staging Comment"}'
```
Atualize um pacote de modelo com ModelLifeCycle.
```
aws sagemaker update-model-package --model-package 'model-package-arn' --region 'region' --model-life-cycle '{"Stage":"stage-name", "StageStatus":"stage-status"}'
```
Pesquise pelo ModelLifeCycle campo.
```
aws sagemaker search --region 'region' --resource ModelPackage --search-expression '{"Filters": [{"Name": "ModelLifeCycle.Stage","Value": "stage-name"}]}'
```
Obtenha registros de auditoria para ModelLifeField atualizações via [Rastreamento SageMaker de linhagem do Amazon ML](lineage-tracking.md) APIs.
```
aws sagemaker list-actions --region 'region' --action-type ModelLifeCycle
```
```
aws sagemaker describe-action --region 'region' --action-name 'action-arn or action-name'
```
# Receba notificações de eventos para ModelLifeCycle
Você pode receber as notificações de ModelLifeCycle atualização e os eventos EventBridge em sua conta. Veja a seguir um exemplo de uma EventBridge regra a ser configurada em sua conta para receber as notificações do ModelLifeCycle evento.
```
{
"source": ["aws.sagemaker"],
"detail-type": ["SageMaker Model Package State Change"]
}
```
Para obter um exemplo de EventBridge carga útil que você pode receber, consulte[SageMaker mudança de estado do pacote modelo](automating-sagemaker-with-eventbridge.md#eventbridge-model-package).
# Atualizar o status da aprovação de um modelo
Após criar uma versão do modelo, você normalmente deseja avaliar seu desempenho antes de implantá-la em um endpoint de produção. Se atender aos seus requisitos, você poderá atualizar o status de aprovação da versão do modelo para `Approved`. Definir o status como `Approved` pode iniciar a CI/CD implantação do modelo. Se a versão do modelo não atender aos seus requisitos, você poderá atualizar o status de aprovação para `Rejected`.
Você pode atualizar manualmente o status de aprovação de uma versão do modelo depois de registrá-la ou criar uma etapa de condição para avaliar o modelo ao criar um pipeline de SageMaker IA. Para obter informações sobre como criar uma etapa de condição em um pipeline de SageMaker IA, consulte[Etapas do Pipelines](build-and-manage-steps.md).
Quando você usa um dos modelos de projeto fornecidos pela SageMaker IA e o status de aprovação de uma versão do modelo muda, a ação a seguir ocorre. Somente transições válidas são mostradas.
+ `PendingManualApproval`para `Approved` — inicia a CI/CD implantação da versão do modelo aprovada
+ `PendingManualApproval` para `Rejected`: Nenhuma ação
+ `Rejected` para `Approved`: inicia a implantação de CI/CD para a versão do modelo aprovada
+ `Approved`para `Rejected` — inicia CI/CD a implantação da versão mais recente do modelo com um status `Approved`
Você pode atualizar o status de aprovação de uma versão do modelo usando AWS SDK para Python (Boto3) ou usando o console do Amazon SageMaker Studio. Você também pode atualizar o status de aprovação de uma versão do modelo como parte de uma etapa de condição em um pipeline de SageMaker IA. Para obter informações sobre como usar uma etapa de aprovação de modelo em um pipeline de SageMaker IA, consulte[Visão geral do Pipelines](pipelines-overview.md).
## Atualizar o status da aprovação de um modelo (Boto3)
Ao criar a versão do modelo na [Registrar uma versão do modelo](model-registry-version.md), você definiu o `ModelApprovalStatus` para `PendingManualApproval`. Você atualiza o status da aprovação do modelo chamando `update_model_package`. Observe que você pode automatizar esse processo escrevendo um código que, por exemplo, define o status da aprovação de um modelo dependendo do resultado de uma avaliação de alguma medida do desempenho do modelo. Você também pode criar uma etapa em um pipeline que implanta automaticamente uma nova versão do modelo quando ela for aprovada. O trecho de código a seguir mostra como alterar manualmente o status da aprovação para `Approved`.
```
model_package_update_input_dict = {
"ModelPackageArn" : model_package_arn,
"ModelApprovalStatus" : "Approved"
}
model_package_update_response = sm_client.update_model_package(**model_package_update_input_dict)
```
## Atualizar o status da aprovação de um modelo (Studio ou Studio Classic)
Para alterar manualmente o status de aprovação no console do Amazon SageMaker Studio, conclua as etapas a seguir com base no uso do Studio ou do Studio Classic.
------
#### [ Studio ]
1. Abra o console do SageMaker Studio seguindo as instruções em [Iniciar o Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. No painel de navegação à esquerda, selecione os **Modelos** para exibir uma lista de seus grupos de modelos.
1. Escolha a guia **Modelos registrados**, se ainda não estiver selecionada.
1. Logo abaixo da etiqueta da guia **Modelos registrados**, escolha **Grupos de modelos**, se ainda não estiver selecionado.
1. Na lista de grupos de modelos, escolha o colchete angular à esquerda do grupo de modelos que você deseja visualizar.
1. Uma lista das versões do modelo no grupo de modelos aparece. Se você não vê a versão do modelo que deseja excluir, escolha **Exibir tudo** para exibir a lista completa das versões do modelo na página de detalhes do grupo de modelos.
1. Selecione o nome da versão do modelo que deseja atualizar.
1. A guia **Implantar** exibe o status de aprovação atual. Escolha o menu suspenso ao lado do status de aprovação atual e selecione o status de aprovação atualizado.
------
#### [ Studio Classic ]
1. Faça login no Amazon SageMaker Studio Classic. Para obter mais informações, consulte [Launch Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. No painel de navegação à esquerda, selecione o ícone **Início** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Escolha **Modelos** e, em seguida, **Registro de modelo**.
1. Na lista de grupos de modelos, selecione o nome do grupo de modelos que você deseja visualizar. Uma nova guia é aberta com uma lista das versões do modelo no Grupo de modelos.
1. Na lista de versões do modelo, selecione o nome da versão do modelo que você deseja atualizar.
1. No menu suspenso **Ações**, você pode escolher uma das duas opções de menu possíveis para atualizar o status da versão do modelo.
+ Usar a opção **Atualizar status**
1. No menu suspenso **Ações**, escolha o menu suspenso **Atualizar status** e escolha o status da versão do novo modelo.
1. (Opcional) No campo **Comentar**, inclua detalhes adicionais.
1. Escolha **Salvar e atualizar**.
+ Usar a opção **Editar**
1. No menu suspenso **Ações**, escolha **Editar**.
1. (Opcional) No campo **Comentar**, inclua detalhes adicionais.
1. Escolha **Salvar alterações**.
1. Confirme se o status da versão do modelo foi atualizado para o valor correto na página da versão do modelo.
------
Para`us-east-1`,`us-west-2`, e `eu-west-1` regiões`ap-northeast-1`, você pode usar as instruções a seguir para acessar os detalhes da linhagem das versões de modelo registradas e registradas:
1. Abra o console do SageMaker Studio seguindo as instruções em [Iniciar o Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. No painel de navegação à esquerda, escolha **Modelos**.
1. Escolha a guia **Modelos** registrados, se ainda não estiver selecionada, selecione **Modelos registrados**.
1. Selecione um modelo e escolha **Exibir versão mais recente**.
1. Escolha a guia **Governança**.
1. A seção **Implantar**, em **Visão geral da governança**, exibe o status atual da aprovação. Selecione o status de aprovação atualizado no menu suspenso.
# Implantar um modelo a partir do registro com Python
Depois de registrar uma versão do modelo e aprová-la para implantação, implante-a em um endpoint de SageMaker IA para inferência em tempo real. Você pode implantar seu modelo usando o SageMaker AI SDK ou o. AWS SDK para Python (Boto3)
Quando você cria um projeto de operações de aprendizado de máquina (MLOps) e escolhe um modelo de MLOps projeto que inclui a implantação do modelo, as versões aprovadas do modelo no Registro de Modelos são automaticamente implantadas na produção. Para obter informações sobre o uso de MLOps projetos de SageMaker IA, consulte[MLOps Automação com SageMaker projetos](sagemaker-projects.md).
Você também pode habilitar uma AWS conta para implantar versões de modelo que foram criadas em uma conta diferente adicionando uma política de recursos entre contas. Por exemplo, uma equipe em sua organização pode ser responsável pelos modelos de treinamento e uma equipe diferente é responsável pela implantação e atualização dos modelos.
**Topics**
+ [Implantar um modelo a partir do Registro (SageMaker SDK)](#model-registry-deploy-smsdk)
+ [Implantar um modelo a partir do Registro (Boto3)](#model-registry-deploy-api)
+ [Implantar uma versão do modelo de uma conta diferente](#model-registry-deploy-xaccount)
## Implantar um modelo a partir do Registro (SageMaker SDK)
Para implantar uma versão do modelo usando o [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable), use o seguinte trecho de código:
```
from sagemaker import ModelPackage
from time import gmtime, strftime
model_package_arn = 'arn:aws:sagemaker:us-east-2:12345678901:model-package/modeltest/1'
model = ModelPackage(role=role,
model_package_arn=model_package_arn,
sagemaker_session=sagemaker_session)
model.deploy(initial_instance_count=1, instance_type='ml.m5.xlarge')
```
## Implantar um modelo a partir do Registro (Boto3)
Para implantar uma versão do modelo usando o AWS SDK para Python (Boto3), conclua as seguintes etapas:
1. O trecho de código a seguir pressupõe que você já criou o cliente SageMaker AI Boto3 `sm_client` e uma versão do modelo cujo ARN está armazenado na variável. `model_version_arn`
Crie um objeto de modelo a partir da versão do modelo chamando a operação de API [create\$1model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model). Passe o nome de recurso da Amazon (ARN) da versão do modelo como parte dos `Containers` para o objeto do modelo.
```
model_name = 'DEMO-modelregistry-model-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
print("Model name : {}".format(model_name))
container_list = [{'ModelPackageName': model_version_arn}]
create_model_response = sm_client.create_model(
ModelName = model_name,
ExecutionRoleArn = role,
Containers = container_list
)
print("Model arn : {}".format(create_model_response["ModelArn"]))
```
1. Crie uma configuração de endpoint chamando a API `create_endpoint_config`. A configuração do endpoint especifica o número e o tipo de instâncias do Amazon EC2 a serem usadas para o endpoint.
```
endpoint_config_name = 'DEMO-modelregistry-EndpointConfig-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
print(endpoint_config_name)
create_endpoint_config_response = sm_client.create_endpoint_config(
EndpointConfigName = endpoint_config_name,
ProductionVariants=[{
'InstanceType':'ml.m4.xlarge',
'InitialVariantWeight':1,
'InitialInstanceCount':1,
'ModelName':model_name,
'VariantName':'AllTraffic'}])
```
1. Crie o endpoint chamando `create_endpoint`.
```
endpoint_name = 'DEMO-modelregistry-endpoint-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
print("EndpointName={}".format(endpoint_name))
create_endpoint_response = sm_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name)
print(create_endpoint_response['EndpointArn'])
```
## Implantar uma versão do modelo de uma conta diferente
Você pode permitir que uma AWS conta implante versões de modelo que foram criadas em uma conta diferente adicionando uma política de recursos entre contas. Por exemplo, uma equipe em sua organização pode ser responsável pelos modelos de treinamento e uma equipe diferente é responsável pela implantação e atualização dos modelos. Ao criar essas políticas de recursos, você aplica a política ao recurso específico ao qual deseja conceder acesso. Para obter mais informações sobre políticas de recursos entre contas em AWS, consulte [Lógica de avaliação de políticas entre contas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html) no Guia do *AWS Identity and Access Management usuário*.
**nota**
Você deve usar uma chave do KMS para criptografar a ação de [configurar dados de saída](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_OutputDataConfig.html) durante o treinamento para implantação do modelo entre contas.
Para permitir a implantação do modelo entre contas na SageMaker IA, você precisa fornecer uma política de recursos entre contas para o grupo de modelos que contém as versões do modelo que você deseja implantar, o repositório do Amazon ECR onde reside a imagem de inferência do grupo de modelos e o bucket do Amazon S3 onde as versões do modelo são armazenadas.
Para poder implantar um modelo que foi criado em uma conta diferente, você deve ter uma função que tenha acesso às ações de SageMaker IA, como uma função com a política `AmazonSageMakerFullAccess` gerenciada. Para obter informações sobre políticas gerenciadas por SageMaker IA, consulte[AWS políticas gerenciadas para Amazon SageMaker AI](security-iam-awsmanpol.md).
O exemplo a seguir cria políticas entre contas para todos esses três recursos e aplica as políticas aos recursos. O exemplo também pressupõe que você tenha definido anteriormente as seguintes variáveis:
+ `bucket`: O bucket do Amazon S3 onde as versões do modelo são armazenadas.
+ `kms_key_id`: A chave do KMS usada para criptografar a saída do treinamento.
+ `sm_client`— Um cliente SageMaker AI Boto3.
+ `model_package_group_name`: O grupo de modelos ao qual você deseja conceder acesso entre contas.
+ `model_package_group_arn`: O ARN do grupo de modelos ao qual você deseja conceder acesso entre contas.
```
import json
# The cross-account id to grant access to
cross_account_id = "123456789012"
# Create the policy for access to the ECR repository
ecr_repository_policy = {
'Version': '2012-10-17 ',
'Statement': [{
'Sid': 'AddPerm',
'Effect': 'Allow',
'Principal': {
'AWS': f'arn:aws:iam::{cross_account_id}:root'
},
'Action': ['ecr:*']
}]
}
# Convert the ECR policy from JSON dict to string
ecr_repository_policy = json.dumps(ecr_repository_policy)
# Set the new ECR policy
ecr = boto3.client('ecr')
response = ecr.set_repository_policy(
registryId = account,
repositoryName = 'decision-trees-sample',
policyText = ecr_repository_policy
)
# Create a policy for accessing the S3 bucket
bucket_policy = {
'Version': '2012-10-17 ',
'Statement': [{
'Sid': 'AddPerm',
'Effect': 'Allow',
'Principal': {
'AWS': f'arn:aws:iam::{cross_account_id}:root'
},
'Action': 's3:*',
'Resource': f'arn:aws:s3:::{bucket}/*'
}]
}
# Convert the policy from JSON dict to string
bucket_policy = json.dumps(bucket_policy)
# Set the new policy
s3 = boto3.client('s3')
response = s3.put_bucket_policy(
Bucket = bucket,
Policy = bucket_policy)
# Create the KMS grant for encryption in the source account to the
# Model Registry account Model Group
client = boto3.client('kms')
response = client.create_grant(
GranteePrincipal=cross_account_id,
KeyId=kms_key_id
Operations=[
'Decrypt',
'GenerateDataKey',
],
)
# 3. Create a policy for access to the Model Group.
model_package_group_policy = {
'Version': '2012-10-17 ',
'Statement': [{
'Sid': 'AddPermModelPackageGroup',
'Effect': 'Allow',
'Principal': {
'AWS': f'arn:aws:iam::{cross_account_id}:root'
},
'Action': ['sagemaker:DescribeModelPackageGroup'],
'Resource': f'arn:aws:sagemaker:{region}:{account}:model-package-group/{model_package_group_name}'
},{
'Sid': 'AddPermModelPackageVersion',
'Effect': 'Allow',
'Principal': {
'AWS': f'arn:aws:iam::{cross_account_id}:root'
},
'Action': ["sagemaker:DescribeModelPackage",
"sagemaker:ListModelPackages",
"sagemaker:UpdateModelPackage",
"sagemaker:CreateModel"],
'Resource': f'arn:aws:sagemaker:{region}:{account}:model-package/{model_package_group_name}/*'
}]
}
# Convert the policy from JSON dict to string
model_package_group_policy = json.dumps(model_package_group_policy)
# Set the policy to the Model Group
response = sm_client.put_model_package_group_policy(
ModelPackageGroupName = model_package_group_name,
ResourcePolicy = model_package_group_policy)
print('ModelPackageGroupArn : {}'.format(create_model_package_group_response['ModelPackageGroupArn']))
print("First Versioned ModelPackageArn: " + model_package_arn)
print("Second Versioned ModelPackageArn: " + model_package_arn2)
print("Success! You are all set to proceed for cross-account deployment.")
```
# Implantar um modelo no Studio
Depois de registrar uma versão do modelo e aprová-la para implantação, implante-a em um endpoint de SageMaker IA da Amazon para inferência em tempo real. Você pode [Implantar um modelo a partir do registro com Python](model-registry-deploy.md) ou implantar seu modelo no Amazon SageMaker Studio. Veja a seguir instruções sobre como implantar seu modelo no Studio.
Esse recurso não está disponível no Amazon SageMaker Studio Classic.
+ Se o Studio for sua experiência padrão, a interface de usuário será semelhante às imagens encontradas em [Visão geral da interface do usuário do Amazon SageMaker Studio](studio-updated-ui.md).
+ Se o Studio Classic for sua experiência padrão, a interface de usuário será semelhante às imagens encontradas em [Visão geral da interface do usuário do Amazon SageMaker Studio Classic](studio-ui.md).
Antes de poder implantar um pacote de modelo, os seguintes requisitos devem ser atendidos para o pacote de modelos:
+ Uma especificação de inferência válida disponível. Consulte [InferenceSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-InferenceSpecification) para obter mais informações.
+ Modelo com status de aprovado. Consulte [Atualizar o status da aprovação de um modelo](model-registry-approve.md) para obter mais informações.
Veja a seguir instruções sobre como implantar um modelo no Studio.
**Para implantar um modelo no Studio**
1. Abra o console do Studio seguindo as instruções em [Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, escolha **Modelos**.
1. Escolha a guia **Modelos registrados**, se ainda não estiver selecionada.
1. Logo abaixo da etiqueta da guia **Modelos registrados**, escolha **Grupos de modelos**, se ainda não estiver selecionado.
1. (Opcional) Se você tiver modelos compartilhados com você, poderá escolher entre **Meus modelos** ou **Compartilhado comigo**.
1. Marque as caixas de seleção para os modelos registrados. Se os requisitos acima forem atendidos, o botão **Implantar** ficará disponível para escolha.
1. Escolha **Implantar** para abrir a página **Implantar modelo no endpoint**.
1. Configure os recursos de implantação em **Configurações do endpoint**.
1. Depois de verificar as configurações, escolha **Implantar**. O modelo será, então, implantado no endpoint com o status **Em serviço**.
Para`us-east-1`, `us-west-2``ap-northeast-1`, e `eu-west-1` regiões, você pode usar as seguintes instruções para implantar modelos:
**Para implantar um modelo no Studio**
1. Abra o console do Studio seguindo as instruções em [Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, escolha **Modelos**.
1. Escolha a guia **Meus modelos**.
1. Escolha a guia **Modelos** registrados, se ainda não estiver selecionada.
1. Selecione um modelo e escolha **Exibir versão mais recente**.
1. Escolha **Deploy** e selecione entre SageMaker AI ou Amazon Bedrock.
1. Depois de verificar as configurações, escolha **Implantar**. O modelo será, então, implantado no endpoint com o status **Em serviço**.
# Detecção entre contas
Ao explorar e acessar grupos de pacote de modelos registrados em outras contas, os cientistas e engenheiros de dados podem promover a consistência de dados, agilizar a colaboração e reduzir a duplicação de esforços. Com o Amazon SageMaker Model Registry, você pode compartilhar grupos de pacotes de modelos entre contas. Há duas categorias de permissões associadas ao compartilhamento de recursos:
+ **Capacidade de descoberta**: a *capacidade de descoberta* é a capacidade da conta do consumidor do recurso de ver os grupos de pacotes de modelo compartilhados por uma ou mais contas do proprietário do recurso. A descoberta só é possível se o proprietário do recurso anexar as políticas de recurso necessárias aos grupos de pacotes de modelo compartilhados. O consumidor do recurso pode visualizar todos os grupos de pacotes de modelos compartilhados na AWS RAM interface do usuário AWS CLI e.
+ **Acessibilidade**: a *acessibilidade* é a capacidade da conta do consumidor de recursos de usar os grupos de pacotes de modelo compartilhados. Por exemplo, o consumidor do recurso pode registrar ou implantar um pacote modelo de uma conta diferente se tiver as permissões necessárias.
**Topics**
+ [Compartilhar grupo de modelos no Studio](model-registry-ram-studio-share.md)
+ [Exibir grupos de modelos compartilhados no Studio](model-registry-ram-studio-view.md)
+ [Acessibilidade](model-registry-ram-accessibility.md)
+ [Configurar a capacidade de descoberta](model-registry-ram-discover.md)
+ [Exibir grupos de pacotes de modelo compartilhados](model-registry-ram-view-shared.md)
+ [Separar entidades principais de um compartilhamento de recursos e remover um compartilhamento de recursos](model-registry-ram-dissociate.md)
+ [Promova a permissão e o compartilhamento de recursos](model-registry-ram-promote.md)
# Compartilhar grupo de modelos no Studio
Você pode compartilhar seus grupos de modelos com outros AWS diretores (Contas da AWS ou AWS Organizations) usando a interface do usuário do Studio. Esse processo de compartilhamento simplificado permite a colaboração entre equipes, promove as melhores práticas e facilita a reutilização de modelos por suas equipes. A seguir, há instruções sobre como compartilhar grupos de modelos no Studio.
Esse recurso não está disponível no Amazon SageMaker Studio Classic.
+ Se o Studio for sua experiência padrão, a interface de usuário será semelhante às imagens encontradas em [Visão geral da interface do usuário do Amazon SageMaker Studio](studio-updated-ui.md).
+ Se o Studio Classic for sua experiência padrão, a interface de usuário será semelhante às imagens encontradas em [Visão geral da interface do usuário do Amazon SageMaker Studio Classic](studio-ui.md).
Para compartilhar grupos de modelos, primeiro você precisa verificar se possui a seguinte permissão adicionada ao perfil de execução da qual você está compartilhando os recursos:
1. [Obtenha um perfil de execução](sagemaker-roles.md#sagemaker-roles-get-execution-role).
1. [Atualize as permissões da função](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_update-role-permissions.html) com o seguinte:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ram:ListPermissions",
"ram:GetPermission",
"ram:GetResourceShareAssociations",
"ram:ListResourceSharePermissions",
"ram:DeleteResourceShare",
"ram:GetResourceShareInvitations",
"ram:AcceptResourceShareInvitation"
],
"Resource": "*"
}
]
}
```
------
A seguir, são apresentadas instruções sobre como compartilhar um grupo de modelos com outras entidades principais da AWS .
**Para compartilhar um grupo de modelos com outros AWS diretores**
1. Abra o console do Studio seguindo as instruções em [Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, escolha **Modelos**.
1. Escolha a guia **Modelos registrados**, se ainda não estiver selecionada.
1. Logo abaixo da etiqueta da guia **Modelos registrados**, escolha **Grupos de modelos**, se ainda não estiver selecionado.
1. Selecione um modelo registrado.
1. No canto superior direito, escolha **Compartilhar**. Isso abrirá a seção **Compartilhar grupo de modelos**.
Se você vir uma mensagem de erro na parte inferior da tela, precisará adicionar as permissões apropriadas ao seu perfil de execução. Veja as permissões acima para mais informações.
1. Em **Compartilhamentos de recursos**, escolha um compartilhamento de recursos para atualizar ou criar um novo compartilhamento de recursos.
1. Em **Permissão gerenciada**, escolha uma permissão gerenciada para controlar o nível de acesso do seu modelo.
As opções visíveis incluem permissões que já foram criadas para você ou suas permissões personalizadas no AWS RAM. Consulte [Creating and using customer managed permissions](https://docs.aws.amazon.com/ram/latest/userguide/create-customer-managed-permissions.html) no Guia do usuário do *AWS Resource Access Manager*.
1. **Em **AWS principais,** insira o AWS Organizations ARN Conta da AWS IDs com o qual você deseja compartilhar e escolha Adicionar.** Você pode adicionar vários AWS principais dessa forma.
1. Quando os requisitos mínimos são atendidos, o botão **Compartilhar** fica acessível. Depois de verificar suas configurações, escolha **Compartilhar**.
Um compartilhamento bem-sucedido resultará em uma mensagem de banner verde na parte inferior da tela.
# Exibir grupos de modelos compartilhados no Studio
Você pode visualizar grupos de modelos que são compartilhados com você ou com uma conta pertencente ao mesmo AWS Organizations. Se um grupo de modelos for compartilhado com uma conta pertencente à mesma AWS Organizations, o grupo de modelos compartilhado será automaticamente aprovado e estará disponível para você visualizar no Studio. Caso contrário, você precisará aprovar o convite pendente antes de poder visualizar o grupo de modelos compartilhados no Studio. Veja a seguir instruções sobre como visualizar grupos de modelos compartilhados e aceitar convites de compartilhamento de grupos de modelos no Studio.
Esse recurso não está disponível no Amazon SageMaker Studio Classic.
+ Se o Studio for sua experiência padrão, a interface de usuário será semelhante às imagens encontradas em [Visão geral da interface do usuário do Amazon SageMaker Studio](studio-updated-ui.md).
+ Se o Studio Classic for sua experiência padrão, a interface de usuário será semelhante às imagens encontradas em [Visão geral da interface do usuário do Amazon SageMaker Studio Classic](studio-ui.md).
A seguir, são apresentadas instruções sobre como visualizar e aceitar grupos de modelos compartilhados com você.
**Visualizar e aceitar grupos de modelos compartilhados com você**
1. Abra o console do Studio seguindo as instruções em [Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, escolha **Modelos**.
1. Escolha a guia **Modelos registrados**, se ainda não estiver selecionada.
1. Logo abaixo da etiqueta da guia **Modelos registrados**, escolha **Grupos de modelos**, se ainda não estiver selecionado.
1. Escolha **Compartilhado comigo** para ver os grupos de modelos que são compartilhados com você.
1. Para aceitar convites pendentes de grupos de modelos:
1. Escolha **Exibir aprovações pendentes** para abrir a lista **Convites pendentes**.
1. Se você quiser aceitar o convite, escolha **Aceitar**.
# Acessibilidade
Se o consumidor do recurso tiver permissões de acesso para usar um grupo de pacotes de modelo compartilhado, ele poderá registrar ou implantar uma versão do grupo de pacotes de modelos. Para obter detalhes sobre como o consumidor de recursos pode registrar um grupo de pacotes de modelo compartilhados, consulte [Registrar uma versão do modelo de uma conta diferente](model-registry-version.md#model-registry-version-xaccount). Para obter detalhes sobre como o consumidor de recursos pode implantar um grupo de pacotes de modelo compartilhados, consulte [Implantar uma versão do modelo de uma conta diferente](model-registry-deploy.md#model-registry-deploy-xaccount).
# Configurar a capacidade de descoberta
O proprietário do recurso pode configurar a capacidade de descoberta do grupo de pacotes de modelo criando compartilhamentos de recursos e anexando políticas de recurso às entidades. Para obter etapas detalhadas sobre como criar um compartilhamento geral de recursos no AWS RAM, consulte [Criar um compartilhamento de recursos](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-sharing.html#getting-started-sharing-create) na [AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html)documentação.
Conclua as instruções a seguir para configurar a capacidade de descoberta do grupo de pacotes de modelos usando o AWS RAM console ou a Política APIs de Recursos do Registro de Modelos.
------
#### [ AWS CLI ]
1. Crie um compartilhamento de recursos na conta do proprietário do modelo.
1. O proprietário do modelo anexa uma política de recursos ao grupo de pacotes do modelo usando a API de política de recursos de SageMaker IA -policy [put-model-package-group-policy](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/put-model-package-group-policy.html), conforme demonstrado no comando a seguir.
```
aws sagemaker put-model-package-group-policy
--model-package-group-name
--resource-policy "{\"Version\":\"2012-10-17\", \"Statement\":[{\"Sid\":
\"ExampleResourcePolicy\",\"Effect\":\"Allow\",\"Principal\":,
\"Action\":[\"sagemaker:DescribeModelPackage\",
\"sagemaker:ListModelPackages\",\"sagemaker:DescribeModelPackageGroup\"],
\"Resource\":[\",\"
\"arn:aws:sagemaker:::model-package/
/*\"]}]}"
```
**nota**
Diferentes combinações de ações podem ser anexadas à política de recursos. Para políticas personalizadas, a permissão criada deve ser promovida pelo proprietário do grupo de pacotes de modelo, e somente entidades com permissões promovidas anexadas podem ser descobertas. Compartilhamentos de recursos não promovidos não podem ser descobertos ou gerenciados por meio do AWS RAM.
1. Para verificar se AWS RAM criou o ARN do compartilhamento de recursos, use o seguinte comando:
```
aws ram get-resource-share-associations --association-type resource --resource-arn
```
A resposta contém o *resource-share-arn* para a entidade.
1. Para verificar se a permissão da política anexada é uma política gerenciada ou personalizada, use o seguinte comando:
```
aws ram list-resource-share-permissions --resource-share-arn
```
O campo `featureSet` pode ter valores `CREATED_FROM_POLICY` ou `STANDARD`, que são definidos da seguinte forma:
+ `STANDARD`: a permissão já existe.
+ `CREATED_FROM_POLICY`: a permissão precisa ser promovida para que a entidade possa ser descoberta. Para obter mais informações, consulte [Promova a permissão e o compartilhamento de recursos](model-registry-ram-promote.md).
1. Aceite o convite de compartilhamento de recursos na conta de consumidor do modelo.
1. O consumidor do grupo de pacotes de modelo aceita o convite para o compartilhamento de recursos. Para ver todos os convites de recursos, execute o seguinte comando:
```
aws ram get-resource-share-invitations
```
Identifique as solicitações que têm status `PENDING` e inclua o ID da conta do proprietário.
1. Aceite o convite de compartilhamento de recursos do proprietário do modelo usando o seguinte comando:
```
aws ram accept-resource-share-invitation --resource-share-invitation-arn
```
------
#### [ AWS RAM console ]
1. Faça login no [console do AWS RAM](https://console.aws.amazon.com/ram/home).
1. Conclua as etapas a seguir para criar um compartilhamento de recursos a partir da conta do proprietário do grupo de pacotes de modelo.
1. Conclua as seguintes etapas para especificar os detalhes do compartilhamento de recurso:
1. No campo **Nome**, adicione um nome exclusivo para seu recurso.
1. No cartão **Resources**, escolha o menu suspenso e selecione **SageMaker AI Model Package** Groups.
1. Marque a caixa de seleção do ARN referente ao compartilhamento de recursos do grupo de pacotes de modelo.
1. No cartão **Selecionar recursos**, marque a caixa de seleção do compartilhamento de recursos do grupo de pacotes de modelo.
1. No cartão **Tags**, adicione pares de valores-chave para as tags a serem adicionadas ao seu compartilhamento de recursos.
1. Escolha **Próximo**.
1. Conclua as etapas a seguir para associar permissões gerenciadas ao compartilhamento de recursos.
1. Se você usa uma permissão gerenciada, escolha uma permissão gerenciada no menu suspenso **Permissões gerenciadas**.
1. Se você usar uma permissão personalizada, escolha **Permissão gerenciada pelo cliente**. Nesse caso, o grupo de pacotes de modelo não pode ser descoberto imediatamente. Você precisa promover a permissão e a política de recursos depois de criar o compartilhamento de recursos. Para obter informações sobre como promover permissões e compartilhamentos de recursos, consulte [Promova a permissão e o compartilhamento de recursos](model-registry-ram-promote.md). Para obter mais informações sobre como anexar permissões personalizadas, consulte [Criação e uso de permissões gerenciadas pelo cliente no AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/create-customer-managed-permissions.html).
1. Escolha **Próximo**.
1. Conclua as seguintes etapas para conceder acesso às entidades principais:
1. Escolha **Permitir o compartilhamento com qualquer pessoa** para permitir o compartilhamento com contas fora da sua organização ou escolha **Permitir o compartilhamento apenas na organização**.
1. No menu suspenso **Selecionar tipo de entidade principal**, adicione os tipos de entidades principais e o ID das entidades principais que você deseja adicionar.
1. Adicione e selecione as entidades principais escolhidas para o compartilhamento.
1. Escolha **Próximo**.
1. Revise a configuração de compartilhamento exibida e escolha **Criar compartilhamento de recursos**.
1. Aceite o convite de compartilhamento de recursos da conta do consumidor. Depois que o proprietário do modelo criar o compartilhamento de recursos e as associações das entidades principais, as contas do consumidor de recursos especificadas receberão um convite para participar do compartilhamento. As contas de consumidor de recursos podem ver e aceitar os convites na página [Compartilhado comigo: compartilhamentos de recursos](https://console.aws.amazon.com/ram/home#SharedResourceShares:) do console do AWS RAM . Para obter mais informações sobre como aceitar e visualizar recursos em AWS RAM, consulte [Acessar AWS recursos compartilhados com você](https://docs.aws.amazon.com//ram/latest/userguide/working-with-shared.html).
------
# Exibir grupos de pacotes de modelo compartilhados
Depois que o proprietário do recurso concluir as etapas anteriores para criar um compartilhamento de recursos e o consumidor aceitar o convite para o compartilhamento, o consumidor poderá visualizar os grupos de pacotes de modelos compartilhados usando o AWS CLI ou no AWS RAM console.
## AWS CLI
Para visualizar os grupos de pacotes de modelo compartilhados, use o seguinte comando na conta do consumidor do modelo:
```
aws sagemaker list-model-package-groups --cross-account-filter-option CrossAccount
```
## AWS RAM console
No AWS RAM console, o proprietário e o consumidor do recurso podem visualizar grupos de pacotes de modelos compartilhados. O proprietário do recurso pode visualizar os grupos de pacotes de modelo compartilhados com o consumidor seguindo as etapas em [Visualização dos compartilhamentos de recursos que você criou no AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/working-with-sharing-view-rs.html). O consumidor do recurso pode visualizar os grupos de pacotes de modelos compartilhados pelo proprietário seguindo as etapas em [Exibir compartilhamentos de recursos compartilhados com você](https://docs.aws.amazon.com/ram/latest/userguide/working-with-shared-view-rs.html).
# Separar entidades principais de um compartilhamento de recursos e remover um compartilhamento de recursos
O proprietário do recurso pode dissociar os principais do compartilhamento de recursos para obter um conjunto de permissões ou excluir todo o compartilhamento de recursos usando o console AWS CLI ou o console. AWS RAM Para obter detalhes sobre como separar entidades principais de um compartilhamento de recursos, consulte [Atualizar um compartilhamento de recursos](https://docs.aws.amazon.com/ram/latest/userguide/working-with-sharing-update.html) na documentação do [AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html). Para obter detalhes sobre como excluir um compartilhamento de recursos, consulte [Como excluir um compartilhamento de recursos](https://docs.aws.amazon.com/ram/latest/userguide/working-with-sharing-delete.html) na documentação do [AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html).
## AWS CLI
Para dissociar os principais de um compartilhamento de recursos, use o comando da seguinte [dissociate-resource-share](https://docs.aws.amazon.com/cli/latest/reference/ram/disassociate-resource-share.html)forma:
```
aws ram disassociate-resource-share --resource-share-arn --principals
```
Para excluir um compartilhamento de recursos, use o comando da [delete-resource-share](https://docs.aws.amazon.com/cli/latest/reference/ram/delete-resource-share.html)seguinte forma:
```
aws ram delete-resource-share --resource-share-arn
```
## AWS RAM console
Para obter mais detalhes sobre como separar entidades principais de um compartilhamento de recursos, veja [Atualizar um compartilhamento de recursos](https://docs.aws.amazon.com/ram/latest/userguide/working-with-sharing-update.html) na documentação do [AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html). Para obter mais detalhes sobre como excluir um compartilhamento de recursos, veja [Como excluir um compartilhamento de recursos](https://docs.aws.amazon.com/ram/latest/userguide/working-with-sharing-delete.html) na documentação do [AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html).
# Promova a permissão e o compartilhamento de recursos
Se você usar permissões personalizadas (gerenciadas pelo cliente), precisará promover a permissão e o compartilhamento de recursos associado para que o grupo de pacotes de modelo possa ser descoberto. Conclua as etapas a seguir para promover a permissão e o compartilhamento de recursos.
1. Para promover sua permissão personalizada para ser acessada por AWS RAM, use o seguinte comando:
```
aws ram promote-permission-created-from-policy —permission-arn
```
1. Promova o compartilhamento de recursos usando o seguinte comando:
```
aws ram promote-resource-share-created-from-policy --resource-share-arn
```
Se você vir o erro `OperationNotPermittedException` ao executar as etapas anteriores, a entidade não pode ser descoberta, mas está acessível. Por exemplo, se o proprietário do recurso anexar uma política de recursos com uma entidade principal de função de assumir, como `“Principal”: {“AWS”: “arn:aws:iam::3333333333:role/Role-1”}`, ou se a política de recursos permitir `“Action”: “*”`, o grupo de pacotes de modelo associado não poderá ser promovido nem descoberto.
# Exibir o histórico de implantações de um modelo
Para visualizar as implantações de uma versão do modelo no console do Amazon SageMaker Studio, conclua as etapas a seguir com base no uso do Studio ou do Studio Classic.
------
#### [ Studio ]
**Visualize o histórico de implantação de uma versão do modelo**
1. Abra o console do SageMaker Studio seguindo as instruções em [Iniciar o Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. No painel de navegação à esquerda, selecione **Modelos** para exibir uma lista de seus grupos de modelos.
1. Escolha a guia **Modelos registrados**, se ainda não estiver selecionada.
1. Logo abaixo da etiqueta da guia **Modelos registrados**, escolha **Grupos de modelos**, se ainda não estiver selecionado.
1. Na lista de grupos de modelos, escolha o colchete angular à esquerda do grupo de modelos que você deseja visualizar.
1. Uma lista das versões do modelo no grupo de modelos aparece. Se você não encontrar a versão do modelo que deseja excluir, escolha **Exibir tudo**.
1. Selecione o nome da versão do modelo que você deseja visualizar.
1. Escolha a guia **Atividade**. As implantações da versão do modelo aparecem como eventos na lista de atividades com um **tipo de evento** de **ModelDeployment**.
------
#### [ Studio Classic ]
**Visualize o histórico de implantação de uma versão do modelo**
1. Faça login no Amazon SageMaker Studio Classic. Para obter mais informações, consulte [Launch Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. No painel de navegação à esquerda, selecione o ícone **Início** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Escolha **Modelos** e, em seguida, **Registro de modelo**.
1. Na lista de grupos de modelos, selecione o nome do grupo de modelos que você deseja visualizar.
1. Uma nova guia aparece com uma lista das versões do modelo no Grupo de modelos.
1. Na lista de versões do modelo, selecione o nome da versão do modelo cujos detalhes você deseja visualizar.
1. Na guia da versão do modelo que se abre, escolha **Atividade**. As implantações da versão do modelo aparecem como eventos na lista de atividades com um **tipo de evento** de **ModelDeployment**.
------
# Visualizar detalhes da linhagem de modelo no Studio
Você pode ver os detalhes da linhagem de um modelo registrado no Amazon SageMaker Studio. A seguir, fornecemos instruções sobre como acessar a visualização de linhagem no Studio. Consulte [Rastreamento SageMaker de linhagem do Amazon ML](lineage-tracking.md) para obter mais informações sobre rastreamento de linhagem no Amazon SageMaker Studio.
Esse recurso não está disponível no Amazon SageMaker Studio Classic.
+ Se o Studio for sua experiência padrão, a interface de usuário será semelhante às imagens encontradas em [Visão geral da interface do usuário do Amazon SageMaker Studio](studio-updated-ui.md).
+ Se o Studio Classic for sua experiência padrão, a interface de usuário será semelhante às imagens encontradas em [Visão geral da interface do usuário do Amazon SageMaker Studio Classic](studio-ui.md).
A visualização de linhagem é uma visualização interativa dos recursos associados aos seus modelos registrados. Esses recursos incluem conjuntos de dados, trabalhos de treinamento, aprovações, modelos e endpoints. Na linhagem, você também pode visualizar os detalhes do recurso associado, incluindo o URI de origem, a data e hora da criação e outros metadados.
Os seguintes recursos estão disponíveis em `us-east-1``us-west-2`,`ap-northeast-1`, e `eu-west-1` regiões:
Você pode rastrear a linhagem de modelos registrados e registrados. Além disso, os recursos de linhagem para modelos incluem conjuntos de dados, avaliadores, trabalhos de treinamento, aprovações, modelos, componentes de inferência e endpoints. Na linhagem, você também pode visualizar os detalhes do recurso associado, incluindo o URI de origem, a data e hora da criação e outros metadados.
A seguir, há instruções sobre como acessar os detalhes da linhagem de uma versão de modelo registrado.
**Para acessar os detalhes da linhagem de uma versão de modelo registrado**
1. Abra o console do Studio seguindo as instruções em [Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, escolha **Modelos**.
1. Escolha a guia **Modelos registrados**, se ainda não estiver selecionada.
1. Logo abaixo da etiqueta da guia **Modelos registrados**, escolha **Grupos de modelos**, se ainda não estiver selecionado.
1. (Opcional) Se você tiver modelos compartilhados com você, poderá escolher entre **Meus modelos** ou **Compartilhado comigo**.
1. Selecione um modelo registrado.
1. Escolha a guia **Versões**, se ainda não estiver selecionada.
1. Escolha uma versão específica do modelo na lista **Versões**.
1. Escolha a guia **Linhagem**.
Na guia **Linhagem**, você pode navegar pelos recursos associados à versão do modelo. Você também pode escolher um recurso para ver os detalhes dele.
Observe que a visualização de linhagem serve apenas para fins de visualização. Reorganizar ou mover os componentes nessa exibição não afeta os recursos reais do modelo registrado.
Para`us-east-1`,`us-west-2`, e `eu-west-1` regiões`ap-northeast-1`, você pode usar as instruções a seguir para acessar os detalhes da linhagem das versões de modelo registradas e registradas:
1. Abra o console do Studio seguindo as instruções em [Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, escolha **Modelos**.
1. Escolha a guia **Meus modelos**.
1. (Opcional) Se você tiver modelos compartilhados com você, poderá escolher entre **Criado por mim** ou **Compartilhado comigo**.
1. Selecione um modelo e escolha **Exibir versão mais recente**.
1. Escolha a guia **Linhagem**.