Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Fine-tuning voor function calling

Les 9 van 16 Bijgewerkt op 2 november 2026 Gevorderd
Op deze pagina
  1. Waarom fine-tunen voor function calling
  2. Data-indeling voor function calling
  3. Veelvoorkomende use cases
  4. Script voor datavoorbereiding
  5. De fine-tuning-taak starten
  6. Best practices
  7. Belangrijkste punten

Update 2 november 2026 — Beschikbaarheid van fine-tuning. De self-service fine-tuning van OpenAI wordt gefaseerd afgebouwd: sinds 7 mei 2026 kunnen organisaties die er nog nooit gebruik van hebben gemaakt geen taken meer aanmaken; sinds 2 juli moet u binnen de laatste 60 dagen een fine-getuned model hebben gebruikt; en vanaf 6 januari 2027 kan geen enkele klant nieuwe taken starten. Reeds getrainde modellen blijven bruikbaar totdat hun basismodel wordt stopgezet. Deze cursus blijft nuttig om een bestaand model te begrijpen en benutten; voor nieuwe projecten geeft u prioriteit aan prompt engineering, RAG en evaluaties.

Waarom fine-tunen voor function calling

Met function calling kan het model zelf beslissen wanneer en hoe externe functies moeten worden aangeroepen. In deze context gaat fine-tuning niet over het aanpassen van de schrijfstijl: het versterkt een besluitvormingsmechanisme. Een model dat op uw eigen aanroepen is getraind, leert eerst de juiste functie te kiezen uit meerdere beschikbare opties. Als uw applicatie zowel het opzoeken van tijdslots als het maken van afspraken mogelijk maakt, mag de zin “Ik wil zien wat er donderdag vrij is” nooit een boeking activeren.

Vervolgens leert het model de juiste parameters uit het verzoek van de gebruiker halen; dat wil zeggen: natuurlijke formuleringen omzetten in waarden die conform het schema zijn: “morgen om 14.00 uur” wordt een genormaliseerde datum en tijd. Hetzelfde mechanisme leert minder opvallende, maar even cruciale reflexen aan. Weten wanneer u een functie NIET moet aanroepen, voorkomt de valkuil dat een model een tool activeert bij een simpele begroeting. En het logisch ketenen van meerdere functieaanroepen—beschikbaarheid lijstten, vervolgens het gekozen slot boeken—vereist dat het model tijdens de training complete sequenties heeft gezien, niet geïsoleerde aanroepen.

Data-indeling voor function calling

Trainingsvoorbeelden bevatten de functiedefinities (tools) en de bijbehorende aanroepen. Het bericht van de assistent bevat geen tekst meer, maar een tool_calls-array; het resultaat dat door uw systeem wordt teruggegeven, verschijnt in een bericht met de rol tool, gekoppeld aan de aanroep via tool_call_id; vervolgens spreekt de assistent opnieuw om de voor de gebruiker bestemde respons te formuleren. Het is deze volledige lus, niet alleen de aanroep, die het model moet leren reproduceren.

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

Veelvoorkomende use cases

De juiste functie selecteren

Train het model om op basis van de context te onderscheiden welke functie moet worden aangeroepen. In het onderstaande voorbeeld gaat het verzoek over het controleren van beschikbaarheid, niet over het maken van een reservering: het voorbeeld bekrachtigt dat een open vraag list_slots aanroept, en niets anders.

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

GEEN functie aanroepen

Reserveer een deel van uw dataset voor uitwisselingen waarbij het model geen enkele functie mag gebruiken. Een model dat uitsluitend op aanroepen is getraind, krijgt de gewoonte om bij elke beurt een aanroep te produceren, zelfs bij een begroeting of een algemene vraag—gedrag dat gebruikers irriteert en uw backend geld kost. Het onderstaande tegenvoorbeeld kost slechts een paar regels en elimineert een hele klasse van fouten.

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

Complexe parameters extraheren

Echte verzoeken zijn zelden gestructureerd. “Volgende maandagochtend” en “de cardioloog” moeten worden omgezet in een absolute datum, een tijdsperiode en een specialisme. Dit is precies waar het basismodel het vaakst struikelt, dus dit is waar fine-tuning het meest zichtbare rendement oplevert: vermenigvuldig dit type voorbeeld in plaats van gevallen die al schoon zijn.

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

Script voor datavoorbereiding

Het bouwen van het bestand blijft mechanisch: een assemblagefunctie, een tool-definitie die door alle voorbeelden wordt gedeeld, een lijst met cases, en vervolgens regel-voor-regel schrijven in JSONL-formaat. Let op het gebruik van json.dumps voor het veld arguments, dat een string moet zijn, geen object.

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

De fine-tuning-taak starten

De taak wordt precies hetzelfde aangemaakt als bij conversationele fine-tuning: het verrijkte formaat wordt herkend aan de inhoud van het bestand, zonder extra parameters.

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

Het resultaat hangt allereerst af van de diversiteit van uw dataset. Elke functie moet meerdere keren voorkomen, de formuleringen van gebruikers moeten variëren voor dezelfde intentie, en het is voordelig om dubbelzinnige gevallen op te nemen, vergezeld van de oplossing die u correct acht, zonder de normale conversaties te vergeten die geen functie aanroepen.

Vervolgens komt de realiteit van de parameters. De arguments moeten exact overeenkomen met het schema dat in tools is gedefinieerd, met plausibele waarden in plaats van placeholders zoals “xxx”—een model dat op nepwaarden is getraind, zal deze produceren. Test systematisch of elk veld arguments geldige JSON is: een ontbrekende haakje of aanhalingsteken is voldoende om het voorbeeld onbruikbaar te maken.

Tot slot is er de kwestie van de verhoudingen. Voor een dataset van 100 voorbeelden die 3 functies bestrijkt, geeft de onderstaande verdeling een gezonde balans tussen functionele dekking en terughoudendheid.

VoorbeeldtypeAantal
Per functie25-30
Geen functieaanroep10-15
Geketende aanroepen (multi-step)5-10

Belangrijkste punten

  • Het formaat bevat naast messages ook tools
  • Functieaanroepen gebruiken tool_calls in het bericht van de assistent
  • Neem voorbeelden op waarbij het model GEEN functie mag aanroepen
  • Varieer de formuleringen voor dezelfde intentie
  • Controleer of alle arguments geldige JSON zijn die conform het schema is