Maitriser les Modeles HuggingFace - Guide Exhaustif

Auteur : AYI-NEDJIMI | Consultant IA & Cybersecurite

Ce tutoriel couvre en profondeur tout ce que vous devez savoir sur les modeles HuggingFace : recherche, chargement, inference, generation de texte, classification, vision, audio, embeddings, API d'inference, upload et bonnes pratiques.

---

1. Parcourir, Rechercher et Filtrer les Modeles

Le Hub HuggingFace heberge plus de 500 000 modeles. Savoir les trouver efficacement est essentiel.

1.1 Filtres Principaux

1.2 Recherche Programmatique

from huggingface_hub import HfApi

api = HfApi()

# Modeles de generation de texte, tries par popularite
models = api.list_models(
    filter="text-generation",
    sort="downloads",
    direction=-1,
    limit=20
)

for m in models:
    print(f"{m.id:50s} | {m.downloads:>12,} DL | {m.likes:>6} likes")

# Recherche par auteur
meta_models = api.list_models(author="meta-llama", limit=10)
for m in meta_models:
    print(f"  {m.id}")

# Recherche textuelle
results = api.list_models(search="cybersecurity", limit=10)
for m in results:
    print(f"  {m.id}")

Pour un comparatif detaille des meilleurs LLM open-source, consultez : Comparatif LLM Open-Source 2026

---

2. Charger un Modele avec AutoModel et Pipeline

2.1 La Methode Pipeline (Recommandee pour Debuter)

from transformers import pipeline

# Le pipeline detecte automatiquement le modele et le tokenizer
classifier = pipeline("sentiment-analysis")
result = classifier("J'adore HuggingFace, c'est genial !")
print(result)
# [{'label': 'POSITIVE', 'score': 0.9998}]

# Specifier un modele particulier
classifier = pipeline(
    "text-classification",
    model="nlptown/bert-base-multilingual-uncased-sentiment",
    device=0  # GPU 0 (ou -1 pour CPU)
)
results = classifier(["Excellent produit !", "Tres decu, mauvaise qualite."])
for r in results:
    print(f"  {r['label']} ({r['score']:.4f})")

2.2 La Methode AutoModel (Plus de Controle)

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name)

# Tokenization manuelle
inputs = tokenizer("Ce restaurant est fantastique !", return_tensors="pt", padding=True, truncation=True)

# Inference
with torch.no_grad():
    outputs = model(**inputs)
    predictions = torch.softmax(outputs.logits, dim=-1)
    predicted_class = torch.argmax(predictions, dim=-1)

print(f"Classe predite: {predicted_class.item() + 1} etoiles")
print(f"Probabilites: {predictions[0].tolist()}")

2.3 Classes Auto Disponibles

---

3. Generation de Texte (LLM)

3.1 Modeles Populaires

Les principaux LLM disponibles sur le Hub :

• Meta Llama 3.1 (8B, 70B, 405B) - le meilleur open-source
• Mistral / Mixtral - excellent rapport qualite/taille
• Qwen 2.5 - performant en multilingue
• Google Gemma 2 - compact et efficace
• Microsoft Phi-3 - petit mais puissant

3.2 Generation avec Pipeline

from transformers import pipeline

generator = pipeline(
    "text-generation",
    model="microsoft/DialoGPT-medium",
    device=-1  # CPU
)

# Generation simple
output = generator(
    "L'intelligence artificielle en 2026",
    max_new_tokens=200,
    temperature=0.7,
    top_p=0.9,
    do_sample=True,
    num_return_sequences=1
)
print(output[0]['generated_text'])

3.3 Generation avec AutoModelForCausalLM

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_name = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# Parametres de generation avances
input_text = "Cybersecurity in the age of AI"
inputs = tokenizer(input_text, return_tensors="pt")

outputs = model.generate(
    **inputs,
    max_new_tokens=150,
    temperature=0.8,        # Creativite (0=deterministe, 1=creatif)
    top_k=50,               # Top-K sampling
    top_p=0.95,             # Nucleus sampling
    repetition_penalty=1.2, # Penalite de repetition
    do_sample=True,
    pad_token_id=tokenizer.eos_token_id
)

result = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(result)

3.4 Chat Templates (Modeles Conversationnels)

from transformers import AutoTokenizer, AutoModelForCausalLM

