Παραλληλισμός και Συγχρονισμός
Σε αυτήν τη σελίδα
Το να περιμένετε μαζί δεν σημαίνει ότι υπολογίζετε μαζί
Μια κλήση στο API του OpenAI είναι μια λειτουργία περιορισμένης εισόδου/εξόδου (I/O-bound): το πρόγραμμά σας δεν κάνει αριθμητικούς υπολογισμούς, αλλά περιμένει μια απόκριση δικτύου. Αυτή η φύση υπαγορεύει το κατάλληλο εργαλείο. Ο παραλληλισμός, με την έννοια της πολυδιεργασίας (multiprocessing), κατανέμει τον υπολογισμό σε πολλούς πυρήνες· κοστίζει μια πλήρη διεργασία ανά μονάδα εργασίας, και η εκτέλεση εκατό διεργασιών που περιμένουν όλες στο δίκτυο αποτελεί καθαρή σπατάλη. Ο συγχρονισμός (concurrency), όπως παρέχεται από το asyncio, επιτρέπει σε μια μοναδική διεργασία να διαχειρίζεται εκατοντάδες ταυτόχρονες αναμονές με αμελητέο κόστος. Αυτό είναι που μεγιστοποιεί τον ρυθμό των κλήσεών σας.
Η διάκριση είναι περισσότερο από ακαδημαϊκή: μια ομάδα που παραλληλοποιεί τις κλήσεις LLM της με ένα pool διεργασιών θα καταναλώσει πολλά gigabytes μνήμης για μηδενικό όφελος, σε σύγκριση με μερικές γραμμές asyncio.
Εκκίνηση Ταυτόχρονων Κλήσεων
Το SDK εκθέτει έναν ασύγχρονο πελάτη, τον AsyncOpenAI, του οποίου οι κλήσεις περιμένουν με τη λέξη-κλειδί await. Η ομαδοποίηση πολλαπλών coroutines σε ένα asyncio.gather επιτρέπει σε όλες να προοδεύουν ταυτόχρονα, με τη συνολική διάρκεια να πλησιάζει εκείνη της πιο αργής κλήσης και όχι το άθροισμά τους.
import asyncio
import openai
client = openai.AsyncOpenAI()
async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
"""Μια μοναδική ασύγχρονη κλήση API."""
response = await client.responses.create(
model=model,
input=prompt,
)
return response.output_text
async def concurrent_calls(prompts: list[str]) -> list[str]:
"""Εκκινεί όλες τις κλήσεις ταυτόχρονα."""
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"Σφάλμα στο prompt {i}: {result}")
return [r for r in results if not isinstance(r, Exception)]
Η σημαία return_exceptions=True είναι αυτή που διαχωρίζει ένα πρωτότυπο από μια επεξεργασία επιπέδου παραγωγής. Χωρίς αυτήν, η πρώτη εξαίρεση διακόπτει το gather και χάνετε τα ενενήντα εννέα αποτελέσματα που έχουν ήδη ληφθεί. Με αυτήν, τα σφάλματα γίνονται τιμές που επιθεωρείτε, καταγράφετε και επαναλαμβάνετε με τον δικό σας ρυθμό.
Ωστόσο, αυτή η αρχική έκδοση έχει ένα άμεσο ελάττωμα: η εκκίνηση χιλίων κλήσεων ταυτόχρονα θα παραβιάσει τα όρια ρυθμού (rate limits) σας μέσα σε δευτερόλεπτα. Ένα semaphore λύνει το πρόβλημα επιτρέποντας μόνο έναν σταθερό αριθμό ταυτόχρονων κλήσεων, με τις υπόλοιπες να περιμένουν υπομονετικά τη σειρά τους. Το είκοσι είναι μια λογική αρχική τιμή, προς προσαρμογή με βάση τα πραγματικά όρια του οργανισμού σας.
async def calls_with_limit(
prompts: list[str],
max_concurrency: int = 20,
) -> list[str]:
"""Περιορίζει τον αριθμό των ταυτόχρονων κλήσεων."""
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:
"""Συνοψίζει ένα μακρύ έγγραφο μέσω παράλληλου map-reduce."""
# Φάση MAP: διαίρεση και συνοπτική παρουσίαση παράλληλα
chunks = [
document[i:i + chunk_size]
for i in range(0, len(document), chunk_size)
]
map_prompts = [
f"Συνοψίστε αυτό το απόσπασμα σε 3 βασικά σημεία:\n\n{chunk}"
for chunk in chunks
]
partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)
# Φάση REDUCE: συνδυασμός συνοψίσεων
summary_text = "\n\n---\n\n".join(
r for r in partial_summaries if isinstance(r, str)
)
final_summary = await single_call(
f"Συνθέστε αυτές τις μερικές συνοψίσεις σε μια συνεκτική σύνοψη "
f"5 βασικών σημείων:\n\n{summary_text}"
)
return final_summary
Το φιλτράρισμα if isinstance(r, str) είναι τόσο μια απόφαση προϊόντος όσο και μια τεχνική προφύλαξη: σημαίνει ότι η τελική σύνθεση θα παραχθεί ακόμα και αν τρία τμήματα απέτυχαν, σιωπηλά. Ανάλογα με το πλαίσιο, αυτό είναι ακριβώς αυτό που θέλετε, ή είναι απαράδεκτο. Αποφασίστε ρητά και καταγράψτε σε κάθε περίπτωση τον αριθμό των χαμένων τμημάτων.
Πότε η Πολυδιεργασία Γίνεται Σχετική Ξανά
Υπάρχουν ακόμη σπάνιες περιπτώσεις όπου ο υπολογισμός ανακτά τον έλεγχο: βαριά μετα-επεξεργασία στις αποκρίσεις, εξαγωγή οντοτήτων, βαθμολόγηση, δομημένη ανάλυση. Αυτή η εργασία είναι περιορισμένη από την CPU (CPU-bound) και δεν κερδίζει τίποτα από το asyncio. Ο κομψός συνδυασμός είναι η αλυσιδωτή σύνδεση των δύο καθεστώτων σε έναν ενιαίο σωλήνα (pipeline): κλήσεις δικτύου σε συγχρονισμό και στη συνέχεια υπολογισμός κατανεμημένος σε ένα pool διεργασιών μέσω του run_in_executor.
import asyncio
from concurrent.futures import ProcessPoolExecutor
def heavy_post_processing(text: str) -> dict:
"""Επεξεργασία περιορισμένης CPU στο αποτέλεσμα (NLP, ανάλυση κ.λπ.)."""
# Παράδειγμα: εξαγωγή οντοτήτων, βαθμολόγηση κ.λπ.
words = text.split()
return {
"word_count": len(words),
"unique_words": len(set(words)),
}
async def complete_pipeline(prompts: list[str]) -> list[dict]:
"""Σωλήνας: ασύγχρονες κλήσεις LLM + παράλληλη μετα-επεξεργασία CPU."""
# Βήμα 1: ταυτόχρονες κλήσεις LLM
llm_results = await calls_with_limit(prompts)
# Βήμα 2: παράλληλη μετα-επεξεργασία (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
Επαληθεύστε ότι ο υπολογισμός δικαιολογεί πραγματικά το pool πριν το εισαγάγετε: η σειριοποίηση δεδομένων σε άλλη διεργασία έχει κόστος, και για επεξεργασίες που διαρκούν λίγα χιλιοστά του δευτερολέπτου, αυτό το κόστος υπερβαίνει το όφελος.
Επαλήθευση Πραγματικού Ρυθμού Απόδοσης
Η ρύθμιση του max_concurrency δεν είναι μαντεψιά. Πολύ χαμηλά, και αφήνετε απόδοση αναξιοποίητη· πολύ υψηλά, και ενεργοποιείτε όρια ρυθμού που σας κοστίζουν περισσότερο χρόνο από ό,τι εξοικονομείτε. Μετρήστε στο πραγματικό σας φορτίο, μεταβάλλοντας την τιμή, και κοιτάξτε τόσο τον ρυθμό απόδοσης όσο και τον αριθμό επιτυχιών—ένας πολύ γρήγορος σωλήνας που αποτυγχάνει μία φορά στις πέντε δεν είναι γρήγορος.
import time
async def benchmark_throughput(num_requests: int = 100):
"""Μετρά τον πραγματικό ρυθμό απόδοσης του σωλήνα σας."""
prompts = [
f"Δώστε ένα ενδιαφέρον γεγονός αριθμός {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"Αιτήματα: {num_requests}")
print(f"Επιτυχίες: {successes}")
print(f"Διάρκεια: {duration:.1f}s")
print(f"Ρυθμός απόδοσης: {successes / duration:.1f} req/s")
Βασικά σημεία
- Χρησιμοποιήστε το
AsyncOpenAIκαι τοasyncio.gatherγια συγχρονισμό I/O - Περιορίστε τον συγχρονισμό με ένα semaphore για να σεβαστείτε τα όρια
- Το πρότυπο map-reduce παραλληλοποιεί την επεξεργασία μεγάλων εγγράφων
- Διατηρήστε το
ProcessPoolExecutorαποκλειστικά για μετα-επεξεργασία έντονης χρήσης CPU