BroadRouter

Avant le fine-tuning : définir le problème à résoudre

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

Ne fine-tunez qu’après qu’une évaluation a montré un échec récurrent que de meilleurs prompts, des exemples, la recherche documentaire et la validation n’ont pas corrigé. Un manque de connaissances relève généralement du RAG, et les erreurs de format de la sortie structurée et des contrôles. Avant de demander un modèle personnalisé, réunissez des exemples annotés que vous avez le droit d’utiliser, isolez un jeu de test et notez le score à battre.

Le fine-tuning est souvent la première solution vers laquelle on se tourne quand un modèle se trompe, et souvent la mauvaise. Il coûte la collecte de données, l’annotation, des entraînements et un modèle qu’il faut ensuite maintenir. Beaucoup d’échecs disparaissent avec un prompt plus clair, la récupération du bon document ou un contrôle de la sortie dans le code. Cet article vous aide à déterminer dans quel cas vous êtes, et quoi préparer si vous avez vraiment besoin d’un modèle personnalisé.

Quel problème essayez-vous de résoudre ?

Nommez l’échec avant de nommer la solution. La plupart des échecs de LLM relèvent de quelques schémas, et chacun a une première étape moins coûteuse :

Symptôme À essayer d’abord Le fine-tuning aide quand
Faits faux ou obsolètes Recherche documentaire (RAG) sur vos documents Rarement ; des faits qui changent demandent de toute façon du RAG
Mauvais format, JSON cassé Sortie structurée, contrôles de schéma, une nouvelle tentative Le format est inhabituel et les exemples dans le prompt ne suffisent pas
Étiquettes ou catégories incohérentes Définitions claires et exemples few-shot L’ensemble d’étiquettes est grand ou subtil et les exemples ne tiennent pas dans le prompt
Mauvais ton ou style Un guide de style dans le prompt système, avec exemples Un style maison doit tenir sur des milliers de sorties
Termes métier mal entendus ou mal orthographiés Une liste de vocabulaire dans le prompt, une correction a posteriori dans le code Les modèles vocaux entendent mal, encore et encore, les mêmes noms, codes ou nombres
Trop lent ou trop coûteux à grande échelle Un modèle plus petit, le prompt caching, des prompts plus courts Un petit modèle fine-tuné peut égaler un grand sur une tâche étroite
Mauvaise langue ou mauvais dialecte Des instructions dans la bonne langue ; voir le prompt engineering en arabe Le modèle comprend mais n’écrit pas dans le dialecte voulu

Le guide d’OpenAI décrit le même ordre : écrire d’abord des evals, puis itérer sur les prompts, et fine-tuner pour certains cas d’usage. Il dit que le processus de prompt engineering « may be all you need in order to get great results » (traduction : « peut suffire pour obtenir d’excellents résultats »). Il liste ce que le fine-tuning apporte par rapport au prompting : plus d’exemples qu’il n’en tient dans un prompt, des prompts plus courts qui économisent des tokens, un entraînement sur des données que vous ne voulez pas envoyer à chaque requête, et un modèle plus petit rendu bon sur une tâche.

Comment prouver que l’échec est récurrent ?

Avec un jeu d’évaluation. Réunissez 100 à 200 entrées réelles avec des sorties correctes connues, comme dans évaluer un LLM avant d’en changer. Notez votre prompt actuel. Puis étiquetez chaque échec avec une catégorie courte : wrong_label, missing_field, dialect, hallucinated_fact, etc.

Un schéma n’est candidat au fine-tuning que si les trois conditions sont réunies :

  1. Il est fréquent. Il représente une part significative des échecs, pas un ou deux cas isolés.
  2. Il survit aux solutions peu coûteuses. Vous avez essayé des instructions plus claires, des exemples, la recherche documentaire et la validation, et la catégorie est toujours là.
  3. Il est cohérent. Les humains s’accordent sur la bonne réponse. Si deux de vos propres relecteurs étiquettent le même cas différemment, un modèle entraîné sur leurs étiquettes apprendra le désaccord.