model_name = "microsoft/DialoGPT-small"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# Conversation multi-tours
conversation_history = []
for question in ["Hello!", "How are you?", "What is AI?"]:
    input_ids = tokenizer.encode(question + tokenizer.eos_token, return_tensors='pt')
    bot_output = model.generate(input_ids, max_length=1000, pad_token_id=tokenizer.eos_token_id)
    response = tokenizer.decode(bot_output[:, input_ids.shape[-1]:][0], skip_special_tokens=True)
    print(f"User: {question}")
    print(f"Bot: {response}")

---

4. Classification de Texte

from transformers import pipeline

# Analyse de sentiment
sentiment = pipeline("sentiment-analysis", model="cardiffnlp/twitter-roberta-base-sentiment-latest")
results = sentiment([
    "I love this new AI tool!",
    "This is terrible, worst experience ever.",
    "The weather is okay today."
])
for r in results:
    print(f"  {r['label']:10s} ({r['score']:.4f})")

# Classification zero-shot (sans entrainement specifique)
classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
result = classifier(
    "La nouvelle mise a jour de securite corrige une vulnerabilite critique",
    candidate_labels=["cybersecurite", "developpement", "marketing", "finance"]
)
for label, score in zip(result['labels'], result['scores']):
    print(f"  {label:20s}: {score:.4f}")

---

5. Reconnaissance d'Entites Nommees (NER)

from transformers import pipeline

ner = pipeline("ner", model="Jean-Baptiste/camembert-ner", aggregation_strategy="simple")
text = "Emmanuel Macron a visite le siege de HuggingFace a Paris le 15 janvier 2026."
entities = ner(text)

for entity in entities:
    print(f"  {entity['entity_group']:5s} | {entity['word']:25s} | score: {entity['score']:.4f}")

---

6. Resume de Texte

from transformers import pipeline

summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
text = (
    "HuggingFace is a technology company that develops tools for building applications "
    "using machine learning. The company is most notable for its Transformers library "
    "built for natural language processing applications and its platform that allows "
    "users to share machine learning models and datasets. Founded in 2016, the company "
    "has grown to become one of the most important players in the AI ecosystem, with "
    "over 500,000 models hosted on its platform."
)

summary = summarizer(text, max_length=80, min_length=20, do_sample=False)
print(summary[0]['summary_text'])

---

7. Vision par Ordinateur

7.1 Classification d'Images

from transformers import pipeline

classifier = pipeline("image-classification", model="google/vit-base-patch16-224")
result = classifier("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg")
for r in result[:3]:
    print(f"  {r['label']:30s}: {r['score']:.4f}")

7.2 Detection d'Objets

from transformers import pipeline

detector = pipeline("object-detection", model="facebook/detr-resnet-50")
result = detector("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg")
for obj in result:
    print(f"  {obj['label']:15s} (score: {obj['score']:.4f}) | box: {obj['box']}")

---

8. Audio et Parole

8.1 Reconnaissance Vocale (ASR)

from transformers import pipeline

asr = pipeline("automatic-speech-recognition", model="openai/whisper-base")
result = asr("audio_sample.wav")  # Ou URL audio
print(result['text'])

# Whisper supporte 99+ langues
asr_fr = pipeline("automatic-speech-recognition", model="openai/whisper-large-v3")
# result = asr_fr("audio_francais.wav", generate_kwargs={"language": "french"})

8.2 Synthese Vocale (TTS)

from transformers import pipeline

tts = pipeline("text-to-speech", model="microsoft/speecht5_tts")
# audio = tts("Bonjour, bienvenue sur HuggingFace !")
# Sauvegarder avec scipy ou soundfile

---

9. Embeddings et Sentence-Transformers

Les embeddings sont essentiels pour le RAG (Retrieval-Augmented Generation) et la recherche semantique.

Pour en savoir plus sur le RAG, consultez : Guide RAG - Retrieval Augmented Generation

from transformers import AutoTokenizer, AutoModel
import torch

# Charger un modele d'embeddings
model_name = "sentence-transformers/all-MiniLM-L6-v2"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name)

def get_embedding(text):
    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
    with torch.no_grad():
        outputs = model(**inputs)
    # Mean pooling
    attention_mask = inputs['attention_mask']
    token_embeddings = outputs.last_hidden_state
    input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
    embedding = torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
    return embedding[0]

