Ejemplos de código para la importación de modelos personalizados - Amazon Bedrock

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.

Ejemplos de código para la importación de modelos personalizados

Los siguientes ejemplos de código muestran cómo configurar los permisos, crear un trabajo de importación de modelos personalizado, ver los detalles de los trabajos de importación y los modelos importados y eliminar el modelo importado.

  1. Preparación de los archivos del modelo para importarlos

    1. Si va a importar desde un bucket de Amazon S3, debe proporcionar los archivos del modelo en formato de pesos Hugging Face. Para obtener más información, consulte Importación de una fuente de modelos desde Amazon S3.

    2. Cree un bucket de Amazon S3 para los archivos del modelo (los nombres deben ser únicos).

    3. Cargue archivos del modelo en el bucket.

  2. Cree una política para acceder a los archivos de sus modelos y adjúntela a un rol de IAM con una relación de confianza en Amazon Bedrock. Elija la pestaña del método que prefiera y, a continuación, siga los pasos:

    Console

    1. Cree una política de Amazon S3 para acceder al bucket de Amazon S3 que contiene los archivos del modelo.

      1. Ve a la consola de IAM en https://console.aws.amazon.com/iam y selecciona Políticas en el panel de navegación izquierdo.

      2. Seleccione Crear política y, a continuación, elija JSON para abrir el Editor de políticas.

      3. Pegue la siguiente política, sustitúyala por ${model-file-bucket} el nombre de su bucket y, a continuación, seleccione Siguiente.

        JSON
        JSON
        {
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::${model-file-bucket}",
                "arn:aws:s3:::${model-file-bucket}/*"
            ]
          }
        ]
      }

      4. Asigne un nombre a la política S3BucketPolicy y seleccione Crear política.

    2. Cree un rol de IAM y asóciele la política.

      1. En el panel de navegación de la izquierda, seleccione Roles y, a continuación, seleccione Crear rol.

      2. Seleccione Política de confianza personalizada, pegue la siguiente política y seleccione Siguiente.

        JSON
        JSON
        {
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "bedrock.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ] 
}

      3. Busca la S3BucketPolicy política que creaste, selecciona la casilla de verificación y selecciona Siguiente.

      4. Asigne un nombre al rol MyImportModelRole y seleccióneloCreate role.

    CLI

    1. Cree un archivo llamado BedrockTrust.json y pegue la siguiente política en él.

      JSON
      JSON
      {
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "bedrock.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ] 
}

    2. Crea otro archivo llamado S3BucketPolicy.json y pega en él la siguiente política y sustitúyela por ${model-file-bucket} los nombres de tus buckets.

      JSON
      JSON
      {
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::${model-file-bucket}",
                "arn:aws:s3:::${model-file-bucket}/*"
            ]
        }
     ]
}

    3. En un terminal, navegue hasta la carpeta que contiene las políticas que ha creado.

    4. CreateRoleSolicita crear un rol de IAM llamado MyImportModelRole y adjunta la política de BedrockTrust.json confianza que creaste.

      aws iam create-role \
    --role-name MyImportModelRole \
    --assume-role-policy-document file://BedrockTrust.json

    5. CreatePolicySolicita crear la política de acceso a datos de S3 con el S3BucketPolicy.json archivo que has creado. La respuesta devuelve un Arn para la política.

      aws iam create-policy \
    --policy-name S3BucketPolicy \
    --policy-document file://S3BucketPolicy.json

    6. Realice una AttachRolePolicysolicitud para adjuntar la política de acceso a datos de S3 a su función, sustituyéndola por el ARN en la respuesta del paso anterior: policy-arn

      aws iam attach-role-policy \
    --role-name MyImportModelRole \
    --policy-arn ${policy-arn}
    Python

    1. Ejecute el siguiente código para realizar una CreateRolesolicitud de creación de un rol de IAM MyImportModel y para realizar una CreatePolicysolicitud de creación de una política de acceso a datos de S3 denominada. S3BucketPolicy Para la política de acceso a datos de S3, sustitúyala por ${model-file-bucket} los nombres de los buckets de S3.

      import boto3
import json

iam = boto3.client("iam")

