Démarrez avec Hugging Face

Mise à jour : 08/09/2025

Ce guide pratique vous apprend à utiliser l’écosystème Hugging Face pour faire tourner des modèles LLM open source en local sur CPU, sans nécessiter de carte graphique spécialisée. Vous découvrirez les outils, la configuration de l’environnement et des exemples concrets pour créer votre premier assistant IA local.

Présentation de l’écosystème Hugging Face

Pour faire tourner un LLM en local, il faut pouvoir accéder facilement à un modèle, à ses fichiers, et à un code prêt à l’emploi. C’est précisément ce que fournit Hugging Face, une plateforme et un ensemble d’outils qui facilitent l’usage des modèles d’intelligence artificielle open source, en particulier dans le domaine du traitement automatique du langage naturel (NLP).

Qu’est-ce que Hugging Face ?

Hugging Face est une entreprise française qui propose des outils pour partager, utiliser et entraîner des modèles de machine learning. Elle est surtout connue pour :

le Hugging Face Hub : un catalogue de milliers de modèles d’IA préentraînés et gratuits ;
la bibliothèque Transformers : un ensemble de fonctions Python prêtes à l’emploi pour charger et utiliser ces modèles ;

Exemple de modèle sur le Hub : distilbert-base-uncased ↗

Hugging Face Transformers : la bibliothèque de base

La bibliothèque Transformers permet de manipuler facilement des modèles de type Transformer, comme BERT, GPT, RoBERTa ou LLaMA. Elle fournit des fonctions pour :

Télécharger un modèle depuis le hub avec from_pretrained(...)
Créer un pipeline pour effectuer une tâche comme la génération de texte ou la classification
Convertir les textes en tokens (unités compréhensibles par les modèles)
Exécuter le modèle sur un texte et récupérer les résultats

pip install transformers

Cette commande installe tout ce qu’il faut pour utiliser les modèles. C’est le point de départ de tous les projets LLM avec Hugging Face.

Le Hugging Face Hub : une bibliothèque de modèles

Le Hub est un site Web où l’on peut :

Rechercher des modèles selon leur tâche (résumé, traduction, génération de texte, etc.)
Lire leur documentation
Voir leur compatibilité (CPU, GPU, quantifié, ONNX, etc.)
Télécharger les fichiers nécessaires au fonctionnement

Certains modèles sont très volumineux (plusieurs dizaines de gigaoctets), mais il en existe aussi des versions compactes, quantifiées et spécialement conçues pour tourner sur CPU.

Création d’un compte Hugging Face

Pour accéder à certains modèles hébergés sur le Hugging Face Hub, vous devez vous authentifier auprès de la plateforme. Cela permet de :

Télécharger des modèles privés ou réservés aux utilisateurs enregistrés
Éviter les limites de téléchargement anonymes
Accéder à des modèles sous licence spéciale (ex : Mistral, LLaMA)

Si ce n’est pas déjà fait, créez un compte gratuit sur : https://huggingface.co/join ↗

Une fois connecté :

Allez sur : https://huggingface.co/settings/tokens ↗
Cliquez sur New token
Donnez un nom (ex: cpu-tuto) et sélectionnez le rôle Read
Cliquez sur Generate token
Copiez le token (chaîne commençant par hf_...)

Se connecter via la ligne de commande

Vous pouvez vous authentifier depuis un terminal :

huggingface-cli login

Collez le token lorsqu’il est demandé.

Cette commande crée un fichier de configuration .huggingface/token dans votre dossier utilisateur.

Préparer son environnement pour l’inférence locale

Avant de pouvoir exécuter un LLM (Large Language Model) sur votre machine, vous devez préparer un environnement Python adapté. L’objectif ici est d’installer les bibliothèques nécessaires pour faire tourner un modèle en local, sur CPU, sans passer par des services cloud.

1. Prérequis matériels

Vous n’avez pas besoin d’un ordinateur très puissant. Voici les recommandations de base :

Un PC sous Linux, macOS ou Windows
8 à 16 Go de RAM minimum (plus si possible)
Un processeur moderne (Intel ou AMD, x86_64 ou ARM pour Apple Silicon)
Environ 5 à 10 Go d’espace disque libre pour stocker les modèles téléchargés

2. Préparer un environnement Python

On vous recommande d’utiliser un environnement virtuel pour isoler vos dépendances Python.

