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 di un modello addestrato Valutazione Una ricetta di valutazione è un file di configurazione YAML che definisce la modalità di esecuzione di un processo di valutazione dei modelli Amazon Nova. Con questa ricetta è possibile valutare le prestazioni di un modello di base o addestrato rispetto a benchmark comuni o a set di dati personalizzati. Le metriche possono essere archiviate in Amazon TensorBoard S3 o. La valutazione fornisce metriche quantitative che permettono di valutare le prestazioni di un modello in varie attività per determinare se sono necessarie ulteriori personalizzazioni. La valutazione dei modelli è un processo offline, in cui i modelli vengono testati rispetto a benchmark fissi con risposte predefinite. Non vengono valutati in tempo reale o in base alle interazioni attive degli utenti. Per le valutazioni in tempo reale, puoi valutare il modello dopo averlo distribuito su Amazon Bedrock richiamando il runtime di Amazon Bedrock. APIs **Topics** + [ # Attività di benchmarking disponibili ](customize-fine-tune-evaluate-available-tasks.md) + [ # Informazioni sui parametri delle ricette ](customize-fine-tune-evaluate-understand-modify.md) + [ # Esempi di ricette di valutazione ](customize-fine-tune-evaluate-recipe-examples.md) + [ # Avvio di un processo di valutazione ](customize-fine-tune-evaluate-start-job.md) + [ # Accesso e analisi dei risultati di valutazione ](customize-fine-tune-evaluate-access-results.md) + [ # Valutazione RFT ](nova-hp-evaluate-rft.md) # 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 dei benchmark standard di settore supportati e disponibili. È possibile specificare i benchmark seguenti nel parametro `eval_task`: | 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 | zs\$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 | Testo | Valutazione dei set di dati personalizzati - Consente di utilizzare uno specifico set di dati per il benchmarking, confrontando gli output del modello con le risposte di riferimento con metriche come ROUGE e BLEU. | tutto | gen\$1qa | No | | llm\$1judge | Testo | LLM-as-a-Judge Confronto delle preferenze: utilizza un modello Amazon Nova Judge per determinare la preferenza tra le risposte accoppiate (B rispetto a A) per i tuoi prompt, calcolando la probabilità che B sia preferito ad A. | tutto | judge | 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 | | mm\$1llm\$1judge | Multimodale (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 LLM-as-a-judge valutazione avanzato basato su Amazon 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 | Sono disponibili le seguenti sottoattività `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" ] ``` Sono disponibili le seguenti sottoattività `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" ] ``` Sono disponibili le seguenti sottoattività `math`: ``` MATH_SUBTASKS = [ "algebra", "counting_and_probability", "geometry", "intermediate_algebra", "number_theory", "prealgebra", "precalculus", ] ``` # Informazioni sui parametri delle ricette **Configurazione run** Di seguito è riportata una configurazione di tipo run generale con una spiegazione dei parametri coinvolti. ``` run: name: eval_job_name model_type: amazon.nova-micro-v1:0:128k model_name_or_path: nova-micro/prod replicas: 1 data_s3_path: "" output_s3_path: s3://output_path mlflow_tracking_uri: "" mlflow_experiment_name : "" mlflow_run_name : "" ``` + `name`: (obbligatorio) un nome descrittivo per il processo di valutazione. Questo aiuta a identificare il tuo lavoro nella AWS console. + `model_type`: (obbligatorio) specifica la variante del modello Amazon 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-v1:0:256k` + `model_name_or_path`: (obbligatorio) 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 checkpoint post-addestrato) `s3:////outputs/checkpoints` + `replicas`: (obbligatorio) il numero di istanze di calcolo da utilizzare per l’addestramento distribuito. È necessario impostare questo valore su 1, perché la modalità multinodo non è supportata. + `data_s3_path`: (obbligatorio) il percorso S3 del set di dati di input. Lascia vuoto questo parametro, se non in caso di utilizzo di una ricetta *Bring Your Own Dataset* o *LLM-as-a-judge*. + `output_s3_path`: (obbligatorio) il percorso S3 per archiviare gli artefatti di valutazione dell’output. Il bucket S3 di output deve essere creato dallo stesso account che crea il processo. + `mlflow_tracking_uri`: (Opzionale) ARN del server di MLflow tracciamento per tracciare MLFlow esecuzioni/esperimenti. Assicurati di avere il permesso di accedere al server di tracciamento dal SageMaker ruolo di esecuzione AI **Configurazione evaluation** Di seguito è riportata una configurazione di tipo evaluation del modello con una spiegazione dei parametri coinvolti. ``` evaluation: task: mmlu strategy: zs_cot subtask: mathematics metric: accuracy ``` + `task`: (obbligatorio) specifica il benchmark o l’attività di valutazione da utilizzare. Elenco delle attività supportate: + mmlu + mmlu\$1pro + bbh + gpqa + matematica + strong\$1reject + gen\$1qa + ifeval + llm\$1judge + humaneval + mm\$1llm\$1judge + rubric\$1llm\$1judge + aime\$12024 + calendario\$1programmazione + humaneval + `strategy`: (obbligatorio) definisce l’approccio di valutazione: + zs\$1cot: Zero-shot Chain-of-Thought - Un approccio per suggerire modelli linguistici di grandi dimensioni che incoraggia il ragionamento senza richiedere esempi espliciti. step-by-step + zs: Zero-shot - Un approccio per risolvere un problema senza esempi di addestramento precedenti. + gen\$1qa: una strategia specifica per ricette di tipo Bring Your Own Dataset. + judge: una strategia specifica per Amazon Nova LLM come Judge e mm\$1llm\$1judge. + `subtask`: (facoltativo e rimovibile) specifica una determinata sottoattività per alcune attività di valutazione. Rimuovila dalla tua ricetta se la tua attività non include sottoattività. + `metric`: (obbligatorio) la metrica di valutazione da utilizzare. + accuracy: percentuale di risposte corrette + exact\$1match: (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à. + pass@1: (per il benchmark `humaneval`) è una metrica utilizzata per misurare la percentuale di casi in cui la previsione con la massima affidabilità del modello corrisponde alla risposta corretta. + `all`: restituisce le seguenti metriche: + 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`mm_llm_judge`, porta il tuo `llm_judge` benchmark personale per il 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`: numero di vittorie per `response_B` nei passaggi di valutazione avanti e indietro. + `b_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. + `inference_error_stderr`: errore standard degli errori di inferenza nei i giudizi. + `score`: punteggio aggregato basato sulle vittorie nei passaggi avanti e indietro per `response_B`. + `score_stderr`: errore standard del punteggio aggregato nei giudizi a coppie. + `winrate`: la probabilità che response\$1B venga preferito rispetto a response\$1a calcolato utilizzando la probabilità di Bradley-Terry. + `lower_rate`: limite inferiore (percentile 2,5) del tasso di successo stimato derivante dal campionamento bootstrap. **Configurazione inference** Di seguito è riportata una configurazione di tipo inference con una spiegazione dei parametri coinvolti. Tutti i parametri sono opzionali: ``` inference: max_new_tokens: 200 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`: il numero massimo di token da generare. Deve essere un numero intero. + `top_k`: il numero di token con la più alta probabilità da considerare. Deve essere un numero intero. + `top_p`: la soglia di probabilità cumulativa per il campionamento tramite token. Deve essere un valore decimale compreso tra 0,0 e 1,0, entrambi inclusi. + `temperature`: casualità nella selezione dei token. Valori più grandi introducono una maggiore casualità. Usa 0 per rendere deterministici i risultati. Deve essere un valore decimale minimo pari a 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 `null` (valore predefinito se non impostato; disabilita il ragionamento), o. `low` `high` Per `humaneval` è consigliabile la configurazione inference seguente: ``` inference: top_k: 1 max_new_tokens: 1600 temperature: 0.0 ``` **MLFlow configurazione** Di seguito è riportata una MLFlow configurazione e una spiegazione dei parametri coinvolti. Tutti i parametri sono opzionali: ``` run: mlflow_tracking_uri: "" mlflow_experiment_name: "" mlflow_run_name: "" ``` + `mlflow_tracking_uri`: Facoltativo) La posizione del server di MLflow tracciamento (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 # Esempi di ricette di valutazione Amazon Nova offre quattro tipi di ricette di valutazione, disponibili nell' GitHub archivio delle SageMaker HyperPod ricette. ## 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. Sono fornite nel formato `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. Sono fornite nel formato `xxx_bring_your_own_dataset_eval.yaml`. Di seguito sono riportati i requisiti per Bring Your Own Data: + Requisiti relativi al formato dei file + È necessario includere un singolo file `gen_qa.jsonl` contenente esempi di valutazione. + Il set di dati deve essere caricato in una posizione S3 a cui SageMaker Training Job possa accedervi. + Il file deve seguire il formato dello schema richiesto per un set di dati di domande e risposte generico. + Requisiti del formato dello schema - Ogni riga del file JSONL deve essere un oggetto JSON con i campi seguenti: + `query`: (obbligatorio) stringa contenente la domanda o l’istruzione che richiede una risposta + `response`: (obbligatorio) stringa contenente l’output del modello previsto + `system`: (facoltativo) 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 + `metadata`: (Facoltativo) Stringa contenente i metadati associati alla voce a scopo di etichettatura. Ecco un esempio di inserimento Bring Your Own Dataset ``` { "system":"You are a 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 that 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 that follows 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" } ``` Per utilizzare un set di dati personalizzato, modifica la ricetta di valutazione con i seguenti campi obbligatori, senza modificare alcun contenuto: ``` evaluation: task: gen_qa strategy: gen_qa metric: all ``` Si applicano le limitazioni seguenti: + È consentito un solo file JSONL per valutazione. + Il file deve seguire rigorosamente lo schema definito. + Limite di lunghezza del contesto: per ogni campione del set di dati, la lunghezza del contesto (inclusi i prompt di interrogazione di sistema \$1) deve essere inferiore a 3,5 k. ## Ricette di benchmark Nova LLM-as-a-judge Amazon Nova LLM-as-a-judge è una funzionalità di valutazione del modello che consente ai clienti di confrontare la qualità delle risposte di un modello con una risposta del modello di base su un set di dati personalizzato. [Include un set di dati con prompt, risposte di base e risposte sfidanti e utilizza un modello Amazon Nova Judge per fornire una metrica della percentuale di vittorie basata sulla probabilità di Bradley-Terry con confronti a coppie.](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) Le ricette sono fornite nel formato `xxx_llm_judge_eval.yaml`. Di seguito sono riportati i requisiti per LLM-as-a-judge: + Requisiti relativi al formato dei file + È necessario includere un singolo file `llm_judge.jsonl` contenente esempi di valutazione. Il nome del file deve essere `llm_judge.jsonl`. + [Il set di dati deve essere caricato in una posizione S3 a cui AI RIG può accedere. SageMaker SageMaker HyperPod ](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-hp-cluster.html) + Il file deve seguire il formato dello schema richiesto per il set di dati `llm_judge.jsonl`. + Il set di dati di input deve garantire che tutti i record abbiano una lunghezza di contesto inferiore a 12.000. + Requisiti del formato dello schema - Ogni riga del file JSONL deve essere un oggetto JSON con i campi seguenti: + `prompt`: (obbligatorio) una stringa contenente il prompt per la risposta generata. + `response_A`: una stringa contenente la risposta di base. + `response_B`: una stringa contenente la risposta alternativa da confrontare con la risposta di base. Ecco un esempio di inserimento LLM-as-a-judge ``` { "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 ``` Si applicano le limitazioni seguenti: + È consentito un solo file JSONL per valutazione. + Il file deve seguire rigorosamente lo schema definito. + I modelli Amazon Nova Judge sono gli stessi per tutte le specifiche delle famiglie di modelli (ovvero Lite, Micro e Pro). + Al momento i modelli Judge personalizzati non sono supportati. + Limite di lunghezza del contesto: per ogni campione del set di dati, la lunghezza del contesto (inclusi i prompt di interrogazione di sistema \$1) deve essere inferiore a 7k. ## Nova LLM come giudice per le ricette di riferimento multimodali (immagini) Nova LLM Judge for multi-modal (immagine), abbreviazione di Amazon 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 sfidanti e immagini sotto forma di stringa codificata in Base64, quindi utilizza un modello Amazon Nova Judge per fornire una metrica del tasso di successo basata sulla probabilità di Bradley-Terry attraverso confronti a coppie.](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) 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` + È necessario caricare il set di dati in una posizione S3 a cui SageMaker Training Jobs possa 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 in echo 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 Lite. + 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. ## Giudice basato sulla rubrica Rubric Judge è un modello di LLM-as-a-judge valutazione avanzato basato su Amazon 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 (A>B, B>A o pareggio), Rubric Judge genera dinamicamente criteri di valutazione personalizzati su misura per ogni richiesta e assegna punteggi granulari su più dimensioni. Funzionalità chiave: + **Generazione dinamica di criteri**: crea automaticamente dimensioni di valutazione pertinenti in base alla richiesta di input + **Punteggio ponderato: assegna dei pesi** di importanza a ciascun criterio in base alla loro importanza relativa + **Valutazione granulare**: fornisce punteggi dettagliati su base binaria (vero/falso) o su scala (1-5) per ogni criterio + **Metriche di qualità**: calcola punteggi di qualità continui (scala 0-1) che quantificano l'entità delle differenze tra le risposte Criterio di esempio generato dal modello: ``` price_validation: description: "The response includes validation to ensure price is a positive value." type: "scale" weight: 0.3 ``` Il modello valuta entrambe le risposte rispetto a tutti i criteri generati, quindi utilizza questi punteggi a livello di criterio per determinare la preferenza finale. **Topics** + [ ### Configurazione della ricetta ](#nova-hp-evaluate-rubric-judge-recipe) + [ ### Formato del set di dati di input ](#nova-hp-evaluate-rubric-judge-input) + [ ### Risultato della valutazione ](#nova-hp-evaluate-rubric-judge-output) + [ ### Supporto del modello di ragionamento ](#nova-hp-evaluate-rubric-judge-reasoning) ### Configurazione della ricetta **Ricetta Rubric Judge** Abilita Rubric Judge `task: rubric_llm_judge` impostando nella tua ricetta: ``` run: name: nova-eval-job-name # [MODIFIABLE] Unique identifier for your evaluation job model_type: amazon.nova-2-lite-v1:0:256k # [FIXED] Rubric Judge model type 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: "" # [FIXED] Leave empty for SageMaker Training job output_s3_path: "" # [FIXED] Leave empty for SageMaker Training job evaluation: task: rubric_llm_judge # [FIXED] Evaluation task - enables Rubric Judge strategy: judge # [FIXED] Evaluation strategy metric: all # [FIXED] Metric calculation method inference: max_new_tokens: 12000 # [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) ``` **Ricetta originale LLM as a Judge (per confronto)** Il modello di giudice originale utilizza`task: llm_judge`: ``` run: name: eval-job-name # [MODIFIABLE] Unique identifier for your evaluation job model_type: amazon.nova-micro-v1:0:128k # [FIXED] Model type model_name_or_path: "nova-micro/prod" # [FIXED] Path to model checkpoint or identifier replicas: 1 # [MODIFIABLE] Number of replicas for SageMaker Training job data_s3_path: "" # [FIXED] Leave empty for SageMaker Training job output_s3_path: "" # [FIXED] Leave empty for SageMaker Training job evaluation: task: llm_judge # [FIXED] Original judge task strategy: judge # [FIXED] Evaluation strategy metric: all # [FIXED] Metric calculation method inference: max_new_tokens: 12000 # [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) ``` ### Formato del set di dati di input Il formato del set di dati di input è identico al modello [originale del giudice](https://aws.amazon.com/blogs/machine-learning/evaluating-generative-ai-models-with-amazon-nova-llm-as-a-judge-on-amazon-sagemaker-ai/): **Campi obbligatori:** + `prompt`: Stringa contenente il prompt di input e le istruzioni + `response_A`: Stringa contenente l'output del modello di base + `response_B`: Stringa contenente l'output del modello personalizzato **Set di dati di esempio (formato JSONL):** ``` {"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."} ``` **Requisiti di formato:** + Ogni voce deve essere un oggetto JSON a riga singola + Separa le voci con nuove righe + Segui l'esatta denominazione dei campi, come mostrato negli esempi ### Risultato della valutazione **Struttura di output** Rubric Judge produce metriche di valutazione migliorate rispetto al modello di giudice originale: ``` { "config_general": { "lighteval_sha": "string", "num_fewshot_seeds": "int", "max_samples": "int | null", "job_id": "int", "start_time": "float", "end_time": "float", "total_evaluation_time_secondes": "string", "model_name": "string", "model_sha": "string", "model_dtype": "string | null", "model_size": "string" }, "results": { "custom|rubric_llm_judge_judge|0": { "a_scores": "float", "a_scores_stderr": "float", "b_scores": "float", "b_scores_stderr": "float", "ties": "float", "ties_stderr": "float", "inference_error": "float", "inference_error_stderr": "float", "score": "float", "score_stderr": "float", "weighted_score_A": "float", "weighted_score_A_stderr": "float", "weighted_score_B": "float", "weighted_score_B_stderr": "float", "score_margin": "float", "score_margin_stderr": "float", "winrate": "float", "lower_rate": "float", "upper_rate": "float" } }, "versions": { "custom|rubric_llm_judge_judge|0": "int" } } ``` **Nuove metriche in Rubric Judge** Le seguenti sei metriche sono esclusive di Rubric Judge e forniscono una valutazione granulare della qualità: | Metrica | Description | | --- |--- | | punteggio\$1ponderato\$1A | Punteggio di qualità medio normalizzato per Response\$1a in base a tutti i criteri di valutazione generati dal modello. I punteggi sono ponderati in base all'importanza del criterio e normalizzati su una scala 0-1 (più alto = migliore qualità) | | Weighted\$1score\$1a\$1stderr | Errore standard della media per Weighted\$1score\$1a, che indica l'incertezza statistica | | Punteggio\$1ponderato\$1B | Punteggio di qualità medio normalizzato per Response\$1b in tutti i criteri di valutazione generati dal modello. I punteggi sono ponderati in base all'importanza del criterio e normalizzati su una scala 0-1 (più alto = migliore qualità) | | Weighted\$1score\$1b\$1stderr | Errore standard della media per Weighted\$1score\$1b, che indica l'incertezza statistica | | score\$1margin | Differenza tra i punteggi ponderati (calcolati come Weighted\$1score\$1A - Weighted\$1score\$1b). Intervallo: da -1,0 a 1,0. Positivo = response\$1a è migliore; negativo = response\$1B è migliore; vicino allo zero = qualità simile | | score\$1margin\$1stderr | Errore standard della media di score\$1margin, che indica l'incertezza nella misurazione della differenza di qualità | **Comprensione delle metriche dei punteggi ponderati** **Scopo**: i punteggi ponderati forniscono misurazioni continue della qualità che completano i verdetti sulle preferenze binarie, consentendo una visione più approfondita delle prestazioni del modello. **Principali differenze rispetto al giudice originale**: + **Giudice originale**: emette solo preferenze discrete (A>B, B>A, A=B) + **Rubric Judge: emette** sia le preferenze che i punteggi di qualità continui (scala 0-1) in base a criteri personalizzati **Interpretazione** di score\$1margin: + `score_margin = -0.128`: Response\$1B ha ottenuto 12,8 punti percentuali in più rispetto a Response\$1a + `|score_margin| < 0.1`: Differenza di qualità ridotta (decisione ravvicinata) + `|score_margin| > 0.2`: Chiara differenza di qualità (decisione sicura) **Casi d'uso**: + **Miglioramento del modello**: identifica le aree specifiche in cui il tuo modello ha prestazioni inferiori + **Quantificazione della qualità**: misura l'entità dei divari prestazionali, non solo i rapporti win/loss + **Valutazione della fiducia**: distinguere tra decisioni ravvicinate e chiare differenze di qualità **Importante** I verdetti finali si basano ancora sulle etichette di preferenza esplicite del modello giudicante per preservare un ragionamento olistico e garantire un'adeguata mitigazione dei pregiudizi di posizione attraverso la valutazione. forward/backward I punteggi ponderati servono come strumenti di osservabilità, non come sostituti del verdetto primario. **Metodologia di calcolo** I punteggi ponderati vengono calcolati attraverso il seguente processo: + **Estrai i dati dei criteri: analizza l'**output YAML del giudice per estrarre i punteggi e i pesi dei criteri + **Normalizza** i punteggi: + Criteri basati sul tipo di scala (1-5): normalizza a 0-1 calcolando `(score - 1) / 4` + Criteri binari (vero/falso): converti in 1,0/0,0 + **Applica pesi**: moltiplica ogni punteggio normalizzato per il relativo peso del criterio + **Aggregato**: somma tutti i punteggi ponderati per ogni risposta + **Calcola il margine**: calcola `score_margin = weighted_score_A - weighted_score_B` **Esempio**: se response\$1a ha una somma ponderata di 0,65 e Response\$1b ha 0,78, `score_margin` sarebbe -0,13, indicando che response\$1b è di 13 punti percentuali superiore in termini di qualità in tutti i criteri ponderati. ### Supporto del modello di ragionamento Il supporto del modello di ragionamento consente la valutazione con modelli Amazon 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: 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 SageMaker HyperPod job output_s3_path: "" # [MODIFIABLE] Output path for SageMaker SageMaker HyperPod job (not compatible with SageMaker Training jobs) evaluation: task: mmlu # [MODIFIABLE] Evaluation task strategy: generate # [MODIFIABLE] Evaluation strategy metric: all # [MODIFIABLE] Metric calculation method inference: reasoning_effort: high # [MODIFIABLE] Enables reasoning mode; options: low/medium/high or null to disable max_new_tokens: 200 # [MODIFIABLE] Maximum tokens to generate top_k: 50 # [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à dei modelli**: 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 | **Quando abilitare il ragionamento** **Usa la modalità di ragionamento (`low``medium`, o`high`)** per: + 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à **Utilizza la modalità non ragionamento (parametro di omissione)** per: + Domande e risposte semplici o domande basate sui fatti + 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 # Avvio di un processo di valutazione Di seguito viene fornita una configurazione consigliata del tipo di istanza di valutazione e del tipo di modello: ``` # Install Dependencies (Helm - https://helm.sh/docs/intro/install/) curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 chmod 700 get_helm.sh ./get_helm.sh rm -f ./get_helm.sh # Install the SageMaker HyperPod CLI git clone --recurse-submodules https://github.com/aws/sagemaker-hyperpod-cli.git git checkout -b release_v2 cd sagemaker-hyperpod-cli pip install . # Verify the installation hyperpod --help # Connect to a SageMaker HyperPod Cluster hyperpod connect-cluster --cluster-name cluster-name # Submit the Job using the recipe for eval # Namespace by default should be kubeflow hyperpod start-job [--namespace namespace] --recipe evaluation/nova/nova_micro_p5_48xl_general_text_benchmark_eval --override-parameters \ '{ "instance_type":"p5d.48xlarge", "container": "708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-HP-Eval-V2-latest", "recipes.run.name": custom-run-name, "recipes.run.model_type": model_type, "recipes.run.model_name_or_path" " model name or finetune checkpoint s3uri, "recipes.run.data_s3_path": s3 for input data only for genqa and llm_judge, must be full S3 path that include filename, }' # List jobs hyperpod list-jobs [--namespace namespace] [--all-namespaces] # Getting Job details hyperpod get-job --job-name job-name [--namespace namespace] [--verbose] # Listing Pods hyperpod list-pods --job-name job-name --namespace namespace # Cancel Job hyperpod cancel-job --job-name job-name [--namespace namespace] ``` Dovrebbe essere anche possibile visualizzare lo stato del processo tramite la console del cluster Amazon EKS. # Accesso e analisi dei risultati di valutazione Una volta completato correttamente il processo di valutazione, è possibile accedere ai risultati e analizzarli utilizzando le informazioni contenute in questa sezione. In base al valore `output_s3_path` (ad esempio `s3://output_path/`) definito nella ricetta, la struttura di output è la seguente: ``` job_name/ ├── eval-result/ │ └── results_[timestamp].json │ └── inference_output.jsonl (only present for gen_qa) │ └── details/ │ └── model/ │ └── execution-date-time/ │ └──details_task_name_#_datetime.parquet └── tensorboard-results/ └── eval/ └── events.out.tfevents.[timestamp] ``` I risultati delle metriche vengono archiviati nella posizione di output S3 `s3://output_path/job_name/eval-result/result-timestamp.json` specificata. I risultati di Tensorboard vengono archiviati nel percorso S3 `s3://output_path/job_name/eval-tensorboard-result/eval/event.out.tfevents.epoch+ip`. Tutti gli output di inferenza, ad eccezione di `llm_judge` e `strong_reject`, vengono archiviati nel percorso S3 `s3://output_path/job_name/eval-result/details/model/taskname.parquet`. 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 Per visualizzare le metriche di valutazione in Tensorboard, completa la seguente procedura: 1. Passa a AI SageMaker Tensorboard. 1. Seleziona **Cartelle S3**. 1. Aggiungi il percorso della cartella S3, ad esempio `s3://output_path/job-name/eval-tensorboard-result/eval`. 1. Attendi il completamento della sincronizzazione. Sono disponibili le visualizzazioni delle serie temporali, degli scalari e del testo. È preferibile seguire le best practice seguenti: + 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. È possibile trovare i log degli errori di SageMaker HyperPod lavoro nel gruppo `/aws/sagemaker/Clusters/cluster-id` di CloudWatch log. ## Formato di output della probabilità logaritmica 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` # Valutazione RFT **Nota** La valutazione tramite funzioni di ricompensa remota nel tuo AWS ambiente è disponibile solo se sei cliente di Amazon Nova Forge. **Importante** Il campo `rl_env` di configurazione viene utilizzato esclusivamente per la valutazione, non per la formazione. Durante la formazione, si configurano le funzioni di ricompensa utilizzando l'infrastruttura `reward_lambda_arn` (a turno singolo) o BYOO con `rollout.delegate: true` (turno multiplo). **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 RFT Evaluation 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. **Topics** + [ ## Requisiti per il formato dei dati ](#nova-hp-evaluate-rft-data-format) + [ ## Preparazione della ricetta di valutazione ](#nova-hp-evaluate-rft-recipe) + [ ## Funzioni di ricompensa preimpostate ](#nova-hp-evaluate-rft-preset) + [ ## Creazione della tua funzione di ricompensa ](#nova-hp-evaluate-rft-create-function) + [ ## autorizzazioni IAM ](#nova-hp-evaluate-rft-iam) + [ ## Esecuzione del processo di valutazione ](#nova-hp-evaluate-rft-execution) + [ ## Comprensione dei risultati della valutazione ](#nova-hp-evaluate-rft-results) ## 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 di conversazione con ruoli `system` `user` + Altri metadati opzionali, ad esempio reference\$1answer **Esempio di formato dei dati** L'esempio seguente mostra il formato richiesto: ``` { "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** Le seguenti limitazioni si applicano alla valutazione RFT: + 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 **Esempio di configurazione della ricetta** L'esempio seguente mostra una ricetta di valutazione RFT completa: ``` 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 SageMaker HyperPod jobs data_s3_path: "" # [REQUIRED FOR HYPERPOD] Leave empty for SageMaker Training jobs 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: 8196 # [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 # Evaluation Environment Configuration (NOT used in training) 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\$1code: generazione di codice** e valutazione della correttezza + **prime\$1math: ragionamento matematico** e valutazione della risoluzione dei problemi **Configurazione rapida** Per utilizzare le funzioni di ricompensa preimpostate: 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 la CLI: AWS ``` 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 in AWS Console (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** **Scopo**: valuta le attività di generazione del codice Python eseguendo codice in base a casi di test e misurando la correttezza. **Esempio di formato del set di dati di input tratto dalla valutazione**: ``` {"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** **Scopo**: valuta le capacità di ragionamento matematico e di risoluzione dei problemi con supporto matematico simbolico. **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 **Best practice** Segui queste best practice quando utilizzi le funzioni di ricompensa preimpostate: + 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 ## Creazione della tua funzione di ricompensa **Lambda ARN** È necessario fare riferimento al seguente formato per l'ARN Lambda: ``` "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) ``` **Struttura della funzione Lambda** La tua funzione Lambda riceve batch di output del modello e restituisce punteggi di ricompensa. Di seguito è riportato un esempio di implementazione: ``` from typing import List, Any import json import re from dataclasses import asdict, dataclass @dataclass class MetricResult: """Individual metric result.""" name: str value: float type: str @dataclass class RewardOutput: """Reward service output.""" id: str aggregate_reward_score: float metrics_list: List[MetricResult] def lambda_handler(event, context): """ Main lambda handler """ return lambda_grader(event) def lambda_grader(samples: list[dict]) -> list[dict]: """ Core grader function """ scores: List[RewardOutput] = [] for sample in samples: print("Sample: ", json.dumps(sample, indent=2)) # Extract components idx = sample.get("id", "no id") if not idx or idx == "no id": print(f"ID is None/empty for sample: {sample}") ground_truth = sample.get("reference_answer") if "messages" not in sample: print(f"Messages is None/empty for id: {idx}") continue if ground_truth is None: print(f"No answer found in ground truth for id: {idx}") continue # Get model's response (last turn is assistant turn) last_message = sample["messages"][-1] if last_message["role"] != "nova_assistant": print(f"Last message is not from assistant for id: {idx}") continue if "content" not in last_message: print(f"Completion text is empty for id: {idx}") continue model_text = last_message["content"] # --- Actual scoring logic (lexical overlap) --- ground_truth_text = _extract_ground_truth_text(ground_truth) # Calculate main score and individual metrics overlap_score = _lexical_overlap_score(model_text, ground_truth_text) # Create two separate metrics as in the first implementation accuracy_score = overlap_score # Use overlap as accuracy fluency_score = _calculate_fluency(model_text) # New function for fluency # Create individual metrics metrics_list = [ MetricResult(name="accuracy", value=accuracy_score, type="Metric"), MetricResult(name="fluency", value=fluency_score, type="Reward") ] ro = RewardOutput( id=idx, aggregate_reward_score=overlap_score, metrics_list=metrics_list ) print(f"Response for id: {idx} is {ro}") scores.append(ro) # Convert to dict format result = [] for score in scores: result.append({ "id": score.id, "aggregate_reward_score": score.aggregate_reward_score, "metrics_list": [asdict(metric) for metric in score.metrics_list] }) return result def _extract_ground_truth_text(ground_truth: Any) -> str: """ Turn the `ground_truth` field into a plain string. """ if isinstance(ground_truth, str): return ground_truth if isinstance(ground_truth, dict): # Common patterns: { "explanation": "...", "answer": "..." } if "explanation" in ground_truth and isinstance(ground_truth["explanation"], str): return ground_truth["explanation"] if "answer" in ground_truth and isinstance(ground_truth["answer"], str): return ground_truth["answer"] # Fallback: stringify the whole dict return json.dumps(ground_truth, ensure_ascii=False) # Fallback: stringify anything else return str(ground_truth) def _tokenize(text: str) -> List[str]: # Very simple tokenizer: lowercase + alphanumeric word chunks return re.findall(r"\w+", text.lower()) def _lexical_overlap_score(model_text: str, ground_truth_text: str) -> float: """ Simple lexical overlap score in [0, 1]: score = |tokens(model) ∩ tokens(gt)| / |tokens(gt)| """ gt_tokens = _tokenize(ground_truth_text) model_tokens = _tokenize(model_text) if not gt_tokens: return 0.0 gt_set = set(gt_tokens) model_set = set(model_tokens) common = gt_set & model_set return len(common) / len(gt_set) def _calculate_fluency(text: str) -> float: """ Calculate a simple fluency score based on: - Average word length - Text length - Sentence structure Returns a score between 0 and 1. """ # Simple implementation - could be enhanced with more sophisticated NLP words = _tokenize(text) if not words: return 0.0 # Average word length normalized to [0,1] range # Assumption: average English word is ~5 chars, so normalize around that avg_word_len = sum(len(word) for word in words) / len(words) word_len_score = min(avg_word_len / 10, 1.0) # Text length score - favor reasonable length responses ideal_length = 100 # words length_score = min(len(words) / ideal_length, 1.0) # Simple sentence structure check (periods, question marks, etc.) sentence_count = len(re.findall(r'[.!?]+', text)) + 1 sentence_ratio = min(sentence_count / (len(words) / 15), 1.0) # Combine scores fluency_score = (word_len_score + length_score + sentence_ratio) / 3 return fluency_score ``` **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 in the traditional sense. However, the development and deployment of AI systems like me involve extensive security measures, including data encryption, user privacy protection, and other safeguards to ensure safe and responsible use." } ] } ], "reference_answer": { "compliant": "No", "explanation": "As an AI developed by Company, I do not have a traditional security team. However, the deployment involves stringent safety measures, such as encryption and privacy safeguards." } } ] ``` **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 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 «Ricompensa» (utilizzato nella formazione) ## autorizzazioni IAM **Autorizzazioni richieste** Il tuo ruolo di esecuzione SageMaker AI deve disporre delle autorizzazioni per richiamare la tua funzione Lambda. Aggiungi questa policy al tuo ruolo di esecuzione dell' SageMaker IA: ``` { "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 tua funzione Lambda accede AWS ad altri servizi (ad esempio, Amazon 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** + Formattate i dati di valutazione in base ai requisiti di formato dei dati + Carica il tuo file JSONL su Amazon 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 lavoro di valutazione utilizzando il notebook fornito: Notebook di [valutazione del modello Nova](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook) 1. **Monitora i progressi** Monitora il tuo lavoro di valutazione tramite: + SageMaker Console AI: controlla lo stato e i registri del lavoro + 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 alla posizione Amazon 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 | Scarso | 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.