# Calculer la similarite
emb1 = get_embedding("La cybersecurite est importante")
emb2 = get_embedding("La protection informatique est essentielle")
emb3 = get_embedding("J'aime la cuisine italienne")

sim_12 = torch.cosine_similarity(emb1.unsqueeze(0), emb2.unsqueeze(0))
sim_13 = torch.cosine_similarity(emb1.unsqueeze(0), emb3.unsqueeze(0))

print(f"Similarite (cybersec/protection): {sim_12.item():.4f}")  # Elevee
print(f"Similarite (cybersec/cuisine):    {sim_13.item():.4f}")  # Faible

---

10. Inference API (Tier Gratuit)

L'Inference API permet d'utiliser des modeles sans les telecharger :

import requests

API_URL = "https://api-inference.huggingface.co/models/gpt2"
headers = {"Authorization": "Bearer hf_votre_token"}

def query(payload):
    response = requests.post(API_URL, headers=headers, json=payload)
    return response.json()

result = query({"inputs": "The future of cybersecurity is"})
print(result)

# Fonctionne pour tous les types de modeles :
# - text-generation
# - text-classification
# - image-classification
# - automatic-speech-recognition
# - etc.

Limites du Tier Gratuit

• Rate limiting (quelques requetes/minute)
• Modeles charges a la demande (cold start)
• Pas de GPU dedie
• Timeout sur les gros modeles

---

11. Inference Endpoints (Production)

Pour la production, les Inference Endpoints offrent :

• GPU dedie : T4, L4, A10G, A100
• Auto-scaling : 0 a N replicas
• SLA : 99.9% de disponibilite
• Securite : VPC, authentification
• Monitoring : metriques temps reel

from huggingface_hub import InferenceClient

client = InferenceClient(
    model="meta-llama/Meta-Llama-3.1-8B-Instruct",
    token="hf_votre_token"
)

# Generation de texte
response = client.text_generation(
    "Explain cybersecurity best practices:",
    max_new_tokens=200,
    temperature=0.7
)
print(response)

# Chat
response = client.chat_completion(
    messages=[
        {"role": "system", "content": "You are a cybersecurity expert."},
        {"role": "user", "content": "What is a zero-day vulnerability?"}
    ],
    max_tokens=300
)
print(response.choices[0].message.content)

---

12. Model Cards - Bonnes Pratiques

Une bonne model card est essentielle pour la transparence :

---
language: fr
license: mit
pipeline_tag: text-classification
tags:
  - cybersecurity
  - french
  - bert
datasets:
  - mon-dataset-cybersec
metrics:
  - accuracy
  - f1
model-index:
  - name: mon-modele-cybersec
    results:
      - task:
          type: text-classification
        metrics:
          - name: Accuracy
            type: accuracy
            value: 0.95
---

# Mon Modele Cybersec

## Description
Ce modele classifie les textes de cybersecurite en categories.

## Utilisation
(exemples de code)

## Entrainement
(details du dataset, hyperparametres)

## Limitations
(biais connus, cas limites)

---

13. Uploader son Propre Modele

from huggingface_hub import HfApi

api = HfApi(token="hf_votre_token")

# Methode 1 : push_to_hub depuis transformers
# model.push_to_hub("mon-username/mon-modele")
# tokenizer.push_to_hub("mon-username/mon-modele")

# Methode 2 : upload_folder
api.upload_folder(
    folder_path="./mon_modele",
    repo_id="mon-username/mon-modele",
    repo_type="model"
)

# Methode 3 : upload_file
api.upload_file(
    path_or_fileobj="./model.safetensors",
    path_in_repo="model.safetensors",
    repo_id="mon-username/mon-modele",
    repo_type="model"
)

---

Conclusion

Les modeles HuggingFace couvrent toutes les taches d'IA imaginables. Que vous ayez besoin de generation de texte, classification, NER, vision, audio ou embeddings, le Hub a le modele qu'il vous faut. La cle est de bien choisir son modele en fonction de la tache, de la langue et des contraintes de deploiement.

Explorez notre collection CyberSec AI : CyberSec AI Portfolio

---

Tutoriel redige par AYI-NEDJIMI - Consultant IA & Cybersecurite