Skip to main content

Inférence par lot

Pour les scénarios d'inférence ne nécessitant pas de réponse en temps réel, l'inférence par lot traite de manière asynchrone de grands volumes de requêtes à 50 % du coût de l'inférence en temps réel, via une API compatible OpenAI. Elle est idéale pour les traitements par lot tels que l'évaluation de modèles et l'étiquetage des données.

Fonctionnement

  1. Soumission de la tâche : téléchargez un fichier JSONL contenant plusieurs requêtes pour créer une tâche d'inférence par lot.
  2. Traitement asynchrone : le système traite la tâche dans une file d'attente en arrière-plan. Vous pouvez consulter la progression et l'état de la tâche via la console ou l'API.
  3. Téléchargement des résultats : une fois la tâche terminée, le système génère un fichier de résultats (consignant les réponses réussies) et un fichier d'erreurs (consignant, le cas échéant, les détails des échecs).

Périmètre d'application

  • Singapour
  • Chine (Pékin)
Modèles pris en charge :
  • Modèles de génération de texte
    • Qwen Max : qwen3.8-max, qwen-max
    • Qwen Plus : qwen3.7-plus, qwen-plus
    • Qwen Flash : qwen-flash
  • Modèles multimodaux
  • Dans les scénarios Batch, qwen3.8-max, qwen3.8-flash, qwen3.7-max, qwen3.7-plus, qwen3.6-plus, qwen3.7-flash, qwen3.6-flash, qwen3.5-plus, qwen3.5-flash, qwen3.5-omni-flash et qwen3.5-omni-plus prennent en charge un maximum de 256 K tokens de contexte par requête. qwen3.5-omni-plus et qwen3.5-omni-flash ne prennent pas en charge la sortie vocale.
  • Certains modèles prennent en charge le mode réflexion. Son activation génère des tokens de réflexion, ce qui augmente les coûts.
  • Les modèles des séries qwen3.8, qwen3.7, qwen3.6 et qwen3.5 ont le mode réflexion activé par défaut. Lors de l'utilisation de modèles à réflexion hybride, il est recommandé de définir explicitement le paramètre enable_thinking (true pour activer / false pour désactiver).
  • Dans le corps de requête JSONL, enable_thinking est un paramètre de premier niveau de body et doit être transmis au même niveau que model ; il ne peut pas être placé dans extra_body.
  • Les fichiers de résultats de l'inférence par lot ne contiennent pas le champ reasoning_content. Même si enable_thinking=true est défini, choices[0].message dans le fichier de résultats ne contient que les champs content et role. Pour obtenir le contenu du processus de réflexion, utilisez des appels d'API en temps réel (en streaming ou non ; définissez simplement enable_thinking=true). Pour plus d'informations, consultez Réflexion approfondie.

Utiliser l'inférence par lot

Étape 1 : Préparer le fichier d'entrée

