Skip to main content

Compatible OpenAI - Batch (entrée fichier)

Alibaba Cloud Model Studio propose une API Batch File compatible OpenAI permettant d'envoyer des requêtes en masse via des fichiers. Le système traite toutes les requêtes de manière asynchrone et renvoie les résultats une fois toutes les requêtes terminées ou lorsque le délai d'attente maximal est atteint. Les frais représentent seulement 50 % de ceux des appels en temps réel. Cela convient aux scénarios tels que l'analyse de données et l'évaluation de modèles, peu sensibles au temps mais nécessitant un traitement à grande échelle.

Pour utiliser la console, consultez Inférence par lots.

Flux de travail

image

Prérequis

Vous pouvez appeler l'API Batch File via le SDK OpenAI (Python, Node.js) ou l'API HTTP.

Périmètre

  • 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 256K 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. Lorsqu'il est activé, des tokens de réflexion sont générés, 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 d'un modèle à réflexion hybride, nous recommandons 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.

Prise en main

Avant de traiter des tâches de production, utilisez le modèle de test batch-test-model pour un test de bout en bout. Ce modèle ignore le processus d'inférence et renvoie directement une réponse de succès fixe, qui sert à vérifier que la chaîne d'appels API et le format des données sont corrects.
Limites du modèle de test (batch-test-model) :
  • Les fichiers de test doivent respecter les exigences relatives au fichier d'entrée, avec une taille de fichier ne dépassant pas 1 Mo et pas plus de 100 lignes.
  • Limite de concurrence : jusqu'à 2 tâches simultanées.
  • Frais : le modèle de test n'entraîne pas de frais d'inférence de modèle.

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

Préparez un fichier nommé test_model.jsonl avec le contenu suivant :
{"custom_id":"1","method":"POST","url":"/v1/chat/ds-test","body":{"model":"batch-test-model","messages":[{"role":"system","content":"You are a helpful assistant."},{"role":"user","content":"你好!有什么可以帮助你的吗?"}]}}
{"custom_id":"2","method":"POST","url":"/v1/chat/ds-test","body":{"model":"batch-test-model","messages":[{"role":"system","content":"You are a helpful assistant."},{"role":"user","content":"What is 2+2?"}]}}
Entrée via encodage Base64 :

Étape 2 : Exécuter le code

Selon le langage de programmation que vous utilisez, sélectionnez l'un des exemples de code suivants, enregistrez-le dans le même répertoire que le fichier d'entrée, puis exécutez-le. Le code couvre le flux de travail complet : téléchargement du fichier, création de la tâche, interrogation de l'état et téléchargement des résultats.
Pour modifier le chemin du fichier ou d'autres paramètres, adaptez le code selon vos besoins.
Réutiliser un ID de fichier existant : L'ID renvoyé après le téléchargement du fichier (par exemple file-batch-xxx) peut être réutilisé. Si le contenu d'entrée est inchangé, il n'est pas nécessaire de le télécharger à nouveau à chaque fois ; vous pouvez directement créer une tâche avec l'ID existant :
batch = client.batches.create(
    input_file_id="file-batch-xxx",  # 直接使用已有文件 ID,无需重新上传
    endpoint="/v1/chat/completions",
    completion_window="24h"
)
Vous pouvez interroger les ID de fichiers Batch téléchargés via l'API client.files.list(purpose="batch").
OpenAI Python SDK
import os
from pathlib import Path
from openai import OpenAI
import time

# 初始化客户端
client = OpenAI(
    # 若没有配置环境变量,可用阿里云百炼API Key将下行替换为:api_key="sk-xxx",但不建议在生产环境中直接将API Key硬编码到代码中,以减少API Key泄露风险。
    # 新加坡和北京地域的API Key不同。
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # 以下是新加坡地域的base_url,如果使用北京地域的模型,需要将base_url替换为:https://dashscope.aliyuncs.com/compatible-mode/v1
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1"  # 阿里云百炼服务的base_url
)

def upload_file(file_path):
    print(f"正在上传包含请求信息的JSONL文件...")
    file_object = client.files.create(file=Path(file_path), purpose="batch")
    print(f"文件上传成功。得到文件ID: {file_object.id}\n")
    return file_object.id

def create_batch_job(input_file_id):
    print(f"正在基于文件ID,创建Batch任务...")
    # 请注意:此处endpoint参数值需和输入文件中的url字段保持一致.测试模型(batch-test-model)填写/v1/chat/ds-test,Embedding文本向量模型填写/v1/embeddings,其他模型填写/v1/chat/completions
    batch = client.batches.create(input_file_id=input_file_id, endpoint="/v1/chat/ds-test", completion_window="24h")
    print(f"Batch任务创建完成。 得到Batch任务ID: {batch.id}\n")
    return batch.id

def check_job_status(batch_id):
    print(f"正在检查Batch任务状态...")
    batch = client.batches.retrieve(batch_id=batch_id)
    print(f"Batch任务状态: {batch.status}\n")
    return batch.status

def get_output_id(batch_id):
    print(f"正在获取Batch任务中执行成功请求的输出文件ID...")
    batch = client.batches.retrieve(batch_id=batch_id)
    print(f"输出文件ID: {batch.output_file_id}\n")
    return batch.output_file_id

def get_error_id(batch_id):
    print(f"正在获取Batch任务中执行错误请求的输出文件ID...")
    batch = client.batches.retrieve(batch_id=batch_id)
    print(f"错误文件ID: {batch.error_file_id}\n")
    return batch.error_file_id

def download_results(output_file_id, output_file_path):
    print(f"正在打印并下载Batch任务的请求成功结果...")
    content = client.files.content(output_file_id)
    # 打印部分内容以供测试
    print(f"打印请求成功结果的前1000个字符内容: {content.text[:1000]}...\n")
    # 保存结果文件至本地
    content.write_to_file(output_file_path)
    print(f"完整的输出结果已保存至本地输出文件result.jsonl\n")

