Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Lygiagretumas ir konkurencija

Paskaita 8 iš 20 Atnaujinta 2026 m. liepos 28 d. Pažengusiems
Šiame puslapyje
  1. Laukti kartu nereiškia skaičiuoti kartu
  2. Konkurencinių užklausų paleidimas
  3. „Map-Reduce“ modelio taikymas tekstui
  4. Kada daugiaprocesinis apdorojimas vėl tampa aktualus
  5. Tikrojo pralaidumo tikrinimas
  6. Svarbiausi punktai

Laukti kartu nereiškia skaičiuoti kartu

„OpenAI“ API užklausa yra įvesties/išvesties (I/O) ribojama operacija: tavo programa neapdoroja skaičių, ji laukia tinklo atsakymo. Ši savybė diktuoja tinkamo įrankio pasirinkimą. Lygiagretumas (angl. parallelism), suprantamas kaip daugiaprocesinis apdorojimas, paskirsto skaičiavimus per kelis procesorius; tai kainuoja visą procesą vienam darbo vienetui, o šimto procesų, laukiančių tinklo atsakymo, paleidimas yra grynas švaistymas. Konkurencija, kurią suteikia asyncio, leidžia vienam procesui vienu metu valdyti šimtus laukimo operacijų beveik be kaštų. Būtent tai maksimaliai padidina tavo užklausų pralaidumą.

Šis skirtumas yra daugiau nei akademinis: komanda, kuri lygiagretina savo didžiųjų kalbos modelių (LLM) užklausas naudodama procesų baseiną, sunaudos kelis gigabaitus atminties negaudama jokios naudos, palyginti su keliomis asyncio eilutėmis.

Konkurencinių užklausų paleidimas

SDK pateikia asinchroninį klientą AsyncOpenAI, kurio užklausos laukiamos naudojant await. Kelių korutinų surinkimas funkcijoje asyncio.gather leidžia joms visoms vykti vienu metu, o bendra trukmė artėja prie lėčiausios užklausos trukmės, o ne jų sumos.

import asyncio
import openai

client = openai.AsyncOpenAI()

async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
    """Vienas asinchroninis API užklausimas."""
    response = await client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

async def concurrent_calls(prompts: list[str]) -> list[str]:
    """Paleidžia visas užklausas konkurenciškai."""
    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"Klaida užuominoje {i}: {result}")

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

Žyma return_exceptions=True yra tai, kas atskiria prototipą nuo gamybinio lygio apdorojimo. Be jos, pirmoji išimtis nutraukia gather veikimą ir tu prarandi devyniasdešimt devynis jau gautus rezultatus. Su ja klaidos tampa reikšmėmis, kurias gali patikrinti, įregistruoti žurnale ir kartoti savo tempu.

Tačiau ši „žalia“ versija turi akivaizdų trūkumą: tūkstančio užklausų paleidimas vienu metu per kelias sekundes viršys tavo dažnio ribas. Semaforas išsprendžia šią problemą leisdamas vykdyti tik fiksuotą skaičių vienalaikių užklausų, o likusios kantriai laukia savo eilės. Dvidešimt yra pagrįstas pradinis taškas, kurį reikia koreguoti atsižvelgiant į realias tavo organizacijos kvotas.

async def calls_with_limit(
    prompts: list[str],
    max_concurrency: int = 20,
) -> list[str]:
    """Apriboja vienalaikių užklausų skaičių."""
    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)

„Map-Reduce“ modelio taikymas tekstui

Dviejų šimtų puslapių dokumento negalima apibendrinti viena užklausa, o jo skaidymas nuosekliai užtruktų minutes. Čia natūraliai tinka „map-reduce“ modelis: padalink dokumentą į dalis, kiekvieną dalį apibendrink konkurenciškai, tada paprašyk modelio sukurti šių santraukų sintezę. „Map“ fazė visiškai pasinaudoja konkurencijos privalumais, o „reduce“ fazė yra viena užklausa tekstui, kuris tapo trumpas.