Consignez le résultat en une phrase courte, comme dans cet exemple inventé : « Sur notre jeu de support arabe de 200 cas, le meilleur prompt classe 18 % des tickets de facturation en livraison ; des exemples few-shot ramènent ce chiffre à 15 %. » Cette phrase est le cahier des charges d’un fine-tune, et le chiffre à battre.

Quels changements plus simples tester d’abord ?

Procédez par ordre de coût, et réévaluez après chacun :

  1. Instructions. Définissez chaque étiquette ou champ. Dites quoi faire en cas de doute.
  2. Exemples. Ajoutez trois à dix exemples réels, y compris les cas difficiles.
  3. Recherche documentaire. Si les réponses demandent des faits, récupérez le passage pertinent. La recherche RAG en arabe et contexte long ou RAG couvrent les options.
  4. Contraintes. Utilisez la sortie structurée quand le modèle la prend en charge, et contrôlez la sortie dans le code. Redemandez une fois avec l’erreur.
  5. Un autre modèle. Un autre modèle de base fait peut-être déjà ce qu’il vous faut. Le même jeu d’évaluation vous le dira en une heure.

Chaque étape coûte des heures, pas des semaines, et chacune vous laisse un meilleur score de référence qu’un fine-tune devra battre si vous en avez encore besoin.

De quelles données avez-vous besoin, et avez-vous le droit de les utiliser ?

Avant la qualité, vérifiez les droits. Les données d’entraînement viennent souvent de conversations clients, de documents ou d’enregistrements d’appels. Il vous faut une base légale et, souvent, un consentement ou une clause contractuelle couvrant l’entraînement. Vérifiez votre propre politique de confidentialité et vos contrats clients, et supprimez les données personnelles dont vous n’avez pas besoin. Ne supposez pas que votre fournisseur d’API les collecte pour vous : la déclaration de confidentialité de BroadNet, par exemple, indique qu’il ne conserve pas le contenu d’inférence et n’utilise pas les données d’inférence pour entraîner, fine-tuner ou évaluer des modèles.

Vérifiez ensuite la qualité. Ce script lit un fichier d’entraînement et un fichier d’évaluation au format chat JSONL courant (un {"messages": [...]} par ligne, terminé par la réponse de l’assistant) et signale les problèmes qui ruinent discrètement les fine-tunes : lignes cassées, doublons, même entrée avec des réponses différentes, éléments d’évaluation qui ont fui dans l’entraînement, équilibre des étiquettes et données personnelles possibles.

import json, re, sys
from collections import Counter

DIAC = re.compile(r"[ً-ٰٟـ]")          # tashkeel, dagger alef, tatweel
PII = {"email": re.compile(r"[\w.+-]+@[\w-]+\.[\w.]+"),
       "phone": re.compile(r"(?:\+|00)\d[\d\s-]{7,}\d")}

def norm(s: str) -> str:
    s = DIAC.sub("", s.lower())
    s = re.sub("[إأآٱ]", "ا", s).replace("ى", "ي")
    return " ".join(s.split())

def load(path):
    rows, errors = [], []
    for i, line in enumerate(open(path, encoding="utf-8"), 1):
        try:
            ex = json.loads(line)
            roles = [m["role"] for m in ex["messages"]]
            if roles[-1] != "assistant" or "user" not in roles:
                raise ValueError(f"roles {roles}")
            rows.append(ex)
        except (ValueError, KeyError, IndexError, TypeError) as e:
            errors.append(f"line {i}: {e}")
    return rows, errors

def key(ex):     # the input side, normalised: what the model sees
    return norm(" ".join(m["content"] for m in ex["messages"] if m["role"] != "assistant"))

