Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Feinabstimmung von Verstärkungen (RFT) für Modelle Amazon Nova

-Übersicht

Was ist RFT?

Reinforcement Fine-Tuning (RFT) verbessert die Modellleistung, indem das Training anhand von Feedbacksignalen — messbaren Ergebnissen oder Belohnungen, die anzeigen, wie gut das Modell abgeschnitten hat — und nicht anhand exakter richtiger Antworten trainiert wird. Im Gegensatz zur überwachten Feinabstimmung, die aus Input-Output-Paaren lernt, verwendet RFT Belohnungsfunktionen, um die Modellantworten zu bewerten, und optimiert das Modell iterativ, um diese Belohnungen zu maximieren. Dieser Ansatz zeichnet sich besonders dann aus, wenn es schwierig ist, den exakt richtigen Output zu definieren, aber Sie können die Antwortqualität zuverlässig messen.

Wann sollte RFT verwendet werden

Verwenden Sie RFT, wenn Sie klare, messbare Erfolgskriterien definieren können, aber Schwierigkeiten haben, exakt korrekte Ergebnisse für das Training zu liefern. Es ist ideal für:

Beste Anwendungsfälle

RFT zeichnet sich besonders in Bereichen aus, in denen die Ausgabequalität objektiv gemessen werden kann, es jedoch schwierig ist, optimale Antworten im Voraus zu definieren:

Unterstützte Modelle

Amazon NovaLite 2.0

Data format (Datenformat)

RFT-Trainingsdaten müssen dem OpenAI Reinforcement Fine-Tuning-Format entsprechen. Jedes Trainingsbeispiel ist ein JSON-Objekt, das Folgendes enthält:

Beispiel: Mathematische Aufgabe

{
  "id": "sample-001",
  "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"]
  }
}

Das reference_answer Feld enthält die erwarteten Ausgabe- oder Bewertungskriterien, anhand derer Ihre Belohnungsfunktion die Antwort des Modells bewertet. Es ist nicht auf strukturierte Ausgaben beschränkt — es kann jedes Format enthalten, das Ihrer Belohnungsfunktion bei der Bewertung der Qualität hilft.

Empfehlungen zur Größe von Datensätzen

Ausgangspunkt

Der Ansatz steht bei der Bewertung an erster Stelle

Bevor Sie in groß angelegte RFT-Schulungen investieren, sollten Sie die Ausgangsleistung Ihres Modells bewerten:

Wenn Sie mit einem kleinen Datensatz beginnen, können Sie überprüfen, ob Ihre Belohnungsfunktion fehlerfrei ist, ob RFT der richtige Ansatz für Ihren Anwendungsfall ist, Probleme frühzeitig erkennen und beheben und den Workflow testen, bevor Sie ihn skalieren.

Eigenschaften effektiver Trainingsdaten

Klarheit und Konsistenz

Gute RFT-Beispiele erfordern klare, eindeutige Eingabedaten, die eine genaue Berechnung der Belohnung für verschiedene Modellergebnisse ermöglichen. Vermeiden Sie Unklarheiten in Ihren Daten, z. B. inkonsistente Formatierungen, widersprüchliche Bezeichnungen oder Anweisungen, mehrdeutige Eingabeaufforderungen und widersprüchliche Referenzantworten. Jede Unklarheit führt den Trainingsprozess in die Irre und führt dazu, dass das Modell unbeabsichtigte Verhaltensweisen erlernt.

Diversität

Ihr Datensatz sollte die gesamte Vielfalt der Anwendungsfälle in der Produktion erfassen, um eine robuste Leistung unter realen Bedingungen zu gewährleisten. Beziehen Sie verschiedene Eingabeformate und Sonderfälle ein, bilden Sie die tatsächlichen Nutzungsmuster in der Produktion anhand von Protokollen und Benutzeranalysen ab, nehmen Sie Stichproben für verschiedene Benutzertypen, geografische Regionen und saisonale Schwankungen vor und beziehen Sie Schwierigkeitsgrade von einfachen bis hin zu komplexen Problemen ein.

Überlegungen zur Belohnungsfunktion

Gestalten Sie Ihre Belohnungsfunktion für effizientes Training. Sie sollte innerhalb von Sekunden (nicht Minuten) ausgeführt werden, effektiv parallelisierenAWS Lambda, konsistente, zuverlässige Ergebnisse liefern und verschiedene Arten von Modellausgaben problemlos verarbeiten. Schnelle, skalierbare Belohnungsfunktionen ermöglichen schnelle Iterationen und kostengünstiges Experimentieren.

Zusätzliche Eigenschaften

Das RFT-Datenformat unterstützt benutzerdefinierte Felder, die über die grundlegenden Schemaanforderungen (messagesund) hinausgehen. reference_answer Diese Flexibilität ermöglicht es Ihnen, alle zusätzlichen Daten hinzuzufügen, die Ihre Belohnungsfunktion für eine korrekte Auswertung benötigt.

Allgemeine zusätzliche Eigenschaften

Diese zusätzlichen Felder werden während der Bewertung an Ihre Prämienfunktion übergeben und ermöglichen so eine ausgeklügelte Bewertungslogik, die auf Ihren speziellen Anwendungsfall zugeschnitten ist.

Beispiele mit zusätzlichen Eigenschaften

Chemistry problem

{
  "id": "chem-001",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful chemistry assistant"
    },
    {
      "role": "user",
      "content": "Predict hydrogen bond donors and acceptors for this SMILES: CCN(CC)CCC(=O)c1sc(N)nc1C"
    }
  ],
  "reference_answer": {
    "donor_bond_counts": 2,
    "acceptor_bond_counts": 4
  }
}

