app.py

import gradio as gr
import torch
import pandas as pd
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, T5Tokenizer, T5ForConditionalGeneration
import numpy as np
import networkx as nx
import nltk
from nltk.corpus import stopwords
from nltk.tokenize import sent_tokenize, word_tokenize
nltk.download('punkt')
nltk.download('stopwords')
nltk.download('punkt_tab')
import string

# Importations spécifiques à Sumy
from sumy.parsers.plaintext import PlaintextParser
from sumy.nlp.tokenizers import Tokenizer
from sumy.summarizers.lsa import LsaSummarizer
from sumy.summarizers.text_rank import TextRankSummarizer
from sumy.nlp.stemmers import Stemmer
from sumy.utils import get_stop_words

# --- Variables globales et chargement des modèles (mis en cache) ---
# Les modèles sont chargés une seule fois lorsque l'application démarre
def load_models():
    """Charge les tokenizers et les modèles T5 et MBart."""
    print("Initialisation de l'application et vérification des ressources...")
    
    # Définir le périphérique
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print(f"Périphérique utilisé : {device}")

    # --- MT5 ---
    t5_model_name = 't5-large'
    print(f"Chargement du tokenizer T5 ({t5_model_name})...")
    t5_tokenizer = AutoTokenizer.from_pretrained(t5_model_name, use_fast=False)
    print("Tokenizer T5 chargé.")

    print(f"Chargement du modèle T5 ({t5_model_name})...")
    t5_model = T5ForConditionalGeneration.from_pretrained(t5_model_name, return_dict=True)
    t5_model.to(device)
    print("Modèle T5 chargé.")
    
    # --- MBart ---
    mbart_model_name = 'facebook/mbart-large-50'
    print(f"Chargement du tokenizer MBart ({mbart_model_name})...")
    mbart_tokenizer = AutoTokenizer.from_pretrained(mbart_model_name)
    print("Tokenizer MBart chargé.")

    print(f"Chargement du modèle MBart ({mbart_model_name})...")
    mbart_model = AutoModelForSeq2SeqLM.from_pretrained(mbart_model_name, return_dict=True)
    mbart_model.to(device)
    print("Modèle MBart chargé.")
    
    print("Tous les modèles et ressources sont chargés avec succès ! L'application est prête.")
    return t5_tokenizer, t5_model, mbart_tokenizer, mbart_model, device

# Charger les modèles une seule fois au démarrage de l'application
t5_tokenizer, t5_model, mbart_tokenizer, mbart_model, device = load_models()

# --- Fonctions de résumé ---

def summarize_lsa(text, num_sentences=3):
    """Génère un résumé extractif en utilisant LSA de Sumy."""
    if not text.strip():
        return "Article trop court ou vide pour LSA."

    parser = PlaintextParser.from_string(text, Tokenizer("french"))
    stemmer = Stemmer("french")
    
    summarizer = LsaSummarizer(stemmer)
    summarizer.stop_words = get_stop_words("french")

    summary_sentences = summarizer(parser.document, num_sentences)
    
    return " ".join([str(sentence) for sentence in summary_sentences])

def summarize_textrank(text, num_sentences=3):
    """Génère un résumé extractif en utilisant TextRank de Sumy."""
    if not text.strip():
        return "Article trop court ou vide pour TextRank."

    parser = PlaintextParser.from_string(text, Tokenizer("french"))
    stemmer = Stemmer("french")
    
    summarizer = TextRankSummarizer(stemmer)
    summarizer.stop_words = get_stop_words("french")

    summary_sentences = summarizer(parser.document, num_sentences)
    
    return " ".join([str(sentence) for sentence in summary_sentences])

def summarize_t5(text, min_length=200, max_length=350):
    """Génère un résumé abstractif en utilisant T5."""
    prefixed_text = f"resumer en francais: {text}"
    
    inputs = t5_tokenizer(
        prefixed_text,
        return_tensors='pt',
        max_length=max_length,
        truncation=True,
        padding=True
    ).to(device)

    output_sequences = t5_model.generate(
        input_ids=inputs['input_ids'],
        attention_mask=inputs['attention_mask'],
        min_length=min_length,
        max_length=max_length
    )
    return t5_tokenizer.decode(output_sequences[0], skip_special_tokens=True)

