---
license: bigscience-openrail-m
---

Face verification 


import os
import cv2
from insightface.app import FaceAnalysis
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-nsanga/Pictures/Webcam'
        self.files = []
        self.files_attempt = []
        self.embeds = []
        self.diff = []
        self.ground_mathches = []
        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))


        
    
    def embeddings(self, image):
        app = FaceAnalysis(name="buffalo_l", providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])
        app.prepare(ctx_id=0, det_size=(640, 640))
        image1 = cv2.imread(image)
        faces = app.get(image1)

        faceid_embeds = torch.from_numpy(faces[0].normed_embedding).unsqueeze(0)
        return(torch.Tensor(faceid_embeds))



    def face_embed(self, face, face1):
        # Load the two images and get their face embeddings.
        face_encodings = self.embeddings(face)
        face_encodings1 = self.embeddings(face1)
        return(torch.nn.functional.cosine_similarity(face_encodings, face_encodings1))
    


    
    

    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 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

        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]


                
        self.sampling_ground = self.expectation(torch.Tensor(ground_embeddings))
        self.sampling_attempt_g = self.expectation(torch.Tensor(attempt_ground))


        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:
            print(False)


       



Recognition = FaceRec()
print(Recognition.model())


```