face expressions

app/Hackathon_setup/exp_recognition.py

@@ -54,49 +54,104 @@ def detected_face(image):
 #4) Perform necessary transformations to the input(detected face using the above function), this should return the Expression in string form ex: "Anger"
 #5) For loading your model use the current_path+'your model file name', anyhow detailed example is given in comments to the function 
 ##Caution: Don't change the definition or function name; for loading the model use the current_path for path example is given in comments to the function
+# def get_expression(img):
+#     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+#
+#     # Recreate the same model architecture
+#     num_classes = 7  # 👈 change this to match your training setup
+#
+#     model = models.resnet18(weights=None)
+#     model.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)
+#     # no pretrained weights now
+#     model.fc = nn.Sequential(
+#         nn.Linear(model.fc.in_features, 256),
+#         nn.ReLU(inplace=True),
+#         nn.Linear(256, num_classes)
+#     )
+#
+#     model = model.to(device)
+#
+#     # Create the optimizer (same as training)
+#     optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)
+#
+#     # Load the checkpoint
+#     BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+#     ckpt_path = os.path.join(BASE_DIR, "expression_model.t7")
+#     checkpoint = torch.load(ckpt_path, map_location=device)
+#
+#     # Restore weights and optimizer
+#     model.load_state_dict(checkpoint['model_state_dict'])
+#     optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+#
+#     # Put the model in evaluation mode
+#     model.eval()
+#
+#     ##########################################################################################
+#     ##Example for loading a model using weight state dictionary:                            ##
+#     ## face_det_net = facExpRec() #Example Network                                          ##
+#     ## model = torch.load(current_path + '/exp_recognition_net.t7', map_location=device)    ##
+#     ## face_det_net.load_state_dict(model['net_dict'])                                      ##
+#     ##                                                                                      ##
+#     ##current_path + '/<network_definition>' is path of the saved model if present in       ##
+#     ##the same path as this file, we recommend to put in the same directory                 ##
+#     ##########################################################################################
+#     ##########################################################################################
+#
+#     transform = transforms.Compose([
+#         transforms.Grayscale(num_output_channels=1),
+#         transforms.Resize(256),
+#         transforms.CenterCrop(224),
+#         transforms.ToTensor(),
+#         transforms.Normalize(mean=[0.5], std=[0.5])
+#     ])
+#
+#     face = detected_face(img)
+#     if face==0:
+#         face = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY))
+#
+#     face = transform(face).unsqueeze(0).to(device)
+#     # YOUR CODE HERE, return expression using your model
+#     with torch.no_grad():
+#         outputs = model(face)
+#         probs = F.softmax(outputs, dim=1)
+#         predicted_class = probs.argmax(dim=1).item()
+#     return predicted_class
+
+
 def get_expression(img):
     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
 
-    # Recreate the same model architecture
-    num_classes = 7  # 👈 change this to match your training setup
+    num_classes = 7  # update as per your dataset
+
+    # Recreate exact same architecture as training
+    model = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1)
 
-    model = models.resnet18(weights=None)
+    # Convert first conv layer to accept 1 channel (grayscale)
+    pretrained_conv = model.conv1.weight
     model.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)
-    # no pretrained weights now
+    with torch.no_grad():
+        model.conv1.weight = nn.Parameter(pretrained_conv.mean(dim=1, keepdim=True))
+
+    # Fully connected head (same as training)
     model.fc = nn.Sequential(
         nn.Linear(model.fc.in_features, 256),
-        nn.ReLU(inplace=True),
+        nn.ReLU(),
+        nn.Dropout(0.5),
         nn.Linear(256, num_classes)
     )
 
     model = model.to(device)
 
-    # Create the optimizer (same as training)
-    optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)
-
-    # Load the checkpoint
+    # Load checkpoint
     BASE_DIR = os.path.dirname(os.path.abspath(__file__))
     ckpt_path = os.path.join(BASE_DIR, "expression_model.t7")
     checkpoint = torch.load(ckpt_path, map_location=device)
 
-    # Restore weights and optimizer
+    # Restore weights (no need for optimizer if inference-only)
     model.load_state_dict(checkpoint['model_state_dict'])
-    optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
-
-    # Put the model in evaluation mode
     model.eval()
-    
-    ##########################################################################################
-    ##Example for loading a model using weight state dictionary:                            ##
-    ## face_det_net = facExpRec() #Example Network                                          ##
-    ## model = torch.load(current_path + '/exp_recognition_net.t7', map_location=device)    ##
-    ## face_det_net.load_state_dict(model['net_dict'])                                      ##
-    ##                                                                                      ##
-    ##current_path + '/<network_definition>' is path of the saved model if present in       ##
-    ##the same path as this file, we recommend to put in the same directory                 ##
-    ##########################################################################################
-    ##########################################################################################
 
+    # Preprocessing pipeline
     transform = transforms.Compose([
         transforms.Grayscale(num_output_channels=1),
         transforms.Resize(256),
@@ -106,13 +161,14 @@ def get_expression(img):
     ])
 
     face = detected_face(img)
-    if face==0:
+    if face == 0:
         face = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY))
 
     face = transform(face).unsqueeze(0).to(device)
-    # YOUR CODE HERE, return expression using your model
+
     with torch.no_grad():
         outputs = model(face)
         probs = F.softmax(outputs, dim=1)
         predicted_class = probs.argmax(dim=1).item()
+
     return predicted_class