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à.
# Esempi di ricette di valutazione
Amazon Nova offre quattro tipi di ricette di valutazione, disponibili nell' GitHub archivio delle SageMaker HyperPod ricette.
## Ricette di benchmark testuali generali
Queste ricette consentono di valutare le funzionalità fondamentali dei modelli Amazon Nova attraverso una suite completa di benchmark di solo testo. Sono fornite nel formato `xxx_general_text_benchmark_eval.yaml`.
## Ricette di benchmark Bring Your Own Dataset
Queste ricette consentono di utilizzare un set di dati personalizzato per il benchmarking e confrontare i risultati del modello con risposte di riferimento utilizzando diversi tipi di metriche. Sono fornite nel formato `xxx_bring_your_own_dataset_eval.yaml`.
Di seguito sono riportati i requisiti per Bring Your Own Data:
+ Requisiti relativi al formato dei file
+ È necessario includere un singolo file `gen_qa.jsonl` contenente esempi di valutazione.
+ Il set di dati deve essere caricato in una posizione S3 a cui SageMaker Training Job possa accedervi.
+ Il file deve seguire il formato dello schema richiesto per un set di dati di domande e risposte generico.
+ Requisiti del formato dello schema - Ogni riga del file JSONL deve essere un oggetto JSON con i campi seguenti:
+ `query`: (obbligatorio) stringa contenente la domanda o l’istruzione che richiede una risposta
+ `response`: (obbligatorio) stringa contenente l’output del modello previsto
+ `system`: (facoltativo) stringa contenente il prompt di sistema che imposta il comportamento, il ruolo o la personalità del modello di intelligenza artificiale prima che elabori la query
+ `metadata`: (Facoltativo) Stringa contenente i metadati associati alla voce a scopo di etichettatura.
Ecco un esempio di inserimento Bring Your Own Dataset
```
{
"system":"You are a english major with top marks in class who likes to give minimal word responses: ",
"query":"What is the symbol that ends the sentence as a question",
"response":"?"
}
{
"system":"You are a pattern analysis specialist that provides succinct answers: ",
"query":"What is the next number in this series? 1, 2, 4, 8, 16, ?",
"response":"32"
}
{
"system":"You have great attention to detail that follows instructions accurately: ",
"query":"Repeat only the last two words of the following: I ate a hamburger today and it was kind of dry",
"response":"of dry"
}
```
Per utilizzare un set di dati personalizzato, modifica la ricetta di valutazione con i seguenti campi obbligatori, senza modificare alcun contenuto:
```
evaluation:
task: gen_qa
strategy: gen_qa
metric: all
```
Si applicano le limitazioni seguenti:
+ È consentito un solo file JSONL per valutazione.
+ Il file deve seguire rigorosamente lo schema definito.
+ Limite di lunghezza del contesto: per ogni campione del set di dati, la lunghezza del contesto (inclusi i prompt di interrogazione di sistema \+) deve essere inferiore a 3,5 k.
## Ricette di benchmark Nova LLM-as-a-judge
Amazon Nova LLM-as-a-judge è una funzionalità di valutazione del modello che consente ai clienti di confrontare la qualità delle risposte di un modello con una risposta del modello di base su un set di dati personalizzato. [Include un set di dati con prompt, risposte di base e risposte sfidanti e utilizza un modello Amazon Nova Judge per fornire una metrica della percentuale di vittorie basata sulla probabilità di Bradley-Terry con confronti a coppie.](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model)
Le ricette sono fornite nel formato `xxx_llm_judge_eval.yaml`.
Di seguito sono riportati i requisiti per LLM-as-a-judge:
+ Requisiti relativi al formato dei file
+ È necessario includere un singolo file `llm_judge.jsonl` contenente esempi di valutazione. Il nome del file deve essere `llm_judge.jsonl`.
+ [Il set di dati deve essere caricato in una posizione S3 a cui AI RIG può accedere. SageMaker SageMaker HyperPod ](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-hp-cluster.html)
+ Il file deve seguire il formato dello schema richiesto per il set di dati `llm_judge.jsonl`.
+ Il set di dati di input deve garantire che tutti i record abbiano una lunghezza di contesto inferiore a 12.000.
+ Requisiti del formato dello schema - Ogni riga del file JSONL deve essere un oggetto JSON con i campi seguenti:
+ `prompt`: (obbligatorio) una stringa contenente il prompt per la risposta generata.
+ `response_A`: una stringa contenente la risposta di base.
+ `response_B`: una stringa contenente la risposta alternativa da confrontare con la risposta di base.
Ecco un esempio di inserimento LLM-as-a-judge
```
{
"prompt": "What is the most effective way to combat climate change?",
"response_A": "The most effective way to combat climate change is through a combination of transitioning to renewable energy sources and implementing strict carbon pricing policies. This creates economic incentives for businesses to reduce emissions while promoting clean energy adoption.",
"response_B": "We should focus on renewable energy. Solar and wind power are good. People should drive electric cars. Companies need to pollute less."
}
{
"prompt": "Explain how a computer's CPU works",
"response_A": "CPU is like brain of computer. It does math and makes computer work fast. Has lots of tiny parts inside.",
"response_B": "A CPU (Central Processing Unit) functions through a fetch-execute cycle, where instructions are retrieved from memory, decoded, and executed through its arithmetic logic unit (ALU). It coordinates with cache memory and registers to process data efficiently using binary operations."
}
{
"prompt": "How does photosynthesis work?",
"response_A": "Plants do photosynthesis to make food. They use sunlight and water. It happens in leaves.",
"response_B": "Photosynthesis is a complex biochemical process where plants convert light energy into chemical energy. They utilize chlorophyll to absorb sunlight, combining CO2 and water to produce glucose and oxygen through a series of chemical reactions in chloroplasts."
}
```
Per utilizzare un set di dati personalizzato, modifica la ricetta di valutazione con i seguenti campi obbligatori, senza modificare alcun contenuto:
```
evaluation:
task: llm_judge
strategy: judge
metric: all
```
Si applicano le limitazioni seguenti:
+ È consentito un solo file JSONL per valutazione.
+ Il file deve seguire rigorosamente lo schema definito.
+ I modelli Amazon Nova Judge sono gli stessi per tutte le specifiche delle famiglie di modelli (ovvero Lite, Micro e Pro).
+ Al momento i modelli Judge personalizzati non sono supportati.
+ Limite di lunghezza del contesto: per ogni campione del set di dati, la lunghezza del contesto (inclusi i prompt di interrogazione di sistema \+) deve essere inferiore a 7k.
## Nova LLM come giudice per le ricette di riferimento multimodali (immagini)
Nova LLM Judge for multi-modal (immagine), abbreviazione di Amazon Nova MM\_LLM Judge, è una funzionalità di valutazione del modello che consente di confrontare la qualità delle risposte di un modello con le risposte di un modello di base utilizzando un set di dati personalizzato. [Accetta un set di dati contenente prompt, risposte di base e risposte sfidanti e immagini sotto forma di stringa codificata in Base64, quindi utilizza un modello Amazon Nova Judge per fornire una metrica del tasso di successo basata sulla probabilità di Bradley-Terry attraverso confronti a coppie.](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) Formato della ricetta: `xxx_mm_llm_judge _eval.yaml`.
**Requisiti dei set di dati Nova LLM**
Formato del file:
+ Singolo file `mm_llm_judge.jsonl` contenente esempi di valutazione. Il nome del file deve essere esatto. `llm_judge.jsonl`
+ È necessario caricare il set di dati in una posizione S3 a cui SageMaker Training Jobs possa accedervi.
+ Il file deve seguire il formato dello schema richiesto per il set di dati `mm_llm_judge`.
+ Il set di dati di input dovrebbe garantire che tutti i record abbiano una lunghezza di contesto inferiore a 12 k, escluso l'attributo dell'immagine.
Formato dello schema - Ogni riga del file `.jsonl` deve essere un oggetto JSON con i campi seguenti.
+ Campi obbligatori.
`prompt`: stringa contenente il prompt per la risposta generata.
`images`: Array contenente un elenco di oggetti con attributi di dati (i valori sono stringhe di immagine codificate in Base64).
`response_A`: stringa contenente la risposta di base.
`response_B`: stringa contenente la risposta alternativa da confrontare con la risposta di base.
Esempio di inserimento
Per motivi di leggibilità, l'esempio seguente include nuove righe e rientri, ma nel set di dati effettivo, ogni record deve trovarsi su una sola riga.
```
{
"prompt": "what is in the image?",
"images": [
{
"data": "data:image/jpeg;Base64,/9j/2wBDAAQDAwQDAwQEAwQFBAQFBgo..."
}
],
"response_A": "a dog.",
"response_B": "a cat.",
}
{
"prompt": "how many animals in echo of the images?",
"images": [
{
"data": "data:image/jpeg;Base64,/9j/2wBDAAQDAwQDAwQEAwQFBAQFBgo..."
},
{
"data": "data:image/jpeg;Base64,/DKEafe3gihn..."
}
],
"response_A": "The first image contains one cat and the second image contains one dog",
"response_B": "The first image has one aminal and the second has one animal",
}
```
Per utilizzare un set di dati personalizzato, modifica la ricetta di valutazione con i seguenti campi obbligatori, senza modificare alcun contenuto:
```
evaluation:
task: mm_llm_judge
strategy: judge
metric: all
```
**Limitazioni**
+ È consentito un solo file `.jsonl` per valutazione.
+ Il file deve seguire rigorosamente lo schema definito.
+ I modelli Nova MM Judge supportano solo il riferimento alle immagini.
+ I modelli Nova MM Judge sono gli stessi per tutte le specifiche di Amazon Nova Lite.
+ Attualmente i modelli Judge personalizzati non sono supportati.
+ L'URI di immagine Amazon S3 non è supportato.
+ Il set di dati di input dovrebbe garantire che tutti i record abbiano una lunghezza di contesto inferiore a 12 k, escluso l'attributo images.
## Giudice basato sulla rubrica
Rubric Judge è un modello di LLM-as-a-judge valutazione avanzato basato su Amazon Nova 2.0 Lite. A differenza del [modello di arbitro originale](https://aws.amazon.com/blogs/machine-learning/evaluating-generative-ai-models-with-amazon-nova-llm-as-a-judge-on-amazon-sagemaker-ai/) che fornisce solo verdetti di preferenza (A>B, B>A o pareggio), Rubric Judge genera dinamicamente criteri di valutazione personalizzati su misura per ogni richiesta e assegna punteggi granulari su più dimensioni.
Funzionalità chiave:
+ **Generazione dinamica di criteri**: crea automaticamente dimensioni di valutazione pertinenti in base alla richiesta di input
+ **Punteggio ponderato: assegna dei pesi** di importanza a ciascun criterio in base alla loro importanza relativa
+ **Valutazione granulare**: fornisce punteggi dettagliati su base binaria (vero/falso) o su scala (1-5) per ogni criterio
+ **Metriche di qualità**: calcola punteggi di qualità continui (scala 0-1) che quantificano l'entità delle differenze tra le risposte
Criterio di esempio generato dal modello:
```
price_validation:
description: "The response includes validation to ensure price is a positive value."
type: "scale"
weight: 0.3
```
Il modello valuta entrambe le risposte rispetto a tutti i criteri generati, quindi utilizza questi punteggi a livello di criterio per determinare la preferenza finale.
**Topics**
+ [Configurazione della ricetta](#nova-hp-evaluate-rubric-judge-recipe)
+ [Formato del set di dati di input](#nova-hp-evaluate-rubric-judge-input)
+ [Risultato della valutazione](#nova-hp-evaluate-rubric-judge-output)
+ [Supporto del modello di ragionamento](#nova-hp-evaluate-rubric-judge-reasoning)
### Configurazione della ricetta
**Ricetta Rubric Judge**
Abilita Rubric Judge `task: rubric_llm_judge` impostando nella tua ricetta:
```
run:
name: nova-eval-job-name # [MODIFIABLE] Unique identifier for your evaluation job
model_type: amazon.nova-2-lite-v1:0:256k # [FIXED] Rubric Judge model type
model_name_or_path: "nova-lite-2/prod" # [FIXED] Path to model checkpoint or identifier
replicas: 1 # [MODIFIABLE] Number of replicas for SageMaker Training job
data_s3_path: "" # [FIXED] Leave empty for SageMaker Training job
output_s3_path: "" # [FIXED] Leave empty for SageMaker Training job
evaluation:
task: rubric_llm_judge # [FIXED] Evaluation task - enables Rubric Judge
strategy: judge # [FIXED] Evaluation strategy
metric: all # [FIXED] Metric calculation method
inference:
max_new_tokens: 12000 # [MODIFIABLE] Maximum tokens to generate
top_k: -1 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
```
**Ricetta originale LLM as a Judge (per confronto)**
Il modello di giudice originale utilizza`task: llm_judge`:
```
run:
name: eval-job-name # [MODIFIABLE] Unique identifier for your evaluation job
model_type: amazon.nova-micro-v1:0:128k # [FIXED] Model type
model_name_or_path: "nova-micro/prod" # [FIXED] Path to model checkpoint or identifier
replicas: 1 # [MODIFIABLE] Number of replicas for SageMaker Training job
data_s3_path: "" # [FIXED] Leave empty for SageMaker Training job
output_s3_path: "" # [FIXED] Leave empty for SageMaker Training job
evaluation:
task: llm_judge # [FIXED] Original judge task
strategy: judge # [FIXED] Evaluation strategy
metric: all # [FIXED] Metric calculation method
inference:
max_new_tokens: 12000 # [MODIFIABLE] Maximum tokens to generate
top_k: -1 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
```
### Formato del set di dati di input
Il formato del set di dati di input è identico al modello [originale del giudice](https://aws.amazon.com/blogs/machine-learning/evaluating-generative-ai-models-with-amazon-nova-llm-as-a-judge-on-amazon-sagemaker-ai/):
**Campi obbligatori:**
+ `prompt`: Stringa contenente il prompt di input e le istruzioni
+ `response_A`: Stringa contenente l'output del modello di base
+ `response_B`: Stringa contenente l'output del modello personalizzato
**Set di dati di esempio (formato JSONL):**
```
{"prompt": "What is the most effective way to combat climate change?", "response_A": "The most effective way to combat climate change is through a combination of transitioning to renewable energy sources and implementing strict carbon pricing policies. This creates economic incentives for businesses to reduce emissions while promoting clean energy adoption.", "response_B": "We should focus on renewable energy. Solar and wind power are good. People should drive electric cars. Companies need to pollute less."}
{"prompt": "Explain how a computer's CPU works", "response_A": "CPU is like brain of computer. It does math and makes computer work fast. Has lots of tiny parts inside.", "response_B": "A CPU (Central Processing Unit) functions through a fetch-execute cycle, where instructions are retrieved from memory, decoded, and executed through its arithmetic logic unit (ALU). It coordinates with cache memory and registers to process data efficiently using binary operations."}
{"prompt": "How does photosynthesis work?", "response_A": "Plants do photosynthesis to make food. They use sunlight and water. It happens in leaves.", "response_B": "Photosynthesis is a complex biochemical process where plants convert light energy into chemical energy. They utilize chlorophyll to absorb sunlight, combining CO2 and water to produce glucose and oxygen through a series of chemical reactions in chloroplasts."}
```
**Requisiti di formato:**
+ Ogni voce deve essere un oggetto JSON a riga singola
+ Separa le voci con nuove righe
+ Segui l'esatta denominazione dei campi, come mostrato negli esempi
### Risultato della valutazione
**Struttura di output**
Rubric Judge produce metriche di valutazione migliorate rispetto al modello di giudice originale:
```
{
"config_general": {
"lighteval_sha": "string",
"num_fewshot_seeds": "int",
"max_samples": "int | null",
"job_id": "int",
"start_time": "float",
"end_time": "float",
"total_evaluation_time_secondes": "string",
"model_name": "string",
"model_sha": "string",
"model_dtype": "string | null",
"model_size": "string"
},
"results": {
"custom|rubric_llm_judge_judge|0": {
"a_scores": "float",
"a_scores_stderr": "float",
"b_scores": "float",
"b_scores_stderr": "float",
"ties": "float",
"ties_stderr": "float",
"inference_error": "float",
"inference_error_stderr": "float",
"score": "float",
"score_stderr": "float",
"weighted_score_A": "float",
"weighted_score_A_stderr": "float",
"weighted_score_B": "float",
"weighted_score_B_stderr": "float",
"score_margin": "float",
"score_margin_stderr": "float",
"winrate": "float",
"lower_rate": "float",
"upper_rate": "float"
}
},
"versions": {
"custom|rubric_llm_judge_judge|0": "int"
}
}
```
**Nuove metriche in Rubric Judge**
Le seguenti sei metriche sono esclusive di Rubric Judge e forniscono una valutazione granulare della qualità:
| Metrica | Description |
| --- |--- |
| punteggio\_ponderato\_A | Punteggio di qualità medio normalizzato per Response\_a in base a tutti i criteri di valutazione generati dal modello. I punteggi sono ponderati in base all'importanza del criterio e normalizzati su una scala 0-1 (più alto = migliore qualità) |
| Weighted\_score\_a\_stderr | Errore standard della media per Weighted\_score\_a, che indica l'incertezza statistica |
| Punteggio\_ponderato\_B | Punteggio di qualità medio normalizzato per Response\_b in tutti i criteri di valutazione generati dal modello. I punteggi sono ponderati in base all'importanza del criterio e normalizzati su una scala 0-1 (più alto = migliore qualità) |
| Weighted\_score\_b\_stderr | Errore standard della media per Weighted\_score\_b, che indica l'incertezza statistica |
| score\_margin | Differenza tra i punteggi ponderati (calcolati come Weighted\_score\_A - Weighted\_score\_b). Intervallo: da -1,0 a 1,0. Positivo = response\_a è migliore; negativo = response\_B è migliore; vicino allo zero = qualità simile |
| score\_margin\_stderr | Errore standard della media di score\_margin, che indica l'incertezza nella misurazione della differenza di qualità |
**Comprensione delle metriche dei punteggi ponderati**
**Scopo**: i punteggi ponderati forniscono misurazioni continue della qualità che completano i verdetti sulle preferenze binarie, consentendo una visione più approfondita delle prestazioni del modello.
**Principali differenze rispetto al giudice originale**:
+ **Giudice originale**: emette solo preferenze discrete (A>B, B>A, A=B)
+ **Rubric Judge: emette** sia le preferenze che i punteggi di qualità continui (scala 0-1) in base a criteri personalizzati
**Interpretazione** di score\_margin:
+ `score_margin = -0.128`: Response\_B ha ottenuto 12,8 punti percentuali in più rispetto a Response\_a
+ `|score_margin| < 0.1`: Differenza di qualità ridotta (decisione ravvicinata)
+ `|score_margin| > 0.2`: Chiara differenza di qualità (decisione sicura)
**Casi d'uso**:
+ **Miglioramento del modello**: identifica le aree specifiche in cui il tuo modello ha prestazioni inferiori
+ **Quantificazione della qualità**: misura l'entità dei divari prestazionali, non solo i rapporti win/loss
+ **Valutazione della fiducia**: distinguere tra decisioni ravvicinate e chiare differenze di qualità
**Importante**
I verdetti finali si basano ancora sulle etichette di preferenza esplicite del modello giudicante per preservare un ragionamento olistico e garantire un'adeguata mitigazione dei pregiudizi di posizione attraverso la valutazione. forward/backward I punteggi ponderati servono come strumenti di osservabilità, non come sostituti del verdetto primario.
**Metodologia di calcolo**
I punteggi ponderati vengono calcolati attraverso il seguente processo:
+ **Estrai i dati dei criteri: analizza l'**output YAML del giudice per estrarre i punteggi e i pesi dei criteri
+ **Normalizza** i punteggi:
+ Criteri basati sul tipo di scala (1-5): normalizza a 0-1 calcolando `(score - 1) / 4`
+ Criteri binari (vero/falso): converti in 1,0/0,0
+ **Applica pesi**: moltiplica ogni punteggio normalizzato per il relativo peso del criterio
+ **Aggregato**: somma tutti i punteggi ponderati per ogni risposta
+ **Calcola il margine**: calcola `score_margin = weighted_score_A - weighted_score_B`
**Esempio**: se response\_a ha una somma ponderata di 0,65 e Response\_b ha 0,78, `score_margin` sarebbe -0,13, indicando che response\_b è di 13 punti percentuali superiore in termini di qualità in tutti i criteri ponderati.
### Supporto del modello di ragionamento
Il supporto del modello di ragionamento consente la valutazione con modelli Amazon Nova compatibili con il ragionamento che eseguono un ragionamento interno esplicito prima di generare risposte finali. Questa funzionalità utilizza il controllo a livello di API tramite il `reasoning_effort` parametro per abilitare o disabilitare dinamicamente la funzionalità di ragionamento, migliorando potenzialmente la qualità della risposta per attività analitiche complesse.
**Modelli supportati:**
+ amazon.nova-2-lite-v 1:0:256k
**Configurazione della ricetta**
Abilita il ragionamento aggiungendo il `reasoning_effort` parametro alla `inference` sezione della tua ricetta:
```
run:
name: eval-job-name # [MODIFIABLE] Unique identifier for your evaluation job
model_type: amazon.nova-2-lite-v1:0:256k # [FIXED] Must be a reasoning-supported model
model_name_or_path: nova-lite-2/prod # [FIXED] Path to model checkpoint or identifier
replicas: 1 # [MODIFIABLE] Number of replicas for SageMaker Training job
data_s3_path: "" # [MODIFIABLE] Leave empty for SageMaker Training job; optional for SageMaker SageMaker HyperPod job
output_s3_path: "" # [MODIFIABLE] Output path for SageMaker SageMaker HyperPod job (not compatible with SageMaker Training jobs)
evaluation:
task: mmlu # [MODIFIABLE] Evaluation task
strategy: generate # [MODIFIABLE] Evaluation strategy
metric: all # [MODIFIABLE] Metric calculation method
inference:
reasoning_effort: high # [MODIFIABLE] Enables reasoning mode; options: low/medium/high or null to disable
max_new_tokens: 200 # [MODIFIABLE] Maximum tokens to generate
top_k: 50 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
```
**Utilizzo del parametro reasoning\_effort**
Il `reasoning_effort` parametro controlla il comportamento di ragionamento per i modelli in grado di ragionare.
**Prerequisiti:**
+ **Compatibilità dei modelli**: impostata `reasoning_effort` solo quando `model_type` specifica un modello in grado di ragionare (attualmente) `amazon.nova-2-lite-v1:0:256k`
+ **Gestione degli errori**: l'utilizzo `reasoning_effort` con modelli non supportati avrà esito negativo con `ConfigValidationError: "Reasoning mode is enabled but model '{model_type}' does not support reasoning. Please use a reasoning-capable model or disable reasoning mode."`
**Opzioni disponibili:**
| Opzione | Comportamento | Limite di token | Caso d'uso |
| --- |--- |--- |--- |
| null (impostazione predefinita) | Disattiva la modalità di ragionamento | N/D | Valutazione standard senza sovraccarico di ragionamento |
| low | Consente il ragionamento con vincoli | 4.000 token per il ragionamento interno | Scenari che richiedono un ragionamento conciso; ottimizza velocità e costi |
| high | Consente il ragionamento senza vincoli | Nessun limite simbolico al ragionamento interno | Problemi complessi che richiedono analisi e step-by-step ragionamenti approfonditi |
**Quando abilitare il ragionamento**
**Usa la modalità di ragionamento (`low``medium`, o`high`)** per:
+ Compiti complessi di risoluzione di problemi (matematica, puzzle logici, programmazione)
+ Domande analitiche in più fasi che richiedono un ragionamento intermedio
+ Attività in cui spiegazioni o riflessioni dettagliate migliorano la precisione step-by-step
+ Scenari in cui la qualità della risposta è prioritaria rispetto alla velocità
**Utilizza la modalità non ragionamento (parametro di omissione)** per:
+ Domande e risposte semplici o domande basate sui fatti
+ Attività di scrittura creativa
+ Quando i tempi di risposta più rapidi sono fondamentali
+ Analisi comparativa delle prestazioni in cui è necessario escludere il sovraccarico di ragionamento
+ L'ottimizzazione dei costi quando il ragionamento non migliora le prestazioni delle attività
**Risoluzione dei problemi**
**Errore: «La modalità di ragionamento è abilitata ma il modello non supporta il ragionamento»**
**Causa**: il `reasoning_effort` parametro è impostato su un valore diverso da nullo, ma quello specificato `model_type` non supporta il ragionamento.
**Risoluzione:**
+ Verifica che il tipo di modello sia `amazon.nova-2-lite-v1:0:256k`
+ Se utilizzi un modello diverso, passa a un modello in grado di ragionare o rimuovi il `reasoning_effort` parametro dalla tua ricetta