async def map_reduce_summary(
    document: str,
    chunk_size: int = 3000,
) -> str:
    """Apibendrina ilgą dokumentą naudodamas lygiagretų map-reduce."""

    # Fazė MAP: skaidymas ir apibendrinimas lygiagrečiai
    chunks = [
        document[i:i + chunk_size]
        for i in range(0, len(document), chunk_size)
    ]

    map_prompts = [
        f"Apibendrinkite šią ištrauką 3 pagrindiniais punktais:\n\n{chunk}"
        for chunk in chunks
    ]

    partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)

    # Fazė REDUCE: santraukų sujungimas
    summary_text = "\n\n---\n\n".join(
        r for r in partial_summaries if isinstance(r, str)
    )

    final_summary = await single_call(
        f"Sintezuokite šias dalines santraukas į nuoseklią "
        f"5 pagrindinių punktų santrauką:\n\n{summary_text}"
    )

    return final_summary

Filtravimas if isinstance(r, str) yra tiek produkto sprendimas, tiek techninė atsargumo priemonė: tai reiškia, kad galutinė sintezė bus sukurta net jei trys dalys nepavyko, ir tai įvyks tyliai. Priklausomai nuo konteksto, tai gali būti būtent tai, ko nori, arba tai gali būti nepriimtina. Priimk sprendimą aiškiai ir bet kuriuo atveju įregistruok žurnale prarastų dalių skaičių.

Kada daugiaprocesinis apdorojimas vėl tampa aktualus

Vis dar lieka retų situacijų, kai skaičiavimai perima kontrolę: sunkus atsakymų poapdorojimas, entitetų išgavimas, vertinimas, struktūruotas analizavimas. Šis darbas yra procesoriaus (CPU) ribojamas ir iš asyncio nieko nelaimi. Elegantiškas derinys yra sujungti abu režimus vienoje vamzdyno sistemoje: tinklo užklausos vykdomos konkurenciškai, o skaičiavimai paskirstomi procesų baseinui naudojant run_in_executor.

import asyncio
from concurrent.futures import ProcessPoolExecutor

def heavy_post_processing(text: str) -> dict:
    """Procesoriaus apkrovą keliantis rezultato apdorojimas (NLP, analizė ir kt.)."""
    # Pavyzdys: entitetų išgavimas, vertinimas ir kt.
    words = text.split()
    return {
        "word_count": len(words),
        "unique_words": len(set(words)),
    }

async def complete_pipeline(prompts: list[str]) -> list[dict]:
    """Vamzdynas: asinchroninės LLM užklausos + lygiagretus CPU poapdorojimas."""
    # 1 žingsnis: konkurencinės LLM užklausos
    llm_results = await calls_with_limit(prompts)

    # 2 žingsnis: lygiagretus poapdorojimas (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

Prieš įdiegdami baseiną, įsitikinkite, kad skaičiavimai tai pateisina: duomenų serializavimas kitam procesui turi kainą, ir kelioms milisekundėms trunkančiam apdorojimui ši kaina viršija naudą.

Tikrojo pralaidumo tikrinimas

max_concurrency derinimas nėra spėjimas. Per mažas – ir palieki pralaidumą nepanaudotą; per didelis – ir sukeliate dažnio ribas, kurios kainuoja daugiau laiko, nei sutaupo. Matuok esant realiai apkrovai, keisdamas reikšmę, ir stebėk tiek pralaidumą, tiek sėkmingų užklausų skaičių – labai greitas vamzdynas, kuris nepavyksta kas penktą kartą, nėra greitas.

import time

async def benchmark_throughput(num_requests: int = 100):
    """Matuoja tikrąjį tavo vamzdyno pralaidumą."""
    prompts = [
        f"Pateik įdomų faktą numeriu {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"Užklausos: {num_requests}")
    print(f"Sėkmės: {successes}")
    print(f"Trukmė: {duration:.1f}s")
    print(f"Pralaidumas: {successes / duration:.1f} užklausų/s")

Svarbiausi punktai

  • Naudok AsyncOpenAI ir asyncio.gather įvesties/išvesties (I/O) konkurencijai
  • Apribok konkurenciją semaforu, kad laikytumeisi kvotų
  • „Map-reduce“ modelis lygiagrečiai apdoroja ilgus dokumentus
  • ProcessPoolExecutor palik tik procesoriaus apkrovą keliančiam poapdorojimui