Salt la conținutul principal
Română— Alege o limbă
Meniu

Paralelism și concurență

Lecția 8 din 20 Actualizată 28 iulie 2026 Avansat
Pe această pagină
  1. A aștepta împreună nu înseamnă a calcula împreună
  2. Lansarea apelurilor concurente
  3. Modelul Map-Reduce aplicat textului
  4. Când multiprocesarea devine din nou relevantă
  5. Verificarea debitului real
  6. Puncte cheie

A aștepta împreună nu înseamnă a calcula împreună

Un apel către API-ul OpenAI este o operațiune limitată de I/O: programul dumneavoastră nu efectuează calcule intensive, ci așteaptă un răspuns din rețea. Această natură dictează instrumentul potrivit. Paralelismul, în sensul de multiprocesare, distribuie calculul pe mai multe nuclee; acesta costă un proces complet per unitate de lucru, iar rularea a o sută de procese care toate așteaptă rețeaua este o risipă pură. Concurența, oferită de asyncio, permite unui singur proces să gestioneze sute de așteptări simultane cu un cost neglijabil. Acesta este mecanismul care maximizează debitul apelurilor dumneavoastră.

Distincția este mai mult decât academică: o echipă care paralelizează apelurile către LLM folosind un pool de procese va consuma câțiva gigaocteți de memorie pentru zero câștig, comparativ cu câteva linii de asyncio.

Lansarea apelurilor concurente

SDK-ul expune un client asincron, AsyncOpenAI, ale cărui apeluri sunt așteptate cu await. Gruparea mai multor corutine într-un asyncio.gather le permite tuturor să progreseze simultan, durata totală apropiindu-se de cea a celui mai lent apel, și nu de suma lor.

import asyncio
import openai

client = openai.AsyncOpenAI()

async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
    """Un singur apel API asincron."""
    response = await client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

async def concurrent_calls(prompts: list[str]) -> list[str]:
    """Lansează toate apelurile concurent."""
    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"Eroare la prompt-ul {i}: {result}")

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

Flag-ul return_exceptions=True este ceea ce distinge un prototip de o procesare de nivel producție. Fără acesta, prima excepție întrerupe gather și pierdeți cele nouăzeci și nouă de rezultate deja obținute. Cu acesta, erorile devin valori pe care le inspectați, le înregistrați în jurnale și le reîncercați în ritmul dumneavoastră.

Totuși, această versiune brută are un defect imediat: lansarea a o mie de apeluri simultan va depăși limitele de rată (rate limits) în câteva secunde. Un semafor rezolvă această problemă permițând doar un număr fix de apeluri simultane, restul așteptând răbdător rândul lor. Douăzeci este un punct de plecare rezonabil, care trebuie ajustat în funcție de cotele reale ale organizației dumneavoastră.

async def calls_with_limit(
    prompts: list[str],
    max_concurrency: int = 20,
) -> list[str]:
    """Limitează numărul de apeluri simultane."""
    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)

Modelul Map-Reduce aplicat textului

Un document de două sute de pagini nu poate fi rezumat într-un singur apel, iar tăierea sa secvențială ar dura minute. Modelul map-reduce se aplică natural aici: divizați în fragmente, rezumați fiecare fragment concurent, apoi cereți modelului o sinteză a rezumatelor. Faza de map beneficiază pe deplin de concurență, în timp ce faza de reduce este un singur apel pe un text care a devenit scurt.

async def map_reduce_summary(
    document: str,
    chunk_size: int = 3000,
) -> str:
    """Rezumatul unui document lung prin map-reduce paralel."""

    # Faza MAP: divizare și rezumare în paralel
    chunks = [
        document[i:i + chunk_size]
        for i in range(0, len(document), chunk_size)
    ]

    map_prompts = [
        f"Rezumă acest pasaj în 3 puncte cheie:\n\n{chunk}"
        for chunk in chunks
    ]

    partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)

    # Faza REDUCE: combinarea rezumatelor
    summary_text = "\n\n---\n\n".join(
        r for r in partial_summaries if isinstance(r, str)
    )

    final_summary = await single_call(
        f"Sintetizează aceste rezumate parțiale într-un rezumat coerent "
        f"de 5 puncte cheie:\n\n{summary_text}"
    )

    return final_summary

Filtrarea if isinstance(r, str) este la fel de mult o decizie de produs cât și o precauție tehnică: înseamnă că sinteza finală va fi produsă chiar dacă trei fragmente au eșuat, în mod silențios. În funcție de context, acesta este exact ceea ce doriți, sau este inacceptabil. Decideți explicit și înregistrați în jurnale numărul de fragmente pierdute în orice caz.

Când multiprocesarea devine din nou relevantă

Există încă situații rare în care calculul preia controlul: post-procesare intensă asupra răspunsurilor, extragerea entităților, scoruri, analiză sintactică structurată. Această muncă este limitată de CPU și nu câștigă nimic de la asyncio. Combinația elegantă este înlănțuirea celor două regimuri într-o singură pipeline: apeluri de rețea în concurență, apoi calcul distribuit printr-un pool de procese prin run_in_executor.

import asyncio
from concurrent.futures import ProcessPoolExecutor

def heavy_post_processing(text: str) -> dict:
    """Procesare limitată de CPU pe rezultat (NLP, parsing, etc.)."""
    # Exemplu: extragerea entităților, scoruri, etc.
    words = text.split()
    return {
        "word_count": len(words),
        "unique_words": len(set(words)),
    }

async def complete_pipeline(prompts: list[str]) -> list[dict]:
    """Pipeline: apeluri LLM asincrone + post-procesare CPU paralelă."""
    # Pasul 1: apeluri LLM concurente
    llm_results = await calls_with_limit(prompts)

    # Pasul 2: post-procesare paralelă (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

Verificați dacă calculul justifică cu adevărat pool-ul înainte de a-l introduce: serializarea datelor către un alt proces are un cost, iar pentru tratamente care durează câteva milisecunde, acest cost depășește câștigul.

Verificarea debitului real

Ajustarea max_concurrency nu este o ghicitoare. Prea scăzut și lăsați debitul pe masă; prea ridicat și declanșați limite de rată care vă costă mai mult timp decât economisesc. Măsurați pe sarcina dumneavoastră reală, variind valoarea, și priviți atât debitul, cât și numărul de succese – o pipeline foarte rapidă care eșuează o dată din cinci nu este rapidă.

import time

async def benchmark_throughput(num_requests: int = 100):
    """Măsoară debitul real al pipeline-ului dumneavoastră."""
    prompts = [
        f"Oferă un fapt interesant numărul {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"Cereri: {num_requests}")
    print(f"Succese: {successes}")
    print(f"Durație: {duration:.1f}s")
    print(f"Debit: {successes / duration:.1f} req/s")

Puncte cheie

  • Folosiți AsyncOpenAI și asyncio.gather pentru concurența I/O
  • Limitați concurența cu un semafor pentru a respecta cotele
  • Modelul map-reduce paralelizează procesarea documentelor lungi
  • Rezervați ProcessPoolExecutor pentru post-procesarea intensivă de CPU