Przejdź do głównej treści
Polski— Wybierz język
Menu

Dostrajanie modelu do wywoływania funkcji

Lekcja 9 z 16 Zaktualizowano 2 listopada 2026 Zaawansowany
Na tej stronie
  1. Dlaczego dostrajać model do wywoływania funkcji
  2. Format danych do wywoływania funkcji
  3. Typowe przypadki użycia
  4. Skrypt przygotowania danych
  5. Uruchamianie zadania dostrajania
  6. Najlepsze praktyki
  7. Kluczowe wnioski

Aktualizacja z 2 listopada 2026 r. — Dostępność dostrajania. Usługa samodzielnego dostrajania modeli OpenAI jest wycofywana: od 7 maja 2026 r. organizacje, które nigdy z niej nie korzystały, nie mogą już tworzyć zadań; od 2 lipca konieczne jest użycie dostrajonego modelu w ciągu ostatnich 60 dni; a począwszy od 6 stycznia 2027 r., żaden klient nie będzie mógł uruchomić nowych zadań. Już wytrenowane modele pozostają użyteczne do momentu wycofania ich modelu bazowego. Ten kurs nadal przydaje się do zrozumienia i wykorzystania istniejącego modelu; w przypadku nowych projektów priorytetowo potraktuj inżynierię promptów, architekturę RAG oraz ewaluację.

Dlaczego dostrajać model do wywoływania funkcji

Wywoływanie funkcji pozwala modelowi decydować, kiedy i jak uruchamiać funkcje zewnętrzne. W tym kontekście dostrajanie nie polega na korygowaniu stylu pisania: jego celem jest utwardzenie mechanizmu podejmowania decyzji. Model szkolony na Twoich własnych wywołaniach najpierw uczy się wybierać właściwą funkcję spośród kilku dostępnych opcji. Jeśli Twoja aplikacja udostępnia zarówno wyszukiwanie wolnych terminów, jak i tworzenie wizyt, fraza „Chciałbym zobaczyć, co jest wolne w czwartek“ nigdy nie może uruchomić rezerwacji.

Następnie model uczy się wydobywać odpowiednie parametry z żądania użytkownika – czyli przekształcać naturalne sformułowania w wartości zgodne ze schematem: „jutro o 14:00“ staje się znormalizowaną datą i godziną. Ten sam mechanizm uczy mniej efektownych, ale równie kluczowych odruchów. Wiedza o tym, kiedy NIE wywoływać funkcji, pozwala uniknąć pułapki, w której model uruchamia narzędzie nawet na zwykłe „cześć“. A logiczne łączenie wielu wywołań funkcji – najpierw lista dostępności, potem rezerwacja wybranego terminu – wymaga, aby model widział podczas szkolenia kompletne sekwencje, a nie izolowane wywołania.

Format danych do wywoływania funkcji

Przykłady szkoleniowe zawierają definicje funkcji (narzędzia) oraz odpowiadające im wywołania. Wiadomość asystenta nie zawiera już tekstu, lecz tablicę tool_calls; wynik zwrócony przez Twój system pojawia się w wiadomości z rolą tool, powiązanej z wywołaniem przez tool_call_id; następnie asystent ponownie zabiera głos, aby sformułować odpowiedź przeznaczoną dla użytkownika. To właśnie całą tę pętlę, a nie samo wywołanie, model musi nauczyć się odtwarzać.

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

Typowe przypadki użycia

Wybór właściwej funkcji

Wytrenuj model, aby rozróżniał, którą funkcję wywołać w zależności od kontekstu. W poniższym przykładzie żądanie dotyczy sprawdzenia dostępności, a nie dokonania rezerwacji: przykład utwierdza model w przekonaniu, że pytanie otwarte wymaga wywołania list_slots i niczego więcej.

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

NIEWYWOŁYWANIE funkcji

Zarezerwuj część swojego zbioru danych na wymiany, w których model nie musi używać żadnej funkcji. Model szkolony wyłącznie na wywołaniach wchodzi w nawyk generowania ich przy każdej okazji, nawet przy powitaniu czy ogólnym pytaniu – zachowanie to irytuje użytkowników i obciąża Twój backend. Poniższy kontrprzykład zajmuje zaledwie kilka linii, a eliminuje całą klasę błędów.

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

Wydobywanie złożonych parametrów

Prawdziwe żądania rzadko mają uporządkowaną strukturę. „W przyszły poniedziałek rano“ i „kardiolog“ muszą stać się konkretną datą, przedziałem czasowym i specjalizacją. To właśnie w takich sytuacjach model bazowy najczęściej się myli, dlatego tutaj dostrajanie przynosi najbardziej widoczne korzyści: mnoż tego typu przykłady, zamiast skupiać się na przypadkach, które już są poprawne.

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

Skrypt przygotowania danych

Budowa pliku pozostaje mechaniczna: funkcja assemblingowa, definicja narzędzi wspólna dla wszystkich przykładów, lista przypadków, a następnie zapis linia po linii w formacie JSONL. Zwróć uwagę na użycie json.dumps dla pola arguments, które musi być ciągiem znaków, a nie obiektem.

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

Uruchamianie zadania dostrajania

Zadanie tworzy się dokładnie tak samo jak w przypadku dostrajania konwersacyjnego: wzbogacony format jest rozpoznawany na podstawie zawartości pliku, bez konieczności podawania dodatkowych parametrów.

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

Najlepsze praktyki

Wynik zależy przede wszystkim od różnorodności Twojego zbioru danych. Każda funkcja musi pojawić się wielokrotnie, sformułowania użytkowników muszą się różnić przy tej samej intencji, a warto uwzględnić przypadki niejednoznaczne wraz z rozwiązaniem, które uznajesz za poprawne, nie zapominając o zwykłych rozmowach, które nie wymagają wywołania żadnej funkcji.

Kolejnym aspektem jest realizm parametrów. Pola arguments muszą dokładnie odpowiadać schematowi zdefiniowanemu w tools, zawierając wiarygodne wartości, a nie symbole zastępcze typu „xxx“ – model szkolony na fałszywych danych będzie je generował. Systematycznie sprawdzaj, czy każde pole arguments zawiera poprawny kod JSON: brakujący nawias lub cudzysłów wystarczy, aby przykład stał się bezużyteczny.

Na koniec kwestia proporcji. Dla zbioru danych liczącego 100 przykładów obejmujących 3 funkcje, poniższy rozkład zapewnia zdrową równowagę między pokryciem funkcjonalnym a powściągliwością.

Typ przykładuIlość
Na funkcję25–30
Bez wywołania funkcji10–15
Wywołania łańcuchowe (wieloetapowe)5–10

Kluczowe wnioski

  • Format obejmuje tools oprócz messages
  • Wywołania funkcji używają tool_calls w wiadomości asystenta
  • Uwzględnij przykłady, w których model NIE powinien wywoływać funkcji
  • Urozmaicaj sformułowania dla tej samej intencji
  • Sprawdź, czy wszystkie pola arguments są poprawnym kodem JSON zgodnym ze schematem