python -m venv llm_env
source llm_env/bin/activate  # Sur Windows : llm_env\Scripts\activate

Vous pouvez ensuite installer les bibliothèques nécessaires avec pip.

Installer les bibliothèques essentielles

Voici les bibliothèques de base à installer pour faire tourner un LLM :

pip install transformers torch accelerate

Vérification de l’installation

Vous pouvez vérifier que tout fonctionne en important les modules :

python3

Et entrez dans l’interpréteur Python :

import transformers

Si aucune erreur ne s’affiche, l’environnement est prêt.

Quels modèles choisir pour débuter ?

Le choix du modèle LLM est une étape clé, surtout lorsque l’on travaille en local sur un processeur (CPU). Tous les modèles ne se valent pas : certains sont lourds, d’autres spécialisés pour une tâche précise, et tous ne comprennent pas forcément le français. L’objectif ici est de vous orienter vers des modèles légers, polyvalents, et compatibles avec la langue française, tout en présentant les types de tâches qu’un LLM peut accomplir.

Les principales tâches des LLM

Voici les tâches les plus courantes qu’on peut tester avec un LLM open source :

text-generation : continuer une phrase, rédiger un paragraphe, créer un résumé.
question-answering : extraire une réponse d’un texte fourni.
translation : passer d’une langue à une autre.
text-classification : identifier un sentiment, une catégorie, etc.
summarization : condenser un texte long en un texte court.
text-fill : prédire un mot ou une expression manquante.

Chaque tâche a des modèles spécifiques, entraînés sur des données adaptées.

Critères de choix pour un modèle CPU

Pour débuter sur CPU, privilégiez les modèles :

de petite taille (moins de 1 à 4 milliards de paramètres)
entraînés ou fine-tunés pour le français

Modèles adaptés au français et au CPU

Voici quelques suggestions testées et recommandées :

Modèle	Langue	Tâche	Taille	Avantages
`camembert-base` ↗	Français	Classification, QA	~110M	Léger, basé sur RoBERTa
`bloomz-560m` ↗	Multilingue (fr inclus)	Génération de texte	~560M	Polyvalent, multilingue
`t5-small` ↗ (fine-tuné fr)	Multilingue	Traduction, résumé	~60M	Polyvalent et léger

Vérifier la compatibilité CPU et français

Sur chaque fiche modèle du Hugging Face Hub, vérifiez :

La langue prise en charge dans la section “Languages”
Le type de tâche mentionné (tags comme text-generation, summarization)

Vérifier les formats compatibles

Tous les modèles Hugging Face ne sont pas égaux en termes de format. Voici un résumé :

Format	Description	Avantage pour CPU
PyTorch (par défaut)	Format natif `transformers`, simple à utiliser	Utilisable sans GPU, mais plus lent
ONNX	Modèle exporté au format optimisé ONNX	Exécution plus rapide via `onnxruntime`
GGUF	Format binaire pour moteurs comme `llama.cpp`	Ultra-rapide, support CPU multithread
Quantifié (int8, bfloat16)	Modèle dont les poids sont compressés	Moins de RAM, plus rapide

Dans ce guide, nous allons principalement utiliser le format PyTorch pour la simplicité, mais vous pouvez explorer les autres formats pour des performances accrues.

Cas pratique : créer un mini assistant local

Dans ce chapitre, vous allez créer un assistant textuel local capable de générer une réponse en français avec un modèle LLM open source, prêt à fonctionner efficacement sur un CPU. L’objectif est de montrer chaque étape, de manière claire et accessible, pour que vous puissiez reproduire ce mini assistant chez vous, même sans carte graphique.

Le choix du modèle

Le modèle que nous allons utiliser est LiquidAI/LFM2-1.2B ↗, un modèle pré-entraîné sur des données multilingues, y compris le français. Il est conçu pour être efficace sur des tâches de génération de texte, de complétion et de classification.

Le code de notre assistant

from transformers import AutoModelForCausalLM, AutoTokenizer

# Load model and tokenizer
model_id = "LiquidAI/LFM2-1.2B"
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    device_map="auto",
    torch_dtype="bfloat16",
)
tokenizer = AutoTokenizer.from_pretrained(model_id)

# Generate answer
prompt = "C'est quoi un LLM?"
input_ids = tokenizer.apply_chat_template(
    [{"role": "user", "content": prompt}],
    add_generation_prompt=True,
    return_tensors="pt",
    tokenize=True,
).to(model.device)

