Hugging Face

À quoi ça sert

Entraîner un gros modèle de deep learning (BERT, Whisper, un détecteur d'objets…) demande des milliers d'heures de GPU et des téraoctets de données. Personne ne fait ça de zéro pour un projet d'application — on récupère un modèle pré-entraîné, on l'adapte si besoin (« fine-tuning »), et c'est tout.

Hugging Face propose deux choses indissociables :

• Le Hub — un site (huggingface.co) où on télécharge et partage des modèles, des datasets, des démos interactives (« Spaces »). Plus de 1 million de modèles disponibles, la plupart gratuits.
• La lib transformers — du code Python qui télécharge un modèle du Hub et l'expose avec une API uniforme. Tu écris la même chose pour BERT, GPT-2 ou Whisper.

Cas d'usage typiques :

• NLP — classification de sentiment, génération de texte, traduction, résumé automatique, NER.
• Vision — classification d'image, détection d'objets, segmentation.
• Audio — transcription (Whisper), synthèse vocale, classification.
• Multimodal — modèles qui mélangent texte + image (CLIP, LLaVA…).

Un exemple d'usage

Tu veux savoir si un avis client est positif ou négatif, sans entraîner de modèle. En 3 lignes :

from transformers import pipeline

clf = pipeline("sentiment-analysis")
print(clf("Le produit est nul, je le déconseille."))
# [{'label': 'NEGATIVE', 'score': 0.9998}]

Au premier run, transformers télécharge un modèle adapté depuis le Hub (mis en cache localement). Aux runs suivants, c'est instantané. pipeline() existe pour des dizaines de tâches : "summarization", "translation_fr_to_en", "automatic-speech-recognition", "object-detection"…

How-to : installer et utiliser Hugging Face

1. Installer transformers

   La lib s'appuie sur PyTorch (par défaut), donc on installe les deux. Avec UV :

   bash Copier

   uv add transformers torch

   Pour certaines tâches multimédia, il faut aussi des extras :

   bash Copier

   uv add "transformers[audio]"   # Whisper, etc.
   uv add "transformers[vision]"  # classification image, etc.

2. Utiliser un pipeline (le plus simple)

   pipeline est l'API haute-niveau. On donne le nom d'une tâche, optionnellement un modèle précis, et c'est tout.

   python Copier

   from transformers import pipeline
   
   # Sentiment (modèle par défaut)
   clf = pipeline("sentiment-analysis")
   
   # Modèle précis (le slug se trouve sur huggingface.co)
   clf = pipeline(
       "sentiment-analysis",
       model="cardiffnlp/twitter-roberta-base-sentiment-latest"
   )
   
   # Transcription audio avec Whisper
   asr = pipeline("automatic-speech-recognition",
                  model="openai/whisper-small")
   print(asr("audio.mp3"))

3. Trouver un modèle sur le Hub

   Va sur huggingface.co/models, filtre par tâche (gauche) et par langue. Le « slug » d'un modèle est de la forme auteur/nom-du-modèle. Quelques valeurs sûres :

   • distilbert-base-uncased — BERT léger pour classification de texte.
   • openai/whisper-small — transcription audio multilingue.
   • sentence-transformers/all-MiniLM-L6-v2 — embeddings de phrases (pour RAG/similarité).
   • facebook/bart-large-cnn — résumé en anglais.

4. API bas-niveau : tokenizer + modèle

   pipeline est pratique mais cache tout. Pour plus de contrôle (batch, GPU explicite, fine-tuning) on passe par l'API bas-niveau :

   python Copier

   from transformers import AutoTokenizer, AutoModelForSequenceClassification
   import torch
   
   model_name = "distilbert-base-uncased-finetuned-sst-2-english"
   tokenizer = AutoTokenizer.from_pretrained(model_name)
   model = AutoModelForSequenceClassification.from_pretrained(model_name)
   
   inputs = tokenizer("This is great", return_tensors="pt")
   with torch.no_grad():
       logits = model(**inputs).logits
   pred = logits.argmax(dim=-1).item()
   print(model.config.id2label[pred])

5. Datasets : la lib compagnon

   Hugging Face héberge aussi des datasets. La lib datasets les charge sans effort :

   bash Copier

   uv add datasets

   python Copier

   from datasets import load_dataset
   
   ds = load_dataset("imdb")
   print(ds["train"][0])
   # {'text': 'Plot is solid…', 'label': 1}

6. Authentification et téléchargement

   La majorité des modèles est publique. Pour les modèles gated (Llama, etc.) ou pour publier les tiens, il faut un compte et un token :

   bash Copier

   huggingface-cli login        # colle ton token HF

   Les modèles téléchargés sont mis en cache dans ~/.cache/huggingface/. Tu peux changer l'emplacement avec la variable d'environnement HF_HOME.

7. Fine-tuner un modèle (aperçu)

   Fine-tuner = repartir d'un modèle pré-entraîné et l'adapter à tes données. La Trainer API encapsule la boucle :

   python Copier

   from transformers import Trainer, TrainingArguments
   
   args = TrainingArguments(
       output_dir="./out",
       num_train_epochs=3,
       per_device_train_batch_size=8,
   )
   trainer = Trainer(model=model, args=args,
                     train_dataset=ds["train"],
                     eval_dataset=ds["test"])
   trainer.train()

   Fine-tuner sans GPU ?

   Le fine-tuning de gros modèles demande un GPU. Pour expérimenter sans, vise des petits modèles (DistilBERT, MiniLM) sur des petits datasets (quelques milliers d'exemples). Sinon, Google Colab donne un T4 gratuit.

Aide-mémoire

from transformers import pipeline
pipeline("sentiment-analysis")
pipeline("text-generation", model="gpt2")
pipeline("automatic-speech-recognition", model="openai/whisper-small")
pipeline("image-classification")
pipeline("object-detection")

from transformers import AutoTokenizer, AutoModel
tok = AutoTokenizer.from_pretrained("name")
mdl = AutoModel.from_pretrained("name")
inputs = tok("texte", return_tensors="pt")
outputs = mdl(**inputs)

huggingface-cli login
huggingface-cli download <model-name>
huggingface-cli repo create my-model

Hugging Face et le reste de l'écosystème

• PyTorch — le backend par défaut. Les modèles renvoyés par transformers sont des nn.Module PyTorch standards, manipulables comme n'importe quel modèle.
• scikit-learn — complémentaire : sklearn fait du ML classique tabulaire, HF fait du deep learning multimodal. Pattern courant : utiliser un modèle HF pour générer des embeddings, puis sklearn pour les classer.
• FastAPI — pour exposer un modèle HF comme service web. On charge le pipeline au démarrage de l'app, chaque requête appelle pipeline(...).
• MLflow — sait logger un modèle Hugging Face directement (mlflow.transformers.log_model). Track les hyperparamètres de fine-tuning, reproduit l'expérience plus tard.
• DVC — pour versionner les modèles fine-tunés (souvent > 100 Mo donc trop gros pour Git). Combo classique : git checkout + dvc pull pour retrouver le modèle de la v1.
• Streamlit — créer une démo en quelques lignes au-dessus d'un pipeline HF. C'est aussi le moteur derrière les « Spaces » du Hub (démos publiques gratuites).

Pour aller plus loin

• Site officiel : huggingface.co
• Documentation transformers : huggingface.co/docs/transformers
• Cours gratuit NLP : huggingface.co/learn/nlp-course
• Bibliothèque datasets : huggingface.co/docs/datasets