Hugging Face Transformers en 2026 : NLP, fine-tuning et questions d'entretien

Hugging Face Transformers s'est imposé comme la bibliothèque standard pour travailler avec les modèles à base de transformers, que ce soit en NLP, en vision par ordinateur ou en traitement audio. Avec la sortie de Transformers v5 et plus d'un million de checkpoints de modèles sur le Hub, la maîtrise de cet écosystème est désormais un prérequis de base lors des entretiens en data science.

Architecture de Transformers v5 et changements clés de l'API

Le passage de la v4 à la v5 représente le plus grand changement structurel depuis la création de la bibliothèque. Les installations quotidiennes sont passées de 20 000 à plus de 3 millions durant les cinq années de vie de la v4, et une grande partie du code avait accumulé une dette technique que la v5 corrige directement.

Trois changements comptent le plus pour les praticiens :

1. Backend PyTorch uniquement — Les implémentations de modèles TensorFlow et Flax ont été supprimées. La compatibilité JAX est maintenue via des bibliothèques partenaires, mais toutes les définitions de modèles dans Transformers ciblent désormais exclusivement PyTorch.
2. Processeur unifié — Les modèles multimodaux (vision-langage, audio-langage) nécessitaient auparavant des combinaisons ad hoc de tokenizers et d'extracteurs de features. Un unique objet processor gère désormais tout le prétraitement.
3. Serveur d'inférence intégré — La commande transformers serve expose une API compatible OpenAI avec batching continu et attention paginée, ce qui élimine le besoin d'une infrastructure de serving séparée dans bien des cas.

# serve_model.py
# Start an OpenAI-compatible inference server from the command line
# transformers serve --model meta-llama/Llama-4-Scout-17B-16E-Instruct --compile

# Or use the Python API directly
from transformers import pipeline

# The pipeline API remains the fastest way to get predictions
classifier = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")
results = classifier(["Transformers v5 simplifies everything.", "Legacy code migration is painful."])
print(results)
# [{'label': 'POSITIVE', 'score': 0.9998}, {'label': 'NEGATIVE', 'score': 0.9994}]

L'API pipeline masque la tokenisation, le chargement du modèle et le post-traitement derrière un unique appel de fonction. Pour les charges de production, transformers serve offre la même simplicité avec un batching et une gestion de la concurrence adaptés.

Charger et utiliser des modèles pré-entraînés depuis le Hub

Le Hub Hugging Face héberge plus d'un million de checkpoints de modèles. En charger un ne demande que deux lignes de code, mais savoir quel modèle choisir et comment le configurer distingue les débutants des praticiens expérimentés.

Les classes AutoModel détectent la bonne architecture à partir des métadonnées de la carte du modèle. Le même code de chargement fonctionne donc pour BERT, GPT, T5, Llama ou toute autre architecture :

# load_model.py
from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load tokenizer and model — architecture detected automatically
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=3)

# Tokenize input text with padding and truncation
inputs = tokenizer(
    "Hugging Face makes NLP accessible.",
    return_tensors="pt",     # Return PyTorch tensors
    padding=True,
    truncation=True,
    max_length=128
)

# Run inference with no gradient computation
with torch.no_grad():
    outputs = model(**inputs)
    predictions = torch.softmax(outputs.logits, dim=-1)
    print(f"Class probabilities: {predictions}")

La méthode from_pretrained télécharge les poids du modèle, sa configuration et le vocabulaire du tokenizer au premier appel, puis les met en cache localement. Les appels suivants chargent depuis le cache sans aucune requête réseau.

Fine-tuning avec LoRA et l'API Trainer

Le fine-tuning complet de grands modèles exige une mémoire GPU considérable — un modèle de 7 milliards de paramètres demande environ 28 Go rien que pour les poids en FP32. LoRA (Low-Rank Adaptation) réduit les besoins en mémoire de 60 à 80 % en gelant les poids pré-entraînés et en injectant de petites matrices entraînables dans chaque couche.

La bibliothèque PEFT s'intègre directement à Transformers pour rendre le fine-tuning LoRA simple :

