PyTorchとFaceNetを使えば1対1の顔認証が手軽に作れる

!pip install facenet_pytorch

from sklearn.datasets import fetch_lfw_pairs
from facenet_pytorch import InceptionResnetV1
from torchvision.transforms.functional import resize
import matplotlib.pyplot as plt
import numpy as np
import torch
import random
from tqdm.notebook import tqdm
from sklearn.metrics import roc_curve, roc_auc_score, precision_recall_curve

lfw_pairs_train = fetch_lfw_pairs(subset='train', color=True)
print(lfw_pairs_train.pairs.shape)
#(2200, 2, 62, 47, 3)

device = "cuda" if torch.cuda.is_available() else "cpu"
resnet = InceptionResnetV1(pretrained='vggface2').to(device).eval()

for img, label in zip(lfw_pairs_train.pairs, lfw_pairs_train.target):
  if random.random() < 0.99: continue
  img0 = img[0]
  img1 = img[1]
  fig = plt.figure(figsize=(4, 2))
  fig.add_subplot(1, 2, 1)
  plt.imshow(img0)
  fig.add_subplot(1, 2, 2)
  plt.imshow(img1)

  img0 = torch.tensor(img0).permute(2, 0, 1)
  img1 = torch.tensor(img1).permute(2, 0, 1)
  img0 = resize(img0, size = (160, 160))
  img1 = resize(img1, size = (160, 160))
  with torch.no_grad():
    vec0 = resnet(img0.unsqueeze(0).to(device))[0].detach().cpu()
    vec1 = resnet(img1.unsqueeze(0).to(device))[0].detach().cpu()
  score = torch.dot(vec0, vec1)

  print(f"Two image is {lfw_pairs_train.target_names[label]}, score = {score}")
  plt.show()

scores = []

with tqdm(total=len(lfw_pairs_train.pairs)) as pbar:
  for img, label in zip(lfw_pairs_train.pairs, lfw_pairs_train.target):
    img0 = img[0]
    img1 = img[1]

    img0 = torch.tensor(img0).permute(2, 0, 1)
    img1 = torch.tensor(img1).permute(2, 0, 1)
    img0 = resize(img0, size = (160, 160))
    img1 = resize(img1, size = (160, 160))

    with torch.no_grad():
      vec0 = resnet(img0.unsqueeze(0).to(device))[0].detach().cpu()
      vec1 = resnet(img1.unsqueeze(0).to(device))[0].detach().cpu()
    score = torch.dot(vec0, vec1)

    scores.append(score)
    pbar.update(1)

y_true = lfw_pairs_train.target
y_score = (np.array(scores)+1)/2 # -1~1を0~1に変換
fpr, tpr, threshold = roc_curve(y_true, y_score, pos_label=1)

plt.plot(fpr, tpr)
plt.xlabel('False positive rate')
plt.ylabel('True positive rate')
plt.title('ROC curve')
plt.show()  
print(f"AUC = {roc_auc_score(y_true, y_score):.3f}")

# https://qiita.com/kotai2003/items/3ee12b776ee205b7db42を参考に作成
precision, recall, threshold_from_pr = precision_recall_curve(y_true, y_score)
a = 2* precision * recall
b = precision + recall
f1 = np.divide(a,b,out=np.zeros_like(a), where=b!=0)
idx_opt = np.argmax(f1)
threshold_opt = threshold_from_pr[idx_opt]
print(f"Threshold = {threshold_opt:.3f}")

acc = sum((y_score > threshold_opt)&(y_true == 1)|(y_score <= threshold_opt)&(y_true == 0))/len(y_true)
print(f"Accuracy = {acc:.3f}")

from IPython.display import display, Javascript
from google.colab.output import eval_js
from base64 import b64decode

def take_photo(filename='photo.jpg', quality=0.8):
  js = Javascript('''
    async function takePhoto(quality) {
      const div = document.createElement('div');
      const capture = document.createElement('button');
      capture.textContent = 'Capture';
      div.appendChild(capture);

      const video = document.createElement('video');
      video.style.display = 'block';
      const stream = await navigator.mediaDevices.getUserMedia({video: true});

      document.body.appendChild(div);
      div.appendChild(video);
      video.srcObject = stream;
      await video.play();

      // Resize the output to fit the video element.
      google.colab.output.setIframeHeight(document.documentElement.scrollHeight, true);

      // Wait for Capture to be clicked.
      await new Promise((resolve) => capture.onclick = resolve);

      const canvas = document.createElement('canvas');
      canvas.width = video.videoWidth;
      canvas.height = video.videoHeight;
      canvas.getContext('2d').drawImage(video, 0, 0);
      stream.getVideoTracks()[0].stop();
      div.remove();
      return canvas.toDataURL('image/jpeg', quality);
    }
    ''')
  display(js)
  data = eval_js('takePhoto({})'.format(quality))
  binary = b64decode(data.split(',')[1])
  with open(filename, 'wb') as f:
    f.write(binary)
  return filename

from IPython.display import Image
try:
  filename = take_photo()
  print('Saved to {}'.format(filename))
  
  # Show the image which was just taken.
  display(Image(filename))
except Exception as err:
  # Errors will be thrown if the user does not have a webcam or if they do not
  # grant the page permission to access it.
  print(str(err))

import PIL.Image as Image

from facenet_pytorch import InceptionResnetV1, MTCNN
device = "cuda" if torch.cuda.is_available() else "cpu"
mtcnn = MTCNN(image_size=160, margin=10, device=device)
resnet = InceptionResnetV1(pretrained='vggface2').to(device).eval()

filename = 'photo.jpg'
img = Image.open(filename)
img_cropped = mtcnn(img, save_path=filename)
ref = resnet(img_cropped.unsqueeze(0).to(device))[0].detach().cpu()

from IPython.display import Image
try:
  filename = take_photo("check.jpg")
  print('Saved to {}'.format(filename))
  
  # Show the image which was just taken.
  display(Image(filename))
except Exception as err:
  # Errors will be thrown if the user does not have a webcam or if they do not
  # grant the page permission to access it.
  print(str(err))

import PIL.Image as Image
filename = 'check.jpg'
img = Image.open(filename)
img_cropped = mtcnn(img, save_path=filename)
vec = resnet(img_cropped.unsqueeze(0).to(device))[0].detach().cpu()
score = torch.dot(ref, vec)
print(score)