Compartir a través de

Introducción a las implementaciones de lotes de Azure OpenAI

La API de Batch de Azure OpenAI está diseñada para controlar las tareas de procesamiento a gran escala y de alto volumen de forma eficaz. Procesa grupos asincrónicos de solicitudes con cuota independiente, con un objetivo de respuesta en 24 horas, a un costo un 50% menor que el estándar global. Con el procesamiento por lotes, en lugar de enviar una solicitud cada vez, se envía un gran número de solicitudes en un único archivo. Las solicitudes por lotes globales tienen una cuota independiente de tokens acumulados para evitar cualquier interrupción de las cargas de trabajo en línea.

Los siguientes son algunos de los principales casos de uso:

  • Procesamiento de datos a gran escala: analice rápidamente conjuntos de datos extensos en paralelo.

  • Generación de contenido: cree grandes volúmenes de texto, como descripciones de productos o artículos.

  • Revisión y resumen de documentos: automatice la revisión y el resumen de documentos largos.

  • Automatización del soporte al cliente: controle numerosas consultas simultáneamente para respuestas más rápidas.

  • Extracción y análisis de datos: extraiga y analice información de grandes cantidades de datos no estructurados.

  • Tareas de procesamiento de lenguaje natural (NLP): realice tareas como análisis de sentimiento o traducción en grandes conjuntos de datos.

  • Marketing y personalización: genere contenido personalizado y recomendaciones a gran escala.

Sugerencia

Si los trabajos por lotes son tan grandes que alcanzan el límite de tokens en cola incluso después de limitar la cuota de la implementación, algunas regiones ahora admiten una nueva característica que le permite poner en cola varios trabajos por lotes con retroceso exponencial.

Una vez que la cuota de tokens en cola vuelva a estar disponible, el siguiente trabajo por lotes se podrá crear e iniciar automáticamente. Para más información, consulte automatización de reintentos de trabajos por lotes de gran tamaño con retroceso exponencial.

Importante

Nuestro objetivo es procesar solicitudes por lotes en un plazo de 24 horas; no expiraremos los trabajos que tardan más tiempo. Puede cancelar el trabajo en cualquier momento. Al cancelar el trabajo, se cancela cualquier trabajo restante y se devuelve cualquier trabajo ya completado. Se le cobrará por cualquier trabajo completado.

Los datos almacenados en reposo permanecen en la geografía de Azure designada, mientras que los datos se pueden procesar para la inferencia en cualquier ubicación de Azure OpenAI.  Obtenga más información sobre la retención de datos. 

Soporte técnico de Batch

Disponibilidad global del modelo por lotes

Región 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 Sur ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
este de Canadá ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
centralus ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
eastus ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
eastus2 ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
francecentral ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Alemania Oeste Central ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
japaneast ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
koreacentral ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
northcentralus ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
NoruegaEste ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
poloniacentral ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Sudáfrica Norte ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
southcentralus ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Sur de la India ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Swedencentral ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Suiza Norte ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
uksouth ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
Europa Occidental ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
westus ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅
westus3 ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅

El registro es necesario para acceder a gpt-5 y o3 para obtener más información, consulte nuestra guía de modelos de razonamiento.

Los modelos siguientes admiten lotes globales:

Modelo Versión Formato de entrada
gpt-5 2025-08-7 Texto e imagen
o3 2025-04-16 Texto e imagen
o3-mini 31-01-2025 texto
gpt-4o 2024-08-06 Texto e imagen
gpt-4o-mini 18/07/2024 Texto e imagen
gpt-4o 13-05-2024 Texto e imagen

Nota:

Aunque Global Batch admite versiones anteriores de la API, algunos modelos requieren versiones más recientes de la API en versión preliminar. Por ejemplo, o3-mini no es compatible con 2024-10-21 porque se lanzó después de esta fecha. Para acceder a los modelos más recientes con el lote global, use la versión preliminar más reciente de la API.

Soporte de funcionalidades

Actualmente, no se admiten los siguientes:

  • Integración con la API de asistentes.
  • Integración con la característica Azure OpenAI en los datos.

Despliegue por lotes

Nota:

En el portal de Microsoft Foundry , los tipos de implementación por lotes aparecerán como Global-Batch y Data Zone Batch. Para más información sobre los tipos de implementación de Azure OpenAI, consulte nuestra guía de tipos de implementación .

