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

Paralleliżmu u Konkurrenza

Lezzjoni 8 / 20 Aġġornat 28 ta’ Lulju 2026 Avvanzat
F'din il-paġna
  1. Stennija Flimkien Mhix Kalkolu Flimkien
  2. Tnedija ta’ Sejħiet Konkurrenti
  3. Il-Mudell Map-Reduce Applikat għat-Test
  4. Meta l-Multiproċessar Isir Rilevanti Mill-Ġdid
  5. Verifika tal-Produzzjoni Reali
  6. Punti Ewlenin

Stennija Flimkien Mhix Kalkolu Flimkien

Sejħa lill-API ta’ OpenAI hija operazzjoni marbuta mal-I/O: il-programm tiegħek mhux qed jgħaffeġ in-numri, qed jistenna risposta fin-netwerk. Din in-natura tiddefinixxi l-għodda t-tajba. Il-paralleliżmu, fis-sens tal-multiproċessar, jiddistribwixxi l-kalkolu fuq diversi cores; jiswiproċess sħiħ għal kull unità ta’ xogħol, u t-tħaddim ta’ mitt proċess li kollha qed jistennew fin-netwerk huwa ħela pura. Il-konkurrenza, kif ipprovduta minn asyncio, tippermetti lil proċess wieħed jimmaniġġja mijiet ta’ stennijiet simultanji b’kost negliġibbli. Dan huwa dak li jimmassimizza l-produzzjoni tas-sejħiet tiegħek.

Id-distinzjoni hija aktar minn sempliċiment akkademika: tim li jparallelizza s-sejħiet tal-LLM tiegħu b’pool ta’ proċessi se jikkonsma diversi gigabytes ta’ memorja għal ebda gwadann meta mqabbel ma’ ftit linji ta’ asyncio.

Tnedija ta’ Sejħiet Konkurrenti

L-SDK jesponi klijent asinkronu, AsyncOpenAI, li s-sejħiet tiegħu jistennew b’await. Il-ġbir ta’ diversi coroutines f’asyncio.gather jħallihom javvanzaw kollha fl-istess ħin, bit-tul totali tal-ħin li jersaq lejn dak tal-aktar sejħa bil-mod minflok is-somma tagħhom.

import asyncio
import openai

client = openai.AsyncOpenAI()

async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
    """Sejħa waħda asinkrona tal-API."""
    response = await client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

async def concurrent_calls(prompts: list[str]) -> list[str]:
    """Tniedi s-sejħiet kollha b'mod konkurrenti."""
    tasks = [single_call(prompt) for prompt in prompts]
    results = await asyncio.gather(*tasks, return_exceptions=True)

    for i, result in enumerate(results):
        if isinstance(result, Exception):
            print(f"Żball fuq il-prompt {i}: {result}")

    return [r for r in results if not isinstance(r, Exception)]

Il-flag return_exceptions=True hija dak li jiddistingwi prototip minn ipproċessar ta’ livell ta’ produzzjoni. Mingħajrha, l-ewwel eċċezzjoni tinterrrompi l-gather u titlef id-disgħa u disgħin riżultat diġà miksuba. Magħha, l-iżbalji jsiru valuri li tista’ tispezzjona, tirreġistra u tipprova mill-ġdid bir-ritmu tiegħek.

Madankollu, din il-verżjoni mhux maħduma għandha difett immedjat: it-tnedija ta’ elf sejħa f’daqqa waħda se taqbeż il-limiti tar-rata tiegħek fi ftit sekondi. Semaphora ssolvi dan billi tippermetti biss numru fiss ta’ sejħiet simultanji, filwaqt li l-bqija jistennew b’paċenzja d-dawra tagħhom. Għoxrin huwa punt tat-tluq raġonevoli, li għandu jiġi aġġustat abbażi tal-kwoti attwali tal-organizzazzjoni tiegħek.

async def calls_with_limit(
    prompts: list[str],
    max_concurrency: int = 20,
) -> list[str]:
    """Jillimita n-numru ta' sejħiet simultanji."""
    semaphore = asyncio.Semaphore(max_concurrency)

    async def limited_call(prompt: str) -> str:
        async with semaphore:
            return await single_call(prompt)

    tasks = [limited_call(prompt) for prompt in prompts]
    return await asyncio.gather(*tasks, return_exceptions=True)

Il-Mudell Map-Reduce Applikat għat-Test

Dokument ta’ mitejn paġna ma jistax jiġi ssuġġerat f’sejħa waħda, u li taqsmu b’mod sekwenzjali jieħu minuti. Il-mudell map-reduce japplika naturalment hawnhekk: aqsam f’biċċiet, agħmel sommarju ta’ kull biċċa b’mod konkurrenti, imbagħad itlob lill-mudell għal sinteżi tas-sommarji. Il-fażi tal-map tibbenefika kompletament mill-konkurrenza, filwaqt li l-fażi tar-reduce hija sejħa waħda fuq test li sar qasir.