Avant de créer une tâche, préparez un fichier JSONL conforme aux spécifications suivantes :
  • Format : JSONL encodé en UTF-8 (un objet JSON indépendant par ligne).
  • Limites de taille : jusqu'à 50 000 requêtes et 500 Mo par fichier.
    Si votre volume de données dépasse ces limites, divisez-le en plusieurs tâches et soumettez-les séparément.
  • Limite par ligne : chaque objet JSON doit faire au maximum 1 Mo et ne doit pas dépasser la longueur de contexte du modèle.
  • Exigence de cohérence : toutes les requêtes d'un même fichier doivent utiliser le même modèle.
  • Identifiant unique : chaque requête doit inclure un champ custom_id unique au sein du fichier, utilisé pour la correspondance des résultats. custom_id accepte jusqu'à 256 caractères ; au-delà de cette limite, la validation de la tâche échoue. Pour transmettre des informations d'identifiant plus longues, utilisez un champ personnalisé de metadata lors de la création de la tâche. Pour plus d'informations, consultez Utiliser metadata pour renvoyer des identifiants personnalisés.
  • Adresses des fichiers multimédias : les fichiers multimédias référencés via des champs tels que image_url et video_url dans le body des requêtes multimodales doivent utiliser des URL accessibles publiquement. Les chemins de fichiers locaux (tels que file:///home/user/test.mp4) et les adresses intranet ne sont pas pris en charge. Les tâches créées avec de telles adresses peuvent être envoyées avec succès mais ne seront jamais traitées jusqu'à leur terme. Téléchargez d'abord les fichiers vers un stockage accessible publiquement, puis référencez leurs URL.
Chaque objet JSON doit respecter les spécifications de champs suivantes :

Champ

Type

Obligatoire

Description

custom_id

string

Oui

Identifiant unique de la requête

method

string

Oui

Méthode HTTP ; seul POST est pris en charge

url

string

Oui

Endpoint de la requête. Saisissez /v1/chat/completions pour les modèles de génération de texte et multimodaux, et /v1/embeddings pour les modèles d'embedding de texte

body

object

Oui

Corps de la requête, dont le format est identique à celui de l'API correspondant à l'url spécifiée (/v1/chat/completions ou /v1/embeddings)

Fichier d'exemple

Vous pouvez télécharger le fichier d'exemple test_model.jsonl, qui contient :
{"custom_id":"1","method":"POST","url":"/v1/chat/completions","body":{"model":"qwen-max","messages":[{"role":"system","content":"You are a helpful assistant."},{"role":"user","content":"Hello!"}]}}
{"custom_id":"2","method":"POST","url":"/v1/chat/completions","body":{"model":"qwen-max","messages":[{"role":"system","content":"You are a helpful assistant."},{"role":"user","content":"What is 2+2?"}]}}
Outil de génération de fichiers JSONL pour l'inférence par lot L'inférence par lot nécessite la construction d'un fichier JSONL dans lequel chaque ligne est une requête indépendante. Le script Python suivant peut être exécuté directement pour générer un fichier JSONL conforme au format.

Utilisation

  1. Enregistrez le code suivant sous generate_batch_jsonl.py
  2. Modifiez le contenu des requêtes dans la liste TASKS du script
  3. Exécutez python generate_batch_jsonl.py
  4. Le fichier batch_input.jsonl généré peut être utilisé directement pour les tâches d'inférence par lot
Script de génération JSONL pour les modèles de génération de texte
#!/usr/bin/env python3
"""
Batch 推理 JSONL 文件生成工具

支持的地域与模型请参见上方“适用范围”。

文件大小限制:单行 ≤6MB,总文件 ≤500MB,建议 ≤10000 行

使用方式:
  1. 修改下方 TASKS 列表
  2. 运行: python generate_batch_jsonl.py
  3. 输出: batch_input.jsonl
"""
import json

# ═══════════════════════════════════════════════════════
# 配置区:修改以下内容来生成您需要的 JSONL
# ═══════════════════════════════════════════════════════

MODEL = "qwen-max"          # 选择模型(参见上方“适用范围”)
ENABLE_THINKING = False     # 是否开启思考模式(仅部分模型支持)
THINKING_BUDGET = 50        # 思考 token 预算(思考模式下生效)

# 任务列表:每个 dict 代表一条用户消息
TASKS = [
    {"role": "user", "content": "你好!请介绍一下自己。"},
    {"role": "user", "content": "What is 2+2?"},
    {"role": "user", "content": "请用Python写一个快速排序算法"},
]

# ═══════════════════════════════════════════════════════
# 以下为生成逻辑,一般无需修改
# ═══════════════════════════════════════════════════════

def build_request(custom_id: str, model: str, messages: list,
                  enable_thinking: bool = False, thinking_budget: int = 50) -> dict:
    """构造单条 Batch 请求"""
    body = {"model": model, "messages": messages}
    if enable_thinking:
        body["enable_thinking"] = True
        body["thinking_budget"] = thinking_budget
        body["stream"] = True  # 思考模式需开启 stream
    return {
        "custom_id": custom_id,
        "method": "POST",
        "url": "/v1/chat/completions",
        "body": body
    }

def main():
    output_file = "batch_input.jsonl"
    with open(output_file, "w", encoding="utf-8") as f:
        for i, task in enumerate(TASKS, 1):
            messages = [
                {"role": "system", "content": "You are a helpful assistant."},
                task
            ]
            req = build_request(
                custom_id=f"request-{i}",
                model=MODEL,
                messages=messages,
                enable_thinking=ENABLE_THINKING,
                thinking_budget=THINKING_BUDGET
            )
            f.write(json.dumps(req, ensure_ascii=False) + "\n")
    print(f"已生成 {output_file},共 {len(TASKS)} 条请求")

if __name__ == "__main__":
    main()
Format de requête des modèles multimodaux
Le champ content des modèles multimodaux est au format tableau et contient des objets multimédias ainsi que des questions textuelles. Les URL de médias de chaque ligne de requête doivent être du même type (image, vidéo ou audio). Remplacez TASKS dans le script ci-dessus par le format suivant :
# 多模态模型配置示例

# 多模态任务:content 为数组格式
TASKS = [
    {"role": "user", "content": [
        {"type": "image_url", "image_url": {"url": "https://example.com/image1.jpg"}},
        {"type": "image_url", "image_url": {"url": "https://example.com/image2.jpg"}},
        {"type": "text", "text": "这些图描绘了什么内容?"}
    ]},
]

# {"type": "input_audio", "input_audio": {"data": "https://example.com/audio.wav", "format": "wav"}}
# {"type": "video_url", "video_url": "https://example.com/video.mp4"}

# 注意:
# - 其他多模态模型包含 system 角色,thinking_budget 设置为 50
# - 思考模式需额外设置 ENABLE_THINKING = True
Format de requête des modèles d'embedding de texte
Les modèles d'embedding de texte utilisent l'API /v1/embeddings et leur format de requête diffère de celui des modèles de génération de texte. Vous pouvez utiliser le script autonome suivant pour le générer :
#!/usr/bin/env python3
"""文本向量模型 Batch JSONL 生成(使用 /v1/embeddings 接口)"""
import json

MODEL = "text-embedding-v3"  # 向量模型,可选型号参见上方“适用范围”

TEXTS = [
    "衣服的质量杠杠的,很漂亮,不枉我等了这么久啊,喜欢,以后还来这里买。",
    "风急天高猿啸哀",
    "The quick brown fox jumps over the lazy dog",
]

output_file = "batch_embedding.jsonl"
with open(output_file, "w", encoding="utf-8") as f:
    for i, text in enumerate(TEXTS, 1):
        req = {
            "custom_id": f"emb-{i}",
            "method": "POST",
            "url": "/v1/embeddings",
            "body": {"model": MODEL, "input": text, "encoding_format": "float"}
        }
        f.write(json.dumps(req, ensure_ascii=False) + "\n")
print(f"已生成 {output_file},共 {len(TEXTS)} 条请求")

Configurer le mode de réflexion dans l'inférence par lot

Certains modèles (tels que qwen3.7-plus, qwen3.7-max ainsi que les séries qwen3.6 et qwen3.5) ont le mode réflexion activé par défaut, ce qui génère des tokens de réflexion supplémentaires. Pour configurer le mode réflexion dans l'inférence par lot, définissez le paramètre enable_thinking dans le body de chaque ligne de requête du fichier JSONL, en le plaçant au même niveau que model. Le paramètre facultatif thinking_budget permet de limiter le nombre maximal de tokens de réflexion.
enable_thinking et thinking_budget doivent être placés directement au niveau supérieur du body (au même niveau que model). Ne les insérez pas dans extra_body — extra_body est un mécanisme utilisé par le SDK Python OpenAI pour transmettre des paramètres non standard, qui ne fonctionne que lors des appels SDK en inférence en temps réel et ne s'applique pas aux fichiers JSONL d'inférence par lot.
Exemple : désactiver le mode de réflexion
{"custom_id":"request-1","method":"POST","url":"/v1/chat/completions","body":{"model":"qwen3.5-plus","enable_thinking":false,"messages":[{"role":"user","content":"你好"}]}}
Exemple : activer le mode de réflexion et limiter le budget de tokens de réflexion
{"custom_id":"request-2","method":"POST","url":"/v1/chat/completions","body":{"model":"qwen3.5-plus","enable_thinking":true,"thinking_budget":50,"messages":[{"role":"user","content":"请分析以下问题"}]}}

Étape 2 : Créer une tâche d'inférence par lot

  1. Sur la page **Inférence par lot**, cliquez sur Create Batch.
  2. Dans la boîte de dialogue qui s'affiche : saisissez le Task Name et la Task Description, définissez le Maximum Waiting Time (1 à 14 jours), puis chargez un fichier JSONL.
    Vous pouvez cliquer sur Download Sample File pour obtenir un modèle.
  3. Une fois le formulaire rempli, cliquez sur Confirm.

Étape 3 : Surveiller et gérer les tâches

  • Consultation :
    • Sur la page des tâches, consultez la progression (nombre de requêtes traitées / nombre total de requêtes) et le statut d'une tâche.
    • Recherchez par nom ou ID de tâche, ou filtrez par espace de travail pour localiser rapidement la tâche souhaitée.
  • Gestion :
    • Annulation : les tâches à l'état « Running » peuvent être annulées depuis la colonne Actions.

Étape 4 : Télécharger les résultats

Les tâches sont automatiquement supprimées 30 jours après leur achèvement. Téléchargez les résultats en temps utile.
Une fois la tâche terminée, cliquez sur View Results pour télécharger les fichiers de sortie :
  • Fichier de résultats : consigne toutes les requêtes réussies ainsi que leurs résultats response.
  • Fichier d'erreurs (le cas échéant) : consigne toutes les requêtes ayant échoué ainsi que leurs détails error.
Ces deux fichiers contiennent le champ custom_id, utilisé pour faire correspondre les données d'entrée d'origine, associer les résultats ou localiser les erreurs.

Étape 5 : Consulter les statistiques d'utilisation (facultatif)

Sur la page Monitoring, filtrez et consultez les statistiques d'utilisation de l'inférence par lot.
  • Consulter la vue d'ensemble des données : sélectionnez une période (jusqu'à 30 jours), définissez Inference Type sur Batch Inference, et vous pourrez consulter :
    • Données de surveillance : statistiques récapitulatives de tous les modèles sur la période sélectionnée, telles que le nombre total d'appels et le nombre total d'échecs.
    • Modèles : données détaillées de chaque modèle, telles que le nombre total d'appels, le taux d'échec et la durée moyenne d'appel.
    Pour consulter des données d'inférence de plus de 30 jours, accédez à la page Bill.
  • Consulter les détails d'un modèle : dans la liste Modèles, cliquez sur Monitoring dans la colonne Actions du modèle souhaité pour afficher les détails des statistiques d'appels (telles que le nombre d'appels et le volume d'appels).
    image
  • Les données d'appel de l'inférence par lot sont comptabilisées sur la base de l'heure de fin de la tâche. Pour les tâches en cours d'exécution, les informations d'appel ne peuvent pas être consultées tant que la tâche n'est pas terminée.
  • Les données de surveillance présentent un délai de 1 à 2 heures.