Sugerencia

Se recomienda habilitar cuota dinámica para todas las implementaciones de modelos por lotes globales para ayudar a evitar errores de trabajo debido a una cuota de tokens en cola insuficiente. El uso de la cuota dinámica permite que la implementación aproveche de forma oportunista más cuota cuando haya capacidad adicional disponible. Cuando la cuota dinámica se establece en desactivada, la implementación solo podrá procesar solicitudes hasta el límite de tokens en cola que se definió al crear la implementación.

Prerrequisitos

  • Una suscripción de Azure: cree una gratuitamente.
  • Un recurso con un modelo del tipo de implementación de GlobalBatch o DataZoneBatch implementado.

Preparación del archivo por lotes

Al igual que el ajuste, el lote usa archivos en formato de líneas JSON (.jsonl). A continuación se muestran algunos archivos de ejemplo con diferentes tipos de contenido admitido:

Formato de entrada

API de respuestas

{"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 finalizaciones 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?"}]}}

custom_id es necesario para permitir identificar qué solicitud por lotes individual corresponde a una respuesta determinada. Las respuestas no se devolverán en orden idéntico al orden definido en el archivo por lotes .jsonl.

Debe establecerse el atributo model para que coincida con el nombre de la implementación del lote global que desea establecer como destino para las respuestas de inferencia.

Importante

El atributo model debe establecerse para que coincida con el nombre de la implementación de Batch global que desea establecer como destino para las respuestas de inferencia. El mismo nombre de implementación del modelo de Batch global debe estar presente en cada línea del archivo por lotes. Si desea tener como destino una implementación diferente, debe hacerlo en un archivo o trabajo por lotes independiente.

Para obtener el mejor rendimiento, se recomienda enviar archivos grandes para el procesamiento por lotes, en lugar de un gran número de archivos pequeños con solo unas pocas líneas en cada archivo.

Crear un archivo de entrada

En este artículo, crearemos un archivo denominado test.jsonl y copiaremos el contenido del bloque de código de entrada estándar anterior al archivo. Deberá modificar y agregar el nombre de implementación del lote global a cada línea del archivo.

Creación de trabajo por lotes

Una vez preparado el archivo de entrada, primero debe cargar el archivo para poder iniciar un trabajo por lotes. La carga de archivos se puede realizar mediante programación o a través del portal de Microsoft Foundry. En este ejemplo se muestra cómo cargar un archivo directamente en el recurso de Azure OpenAI. Como alternativa, puede configurar Azure Blob Storage para Azure OpenAI Batch.

  1. Inicie sesión en Microsoft Foundry. Asegúrese de que el conmutador New Foundry está desactivado. Estos pasos hacen referencia a Foundry (clásico).

  2. Seleccione el recurso de Azure OpenAI donde hay disponible una implementación de modelo por lotes global.

  3. Seleccione Trabajos de Batch>+Crear trabajos por lotes.

    Captura de pantalla que muestra la experiencia de creación de trabajos por lotes en el portal de Foundry.

  4. En la lista desplegable en Datos por lote>Cargar archivos>, seleccione Cargar archivo y proporcione la ruta de acceso al archivo test.jsonl creado en el paso anterior >Siguiente.

    Captura de pantalla que muestra la experiencia de carga de archivos

Seleccione Crear para iniciar su trabajo por lotes.

  1. Inicie sesión en Microsoft Foundry. Asegúrese de que el interruptor New Foundry está activado. Estos pasos hacen referencia a Foundry (nuevo).

  2. En la esquina superior derecha, seleccione Compilar.

  3. En el panel izquierdo, seleccione Modelos.

  4. Seleccione Trabajos por lotes>para crear un trabajo por lotes.

    Captura de pantalla de la nueva experiencia de creación de lotes de Foundry.

Seguimiento del progreso del trabajo por lotes

Una vez creado el trabajo, puede supervisar el progreso seleccionando el identificador de trabajo para el trabajo creado más recientemente. De manera predeterminada, accederá a la página de estado de su trabajo por lotes creado más recientemente.

Puede realizar un seguimiento del estado de su trabajo en el panel derecho.

Recuperar el archivo de salida del trabajo por lotes

