Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Sejħiet Paralleli u Sekwenzjali

Lezzjoni 3 / 20 Zviluppatur
F'din il-paġna
  1. Sejħiet Paralleli u Sekwenzjali
  2. Sejħiet Paralleli
  3. Iddiżattiva s-Sejħiet Paralleli
  4. Sejħiet Sekwenzjali b’Linja (Loop)
  5. Eżempju Prattiku: Pipeline ta’ Ipproċessar
  6. Mudell Ibridu: Paralleli Imbagħad Sekwenzjali
  7. Punti Ewlenin

Sejħiet Paralleli u Sekwenzjali

Il-mudell jista’ joħroġ sejħiet multipli ta’ funzjonijiet f’tweġiba waħda, u jagħmel dan awtomatikament kull meta jidentifika ħtiġijiet indipendenti. Dan mhux sempliċiment ottimizzazzjoni kożmetika: tliet sejħiet ta’ żewġ sekondi li jsiru flimkien jieħdu żewġ sekondi biss, iżda jekk isiru wieħed wara l-ieħor (sekwenza), jieħdu sitta.

Il-fokus reali ta’ din il-lezzjoni mhuwiex kif tparallelizza—il-mudell jittratta dan waħdu—iżda kif tirrikonoxxi l-każijiet fejn m’għandekx tagħmel hekk. Żewġ sejħiet huma indipendenti meta l-ordni ta’ eżekuzzjoni ma taffettwax ir-riżultat. Hekk kif operazzjoni waħda taqra dak li oħra tikteb, jew parametru jrid jiġi minn sejħa preċedenti, il-parallelizmu jsir bug diffiċli biex jiġi rriprodot.

Sejħiet Paralleli

M’hemm xejn li għandu jiġi attivat: dan huwa l-imġiba default. Mistoqsija dwar tliet bliet toħloq tliet oġġetti function_call fl-istess tweġiba; int tesegwixxihom. Innota li l-mudell jirraġuna dwar it-tifsira tal-funzjonijiet abbażi tad-deskrizzjonijiet tiegħek—id-deskrizzjonijiet imexxu d-deċiżjoni, bħal f’kważi kollox f’dan il-kors.

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

Eżekuzzjoni ta’ Sejħiet Paralleli fuq in-Naħa tal-Klijent

Li tirċievi tliet sejħiet fl-istess ħin ma jservix jekk il-kodiċi tiegħek jesegwixxihom wieħed wara l-ieħor: titlef il-gwadann kollu fuq in-naħa tal-klijent. asyncio.gather huwa l-minimu; żid żewġ prekawzjonijiet għall-produzzjoni—limitu ta’ konkorrenza, biex ma tiftaħx ħamsin konnessjoni simultanja ma’ servizz li jappoġġja għaxra biss, u ġestjoni tal-iżbaljiet għal kull sejħa, biex falliment iżolat ma jweġġax ir-riżultati l-oħra.

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)

Iddiżattiva s-Sejħiet Paralleli

parallel_tool_calls=False jfurza lill-mudell joħroġ sejħa waħda biss għal kull tweġiba. Uża din l-impostazzjoni b’mod deliberat: tqiegħed il-latency fis-sigurtà. Irriżervaha għal funzjonijiet li jiktbu, jimmodifikaw, jew jattivaw xi ħaġa esterna.

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

Każijiet ta’ użu għad-diżattivazzjoni tal-parallelizmu:

  • Operazzjonijiet li jridu jiġu eżegwiti f’ordni speċifika
  • Funzjonijiet b’effetti sekondarji li jinterferixxu ma’ xulxin
  • Meta r-riżultat ta’ sejħa waħda jikkundizzjona li jmiss

Sejħiet Sekwenzjali b’Linja (Loop)

L-eżekuzzjoni sekwenzzjali mhix ikkontrollata minn parametru: tiġi mil-linja (loop). Int tesegwixxi s-sejħa, tibgħat lura r-riżultat, u l-mudell jiddeċiedi l-pass li jmiss abbażi ta’ dak li għadu kemm tgħallem. Dan huwa preċiżament dak li jiddistingwi katina dinamika minn pjan riġidu—jekk il-pass 2 jiżvela li l-pass 3 mhuwiex meħtieġ, il-mudell ma jsejjaħx.

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"

Eżempju Prattiku: Pipeline ta’ Ipproċessar

Każ tipiku fejn l-eżekuzzjoni sekwenzzjali hija obbligatorja, għax kull pass jikkonsma dak li pproduċa l-preċedenti:

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
)

Mudell Ibridu: Paralleli Imbagħad Sekwenzjali

Fil-prattika, il-biċċa l-kbira tal-flussi ta’ xogħol fid-dinja reali jsegwu dan il-mudell imħallat: fażi ta’ ġbir fejn kollox jista’ jiġri simultanjament, segwita minn fażi ta’ pproċessar li tirrispetta d-dipendenzi. M’għandekx bżonn tikteb xejn speċjali għal dan—hija l-konsegwenza naturali tal-linja (loop), sakemm id-deskrizzjonijiet tiegħek jagħmlu d-dipendenzi ċari.

# 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

Dan il-mudell iħossu naturali: il-mudell awtomatikament jipparallelizza meta s-sejħiet ikunu indipendenti, imbagħad iħabbathom sekwenza meta tidher dipendenza.

Punti Ewlenin

  • Il-mudell awtomatikament jipparallelizza sejħiet indipendenti
  • Uża asyncio.gather biex tesegwixxi sejħiet paralleli fuq in-naħa tal-klijent
  • Iddiżattiva b’parallel_tool_calls=False meta l-ordni tkun importanti
  • Implimenta linja (loop) għal flussi ta’ xogħol b’diversi passi
  • Id-deskrizzjonijiet tal-funzjonijiet jiggwidaw lill-mudell dwar id-dipendenzi bejn il-passi