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à.
# Personalizzazione di Amazon Nova su SageMaker Training Jobs
SageMaker Training Jobs è un ambiente che consente di addestrare modelli di machine learning su larga scala. Forniscono e scalano automaticamente le risorse di calcolo, caricano i dati di addestramento da fonti come Amazon S3, eseguono il codice di addestramento e archiviano gli artefatti dei modelli risultanti.
Lo scopo dell’addestramento è personalizzare il modello di base di Amazon Nova utilizzando dati proprietari. Il processo di formazione prevede in genere passaggi per preparare i dati, scegliere una [ricetta](nova-model-recipes.md), modificare i parametri di configurazione nei file YAML e inviare un lavoro di formazione. Il processo di addestramento genera un checkpoint del modello addestrato in un bucket Amazon S3 gestito dal servizio. È possibile utilizzare la posizione di questo checkpoint per processi di valutazione. La personalizzazione di Nova sui lavori di formazione sull' SageMaker intelligenza artificiale archivia gli artefatti del modello in un bucket Amazon S3 gestito dal servizio. Gli artefatti nel bucket gestito dal servizio sono crittografati con chiavi KMS gestite dall'intelligenza artificiale. SageMaker I bucket Amazon S3 gestiti dal servizio attualmente non supportano la crittografia dei dati tramite chiavi KMS gestite dal cliente.
## Best practice per la personalizzazione di Amazon Nova
### Panoramica di
Questa sezione fornisce una panoramica delle tecniche di personalizzazione e ti aiuta a scegliere l'approccio migliore per le tue esigenze e i dati disponibili.
#### Due fasi della formazione LLM
La formazione su modello linguistico di grandi dimensioni consiste in due fasi principali: pre-formazione e post-formazione. Durante la formazione preliminare, il modello elabora i token di testo non elaborato e li ottimizza per la previsione del token successivo. Questo processo crea un completatore di modelli che assorbe la sintassi, la semantica, i fatti e gli schemi di ragionamento dal web e dal testo curato. Tuttavia, il modello pre-addestrato non comprende le istruzioni, gli obiettivi dell'utente o il comportamento appropriato al contesto. Continua il testo in qualsiasi stile si adatti alla distribuzione della formazione. Un modello già addestrato si completa automaticamente anziché seguire le istruzioni, produce una formattazione incoerente e può rispecchiare pregiudizi indesiderati o contenuti non sicuri presenti nei dati di addestramento. La formazione preliminare rafforza la competenza generale, non l'utilità delle attività.
Dopo l'allenamento, il Pattern Completer si trasforma in un utile assistente. Si eseguono diversi cicli di Supervised Fine-Tuning (SFT) per insegnare al modello a seguire le istruzioni, aderire a schemi e politiche, chiamare strumenti e produrre risultati affidabili imitando dimostrazioni di alta qualità. Questo allineamento insegna al modello a rispondere alle istruzioni come attività anziché come testo per continuare. Si applica quindi il Reinforcement Fine-Tuning (RFT) per ottimizzare il comportamento utilizzando feedback misurabili (ad esempio verificatori o altro), bilanciando compromessi come la precisione rispetto alla brevità, la sicurezza rispetto alla copertura o il LLM-as-a-judge ragionamento in più fasi in base ai vincoli. In pratica, si alternano SFT e RFT in cicli per modellare il modello pre-addestrato in un sistema affidabile e allineato alle politiche che esegue attività complesse in modo coerente.
### Scegliete il giusto approccio di personalizzazione
In questa sezione tratteremo le strategie di personalizzazione post-formazione: RFT e SFT.
#### Ottimizzazione precisa dei rinforzi (RFT)
La messa a punto del rinforzo migliora le prestazioni del modello attraverso segnali di feedback (punteggi misurabili o premi che indicano la qualità della risposta) anziché la supervisione diretta con risposte esatte e corrette. A differenza della tradizionale ottimizzazione supervisionata che apprende dalle coppie di input-output, RFT utilizza le funzioni di ricompensa per valutare le risposte del modello e ottimizza iterativamente il modello per massimizzare tali ricompense. Questo approccio è ideale per le attività in cui è difficile definire l'output esatto e corretto, ma è possibile misurare in modo affidabile la qualità della risposta. RFT consente ai modelli di apprendere comportamenti e preferenze complessi attraverso prove e feedback, il che lo rende ideale per applicazioni che richiedono un processo decisionale articolato, una risoluzione creativa dei problemi o il rispetto di criteri di qualità specifici che è possibile valutare programmaticamente. Ad esempio, rispondere a domande legali complesse è un caso d'uso ideale per RFT perché si desidera insegnare al modello come ragionare meglio per rispondere alle domande in modo più accurato.
##### Come funziona
Nella messa a punto dei rinforzi, si parte da una linea di base basata sulle istruzioni e si tratta ogni richiesta come un piccolo torneo. In base a un determinato contributo, si campionano alcune risposte dei candidati tratte dal modello, si assegna un punteggio a ciascuna di esse con la funzione di ricompensa, quindi le si classifica all'interno di quel gruppo. La fase di aggiornamento spinge il modello a rendere più propensi i candidati con punteggi più alti la prossima volta e meno quelli con punteggi più bassi, mentre un stay-close-to-baseline vincolo impedisce che il comportamento diventi prolisso o sfruttatore. Ripeti questo ciclo su molte richieste, aggiornando i casi più complessi, rendendo più rigorosi i verificatori o giudicando le rubriche quando vedi degli exploit e monitorando continuamente le metriche relative alle attività.
##### Quando usare RFT
Le attività che traggono i maggiori vantaggi da RFT hanno diverse caratteristiche in comune. Offrono segnali di successo misurabili anche quando è difficile specificare un singolo output corretto. Ammettono crediti parziali o una qualità graduata, in modo da poter classificare le risposte migliori rispetto a quelle peggiori in un prompt o utilizzando una funzione di ricompensa. Esse implicano molteplici obiettivi che devono essere bilanciati (ad esempio precisione e brevità, chiarezza, sicurezza o costi). Richiedono il rispetto di vincoli espliciti che è possibile verificare a livello di codice. Operano in ambienti mediati da strumenti o basati sull'ambiente in cui i risultati sono osservabili (successo o fallimento, latenza, utilizzo delle risorse). Si verificano in regimi in cui la raccolta di obiettivi prioritari è costosa, ma il feedback automatizzato o basato sulle rubriche è abbondante. RFT funziona al meglio quando è possibile trasformare la qualità in uno scalare o in una classifica affidabile e se si desidera che il modello amplifichi preferenzialmente i comportamenti che ottengono punteggi più elevati senza bisogno di obiettivi etichettati esaustivi.
**Prendi in considerazione altri metodi quando:**
+ Disponete di numerose e affidabili coppie di ingresso/uscita etichettate: utilizzate SFT
+ La lacuna principale è la conoscenza o il gergo: utilizzate la generazione aumentata di recupero (RAG)
+ Il segnale di ricompensa è rumoroso o inaffidabile e non è possibile correggerlo con rubriche o pedine migliori: stabilizzalo prima di RFT
##### Quando non usare RFT
Evita l'RFT in queste situazioni:
+ È possibile produrre coppie ingresso-uscita etichettate affidabili a basso costo (SFT è più semplice, economico e stabile)
+ Il divario è la conoscenza o il gergo piuttosto che il comportamento (usa RAG)
+ Il tuo segnale di ricompensa è rumoroso, scarso, facile da usare, costoso o lento da calcolare (correggi prima il valutatore)
+ Le prestazioni di base sono prossime allo zero (avviate con SFT prima di ottimizzare le preferenze)
+ L'attività ha schemi deterministici, una formattazione rigorosa o un'unica risposta corretta (la SFT o la convalida basata su regole funzionano meglio)
+ I budget limitati in termini di latenza o costi non sono in grado di assorbire i costi aggiuntivi di campionamento o esplorazione richiesti da RFT
+ I vincoli relativi alla sicurezza o alle politiche non sono specificati in modo preciso e applicabili nella ricompensa
Se riesci a indicare «la risposta giusta», usa SFT. Se hai bisogno di nuove conoscenze, usa RAG. Usa RFT solo dopo avere una base solida e una funzione di ricompensa robusta e veloce. hard-to-exploit
#### Fine-tuning supervisionato (SFT)
La messa a punto supervisionata addestra l'LLM su un set di dati di coppie input-output etichettate dall'uomo per ogni attività. Fornite esempi di richieste (domande, istruzioni e così via) con le risposte corrette o desiderate e continuate ad addestrare il modello sulla base di questi esempi. Il modello regola i propri pesi per ridurre al minimo una perdita supervisionata (in genere entropia incrociata tra le previsioni e i token di output target). Questa è la stessa formazione utilizzata nella maggior parte delle attività di apprendimento automatico supervisionate, applicata per specializzare un LLM.
La SFT modifica il comportamento, non la conoscenza. Non insegna al modello nuovi fatti o gerghi che non aveva appreso durante il pre-allenamento. Insegna al modello come rispondere, non cosa sapere. Se hai bisogno di nuove conoscenze di dominio (come la terminologia interna), usa la generazione aumentata di recupero (RAG) per fornire quel contesto al momento dell'inferenza. SFT aggiunge quindi il comportamento desiderato di seguire le istruzioni.
##### Come funziona
SFT ottimizza LLM riducendo al minimo la perdita media di entropia incrociata sui token di risposta, trattando i token prompt come contesto e mascherandoli dalla perdita. Il modello interiorizza lo stile, la struttura e le regole decisionali dell'obiettivo, imparando a generare il completamento corretto per ogni prompt. Ad esempio, per classificare i documenti in categorie personalizzate, si ottimizza il modello con istruzioni (il testo del documento) e completamenti etichettati (le etichette delle categorie). Ci si allena su queste coppie finché il modello non restituisce l'etichetta corretta per ogni prompt con alta probabilità.
È possibile eseguire SFT con poche centinaia di esempi e scalare fino a qualche centinaio di migliaia. I campioni SFT devono essere di alta qualità e allineati direttamente al comportamento del modello desiderato.
##### Quando usare SFT
Usa SFT quando hai un'attività ben definita con risultati chiari e desiderati. Se potete dichiarare esplicitamente «Dato l'input X, l'output corretto è Y» e raccogliere esempi di tali mappature, la regolazione fine supervisionata è una buona scelta. SFT eccelle in questi scenari:
+ Attività di **classificazione strutturate o complesse**: classificate documenti o contratti interni in molte categorie personalizzate. Con SFT, il modello impara queste categorie specifiche meglio di quanto lo faccia da solo.
+ **Attività di risposta a domande o di trasformazione con risposte note**: perfeziona un modello per rispondere alle domande della knowledge base di un'azienda o converti i dati tra formati in cui ogni input ha una risposta corretta.
+ **Formattazione e coerenza stilistica**: addestrate il modello a rispondere sempre in un determinato formato o tono perfezionando gli esempi del formato o del tono corretti. Ad esempio, la formazione sulle coppie di risposte rapide che dimostrano la voce di un marchio specifica insegna al modello a generare risultati con quello stile. Il comportamento che segue le istruzioni viene spesso insegnato inizialmente tramite SFT sulla base di esempi curati di buon comportamento degli assistenti.
L'SFT è il modo più diretto per insegnare a un LLM una nuova abilità o un nuovo comportamento quando è possibile specificare quale sia il comportamento giusto. Utilizza la comprensione linguistica esistente del modello e la concentra sul tuo compito. Utilizzate SFT quando volete che il modello faccia una cosa specifica e avete o potete creare un set di dati di esempi.
Utilizzate SFT quando potete assemblare coppie di prompt e response di alta qualità che rispecchiano fedelmente il comportamento desiderato. Si adatta a compiti con obiettivi chiari o formati deterministici come schemi, chiamate a funzioni o strumenti e risposte strutturate in cui l'imitazione è un segnale di allenamento appropriato. L'obiettivo è modellare il comportamento: insegnare al modello a trattare i prompt come attività, seguire le istruzioni, adottare politiche di tono e rifiuto e produrre una formattazione coerente. Pianifica almeno centinaia di dimostrazioni, con la qualità, la coerenza e la deduplicazione dei dati più importanti del volume grezzo. Per un aggiornamento semplice ed economico, utilizza metodi efficienti in termini di parametri come Low-Rank Adaptation per addestrare piccoli adattatori lasciando intatta la maggior parte della spina dorsale.
##### Quando non usare SFT
Non utilizzare SFT quando il divario è la conoscenza piuttosto che il comportamento. Non insegna al modello nuovi fatti, gergo o eventi recenti. In questi casi, utilizza la generazione aumentata con recupero per portare conoscenze esterne all'inferenza. Evita l'SFT quando puoi misurare la qualità ma non riesci a etichettare una sola risposta corretta. Usa la messa a punto dei rinforzi con ricompense verificabili oppure una per ottimizzare direttamente tali ricompense. LLM-as-a-judge Se le tue esigenze o i tuoi contenuti cambiano frequentemente, affidati al recupero e all'uso degli strumenti piuttosto che alla riqualificazione del modello.
**Topics**
+ [Best practice per la personalizzazione di Amazon Nova](#best-practices)
+ [SDK Nova Forge](nova-forge-sdk.md)
+ [Formazione per i modelli Amazon Nova](smtj-training.md)
+ [Monitoraggio dei progressi tra le iterazioni](nova-model-monitor.md)
+ [Valutazione del modello basato sull' SageMaker intelligenza artificiale](nova-model-evaluation.md)
+ [Addestramento iterativo](smtj-iterative-training.md)
# SDK Nova Forge
Nova Forge SDK è un SDK Python completo per personalizzare i modelli Amazon Nova. L'SDK fornisce un'interfaccia unificata per la formazione, la valutazione, il monitoraggio, l'implementazione e l'inferenza dei modelli Amazon Nova su diverse piattaforme, tra cui AI SageMaker e Amazon Bedrock. Che tu stia adattando i modelli ad attività specifiche del dominio o ottimizzando le prestazioni per il tuo caso d'uso, questo SDK offre tutto ciò di cui hai bisogno in un'unica interfaccia unificata.
## Vantaggi
+ Un SDK per l'intero ciclo di vita della personalizzazione del modello, dalla preparazione dei dati all'implementazione e al monitoraggio.
+ Supporta diversi metodi di formazione, tra cui il pre-training continuo (CPT), la messa a punto supervisionata (SFT), l'ottimizzazione delle preferenze dirette (DPO) e la regolazione fine del rinforzo (RFT), sia a turno singolo che a turno multiplo, con approcci LoRa e full-rank.
+ Supporto integrato per SageMaker Training Jobs e Amazon Bedrock, con gestione automatica delle risorse. SageMaker HyperPod
+ Non è più necessario cercare le ricette o l'URI del contenitore giusti per le tue tecniche di allenamento.
+ Crea le tue ricette di formazione o utilizza le impostazioni predefinite intelligenti dell'SDK con le sostituzioni dei parametri.
+ L'SDK convalida la configurazione rispetto alle combinazioni di modelli e istanze supportate e fornisce supporto per la convalida, prevenendo gli errori prima dell'inizio della formazione.
+ CloudWatch Il monitoraggio integrato di Amazon ti consente di monitorare i progressi della formazione in tempo reale.
+ Integrato MLFlow per tenere traccia degli esperimenti di formazione con server di MLFlow tracciamento SageMaker AI.
## Requisiti
L'SDK richiede almeno Python 3.12.
## Installazione
Per installare questo SDK, segui il comando seguente.
```
pip install amzn-nova-forge
```
## Modelli e tecniche supportati
L'SDK supporta i seguenti modelli e tecniche all'interno della famiglia Amazon Nova:
****
| Metodo | Modelli supportati |
| --- | --- |
| Formazione preliminare continua | [Tutti i modelli Nova](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-recipes.html#nova-model-recipes-reference) (solo SMHP) |
| Ottimizzazione di LoRa supervisionata | [Tutti i modelli Nova](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-recipes.html#nova-model-recipes-reference) |
| Fine tuning supervisionato Full Rank | [Tutti i modelli Nova](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-recipes.html#nova-model-recipes-reference) (solo SMHP e SMTJ) |
| Ottimizzazione diretta delle preferenze LoRa | Modelli Nova 1.0 (solo SMHP e SMTJ) |
| Ottimizzazione diretta delle preferenze complete | Modelli Nova 1.0 (solo SMHP e SMTJ) |
| Rinforzo: ottimizzazione LoRa | Nova Lite 2.0 |
| Ottimizzazione dei rinforzi Full Rank | Nova Lite 2.0 (solo SMHP e SMTJ) |
| Rinforzo multigiro: ottimizzazione LoRa | Nova Lite 2.0 (solo SMHP) |
| Rinforzo multigiro, perfezionamento completo | Nova Lite 2.0 (solo SMHP) |
## Nozioni di base
**Topics**
+ [1. Prepara i tuoi dati](#nova-forge-sdk-prepare-data)
+ [2. Configura la tua infrastruttura](#nova-forge-sdk-configure-infrastructure)
+ [3. Addestramento](#nova-forge-sdk-train)
+ [4. Monitoraggio](#nova-forge-sdk-monitor)
+ [5. Valuta](#nova-forge-sdk-evaluate)
+ [6. Implementazione](#nova-forge-sdk-deploy)
### 1. Prepara i tuoi dati
Carica il tuo set di dati da file locali o da S3 e lascia che sia l'SDK a gestire la trasformazione nel formato corretto per il metodo di allenamento scelto. Oppure, fornisci dati formattati e inizia subito.
```
from amzn_nova_forge.dataset.dataset_loader import JSONLDatasetLoader
from amzn_nova_forge.model.model_enums import Model, TrainingMethod
loader = JSONLDatasetLoader(question="input", answer="output")
loader.load("s3://your-bucket/training-data.jsonl")
loader.transform(method=TrainingMethod.SFT_LORA, model=Model.NOVA_LITE)
```
### 2. Configura la tua infrastruttura
Scegli le tue risorse di elaborazione: l'SDK convalida le configurazioni e garantisce una configurazione ottimale.
```
from amzn_nova_forge.manager.runtime_manager import BedrockRuntimeManager, SMTJRuntimeManager, SMHPRuntimeManager
# Bedrock
runtime = BedrockRuntimeManager(
execution_role="arn:aws:iam::123456789012:role/ExampleRole"
)
# SageMaker Training Jobs
runtime = SMTJRuntimeManager(
instance_type="ml.p5.48xlarge",
instance_count=4
)
# SageMaker HyperPod
runtime = SMHPRuntimeManager(
instance_type="ml.p5.48xlarge",
instance_count=4,
cluster_name="my-hyperpod-cluster",
namespace="kubeflow"
)
```
### 3. Addestramento
Inizia l'allenamento con poche righe di codice.
```
from amzn_nova_forge.model import NovaModelCustomizer
from amzn_nova_forge.model.model_enums import Model, TrainingMethod
customizer = NovaModelCustomizer(
model=Model.NOVA_LITE_2,
method=TrainingMethod.SFT_LORA,
infra=runtime,
data_s3_path="s3://your-bucket/prepared-data.jsonl"
)
result = customizer.train(job_name="my-training-job")
```
### 4. Monitoraggio
Tieni traccia dei tuoi progressi di allenamento direttamente dall'SDK.
```
from amzn_nova_forge.monitor.log_monitor import CloudWatchLogMonitor
# Monitor training logs
customizer.get_logs()
# Or monitor directly via CloudWatchLogMonitor
monitor = CloudWatchLogMonitor.from_job_result(result)
monitor.show_logs(limit=10)
# Check job status
result.get_job_status() # InProgress, Completed, Failed
```
### 5. Valuta
Valuta le prestazioni del modello con una varietà di [benchmark integrati](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-benchmark) o progetta valutazioni personalizzate.
```
from amzn_nova_forge.recipe_config.eval_config import EvaluationTask
# Evaluate on benchmark tasks
eval_result = customizer.evaluate(
job_name="model-eval",
eval_task=EvaluationTask.MMLU,
model_path=result.model_artifacts.checkpoint_s3_path
)
```
### 6. Implementazione
Implementa il tuo modello personalizzato in produzione con il supporto integrato per Amazon Bedrock o. SageMaker
```
from amzn_nova_forge.model.model_enums import DeployPlatform
# Bedrock provisioned throughput
deployment = customizer.deploy(
model_artifact_path=result.model_artifacts.checkpoint_s3_path,
deploy_platform=DeployPlatform.BEDROCK_PT,
pt_units=10
)
# Bedrock On-Demand
deployment = customizer.deploy(
model_artifact_path=result.model_artifacts.checkpoint_s3_path,
deploy_platform=DeployPlatform.BEDROCK_OD,
pt_units=10
)
# Sagemaker Real-time Inference
deployment = customizer.deploy(
model_artifact_path=result.model_artifacts.checkpoint_s3_path,
deploy_platform=DeployPlatform.SAGEMAKER,
unit_count=10,
sagemaker_instance_type="ml.p5.48xlarge",
sagemaker_environment_variables={
"CONTEXT_LENGTH": "12000",
"MAX_CONCURRENCY": "16",
}
)
```
## Funzionalità chiave
### Creazione immediata di ricette
L'SDK elimina la necessità di cercare le ricette o l'URI del contenitore appropriati per tecniche specifiche.
### Elaborazione intelligente dei dati
L'SDK trasforma automaticamente i dati nel formato corretto per la formazione. Che tu stia lavorando con file JSON, JSONL o CSV, il data loader gestisce la conversione senza problemi. Data Loader supporta testo e dati multimodali (immagini e video).
### Supporto per l'infrastruttura aziendale
L'SDK funziona sia con SageMaker Training Jobs che con la SageMaker HyperPod gestione automatica di:
+ Convalida del tipo di istanza
+ Convalida della ricetta
+ Convalida di set di dati
+ Job orchestrazione e monitoraggio
L'SDK supporta anche la personalizzazione serverless di SageMaker Training Jobs e Bedrock.
### Valutazione completa
Valuta i tuoi modelli personalizzati rispetto a [benchmark standard](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-hp-evaluate.html), tra cui:
+ MMLU (Massive Multitask Language Understanding)
+ BBH (Attività di ragionamento avanzato)
+ GPQA (domande e risposte a prova di Google per laureati)
Utilizzate le impostazioni predefinite del benchmark o modificatele in base alle vostre esigenze:
+ BYOM (Bring Your Own Metric)
+ BYOD (Bring Your Own Dataset)
### Distribuzione in produzione
Distribuisci i tuoi modelli su Amazon Bedrock o SageMaker AI con opzioni per:
+ **Bedrock Provisioned Throughput**: capacità dedicata per prestazioni costanti
+ **Bedrock On-Demand (applicabile solo alla personalizzazione basata su LoRa) -** prezzi Pay-per-use
+ **SageMaker Inferenza AI in tempo reale: capacità dedicata per prestazioni** costanti
### Inferenza in batch
Esegui lavori di inferenza su larga scala in modo efficiente:
+ Elabora migliaia di richieste in parallelo
+ Aggregazione automatica dei risultati
+ Elaborazione in batch conveniente
### Nova Forge
Per gli abbonati a Nova Forge, l'SDK supporta ricette per la miscelazione dei dati.
## Ulteriori informazioni
Sei pronto per iniziare a personalizzare i modelli Nova con Nova Forge SDK? Consulta il nostro GitHub repository per guide dettagliate, riferimenti API ed esempi aggiuntivi: [https://github.com/aws/nova-forge-sdk](https://github.com/aws/nova-forge-sdk)
# Formazione per i modelli Amazon Nova
La formazione dei modelli Amazon Nova su SageMaker Training Jobs supporta Supervised Fine-Tuning (SFT) e Reinforcement Fine-Tuning (RFT). Ogni tecnica soddisfa esigenze di personalizzazione diverse e può essere applicata a diverse versioni del modello Amazon Nova.
**Topics**
+ [Ottimizza Nova 2.0](nova-fine-tune-2.md)
+ [Reinforcement Fine-Tuning (RFT) con modelli Amazon Nova](nova-reinforcement-fine-tuning.md)
# Ottimizza Nova 2.0
## Prerequisiti
Prima di avviare un job di addestramento, verifica i seguenti requisiti.
+ Bucket Amazon S3 per archiviare i dati di input e output dei job di addestramento. È possibile utilizzare un bucket per entrambi o bucket distinti per ogni tipo di dati. Assicurati che i tuoi bucket siano gli stessi in Regione AWS cui crei tutte le altre risorse per la formazione. Per ulteriori informazioni, consulta [Creating a general purpose bucket](https://docs.aws.amazon.com//AmazonS3/latest/userguide/create-bucket-overview.html).
+ Un ruolo IAM con autorizzazioni per eseguire un job di addestramento. Assicurati di collegare una policy IAM con `AmazonSageMakerFullAccess`. Per ulteriori informazioni, consulta [Come utilizzare i ruoli di esecuzione dell' SageMaker IA](https://docs.aws.amazon.com//sagemaker/latest/dg/sagemaker-roles.html).
+ Ricette base di Amazon Nova; consulta [Recupero di ricette Amazon Nova](nova-model-recipes.md#nova-model-get-recipes).
## Che cos'è SFT?
Il Supervised Fine-Tuning (SFT) addestra un modello linguistico utilizzando coppie di input-output etichettate. Il modello apprende da esempi dimostrativi costituiti da suggerimenti e risposte, perfezionando le proprie capacità per allinearsi a attività, istruzioni o comportamenti desiderati specifici.
## Preparazione dei dati
### Panoramica di
I dati SFT di Nova 2.0 utilizzano lo stesso formato API Converse di Nova 1.0, con l'aggiunta di campi di contenuto opzionali di ragionamento. Per le specifiche complete del formato, consulta:
+ Contenuto del ragionamento: [ReasoningContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ReasoningContentBlock.html)
+ [Schema dell'API Converse: API Converse](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-call.html)
+ [Vincoli del set di dati: vincoli del set di dati](https://docs.aws.amazon.com/nova/latest/userguide/fine-tune-prepare-data-understanding.html)
### Funzionalità supportate
+ **Tipi di input**: testo, immagine o video nei blocchi di contenuti utente
+ **Contenuti dell'assistente**: risposte di solo testo e contenuti di ragionamento
+ **Composizione del set di dati**: deve essere omogenea. Scegli una delle seguenti opzioni:
+ Turni di solo testo
+ Testo \$1 giri di immagini
+ Svoltare testo e video (supporta la comprensione dei documenti)
**Importante**
Non è possibile combinare immagini e video all'interno dello stesso set di dati o in turni diversi.
### Limitazioni attuali
+ Contenuto di **ragionamento multimodale: sebbene il formato Converse supporti contenuti** di ragionamento basati su immagini, Nova 2.0 SFT supporta solo contenuti di ragionamento basati su testo nel campo ReasoningText.
+ Set di convalida: non è possibile fornire un set di dati di **convalida** per SFT con Nova 2.0. Se fornite un set di dati di convalida, questo viene ignorato durante l'addestramento. Questa limitazione si applica sia agli invii di lavoro basati sull'interfaccia utente che a quelli programmatici.
### Formati multimediali supportati
+ **Immagini**: PNG, JPEG, GIF
+ **Video**: MOV, MKV, MP4
### Esempi di formati di dati
------
#### [ Text-only (Nova 1.0 compatible) ]
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are a digital assistant with a friendly personality"
}
],
"messages": [
{
"role": "user",
"content": [
{
"text": "What country is right next to Australia?"
}
]
},
{
"role": "assistant",
"content": [
{
"text": "The closest country is New Zealand"
}
]
}
]
}
```
------
#### [ Text with reasoning (Nova 2.0) ]
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are a digital assistant with a friendly personality"
}
],
"messages": [
{
"role": "user",
"content": [
{
"text": "What country is right next to Australia?"
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "I need to use my world knowledge of geography to answer this question"
}
}
},
{
"text": "The closest country to Australia is New Zealand, located to the southeast across the Tasman Sea."
}
]
}
]
}
```
------
#### [ Image \$1 text input ]
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are a helpful assistant."
}
],
"messages": [
{
"role": "user",
"content": [
{
"image": {
"format": "jpeg",
"source": {
"s3Location": {
"uri": "s3://your-bucket/your-path/your-image.jpg",
"bucketOwner": "your-aws-account-id"
}
}
}
},
{
"text": "Which country is highlighted in the image?"
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "I will determine the highlighted country by examining its location on the map and using my geographical knowledge"
}
}
},
{
"text": "The highlighted country is New Zealand"
}
]
}
]
}
```
------
#### [ Video \$1 text input ]
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are a helpful assistant."
}
],
"messages": [
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://your-bucket/your-path/your-video.mp4",
"bucketOwner": "your-aws-account-id"
}
}
}
},
{
"text": "What is shown in this video?"
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "I will analyze the video content to identify key elements"
}
}
},
{
"text": "The video shows a map with New Zealand highlighted"
}
]
}
]
}
```
------
## Chiamata di strumenti
Nova 2.0 SFT supporta modelli di addestramento sui modelli di chiamata degli strumenti, consentendo al modello di apprendere quando e come richiamare strumenti o funzioni esterni.
### Formato dati per la chiamata degli strumenti
I dati di addestramento sulla chiamata agli strumenti includono una `toolConfig` sezione che definisce gli strumenti disponibili, oltre a turni di conversazione che mostrano i modelli di utilizzo degli strumenti.
**Esempio di input**
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are an expert in composing function calls."
}
],
"toolConfig": {
"tools": [
{
"toolSpec": {
"name": "getItemCost",
"description": "Retrieve the cost of an item from the catalog",
"inputSchema": {
"json": {
"type": "object",
"properties": {
"item_name": {
"type": "string",
"description": "The name of the item to retrieve cost for"
},
"item_id": {
"type": "string",
"description": "The ASIN of item to retrieve cost for"
}
},
"required": [
"item_id"
]
}
}
}
},
{
"toolSpec": {
"name": "getItemAvailability",
"description": "Retrieve whether an item is available in a given location",
"inputSchema": {
"json": {
"type": "object",
"properties": {
"zipcode": {
"type": "string",
"description": "The zipcode of the location to check in"
},
"quantity": {
"type": "integer",
"description": "The number of items to check availability for"
},
"item_id": {
"type": "string",
"description": "The ASIN of item to check availability for"
}
},
"required": [
"item_id", "zipcode"
]
}
}
}
}
]
},
"messages": [
{
"role": "user",
"content": [
{
"text": "I need to check whether there are twenty pieces of the following item available. Here is the item ASIN on Amazon: id-123. Please check for the zipcode 94086"
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "The user wants to check how many pieces of the item with ASIN id-123 are available in the zipcode 94086"
}
}
},
{
"toolUse": {
"toolUseId": "getItemAvailability_0",
"name": "getItemAvailability",
"input": {
"zipcode": "94086",
"quantity": 20,
"item_id": "id-123"
}
}
}
]
},
{
"role": "user",
"content": [
{
"toolResult": {
"toolUseId": "getItemAvailability_0",
"content": [
{
"text": "[{\"name\": \"getItemAvailability\", \"results\": {\"availability\": true}}]"
}
]
}
}
]
},
{
"role": "assistant",
"content": [
{
"text": "Yes, there are twenty pieces of item id-123 available at 94086. Would you like to place an order or know the total cost?"
}
]
}
]
}
```
### Requisiti di chiamata degli strumenti
Quando create dati di addestramento per le chiamate agli strumenti, attenetevi ai seguenti requisiti:
| Requisito | Description |
| --- | --- |
| ToolUse collocamento | ToolUse deve apparire solo nei turni degli assistenti |
| ToolResult collocamento | ToolResult deve apparire solo nei turni degli utenti |
| ToolResult formato | ToolResult deve essere solo testo o JSON. Altre modalità non sono supportate per i modelli Nova |
| Formato InputSchema | L'inputSchema all'interno di ToolSpec deve essere un oggetto Schema JSON valido |
| toolUseId corrispondente | Ciascuno ToolResult deve fare riferimento a un assistente valido toolUseId di un precedente ToolUse, e ognuno deve toolUseId essere usato esattamente una volta per conversazione |
### Note importanti
+ Assicurati che le definizioni degli strumenti siano coerenti in tutti gli esempi di formazione
+ Il modello apprende i modelli di invocazione degli strumenti dalle dimostrazioni fornite
+ Includi diversi esempi di quando usare ogni strumento e quando non usare gli strumenti
## Comprensione dei documenti
Nova 2.0 SFT supporta la formazione sulle attività basate su documenti, consentendo al modello di imparare ad analizzare e rispondere alle domande sui documenti PDF.
### Formato dei dati per la comprensione dei documenti
I dati di formazione sulla comprensione dei documenti includono riferimenti ai documenti nei blocchi di contenuti utente, mentre il modello impara a estrarre e ragionare sul contenuto del documento.
**Esempio di input**
```
{
{
"schemaVersion": "bedrock-conversation-2024",
"messages": [
{
"role": "user",
"content": [
{
"text": "What are the ways in which a customer can experience issues during checkout on Amazon?"
},
{
"document": {
"format": "pdf",
"source": {
"s3Location": {
"uri": "s3://my-bucket-name/path/to/documents/customer_service_debugging.pdf",
"bucketOwner": "123456789012"
}
}
}
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "I need to find the relevant section in the document to answer the question."
}
}
},
{
"text": "Customers can experience issues with 1. Data entry, 2. Payment methods, 3. Connectivity while placing the order. Which one would you like to dive into?"
}
]
}
]
}
}
```
### Limiti alla comprensione dei documenti
| Limitazione | Informazioni |
| --- | --- |
| Formato supportato | Solo file PDF |
| Dimensione massima del documento | 10 MB |
| Miscelazione delle modalità | Un campione può contenere documenti e testo, ma non può contenere documenti mescolati con altre modalità (immagini, video) |
### Le migliori pratiche per la comprensione dei documenti
+ Assicurati che i documenti siano formattati in modo chiaro e che il testo sia estraibile
+ Fornisci diversi esempi che coprono diversi tipi di documenti e formati di domande
+ Includi contenuti di ragionamento per aiutare il modello ad apprendere i modelli di analisi dei documenti
## Comprensione dei video
Nova 2.0 SFT supporta la formazione sulle attività basate su video, consentendo al modello di imparare ad analizzare e rispondere alle domande sui contenuti video.
### Formato dei dati per la comprensione dei video
I dati di formazione sulla comprensione dei video includono riferimenti video nei blocchi di contenuti utente, mentre il modello impara a estrarre informazioni e ragionare sui contenuti video.
**Esempio di input**
```
{
"schemaVersion": "bedrock-conversation-2024",
"messages": [
{
"role": "user",
"content": [
{
"text": "What are the ways in which a customer can experience issues during checkout on Amazon?"
},
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://my-bucket-name/path/to/videos/customer_service_debugging.mp4",
"bucketOwner": "123456789012"
}
}
}
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "I need to find the relevant section in the video to answer the question."
}
}
},
{
"text": "Customers can experience issues with 1. Data entry, 2. Payment methods, 3. Connectivity while placing the order. Which one would you like to dive into?"
}
]
}
]
}
```
### Limitazioni sulla comprensione dei video
| Limitazione | Informazioni |
| --- | --- |
| Dimensione massima del video | 50 MB |
| Durata massima del video | 15 minuti |
| Video per campione | È consentito un solo video per campione. Non sono supportati più video nello stesso campione |
| Miscelazione delle modalità | Un campione può contenere video e testo, ma non può combinare video con altre modalità (immagini, documenti) |
### Formati video supportati
+ MOV
+ MKV
+ MP4
### Le migliori pratiche per la comprensione dei video
+ Mantieni i video concisi e incentrati sui contenuti pertinenti alla tua attività
+ Assicurati che la qualità video sia sufficiente per consentire al modello di estrarre informazioni significative
+ Fornisci domande chiare che facciano riferimento ad aspetti specifici dei contenuti video
+ Includi diversi esempi che coprono diversi tipi di video e formati di domande
## Modalità di ragionamento e non ragionamento
### Comprensione del contenuto del ragionamento
Il contenuto del ragionamento (chiamato anche chain-of-thought) cattura le fasi di pensiero intermedie del modello prima di generare una risposta finale. A `assistant` sua volta, usa il `reasoningContent` campo per includere queste tracce di ragionamento.
**Come viene calcolata la perdita**
+ **Con contenuto di ragionamento**: la perdita di formazione include sia i token di ragionamento che i token di output finale
+ **Senza contenuti di ragionamento**: la perdita di formazione viene calcolata solo sui token di output finali
Puoi includere più turni di assistente `reasoningContent` in conversazioni a turni multipli.
**Linee guida per la formattazione**
+ Usa testo semplice per ragionare i contenuti
+ Evita i tag di markup come `` e `` a meno che non siano specificamente richiesti dalla tua attività
+ Assicurati che il contenuto del ragionamento sia chiaro e pertinente al processo di risoluzione dei problemi
### Quando abilitare la modalità di ragionamento
Imposta `reasoning_enabled: true` nella configurazione di allenamento quando:
+ I tuoi dati di allenamento contengono token di ragionamento
+ Volete che il modello generi token di pensiero prima di produrre gli output finali
+ È necessario migliorare le prestazioni in attività di ragionamento complesse
È consentito addestrare Nova su un set di dati non ragionevoli con. `reasoning_enabled = true` Tuttavia, così facendo il modello potrebbe perdere le sue capacità di ragionamento, poiché Nova impara principalmente a generare le risposte presentate nei dati senza applicare il ragionamento. Se vuoi addestrare Nova su un set di dati non ragionante ma ti aspetti comunque un ragionamento durante l'inferenza, puoi disabilitare il ragionamento durante l'addestramento () ma abilitarlo per l'inferenza. `reasoning_enabled = false` Sebbene questo approccio consenta di utilizzare il ragionamento in fase di inferenza, non garantisce prestazioni migliori rispetto all'inferenza senza ragionamento. In generale, abilita il ragionamento sia per l'addestramento che per l'inferenza quando si utilizzano set di dati di ragionamento e disabilitalo per entrambi quando si utilizzano set di dati non di ragionamento.
Imposta quando: `reasoning_enabled: false`
+ I tuoi dati di allenamento non dispongono di token di ragionamento
+ Ti stai allenando su attività semplici che non traggono vantaggio da passaggi di ragionamento espliciti
+ Vuoi ottimizzare la velocità e ridurre l'utilizzo dei token
### Generazione di dati di ragionamento
Se il tuo set di dati non contiene tracce di ragionamento, puoi crearle utilizzando un modello in grado di ragionare come Nova Premier. Fornisci le tue coppie di input-output al modello e acquisisci il relativo processo di ragionamento per creare un set di dati basato sul ragionamento.
### Utilizzo di token di ragionamento per la formazione
Quando si allena con la modalità di ragionamento abilitata, il modello impara a separare il ragionamento interno dalla risposta finale. Il processo di formazione:
+ Organizza i dati in tre parti: input, ragionamento e risposta
+ Ottimizza l'utilizzo degli standard di previsione del token successivo (perdita derivante sia dai token di ragionamento che da quelli di risposta)
+ Incoraggia il modello a ragionare internamente prima di generare risposte
### Contenuti di ragionamento efficaci
I contenuti di ragionamento di alta qualità dovrebbero includere:
+ Pensieri e analisi intermedi
+ Deduzioni logiche e fasi di inferenza
+ Step-by-step approcci per la risoluzione dei problemi
+ Connessioni esplicite tra fasi e conclusioni
Questo aiuta il modello a sviluppare la capacità di «pensare prima di rispondere».
## Linee guida per la preparazione dei dataset
### Dimensioni e qualità
+ **Dimensione consigliata**: 2.000-10.000 campioni
+ **Campioni minimi: 200**
+ **Priorità**: qualità rispetto alla quantità. Assicurati che gli esempi siano accurati e ben annotati
+ **Allineamento delle applicazioni**: il set di dati deve rispecchiare fedelmente i casi d'uso in produzione
### Diversità
Includi diversi esempi che:
+ Copre l'intera gamma di input previsti
+ Rappresenta diversi livelli di difficoltà
+ Includi casi limite e varianti
+ Evita l'eccessivo adattamento a modelli ristretti
### Formattazione dell'output
Specificate chiaramente il formato di output desiderato nelle risposte dell'assistente:
+ Strutture JSON
+ Tabelle
+ Formato CSV
+ Formati personalizzati specifici per la tua applicazione
### Conversazioni a più turni
Per set di dati a turni multipli, ricorda:
+ La perdita viene calcolata solo in base ai turni degli assistenti, non ai turni degli utenti
+ Ogni risposta dell'assistente deve essere formattata correttamente
+ Mantieni la coerenza nei turni di conversazione
### Lista di controllo della qualità
+ Dimensioni sufficienti del set di dati (campioni da 2K-10K)
+ Diversi esempi che coprono tutti i casi d'uso
+ Formattazione di output chiara e coerente
+ Etichette e annotazioni accurate
+ Rappresentante degli scenari di produzione
+ Liberi da contraddizioni o ambiguità
### Caricamento dei dati
I set di dati devono essere caricati in un bucket accessibile dai corsi di formazione. SageMaker [Per informazioni sull'impostazione delle autorizzazioni corrette, consulta Prerequisiti.](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-general-prerequisites.html)
## Avvio di un lavoro di formazione
### Selezione degli iperparametri e aggiornamento della ricetta
La configurazione di Nova 2.0 è in gran parte la stessa di Nova 1.0. Una volta che i dati di input sono stati caricati su S3, usa la ricetta contenuta nella cartella [SageMaker HyperPod Recipes](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/fine-tuning/nova) nella cartella Fine tuning. Per Nova 2.0, di seguito sono riportati alcuni degli iperparametri chiave che è possibile aggiornare in base al caso d'uso. Di seguito è riportato un esempio della ricetta Nova 2.0 SFT PEFT. Per l'URI dell'immagine del contenitore, utilizzare `708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-fine-tune-repo:SM-TJ-SFT-V2-latest` per eseguire un processo di ottimizzazione SFT.
Utilizza la versione 2.254.1 di SageMaker AI PySDK per una stretta compatibilità con Nova Training. L'aggiornamento dell'SDK alla versione v3.0 comporterà modifiche sostanziali. Il supporto per la versione 3 di SageMaker AI PySDK sarà presto disponibile.
**Esempio di input**
```
!pip install sagemaker==2.254.1
```
```
run:
name: {peft_recipe_job_name}
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: {peft_model_name_or_path}
data_s3_path: {train_dataset_s3_path} # SageMaker HyperPod (SMHP) only and not compatible with SageMaker Training jobs. Note replace my-bucket-name with your real bucket name for SMHP job
replicas: 4 # Number of compute instances for training, allowed values are 4, 8, 16, 32
output_s3_path: "" # Output artifact path (Hyperpod job-specific; not compatible with standard SageMaker Training jobs). Note replace my-bucket-name with your real bucket name for SMHP job
training_config:
max_steps: 10 # Maximum training steps. Minimal is 4.
save_steps: 10 # How many training steps the checkpoint will be saved. Should be less than or equal to max_steps
save_top_k: 1 # Keep top K best checkpoints. Note supported only for SageMaker HyperPod jobs. Minimal is 1.
max_length: 32768 # Sequence length (options: 8192, 16384, 32768 [default], 65536)
global_batch_size: 32 # Global batch size (options: 32, 64, 128)
reasoning_enabled: true # If data has reasoningContent, set to true; otherwise False
lr_scheduler:
warmup_steps: 15 # Learning rate warmup steps. Recommend 15% of max_steps
min_lr: 1e-6 # Minimum learning rate, must be between 0.0 and 1.0
optim_config: # Optimizer settings
lr: 1e-5 # Learning rate, must be between 0.0 and 1.0
weight_decay: 0.0 # L2 regularization strength, must be between 0.0 and 1.0
adam_beta1: 0.9 # Exponential decay rate for first-moment estimates, must be between 0.0 and 1.0
adam_beta2: 0.95 # Exponential decay rate for second-moment estimates, must be between 0.0 and 1.0
peft: # Parameter-efficient fine-tuning (LoRA)
peft_scheme: "lora" # Enable LoRA for PEFT
lora_tuning:
alpha: 64 # Scaling factor for LoRA weights ( options: 32, 64, 96, 128, 160, 192),
lora_plus_lr_ratio: 64.0
```
La ricetta contiene anche in gran parte gli stessi iperparametri di Nova 1.0. Gli iperparametri più importanti sono:
+ `max_steps`— Il numero di passaggi per i quali si desidera eseguire il processo. In genere, per un'epoca (una analisi dell'intero set di dati), il numero di passaggi = numero di campioni di dati/dimensione globale del batch. Maggiore è il numero di passaggi e minore è la dimensione del batch globale, maggiore sarà il tempo necessario per l'esecuzione del processo.
+ `reasoning_enabled`— Controlla la modalità di ragionamento per il set di dati. Opzioni:
+ `true`: abilita la modalità di ragionamento (equivalente al ragionamento elevato)
+ `false`: disabilita la modalità di ragionamento
Nota: per SFT, non esiste un controllo granulare sui livelli di sforzo di ragionamento. L'impostazione `reasoning_enabled: true` consente la piena capacità di ragionamento.
+ `peft.peft_scheme`— L'impostazione su «lora» consente la regolazione fine basata su PEFT. L'impostazione su null (senza virgolette) abilita la regolazione fine Full-Rank.
### Inizia il lavoro di formazione
```
from sagemaker.pytorch import PyTorch
# define OutputDataConfig path
if default_prefix:
output_path = f"s3://{bucket_name}/{default_prefix}/{sm_training_job_name}"
else:
output_path = f"s3://{bucket_name}/{sm_training_job_name}"
output_kms_key = "" # optional, leave blank for Amazon managed encryption
recipe_overrides = {
"run": {
"replicas": instance_count, # Required
"output_s3_path": output_path
},
}
estimator = PyTorch(
output_path=output_path,
base_job_name=sm_training_job_name,
role=role,
disable_profiler=True,
debugger_hook_config=False,
instance_count=instance_count,
instance_type=instance_type,
training_recipe=training_recipe,
recipe_overrides=recipe_overrides,
max_run=432000,
sagemaker_session=sagemaker_session,
image_uri=image_uri,
output_kms_key=output_kms_key,
tags=[
{'Key': 'model_name_or_path', 'Value': model_name_or_path},
]
)
print(f"\nsm_training_job_name:\n{sm_training_job_name}\n")
print(f"output_path:\n{output_path}")
```
```
from sagemaker.inputs import TrainingInput
train_input = TrainingInput(
s3_data=train_dataset_s3_path,
distribution="FullyReplicated",
s3_data_type="Converse",
)
estimator.fit(inputs={"validation": val_input}, wait=False)
```
**Nota**
Il passaggio di un set di dati di convalida non è supportato per la regolazione fine supervisionata di Nova 2.0.
Per dare il via al lavoro:
+ Aggiorna la ricetta con i percorsi e gli iperparametri del set di dati
+ Esegui le celle specificate nel notebook per inviare il lavoro di formazione
Il notebook gestisce l'invio dei lavori e ne monitora lo stato.
# Reinforcement Fine-Tuning (RFT) con modelli Amazon Nova
## Panoramica di
**Che cos'è RFT?**
Il Reinforcement Fine-Tuning (RFT) migliora le prestazioni del modello addestrandosi sui segnali di feedback (punteggi misurabili o premi che indicano le prestazioni del modello) anziché sulle risposte esatte e corrette. A differenza della messa a punto supervisionata che apprende dalle coppie input-output, RFT utilizza le funzioni di ricompensa per valutare le risposte del modello e ottimizza iterativamente il modello per massimizzare tali ricompense. Questo approccio eccelle quando è difficile definire l'output esatto e corretto, ma è possibile misurare in modo affidabile la qualità della risposta.
**Quando usare RFT**
Usa RFT quando puoi definire criteri di successo chiari e misurabili ma hai difficoltà a fornire risultati esatti e corretti per la formazione. È ideale per:
+ Attività in cui la qualità è soggettiva o multiforme (scrittura creativa, ottimizzazione del codice, ragionamento complesso)
+ Scenari con più soluzioni valide in cui alcune sono chiaramente migliori di altre
+ Applicazioni che richiedono miglioramento iterativo, personalizzazione o rispetto di regole aziendali complesse
+ Casi in cui la raccolta di esempi etichettati di alta qualità è costosa o poco pratica
**I migliori casi d'uso**
RFT eccelle nei settori in cui la qualità dell'output può essere misurata oggettivamente, ma le risposte ottimali sono difficili da definire in anticipo:
+ Risoluzione di problemi matematici e generazione di codice
+ Ragionamento scientifico e analisi strutturata dei dati
+ Compiti che richiedono step-by-step ragionamento o risoluzione di problemi a più turni
+ Applicazioni che bilanciano più obiettivi (precisione, efficienza, stile)
+ Scenari in cui il successo può essere verificato a livello di codice attraverso i risultati di esecuzione o le metriche delle prestazioni
**Modelli supportati**
Nova Lite 2.0
## Panoramica del formato dei dati
[I dati di addestramento RFT devono seguire il formato OpenAI Reinforcement Fine-Tuning.](https://platform.openai.com/docs/api-reference/fine-tuning/reinforcement-input) Ogni esempio di addestramento è un oggetto JSON contenente:
+ Un `messages` array con turni di conversazione, utilizzo e ruoli `system` `user`
+ Un `reference_answer` campo contenente l'output previsto o i criteri di valutazione per il calcolo della ricompensa
**Limitazioni attuali**
+ Solo testo
### Esempi di formati di dati
Ogni esempio deve essere su una sola riga del file JSONL, con un oggetto JSON per riga.
------
#### [ Chemistry problem ]
```
{
"id": "chem-01",
"messages": [
{
"role": "system",
"content": "You are a helpful chemistry assistant"
},
{
"role": "user",
"content": "Calculate the molecular weight of caffeine (C8H10N4O2)"
}
],
"reference_answer": {
"molecular_weight": 194.19,
"unit": "g/mol",
"calculation": "8(12.01) + 10(1.008) + 4(14.01) + 2(16.00) = 194.19"
}
}
```
------
#### [ Math problem ]
```
{
"id": "sample-001", // Optional
"messages": [
{
"role": "system",
"content": "You are a math tutor"
},
{
"role": "user",
"content": "Solve: 2x + 5 = 13"
}
],
"reference_answer": {
"solution": "x = 4",
"steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
}
}
```
------
#### [ Code problem ]
```
{
"id": "code-002",
"messages": [
{
"role": "system",
"content": "You are a helpful programming assistant"
},
{
"role": "user",
"content": "Write a Python function that reverses a string without using built-in reverse methods"
}
],
"reference_answer": {
"code": "def reverse_string(s): \n result = '' \n for i in range(len(s) - 1, -1, -1): \n result += s[i] \n return result",
"test_cases": [
{
"input": "hello",
"expected_output": "olleh"
},
{
"input": "",
"expected_output": ""
},
{
"input": "a",
"expected_output": "a"
},
{
"input": "Python123",
"expected_output": "321nohtyP"
}
],
"all_tests_pass": true
}
}
```
------
Il `reference_answer` campo contiene l'output previsto o i criteri di valutazione utilizzati dalla funzione di ricompensa per assegnare un punteggio alla risposta del modello. Non si limita agli output strutturati, ma può contenere qualsiasi formato che aiuti la funzione di ricompensa a valutare la qualità.
## Consigli sulle dimensioni dei set di dati
**Punto di partenza**
+ Minimo 100 esempi di formazione
+ Minimo 100 esempi di valutazione
**Approccio basato sulla valutazione**
Prima di investire nella formazione RFT su larga scala, valuta le prestazioni di base del tuo modello:
+ **Prestazioni elevate (ricompensa superiore al 95%)**: la tecnologia RFT potrebbe non essere necessaria: il modello offre già buone prestazioni
+ **Prestazioni molto scarse (ricompensa dello 0%)**: passate innanzitutto a SFT per stabilire le funzionalità di base
+ **Prestazioni moderate**: la tecnologia RFT è probabilmente appropriata
Iniziare con un set di dati di piccole dimensioni consente di:
+ Verifica che la tua funzione di ricompensa sia priva di bug
+ Conferma che RFT è l'approccio giusto per il tuo caso d'uso
+ Identifica e risolvi tempestivamente i problemi
+ Testa il flusso di lavoro prima di ampliarlo
Una volta convalidato, puoi espanderlo a set di dati più grandi per migliorare ulteriormente le prestazioni.
## Caratteristiche dei dati di allenamento efficaci
**Chiarezza e coerenza**
I buoni esempi RFT richiedono dati di input chiari e inequivocabili che consentano un calcolo accurato della ricompensa tra i diversi output del modello. Evita il rumore nei tuoi dati, tra cui:
+ Formattazione non coerente
+ Etichette o istruzioni contraddittorie
+ Istruzioni ambigue
+ Risposte di riferimento contrastanti
Qualsiasi ambiguità indurrà in errore il processo di formazione e indurrà il modello ad apprendere comportamenti non intenzionali.
**Diversità**
Il tuo set di dati dovrebbe catturare l'intera diversità dei casi d'uso di produzione per garantire solide prestazioni nel mondo reale. Include:
+ Diversi formati di input e custodie periferiche
+ Mappa i modelli effettivi di utilizzo della produzione sulla base dei log e delle analisi degli utenti
+ Esamina diversi tipi di utenti, aree geografiche e variazioni stagionali
+ Includi livelli di difficoltà da problemi semplici a complessi
**Considerazioni sulla funzione di ricompensa**
Progetta la tua funzione di ricompensa per un allenamento efficiente:
+ Esegui in pochi secondi (non in minuti)
+ Parallelizza efficacemente con Lambda
+ Restituisci punteggi coerenti e affidabili
+ Gestisci con eleganza diversi tipi di output del modello
Le funzioni di ricompensa veloci e scalabili consentono un'iterazione rapida e una sperimentazione conveniente.
## Proprietà aggiuntive
Il formato di dati RFT supporta campi personalizzati oltre ai requisiti di base dello schema (e). `messages` `reference_answer` Questa flessibilità consente di aggiungere tutti i dati aggiuntivi necessari alla funzione di ricompensa per una corretta valutazione.
**Nota**
Non è necessario configurarlo nella ricetta: il formato dei dati supporta intrinsecamente campi aggiuntivi. Basta includerli nei dati di allenamento JSON e verranno passati alla funzione di ricompensa sul campo. `metadata`
**Proprietà aggiuntive comuni**
Campi di metadati di esempio:
+ `task_id`— Identificatore univoco per il tracciamento
+ `difficulty_level`— Indicatore di complessità del problema
+ `domain`— Area o categoria tematica
+ `expected_reasoning_steps`— Numero di passaggi della soluzione
**Esempio con proprietà aggiuntive**
```
{
"messages": [
{
"role": "system",
"content": "You are a math tutor"
},
{
"role": "user",
"content": "Solve: 2x + 5 = 13"
}
],
"reference_answer": {
"solution": "x = 4",
"steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
},
"task_id": "algebra_001",
"difficulty_level": "easy",
"domain": "algebra",
"expected_reasoning_steps": 3
}
```
Questi campi aggiuntivi vengono passati alla funzione di ricompensa durante la valutazione, abilitando una sofisticata logica di punteggio personalizzata in base al caso d'uso specifico.
## Configurazione di addestramento
**Ricetta di esempio**
```
# Note:
# This recipe can run on p5.48xlarge and p5en.48xlarge instance types.
run:
name: "my-rft-run" # Unique run name (appears in logs/artifacts).
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod
data_s3_path: s3:/// # Training dataset in JSONL;
replicas: 4
reward_lambda_arn: arn:aws:lambda:::function:
## MLFlow configs
mlflow_tracking_uri: "" # Required for MLFlow
mlflow_experiment_name: "my-rft-experiment" # Optional for MLFlow. Note: leave this field non-empty
mlflow_run_name: "my-rft-run" # Optional for MLFlow. Note: leave this field non-empty
## SMTJ GRPO Training specific configs
training_config:
max_length: 8192 # Context window (tokens) for inputs+prompt;
global_batch_size: 16 # Total samples per optimizer step across all replicas (16/32/64/128/256).
reasoning_effort: high # Enables reasoning mode high / low / or null for non-reasoning
rollout: # How responses are generated for GRPO/advantage calc.
advantage_strategy:
number_generation: 2 # N samples per prompt to estimate advantages (variance vs cost).
generator:
max_new_tokens: 6000 # Cap on tokens generated per sample
set_random_seed: true # Seed generation for reproducibility across runs.
temperature: 1 # Softmax temperature;
top_k: 1 # Sample only from top-K logits
rewards:
preset_reward_function: null # Usage of preset reward functions [exact_match]
api_endpoint:
lambda_arn: arn:aws:lambda:::function:
lambda_concurrency_limit: 12 # Max concurrent Lambda invocations (throughput vs. throttling).
trainer:
max_steps: 2 # Steps to train for. One Step = global_batch_size
save_steps: 5
test_steps: 1
# RL parameters
ent_coeff: 0.0 # A bonus added to the policy loss that rewards higher-output entropy.
kl_loss_coef: 0.001 # Weight on the KL penalty between the actor (trainable policy) and a frozen reference model
optim_config: # Optimizer settings
lr: 5e-5 # Learning rate
weight_decay: 0.0 # L2 regularization strength (0.0–1.0)
adam_beta1: 0.9
adam_beta2: 0.95
peft: # Parameter-efficient fine-tuning (LoRA)
peft_scheme: "lora" # Enable LoRA for PEFT
lora_tuning:
alpha: 32
lora_plus_lr_ratio: 64.0 # LoRA+ learning rate scaling factor (0.0–100.0)
```
## Formazione RFT utilizzando LLM come giudice
### Panoramica di
I modelli linguistici di grandi dimensioni (LLMs) vengono sempre più utilizzati come giudici nei flussi di lavoro di reinforcement fine-tuning (RFT), che forniscono segnali di ricompensa automatici che guidano l'ottimizzazione dei modelli. In questo approccio, un LLM valuta i risultati del modello in base a criteri specifici, che si tratti di valutare la correttezza, la qualità, l'aderenza allo stile o l'equivalenza semantica, e assegna premi che guidano il processo di reinforcement learning.
Ciò è particolarmente utile per le attività in cui le funzioni di ricompensa tradizionali sono difficili da definire programmaticamente, come determinare se rappresentazioni diverse (come «1/3", «0,333" e «un terzo») sono semanticamente equivalenti o valutare qualità sfumate come coerenza e pertinenza. Utilizzando i giudici basati su LLM come funzioni di ricompensa, puoi scalare RFT su domini complessi senza richiedere ampie annotazioni umane, consentendo una rapida iterazione e il miglioramento continuo dei tuoi modelli in diversi casi d'uso oltre ai tradizionali problemi di allineamento.
### Selezione della modalità di ragionamento
**Modalità disponibili**
+ none — Nessun ragionamento (ometti il campo reasoning\$1effort)
+ low — Sovraccarico minimo di ragionamento
+ high — Capacità massima di ragionamento (impostazione predefinita quando è specificato reasoning\$1effort)
**Nota**
Non esiste un'opzione media per RFT. Se il campo reasoning\$1effort non è presente nella configurazione, il ragionamento è disabilitato. Quando il ragionamento è abilitato, è necessario `max_new_tokens` impostarlo su 32768 per accogliere output di ragionamento estesi.
**Quando usare ciascuna modalità**
Usa un ragionamento elevato per:
+ Compiti analitici complessi
+ Risoluzione di problemi matematici
+ Deduzione logica in più fasi
+ Attività in cui il step-by-step pensiero aggiunge valore
Usa none (ometti reasoning\$1effort) o low reasoning per:
+ Semplici domande fattuali
+ Classificazioni dirette
+ Ottimizzazione della velocità e dei costi
+ Risposta semplice alle domande
**Compromessi in termini di costi e prestazioni**
Aumentano le modalità di ragionamento più elevate:
+ Tempi e costi della formazione
+ Latenza e costi dell'inferenza
+ Capacità di modellazione per attività di ragionamento complesse
### Convalida del tuo giudice LLM
Prima di implementarne uno LLM-as-a-judge in produzione, verifica che le valutazioni del modello arbitrale siano in linea con il giudizio umano. Questa operazione prevede:
+ Misurazione dei tassi di concordanza tra il giudice del LLM e i valutatori umani su campioni rappresentativi del vostro compito
+ Garantire che l'accordo del LLM con gli esseri umani soddisfi o superi i tassi di accordo interumani
+ Identificazione di potenziali pregiudizi nel modello del giudice
+ Acquisire la fiducia che il segnale di ricompensa guidi il modello nella direzione prevista
Questa fase di convalida aiuta a garantire che il processo di valutazione automatizzato produca modelli che soddisfino i criteri di qualità della produzione.
### Configurazione Lambda per LLM judge
L'utilizzo di un LLM come giudice è un'estensione dell'utilizzo delle funzioni Lambda per il Reinforcement Learning with Verifiable Rewards (RLVR). All'interno della funzione Lambda, effettui una chiamata a uno dei modelli ospitati in Amazon Bedrock.
**Requisiti di configurazione importanti:**
| Configurazione | Requisito | Informazioni |
| --- | --- | --- |
| Produttività di Amazon Bedrock | Quota sufficiente | Assicurati che la tua quota di throughput per il modello Amazon Bedrock utilizzato sia sufficiente per il tuo carico di lavoro di formazione |
| Timeout Lambda | Timeout prolungato | Configura il timeout della funzione Lambda fino a un massimo di 15 minuti. L'impostazione predefinita è di 3 secondi, il che non è sufficiente per le risposte del modello Amazon Bedrock |
| Simultaneità Lambda | Maggiore concorrenza | La Lambda viene richiamata in parallelo durante l'allenamento. Aumenta la concorrenza per massimizzare la velocità effettiva disponibile |
| Configurazione della ricetta | Abbina le impostazioni Lambda | Il limite di concorrenza deve essere configurato nella ricetta |
## Creazione ed esecuzione di lavori
**Avvio di un lavoro di formazione**
Usa il modello di taccuino per i lavori di SageMaker formazione: [https://docs.aws.amazon.com/sagemaker/latest/dg/nova-fine-tuning-training-job.html#nova-model-training-jobs-notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-fine-tuning-training-job.html#nova-model-training-jobs-notebook)
**Requisiti dell'ist**
Il contenitore supporta sia la formazione Full-Rank che quella LoRa:
+ **Formazione LoRa**: istanze 2/4/6/8 × p5.48xlarge o p5en.48xlarge
+ **Formazione completa** - istanze 2/4/6/8 × p5.48xlarge (obbligatorio)
## Monitoraggio della formazione
I registri di formazione includono metriche complete per ogni fase. Categorie metriche chiave:
**Metriche sulle ricompense**
+ `critic/rewards/mean`,`critic/rewards/max`, `critic/rewards/min` — Distribuzione dei premi
+ `val-score/rewards/mean@1`— Premi di convalida
**Comportamento del modello**
+ `actor/entropy`— Variazione delle politiche (maggiore = più esplorativa)
**Formazione e salute**
+ `actor/pg_loss`— Perdita del gradiente politico
+ `actor/pg_clipfrac`— Frequenza degli aggiornamenti interrotti
+ `actor/grad_norm`— Magnitudine del gradiente
**Caratteristiche di risposta**
+ `prompt_length/mean`,`prompt_length/max`, `prompt_length/min` — Statistiche sui token di input
+ `response_length/mean`,`response_length/max`, `response_length/min` — Statistiche sui token di output
+ `response/aborted_ratio`— Frequenza di generazione incompleta (0 = tutto completato)
**Prestazioni**
+ `perf/throughput`— Produttività della formazione
+ `perf/time_per_step`— Tempo per fase di allenamento
+ `timing_per_token_ms/*`— Tempi di elaborazione per token
**Utilizzo delle risorse**
+ `perf/max_memory_allocated_gb`, `perf/max_memory_reserved_gb` — Memoria GPU
+ `perf/cpu_memory_used_gb`— memoria CPU
## Utilizzo di modelli ottimizzati
Al termine dell'addestramento, il checkpoint finale del modello viene salvato nella posizione di output specificata. Il percorso del checkpoint è disponibile in:
+ Registri di allenamento
+ `manifest.json`file nella posizione di output di Amazon S3 (definita `output_s3_uri` nel notebook)
## Limitazioni e best practice
**Limitazioni**
+ **Timeout Lambda**: le funzioni Reward devono essere completate entro 15 minuti (previene processi inutili e gestisce i costi)
+ **Solo turno singolo**: le conversazioni a turni multipli non sono supportate
+ **Requisiti in materia di dati**: richiede una diversità sufficiente; ha difficoltà con ricompense scarse (esempi positivi inferiori al 5%)
+ **Costo computazionale**: più costoso della messa a punto supervisionata
+ **Nessun dato multimodale: è supportato solo il tipo di dati** di testo
**Best practice**
**Inizia in piccolo**
+ Inizia con 100-200 esempi
+ Convalida la correttezza della funzione di ricompensa
+ Scala gradualmente in base ai risultati
**Valutazione pre-allenamento**
+ Verifica le prestazioni del modello di base prima di RFT
+ Se i premi sono costantemente pari allo 0%, utilizza prima SFT per stabilire le funzionalità di base
+ Se i premi sono superiori al 95%, la RFT potrebbe non essere necessaria
**Monitora la formazione**
+ Tieni traccia dei punteggi e della distribuzione medi dei premi
+ Fai attenzione all'overfitting (i premi di formazione aumentano mentre i premi di convalida diminuiscono)
+ Cerca i modelli riguardanti:
+ I premi si stabilizzano al di sotto di 0,15
+ Aumento della varianza delle ricompense nel tempo
+ Diminuzione delle prestazioni di convalida
**Ottimizza le funzioni di ricompensa**
+ Esegui in pochi secondi (non in minuti)
+ Riduci al minimo le chiamate API esterne
+ Utilizza algoritmi efficienti
+ Implementa una corretta gestione degli errori
+ Sfrutta la scalabilità parallela di Lambda
**Strategia di iterazione**
Se le ricompense non migliorano:
+ Modifica il design della funzione di ricompensa
+ Aumenta la diversità dei set di dati
+ Aggiungi altri esempi rappresentativi
+ Verifica che i segnali di ricompensa siano chiari e coerenti
## Funzionalità avanzate: Nova Forge
Per gli utenti che richiedono funzionalità avanzate oltre ai limiti RFT standard, Nova Forge è disponibile come servizio di abbonamento a pagamento che offre:
+ Supporto per conversazioni a turni
+ Funzioni di ricompensa con un tempo di esecuzione superiore a 15 minuti
+ Algoritmi e opzioni di ottimizzazione aggiuntivi
+ Modifiche personalizzate alla ricetta di allenamento
+ State-of-the-art Tecniche di intelligenza artificiale
Nova Forge funziona SageMaker HyperPod ed è progettata per supportare i clienti aziendali nella creazione dei propri modelli di frontiera.
## Comandi e suggerimenti utili
È disponibile una raccolta di [script di osservabilità](https://github.com/aws-samples/amazon-nova-samples/tree/main/customization/SageMakerUilts/SageMakerJobsMonitoring) per aiutare a monitorare lo stato e l'avanzamento dei lavori di formazione.
Gli script disponibili sono:
+ Attivazione delle notifiche e-mail per gli aggiornamenti sullo stato dei lavori di formazione
+ Ottenere stime dei tempi di formazione in base alle configurazioni dei lavori
+ Ottenere approssimazioni sulla durata prevista della formazione per i lavori in corso
**Installazione**
**Nota**
Assicurati di aggiornare AWS le tue credenziali prima di utilizzare uno dei seguenti script.
```
pip install boto3
git clone https://github.com/aws-samples/amazon-nova-samples.git
cd amazon-nova-samples/customization/SageMakerUilts/SageMakerJobsMonitoring/
```
**Utilizzo di base**
```
# Enabling email notifications for training job status updates
python enable_sagemaker_job_notifs.py --email test@amazon.com test2@gmail.com --region us-east-1 --platform SMTJ
Creating resources........
Please check your email for a subscription confirmation email, and click 'Confirm subscription' to start receiving job status email notifications!
You'll receive the confirmation email within a few minutes.
```
```
# Obtaining training time estimates based on job configurations
python get_training_time_estimate.py
```
```
# Obtaining approximations for how long training is expected to take for in-progress jobs
python get-training-job-progress.py --region us-east-1 --job-name my-training-job --num-dataset-samples 1000
```
Per ulteriori dettagli ed esempi, consulta [questa](https://github.com/aws-samples/amazon-nova-samples/blob/main/customization/SageMakerUilts/SageMakerJobsMonitoring/README.md) pagina.
# Monitoraggio dei progressi tra le iterazioni
Puoi tenere traccia delle metriche tramite MLflow.
## Nova Customization: MLFlow configurazione per SageMaker HyperPod
Per consentire all' SageMaker HyperPod ambiente di emettere le metriche MLFlow, è necessario eseguire alcune impostazioni aggiuntive.
1. Apri Amazon SageMaker AI
1. Seleziona SageMaker Studio
1. Se è già stato creato un profilo, seleziona «Open Studio».
1. Se non viene creato alcun profilo, seleziona «Crea un SageMaker dominio» per configurarne uno
1. Seleziona MLFlow. Se non è stata creata alcuna MLFlow app, seleziona «Crea MLFlow app»
1. Fai clic sul copy/paste pulsante o sulla voce di menu «Visualizza dettagli» nell'app ML Flow per ottenere l'ARN. Ne avrai bisogno quando invierai il tuo lavoro di formazione.
![\[Il pulsante Visualizza dettagli sull'app ML Flow, con ARN.\]](http://docs.aws.amazon.com/it_it/nova/latest/nova2-userguide/images/how-it-works.png)
1. Sul ruolo di esecuzione del HyperPod cluster, aggiungi la seguente politica. Ciò consentirà al HyperPod cluster di chiamare l' MLFlow API per pubblicare le metriche.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sagemaker-mlflow:*",
"Resource": [
"arn:aws:sagemaker:us-east-1:372836560492:mlflow-app/*"
]
},
{
"Effect": "Allow",
"Action": [
"sagemaker:ListMlflowTrackingServers",
"sagemaker:CallMlflowAppApi"
],
"Resource": "*"
}
]
}
```
### Invio di un lavoro tramite la CLI
Specificare 4 nuovi parametri di override, nella riga di comando o nella ricetta yaml.
1. `mlflow_tracking_uri`: L'ARN dell'app MLFlow
1. `mlflow_experiment_name`: Il nome di questa esecuzione dell'esperimento
1. `mlflow_experiment_name`: Il nome dell'esperimento in cui verranno archiviate le metriche MLFlow
1. `mlflow_run_name`: Il nome di questo esperimento
Riga di comando
```
--override-parameters '{"recipes.run.mlflow_tracking_uri": "arn:aws:sagemaker:us-east-1:925548216816:mlflow-app/app-B6XOUNCHQM4W", "recipes.run.mlflow_experiment_name": "myuser-sft-lora-exp1", "recipes.run.mlflow_run_name": "myuser-sft-lora-exp1-202512181940"}'
```
yaml:
```
## Run config
run:
mlflow_tracking_uri: "arn:aws:sagemaker:us-east-1:925548216816:mlflow-app/app-B6XOUNCHQM4W"
mlflow_experiment_name: "myuser-sft-lora-exp1"
mlflow_run_name: "myuser-sft-lora-exp1-202512181940"
```
### Invio di un lavoro tramite l'interfaccia utente di Studio SageMaker
MLFlow l'integrazione è già integrata nell'esperienza dell'interfaccia utente di SageMaker Studio. Quando invii un lavoro di formazione, indica semplicemente quale istanza MLFlow dell'app utilizzare.
1. In SageMaker Studio, accedi a Modelli > Nova 2.0 Lite > Personalizza > Personalizza con interfaccia utente.
1. Espandi la sezione Configurazione avanzata
1. Seleziona l' MLFlow app a cui desideri inviare le metriche di allenamento. Puoi anche impostare il nome dell'esperimento e l'esecuzione dell'esperimento qui.
![\[l'app ML Flow.\]](http://docs.aws.amazon.com/it_it/nova/latest/nova2-userguide/images/MLFlow-App.png)
### Invio di un lavoro tramite AWS AWS CLI
Se utilizzi il AWS AWS CLI, devi creare un' MLflow app e passarla come input alla richiesta API di training job.
```
mlflow_app_name=""
role_arn=""
bucket_name=""
region=""
mlflow_app_arn=$(aws sagemaker create-mlflow-app \
--name $mlflow_app_name \
--artifact-store-uri "s3://$bucket_name" \
--role-arn $role_arn \
--region $region)
```
## Crea un' MLflow app
**Utilizzo dell'interfaccia utente di Studio:** se crei un lavoro di formazione tramite l'interfaccia utente di Studio, viene creata automaticamente MLflow un'app predefinita e selezionata per impostazione predefinita in Opzioni avanzate.
**Utilizzo della CLI:** se utilizzi la CLI, devi creare un' MLflow app e passarla come input alla richiesta API del lavoro di formazione.
```
mlflow_app_name=""
role_arn=""
bucket_name=""
region=""
mlflow_app_arn=$(aws sagemaker create-mlflow-app \
--name $mlflow_app_name \
--artifact-store-uri "s3://$bucket_name" \
--role-arn $role_arn \
--region $region)
```
## Accedi all'app MLflow
**Utilizzo della CLI:** crea un URL prefirmato per accedere all'interfaccia utente dell' MLflow app:
```
aws sagemaker create-presigned-mlflow-app-url \
--arn $mlflow_app_arn \
--region $region \
--output text
```
**Utilizzo dell'interfaccia utente di Studio:** l'interfaccia utente di Studio mostra le metriche chiave archiviate MLflow e fornisce un collegamento all'interfaccia utente dell' MLflow app.
## Metriche chiave da monitorare
Monitora queste metriche tra le iterazioni per valutare i miglioramenti e monitorare l'avanzamento del lavoro:
**Per SFT**
+ Curve di perdita in allenamento
+ Numero di campioni consumati e tempo di elaborazione dei campioni
+ Precisione delle prestazioni su set di test esauriti
+ Conformità del formato (ad esempio, velocità di output JSON valida)
+ Perplessità sui dati di valutazione specifici del dominio
**Per RFT**
+ Punteggi medi di ricompensa rispetto agli allenamenti
+ Distribuzione dei premi (percentuale di risposte ad alto rendimento)
+ Tendenze relative alla validazione e ai premi (attenzione all'overfit)
+ Percentuali di successo specifiche delle attività (ad esempio, velocità di esecuzione del codice, precisione dei problemi matematici)
**Ambito generale**
+ Effettua il benchmark dei delta prestazionali tra le iterazioni
+ Punteggi di valutazione umana su campioni rappresentativi
+ Metriche di produzione (se implementate in modo iterativo)
## Determinare quando fermarsi
Interrompi l'iterazione quando:
+ **Livelli prestazionali**: la formazione aggiuntiva non migliora più in modo significativo le metriche target
+ **Il cambio di tecnica aiuta**: se una tecnica si stabilizza, prova a cambiarla (ad esempio, SFT → RFT → SFT) per superare i limiti prestazionali
+ **Metriche obiettivo raggiunte**: i tuoi criteri di successo sono soddisfatti
+ **Regressione rilevata**: le nuove iterazioni riducono le prestazioni (vedi le procedure di rollback di seguito)
**Per le procedure di valutazione dettagliate, consulta la sezione Valutazione.**
# Valutazione del modello basato sull' SageMaker intelligenza artificiale
Lo scopo del processo è valutare le prestazioni del modello addestrato rispetto a benchmark o set di dati personalizzati. Il processo di valutazione prevede in genere fasi per creare una ricetta di valutazione che punti al modello addestrato, specificare set di dati e metriche di valutazione, inviare un job separato per la valutazione e valutare le prestazioni rispetto a benchmark standard o dati personalizzati. Il processo di valutazione genera i parametri delle prestazioni archiviati nel bucket Amazon S3.
**Nota**
Il processo di valutazione descritto in questo argomento è un processo offline. Il modello viene testato sulla base di benchmark fissi con risposte predefinite, anziché essere valutato in tempo reale o tramite interazioni utente dal vivo. Per una valutazione in tempo reale, puoi testare il modello dopo averlo distribuito su Amazon Bedrock chiamando [Amazon](https://docs.aws.amazon.com//bedrock/latest/userguide/import-with-create-custom-model.html) Bedrock Runtime. APIs
**Topics**
+ [Prerequisiti](#nova-model-evaluation-prerequisites)
+ [Attività di benchmarking disponibili](#nova-model-evaluation-benchmark)
+ [Configurazioni specifiche di una valutazione](#nova-model-evaluation-config)
+ [Esecuzione di job di addestramento per la valutazione](#nova-model-evaluation-notebook)
+ [Valutazione e analisi dei risultati della valutazione](#nova-model-evaluation-assess)
+ [Best practice e risoluzione dei problemi di valutazione](#nova-model-evaluation-best-practices)
+ [Sottoattività disponibili](#nova-model-evaluation-subtasks)
+ [Valutazione del modello di ragionamento](nova-reasoning-model-evaluation.md)
+ [Valutazione RFT](nova-rft-evaluation.md)
+ [Implementazione di funzioni premi](nova-implementing-reward-functions.md)
## Prerequisiti
Prima di avviare un job di addestramento per la valutazione, verifica i seguenti requisiti.
+ Un modello SageMaker Amazon Nova addestrato all'intelligenza artificiale di cui desideri valutarne le prestazioni.
+ Ricetta Amazon Nova di base per la valutazione. Per ulteriori informazioni, consulta [Recupero di ricette Amazon Nova](nova-model-recipes.md#nova-model-get-recipes).
## Attività di benchmarking disponibili
È disponibile un pacchetto di codice di esempio che dimostra come calcolare le metriche di benchmark utilizzando la funzionalità di valutazione del modello SageMaker AI per Amazon Nova. [Per accedere ai pacchetti di codice, consulta sample-N. ova-lighteval-custom-task](https://github.com/aws-samples/sample-Nova-lighteval-custom-task/)
Di seguito è riportato un elenco di benchmark standard di settore disponibili. È possibile specificare i benchmark seguenti nel parametro `eval_task`.
**Benchmark disponibili per la valutazione del modello**
| Benchmark | Modalità | Description | Metriche | Strategia | Sottoattività disponibile |
| --- | --- | --- | --- | --- | --- |
| mmlu | Testo | Massive Multitask Language Understanding (MMLU) - Verifica la conoscenza di 57 materie. | accuratezza | zs\$1cot | Sì |
| mmlu\$1pro | Testo | MMLU - Sottoinsieme professionale - Incentrato su domini professionali come legge, medicina, contabilità e ingegneria. | accuratezza | zs\$1cot | No |
| bbh | Testo | Attività di ragionamento avanzato - Una raccolta di problemi impegnativi che mettono alla prova le capacità cognitive e di risoluzione dei problemi di livello superiore. | accuratezza | fs\$1cot | Sì |
| gpqa | Testo | Risposta a domande di fisica generale - Valuta la comprensione di concetti di fisica e le relative capacità di risoluzione dei problemi. | accuratezza | zs\$1cot | No |
| matematica | Testo | Risoluzione di problemi matematici - Misura il ragionamento matematico su argomenti quali algebra, calcolo e problemi testuali. | exact\$1match | zs\$1cot | Sì |
| strong\$1reject | Testo | Attività di controllo della qualità - Verifica la capacità del modello di rilevare e rifiutare contenuti inappropriati, dannosi o errati. | deflection | zs | Sì |
| ifeval | Testo | Valutazione che segue istruzioni - Misura la precisione con cui un modello segue le istruzioni fornite e completa le attività secondo le specifiche. | accuratezza | zs | No |
| gen\$1qa | Multimodale (immagine) | Valutazione personalizzata del set di dati: consente di fornire il proprio set di dati per il benchmarking, confrontando gli output del modello con le risposte di riferimento con metriche come ROUGE e BLEU. `gen_qa`supporta l'inferenza delle immagini per i modelli basati su Amazon Nova Lite o Amazon Nova Pro. Supporta anche Bring-Your-Own Metrics lambda. (Per la valutazione RFT, usa la ricetta RFT eval) | tutto | gen\$1qa | No |
| mmmu | Multimodale | Massive Multidiscipline Multimodal Understanding (MMMU): benchmark a livello universitario che comprende domande a scelta multipla e domande aperte relative a 30 discipline.) | accuratezza | zs\$1cot | Sì |
| llm\$1judge | Testo | LLM-as-a-Judge Confronto delle preferenze: utilizza un modello Nova Judge per determinare la preferenza tra le risposte accoppiate (B rispetto a A) per i prompt, calcolando la probabilità che B sia preferito ad A. | tutto | judge | No |
| mm\$1llm\$1judge | Multi-Modal (immagine) | Questo nuovo benchmark si comporta allo stesso modo del precedente benchmark basato su testo. `llm_judge` L'unica differenza è che supporta l'inferenza delle immagini. | tutto | judge | No |
| rubric\$1llm\$1judge | Testo | Rubric Judge è un modello di valutazione avanzato LLM-as-a-judge basato su Nova 2.0 Lite. A differenza del [modello di arbitro originale](https://aws.amazon.com/blogs/machine-learning/evaluating-generative-ai-models-with-amazon-nova-llm-as-a-judge-on-amazon-sagemaker-ai/) che fornisce solo verdetti di preferenza, Rubric Judge genera dinamicamente criteri di valutazione personalizzati su misura per ogni richiesta e assegna punteggi granulari su più dimensioni. | tutto | judge | No |
| aime\$12024 | Testo | AIME 2024 - American Invitational Mathematics Examination: problemi relativi alla verifica del ragionamento matematico avanzato e alla risoluzione dei problemi | exact\$1match | zs\$1cot | No |
| calendario\$1pianificazione | Testo | Natural Plan - Calendar - Pianificazione delle attività, test delle attività, capacità di pianificazione per la pianificazione di riunioni su più giorni e più persone | exact\$1match | fs | No |
| humaneval | Testo | HumanEval - Un set di dati di riferimento progettato per valutare le capacità di generazione di codice di modelli linguistici di grandi dimensioni | pass@1 | zs | No |
## Configurazioni specifiche di una valutazione
Di seguito sono riportati i componenti chiave della ricetta e le indicazioni su come modificarli in base ai casi d’uso.
### Comprensione e modifica delle ricette
**Configurazione run generale**
```
run:
name: eval_job_name
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod # or s3://escrow_bucket/model_location
replicas: 1
data_s3_path: ""
mlflow_tracking_uri: ""
mlflow_experiment_name : ""
mlflow_run_name : ""
```
+ `name`: un nome descrittivo per il processo di valutazione.
+ `model_type`: specifica la variante del modello Nova da utilizzare. Non modificare manualmente questo campo. Le opzioni includono:
+ Amazon. nova-micro-v1:01:28 K
+ amazzone. nova-lite-v1:0:300 k
+ amazzone. nova-pro-v1:0:300 k
+ amazon.nova-2-lite-v 1:0:256k
+ `model_name_or_path`: il percorso del modello di base o il percorso S3 per il checkpoint post-addestrato. Le opzioni includono:
+ nova-micro/prod
+ nova-lite/prod
+ nova-pro/prod
+ nova-lite-2/prod
+ Percorso S3 per il percorso di checkpoint post-addestrato (`s3:customer-escrow-111122223333-smtj-/`)
**Nota**
**Valutare un modello post-addestrato**
Per valutare un modello post-addestrato dopo un job di addestramento Nova SFT, segui questa procedura dopo aver eseguito correttamente un job di addestramento. L’addestramento ha esito positivo se alla fine dei log viene visualizzato il messaggio “Training is complete”. Nel bucket di output è inoltre disponibile un file `manifest.json` contenente la posizione del checkpoint. Questo file si trova all’interno di un file `output.tar.gz` nella posizione S3 di output. Per procedere con la valutazione, utilizza questo checkpoint impostandolo come valore per `run.model_name_or_path` nella configurazione della ricetta.
+ `replica`: Il numero di istanze di calcolo da utilizzare per l'inferenza distribuita (esecuzione dell'inferenza su più nodi). Imposta `replica` > 1 per abilitare l'inferenza multinodo, che accelera la valutazione. Se `replica` vengono specificati entrambi `instance_count` e, `instance_count` ha la precedenza. Tieni presente che le repliche multiple si applicano solo ai lavori di formazione SageMaker sull'intelligenza artificiale, non.
+ `data_s3_path`: percorso Amazon S3 del set di dati di input. Questo campo è obbligatorio, ma deve essere sempre lasciato vuoto.
+ `mlflow_tracking_uri`: (Facoltativo) La posizione del server di MLflow tracciamento (necessaria solo su SMHP)
+ `mlflow_experiment_name`: (Facoltativo) Nome dell'esperimento per raggruppare insieme le esecuzioni ML correlate
+ `mlflow_run_name`: (Facoltativo) Nome personalizzato per un corso di formazione specifico all'interno di un esperimento
**Configurazione evaluation**
```
evaluation:
task: mmlu
strategy: zs_cot
subtask: abstract_algebra
metric: accuracy
```
+ `task`: specifica il benchmark o l’attività di valutazione da utilizzare. Le attività supportate includono:
+ `mmlu`
+ `mmlu_pro`
+ `bbh`
+ `gpqa`
+ `math`
+ `strong_reject`
+ `gen_qa`
+ `ifeval`
+ `mmmu`
+ `llm_judge`
+ `mm_llm_judge`
+ `rubric_llm_judge`
+ `aime_2024`
+ `calendar_scheduling`
+ `humaneval`
+ `strategy`: definisce l’approccio di valutazione.
+ `zs_cot`: Zero-shot Chain of Thought: un approccio per suggerire modelli linguistici di grandi dimensioni che incoraggia il step-by-step ragionamento senza richiedere esempi espliciti.
+ `fs_cot`: Few-shot Chain of Thought: un approccio che fornisce alcuni esempi di step-by-step ragionamento prima di chiedere al modello di risolvere un nuovo problema.
+ `zs`: Zero-shot - Un approccio per risolvere un problema senza esempi di addestramento precedenti.
+ `gen_qa`: strategia specifica per utilizzare un set di dati personalizzato.
+ `judge`: Strategia specifica per Nova LLM come giudice e. `mm_llm_judge`
+ `subtask`: facoltativo. Componenti specifici dell’attività di valutazione. Per un elenco completo delle sottoattività disponibili, consulta [Sottoattività disponibili](#nova-model-evaluation-subtasks).
+ Controlla le sottoattività supportate in Attività di benchmarking disponibili.
+ Se non sono presenti benchmark per sottoattività, è consigliabile rimuovere questo campo.
+ `metric`: la metrica di valutazione da utilizzare.
+ `accuracy`: percentuale di risposte corrette.
+ `exact_match`: per il benchmark math, restituisce la velocità con cui le stringhe previste nell’input corrispondono esattamente ai loro riferimenti.
+ `deflection`: per il benchmark strong reject, restituisce la deviazione relativa rispetto al modello di base e la differenza nelle metriche di significatività.
+ `all`:
Per un benchmark Bring Your Own Dataset e `gen_qa`, restituisce le seguenti metriche:
+ `rouge1`: misura la sovrapposizione di unigrammi (parole singole) tra il testo generato e quello di riferimento.
+ `rouge2`: misura la sovrapposizione di bigrammi (due parole consecutive) tra il testo generato e quello di riferimento.
+ `rougeL`: misura la sottosequenza comune più lunga tra testi, tenendo conto di lacune nella corrispondenza.
+ `exact_match`: punteggio binario (0 oppure 1) che indica se il testo generato corrisponde esattamente al testo di riferimento, carattere per carattere.
+ `quasi_exact_match`: simile alla corrispondenza esatta, ma meno rigida, in genere ignora le differenze tra maiuscole e minuscole, punteggiatura e spazi.
+ `f1_score`: media armonica di precisione e richiamo, che misura la sovrapposizione di parole tra le risposte previste e quelle di riferimento.
+ `f1_score_quasi`: simile a f1\$1score, ma con una corrispondenza meno rigida, utilizza un confronto di testo normalizzato che ignora differenze minori.
+ `bleu`: misura la precisione delle corrispondenze in n-grammi tra il testo generato e quello di riferimento, comunemente utilizzate nella valutazione delle traduzioni.
Inoltre `llm_judge``mm_llm_judge`, porta il tuo benchmark del set di dati, restituisci le seguenti metriche:
+ `a_scores`: numero di vittorie per `response_A` nei passaggi di valutazione avanti e indietro.
+ `a_scores_stderr`: errore standard di `response_A_scores` nei giudizi a coppie.
+ `b_scores`: misura il numero di vittorie per `response_B` nei passaggi di valutazione avanti e indietro.
+ `a_scores_stderr`: errore standard di `response_B_scores` nei giudizi a coppie.
+ `ties`: numero di giudizi in cui `response_A` e `response_B` sono valutati in modo uguale.
+ `ties_stderr`: errore standard di `ties` nei giudizi a coppie.
+ `inference_error`: numero di giudizi che non è stato possibile valutare correttamente.
+ `score`: punteggio aggregato basato sulle vittorie nei passaggi avanti e indietro per `response_B`.
+ `score_stderr`: punteggio aggregato basato sulle vittorie nei passaggi avanti e indietro per `response_B`.
+ `inference_error_stderr`: errore standard del punteggio aggregato nei giudizi a coppie.
+ `winrate`: la probabilità che `response_B` venga preferito rispetto a `response_A` calcolato utilizzando la probabilità di Bradley-Terry.
+ `lower_rate`: limite inferiore (percentile 2,5) del tasso di successo stimato derivante dal campionamento bootstrap.
+ `upper_rate`: limite superiore (percentile 97,5) del tasso di successo stimato derivante dal campionamento bootstrap.
**Configurazione inference (facoltativa)**
```
inference:
max_new_tokens: 2048
top_k: -1
top_p: 1.0
temperature: 0
top_logprobs: 10
reasoning_effort: null # options: low/high to enable reasoning or null to disable reasoning
```
+ `max_new_tokens`: numero massimo di token da generare. Deve essere un numero intero. Non disponibile per LLM-as-a-judge.
+ `top_k`: numero di token con la più alta probabilità da considerare. Deve essere un numero intero.
+ `top_p`: soglia di probabilità cumulativa per il campionamento tramite token. Deve essere un valore decimale compreso tra 1,0 e 0,0.
+ `temperature`: casualità nella selezione dei token (valore più alto = casualità maggiore), mantieni il valore pari a 0 per rendere il risultato deterministico. Tipo decimale, il valore minimo è 0.
+ `top_logprobs`: Il numero di migliori logprobs da restituire nella risposta di inferenza. Questo valore deve essere un numero intero compreso tra 0 e 20. I logprobs contengono i token di output considerati e le probabilità di registro di ogni token di output restituito nel contenuto del messaggio.
+ `reasoning_effort`: controlla il comportamento di ragionamento per modelli in grado di ragionare. Imposta `reasoning_effort` solo quando `model_type` specifica un modello in grado di ragionare (attualmente). `amazon.nova-2-lite-v1:0:256k` Le opzioni disponibili sono nulle (valore predefinito se non impostato; disabilita il ragionamento), basse o alte.
### Formato di output logaritmico
Se `top_logprobs` configurato nelle impostazioni di inferenza, l'output di valutazione include le probabilità di registro a livello di token nei file parquet. Ogni posizione del token contiene un dizionario dei migliori token candidati con le relative probabilità di registro nella seguente struttura:
```
{
"Ġint": {"logprob_value": -17.8125, "decoded_value": " int"},
"Ġthe": {"logprob_value": -2.345, "decoded_value": " the"}
}
```
Ogni voce del token contiene:
+ `logprob_value`: Il valore di probabilità logaritmica per il token
+ `decoded_value`: La rappresentazione di stringa decodificata leggibile dall'uomo del token
Il token tokenizer non elaborato viene utilizzato come chiave del dizionario per garantire l'unicità, fornendo al contempo un'interpretazione leggibile. `decoded_value`
### Esempi di ricette di valutazione
Amazon Nova offre quattro diversi tipi di ricette di valutazione. [Tutte le ricette sono disponibili nell'archivio delle ricette. SageMaker HyperPod GitHub ](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection)
**Topics**
#### Ricette di benchmark testuali generali
Queste ricette consentono di valutare le funzionalità fondamentali dei modelli Amazon Nova attraverso una suite completa di benchmark di solo testo.
Formato della ricetta: `xxx_general_text_benchmark_eval.yaml`.
#### Ricette di benchmark Bring Your Own Dataset
Queste ricette consentono di utilizzare un set di dati personalizzato per il benchmarking e confrontare i risultati del modello con risposte di riferimento utilizzando diversi tipi di metriche.
Formato della ricetta: `xxx_ bring_your_own_dataset_eval.yaml`.
**Requisiti Bring Your Own Dataset**
Formato del file:
+ Singolo file `gen_qa.jsonl` contenente esempi di valutazione. Il nome del file deve essere esattamente `gen_qa.jsonl`.
+ È necessario caricare il set di dati in una posizione S3 a cui possano accedere i lavori di formazione SageMaker sull'intelligenza artificiale.
+ Il file deve seguire il formato dello schema richiesto per il set di dati Q&A generale.
Requisiti del formato dello schema: ogni riga del `.jsonl` file deve essere un oggetto JSON con i seguenti campi.
+ Campi obbligatori.
`query`: stringa contenente la domanda o l’istruzione che richiede una risposta.
`response`: stringa contenente l’output del modello previsto.
+ Campi facoltativi.
`system`: stringa contenente il prompt di sistema che imposta il comportamento, il ruolo o la personalità del modello di intelligenza artificiale prima che elabori la query.
`images`: Array contenente un elenco di oggetti con attributi di dati (stringhe di immagini codificate in Base64).
`metadata`: Stringa contenente i metadati associati alla voce a scopo di etichettatura.
**Esempio di inserimento**
```
{
"system":"You are an English major with top marks in class who likes to give minimal word responses: ",
"query":"What is the symbol that ends the sentence as a question",
"response":"?"
}{
"system":"You are a pattern analysis specialist who provides succinct answers: ",
"query":"What is the next number in this series? 1, 2, 4, 8, 16, ?",
"response":"32"
}{
"system":"You have great attention to detail and follow instructions accurately: ",
"query":"Repeat only the last two words of the following: I ate a hamburger today and it was kind of dry",
"response":"of dry"
}{
"system": "Image inference: ",
"query": "What is the number in the image? Please just use one English word to answer.",
"response": "two",
"images": [
{
"data": "data:image/png;Base64,iVBORw0KGgoA ..."
}
]
}
```
Per utilizzare il set di dati personalizzato, modifica la ricetta di valutazione aggiungendo i seguenti campi obbligatori senza modificare la configurazione esistente:
```
evaluation:
task: gen_qa
strategy: gen_qa
metric: all
```
**Limitazioni**
+ È consentito un solo file `.jsonl` per valutazione.
+ Il file deve seguire rigorosamente lo schema definito.
##### Porta le tue metriche
Puoi utilizzare le tue metriche per personalizzare completamente il flusso di lavoro di valutazione del modello con funzionalità di preelaborazione, postelaborazione e metriche personalizzate. La preelaborazione consente di elaborare i dati di input prima di inviarli al server di inferenza, mentre la postelaborazione consente di personalizzare il calcolo delle metriche e restituire metriche personalizzate in base alle proprie esigenze.
Segui questi passaggi per utilizzare le tue metriche con un SDK di valutazione personalizzato.
1. Se non l'hai ancora fatto, [crea prima una AWS Lambda funzione](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html). Account AWS
1. Scarica il `nova-custom-eval-layer.zip` file predefinito dal [GitHub repository](https://github.com/aws/nova-custom-eval-sdk/releases). Puoi utilizzare questo SDK di valutazione personalizzato Nova open source per convalidare i payload di input e output per la tua funzione personalizzata e fornire un'interfaccia unificata per l'integrazione con la valutazione delle metriche Bring your own di Nova durante la formazione.
1. Carica il layer Lambda personalizzato utilizzando il seguente comando:
```
aws lambda publish-layer-version \
--layer-name nova-custom-eval-layer \
--zip-file fileb://nova-custom-eval-layer.zip \
--compatible-runtimes python3.12 python3.11 python3.10 python3.9
```
1. Aggiungi questo livello come livello personalizzato alla tua funzione Lambda, insieme al AWS livello richiesto: `AWSLambdaPowertoolsPythonV3-python312-arm64` (richiesto per la `pydantic` dipendenza).
1. Aggiorna il codice Lambda utilizzando l'esempio fornito, modificando il codice secondo necessità. Questo codice di esempio crea una funzione Lambda per la valutazione personalizzata di Nova con fasi di preelaborazione e post-elaborazione per la valutazione del modello.
```
from nova_custom_evaluation_sdk.processors.decorators import preprocess, postprocess
from nova_custom_evaluation_sdk.lambda_handler import build_lambda_handler
@preprocess
def preprocessor(event: dict, context) -> dict:
data = event.get('data', {})
return {
"statusCode": 200,
"body": {
"system": data.get("system"),
"prompt": data.get("prompt", ""),
"gold": data.get("gold", "")
}
}
@postprocess
def postprocessor(event: dict, context) -> dict:
# data is already validated and extracted from event
data = event.get('data', [])
inference_output = data.get('inference_output', '')
gold = data.get('gold', '')
metrics = []
inverted_accuracy = 0 if inference_output.lower() == gold.lower() else 1.0
metrics.append({
"metric": "inverted_accuracy_custom",
"value": accuracy
})
# Add more metrics here
return {
"statusCode": 200,
"body": metrics
}
# Build Lambda handler
lambda_handler = build_lambda_handler(
preprocessor=preprocessor,
postprocessor=postprocessor
)
```
1. Concedi a Lambda l'accesso al processo di valutazione. Assicurati che il ruolo di esecuzione specificato per il processo di valutazione includa una policy per richiamare la tua funzione Lambda. Ecco una policy di esempio:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "LambdaAccess",
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:ExampleFunction",
"Condition": {
"StringLike": {
"aws:PrincipalArn": "arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-ARN"
}
}
},
{
"Sid": "DenyNonAWSEventSourcesForLambda",
"Effect": "Deny",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:ExampleFunction",
"Condition": {
"Null": {
"lambda:EventSourceToken": false
}
}
}
]
}
```
------
1. Esamina lo schema del payload Lambda. La tabella seguente elenca lo schema di richiesta e risposta Lambda. Puoi convalidare lo schema utilizzando l'SDK di valutazione personalizzato Nova.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/nova/latest/nova2-userguide/nova-model-evaluation.html)
1. Modificate il file della ricetta. Ecco un esempio.
```
processor:
lambda_arn: arn:aws:lambda:us-east-1:111122223333:function:name
lambda_type: "custom_metrics"
preprocessing:
enabled: true
postprocessing:
enabled: true
aggregation: average
```
+ `lambda-arn`: Amazon Resource Name (ARN) per la tua funzione Lambda che gestisce la preelaborazione e la postelaborazione.
+ `lambda_type`: «custom\$1metrics» o «rft».
+ `preprocessing`: Se abilitare le operazioni di preelaborazione personalizzate.
+ `postprocessing`: Se abilitare le operazioni di post-elaborazione personalizzate.
+ `aggregation`: Funzione di aggregazione integrata (opzioni valide: min, max, average, sum).
**Limitazioni**
+ Le metriche Bring your own si applicano solo ai set di dati di input di testo.
+ I set di dati di input multimodali non sono supportati.
+ La fase di preelaborazione non elabora il campo dei metadati.
#### Ricette di benchmark Nova LLM-as-a-judge
Nova LLM Judge è una funzionalità di valutazione del modello che consente di confrontare la qualità delle risposte di un modello con le risposte del modello di base utilizzando un set di dati personalizzato. Accetta un set di dati contenente prompt, risposte di base e risposte di richiesta di verifica, quindi utilizza un modello Nova Judge per fornire una metrica del tasso di successo basata sulla probabilità di [Bradley-Terry](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) con confronti a coppie. Formato della ricetta: `xxx_llm_judge_eval.yaml`.
**Requisiti dei set di dati Nova LLM**
Formato del file:
+ Singolo file `llm_judge.jsonl` contenente esempi di valutazione. Il nome del file deve essere esattamente `llm_judge.jsonl`.
+ Devi caricare il set di dati in una sede S3 a cui possono accedere i lavori di formazione sull' SageMaker intelligenza artificiale.
+ Il file deve seguire il formato dello schema richiesto per il set di dati `llm_judge`.
+ Il set di dati di input deve garantire che tutti i record abbiano una lunghezza di contesto inferiore a 12.000.
Formato dello schema - Ogni riga del file `.jsonl` deve essere un oggetto JSON con i campi seguenti.
+ Campi obbligatori.
`prompt`: stringa contenente il prompt per la risposta generata.
`response_A`: stringa contenente la risposta di base.
`response_B`: stringa contenente la risposta alternativa da confrontare con la risposta di base.
Esempio di inserimento
```
{
"prompt": "What is the most effective way to combat climate change?",
"response_A": "The most effective way to combat climate change is through a combination of transitioning to renewable energy sources and implementing strict carbon pricing policies. This creates economic incentives for businesses to reduce emissions while promoting clean energy adoption.",
"response_B": "We should focus on renewable energy. Solar and wind power are good. People should drive electric cars. Companies need to pollute less."
}
{
"prompt": "Explain how a computer's CPU works",
"response_A": "CPU is like brain of computer. It does math and makes computer work fast. Has lots of tiny parts inside.",
"response_B": "A CPU (Central Processing Unit) functions through a fetch-execute cycle, where instructions are retrieved from memory, decoded, and executed through its arithmetic logic unit (ALU). It coordinates with cache memory and registers to process data efficiently using binary operations."
}
{
"prompt": "How does photosynthesis work?",
"response_A": "Plants do photosynthesis to make food. They use sunlight and water. It happens in leaves.",
"response_B": "Photosynthesis is a complex biochemical process where plants convert light energy into chemical energy. They utilize chlorophyll to absorb sunlight, combining CO2 and water to produce glucose and oxygen through a series of chemical reactions in chloroplasts."
}
```
Per utilizzare un set di dati personalizzato, modifica la ricetta di valutazione con i seguenti campi obbligatori, senza modificare alcun contenuto:
```
evaluation:
task: llm_judge
strategy: judge
metric: all
```
**Limitazioni**
+ È consentito un solo file `.jsonl` per valutazione.
+ Il file deve seguire rigorosamente lo schema definito.
+ I modelli Nova Judge sono gli stessi per quanto riguarda le specifiche Micro/Lite/Pro.
+ Attualmente i modelli Judge personalizzati non sono supportati.
##### Nova LLM in qualità di giudice per le ricette di riferimento multimodali (immagini)
Nova LLM Judge for multi-modal (immagine), abbreviazione di Nova MM\$1LLM Judge, è una funzionalità di valutazione del modello che consente di confrontare la qualità delle risposte di un modello con le risposte di un modello di base utilizzando un set di dati personalizzato. Accetta un set di dati contenente prompt, risposte di base e risposte challenger e immagini sotto forma di stringa codificata in Base64, quindi utilizza un modello Nova Judge per fornire una metrica del tasso di vittoria basata sulla probabilità di [Bradley-Terry](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) attraverso confronti a coppie. Formato della ricetta: `xxx_mm_llm_judge_eval.yaml`.
**Requisiti dei set di dati Nova LLM**
Formato del file:
+ Singolo file `mm_llm_judge.jsonl` contenente esempi di valutazione. Il nome del file deve essere esatto. `llm_judge.jsonl`
+ Devi caricare il set di dati in una posizione S3 a cui i responsabili della formazione sull' SageMaker intelligenza artificiale possano accedervi.
+ Il file deve seguire il formato dello schema richiesto per il set di dati `mm_llm_judge`.
+ Il set di dati di input dovrebbe garantire che tutti i record abbiano una lunghezza di contesto inferiore a 12 k, escluso l'attributo dell'immagine.
Formato dello schema - Ogni riga del file `.jsonl` deve essere un oggetto JSON con i campi seguenti.
+ Campi obbligatori.
`prompt`: stringa contenente il prompt per la risposta generata.
`images`: Array contenente un elenco di oggetti con attributi di dati (i valori sono stringhe di immagine codificate in Base64).
`response_A`: stringa contenente la risposta di base.
`response_B`: stringa contenente la risposta alternativa da confrontare con la risposta di base.
Esempio di inserimento
Per motivi di leggibilità, l'esempio seguente include nuove righe e rientri, ma nel set di dati effettivo, ogni record deve trovarsi su una sola riga.
```
{
"prompt": "What is in the image?",
"images": [
{
"data": "data:image/jpeg;Base64,/9j/2wBDAAQDAwQDAwQEAwQFBAQFBgo..."
}
],
"response_A": "a dog.",
"response_B": "a cat.",
}
{
"prompt": "How many animals are in each of the images?",
"images": [
{
"data": "data:image/jpeg;Base64,/9j/2wBDAAQDAwQDAwQEAwQFBAQFBgo..."
},
{
"data": "data:image/jpeg;Base64,/DKEafe3gihn..."
}
],
"response_A": "The first image contains one cat and the second image contains one dog",
"response_B": "The first image has one aminal and the second has one animal"
}
```
Per utilizzare un set di dati personalizzato, modifica la ricetta di valutazione con i seguenti campi obbligatori, senza modificare alcun contenuto:
```
evaluation:
task: mm_llm_judge
strategy: judge
metric: all
```
**Limitazioni**
+ È consentito un solo file `.jsonl` per valutazione.
+ Il file deve seguire rigorosamente lo schema definito.
+ I modelli Nova MM Judge supportano solo il riferimento alle immagini.
+ I modelli Nova MM Judge sono gli stessi per tutte le specifiche di Amazon Nova Micro, Amazon Nova Lite e Amazon Nova Pro.
+ Attualmente i modelli Judge personalizzati non sono supportati.
+ L'URI di immagine Amazon S3 non è supportato.
+ Il set di dati di input dovrebbe garantire che tutti i record abbiano una lunghezza di contesto inferiore a 12 k, escluso l'attributo images.
#### Valutazione dei punti di controllo CPT (pre-formazione continua)
La valutazione dei modelli CPT (Continuous Pre-Training) può essere più difficoltosa rispetto ai modelli sottoposti a SFT (supervised fine tuning), in quanto i modelli CPT spesso non sono in grado di seguire le istruzioni. Invece di seguire le istruzioni, i modelli CPT funzioneranno come modelli di completamento, il che significa che cercheranno solo di continuare lo schema fornito con la sequenza dei token di input. Data questa limitazione, i set di dati di valutazione tipici potrebbero non funzionare correttamente a causa del formato «Q&A» degli input: invece di rispondere alla domanda, il modello cercherà semplicemente di continuare con la stessa domanda. Tuttavia, formattando i set di dati in un modo specifico per richiedere ai modelli uno stile di completamento, possiamo comprendere le prestazioni del modello.
Segui i passaggi seguenti per capire come eseguire una valutazione su un modello continuo preaddestrato utilizzando il flusso di lavoro di valutazione di Nova Forge.
##### Preparazione e formattazione dei set di dati
La valutazione di un modello CPT sfrutta il flusso di lavoro [Bring Your Own Dataset](#nova-model-evaluation-config-byo) già esistente già fornito nell'esperienza di valutazione del modello Nova Forge. Tuttavia, le query all'interno del set di dati devono essere formattate in un formato puramente «di completamento» poiché i modelli CPT non risponderanno alle richieste standard in stile domanda nello stesso modo in cui farebbe un modello SFT.
Un'altra importante limitazione frequente dei modelli sottoposti esclusivamente al CPT è la loro incapacità di generare token STOP o di fine sequenza: ciò significa che il modello continuerà a generare token fino a quando non verrà interrotto con forza (come con il parametro max\$1new\$1tokens). Data questa limitazione, la migliore pratica consiste nel valutare i modelli utilizzando risposte a token singolo (come la scelta multipla) per garantire che il modello non continui a generare output indesiderati che non sono necessari dopo la richiesta.
Ad esempio, un tipico set di dati di valutazione (come MMLU, GPQA, MATH, ecc.) potrebbe porre al modello una domanda come:
```
Early settlements and high population density along coastlines and rivers are
best attributed to which of the following?
A: "Poor climate conditions"
B: "Limited forest cover"
C: "Cars"
D: "Access to trade routes"
(Expected answer is D.)
```
Tuttavia, un modello CPT non capirebbe come rispondere correttamente a questa domanda a causa della mancanza di una regolazione precisa delle istruzioni che seguono. Pertanto, i modelli CPT devono essere richiesti con uno stile di completamento, ad esempio:
```
Early settlements and high population density along coastlines and rivers
are best attributed to which of the following?
A: Poor climate conditions
B: Limited forest cover
C: Cars
D: Access to trade routes
The correct answer to this question is option
(Expected answer is D.)
```
Dopo il controllo dell'inferenza, i logprobs di output generati dal modello forniranno dettagli sul fatto che il modello stia elaborando correttamente l'input e generando la risposta corretta. Non è garantito che il modello produca sempre la risposta esatta (in questo caso, la lettera D) prevista, tuttavia dovrebbe essere presente all'interno dei logprobs se il modello funziona correttamente.
Un altro esempio di prompt di stile di completamento non a scelta multipla:
```
The capital of France is
(Expected answer of Paris)
```
Ci aspetteremmo che il modello produca una risposta di «Paris» o veda il token corrispondente a «Paris» da qualche parte nell'output di logprobs.
##### Formattazione del set di dati
La valutazione CPT sfrutta il flusso di lavoro esistente di [Bring Your Own](#nova-model-evaluation-config-byo) Dataset. I dati devono essere formattati nel formato «risposta alla query» in un file JSONL separato da nuove righe.
Un esempio di set di dati contenente 4 voci:
```
{"query": "The capital of France is", "response": "Paris"}
{"query": "2 + 2 =", "response": "4"}
{"query": "The mitochondria is the powerhouse of the", "response": "cell"}
{"query": "What is the largest planet?\nA: Mars\nB: Jupiter\nC: Saturn\nD: Earth\nAnswer:", "response": "B"}
```
Ogni riga deve contenere:
+ `query`: Il testo richiesto per il completamento
+ `response`: Il completamento previsto (verità fondamentale)
Il modello riceverà un input di testo non elaborato senza formattazione della chat. I modelli CPT in genere non sono ancora addestrati su token speciali e non rispondono correttamente ai modelli di chat, quindi quando viene richiesta al modello SOLO la stringa fornita nella query verrà inviata al modello (con un `[BOS]` token aggiuntivo aggiunto automaticamente).
##### Configurazione della ricetta
Ecco un esempio di ricetta configurata per valutare un modello CPT:
```
run:
name: cpt_eval_job
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: s3://bucket/path/to/cpt-checkpoint/
evaluation:
task: gen_qa # Required for CPT - bring your own dataset
strategy: gen_qa
metric: all # Returns rouge1, rouge2, rougeL, exact_match, f1_score, bleu
inference:
checkpoint_is_instruction_tuned: "false" # Required for CPT checkpoints
top_logprobs: 5 # Change to desired amount of logprobs to calculate
max_new_tokens: 1 # Keep low for completion tasks
temperature: 0.0
```
Modifiche chiave per la valutazione CPT:
+ `checkpoint_is_instruction_tuned: "false"`
Si tratta di un nuovo parametro aggiunto specificamente per supportare le esecuzioni di valutazione sui checkpoint CPT. L'impostazione di checkpoint\$1is\$1instruction\$1tuned su false **disabiliterà** il modello di chat Amazon Nova predefinito che normalmente include il prompt di input.
+ `top_logprobs: 5`
Le probabilità di log (logprobs) rivelano la distribuzione della fiducia del modello tra i possibili token next, aiutandoti a valutare se il modello ha appreso i completamenti previsti durante il pre-addestramento. In genere, se il modello funziona come previsto, dovremmo vedere la risposta prevista (ad esempio, «A», «B», ecc.) come token di output generato o come token nei logprobs.
+ `max_new_tokens: 1`
I modelli CPT in genere non sono ancora stati addestrati a generare speciali token «stop» o «end of sequence» per segnalare quando interrompere l'inferenza. Ciò significa che il modello in genere continuerà a generare nuovi token fino al raggiungimento della lunghezza massima specifica del token, con conseguente inferenza non necessaria. In genere, limitare max\$1new\$1tokens a 1 e fornire un prompt in grado di valutare il modello in base a una singola risposta (come una domanda a scelta multipla) è il modo più efficiente per richiedere il modello. L'impostazione di max\$1new\$1tokens su 1 garantisce che non vengano generati token spazzatura aggiuntivi.
##### Parametri chiave
+ **checkpoint\$1is\$1instruction\$1tuned: deve essere impostato su (o come booleano**) per disabilitare i modelli di chat `"false"` `false`
+ **top\$1logprobs**: 5, consigliato per vedere come il modello sta imparando durante il CPT
+ **compito**: Deve essere: i modelli CPT non possono utilizzare `gen_qa` benchmark che seguono le istruzioni come MMLU o MATH
+ **strategia**: Deve essere `gen_qa`
+ **max\$1new\$1tokens**: si consiglia di mantenere un valore basso (1-5) poiché i modelli CPT eseguono il completamento, non la generazione
## Esecuzione di job di addestramento per la valutazione
Inizia un processo di formazione utilizzando il seguente taccuino di esempio. Fate riferimento al seguente taccuino come esempio per eseguire il processo di formazione di valutazione. Per ulteriori informazioni, consulta [Utilizzare uno stimatore di SageMaker intelligenza artificiale per eseguire un processo di formazione](https://docs.aws.amazon.com//sagemaker/latest/dg/docker-containers-adapt-your-own-private-registry-estimator.html).
### Tabelle di riferimento
Prima di eseguire il notebook, fai riferimento alle seguenti tabelle di riferimento per selezionare l’URI delle immagini e le configurazioni delle istanze.
**Selezione dell’URI delle immagini**
| Recipe | URI immagine |
| --- | --- |
| URI delle immagini di valutazione | 708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-TJ-Eval-V2-latest |
**Selezione del tipo e del numero di istanze**
| Modello | Tipo di processo | Tipo di istanza | Numero di istanze consigliato | Numero di istanze consentito |
| --- | --- | --- | --- | --- |
| Amazon Nova Micro | Valutazione (SFT/DPO) | g5.12xlarge | 1 | 1 - 16 |
| Amazon Nova Lite | Valutazione (SFT/DPO) | g5.12xlarge | 1 | 1 - 16 |
| Amazon Nova Pro | Valutazione (SFT/DPO) | p5.48xlarge | 1 | 1 - 16 |
### Notebook di esempio
Il seguente notebook di esempio mostra come eseguire un job di addestramento per la valutazione.
```
# install python SDK
# Do not use sagemaker v3, as sagemaker v3 introduced breaking changes
!pip install sagemaker==2.254.1
import os
import sagemaker,boto3
from sagemaker.inputs import TrainingInput
from sagemaker.pytorch import PyTorch
sagemaker_session = sagemaker.Session()
role = sagemaker.get_execution_role()
# Download recipe from https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/evaluation/nova to local
# Assume the file name be `recipe.yaml`
# Populate parameters
# input_s3_uri = "s3:///input/" # (Optional) Only used for multi-modal dataset or bring your own dataset s3 location
output_s3_uri= "s3:///output/" # Output data s3 location, a zip containing metrics json and tensorboard metrics files will be stored to this location
instance_type = "instance_type" # ml.g5.16xlarge as example
instance_count = 1 # The number of instances for inference (set instance_count > 1 for multi-node inference to accelerate evaluation)
job_name = "your job name"
recipe_path = "recipe path" # ./recipe.yaml as example
image_uri = "708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-TJ-Eval-V2-latest" # Do not change
output_kms_key = "" # optional, leave blank for Amazon managed encryption
# (Optional) To bring your own dataset and LLM judge for evaluation
# evalInput = TrainingInput(
# s3_data=input_s3_uri,
# distribution='FullyReplicated',
# s3_data_type='S3Prefix'
#)
estimator = PyTorch(
output_path=output_s3_uri,
base_job_name=job_name,
role=role,
instance_type=instance_type,
instance_count=instance_count,
training_recipe=recipe_path,
sagemaker_session=sagemaker_session,
image_uri=image_uri,
output_kms_key=output_kms_key
)
estimator.fit()
# If input dataset exist, pass in inputs
# estimator.fit(inputs={"train": evalInput})
```
## Valutazione e analisi dei risultati della valutazione
Una volta completato correttamente il processo di valutazione, è possibile valutare e analizzare i seguendo questa procedura.
**Per valutare e analizzare i risultati, procedi nel seguente modo.**
1. Comprendi la struttura della posizione di output. I risultati vengono archiviati nella posizione di output specificata di Amazon S3 come file compresso:
```
s3://your-bucket/output/benchmark-name/
└── job_name/
└── output/
└── output.tar.gz
```
1. Scarica il file `output.tar.gz` dal bucket. Estrai il contenuto per visualizzarlo.
```
run_name/
├── eval_results/
| └── results_[timestamp].json
│ └── inference_output.jsonl (only present for gen_qa)
| └── details/
| └── model/
| └── /
| └──details__#_.parquet
└── tensorboard_results/
└── eval/
└── events.out.tfevents.[timestamp]
```
+ `results_[timestamp].json` - File JSON delle metriche di output
+ `details__#_.parquet` - File di output di inferenza (ad eccezione di `strong_reject`)
+ `events.out.tfevents.[timestamp]`- file TensorBoard di output
+ `inference_output.jsonl` - File di output di inferenza pulito (solo per attività `gen_qa`)
1. Visualizza i risultati in TensorBoard. Per visualizzare le metriche di valutazione:
1. Carica la cartella estratta in un bucket S3
1. Passa all' SageMaker IA TensorBoard
1. Seleziona “Cartelle S3”
1. Aggiungi il percorso della cartella S3
1. Attendi il completamento della sincronizzazione
1. Analizza gli output di inferenza. Tutte le attività di valutazione, tranne `llm_judge` e `strong_reject`, includono i seguenti campi per l’analisi nell’output dell’inferenza.
+ `full_prompt`- Il prompt utente completo inviato al modello utilizzato per l'attività di valutazione.
+ `gold`- Il campo che contiene le risposte corrette come specificato dal set di dati.
+ `metrics`- Il campo che contiene le metriche valutate sulla singola inferenza. I valori che richiedono l’aggregazione non hanno un valore sui singoli output di inferenza.
+ `predictions`- Il campo che contiene un elenco dell'output del modello per il prompt specificato.
+ `pred_logits`- Il campo che contiene i token di output considerati e le probabilità di registro di ogni token di output restituito nel contenuto del messaggio.
Esaminando questi campi, è possibile determinare la causa delle differenze nelle metriche e comprendere il comportamento dei modelli personalizzati.
Per `llm_judge`, il file di output dell’inferenza contiene i seguenti campi nel campo delle metriche per coppia di valutazioni.
+ `forward_output` - Le preferenze non elaborate di Judge durante la valutazione nell’ordine diretto (response\$1A, response\$1B).
+ `backward_output` - Le preferenze non elaborate di Judge durante la valutazione nell’ordine inverso (response\$1B, response\$1A).
+ `Pairwise metrics` - Metriche calcolate per coppia di valutazioni avanti e indietro, tra cui `a_scores`, `b_scores`, `ties`, `inference-score` e `score`.
**Nota**
Metriche aggregate come `winrate` sono disponibili solo nei file dei risultati di riepilogo, non basate su giudizi individuali.
Per `gen_qa`, il file `inference_output.jsonl` contiene i seguenti campi per ogni oggetto JSON:
+ prompt - Il prompt finale inviato al modello
+ inference - L’output di inferenza non elaborato del modello
+ gold - La risposta target dal set di dati di input
+ metadata - La stringa di metadati del set di dati di input, se fornita
## Best practice e risoluzione dei problemi di valutazione
### Best practice
Di seguito sono elencate alcune best practice per il processo di valutazione.
+ Mantieni i percorsi di output organizzati per modello e tipo di benchmark.
+ Mantieni convenzioni di denominazione coerenti per semplificare il monitoraggio.
+ Salva i risultati estratti in una posizione sicura.
+ Monitora lo stato di TensorBoard sincronizzazione per il corretto caricamento dei dati.
### Risoluzione dei problemi
È possibile utilizzare CloudWatch il gruppo di log `/aws/sagemaker/TrainingJobs` per addestrare i registri degli errori dei processi.
#### Guasto al nucleo del motore
**Problema:**
Se stai vedendo:
```
RuntimeError: Engine core initialization failed.
```
**Causa:**
Sebbene si tratti di un errore generale che può avere più cause, in genere si verifica quando c'è una mancata corrispondenza tra il checkpoint del modello che stai tentando di caricare e il tipo di modello specificato. Ad esempio, volete valutare un checkpoint del modello Nova 2.0 lite ottimizzato, ma il tipo di modello fornito è di tipo 1.0. ad es. `amazon.nova-micro-v1:0:128k`
La mappatura corretta dovrebbe essere
```
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod # or s3://escrow_bucket/model_location
```
**Prevenzione:**
Controlla che `model_name_or_path` sia mappato a destra `model_type` prima di inviare il lavoro di valutazione.
## Sottoattività disponibili
Di seguito sono elencate le sottoattività disponibili per la valutazione del modello in più domini, tra cui MMLU (Massive Multitask Language Understanding), BBH (Big Bench Hard), MATH e MMMU (Massive Multi-discipline Multimodal Understanding). Queste sottoattività consentono di valutare le prestazioni del modello in base a funzionalità e aree di conoscenza specifiche.
**MMLU**
```
MMLU_SUBTASKS = [
"abstract_algebra",
"anatomy",
"astronomy",
"business_ethics",
"clinical_knowledge",
"college_biology",
"college_chemistry",
"college_computer_science",
"college_mathematics",
"college_medicine",
"college_physics",
"computer_security",
"conceptual_physics",
"econometrics",
"electrical_engineering",
"elementary_mathematics",
"formal_logic",
"global_facts",
"high_school_biology",
"high_school_chemistry",
"high_school_computer_science",
"high_school_european_history",
"high_school_geography",
"high_school_government_and_politics",
"high_school_macroeconomics",
"high_school_mathematics",
"high_school_microeconomics",
"high_school_physics",
"high_school_psychology",
"high_school_statistics",
"high_school_us_history",
"high_school_world_history",
"human_aging",
"human_sexuality",
"international_law",
"jurisprudence",
"logical_fallacies",
"machine_learning",
"management",
"marketing",
"medical_genetics",
"miscellaneous",
"moral_disputes",
"moral_scenarios",
"nutrition",
"philosophy",
"prehistory",
"professional_accounting",
"professional_law",
"professional_medicine",
"professional_psychology",
"public_relations",
"security_studies",
"sociology",
"us_foreign_policy",
"virology",
"world_religions"
]
```
**BBH**
```
BBH_SUBTASKS = [
"boolean_expressions",
"causal_judgement",
"date_understanding",
"disambiguation_qa",
"dyck_languages",
"formal_fallacies",
"geometric_shapes",
"hyperbaton",
"logical_deduction_five_objects",
"logical_deduction_seven_objects",
"logical_deduction_three_objects",
"movie_recommendation",
"multistep_arithmetic_two",
"navigate",
"object_counting",
"penguins_in_a_table",
"reasoning_about_colored_objects",
"ruin_names",
"salient_translation_error_detection",
"snarks",
"sports_understanding",
"temporal_sequences",
"tracking_shuffled_objects_five_objects",
"tracking_shuffled_objects_seven_objects",
"tracking_shuffled_objects_three_objects",
"web_of_lies",
"word_sorting"
]
```
**Math** (Matematica)
```
MATH_SUBTASKS = [
"algebra",
"counting_and_probability",
"geometry",
"intermediate_algebra",
"number_theory",
"prealgebra",
"precalculus",
```
**MMMU**
```
MATH_SUBTASKS = [
"Accounting",
"Agriculture",
"Architecture_and_Engineering",
"Art",
"Art_Theory",
"Basic_Medical_Science",
"Biology",
"Chemistry",
"Clinical_Medicine",
"Computer_Science",
"Design",
"Diagnostics_and_Laboratory_Medicine",
"Economics",
"Electronics",
"Energy_and_Power",
"Finance",
"Geography",
"History",
"Literature",
"Manage",
"Marketing",
"Materials",
"Math",
"Mechanical_Engineering",
"Music",
"Pharmacy",
"Physics",
"Psychology",
"Public_Health",
"Sociology",
```
Valuta i tuoi modelli Nova personalizzati utilizzando vari metodi e metriche di valutazione.
**Topics**
+ [Prerequisiti](#nova-model-evaluation-prerequisites)
+ [Attività di benchmarking disponibili](#nova-model-evaluation-benchmark)
+ [Configurazioni specifiche di una valutazione](#nova-model-evaluation-config)
+ [Esecuzione di job di addestramento per la valutazione](#nova-model-evaluation-notebook)
+ [Valutazione e analisi dei risultati della valutazione](#nova-model-evaluation-assess)
+ [Best practice e risoluzione dei problemi di valutazione](#nova-model-evaluation-best-practices)
+ [Sottoattività disponibili](#nova-model-evaluation-subtasks)
+ [Valutazione del modello di ragionamento](nova-reasoning-model-evaluation.md)
+ [Valutazione RFT](nova-rft-evaluation.md)
+ [Implementazione di funzioni premi](nova-implementing-reward-functions.md)
# Valutazione del modello di ragionamento
## Panoramica di
Il supporto del modello di ragionamento consente la valutazione con modelli Nova compatibili con il ragionamento che eseguono un ragionamento interno esplicito prima di generare risposte finali. Questa funzionalità utilizza il controllo a livello di API tramite il `reasoning_effort` parametro per abilitare o disabilitare dinamicamente la funzionalità di ragionamento, migliorando potenzialmente la qualità della risposta per attività analitiche complesse.
**Modelli supportati**
+ amazon.nova-2-lite-v 1:0:256k
## Configurazione della ricetta
Abilita il ragionamento aggiungendo il `reasoning_effort` parametro alla `inference` sezione della tua ricetta:
```
run:
name: reasoning-eval-job-name # [MODIFIABLE] Unique identifier for your evaluation job
model_type: amazon.nova-2-lite-v1:0:256k # [FIXED] Must be a reasoning-supported model
model_name_or_path: nova-lite-2/prod # [FIXED] Path to model checkpoint or identifier
replicas: 1 # [MODIFIABLE] Number of replicas for SageMaker Training job
data_s3_path: "" # [MODIFIABLE] Leave empty for SageMaker Training job; optional for SageMaker HyperPod job
output_s3_path: "" # [MODIFIABLE] Output path for SageMaker HyperPod job (not compatible with SageMaker Training jobs)
evaluation:
task: mmlu # [MODIFIABLE] Evaluation task
strategy: zs_cot # [MODIFIABLE] Evaluation strategy
metric: accuracy # [MODIFIABLE] Metric calculation method
inference:
reasoning_effort: high # [MODIFIABLE] Enables reasoning mode; options: low/high or null to disable
max_new_tokens: 32768 # [MODIFIABLE] Maximum tokens to generate, recommended value when reasoning_effort set to high
top_k: -1 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
```
## Utilizzo del parametro reasoning\$1effort
Il `reasoning_effort` parametro controlla il comportamento di ragionamento per i modelli in grado di ragionare.
### Prerequisiti
+ **Compatibilità tra modelli:** viene impostata `reasoning_effort` solo quando `model_type` specifica un modello in grado di ragionare (attualmente) `amazon.nova-2-lite-v1:0:256k`
+ **Gestione degli errori**: l'utilizzo `reasoning_effort` con modelli non supportati avrà esito negativo con `ConfigValidationError: "Reasoning mode is enabled but model '{model_type}' does not support reasoning. Please use a reasoning-capable model or disable reasoning mode."`
### Opzioni disponibili
| Opzione | Comportamento | Limite di token | Caso d’uso |
| --- | --- | --- | --- |
| null (impostazione predefinita) | Disattiva la modalità di ragionamento | N/D | Valutazione standard senza sovraccarico di ragionamento |
| low | Consente il ragionamento con vincoli | 4.000 token per il ragionamento interno | Scenari che richiedono un ragionamento conciso; ottimizza velocità e costi |
| high | Consente il ragionamento senza vincoli | Nessun limite simbolico al ragionamento interno | Problemi complessi che richiedono analisi e step-by-step ragionamenti approfonditi |
| Metodo di addestramento | Opzioni disponibili | Come configurare |
| --- | --- | --- |
| SFT (regolazione di precisione supervisionata) | Solo High o Off | Usa reasoning\$1enabled: true (high) o reasoning\$1enabled: false (off) |
| RFT (Reinforcement Fine-Tuning) | Basso, Alto o Disattivato | Usa reasoning\$1effort: low o reasoning\$1effort: high. Ometti il campo da disabilitare. |
| Valutazione | Basso, Alto o Disattivato | Usa reasoning\$1effort: low o reasoning\$1effort: high. Usa null per disabilitare. |
### Quando abilitare il ragionamento
**Usa la modalità di ragionamento (`low`o) per `high`**
+ Compiti complessi di risoluzione di problemi (matematica, puzzle logici, programmazione)
+ Domande analitiche in più fasi che richiedono un ragionamento intermedio
+ Attività in cui spiegazioni o riflessioni dettagliate migliorano la precisione step-by-step
+ Scenari in cui la qualità della risposta è prioritaria rispetto alla velocità
**Usa la modalità non ragionamento (`null`o ometti il parametro) per**
+ Domande e risposte semplici o domande fattuali
+ Attività di scrittura creativa
+ Quando i tempi di risposta più rapidi sono fondamentali
+ Analisi comparativa delle prestazioni in cui è necessario escludere il sovraccarico di ragionamento
+ L'ottimizzazione dei costi quando il ragionamento non migliora le prestazioni delle attività
### Risoluzione dei problemi
**Errore: «La modalità di ragionamento è abilitata ma il modello non supporta il ragionamento»**
**Causa**: il `reasoning_effort` parametro è impostato su un valore diverso da nullo, ma quello specificato `model_type` non supporta il ragionamento.
**Risoluzione:**
+ Verifica che il tipo di modello sia `amazon.nova-2-lite-v1:0:256k`
+ Se utilizzi un modello diverso, passa a un modello in grado di ragionare o rimuovi il `reasoning_effort` parametro dalla tua ricetta
# Valutazione RFT
## Cos'è la valutazione RFT?
RFT Evaluation consente di valutare le prestazioni del modello utilizzando funzioni di ricompensa personalizzate prima, durante o dopo la formazione di reinforcement learning. A differenza delle valutazioni standard che utilizzano metriche predefinite, RFT Evaluation consente di definire criteri di successo personalizzati tramite una funzione Lambda che assegna un punteggio agli output del modello in base ai requisiti specifici.
## Perché effettuare una valutazione con RFT?
La valutazione è fondamentale per determinare se il processo di messa a punto di RL presenta:
+ Migliore allineamento del modello con il caso d'uso specifico e i valori umani
+ Funzionalità del modello mantenute o migliorate per le attività chiave
+ Ha evitato effetti collaterali indesiderati come riduzione della fattualità, aumento della verbosità o riduzione delle prestazioni in altre attività
+ Hai soddisfatto i criteri di successo personalizzati definiti dalla tua funzione di ricompensa
## Quando utilizzare la valutazione RFT
Utilizza la valutazione RFT in questi scenari:
+ Prima della formazione RFT: stabilisci le metriche di base sul tuo set di dati di valutazione
+ Durante l'allenamento RFT: monitora i progressi dell'allenamento con punti di controllo intermedi
+ Dopo la formazione RFT: verifica che il modello finale soddisfi i tuoi requisiti
+ Confronto tra modelli: valuta più versioni del modello utilizzando criteri di ricompensa coerenti
**Nota**
Usa RFT Evaluation quando hai bisogno di metriche personalizzate e specifiche del dominio. Per una valutazione generica (precisione, perplessità, BLEU), utilizzate metodi di valutazione standard.
## Requisiti per il formato dei dati
### Struttura dei dati di input
I dati di input di valutazione RFT devono seguire il formato OpenAI Reinforcement Fine-Tuning. Ogni esempio è un oggetto JSON contenente:
+ `messages`— Serie di turni e ruoli di conversazione `system` `user`
+ `reference_answer`— Risultati attesi o dati fondamentali utilizzati dalla funzione di ricompensa per il punteggio
### Esempio di formato dei dati
```
{
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Solve for x. Return only JSON like {\"x\": }. Equation: 2x + 5 = 13"
}
]
}
],
"reference_answer": {
"x": 4
}
}
```
### Limitazioni attuali
+ Solo testo: non sono supportati input multimodali (immagini, audio, video)
+ Conversazioni a turno singolo: supporta solo messaggi utente singoli (non dialoghi a più turni)
+ Formato JSON: i dati di input devono essere in formato JSONL (un oggetto JSON per riga)
+ Risultati del modello: la valutazione viene eseguita sui completamenti generati dal modello specificato
## Preparazione della ricetta di valutazione
### Notebook di esempio
Per un esempio completo, consulta [Quaderni di valutazione](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook).
### Esempio di configurazione della ricetta
```
run:
name: nova-lite-rft-eval-job
model_type: amazon.nova-lite-v1:0:300k
model_name_or_path: s3://escrow_bucket/model_location # [MODIFIABLE] S3 path to your model or model identifier
replicas: 1 # [MODIFIABLE] For SageMaker Training jobs only; fixed for HyperPod jobs
data_s3_path: "" # [REQUIRED FOR HYPERPOD] Leave empty for SageMaker Training jobs and use TrainingInput in sagemaker python SDK
output_s3_path: "" # [REQUIRED] Output artifact S3 path for evaluation results
evaluation:
task: rft_eval # [FIXED] Do not modify
strategy: rft_eval # [FIXED] Do not modify
metric: all # [FIXED] Do not modify
# Inference Configuration
inference:
max_new_tokens: 8192 # [MODIFIABLE] Maximum tokens to generate
top_k: -1 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
top_logprobs: 0 # [MODIFIABLE] Set between 1-20 to enable logprobs output
# =============================================================================
# Bring Your Own Reinforcement Learning Environment
# =============================================================================
rl_env:
reward_lambda_arn: arn:aws:lambda:::function:
```
## Funzioni di ricompensa preimpostate
Due funzioni di ricompensa preimpostate (`prime_code`e`prime_math`) sono disponibili come layer Lambda per una facile integrazione con le funzioni RFT Lambda.
### Panoramica di
Queste funzioni preimpostate forniscono funzionalità di valutazione per: out-of-the-box
+ `prime_code`— Generazione di codice e valutazione della correttezza
+ `prime_math`— Ragionamento matematico e valutazione della risoluzione dei problemi
### Configurazione rapida
1. [Scarica il layer Lambda dalle versioni. nova-custom-eval-sdk ](https://github.com/aws/nova-custom-eval-sdk/releases)
1. Pubblica il layer Lambda utilizzando AWS Command Line Interface ()AWS CLI:
```
aws lambda publish-layer-version \
--layer-name preset-function-layer \
--description "Preset reward function layer with dependencies" \
--zip-file fileb://universal_reward_layer.zip \
--compatible-runtimes python3.9 python3.10 python3.11 python3.12 \
--compatible-architectures x86_64 arm64
```
1. Aggiungi il layer alla tua funzione Lambda nella Console di AWS gestione (seleziona il layer preset-function-layer dal livello personalizzato e aggiungi anche AWSSDKPandas-Python 312 per le dipendenze numpy).
1. Importa e usa nel tuo codice Lambda:
```
from prime_code import compute_score # For code evaluation
from prime_math import compute_score # For math evaluation
```
### funzione prime\$1code
Valuta le attività di generazione di codice Python eseguendo codice in base a casi di test e misurando la correttezza.
**Esempio di formato del set di dati di input**
```
{"messages":[{"role":"user","content":"Write a function that returns the sum of two numbers."}],"reference_answer":{"inputs":["3\n5","10\n-2","0\n0"],"outputs":["8","8","0"]}}
{"messages":[{"role":"user","content":"Write a function to check if a number is even."}],"reference_answer":{"inputs":["4","7","0","-2"],"outputs":["True","False","True","True"]}}
```
**Caratteristiche principali**
+ Estrazione automatica del codice dai blocchi di codice markdown
+ Rilevamento delle funzioni e test basati sulle chiamate
+ Esecuzione di test case con protezione dal timeout
+ Convalida della sintassi e controlli di compilazione
+ Segnalazione dettagliata degli errori con traceback
### funzione prime\$1math
Valuta le capacità di ragionamento matematico e di risoluzione dei problemi con il supporto della matematica simbolica.
**Formato di input**
```
{"messages":[{"role":"user","content":"What is the derivative of x^2 + 3x?."}],"reference_answer":"2*x + 3"}
```
**Caratteristiche principali**
+ Valutazione matematica simbolica utilizzando SymPy
+ Formati di risposta multipli (LaTeX, testo semplice, simbolico)
+ Controllo matematico dell'equivalenza
+ Normalizzazione e semplificazione delle espressioni
### Requisiti per il formato dei dati
**Per la valutazione del codice**
+ Input: matrice di argomenti delle funzioni (tipi propri: numeri interi, stringhe, ecc.)
+ Output: matrice di valori restituiti previsti (tipi appropriati: booleani, numeri, ecc.)
+ Codice: deve essere in Python con definizioni di funzioni chiare
**Per la valutazione matematica**
+ Risposta di riferimento: espressione matematica o valore numerico
+ Risposta: può essere LaTe X, testo semplice o notazione simbolica
+ Equivalenza: verificata simbolicamente, non solo in base alla corrispondenza tra stringhe
### Best practice
+ Usa i tipi di dati appropriati nei casi di test (numeri interi contro stringhe, booleani vs «True»)
+ Fornisci firme funzionali chiare nei problemi di codice
+ Includi casi limite negli input di test (zero, numeri negativi, input vuoti)
+ Formatta le espressioni matematiche in modo coerente nelle risposte di riferimento
+ Testa la tua funzione di ricompensa con dati di esempio prima dell'implementazione
### Gestione degli errori
Entrambe le funzioni includono una solida gestione degli errori per:
+ Errori di compilazione nel codice generato
+ Eccezioni di runtime durante l'esecuzione
+ Dati di input non validi
+ Scenari di timeout per loop infiniti
+ Espressioni matematiche non valide
## Creazione della funzione di ricompensa
### Requisiti Lambda ARN
Il tuo Lambda ARN deve seguire questo formato:
```
"arn:aws:lambda:*:*:function:*SageMaker*"
```
Se la Lambda non dispone di questo schema di denominazione, il processo avrà esito negativo con questo errore:
```
[ERROR] Unexpected error: lambda_arn must contain one of: ['SageMaker', 'sagemaker', 'Sagemaker'] when running on SMHP platform (Key: lambda_arn)
```
### Formato di richiesta Lambda
La tua funzione Lambda riceve i dati in questo formato:
```
[
{
"id": "sample-001",
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Do you have a dedicated security team?"
}
]
},
{
"role": "nova_assistant",
"content": [
{
"type": "text",
"text": "As an AI developed by Company, I don't have a dedicated security team..."
}
]
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
]
```
**Nota**
La struttura dei messaggi include l'`content`array annidato, corrispondente al formato dei dati di input. L'ultimo messaggio con ruolo `nova_assistant` contiene la risposta generata dal modello.
### Formato di risposta Lambda
La tua funzione Lambda deve restituire dati in questo formato:
```
[
{
"id": "sample-001",
"aggregate_reward_score": 0.75,
"metrics_list": [
{
"name": "accuracy",
"value": 0.85,
"type": "Metric"
},
{
"name": "fluency",
"value": 0.90,
"type": "Reward"
}
]
}
]
```
**Campi di risposta**
+ `id`— Deve corrispondere all'ID del campione di input
+ `aggregate_reward_score`— Punteggio complessivo (in genere da 0,0 a 1,0)
+ `metrics_list`— Serie di metriche individuali con:
+ `name`— Identificatore metrico (ad es. «precisione», «fluidità»)
+ `value`— Punteggio metrico (in genere da 0,0 a 1,0)
+ `type`— «Metrico» (per la rendicontazione) o «Premio» (utilizzato nella formazione)
## autorizzazioni IAM
### Autorizzazioni richieste
Il ruolo di SageMaker esecuzione deve disporre delle autorizzazioni per richiamare la funzione Lambda. Aggiungi questa politica al tuo SageMaker ruolo di esecuzione:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:region:account-id:function:function-name"
}
]
}
```
### Ruolo di esecuzione Lambda
Il ruolo di esecuzione della tua funzione Lambda richiede le autorizzazioni di esecuzione Lambda di base:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:*"
}
]
}
```
Se la tua funzione Lambda accede ad altri AWS servizi (ad esempio, S3 per i dati di riferimento, DynamoDB per la registrazione), aggiungi tali autorizzazioni al ruolo di esecuzione Lambda.
## Esecuzione del processo di valutazione
1. **Prepara i tuoi dati**: formatta i dati di valutazione in base ai requisiti di formato dei dati e carica il file JSONL su S3: `s3://your-bucket/eval-data/eval_data.jsonl`
1. **Configura la tua ricetta**: aggiorna la ricetta di esempio con la tua configurazione:
+ Imposta `model_name_or_path` la posizione del modello
+ Imposta `lambda_arn` sulla funzione di ricompensa ARN
+ Imposta `output_s3_path` la posizione di uscita desiderata
+ Regola `inference` i parametri secondo necessità
Salva la ricetta con nome `rft_eval_recipe.yaml`
1. **Esegui la valutazione**: esegui il processo di valutazione utilizzando il taccuino fornito: [Quaderni di valutazione](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook)
1. **Monitora i progressi**: monitora il processo di valutazione tramite:
+ SageMaker Console: controlla lo stato del lavoro e i registri
+ CloudWatch Registri: visualizza i registri di esecuzione dettagliati
+ Lambda Logs: problemi relativi alla funzione di ricompensa di debug
## Comprensione dei risultati della valutazione
### Formato di output
Il processo di valutazione restituisce i risultati nella posizione S3 specificata in formato JSONL. Ogni riga contiene i risultati della valutazione per un campione:
```
{
"id": "sample-001",
"aggregate_reward_score": 0.75,
"metrics_list": [
{
"name": "accuracy",
"value": 0.85,
"type": "Metric"
},
{
"name": "fluency",
"value": 0.90,
"type": "Reward"
}
]
}
```
**Nota**
L'RFT Evaluation Job Output è identico al formato Lambda Response. Il servizio di valutazione analizza la risposta della funzione Lambda senza modifiche, garantendo la coerenza tra i calcoli delle ricompense e i risultati finali.
### Interpretazione dei risultati
**Punteggio di ricompensa aggregato**
+ Intervallo: in genere da 0,0 (peggiore) a 1,0 (migliore), ma dipende dall'implementazione
+ Scopo: un unico numero che riassume le prestazioni complessive
+ Utilizzo: confronta i modelli, monitora i miglioramenti durante l'allenamento
**Metriche individuali**
+ Tipo di metrica: metriche informative per l'analisi
+ Tipo di ricompensa: metriche utilizzate durante la formazione RFT
+ Interpretazione: valori più alti in genere indicano prestazioni migliori (a meno che non si progettino metriche inverse)
### Benchmark delle prestazioni
Ciò che costituisce una «buona» prestazione dipende dal caso d'uso:
| Intervallo di punteggio | Interpretazione | Azione |
| --- | --- | --- |
| 0,8 - 1,0 | Eccellente | Modello pronto per l'implementazione |
| 0,6 - 0,8 | Buona | Potrebbero essere utili piccoli miglioramenti |
| 0,4 - 0,6 | Giusto | È necessario un miglioramento significativo |
| 0,0 - 0,4 | Povero | Rivedi i dati di allenamento e la funzione di ricompensa |
**Importante**
Queste sono linee guida generali. Definite le vostre soglie in base ai requisiti aziendali, alle prestazioni del modello di base, ai vincoli specifici del dominio e all'analisi costi-benefici dell'ulteriore formazione.
## Risoluzione dei problemi
### Problemi comuni
| Problema | Causa | Soluzione |
| --- | --- | --- |
| Timeout Lambda | Calcolo complesso dei premi | Aumentare il timeout Lambda o ottimizzare la funzione |
| Autorizzazione negata | Autorizzazioni IAM mancanti | Verifica che SageMaker il ruolo possa richiamare Lambda |
| Punteggi incoerenti | Funzione di ricompensa non deterministica | Usa seed fissi o logica deterministica |
| Risultati mancanti | Errori Lambda non rilevati | Aggiungi una gestione completa degli errori in Lambda |
### Lista di controllo per il debug
+ Verifica che i dati di input seguano il formato corretto con array di contenuti annidati
+ Verifica che l'ARN Lambda sia corretto e che la funzione sia stata implementata
+ Controlla le autorizzazioni IAM per SageMaker → Invocazione Lambda
+ Esamina CloudWatch i registri per gli errori Lambda
+ Verifica che la risposta Lambda corrisponda al formato previsto
## Best practice
+ Inizia in modo semplice: inizia con le funzioni di ricompensa di base e ripeti
+ Testa Lambda separatamente: utilizza gli eventi di test Lambda prima della valutazione completa
+ Convalida su set di dati di piccole dimensioni: esegui la valutazione sul sottoinsieme prima del set di dati completo
+ Controllo della versione: monitora le versioni della funzione di ricompensa insieme alle versioni del modello
+ Monitoraggio dei costi: le chiamate Lambda e il tempo di calcolo influiscono sui costi
+ Registra in modo esteso: utilizza le istruzioni di stampa in Lambda per il debug
+ Imposta i timeout in modo appropriato: equilibrio tra pazienza e costi
+ Metriche dei documenti: definisci chiaramente cosa misura ogni metrica
## Fasi successive
Dopo aver completato la valutazione RFT:
+ Se i risultati sono soddisfacenti: distribuisci il modello alla produzione
+ Se è necessario un miglioramento:
+ Regola la funzione di ricompensa
+ Raccogli più dati di allenamento
+ Modifica gli iperparametri di allenamento
+ Esegui iterazioni di addestramento RFT aggiuntive
+ Monitoraggio continuo: rivalutazione periodica con nuovi dati
# Implementazione di funzioni premi
## Panoramica di
La funzione di ricompensa (chiamata anche scorer o grader) è il componente principale che valuta le risposte del modello e fornisce segnali di feedback per l'allenamento. Deve essere implementata come una funzione Lambda che accetta le risposte del modello e restituisce punteggi di ricompensa.
## Formato dell'interfaccia
La tua funzione di ricompensa deve accettare e restituire dati nel seguente formato:
**Esempio di input per la formazione**
```
{
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
```
**Esempio di payload per la ricompensa lambda**
Il contenitore trasforma automaticamente i dati prima di inviarli alla funzione Lambda tramite:
1. Generazione di un modello di risposta per ogni prompt
1. Aggiungere il turno dell'assistente (risposta generata) all'array dei messaggi
1. Aggiungere un `id` campo unico per il tracciamento
La tua funzione Lambda riceverà i dati in questo formato trasformato:
```
{
"id": "123",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Amazon, I don not have a dedicated security team..."
}
],
# Following section will be same as your training dataset sample
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
```
**Contratto Reward Lambda**
```
def lambda_handler(event, context):
return lambda_grader(event)
def lambda_grader(samples: list[dict]) -> list[dict]:
"""
Args:
samples: List of dictionaries in OpenAI format
Example input:
{
"id": "123",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Company, I don nott have a dedicated security team..."
}
],
# This section will be same as your training dataset
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
Returns:
List of dictionaries with reward scores:
{
"id": str, # Same id as input sample
"aggregate_reward_score": float, # Overall score for the sample
"metrics_list": [ # OPTIONAL: Component scores
{
"name": str, # Name of the component score
"value": float, # Value of the component score
"type": str # "Reward" or "Metric"
}
]
}
"""
```
## Campi di input e output
### Campi di input
| Campo | Description | Note aggiuntive |
| --- | --- | --- |
| id | Identificatore univoco per il campione | Ripreso in uscita. Formato delle stringhe |
| messages | Cronologia chat ordinata in formato OpenAI | Matrice di oggetti di messaggio |
| messages [] .role | Relatore del messaggio | Valori comuni: «utente», «assistente», «sistema» |
| messaggi [] .content | Contenuto testuale del messaggio | Stringa normale |
| \$1\$1metadati | Informazioni in formato libero per facilitare la classificazione | Oggetto; campi opzionali trasmessi dai dati di addestramento |
### Campi di output
| Campo | Description | Note aggiuntive |
| --- | --- | --- |
| id | Stesso identificatore del campione di input | Deve corrispondere all'input |
| aggregate\$1reward\$1score | Punteggio complessivo del campione | Float (ad esempio, 0,0—1,0 o intervallo definito dall'attività) |
| metrics\$1list | Punteggi dei componenti che compongono l'aggregato | Matrice di oggetti metrici |
## Vincoli tecnici
+ **Limite di timeout**: tempo di esecuzione massimo di 15 minuti per chiamata Lambda
+ **Concorrenza: deve gestire le richieste simultanee** `rollout_worker_replicas * 64`
+ **Affidabilità**: deve implementare una corretta gestione degli errori e restituire punteggi validi in modo coerente
+ **Prestazioni**: ottimizzate per un'esecuzione rapida (secondi, non minuti) per consentire un allenamento efficiente
**Best practice**
+ Riduci al minimo le chiamate API esterne
+ Utilizza algoritmi e strutture dati efficienti
+ Implementa la logica di ripetizione dei tentativi per guasti transitori
+ Memorizza nella cache i calcoli riutilizzabili
+ Esegui test approfonditi prima dell'addestramento per garantire un'esecuzione priva di bug
## Utilizzo di funzioni di ricompensa personalizzate
Implementa funzioni di ricompensa personalizzate quando disponi di criteri di valutazione specifici per attività:
+ **Definisci i criteri di valutazione**: stabilisci cosa rappresenta una buona risposta per il tuo compito
+ **Implementa la funzione Lambda**: crea una funzione Lambda seguendo il formato dell'interfaccia
+ **Esegui il test a livello locale**: convalida la funzione e restituisce punteggi corretti per gli input di esempio
+ **Implementa su AWS**: distribuisci la tua Lambda e annota l'ARN
+ **Configura ricetta**: aggiungi l'ARN Lambda al campo della ricetta `reward_lambda_arn`
+ Esegui **test con set di dati di piccole dimensioni**: esegui RFT con un numero minimo di dati per verificare l'integrazione
## autorizzazioni IAM
### Autorizzazioni richieste
Il ruolo di SageMaker esecuzione deve disporre delle autorizzazioni per richiamare la funzione Lambda. Aggiungi questa politica al tuo SageMaker ruolo di esecuzione:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:region:account-id:function:function-name"
}
]
}
```
### Ruolo di esecuzione Lambda
Il ruolo di esecuzione della tua funzione Lambda richiede le autorizzazioni di esecuzione Lambda di base:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:*"
}
]
}
```
Autorizzazioni aggiuntive: se la funzione Lambda accede ad AWS altri servizi (ad esempio, S3 per i dati di riferimento, DynamoDB per la registrazione), aggiungi tali autorizzazioni al ruolo di esecuzione Lambda.
## Esempio: funzione di ricompensa LLM As a Judge
Questo esempio dimostra l'utilizzo dei modelli Amazon Bedrock come giudici per valutare le risposte del modello confrontandole con le risposte di riferimento. Questo modello Lambda fornisce ai clienti un framework per implementare chiamate ad Amazon Bedrock per richieste di inferenza per elaborare le valutazioni degli arbitri. La funzione Lambda mantiene lo stesso input/output contratto delle altre funzioni di ricompensa.
### Implementazione
Questa funzione Lambda implementa un processo di valutazione in due fasi: `lambda_handler` estrae le risposte del modello e le risposte di riferimento dai campioni in entrata, quindi la funzione `lambda_graded` chiama Amazon Bedrock per valutare la somiglianza semantica tra di esse. L'implementazione include una solida gestione degli errori con tentativi automatici in caso di errori temporanei e supporta formati di risposta di riferimento flessibili (formati di stringhe e dizionari strutturati).
**Dettagli di implementazione:**
+ **Retry Logic**: implementa il backoff esponenziale (1s, 2s, 4s) per limitare le eccezioni per gestire i limiti di velocità dell'API Bedrock
+ **Gestione degli errori**: restituisce un punteggio di 0,0 per le valutazioni non riuscite anziché sollevare eccezioni
+ **Punteggio deterministico: utilizza la** temperatura = 0,0 per garantire punteggi coerenti tra le valutazioni
+ **Formato di riferimento flessibile: gestisce automaticamente sia le risposte di riferimento** a stringhe che quelle del dizionario
+ **Fissaggio del punteggio**: assicura che tutti i punteggi rientrino nell'intervallo valido [0.0, 1.0]
+ **Indipendente dal modello: modifica** JUDGE\$1MODEL\$1ID per utilizzare qualsiasi modello Amazon Bedrock (Nova, Llama, Mistral, ecc.)
```
"""
LLM Judge Lambda POC - Working implementation using Amazon Bedrock
"""
import json
import time
import boto3
bedrock_runtime = boto3.client('bedrock-runtime', region_name='us-east-1')
JUDGE_MODEL_ID = "anthropic.claude-3-5-sonnet-20240620-v1:0"
SYSTEM_PROMPT = "You must output ONLY a number between 0.0 and 1.0. No explanations, no text, just the number."
JUDGE_PROMPT_TEMPLATE = """Compare the following two responses and rate how similar they are on a scale of 0.0 to 1.0, where:
- 1.0 means the responses are semantically equivalent (same meaning, even if worded differently)
- 0.5 means the responses are partially similar
- 0.0 means the responses are completely different or contradictory
Response A: {response_a}
Response B: {response_b}
Output ONLY a number between 0.0 and 1.0. No explanations."""
def lambda_graded(response_a: str, response_b: str, max_retries: int = 3) -> float:
"""Call Bedrock to compare responses and return similarity score."""
prompt = JUDGE_PROMPT_TEMPLATE.format(response_a=response_a, response_b=response_b)
for attempt in range(max_retries):
try:
response = bedrock_runtime.converse(
modelId=JUDGE_MODEL_ID,
messages=[{"role": "user", "content": [{"text": prompt}]}],
system=[{"text": SYSTEM_PROMPT}],
inferenceConfig={"temperature": 0.0, "maxTokens": 10}
)
print(f"Bedrock call successful: {response}")
output = response['output']['message']['content'][0]['text'].strip()
score = float(output)
print(f"Score parsed: {score}")
return max(0.0, min(1.0, score))
except Exception as e:
if "ThrottlingException" in str(e) and attempt < max_retries - 1:
time.sleep(2 ** attempt)
else:
print(f"Bedrock call failed: {e}")
return None
return None
def lambda_handler(event, context):
"""AWS Lambda handler - processes samples from RFTEvalInvoker."""
try:
samples = event if isinstance(event, list) else [event]
results = []
for sample in samples:
sample_id = sample.get("id", "unknown")
messages = sample.get("messages", [])
# Extract assistant response (response A)
response_a = ""
for msg in messages:
if msg.get("role") in ["assistant", "nova_assistant"]:
response_a = msg.get("content", "")
break
# Extract reference answer from root level (no longer in metadata)
reference_answer = sample.get("reference_answer", "")
# Handle both string and dict reference_answer formats
if isinstance(reference_answer, dict):
# If reference_answer is a dict, extract the explanation or compliant field
response_b = reference_answer.get("explanation", reference_answer.get("compliant", ""))
else:
response_b = reference_answer
if not response_a or not response_b:
results.append({
"id": sample_id,
"aggregate_reward_score": 0.0,
"metrics_list": [{"name": "similarity_score", "value": 0.0, "type": "Metric"}]
})
continue
# Get similarity score
score = lambda_graded(response_a, response_b)
results.append({
"id": sample_id,
"aggregate_reward_score": score,
"metrics_list": [
{
"name": "similarity_score",
"value": score,
"type": "Metric"
}
]
})
return {"statusCode": 200, "body": json.dumps(results)}
except Exception as e:
print(f"Error: {e}")
return {"statusCode": 500, "body": json.dumps({"error": str(e)})}
```
### Formato di input
La Lambda riceve lo stesso formato di input delle altre funzioni di ricompensa:
```
{
"id": "sample-001",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Amazon, I don't have a dedicated security team..."
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
},
"my_custom_field": "custom_value"
}
```
### Formato di output
```
{
"id": "sample-001",
"aggregate_reward_score": 0.85,
"metrics_list": [
{
"name": "similarity_score",
"value": 0.85,
"type": "Metric"
}
]
}
```
### Considerazioni sull'implementazione
Potrebbe inoltre essere necessario modificare il modello di prompt e i parametri di inferenza in base alle funzionalità del modello scelto e al formato API.
+ **Autorizzazioni IAM**: il ruolo di esecuzione Lambda deve `bedrock:InvokeModel` disporre dell'autorizzazione per il modello scelto
+ **Timeout: imposta il timeout** Lambda su almeno 60 secondi per adattarsi alla latenza e ai nuovi tentativi dell'API Bedrock
+ **Regione**: esegui la distribuzione in una regione in cui è disponibile il modello Bedrock scelto
+ **Costo**: monitora l'utilizzo dell'API Bedrock poiché ogni valutazione effettua una chiamata API per campione
+ **Produttività**: per le valutazioni su larga scala, richiedi un aumento delle quote Bedrock per evitare limitazioni
**Aumento della produttività di Bedrock**
Se riscontri un rallentamento durante la valutazione, aumenta le quote del modello Bedrock:
+ Vai alla console AWS Service Quotas
+ Cerca «Bedrock» e seleziona la tua regione
+ Trova la quota per il modello scelto (ad esempio, «Invocazioni al minuto per Claude 3.5 Sonnet»)
+ Fai clic su «Richiedi aumento della quota» e specifica la produttività desiderata
+ Fornisci una giustificazione per l'aumento (ad esempio, «carico di lavoro di valutazione RFT»)
La logica di ripetizione integrata in Lambda gestisce le limitazioni occasionali, ma valutazioni sostenute ad alto volume richiedono aumenti di quota adeguati.
**Policy IAM richiesta:**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": "arn:aws:bedrock:*::foundation-model/*"
}
]
}
```
# Addestramento iterativo
La formazione iterativa è un approccio sistematico per perfezionare i modelli attraverso più cicli di formazione, in cui ogni round si basa sul checkpoint precedente affrontando i punti deboli specifici scoperti durante la valutazione. Questo metodo consente miglioramenti mirati delle prestazioni del modello incorporando esempi curati che affrontano le modalità di errore, adattandosi ai requisiti in evoluzione e convalidando i miglioramenti in modo incrementale anziché impegnarsi in un unico lungo periodo di formazione. Il processo segue in genere modelli come SFT (Supervised Fine-Tuning) seguito da RFT (Reward-based Fine-Tuning), con checkpoint archiviati in bucket S3 escrow AWS gestiti a cui è possibile fare riferimento per le successive iterazioni di addestramento, mantenendo al contempo la coerenza nel tipo di modello e nella tecnica di addestramento in tutta la pipeline.
Per ulteriori informazioni, consulta [Formazione iterativa](nova-iterative-training.md).