Compartilhar via

Introdução às implantações em lotes do Serviço OpenAI do Azure

A API de Lote do OpenAI do Azure foi projetada para lidar com tarefas de processamento em grande escala e de alto volume com eficiência. Processe grupos assíncronos de solicitações com cota separada, com prazo de resposta de 24 horas, a custos 50% menores que o padrão global. Com o processamento em lote, em vez de enviar uma solicitação por vez, você deve enviar um grande número de solicitações em um único arquivo. As solicitações em lotes globais têm uma cota de token enfileirada separada, evitando qualquer interrupção de suas cargas de trabalho online.

Os casos de uso incluem:

  • Processamento de dados em larga escala: analisar rapidamente conjuntos de dados extensos em paralelo.

  • Geração de Conteúdo: Criar grandes volumes de texto, como descrições de produto ou artigos.

  • Revisão e Resumo de Documentos: automatizar a revisão e o resumo de documentos longos.

  • Automação de Suporte ao Cliente: lidar com várias consultas simultaneamente para obter respostas mais rápidas.

  • Extração e Análise de Dados: extrair e analisar informações de grandes quantidades de dados não estruturados.

  • Tarefas do Processamento de Linguagem Natural (NLP): execute tarefas como análise de sentimento ou tradução em grandes conjuntos de dados.

  • Marketing e Personalização: gere conteúdo personalizado e recomendações em escala.

Dica

Se os seus trabalhos em lote são tão grandes que você está atingindo o limite de token na fila mesmo depois de maximizar a cota para a implantação, algumas regiões já dão suporte a um novo recurso que permite colocar vários trabalhos em lote na fila com a retirada exponencial.

Quando sua cota de tokens em fila estiver disponível, o próximo trabalho em lote poderá ser criado e iniciado automaticamente. Para saber mais, consulte Automatização de novas tentativas de grandes trabalhos em lote com retirada exponencial.

Importante

Pretendemos processar solicitações em lotes dentro de 24 horas; não expiramos os trabalhos que levam mais tempo. Você poderá cancelar o trabalho a qualquer momento. Quando você cancela o trabalho, qualquer trabalho restante é cancelado e qualquer trabalho já concluído é retornado. Você será cobrado por qualquer trabalho concluído.

Os dados armazenados em repouso permanecem na geografia designada do Azure, enquanto os dados podem ser processados para inferência em qualquer local do Azure OpenAI.  Saiba mais sobre residência de dados. 

Suporte ao Lote

Disponibilidade do modelo de lote global

Região gpt-5, 2025-08-07 o3, 2025-04-16 o4-mini, 2025-04-16 gpt-4.1, 2025-04-14 gpt-4.1-nano, 2025-04-14 gpt-4.1-mini, 2025-04-14 o3-mini, 2025-01-31 gpt-4o, 2024-05-13 gpt-4o, 2024-08-06 gpt-4o, 2024-11-20 gpt-4o-mini, 2024-07-18
australiaeast ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Brasil Sul ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Canadá Oriental ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
centralus ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
eastus ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
eastus2 ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
francecentral ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
alemanhacentro-oeste ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
japaneast ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
koreacentral ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
northcentralus ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
noruega-leste ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Polônia Central ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
southafricanorth ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
southcentralus ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
sul da Índia ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
swedencentral ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Suíça Norte ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
uksouth ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
westeurope ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
westus ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
westus3 ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅

O registro é necessário para acesso gpt-5 e o3 para obter mais informações, consulte nosso guia de modelos de raciocínio.

Os seguintes modelos são compatíveis com o lote global:

Modelo Versão Formato de entrada
gpt-5 2025-08-7 texto + imagem
o3 2025-04-16 texto + imagem
o3-mini 31/01/2025 enviar SMS
gpt-4o 06/08/2024 texto + imagem
gpt-4o-mini 18/07/2024 texto + imagem
gpt-4o 13/05/2024 texto + imagem

Observação

Embora o Lote Global dê suporte a versões de API mais antigas, alguns modelos exigem versões de API de versão prévia mais recentes. Por exemplo, o3-mini não é compatível com 2024-10-21 porque foi lançado após essa data. Para acessar os modelos mais recentes com o lote global, use a versão mais recente da API de visualização.

Suporte de funcionalidades

No momento, não há suporte para o seguinte:

  • Integração com a API de Assistentes.
  • Integração com o recurso do OpenAI do Azure em Seus Dados.

Implantação em lote

Observação

No portal do Microsoft Foundry , os tipos de implantação em lote serão exibidos como Global-Batch e Data Zone Batch. Para saber mais sobre os tipos de implantação do OpenAI do Azure, confira nosso guia de tipos de implantação.

Dica

Recomendamos habilitar cota dinâmica para todas as implantações globais de modelo em lotes para ajudar a evitar falhas de trabalho devido à cota de token enfileirada insuficiente. A utilização de cota dinâmica permite que sua implantação aproveite de forma oportunista mais cota disponível quando houver capacidade extra. Quando a cota dinâmica for definida como desativada, sua implantação só poderá processar solicitações até o limite de token enfileirado definido quando você criou a implantação.

Pré-requisitos

  • Uma assinatura do Azure – Crie uma gratuitamente.
  • Um recurso com um modelo do tipo de implantação GlobalBatch ou DataZoneBatch implantado.

Preparar seu arquivo em lote

Assim como o ajuste fino, o processamento em lote usa arquivos no formato de linhas JSON (.jsonl). Abaixo estão alguns arquivos de exemplo com diferentes tipos de conteúdo com suporte:

Formato de entrada

API de Respostas

{"custom_id": "task-0", "method": "POST", "url": "/v1/responses", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "input": "When was Microsoft founded, and by whom?"}}
{"custom_id": "task-1", "method": "POST", "url": "/v1/responses", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "input": "When was XBOX merged into Microsoft?"}}
{"custom_id": "task-2", "method": "POST", "url": "/v1/responses", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "input": "What is Visual Basic?"}}

API de finalizações de chat

{"custom_id": "task-0", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "messages": [{"role": "system", "content": "You are an AI assistant that helps people find information."}, {"role": "user", "content": "When was Microsoft founded?"}]}}
{"custom_id": "task-1", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "messages": [{"role": "system", "content": "You are an AI assistant that helps people find information."}, {"role": "user", "content": "When was the first XBOX released?"}]}}
{"custom_id": "task-2", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "messages": [{"role": "system", "content": "You are an AI assistant that helps people find information."}, {"role": "user", "content": "What is Altair Basic?"}]}}

O custom_id é necessário para permitir que você identifique quais solicitações em lote individuais correspondem a uma determinada resposta. As respostas não serão retornadas em ordem idêntica à ordem definida no arquivo em lote .jsonl.

O atributo model deve ser definido para corresponder ao nome da implantação do Lote Global que você deseja direcionar para respostas de inferência.

Importante

O atributo model deve ser configurado para corresponder ao nome da implantação do Lote Global que você deseja direcionar para as respostas de inferência. O mesmo nome de implantação do modelo do Lote Globa deve estar presente em cada linha do arquivo de lote. Se você quiser direcionar uma implantação diferente, deverá fazê-lo em um arquivo de lote/trabalho separado.

