Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Modelos de registro de modelos, versiones del modelo y grupos de modelos
El registro de SageMaker modelos está estructurado en varios grupos de modelos (paquetes) con paquetes de modelos en cada grupo. Estos grupos de modelos se pueden agregar opcionalmente a una o más colecciones. Cada paquete de modelos de un grupo de modelos corresponde a un modelo entrenado. La versión de cada paquete de modelos es un valor numérico que comienza en 1 y se incrementa con cada nuevo paquete de modelos que se agrega a un grupo de modelos. Por ejemplo, si se agregan 5 paquetes de modelos a un grupo de modelos, las versiones del paquete de modelos serán 1, 2, 3, 4 y 5.
Un paquete de modelos es el modelo real que está registrado en el registro de modelos como una entidad con control de versiones. Hay dos tipos de paquetes de modelos en la SageMaker IA. Un tipo se usa en AWS Marketplace y el otro se usa en el registro de modelos. Los paquetes de modelos utilizados en AWS Marketplace no son entidades que se puedan versionar y no están asociados a los grupos de modelos del registro de modelos. El registro de modelos recibe cada modelo nuevo que se reentrena, le da una versión y lo asigna a un grupo de modelos dentro del registro de modelos. En la siguiente imagen se muestra un ejemplo de un grupo de modelos con 25 modelos con versiones consecutivas. Para obtener más información sobre los paquetes modelo utilizados en AWS Marketplace, consulte[Algoritmos y paquetes en el AWS Marketplace](sagemaker-marketplace.md).
Los paquetes de modelos utilizados en el registro de modelos tienen control de versiones y **deben** estar asociados a un grupo de modelos. El ARN de este tipo de paquete modelo tiene la estructura: `'arn:aws:sagemaker:region:account:model-package-group/version'`
En los temas siguientes se muestra cómo crear modelos, versiones del modelo y grupos de modelos del registro de modelos y cómo trabajar con ellos.
**Topics**
+ [Cree un grupo de modelos](model-registry-model-group.md)
+ [Eliminación de un grupo de modelos](model-registry-delete-model-group.md)
+ [Registro de una versión del modelo](model-registry-version.md)
+ [Ver los grupos y las versiones de los modelos](model-registry-view.md)
+ [Actualización de los detalles de una versión del modelo](model-registry-details.md)
+ [Comparación de versiones del modelo](model-registry-version-compare.md)
+ [Visualización y administración del grupo de modelos y las etiquetas de versión del modelo](model-registry-tags.md)
+ [Eliminar una versión del modelo](model-registry-delete-model-version.md)
+ [Constructo por etapas para el ciclo de vida de su modelo](model-registry-staging-construct.md)
+ [Actualizar el estado de aprobación de un modelo](model-registry-approve.md)
+ [Implementación de un modelo desde el registro con Python](model-registry-deploy.md)
+ [Implementación de un modelo en Studio](model-registry-deploy-studio.md)
+ [Capacidad de detección entre cuentas](model-registry-ram.md)
+ [Ver el historial de implementación de un modelo](model-registry-deploy-history.md)
+ [Visualización de los detalles del linaje del modelo en Studio](model-registry-lineage-view-studio.md)
# Cree un grupo de modelos
Un grupo de modelos contiene diferentes versiones de un modelo. Puede crear un grupo de modelos que haga un seguimiento de todos los modelos que entrene para resolver un problema concreto. Cree un grupo de modelos mediante la consola AWS SDK para Python (Boto3) o la de Amazon SageMaker Studio.
## Cree un grupo de modelos (Boto3)
**importante**
Las políticas de IAM personalizadas que permiten a Amazon SageMaker Studio o Amazon SageMaker Studio Classic crear SageMaker recursos de Amazon también deben conceder permisos para añadir etiquetas a esos recursos. El permiso para añadir etiquetas a los recursos es necesario porque Studio y Studio Classic etiquetan automáticamente todos los recursos que crean. Si una política de IAM permite a Studio y Studio Classic crear recursos, pero no permite el etiquetado, se pueden producir errores de tipo AccessDenied «» al intentar crear recursos. Para obtener más información, consulte [Proporcione permisos para etiquetar los recursos de SageMaker IA](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS políticas gestionadas para Amazon SageMaker AI](security-iam-awsmanpol.md)que otorgan permisos para crear SageMaker recursos ya incluyen permisos para añadir etiquetas al crear esos recursos.
Para crear un grupo de modelos mediante Boto3, llame a la operación de la API `create_model_package_group` y especifique un nombre y una descripción como parámetros. En el ejemplo siguiente se muestra cómo crear un mediante grupo de modelos. La respuesta de la llamada `create_model_package_group` es el nombre de recurso de Amazon (ARN) del nuevo grupo de modelos.
En primer lugar, importe los paquetes necesarios y configure el 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)
```
Ahora cree el 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']))
```
## Creación de un grupo de modelos (Studio o Studio Classic)
Para crear un grupo de modelos en la consola de Amazon SageMaker Studio, complete los siguientes pasos en función de si utiliza Studio o Studio Classic.
------
#### [ Studio ]
1. Abre la consola de SageMaker Studio siguiendo las instrucciones de [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. En el panel de navegación izquierdo, elija **Models (Modelos)**.
1. Seleccione la pestaña **Modelos registrados**, si aún no la ha seleccionado.
1. Justo debajo de la etiqueta de la pestaña **Modelos registrados**, elija **Grupos de modelos**, si aún no lo ha seleccionado.
1. Seleccione **Registrar** y, a continuación, **Grupo de modelos**.
1. En el cuadro de diálogo **Registrar grupo de modelos**, introduzca la información siguiente:
+ El nombre del nuevo grupo de modelos en el campo **Nombre del grupo de modelos**.
+ (Opcional) Una descripción del grupo de modelos en el campo **Descripción**.
+ (Opcional) Cualquier par clave-valor que quiera asociar con el grupo de modelos en el campo **Etiquetas**. Para obtener información sobre el uso de etiquetas, consulte [Tagging AWS resources](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) en la *Referencia general de AWS*.
1. Elija **Registrar grupo de modelos**.
1. (Opcional) En la página **Modelos**, seleccione la pestaña **Modelos registrados** y, a continuación, elija **Grupos de modelos**. Confirme que el grupo de modelos recién creado aparezca en la lista de grupos de modelos.
------
#### [ Studio Classic ]
1. Inicia sesión en Amazon SageMaker Studio Classic. Para obtener más información, consulte [Lanzamiento de Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. En el panel de navegación izquierdo, elija el icono de **Inicio** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Elija **Modelos** y, a continuación, **Registro de modelos**.
1. Elija **Acciones** y, a continuación, elija **Crear grupo de modelos**.
1. En el cuadro de diálogo **Crear grupo de modelos**, ingrese la información siguiente:
+ Ingrese el nombre del nuevo grupo de modelos en el campo **Nombre del grupo de modelos**.
+ Ingrese una descripción en el campo **Descripción** (opcional).
+ Ingrese cualquier par clave-valor que quiera asociar con el grupo de modelos en el campo **Etiquetas** (opcional). Para obtener información sobre el uso de etiquetas, consulte [Tagging AWS resources](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) en la *Referencia general de AWS*.
+ Elija un proyecto al que asociar el grupo de modelos en el campo **Proyecto** (opcional). Para obtener información sobre proyectos, consulte [MLOps Automatización con SageMaker proyectos](sagemaker-projects.md).
1. Elija **Crear modelo**.
------
# Eliminación de un grupo de modelos
Este procedimiento muestra cómo eliminar un grupo de modelos en la consola de Amazon SageMaker Studio. Cuando se elimina un grupo de modelos, se pierde el acceso a las versiones del modelo en el grupo de modelos.
## Eliminación de un grupo de modelos (Studio o Studio Classic)
**importante**
Solo puede eliminar un grupo de modelos vacío. Antes de eliminar el grupo de modelos, elimine las versiones del modelo, si las hubiera.
Para eliminar un grupo de modelos en la consola de Amazon SageMaker Studio, complete los siguientes pasos en función de si utiliza Studio o Studio Classic.
------
#### [ Studio ]
1. Abre la consola de SageMaker Studio siguiendo las instrucciones de [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. En el panel de navegación izquierdo, elija **Models (Modelos)**.
1. Seleccione la pestaña **Modelos registrados**, si aún no la ha seleccionado.
1. Justo debajo de la etiqueta de la pestaña **Modelos registrados**, elija **Grupos de modelos**, si aún no lo ha seleccionado.
1. En la lista de grupos de modelos, marque la casilla de verificación situada junto a nombre del grupo de modelos que desea eliminar.
1. Seleccione los puntos suspensivos verticales situados sobre la esquina superior derecha de la lista de grupos de modelos y seleccione **Eliminar**.
1. En el cuadro de diálogo **Eliminar grupo de modelos**, elija **Sí, eliminar el grupo de modelos**.
1. Elija **Eliminar**.
1. Confirme que los grupos de modelos eliminados ya no aparecen en la lista de grupos de modelos.
------
#### [ Studio Classic ]
1. Inicia sesión en Amazon SageMaker Studio Classic. Para obtener más información, consulte [Lanzamiento de Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. En el panel de navegación izquierdo, elija el icono de **Inicio** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Elija **Modelos** y, a continuación, **Registro de modelos**. Aparece una lista de sus grupos de modelos.
1. En la lista de grupos de modelos, seleccione el nombre del grupo de modelos que desea eliminar.
1. En la esquina superior derecha, elija **Eliminar**.
1. En el cuadro de diálogo de confirmación, ingrese `REMOVE`.
1. Elija **Eliminar **.
------
# Registro de una versión del modelo
Puede registrar un modelo de Amazon SageMaker AI creando una versión del modelo que especifique el grupo de modelos al que pertenece. La versión del modelo debe incluir tanto los artefactos del modelo (los pesos entrenados de un modelo) como el código de inferencia del modelo.
Una *canalización de inferencia* es un modelo de SageMaker IA compuesto por una secuencia lineal de dos a quince contenedores que procesan las solicitudes de inferencia. Para registrar una canalización de inferencia, especifique los contenedores y las variables de entorno asociadas. Para obtener más información sobre las canalizaciones de inferencia, consulte [Canalizaciones de inferencia en Amazon AI SageMaker](inference-pipelines.md).
Para registrar un modelo con una canalización de inferencia, especifique los contenedores y las variables de entorno asociadas. Para crear una versión del modelo con una canalización de inferencias mediante la AWS SDK para Python (Boto3) consola de Amazon SageMaker Studio o mediante la creación de un paso en una canalización de creación de modelos de SageMaker IA, siga estos pasos.
**Topics**
+ [Registre una versión del modelo (SageMaker AI Pipelines)](#model-registry-pipeline)
+ [Registrar una versión del modelo (Boto3)](#model-registry-version-api)
+ [Registro de una versión del modelo (Studio o Studio Classic)](#model-registry-studio)
+ [Registrar una versión del modelo desde una cuenta diferente](#model-registry-version-xaccount)
## Registre una versión del modelo (SageMaker AI Pipelines)
Para registrar una versión del modelo mediante una canalización de creación de modelos de SageMaker IA, cree un `RegisterModel` paso en la canalización. Para obtener más información sobre cómo crear un paso `RegisterModel` como parte de una canalización, consulte [Paso 8: Defina un RegisterModel paso para crear un paquete modelo](define-pipeline.md#define-pipeline-register).
## Registrar una versión del modelo (Boto3)
Para registrar una versión de modelo mediante Boto3, llame a la operación de la API `create_model_package`.
En primer lugar, debe configurar el diccionario de parámetros para pasarlo a la operación de la 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)
```
A continuación, llame a la operación de la API `create_model_package` y pase el diccionario de parámetros que acaba 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))
```
## Registro de una versión del modelo (Studio o Studio Classic)
Para registrar una versión modelo en la consola de Amazon SageMaker Studio, complete los siguientes pasos en función de si utiliza Studio o Studio Classic.
------
#### [ Studio ]
1. Abre la consola de SageMaker Studio siguiendo las instrucciones de [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. En el panel de navegación izquierdo, elija **Modelos** en el menú.
1. Seleccione la pestaña **Modelos registrados**, si aún no la ha seleccionado.
1. Justo debajo de la etiqueta de la pestaña **Modelos registrados**, elija **Grupos de modelos** y **Mis modelos**, si aún no lo ha seleccionado.
1. Elija **Registro**. Esto abrirá la página **Registro del modelo**.
1. Siga las instrucciones proporcionadas en la página **Registro del modelo**.
1. Una vez revisadas las opciones elegidas, seleccione **Registrarse**. Una vez completado, accederá a la página **Información general** de la versión del modelo.
------
#### [ Studio Classic ]
1. Inicia sesión en Amazon SageMaker Studio Classic. Para obtener más información, consulte [Lanzamiento de Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. En el panel de navegación izquierdo, elija el icono de **Inicio** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Elija **Modelos** y, a continuación, **Registro de modelos**.
1. Abra el formulario **Registrar versión**. Puede hacerlo de una de las dos formas siguientes:
+ Elija **Acciones** y, a continuación, elija **Crear versión del modelo**.
+ Seleccione el nombre del grupo de modelos para el que desea crear una versión del modelo y, a continuación, elija **Crear versión del modelo**.
1. En el formulario **Registrar la versión del modelo**, ingrese la siguiente información:
+ En el menú desplegable **Nombre del grupo de paquetes de modelos**, seleccione el nombre del grupo de modelos.
+ Escriba una descripción para la versión del modelo (opcional).
+ En el menú desplegable **Estado de aprobación del modelo**, seleccione el estado de aprobación de la versión.
+ (Opcional) En el campo **Metadatos personalizados**, añada etiquetas personalizadas como pares clave-valor.
1. Elija **Siguiente**.
1. En el formulario de **Especificación de inferencia**, ingrese la siguiente información:
+ Ingrese la ubicación de la imagen de inferencia.
+ Ingrese la ubicación de los artefactos de los datos del modelo.
+ (Opcional) Introduzca la información sobre las imágenes que se van a usar para los trabajos de transformación e inferencia en tiempo real, y los tipos MIME de entrada y salida admitidos.
1. Elija **Siguiente**.
1. Proporcione detalles para facilitar las recomendaciones de puntos de conexión (opcional).
1. Elija **Siguiente**.
1. Elija las métricas del modelo que desee incluir (opcional).
1. Elija **Siguiente**.
1. Asegúrese de que la configuración mostrada sea correcta y elija **Registrar la versión del modelo**. Si posteriormente ve una ventana modal con un mensaje de error, seleccione **Ver** (junto al mensaje) para ver el origen del error.
1. Confirme que la nueva versión del modelo aparezca en la página del grupo de modelos principal.
------
## Registrar una versión del modelo desde una cuenta diferente
Para registrar versiones de modelos en un grupo de modelos creado por una AWS cuenta diferente, debe añadir una política de AWS Identity and Access Management recursos multicuenta para habilitar esa cuenta. Por ejemplo, una AWS cuenta de su organización es responsable del entrenamiento de los modelos y otra cuenta es responsable de administrar, implementar y actualizar los modelos. En este caso, debe crear políticas de recursos de IAM y aplicarlas al recurso de cuenta específico al que desea conceder acceso. Para obtener más información sobre las políticas de recursos multicuentas AWS, consulte la [Lógica de evaluación de políticas multicuentas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html) en la Guía del *AWS Identity and Access Management usuario*.
Para habilitar la detección entre cuentas, que permite a otras cuentas ver los grupos de paquetes de modelos desde la cuenta del propietario del recurso, consulte [Capacidad de detección entre cuentas](model-registry-ram.md).
**nota**
También debe usar una clave de KMS para cifrar la acción de [configuración de los datos de salida](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_OutputDataConfig.html) durante el entrenamiento para la implementación de un modelo entre cuentas.
Para habilitar el registro de modelos multicuentas en SageMaker AI, debe proporcionar una política de recursos multicuentas para el grupo de modelos que contenga las versiones del modelo. A continuación se muestra un ejemplo en el que se crean políticas entre cuentas para el grupo de modelos y se aplican a ese recurso específico.
La siguiente configuración debe establecerse en la cuenta de origen que registra los modelos entre cuentas en un grupo de modelos. En este ejemplo, la cuenta de origen es la cuenta de entrenamiento del modelo que entrenará y, a continuación, registrará la cuenta cruzada del modelo en el registro de modelos de la cuenta del registro de modelos.
En el ejemplo se supone que ha definido previamente las siguientes variables:
+ `sm_client`— Un cliente Boto3 de SageMaker IA.
+ `model_package_group_name`: el grupo de modelos al que desea conceder acceso.
+ `model_package_group_arn`: el ARN del grupo de modelos al que desea conceder acceso entre cuentas.
+ `bucket`: el bucket de Amazon S3 donde se almacenan los artefactos de entrenamiento del modelo.
Para poder implementar un modelo creado en una cuenta diferente, el usuario debe tener un rol que tenga acceso a las acciones de la SageMaker IA, como un rol con la política `AmazonSageMakerFullAccess` gestionada. Para obtener información sobre las políticas gestionadas de SageMaker IA, consulte[AWS políticas gestionadas para Amazon SageMaker AI](security-iam-awsmanpol.md).
### Políticas de recursos de IAM obligatorias
El siguiente diagrama muestra las políticas necesarias para permitir el registro de modelos entre cuentas. Como se muestra, estas políticas deben estar activas durante el entrenamiento del modelo para registrar correctamente el modelo en la cuenta del registro de modelos.
![\[\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/model_registry_cross_account.png)
En los siguientes ejemplos de código se muestran Amazon ECR, Amazon S3 y las AWS KMS políticas.
**Ejemplo de política de Amazon ECR**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AddPerm",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": [
"ecr:BatchGetImage",
"ecr:Describe*"
]
}
]
}
```
------
**Ejemplo de política de 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/*"
}
]
}
```
------
**Ejemplo de política AWS KMS **
------
#### [ 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 a las cuentas
La siguiente configuración de políticas aplica las políticas descritas en la sección anterior y debe incluirse en la cuenta de entrenamiento 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",
],
)
```
La siguiente configuración debe colocarse en la cuenta del registro de modelos donde se encuentra el grupo de modelos.
```
# 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 último, utilice la acción `create_model_package` de la cuenta de entrenamiento de modelos para registrar el paquete de modelos en la cuenta cruzada.
```
# 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))
```
# Ver los grupos y las versiones de los modelos
Los grupos y las versiones de los modelos le ayudan a organizar sus modelos. Puede ver una lista de las versiones de modelos de un grupo de modelos mediante la consola AWS SDK para Python (Boto3) (Boto3) o Amazon SageMaker Studio.
## Ver una lista de versiones del modelo en un grupo
Puede ver todas las versiones del modelo asociadas a un grupo de modelos. Si un grupo de modelos representa todos los modelos que se entrenan para solucionar un problema de ML específico, se pueden ver todos los modelos relacionados.
### Ver una lista de versiones del modelo en un grupo (Boto3)
Para ver las versiones del modelo asociadas a un grupo de modelos mediante Boto3, llame a la operación de la API `list_model_packages` y pase el nombre del grupo de modelos como valor del parámetro `ModelPackageGroupName`. El código siguiente muestra las versiones del modelo asociadas al grupo de modelos que creó en [Cree un grupo de modelos (Boto3)](model-registry-model-group.md#model-registry-package-group-api).
```
sm_client.list_model_packages(ModelPackageGroupName=model_package_group_name)
```
### Visualización de una lista de versiones del modelo en un grupo (Studio o Studio Classic)
Para ver una lista de las versiones de modelos de un grupo de modelos en la consola de Amazon SageMaker Studio, complete los siguientes pasos en función de si utiliza Studio o Studio Classic.
------
#### [ Studio ]
1. Abre la consola de SageMaker Studio siguiendo las instrucciones de [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. En el panel de navegación izquierdo, elija **Modelos** en el menú.
1. Seleccione la pestaña **Modelos registrados**, si aún no la ha seleccionado.
1. Justo debajo de la etiqueta de la pestaña **Modelos registrados**, elija **Grupos de modelos**, si aún no lo ha seleccionado.
1. En la lista de grupos de modelos, elija el corchete angular situado a la izquierda del grupo de modelos que desea ver.
1. Aparece una lista de las versiones del modelo del grupo de modelos.
1. (Opcional) Seleccione **Ver todo**, si se muestra, para ver otras versiones del modelo.
------
#### [ Studio Classic ]
1. Inicia sesión en Amazon SageMaker Studio Classic. Para obtener más información, consulte [Lanzamiento de Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. En el panel de navegación izquierdo, elija el icono de **Inicio** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Elija **Modelos** y, a continuación, **Registro de modelos**.
1. En la lista de grupos de modelos, seleccione el nombre del grupo de modelos que desea ver.
1. Aparece una nueva pestaña con una lista de las versiones del modelo del grupo de modelos.
------
# Actualización de los detalles de una versión del modelo
Puede ver y actualizar los detalles de una versión de modelo específica mediante la consola AWS SDK para Python (Boto3) o la de Amazon SageMaker Studio.
**importante**
Amazon SageMaker AI integra las tarjetas de modelo en Model Registry. Un paquete de modelos registrado en el Registro de modelos incluye una tarjeta de modelo simplificada como componente del paquete de modelos. Para obtener más información, consulte [Esquema de tarjeta de modelo del paquete del modelo (Studio)](#model-card-schema).
## Visualización y actualización de los detalles de una versión del modelo (Boto3)
Para ver los detalles de una versión del modelo mediante Boto3, complete los pasos siguientes.
1. Llame a la operación de la API `list_model_packages` para ver las versiones del modelo en un grupo de modelos.
```
sm_client.list_model_packages(ModelPackageGroupName="ModelGroup1")
```
La respuesta es una lista de resúmenes de paquetes de modelos. En esta lista, puede obtener el nombre de recurso de Amazon (ARN) de las versiones del modelo.
```
{'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. Llame a `describe_model_package` para ver los detalles de la versión del modelo. Ingrese el ARN de una versión del modelo que obtuvo en el resultado de la llamada `list_model_packages`.
```
sm_client.describe_model_package(ModelPackageName="arn:aws:sagemaker:us-east-2:123456789012:model-package/ModelGroup1/1")
```
El resultado de esta llamada es un objeto JSON con los detalles de la versión del 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 de tarjeta de modelo del paquete del modelo (Studio)
Todos los detalles relacionados con la versión del modelo están encapsulados en la tarjeta de modelo del paquete del modelo. La tarjeta modelo de un paquete modelo es un uso especial de la tarjeta SageMaker modelo de Amazon y su esquema está simplificado. El esquema de la tarjeta de modelo del paquete de modelos se muestra en el siguiente menú desplegable expandible.
#### Esquema de tarjeta de modelo del paquete del modelo
```
{
"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
}
}
}
```
## Visualización y actualización de los detalles de una versión del modelo (Studio o Studio Classic)
Para ver y actualizar los detalles de una versión del modelo, realice los pasos siguientes en función de si utiliza Studio o Studio Classic. En Studio Classic, puede actualizar el estado de aprobación de una versión del modelo. Para obtener más información, consulte [Actualizar el estado de aprobación de un modelo](model-registry-approve.md). En Studio, por otro lado, la SageMaker IA crea una tarjeta modelo para un paquete modelo, y la interfaz de usuario de la versión del modelo ofrece opciones para actualizar los detalles de la tarjeta modelo.
------
#### [ Studio ]
1. Abre la consola de SageMaker Studio siguiendo las instrucciones de [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. En el panel de navegación izquierdo, elija **Modelos** en el menú.
1. Seleccione la pestaña **Modelos registrados**, si aún no la ha seleccionado.
1. Justo debajo de la etiqueta de la pestaña **Modelos registrados**, elija **Grupos de modelos**, si aún no lo ha seleccionado.
1. Seleccione el nombre del grupo de modelos que contiene la versión del modelo que desea ver.
1. En la lista de versiones del modelo, seleccione la versión del modelo que desea ver.
1. Elija una de las siguientes pestañas:
+ **Entrenamiento**: para ver o editar los detalles relacionados con su trabajo de entrenamiento, incluidas las métricas de rendimiento, los artefactos, el rol de IAM y el cifrado y los contenedores. Para obtener más información, consulte [Adición de un trabajo de entrenamiento (Studio)](model-registry-details-studio-training.md).
+ **Evaluar**: para ver o editar los detalles relacionados con su trabajo de entrenamiento, como las métricas de rendimiento, los conjuntos de datos de evaluación y la seguridad. Para obtener más información, consulte [Adición de un trabajo de evaluación (Studio)](model-registry-details-studio-evaluate.md).
+ **Auditoría**: para ver o editar detalles de alto nivel relacionados con el propósito empresarial, el uso, el riesgo y los detalles técnicos del modelo, como las limitaciones del algoritmo y el rendimiento. Para obtener más información, consulte [Actualización de la información de auditoría (gobernanza) (Studio)](model-registry-details-studio-audit.md).
+ **Implementación**: para ver o editar la ubicación del contenedor de imágenes de inferencia y las instancias que componen el punto de conexión. Para obtener más información, consulte [Actualización de la información de implementación (Studio)](model-registry-details-studio-deploy.md).
------
#### [ Studio Classic ]
1. Inicia sesión en Amazon SageMaker Studio Classic. Para obtener más información, consulte [Lanzamiento de Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. En el panel de navegación izquierdo, elija el icono de **Inicio** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Elija **Modelos** y, a continuación, **Registro de modelos**.
1. En la lista de grupos de modelos, seleccione el nombre del grupo de modelos que desea ver.
1. Aparece una nueva pestaña con una lista de las versiones del modelo del grupo de modelos.
1. En la lista de versiones de modelo, seleccione el nombre de la versión del modelo de la que quiere ver los detalles.
1. En la pestaña de la versión del modelo que se abre, elija una de las siguientes opciones para ver los detalles sobre la versión del modelo:
+ **Actividad**: muestra los eventos de la versión del modelo, como las actualizaciones del estado de aprobación.
+ **Calidad del modelo**: comunica las métricas relacionadas con las comprobaciones de calidad de los modelos del monitor de modelos, que comparan las predicciones del modelo con las de Ground Truth. Para obtener más información sobre las comprobaciones de calidad de los modelos del monitor de modelos, consulte [Calidad de modelo](model-monitor-model-quality.md).
+ **Explicabilidad**: comunica las métricas relacionadas con las comprobaciones de atribución de características del monitor de modelos, que comparan las clasificaciones relativas de las características en los datos de entrenamiento con las de los datos en tiempo real. Para obtener más información sobre las comprobaciones de explicabilidad del monitor de modelos, consulte [Desviación en la atribución de características de los modelos en producción](clarify-model-monitor-feature-attribution-drift.md).
+ **Sesgo**: comunica las métricas relacionadas con las comprobaciones de desviación de sesgo del monitor de modelos, que comparan la distribución de los datos en tiempo real con los datos de entrenamiento. Para obtener más información sobre las comprobaciones de desviación de sesgo del monitor de modelos, consulte [Desviación de sesgo de modelos en producción](clarify-model-monitor-bias-drift.md).
+ **Recomendador de inferencias**: proporciona recomendaciones de instancia iniciales para lograr un rendimiento óptimo en función del modelo y las cargas de muestra.
+ **Prueba de carga**: ejecuta pruebas de carga en los tipos de instancias que elija cuando indique sus requisitos de producción específicos, como las restricciones de latencia y rendimiento.
+ **Especificación de inferencia**: muestra los tipos de instancias para sus trabajos de inferencia y transformación en tiempo real, así como información sobre sus contenedores de Amazon ECR.
+ **Información**: muestra información como el proyecto al que está asociada la versión del modelo, la canalización que generó el modelo, el grupo de modelos y la ubicación del modelo en Amazon S3.
------
# Adición de un trabajo de entrenamiento (Studio)
**importante**
A partir del 30 de noviembre de 2023, la experiencia anterior de Amazon SageMaker Studio pasa a denominarse Amazon SageMaker Studio Classic. La siguiente sección está dedicada expresamente al uso de la experiencia de Studio actualizada. Para obtener más información sobre el uso de la aplicación de Studio Classic, consulte [Amazon SageMaker Studio Clásico](studio.md).
Puedes añadir a tu modelo un trabajo de formación, creado externamente o con SageMaker IA. **Si añades un trabajo de SageMaker formación, la SageMaker IA rellena previamente los campos de todas las subpáginas de la pestaña Tren.** Si añade un trabajo de entrenamiento creado externamente, tendrá que añadir los detalles relacionados con el trabajo de entrenamiento de forma manual.
**Para añadir un trabajo de entrenamiento a su paquete del modelo, realice los pasos siguientes.**
1. Elija la pestaña **Entrenar**.
1. Elija **Añadir**. Si no ve esta opción, es posible que ya tenga un trabajo de entrenamiento asociado. Si desea eliminar este trabajo de entrenamiento, siga estas instrucciones para eliminar un trabajo de entrenamiento.
1. Puedes añadir un trabajo de formación que hayas creado en SageMaker IA o un trabajo de formación que hayas creado externamente.
1. Para añadir un trabajo de formación que hayas creado en SageMaker IA, sigue estos pasos.
1. Elige **SageMaker IA**.
1. Seleccione el botón de opción junto al trabajo de entrenamiento que desee añadir.
1. Elija **Añadir**.
1. Para añadir un trabajo de entrenamiento creado externamente, realice los pasos siguientes.
1. Elija **Custom (Personalizados)**.
1. En el campo **Nombre**, introduzca el nombre de su trabajo de entrenamiento personalizado.
1. Elija **Añadir**.
# Eliminación de un trabajo de entrenamiento (Studio)
Puede eliminar de su modelo un trabajo de formación, creado externamente o con SageMaker IA, siguiendo estos pasos.
**Realice los siguientes pasos para eliminar un trabajo de entrenamiento de su paquete de modelos.**
1. Seleccione **Capacitar**.
1. Seleccione el icono del **engranaje** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/icons/Settings_squid.png)) en la pestaña **Entrenar**.
1. Seleccione **Eliminar** junto al trabajo de entrenamiento.
1. Seleccione **Sí, quiero eliminar **.
1. Seleccione **Listo**.
# Actualización de los detalles del trabajo de entrenamiento (Studio)
Complete los siguientes pasos para actualizar los detalles de un trabajo de formación, creado externamente o con SageMaker IA, asociado a su modelo.
**Para actualizar (y ver) los detalles relacionados con el trabajo de entrenamiento:**
1. En la pestaña **Entrenar**, consulte el estado del trabajo de entrenamiento. El estado es `Complete` si ha añadido un trabajo de entrenamiento a su paquete del modelo y `Undefined` si no lo ha hecho.
1. Para ver los detalles relacionados con su trabajo de entrenamiento, como el rendimiento, los hiperparámetros y los detalles de identificación, seleccione la pestaña **Entrenar**.
1. Realice los siguientes pasos para actualizar y ver detalles relacionados con el rendimiento del modelo.
1. Seleccione **Rendimiento** en la barra lateral izquierda de la pestaña **Entrenar**.
1. Consulte **Métricas** relacionadas con su trabajo de entrenamiento. La página **Rendimiento** muestra las métricas por nombre, valor y cualquier nota que haya añadido en relación con la métrica.
1. (Opcional) Para añadir notas a las métricas existentes, realice los pasos siguientes.
1. Elija los puntos suspensivos verticales en la esquina superior derecha de la página de versión del modelo y elija **Editar**.
1. Añada notas a cualquiera de las métricas de la lista.
1. En la parte superior de la página de la versión del modelo, seleccione **Guardar** en el banner **Edición de versión del modelo...**
1. Consulte **Métricas personalizadas** relacionadas con su trabajo de entrenamiento. Las métricas personalizadas tienen un formato similar al de las métricas.
1. (Opcional) Para añadir métricas personalizadas, realice los pasos siguientes.
1. Elija **Añadir**.
1. Inserte un nombre, un valor y cualquier nota opcional para la nueva métrica.
1. (Opcional) Para eliminar métricas personalizadas, elija el icono de la **papelera** junto a la métrica correspondiente.
1. En el cuadro de texto **Observaciones**, consulte las notas que haya añadido relacionadas con el rendimiento de su trabajo de entrenamiento.
1. (Opcional) Para añadir o actualizar las observaciones, realice los pasos siguientes.
1. Elija los puntos suspensivos verticales en la esquina superior derecha de la página de versión del modelo y elija **Editar**.
1. Añada o actualice sus notas en el cuadro de texto **Observaciones**.
1. En la parte superior de la página de la versión del modelo, seleccione **Guardar** en el banner **Edición de versión del modelo...**
1. Realice los siguientes pasos para actualizar y ver detalles relacionados con los artefactos del modelo.
1. Seleccione **Artefactos** en la barra lateral izquierda de la pestaña **Entrenar**.
1. En el campo **Ubicación (URI de S3)**, consulte la ubicación en Amazon S3 de sus conjuntos de datos de entrenamiento.
1. En el campo **Modelos**, consulte el nombre y las ubicaciones en Amazon S3 de los artefactos de modelos de otros modelos que haya incluido en el trabajo de entrenamiento.
1. Para actualizar cualquiera de los campos de la página **Artefactos**, realice los siguientes pasos.
1. Elija los puntos suspensivos verticales en la esquina superior derecha de la página de versión del modelo y elija **Editar**.
1. Introduzca valores nuevos en cualquiera de los campos.
1. En la parte superior de la página de la versión del modelo, seleccione **Guardar** en el banner **Edición de versión del modelo...**
1. Realice los siguientes pasos para actualizar y ver detalles relacionados con los hiperparámetros.
1. Seleccione **Hiperparámetros** en la barra lateral izquierda de la pestaña **Entrenar**.
1. Vea la SageMaker IA proporcionada y los hiperparámetros personalizados definidos. Cada hiperparámetro aparece con su nombre y valor.
1. Vea los hiperparámetros personalizados que ha añadido.
1. (Opcional) Para añadir un hiperparámetro personalizado adicional, realice los siguientes pasos.
1. Encima de la esquina superior derecha de la tabla **Hiperparámetros personalizados**, elija **Agregar**. Aparecen un par de campos en blanco nuevos.
1. Introduzca el nombre y el valor del nuevo hiperparámetro personalizado. Estos valores se guardan automáticamente.
1. (Opcional) Para eliminar un hiperparámetro personalizado, seleccione el icono de la **papelera** situado a la derecha del hiperparámetro.
1. Realice los siguientes pasos para actualizar y ver los detalles relacionados con el entorno de trabajo de entrenamiento.
1. Seleccione **Entorno** en la barra lateral izquierda de la pestaña **Entrenar**.
1. Vea las ubicaciones de los URI de Amazon ECR de cualquier contenedor de trabajos de formación que haya añadido SageMaker AI (para un trabajo de SageMaker formación) o usted (para un trabajo de formación personalizado).
1. (Opcional) Para añadir un contenedor de trabajos de entrenamiento adicional, seleccione **Agregar** y, a continuación, introduzca el URI del nuevo contenedor de entrenamiento.
1. Para actualizar y ver el nombre del trabajo de entrenamiento y los nombres de recurso de Amazon (ARN) del trabajo de entrenamiento, realice los siguientes pasos.
1. Seleccione **Detalles** en la barra lateral izquierda de la pestaña **Entrenar**.
1. Vea el nombre del trabajo de entrenamiento y el ARN del trabajo de entrenamiento.
# Adición de un trabajo de evaluación (Studio)
**importante**
A partir del 30 de noviembre de 2023, la experiencia anterior de Amazon SageMaker Studio pasa a denominarse Amazon SageMaker Studio Classic. La siguiente sección está dedicada expresamente al uso de la experiencia de Studio actualizada. Para obtener más información sobre el uso de la aplicación de Studio Classic, consulte [Amazon SageMaker Studio Clásico](studio.md).
Después de registrar el modelo, puede probarlo con uno o más conjuntos de datos para evaluar su rendimiento. Puede añadir uno o más trabajos de evaluación desde Amazon S3 o definir su propio trabajo de evaluación introduciendo manualmente todos los detalles. **Si añade un trabajo desde Amazon S3, la SageMaker IA rellena previamente los campos de todas las subpáginas de la pestaña Evaluar.** Si define su propio trabajo de evaluación, tendrá que añadir manualmente los detalles relacionados con el trabajo de evaluación.
**Para añadir un trabajo de evaluación a su paquete del modelo, realice los pasos siguientes.**
1. Seleccione la pestaña **Evaluar**.
1. Elija **Añadir**.
1. Puede añadir un trabajo de evaluación desde Amazon S3 o un trabajo de evaluación personalizado.
1. Para añadir un trabajo de evaluación con material de Amazon S3, realice los siguientes pasos.
1. Elija **S3**.
1. Introduzca un nombre para el trabajo de evaluación.
1. Introduzca la ubicación de Amazon S3 en el material de salida de su trabajo de evaluación.
1. Elija **Añadir**.
1. Para añadir un trabajo de evaluación personalizado, realice el siguiente paso:
1. Elija **Custom (Personalizados)**.
1. Introduzca un nombre para el trabajo de evaluación.
1. Elija **Añadir**.
**Realice los siguientes pasos para añadir un trabajo de evaluación adicional a su paquete del modelo.**
1. Seleccione la pestaña **Evaluar**.
1. Seleccione el icono del **engranaje** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/icons/Settings_squid.png)) en la pestaña **Entrenar**.
1. En el cuadro de diálogo, elija **Agregar**.
1. Puede añadir un trabajo de evaluación desde Amazon S3 o un trabajo de evaluación personalizado.
1. Para añadir un trabajo de evaluación con material de Amazon S3, realice los siguientes pasos.
1. Elija **S3**.
1. Introduzca un nombre para el trabajo de evaluación.
1. Introduzca la ubicación de Amazon S3 en el material de salida de su trabajo de evaluación.
1. Elija **Añadir**.
1. Para añadir un trabajo de evaluación personalizado, realice el siguiente paso:
1. Elija **Custom (Personalizados)**.
1. Introduzca un nombre para el trabajo de evaluación.
1. Elija **Añadir**.
# Eliminación de un trabajo de evaluación (Studio)
Puede eliminar de su modelo un trabajo de evaluación, creado externamente o con SageMaker IA, siguiendo estos pasos.
**Realice los siguientes pasos para eliminar un trabajo de evaluación de su paquete del modelo.**
1. Seleccione la pestaña **Evaluar**.
1. Seleccione el icono del **engranaje** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/icons/Settings_squid.png)) en la pestaña **Entrenar**.
1. (Opcional) Para encontrar el trabajo de evaluación en la lista, introduzca un término de búsqueda en el cuadro de búsqueda para reducir la lista de opciones.
1. Elija el botón de opción situado junto al trabajo de evaluación.
1. Elija **Eliminar **.
1. Seleccione **Sí, quiero eliminar **.
1. Seleccione **Listo**.
# Actualización de un trabajo de evaluación (Studio)
Complete los siguientes pasos para actualizar los detalles de un trabajo de evaluación, creado externamente o con SageMaker IA, asociado a su modelo.
**Para actualizar (y ver) los detalles relacionados con el trabajo de evaluación:**
1. En la pestaña **Evaluar**, consulte el estado del trabajo de evaluación. El estado es `Complete` si ha añadido un trabajo de evaluación a su paquete del modelo y `Undefined` si no lo ha hecho.
1. Para ver los detalles relacionados con su trabajo de evaluación, como el rendimiento y la ubicación de los artefactos, seleccione la pestaña **Evaluar**.
1. Para actualizar y ver los detalles relacionados con el rendimiento del modelo durante la evaluación, realice los siguientes pasos.
1. Elija **Rendimiento** en la barra lateral de la pestaña **Evaluar**.
1. Consulte las métricas relacionadas con el trabajo de evaluación en la lista **Métricas**. La lista **Métricas** muestra las métricas individuales por nombre, valor y cualquier nota que haya añadido en relación con la métrica.
1. En el cuadro de texto **Observaciones**, consulte las notas que haya añadido relacionadas con el rendimiento de su trabajo de evaluación.
1. Para actualizar cualquiera de los campos de **Notas** para cualquier métrica o campo **Observaciones**, realice los siguientes pasos.
1. Elija los puntos suspensivos verticales en la esquina superior derecha de la página de versión del modelo y elija **Editar**.
1. Introduzca notas para cualquier métrica o en el cuadro de texto **Observaciones**.
1. En la parte superior de la página de la versión del modelo, seleccione **Guardar** en el banner **Edición de versión del modelo...**
1. Realice los siguientes pasos para actualizar y ver los detalles relacionados con sus conjuntos de datos de trabajos de evaluación.
1. Seleccione **Artefactos** en la barra lateral izquierda de la página **Evaluar**.
1. Vea los conjuntos de datos utilizados en su trabajo de evaluación.
1. (Opcional) Para añadir un conjunto de datos, elija **Agregar** e introduzca un URI de Amazon S3 en el conjunto de datos.
1. (Opcional) Para eliminar un conjunto de datos, elija el icono de la **papelera** situado junto al conjunto de datos que desea eliminar.
1. Para ver el nombre del trabajo y el ARN del trabajo de evaluación, elija **Detalles**.
# Actualización de la información de auditoría (gobernanza) (Studio)
**importante**
A partir del 30 de noviembre de 2023, la experiencia anterior de Amazon SageMaker Studio pasa a denominarse Amazon SageMaker Studio Classic. La siguiente sección está dedicada expresamente al uso de la experiencia de Studio actualizada. Para obtener más información sobre el uso de la aplicación de Studio Classic, consulte [Amazon SageMaker Studio Clásico](studio.md).
Documente los detalles importantes del modelo para ayudar a su organización a establecer un marco sólido de gobernanza del modelo. Usted y los miembros de su equipo pueden consultar estos detalles para que utilicen el modelo en los casos de uso adecuados, conozcan el dominio empresarial y los propietarios del modelo y comprendan los riesgos del modelo. También puede guardar detalles sobre el rendimiento esperado del modelo y los motivos de las limitaciones de rendimiento.
**Realice los siguientes pasos para ver o actualizar los detalles relacionados con la gobernanza del modelo.**
1. En la pestaña **Auditoría**, consulte el estado de aprobación de la tarjeta de modelo. El estado puede ser uno de los siguientes:
+ **Borrador**: la tarjeta de modelo sigue siendo un borrador.
+ **Pendiente de aprobación**: el modelo de tarjeta está pendiente de aprobación.
+ **Aprobado**: el modelo de tarjeta está aprobado.
1. Para actualizar el estado de aprobación del modelo de tarjeta, seleccione el menú desplegable situado junto al estado de aprobación y elija el estado de aprobación actualizado.
1. Realice los siguientes pasos para actualizar y ver los detalles relacionados con el riesgo de su paquete del modelo.
1. Seleccione **Riesgo** en la barra lateral izquierda de la pestaña **Auditoría**.
1. Vea la clasificación de riesgo actual y su explicación.
1. Realice los siguientes pasos para actualizar la clasificación o la explicación.
1. Elija los puntos suspensivos verticales en la esquina superior derecha de la página **Auditoría** y elija **Editar**.
1. (Opcional) Elija una clasificación de riesgo actualizada.
1. (Opcional) Actualice la explicación de la clasificación de riesgo.
1. En la parte superior de la página de la versión del modelo, seleccione **Guardar** en el banner **Edición de versión del modelo...**
1. Realice los siguientes pasos para actualizar y ver los detalles relacionados con el uso de su paquete del modelo.
1. Seleccione **Uso** en la barra lateral izquierda de la pestaña **Auditoría**.
1. Vea el texto que ha añadido en los siguientes campos:
+ **Tipo de problema**: la categoría de algoritmo de machine learning utilizada para crear el modelo.
+ **Tipo de algoritmo**: el algoritmo específico utilizado para crear el modelo.
+ **Usos previstos**: la aplicación actual del modelo a su problema empresarial.
+ **Factores que afectan a la eficacia del modelo**: notas sobre las limitaciones de rendimiento de su modelo.
+ **Uso recomendado**: los tipos de aplicaciones que se pueden crear con el modelo, los escenarios en los que se puede esperar un rendimiento razonable o el tipo de datos que se van a utilizar con el modelo.
+ **Consideraciones éticas**: una descripción de la forma en que su modelo podría discriminar en función de factores como la edad o el sexo.
1. Para actualizar cualquiera de los campos de la lista anterior, realice los pasos siguientes.
1. Elija los puntos suspensivos verticales en la esquina superior derecha de la página de versión del modelo y elija **Editar**.
1. (Opcional) Utilice los menús desplegables de **Tipo de problema** y **Tipo de algoritmo** para seleccionar nuevos valores, si es necesario.
1. (Opcional) Actualice las descripciones de texto en los campos restantes.
1. En la parte superior de la página de la versión del modelo, seleccione **Guardar** en el banner **Edición de versión del modelo...**
1. Para actualizar y ver los detalles relacionados con las partes interesadas de su paquete de modelos, realice los siguientes pasos.
1. Seleccione **Partes interesadas** en la barra lateral izquierda de la pestaña **Auditoría**.
1. Vea el propietario y el creador del modelo actual, si los hay.
1. Realice los siguientes pasos para actualizar al propietario o al creador del modelo:
1. Elija los puntos suspensivos verticales en la esquina superior derecha de la página de versión del modelo y elija **Editar**.
1. Actualice los campos del propietario o creador del modelo.
1. En la parte superior de la página de la versión del modelo, seleccione **Guardar** en el banner **Edición de versión del modelo...**
1. Para actualizar y ver los detalles relacionados con el problema empresarial que aborda el paquete del modelo, realice los siguientes pasos.
1. Seleccione **Empresa** en la barra lateral izquierda de la pestaña **Auditoría**.
1. Vea las descripciones actuales, si las hay, del problema empresarial que aborda el modelo, las partes interesadas en el problema empresarial y la línea de negocio.
1. Para actualizar cualquiera de los campos de la pestaña **Empresa**, realice los siguientes pasos.
1. Elija los puntos suspensivos verticales en la esquina superior derecha de la página de versión del modelo y elija **Editar**.
1. Actualice las descripciones de cualquiera de los campos.
1. En la parte superior de la página de la versión del modelo, seleccione **Guardar** en el banner **Edición de versión del modelo...**
1. Para actualizar y ver la documentación existente (representada como pares clave-valor) del modelo, realice los siguientes pasos.
1. Elija **Documentación** en la barra lateral izquierda de la página **Auditoría**.
1. Visualización de pares clave-valor existentes.
1. Para añadir cualquier par clave-valor, siga los pasos que se indican a continuación.
1. Elija los puntos suspensivos verticales en la esquina superior derecha de la página de versión del modelo y elija **Editar**.
1. Elija **Añadir**.
1. Introduzca un nuevo valor de clave y asociado.
1. En la parte superior de la página de la versión del modelo, seleccione **Guardar** en el banner **Edición de versión del modelo...**
1. Para eliminar cualquier par clave-valor, siga los pasos que se indican a continuación.
1. Elija los puntos suspensivos verticales en la esquina superior derecha de la página de versión del modelo y elija **Editar**.
1. Elija el icono de la **papelera** junto al par clave-valor que desea eliminar.
1. En la parte superior de la página de la versión del modelo, seleccione **Guardar** en el banner **Edición de versión del modelo...**
# Actualización de la información de implementación (Studio)
**importante**
A partir del 30 de noviembre de 2023, la experiencia anterior de Amazon SageMaker Studio pasa a denominarse Amazon SageMaker Studio Classic. La siguiente sección está dedicada expresamente al uso de la experiencia de Studio actualizada. Para obtener más información sobre el uso de la aplicación de Studio Classic, consulte [Amazon SageMaker Studio Clásico](studio.md).
Tras evaluar el rendimiento del modelo y determinar si está listo para usarse en las cargas de trabajo de producción, puede cambiar el estado de aprobación del modelo para iniciar la CI/CD implementación. Para obtener más información sobre las definiciones del estado de aprobación, consulte [Actualizar el estado de aprobación de un modelo](model-registry-approve.md).
**Realice los siguientes pasos para ver o actualizar los detalles relacionados con la implementación del paquete del modelo.**
1. En la pestaña **Implementar**, consulte el estado de aprobación del paquete del modelo. Los valores posibles pueden ser los siguientes:
+ **Pendiente de aprobación**: el modelo está registrado pero aún no se ha aprobado o rechazado su implementación.
+ **Aprobado**: el modelo está aprobado para la implementación de CI/CD. Si existe una EventBridge regla que inicia la implementación del modelo tras un evento de aprobación del modelo, como es el caso de un modelo creado a partir de una plantilla de proyecto de SageMaker IA, la SageMaker IA también despliega el modelo.
+ **Rechazado**: se rechaza la implementación del modelo.
Si necesita cambiar el estado de aprobación, elija el menú desplegable situado junto al estado y seleccione el estado actualizado.
1. Para actualizar el estado de aprobación del paquete del modelo, seleccione el menú desplegable situado junto al estado de aprobación y elija el estado de aprobación actualizado.
1. En la lista **Contenedores**, consulte los contenedores de imágenes de inferencia.
1. En la lista **Instancias**, consulte las instancias que componen el punto de conexión de la implementación.
# Comparación de versiones del modelo
A medida que genere versiones de modelos, es posible que desee comparar las versiones de los modelos consultando las métricas de calidad de los modelos relevantes side-by-side. Por ejemplo, es posible que desee realizar un seguimiento de la precisión comparando los valores del error cuadrático medio (MSE) o puede decidir eliminar los modelos que tienen un rendimiento deficiente en determinadas medidas. El siguiente procedimiento muestra cómo configurar la comparación de versiones de modelos en Model Registry mediante la consola Amazon SageMaker Studio Classic.
## Comparar versiones de modelos (Amazon SageMaker Studio Classic)
**nota**
Solo puedes comparar las versiones de los modelos de la consola Amazon SageMaker Studio Classic.
Para comparar las versiones del modelo dentro de un grupo de modelos, complete los siguientes pasos:
1. Inicie sesión en Studio Classic. Para obtener más información, consulte [Descripción general del dominio Amazon SageMaker AI](gs-studio-onboard.md).
1. En el panel de navegación izquierdo, elija el icono de **Inicio** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Elija **Modelos** y, a continuación, **Registro de modelos**.
1. En la lista de grupos de modelos, seleccione el nombre del grupo de modelos que desea ver. Se abre una nueva pestaña con una lista de las versiones del modelo del grupo de modelos.
1. En la lista de las versiones del modelo, marque las casillas situadas junto a las versiones del modelo que desee comparar.
1. Elija **Acciones** y después **Modificar**. Aparece una lista de las métricas de calidad de los modelos seleccionados.
# Visualización y administración del grupo de modelos y las etiquetas de versión del modelo
El registro de modelos le ayuda a ver y administrar las etiquetas relacionadas con sus grupos de modelos. Utilice etiquetas para clasificar los grupos de modelos según su finalidad, propietario, entorno u otro criterio. En las siguientes instrucciones se muestra cómo ver, añadir, eliminar y editar las etiquetas en la consola de Amazon SageMaker Studio.
**nota**
Los paquetes de modelos del Registro de SageMaker modelos no admiten etiquetas; se trata de paquetes de modelos versionados. En cambio, puede agregar pares clave-valor con `CustomerMetadataProperties`. Los grupos de paquetes de modelos del registro de modelos admiten el etiquetado.
## Visualización y administración de etiquetas de grupos de modelos
------
#### [ Studio ]
**Para ver una etiqueta del grupo de modelos, realice los siguientes pasos:**
1. Abre la consola de SageMaker Studio siguiendo las instrucciones de [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. En el panel de navegación izquierdo, elija **Modelos** para ver una lista de sus grupos de modelos.
1. Seleccione la pestaña **Modelos registrados**, si aún no la ha seleccionado.
1. Justo debajo de la etiqueta de la pestaña **Modelos registrados**, elija **Grupos de modelos**, si aún no lo ha seleccionado.
1. En la lista de grupos de modelos, seleccione el nombre del grupo de modelos que desea ver.
1. En la página del grupo de modelos, seleccione la pestaña **Etiquetas**. Vea las etiquetas asociadas a su grupo de modelos.
**Para agregar una etiqueta al grupo de modelos, complete los siguientes pasos:**
1. Abre la consola de SageMaker Studio siguiendo las instrucciones de [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. En el panel de navegación izquierdo, elija **Modelos** para ver una lista de sus grupos de modelos.
1. Seleccione la pestaña **Modelos registrados**, si aún no la ha seleccionado.
1. Justo debajo de la etiqueta de la pestaña **Modelos registrados**, elija **Grupos de modelos**, si aún no lo ha seleccionado.
1. En la lista Grupos de modelos, seleccione el nombre del grupo de modelos que desea editar.
1. En la página del grupo de modelos, seleccione la pestaña **Etiquetas**.
1. Elija **Agregar/Editar etiquetas**.
1. En la parte superior de **\$1 Agregar nueva etiqueta**, introduzca la nueva clave en el campo **Clave** en blanco.
1. Ingrese el nuevo valor en el campo **Valor** en blanco (opcional).
1. Elija **Confirmar cambios**.
1. Confirme que la nueva etiqueta aparezca en la sección **Etiquetas** de la página **Información**.
**Para eliminar una etiqueta del grupo de modelos, complete los siguientes pasos:**
1. Abre la consola de SageMaker Studio siguiendo las instrucciones de [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. En el panel de navegación izquierdo, elija **Modelos** para ver una lista de sus grupos de modelos.
1. Seleccione la pestaña **Modelos registrados**, si aún no la ha seleccionado.
1. Justo debajo de la etiqueta de la pestaña **Modelos registrados**, elija **Grupos de modelos**, si aún no lo ha seleccionado.
1. En la lista Grupos de modelos, seleccione el nombre del grupo de modelos que desea editar.
1. En la página del grupo de modelos, seleccione la pestaña **Etiquetas**.
1. Elija **Agregar/Editar etiquetas**.
1. Elija el icono de la **papelera** situado al lado del par clave-valor que desea eliminar.
1. Elija **Confirmar cambios**.
**Para editar una etiqueta del grupo de modelos, complete los siguientes pasos:**
1. Abre la consola de SageMaker Studio siguiendo las instrucciones de [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. En el panel de navegación izquierdo, elija **Modelos** para ver una lista de sus grupos de modelos.
1. Seleccione la pestaña **Modelos registrados**, si aún no la ha seleccionado.
1. Justo debajo de la etiqueta de la pestaña **Modelos registrados**, elija **Grupos de modelos**, si aún no lo ha seleccionado.
1. En la lista Grupos de modelos, seleccione el nombre del grupo de modelos que desea editar.
1. En la página del grupo de modelos, seleccione la pestaña **Etiquetas**.
1. Elija **Agregar/Editar etiquetas**.
1. Introduzca un nuevo valor en el campo **Valor** del par de claves que desee editar.
1. Elija **Confirmar cambios**.
------
#### [ Studio Classic ]
**Para ver una etiqueta del grupo de modelos, realice los siguientes pasos:**
1. Inicia sesión en Amazon SageMaker Studio Classic. Para obtener más información, consulte [Lanzamiento de Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. En el panel de navegación izquierdo, elija el icono de **Inicio** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Elija **Modelos** y, a continuación, **Registro de modelos**.
1. En la lista Grupos de modelos, seleccione el nombre del grupo de modelos que desea editar.
1. Elija **Información**.
1. Vea las etiquetas en la sección **Etiquetas** de la página **Información**.
**Para agregar una etiqueta al grupo de modelos, complete los siguientes pasos:**
1. Inicia sesión en Amazon SageMaker Studio Classic. Para obtener más información, consulte [Descripción general del dominio Amazon SageMaker AI](gs-studio-onboard.md).
1. En el panel de navegación izquierdo, elija el icono de **Inicio** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Elija **Modelos** y, a continuación, **Registro de modelos**.
1. En la lista Grupos de modelos, seleccione el nombre del grupo de modelos que desea editar.
1. Elija **Información**.
1. Si no tiene ninguna etiqueta, elija **Agregar etiquetas**.
1. Si ya tiene etiquetas, elija **Administrar etiquetas** en la sección **Etiquetas**. Aparece una lista de las etiquetas del grupo de modelos como pares clave-valor.
1. En la parte superior de **Agregar nueva etiqueta**, ingrese la nueva clave en el campo **Clave** en blanco.
1. Ingrese el nuevo valor en el campo **Valor** en blanco (opcional).
1. Elija **Confirmar cambios**.
1. Confirme que la nueva etiqueta aparezca en la sección **Etiquetas** de la página **Información**.
**Para eliminar una etiqueta del grupo de modelos, complete los siguientes pasos:**
1. Inicia sesión en Amazon SageMaker Studio Classic. Para obtener más información, consulte [Descripción general del dominio Amazon SageMaker AI](gs-studio-onboard.md).
1. En el panel de navegación izquierdo, elija el icono de **Inicio** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Elija **Modelos** y, a continuación, **Registro de modelos**.
1. En la lista Grupos de modelos, seleccione el nombre del grupo de modelos que desea editar.
1. Elija **Información**.
1. En la sección **Etiquetas**, elija **Administrar etiquetas**. Aparece una lista de las etiquetas del grupo de modelos como pares clave-valor.
1. Elija el icono de **Papelera** situado a la derecha de la etiqueta que desee eliminar.
1. Elija **Confirmar cambios**.
1. Confirme que la etiqueta eliminada no aparezca en la sección **Etiquetas** de la página **Información**.
**Para editar una etiqueta del grupo de modelos, complete los siguientes pasos:**
1. Inicia sesión en Amazon SageMaker Studio Classic. Para obtener más información, consulte [Descripción general del dominio Amazon SageMaker AI](gs-studio-onboard.md).
1. En el panel de navegación izquierdo, elija el icono de **Inicio** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Elija **Modelos** y, a continuación, **Registro de modelos**.
1. En la lista Grupos de modelos, seleccione el nombre del grupo de modelos que desea editar.
1. Elija **Información**.
1. En la sección **Etiquetas**, elija **Administrar etiquetas**. Aparece una lista de las etiquetas del grupo de modelos como pares clave-valor.
1. Edite cualquier clave o valor.
1. Elija **Confirmar cambios**.
1. Confirma que la etiqueta contiene las modificaciones en la sección **Etiquetas** de la página **Información**.
**Para asignar o etiquetar grupos de modelos a un proyecto, siga estos pasos:**
1. Obtenga etiquetas con la clave `sagemaker:project-name` y `sagemaker:project-id` para el proyecto de SageMaker IA mediante la [ListTags](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListTags.html)API.
1. Para aplicar las etiquetas al grupo del paquetes del modelo, elija uno de los siguientes métodos:
+ Si creas un nuevo grupo de paquetes modelo y quieres añadir etiquetas, pasa las etiquetas del paso 1 a la [CreateModelPackageGroup](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackageGroup.html)API.
+ Si desea añadir etiquetas a un grupo de paquetes de modelos existente, utilice el [AddTags](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AddTags.html) APIs.
+ Si crea su grupo de paquetes modelo a través de Pipelines, utilice los `pipeline.upsert()` métodos `pipeline.create()` o o pase las etiquetas al [RegisterModel](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-register-model)paso.
------
# Eliminar una versión del modelo
Este procedimiento muestra cómo eliminar una versión de modelo en la consola de Amazon SageMaker Studio.
## Eliminación de una versión del modelo (Studio o Studio Classic)
Para eliminar una versión modelo en la consola de Amazon SageMaker Studio, complete los siguientes pasos en función de si utiliza Studio o Studio Classic.
------
#### [ Studio ]
1. Abre la consola de SageMaker Studio siguiendo las instrucciones de [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. En el panel de navegación izquierdo, elija **Modelos** para ver una lista de sus grupos de modelos.
1. Seleccione la pestaña **Modelos registrados**, si aún no la ha seleccionado.
1. Justo debajo de la etiqueta de la pestaña **Modelos registrados**, elija **Grupos de modelos**, si aún no lo ha seleccionado.
1. En la lista de grupos de modelos, elija el corchete angular situado a la izquierda del grupo de modelos que desee ver.
1. Aparece una lista de las versiones del modelo del grupo de modelos. Si no ve la versión del modelo que desea eliminar, seleccione **Ver todo**.
1. Seleccione las casillas de verificación situadas junto a las versiones del modelo que desea eliminar.
1. Seleccione los puntos suspensivos verticales situados sobre la esquina superior derecha de la tabla y elija **Eliminar** (o **Eliminar versión del modelo** si se encuentra en la página de detalles del grupo de modelos).
1. En el cuadro de diálogo **Eliminar versión del modelo**, elija **Sí, eliminar versión del modelo**.
1. Elija **Eliminar**.
1. Confirme que las versiones del modelo eliminadas ya no aparecen en el grupo de modelos.
------
#### [ Studio Classic ]
1. Inicia sesión en Amazon SageMaker Studio Classic. Para obtener más información, consulte [Lanzamiento de Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. En el panel de navegación izquierdo, elija el icono de **Inicio** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Elija **Modelos** y, a continuación, **Registro de modelos**. Aparece una lista de sus grupos de modelos.
1. En la lista de grupos de modelos, seleccione el nombre del grupo de modelos de la versión del modelo que desee eliminar.
1. En la lista de versiones del modelo, seleccione el nombre de la versión del modelo que desee eliminar.
1. Seleccione el menú desplegable **Acciones** y, a continuación, elija **Eliminar**.
1. En el cuadro de diálogo de confirmación, ingrese `REMOVE`.
1. Elija **Eliminar **.
1. Confirme que la versión del modelo que ha eliminado no aparece en la lista de versiones del modelo del grupo de modelos.
------
# Constructo por etapas para el ciclo de vida de su modelo
Puede definir una serie de etapas por las que los modelos pueden seguir durante los flujos de trabajo y el ciclo de vida de los modelos con el constructo por etapas de registro de modelos. Esto simplifica el seguimiento y la administración de los modelos a medida que pasan por las etapas de desarrollo, prueba y producción. A continuación, se proporciona información sobre los constructos por etapas y cómo utilizarlos en la gobernanza del modelo.
El constructo por etapas le permite definir una serie de etapas y estados por los que avanzan los modelos. En cada etapa, personas específicas con los permisos pertinentes pueden actualizar el estado de la etapa. A medida que un modelo avanza por las etapas, sus metadatos se transfieren, lo que proporciona una visión completa del ciclo de vida del modelo. Personas autorizadas pueden acceder a estos metadatos y revisarlos en cada etapa, lo que permite tomar decisiones informadas. Esto incluye los siguientes beneficios.
+ Permisos del ciclo de vida del modelo: defina permisos para que las personas designadas actualicen el estado de una fase del modelo y apliquen las puertas de aprobación en los puntos de transición críticos. Los administradores pueden asignar permisos mediante las políticas de IAM y las claves de condición con la API. Por ejemplo, puede impedir que su científico de datos actualice la fase de transición del ciclo de vida del modelo de “desarrollo” a “producción”. Para ver ejemplos, consulte [Ejemplos de configuración del constructo por etapas](model-registry-staging-construct-set-up.md).
+ Modele los eventos del ciclo de vida a través de Amazon EventBridge : puede consumir los eventos de las etapas del ciclo de vida utilizando EventBridge. Esto le permite recibir notificaciones de eventos cuando los modelos cambien de estado de aprobación o de etapa, lo que permite la integración con herramientas de gobernanza de terceros. Consulte [Reciba notificaciones de eventos para ModelLifeCycle](model-registry-staging-construct-event-bridge.md) para ver un ejemplo.
+ Búsqueda basada en los campos del ciclo de vida del modelo: puede buscar y filtrar las etapas y el estado de las etapas mediante la API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Search.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Search.html).
+ Registros de auditoría de los eventos del ciclo de vida del modelo: puede ver el historial de los eventos de aprobación y etapas del modelo y organizar las transiciones del ciclo de vida del modelo.
En los siguientes temas se explica cómo configurar un constructo por etapas desde el lado del administrador y cómo actualizar el estado de una etapa desde el lado del usuario.
**Topics**
+ [Ejemplos de configuración del constructo por etapas](model-registry-staging-construct-set-up.md)
+ [Actualización del estado y la etapa de un paquete modelo en Studio](model-registry-staging-construct-update-studio.md)
+ [Actualización de un ejemplo de estado y etapa de un paquete de modelos (boto3)](model-registry-staging-construct-update-boto3.md)
+ [Invoca ModelLifeCycle usando los ejemplos AWS CLI](model-registry-staging-construct-cli.md)
+ [Reciba notificaciones de eventos para ModelLifeCycle](model-registry-staging-construct-event-bridge.md)
# Ejemplos de configuración del constructo por etapas
Para configurar las construcciones de etapas para su Amazon SageMaker Model Registry, el administrador tendrá que conceder los permisos pertinentes a las funciones previstas. A continuación, se proporcionan ejemplos de cómo configurar constructos por etapas para varios roles.
**nota**
Los usuarios de un dominio de Amazon SageMaker AI podrán ver todas las etapas definidas en el dominio, pero solo podrán usar aquellas para las que tengan permisos.
Las etapas se definen con el parámetro `ModelLifeCycle` y tienen la siguiente estructura. El administrador configura los permisos para que los roles puedan acceder a `stage` y `stageStatus`. Los usuarios que asuman un rol pueden usar los `stage` y `stageStatus` correspondientes e incluir su propia `stageDescription`.
```
ModelLifeCycle {
stage: String # Required (e.g., Development/QA/Production)
stageStatus: String # Required (e.g., PendingApproval/Approved/Rejected)
stageDescription: String # Optional
}
```
La siguiente tabla contiene las plantillas de constructo por etapas predefinidas del registro de modelos. Puede definir sus propios constructos por etapas en función de sus casos de uso. Deberá configurar los permisos necesarios antes de que los usuarios puedan usarlos.
| Etapa | Estado de la etapa |
| --- | --- |
| Propuesta | PendingApproval |
| Desarrollo | InProgress |
| QA | OnHold |
| PreProduction | Approved |
| Producción | Rechazada |
| Archived | Retired |
El `ModelLifeCycle` parámetro se puede invocar de la siguiente manera APIs:
+ [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 ]
El siguiente es un ejemplo de política de IAM que utiliza claves de condición del ciclo de vida del modelo. Puede modificarlos en función de sus propios requisitos. En este ejemplo, los permisos del rol se limitan a establecer o definir la etapa del ciclo de vida del modelo para:
+ Crear o actualizar un modelo con la etapa `"Development"` y el estado `"Approved"`.
+ Actualizar un paquete de modelos con el control de calidad de las etapas,`"QA"`, y el estado `"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 ]
El siguiente es un ejemplo de política de IAM que utiliza claves de condición del ciclo de vida del modelo. Puede modificarlos en función de sus propios requisitos. En este ejemplo, los permisos del rol se limitan a establecer o definir la etapa del ciclo de vida del modelo para:
+ Actualizar un paquete de modelos con:
+ La etapa `"QA"` y el estado `"Approved"` o `"Rejected"`.
+ La etapa `"Production"` y el estado `"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 ]
El siguiente es un ejemplo de política de IAM que utiliza claves de condición del ciclo de vida del modelo. Puede modificarlos en función de sus propios requisitos. En este ejemplo, los permisos del rol se limitan a establecer o definir la etapa del ciclo de vida del modelo para:
+ Actualizar un paquete de modelos con:
+ La etapa `"Production"` y el estado `"Approved"` o `"Rejected"`.
+ La etapa `"Development"` y el estado `"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 recibir EventBridge notificaciones de Amazon sobre cualquier actualización del estado de un modelo, consulta el ejemplo de[Reciba notificaciones de eventos para ModelLifeCycle](model-registry-staging-construct-event-bridge.md). Para ver un ejemplo de la EventBridge carga útil que podrías recibir, consulta[SageMaker cambio de estado del paquete modelo](automating-sagemaker-with-eventbridge.md#eventbridge-model-package).
# Actualización del estado y la etapa de un paquete modelo en Studio
Para utilizar un constructo por etapas de paquete de modelos, tendrá que asumir una rol de ejecución con los permisos correspondientes. En la página siguiente se proporciona información sobre cómo actualizar el estado del escenario con Amazon SageMaker Studio.
Todos los usuarios podrán ver todos los constructos por etapas definidos en el dominio. Para actualizar una etapa, necesitará que el administrador configure los permisos pertinentes para que pueda acceder a ella. Para obtener más información sobre cómo, consulte [Ejemplos de configuración del constructo por etapas](model-registry-staging-construct-set-up.md).
El siguiente procedimiento lo lleva a la interfaz de usuario de Studio, donde podrá actualizar la etapa del paquete de modelos.
1. Inicia sesión en Amazon SageMaker Studio. Para obtener más información, consulte [Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. En el panel de navegación izquierdo, elija **Modelos**.
1. Busque su modelo.
+ Puede usar las pestañas para buscar sus modelos. Por ejemplo, elija las pestañas **Modelos registrados** o **Modelos implementables**.
+ Puede usar las opciones **Mis modelos** y **Compartido conmigo** para buscar los modelos que ha creado o los que ha compartido.
1. Seleccione la casilla situada junto al modelo que desee actualizar.
1. Seleccione el icono **Más opciones**.
1. Seleccione **Actualizar el ciclo de vida del modelo**. Esto le llevará a la sección **Actualizar el ciclo de vida del modelo**.
1. Complete las tareas para actualizar la etapa.
Si no puede actualizar la etapa, recibirá un mensaje de error. El administrador tendrá que configurar los permisos para que pueda hacerlo. Para obtener más información sobre cómo configurar los permisos, consulte [Ejemplos de configuración del constructo por etapas](model-registry-staging-construct-set-up.md).
# Actualización de un ejemplo de estado y etapa de un paquete de modelos (boto3)
Para actualizar el estado y la etapa de un paquete de modelos, tendrá que asumir un rol de ejecución con los permisos correspondientes. A continuación se proporciona un ejemplo de cómo se puede actualizar el estado de la etapa mediante la API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateModelPackage.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateModelPackage.html) usando AWS SDK para Python (Boto3).
En este ejemplo, se han concedido las claves de condición de la etapa `"Development"` y el estado de la etapa `"Approved"` de `ModelLifeCycle` para la acción de la API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateModelPackage.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateModelPackage.html) a su rol de ejecución. Puede incluir una descripción en `stage-description`. Para obtener más información, consulte [Ejemplos de configuración del constructo por etapas](model-registry-staging-construct-set-up.md).
```
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)
```
# Invoca ModelLifeCycle usando los ejemplos AWS CLI
Puede utilizar la AWS CLI herramienta para gestionar sus AWS recursos. Algunos comandos AWS CLI son [search](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/cloudsearchdomain/search.html) y [list-actions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/fis/list-actions.html). En la página siguiente se proporcionan ejemplos de cómo utilizar `ModelPackage` mientras se utilizan estos comandos. Para obtener más información y ejemplos sobre cómo configurar el constructo por etapas, consulte [Ejemplos de configuración del constructo por etapas](model-registry-staging-construct-set-up.md).
En los ejemplos de esta página se utilizan las siguientes variables.
+ `region` es la región en la que existe su paquete de modelos.
+ `stage-name` es el nombre de la etapa definida.
+ `stage-status` es el nombre del estado de la etapa definida.
Los siguientes son ejemplos de AWS CLI comandos que utilizan ModelLifeCycle.
Busque sus paquetes de modelos con una *stage-name* que ya haya definido.
```
aws sagemaker search --region 'region' --resource ModelPackage --search-expression '{"Filters": [{"Name": "ModelLifeCycle.Stage","Value": "stage-name"}]}'
```
Enumere las acciones asociadas a `ModelLifeCycle`.
```
aws sagemaker list-actions --region 'region' --action-type ModelLifeCycle
```
Cree un paquete modelo con 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"}'
```
Actualice un paquete modelo con ModelLifeCycle.
```
aws sagemaker update-model-package --model-package 'model-package-arn' --region 'region' --model-life-cycle '{"Stage":"stage-name", "StageStatus":"stage-status"}'
```
Busca a través del ModelLifeCycle campo.
```
aws sagemaker search --region 'region' --resource ModelPackage --search-expression '{"Filters": [{"Name": "ModelLifeCycle.Stage","Value": "stage-name"}]}'
```
Obtenga los registros de auditoría para obtener ModelLifeField actualizaciones a través de [Seguimiento del linaje de Amazon SageMaker 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'
```
# Reciba notificaciones de eventos para ModelLifeCycle
Puedes recibir las notificaciones y los eventos de ModelLifeCycle actualización EventBridge en tu cuenta. El siguiente es un ejemplo de una EventBridge regla que debe configurarse en su cuenta para recibir las notificaciones de ModelLifeCycle eventos.
```
{
"source": ["aws.sagemaker"],
"detail-type": ["SageMaker Model Package State Change"]
}
```
Para ver un ejemplo de la EventBridge carga útil que puede recibir, consulte[SageMaker cambio de estado del paquete modelo](automating-sagemaker-with-eventbridge.md#eventbridge-model-package).
# Actualizar el estado de aprobación de un modelo
Después de crear una versión del modelo, normalmente es buena idea evaluar su rendimiento antes de implementarla en un punto de conexión de producción. Si cumple con sus requisitos, puede actualizar el estado de aprobación de la versión del modelo a `Approved`. Si se establece el estado en, `Approved` se puede iniciar la CI/CD implementación del modelo. Si la versión del modelo no cumple con sus requisitos, puede actualizar el estado de aprobación a `Rejected`.
Puede actualizar manualmente el estado de aprobación de una versión del modelo después de registrarla, o puede crear un paso previo para evaluar el modelo al crear una canalización de SageMaker IA. Para obtener información sobre cómo crear un paso de condición en una canalización de SageMaker IA, consulte[Pasos de canalizaciones](build-and-manage-steps.md).
Cuando utilizas una de las plantillas de proyecto proporcionadas por la SageMaker IA y el estado de aprobación de una versión del modelo cambia, se produce la siguiente acción. Solo se muestran las transiciones válidas.
+ `PendingManualApproval`to`Approved`: inicia el CI/CD despliegue de la versión del modelo aprobada
+ `PendingManualApproval` a `Rejected`: no hay ninguna acción
+ `Rejected` a `Approved`: inicia la implementación de CI/CD para la versión del modelo aprobada
+ `Approved`to`Rejected`: inicia la implementación CI/CD de la última versión del modelo con un estado `Approved`
Puede actualizar el estado de aprobación de una versión modelo mediante la consola Amazon SageMaker Studio AWS SDK para Python (Boto3) o desde la consola. También puedes actualizar el estado de aprobación de una versión del modelo como parte de un paso previo en un proceso de SageMaker IA. Para obtener información sobre el uso de un paso de aprobación de modelos en una canalización de SageMaker IA, consulte[Información general de canalizaciones](pipelines-overview.md).
## Actualizar el estado de aprobación de un modelo (Boto3)
Cuando creó la versión del modelo en [Registro de una versión del modelo](model-registry-version.md), configuró `ModelApprovalStatus` en `PendingManualApproval`. Para actualizar el estado de aprobación del modelo, llamea `update_model_package`. Tenga en cuenta que para automatizar este proceso puede escribir un código que, por ejemplo, establezca el estado de aprobación de un modelo en función del resultado de la evaluación de alguna medida del rendimiento del modelo. También puede crear un paso en una canalización que implemente automáticamente una nueva versión del modelo cuando se apruebe. En el siguiente fragmento de código se muestra cómo cambiar manualmente el estado de aprobación a `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)
```
## Actualización del estado de aprobación de un modelo (Studio o Studio Classic)
Para cambiar manualmente el estado de aprobación en la consola de Amazon SageMaker Studio, complete los siguientes pasos en función de si utiliza Studio o Studio Classic.
------
#### [ Studio ]
1. Abre la consola de SageMaker Studio siguiendo las instrucciones de [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. En el panel de navegación izquierdo, elija **Modelos** para ver una lista de sus grupos de modelos.
1. Seleccione la pestaña **Modelos registrados**, si aún no la ha seleccionado.
1. Justo debajo de la etiqueta de la pestaña **Modelos registrados**, elija **Grupos de modelos**, si aún no lo ha seleccionado.
1. En la lista de grupos de modelos, elija el corchete angular situado a la izquierda del grupo de modelos que desee ver.
1. Aparece una lista de las versiones del modelo del grupo de modelos. Si no ve la versión del modelo que desea eliminar, seleccione **Ver todo** para ver la lista completa de versiones del modelo en la página de detalles del grupo de modelos.
1. Seleccione el nombre de la versión del modelo que desea actualizar.
1. La pestaña **Implementar** muestra el estado de aprobación actual. Elija el menú desplegable situado junto al estado de aprobación actual y seleccione el estado de aprobación actualizado.
------
#### [ Studio Classic ]
1. Inicia sesión en Amazon SageMaker Studio Classic. Para obtener más información, consulte [Lanzamiento de Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. En el panel de navegación izquierdo, elija el icono de **Inicio** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Elija **Modelos** y, a continuación, **Registro de modelos**.
1. En la lista de grupos de modelos, seleccione el nombre del grupo de modelos que desea ver. Se abre una nueva pestaña con una lista de las versiones del modelo del grupo de modelos.
1. En la lista de versiones del modelo, seleccione el nombre de la versión del modelo que desee actualizar.
1. En el menú desplegable **Acciones**, puede elegir una de las dos opciones de menú posibles para actualizar el estado de la versión del modelo.
+ Mediante la opción **Actualizar estado**
1. En el menú desplegable **Acciones**, elija el menú desplegable **Actualizar estado** y elija el estado de la nueva versión del modelo.
1. En el campo **Comentario**, agregue detalles adicionales (opcional).
1. Elija **Guardar y actualizar**.
+ Uso de la opción **Editar**
1. En el menú desplegable **Acciones**, elija **Editar**.
1. En el campo **Comentario**, agregue detalles adicionales (opcional).
1. Seleccione **Save changes (Guardar cambios)**.
1. Confirme que el estado de la versión del modelo esté actualizado al valor correcto en la página de la versión del modelo.
------
`us-east-1`En `us-west-2` el caso de `eu-west-1` las versiones de modelos registradas y registradas, puede utilizar las siguientes instrucciones para acceder a los detalles del linaje de las versiones de modelos registradas y registradas: `ap-northeast-1`
1. Abre la consola de SageMaker Studio siguiendo las instrucciones de [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. Seleccione **Modelos** en el panel de navegación izquierdo.
1. Selecciona la pestaña **Modelos** registrados, si aún no la has seleccionado, y selecciona **Modelos registrados**.
1. Seleccione un modelo y elija **Ver la última versión**.
1. Seleccione la pestaña **Gobernanza**.
1. La sección **Despliegue** de **la descripción general de la gobernanza** muestra el estado de aprobación actual. Seleccione el estado de aprobación actualizado en el menú desplegable.
# Implementación de un modelo desde el registro con Python
Después de registrar una versión del modelo y aprobar su implementación, impleméntela en un punto final de SageMaker IA para realizar inferencias en tiempo real. Puede implementar su modelo mediante el SDK de SageMaker IA o el AWS SDK para Python (Boto3).
Al crear un proyecto de operaciones de aprendizaje automático (MLOps) y elegir una plantilla de MLOps proyecto que incluya la implementación del modelo, las versiones del modelo aprobadas en el registro de modelos se implementan automáticamente en la producción. Para obtener información sobre el uso de MLOps proyectos de SageMaker IA, consulte[MLOps Automatización con SageMaker proyectos](sagemaker-projects.md).
También puede habilitar una AWS cuenta para implementar versiones de modelos que se crearon en otra cuenta añadiendo una política de recursos multicuenta. Por ejemplo, un equipo de su organización puede ser responsable del entrenamiento de los modelos y otro equipo se encarga de implementar y actualizar los modelos.
**Topics**
+ [Implemente un modelo desde el registro (SageMaker SDK)](#model-registry-deploy-smsdk)
+ [Implementar un modelo desde el registro (Boto3)](#model-registry-deploy-api)
+ [Implementar una versión del modelo desde una cuenta diferente](#model-registry-deploy-xaccount)
## Implemente un modelo desde el registro (SageMaker SDK)
Para implementar una versión de modelo mediante el [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable), utilice el siguiente fragmento 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')
```
## Implementar un modelo desde el registro (Boto3)
Para implementar una versión de modelo mediante el AWS SDK para Python (Boto3), complete los siguientes pasos:
1. El siguiente fragmento de código supone que ya ha creado el cliente SageMaker AI Boto3 `sm_client` y una versión del modelo cuyo ARN está almacenado en la variable. `model_version_arn`
Cree un objeto del modelo a partir de la versión del modelo llamando a la operación de la API [create\$1model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model). Pase el nombre de recurso de Amazon (ARN) de la versión del modelo como parte de los `Containers` del objeto del 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. Cree una configuración de punto de conexión llamando a `create_endpoint_config`. La configuración del punto de conexión especifica el número y el tipo de instancias de Amazon EC2 que se van a utilizar para el punto de conexión.
```
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. Cree el punto de conexión llamando a `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'])
```
## Implementar una versión del modelo desde una cuenta diferente
Puedes permitir que una AWS cuenta implemente versiones de modelos que se crearon en otra cuenta añadiendo una política de recursos multicuenta. Por ejemplo, un equipo de su organización puede ser responsable del entrenamiento de los modelos y otro equipo se encarga de implementar y actualizar los modelos. Al crear estas políticas de recursos, se aplica la política al recurso concreto al que se quiere conceder acceso. *Para obtener más información sobre las políticas de recursos multicuentas AWS, consulte la [Lógica de evaluación de políticas multicuentas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html) en la Guía del AWS Identity and Access Management usuario.*
**nota**
Debe usar una clave de KMS para cifrar la acción de [configuración de los datos de salida](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_OutputDataConfig.html) durante el entrenamiento para la implementación de un modelo entre cuentas.
Para habilitar el despliegue del modelo multicuenta en la SageMaker IA, debe proporcionar una política de recursos multicuenta para el grupo de modelos que contenga las versiones del modelo que desee implementar, el repositorio de Amazon ECR donde reside la imagen de inferencia del grupo de modelos y el depósito de Amazon S3 donde se almacenan las versiones del modelo.
Para poder implementar un modelo que se creó en una cuenta diferente, debes tener un rol que tenga acceso a las acciones de SageMaker IA, como un rol con la política `AmazonSageMakerFullAccess` administrada. Para obtener información sobre las políticas gestionadas de SageMaker IA, consulte[AWS políticas gestionadas para Amazon SageMaker AI](security-iam-awsmanpol.md).
El siguiente ejemplo crea políticas entre cuentas para estos tres recursos y aplica las políticas a los recursos. En el ejemplo también se asume que ha definido previamente las siguientes variables:
+ `bucket`: el bucket de Amazon S3 donde se almacenan las versiones del modelo.
+ `kms_key_id`: la clave de KMS utilizada para cifrar el resultado del entrenamiento.
+ `sm_client`— Un cliente Boto3 de SageMaker AI.
+ `model_package_group_name`: el grupo de modelos al que desea conceder acceso entre cuentas.
+ `model_package_group_arn`: el ARN del grupo de modelos al que desea conceder acceso entre cuentas.
```
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.")
```
# Implementación de un modelo en Studio
Después de registrar una versión del modelo y aprobarla para su implementación, impleméntela en un punto final de Amazon SageMaker AI para obtener inferencias en tiempo real. Puede implementar [Implementación de un modelo desde el registro con Python](model-registry-deploy.md) o implementar su modelo en Amazon SageMaker Studio. A continuación, se proporcionan instrucciones sobre cómo implementar el modelo en Studio.
Esta función no está disponible en Amazon SageMaker Studio Classic.
+ Si Studio es su experiencia predeterminada, la interfaz de usuario es similar a las imágenes que se encuentran en [Descripción general de la interfaz de usuario de Amazon SageMaker Studio](studio-updated-ui.md).
+ Si su experiencia predeterminada es Studio Classic, la interfaz de usuario es similar a las imágenes que aparecen en [Descripción general de la interfaz de usuario clásica de Amazon SageMaker Studio](studio-ui.md).
Para poder implementar un paquete de modelos, deben cumplirse los siguientes requisitos para el paquete del modelo:
+ Hay disponible una especificación de inferencia válida. Para obtener más información, consulte [InferenceSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-InferenceSpecification).
+ Modelo con estado aprobado. Para obtener más información, consulte [Actualizar el estado de aprobación de un modelo](model-registry-approve.md).
A continuación, se proporcionan instrucciones sobre cómo implementar un modelo en Studio.
**Implementación de un modelo en Studio**
1. Abra la consola de Studio siguiendo las instrucciones de [Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. Seleccione **Modelos** en el panel de navegación izquierdo.
1. Seleccione la pestaña **Modelos registrados**, si aún no la ha seleccionado.
1. Justo debajo de la etiqueta de la pestaña **Modelos registrados**, elija **Grupos de modelos**, si aún no lo ha seleccionado.
1. (Opcional) Si tiene modelos que han compartido con usted, puede elegir entre **Mis modelos** o **Compartidos conmigo**.
1. Seleccione las casillas de verificación de los modelos registrados. Si se cumplen los requisitos anteriores, podrá elegir el botón **Implementar**.
1. Elija **Implementar** para abrir la página **Implementar modelo en punto de conexión**.
1. Configure los recursos de implementación en **Configuración del punto de conexión**.
1. Una vez que haya verificado la configuración, elija **Implementar**. A continuación, el modelo se implementará en el punto de conexión con el estado **En servicio**.
Para`us-east-1`, `us-west-2``ap-northeast-1`, y `eu-west-1` regiones, puede usar las siguientes instrucciones para implementar modelos:
**Implementación de un modelo en Studio**
1. Abra la consola de Studio siguiendo las instrucciones de [Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. Seleccione **Modelos** en el panel de navegación izquierdo.
1. Seleccione la pestaña **Mis modelos**.
1. Seleccione la pestaña **Modelos** registrados, si aún no la ha seleccionado.
1. Seleccione un modelo y elija **Ver la última versión**.
1. Elija **Deploy** y seleccione entre SageMaker AI o Amazon Bedrock.
1. Una vez que haya verificado la configuración, elija **Implementar**. A continuación, el modelo se implementará en el punto de conexión con el estado **En servicio**.
# Capacidad de detección entre cuentas
Al explorar y acceder a los grupos de paquetes del modelo registrados en otras cuentas, los científicos e ingenieros de datos pueden fomentar la coherencia de datos, agilizar la colaboración y reducir la duplicación de esfuerzos. Con Amazon SageMaker Model Registry, puede compartir grupos de paquetes de modelos entre cuentas. Hay dos categorías de permisos asociados al uso compartido de recursos:
+ **Capacidad de detección**: la *capacidad de detección* es la capacidad de la cuenta consumidora de recursos para ver los grupos de paquetes del modelo compartidos por una o más cuentas de propietarios de recursos. La capacidad de detección solo es posible si el propietario del recurso asocia las políticas de recursos necesarias a los grupos de paquetes del modelo compartidos. El consumidor de recursos puede ver todos los grupos de paquetes de modelos compartidos en la AWS RAM interfaz de usuario y AWS CLI.
+ **Accesibilidad**: la *accesibilidad* es la capacidad de la cuenta consumidora de recursos para utilizar los grupos de paquetes del modelo compartido. Por ejemplo, el consumidor de recursos puede registrar o implementar un paquete del modelo desde una cuenta diferente si tiene los permisos necesarios.
**Topics**
+ [Uso compartido del grupo de modelos en Studio](model-registry-ram-studio-share.md)
+ [Visualización de los grupos de modelos compartidos en Studio](model-registry-ram-studio-view.md)
+ [Accesibilidad](model-registry-ram-accessibility.md)
+ [Configuración de la capacidad de detección](model-registry-ram-discover.md)
+ [Visualización grupos de paquetes de modelos compartidos](model-registry-ram-view-shared.md)
+ [Anulación de la asociación de entidades principales de un recurso compartido y eliminación de un recurso compartido](model-registry-ram-dissociate.md)
+ [Promoción del uso compartido de permisos y recursos](model-registry-ram-promote.md)
# Uso compartido del grupo de modelos en Studio
Puede compartir sus grupos de modelos con otros AWS directores (Cuentas de AWS o AWS Organizations) mediante la interfaz de usuario de Studio. Este proceso de uso compartido simplificado permite la colaboración entre equipos, fomenta las prácticas recomendadas y facilita la reutilización de modelos entre todos los equipos. A continuación, se proporcionan instrucciones sobre cómo compartir grupos de modelos en Studio.
Esta función no está disponible en Amazon SageMaker Studio Classic.
+ Si Studio es su experiencia predeterminada, la interfaz de usuario es similar a las imágenes que se encuentran en [Descripción general de la interfaz de usuario de Amazon SageMaker Studio](studio-updated-ui.md).
+ Si su experiencia predeterminada es Studio Classic, la interfaz de usuario es similar a las imágenes que aparecen en [Descripción general de la interfaz de usuario clásica de Amazon SageMaker Studio](studio-ui.md).
Para compartir grupos de modelos, primero tendrá que asegurarse de que el siguiente permiso se ha añadido al rol de ejecución desde el que comparte los recursos.
1. [Obtenga el rol de ejecución](sagemaker-roles.md#sagemaker-roles-get-execution-role).
1. [Actualice los permisos del rol](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_update-role-permissions.html) con lo siguiente:
------
#### [ 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 continuación, se proporcionan instrucciones sobre cómo compartir un grupo de modelos con otras entidades principales de AWS .
**Para compartir un grupo de modelos con otros AWS directores**
1. Abra la consola de Studio siguiendo las instrucciones de [Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. Seleccione **Modelos** en el panel de navegación izquierdo.
1. Seleccione la pestaña **Modelos registrados**, si aún no la ha seleccionado.
1. Justo debajo de la etiqueta de la pestaña **Modelos registrados**, elija **Grupos de modelos**, si aún no lo ha seleccionado.
1. Seleccione un modelo registrado.
1. En la esquina superior derecha, elija **Compartir**. Se abrirá la sección **Compartir grupo de modelos**.
Si aparece un mensaje de error en la parte inferior de la pantalla, tendrá que añadir los permisos adecuados a su rol de ejecución. Para obtener más información, vea los permisos anteriores.
1. En **Recursos compartidos**, seleccione un recurso compartido para actualizar o crear uno nuevo.
1. En **Permiso administrado**, elija un permiso administrado para controlar el nivel de acceso de su modelo.
Las opciones visibles incluyen los permisos que ya se han creado para usted o sus permisos personalizados en AWS RAM. Consulte [Crear y usar permisos administrados por el cliente](https://docs.aws.amazon.com/ram/latest/userguide/create-customer-managed-permissions.html) en la Guía del usuario de *AWS Resource Access Manager*.
1. **En **AWS Principios,** introduce el AWS Organizations ARN Cuenta de AWS IDs con el que deseas compartir y, a continuación, selecciona Agregar.** Puede añadir varios AWS principales de esta manera.
1. Cuando se cumplen los requisitos mínimos, se puede acceder al botón **Compartir**. Una vez que haya verificado la configuración, elija **Compartir**.
Si lo comparte correctamente, aparecerá un mensaje en un banner verde en la parte inferior de la pantalla.
# Visualización de los grupos de modelos compartidos en Studio
Puede ver los grupos de modelos que se comparten con usted o una cuenta que pertenezca al mismo AWS Organizations. Si un grupo de modelos se comparte con una cuenta que pertenezca al mismo AWS Organizations, el grupo de modelos compartido se aprobará automáticamente y estará disponible para su visualización en Studio. De lo contrario, tendrá que aprobar la invitación pendiente para poder ver el grupo de modelos compartido en Studio. A continuación, se proporcionan instrucciones sobre cómo ver los grupos de modelos compartidos y cómo aceptar las invitaciones para compartir grupos de modelos en Studio.
Esta función no está disponible en Amazon SageMaker Studio Classic.
+ Si Studio es su experiencia predeterminada, la interfaz de usuario es similar a las imágenes que se encuentran en [Descripción general de la interfaz de usuario de Amazon SageMaker Studio](studio-updated-ui.md).
+ Si su experiencia predeterminada es Studio Classic, la interfaz de usuario es similar a las imágenes que aparecen en [Descripción general de la interfaz de usuario clásica de Amazon SageMaker Studio](studio-ui.md).
A continuación, se proporcionan instrucciones sobre cómo ver y aceptar los grupos de modelos que se han compartido con usted.
**Visualización y aceptación de grupos de modelos que se han compartido con usted**
1. Abra la consola de Studio siguiendo las instrucciones de [Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. Seleccione **Modelos** en el panel de navegación izquierdo.
1. Seleccione la pestaña **Modelos registrados**, si aún no la ha seleccionado.
1. Justo debajo de la etiqueta de la pestaña **Modelos registrados**, elija **Grupos de modelos**, si aún no lo ha seleccionado.
1. Seleccione **Compartido conmigo** para ver los grupos de modelos que se comparten con usted.
1. Para aceptar las invitaciones pendientes a grupos de modelos:
1. Seleccione **Ver las aprobaciones pendientes** para abrir la lista **Invitaciones pendientes**.
1. Si quiere aceptar la invitación, seleccione **Aceptar**.
# Accesibilidad
Si el consumidor de recursos tiene permisos de acceso para usar un grupo de paquetes de modelos compartido, puede registrar o implementar una versión del grupo de paquetes de modelos. Para obtener más información sobre cómo el consumidor de recursos puede registrar un grupo de paquetes de modelos compartidos, consulte [Registrar una versión del modelo desde una cuenta diferente](model-registry-version.md#model-registry-version-xaccount). Para obtener más información sobre cómo el consumidor de recursos puede implementar un grupo de paquetes de modelos compartidos, consulte [Implementar una versión del modelo desde una cuenta diferente](model-registry-deploy.md#model-registry-deploy-xaccount).
# Configuración de la capacidad de detección
El propietario del recurso puede configurar la capacidad de detección de grupos de paquetes del modelo creando recursos compartidos y asociando políticas de recursos a las entidades. Para ver los pasos detallados sobre cómo crear un recurso compartido general en AWS RAM, consulte [Crear un recurso compartido](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-sharing.html#getting-started-sharing-create) en la [AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html)documentación.
Complete las siguientes instrucciones para configurar la capacidad de detección de grupos de paquetes modelo mediante la AWS RAM consola o la política APIs de recursos de Model Registry.
------
#### [ AWS CLI ]
1. Cree un recurso compartido en la cuenta del propietario del modelo.
1. El propietario del modelo adjunta una política de recursos al grupo de paquetes del modelo mediante la API [put-model-package-group-policy](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/put-model-package-group-policy.html) de políticas de recursos de SageMaker IA, como se muestra en el siguiente comando.
```
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**
Se pueden asociar diferentes combinaciones de acciones a la política de recursos. En el caso de políticas personalizadas, el propietario del grupo de paquetes modelo debe promocionar el permiso creado y solo se pueden detectar las entidades que tengan los permisos promocionados asociados. Los recursos compartidos que no se pueden promocionar no se pueden detectar ni administrar a través de AWS RAM.
1. Para comprobar que AWS RAM se creó el ARN del recurso compartido, utilice el siguiente comando:
```
aws ram get-resource-share-associations --association-type resource --resource-arn
```
La respuesta contiene el de *resource-share-arn* la entidad.
1. Para comprobar si el permiso de política asociado es una política administrada o personalizada, utilice el siguiente comando:
```
aws ram list-resource-share-permissions --resource-share-arn
```
El campo `featureSet` puede tomar los valores `CREATED_FROM_POLICY` o `STANDARD`, que se definen de la siguiente manera:
+ `STANDARD`: el permiso ya existe.
+ `CREATED_FROM_POLICY`: el permiso debe promocionarse para que la entidad pueda detectarse. Para obtener más información, consulte [Promoción del uso compartido de permisos y recursos](model-registry-ram-promote.md).
1. Acepte la invitación para compartir recursos en la cuenta de consumidor del modelo.
1. El consumidor del grupo de paquetes del modelo acepta la invitación a compartir recursos. Para ver todas las invitaciones a los recursos, ejecute el siguiente comando:
```
aws ram get-resource-share-invitations
```
Identifique las solicitudes que tienen estado `PENDING` e incluya el ID de la cuenta propietaria.
1. Para aceptar la invitación a compartir recursos del propietario del modelo, utilice el siguiente comando:
```
aws ram accept-resource-share-invitation --resource-share-invitation-arn
```
------
#### [ AWS RAM console ]
1. Inicie sesión en la [consola de AWS RAM](https://console.aws.amazon.com/ram/home).
1. Realice los pasos siguientes para crear un recurso compartido a partir de la cuenta propietaria del grupo de paquetes del modelo.
1. Realice los siguientes pasos para especificar los detalles del recurso compartido.
1. En el campo **Nombre**, añada un nombre único para el recurso.
1. En la tarjeta **Resources**, selecciona el menú desplegable y selecciona **SageMaker AI Model Package Groups**.
1. Seleccione la casilla de verificación del ARN del recurso compartido de recursos del grupo de paquetes del modelo.
1. En la tarjeta **Seleccionar recursos**, active la casilla de verificación del recurso compartido del grupo del paquete del modelo.
1. En la tarjeta **Etiquetas**, añada pares clave-valor para las etiquetas que desee añadir a su recurso compartido.
1. Elija **Siguiente**.
1. Realice los siguientes pasos para asociar permisos administrados al recurso compartido.
1. Si usa un permiso administrado, elija un permiso administrado en el menú desplegable **Permisos administrados**.
1. Si utiliza un permiso personalizado, seleccione **Permiso administrado por el cliente**. En este caso, el grupo de paquetes del modelo no se puede detectar inmediatamente. Debe promocionar el permiso y la política de recursos después de crear el recurso compartido. Para obtener más información sobre cómo promocionar permisos y recursos compartidos, consulte [Promoción del uso compartido de permisos y recursos](model-registry-ram-promote.md). Para obtener más información sobre cómo asociar permisos personalizados, consulte [Crear y usar permisos administrados por el cliente en AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/create-customer-managed-permissions.html).
1. Elija **Siguiente**.
1. Realice los siguientes pasos para permitir el acceso a las entidades principales.
1. Seleccione **Permitir compartir con cualquier persona** para permitir compartir con cuentas ajenas a su organización o seleccione **Permitir compartir solo dentro de su organización**.
1. En el menú desplegable **Seleccione tipo de entidad principal**, añada los tipos de entidades principales y el ID de las entidades principales que desee añadir.
1. Añada y seleccione las entidades principales elegidas para el recurso compartido.
1. Elija **Siguiente**.
1. Revise la configuración del recurso compartido que se muestra y, a continuación, seleccione **Crear recurso compartido**.
1. Acepte la invitación para compartir recursos desde la cuenta de consumidor. Una vez que el propietario del modelo crea las asociaciones de recurso compartido y entidad principal, las cuentas consumidoras de recursos especificadas reciben una invitación para unirse al recurso compartido. Las cuentas consumidoras de recursos pueden ver y aceptar las invitaciones en la página [Compartido conmigo: recursos compartidos](https://console.aws.amazon.com/ram/home#SharedResourceShares:) en la consola de AWS RAM . Para obtener más información sobre cómo aceptar y ver los recursos en AWS RAM, consulte [Acceder a AWS los recursos que se comparten con usted](https://docs.aws.amazon.com//ram/latest/userguide/working-with-shared.html).
------
# Visualización grupos de paquetes de modelos compartidos
Una vez que el propietario del recurso complete los pasos anteriores para crear un recurso compartido y el consumidor acepte la invitación para compartirlo, el consumidor podrá ver los grupos de paquetes del modelo compartido mediante la consola AWS CLI o en la AWS RAM consola.
## AWS CLI
Para ver grupos de paquetes de modelos compartidos, utilice el siguiente comando en la cuenta del consumidor del modelo:
```
aws sagemaker list-model-package-groups --cross-account-filter-option CrossAccount
```
## AWS RAM consola
En la AWS RAM consola, el propietario del recurso y el consumidor pueden ver los grupos de paquetes de modelos compartidos. El propietario del recurso puede ver los grupos de paquetes del modelo compartidos con el consumidor siguiendo los pasos que se indican en [Ver los recursos compartidos que ha creado en AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/working-with-sharing-view-rs.html). El consumidor de recursos puede ver los grupos de paquetes del modelo compartidos por el propietario siguiendo los pasos indicados en [Ver los recursos compartidos que se comparten con usted](https://docs.aws.amazon.com/ram/latest/userguide/working-with-shared-view-rs.html).
# Anulación de la asociación de entidades principales de un recurso compartido y eliminación de un recurso compartido
El propietario del recurso puede disociar los principales del recurso compartido para obtener un conjunto de permisos o eliminar todo el recurso compartido mediante la consola AWS CLI o la consola. AWS RAM Para obtener más información sobre cómo anular la asociación de entidades principales de un recurso compartido, consulte [Update a Resource Share](https://docs.aws.amazon.com/ram/latest/userguide/working-with-sharing-update.html) en la documentación de [AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html). Para obtener más información sobre cómo eliminar un recurso compartido, consulte [Eliminar un recurso compartido](https://docs.aws.amazon.com/ram/latest/userguide/working-with-sharing-delete.html) en la documentación de [AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html).
## AWS CLI
Para disociar los principios de un recurso compartido, utilice el comando [dissociate-resource-share](https://docs.aws.amazon.com/cli/latest/reference/ram/disassociate-resource-share.html)de la siguiente manera:
```
aws ram disassociate-resource-share --resource-share-arn --principals
```
Para eliminar un recurso compartido, utilice el comando [delete-resource-share](https://docs.aws.amazon.com/cli/latest/reference/ram/delete-resource-share.html)de la siguiente manera:
```
aws ram delete-resource-share --resource-share-arn
```
## AWS RAM consola
Para obtener más información sobre cómo anular la asociación de entidades principales de un recurso compartido, consulte [Update a Resource Share](https://docs.aws.amazon.com/ram/latest/userguide/working-with-sharing-update.html) en la documentación de [AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html). Para obtener más información sobre cómo eliminar un recurso compartido, consulte [Deleting a resource share](https://docs.aws.amazon.com/ram/latest/userguide/working-with-sharing-delete.html) en la documentación de [AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html).
# Promoción del uso compartido de permisos y recursos
Si utiliza permisos personalizados (administrados por el cliente), debe promocionar el permiso y el recurso compartido asociado para que el grupo de paquetes del modelo sea visible. Realice estos pasos para promocionar el permiso y el recurso compartido.
1. Para promover el acceso a su permiso personalizado AWS RAM, utilice el siguiente comando:
```
aws ram promote-permission-created-from-policy —permission-arn
```
1. Promocione el recurso compartido mediante el siguiente comando:
```
aws ram promote-resource-share-created-from-policy --resource-share-arn
```
Si ve el error `OperationNotPermittedException` al realizar los pasos anteriores, eso significa que la entidad no se puede detectar, pero sí se puede acceder a ella. Por ejemplo, si el propietario del recurso asocia una política de recursos con una entidad principal de rol de asunción como `“Principal”: {“AWS”: “arn:aws:iam::3333333333:role/Role-1”}`, o si la política de recursos permite `“Action”: “*”`, el grupo de paquetes del modelo asociado no se puede promocionar ni detectar.
# Ver el historial de implementación de un modelo
Para ver las implementaciones de una versión modelo en la consola de Amazon SageMaker Studio, complete los siguientes pasos en función de si utiliza Studio o Studio Classic.
------
#### [ Studio ]
**Ver el historial de implementación de una versión del modelo**
1. Abre la consola de SageMaker Studio siguiendo las instrucciones de [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. En el panel de navegación izquierdo, elija **Modelos** para ver una lista de sus grupos de modelos.
1. Seleccione la pestaña **Modelos registrados**, si aún no la ha seleccionado.
1. Justo debajo de la etiqueta de la pestaña **Modelos registrados**, elija **Grupos de modelos**, si aún no lo ha seleccionado.
1. En la lista de grupos de modelos, elija el corchete angular situado a la izquierda del grupo de modelos que desee ver.
1. Aparece una lista de las versiones del modelo del grupo de modelos. Si no ve la versión del modelo que desea eliminar, seleccione **Ver todo**.
1. Seleccione el nombre de la versión del modelo que desea visualizar.
1. Seleccione la pestaña **Actividad**. Las implementaciones de la versión modelo aparecen como eventos en la lista de actividades con un **tipo de evento** de **ModelDeployment**.
------
#### [ Studio Classic ]
**Ver el historial de implementación de una versión del modelo**
1. Inicia sesión en Amazon SageMaker Studio Classic. Para obtener más información, consulte [Lanzamiento de Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. En el panel de navegación izquierdo, elija el icono de **Inicio** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Elija **Modelos** y, a continuación, **Registro de modelos**.
1. En la lista de grupos de modelos, seleccione el nombre del grupo de modelos que desea ver.
1. Aparece una nueva pestaña con una lista de las versiones del modelo del grupo de modelos.
1. En la lista de versiones de modelo, seleccione el nombre de la versión del modelo de la que quiere ver los detalles.
1. En la pestaña de la versión del modelo que se abre, elija **Actividad**. Las implementaciones de la versión modelo aparecen como eventos en la lista de actividades con un **tipo de evento** de **ModelDeployment**.
------
# Visualización de los detalles del linaje del modelo en Studio
Puedes ver los detalles del linaje de un modelo registrado en Amazon SageMaker Studio. A continuación, se proporcionan instrucciones sobre cómo acceder a la vista de linaje en Studio. Consulte [Seguimiento del linaje de Amazon SageMaker ML](lineage-tracking.md) para obtener más información sobre el seguimiento del linaje en Amazon SageMaker Studio.
Esta función no está disponible en Amazon SageMaker Studio Classic.
+ Si Studio es su experiencia predeterminada, la interfaz de usuario es similar a las imágenes que se encuentran en [Descripción general de la interfaz de usuario de Amazon SageMaker Studio](studio-updated-ui.md).
+ Si su experiencia predeterminada es Studio Classic, la interfaz de usuario es similar a las imágenes que aparecen en [Descripción general de la interfaz de usuario clásica de Amazon SageMaker Studio](studio-ui.md).
La vista de linaje es una visualización interactiva de los recursos asociados a los modelos registrados. Estos recursos incluyen conjuntos de datos, trabajos de entrenamiento, aprobaciones, modelos y puntos de conexión. En el linaje, también puede ver los detalles del recurso asociado, incluidos el URI de origen, la marca de tiempo de creación y otros metadatos.
Las siguientes funciones están disponibles en `eu-west-1` las regiones `us-east-1` `us-west-2``ap-northeast-1`,, y:
Puede realizar un seguimiento del linaje de modelos registrados y registrados. Además, los recursos sobre el linaje de los modelos incluyen conjuntos de datos, evaluadores, trabajos de formación, aprobaciones, modelos, componentes de inferencia y puntos finales. En el linaje, también puede ver los detalles del recurso asociado, incluidos el URI de origen, la marca de tiempo de creación y otros metadatos.
A continuación, se proporcionan instrucciones sobre cómo acceder a los detalles del linaje de una versión del modelo registrada.
**Acceso a los detalles del linaje de una versión del modelo registrada**
1. Abra la consola de Studio siguiendo las instrucciones de [Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. Seleccione **Modelos** en el panel de navegación izquierdo.
1. Seleccione la pestaña **Modelos registrados**, si aún no la ha seleccionado.
1. Justo debajo de la etiqueta de la pestaña **Modelos registrados**, elija **Grupos de modelos**, si aún no lo ha seleccionado.
1. (Opcional) Si tiene modelos que han compartido con usted, puede elegir entre **Mis modelos** o **Compartidos conmigo**.
1. Seleccione un modelo registrado.
1. Elija la pestaña **Versiones** si aún no está seleccionada.
1. Elija una versión de modelo específica en la lista **Versiones**.
1. Elija la pestaña **Linaje**.
En la pestaña **Linaje**, puede navegar por los recursos asociados a la versión del modelo. También puede elegir un recurso para ver sus detalles.
Tenga en cuenta que la vista Linaje es solo para fines de visualización. Reorganizar o mover los componentes de esta vista no afecta a los recursos reales del modelo registrado.
Para`us-east-1`, y `eu-west-1` regiones `us-west-2``ap-northeast-1`, puede utilizar las siguientes instrucciones para acceder a los detalles del linaje de las versiones de modelos registradas y registradas:
1. Abra la consola de Studio siguiendo las instrucciones de [Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. Seleccione **Modelos** en el panel de navegación izquierdo.
1. Seleccione la pestaña **Mis modelos**.
1. (Opcional) Si tienes modelos compartidos contigo, puedes elegir entre **Creados por mí** o **Compartidos conmigo**.
1. Seleccione un modelo y elija **Ver la última versión**.
1. Elija la pestaña **Linaje**.