Upload 4 files

README.md

@@ -0,0 +1,60 @@
+---
+title: AI Text Summarizer
+emoji: 📝
+colorFrom: blue
+colorTo: indigo
+sdk: gradio
+sdk_version: 6.0.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# AI Text Summarizer
+
+This project implements an AI-powered text summarizer using a local **Mistral-7B** LLM (via `ctransformers`) and provides a web interface using `gradio`.
+
+## Features
+- **100% Local**: Runs entirely on your machine without internet (after model download).
+- **High Accuracy**: Uses **Mistral-7B-Instruct**, a state-of-the-art open-source model.
+- **Abstractive Summarization**: Generates new text rather than just selecting sentences.
+- **No API Token Required**: Free and private.
+- Simple and intuitive web interface.
+
+## Installation
+
+1.  **Clone the repository** (if applicable) or navigate to the project directory.
+
+2.  **Create a virtual environment** (recommended):
+    ```bash
+    python -m venv venv
+    source venv/bin/activate  # On Windows use `venv\Scripts\activate`
+    ```
+
+3.  **Install dependencies**:
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+## Usage
+
+### Running the Web Interface
+To start the Gradio web interface, run:
+```bash
+python app.py
+```
+This will launch a local server (usually at `http://127.0.0.1:7860`). Open this URL in your browser to use the summarizer.
+
+### Using the Script Directly
+You can also use the `summarizer.py` script directly in your own code:
+```python
+from summarizer import TextSummarizer
+
+summarizer = TextSummarizer()
+text = "Your long text here..."
+summary = summarizer.summarize(text, sentences_count=3)
+print(summary)
+```
+
+## Requirements
+- Python 3.7+

app.py

@@ -0,0 +1,39 @@
+import gradio as gr
+from summarizer import TextSummarizer
+
+# Initialize the summarizer globally to load the model once
+print("Initializing Summarizer...")
+global_summarizer = TextSummarizer()
+
+def summarize_text(text, max_tokens):
+    try:
+        # Use the global instance
+        summary, stats = global_summarizer.summarize(text, int(max_tokens))
+        return summary, stats
+    except Exception as e:
+        return f"An error occurred: {str(e)}", ""
+
+# Create the Gradio interface
+with gr.Blocks() as iface:
+    gr.Markdown("# AI Text Summarizer (Local Mistral-7B)")
+    gr.Markdown("Enter a long text to get a concise summary using the **Mistral-7B** model (running locally).")
+    gr.Markdown("> **Note:** The first run might take a moment to load the model. Subsequent runs will be faster.")
+    
+    with gr.Row():
+        with gr.Column():
+            text_input = gr.Textbox(lines=10, label="Input Text", placeholder="Enter text to summarize here...")
+            max_tokens_slider = gr.Slider(minimum=50, maximum=500, value=100, step=10, label="Max Summary Length (Tokens)")
+            submit_btn = gr.Button("Summarize", variant="primary")
+        
+        with gr.Column():
+            output_text = gr.Textbox(label="Summary", lines=8)
+            stats_output = gr.Label(label="Statistics")
+
+    submit_btn.click(
+        fn=summarize_text,
+        inputs=[text_input, max_tokens_slider],
+        outputs=[output_text, stats_output]
+    )
+
+if __name__ == "__main__":
+    iface.launch()

requirements.txt

@@ -0,0 +1,3 @@
+ctransformers
+huggingface_hub
+gradio

summarizer.py

@@ -0,0 +1,87 @@
+from ctransformers import AutoModelForCausalLM
+import os
+from huggingface_hub import hf_hub_download
+
+class TextSummarizer:
+    _model_instance = None
+
+    def __init__(self, model_path="mistral-7b-instruct-v0.1.Q4_K_M.gguf"):
+        """
+        Initialize the local LLM summarizer.
+        Loads the model only once (Singleton pattern).
+        """
+        if TextSummarizer._model_instance is None:
+            print("Loading model...")
+            if not os.path.exists(model_path):
+                print(f"Model file {model_path} not found. Downloading...")
+                try:
+                    # Download specific file from the repo
+                    model_path = hf_hub_download(
+                        repo_id="TheBloke/Mistral-7B-Instruct-v0.1-GGUF",
+                        filename="mistral-7b-instruct-v0.1.Q4_K_M.gguf",
+                        local_dir=".",
+                        local_dir_use_symlinks=False
+                    )
+                    print("Download complete.")
+                except Exception as e:
+                    raise RuntimeError(f"Failed to download model: {e}")
+            
+            # Load the model
+            # threads=2 is safer for free HF Spaces (usually 2 vCPU)
+            TextSummarizer._model_instance = AutoModelForCausalLM.from_pretrained(
+                model_path, 
+                model_type="mistral", 
+                context_length=4096,
+                threads=2
+            )
+            print("Model loaded successfully.")
+        
+        self.llm = TextSummarizer._model_instance
+
+    def summarize(self, text, max_new_tokens=250):
+        """
+        Summarize the given text using Mistral-7B.
+        """
+        if not text or not text.strip():
+            return "Error: Input text cannot be empty.", ""
+            
+        # Construct prompt for Mistral Instruct
+        # Format: <s>[INST] {prompt} [/INST]
+        prompt = f"<s>[INST] Please summarize the following text concisely in 2-3 sentences:\n\n{text} [/INST]"
+        
+        try:
+            # Generate summary
+            # Mistral is smarter, so we can use standard sampling
+            response = self.llm(prompt, max_new_tokens=max_new_tokens, temperature=0.2, repetition_penalty=1.1)
+            
+            summary_text = response.strip()
+            
+            # Stats
+            input_len = len(text.split())
+            summary_len = len(summary_text.split())
+            stats = f"Input Words: {input_len}. Summary Words: {summary_len}."
+            
+            return summary_text, stats
+        except Exception as e:
+            return f"Error during summarization: {e}", ""
+
+if __name__ == "__main__":
+    # Simple test
+    try:
+        summarizer = TextSummarizer()
+        text = """
+        The Transformer is a deep learning model introduced in 2017 by Google researchers. 
+        It is primarily used in the field of natural language processing (NLP). 
+        Like recurrent neural networks (RNNs), Transformers are designed to handle sequential data, 
+        such as natural language, for tasks such as translation and text summarization. 
+        However, unlike RNNs, Transformers do not require that the sequential data be processed in order. 
+        For example, if the input data is a natural language sentence, the Transformer does not need to 
+        process the beginning of it before the end. Due to this feature, the Transformer allows for 
+        much more parallelization than RNNs and therefore reduced training times.
+        """
+        print("Original Text:\n", text)
+        summary, stats = summarizer.summarize(text)
+        print("\nSummary:\n", summary)
+        print("\nStats:", stats)
+    except Exception as e:
+        print(e)