Para obter um melhor desempenho, recomendamos enviar arquivos grandes para processamento em lote, em vez de muitos arquivos pequenos com apenas algumas linhas em cada um.

Criar arquivo de entrada

Para este artigo, criaremos um arquivo nomeado test.jsonl e copiaremos o conteúdo do bloco de código de entrada padrão acima para o arquivo. Você precisará modificar e adicionar seu nome de implantação em lote global a cada linha do arquivo.

Criar um trabalho em lotes

Depois que o arquivo de entrada estiver preparado, primeiro você precisará carregar o arquivo para poder iniciar um trabalho em lotes. O upload de arquivo pode ser feito programaticamente ou por meio do portal do Microsoft Foundry. Este exemplo demonstra o carregamento de um arquivo diretamente para o recurso do Azure OpenAI. Como alternativa, você pode configurar o Armazenamento de Blobs do Azure para o Azure OpenAI Batch.

  1. Entre no Microsoft Foundry. Certifique-se de que o botão New Foundry está desativado. Essas etapas se referem à Fábrica (clássica).

  2. Selecione o recurso do OpenAI do Azure em que você tem uma implantação de modelo de lote global disponível.

  3. Selecione Trabalhos em lote>+Criar trabalhos em lote.

    Captura de tela que mostra a experiência de criação de trabalho em lote no portal do Foundry.

  4. Na lista suspensa, em Dados em lote>Carregar arquivos>, selecione Carregar arquivo e indique o caminho para o arquivo test.jsonl criado na etapa anterior >Avançar.

    Captura de tela que mostra a experiência de carregar arquivo.

Selecione Criar para iniciar o trabalho em lotes.

  1. Entre no Microsoft Foundry. Certifique-se de que a chave New Foundry está ativada. Essas etapas se referem à Fábrica (nova).

  2. No canto superior direito, selecione Compilar

  3. No painel esquerdo, selecione Modelos

  4. Selecione Trabalhos em Lote>criar um trabalho em lote

    Captura de tela da nova experiência de criação de lote do Foundry.

Acompanhar o progresso do trabalho em lotes

Após criar o trabalho, você poderá monitorar o progresso do trabalho selecionando a ID do trabalho para o trabalho criado mais recentemente. Por padrão, você será direcionado para a página de status do trabalho em lotes criado mais recentemente.

Você pode acompanhar o status da tarefa no painel à direita.

Recuperar o arquivo de saída do trabalho em lote

Quando o trabalho for concluído ou atingir um estado terminal, ele vai gerar um arquivo de erro e um arquivo de saída que podem ser baixados para revisão selecionando o respectivo botão com o ícone de seta para baixo.

Cancelar lote

Cancela um lote em andamento. O lote ficará em status cancelling por até 10 minutos, antes de ser alterado para cancelled, onde terá resultados parciais (se houver) disponíveis no arquivo de saída.

Acompanhar o progresso do trabalho em lotes

Após criar o trabalho, você poderá monitorar o progresso do trabalho selecionando a ID do trabalho para o trabalho criado mais recentemente. Por padrão, você será direcionado para a página de status do trabalho em lotes criado mais recentemente.

Você pode acompanhar o status da tarefa no painel à direita.

Recuperar o arquivo de saída do trabalho em lote

Quando o trabalho for concluído ou atingir um estado terminal, ele vai gerar um arquivo de erro e um arquivo de saída que podem ser baixados para revisão selecionando o respectivo botão com o ícone de seta para baixo.

Cancelar lote

Cancela um lote em andamento. O lote ficará em status cancelling por até 10 minutos, antes de ser alterado para cancelled, onde terá resultados parciais (se houver) disponíveis no arquivo de saída.

Pré-requisitos

As etapas neste artigo devem ser executadas sequencialmente no Jupyter Notebooks. Por esse motivo, só instanciaremos o cliente do OpenAI do Azure uma vez no início dos exemplos. Caso queira executar uma etapa fora de ordem, geralmente é necessário configurar um cliente Azure OpenAI como parte desta chamada.

Mesmo se você já tiver a biblioteca do Python do OpenAI instalada, talvez seja necessário atualizar sua instalação para a versão mais recente:

!pip install openai --upgrade

Preparar seu arquivo em lote

Assim como o ajuste fino, o lote global usa arquivos no formato de linhas JSON (.jsonl). Abaixo estão alguns arquivos de exemplo com diferentes tipos de conteúdo com suporte:

Formato de entrada

API de Respostas

{"custom_id": "task-0", "method": "POST", "url": "/v1/responses", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "input": "When was Microsoft founded, and by whom?"}}
{"custom_id": "task-1", "method": "POST", "url": "/v1/responses", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "input": "When was XBOX merged into Microsoft?"}}
{"custom_id": "task-2", "method": "POST", "url": "/v1/responses", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "input": "What is Visual Basic?"}}

API de finalizações de chat

{"custom_id": "task-0", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "messages": [{"role": "system", "content": "You are an AI assistant that helps people find information."}, {"role": "user", "content": "When was Microsoft founded?"}]}}
{"custom_id": "task-1", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "messages": [{"role": "system", "content": "You are an AI assistant that helps people find information."}, {"role": "user", "content": "When was the first XBOX released?"}]}}
{"custom_id": "task-2", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "messages": [{"role": "system", "content": "You are an AI assistant that helps people find information."}, {"role": "user", "content": "What is Altair Basic?"}]}}

O custom_id é necessário para permitir que você identifique quais solicitações em lote individuais correspondem a uma determinada resposta. As respostas não serão retornadas em ordem idêntica à ordem definida no arquivo em lote .jsonl.

O atributo model deve ser definido para corresponder ao nome da implantação do Lote Global que você deseja direcionar para respostas de inferência.

Importante

O atributo model deve ser configurado para corresponder ao nome da implantação do Lote Global que você deseja direcionar para as respostas de inferência. O mesmo nome de implantação do modelo do Lote Globa deve estar presente em cada linha do arquivo de lote. Se você quiser direcionar uma implantação diferente, deverá fazê-lo em um arquivo de lote/trabalho separado.

Para obter um melhor desempenho, recomendamos enviar arquivos grandes para processamento em lote, em vez de muitos arquivos pequenos com apenas algumas linhas em cada um.

Criar arquivo de entrada

Para este artigo, criaremos um arquivo nomeado test.jsonl e copiaremos o conteúdo do bloco de código de entrada padrão acima para o arquivo. Você precisará modificar e adicionar seu nome de implantação em lote global a cada linha do arquivo. Salve esse arquivo no mesmo diretório que você está executando seu Jupyter Notebook.

Carregar arquivo em lote

Depois que o arquivo de entrada estiver preparado, primeiro você precisará carregar o arquivo para poder iniciar um trabalho em lotes. O upload de arquivo pode ser feito programaticamente ou por meio do portal do Microsoft Foundry. Este exemplo demonstra o carregamento de um arquivo diretamente para o recurso do Azure OpenAI. Como alternativa, você pode configurar o Armazenamento de Blobs do Azure para o Azure OpenAI Batch.

import os
from datetime import datetime
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://cognitiveservices.azure.com/.default"
)

client = OpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  api_key=token_provider,
)


