Update pages/1_TensorIntro.py

pages/1_TensorIntro.py

@@ -202,86 +202,45 @@ print("Normalized data:", normalized_data)
 '''
     },
 
-"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.",
+"Final Project: Basic Tensor Operations": {
+    "description": "This project demonstrates the usage of PyTorch tensors through basic mathematical operations such as addition, multiplication, and reshaping. The aim is to help you understand the fundamental operations you can perform with tensors.",
     "code": '''import torch
-import torch.nn as nn
-import torch.optim as optim
-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))])
-
-# 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
-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()
-
-        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}%')
+# Create two tensors
+tensor_a = torch.tensor([[1, 2], [3, 4]])
+tensor_b = torch.tensor([[5, 6], [7, 8]])
+
+# Perform basic operations
+# Addition
+add_result = tensor_a + tensor_b
+print("Addition result:")
+print(add_result)
+
+# Element-wise multiplication
+mul_result = tensor_a * tensor_b
+print("Element-wise multiplication result:")
+print(mul_result)
+
+# Matrix multiplication
+matmul_result = torch.matmul(tensor_a, tensor_b)
+print("Matrix multiplication result:")
+print(matmul_result)
+
+# Reshaping tensor_a
+reshaped_tensor = tensor_a.view(4, 1)
+print("Reshaped tensor_a:")
+print(reshaped_tensor)
+
+# Slicing tensor_b
+sliced_tensor = tensor_b[:, 1]
+print("Sliced tensor_b (second column):")
+print(sliced_tensor)
+
+# Compute the mean of tensor_a
+mean_result = torch.mean(tensor_a.float())
+print("Mean of tensor_a:")
+print(mean_result)
+
     
 '''
     },