BroadRouter
Commencer

Traitement par lots LLM sans Batch API : un exécuteur reprenable

Par l’équipe BroadNet Inference · 8 min de lecture · Publié · Mis à jour

Sans Batch API, pilotez le traitement vous-même : lisez les éléments depuis un fichier JSONL, plafonnez les requêtes simultanées à la limite de la clé, cadencez les départs sous la limite par minute, relancez les 429 et 5xx avec un backoff plafonné et ajoutez chaque résultat avec son identifiant. Au redémarrage, sautez les identifiants terminés. C’est en général la limite de débit, pas le modèle, qui fixe l’heure de fin.

Certains travaux LLM ne sont pas des conversations. Vous avez 50 000 tickets de support à étiqueter, 200 000 descriptions de produits à traduire ou un million d’avis à noter. Des fournisseurs comme OpenAI et Anthropic vendent une Batch API pour cela. Beaucoup d’API compatibles OpenAI, dont BroadNet Inference, n’en ont pas. Cet article montre comment mener le traitement vous-même : estimer sa durée, écrire un exécuteur qui respecte les limites, et pouvoir l’arrêter et le relancer sans risque.

BroadRouter est le site de BroadNet ; les exemples chiffrés utilisent donc les limites publiées par BroadNet. La méthode fonctionne avec n’importe quelle API chat completions ; remplacez par les chiffres de votre fournisseur.

BroadNet Inference propose-t-il une Batch API ?

Non. La référence de l’API, vérifiée le 15 novembre 2026, documente POST /v1/chat/completions, POST /v1/audio/transcriptions et GET /v1/models (une liste de modèles), plus des points de terminaison de compte sous /portal/. Il n’y a ni point de terminaison de lot ou d’envoi de fichier, ni remise sur les lots. Un traitement de masse est une boucle de requêtes normales.

Voici ce qu’apporte une Batch API hébergée, pour savoir ce que vous reconstruisez :

Batch API d’OpenAI Message Batches d’Anthropic Votre propre exécuteur
Prix 50 % de moins que le synchrone 50 % de remise Prix normal
Délai Sous 24 heures La plupart en moins d’1 heure ; expire après 24 Fixé par vos limites de débit
Taille par lot 50 000 requêtes ou 200 Mo 100 000 requêtes ou 256 Mo Toute taille
Limites de débit Séparées des limites par modèle S’appliquent aux requêtes en file Les limites de votre clé
Ordre des résultats Peut varier ; rapprochement par custom_id Rapprochement par custom_id Résultats indexés par identifiant

Deux leçons se transposent. Les deux fournisseurs vous obligent à étiqueter chaque requête avec un identifiant, car les résultats ne reviennent pas dans l’ordre. Aucun ne promet de réponse en quelques secondes. Votre exécuteur doit fonctionner de la même façon : des identifiants partout, et un plan mesuré en heures.

Si une remise de 50 % compte plus que le délai, et que les modèles dont vous avez besoin y sont disponibles, une Batch API hébergée peut être l’outil le moins cher. Chiffrez les deux avec le calculateur de coût d’API LLM avant de construire.

Combien de temps prendra le traitement ?

Faites ce calcul avant d’écrire du code. Deux limites plafonnent le débit, et la plus lente l’emporte :

  • Limite de requêtes simultanées ÷ latence. Avec 4 requêtes simultanées et 2 secondes par requête, vous en terminez 2 par seconde.
  • Requêtes par minute. À 30 par minute, vous pouvez en lancer 0,5 par seconde, quelle que soit la vitesse du modèle.

Une clé BroadNet en paiement à l’usage autorise 4 requêtes simultanées et 30 par minute. Avec les valeurs de la référence de l’API au moment de notre vérification (30 par minute et 4 simultanées, le 2026-11-15), c’est la limite de débit qui bloque, sauf si chaque requête dure plus de 8 secondes ; le tableau ci-dessous utilise 30 par minute :

Éléments Un élément par requête 20 éléments par requête
10 000 5,6 heures 17 minutes
100 000 2,3 jours 2,8 heures
1 000 000 23 jours 28 heures

À 30 requêtes par minute, une clé traite 1 800 requêtes par heure, soit 43 200 par jour. Les nouvelles tentatives comptent aussi : chaque 429 que vous déclenchez consomme un créneau.

La deuxième colonne est le levier le plus puissant. Les éléments courts, comme des avis ou des objets de tickets, peuvent partir par 10 à 50 par requête sous forme de liste numérotée, avec un tableau JSON en retour. Vérifiez que le tableau a une entrée par élément et que chacune porte son numéro. L’article sur la classification de textes arabes montre le principe. Les éléments longs ne se regroupent pas : chaque requête doit toujours tenir dans la fenêtre de contexte du modèle, et la qualité peut baisser quand la liste s’allonge. Testez le regroupement sur 200 éléments avant de vous y fier.