# Upload a file with a purpose of "batch"
file = client.files.create(
  file=open("test.jsonl", "rb"), 
  purpose="batch",
  extra_body={"expires_after":{"seconds": 1209600, "anchor": "created_at"}} # Optional you can set to a number between 1209600-2592000. This is equivalent to 14-30 days
)


print(file.model_dump_json(indent=2))

print(f"File expiration: {datetime.fromtimestamp(file.expires_at) if file.expires_at is not None else 'Not set'}")

file_id = file.id

Ao cancelar o comentário e adicionar extra_body={"expires_after":{"seconds": 1209600, "anchor": "created_at"}} , você está definindo nosso arquivo de upload para expirar em 14 dias. Há um limite máximo de 500 arquivos de lote de entrada por recurso quando nenhuma expiração é definida. Ao definir um valor para expiração, o número de arquivos de lote de entrada por recurso é aumentado para 10.000 arquivos por recurso. Para remover os limites de arquivo de entrada em lote, use Batch com Azure Blob Storage.

Saída:

{
  "id": "file-655111ec9cfc44489d9af078f08116ef",
  "bytes": 176064,
  "created_at": 1743391067,
  "filename": "test.jsonl",
  "object": "file",
  "purpose": "batch",
  "status": "processed",
  "expires_at": 1744600667,
  "status_details": null
}
File expiration: 2025-04-13 23:17:47

Criar um trabalho em lotes

Após carregar o arquivo, você poderá enviar o arquivo para processamento em lote.

# Submit a batch job with the file
batch_response = client.batches.create(
    input_file_id=file_id,
    endpoint="/chat/completions", # While passing this parameter is required, the system will read your input file to determine if the chat completions or responses API is needed.  
    completion_window="24h",
    # extra_body={"output_expires_after":{"seconds": 1209600, "anchor": "created_at"}} # Optional you can set to a number between 1209600-2592000. This is equivalent to 14-30 days
)


# Save batch ID for later use
batch_id = batch_response.id

print(batch_response.model_dump_json(indent=2))

Observação

Atualmente, a janela de conclusão deve ser definida como 24h. Se você definir qualquer valor que não seja 24h, seu trabalho falhará. Os trabalhos que levam mais de 24 horas continuarão a ser executados até serem cancelados.

Saída:

{
  "id": "batch_6caaf24d-54a5-46be-b1b7-518884fcbdde",
  "completion_window": "24h",
  "created_at": 1722476583,
  "endpoint": null,
  "input_file_id": "file-655111ec9cfc44489d9af078f08116ef",
  "object": "batch",
  "status": "validating",
  "cancelled_at": null,
  "cancelling_at": null,
  "completed_at": null,
  "error_file_id": null,
  "errors": null,
  "expired_at": null,
  "expires_at": 1722562983,
  "failed_at": null,
  "finalizing_at": null,
  "in_progress_at": null,
  "metadata": null,
  "output_file_id": null,
  "request_counts": {
    "completed": 0,
    "failed": 0,
    "total": 0
  }
}

Se os seus trabalhos em lotes são tão grandes que você está atingindo o limite de tokens na fila mesmo depois de maximizar a cota para a implantação, algumas regiões já dão suporte a um novo recurso de fail fast que permite colocar vários trabalhos em lotes na fila com a retirada exponencial. Portanto, logo que um trabalho em lotes grande é concluído, o próximo pode ser iniciado automaticamente. Para saber mais sobre quais regiões dão suporte a esse recurso e como adaptar seu código para tirar proveito dele, consulte encaminhamento de trabalhos em lotes.

Acompanhar o progresso do trabalho em lotes

Depois de criar um trabalho em lote com êxito, você poderá monitorar seu progresso no Studio ou programaticamente. Ao verificar o progresso do trabalho em lotes, recomendamos aguardar pelo menos 60 segundos entre cada chamada de status.

import time
import datetime 

status = "validating"
while status not in ("completed", "failed", "canceled"):
    time.sleep(60)
    batch_response = client.batches.retrieve(batch_id)
    status = batch_response.status
    print(f"{datetime.datetime.now()} Batch Id: {batch_id},  Status: {status}")

if batch_response.status == "failed":
    for error in batch_response.errors.data:  
        print(f"Error code {error.code} Message {error.message}")

Saída:

2024-07-31 21:48:32.556488 Batch Id: batch_6caaf24d-54a5-46be-b1b7-518884fcbdde,  Status: validating
2024-07-31 21:49:39.221560 Batch Id: batch_6caaf24d-54a5-46be-b1b7-518884fcbdde,  Status: in_progress
2024-07-31 21:50:53.383138 Batch Id: batch_6caaf24d-54a5-46be-b1b7-518884fcbdde,  Status: in_progress
2024-07-31 21:52:07.274570 Batch Id: batch_6caaf24d-54a5-46be-b1b7-518884fcbdde,  Status: in_progress
2024-07-31 21:53:21.149501 Batch Id: batch_6caaf24d-54a5-46be-b1b7-518884fcbdde,  Status: finalizing
2024-07-31 21:54:34.572508 Batch Id: batch_6caaf24d-54a5-46be-b1b7-518884fcbdde,  Status: finalizing
2024-07-31 21:55:35.304713 Batch Id: batch_6caaf24d-54a5-46be-b1b7-518884fcbdde,  Status: finalizing
2024-07-31 21:56:36.531816 Batch Id: batch_6caaf24d-54a5-46be-b1b7-518884fcbdde,  Status: finalizing
2024-07-31 21:57:37.414105 Batch Id: batch_6caaf24d-54a5-46be-b1b7-518884fcbdde,  Status: completed

Os seguintes valores de status são possíveis:

Estado Descrição
validating O arquivo de entrada está sendo validado antes que o processamento em lote possa começar.
failed O arquivo de entrada falhou no processo de validação.
in_progress O arquivo de entrada foi validado com êxito e o lote está em execução no momento.
finalizing O lote foi concluído e os resultados estão sendo preparados.
completed O lote foi concluído e os resultados estão prontos.
expired O lote não pôde ser concluído dentro da janela de tempo de 24 horas.
cancelling O lote está sendo cancelled (isso pode levar até 10 minutos para entrar em vigor.)
cancelled o lote era cancelled.

Para examinar os detalhes do status do trabalho, você poderá executar:

print(batch_response.model_dump_json(indent=2))

Saída:

{
  "id": "batch_6caaf24d-54a5-46be-b1b7-518884fcbdde",
  "completion_window": "24h",
  "created_at": 1722476583,
  "endpoint": null,
  "input_file_id": "file-9f3a81d899b4442f98b640e4bc3535dd",
  "object": "batch",
  "status": "completed",
  "cancelled_at": null,
  "cancelling_at": null,
  "completed_at": 1722477429,
  "error_file_id": "file-c795ae52-3ba7-417d-86ec-07eebca57d0b",
  "errors": null,
  "expired_at": null,
  "expires_at": 1722562983,
  "failed_at": null,
  "finalizing_at": 1722477177,
  "in_progress_at": null,
  "metadata": null,
  "output_file_id": "file-3304e310-3b39-4e34-9f1c-e1c1504b2b2a",
  "request_counts": {
    "completed": 3,
    "failed": 0,
    "total": 3
  }
}

