Update pages/1_TensorIntro.py

pages/1_TensorIntro.py

@@ -202,88 +202,87 @@ print("Normalized data:", normalized_data)
 '''
     },
 
-"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.",
+"Final Project: Image Classification with a Simple CNN": {
+    "description": "In this project, you will build and train a simple Convolutional Neural Network (CNN) for image classification using the CIFAR-10 dataset. This involves loading the dataset, defining the CNN model, and training the model to classify images into one of the 10 classes.",
     "code": '''import torch
 import torch.nn as nn
 import torch.optim as optim
-from torchtext.datasets import IMDB
-from torchtext.data.utils import get_tokenizer
-from torchtext.vocab import build_vocab_from_iterator
-from torch.utils.data import DataLoader
-from torch.nn.utils.rnn import pad_sequence
-
-# Define the tokenizer and vocabulary
-tokenizer = get_tokenizer('basic_english')
-train_iter = IMDB(split='train')
-
-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 preprocessing pipeline
-text_pipeline = lambda x: vocab(tokenizer(x))
-label_pipeline = lambda x: 1 if x == 'pos' else 0
-
-# Define the collate function for the DataLoader
-def collate_batch(batch):
-    label_list, text_list, lengths = [], [], []
-    for _label, _text in batch:
-        label_list.append(label_pipeline(_label))
-        processed_text = torch.tensor(text_pipeline(_text), dtype=torch.int64)
-        text_list.append(processed_text)
-        lengths.append(processed_text.size(0))
-    label_list = torch.tensor(label_list, dtype=torch.float)
-    text_list = pad_sequence(text_list, batch_first=True)
-    lengths = torch.tensor(lengths, dtype=torch.int64)
-    return label_list, text_list, lengths
-
-# Create DataLoaders for training and testing
-train_iter, test_iter = IMDB()
-train_dataloader = DataLoader(list(train_iter), batch_size=8, shuffle=True, collate_fn=collate_batch)
-test_dataloader = DataLoader(list(test_iter), batch_size=8, shuffle=False, collate_fn=collate_batch)
-
-# 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, batch_first=True, enforce_sorted=False)
-        packed_output, (hidden, cell) = self.lstm(packed_embedded)
-        return self.fc(hidden.squeeze(0))
-
-# Instantiate the model
-INPUT_DIM = len(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())
+import torchvision
+import torchvision.transforms as transforms
+
+# Define the transformation for the dataset
+transform = transforms.Compose(
+    [transforms.ToTensor(),
+     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
+
+# Load the CIFAR-10 dataset
+trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
+trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True, num_workers=2)
+
+testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
+testloader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=False, num_workers=2)
+
+# Define the CNN model
+class SimpleCNN(nn.Module):
+    def __init__(self):
+        super(SimpleCNN, self).__init__()
+        self.conv1 = nn.Conv2d(3, 6, 5)
+        self.pool = nn.MaxPool2d(2, 2)
+        self.conv2 = nn.Conv2d(6, 16, 5)
+        self.fc1 = nn.Linear(16 * 5 * 5, 120)
+        self.fc2 = nn.Linear(120, 84)
+        self.fc3 = nn.Linear(84, 10)
+
+    def forward(self, x):
+        x = self.pool(nn.functional.relu(self.conv1(x)))
+        x = self.pool(nn.functional.relu(self.conv2(x)))
+        x = x.view(-1, 16 * 5 * 5)
+        x = nn.functional.relu(self.fc1(x))
+        x = nn.functional.relu(self.fc2(x))
+        x = self.fc3(x)
+        return x
+
+# Instantiate the model, loss function, and optimizer
+net = SimpleCNN()
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
 
 # Training loop
-N_EPOCHS = 5
-for epoch in range(N_EPOCHS):
-    model.train()
-    for labels, text, text_lengths in train_dataloader:
+for epoch in range(5):  # loop over the dataset multiple times
+    running_loss = 0.0
+    for i, data in enumerate(trainloader, 0):
+        inputs, labels = data
+
         optimizer.zero_grad()
-        predictions = model(text, text_lengths).squeeze(1)
-        loss = criterion(predictions, labels)
+
+        outputs = net(inputs)
+        loss = criterion(outputs, labels)
         loss.backward()
         optimizer.step()
 
+        running_loss += loss.item()
+        if i % 200 == 199:    # print every 200 mini-batches
+            print(f'[{epoch + 1}, {i + 1}] loss: {running_loss / 200:.3f}')
+            running_loss = 0.0
+
 print('Finished Training')
 
+# Save the trained model
+torch.save(net.state_dict(), 'simple_cnn.pth')
+
+# Testing the model
+correct = 0
+total = 0
+with torch.no_grad():
+    for data in testloader:
+        images, labels = data
+        outputs = net(images)
+        _, predicted = torch.max(outputs.data, 1)
+        total += labels.size(0)
+        correct += (predicted == labels).sum().item()
+
+print(f'Accuracy of the network on the 10000 test images: {100 * correct / total}%')
+
     
 '''
     },