Prédictions

Comprendre les tâches de génération asynchrones — soumettre, interroger et récupérer les résultats

Que sont les prédictions ?

Lorsque vous soumettez une requête de génération d'image ou de vidéo à Atlas Cloud, la tâche ne se termine pas immédiatement. Au lieu de cela, vous recevez un ID de prédiction que vous pouvez utiliser pour suivre la progression de la tâche et récupérer le résultat lorsqu'il est prêt.

Ce modèle asynchrone est utilisé pour toutes les tâches de génération non-LLM (images, vidéos, etc.) car ces tâches peuvent prendre de quelques secondes à plusieurs minutes.

Cycle de vie d'une prédiction

+----------+     +-------------+     +------------+
| Soumettre| --> | Traitement  | --> | Terminé    |
| la tâche |     |             |     |            |
+----------+     +-------------+     +------------+
                       |
                       v
                 +------------+
                 |   Échoué   |
                 +------------+

Valeurs de statut :

processing — La tâche est en cours de traitement par le modèle
completed — La génération est terminée, la sortie est disponible
failed — La génération a échoué, les détails de l'erreur sont disponibles

Soumettre une tâche

Génération d'images

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["data"]["id"]
print(f"Task submitted: {prediction_id}")

Génération de vidéos

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["data"]["id"]

Interroger les résultats

Utilisez l'ID de prédiction pour vérifier le statut de la tâche et récupérer la sortie :

import requests
import time

def wait_for_result(prediction_id, api_key, interval=5, timeout=300):
    """Interroge le résultat de génération avec timeout."""
    elapsed = 0
    while elapsed < timeout:
        response = requests.get(
            f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}",
            headers={"Authorization": f"Bearer {api_key}"}
        )
        result = response.json()
        status = result["data"]["status"]

        if status == "completed":
            return result["data"]["outputs"][0]
        elif status == "failed":
            raise Exception(f"Generation failed: {result['data'].get('error')}")

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

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

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

Exemple Node.js

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/prediction/${predictionId}`,
      { headers: { Authorization: `Bearer ${apiKey}` } }
    );
    const result = await response.json();
    const status = result.data.status;

    if (status === "completed") return result.data.outputs[0];
    if (status === "failed") throw new Error(`Failed: ${result.data.error}`);

    console.log(`Status: ${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}`);

Exemple cURL

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

Bonnes pratiques de polling

Commencez avec des intervalles plus longs : Utilisez des intervalles de 5 secondes pour la génération de vidéos, de 2 secondes pour la génération d'images
Définissez un timeout : Définissez toujours un temps d'attente maximum pour éviter le polling infini
Gérez les échecs avec élégance : Vérifiez le statut failed et gérez les erreurs de manière appropriée
Journalisez la progression : Affichez les mises à jour de statut pour que les utilisateurs sachent que la tâche est toujours en cours

Temps de génération typiques

Type de tâche	Temps typique
Génération d'images	2–10 secondes
Génération de vidéos	30 secondes – 3 minutes
Image-vers-vidéo	30 secondes – 3 minutes
Outils d'image (upscale, etc.)	5–15 secondes

Les temps réels varient selon le modèle, les paramètres (résolution, durée) et la charge actuelle.

Gestion des erreurs

Lorsqu'une prédiction échoue, le résultat inclut un message d'erreur :

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

Raisons d'échec courantes :

Paramètres de modèle invalides
L'URL de l'image d'entrée est inaccessible
Le prompt contient du contenu non autorisé
Solde du compte insuffisant

Consultez la Référence API pour la documentation complète des codes d'erreur.

Sur cette page