Commit initial

.gitignore

@@ -0,0 +1,5 @@
+/venv
+/models
+push_models.py
+hf_login.py
+/scripts/__pycache__

app.py

@@ -0,0 +1,74 @@
+import gradio as gr
+import pandas as pd
+from scripts.inference import (
+    zero_shot_inference,
+    few_shot_inference,
+    base_model_inference,
+    fine_tuned_inference
+)
+
+def predict_with_model(text, model_type):
+    """
+    Applique la stratégie de classification sélectionnée sur un texte donné
+    et retourne la catégorie prédite avec les scores de confiance.
+
+    Args:
+        text (str): Le texte à analyser (actualité).
+        model_type (str): Le type de modèle sélectionné ("Zero-shot", "Few-shot", etc.).
+
+    Returns:
+        tuple:
+            - str: Catégorie prédite.
+            - pandas.DataFrame: Tableau des scores de confiance par classe.
+    """
+
+    #Sélection du modèle d'inférence en fonction du choix utilisateur
+    if model_type == "Zero-shot":
+        prediction, scores = zero_shot_inference(text)
+    elif model_type == "Few-shot":
+        prediction, scores = few_shot_inference(text)
+    elif model_type == "Fine-tuned":
+        prediction, scores = fine_tuned_inference(text)
+    elif model_type == "Base model":
+        prediction, scores = base_model_inference(text)
+    else:
+        return "Modèle inconnu", pd.DataFrame()
+
+    #Convertit les scores (dict) en DataFrame pour affichage dans Gradio
+    scores_df = pd.DataFrame([
+        {"Classe": label, "Score": score} for label, score in scores.items()
+    ])
+
+    return prediction, scores_df
+
+#Définition de l'interface utilisateur avec Gradio
+iface = gr.Interface(
+    fn=predict_with_model,  #Fonction appelée au clic de l'utilisateur
+    inputs=[
+        gr.Textbox(
+            lines=4,
+            placeholder="Entrez une phrase d'actualité ici...",
+            label="Texte à classifier"
+        ),
+        gr.Radio(
+            choices=["Base model", "Zero-shot", "Few-shot", "Fine-tuned"],
+            label="Choisir le modèle",
+            value="Base model"                  #Valeur par défaut
+        )
+    ],
+    outputs=[
+        gr.Label(label="Catégorie prédite"),    #Affiche la prédiction principale
+        gr.BarPlot(                             #Affiche les scores de confiance
+            label="Scores de confiance",
+            x="Classe",
+            y="Score",
+            color="Classe"
+        )
+    ],
+    title="Classification AG News (4 stratégies)",
+    description="Comparer un modèle préentraîné, Zero-shot, Few-shot et Fine-tuned sur AG News"
+)
+
+#Lancement de l'application
+if __name__ == "__main__":
+    iface.launch()

push_model.py

@@ -0,0 +1,12 @@
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+
+model_path = "models/fine_tuned_model"  # Chemin vers ton modèle fine-tuné
+repo_name = "agnews-finetuned-bert"     # Nom public sur Hugging Face
+
+# Charger le modèle et le tokenizer
+model = AutoModelForSequenceClassification.from_pretrained(model_path)
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+
+# Uploader
+model.push_to_hub(repo_name)
+tokenizer.push_to_hub(repo_name)

readme.md

