updating network architecture

MNISTModel_97.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8f6e5ce379e6857ca016fdc51f17e2b87926295a02e9f980bd214bd7a82e320
+size 1745671

MNISTModel_98.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:097d546bb4f0432bd9310f9228edb7d7304b6ecde70b2de66ae9a76ae9ecd034
+size 1690063

app.py

@@ -6,20 +6,20 @@ from neural_network import MNISTNetwork
 
 transform = transforms.Compose([
     transforms.ToTensor(),  # Convert image to tensor
-    transforms.Normalize((0.1307,), (0.3081,))  # Normalize the image
+    transforms.Normalize((0.5,), (0.5,))  # Normalize the image
 ])
 
 # Load the trained model    
-net = MNISTNetwork()
-net.load_state_dict(torch.load('mnist_net.pth'))
+net = torch.load('MNISTModel_98.pth')
 LABELS = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
 
 def predict(drawing): 
     if drawing is None: 
-        return "Draw something hoe"
+        return "Draw a number hoe"
     
     input_tensor = transform(drawing)
-    x = input_tensor.view(input_tensor.shape[0], -1)
+    x = input_tensor
+    # x = input_tensor.view(input_tensor.shape[0], -1)
     
     with torch.no_grad():
         output = net(x)

neural_network.py

@@ -1,39 +1,42 @@
-import torch.nn as nn 
-import torch.nn.functional as F
+import torch
+import torch.nn as nn
+import torch.nn.functional as F 
 
-class MNISTNetwork(nn.Module): 
+# class MNISTNetwork(nn.Module): 
+#     # achieved 97 percent accuracy 
+#     def __init__(self): 
+#         super().__init__()
+#         self.layer1 = nn.Linear(784, 400)
+#         self.layer2 = nn.Linear(400, 256)
+#         self.layer3 = nn.Linear(256, 64)
+#         self.layer4 = nn.Linear(64, 32)
+#         self.layer5 = nn.Linear(32, 10)
     
-    def __init__(self): 
+#     def forward(self, x):
+#         x = x.view(-1, 28*28) 
+#         x = torch.relu(self.layer1(x))
+#         x = torch.relu(self.layer2(x))
+#         x = torch.relu(self.layer3(x))
+#         x = torch.relu(self.layer4(x))
+#         x = torch.relu(self.layer5(x))
+#         return F.log_softmax(x, dim=1)
+
+class MNISTNetwork(nn.Module):
+    # achieved 98.76 percent accuracy 
+    def __init__(self):
         super().__init__()
-        self.layer1 = nn.Linear(784, 128)
-        self.layer2 = nn.Linear(128, 64)
-        self.layer3 = nn.Linear(64, 32)
-        self.layer4 = nn.Linear(32, 10)
-    
+        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
+        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
+        self.fc1 = nn.Linear(64*7*7, 128)
+        self.fc2 = nn.Linear(128, 10)
+
     def forward(self, x):
-        x = F.relu(self.layer1(x))
-        x = F.relu(self.layer2(x))
-        x = F.relu(self.layer3(x))
-        x = self.layer4(x)
+        x = F.relu(self.conv1(x))
+        x = F.max_pool2d(x, 2)
+        x = F.relu(self.conv2(x))
+        x = F.max_pool2d(x, 2)
+        x = x.view(-1, 64*7*7)
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
         return F.log_softmax(x, dim=1)
 
-
-
-# class MNISTNetwork(nn.Module):
-#     def __init__(self):
-#         super().__init__()
-#         self.conv1 = nn.Conv2d(1, 32, kernel_size=5, padding=2)
-#         self.conv2 = nn.Conv2d(32, 64, kernel_size=5, padding=2)
-#         self.fc1 = nn.Linear(64*7*7, 1024)
-#         self.fc2 = nn.Linear(1024, 10)
-
-#     def forward(self, x):
-#         x = nn.functional.relu(self.conv1(x))
-#         x = nn.functional.max_pool2d(x, 2)
-#         x = nn.functional.relu(self.conv2(x))
-#         x = nn.functional.max_pool2d(x, 2)
-#         x = x.view(-1, 64*7*7)
-#         x = nn.functional.relu(self.fc1(x))
-#         x = nn.functional.dropout(x, training=self.training)
-#         x = self.fc2(x)
-#         return nn.functional.log_softmax(x, dim=1)

train_model.py

@@ -0,0 +1,86 @@
+import torch
+import torchvision 
+import multiprocessing, prettytable
+import torchvision.transforms as transforms
+from neural_network import MNISTNetwork
+
+
+# hyperparameters 
+BATCH_SIZE = 64
+NUM_WORKERS = 2
+EPOCH = 12
+LEARNING_RATE = 0.01
+MOMENTUM = 0.5
+LOSS = torch.nn.CrossEntropyLoss()
+
+
+## Step 1: define our transforms 
+transform = transforms.Compose(
+    [
+        transforms.ToTensor(),
+        transforms.Normalize((0.5), (0.5))
+    ]
+)
+
+## Step 2: get our datasets
+full_ds = torchvision.datasets.MNIST(root='./data', train=True, download=False, transform=transform)
+train_ds, valid_ds = torch.utils.data.random_split(full_ds, [50000, 10000])
+test_ds = torchvision.datasets.MNIST(root='./data', train=False, download=False, transform=transform)
+
+## Step 3: create our dataloaders 
+train_dl = torch.utils.data.DataLoader(train_ds, num_workers=NUM_WORKERS, shuffle=True, batch_size=BATCH_SIZE)
+valid_dl = torch.utils.data.DataLoader(valid_ds, num_workers=NUM_WORKERS, shuffle=False, batch_size=BATCH_SIZE)
+test_dl = torch.utils.data.DataLoader(test_ds, num_workers=NUM_WORKERS, shuffle=False, batch_size=BATCH_SIZE)
+
+## Step 4: define our model and optimizer 
+model = MNISTNetwork()
+criteron = LOSS # define our loss function
+optimizer = torch.optim.SGD(model.parameters(), lr=LEARNING_RATE, momentum=MOMENTUM)
+
+## define our table
+table = prettytable.PrettyTable()
+table.field_names = ['Epoch', 'Training Loss', 'Validation Accuracy']
+
+if __name__ == "__main__":
+    multiprocessing.freeze_support()
+    ## begin training process 
+    for e in range(EPOCH): 
+        model.train()
+        running_loss = 0.0
+        for inputs, labels in train_dl:
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = criteron(outputs, labels)
+            loss.backward()
+            optimizer.step()
+            running_loss += loss.item()
+        train_loss = round(running_loss/len(train_dl), 4)
+    
+        # evaluate on the test set
+        model.eval()
+        with torch.no_grad():
+            total, correct = 0, 0
+            for inputs, labels in valid_dl: 
+                outputs = model(inputs)
+                _, predicted = torch.max(outputs.data, 1)
+                total += labels.size(0)
+                correct += (predicted == labels).sum().item()
+            val_acc = round((correct/total)*100, 3)
+        table.add_row([e, train_loss, val_acc])
+        print(f'Training Loss: {train_loss}, Validation Accuracy: {val_acc}')
+    
+    print(table)
+    # evaluate on test set
+    model.eval()
+    with torch.no_grad(): 
+        total, correct = 0, 0
+        for inputs, labels in test_dl: 
+            outputs = model(inputs)
+            _, predicted = torch.max(outputs.data, 1)
+            total += labels.size(0)
+            correct += (predicted == labels).sum().item()
+    test_acc = round((correct/total)*100, 3)
+    
+    print(f'Test Accuracy: {test_acc}')
+    torch.save(model, 'MNISTModel.pth')
+