Exemplos de código para importação de modelos personalizados

Os exemplos de código a seguir mostram como configurar permissões, criar um trabalho de importação de modelo personalizado, visualizar os detalhes dos trabalhos de importação e de modelos importados e excluir o modelo importado.

Preparar arquivos de modelo para importação
1. Se você estiver importando de um bucket do Amazon S3, precisará fornecer os arquivos de modelo no Hugging Face formato de pesos. Para obter mais informações, consulte Importar a origem.
2. Crie um bucket do Amazon S3 para os arquivos de modelo (os nomes devem ser exclusivos).
3. Carregue os arquivos no bucket.

Crie uma política para acessar seus arquivos de modelo e anexá-la a uma IAM função com uma relação de confiança da Amazon Bedrock. Escolha a guia do seu método preferido e siga as etapas:

Console

Crie uma política do Amazon S3 para acessar o bucket do Amazon S3 que contém os arquivos de modelo.
1. Navegue até o IAM console em https://console.aws.amazon.com/iam e escolha Políticas no painel de navegação esquerdo.
2. Selecione Criar política e, em seguida, escolha JSONabrir o editor de políticas.
3. Cole a política a seguir, ${model-file-bucket} substituindo-a pelo nome do bucket e selecione Avançar.
```
{
    "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. Nomeie a política S3BucketPolicy e selecione Criar política.
Crie uma IAM função e anexe a política.
1. No painel de navegação à esquerda, escolha Perfis e selecione Criar perfil.
2. Selecione Política de confiança personalizada, cole a política a seguir e selecione Próximo.
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "bedrock.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ] 
}
```
3. Procure a S3BucketPolicy política que você criou, marque a caixa de seleção e escolha Avançar.
4. Nomeie a função MyImportModelRole e selecioneCreate role.

CLI

Crie um arquivo chamado BedrockTrust.json e cole a política a seguir nele.


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

Crie outro arquivo chamado S3BucketPolicy.json e cole a política a seguir nele, ${model-file-bucket} substituindo-o pelos nomes dos seus buckets.


{
    "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}/*"
            ]
        }
     ]
}

Em um terminal, navegue até a pasta que contém as políticas que criou.
Faça uma CreateRolesolicitação para criar uma IAM função chamada MyImportModelRole e anexar a política de BedrockTrust.json confiança que você criou.
```
aws iam create-role \
    --role-name MyImportModelRole \
    --assume-role-policy-document file://BedrockTrust.json
```
Faça uma CreatePolicysolicitação para criar a política de acesso a dados do S3 com o S3BucketPolicy.json arquivo que você criou. A resposta retorna um Arn para a política.
```
aws iam create-policy \
    --policy-name S3BucketPolicy \
    --policy-document file://S3BucketPolicy.json
```
Faça uma AttachRolePolicysolicitação para anexar a política de acesso a dados do S3 à sua função, substituindo-a policy-arn pela ARN na resposta da etapa anterior:
```
aws iam attach-role-policy \
    --role-name MyImportModelRole \
    --policy-arn ${policy-arn}
```

Python