Una vez que su trabajo haya finalizado o alcanzado un estado terminal, generará un archivo de error y un archivo de salida que podrá descargar para su revisión seleccionando el botón correspondiente con el icono de la flecha hacia abajo.

Cancelación del lote

Cancela un lote en curso. El lote estará en estado cancelling durante un máximo de 10 minutos, antes de cambiar a cancelled, donde tendrá resultados parciales (si los hay) disponibles en el archivo de salida.

Seguimiento del progreso del trabajo por lotes

Una vez creado el trabajo, puede supervisar el progreso seleccionando el identificador de trabajo para el trabajo creado más recientemente. De manera predeterminada, accederá a la página de estado de su trabajo por lotes creado más recientemente.

Puede realizar un seguimiento del estado de su trabajo en el panel derecho.

Recuperar el archivo de salida del trabajo por lotes

Una vez que su trabajo haya finalizado o alcanzado un estado terminal, generará un archivo de error y un archivo de salida que podrá descargar para su revisión seleccionando el botón correspondiente con el icono de la flecha hacia abajo.

Cancelación del lote

Cancela un lote en curso. El lote estará en estado cancelling durante un máximo de 10 minutos, antes de cambiar a cancelled, donde tendrá resultados parciales (si los hay) disponibles en el archivo de salida.

Prerrequisitos

Los pasos de este artículo están diseñados para ejecutarse secuencialmente en Jupyter Notebooks. Por este motivo, solo crearemos instancias del cliente de Azure OpenAI una vez al principio de los ejemplos. Si desea ejecutar un paso fuera de orden, a menudo tendrá que configurar un cliente de Azure OpenAI como parte de esa llamada.

Incluso si ya tiene instalada la biblioteca de Python de OpenAI, es posible que tenga que actualizar la instalación a la versión más reciente:

!pip install openai --upgrade

Preparación del archivo por lotes

Al igual que el ajuste, el lote global usa archivos en formato de líneas JSON (.jsonl). A continuación se muestran algunos archivos de ejemplo con diferentes tipos de contenido admitido:

Formato de entrada

API de respuestas

{"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 finalizaciones 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?"}]}}

custom_id es necesario para permitir identificar qué solicitud por lotes individual corresponde a una respuesta determinada. Las respuestas no se devolverán en orden idéntico al orden definido en el archivo por lotes .jsonl.

Debe establecerse el atributo model para que coincida con el nombre de la implementación del lote global que desea establecer como destino para las respuestas de inferencia.

Importante

El atributo model debe establecerse para que coincida con el nombre de la implementación de Batch global que desea establecer como destino para las respuestas de inferencia. El mismo nombre de implementación del modelo de Batch global debe estar presente en cada línea del archivo por lotes. Si desea tener como destino una implementación diferente, debe hacerlo en un archivo o trabajo por lotes independiente.

Para obtener el mejor rendimiento, se recomienda enviar archivos grandes para el procesamiento por lotes, en lugar de un gran número de archivos pequeños con solo unas pocas líneas en cada archivo.

Crear un archivo de entrada

En este artículo, crearemos un archivo denominado test.jsonl y copiaremos el contenido del bloque de código de entrada estándar anterior al archivo. Deberá modificar y agregar el nombre de implementación del lote global a cada línea del archivo. Guarda este archivo en el mismo directorio donde estás ejecutando tu Jupyter Notebook.

Carga del archivo por lotes

Una vez preparado el archivo de entrada, primero debe cargar el archivo para poder iniciar un trabajo por lotes. La carga de archivos se puede realizar mediante programación o a través del portal de Microsoft Foundry. En este ejemplo se muestra cómo cargar un archivo directamente en el recurso de Azure OpenAI. Como alternativa, puede configurar Azure Blob Storage para 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

Al quitar la marca de comentario y agregar extra_body={"expires_after":{"seconds": 1209600, "anchor": "created_at"}}, establecerá el archivo de carga para que expire en 14 días. Hay un límite máximo de 500 archivos por lotes de entrada por recurso cuando no se establece ninguna expiración. Al establecer un valor para expirar, el número de archivos por lotes de entrada por recurso aumenta a 10 000 archivos por recurso. Para quitar los límites de archivos de entrada por lotes, use Batch con Azure Blob Storage.

Salida:

{
  "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

Creación de trabajo por lotes

Una vez que el archivo se haya cargado correctamente, puede enviar el archivo para el procesamiento por lotes.

# 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))

Nota:

Actualmente, la ventana de finalización debe establecerse en 24h. Si establece cualquier otro valor que no sea 24h, su trabajo fallará. Los trabajos que tardan más de 24 horas seguirán ejecutándose hasta que se cancele.

Salida:

{
  "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
  }
}

Si los trabajos por lotes son tan grandes que están alcanzando el límite de tokens en cola incluso después de maximizar la cuota de la implementación, algunas regiones ahora admiten una nueva característica rápida de error que le permite poner en cola varios trabajos por lotes con retroceso exponencial, por lo que una vez que un trabajo de lote grande se completa, el próximo se puede iniciar automáticamente. Para aprender más sobre qué regiones admiten esta característica y cómo adaptar el código para aprovechar esa característica, considere consultar Gestión de trabajos por lotes en cola.

Seguimiento del progreso del trabajo por lotes

Una vez que haya creado el trabajo por lotes correctamente, puede supervisar su progreso en Studio o mediante programación. Al comprobar el progreso del trabajo por lotes, se recomienda esperar al menos 60 segundos entre cada llamada de estado.

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}")

Salida:

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

Los siguientes valores de estado son posibles:

Estado Descripción
validating El archivo de entrada se está validando antes de que pueda comenzar el procesamiento por lotes.
failed El archivo de entrada ha producido un error en el proceso de validación.
in_progress El archivo de entrada se validó correctamente y el lote se está ejecutando.
finalizing El lote ha sido completado y se están preparando los resultados.
completed El lote se ha completado y los resultados están listos.
expired El lote no pudo completarse en el período de tiempo de 24 horas.
cancelling El lote está siendo cancelled (puede tardar hasta 10 minutos en entrar en vigor).
cancelled el lote era cancelled.

Para examinar los detalles del estado del trabajo, puede ejecutar:

print(batch_response.model_dump_json(indent=2))

Salida:

{
  "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 hay error_file_id y un elemento independiente output_file_id. Use error_file_id para ayudar a depurar los problemas que se producen con el trabajo por lotes.

Recuperar el archivo de salida del trabajo por lotes

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)

Salida:

Por motivos de brevedad, solo se incluye una sola respuesta de finalización de chat de salida. Si sigue los pasos descritos en este artículo, debe tener tres respuestas similares a las siguientes:

Completaciones 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 respuestas

{
  "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 por lotes adicionales

Cancelación del lote

Cancela un lote en curso. El lote estará en estado cancelling durante un máximo de 10 minutos, antes de cambiar a cancelled, donde tendrá resultados parciales (si los hay) disponibles en el archivo de salida.

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

Enumerar lotes

Enumeración de trabajos por lotes para un recurso de Azure OpenAI determinado.

client.batches.list()

Los métodos de lista de la biblioteca de Python están paginados.

Para enumerar todos los trabajos:

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 listas (versión preliminar)

Use la API de REST para enumerar todos los trabajos por lotes con opciones adicionales de ordenación y filtrado.

En los ejemplos siguientes se proporciona la generate_time_filter función para facilitar la construcción del filtro. Si no desea usar esta función, el formato de la cadena de filtro tendría el aspecto 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)

Salida:

{
  "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"
}

Poner en cola los trabajos por lotes

Si los trabajos por lotes son tan grandes que está alcanzando el límite de tokens en cola incluso después de limitar la cuota de la implementación, algunas regiones ahora admiten una nueva característica rápida de error que le permite poner en cola varios trabajos por lotes con retroceso exponencial. Una vez que se completa un trabajo por lotes grande y la cuota de tokens en cola vuelve a estar disponible, el siguiente trabajo por lotes se puede crear e iniciar automáticamente.

Comportamiento anterior:

  1. Trabajos de Batch grandes que ya se están ejecutando y usando todos los tokens disponibles para la implementación.
  2. Nuevo trabajo por lotes enviado.
  3. El nuevo trabajo por lotes entra en fase de validación que puede durar hasta unos minutos.
  4. El recuento de tokens para el nuevo trabajo se comprueba con la cuota disponible actualmente.
  5. Se produce un error en el nuevo trabajo por lotes con el límite de tokens de notificación de errores superado.