Das reference_answer Feld enthält die erwarteten Ausgabe- oder Bewertungskriterien, anhand derer Ihre Belohnungsfunktion die Antwort des Modells bewertet. Es ist nicht auf strukturierte Ausgaben beschränkt — es kann jedes Format enthalten, das Ihrer Belohnungsfunktion bei der Bewertung der Qualität hilft.

Math problem with metadata

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

Implementierung von Belohnungsfunktionen

Belohnungsfunktionen werden als Lambda-Funktionen implementiert, die Modellantworten auswerten und numerische Werte zurückgeben. Die Lambda-Funktion empfängt Nachrichten und Ground Truth im OpenAI-Format und muss Punktzahlen als Wörterbuch zurückgeben.

IAM-Berechtigungen

Stellen Sie sicher, dass Ihre SageMaker KI-Ausführungsrolle über InvokeFunction Berechtigungen für die Lambda-Funktion verfügt.

{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "lambda:InvokeFunction",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:my-reward-function-lambda"
    }
  ]
}

Richtlinien für das Design

Gehen Sie beim Schreiben von Belohnungsfunktionen wie folgt vor:

Format der Schnittstelle

Ihre Belohnungsfunktion muss Daten im folgenden Format akzeptieren und zurückgeben.

Eingabestruktur

[{
  "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..."
    }
  ],
  "metadata": {
    "reference_answer": {
      "compliant": "No",
      "explanation": "As an AI developed by Company, I do not have a traditional security team..."
    },
    "my_key": "sample-001"
  }
}]

Ausgangsstruktur

[{
  "id": "123",
  "aggregate_reward_score": 0.85,
  "metrics_list": [
    {
      "name": "accuracy",
      "value": 0.9,
      "type": "Reward"
    },
    {
      "name": "policy_compliance",
      "value": 0.8,
      "type": "Metric"
    }
  ]
}]

Beispiel für eine Lambda-Funktion

from typing import List
import json
from dataclasses import asdict, dataclass

@dataclass
class RewardOutput:
    """Reward service output."""
    id: str
    aggregate_reward_score: float

def lambda_handler(event, context):
    """Main lambda handler"""
    return lambda_grader(event)

def lambda_grader(samples: list[dict]) -> list[dict]:
    """Core grader function"""
    scores: List[RewardOutput] = []
    for sample in samples:
        idx = sample["id"]
        ground_truth = sample.get("metadata", {}).get("reference_answer")
        
        if "messages" not in sample:
            print(f"Messages is None/empty for id: {idx}")
            ro = RewardOutput(id=idx, aggregate_reward_score=0.0)
            scores.append(ro)
            continue
        
        if ground_truth is None:
            print(f"No answer found in ground truth for id: {idx}")
            ro = RewardOutput(id=idx, aggregate_reward_score=0.0)
            scores.append(ro)
            continue
        
        # Get model's response (last turn is assistant turn)
        last_message = sample["messages"][-1]
        assert last_message["role"] == "assistant", "Last message must be from assistant"
        model_text = last_message["content"]
        
        ground_truth_text = _extract_ground_truth_text(ground_truth)
        
        if model_text.lower() == ground_truth_text.lower():
            score = 1.0
        else:
            score = 0.0
        
        ro = RewardOutput(id=idx, aggregate_reward_score=score)
        scores.append(ro)
    
    return [asdict(score) for score in scores]

def _extract_ground_truth_text(ground_truth) -> str:
    """Turn the ground_truth field into a plain string."""
    if isinstance(ground_truth, str):
        return ground_truth
    
    if isinstance(ground_truth, dict):
        if "explanation" in ground_truth and isinstance(ground_truth["explanation"], str):
            return ground_truth["explanation"]
        if "answer" in ground_truth and isinstance(ground_truth["answer"], str):
            return ground_truth["answer"]
        return json.dumps(ground_truth, ensure_ascii=False)
    
    return str(ground_truth)

Konfiguration des Trainings

Verwenden Sie die Notizbuchvorlage SageMaker AI Training Job, um einen Schulungsjob zu starten. Weitere Informationen finden Sie unter Einen Schulungsjob erstellen.

Schulungscontainer

708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-fine-tune-repo:SM-TJ-RFT-latest

Anforderungen an die Instanz

Der Container unterstützt sowohl Full Rank- als auch LoRa-Schulungen:

Auswahl des Argumentationsmodus

Verfügbare Modi

Wann sollten die einzelnen Modi verwendet werden

Verwenden Sie high Argumentation für komplexe analytische Aufgaben, mathematische Problemlösungen, logische Ableitungen in mehreren Schritten und für Aufgaben, bei denen Denken einen Mehrwert bietet. step-by-step

Verwenden Sie none (weglassenreasoning_effort) oder low Argumentation für einfache sachliche Fragen, direkte Klassifizierungen, Geschwindigkeits- und Kostenoptimierung und einfache Beantwortung von Fragen.

Kompromisse bei Kosten und Leistung

Höhere Argumentationsmodi erhöhen die Trainingszeit und -kosten, erhöhen die Inferenzlatenz und die Kosten und erhöhen die Modellfähigkeit für komplexe Denkaufgaben.

Überwachung des Trainings

Die Trainingsprotokolle enthalten bei jedem Schritt umfassende Kennzahlen. Zu den wichtigsten Metrikkategorien gehören die folgenden:

Verwendung fein abgestimmter Modelle

Nach Abschluss des Trainings wird der endgültige Modellprüfpunkt am angegebenen Ausgabeort gespeichert. Der Checkpoint-Pfad ist in den Trainingsprotokollen und in der manifest.json Datei im Amazon S3-Ausgabespeicherort (definiert von output_s3_uri in Ihrem Notizbuch) verfügbar.

Einschränkungen und bewährte Methoden

Einschränkungen

Best Practices