Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Création d'un modèle personnalisé (AWS SDKs)
<a name="create-custom-model-sdks"></a>

Pour créer un modèle personnalisé à partir d'un modèle SageMaker Amazon Nova entraîné par l'IA et stocké dans Amazon S3, vous devez utiliser l'opération [CreateCustomModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateCustomModel.html)API. Vous pouvez utiliser le code suivant pour créer un modèle personnalisé à l’aide du kit SDK for Python (Boto3). Le code crée un modèle personnalisé, puis vérifie son état jusqu’à ce que le modèle soit `ACTIVE` et prêt à être utilisé.

Pour utiliser le code, mettez à jour les paramètres suivants. L’exemple de code inclut également des paramètres facultatifs tels que `clientRequestToken` pour l’idempotence et `modelTags` pour l’étiquetage des ressources. 
+ **modelName** : donnez un nom unique au modèle.
+ **S3uri** — Spécifiez le chemin d'accès au compartiment Amazon S3 géré par Amazon qui stocke les artefacts de votre modèle. SageMaker L'IA crée ce compartiment lorsque vous exécutez votre premier poste de formation en SageMaker IA.
+ **roleArn** : spécifiez l’Amazon Resource Name (ARN) d’un rôle de service IAM qu’Amazon Bedrock assume pour effectuer des tâches en votre nom. Pour plus d'informations sur la création de ce rôle, consultez la page [Création d’un rôle de service pour l’importation de modèles pré-entraînés](model-import-iam-role.md).
+ **modelKmsKeyArn** (facultatif) — Spécifiez une AWS KMS clé pour chiffrer le modèle dans Amazon Bedrock. Si vous ne fournissez pas de AWS KMS clé, Amazon Bedrock utilise une AWS KMS clé AWS gérée pour chiffrer le modèle. Pour plus d’informations sur le chiffrement, consultez [Chiffrement des modèles personnalisés importés](encryption-import-model.md).

Une fois que vous avez créé le modèle personnalisé, celui-ci apparaît dans la [ListCustomModels](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_ListCustomModels.html)réponse avec un signe `customizationType` de`imported`. Pour suivre l'état du nouveau modèle, vous utilisez l'opération [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()
```