# finetune_lora.py
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from peft import LoraConfig, get_peft_model, TaskType
from datasets import load_dataset

# Load base model and tokenizer
model_name = "Qwen/Qwen3-0.6B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto")

# Configure LoRA — only 0.5-2% of parameters become trainable
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,                   # Rank of the low-rank matrices
    lora_alpha=32,          # Scaling factor
    lora_dropout=0.05,      # Dropout for regularization
    target_modules=["q_proj", "v_proj"],  # Which attention layers to adapt
)

# Wrap the model with LoRA adapters
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable params: 1,572,864 || all params: 631,000,000 || trainable%: 0.25

# Load and tokenize dataset
dataset = load_dataset("tatsu-lab/alpaca", split="train[:5000]")

def tokenize(example):
    return tokenizer(example["text"], truncation=True, max_length=512, padding="max_length")

tokenized = dataset.map(tokenize, batched=True, remove_columns=dataset.column_names)

# Configure training
training_args = TrainingArguments(
    output_dir="./lora-qwen",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,  # Effective batch size = 16
    learning_rate=2e-4,
    bf16=True,                      # Use bfloat16 mixed precision
    logging_steps=50,
    save_strategy="epoch",
)

# Train
trainer = Trainer(model=model, args=training_args, train_dataset=tokenized)
trainer.train()

Les adaptateurs LoRA sont sauvegardés séparément du modèle de base (généralement 10 à 50 Mo contre plusieurs Go). Plusieurs adaptateurs peuvent être permutés au moment de l'inférence sans recharger les poids de base, ce qui rend LoRA particulièrement utile pour servir plusieurs modèles spécialisés depuis un seul déploiement.

Construire un pipeline NLP : de la tokenisation à l'inférence

Chaque tâche NLP dans Transformers suit le même schéma en trois étapes : tokeniser l'entrée, la faire passer dans le modèle, puis décoder la sortie. Comprendre ce flux est essentiel pour déboguer les systèmes de production et répondre aux questions d'entretien sur l'architecture transformer.

La tokenisation convertit le texte brut en identifiants numériques que le modèle comprend. Chaque famille de modèles utilise une stratégie de tokenisation différente — BERT utilise WordPiece, les modèles GPT utilisent BPE et T5 utilise SentencePiece :

# tokenization_demo.py
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
text = "Transformers handle tokenization automatically."

# Step-by-step tokenization
tokens = tokenizer.tokenize(text)          # Split into subwords
print(f"Tokens: {tokens}")
# ['transformers', 'handle', 'token', '##ization', 'automatically', '.']

ids = tokenizer.convert_tokens_to_ids(tokens)  # Convert to numeric IDs
print(f"IDs: {ids}")
# [19081, 5765, 19204, 6032, 8073, 1012]

# The encode method does both steps plus adds special tokens
encoded = tokenizer.encode(text, add_special_tokens=True)
print(f"Encoded with special tokens: {encoded}")
# [101, 19081, 5765, 19204, 6032, 8073, 1012, 102]
# 101 = [CLS], 102 = [SEP]

Le token ##ization illustre la tokenisation en sous-mots — les mots rares sont découpés en sous-mots connus, ce qui permet aux modèles de gérer un vocabulaire jamais vu en pré-entraînement sans recourir à un repli au niveau caractère.

Quantification pour un déploiement efficace

La quantification réduit la taille du modèle et la latence d'inférence en convertissant les poids depuis le format flottant 32 bits vers des formats de précision inférieure. L'approche la plus pratique en 2026 utilise bitsandbytes pour la quantification 4 bits, qui fait tenir un modèle de 7 milliards de paramètres dans environ 4 Go de mémoire GPU :

# quantize_model.py
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

# Configure 4-bit quantization
quant_config = BitsAndBytesConfig(
    load_in_4bit=True,                      # Use 4-bit precision
    bnb_4bit_compute_dtype=torch.bfloat16,  # Compute in bfloat16
    bnb_4bit_quant_type="nf4",              # NormalFloat4 quantization
    bnb_4bit_use_double_quant=True,         # Quantize the quantization constants
)