Observe que há tanto error_file_id quanto um output_file_id separado. Use o error_file_id para ajudar na depuração de quaisquer problemas que ocorram com seu trabalho em lote.

Recuperar o arquivo de saída do trabalho em lote

import json

output_file_id = batch_response.output_file_id

if not output_file_id:
    output_file_id = batch_response.error_file_id

if output_file_id:
    file_response = client.files.content(output_file_id)
    raw_responses = file_response.text.strip().split('\n')  

    for raw_response in raw_responses:  
        json_response = json.loads(raw_response)  
        formatted_json = json.dumps(json_response, indent=2)  
        print(formatted_json)

Saída:

Para simplificar, incluímos apenas uma resposta de preenchimento de chat da saída. Caso siga as etapas neste artigo, deverá ter três respostas semelhantes à seguinte:

Finalizações de chat

{
  "custom_id": "task-0",
  "response": {
    "body": {
      "choices": [
        {
          "content_filter_results": {
            "hate": {
              "filtered": false,
              "severity": "safe"
            },
            "self_harm": {
              "filtered": false,
              "severity": "safe"
            },
            "sexual": {
              "filtered": false,
              "severity": "safe"
            },
            "violence": {
              "filtered": false,
              "severity": "safe"
            }
          },
          "finish_reason": "stop",
          "index": 0,
          "logprobs": null,
          "message": {
            "content": "Microsoft was founded on April 4, 1975, by Bill Gates and Paul Allen in Albuquerque, New Mexico.",
            "role": "assistant"
          }
        }
      ],
      "created": 1722477079,
      "id": "chatcmpl-9rFGJ9dh08Tw9WRKqaEHwrkqRa4DJ",
      "model": "gpt-4o-2024-05-13",
      "object": "chat.completion",
      "prompt_filter_results": [
        {
          "prompt_index": 0,
          "content_filter_results": {
            "hate": {
              "filtered": false,
              "severity": "safe"
            },
            "jailbreak": {
              "filtered": false,
              "detected": false
            },
            "self_harm": {
              "filtered": false,
              "severity": "safe"
            },
            "sexual": {
              "filtered": false,
              "severity": "safe"
            },
            "violence": {
              "filtered": false,
              "severity": "safe"
            }
          }
        }
      ],
      "system_fingerprint": "fp_a9bfe9d51d",
      "usage": {
        "completion_tokens": 24,
        "prompt_tokens": 27,
        "total_tokens": 51
      }
    },
    "request_id": "660b7424-b648-4b67-addc-862ba067d442",
    "status_code": 200
  },
  "error": null
}

API de Respostas

{
  "custom_id": "task-0",
  "response": {
    "body": {
      "id": "resp_0e5c78eb05ee70cf00690cc6d988e4819587556df17436a206",
      "created_at": 1762445017.0,
      "error": null,
      "incomplete_details": null,
      "instructions": null,
      "metadata": {},
      "model": "gpt-4.1-batch",
      "object": "response",
      "output": [
        {
          "id": "msg_0e5c78eb05ee70cf00690cc6da3c548195aae483031113df16",
          "content": [
            {
              "annotations": [],
              "text": "Microsoft was founded on **April 4, 1975** by **Bill Gates** and **Paul Allen**.",
              "type": "output_text",
              "logprobs": []
            }
          ],
          "role": "assistant",
          "status": "completed",
          "type": "message"
        }
      ],
      "parallel_tool_calls": true,
      "temperature": 1.0,
      "tool_choice": "auto",
      "tools": [],
      "top_p": 1.0,
      "background": false,
      "max_output_tokens": null,
      "max_tool_calls": null,
      "previous_response_id": null,
      "prompt_cache_key": null,
      "reasoning": {
        "effort": null,
        "summary": null
      },
      "safety_identifier": null,
      "service_tier": "default",
      "status": "completed",
      "text": {
        "format": {
          "type": "text"
        },
        "verbosity": "medium"
      },
      "top_logprobs": 0,
      "truncation": "disabled",
      "usage": {
        "input_tokens": 16,
        "input_tokens_details": {
          "cached_tokens": 0
        },
        "output_tokens": 25,
        "output_tokens_details": {
          "reasoning_tokens": 0
        },
        "total_tokens": 41
      },
      "user": null,
      "content_filters": null,
      "store": true
    },
    "request_id": "809b30c2-fa0b-4613-b5cc-c30f6b780c9a",
    "status_code": 200
  },
  "error": null
}

Comandos de lote adicionais

Cancelar lote

Cancela um lote em andamento. O lote ficará em status cancelling por até 10 minutos, antes de ser alterado para cancelled, onde terá resultados parciais (se houver) disponíveis no arquivo de saída.

client.batches.cancel("batch_abc123") # set to your batch_id for the job you want to cancel

Listar lote

Liste os trabalhos em lote para um recurso específico do OpenAI do Azure.

client.batches.list()

Os métodos de lista na biblioteca do Python são paginados.

Para listar todos os trabalhos:

all_jobs = []
# Automatically fetches more pages as needed.
for job in client.batches.list(
    limit=20,
):
    # Do something with job here
    all_jobs.append(job)
print(all_jobs)

Lote de lista (Versão prévia)

Use a API REST para listar todos os trabalhos em lote com opções adicionais de classificação/filtragem.

Nos exemplos abaixo, estamos fornecendo a generate_time_filter função para facilitar a construção do filtro. Se você não quiser usar essa função, o formato da cadeia de caracteres de filtro será semelhante a created_at gt 1728860560 and status eq 'Completed'.

import requests
import json
from datetime import datetime, timedelta
from azure.identity import DefaultAzureCredential

token_credential = DefaultAzureCredential()
token = token_credential.get_token('https://cognitiveservices.azure.com/.default')

endpoint = "https://{YOUR_RESOURCE_NAME}.openai.azure.com/"
api_version = "2025-03-01-preview"
url = f"{endpoint}openai/batches"
order = "created_at asc"
time_filter =  lambda: generate_time_filter("past 8 hours")

# Additional filter examples:
#time_filter =  lambda: generate_time_filter("past 1 day")
#time_filter =  lambda: generate_time_filter("past 3 days", status="Completed")

def generate_time_filter(time_range, status=None):
    now = datetime.now()
    
    if 'day' in time_range:
        days = int(time_range.split()[1])
        start_time = now - timedelta(days=days)
    elif 'hour' in time_range:
        hours = int(time_range.split()[1])
        start_time = now - timedelta(hours=hours)
    else:
        raise ValueError("Invalid time range format. Use 'past X day(s)' or 'past X hour(s)'")
    
    start_timestamp = int(start_time.timestamp())
    
    filter_string = f"created_at gt {start_timestamp}"
    
    if status:
        filter_string += f" and status eq '{status}'"
    
    return filter_string

filter = time_filter()

headers = {'Authorization': 'Bearer ' + token.token}

params = {
    "api-version": api_version,
    "$filter": filter,
    "$orderby": order
}

response = requests.get(url, headers=headers, params=params)

json_data = response.json()

if response.status_code == 200:
    print(json.dumps(json_data, indent=2))
else:
    print(f"Request failed with status code: {response.status_code}")
    print(response.text)

