Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Feintuning für Funktionsaufrufe

Lektion 9 von 16 Aktualisiert am 2. November 2026 Fortgeschritten
Auf dieser Seite
  1. Warum Feintuning für Funktionsaufrufe
  2. Datenformat für Funktionsaufrufe
  3. Häufige Anwendungsfälle
  4. Skript zur Datenvorbereitung
  5. Starten des Feintuning-Jobs
  6. Best Practices
  7. Wichtige Erkenntnisse

Update vom 2. November 2026 — Verfügbarkeit des Feintunings. Das selbstbediente Feintuning von OpenAI wird schrittweise eingestellt: Seit dem 7. Mai 2026 können Organisationen, die es noch nie genutzt haben, keine Jobs mehr erstellen; seit dem 2. Juli müssen Sie ein feingestelltes Modell innerhalb der letzten 60 Tage verwendet haben; und ab dem 6. Januar 2027 können keine Kunden neue Jobs starten. Bereits trainierte Modelle bleiben nutzbar, bis ihr Basismodell zurückgezogen wird. Dieser Kurs bleibt nützlich, um ein bestehendes Modell zu verstehen und zu nutzen; für neue Projekte sollten Sie Prompt Engineering, RAG und Evaluierungen priorisieren.

Warum Feintuning für Funktionsaufrufe

Funktionsaufrufe ermöglichen es dem Modell, zu entscheiden, wann und wie externe Funktionen aufgerufen werden sollen. In diesem Kontext geht es beim Feintuning nicht darum, den Schreibstil anzupassen: Es festigt einen Entscheidungsmechanismus. Ein Modell, das auf Ihren eigenen Aufrufen trainiert wurde, lernt zunächst, die richtige Funktion aus mehreren verfügbaren Optionen auszuwählen. Wenn Ihre Anwendung sowohl die Suche nach freien Zeitfenstern als auch die Erstellung von Terminen anbietet, darf der Satz „Ich würde gerne sehen, was am Donnerstag frei ist” niemals eine Buchung auslösen.

Anschließend lernt es, die richtigen Parameter aus der Benutzeranfrage zu extrahieren – das heißt, natürliche Formulierungen in Werte zu verwandeln, die dem Schema entsprechen: „morgen um 14 Uhr” wird zu einem normalisierten Datum und einer Uhrzeit. Der gleiche Mechanismus lehrt weniger auffällige, aber ebenso kritische Reflexe. Das Wissen, wann man eine Funktion NICHT aufrufen muss, vermeidet die Falle, dass ein Modell ein Tool bei einem einfachen Hallo auslöst. Und das logische Verkettung mehrerer Funktionsaufrufe – Verfügbarkeit auflisten, dann das gewählte Zeitfenster buchen – erfordert, dass das Modell während des Trainings vollständige Sequenzen gesehen hat, nicht isolierte Aufrufe.

Datenformat für Funktionsaufrufe

Trainingsbeispiele umfassen die Funktionsdefinitionen (Tools) und die entsprechenden Aufrufe. Die Nachricht des Assistenten enthält keinen Text mehr, sondern ein tool_calls-Array; das vom System zurückgegebene Ergebnis erscheint in einer Nachricht mit der Rolle tool, verknüpft mit dem Aufruf über die tool_call_id; der Assistent spricht dann erneut, um die für den Benutzer intendierte Antwort zu formulieren. Genau dieser gesamte Zyklus, nicht nur der Aufruf selbst, muss das Modell lernen, zu reproduzieren.

