def find_retinaface_detections(img, retinaface_res_path, im_path):
print("loading from {:s}".format(retinaface_res_path))
refrence = get_reference_facial_points(default_square=True)
frame = int(im_path.replace(".jpg", ""))
retinaface_res = np.loadtxt(retinaface_res_path)
info = retinaface_res[retinaface_res[:, 0] == frame]
if info.shape[0] > 0:
bboxes = info[:, 1:5]
landmarks = info[:, 5:]
faces = []
for i, landmark in enumerate(landmarks):
facial5points = [[landmark[j], landmark[j + 1]]
for j in range(0, 10, 2)]
warped_face = warp_and_crop_face(np.array(img),
facial5points,
refrence,
crop_size=(112, 112))
im_warped = Image.fromarray(warped_face)
os.makedirs(osp.join(image_root, "debug"), exist_ok=True)
im_warped.save(
osp.join(image_root, "debug",
"face_warped_{}_{}.jpg".format(frame, i)))
faces.append(Image.fromarray(warped_face))
else:
bboxes = []
faces = []
landmarks = []
print(bboxes)
return bboxes, faces, landmarks
def initialize_face_bank_retinaface(img, retinaface_res_path):
embeddings = []
names = ["Unknown"]
emb_counts = []
# get retinaface detections
refrence = get_reference_facial_points(default_square=True)
retinaface_res = np.loadtxt(retinaface_res_path)
info = retinaface_res[retinaface_res[:, 0] == 1]
if info.shape[0] > 0:
bboxes = info[:, 1:5]
landmarks = info[:, 5:]
# Warp faces
faces = []
for i, landmark in enumerate(landmarks):
facial5points = [[landmark[j], landmark[j + 1]]
for j in range(0, 10, 2)]
warped_face = warp_and_crop_face(np.array(img),
facial5points,
refrence,
crop_size=(112, 112))
faces.append(Image.fromarray(warped_face))
# Extracting face embeddings
for i, img in enumerate(faces):
emb = learner.model(
conf.test_transform(img).to(conf.device).unsqueeze(0))
embeddings.append(emb)
names.append("{:02d}".format(i))
emb_counts.append(1)
embeddings = torch.cat(embeddings)
return embeddings, names, emb_counts, bboxes
return None
def __init__(self):
self.pnet = PNet().to(device)
self.rnet = RNet().to(device)
self.onet = ONet().to(device)
self.pnet.eval()
self.rnet.eval()
self.onet.eval()
self.refrence = get_reference_facial_points(default_square=True)
def __init__(self, select_largest=False, keep_all=True):
self.pnet = PNet().to(device)
self.rnet = RNet().to(device)
self.onet = ONet().to(device)
self.pnet.eval()
self.rnet.eval()
self.onet.eval()
self.refrence = get_reference_facial_points(default_square=True)
def __init__(self, device='cpu'):
self.device = torch.device("cuda:0" if device == 'cuda' else "cpu")
self.pnet = PNet().to(device)
self.rnet = RNet().to(device)
self.onet = ONet().to(device)
self.pnet.eval()
self.rnet.eval()
self.onet.eval()
self.refrence = get_reference_facial_points(default_square=True)
def __init__(self, weight_path='mtcnn_pytorch/src/weights'):
self.device = torch.device(
"cuda" if torch.cuda.is_available() else "cpu")
self.pnet = PNet(weight_path).to(self.device)
self.rnet = RNet(weight_path).to(self.device)
self.onet = ONet(weight_path).to(self.device)
self.pnet.eval()
self.rnet.eval()
self.onet.eval()
self.refrence = get_reference_facial_points(default_square=True)
def __init__(self,
device=devi,
thresholds=[0.3, 0.6, 0.8],
nms_thresholds=[0.6, 0.6, 0.6]):
self.pnet = PNet().to(device)
self.rnet = RNet().to(device)
self.onet = ONet().to(device)
self.onet.eval()
self.rnet.eval()
self.onet.eval()
self.refrence = get_reference_facial_points(default_square=True)
self.device = device
self.thresholds = thresholds
self.nms_thresholds = nms_thresholds
def __init__(self, network="resnet50"):
cfg = None
if network == "mobile0.25":
self.cfg = cfg_mnet
elif network == "resnet50":
self.cfg = cfg_re50
torch.set_grad_enabled(False)
self.net = RetinaFace(cfg=self.cfg, phase='test')
if network == "mobile0.25":
self.net = self.load_model(
self.net, "retinaface_pytorch/mobilenet0.25_Final.pth", False)
else:
self.net = self.load_model(
self.net, "retinaface_pytorch/Resnet50_Final.pth", False)
self.net.eval()
cudnn.benchmark = True
self.device = torch.device("cuda")
self.net = self.net.to(self.device)
self.refrence = get_reference_facial_points(default_square=True)
def construct_face_bank(seq: str, retina_face_root: str, image_root: str, data_root: str, learner: face_learner, verbose: bool):
"""
loop through all images under the seq folder and count the number of distinct face embeddings
:param seq: sequence id
:param retina_face_root: root dir for retinaface detections. (frame, face_bbox (4), landmarks (10))
:param image_root: root dir for images
:param openface_root: root dir for openface results
:param learner: a face verification network
:return:
"""
seq_images = sorted(os.listdir(image_root))
seq_retina_face_result = np.loadtxt(retina_face_root, dtype=str)
embeddings = []
names = ["Unknown"]
emb_counts = []
# get default reference face points
reference = get_reference_facial_points(default_square=True)
for frame_idx, frame in enumerate(seq_images):
if verbose:
print("Processing {} {}".format(frame_idx, frame))
print("Names: {}".format(names))
print("emb_counts: {}".format(emb_counts))
# 1. load data
# 1.1. read image
img = Image.open(osp.join(image_root, frame))
# 1.2. get the retinaface detections
retinaface_result = seq_retina_face_result[seq_retina_face_result[:, 0] == frame]
# skip if no detection
if len(retinaface_result) == 0:
print("No retinaface")
continue
retinaface_bboxes = retinaface_result[:, 1:5].astype(np.int)
landmarks = retinaface_result[:, 5:].astype(np.float32)
retinaface_bboxes = retinaface_bboxes
# Warp faces: preparing input for learner
faces = []
for i, landmark in enumerate(landmarks):
facial5points = [[landmark[j], landmark[j + 1]] for j in range(0, 10, 2)]
warped_face = warp_and_crop_face(np.array(img), facial5points, reference, crop_size=(112, 112))
faces.append(Image.fromarray(warped_face))
# if the very first frame, we initialize face bank
if len(embeddings) == 0:
# Extracting face embeddings
for i, img in enumerate(faces):
with torch.no_grad():
emb = learner.model(conf.test_transform(img).to(conf.device).unsqueeze(0))
embeddings.append(emb)
names.append("{:02d}".format(i))
emb_counts.append(1)
embeddings = torch.cat(embeddings)
else: # otherwise we try to match, and update the face bank
with torch.no_grad():
print(len(faces))
results, score, source_embs = learner.infer_embeddings(conf, faces, embeddings, True)
# udpate facebank
for i, idx in enumerate(results):
if idx != -1: # we find a match, smooth the previous embeddings
embeddings[idx] = (emb_counts[idx] * embeddings[idx] + source_embs[i]) / (emb_counts[idx] + 1)
emb_counts[idx] += 1
else: # otherwise this is a new face
embeddings = torch.cat((embeddings, source_embs[i].unsqueeze(0)), dim=0)
emb_counts.append(1)
names.append("{:02d}".format(int(names[-1]) + 1))
results[i] = len(embeddings) - 1
np.savez(osp.join(data_root, "{}.npz".format(seq)),
embeddings=embeddings.cpu().numpy(), names=names, emb_counts=emb_counts)
return embeddings, names, emb_counts