output = model.generate(
    input_ids,
    do_sample=True,
    temperature=0.3,
    min_p=0.15,
    repetition_penalty=1.05,
    max_new_tokens=2048,
)

print(tokenizer.decode(output[0], skip_special_tokens=False))

Explication de chaque ligne :

Import des bibliothèques : on importe les classes nécessaires de transformers.
Chargement du modèle et du tokenizer : on utilise from_pretrained pour charger le modèle et le tokenizer depuis Hugging Face.
Préparation du prompt : on crée un prompt simple pour poser une question.
Génération de la réponse : on utilise model.generate pour obtenir une réponse basée sur le prompt.

Exemple de sortie :

<|startoftext|><|im_start|>user
C'est quoi un LLM?<|im_end|>
<|im_start|>assistant
Un LLM, ou Large Language Model en anglais (Modèle de Langage Large), est un type d'intelligence artificielle spécialement conçu pour comprendre et générer du langage humain. Ces modèles sont entraînés sur de vastes quantités de données textuelles provenant de diverses sources, ce qui leur permet d'acquérir une compréhension approfondie des structures linguistiques, des contextes et des nuances du langage naturel.

Voici quelques caractéristiques clés des LLM :

1. **Taille** : Ils sont généralement très grands, avec des milliards voire des trillions de paramètres (les poids ajustables du modèle). Cette taille leur permet de capturer des motifs complexes dans les données.²
2. **Capacités de génération** : Les LLM peuvent produire du texte cohérent et contextuellement pertinent, ce qui les rend utiles pour la rédaction automatique, la traduction, la réponse aux questions, la création de contenu créatif, etc.
3. **Compréhension contextuelle** : Ils peuvent comprendre le contexte d'une conversation ou d'un texte, ce qui améliore leur capacité à répondre de manière appropriée et pertinente.
4. **Apprentissage continu** : Certains LLM peuvent être affinés ou "fine-tuned" pour des tâches spécifiques, ce qui signifie qu'ils peuvent être adaptés à des domaines particuliers comme le médical, juridique ou technique.
5. **Utilisation dans divers domaines** : Les LLM sont utilisés dans des applications telles que les assistants virtuels (comme ChatGPT), les chatbots, les systèmes de recommandation, l'analyse de sentiments, et bien d'autres.

Les LLM représentent une avancée significative dans le domaine de l'IA et ont transformé la façon dont nous interagissons avec le langage numérique. Cependant, ils soulèvent également des questions éthiques et techniques, notamment en termes de biais, de confidentialité et de sécurité.<|im_end|>

En fonction du modèle et de son nombre de paramètres, la réponse peut varier. Le modèle peut générer des réponses plus ou moins longues, et la diversité des réponses peut être ajustée avec les paramètres temperature, top_k et top_p. Par exemple, une température plus basse rendra les réponses plus prévisibles, tandis qu’une température plus élevée les rendra plus créatives et variées.

Vous avez remarqué que le traitement est plutôt lent, mais c’est normal : les modèles LLM sont complexes et nécessitent du temps pour générer des réponses.

Astuces

Par défaut, les modèles sont téléchargés automatiquement. Vous pouvez aussi le faire manuellement pour l’utiliser sans réseau ou hors-ligne.

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("chemin/vers/model", cache_dir="./models/")
tokenizer = AutoTokenizer.from_pretrained("chemin/vers/model", cache_dir="./models/")

Le dossier ./models/ contiendra tous les fichiers (config, tokenizer, poids…). Cela vous permet de charger le modèle sans connexion internet.

Résolution des erreurs fréquentes et bonnes pratiques CPU

L’usage local de LLM peut parfois provoquer des erreurs ou ralentissements. Voici une compilation des problèmes les plus rencontrés, leurs causes, et comment les corriger.

Problème d’authentification Hugging Face

Symptôme :

You are trying to access a gated model. Please authenticate.

Cause : certains modèles comme Mistral, LLaMA ou LLMWare sont restreints et nécessitent un compte Hugging Face connecté.

Solution :

huggingface-cli login

Puis collez votre token d’accès depuis https://huggingface.co/settings/tokens ↗.

Mémoire saturée ou plantage Python

Symptôme : votre script s’arrête sans erreur ou avec Killed, Segmentation fault, OOM.

Cause : modèle trop gros pour votre RAM.