{
  "messages": [
    {
      "role": "system",
      "content": "You are an assistant that helps manage appointments."
    },
    {
      "role": "user",
      "content": "Book me a slot tomorrow at 2 PM with Dr. Martin."
    },
    {
      "role": "assistant",
      "tool_calls": [
        {
          "id": "call_001",
          "type": "function",
          "function": {
            "name": "create_appointment",
            "arguments": "{\"date\": \"2026-04-03\", \"time\": \"14:00\", \"practitioner\": \"Dr. Martin\"}"
          }
        }
      ]
    },
    {
      "role": "tool",
      "tool_call_id": "call_001",
      "content": "{\"status\": \"confirmed\", \"id\": \"appt_42\"}"
    },
    {
      "role": "assistant",
      "content": "Your appointment with Dr. Martin is confirmed for tomorrow at 2 PM. Reference: APPT-42."
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "create_appointment",
        "description": "Creates a new medical appointment",
        "parameters": {
          "type": "object",
          "properties": {
            "date": {
              "type": "string",
              "description": "Date in YYYY-MM-DD format"
            },
            "time": {
              "type": "string",
              "description": "Time in HH:MM format"
            },
            "practitioner": {
              "type": "string",
              "description": "Name of the practitioner"
            }
          },
          "required": ["date", "time", "practitioner"]
        }
      }
    },
    {
      "type": "function",
      "function": {
        "name": "list_slots",
        "description": "Lists available slots for a practitioner",
        "parameters": {
          "type": "object",
          "properties": {
            "practitioner": {"type": "string"},
            "date": {"type": "string"}
          },
          "required": ["practitioner"]
        }
      }
    }
  ]
}

Häufige Anwendungsfälle

Auswahl der richtigen Funktion

Trainieren Sie das Modell, um basierend auf dem Kontext zu unterscheiden, welche Funktion aufgerufen werden soll. Im folgenden Beispiel geht die Anfrage um die Prüfung der Verfügbarkeit, nicht um eine Reservierung: Das Beispiel unterstreicht, dass eine offene Frage list_slots aufruft und nichts anderes.

{
  "messages": [
    {"role": "user", "content": "What slots are free on Thursday with Dr. Martin?"},
    {
      "role": "assistant",
      "tool_calls": [
        {
          "id": "call_002",
          "type": "function",
          "function": {
            "name": "list_slots",
            "arguments": "{\"practitioner\": \"Dr. Martin\", \"date\": \"2026-04-04\"}"
          }
        }
      ]
    }
  ],
  "tools": ["... same tools as above ..."]
}

NICHT Aufruf einer Funktion

Reservieren Sie einen Teil Ihres Datensatzes für Austausch, bei denen das Modell keine Funktion verwenden muss. Ein Modell, das ausschließlich auf Aufrufen trainiert wurde, entwickelt die Angewohnheit, in jeder Runde einen aufzurufen, selbst bei einer Begrüßung oder einer allgemeinen Frage – ein Verhalten, das Benutzer ärgert und Ihre Backend-Ressourcen belastet. Das Gegenbeispiel unten benötigt nur wenige Zeilen und eliminiert eine ganze Klasse von Fehlern.

{
  "messages": [
    {"role": "user", "content": "Hello, how are you?"},
    {
      "role": "assistant",
      "content": "Hello! I'm doing well, thanks. How can I help you with your appointments today?"
    }
  ],
  "tools": ["... same tools ..."]
}

Extraktion komplexer Parameter

Echte Anfragen sind selten strukturiert. „Nächste Woche am Montagmorgen” und „der Kardiologe” müssen in ein absolutes Datum, einen Zeitbereich und eine Fachrichtung umgewandelt werden. Genau hier stolpert das Basismodell am häufigsten, daher liefert Feintuning den sichtbarsten Gewinn: Vervielfältigen Sie Beispiele dieses Typs statt Fälle, die bereits sauber sind.

{
  "messages": [
    {"role": "user", "content": "Cancel my appointment next Monday morning with the cardiologist"},
    {
      "role": "assistant",
      "tool_calls": [
        {
          "id": "call_003",
          "type": "function",
          "function": {
            "name": "cancel_appointment",
            "arguments": "{\"date\": \"2026-04-06\", \"period\": \"morning\", \"specialty\": \"cardiology\"}"
          }
        }
      ]
    }
  ],
  "tools": ["..."]
}

Skript zur Datenvorbereitung

