Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Registrazione di una versione del modello
Puoi registrare un modello Amazon SageMaker AI creando una versione del modello che specifica il gruppo di modelli a cui appartiene. Una versione del modello deve includere gli artefatti del modello (i pesi addestrati di un modello) e, facoltativamente, il codice di inferenza per il modello.
Una *pipeline di inferenza* è un modello di SageMaker intelligenza artificiale composto da una sequenza lineare da due a quindici contenitori che elaborano le richieste di inferenza. Una pipeline di inferenza può essere registrata specificando i container e le variabili di ambiente associate. Per ulteriori informazioni sulle pipeline di inferenza, consulta [Pipeline di inferenza in Amazon AI SageMaker](inference-pipelines.md).
È possibile registrare un modello con una pipeline di inferenza, specificando i container e le variabili di ambiente associate. Per creare una versione del modello con una pipeline di inferenza utilizzando la AWS SDK per Python (Boto3) console Amazon SageMaker Studio o creando una fase in una pipeline di creazione di modelli di SageMaker intelligenza artificiale, utilizza i passaggi seguenti.
**Topics**
+ [Registra una versione del modello (AI Pipelines) SageMaker](#model-registry-pipeline)
+ [Registrazione di una versione del modello (boto3)](#model-registry-version-api)
+ [Registrazione di una versione del modello (Studio o Studio Classic)](#model-registry-studio)
+ [Registrazione di una versione del modello da un account diverso](#model-registry-version-xaccount)
## Registra una versione del modello (AI Pipelines) SageMaker
Per registrare una versione del modello utilizzando una pipeline di creazione di modelli SageMaker AI, crea una `RegisterModel` fase nella pipeline. Per ulteriori informazioni sulla creazione di una fase `RegisterModel` come parte di una pipeline, consulta [Fase 8: Definire una RegisterModel fase per creare un pacchetto modello](define-pipeline.md#define-pipeline-register).
## Registrazione di una versione del modello (boto3)
Per registrare una versione del modello con Boto3, chiama l’operazione API `create_model_package`.
Innanzitutto, configura il dizionario dei parametri da passare all’operazione 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)
```
Quindi, chiama l’operazione API `create_model_package` passando il dizionario dei parametri appena impostato.
```
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))
```
## Registrazione di una versione del modello (Studio o Studio Classic)
Per registrare una versione del modello nella console Amazon SageMaker Studio, completa i seguenti passaggi a seconda che utilizzi Studio o Studio Classic.
------
#### [ Studio ]
1. Apri la console SageMaker Studio seguendo le istruzioni in [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. Nel riquadro di navigazione a sinistra scegli **Modelli** dal menu.
1. Scegli la scheda **Modelli registrati**, se non è già selezionata.
1. Immediatamente sotto l’etichetta della scheda **Modelli registrati**, scegli **Gruppi di modelli** e **I miei modelli**, se non sono già selezionati.
1. Scegli **Registrati**. Si apre la pagina **Registra modello**.
1. Segui le istruzioni fornite nella pagina **Registra modello**.
1. Dopo aver controllato le tue scelte, scegli **Registra**. Al termine, verrai indirizzato alla pagina **Panoramica** della versione del modello.
------
#### [ Studio Classic ]
1. Accedi ad Amazon SageMaker Studio Classic. Per ulteriori informazioni, consulta [Launch Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html).
1. Nel riquadro di navigazione a sinistra, scegli l’icona **Home** (  ).
1. Scegli **Modelli**, quindi **Registro dei modelli**.
1. Apri il modulo **Registra versione**. Ci sono due modi per farlo:
+ Seleziona **Azioni** e scegli **Crea versione del modello**.
+ Seleziona il nome del gruppo di modelli per il quale desideri creare una versione del modello, quindi scegli **Crea versione del modello**.
1. Nel modulo **Registra versione del modello**, inserisci le seguenti informazioni:
+ Nel menu a discesa **Nome del gruppo del pacchetto di modelli**, seleziona il nome del gruppo di modelli.
+ (Facoltativo) Inserisci una descrizione per la versione del modello.
+ Nel menu a discesa **Stato di approvazione del modello**, seleziona lo stato di approvazione della versione.
+ (Facoltativo) Nel campo **Metadati personalizzati**, aggiungi tag personalizzati come coppie chiave-valore.
1. Scegli **Next (Successivo)**.
1. Nel modulo **Specifica di inferenza**, inserisci le seguenti informazioni:
+ Immetti la posizione dell'immagine di inferenza.
+ Immetti la posizione degli artefatti dei dati del modello.
+ (Facoltativo) Inserisci le informazioni sulle immagini da utilizzare per i processi di trasformazione e inferenza in tempo reale e sui tipi MIME di input e output supportati.
1. Scegli **Next (Successivo)**.
1. (Facoltativo) Inserisci ulteriori dettagli per ricevere migliori raccomandazioni sugli endpoint.
1. Seleziona **Avanti**.
1. (Facoltativo) Scegli le metriche del modello che desideri includere.
1. Seleziona **Avanti**.
1. Assicurati che le impostazioni visualizzate siano corrette e scegli **Registra versione del modello**. Se, successivamente, viene visualizzata una finestra modale con un messaggio di errore, scegli **Visualizza** (accanto al messaggio) per visualizzare l'origine dell'errore.
1. Conferma che la nuova versione del modello sia visualizzata nella pagina del gruppo di modelli principale.
------
## Registrazione di una versione del modello da un account diverso
Per registrare le versioni del modello con un gruppo di modelli creato da un AWS account diverso, devi aggiungere una politica sulle AWS Identity and Access Management risorse tra account per abilitare quell'account. Ad esempio, un AWS account dell'organizzazione è responsabile dei modelli di formazione e un altro account è responsabile della gestione, della distribuzione e dell'aggiornamento dei modelli. Crea le policy delle risorse IAM e applicale alla risorsa specifica dell'account a cui desideri concedere l'accesso in questo caso. *Per ulteriori informazioni sulle politiche relative alle risorse tra account in AWS, consulta [Logica di valutazione delle politiche tra account](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html) nella Guida per l'AWS Identity and Access Management utente.*
Per abilitare la rilevabilità multi-account, che consente ad altri account di visualizzare i gruppi di pacchetti di modelli dall’account proprietario di risorse, consulta [Rilevabilità multi-account](model-registry-ram.md).
**Nota**
È inoltre necessario utilizzare una chiave KMS per crittografare l'azione di [configurazione dei dati di output](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_OutputDataConfig.html) durante l'addestramento per la distribuzione del modello tra account.
Per abilitare il registro dei modelli tra account in SageMaker AI, devi fornire una politica delle risorse tra account per il Model Group che contiene le versioni del modello. Di seguito è riportato un esempio che crea policy tra account per il gruppo di modelli e le applica alla specifica risorsa.
La seguente configurazione deve essere impostata nell'account di origine che registra i modelli tra account in un gruppo di modelli. In questo esempio, l'account di origine è l'account di addestramento del modello che addestrerà e, di conseguenza, registrerà l'account incrociato del modello nel registro dei modelli dell'apposito account.
L'esempio presuppone che in precedenza siano state definite le seguenti variabili:
+ `sm_client`— Un client SageMaker AI Boto3.
+ `model_package_group_name`: il gruppo di modelli al quale si desidera concedere l’accesso.
+ `model_package_group_arn`: l’ARN del gruppo di modelli a cui concedere l’accesso multi-account.
+ `bucket`: il bucket Amazon S3 in cui vengono archiviati gli artefatti per l’addestramento dei modelli.
Per poter implementare un modello creato in un account diverso, l'utente deve avere un ruolo che abbia accesso alle azioni di SageMaker intelligenza artificiale, ad esempio un ruolo con la `AmazonSageMakerFullAccess` politica gestita. Per informazioni sulle politiche gestite dall' SageMaker IA, consulta[AWS politiche gestite per Amazon SageMaker AI](security-iam-awsmanpol.md).
### Policy relative alle risorse IAM richieste
Il diagramma seguente illustra le policy necessarie per consentire la registrazione del modello tra più account. Come illustrato, queste policy devono essere attive durante l’addestramento del modello per registrare correttamente il modello nell'account di registrazione dei modelli.
Amazon ECR, Amazon S3 AWS KMS e le policy sono dimostrate nei seguenti esempi di codice.
**Esempio di policy Amazon ECR**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AddPerm",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::{{111122223333}}:root"
},
"Action": [
"ecr:BatchGetImage",
"ecr:Describe*"
]
}
]
}
```
------
**Esempio di policy 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}}/*"
}
]
}
```
------
**Esempio di politica 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": "*"
}
]
}
```
------
### Applicazione di policy relative alle risorse agli account
La seguente configurazione delle policy, che applica le policy discusse nella sezione precedente, deve essere inserita nell'account di addestramento del modello.
```
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 seguente configurazione deve essere inserita nell'account di registrazione del modello in cui esiste il gruppo di modelli.
```
# 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)
```
Infine, utilizza l'azione `create_model_package` dell’account di addestramento del modello per registrare il pacchetto di modelli tra account.
```
# 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))
```