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 richiesta

2. Aggiungere il turno dell'assistente (risposta generata) all'array dei messaggi

3. 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
**metadati	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_reward_score	Punteggio complessivo del campione	Float (ad esempio, 0,0—1,0 o intervallo definito dall'attività)
metrics_list	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_MODEL_ID 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/*"  
        }  
    ]  
}