Vorhersagen

Asynchrone Generierungsaufgaben verstehen — einreichen, pollen und Ergebnisse abrufen

Was sind Vorhersagen?

Wenn Sie eine Bild- oder Videogenerierungsanfrage an Atlas Cloud senden, wird die Aufgabe nicht sofort abgeschlossen. Stattdessen erhalten Sie eine Vorhersage-ID, mit der Sie den Fortschritt der Aufgabe verfolgen und das Ergebnis abrufen können, wenn es fertig ist.

Dieses asynchrone Muster wird für alle Nicht-LLM-Generierungsaufgaben (Bilder, Videos usw.) verwendet, da diese Aufgaben zwischen wenigen Sekunden und mehreren Minuten dauern können.

Lebenszyklus einer Vorhersage

+----------+     +-------------+     +------------+
| Aufgabe  | --> | Verarbeitung| --> | Abgeschl.  |
| einreich.|     |             |     |            |
+----------+     +-------------+     +------------+
                       |
                       v
                 +------------+
                 | Fehlgeschl.|
                 +------------+

Statuswerte:

processing — Die Aufgabe wird vom Modell verarbeitet
completed — Die Generierung ist abgeschlossen, die Ausgabe ist verfügbar
failed — Die Generierung ist fehlgeschlagen, Fehlerdetails sind verfügbar

Aufgabe einreichen

Bildgenerierung

import requests

response = requests.post(
    "https://api.atlascloud.ai/api/v1/model/generateImage",
    headers={
        "Authorization": "Bearer your-api-key",
        "Content-Type": "application/json"
    },
    json={
        "model": "seedream-3.0",
        "prompt": "A beautiful mountain landscape at golden hour"
    }
)

data = response.json()
prediction_id = data.get("predictionId")
print(f"Task submitted: {prediction_id}")

Videogenerierung

response = requests.post(
    "https://api.atlascloud.ai/api/v1/model/generateVideo",
    headers={
        "Authorization": "Bearer your-api-key",
        "Content-Type": "application/json"
    },
    json={
        "model": "kling-v2.0",
        "prompt": "Ocean waves crashing on a rocky shore at sunset"
    }
)

data = response.json()
prediction_id = data.get("predictionId")

Ergebnisse abrufen

Verwenden Sie die Vorhersage-ID, um den Aufgabenstatus zu prüfen und die Ausgabe abzurufen:

import requests
import time

def wait_for_result(prediction_id, api_key, interval=5, timeout=300):
    """Pollt auf Generierungsergebnis mit Timeout."""
    elapsed = 0
    while elapsed < timeout:
        response = requests.get(
            f"https://api.atlascloud.ai/api/v1/model/getResult?predictionId={prediction_id}",
            headers={"Authorization": f"Bearer {api_key}"}
        )
        result = response.json()
        status = result.get("status")

        if status == "completed":
            return result.get("output")
        elif status == "failed":
            raise Exception(f"Generation failed: {result.get('error')}")

        print(f"Status: {status} ({elapsed}s elapsed)")
        time.sleep(interval)
        elapsed += interval

    raise TimeoutError(f"Task did not complete within {timeout}s")

# Verwendung
output = wait_for_result("your-prediction-id", "your-api-key")
print(f"Result: {output}")

Node.js-Beispiel

async function waitForResult(predictionId, apiKey, interval = 5000, timeout = 300000) {
  const startTime = Date.now();

  while (Date.now() - startTime < timeout) {
    const response = await fetch(
      `https://api.atlascloud.ai/api/v1/model/getResult?predictionId=${predictionId}`,
      { headers: { Authorization: `Bearer ${apiKey}` } }
    );
    const result = await response.json();

    if (result.status === "completed") return result.output;
    if (result.status === "failed") throw new Error(`Failed: ${result.error}`);

    console.log(`Status: ${result.status}`);
    await new Promise((r) => setTimeout(r, interval));
  }

  throw new Error("Timeout");
}

const output = await waitForResult("your-prediction-id", "your-api-key");
console.log(`Result: ${output}`);

cURL-Beispiel

curl "https://api.atlascloud.ai/api/v1/model/getResult?predictionId=your-prediction-id" \
  -H "Authorization: Bearer your-api-key"

Best Practices für das Polling

Beginnen Sie mit längeren Intervallen: Verwenden Sie 5-Sekunden-Intervalle für die Videogenerierung, 2-Sekunden-Intervalle für die Bildgenerierung
Setzen Sie ein Timeout: Legen Sie immer eine maximale Wartezeit fest, um endloses Polling zu vermeiden
Behandeln Sie Fehler elegant: Prüfen Sie den Status failed und behandeln Sie Fehler angemessen
Protokollieren Sie den Fortschritt: Geben Sie Statusaktualisierungen aus, damit Benutzer wissen, dass die Aufgabe noch läuft

Typische Generierungszeiten

Aufgabentyp	Typische Zeit
Bildgenerierung	2–10 Sekunden
Videogenerierung	30 Sekunden – 3 Minuten
Bild-zu-Video	30 Sekunden – 3 Minuten
Bild-Tools (Hochskalierung usw.)	5–15 Sekunden

Die tatsächlichen Zeiten variieren je nach Modell, Parametern (Auflösung, Dauer) und aktueller Auslastung.

Fehlerbehandlung

Wenn eine Vorhersage fehlschlägt, enthält das Ergebnis eine Fehlermeldung:

{
  "status": "failed",
  "error": "Invalid parameter: resolution not supported by this model"
}

Häufige Fehlergründe:

Ungültige Modellparameter
Eingabebild-URL ist nicht erreichbar
Prompt enthält nicht erlaubte Inhalte
Unzureichendes Kontoguthaben

Siehe die API-Referenz für die vollständige Fehlercode-Dokumentation.

Auf dieser Seite