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à.
# Valutazione del modello basato sull' SageMaker intelligenza artificiale
Lo scopo del processo è valutare le prestazioni del modello addestrato rispetto a benchmark o set di dati personalizzati. Il processo di valutazione prevede in genere fasi per creare una ricetta di valutazione che punti al modello addestrato, specificare set di dati e metriche di valutazione, inviare un job separato per la valutazione e valutare le prestazioni rispetto a benchmark standard o dati personalizzati. Il processo di valutazione genera i parametri delle prestazioni archiviati nel bucket Amazon S3.
**Nota**
Il processo di valutazione descritto in questo argomento è un processo offline. Il modello viene testato sulla base di benchmark fissi con risposte predefinite, anziché essere valutato in tempo reale o tramite interazioni utente dal vivo. Per una valutazione in tempo reale, puoi testare il modello dopo averlo distribuito su Amazon Bedrock chiamando [Amazon](https://docs.aws.amazon.com//bedrock/latest/userguide/import-with-create-custom-model.html) Bedrock Runtime. APIs
**Topics**
+ [
## Prerequisiti
](#nova-model-evaluation-prerequisites)
+ [
## Attività di benchmarking disponibili
](#nova-model-evaluation-benchmark)
+ [
## Configurazioni specifiche di una valutazione
](#nova-model-evaluation-config)
+ [
## Esecuzione di job di addestramento per la valutazione
](#nova-model-evaluation-notebook)
+ [
## Valutazione e analisi dei risultati della valutazione
](#nova-model-evaluation-assess)
+ [
## Best practice e risoluzione dei problemi di valutazione
](#nova-model-evaluation-best-practices)
+ [
## Sottoattività disponibili
](#nova-model-evaluation-subtasks)
+ [
# Valutazione del modello di ragionamento
](nova-reasoning-model-evaluation.md)
+ [
# Valutazione RFT
](nova-rft-evaluation.md)
+ [
# Implementazione di funzioni premi
](nova-implementing-reward-functions.md)
## Prerequisiti
Prima di avviare un job di addestramento per la valutazione, verifica i seguenti requisiti.
+ Un modello SageMaker Amazon Nova addestrato all'intelligenza artificiale di cui desideri valutarne le prestazioni.
+ Ricetta Amazon Nova di base per la valutazione. Per ulteriori informazioni, consulta [Recupero di ricette Amazon Nova](nova-model-recipes.md#nova-model-get-recipes).
## Attività di benchmarking disponibili
È disponibile un pacchetto di codice di esempio che dimostra come calcolare le metriche di benchmark utilizzando la funzionalità di valutazione del modello SageMaker AI per Amazon Nova. [Per accedere ai pacchetti di codice, consulta sample-N. ova-lighteval-custom-task](https://github.com/aws-samples/sample-Nova-lighteval-custom-task/)
Di seguito è riportato un elenco di benchmark standard di settore disponibili. È possibile specificare i benchmark seguenti nel parametro `eval_task`.
**Benchmark disponibili per la valutazione del modello**
| Benchmark | Modalità | Description | Metriche | Strategia | Sottoattività disponibile |
| --- | --- | --- | --- | --- | --- |
| mmlu | Testo | Massive Multitask Language Understanding (MMLU) - Verifica la conoscenza di 57 materie. | accuratezza | zs\$1cot | Sì |
| mmlu\$1pro | Testo | MMLU - Sottoinsieme professionale - Incentrato su domini professionali come legge, medicina, contabilità e ingegneria. | accuratezza | zs\$1cot | No |
| bbh | Testo | Attività di ragionamento avanzato - Una raccolta di problemi impegnativi che mettono alla prova le capacità cognitive e di risoluzione dei problemi di livello superiore. | accuratezza | fs\$1cot | Sì |
| gpqa | Testo | Risposta a domande di fisica generale - Valuta la comprensione di concetti di fisica e le relative capacità di risoluzione dei problemi. | accuratezza | zs\$1cot | No |
| matematica | Testo | Risoluzione di problemi matematici - Misura il ragionamento matematico su argomenti quali algebra, calcolo e problemi testuali. | exact\$1match | zs\$1cot | Sì |
| strong\$1reject | Testo | Attività di controllo della qualità - Verifica la capacità del modello di rilevare e rifiutare contenuti inappropriati, dannosi o errati. | deflection | zs | Sì |
| ifeval | Testo | Valutazione che segue istruzioni - Misura la precisione con cui un modello segue le istruzioni fornite e completa le attività secondo le specifiche. | accuratezza | zs | No |
| gen\$1qa | Multimodale (immagine) | Valutazione personalizzata del set di dati: consente di fornire il proprio set di dati per il benchmarking, confrontando gli output del modello con le risposte di riferimento con metriche come ROUGE e BLEU. `gen_qa`supporta l'inferenza delle immagini per i modelli basati su Amazon Nova Lite o Amazon Nova Pro. Supporta anche Bring-Your-Own Metrics lambda. (Per la valutazione RFT, usa la ricetta RFT eval) | tutto | gen\$1qa | No |
| mmmu | Multimodale | Massive Multidiscipline Multimodal Understanding (MMMU): benchmark a livello universitario che comprende domande a scelta multipla e domande aperte relative a 30 discipline.) | accuratezza | zs\$1cot | Sì |
| llm\$1judge | Testo | LLM-as-a-Judge Confronto delle preferenze: utilizza un modello Nova Judge per determinare la preferenza tra le risposte accoppiate (B rispetto a A) per i prompt, calcolando la probabilità che B sia preferito ad A. | tutto | judge | No |
| mm\$1llm\$1judge | Multi-Modal (immagine) | Questo nuovo benchmark si comporta allo stesso modo del precedente benchmark basato su testo. `llm_judge` L'unica differenza è che supporta l'inferenza delle immagini. | tutto | judge | No |
| rubric\$1llm\$1judge | Testo | Rubric Judge è un modello di valutazione avanzato LLM-as-a-judge basato su Nova 2.0 Lite. A differenza del [modello di arbitro originale](https://aws.amazon.com/blogs/machine-learning/evaluating-generative-ai-models-with-amazon-nova-llm-as-a-judge-on-amazon-sagemaker-ai/) che fornisce solo verdetti di preferenza, Rubric Judge genera dinamicamente criteri di valutazione personalizzati su misura per ogni richiesta e assegna punteggi granulari su più dimensioni. | tutto | judge | No |
| aime\$12024 | Testo | AIME 2024 - American Invitational Mathematics Examination: problemi relativi alla verifica del ragionamento matematico avanzato e alla risoluzione dei problemi | exact\$1match | zs\$1cot | No |
| calendario\$1pianificazione | Testo | Natural Plan - Calendar - Pianificazione delle attività, test delle attività, capacità di pianificazione per la pianificazione di riunioni su più giorni e più persone | exact\$1match | fs | No |
| humaneval | Testo | HumanEval - Un set di dati di riferimento progettato per valutare le capacità di generazione di codice di modelli linguistici di grandi dimensioni | pass@1 | zs | No |
## Configurazioni specifiche di una valutazione
Di seguito sono riportati i componenti chiave della ricetta e le indicazioni su come modificarli in base ai casi d’uso.
### Comprensione e modifica delle ricette
**Configurazione run generale**
```
run:
name: eval_job_name
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod # or s3://escrow_bucket/model_location
replicas: 1
data_s3_path: ""
mlflow_tracking_uri: ""
mlflow_experiment_name : ""
mlflow_run_name : ""
```
+ `name`: un nome descrittivo per il processo di valutazione.
+ `model_type`: specifica la variante del modello Nova da utilizzare. Non modificare manualmente questo campo. Le opzioni includono:
+ Amazon. nova-micro-v1:01:28 K
+ amazzone. nova-lite-v1:0:300 k
+ amazzone. nova-pro-v1:0:300 k
+ amazon.nova-2-lite-v 1:0:256k
+ `model_name_or_path`: il percorso del modello di base o il percorso S3 per il checkpoint post-addestrato. Le opzioni includono:
+ nova-micro/prod
+ nova-lite/prod
+ nova-pro/prod
+ nova-lite-2/prod
+ Percorso S3 per il percorso di checkpoint post-addestrato (`s3:customer-escrow-111122223333-smtj-/`)
**Nota**
**Valutare un modello post-addestrato**
Per valutare un modello post-addestrato dopo un job di addestramento Nova SFT, segui questa procedura dopo aver eseguito correttamente un job di addestramento. L’addestramento ha esito positivo se alla fine dei log viene visualizzato il messaggio “Training is complete”. Nel bucket di output è inoltre disponibile un file `manifest.json` contenente la posizione del checkpoint. Questo file si trova all’interno di un file `output.tar.gz` nella posizione S3 di output. Per procedere con la valutazione, utilizza questo checkpoint impostandolo come valore per `run.model_name_or_path` nella configurazione della ricetta.
+ `replica`: Il numero di istanze di calcolo da utilizzare per l'inferenza distribuita (esecuzione dell'inferenza su più nodi). Imposta `replica` > 1 per abilitare l'inferenza multinodo, che accelera la valutazione. Se `replica` vengono specificati entrambi `instance_count` e, `instance_count` ha la precedenza. Tieni presente che le repliche multiple si applicano solo ai lavori di formazione SageMaker sull'intelligenza artificiale, non.
+ `data_s3_path`: percorso Amazon S3 del set di dati di input. Questo campo è obbligatorio, ma deve essere sempre lasciato vuoto.
+ `mlflow_tracking_uri`: (Facoltativo) La posizione del server di MLflow tracciamento (necessaria solo su SMHP)
+ `mlflow_experiment_name`: (Facoltativo) Nome dell'esperimento per raggruppare insieme le esecuzioni ML correlate
+ `mlflow_run_name`: (Facoltativo) Nome personalizzato per un corso di formazione specifico all'interno di un esperimento
**Configurazione evaluation**
```
evaluation:
task: mmlu
strategy: zs_cot
subtask: abstract_algebra
metric: accuracy
```
+ `task`: specifica il benchmark o l’attività di valutazione da utilizzare. Le attività supportate includono:
+ `mmlu`
+ `mmlu_pro`
+ `bbh`
+ `gpqa`
+ `math`
+ `strong_reject`
+ `gen_qa`
+ `ifeval`
+ `mmmu`
+ `llm_judge`
+ `mm_llm_judge`
+ `rubric_llm_judge`
+ `aime_2024`
+ `calendar_scheduling`
+ `humaneval`
+ `strategy`: definisce l’approccio di valutazione.
+ `zs_cot`: Zero-shot Chain of Thought: un approccio per suggerire modelli linguistici di grandi dimensioni che incoraggia il step-by-step ragionamento senza richiedere esempi espliciti.
+ `fs_cot`: Few-shot Chain of Thought: un approccio che fornisce alcuni esempi di step-by-step ragionamento prima di chiedere al modello di risolvere un nuovo problema.
+ `zs`: Zero-shot - Un approccio per risolvere un problema senza esempi di addestramento precedenti.
+ `gen_qa`: strategia specifica per utilizzare un set di dati personalizzato.
+ `judge`: Strategia specifica per Nova LLM come giudice e. `mm_llm_judge`
+ `subtask`: facoltativo. Componenti specifici dell’attività di valutazione. Per un elenco completo delle sottoattività disponibili, consulta [Sottoattività disponibili](#nova-model-evaluation-subtasks).
+ Controlla le sottoattività supportate in Attività di benchmarking disponibili.
+ Se non sono presenti benchmark per sottoattività, è consigliabile rimuovere questo campo.
+ `metric`: la metrica di valutazione da utilizzare.
+ `accuracy`: percentuale di risposte corrette.
+ `exact_match`: per il benchmark math, restituisce la velocità con cui le stringhe previste nell’input corrispondono esattamente ai loro riferimenti.
+ `deflection`: per il benchmark strong reject, restituisce la deviazione relativa rispetto al modello di base e la differenza nelle metriche di significatività.
+ `all`:
Per un benchmark Bring Your Own Dataset e `gen_qa`, restituisce le seguenti metriche:
+ `rouge1`: misura la sovrapposizione di unigrammi (parole singole) tra il testo generato e quello di riferimento.
+ `rouge2`: misura la sovrapposizione di bigrammi (due parole consecutive) tra il testo generato e quello di riferimento.
+ `rougeL`: misura la sottosequenza comune più lunga tra testi, tenendo conto di lacune nella corrispondenza.
+ `exact_match`: punteggio binario (0 oppure 1) che indica se il testo generato corrisponde esattamente al testo di riferimento, carattere per carattere.
+ `quasi_exact_match`: simile alla corrispondenza esatta, ma meno rigida, in genere ignora le differenze tra maiuscole e minuscole, punteggiatura e spazi.
+ `f1_score`: media armonica di precisione e richiamo, che misura la sovrapposizione di parole tra le risposte previste e quelle di riferimento.
+ `f1_score_quasi`: simile a f1\$1score, ma con una corrispondenza meno rigida, utilizza un confronto di testo normalizzato che ignora differenze minori.
+ `bleu`: misura la precisione delle corrispondenze in n-grammi tra il testo generato e quello di riferimento, comunemente utilizzate nella valutazione delle traduzioni.
Inoltre `llm_judge``mm_llm_judge`, porta il tuo benchmark del set di dati, restituisci le seguenti metriche:
+ `a_scores`: numero di vittorie per `response_A` nei passaggi di valutazione avanti e indietro.
+ `a_scores_stderr`: errore standard di `response_A_scores` nei giudizi a coppie.
+ `b_scores`: misura il numero di vittorie per `response_B` nei passaggi di valutazione avanti e indietro.
+ `a_scores_stderr`: errore standard di `response_B_scores` nei giudizi a coppie.
+ `ties`: numero di giudizi in cui `response_A` e `response_B` sono valutati in modo uguale.
+ `ties_stderr`: errore standard di `ties` nei giudizi a coppie.
+ `inference_error`: numero di giudizi che non è stato possibile valutare correttamente.
+ `score`: punteggio aggregato basato sulle vittorie nei passaggi avanti e indietro per `response_B`.
+ `score_stderr`: punteggio aggregato basato sulle vittorie nei passaggi avanti e indietro per `response_B`.
+ `inference_error_stderr`: errore standard del punteggio aggregato nei giudizi a coppie.
+ `winrate`: la probabilità che `response_B` venga preferito rispetto a `response_A` calcolato utilizzando la probabilità di Bradley-Terry.
+ `lower_rate`: limite inferiore (percentile 2,5) del tasso di successo stimato derivante dal campionamento bootstrap.
+ `upper_rate`: limite superiore (percentile 97,5) del tasso di successo stimato derivante dal campionamento bootstrap.
**Configurazione inference (facoltativa)**
```
inference:
max_new_tokens: 2048
top_k: -1
top_p: 1.0
temperature: 0
top_logprobs: 10
reasoning_effort: null # options: low/high to enable reasoning or null to disable reasoning
```
+ `max_new_tokens`: numero massimo di token da generare. Deve essere un numero intero. Non disponibile per LLM-as-a-judge.
+ `top_k`: numero di token con la più alta probabilità da considerare. Deve essere un numero intero.
+ `top_p`: soglia di probabilità cumulativa per il campionamento tramite token. Deve essere un valore decimale compreso tra 1,0 e 0,0.
+ `temperature`: casualità nella selezione dei token (valore più alto = casualità maggiore), mantieni il valore pari a 0 per rendere il risultato deterministico. Tipo decimale, il valore minimo è 0.
+ `top_logprobs`: Il numero di migliori logprobs da restituire nella risposta di inferenza. Questo valore deve essere un numero intero compreso tra 0 e 20. I logprobs contengono i token di output considerati e le probabilità di registro di ogni token di output restituito nel contenuto del messaggio.
+ `reasoning_effort`: controlla il comportamento di ragionamento per modelli in grado di ragionare. Imposta `reasoning_effort` solo quando `model_type` specifica un modello in grado di ragionare (attualmente). `amazon.nova-2-lite-v1:0:256k` Le opzioni disponibili sono nulle (valore predefinito se non impostato; disabilita il ragionamento), basse o alte.
### Formato di output logaritmico
Se `top_logprobs` configurato nelle impostazioni di inferenza, l'output di valutazione include le probabilità di registro a livello di token nei file parquet. Ogni posizione del token contiene un dizionario dei migliori token candidati con le relative probabilità di registro nella seguente struttura:
```
{
"Ġint": {"logprob_value": -17.8125, "decoded_value": " int"},
"Ġthe": {"logprob_value": -2.345, "decoded_value": " the"}
}
```
Ogni voce del token contiene:
+ `logprob_value`: Il valore di probabilità logaritmica per il token
+ `decoded_value`: La rappresentazione di stringa decodificata leggibile dall'uomo del token
Il token tokenizer non elaborato viene utilizzato come chiave del dizionario per garantire l'unicità, fornendo al contempo un'interpretazione leggibile. `decoded_value`
### Esempi di ricette di valutazione
Amazon Nova offre quattro diversi tipi di ricette di valutazione. [Tutte le ricette sono disponibili nell'archivio delle ricette. SageMaker HyperPod GitHub ](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection)
**Topics**
#### Ricette di benchmark testuali generali
Queste ricette consentono di valutare le funzionalità fondamentali dei modelli Amazon Nova attraverso una suite completa di benchmark di solo testo.
Formato della ricetta: `xxx_general_text_benchmark_eval.yaml`.
#### Ricette di benchmark Bring Your Own Dataset
Queste ricette consentono di utilizzare un set di dati personalizzato per il benchmarking e confrontare i risultati del modello con risposte di riferimento utilizzando diversi tipi di metriche.
Formato della ricetta: `xxx_ bring_your_own_dataset_eval.yaml`.
**Requisiti Bring Your Own Dataset**
Formato del file:
+ Singolo file `gen_qa.jsonl` contenente esempi di valutazione. Il nome del file deve essere esattamente `gen_qa.jsonl`.
+ È necessario caricare il set di dati in una posizione S3 a cui possano accedere i lavori di formazione SageMaker sull'intelligenza artificiale.
+ Il file deve seguire il formato dello schema richiesto per il set di dati Q&A generale.
Requisiti del formato dello schema: ogni riga del `.jsonl` file deve essere un oggetto JSON con i seguenti campi.
+ Campi obbligatori.
`query`: stringa contenente la domanda o l’istruzione che richiede una risposta.
`response`: stringa contenente l’output del modello previsto.
+ Campi facoltativi.
`system`: stringa contenente il prompt di sistema che imposta il comportamento, il ruolo o la personalità del modello di intelligenza artificiale prima che elabori la query.
`images`: Array contenente un elenco di oggetti con attributi di dati (stringhe di immagini codificate in Base64).
`metadata`: Stringa contenente i metadati associati alla voce a scopo di etichettatura.
**Esempio di inserimento**
```
{
"system":"You are an English major with top marks in class who likes to give minimal word responses: ",
"query":"What is the symbol that ends the sentence as a question",
"response":"?"
}{
"system":"You are a pattern analysis specialist who provides succinct answers: ",
"query":"What is the next number in this series? 1, 2, 4, 8, 16, ?",
"response":"32"
}{
"system":"You have great attention to detail and follow instructions accurately: ",
"query":"Repeat only the last two words of the following: I ate a hamburger today and it was kind of dry",
"response":"of dry"
}{
"system": "Image inference: ",
"query": "What is the number in the image? Please just use one English word to answer.",
"response": "two",
"images": [
{
"data": "data:image/png;Base64,iVBORw0KGgoA ..."
}
]
}
```
Per utilizzare il set di dati personalizzato, modifica la ricetta di valutazione aggiungendo i seguenti campi obbligatori senza modificare la configurazione esistente:
```
evaluation:
task: gen_qa
strategy: gen_qa
metric: all
```
**Limitazioni**
+ È consentito un solo file `.jsonl` per valutazione.
+ Il file deve seguire rigorosamente lo schema definito.
##### Porta le tue metriche
Puoi utilizzare le tue metriche per personalizzare completamente il flusso di lavoro di valutazione del modello con funzionalità di preelaborazione, postelaborazione e metriche personalizzate. La preelaborazione consente di elaborare i dati di input prima di inviarli al server di inferenza, mentre la postelaborazione consente di personalizzare il calcolo delle metriche e restituire metriche personalizzate in base alle proprie esigenze.
Segui questi passaggi per utilizzare le tue metriche con un SDK di valutazione personalizzato.
1. Se non l'hai ancora fatto, [crea prima una AWS Lambda funzione](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html). Account AWS
1. Scarica il `nova-custom-eval-layer.zip` file predefinito dal [GitHub repository](https://github.com/aws/nova-custom-eval-sdk/releases). Puoi utilizzare questo SDK di valutazione personalizzato Nova open source per convalidare i payload di input e output per la tua funzione personalizzata e fornire un'interfaccia unificata per l'integrazione con la valutazione delle metriche Bring your own di Nova durante la formazione.
1. Carica il layer Lambda personalizzato utilizzando il seguente comando:
```
aws lambda publish-layer-version \
--layer-name nova-custom-eval-layer \
--zip-file fileb://nova-custom-eval-layer.zip \
--compatible-runtimes python3.12 python3.11 python3.10 python3.9
```
1. Aggiungi questo livello come livello personalizzato alla tua funzione Lambda, insieme al AWS livello richiesto: `AWSLambdaPowertoolsPythonV3-python312-arm64` (richiesto per la `pydantic` dipendenza).
1. Aggiorna il codice Lambda utilizzando l'esempio fornito, modificando il codice secondo necessità. Questo codice di esempio crea una funzione Lambda per la valutazione personalizzata di Nova con fasi di preelaborazione e post-elaborazione per la valutazione del modello.
```
from nova_custom_evaluation_sdk.processors.decorators import preprocess, postprocess
from nova_custom_evaluation_sdk.lambda_handler import build_lambda_handler
@preprocess
def preprocessor(event: dict, context) -> dict:
data = event.get('data', {})
return {
"statusCode": 200,
"body": {
"system": data.get("system"),
"prompt": data.get("prompt", ""),
"gold": data.get("gold", "")
}
}
@postprocess
def postprocessor(event: dict, context) -> dict:
# data is already validated and extracted from event
data = event.get('data', [])
inference_output = data.get('inference_output', '')
gold = data.get('gold', '')
metrics = []
inverted_accuracy = 0 if inference_output.lower() == gold.lower() else 1.0
metrics.append({
"metric": "inverted_accuracy_custom",
"value": accuracy
})
# Add more metrics here
return {
"statusCode": 200,
"body": metrics
}
# Build Lambda handler
lambda_handler = build_lambda_handler(
preprocessor=preprocessor,
postprocessor=postprocessor
)
```
1. Concedi a Lambda l'accesso al processo di valutazione. Assicurati che il ruolo di esecuzione specificato per il processo di valutazione includa una policy per richiamare la tua funzione Lambda. Ecco una policy di esempio:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "LambdaAccess",
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:ExampleFunction",
"Condition": {
"StringLike": {
"aws:PrincipalArn": "arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-ARN"
}
}
},
{
"Sid": "DenyNonAWSEventSourcesForLambda",
"Effect": "Deny",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:ExampleFunction",
"Condition": {
"Null": {
"lambda:EventSourceToken": false
}
}
}
]
}
```
------
1. Esamina lo schema del payload Lambda. La tabella seguente elenca lo schema di richiesta e risposta Lambda. Puoi convalidare lo schema utilizzando l'SDK di valutazione personalizzato Nova.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/nova/latest/nova2-userguide/nova-model-evaluation.html)
1. Modificate il file della ricetta. Ecco un esempio.
```
processor:
lambda_arn: arn:aws:lambda:us-east-1:111122223333:function:name
lambda_type: "custom_metrics"
preprocessing:
enabled: true
postprocessing:
enabled: true
aggregation: average
```
+ `lambda-arn`: Amazon Resource Name (ARN) per la tua funzione Lambda che gestisce la preelaborazione e la postelaborazione.
+ `lambda_type`: «custom\$1metrics» o «rft».
+ `preprocessing`: Se abilitare le operazioni di preelaborazione personalizzate.
+ `postprocessing`: Se abilitare le operazioni di post-elaborazione personalizzate.
+ `aggregation`: Funzione di aggregazione integrata (opzioni valide: min, max, average, sum).
**Limitazioni**
+ Le metriche Bring your own si applicano solo ai set di dati di input di testo.
+ I set di dati di input multimodali non sono supportati.
+ La fase di preelaborazione non elabora il campo dei metadati.
#### Ricette di benchmark Nova LLM-as-a-judge
Nova LLM Judge è una funzionalità di valutazione del modello che consente di confrontare la qualità delle risposte di un modello con le risposte del modello di base utilizzando un set di dati personalizzato. Accetta un set di dati contenente prompt, risposte di base e risposte di richiesta di verifica, quindi utilizza un modello Nova Judge per fornire una metrica del tasso di successo basata sulla probabilità di [Bradley-Terry](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) con confronti a coppie. Formato della ricetta: `xxx_llm_judge_eval.yaml`.
**Requisiti dei set di dati Nova LLM**
Formato del file:
+ Singolo file `llm_judge.jsonl` contenente esempi di valutazione. Il nome del file deve essere esattamente `llm_judge.jsonl`.
+ Devi caricare il set di dati in una sede S3 a cui possono accedere i lavori di formazione sull' SageMaker intelligenza artificiale.
+ Il file deve seguire il formato dello schema richiesto per il set di dati `llm_judge`.
+ Il set di dati di input deve garantire che tutti i record abbiano una lunghezza di contesto inferiore a 12.000.
Formato dello schema - Ogni riga del file `.jsonl` deve essere un oggetto JSON con i campi seguenti.
+ Campi obbligatori.
`prompt`: stringa contenente il prompt per la risposta generata.
`response_A`: stringa contenente la risposta di base.
`response_B`: stringa contenente la risposta alternativa da confrontare con la risposta di base.
Esempio di inserimento
```
{
"prompt": "What is the most effective way to combat climate change?",
"response_A": "The most effective way to combat climate change is through a combination of transitioning to renewable energy sources and implementing strict carbon pricing policies. This creates economic incentives for businesses to reduce emissions while promoting clean energy adoption.",
"response_B": "We should focus on renewable energy. Solar and wind power are good. People should drive electric cars. Companies need to pollute less."
}
{
"prompt": "Explain how a computer's CPU works",
"response_A": "CPU is like brain of computer. It does math and makes computer work fast. Has lots of tiny parts inside.",
"response_B": "A CPU (Central Processing Unit) functions through a fetch-execute cycle, where instructions are retrieved from memory, decoded, and executed through its arithmetic logic unit (ALU). It coordinates with cache memory and registers to process data efficiently using binary operations."
}
{
"prompt": "How does photosynthesis work?",
"response_A": "Plants do photosynthesis to make food. They use sunlight and water. It happens in leaves.",
"response_B": "Photosynthesis is a complex biochemical process where plants convert light energy into chemical energy. They utilize chlorophyll to absorb sunlight, combining CO2 and water to produce glucose and oxygen through a series of chemical reactions in chloroplasts."
}
```
Per utilizzare un set di dati personalizzato, modifica la ricetta di valutazione con i seguenti campi obbligatori, senza modificare alcun contenuto:
```
evaluation:
task: llm_judge
strategy: judge
metric: all
```
**Limitazioni**
+ È consentito un solo file `.jsonl` per valutazione.
+ Il file deve seguire rigorosamente lo schema definito.
+ I modelli Nova Judge sono gli stessi per quanto riguarda le specifiche Micro/Lite/Pro.
+ Attualmente i modelli Judge personalizzati non sono supportati.
##### Nova LLM in qualità di giudice per le ricette di riferimento multimodali (immagini)
Nova LLM Judge for multi-modal (immagine), abbreviazione di Nova MM\$1LLM Judge, è una funzionalità di valutazione del modello che consente di confrontare la qualità delle risposte di un modello con le risposte di un modello di base utilizzando un set di dati personalizzato. Accetta un set di dati contenente prompt, risposte di base e risposte challenger e immagini sotto forma di stringa codificata in Base64, quindi utilizza un modello Nova Judge per fornire una metrica del tasso di vittoria basata sulla probabilità di [Bradley-Terry](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) attraverso confronti a coppie. Formato della ricetta: `xxx_mm_llm_judge_eval.yaml`.
**Requisiti dei set di dati Nova LLM**
Formato del file:
+ Singolo file `mm_llm_judge.jsonl` contenente esempi di valutazione. Il nome del file deve essere esatto. `llm_judge.jsonl`
+ Devi caricare il set di dati in una posizione S3 a cui i responsabili della formazione sull' SageMaker intelligenza artificiale possano accedervi.
+ Il file deve seguire il formato dello schema richiesto per il set di dati `mm_llm_judge`.
+ Il set di dati di input dovrebbe garantire che tutti i record abbiano una lunghezza di contesto inferiore a 12 k, escluso l'attributo dell'immagine.
Formato dello schema - Ogni riga del file `.jsonl` deve essere un oggetto JSON con i campi seguenti.
+ Campi obbligatori.
`prompt`: stringa contenente il prompt per la risposta generata.
`images`: Array contenente un elenco di oggetti con attributi di dati (i valori sono stringhe di immagine codificate in Base64).
`response_A`: stringa contenente la risposta di base.
`response_B`: stringa contenente la risposta alternativa da confrontare con la risposta di base.
Esempio di inserimento
Per motivi di leggibilità, l'esempio seguente include nuove righe e rientri, ma nel set di dati effettivo, ogni record deve trovarsi su una sola riga.
```
{
"prompt": "What is in the image?",
"images": [
{
"data": "data:image/jpeg;Base64,/9j/2wBDAAQDAwQDAwQEAwQFBAQFBgo..."
}
],
"response_A": "a dog.",
"response_B": "a cat.",
}
{
"prompt": "How many animals are in each of the images?",
"images": [
{
"data": "data:image/jpeg;Base64,/9j/2wBDAAQDAwQDAwQEAwQFBAQFBgo..."
},
{
"data": "data:image/jpeg;Base64,/DKEafe3gihn..."
}
],
"response_A": "The first image contains one cat and the second image contains one dog",
"response_B": "The first image has one aminal and the second has one animal"
}
```
Per utilizzare un set di dati personalizzato, modifica la ricetta di valutazione con i seguenti campi obbligatori, senza modificare alcun contenuto:
```
evaluation:
task: mm_llm_judge
strategy: judge
metric: all
```
**Limitazioni**
+ È consentito un solo file `.jsonl` per valutazione.
+ Il file deve seguire rigorosamente lo schema definito.
+ I modelli Nova MM Judge supportano solo il riferimento alle immagini.
+ I modelli Nova MM Judge sono gli stessi per tutte le specifiche di Amazon Nova Micro, Amazon Nova Lite e Amazon Nova Pro.
+ Attualmente i modelli Judge personalizzati non sono supportati.
+ L'URI di immagine Amazon S3 non è supportato.
+ Il set di dati di input dovrebbe garantire che tutti i record abbiano una lunghezza di contesto inferiore a 12 k, escluso l'attributo images.
#### Valutazione dei punti di controllo CPT (pre-formazione continua)
La valutazione dei modelli CPT (Continuous Pre-Training) può essere più difficoltosa rispetto ai modelli sottoposti a SFT (supervised fine tuning), in quanto i modelli CPT spesso non sono in grado di seguire le istruzioni. Invece di seguire le istruzioni, i modelli CPT funzioneranno come modelli di completamento, il che significa che cercheranno solo di continuare lo schema fornito con la sequenza dei token di input. Data questa limitazione, i set di dati di valutazione tipici potrebbero non funzionare correttamente a causa del formato «Q&A» degli input: invece di rispondere alla domanda, il modello cercherà semplicemente di continuare con la stessa domanda. Tuttavia, formattando i set di dati in un modo specifico per richiedere ai modelli uno stile di completamento, possiamo comprendere le prestazioni del modello.
Segui i passaggi seguenti per capire come eseguire una valutazione su un modello continuo preaddestrato utilizzando il flusso di lavoro di valutazione di Nova Forge.
##### Preparazione e formattazione dei set di dati
La valutazione di un modello CPT sfrutta il flusso di lavoro [Bring Your Own Dataset](#nova-model-evaluation-config-byo) già esistente già fornito nell'esperienza di valutazione del modello Nova Forge. Tuttavia, le query all'interno del set di dati devono essere formattate in un formato puramente «di completamento» poiché i modelli CPT non risponderanno alle richieste standard in stile domanda nello stesso modo in cui farebbe un modello SFT.
Un'altra importante limitazione frequente dei modelli sottoposti esclusivamente al CPT è la loro incapacità di generare token STOP o di fine sequenza: ciò significa che il modello continuerà a generare token fino a quando non verrà interrotto con forza (come con il parametro max\$1new\$1tokens). Data questa limitazione, la migliore pratica consiste nel valutare i modelli utilizzando risposte a token singolo (come la scelta multipla) per garantire che il modello non continui a generare output indesiderati che non sono necessari dopo la richiesta.
Ad esempio, un tipico set di dati di valutazione (come MMLU, GPQA, MATH, ecc.) potrebbe porre al modello una domanda come:
```
Early settlements and high population density along coastlines and rivers are
best attributed to which of the following?
A: "Poor climate conditions"
B: "Limited forest cover"
C: "Cars"
D: "Access to trade routes"
(Expected answer is D.)
```
Tuttavia, un modello CPT non capirebbe come rispondere correttamente a questa domanda a causa della mancanza di una regolazione precisa delle istruzioni che seguono. Pertanto, i modelli CPT devono essere richiesti con uno stile di completamento, ad esempio:
```
Early settlements and high population density along coastlines and rivers
are best attributed to which of the following?
A: Poor climate conditions
B: Limited forest cover
C: Cars
D: Access to trade routes
The correct answer to this question is option
(Expected answer is D.)
```
Dopo il controllo dell'inferenza, i logprobs di output generati dal modello forniranno dettagli sul fatto che il modello stia elaborando correttamente l'input e generando la risposta corretta. Non è garantito che il modello produca sempre la risposta esatta (in questo caso, la lettera D) prevista, tuttavia dovrebbe essere presente all'interno dei logprobs se il modello funziona correttamente.
Un altro esempio di prompt di stile di completamento non a scelta multipla:
```
The capital of France is
(Expected answer of Paris)
```
Ci aspetteremmo che il modello produca una risposta di «Paris» o veda il token corrispondente a «Paris» da qualche parte nell'output di logprobs.
##### Formattazione del set di dati
La valutazione CPT sfrutta il flusso di lavoro esistente di [Bring Your Own](#nova-model-evaluation-config-byo) Dataset. I dati devono essere formattati nel formato «risposta alla query» in un file JSONL separato da nuove righe.
Un esempio di set di dati contenente 4 voci:
```
{"query": "The capital of France is", "response": "Paris"}
{"query": "2 + 2 =", "response": "4"}
{"query": "The mitochondria is the powerhouse of the", "response": "cell"}
{"query": "What is the largest planet?\nA: Mars\nB: Jupiter\nC: Saturn\nD: Earth\nAnswer:", "response": "B"}
```
Ogni riga deve contenere:
+ `query`: Il testo richiesto per il completamento
+ `response`: Il completamento previsto (verità fondamentale)
Il modello riceverà un input di testo non elaborato senza formattazione della chat. I modelli CPT in genere non sono ancora addestrati su token speciali e non rispondono correttamente ai modelli di chat, quindi quando viene richiesta al modello SOLO la stringa fornita nella query verrà inviata al modello (con un `[BOS]` token aggiuntivo aggiunto automaticamente).
##### Configurazione della ricetta
Ecco un esempio di ricetta configurata per valutare un modello CPT:
```
run:
name: cpt_eval_job
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: s3://bucket/path/to/cpt-checkpoint/
evaluation:
task: gen_qa # Required for CPT - bring your own dataset
strategy: gen_qa
metric: all # Returns rouge1, rouge2, rougeL, exact_match, f1_score, bleu
inference:
checkpoint_is_instruction_tuned: "false" # Required for CPT checkpoints
top_logprobs: 5 # Change to desired amount of logprobs to calculate
max_new_tokens: 1 # Keep low for completion tasks
temperature: 0.0
```
Modifiche chiave per la valutazione CPT:
+ `checkpoint_is_instruction_tuned: "false"`
Si tratta di un nuovo parametro aggiunto specificamente per supportare le esecuzioni di valutazione sui checkpoint CPT. L'impostazione di checkpoint\$1is\$1instruction\$1tuned su false **disabiliterà** il modello di chat Amazon Nova predefinito che normalmente include il prompt di input.
+ `top_logprobs: 5`
Le probabilità di log (logprobs) rivelano la distribuzione della fiducia del modello tra i possibili token next, aiutandoti a valutare se il modello ha appreso i completamenti previsti durante il pre-addestramento. In genere, se il modello funziona come previsto, dovremmo vedere la risposta prevista (ad esempio, «A», «B», ecc.) come token di output generato o come token nei logprobs.
+ `max_new_tokens: 1`
I modelli CPT in genere non sono ancora stati addestrati a generare speciali token «stop» o «end of sequence» per segnalare quando interrompere l'inferenza. Ciò significa che il modello in genere continuerà a generare nuovi token fino al raggiungimento della lunghezza massima specifica del token, con conseguente inferenza non necessaria. In genere, limitare max\$1new\$1tokens a 1 e fornire un prompt in grado di valutare il modello in base a una singola risposta (come una domanda a scelta multipla) è il modo più efficiente per richiedere il modello. L'impostazione di max\$1new\$1tokens su 1 garantisce che non vengano generati token spazzatura aggiuntivi.
##### Parametri chiave
+ **checkpoint\$1is\$1instruction\$1tuned: deve essere impostato su (o come booleano**) per disabilitare i modelli di chat `"false"` `false`
+ **top\$1logprobs**: 5, consigliato per vedere come il modello sta imparando durante il CPT
+ **compito**: Deve essere: i modelli CPT non possono utilizzare `gen_qa` benchmark che seguono le istruzioni come MMLU o MATH
+ **strategia**: Deve essere `gen_qa`
+ **max\$1new\$1tokens**: si consiglia di mantenere un valore basso (1-5) poiché i modelli CPT eseguono il completamento, non la generazione
## Esecuzione di job di addestramento per la valutazione
Inizia un processo di formazione utilizzando il seguente taccuino di esempio. Fate riferimento al seguente taccuino come esempio per eseguire il processo di formazione di valutazione. Per ulteriori informazioni, consulta [Utilizzare uno stimatore di SageMaker intelligenza artificiale per eseguire un processo di formazione](https://docs.aws.amazon.com//sagemaker/latest/dg/docker-containers-adapt-your-own-private-registry-estimator.html).
### Tabelle di riferimento
Prima di eseguire il notebook, fai riferimento alle seguenti tabelle di riferimento per selezionare l’URI delle immagini e le configurazioni delle istanze.
**Selezione dell’URI delle immagini**
| Recipe | URI immagine |
| --- | --- |
| URI delle immagini di valutazione | 708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-TJ-Eval-V2-latest |
**Selezione del tipo e del numero di istanze**
| Modello | Tipo di processo | Tipo di istanza | Numero di istanze consigliato | Numero di istanze consentito |
| --- | --- | --- | --- | --- |
| Amazon Nova Micro | Valutazione (SFT/DPO) | g5.12xlarge | 1 | 1 - 16 |
| Amazon Nova Lite | Valutazione (SFT/DPO) | g5.12xlarge | 1 | 1 - 16 |
| Amazon Nova Pro | Valutazione (SFT/DPO) | p5.48xlarge | 1 | 1 - 16 |
### Notebook di esempio
Il seguente notebook di esempio mostra come eseguire un job di addestramento per la valutazione.
```
# install python SDK
# Do not use sagemaker v3, as sagemaker v3 introduced breaking changes
!pip install sagemaker==2.254.1
import os
import sagemaker,boto3
from sagemaker.inputs import TrainingInput
from sagemaker.pytorch import PyTorch
sagemaker_session = sagemaker.Session()
role = sagemaker.get_execution_role()
# Download recipe from https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/evaluation/nova to local
# Assume the file name be `recipe.yaml`
# Populate parameters
# input_s3_uri = "s3:///input/" # (Optional) Only used for multi-modal dataset or bring your own dataset s3 location
output_s3_uri= "s3:///output/" # Output data s3 location, a zip containing metrics json and tensorboard metrics files will be stored to this location
instance_type = "instance_type" # ml.g5.16xlarge as example
instance_count = 1 # The number of instances for inference (set instance_count > 1 for multi-node inference to accelerate evaluation)
job_name = "your job name"
recipe_path = "recipe path" # ./recipe.yaml as example
image_uri = "708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-TJ-Eval-V2-latest" # Do not change
output_kms_key = "" # optional, leave blank for Amazon managed encryption
# (Optional) To bring your own dataset and LLM judge for evaluation
# evalInput = TrainingInput(
# s3_data=input_s3_uri,
# distribution='FullyReplicated',
# s3_data_type='S3Prefix'
#)
estimator = PyTorch(
output_path=output_s3_uri,
base_job_name=job_name,
role=role,
instance_type=instance_type,
instance_count=instance_count,
training_recipe=recipe_path,
sagemaker_session=sagemaker_session,
image_uri=image_uri,
output_kms_key=output_kms_key
)
estimator.fit()
# If input dataset exist, pass in inputs
# estimator.fit(inputs={"train": evalInput})
```
## Valutazione e analisi dei risultati della valutazione
Una volta completato correttamente il processo di valutazione, è possibile valutare e analizzare i seguendo questa procedura.
**Per valutare e analizzare i risultati, procedi nel seguente modo.**
1. Comprendi la struttura della posizione di output. I risultati vengono archiviati nella posizione di output specificata di Amazon S3 come file compresso:
```
s3://your-bucket/output/benchmark-name/
└── job_name/
└── output/
└── output.tar.gz
```
1. Scarica il file `output.tar.gz` dal bucket. Estrai il contenuto per visualizzarlo.
```
run_name/
├── eval_results/
| └── results_[timestamp].json
│ └── inference_output.jsonl (only present for gen_qa)
| └── details/
| └── model/
| └── /
| └──details__#_.parquet
└── tensorboard_results/
└── eval/
└── events.out.tfevents.[timestamp]
```
+ `results_[timestamp].json` - File JSON delle metriche di output
+ `details__#_.parquet` - File di output di inferenza (ad eccezione di `strong_reject`)
+ `events.out.tfevents.[timestamp]`- file TensorBoard di output
+ `inference_output.jsonl` - File di output di inferenza pulito (solo per attività `gen_qa`)
1. Visualizza i risultati in TensorBoard. Per visualizzare le metriche di valutazione:
1. Carica la cartella estratta in un bucket S3
1. Passa all' SageMaker IA TensorBoard
1. Seleziona “Cartelle S3”
1. Aggiungi il percorso della cartella S3
1. Attendi il completamento della sincronizzazione
1. Analizza gli output di inferenza. Tutte le attività di valutazione, tranne `llm_judge` e `strong_reject`, includono i seguenti campi per l’analisi nell’output dell’inferenza.
+ `full_prompt`- Il prompt utente completo inviato al modello utilizzato per l'attività di valutazione.
+ `gold`- Il campo che contiene le risposte corrette come specificato dal set di dati.
+ `metrics`- Il campo che contiene le metriche valutate sulla singola inferenza. I valori che richiedono l’aggregazione non hanno un valore sui singoli output di inferenza.
+ `predictions`- Il campo che contiene un elenco dell'output del modello per il prompt specificato.
+ `pred_logits`- Il campo che contiene i token di output considerati e le probabilità di registro di ogni token di output restituito nel contenuto del messaggio.
Esaminando questi campi, è possibile determinare la causa delle differenze nelle metriche e comprendere il comportamento dei modelli personalizzati.
Per `llm_judge`, il file di output dell’inferenza contiene i seguenti campi nel campo delle metriche per coppia di valutazioni.
+ `forward_output` - Le preferenze non elaborate di Judge durante la valutazione nell’ordine diretto (response\$1A, response\$1B).
+ `backward_output` - Le preferenze non elaborate di Judge durante la valutazione nell’ordine inverso (response\$1B, response\$1A).
+ `Pairwise metrics` - Metriche calcolate per coppia di valutazioni avanti e indietro, tra cui `a_scores`, `b_scores`, `ties`, `inference-score` e `score`.
**Nota**
Metriche aggregate come `winrate` sono disponibili solo nei file dei risultati di riepilogo, non basate su giudizi individuali.
Per `gen_qa`, il file `inference_output.jsonl` contiene i seguenti campi per ogni oggetto JSON:
+ prompt - Il prompt finale inviato al modello
+ inference - L’output di inferenza non elaborato del modello
+ gold - La risposta target dal set di dati di input
+ metadata - La stringa di metadati del set di dati di input, se fornita
## Best practice e risoluzione dei problemi di valutazione
### Best practice
Di seguito sono elencate alcune best practice per il processo di valutazione.
+ Mantieni i percorsi di output organizzati per modello e tipo di benchmark.
+ Mantieni convenzioni di denominazione coerenti per semplificare il monitoraggio.
+ Salva i risultati estratti in una posizione sicura.
+ Monitora lo stato di TensorBoard sincronizzazione per il corretto caricamento dei dati.
### Risoluzione dei problemi
È possibile utilizzare CloudWatch il gruppo di log `/aws/sagemaker/TrainingJobs` per addestrare i registri degli errori dei processi.
#### Guasto al nucleo del motore
**Problema:**
Se stai vedendo:
```
RuntimeError: Engine core initialization failed.
```
**Causa:**
Sebbene si tratti di un errore generale che può avere più cause, in genere si verifica quando c'è una mancata corrispondenza tra il checkpoint del modello che stai tentando di caricare e il tipo di modello specificato. Ad esempio, volete valutare un checkpoint del modello Nova 2.0 lite ottimizzato, ma il tipo di modello fornito è di tipo 1.0. ad es. `amazon.nova-micro-v1:0:128k`
La mappatura corretta dovrebbe essere
```
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod # or s3://escrow_bucket/model_location
```
**Prevenzione:**
Controlla che `model_name_or_path` sia mappato a destra `model_type` prima di inviare il lavoro di valutazione.
## Sottoattività disponibili
Di seguito sono elencate le sottoattività disponibili per la valutazione del modello in più domini, tra cui MMLU (Massive Multitask Language Understanding), BBH (Big Bench Hard), MATH e MMMU (Massive Multi-discipline Multimodal Understanding). Queste sottoattività consentono di valutare le prestazioni del modello in base a funzionalità e aree di conoscenza specifiche.
**MMLU**
```
MMLU_SUBTASKS = [
"abstract_algebra",
"anatomy",
"astronomy",
"business_ethics",
"clinical_knowledge",
"college_biology",
"college_chemistry",
"college_computer_science",
"college_mathematics",
"college_medicine",
"college_physics",
"computer_security",
"conceptual_physics",
"econometrics",
"electrical_engineering",
"elementary_mathematics",
"formal_logic",
"global_facts",
"high_school_biology",
"high_school_chemistry",
"high_school_computer_science",
"high_school_european_history",
"high_school_geography",
"high_school_government_and_politics",
"high_school_macroeconomics",
"high_school_mathematics",
"high_school_microeconomics",
"high_school_physics",
"high_school_psychology",
"high_school_statistics",
"high_school_us_history",
"high_school_world_history",
"human_aging",
"human_sexuality",
"international_law",
"jurisprudence",
"logical_fallacies",
"machine_learning",
"management",
"marketing",
"medical_genetics",
"miscellaneous",
"moral_disputes",
"moral_scenarios",
"nutrition",
"philosophy",
"prehistory",
"professional_accounting",
"professional_law",
"professional_medicine",
"professional_psychology",
"public_relations",
"security_studies",
"sociology",
"us_foreign_policy",
"virology",
"world_religions"
]
```
**BBH**
```
BBH_SUBTASKS = [
"boolean_expressions",
"causal_judgement",
"date_understanding",
"disambiguation_qa",
"dyck_languages",
"formal_fallacies",
"geometric_shapes",
"hyperbaton",
"logical_deduction_five_objects",
"logical_deduction_seven_objects",
"logical_deduction_three_objects",
"movie_recommendation",
"multistep_arithmetic_two",
"navigate",
"object_counting",
"penguins_in_a_table",
"reasoning_about_colored_objects",
"ruin_names",
"salient_translation_error_detection",
"snarks",
"sports_understanding",
"temporal_sequences",
"tracking_shuffled_objects_five_objects",
"tracking_shuffled_objects_seven_objects",
"tracking_shuffled_objects_three_objects",
"web_of_lies",
"word_sorting"
]
```
**Math** (Matematica)
```
MATH_SUBTASKS = [
"algebra",
"counting_and_probability",
"geometry",
"intermediate_algebra",
"number_theory",
"prealgebra",
"precalculus",
```
**MMMU**
```
MATH_SUBTASKS = [
"Accounting",
"Agriculture",
"Architecture_and_Engineering",
"Art",
"Art_Theory",
"Basic_Medical_Science",
"Biology",
"Chemistry",
"Clinical_Medicine",
"Computer_Science",
"Design",
"Diagnostics_and_Laboratory_Medicine",
"Economics",
"Electronics",
"Energy_and_Power",
"Finance",
"Geography",
"History",
"Literature",
"Manage",
"Marketing",
"Materials",
"Math",
"Mechanical_Engineering",
"Music",
"Pharmacy",
"Physics",
"Psychology",
"Public_Health",
"Sociology",
```
Valuta i tuoi modelli Nova personalizzati utilizzando vari metodi e metriche di valutazione.
**Topics**
+ [
## Prerequisiti
](#nova-model-evaluation-prerequisites)
+ [
## Attività di benchmarking disponibili
](#nova-model-evaluation-benchmark)
+ [
## Configurazioni specifiche di una valutazione
](#nova-model-evaluation-config)
+ [
## Esecuzione di job di addestramento per la valutazione
](#nova-model-evaluation-notebook)
+ [
## Valutazione e analisi dei risultati della valutazione
](#nova-model-evaluation-assess)
+ [
## Best practice e risoluzione dei problemi di valutazione
](#nova-model-evaluation-best-practices)
+ [
## Sottoattività disponibili
](#nova-model-evaluation-subtasks)
+ [
# Valutazione del modello di ragionamento
](nova-reasoning-model-evaluation.md)
+ [
# Valutazione RFT
](nova-rft-evaluation.md)
+ [
# Implementazione di funzioni premi
](nova-implementing-reward-functions.md)
# Valutazione del modello di ragionamento
## Panoramica di
Il supporto del modello di ragionamento consente la valutazione con modelli Nova compatibili con il ragionamento che eseguono un ragionamento interno esplicito prima di generare risposte finali. Questa funzionalità utilizza il controllo a livello di API tramite il `reasoning_effort` parametro per abilitare o disabilitare dinamicamente la funzionalità di ragionamento, migliorando potenzialmente la qualità della risposta per attività analitiche complesse.
**Modelli supportati**
+ amazon.nova-2-lite-v 1:0:256k
## Configurazione della ricetta
Abilita il ragionamento aggiungendo il `reasoning_effort` parametro alla `inference` sezione della tua ricetta:
```
run:
name: reasoning-eval-job-name # [MODIFIABLE] Unique identifier for your evaluation job
model_type: amazon.nova-2-lite-v1:0:256k # [FIXED] Must be a reasoning-supported model
model_name_or_path: nova-lite-2/prod # [FIXED] Path to model checkpoint or identifier
replicas: 1 # [MODIFIABLE] Number of replicas for SageMaker Training job
data_s3_path: "" # [MODIFIABLE] Leave empty for SageMaker Training job; optional for SageMaker HyperPod job
output_s3_path: "" # [MODIFIABLE] Output path for SageMaker HyperPod job (not compatible with SageMaker Training jobs)
evaluation:
task: mmlu # [MODIFIABLE] Evaluation task
strategy: zs_cot # [MODIFIABLE] Evaluation strategy
metric: accuracy # [MODIFIABLE] Metric calculation method
inference:
reasoning_effort: high # [MODIFIABLE] Enables reasoning mode; options: low/high or null to disable
max_new_tokens: 32768 # [MODIFIABLE] Maximum tokens to generate, recommended value when reasoning_effort set to high
top_k: -1 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
```
## Utilizzo del parametro reasoning\$1effort
Il `reasoning_effort` parametro controlla il comportamento di ragionamento per i modelli in grado di ragionare.
### Prerequisiti
+ **Compatibilità tra modelli:** viene impostata `reasoning_effort` solo quando `model_type` specifica un modello in grado di ragionare (attualmente) `amazon.nova-2-lite-v1:0:256k`
+ **Gestione degli errori**: l'utilizzo `reasoning_effort` con modelli non supportati avrà esito negativo con `ConfigValidationError: "Reasoning mode is enabled but model '{model_type}' does not support reasoning. Please use a reasoning-capable model or disable reasoning mode."`
### Opzioni disponibili
| Opzione | Comportamento | Limite di token | Caso d’uso |
| --- | --- | --- | --- |
| null (impostazione predefinita) | Disattiva la modalità di ragionamento | N/D | Valutazione standard senza sovraccarico di ragionamento |
| low | Consente il ragionamento con vincoli | 4.000 token per il ragionamento interno | Scenari che richiedono un ragionamento conciso; ottimizza velocità e costi |
| high | Consente il ragionamento senza vincoli | Nessun limite simbolico al ragionamento interno | Problemi complessi che richiedono analisi e step-by-step ragionamenti approfonditi |
| Metodo di addestramento | Opzioni disponibili | Come configurare |
| --- | --- | --- |
| SFT (regolazione di precisione supervisionata) | Solo High o Off | Usa reasoning\$1enabled: true (high) o reasoning\$1enabled: false (off) |
| RFT (Reinforcement Fine-Tuning) | Basso, Alto o Disattivato | Usa reasoning\$1effort: low o reasoning\$1effort: high. Ometti il campo da disabilitare. |
| Valutazione | Basso, Alto o Disattivato | Usa reasoning\$1effort: low o reasoning\$1effort: high. Usa null per disabilitare. |
### Quando abilitare il ragionamento
**Usa la modalità di ragionamento (`low`o) per `high`**
+ Compiti complessi di risoluzione di problemi (matematica, puzzle logici, programmazione)
+ Domande analitiche in più fasi che richiedono un ragionamento intermedio
+ Attività in cui spiegazioni o riflessioni dettagliate migliorano la precisione step-by-step
+ Scenari in cui la qualità della risposta è prioritaria rispetto alla velocità
**Usa la modalità non ragionamento (`null`o ometti il parametro) per**
+ Domande e risposte semplici o domande fattuali
+ Attività di scrittura creativa
+ Quando i tempi di risposta più rapidi sono fondamentali
+ Analisi comparativa delle prestazioni in cui è necessario escludere il sovraccarico di ragionamento
+ L'ottimizzazione dei costi quando il ragionamento non migliora le prestazioni delle attività
### Risoluzione dei problemi
**Errore: «La modalità di ragionamento è abilitata ma il modello non supporta il ragionamento»**
**Causa**: il `reasoning_effort` parametro è impostato su un valore diverso da nullo, ma quello specificato `model_type` non supporta il ragionamento.
**Risoluzione:**
+ Verifica che il tipo di modello sia `amazon.nova-2-lite-v1:0:256k`
+ Se utilizzi un modello diverso, passa a un modello in grado di ragionare o rimuovi il `reasoning_effort` parametro dalla tua ricetta
# Valutazione RFT
## Cos'è la valutazione RFT?
RFT Evaluation consente di valutare le prestazioni del modello utilizzando funzioni di ricompensa personalizzate prima, durante o dopo la formazione di reinforcement learning. A differenza delle valutazioni standard che utilizzano metriche predefinite, RFT Evaluation consente di definire criteri di successo personalizzati tramite una funzione Lambda che assegna un punteggio agli output del modello in base ai requisiti specifici.
## Perché effettuare una valutazione con RFT?
La valutazione è fondamentale per determinare se il processo di messa a punto di RL presenta:
+ Migliore allineamento del modello con il caso d'uso specifico e i valori umani
+ Funzionalità del modello mantenute o migliorate per le attività chiave
+ Ha evitato effetti collaterali indesiderati come riduzione della fattualità, aumento della verbosità o riduzione delle prestazioni in altre attività
+ Hai soddisfatto i criteri di successo personalizzati definiti dalla tua funzione di ricompensa
## Quando utilizzare la valutazione RFT
Utilizza la valutazione RFT in questi scenari:
+ Prima della formazione RFT: stabilisci le metriche di base sul tuo set di dati di valutazione
+ Durante l'allenamento RFT: monitora i progressi dell'allenamento con punti di controllo intermedi
+ Dopo la formazione RFT: verifica che il modello finale soddisfi i tuoi requisiti
+ Confronto tra modelli: valuta più versioni del modello utilizzando criteri di ricompensa coerenti
**Nota**
Usa RFT Evaluation quando hai bisogno di metriche personalizzate e specifiche del dominio. Per una valutazione generica (precisione, perplessità, BLEU), utilizzate metodi di valutazione standard.
## Requisiti per il formato dei dati
### Struttura dei dati di input
I dati di input di valutazione RFT devono seguire il formato OpenAI Reinforcement Fine-Tuning. Ogni esempio è un oggetto JSON contenente:
+ `messages`— Serie di turni e ruoli di conversazione `system` `user`
+ `reference_answer`— Risultati attesi o dati fondamentali utilizzati dalla funzione di ricompensa per il punteggio
### Esempio di formato dei dati
```
{
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Solve for x. Return only JSON like {\"x\": }. Equation: 2x + 5 = 13"
}
]
}
],
"reference_answer": {
"x": 4
}
}
```
### Limitazioni attuali
+ Solo testo: non sono supportati input multimodali (immagini, audio, video)
+ Conversazioni a turno singolo: supporta solo messaggi utente singoli (non dialoghi a più turni)
+ Formato JSON: i dati di input devono essere in formato JSONL (un oggetto JSON per riga)
+ Risultati del modello: la valutazione viene eseguita sui completamenti generati dal modello specificato
## Preparazione della ricetta di valutazione
### Notebook di esempio
Per un esempio completo, consulta [Quaderni di valutazione](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook).
### Esempio di configurazione della ricetta
```
run:
name: nova-lite-rft-eval-job
model_type: amazon.nova-lite-v1:0:300k
model_name_or_path: s3://escrow_bucket/model_location # [MODIFIABLE] S3 path to your model or model identifier
replicas: 1 # [MODIFIABLE] For SageMaker Training jobs only; fixed for HyperPod jobs
data_s3_path: "" # [REQUIRED FOR HYPERPOD] Leave empty for SageMaker Training jobs and use TrainingInput in sagemaker python SDK
output_s3_path: "" # [REQUIRED] Output artifact S3 path for evaluation results
evaluation:
task: rft_eval # [FIXED] Do not modify
strategy: rft_eval # [FIXED] Do not modify
metric: all # [FIXED] Do not modify
# Inference Configuration
inference:
max_new_tokens: 8192 # [MODIFIABLE] Maximum tokens to generate
top_k: -1 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
top_logprobs: 0 # [MODIFIABLE] Set between 1-20 to enable logprobs output
# =============================================================================
# Bring Your Own Reinforcement Learning Environment
# =============================================================================
rl_env:
reward_lambda_arn: arn:aws:lambda:::function:
```
## Funzioni di ricompensa preimpostate
Due funzioni di ricompensa preimpostate (`prime_code`e`prime_math`) sono disponibili come layer Lambda per una facile integrazione con le funzioni RFT Lambda.
### Panoramica di
Queste funzioni preimpostate forniscono funzionalità di valutazione per: out-of-the-box
+ `prime_code`— Generazione di codice e valutazione della correttezza
+ `prime_math`— Ragionamento matematico e valutazione della risoluzione dei problemi
### Configurazione rapida
1. [Scarica il layer Lambda dalle versioni. nova-custom-eval-sdk ](https://github.com/aws/nova-custom-eval-sdk/releases)
1. Pubblica il layer Lambda utilizzando AWS Command Line Interface ()AWS CLI:
```
aws lambda publish-layer-version \
--layer-name preset-function-layer \
--description "Preset reward function layer with dependencies" \
--zip-file fileb://universal_reward_layer.zip \
--compatible-runtimes python3.9 python3.10 python3.11 python3.12 \
--compatible-architectures x86_64 arm64
```
1. Aggiungi il layer alla tua funzione Lambda nella Console di AWS gestione (seleziona il layer preset-function-layer dal livello personalizzato e aggiungi anche AWSSDKPandas-Python 312 per le dipendenze numpy).
1. Importa e usa nel tuo codice Lambda:
```
from prime_code import compute_score # For code evaluation
from prime_math import compute_score # For math evaluation
```
### funzione prime\$1code
Valuta le attività di generazione di codice Python eseguendo codice in base a casi di test e misurando la correttezza.
**Esempio di formato del set di dati di input**
```
{"messages":[{"role":"user","content":"Write a function that returns the sum of two numbers."}],"reference_answer":{"inputs":["3\n5","10\n-2","0\n0"],"outputs":["8","8","0"]}}
{"messages":[{"role":"user","content":"Write a function to check if a number is even."}],"reference_answer":{"inputs":["4","7","0","-2"],"outputs":["True","False","True","True"]}}
```
**Caratteristiche principali**
+ Estrazione automatica del codice dai blocchi di codice markdown
+ Rilevamento delle funzioni e test basati sulle chiamate
+ Esecuzione di test case con protezione dal timeout
+ Convalida della sintassi e controlli di compilazione
+ Segnalazione dettagliata degli errori con traceback
### funzione prime\$1math
Valuta le capacità di ragionamento matematico e di risoluzione dei problemi con il supporto della matematica simbolica.
**Formato di input**
```
{"messages":[{"role":"user","content":"What is the derivative of x^2 + 3x?."}],"reference_answer":"2*x + 3"}
```
**Caratteristiche principali**
+ Valutazione matematica simbolica utilizzando SymPy
+ Formati di risposta multipli (LaTeX, testo semplice, simbolico)
+ Controllo matematico dell'equivalenza
+ Normalizzazione e semplificazione delle espressioni
### Requisiti per il formato dei dati
**Per la valutazione del codice**
+ Input: matrice di argomenti delle funzioni (tipi propri: numeri interi, stringhe, ecc.)
+ Output: matrice di valori restituiti previsti (tipi appropriati: booleani, numeri, ecc.)
+ Codice: deve essere in Python con definizioni di funzioni chiare
**Per la valutazione matematica**
+ Risposta di riferimento: espressione matematica o valore numerico
+ Risposta: può essere LaTe X, testo semplice o notazione simbolica
+ Equivalenza: verificata simbolicamente, non solo in base alla corrispondenza tra stringhe
### Best practice
+ Usa i tipi di dati appropriati nei casi di test (numeri interi contro stringhe, booleani vs «True»)
+ Fornisci firme funzionali chiare nei problemi di codice
+ Includi casi limite negli input di test (zero, numeri negativi, input vuoti)
+ Formatta le espressioni matematiche in modo coerente nelle risposte di riferimento
+ Testa la tua funzione di ricompensa con dati di esempio prima dell'implementazione
### Gestione degli errori
Entrambe le funzioni includono una solida gestione degli errori per:
+ Errori di compilazione nel codice generato
+ Eccezioni di runtime durante l'esecuzione
+ Dati di input non validi
+ Scenari di timeout per loop infiniti
+ Espressioni matematiche non valide
## Creazione della funzione di ricompensa
### Requisiti Lambda ARN
Il tuo Lambda ARN deve seguire questo formato:
```
"arn:aws:lambda:*:*:function:*SageMaker*"
```
Se la Lambda non dispone di questo schema di denominazione, il processo avrà esito negativo con questo errore:
```
[ERROR] Unexpected error: lambda_arn must contain one of: ['SageMaker', 'sagemaker', 'Sagemaker'] when running on SMHP platform (Key: lambda_arn)
```
### Formato di richiesta Lambda
La tua funzione Lambda riceve i dati in questo formato:
```
[
{
"id": "sample-001",
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Do you have a dedicated security team?"
}
]
},
{
"role": "nova_assistant",
"content": [
{
"type": "text",
"text": "As an AI developed by Company, I don't have a dedicated security team..."
}
]
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
]
```
**Nota**
La struttura dei messaggi include l'`content`array annidato, corrispondente al formato dei dati di input. L'ultimo messaggio con ruolo `nova_assistant` contiene la risposta generata dal modello.
### Formato di risposta Lambda
La tua funzione Lambda deve restituire dati in questo formato:
```
[
{
"id": "sample-001",
"aggregate_reward_score": 0.75,
"metrics_list": [
{
"name": "accuracy",
"value": 0.85,
"type": "Metric"
},
{
"name": "fluency",
"value": 0.90,
"type": "Reward"
}
]
}
]
```
**Campi di risposta**
+ `id`— Deve corrispondere all'ID del campione di input
+ `aggregate_reward_score`— Punteggio complessivo (in genere da 0,0 a 1,0)
+ `metrics_list`— Serie di metriche individuali con:
+ `name`— Identificatore metrico (ad es. «precisione», «fluidità»)
+ `value`— Punteggio metrico (in genere da 0,0 a 1,0)
+ `type`— «Metrico» (per la rendicontazione) o «Premio» (utilizzato nella formazione)
## autorizzazioni IAM
### Autorizzazioni richieste
Il ruolo di SageMaker esecuzione deve disporre delle autorizzazioni per richiamare la funzione Lambda. Aggiungi questa politica al tuo SageMaker ruolo di esecuzione:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:region:account-id:function:function-name"
}
]
}
```
### Ruolo di esecuzione Lambda
Il ruolo di esecuzione della tua funzione Lambda richiede le autorizzazioni di esecuzione Lambda di base:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:*"
}
]
}
```
Se la tua funzione Lambda accede ad altri AWS servizi (ad esempio, S3 per i dati di riferimento, DynamoDB per la registrazione), aggiungi tali autorizzazioni al ruolo di esecuzione Lambda.
## Esecuzione del processo di valutazione
1. **Prepara i tuoi dati**: formatta i dati di valutazione in base ai requisiti di formato dei dati e carica il file JSONL su S3: `s3://your-bucket/eval-data/eval_data.jsonl`
1. **Configura la tua ricetta**: aggiorna la ricetta di esempio con la tua configurazione:
+ Imposta `model_name_or_path` la posizione del modello
+ Imposta `lambda_arn` sulla funzione di ricompensa ARN
+ Imposta `output_s3_path` la posizione di uscita desiderata
+ Regola `inference` i parametri secondo necessità
Salva la ricetta con nome `rft_eval_recipe.yaml`
1. **Esegui la valutazione**: esegui il processo di valutazione utilizzando il taccuino fornito: [Quaderni di valutazione](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook)
1. **Monitora i progressi**: monitora il processo di valutazione tramite:
+ SageMaker Console: controlla lo stato del lavoro e i registri
+ CloudWatch Registri: visualizza i registri di esecuzione dettagliati
+ Lambda Logs: problemi relativi alla funzione di ricompensa di debug
## Comprensione dei risultati della valutazione
### Formato di output
Il processo di valutazione restituisce i risultati nella posizione S3 specificata in formato JSONL. Ogni riga contiene i risultati della valutazione per un campione:
```
{
"id": "sample-001",
"aggregate_reward_score": 0.75,
"metrics_list": [
{
"name": "accuracy",
"value": 0.85,
"type": "Metric"
},
{
"name": "fluency",
"value": 0.90,
"type": "Reward"
}
]
}
```
**Nota**
L'RFT Evaluation Job Output è identico al formato Lambda Response. Il servizio di valutazione analizza la risposta della funzione Lambda senza modifiche, garantendo la coerenza tra i calcoli delle ricompense e i risultati finali.
### Interpretazione dei risultati
**Punteggio di ricompensa aggregato**
+ Intervallo: in genere da 0,0 (peggiore) a 1,0 (migliore), ma dipende dall'implementazione
+ Scopo: un unico numero che riassume le prestazioni complessive
+ Utilizzo: confronta i modelli, monitora i miglioramenti durante l'allenamento
**Metriche individuali**
+ Tipo di metrica: metriche informative per l'analisi
+ Tipo di ricompensa: metriche utilizzate durante la formazione RFT
+ Interpretazione: valori più alti in genere indicano prestazioni migliori (a meno che non si progettino metriche inverse)
### Benchmark delle prestazioni
Ciò che costituisce una «buona» prestazione dipende dal caso d'uso:
| Intervallo di punteggio | Interpretazione | Azione |
| --- | --- | --- |
| 0,8 - 1,0 | Eccellente | Modello pronto per l'implementazione |
| 0,6 - 0,8 | Buona | Potrebbero essere utili piccoli miglioramenti |
| 0,4 - 0,6 | Giusto | È necessario un miglioramento significativo |
| 0,0 - 0,4 | Povero | Rivedi i dati di allenamento e la funzione di ricompensa |
**Importante**
Queste sono linee guida generali. Definite le vostre soglie in base ai requisiti aziendali, alle prestazioni del modello di base, ai vincoli specifici del dominio e all'analisi costi-benefici dell'ulteriore formazione.
## Risoluzione dei problemi
### Problemi comuni
| Problema | Causa | Soluzione |
| --- | --- | --- |
| Timeout Lambda | Calcolo complesso dei premi | Aumentare il timeout Lambda o ottimizzare la funzione |
| Autorizzazione negata | Autorizzazioni IAM mancanti | Verifica che SageMaker il ruolo possa richiamare Lambda |
| Punteggi incoerenti | Funzione di ricompensa non deterministica | Usa seed fissi o logica deterministica |
| Risultati mancanti | Errori Lambda non rilevati | Aggiungi una gestione completa degli errori in Lambda |
### Lista di controllo per il debug
+ Verifica che i dati di input seguano il formato corretto con array di contenuti annidati
+ Verifica che l'ARN Lambda sia corretto e che la funzione sia stata implementata
+ Controlla le autorizzazioni IAM per SageMaker → Invocazione Lambda
+ Esamina CloudWatch i registri per gli errori Lambda
+ Verifica che la risposta Lambda corrisponda al formato previsto
## Best practice
+ Inizia in modo semplice: inizia con le funzioni di ricompensa di base e ripeti
+ Testa Lambda separatamente: utilizza gli eventi di test Lambda prima della valutazione completa
+ Convalida su set di dati di piccole dimensioni: esegui la valutazione sul sottoinsieme prima del set di dati completo
+ Controllo della versione: monitora le versioni della funzione di ricompensa insieme alle versioni del modello
+ Monitoraggio dei costi: le chiamate Lambda e il tempo di calcolo influiscono sui costi
+ Registra in modo esteso: utilizza le istruzioni di stampa in Lambda per il debug
+ Imposta i timeout in modo appropriato: equilibrio tra pazienza e costi
+ Metriche dei documenti: definisci chiaramente cosa misura ogni metrica
## Fasi successive
Dopo aver completato la valutazione RFT:
+ Se i risultati sono soddisfacenti: distribuisci il modello alla produzione
+ Se è necessario un miglioramento:
+ Regola la funzione di ricompensa
+ Raccogli più dati di allenamento
+ Modifica gli iperparametri di allenamento
+ Esegui iterazioni di addestramento RFT aggiuntive
+ Monitoraggio continuo: rivalutazione periodica con nuovi dati
# Implementazione di funzioni premi
## Panoramica di
La funzione di ricompensa (chiamata anche scorer o grader) è il componente principale che valuta le risposte del modello e fornisce segnali di feedback per l'allenamento. Deve essere implementata come una funzione Lambda che accetta le risposte del modello e restituisce punteggi di ricompensa.
## Formato dell'interfaccia
La tua funzione di ricompensa deve accettare e restituire dati nel seguente formato:
**Esempio di input per la formazione**
```
{
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
```
**Esempio di payload per la ricompensa lambda**
Il contenitore trasforma automaticamente i dati prima di inviarli alla funzione Lambda tramite:
1. Generazione di un modello di risposta per ogni prompt
1. Aggiungere il turno dell'assistente (risposta generata) all'array dei messaggi
1. Aggiungere un `id` campo unico per il tracciamento
La tua funzione Lambda riceverà i dati in questo formato trasformato:
```
{
"id": "123",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Amazon, I don not have a dedicated security team..."
}
],
# Following section will be same as your training dataset sample
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
```
**Contratto Reward Lambda**
```
def lambda_handler(event, context):
return lambda_grader(event)
def lambda_grader(samples: list[dict]) -> list[dict]:
"""
Args:
samples: List of dictionaries in OpenAI format
Example input:
{
"id": "123",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Company, I don nott have a dedicated security team..."
}
],
# This section will be same as your training dataset
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
Returns:
List of dictionaries with reward scores:
{
"id": str, # Same id as input sample
"aggregate_reward_score": float, # Overall score for the sample
"metrics_list": [ # OPTIONAL: Component scores
{
"name": str, # Name of the component score
"value": float, # Value of the component score
"type": str # "Reward" or "Metric"
}
]
}
"""
```
## Campi di input e output
### Campi di input
| Campo | Description | Note aggiuntive |
| --- | --- | --- |
| id | Identificatore univoco per il campione | Ripreso in uscita. Formato delle stringhe |
| messages | Cronologia chat ordinata in formato OpenAI | Matrice di oggetti di messaggio |
| messages [] .role | Relatore del messaggio | Valori comuni: «utente», «assistente», «sistema» |
| messaggi [] .content | Contenuto testuale del messaggio | Stringa normale |
| \$1\$1metadati | Informazioni in formato libero per facilitare la classificazione | Oggetto; campi opzionali trasmessi dai dati di addestramento |
### Campi di output
| Campo | Description | Note aggiuntive |
| --- | --- | --- |
| id | Stesso identificatore del campione di input | Deve corrispondere all'input |
| aggregate\$1reward\$1score | Punteggio complessivo del campione | Float (ad esempio, 0,0—1,0 o intervallo definito dall'attività) |
| metrics\$1list | Punteggi dei componenti che compongono l'aggregato | Matrice di oggetti metrici |
## Vincoli tecnici
+ **Limite di timeout**: tempo di esecuzione massimo di 15 minuti per chiamata Lambda
+ **Concorrenza: deve gestire le richieste simultanee** `rollout_worker_replicas * 64`
+ **Affidabilità**: deve implementare una corretta gestione degli errori e restituire punteggi validi in modo coerente
+ **Prestazioni**: ottimizzate per un'esecuzione rapida (secondi, non minuti) per consentire un allenamento efficiente
**Best practice**
+ Riduci al minimo le chiamate API esterne
+ Utilizza algoritmi e strutture dati efficienti
+ Implementa la logica di ripetizione dei tentativi per guasti transitori
+ Memorizza nella cache i calcoli riutilizzabili
+ Esegui test approfonditi prima dell'addestramento per garantire un'esecuzione priva di bug
## Utilizzo di funzioni di ricompensa personalizzate
Implementa funzioni di ricompensa personalizzate quando disponi di criteri di valutazione specifici per attività:
+ **Definisci i criteri di valutazione**: stabilisci cosa rappresenta una buona risposta per il tuo compito
+ **Implementa la funzione Lambda**: crea una funzione Lambda seguendo il formato dell'interfaccia
+ **Esegui il test a livello locale**: convalida la funzione e restituisce punteggi corretti per gli input di esempio
+ **Implementa su AWS**: distribuisci la tua Lambda e annota l'ARN
+ **Configura ricetta**: aggiungi l'ARN Lambda al campo della ricetta `reward_lambda_arn`
+ Esegui **test con set di dati di piccole dimensioni**: esegui RFT con un numero minimo di dati per verificare l'integrazione
## autorizzazioni IAM
### Autorizzazioni richieste
Il ruolo di SageMaker esecuzione deve disporre delle autorizzazioni per richiamare la funzione Lambda. Aggiungi questa politica al tuo SageMaker ruolo di esecuzione:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:region:account-id:function:function-name"
}
]
}
```
### Ruolo di esecuzione Lambda
Il ruolo di esecuzione della tua funzione Lambda richiede le autorizzazioni di esecuzione Lambda di base:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:*"
}
]
}
```
Autorizzazioni aggiuntive: se la funzione Lambda accede ad AWS altri servizi (ad esempio, S3 per i dati di riferimento, DynamoDB per la registrazione), aggiungi tali autorizzazioni al ruolo di esecuzione Lambda.
## Esempio: funzione di ricompensa LLM As a Judge
Questo esempio dimostra l'utilizzo dei modelli Amazon Bedrock come giudici per valutare le risposte del modello confrontandole con le risposte di riferimento. Questo modello Lambda fornisce ai clienti un framework per implementare chiamate ad Amazon Bedrock per richieste di inferenza per elaborare le valutazioni degli arbitri. La funzione Lambda mantiene lo stesso input/output contratto delle altre funzioni di ricompensa.
### Implementazione
Questa funzione Lambda implementa un processo di valutazione in due fasi: `lambda_handler` estrae le risposte del modello e le risposte di riferimento dai campioni in entrata, quindi la funzione `lambda_graded` chiama Amazon Bedrock per valutare la somiglianza semantica tra di esse. L'implementazione include una solida gestione degli errori con tentativi automatici in caso di errori temporanei e supporta formati di risposta di riferimento flessibili (formati di stringhe e dizionari strutturati).
**Dettagli di implementazione:**
+ **Retry Logic**: implementa il backoff esponenziale (1s, 2s, 4s) per limitare le eccezioni per gestire i limiti di velocità dell'API Bedrock
+ **Gestione degli errori**: restituisce un punteggio di 0,0 per le valutazioni non riuscite anziché sollevare eccezioni
+ **Punteggio deterministico: utilizza la** temperatura = 0,0 per garantire punteggi coerenti tra le valutazioni
+ **Formato di riferimento flessibile: gestisce automaticamente sia le risposte di riferimento** a stringhe che quelle del dizionario
+ **Fissaggio del punteggio**: assicura che tutti i punteggi rientrino nell'intervallo valido [0.0, 1.0]
+ **Indipendente dal modello: modifica** JUDGE\$1MODEL\$1ID per utilizzare qualsiasi modello Amazon Bedrock (Nova, Llama, Mistral, ecc.)
```
"""
LLM Judge Lambda POC - Working implementation using Amazon Bedrock
"""
import json
import time
import boto3
bedrock_runtime = boto3.client('bedrock-runtime', region_name='us-east-1')
JUDGE_MODEL_ID = "anthropic.claude-3-5-sonnet-20240620-v1:0"
SYSTEM_PROMPT = "You must output ONLY a number between 0.0 and 1.0. No explanations, no text, just the number."
JUDGE_PROMPT_TEMPLATE = """Compare the following two responses and rate how similar they are on a scale of 0.0 to 1.0, where:
- 1.0 means the responses are semantically equivalent (same meaning, even if worded differently)
- 0.5 means the responses are partially similar
- 0.0 means the responses are completely different or contradictory
Response A: {response_a}
Response B: {response_b}
Output ONLY a number between 0.0 and 1.0. No explanations."""
def lambda_graded(response_a: str, response_b: str, max_retries: int = 3) -> float:
"""Call Bedrock to compare responses and return similarity score."""
prompt = JUDGE_PROMPT_TEMPLATE.format(response_a=response_a, response_b=response_b)
for attempt in range(max_retries):
try:
response = bedrock_runtime.converse(
modelId=JUDGE_MODEL_ID,
messages=[{"role": "user", "content": [{"text": prompt}]}],
system=[{"text": SYSTEM_PROMPT}],
inferenceConfig={"temperature": 0.0, "maxTokens": 10}
)
print(f"Bedrock call successful: {response}")
output = response['output']['message']['content'][0]['text'].strip()
score = float(output)
print(f"Score parsed: {score}")
return max(0.0, min(1.0, score))
except Exception as e:
if "ThrottlingException" in str(e) and attempt < max_retries - 1:
time.sleep(2 ** attempt)
else:
print(f"Bedrock call failed: {e}")
return None
return None
def lambda_handler(event, context):
"""AWS Lambda handler - processes samples from RFTEvalInvoker."""
try:
samples = event if isinstance(event, list) else [event]
results = []
for sample in samples:
sample_id = sample.get("id", "unknown")
messages = sample.get("messages", [])
# Extract assistant response (response A)
response_a = ""
for msg in messages:
if msg.get("role") in ["assistant", "nova_assistant"]:
response_a = msg.get("content", "")
break
# Extract reference answer from root level (no longer in metadata)
reference_answer = sample.get("reference_answer", "")
# Handle both string and dict reference_answer formats
if isinstance(reference_answer, dict):
# If reference_answer is a dict, extract the explanation or compliant field
response_b = reference_answer.get("explanation", reference_answer.get("compliant", ""))
else:
response_b = reference_answer
if not response_a or not response_b:
results.append({
"id": sample_id,
"aggregate_reward_score": 0.0,
"metrics_list": [{"name": "similarity_score", "value": 0.0, "type": "Metric"}]
})
continue
# Get similarity score
score = lambda_graded(response_a, response_b)
results.append({
"id": sample_id,
"aggregate_reward_score": score,
"metrics_list": [
{
"name": "similarity_score",
"value": score,
"type": "Metric"
}
]
})
return {"statusCode": 200, "body": json.dumps(results)}
except Exception as e:
print(f"Error: {e}")
return {"statusCode": 500, "body": json.dumps({"error": str(e)})}
```
### Formato di input
La Lambda riceve lo stesso formato di input delle altre funzioni di ricompensa:
```
{
"id": "sample-001",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Amazon, I don't have a dedicated security team..."
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
},
"my_custom_field": "custom_value"
}
```
### Formato di output
```
{
"id": "sample-001",
"aggregate_reward_score": 0.85,
"metrics_list": [
{
"name": "similarity_score",
"value": 0.85,
"type": "Metric"
}
]
}
```
### Considerazioni sull'implementazione
Potrebbe inoltre essere necessario modificare il modello di prompt e i parametri di inferenza in base alle funzionalità del modello scelto e al formato API.
+ **Autorizzazioni IAM**: il ruolo di esecuzione Lambda deve `bedrock:InvokeModel` disporre dell'autorizzazione per il modello scelto
+ **Timeout: imposta il timeout** Lambda su almeno 60 secondi per adattarsi alla latenza e ai nuovi tentativi dell'API Bedrock
+ **Regione**: esegui la distribuzione in una regione in cui è disponibile il modello Bedrock scelto
+ **Costo**: monitora l'utilizzo dell'API Bedrock poiché ogni valutazione effettua una chiamata API per campione
+ **Produttività**: per le valutazioni su larga scala, richiedi un aumento delle quote Bedrock per evitare limitazioni
**Aumento della produttività di Bedrock**
Se riscontri un rallentamento durante la valutazione, aumenta le quote del modello Bedrock:
+ Vai alla console AWS Service Quotas
+ Cerca «Bedrock» e seleziona la tua regione
+ Trova la quota per il modello scelto (ad esempio, «Invocazioni al minuto per Claude 3.5 Sonnet»)
+ Fai clic su «Richiedi aumento della quota» e specifica la produttività desiderata
+ Fornisci una giustificazione per l'aumento (ad esempio, «carico di lavoro di valutazione RFT»)
La logica di ripetizione integrata in Lambda gestisce le limitazioni occasionali, ma valutazioni sostenute ad alto volume richiedono aumenti di quota adeguati.
**Policy IAM richiesta:**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": "arn:aws:bedrock:*::foundation-model/*"
}
]
}
```