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à.
# Definizione dei metodi di valutazione
## Panoramica di
Scegli UN metodo di valutazione per modello di prompt o ometti tutti i campi di valutazione opzionali per l'impostazione predefinita del sistema. Modelli diversi nello stesso lavoro possono utilizzare metodi diversi. La valutazione guida la pronta ottimizzazione, quindi definisci il metodo e i criteri nel modo più preciso possibile.
+ [Valutazione predefinita](#advanced-prompt-optimization-evaluation-default)
+ [Criteri direttivi](#advanced-prompt-optimization-evaluation-steering)
+ [Personalizzato LLM-as-a-judge](#advanced-prompt-optimization-evaluation-llmj)
+ [Valutatore Lambda personalizzato](#advanced-prompt-optimization-evaluation-lambda)
## Suggerimenti per i set di dati
+ **Combina esempi semplici e concreti**: abbina ciò che vedi nel mondo reale. All-easy i dati non spingeranno al miglioramento; i dati completi non lasciano nulla da cui imparare.
+ **Risolvi i casi che ti interessano**: il sistema generalizza al di là di ciò che vede, ma una distribuzione rappresentativa dei dati aiuta a generalizzare meglio gli input del mondo reale.
+ **Dopo una pronta ottimizzazione, esegui un test sui dati che l'ottimizzatore non ha ancora visto con un set di dati esaurito**: conferma che i guadagni sono reali e non solo memorizzati.
## Valutazione predefinita
Ometti tutti i campi di valutazione opzionali (`steeringCriteria`,`customLLMJConfig`,`evaluationMetricLambdaArn`). Il servizio utilizza un generico integrato LLM-as-judge basato su Anthropic Claude Sonnet 4.6 che valuta tre criteri predefiniti: accuratezza della risposta, completezza della risposta e qualità dell'espressione. In base alla risposta tempestiva fornita dal modello target e a una risposta di riferimento, il giudice assegna un punteggio a ciascuna dimensione. Quindi assegna dinamicamente i pesi appropriati all'attività e produce un punteggio complessivo ponderato.
Ti consigliamo di definire il tuo metodo di valutazione per ottenere i migliori risultati.
### Richiesta di valutazione predefinita fornita dal sistema
Di seguito è riportato il prompt di giudizio completo fornito dal sistema utilizzato nella valutazione predefinita con Anthropic Claude Sonnet 4.6:
```
Please act as an impartial judge and evaluate the quality of an answer to a user question, with the help of a reference answer.
You will be given:
(1) a user question, enclosed in tags
(2) an answer, enclosed in tags
(3) a reference answer, enclosed in tags
## Universal Evaluation Dimensions
Evaluate the answer across these core dimensions:
**(1) Answer Accuracy:**
examines correctness, consistency, and factuality alignment between the and the ;
examines if the contains irrelevant or wrongful information/hallucination.
**(2) Answer Completeness:**
examines if the is fully addressing the ;
examines if the is good at relevance/informativeness: selection of important/key content from
**(3) Expression Quality:**
examines if the is concise at answering the .
NOTE that unless there is special instruction, more concise is always better,
and explanation or rational is strictly NOT needed - THIS IS THE MOST IMPORTANT!
examines the alignment on instruction following, e.g., if the adheres
to both explicit guidelines and implicit guidelines (like few-shot examples) in the ;
## Scoring Rubric
For each dimension, assign one score:
- **3 points**: Fully satisfies the dimension requirements
- **2 points**: Mostly satisfies with minor issues or gaps
- **1 point**: Partially satisfies but has notable limitations
- **0 points**: Does not satisfy the dimension requirements
## Evaluation Process
1. First, identify the task type from the user question
2. Consider any additional criteria provided
3. Score each dimension independently
4. Determine appropriate weights and calculate final weighted score
## Dimension Weighting and Final Scoring
**Weight Determination Process:**
Assign weights (must sum to 1.0) based on:
- Explicit weights in evaluation_criteria (if provided)
- Task analysis and question requirements (if no explicit weights)
- Default weights (Answer Accuracy: 0.35, Answer Completeness: 0.30, Expression Quality: 0.35) as fallback
**Weight Guidelines:**
- **High Accuracy Weight (0.4-0.6)**: Factual questions, multiple choice, technical problems
- **High Completeness Weight (0.4-0.6)**: Complex explanatory tasks, multi-part questions
- **High Expression Weight (0.4-0.6)**: Creative tasks, presentation-focused questions, format-specific requirements
{custom_eval_weight_guideline}
**Overall Score Calculation:**
Overall = (Answer_Accuracy x Weight_A) + (Answer_Completeness x Weight_C) + (Expression_Quality x Weight_E)
## Output Format
Provide your evaluation in this exact format:
Brief analysis of task type and appropriate weight rationale
Answer Accuracy: 0.XX, Answer Completeness: 0.XX, Expression Quality: 0.XX
X
X
X
(X x 0.XX) + (X x 0.XX) + (X x 0.XX) = X.XX
X.XX
**Answer Accuracy**: [Evaluate factual accuracy, alignment with reference answer, absence of errors/hallucinations, and logical consistency]
**Answer Completeness**: [Assess whether all aspects of the question are addressed, necessary information is included, and content stays relevant]
**Expression Quality**: [Examine formatting/style adherence, appropriate detail level, communication clarity, and instruction following]
**Weight Application**: [Explain how the chosen weights reflect the task requirements and impact the final score]
---
## Current Evaluation Task
{prompt}
{prediction}
{gold}
Based on the above guidelines and criteria, provide your evaluation:
```
## Criteri direttivi
I criteri di guida sono brevi descrittori in linguaggio naturale che guidano la direzione dell'ottimizzazione.
+ **Format**: `"steeringCriteria": ["string1", "string2"]`
+ **Cosa possono essere: ** da una singola parola a poche frasi con descrizioni qualitative o quantitative di come si desidera che sia la risposta del modello.
+ **Limite: ** fino a 5 per modello di prompt.
**Esempio**:
```
"steeringCriteria": ["PROFESSIONAL", "CONCISE"]
```
## Personalizzato LLM-as-a-judge
Fornisci una rubrica completa con una scala di valutazione definita da te. La tua richiesta di giudizio personalizzata viene unita alla richiesta di giudizio del sistema del servizio e viene data una maggiore ponderazione.
### Configurazione
+ **Formato: plus ** `"customLLMJConfig": {"customLLMJPrompt": "...", "customLLMJModelId": "..."}` `"customEvaluationMetricLabel": "My Metric"`
+ **Modelli di giudice disponibili: ** anthropic.claude-opus-4-6-v1, anthropic.claude-sonnet-4-5-20250929-v 1:0, anthropic.claude-sonnet-4-6
+ **Segnaposto nella richiesta del giudice: **
+ `{{prompt}}`: il prompt completamente renderizzato (modello di richiesta più esempi di valutazione combinati)
+ `{{response}}`: l'output del modello
+ `{{referenceResponse}}`: la verità fondamentale
+ **Punteggio: ** definisci la tua scala di valutazione in modo che un numero più alto sia migliore. Il servizio normalizza tutti i punteggi per i risultati finali.
+ Se hai più rubriche, uniscile in un'unica richiesta del giudice.
### Procedure consigliate per la stesura delle istruzioni dei giudici
Usa una rubrica chiaramente definita con criteri di punteggio espliciti ed esempi concreti di ogni livello di punteggio. Ancorate ogni livello di rubrica con descrizioni comportamentali anziché aggettivi soggettivi. Includi almeno un esempio funzionante che mostri un punteggio non perfetto per far sì che il giudice non si limiti a punteggi elevati. Chiedi al modello di fornire una giustificazione scritta prima del punteggio numerico. Valuta la possibilità di valutare dimensioni specifiche in modo indipendente prima di assegnare un punteggio complessivo. I LLM-as-a-judge valutatori più affidabili e utili sono in genere quelli in cui siete d'accordo con le risposte fornite dal modello di giudice. Pertanto, può essere utile utilizzare una valutazione che hai già verificato.
### In che modo il prompt di giudizio personalizzato viene unito al prompt di sistema in fase di esecuzione
Quando fornisci il tuo prompt di LLM-as-a-judge valutazione, questo viene unito a un prompt di valutazione generico fornito dal servizio. Il prompt contiene istruzioni specifiche sulla formattazione e altre best practice che aiutano il progresso dell'ottimizzazione. Alla richiesta di valutazione personalizzata viene attribuita una ponderazione maggiore rispetto ai criteri generici nel giudizio finale. Nello specifico, il servizio:
+ Estrae l'intento dal tuo prompt personalizzato
+ Normalizza la scala in modo che corrisponda alla rubrica da 0 a 3 del sistema
+ La inserisce come dimensione denominata all'interno dei tag CUSTOM\_CRITERIA\_DESCRIPTION
+ Distorce le istruzioni di ponderazione per dare al criterio personalizzato un'importanza elevata (da 0,3 a 0,6)
+ Aggiunge regole di precedenza in base alle quali i criteri personalizzati hanno la precedenza sui conflitti con altre dimensioni
+ Preserva la semantica originale della valutazione
**Esempio: ** puoi fornire il seguente LLM-as-a-judge prompt personalizzato per valutare la fedeltà:
```
You are given a task in some context (Input), and a candidate answer. Is the candidate answer faithful to the task description and context?
A response is unfaithful only when (1) it clearly contradicts the context, or (2) the task implies that the response must be based on the context, like in a summarization task. If the task does not ask to respond based on the context, the model is allowed to use its own knowledge to provide a response, even if its claims are not verifiable.
Task: {{prompt}}
Candidate Response: {{response}}
First provide your explanation, then state your final answer. Use the following format: Explanation: [Explanation], Answer: [Answer], where '[Answer]' must be one of:
none is faithful
some is faithful
approximately half is faithful
most is faithful
all is faithful
```
Questo viene quindi unito al LLM-as-a-judge prompt predefinito e viene assegnato un forte peso. L'effetto finale: la richiesta di fedeltà basata su un solo criterio diventa un asse pesantemente ponderato in una valutazione multidimensionale, mentre il sistema aggiunge una struttura (precisione, completezza, espressione) attorno ad esso.
Di seguito è riportato il prompt unificato dei giudici risultante:
```
"""Please act as an impartial judge and evaluate the quality of an answer to a user question, with the help of a reference answer.
You will be given:
(1) a user question, enclosed in tags
(2) an answer, enclosed in tags
(3) a reference answer, enclosed in tags
(4) custom evaluation criteria that have been integrated into the evaluation dimensions below
**IMPORTANT**: - Custom criteria requirements take absolute precedence over user requirements specified inside
**IMPORTANT**: - If there is any conflict between custom criteria and user question requirements, prioritize custom criteria
## Universal Evaluation Dimensions
Evaluate the answer across these core dimensions:
**(1) Answer Accuracy:**
examines correctness, consistency, and factuality alignment between the and the ;
examines if the contains irrelevant or wrongful information/hallucination.
**(2) Answer Completeness:**
examines if the is fully addressing the ;
examines if the is good at relevance/informativeness: selection of important/key content from
**(3) Expression Quality:**
examines if the is concise at answering the .
NOTE that unless there is special instruction, more concise is always better,
and explanation or rational is strictly NOT needed - THIS IS THE MOST IMPORTANT!
examines the alignment on instruction following, e.g., if the adheres
to both explicit guidelines and implicit guidelines (like few-shot examples) in the ;
**(4) Faithfulness to Context:**
examines whether the candidate answer is faithful to the task description and context provided in the user question. A response is unfaithful only when (1) it clearly contradicts the context, or (2) the task implies that the response must be based on the context (like in a summarization task). If the task does not ask to respond based on the context, the model is allowed to use its own knowledge to provide a response, even if its claims are not verifiable. Evaluate the degree of faithfulness on the following scale:
- **3 points**: All content is faithful (no contradictions, fully grounded when required)
- **2 points**: Most content is faithful (minor deviations or unverifiable claims when context-grounding is required)
- **1 point**: Some content is faithful or approximately half is faithful (notable contradictions or significant departures from context when required)
- **0 points**: None or minimal content is faithful (clear contradictions or complete disregard of context when grounding is required)
## Dimension Weighting and Final Scoring
**Weight Determination Process:**
Assign weights (must sum to 1.0) based on:
- Explicit weights in evaluation_criteria (if provided)
- Task analysis and question requirements (if no explicit weights)
- Default weights (Answer Accuracy: 0.25, Answer Completeness: 0.25, Expression Quality: 0.25, Faithfulness to Context: 0.25) as fallback
**Weight Guidelines:**
- **High Accuracy Weight (0.3-0.5)**: Factual questions, multiple choice, technical problems
- **High Completeness Weight (0.3-0.5)**: Complex explanatory tasks, multi-part questions
- **High Expression Weight (0.3-0.5)**: Creative tasks, presentation-focused questions, format-specific requirements
- [*IMPORTANT*] **High Custom Criteria Weight**: The custom criteria (Faithfulness to Context) should always be *prioritized*. Assign it significant weight (0.3-0.6) and adjust other weights accordingly.
**Overall Score Calculation:**
Overall = (Answer_Accuracy x Weight_A) + (Answer_Completeness x Weight_C) + (Expression_Quality x Weight_E) + (Faithfulness_to_Context x Weight_F)
## Current Evaluation Task
{prompt}
{prediction}
{gold}
Based on the above guidelines and criteria, provide your evaluation:"""
```
## Valutatore Lambda personalizzato
Porta la tua funzione di punteggio come funzione Lambda.
### Configurazione
Specifica l'ARN Lambda nel file JSONL di input per ogni modello di prompt che dovrebbe utilizzarlo. Fornisci anche il `customEvaluationMetricLabel` campo per assegnare un nome alla metrica:
```
"evaluationMetricLambdaArn": "arn:aws:lambda:us-west-2:123456789012:function:my-eval-function",
"customEvaluationMetricLabel": "My Custom Metric"
```
Quando si crea il job tramite l'API, non è necessaria alcuna configurazione di valutazione aggiuntiva nella `CreateAdvancedPromptOptimizationJob` richiesta stessa. Il metodo di valutazione è determinato per modello dal file JSONL di input.
### Requisiti Lambda
+ `.py`File singolo con tutto il codice
+ Handler impostato su `lambda_function.lambda_handler`
+ Deve implementare `compute_score(preds, golds)` la restituzione `{"score": float, "scores": [float, ...]}`
+ Il `golds` parametro contiene i `referenceResponse` valori. Se non hai fornito `referenceResponse` il set di dati di input, non è necessario passare `golds` la `compute_score` funzione.
+ Non si blocca mai; restituisce 0.0 in caso di errori invece di sollevare eccezioni
+ Preferisci i punteggi continui (da 0,0 a 1,0) rispetto a quelli binari 0/1 per una convergenza di ottimizzazione più rapida
+ Non è necessario che i punteggi siano limitati a [0, 1].
+ I punteggi devono seguire una scala «più alto è meglio». Questo è un requisito affinché l'ottimizzazione funzioni correttamente.
+ Imposta il timeout su un massimo di 15 minuti (900 s) per lotti di grandi dimensioni per evitare timeout anticipati
+ Aggiungi una policy basata sulle risorse che consenta di richiamare la tua Lambda `bedrock.amazonaws.com`
### Suggerimenti sulle metriche Lambda
+ **Scrivi una docstring chiara `compute_score`**: la docstring viene estratta e mostrata al sistema come descrizione della metrica. Spiega cosa significa il punteggio e cosa rende un punteggio alto rispetto a un punteggio basso.
+ **Scrivi il tuo codice metrico in modo chiaro**: il codice sorgente completo viene letto dal sistema. Commenti, nomi delle variabili e logica leggibile aiutano a comprendere le tue intenzioni e a generare un feedback migliore.
+ **Preferisci i punteggi continui rispetto a quelli binari 0/1**: l'ottimizzatore massimizza il punteggio medio tra i campioni. Le gradazioni continue (ad esempio, crediti parziali) forniscono un segnale più fluido da seguire rispetto ai punteggi tutto o niente.
+ **Restituisci dettagli strutturati, non solo un numero**: la restituzione di un dict con punteggi secondari o campi diagnostici fornisce al sistema più segnali sul motivo per cui una previsione ha ottenuto un punteggio basso, portando a miglioramenti più mirati.
+ **Restituisci messaggi descrittivi con punteggi alternativi**: quando restituisci un punteggio alternativo di 0,0, includi un campo diagnostico nel dict del risultato (ad esempio,). `{"score": 0.0, "error": "JSON parse failed on line 3"}` Il sistema legge questi messaggi per capire perché una previsione ha ottenuto un punteggio basso e genera un feedback più mirato.
+ **Verifica il tuo punteggio**: segna alcuni risultati palesemente negativi per confermare che la metrica li penalizza. Se una risposta banale ottiene un buon punteggio, l'ottimizzatore troverà quella scorciatoia.
### Modello Lambda
```
"""
APO Custom Metric Lambda - Minimal Template
Handler: lambda_function.lambda_handler
"""
import logging
from typing import List, Dict, Any
logger = logging.getLogger()
logger.setLevel(logging.INFO)
def compute_score(preds: List[str], golds: List[str]) -> Dict[str, Any]:
"""
Score predictions against ground truths.
Args:
preds: Model outputs (one per sample)
golds: Expected answers (one per sample)
Returns:
Must contain:
"score": float - aggregate score (higher is better)
"scores": list[float] - per-instance scores
"""
# --- REPLACE THIS with your scoring logic ---
scores = []
for pred, gold in zip(preds, golds):
# Example: exact match (case-insensitive)
scores.append(1.0 if pred.strip().lower() == gold.strip().lower() else 0.0)
return {
"score": sum(scores) / len(scores) if scores else 0.0,
"scores": scores,
}
def lambda_handler(event, context):
"""
Lambda entry point. APO service sends:
event = {"preds": ["output1", ...], "golds": ["truth1", ...]}
"""
logger.info(f"Received {len(event.get('preds', []))} predictions")
try:
preds = event.get("preds", [])
golds = event.get("golds", [])
if not preds:
return {"score": 0.0, "scores": []}
return compute_score(preds, golds)
except Exception as e:
logger.error(f"Error: {e}", exc_info=True)
return {"score": 0.0, "scores": [0.0] * len(event.get("preds", [])), "error": str(e)}
```
Consulta gli esempi GitHub per AWS esempi più dettagliati, tra cui il codice standard per la gestione degli errori e la convalida dell'input della funzione Lambda.