Deploy conversation summarizer space

.gitignore

@@ -0,0 +1,17 @@
+env/
+**/env/
+__pycache__/
+**/__pycache__/
+*.pyc
+.ipynb_checkpoints/
+results/
+logs/
+.gradio/
+
+# model weights / saved local model folders
+*.safetensors
+*.bin
+*.pt
+*.pth
+conversation_summarizer/conversation_summarizer/
+conversation_summarizer/

README.md

@@ -0,0 +1,223 @@
+# Dialogue Summarizer
+
+An interactive Gradio app that summarizes chat-style conversations using a fine-tuned `google/flan-t5-small` model from Hugging Face.
+
+The model was fine-tuned on the [SAMSum](https://huggingface.co/datasets/knkarthick/samsum) dialogue summarization dataset. Users can paste a conversation, click submit, and receive a short generated summary.
+
+## Demo
+
+```text
+Tom: Did you submit the report?
+Anika: Not yet, I'm fixing the charts.
+Tom: The deadline is 5 pm.
+Anika: I know. I'll send it by 4:30.
+Tom: Great, please copy me on the email.
+```
+
+Expected output:
+
+```text
+Anika is fixing the report charts and will send the report by 4:30, copying Tom.
+```
+
+## Features
+
+- Fine-tuned T5/FLAN-T5 sequence-to-sequence summarization model
+- Simple Gradio web interface
+- Built-in example conversations
+- Beam search generation for better summaries
+- Local model loading from the `conversation_summarizer/` folder
+
+## Project Structure
+
+```text
+conversation_summarizer/
++-- app.py
++-- model.py
++-- requirements.txt
++-- README.md
++-- conversation_summarizer/
+    +-- config.json
+    +-- generation_config.json
+    +-- model.safetensors
+    +-- spiece.model
+    +-- tokenizer_config.json
+    +-- special_tokens_map.json
+```
+
+## Setup
+
+Create and activate a virtual environment:
+
+```bash
+python -m venv env
+```
+
+Windows:
+
+```bash
+env\Scripts\activate
+```
+
+macOS/Linux:
+
+```bash
+source env/bin/activate
+```
+
+Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Run The App
+
+```bash
+python app.py
+```
+
+Gradio will start a local app and print a URL like:
+
+```text
+http://127.0.0.1:7860
+```
+
+Open the URL in your browser and try one of the example conversations.
+
+## Example Inputs
+
+```text
+Nora: Are you picking up the groceries today?
+Eli: Yes, after work.
+Nora: Please get milk, eggs, and bread.
+Eli: Got it. Anything else?
+Nora: Bananas if they look fresh.
+Eli: Okay, I'll be home around 6:30.
+```
+
+```text
+Priya: Did you call the dentist?
+Karan: Yes, they had an opening tomorrow at 11.
+Priya: Great. Did you book it?
+Karan: Yes, I confirmed it.
+Priya: Thanks. I'll leave work early to go.
+```
+
+```text
+Sam: The Wi-Fi is down again.
+Lina: I restarted the router, but it didn't help.
+Sam: Should I call the provider?
+Lina: Yes, please. Tell them it stopped working an hour ago.
+Sam: Okay, I'll call them now.
+```
+
+## Training
+
+The training script is in `model.py`.
+
+It:
+
+1. Loads the SAMSum dataset.
+2. Loads `google/flan-t5-small`.
+3. Tokenizes dialogues as inputs and summaries as labels.
+4. Fine-tunes the model with `Seq2SeqTrainer`.
+5. Evaluates with ROUGE.
+6. Saves the trained model and tokenizer.
+
+Run training with:
+
+```bash
+python model.py
+```
+
+Note: training is much faster with a CUDA-enabled GPU.
+
+## Model Notes
+
+The app expects a saved Hugging Face model folder at:
+
+```text
+./conversation_summarizer
+```
+
+This folder should contain files like:
+
+```text
+model.safetensors
+config.json
+spiece.model
+tokenizer_config.json
+generation_config.json
+```
+
+If you retrain the model and save it to another folder, update this line in `app.py`:
+
+```python
+model = T5ForConditionalGeneration.from_pretrained("./conversation_summarizer")
+tokenizer = T5Tokenizer.from_pretrained("./conversation_summarizer")
+```
+
+## Evaluation
+
+The model is evaluated using ROUGE:
+
+- `rouge1`: unigram overlap
+- `rouge2`: bigram overlap
+- `rougeL`: longest common subsequence overlap
+- `rougeLsum`: summarization-oriented ROUGE-L
+
+ROUGE scores usually range from `0` to `1`, where higher is better.
+
+## Before Pushing To GitHub
+
+Do not commit the local virtual environment:
+
+```text
+env/
+```
+
+If the model file is large, consider using Git LFS or uploading the model to the Hugging Face Hub instead of committing `model.safetensors` directly.
+
+Recommended `.gitignore`:
+
+```gitignore
+env/
+__pycache__/
+*.pyc
+.ipynb_checkpoints/
+results/
+logs/
+```
+
+## Git Commands
+
+Initialize the repo:
+
+```bash
+git init
+git add app.py model.py requirements.txt README.md conversation_summarizer/
+git commit -m "Add dialogue summarizer app"
+```
+
+Connect to GitHub:
+
+```bash
+git branch -M main
+git remote add origin https://github.com/YOUR_USERNAME/YOUR_REPO_NAME.git
+git push -u origin main
+```
+
+## Tech Stack
+
+- Python
+- Hugging Face Transformers
+- Hugging Face Datasets
+- Evaluate
+- ROUGE
+- Gradio
+- FLAN-T5
+
+## Limitations
+
+This is a small fine-tuned model, so it may occasionally miss details or infer something incorrectly. It works best when the dialogue clearly identifies speakers, actions, and decisions.

app.py

@@ -0,0 +1,62 @@
+from transformers import T5ForConditionalGeneration, T5Tokenizer
+import gradio as gr
+
+model = T5ForConditionalGeneration.from_pretrained("abhi-codes/finetuned_flank_t5_for_summarization")
+tokenizer = T5Tokenizer.from_pretrained("abhi-codes/finetuned_flank_t5_for_summarization")
+
+examples = [
+    ["""Tom: Did you submit the report?
+Anika: Not yet, I'm fixing the charts.
+Tom: The deadline is 5 pm.
+Anika: I know. I'll send it by 4:30.
+Tom: Great, please copy me on the email."""],
+    ["""Nora: Are you picking up the groceries today?
+Eli: Yes, after work.
+Nora: Please get milk, eggs, and bread.
+Eli: Got it. Anything else?
+Nora: Bananas if they look fresh.
+Eli: Okay, I'll be home around 6:30"""],
+    ["""Priya: Did you call the dentist?
+Karan: Yes, they had an opening tomorrow at 11.
+Priya: Great. Did you book it?
+Karan: Yes, I confirmed it.
+Priya: Thanks. I'll leave work early to go."""]
+]
+
+
+def summarize(input):
+    input = "summarize: "+ input
+    model_inputs = tokenizer(input, return_tensors="pt", max_length=512, truncation=True,padding = 'max_length')
+    summary_ids = model.generate(
+        input_ids=model_inputs["input_ids"],
+        attention_mask=model_inputs["attention_mask"],
+        max_new_tokens=128,
+        num_beams=4,
+        no_repeat_ngram_size=3
+    )
+    return tokenizer.decode(summary_ids[0], skip_special_tokens=True)
+  
+demo = gr.Interface(
+    fn=summarize,
+    inputs=[
+        gr.Textbox(
+            lines=8,
+            label="Dialogue",
+            placeholder="Paste a conversation here"
+        )],
+        outputs=[
+        gr.Textbox(
+            lines=2,
+            label="Summary"
+        ),
+    ],
+    title="Dialogue Summarizer",
+    description=(
+        "Enter a chat-style conversation and the model will generate a short summary. "
+        "For best results, write each message on a new line with the speaker name."
+    ),
+    examples=examples,
+    flagging_mode="never"
+    
+)
+demo.launch()

model.py

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+"""hf_workshop_project.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/16rr3KcHT3lyfI2QjUDm720EZjpP8Jw28
+"""
+
+from datasets import load_dataset
+from transformers import T5Tokenizer,T5ForConditionalGeneration
+from transformers import Seq2SeqTrainingArguments,Seq2SeqTrainer
+import evaluate
+import numpy as np
+
+df = load_dataset("knkarthick/samsum")
+
+tokenizer = T5Tokenizer.from_pretrained("google/flan-t5-small")
+model = T5ForConditionalGeneration.from_pretrained("google/flan-t5-small",device_map = "auto")
+
+def tokenize(data):
+  input = ["summarize: "+ text for text in data['dialogue']]
+  model_inputs =  tokenizer(input,max_length=128,padding='max_length',truncation=True)
+  label = tokenizer(data['summary'],max_length=128,padding='max_length',truncation=True)
+  model_inputs['labels'] = label['input_ids']
+  return model_inputs
+
+tokenized_train_data = df['train'].map(tokenize,batched= True)
+tokenized_validation_data = df['validation'].map(tokenize,batched= True)
+
+# tokenized_train_data = df['train'].select(range(2000)).map(tokenize,batched= True)
+# tokenized_validation_data = df['validation'].select(range(600)).map(tokenize,batched= True)
+
+
+training_args = Seq2SeqTrainingArguments(
+    output_dir = './results',
+    eval_strategy = 'epoch',
+    learning_rate = 3e-5,
+    per_device_train_batch_size = 8,
+    per_device_eval_batch_size = 8,
+    num_train_epochs = 10,
+    weight_decay = 0.01,
+    report_to = "none",
+    logging_dir = './logs',
+    fp16 = False,
+    predict_with_generate= True,
+    generation_max_length= 128,
+
+)
+
+# !pip install evaluate
+# !pip install rouge_score
+
+
+metric = evaluate.load('rouge')
+
+def compute_metrics(eval_pred) :
+  preds,labels = eval_pred
+
+  if isinstance(preds,tuple):
+    preds = preds[0]
+
+  if preds.ndim == 3:
+        preds = np.argmax(preds, axis=-1)
+
+  preds = np.where(preds < 0, tokenizer.pad_token_id, preds)
+  decoded_preds = tokenizer.batch_decode(preds,skip_special_tokens= True)
+
+  labels = np.where(labels !=-100,labels,tokenizer.pad_token_id)
+  decoded_labels = tokenizer.batch_decode(labels,skip_special_tokens= True)
+
+  return metric.compute(predictions=decoded_preds,
+                 references = decoded_labels,
+                 use_stemmer = True)
+
+trainer = Seq2SeqTrainer(
+    model = model,
+    train_dataset= tokenized_train_data,
+    eval_dataset= tokenized_validation_data,
+    args = training_args,
+    compute_metrics= compute_metrics
+)
+
+trainer.train()
+
+save_dir = './summary_model'
+trainer.save_model(save_dir)
+tokenizer.save_pretrained(save_dir)

requirements.txt

@@ -0,0 +1,8 @@
+transformers==4.43.0
+accelerate==0.33.0
+datasets==2.20.0
+evaluate==0.4.2
+rouge_score
+sentencepiece
+numpy
+gradio