convolution

app.py

@@ -3,7 +3,7 @@ from PIL import Image
 import numpy as np
 import torch
 import torch.nn as nn
-import model
+from models import Net,NetConv
 
 net = torch.load('mnist.pth')
 net.eval()

app_conv.py

@@ -0,0 +1,40 @@
+import gradio as gr
+from PIL import Image
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from models import NetConv
+
+    
+net_conv = torch.load('mnist_conv.pth')
+net_conv.eval()
+
+def predict(img):
+    arr = np.array(img) / 255  # Assuming img is in the range [0, 255]
+    arr.reshape(28,28)
+    arr = np.expand_dims(arr, axis=0)  # Add batch dimension
+    arr = np.expand_dims(arr, axis=0)  # Add batch dimension
+    arr = torch.from_numpy(arr).float()  # Convert to PyTorch tensor
+    output = net_conv(arr)
+    topk_values, topk_indices = torch.topk(output, 2)  # Get the top 2 classes
+    return [str(k) for k in topk_indices[0].tolist()]
+
+with gr.Blocks() as iface:
+    gr.Markdown("# MNIST + Gradio End to End")
+    gr.HTML("Shows end to end MNIST training with Gradio interface")
+    with gr.Row():
+        with gr.Column():
+            sp = gr.Sketchpad(shape=(28, 28))
+            with gr.Row():
+                with gr.Column():
+                    pred_button = gr.Button("Predict")
+                with gr.Column():
+                    clear = gr.Button("Clear")
+        with gr.Column():
+            label1 = gr.Label(label='1st Pred')
+            label2 = gr.Label(label='2nd Pred')
+
+    pred_button.click(predict, inputs=sp, outputs=[label1,label2])
+    clear.click(lambda: None, None, sp, queue=False)
+iface.launch()

model.py → models.py

@@ -1,5 +1,6 @@
 import torch
 import torch.nn as nn
+import torch.nn.functional as F
 # Define the model
 class Net(nn.Module):
     def __init__(self):
@@ -14,4 +15,27 @@ class Net(nn.Module):
         x = torch.relu(self.fc1(x))
         x = torch.relu(self.fc2(x))
         x = torch.relu(self.fc3(x))
-        return self.fc4(x)
+        return self.fc4(x)
+
+class NetConv(nn.Module):
+    def __init__(self):
+        super(NetConv, self).__init__()
+        self.conv1 = nn.Conv2d(1, 32, 3)
+        self.conv2 = nn.Conv2d(32, 64, 3)
+        self.fc1 = nn.Linear(64 * 5 * 5, 128) # Corrected
+        self.fc2 = nn.Linear(128, 10)
+
+    def forward(self, x):
+        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
+        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
+        x = x.view(-1, self.num_flat_features(x))
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
+        return F.log_softmax(x, dim=1)
+
+    def num_flat_features(self, x):
+        size = x.size()[1:]
+        num_features = 1
+        for s in size:
+            num_features *= s
+        return num_features

train.py

@@ -3,7 +3,7 @@ import torch.nn as nn
 import torch.optim as optim
 import torchvision
 import torchvision.transforms as transforms
-import model
+from models import Net
 # Load the MNIST dataset
 train_set = torchvision.datasets.MNIST(root='./data', train=True,
                                        download=True, transform=transforms.ToTensor())
@@ -17,7 +17,7 @@ test_loader = torch.utils.data.DataLoader(test_set, batch_size=32,
 
 
 
-net = model.Net()
+net = Net()
 
 # Use CrossEntropyLoss for multi-class classification
 criterion = nn.CrossEntropyLoss()