Nuevo comportamiento:

  1. Trabajos de Batch grandes que ya se están ejecutando y que están usando todos los tokens disponibles para la implementación
  2. Nuevo trabajo por lotes enviado
  3. Se produce un error en el recuento aproximado de tokens del nuevo trabajo en comparación con el trabajo de cuota por lotes disponible actualmente, lo que le permite controlar más fácilmente los reintentos mediante programación.

Soporte para regiones

Las siguientes regiones admiten el nuevo comportamiento de fracaso rápido:

  • australiaeast
  • eastus
  • Alemania Oeste Central
  • italynorth
  • northcentralus
  • poloniacentral
  • Swedencentral
  • Suiza Norte
  • eastus2
  • westus

El código siguiente muestra la mecánica básica de controlar el comportamiento de fracaso rápido para permitir la automatización de reintentos y las puestas en cola de trabajos por lotes con retroceso exponencial.

Según el tamaño de los trabajos por lotes, es posible que tenga que aumentar considerablemente el max_retries o modificar este ejemplo aún más.

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

Salida:

⏳ 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
  }
}

Prerrequisitos

Preparación del archivo por lotes

Al igual que el ajuste, el lote global usa archivos en formato de líneas JSON (.jsonl). A continuación se muestran algunos archivos de ejemplo con diferentes tipos de contenido admitido:

Formato de entrada

API de respuestas

{"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 finalizaciones 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?"}]}}

custom_id es necesario para permitir identificar qué solicitud por lotes individual corresponde a una respuesta determinada. Las respuestas no se devolverán en orden idéntico al orden definido en el archivo por lotes .jsonl.

Debe establecerse el atributo model para que coincida con el nombre de la implementación del lote global que desea establecer como destino para las respuestas de inferencia.

Importante

El atributo model debe establecerse para que coincida con el nombre de la implementación de Batch global que desea establecer como destino para las respuestas de inferencia. El mismo nombre de implementación del modelo de Batch global debe estar presente en cada línea del archivo por lotes. Si desea tener como destino una implementación diferente, debe hacerlo en un archivo o trabajo por lotes independiente.

Para obtener el mejor rendimiento, se recomienda enviar archivos grandes para el procesamiento por lotes, en lugar de un gran número de archivos pequeños con solo unas pocas líneas en cada archivo.

Crear un archivo de entrada

En este artículo, crearemos un archivo denominado test.jsonl y copiaremos el contenido del bloque de código de entrada estándar anterior al archivo. Deberá modificar y agregar el nombre de implementación del lote global a cada línea del archivo.

Carga del archivo por lotes

Una vez preparado el archivo de entrada, primero debe cargar el archivo para poder iniciar un trabajo por lotes. La carga de archivos se puede realizar mediante programación o a través del portal de Microsoft Foundry. En este ejemplo se muestra cómo cargar un archivo directamente en el recurso de Azure OpenAI. Como alternativa, puede configurar Azure Blob Storage para Azure OpenAI Batch.

Importante

Use las claves de API con precaución. No incluya la clave de API directamente en el código ni la exponga nunca públicamente. Si está usando una clave de API, almacénela de forma segura en Azure Key Vault. Para más información sobre cómo utilizar las claves de API de forma segura en sus aplicaciones, consulte Claves de API con Azure Key Vault.

Para más información sobre la seguridad de los servicios de AI, consulte Autenticación de solicitudes a los servicios de Azure AI.

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"

El código anterior supone una ruta de archivo determinada para su archivo test.jsonl. Ajuste esta ruta de acceso de archivo según sea necesario para el sistema local.

Al agregar los parámetros "expires_after.seconds=1209600" y "expires_after.anchor=created_at" opcionales que va a establecer para que expire el archivo de carga en 14 días. Hay un límite máximo de 500 archivos de entrada por lotes por recurso cuando no se establece ninguna expiración. Al establecer un valor para expirar, el número de archivos por lotes por recurso aumenta a 10 000 archivos por recurso. Puede establecer un valor entre 1209600 y 2592000. Esto equivale a 14-30 días. Para quitar los límites de archivos de entrada por lotes, use Batch con Azure Blob Storage.

Salida:

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

Seguimiento del estado de la carga de archivo

Dependiendo del tamaño del archivo de carga, puede tardar algún tiempo antes de que se cargue y procese por completo. Para comprobar el estado de carga de archivos, ejecute:

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