iam.create_role(
    RoleName="MyImportModelRole",
    AssumeRolePolicyDocument=json.dumps({
        "Version": "2012-10-17",		 	 	 
        "Statement": [
            {
                "Effect": "Allow",
                "Principal": {
                    "Service": "bedrock.amazonaws.com"
                },
                "Action": "sts:AssumeRole"
            }
        ] 
    })
)

iam.create_policy(
    PolicyName="S3BucketPolicy",
    PolicyDocument=json.dumps({
        "Version": "2012-10-17",		 	 	 
        "Statement": [
            {
                "Effect": "Allow",
                "Action": [
                    "s3:GetObject",
                    "s3:ListBucket"
                ],
                "Resource": [
                    "arn:aws:s3:::${training-bucket}",
                    "arn:aws:s3:::${training-bucket}/*"
                ]
            }
          ]
       })
     )

    2. En la respuesta se devuelve un Arn. Ejecuta el siguiente fragmento de código para realizar una AttachRolePolicysolicitud y sustitúyelo por el ${policy-arn} devuelto. Arn

      iam.attach_role_policy(
    RoleName="MyImportModelRole",
    PolicyArn="${policy-arn}"
)

  3. Seleccione un idioma para ver ejemplos de código para llamar a las operaciones de la API de importación de modelos personalizados.

CLI

Para enviar un trabajo de importación de un modelo personalizado, ejecute el siguiente comando en la línea de comandos y ${my-import-model-role-arn} sustitúyalo por el rol de modelo que haya configurado y por la s3-bucket-path ruta del bucket S3 de sus archivos de modelo.

aws bedrock create-model-import-job 
    --job-name MyImportedModelJobName
    --imported-model-name MyImportedModelName
    --role-arn ${my-import-model-role-arn}  
    --model-data-source '{"s3DataSource": {"s3Uri": s3-bucket-path }}

La respuesta devuelve un jobArn. El trabajo de importación personalizado tardará un tiempo en completarse. Puede usar el jobArn con el siguiente comando para comprobar el estado del trabajo de importación.

Los siguientes campos son opcionales:

  • Para agregar una configuración de VPC, agregue el siguiente argumento al comando anterior para especificar el grupo de seguridad y las subredes:

    
   -\\-vpc-config '{securityGroupIds": ["sg-xx"], "subnetIds": ["subnet-yy", "subnet-zz"]}'

  • Para cifrar el modelo con una clave de KMS, agregue el siguiente argumento al comando anterior y sustituya los valores para especificar la clave con la que desea cifrar el modelo.

    
   -\\-customModelKmsKeyId 'arn:aws:kms:region:account-id:key/key-id'

  • Para añadir etiquetas, añada el siguiente argumento al comando anterior, sustituya las claves y los valores por las etiquetas que desee adjuntar al modelo de and/or salida del trabajo y asegúrese de separar los key/value pares con un espacio:

    
   -\\-tags key=key1,value=value1 key=key2,value=value2

La respuesta devuelve un jobArn. El trabajo de importación personalizado tardará un tiempo en completarse. Puede usar el jobArn con el siguiente comando para comprobar el estado del trabajo de importación.

aws bedrock get-model-import-job \
    --job-identifier "jobArn"

La respuesta tendrá un aspecto parecido al siguiente:

{
    "jobArn": ${job-arn} ,
    "jobName": MyImportedModelJobName,
    "importedModelName": MyImportedModelName,
    "roleArn": ${my-role-arn},
    "modelDataSource": {
        "s3DataSource": {
            "s3Uri": "${S3Uri}"
        }
    },
    "status": "Complete",
    "creationTime": "2024-08-13T23:38:42.457Z",
    "lastModifiedTime": "2024-08-13T23:39:25.158Z"

Cuando status sea Complete, el trabajo de importación se habrá completado.

Para ejecutar la inferencia en el modelo que acaba de importar, debe proporcionar el ARN del modelo importado como model-id. Obtenga el ARN del modelo importado.

aws bedrock list-imported-models

La respuesta contiene el nombre del modelo y el ARN del modelo. Utilice el ARN del modelo para invocar el modelo importado. Para obtener más información, consulte Envíe un único mensaje con InvokeModel.

{
    "modelSummaries": [
        {
            "modelArn": model-arn,
            "modelName": "MyImportedModelName",
            "modelArchitecture":model-architecture,
            "instructSupported":Y,
            "creationTime": "2024-08-13T19:20:14.058Z"
            
        }
    ]
}

Para eliminar el modelo importado, ejecute el siguiente comando en la línea de comandos en un terminal con el nombre del modelo o el ARN del modelo importado que desee eliminar.

aws bedrock delete-imported-model 
                --model-identifier MyImportedModelName
Python

Ejecute el siguiente fragmento de código para enviar un trabajo de importación de modelo personalizado. my-regionSustitúyalo por la región en la que importó el modelo, ${my-import-model-role-arn} por el ARN del MyImportModelRole que configuró y ${model-file-bucket} sustitúyalo por el nombre de su bucket de S3.

import boto3
import json

REGION_NAME = my-region
bedrock = boto3.client(service_name='bedrock',
                       region_name=REGION_NAME)

JOB_NAME = MyImportedModelJobName 
ROLE_ARN = ${my-import-model-role-arn}
IMPORTED_MODEL_NAME = ImportedModelName
S3_URI = ${S3Uri}

# createModelImportJob API
create_job_response = bedrock.create_model_import_job(
    jobName=JOB_NAME,
    importedModelName=IMPORTED_MODEL_NAME,
    roleArn=ROLE_ARN,
    modelDataSource={
        "s3DataSource": {
            "s3Uri": S3_URI
        }
    },
)
job_arn = create_job_response.get("jobArn")

Los siguientes campos son opcionales.

  • Para agregar una configuración de VPC, agregue el siguiente argumento al comando anterior para especificar el grupo de seguridad y las subredes:

    
   vpc-config = {'securityGroupIds: ["sg-xx".], 'subnetIds': [subnet-yy, 'subnet-zz']}'

  • Para cifrar el modelo con una clave de KMS, agregue el siguiente argumento al comando anterior y sustituya los valores para especificar la clave con la que desea cifrar el modelo.

    
   importedModelKmsKeyId = 'arn:aws:kms:region:account-id:key/key-id'

  • Para añadir etiquetas, añada el siguiente argumento al comando anterior, sustituya las claves y los valores por las etiquetas que desee adjuntar al modelo de and/or salida del trabajo y asegúrese de separar los key/value pares con un espacio:

    
   jobTags key=key1,value=value1 key=key2,value=value2

La respuesta devuelve un jobArn.


               job_arn = create_job_response.get("jobArn")

El trabajo de importación personalizado tardará un tiempo en completarse. Puede usar el jobArn con el siguiente comando para comprobar el estado del trabajo de importación.

bedrock.get_model_import_job(jobIdentifier=jobArn)

Cuando status sea Completed, el trabajo de importación se habrá completado.

Para ejecutar la inferencia en el modelo que acaba de importar, debe proporcionar el ARN del modelo importado como model-id. Obtenga el ARN del modelo importado.

response_pt = bedrock.list_imported_models(
    creationTimeBefore=datetime (2015,1,1,
    creationTimeAfter= datetime (2015,1,1,
    nameContains = 'MyImportedModelName,
    maxresults = 123
    nextToken = 'none',
    sortBy = 'creationTime',
    sortOrder = 'Ascending'

La respuesta devuelve el modelArn junto con otros detalles del modelo importado. 

{
    'nextToken': '',
    'modelSummaries': [
        {
            'modelArn': 'your-model-arn',
            'modelName': 'MyImportedModelName',
            'modelArchitecture':model-architecture,
            'instructSupported':Y,
            'creationTime': datetime(2015, 1, 1)
        },
    ]

Utilice el ARN del modelo para invocar el modelo importado. Para obtener más información, consulte Envíe un único mensaje con InvokeModel.

Para eliminar el modelo importado, utilice el siguiente comando con el nombre del modelo o el ARN del modelo importado que desee eliminar.

response = client.delete_imported_model(
    modelIdentifier='MyImportedModelName'
            )