# Load quantized model — fits in ~4GB VRAM instead of ~14GB
model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mistral-7B-Instruct-v0.3",
    quantization_config=quant_config,
    device_map="auto",  # Automatically distribute across available GPUs
)

tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3")

# Inference works identically to the non-quantized model
inputs = tokenizer("Explain quantization in one sentence:", return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=50)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

La quantification 4 bits réduit généralement la qualité de moins de 1 % sur les benchmarks standards tout en diminuant l'usage mémoire de 75 %. Combinée à LoRA, elle permet de fine-tuner sur un seul GPU grand public des modèles qui nécessiteraient autrement une configuration multi-GPU — une technique connue sous le nom de QLoRA.

Questions d'entretien fréquentes sur Hugging Face et réponses

Les entretiens en data science en 2026 testent de plus en plus les connaissances pratiques de Transformers en parallèle de la compréhension théorique. Les questions suivantes reviennent souvent lors des screenings techniques pour les postes d'ingénieur ML et de data scientist.

Qu'est-ce que la self-attention et comment l'attention multi-têtes l'étend-elle ?

La self-attention calcule une représentation pondérée de chaque token en fonction de sa relation avec tous les autres tokens de la séquence. Pour chaque token, le modèle produit trois vecteurs : query (Q), key (K) et value (V). Le score d'attention entre deux tokens est égal au produit scalaire de la query de l'un avec la key de l'autre, mis à l'échelle par la racine carrée de la dimension de la key, puis passé dans une softmax. La sortie est la somme pondérée des vecteurs value.

L'attention multi-têtes exécute ce processus plusieurs fois en parallèle avec des projections apprises différentes. Chaque « tête » peut apprendre à se concentrer sur différents types de relations — la structure syntaxique dans une tête, la coréférence dans une autre, la proximité positionnelle dans une troisième. Les sorties sont concaténées puis projetées de nouveau vers la dimension du modèle.

Pourquoi les transformers ont-ils besoin d'un encodage positionnel ?

Contrairement aux RNN et aux LSTM, les transformers traitent tous les tokens simultanément plutôt que séquentiellement. Sans information de position, le modèle traite l'entrée comme un sac de tokens sans aucune notion d'ordre. Les encodages positionnels (fonctions sinusoïdales fixes ou embeddings appris) sont ajoutés aux embeddings de tokens avant la première couche d'attention. Les modèles modernes comme LLaMA et Qwen utilisent les Rotary Position Embeddings (RoPE), qui encodent des positions relatives plutôt qu'absolues et généralisent mieux aux séquences plus longues que celles vues à l'entraînement.

Quand faut-il préférer LoRA au fine-tuning complet ?

LoRA est le meilleur choix lorsque la mémoire GPU est limitée, lorsque le modèle de base est volumineux (7 milliards de paramètres et plus) ou lorsque plusieurs adaptateurs spécifiques à des tâches doivent être servis depuis un seul modèle de base. Le fine-tuning complet produit des résultats marginalement meilleurs sur les benchmarks (généralement 0,5 à 2 % de précision en plus) mais exige 4 à 8 fois plus de mémoire et crée une copie complète du modèle pour chaque tâche. En pratique, LoRA atteint une qualité comparable pour la plupart des tâches en aval tout en réduisant nettement le temps d'entraînement et les coûts d'infrastructure.

Quelle est la différence entre les modèles encodeur seul, décodeur seul et encodeur-décodeur ?

| Architecture | Exemples | Idéal pour | Schéma d'attention | |---|---|---|---| | Encodeur seul | BERT, RoBERTa, DeBERTa | Classification, NER, embeddings | Bidirectionnel (voit tout le contexte) | | Décodeur seul | GPT, LLaMA, Mistral, Qwen | Génération de texte, chat, code | Causal (de gauche à droite uniquement) | | Encodeur-décodeur | T5, BART, mBART | Traduction, résumé | Cross-attention entre encodeur et décodeur |

