Updated model.py to achieve over 63% accuracy

model.py

@@ -88,32 +88,23 @@ class Net(nn.Module):
     def __init__(self):
         super(Net, self).__init__()
 
-        # placing all layers in nn.Sequential brought +4% accuracy improvement
         self.network = nn.Sequential(
             # first 2 concolutional layers
             nn.Conv2d(nc, 16, kernel_size=3, stride=1, padding=1),          # a convoltional layer with 3 input channels, 16 output channels,
                                                                             # a kernel size of 3, a stride of 1, and padding of 1
-            nn.Conv2d(16, 64, kernel_size=3, stride=1, padding=1),
-            nn.Conv2d(64, 32, kernel_size=3, stride=1, padding=1),
+            nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1),
 
             # max pooling layers
             nn.MaxPool2d(kernel_size=2, stride=2),                          # a max pooling layer with kernel size of 3 and stride of 1
                                                                             # helps reduce spatial dimensions of feature maps
             nn.Flatten(),
-            nn.Linear(32 * 16 * 16, 16),                                    # adjust the input size based on the output of the last conv layer
+            nn.Linear(32 * 16 * 16, 64),                                    # adjust the input size based on the output of the last conv layer
+            nn.Linear(64, 16),
             nn.Linear(16, output),
         )
 
 
     def forward(self, x):
-        # x = self.pool(F.relu(self.conv1(x)))                # First convoltional layer, then ReLU active, then max pooling
-        # x = self.pool(F.relu(self.conv2(x)))                # Second convolutional layer, then ReLu, then pooling
-
-        # x = x.view(x.size(0), -1)                           # Flatten tensor before passing through fully connected layers
-
-        # x = F.relu(self.fc1(x))                             # First fully connected layer, then ReLu, then pooling
-        # x = self.fc2(x)                                     # Layer with predictions, fully connected
-
         return self.network(x)
     
 # creates instance of the model
@@ -121,8 +112,8 @@ model = Net()
 
 # create the optimizer and criterion
 criterion = nn.CrossEntropyLoss()
-optimizer = optim.SGD(model.parameters() , lr=learning_rate, momentum=0.9)
-# Maybe use Adam
+# Adam optimizer yields much better results than SGD
+optimizer = optim.Adam(model.parameters(), lr=learning_rate)
 
 # moves model to device (ie. cpu/gpu)
 model.to(device)
@@ -203,4 +194,6 @@ print(f"Accuracy on the test dataset: {accuracy:.2%}")
 
 # ADDED: After adding all layers to nn.Sequential: ~55-57%
 
-# After adding a 3rd Conv2d layer (64, 32)
+# ADDED: After using optim.Adam instead of optim.SGD: ~61-62%
+
+# ADDED: After adding a nn.Linear(64, 16): ~62-63+%