def check(train_path, eval_path):
    train, errs = load(train_path)
    evals, eval_errs = load(eval_path)
    keys = Counter(key(e) for e in train)
    labels = Counter(e["messages"][-1]["content"].strip() for e in train)
    leaked = {key(e) for e in evals} & set(keys)
    pii = Counter(k for e in train for m in e["messages"] for k, rx in PII.items() if rx.search(m["content"]))
    conflicts = Counter()
    seen = {}
    for e in train:
        k, a = key(e), e["messages"][-1]["content"].strip()
        if k in seen and seen[k] != a:
            conflicts[k] += 1
        seen.setdefault(k, a)
    return {"train_examples": len(train), "parse_errors": errs + eval_errs,
            "duplicate_inputs": sum(n - 1 for n in keys.values() if n > 1),
            "same_input_different_answer": len(conflicts),
            "eval_items_also_in_train": len(leaked),
            "answer_distribution": labels.most_common(5),
            "examples_with_possible_pii": dict(pii)}

if __name__ == "__main__":
    print(json.dumps(check(sys.argv[1], sys.argv[2]), ensure_ascii=False, indent=1))

Nous l’avons exécuté sur un fichier jouet de sept lignes de tickets de support en arabe, en anglais et en espagnol. Il a trouvé une ligne sans réponse de l’assistant, deux entrées en double (l’une ne différait que par un signe diacritique, que le normaliseur supprime, comme dans la normalisation du texte arabe), une entrée étiquetée à la fois billing et other, un élément d’évaluation présent aussi dans l’entraînement, et un numéro de téléphone. Chacun de ces problèmes aurait fait paraître le fine-tune meilleur ou pire qu’il ne l’est.

La normalisation compte pour l’arabe. Sans elle, « متأخر » et « متأخِّر » comptent comme des entrées différentes, et une quasi-copie d’un élément de test peut se glisser dans l’entraînement.

Comment évaluer un fine-tune équitablement ?

Utilisez le même jeu de test mis de côté que pour le score de référence, et gardez-le hors de l’entraînement. Puis comparez :

  • Avec le meilleur prompt, pas le premier. Un fine-tune qui bat un prompt faible ne prouve rien.
  • Par catégorie et par langue. Un gain global peut masquer une baisse en arabe pendant que l’anglais progresse. Rapportez chacun.
  • Sur le comportement général. Ajoutez 20 à 50 requêtes ordinaires que le modèle traitait bien avant. Un entraînement étroit peut dégrader le comportement hors de la tâche.
  • Sur le coût et la latence. Un fine-tune se justifie souvent par un modèle plus petit qui fait le travail. Mesurez aussi les tokens et le temps par requête.

Fixez la règle de réussite avant de voir les chiffres, comme dans l’article sur l’évaluation : par exemple, « au moins 5 points de mieux sur les étiquettes de facturation, aucune catégorie en recul de plus de 2 points, l’arabe et l’anglais passent tous les deux ».

Qu’est-ce qui change quand vous ne pouvez pas fine-tuner les modèles hébergés ?

Moins d’API hébergées qu’on ne le pense proposent le fine-tuning en libre-service. La page Deprecations d’OpenAI consigne une mise à jour de sa plateforme de fine-tuning en libre-service : à partir du 7 mai 2026, les organisations qui n’avaient jamais lancé de fine-tuning ne peuvent plus créer de jobs ; à partir du 2 juillet 2026, les organisations qui n’avaient pas fait d’inférence sur un modèle fine-tuné au cours des 60 derniers jours ne le peuvent plus non plus ; et à partir du 6 janvier 2027, les clients existants actifs ne pourront plus créer de nouveaux jobs de fine-tuning. Les modèles fine-tunés existants restent disponibles en inférence jusqu’à la dépréciation de leurs modèles de base.

L’alternative habituelle est un modèle open-weight entraîné avec une méthode économe en paramètres comme LoRA. L’article sur LoRA (Hu et al.) rapporte que, par rapport au fine-tuning complet de GPT-3 175B avec Adam, LoRA peut réduire le nombre de paramètres entraînables d’un facteur 10 000 et le besoin en mémoire GPU d’un facteur 3. Il vous faut ensuite un endroit où servir le résultat : votre propre matériel ou un fournisseur qui héberge des poids personnalisés. Modèles open-weight ou fermés traite de ce compromis.

Où se situe BroadNet Inference

BroadRouter est le site de BroadNet. L’API en libre-service de BroadNet Inference n’a pas d’endpoint de fine-tuning : sa référence d’API ne documente que les chat completions et la transcription audio. La même page indique : « private endpoints, our Arabic fine-tunes and other models on request are reached with a private ID issued with the endpoint » (traduction : « les endpoints privés, nos fine-tunes arabes et les autres modèles sur demande sont accessibles avec un ID privé délivré avec l’endpoint »). Les pages de modèles de BroadNet présentent un fine-tune de Cohere Transcribe Arabic par BroadNet, pour les nombres, les dates et les noms dans un audio bruité, comme disponible sur demande, avec un ID de modèle privé par client, et indiquent que Gemma 4 VL 26B est disponible sur un endpoint privé « including our Arabic fine-tunes » (traduction : « y compris nos fine-tunes arabes »). Ce sont des demandes à faire via la page de contact, pas quelque chose que vous pouvez acheter ou entraîner vous-même ; planifier un endpoint privé explique quoi envoyer.

Pour tout ce qui précède cette étape, les modèles publics suffisent pour construire votre jeu d’évaluation et votre score de référence : Qwen3.8 27B et GLM 5.3 documentent la sortie structurée, Gemma 4 VL 26B fonctionne avec le crédit de départ de $5, et BroadNet Transcribe Arabic traite la parole à $0.0042 la minute. Le contenu d’inférence n’est pas conservé ; les métadonnées nécessaires de compte, de facturation et de sécurité sont conservées comme le décrit la déclaration de confidentialité de BroadNet.

Questions fréquentes

Faut-il faire du fine-tuning ou du RAG ?

Utilisez la recherche documentaire quand il manque des faits au modèle, surtout des faits qui changent : documents, prix, politiques. Envisagez le fine-tuning quand le modèle a l’information mais se comporte mal de façon constante, par exemple sur le format, le ton, les étiquettes ou le vocabulaire métier, et que des prompts avec exemples ne l’ont pas corrigé.

Comment savoir si le prompt engineering suffit ?

Mesurez-le. Construisez un jeu d’évaluation à partir d’entrées réelles, notez le prompt actuel, puis essayez des instructions plus claires, des exemples few-shot, la sortie structurée et la validation. Si le score atteint votre objectif, arrêtez-vous. Si un type d’échec persiste malgré ces changements, c’est un candidat au fine-tuning.

Combien de données faut-il pour un fine-tuning ?

Il n’y a pas de chiffre universel. Cela dépend de la tâche, du modèle de base et de la méthode. Réunissez assez d’exemples annotés et cohérents pour couvrir chaque cas qui compte, plus un jeu de test séparé mis de côté, et vérifiez si le score augmente encore quand vous ajoutez des données.

Puis-je fine-tuner un modèle sur BroadNet Inference ?

Pas en libre-service. La référence de l’API de BroadNet documente les chat completions et la transcription audio, sans endpoint d’entraînement. BroadNet présente ses fine-tunes arabes, comme une version ajustée de Cohere Transcribe Arabic, comme des modèles sur demande servis sur un endpoint privé avec un ID de modèle privé.

BroadNet s’entraîne-t-il sur mon trafic d’API ?

La déclaration de confidentialité de BroadNet indique qu’il n’utilise pas les données d’inférence pour entraîner, fine-tuner ou évaluer des modèles, et qu’il ne conserve pas le contenu d’inférence. Si vous voulez fine-tuner sur votre propre trafic, vous devez collecter et stocker ces données vous-même, avec le droit de les utiliser.

Lire en MarkdownDemander à ChatGPTDemander à ClaudeDemander à Perplexity