As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# 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. Esses exemplos de código se aplicam a Mistral AILlama,Qwen,Flan,GPTBigCode, e Mixtral arquiteturas.
## Importante: Model Architecture Support
**GPT-OSSLimitações do modelo:**
+ **API Converse não suportada:** modelos de importação de modelos personalizados GPT-OSS baseados NÃO oferecem suporte à API ou ConverseStream API Converse.
+ **Em vez disso, use a InvokeModel API:** os clientes devem usar a [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)API ao trabalhar com modelos personalizados GPT-OSS baseados.
+ **Requisito de esquema de API:** GPT-OSS os modelos exigem esquemas de API compatíveis com OpenAI:
+ Formato de preenchimento para solicitações de preenchimento
+ ChatCompletion formato para solicitações de bate-papo
+ O formato de resposta segue as especificações da API OpenAI
+ **Modelos compatíveis com a API Converse:** A API Converse é compatível somente com Mixtral arquiteturas Mistral AI LlamaQwen,Flan,,GPTBigCode, e.
Para exemplos de uso de GPT-OSS modelos com [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)API, consulte a documentação da API OpenAI para request/response esquemas.
1. Preparar arquivos de modelo para importação
1. Se estiver importando em um bucket do Amazon S3, será necessário fornecer os arquivos de modelo no formato de pesos da Hugging Face. Para obter mais informações, consulte [Importar uma fonte de modelo do Amazon S3](model-customization-import-model.md#model-customization-import-model-source).
1. Crie um bucket do Amazon S3 para os arquivos de modelo (os nomes devem ser exclusivos).
1. Carregue os arquivos no bucket.
1. Crie uma política para acessar seus arquivos de modelo e a anexe a um perfil do IAM com uma relação de confiança do Amazon Bedrock. Escolha a guia correspondente ao método de sua preferência e siga as etapas:
------
#### [ Console ]
1. 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 console do IAM em [https://console.aws.amazon.com/iam](https://console.aws.amazon.com/iam) e escolha **Políticas** no painel de navegação esquerdo.
1. Selecione **Criar política** e escolha **JSON** para abrir o **Editor de políticas**.
1. Cole a política a seguir, {{${model-file-bucket}}} substituindo-a pelo nome do bucket e selecione **Avançar**.
------
#### [ 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}}}/*"
]
}
]
}
```
------
1. Nomeie a política {{S3BucketPolicy}} e selecione **Criar política**.
1. Crie um perfil do IAM e anexe a política.
1. No painel de navegação à esquerda, escolha **Perfis** e selecione **Criar perfil**.
1. Selecione **Política de confiança personalizada**, cole a política a seguir e selecione **Próximo**.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "bedrock.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Procure a {{S3BucketPolicy}} política que você criou, marque a caixa de seleção e escolha **Avançar**.
1. Nomeie a função {{MyImportModelRole}} e selecione{{Create role}}.
------
#### [ CLI ]
1. Crie um arquivo chamado {{BedrockTrust.json}} e cole a política a seguir nele.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "bedrock.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Crie outro arquivo chamado {{S3BucketPolicy.json}} e cole a política a seguir nele, {{${model-file-bucket}}} substituindo-o pelos nomes dos seus buckets.
------
#### [ 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}}}/*"
]
}
]
}
```
------
1. Em um terminal, navegue até a pasta que contém as políticas que criou.
1. Faça uma [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)solicitação para criar uma função do IAM chamada {{MyImportModelRole}} e anexe 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
```
1. Faça uma [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)solicitaçã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
```
1. Faça uma [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)solicitação para anexar a política de acesso a dados do S3 à sua função, substituindo-a `policy-arn` pelo ARN na resposta da etapa anterior:
```
aws iam attach-role-policy \
--role-name MyImportModelRole \
--policy-arn {{${policy-arn}}}
```
------
#### [ Python ]
1. Execute o código a seguir para fazer uma [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)solicitação para criar uma função do IAM chamada {{MyImportModel}} e para fazer uma [CreatePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreatePolicy.html)solicitação para criar uma política de acesso a dados do S3 chamada{{S3BucketPolicy}}. 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}}}/*"
]
}
]
})
)
```
1. Um `Arn` é retornado na resposta. Execute o seguinte trecho de código para fazer uma [AttachRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_AttachRolePolicy.html)solicitação, {{${policy-arn}}} substituindo-o pelo retornado. `Arn`
```
iam.attach_role_policy(
RoleName="MyImportModelRole",
PolicyArn="{{${policy-arn}}}"
)
```
------
1. Selecione uma linguagem para ver exemplos de código para chamar as operações de API de importação de 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 a configuração de uma VPC, 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 chave KMS, 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 ao modelo de and/or saída do trabalho e certificando-se de separar os key/value pares com um espaço:
```
-\\-tags key={{key1}},value={{value1}} key={{key2}},value={{value2}}
```
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.
```
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 no modelo recém-importado, forneça o ARN do modelo importado como o `model-id`. Obtenha o ARN do modelo importado.
```
aws bedrock list-imported-models
```
A resposta contém o nome e o ARN do modelo. Use o ARN do modelo para invocar o modelo importado. Para obter mais informações, consulte [Envie uma única solicitação com InvokeModel](inference-invoke.md).
```
{
"modelSummaries": [
{
"modelArn": {{model-arn}},
"modelName": "MyImportedModelName",
"modelArchitecture":{{model-architecture}},
"instructSupported":{{Y}},
"creationTime": "2024-08-13T19:20:14.058Z"
}
]
}
```
Para excluir o modelo importado, em um terminal, execute o comando a seguir na linha de comandos, usando o nome do modelo ou o ARN do modelo importado que 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-region}}Substitua pela região em que você importou o modelo, {{${my-import-model-role-arn}}} pelo ARN do {{MyImportModelRole}} que você configurou e {{${model-file-bucket}}} substitua pelo nome do bucket do 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")
```
Os campos a seguir são opcionais.
+ Para adicionar a configuração de uma VPC, 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 chave KMS, 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 ao modelo de and/or saída do trabalho e certificando-se de separar os key/value pares 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 no modelo recém-importado, forneça o ARN do modelo importado como o `model-id`. Obtenha o ARN do 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 ARN do modelo para invocar o modelo importado. Para obter mais informações, consulte [Envie uma única solicitação com InvokeModel](inference-invoke.md).
Para excluir o modelo importado, use o comando a seguir com o nome ou o ARN do modelo importado que deseja excluir.
```
response = client.delete_imported_model(
modelIdentifier='{{MyImportedModelName}}'
)
```
------