Esempi di codice per l’importazione di modelli personalizzati

I seguenti esempi di codice mostrano come impostare le autorizzazioni, creare un processo di importazione di modelli personalizzati, visualizzare i dettagli dei processi di importazione e dei modelli importati ed eliminare il modello importato. Questi esempi di codice si applicano a Mistral AILlama,Qwen, FlanGPTBigCode, e Mixtral architetture.

Importante: Model Architecture Support

GPT-OSSLimitazioni del modello:

API Converse non supportata: i modelli di importazione di modelli personalizzati GPT-OSS basati su modelli NON supportano l'API o ConverseStream l'API Converse.
Utilizza invece l' InvokeModel API: i clienti devono utilizzare l'InvokeModelAPI quando lavorano con modelli personalizzati GPT-OSS basati.
Requisito dello schema API: GPT-OSS i modelli richiedono schemi API compatibili con OpenAI:
- Formato di completamento per le richieste di completamento
- ChatCompletion formato per le richieste di chat
- Il formato di risposta segue le specifiche dell'API OpenAI
Modelli supportati per l'API Converse: l'API Converse è supportata solo per le Mistral AI architettureLlama,Qwen,Flan,GPTBigCode, eMixtral.

Per esempi di utilizzo GPT-OSS del modello con InvokeModelAPI, consulta la documentazione dell'API OpenAI per gli request/response schemi.

Prepara i file modello per l’importazione
1. Se esegui l’importazione da un bucket Amazon S3, devi fornire i file modello nel formato dei pesi di Hugging Face. Per ulteriori informazioni, consulta Importare un origine del modello da Amazon S3.
2. Crea un bucket Amazon S3 per i file modello (i nomi devono essere univoci).
3. Carica i file modello nel bucket.

Crea una policy per accedere ai file modello e collegala a un ruolo IAM con una relazione di attendibilità di Amazon Bedrock. Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:

Console

Crea una policy Amazon S3 per accedere al bucket Amazon S3 che contiene i file modello
1. Accedi alla console IAM all'indirizzo https://console.aws.amazon.com/iam e scegli Policies dal riquadro di navigazione a sinistra.
2. Seleziona Crea policy, quindi scegli JSON per aprire l’Editor di policy.
3. Incolla la seguente policy, sostituendola ${model-file-bucket} con il nome del tuo bucket, quindi seleziona Avanti.
  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. Assegna un nome alla politica S3BucketPolicy e seleziona Crea politica.
Crea un ruolo IAM e collega la policy.
1. Nel riquadro di navigazione a sinistra, scegli Ruoli, poi Crea ruolo.
2. Seleziona Policy di attendibilità personalizzata, incolla la seguente policy e seleziona Avanti.
  JSON
  JSON
  { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "bedrock.amazonaws.com" }, "Action": "sts:AssumeRole" } ] }
3. Cerca la S3BucketPolicy politica che hai creato, seleziona la casella di controllo e scegli Avanti.
4. Assegna un nome al ruolo MyImportModelRole e selezionaCreate role.

CLI

Crea un file chiamato BedrockTrust.json e incolla la seguente politica al suo interno.

JSON

JSON


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

Crea un altro file chiamato S3BucketPolicy.json e incolla la seguente politica, sostituendola ${model-file-bucket} con i nomi dei tuoi bucket.

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

In un terminale, accedi alla cartella contenente le policy che hai creato.
Fai una CreateRolerichiesta per creare un ruolo IAM chiamato MyImportModelRole e allega la policy di BedrockTrust.json fiducia che hai creato.
```
aws iam create-role \
    --role-name MyImportModelRole \
    --assume-role-policy-document file://BedrockTrust.json
```
Fai una CreatePolicyrichiesta per creare la policy di accesso ai dati di S3 con il S3BucketPolicy.json file che hai creato. La risposta restituisce un Arn per la policy.
```
aws iam create-policy \
    --policy-name S3BucketPolicy \
    --policy-document file://S3BucketPolicy.json
```
Fai una AttachRolePolicyrichiesta per allegare la policy di accesso ai dati di S3 al tuo ruolo, sostituendola policy-arn con l'ARN nella risposta del passaggio precedente:
```
aws iam attach-role-policy \
    --role-name MyImportModelRole \
    --policy-arn ${policy-arn}
```

Python

