Deeplearning_nhận diện khuôn mặt bằng mô hình học trước

TRƯỜNG ĐẠI HỌC BÁCH KHOA HÀ NỘI
TRƯỜNG ĐIỆN - ĐIỆN TỬ

BÀI TẬP LỚN MƠN HỌC SÂU
Nhận diện khn mặt với mơ hình được đào tạo trước

Ngành Kỹ thuật Điều khiển và Tự động hoá
Chuyên ngành Kỹ thuật đo và Tin học công nghiệp

1


HÀ NỘI, 11/2022
Mục lục
Mục lục .................................................................................................................. 2
Danh mục hình ảnh .............................................................................................. 3
CHƯƠNG 1. TỔNG QUAN ................................................................................ 4
1.1

Hệ thống nhận dạng khuôn mặt ................................................................. 4

1.2

Học chuyển tiếp.......................................................................................... 4

1.3

CNN VGG16 .............................................................................................. 4

CHƯƠNG 2. PHÂN TÍCH – THIẾT KẾ .......................................................... 5
2.1

2.2

Phân tích ..................................................................................................... 5
2.1.1

Dữ liệu ......................................................................................... 5

2.1.2

Kiến trúc ...................................................................................... 5

Thiết kế....................................................................................................... 6

CHƯƠNG 3. Kết quả ......................................................................................... 12
3.1

Kết quả thu được ...................................................................................... 12

2


Danh mục hình ảnh
Hình 1-1 Học chuyển tiếp ...................................................................................... 4
Hình 2-1: Tập hình ảnh đào tạo.............................................................................. 5
Hình 2-2 Tập hình ảnh thử nghiệm ........................................................................ 5
Hình 2-3: Kiến trúc mạng CNN VGG16 ............................................................... 6
Hình 2-4 Tập thư mục trên google drive ................................................................ 8
Hình 2-5 Kết quả thu được khi thực hiện bước 4 .................................................. 9
Hình 3-1 Kết quả thử nghiệm với ảnh từ thư mục datatest .................................. 12

3


CHƯƠNG 1. TỔNG QUAN
1.1 Hệ thống nhận dạng khuôn mặt
Hệ thống nhận dạng khn mặt là cơng nghệ có khả năng xác định hoặc
xác minh một người từ hình ảnh kỹ thuật số hoặc khung hình video từ nguồn
video. Nó thường được sử dụng làm kiểm soát truy cập trong các hệ thống bảo
mật và có thể được so sánh với hệ thống sinh trắc học như hệ thống quét võng
mạc mắt hoặc vân tay.
1.2 Học chuyển tiếp
Học chuyển tiếp (TL) là một cách tiếp cận trong học sâu và học máy. Nơi
kiến thức được chuyển giao từ mơ hình này sang mơ hình khác.
Sử dụng học chuyển tiếp, chúng ta có thể giải quyết một nhiệm vụ cụ thể
bằng cách sử dụng tồn bộ hoặc một phần của mơ hình đã được huấn luyện trước
về một nhiệm vụ khác.

Hình 1-1 Học chuyển tiếp

Học chuyển đổi có lợi ích là giảm thời gian đào tạo cho mơ hình mạng
thần kinh và dẫn đến lỗi tổng quát hóa thấp hơn.
Trong bài tập này, em đã sử dụng mơ hình VGG 16 để học chuyển giao.
1.3 CNN VGG16
CNN VGG16 là một mô hình mạng neuron tích chập được đề xuất bởi K.
Simonyan và A. Zisserman từ Đại học Oxford trong bài báo “Very Deep
Convolutional Networks for Large-Scale Image Recognition”.
Mơ hình đạt được 92,7% độ chính xác của bài kiểm tra top 5 trong
ImageNet, đây là bộ dữ liệu gồm hơn 14 triệu hình ảnh thuộc 1000 lớp. Đó là
một trong những mơ hình nổi tiếng được gửi tới ILSVRC-2014 . Nó tạo ra sự cải

