QwenCloudBRASIL
Início›Biblioteca›Documentação
Tradução de apoio para consulta. Código e identificadores técnicos preservados. Consultar referência original ↗

API de processamento em lote

O processo requer assíncrono 50% de desconto.

Modelos apoiados incluem qwen3.7-plus, qwen-max, qwen-plus, qwen-flash, e qwen3.5-flash. Os resultados são entregues em 24 horas. Você pode criar e gerenciar trabalhos em lote usando o QwenCloud console ou API.

Formato de arquivo de entrada

Cada linha no arquivo de entrada JSONL é um pedido:

{"custom_id":"req-1","method":"POST","url":"/v1/chat/completions","body":{"model":"qwen-plus","messages":[{"role":"user","content":"Summarize quantum computing in two sentences."}]}}
{"custom_id":"req-2","method":"POST","url":"/v1/chat/completions","body":{"model":"qwen-plus","messages":[{"role":"user","content":"What is 2+2?"}]}}

Preparar. url para /v1/chat/completions para todos os pedidos. Até **50 mil pedidos por arquivo, 500 MB total, 1 MB por linha. Todos os pedidos devem usar o mesmo modelo. Cada um custom_id deve ser único.

Use o o QwenCloud console

Abra [A API do lote] (https://home.qwencloud.com/model-production/batch-api) na QwenCloud console.

Criar um trabalho de lote

  1. Clique em ** Criar trabalho em lote**.
  2. Preencha o nome da tarefa e descrição, defina o tempo de espera máximo e carregue seu arquivo de entrada JSONL.
  3. Clique em ** Criar trabalho em lote** para se submeter.

Clique em Arquivo de amostra à direita para baixar um modelo de arquivo JSONL.

Monitore e gerencie tarefas.

Na lista de tarefas, veja o progresso de cada tarefa** (pedidos processados / totais) e status**. Filtrar por status para localizar uma tarefa.

Clique em Cancelar para parar uma tarefa que é validating Ou in_progress. Clique em Detalhe para ver a configuração do trabalho, estatísticas e arquivos.

Descarregar resultados

Depois que a tarefa chegar completed Status, abra a página de detalhes do trabalho para baixar de Entrada& Output Files:

Ambos os arquivos incluem custom_id por combinar com a entrada original.

Uso de visualização

Na [Pay-As-You-Go] (https://home.qwencloud.com/billing/pay-as-you-go) página, ver gastos por modelo. O uso de lote aparece como um item de linha na tabela de tendências de gastos. Os dados podem demorar até 1-2 horas.

Use uma API

Enviar arquivo

import os
from pathlib import Path
from openai import OpenAI
client = OpenAI(api_key=os.getenv("DASHSCOPE_API_KEY"), base_url="https://maas.qwencloudapi.com/compatible-mode/v1")

file_object = client.files.create(
  file=Path("input.jsonl"),
  purpose="batch"
)
print(file_object.id)  # <-- use this in the next step

import OpenAI from "openai";
import fs from "fs";
const client = new OpenAI({ apiKey: process.env.DASHSCOPE_API_KEY, baseURL: "https://maas.qwencloudapi.com/compatible-mode/v1" });

const fileObject = await client.files.create({
  file: fs.createReadStream("input.jsonl"),
  purpose: "batch"
});
console.log(fileObject.id);  // <-- use this in the next step

curl -X POST https://maas.qwencloudapi.com/compatible-mode/v1/files \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
  --form 'file=@"input.jsonl"' \
  --form 'purpose="batch"'

Resposta (campos chave):

{"id": "file-batch-xxx", "status": "uploaded", "purpose": "batch"}

**Reutilizar um arquivo de identificação existente:**O ID retornado após o upload de um arquivo (por exemplo, file-batch-xxx) podem ser reutilizados. Se o conteúdo de entrada permanecer o mesmo, pule o re-uploading e crie uma tarefa diretamente com a ID existente:

batch = client.batches.create(
  input_file_id="file-batch-xxx",  # Reuse existing file ID, no need to re-upload
  endpoint="/v1/chat/completions",
  completion_window="24h"
)

Você pode recuperar as identidades históricas através do client.files.list(purpose="batch") API.

Criar lote

batch = client.batches.create(
  input_file_id="file-batch-xxx",       # <-- from upload step
  endpoint="/v1/chat/completions",       # <-- must match url in input file
  completion_window="24h",               # <-- 24h to 336h (14 days)
  metadata={
    "ds_name": "My batch job",         # <-- optional: task name (max 100 chars)
    "ds_description": "Weekly report", # <-- optional: task description (max 200 chars)
  }
)
print(batch.id)

const batch = await client.batches.create({
  input_file_id: "file-batch-xxx",       // <-- from upload step
  endpoint: "/v1/chat/completions",      // <-- must match url in input file
  completion_window: "24h",
  metadata: {
    ds_name: "My batch job",
    ds_description: "Weekly report",
  }
});
console.log(batch.id);

curl -X POST https://maas.qwencloudapi.com/compatible-mode/v1/batches \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input_file_id": "file-batch-xxx",
    "endpoint": "/v1/chat/completions",
    "completion_window": "24h",
    "metadata": {"ds_name": "My batch job"}
  }'

Use o modelo de teste batch-test-model com ponto final /v1/chat/ds-test para validar seu formato de arquivo sem custos de inferência. Limites: 1 MB, 100 linhas, 2 tarefas simultâneas.

Verifique o status

batch = client.batches.retrieve("batch_xxx")
print(batch.status)  # <-- see status lifecycle below

const batch = await client.batches.retrieve("batch_xxx");
console.log(batch.status);

curl https://maas.qwencloudapi.com/compatible-mode/v1/batches/batch_xxx \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY"

Ciclo de vida da situação: validating → in_progress → finalizing → completed. Terminal de estados: completed, failed, expired, cancelled. Pesquise a cada 1-2 minutos.

Resposta (campos chave):

{
  "id": "batch_xxx",
  "status": "completed",
  "output_file_id": "file-batch_output-xxx",  // <-- download this
  "error_file_id": "file-batch_error-xxx",     // <-- failed requests (if any)
  "request_counts": {"total": 100, "completed": 98, "failed": 2}
}

Descarregar resultados

content = client.files.content("file-batch_output-xxx")  # <-- output_file_id from above
content.write_to_file("result.jsonl")

const content = await client.files.content("file-batch_output-xxx");
const text = await content.text();
fs.writeFileSync("result.jsonl", text);

curl https://maas.qwencloudapi.com/compatible-mode/v1/files/file-batch_output-xxx/content \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY" > result.jsonl

Cada linha na saída JSONL mapeia para um pedido de custom_id:

{"id": "batch_req_xxx", "custom_id": "req-1", "response": {"status_code": 200, "body": {"choices": [{"message": {"content": "..."}}], "usage": {...}}}}

Baixe o arquivo de erro (error_file_idDa mesma forma que inspecionar pedidos fracassados. Veja [códigos de erro] (/api-reference/preparation/error-messages) para detalhes.

Gerencie lotes.

Listar lotes

batches = client.batches.list(limit=10)

curl 'https://maas.qwencloudapi.com/compatible-mode/v1/batches?limit=10&status=completed,failed' \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY"

Parâmetros do filtro (corrente de interrogação): ds_name (Fuzzy match), input_file_ids (comma-separado, máx. 20), status (comma-separado), create_after / create_before (formato: yyyyMMddHHmmss), after (cursor), limit (tamanho da página).

Cancele um lote.

client.batches.cancel("batch_xxx")

curl -X POST https://maas.qwencloudapi.com/compatible-mode/v1/batches/batch_xxx/cancel \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY"

O status se move para cancelling, então cancelled após os pedidos de vôo terminarem. Pedidos completados antes do cancelamento ainda estão faturados.

Roteiros de utilidade

CSV to JSONL converter

import csv, json

def build_messages(content):
  return [{"role": "user", "content": content}]

with open("input.csv") as fin, open("input.jsonl", "w") as fout:
  for row in csv.reader(fin):
    request = {
      "custom_id": row[0],
      "method": "POST",
      "url": "/v1/chat/completions",
      "body": {"model": "qwen-plus", "messages": build_messages(row[1])}
    }
    fout.write(json.dumps(request, ensure_ascii=False) + "\n")

JSONL results to CSV converter

import json, csv

columns = ["custom_id", "status_code", "content", "usage"]

def get(obj, path):
  for key in path:
    obj = obj[key] if obj and key in obj else None
  return obj

with open("result.jsonl") as fin, open("result.csv", "w") as fout:
  writer = csv.writer(fout)
  writer.writerow(columns)
  for line in fin:
    r = json.loads(line)
    writer.writerow([
      r.get("custom_id"),
      get(r, ["response", "status_code"]),
      get(r, ["response", "body", "choices", 0, "message", "content"]),
      get(r, ["response", "body", "usage"]),
    ])

Notas

Referência da API