def get_emb(emb_state, image, box):
if emb_state is not None:
return (emb_state)
else:
cropped_face = extract_face(image, box)
cropped_face = prewhiten(cropped_face)
emb = resnet(cropped_face.unsqueeze(0))[0].detach() # .numpy().reshape(1, 512)
return (emb)
def pre_process(self, image: Image_Type):
"""
Redimensiona e preprocessa imagem para extracao de features
:param image: imagem para pre-processamento (cv2 ou Pil)
:return: img_tensor pre-processado para geracao de embeddings
"""
image = self.pil_to_cv2(image)
try:
image = cv2.resize(image, (input_image_size, input_image_size), interpolation=cv2.INTER_AREA)
except cv2.error:
return None
img_tensor = functional.to_tensor(np.float32(image)).to(self.device)
return prewhiten(img_tensor)
def run_training(num_images, batch_size, anonymizer, mtcnn, facenet, fc,
optimizer, loss_fn):
for j in range(0, num_images, batch_size):
with torch.no_grad():
latents = torch.randn(batch_size, 512).cuda()
generated_image = anonymizer(latents)
generated_image = (generated_image.clamp(-1, 1) + 1) / 2.0
generated_image = interpolate(generated_image, size=(160, 160))
aligned = []
for ogimg in generated_image:
img = ogimg.permute(1, 2, 0).cpu().numpy() * 255
img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
dets = detector(img.astype('uint8'), 1)
if len(dets) > 0:
cropped_image = fp.prewhiten(
crop_image(ogimg.permute(1, 2, 0),
dets[0])).permute(2, 0, 1)
cropped_image = interpolate(cropped_image, size=160)
aligned.append(cropped_image)
else:
aligned.append(interpolate(ogimg, size=160))
for i in range(len(aligned)):
target = torch.zeros(3, 160, 160)
w = aligned[i].size(1)
h = aligned[i].size(2)
target[:,
math.floor((160 - w) / 2):160 -
math.ceil((160 - w) / 2), :] = aligned[i]
aligned[i] = target
generated_image = torch.stack(aligned).cuda()
predicted_features = facenet(generated_image)
predicted_features = fc(predicted_features)
loss = loss_fn(
predicted_features,
latents) # we wanna make the latent features representative
loss.backward()
optimizer.step()
optimizer.zero_grad()
if j % 128 == 0:
print(f"Iteration: {j} \t\t Loss {loss.item()}")
def main():
num_eval = 50
batch_size = 32
fc_lr = 1e-2
mtcnn, facenet, fc = build_facenet_model()
anonymizer = get_style_gan()
loss_fn = torch.nn.MSELoss()
# Now freeze the full model and then train only the fc layer
for param in facenet.parameters(): # Freeze the full model
param.requires_grad = False
for param in fc.parameters(): # Unfreeze the fc layer
param.requires_grad = True
facenet.eval()
fc.train()
anonymizer.eval()
optimizer = optim.Adam(filter(lambda x: x.requires_grad, fc.parameters()),
lr=fc_lr)
run_training(1000, batch_size, anonymizer, mtcnn, facenet, fc, optimizer,
loss_fn)
######
# Run Eval
print(f"Evaluating On {num_eval} Images")
print("Saving checkpoint ...")
anonymizer.eval()
facenet.eval()
for i in range(0, num_eval, 5):
with torch.no_grad():
latents = torch.randn(batch_size, 512).cuda()
generated_image = anonymizer(latents)
generated_image = (generated_image.clamp(-1, 1) + 1) / 2.0
aligned = []
for ogimg in generated_image:
img = ogimg.permute(1, 2, 0).cpu().numpy() * 255
img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
dets = detector(img.astype('uint8'), 1)
if len(dets) > 0:
cropped_image = fp.prewhiten(
crop_image(ogimg.permute(1, 2, 0),
dets[0])).permute(2, 0, 1)
cropped_image = interpolate(cropped_image, size=160)
aligned.append(cropped_image)
else:
aligned.append(interpolate(ogimg, size=160))
for i in range(len(aligned)):
target = torch.zeros(3, 160, 160)
w = aligned[i].size(1)
h = aligned[i].size(2)
target[:,
math.floor((160 - w) / 2):160 -
math.ceil((160 - w) / 2), :] = aligned[i]
aligned[i] = target
preprocessed_image = torch.stack(aligned).cuda()
predicted_features = facenet(preprocessed_image)
predicted_features = fc(predicted_features)
resnet_based_images = anonymizer(predicted_features)
resnet_based_images = (resnet_based_images.clamp(-1, 1) + 1) / 2.0
generator_image = torchvision.utils.make_grid(generated_image,
nrow=4)
resnet_image = torchvision.utils.make_grid(resnet_based_images,
nrow=4)
torchvision.utils.save_image(generator_image,
"input_output/" + str(i) + "gen" +
".png",
nrow=10,
range=(-1, 1))
torchvision.utils.save_image(resnet_image,
"input_output/" + str(i) + "res" +
".png",
nrow=10,
range=(-1, 1))
print("Saved Images")
def _get_emb(image, box):
"""Return facial embeddings from given image inside the box."""
cropped_face = extract_face(image, box)
cropped_face = prewhiten(cropped_face)
return resnet(cropped_face.unsqueeze(0))[0].detach()