Update pages/1_TensorIntro.py

pages/1_TensorIntro.py

@@ -201,49 +201,73 @@ normalized_data = min_max_normalize(data)
 print("Normalized data:", normalized_data)
 '''
     },
-    "Final Project: Training a Simple Neural Network on MNIST": {
-        "description": "This project involves building and training a simple neural network on the MNIST dataset. It encompasses loading the dataset, defining the network architecture, and implementing the training loop with loss computation and backpropagation.",
+
+    "Final Project: Sentiment Analysis with LSTM": {
+        "description": "In this project, you will build and train a simple Long Short-Term Memory (LSTM) network for sentiment analysis on a text dataset. This involves preprocessing text data, defining the LSTM model, and training the model to classify text as positive or negative sentiment.",
         "code": '''import torch
 import torch.nn as nn
 import torch.optim as optim
-from torchvision import datasets, transforms
-
-# Define a simple neural network
-class SimpleNN(nn.Module):
-    def __init__(self):
-        super(SimpleNN, self).__init__()
-        self.fc1 = nn.Linear(28*28, 128)
-        self.fc2 = nn.Linear(128, 10)
-
-    def forward(self, x):
-        x = x.view(-1, 28*28)
-        x = torch.relu(self.fc1(x))
-        x = self.fc2(x)
-        return x
-
-# Load dataset
-transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
-trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
-trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
-
-# Initialize network, loss function, and optimizer
-model = SimpleNN()
-criterion = nn.CrossEntropyLoss()
-optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
+from torchtext.legacy import data, datasets
+
+# Define the fields for the dataset
+TEXT = data.Field(tokenize='spacy', include_lengths=True)
+LABEL = data.LabelField(dtype=torch.float)
+
+# Load the IMDb dataset
+train_data, test_data = datasets.IMDB.splits(TEXT, LABEL)
+
+# Build the vocabulary
+TEXT.build_vocab(train_data, max_size=25000)
+LABEL.build_vocab(train_data)
+
+# Create the iterators
+BATCH_SIZE = 64
+train_iterator, test_iterator = data.BucketIterator.splits(
+    (train_data, test_data),
+    batch_size=BATCH_SIZE,
+    sort_within_batch=True,
+    device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+)
+
+# Define the LSTM model
+class LSTM(nn.Module):
+    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim):
+        super().__init__()
+        self.embedding = nn.Embedding(vocab_size, embedding_dim)
+        self.lstm = nn.LSTM(embedding_dim, hidden_dim)
+        self.fc = nn.Linear(hidden_dim, output_dim)
+
+    def forward(self, text, text_lengths):
+        embedded = self.embedding(text)
+        packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded, text_lengths)
+        packed_output, (hidden, cell) = self.lstm(packed_embedded)
+        return self.fc(hidden.squeeze(0))
+
+# Instantiate the model
+INPUT_DIM = len(TEXT.vocab)
+EMBEDDING_DIM = 100
+HIDDEN_DIM = 256
+OUTPUT_DIM = 1
+model = LSTM(INPUT_DIM, EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM)
+
+# Define the loss and optimizer
+criterion = nn.BCEWithLogitsLoss()
+optimizer = optim.Adam(model.parameters())
 
 # Training loop
-for epoch in range(2):  # loop over the dataset multiple times
-    for inputs, labels in trainloader:
-        # Zero the parameter gradients
+N_EPOCHS = 5
+for epoch in range(N_EPOCHS):
+    model.train()
+    for batch in train_iterator:
         optimizer.zero_grad()
-        # Forward pass
-        outputs = model(inputs)
-        loss = criterion(outputs, labels)
-        # Backward pass and optimize
+        text, text_lengths = batch.text
+        predictions = model(text, text_lengths).squeeze(1)
+        loss = criterion(predictions, batch.label)
         loss.backward()
         optimizer.step()
 
 print('Finished Training')
+    
 '''
     },
 }