Module 9 — La bibliothèque Transformers en pratique

Les modules précédents utilisaient déjà transformers pour l'affinage (module 6), le NER (module 7) et la QA (module 8). Ce module remonte au niveau du framework : comment il est structuré, comment on choisit un modèle sur le Hub, comment on l'utilise sans se tirer une balle dans le pied.

Trois niveaux d'abstraction, trois usages

La bibliothèque transformers de Hugging Face expose trois niveaux :

Niveau	API	Usage
Haut	pipeline("task", model=…)	Prototype, démonstration, inférence sans entraîner
Moyen	AutoTokenizer, AutoModel*, Trainer	Affinage, contrôle des hyperparamètres, production
Bas	Sous-classer PreTrainedModel, boucle PyTorch	Architecture personnalisée, recherche

Le piège classique du débutant est de choisir le mauvais niveau : utiliser pipeline pour un affinage (impossible), ou tout coder à la main quand Trainer fait exactement ce qu'il faut (perte de temps). Le bon réflexe : commencer par le pipeline pour vérifier que la tâche est bien celle qu'on croit, puis descendre d'un cran pour affiner.

Pipeline : dix lignes pour vérifier une idée

pipeline encapsule tokeniseur, modèle et post-traitement. On lui donne une tâche et un identifiant de modèle du Hub, il gère tout le reste.

from transformers import pipeline

# Analyse de sentiment sur un avis en français
classer = pipeline("text-classification",
                   model="tblard/tf-allocine")
print(classer("Ce restaurant est vraiment excellent, à recommander sans hésiter."))
# [{'label': 'POSITIVE', 'score': 0.998}]

# NER sur un avis
extraire = pipeline("token-classification",
                    model="Jean-Baptiste/camembert-ner",
                    aggregation_strategy="simple")
print(extraire("J'ai déjeuné au Café de Flore avec Marie hier."))

Les tâches supportées couvrent la classification de séquences, la classification de jetons, le NER, la QA, le résumé, la traduction, la génération, la classification à zéro exemple, la classification d'images, l'ASR (reconnaissance vocale), etc.

Chaque pipeline télécharge le modèle depuis le Hub à la première invocation et le met en cache dans ~/.cache/huggingface/. Sur un serveur sans accès Internet, il faut télécharger manuellement puis passer un chemin local.

AutoTokenizer, AutoModel : la bonne classe pour chaque tâche

Une fois qu'on veut contrôler ce qui se passe, on descend d'un cran. Les classes Auto* détectent automatiquement l'architecture du modèle (BERT, CamemBERT, RoBERTa, T5, …) et instancient la bonne sous-classe. Sept variantes principales :

Classe	Tête ajoutée	Tâches
AutoModel	Aucune	Récupérer les vecteurs cachés
AutoModelForSequenceClassification	Linéaire sur [CLS]	Sentiment, catégorisation
AutoModelForTokenClassification	Linéaire par jeton	NER, étiquetage grammatical
AutoModelForQuestionAnswering	Deux linéaires (start, end)	QA extractive
AutoModelForMaskedLM	Prédiction de vocabulaire	Reconstitution de jetons masqués
AutoModelForSeq2SeqLM	Décodeur autoregressif	Traduction, résumé, T5, BART
AutoModelForCausalLM	Décodeur autoregressif	Génération, GPT, LLaMA

Utiliser une classe qui ne correspond pas à la tâche produit soit une erreur explicite (dimensions incompatibles), soit — pire — un entraînement qui converge lentement parce que la tête ajoutée n'est pas pertinente.

Le Hub : lire une fiche modèle avant de télécharger

Il existe environ six cent mille modèles sur le Hub. Trois filtres à appliquer systématiquement :

1. Langue. Le filtre « French » réduit à quelques milliers. Pour l'arabe, quelques centaines. Ne pas prendre un modèle anglais pour du français « en espérant que ça marche » : la tokenisation seule fait perdre l'essentiel du bénéfice.
2. Taille. Un modèle base (110 M paramètres) tourne sur un CPU en 100 ms par exemple ; un large (335 M) prend un GPU pour rester sous 100 ms ; un modèle 7B exige un GPU dédié et une quantisation.
3. Licence. MIT et Apache 2.0 sont sans restriction commerciale. CC-BY-NC interdit l'usage commercial. LLaMA 2 exige une acceptation manuelle et interdit certains usages au-delà de 700 millions d'utilisateurs. Vérifier la licence est une obligation légale, pas une bonne pratique.

Sur le Hub, une fiche modèle (README.md du dépôt) contient normalement : la carte du modèle (model card), les jeux d'entraînement, les métriques, la licence, et un exemple de code. Un modèle sans fiche modèle explicite est un signal négatif — l'auteur n'a pas jugé utile de documenter, on ne saura ni sur quoi il a été entraîné ni ce qu'il évite.

Un modèle inconnu ne s'entraîne pas sur des données inconnues

Si la fiche modèle ne dit rien du corpus d'entraînement, on ne peut pas exclure que ce corpus contienne les données de test qu'on prépare — ni qu'il ait été appris sur des documents dont on n'a pas la licence. En entreprise, ne prendre que des modèles dont la provenance des données est vérifiable ou dont l'éditeur a une responsabilité juridique (Meta, Google, Mistral).

Choix pratique pour un service français en 2026

Voici l'arbre de décision qu'on suit sur le corpus d'avis :

• Classification et NER (modules 6 et 7) : CamemBERT-base ou XLM-RoBERTa-base. Le premier est légèrement meilleur sur le français seul, le second si l'application doit gérer plusieurs langues.
• Recherche sémantique (module 5) : dangvantuan/sentence-camembert-base pour le rapport qualité-prix, dangvantuan/sentence-camembert-large si le budget permet.
• Résumé abstractif (module 8) : BARThez ou mT5-small pour une preuve de concept, puis mT5-base si la qualité manque.
• QA extractive (module 8) : etalab-ia/camembert-base-squadFR-fquad-piaf, entraîné explicitement sur des jeux français.

Trainer : la boucle standard et ses points d'extension

Trainer factorise ce qu'on écrirait à la main en PyTorch : boucle d'entraînement, gestion des lots, évaluation périodique, sauvegarde de point de contrôle, rapports en TensorBoard.

from transformers import Trainer, TrainingArguments

args = TrainingArguments(
    output_dir="./run-01",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=32,
    gradient_accumulation_steps=2,        # lot effectif 32
    learning_rate=2e-5,
    warmup_ratio=0.1,                     # 10 % des pas en montée
    weight_decay=0.01,
    eval_strategy="steps",
    eval_steps=200,
    save_strategy="steps",
    save_steps=200,
    load_best_model_at_end=True,
    metric_for_best_model="f1",
    report_to="tensorboard",
    fp16=True,                            # précision mixte, GPU récent
)

trainer = Trainer(model=modele, args=args,
                  train_dataset=jeu_train,
                  eval_dataset=jeu_valid,
                  tokenizer=tok,
                  compute_metrics=metriques)
trainer.train()
trainer.push_to_hub(commit_message="v1 sur les avis clients")

Trois points d'extension méritent d'être connus :

1. Trainer.compute_loss se surcharge pour changer la fonction de perte, comme au module 6 pour pondérer les classes.
2. Trainer.evaluation_loop se surcharge pour ajouter des métriques calculées en flux.
3. Des rappels (TrainerCallback) s'ajoutent pour l'arrêt anticipé (EarlyStoppingCallback), la journalisation vers Weights and Biases, ou tout comportement personnalisé.

Pousser un modèle sur le Hub : ce que la commande fait vraiment

push_to_hub fait trois choses : elle crée un dépôt public ou privé sur huggingface.co/<utilisateur>/<nom>, elle pousse les fichiers de poids (pytorch_model.bin ou model.safetensors), le tokeniseur, la configuration et le README.md. Le modèle devient alors disponible pour tout le monde via AutoModel.from_pretrained("<utilisateur>/<nom>").

Deux règles importantes : la valeur par défaut du dépôt est publique, ce qui peut être un problème si le modèle a été entraîné sur des données confidentielles ; et le format safetensors est à préférer à pytorch_model.bin, car il ne contient pas de code Python exécutable au chargement.

En résumé

• Trois niveaux d'abstraction : pipeline pour l'inférence rapide, AutoTokenizer plus Auto*Model plus Trainer pour l'affinage, sous-classement pour la recherche.
• Le Hub se filtre par langue, taille et licence ; un modèle sans fiche modèle est un signal négatif à prendre au sérieux.
• La bonne classe AutoModelFor… dépend de la tâche : sept variantes principales couvrent 95 % des besoins.
• Trainer couvre la boucle standard ; ses points d'extension (compute_loss, callbacks) évitent de tout réécrire quand on a un besoin particulier.

Module suivant : on met tout bout à bout — nettoyage, tokenisation, affinage, évaluation, comparaison des trois approches — sur le corpus d'avis, avec les spécificités du français comme fil conducteur.