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 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). **Che 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é valutare 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\_answer **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\_code: generazione di codice** e valutazione della correttezza + **prime\_math: 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\_code** **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\_math** **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.