Ne répartissez pas un traitement sur plusieurs clés pour dépasser une limite par clé sans demander. La politique d’utilisation acceptable de BroadNet interdit de contourner les limites de débit, de concurrence ou de budget. S’il vous en faut plus, demandez à BroadNet, ou utilisez des sessions de forfait (voir plus bas). Le planificateur de traitement par lots fait ce calcul pour votre nombre d’éléments, votre latence et vos limites.

À quoi ressemble un exécuteur reprenable ?

Cet exécuteur lit items.jsonl (un objet {"id", "text"} par ligne) et ajoute une ligne de résultat par élément à results.jsonl. Il n’a besoin que du SDK Python d’OpenAI.

import asyncio, json, os, random, time
from openai import AsyncOpenAI, APIStatusError, APIConnectionError, APITimeoutError

client = AsyncOpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
                     api_key=os.environ["BROADNET_API_KEY"],
                     max_retries=0,        # we retry ourselves, with a cap we can see
                     timeout=120)
MODEL = os.environ.get("MODEL", "broadnet/deepseek-v4.1-flash")
IN_FLIGHT = int(os.environ.get("IN_FLIGHT", "4"))     # PAYG key: 4 in flight. Plan: 1 per session.
RPM = int(os.environ.get("RPM", "30"))                # PAYG key: 30 requests a minute
MAX_ATTEMPTS = 6

class Pacer:
    """Spaces request starts at least 60/RPM seconds apart, across all workers."""
    def __init__(self, rpm):
        self.gap, self.next, self.lock = 60 / rpm, 0.0, asyncio.Lock()
    async def wait(self):
        async with self.lock:
            now = time.monotonic()
            delay = max(0.0, self.next - now)
            self.next = max(now, self.next) + self.gap
        await asyncio.sleep(delay)

def retryable(e):
    if isinstance(e, (APIConnectionError, APITimeoutError)):
        return True
    return isinstance(e, APIStatusError) and e.status_code in (429, 500, 502, 503, 504)

async def call(item, pacer):
    for attempt in range(MAX_ATTEMPTS):
        await pacer.wait()                          # every attempt counts against the rate limit
        try:
            r = await client.chat.completions.create(
                model=MODEL, max_tokens=1500, reasoning_effort="low",
                messages=[{"role": "system", "content": "Classify the review as positive, negative or mixed. Reply with one word."},
                          {"role": "user", "content": item["text"]}])
            c = r.choices[0]
            return {"id": item["id"], "ok": True, "finish_reason": c.finish_reason,
                    "output": c.message.content, "usage": r.usage.model_dump() if r.usage else None}
        except Exception as e:
            if not retryable(e) or attempt == MAX_ATTEMPTS - 1:
                return {"id": item["id"], "ok": False, "error": repr(e)[:300]}
            await asyncio.sleep(random.uniform(0, min(60, 2 ** attempt)))   # full jitter, capped

async def run(in_path, out_path):
    done = set()
    if os.path.exists(out_path):                    # resume: skip ids that already succeeded
        with open(out_path) as f:
            done = {json.loads(l)["id"] for l in f if l.strip() and json.loads(l).get("ok")}
    todo = [it for it in map(json.loads, open(in_path)) if it["id"] not in done]
    print(f"{len(done)} done, {len(todo)} to go")
    pacer, queue = Pacer(RPM), asyncio.Queue()
    for it in todo:
        queue.put_nowait(it)
    with open(out_path, "a") as out:
        async def worker():
            while True:
                try:
                    it = queue.get_nowait()
                except asyncio.QueueEmpty:
                    return
                res = await call(it, pacer)
                out.write(json.dumps(res, ensure_ascii=False) + "\n")
                out.flush()                         # one line per finished item = the checkpoint
        await asyncio.gather(*(worker() for _ in range(IN_FLIGHT)))

if __name__ == "__main__":
    import sys
    asyncio.run(run(sys.argv[1], sys.argv[2]))

Lancez-le avec python batch_run.py items.jsonl results.jsonl. Nous avons testé ce fichier tel quel contre un serveur fictif local qui renvoyait des 429 (8 %) et des 500 (5 %) au hasard et refusait tout au-delà de 4 requêtes simultanées ou de 30 départs par minute. 25 éléments ont été traités en 55 secondes avec 28 requêtes (3 nouvelles tentatives), et jamais plus de 30 départs sur une fenêtre de 60 secondes. Avec la limite du serveur fictif relevée à 300 par minute pour gagner du temps, une exécution de 120 éléments interrompue au bout de 10 secondes a repris à partir de 39 résultats enregistrés et s’est terminée avec 120 identifiants uniques, sans doublon.

