Aller au contenu
    MODELS
    Guide IA · Série Hugging Face 2/3

    Le Hub de modèles : naviguer, tester, télécharger

    Plus de 3 millions de modèles sont disponibles sur le Hub Hugging Face. Face à cette masse, la plupart des utilisateurs tombent sur les mêmes grands noms et passent à côté de modèles spécialisés, souvent mieux adaptés à leur besoin. Ce guide vous apprend à filtrer le catalogue, à lire une model card, à distinguer safetensors et GGUF, à tester un modèle dans le navigateur et à le récupérer sur votre machine.

    Ouvrez huggingface.co/models et regardez la liste défiler. Vous y verrez des modèles de langage, des traducteurs, des modèles d’embeddings, des générateurs d’images, des outils de transcription, des modèles de vision, des versions compressées et des variantes créées par la communauté. Les modèles les plus téléchargés attirent naturellement l’œil, alors que la meilleure réponse à votre besoin se cache souvent plus loin dans la liste.

    Savoir naviguer dans le Hub revient donc à trouver le modèle qui correspond à votre tâche, à votre matériel et à votre contrainte de licence, sans vous laisser guider par la seule popularité. Vous apprendrez aussi à juger vite si un modèle mérite d’être testé, téléchargé ou écarté. Si vous découvrez Hugging Face, le premier volet de la série, Hugging Face décrypté, présente la plateforme, et le guide pour débuter vous fait faire vos premiers tests sans coder.

    Chercher avec les filtres plutôt qu’avec les téléchargements

    L’interface du Hub propose deux façons de chercher. La barre en haut de page lance une recherche sur les noms de modèles, ce qui sert surtout quand vous savez déjà ce que vous voulez. Pour explorer, mieux vaut passer par la colonne de filtres de la page huggingface.co/models.

    Cette colonne classe les modèles par tâche, bibliothèque, langue, licence et fournisseur d’inférence. Chaque filtre affine la liste en temps réel, et la tâche reste le meilleur point de départ.

    Filtrer par tâche

    Les tâches regroupent les modèles selon ce qu’ils font. Voici les principales pour un utilisateur francophone :

    • Text Generation — Cette catégorie réunit les LLM génératifs, comme Llama, Mistral, Qwen, DeepSeek, Gemma ou gpt-oss. C’est là que se joue la bataille des modèles conversationnels.
    • Text Classification — Ces modèles classent un texte : spam ou non, avis positif ou négatif, catégorie d’un ticket de support. Ils sont bien plus légers qu’un LLM généraliste.
    • Translation — Les modèles de traduction spécialisés, comme NLLB ou ceux de Helsinki-NLP, couvrent de nombreuses paires de langues.
    • Automatic Speech Recognition — On y trouve les modèles de transcription. Whisper reste une référence, et Voxtral de Mistral AI s’y est ajouté, tandis que les variantes allégées conviennent mieux au temps réel.
    • Text-to-Image — Les générateurs d’images, comme FLUX, Stable Diffusion ou Qwen-Image, se trouvent ici. Leur licence doit toujours être vérifiée avant un usage commercial.
    • Feature Extraction — Ces modèles d’embeddings servent à la recherche sémantique et au RAG. BGE, E5 ou Sentence-Transformers en font partie.

    Quand plusieurs tâches collent à votre besoin, testez d’abord la solution la plus souple. Un LLM de la catégorie Text Generation, bien guidé par un prompt, fait parfois mieux qu’un modèle de classification mal entraîné. Pour un traitement à gros volume, un petit modèle spécialisé reste en revanche bien plus économique qu’un LLM massif.

    Filtrer par bibliothèque et par licence

    Le filtre Libraries n’affiche que les modèles compatibles avec votre environnement. Choisissez Transformers pour travailler en Python, MLX pour un Mac équipé d’une puce Apple, ONNX pour un déploiement hors Python et GGUF pour faire tourner un modèle en local avec llama.cpp, Ollama ou LM Studio.

    Le filtre Licenses est souvent négligé, à tort. Un modèle sous licence non commerciale ne peut pas équiper votre produit, quelle que soit sa qualité. Pour un usage commercial, les licences permissives Apache 2.0 et MIT sont les plus simples. D’autres licences, comme celles de Llama ou de Gemma, autorisent l’usage commercial mais imposent leurs propres conditions. Dans le doute, lisez le texte complet avant toute intégration professionnelle.

    Lire une model card en 30 secondes

    Chaque page de modèle s’ouvre sur sa model card, l’équivalent d’un mode d’emploi pour un modèle d’IA. Une bonne fiche répond à sept questions.

    01
    Quelle est l’architecture ?

    Un LLM génératif repose sur un Transformer décodeur, beaucoup de modèles de classification sur un encodeur, et les générateurs d’images sur la diffusion. Les modèles MoE (mixture of experts) n’activent qu’une partie de leurs paramètres à chaque calcul. L’architecture donne une première idée de l’usage et de la consommation.

    02
    Combien de paramètres ?

    La taille va de quelques centaines de millions à plusieurs centaines de milliards de paramètres (on lit 4B, 24B, 70B). Plus le modèle est grand, plus il demande de mémoire et de calcul. La quantification réduit fortement ces besoins, au prix d’une légère perte de qualité.

    03
    Sur quelles données a-t-il été entraîné ?

    Les sources possibles sont nombreuses : web public, code, livres, dialogues synthétiques, données multilingues ou corpus spécialisés. Un modèle qui documente clairement ses données inspire plus confiance qu’un dépôt muet.

    04
    Quels benchmarks ?

    Les LLM récents publient surtout leurs scores sur MMLU-Pro, GPQA, LiveCodeBench ou SWE-bench, et les modèles audio ou de traduction ont leurs propres tests. Les scores ne disent pas tout, mais ils écartent vite les modèles trop faibles ou mal documentés.

    05
    Quelle licence et quelles restrictions ?

    La licence apparaît dans les métadonnées, en haut de la page. Cliquez dessus pour lire le texte complet avant tout usage commercial ou toute intégration dans un produit client.

    06
    Quand a-t-il été mis à jour ?

    La date figure dans l’onglet « Files and versions ». Un modèle abandonné depuis longtemps a probablement été dépassé par une version plus récente ou mieux entretenue.

    07
    Qui le publie ?

    Les organisations reconnues ou vérifiées rassurent davantage pour un usage professionnel. Les contributeurs individuels produisent parfois d’excellentes variantes, mais leurs fichiers, leur licence et leur documentation demandent plus de vigilance.

    Les modèles « gated » demandent un accès

    Certains modèles affichent un bandeau qui vous demande d’accepter une licence ou de partager quelques informations avant l’accès. Lisez la licence, puis remplissez le formulaire si nécessaire. Sans cette étape, un téléchargement par Transformers ou par la ligne de commande renvoie une erreur d’accès, même avec un jeton valide.

    Tester un modèle dans le navigateur avant de le télécharger

    Télécharger plusieurs gigaoctets pour découvrir que le modèle ne fait pas ce que vous espériez fait perdre du temps. Hugging Face propose plusieurs moyens de tester avant.

    Le widget d’inférence de la model card

    Beaucoup de model cards affichent une zone de test à droite de la page. Vous saisissez un texte, une image ou un son selon la tâche, et le modèle répond dans le navigateur. Cette vérification rapide suffit souvent à écarter un candidat.

    Ce widget passe par les Inference Providers, des fournisseurs partenaires qui hébergent les modèles et que Hugging Face facture pour vous. Chaque test consomme une petite part de vos crédits mensuels : 0,10 dollar sur un compte gratuit, 2 dollars avec l’abonnement PRO. Le même système sert ensuite si vous appelez le modèle par API, sans gérer de serveur.

    Les Spaces de démonstration

    Beaucoup de modèles connus ont un ou plusieurs Spaces associés, listés sur leur page. Un Space est une petite application web, souvent construite avec Gradio, qui offre une utilisation plus riche : envoi d’image, réglages avancés, comparaison côte à côte ou interface de chat complète. Beaucoup tournent sur ZeroGPU, qui prête gratuitement une carte graphique dans la limite d’un quota quotidien de quelques minutes.

    HuggingChat et le playground

    Pour les modèles conversationnels, HuggingChat permet de discuter avec plus d’une centaine de modèles ouverts. Relancé en octobre 2025, il choisit par défaut le modèle à votre place grâce à un routeur baptisé Omni, mais vous pouvez aussi en sélectionner un vous-même pour comparer deux modèles sur la même question. Le service demande une connexion et consomme vos crédits d’inférence.

    Les formats de modèles, expliqués pour choisir

    Un même modèle existe souvent en plusieurs formats de fichiers, et chacun répond à un usage précis.

    Format Extension Cas d’usage principal Outils compatibles
    Safetensors .safetensors Usage en Python, ajustement d’un modèle, chargement sécurisé Transformers, Diffusers, PyTorch, vLLM
    GGUF .gguf Utilisation locale sur processeur ou carte graphique grand public, avec quantification llama.cpp, Ollama, LM Studio, Jan
    ONNX .onnx Déploiement hors Python, appareils embarqués, environnements variés ONNX Runtime, TensorRT, OpenVINO
    MLX .safetensors au format MLX Utilisation optimisée sur Mac équipé d’une puce Apple mlx-lm, LM Studio
    PyTorch ancien format .bin / .pt / .pth Anciens modèles ou usages particuliers, à éviter quand la source n’est pas vérifiée PyTorch

    Pourquoi safetensors a remplacé les fichiers .bin

    Jusqu’en 2023, beaucoup de modèles PyTorch étaient enregistrés avec pickle, un mécanisme Python qui peut exécuter du code au chargement. Un fichier piégé peut donc lancer un programme malveillant sur votre machine. Hugging Face analyse les fichiers déposés et signale les imports suspects sur la page du dépôt, tout en prévenant que ce contrôle n’est pas infaillible.

    Le format safetensors a été conçu pour supprimer ce risque. Il stocke uniquement les poids du modèle, sans code exécutable, et il charge aussi plus vite les gros modèles. Pour un usage professionnel, privilégiez les dépôts documentés, les éditeurs fiables et ce format quand il est proposé.

    GGUF, le format de l’IA locale

    GGUF est devenu le format de référence pour faire tourner des modèles compressés avec llama.cpp et les outils qui s’appuient dessus. Un seul fichier regroupe les poids, le tokenizer et les informations nécessaires à l’exécution. Son principal atout tient à la quantification, qui compresse les poids pour réduire la mémoire nécessaire.

    Un modèle en pleine précision peut demander beaucoup de mémoire, alors que sa version GGUF quantifiée tient sur un ordinateur grand public, avec une qualité à peine inférieure. Le nom du fichier indique le niveau de compression : Q4_K_M offre un bon équilibre, Q8_0 reste plus fidèle mais pèse presque deux fois plus lourd. Des comptes comme unsloth ou bartowski publient des versions GGUF des principaux modèles peu après leur sortie.

    La règle pratique est simple. Pour ajuster ou entraîner un modèle, partez du format safetensors. Pour faire tourner un modèle sur votre machine sans serveur, cherchez d’abord une version GGUF.

    Télécharger un modèle : les trois méthodes

    Méthode 1 : le téléchargement dans le navigateur

    Sur la page du modèle, ouvrez l’onglet Files and versions. Vous pouvez y télécharger un fichier précis, comme config.json, tokenizer.json, model.safetensors ou un fichier .gguf. Cette méthode convient pour un test ponctuel, beaucoup moins pour un gros modèle découpé en plusieurs fichiers.

    Méthode 2 : la ligne de commande hf

    L’outil officiel en ligne de commande télécharge proprement un modèle, un fichier ou un dépôt complet.

    # Installation et authentification
    
    pip install -U huggingface_hub
    hf auth login
    
    # Téléchargement d'un modèle complet
    hf download Qwen/Qwen3-4B-Instruct-2507
    
    # Téléchargement d'un seul fichier
    hf download unsloth/Qwen3-4B-Instruct-2507-GGUF Qwen3-4B-Instruct-2507-Q4_K_M.gguf
    
    # Téléchargement dans un dossier précis
    hf download mistralai/Mistral-Small-3.2-24B-Instruct-2506 \
      --local-dir ./models/mistral-small

    Par défaut, le modèle est rangé dans le cache Hugging Face, partagé entre vos projets Python pour éviter les doublons. L’option --local-dir impose un autre emplacement.

    Méthode 3 : le chargement direct depuis Python

    C’est la méthode la plus courante pour un développeur. La bibliothèque Transformers télécharge le modèle à la première utilisation, puis le garde en cache.

    # Chargement d'un LLM en quelques lignes
    
    from transformers import pipeline
    
    chat = pipeline(
        "text-generation",
        model="Qwen/Qwen3-4B-Instruct-2507",
        dtype="auto",
        device_map="auto"
    )
    
    # Génération
    messages = [{"role": "user", "content": "Bonjour, peux-tu te présenter ?"}]
    resultat = chat(messages, max_new_tokens=200)
    print(resultat[0]["generated_text"][-1]["content"])

    Depuis la version 5 de Transformers, sortie en décembre 2025, la bibliothèque fonctionne uniquement avec PyTorch, et le paramètre dtype remplace l’ancien torch_dtype. Pour un modèle gated, authentifiez-vous d’abord avec hf auth login et un jeton personnel créé sur huggingface.co/settings/tokens. Un jeton en lecture seule suffit pour télécharger.

    Pour l’IA locale : Ollama et les applications locales

    Ollama lance directement un modèle GGUF hébergé sur Hugging Face grâce à la syntaxe hf.co, sans créer de fichier de configuration. Sans précision, Ollama choisit la version Q4_K_M quand elle existe.

    # Syntaxe directe Hugging Face
    
    ollama run hf.co/unsloth/Qwen3-4B-Instruct-2507-GGUF
    
    # Avec un niveau de quantification précis
    ollama run hf.co/unsloth/Mistral-Small-3.2-24B-Instruct-2506-GGUF:Q4_K_M

    Le bouton Use this model de chaque page propose aussi les applications locales compatibles, comme llama.cpp, Ollama, LM Studio ou Jan, avec la commande prête à copier. Activez-les dans les réglages de votre compte, rubrique Local Apps. Vous repérez ainsi un modèle sur le Hub, vous copiez la commande, puis vous le lancez sur votre machine si elle a assez de mémoire. Notre guide pour installer Qwen en local avec Ollama et LM Studio détaille cette démarche pas à pas.

    La méthode pour trouver le bon modèle en cinq minutes

    Étape 01
    Définir la tâche

    Choisissez la tâche dans le filtre Tasks : génération de texte, classification, traduction, transcription ou embeddings. Cherchez ce que le modèle doit faire avant de regarder son architecture.

    Étape 02
    Filtrer par contraintes

    Ajoutez une licence compatible avec votre usage, la langue voulue et une taille adaptée à votre matériel, puis triez par date. Trois filtres cumulés suffisent souvent.

    Étape 03
    Tester, lire, décider

    Testez deux ou trois candidats dans le widget ou un Space, puis lisez leur model card. Décidez sur votre cas réel plutôt que sur les benchmarks ou les téléchargements.

    Ce que vous saurez faire après cet article

    Vous ne tapez plus une requête vague en espérant tomber sur le bon modèle. Vous ouvrez huggingface.co/models, vous filtrez par tâche et par licence, puis vous comparez plusieurs candidats dans le widget d’inférence ou dans un Space. Vous lisez ensuite la model card du meilleur, et vous téléchargez le format adapté à votre cas : safetensors pour Python, GGUF pour Ollama, ONNX pour certains déploiements.

    Pour la plupart des besoins courants, comme un assistant conversationnel en français, un classement de tickets, une traduction ou des embeddings pour un RAG, cette méthode suffit à trouver en quelques minutes un modèle adapté à votre matériel. Le dernier volet de la série s’attaque à l’autre grande colonne du Hub, les datasets : comment explorer les jeux de données disponibles, préparer les vôtres pour ajuster un modèle et les charger dans vos scripts Python.

    Article suivant
    Datasets Hugging Face

    Trouvez les bons jeux de données, chargez-les en Python, préparez vos fichiers JSONL et publiez-les sur le Hub.

    Comprendre les Datasets ↗
    Mise à jour : 23 septembre 2026

    Étiquettes: