Introduction aux LLM avec Hugging Face

Ce guide s’adresse à tous ceux qui souhaitent découvrir les LLM (Large Language Models) et expérimenter leur utilisation en local, sur CPU, sans nécessiter de carte graphique spécialisée. L’objectif est d’apprendre à manipuler ces modèles open source avec des outils simples comme Hugging Face Transformers, de comprendre leur fonctionnement et de poser les bases d’un usage plus avancé, jusqu’à une éventuelle mise en production. Que ce soit pour générer du texte, résumer un article ou répondre à une question, tout se fait depuis votre poste, avec des exemples concrets et commentés.

Comprendre ce qu’est un LLM et pourquoi l’utiliser localement

Un LLM, ou Large Language Model (grand modèle de langage), est un programme capable de comprendre et de générer du texte de manière cohérente, en s’appuyant sur des milliards de phrases apprises durant son entraînement. Ces modèles sont à la base d’applications comme ChatGPT, Bard, ou des outils de traduction automatique, de résumé, ou de réponse à des questions.

Comment fonctionne un LLM ?

Un LLM transforme un texte d’entrée (le prompt) en une suite de mots logiques. Pour cela, il s’appuie sur une architecture appelée Transformer, introduite par Google en 2017. Cette architecture permet au modèle d’analyser des relations complexes entre les mots, peu importe leur position dans la phrase.

Exemples d’applications concrètes

• Générer des articles ou des descriptions de produits
• Créer des assistants conversationnels
• Répondre automatiquement à des mails
• Résumer des documents
• Traduire du texte d’une langue à une autre

Pourquoi exécuter un LLM en local ?

• Apprentissage personnel : Faire tourner un LLM localement permet de comprendre concrètement comment il fonctionne, en manipulant son code, ses paramètres, ses limites. C’est un excellent point de départ pour toute personne souhaitant se former en IA, traitement du langage naturel (NLP) ou DevOps/ML Ops.
• Respect de la vie privée : En local, les données que vous traitez ne quittent jamais votre ordinateur. C’est un atout majeur pour la confidentialité, notamment dans les entreprises ou pour des documents sensibles.
• Autonomie technique : Pas besoin de dépendre d’un service cloud ou d’API payantes. Vous êtes libre de choisir votre modèle, de le modifier, de le redéployer. Même avec un simple ordinateur portable, vous pouvez tester de petits modèles et obtenir des résultats impressionnants.
• Coût réduit : Pas besoin d’investir dans une carte graphique haut de gamme. Des optimisations permettent de faire tourner certains LLM directement sur CPU, avec des performances acceptables pour l’apprentissage ou de petits cas d’usage.

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 :

1. Import des bibliothèques : on importe les classes nécessaires de transformers.
2. Chargement du modèle et du tokenizer : on utilise from_pretrained pour charger le modèle et le tokenizer depuis Hugging Face.
3. Préparation du prompt : on crée un prompt simple pour poser une question.
4. 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

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

Dans le prochain guide, nous verrons comment aller plus loin en exposant notre modèle via une API REST avec FastChat.