Utiliser metadata pour renvoyer des identifiants personnalisés

custom_id accepte jusqu'à 256 caractères. Pour renvoyer des informations d'identifiant plus longues dans le fichier de résultats, vous pouvez utiliser les champs personnalisés de metadata.

Champs de metadata

metadata est un paramètre facultatif lors de la création d'une tâche Batch et prend en charge les champs suivants :
  • ds_name : nom de la tâche. Une fois défini, il s'affiche dans la colonne Task Name de la console.
  • ds_description : description de la tâche. Une fois définie, elle s'affiche dans la colonne Task Description de la console.
  • Champs personnalisés : en plus des champs officiels ci-dessus, metadata prend également en charge des champs personnalisés arbitraires, dont les valeurs ne sont pas soumises à la limite de 256 caractères. Lors de la consultation des détails d'une tâche, tous les champs personnalisés sont renvoyés intégralement.

Exemple de code

L'exemple suivant montre comment renvoyer des informations d'identifiant de plus de 256 caractères via les champs personnalisés de metadata :
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

batch = client.batches.create(
    input_file_id="file-batch-xxxxxxxxxxxxxxxxxxxx",
    endpoint="/v1/chat/completions",
    completion_window="24h",
    metadata={
        "ds_name": "my_batch_task",
        "ds_description": "批量推理任务描述",
        "my_custom_field": "此字段的值可以超过256个字符,用于回传更长的标识信息..."
    }
)
print(batch)
Après la création de la tâche, vous pouvez appeler l'API de consultation des détails de la tâche (GET /v1/batches/{batch_id}) pour obtenir les informations metadata complètes, y compris tous les champs personnalisés et leur contenu intégral.

