Upload 14 files

.gitignore

@@ -0,0 +1,9 @@
+venv/
+__pycache__/
+*.pyc
+*.pyo
+
+.vscode/
+.github/
+
+lid.176.bin

.streamlit/config.toml

@@ -0,0 +1,2 @@
+[server]
+fileWatcherType = "poll"

Dockerfile

@@ -1,20 +1,28 @@
-FROM python:3.13.5-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+FROM python:3.10-slim
+
+WORKDIR /code
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    cmake \
+    pkg-config \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Create a non-root user
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
+EXPOSE 7860
+
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -1,19 +1,98 @@
----
-title: Summariser
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+## Multilingual News Article Summarizer
+
+A complete multilingual news summarization solution using Google Pegasus and Facebook NLLB-200 models with Streamlit web interface and comprehensive evaluation pipeline.
+
+## Demo
+
+[View Demo](http://bluelantern.tplinkdns.com:8501/)
+
+### Features
+
+- ✅ **Multilingual Support**: Auto-detects 70+ languages, translates to English for summarization, then back-translates
+- ✅ **Chunking for Long Articles**: Handles unlimited text length with overlapping token-based chunking
+- ✅ **Customizable Parameters**: Adjustable min/max summary lengths and chunk processing
+- ✅ **Evaluation Pipeline**: ROUGE metrics on CNN/DailyMail (English) and MLSUM (French) datasets
+- ✅ **Interactive Dashboard**: Compare results with official Pegasus benchmarks
+- ✅ **Navigation System**: Seamless switching between summarizer and evaluation views
+
+### Models Used
+
+- **Summarization**: [google/pegasus-cnn_dailymail](https://huggingface.co/google/pegasus-cnn_dailymail)
+- **Translation**: [facebook/nllb-200-distilled-600M](https://huggingface.co/facebook/nllb-200-distilled-600M)
+
+### Installation
+
+1. **Virtual Environment** (recommended):
+
+   ```powershell
+   python -m venv venv
+   venv\Scripts\activate
+   ```
+
+2. **Install Dependencies**:
+
+   ```powershell
+   pip install -r requirements.txt
+   ```
+
+3. **Optional**: Install CUDA for GPU acceleration (faster processing)
+
+4. **Download fastText Model**: [fastText Model](https://fasttext.cc/docs/en/language-identification.html)
+
+5. **Run Application**:
+
+   ```powershell
+   streamlit run app.py
+   ```
+
+6. **Access**: Open browser to `http://localhost:8501`
+
+### File Structure
+
+```
+📁 nlp/
+├── 📄 app.py                          # Main Streamlit application with navigation
+├── 📄 summariser.py                   # Core multilingual summarizer class
+├── 📄 evaluation.py                   # Evaluation pipeline for ROUGE metrics
+├── 📄 evaluation_dashboard.py         # Results dashboard with benchmark comparisons
+├── 📄 requirements.txt               # Python dependencies
+├── 📄 README.md                      # This documentation
+├── 📊 evaluation_results_en.csv      # English evaluation results
+├── 📊 evaluation_results_fr.csv      # French evaluation results
+└── 📊 evaluation_results_summary.csv # Aggregated metrics summary
+```
+
+### Quick Start
+
+```powershell
+# Clone and setup
+git clone <repository-url>
+cd nlp
+
+# Create virtual environment
+python -m venv venv
+venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run application
+streamlit run app.py
+```
+
+### Usage
+
+1. **News Summarizer**: Paste any article (70+ languages supported) and get intelligent summaries
+2. **Evaluation Dashboard**: View ROUGE metrics and compare with official Pegasus benchmarks
+3. **Navigation**: Use sidebar to switch between summarizer and evaluation views
+
+### Technical Details
+
+- **Chunking**: 462-token chunks with 50-token overlap for long articles
+- **Languages**: Auto-detection with langdetect, NLLB-200 translation support
+- **Evaluation**: 25 samples per language, ROUGE-1/2/L metrics
+- **GPU Support**: Automatic CUDA detection for faster processing
+
+### Team
+
+Made by **Group 31**: Loh Lit Hoong, John Ong Ming Hom, Liew Jin Sze, Kueh Pang Lang

app.py

@@ -0,0 +1,197 @@
+import streamlit as st
+from summariser import Summarizer
+from evaluation_dashboard import show_evaluation_page
+
+
+@st.cache_resource
+def load_summarizer_model():
+    model = Summarizer()
+    return model
+
+
+def show_summarizer_page():
+    """Main summarizer page function."""
+    st.title("📰 Multilingual News Article Summarizer")
+    st.markdown(
+        "Enter a news article below. If non-English, it will be translated to English, summarized, and the summary translated back."
+    )
+
+    with st.spinner("Loading models... This may take longer on first run."):
+        summarizer = load_summarizer_model()
+
+    article_text = st.text_area(
+        "Paste your article here (supports multiple languages):",
+        height=250,
+        key="article_input",
+    )
+
+    col1, col2 = st.columns(2)
+    with col1:
+        min_summary_length = st.slider(
+            "Minimum Final Summary Length (optional):",
+            min_value=0,
+            max_value=150,
+            value=0,
+            step=5,
+            help="Set to 0 to let the model decide."
+        )
+    with col2:
+        max_summary_length = st.slider(
+            "Maximum Final Summary Length (optional):",
+            min_value=0,
+            max_value=500,
+            value=0,
+            step=10,
+            help="Set to 0 to let the model decide."
+        )
+
+    show_intermediate = st.checkbox(
+        "Show intermediate translation and English summary", value=True
+    )
+
+    if st.button("✨ Summarize Article", type="primary"):
+        if not article_text.strip():
+            st.warning("Please enter some text to summarize.")
+        else:
+            with st.spinner(
+                "Processing and generating summary... This can take a while for long non-English texts."
+            ):
+                try:
+                    # Convert 0 to None before passing to the summarizer
+                    effective_min_length = None if min_summary_length == 0 else min_summary_length
+                    effective_max_length = None if max_summary_length == 0 else max_summary_length
+
+                    summary_results = summarizer.summarize(
+                        article_text,
+                        overall_min_length=effective_min_length,
+                        overall_max_length=effective_max_length,
+                    )
+
+                    if summary_results.get('error'):
+                        st.error(summary_results['error'])
+                    else:
+                        detected_lang = summary_results.get('detected_language_raw')
+                        confidence = summary_results.get('detected_language_confidence')
+                        
+                        if detected_lang:
+                            lang_display_text = f"Detected Input Language: **{detected_lang}**"
+                            if confidence is not None:
+                                lang_display_text += f" (Confidence: {confidence:.2f})"
+                            st.info(lang_display_text)
+                            if summary_results.get('translation_performed') and \
+                               (detected_lang != 'en' and detected_lang != 'eng'):
+                                st.caption("Translation to English was performed before summarization.")
+                            elif summary_results.get('translation_performed') and \
+                                 (detected_lang == 'en' or detected_lang == 'eng'):
+                                st.caption("Input detected as English with low confidence; an English-to-English 'translation' pass was performed for normalization before summarization.")
+
+                        if show_intermediate and summary_results.get(
+                            "english_translation"
+                        ):
+                            st.subheader(
+                                "Intermediate: Translated to English (for Summarization)"
+                            )
+                            st.text_area(
+                                "English Translation",
+                                value=summary_results["english_translation"],
+                                height=200,
+                                disabled=True,
+                                key="eng_trans",
+                            )
+
+                        if show_intermediate and summary_results.get("english_summary"):
+                            st.subheader("Intermediate: English Summary (from Pegasus)")
+                            st.text_area(
+                                "English Summary",
+                                value=summary_results["english_summary"],
+                                height=150,
+                                disabled=True,
+                                key="eng_sum",
+                            )
+
+                        st.subheader("Final Summary")
+                        if summary_results.get("final_summary"):
+                            st.success(summary_results["final_summary"])
+                        else:
+                            st.warning("No final summary was generated.")
+
+                except Exception as e:
+                    st.error(f"A critical error occurred in the application: {e}")
+                    import traceback
+
+                    st.exception(traceback.format_exc())
+
+    st.markdown("---")
+    st.markdown(
+        "<div style='text-align: center; color: #666; font-size: 16px;'>"
+        "Powered by google/pegasus-cnn_dailymail<br>"
+        "<strong>Made by Group 31:</strong> Loh Lit Hoong, John Ong Ming Hom, Liew Jin Sze, Kueh Pang Lang"
+        "</div>",
+        unsafe_allow_html=True,
+    )
+
+
+def main():
+    """Main application with navigation."""
+    st.set_page_config(
+        page_title="Multilingual News Summarizer", page_icon="📰", layout="wide"
+    )
+
+    custom_font_css = """
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Oswald:wght@200..700&display=swap');
+
+        /* Apply to general elements first */
+        html, body, [class*="st-"],
+        .stTextArea textarea, .stTextInput input,
+        .stButton button, .stSelectbox select, .stSlider label,
+        p, span, div, li /* Common text holding elements */
+        {
+            font-family: 'Oswald', sans-serif;
+        }
+
+        /* Specifically target headings, with !important */
+        h1, h2, h3, h4, h5, h6,
+        [data-testid="stAppViewContainer"] h1, /* Main page title */
+        [data-testid="stAppViewContainer"] h2,
+        [data-testid="stAppViewContainer"] h3,
+        [data-testid="stSidebarContent"] h1, /* Sidebar title */
+        [data-testid="stSidebarContent"] h2,
+        [data-testid="stSidebarContent"] h3,
+        div[data-testid="stHeading"] > h1, /* For st.title() */
+        div[data-testid="stHeading"] > h2, /* For st.header() */
+        div[data-testid="stHeading"] > h3  /* For st.subheader() */
+        {
+            font-family: 'Oswald', sans-serif !important;
+        }
+    </style>
+    """
+    st.markdown(custom_font_css, unsafe_allow_html=True)
+
+    # Navigation sidebar
+    with st.sidebar:
+        st.title("🧭 Navigation")
+        page = st.selectbox(
+            "Select Page:",
+            ["📰 News Summarizer", "📊 Evaluation Dashboard"],
+            index=0,
+            key="navigation",
+        )
+
+        st.markdown("---")
+        st.markdown("**About this App:**")
+        st.markdown("• Multilingual news summarization")
+        st.markdown(
+            "• Powered by [Pegasus](https://huggingface.co/google/pegasus-cnn_dailymail) & [NLLB-200](https://huggingface.co/facebook/nllb-200-distilled-600M)"
+        )
+        st.markdown("• Evaluation with ROUGE metrics")
+
+    # Display selected page
+    if page == "📰 News Summarizer":
+        show_summarizer_page()
+    elif page == "📊 Evaluation Dashboard":
+        show_evaluation_page()
+
+
+if __name__ == "__main__":
+    main()

evaluation.py

@@ -0,0 +1,466 @@
+"""
+Evaluation pipeline for Multilingual News Article Summarizer.
+
+Evaluates model performance on:
+- CNN/DailyMail (English)
+- MLSUM French
+- MLSUM German
+
+Uses 100 test samples per language and calculates ROUGE-1, ROUGE-2, and ROUGE-L scores.
+"""
+
+import csv
+import os
+from typing import List, Dict, Any
+from datasets import load_dataset
+from rouge_score import rouge_scorer
+from summariser import Summarizer
+
+
+class SummarizerEvaluator:
+    """Evaluator for multilingual news article summarization."""
+
+    def __init__(self):
+        """Initialize the evaluator with required models."""
+        print("Initializing Summarizer...")
+        self.summarizer = Summarizer()
+        self.rouge_scorer = rouge_scorer.RougeScorer(
+            ["rouge1", "rouge2", "rougeL"], use_stemmer=True
+        )
+        print("Evaluator initialized successfully.\n")
+
+    def load_dataset_samples(
+        self, dataset_name: str, language: str, num_samples: int = 100
+    ) -> List[Dict[str, Any]]:
+        """
+        Load samples from a dataset using streaming to avoid memory issues.
+
+        Args:
+            dataset_name: Name of the dataset to load
+            language: Language identifier
+            num_samples: Number of samples to load (default: 100)
+
+        Returns:
+            List of sample dictionaries with 'article' and 'summary' keys
+        """
+        print(f"Loading {num_samples} samples from {dataset_name} ({language})...")
+
+        samples = []
+        successful_loads = 0
+
+        try:
+            # Configure dataset loading
+            if dataset_name == "cnn_dailymail":
+                dataset = load_dataset(
+                    dataset_name, "3.0.0", streaming=True, split="test"
+                )
+                article_key = "article"
+                summary_key = "highlights"
+            elif dataset_name == "mlsum":
+                # MLSUM needs trust_remote_code=True
+                dataset = load_dataset(
+                    dataset_name,
+                    language,
+                    streaming=True,
+                    split="test",
+                    trust_remote_code=True,
+                )
+                article_key = "text"
+                summary_key = "summary"
+            else:
+                raise ValueError(f"Unsupported dataset: {dataset_name}")
+
+            # Stream and collect samples until we get exactly num_samples successful ones
+            for sample in dataset:
+                try:
+                    # Extract article and summary
+                    article = sample.get(article_key, "").strip()
+                    summary = sample.get(summary_key, "").strip()
+
+                    # Skip if either article or summary is empty
+                    if not article or not summary:
+                        continue
+
+                    samples.append({"article": article, "summary": summary})
+
+                    successful_loads += 1  # Progress logging every 10 samples
+                    if successful_loads % 10 == 0:
+                        print(f"  Loaded {successful_loads}/{num_samples} samples...")
+
+                    # Stop when we have enough samples
+                    if successful_loads >= num_samples:
+                        break
+
+                except Exception as e:
+                    print(f"  Warning: Skipping sample due to error: {e}")
+                    continue
+
+            print(
+                f"Successfully loaded {len(samples)} samples from {dataset_name} ({language})\n"
+            )
+            return samples
+
+        except Exception as e:
+            print(f"Error loading dataset {dataset_name} ({language}): {e}")
+            return []
+
+    def evaluate_sample(self, article: str, reference_summary: str) -> Dict[str, Any]:
+        """
+        Evaluate a single article-summary pair.
+
+        Args:
+            article: Input article text
+            reference_summary: Ground truth summary
+
+        Returns:
+            Dictionary with evaluation results
+        """
+        try:
+            # Generate summary using the summarizer
+            result = self.summarizer.summarize(article)
+
+            if result["error"]:
+                return {
+                    "success": False,
+                    "error": result["error"],
+                    "rouge1_f": 0.0,
+                    "rouge2_f": 0.0,
+                    "rougeL_f": 0.0,
+                    "generated_summary": None,
+                    "detected_language": result.get("detected_language_ld"),
+                }
+
+            generated_summary = result["final_summary"]
+            if not generated_summary:
+                return {
+                    "success": False,
+                    "error": "No summary generated",
+                    "rouge1_f": 0.0,
+                    "rouge2_f": 0.0,
+                    "rougeL_f": 0.0,
+                    "generated_summary": None,
+                    "detected_language": result.get("detected_language_ld"),
+                }
+
+            # Calculate ROUGE scores
+            scores = self.rouge_scorer.score(reference_summary, generated_summary)
+
+            return {
+                "success": True,
+                "error": None,
+                "rouge1_f": scores["rouge1"].fmeasure,
+                "rouge2_f": scores["rouge2"].fmeasure,
+                "rougeL_f": scores["rougeL"].fmeasure,
+                "generated_summary": generated_summary,
+                "detected_language": result.get("detected_language_ld"),
+            }
+
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "rouge1_f": 0.0,
+                "rouge2_f": 0.0,
+                "rougeL_f": 0.0,
+                "generated_summary": None,
+                "detected_language": None,
+            }
+
+    def evaluate_dataset(
+        self, dataset_name: str, language: str, num_samples: int = 25
+    ) -> Dict[str, Any]:
+        """
+        Evaluate summarizer on a complete dataset.
+
+        Args:
+            dataset_name: Name of the dataset
+            language: Language identifier
+            num_samples: Number of samples to evaluate
+
+        Returns:
+            Dictionary with aggregated results
+        """
+        print(f"=== Evaluating {dataset_name} ({language}) ===")
+
+        # Load samples
+        samples = self.load_dataset_samples(dataset_name, language, num_samples)
+        if not samples:
+            return {
+                "dataset": dataset_name,
+                "language": language,
+                "total_samples": 0,
+                "successful_evaluations": 0,
+                "avg_rouge1_f": 0.0,
+                "avg_rouge2_f": 0.0,
+                "avg_rougeL_f": 0.0,
+                "individual_results": [],
+                "error": "Failed to load samples",
+            }
+
+        # Evaluate each sample
+        individual_results = []
+        successful_evaluations = 0
+        total_rouge1 = 0.0
+        total_rouge2 = 0.0
+        total_rougeL = 0.0
+
+        for i, sample in enumerate(samples):
+            try:  # Progress logging every 10 evaluations
+                if (i + 1) % 10 == 0:
+                    print(f"  Evaluating sample {i + 1}/{len(samples)}...")
+
+                # Evaluate single sample
+                eval_result = self.evaluate_sample(sample["article"], sample["summary"])
+
+                # Store individual result
+                individual_result = {
+                    "sample_id": i + 1,
+                    "dataset": dataset_name,
+                    "language": language,
+                    "success": eval_result["success"],
+                    "error": eval_result["error"],
+                    "rouge1_f": eval_result["rouge1_f"],
+                    "rouge2_f": eval_result["rouge2_f"],
+                    "rougeL_f": eval_result["rougeL_f"],
+                    "detected_language": eval_result["detected_language"],
+                    "reference_summary": (
+                        sample["summary"][:200] + "..."
+                        if len(sample["summary"]) > 200
+                        else sample["summary"]
+                    ),
+                    "generated_summary": (
+                        eval_result["generated_summary"][:200] + "..."
+                        if eval_result["generated_summary"]
+                        and len(eval_result["generated_summary"]) > 200
+                        else eval_result["generated_summary"]
+                    ),
+                }
+                individual_results.append(individual_result)
+
+                # Accumulate scores for successful evaluations
+                if eval_result["success"]:
+                    successful_evaluations += 1
+                    total_rouge1 += eval_result["rouge1_f"]
+                    total_rouge2 += eval_result["rouge2_f"]
+                    total_rougeL += eval_result["rougeL_f"]
+
+            except Exception as e:
+                print(f"  Warning: Error evaluating sample {i + 1}: {e}")
+                individual_results.append(
+                    {
+                        "sample_id": i + 1,
+                        "dataset": dataset_name,
+                        "language": language,
+                        "success": False,
+                        "error": str(e),
+                        "rouge1_f": 0.0,
+                        "rouge2_f": 0.0,
+                        "rougeL_f": 0.0,
+                        "detected_language": None,
+                        "reference_summary": (
+                            sample["summary"][:200] + "..."
+                            if len(sample["summary"]) > 200
+                            else sample["summary"]
+                        ),
+                        "generated_summary": None,
+                    }
+                )
+                continue
+
+        # Calculate averages
+        avg_rouge1 = (
+            total_rouge1 / successful_evaluations if successful_evaluations > 0 else 0.0
+        )
+        avg_rouge2 = (
+            total_rouge2 / successful_evaluations if successful_evaluations > 0 else 0.0
+        )
+        avg_rougeL = (
+            total_rougeL / successful_evaluations if successful_evaluations > 0 else 0.0
+        )
+
+        print(
+            f"Completed evaluation: {successful_evaluations}/{len(samples)} successful"
+        )
+        print(f"Average ROUGE-1: {avg_rouge1:.4f}")
+        print(f"Average ROUGE-2: {avg_rouge2:.4f}")
+        print(f"Average ROUGE-L: {avg_rougeL:.4f}\n")
+
+        return {
+            "dataset": dataset_name,
+            "language": language,
+            "total_samples": len(samples),
+            "successful_evaluations": successful_evaluations,
+            "avg_rouge1_f": avg_rouge1,
+            "avg_rouge2_f": avg_rouge2,
+            "avg_rougeL_f": avg_rougeL,
+            "individual_results": individual_results,
+            "error": None,
+        }
+
+    def run_full_evaluation(self, num_samples: int = 25) -> str:
+        """
+        Run complete evaluation pipeline on all datasets.
+
+        Args:
+            num_samples: Number of samples per dataset
+
+        Returns:
+            Path to the saved results CSV file
+        """
+        print(
+            "🚀 Starting Full Multilingual Evaluation Pipeline 🚀\n"
+        )  # Define datasets to evaluate
+        datasets_config = [
+            {"dataset_name": "cnn_dailymail", "language": "en"},
+            {"dataset_name": "mlsum", "language": "fr"},
+        ]
+
+        all_summary_results = []
+
+        # Evaluate each dataset
+        for config in datasets_config:
+            dataset_result = self.evaluate_dataset(
+                config["dataset_name"], config["language"], num_samples
+            )
+
+            # Save individual CSV immediately after each language evaluation
+            individual_csv_path = self.save_individual_results_to_csv(
+                dataset_result["individual_results"],
+                dataset_result["dataset"],
+                dataset_result["language"],
+            )
+            print(
+                f"✅ Saved {dataset_result['language'].upper()} results to: {individual_csv_path}"
+            )
+
+            # Store summary results
+            all_summary_results.append(
+                {
+                    "dataset": dataset_result["dataset"],
+                    "language": dataset_result["language"],
+                    "total_samples": dataset_result["total_samples"],
+                    "successful_evaluations": dataset_result["successful_evaluations"],
+                    "success_rate": (
+                        dataset_result["successful_evaluations"]
+                        / dataset_result["total_samples"]
+                        if dataset_result["total_samples"] > 0
+                        else 0.0
+                    ),
+                    "avg_rouge1_f": dataset_result["avg_rouge1_f"],
+                    "avg_rouge2_f": dataset_result["avg_rouge2_f"],
+                    "avg_rougeL_f": dataset_result["avg_rougeL_f"],
+                    "error": dataset_result["error"],
+                }
+            )
+
+        # Save combined summary CSV
+        summary_csv_path = self.save_summary_results_to_csv(
+            all_summary_results
+        )  # Print final summary
+        print("📊 FINAL EVALUATION SUMMARY 📊")
+        print("=" * 50)
+        for result in all_summary_results:
+            print(f"{result['dataset']} ({result['language'].upper()}):")
+            print(
+                f"  Success Rate: {result['success_rate']:.1%} ({result['successful_evaluations']}/{result['total_samples']})"
+            )
+            print(f"  ROUGE-1: {result['avg_rouge1_f']:.4f}")
+            print(f"  ROUGE-2: {result['avg_rouge2_f']:.4f}")
+            print(f"  ROUGE-L: {result['avg_rougeL_f']:.4f}")
+            print()
+
+        print(f"✅ Combined summary saved to: {summary_csv_path}")
+        return summary_csv_path
+
+    def save_individual_results_to_csv(
+        self, individual_results: List[Dict], dataset_name: str, language: str
+    ) -> str:
+        """
+        Save individual evaluation results to a language-specific CSV file with summary row.
+
+        Args:
+            individual_results: List of individual sample results
+            dataset_name: Name of the dataset
+            language: Language identifier
+
+        Returns:
+            Path to the saved CSV file
+        """
+        # Create filename
+        csv_path = f"evaluation_results_{language}.csv"
+
+        with open(csv_path, "w", newline="", encoding="utf-8") as csvfile:
+            if individual_results:
+                fieldnames = individual_results[0].keys()
+                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+                writer.writeheader()
+                writer.writerows(individual_results)
+
+                # Add summary row
+                successful_results = [r for r in individual_results if r["success"]]
+                if successful_results:
+                    avg_rouge1 = sum(r["rouge1_f"] for r in successful_results) / len(
+                        successful_results
+                    )
+                    avg_rouge2 = sum(r["rouge2_f"] for r in successful_results) / len(
+                        successful_results
+                    )
+                    avg_rougeL = sum(r["rougeL_f"] for r in successful_results) / len(
+                        successful_results
+                    )
+
+                    summary_row = {
+                        "sample_id": "SUMMARY",
+                        "dataset": dataset_name,
+                        "language": language,
+                        "success": f"{len(successful_results)}/{len(individual_results)}",
+                        "error": None,
+                        "rouge1_f": avg_rouge1,
+                        "rouge2_f": avg_rouge2,
+                        "rougeL_f": avg_rougeL,
+                        "detected_language": None,
+                        "reference_summary": "AVERAGE SCORES",
+                        "generated_summary": f"Success Rate: {len(successful_results)/len(individual_results):.1%}",
+                    }
+                    writer.writerow(summary_row)
+
+        return csv_path
+
+    def save_summary_results_to_csv(self, summary_results: List[Dict]) -> str:
+        """
+        Save aggregated summary results to CSV file.
+
+        Args:
+            summary_results: List of aggregated dataset results
+
+        Returns:
+            Path to the saved CSV file
+        """
+        summary_csv_path = "evaluation_results_summary.csv"
+        with open(summary_csv_path, "w", newline="", encoding="utf-8") as csvfile:
+            if summary_results:
+                fieldnames = summary_results[0].keys()
+                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+                writer.writeheader()
+                writer.writerows(summary_results)
+
+        return summary_csv_path
+
+
+def main():
+    """Main evaluation function."""
+    try:
+        evaluator = SummarizerEvaluator()
+        csv_path = evaluator.run_full_evaluation(num_samples=25)
+        print(f"\n🎉 Evaluation completed successfully!")
+        print(f"Results available in: {csv_path}")
+
+    except Exception as e:
+        print(f"❌ Evaluation failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    main()

evaluation_dashboard.py

@@ -0,0 +1,286 @@
+"""
+Evaluation Results Dashboard for Multilingual News Article Summarizer
+"""
+
+import streamlit as st
+import pandas as pd
+import math
+from typing import Dict, Any
+
+
+def load_evaluation_data():
+    """Load evaluation results from CSV files."""
+    try:
+        # Load English results
+        df_en = pd.read_csv("evaluation_results_en.csv")
+
+        # Load French results
+        df_fr = pd.read_csv("evaluation_results_fr.csv")
+
+        return df_en, df_fr
+    except FileNotFoundError as e:
+        st.error(f"Could not load evaluation files: {e}")
+        return None, None
+
+
+def display_summary_metrics(df: pd.DataFrame, title: str):
+    """Display summary metrics in a highlighted card format."""
+    # Get summary row (last row with sample_id = 'SUMMARY')
+    summary_row = (
+        df[df["sample_id"] == "SUMMARY"].iloc[0]
+        if len(df[df["sample_id"] == "SUMMARY"]) > 0
+        else None
+    )
+
+    if summary_row is not None:
+        st.markdown(f"### 📊 {title} - Summary Results")
+
+        # Create metrics columns with ample spacing
+        col1, col2, col3 = st.columns([1, 1, 1])
+
+        with col1:
+            st.metric(
+                label="ROUGE-1", value=f"{summary_row['rouge1_f']:.4f}", delta=None
+            )
+
+        with col2:
+            st.metric(
+                label="ROUGE-2", value=f"{summary_row['rouge2_f']:.4f}", delta=None
+            )
+
+        with col3:
+            st.metric(
+                label="ROUGE-L", value=f"{summary_row['rougeL_f']:.4f}", delta=None
+            )
+
+        st.markdown("---")
+
+
+def display_paginated_table(
+    df: pd.DataFrame, columns_to_show: list, page_size: int = 15
+):
+    """Display a paginated table with the specified columns."""
+    # Filter out summary row for the detailed table
+    df_filtered = df[df["sample_id"] != "SUMMARY"].copy()
+    df_display = df_filtered[columns_to_show].copy()
+
+    # Rename columns for better display
+    column_rename = {
+        "sample_id": "Sample ID",
+        "rouge1_f": "ROUGE-1",
+        "rouge2_f": "ROUGE-2",
+        "rougeL_f": "ROUGE-L",
+        "reference_summary": "Reference Summary",
+        "generated_summary": "Generated Summary",
+    }
+    df_display = df_display.rename(columns=column_rename)
+
+    # Format ROUGE scores to 4 decimal places
+    for col in ["ROUGE-1", "ROUGE-2", "ROUGE-L"]:
+        if col in df_display.columns:
+            df_display[col] = df_display[col].apply(lambda x: f"{x:.4f}")
+
+    # Calculate pagination
+    total_rows = len(df_display)
+    total_pages = math.ceil(total_rows / page_size)
+
+    if total_pages > 1:
+        # Page selector
+        col1, col2, col3 = st.columns([1, 2, 1])
+        with col2:
+            page = st.selectbox(
+                "Select Page",
+                range(1, total_pages + 1),
+                format_func=lambda x: f"Page {x} of {total_pages}",
+                key="page_selector",
+            )
+    else:
+        page = 1
+
+    # Calculate start and end indices
+    start_idx = (page - 1) * page_size
+    end_idx = min(start_idx + page_size, total_rows)
+
+    # Display page info
+    st.caption(f"Showing rows {start_idx + 1}-{end_idx} of {total_rows}")
+
+    # Display the table
+    df_page = df_display.iloc[start_idx:end_idx]
+    st.dataframe(
+        df_page,
+        use_container_width=True,
+        hide_index=True,
+        column_config={
+            "Reference Summary": st.column_config.TextColumn(
+                width="medium", help="Ground truth summary from the dataset"
+            ),
+            "Generated Summary": st.column_config.TextColumn(
+                width="medium", help="Summary generated by our model"
+            ),
+            "ROUGE-1": st.column_config.NumberColumn(
+                help="ROUGE-1 F1 score", format="%.4f"
+            ),
+            "ROUGE-2": st.column_config.NumberColumn(
+                help="ROUGE-2 F1 score", format="%.4f"
+            ),
+            "ROUGE-L": st.column_config.NumberColumn(
+                help="ROUGE-L F1 score", format="%.4f"
+            ),
+        },
+    )
+
+
+def display_benchmark_table():
+    """Display the official Pegasus benchmark results."""
+    st.markdown("### 🏆 Official Google Pegasus Benchmark Results")
+    st.markdown("*ROUGE scores in format: ROUGE-1/ROUGE-2/ROUGE-L*")
+
+    # Create the benchmark data
+    benchmark_data = {
+        "Dataset": ["xsum", "cnn_dailymail", "newsroom", "multi_news", "gigaword"],
+        "C4": [
+            "45.20/22.06/36.99",
+            "43.90/21.20/40.76",
+            "45.07/33.39/41.28",
+            "46.74/17.95/24.26",
+            "38.75/19.96/36.14",
+        ],
+        "HugeNews": [
+            "47.21/24.56/39.25",
+            "44.17/21.47/41.11",
+            "45.15/33.51/41.33",
+            "47.52/18.72/24.91",
+            "39.12/19.86/36.24",
+        ],
+        "Mixed & Stochastic": [
+            "47.60/24.83/39.64",
+            "44.16/21.56/41.30",
+            "45.98/34.20/42.18",
+            "47.65/18.75/24.95",
+            "39.65/20.47/36.76",
+        ],
+    }
+
+    df_benchmark = pd.DataFrame(benchmark_data)
+
+    st.dataframe(
+        df_benchmark,
+        use_container_width=True,
+        hide_index=True,
+        column_config={
+            "Dataset": st.column_config.TextColumn(
+                width="medium", help="Evaluation dataset"
+            ),
+            "C4": st.column_config.TextColumn(
+                width="medium", help="C4 pre-training configuration"
+            ),
+            "HugeNews": st.column_config.TextColumn(
+                width="medium", help="HugeNews pre-training configuration"
+            ),
+            "Mixed & Stochastic": st.column_config.TextColumn(
+                width="medium", help="Mixed & Stochastic pre-training configuration"
+            ),
+        },
+    )
+
+
+def show_evaluation_page():
+    """Evaluation dashboard page function for navigation."""
+    st.title("📊 Evaluation Results Dashboard")
+    st.markdown(
+        "*Comprehensive evaluation results for the Multilingual News Article Summarizer*"
+    )
+    st.markdown("---")
+
+    # Load data
+    df_en, df_fr = load_evaluation_data()
+
+    if df_en is None or df_fr is None:
+        st.error(
+            "⚠️ Could not load evaluation data. Please ensure evaluation CSV files are present."
+        )
+        return  # Create selection dropdown
+    st.markdown("### 🔍 Select Evaluation Results to View")
+
+    # Use dropdown for clean, modern selection
+    option = st.selectbox(
+        "Choose an option:",
+        [
+            "🏆 Official Google Pegasus Benchmark Results",
+            "🇺🇸 Our English Evaluation (CNN/DailyMail)",
+            "🇫🇷 Our French Evaluation (MLSUM)",
+        ],
+        index=0,
+        key="evaluation_option",
+    )
+
+    st.markdown("---")  # Display content based on selection
+    if option == "🏆 Official Google Pegasus Benchmark Results":
+        display_benchmark_table()
+
+        # Page-specific disclaimer
+        st.markdown("---")
+        st.info(
+            "📖 **Additional Information**: For more details about the Pegasus model, visit the [official HuggingFace model page](https://huggingface.co/google/pegasus-cnn_dailymail)."
+        )
+
+    elif option == "🇺🇸 Our English Evaluation (CNN/DailyMail)":
+        # Display summary metrics first
+        display_summary_metrics(df_en, "English (CNN/DailyMail)")
+
+        # Display detailed results
+        st.markdown("### 📝 Detailed Sample Results")
+        columns_to_show = [
+            "sample_id",
+            "rouge1_f",
+            "rouge2_f",
+            "rougeL_f",
+            "reference_summary",
+            "generated_summary",
+        ]
+        display_paginated_table(df_en, columns_to_show)
+
+        # Page-specific disclaimer
+        st.markdown("---")
+        st.warning(
+            "⚠️ **Disclaimer**: ROUGE scores shown are based on a small test set of 25 articles per dataset, due to time and computational constraints. These results are indicative but not fully representative. Performance is expected to improve with larger, more comprehensive test sets."
+        )
+        st.info(
+            "📖 **Dataset Information**: For more details about the CNN/DailyMail dataset used in this evaluation, visit the [official dataset page](https://huggingface.co/datasets/abisee/cnn_dailymail)."
+        )
+
+    elif option == "🇫🇷 Our French Evaluation (MLSUM)":
+        # Display summary metrics first
+        display_summary_metrics(df_fr, "French (MLSUM)")
+
+        # Display detailed results
+        st.markdown("### 📝 Detailed Sample Results")
+        columns_to_show = [
+            "sample_id",
+            "rouge1_f",
+            "rouge2_f",
+            "rougeL_f",
+            "reference_summary",
+            "generated_summary",
+        ]
+        display_paginated_table(df_fr, columns_to_show)  # Page-specific disclaimer
+        st.markdown("---")
+        st.warning(
+            "⚠️ **Disclaimer**: Evaluations for non-English summaries (e.g., French) tend to be lower than for English ones primarily due to cascading errors introduced during the machine translation step. Our translation model, while generally good, is a distilled, research-focused version and not intended for production deployment. This means it can struggle with the nuances of news articles, introducing inaccuracies or losing subtle context. These translation imperfections are then amplified when fed into the English-optimized summarization model, often resulting in less precise content in the final summary. For more details about the translation model limitations and specifications, visit the [NLLB-200 distilled model page](https://huggingface.co/facebook/nllb-200-distilled-600M)."
+        )
+        st.info(
+            "📖 **Dataset Information**: For more details about the MLSUM dataset used in this evaluation, visit the [official dataset page](https://huggingface.co/datasets/reciTAL/mlsum)."
+        )
+
+
+# For backwards compatibility when run directly
+def main():
+    """Main function for backwards compatibility."""
+    st.set_page_config(
+        page_title="Evaluation Results Dashboard", page_icon="📊", layout="wide"
+    )
+    show_evaluation_page()
+
+
+if __name__ == "__main__":
+    main()

evaluation_results_en.csv

@@ -0,0 +1,95 @@
+sample_id,dataset,language,success,error,rouge1_f,rouge2_f,rougeL_f,detected_language,reference_summary,generated_summary
+1,cnn_dailymail,en,True,,0.39999999999999997,0.22727272727272727,0.33333333333333337,en,"Membership gives the ICC jurisdiction over alleged crimes committed in Palestinian territories since last June .
+Israel and the United States opposed the move, which could open the door to war crimes ...","The Palestinian Authority officially becomes the 123rd member of the International Criminal Court.
+The move gives the court jurisdiction over alleged crimes in Palestinian territories. The United Stat..."
+2,cnn_dailymail,en,True,,0.4888888888888889,0.31818181818181823,0.4444444444444445,en,"Theia, a bully breed mix, was apparently hit by a car, whacked with a hammer and buried in a field .
+""She's a true miracle dog and she deserves a good life,"" says Sara Mellado, who is looking for a ho...","Theia, a white-and-black bully breed mix, was apparently hit by a car and buried in a field.
+Four days later, she staggered to a nearby farm and was taken in by a worker.
+She's been treated at Washing..."
+3,cnn_dailymail,en,True,,0.4672897196261682,0.24761904761904763,0.26168224299065423,en,"Mohammad Javad Zarif has spent more time with John Kerry than any other foreign minister .
+He once participated in a takeover of the Iranian Consulate in San Francisco .
+The Iranian foreign minister t...","Mohammad Javad Zarif is the Iranian foreign minister.
+He has been the U.S. secretary of state's opposite number in nuclear talks. Iranian Foreign Minister Javad Zarif and U.S. Secretary of State John ..."
+4,cnn_dailymail,en,True,,0.3561643835616438,0.16901408450704225,0.24657534246575344,en,"17 Americans were exposed to the Ebola virus while in Sierra Leone in March .
+Another person was diagnosed with the disease and taken to hospital in Maryland .
+National Institutes of Health says the p...","One of the five had a heart-related issue on Saturday and has been discharged but hasn't left the area.
+They were exposed to Ebola in Sierra Leone in March."
+5,cnn_dailymail,en,True,,0.3611111111111111,0.1142857142857143,0.2222222222222222,en,"Student is no longer on Duke University campus and will face disciplinary review .
+School officials identified student during investigation and the person admitted to hanging the noose, Duke says .
+Th...","A student has admitted to hanging a noose from a tree near a student union, Duke says.
+The prestigious private school didn't identify the student, citing federal privacy laws."
+6,cnn_dailymail,en,True,,0.22988505747126436,0.07058823529411765,0.1839080459770115,en,"College-bound basketball star asks girl with Down syndrome to high school prom .
+Pictures of the two during the ""prom-posal"" have gone viral .","Trey Moses is a star high school basketball player in Louisville, Kentucky.
+He made the prom-posal in Ellie Meredith's P.E. class.
+""That's the kind of person Trey is,"" a teacher says. Trey's future co..."
+7,cnn_dailymail,en,True,,0.36363636363636365,0.13793103448275862,0.21590909090909088,en,"Amnesty's annual death penalty report catalogs encouraging signs, but setbacks in numbers of those sentenced to death .
+Organization claims that governments around the world are using the threat of te...","Amnesty International's annual death penalty report says number of executions fell by 22% in 2014.
+But mass-sentencing cases increased by 28% globally last year.
+Pakistan, China and Egypt are cited as..."
+8,cnn_dailymail,en,True,,0.358974358974359,0.15789473684210528,0.33333333333333337,en,"Andrew Getty's death appears to be from natural causes, police say, citing coroner's early assessment .
+In a petition for a restraining order, Getty had written he had a serious medical condition.
+Pol...","Andrew Getty appears to have died of natural causes, police say.
+Coroner's preliminary assessment is there was no foul play involved, detective says.
+The 47-year-old had ""several health issues,"" detec..."
+9,cnn_dailymail,en,True,,0.23076923076923078,0.08,0.15384615384615385,en,"Once a super typhoon, Maysak is now a tropical storm with 70 mph winds .
+It could still cause flooding, landslides and other problems in the Philippines .","Tropical storm Maysak is centered 200 miles southwest of Aurora province.
+It's expected to make landfall Sunday morning on the southeastern coast of Isabela province."
+10,cnn_dailymail,en,True,,0.5365853658536586,0.30769230769230765,0.3902439024390244,en,"Bob Barker returned to host ""The Price Is Right"" on Wednesday .
+Barker, 91, had retired as host in 2007 .","Barker hosted ""The Price Is Right"" for 35 years before stepping down in 2007.
+He returned to the show on April 1."
+11,cnn_dailymail,en,True,,0.24242424242424243,0.0625,0.18181818181818182,en,"London's Metropolitan Police say the man was arrested at Luton airport after landing on a flight from Istanbul .
+He's been charged with terror offenses allegedly committed since the start of November ...","Yahya Rashid is charged with engaging in conduct in preparation of acts of terrorism.
+He's also charged with engaging in conduct with the intention of assisting others to commit acts of terrorism."
+12,cnn_dailymail,en,True,,0.2765957446808511,0.10869565217391305,0.19148936170212763,en,"""Furious 7"" pays tribute to star Paul Walker, who died during filming .
+Vin Diesel: ""This movie is more than a movie""
+""Furious 7"" opens Friday .","Paul Walker died in a car crash while filming ""Furious 7""
+Fans have been paying tribute to the late actor. A week after Walker's death, about 5,000 people attended an outdoor memorial to him in Los An..."
+13,cnn_dailymail,en,True,,0.31775700934579443,0.15238095238095237,0.205607476635514,en,"Museum: Anne Frank died earlier than previously believed .
+Researchers re-examined archives and testimonies of survivors .
+Anne and older sister Margot Frank are believed to have died in February 1945...","Anne Frank died of typhus in a Nazi concentration camp at the age of 15.
+Two weeks after her supposed death, the Bergen-Belsen camp was liberated.
+New research shows Anne and her older sister, Margot ..."
+14,cnn_dailymail,en,True,,0.2346368715083799,0.03389830508474576,0.1340782122905028,en,"LZ: Indiana law pushing back LGBT rights, and other states' anti-LGBT moves, bow to far right wing that GOP candidates need for 2016 .
+Cruz, Huckabee, Jindal, Carson, Walker are reviving culture wars,...","Indiana Gov. Mike Pence signed a religious freedom law last week that opens the door to discrimination against gays and lesbians.
+John Avlon: The law was Pence's way of shoring up his street cred with..."
+15,cnn_dailymail,en,True,,0.37209302325581395,0.1951219512195122,0.37209302325581395,en,"Singing the national anthem is a risky proposition .
+Whitney Houston nailed it; Roseanne Barr destroyed it .","Mtley Cre's Vince Neil sang the national anthem at a Las Vegas football game.
+Whitney Houston, Roseanne Barr and Jimi Hendrix have all butchered the song."
+16,cnn_dailymail,en,True,,0.15384615384615383,0.01111111111111111,0.07692307692307691,en,"While Republican Gov. Asa Hutchinson was weighing an Arkansas religious freedom bill, Walmart voiced its opposition .
+Walmart and other high-profile businesses are showing their support for gay and le...","Walmart's opposition to a religious freedom law in its home state of Arkansas resonated most deeply.
+The company is emerging as a bellwether for shifting public opinion on hot-button political issues...."
+17,cnn_dailymail,en,True,,0.30158730158730157,0.17741935483870966,0.253968253968254,en,"Amnesty International releases its annual review of the death penalty worldwide; much of it makes for grim reading .
+Salil Shetty: Countries that use executions to deal with problems are on the wrong ...","Amnesty International releases its annual review of the death penalty worldwide.
+In Pakistan, the government lifted a six-year moratorium on the execution of civilians.
+A sharp spike in death sentence..."
+18,cnn_dailymail,en,True,,0.26666666666666666,0.10762331838565023,0.1688888888888889,en,"Marseille prosecutor says ""so far no videos were used in the crash investigation"" despite media reports .
+Journalists at Bild and Paris Match are ""very confident"" the video clip is real, an editor say...","""So far no videos were used in the crash investigation,"" Marseille prosecutor Brice Robin says.
+Paris Match and Bild report that a cell phone video was found at the crash site.
+The publications descri..."
+19,cnn_dailymail,en,True,,0.33644859813084116,0.11428571428571428,0.24299065420560745,en,"The Rev. Robert Schuller, 88, had been diagnosed with esophageal cancer in 2013 .
+His TV show, ""Hour of Power,"" was enormously popular in the 1970s and 1980s .","Schuller was diagnosed with esophageal cancer in August 2013.
+He was born in an Iowa farmhouse without running water. Schuller began broadcasting ""Hour of Power"" in 1970.
+The show, which ran for decad..."
+20,cnn_dailymail,en,True,,0.30303030303030304,0.03125,0.18181818181818182,en,"Former GOP representative compares President Obama to Andreas Lubitz .
+Bachmann said with possible Iran deal, Obama will fly ""entire nation into the rocks""
+Reaction on social media? She was blasted by...","""With his Iran deal, Barack Obama is for the 300 million souls of the United States,"" she wrote.
+Bachmann is no stranger to voicing her opinion on the President's dealing with Iran."
+21,cnn_dailymail,en,True,,0.3503649635036496,0.16296296296296298,0.24817518248175185,en,"Father: ""I know he went through what he went through""
+Louis Jordan was found on his sailboat, which was listing and in bad shape, rescuer says .
+He appears to be in good shape, physically and mentally...","Louis Jordan, 37, left Conway, South Carolina, to fish in the ocean.
+Just a few days into his trip, a storm capsized his boat and broke his mast. The Coast Guard says it has found no reason to doubt J..."
+22,cnn_dailymail,en,True,,0.24858757062146897,0.057142857142857134,0.1581920903954802,en,"Richard Klass: Iran framework agreement on nukes is strong, but opponents will cast doubts on this and try to obscure its facts .
+He says the deal would cut uranium stockpile, centrifuges, implement r...","U.S., Iran reach framework deal to limit Iran's nuclear program.
+Aaron Miller: Opponents will likely raise questions about the agreement. David Rothkopf: Some in Congress are skeptical of Iran nuclear..."
+23,cnn_dailymail,en,True,,0.3178807947019867,0.053691275167785234,0.15894039735099336,en,"Americans paid more for some fruits and vegetables last year because of the drought .
+Tourists will now have to ask for a glass of water at a California restaurant .
+Perhaps the only good thing is ano...","California is a breadbasket to the nation, growing more than a third of its vegetables and nearly two-thirds of its fruits and nuts.
+The historic California drought hurts the rest of the union, too. T..."
+24,cnn_dailymail,en,True,,0.711864406779661,0.5614035087719298,0.4067796610169491,en,"The FBI cites social media messages sent by Keonna Thomas, 30 .
+She's accused of trying to travel overseas to join ISIS .
+Thomas is one of three women facing federal terror charges this week .","Keonna Thomas is one of three women arrested this week on terror charges.
+She's accused of trying to travel overseas to fight for ISIS."
+25,cnn_dailymail,en,True,,0.4074074074074074,0.2692307692307692,0.37037037037037035,en,"Iranian sports official: The ban will be lifted for some events in the coming year .
+But he says ""families are not interested in attending"" some sports matches .","Deputy Sports Minister Abdolhamid Ahmadi says the ban will be lifted for some events.
+It isn't clear exactly which games women will be able to attend."
+SUMMARY,cnn_dailymail,en,25/25,,0.34537982149532837,0.15716789755737007,0.24550524500330861,,AVERAGE SCORES,Success Rate: 100.0%

evaluation_results_fr.csv

@@ -0,0 +1,27 @@
+sample_id,dataset,language,success,error,rouge1_f,rouge2_f,rougeL_f,detected_language,reference_summary,generated_summary
+1,mlsum,fr,True,,0.1754385964912281,0.0,0.10526315789473685,fr,Mohamed Salah et Divock Origi ont permis à Liverpool de remporter son sixième trophée en C1 au terme d’une finale décevante.,"Liverpool a battu Tottenham 2-0 en finale de la Ligue des champions, mais Manchester United a perdu à Arsenal aux quarts de finale. Chelsea est éliminé par Llorinous Corious FC au dernier 16."
+2,mlsum,fr,True,,0.23376623376623376,0.026666666666666665,0.15584415584415584,fr,"Le philosophe, mort samedi à 88 ans, a su faire vivre une longue tradition française alliant les charmes de la plume, le travail heureux de la pensée et les générosités du cœur.","Les Français ont trouvé un moyen de comprendre le désaccord avec les idées des autres. Au lieu d'être ouvertement, il a rendu possible la création d'œuvres comme celle du Sirénage nationaliste françai..."
+3,mlsum,fr,True,,0.3333333333333333,0.17391304347826086,0.2916666666666667,fr,"L’auteur des best-sellers « Les Cinq Sens », « Petite Poucette », « Le Gaucher boiteux », s’est éteint à l’âge de 88 ans, « entouré de sa famille ».","Michel Serres est décédé samedi à l'âge de 88 ans, en paix à 19 heures amoureux des saveurs et de la science."
+4,mlsum,fr,True,,0.358974358974359,0.07894736842105264,0.1794871794871795,fr,"Deuxième demi-finale de suite, pour un club seulement remonté dans l’élite en 2016 : la performance est remarquable et ancre un peu plus le LOU dans le paysage du rugby français.",Le Lyonnais se qualifie pour la deuxième année consécutive en demi-finale.L'équipe française est capable de retrouver sa force après deux points.Barceland parvient à faire 10 points supplémentaires da...
+5,mlsum,fr,True,,0.2716049382716049,0.025316455696202528,0.14814814814814814,fr,"Plusieurs de ces manifestants arboraient une kippa, alors que le port de cette calotte dans l’espace public est l’objet d’un âpre débat depuis une semaine en Allemagne.","Plusieurs politiciens antisémites, membres du Bundestag et un membre de l'ambassadeur des États-Unis en Allemagne ont participé à une manifestation anti-semitiste organisée en solidarité avec les Juif..."
+6,mlsum,fr,True,,0.1627906976744186,0.07142857142857142,0.1627906976744186,fr,"Le chanteur et guitariste texan fut un des fondateurs du genre en 1966 avec son groupe, The 13th Floor Elevators.","Roky Erickson est décédé le vendredi 31 mai 2018 dans sa ville natale d'Austin, au Texas où il est né le 15 juillet 1947. Après une carrière inconsciente empêchée par la schizophrénie et la mort préma..."
+7,mlsum,fr,True,,0.3055555555555555,0.1142857142857143,0.19444444444444445,fr,"Le militant des droits humains avait été placé en détention le 31 mars pour « atteintes aux institutions », et observait depuis une grève de la faim.",Plusieurs milliers de personnes ont assisté aux funérailles de Kamil Eddin Fekher. Le médecin âgé de 54 ans était également un défenseur de la cause du Mozambique. Il a été arrêté le 31 mars pour avoi...
+8,mlsum,fr,True,,0.21052631578947367,0.02702702702702703,0.10526315789473684,fr,Une équipe de l’Inrap a mis au jour un dépôt d’une trentaine de monnaies d’or et d’argent qui nous transportent dans la Bourgogne de la toute fin du XVe siècle.,Environ 33 pièces de monnaie ont été imprimées sur du papier sans valeur significative. Le gouvernement français a commencé à utiliser le système nouvellement créé des taux de change entre les États-U...
+9,mlsum,fr,True,,0.47457627118644075,0.21052631578947367,0.2711864406779661,fr,Le Figaro 3 qui équipe tous les concurrents de la course partie dimanche de La Baule est le premier monotype de série équipé de foils.,La course Solitaire Urgo Le Figaro sera lancée le 2 juin à partir de la baie de La Baule (Loire-Atlantique) Les quarante-sept concurrents deviendront tous admirateurs du premier Figaro 3 riggé.
+10,mlsum,fr,True,,0.14705882352941174,0.030303030303030307,0.11764705882352941,fr,"Dimanche, 47 concurrents s’élancent pour la première des quatre étapes de la Solitaire Urgo « Le Figaro ». Parmi eux, Loïck Peyron, Michel Desjoyeaux, ou Alain Gautier.","Le Solitaires du Figaro juin 2017 fête son 50e anniversaire. Pour cet anniversair, la course a été menée sur tous les bateaux identiques. Pour ce jubilé, il sera en compétition avec un nouveau bateau,..."
+11,mlsum,fr,True,,0.14545454545454545,0.0,0.07272727272727272,fr,"La confession catholique ne doit pas être conçue en opposition à d’autres et utilisée à des fins politiques, a expliqué le pontife argentin.",Le sanctuaire commémore à la fois une victoire contre les Ottomans et le refus par les habitants de la région d'être forcés dans le Saint-Siège à la fin du 16ème siècle. C'est ici que certains frères ...
+12,mlsum,fr,True,,0.6363636363636365,0.46875,0.5757575757575758,fr,"L’explosion a eu lieu dans l’usine Kristall à Dzerzhinsk, une ville située à environ 400 kilomètres à l’est de Moscou.","Une explosion dans une grande usine d'explosifs du centre de la Russie tue au moins 79 personnes. L'explosion a eu lieu à l'usine Kristall de Dzerzhinsk, ville située à environ 400 kilomètres à l-est ..."
+13,mlsum,fr,True,,0.1694915254237288,0.035087719298245605,0.1016949152542373,fr,"Tsitsipas, Halep, Fognini et Zverev ont gagné leurs matchs. « Le Monde » livre les résultats en détail au fil de la journée.","Serena Williams a été éliminée au troisième tour de Roland Garres par un autre Américain Antoine Kenin (35e) Ils essaient maintenant de battre leur meilleur rival, Jean de la Potrocki (115ème)."
+14,mlsum,fr,True,,0.273972602739726,0.056338028169014086,0.1643835616438356,fr,"Des appels au rassemblement ont été lancés notamment à Paris, où des manifestants se sont élancés en direction de la place de la Nation.","Le dimanche vers 13h, à la place Denfert-Rochereau dans le 14e arrondissement, plusieurs partis politiques ont organisé de nouvelles manifestations. Ils ont également appelé à des mouvements de justic..."
+15,mlsum,fr,True,,0.2,0.08333333333333333,0.2,fr,"L’ancien joueur du FC Séville, d’Arsenal et du Real Madrid, avait également disputé la Coupe du monde 2006 avec l’Espagne.",Jose Antonio Reyas est mort à l'âge de 35 ans dans un accident de voiture. Il a joué pour Arsenal et le Real Madrid entre autres.
+16,mlsum,fr,True,,0.15384615384615385,0.05405405405405406,0.15384615384615385,fr,Le neurobiologiste fait une lecture de la pièce de Molière (1672) située quelque part entre la psychanalyse freudienne et l’existentialisme pascalien. Subtil et drôle.,"Les femmes de la science, par Molire (1672), Act III."
+17,mlsum,fr,True,,0.20689655172413793,0.0,0.13793103448275862,fr,"Sa musique était un mélange de vieux blues, de jazz du temps du ragtime, de country minimaliste et de folk.","Leon Redbone est guitariste, banjoteur et chanteur du groupe American Blues Band. En 1977, il écrit trois livres pour le genre de musique country, dont ""How Can I Live Without You?"" et ""Where Will I G..."
+18,mlsum,fr,True,,0.5066666666666667,0.21917808219178084,0.3733333333333333,fr,"Alors que le projet de loi est examiné lundi à l’Assemblée, le Réseau Action Climat demande notamment la fin de la vente des voitures thermiques dès 2030 et une taxe sur les vols.","Le projet de loi sur l'orientation à la mobilité (MoB) est examiné lundi 3 juin 2050 à l'Assemblée nationale.Il est urgent que les parlementaires et le gouvernement révisent leur copie de la loi, exho..."
+19,mlsum,fr,True,,0.1951219512195122,0.025,0.0975609756097561,fr,Les élections européennes du 26 mai ont confirmé le fossé entre un vote La République en marche urbain et un vote Rassemblement national dans les zones périphériques.,"Au niveau national, le NRM et le LRM représentent 45,7 des 20 circonscriptions électorales. Certaines régions avec 24,3% de la population, y compris les zones rurales, restent inférieures à 25,7%; le ..."
+20,mlsum,fr,True,,0.13333333333333333,0.0,0.08888888888888889,fr,"Le chercheur en gestion Sihem Dekhili livre dans une tribune au « Monde » les résultats d’une enquête sur les obstacles, essentiellement psychologiques, en particulier avec la réticence de l’utilisati...",Les restaurateurs français ont été recommandés de permettre aux clients d'emporter avec eux tout aliment restant dont ils pourraient avoir besoin. Cet incitatif est devenu une obligation le 27 mai 201...
+21,mlsum,fr,True,,0.2337662337662338,0.026666666666666665,0.15584415584415584,fr,Le premier film du réalisateur Jordan Peele détourne les codes du gothique et de la science-fiction pour mieux appuyer sa dénonciation.,L'idée d'un jeune homme qu'il allait devenir un vampire est encore trop troublée et beaucoup plus efficace que la suggestion de sa femme. Le film montre également comment les cinéastes se sentent en c...
+22,mlsum,fr,True,,0.23728813559322032,0.0,0.11864406779661016,fr,"Le journalisme est un métier qui ­nécessite parfois de faire face aux situations les plus extrêmes. Au­jourd’hui, c’est à une expérience en lisière de l’anthropophagie que je dois me livrer, puisque m...",Le sandwich hommage des Burgers de Papa devait rester sur les charts pendant deux mois. Il a été lancé fin mars par la chaîne de restaurants Les Burgers De Papa. Jacques Heckerton et moi avons essayé ...
+23,mlsum,fr,True,,0.48192771084337355,0.19753086419753085,0.2891566265060241,fr,"Le 1er juin 2009, le vol Air France AF 447 disparaissait dans l’Atlantique, entre Rio et Paris. A bord de l’appareil, 228 passagers et membres d’équipage.","Le 1er juin 2009, l'AF 447 Rio-Paris s'est écrasée dans l'Atlantique, tuant 228 personnes. D'une part, Airbus insiste sur les fautes de l'équipage à Rio-Paris. d'autre part, les syndicats des pilotes,..."
+24,mlsum,fr,True,,0.2857142857142857,0.07407407407407408,0.17857142857142855,fr,"Le projet de loi, qui vise à donner un nouveau cadre aux déplacements des Français, arrive lundi à l’Assemblée.","La Commission a proposé que la nouvelle loi sur les orientations en matière de mobilité (LOG) soit examinée lors d'une session publique à l'Assemblée nationale, qui débutera le 3 juin."
+25,mlsum,fr,True,,0.21782178217821782,0.0,0.11881188118811882,fr,"L’abondance des récoltes a fait baisser le cours des fruits du caféier mais les industriels misent sur cette boisson et ses versions glacées pour séduire les plus jeunes, explique dans sa chronique, L...",La Colombie a été particulièrement touchée par la pression de ses presses au brocolique et l'ajout de mousse à son prix du marché. Son obsession pour le grand secteur du chocolat blanc a également con...
+SUMMARY,mlsum,fr,25/25,,0.2700516095775533,0.07993708060322793,0.1823557191602453,,AVERAGE SCORES,Success Rate: 100.0%

evaluation_results_summary.csv

@@ -0,0 +1,3 @@
+dataset,language,total_samples,successful_evaluations,success_rate,avg_rouge1_f,avg_rouge2_f,avg_rougeL_f,error
+cnn_dailymail,en,25,25,1.0,0.34537982149532837,0.15716789755737007,0.24550524500330861,
+mlsum,fr,25,25,1.0,0.2700516095775533,0.07993708060322793,0.1823557191602453,

packages.txt

@@ -0,0 +1,3 @@
+build-essential
+cmake
+pkg-config

summariser.py

@@ -0,0 +1,599 @@
+from transformers import PegasusForConditionalGeneration, PegasusTokenizer, pipeline
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer as NLLBTokenizer
+from transformers import M2M100ForConditionalGeneration, M2M100Config
+# from langdetect import detect, LangDetectException
+import torch
+import os
+
+_ft_model = None
+_FASTTEXT_MODEL_PATH = "lid.176.bin"
+_ENGLISH_CONFIDENCE_THRESHOLD = 0.95
+
+try:
+    import fasttext
+    if os.path.exists(_FASTTEXT_MODEL_PATH):
+        print(f"Loading fastText language identification model from: {_FASTTEXT_MODEL_PATH}")
+        _ft_model = fasttext.load_model(_FASTTEXT_MODEL_PATH)
+        print("fastText model loaded successfully.")
+    else:
+        print(f"Warning: fastText model file not found at {_FASTTEXT_MODEL_PATH}.")
+        _ft_model = None
+except ImportError:
+    print("Warning: fastText library not installed.")
+    _ft_model = None
+except Exception as e:
+    print(f"Error loading fastText model: {e}")
+    _ft_model = None
+
+def get_language_code(text: str) -> tuple[str | None, str | None, float | None, bool]:
+    """
+    Detects language using fastText and returns a tuple:
+    (detected_code_raw, nllb_compatible_code, confidence, force_translation_to_english_flag)
+    The last flag is True if detected as English but confidence is below threshold.
+    """
+    global _ft_model
+    detected_code_raw = None
+    confidence = 0.0
+    force_translation = False
+
+    if not _ft_model:
+        print("Error: fastText model not available for language detection.")
+        return None, None, None, False 
+
+    try:
+        cleaned_text = text.replace("\n", " ").replace("\r", " ")
+        if not cleaned_text.strip():
+            print("Warning: Input text is empty or whitespace only for language detection.")
+            return None, None, None, False
+
+        predictions = _ft_model.predict(cleaned_text, k=1)
+        if predictions and predictions[0]:
+            detected_code_raw = predictions[0][0].replace('__label__', '')
+            confidence = predictions[1][0]
+            print(f"fastText detected: {detected_code_raw} with confidence {confidence:.4f}")
+
+            # Check for low confidence English
+            if (detected_code_raw == 'en' or detected_code_raw == 'eng') and confidence < _ENGLISH_CONFIDENCE_THRESHOLD:
+                print(f"English detected with low confidence ({confidence:.4f} < {_ENGLISH_CONFIDENCE_THRESHOLD}). Flagging for potential translation.")
+                force_translation = True
+        else:
+            print("fastText could not predict language.")
+            return None, None, None, False
+    except Exception as e:
+        print(f"Error during fastText language detection: {e}")
+        return None, None, None, False
+
+    if not detected_code_raw:
+        return None, None, None, False
+        
+        # --- NLLB Language Code Mapping ---
+        # NLLB uses Flores-200 codes
+    nllb_lang_map = {
+        'en': 'eng_Latn', 'eng': 'eng_Latn',
+        'es': 'spa_Latn', 'spa': 'spa_Latn',
+        'fr': 'fra_Latn',
+        'de': 'deu_Latn', 'ger': 'deu_Latn',
+        'it': 'ita_Latn',
+        'pt': 'por_Latn',
+        'zh': 'zho_Hans',
+        'zh-cn': 'zho_Hans', 
+        'zh-tw': 'zho_Hant',
+        'ja': 'jpn_Jpan', 'jpn': 'jpn_Jpan',
+        'ko': 'kor_Hang', 'kor': 'kor_Hang',
+        'ar': 'ara_Arab',
+        'hi': 'hin_Deva',
+        'ru': 'rus_Cyrl',
+        'bn': 'ben_Beng',
+        'pa': 'pan_Guru',
+        'ur': 'urd_Arab',
+        'ta': 'tam_Taml',
+        'te': 'tel_Telu',
+        'ml': 'mal_Mlym',
+        'gu': 'guj_Gujr',
+        'mr': 'mar_Deva',
+        'id': 'ind_Latn', 'ind': 'ind_Latn',
+        'vi': 'vie_Latn', 'vie': 'vie_Latn',
+        'th': 'tha_Thai',
+        'tr': 'tur_Latn',
+        'fa': 'pes_Arab', 'per': 'pes_Arab',
+        'uk': 'ukr_Cyrl',
+        'pl': 'pol_Latn',
+        'nl': 'nld_Latn', 'dut': 'nld_Latn',
+        'ro': 'ron_Latn', 'rum': 'ron_Latn',
+        'cs': 'ces_Latn', 'cze': 'ces_Latn',
+        'sv': 'swe_Latn',
+        'fi': 'fin_Latn',
+        'da': 'dan_Latn',
+        'no': 'nob_Latn',
+        'el': 'ell_Grek', 'gre': 'ell_Grek',
+        'he': 'heb_Hebr',
+        'hu': 'hun_Latn',
+        'bg': 'bul_Cyrl',
+        'sr': 'srp_Cyrl',
+        'hr': 'hrv_Latn',
+        'sk': 'slk_Latn',
+        'sl': 'slv_Latn',
+        'et': 'est_Latn',
+        'lv': 'lav_Latn',
+        'lt': 'lit_Latn',
+        'sw': 'swh_Latn',
+        'am': 'amh_Ethi',
+        'yo': 'yor_Latn',
+        'ig': 'ibo_Latn',
+        'zu': 'zul_Latn',
+        'xh': 'xho_Latn',
+        'my': 'mya_Mymr',
+        'km': 'khm_Khmr',
+        'lo': 'lao_Laoo',
+        'ne': 'npi_Deva',
+        'si': 'sin_Sinh',
+        'az': 'azj_Latn',
+        'kk': 'kaz_Cyrl',
+        'uz': 'uzn_Latn',
+        'mn': 'khk_Cyrl',
+        'ps': 'pbt_Arab',
+        'tg': 'tgk_Cyrl',
+        'tk': 'tuk_Latn',
+        'so': 'som_Latn',
+    }
+
+    nllb_code = nllb_lang_map.get(detected_code_raw)
+    if not nllb_code and '-' in detected_code_raw:
+         nllb_code = nllb_lang_map.get(detected_code_raw.split('-')[0])
+
+    if not nllb_code:
+        print(f"Warning: No NLLB mapping for detected language code '{detected_code_raw}'.")
+    
+    return detected_code_raw, nllb_code, confidence, force_translation
+
+class Summarizer:
+    def __init__(self, 
+                 summarizer_model_name="google/pegasus-cnn_dailymail",
+                 translator_model_name="facebook/nllb-200-distilled-1.3B"): # NLLB model
+        
+        self.summarizer_model_name = summarizer_model_name
+        self.translator_model_name = translator_model_name
+        
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {self.device}")
+
+        self.pegasus_tokenizer = None
+        self.pegasus_model = None
+        self.translator_tokenizer = None
+        self.translator_model = None
+
+        if "pegasus" in self.summarizer_model_name.lower():
+            self.effective_input_token_limit = 512
+        # elif "bart" in self.summarizer_model_name.lower(): # mbart is a bart model
+        #     self.effective_input_token_limit = 1024
+        else: # Default
+            self.effective_input_token_limit = 512
+        
+        # Add effective input token limit for the translator model
+        self.translator_effective_input_token_limit = 500
+        
+        self._load_models()
+
+    def _load_models(self):
+        try:
+            print(f"Loading Pegasus tokenizer: {self.summarizer_model_name}...")
+            self.pegasus_tokenizer = PegasusTokenizer.from_pretrained(self.summarizer_model_name)
+            print(f"{self.summarizer_model_name} tokenizer loaded.")
+            print(f"Loading Pegasus model: {self.summarizer_model_name}...")
+            self.pegasus_model = PegasusForConditionalGeneration.from_pretrained(self.summarizer_model_name).to(self.device)
+            print(f"{self.summarizer_model_name} model loaded.")
+
+            print(f"Loading NLLB tokenizer: {self.translator_model_name}...")
+            self.translator_tokenizer = NLLBTokenizer.from_pretrained(self.translator_model_name)
+            print(f"NLLB tokenizer type: {type(self.translator_tokenizer)}")
+            print("NLLB tokenizer loaded.")
+
+            print(f"Loading NLLB model config using M2M100Config: {self.translator_model_name}...")
+            translator_config = M2M100Config.from_pretrained(self.translator_model_name)
+            print(f"Explicit NLLB/M2M100 config type: {type(translator_config)}")
+
+            print(f"Loading NLLB model using M2M100ForConditionalGeneration: {self.translator_model_name}...")
+            self.translator_model = M2M100ForConditionalGeneration.from_pretrained(
+                self.translator_model_name,
+                config=translator_config
+            ).to(self.device)
+            print(f"NLLB model type: {type(self.translator_model)}")
+            print("NLLB model loaded.")
+
+            # --- DEBUGGING ---
+            # if self.translator_model and hasattr(self.translator_model, 'config'):
+            #     print(f"NLLB model config type: {type(self.translator_model.config)}") # Should be M2M100Config
+            #     print(f"NLLB model config keys: {list(self.translator_model.config.to_dict().keys())}")
+            #     if hasattr(self.translator_model.config, 'lang_code_to_id'):
+            #         print("SUCCESS: 'lang_code_to_id' FOUND in translator_model.config")
+            #     else:
+            #         print("FAILURE: 'lang_code_to_id' NOT FOUND in translator_model.config")
+            # else:
+            #     print("NLLB model or its config is None after loading attempts.")
+            # --- END DEBUGGING ---
+
+        except Exception as e:
+            print(f"Error loading models: {e}")
+            import traceback
+            traceback.print_exc()
+            raise
+        
+    def _translate_text(self, text_to_translate: str, src_nllb_lang: str, tgt_nllb_lang: str) -> str | None:
+        if not self.translator_model or not self.translator_tokenizer:
+            print("Translator model/tokenizer not loaded.")
+            return None
+        if not src_nllb_lang:
+            print(f"Missing NLLB source language code for translation. Cannot translate.")
+            return text_to_translate # Keep original behavior
+
+        if not text_to_translate.strip():
+            return "" # Handle empty string input explicitly
+
+        token_limit = self.translator_effective_input_token_limit
+
+        try:
+            # Set the source language for the NLLB tokenizer
+            self.translator_tokenizer.src_lang = src_nllb_lang
+            
+            all_input_ids = self.translator_tokenizer.encode(text_to_translate, add_special_tokens=False)
+            total_tokens = len(all_input_ids)
+
+            if total_tokens == 0:
+                print(f"Warning: Text resulted in 0 tokens after encoding. Original text (first 100 chars): '{text_to_translate[:100]}...'")
+                return ""
+
+            translated_parts = []
+
+            if total_tokens <= token_limit:
+                print(f"DEBUG: Translating text as a single chunk ({total_tokens} tokens).")
+                inputs = self.translator_tokenizer(
+                    text_to_translate, 
+                    return_tensors="pt", 
+                    truncation=True, 
+                    padding=True,
+                    max_length=token_limit 
+                ).to(self.device)
+                
+                try:
+                    target_lang_token_id = self.translator_tokenizer.convert_tokens_to_ids(tgt_nllb_lang)
+                except Exception as e_conv:
+                    print(f"Error converting target language code '{tgt_nllb_lang}' to ID: {e_conv}")
+                    return None
+
+                if target_lang_token_id == self.translator_tokenizer.unk_token_id:
+                    print(f"Warning: Target language code '{tgt_nllb_lang}' was converted to UNK token ID.")
+                    return None
+
+                generated_tokens = self.translator_model.generate(
+                    **inputs,
+                    forced_bos_token_id=target_lang_token_id,
+                    max_length=1024, 
+                    repetition_penalty=1.2,
+                    no_repeat_ngram_size=3
+                )
+                translated_text_segment = self.translator_tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
+                translated_parts.append(translated_text_segment)
+            else:
+                print(f"Input text for translation has {total_tokens} tokens. Applying chunking (token limit for tokenizer: {token_limit}).")
+                
+                # Pattern similar to summarizer chunking:
+                # chunk_size for slicing from all_input_ids
+                chunk_slice_size = token_limit - 50 
+                if chunk_slice_size <= 0: # Ensure positive slice size
+                    chunk_slice_size = token_limit // 2 if token_limit > 1 else 1
+                
+                overlap_tokens = 50
+                if overlap_tokens >= chunk_slice_size and chunk_slice_size > 0:
+                    overlap_tokens = chunk_slice_size // 3
+                elif chunk_slice_size == 0:
+                    overlap_tokens = 0
+                
+                start_idx = 0
+                chunk_num = 1
+                while start_idx < total_tokens:
+                    end_idx = min(start_idx + chunk_slice_size, total_tokens)
+                    chunk_token_ids_for_decode = all_input_ids[start_idx:end_idx]
+                    
+                    current_chunk_text_to_translate = self.translator_tokenizer.decode(
+                        chunk_token_ids_for_decode,
+                        skip_special_tokens=True,
+                        clean_up_tokenization_spaces=True
+                    )
+
+                    if not current_chunk_text_to_translate.strip():
+                        print(f"DEBUG: Skipping empty decoded chunk {chunk_num}.")
+                        # Advance start_idx
+                        if end_idx == total_tokens: break
+                        step = chunk_slice_size - overlap_tokens
+                        start_idx += step if step > 0 else 1
+                        if start_idx >= end_idx and end_idx < total_tokens : start_idx = end_idx # Ensure progress
+                        chunk_num += 1
+                        continue
+                    
+                    print(f"DEBUG: Translating chunk {chunk_num}. Input token slice: {start_idx}-{end_idx-1}. Decoded text length: {len(current_chunk_text_to_translate)}")
+                    
+                    inputs = self.translator_tokenizer(
+                        current_chunk_text_to_translate, 
+                        return_tensors="pt", 
+                        truncation=True, 
+                        padding=True,
+                        max_length=token_limit # Tokenizer will cap the input from this text chunk
+                    ).to(self.device)
+
+                    try:
+                        target_lang_token_id = self.translator_tokenizer.convert_tokens_to_ids(tgt_nllb_lang)
+                    except Exception as e_conv:
+                        print(f"Error converting target language code '{tgt_nllb_lang}' to ID for chunk {chunk_num}: {e_conv}")
+                        return None 
+                    if target_lang_token_id == self.translator_tokenizer.unk_token_id:
+                        print(f"Warning: Target language code '{tgt_nllb_lang}' was UNK for chunk {chunk_num}.")
+                        return None
+
+                    generated_tokens = self.translator_model.generate(
+                        **inputs,
+                        forced_bos_token_id=target_lang_token_id,
+                        max_length=1024,
+                        repetition_penalty=1.2,
+                        no_repeat_ngram_size=3
+                    )
+                    translated_segment = self.translator_tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
+                    translated_parts.append(translated_segment)
+                    
+                    chunk_num +=1
+                    if end_idx == total_tokens:
+                        break
+                    
+                    step = chunk_slice_size - overlap_tokens
+                    start_idx += step if step > 0 else 1 # Ensure progress even if step is not positive
+                    
+                    # Safety break if start_idx doesn't advance properly (should not be needed with step logic)
+                    if start_idx >= total_tokens and end_idx < total_tokens: break 
+                    if start_idx >= end_idx and end_idx < total_tokens : start_idx = end_idx
+
+
+            final_translated_text = " ".join(translated_parts).strip()
+            return final_translated_text
+
+        except Exception as e:
+            print(f"Error during translation from {src_nllb_lang} to {tgt_nllb_lang}: {e}")
+            import traceback
+            traceback.print_exc()
+            return None
+    
+    def _summarize_english_text(self, text_chunk: str, min_length: int, max_length: int) -> str:
+        # Refined from your version for clarity and robustness
+        if not self.pegasus_model or not self.pegasus_tokenizer:
+            print("Error: Pegasus model/tokenizer not loaded.")
+            return "Error: Summarization model not available."
+        try:
+            # Provide default values if None
+            effective_min_length = min_length if min_length is not None else 30
+            effective_max_length = max_length if max_length is not None else 128
+
+            inputs = self.pegasus_tokenizer(
+                text_chunk, return_tensors="pt", truncation=True, max_length=self.effective_input_token_limit
+            ).to(self.device)
+
+            summary_ids = self.pegasus_model.generate(
+                inputs["input_ids"],
+                num_beams=4,
+                min_length=effective_min_length,
+                max_length=effective_max_length,
+                early_stopping=True
+            )
+            
+            summary_text_raw = self.pegasus_tokenizer.decode(
+                summary_ids[0], 
+                skip_special_tokens=True, # Important
+                clean_up_tokenization_spaces=True
+            )
+
+            # Post-processing for <n> tokens
+            processed_summary = summary_text_raw.replace("<n>", "\n")
+            lines = [line.strip() for line in processed_summary.split('\n')]
+            processed_summary = "\n".join(filter(None, lines)) # Removes empty lines
+
+            return processed_summary.strip()
+        except Exception as e:
+            print(f"Error during Pegasus summarization of chunk: {e}")
+            import traceback
+            traceback.print_exc()
+            return f"Error summarizing chunk: {e}"
+    
+    def summarize(self, text: str, min_length_per_chunk: int = None, max_length_per_chunk: int = None,
+                      overall_min_length: int = None, overall_max_length: int = None) -> dict:
+        result = {
+            'final_summary': None, 'detected_language_raw': None, 'detected_language_confidence': None,
+            'english_translation': None, 'english_summary': None, 'error': None,
+            'translation_performed': False # New key to indicate if translation to English happened
+        }
+
+        if not all([self.pegasus_model, self.pegasus_tokenizer, self.translator_model, self.translator_tokenizer]):
+            result['error'] = "Error: Core models not loaded."
+            return result
+        if _ft_model is None:
+            result['error'] = "Error: Language detection model (fastText) not available."
+            return result
+        if not text.strip():
+            result['error'] = "Error: Input text is empty."
+            return result
+
+        original_text_to_process = text
+        detected_lang_raw, detected_lang_nllb, confidence, force_translation_flag = get_language_code(text)
+        
+        result['detected_language_raw'] = detected_lang_raw
+        result['detected_language_confidence'] = confidence
+
+        if not detected_lang_raw:
+            result['error'] = "Error: Could not detect language."
+            return result
+        
+        # Determine if translation to English is needed
+        needs_translation_to_english = False
+        if (detected_lang_raw != 'en' and detected_lang_raw != 'eng'):
+            needs_translation_to_english = True
+        elif force_translation_flag:
+            print(f"INFO: Detected as English ('{detected_lang_raw}') but confidence {confidence} is low. Attempting 'translation' to English to normalize.")
+            needs_translation_to_english = True
+            if not detected_lang_nllb:
+                detected_lang_nllb = 'eng_Latn' 
+            result['translation_performed'] = True
+        
+        if needs_translation_to_english:
+            if detected_lang_nllb:
+                print(f"Original language: {detected_lang_raw} (NLLB src: {detected_lang_nllb}). Translating to English (eng_Latn)...")
+                english_text_translation = self._translate_text(original_text_to_process, detected_lang_nllb, "eng_Latn")
+                result['translation_performed'] = True 
+                
+                if not english_text_translation or english_text_translation.startswith("Error"):
+                    err_msg = f"Error: Translation to English failed for lang {detected_lang_raw}."
+                    result['error'] = err_msg
+                    return result
+                
+                original_text_to_process = english_text_translation
+                result['english_translation'] = original_text_to_process
+                print("Translation to English complete.")
+            else: # Non-English detected by fastText, but no NLLB mapping for it
+                print(f"Critical: Original language detected as '{detected_lang_raw}', but no NLLB code mapping found. Cannot reliably translate.")
+                result['error'] = f"Error: Input language '{detected_lang_raw}' is not supported for translation (no NLLB mapping)."
+                return result
+
+
+        # --- Summarization of English text (original_text_to_process is now English) ---
+        all_input_ids = self.pegasus_tokenizer.encode(original_text_to_process, add_special_tokens=False)
+        total_tokens = len(all_input_ids)
+        english_summary_text = None
+
+        if total_tokens <= self.effective_input_token_limit:
+            english_summary_text = self._summarize_english_text(original_text_to_process, overall_min_length, overall_max_length)
+        else:
+            # (Your full chunking logic here)
+            print(f"Input text for summarizer has {total_tokens} tokens. Applying chunking...")
+            chunk_size = self.effective_input_token_limit - 50 
+            overlap_size = 50 
+            chunks_texts = []
+            start_idx = 0
+            while start_idx < total_tokens:
+                end_idx = min(start_idx + chunk_size, total_tokens)
+                chunk_token_ids = all_input_ids[start_idx:end_idx]
+                chunk_text_for_summary = self.pegasus_tokenizer.decode(chunk_token_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+                chunks_texts.append(chunk_text_for_summary)
+                if end_idx == total_tokens: break
+                start_idx += (chunk_size - overlap_size)
+                if start_idx >= end_idx : break 
+            
+            if not chunks_texts:
+                result['error'] = "Error: Failed to create any chunks from the (potentially translated) text."
+                return result
+            
+            chunk_summaries_list = []
+            for i_chunk, chunk_text_to_summarize in enumerate(chunks_texts):
+                print(f"Summarizing (English) chunk {i_chunk+1}/{len(chunks_texts)}...")
+                chunk_sum = self._summarize_english_text(chunk_text_to_summarize, min_length_per_chunk, max_length_per_chunk)
+                if chunk_sum.startswith("Error"):
+                    result['error'] = f"Error summarizing chunk {i_chunk+1}: {chunk_sum.split(':', 1)[1].strip() if ':' in chunk_sum else chunk_sum}"
+                    return result
+                chunk_summaries_list.append(chunk_sum)
+            english_summary_text = " ".join(chunk_summaries_list)
+        
+        if not english_summary_text or english_summary_text.startswith("Error"):
+            err_msg_sum = f"Error during English summarization"
+            if english_summary_text and english_summary_text.startswith("Error"):
+                err_msg_sum += f": {english_summary_text.split(':', 1)[1].strip() if ':' in english_summary_text else english_summary_text}"
+            elif not english_summary_text:
+                err_msg_sum += ": Summarization returned no text."
+            result['error'] = err_msg_sum
+            return result
+        
+        result['english_summary'] = english_summary_text
+
+        # --- Translate summary back ---
+        final_summary_text = english_summary_text
+        if result['translation_performed'] and not force_translation_flag: # if force_translation_flag, it was already "English"
+            if detected_lang_raw != 'en' and detected_lang_raw != 'eng' and detected_lang_nllb:
+                print(f"Translating summary back to {detected_lang_raw} (NLLB: {detected_lang_nllb})...")
+                translated_summary_back = self._translate_text(english_summary_text, "eng_Latn", detected_lang_nllb)
+                if translated_summary_back and not translated_summary_back.startswith("Error"):
+                    final_summary_text = translated_summary_back
+                    print("Back-translation complete.")
+                else:
+                    warning_msg = f"Warning: Back-translation to {detected_lang_raw} failed or returned error. Returning English summary."
+                    if translated_summary_back and translated_summary_back.startswith("Error"):
+                        warning_msg += f" Details: {translated_summary_back.split(':', 1)[1].strip() if ':' in translated_summary_back else translated_summary_back}"
+                    elif not translated_summary_back:
+                        warning_msg += " Back-translation function returned None."
+                    print(warning_msg)
+        
+        result['final_summary'] = final_summary_text
+        return result
+
+if __name__ == "__main__":
+    print("Testing Summarizer Engine...")
+    if _ft_model is None:
+        print("CRITICAL: fastText model not loaded. Please ensure 'lid.176.bin' is present and readable.")
+        print("Skipping direct engine tests.")
+    else:
+        try:
+            engine = Summarizer()
+            
+            print("\n--- Testing English Article ---")
+            short_article_en = "Apple today announced its new iPhone, which features a faster processor and an improved camera. The company expects strong sales."
+            print(f"Input (EN):\n{short_article_en}")
+            summary_en_result = engine.summarize(short_article_en, overall_min_length=10, overall_max_length=50)
+            print(f"Result (EN): {summary_en_result}")
+
+            print("\n--- Testing Chinese Article (Short) ---")
+            short_article_zh = "今天天气真好，阳光明媚。"
+            print(f"Input (ZH):\n{short_article_zh}")
+            summary_zh_result = engine.summarize(short_article_zh, overall_min_length=5, overall_max_length=30)
+            print(f"Result (ZH): {summary_zh_result}")
+            
+            print("\n--- Testing Mixed Language Article ---")
+            mixed_article = '今天天气真好 How are you? 大家都在玩'
+            print(f"Input (Mixed):\n{mixed_article}")
+            summary_mixed_result = engine.summarize(mixed_article, overall_min_length=5, overall_max_length=40)
+            print(f"Result (Mixed): {summary_mixed_result}")
+
+
+            print("\n--- Testing Long English Article ---")
+            long_article_en = """
+            Warmer weather is finally here in the Northern Hemisphere, and with it, many pools and beaches are opening for the summer. That’s great for families who want to spend time by the water, but it’s also a good time to be reminded about the importance of water safety.
+            An estimated 4,000 fatal unintentional drownings happen every year in the United States — an average of 11 drowning deaths per day — according to the Centers for Disease Control and Prevention.
+            Drowning is the leading cause of death in children ages 1 to 4, and after motor vehicle accidents, it is the second leading cause of death attributed to unintentional injuries among kids ages 5 to 14.
+            I wanted to speak more about water safety with CNN wellness expert Dr. Leana Wen. Wen is an emergency physician and adjunct associate professor at George Washington University who previously served as Baltimore’s health commissioner. She is also the mother of two young children, and as someone who learned to swim as an adult, she is a passionate advocate for kids — and adults — learning to swim.
+            CNN: Who is most at risk of drowning, and under what circumstances?
+            Dr. Leana Wen: The CDC issued an important report in 2024 about unintentional drowning deaths in the United States. Death rates were significantly higher in 2020, 2021 and 2022 than in 2019, according to the agency. Moreover, the highest rates were seen in young children ages 1 to 4. Among children in this age group, 461 died by drowning in 2022, an increase of 28% from 2019.
+            The report also highlighted racial disparities, with higher rates of drowning deaths among individuals identified as non-Hispanic American Indian or Alaska Native and as non-Hispanic Black or African American. Only 45% of all adults reported having had swim lessons, and those numbers were higher among White Americans (52%) than among Black (37%) and Hispanic (28%) Americans.
+            Racial disparities were also reported in a 2023 analysis from the Consumer Product Safety Commission, which found that African American children made up 21% of all drownings for kids younger than age 15 in which race and ethnicity are known. Among kids ages 5 to 14, 45% of drowning deaths occurred among African Americans.
+            The CPSC analysis also contained another key data point: The vast majority (80%) of pediatric drownings in which the setting is known occurred at a residence. This means that 4 in 5 kids who drowned died in their own backyard pool or that of a friend, neighbor or family member. Of these residential drownings, 91% occurred among kids younger than 7 years old.
+            CNN: Why do so many drownings happen in residential settings?
+            Wen: One major reason is the difference in supervision. Many public beaches and community pools hire lifeguards whose job is to watch out for the safety of everyone in or near the water. Private pools in people’s yards often don’t have someone designated for this purpose. Sometimes older children are supervising younger children but aren’t always watching. Or adults may be supervising, but they are also busy with other tasks. In addition, some of those watching others may not know how to swim themselves.
+            There may also be a false sense of security in residential settings. People may think the pool is small or not that deep or there are a lot of people around, so what can happen? Keep in mind, though, that small kids can drown in just inches of water. Serious injury or death can happen within 30 seconds. Drownings are often silent because the victim is unable to call out for help.
+            CNN: How can parents and guardians prevent drownings in residential settings?
+            Wen: The single most important best practice is to never leave children unsupervised near a body of water. Even if they already know how to swim, even if they are wearing a flotation device, even if the pool is shallow or small, an accident could occur — and either you or another responsible adult should always be able to see your child. The supervising adult should be actively watching the child and not distracted by chores or their smartphone. That person also should not be under the influence of alcohol or drugs.
+            The adult who’s responsible must also know how to swim well enough so they are able to jump into the pool and save the child if necessary. An additional safety precaution is learning CPR and first aid for infants, children and adults, which you can do through the American Red Cross.
+            More than 1 in 3 Black adults say they can’t swim. This team is trying to teach them and their kids
+            If you have a pool, be very careful before allowing others to use it. If your neighbors’ children want to swim in your pool, a responsible adult must accompany them. Private swimming pools should all have childproof fencing around them. The fencing should enclose the pool, have a self-close latch out of the reach of children and be at least 4 feet high. This is required by law in most states.
+            CNN: What safety precautions should people take around natural bodies of water?
+            Wen: Always wear a properly fitted, US Coast Guard–approved life jacket when boating. Of all the people who drowned while boating in 2022, 85% were not wearing a life jacket, according to the CDC.
+            To be safe, swim in areas where a lifeguard is on duty. Always follow lifeguard guidance about safety conditions, and stay in the area designated for swimming.
+            CNN: What about teaching children how to swim — can that help with water safety?
+            Wen: Yes. Kids ages 1 to 4 who took part in formal swim lessons had an 88% lower risk of drowning, according to a study in JAMA Pediatrics. The goal here isn’t necessarily to teach kids all the different strokes and get them to join a swim team; it’s to impart basic lifesaving skills, such as treading water and floating on their back.
+            When you are in the water with your children, take every opportunity to remind them about water safety. Other tips include never swimming alone, always asking for permission before entering the water and never diving into unknown bodies of water headfirst. Young children should also be reminded not to reach for items in the pool, as they are at risk of falling in; they should always ask for help instead.
+            Never leave children alone by the water, and remind them to ask for help if they want to reach something in the pool. travelism/E+/Getty Images
+            CNN: What about parents or guardians who don’t know how to swim? Do you recommend that they also take swim lessons?
+            Wen: Yes. First, adults who don’t know how to swim are more likely to have children who don’t know how to swim. This was the case for me. My parents didn’t swim, and I also never learned swimming growing up.
+            Second, it’s hard for adults to properly supervise children swimming if they can’t swim themselves. It was actually a terrifying experience with my own children that prompted me to learn to swim. My children were just 1 year and 3 years old one summer when my older kid pushed the younger one into the pool.
+            We were at our local community pool, and there was a lifeguard who immediately sprang into action. But I remember how terrified I felt — and how helpless. I enrolled my kids in swim lessons right away. I also found an instructor to teach me, too, because I realized I had to overcome my own fear of the water and learn basic water safety skills to protect my kids.
+            Learning how to swim as an adult is a humbling experience, especially for people like me who had to first start with overcoming fear. I began literally from zero. For weeks, I worked on just getting comfortable submerging my head underwater.
+            Eventually, I learned how to swim and now really enjoy being in the water. And I feel a lot more comfortable supervising my children when we are in private or community swimming spaces. I’m looking forward to our local pool opening for the summer and to spending time with my kids having a fun — and safe — time in the water.
+            """
+            print(f"Input (Long EN), num chars: {len(long_article_en)}")
+            summary_long_en_result = engine.summarize(long_article_en, overall_min_length=50, overall_max_length=200)
+            print(f"Result (Long EN): {summary_long_en_result}")
+
+
+        except Exception as e:
+            print(f"Failed to initialize or use Summarizer engine: {e}")
+            import traceback
+            traceback.print_exc()

test.py

@@ -0,0 +1,57 @@
+from transformers import pipeline, PegasusForConditionalGeneration, PegasusTokenizer
+
+def main():
+    model_name = "google/pegasus-cnn_dailymail"
+
+    try:
+        print(f"Loading tokenizer: {model_name}...")
+        tokenizer = PegasusTokenizer.from_pretrained(model_name)
+        print("Tokenizer loaded successfully!")
+
+        print(f"Loading model: {model_name}...")
+        model = PegasusForConditionalGeneration.from_pretrained(model_name)
+        print("Model loaded successfully!")
+        
+        print("Creating summarization pipeline...")
+        # use GPU (if it is available)
+        summarizer_pipeline = pipeline("summarization", model=model, tokenizer=tokenizer, device=0) 
+        print("Pipeline created successfully!")
+
+    except Exception as e:
+        print(f"Error during model/tokenizer loading or pipeline creation: {e}")
+        # Print more detailed error if possible
+        import traceback
+        traceback.print_exc()
+        return
+
+    article_text = """
+    Scientists have discovered a new species of glowing frog in the Amazon rainforest.
+    The frog, which has been named 'Luminos Hyalinobatrachium', emits a faint blue light
+    from its translucent skin. Researchers believe this bioluminescence might be used
+    for communication or camouflage in the dense jungle environment. The discovery
+    highlights the incredible biodiversity still being uncovered in the region and
+    underscores the importance of conservation efforts to protect these unique ecosystems.
+    Further studies are planned to understand the exact mechanism and purpose of the glow.
+    """
+
+    print("\nOriginal Article:")
+    print(article_text)
+
+    try:
+        print("\nGenerating summary...")
+        summary = summarizer_pipeline(article_text, max_length=60, min_length=20, do_sample=False)
+        
+        if summary and isinstance(summary, list) and 'summary_text' in summary[0]:
+            print("\nGenerated Summary:")
+            print(summary[0]['summary_text'])
+        else:
+            print("Could not generate summary or unexpected output format.")
+            print("Output from pipeline:", summary)
+
+    except Exception as e:
+        print(f"Error during summarization: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    main()