def download_errors(error_file_id, error_file_path):
    print(f"正在打印并下载Batch任务的请求失败信息...")
    content = client.files.content(error_file_id)
    # 打印部分内容以供测试
    print(f"打印请求失败信息的前1000个字符内容: {content.text[:1000]}...\n")
    # 保存错误信息文件至本地
    content.write_to_file(error_file_path)
    print(f"完整的请求失败信息已保存至本地错误文件error.jsonl\n")

def main():
    # 文件路径
    input_file_path = "test_model.jsonl"  # 可替换为您的输入文件路径
    output_file_path = "result.jsonl"  # 可替换为您的输出文件路径
    error_file_path = "error.jsonl"  # 可替换为您的错误文件路径
    try:
        # Step 1: 上传包含请求信息的JSONL文件,得到输入文件ID
        input_file_id = upload_file(input_file_path)
        # Step 2: 基于输入文件ID,创建Batch任务
        batch_id = create_batch_job(input_file_id)
        # Step 3: 检查Batch任务状态直到结束
        status = ""
        while status not in ["completed", "failed", "expired", "cancelled"]:
            status = check_job_status(batch_id)
            print(f"等待任务完成...")
            time.sleep(10)  # 等待10秒后再次查询状态
        # 如果任务失败,则打印错误信息并退出
        if status == "failed":
            batch = client.batches.retrieve(batch_id)
            print(f"Batch任务失败。错误信息为:{batch.errors}\n")
            print(f"参见错误码文档: https://www.alibabacloud.com/help/model-studio/developer-reference/error-code")
            return
        # Step 4: 下载结果:如果输出文件ID不为空,则打印请求成功结果的前1000个字符内容,并下载完整的请求成功结果到本地输出文件;
        # 如果错误文件ID不为空,则打印请求失败信息的前1000个字符内容,并下载完整的请求失败信息到本地错误文件.
        output_file_id = get_output_id(batch_id)
        if output_file_id:
            download_results(output_file_id, output_file_path)
        error_file_id = get_error_id(batch_id)
        if error_file_id:
            download_errors(error_file_id, error_file_path)
            print(f"参见错误码文档: https://www.alibabacloud.com/help/model-studio/developer-reference/error-code")
    except Exception as e:
        print(f"An error occurred: {e}")
        print(f"参见错误码文档: https://www.alibabacloud.com/help/model-studio/developer-reference/error-code")

if __name__ == "__main__":
    main()

Étape 3 : Vérifier le résultat du test

Une fois la tâche terminée avec succès, le fichier de résultats result.jsonl contient la réponse fixe {"content":"This is a test result."} :
{"id":"a2b1ae25-21f4-4d9a-8634-99a29926486c","custom_id":"1","response":{"status_code":200,"request_id":"a2b1ae25-21f4-4d9a-8634-99a29926486c","body":{"created":1743562621,"usage":{"completion_tokens":6,"prompt_tokens":20,"total_tokens":26},"model":"batch-test-model","id":"chatcmpl-bca7295b-67c3-4b1f-8239-d78323bb669f","choices":[{"finish_reason":"stop","index":0,"message":{"content":"This is a test result."}}],"object":"chat.completion"}},"error":null}
{"id":"39b74f09-a902-434f-b9ea-2aaaeebc59e0","custom_id":"2","response":{"status_code":200,"request_id":"39b74f09-a902-434f-b9ea-2aaaeebc59e0","body":{"created":1743562621,"usage":{"completion_tokens":6,"prompt_tokens":20,"total_tokens":26},"model":"batch-test-model","id":"chatcmpl-1e32a8ba-2b69-4dc4-be42-e2897eac9e84","choices":[{"finish_reason":"stop","index":0,"message":{"content":"This is a test result."}}],"object":"chat.completion"}},"error":null}

Exécuter des tâches formelles

Exigences relatives au fichier d'entrée

  • Format : JSONL encodé en UTF-8 (un objet JSON indépendant par ligne)
  • Limites de taille : Au plus 50 000 requêtes par fichier, et pas plus de 500 Mo
  • Limites par ligne : Chaque objet JSON ne doit pas dépasser 6 Mo et ne doit pas dépasser la longueur de contexte du modèle
  • Exigences de cohérence : Toutes les requêtes d'un même fichier doivent utiliser le même modèle et le même mode réflexion (le cas échéant)
  • Identifiant unique : Chaque requête doit contenir un champ custom_id unique dans le fichier, utilisé pour faire correspondre les requêtes et les résultats
Scénario 1 : conversation texte Exemple de contenu de fichier :
{"custom_id":"1","method":"POST","url":"/v1/chat/completions","body":{"model":"qwen-plus","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-plus","messages":[{"role":"system","content":"You are a helpful assistant."},{"role":"user","content":"What is 2+2?"}]}}
Scénario 2 : compréhension d'images et de vidéos Méthode d'entrée par encodage Base64.
Les chaînes Base64 des exemples ont été omises ; utilisez le code Python ci-dessous pour générer l'encodage complet.
  1. Convertissez le fichier local en encodage Base64 :
#  编码函数: 将本地文件转换为 Base64 编码的字符串
import base64
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

# 将xxxx/eagle.png替换为你本地图像的绝对路径
base64_image = encode_image("xxx/eagle.png")
  1. Construisez le format Data URL : data:[MIME_type];base64,{base64_image};
    1. MIME_type doit être remplacé par le type de média réel, en veillant à ce qu'il corresponde à la valeur de MIME Type (par exemple, image/jpeg, image/png) ;
    2. base64_image est la chaîne Base64 générée à l'étape précédente.
Pour plus de détails (notamment les limites de fichiers, les types MIME et les méthodes d'encodage), consultez Transmettre des fichiers locaux (encodage Base64 ou chemin de fichier).
Outil de génération de fichiers JSONL pour l'inférence par lots L'inférence par lots nécessite la construction d'un fichier JSONL, chaque ligne étant 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 de la liste TASKS dans le 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 lots

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 pour les modèles multimodaux

Pour les modèles multimodaux, le champ content est au format tableau, contenant des objets média et des invites textuelles. Les URL de média 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 pour les 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)} 条请求")

