Upload 3 files

Modified_ALexnet_for_CIFAR.pth

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

app.py

@@ -0,0 +1,30 @@
+import torch
+import gradio as gr
+from model import ALexNet  # Make sure this matches your actual class name
+from torchvision import transforms
+from PIL import Image
+
+# Load model
+model = ALexNet(3, 64, 10)
+model.load_state_dict(torch.load("Modified_ALexnet_for_CIFAR.pth", map_location=torch.device("cpu")))
+model.eval()
+
+# Preprocessing
+transform = transforms.Compose([
+    transforms.Resize((32, 32)),  # Adjust to your model's input size
+    transforms.ToTensor()
+])
+
+# Inference function
+def predict(img):
+    img = transform(img).unsqueeze(0)
+    with torch.no_grad():
+        outputs = model(img)
+        predicted_class = torch.argmax(outputs, dim=1).item()
+        class_names = ["airplane", "automobile", "bird", "cat", "deer",
+               "dog", "frog", "horse", "ship", "truck"]
+
+    return f"Predicted class: {class_names[predicted_class]}"
+
+# Gradio UI
+gr.Interface(fn=predict, inputs=gr.Image(type="pil"), outputs="text").launch()

model.py

@@ -0,0 +1,71 @@
+import torch
+from torch import nn
+
+class ALexNet(nn.Module):
+  def __init__(self, input_shape: int, hidden_units: int, output_shape):
+    super().__init__()
+    self.block1 = nn.Sequential(
+    nn.Conv2d(input_shape, 64, kernel_size=3, padding=1),
+    nn.BatchNorm2d(64),
+    nn.ReLU(),
+    nn.MaxPool2d(2, 2)
+    )
+    self.block2 = nn.Sequential(
+        nn.Conv2d(64, 192, kernel_size=3, padding=1),
+        nn.BatchNorm2d(192),
+        nn.ReLU(),
+        nn.MaxPool2d(2, 2)
+    )
+    self.block3 = nn.Sequential(
+        nn.Conv2d(192, 384, kernel_size=3, padding=1),
+        nn.BatchNorm2d(384),
+        nn.ReLU()
+    )
+    self.block4 = nn.Sequential(
+        nn.Conv2d(384, 256, kernel_size=3, padding=1),
+        nn.BatchNorm2d(256),
+        nn.ReLU()
+    )
+    self.block5 = nn.Sequential(
+        nn.Conv2d(256, 256, kernel_size=3, padding=1),
+        nn.BatchNorm2d(256),
+        nn.ReLU(),
+        nn.MaxPool2d(2, 2)
+    )
+
+    with torch.no_grad():
+      dummy = torch.zeros(1, input_shape, 32, 32)  # change 224 if needed
+      x = self.block1(dummy)
+      x = self.block2(x)
+      x = self.block3(x)
+      x = self.block4(x)
+      x = self.block5(x)
+      self.flattened_size = x.view(1, -1).shape[1]
+    self.flatten = nn.Flatten()
+    self.fc1 = nn.Sequential(
+        nn.Linear(in_features=self.flattened_size,
+                  out_features=1024),
+        nn.ReLU(),
+        nn.Dropout(0.5)
+    )
+    self.fc2 = nn.Sequential(
+        nn.Linear(1024, 1024),
+        nn.ReLU(),
+        nn.Dropout(0.5)
+    )
+    self.classifier = nn.Sequential(
+        nn.Linear(1024, output_shape)
+    )
+
+  def forward(self, x: torch.Tensor):
+    x = self.block1(x)
+    x = self.block2(x)
+    x = self.block3(x)
+    x = self.block4(x)
+    x = self.block5(x)
+    x = self.flatten(x)
+    x = self.fc1(x)
+    x = self.fc2(x)
+    x = self.classifier(x)
+
+    return x