Update app.py

app.py

@@ -1,196 +1,29 @@
-import torch
-import torch.nn as nn
-import torch.optim as optim
-from torchtext.data.utils import get_tokenizer
-from torchtext.vocab import build_vocab_from_iterator
-from torchtext.datasets import Multi30k
-from torch.utils.data import DataLoader, Dataset
-from collections import Counter
-import spacy
 import streamlit as st
+from transformers import pipeline
+import nltk
+from nltk.tokenize import word_tokenize
 
-# Load English tokenizer
-spacy_en = spacy.load('en_core_web_sm')
-tokenizer = get_tokenizer("spacy", language="en_core_web_sm")
+# Download NLTK data
+nltk.download('punkt')
 
-# Define a simple dataset class
-class SimpleDataset(Dataset):
-    def __init__(self, texts, summaries, tokenizer, vocab):
-        self.texts = texts
-        self.summaries = summaries
-        self.tokenizer = tokenizer
-        self.vocab = vocab
+# Load summarization pipeline
+summarizer = pipeline("summarization")
 
-    def __len__(self):
-        return len(self.texts)
+# Function to tokenize text
+def tokenize(text):
+    return word_tokenize(text)
 
-    def __getitem__(self, idx):
-        text = self.texts[idx]
-        summary = self.summaries[idx]
-        text_tokens = [self.vocab[token] for token in self.tokenizer(text)]
-        summary_tokens = [self.vocab[token] for token in self.tokenizer(summary)]
-        return torch.tensor(text_tokens), torch.tensor(summary_tokens)
+# Function to summarize text
+def summarize(text):
+    summary = summarizer(text, max_length=130, min_length=30, do_sample=False)
+    return summary[0]['summary_text']
 