def summarize_mbart(text, min_length=200, max_length=350):
    """Génère un résumé abstractif en utilisant mBART."""

    #prefixed_text = f"résumer en français: {text}"
    inputs = mbart_tokenizer(
        text,
        return_tensors='pt',
        max_length=max_length,
        truncation=True,
        padding=True
    ).to(device)

    FRENCH_LANGUAGE_TOKEN_ID = mbart_tokenizer.lang_code_to_id["fr_XX"]

    output_sequences = mbart_model.generate(
        input_ids=inputs['input_ids'],
        attention_mask=inputs['attention_mask'],
        min_length=min_length,
        max_length=max_length,
        forced_bos_token_id=FRENCH_LANGUAGE_TOKEN_ID
    )
    return mbart_tokenizer.decode(output_sequences[0], skip_special_tokens=True)

# --- Fonction principale pour la page de résumé ---
def generate_all_summaries(article_input, num_sentences, min_summary_len, max_summary_len):
    """Génère les résumés pour tous les algorithmes et met à jour la progression."""
    if not article_input:
        return "Veuillez entrer un article pour générer les résumés.", "", "", ""

    # Utilisation de yield pour les mises à jour de progression dans Gradio
    # Gradio affichera automatiquement une barre de progression pour les fonctions qui yield
    
    # LSA
    yield "Génération du résumé LSA...", "", "", "",""
    lsa_summary = summarize_lsa(article_input, num_sentences)
    
    # TextRank
    yield "Génération du résumé TextRank...", lsa_summary, "", "",""
    textrank_summary = summarize_textrank(article_input, num_sentences)
    
    # T5
    yield "Génération du résumé T5...", lsa_summary, textrank_summary, "",""
    t5_summary = summarize_t5(article_input, min_summary_len, max_summary_len)
    
    # MBart
    yield "Génération du résumé MBart...", lsa_summary, textrank_summary, t5_summary,""
    mbart_summary = summarize_mbart(article_input, min_summary_len, max_summary_len)
    
    yield "Résumés terminés !", lsa_summary, textrank_summary, t5_summary, mbart_summary


# --- Contenu de la page d'explications (Markdown) ---
explanations_markdown = """
# Comprendre les Méthodes de Résumé de Texte
---
## Méthodes Extractives vs. Abstractives

Il existe deux grandes catégories de méthodes pour résumer du texte :

### 1. Méthodes Extractives

Ces méthodes fonctionnent en **sélectionnant des phrases ou des passages clés** directement à partir du texte original et en les assemblant pour former le résumé. Elles ne génèrent pas de nouvelles phrases ou de nouveaux mots.

**Avantages :** Les résumés sont garantis d'être grammaticalement corrects et fidèles au texte source.

**Inconvénients :** Ils peuvent manquer de fluidité ou de cohérence, car les phrases sont simplement juxtaposées, et ils peuvent inclure des informations redondantes.

### 2. Méthodes Abstractives

Ces méthodes **génèrent de nouvelles phrases** qui capturent le sens du texte original, de manière similaire à la façon dont un humain écrirait un résumé. Elles peuvent paraphraser, condenser et même introduire des mots qui n'étaient pas présents dans le texte source.

**Avantages :** Les résumés sont plus fluides, plus concis et plus cohérents.

**Inconvénients :** Elles sont plus complexes à développer et peuvent parfois générer des informations incorrectes ou des 'hallucinations' (informations non présentes dans le texte original).

---

## Principes des Algorithmes Spécifiques

### LSA (Latent Semantic Analysis) - Extractif

LSA est une technique qui utilise l'algèbre linéaire pour identifier les relations entre les termes et les documents. Pour le résumé, LSA crée une représentation numérique du texte où les phrases sont des points dans un espace multidimensionnel. Il utilise la **Décomposition en Valeurs Singulières (SVD)** pour réduire la dimensionnalité et identifier les concepts latents (thèmes) dans le texte. Les phrases qui sont les plus représentatives de ces concepts latents sont sélectionnées pour former le résumé.

### TextRank - Extractif

TextRank est un algorithme basé sur le célèbre algorithme PageRank de Google, utilisé pour classer l'importance des pages web. Pour le résumé, TextRank construit un **graphe** où chaque **phrase** du texte est un **nœud**. Les **liens (arêtes)** entre les phrases sont basés sur leur **similarité sémantique** (par exemple, le nombre de mots partagés ou la similarité cosinus des vecteurs de mots). L'algorithme parcourt ensuite ce graphe pour attribuer un score d'importance à chaque phrase. Les phrases avec les scores les plus élevés sont choisies pour le résumé.

### T5 (Text-to-Text Transfer Transformer) - Abstractif

T5 est un modèle de langage développé par Google, dont le principe est de traiter toutes les tâches de traitement du langage naturel (NLP) comme des problèmes de "texte-à-texte". Cela signifie que pour n'importe quelle tâche (résumé, traduction, question-réponse), l'entrée et la sortie du modèle sont toujours du texte. Pour réaliser un résumé, on fournit à T5 le texte original avec un préfixe spécifique, comme 'summarize: '. Le modèle va ensuite générer un nouveau texte qui représente le résumé. Ce résumé n'est pas une simple extraction de phrases existantes, mais une nouvelle formulation des informations clés, ce qui en fait une méthode abstractive.

### MBart (Multilingual BART) - Abstractif

MBart est un modèle de séquence-à-séquence (encoder-decoder) pré-entraîné sur un grand corpus multilingue. Il est particulièrement adapté aux tâches de **traduction** et de **génération de texte multilingues**. Pour le résumé, MBart apprend à reconstruire le texte original tout en le compressant. Pour forcer la génération dans une langue spécifique (comme le français), on utilise un **token de début de séquence (BOS)** spécifique à la langue cible lors de la génération. Cela lui indique de commencer à générer le résumé en français, quelle que soit la langue de l'article d'entrée.

---
*Les modèles abstractifs (T5, MBart) nécessitent généralement plus de ressources de calcul (GPU) que les méthodes extractives (LSA, TextRank).*
"""

