[Coral] 인공지능으로 얼굴 인식하기! (face detect) / Google Coral Edge TPU(USB Accelerator) / MobileNet V2 / tflite / Haarcascade 아님!

안녕하세요. 오랜만에 글을 작성합니다. 

 

오늘은 예제만 돌려봤다면, 실제로 학습된 모델을 이용하여 얼굴을 찾도록 하겠습니다. 

 

라즈베리파이로 얼굴인식을 찾아보면 Haarcascade 알고리즘이 많이 사용됩니다. 

 

하지만 오래전에 나온 알고리즘이고 좀 더 빠르고 더 정확하게 인공지능으로 얼굴 인식을 할 수 있습니다.

 

그리고 얼굴인식 자체를 Edge TPU가 처리하기 때문에 라즈베리파이의 CPU는 거의 사용되지 않습니다. 

 

그러기 때문에 라즈베리파이에서 부담 없이 강력한 효과를 보여줍니다. 

 

아래 글을 읽어보시고 가시는 것을 추천드립니다. 

 

coding-yoon.tistory.com/87?category=866905

coding-yoon.tistory.com/88?category=866905

coding-yoon.tistory.com/91?category=866905

[Coral] TensorFlow Lite : Tflite 모델 생성 & Edge TPU로 Inferece까지 간단하게 개발하기!

 

우선, coral에서 Face detection tflite 파일을 먼저 받겠습니다. 

coral.ai/models/

Models | Coral

위 파일 Edge TPU model을 눌러 파일을 받습니다.

ssd_mobilenet_v2_face_quant_postprocess_edgetpu.tflite

6.39MB

네트워크는 경량 된 MobileNet V2와 객체인식 SSD(Single Shot MultiBox Detection)으로 학습된 모델입니다. 

궁금하시면 두 논문을 참고하시면 될 것 같습니다.

 

arxiv.org/abs/1801.04381

MobileNetV2: Inverted Residuals and Linear Bottlenecks

arxiv.org/abs/1512.02325

SSD: Single Shot MultiBox Detector

 

detect.py (google git에서 구할 수 있음)

# Lint as: python3
# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Functions to work with detection models."""

import collections
import numpy as np

Object = collections.namedtuple('Object', ['id', 'score', 'bbox'])


class BBox(collections.namedtuple('BBox', ['xmin', 'ymin', 'xmax', 'ymax'])):
  """Bounding box.
  Represents a rectangle which sides are either vertical or horizontal, parallel
  to the x or y axis.
  """
  __slots__ = ()

  @property
  def width(self):
    """Returns bounding box width."""
    return self.xmax - self.xmin

  @property
  def height(self):
    """Returns bounding box height."""
    return self.ymax - self.ymin

  @property
  def area(self):
    """Returns bound box area."""
    return self.width * self.height

  @property
  def valid(self):
    """Returns whether bounding box is valid or not.
    Valid bounding box has xmin <= xmax and ymin <= ymax which is equivalent to
    width >= 0 and height >= 0.
    """
    return self.width >= 0 and self.height >= 0

  def scale(self, sx, sy):
    """Returns scaled bounding box."""
    return BBox(xmin=sx * self.xmin,
                ymin=sy * self.ymin,
                xmax=sx * self.xmax,
                ymax=sy * self.ymax)

  def translate(self, dx, dy):
    """Returns translated bounding box."""
    return BBox(xmin=dx + self.xmin,
                ymin=dy + self.ymin,
                xmax=dx + self.xmax,
                ymax=dy + self.ymax)

  def map(self, f):
    """Returns bounding box modified by applying f for each coordinate."""
    return BBox(xmin=f(self.xmin),
                ymin=f(self.ymin),
                xmax=f(self.xmax),
                ymax=f(self.ymax))

  @staticmethod
  def intersect(a, b):
    """Returns the intersection of two bounding boxes (may be invalid)."""
    return BBox(xmin=max(a.xmin, b.xmin),
                ymin=max(a.ymin, b.ymin),
                xmax=min(a.xmax, b.xmax),
                ymax=min(a.ymax, b.ymax))

  @staticmethod
  def union(a, b):
    """Returns the union of two bounding boxes (always valid)."""
    return BBox(xmin=min(a.xmin, b.xmin),
                ymin=min(a.ymin, b.ymin),
                xmax=max(a.xmax, b.xmax),
                ymax=max(a.ymax, b.ymax))

  @staticmethod
  def iou(a, b):
    """Returns intersection-over-union value."""
    intersection = BBox.intersect(a, b)
    if not intersection.valid:
      return 0.0
    area = intersection.area
    return area / (a.area + b.area - area)


def input_size(interpreter):
  """Returns input image size as (width, height) tuple."""
  _, height, width, _ = interpreter.get_input_details()[0]['shape']
  return width, height


def input_tensor(interpreter):
  """Returns input tensor view as numpy array of shape (height, width, 3)."""
  tensor_index = interpreter.get_input_details()[0]['index']
  return interpreter.tensor(tensor_index)()[0]


