Implementierung von Belohnungsfunktionen

-Übersicht

Die Belohnungsfunktion (auch Scorer oder Grader genannt) ist die Kernkomponente, die Modellantworten auswertet und Feedbacksignale für das Training liefert. Sie muss als Lambda-Funktion implementiert werden, die Modellantworten akzeptiert und Belohnungspunkte zurückgibt.

Format der Schnittstelle

Ihre Prämienfunktion muss Daten im folgenden Format akzeptieren und zurückgeben:

Beispiel für ein Eingabebeispiel für das Training

{  
    "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..."  
    }  
}

Beispielnutzlast für das Belohnungs-Lambda

Der Container transformiert Ihre Daten automatisch, bevor er sie an Ihre Lambda-Funktion sendet, indem er:

1. Generieren einer Modellantwort für jede Aufforderung

2. Der Turn des Assistenten (generierte Antwort) wird an das Nachrichten-Array angehängt

3. Ein eindeutiges id Feld für die Nachverfolgung hinzufügen

Ihre Lambda-Funktion empfängt Daten in diesem transformierten Format:

{    
   "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..."  
    }  
}

Lambda-Vertrag belohnen

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"  
                }  
            ]  
        }  
    """

Eingabe- und Ausgabefelder

Eingabefelder

Feld	Description	Weitere Hinweise
id	Eindeutiger Bezeichner für die Probe	In der Ausgabe wiedergegeben. Zeichenkettenformat
messages	Chatverlauf im OpenAI-Format bestellt	Reihe von Nachrichtenobjekten
nachrichten [] .role	Sprecher der Nachricht	Allgemeine Werte: „Benutzer“, „Assistent“, „System“
nachrichten [] .content	Textinhalt der Nachricht	Einfache Zeichenfolge
**Metadaten	Informationen in freier Form zur Unterstützung der Benotung	Objekt; optionale Felder, die aus Trainingsdaten übernommen wurden

Ausgabefelder

Feld	Description	Weitere Hinweise
id	Derselbe Bezeichner wie beim Eingabebeispiel	Muss mit der Eingabe übereinstimmen
aggregate_reward_score	Gesamtpunktzahl für die Stichprobe	Float (z. B. 0,0—1,0 oder aufgabendefinierter Bereich)
metrics_list	Die Werte der Komponenten, aus denen sich das Aggregat zusammensetzt	Anordnung von metrischen Objekten

Technische Einschränkungen

• Timeout-Limit — maximale Ausführungszeit von 15 Minuten pro Lambda-Aufruf

• Parallelität — Muss gleichzeitige Anfragen bearbeiten rollout_worker_replicas * 64

• Zuverlässigkeit — Muss eine angemessene Fehlerbehandlung implementieren und konsistent gültige Ergebnisse zurückgeben

• Leistung — Optimiere für eine schnelle Ausführung (Sekunden, nicht Minuten), um effizientes Training zu ermöglichen

Best Practices

• Minimiere externe API-Aufrufe

• Verwenden Sie effiziente Algorithmen und Datenstrukturen

• Implementieren Sie eine Wiederholungslogik für vorübergehende Fehler

• Wiederverwendbare Berechnungen zwischenspeichern

• Testen Sie vor dem Training gründlich, um eine fehlerfreie Ausführung sicherzustellen

Verwenden von benutzerdefinierten Belohnungsfunktionen

Implementieren Sie benutzerdefinierte Belohnungsfunktionen, wenn Sie aufgabenspezifische Bewertungskriterien haben:

• Definieren Sie Bewertungskriterien — Ermitteln Sie, was eine gute Antwort auf Ihre Aufgabe ausmacht

• Lambda-Funktion implementieren — Erstellen Sie eine Lambda-Funktion im Schnittstellenformat

• Lokal testen — Stellen Sie sicher, dass Ihre Funktion korrekte Werte für Beispieleingaben zurückgibt

• Bereitstellen auf AWS — Stellen Sie Ihr Lambda bereit und notieren Sie sich den ARN

• Rezept konfigurieren — Fügen Sie den Lambda-ARN zum Feld Ihres Rezepts reward_lambda_arn hinzu

• Test mit kleinem Datensatz — Führen Sie RFT mit minimalen Daten aus, um die Integration zu überprüfen

IAM-Berechtigungen

Erforderliche Berechtigungen

Ihre SageMaker Ausführungsrolle muss über Berechtigungen zum Aufrufen Ihrer Lambda-Funktion verfügen. Fügen Sie diese Richtlinie zu Ihrer SageMaker Ausführungsrolle hinzu:

{  
  "Version": "2012-10-17",		 	 	   
  "Statement": [  
    {  
      "Effect": "Allow",  
      "Action": [  
        "lambda:InvokeFunction"  
      ],  
      "Resource": "arn:aws:lambda:region:account-id:function:function-name"  
    }  
  ]  
}

Lambda-Ausführungsrolle

Die Ausführungsrolle Ihrer Lambda-Funktion benötigt grundlegende Lambda-Ausführungsberechtigungen:

{  
  "Version": "2012-10-17",		 	 	   
  "Statement": [  
    {  
      "Effect": "Allow",  
      "Action": [  
        "logs:CreateLogGroup",  
        "logs:CreateLogStream",  
        "logs:PutLogEvents"  
      ],  
      "Resource": "arn:aws:logs:*:*:*"  
    }  
  ]  
}

Zusätzliche Berechtigungen: Wenn Ihre Lambda-Funktion auf andere AWS Dienste zugreift (z. B. S3 für Referenzdaten, DynamoDB für die Protokollierung), fügen Sie diese Berechtigungen der Lambda-Ausführungsrolle hinzu.

Beispiel: LLM als Prämienfunktion für Richter

Dieses Beispiel zeigt, wie Amazon Bedrock-Modelle als Richter verwendet werden, um Modellantworten zu bewerten, indem sie mit Referenzantworten verglichen werden. Diese Lambda-Vorlage bietet Kunden ein Framework, mit dem sie Aufrufe an Amazon Bedrock für Inferenzanfragen zur Verarbeitung von Richterbeurteilungen implementieren können. Die Lambda-Funktion behält den gleichen input/output Vertrag wie andere Belohnungsfunktionen bei.

Implementierung

Diese Lambda-Funktion implementiert einen zweistufigen Bewertungsprozess: Sie lambda_handler extrahiert Modellantworten und Referenzantworten aus eingehenden Stichproben. Anschließend ruft die lambda_graded Funktion Amazon Bedrock auf, um die semantische Ähnlichkeit zwischen ihnen zu bewerten. Die Implementierung umfasst eine robuste Fehlerbehandlung mit automatischen Wiederholungsversuchen bei vorübergehenden Fehlern und unterstützt flexible Referenzantwortformate (sowohl Zeichenketten- als auch strukturierte Wörterbuchformate).

Einzelheiten der Implementierung:

• Retry Logic: Implementiert exponentielles Backoff (1s, 2s, 4s) zur Drosselung von Ausnahmen, um Bedrock-API-Ratenbegrenzungen zu umgehen

• Fehlerbehandlung: Gibt für fehlgeschlagene Auswertungen einen Wert von 0,0 zurück, anstatt Ausnahmen auszulösen

• Deterministische Bewertung: Verwendet Temperatur=0,0, um konsistente Ergebnisse bei allen Bewertungen sicherzustellen

• Flexibles Referenzformat: Verarbeitet automatisch sowohl Antworten auf Zeichenketten als auch auf Wörterbuchreferenzen

• Punktebegrenzung: Stellt sicher, dass alle Ergebnisse innerhalb des gültigen Bereichs [0,0, 1,0] liegen

• Modellunabhängig: Ändern Sie JUDGE_MODEL_ID, um ein beliebiges Amazon Bedrock-Modell (Nova, Llama, Mistral usw.) zu verwenden

"""  
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)})}