Saída:

{
  "data": [
    {
      "cancelled_at": null,
      "cancelling_at": null,
      "completed_at": 1729011896,
      "completion_window": "24h",
      "created_at": 1729011128,
      "error_file_id": "file-472c0626-4561-4327-9e4e-f41afbfb30e6",
      "expired_at": null,
      "expires_at": 1729097528,
      "failed_at": null,
      "finalizing_at": 1729011805,
      "id": "batch_4ddc7b60-19a9-419b-8b93-b9a3274b33b5",
      "in_progress_at": 1729011493,
      "input_file_id": "file-f89384af0082485da43cb26b49dc25ce",
      "errors": null,
      "metadata": null,
      "object": "batch",
      "output_file_id": "file-62bebde8-e767-4cd3-a0a1-28b214dc8974",
      "request_counts": {
        "total": 3,
        "completed": 2,
        "failed": 1
      },
      "status": "completed",
      "endpoint": "/chat/completions"
    },
    {
      "cancelled_at": null,
      "cancelling_at": null,
      "completed_at": 1729016366,
      "completion_window": "24h",
      "created_at": 1729015829,
      "error_file_id": "file-85ae1971-9957-4511-9eb4-4cc9f708b904",
      "expired_at": null,
      "expires_at": 1729102229,
      "failed_at": null,
      "finalizing_at": 1729016272,
      "id": "batch_6287485f-50fc-4efa-bcc5-b86690037f43",
      "in_progress_at": 1729016126,
      "input_file_id": "file-686746fcb6bc47f495250191ffa8a28e",
      "errors": null,
      "metadata": null,
      "object": "batch",
      "output_file_id": "file-04399828-ae0b-4825-9b49-8976778918cb",
      "request_counts": {
        "total": 3,
        "completed": 2,
        "failed": 1
      },
      "status": "completed",
      "endpoint": "/chat/completions"
    }
  ],
  "first_id": "batch_4ddc7b60-19a9-419b-8b93-b9a3274b33b5",
  "has_more": false,
  "last_id": "batch_6287485f-50fc-4efa-bcc5-b86690037f43"
}

Como colocar trabalhos em lotes na fila

Se os seus trabalhos em lotes são tão grandes que você está atingindo o limite de token na fila mesmo depois de maximizar a cota para sua implantação, algumas regiões já dão suporte a um novo recurso de fail fast que permite colocar vários trabalhos em lotes na fila com a retirada exponencial. Depois que um trabalho em lotes grande for concluído e sua cota de tokens em fila estiver novamente disponível, os próximos trabalhos em lotes poderão ser criados e iniciados automaticamente.

Comportamento antigo:

  1. Trabalhos em lotes grandes já em execução e usando todos os tokens disponíveis para sua implementação.
  2. Novo trabalho em lotes enviado.
  3. O novo trabalho em lote entra em fase de validação que pode durar até alguns minutos.
  4. A contagem de tokens para o novo trabalho é verificada em relação à cota atualmente disponível.
  5. O novo trabalho em lotes falha com o limite de token de relatório de erros excedido.

Novo comportamento:

  1. Trabalhos em lotes grandes já em execução e usando todos os tokens disponíveis para sua implantação
  2. Novo trabalho em lotes enviado
  3. A contagem aproximada de tokens de um novo trabalho é imediatamente comparada com a cota de lote atualmente disponível e o fail fast de trabalhos, permitindo que você lide com as repetições com mais facilidade por meio de programação.

Suporte de regiões

As seguintes regiões dão suporte ao novo comportamento de fail fast:

  • australiaeast
  • eastus
  • alemanhacentro-oeste
  • italynorth
  • northcentralus
  • Polônia Central
  • swedencentral
  • Suíça Norte
  • eastus2
  • westus

O código abaixo demonstra a mecânica básica de lidar com o comportamento de fail fast para permitir a automatização de novas repetições e o enfileiramento de trabalhos em lotes com a retirada exponencial.

Dependendo do tamanho dos trabalhos em lotes, talvez seja necessário aumentar as max_retries ou alterar ainda mais este exemplo.

import time
from openai import BadRequestError

max_retries = 10
retries = 0
initial_delay = 5
delay = initial_delay

while True:
    try:
        batch_response = client.batches.create(
            input_file_id=file_id,
            endpoint="/chat/completions",
            completion_window="24h",
        )
        
        # Save batch ID for later use
        batch_id = batch_response.id
        
        print(f"✅ Batch created successfully after {retries} retries")
        print(batch_response.model_dump_json(indent=2))
        break  
        
    except BadRequestError as e:
        error_message = str(e)
        
        # Check if it's a token limit error
        if 'token_limit_exceeded' in error_message:
            retries += 1
            if retries >= max_retries:
                print(f"❌ Maximum retries ({max_retries}) reached. Giving up.")
                raise
            
            print(f"⏳ Token limit exceeded. Waiting {delay} seconds before retry {retries}/{max_retries}...")
            time.sleep(delay)
            
            # Exponential backoff - increase delay for next attempt
            delay *= 2
        else:
            # If it's a different error, raise it immediately
            print(f"❌ Encountered non-token limit error: {error_message}")
            raise

Saída:

⏳ Token limit exceeded. Waiting 5 seconds before retry 1/10...
⏳ Token limit exceeded. Waiting 10 seconds before retry 2/10...
⏳ Token limit exceeded. Waiting 20 seconds before retry 3/10...
⏳ Token limit exceeded. Waiting 40 seconds before retry 4/10...
⏳ Token limit exceeded. Waiting 80 seconds before retry 5/10...
⏳ Token limit exceeded. Waiting 160 seconds before retry 6/10...
⏳ Token limit exceeded. Waiting 320 seconds before retry 7/10...
✅ Batch created successfully after 7 retries
{
  "id": "batch_1e1e7b9f-d4b4-41fa-bd2e-8d2ec50fb8cc",
  "completion_window": "24h",
  "created_at": 1744402048,
  "endpoint": "/chat/completions",
  "input_file_id": "file-e2ba4ccaa4a348e0976c6fe3c018ea92",
  "object": "batch",
  "status": "validating",
  "cancelled_at": null,
  "cancelling_at": null,
  "completed_at": null,
  "error_file_id": "",
  "errors": null,
  "expired_at": null,
  "expires_at": 1744488444,
  "failed_at": null,
  "finalizing_at": null,
  "in_progress_at": null,
  "metadata": null,
  "output_file_id": "",
  "request_counts": {
    "completed": 0,
    "failed": 0,
    "total": 0
  }
}

Pré-requisitos

Preparar seu arquivo em lote

Assim como o ajuste fino, o lote global usa arquivos no formato de linhas JSON (.jsonl). Abaixo estão alguns arquivos de exemplo com diferentes tipos de conteúdo com suporte:

Formato de entrada

API de Respostas

{"custom_id": "task-0", "method": "POST", "url": "/v1/responses", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "input": "When was Microsoft founded, and by whom?"}}
{"custom_id": "task-1", "method": "POST", "url": "/v1/responses", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "input": "When was XBOX merged into Microsoft?"}}
{"custom_id": "task-2", "method": "POST", "url": "/v1/responses", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "input": "What is Visual Basic?"}}