tiến so với AlexNet bằng cách thay thế các bộ lọc có kích thước kernel lớn
(tương ứng là 11 và 5 trong lớp chập thứ nhất và thứ hai) bằng nhiều bộ lọc có
kích thước 3×3. VGG16 đã được đào tạo trong nhiều tuần và đang sử dụng GPU
NVIDIA Titan Black.
4


CHƯƠNG 2. PHÂN TÍCH – THIẾT KẾ
2.1 Phân tích
2.1.1 Dữ liệu
Tập dữ liệu của em dùng gồm khuôn mặt của 3 người để dự đoán. Tập dữ
liệu đào tạo bao gồm 3 thư mục mỗi thư mục chứa 15 ảnh (tổng 45 ảnh), tập dữ
liệu thử nghiệm gồm 3 thư mục mỗi thư mục gồm 5 ảnh (tổng 15 ảnh). Các hình
ảnh đều cắt sát khn mặt ,có nhiều kích thước khác nhau và đều ở định dạng
jpg.

Hình 2-1: Tập hình ảnh đào tạo

Hình 2-2 Tập hình ảnh thử nghiệm

2.1.2 Kiến trúc
Nó chứa 13 Lớp tích chập và 3 Lớp được kết nối đầy đủ.
- Đầu vào: VGG lấy hình ảnh RGB 224x224 pixel. Đối với cuộc thi ImageNet,
các tác giả đã cắt bỏ phần vá lỗi 224x224 ở giữa trong mỗi hình ảnh để giữ cho
kích thước hình ảnh đầu vào nhất qn.
- Các lớp tích chập: Có các bộ lọc tích chập 1x1 hoạt động như một phép biến
đổi tuyến tính của đầu vào, theo sau là một đơn vị ReLU. Bước tích chập được cố
định thành 1 pixel để độ phân giải không gian được giữ nguyên sau khi tích chập.
- Các lớp được kết nối đầy đủ : VGG có ba lớp được kết nối đầy đủ: hai lớp đầu
tiên có 4096 kênh mỗi lớp và lớp thứ ba có 1000 kênh, mỗi lớp 1 kênh.

- Các lớp ẩn : Tất cả các lớp ẩn của VGG đều sử dụng ReLU . VGG thường
5


khơng sử dụng Chuẩn hóa phản hồi cục bộ (LRN), vì LRN tăng mức tiêu thụ bộ
nhớ và thời gian đào tạo mà khơng tăng độ chính xác cụ thể.

Hình 2-3: Kiến trúc mạng CNN VGG16

Thử Thách Của VGG 16:
- Q trình đào tạo rất chậm (mơ hình VGG ban đầu được đào tạo trên GPU
Nvidia Titan trong 2-3 tuần).
- Kích thước imageNet được đào tạo VGG-16 là 528 MB. Vì vậy, nó chiếm khá
nhiều dung lượng ổ đĩa và băng thơng khiến nó hoạt động khơng hiệu quả.
Vì vậy để vượt qua những thách thức này, chúng ta sử dụng phương pháp học
chuyển giao.
2.2 Thiết kế
Em dùng google colab để thực hiện code
- Bước 1: Nhập mơ hình VGG 16 đã được đào tạo trước. Đóng băng các lớp
bằng cách sử dụng " layer.trainable = False ".
Bằng cách đóng băng các lớp , chúng ta có thể sửa các trọng số của mơ hình
được đào tạo trước và nó sẽ không được đào tạo lại.
from keras.applications import VGG16
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Conv2D, MaxPooling2D, ZeroPadding2D
from keras.layers.normalization import batch_normalization
from keras.models import Model
from keras.preprocessing.image import ImageDataGenerator
from keras.optimizers import RMSprop

from keras.callbacks import ModelCheckpoint
# VGG16 was designed to work on 224 x 224 pixel input images sizes
img_rows = 224
img_cols = 224
# Re-loads the VGG16 model without the top or FC layers
model = VGG16(weights = 'imagenet',

6


include_top = False,
input_shape = (img_rows, img_cols, 3))
# Here we freeze the last 4 layers
# Layers are set to trainable as True by default
for layer in model.layers:
layer.trainable = False
# Let's print our layers
for (i,layer) in enumerate(model.layers):
print(str(i) + " "+ layer.__class__.__name__, layer.trainable)

- Bước 2: Thêm các lớp mà chúng ta muốn thêm lên trên mơ hình.
def addTopModel(bottom_model, num_classes, D=256):
#"""creates the top or head of the model that will be placed on
top of the bottom layers"""
top_model = bottom_model.output
top_model = Flatten(name = "flatten")(top_model)
top_model = Dense(D, activation = "relu")(top_model)
top_model = Dropout(0.3)(top_model)
top_model = Dense(num_classes, activation = "softmax")(top_mode
l)

return top_model

Ở đây đã sử dụng hàm kích hoạt"softmax" để phân loại nhiều lớp.
Hàm kích hoạt là một phép biến đổi phi tuyến tính mà chúng ta thực hiện
trên đầu vào trước khi gửi nó đến lớp tiếp theo.
- Bước 3: Cung cấp số lớp (thư mục) có trong tập dữ liệu . Ở đây em có 3 thư
mục tương ứng với 3 lớp
model.input
model.layers
num_classes = 3
FC_Head = addTopModel(model, num_classes)
modelnew = Model(inputs=model.input, outputs=FC_Head)
print(modelnew.summary())

- Bước 4: Tăng cường hình ảnh, chúng ta Có thể dễ dàng tạo trình tạo hình ảnh
tăng cường bằng API ImageDataGenerator trong Keras. ImageDataGenerator
tạo các tập dữ liệu hình ảnh với tính năng tăng cường dữ liệu theo thời gian thực.
Tập dữ liệu hình ảnh đã được tải lên google drive với tên thư mục là
“20181797_NguyenQuangTrung”. Và thư mục này bao gồm hai thư mục con tức
là "datalearn" và "datatest" . Trong cả hai thư mục này, có 3 thư mục con chứa
hình ảnh khn mặt của 3 người khác nhau ("face1", "face2", "face3").

7


Hình 2-4 Tập thư mục trên google drive
train_data_dir = '/content/drive/MyDrive/20181797_NguyenQuangTrung/
datalearn'
validation_data_dir = '/content/drive/MyDrive/20181797_NguyenQuangT
rung/datatest'

train_datagen = ImageDataGenerator(
rescale=1./255,
rotation_range=20,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True,
fill_mode='nearest')
validation_datagen = ImageDataGenerator(rescale=1./255)
# Change the batchsize according to your system RAM
train_batchsize = 3
val_batchsize = 3
train_generator = train_datagen.flow_from_directory(
train_data_dir,
target_size=(img_rows, img_cols),
batch_size=train_batchsize,
class_mode='categorical')
validation_generator = validation_datagen.flow_from_directory(
validation_data_dir,
target_size=(img_rows, img_cols),
batch_size=val_batchsize,

8


class_mode='categorical',
shuffle=False)

Hình 2-5 Kết quả thu được khi thực hiện bước 4

- Bước 5: Nhập RMSprop và ModelCheckpoint. Huấn luyện mô hình bằng trọng

số của mơ hình VGG16 được huấn luyện trước và lưu nó dưới dạng "facerecog.h5" . Trong bài tập sử dụng thuật tốn tối ưu hóa RMSprop.
Thuật tốn tối ưu hóa là các thuật tốn hoặc phương pháp được sử dụng để
thay đổi các thuộc tính của mạng nơ-ron, chẳng hạn như trọng số và tốc độ học
tập nhằm giảm tổn thất.
ModelCheckpoint cho phép chúng ta xác định vị trí của điểm kiểm tra (kết
xuất trung gian các trọng số và tốc độ học tập hiện tại để nó có thể tiếp tục đào
tạo từ điểm này bất cứ khi nào muốn) trọng số của mơ hình, cách đặt tên tệp,…
Để đào tạo mơ hình, chúng ta sử dụng 50 kỷ nguyên. Một kỷ nguyên là
khi toàn bộ tập dữ liệu được truyền tới và đi qua mạng neuron một lần.
checkpoint = ModelCheckpoint("face_recog.h5",
monitor="val_loss",
mode="min",
save_best_only = True,
verbose=1)
# we put our call backs into a callback list
callbacks = [ checkpoint]
# Note we use a very small learning rate
modelnew.compile(loss = 'categorical_crossentropy',
optimizer = RMSprop(lr = 0.001),
metrics = ['accuracy'])
nb_train_samples = 299
nb_validation_samples = 60
epochs = 50
batch_size = 32
history = modelnew.fit_generator(
train_generator,
epochs = epochs,
steps_per_epoch = 50,
callbacks = callbacks,
validation_data = validation_generator,

validation_steps = nb_validation_samples // batch_size)
modelnew.save("face_recog.h5")

- Bước 6: Tải mơ hình đã lưu để thử nghiệm
classifier = load_model('face_recog.h5')

- Bước 7: Kiểm tra mơ hình, Lấy 10 hình ảnh ngẫu nhiên từ thư mục Test để thử
nghiệm.
9


from keras.models import load_model
import os
import cv2
import numpy as np
from os import listdir
from os.path import isfile, join
from google.colab.patches import cv2_imshow
classifier = load_model('face_recog.h5')
face_recog = {"[0]":"face1","[1]":"face2","[2]":"face3"}
face_recog_n = {"face1":"face1","face2":"face2","face3":"face3"}
def draw_test(name, pred, im):
face = face_recog[str(pred)]
BLACK = [0,0,0]
expanded_image = cv2.copyMakeBorder(im, 80, 0, 0, 100 ,cv2.BORD
ER_CONSTANT,value=BLACK)
cv2.putText(expanded_image,face, (20, 60) , cv2.FONT_HERSHEY_SI
MPLEX,1, (0,0,255), 2)
cv2_imshow(expanded_image)
def getRandomImage(path):

#"function loads a random images from a random folder in our te
st path "
folders = list(filter(lambda x: os.path.isdir(os.path.join(path
, x)), os.listdir(path)))
random_directory = np.random.randint(0,len(folders))
path_class = folders[random_directory]
print("Class - " + face_recog_n[str(path_class)])
file_path = path + path_class
file_names = [f for f in listdir(file_path) if isfile(join(file
_path, f))]
random_file_index = np.random.randint(0,len(file_names))
image_name = file_names[random_file_index]
return cv2.imread(file_path+"/"+image_name)
for i in range(0,5):
input_im = getRandomImage("/content/drive/MyDrive/20181797_Nguy
enQuangTrung/datatest/")
input_original = input_im.copy()
input_original = cv2.resize(input_original, None, fx=0.5, fy=0.
5, interpolation = cv2.INTER_LINEAR)
input_im = cv2.resize(input_im, (224, 224), interpolation = cv2
.INTER_LINEAR)
input_im = input_im / 255.
input_im = input_im.reshape(1,224,224,3)
# Get Prediction
res = np.argmax(classifier.predict(input_im, 1, verbose = 0), a
xis=1)

10

# Show image with predicted class
draw_test("Prediction", res, input_original)
cv2.waitKey(0)
cv2.destroyAllWindows()

11


CHƯƠNG 3. Kết quả
3.1 Kết quả thu được

Model có độ chính xác ảnh đạt 35,56% sau 50 kỉ ngun.

Hình 3-1 Kết quả thử nghiệm với ảnh từ thư mục datatest

Em thử nghiệm 5 ảnh và kết quả thu được là nhận diện đúng được ảnh 2
người là “putin” và “bill gate” cịn ảnh “châu tinh trì” bị nhận diện sai. Nguyên
nhân của sự sai lệnh này là do tập mẫu chưa đủ lớn và số kỷ ngun học cịn ít.

12