-# Example dataset
-data = {
-    "text": ["The cat sat on the mat.", "The dog barked at the mailman.", "She sells seashells by the seashore."],
-    "summary": ["Cat on mat.", "Dog barked.", "Seashells by seashore."]
-}
-
-texts = data["text"]
-summaries = data["summary"]
-
-# Build the vocabulary
-counter = Counter()
-for text in texts:
-    counter.update(tokenizer(text))
-
-vocab = build_vocab_from_iterator([counter.keys()], specials=["<unk>", "<pad>", "<sos>", "<eos>"])
-vocab.set_default_index(vocab["<unk>"])
-
-# Create dataset and dataloader
-dataset = SimpleDataset(texts, summaries, tokenizer, vocab)
-dataloader = DataLoader(dataset, batch_size=2, shuffle=True)
-
-# Define the model
-class Encoder(nn.Module):
-    def __init__(self, input_dim, emb_dim, hid_dim, n_layers, dropout):
-        super().__init__()
-
-        self.embedding = nn.Embedding(input_dim, emb_dim)
-        self.rnn = nn.LSTM(emb_dim, hid_dim, n_layers, dropout=dropout)
-        self.dropout = nn.Dropout(dropout)
-
-    def forward(self, src):
-        embedded = self.dropout(self.embedding(src))
-        outputs, (hidden, cell) = self.rnn(embedded)
-        return hidden, cell
-
-class Decoder(nn.Module):
-    def __init__(self, output_dim, emb_dim, hid_dim, n_layers, dropout):
-        super().__init__()
-
-        self.output_dim = output_dim
-        self.embedding = nn.Embedding(output_dim, emb_dim)
-        self.rnn = nn.LSTM(emb_dim, hid_dim, n_layers, dropout=dropout)
-        self.fc_out = nn.Linear(hid_dim, output_dim)
-        self.dropout = nn.Dropout(dropout)
-
-    def forward(self, input, hidden, cell):
-        input = input.unsqueeze(0)
-        embedded = self.dropout(self.embedding(input))
-        output, (hidden, cell) = self.rnn(embedded, (hidden, cell))
-        prediction = self.fc_out(output.squeeze(0))
-        return prediction, hidden, cell
-
-class Seq2Seq(nn.Module):
-    def __init__(self, encoder, decoder, device):
-        super().__init__()
-
-        self.encoder = encoder
-        self.decoder = decoder
-        self.device = device
-
-    def forward(self, src, trg, teacher_forcing_ratio=0.5):
-        trg_len = trg.shape[0]
-        batch_size = trg.shape[1]
-        trg_vocab_size = self.decoder.output_dim
-
-        outputs = torch.zeros(trg_len, batch_size, trg_vocab_size).to(self.device)
-        hidden, cell = self.encoder(src)
-
-        input = trg[0,:]
-
-        for t in range(1, trg_len):
-            output, hidden, cell = self.decoder(input, hidden, cell)
-            outputs[t] = output
-            top1 = output.argmax(1)
-            input = trg[t] if random.random() < teacher_forcing_ratio else top1
-
-        return outputs
-
-INPUT_DIM = len(vocab)
-OUTPUT_DIM = len(vocab)
-ENC_EMB_DIM = 256
-DEC_EMB_DIM = 256
-HID_DIM = 512
-N_LAYERS = 2
-ENC_DROPOUT = 0.5
-DEC_DROPOUT = 0.5
-
-enc = Encoder(INPUT_DIM, ENC_EMB_DIM, HID_DIM, N_LAYERS, ENC_DROPOUT)
-dec = Decoder(OUTPUT_DIM, DEC_EMB_DIM, HID_DIM, N_LAYERS, DEC_DROPOUT)
-
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-
-model = Seq2Seq(enc, dec, device).to(device)
-
-# Define optimizer and loss
-optimizer = optim.Adam(model.parameters())
-criterion = nn.CrossEntropyLoss()
-
-# Training the model
-def train(model, iterator, optimizer, criterion, clip):
-    model.train()
-    epoch_loss = 0
-
-    for i, (src, trg) in enumerate(iterator):
-        src = src.to(device)
-        trg = trg.to(device)
-
-        optimizer.zero_grad()
-        output = model(src, trg)
-        output_dim = output.shape[-1]
-
-        output = output[1:].view(-1, output_dim)
-        trg = trg[1:].view(-1)
-
-        loss = criterion(output, trg)
-        loss.backward()
-
-        torch.nn.utils.clip_grad_norm_(model.parameters(), clip)
-        optimizer.step()
-        epoch_loss += loss.item()
-
-    return epoch_loss / len(iterator)
-
-# Dummy training loop for illustration
-N_EPOCHS = 10
-CLIP = 1
-
-for epoch in range(N_EPOCHS):
-    train_loss = train(model, dataloader, optimizer, criterion, CLIP)
-    print(f'Epoch {epoch+1}, Train Loss: {train_loss:.4f}')
-
-# Function for inference
-def summarize(text, tokenizer, vocab, model, device, max_len=50):
-    model.eval()
-    tokens = [token.lower() for token in tokenizer(text)]
-    tokens = ["<sos>"] + tokens + ["<eos>"]
-    src_indexes = [vocab[token] for token in tokens]
-    src_tensor = torch.LongTensor(src_indexes).unsqueeze(1).to(device)
-
-    with torch.no_grad():
-        hidden, cell = model.encoder(src_tensor)
-
-    trg_indexes = [vocab["<sos>"]]
-
-    for i in range(max_len):
-        trg_tensor = torch.LongTensor([trg_indexes[-1]]).to(device)
-        with torch.no_grad():
-            output, hidden, cell = model.decoder(trg_tensor, hidden, cell)
-        pred_token = output.argmax(1).item()
-        trg_indexes.append(pred_token)
-        if pred_token == vocab["<eos>"]:
-            break
-
-    trg_tokens = [vocab.itos[i] for i in trg_indexes]
-    return ' '.join(trg_tokens[1:-1])
-
-# Step 4: Create Streamlit App
-st.title("Text Summarization with PyTorch")
+# Streamlit app
+st.title("Text Summarization with Hugging Face Transformers")
 
 user_input = st.text_area("Enter text to summarize")
 if st.button("Summarize"):
-    summary = summarize(user_input, tokenizer, vocab, model, device)
+    tokens = tokenize(user_input)
+    st.write(f"Tokens: {tokens}")
+    summary = summarize(user_input)
     st.write(f"Summary: {summary}")