Lygiagretumas ir konkurencija
Šiame puslapyje
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
AsyncOpenAIirasyncio.gatherįvesties/išvesties (I/O) konkurencijai - Apribok konkurenciją semaforu, kad laikytumeisi kvotų
- „Map-reduce“ modelis lygiagrečiai apdoroja ilgus dokumentus
ProcessPoolExecutorpalik tik procesoriaus apkrovą keliančiam poapdorojimui