Das Erstellen der Datei bleibt mechanisch: Eine Zusammenfassungs-Funktion, eine von allen Beispielen geteilte Tool-Definition, eine Liste von Fällen und dann das Zeilenweise Schreiben im JSONL-Format. Beachten Sie die Verwendung von json.dumps für das Feld arguments, das ein String und kein Objekt sein muss.

import json

def create_function_calling_example(
    messages: list[dict],
    tools: list[dict]
) -> dict:
    """Creates a training example for function calling."""
    return {
        "messages": messages,
        "tools": tools
    }

# Tool definitions
tools = [
    {
      "type": "function",
      "function": {
        "name": "search_product",
        "description": "Searches for a product in the catalog",
        "parameters": {
          "type": "object",
          "properties": {
            "query": {"type": "string", "description": "Search terms"},
            "category": {"type": "string", "enum": ["electronics", "clothing", "home"]},
            "max_price": {"type": "number", "description": "Maximum price in euros"}
          },
          "required": ["query"]
        }
      }
    }
]

# Training examples
examples = [
    create_function_calling_example(
        messages=[
            {"role": "user", "content": "I'm looking for headphones under 100 euros"},
            {
                "role": "assistant",
                "tool_calls": [{
                    "id": "call_1",
                    "type": "function",
                    "function": {
                        "name": "search_product",
                        "arguments": json.dumps({
                            "query": "headphones",
                            "category": "electronics",
                            "max_price": 100
                        })
                    }
                }]
            }
        ],
        tools=tools
    )
]

# Save
with open("function_calling_train.jsonl", "w", encoding="utf-8") as f:
    for ex in examples:
        f.write(json.dumps(ex, ensure_ascii=False) + "\n")

Starten des Feintuning-Jobs

Der Job wird genau wie beim konversationellen Feintuning erstellt: Das angereicherte Format wird aus dem Dateiinhalte erkannt, ohne zusätzliche Parameter.

from openai import OpenAI

client = OpenAI()

file = client.files.create(
    file=open("function_calling_train.jsonl", "rb"),
    purpose="fine-tune"
)

job = client.fine_tuning.jobs.create(
    training_file=file.id,
    model="gpt-5.6-luna",
    suffix="function-calling-v1"
)

Best Practices

Das Ergebnis hängt zunächst von der Vielfalt Ihres Datensatzes ab. Jede Funktion muss mehrfach erscheinen, die Formulierungen der Benutzer müssen für denselben Intent variieren, und Sie profitieren davon, mehrdeutige Fälle mit der von Ihnen als korrekt erachteten Lösung einzubeziehen, ohne normale Gespräche zu vergessen, die keine Funktion aufrufen.

Als Nächstes kommt die Realismus der Parameter. Die arguments müssen dem in tools definierten Schema exakt entsprechen, mit plausiblem Werten statt Platzhaltern wie „xxx” – ein Modell, das auf falsche Werte trainiert wurde, wird diese produzieren. Testen Sie systematisch, dass jedes arguments-Feld gültiges JSON ist: Ein fehlender geschweiften Klammer oder Anführungszeichen reicht aus, um das Beispiel unbrauchbar zu machen.

Schließlich stellt sich die Frage der Proportionen. Für einen Datensatz mit 100 Beispielen, der 3 Funktionen abdeckt, gibt die folgende Verteilung ein gesundes Gleichgewicht zwischen funktionaler Abdeckung und Zurückhaltung.

BeispieltypMenge
Pro Funktion25-30
Kein Funktionsaufruf10-15
Verkettete Aufrufe (mehrstufig)5-10

Wichtige Erkenntnisse

  • Das Format enthält tools zusätzlich zu messages
  • Funktionsaufrufe verwenden tool_calls in der Nachricht des Assistenten
  • Beziehen Sie Beispiele mit ein, bei denen das Modell eine Funktion NICHT aufrufen muss
  • Variieren Sie Formulierungen für denselben Intent
  • Stellen Sie sicher, dass alle arguments gültiges JSON sind, das dem Schema entspricht