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à.

# Creare un modello personalizzato (AWS SDKs)
<a name="create-custom-model-sdks"></a>

Per creare un modello personalizzato da un modello SageMaker Amazon Nova addestrato all'intelligenza artificiale e archiviato in Amazon S3, utilizzi l'[CreateCustomModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateCustomModel.html)operazione API. È possibile utilizzare il seguente codice creare un modello personalizzato con l’SDK per Python (Boto3). Il codice crea un modello personalizzato e poi ne controlla lo stato fino a quando il modello è `ACTIVE` e pronto all’uso.

Per utilizzare il codice, aggiornare i seguenti parametri. L’esempio di codice include anche parametri facoltativi come `clientRequestToken` per l’idempotenza e `modelTags` per l’assegnazione di tag alle risorse. 
+ **modelName**: assegna al modello un nome univoco.
+ **s3URI**: specifica il percorso del bucket Amazon S3 gestito da Amazon che memorizza gli artefatti del tuo modello. SageMaker L'intelligenza artificiale crea questo bucket quando esegui il tuo primo lavoro di formazione sull'intelligenza artificiale. SageMaker 
+ **roleArn**: specifica il nome della risorsa Amazon (ARN) di un ruolo di servizio IAM che Amazon Bedrock assume per eseguire attività. Per ulteriori informazioni sulla creazione di questo ruolo, consultare [Creazione di un ruolo di servizio per l’importazione di modelli pre-addestrati](model-import-iam-role.md).
+ **modelKmsKeyArn** (opzionale): specifica una AWS KMS chiave per crittografare il modello in Amazon Bedrock. Se non fornisci una AWS KMS chiave, Amazon Bedrock utilizza una AWS KMS chiave AWS gestita per crittografare il modello. Per informazioni sulla crittografia, consulta [Crittografia di modelli personalizzati importati](encryption-import-model.md).

Dopo aver creato il modello personalizzato, il modello viene visualizzato nella [ListCustomModels](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_ListCustomModels.html)risposta con un di. `customizationType` `imported` Per tenere traccia dello stato del nuovo modello, si utilizza l'operazione [GetCustomModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetCustomModel.html)API.

```
import boto3
import uuid
from botocore.exceptions import ClientError
import time

def create_custom_model(bedrock_client):
    """
    Creates a custom model in Amazon Bedrock from a SageMaker AI-trained Amazon Nova model stored in Amazon S3.
    Args:
        bedrock_client: The Amazon Bedrock client instance
    Returns:
        dict: Response from the CreateCustomModel API call
    """
    try:
        # Create a unique client request token for idempotency
        client_request_token = str(uuid.uuid4())

        # Define the model source configuration
        model_source_config = {
            's3DataSource': {
                's3Uri': '{{s3://amzn-s3-demo-bucket/folder/}}',
            }
        }

        # Create the custom model
        response = bedrock_client.create_custom_model(
            # Required parameters
            modelName='{{modelName}}',
            roleArn='{{serviceRoleArn}}',
            modelSourceConfig=model_source_config,

            # Optional parameters
            clientRequestToken=client_request_token,
            modelKmsKeyArn='{{keyArn}}',
            modelTags=[
                {
                    'key': 'Environment',
                    'value': 'Production'
                },
                {
                    'key': 'Project',
                    'value': 'AIInference'
                }
            ]
        )

        print(f"Custom model creation initiated. Model ARN: {response['modelArn']}")

        return response

    except ClientError as e:
        print(f"Error creating custom model: {e}")
        raise

def list_custom_models(bedrock_client):
    """
    Lists all custom models in Amazon Bedrock.

    Args:
        bedrock_client: An Amazon Bedrock client.

    Returns:
        dict: Response from the ListCustomModels API call

    """

    try:
        response = bedrock_client.list_custom_models()
        print(f"Total number of custom models: {len(response['modelSummaries'])}")

        for model in response['modelSummaries']:
            print("ARN: " + model['modelArn'])
            print("Name: " + model['modelName'])
            print("Status: " + model['modelStatus'])
            print("Customization type: " + model['customizationType'])
            print("------------------------------------------------------")

        return response

    except ClientError as e:
        print(f"Error listing custom models: {e}")
        raise

def check_model_status(bedrock_client, model_arn):
    """
    Checks the status of a custom model creation.

    Args:
        model_arn (str): The ARN of the custom model
        bedrock_client: An Amazon Bedrock client.

    Returns:
        dict: Response from the GetCustomModel API call

    """

    try:
        max_time = time.time() + 60 * 60  # 1 hour

        while time.time() < max_time:
            response = bedrock_client.get_custom_model(modelIdentifier=model_arn)
            status = response.get('modelStatus')
            print(f"Job status: {status}")
            if status == 'Failed':
                print(f"Failure reason: {response.get('failureMessage')}")
                break
            if status == 'Active':
                print("Model is ready for use.")
                break
            time.sleep(60)

    except ClientError as e:
        print(f"Error checking model status: {e}")
        raise


def main():
    bedrock_client = boto3.client(service_name='bedrock', region_name='{{REGION}}')
    
    # Create the custom model
    model_arn = create_custom_model(bedrock_client)["modelArn"]

    # Check the status of the model
    if model_arn:
        check_model_status(bedrock_client, model_arn)

    # View all custom models
    list_custom_models(bedrock_client)


if __name__ == "__main__":
    main()
```