GPT-4o mini dans six tests de première main : 128 rapprochements justes sur 168, 4 entrées sur 12 stables à température 0

Cette page rassemble les résultats obtenus par GPT-4o mini (openai/gpt-4o-mini) dans les tests publiés sur ce site entre le 2026-08-10 et le 2026-09-30. Elle ne rapporte aucun test nouveau. Chaque chiffre ci-dessous a été recalculé le 2026-10-19 à partir des réponses brutes publiées avec chaque test, par le script montré en fin de page, que tout lecteur peut lancer sur les mêmes archives.

Les tests ont été conduits par la chaîne de test automatisée de ce site : les corpus, les appels aux modèles et l'analyse sont des scripts, publiés avec chaque jeu de données pour que chacun puisse les rejouer et contester le résultat. Dans chaque test, GPT-4o mini a reçu la même consigne et les mêmes entrées que les autres modèles du test, ce qui rend les chiffres comparables d'un modèle à l'autre.

Les chiffres, test par test

Ce que décrit chaque chiffre

Extraction de factures. Le modèle a lu 24 factures fournisseur générées par script, chacune à quatre niveaux de texte dégradé, et rendu sept champs par facture. 83 des 96 extractions avaient leurs sept champs justes. Les 13 extractions fausses sont toutes revenues avec un champ de notes vide, alors que le modèle devait le remplir quand un point de la facture n'était pas clair. C'est le cas qu'un relecteur humain a le moins de chances de voir.

Auto-vérification. Le 2026-09-04, le même modèle a relu chacune de ses propres extractions face à la facture et dit si elle était correcte. Il a signalé 13 de ses 13 extractions fausses, et aussi 26 de ses 83 extractions justes : un relecteur qui ouvrirait chaque facture signalée en ouvrirait donc 39 pour trouver 13 erreurs.

Nouvelle passe. Les 96 extractions ont été relancées le 2026-09-06 avec un budget de sortie plus large, dans le cadre du test prix contre justesse : 83 sont revenues entièrement justes, pour 0,0095 USD facturés. Cette passe reproduit le premier test et n'est pas comptée ici comme un résultat de plus.

Dédoublonnage de contacts. Huit carnets de 12 contacts, générés par script avec des doublons et des paires pièges (deux personnes différentes construites pour se ressembler), chacun envoyé à quatre niveaux de désordre de mise en forme. Sur les 32 passes, le modèle a retrouvé 87 des 96 doublons posés et fusionné 46 paires de personnes différentes, dont 43 sur des paires pièges.

Répétabilité à température 0. Les mêmes 12 entrées ont été envoyées 10 fois chacune, température réglée à 0. Pour 4 des 12 entrées, les 10 réponses brutes étaient identiques octet pour octet ; pour une entrée, le modèle a rendu 10 réponses brutes différentes. L'article du test compare aussi le contenu interprété des réponses, une comparaison plus souple, et ses propres décomptes d'entrées divergentes diffèrent donc de ce décompte octet pour octet.

Classification de messages de support. 270 messages de clients tirés du jeu public de support Bitext, 10 pour chacune de 27 intentions, chacun à ranger dans une intention avec une confiance de 0 à 100. Le modèle a nommé la bonne intention 237 fois. Sur ses 33 réponses fausses, 0 portaient une confiance déclarée de 90 ou plus.

Rapprochement facture et bon de commande. Chacune des 24 factures a été appariée à sept bons de commande portant un écart contrôlé à la fois ; pour deux des sept conditions, une commande conforme et une livraison partielle, la bonne décision est d'approuver. Le modèle a décidé juste sur 128 des 168 paires. Il a approuvé 3 des 120 paires qui devaient être bloquées, et bloqué 37 des 48 paires qui devaient être approuvées.

Les mêmes entrées, comparées aux deux autres modèles

Deux pages placent ce modèle à côté de chacun des deux autres sur les entrées qu'ils ont tous reçues, et comptent les cas où un seul des deux avait raison :

• Claude Haiku 4.5 et GPT-4o mini
• Gemini 2.5 Flash Lite et GPT-4o mini

Les pages des deux autres modèles : Claude Haiku 4.5, Gemini 2.5 Flash Lite.

Méthode