Esegui il codice seguente per fare una CreateRolerichiesta per creare un ruolo IAM chiamato MyImportModel e per fare una CreatePolicyrichiesta per creare una policy di accesso ai dati S3 chiamata. S3BucketPolicy Per la politica di accesso ai dati di S3, sostituiscila ${model-file-bucket} con i nomi dei bucket 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}/*"
                ]
            }
          ]
       })
     )

Un Arn viene restituito nella risposta. Esegui il seguente frammento di codice per effettuare una AttachRolePolicyrichiesta, sostituendolo con quello restituito. ${policy-arn} Arn
```
iam.attach_role_policy(
    RoleName="MyImportModelRole",
    PolicyArn="${policy-arn}"
)
```

Seleziona una lingua per visualizzare esempi di codice per chiamare le operazioni dell’API di importazione di modelli personalizzati.

CLI

Per inviare un processo di importazione di un modello personalizzato, in un terminale esegui il seguente comando nella riga di comando, sostituendolo ${my-import-model-role-arn} con il ruolo modello che hai impostato e il s3-bucket-path percorso del bucket S3 dei tuoi file di modello.


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 risposta restituisce un jobArn. Il completamento del processo di importazione personalizzato richiederà un po’ di tempo. Puoi utilizzare il jobArn con il seguente comando per controllare lo stato del processo di importazione.

I seguenti campi sono facoltativi:

Per aggiungere una configurazione VPC, aggiungi il seguente argomento al comando precedente per specificare il gruppo di sicurezza e le sottoreti:
```
   -\\-vpc-config '{securityGroupIds": ["sg-xx"], "subnetIds": ["subnet-yy", "subnet-zz"]}'
                
```
Per crittografare il modello con una chiave KMS, aggiungi il seguente argomento al comando precedente, sostituendo i valori per specificare la chiave con cui crittografare il modello.
```
   -\\-customModelKmsKeyId 'arn:aws:kms:region:account-id:key/key-id'
                
```
Per aggiungere tag, aggiungi il seguente argomento al comando precedente, sostituendo le chiavi e i valori con i tag che desideri allegare al modello di and/or output del lavoro e assicurandoti di separare key/value le coppie con uno spazio:
```
   -\\-tags key=key1,value=value1 key=key2,value=value2
                
```


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

La risposta dovrebbe essere simile a questa:


{
    "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 lo status è Complete, il processo di importazione è completato.

Per eseguire l’inferenza sul modello appena importato, devi fornire l’ARN del modello importato come il model-id. Ottenere l’ARN del modello importato.


aws bedrock list-imported-models

La risposta contiene il nome del modello e l’ARN del modello. Utilizza il modello ARN per invocare il modello importato. Per ulteriori informazioni, consulta Invia una sola richiesta con InvokeModel.


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

Per eliminare il modello importato, in un terminale esegui il seguente comando nella riga di comando, utilizzando il nome del modello o l’ARN del modello importato che vuoi eliminare.


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

Python

Esegui il seguente frammento di codice per inviare un processo di importazione del modello personalizzato. Sostituisci my-region con la regione in cui hai importato il modello, ${my-import-model-role-arn} con l'ARN di MyImportModelRole quello che hai configurato e sostituiscilo ${model-file-bucket} con il nome del bucket 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")

I seguenti campi sono facoltativi.

Per aggiungere una configurazione VPC, aggiungi il seguente argomento al comando precedente per specificare il gruppo di sicurezza e le sottoreti:
```
   vpc-config = {'securityGroupIds: ["sg-xx".], 'subnetIds': [subnet-yy, 'subnet-zz']}'
                
```
Per crittografare il modello con una chiave KMS, aggiungi il seguente argomento al comando precedente, sostituendo i valori per specificare la chiave con cui crittografare il modello.
```
   importedModelKmsKeyId = 'arn:aws:kms:region:account-id:key/key-id'
                
```
Per aggiungere tag, aggiungi il seguente argomento al comando precedente, sostituendo le chiavi e i valori con i tag che desideri allegare al modello di and/or output del lavoro e assicurandoti di separare key/value le coppie con uno spazio:
```
   jobTags key=key1,value=value1 key=key2,value=value2
                
```

La risposta restituisce un jobArn.



               job_arn = create_job_response.get("jobArn")

Il completamento del processo di importazione personalizzato richiederà un po’ di tempo. Puoi utilizzare il jobArn con il seguente comando per controllare lo stato del processo di importazione.


bedrock.get_model_import_job(jobIdentifier=jobArn)

Quando lo status è Completed, il processo di importazione è completato.

Per eseguire l’inferenza sul modello appena importato, devi fornire l’ARN del modello importato come il model-id. Ottenere l’ARN del modello importato.


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 risposta restituisce modelArn insieme ad altri dettagli del modello importato.


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

Utilizza il modello ARN per invocare il modello importato. Per ulteriori informazioni, consulta Invia una sola richiesta con InvokeModel.

Per eliminare il modello importato, utilizza il seguente comando utilizzando il nome del modello o l’ARN del modello importato che vuoi eliminare.


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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Calcolare il costo di esecuzione di un modello personalizzato

Converse Esempi di codice API per l’importazione di modelli personalizzati