1. Modifiez le fichier d'entrée

  • Vous pouvez directement modifier le fichier test_model.jsonl utilisé pour les tests, définir le paramètre model sur le modèle formel cible, et définir le champ URL :

    Type de modèle

    url

    Modèles de génération de texte/multimodaux

    /v1/chat/completions

    Modèles d'embedding de texte

    /v1/embeddings

  • Vous pouvez également utiliser l'« outil de génération JSONL par lots » ci-dessus pour générer un nouveau fichier pour la tâche formelle. L'essentiel est de veiller à ce que les champs model et url soient corrects.

2. Modifiez le code de prise en main

  1. Remplacez le chemin du fichier d'entrée par le nom de votre fichier
  2. Modifiez la valeur du paramètre endpoint pour qu'elle corresponde au champ url du fichier d'entrée

3. Exécutez le code et attendez les résultats

Une fois la tâche terminée, les résultats des requêtes réussies sont enregistrés dans le fichier local result.jsonl. Si une requête échoue, les détails de l'erreur sont enregistrés dans le fichier error.jsonl.
  • Résultats réussis (output_file_id) : chaque ligne correspond à une requête d'origine réussie, contenant custom_id et response.
{"id":"3a5c39d5-3981-4e4c-97f2-e0e821893f03","custom_id":"req-001","response":{"status_code":200,"request_id":"3a5c39d5-3981-4e4c-97f2-e0e821893f03","body":{"created":1768306034,"usage":{"completion_tokens":654,"prompt_tokens":14,"total_tokens":668},"model":"qwen-plus","id":"chatcmpl-3a5c39d5-3981-4e4c-97f2-e0e821893f03","choices":[{"finish_reason":"stop","index":0,"message":{"role":"assistant","content":"你好!杭州西湖是中国著名的风景名胜区,位于浙江省杭州市西部,因此得名“西湖”。它是中国十大风景名胜之一,也是世界文化遗产(2011年被联合国教科文组织列入《世界遗产名录》),以其秀丽的自然风光与深厚的人文底蕴闻名于世。\n\n### 一、自然景观\n西湖三面环山,一面邻城,湖面面积约6.39平方公里,形似如意,碧波荡漾。湖中被孤山、白堤、苏堤、杨公堤等自然或人工分隔成多个水域,形成“一山二塔三岛三堤”的格局。\n\n主要景点包括:\n- **苏堤春晓**:北宋大文豪苏东坡任杭州知州时主持疏浚西湖,用挖出的淤泥堆筑成堤,后人称为“苏堤”。春天桃红柳绿,景色如画。\n- **断桥残雪**:位于白堤东端,是白蛇传中“断桥相会”的发生地,冬日雪后银装素裹,尤为著名。\n- **雷峰夕照**:雷峰塔在夕阳映照下金光熠熠,曾是“西湖十景”之一。\n- **三潭印月**:湖中小瀛洲上的三座石塔,中秋夜可在塔内点灯,月影、灯光、湖光交相辉映。\n- **平湖秋月**:位于白堤西端,是观赏湖上明月的绝佳地点。\n- **花港观鱼**:以赏花和观鱼著称,园内牡丹、锦鲤相映成趣。\n\n### 二、人文历史\n西湖不仅风景优美,还承载着丰富的历史文化:\n- 自唐宋以来,众多文人墨客如白居易、苏东坡、林逋、杨万里等在此留下诗篇。\n- 白居易曾主持修建“白堤”,疏浚西湖,造福百姓。\n- 西湖周边有众多古迹,如岳王庙(纪念民族英雄岳飞)、灵隐寺(千年古刹)、六和塔、龙井村(中国十大名茶龙井茶的产地)等。\n\n### 三、文化象征\n西湖被誉为“人间天堂”的代表,是中国传统山水美学的典范。它融合了自然美与人文美,体现了“天人合一”的哲学思想。许多诗词、绘画、戏曲都以西湖为题材,成为中国文化的重要符号。\n\n### 四、旅游建议\n- 最佳游览季节:春季(3-5月)桃红柳绿,秋季(9-11月)天高气爽。\n- 推荐方式:步行、骑行(环湖绿道)、乘船游湖。\n- 周边美食:西湖醋鱼、龙井虾仁、东坡肉、片儿川等。\n\n总之,杭州西湖不仅是一处自然美景,更是一座活着的文化博物馆,值得细细品味。如果你有机会到杭州,一定不要错过这个“淡妆浓抹总相宜”的人间仙境。"}}],"object":"chat.completion"}},"error":null}
{"id":"628312ba-172c-457d-ba7f-3e5462cc6899","custom_id":"req-002","response":{"status_code":200,"request_id":"628312ba-172c-457d-ba7f-3e5462cc6899","body":{"created":1768306035,"usage":{"completion_tokens":25,"prompt_tokens":18,"total_tokens":43},"model":"qwen-plus","id":"chatcmpl-628312ba-172c-457d-ba7f-3e5462cc6899","choices":[{"finish_reason":"stop","index":0,"message":{"role":"assistant","content":"春风拂柳绿,  \n夜雨润花红。  \n鸟语林间闹,  \n山川处处同。"}}],"object":"chat.completion"}},"error":null}
  • Détails des requêtes échouées (error_file_id) : contiennent les informations des lignes de requête dont le traitement a échoué ainsi que les causes des erreurs. Consultez les codes d'erreur pour le dépannage.

Procédure détaillée

