Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Paralleelsed ja järjestikused väljakutsed

Õppetund 3 / 20 Arendajatele
Sellel lehel
  1. Paralleelsed ja järjestikused väljakutsed
  2. Paralleelsed väljakutsed
  3. Paralleelsete väljakutsete keelamine
  4. Järjestikused väljakutsed tsükliga
  5. Läbitöötatud näide: töötlemistorustik
  6. Hübriidmuster: paralleelne, seejärel järjestikune
  7. Peamised punktid

Paralleelsed ja järjestikused väljakutsed

Mudel võib ühes vastuses teha mitu funktsioonikutset, tehes seda automaatselt iga kord, kui ta tuvastab sõltumatuid vajadusi. See pole pelgalt kosmeetiline optimeerimine: kolm kahe sekundiga kestvat väljakutset, mis käivitatakse koos, võtavad kokku kaks sekundit, kuid järjestikku aheldatuna kuus sekundit.

Selle tunni tegelik fookus ei ole selles, kuidas paralleelsust rakendada – mudel haldab seda ise –, vaid selles, kuidas tuvastada juhtumeid, kus seda teha ei tohi. Kaks väljakutset on sõltumatud, kui täitmise järjekord tulemust ei mõjuta. Niipea kui üks operatsioon loeb seda, mida teine kirjutab, või kui parameeter peab tulema eelmisest väljakutsest, muutub paralleelsus raskesti reprodutseeritavaks veaks.

Paralleelsed väljakutsed

Midagi ei vaja lubamist: see on vaikimisi käitumine. Päring kolme linna kohta toodab samas vastuses kolm function_call elementi; sina täidad need. Pane tähele, et mudel arutleb funktsioonide tähenduse üle sinu kirjelduste põhjal – kirjeldused juhivad otsust, nagu peaaegu kõiges selles kursuses.

from openai import OpenAI
import json
import asyncio

client = OpenAI()

tools = [
    {
        "type": "function",
        "name": "get_meteo",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "ville": {"type": "string"}
            },
            "required": ["ville"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "get_taux_change",
        "description": "Get exchange rate between two currencies",
        "parameters": {
            "type": "object",
            "properties": {
                "source": {"type": "string"},
                "cible": {"type": "string"}
            },
            "required": ["source", "cible"],
            "additionalProperties": False
        },
        "strict": True
    }
]

response = client.responses.create(
    model="gpt-5.6-terra",
    input="What's the weather in Paris and Berlin, "
          "and what is the EUR/USD exchange rate?",
    tools=tools
)

# The model emits 3 calls in parallel
appels = [item for item in response.output if item.type == "function_call"]
print(f"Nombre d'appels : {len(appels)}")
# => Nombre d'appels : 3

Paralleelsete väljakutsete täitmine kliendi poolel

Kolme väljakutse korraga vastuvõtmine on kasutu, kui sinu kood täidab need üksteise järel: kaotad kogu võidu kliendi poolel. asyncio.gather on miinimum; lisa tootmiskeskkonnaks kaks ettevaatusabinõu – samaaegsuse piirang, et mitte avada viiskümmend samaaegset ühendust teenusega, mis toetab vaid kümmet, ja iga väljakutse veahaldus, et üksik tõrge ei tooks kaasa teiste tulemuste nurjumist.

async def executer_fonction(name: str, arguments: str) -> dict:
    args = json.loads(arguments)
    if name == "get_meteo":
        return await api_meteo(args["ville"])
    elif name == "get_taux_change":
        return await api_change(args["source"], args["cible"])

async def traiter_appels_paralleles(appels):
    taches = [
        executer_fonction(appel.name, appel.arguments)
        for appel in appels
    ]
    resultats = await asyncio.gather(*taches)

    return [
        {
            "type": "function_call_output",
            "call_id": appel.call_id,
            "output": json.dumps(resultat)
        }
        for appel, resultat in zip(appels, resultats)
    ]

# Execute
resultats = asyncio.run(traiter_appels_paralleles(appels))

# Send back to the model
response_finale = client.responses.create(
    model="gpt-5.6-terra",
    input=response.output + resultats,
    tools=tools
)
print(response_finale.output_text)

Paralleelsete väljakutsete keelamine

parallel_tool_calls=False sunnib mudelit väljastama ainult ühe väljakutse ühes vastuses. Kasuta seda sätet teadlikult: see vahetab latentsuse ohutuse vastu. Reserveeri see funktsioonidele, mis kirjutavad, muudavad või käivitavad midagi välist.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Process these three orders",
    tools=tools,
    parallel_tool_calls=False  # One call per response
)