Référence API

En environnement de production, utilisez les API compatibles OpenAI pour créer et gérer automatiquement des tâches Batch. Le flux de travail principal est le suivant :
L'inférence par lot ne prend en charge que les appels API au format compatible OpenAI. Lorsque vous utilisez le SDK Python OpenAI, définissez base_url sur https://dashscope.aliyuncs.com/compatible-mode/v1. Le SDK Python DashScope (le package dashscope) ne fournit pas d'interfaces d'inférence par lot ; les tâches d'inférence par lot ne peuvent donc pas être soumises via dashscope.BatchInference, dashscope.Batches ou des méthodes similaires.
Exemple :
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
batch = client.batches.create(
    input_file_id=file_id,
    endpoint="/v1/chat/completions",
    completion_window="24h",
)
  1. Charger le fichier Appelez POST /v1/files pour charger le fichier et notez l'ID de fichier renvoyé.
  2. Créer la tâche Transmettez l'ID du fichier et appelez POST /v1/batches pour créer une tâche, puis notez le batch_id renvoyé.
  3. Interroger l'état Utilisez batch_id pour interroger GET /v1/batches/{batch_id}. Lorsque status passe à completed, notez output_file_id et arrêtez l'interrogation.
  4. Télécharger les résultats Utilisez output_file_id pour appeler GET /v1/files/{output_file_id}/content et télécharger le fichier de résultats.