Le flux de travail de l'API Batch se compose de quatre étapes : téléchargement des fichiers, création des tâches, interrogation de l'état des tâches et téléchargement des résultats.
Avant de créer une tâche Batch, téléchargez un fichier JSONL conforme aux exigences de format via l'API de téléchargement de fichiers pour obtenir le file_id.
Lors du téléchargement d'un fichier, purpose doit être batch.
Réutiliser un ID de fichier existant : L'ID renvoyé après le téléchargement du fichier (par exemple file-batch-xxx) peut être réutilisé. Si le contenu d'entrée est inchangé, il n'est pas nécessaire de le télécharger à nouveau à chaque fois ; vous pouvez directement créer une tâche avec l'ID existant :
batch = client.batches.create(
    input_file_id="file-batch-xxx",  # 直接使用已有文件 ID,无需重新上传
    endpoint="/v1/chat/completions",
    completion_window="24h"
)
Vous pouvez interroger les ID de fichiers Batch téléchargés via l'API client.files.list(purpose="batch").
  • OpenAI Python SDK
  • OpenAI Node.js SDK
  • Java(HTTP)
  • curl(HTTP)

Exemple de requête

import os
from pathlib import Path
from openai import OpenAI

client = OpenAI(
    # 若没有配置环境变量,可用阿里云百炼API Key将下行替换为:api_key="sk-xxx"。但不建议在生产环境中直接将API Key硬编码到代码中,以减少API Key泄露风险。
    # 新加坡和北京地域的API Key不同。
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # 以下是新加坡地域base_url,如果使用北京地域的模型,需要将base_url替换为:https://dashscope.aliyuncs.com/compatible-mode/v1
    # 注意:切换地域时,API Key也需要对应更换
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

# test.jsonl 是一个本地示例文件,purpose必须是batch
file_object = client.files.create(file=Path("test.jsonl"), purpose="batch")

print(file_object.model_dump_json())

Exemple de réponse

{
    "id": "file-batch-xxx",
    "bytes": 437,
    "created_at": 1742304153,
    "filename": "test.jsonl",
    "object": "file",
    "purpose": "batch",
    "status": "processed",
    "status_details": null
}
Créez une tâche Batch à l'aide de l'ID de fichier renvoyé par le téléchargement.
  • OpenAI Python SDK
  • OpenAI Node.js SDK
  • Java(HTTP)
  • curl(HTTP)

Exemple de requête

import os
from openai import OpenAI

client = OpenAI(
    # 若没有配置环境变量,可用阿里云百炼API Key将下行替换为:api_key="sk-xxx"。但不建议在生产环境中直接将API Key硬编码到代码中,以减少API Key泄露风险。
    # 新加坡和北京地域的API Key不同。
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # 以下是新加坡地域base_url,如果使用北京地域的模型,需要将base_url替换为:https://dashscope.aliyuncs.com/compatible-mode/v1
    # 注意:切换地域时,API Key也需要对应更换
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

batch = client.batches.create(
    input_file_id="file-batch-xxx",  # 上传文件返回的id
    endpoint="/v1/chat/completions",  # # 测试模型batch-test-model填写/v1/chat/ds-test,文本向量模型填写/v1/embeddings,文本生成/多模态模型填写/v1/chat/completions
    completion_window="24h",
    metadata={'ds_name':"任务名称",'ds_description':'任务描述'} # metadata数据,非必填字段,用于创建任务名称、描述
)
print(batch)

Paramètres d'entrée

Champ

Type

Méthode de transmission

des paramètres

Obligatoire

Description

input_file_id

String

Body

Oui

Spécifie l'ID du fichier utilisé comme fichier d'entrée pour la tâche Batch.

Utilisez l'ID de fichier renvoyé par l'interface Préparer et télécharger des fichiers, par exemple file-batch-xxx.

endpoint

String

Body

Oui

Chemin d'accès, qui doit correspondre au champ URL du fichier d'entrée.

  • Pour le modèle de test batch-test-model, saisissez /v1/chat/ds-test

  • Pour les autres modèles, saisissez /v1/chat/completions

completion_window

String

Body

Oui

Délai d'attente, minimum 24h et maximum 336h ; seuls les entiers sont pris en charge.

Prend en charge deux unités : « h » et « d », par exemple « 24h » ou « 14d ».

metadata

Map

Body

Non

Métadonnées d'extension de tâche permettant d'associer des informations supplémentaires sous forme de paires clé-valeur.

metadata.ds_name

String

Body

Non

Nom de la tâche.

Exemple : "ds_name": "Batch task"

Limite : jusqu'à 100 caractères.

Si ce champ est défini plusieurs fois, la dernière valeur transmise prévaut.

metadata.ds_description

String

Body

Non

Description de la tâche.

Exemple : "ds_description": "Batch inference task test"

Limite : jusqu'à 200 caractères.

Si ce champ est défini plusieurs fois, la dernière valeur transmise prévaut.

Exemple de réponse

{
    "id": "batch_xxx",
    "object": "batch",
    "endpoint": "/v1/chat/completions",
    "errors": null,
    "input_file_id": "file-batch-xxx",
    "completion_window": "24h",
    "status": "validating",
    "output_file_id": null,
    "error_file_id": null,
    "created_at": 1742367779,
    "in_progress_at": null,
    "expires_at": null,
    "finalizing_at": null,
    "completed_at": null,
    "failed_at": null,
    "expired_at": null,
    "cancelling_at": null,
    "cancelled_at": null,
    "request_counts": {
        "total": 0,
        "completed": 0,
        "failed": 0
    },
    "metadata": {
        "ds_name": "任务名称",
        "ds_description": "任务描述"
    }
}

Paramètres de réponse

Champ

Type

Description

id

String

L'ID de la tâche Batch créée cette fois.

object

String

Le type d'objet, avec une valeur fixe de batch.

endpoint

String

Le chemin d'accès.

errors

Map

Le message d'erreur.

input_file_id

String

L'ID du fichier.

completion_window

String

Le délai d'attente. Le délai d'attente minimum est de 24h et le maximum de 336h ; seuls les entiers sont pris en charge.

Prend en charge deux unités : « h » et « d », par exemple « 24h » ou « 14d ».

status

String

L'état de la tâche. Valeurs possibles : validating, failed, in_progress, finalizing, completed, expired, cancelling, cancelled.

output_file_id

String

L'ID du fichier de sortie des requêtes réussies.

error_file_id

String

L'ID du fichier d'erreur des requêtes échouées.

created_at

Integer

Horodatage Unix (en secondes) de la création de la tâche.

in_progress_at

Integer

Horodatage Unix (en secondes) du début d'exécution de la tâche.

expires_at

Integer

Horodatage Unix (en secondes) de l'expiration prévue de la tâche.

finalizing_at

Integer

Horodatage Unix (en secondes) du début d'agrégation des résultats de la tâche.

completed_at

Integer

Horodatage Unix (en secondes) de la fin de la tâche.

failed_at

Integer

Horodatage Unix (en secondes) de l'échec de la tâche.

expired_at

Integer

Horodatage Unix (en secondes) de l'expiration de la tâche.

cancelling_at

Integer

Horodatage Unix (en secondes) du début d'annulation de la tâche.

cancelled_at

Integer

Horodatage Unix (en secondes) de la fin d'annulation de la tâche.

request_counts

Map

Statistiques du nombre de requêtes par état.

metadata

Map

Métadonnées supplémentaires sous forme de paires clé-valeur.

metadata.ds_name

String

Nom de la tâche.

metadata.ds_description

String

Description de la tâche.

Après la création d'une tâche, vous pouvez utiliser les opérations API suivantes pour interroger son état, lister les tâches historiques ou annuler des tâches en cours.
Transmettez un ID de tâche Batch pour interroger les détails d'une tâche spécifiée. Actuellement, seules les tâches Batch créées au cours des 30 derniers jours peuvent être interrogées.
  • OpenAI Python SDK
  • OpenAI Node.js SDK
  • Java(HTTP)
  • curl(HTTP)

Exemple de requête

import os
from openai import OpenAI

client = OpenAI(
    # 若没有配置环境变量,可用阿里云百炼API Key将下行替换为:api_key="sk-xxx"。但不建议在生产环境中直接将API Key硬编码到代码中,以减少API Key泄露风险。
    # 新加坡和北京地域的API Key不同。
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # 以下是新加坡地域base_url,如果使用北京地域的模型,需要将base_url替换为:https://dashscope.aliyuncs.com/compatible-mode/v1
    # 注意:切换地域时,API Key也需要对应更换
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)
batch = client.batches.retrieve("batch_id")  # 将batch_id替换为Batch任务的id
print(batch)

Exemple de réponse

Après une requête réussie, les détails de la tâche Batch sont renvoyés. Voici un exemple de réponse pour une tâche à l'état terminé :
{
  "id": "batch_abc123",
  "object": "batch",
  "endpoint": "/v1/chat/completions",
  "errors": null,
  "input_file_id": "file-abc123",
  "completion_window": "24h",
  "status": "completed",
  "output_file_id": "file-batch_output-xyz789",
  "error_file_id": "file-batch_error-xyz789",
  "created_at": 1711402400,
  "in_progress_at": 1711402450,
  "expires_at": 1711488800,
  "finalizing_at": 1711405000,
  "completed_at": 1711406000,
  "failed_at": null,
  "expired_at": null,
  "cancelling_at": null,
  "cancelled_at": null,
  "request_counts": {
    "total": 100,
    "completed": 95,
    "failed": 5
  },
  "metadata": {
    "customer_id": "user_123456789",
    "batch_description": "Nightly eval job"
  }
}
L'objet JSON renvoyé contient les informations complètes de la tâche Batch, notamment l'état de la tâche, l'ID du fichier de sortie, les statistiques de requêtes, etc. Voir le tableau ci-dessous pour la description des champs.

Champ

Type

Description

id

String

ID de la tâche Batch.

status

String

État de la tâche. Valeurs possibles :

  • validating : le fichier d'entrée est en cours de validation

  • in_progress : la tâche est en cours de traitement

  • finalizing : le traitement est terminé et le fichier de sortie est en cours de génération

  • completed : la tâche s'est terminée avec succès

  • failed : la tâche a échoué en raison d'une erreur critique

  • expired : la tâche a expiré car elle n'a pas été terminée dans le completion_window

  • cancelling : la tâche est en cours d'annulation

  • cancelled : la tâche a été annulée

output_file_id

String

L'ID du fichier de résultats de succès, généré une fois la tâche terminée.

error_file_id

String

L'ID du fichier de résultats d'échec, généré lorsque la tâche est terminée et qu'il y a des requêtes échouées.

request_counts

Object

L'objet statistique du nombre de requêtes, contenant les champs total, completed et failed.

Vous pouvez utiliser la méthode batches.list() pour interroger la liste des tâches Batch et récupérer la liste complète des tâches de manière progressive via la pagination.
  • OpenAI Python SDK
  • OpenAI Node.js SDK
  • Java(HTTP)
  • curl(HTTP)

Exemple de requête

import os
from openai import OpenAI

client = OpenAI(
    # 若没有配置环境变量,可用阿里云百炼API Key将下行替换为:api_key="sk-xxx"。但不建议在生产环境中直接将API Key硬编码到代码中,以减少API Key泄露风险。
    # 新加坡和北京地域的API Key不同。
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # 以下是新加坡地域base_url,如果使用北京地域的模型,需要将base_url替换为:https://dashscope.aliyuncs.com/compatible-mode/v1
    # 注意:切换地域时,API Key也需要对应更换
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)
batches = client.batches.list(after="batch_xxx", limit=2,extra_query={'ds_name':'任务名称','input_file_ids':'file-batch-xxx,file-batch-xxx','status':'completed,expired','create_after':'20250304000000','create_before':'20250306123000'})
print(batches)

Paramètres d'entrée

Champ

Type

Méthode de transmission

Obligatoire

Description

after

String

Query

Non

Le curseur utilisé pour la pagination, dont la valeur est l'ID de la dernière tâche de la page précédente.

limit

Integer

Query

Non

Le nombre de tâches renvoyées par page, plage [1, 100], 20 par défaut.

ds_name

String

Query

Non

Correspondance floue par nom de tâche.

input_file_ids

String

Query

Non

Filtrer par ID de fichier. Plusieurs ID sont séparés par des virgules, jusqu'à 20.

status

String

Query

Non

Filtrer par état de tâche. Plusieurs états sont séparés par des virgules.

create_after

String

Query

Non

Filtrer les tâches créées après ce point temporel, au format yyyyMMddHHmmss.

create_before

String

Query

Non

Filtrer les tâches créées avant ce point temporel, au format yyyyMMddHHmmss.

Exemple de réponse

{
  "object": "list",
  "data": [
    {
      "id": "batch_xxx",
      "object": "batch",
      "endpoint": "/v1/chat/completions",
      "errors": null,
      "input_file_id": "file-batch-xxx",
      "completion_window": "24h",
      "status": "completed",
      "output_file_id": "file-batch_output-xxx",
      "error_file_id": null,
      "created_at": 1722234109,
      "in_progress_at": 1722234109,
      "expires_at": null,
      "finalizing_at": 1722234165,
      "completed_at": 1722234165,
      "failed_at": null,
      "expired_at": null,
      "cancelling_at": null,
      "cancelled_at": null,
      "request_counts": {
        "total": 100,
        "completed": 95,
        "failed": 5
      },
      "metadata": {}
    },
    { ... }
  ],
  "first_id": "batch_xxx",
  "last_id": "batch_xxx",
  "has_more": true
}

Paramètres de réponse

Champ

Type

Description

object

String

Le type, avec une valeur fixe de list.

data

Array

L'objet tâche Batch. Voir les paramètres de réponse de la création d'une tâche Batch.

first_id

String

L'ID de la première tâche Batch de la page actuelle.

last_id

String

L'ID de la dernière tâche Batch de la page actuelle.

has_more

Boolean

Indique s'il existe une page suivante.

Annulez une tâche en cours d'exécution ou en file d'attente. Après un appel réussi, l'état de la tâche passe à cancelling puis finalement à cancelled. Avant l'annulation complète de la tâche, la partie terminée reste facturée.
  • OpenAI Python SDK
  • OpenAI Node.js SDK
  • Java(HTTP)
  • curl(HTTP)

Exemple de requête

import os
from openai import OpenAI

client = OpenAI(
    # 若没有配置环境变量,可用阿里云百炼API Key将下行替换为:api_key="sk-xxx"。但不建议在生产环境中直接将API Key硬编码到代码中,以减少API Key泄露风险。
    # 新加坡和北京地域的API Key不同。
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # 以下是新加坡地域base_url,如果使用北京地域的模型,需要将base_url替换为:https://dashscope.aliyuncs.com/compatible-mode/v1
    # 注意:切换地域时,API Key也需要对应更换
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)
batch = client.batches.cancel("batch_id")  # 将batch_id替换为Batch任务的id
print(batch)

Exemple de réponse

Une fois la tâche annulée avec succès, les détails de la tâche Batch sont renvoyés. Voici un exemple de réponse à l'état cancelling :
{
  "id": "batch_abc123",
  "object": "batch",
  "endpoint": "/v1/chat/completions",
  "errors": null,
  "input_file_id": "file-abc123",
  "completion_window": "24h",
  "status": "cancelling",
  "output_file_id": null,
  "error_file_id": null,
  "created_at": 1711402400,
  "in_progress_at": 1711402450,
  "expires_at": 1711488800,
  "finalizing_at": null,
  "completed_at": null,
  "failed_at": null,
  "expired_at": null,
  "cancelling_at": 1711403000,
  "cancelled_at": null,
  "request_counts": {
    "total": 100,
    "completed": 23,
    "failed": 1
  },
  "metadata": null
}
Après l'annulation de la tâche, l'état passe d'abord à cancelling, en attendant la fin des requêtes en cours ; il finit par passer à cancelled. Les résultats des requêtes terminées restent enregistrés dans le fichier de sortie.
Une fois la tâche terminée, un fichier de résultats (output_file_id) et éventuellement un fichier d'erreurs (error_file_id) sont générés ; les deux s'obtiennent via la même API de téléchargement de fichiers.Seul le fichier correspondant au file_id commençant par file-batch_output peut être téléchargé.
  • OpenAI Python SDK
  • OpenAI Node.js SDK
  • Java(HTTP)
  • curl(HTTP)
Vous pouvez utiliser la méthode content pour récupérer le contenu du fichier de résultats Batch, et la méthode write_to_file pour l'enregistrer localement.

Exemple de requête

import os
from openai import OpenAI

client = OpenAI(
    # 若没有配置环境变量,可用阿里云百炼API Key将下行替换为:api_key="sk-xxx"。但不建议在生产环境中直接将API Key硬编码到代码中,以减少API Key泄露风险。
    # 新加坡和北京地域的API Key不同。
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # 以下是新加坡地域base_url,如果使用北京地域的模型,需要将base_url替换为:https://dashscope.aliyuncs.com/compatible-mode/v1
    # 注意:切换地域时,API Key也需要对应更换
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)
content = client.files.content(file_id="file-batch_output-xxx")
# 打印结果文件内容
print(content.text)
# 保存结果文件至本地
content.write_to_file("result.jsonl")

Exemple de réponse

{"id":"c308ef7f-xxx","custom_id":"1","response":{"status_code":200,"request_id":"c308ef7f-0824-9c46-96eb-73566f062426","body":{"created":1742303743,"usage":{"completion_tokens":35,"prompt_tokens":26,"total_tokens":61},"model":"qwen-plus","id":"chatcmpl-c308ef7f-0824-9c46-96eb-73566f062426","choices":[{"finish_reason":"stop","index":0,"message":{"content":"你好!当然可以。无论是需要信息查询、学习资料、解决问题的方法,还是其他任何帮助,我都在这里为你提供支持。请告诉我你需要什么方面的帮助?"}}],"object":"chat.completion"}},"error":null}
{"id":"73291560-xxx","custom_id":"2","response":{"status_code":200,"request_id":"73291560-7616-97bf-87f2-7d747bbe84fd","body":{"created":1742303743,"usage":{"completion_tokens":7,"prompt_tokens":26,"total_tokens":33},"model":"qwen-plus","id":"chatcmpl-73291560-7616-97bf-87f2-7d747bbe84fd","choices":[{"finish_reason":"stop","index":0,"message":{"content":"2+2 equals 4."}}],"object":"chat.completion"}},"error":null}

Exemple de réponse

Résultat de réponse unique :
{
    "id": "c308ef7f-xxx",
    "custom_id": "1",
    "response": {
        "status_code": 200,
        "request_id": "c308ef7f-0824-9c46-96eb-73566f062426",
        "body": {
            "created": 1742303743,
            "usage": {
                "completion_tokens": 35,
                "prompt_tokens": 26,
                "total_tokens": 61
            },
            "model": "qwen-plus",
            "id": "chatcmpl-c308ef7f-0824-9c46-96eb-73566f062426",
            "choices": [
                {
                    "finish_reason": "stop",
                    "index": 0,
                    "message": {
                        "content": "你好!当然可以。无论是需要信息查询、学习资料、解决问题的方法,还是其他任何帮助,我都在这里为你提供支持。请告诉我你需要什么方面的帮助?"
                    }
                }
            ],
            "object": "chat.completion"
        }
    },
    "error": null
}

Paramètres de réponse

Champ

Type

Description

id

String

ID de la requête.

custom_id

String

ID défini par l'utilisateur.

response

Object

Résultat de la requête.

status_code

Integer

Code d'état. 200 indique une requête réussie.

request_id

String

L'ID unique généré par le serveur pour cette requête.

completion_tokens

Integer

Le nombre de tokens consommés par le contenu de réponse généré par le modèle (completion).

prompt_tokens

Integer

Le nombre de tokens consommés par le contenu d'entrée (prompt) envoyé au modèle.

total_tokens

Integer

Le nombre total de tokens consommés par cet appel.

model

String

Le nom du modèle utilisé par cet appel.

error

Object

L'objet message d'erreur. Si l'appel API réussit, cette valeur est null. En cas d'erreur, il contient le code d'erreur et le message d'erreur détaillé.

error.code

String

Informations sur la ligne d'erreur et les causes de l'erreur. Consultez les codes d'erreur pour le dépannage.

error.message

String

Le message d'erreur.

Fonctionnalités avancées

Configurer les notifications de fin de tâche

L'interrogation (polling) de tâches longues consomme des ressources inutiles. Nous recommandons de configurer des notifications asynchrones afin que le système vous informe proactivement lorsqu'une tâche se termine.
La fonctionnalité de notification de fin de tâche est uniquement prise en charge dans la région Pékin.
  • Callback : Spécifiez une URL accessible publiquement lors de la création d'une tâche
  • File de messages EventBridge : Intégration profonde à l'écosystème Alibaba Cloud, sans IP publique requise
Spécifiez une URL accessible publiquement via metadata lors de la création d'une tâche. Une fois la tâche terminée, le système envoie une requête POST contenant l'état de la tâche à cette URL :
  • OpenAI Python SDK
  • curl(HTTP)
import os
from openai import OpenAI

client = OpenAI(
    # 若没有配置环境变量,可用阿里云百炼API Key将下行替换为:api_key="sk-xxx"。但不建议在生产环境中直接将API Key硬编码到代码中,以减少API Key泄露风险。
    # 新加坡和北京地域的API Key不同。
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # 以下是北京地域base_url,如果使用新加坡地域的模型,需要将base_url替换为:https://dashscope-intl.aliyuncs.com/compatible-mode/v1
    # 注意:切换地域时,API Key也需要对应更换
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

batch = client.batches.create(
    input_file_id="file-batch-xxx",  # 上传文件返回的 id
    endpoint="/v1/chat/completions",  # Embedding文本向量模型填写"/v1/embeddings",测试模型batch-test-model填写/v1/chat/ds-test,其他模型填写/v1/chat/completions
    completion_window="24h",
    metadata={
            "ds_batch_finish_callback": "https://xxx/xxx"
          }
)
print(batch)
Cette méthode ne nécessite pas d'IP publique et convient aux scénarios où vous vous intégrez à d'autres services Alibaba Cloud (tels que Function Compute et RocketMQ).Lorsqu'une tâche par lots se termine, le système envoie un événement à Alibaba Cloud EventBridge. Vous pouvez configurer des règles EventBridge pour écouter cet événement et l'acheminer vers une cible spécifiée.
  • Source : acs.dashscope
  • Type : dashscope:System:BatchTaskFinish
Documentation associée : Acheminement vers Message Queue for Apache RocketMQ.

Mise en production

  • Gestion des fichiers
    • Appelez périodiquement l'API de suppression de fichiers OpenAI-File pour supprimer les fichiers inutiles et éviter d'atteindre la limite de stockage de fichiers (10 000 fichiers ou 100 Go)
    • Pour les fichiers volumineux, nous recommandons de les stocker dans Alibaba Cloud OSS
  • Surveillance des tâches
    • Privilégiez les notifications asynchrones Callback ou EventBridge
    • Utilisez un intervalle d'interrogation > 1 minute avec une stratégie de temporisation exponentielle
  • Gestion des erreurs
    • Mettez en place un mécanisme complet de gestion des exceptions couvrant les erreurs réseau, les erreurs API, etc.
    • Téléchargez et analysez les détails des erreurs dans error_file_id
    • Pour les codes d'erreur courants, consultez les codes d'erreur pour les résoudre
  • Optimisation des coûts
    • Fusionnez les petites tâches en un seul lot
    • Définissez completion_window de manière appropriée pour offrir plus de flexibilité de planification

Utilitaires

Lorsque vos données brutes sont stockées dans un fichier CSV (première colonne comme ID, deuxième colonne comme contenu), vous pouvez utiliser le script suivant pour générer rapidement le fichier JSONL requis pour les tâches par lots.
Pour modifier le chemin du fichier ou d'autres paramètres, adaptez le code selon vos besoins.
import csv
import json
def messages_builder_example(content):
    messages = [{"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": content}]
    return messages

with open("input_demo.csv", "r") as fin:
    with open("input_demo.jsonl", 'w', encoding='utf-8') as fout:
        csvreader = csv.reader(fin)
        for row in csvreader:
"messages": messages_builder_example(row[1])}
            # 选择Embedding文本向量模型进行调用时,url的值需填写"/v1/embeddings",其他模型填写/v1/chat/completions
            request = {"custom_id": row[0], "method": "POST", "url": "/v1/chat/completions", "body": body}
            fout.write(json.dumps(request, separators=(',', ':'), ensure_ascii=False) + "\n")
Utilisez le script suivant pour analyser le fichier result.jsonl en un fichier result.csv facile à analyser dans Excel.
Pour modifier le chemin du fichier ou d'autres paramètres, adaptez le code selon vos besoins.
import json
import csv
columns = ["custom_id",
           "model",
           "request_id",
           "status_code",
           "error_code",
           "error_message",
           "created",
           "content",
           "usage"]

def dict_get_string(dict_obj, path):
    obj = dict_obj
    try:
        for element in path:
            obj = obj[element]
        return obj
    except:
        return None

with open("result.jsonl", "r") as fin:
    with open("result.csv", 'w', encoding='utf-8') as fout:
        rows = [columns]
        for line in fin:
            request_result = json.loads(line)
            row = [dict_get_string(request_result, ["custom_id"]),
                   dict_get_string(request_result, ["response", "body", "model"]),
                   dict_get_string(request_result, ["response", "request_id"]),
                   dict_get_string(request_result, ["response", "status_code"]),
                   dict_get_string(request_result, ["error", "error_code"]),
                   dict_get_string(request_result, ["error", "error_message"]),
                   dict_get_string(request_result, ["response", "body", "created"]),
                   dict_get_string(request_result, ["response", "body", "choices", 0, "message", "content"]),
                   dict_get_string(request_result, ["response", "body", "usage"])]
            rows.append(row)
        writer = csv.writer(fout)
        writer.writerows(rows)
Correction des caractères illisibles dans Excel
  • Utilisez un éditeur de texte (tel que Sublime) pour convertir l'encodage du fichier CSV en GBK, puis ouvrez-le dans Excel.
  • Ou créez un nouveau fichier dans Excel et spécifiez le bon format d'encodage (UTF-8) lors de l'importation des données.

Limites de débit de l'API

API

Limite de débit (niveau compte principal)

Créer une tâche

1000 fois/minute, jusqu'à 1000 tâches simultanées

Interroger une tâche

1000 fois/minute

Interroger la liste des tâches

100 fois/minute

Annuler une tâche

1000 fois/minute

Détails de facturation

  • Prix unitaire : Pour toutes les requêtes réussies, le prix unitaire des tokens d'entrée et de sortie est de 50 % du prix d'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 sont facturées.
    • Les échecs d'analyse de fichier, les échecs d'exécution de tâche et les requêtes en erreur au niveau ligne n'entraînent aucun frais.
    • Pour les tâches annulées, les requêtes terminées avec succès avant l'annulation restent facturées normalement.
  • L'inférence par lots est un élément de facturation distinct. Elle prend en charge le plan d'économies universel AI, mais ne prend pas en charge les remises d'achat à l'avance (plan d'économies) ni le quota gratuit pour nouveaux utilisateurs, ni des fonctionnalités telles que le cache de contexte.
  • Certains modèles (tels que qwen3.5-plus et qwen3.5-flash) 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 et augmente les coûts. Nous recommandons 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.

Codes d'erreur

Si un appel échoue, consultez les codes d'erreur pour le dépannage.

FAQ

  1. Comment choisir entre Batch Chat et Batch File ? Choisissez Batch File pour traiter un seul fichier volumineux contenant un grand nombre de requêtes et récupérer les résultats de manière asynchrone. Choisissez Batch Chat lorsque vous devez envoyer un grand nombre de requêtes de conversation indépendantes à forte concurrence via des appels API synchrones.
  2. Comment l'utilisation de Batch File est-elle facturée ? Dois-je l'acheter séparément ? Batch est un mode d'appel utilisant un modèle de paiement à l'usage et facturé en fonction de l'utilisation de tokens des requêtes réussies ; vous n'avez donc pas besoin d'acheter de packages supplémentaires.
  3. Les fichiers Batch soumis sont-ils exécutés dans l'ordre ? Non. Le système utilise un mécanisme de planification dynamique pour organiser l'exécution des tâches en fonction de la charge des ressources de calcul et ne garantit pas le respect strict de l'ordre de soumission. Lorsque les ressources sont limitées, le démarrage et l'exécution des tâches peuvent être retardés.
  4. Combien de temps faut-il pour qu'un fichier Batch soumis se termine ? Le temps d'exécution dépend de l'allocation des ressources système et de l'échelle de la tâche. Si une tâche n'est pas terminée dans le completion_window spécifié, son état passe à expired, et les requêtes non traitées ne sont plus exécutées et n'entraînent aucun frais. Recommandations de scénario : Pour les scénarios avec des exigences strictes de rapidité, nous recommandons d'utiliser des appels en temps réel. Pour les scénarios de traitement de données à grande échelle tolérant une certaine latence, nous recommandons d'utiliser des appels Batch.