Równoległość i współbieżność
Na tej stronie
Czekanie razem nie oznacza liczenia razem
Wywołanie API OpenAI to operacja ograniczona przez wejście/wyjście (I/O-bound): Twój program nie wykonuje obliczeń, lecz czeka na odpowiedź sieciową. Ta natura dyktuje wybór odpowiedniego narzędzia. Równoległość w sensie wieloprocesowości (multiprocessing) rozdziela obliczenia na wiele rdzeni; kosztuje to pełny proces na jednostkę pracy, a uruchamianie stu procesów, które wszystkie czekają na sieć, to czysta strata. Współbieżność, zapewniana przez asyncio, pozwala pojedynczemu procesowi obsłużyć setki jednoczesnych oczekiwań przy znikomym koszcie. To właśnie maksymalizuje przepustowość Twoich wywołań.
To rozróżnienie jest czymś więcej niż akademickim ćwiczeniem: zespół, który równolegli wywołania LLM za pomocą puli procesów, zużyje kilka gigabajtów pamięci bez żadnego zysku w porównaniu do kilku linii kodu z asyncio.
Uruchamianie wywołań współbieżnych
SDK udostępnia klienta asynchronicznego, AsyncOpenAI, którego wywołania oczekują się za pomocą await. Zebranie wielu korutyn w asyncio.gather pozwala im wszystkim postępować jednocześnie, przy czym całkowity czas trwania zbliża się do czasu najwolniejszego wywołania, a nie do sumy czasów wszystkich wywołań.
import asyncio
import openai
client = openai.AsyncOpenAI()
async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
"""Pojedyncze asynchroniczne wywołanie API."""
response = await client.responses.create(
model=model,
input=prompt,
)
return response.output_text
async def concurrent_calls(prompts: list[str]) -> list[str]:
"""Uruchamia wszystkie wywołania współbieżnie."""
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"Błąd przy prompcie {i}: {result}")
return [r for r in results if not isinstance(r, Exception)]
Flaga return_exceptions=True to właśnie to, co odróżnia prototyp od przetwarzania klasy produkcyjnej. Bez niej pierwszy wyjątek przerywa działanie gather, a Ty tracisz dziewięćdziesiąt dziewięć już uzyskanych wyników. Dzięki niej błędy stają się wartościami, które możesz sprawdzić, zalogować i ponowić we własnym tempie.
Jednak ta surowa wersja ma natychmiastową wadę: uruchomienie tysiąca wywołań naraz błyskawicznie przekroczy Twoje limity częstotliwości (rate limits). Semafory rozwiązują ten problem, pozwalając tylko na określoną liczbę jednoczesnych wywołań, podczas gdy reszta cierpliwie czeka na swoją kolej. Dwadzieścia to rozsądny punkt wyjścia, który należy dostosować w oparciu o rzeczywiste kwoty Twojej organizacji.
async def calls_with_limit(
prompts: list[str],
max_concurrency: int = 20,
) -> list[str]:
"""Ogranicza liczbę jednoczesnych wywołań."""
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)
Wzorzec Map-Reduce zastosowany do tekstu
Dwustustronicowego dokumentu nie można podsumować w jednym wywołaniu, a sekwencyjne dzielenie go zajęłoby minuty. Wzorzec map-reduce pasuje tu naturalnie: podziel dokument na fragmenty, podsumuj każdy fragment współbieżnie, a następnie poproś model o syntezę tych podsumowań. Faza map korzysta w pełni ze współbieżności, podczas gdy faza reduce to pojedyncze wywołanie na tekście, który stał się już krótki.
async def map_reduce_summary(
document: str,
chunk_size: int = 3000,
) -> str:
"""Podsumowuje długi dokument za pomocą równoległego map-reduce."""
# Faza MAP: podział i podsumowanie równoległe
chunks = [
document[i:i + chunk_size]
for i in range(0, len(document), chunk_size)
]
map_prompts = [
f"Podsumuj ten fragment w 3 kluczowych punktach:\n\n{chunk}"
for chunk in chunks
]
partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)
# Faza REDUCE: połączenie podsumowań
summary_text = "\n\n---\n\n".join(
r for r in partial_summaries if isinstance(r, str)
)
final_summary = await single_call(
f"Syntezuj te częściowe podsumowania w spójne podsumowanie "
f"zawierające 5 kluczowych punktów:\n\n{summary_text}"
)
return final_summary
Filtrowanie if isinstance(r, str) jest decyzją produktową tak samo, jak technicznym zabezpieczeniem: oznacza to, że końcowa synteza zostanie wygenerowana nawet wtedy, gdy trzy fragmenty zawiodą po cichu. W zależności od kontekstu jest to dokładnie to, czego chcesz, albo jest to nie do przyjęcia. Zdecyduj o tym wyraźnie i w każdym przypadku loguj liczbę utraconych fragmentów.
Kiedy wieloprocesowość znów staje się istotna
Nadal istnieją rzadkie sytuacje, w których obliczenia przejmują kontrolę: ciężkie przetwarzanie post-processingu odpowiedzi, ekstrakcja encji, ocenianie, parsowanie strukturalne. Ta praca jest ograniczona przez CPU (CPU-bound) i nie zyskuje nic dzięki asyncio. Eleganckim połączeniem jest splecenie tych dwóch reżimów w jednym potoku: wywołania sieciowe we współbieżności, a następnie obliczenia rozproszone na puli procesów za pomocą run_in_executor.
import asyncio
from concurrent.futures import ProcessPoolExecutor
def heavy_post_processing(text: str) -> dict:
"""Przetwarzanie ograniczone przez CPU na wyniku (NLP, parsowanie itp.)."""
# Przykład: ekstrakcja encji, ocenianie itp.
words = text.split()
return {
"word_count": len(words),
"unique_words": len(set(words)),
}
async def complete_pipeline(prompts: list[str]) -> list[dict]:
"""Potok: asynchroniczne wywołania LLM + równoległy post-processing CPU."""
# Krok 1: współbieżne wywołania LLM
llm_results = await calls_with_limit(prompts)
# Krok 2: równoległy 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
Zweryfikuj, czy obliczenia naprawdę uzasadniają użycie puli, zanim ją wprowadzisz: serializacja danych do innego procesu ma swój koszt, a dla operacji trwających kilka milisekund koszt ten przewyższa zysk.
Weryfikacja rzeczywistej przepustowości
Dostrajanie max_concurrency nie jest zgadywanką. Zbyt niska wartość oznacza zmarnowany potencjał przepustowości; zbyt wysoka uruchamia limity częstotliwości, które kosztują Cię więcej czasu, niż oszczędzają. Mierz na rzeczywistym obciążeniu, zmieniając tę wartość, i obserwuj zarówno przepustowość, jak i liczbę sukcesów – bardzo szybki potok, który zawodzi raz na pięć razy, nie jest szybki.
import time
async def benchmark_throughput(num_requests: int = 100):
"""Mierzy rzeczywistą przepustowość Twojego potoku."""
prompts = [
f"Podaj ciekawy fakt numer {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"Liczba żądań: {num_requests}")
print(f"Sukcesy: {successes}")
print(f"Czas trwania: {duration:.1f}s")
print(f"Przepustowość: {successes / duration:.1f} req/s")
Kluczowe wnioski
- Używaj
AsyncOpenAIiasyncio.gatherdo współbieżności I/O - Ograniczaj współbieżność za pomocą semafora, aby przestrzegać limitów
- Wzorzec map-reduce równolegli przetwarzanie długich dokumentów
- Rezerwuj
ProcessPoolExecutordla post-processingu wymagającego dużych zasobów CPU