Juhtumid paralleelsuse keelamiseks:

  • Toimingud, mis peavad toimuma kindlas järjekorras
  • Funktsioonid kõrvalmõjudega, mis segavad üksteist
  • Kui ühe väljakutse tulemus määrab järgmise tingimused

Järjestikused väljakutsed tsükliga

Järjestikust täitmist ei juhi parameeter: see tuleneb tsüklist. Sa täidad väljakutse, saadad tulemuse tagasi ja mudel otsustab järgmise sammu selle põhjal, mida ta just õppis. See ongi see, mis eristab dünaamilist ahelat jäigast plaanist – kui 2. samm näitab, et 3. samm on tarbetu, ei kutsu mudel seda.

def boucle_function_calling(prompt: str, tools: list, max_tours: int = 10):
    """Complete loop for sequential function calling."""
    messages_input = prompt
    tour = 0

    while tour < max_tours:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=messages_input,
            tools=tools,
            parallel_tool_calls=False
        )

        # Check for function calls
        appels = [i for i in response.output if i.type == "function_call"]

        if not appels:
            # Model is done, responding with text
            return response.output_text

        # Execute each call
        resultats = []
        for appel in appels:
            resultat = executer_fonction_sync(appel.name, appel.arguments)
            resultats.append({
                "type": "function_call_output",
                "call_id": appel.call_id,
                "output": json.dumps(resultat)
            })

        # Prepare next turn
        messages_input = response.output + resultats
        tour += 1

    return "Turn limit reached"

Läbitöötatud näide: töötlemistorustik

Tüüpiline juhtum, kus järjestikune täitmine on kohustuslik, sest iga samm tarbib eelmise toodangut:

tools_pipeline = [
    {
        "type": "function",
        "name": "valider_commande",
        "description": "Verify order validity (stock, price, customer)",
        "parameters": {
            "type": "object",
            "properties": {
                "commande_id": {"type": "string"}
            },
            "required": ["commande_id"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "calculer_livraison",
        "description": "Calculate shipping fees and delays. "
                       "Requires a validated order.",
        "parameters": {
            "type": "object",
            "properties": {
                "commande_id": {"type": "string"},
                "mode": {"type": "string", "enum": ["standard", "express"]}
            },
            "required": ["commande_id", "mode"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "confirmer_commande",
        "description": "Confirm the order and trigger payment. "
                       "Requires prior validation and shipping calculation.",
        "parameters": {
            "type": "object",
            "properties": {
                "commande_id": {"type": "string"},
                "livraison_id": {"type": "string"}
            },
            "required": ["commande_id", "livraison_id"],
            "additionalProperties": False
        },
        "strict": True
    }
]

# The model will naturally call in this order:
# 1. valider_commande
# 2. calculer_livraison (using step 1 result)
# 3. confirmer_commande (using results from steps 1 and 2)
resultat = boucle_function_calling(
    "Process order CMD-42567 with express shipping",
    tools_pipeline
)

Hübriidmuster: paralleelne, seejärel järjestikune

Praktikas järgib enamik reaalseid töövooge seda segamustrit: kogumisfaas, kus kõik saab käivituda samaaegselt, millele jäneb töötlemisfaas, mis austab sõltuvusi. Sa ei pea selleks midagi erilist kodeerima – see on tsükli loomulik tagajärg, eeldusel et sinu kirjeldused teevad sõltuvused selgeks.

# Turn 1: Parallel data collection
# The model calls get_client AND get_stock in parallel

# Turn 2: Sequential decision based on results
# The model calls valider_commande with collected info

# Turn 3: Final action
# The model calls confirmer_commande

See muster tundub loomulik: mudel paralleelistab automaatselt, kui väljakutsed on sõltumatud, ja aheldab seejärel järjestikku, kui ilmneb sõltuvus.

Peamised punktid

  • Mudel paralleelistab automaatselt sõltumatud väljakutsed
  • Kasuta asyncio.gather paralleelsete väljakutsete täitmiseks kliendi poolel
  • Keela kasutades parallel_tool_calls=False, kui järjekord on oluline
  • Rakenda tsükkel mitmeastmeliste töövoogude jaoks
  • Funktsioonide kirjeldused juhivad mudelit sammudevaheliste sõltuvuste osas