Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Ασύγχρονος Πελάτης και Απόδοση

Μάθημα 10 / 14 Ενημερώθηκε 3 Νοεμβρίου 2026 Αρχάριος
Σε αυτήν τη σελίδα
  1. Βελτιστοποίηση Απόδοσης με Ασύγχρονη Λειτουργία
  2. Ο Πελάτης AsyncOpenAI
  3. Παράλληλα Αιτήματα με asyncio.gather
  4. Έλεγχος Παραλληλισμού
  5. Πλήρης Ασύγχρονη Ροή Εργασίας
  6. Σύγκριση Σύγχρονης vs Ασύγχρονης Λειτουργίας
  7. Διαχείριση Σφαλμάτων
  8. Βασικά σημεία

Ενημερώθηκε στις 3 Νοεμβρίου 2026 με βάση τη σελίδα Rate limits της xAI και την αναφορά API Εικόνων: Τα όρια του μοντέλου Imagine μετρώνται ως αιτήματα ανά δευτερόλεπτο—6 στο βασικό επίπεδο, 100 στο ανώτατο επίπεδο—και όχι «30 ανά λεπτό»· ένας σηματοφόρος (semaphore) περιορίζει τα ταυτόχρονα αιτήματα, όχι τον ρυθμό διέλευσης (throughput)· οι εικόνες εξάγονται ως JPEG από προεπιλογή· και οι συγκεκριμένοι χρονισμοί της παλιάς έκδοσης, οι οποίοι προέρχονταν από μη δημοσιευμένες μετρήσεις, αντικαθίστανται από έναν υπολογισμό. Πηγές: Rate limits · Images API.

Βελτιστοποίηση Απόδοσης με Ασύγχρονη Λειτουργία

Όταν χρειάζεται να δημιουργήσετε ή να επεξεργαστείτε πολλές εικόνες, οι διαδοχικές κλήσεις γίνονται σημείο συμφόρησης. Ο ασύγχρονος πελάτης του API της xAI σας επιτρέπει να εκτελείτε πολλαπλά αιτήματα παράλληλα, μειώνοντας σημαντικά τον συνολικό χρόνο επεξεργασίας.

Ο Πελάτης AsyncOpenAI

Η ασύγχρονη λειτουργία δεν κάνει μια μεμονωμένη δημιουργία ταχύτερη: ένα αίτημα για μία εικόνα διαρκεί ακριβώς τον ίδιο χρόνο. Αυτό που εξαλείφει είναι η περιττή αναμονή μεταξύ των αιτημάτων—ενώ η πρώτη εικόνα υπολογίζεται στον διακομιστή, το πρόγραμμά σας μπορεί να ζητήσει άλλες δέκα αντί να παραμείνει αποκλεισμένο. Γι’ αυτό το κέρδος είναι μηδενικό για μία εικόνα και δραματικό για πενήντα.

from openai import AsyncOpenAI
import asyncio
import os

async_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1"
)

async def generate_image(prompt):
    """Δημιουργεί μια εικόνα ασύγχρονα."""
    response = await async_client.images.generate(
        model="grok-imagine-image",
        prompt=prompt,
        extra_body={"resolution": "1k"},
    )
    return response.data[0].url

async def main():
    url = await generate_image("A lighthouse on a cliff, watercolor style")
    print(url)

asyncio.run(main())

Παράλληλα Αιτήματα με asyncio.gather

Το asyncio.gather εκκινεί όλα τα αιτήματα και στη συνέχεια περιμένει να ολοκληρωθεί το σύνολο. Η συνολική διάρκεια γίνεται ίση με εκείνη του πιο αργού αιτήματος, και όχι το άθροισμα όλων—αυτή είναι η ουσιαστική διαφορά, την οποία θα δείτε ήδη με τρεις ή τέσσερις εικόνες.

async def generate_batch(prompts):
    """Δημιουργεί εικόνες για πολλαπλές προτροπές παράλληλα."""
    tasks = [generate_image(prompt) for prompt in prompts]
    results = await asyncio.gather(*tasks)
    return results

async def main():
    prompts = [
        "Portrait of an engineer, corporate style",
        "Panoramic view of a futuristic city",
        "Isometric diagram of a data center",
        "Abstract blue and silver logo",
        "Illustration of a team in a meeting"
    ]

    urls = await generate_batch(prompts)
    for prompt, url in zip(prompts, urls):
        print(f"{prompt[:40]}... → {url}")

asyncio.run(main())

Με πέντε προτροπές, αντί να περιμένετε την ολοκλήρωση κάθε αιτήματος πριν ξεκινήσετε το επόμενο, και οι πέντε εικόνες υπολογίζονται ταυτόχρονα: ο συνολικός χρόνος πλησιάζει εκείνον του πιο αργού αιτήματος.

Έλεγχος Παραλληλισμού

Χωρίς όριο, το gather εκκινεί τα πάντα ταυτόχρονα—και πενήντα ταυτόχρονα αιτήματα σε ένα μοντέλο με όριο 6 αιτημάτων ανά δευτερόλεπτο στο βασικό επίπεδο προκαλούν χιονοστιβάδα σφαλμάτων 429 που σας κοστίζει περισσότερο χρόνο από την διαδοχική εκτέλεση. Ο σηματοφόρος (semaphore) επομένως δεν είναι προαιρετική προφύλαξη: είναι αυτό που καθιστά τον παραλληλισμό usable. Ρυθμίστε τον σύμφωνα με το όριο ρυθμού του μοντέλου, ποτέ σύμφωνα με την ικανότητα του μηχανήματός σας.

