Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Crea e gestisci lavori di ottimizzazione per i modelli Amazon Nova
Puoi creare un job RFT (Reinforcement Fine-Tuning) utilizzando la console o l'API Amazon Bedrock. Il processo RFT può richiedere alcune ore a seconda delle dimensioni dei dati di allenamento, del numero di epoche e della complessità delle funzioni di ricompensa.
## Prerequisiti
+ Crea un ruolo di servizio IAM con le autorizzazioni richieste. Per informazioni complete sulla sicurezza e sulle autorizzazioni, comprese le autorizzazioni specifiche per RFT, consulta. [Accesso e sicurezza per i modelli Amazon Nova](rft-access-security.md)
+ (Facoltativo) Crittografa i dati di input e output, il job RFT o le richieste di inferenza effettuate su modelli personalizzati. Per ulteriori informazioni, consulta [Crittografia dei modelli personalizzati.](https://docs.aws.amazon.com/bedrock/latest/userguide/encryption-custom-job.html)
## Crea il tuo lavoro RFT
Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ Console ]
Per inviare un lavoro RFT nella console, procedi nel seguente modo:
1. Apri la console Amazon Bedrock e vai a **Modelli personalizzati** in **Tune**.
1. Scegli **Crea, quindi Crea un** **lavoro di messa a punto delle armature**.
1. Nella sezione **Dettagli del modello**, scegli **Amazon Nova 2 Lite** come modello base.
1. Nella sezione **Dettagli di personalizzazione**, inserisci il nome della personalizzazione.
1. Nella sezione **Dati di allenamento**, scegli la tua fonte di dati. Seleziona tra i log delle chiamate disponibili archiviati in Amazon S3, seleziona la posizione Amazon S3 del file del set di dati di addestramento o carica un file direttamente dal tuo dispositivo.
**Nota**
Il tuo set di dati di allenamento dovrebbe essere nel formato dati OpenAI Chat Completions. Se fornisci i log delle chiamate nel formato Amazon Bedrock invoke o converse, Amazon Bedrock li converte automaticamente nel formato Chat Completions.
1. Nella sezione Funzione Reward, configura il tuo meccanismo di **ricompensa**:
+ **Model as judice (RLAIF)**: seleziona un modello base ospitato da Bedrock come giudice e configura le istruzioni per la valutazione. Utilizzalo per attività soggettive come la moderazione dei contenuti.
**Nota**
L'opzione **Model as judge** della console converte automaticamente la configurazione in una funzione Lambda durante l'allenamento.
+ **Codice personalizzato (RLVR)**: crea funzioni di ricompensa personalizzate utilizzando il codice Python eseguito tramite le funzioni Lambda. Usalo per attività oggettive come la generazione di codice.
Per ulteriori informazioni, consulta [Configurazione delle funzioni di ricompensa per i modelli Amazon Nova](reward-functions.md).
1. (Facoltativo) Nella sezione **Iperparametri**, regolate i parametri di allenamento o utilizzate i valori predefiniti.
1. Nella sezione **Dati di output**, inserisci la posizione Amazon S3 in cui Amazon Bedrock deve salvare gli output del lavoro.
1. Nella sezione **Configurazione del ruolo**, scegli un ruolo esistente dall'elenco a discesa o inserisci un nome per il ruolo di servizio da creare.
1. (Facoltativo) Nella sezione **Configurazione aggiuntiva**, configura i dati di convalida facendo riferimento a un bucket Amazon S3, alle impostazioni di crittografia KMS e ai tag di processo e modello.
1. Scegli **Create reinforcement fine-tuning** job per iniziare il lavoro.
------
#### [ API ]
Invia una CreateModelCustomizationJob richiesta con set to. `customizationType` `REINFORCEMENT_FINE_TUNING`
**Campi obbligatori:** `roleArn``baseModelIdentifier`,`customModelName`,`jobName`,`trainingDataConfig`,`outputDataConfig`, `rftConfig`
**Richiesta di esempio:**
```
{
"roleArn": "arn:aws:iam::123456789012:role/BedrockRFTRole",
"baseModelIdentifier": "amazon.nova-2.0",
"customModelName": "my-rft-model",
"jobName": "my-rft-job",
"customizationType": "REINFORCEMENT_FINE_TUNING",
"trainingDataConfig": {
"s3Uri": "s3://my-bucket/training-data.jsonl"
},
"customizationConfig": {
"rftConfig" : {
"graderConfig": {
"lambdaGrader": {
"lambdaArn": "arn:aws:lambda:us-east-1:123456789012:function:function-name"
}
},
"hyperParameters": {
"batchSize": 64,
"epochCount": 2,
"evalInterval": 10,
"inferenceMaxTokens": 8192,
"learningRate": 0.00001,
"maxPromptLength": 4096,
"reasoningEffort": "high",
"trainingSamplePerPrompt": 4
}
}
},
"outputDataConfig": {
"s3Uri": "s3://my-bucket/rft-output/"
}
}
```
**Richiesta di esempio di API Python:**
```
import boto3
bedrock = boto3.client(service_name='bedrock')
# Set parameters
customizationType = "REINFORCEMENT_FINE_TUNING"
baseModelIdentifier = "arn:aws:bedrock:us-east-1::foundation-model/amazon.nova-2-lite-v1:0:256k"
roleArn = "${your-customization-role-arn}"
jobName = "MyFineTuningJob"
customModelName = "MyCustomModel"
customizationConfig = {
'rftConfig' : {
'graderConfig': {
'lambdaGrader': {
'lambdaArn': 'arn:aws:lambda:us-east-1:123456789012:function:function-name'
}
},
'hyperParameters': {
'batchSize': 64,
'epochCount': 2,
'evalInterval': 10,
'inferenceMaxTokens': 8192,
'learningRate':0.00001,
'maxPromptLength': 4096,
'reasoningEffort': 'high',
'trainingSamplePerPrompt':4
}
}
}
trainingDataConfig = {"s3Uri": "s3://${training-bucket}/myInputData/train.jsonl"}
outputDataConfig = {"s3Uri": "s3://${output-bucket}/myOutputData"}
# Create job
response_ft = bedrock.create_model_customization_job(
jobName=jobName,
customModelName=customModelName,
roleArn=roleArn,
baseModelIdentifier=baseModelIdentifier,
customizationConfig=customizationConfig,
trainingDataConfig=trainingDataConfig,
outputDataConfig=outputDataConfig,
customizationType=customizationType
)
jobArn = response_ft['jobArn']
```
------
## Monitora il tuo lavoro di formazione su RFT
Amazon Bedrock fornisce monitoraggio in tempo reale con grafici e metriche visive durante la formazione RFT. Queste metriche ti aiutano a capire se il modello converge correttamente e se la funzione di ricompensa guida efficacemente il processo di apprendimento.
### Monitoraggio dello stato del lavoro
Puoi monitorare lo stato del tuo lavoro RFT attraverso le fasi di convalida e formazione nella console Amazon Bedrock.
**Indicatori di completamento:**
+ Lo stato del Job passa a **Completato** quando la formazione viene completata con successo
+ Il modello ARN personalizzato diventa disponibile per l'implementazione
+ Le metriche di formazione raggiungono le soglie di convergenza
### Metriche di formazione in tempo reale
Amazon Bedrock fornisce il monitoraggio in tempo reale durante l'addestramento RFT con grafici visivi che mostrano i parametri di formazione e convalida.
#### Metriche di formazione di base
+ **Perdita di formazione**: misura l'efficacia dell'apprendimento del modello dai dati di addestramento
+ **Statistiche sui premi di allenamento**: mostra i punteggi di ricompensa assegnati dalle tue funzioni di ricompensa
+ **Margine di ricompensa**: misura la differenza tra premi di risposta positivi e negativi
+ **Precisione dei set di addestramento e convalida**: mostra le prestazioni del modello sia sui dati di addestramento che su quelli forniti
**Categorie metriche dettagliate**
+ **Metriche dei premi**: `critic/rewards/mean``critic/rewards/max`, `critic/rewards/min` (distribuzione dei premi) e `val-score/rewards/mean@1` (premi di convalida)
+ **Comportamento modello**: `actor/entropy` (variazione delle politiche; più alto equivale a più esplorativo)
+ **Integrità della formazione**: `actor/pg_loss` (perdita del gradiente delle policy), `actor/pg_clipfrac` (frequenza degli aggiornamenti interrotti) e (entità del gradiente) `actor/grad_norm`
+ **Caratteristiche di risposta**:`prompt_length/mean`,`prompt_length/max`, `prompt_length/min` (statistiche sui token di input), `response_length/mean``response_length/max`, (statistiche sui token di output) e `response_length/min` `response/aborted_ratio` (frequenza di generazione incompleta; 0 equivale a tutti i dati completati)
+ **Prestazioni**: `perf/throughput` (velocità di formazione), `perf/time_per_step` (tempo per fase di addestramento) e `timing_per_token_ms/*` (tempi di elaborazione per token)
+ **Utilizzo delle risorse**: `perf/max_memory_allocated_gb` `perf/max_memory_reserved_gb` (memoria GPU) e `perf/cpu_memory_used_gb` (memoria CPU)
#### Visualizzazione dei progressi dell'allenamento
La console mostra grafici interattivi che si aggiornano in tempo reale man mano che il lavoro RFT procede. Queste visualizzazioni possono aiutarti a:
+ Monitora la convergenza verso prestazioni ottimali
+ Identifica tempestivamente potenziali problemi di formazione
+ Determina i punti di sosta ottimali
+ Confronta le prestazioni in epoche diverse
## Imposta l'inferenza
Dopo il completamento del lavoro, implementa il modello RFT per l'inferenza su richiesta o utilizza Provisioned Throughput per prestazioni coerenti. Per impostare l'inferenza, vedere. [Impostazione dell’inferenza per un modello personalizzato](model-customization-use.md)
Usa **Test in Playground** per valutare e confrontare le risposte con il modello base. Per valutare il modello RFT completato, consulta. [Valuta il tuo modello RFT](rft-evaluate-model.md)