| --- |
| 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()) |
| |
| |
| ``` |
|
|