Pour consulter les définitions complètes de l'API Batch et des exemples de code, reportez-vous à Batch compatible OpenAI (entrée par fichier).

Cycle de vie d'une tâche

Statut

Description

validating (Vérification)

Le système valide le format du fichier (spécification JSONL) ainsi que la validité du format API de chaque ligne de requête.

in_progress (En cours)

Le fichier a passé la validation et le système a commencé à traiter les requêtes d'inférence ligne par ligne.

finalizing (En cours)

Toutes les requêtes ont été traitées et les résultats sont en cours d'écriture dans le fichier de résultats et le fichier d'erreurs. Dans la liste des tâches de la console, cette étape partage le libellé d'état Running avec in_progress et ne dispose d'aucun texte d'affichage distinct.

completed (Terminé)

Le fichier de résultats et le fichier d'erreurs ont été écrits et sont prêts à être téléchargés.

failed

La tâche a échoué pendant l'étape validating, généralement en raison d'erreurs au niveau du fichier (format JSONL invalide ou fichier trop volumineux). Dans cet état, aucune requête d'inférence n'est exécutée et aucun fichier de résultats n'est généré.

expired

La durée d'exécution de la tâche a dépassé le temps d'attente maximal défini lors de la création et la tâche a été interrompue par le système. Lors de la création d'une nouvelle tâche, il est recommandé de définir un temps d'attente plus long.

cancelled

L'utilisateur annule la tâche et les requêtes dont le traitement n'a pas commencé sont interrompues.

Détails de facturation

  • Prix unitaire de facturation : pour toutes les requêtes réussies, le prix unitaire des tokens d'entrée et de sortie est de 50 % du prix de l'inférence en temps réel du modèle correspondant. Pour plus d'informations, consultez Modèles.
  • Périmètre de facturation :
    • Seules les requêtes exécutées avec succès dans la tâche sont facturées.
    • Les échecs d'analyse de fichier, les échecs d'exécution de tâche ou les requêtes erronées au niveau de la ligne n'entraînent aucun frais.
    • Pour les tâches annulées, les requêtes achevées avec succès avant l'annulation sont toujours facturées normalement.
  • L'inférence par lot est un poste de facturation indépendant. Elle prend en charge le Plan d'économies universel IA, mais ne prend pas en charge les remises telles que le paiement anticipé (savings plan) et le quota gratuit pour nouveaux utilisateurs, ni les fonctionnalités telles que le cache de contexte.
  • Certains modèles (tels que qwen3.7-plus, qwen3.7-max ainsi que les séries qwen3.6 et qwen3.5) ont le mode réflexion activé par défaut, ce qui génère des tokens de réflexion supplémentaires facturés au prix des tokens de sortie, augmentant ainsi les coûts. Il est recommandé de définir le paramètre enable_thinking en fonction de la complexité de la tâche pour maîtriser les coûts. Pour plus d'informations, consultez Réflexion approfondie.

FAQ

  1. Dois-je effectuer un achat ou une activation supplémentaire pour utiliser l'inférence par lot ? Non. Vous pouvez l'utiliser dès l'activation d'Alibaba Cloud Model Studio, et les frais sont déduits du solde de votre compte selon le modèle du paiement à l'utilisation.
  2. Pourquoi une tâche échoue-t-elle immédiatement après sa soumission (le statut passe à failed) ? Cela est généralement dû à des erreurs au niveau du fichier, et la tâche n'a exécuté aucune requête d'inférence. Dépannez dans l'ordre suivant :
    • Format du fichier : est-ce un format JSONL strict, avec un objet JSON complet par ligne ?
    • Taille du fichier : la taille du fichier, le nombre de lignes, etc. dépassent-ils les limites ? Pour plus d'informations, consultez Préparer le fichier d'entrée.
    • Cohérence du modèle : vérifiez que le champ body.model de toutes les requêtes du fichier est strictement identique et que les modèles utilisés sont pris en charge dans la région actuelle.
  3. Combien de temps prend le traitement d'une tâche ? Le temps de traitement dépend principalement de la charge du système au moment de la soumission. Lorsque le système est occupé, les tâches peuvent devoir être mises en file d'attente, mais les résultats, qu'ils soient un succès ou un échec, seront renvoyés dans le temps d'attente maximal défini.

Codes d'erreur

Si un appel échoue et renvoie un message d'erreur, consultez Codes d'erreur pour le dépannage.