Pourquoi un pool de workers et pas asyncio.gather ?

Le guide des erreurs 429 utilise un sémaphore autour de asyncio.gather. C’est très bien pour quelques centaines d’appels. Pour un gros traitement, un pool fixe de workers qui puisent dans une file est préférable :

  • Mémoire. gather crée d’emblée une tâche par élément. Un pool ne garde que les éléments en cours.
  • La concurrence, c’est la taille du pool. Quatre workers ne peuvent jamais avoir cinq requêtes ouvertes.
  • Les résultats partent sur le disque au fur et à mesure, dans n’importe quel ordre, indexés par identifiant.

Le Pacer gère la seconde limite. Un sémaphore seul vous empêche de dépasser 4 requêtes simultanées, mais si les requêtes prennent une seconde, quatre workers en lanceraient 240 par minute et recevraient un 429 pour la plupart. Le pacer espace les départs de 2 secondes, tous workers confondus, nouvelles tentatives comprises.

Comment les nouvelles tentatives restent-elles sûres ?

Ne relancez que ce qui peut réussir au second essai :

Réponse Action
429 Attendre puis relancer ; la documentation de BroadNet dit « use response details and bounded backoff » (traduction : « utilisez les détails de la réponse et un backoff borné »)
500, 502, 503, 504, délais dépassés, connexions coupées Relancer avec un backoff exponentiel borné
400, 422 Corriger la requête ; la relancer renvoie la même erreur
401, 402, 403 Arrêter le traitement ; la clé, le solde ou la politique demande votre attention
413 Raccourcir l’élément

L’exécuteur désactive les nouvelles tentatives propres au SDK (max_retries=0) pour qu’il n’y ait qu’une seule politique de relance, avec un plafond visible. Le backoff est exponentiel avec gigue complète, plafonné à 60 secondes, pour que des workers qui ont échoué ensemble ne relancent pas ensemble. Après six tentatives, l’élément est écrit avec "ok": false et le traitement continue. Un élément défectueux n’arrête jamais un million d’autres.

Un appel au modèle n’a pas d’effet de bord : la livraison est ici « au moins une fois ». Si le processus meurt au milieu d’une requête, cet élément est renvoyé au redémarrage, et vous le payez deux fois. C’est le seul gaspillage. Si le traitement écrit aussi dans un autre système, comme des tickets ou des e-mails, rendez cette écriture idempotente par identifiant d’élément et faites-la dans une passe séparée sur results.jsonl. L’article sur les agents longue durée traite en détail des effets de bord idempotents.

Comment fonctionnent les points de reprise ?

Le fichier de sortie est le point de reprise. Chaque élément terminé est une ligne écrite sur disque ; après un plantage, un déploiement ou un Ctrl-C, l’exécution suivante lit le fichier, collecte les identifiants avec "ok": true et ne met en file que le reste. Les éléments qui avaient échoué sont relancés à l’exécution suivante, et leur nouvelle ligne est ajoutée. À la lecture des résultats, prenez la dernière ligne de chaque identifiant.

Trois habitudes rendent cela robuste sur plusieurs jours :

  1. Des identifiants stables. Utilisez une clé de base de données ou un hachage de l’entrée, jamais un numéro de ligne qui bouge quand le fichier d’entrée change.
  2. Vérifiez finish_reason. Une réponse coupée à max_tokens est "ok": true mais inutile. DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B raisonnent avant de répondre, et le raisonnement compte dans max_tokens. L’exécuteur règle reasoning_effort="low", que BroadNet documente, et laisse 1 500 tokens.
  3. Journalisez l’usage à chaque ligne. La somme des usage de results.jsonl donne la vraie facture en tokens, à comparer avec votre estimation.

Combien ça coûte : paiement à l’usage ou session de forfait ?

En paiement à l’usage, le coût, ce sont les tokens. Prenez 100 000 avis, un prompt système de 150 tokens, un avis de 150 tokens et 100 tokens de sortie avec un raisonnement faible. Cela fait 30 millions de tokens d’entrée et 10 millions de tokens de sortie. Sur DeepSeek V4.1 Flash, cela coûte 30 × $0.175 + 10 × $0.52. Gardez le prompt système en premier et identique à l’octet près : ses 15 millions de tokens pourront alors être facturés au tarif de l’entrée en cache, $0.0055 par million, là où le cache fonctionne. Vos lignes usage montrent à quelle fréquence c’est le cas.