Les modèles encodeur seul excellent dans les tâches de compréhension car l'attention bidirectionnelle permet à chaque token de s'attacher à tous les autres tokens. Les modèles décodeur seul dominent les tâches de génération car le masquage causal produit naturellement un token à la fois. Les modèles encodeur-décodeur combinent les deux capacités mais ont largement été supplantés par les modèles décodeur seul qui atteignent des résultats comparables avec des architectures plus simples.

Comment l'API Trainer gère-t-elle l'entraînement distribué ?

La classe Trainer détecte automatiquement les GPU disponibles et configure le parallélisme de données. Pour l'entraînement multi-nœuds, elle s'intègre avec le DistributedDataParallel de PyTorch et prend en charge les stages ZeRO 1 à 3 de DeepSpeed via un unique fichier de configuration. Définir deepspeed="ds_config.json" dans TrainingArguments suffit à activer l'offloading ZeRO-3, qui répartit les états de l'optimiseur, les gradients et les paramètres du modèle entre les GPU et les délègue éventuellement à la RAM CPU.

Quelles métriques comptent pour évaluer un modèle NLP ?

Le choix dépend de la tâche. Pour la classification : accuracy, F1-score (surtout le macro-F1 pour les classes déséquilibrées), précision et rappel. Pour la génération : BLEU, ROUGE et de plus en plus BERTScore qui corrèle mieux avec le jugement humain. Pour la recherche et les embeddings : recall@k, NDCG et mean reciprocal rank. Les systèmes de production doivent aussi suivre la latence d'inférence (p50/p99), le débit (tokens/seconde) et l'usage mémoire en parallèle des métriques de qualité.

Se préparer aux entretiens Hugging Face et NLP

La préparation technique aux entretiens data science orientés NLP gagne à passer par une pratique concrète de la bibliothèque Transformers plutôt que par une étude purement théorique. L'approche la plus efficace combine trois éléments :

• Construire des projets de bout en bout — un classifieur de sentiments, un système de reconnaissance d'entités nommées ou un pipeline de résumé. Chacun force des décisions sur le prétraitement, la sélection de modèle et l'évaluation que les recruteurs sondent directement.
• Lire les cartes de modèles — les cartes de modèles du Hub documentent les données d'entraînement, l'usage prévu, les limites et les résultats d'évaluation. Les recruteurs attendent des candidats qu'ils évaluent ces cartes de manière critique plutôt que de choisir aveuglément le checkpoint le plus téléchargé.
• Profiler la mémoire et la latence — comprendre les compromis entre l'inférence FP32, FP16, BF16 et INT4 sur différentes configurations matérielles distingue les candidats seniors des juniors.

Le module de pratique NLP et Hugging Face de SharpSkill couvre ces sujets à travers des questions d'entretien ciblées accompagnées d'explications détaillées. Pour une préparation plus large sur les mécanismes d'attention des transformers et les fondamentaux du deep learning, le parcours data science propose des chemins de pratique structurés.

Conclusion

• Transformers v5 consolide la bibliothèque autour de PyTorch, supprime les backends hérités et introduit un serving intégré avec transformers serve pour l'inférence en production.
• Les API AutoModel et pipeline restent le chemin le plus rapide entre zéro et des prédictions fonctionnelles — deux lignes de code chargent n'importe lequel des plus d'un million de modèles du Hub.
• Le fine-tuning LoRA via PEFT réduit les besoins en mémoire GPU de 60 à 80 % tout en restant à 1-2 % de la qualité du fine-tuning complet sur la plupart des tâches.
• La quantification 4 bits via bitsandbytes fait tenir des modèles de 7 milliards de paramètres dans 4 Go de VRAM, et QLoRA combine les deux techniques pour un fine-tuning sur GPU grand public.
• Les questions d'entretien portent sur trois domaines : la connaissance de l'architecture (self-attention, encodage positionnel, encodeur vs décodeur), les compétences pratiques (fine-tuning, quantification, sélection de modèle) et le system design (entraînement distribué, serving, optimisation mémoire).
• Comprendre les rouages internes de la tokenisation (WordPiece, BPE, SentencePiece) et savoir déboguer le comportement d'un tokenizer est un facteur de différenciation souvent sous-estimé en entretien.