Rename pages/RNN.py to pages/17_RNN.py

pages/{RNN.py → 17_RNN.py}

@@ -2,11 +2,16 @@ import streamlit as st
 import torch
 import torch.nn as nn
 import torch.optim as optim
-from torchtext.legacy import data, datasets
+from torchtext.data.utils import get_tokenizer
+from torchtext.vocab import build_vocab_from_iterator, GloVe
+from torchtext.datasets import IMDB
+from torch.utils.data import DataLoader, random_split
 import matplotlib.pyplot as plt
 import seaborn as sns
 import pandas as pd
 import numpy as np
+from collections import Counter
+from torch.nn.utils.rnn import pad_sequence
 
 # Define the RNN model
 class RNN(nn.Module):
@@ -27,22 +32,52 @@ class RNN(nn.Module):
 # Function to load the data
 @st.cache_data
 def load_data():
-    TEXT = data.Field(tokenize='spacy', tokenizer_language='en_core_web_sm')
-    LABEL = data.LabelField(dtype=torch.float)
-    train_data, test_data = datasets.IMDB.splits(TEXT, LABEL)
-    train_data, valid_data = train_data.split(split_ratio=0.8)
+    tokenizer = get_tokenizer("basic_english")
+    train_iter, test_iter = IMDB(split=('train', 'test'))
 
-    MAX_VOCAB_SIZE = 25_000
-    TEXT.build_vocab(train_data, max_size=MAX_VOCAB_SIZE, vectors="glove.6B.100d", unk_init=torch.Tensor.normal_)
-    LABEL.build_vocab(train_data)
+    def yield_tokens(data_iter):
+        for _, text in data_iter:
+            yield tokenizer(text)
+    
+    vocab = build_vocab_from_iterator(yield_tokens(train_iter), specials=["<unk>"])
+    vocab.set_default_index(vocab["<unk>"])
+
+    # Define the text and label processing pipelines
+    text_pipeline = lambda x: vocab(tokenizer(x))
+    label_pipeline = lambda x: 1 if x == 'pos' else 0
+
+    # Process the data into tensors
+    def process_data(data_iter):
+        texts, labels = [], []
+        for label, text in data_iter:
+            texts.append(torch.tensor(text_pipeline(text), dtype=torch.long))
+            labels.append(label_pipeline(label))
+        return texts, torch.tensor(labels, dtype=torch.float)
+
+    train_texts, train_labels = process_data(train_iter)
+    test_texts, test_labels = process_data(test_iter)
+
+    # Create a custom collate function to pad sequences
+    def collate_batch(batch):
+        texts, labels = zip(*batch)
+        text_lengths = [len(text) for text in texts]
+        texts_padded = pad_sequence(texts, batch_first=True, padding_value=vocab["<pad>"])
+        return texts_padded, torch.tensor(labels, dtype=torch.float), text_lengths
+
+    # Create DataLoaders
+    train_dataset = list(zip(train_texts, train_labels))
+    test_dataset = list(zip(test_texts, test_labels))
+
+    train_size = int(0.8 * len(train_dataset))
+    valid_size = len(train_dataset) - train_size
+    train_dataset, valid_dataset = random_split(train_dataset, [train_size, valid_size])
 
     BATCH_SIZE = 64
-    train_iterator, valid_iterator, test_iterator = data.BucketIterator.splits(
-        (train_data, valid_data, test_data), 
-        batch_size=BATCH_SIZE,
-        device=device)
-    
-    return TEXT, LABEL, train_iterator, valid_iterator, test_iterator
+    train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_batch)
+    valid_loader = DataLoader(valid_dataset, batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_batch)
+    test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_batch)
+
+    return vocab, train_loader, valid_loader, test_loader
 
 # Function to train the network
 def train_network(net, iterator, optimizer, criterion, epochs):
@@ -50,10 +85,11 @@ def train_network(net, iterator, optimizer, criterion, epochs):
     for epoch in range(epochs):
         epoch_loss = 0
         net.train()
-        for batch in iterator:
+        for texts, labels, _ in iterator:
+            texts, labels = texts.to(device), labels.to(device)
             optimizer.zero_grad()
-            predictions = net(batch.text).squeeze(1)
-            loss = criterion(predictions, batch.label)
+            predictions = net(texts).squeeze(1)
+            loss = criterion(predictions, labels)
             loss.backward()
             optimizer.step()
             epoch_loss += loss.item()
