Atrium blanc d'une bibliothèque sur plusieurs étages, rayonnages et escaliers
Jolimoi Tech · Grand format

Multi-label Classification Problems with Large Language Models

Classer un texte dans plusieurs catégories à la fois demandait des données annotées en masse et un modèle à entraîner. Un LLM et quelques exemples raccourcissent le chemin. Ils ne dispensent pas de mesurer.

Par Alexis Blandin et Martin Labenne · 10 min de lecture

Faites défiler

Dans une bibliothèque, un livre n'occupe qu'une place sur l'étagère. Dans le catalogue, il peut en occuper plusieurs : un essai sur la dette publique se range en politique et en économie. Et certains livres n'entrent dans aucune des cases prévues.

Les données textuelles posent le même problème. Un avis client, un ticket de support, une dépêche parlent rarement d'un seul sujet. Les étiqueter, c'est faire de la classification multi-label : attribuer à chaque texte zéro, une ou plusieurs étiquettes. Le problème revient partout, du tagging sur les réseaux sociaux au diagnostic médical, en passant par le classement des articles de presse et la recommandation de produits.

Nous avons pris un autre chemin que l'entraînement d'un modèle : confier le tri à un grand modèle de langage. Le raccourci est réel. Il a un prix, et il déplace la rigueur plus qu'il ne la supprime.

Dépêche

« Election debate highlights key economic policies. »

Politique
Économie
Sport
Divertissement

Prenez cette dépêche. Quatre rayons sont ouverts : politique, économie, sport et divertissement. Où la ranger ?
Un premier lecteur la range en politique : il s'agit d'un débat électoral.
Un second la range en économie : le débat porte sur la politique économique. Les deux ont raison. La dépêche va dans deux rayons.
Autre dépêche, autre cas. Aucun des quatre rayons ne convient. Le vide est une réponse, et un classifieur doit savoir la donner.
Toute la différence entre multi-classe et multi-label tient là. En multi-classe, chaque texte reçoit exactement une étiquette. En multi-label, il en reçoit zéro, une ou plusieurs, et leur nombre varie d'un texte à l'autre.

Les étiquettes ne sont pas indépendantes. Un texte classé en politique a plus de chances d'être aussi classé en économie qu'en divertissement : la présence d'une étiquette change la probabilité des autres. Un bon modèle apprend ces liens en plus de chaque étiquette.

On écrit ces étiquettes de deux façons : une liste par texte, ou une colonne binaire par étiquette, qui vaut 1 quand l'étiquette s'applique. La seconde forme est celle qu'attendent les outils de mesure.

TexteListePol.Éco.SportDiv.
Government passes new healthcare reform.politique1000
Stock market hits new highs amid economic boom.économie0100
Celebrity singer releases new music video.divertissement0001
Local sports team wins championship game.sport0010
Election debate highlights key economic policies.politique économie1100
AI will take on the world.[ ]0000
Le même jeu de données, écrit en liste et en colonnes binaires.

La difficulté tient à l'arithmétique.

4étiquettes
16
combinaisons possibles
Part couverte par 500 exemples, au mieux
100 %
Si chaque exemple tombait dans une combinaison différente.
Avec 4 étiquettes, un texte peut recevoir 16 combinaisons, de l'ensemble vide aux quatre à la fois. Avec 500 exemples annotés, chacune peut être vue plusieurs fois.
Chaque étiquette ajoutée double ce nombre. À 8 étiquettes, on compte 256 combinaisons.
À 12, on passe à 4 096. Même dans le meilleur des cas, 500 exemples n'en couvrent qu'une sur huit.
À 20 étiquettes, plus d'un million. La matrice des étiquettes se vide : la plupart des combinaisons n'ont aucun exemple, et les étiquettes rares en ont trop peu pour qu'un modèle les apprenne.

Entraîner un modèle demande alors une grande quantité de données annotées. La question pratique devient : que faire quand on n'a ni ces données, ni les moyens de les produire ?

Tiroirs en bois d'un ancien fichier de bibliothèque
Rayon 1

L'ancien chemin

Ce que coûte un classifieur entraîné à la main.

La réponse classique passe par un projet de traitement automatique du langage, le NLP, en trois étapes.

Prétraitement

Minuscules, suppression de la ponctuation et des chiffres, racinisation ou lemmatisation.

→

Features

Sac de mots, n-grammes.

→

Modèle

Choix du modèle, réglage des hyperparamètres, validation.

Chaque étape demande de l'expertise, et le multi-label y ajoute deux difficultés.

Le déséquilibre. Certaines étiquettes apparaissent partout, d'autres presque jamais. Plus l'écart est grand, plus l'entraînement peine.

La corrélation. Les étiquettes dépendent les unes des autres, et le modèle doit apprendre ces dépendances en plus des étiquettes elles-mêmes.

Du prétraitement à la validation, le chemin consomme du temps et des ressources avant la première prédiction utile.

Échelle appuyée contre de hauts rayonnages, entre deux colonnes
Rayon 2

Le raccourci

Un modèle déjà entraîné, une API, quelques exemples.

Les grands modèles de langage changent l'équation. Entraînés sur d'immenses volumes de texte, ils résument, traduisent et analysent le sentiment dans la plupart des langues. Classer un texte entre dans leurs compétences, pour trois raisons.

Simple. Les fournisseurs exposent une API utilisable depuis n'importe quel langage. Pas besoin d'une expertise en machine learning, et le texte n'a même pas à être prétraité.

Moins cher. Les meilleurs modèles de langage sont des réseaux de neurones, qui tournent vite sur GPU. Monter une instance équipée, dans le cloud ou sur site, alourdit le déploiement et l'exploitation. Pour des textes courts, payer l'inférence d'un fournisseur au token, un fragment de mot, revient souvent moins cher.

Ajustable. Un ou deux exemples glissés dans la consigne suffisent à relever la qualité des prédictions.

Reste l'objection habituelle : un LLM ne répondrait jamais deux fois la même chose. C'est vrai en général, et rare sur une tâche de classification simple. L'API d'OpenAI permet en plus de fixer le hasard.

# on fixe le hasard autant que l'API le permet
temperature=0,
seed=424242,

Le résultat devient presque déterministe. Pour classer, presque suffit.

Pas de jeu d'entraînement.Un jeu de test, toujours.

Le LLM dispense d'entraîner un modèle. Il ne dispense pas de vérifier qu'il classe bien vos textes à vous. Pour le multi-label, un bon jeu de test :

Le renouveler avec des données fraîches permet de suivre la qualité dans les conditions réelles, sur des textes que le prompt n'a jamais vus.

Gravure de lecteurs absorbés sous des lampes de bibliothèque
Rayon 3

Le prix d'une pensée

Chaque mot que le modèle écrit se paie, en argent et en temps.

Depuis l'arrivée des LLM, les techniques de prompt se multiplient : few-shot, chain of thought, tree of thoughts, et une nouvelle chaque mois. Elles n'emploient pas le même nombre de tokens, et ce nombre décide du coût et de la latence.

= 4 tokens lus coûtent autant qu'1 token écrit
Chain of thoughtraisonne pas à pas
Tree of thoughtsplusieurs experts débattent
Few-shotexemples, réponse courte
entréesortieschéma, pas une mesure
Une règle d'abord. Les fournisseurs facturent environ un quart du coût aux tokens d'entrée et trois quarts aux tokens de sortie. Quatre mots lus coûtent autant qu'un mot écrit, et chaque mot écrit prend du temps.
Chain of thought demande au modèle de raisonner étape par étape (« Let's think step by step »). Il écrit son raisonnement avant de répondre : beaucoup de sortie.
Tree of thoughts fait débattre plusieurs experts imaginaires. Chacun écrit une étape, la partage, et quitte la discussion s'il se trompe. La sortie s'allonge encore.
Few-shot procède à l'inverse : une consigne courte, quelques paires question-réponse en exemple, puis le texte à traiter. L'entrée grossit, la sortie se réduit à une liste d'étiquettes.
Pour classer, le few-shot l'emporte : on paie les exemples au tarif de l'entrée et on économise la sortie. Chain of thought et tree of thoughts restent une option quand ni le budget ni la latence ne comptent.
Allée de rayonnages aux livres bien rangés
Rayon 4

Le classifieur

Quelques dizaines de lignes de Python.

Le classifieur repose sur l'API d'OpenAI. Il choisit entre zéro et quatre étiquettes : sports, politics, economy et entertainment. Tout se joue dans la pile de messages envoyée au modèle.

messages = [  {"role": "system", "content":    "You are a multi-label classifier. Return the tags as a "    "list separated by commas. If no tags apply, return nothing. "    "Available tags: sports, politics, economy, entertainment."},   # exemple 1 : deux étiquettes  {"role": "user",   "content": "Text: 'Election debate highlights key economic policies.'"},  {"role": "assistant", "content": "Tags:politics,economy"},   # exemple 2 : aucune étiquette  {"role": "user", "content": "Text: 'AI will take on the world.'"},  {"role": "assistant", "content": "Tags:"},   # le texte à classer  {"role": "user", "content": f"Text: '{content_txt}'"},]
La consigne système décrit la tâche, le format de sortie et les étiquettes autorisées. Elle dit aussi quoi faire quand rien ne s'applique : ne rien répondre.
Le premier exemple montre une dépêche à deux étiquettes, et la forme exacte de la réponse attendue : un préfixe, puis une liste séparée par des virgules.
Le second montre le cas vide. Une réponse sans étiquette est permise, et le modèle le voit écrit noir sur blanc.
Le texte à classer arrive en dernier. Choisir les exemples reste la partie difficile : ce sont eux qui apprennent au modèle la structure de la tâche et le format de sortie.

La réponse du modèle reste du texte libre. Il faut la nettoyer : retirer le préfixe, découper, ôter les espaces. Puis la filtrer, car le modèle peut inventer une étiquette. L'intersection avec la liste autorisée l'efface.

ALLOWED = ["sports", "politics", "economy", "entertainment"] def parse_labels(completion) -> list[str]:    text = completion.choices[0].message.content    text = text.replace("Tags:", "").strip()    if not text:        return []    labels = [label.strip() for label in text.split(",")]    return sorted(set(labels) & set(ALLOWED))   # le garde-fou
Extrait condensé. La liste triée se compare directement au jeu de test.

Le few-shot a une limite : plus il y a d'étiquettes, plus le modèle hésite, et la précision baisse. Quand les étiquettes s'organisent en hiérarchie, une cascade contourne le problème. Un premier appel choisit l'étage, un second, spécialisé, choisit le rayon.

Texte

→

Grandes catégories

premier appel, généraliste

→

Spécialiste A

étiquettes fines

Spécialiste B

étiquettes fines

Sinon, il faut tester des techniques plus coûteuses, moins sensibles au nombre d'étiquettes.

Dernier détail de plomberie. Classer un historique de milliers de textes heurte vite la limite d'appels du fournisseur. Le paquet ratelimit règle la question avec deux décorateurs : au-delà de 50 appels par minute, les appels en trop attendent la fenêtre suivante au lieu d'échouer.

from ratelimit import limits, sleep_and_retry @sleep_and_retry               # au-delà : attendre, puis réessayer@limits(calls=50, period=60)   # 50 appels par minutedef get_chat_completion(messages):    return client.chat.completions.create(        model=MODEL_NAME, messages=messages,        temperature=0, seed=424242,    )
Grande salle de lecture pleine de lecteurs, vue d'en haut
Rayon 5

En production

Tracer, mesurer, comparer.

En production, chaque appel doit laisser une trace : l'entrée, la sortie, le nombre de tokens et la durée. Ces traces montrent les bonnes et les mauvaises prédictions, le coût réel et la latence. Une séquence plus longue met plus de temps à générer. Des outils comme LangSmith ou Phoenix rendent ces traces lisibles.

La qualité se mesure en continu, sur des données fraîches, par une revue humaine ou par un second LLM chargé de juger le premier : c'est le LLM as a judge. Chaque version du prompt se conserve avec son rapport de classification, pour comparer les versions sur les mêmes métriques.

Reste à choisir ces métriques. En multi-label, une même prédiction reçoit des notes très différentes selon la règle appliquée.

Attendupolitiqueéconomie Préditpolitique

Exact match

0

Tout ou rien.

Hamming loss

0,25

1 étiquette fausse sur 4.

Jaccard

0,5

1 commune sur 2 au total.

Précision · Rappel

1 · 0,5

Rien de faux, un oubli.

Reprenons la dépêche du début. On attendait politique et économie. Le modèle ne prédit que politique.
L'exact match, ou subset accuracy, compte tout ou rien : l'ensemble prédit doit être identique à l'ensemble attendu. Ici, 0. C'est la métrique la plus stricte.
La Hamming loss compte les étiquettes mal prédites, une par une. Sur quatre étiquettes possibles, une seule est fausse : 0,25. Plus elle est basse, mieux c'est.
Le score de Jaccard divise l'intersection par l'union : une étiquette en commun, deux au total. 0,5.
La précision regarde ce qui a été prédit : tout est juste, 1. Le rappel regarde ce qui était attendu : la moitié a été trouvée, 0,5. Le F1, leur moyenne harmonique, vaut 0,67.

Le choix dépend de l'erreur qu'on redoute. La précision évite les faux positifs, le rappel évite les oublis, le F1 équilibre les deux. Pour agréger sur plusieurs étiquettes, scikit-learn propose quatre moyennes.

micro
un compte global des vrais et faux positifs, toutes étiquettes confondues ;
macro
la moyenne simple par étiquette, où une étiquette rare pèse autant qu'une fréquente ;
weighted
la moyenne par étiquette, pondérée par sa fréquence, qui tient compte du déséquilibre ;
samples
le calcul texte par texte, puis la moyenne : il dit si le modèle trouve les bonnes étiquettes pour chaque texte.

Un seul appel à classification_report donne précision, rappel, F1 et support, par étiquette et pour chaque moyenne.

mlb = MultiLabelBinarizer().fit([ALLOWED])y_true = mlb.transform(labels_true)y_pred = mlb.transform(labels_pred) accuracy_score(y_true, y_pred)       # exact matchhamming_loss(y_true, y_pred)jaccard_score(y_true, y_pred, average="samples")classification_report(y_true, y_pred, target_names=mlb.classes_)

Un LLM ne supprime pas le dataset.Il le déplace de l'entraînement vers le test.

Le raccourci est réel : une API, quelques exemples, ni pipeline de prétraitement ni modèle à entraîner. Mais la rigueur change d'endroit. Elle se loge dans le jeu de test, dans les traces, dans les métriques et dans l'historique des prompts. C'est là qu'on sait si le livre est dans le bon rayon.