Eingabeformat

Das Lambda erhält dasselbe Eingabeformat wie andere Belohnungsfunktionen:

{  
    "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"  
}

Ausgabeformat

{  
    "id": "sample-001",  
    "aggregate_reward_score": 0.85,  
    "metrics_list": [  
        {  
            "name": "similarity_score",  
            "value": 0.85,  
            "type": "Metric"  
        }  
    ]  
}

Überlegungen zur Bereitstellung

Möglicherweise müssen Sie auch die Eingabeaufforderungsvorlage und die Inferenzparameter an die Funktionen und das API-Format Ihres ausgewählten Modells anpassen.

• IAM-Berechtigungen: Die Lambda-Ausführungsrolle muss über bedrock:InvokeModel Berechtigungen für das von Ihnen gewählte Modell verfügen

• Timeout: Legen Sie das Lambda-Timeout auf mindestens 60 Sekunden fest, um der Bedrock-API-Latenz und den Wiederholungsversuchen Rechnung zu tragen

• Region: In einer Region einsetzen, in der das von Ihnen gewählte Bedrock-Modell verfügbar ist

• Kosten: Überwachen Sie die Bedrock-API-Nutzung, da bei jeder Evaluierung ein API-Aufruf pro Probe erfolgt

• Durchsatz: Fordern Sie für umfangreiche Evaluationen erhöhte Bedrock-Kontingente an, um Drosselungen zu vermeiden

Erhöhung des Durchsatzes im Grundgestein

Wenn Sie während der Evaluierung eine Drosselung feststellen, erhöhen Sie die Kontingente für Ihr Bedrock-Modell:

• Navigieren Sie zur AWS Service Quotas Quotas-Konsole

• Suchen Sie nach „Bedrock“ und wählen Sie Ihre Region aus

• Finden Sie das Kontingent für das von Ihnen gewählte Modell heraus (zum Beispiel „Aufrufe pro Minute für Claude 3.5 Sonnet“)

• Klicken Sie auf „Erhöhung des Kontingents beantragen“ und geben Sie den gewünschten Durchsatz an

• Begründen Sie die Erhöhung (z. B. „Arbeitsaufwand bei der RFT-Evaluierung“)

Die in Lambda integrierte Wiederholungslogik bewältigt gelegentliche Drosselungen, aber dauerhaft umfangreiche Auswertungen erfordern angemessene Quotenerhöhungen.

Erforderliche IAM-Richtlinie:

{  
    "Version": "2012-10-17",		 	 	   
    "Statement": [  
        {  
            "Effect": "Allow",  
            "Action": [  
                "bedrock:InvokeModel"  
            ],  
            "Resource": "arn:aws:bedrock:*::foundation-model/*"  
        }  
    ]  
}