Execute o código a seguir para fazer uma CreateRolesolicitação para criar uma IAM função chamada MyImportModel e para fazer uma CreatePolicysolicitação para criar uma política de acesso a dados do S3 chamadaS3BucketPolicy. Para a política de acesso a dados do S3, ${model-file-bucket} substitua pelos nomes dos seus buckets do 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}/*"
                ]
            }
          ]
       })
     )

Um Arn é retornado na resposta. Execute o seguinte trecho de código para fazer uma AttachRolePolicysolicitação, ${policy-arn} substituindo-o pelo retornado. Arn
```
iam.attach_role_policy(
    RoleName="MyImportModelRole",
    PolicyArn="${policy-arn}"
)
```

Selecione um idioma para ver exemplos de código para chamar as API operações de importação do modelo personalizado.

CLI

Para enviar um trabalho de importação de modelo personalizado, em um terminal, execute o seguinte comando na linha de comando, ${my-import-model-role-arn} substituindo-o pela função de modelo que você configurou e pelo s3-bucket-path caminho do bucket do S3 dos seus arquivos 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 }}

A resposta retorna o jobArn. O trabalho de importação personalizado levará algum tempo para ser concluído. É possível usar o jobArn com o comando a seguir para verificar o status do trabalho de importação.

Os seguintes campos são opcionais:

Para adicionar uma VPC configuração, adicione o seguinte argumento ao comando acima para especificar o grupo de segurança e as sub-redes:
```
   -\\-vpc-config '{securityGroupIds": ["sg-xx"], "subnetIds": ["subnet-yy", "subnet-zz"]}'
                
```
Para criptografar seu modelo com uma KMS chave, adicione o seguinte argumento ao comando acima, substituindo os valores para especificar a chave com a qual você deseja criptografar seu modelo.
```
   -\\-customModelKmsKeyId 'arn:aws:kms:region:account-id:key/key-id'
                
```
Para adicionar tags, adicione o seguinte argumento ao comando acima, substituindo as chaves e os valores pelas tags que você deseja anexar aos and/or output model and making sure to separate key/value pares de tarefas com um espaço:
```
   -\\-tags key=key1,value=value1 key=key2,value=value2
                
```


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

A resposta deve ser semelhante a esta:


{
    "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"

Quando o status for Complete, o trabalho de importação estará concluído.

Para executar inferência em seu modelo recém-importado, você deve fornecer o ARN do modelo importado como o. model-id Obtenha ARN o modelo importado.


aws bedrock list-imported-models

A resposta contém o nome do modelo e o modeloARN. Use o modelo ARN para invocar o modelo importado. Para obter mais informações, consulte Envie uma única solicitação com InvokeModel.


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

Para excluir seu modelo importado, em um terminal, execute o seguinte comando na linha de comando, usando o nome do modelo ou o modelo ARN do modelo importado que você deseja excluir.


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

Python

Execute o trecho de código a seguir para enviar um trabalho de importação de modelo personalizado. my-regionSubstitua pela região em que você importou o modelo, ${my-import-model-role-arn} pela MyImportModelRole que você configurou e ${model-file-bucket} substitua pelo nome do bucket do S3. ARN


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")

Os campos a seguir são opcionais.

Para adicionar uma VPC configuração, adicione o seguinte argumento ao comando acima para especificar o grupo de segurança e as sub-redes:
```
   vpc-config = {'securityGroupIds: ["sg-xx".], 'subnetIds': [subnet-yy, 'subnet-zz']}'
                
```
Para criptografar seu modelo com uma KMS chave, adicione o seguinte argumento ao comando acima, substituindo os valores para especificar a chave com a qual você deseja criptografar seu modelo.
```
   importedModelKmsKeyId = 'arn:aws:kms:region:account-id:key/key-id'
                
```
Para adicionar tags, adicione o seguinte argumento ao comando acima, substituindo as chaves e os valores pelas tags que você deseja anexar aos and/or output model and making sure to separate key/value pares de tarefas com um espaço:
```
   jobTags key=key1,value=value1 key=key2,value=value2
                
```

A resposta retorna um jobArn



               job_arn = create_job_response.get("jobArn")

O trabalho de importação personalizado levará algum tempo para ser concluído. É possível usar o jobArn com o comando a seguir para verificar o status do trabalho de importação.


bedrock.get_model_import_job(jobIdentifier=jobArn)

Quando o status for Completed, o trabalho de importação estará concluído.

Para executar inferência em seu modelo recém-importado, você deve fornecer o ARN do modelo importado como o. model-id Obtenha ARN o 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'

A resposta retorna o modelArn com outros detalhes do modelo importado.


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

Use o modelo ARN para invocar o modelo importado. Para obter mais informações, consulte Envie uma única solicitação com InvokeModel.

Para excluir seu modelo importado, use o comando a seguir usando o nome do modelo ou o modelo ARN do modelo importado que você deseja excluir.


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

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Invocar o modelo importado

Converse APIexemplos de código para importação de modelos personalizados