Update model.py

model.py

@@ -1,60 +1,66 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import pickle
-from torchvision import transforms
-
-import numpy as np
-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)
-        
-        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.Resize((128, 128)),
-            transforms.ToTensor(),
-            transforms.Normalize((0.5,), (0.5,))
-        ])
-    @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()]
-
-
-
+import torch
+import torchvision.transforms as transforms
+import pickle
+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)
+        
+        # 3. Pre-compiled Tensor Transformations
+        # (Adjust the Resize dimensions to match what you used in Train_model.ipynb)
+        self.transform = transforms.Compose([
+            transforms.ToPILImage(),
+            transforms.Resize((224, 224)), 
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+
+    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()]
+