@@ -0,0 +1,77 @@
+# 📰 AG News Text Classification Demo
+
+Ce projet présente une application de classification de textes d’actualité basée sur le dataset **AG News**.  
+L'objectif est de comparer plusieurs stratégies d'inférence de modèles Transformers pour la classification de texte.
+
+---
+
+## 🚀 Démo en ligne
+
+L’application est disponible ici :  
+[**Lien vers la démo Hugging Face Space**](https://huggingface.co/spaces/TON_UTILISATEUR/TON_ESPACE) *(à remplacer par ton lien)*
+
+---
+
+## 📂 Organisation du projet
+
+- `app.py` : interface Gradio avec deux onglets (`Demo` + `Documentation`)
+- `scripts/inference.py` : fonctions d’inférence pour 4 types de modèles
+- `scripts/train.py` : script d’entraînement du modèle BERT fine-tuné sur AG News
+- `scripts/utils.py` : calcul des métriques d’évaluation (accuracy, F1, etc.)
+- `requirements.txt` : liste des dépendances Python
+
+---
+
+## 🧠 Description des modèles utilisés
+
+1. **Base model**  
+   Modèle BERT préentraîné `textattack/bert-base-uncased-ag-news` utilisé directement sans fine-tuning.
+
+2. **Zero-shot**  
+   Modèle `facebook/bart-large-mnli` utilisé pour classification zero-shot via pipeline Hugging Face.
+
+3. **Few-shot**  
+   Approche zero-shot avec exemples dans le prompt (prompt engineering).
+
+4. **Fine-tuned model**  
+   Modèle BERT `bert-base-uncased` entraîné sur un sous-ensemble équilibré du dataset AG News (3000 exemples par classe), sauvegardé sur Hugging Face Hub sous `Merwan611/agnews-finetuned-bert`.
+
+---
+
+## 📊 Données et entraînement
+
+- **Dataset** : AG News (4 classes : World, Sports, Business, Sci/Tech)
+- **Préprocessing** : tokenisation avec `AutoTokenizer` BERT
+- **Entraînement** : 3 epochs, batch size 32, métrique optimisée : accuracy
+- **Sous-échantillonnage** pour accélérer l’entraînement : 3000 exemples par classe pour le train, 1000 par classe pour le test
+
+---
+
+## 📈 Performances
+
+Les métriques calculées sont :  
+- Accuracy  
+- Precision (moyenne pondérée)  
+- Recall (moyenne pondérée)  
+- F1-score (moyenne pondérée)
+
+Le modèle fine-tuné atteint généralement une meilleure précision que le modèle de base ou les approches zero-shot.
+
+---
+
+## ⚙️ Lancer l’application localement
+
+1. Cloner le repo  
+2. Créer un environnement virtuel Python  
+3. Installer les dépendances :  
+   ```bash
+   pip install -r requirements.txt
+4. Lancer l'application python app.py
+
+## ✍️ Auteur
+Réalisé par Merwan BOUDRIAS dans le cadre d’une démonstration technique.
+
+## 📚 Références
+Dataset AG News : https://huggingface.co/datasets/ag_news
+Modèles Transformers : https://huggingface.co/models
+Documentation Gradio : https://gradio.app/

requirements.txt

@@ -0,0 +1,84 @@
+accelerate==1.7.0
+aiofiles==24.1.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.9
+aiosignal==1.3.2
+annotated-types==0.7.0
+anyio==4.9.0
+attrs==25.3.0
+certifi==2025.4.26
+charset-normalizer==3.4.2
+click==8.2.1
+datasets==3.6.0
+dill==0.3.8
+dotenv==0.9.9
+fastapi==0.115.12
+ffmpy==0.6.0
+filelock==3.18.0
+frozenlist==1.6.2
+fsspec==2025.3.0
+gradio==5.33.0
+gradio_client==1.10.2
+groovy==0.1.2
+h11==0.16.0
+hf-xet==1.1.3
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.32.4
+idna==3.10
+Jinja2==3.1.6
+joblib==1.5.1
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+mdurl==0.1.2
+mpmath==1.3.0
+multidict==6.4.4
+multiprocess==0.70.16
+networkx==3.5
+numpy==2.2.6
+orjson==3.10.18
+packaging==25.0
+pandas==2.3.0
+pillow==11.2.1
+propcache==0.3.1
+protobuf==6.31.1
+psutil==7.0.0
+pyarrow==20.0.0
+pydantic==2.11.5
+pydantic_core==2.33.2
+pydub==0.25.1
+Pygments==2.19.1
+python-dateutil==2.9.0.post0
+python-dotenv==1.1.0
+python-multipart==0.0.20
+pytz==2025.2
+PyYAML==6.0.2
+regex==2024.11.6
+requests==2.32.3
+rich==14.0.0
+ruff==0.11.12
+safehttpx==0.1.6
+safetensors==0.5.3
+scikit-learn==1.6.1
+scipy==1.15.3
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+starlette==0.46.2
+sympy==1.14.0
+threadpoolctl==3.6.0
+tokenizers==0.21.1
+tomlkit==0.13.3
+torch==2.7.1
+tqdm==4.67.1
+transformers==4.52.4
+typer==0.16.0
+typing-inspection==0.4.1
+typing_extensions==4.14.0
+tzdata==2025.2
+urllib3==2.4.0
+uvicorn==0.34.3
+websockets==15.0.1
+xxhash==3.5.0
+yarl==1.20.0

scripts/inference.py

@@ -0,0 +1,127 @@
+import torch
+import torch.nn.functional as F
+from dotenv import load_dotenv
+import os
+from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
+
+#Mapping entre les ID des classes et les labels textuels
+id2label = {0: "World", 1: "Sports", 2: "Business", 3: "Sci/Tech"}
+
+
+def zero_shot_inference(text):
+    """
+    Effectue une classification zero-shot à l'aide du modèle BART MNLI.
+    
+    Args:
+        text (str): Texte à classifier.
+    
+    Returns:
+        tuple:
+            - str: Label prédit.
+            - dict: Dictionnaire {label: score} pour chaque classe.
+    """
+    classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
+    candidate_labels = list(id2label.values())
+    result = classifier(text, candidate_labels)
+    prediction = result["labels"][0]
+    # Formatage des scores avec 4 décimales
+    scores = {label: float(f"{score:.4f}") for label, score in zip(result["labels"], result["scores"])}
+    return prediction, scores
+
+
+def few_shot_inference(text):
+    """
+    Simule un few-shot learning en injectant des exemples dans le prompt (type prompt engineering).
+    
+    Args:
+        text (str): Texte à classifier.
+    
+    Returns:
+        tuple:
+            - str: Label prédit.
+            - dict: Scores pour chaque classe.
+    """
+    classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
+    
+    #Exemples donnés au modèle pour le guider (prompt engineering)
+    examples = [
+        ("The president met the UN delegation to discuss global peace.", "World"),
+        ("The football team won their match last night.", "Sports"),
+        ("The company reported a big profit this quarter.", "Business"),
+        ("New research in AI shows promising results.", "Sci/Tech")
+    ]
+    
+    #Construction du prompt avec des exemples
+    prompt = ""
+    for example_text, example_label in examples:
+        prompt += f"Text: {example_text}\nLabel: {example_label}\n\n"
+    prompt += f"Text: {text}\nLabel:"
+
+    candidate_labels = list(id2label.values())
+    result = classifier(prompt, candidate_labels)
+    prediction = result["labels"][0]
+    scores = {label: float(f"{score:.4f}") for label, score in zip(result["labels"], result["scores"])}
+    return prediction, scores
+
+
+def base_model_inference(text):
+    """
+    Utilise un modèle BERT préentraîné sur AG News (sans fine-tuning personnalisé).
+    
+    Args:
+        text (str): Texte à classifier.
+    
+    Returns:
+        tuple:
+            - str: Label prédit.
+            - dict: Scores softmax par classe.
+    """
+    model_name = "textattack/bert-base-uncased-ag-news"
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModelForSequenceClassification.from_pretrained(model_name)
+
+    #Encodage du texte
+    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+
+    #Prédiction sans calcul de gradients
+    with torch.no_grad():
+        outputs = model(**inputs)
+
+    #Calcul des probabilités avec softmax
+    probs = F.softmax(outputs.logits, dim=-1)[0].cpu().numpy()
+
+    pred_id = probs.argmax()
+    prediction = id2label[pred_id]
+    scores = {id2label[i]: float(f"{p:.4f}") for i, p in enumerate(probs)}
+    return prediction, scores
+
+
+def fine_tuned_inference(text, model_path="Merwan611/agnews-finetuned-bert"):
+    """
+    Utilise un modèle BERT fine-tuné personnalisé sur AG News, avec authentification Hugging Face si nécessaire.
+
+    Args:
+        text (str): Texte à classifier.
+        model_path (str): Nom du modèle Hugging Face ou chemin local.
+
+    Returns:
+        tuple:
+            - str: Label prédit.
+            - dict: Scores softmax par classe.
+    """
+
+    #Récupération du token d'auth depuis les variables d'environnement
+    token = os.getenv("CLE")
+
+    tokenizer = AutoTokenizer.from_pretrained(model_path, use_auth_token=token)
+    model = AutoModelForSequenceClassification.from_pretrained(model_path)
+
+    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+    with torch.no_grad():
+        outputs = model(**inputs)
+
+    probs = F.softmax(outputs.logits, dim=-1)[0].cpu().numpy()
+    pred_id = probs.argmax()
+    prediction = id2label[pred_id]
+    scores = {id2label[i]: float(f"{p:.4f}") for i, p in enumerate(probs)}
+    return prediction, scores

scripts/train.py

@@ -0,0 +1,137 @@
+from datasets import load_dataset, DatasetDict, Dataset
+from transformers import (
+    AutoTokenizer, AutoModelForSequenceClassification,
+    Trainer, TrainingArguments, DataCollatorWithPadding
+)
+import numpy as np
+from utils import compute_metrics  
+import os
+
+def load_ag_news():
+    """
+    Charge le jeu de données AG News via Hugging Face datasets.
+    
+    Returns:
+        DatasetDict: Contenant les splits train/test.
+    """
+    dataset = load_dataset("ag_news")
+    return dataset
+
+
+def get_balanced_subset(dataset_split, n_per_class=1000):
+    """
+    Crée un sous-ensemble équilibré contenant `n_per_class` exemples par classe.
+    
+    Args:
+        dataset_split (Dataset): Split de type train ou test.
+        n_per_class (int): Nombre d'exemples à garder par classe.
+    
+    Returns:
+        Dataset: Sous-ensemble équilibré.
+    """
+    subsets = []
+
+    for label in range(4):
+        #Filtrage des exemples correspondant à la classe `label`
+        filtered = dataset_split.filter(lambda example: example['label'] == label)
+        #Sélection des n premiers exemples (ou tous s’il y en a moins)
+        subsets.append(filtered.select(range(min(n_per_class, len(filtered)))))
+
+    #Fusionner les sous-ensembles
+    combined_dict = {
+        key: sum([subset[key] for subset in subsets], []) for key in subsets[0].features.keys()
+    }
+
+    return Dataset.from_dict(combined_dict)
+
+
+def preprocess_data(dataset, tokenizer):
+    """
+    Tokenise le jeu de données avec troncature et padding.
+
+    Args:
+        dataset (DatasetDict): Données d'entraînement et de test.
+        tokenizer (AutoTokenizer): Tokenizer à utiliser.
+
+    Returns:
+        DatasetDict: Données tokenisées.
+    """
+    def preprocess(batch):
+        return tokenizer(batch["text"], truncation=True, padding=True)
+
+    return dataset.map(preprocess, batched=True)
+
+
+def main():
+    """
+    Lance le fine-tuning du modèle BERT sur AG News et sauvegarde le modèle.
+    """
+    #Création des dossiers de sortie
+    os.makedirs("../models/fine_tuned_model", exist_ok=True)
+    os.makedirs("../logs", exist_ok=True)
+
+    #Chargement du jeu de données
+    dataset = load_ag_news()
+
+    #Création de sous-ensembles équilibrés (entraînement/test)
+    train_subset = get_balanced_subset(dataset["train"], n_per_class=3000)
+    test_subset = get_balanced_subset(dataset["test"], n_per_class=1000)
+
+    dataset_small = DatasetDict({
+        "train": train_subset,
+        "test": test_subset
+    })
+
+    #Chargement du tokenizer
+    model_name = "bert-base-uncased"
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+
+    #Prétraitement (tokenisation)
+    encoded = preprocess_data(dataset_small, tokenizer)
+
+    #Préparation des entrées avec padding dynamique
+    data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
+
+    #Chargement du modèle BERT pour classification
+    model = AutoModelForSequenceClassification.from_pretrained(
+        model_name,
+        num_labels=4  #AG News contient 4 classes
+    )
+
+    #Configuration de l'entraînement
+    training_args = TrainingArguments(
+        output_dir="../models/fine_tuned_model",
+        eval_strategy="epoch",
+        save_strategy="epoch",
+        num_train_epochs=3,
+        per_device_train_batch_size=32,
+        per_device_eval_batch_size=32,
+        load_best_model_at_end=True,
+        metric_for_best_model="accuracy",
+        logging_dir="../logs",
+        seed=42
+    )
+
+    #Définition du trainer Hugging Face
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=encoded["train"],
+        eval_dataset=encoded["test"],
+        tokenizer=tokenizer,
+        data_collator=data_collator,
+        compute_metrics=lambda p: compute_metrics(
+            np.argmax(p.predictions, axis=1), p.label_ids
+        )
+    )
+
+    #Lancement de l'entraînement
+    trainer.train()
+
+    #Sauvegarde finale du modèle
+    trainer.save_model("../models/fine_tuned_model")
+    print("✅ Modèle sauvegardé dans ../models/fine_tuned_model")
+
+
+if __name__ == "__main__":
+    main()

scripts/utils.py

@@ -0,0 +1,31 @@
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+
+def compute_metrics(preds, labels):
+    """
+    Calcule les métriques de classification à partir des prédictions du modèle
+    et des labels de vérité terrain (vrais).
+
+    Args:
+        preds (array-like): Les classes prédites par le modèle (entiers).
+        labels (array-like): Les vraies classes associées aux exemples (entiers).
+
+    Returns:
+        dict: Dictionnaire contenant les métriques suivantes :
+            - "accuracy" : exactitude globale des prédictions
+            - "f1" : score F1 pondéré (par classe)
+            - "precision" : précision pondérée
+            - "recall" : rappel pondéré
+    """
+
+    #Calcule précision, rappel et F1 pondérés selon la taille de chaque classe
+    precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average='weighted')
+    
+    #Calcule l'accuracy brute
+    acc = accuracy_score(labels, preds)
+    
+    return {
+        "accuracy": acc,
+        "f1": f1,
+        "precision": precision,
+        "recall": recall
+    }