API de finalizações de chat

{"custom_id": "task-0", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "messages": [{"role": "system", "content": "You are an AI assistant that helps people find information."}, {"role": "user", "content": "When was Microsoft founded?"}]}}
{"custom_id": "task-1", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "messages": [{"role": "system", "content": "You are an AI assistant that helps people find information."}, {"role": "user", "content": "When was the first XBOX released?"}]}}
{"custom_id": "task-2", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "REPLACE-WITH-MODEL-DEPLOYMENT-NAME", "messages": [{"role": "system", "content": "You are an AI assistant that helps people find information."}, {"role": "user", "content": "What is Altair Basic?"}]}}

O custom_id é necessário para permitir que você identifique quais solicitações em lote individuais correspondem a uma determinada resposta. As respostas não serão retornadas em ordem idêntica à ordem definida no arquivo em lote .jsonl.

O atributo model deve ser definido para corresponder ao nome da implantação do Lote Global que você deseja direcionar para respostas de inferência.

Importante

O atributo model deve ser configurado para corresponder ao nome da implantação do Lote Global que você deseja direcionar para as respostas de inferência. O mesmo nome de implantação do modelo do Lote Globa deve estar presente em cada linha do arquivo de lote. Se você quiser direcionar uma implantação diferente, deverá fazê-lo em um arquivo de lote/trabalho separado.

Para obter um melhor desempenho, recomendamos enviar arquivos grandes para processamento em lote, em vez de muitos arquivos pequenos com apenas algumas linhas em cada um.

Criar arquivo de entrada

Para este artigo, criaremos um arquivo nomeado test.jsonl e copiaremos o conteúdo do bloco de código de entrada padrão acima para o arquivo. Você precisará modificar e adicionar seu nome de implantação em lote global a cada linha do arquivo.

Carregar arquivo em lote

Depois que o arquivo de entrada estiver preparado, primeiro você precisará carregar o arquivo para poder iniciar um trabalho em lotes. O upload de arquivo pode ser feito programaticamente ou por meio do portal do Microsoft Foundry. Este exemplo demonstra o carregamento de um arquivo diretamente para o recurso do Azure OpenAI. Como alternativa, você pode configurar o Armazenamento de Blobs do Azure para o Azure OpenAI Batch.

Importante

Use as chaves de API com cuidado. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente. Se você usar uma chave de API, armazene-a com segurança no Azure Key Vault. Para obter mais informações sobre como usar chaves de API com segurança em seus aplicativos, confira Chaves de API com o Azure Key Vault.

Para obter mais informações sobre a segurança dos serviços de IA, veja Autenticar solicitações para serviços de IA do Azure.

curl -X POST https://YOUR_RESOURCE_NAME.openai.azure.com/openai/v1/files \
  -H "Content-Type: multipart/form-data" \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -F "purpose=batch" \
  -F "file=@C:\\batch\\test.jsonl;type=application/json" \
  -F "expires_after.seconds=1209600" \
  -F "expires_after.anchor=created_at"

O código acima pressupõe um caminho de arquivo específico para o arquivo test.jsonl. Ajuste esse caminho de arquivo conforme necessário para seu sistema local.

Ao adicionar os parâmetros opcionais "expires_after.seconds=1209600" e "expires_after.anchor=created_at", você está definindo seu arquivo carregado para expirar em 14 dias. Há um limite máximo de 500 arquivos de entrada em lote por recurso quando nenhuma expiração é definida. Ao definir um valor para expiração, o número de arquivos em lote por recurso é aumentado para 10.000 arquivos por recurso. Você pode defini-lo como um número entre 1.209.600-2.592.000. Isso equivale a 14 a 30 dias. Para remover os limites de arquivos de entrada em lote, use o recurso Lote com o Armazenamento de Blobs do Azure.

Saída:

{
  "status": "processed",
  "bytes": 817,
  "purpose": "batch",
  "filename": "test.jsonl",
  "expires_at": 1744607747,
  "id": "file-7733bc35e32841e297a62a9ee50b3461",
  "created_at": 1743398147,
  "object": "file"
}

Acompanhar o status de upload de arquivo

Dependendo do tamanho do arquivo de carregamento, pode levar algum tempo até que ele seja totalmente carregado e processado. Para verificar o status do upload do arquivo, execute:

curl https://YOUR_RESOURCE_NAME.openai.azure.com/openai/v1/files/{file-id} \
  -H "api-key: $AZURE_OPENAI_API_KEY"

Saída:

{
  "status": "processed",
  "bytes": 686,
  "purpose": "batch",
  "filename": "test.jsonl",
  "expires_at": 1744607747,
  "id": "file-7733bc35e32841e297a62a9ee50b3461",
  "created_at": 1721408291,
  "object": "file"
}

Criar um trabalho em lotes

Após carregar o arquivo, você poderá enviar o arquivo para processamento em lote.

curl -X POST https://YOUR_RESOURCE_NAME.openai.azure.com/openai/v1/batches \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input_file_id": "file-abc123",
    "endpoint": "/chat/completions",
    "completion_window": "24h",
    "output_expires_after": {
        "seconds": 1209600
    },
    "anchor": "created_at"
  }'

Aqui você pode, opcionalmente, adicionar "output_expires_after":{"seconds": 1209600}, e "anchor": "created_at" para que os arquivos de saída expirem em 14 dias.

Observação

Atualmente, a janela de conclusão deve ser definida como 24h. Se você definir qualquer valor que não seja 24h, seu trabalho falhará. Os trabalhos que levam mais de 24 horas continuarão a ser executados até serem cancelados.

Saída:

{
  "cancelled_at": null,
  "cancelling_at": null,
  "completed_at": null,
  "completion_window": "24h",
  "created_at": "2024-07-19T17:13:57.2491382+00:00",
  "error_file_id": null,
  "expired_at": null,
  "expires_at": "2024-07-20T17:13:57.1918498+00:00",
  "failed_at": null,
  "finalizing_at": null,
  "id": "batch_fe3f047a-de39-4068-9008-346795bfc1db",
  "in_progress_at": null,
  "input_file_id": "file-21006e70789246658b86a1fc205899a4",
  "errors": null,
  "metadata": null,
  "object": "batch",
  "output_file_id": null,
  "request_counts": {
    "total": null,
    "completed": null,
    "failed": null
  },
  "status": "Validating"
}

Acompanhar o progresso do trabalho em lotes

Depois de criar um trabalho em lote com êxito, você poderá monitorar seu progresso no Studio ou programaticamente. Ao verificar o progresso do trabalho em lotes, recomendamos aguardar pelo menos 60 segundos entre cada chamada de status.

curl https://YOUR_RESOURCE_NAME.openai.azure.com/openai/v1/batches/{batch_id} \
  -H "api-key: $AZURE_OPENAI_API_KEY"

Saída:

{
  "cancelled_at": null,
  "cancelling_at": null,
  "completed_at": null,
  "completion_window": "24h",
  "created_at": "2024-07-19T17:33:29.1619286+00:00",
  "error_file_id": null,
  "expired_at": null,
  "expires_at": "2024-07-20T17:33:29.1578141+00:00",
  "failed_at": null,
  "finalizing_at": null,
  "id": "batch_e0a7ee28-82c4-46a2-a3a0-c13b3c4e390b",
  "in_progress_at": null,
  "input_file_id": "file-c55ec4e859d54738a313d767718a2ac5",
  "errors": null,
  "metadata": null,
  "object": "batch",
  "output_file_id": null,
  "request_counts": {
    "total": null,
    "completed": null,
    "failed": null
  },
  "status": "Validating"
}

Os seguintes valores de status são possíveis:

Estado Descrição
validating O arquivo de entrada está sendo validado antes que o processamento em lote possa começar.
failed O arquivo de entrada falhou no processo de validação.
in_progress O arquivo de entrada foi validado com êxito e o lote está em execução no momento.
finalizing O lote foi concluído e os resultados estão sendo preparados.
completed O lote foi concluído e os resultados estão prontos.
expired O lote não pôde ser concluído dentro da janela de tempo de 24 horas.
cancelling O lote está sendo cancelled (isso pode levar até 10 minutos para entrar em vigor.)
cancelled o lote era cancelled.

Recuperar o arquivo de saída do trabalho em lote

curl https://YOUR_RESOURCE_NAME.openai.azure.com/openai/v1/files/{output_file_id}/content \
  -H "api-key: $AZURE_OPENAI_API_KEY" > batch_output.jsonl

Comandos de lote adicionais

Cancelar lote

Cancela um lote em andamento. O lote ficará em status cancelling por até 10 minutos, antes de ser alterado para cancelled, onde terá resultados parciais (se houver) disponíveis no arquivo de saída.

curl -X POST https://YOUR_RESOURCE_NAME.openai.azure.com/openai/v1/batches/{batch_id}/cancel \
  -H "api-key: $AZURE_OPENAI_API_KEY"

Listar lote

Liste os trabalhos em lotes existentes para um determinado recurso do OpenAI do Azure.

curl https://YOUR_RESOURCE_NAME.openai.azure.com/openai/v1/batches \
  -H "api-key: $AZURE_OPENAI_API_KEY"

A chamada à API de lista é paginada. A resposta contém um booliano has_more para indicar quando há mais resultados para iterar.

Lote de lista (Versão prévia)

Use a API REST para listar todos os trabalhos em lote com opções adicionais de classificação/filtragem.

curl "YOUR_RESOURCE_NAME.openai.azure.com/batches?api-version=2025-04-01-preview&$filter=created_at%20gt%201728773533%20and%20created_at%20lt%201729032733%20and%20status%20eq%20'Completed'&$orderby=created_at%20asc" \
  -H "api-key: $AZURE_OPENAI_API_KEY"

Para evitar o erro URL rejected: Malformed input to a URL function, os espaços são substituídos por %20.

Limites do Lote

Nome do limite Valor limite
Máximo de arquivos de entrada de batch – (sem expiração) 500
Máximo de arquivos de entrada em lote - (expiração definida) 10,000
Tamanho máximo do arquivo de entrada 200 MB
Máximo de solicitações por arquivo 100,000

Observação

Os limites de arquivo em lote não se aplicam a arquivos de saída (por exemplo, result.jsonle error.jsonl). Para remover os limites de arquivos de entrada em lote, use o recurso Lote com o Armazenamento de Blobs do Azure.

Cota do lote

A tabela mostra o limite de cota do lote. Os valores de cota para o lote global são representados em termos de tokens enfileirados. Quando você envia um arquivo para processamento em lote, o número de tokens no arquivo é contado. Até que o trabalho em lote atinja um estado de terminal, esses tokens contam com relação ao limite total de tokens enfileirados.

Lote global

Modelo Enterprise e MCA-E Padrão Assinaturas mensais baseadas em cartão de crédito Assinaturas MSDN Azure for Students, avaliações gratuitas
gpt-4.1 5 bilhões 200 milhões 50 mi 90 mil Não aplicável
gpt-4.1 mini 15 bi 1 bi 50 mi 90 mil Não aplicável
gpt-4.1-nano 15 bi 1 bi 50 mi 90 mil Não aplicável
gpt-4o 5 bilhões 200 milhões 50 mi 90 mil Não aplicável
gpt-4o-mini 15 bi 1 bi 50 mi 90 mil Não aplicável
gpt-4-turbo 300 milhões 80 milhões 40 milhões 90 mil Não aplicável
gpt-4 150 milhões 30 milhões 5 M 100 mil Não aplicável
o3-mini 15 bi 1 bi 50 mi 90 mil Não aplicável
o4-mini 15 bi 1 bi 50 mi 90 mil Não aplicável
gpt-5 5 bilhões 200 milhões 50 mi 90 mil Não aplicável

B = bilhões | M = milhões | K = mil

Lote da zona de dados

Modelo Enterprise e MCA-E Padrão Assinaturas mensais baseadas em cartão de crédito Assinaturas MSDN Azure for Students, avaliações gratuitas
gpt-4.1 500 milhões 30 milhões 30 milhões 90 mil Não aplicável
gpt-4.1-mini 1,5 bilhões 100 milhões 50 mi 90 mil Não aplicável
gpt-4o 500 milhões 30 milhões 30 milhões 90 mil Não aplicável
gpt-4o-mini 1,5 bilhões 100 milhões 50 mi 90 mil Não aplicável
o3-mini 1,5 bilhões 100 milhões 50 mi 90 mil Não aplicável
gpt-5 5 bilhões 200 milhões 50 mi 90 mil Não aplicável

Objeto de lote

Propriedade Tipo Definição
id cadeia
object cadeia batch
endpoint cadeia O ponto de extremidade de API usado pelo lote
errors objeto
input_file_id cadeia A ID do arquivo de entrada para o lote
completion_window cadeia O período dentro do qual o lote deve ser processado
status cadeia O status atual do lote. Valores possíveis: validating, failed, in_progress, finalizing, completed, expired, cancelling e cancelled.
output_file_id cadeia A ID do arquivo que contém as saídas de solicitações executadas com êxito.
error_file_id cadeia A ID do arquivo que contém as saídas de solicitações com erros.
created_at inteiro Um carimbo de data/hora quando esse lote foi criado (em épocas do Unix).
in_progress_at inteiro Um carimbo de data/hora quando este lote começou a progredir (em épocas do Unix).
expires_at inteiro Um carimbo de data/hora em que esse lote expirará (em épocas do Unix).
finalizing_at inteiro Um carimbo de data/hora quando este lote começou a ser finalizado (em épocas do Unix).
completed_at inteiro Um carimbo de data/hora quando este lote começou a ser finalizado (em épocas do Unix).
failed_at inteiro Um carimbo de data/hora quando esse lote falhou (em épocas do Unix)
expired_at inteiro Um carimbo de data/hora quando esse lote expirou (em épocas do Unix).
cancelling_at inteiro Um carimbo de data/hora quando este lote foi iniciado cancelling (em épocas do Unix).
cancelled_at inteiro Um carimbo de data/hora quando este lote estava cancelled (em épocas do Unix).
request_counts objeto Estrutura do objeto:

