diff --git "a/notebooks/Smart-Summarizer.ipynb" "b/notebooks/Smart-Summarizer.ipynb" new file mode 100644--- /dev/null +++ "b/notebooks/Smart-Summarizer.ipynb" @@ -0,0 +1,1438 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "main-title", + "metadata": {}, + "source": [ + "# πŸ€– Smart Summarizer: Comprehensive Analysis & Model Comparison\n", + "\n", + "**A complete analysis of three state-of-the-art text summarization models:**\n", + "- **TextRank** (Extractive - Graph-based PageRank)\n", + "- **BART** (Abstractive - Transformer Encoder-Decoder) \n", + "- **PEGASUS** (Abstractive - Gap Sentence Generation)\n", + "\n", + "---\n", + "\n", + "## πŸ“‹ Table of Contents\n", + "1. [Environment Setup & Imports](#setup)\n", + "2. [Dataset Exploration](#data)\n", + "3. [Data Preprocessing & Train-Test Split](#preprocessing)\n", + "4. [Model Implementation & Testing](#models)\n", + "5. [Model Evaluation & Metrics](#evaluation)\n", + "6. [Comparative Analysis](#comparison)\n", + "7. [Insights & Visualizations](#insights)\n", + "8. [Performance Benchmarking](#benchmarking)\n", + "9. [Conclusions & Recommendations](#conclusions)\n", + "\n", + "---\n", + "\n", + "**Author:** Abdul Razzaq Ansari \n", + "**Date:** January 2025 \n", + "**Project:** Smart Summarizer" + ] + }, + { + "cell_type": "markdown", + "id": "setup-section", + "metadata": {}, + "source": [ + "## 1. Environment Setup & Library Imports\n", + "\n", + "Setting up the environment with all necessary libraries for:\n", + "- Data analysis and manipulation\n", + "- Model implementation and evaluation\n", + "- Visualization and reporting\n", + "- Performance benchmarking" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1b2c317b-4d2e-47c4-9a9a-059184629e93", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: plotly in /opt/anaconda3/envs/Workshop2/lib/python3.13/site-packages (6.5.0)\n", + "Requirement already satisfied: narwhals>=1.15.1 in /opt/anaconda3/envs/Workshop2/lib/python3.13/site-packages (from plotly) (2.14.0)\n", + "Requirement already satisfied: packaging in /opt/anaconda3/envs/Workshop2/lib/python3.13/site-packages (from plotly) (25.0)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "pip install plotly" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "imports", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "πŸ“ Project root: /Users/rajak/Downloads/Smart-Summarizer\n", + "⚠️ Custom model import error: cannot import name 'SummaryEvaluator' from 'utils.evaluator' (/Users/rajak/Downloads/Smart-Summarizer/utils/evaluator.py)\n", + "Will use alternative implementations...\n", + "\n", + "🎯 Environment Setup Complete!\n", + "🐍 Python version: 3.13.9\n", + "πŸ”₯ PyTorch version: 2.9.1\n", + "πŸ€— CUDA available: False\n", + "πŸ“Š Pandas version: 2.3.3\n", + "πŸ”’ NumPy version: 2.3.4\n" + ] + } + ], + "source": [ + "# Core libraries\n", + "import sys\n", + "import os\n", + "import json\n", + "import pandas as pd\n", + "import numpy as np\n", + "from pathlib import Path\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Visualization libraries\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import plotly.express as px\n", + "import plotly.graph_objects as go\n", + "from plotly.subplots import make_subplots\n", + "\n", + "# NLP and ML libraries\n", + "import nltk\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import accuracy_score, classification_report\n", + "from rouge_score import rouge_scorer\n", + "import torch\n", + "from transformers import pipeline\n", + "\n", + "# Time and progress tracking\n", + "import time\n", + "from tqdm import tqdm\n", + "tqdm.pandas()\n", + "\n", + "# Statistical analysis\n", + "from scipy import stats\n", + "from scipy.stats import pearsonr, spearmanr\n", + "\n", + "# Add project root to path\n", + "project_root = Path().absolute().parent if 'notebooks' in str(Path().absolute()) else Path().absolute()\n", + "sys.path.append(str(project_root))\n", + "\n", + "print(f\"πŸ“ Project root: {project_root}\")\n", + "\n", + "# Import our custom models\n", + "try:\n", + " from models.textrank import TextRankSummarizer\n", + " from models.bart import BARTSummarizer\n", + " from models.pegasus import PEGASUSSummarizer\n", + " from utils.evaluator import SummaryEvaluator\n", + " print(\"βœ… Custom models imported successfully!\")\n", + "except ImportError as e:\n", + " print(f\"⚠️ Custom model import error: {e}\")\n", + " print(\"Will use alternative implementations...\")\n", + "\n", + "# Set style for plots\n", + "plt.style.use('default')\n", + "sns.set_palette(\"husl\")\n", + "plt.rcParams['figure.figsize'] = (12, 8)\n", + "plt.rcParams['font.size'] = 12\n", + "\n", + "print(\"\\n🎯 Environment Setup Complete!\")\n", + "print(f\"🐍 Python version: {sys.version.split()[0]}\")\n", + "print(f\"πŸ”₯ PyTorch version: {torch.__version__}\")\n", + "print(f\"πŸ€— CUDA available: {torch.cuda.is_available()}\")\n", + "print(f\"πŸ“Š Pandas version: {pd.__version__}\")\n", + "print(f\"πŸ”’ NumPy version: {np.__version__}\")" + ] + }, + { + "cell_type": "markdown", + "id": "data-section", + "metadata": {}, + "source": [ + "## 2. Dataset Exploration\n", + "\n", + "Loading and exploring the CNN/DailyMail dataset to understand:\n", + "- Dataset structure and columns\n", + "- Text length distributions\n", + "- Summary characteristics\n", + "- Data quality assessment" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "load-data", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "πŸ“‚ Loading data from: /Users/rajak/Downloads/Smart-Summarizer/data/samples/cnn_dailymail_test.json\n", + "πŸ“Š Dataset loaded successfully!\n", + "πŸ“ Dataset shape: (20, 3)\n", + "πŸ” Columns: ['article', 'reference_summary', 'id']\n", + "\n", + "πŸ“‹ Dataset Info:\n", + "\n", + "RangeIndex: 20 entries, 0 to 19\n", + "Data columns (total 3 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 article 20 non-null object\n", + " 1 reference_summary 20 non-null object\n", + " 2 id 20 non-null object\n", + "dtypes: object(3)\n", + "memory usage: 612.0+ bytes\n" + ] + } + ], + "source": [ + "# Load the dataset\n", + "data_path = project_root / 'data' / 'samples' / 'cnn_dailymail_test.json'\n", + "print(f\"πŸ“‚ Loading data from: {data_path}\")\n", + "\n", + "# Load JSON data\n", + "with open(data_path, 'r') as f:\n", + " raw_data = json.load(f)\n", + "\n", + "# Convert to DataFrame\n", + "df = pd.DataFrame(raw_data)\n", + "\n", + "print(f\"πŸ“Š Dataset loaded successfully!\")\n", + "print(f\"πŸ“ Dataset shape: {df.shape}\")\n", + "print(f\"πŸ” Columns: {list(df.columns)}\")\n", + "\n", + "# Display basic info\n", + "print(\"\\nπŸ“‹ Dataset Info:\")\n", + "df.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "explore-data", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "πŸ” First 3 rows of the dataset:\n", + "================================================================================\n", + "\n", + "πŸ“° Article 1:\n", + "ID: f001ec5c4704938247d27a44948eebb37ae98d01\n", + "Article (first 200 chars): (CNN)The Palestinian Authority officially became the 123rd member of the International Criminal Court on Wednesday, a step that gives the court jurisdiction over alleged crimes in Palestinian territor...\n", + "Reference Summary: Membership gives the ICC jurisdiction over alleged crimes committed in Palestinian territories since last June .\n", + "Israel and the United States opposed the move, which could open the door to war crimes investigations against Israelis .\n", + "--------------------------------------------------------------------------------\n", + "\n", + "πŸ“° Article 2:\n", + "ID: 230c522854991d053fe98a718b1defa077a8efef\n", + "Article (first 200 chars): (CNN)Never mind cats having nine lives. A stray pooch in Washington State has used up at least three of her own after being hit by a car, apparently whacked on the head with a hammer in a misguided me...\n", + "Reference Summary: Theia, a bully breed mix, was apparently hit by a car, whacked with a hammer and buried in a field .\n", + "\"She's a true miracle dog and she deserves a good life,\" says Sara Mellado, who is looking for a home for Theia .\n", + "--------------------------------------------------------------------------------\n", + "\n", + "πŸ“° Article 3:\n", + "ID: 4495ba8f3a340d97a9df1476f8a35502bcce1f69\n", + "Article (first 200 chars): (CNN)If you've been following the news lately, there are certain things you doubtless know about Mohammad Javad Zarif. He is, of course, the Iranian foreign minister. He has been U.S. Secretary of Sta...\n", + "Reference Summary: Mohammad Javad Zarif has spent more time with John Kerry than any other foreign minister .\n", + "He once participated in a takeover of the Iranian Consulate in San Francisco .\n", + "The Iranian foreign minister tweets in English .\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "# Explore the first few rows\n", + "print(\"πŸ” First 3 rows of the dataset:\")\n", + "print(\"=\" * 80)\n", + "\n", + "for i in range(min(3, len(df))):\n", + " print(f\"\\nπŸ“° Article {i+1}:\")\n", + " print(f\"ID: {df.iloc[i]['id']}\")\n", + " print(f\"Article (first 200 chars): {df.iloc[i]['article'][:200]}...\")\n", + " print(f\"Reference Summary: {df.iloc[i]['reference_summary']}\")\n", + " print(\"-\" * 80)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "data-statistics", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "πŸ“Š Text Statistics:\n", + " article_length article_words summary_length summary_words \\\n", + "count 20.00 20.00 20.00 20.00 \n", + "mean 3215.15 530.35 216.10 36.70 \n", + "std 1879.04 298.37 67.26 10.32 \n", + "min 630.00 111.00 105.00 18.00 \n", + "25% 2010.00 343.00 157.75 28.75 \n", + "50% 2697.50 452.50 217.50 36.50 \n", + "75% 4519.75 746.75 255.25 44.25 \n", + "max 7146.00 1133.00 346.00 56.00 \n", + "\n", + " compression_ratio \n", + "count 20.00 \n", + "mean 0.10 \n", + "std 0.07 \n", + "min 0.04 \n", + "25% 0.05 \n", + "50% 0.07 \n", + "75% 0.11 \n", + "max 0.30 \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "🎯 Key Insights:\n", + "πŸ“° Average article length: 530 words\n", + "πŸ“ Average summary length: 37 words\n", + "πŸ—œοΈ Average compression ratio: 9.5%\n", + "πŸ”— Article-Summary correlation: 0.548\n" + ] + } + ], + "source": [ + "# Calculate text statistics\n", + "df['article_length'] = df['article'].str.len()\n", + "df['article_words'] = df['article'].str.split().str.len()\n", + "df['summary_length'] = df['reference_summary'].str.len()\n", + "df['summary_words'] = df['reference_summary'].str.split().str.len()\n", + "df['compression_ratio'] = df['summary_words'] / df['article_words']\n", + "\n", + "# Display statistics\n", + "print(\"πŸ“Š Text Statistics:\")\n", + "stats_df = df[['article_length', 'article_words', 'summary_length', 'summary_words', 'compression_ratio']].describe()\n", + "print(stats_df.round(2))\n", + "\n", + "# Create visualizations\n", + "fig, axes = plt.subplots(2, 2, figsize=(15, 12))\n", + "fig.suptitle('πŸ“Š Dataset Statistics Overview', fontsize=16, fontweight='bold')\n", + "\n", + "# Article word count distribution\n", + "axes[0,0].hist(df['article_words'], bins=30, alpha=0.7, color='skyblue', edgecolor='black')\n", + "axes[0,0].set_title('πŸ“° Article Word Count Distribution')\n", + "axes[0,0].set_xlabel('Number of Words')\n", + "axes[0,0].set_ylabel('Frequency')\n", + "axes[0,0].axvline(df['article_words'].mean(), color='red', linestyle='--', label=f'Mean: {df[\"article_words\"].mean():.0f}')\n", + "axes[0,0].legend()\n", + "\n", + "# Summary word count distribution\n", + "axes[0,1].hist(df['summary_words'], bins=30, alpha=0.7, color='lightgreen', edgecolor='black')\n", + "axes[0,1].set_title('πŸ“ Summary Word Count Distribution')\n", + "axes[0,1].set_xlabel('Number of Words')\n", + "axes[0,1].set_ylabel('Frequency')\n", + "axes[0,1].axvline(df['summary_words'].mean(), color='red', linestyle='--', label=f'Mean: {df[\"summary_words\"].mean():.0f}')\n", + "axes[0,1].legend()\n", + "\n", + "# Compression ratio distribution\n", + "axes[1,0].hist(df['compression_ratio'], bins=30, alpha=0.7, color='orange', edgecolor='black')\n", + "axes[1,0].set_title('πŸ—œοΈ Compression Ratio Distribution')\n", + "axes[1,0].set_xlabel('Compression Ratio (Summary/Article)')\n", + "axes[1,0].set_ylabel('Frequency')\n", + "axes[1,0].axvline(df['compression_ratio'].mean(), color='red', linestyle='--', label=f'Mean: {df[\"compression_ratio\"].mean():.3f}')\n", + "axes[1,0].legend()\n", + "\n", + "# Scatter plot: Article vs Summary length\n", + "axes[1,1].scatter(df['article_words'], df['summary_words'], alpha=0.6, color='purple')\n", + "axes[1,1].set_title('πŸ“Š Article vs Summary Length Correlation')\n", + "axes[1,1].set_xlabel('Article Words')\n", + "axes[1,1].set_ylabel('Summary Words')\n", + "\n", + "# Add correlation coefficient\n", + "corr_coef = df['article_words'].corr(df['summary_words'])\n", + "axes[1,1].text(0.05, 0.95, f'Correlation: {corr_coef:.3f}', transform=axes[1,1].transAxes, \n", + " bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(f\"\\n🎯 Key Insights:\")\n", + "print(f\"πŸ“° Average article length: {df['article_words'].mean():.0f} words\")\n", + "print(f\"πŸ“ Average summary length: {df['summary_words'].mean():.0f} words\")\n", + "print(f\"πŸ—œοΈ Average compression ratio: {df['compression_ratio'].mean():.1%}\")\n", + "print(f\"πŸ”— Article-Summary correlation: {corr_coef:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "preprocessing-section", + "metadata": {}, + "source": [ + "## 3. Data Preprocessing & Train-Test Split\n", + "\n", + "Preparing the data for model training and evaluation:\n", + "- Data cleaning and validation\n", + "- Train-test split for proper evaluation\n", + "- Text preprocessing for different models" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "preprocessing", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧹 Data Preprocessing...\n", + "πŸ“Š Removed 0 rows with missing data\n", + "πŸ“Š Filtered dataset: 20 articles\n", + "πŸ“Š Removed 0 articles (too short)\n", + "\n", + "🎯 Dataset Split:\n", + "πŸ“š Training set: 16 articles (80.0%)\n", + "πŸ§ͺ Test set: 4 articles (20.0%)\n", + "\n", + "πŸ“Š Split Statistics:\n", + "Training - Avg article words: 467\n", + "Training - Avg summary words: 35\n", + "Test - Avg article words: 785\n", + "Test - Avg summary words: 45\n", + "\n", + "🎯 Using sample of 4 articles for model evaluation\n" + ] + } + ], + "source": [ + "# Data preprocessing and validation\n", + "print(\"🧹 Data Preprocessing...\")\n", + "\n", + "# Remove any rows with missing data\n", + "initial_count = len(df)\n", + "df_clean = df.dropna().copy()\n", + "print(f\"πŸ“Š Removed {initial_count - len(df_clean)} rows with missing data\")\n", + "\n", + "# Filter out very short articles or summaries\n", + "min_article_words = 50\n", + "min_summary_words = 5\n", + "\n", + "df_filtered = df_clean[\n", + " (df_clean['article_words'] >= min_article_words) & \n", + " (df_clean['summary_words'] >= min_summary_words)\n", + "].copy()\n", + "\n", + "print(f\"πŸ“Š Filtered dataset: {len(df_filtered)} articles\")\n", + "print(f\"πŸ“Š Removed {len(df_clean) - len(df_filtered)} articles (too short)\")\n", + "\n", + "# Train-test split (80-20)\n", + "train_df, test_df = train_test_split(\n", + " df_filtered, \n", + " test_size=0.2, \n", + " random_state=42,\n", + " stratify=None # No stratification for regression-like task\n", + ")\n", + "\n", + "print(f\"\\n🎯 Dataset Split:\")\n", + "print(f\"πŸ“š Training set: {len(train_df)} articles ({len(train_df)/len(df_filtered):.1%})\")\n", + "print(f\"πŸ§ͺ Test set: {len(test_df)} articles ({len(test_df)/len(df_filtered):.1%})\")\n", + "\n", + "# Display split statistics\n", + "print(f\"\\nπŸ“Š Split Statistics:\")\n", + "print(f\"Training - Avg article words: {train_df['article_words'].mean():.0f}\")\n", + "print(f\"Training - Avg summary words: {train_df['summary_words'].mean():.0f}\")\n", + "print(f\"Test - Avg article words: {test_df['article_words'].mean():.0f}\")\n", + "print(f\"Test - Avg summary words: {test_df['summary_words'].mean():.0f}\")\n", + "\n", + "# For demonstration, we'll use a smaller subset for faster processing\n", + "sample_size = min(20, len(test_df))\n", + "test_sample = test_df.head(sample_size).copy()\n", + "print(f\"\\n🎯 Using sample of {sample_size} articles for model evaluation\")" + ] + }, + { + "cell_type": "markdown", + "id": "models-section", + "metadata": {}, + "source": [ + "## 4. Model Implementation & Testing\n", + "\n", + "Implementing and testing all three summarization models:\n", + "- **TextRank**: Graph-based extractive summarization\n", + "- **BART**: Transformer-based abstractive summarization\n", + "- **PEGASUS**: Specialized abstractive summarization model" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "initialize-models", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:models.base_summarizer:Initializing TextRank (Extractive) summarizer\n", + "INFO:models.textrank:TextRank summarizer initialized successfully\n", + "INFO:models.base_summarizer:Initializing BART (Abstractive) summarizer\n", + "INFO:models.bart:Loading BART model: facebook/bart-large-cnn\n", + "INFO:models.bart:Initial model loading may take 2-3 minutes...\n", + "INFO:models.bart:Using device: cpu\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "πŸ€– Initializing Models...\n", + "πŸ“Š Loading TextRank...\n", + "βœ… TextRank loaded successfully\n", + "πŸ€— Loading BART...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:models.bart:BART model loaded successfully!\n", + "INFO:models.base_summarizer:Initializing PEGASUS (Abstractive) summarizer\n", + "INFO:models.pegasus:Loading PEGASUS model: google/pegasus-cnn_dailymail\n", + "INFO:models.pegasus:PEGASUS is a large model. Initial loading may take 3-5 minutes...\n", + "INFO:models.pegasus:Using device: cpu\n", + "INFO:models.pegasus:Loading tokenizer...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "βœ… BART loaded successfully\n", + "πŸš€ Loading PEGASUS...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:models.pegasus:Loading model weights...\n", + "Some weights of PegasusForConditionalGeneration were not initialized from the model checkpoint at google/pegasus-cnn_dailymail and are newly initialized: ['model.decoder.embed_positions.weight', 'model.encoder.embed_positions.weight']\n", + "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n", + "INFO:models.pegasus:PEGASUS model loaded successfully!\n", + "INFO:models.pegasus:Model size: 568.7M parameters\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "βœ… PEGASUS loaded successfully\n", + "\n", + "🎯 Successfully loaded 3 models:\n", + " β€’ TextRank (Extractive): Graph-based PageRank algorithm for sentence ranking\n", + " β€’ BART (Abstractive): Bidirectional and Auto-Regressive Transformer\n", + " β€’ PEGASUS (Abstractive): Pre-training with Extracted Gap-sentences for Abstractive SUmmarization\n" + ] + } + ], + "source": [ + "# Initialize models\n", + "print(\"πŸ€– Initializing Models...\")\n", + "\n", + "models = {}\n", + "model_info = {}\n", + "\n", + "# TextRank Model\n", + "try:\n", + " print(\"πŸ“Š Loading TextRank...\")\n", + " models['textrank'] = TextRankSummarizer()\n", + " model_info['textrank'] = {\n", + " 'name': 'TextRank',\n", + " 'type': 'Extractive',\n", + " 'description': 'Graph-based PageRank algorithm for sentence ranking'\n", + " }\n", + " print(\"βœ… TextRank loaded successfully\")\n", + "except Exception as e:\n", + " print(f\"❌ TextRank loading failed: {e}\")\n", + "\n", + "# BART Model\n", + "try:\n", + " print(\"πŸ€— Loading BART...\")\n", + " models['bart'] = BARTSummarizer(device='cpu') # Use CPU for compatibility\n", + " model_info['bart'] = {\n", + " 'name': 'BART',\n", + " 'type': 'Abstractive',\n", + " 'description': 'Bidirectional and Auto-Regressive Transformer'\n", + " }\n", + " print(\"βœ… BART loaded successfully\")\n", + "except Exception as e:\n", + " print(f\"❌ BART loading failed: {e}\")\n", + " # Fallback to HuggingFace pipeline\n", + " try:\n", + " models['bart'] = pipeline('summarization', model='facebook/bart-large-cnn')\n", + " model_info['bart'] = {\n", + " 'name': 'BART (Pipeline)',\n", + " 'type': 'Abstractive',\n", + " 'description': 'BART via HuggingFace Pipeline'\n", + " }\n", + " print(\"βœ… BART pipeline loaded as fallback\")\n", + " except Exception as e2:\n", + " print(f\"❌ BART pipeline also failed: {e2}\")\n", + "\n", + "# PEGASUS Model\n", + "try:\n", + " print(\"πŸš€ Loading PEGASUS...\")\n", + " models['pegasus'] = PEGASUSSummarizer(device='cpu')\n", + " model_info['pegasus'] = {\n", + " 'name': 'PEGASUS',\n", + " 'type': 'Abstractive',\n", + " 'description': 'Pre-training with Extracted Gap-sentences for Abstractive SUmmarization'\n", + " }\n", + " print(\"βœ… PEGASUS loaded successfully\")\n", + "except Exception as e:\n", + " print(f\"❌ PEGASUS loading failed: {e}\")\n", + " # Fallback to HuggingFace pipeline\n", + " try:\n", + " models['pegasus'] = pipeline('summarization', model='google/pegasus-cnn_dailymail')\n", + " model_info['pegasus'] = {\n", + " 'name': 'PEGASUS (Pipeline)',\n", + " 'type': 'Abstractive',\n", + " 'description': 'PEGASUS via HuggingFace Pipeline'\n", + " }\n", + " print(\"βœ… PEGASUS pipeline loaded as fallback\")\n", + " except Exception as e2:\n", + " print(f\"❌ PEGASUS pipeline also failed: {e2}\")\n", + "\n", + "print(f\"\\n🎯 Successfully loaded {len(models)} models:\")\n", + "for model_name, info in model_info.items():\n", + " print(f\" β€’ {info['name']} ({info['type']}): {info['description']}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "model-testing", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "πŸ§ͺ Testing Models on Sample Data...\n", + "\n", + "πŸ“° Processing Article 1/4\n", + "ID: f001ec5c4704938247d27a44948eebb37ae98d01\n", + "Article length: 567 words\n", + " οΏ½οΏ½οΏ½οΏ½ Testing TEXTRANK...\n", + " βœ… Generated summary (96 words) in 0.03s\n", + " πŸ€– Testing BART...\n", + " βœ… Generated summary (37 words) in 7.27s\n", + " πŸ€– Testing PEGASUS...\n", + " βœ… Generated summary (24 words) in 4.34s\n", + "\n", + "πŸ“° Processing Article 18/4\n", + "ID: 469c6ac05092ca5997728c9dfc19f9ab6b936e40\n", + "Article length: 1133 words\n", + " πŸ€– Testing TEXTRANK...\n", + " βœ… Generated summary (83 words) in 0.01s\n", + " πŸ€– Testing BART...\n", + " βœ… Generated summary (45 words) in 4.65s\n", + " πŸ€– Testing PEGASUS...\n", + " βœ… Generated summary (42 words) in 6.45s\n", + "\n", + "πŸ“° Processing Article 16/4\n", + "ID: dc833f8b55e381011ce23f89ea909b9a141b5a66\n", + "Article length: 1028 words\n", + " πŸ€– Testing TEXTRANK...\n", + " βœ… Generated summary (97 words) in 0.00s\n", + " πŸ€– Testing BART...\n", + " βœ… Generated summary (31 words) in 3.84s\n", + " πŸ€– Testing PEGASUS...\n", + " βœ… Generated summary (27 words) in 4.88s\n", + "\n", + "πŸ“° Processing Article 2/4\n", + "ID: 230c522854991d053fe98a718b1defa077a8efef\n", + "Article length: 411 words\n", + " πŸ€– Testing TEXTRANK...\n", + " βœ… Generated summary (97 words) in 0.00s\n", + " πŸ€– Testing BART...\n", + " βœ… Generated summary (51 words) in 5.60s\n", + " πŸ€– Testing PEGASUS...\n", + " βœ… Generated summary (31 words) in 5.43s\n", + "\n", + "βœ… Model testing completed!\n", + "πŸ“Š Processed 4 articles with 3 models\n" + ] + } + ], + "source": [ + "# Test each model on sample data\n", + "print(\"πŸ§ͺ Testing Models on Sample Data...\")\n", + "\n", + "# Initialize results storage\n", + "results = []\n", + "processing_times = {}\n", + "\n", + "# Test each model\n", + "for idx, row in test_sample.iterrows():\n", + " article = row['article']\n", + " reference = row['reference_summary']\n", + " article_id = row['id']\n", + " \n", + " print(f\"\\nπŸ“° Processing Article {idx + 1}/{len(test_sample)}\")\n", + " print(f\"ID: {article_id}\")\n", + " print(f\"Article length: {len(article.split())} words\")\n", + " \n", + " article_results = {\n", + " 'id': article_id,\n", + " 'article': article,\n", + " 'reference_summary': reference,\n", + " 'article_words': len(article.split()),\n", + " 'reference_words': len(reference.split())\n", + " }\n", + " \n", + " # Test each available model\n", + " for model_name, model in models.items():\n", + " try:\n", + " print(f\" πŸ€– Testing {model_name.upper()}...\")\n", + " start_time = time.time()\n", + " \n", + " # Generate summary based on model type\n", + " if hasattr(model, 'summarize'):\n", + " # Custom model with summarize method\n", + " if model_name == 'textrank':\n", + " summary = model.summarize(article, num_sentences=3)\n", + " else:\n", + " summary = model.summarize(article, max_length=100, min_length=30)\n", + " else:\n", + " # HuggingFace pipeline\n", + " summary_result = model(article, max_length=100, min_length=30, do_sample=False)\n", + " summary = summary_result[0]['summary_text']\n", + " \n", + " end_time = time.time()\n", + " processing_time = end_time - start_time\n", + " \n", + " # Store results\n", + " article_results[f'{model_name}_summary'] = summary\n", + " article_results[f'{model_name}_words'] = len(summary.split())\n", + " article_results[f'{model_name}_time'] = processing_time\n", + " \n", + " # Track processing times\n", + " if model_name not in processing_times:\n", + " processing_times[model_name] = []\n", + " processing_times[model_name].append(processing_time)\n", + " \n", + " print(f\" βœ… Generated summary ({len(summary.split())} words) in {processing_time:.2f}s\")\n", + " \n", + " except Exception as e:\n", + " print(f\" ❌ {model_name.upper()} failed: {e}\")\n", + " article_results[f'{model_name}_summary'] = \"Error: Failed to generate summary\"\n", + " article_results[f'{model_name}_words'] = 0\n", + " article_results[f'{model_name}_time'] = 0\n", + " \n", + " results.append(article_results)\n", + "\n", + "print(f\"\\nβœ… Model testing completed!\")\n", + "print(f\"πŸ“Š Processed {len(results)} articles with {len(models)} models\")" + ] + }, + { + "cell_type": "markdown", + "id": "evaluation-section", + "metadata": {}, + "source": [ + "## 5. Model Evaluation & Metrics\n", + "\n", + "Evaluating model performance using:\n", + "- **ROUGE Scores** (ROUGE-1, ROUGE-2, ROUGE-L)\n", + "- **Processing Time** analysis\n", + "- **Summary Quality** metrics\n", + "- **Compression Ratio** analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "rouge-evaluation", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:absl:Using default tokenizer.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "πŸ“Š Calculating ROUGE Scores...\n", + "\n", + "🎯 ROUGE Score Results:\n", + "================================================================================\n", + " rouge1_avg rouge2_avg rougeL_avg samples\n", + "textrank 0.2727 0.0670 0.1843 4.0\n", + "bart 0.3706 0.1793 0.2901 4.0\n", + "pegasus 0.3735 0.2050 0.3062 4.0\n", + "\n", + "⚑ Processing Time Summary:\n", + "==================================================\n", + " avg_time std_time min_time max_time\n", + "textrank 0.010 0.010 0.003 0.028\n", + "bart 5.340 1.277 3.838 7.271\n", + "pegasus 5.275 0.782 4.336 6.451\n" + ] + } + ], + "source": [ + "# ROUGE Score Evaluation\n", + "print(\"πŸ“Š Calculating ROUGE Scores...\")\n", + "\n", + "# Initialize ROUGE scorer\n", + "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)\n", + "\n", + "# Calculate ROUGE scores for each model\n", + "rouge_results = {}\n", + "\n", + "for model_name in models.keys():\n", + " rouge_scores = {'rouge1': [], 'rouge2': [], 'rougeL': []}\n", + " \n", + " for result in results:\n", + " if f'{model_name}_summary' in result and result[f'{model_name}_summary'] != \"Error: Failed to generate summary\":\n", + " reference = result['reference_summary']\n", + " generated = result[f'{model_name}_summary']\n", + " \n", + " # Calculate ROUGE scores\n", + " scores = scorer.score(reference, generated)\n", + " \n", + " rouge_scores['rouge1'].append(scores['rouge1'].fmeasure)\n", + " rouge_scores['rouge2'].append(scores['rouge2'].fmeasure)\n", + " rouge_scores['rougeL'].append(scores['rougeL'].fmeasure)\n", + " \n", + " # Calculate average scores\n", + " rouge_results[model_name] = {\n", + " 'rouge1_avg': np.mean(rouge_scores['rouge1']) if rouge_scores['rouge1'] else 0,\n", + " 'rouge2_avg': np.mean(rouge_scores['rouge2']) if rouge_scores['rouge2'] else 0,\n", + " 'rougeL_avg': np.mean(rouge_scores['rougeL']) if rouge_scores['rougeL'] else 0,\n", + " 'rouge1_std': np.std(rouge_scores['rouge1']) if rouge_scores['rouge1'] else 0,\n", + " 'rouge2_std': np.std(rouge_scores['rouge2']) if rouge_scores['rouge2'] else 0,\n", + " 'rougeL_std': np.std(rouge_scores['rougeL']) if rouge_scores['rougeL'] else 0,\n", + " 'samples': len(rouge_scores['rouge1'])\n", + " }\n", + "\n", + "# Display ROUGE results\n", + "print(\"\\n🎯 ROUGE Score Results:\")\n", + "print(\"=\" * 80)\n", + "\n", + "rouge_df = pd.DataFrame(rouge_results).T\n", + "rouge_df = rouge_df.round(4)\n", + "print(rouge_df[['rouge1_avg', 'rouge2_avg', 'rougeL_avg', 'samples']])\n", + "\n", + "# Performance summary\n", + "print(\"\\n⚑ Processing Time Summary:\")\n", + "print(\"=\" * 50)\n", + "\n", + "time_summary = {}\n", + "for model_name, times in processing_times.items():\n", + " if times:\n", + " time_summary[model_name] = {\n", + " 'avg_time': np.mean(times),\n", + " 'std_time': np.std(times),\n", + " 'min_time': np.min(times),\n", + " 'max_time': np.max(times)\n", + " }\n", + "\n", + "time_df = pd.DataFrame(time_summary).T\n", + "if not time_df.empty:\n", + " time_df = time_df.round(3)\n", + " print(time_df)" + ] + }, + { + "cell_type": "markdown", + "id": "comparison-section", + "metadata": {}, + "source": [ + "## 6. Comparative Analysis\n", + "\n", + "Comprehensive comparison of all three models across multiple dimensions:\n", + "- Performance metrics comparison\n", + "- Speed vs Quality trade-offs\n", + "- Model strengths and weaknesses" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "comparative-analysis", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "πŸ“Š Creating Comprehensive Model Comparison...\n", + "\n", + "πŸ† Model Comparison Results:\n", + "====================================================================================================\n", + " Model Type ROUGE-1 ROUGE-2 ROUGE-L ROUGE_Avg Avg Time (s) Overall_Score\n", + " PEGASUS Abstractive 0.3735 0.2050 0.3062 0.2949 5.2750 0.6942\n", + " BART Abstractive 0.3706 0.1793 0.2901 0.2800 5.3397 0.6081\n", + "TextRank Extractive 0.2727 0.0670 0.1843 0.1747 0.0103 0.3000\n", + "\n", + "πŸ₯‡ Model Rankings:\n", + "1. PEGASUS - Overall Score: 0.694\n", + "2. BART - Overall Score: 0.608\n", + "3. TextRank - Overall Score: 0.300\n" + ] + } + ], + "source": [ + "# Create comprehensive comparison\n", + "print(\"πŸ“Š Creating Comprehensive Model Comparison...\")\n", + "\n", + "# Combine all metrics\n", + "comparison_data = []\n", + "\n", + "for model_name in models.keys():\n", + " if model_name in rouge_results and model_name in time_summary:\n", + " comparison_data.append({\n", + " 'Model': model_info[model_name]['name'],\n", + " 'Type': model_info[model_name]['type'],\n", + " 'ROUGE-1': rouge_results[model_name]['rouge1_avg'],\n", + " 'ROUGE-2': rouge_results[model_name]['rouge2_avg'],\n", + " 'ROUGE-L': rouge_results[model_name]['rougeL_avg'],\n", + " 'Avg Time (s)': time_summary[model_name]['avg_time'],\n", + " 'Samples': rouge_results[model_name]['samples']\n", + " })\n", + "\n", + "comparison_df = pd.DataFrame(comparison_data)\n", + "\n", + "if not comparison_df.empty:\n", + " # Calculate composite scores\n", + " comparison_df['ROUGE_Avg'] = (comparison_df['ROUGE-1'] + comparison_df['ROUGE-2'] + comparison_df['ROUGE-L']) / 3\n", + " comparison_df['Speed_Score'] = 1 / (comparison_df['Avg Time (s)'] + 0.001) # Inverse of time\n", + " \n", + " # Normalize scores for fair comparison\n", + " comparison_df['ROUGE_Norm'] = (comparison_df['ROUGE_Avg'] - comparison_df['ROUGE_Avg'].min()) / (comparison_df['ROUGE_Avg'].max() - comparison_df['ROUGE_Avg'].min() + 0.001)\n", + " comparison_df['Speed_Norm'] = (comparison_df['Speed_Score'] - comparison_df['Speed_Score'].min()) / (comparison_df['Speed_Score'].max() - comparison_df['Speed_Score'].min() + 0.001)\n", + " \n", + " # Overall score (weighted: 70% quality, 30% speed)\n", + " comparison_df['Overall_Score'] = 0.7 * comparison_df['ROUGE_Norm'] + 0.3 * comparison_df['Speed_Norm']\n", + " \n", + " # Sort by overall score\n", + " comparison_df = comparison_df.sort_values('Overall_Score', ascending=False)\n", + " \n", + " print(\"\\nπŸ† Model Comparison Results:\")\n", + " print(\"=\" * 100)\n", + " display_cols = ['Model', 'Type', 'ROUGE-1', 'ROUGE-2', 'ROUGE-L', 'ROUGE_Avg', 'Avg Time (s)', 'Overall_Score']\n", + " print(comparison_df[display_cols].round(4).to_string(index=False))\n", + " \n", + " # Model rankings\n", + " print(\"\\nπŸ₯‡ Model Rankings:\")\n", + " for i, row in comparison_df.iterrows():\n", + " rank = comparison_df.index.get_loc(i) + 1\n", + " print(f\"{rank}. {row['Model']} - Overall Score: {row['Overall_Score']:.3f}\")\n", + "else:\n", + " print(\"❌ No comparison data available\")" + ] + }, + { + "cell_type": "markdown", + "id": "insights-section", + "metadata": {}, + "source": [ + "## 7. Insights & Visualizations\n", + "\n", + "Creating meaningful visualizations to understand:\n", + "- Model performance comparison\n", + "- Speed vs Quality trade-offs\n", + "- ROUGE score distributions\n", + "- Processing time analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "performance-visualizations", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "πŸ“Š Creating Performance Visualizations...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create comprehensive visualizations\n", + "print(\"πŸ“Š Creating Performance Visualizations...\")\n", + "\n", + "if not comparison_df.empty:\n", + " # Set up the plotting area\n", + " fig = plt.figure(figsize=(20, 15))\n", + " \n", + " # 1. ROUGE Scores Comparison (Bar Chart)\n", + " ax1 = plt.subplot(2, 3, 1)\n", + " rouge_cols = ['ROUGE-1', 'ROUGE-2', 'ROUGE-L']\n", + " x = np.arange(len(comparison_df))\n", + " width = 0.25\n", + " \n", + " for i, col in enumerate(rouge_cols):\n", + " plt.bar(x + i*width, comparison_df[col], width, label=col, alpha=0.8)\n", + " \n", + " plt.xlabel('Models')\n", + " plt.ylabel('ROUGE Score')\n", + " plt.title('🎯 ROUGE Scores Comparison')\n", + " plt.xticks(x + width, comparison_df['Model'], rotation=45)\n", + " plt.legend()\n", + " plt.grid(True, alpha=0.3)\n", + " \n", + " # 2. Processing Time Comparison\n", + " ax2 = plt.subplot(2, 3, 2)\n", + " colors = ['#FF6B6B', '#4ECDC4', '#45B7D1']\n", + " bars = plt.bar(comparison_df['Model'], comparison_df['Avg Time (s)'], color=colors, alpha=0.8)\n", + " plt.xlabel('Models')\n", + " plt.ylabel('Average Time (seconds)')\n", + " plt.title('⚑ Processing Time Comparison')\n", + " plt.xticks(rotation=45)\n", + " \n", + " # Add value labels on bars\n", + " for bar in bars:\n", + " height = bar.get_height()\n", + " plt.text(bar.get_x() + bar.get_width()/2., height + 0.01,\n", + " f'{height:.2f}s', ha='center', va='bottom')\n", + " \n", + " # 3. Speed vs Quality Scatter Plot\n", + " ax3 = plt.subplot(2, 3, 3)\n", + " scatter = plt.scatter(comparison_df['Avg Time (s)'], comparison_df['ROUGE_Avg'], \n", + " s=200, c=colors, alpha=0.7, edgecolors='black')\n", + " \n", + " for i, model in enumerate(comparison_df['Model']):\n", + " plt.annotate(model, \n", + " (comparison_df['Avg Time (s)'].iloc[i], comparison_df['ROUGE_Avg'].iloc[i]),\n", + " xytext=(5, 5), textcoords='offset points', fontsize=10)\n", + " \n", + " plt.xlabel('Average Processing Time (s)')\n", + " plt.ylabel('Average ROUGE Score')\n", + " plt.title('🎯 Speed vs Quality Trade-off')\n", + " plt.grid(True, alpha=0.3)\n", + " \n", + " # 4. Overall Performance Radar Chart (if we have 3 models)\n", + " if len(comparison_df) >= 2:\n", + " ax4 = plt.subplot(2, 3, 4, projection='polar')\n", + " \n", + " # Metrics for radar chart\n", + " metrics = ['ROUGE-1', 'ROUGE-2', 'ROUGE-L', 'Speed_Norm']\n", + " angles = np.linspace(0, 2*np.pi, len(metrics), endpoint=False).tolist()\n", + " angles += angles[:1] # Complete the circle\n", + " \n", + " for i, row in comparison_df.iterrows():\n", + " values = [row['ROUGE-1'], row['ROUGE-2'], row['ROUGE-L'], row['Speed_Norm']]\n", + " values += values[:1] # Complete the circle\n", + " \n", + " ax4.plot(angles, values, 'o-', linewidth=2, label=row['Model'])\n", + " ax4.fill(angles, values, alpha=0.25)\n", + " \n", + " ax4.set_xticks(angles[:-1])\n", + " ax4.set_xticklabels(metrics)\n", + " ax4.set_title('πŸ•ΈοΈ Multi-Metric Performance', pad=20)\n", + " ax4.legend(loc='upper right', bbox_to_anchor=(1.3, 1.0))\n", + " \n", + " # 5. Model Type Distribution\n", + " ax5 = plt.subplot(2, 3, 5)\n", + " type_counts = comparison_df['Type'].value_counts()\n", + " plt.pie(type_counts.values, labels=type_counts.index, autopct='%1.1f%%', \n", + " colors=['#FF9999', '#66B2FF'], startangle=90)\n", + " plt.title('πŸ“Š Model Type Distribution')\n", + " \n", + " # 6. Overall Score Ranking\n", + " ax6 = plt.subplot(2, 3, 6)\n", + " bars = plt.barh(comparison_df['Model'], comparison_df['Overall_Score'], \n", + " color=['gold', 'silver', '#CD7F32'][:len(comparison_df)])\n", + " plt.xlabel('Overall Score')\n", + " plt.title('πŸ† Overall Performance Ranking')\n", + " \n", + " # Add value labels\n", + " for i, bar in enumerate(bars):\n", + " width = bar.get_width()\n", + " plt.text(width + 0.01, bar.get_y() + bar.get_height()/2,\n", + " f'{width:.3f}', ha='left', va='center')\n", + " \n", + " plt.tight_layout()\n", + " plt.show()\n", + " \n", + "else:\n", + " print(\"❌ No data available for visualization\")" + ] + }, + { + "cell_type": "markdown", + "id": "benchmarking-section", + "metadata": {}, + "source": [ + "## 8. Performance Benchmarking\n", + "\n", + "Detailed performance analysis and benchmarking results." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "benchmarking", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🏁 Performance Benchmarking Summary\n", + "============================================================\n", + "πŸ₯‡ Best ROUGE-1 Score: PEGASUS (0.3735)\n", + "πŸ₯‡ Best ROUGE-2 Score: PEGASUS (0.2050)\n", + "πŸ₯‡ Best ROUGE-L Score: PEGASUS (0.3062)\n", + "⚑ Fastest Model: TextRank (0.010s)\n", + "πŸ† Best Overall: PEGASUS (Score: 0.694)\n", + "\n", + "πŸ’‘ Key Performance Insights:\n", + "----------------------------------------\n", + "πŸ“Š Speed Variation: 518.3x difference between fastest and slowest\n", + "πŸ“Š Quality Variation: 0.1202 ROUGE score difference\n", + "⚑ Most Efficient: TextRank (ROUGE/Time: 16.9562)\n", + "\n", + "πŸ“ Sample Summary Outputs:\n", + "============================================================\n", + "\n", + "πŸ“° Original Article (first 200 chars):\n", + "(CNN)The Palestinian Authority officially became the 123rd member of the International Criminal Court on Wednesday, a step that gives the court jurisdiction over alleged crimes in Palestinian territor...\n", + "\n", + "πŸ“š Reference Summary:\n", + "Membership gives the ICC jurisdiction over alleged crimes committed in Palestinian territories since last June .\n", + "Israel and the United States opposed the move, which could open the door to war crimes investigations against Israelis .\n", + "\n", + "πŸ€– TEXTRANK Summary:\n", + "(CNN)The Palestinian Authority officially became the 123rd member of the International Criminal Court on Wednesday, a step that gives the court jurisdiction over alleged crimes in Palestinian territories. The Palestinians signed the ICC's founding Rome Statute in January, when they also accepted its jurisdiction over alleged crimes committed \"in the occupied Palestinian territory, including East Jerusalem, since June 13, 2014.\" \"As Palestine formally becomes a State Party to the Rome Statute today, the world is also a step closer to ending a long era of impunity and injustice,\" he said, according to an ICC news release.\n", + " Words: 96, Time: 0.03s\n", + "\n", + "πŸ€– BART Summary:\n", + "The Palestinian Authority becomes the 123rd member of the International Criminal Court. The move gives the court jurisdiction over alleged crimes in Palestinian territories. Israel and the United States opposed the Palestinians' efforts to join the body.\n", + " Words: 37, Time: 7.27s\n", + "\n", + "πŸ€– PEGASUS Summary:\n", + "The Palestinian Authority officially becomes the 123rd member of the International Criminal Court.The move gives the court jurisdiction over alleged crimes in Palestinian territories.\n", + " Words: 24, Time: 4.34s\n" + ] + } + ], + "source": [ + "# Performance benchmarking summary\n", + "print(\"🏁 Performance Benchmarking Summary\")\n", + "print(\"=\" * 60)\n", + "\n", + "if not comparison_df.empty:\n", + " # Best performing model in each category\n", + " best_rouge1 = comparison_df.loc[comparison_df['ROUGE-1'].idxmax()]\n", + " best_rouge2 = comparison_df.loc[comparison_df['ROUGE-2'].idxmax()]\n", + " best_rougeL = comparison_df.loc[comparison_df['ROUGE-L'].idxmax()]\n", + " fastest_model = comparison_df.loc[comparison_df['Avg Time (s)'].idxmin()]\n", + " best_overall = comparison_df.iloc[0] # Already sorted by overall score\n", + " \n", + " print(f\"πŸ₯‡ Best ROUGE-1 Score: {best_rouge1['Model']} ({best_rouge1['ROUGE-1']:.4f})\")\n", + " print(f\"πŸ₯‡ Best ROUGE-2 Score: {best_rouge2['Model']} ({best_rouge2['ROUGE-2']:.4f})\")\n", + " print(f\"πŸ₯‡ Best ROUGE-L Score: {best_rougeL['Model']} ({best_rougeL['ROUGE-L']:.4f})\")\n", + " print(f\"⚑ Fastest Model: {fastest_model['Model']} ({fastest_model['Avg Time (s)']:.3f}s)\")\n", + " print(f\"πŸ† Best Overall: {best_overall['Model']} (Score: {best_overall['Overall_Score']:.3f})\")\n", + " \n", + " # Performance insights\n", + " print(\"\\nπŸ’‘ Key Performance Insights:\")\n", + " print(\"-\" * 40)\n", + " \n", + " # Speed analysis\n", + " speed_ratio = comparison_df['Avg Time (s)'].max() / comparison_df['Avg Time (s)'].min()\n", + " print(f\"πŸ“Š Speed Variation: {speed_ratio:.1f}x difference between fastest and slowest\")\n", + " \n", + " # Quality analysis\n", + " rouge_range = comparison_df['ROUGE_Avg'].max() - comparison_df['ROUGE_Avg'].min()\n", + " print(f\"πŸ“Š Quality Variation: {rouge_range:.4f} ROUGE score difference\")\n", + " \n", + " # Efficiency analysis\n", + " comparison_df['Efficiency'] = comparison_df['ROUGE_Avg'] / comparison_df['Avg Time (s)']\n", + " most_efficient = comparison_df.loc[comparison_df['Efficiency'].idxmax()]\n", + " print(f\"⚑ Most Efficient: {most_efficient['Model']} (ROUGE/Time: {most_efficient['Efficiency']:.4f})\")\n", + " \n", + "else:\n", + " print(\"❌ No benchmarking data available\")\n", + "\n", + "# Sample outputs display\n", + "print(\"\\nπŸ“ Sample Summary Outputs:\")\n", + "print(\"=\" * 60)\n", + "\n", + "if results:\n", + " sample_result = results[0] # Show first result\n", + " print(f\"\\nπŸ“° Original Article (first 200 chars):\")\n", + " print(f\"{sample_result['article'][:200]}...\")\n", + " \n", + " print(f\"\\nπŸ“š Reference Summary:\")\n", + " print(f\"{sample_result['reference_summary']}\")\n", + " \n", + " for model_name in models.keys():\n", + " if f'{model_name}_summary' in sample_result:\n", + " print(f\"\\nπŸ€– {model_name.upper()} Summary:\")\n", + " print(f\"{sample_result[f'{model_name}_summary']}\")\n", + " print(f\" Words: {sample_result[f'{model_name}_words']}, Time: {sample_result[f'{model_name}_time']:.2f}s\")" + ] + }, + { + "cell_type": "markdown", + "id": "conclusions-section", + "metadata": {}, + "source": [ + "## 9. Conclusions & Recommendations\n", + "\n", + "Summary of findings and recommendations for different use cases." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "conclusions", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🎯 Smart Summarizer: Final Conclusions & Recommendations\n", + "======================================================================\n", + "\n", + "πŸ“Š Model Analysis Summary:\n", + "------------------------------\n", + "\n", + "πŸ€– TextRank:\n", + " βœ… Strengths: Very fast processing, No GPU required, Extractive (preserves original text), Language agnostic\n", + " ⚠️ Weaknesses: Limited creativity, May miss context, Sentence-level only\n", + " 🎯 Best for: Real-time applications, Resource-constrained environments, Quick previews\n", + "\n", + "πŸ€– BART:\n", + " βœ… Strengths: High-quality abstracts, Good fluency, Flexible length control, Strong performance\n", + " ⚠️ Weaknesses: Slower processing, Requires more memory, May hallucinate facts\n", + " 🎯 Best for: High-quality summaries, Content creation, Editorial applications\n", + "\n", + "πŸ€– PEGASUS:\n", + " βœ… Strengths: Specialized for summarization, Excellent ROUGE scores, Good compression, Research-grade quality\n", + " ⚠️ Weaknesses: Large model size, Slower inference, High memory requirements\n", + " 🎯 Best for: Research applications, Batch processing, Maximum quality needs\n", + "\n", + "🎯 Use Case Recommendations:\n", + "-----------------------------------\n", + "⚑ Real-time Applications: TextRank - Fast processing with acceptable quality\n", + "πŸ“± Mobile/Edge Devices: TextRank - Low resource requirements\n", + "πŸ“° News Summarization: BART - Good balance of speed and quality\n", + "πŸ“š Research Papers: PEGASUS - Highest quality for academic content\n", + "πŸ”„ Batch Processing: PEGASUS - Maximum quality when time allows\n", + "πŸ’Ό Business Reports: BART - Professional quality with reasonable speed\n", + "🌐 Web Applications: Hybrid approach - TextRank for preview, BART for full summary\n", + "\n", + "πŸ”¬ Technical Insights:\n", + "-------------------------\n", + " πŸ“ˆ Abstractive models (BART, PEGASUS) generally produce higher ROUGE scores\n", + " ⚑ TextRank offers 10-100x faster processing than transformer models\n", + " 🎯 Model choice depends heavily on speed vs quality requirements\n", + " πŸ’Ύ Memory usage scales significantly with model complexity\n", + " πŸ”„ Hybrid approaches can optimize for both speed and quality\n", + " πŸ“Š ROUGE scores correlate well with human judgment for news summarization\n", + "\n", + "πŸš€ Future Improvements:\n", + "-------------------------\n", + " πŸ”§ Implement model ensembling for better quality\n", + " ⚑ Add GPU acceleration for transformer models\n", + " πŸ“Š Include more evaluation metrics (BERTScore, METEOR)\n", + " 🎯 Fine-tune models on domain-specific data\n", + " πŸ”„ Implement adaptive model selection based on input characteristics\n", + " πŸ“± Optimize models for mobile deployment\n", + "\n", + "======================================================================\n", + "βœ… Analysis Complete! Smart Summarizer provides a comprehensive\n", + " comparison of three state-of-the-art summarization approaches.\n", + "🎯 Choose the right model for your specific use case and requirements.\n", + "======================================================================\n" + ] + } + ], + "source": [ + "# Final conclusions and recommendations\n", + "print(\"🎯 Smart Summarizer: Final Conclusions & Recommendations\")\n", + "print(\"=\" * 70)\n", + "\n", + "print(\"\\nπŸ“Š Model Analysis Summary:\")\n", + "print(\"-\" * 30)\n", + "\n", + "model_analysis = {\n", + " 'TextRank': {\n", + " 'strengths': ['Very fast processing', 'No GPU required', 'Extractive (preserves original text)', 'Language agnostic'],\n", + " 'weaknesses': ['Limited creativity', 'May miss context', 'Sentence-level only'],\n", + " 'best_for': ['Real-time applications', 'Resource-constrained environments', 'Quick previews']\n", + " },\n", + " 'BART': {\n", + " 'strengths': ['High-quality abstracts', 'Good fluency', 'Flexible length control', 'Strong performance'],\n", + " 'weaknesses': ['Slower processing', 'Requires more memory', 'May hallucinate facts'],\n", + " 'best_for': ['High-quality summaries', 'Content creation', 'Editorial applications']\n", + " },\n", + " 'PEGASUS': {\n", + " 'strengths': ['Specialized for summarization', 'Excellent ROUGE scores', 'Good compression', 'Research-grade quality'],\n", + " 'weaknesses': ['Large model size', 'Slower inference', 'High memory requirements'],\n", + " 'best_for': ['Research applications', 'Batch processing', 'Maximum quality needs']\n", + " }\n", + "}\n", + "\n", + "for model, analysis in model_analysis.items():\n", + " print(f\"\\nπŸ€– {model}:\")\n", + " print(f\" βœ… Strengths: {', '.join(analysis['strengths'])}\")\n", + " print(f\" ⚠️ Weaknesses: {', '.join(analysis['weaknesses'])}\")\n", + " print(f\" 🎯 Best for: {', '.join(analysis['best_for'])}\")\n", + "\n", + "print(\"\\n🎯 Use Case Recommendations:\")\n", + "print(\"-\" * 35)\n", + "\n", + "recommendations = {\n", + " '⚑ Real-time Applications': 'TextRank - Fast processing with acceptable quality',\n", + " 'πŸ“± Mobile/Edge Devices': 'TextRank - Low resource requirements',\n", + " 'πŸ“° News Summarization': 'BART - Good balance of speed and quality',\n", + " 'πŸ“š Research Papers': 'PEGASUS - Highest quality for academic content',\n", + " 'πŸ”„ Batch Processing': 'PEGASUS - Maximum quality when time allows',\n", + " 'πŸ’Ό Business Reports': 'BART - Professional quality with reasonable speed',\n", + " '🌐 Web Applications': 'Hybrid approach - TextRank for preview, BART for full summary'\n", + "}\n", + "\n", + "for use_case, recommendation in recommendations.items():\n", + " print(f\"{use_case}: {recommendation}\")\n", + "\n", + "print(\"\\nπŸ”¬ Technical Insights:\")\n", + "print(\"-\" * 25)\n", + "\n", + "insights = [\n", + " \"πŸ“ˆ Abstractive models (BART, PEGASUS) generally produce higher ROUGE scores\",\n", + " \"⚑ TextRank offers 10-100x faster processing than transformer models\",\n", + " \"🎯 Model choice depends heavily on speed vs quality requirements\",\n", + " \"πŸ’Ύ Memory usage scales significantly with model complexity\",\n", + " \"πŸ”„ Hybrid approaches can optimize for both speed and quality\",\n", + " \"πŸ“Š ROUGE scores correlate well with human judgment for news summarization\"\n", + "]\n", + "\n", + "for insight in insights:\n", + " print(f\" {insight}\")\n", + "\n", + "print(\"\\nπŸš€ Future Improvements:\")\n", + "print(\"-\" * 25)\n", + "\n", + "improvements = [\n", + " \"πŸ”§ Implement model ensembling for better quality\",\n", + " \"⚑ Add GPU acceleration for transformer models\",\n", + " \"πŸ“Š Include more evaluation metrics (BERTScore, METEOR)\",\n", + " \"🎯 Fine-tune models on domain-specific data\",\n", + " \"πŸ”„ Implement adaptive model selection based on input characteristics\",\n", + " \"πŸ“± Optimize models for mobile deployment\"\n", + "]\n", + "\n", + "for improvement in improvements:\n", + " print(f\" {improvement}\")\n", + "\n", + "print(\"\\n\" + \"=\" * 70)\n", + "print(\"βœ… Analysis Complete! Smart Summarizer provides a comprehensive\")\n", + "print(\" comparison of three state-of-the-art summarization approaches.\")\n", + "print(\"🎯 Choose the right model for your specific use case and requirements.\")\n", + "print(\"=\" * 70)" + ] + }, + { + "cell_type": "markdown", + "id": "metadata", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## πŸ“‹ Notebook Metadata\n", + "\n", + "**Project:** Smart Summarizer - Comprehensive Model Analysis \n", + "**Author:** Abdul Razzaq Ansari \n", + "**Date:** January 2025 \n", + "**Version:** 1.0 \n", + "\n", + "**Models Analyzed:**\n", + "- TextRank (Extractive)\n", + "- BART (Abstractive)\n", + "- PEGASUS (Abstractive)\n", + "\n", + "**Evaluation Metrics:**\n", + "- ROUGE-1, ROUGE-2, ROUGE-L\n", + "- Processing Time\n", + "- Compression Ratio\n", + "- Overall Performance Score\n", + "\n", + "**Dataset:** CNN/DailyMail Test Set \n", + "**Repository:** [Smart-Summarizer](https://github.com/Rajak13/Smart-Summarizer) \n", + "**Live Demo:** [Hugging Face Spaces](https://huggingface.co/spaces/Rajak13/smart-summarizer)\n", + "\n", + "---" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}