Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Izsaukumi paralēli un secīgi

Nodarbība 3 no 20 Programmētājs
Šajā lapā
  1. Izsaukumi paralēli un secīgi
  2. Paralēlie izsaukumi
  3. Paralēlo izsaukumu atspējošana
  4. Secīgi izsaukumi, izmantojot ciklu
  5. Praktisks piemērs: apstrādes konveijers
  6. Hibrīda modelis: vispirms paralēli, tad secīgi
  7. Galvenās atziņas

Izsaukumi paralēli un secīgi

Modelis vienā atbildē var ģenerēt vairākus funkciju izsaukumus, to darot automātiski, tiklīdz tas identificē neatkarīgas vajadzības. Tas nav tikai kosmētisks uzlabojums: trīs divu sekunžu ilgi izsaukumi, kas veikti vienlaicīgi, kopā aizņem divas sekundes, bet virknēti secīgi tie prasīs sešas sekundes.

Šīs nodarbības galvenais fokuss nav tas, kā veikt paralēlizpildi – modeli to paveic pats –, bet gan kā atpazīt gadījumus, kad to nevajadzētu darīt. Divi izsaukumi ir neatkarīgi, ja izpildes secība neietekmē rezultātu. Tiklīdz viena operācija nolasīja datus, ko otra raksta, vai ja parametrs ir jāiegūst no iepriekšējā izsaukuma, paralēlisms kļūst par grūti reproducējamu kļūdu.

Paralēlie izsaukumi

Nekas nav jāaktivizē: tā ir noklusējuma uzvedība. Vaicājums par trim pilsētām ģenerēs trīs function_call vienumus vienā atbildē; tev tie jāizpilda. Ņem vērā, ka modelis spriež par funkciju nozīmi, balstoties uz taviem aprakstiem – apraksti virza lēmumu pieņemšanu, tāpat kā gandrīz visā šajā kursā.

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

Paralēlo izsaukumu izpilde klienta pusē

Trīs izsaukumu saņemšana vienlaikus ir bezjēdzīga, ja tavs kods tos izpilda vienu pēc otra: tu zaudē visu ieguvumu klienta pusē. asyncio.gather ir minimums; ražošanas videi pievieno divus piesardzības pasākumus – vienlaicīguma ierobežojumu, lai neatvērtu piecdesmit savienojumus vienlaicīgi ar servisu, kas atbalsta tikai desmit, un kļūdu apstrādi katram izsaukumam atsevišķi, lai izolēta kļūda neiznīcinātu pārējos rezultātus.

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)

Paralēlo izsaukumu atspējošana

parallel_tool_calls=False piespiež modeli ģenerēt tikai vienu izsaukumu vienā atbildē. Izmanto šo iestatījumu apzināti: tas upurē latentumu drošības labā. Rezervē to funkcijām, kas raksta datus, veic izmaiņas vai aktivizē kaut ko ārējā vidē.

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

Gadījumi, kad paralēlisms ir jāatspējo:

  • Operācijas, kas jāizpilda noteiktā secībā
  • Funkcijas ar blakusparādībām, kas traucē cita citai
  • Situācijas, kad viena izsaukuma rezultāts nosaka nākamo soli

Secīgi izsaukumi, izmantojot ciklu

Secīga izpilde netiek kontrolēta ar parametru: tā izriet no cikla. Tu izpildi izsaukumu, nosūti atpakaļ rezultātu, un modelis, balstoties uz tikko iegūto informāciju, lemj par nākamo soli. Tieši tas atšķir dinamisku ķēdi no stingra plāna – ja 2. solis atklāj, ka 3. solis nav nepieciešams, modelis to neizsauks.

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"

Praktisks piemērs: apstrādes konveijers

Tipisks gadījums, kur secīga izpilde ir obligāta, jo katrs solis patērē iepriekšējā solī iegūto:

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
)

Hibrīda modelis: vispirms paralēli, tad secīgi

Praksē lielākā daļa reālu darba plūsmu seko šim jauktajam modelim: datu vākšanas fāze, kur viss var notikt vienlaicīgi, kam seko apstrādes fāze, kas ievēro atkarības. Tev nav jākodē nekas īpašs – tas ir dabiskais cikla rezultāts, ja tavi apraksti skaidri norāda uz atkarībām.

# 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

Šis modelis šķiet dabisks: modelis automātiski veic paralēlizpildi, kad izsaukumi ir neatkarīgi, un pāriet uz secīgu ķēdi, tiklīdz parādās atkarība.

Galvenās atziņas

  • Modelis automātiski veic neatkarīgu izsaukumu paralēlizpildi
  • Izmanto asyncio.gather, lai klienta pusē izpildītu paralēlos izsaukumus
  • Atspējo ar parallel_tool_calls=False, ja secībai ir nozīme
  • Ievies ciklu daudzsoļu darba plūsmām
  • Funkciju apraksti norāda modelim uz atkarībām starp soļiem