total inteiro
O número total de solicitações no lote.
completed inteiro
O número de solicitações no lote que foram concluídas com êxito.
failed inteiro
O número de solicitações no lote que falharam.
metadata mapa Um conjunto de pares chave-valor que podem ser anexados ao lote. Esta propriedade poderá ser útil para armazenar informações adicionais sobre o lote em um formato estruturado.

Perguntas frequentes (FAQ)

É possível usar imagens com a API em lote?

Essa funcionalidade é limitada a determinados modelos multi modais. Atualmente, apenas GPT-4o dá suporte a imagens como parte de solicitações em lote. As imagens podem ser fornecidas como entrada por meio doURL da imagem ou de uma representação codificada em base64 da imagem. No momento, não há suporte para imagens em lote com GPT-4 Turbo.

Posso usar a API em lote com modelos afinados?

Não há suporte para esse recurso no momento.

Posso usar a API em lote para modelos de embeddings?

Não há suporte para esse recurso no momento.

A filtragem de conteúdo funciona com a implantação do Lote Global?

Sim. Semelhante a outros tipos de implantação, você poderá criar filtros de conteúdo e associá-los ao tipo de implantação do Lote Global.

Posso solicitar cota adicional?

Sim, na página de cota no portal do Foundry. A alocação de cota padrão pode ser encontrada no artigo de cota e limites.

O que acontece se a API não concluir minha solicitação dentro do período de 24 horas?

Nosso objetivo é processar essas solicitações dentro de 24 horas; não expiramos os trabalhos que levam mais tempo. Você poderá cancelar o trabalho a qualquer momento. Quando você cancela o trabalho, qualquer trabalho restante é cancelado e qualquer trabalho já concluído é retornado. Você será cobrado por qualquer trabalho concluído.

Quantas solicitações posso colocar em fila usando processamento em lote?

Não há nenhum limite fixo no número de solicitações que você poderá fazer em lote, no entanto, isso dependerá da cota de token enfileirada. Sua cota de token enfileirada inclui o número máximo de tokens de entrada que você poderá enfileirar ao mesmo tempo.

Depois que a solicitação em lote for concluída, o limite de taxa de lote será redefinido, pois os tokens de entrada serão limpos. O limite depende do número de solicitações globais na fila. Se a fila da API do Lote processar seus lotes rapidamente, o limite de taxa de lote será redefinido mais rapidamente.

Resolução de problemas

Um trabalho é bem-sucedido quando status é Completed. Trabalhos bem-sucedidos ainda gerarão um error_file_id, mas ele será associado a um arquivo vazio com zero bytes.

Quando ocorrer uma falha no trabalho, você encontrará detalhes sobre a falha na propriedade errors:

"value": [
        {
          "id": "batch_80f5ad38-e05b-49bf-b2d6-a799db8466da",
          "completion_window": "24h",
          "created_at": 1725419394,
          "endpoint": "/chat/completions",
          "input_file_id": "file-c2d9a7881c8a466285e6f76f6321a681",
          "object": "batch",
          "status": "failed",
          "cancelled_at": null,
          "cancelling_at": null,
          "completed_at": 1725419955,
          "error_file_id": "file-3b0f9beb-11ce-4796-bc31-d54e675f28fb",
          "errors": {
                "object": “list”,
                "data": [
                {
               "code": "empty_file",
               "message": "The input file is empty. Please ensure that the batch contains at least one   request."
                    }
                ]
          },
          "expired_at": null,
          "expires_at": 1725505794,
          "failed_at": null,
          "finalizing_at": 1725419710,
          "in_progress_at": 1725419572,
          "metadata": null,
          "output_file_id": "file-ef12af98-dbbc-4d27-8309-2df57feed572",

            "request_counts": {
                "total": 10,
                "completed": null,
                "failed": null
            },
        }

Códigos de erro

Código do erro Definição
invalid_json_line Uma linha (ou várias) no arquivo de entrada não pôde ser analisada como json válida.

Verifique se não há erros de digitação, colchetes de abertura e fechamento adequados e aspas de acordo com o padrão do JSON e reenvie a solicitação.
too_many_tasks O número de solicitações no arquivo de entrada excede o valor máximo permitido de 100.000.

Verifique se o total de solicitações está abaixo de 100.000 e reenvie o trabalho.
url_mismatch Uma linha no arquivo de entrada tem um URL que não corresponde ao restante das linhas ou o URL especificado no arquivo de entrada não corresponde ao URL do ponto de extremidade esperada.

Verifique se todos os URLs de solicitação são iguais e se correspondem ao URL do ponto de extremidade associado à implantação do Azure OpenAI.
model_not_found O nome de implantação do modelo do OpenAI do Azure especificado na propriedade model do arquivo de entrada não foi encontrado.

Verifique se esse nome aponta para uma implantação de modelo válida do OpenAI do Azure.
duplicate_custom_id A ID personalizada dessa solicitação é uma duplicata da ID personalizada em outra solicitação.
empty_batch Verifique o arquivo de entrada para garantir que o parâmetro de ID personalizado seja exclusivo para cada solicitação no lote.
model_mismatch O nome de implantação do modelo do OpenAI do Azure especificado na propriedade model dessa solicitação no arquivo de entrada não corresponde ao restante do arquivo.

Certifique-se de que todas as solicitações no lote apontem para a mesma implantação de modelo do Azure OpenAI no Foundry Models, na propriedade model da solicitação.
invalid_request O esquema da linha de entrada é inválido ou o SKU de implantação é inválido.

Verifique se as propriedades da solicitação no arquivo de entrada correspondem às propriedades de entrada esperadas e se a SKU de implantação do OpenAI do Azure é globalbatch para solicitações de API em lote.
input_modified A entrada de blob foi modificada após o envio do trabalho em lote.
input_no_permissions Não é possível acessar o blob de entrada. Verifique as permissões e o acesso à rede entre a conta do Azure OpenAI e a conta de Armazenamento do Azure.

Problemas conhecidos

  • Os recursos implantados com a CLI do Azure não funcionarão prontamente com o lote global do OpenAI do Azure. Isso ocorre devido a um problema em que os recursos implantados usando esse método têm subdomínios de ponto de extremidade que não seguem o padrão https://your-resource-name.openai.azure.com. Uma solução alternativa para esse problema é implantar um novo recurso do OpenAI do Azure usando um dos outros métodos de implantação comuns que manipularão corretamente a configuração do subdomínio como parte do processo de implantação.

  • Não há suporte para arquivos codificados jsonl em UTF-8-BOM. Os arquivos de linhas JSON devem ser codificados usando UTF-8. O uso de arquivos codificados em Byte-Order-Mark (BOM) não é oficialmente compatível com a especificação JSON RFC e o Azure OpenAI tratará atualmente os arquivos codificados em BOM como inválidos. Um arquivo codificado em UTF-8-BOM retornará atualmente a mensagem de erro genérica: "Falha na validação: não foi possível extrair um nome de implantação de modelo válido do arquivo de entrada. Verifique se cada linha no arquivo de entrada tem um nome de implantação válido especificado no campo 'modelo' e se o nome da implantação é consistente em todas as linhas."

  • Ao usar um armazenamento próprio para os dados de entrada em lote, depois que o trabalho em lote for enviado, se o blob de entrada for modificado, o trabalho de pontuação será reprovado pelo serviço.

Consulte também

  • Last updated on