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.

Erstellung von Ressourcen für mehrstufiges Reinforcement-Learning

Promptes Datensatzformat

Ihr Trainingsdatensatz ist eine Sammlung von Eingabeaufforderungen, die SageMaker KI während des Trainings an Ihren Agenten sendet. Jede Aufforderung leitet einen Rollout ein: Ihr Agent verarbeitet sie, führt in einer oder mehreren Runden Aktionen durch und gibt eine Belohnung zurück. Die Qualität und Struktur Ihres Datensatzes wirken sich direkt darauf aus, was das Modell lernt.

Unterstützte Datei-Formate

Datensatz-Schema

Sofortige Erkennung von Spalten

Der RFT-Dienst erkennt die Eingabeaufforderungsspalte anhand der folgenden Regeln der Reihe nach:

Benennen Sie Ihre Eingabeaufforderungsspalte immerprompt, um Mehrdeutigkeiten zu vermeiden. Sie können zusätzliche Spalten für Ihre eigenen Nachverfolgungszwecke hinzufügen, aber nur die Eingabeaufforderungsspalte wird vom RFT-Dienst gelesen.

Wie werden Eingabeaufforderungen verwendet

Der RFT-Dienst liest die Eingabeaufforderungsspalte und übergibt den Zeichenkettenwert unverändert direkt an Ihren Agenten. Der Inhalt wird nicht analysiert, validiert oder transformiert. Welches Format verwendet wird, hängt ganz davon ab, was Ihr Agent erwartet. Ein einfacher Agent verwendet möglicherweise einfachen Text, während ein anspruchsvollerer Agent eine JSON-Zeichenfolge mit Konversationsverlauf, Toolkonfiguration und Prämienspezifikationen erwarten könnte.

Datenschutz

Da der RFT-Service Eingabeaufforderungen ungeprüft weiterleitet, sind Sie für den Schutz vertraulicher Inhalte verantwortlich. Erwägen Sie, Eingabeaufforderungsdaten vor dem Speichern zu kodieren oder zu verschlüsseln und die Dekodierung oder Entschlüsselung in Ihrem Agenten vorzunehmen.

Gängige Ansätze:

Beispiel 1: Einfacher & QA-Datensatz (Klartext)

Für einfache Trainingsaufgaben mit Klartext-Eingabeaufforderungen.

Anwendungsfall: Einfache Beantwortung von Fragen, anschließende einfache Anweisungen

Parkett (Python)

import pyarrow as pa
import pyarrow.parquet as pq

data = {
    "prompt": [
        "What is 2 + 2?",
        "Explain the concept of machine learning.",
        "Write a Python function to reverse a string.",
        "What is the capital of France?",
        "How does photosynthesis work?",
    ]
}

table = pa.table(data)
pq.write_table(table, "training_data.parquet")

JSON-Zeilen (.jsonl)

{"prompt": "What is 2 + 2?"}
{"prompt": "Explain the concept of machine learning."}
{"prompt": "Write a Python function to reverse a string."}

Beispiel 2: Search/Reasoning mit der Verwendung von Tools

Für Aufgaben, die während der Modellanalyse Zugriff auf externe Tools (z. B. Suchmaschinen) erfordern.

Anwendungsfall: Fragen und Fact-based Antworten mit Websuche, erweitertes Denken beim Abrufen

Struktur:

prompt (column) = JSON string (recommend encoded/encrypted) containing:
├── data_source: Dataset origin identifier
├── prompt: Conversation messages [system, user]
├── ability: Task category (e.g., "fact-reasoning")
├── env_class: "search"
├── reward_spec: Ground truth answer for evaluation
└── extra_info: Tool configuration and metadata

Beispiel für eine Zeile:

import pyarrow as pa
import pyarrow.parquet as pq
import json

task_data = {
    "data_source": "searchR1_nq",
    "prompt": [
        {
            "role": "system",
            "content": "You are a helpful and harmless assistant."
        },
        {
            "role": "user",
            "content": "Answer the given question. You must conduct reasoning inside <think> and </think> first every time you get new information. After reasoning, if you find you lack some knowledge, you can call a search engine by <search> query </search> and it will return the top searched results between <information> and </information>. You can search as many times as you want. If you find no further external knowledge needed, you can directly provide the answer inside <answer> and </answer>, without detailed illustrations. For example, <answer> Beijing </answer>. Question: total number of death row inmates in the us?"
        }
    ],
    "ability": "fact-reasoning",
    "env_class": "search",
    "reward_spec": {
        "ground_truth": {
            "target": [
                "2,718"
            ]
        },
        "style": "rule"
    },
    "extra_info": {
        "index": 0,
        "question": "total number of death row inmates in the us?",
        "split": "train",
        "need_tools_kwargs": true,
        "tools_kwargs": {
            "search": {
                "create_kwargs": {
                    "question": "total number of death row inmates in the us?",
                    "ground_truth": {
                        "target": [
                            "2,718"
                        ]
                    },
                    "data_source": "searchR1_nq"
                }
            }
        }
    }
}

# Recommend: encode or encrypt before storing
data = {"prompt": [json.dumps(task_data)]}
table = pa.table(data)
pq.write_table(table, "search_training_data.parquet")

Beispiel 3: SQL-Generierung (Multi-Turn mit komplexem Kontext)

Für Aufgaben zur Codegenerierung, die Datenbankschemas, mehrstufige Argumentation und Feedback zur SQL-Ausführung erfordern.

Anwendungsfall: Text-to-SQL Codegenerierung mit Überprüfung der Ausführung

Struktur:

