update

Author: mhjensen

doc/pub/week4/pdf/week4.pdf

@@ -0,0 +1,76 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torchvision import datasets, transforms
+
+# Set device
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Define transforms
+transform = transforms.Compose([
+   transforms.ToTensor(),
+   transforms.Normalize((0.1307,), (0.3081,))
+])
+
+# Load datasets
+train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
+test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)
+
+# Create data loaders
+train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
+test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)
+
+# Define CNN model
+class CNN(nn.Module):
+   def __init__(self):
+       super(CNN, self).__init__()
+       self.conv1 = nn.Conv2d(1, 32, 3, padding=1)
+       self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
+       self.pool = nn.MaxPool2d(2, 2)
+       self.fc1 = nn.Linear(64*7*7, 1024)
+       self.fc2 = nn.Linear(1024, 10)
+       self.dropout = nn.Dropout(0.5)
+
+   def forward(self, x):
+       x = self.pool(F.relu(self.conv1(x)))
+       x = self.pool(F.relu(self.conv2(x)))
+       x = x.view(-1, 64*7*7)
+       x = self.dropout(F.relu(self.fc1(x)))
+       x = self.fc2(x)
+       return x
+
+# Initialize model, loss function, and optimizer
+model = CNN().to(device)
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.Adam(model.parameters(), lr=0.001)
+
+# Training loop
+num_epochs = 10
+for epoch in range(num_epochs):
+   model.train()
+   running_loss = 0.0
+   for batch_idx, (data, target) in enumerate(train_loader):
+       data, target = data.to(device), target.to(device)
+       optimizer.zero_grad()
+       outputs = model(data)
+       loss = criterion(outputs, target)
+       loss.backward()
+       optimizer.step()
+       running_loss += loss.item()
+
+   print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(train_loader):.4f}')
+
+# Testing the model
+model.eval()
+correct = 0
+total = 0
+with torch.no_grad():
+   for data, target in test_loader:
+       data, target = data.to(device), target.to(device)
+       outputs = model(data)
+       _, predicted = torch.max(outputs.data, 1)
+       total += target.size(0)
+       correct += (predicted == target).sum().item()
+
+print(f'Test Accuracy: {100 * correct / total:.2f}%')