clf model

app/Hackathon_setup/clf_model.joblib

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

app/Hackathon_setup/face_recognition.py

@@ -10,10 +10,9 @@ import io
 import os
 import joblib
 import pickle
+from joblib import load
 # Add more imports if required
 
-
-
 ###########################################################################################################################################
 #         Caution: Don't change any of the filenames, function names and definitions                                                      #
 #        Always use the current_path + file_name for refering any files, without it we cannot access files on the server                  # 
@@ -44,15 +43,8 @@ def detected_face(image):
         required_image = Image.fromarray(required_image)
     return required_image
 
-
-#1) Images captured from mobile is passed as parameter to the below function in the API call. It returns the similarity measure between given images.
-#2) The image is passed to the function in base64 encoding, Code for decoding the image is provided within the function.
-#3) Define an object to your siamese network here in the function and load the weight from the trained network, set it in evaluation mode.
-#4) Get the features for both the faces from the network and return the similarity measure, Euclidean,cosine etc can be it. But choose the Relevant measure.
-#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_similarity(img1, img2):
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     
     det_img1 = detected_face(img1)
     det_img2 = detected_face(img2)
@@ -73,11 +65,18 @@ def get_similarity(img1, img2):
     ##########################################################################################
     
     # YOUR CODE HERE, load the model
+    feature_net = SiameseNetwork()                                          
+    model = torch.load(current_path + '/siamese_model.t7', map_location=device)          ##
+    feature_net.load_state_dict(model['net_dict'])  
     
+    feature_net.eval()
     # YOUR CODE HERE, return similarity measure using your model
+    output1,output2 = feature_net(face1.cuda(),face2.cuda())
+    euclidean_distance = F.pairwise_distance(output1, output2)
     
-    return 0
-    
+    return euclidean_distance
+
+
 #1) Image captured from mobile is passed as parameter to this function in the API call, It returns the face class in the string form ex: "Person1"
 #2) The image is passed to the function in base64 encoding, Code to decode the image provided within the function
 #3) Define an object to your network here in the function and load the weight from the trained network, set it in evaluation mode
@@ -93,4 +92,16 @@ def get_face_class(img1):
     ##YOUR CODE HERE, return face class here
     ##Hint: you need a classifier finetuned for your classes, it takes o/p of siamese as i/p to it
     ##Better Hint: Siamese experiment is covered in one of the labs
-    return "YET TO BE CODED"
+    face1 = trnscm(det_img1).unsqueeze(0)
+
+    feature_net = SiameseNetwork()                                          
+    model = torch.load(current_path + '/siamese_model.t7', map_location=device)          ##
+    feature_net.load_state_dict(model['net_dict'])  
+    feature_net.eval()
+
+    output1,output2 = feature_net(face1.cuda(),face1.cuda())
+    output1 = output1.cpu().numpy()
+
+    clf_model = load('clf_model.joblib')
+    label = clf_model.predict(output1)
+    return label

app/Hackathon_setup/face_recognition_model.py

@@ -67,55 +67,7 @@ class SiameseNetwork(nn.Module):
 
 # YOUR CODE HERE for pytorch classifier
 
-def detected_face(image):
-    eye_haar = current_path + '/haarcascade_eye.xml'
-    face_haar = current_path + '/haarcascade_frontalface_default.xml'
-    face_cascade = cv2.CascadeClassifier(face_haar)
-    eye_cascade = cv2.CascadeClassifier(eye_haar)
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
-    face_areas=[]
-    images = []
-    required_image=0
-    for i, (x,y,w,h) in enumerate(faces):
-        face_cropped = gray[y:y+h, x:x+w]
-        face_areas.append(w*h)
-        images.append(face_cropped)
-        required_image = images[np.argmax(face_areas)]
-        required_image = Image.fromarray(required_image)
-    return required_image
-
-def get_similarity(img1, img2):
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    
-    det_img1 = detected_face(img1)
-    det_img2 = detected_face(img2)
-    if(det_img1 == 0 or det_img2 == 0):
-        det_img1 = Image.fromarray(cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY))
-        det_img2 = Image.fromarray(cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY))
-    face1 = trnscm(det_img1).unsqueeze(0)
-    face2 = trnscm(det_img2).unsqueeze(0)
-    ##########################################################################################
-    ##Example for loading a model using weight state dictionary:                            ##
-    ## feature_net = light_cnn() #Example Network                                           ##
-    ## model = torch.load(current_path + '/siamese_model.t7', map_location=device)          ##
-    ## feature_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                 ##
-    ##########################################################################################
-    ##########################################################################################
-    
-    # YOUR CODE HERE, load the model
-    feature_net = SiameseNetwork()                                          
-    model = torch.load(current_path + '/siamese_model.t7', map_location=device)          ##
-    feature_net.load_state_dict(model['net_dict'])  
-    
-    # YOUR CODE HERE, return similarity measure using your model
-    output1,output2 = feature_net(face1.cuda(),face2.cuda())
-    euclidean_distance = F.pairwise_distance(output1, output2)
-    
-    return euclidean_distance
+
 
 
 # Definition of classes as dictionary