Salida:

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

Creación de trabajo por lotes

Una vez que el archivo se haya cargado correctamente, puede enviar el archivo para el procesamiento por lotes.

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"
  }'

Aquí puede agregar "output_expires_after":{"seconds": 1209600}, y "anchor": "created_at" , opcionalmente, para que los archivos de salida expiren en 14 días.

Nota:

Actualmente, la ventana de finalización debe establecerse en 24h. Si establece cualquier otro valor que no sea 24h, su trabajo fallará. Los trabajos que tardan más de 24 horas seguirán ejecutándose hasta que se cancele.

Salida:

{
  "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"
}

Seguimiento del progreso del trabajo por lotes

Una vez que haya creado el trabajo por lotes correctamente, puede supervisar su progreso en Studio o mediante programación. Al comprobar el progreso del trabajo por lotes, se recomienda esperar al menos 60 segundos entre cada llamada de estado.

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

Salida:

{
  "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"
}

Los siguientes valores de estado son posibles:

Estado Descripción
validating El archivo de entrada se está validando antes de que pueda comenzar el procesamiento por lotes.
failed El archivo de entrada ha producido un error en el proceso de validación.
in_progress El archivo de entrada se validó correctamente y el lote se está ejecutando.
finalizing El lote ha sido completado y se están preparando los resultados.
completed El lote se ha completado y los resultados están listos.
expired El lote no pudo completarse en el período de tiempo de 24 horas.
cancelling El lote está siendo cancelled (puede tardar hasta 10 minutos en entrar en vigor).
cancelled el lote era cancelled.

Recuperar el archivo de salida del trabajo por lotes

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 por lotes adicionales

Cancelación del lote

Cancela un lote en curso. El lote estará en estado cancelling durante un máximo de 10 minutos, antes de cambiar a cancelled, donde tendrá resultados parciales (si los hay) disponibles en el archivo de salida.

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

Enumerar lotes

Enumere los trabajos por lotes existentes para un recurso de Azure OpenAI determinado.

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

La llamada API de lista está paginada. La respuesta contiene un valor booleano has_more para indicar cuándo hay más resultados para recorrer en iteración.

Lote de listas (versión preliminar)

Use la API de REST para enumerar todos los trabajos por lotes con opciones adicionales de ordenación y filtrado.

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 el error, los espacios de URL rejected: Malformed input to a URL function se reemplazan por %20.

Límites de lotes

Nombre del límite Valor del límite
Número máximo de archivos de entrada de Batch: (sin expiración) 500
Número máximo de archivos de entrada en Batch - (configuración de expiración) 10 000
Tamaño máximo del archivo de entrada 200 MB
Número máximo de solicitudes por archivo 100 000

Nota:

Los límites de archivos por lotes no se aplican a los archivos de salida (por ejemplo, result.jsonl, y error.jsonl). Para quitar los límites de archivos de entrada por lotes, use Batch con Azure Blob Storage.

Cuota de lote

En la tabla se muestra el límite de cuota por lotes. Los valores de cuota para lote global se representan en términos de tokens en cola. Al enviar un archivo para el procesamiento por lotes, se cuenta el número de tokens del archivo. Hasta que el trabajo por lotes alcance un estado de terminal, esos tokens cuentan para el límite total de tokens en cola.

Lote global

Modelo Enterprise y MCA-E Predeterminado Suscripciones mensuales basadas en tarjetas de crédito Suscripciones de MSDN Microsoft Azure for Students, pruebas gratuitas
gpt-4.1 5B 200 M 50 millones 90K No disponible
gpt-4.1 mini 15B 1B 50 millones 90K No disponible
gpt-4.1-nano 15B 1B 50 millones 90K No disponible
gpt-4o 5B 200 M 50 millones 90K No disponible
gpt-4o-mini 15B 1B 50 millones 90K No disponible
gpt-4-turbo 300M 80M 40M 90K No disponible
gpt-4 150M 30 M 5M 100 k No disponible
o3-mini 15B 1B 50 millones 90K No disponible
o4-mini 15B 1B 50 millones 90K No disponible
gpt-5 5B 200 M 50 millones 90K No disponible

B = mil millones | M = millones | K = mil

Lote de zona de datos

