Hugging Face + Gradio : créez votre première app IA en 15 minutes (sans être développeur)

Vous avez entendu parler de Hugging Face, vous savez que c'est « le GitHub de l'IA », mais vous n'avez jamais osé y toucher. Bonne nouvelle : avec Gradio, vous allez créer votre première application IA en moins de temps qu'il n'en faut pour télécharger un modèle. Et tout ça gratuitement, hébergé en ligne, sans serveur, sans Docker, sans migraine.

Avant de coder : de quoi on parle ?

Hugging Face, c'est quoi exactement ?

Imaginez GitHub. Mais au lieu d'héberger du code, il héberge des modèles d'intelligence artificielle. Des milliers de modèles. Gratuits. Open source. Prêts à l'emploi.

Hugging Face, c'est trois choses :

Le Model Hub — 500 000+ modèles prêts à être téléchargés et utilisés. Traduction, reconnaissance d'image, génération de texte, synthèse vocale... Vous voulez un modèle qui détecte les émotions dans un tweet ? Y en a 200. Un modèle qui transforme un croquis en photo réaliste ? Y en a 50. Un modèle qui résume un PDF de 50 pages en 3 phrases ? Y en a 30.

Les Spaces — un hébergement gratuit pour vos applications. Vous créez une démo, vous la poussez sur Hugging Face, et elle est en ligne. Gratuitement. Avec un CPU. Si vous avez besoin d'un GPU, les options payantes démarrent à 0,40 $/h.

Les Datasets, la communauté, les cours — des jeux de données, des forums, des tutoriels. C'est l'écosystème complet.

Et tout ça est accessible via une API Python en trois lignes :

python

from transformers import pipeline
analyseur = pipeline("sentiment-analysis")
analyseur("Je kiffe ce tutoriel !")
#  [{'label': 'POSITIVE', 'score': 0.9998}]

Oui. Trois lignes. Pour charger un modèle d'IA et l'exécuter.

Gradio, le dernier kilomètre

Un modèle dans un notebook Jupyter, c'est bien pour vous. Mais pour vos utilisateurs, vos collègues, vos clients, c'est inutilisable. Ils ne veulent pas lire du code. Ils veulent une interface. Un champ de texte. Un bouton. Un résultat.

Gradio fait exactement ça. Vous prenez une fonction Python — n'importe laquelle — et Gradio la transforme en interface web.

python

import gradio as gr

def dire_bonjour(nom):
    return f"Bonjour {nom} ! "

gr.Interface(fn=dire_bonjour, inputs="text", outputs="text").launch()

Résultat : une page web avec un champ texte, un bouton, et le résultat qui s'affiche. En 6 lignes de code.

On passe à la pratique

Ce qu'on va construire

Un analyseur d'émotions : vous collez un texte (un tweet, un commentaire, un email), et l'application vous dit s'il est positif, négatif ou neutre — avec un score de confiance.

Pourquoi cet exemple ? Parce qu'il est : - Utile (analyse de commentaires clients, modération de contenu) - Simple (moins de 30 lignes de code) - Gratuit (le modèle tourne gratuitement sur Hugging Face Spaces) - Reproductible (vous pourrez l'adapter à d'autres modèles)

Étape 1 — Installer les outils (2 minutes)

Ouvrez un terminal et créez un dossier propre :

bash

mkdir mon-analyseur-emotions
cd mon-analyseur-emotions
python3 -m venv .venv
source .venv/bin/activate

Installez les deux bibliothèques :

bash

pip install gradio transformers torch

transformers = la bibliothèque Hugging Face qui donne accès aux modèles. gradio = l'interface utilisateur. torch = le moteur de calcul (PyTorch, derrière la plupart des modèles).

Étape 2 — Écrire l'application (5 minutes)

Créez un fichier app.py :

python

import gradio as gr
from transformers import pipeline

# 1. Charger le modèle de Hugging Face (téléchargé une fois, réutilisé ensuite)
analyseur = pipeline(
    "text-classification",
    model="cardiffnlp/twitter-roberta-base-sentiment-latest"
)

# 2. Définir la fonction que Gradio va exposer
def analyser_emotion(texte):
    if not texte.strip():
        return " Écrivez quelque chose !"

    resultat = analyseur(texte)[0]
    label = resultat["label"]
    score = round(resultat["score"] * 100, 1)

    emojis = {
        "positive": "",
        "negative": "",
        "neutral": ""
    }

    return f"{emojis.get(label, '')} **{label.upper()}** — {score}% de confiance"

# 3. Créer l'interface
interface = gr.Interface(
    fn=analyser_emotion,                    # la fonction à appeler
    inputs=gr.Textbox(
        label="Votre texte",
        placeholder="Collez un tweet, un commentaire, un email...",
        lines=4
    ),
    outputs=gr.Markdown(label="Résultat"),
    title=" Analyseur d'émotions",
    description="Collez un texte et découvrez l'émotion dominante. Modèle : RoBERTa fine-tuné sur 124M de tweets.",
    examples=[
        ["J'adore ce nouveau téléphone, il est incroyable !"],
        ["Le service client est nul, j'attends depuis 3 heures."],
        ["Le train part à 14h30 du quai B."]
    ],
    theme="soft"
)

# 4. Lancer l'application
interface.launch()

Étape 3 — Lancer et tester (2 minutes)

bash

python app.py

Ouvrez votre navigateur sur http://127.0.0.1:7860. Vous devriez voir ça :

Un champ de texte
Des exemples déjà pré-remplis (cliquez dessus pour les tester)
Un bouton "Submit"
Le résultat qui s'affiche en dessous