def set_input(interpreter, size, resize):
  """Copies a resized and properly zero-padded image to the input tensor.
  Args:
    interpreter: Interpreter object.
    size: original image size as (width, height) tuple.
    resize: a function that takes a (width, height) tuple, and returns an RGB
      image resized to those dimensions.
  Returns:
    Actual resize ratio, which should be passed to `get_output` function.
  """
  width, height = input_size(interpreter)
  w, h = size
  scale = min(width / w, height / h)
  w, h = int(w * scale), int(h * scale)
  tensor = input_tensor(interpreter)
  tensor.fill(0)  # padding
  _, _, channel = tensor.shape
  tensor[:h, :w] = np.reshape(resize((w, h)), (h, w, channel))
  return scale, scale


def output_tensor(interpreter, i):
  """Returns output tensor view."""
  tensor = interpreter.tensor(interpreter.get_output_details()[i]['index'])()
  return np.squeeze(tensor)


def get_output(interpreter, score_threshold, image_scale=(1.0, 1.0)):
  """Returns list of detected objects."""
  boxes = output_tensor(interpreter, 0)
  class_ids = output_tensor(interpreter, 1)
  scores = output_tensor(interpreter, 2)
  count = int(output_tensor(interpreter, 3))

  width, height = input_size(interpreter)
  image_scale_x, image_scale_y = image_scale
  sx, sy = width / image_scale_x, height / image_scale_y

  def make(i):
    ymin, xmin, ymax, xmax = boxes[i]

    return Object(
        id=int(class_ids[i]),
        score=float(scores[i]),
        bbox=BBox(xmin=xmin,
                  ymin=ymin,
                  xmax=xmax,
                  ymax=ymax).scale(sx, sy).map(int))

  return [make(i) for i in range(count) if scores[i] >= score_threshold]

 

main.py

import detect
import tflite_runtime.interpreter as tflite
import time

from PIL import Image
from PIL import ImageDraw
import cv2
import numpy as np
import time
import os



# .tflite interpreter
interpreter = tflite.Interpreter(
    os.path.join(os.getcwd(), "ssd_mobilenet_v2_face_quant_postprocess_edgetpu.tflite"),
    experimental_delegates=[tflite.load_delegate('libedgetpu.so.1')]
    )
interpreter.allocate_tensors()

# Draws the bounding box and label for each object.
def draw_objects(image, objs):
    for obj in objs:
        bbox = obj.bbox
        
        cv2.rectangle(image,(bbox.xmin, bbox.ymin), (bbox.xmax, bbox.ymax), (0, 255, 0),2)

        bbox_point_w = bbox.xmin + ((bbox.xmax-bbox.xmin) // 2)
        bbox_point_h = bbox.ymin + ((bbox.ymax-bbox.ymin) // 2) 
        
        cv2.circle(image, (bbox_point_w, bbox.ymax-bbox.ymin), 5, (0,0,255),-1)
        cv2.putText(image, text='%d%%' % (obj.score*100), org=(bbox.xmin, bbox.ymin), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=1.0, color=(0, 255, 0), thickness=1, lineType=cv2.LINE_AA)

        

        
def main():
    cap = cv2.VideoCapture(0)    

    while True:
        ret, image = cap.read()

	    # image reshape
        image = cv2.resize(image, dsize=(320, 320), interpolation=cv2.INTER_AREA)
	    # image BGR to RGB
        image = cv2.cvtColor(image,cv2.COLOR_BGR2RGB)

       	tensor = detect.input_tensor(interpreter=interpreter)[:, :] = image.copy() 
        tensor.fill(0)  # padding        
        interpreter.invoke()  # start
        
        objs = detect.get_output(interpreter, 0.5, (1.0, 1.0))
        
        if len(image):
            draw_objects(image, objs)

        image = cv2.cvtColor(image,cv2.COLOR_RGB2BGR)
        cv2.imshow('face detector', image)

        k = cv2.waitKey(30) & 0xff
        if k == 27: # press 'ESC' to quit # ESC exit
            break


if __name__ == '__main__':
    main()

 

 

위 코드를 돌려보시면, delay가 전혀 없이 높은 성능으로 얼굴 인식을 합니다. 

 

그렇기 때문에 얼굴 인식하고 다른 프로세스를 추가할 수 있습니다. 예를 들어 얼굴 인식하고 마스크를 검출하더라도 

전혀 delay가 없습니다.

 

그리고 얼굴인식을 하기 전,  전처리가 없습니다. 

 

딥러닝으로 만든 모델을 돌려보면, 실제로 적용되지 않는 경우가 많습니다. 

 

만들어진 모델을 성능을 높이기 위해 OpenCV의 전처리를 많이 사용하는 경우가 많습니다. 

 

하지만 이 같은 경우는 OpenCV는 사이즈를 줄이거나, 단순히 View 역할만 하고 그 외 작업은 전혀 하지 않습니다. 

 

 

마스크를 쓰지 않았을 때

마쓰크를 썻을 때

딥러닝을 공부하신다면, 실제로 모델을 적용해보시는 것도 많은 공부를 하는데 도움이 될 것 같습니다.