Update model.py

model.py

@@ -1,66 +1,113 @@
 import torch
-import torchvision.transforms as transforms
+
+import torch.nn as nn
+
+import torch.nn.functional as F
+
 import pickle
+
+from torchvision import transforms
+
+
+
 import numpy as np
-# Import your specific model architecture here if you saved a state_dict!
-# from your_network_file import YourCNNClass 
 
-class EmotionPredictor:
-    def __init__(self, model_path='face_classifier.pth', classes_path='classes.pkl'):
-        # 1. Device Management: Automatically fall back to CPU for Hugging Face Spaces
-        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-        
-        # 2. Weight & Class Caching: Load these ONLY ONCE when the server starts
-        self.classes = self._load_classes(classes_path)
-        self.model = self._load_model(model_path)
+from PIL import Image
+
+
+
+
+
+class FaceClassifier(nn.Module):
+
+    def __init__(self, num_classes):
+
+        super().__init__()
+
+        self.conv1 = nn.Conv2d(3, 32, 3, padding=1)
+
+        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
+
+        self.conv3 = nn.Conv2d(64, 128, 3, padding=1)
+
+        self.pool = nn.MaxPool2d(2, 2)
+
         
-        # 3. Pre-compiled Tensor Transformations
-        # (Adjust the Resize dimensions to match what you used in Train_model.ipynb)
+
+        self.dropout = nn.Dropout(0.1)
+
+        self.fc1 = nn.Linear(128 * 16 * 16, 512)
+
+        self.fc2 = nn.Linear(512, num_classes) 
+
+
+
+    def forward(self, x):
+
+        x = self.pool(F.relu(self.conv1(x)))
+
+        x = self.pool(F.relu(self.conv2(x)))
+
+        x = self.pool(F.relu(self.conv3(x)))
+
+        x = x.view(-1, 128 * 16 * 16)
+
+        x = self.dropout(F.relu(self.fc1(x)))
+
+        x = self.fc2(x)
+
+        return x
+
+
+
+
+
+
+
+class EmotionPredictor:
+
+    def __init__(self):
+
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+
+        with open("classes.pkl", "rb") as f:
+
+            self.classes = pickle.load(f)
+
+
+
+        self.model = FaceClassifier(len(self.classes))
+
+        self.model.load_state_dict(
+
+            torch.load("face_classifier.pth", map_location=self.device)
+
+        )
+
+        self.model.to(self.device).eval()
+
+
+
         self.transform = transforms.Compose([
-            transforms.ToPILImage(),
-            transforms.Resize((224, 224)), 
+
+            transforms.Resize((128, 128)),
+
             transforms.ToTensor(),
-            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+
+            transforms.Normalize((0.5,), (0.5,))
+
         ])
 
-    def _load_classes(self, path):
-        try:
-            with open(path, 'rb') as f:
-                return pickle.load(f)
-        except Exception as e:
-            print(f"Warning: Could not load {path}. Defaulting to standard classes. Error: {e}")
-            return ['Angry', 'Disgust', 'Fear', 'Happy', 'Sad', 'Surprise', 'Neutral']
-
-    def _load_model(self, path):
-        try:
-            # OPTION A: If you saved the ENTIRE model in your Jupyter Notebook
-            model = torch.load(path, map_location=self.device)
-            
-            # OPTION B: If you saved ONLY the state_dict (Best Practice)
-            # Uncomment and use this if Option A throws an architecture error:
-            # model = YourCNNClass(num_classes=len(self.classes))
-            # model.load_state_dict(torch.load(path, map_location=self.device))
-            
-            model.to(self.device)
-            
-            # CRITICAL: Put the model in evaluation mode to disable dropout/batchnorm
-            model.eval() 
-            return model
-            
-        except Exception as e:
-            raise RuntimeError(f"Failed to load PyTorch model: {e}")
-
-    def predict(self, face_image_rgb):
-        """
-        Expects an RGB numpy array of the cropped face from OpenCV.
-        """
-        # Apply transforms and add the batch dimension (B, C, H, W)
-        tensor = self.transform(face_image_rgb).unsqueeze(0).to(self.device)
-        
-        # Disable gradient calculation for significantly faster CPU inference
-        with torch.no_grad():
-            outputs = self.model(tensor)
-            _, predicted = torch.max(outputs, 1)
-            
-        return self.classes[predicted.item()]
+    @torch.inference_mode()
+
+    def predict(self, image_np: np.ndarray) -> str:
+
+        img = Image.fromarray(image_np)
+
+        tensor = self.transform(img).unsqueeze(0).to(self.device)
+
+        output = self.model(tensor)
 
+        return self.classes[output.argmax(1).item()]