Modelo Enterprise y MCA-E Predeterminado Suscripciones mensuales basadas en tarjetas de crédito Suscripciones de MSDN Microsoft Azure for Students, pruebas gratuitas
gpt-4.1 500M 30 M 30 M 90K No disponible
gpt-4.1-mini 1,5B 100M 50 millones 90K No disponible
gpt-4o 500M 30 M 30 M 90K No disponible
gpt-4o-mini 1,5B 100M 50 millones 90K No disponible
o3-mini 1,5B 100M 50 millones 90K No disponible
gpt-5 5B 200 M 50 millones 90K No disponible

Objeto Batch

Propiedad Tipo Definición
id cuerda / cadena
object cuerda / cadena batch
endpoint cuerda / cadena Punto de conexión de API usado por el lote
errors objeto
input_file_id cuerda / cadena Identificador del archivo de entrada para el lote
completion_window cuerda / cadena Período de tiempo en el que se debe procesar el lote
status cuerda / cadena El estado actual del lote. Valores posibles: validating, failed, in_progress, finalizing, completed, expired, cancelling, cancelled.
output_file_id cuerda / cadena Identificador del archivo que contiene las salidas de las solicitudes ejecutadas correctamente.
error_file_id cuerda / cadena Identificador del archivo que contiene las salidas de las solicitudes con errores.
created_at entero Marca de tiempo cuando se creó este lote (en épocas Unix).
in_progress_at entero Marca de tiempo cuando este lote comenzó a avanzar (en épocas Unix).
expires_at entero Marca de tiempo cuando este lote va a expirar (en épocas Unix).
finalizing_at entero Marca de tiempo cuando este lote comenzó a finalizar (en épocas Unix).
completed_at entero Marca de tiempo cuando este lote comenzó a finalizar (en épocas Unix).
failed_at entero Marca de tiempo cuando se produjo un error en este lote (en épocas Unix)
expired_at entero Marca de tiempo cuando este lote expiró (en épocas Unix).
cancelling_at entero Marca de tiempo cuando este lote comenzó a cancelling (en épocas Unix).
cancelled_at entero Marca de tiempo cuando este lote fue cancelled (en épocas Unix).
request_counts objeto Estructura del objeto:

total entero
Número total de solicitudes en el lote.
completed entero
Número de solicitudes del lote que se han completado correctamente.
failed entero
Número de solicitudes del lote que han fallado.
metadata mapa Conjunto de pares clave-valor que se pueden adjuntar a un objeto. Esta propiedad puede ser útil para almacenar información adicional sobre el lote en un formato estructurado.

Preguntas más frecuentes (FAQ)

¿Se pueden usar imágenes con la API por lotes?

Esta funcionalidad se limita a determinados modelos multi modales. Actualmente, solo GPT-4o admite imágenes como parte de las solicitudes por lotes. Las imágenes se pueden proporcionar como entrada a través de la dirección URL de la imagen o una representación codificada en base64 de la imagen. Actualmente no se admite el procesamiento por lotes de imágenes con GPT-4 Turbo.

¿Puedo usar la API por lotes con modelos ajustados?

Actualmente no se admite.

¿Puedo usar la API por lotes para insertar modelos?

Actualmente no se admite.

¿Funciona el filtrado de contenido con la implementación global por lotes?

Sí. De forma similar a otros tipos de implementación, puede crear filtros de contenido y asociarlos con el tipo de implementación global por lotes.

¿Puedo solicitar más cuota?

Sí, desde la página de cuota en el portal de Foundry. La asignación de cuota predeterminada se puede encontrar en el artículo sobre cuota y límites.

¿Qué ocurre si la API no completa mi solicitud dentro del período de tiempo de 24 horas?

Nuestro objetivo es procesar estas solicitudes en un plazo de 24 horas; no expiran los trabajos que tardan más tiempo. Puede cancelar el trabajo en cualquier momento. Al cancelar el trabajo, se cancela cualquier trabajo restante y se devuelve cualquier trabajo ya completado. Se le cobrará por cualquier trabajo completado.

¿Cuántas solicitudes puedo poner en cola mediante lotes?

No hay ningún límite fijo en el número de solicitudes que se pueden procesar por lotes; sin embargo, dependerá de tu cuota de tokens en espera. La cuota de tokens en cola incluye el número máximo de tokens de entrada que puede poner en cola cada vez.