async def generate_with_limit(prompts, max_concurrent=5):
    """Δημιουργεί εικόνες με μέγιστο αριθμό παράλληλων αιτημάτων."""
    semaphore = asyncio.Semaphore(max_concurrent)

    async def limited_generate(prompt):
        async with semaphore:
            return await generate_image(prompt)

    tasks = [limited_generate(prompt) for prompt in prompts]
    return await asyncio.gather(*tasks)

Τα επίσημα φύλλα για τα grok-imagine-image και grok-imagine-image-2.0 υποδεικνύουν 6 αιτήματα ανά δευτερόλεπτο στο βασικό επίπεδο, ένα όριο που αυξάνεται με το επίπεδο της ομάδας σας έως και 100. Σημείωση: ένας σηματοφόρος περιορίζει τα ταυτόχρονα αιτήματα, όχι τον ρυθμό διέλευσης. Με max_concurrent=5, παραμένετε κάτω από 6 αιτήματα ανά δευτερόλεπτο εφόσον κάθε δημιουργία διαρκεί περισσότερο από ένα δευτερόλεπτο· αν οι αποκρίσεις φτάνουν ταχύτερα, αραιώστε και τις υποβολές. Ελέγξτε τα όρια της ομάδας σας στην κονσόλα της xAI πριν αυξήσετε την τιμή.

Πλήρης Ασύγχρονη Ροή Εργασίας

Αυτή η ροή εργασίας αλυσιδώνει τις τρεις λειτουργίες που πρέπει να συνυπάρχουν: δημιουργία, άμεση λήψη—τα URL λήγουν—και απομόνωση σφαλμάτων. Σε ένα μεγάλο πακέτο δεδομένων, αυτό το τρίτο σημείο κάνει τη διαφορά μεταξύ ενός μεμονωμένου incident και της ολικής απώλειας.

import aiohttp
import aiofiles

async def download_image(session, url, filepath):
    """Κατεβάζει μια εικόνα ασύγχρονα."""
    async with session.get(url) as resp:
        if resp.status == 200:
            async with aiofiles.open(filepath, "wb") as f:
                await f.write(await resp.read())
            return filepath
    return None

async def pipeline(prompts, output_dir="output"):
    """Πλήρης ροή εργασίας: δημιουργία + λήψη."""
    os.makedirs(output_dir, exist_ok=True)

    # Βήμα 1: δημιουργία όλων των εικόνων παράλληλα
    urls = await generate_with_limit(prompts, max_concurrent=5)

    # Βήμα 2: λήψη όλων των εικόνων παράλληλα
    async with aiohttp.ClientSession() as session:
        download_tasks = []
        for i, url in enumerate(urls):
            if url:
                # JPEG από προεπιλογή (image/jpeg), εκτός αν η ρύθμιση ποιότητας παράγει PNG
                filepath = os.path.join(output_dir, f"image_{i:03d}.jpg")
                download_tasks.append(download_image(session, url, filepath))

        saved_files = await asyncio.gather(*download_tasks)

    count = sum(1 for f in saved_files if f)
    print(f"{count}/{len(prompts)} images generated and saved")

Σύγκριση Σύγχρονης vs Ασύγχρονης Λειτουργίας

Το κέρδος υπολογίζεται θεωρητικά. Αν μια δημιουργία διαρκεί T δευτερόλεπτα, είκοσι εικόνες που ζητούνται μία μετά την άλλη διαρκούν περίπου 20 × T. Με πέντε ταυτόχρονα αιτήματα, προχωρούν σε κύματα των πέντε: περίπου 4 × T, ένα κέρδος κοντά στο πέντε, τον αριθμό των ταυτόχρονων αιτημάτων—υπό την προϋπόθεση ότι παραμένετε κάτω από το όριο ρυθμού διέλευσης. Μετρήστε το T στον δικό σας λογαριασμό πριν δεσμευτείτε για προθεσμία: οι σελίδες εικόνων της xAI δεν παρέχουν χρόνο δημιουργίας, και αυτός varies ανάλογα με το μοντέλο, την ανάλυση και το φορτίο.

Διαχείριση Σφαλμάτων

Η προεπιλεγμένη συμπεριφορά του gather είναι σκληρή: μια εξαίρεση σε μια εργασία αναβιβάζει το σφάλμα και χάνετε τα αποτελέσματα των υπολοίπων, συμπεριλαμβανομένων εκείνων που έχουν ήδη χρεωθεί. Το return_exceptions=True αλλάζει αυτό—κάθε εργασία επιστρέφει είτε το αποτέλεσμά της είτε την εξαίρεσή της, και εσείς αποφασίζετε τι θα κάνετε με τις αποτυχίες χωρίς να θυσιάσετε τις επιτυχίες.

async def safe_generate(prompt):
    """Δημιουργεί μια εικόνα με διαχείριση σφαλμάτων."""
    try:
        return await generate_image(prompt)
    except Exception as e:
        print(f"Error for '{prompt[:30]}...' : {e}")
        return None

Βασικά σημεία

  • Ο πελάτης AsyncOpenAI επιτρέπει παράλληλα αιτήματα μέσω του asyncio
  • Χρησιμοποιήστε το asyncio.gather για να εκκινήσετε πολλαπλές δημιουργίες ταυτόχρονα
  • Περιορίστε τον παραλληλισμό με έναν σηματοφόρο (semaphore) για να σεβαστείτε τα όρια ρυθμού
  • Το κέρδος πλησιάζει τον αριθμό των ταυτόχρονων αιτημάτων, εντός του επιτρεπόμενου ορίου ρυθμού διέλευσης (6 αιτήματα ανά δευτερόλεπτο στο βασικό επίπεδο)
  • Διαχειριστείτε τα σφάλματα μεμονωμένα για να αποφύγετε την απώλεια ολόκληρου του πακέτου