prompt (column) = JSON string (recommend encoded/encrypted) containing:
├── input_seq: Human-readable task description
├── prompt: Conversation messages [system, user]
├── env_class: "text2sql"
├── reward_spec: Ground truth SQL and evaluation config
├── instance_id: Unique task identifier
├── schema: Database schema definition
├── question: Natural language question
└── extra_info: Additional metadata

Beispiel für eine Zeile:

import pyarrow as pa
import pyarrow.parquet as pq
import json

task_data = {
    "input_seq": "Task Overview:\nYou are a data science expert. Below, you are provided with a database schema\nand a natural language question. Your task is to understand the schema and\ngenerate a valid SQL query to answer the question.\n\nDatabase Engine: SQLite\n\nDatabase Schema:\nCREATE TABLE countries (\n    country_id INTEGER PRIMARY KEY,\n    english_name TEXT,\n    population INTEGER\n);\n\nCREATE TABLE country_metrics (\n    metric_id INTEGER PRIMARY KEY,\n    country_id INTEGER,\n    metric_type TEXT,\n    year INTEGER,\n    value REAL\n);\n\nQuestion: List all countries with their current population and average\npopulation over the last five years.",
    "prompt": [
        {
            "role": "system",
            "content": "Task Overview:\nYou are a data science expert. Your task is to understand the schema and generate\na valid SQL query to answer the question within limited turns.\n\nInstructions:\n- Make sure you only output the information asked in the question.\n- Think through the steps before generating the final SQL query.\n\nFormat:\n- Conduct thinking inside <think>...</think> blocks.\n- You can use SQL tool written within <sql>your sql</sql> to explore or verify.\n- SQL tool output will be shown inside <observation>...</observation>.\n- Provide the final SQL query inside <solution>...</solution>."
        },
        {
            "role": "user",
            "content": "Database Schema:\nCREATE TABLE countries (\n    country_id INTEGER PRIMARY KEY,\n    english_name TEXT,\n    population INTEGER\n);\n\nCREATE TABLE country_metrics (\n    metric_id INTEGER PRIMARY KEY,\n    country_id INTEGER,\n    metric_type TEXT,\n    year INTEGER,\n    value REAL\n);\n\nQuestion: List all countries with their current population and average\npopulation over the last five years."
        }
    ],
    "env_class": "text2sql",
    "instance_id": "sql_task_001",
    "reward_spec": {
        "ground_truth": "SELECT c.english_name, c.population, AVG(m.value) as avg_pop\nFROM countries c\nJOIN country_metrics m ON c.country_id = m.country_id\nWHERE m.metric_type = 'Population' AND m.year > strftime('%Y', 'now') - 5\nGROUP BY c.country_id;",
        "style": "rule"
    },
    "schema": "CREATE TABLE countries (...); CREATE TABLE country_metrics (...);",
    "question": "List all countries with their current population...",
    "extra_info": {
        "split": "train",
        "difficulty": "medium"
    }
}

# Recommend: encode or encrypt before storing
data = {"prompt": [json.dumps(task_data)]}
table = pa.table(data)
pq.write_table(table, "sql_training_data.parquet")

Bewährte Methoden

Größe des Datensatzes

Aus Gründen der Vielfalt wird eine Mindestanzahl von Beispielen von mindestens 10 x mehr als Ihrer Chargengröße empfohlentraining_batch_size.

Prompte Qualität

Datenschutz

Belohnen Sie das Design der Funktion

Das Design von Belohnungsfunktionen ist entscheidend für die Bereitstellung effektiver Lernsignale in komplexen, mehrstufigen Agentensystemen. Beachten Sie beim Entwerfen von Belohnungsfunktionen für Multi-Turn-RL die folgenden Richtlinien.

Belohnen Sie den Designprozess

In der Praxis verwendet eine Belohnungsfunktion den gesamten Nachrichtenverlauf einer Episode als Eingabe und gibt zwei Ausgaben zurück: eine skalare Belohnung (ein Gleitkommawert zur Messung der Trajektorienqualität, wobei höhere Werte für eine bessere Leistung stehen) und ein Metrikwörterbuch für die Protokollierung, Debugging und Überwachung.

Beispiel: Belohnungsfunktion für Suchagenten

Das folgende Beispiel zeigt eine Belohnungsfunktion für einen Agenten, der Fragen mithilfe der Suche beantwortet. Es zeigt die Bewertung der Ergebnisse, die Gestaltung des Formats und die Überprüfung der Richtigkeit der Antworten.

class TextAnswerReward:
    """Reward function to check text answer against gold answers.

    formula: format_coef * (correct_format - 1) + correct_answer
    """

    gold_answers: list[str]
    format_coef: float = 0.1

    async def __call__(self, history: list[Message]) -> tuple[float, dict[str, float]]:
        """Grade the completed episode by checking the final assistant message."""
        final_message = None
        for msg in reversed(history):
            if msg.get("role") == "assistant":
                final_message = msg
                break

        if final_message is None:
            return 0.0, {"format": 0.0, "correct": 0.0}

        content = get_text_content(final_message)

        correct_format = float(self._extract_answer(content) is not None)
        correct_answer = float(self._check_answer(content))

        reward = self.format_coef * (correct_format - 1) + correct_answer
        return reward, {"format": correct_format, "correct": correct_answer}

    def _extract_answer(self, text: str) -> str | None:
        if "Answer:" not in text:
            return None
        parts = text.split("Answer:")
        if len(parts) != 2:
            return None
        return parts[1].strip()

    def _check_answer(self, text: str) -> bool:
        model_answer = self._extract_answer(text)
        if model_answer is None or len(self.gold_answers) == 0:
            return False
        for gold in self.gold_answers:
            if normalize_answer(model_answer) == normalize_answer(gold):
                return True
        return False

Diese Belohnungsfunktion umfasst die folgenden wichtigen Gestaltungsmöglichkeiten: