안녕하세요. 오랜만에 글을 작성합니다.
오늘은 예제만 돌려봤다면, 실제로 학습된 모델을 이용하여 얼굴을 찾도록 하겠습니다.
라즈베리파이로 얼굴인식을 찾아보면 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까지 간단하게 개발하기!
안녕하세요. 만약, 처음 이 글을 보신다면 아래 글을 먼저 읽어보시는 것을 추천드립니다. 1편 : Coral Board 대신 라즈베리파이를 사용하는 이유 : https://coding-yoon.tistory.com/85?category=866905 2편 :..
coding-yoon.tistory.com
우선, coral에서 Face detection tflite 파일을 먼저 받겠습니다.
Models | Coral
Download pre-compiled demo models that are compatible with the Edge TPU, or use the model source files to retrain the models for your own applications
coral.ai
위 파일 Edge TPU model을 눌러 파일을 받습니다.
네트워크는 경량 된 MobileNet V2와 객체인식 SSD(Single Shot MultiBox Detection)으로 학습된 모델입니다.
궁금하시면 두 논문을 참고하시면 될 것 같습니다.
MobileNetV2: Inverted Residuals and Linear Bottlenecks
In this paper we describe a new mobile architecture, MobileNetV2, that improves the state of the art performance of mobile models on multiple tasks and benchmarks as well as across a spectrum of different model sizes. We also describe efficient ways of app
arxiv.org
SSD: Single Shot MultiBox Detector
We present a method for detecting objects in images using a single deep neural network. Our approach, named SSD, discretizes the output space of bounding boxes into a set of default boxes over different aspect ratios and scales per feature map location. At
arxiv.org
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 역할만 하고 그 외 작업은 전혀 하지 않습니다.
딥러닝을 공부하신다면, 실제로 모델을 적용해보시는 것도 많은 공부를 하는데 도움이 될 것 같습니다.