• Les dates des tests sont celles du tableau. Cette page a été publiée le 2026-10-19, et ses chiffres recalculés le même jour à partir des archives servies sur les pages de données.
• Les factures, les carnets de contacts, les bons de commande et les 12 entrées de répétabilité ont été générés par script avec des graines fixes, et chaque page de données le dit avec ce que cela ne prouve pas. Les messages de support viennent du jeu public Bitext.
• Les chiffres du tableau viennent d'un appel par cas et par modèle, sauf le test de répétabilité, qui a envoyé chaque entrée 10 fois.
• Les coûts sont les montants que l'API a rendus pour chaque appel, consignés dans les réponses brutes, et non des estimations tirées d'une grille de prix.

Ce que ces chiffres ne montrent pas

• Les documents ont été générés par script et ne contiennent ni scan, ni mise en page inhabituelle, ni écriture manuscrite : ils ne représentent donc pas la variété des documents réels.
• Les résultats décrivent le modèle tel qu'il était servi à la date de chaque test. Un fournisseur peut mettre à jour un modèle sous le même nom.
• Chaque cas a été posé une fois, et le test de répétabilité montre qu'un second appel à température 0 peut rendre une autre réponse : une nouvelle passe peut donc déplacer un chiffre de quelques cas.
• Les chiffres décrivent ce modèle sous la consigne de chaque test. Une autre consigne pourrait donner d'autres résultats.
• Les sept tâches ne sont pas pondérées entre elles, et aucun classement d'ensemble n'en est tiré.

Recalculer chaque chiffre du tableau

Ce script lit les réponses brutes de six archives et imprime chaque chiffre du tableau ci-dessus. Téléchargez chaque archive depuis la page de données liée dans le tableau, décompressez-la dans un dossier qui porte son nom (par exemple unzip 2026-08-invoice-extraction.zip -d 2026-08-invoice-extraction), puis lancez le script depuis le dossier qui les contient.

import json
from pathlib import Path

MODEL = "openai/gpt-4o-mini"

def rows(archive, name):
    data = json.loads(next(Path(archive).rglob(name)).read_text())
    rows = data["lignes"] if isinstance(data, dict) else data
    return [r for r in rows if r["modele"] == MODEL]

def cost(rs):
    return round(sum(r["cout_usd"] or 0 for r in rs), 4)

ext = rows("2026-08-invoice-extraction", "resultats-bruts.json")
wrong = [r for r in ext if not r["tous_les_champs_justes"]]
print("extraction: right", len(ext) - len(wrong), "of", len(ext), "| wrong", len(wrong),
      "| wrong with no warning", sum(not r["a_signale_quelque_chose"] for r in wrong), "| USD", cost(ext))

said = {(r["facture"], r["niveau"]): r["dit_correct"]
        for r in rows("2026-09-extraction-guardrails", "verifications.json")}
flag = lambda r: said[(r["facture"], r["niveau"])] is False
print("self-check: wrong flagged", sum(flag(r) for r in wrong),
      "| right flagged", sum(flag(r) for r in ext if r["tous_les_champs_justes"]))

rerun = rows("2026-09-invoice-price-accuracy", "passeB-fusionnee.json")
print("rerun: right", sum(r["tous_les_champs_justes"] for r in rerun), "of", len(rerun), "| USD", cost(rerun))

dd = rows("2026-08-contact-deduplication", "resultats-bruts.json")
print("deduplication: passes", len(dd), "| found", sum(r["nb_fusions_justes"] for r in dd),
      "of", sum(r["nb_fusions_justes"] + r["nb_fusions_manquees"] for r in dd),
      "| false merges", sum(r["nb_fusions_fausses"] for r in dd),
      "| traps", sum(r["nb_pieges_tombes"] for r in dd))

raw = {}
for r in rows("2026-08-temperature-zero-repeatability", "resultats-bruts.json"):
    raw.setdefault(r["entree"], set()).add(r["brut"])
print("temperature 0: identical", sum(len(v) == 1 for v in raw.values()), "of", len(raw),
      "| most variants", max(len(v) for v in raw.values()))

tk = rows("2026-09-support-ticket-classification", "resultats-bruts.json")
print("tickets: right", sum(bool(r["juste"]) for r in tk), "of", len(tk),
      "| wrong at confidence 90+", sum(not r["juste"] and (r["confiance"] or 0) >= 90 for r in tk),
      "| USD per 1,000", round(1000 * sum(r["cout_usd"] or 0 for r in tk) / len(tk), 4))

po = rows("2026-09-invoice-po-matching", "resultats-bruts.json")
print("purchase orders: right", sum(bool(r["juste"]) for r in po), "of", len(po),
      "| wrong APPROVE", sum(not r["juste"] and r["decision"] == "APPROVE" for r in po),
      "| wrong HOLD", sum(not r["juste"] and r["decision"] == "HOLD" for r in po))