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 SageMaker AI-trained 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, è possibile testare il modello dopo averlo implementato in Amazon Bedrock chiamando le API di runtime di [Amazon Bedrock](https://docs.aws.amazon.com//bedrock/latest/userguide/import-with-create-custom-model.html). **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 AI-trained Amazon Nova 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-. Nova-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 | Multi-task Comprensione del linguaggio: verifica le conoscenze in 57 materie. | accuratezza | zs\_cot | Sì | | mmlu\_pro | Testo | MMLU - Sottoinsieme professionale - Incentrato su domini professionali come legge, medicina, contabilità e ingegneria. | accuratezza | zs\_cot | 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\_cot | 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\_cot | No | | matematica | Testo | Risoluzione di problemi matematici - Misura il ragionamento matematico su argomenti quali algebra, calcolo e problemi testuali. | exact\_match | zs\_cot | Sì | | strong\_reject | Testo | Quality-Control Attività: verifica la capacità del modello di rilevare e rifiutare contenuti inappropriati, dannosi o errati. | deflection | zs | Sì | | ifeval | Testo | Instruction-Following Valutazione: misura la precisione con cui un modello segue determinate istruzioni e completa le attività secondo le specifiche. | accuratezza | zs | No | | gen\_qa | Multi-Modal (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\_qa | No | | mmmu | Multi-Modal | Massive Multidiscipline Multimodal Understanding (MMMU): College-level benchmark composto da domande a scelta multipla e a risposta aperta relative a 30 discipline.) | accuratezza | zs\_cot | Sì | | llm\_judge | 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\_llm\_judge | Multi-Modal (immagine) | Questo nuovo benchmark si comporta come quello testuale `llm_judge` riportato sopra. L'unica differenza è che supporta l'inferenza delle immagini. | tutto | judge | No | | rubric\_llm\_judge | 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\_2024 | Testo | AIME 2024 - American Invitational Mathematics Examination: problemi relativi alla verifica del ragionamento matematico avanzato e alla risoluzione dei problemi | exact\_match | zs\_cot | No | | calendario\_pianificazione | 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\_match | 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:0:128k + amazon.nova-lite-v1:0:300k + amazon.nova-pro-v1:0:300k + 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 tracciamento MLFlow (necessaria solo su SMHP) + `mlflow_experiment_name`: (Facoltativo) Nome dell'esperimento per raggruppare 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 ragionamento graduale senza richiedere esempi espliciti. + `fs_cot`: Few-shot Chain of Thought: un approccio che fornisce alcuni esempi di ragionamento passo dopo passo prima di chiedere al modello di risolvere un nuovo problema. + `zs`: Zero-shot - un approccio per risolvere un problema senza esempi di formazione precedenti. + `gen_qa`: strategia specifica per utilizzare un set di dati personalizzato. + `judge`: Strategia specifica per Nova LLM in qualità di 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\_score, 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` sarà preferita rispetto a quella `response_A` calcolata utilizzando la probabilità. 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 una AWS Lambda funzione](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) nella tua Account AWS prima applicazione. 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\_metrics» o «rft». + `preprocessing`: Se abilitare le operazioni di pre-elaborazione personalizzate. + `postprocessing`: Se abilitare le operazioni di post-elaborazione personalizzate. + `aggregation`: funzione Built-in di aggregazione (opzioni valide: min, max, average, sum). **Limitazioni** + Le metriche Bring your own si applicano solo ai set di dati di input di testo. + Multi-modal i set di dati di input non sono supportati. + La fase di preelaborazione non elabora il campo dei metadati. #### Ricette di benchmark Nova LLM-as-a-judge **Importante** `llm_judge`e `mm_llm_judge` può essere eseguito solo con i modelli base di Amazon Nova (ad esempio`nova-micro/prod`,`nova-lite/prod`,`nova-pro/prod`, o`nova-lite-2/prod`). Non sono supportati sui checkpoint dei modelli personalizzati. `rubric_llm_judge`può essere eseguito solo con i modelli base di Amazon Nova 2.0 (ad esempio,`nova-lite-2/prod`). Non è supportato sui modelli base di Amazon Nova 1.0 o sui checkpoint di modelli personalizzati. Per valutare un modello personalizzato con un flusso di lavoro arbitrale, utilizza prima il modello personalizzato per generare il set di dati di richiesta e risposta, quindi esegui il flusso di lavoro dell'arbitro su un modello base di Amazon Nova utilizzando quel set di dati come input. 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 suggerimenti, risposte di base e risposte degli sfidanti, quindi utilizza un modello Nova Judge per fornire una metrica del tasso di successo basata sulla probabilità attraverso confronti a coppie. [Bradley-Terry](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) 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`. + È necessario caricare il set di dati in una posizione S3 a cui possano accedere i lavori di formazione sull'intelligenza artificiale. SageMaker + 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\_LLM 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 sfidanti e immagini sotto forma di Base64-encoded stringa, quindi utilizza un modello Nova Judge per fornire una metrica del tasso di vittoria basata sulla [Bradley-Terry](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model)probabilità 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 `llm_judge.jsonl` deve essere esatto. + 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 Base64-encoded immagini). `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 checkpoint CPT (continui) Pre-Training 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\_new\_tokens). 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 nei 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\_is\_instruction\_tuned 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\_new\_tokens 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\_new\_tokens su 1 garantisce che non vengano generati token spazzatura aggiuntivi. ##### Parametri chiave + **checkpoint\_is\_instruction\_tuned: deve essere impostato su (o come booleano**) per disabilitare i modelli di chat `"false"` `false` + **top\_logprobs**: 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\_new\_tokens**: 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 | | Nova 2 Lite | 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\_A, response\_B). + `backward_output` - Le preferenze non elaborate di Judge durante la valutazione nell’ordine inverso (response\_B, response\_A). + `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. E.g. vuoi valutare un checkpoint del modello Nova 2.0 lite perfezionato ma il tipo di modello che fornisci è 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:** Ricontrolla 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 Multimodal Understanding). Multi-discipline 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)