Паралелизъм и конкурентност
На тази страница
Чакането заедно не е изчисление заедно
Извикването на OpenAI API е операция, ограничена от входно-изходните устройства (I/O-bound): Вашата програма не извършва тежки изчисления, а чака мрежов отговор. Тази природа диктува правилния инструмент. Паралелизмът, в смисъл на многопроцесорна обработка (multiprocessing), разпределя изчисленията между множество ядра; той изисква отделен процес за всяка единица работа, а стартирането на сто процеса, които всички чакат мрежата, е чиста загуба. Конкурентността, осигурена от asyncio, позволява на един единствен процес да обработва стотици едновременни очаквания с пренебрежимо малка цена. Това е, което максимизира пропускателната способност на Вашите извиквания.
Разликата е повече от академична: екип, който паралелизира своите LLM извиквания чрез пул от процеси, ще консумира няколко гигабайта памет без никакво предимство в сравнение с няколко реда asyncio.
Стартиране на конкурентни извиквания
SDK предоставя асинхронен клиент, AsyncOpenAI, чиито извиквания се очакват с await. Събирането на множество корутини в asyncio.gather позволява на всички тях да напредват едновременно, като общата продължителност се доближава до тази на най-бавното извикване, а не до сумата им.
import asyncio
import openai
client = openai.AsyncOpenAI()
async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
"""A single asynchronous API call."""
response = await client.responses.create(
model=model,
input=prompt,
)
return response.output_text
async def concurrent_calls(prompts: list[str]) -> list[str]:
"""Launches all calls concurrently."""
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"Error on prompt {i}: {result}")
return [r for r in results if not isinstance(r, Exception)]
Флагът return_exceptions=True е това, което отличава прототипа от обработка на производствено ниво. Без него първото изключение прекъсва gather и Вие губите деветдесет и деветте вече получени резултата. С него грешките стават стойности, които проверявате, регистрирате и повторете опитите със собственото си темпо.
Въпреки това, тази сурова версия има незабавен недостатък: стартирането на хиляда извиквания наведнъж ще надхвърли лимитите Ви за честота (rate limits) за секунди. Семафорът решава този проблем, като позволява само фиксиран брой едновременни извиквания, докато останалите търпеливо чакат своя ред. Двадесет е разумна начална точка, която да се коригира въз основа на действителните квоти на Вашата организация.
async def calls_with_limit(
prompts: list[str],
max_concurrency: int = 20,
) -> list[str]:
"""Limits the number of simultaneous calls."""
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 към текст
Документ от двеста страници не може да бъде обобщен с едно единствено извикване, а последователното му разрязване би отнело минути. Шаблонът map-reduce се прилага естествено тук: разделете на части, обобщете всяка част конкурентно, след което поискайте от модела синтез на обобщенията. Фазата на map се възползва изцяло от конкурентността, докато фазата на reduce представлява едно единствено извикване върху текст, който вече е станал кратък.
async def map_reduce_summary(
document: str,
chunk_size: int = 3000,
) -> str:
"""Summarizes a long document via parallel map-reduce."""
# Phase MAP: split and summarize in parallel
chunks = [
document[i:i + chunk_size]
for i in range(0, len(document), chunk_size)
]
map_prompts = [
f"Summarize this passage in 3 key points:\n\n{chunk}"
for chunk in chunks
]
partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)
# Phase REDUCE: combine summaries
summary_text = "\n\n---\n\n".join(
r for r in partial_summaries if isinstance(r, str)
)
final_summary = await single_call(
f"Synthesize these partial summaries into a coherent summary "
f"of 5 key points:\n\n{summary_text}"
)
return final_summary
Филтрирането if isinstance(r, str) е толкова продуктово решение, колкото и техническа предпазна мярка: то означава, че крайният синтез ще бъде произведен, дори ако три части са се провалили тихо. В зависимост от контекста, това е точно това, което искате, или е неприемливо. Решете изрично и във всеки случай регистрирайте броя на загубените части.
Кога многопроцесорната обработка отново става актуална
Все още съществуват редки ситуации, при които изчисленията си връщат контрола: тежка пост-обработка на отговори, извличане на entidades, оценяване, структуриран парсинг. Тази работа е ограничена от процесора (CPU-bound) и не печели нищо от asyncio. Елегантната комбинация е да се свържат двата режима в един единствен конвейер: мрежови извиквания чрез конкурентност, последвани от изчисления, разпределени през пул от процеси чрез run_in_executor.
import asyncio
from concurrent.futures import ProcessPoolExecutor
def heavy_post_processing(text: str) -> dict:
"""CPU-bound processing on the result (NLP, parsing, etc.)."""
# Example: entity extraction, scoring, etc.
words = text.split()
return {
"word_count": len(words),
"unique_words": len(set(words)),
}
async def complete_pipeline(prompts: list[str]) -> list[dict]:
"""Pipeline: async LLM calls + parallel CPU post-processing."""
# Step 1: concurrent LLM calls
llm_results = await calls_with_limit(prompts)
# Step 2: parallel post-processing (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
Уверете се, че изчислението наистина оправдава пула, преди да го въведете: сериализирането на данни към друг процес има цена и за обработки, траещи няколко милисекунди, тази цена надвишава ползата.
Проверка на реалната пропускателна способност
Настройването на max_concurrency не е гадаене. Твърде ниска стойност и Вие оставяте пропускателна способност на масата; твърде висока и задействате лимити за честота, които Ви струват повече време, отколкото спестяват. Измервайте върху действителното си натоварване, варирайки стойността, и наблюдавайте както пропускателната способност, така и броя на успехите – много бърз конвейер, който се проваля един път на всеки пет, не е бърз.
import time
async def benchmark_throughput(num_requests: int = 100):
"""Measures the real throughput of your pipeline."""
prompts = [
f"Give an interesting fact number {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"Requests: {num_requests}")
print(f"Successes: {successes}")
print(f"Duration: {duration:.1f}s")
print(f"Throughput: {successes / duration:.1f} req/s")
Ключови изводи
- Използвайте
AsyncOpenAIиasyncio.gatherза I/O конкурентност - Ограничете конкурентността със семафор, за да спазвате квотите
- Шаблонът map-reduce паралелизира обработката на дълги документи
- Запазете
ProcessPoolExecutorза пост-обработка, интензивна за процесора