Collez « Je suis tellement heureux d'avoir découvert cet outil ! » → POSITIVE, ~98% de confiance.

Collez « Cette application est une perte de temps monumentale. » → NEGATIVE, ~97% de confiance.

Ça marche. En 15 minutes. Sans serveur, sans base de données, sans JavaScript.

Étape 4 — Publier sur Hugging Face Spaces (5 minutes)

L'application tourne sur votre machine. Mais ce qui est fort, c'est de la partager avec le monde. Gratuitement.

Créez un compte sur huggingface.co/join (gratuit)
Installez Git si ce n'est pas fait : sudo apt install git (Linux) ou téléchargez-le sur git-scm.com
Créez un token : allez dans Settings → Access Tokens → New Token (type : Write)
Dans votre terminal :

bash

git init
git add app.py requirements.txt
git commit -m "Première version : analyseur d'émotions"

Créez un Space : allez sur huggingface.co/new-space
Nom : mon-analyseur-emotions
SDK : Gradio
License : MIT
Cliquez sur "Create Space"

Poussez votre code :

bash

git remote add origin https://huggingface.co/spaces/VOTRE_USERNAME/mon-analyseur-emotions
git push origin main

5 secondes plus tard, votre app est en ligne sur https://huggingface.co/spaces/VOTRE_USERNAME/mon-analyseur-emotions. Partagez le lien. C'est tout.

Pourquoi ce duo est imbattable

	Sans Gradio	Avec Gradio
Interface utilisateur	3 jours de React/HTML/CSS	1 ligne : `gr.Interface(...)`
Hébergement	VPS, Docker, nginx, certificats SSL...	`git push` sur Hugging Face Spaces
Mise à jour du modèle	Re-déployer toute l'app	Changer le `model="..."` dans `app.py`
Partage	Envoyer un notebook Jupyter	Envoyer une URL qui marche sur mobile
Coût	5-50 €/mois (serveur)	0 € (CPU gratuit sur Spaces)

Aller plus loin : 3 idées d'apps à construire ce soir

1. Générateur de noms de startup (15 lignes)

python

import gradio as gr
from transformers import pipeline

gen = pipeline("text-generation", model="gpt2")

def generer_noms(description):
    prompt = f"Génère 5 noms créatifs de startup pour : {description}\n\n1."
    return gen(prompt, max_length=80, num_return_sequences=1)[0]["generated_text"]

gr.Interface(fn=generer_noms, inputs="text", outputs="text",
             title=" Générateur de noms de startup").launch()

2. Résumeur de texte (10 lignes)

python

import gradio as gr
from transformers import pipeline

resumeur = pipeline("summarization", model="facebook/bart-large-cnn")

def resumer(texte):
    return resumeur(texte, max_length=130, min_length=30)[0]["summary_text"]

gr.Interface(fn=resumer, inputs=gr.Textbox(lines=10),
             outputs="text", title=" Résumeur automatique").launch()

3. Traducteur vocal (avec Whisper)

python

import gradio as gr
from transformers import pipeline

transcripteur = pipeline("automatic-speech-recognition", model="openai/whisper-small")

def transcrire(audio):
    return transcripteur(audio)["text"]

gr.Interface(fn=transcrire, inputs=gr.Audio(type="filepath", sources=["microphone"]),
             outputs="text", title=" Dictée vocale").launch()

Ce qu'il faut retenir

Hugging Face, c'est le supermarché des modèles d'IA. Gradio, c'est la caisse automatique : vous prenez ce que vous voulez, et en trois gestes c'est emballé.

Le workflow est toujours le même :

Trouver un modèle sur huggingface.co/models (tapez votre besoin : « sentiment analysis », « image generation », « text summarization »...)
Le charger avec pipeline() (une ligne)
L'envelopper dans gr.Interface() (trois lignes)
Le publier sur Spaces (git push)

Vous n'avez pas besoin d'être ingénieur ML. Vous n'avez pas besoin de GPU. Vous n'avez pas besoin de savoir ce qu'est un transformer ou un mécanisme d'attention. Vous avez juste besoin de savoir ce que vous voulez construire.

Le reste, Hugging Face et Gradio s'en chargent.

Pièges classiques du débutant

Modèle trop gros pour le CPU gratuit : certains modèles (Llama, Falcon, SDXL) nécessitent un GPU. Commencez par des petits modèles (distilbert, gpt2, whisper-tiny) qui tournent sur CPU gratuit.
Premier lancement lent : le modèle est téléchargé la première fois (cache Hugging Face). Les lancements suivants sont instantanés.
`requirements.txt` obligatoire : sur Spaces, Hugging Face lit ce fichier pour installer les dépendances. Si vous l'oubliez, l'app plante.
Nom de modèle exact : cardiffnlp/twitter-roberta-base-sentiment-latest n'est pas cardiffnlp/twitter-roberta-base-sentiment. Copiez-collez depuis le Hub, pas de saisie manuelle.

Sources

Documentation Gradio : https://gradio.app/docs
Documentation Hugging Face Spaces : https://huggingface.co/docs/hub/spaces
Liste des modèles Hugging Face : https://huggingface.co/models
Notebook Colab Gradio Quickstart : https://colab.research.google.com/drive/18Y066JYHc1sIZaFehZCM57KV5bVQvIQk

Idée d'illustration : Un écran d'ordinateur montrant une interface Gradio avec le résultat « POSITIVE 98% », avec en arrière-plan le logo Hugging Face (emoji souriant) et des lignes de code Python flottantes façon Matrix, style néobrutaliste, couleurs #0a0e17 et #e8e4d8.