summarizer.py

"""
Advanced Text Summarizer using Sentence-BERT
Fast, lightweight, with modern semantic understanding
Perfect for free-tier hosting with ~100MB RAM footprint
"""

from sentence_transformers import SentenceTransformer
import numpy as np
import nltk
from sklearn.metrics.pairwise import cosine_similarity
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


class ProductionSummarizer:
    """
    Fast, lightweight summarizer using contextual embeddings

    Uses Sentence-BERT (all-MiniLM-L6-v2) for modern semantic understanding:
    - Contextual embeddings (understands "bank" differently based on context)
    - 10x better than Word2Vec/TF-IDF approaches
    - Fast inference (~500ms per request on CPU)
    - Small memory footprint (~100MB)
    """

    def __init__(self):
        """Initialize the summarizer with Sentence-BERT model"""
        logger.info("Loading Sentence-BERT model (all-MiniLM-L6-v2)...")

        # Load lightweight but powerful model
        # Model: 384-dimensional embeddings, 22M parameters
        self.model = SentenceTransformer('all-MiniLM-L6-v2')

        # Download NLTK data for sentence tokenization
        try:
            nltk.download('punkt', quiet=True)
            nltk.download('punkt_tab', quiet=True)
        except Exception as e:
            logger.warning(f"NLTK download warning: {e}")

        logger.info("Model loaded successfully!")

    def generate_summary(self, text, summary_length=3):
        """
        Generate extractive summary using contextual embeddings

        Process:
        1. Tokenize text into sentences
        2. Generate contextual embeddings for each sentence
        3. Calculate document-level embedding (centroid)
        4. Find sentences most similar to overall document
        5. Return top N sentences in original order

        Args:
            text (str): Input text to summarize
            summary_length (int): Number of sentences in summary (default: 3)

        Returns:
            str: Summary text with selected sentences
        """
        try:
            # Sentence segmentation
            sentences = nltk.sent_tokenize(text)

            # If text is already short, return as-is
            if len(sentences) <= summary_length:
                logger.info(f"Text has {len(sentences)} sentences, returning full text")
                return ' '.join(sentences)

            logger.info(f"Processing {len(sentences)} sentences...")

            # Get contextual embeddings
            # Each sentence gets a 384-dimensional vector
            # Context matters: "bank" in "river bank" vs "financial bank" gets different embeddings
            embeddings = self.model.encode(
                sentences,
                show_progress_bar=False,
                convert_to_numpy=True
            )

            # Calculate document centroid (average of all sentence embeddings)
            # Represents the "core meaning" of the entire document
            doc_embedding = np.mean(embeddings, axis=0, keepdims=True)

            # Calculate similarity between each sentence and the document
            # Higher similarity = more representative of overall content
            similarities = cosine_similarity(doc_embedding, embeddings)[0]

            # Get indices of top N most representative sentences
            top_indices = np.argsort(similarities)[-summary_length:]

            # Sort indices to maintain original text order
            top_indices_sorted = sorted(top_indices)

            # Build summary from selected sentences
            summary_sentences = [sentences[i] for i in top_indices_sorted]
            summary_text = ' '.join(summary_sentences)

            logger.info(f"Generated summary with {len(summary_sentences)} sentences")

            return summary_text

        except Exception as e:
            logger.error(f"Error generating summary: {str(e)}")
            raise

    def get_model_info(self):
        """Return information about the loaded model"""
        return {
            'model_name': 'sentence-transformers/all-MiniLM-L6-v2',
            'embedding_dimension': 384,
            'max_sequence_length': 256,
            'parameters': '22M',
            'license': 'Apache-2.0',
            'type': 'extractive_with_contextual_embeddings'
        }


# Example usage and testing
if __name__ == "__main__":
    # Test the summarizer
    sample_text = """
    Artificial Intelligence (AI) has rapidly evolved over the past decade, transforming
    multiple sectors of human activity. From healthcare to finance, AI technologies are
    reshaping how we approach complex problems. Machine learning algorithms can now
    detect diseases with unprecedented accuracy, predict financial market trends, and
    even assist in scientific research by processing vast amounts of data far beyond
    human capabilities. However, this technological revolution also brings significant
    ethical challenges. Questions about data privacy, algorithmic bias, and the potential
    displacement of human workers are at the forefront of ongoing debates. Despite these
    concerns, the potential of AI to solve global challenges like climate change,
    medical research, and resource optimization remains immense. Researchers are
    continuously developing more sophisticated neural networks and exploring concepts
    like explainable AI to make these systems more transparent and trustworthy.
    """

    print("Initializing summarizer...")
    summarizer = ProductionSummarizer()

    print("\nModel Info:")
    print(summarizer.get_model_info())

    print("\nOriginal Text:")
    print(sample_text.strip())
    print(f"\nCharacter count: {len(sample_text)}")

    print("\nGenerating summary...")
    summary = summarizer.generate_summary(sample_text, summary_length=3)

    print("\nSummary:")
    print(summary)
    print(f"\nCharacter count: {len(summary)}")
    print(f"Compression ratio: {len(summary)/len(sample_text):.1%}")