@@ -72,14 +108,15 @@ def evaluate_network(net, iterator, criterion):
     all_predictions = []
     net.eval()
     with torch.no_grad():
-        for batch in iterator:
-            predictions = net(batch.text).squeeze(1)
-            loss = criterion(predictions, batch.label)
+        for texts, labels, _ in iterator:
+            texts, labels = texts.to(device), labels.to(device)
+            predictions = net(texts).squeeze(1)
+            loss = criterion(predictions, labels)
             epoch_loss += loss.item()
             rounded_preds = torch.round(torch.sigmoid(predictions))
-            correct += (rounded_preds == batch.label).sum().item()
-            total += len(batch.label)
-            all_labels.extend(batch.label.cpu().numpy())
+            correct += (rounded_preds == labels).sum().item()
+            total += len(labels)
+            all_labels.extend(labels.cpu().numpy())
             all_predictions.extend(rounded_preds.cpu().numpy())
     accuracy = 100 * correct / total
     st.write(f'Loss: {epoch_loss / len(iterator):.4f}, Accuracy: {accuracy:.2f}%')
@@ -87,7 +124,7 @@ def evaluate_network(net, iterator, criterion):
 
 # Load the data
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-TEXT, LABEL, train_iterator, valid_iterator, test_iterator = load_data()
+vocab, train_loader, valid_loader, test_loader = load_data()
 
 # Streamlit interface
 st.title("RNN for Text Classification on IMDb Dataset")
@@ -106,7 +143,7 @@ learning_rate = st.sidebar.slider('Learning Rate', 0.001, 0.1, 0.01, step=0.001)
 epochs = st.sidebar.slider('Epochs', 1, 20, 5)
 
 # Create the network
-vocab_size = len(TEXT.vocab)
+vocab_size = len(vocab)
 output_size = 1
 net = RNN(vocab_size, embed_size, hidden_size, output_size, n_layers, dropout).to(device)
 criterion = nn.BCEWithLogitsLoss()
@@ -117,7 +154,7 @@ st.write('\n' * 10)
 
 # Train the network
 if st.sidebar.button('Train Network'):
-    loss_values = train_network(net, train_iterator, optimizer, criterion, epochs)
+    loss_values = train_network(net, train_loader, optimizer, criterion, epochs)
     
     # Plot the loss values
     plt.figure(figsize=(10, 5))
@@ -133,7 +170,7 @@ if st.sidebar.button('Train Network'):
 
 # Test the network
 if 'trained_model' in st.session_state and st.sidebar.button('Test Network'):
-    accuracy, all_labels, all_predictions = evaluate_network(st.session_state['trained_model'], test_iterator, criterion)
+    accuracy, all_labels, all_predictions = evaluate_network(st.session_state['trained_model'], test_loader, criterion)
     st.write(f'Test Accuracy: {accuracy:.2f}%')
     
     # Display results in a table
@@ -149,17 +186,17 @@ def visualize_text_predictions(iterator, net):
     net.eval()
     samples = []
     with torch.no_grad():
-        for batch in iterator:
-            predictions = torch.round(torch.sigmoid(net(batch.text).squeeze(1)))
-            samples.extend(zip(batch.text.cpu(), batch.label.cpu(), predictions.cpu()))
+        for texts, labels, _ in iterator:
+            predictions = torch.round(torch.sigmoid(net(texts).squeeze(1)))
+            samples.extend(zip(texts.cpu(), labels.cpu(), predictions.cpu()))
             if len(samples) >= 10:
                 break
     return samples[:10]
 
 if 'trained_model' in st.session_state and st.sidebar.button('Show Test Results'):
-    samples = visualize_text_predictions(test_iterator, st.session_state['trained_model'])
+    samples = visualize_text_predictions(test_loader, st.session_state['trained_model'])
     st.write('Ground Truth vs Predicted for Sample Texts')
     for i, (text, true_label, predicted) in enumerate(samples):
         st.write(f'Sample {i+1}')
-        st.text(' '.join([TEXT.vocab.itos[token] for token in text]))
+        st.text(' '.join([vocab.itos[token] for token in text]))
         st.write(f'Ground Truth: {true_label.item()}, Predicted: {predicted.item()}')