🤗 Hugging Face Transformers – L'Écosystème SOTA du NLP

SpaCy/NLTK utilisent des modèles "classiques" (statistiques ou CNN simples). transformers utilise des modèles "Deep Learning" (SOTA) pré-entraînés sur des Pétaoctets de texte.

transformers est "agnostique" : il a besoin d'un backend (PyTorch ou TensorFlow) pour tourner. (PyTorch est le backend par défaut/préféré par la communauté).

1. Installation (avec PyTorch)

# 1. (Recommandé) Installer PyTorch d'abord (voir guide PyTorch)
pip install torch

# 2. Installer transformers
pip install transformers

# (OU: Installer les deux en une fois)
# pip install transformers[torch]

2. Installation (avec TensorFlow)

# 1. Installer TensorFlow
pip install tensorflow

# 2. Installer transformers
pip install transformers

# (OU: Installer les deux en une fois)
# pip install transformers[tensorflow]

3. Installation (avec datasets & accelerate)

# (Pour le Fine-Tuning)
pip install transformers[torch] datasets accelerate

Le **Hugging Face Hub** (huggingface.co) est le "cœur" de l'écosystème. C'est un "GitHub pour le Machine Learning".

Il héberge (gratuitement) :

• Des milliers de Modèles pré-entraînés (ex: bert-base-uncased, meta-llama/Llama-2-7b).
• Des milliers de Datasets (via datasets).
• Des Démos (Spaces) (via Gradio/Streamlit).

Toutes les fonctions .from_pretrained() de la bibliothèque transformers téléchargent les modèles *depuis* ce Hub.

Le pipeline() est l'API "facile". C'est la meilleure façon de commencer.

Elle abstrait **tout** le workflow (Tokenizer, Modèle, Post-processing) en une seule fonction. Il suffit de lui donner le nom de la "tâche" (task).

Diagramme (pipeline)

(Votre texte: "I love this!")
      |
      ▼
+------------------------------------------+
| pipeline("sentiment-analysis")           | (Cache le workflow)
|                                          |
| 1. Tokenizer (Texte -> IDs)              |
| 2. Model (IDs -> Logits)                 |
| 3. Post-process (Logits -> Label)        |
|                                          |
+------------------------------------------+
      |
      ▼
(Résultat: [{'label': 'POSITIVE', 'score': 0.99...}])

Syntaxe (Générique)

from transformers import pipeline

// 1. Charger un pipeline (par tâche)
// (Télécharge le modèle par défaut pour cette tâche)
classifier = pipeline("sentiment-analysis")

// 2. Utiliser
result = classifier("This movie is fantastic!")

// 3. Charger un pipeline (modèle spécifique du Hub)
ner_pipeline = pipeline(
    "ner", 
    model="dbmdz/bert-large-cased-finetuned-conll03-english"
)

// 4. Spécifier le device (GPU)
text_gen = pipeline("text-generation", device=0) // (GPU 0)

Pour le fine-tuning ou un contrôle avancé, on n'utilise pas pipeline(). On utilise les 3 composants manuels :

Diagramme (Workflow Manuel)

+-------------------------+
| Texte brut (String)     |
+-------------------------+
      |
      ▼ (1. Tokenizer)
+-------------------------+
| AutoTokenizer           | (Ex: bert-base-uncased)
| (Texte -> IDs)          |
+-------------------------+
      |
      ▼
+-------------------------+
| Dictionnaire (Python)   |
| {'input_ids': [...],    |
|  'attention_mask': [...]} |
+-------------------------+
      |
      ▼ (2. Model)
+-------------------------+
| AutoModel (PyTorch/TF)  | (Ex: bert-base-uncased)
| (IDs -> Logits)         |
+-------------------------+
      |
      ▼
+-------------------------+
| Output (Logits/Vecteurs)|
+-------------------------+
      |
      ▼ (3. Post-processing)
+-------------------------+
| Votre code (ex: ArgMax) |
+-------------------------+

Le Tokenizer (Tokeniseur) convertit le texte (string) en "Tensors" (nombres) que le modèle comprend.

AutoTokenizer est une "factory" qui charge le bon tokenizer (WordPiece, BPE, ...) associé au modèle (.from_pretrained()).

from transformers import AutoTokenizer

model_name = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)

text = "Hello, world!"

# (Tokenize + Convert to IDs + Add Special Tokens [CLS]/[SEP])
inputs = tokenizer(
    text, 
    padding=True, 
    truncation=True, 
    return_tensors="pt" // "pt" (PyTorch) ou "tf" (TensorFlow)
)

print(inputs)
// {
//  'input_ids': tensor([[ 101, 7592, 1010, 2088,  102]]),
//  'token_type_ids': tensor([[   0,    0,    0,    0,    0]]),
//  'attention_mask': tensor([[   1,    1,    1,    1,    1]])
// }
// (attention_mask = 1 si 'vrai' token, 0 si 'padding')

AutoModel charge le "corps" (base) du Transformer. Il retourne les **hidden states** (les "embeddings" contextuels), mais **pas** de prédiction finale.

Utile pour extraire des features (Embeddings) ou pour construire une "tête" (Head) custom.

from transformers import AutoModel

model = AutoModel.from_pretrained(model_name)

// (inputs = Tensors du Tokenizer)
outputs = model(**inputs) // (Le ** décompose le dict)

// (La sortie 'last_hidden_state'
// est le vecteur (embedding) de chaque token)
print(outputs.last_hidden_state.shape)
// torch.Size([1, 5, 768])
// (Batch=1, N_Tokens=5, Dim_Hidden=768)

C'est ce qu'on utilise 99% du temps (y compris pour le fine-tuning). Ce sont des classes (ex: AutoModelForSequenceClassification) qui ajoutent une "tête" (Head) de tâche (ex: une couche Dense) au-dessus du modèle de base.

Diagramme (Base + Head)

(input_ids)
     |
     ▼
+----------+
| AutoModel| (Ex: BERT)
| (Base)   | (Retourne Hidden States 768-dim)
+----------+
     |
     ▼
+----------+
| "Head"   | (Couche Dense (768 -> 2) + Softmax)
| (Tâche)  |
+----------+
     |
     ▼
(Logits/Probas) (ex: POSITIVE/NEGATIVE)

Exemple (Classification)

from transformers import AutoModelForSequenceClassification

// (Charge BERT + une tête de classification
// (2 labels: POS/NEG) déjà fine-tunée)
model_name = "distilbert-base-uncased-finetuned-sst-2-english"
model = AutoModelForSequenceClassification.from_pretrained(model_name)

outputs = model(**inputs)

print(outputs.logits) // (Logits bruts, avant Softmax)
// tensor([[-4.2, 4.5]]) (-> POSITIVE)

On n'entraîne (quasiment) **jamais** un Transformer (BERT, GPT) "from scratch" (de zéro). C'est trop coûteux (Mois, Millions $).

Le **Fine-Tuning** (Transfer Learning) est le processus :

1. Pre-training (Pré-entraînement) : (Fait 1x par Google/Meta). Le modèle (ex: BERT) apprend le langage sur des Pétaoctets de texte (ex: Wikipédia). (Coûteux).
2. Fine-Tuning (Ajustement) : (Fait par vous). On prend le modèle (ex: bert-base-uncased), on y ajoute une "tête" (Head) (ex: classifieur 3 classes), et on le ré-entraîne (.train()) sur **nos données spécifiques** (ex: 5000 tickets support).

C'est la méthode SOTA pour adapter un gros modèle à une tâche de niche.

La bibliothèque datasets est l'outil standard (de Hugging Face) pour charger et pré-traiter (mapper, filtrer) des datasets (petits ou très gros) depuis le Hub ou localement.

from datasets import load_dataset

# 1. Charger depuis le Hub
dataset = load_dataset("imdb") # (Dataset de reviews de films)
// (Retourne un 'DatasetDict': {'train': ..., 'test': ...})

# 2. Charger un CSV local
dataset_local = load_dataset("csv", data_files="mon_fichier.csv")

# 3. Tokenizer (Preprocessing)
// (On utilise .map() pour appliquer le tokenizer
// à tout le dataset de manière optimisée)
def tokenize_function(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True)

tokenized_datasets = dataset.map(tokenize_function, batched=True)

L'API Trainer est l'équivalent du .fit() de Keras. Elle abstrait la boucle d'entraînement (for epoch...) de PyTorch/TF.

C'est la méthode "standard" pour le Fine-Tuning.

from transformers import Trainer, TrainingArguments

# (tokenized_datasets = dataset (4.1))
# (model = AutoModelFor... (3.3))

# 1. Arguments d'entraînement
training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    evaluation_strategy="epoch", // (Évaluer à chaque epoch)
    logging_dir="./logs",
)

# 2. Initialiser le Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["test"],
    # (compute_metrics=... (optionnel))
)

# 3. Lancer le Fine-Tuning
trainer.train()

# 4. Sauvegarder
trainer.save_model("./mon_modele_finetuned")

accelerate est une bibliothèque qui simplifie le passage d'un script PyTorch d'un CPU -> 1 GPU -> Multi-GPU -> TPU, sans (presque) changer le code.

Elle est utilisée en interne par le Trainer, mais peut aussi être utilisée pour des boucles custom (PyTorch natif).

Hugging Face n'est plus "juste" du NLP. La bibliothèque diffusers est devenue le "standard" (similaire à transformers) pour la **Génération d'Images** (Modèles de Diffusion).

from diffusers import DiffusionPipeline

# (Ex: Stable Diffusion)
pipeline = DiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5"
)
pipeline.to("cuda") // (GPU obligatoire)

prompt = "A high-quality photo of an astronaut riding a horse."
image = pipeline(prompt).images[0]

image.save("astronaut.png")

transformers est devenu l'outil standard de l'industrie et de la recherche pour le SOTA (Deep Learning).

Ressources pour apprendre et travailler avec Hugging Face.