async def map_reduce_summary(
    document: str,
    chunk_size: int = 3000,
) -> str:
    """Jagħmel sommarju ta' dokument twil permezz ta' map-reduce parallelu."""

    # Fażi MAP: aqsam u agħmel sommarju b'mod parallel
    chunks = [
        document[i:i + chunk_size]
        for i in range(0, len(document), chunk_size)
    ]

    map_prompts = [
        f"Agħmel sommarju ta' dan il-passaġġ f'3 punti ewlenin:\n\n{chunk}"
        for chunk in chunks
    ]

    partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)

    # Fażi REDUCE: għaqqad is-sommarji
    summary_text = "\n\n---\n\n".join(
        r for r in partial_summaries if isinstance(r, str)
    )

    final_summary = await single_call(
        f"Sintetizza dawn is-sommarji parzjali f'sommarju koerenti "
        f"ta' 5 punti ewlenin:\n\n{summary_text}"
    )

    return final_summary

Il-filtrar if isinstance(r, str) huwa daqshekk deċiżjoni tal-prodott kemm hija prekawzjoni teknika: ifisser li s-sinteżi finali se tiġi prodotta anke jekk tliet biċċiet ifallu, b’mod silenzjuż. Skont il-kuntest, dan huwa eżattament dak li trid, jew huwa inaċċettabbli. Iddeċiedi b’mod espliċitu, u rreġistra n-numru ta’ biċċiet mitlufa fi kwalunkwe każ.

Meta l-Multiproċessar Isir Rilevanti Mill-Ġdid

Jibqgħu sitwazzjonijiet rari fejn il-kalkolu jerġa’ jieħu l-kontroll: post-ipproċessar tqil fuq ir-risposti, estrazzjoni ta’ entitajiet, skoring, parsing strutturat. Dan ix-xogħol huwa marbut mal-CPU u ma jikseb xejn minn asyncio. Il-kombinazzjoni eleganti hija li tgħaqqad iż-żewġ reġimi f’pipeline waħda: sejħiet tan-netwerk fil-konkurrenza, imbagħad kalkolu distribwit fuq pool ta’ proċessi permezz ta’ run_in_executor.

import asyncio
from concurrent.futures import ProcessPoolExecutor

def heavy_post_processing(text: str) -> dict:
    """Ipproċessar marbut mal-CPU fuq ir-riżultat (NLP, parsing, eċċ.)."""
    # Eżempju: estrazzjoni ta' entitajiet, skoring, eċċ.
    words = text.split()
    return {
        "word_count": len(words),
        "unique_words": len(set(words)),
    }

async def complete_pipeline(prompts: list[str]) -> list[dict]:
    """Pipeline: sejħiet asinkroni tal-LLM + post-ipproċessar parallelu tal-CPU."""
    # Pass 1: sejħiet konkurrenti tal-LLM
    llm_results = await calls_with_limit(prompts)

    # Pass 2: post-ipproċessar parallelu (CPU)
    loop = asyncio.get_event_loop()
    with ProcessPoolExecutor(max_workers=4) as pool:
        tasks = [
            loop.run_in_executor(pool, heavy_post_processing, r)
            for r in llm_results
            if isinstance(r, str)
        ]
        final_results = await asyncio.gather(*tasks)

    return final_results

Ivverifika li l-kalkolu jiġġustifika verament il-pool qabel tintroduċih: is-serializzazzjoni tad-data għal proċess ieħor għandha kost, u għal trattamenti li jdumu ftit millisekondi dan il-kost jaqbeż il-gwadann.

Verifika tal-Produzzjoni Reali

L-aġġustament ta’ max_concurrency mhix suppożizzjoni. Baxx wisq, u tħalli l-produzzjoni fuq il-mejda; għoli wisq, u ttriggera limiti tar-rata li jiswuk aktar ħin milli jiffrankawlek. Kejjel fuq it-tagħbija attwali tiegħek, ivvarja l-valur, u ħares lejn kemm il-produzzjoni kif ukoll in-numru ta’ suċċessi—pipeline veloċi ħafna li tfalli darba minn kull ħams mhix mgħaġġla.

import time

async def benchmark_throughput(num_requests: int = 100):
    """Ikejjel il-produzzjoni reali tal-pipeline tiegħek."""
    prompts = [
        f"Agħti fatt interessanti numru {i}."
        for i in range(num_requests)
    ]

    start = time.perf_counter()
    results = await calls_with_limit(prompts, max_concurrency=20)
    duration = time.perf_counter() - start

    successes = sum(1 for r in results if isinstance(r, str))
    print(f"Talbiet: {num_requests}")
    print(f"Suċċessi: {successes}")
    print(f"Tul: {duration:.1f}s")
    print(f"Produzzjoni: {successes / duration:.1f} req/s")

Punti Ewlenin

  • Uża AsyncOpenAI u asyncio.gather għall-konkurrenza tal-I/O
  • Illimita l-konkurrenza b’semaphora biex tirrispetta l-kwoti
  • Il-mudell map-reduce jparallelizza l-ipproċessar ta’ dokumenti twal
  • Irriżerva ProcessPoolExecutor għall-post-ipproċessar intensiv tal-CPU