Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Fine-tuning för funktionsanrop

Lektion 9 av 16 Uppdaterad 2 november 2026 Avancerad
På denna sida
  1. Varför fine-tuna för funktionsanrop
  2. Dataformat för funktionsanrop
  3. Vanliga användningsområden
  4. Skript för dataförberedelse
  5. Starta fine-tuning-jobbet
  6. Bästa praxis
  7. Viktiga punkter

Uppdatering 2 november 2026 — Tillgänglighet för fine-tuning. OpenAIs självbetjäningstjänst för fine-tuning avvecklas: sedan den 7 maj 2026 kan organisationer som aldrig har använt tjänsten inte längre skapa jobb; sedan den 2 juli måste du ha använt en finjusterad modell inom de senaste 60 dagarna; och från och med 6 januari 2027 kommer ingen kund att kunna starta nya jobb. Redan tränade modeller förblir användbara tills deras basmodell tas ur bruk. Denna kurs är fortfarande användbar för att förstå och utnyttja en befintlig modell; för nya projekt bör du prioritera prompt engineering, RAG och utvärderingar.

Varför fine-tuna för funktionsanrop

Funktionsanrop låter modellen besluta när och hur externa funktioner ska anropas. I detta sammanhang handlar fine-tuning inte om att justera skrivstil: det härdar en beslutsmechanism. En modell som tränats på dina egna anrop lär sig först att välja rätt funktion bland flera tillgängliga alternativ. Om din app exponerar både sökning av lediga tider och bokning av appointment, får meningen “Jag vill se vad som är ledigt på torsdag” aldrig utlösa en bokning.

Därefter lär den sig att extrahera rätt parametrar från användarens begäran – det vill säga att omvandla naturligt språk till värden som följer schemat: “imorgon klockan 14.00” blir ett normaliserat datum och en tid. Samma mekanism lär ut mindre synliga men lika kritiska reflexer. Att veta när man INTE ska anropa en funktion undviker fällan att modellen utlöser ett verktyg vid ett enkelt hej. Och att kedja flera funktionsanrop logiskt – lista tillgänglighet, sedan boka den valda tiden – kräver att modellen har sett kompletta sekvenser under träningen, inte isolerade anrop.

Dataformat för funktionsanrop

Tränings exempel inkluderar funktionsdefinitionerna (verktyg) och de motsvarande anropen. Assistents meddelande innehåller inte längre text utan en tool_calls-array; resultatet som returneras av ditt system visas i ett meddelande med rollen tool, länkat till anropet via tool_call_id; därefter svarar assistenten igen för att formulera svaret avsett för användaren. Det är denna hela loop, inte bara anropet, som modellen måste lära sig att reproducera.

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

Vanliga användningsområden

Välja rätt funktion

Träna modellen att skilja på vilken funktion som ska anropas baserat på kontexten. I exemplet nedan gäller begäran att kontrollera tillgänglighet, inte att göra en bokning: exemplet förstärker att en öppen fråga anropar list_slots, och inget annat.

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

INTE anropa en funktion

Avsätt en del av din datamängd för utbyten där modellen inte får använda någon funktion. En modell som endast tränats på anrop får för vana att producera ett vid varje tillfälle, även vid en hälsning eller en generell fråga – ett beteende som irriterar användare och kostar ditt backend. Motexemplet nedan tar bara några rader och eliminerar en hel klass av fel.

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

Extrahera komplexa parametrar

Verkliga begäranden är sällan strukturerade. “Nästa måndag morgon” och “kardiologen” måste bli ett absolut datum, en tidsperiod och en specialitet. Det är precis här basmodellen snubblar oftast, så det är här fine-tuning ger mest synlig vinst: multiplicera denna typ av exempel snarare än fall som redan är rena.

{
  "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 för dataförberedelse

Att bygga filen förblir mekaniskt: en sammansättningsfunktion, en verktygsdefinition som delas av alla exempel, en lista över fall, och sedan rad-för-rad-skrivning i JSONL-format. Notera användningen av json.dumps för fältet arguments, som måste vara en sträng, inte ett objekt.

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

Starta fine-tuning-jobbet

Jobbet skapas exakt som för konversationsbaserad fine-tuning: det berikade formatet känns igen från filinnehållet, utan ytterligare parametrar.

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

Bästa praxis

Resultatet beror först och främst på mångfalden i din datamängd. Varje funktion måste förekomma flera gånger, användarformuleringar måste variera för samma avsikt, och du har fördel av att inkludera tvetydiga fall åtföljda av den lösning du anser korrekt, utan att glömma normala konversationer som inte anropar någon funktion.

Därefter kommer parameterrealism. arguments måste matcha exakt schemat som definierats i tools, med trovärdiga värden snarare än platshållare som “xxx” – en modell som tränats på falska värden kommer att producera dem. Testa systematiskt att varje arguments-fält är giltig JSON: en saknad klammerparentes eller citationstecken räcker för att göra exemplet oanvändbart.

Slutligen finns frågan om proportioner. För en datamängd på 100 exempel som täcker 3 funktioner ger fördelningen nedan en hälsosam balans mellan funktionell täckning och återhållsamhet.

ExempeltypAntal
Per funktion25–30
Inget funktionsanrop10–15
Kedjade anrop (flerstegs)5–10

Viktiga punkter

  • Formatet inkluderar tools utöver messages
  • Funktionsanrop använder tool_calls i assistentmeddelandet
  • Inkludera exempel där modellen INTE får anropa en funktion
  • Variera formuleringar för samma avsikt -Verifiera att alla arguments är giltig JSON som följer schemat