Update README.md

README.md

@@ -15,34 +15,39 @@ import torch
 # prompt: compare face embediggs
 
 ```
+import os
+import cv2
+from insightface.app import FaceAnalysis
+import torch
+
+import torch.nn.functional as F
+
+
+# prompt: compare face embediggs
+
+
 
 
 class FaceRec:
     def __init__(self):
-        self.foldername = '/home/emmanuel/Pictures/Webcam'
+        self.foldername = '/home/emmanuel-nsanga/Pictures/Webcam'
         self.files = []
+        self.files_attempt = []
         self.embeds = []
         self.diff = []
         self.ground_mathches = []
-        self.sampling = None
-        
-            
-
-    def folder(self, attempt=True, folder='/home/emmanuel/Pictures/Webcam'):
-        if attempt:
-            for file in os.listdir(folder):
-                self.files.append(file)
-
-            self.image_pair = list(zip(self.files[0:len(self.files)//2], self.files[len(self.files)//2:]))
-            print(self.image_pair)
+        self.sample_true = []
+        self.sample_attemt = []
+        self.folder_attempt='/home/emmanuel-nsanga/Pictures/Webcam/'
+        self.folder_ground = '/home/emmanuel-nsanga/Pictures/webcam/'
+        self.folder_camera = '/home/emmanuel-nsanga/Pictures/camera/'
+        self.files_ground = [self.folder_ground+files for files in os.listdir(self.folder_ground)]
+        self.files_attempt = [self.folder_attempt+files for files in os.listdir(self.folder_attempt)]
+        self.files_camera = [self.folder_camera+files for files in os.listdir(self.folder_camera)]
+        self.zip_ground = list(zip(self.files_ground, self.files_attempt))
+        self.zip_attempt = list(zip(self.files_attempt, self.files_camera))
 
 
-        else:
-            self.foldername = '/home/emmanuel/Pictures/webcam'
-            self.files = []
-            self.folder(attempt=True, folder=self.foldername)
-            
-
         
     
     def embeddings(self, image):
@@ -64,67 +69,71 @@ class FaceRec:
     
 
 
-    def closeness(self):
-        self.embeds = []
-        for faces in self.image_pair:
-            self.embeds.append(self.face_embed(self.foldername+'/'+faces[0], self.foldername+'/'+faces[1]))
-
-        return(0)
+    
     
 
-    def compare(self, attempt=True):
-        self.diff = []
-        for diffs in list(zip(self.embeds[0:len(self.embeds)//2], self.embeds[len(self.embeds)//2:])):
-            self.diff.append(torch.nn.functional.pairwise_distance(diffs[0], diffs[1]))
+    def expectation(self, sample_data):
+        mean, std = torch.mean(sample_data), torch.std(sample_data)
+        distribute = torch.distributions.Normal(mean, std)
+        return(distribute.sample(sample_shape=(10,)))
 
 
 
-    
-    def expectation(self):
-        mean, std = torch.mean(torch.Tensor(self.diff[0:])), torch.std(torch.Tensor(self.diff[0:]))
-        distribute = torch.distributions.Normal(mean, std)
-        self.sampling = distribute.sample(sample_shape=(10,))
 
+    def sim_distribution(self):
+        attempt_embeddings = self.zip_ground[0::]
+        ground_embeddings = self.zip_attempt[len(self.zip_ground)::]
+        
+        
 
+        w_r_t_g = self.zip_ground[0::]
+        w_r_t_c = self.zip_attempt
 
-    def model(self):       
-        self.closeness()
-        return(self.compare())
+        w_r_t_g = self.zip_ground[0::len(self.zip_ground)//2]
+        w_r_t_tr = self.zip_ground[len(self.zip_ground)//2::]
 
 
+        
+
+        ground_embeddings = [self.face_embed(attempting, attempt) for attempting, attempt in w_r_t_g]
+        attempt_ground = [self.face_embed(attempting, attempt) for attempting, attempt in w_r_t_tr]
+
+
+        ground_embeddings_g = [self.face_embed(attempting, attempt) for attempting, attempt in w_r_t_g]
+        attempt_ground_c = [self.face_embed(attempting, attempt) for attempting, attempt in w_r_t_c]
 
-    def verify(self):
-        self.folder()
-        self.model()
-        self.expectation()
-        self.folder(attempt=False)
-        self.model()
 
-        fails = 0
-        success = 0
-        max_itter = 10
-        while max_itter >= 0:
-            for samples in self.sampling:
-                if self.diff[0] <= samples:
-                    success = success+1
-                
-                else:
-                    fails = fails+1
                 
-            max_itter = max_itter-1
+        self.sampling_ground = self.expectation(torch.Tensor(ground_embeddings))
+        self.sampling_attempt_g = self.expectation(torch.Tensor(attempt_ground))
 
 
-        if fails > success:
-            return(False)
+        self.sampling_ground = self.expectation(torch.Tensor(ground_embeddings_g))
+        self.sampling_attempt_c = self.expectation(torch.Tensor(attempt_ground_c))
+
+        return(self.sampling_ground, self.sampling_attempt_g, self.sampling_ground, self.sampling_attempt_c)
+    
+
+    
+    def model(self):       
+        sim_distribution = self.sim_distribution()
+        xy = torch.mean(torch.Tensor([x-y for x, y in zip(sim_distribution[2], sim_distribution[3])]))
+        print(xy.item())
+
+        if xy.item() < 0.5:
+            print(True)        
+
 
         else:
-            return(True)
+            print(False)
 
 
-    
+       
 
 
 
 Recognition = FaceRec()
-print(Recognition.verify())
+print(Recognition.model())
+
+
 ```