Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,36 @@
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt && \
+    pip install --no-cache-dir gunicorn==21.2.0
+
+# Copy application code
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p uploads logs
+
+# Download NLTK data
+RUN python -c "import nltk; nltk.download('punkt'); nltk.download('stopwords')"
+
+# Expose port for Hugging Face Spaces
+EXPOSE 7860
+
+# Set environment variables for Hugging Face Spaces
+ENV FLASK_ENV=production
+ENV PYTHONUNBUFFERED=1
+ENV PORT=7860
+
+# Run the application on port 7860 for Hugging Face Spaces
+CMD ["gunicorn", "--chdir", "webapp", "app:app", "--bind", "0.0.0.0:7860", "--timeout", "120", "--workers", "2"]

README.md

@@ -1,13 +1,65 @@
 ---
 title: Smart Summarizer
-emoji: 🏆
-colorFrom: yellow
-colorTo: gray
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
 sdk: docker
-sdk_version: 6.2.0
-app_file: app.py
 pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Smart Summarizer
+
+Professional text summarization using three state-of-the-art models:
+
+- **TextRank**: Fast extractive summarization (graph-based)
+- **BART**: High-quality abstractive summarization  
+- **PEGASUS**: Specialized abstractive model for summarization
+
+## Features
+
+- 📄 **Single Summary**: Generate summaries with individual models
+- ⚖️ **Comparison**: Compare all three models side-by-side
+- 📚 **Batch Processing**: Process multiple documents simultaneously
+- 📊 **Evaluation**: ROUGE metrics and performance insights
+- 📁 **File Support**: Upload .txt, .md, .pdf, .docx files
+
+## Models
+
+### TextRank (Extractive)
+- **Speed**: Very fast (~0.03s)
+- **Type**: Graph-based PageRank algorithm
+- **Best for**: Quick summaries, keyword extraction
+
+### BART (Abstractive)
+- **Speed**: Moderate (~9s on CPU)
+- **Type**: Transformer encoder-decoder
+- **Best for**: Fluent, human-like summaries
+
+### PEGASUS (Abstractive)
+- **Speed**: Moderate (~6s on CPU)
+- **Type**: Gap Sentence Generation pre-training
+- **Best for**: High-quality abstractive summaries
+
+## Usage
+
+1. Navigate to the web interface
+2. Choose between single summary or model comparison
+3. Input text directly or upload a supported file
+4. Select your preferred model(s)
+5. Generate and compare summaries
+
+## Supported File Types
+
+- Plain text (`.txt`, `.md`)
+- PDF documents (`.pdf`)
+- Word documents (`.docx`, `.doc`)
+
+## Author
+
+**Abdul Razzaq Ansari**
+
+## Links
+
+- [GitHub Repository](https://github.com/Rajak13/Smart-Summarizer)
+- [Documentation](https://github.com/Rajak13/Smart-Summarizer/blob/main/QUICK_START.md)

models/__init__.py

@@ -0,0 +1,29 @@
+"""
+Models package for text summarization
+Contains implementations of various summarization algorithms
+"""
+
+# Optional imports - import only what you need to avoid loading heavy dependencies
+__all__ = [
+    'BaseSummarizer',
+    'TextRankSummarizer',
+    'BARTSummarizer',
+    'PEGASUSSummarizer'
+]
+
+# Lazy imports - import classes when accessed via package
+def __getattr__(name):
+    if name == 'BaseSummarizer':
+        from .base_summarizer import BaseSummarizer
+        return BaseSummarizer
+    elif name == 'TextRankSummarizer':
+        from .textrank import TextRankSummarizer
+        return TextRankSummarizer
+    elif name == 'BARTSummarizer':
+        from .bart import BARTSummarizer
+        return BARTSummarizer
+    elif name == 'PEGASUSSummarizer':
+        from .pegasus import PEGASUSSummarizer
+        return PEGASUSSummarizer
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+

models/bart.py

@@ -0,0 +1,348 @@
+"""
+BART (Bidirectional and Auto-Regressive Transformers) Abstractive Summarization
+State-of-the-art sequence-to-sequence model for text generation
+Professional implementation with comprehensive features
+"""
+
+# Handle imports when running directly (python models/bart.py)
+# For proper package usage, run as: python -m models.bart
+import sys
+from pathlib import Path
+project_root = Path(__file__).parent.parent
+if str(project_root) not in sys.path:
+    sys.path.insert(0, str(project_root))
+
+from transformers import BartForConditionalGeneration, BartTokenizer
+import torch
+import logging
+from typing import Dict, List, Optional, Union
+from models.base_summarizer import BaseSummarizer
+
+logger = logging.getLogger(__name__)
+
+
+class BARTSummarizer(BaseSummarizer):
+    """
+    BART implementation for abstractive text summarization.
+    
+    Model Architecture:
+    - Encoder: Bidirectional transformer (like BERT)
+    - Decoder: Auto-regressive transformer (like GPT)
+    - Pre-trained on denoising tasks
+    
+    Key Features:
+    - Generates human-like, fluent summaries
+    - Can paraphrase and compress information
+    - Handles long documents effectively
+    - State-of-the-art performance on CNN/DailyMail
+    
+    Training Objective:
+    Trained to reconstruct original text from corrupted versions:
+    - Token masking
+    - Token deletion
+    - Sentence permutation
+    - Document rotation
+    
+    Mathematical Foundation:
+    Self-Attention: Attention(Q,K,V) = softmax(QK^T/√d_k)V
+    Where Q=Query, K=Key, V=Value, d_k=dimension of keys
+    """
+    
+    def __init__(self, 
+                 model_name: str = "facebook/bart-large-cnn",
+                 device: Optional[str] = None,
+                 use_fp16: bool = False):
+        """
+        Initialize BART Summarizer
+        
+        Args:
+            model_name: HuggingFace model identifier
+            device: Computing device ('cuda', 'cpu', or None for auto-detect)
+            use_fp16: Use 16-bit floating point for faster inference (requires GPU)
+        """
+        super().__init__(model_name="BART", model_type="Abstractive")
+        
+        logger.info(f"Loading BART model: {model_name}")
+        logger.info("Initial model loading may take 2-3 minutes...")
+        
+        # Determine device
+        if device is None:
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        else:
+            self.device = device
+        
+        logger.info(f"Using device: {self.device}")
+        if self.device == "cuda":
+            logger.info(f"GPU: {torch.cuda.get_device_name(0)}")
+            logger.info(f"GPU Memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.2f} GB")
+        
+        # Load tokenizer and model
+        try:
+            self.tokenizer = BartTokenizer.from_pretrained(model_name)
+            self.model = BartForConditionalGeneration.from_pretrained(model_name)
+            
+            # Move model to device
+            self.model.to(self.device)
+            
+            # Enable FP16 if requested and GPU available
+            if use_fp16 and self.device == "cuda":
+                self.model.half()
+                logger.info("Using FP16 precision for faster inference")
+            
+            # Set to evaluation mode
+            self.model.eval()
+            
+            self.model_name_full = model_name
+            self.is_initialized = True
+            
+            logger.info("BART model loaded successfully!")
+            
+        except Exception as e:
+            logger.error(f"Failed to load BART model: {e}")
+            raise
+    
+    def summarize(self,
+                  text: str,
+                  max_length: int = 150,
+                  min_length: int = 50,
+                  num_beams: int = 4,
+                  length_penalty: float = 2.0,
+                  no_repeat_ngram_size: int = 3,
+                  early_stopping: bool = True,
+                  do_sample: bool = False,
+                  temperature: float = 1.0,
+                  top_k: int = 50,
+                  top_p: float = 0.95) -> str:
+        """
+        Generate abstractive summary using BART
+        
+        Beam Search: Maintains top-k hypotheses at each step
+        Length Penalty: Exponential penalty applied to sequence length
+        
+        Args:
+            text: Input text to summarize
+            max_length: Maximum summary length in tokens
+            min_length: Minimum summary length in tokens
+            num_beams: Number of beams for beam search (higher = better quality, slower)
+            length_penalty: >1.0 favors longer sequences, <1.0 favors shorter
+            no_repeat_ngram_size: Prevent repetition of n-grams
+            early_stopping: Stop when num_beams hypotheses are complete
+            do_sample: Use sampling instead of greedy decoding
+            temperature: Sampling temperature (higher = more random)
+            top_k: Keep only top k tokens for sampling
+            top_p: Nucleus sampling threshold
+            
+        Returns:
+            Generated summary string
+        """
+        # Validate input
+        self.validate_input(text)
+        
+        # Tokenize input
+        inputs = self.tokenizer(
+            text,
+            max_length=1024,  # BART max input length
+            truncation=True,
+            padding="max_length",
+            return_tensors="pt"
+        )
+        
+        # Move to device
+        input_ids = inputs["input_ids"].to(self.device)
+        attention_mask = inputs["attention_mask"].to(self.device)
+        
+        # Generate summary
+        with torch.no_grad():
+            if do_sample:
+                # Sampling-based generation (more diverse)
+                summary_ids = self.model.generate(
+                    input_ids,
+                    attention_mask=attention_mask,
+                    max_length=max_length,
+                    min_length=min_length,
+                    do_sample=True,
+                    temperature=temperature,
+                    top_k=top_k,
+                    top_p=top_p,
+                    no_repeat_ngram_size=no_repeat_ngram_size,
+                    early_stopping=early_stopping
+                )
+            else:
+                # Beam search generation (more deterministic, higher quality)
+                summary_ids = self.model.generate(
+                    input_ids,
+                    attention_mask=attention_mask,
+                    max_length=max_length,
+                    min_length=min_length,
+                    num_beams=num_beams,
+                    length_penalty=length_penalty,
+                    no_repeat_ngram_size=no_repeat_ngram_size,
+                    early_stopping=early_stopping
+                )
+        
+        # Decode summary
+        summary = self.tokenizer.decode(
+            summary_ids[0],
+            skip_special_tokens=True,
+            clean_up_tokenization_spaces=True
+        )
+        
+        return summary
+    
+    def batch_summarize(self,
+                       texts: List[str],
+                       batch_size: int = 4,
+                       max_length: int = 150,
+                       min_length: int = 50,
+                       **kwargs) -> List[str]:
+        """
+        Efficiently summarize multiple texts in batches
+        
+        Args:
+            texts: List of texts to summarize
+            batch_size: Number of texts to process simultaneously
+            max_length: Maximum summary length
+            min_length: Minimum summary length
+            **kwargs: Additional generation parameters
+            
+        Returns:
+            List of generated summaries
+        """
+        logger.info(f"Batch summarizing {len(texts)} texts (batch_size={batch_size})")
+        
+        summaries = []
+        
+        # Process in batches
+        for i in range(0, len(texts), batch_size):
+            batch = texts[i:i + batch_size]
+            
+            # Tokenize batch
+            inputs = self.tokenizer(
+                batch,
+                max_length=1024,
+                truncation=True,
+                padding=True,
+                return_tensors="pt"
+            )
+            
+            input_ids = inputs["input_ids"].to(self.device)
+            attention_mask = inputs["attention_mask"].to(self.device)
+            
+            # Generate summaries for batch
+            with torch.no_grad():
+                summary_ids = self.model.generate(
+                    input_ids,
+                    attention_mask=attention_mask,
+                    max_length=max_length,
+                    min_length=min_length,
+                    num_beams=kwargs.get('num_beams', 4),
+                    early_stopping=True
+                )
+            
+            # Decode summaries
+            batch_summaries = [
+                self.tokenizer.decode(ids, skip_special_tokens=True)
+                for ids in summary_ids
+            ]
+            
+            summaries.extend(batch_summaries)
+            
+            logger.info(f"Processed batch {i//batch_size + 1}/{(len(texts)-1)//batch_size + 1}")
+        
+        return summaries
+    
+    def get_model_info(self) -> Dict:
+        """Return comprehensive model information"""
+        info = super().get_model_info()
+        info.update({
+            'algorithm': 'Transformer Encoder-Decoder',
+            'architecture': {
+                'encoder': 'Bidirectional (BERT-like)',
+                'decoder': 'Auto-regressive (GPT-like)',
+                'layers': '12 encoder + 12 decoder',
+                'attention_heads': 16,
+                'hidden_size': 1024,
+                'parameters': '406M'
+            },
+            'training': {
+                'objective': 'Denoising autoencoder',
+                'noise_functions': [
+                    'Token masking',
+                    'Token deletion',
+                    'Sentence permutation',
+                    'Document rotation'
+                ],
+                'dataset': 'Large-scale web text + CNN/DailyMail fine-tuning'
+            },
+            'performance': {
+                'rouge_1': '44.16',
+                'rouge_2': '21.28',
+                'rouge_l': '40.90',
+                'benchmark': 'CNN/DailyMail test set'
+            },
+            'advantages': [
+                'Generates fluent, human-like summaries',
+                'Can paraphrase and compress effectively',
+                'Handles long documents well',
+                'State-of-the-art performance'
+            ],
+            'limitations': [
+                'May introduce factual errors',
+                'Computationally intensive',
+                'Requires GPU for fast inference',
+                'Black-box nature (less interpretable)'
+            ]
+        })
+        return info
+    
+    def __del__(self):
+        """Cleanup GPU memory when object is destroyed"""
+        if hasattr(self, 'device') and self.device == 'cuda':
+            torch.cuda.empty_cache()
+
+
+# Test the implementation
+if __name__ == "__main__":
+    sample_text = """
+    Machine learning has revolutionized artificial intelligence in recent years. 
+    Deep learning neural networks can now perform tasks that were impossible just 
+    a decade ago. Computer vision systems can recognize objects in images with 
+    superhuman accuracy. Natural language processing models can generate human-like 
+    text and translate between languages. Reinforcement learning has enabled AI 
+    to master complex games like Go and StarCraft. These advances have been driven 
+    by increases in computing power, availability of large datasets, and algorithmic 
+    innovations. However, challenges remain in areas like explainability, fairness, 
+    and robustness. The field continues to evolve rapidly with new breakthroughs 
+    occurring regularly.
+    """
+    
+    print("=" * 70)
+    print("BART SUMMARIZER - PROFESSIONAL TEST")
+    print("=" * 70)
+    
+    # Initialize summarizer
+    summarizer = BARTSummarizer()
+    
+    # Generate summary with metrics
+    result = summarizer.summarize_with_metrics(
+        sample_text,
+        max_length=100,
+        min_length=30,
+        num_beams=4
+    )
+    
+    print(f"\nModel: {result['metadata']['model_name']}")
+    print(f"Type: {result['metadata']['model_type']}")
+    print(f"Device: {summarizer.device}")
+    print(f"Input Length: {result['metadata']['input_length']} words")
+    print(f"Summary Length: {result['metadata']['summary_length']} words")
+    print(f"Compression Ratio: {result['metadata']['compression_ratio']:.2%}")
+    print(f"Processing Time: {result['metadata']['processing_time']:.4f} seconds")
+    
+    print(f"\n{'Generated Summary:':-^70}")
+    print(result['summary'])
+    
+    print("\n" + "=" * 70)
+    model_info = summarizer.get_model_info()
+    print(f"Architecture: {model_info['architecture']}")
+    print(f"Performance: {model_info['performance']}")

models/base_summarizer.py

@@ -0,0 +1,221 @@
+"""
+Base Summarizer Class
+Defines the interface for all summarization models
+Implements Strategy Design Pattern for interchangeable algorithms
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional, List
+import time
+import logging
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class BaseSummarizer(ABC):
+    """
+    Abstract base class for all summarization models.
+    Implements common functionality and defines interface.
+    
+    Design Pattern: Strategy Pattern
+    - Allows switching between different summarization algorithms
+    - Ensures consistent interface across models
+    """
+    
+    def __init__(self, model_name: str, model_type: str):
+        """
+        Initialize base summarizer
+        
+        Args:
+            model_name: Name of the model (e.g., "TextRank", "BART")
+            model_type: Type of summarization ("Extractive" or "Abstractive")
+        """
+        self.model_name = model_name
+        self.model_type = model_type
+        self.is_initialized = False
+        self.stats = {
+            'total_summarizations': 0,
+            'total_processing_time': 0.0,
+            'average_processing_time': 0.0
+        }
+        logger.info(f"Initializing {model_name} ({model_type}) summarizer")
+    
+    @abstractmethod
+    def summarize(self, text: str, **kwargs) -> str:
+        """
+        Generate summary from input text.
+        Must be implemented by all subclasses.
+        
+        Args:
+            text: Input text to summarize
+            **kwargs: Additional parameters specific to each model
+            
+        Returns:
+            Generated summary string
+        """
+        pass
+    
+    def summarize_with_metrics(self, text: str, **kwargs) -> Dict[str, Any]:
+        """
+        Summarize text and return detailed metrics
+        
+        Args:
+            text: Input text to summarize
+            **kwargs: Model-specific parameters
+            
+        Returns:
+            Dictionary containing summary and metadata
+        """
+        start_time = time.time()
+        
+        # Generate summary
+        summary = self.summarize(text, **kwargs)
+        
+        # Calculate metrics
+        processing_time = time.time() - start_time
+        self._update_stats(processing_time)
+        
+        return {
+            'summary': summary,
+            'metadata': {
+                'model_name': self.model_name,
+                'model_type': self.model_type,
+                'processing_time': processing_time,
+                'input_length': len(text.split()),
+                'summary_length': len(summary.split()),
+                'compression_ratio': len(summary.split()) / len(text.split()) if len(text.split()) > 0 else 0,
+                'timestamp': time.strftime('%Y-%m-%d %H:%M:%S')
+            }
+        }
+    
+    def batch_summarize(self, texts: List[str], **kwargs) -> List[Dict[str, Any]]:
+        """
+        Summarize multiple texts
+        
+        Args:
+            texts: List of texts to summarize
+            **kwargs: Model-specific parameters
+            
+        Returns:
+            List of dictionaries with summaries and metadata
+        """
+        logger.info(f"Batch summarizing {len(texts)} texts with {self.model_name}")
+        results = []
+        
+        for idx, text in enumerate(texts):
+            logger.info(f"Processing text {idx + 1}/{len(texts)}")
+            result = self.summarize_with_metrics(text, **kwargs)
+            result['metadata']['batch_index'] = idx
+            results.append(result)
+        
+        return results
+    
+    def _update_stats(self, processing_time: float):
+        """Update internal statistics"""
+        self.stats['total_summarizations'] += 1
+        self.stats['total_processing_time'] += processing_time
+        self.stats['average_processing_time'] = (
+            self.stats['total_processing_time'] / self.stats['total_summarizations']
+        )
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        """
+        Get detailed model information
+        
+        Returns:
+            Dictionary with model specifications
+        """
+        return {
+            'name': self.model_name,
+            'type': self.model_type,
+            'statistics': self.stats.copy(),
+            'is_initialized': self.is_initialized
+        }
+    
+    def reset_stats(self):
+        """Reset usage statistics"""
+        self.stats = {
+            'total_summarizations': 0,
+            'total_processing_time': 0.0,
+            'average_processing_time': 0.0
+        }
+        logger.info(f"Statistics reset for {self.model_name}")
+    
+    def validate_input(self, text: str, min_length: int = 10) -> bool:
+        """
+        Validate input text
+        
+        Args:
+            text: Input text
+            min_length: Minimum number of words required
+            
+        Returns:
+            Boolean indicating if input is valid
+            
+        Raises:
+            ValueError: If input is invalid
+        """
+        if not text or not isinstance(text, str):
+            raise ValueError("Input text must be a non-empty string")
+        
+        word_count = len(text.split())
+        if word_count < min_length:
+            raise ValueError(
+                f"Input text too short. Minimum {min_length} words required, got {word_count}"
+            )
+        
+        return True
+    
+    def __repr__(self) -> str:
+        """String representation of the summarizer"""
+        return (f"{self.__class__.__name__}(model_name='{self.model_name}', "
+                f"model_type='{self.model_type}', "
+                f"total_summarizations={self.stats['total_summarizations']})")
+
+
+class SummarizerFactory:
+    """
+    Factory Pattern for creating summarizer instances
+    Centralizes model instantiation logic
+    """
+    
+    _models = {}
+    
+    @classmethod
+    def register_model(cls, model_class, name: str):
+        """Register a new summarizer model"""
+        cls._models[name.lower()] = model_class
+        logger.info(f"Registered model: {name}")
+    
+    @classmethod
+    def create_summarizer(cls, model_name: str, **kwargs):
+        """
+        Create a summarizer instance
+        
+        Args:
+            model_name: Name of the model to create
+            **kwargs: Model-specific initialization parameters
+            
+        Returns:
+            Instance of requested summarizer
+            
+        Raises:
+            ValueError: If model not found
+        """
+        model_name_lower = model_name.lower()
+        
+        if model_name_lower not in cls._models:
+            available = ', '.join(cls._models.keys())
+            raise ValueError(
+                f"Model '{model_name}' not found. Available models: {available}"
+            )
+        
+        model_class = cls._models[model_name_lower]
+        return model_class(**kwargs)
+    
+    @classmethod
+    def list_available_models(cls) -> List[str]:
+        """Get list of available models"""
+        return list(cls._models.keys())

models/pegasus.py

@@ -0,0 +1,384 @@
+"""
+PEGASUS (Pre-training with Extracted Gap-sentences for Abstractive SUmmarization)
+State-of-the-art model specifically designed for summarization tasks
+Professional implementation with Gap Sentence Generation pre-training
+"""
+
+# Handle imports when running directly (python models/pegasus.py)
+# For proper package usage, run as: python -m models.pegasus
+import sys
+from pathlib import Path
+project_root = Path(__file__).parent.parent
+if str(project_root) not in sys.path:
+    sys.path.insert(0, str(project_root))
+
+from transformers import PegasusForConditionalGeneration, PegasusTokenizer
+import torch
+import logging
+from typing import Dict, List, Optional
+from models.base_summarizer import BaseSummarizer
+
+logger = logging.getLogger(__name__)
+
+
+class PEGASUSSummarizer(BaseSummarizer):
+    """
+    PEGASUS implementation for abstractive text summarization.
+    
+    Innovation: Gap Sentence Generation (GSG)
+    - Pre-training task: Predict important missing sentences
+    - Directly aligned with summarization objective
+    - Superior transfer learning for summarization
+    
+    Model Architecture:
+    - Transformer encoder-decoder (16 layers each)
+    - Pre-trained on C4 and HugeNews datasets
+    - Fine-tuned on domain-specific summarization data
+    
+    Key Advantages:
+    - Highest ROUGE scores on multiple benchmarks
+    - Excellent zero-shot and few-shot capabilities
+    - Generates highly coherent summaries
+    - Handles long documents effectively
+    
+    Performance Highlights (CNN/DailyMail):
+    - ROUGE-1: 44.17
+    - ROUGE-2: 21.47
+    - ROUGE-L: 41.11
+    
+    Mathematical Foundation:
+    Sentence Importance: ROUGE-F1(Si, D\Si)
+    Where Si = sentence i, D\Si = document without sentence i
+    """
+    
+    def __init__(self,
+                 model_name: str = "google/pegasus-cnn_dailymail",
+                 device: Optional[str] = None,
+                 use_fp16: bool = False):
+        """
+        Initialize PEGASUS Summarizer
+        
+        Args:
+            model_name: HuggingFace model identifier
+                       Options: 'google/pegasus-cnn_dailymail' (recommended)
+                               'google/pegasus-xsum' (for extreme summarization)
+                               'google/pegasus-large' (base model)
+            device: Computing device ('cuda', 'cpu', or None for auto-detect)
+            use_fp16: Use 16-bit floating point for faster inference
+        """
+        super().__init__(model_name="PEGASUS", model_type="Abstractive")
+        
+        logger.info(f"Loading PEGASUS model: {model_name}")
+        logger.info("PEGASUS is a large model. Initial loading may take 3-5 minutes...")
+        
+        # Determine device
+        if device is None:
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        else:
+            self.device = device
+        
+        logger.info(f"Using device: {self.device}")
+        
+        # Load tokenizer and model
+        try:
+            logger.info("Loading tokenizer...")
+            self.tokenizer = PegasusTokenizer.from_pretrained(model_name)
+            
+            logger.info("Loading model weights...")
+            self.model = PegasusForConditionalGeneration.from_pretrained(model_name)
+            
+            # Move to device
+            self.model.to(self.device)
+            
+            # Enable FP16 if requested
+            if use_fp16 and self.device == "cuda":
+                self.model.half()
+                logger.info("Using FP16 precision")
+            
+            # Set to evaluation mode
+            self.model.eval()
+            
+            self.model_name_full = model_name
+            self.is_initialized = True
+            
+            # Get model configuration
+            self.config = self.model.config
+            
+            logger.info("PEGASUS model loaded successfully!")
+            logger.info(f"Model size: {self._count_parameters() / 1e6:.1f}M parameters")
+            
+        except Exception as e:
+            logger.error(f"Failed to load PEGASUS model: {e}")
+            raise
+    
+    def _count_parameters(self) -> int:
+        """Count total number of trainable parameters"""
+        return sum(p.numel() for p in self.model.parameters() if p.requires_grad)
+    
+    def summarize(self,
+                  text: str,
+                  max_length: int = 128,
+                  min_length: int = 32,
+                  num_beams: int = 4,
+                  length_penalty: float = 2.0,
+                  no_repeat_ngram_size: int = 3,
+                  early_stopping: bool = True,
+                  do_sample: bool = False,
+                  temperature: float = 1.0) -> str:
+        """
+        Generate abstractive summary using PEGASUS
+        
+        PEGASUS uses special tokens:
+        - <pad>: Padding token (also used as decoder start token)
+        - </s>: End of sequence token
+        - <unk>: Unknown token
+        - <mask_1>, <mask_2>: Gap sentence masks
+        
+        Args:
+            text: Input text to summarize
+            max_length: Maximum summary length in tokens (PEGASUS optimal: 128)
+            min_length: Minimum summary length in tokens
+            num_beams: Beam search width (4-8 recommended)
+            length_penalty: Controls summary length (>1.0 = longer)
+            no_repeat_ngram_size: Prevent n-gram repetition
+            early_stopping: Stop when beams complete
+            do_sample: Use sampling instead of beam search
+            temperature: Sampling randomness (lower = more deterministic)
+            
+        Returns:
+            Generated summary string
+        """
+        # Validate input
+        self.validate_input(text)
+        
+        # Tokenize input
+        inputs = self.tokenizer(
+            text,
+            max_length=1024,  # PEGASUS max input
+            truncation=True,
+            padding="max_length",
+            return_tensors="pt"
+        )
+        
+        # Move to device
+        input_ids = inputs["input_ids"].to(self.device)
+        attention_mask = inputs["attention_mask"].to(self.device)
+        
+        # Generate summary
+        with torch.no_grad():
+            if do_sample:
+                # Sampling-based generation
+                summary_ids = self.model.generate(
+                    input_ids,
+                    attention_mask=attention_mask,
+                    max_length=max_length,
+                    min_length=min_length,
+                    do_sample=True,
+                    temperature=temperature,
+                    top_k=50,
+                    top_p=0.95,
+                    no_repeat_ngram_size=no_repeat_ngram_size
+                )
+            else:
+                # Beam search generation (recommended for PEGASUS)
+                summary_ids = self.model.generate(
+                    input_ids,
+                    attention_mask=attention_mask,
+                    max_length=max_length,
+                    min_length=min_length,
+                    num_beams=num_beams,
+                    length_penalty=length_penalty,
+                    no_repeat_ngram_size=no_repeat_ngram_size,
+                    early_stopping=early_stopping
+                )
+        
+        # Decode summary
+        summary = self.tokenizer.decode(
+            summary_ids[0],
+            skip_special_tokens=True,
+            clean_up_tokenization_spaces=True
+        )
+        
+        return summary
+    
+    def batch_summarize(self,
+                       texts: List[str],
+                       batch_size: int = 2,
+                       max_length: int = 128,
+                       **kwargs) -> List[str]:
+        """
+        Batch summarization (PEGASUS is large, use smaller batches)
+        
+        Args:
+            texts: List of texts to summarize
+            batch_size: Texts per batch (2-4 recommended for PEGASUS)
+            max_length: Maximum summary length
+            **kwargs: Additional generation parameters
+            
+        Returns:
+            List of generated summaries
+        """
+        logger.info(f"Batch summarizing {len(texts)} texts (batch_size={batch_size})")
+        
+        summaries = []
+        
+        for i in range(0, len(texts), batch_size):
+            batch = texts[i:i + batch_size]
+            
+            # Tokenize
+            inputs = self.tokenizer(
+                batch,
+                max_length=1024,
+                truncation=True,
+                padding=True,
+                return_tensors="pt"
+            )
+            
+            input_ids = inputs["input_ids"].to(self.device)
+            attention_mask = inputs["attention_mask"].to(self.device)
+            
+            # Generate
+            with torch.no_grad():
+                summary_ids = self.model.generate(
+                    input_ids,
+                    attention_mask=attention_mask,
+                    max_length=max_length,
+                    num_beams=kwargs.get('num_beams', 4),
+                    length_penalty=kwargs.get('length_penalty', 2.0),
+                    early_stopping=True
+                )
+            
+            # Decode
+            batch_summaries = [
+                self.tokenizer.decode(ids, skip_special_tokens=True)
+                for ids in summary_ids
+            ]
+            
+            summaries.extend(batch_summaries)
+            
+            logger.info(f"Completed batch {i//batch_size + 1}/{(len(texts)-1)//batch_size + 1}")
+        
+        return summaries
+    
+    def get_model_info(self) -> Dict:
+        """Return comprehensive model information"""
+        info = super().get_model_info()
+        info.update({
+            'algorithm': 'Gap Sentence Generation (GSG) + Transformer',
+            'innovation': 'Pre-training specifically designed for summarization',
+            'architecture': {
+                'encoder_layers': 16,
+                'decoder_layers': 16,
+                'attention_heads': 16,
+                'hidden_size': 1024,
+                'parameters': f'{self._count_parameters() / 1e6:.1f}M',
+                'vocabulary_size': self.tokenizer.vocab_size
+            },
+            'pre_training': {
+                'objective': 'Gap Sentence Generation (GSG)',
+                'method': 'Mask and predict important sentences',
+                'datasets': ['C4 corpus', 'HugeNews dataset'],
+                'sentence_selection': 'ROUGE-based importance scoring'
+            },
+            'fine_tuning': {
+                'dataset': 'CNN/DailyMail',
+                'task': 'Abstractive summarization'
+            },
+            'performance': {
+                'rouge_1': '44.17',
+                'rouge_2': '21.47',
+                'rouge_l': '41.11',
+                'benchmark': 'CNN/DailyMail test set',
+                'ranking': 'State-of-the-art (as of 2020)'
+            },
+            'advantages': [
+                'Highest ROUGE scores on benchmarks',
+                'Excellent zero-shot performance',
+                'Generates highly coherent summaries',
+                'Pre-training aligned with summarization',
+                'Strong transfer learning capabilities'
+            ],
+            'limitations': [
+                'Very large model (high memory requirements)',
+                'Slower inference than smaller models',
+                'May hallucinate facts',
+                'Less interpretable (black-box)',
+                'Requires powerful GPU for real-time use'
+            ],
+            'optimal_use_cases': [
+                'High-quality abstractive summaries needed',
+                'News article summarization',
+                'Long document summarization',
+                'Multi-document summarization',
+                'Research paper abstracts'
+            ]
+        })
+        return info
+    
+    def get_special_tokens(self) -> Dict:
+        """Get information about special tokens"""
+        return {
+            'pad_token': self.tokenizer.pad_token,
+            'eos_token': self.tokenizer.eos_token,
+            'unk_token': self.tokenizer.unk_token,
+            'mask_token': self.tokenizer.mask_token,
+            'vocab_size': self.tokenizer.vocab_size
+        }
+    
+    def __del__(self):
+        """Cleanup GPU memory"""
+        if hasattr(self, 'device') and self.device == 'cuda':
+            torch.cuda.empty_cache()
+            logger.info("Cleared GPU cache")
+
+
+# Test the implementation
+if __name__ == "__main__":
+    sample_text = """
+    Climate change poses one of the greatest challenges to humanity in the 21st century.
+    Rising global temperatures are causing ice caps to melt and sea levels to rise.
+    Extreme weather events like hurricanes, droughts, and floods are becoming more frequent.
+    Scientists warn that without immediate action, the consequences could be catastrophic.
+    Renewable energy sources like solar and wind power offer sustainable alternatives to
+    fossil fuels. Many countries have committed to reducing carbon emissions through the
+    Paris Agreement. However, implementing these changes requires unprecedented international
+    cooperation and technological innovation. The transition to a green economy will create
+    new jobs while protecting the environment for future generations.
+    """
+    
+    print("=" * 70)
+    print("PEGASUS SUMMARIZER - PROFESSIONAL TEST")
+    print("=" * 70)
+    
+    # Initialize summarizer
+    summarizer = PEGASUSSummarizer()
+    
+    # Generate summary with metrics
+    result = summarizer.summarize_with_metrics(
+        sample_text,
+        max_length=100,
+        min_length=30,
+        num_beams=4,
+        length_penalty=2.0
+    )
+    
+    print(f"\nModel: {result['metadata']['model_name']}")
+    print(f"Type: {result['metadata']['model_type']}")
+    print(f"Device: {summarizer.device}")
+    print(f"Input Length: {result['metadata']['input_length']} words")
+    print(f"Summary Length: {result['metadata']['summary_length']} words")
+    print(f"Compression Ratio: {result['metadata']['compression_ratio']:.2%}")
+    print(f"Processing Time: {result['metadata']['processing_time']:.4f} seconds")
+    
+    print(f"\n{'Generated Summary:':-^70}")
+    print(result['summary'])
+    
+    print(f"\n{'Model Architecture:':-^70}")
+    model_info = summarizer.get_model_info()
+    print(f"Parameters: {model_info['architecture']['parameters']}")
+    print(f"Pre-training: {model_info['pre_training']['objective']}")
+    print(f"Performance (CNN/DM): ROUGE-1={model_info['performance']['rouge_1']}, "
+          f"ROUGE-2={model_info['performance']['rouge_2']}, "
+          f"ROUGE-L={model_info['performance']['rouge_l']}")
+    
+    print("\n" + "=" * 70)

models/textrank.py

@@ -0,0 +1,366 @@
+"""
+TextRank Extractive Summarization
+Graph-based ranking algorithm inspired by PageRank
+Professional implementation with extensive documentation
+"""
+
+# Handle imports when running directly (python models/textrank.py)
+# For proper package usage, run as: python -m models.textrank
+import sys
+from pathlib import Path
+project_root = Path(__file__).parent.parent
+if str(project_root) not in sys.path:
+    sys.path.insert(0, str(project_root))
+
+import numpy as np
+import networkx as nx
+from nltk.tokenize import sent_tokenize, word_tokenize
+from nltk.corpus import stopwords
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+import logging
+from typing import Dict, List, Tuple, Optional
+from models.base_summarizer import BaseSummarizer
+
+# Setup logging
+logger = logging.getLogger(__name__)
+
+
+class TextRankSummarizer(BaseSummarizer):
+    """
+    TextRank implementation for extractive text summarization.
+    
+    Algorithm Overview:
+    1. Split text into sentences
+    2. Create TF-IDF vectors for each sentence
+    3. Calculate cosine similarity between all sentence pairs
+    4. Build weighted graph (sentences as nodes, similarities as edges)
+    5. Apply PageRank algorithm to rank sentences
+    6. Select top-ranked sentences for summary
+    
+    Advantages:
+    - Fast and efficient (no neural networks)
+    - Language-agnostic (works on any language)
+    - Interpretable results
+    - No training required
+    
+    Limitations:
+    - Cannot generate new sentences
+    - May select redundant information
+    - Limited semantic understanding
+    """
+    
+    def __init__(self, 
+                 damping: float = 0.85,
+                 max_iter: int = 100,
+                 tol: float = 1e-4,
+                 summary_ratio: float = 0.3,
+                 min_sentence_length: int = 5):
+        """
+        Initialize TextRank Summarizer
+        
+        Args:
+            damping: PageRank damping factor (0-1). Higher = more weight to neighbors
+            max_iter: Maximum iterations for PageRank convergence
+            tol: Convergence tolerance for PageRank
+            summary_ratio: Proportion of sentences to include (0-1)
+            min_sentence_length: Minimum words per sentence to consider
+        """
+        super().__init__(model_name="TextRank", model_type="Extractive")
+        
+        self.damping = damping
+        self.max_iter = max_iter
+        self.tol = tol
+        self.summary_ratio = summary_ratio
+        self.min_sentence_length = min_sentence_length
+        
+        # Initialize stopwords
+        try:
+            self.stop_words = set(stopwords.words('english'))
+        except LookupError:
+            logger.warning("NLTK stopwords not found. Downloading...")
+            import nltk
+            nltk.download('stopwords')
+            self.stop_words = set(stopwords.words('english'))
+        
+        self.is_initialized = True
+        logger.info("TextRank summarizer initialized successfully")
+    
+    def preprocess(self, text: str) -> Tuple[List[str], List[str]]:
+        """
+        Preprocess text into sentences
+        
+        Args:
+            text: Input text string
+            
+        Returns:
+            Tuple of (original_sentences, cleaned_sentences)
+        """
+        # Split into sentences
+        sentences = sent_tokenize(text)
+        
+        # Filter out very short sentences
+        filtered_sentences = [
+            s for s in sentences 
+            if len(s.split()) >= self.min_sentence_length
+        ]
+        
+        if not filtered_sentences:
+            filtered_sentences = sentences  # Keep all if filtering removes everything
+        
+        # Clean sentences for similarity calculation
+        cleaned_sentences = []
+        for sent in filtered_sentences:
+            # Tokenize and lowercase
+            words = word_tokenize(sent.lower())
+            # Remove stopwords and non-alphanumeric tokens
+            words = [w for w in words if w.isalnum() and w not in self.stop_words]
+            cleaned_sentences.append(' '.join(words))
+        
+        return filtered_sentences, cleaned_sentences
+    
+    def build_similarity_matrix(self, sentences: List[str]) -> np.ndarray:
+        """
+        Build sentence similarity matrix using TF-IDF and cosine similarity
+        
+        Mathematical Foundation:
+        - TF-IDF: Term Frequency-Inverse Document Frequency
+        - Cosine Similarity: cos(θ) = (A·B) / (||A|| × ||B||)
+        
+        Args:
+            sentences: List of cleaned sentences
+            
+        Returns:
+            Similarity matrix (numpy array) of shape [n_sentences, n_sentences]
+        """
+        # Edge case handling
+        n_sentences = len(sentences)
+        if n_sentences < 2:
+            return np.zeros((n_sentences, n_sentences))
+        
+        # Remove empty sentences
+        valid_sentences = [s for s in sentences if s.strip()]
+        if not valid_sentences:
+            return np.zeros((n_sentences, n_sentences))
+        
+        try:
+            # Create TF-IDF vectors
+            vectorizer = TfidfVectorizer(
+                max_features=1000,  # Limit features for efficiency
+                ngram_range=(1, 2)  # Use unigrams and bigrams
+            )
+            tfidf_matrix = vectorizer.fit_transform(valid_sentences)
+            
+            # Calculate cosine similarity
+            similarity_matrix = cosine_similarity(tfidf_matrix)
+            
+            # Set diagonal to 0 (sentence shouldn't be similar to itself)
+            np.fill_diagonal(similarity_matrix, 0)
+            
+            return similarity_matrix
+            
+        except ValueError as e:
+            logger.error(f"Error building similarity matrix: {e}")
+            return np.zeros((n_sentences, n_sentences))
+    
+    def calculate_pagerank(self, similarity_matrix: np.ndarray) -> Dict[int, float]:
+        """
+        Apply PageRank algorithm to rank sentences
+        
+        PageRank Formula:
+        WS(Vi) = (1-d) + d × Σ(wji / Σwjk) × WS(Vj)
+        
+        Where:
+        - WS(Vi) = Score of sentence i
+        - d = damping factor
+        - wji = weight of edge from sentence j to i
+        
+        Args:
+            similarity_matrix: Sentence similarity matrix
+            
+        Returns:
+            Dictionary mapping sentence index to score
+        """
+        # Create graph from similarity matrix
+        nx_graph = nx.from_numpy_array(similarity_matrix)
+        
+        try:
+            # Calculate PageRank scores
+            scores = nx.pagerank(
+                nx_graph,
+                alpha=self.damping,  # damping factor
+                max_iter=self.max_iter,
+                tol=self.tol
+            )
+            return scores
+            
+        except Exception as e:
+            logger.error(f"PageRank calculation failed: {e}")
+            # Return uniform scores as fallback
+            n_nodes = similarity_matrix.shape[0]
+            return {i: 1.0/n_nodes for i in range(n_nodes)}
+    
+    def summarize(self, 
+                  text: str, 
+                  num_sentences: Optional[int] = None,
+                  return_scores: bool = False) -> str:
+        """
+        Generate extractive summary using TextRank
+        
+        Args:
+            text: Input text to summarize
+            num_sentences: Number of sentences in summary (overrides ratio)
+            return_scores: If True, return tuple of (summary, scores)
+            
+        Returns:
+            Summary string, or tuple of (summary, scores) if return_scores=True
+        """
+        # Validate input
+        self.validate_input(text)
+        
+        # Preprocess
+        original_sentences, cleaned_sentences = self.preprocess(text)
+        
+        # Edge cases
+        if len(original_sentences) == 0:
+            return "" if not return_scores else ("", {})
+        if len(original_sentences) == 1:
+            summary = original_sentences[0]
+            return summary if not return_scores else (summary, {0: 1.0})
+        
+        # Build similarity matrix
+        similarity_matrix = self.build_similarity_matrix(cleaned_sentences)
+        
+        # Calculate sentence scores using PageRank
+        scores = self.calculate_pagerank(similarity_matrix)
+        
+        # Determine number of sentences for summary
+        if num_sentences is None:
+            num_sentences = max(1, int(len(original_sentences) * self.summary_ratio))
+        num_sentences = min(num_sentences, len(original_sentences))
+        
+        # Rank sentences by score
+        ranked_sentences = sorted(
+            ((scores[i], i, s) for i, s in enumerate(original_sentences)),
+            reverse=True
+        )
+        
+        # Select top sentences and maintain original order
+        top_sentences = sorted(
+            ranked_sentences[:num_sentences],
+            key=lambda x: x[1]  # Sort by original position
+        )
+        
+        # Build summary
+        summary = ' '.join([sent for _, _, sent in top_sentences])
+        
+        if return_scores:
+            return summary, {
+                'sentence_scores': scores,
+                'selected_indices': [idx for _, idx, _ in top_sentences],
+                'num_sentences_original': len(original_sentences),
+                'num_sentences_summary': num_sentences
+            }
+        
+        return summary
+    
+    def get_sentence_importance(self, text: str) -> List[Tuple[str, float]]:
+        """
+        Get all sentences with their importance scores
+        
+        Args:
+            text: Input text
+            
+        Returns:
+            List of (sentence, score) tuples sorted by importance
+        """
+        original_sentences, cleaned_sentences = self.preprocess(text)
+        
+        if len(original_sentences) < 2:
+            return [(s, 1.0) for s in original_sentences]
+        
+        similarity_matrix = self.build_similarity_matrix(cleaned_sentences)
+        scores = self.calculate_pagerank(similarity_matrix)
+        
+        # Combine sentences with scores
+        sentence_importance = [
+            (original_sentences[i], scores[i])
+            for i in range(len(original_sentences))
+        ]
+        
+        # Sort by importance
+        sentence_importance.sort(key=lambda x: x[1], reverse=True)
+        
+        return sentence_importance
+    
+    def get_model_info(self) -> Dict:
+        """Return detailed model information"""
+        info = super().get_model_info()
+        info.update({
+            'algorithm': 'Graph-based PageRank',
+            'parameters': {
+                'damping_factor': self.damping,
+                'max_iterations': self.max_iter,
+                'tolerance': self.tol,
+                'summary_ratio': self.summary_ratio,
+                'min_sentence_length': self.min_sentence_length
+            },
+            'complexity': 'O(V²) where V = number of sentences',
+            'advantages': [
+                'Fast and efficient',
+                'No training required',
+                'Language-agnostic',
+                'Interpretable results'
+            ],
+            'limitations': [
+                'Cannot generate new sentences',
+                'Limited semantic understanding',
+                'May miss context'
+            ]
+        })
+        return info
+
+
+# Test the implementation
+if __name__ == "__main__":
+    # Sample academic text
+    sample_text = """
+    Artificial intelligence has become one of the most transformative technologies 
+    of the 21st century. Machine learning, a subset of AI, enables computers to 
+    learn from data without explicit programming. Deep learning uses neural networks 
+    with multiple layers to process complex patterns. Natural language processing 
+    allows machines to understand and generate human language. Computer vision enables 
+    machines to interpret visual information from the world. AI applications span 
+    healthcare, finance, education, transportation, and entertainment. Ethical 
+    considerations around AI include privacy, bias, and job displacement. The future 
+    of AI promises both unprecedented opportunities and significant challenges that 
+    society must navigate carefully.
+    """
+    
+    # Initialize summarizer
+    summarizer = TextRankSummarizer(summary_ratio=0.3)
+    
+    print("=" * 70)
+    print("TEXTRANK SUMMARIZER - PROFESSIONAL TEST")
+    print("=" * 70)
+    
+    # Generate summary with metrics
+    result = summarizer.summarize_with_metrics(sample_text)
+    
+    print(f"\nModel: {result['metadata']['model_name']}")
+    print(f"Type: {result['metadata']['model_type']}")
+    print(f"Input Length: {result['metadata']['input_length']} words")
+    print(f"Summary Length: {result['metadata']['summary_length']} words")
+    print(f"Compression Ratio: {result['metadata']['compression_ratio']:.2%}")
+    print(f"Processing Time: {result['metadata']['processing_time']:.4f} seconds")
+    
+    print(f"\n{'Summary:':-^70}")
+    print(result['summary'])
+    
+    print(f"\n{'Sentence Importance Ranking:':-^70}")
+    importance = summarizer.get_sentence_importance(sample_text)
+    for i, (sent, score) in enumerate(importance[:5], 1):
+        print(f"{i}. [Score: {score:.4f}] {sent[:80]}...")
+    
+    print("\n" + "=" * 70)
+    print(summarizer.get_model_info())

requirements.txt

@@ -0,0 +1,38 @@
+# Core Dependencies
+torch>=2.0.1
+transformers>=4.30.2
+datasets>=2.14.0
+
+# NLP Libraries
+nltk>=3.8.1
+rouge-score>=0.1.2
+sentencepiece>=0.1.99
+
+# Scientific Computing
+numpy>=1.24.3
+pandas>=2.0.3
+scipy>=1.11.1
+scikit-learn>=1.3.0
+
+# Web Framework
+flask>=2.3.0
+gunicorn>=21.2.0
+
+# File Processing
+PyPDF2>=3.0.0
+python-docx>=0.8.11
+
+# Visualization
+networkx>=3.1
+matplotlib>=3.7.2
+seaborn>=0.12.2
+plotly>=5.15.0
+
+# Utilities
+tqdm>=4.65.0
+python-dotenv>=1.0.0
+
+# Development & Testing
+pytest>=7.4.0
+pytest-cov>=4.1.0
+sphinx>=7.0.1

utils/__init__.py

@@ -0,0 +1,8 @@
+"""
+Utils package for text summarization utilities
+Contains data loading, evaluation, preprocessing, and visualization tools
+"""
+
+# Package-level imports can be added here if needed
+__all__ = []
+

utils/data_loader.py

@@ -0,0 +1,384 @@
+"""
+Data Loading and Management System
+Handles CNN/DailyMail dataset loading, preprocessing, and sample management
+"""
+
+import json
+import os
+from typing import Dict, List, Optional, Union
+import logging
+from pathlib import Path
+import pandas as pd
+
+try:
+    from datasets import load_dataset
+    DATASETS_AVAILABLE = True
+except ImportError:
+    DATASETS_AVAILABLE = False
+    print("Warning: datasets library not available. Install with: pip install datasets")
+
+logger = logging.getLogger(__name__)
+
+
+class DataLoader:
+    """
+    Professional data loading system for summarization datasets.
+    
+    Features:
+    - CNN/DailyMail dataset loading
+    - Sample management and caching
+    - Data preprocessing and validation
+    - Export/import functionality
+    """
+    
+    def __init__(self, cache_dir: Optional[str] = None):
+        """
+        Initialize DataLoader
+        
+        Args:
+            cache_dir: Directory for caching datasets
+        """
+        self.cache_dir = cache_dir or "./data/cache"
+        os.makedirs(self.cache_dir, exist_ok=True)
+        logger.info(f"DataLoader initialized with cache dir: {self.cache_dir}")
+    
+    def load_cnn_dailymail(self, 
+                          split: str = "test",
+                          num_samples: Optional[int] = None,
+                          version: str = "3.0.0") -> List[Dict]:
+        """
+        Load CNN/DailyMail dataset
+        
+        Args:
+            split: Dataset split ('train', 'validation', 'test')
+            num_samples: Number of samples to load (None for all)
+            version: Dataset version
+            
+        Returns:
+            List of dictionaries with 'article' and 'reference_summary' keys
+        """
+        if not DATASETS_AVAILABLE:
+            logger.error("datasets library not available")
+            return self._load_sample_data()
+        
+        logger.info(f"Loading CNN/DailyMail {split} split (version {version})")
+        
+        try:
+            # Load dataset
+            dataset = load_dataset('abisee/cnn_dailymail', version, split=split)
+            
+            # Limit samples if requested
+            if num_samples:
+                dataset = dataset.select(range(min(num_samples, len(dataset))))
+            
+            # Convert to our format
+            data = []
+            for item in dataset:
+                data.append({
+                    'article': item['article'],
+                    'reference_summary': item['highlights'],
+                    'id': item.get('id', len(data))
+                })
+            
+            logger.info(f"Loaded {len(data)} samples from CNN/DailyMail")
+            return data
+            
+        except Exception as e:
+            logger.error(f"Failed to load CNN/DailyMail: {e}")
+            return self._load_sample_data()
+    
+    def _load_sample_data(self) -> List[Dict]:
+        """Load sample data when dataset library is not available"""
+        logger.info("Loading built-in sample data")
+        
+        return [
+            {
+                'article': """
+                Artificial intelligence has revolutionized modern technology in unprecedented ways. 
+                Machine learning algorithms enable computers to learn from vast amounts of data without 
+                explicit programming. Deep learning neural networks, inspired by the human brain, can 
+                now recognize patterns in images, understand natural language, and even generate creative 
+                content. Natural language processing has advanced to the point where AI systems can 
+                engage in human-like conversations, translate between languages in real-time, and 
+                summarize lengthy documents automatically. Computer vision technology allows machines 
+                to interpret and understand visual information from the world, powering applications 
+                from autonomous vehicles to medical diagnosis systems. The integration of AI across 
+                industries has improved efficiency, accuracy, and decision-making capabilities. 
+                Healthcare providers use AI to detect diseases earlier and recommend personalized 
+                treatments. Financial institutions employ machine learning for fraud detection and 
+                algorithmic trading. Manufacturing companies utilize AI-powered robots for precision 
+                tasks and quality control. Despite these advances, challenges remain in areas such as 
+                algorithmic bias, data privacy, interpretability of AI decisions, and the ethical 
+                implications of autonomous systems.
+                """,
+                'reference_summary': "AI has transformed technology through machine learning, deep learning, and NLP. Applications span healthcare, finance, and manufacturing, though challenges like bias and privacy remain.",
+                'id': 1
+            },
+            {
+                'article': """
+                Climate change represents one of the most pressing challenges facing humanity in the 
+                21st century. Global temperatures have risen significantly over the past century, 
+                primarily due to increased greenhouse gas emissions from human activities. The burning 
+                of fossil fuels for energy, deforestation, and industrial processes have released 
+                enormous amounts of carbon dioxide and methane into the atmosphere. These greenhouse 
+                gases trap heat, leading to a warming effect known as the greenhouse effect. The 
+                consequences of climate change are already visible worldwide. Polar ice caps and 
+                glaciers are melting at alarming rates, contributing to rising sea levels that threaten 
+                coastal communities. Extreme weather events, including hurricanes, droughts, floods, 
+                and heat waves, have become more frequent and intense. Changes in precipitation patterns 
+                affect agriculture and water supplies, potentially leading to food insecurity. Ocean 
+                acidification, caused by increased absorption of carbon dioxide, threatens marine 
+                ecosystems and the communities that depend on them. Many species face extinction as 
+                their habitats change faster than they can adapt.
+                """,
+                'reference_summary': "Climate change, driven by greenhouse gas emissions, causes rising temperatures, melting ice caps, extreme weather, and threatens ecosystems and human communities worldwide.",
+                'id': 2
+            },
+            {
+                'article': """
+                Space exploration has captured human imagination for decades and continues to push the 
+                boundaries of what's possible. Since the first satellite launch in 1957 and the moon 
+                landing in 1969, humanity has made remarkable progress in understanding our universe. 
+                Modern space agencies like NASA, ESA, and private companies like SpaceX have developed 
+                advanced technologies for space travel. The International Space Station serves as a 
+                permanent laboratory orbiting Earth, enabling research in microgravity conditions. 
+                Robotic missions have explored nearly every planet in our solar system, sending back 
+                invaluable data about planetary geology, atmospheres, and potential for life. Mars has 
+                been particularly exciting, with rovers like Curiosity and Perseverance analyzing soil 
+                samples and searching for signs of ancient microbial life. Space telescopes such as 
+                Hubble and James Webb have revolutionized astronomy, capturing images of distant 
+                galaxies and helping scientists understand the universe's origins. Commercial space 
+                flight is becoming reality, with companies developing reusable rockets and planning 
+                tourist trips to orbit.
+                """,
+                'reference_summary': "Space exploration has advanced from early satellites to modern missions exploring planets, operating space stations, and developing commercial spaceflight capabilities.",
+                'id': 3
+            }
+        ]
+    
+    def save_samples(self, data: List[Dict], filename: str) -> bool:
+        """
+        Save samples to JSON file
+        
+        Args:
+            data: List of sample dictionaries
+            filename: Output filename
+            
+        Returns:
+            Success status
+        """
+        try:
+            # Ensure directory exists
+            filepath = Path(filename)
+            filepath.parent.mkdir(parents=True, exist_ok=True)
+            
+            with open(filename, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+            
+            logger.info(f"Saved {len(data)} samples to {filename}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to save samples: {e}")
+            return False
+    
+    def load_samples(self, filename: str) -> List[Dict]:
+        """
+        Load samples from JSON file
+        
+        Args:
+            filename: Input filename
+            
+        Returns:
+            List of sample dictionaries
+        """
+        try:
+            with open(filename, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            logger.info(f"Loaded {len(data)} samples from {filename}")
+            return data
+            
+        except FileNotFoundError:
+            logger.warning(f"File not found: {filename}")
+            return []
+        except Exception as e:
+            logger.error(f"Failed to load samples: {e}")
+            return []
+    
+    def validate_data(self, data: List[Dict]) -> Dict:
+        """
+        Validate dataset structure and content
+        
+        Args:
+            data: List of sample dictionaries
+            
+        Returns:
+            Validation report
+        """
+        report = {
+            'total_samples': len(data),
+            'valid_samples': 0,
+            'issues': []
+        }
+        
+        required_keys = ['article', 'reference_summary']
+        
+        for i, sample in enumerate(data):
+            # Check required keys
+            missing_keys = [key for key in required_keys if key not in sample]
+            if missing_keys:
+                report['issues'].append(f"Sample {i}: Missing keys {missing_keys}")
+                continue
+            
+            # Check content
+            if not sample['article'] or not sample['reference_summary']:
+                report['issues'].append(f"Sample {i}: Empty content")
+                continue
+            
+            # Check lengths
+            article_words = len(sample['article'].split())
+            summary_words = len(sample['reference_summary'].split())
+            
+            if article_words < 10:
+                report['issues'].append(f"Sample {i}: Article too short ({article_words} words)")
+                continue
+            
+            if summary_words < 3:
+                report['issues'].append(f"Sample {i}: Summary too short ({summary_words} words)")
+                continue
+            
+            report['valid_samples'] += 1
+        
+        report['validity_rate'] = report['valid_samples'] / report['total_samples'] if report['total_samples'] > 0 else 0
+        
+        logger.info(f"Validation: {report['valid_samples']}/{report['total_samples']} valid samples")
+        return report
+    
+    def get_statistics(self, data: List[Dict]) -> Dict:
+        """
+        Get dataset statistics
+        
+        Args:
+            data: List of sample dictionaries
+            
+        Returns:
+            Statistics dictionary
+        """
+        if not data:
+            return {}
+        
+        article_lengths = [len(sample['article'].split()) for sample in data]
+        summary_lengths = [len(sample['reference_summary'].split()) for sample in data]
+        compression_ratios = [s/a for a, s in zip(article_lengths, summary_lengths) if a > 0]
+        
+        stats = {
+            'total_samples': len(data),
+            'article_stats': {
+                'mean_length': sum(article_lengths) / len(article_lengths),
+                'min_length': min(article_lengths),
+                'max_length': max(article_lengths),
+                'median_length': sorted(article_lengths)[len(article_lengths)//2]
+            },
+            'summary_stats': {
+                'mean_length': sum(summary_lengths) / len(summary_lengths),
+                'min_length': min(summary_lengths),
+                'max_length': max(summary_lengths),
+                'median_length': sorted(summary_lengths)[len(summary_lengths)//2]
+            },
+            'compression_stats': {
+                'mean_ratio': sum(compression_ratios) / len(compression_ratios),
+                'min_ratio': min(compression_ratios),
+                'max_ratio': max(compression_ratios)
+            }
+        }
+        
+        return stats
+    
+    def export_to_csv(self, data: List[Dict], filename: str) -> bool:
+        """
+        Export data to CSV format
+        
+        Args:
+            data: List of sample dictionaries
+            filename: Output CSV filename
+            
+        Returns:
+            Success status
+        """
+        try:
+            df = pd.DataFrame(data)
+            df.to_csv(filename, index=False, encoding='utf-8')
+            logger.info(f"Exported {len(data)} samples to {filename}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to export CSV: {e}")
+            return False
+    
+    def create_sample_dataset(self, 
+                            full_data: List[Dict], 
+                            sample_size: int,
+                            strategy: str = "random") -> List[Dict]:
+        """
+        Create a sample dataset from full data
+        
+        Args:
+            full_data: Complete dataset
+            sample_size: Number of samples to select
+            strategy: Sampling strategy ('random', 'first', 'balanced')
+            
+        Returns:
+            Sampled dataset
+        """
+        if sample_size >= len(full_data):
+            return full_data
+        
+        if strategy == "random":
+            import random
+            return random.sample(full_data, sample_size)
+        elif strategy == "first":
+            return full_data[:sample_size]
+        elif strategy == "balanced":
+            # Try to balance by length
+            sorted_data = sorted(full_data, key=lambda x: len(x['article'].split()))
+            step = len(sorted_data) // sample_size
+            return [sorted_data[i * step] for i in range(sample_size)]
+        else:
+            return full_data[:sample_size]
+
+
+# Test the DataLoader
+if __name__ == "__main__":
+    print("=" * 60)
+    print("DATA LOADER - PROFESSIONAL TEST")
+    print("=" * 60)
+    
+    # Initialize loader
+    loader = DataLoader()
+    
+    # Load sample data
+    data = loader.load_cnn_dailymail(split='test', num_samples=5)
+    
+    print(f"\nLoaded {len(data)} samples")
+    
+    # Validate data
+    validation = loader.validate_data(data)
+    print(f"Validation: {validation['valid_samples']}/{validation['total_samples']} valid")
+    
+    # Get statistics
+    stats = loader.get_statistics(data)
+    print(f"\nStatistics:")
+    print(f"  Article length: {stats['article_stats']['mean_length']:.1f} words (avg)")
+    print(f"  Summary length: {stats['summary_stats']['mean_length']:.1f} words (avg)")
+    print(f"  Compression ratio: {stats['compression_stats']['mean_ratio']:.2%}")
+    
+    # Test save/load
+    test_file = "test_samples.json"
+    if loader.save_samples(data, test_file):
+        loaded_data = loader.load_samples(test_file)
+        print(f"\nSave/Load test: {len(loaded_data)} samples loaded")
+        
+        # Cleanup
+        os.remove(test_file)
+    
+    print("\n" + "=" * 60)

utils/evaluator.py

@@ -0,0 +1,394 @@
+"""
+Comprehensive Evaluation System for Summarization Models
+Implements ROUGE metrics, comparison analysis, and statistical testing
+"""
+
+# Handle different rouge library installations
+try:
+    from rouge import Rouge
+    ROUGE_AVAILABLE = True
+    ROUGE_TYPE = "rouge"
+except ImportError:
+    try:
+        from rouge_score import rouge_scorer
+        ROUGE_AVAILABLE = True
+        ROUGE_TYPE = "rouge_score"
+    except ImportError:
+        ROUGE_AVAILABLE = False
+        ROUGE_TYPE = None
+        print("Warning: No ROUGE library found. Install with: pip install rouge-score")
+
+import numpy as np
+from typing import Dict, List, Tuple, Optional
+import pandas as pd
+import logging
+from scipy import stats
+import time
+
+logger = logging.getLogger(__name__)
+
+
+class SummarizerEvaluator:
+    """
+    Professional evaluation system for summarization models.
+    
+    Metrics Implemented:
+    - ROUGE-1: Unigram overlap
+    - ROUGE-2: Bigram overlap
+    - ROUGE-L: Longest common subsequence
+    - ROUGE-W: Weighted longest common subsequence
+    
+    Additional Analysis:
+    - Compression ratio
+    - Processing time
+    - Statistical significance testing
+    - Model comparison
+    """
+    
+    def __init__(self):
+        """Initialize evaluator with ROUGE scorer"""
+        if ROUGE_AVAILABLE:
+            if ROUGE_TYPE == "rouge":
+                self.rouge = Rouge()
+                self.rouge_scorer = None
+            else:  # rouge_score
+                self.rouge = None
+                self.rouge_scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
+            logger.info(f"Evaluator initialized with {ROUGE_TYPE} library")
+        else:
+            self.rouge = None
+            self.rouge_scorer = None
+            logger.warning("ROUGE library not available - only basic metrics will be computed")
+        
+        self.evaluation_history = []
+    
+    def _calculate_rouge_scores(self, generated: str, reference: str) -> Dict:
+        """Calculate ROUGE scores using available library"""
+        if not ROUGE_AVAILABLE:
+            return {
+                'rouge-1': {'f': 0.0, 'p': 0.0, 'r': 0.0},
+                'rouge-2': {'f': 0.0, 'p': 0.0, 'r': 0.0},
+                'rouge-l': {'f': 0.0, 'p': 0.0, 'r': 0.0}
+            }
+        
+        if ROUGE_TYPE == "rouge":
+            # Original rouge library
+            scores = self.rouge.get_scores(generated, reference)[0]
+            return scores
+        else:
+            # rouge_score library
+            scores = self.rouge_scorer.score(reference, generated)
+            return {
+                'rouge-1': {
+                    'f': scores['rouge1'].fmeasure,
+                    'p': scores['rouge1'].precision,
+                    'r': scores['rouge1'].recall
+                },
+                'rouge-2': {
+                    'f': scores['rouge2'].fmeasure,
+                    'p': scores['rouge2'].precision,
+                    'r': scores['rouge2'].recall
+                },
+                'rouge-l': {
+                    'f': scores['rougeL'].fmeasure,
+                    'p': scores['rougeL'].precision,
+                    'r': scores['rougeL'].recall
+                }
+            }
+    
+    def evaluate_single(self,
+                       generated: str,
+                       reference: str,
+                       model_name: str = "Unknown") -> Dict:
+        """
+        Evaluate a single summary against reference
+        
+        ROUGE Metrics Explained:
+        - Precision: What % of generated words are in reference
+        - Recall: What % of reference words are in generated
+        - F1-Score: Harmonic mean of precision and recall
+        
+        Args:
+            generated: Generated summary
+            reference: Human reference summary
+            model_name: Name of the model
+            
+        Returns:
+            Dictionary containing all metrics
+        """
+        if not generated or not reference:
+            logger.warning("Empty summary or reference provided")
+            return self._empty_scores()
+        
+        try:
+            # Calculate ROUGE scores
+            scores = self._calculate_rouge_scores(generated, reference)
+            
+            # Calculate additional metrics
+            compression_ratio = len(generated.split()) / len(reference.split()) if len(reference.split()) > 0 else 0
+            
+            result = {
+                'model_name': model_name,
+                'rouge_1_f1': scores['rouge-1']['f'],
+                'rouge_1_precision': scores['rouge-1']['p'],
+                'rouge_1_recall': scores['rouge-1']['r'],
+                'rouge_2_f1': scores['rouge-2']['f'],
+                'rouge_2_precision': scores['rouge-2']['p'],
+                'rouge_2_recall': scores['rouge-2']['r'],
+                'rouge_l_f1': scores['rouge-l']['f'],
+                'rouge_l_precision': scores['rouge-l']['p'],
+                'rouge_l_recall': scores['rouge-l']['r'],
+                'compression_ratio': compression_ratio,
+                'generated_length': len(generated.split()),
+                'reference_length': len(reference.split())
+            }
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Error evaluating summary: {e}")
+            return self._empty_scores()
+    
+    def _empty_scores(self) -> Dict:
+        """Return empty scores for error cases"""
+        return {
+            'rouge_1_f1': 0.0,
+            'rouge_1_precision': 0.0,
+            'rouge_1_recall': 0.0,
+            'rouge_2_f1': 0.0,
+            'rouge_2_precision': 0.0,
+            'rouge_2_recall': 0.0,
+            'rouge_l_f1': 0.0,
+            'rouge_l_precision': 0.0,
+            'rouge_l_recall': 0.0,
+            'compression_ratio': 0.0,
+            'generated_length': 0,
+            'reference_length': 0
+        }
+    
+    def evaluate_batch(self,
+                      generated_summaries: List[str],
+                      reference_summaries: List[str],
+                      model_name: str = "Unknown") -> Dict:
+        """
+        Evaluate multiple summaries and aggregate results
+        
+        Args:
+            generated_summaries: List of generated summaries
+            reference_summaries: List of reference summaries
+            model_name: Name of the model
+            
+        Returns:
+            Dictionary with aggregated statistics
+        """
+        assert len(generated_summaries) == len(reference_summaries), \
+            "Generated and reference lists must have same length"
+        
+        logger.info(f"Evaluating {len(generated_summaries)} summaries for {model_name}")
+        
+        results = []
+        for gen, ref in zip(generated_summaries, reference_summaries):
+            scores = self.evaluate_single(gen, ref, model_name)
+            results.append(scores)
+        
+        # Aggregate statistics
+        df = pd.DataFrame(results)
+        
+        aggregated = {
+            'model_name': model_name,
+            'num_samples': len(results),
+            'rouge_1_f1_mean': df['rouge_1_f1'].mean(),
+            'rouge_1_f1_std': df['rouge_1_f1'].std(),
+            'rouge_2_f1_mean': df['rouge_2_f1'].mean(),
+            'rouge_2_f1_std': df['rouge_2_f1'].std(),
+            'rouge_l_f1_mean': df['rouge_l_f1'].mean(),
+            'rouge_l_f1_std': df['rouge_l_f1'].std(),
+            'compression_ratio_mean': df['compression_ratio'].mean(),
+            'compression_ratio_std': df['compression_ratio'].std(),
+            'individual_scores': results
+        }
+        
+        # Store in history
+        self.evaluation_history.append(aggregated)
+        
+        return aggregated
+    
+    def compare_models(self,
+                      models_dict: Dict,
+                      test_texts: List[str],
+                      reference_summaries: List[str],
+                      **summarize_kwargs) -> pd.DataFrame:
+        """
+        Compare multiple models on the same dataset
+        
+        Args:
+            models_dict: Dictionary {model_name: model_instance}
+            test_texts: List of texts to summarize
+            reference_summaries: List of reference summaries
+            **summarize_kwargs: Additional parameters for summarization
+            
+        Returns:
+            DataFrame with comparison results
+        """
+        logger.info(f"Comparing {len(models_dict)} models on {len(test_texts)} texts")
+        
+        comparison_results = []
+        
+        for model_name, model in models_dict.items():
+            logger.info(f"Evaluating {model_name}...")
+            
+            start_time = time.time()
+            
+            # Generate summaries
+            generated_summaries = []
+            for text in test_texts:
+                try:
+                    summary = model.summarize(text, **summarize_kwargs)
+                    generated_summaries.append(summary)
+                except Exception as e:
+                    logger.error(f"Error with {model_name}: {e}")
+                    generated_summaries.append("")
+            
+            total_time = time.time() - start_time
+            
+            # Evaluate
+            eval_results = self.evaluate_batch(
+                generated_summaries,
+                reference_summaries,
+                model_name
+            )
+            
+            # Add timing information
+            eval_results['total_time'] = total_time
+            eval_results['avg_time_per_summary'] = total_time / len(test_texts)
+            
+            comparison_results.append(eval_results)
+        
+        # Create comparison DataFrame
+        df = pd.DataFrame([
+            {
+                'Model': r['model_name'],
+                'ROUGE-1': f"{r['rouge_1_f1_mean']:.4f} ± {r['rouge_1_f1_std']:.4f}",
+                'ROUGE-2': f"{r['rouge_2_f1_mean']:.4f} ± {r['rouge_2_f1_std']:.4f}",
+                'ROUGE-L': f"{r['rouge_l_f1_mean']:.4f} ± {r['rouge_l_f1_std']:.4f}",
+                'Compression': f"{r['compression_ratio_mean']:.2f}x",
+                'Avg Time (s)': f"{r['avg_time_per_summary']:.3f}"
+            }
+            for r in comparison_results
+        ])
+        
+        logger.info("Model comparison completed")
+        return df
+    
+    def statistical_significance_test(self,
+                                     model1_scores: List[float],
+                                     model2_scores: List[float],
+                                     test_name: str = "paired t-test") -> Dict:
+        """
+        Test if difference between models is statistically significant
+        
+        Args:
+            model1_scores: Scores from first model
+            model2_scores: Scores from second model
+            test_name: Type of statistical test
+            
+        Returns:
+            Dictionary with test results
+        """
+        if test_name == "paired t-test":
+            statistic, p_value = stats.ttest_rel(model1_scores, model2_scores)
+        elif test_name == "wilcoxon":
+            statistic, p_value = stats.wilcoxon(model1_scores, model2_scores)
+        else:
+            raise ValueError(f"Unknown test: {test_name}")
+        
+        is_significant = p_value < 0.05
+        
+        return {
+            'test_name': test_name,
+            'statistic': statistic,
+            'p_value': p_value,
+            'is_significant': is_significant,
+            'significance_level': 0.05,
+            'interpretation': (
+                f"The difference is {'statistically significant' if is_significant else 'not statistically significant'} "
+                f"(p={p_value:.4f})"
+            )
+        }
+    
+    def get_detailed_report(self,
+                           evaluation_result: Dict) -> str:
+        """
+        Generate a detailed text report
+        
+        Args:
+            evaluation_result: Results from evaluate_batch
+            
+        Returns:
+            Formatted report string
+        """
+        report = []
+        report.append("=" * 70)
+        report.append(f"EVALUATION REPORT: {evaluation_result['model_name']}")
+        report.append("=" * 70)
+        report.append(f"\nDataset Size: {evaluation_result['num_samples']} samples\n")
+        
+        report.append("ROUGE Scores (F1):")
+        report.append(f"  ROUGE-1: {evaluation_result['rouge_1_f1_mean']:.4f} (±{evaluation_result['rouge_1_f1_std']:.4f})")
+        report.append(f"  ROUGE-2: {evaluation_result['rouge_2_f1_mean']:.4f} (±{evaluation_result['rouge_2_f1_std']:.4f})")
+        report.append(f"  ROUGE-L: {evaluation_result['rouge_l_f1_mean']:.4f} (±{evaluation_result['rouge_l_f1_std']:.4f})")
+        
+        report.append(f"\nCompression Ratio: {evaluation_result['compression_ratio_mean']:.2f}x")
+        report.append(f"  (Standard Deviation: {evaluation_result['compression_ratio_std']:.2f})")
+        
+        report.append("\n" + "=" * 70)
+        
+        return "\n".join(report)
+    
+    def export_results(self,
+                      evaluation_result: Dict,
+                      filename: str = "evaluation_results.json"):
+        """
+        Export evaluation results to file
+        
+        Args:
+            evaluation_result: Results to export
+            filename: Output filename
+        """
+        import json
+        
+        with open(filename, 'w') as f:
+            json.dump(evaluation_result, f, indent=2)
+        
+        logger.info(f"Results exported to {filename}")
+
+
+# Test the evaluator
+if __name__ == "__main__":
+    print("=" * 70)
+    print("EVALUATOR SYSTEM TEST")
+    print("=" * 70)
+    
+    # Sample data
+    generated = "Machine learning revolutionizes AI. Neural networks perform complex tasks."
+    reference = "Machine learning has transformed artificial intelligence. Deep neural networks can now handle complicated tasks with high accuracy."
+    
+    # Initialize evaluator
+    evaluator = SummarizerEvaluator()
+    
+    # Evaluate single summary
+    scores = evaluator.evaluate_single(generated, reference, "TestModel")
+    
+    print("\nSingle Summary Evaluation:")
+    print(f"ROUGE-1 F1: {scores['rouge_1_f1']:.4f}")
+    print(f"ROUGE-2 F1: {scores['rouge_2_f1']:.4f}")
+    print(f"ROUGE-L F1: {scores['rouge_l_f1']:.4f}")
+    print(f"Compression Ratio: {scores['compression_ratio']:.2f}x")
+    
+    # Test batch evaluation
+    generated_list = [generated] * 5
+    reference_list = [reference] * 5
+    
+    batch_scores = evaluator.evaluate_batch(generated_list, reference_list, "TestModel")
+    
+    print("\n" + evaluator.get_detailed_report(batch_scores))

webapp/README.md

@@ -0,0 +1,158 @@
+# Smart Summarizer Web Application
+
+Professional web interface for comparing TextRank, BART, and PEGASUS summarization models.
+
+## Features
+
+- **Home**: Overview of the three summarization models
+- **Single Summary**: Generate summaries with individual models
+- **Comparison**: Compare all three models side-by-side
+- **Batch Processing**: Process multiple documents simultaneously
+- **Evaluation**: View ROUGE metric benchmarks and model performance
+
+## Design
+
+The UI follows the "Ink Wash" color palette:
+- Charcoal (#4A4A4A)
+- Cool Gray (#CBCBCB)
+- Soft Ivory (#FFFFE3)
+- Slate Blue (#6D8196)
+
+## Running the Application
+
+### 1. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 2. Start the Server
+
+```bash
+cd webapp
+python app.py
+```
+
+The application will be available at: `http://localhost:5001`
+
+### 3. Test the Routes
+
+```bash
+python test_webapp.py
+```
+
+## File Structure
+
+```
+webapp/
+├── app.py                      # Flask application
+├── templates/
+│   ├── home.html              # Home page
+│   ├── single_summary.html    # Single summary page
+│   ├── comparison.html        # Model comparison page
+│   ├── batch.html             # Batch processing page
+│   └── evaluation.html        # Evaluation metrics page
+├── static/
+│   ├── css/
+│   │   └── style.css          # Main stylesheet
+│   └── js/
+│       ├── evaluation.js      # Evaluation page logic
+│       └── batch.js           # Batch processing logic
+└── uploads/                    # Temporary file uploads
+```
+
+## API Endpoints
+
+### POST /api/summarize
+Generate a summary with a single model.
+
+**Request:**
+```json
+{
+  "text": "Your text here...",
+  "model": "bart"  // or "textrank", "pegasus"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "summary": "Generated summary...",
+  "metadata": {
+    "model_name": "BART",
+    "processing_time": 2.34,
+    "compression_ratio": 0.22
+  }
+}
+```
+
+### POST /api/compare
+Compare all three models on the same text.
+
+**Request:**
+```json
+{
+  "text": "Your text here..."
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "results": {
+    "textrank": { "summary": "...", "metadata": {...} },
+    "bart": { "summary": "...", "metadata": {...} },
+    "pegasus": { "summary": "...", "metadata": {...} }
+  }
+}
+```
+
+### POST /api/upload
+Upload a file (.txt, .md, .pdf, .docx) and extract text.
+
+**Request:** multipart/form-data with file
+
+**Response:**
+```json
+{
+  "success": true,
+  "text": "Extracted text...",
+  "filename": "document.pdf",
+  "word_count": 1234
+}
+```
+
+## Supported File Types
+
+- Plain text (.txt, .md)
+- PDF documents (.pdf)
+- Word documents (.docx, .doc)
+
+## Model Information
+
+### TextRank
+- Type: Extractive
+- Algorithm: Graph-based PageRank
+- Speed: Very fast (~0.03s)
+- Best for: Quick summaries, keyword extraction
+
+### BART
+- Type: Abstractive
+- Algorithm: Transformer encoder-decoder
+- Speed: Moderate (~9s on CPU)
+- Best for: Fluent, human-like summaries
+
+### PEGASUS
+- Type: Abstractive
+- Algorithm: Gap Sentence Generation
+- Speed: Moderate (~6s on CPU)
+- Best for: High-quality abstractive summaries
+
+## Notes
+
+- Models are loaded lazily (on first use) to reduce startup time
+- GPU acceleration is supported if CUDA is available
+- All models generate similar compression ratios (~22%) for fair comparison
+- File uploads are limited to 16MB

webapp/app.py

@@ -0,0 +1,267 @@
+"""
+Smart Summarizer - Flask Web Application
+Professional UI matching Figma design
+"""
+
+from flask import Flask, render_template, request, jsonify
+import sys
+from pathlib import Path
+import os
+from werkzeug.utils import secure_filename
+import PyPDF2
+from docx import Document as DocxDocument
+
+# Add project root to path
+sys.path.append(str(Path(__file__).parent.parent))
+
+from models.textrank import TextRankSummarizer
+from models.bart import BARTSummarizer
+from models.pegasus import PEGASUSSummarizer
+
+app = Flask(__name__)
+app.config['SECRET_KEY'] = 'your-secret-key-here'
+app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB max file size
+app.config['UPLOAD_FOLDER'] = 'uploads'
+
+# Create uploads folder if it doesn't exist
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+
+# Allowed file extensions
+ALLOWED_EXTENSIONS = {'txt', 'md', 'text', 'pdf', 'docx', 'doc'}
+
+def allowed_file(filename):
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+# Initialize models (lazy loading)
+models = {}
+
+def get_model(model_name):
+    """Load and cache models"""
+    if model_name not in models:
+        if model_name == "textrank":
+            models[model_name] = TextRankSummarizer()
+        elif model_name == "bart":
+            models[model_name] = BARTSummarizer(device='cpu')
+        elif model_name == "pegasus":
+            models[model_name] = PEGASUSSummarizer(device='cpu')
+    return models[model_name]
+
+@app.route('/')
+def home():
+    """Home page"""
+    return render_template('home.html')
+
+@app.route('/single-summary')
+def single_summary():
+    """Single summary page"""
+    return render_template('single_summary.html')
+
+@app.route('/comparison')
+def comparison():
+    """Model comparison page"""
+    return render_template('comparison.html')
+
+@app.route('/batch')
+def batch():
+    """Batch processing page"""
+    return render_template('batch.html')
+
+@app.route('/evaluation')
+def evaluation():
+    """Evaluation page"""
+    return render_template('evaluation.html')
+
+@app.route('/api/summarize', methods=['POST'])
+def summarize():
+    """API endpoint for summarization"""
+    try:
+        data = request.json
+        text = data.get('text', '')
+        model_name = data.get('model', 'bart').lower()
+        
+        if not text or len(text.split()) < 10:
+            return jsonify({
+                'success': False,
+                'error': 'Please provide at least 10 words of text'
+            }), 400
+        
+        # Get model
+        model = get_model(model_name)
+        
+        # Calculate target summary length (approximately 20-25% of original)
+        input_words = len(text.split())
+        target_length = max(30, min(150, int(input_words * 0.22)))  # 22% compression
+        
+        # Generate summary based on model type
+        if model_name == 'textrank':
+            # For TextRank, calculate number of sentences to achieve similar compression
+            sentences = text.count('.') + text.count('!') + text.count('?')
+            num_sentences = max(2, int(sentences * 0.3))  # ~30% of sentences
+            result = model.summarize_with_metrics(text, num_sentences=num_sentences)
+        else:
+            # For BART and PEGASUS, use word-based limits
+            result = model.summarize_with_metrics(
+                text,
+                max_length=target_length,
+                min_length=max(20, int(target_length * 0.5))
+            )
+        
+        return jsonify({
+            'success': True,
+            'summary': result['summary'],
+            'metadata': result['metadata']
+        })
+        
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+@app.route('/api/compare', methods=['POST'])
+def compare():
+    """API endpoint for comparing all three models"""
+    try:
+        data = request.json
+        text = data.get('text', '')
+        
+        if not text or len(text.split()) < 10:
+            return jsonify({
+                'success': False,
+                'error': 'Please provide at least 10 words of text'
+            }), 400
+        
+        results = {}
+        
+        # Calculate consistent target length for all models
+        input_words = len(text.split())
+        target_length = max(30, min(150, int(input_words * 0.22)))
+        sentences = text.count('.') + text.count('!') + text.count('?')
+        num_sentences = max(2, int(sentences * 0.3))
+        
+        # Run all three models
+        for model_name in ['textrank', 'bart', 'pegasus']:
+            try:
+                model = get_model(model_name)
+                
+                if model_name == 'textrank':
+                    result = model.summarize_with_metrics(text, num_sentences=num_sentences)
+                else:
+                    result = model.summarize_with_metrics(
+                        text,
+                        max_length=target_length,
+                        min_length=max(20, int(target_length * 0.5))
+                    )
+                
+                results[model_name] = {
+                    'summary': result['summary'],
+                    'metadata': result['metadata']
+                }
+            except Exception as e:
+                results[model_name] = {
+                    'error': str(e)
+                }
+        
+        return jsonify({
+            'success': True,
+            'results': results
+        })
+        
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+@app.route('/api/upload', methods=['POST'])
+def upload_file():
+    """API endpoint for file upload"""
+    try:
+        if 'file' not in request.files:
+            return jsonify({
+                'success': False,
+                'error': 'No file provided'
+            }), 400
+        
+        file = request.files['file']
+        
+        if file.filename == '':
+            return jsonify({
+                'success': False,
+                'error': 'No file selected'
+            }), 400
+        
+        if not allowed_file(file.filename):
+            return jsonify({
+                'success': False,
+                'error': 'Invalid file type. Please upload .txt, .md, .pdf, .docx, or .doc files'
+            }), 400
+        
+        # Extract text based on file type
+        filename = secure_filename(file.filename)
+        file_ext = filename.rsplit('.', 1)[1].lower()
+        
+        try:
+            if file_ext in ['txt', 'md', 'text']:
+                # Plain text files
+                text = file.read().decode('utf-8')
+            
+            elif file_ext == 'pdf':
+                # PDF files
+                pdf_reader = PyPDF2.PdfReader(file)
+                text = ''
+                for page in pdf_reader.pages:
+                    text += page.extract_text() + '\n'
+            
+            elif file_ext in ['docx', 'doc']:
+                # Word documents
+                doc = DocxDocument(file)
+                text = '\n'.join([paragraph.text for paragraph in doc.paragraphs])
+            
+            else:
+                return jsonify({
+                    'success': False,
+                    'error': 'Unsupported file format'
+                }), 400
+                
+        except UnicodeDecodeError:
+            return jsonify({
+                'success': False,
+                'error': 'File encoding not supported. Please use UTF-8 encoded files'
+            }), 400
+        except Exception as e:
+            return jsonify({
+                'success': False,
+                'error': f'Error reading file: {str(e)}'
+            }), 400
+        
+        if not text or len(text.split()) < 10:
+            return jsonify({
+                'success': False,
+                'error': 'File content is too short. Please provide at least 10 words'
+            }), 400
+        
+        return jsonify({
+            'success': True,
+            'text': text,
+            'filename': filename,
+            'word_count': len(text.split())
+        })
+        
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+if __name__ == '__main__':
+    import os
+    
+    # Get port from environment variable (Hugging Face Spaces uses 7860)
+    port = int(os.environ.get('PORT', 7860))
+    
+    # Check if running in production
+    debug = os.environ.get('FLASK_ENV') != 'production'
+    
+    # Bind to 0.0.0.0 for cloud deployment
+    app.run(host='0.0.0.0', port=port, debug=debug)

webapp/requirements.txt

@@ -0,0 +1,3 @@
+Flask==3.0.0
+PyPDF2==3.0.1
+python-docx==1.1.0

webapp/static/css/style.css

@@ -0,0 +1,880 @@
+/* Smart Summarizer - Main Stylesheet */
+@import url('https://fonts.googleapis.com/css2?family=Playfair+Display:wght@400;600;700&display=swap');
+
+/* Ink Wash Color Palette */
+:root {
+    --charcoal: #4A4A4A;
+    --cool-gray: #CBCBCB;
+    --soft-ivory: #FFFFE3;
+    --slate-blue: #6D8196;
+    --card-bg: #F5F0F6;
+    --white: #ffffff;
+}
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    background: var(--soft-ivory);
+    color: var(--charcoal);
+    line-height: 1.6;
+}
+
+/* Top Navigation Bar */
+.top-navbar {
+    background: var(--slate-blue);
+    padding: 1rem 3rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    position: sticky;
+    top: 0;
+    z-index: 1000;
+    box-shadow: 0 2px 10px rgba(74, 74, 74, 0.1);
+}
+
+.navbar-logo {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    color: white;
+    font-size: 1.1rem;
+    font-weight: 600;
+    text-decoration: none;
+    transition: opacity 0.3s ease;
+}
+
+.navbar-logo:hover {
+    opacity: 0.9;
+}
+
+.logo-circle {
+    width: 36px;
+    height: 36px;
+    background: white;
+    color: var(--slate-blue);
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-weight: bold;
+    font-size: 1.2rem;
+}
+
+.navbar-links {
+    display: flex;
+    gap: 2.5rem;
+    align-items: center;
+}
+
+.nav-item {
+    color: rgba(255, 255, 255, 0.8);
+    font-size: 0.95rem;
+    font-weight: 500;
+    text-decoration: none;
+    transition: color 0.3s ease;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.nav-item i {
+    font-size: 0.9rem;
+}
+
+.nav-item:hover {
+    color: white;
+}
+
+.nav-item.active {
+    color: white;
+}
+
+/* Hero Section */
+.hero-container {
+    text-align: center;
+    padding: 5rem 2rem 3rem 2rem;
+    max-width: 900px;
+    margin: 0 auto;
+}
+
+.hero-title {
+    font-family: 'Playfair Display', serif;
+    font-size: 4.5rem;
+    font-weight: 400;
+    color: var(--charcoal);
+    line-height: 1.1;
+    margin-bottom: 0.5rem;
+    letter-spacing: -0.02em;
+}
+
+.hero-subtitle {
+    font-family: 'Playfair Display', serif;
+    font-size: 4.5rem;
+    font-weight: 400;
+    color: var(--slate-blue);
+    line-height: 1.1;
+    margin-bottom: 2rem;
+    letter-spacing: -0.02em;
+}
+
+.hero-description {
+    font-size: 1.1rem;
+    color: var(--slate-blue);
+    line-height: 1.6;
+    margin-bottom: 0.5rem;
+}
+
+/* CTA Buttons */
+.cta-container {
+    display: flex;
+    gap: 1rem;
+    justify-content: center;
+    margin: 3rem 0 4rem 0;
+}
+
+.btn-primary {
+    background: var(--charcoal);
+    color: white;
+    padding: 1rem 2.5rem;
+    border: none;
+    border-radius: 8px;
+    font-size: 1rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    text-decoration: none;
+    display: inline-block;
+}
+
+.btn-primary:hover {
+    background: #3a3a3a;
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(74, 74, 74, 0.3);
+}
+
+.btn-secondary {
+    background: transparent;
+    color: var(--charcoal);
+    padding: 1rem 2.5rem;
+    border: 1px solid var(--cool-gray);
+    border-radius: 8px;
+    font-size: 1rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    text-decoration: none;
+    display: inline-block;
+}
+
+.btn-secondary:hover {
+    border-color: var(--slate-blue);
+    color: var(--slate-blue);
+}
+
+/* Model Cards */
+.models-container {
+    max-width: 1100px;
+    margin: 0 auto;
+    padding: 0 2rem 4rem 2rem;
+}
+
+.cards-grid {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    gap: 2rem;
+}
+
+.model-card {
+    background: var(--card-bg);
+    border-radius: 16px;
+    padding: 2.5rem 2rem;
+    text-align: left;
+    transition: all 0.3s ease;
+    border: 1px solid rgba(203, 203, 203, 0.3);
+}
+
+.model-card:hover {
+    transform: translateY(-4px);
+    box-shadow: 0 8px 24px rgba(74, 74, 74, 0.12);
+}
+
+.model-emoji {
+    font-size: 2.5rem;
+    margin-bottom: 1.5rem;
+    display: block;
+}
+
+.model-name {
+    font-size: 1.6rem;
+    font-weight: 600;
+    color: var(--charcoal);
+    margin-bottom: 1rem;
+}
+
+.model-desc {
+    font-size: 0.95rem;
+    color: var(--slate-blue);
+    line-height: 1.6;
+}
+
+/* Page Container */
+.page-container {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 3rem 2rem;
+}
+
+.page-title {
+    font-family: 'Playfair Display', serif;
+    font-size: 2.5rem;
+    font-weight: 600;
+    color: var(--charcoal);
+    margin-bottom: 0.5rem;
+}
+
+.page-subtitle {
+    font-size: 1.1rem;
+    color: var(--slate-blue);
+    margin-bottom: 3rem;
+}
+
+/* Content Grid */
+.content-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 2rem;
+    margin-bottom: 2rem;
+}
+
+.input-section, .output-section {
+    background: white;
+    border-radius: 12px;
+    padding: 2rem;
+    border: 1px solid rgba(203, 203, 203, 0.3);
+}
+
+.section-label {
+    font-size: 0.85rem;
+    font-weight: 600;
+    color: var(--slate-blue);
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    margin-bottom: 1rem;
+}
+
+.text-input {
+    width: 100%;
+    min-height: 300px;
+    padding: 1rem;
+    border: 1px solid var(--cool-gray);
+    border-radius: 8px;
+    font-size: 0.95rem;
+    font-family: inherit;
+    resize: vertical;
+    background: #FAFAFA;
+}
+
+.text-input:focus {
+    outline: none;
+    border-color: var(--slate-blue);
+}
+
+.char-count {
+    display: flex;
+    justify-content: space-between;
+    margin-top: 0.5rem;
+    font-size: 0.85rem;
+    color: var(--slate-blue);
+}
+
+.output-preview {
+    min-height: 300px;
+    padding: 2rem;
+    border: 2px dashed var(--cool-gray);
+    border-radius: 8px;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+    color: var(--slate-blue);
+    background: var(--soft-ivory);
+}
+
+.output-preview .icon {
+    font-size: 3rem;
+    margin-bottom: 1rem;
+}
+
+.output-text {
+    width: 100%;
+    min-height: 300px;
+    padding: 1rem;
+    border: 1px solid var(--cool-gray);
+    border-radius: 8px;
+    font-size: 0.95rem;
+    line-height: 1.8;
+    background: white;
+}
+
+/* Controls */
+.controls-section {
+    display: flex;
+    gap: 1rem;
+    align-items: center;
+    margin-top: 2rem;
+}
+
+.model-select {
+    padding: 0.75rem 1.5rem;
+    border: 1px solid var(--cool-gray);
+    border-radius: 8px;
+    font-size: 0.95rem;
+    background: white;
+    color: var(--charcoal);
+    cursor: pointer;
+}
+
+.btn-generate {
+    background: var(--charcoal);
+    color: white;
+    padding: 0.75rem 2rem;
+    border: none;
+    border-radius: 8px;
+    font-size: 0.95rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.3s ease;
+}
+
+.btn-generate:hover {
+    background: #3a3a3a;
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(74, 74, 74, 0.3);
+}
+
+.btn-generate:disabled {
+    background: var(--cool-gray);
+    cursor: not-allowed;
+    transform: none;
+}
+
+/* Footer */
+.footer {
+    background: var(--charcoal);
+    color: var(--cool-gray);
+    padding: 2rem 3rem;
+    margin-top: 4rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.footer-left {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.footer-right {
+    display: flex;
+    gap: 2rem;
+    align-items: center;
+}
+
+.footer-link {
+    color: var(--cool-gray);
+    text-decoration: none;
+    font-size: 0.9rem;
+    transition: color 0.3s ease;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.footer-link i {
+    font-size: 1rem;
+}
+
+.footer-link:hover {
+    color: white;
+}
+
+/* Loading Spinner */
+.spinner {
+    border: 3px solid rgba(109, 129, 150, 0.3);
+    border-top: 3px solid var(--slate-blue);
+    border-radius: 50%;
+    width: 40px;
+    height: 40px;
+    animation: spin 1s linear infinite;
+    margin: 2rem auto;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+/* Responsive */
+@media (max-width: 1024px) {
+    .cards-grid {
+        grid-template-columns: 1fr;
+    }
+    
+    .content-grid {
+        grid-template-columns: 1fr;
+    }
+    
+    .hero-title, .hero-subtitle {
+        font-size: 3rem;
+    }
+    
+    .navbar-links {
+        gap: 1rem;
+    }
+}
+
+/* Comparison Page Styles */
+.comparison-input-section {
+    background: white;
+    border-radius: 12px;
+    padding: 2rem;
+    border: 1px solid rgba(203, 203, 203, 0.3);
+    margin-bottom: 2rem;
+}
+
+.comparison-grid {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    gap: 2rem;
+    margin-top: 2rem;
+}
+
+.comparison-card {
+    background: white;
+    border-radius: 12px;
+    border: 1px solid rgba(203, 203, 203, 0.3);
+    overflow: hidden;
+}
+
+.comparison-header {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    padding: 1.5rem;
+    background: var(--card-bg);
+    border-bottom: 1px solid rgba(203, 203, 203, 0.3);
+}
+
+.model-indicator {
+    width: 12px;
+    height: 12px;
+    border-radius: 50%;
+    display: inline-block;
+}
+
+.comparison-header h3 {
+    margin: 0;
+    font-size: 1.3rem;
+    font-weight: 600;
+    color: var(--charcoal);
+}
+
+.comparison-result {
+    padding: 2rem;
+    min-height: 250px;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+}
+
+.awaiting-text {
+    color: var(--cool-gray);
+    font-size: 0.95rem;
+    text-align: center;
+}
+
+.summary-content {
+    line-height: 1.8;
+    color: var(--charcoal);
+    margin-bottom: 1.5rem;
+    text-align: left;
+    width: 100%;
+}
+
+.summary-metrics {
+    display: flex;
+    gap: 1.5rem;
+    padding-top: 1rem;
+    border-top: 1px solid rgba(203, 203, 203, 0.3);
+    width: 100%;
+}
+
+.metric-item {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+}
+
+.metric-label {
+    font-size: 0.75rem;
+    color: var(--slate-blue);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    font-weight: 600;
+}
+
+.metric-value {
+    font-size: 1.1rem;
+    color: var(--charcoal);
+    font-weight: 600;
+}
+
+@media (max-width: 1024px) {
+    .comparison-grid {
+        grid-template-columns: 1fr;
+    }
+}
+
+/* Input Tabs */
+.input-tabs {
+    display: flex;
+    gap: 0.5rem;
+    margin-bottom: 1rem;
+}
+
+.tab-btn {
+    padding: 0.75rem 1.5rem;
+    border: 1px solid var(--cool-gray);
+    background: white;
+    color: var(--charcoal);
+    border-radius: 8px 8px 0 0;
+    cursor: pointer;
+    font-size: 0.9rem;
+    font-weight: 500;
+    transition: all 0.3s ease;
+}
+
+.tab-btn:hover {
+    background: var(--card-bg);
+}
+
+.tab-btn.active {
+    background: var(--slate-blue);
+    color: white;
+    border-color: var(--slate-blue);
+}
+
+.tab-content {
+    display: none;
+}
+
+.tab-content.active {
+    display: block;
+}
+
+/* File Upload Area */
+.upload-area {
+    border: 2px dashed var(--cool-gray);
+    border-radius: 8px;
+    padding: 3rem 2rem;
+    text-align: center;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    background: transparent;
+}
+
+.upload-area:hover {
+    border-color: var(--slate-blue);
+    background: rgba(109, 129, 150, 0.05);
+}
+
+.upload-icon {
+    font-size: 3rem;
+    margin-bottom: 1rem;
+}
+
+.upload-hint {
+    font-size: 0.85rem;
+    color: var(--slate-blue);
+    margin-top: 0.5rem;
+}
+
+.file-info {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 1rem;
+    background: var(--card-bg);
+    border-radius: 8px;
+    margin-top: 1rem;
+}
+
+.btn-remove {
+    background: #ef4444;
+    color: white;
+    border: none;
+    padding: 0.5rem 1rem;
+    border-radius: 6px;
+    cursor: pointer;
+    font-size: 0.85rem;
+    transition: all 0.3s ease;
+}
+
+.btn-remove:hover {
+    background: #dc2626;
+}
+
+/* Evaluation Page Styles */
+.evaluation-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 2rem;
+    margin-top: 2rem;
+}
+
+.chart-section {
+    background: white;
+    border-radius: 12px;
+    padding: 2rem;
+    border: 1px solid rgba(203, 203, 203, 0.3);
+}
+
+.chart-container {
+    width: 100%;
+}
+
+.chart-title {
+    font-size: 1.3rem;
+    font-weight: 600;
+    color: var(--charcoal);
+    margin-bottom: 2rem;
+    text-align: center;
+}
+
+.metrics-explanation {
+    display: flex;
+    flex-direction: column;
+    gap: 1.5rem;
+}
+
+.section-title {
+    font-size: 1.3rem;
+    font-weight: 600;
+    color: var(--charcoal);
+    margin-bottom: 0.5rem;
+}
+
+.metric-card {
+    background: white;
+    border-radius: 12px;
+    padding: 1.5rem;
+    border: 1px solid rgba(203, 203, 203, 0.3);
+}
+
+.metric-header {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    margin-bottom: 0.75rem;
+}
+
+.metric-indicator {
+    width: 12px;
+    height: 12px;
+    border-radius: 50%;
+}
+
+.metric-card h4 {
+    font-size: 1.1rem;
+    font-weight: 600;
+    color: var(--charcoal);
+    margin: 0;
+}
+
+.metric-card p {
+    font-size: 0.9rem;
+    color: var(--slate-blue);
+    line-height: 1.6;
+    margin: 0;
+}
+
+.insight-box {
+    background: var(--charcoal);
+    color: white;
+    border-radius: 12px;
+    padding: 1.5rem;
+    margin-top: 1rem;
+}
+
+.insight-box h4 {
+    font-size: 0.85rem;
+    font-weight: 600;
+    letter-spacing: 1px;
+    margin-bottom: 0.75rem;
+    color: var(--cool-gray);
+}
+
+.insight-box p {
+    font-size: 0.95rem;
+    line-height: 1.6;
+    margin: 0;
+    font-style: italic;
+}
+
+/* Batch Page Styles */
+.batch-controls {
+    display: flex;
+    gap: 1rem;
+    justify-content: flex-end;
+    margin-bottom: 2rem;
+}
+
+.batch-table-container {
+    background: white;
+    border-radius: 12px;
+    border: 1px solid rgba(203, 203, 203, 0.3);
+    overflow: hidden;
+    margin-bottom: 2rem;
+}
+
+.batch-table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+.batch-table thead {
+    background: var(--card-bg);
+}
+
+.batch-table th {
+    padding: 1rem 1.5rem;
+    text-align: left;
+    font-size: 0.75rem;
+    font-weight: 600;
+    color: var(--slate-blue);
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    border-bottom: 1px solid rgba(203, 203, 203, 0.3);
+}
+
+.batch-table td {
+    padding: 1.5rem;
+    border-bottom: 1px solid rgba(203, 203, 203, 0.1);
+    color: var(--charcoal);
+}
+
+.batch-table tbody tr:hover {
+    background: rgba(109, 129, 150, 0.03);
+}
+
+.empty-state {
+    text-align: center;
+}
+
+.empty-message {
+    padding: 4rem 2rem;
+    color: var(--cool-gray);
+    font-size: 1rem;
+}
+
+.source-preview {
+    max-width: 400px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    color: var(--charcoal);
+}
+
+.model-badges {
+    display: flex;
+    gap: 0.5rem;
+    flex-wrap: wrap;
+}
+
+.model-badge {
+    padding: 0.25rem 0.75rem;
+    border-radius: 6px;
+    font-size: 0.8rem;
+    font-weight: 500;
+    background: var(--card-bg);
+    color: var(--charcoal);
+    border: 1px solid rgba(203, 203, 203, 0.3);
+}
+
+.status-badge {
+    padding: 0.5rem 1rem;
+    border-radius: 6px;
+    font-size: 0.85rem;
+    font-weight: 500;
+    display: inline-block;
+}
+
+.status-pending {
+    background: rgba(203, 203, 203, 0.2);
+    color: var(--slate-blue);
+}
+
+.status-processing {
+    background: rgba(109, 129, 150, 0.2);
+    color: var(--slate-blue);
+}
+
+.status-complete {
+    background: rgba(34, 197, 94, 0.2);
+    color: #16a34a;
+}
+
+.status-error {
+    background: rgba(239, 68, 68, 0.2);
+    color: #dc2626;
+}
+
+.action-buttons {
+    display: flex;
+    gap: 0.5rem;
+}
+
+.btn-icon {
+    background: transparent;
+    border: 1px solid var(--cool-gray);
+    color: var(--charcoal);
+    padding: 0.5rem 0.75rem;
+    border-radius: 6px;
+    cursor: pointer;
+    font-size: 0.85rem;
+    transition: all 0.3s ease;
+}
+
+.btn-icon:hover {
+    background: var(--card-bg);
+    border-color: var(--slate-blue);
+}
+
+.export-section {
+    display: flex;
+    justify-content: flex-end;
+}
+
+@media (max-width: 1024px) {
+    .evaluation-grid {
+        grid-template-columns: 1fr;
+    }
+    
+    .batch-table {
+        font-size: 0.85rem;
+    }
+    
+    .batch-table th,
+    .batch-table td {
+        padding: 0.75rem;
+    }
+}

webapp/static/js/batch.js

@@ -0,0 +1,217 @@
+// Batch Processing Page
+
+let batchQueue = [];
+let batchResults = [];
+
+// DOM Elements
+const loadSamplesBtn = document.getElementById('loadSamplesBtn');
+const runBatchBtn = document.getElementById('runBatchBtn');
+const exportBtn = document.getElementById('exportBtn');
+const tableBody = document.getElementById('batchTableBody');
+
+// Sample texts for demo
+const sampleTexts = [
+    {
+        text: "Artificial intelligence has revolutionized the way we interact with technology. Machine learning algorithms can now process vast amounts of data and identify patterns that humans might miss. Deep learning neural networks have enabled breakthroughs in computer vision, natural language processing, and speech recognition. These advances are transforming industries from healthcare to finance.",
+        models: ['textrank', 'bart', 'pegasus']
+    },
+    {
+        text: "Climate change poses one of the greatest challenges to humanity. Rising global temperatures are causing ice caps to melt and sea levels to rise. Extreme weather events are becoming more frequent and severe. Scientists warn that without immediate action, the consequences could be catastrophic for future generations.",
+        models: ['textrank', 'bart']
+    },
+    {
+        text: "The human brain is the most complex organ in the body, containing approximately 86 billion neurons. These neurons communicate through electrical and chemical signals, forming intricate networks that enable thought, memory, and consciousness. Neuroscientists continue to uncover the mysteries of how the brain processes information and generates our subjective experiences.",
+        models: ['bart', 'pegasus']
+    }
+];
+
+// Load sample documents
+loadSamplesBtn.addEventListener('click', function() {
+    batchQueue = [...sampleTexts];
+    renderTable();
+});
+
+// Run batch processing
+runBatchBtn.addEventListener('click', async function() {
+    if (batchQueue.length === 0) {
+        alert('No items in queue. Please load samples first.');
+        return;
+    }
+    
+    runBatchBtn.disabled = true;
+    runBatchBtn.textContent = 'Processing...';
+    
+    for (let i = 0; i < batchQueue.length; i++) {
+        const item = batchQueue[i];
+        item.status = 'processing';
+        renderTable();
+        
+        try {
+            const results = {};
+            
+            for (const model of item.models) {
+                const response = await fetch('/api/summarize', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        text: item.text,
+                        model: model
+                    })
+                });
+                
+                const data = await response.json();
+                
+                if (data.success) {
+                    results[model] = {
+                        summary: data.summary,
+                        metadata: data.metadata
+                    };
+                }
+            }
+            
+            item.results = results;
+            item.status = 'complete';
+            batchResults.push(item);
+            
+        } catch (error) {
+            item.status = 'error';
+            item.error = error.message;
+        }
+        
+        renderTable();
+    }
+    
+    runBatchBtn.disabled = false;
+    runBatchBtn.textContent = 'Run Batch';
+});
+
+// Export results to CSV
+exportBtn.addEventListener('click', function() {
+    if (batchResults.length === 0) {
+        alert('No results to export. Please run batch processing first.');
+        return;
+    }
+    
+    let csv = 'Source Text,Model,Summary,Processing Time (s),Compression Ratio\n';
+    
+    batchResults.forEach(item => {
+        if (item.results) {
+            Object.keys(item.results).forEach(model => {
+                const result = item.results[model];
+                const sourceText = item.text.replace(/"/g, '""').substring(0, 100) + '...';
+                const summary = result.summary.replace(/"/g, '""');
+                const time = result.metadata.processing_time.toFixed(2);
+                const compression = (result.metadata.compression_ratio * 100).toFixed(1) + '%';
+                
+                csv += `"${sourceText}","${model}","${summary}",${time},${compression}\n`;
+            });
+        }
+    });
+    
+    // Download CSV
+    const blob = new Blob([csv], { type: 'text/csv' });
+    const url = window.URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = 'batch_results_' + new Date().toISOString().split('T')[0] + '.csv';
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    window.URL.revokeObjectURL(url);
+});
+
+// Render table
+function renderTable() {
+    if (batchQueue.length === 0) {
+        tableBody.innerHTML = `
+            <tr class="empty-state">
+                <td colspan="4">
+                    <div class="empty-message">
+                        No items in the queue. Load samples or upload a CSV to begin.
+                    </div>
+                </td>
+            </tr>
+        `;
+        return;
+    }
+    
+    tableBody.innerHTML = batchQueue.map((item, index) => {
+        const preview = item.text.substring(0, 80) + '...';
+        const modelBadges = item.models.map(m => 
+            `<span class="model-badge">${m.toUpperCase()}</span>`
+        ).join('');
+        
+        let statusBadge = '';
+        if (!item.status || item.status === 'pending') {
+            statusBadge = '<span class="status-badge status-pending">Pending</span>';
+        } else if (item.status === 'processing') {
+            statusBadge = '<span class="status-badge status-processing">Processing...</span>';
+        } else if (item.status === 'complete') {
+            statusBadge = '<span class="status-badge status-complete">Complete</span>';
+        } else if (item.status === 'error') {
+            statusBadge = '<span class="status-badge status-error">Error</span>';
+        }
+        
+        return `
+            <tr>
+                <td><div class="source-preview">${preview}</div></td>
+                <td><div class="model-badges">${modelBadges}</div></td>
+                <td>${statusBadge}</td>
+                <td>
+                    <div class="action-buttons">
+                        <button class="btn-icon" onclick="viewItem(${index})" ${item.status !== 'complete' ? 'disabled' : ''}>View</button>
+                        <button class="btn-icon" onclick="removeItem(${index})">Remove</button>
+                    </div>
+                </td>
+            </tr>
+        `;
+    }).join('');
+}
+
+// View item results
+function viewItem(index) {
+    const item = batchQueue[index];
+    if (!item.results) return;
+    
+    let resultsHtml = '<div style="max-width: 800px; margin: 0 auto;">';
+    resultsHtml += '<h3 style="margin-bottom: 1rem;">Batch Results</h3>';
+    resultsHtml += `<p style="color: #6D8196; margin-bottom: 2rem;"><strong>Source:</strong> ${item.text.substring(0, 200)}...</p>`;
+    
+    Object.keys(item.results).forEach(model => {
+        const result = item.results[model];
+        resultsHtml += `
+            <div style="margin-bottom: 2rem; padding: 1.5rem; background: #F5F0F6; border-radius: 8px;">
+                <h4 style="margin-bottom: 0.5rem; color: #4A4A4A;">${model.toUpperCase()}</h4>
+                <p style="line-height: 1.8; margin-bottom: 1rem;">${result.summary}</p>
+                <div style="display: flex; gap: 2rem; font-size: 0.9rem; color: #6D8196;">
+                    <span><strong>Time:</strong> ${result.metadata.processing_time.toFixed(2)}s</span>
+                    <span><strong>Compression:</strong> ${(result.metadata.compression_ratio * 100).toFixed(1)}%</span>
+                </div>
+            </div>
+        `;
+    });
+    
+    resultsHtml += '</div>';
+    
+    // Create modal
+    const modal = document.createElement('div');
+    modal.style.cssText = 'position: fixed; top: 0; left: 0; right: 0; bottom: 0; background: rgba(0,0,0,0.5); display: flex; align-items: center; justify-content: center; z-index: 9999; padding: 2rem;';
+    modal.innerHTML = `
+        <div style="background: white; border-radius: 12px; padding: 2rem; max-height: 90vh; overflow-y: auto; position: relative;">
+            <button onclick="this.parentElement.parentElement.remove()" style="position: absolute; top: 1rem; right: 1rem; background: none; border: none; font-size: 1.5rem; cursor: pointer; color: #4A4A4A;">×</button>
+            ${resultsHtml}
+        </div>
+    `;
+    document.body.appendChild(modal);
+}
+
+// Remove item from queue
+function removeItem(index) {
+    batchQueue.splice(index, 1);
+    renderTable();
+}
+
+// Initial render
+renderTable();

webapp/static/js/evaluation.js

@@ -0,0 +1,126 @@
+// Evaluation Page - ROUGE Metrics Chart
+
+// Sample benchmark data (from CNN/DailyMail evaluation)
+const benchmarkData = {
+    textrank: {
+        rouge1: 0.43,
+        rouge2: 0.18,
+        rougeL: 0.35
+    },
+    bart: {
+        rouge1: 0.51,
+        rouge2: 0.34,
+        rougeL: 0.48
+    },
+    pegasus: {
+        rouge1: 0.55,
+        rouge2: 0.30,
+        rougeL: 0.52
+    }
+};
+
+// Initialize chart
+document.addEventListener('DOMContentLoaded', function() {
+    const ctx = document.getElementById('rougeChart').getContext('2d');
+    
+    const chart = new Chart(ctx, {
+        type: 'bar',
+        data: {
+            labels: ['TextRank', 'BART', 'PEGASUS'],
+            datasets: [
+                {
+                    label: 'ROUGE-1',
+                    data: [
+                        benchmarkData.textrank.rouge1,
+                        benchmarkData.bart.rouge1,
+                        benchmarkData.pegasus.rouge1
+                    ],
+                    backgroundColor: '#6D8196',
+                    borderRadius: 6
+                },
+                {
+                    label: 'ROUGE-2',
+                    data: [
+                        benchmarkData.textrank.rouge2,
+                        benchmarkData.bart.rouge2,
+                        benchmarkData.pegasus.rouge2
+                    ],
+                    backgroundColor: '#CBCBCB',
+                    borderRadius: 6
+                },
+                {
+                    label: 'ROUGE-L',
+                    data: [
+                        benchmarkData.textrank.rougeL,
+                        benchmarkData.bart.rougeL,
+                        benchmarkData.pegasus.rougeL
+                    ],
+                    backgroundColor: '#4A4A4A',
+                    borderRadius: 6
+                }
+            ]
+        },
+        options: {
+            responsive: true,
+            maintainAspectRatio: true,
+            plugins: {
+                legend: {
+                    display: true,
+                    position: 'bottom',
+                    labels: {
+                        padding: 20,
+                        font: {
+                            size: 12,
+                            family: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto'
+                        },
+                        usePointStyle: true,
+                        pointStyle: 'circle'
+                    }
+                },
+                tooltip: {
+                    backgroundColor: '#4A4A4A',
+                    padding: 12,
+                    titleFont: {
+                        size: 13
+                    },
+                    bodyFont: {
+                        size: 12
+                    },
+                    callbacks: {
+                        label: function(context) {
+                            return context.dataset.label + ': ' + context.parsed.y.toFixed(2);
+                        }
+                    }
+                }
+            },
+            scales: {
+                y: {
+                    beginAtZero: true,
+                    max: 0.6,
+                    ticks: {
+                        font: {
+                            size: 11
+                        },
+                        color: '#6D8196'
+                    },
+                    grid: {
+                        color: 'rgba(203, 203, 203, 0.3)',
+                        drawBorder: false
+                    }
+                },
+                x: {
+                    ticks: {
+                        font: {
+                            size: 12,
+                            weight: '500'
+                        },
+                        color: '#4A4A4A'
+                    },
+                    grid: {
+                        display: false
+                    }
+                }
+            }
+        }
+    });
+});

webapp/templates/batch.html

@@ -0,0 +1,94 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Batch Processing - Smart Summarizer</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+</head>
+<body>
+    <!-- Top Navigation Bar -->
+    <nav class="top-navbar">
+        <a href="/" class="navbar-logo">
+            <div class="logo-circle">S</div>
+            <span>Smart Summarizer</span>
+        </a>
+        <div class="navbar-links">
+            <a href="/" class="nav-item">
+                <i class="fas fa-home"></i> Home
+            </a>
+            <a href="/single-summary" class="nav-item">
+                <i class="fas fa-file-alt"></i> Single Summary
+            </a>
+            <a href="/comparison" class="nav-item">
+                <i class="fas fa-balance-scale"></i> Comparison
+            </a>
+            <a href="/batch" class="nav-item active">
+                <i class="fas fa-layer-group"></i> Batch
+            </a>
+            <a href="/evaluation" class="nav-item">
+                <i class="fas fa-chart-bar"></i> Evaluation
+            </a>
+        </div>
+    </nav>
+
+    <!-- Page Content -->
+    <div class="page-container">
+        <h1 class="page-title">Batch Processing</h1>
+        <p class="page-subtitle">Process multiple documents simultaneously for high-throughput summarization.</p>
+
+        <!-- Controls -->
+        <div class="batch-controls">
+            <button class="btn-secondary" id="loadSamplesBtn">Load Samples</button>
+            <button class="btn-primary" id="runBatchBtn">Run Batch</button>
+        </div>
+
+        <!-- Batch Table -->
+        <div class="batch-table-container">
+            <table class="batch-table">
+                <thead>
+                    <tr>
+                        <th>SOURCE PREVIEW</th>
+                        <th>MODELS</th>
+                        <th>STATUS</th>
+                        <th>ACTIONS</th>
+                    </tr>
+                </thead>
+                <tbody id="batchTableBody">
+                    <tr class="empty-state">
+                        <td colspan="4">
+                            <div class="empty-message">
+                                No items in the queue. Load samples or upload a CSV to begin.
+                            </div>
+                        </td>
+                    </tr>
+                </tbody>
+            </table>
+        </div>
+
+        <!-- Export Button -->
+        <div class="export-section">
+            <button class="btn-secondary" id="exportBtn">
+                <span>📥</span> Export All Results (CSV)
+            </button>
+        </div>
+    </div>
+
+    <!-- Footer -->
+    <footer class="footer">
+        <div class="footer-left">
+            <div class="logo-circle" style="width: 24px; height: 24px; font-size: 0.9rem;">S</div>
+            <span>Smart Summarizer</span>
+        </div>
+        <div class="footer-right">
+            <span>© 2025 Smart Summarizer. Abdul Razzaq Ansari</span>
+            <a href="https://github.com/Rajak13/Smart-Summarizer" target="_blank" class="footer-link">
+                <i class="fab fa-github"></i> GitHub Repository
+            </a>
+        </div>
+    </footer>
+
+    <script src="{{ url_for('static', filename='js/batch.js') }}"></script>
+</body>
+</html>

webapp/templates/comparison.html

@@ -0,0 +1,191 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Model Comparison - Smart Summarizer</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+</head>
+<body>
+    <!-- Top Navigation Bar -->
+    <nav class="top-navbar">
+        <a href="/" class="navbar-logo">
+            <div class="logo-circle">S</div>
+            <span>Smart Summarizer</span>
+        </a>
+        <div class="navbar-links">
+            <a href="/" class="nav-item">
+                <i class="fas fa-home"></i> Home
+            </a>
+            <a href="/single-summary" class="nav-item">
+                <i class="fas fa-file-alt"></i> Single Summary
+            </a>
+            <a href="/comparison" class="nav-item active">
+                <i class="fas fa-balance-scale"></i> Comparison
+            </a>
+            <a href="/batch" class="nav-item">
+                <i class="fas fa-layer-group"></i> Batch
+            </a>
+            <a href="/evaluation" class="nav-item">
+                <i class="fas fa-chart-bar"></i> Evaluation
+            </a>
+        </div>
+    </nav>
+
+    <!-- Page Content -->
+    <div class="page-container">
+        <h1 class="page-title">Model Comparison Matrix</h1>
+        <p class="page-subtitle">Compare extractive and abstractive strategies in real-time. Witness how graph-based ranking compares to transformer-based generation.</p>
+        
+        <!-- Input Section -->
+        <div class="comparison-input-section">
+            <textarea 
+                class="text-input" 
+                id="inputText"
+                placeholder="Input source text for cross-model analysis..."
+                style="min-height: 200px;"
+            ></textarea>
+        </div>
+        
+        <!-- Run Analysis Button -->
+        <div style="text-align: center; margin: 2rem 0;">
+            <button class="btn-generate" id="runAnalysisBtn" style="padding: 1rem 3rem;">
+                Run Analysis
+            </button>
+        </div>
+        
+        <!-- Results Grid -->
+        <div class="comparison-grid" id="resultsGrid">
+            <!-- TextRank Card -->
+            <div class="comparison-card">
+                <div class="comparison-header">
+                    <span class="model-indicator" style="background: #FFA500;"></span>
+                    <h3>TextRank</h3>
+                </div>
+                <div class="comparison-result" id="textrank-result">
+                    <div class="awaiting-text">Awaiting Analysis</div>
+                </div>
+            </div>
+            
+            <!-- BART Card -->
+            <div class="comparison-card">
+                <div class="comparison-header">
+                    <span class="model-indicator" style="background: #4A90E2;"></span>
+                    <h3>BART</h3>
+                </div>
+                <div class="comparison-result" id="bart-result">
+                    <div class="awaiting-text">Awaiting Analysis</div>
+                </div>
+            </div>
+            
+            <!-- PEGASUS Card -->
+            <div class="comparison-card">
+                <div class="comparison-header">
+                    <span class="model-indicator" style="background: #50C878;"></span>
+                    <h3>PEGASUS</h3>
+                </div>
+                <div class="comparison-result" id="pegasus-result">
+                    <div class="awaiting-text">Awaiting Analysis</div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Footer -->
+    <footer class="footer">
+        <div class="footer-left">
+            <div class="logo-circle" style="width: 24px; height: 24px; font-size: 0.9rem;">S</div>
+            <span>Smart Summarizer</span>
+        </div>
+        <div class="footer-right">
+            <span>© 2025 Smart Summarizer. Abdul Razzaq Ansari</span>
+            <a href="https://github.com/Rajak13/Smart-Summarizer" target="_blank" class="footer-link">
+                <i class="fab fa-github"></i> GitHub Repository
+            </a>
+        </div>
+    </footer>
+
+    <script>
+        const inputText = document.getElementById('inputText');
+        const runAnalysisBtn = document.getElementById('runAnalysisBtn');
+
+        runAnalysisBtn.addEventListener('click', async () => {
+            const text = inputText.value.trim();
+            
+            if (!text || text.split(/\s+/).length < 10) {
+                alert('Please enter at least 10 words of text');
+                return;
+            }
+            
+            // Show loading state
+            runAnalysisBtn.disabled = true;
+            runAnalysisBtn.textContent = 'Analyzing...';
+            
+            // Show loading in all cards
+            ['textrank', 'bart', 'pegasus'].forEach(model => {
+                document.getElementById(`${model}-result`).innerHTML = `
+                    <div class="spinner"></div>
+                    <div style="margin-top: 1rem; color: var(--slate-blue);">Processing...</div>
+                `;
+            });
+            
+            try {
+                const response = await fetch('/api/compare', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ text: text })
+                });
+                
+                const data = await response.json();
+                
+                if (data.success) {
+                    // Display results for each model
+                    Object.keys(data.results).forEach(model => {
+                        const result = data.results[model];
+                        const resultDiv = document.getElementById(`${model}-result`);
+                        
+                        if (result.error) {
+                            resultDiv.innerHTML = `
+                                <div style="color: #ef4444; padding: 1rem;">
+                                    <strong>Error:</strong> ${result.error}
+                                </div>
+                            `;
+                        } else {
+                            resultDiv.innerHTML = `
+                                <div class="summary-content">
+                                    ${result.summary}
+                                </div>
+                                <div class="summary-metrics">
+                                    <div class="metric-item">
+                                        <span class="metric-label">Time:</span>
+                                        <span class="metric-value">${result.metadata.processing_time.toFixed(2)}s</span>
+                                    </div>
+                                    <div class="metric-item">
+                                        <span class="metric-label">Compression:</span>
+                                        <span class="metric-value">${(result.metadata.compression_ratio * 100).toFixed(1)}%</span>
+                                    </div>
+                                    <div class="metric-item">
+                                        <span class="metric-label">Words:</span>
+                                        <span class="metric-value">${result.metadata.summary_length}</span>
+                                    </div>
+                                </div>
+                            `;
+                        }
+                    });
+                } else {
+                    alert('Error: ' + data.error);
+                }
+            } catch (error) {
+                alert('Failed to run analysis. Please try again.');
+                console.error(error);
+            } finally {
+                runAnalysisBtn.disabled = false;
+                runAnalysisBtn.textContent = 'Run Analysis';
+            }
+        });
+    </script>
+</body>
+</html>

webapp/templates/evaluation.html

@@ -0,0 +1,104 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Evaluation - Smart Summarizer</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+</head>
+<body>
+    <!-- Top Navigation Bar -->
+    <nav class="top-navbar">
+        <a href="/" class="navbar-logo">
+            <div class="logo-circle">S</div>
+            <span>Smart Summarizer</span>
+        </a>
+        <div class="navbar-links">
+            <a href="/" class="nav-item">
+                <i class="fas fa-home"></i> Home
+            </a>
+            <a href="/single-summary" class="nav-item">
+                <i class="fas fa-file-alt"></i> Single Summary
+            </a>
+            <a href="/comparison" class="nav-item">
+                <i class="fas fa-balance-scale"></i> Comparison
+            </a>
+            <a href="/batch" class="nav-item">
+                <i class="fas fa-layer-group"></i> Batch
+            </a>
+            <a href="/evaluation" class="nav-item active">
+                <i class="fas fa-chart-bar"></i> Evaluation
+            </a>
+        </div>
+    </nav>
+
+    <!-- Page Content -->
+    <div class="page-container">
+        <h1 class="page-title">Metric Benchmarks</h1>
+        <p class="page-subtitle">Aggregate performance data based on the ROUGE (Recall-Oriented Understudy for Gisting Evaluation) scoring system.</p>
+
+        <!-- Content Grid -->
+        <div class="evaluation-grid">
+            <!-- Chart Section -->
+            <div class="chart-section">
+                <div class="chart-container">
+                    <h3 class="chart-title">ROUGE Metric Comparison</h3>
+                    <canvas id="rougeChart"></canvas>
+                </div>
+            </div>
+
+            <!-- Metrics Explanation -->
+            <div class="metrics-explanation">
+                <h3 class="section-title">Understanding the Metrics</h3>
+                
+                <div class="metric-card">
+                    <div class="metric-header">
+                        <div class="metric-indicator" style="background: #6D8196;"></div>
+                        <h4>ROUGE-1</h4>
+                    </div>
+                    <p>Measures the overlap of unigrams (single words) between the generated summary and the reference text. High scores indicate good content coverage.</p>
+                </div>
+
+                <div class="metric-card">
+                    <div class="metric-header">
+                        <div class="metric-indicator" style="background: #CBCBCB;"></div>
+                        <h4>ROUGE-2</h4>
+                    </div>
+                    <p>Measures the overlap of bigrams (pairs of consecutive words). This is a strong indicator of fluency and phrasing quality.</p>
+                </div>
+
+                <div class="metric-card">
+                    <div class="metric-header">
+                        <div class="metric-indicator" style="background: #4A4A4A;"></div>
+                        <h4>ROUGE-L</h4>
+                    </div>
+                    <p>Based on the Longest Common Subsequence. It captures sentence structure and sequential flow more effectively than simple n-gram overlap.</p>
+                </div>
+
+                <div class="insight-box">
+                    <h4>MODEL INSIGHT</h4>
+                    <p>"BART and PEGASUS typically outperform TextRank in ROUGE-2 and ROUGE-L as they generate fluent, abstractive prose rather than just extracting source fragments."</p>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Footer -->
+    <footer class="footer">
+        <div class="footer-left">
+            <div class="logo-circle" style="width: 24px; height: 24px; font-size: 0.9rem;">S</div>
+            <span>Smart Summarizer</span>
+        </div>
+        <div class="footer-right">
+            <span>© 2025 Smart Summarizer. Abdul Razzaq Ansari</span>
+            <a href="https://github.com/Rajak13/Smart-Summarizer" target="_blank" class="footer-link">
+                <i class="fab fa-github"></i> GitHub Repository
+            </a>
+        </div>
+    </footer>
+
+    <script src="{{ url_for('static', filename='js/evaluation.js') }}"></script>
+</body>
+</html>

webapp/templates/home.html

@@ -0,0 +1,97 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Smart Summarizer - Home</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+</head>
+<body>
+    <!-- Top Navigation Bar -->
+    <nav class="top-navbar">
+        <a href="/" class="navbar-logo">
+            <div class="logo-circle">S</div>
+            <span>Smart Summarizer</span>
+        </a>
+        <div class="navbar-links">
+            <a href="/" class="nav-item active">
+                <i class="fas fa-home"></i> Home
+            </a>
+            <a href="/single-summary" class="nav-item">
+                <i class="fas fa-file-alt"></i> Single Summary
+            </a>
+            <a href="/comparison" class="nav-item">
+                <i class="fas fa-balance-scale"></i> Comparison
+            </a>
+            <a href="/batch" class="nav-item">
+                <i class="fas fa-layer-group"></i> Batch
+            </a>
+            <a href="/evaluation" class="nav-item">
+                <i class="fas fa-chart-bar"></i> Evaluation
+            </a>
+        </div>
+    </nav>
+
+    <!-- Hero Section -->
+    <div class="hero-container">
+        <h1 class="hero-title">Refined Intelligence.</h1>
+        <h1 class="hero-subtitle">Elegant Summaries.</h1>
+        
+        <p class="hero-description">A high-fidelity comparison platform for state-of-the-art NLP models.</p>
+        <p class="hero-description">Compare TextRank, BART, and PEGASUS with precision metrics.</p>
+        
+        <!-- CTA Buttons -->
+        <div class="cta-container">
+            <a href="/single-summary" class="btn-primary">Start Summarizing</a>
+            <a href="/evaluation" class="btn-secondary">View Evaluation</a>
+        </div>
+    </div>
+
+    <!-- Model Cards Section -->
+    <div class="models-container">
+        <div class="cards-grid">
+            <div class="model-card">
+                <span class="model-emoji">🎯</span>
+                <h3 class="model-name">TextRank</h3>
+                <p class="model-desc">
+                    Extractive graph-based model that identifies the most 
+                    salient sentences directly from the source.
+                </p>
+            </div>
+            
+            <div class="model-card">
+                <span class="model-emoji">💝</span>
+                <h3 class="model-name">BART</h3>
+                <p class="model-desc">
+                    Abstractive transformer-based model optimized for standard, 
+                    fluent summaries of varying length.
+                </p>
+            </div>
+            
+            <div class="model-card">
+                <span class="model-emoji">🚀</span>
+                <h3 class="model-name">PEGASUS</h3>
+                <p class="model-desc">
+                    Advanced abstractive model pre-trained specifically for 
+                    summarization tasks and gap prediction.
+                </p>
+            </div>
+        </div>
+    </div>
+
+    <!-- Footer -->
+    <footer class="footer">
+        <div class="footer-left">
+            <div class="logo-circle" style="width: 24px; height: 24px; font-size: 0.9rem;">S</div>
+            <span>Smart Summarizer</span>
+        </div>
+        <div class="footer-right">
+            <span>© 2025 Smart Summarizer. Abdul Razzaq Ansari</span>
+            <a href="https://github.com/Rajak13/Smart-Summarizer" target="_blank" class="footer-link">
+                <i class="fab fa-github"></i> GitHub Repository
+            </a>
+        </div>
+    </footer>
+</body>
+</html>

webapp/templates/single_summary.html

@@ -0,0 +1,287 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Single Summary - Smart Summarizer</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+</head>
+<body>
+    <!-- Top Navigation Bar -->
+    <nav class="top-navbar">
+        <a href="/" class="navbar-logo">
+            <div class="logo-circle">S</div>
+            <span>Smart Summarizer</span>
+        </a>
+        <div class="navbar-links">
+            <a href="/" class="nav-item">
+                <i class="fas fa-home"></i> Home
+            </a>
+            <a href="/single-summary" class="nav-item active">
+                <i class="fas fa-file-alt"></i> Single Summary
+            </a>
+            <a href="/comparison" class="nav-item">
+                <i class="fas fa-balance-scale"></i> Comparison
+            </a>
+            <a href="/batch" class="nav-item">
+                <i class="fas fa-layer-group"></i> Batch
+            </a>
+            <a href="/evaluation" class="nav-item">
+                <i class="fas fa-chart-bar"></i> Evaluation
+            </a>
+        </div>
+    </nav>
+
+    <!-- Page Content -->
+    <div class="page-container">
+        <h1 class="page-title">Single Model Summary</h1>
+        <p class="page-subtitle">Input your text and select a specialized model to begin.</p>
+        
+        <div class="content-grid">
+            <!-- Input Section -->
+            <div class="input-section">
+                <div class="section-label">Input Text</div>
+                
+                <!-- Input Method Tabs -->
+                <div class="input-tabs">
+                    <button class="tab-btn active" onclick="switchTab('paste')">Paste Text</button>
+                    <button class="tab-btn" onclick="switchTab('upload')">Upload File</button>
+                </div>
+                
+                <!-- Paste Text Tab -->
+                <div id="paste-tab" class="tab-content active">
+                    <textarea 
+                        class="text-input" 
+                        id="inputText"
+                        placeholder="Paste your source text here..."
+                    ></textarea>
+                    <div class="char-count">
+                        <span id="charCount">0 characters</span>
+                        <span id="wordCount">0 words</span>
+                    </div>
+                </div>
+                
+                <!-- Upload File Tab -->
+                <div id="upload-tab" class="tab-content">
+                    <div class="upload-area" id="uploadArea">
+                        <div class="upload-icon">📄</div>
+                        <p>Drag and drop a file here or click to browse</p>
+                        <p class="upload-hint">Supported formats: .txt, .md, .pdf, .docx, .doc (Max 16MB)</p>
+                        <input type="file" id="fileInput" accept=".txt,.md,.pdf,.docx,.doc" style="display: none;">
+                    </div>
+                    <div id="fileInfo" class="file-info" style="display: none;">
+                        <span id="fileName"></span>
+                        <button class="btn-remove" onclick="removeFile()">Remove</button>
+                    </div>
+                </div>
+            </div>
+            
+            <!-- Output Section -->
+            <div class="output-section">
+                <div class="section-label">Output Preview</div>
+                <div class="output-preview" id="outputPreview">
+                    <div class="icon">✨</div>
+                    <div>Summary will appear here</div>
+                </div>
+            </div>
+        </div>
+        
+        <!-- Controls -->
+        <div class="controls-section">
+            <select class="model-select" id="modelSelect">
+                <option value="bart">BART</option>
+                <option value="textrank">TextRank</option>
+                <option value="pegasus">PEGASUS</option>
+            </select>
+            
+            <button class="btn-generate" id="generateBtn">
+                Generate Summary
+            </button>
+        </div>
+    </div>
+
+    <!-- Footer -->
+    <footer class="footer">
+        <div class="footer-left">
+            <div class="logo-circle" style="width: 24px; height: 24px; font-size: 0.9rem;">S</div>
+            <span>Smart Summarizer</span>
+        </div>
+        <div class="footer-right">
+            <span>© 2025 Smart Summarizer. Abdul Razzaq Ansari</span>
+            <a href="https://github.com/Rajak13/Smart-Summarizer" target="_blank" class="footer-link">
+                <i class="fab fa-github"></i> GitHub Repository
+            </a>
+        </div>
+    </footer>
+
+    <script>
+        const inputText = document.getElementById('inputText');
+        const charCount = document.getElementById('charCount');
+        const wordCount = document.getElementById('wordCount');
+        const generateBtn = document.getElementById('generateBtn');
+        const modelSelect = document.getElementById('modelSelect');
+        const outputPreview = document.getElementById('outputPreview');
+        const fileInput = document.getElementById('fileInput');
+        const uploadArea = document.getElementById('uploadArea');
+        const fileInfo = document.getElementById('fileInfo');
+        const fileName = document.getElementById('fileName');
+
+        // Tab switching
+        function switchTab(tab) {
+            document.querySelectorAll('.tab-btn').forEach(btn => btn.classList.remove('active'));
+            document.querySelectorAll('.tab-content').forEach(content => content.classList.remove('active'));
+            
+            if (tab === 'paste') {
+                document.querySelector('.tab-btn:first-child').classList.add('active');
+                document.getElementById('paste-tab').classList.add('active');
+            } else {
+                document.querySelector('.tab-btn:last-child').classList.add('active');
+                document.getElementById('upload-tab').classList.add('active');
+            }
+        }
+
+        // Update character and word count
+        inputText.addEventListener('input', () => {
+            const text = inputText.value;
+            const chars = text.length;
+            const words = text.trim().split(/\s+/).filter(word => word.length > 0).length;
+            
+            charCount.textContent = `${chars} characters`;
+            wordCount.textContent = `${words} words`;
+        });
+
+        // File upload handling
+        uploadArea.addEventListener('click', () => fileInput.click());
+        
+        uploadArea.addEventListener('dragover', (e) => {
+            e.preventDefault();
+            uploadArea.style.borderColor = 'var(--slate-blue)';
+            uploadArea.style.background = 'rgba(109, 129, 150, 0.05)';
+        });
+        
+        uploadArea.addEventListener('dragleave', () => {
+            uploadArea.style.borderColor = 'var(--cool-gray)';
+            uploadArea.style.background = 'transparent';
+        });
+        
+        uploadArea.addEventListener('drop', async (e) => {
+            e.preventDefault();
+            uploadArea.style.borderColor = 'var(--cool-gray)';
+            uploadArea.style.background = 'transparent';
+            
+            const file = e.dataTransfer.files[0];
+            if (file) {
+                await handleFileUpload(file);
+            }
+        });
+        
+        fileInput.addEventListener('change', async (e) => {
+            const file = e.target.files[0];
+            if (file) {
+                await handleFileUpload(file);
+            }
+        });
+
+        async function handleFileUpload(file) {
+            const formData = new FormData();
+            formData.append('file', file);
+            
+            try {
+                const response = await fetch('/api/upload', {
+                    method: 'POST',
+                    body: formData
+                });
+                
+                const data = await response.json();
+                
+                if (data.success) {
+                    inputText.value = data.text;
+                    inputText.dispatchEvent(new Event('input'));
+                    
+                    fileName.textContent = `${data.filename} (${data.word_count} words)`;
+                    fileInfo.style.display = 'flex';
+                    uploadArea.style.display = 'none';
+                    
+                    // Switch to paste tab to show the text
+                    switchTab('paste');
+                } else {
+                    alert('Error: ' + data.error);
+                }
+            } catch (error) {
+                alert('Failed to upload file. Please try again.');
+                console.error(error);
+            }
+        }
+
+        function removeFile() {
+            fileInput.value = '';
+            fileInfo.style.display = 'none';
+            uploadArea.style.display = 'flex';
+            inputText.value = '';
+            inputText.dispatchEvent(new Event('input'));
+        }
+
+        // Generate summary
+        generateBtn.addEventListener('click', async () => {
+            const text = inputText.value.trim();
+            const model = modelSelect.value;
+            
+            if (!text || text.split(/\s+/).length < 10) {
+                alert('Please enter at least 10 words of text');
+                return;
+            }
+            
+            // Show loading state
+            generateBtn.disabled = true;
+            generateBtn.textContent = 'Generating...';
+            outputPreview.innerHTML = '<div class="spinner"></div><div>Processing your text...</div>';
+            
+            try {
+                const response = await fetch('/api/summarize', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        text: text,
+                        model: model
+                    })
+                });
+                
+                const data = await response.json();
+                
+                if (data.success) {
+                    // Display summary
+                    outputPreview.innerHTML = `
+                        <div class="output-text">
+                            <strong>Summary (${model.toUpperCase()}):</strong><br><br>
+                            ${data.summary}
+                            <br><br>
+                            <small style="color: var(--slate-blue);">
+                                Processing time: ${data.metadata.processing_time.toFixed(2)}s | 
+                                Compression: ${(data.metadata.compression_ratio * 100).toFixed(1)}%
+                            </small>
+                        </div>
+                    `;
+                } else {
+                    outputPreview.innerHTML = `
+                        <div style="color: #ef4444;">
+                            <strong>Error:</strong> ${data.error}
+                        </div>
+                    `;
+                }
+            } catch (error) {
+                outputPreview.innerHTML = `
+                    <div style="color: #ef4444;">
+                        <strong>Error:</strong> Failed to generate summary. Please try again.
+                    </div>
+                `;
+            } finally {
+                generateBtn.disabled = false;
+                generateBtn.textContent = 'Generate Summary';
+            }
+        });
+    </script>
+</body>
+</html>