# --- Interface Gradio ---
with gr.Blocks(title="Application de Résumé d'Articles") as demo:
    gr.Markdown("# Application de Résumé de Texte")

    with gr.Tabs() as tabs:
        with gr.TabItem("Explications", id="explanations_tab"):
            gr.Markdown(explanations_markdown)

        with gr.TabItem("Outil de Résumé", id="summarization_tool_tab"):
            gr.Markdown("## Outil de Résumé de Texte")
            gr.Markdown("---")

            article_input = gr.Textbox(
                label="Article à résumer",
                lines=10,
                placeholder="Collez votre article ici. Les modèles abstractifs peuvent résumer des articles multilingues en français."
            )

            num_sentences_slider = gr.Slider(
                minimum=1,
                maximum=10,
                value=5,
                step=1,
                label="Nombre de phrases pour les résumés extractifs (LSA, TextRank)"
            )
            
            min_summary_len_slider = gr.Slider(
                minimum=100,
                maximum=300,
                value=200,
                step=1,
                label="Longueur minimale du résumé (tokens) pour les modèles abstractifs"
            )
            max_summary_len_slider = gr.Slider(
                minimum=50,
                maximum=600,
                value=350,
                step=1,
                label="Longueur maximale du résumé (tokens) pour les modèles abstractifs"
            )

            generate_button = gr.Button("Générer les résumés")

            status_output = gr.Textbox(label="Statut", interactive=False)
            
            gr.Markdown("---")
            gr.Markdown("### Résultats des Résumés")

            lsa_output = gr.Textbox(label="Résumé LSA", interactive=False, lines=10)
            textrank_output = gr.Textbox(label="Résumé TextRank", interactive=False, lines=10)
            t5_output = gr.Textbox(label="Résumé T5", interactive=False, lines=10)
            mbart_output = gr.Textbox(label="Résumé MBart", interactive=False, lines=10)

            generate_button.click(
                fn=generate_all_summaries,
                inputs=[
                    article_input,
                    num_sentences_slider,
                    min_summary_len_slider,
                    max_summary_len_slider
                ],
                outputs=[
                    status_output,
                    lsa_output,
                    textrank_output,
                    t5_output,
                    mbart_output
                ]
            )

demo.launch()