Solutions :

Utiliser une version quantifiée
Limiter les max_new_tokens à 64 ou 128
Tester un modèle plus petit (ex : TinyLlama au lieu de Mistral)
Fermer tous les processus gourmands avant exécution

Glossaire des termes techniques Hugging Face

Plateforme et outils

Hugging Face : Plateforme qui héberge des milliers de modèles d’IA gratuits et open source
Hub : Site web de Hugging Face où sont stockés tous les modèles
Transformers : Bibliothèque Python principale pour utiliser les modèles de Hugging Face
Datasets : Bibliothèque pour gérer et télécharger des jeux de données
Accelerate : Outil pour optimiser l’entraînement et l’inférence sur différents types de hardware

Formats et optimisations

GGUF : Format de fichier optimisé pour faire tourner des LLM rapidement sur CPU
ONNX : Format de fichier qui permet d’optimiser les modèles pour différents types de processeurs
Quantification : Compression du modèle pour qu’il prenne moins de place et soit plus rapide
Pipeline : Interface simplifiée pour utiliser un modèle sans se soucier des détails techniques

Authentification et sécurité

Token : Clé d’authentification pour accéder aux modèles restreints sur Hugging Face
Gated model : Modèle dont l’accès est restreint et nécessite une authentification
Repository : Dossier contenant un modèle et ses fichiers sur le Hub

Conclusion

Vous avez maintenant les bases pour faire tourner un LLM open source en local, sur CPU, avec des outils simples comme Hugging Face. Vous pouvez :

Expérimenter avec différents modèles et tâches
Adapter le code pour créer des assistants personnalisés
Explorer les possibilités offertes par les LLM dans vos projets
Envisager des cas d’usage plus avancés, comme l’intégration dans une application web ou mobile

L’écosystème Hugging Face offre une porte d’entrée accessible pour découvrir l’intelligence artificielle générative et développer vos propres applications.

Ressources associées

Comprendre l’architecture des modèles : Guide LLM
Améliorer les prompts : Prompt engineering
Créer une interface utilisateur : Chainlit
Mettre en place un pipeline RAG : Introduction RAG
Stocker les embeddings : Chroma
Concepts de vectorisation : Bases de données vectorielles
Extraction de données sources : Trafilatura
Parcours complet IA : Formation Python IA

FAQ - Questions Fréquemment Posées

Qu'est-ce que Hugging Face ?

Hugging Face est une entreprise française qui propose une plateforme et des outils open source pour partager, utiliser et entraîner des modèles d'intelligence artificielle, notamment dans le domaine du traitement automatique du langage naturel.

Qu'est-ce que la bibliothèque Transformers ?

Transformers est une bibliothèque Python développée par Hugging Face. Elle permet de télécharger, charger et utiliser facilement des modèles de type Transformer comme BERT, GPT ou LLaMA pour diverses tâches de NLP.

Quels sont les prérequis matériels pour exécuter un LLM en local ?

Il faut un ordinateur sous Linux, macOS ou Windows, avec 8 à 16 Go de RAM, un processeur moderne (Intel ou AMD) et 5 à 10 Go d'espace disque libre.

Quels sont les modèles adaptés au français et à une exécution sur CPU ?

Parmi les modèles adaptés : camembert-base pour la classification, bloomz-560m pour la génération de texte multilingue, et t5-small pour la traduction ou le résumé. Tous sont légers et partiellement ou entièrement compatibles avec le français.

Comment s'authentifier sur Hugging Face pour accéder à certains modèles ?

Il faut créer un compte Hugging Face, générer un token via les paramètres, puis s'authentifier avec la commande `huggingface-cli login` en collant le token.

Comment créer un assistant local avec Hugging Face ?

Il faut charger un modèle adapté (comme LiquidAI/LFM2-1.2B), préparer un prompt, générer une réponse avec `model.generate`, et afficher le texte obtenu via le tokenizer.

Que faire en cas d'erreur de mémoire ou de plantage ?

Essayez un modèle plus petit, utilisez une version quantifiée, réduisez le nombre de tokens générés ou libérez de la RAM en fermant d'autres programmes.

Qu'est-ce qu'un modèle quantifié ?

Un modèle quantifié est un modèle dont les poids ont été compressés (par exemple en int8) pour utiliser moins de mémoire et s'exécuter plus rapidement, particulièrement utile sur CPU.