Avec un forfait, les tokens sont gratuits et c’est le temps qui coûte. Une session de forfait DeepSeek V4.1 Flash « runs one request at a time » (traduction : « traite une requête à la fois ») : réglez donc IN_FLIGHT=1 par session. Le débit par session vaut 86 400 ÷ secondes par élément, par jour. BroadNet indique une vitesse typique de environ 100 tokens par seconde, mais votre latence dépend de la longueur du prompt et du raisonnement : mesurez-la sur 50 éléments. Si vous mesurez 3 secondes par élément, une session en traite 28 800 par jour :

Traitement Sessions Durée à 3 s/élément Forfait
100 000 éléments 1 Environ 3,5 jours Une semaine Orbit, $15 par session
100 000 éléments 4 Environ 21 heures Quatre semaines Orbit, une par session ; ou environ 21 heures Meteor par session, à $1 chacune
1 000 000 éléments 6 Environ 6 jours Six semaines Orbit

Les forfaits sont fournis « best effort under fair use » (traduction : « au mieux, dans le cadre d’un usage raisonnable »), et BroadNet ne publie pas de limite de requêtes par minute pour les clés de forfait ; votre compte affiche les limites applicables. Réglez RPM à partir de celles-ci, pas au jugé. Le guide du planificateur de sessions explique comment répartir les sessions entre les clés.

Où se situe BroadNet Inference

BroadNet Inference n’a pas de Batch API : il convient aux traitements de masse quand vous préférez piloter l’exécuteur vous-même et payer les prix normaux au token, ou fixer le coût avec des sessions de forfait DeepSeek V4.1 Flash. Pour de petits traitements à petit budget, Gemma 4 VL 26B, à $0.10 en entrée et $0.22 en sortie par million, fonctionne avec le crédit de départ de $5. Les prompts et les sorties ne sont pas conservés après chaque requête. Si votre traitement peut attendre un jour et que les modèles dont vous avez besoin sont chez un fournisseur offrant 50 % de remise sur les lots, cela peut coûter moins cher ; comparez avant de vous engager. Forfaits et limites sur inference.broadnet.ai/plans.

Questions fréquentes

BroadNet Inference propose-t-il une Batch API ?

Non. Sa référence d’API, vérifiée le 15 novembre 2026, documente POST /v1/chat/completions, POST /v1/audio/transcriptions et GET /v1/models, sans point de terminaison de lot ni d’envoi de fichier, et sans remise sur les lots. Lancez les traitements de masse comme des requêtes ordinaires dans les limites de votre clé.

Comment traiter 100 000 prompts avec une API LLM ?

Placez les éléments dans un fichier JSONL, chacun avec un identifiant. Lancez un nombre fixe de workers égal à la limite de requêtes simultanées de la clé, cadencez les départs sous la limite par minute, relancez les 429 et 5xx avec un backoff plafonné, et ajoutez chaque résultat à un fichier de sortie indexé par identifiant pour pouvoir reprendre.

Combien de temps prend un lot d’un million de requêtes ?

Divisez le nombre d’éléments par votre débit réel. À 30 requêtes par minute et un élément par requête, une clé en traite 43 200 par jour : un million prend donc environ 23 jours. Regrouper 20 éléments courts par requête ramène cela à environ 28 heures, si le modèle gère bien le prompt plus long.

Faut-il utiliser asyncio.gather ou un pool de workers pour des appels LLM par lots ?

Pour des dizaines de milliers d’éléments, utilisez un pool fixe de workers qui puisent dans une file. gather avec un sémaphore convient aux petits traitements, mais il crée toutes les tâches d’emblée et complique la reprise et le suivi de progression.

Puis-je utiliser plusieurs clés API pour aller plus vite ?

Vérifiez d’abord. La politique d’utilisation acceptable de BroadNet interdit de contourner les limites de débit ou de concurrence : demandez donc à BroadNet avant de répartir un traitement sur plusieurs clés pour dépasser une limite par clé. Regrouper plus d’éléments par requête et les sessions de forfait sont les moyens documentés d’augmenter le débit.

Un forfait convient-il aux traitements par lots ?

Oui, pour DeepSeek V4.1 Flash. Une session traite une requête à la fois sans compteur de tokens : le coût est fixe et la question devient le temps. Mesurez les secondes par élément, puis achetez assez de sessions pour finir dans la période.

Lire en MarkdownDemander à ChatGPTDemander à ClaudeDemander à Perplexity