Una vez completada la solicitud por lotes, se restablece el límite de tasa por lotes, dado que se borran los tokens de entrada. El límite depende del número de solicitudes globales en la cola. Si la cola de la API por lotes procesa los lotes rápidamente, el límite de velocidad por lotes se restablece más rápidamente.

Solución de problemas

Un trabajo es exitoso cuando status es Completed. Los trabajos exitosos seguirán generando un error_file_id, pero estarán asociados a un archivo vacío de cero bytes.

Cuando se produzca un fallo en la ejecución del trabajo, encontrará detalles sobre el fallo en la propiedad 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 error

Código de error Definición
invalid_json_line No se pudo analizar una línea (o varias) en el archivo de entrada como json válido.

Asegúrese de que no haya errores tipográficos, que los corchetes de apertura y cierre sean correctos y las comillas sigan el estándar JSON y vuelva a enviar la solicitud.
too_many_tasks El número de solicitudes del archivo de entrada supera el valor máximo permitido de 100 000.

Asegúrese de que el total de solicitudes sea inferior a 100 000 y vuelva a enviar el trabajo.
url_mismatch Una fila del archivo de entrada tiene una dirección URL que no coincide con el resto de las filas o la dirección URL especificada en el archivo de entrada no coincide con la del punto de conexión esperado.

Asegúrese de que todas las direcciones URL de solicitud sean las mismas y que coincidan con la dirección URL del punto de conexión asociada a la implementación de Azure OpenAI.
model_not_found No se encontró el nombre de implementación de modelo de Azure OpenAI especificado en la propiedad model del archivo de entrada.

Asegúrese de que este nombre apunte a una implementación de modelo válida de Azure OpenAI.
duplicate_custom_id El identificador personalizado de esta solicitud es un duplicado del identificador personalizado en otra solicitud.
empty_batch Compruebe el archivo de entrada para asegurarse de que el parámetro del identificador personalizado sea único para cada solicitud del lote.
model_mismatch El nombre de implementación de modelo de Azure OpenAI que se especificó en la propiedad model de esta solicitud en el archivo de entrada no coincide con el resto del archivo.

Asegúrese de que todas las solicitudes del lote apunten al mismo modelo de implementación de Azure OpenAI dentro de la propiedad model de Foundry Models en la solicitud.
invalid_request El esquema de la línea de entrada no es válido o la SKU de implementación no es válida.

Asegúrese de que las propiedades de la solicitud en el archivo de entrada coinciden con las propiedades de entrada esperadas y que la SKU de implementación de Azure OpenAI sea globalbatch para las solicitudes de la API por lotes.
input_modified La entrada del blob se ha modificado después de enviar el trabajo por lotes.
input_no_permissions No es posible acceder al blob de entrada. Compruebe los permisos y el acceso a la red entre la cuenta de Azure OpenAI y la cuenta de Azure Storage.

Problemas conocidos

  • Los recursos implementados con la CLI de Azure no funcionarán de forma predeterminada con el lote global de Azure OpenAI. Esto se debe a un problema por el que los recursos implementados mediante este método tienen subdominios de punto de conexión que no siguen el patrón https://your-resource-name.openai.azure.com. Una solución alternativa para este problema es implementar un nuevo recurso de Azure OpenAI mediante uno de los otros métodos de implementación comunes que controlarán correctamente la configuración del subdominio como parte del proceso de implementación.

  • No se admiten archivos codificados jsonl UTF-8-BOM. Los archivos de líneas JSON deben codificarse mediante UTF-8. El uso de archivos codificados con byte-Order-Mark (BOM) no es oficialmente compatible con la especificación RFC JSON, y Azure OpenAI actualmente tratará los archivos codificados con BOM como no válidos. Un archivo codificado UTF-8-BOM devolverá actualmente el mensaje de error genérico: "Error de validación: no se pudo extraer un nombre de implementación de modelo válido del archivo de entrada. Asegúrese de que cada fila del archivo de entrada tenga un nombre de implementación válido especificado en el campo "modelo" y que el nombre de implementación sea coherente en todas las filas".

  • Al usar su propio almacenamiento para los datos de entrada por lotes, una vez enviado el trabajo por lotes, si el servicio producirá un error en el trabajo de puntuación si el servicio modifica el blob de entrada.

Consulte también

  • Last updated on