BỘ GIÁO DỤC VÀ ĐÀO TẠO

TRƯỜNG ĐẠI HỌC GIAO THÔNG VẬN TẢI


BỘ MÔN ĐIỆN – ĐIỆN TỬ

BÁO CÁO CUỐI KỲ

Đề tài :
THIẾT KẾ MÔ HÌNH NHẬN DIỆN KHUÔN MẶT CỬA
TỰ ĐỘNG VỚI OPENCV PYCHARM & ARDUINO

GVHD: K.S Mai Vạn Hậu

Nhóm Sinh viên thực hiện:
Họ&Tên MSSV Lớp
Nguyễn Chí Thoan 6251030065 CQ.62.TĐHĐK
Lê Hoài Nam 6251030085 CQ.62.TĐHĐK
Nguyễn Ngọc Duy Khang 6251030086 CQ.62.TĐHĐK
Đỗ Tiến Đạt 6251030066 CQ.62.TĐHĐK
Văn Trọng Nghĩa 6251030062 CQ.62.TĐHĐK

Tp. Hồ Chí Minh, tháng 01 năm 2024

 BỘ GIÁO DỤC VÀ ĐÀO TẠO
TRƯỜNG ĐẠI HỌC GIAO THÔNG VẬN TẢI

BỘ MÔN ĐIỆN – ĐIỆN TỬ

BÁO CÁO CUỐI KỲ

Đề tài :
THIẾT KẾ MÔ HÌNH NHẬN DIỆN KHUÔN MẶT CỬA
TỰ ĐỘNG VỚI OPENCV PYCHARM & ARDUINO

GVHD: K.S Mai Vạn Hậu

Nhóm Sinh viên thực hiện:
Họ&Tên MSSV Lớp
Nguyễn Chí Thoan 6251030065 CQ.62.TĐHĐK
Lê Hoài Nam 6251030085 CQ.62.TĐHĐK
Nguyễn Ngọc Duy Khang 6251030086 CQ.62.TĐHĐK
Đỗ Tiến Đạt 6251030066 CQ.62.TĐHĐK
Văn Trọng Nghĩa 6251030062 CQ.62.TĐHĐK

Tp. Hồ Chí Minh, tháng 01 năm 2024

 BẢNG NHẬN XÉT CỦA GIÁO VIÊN HƯỚNG DẪN
STT Nội dung thực hiện Nhận xét

Nhận xét tổng quát:

..................................................................................................................................................................
..................................................................................................................................................................
..................................................................................................................................................................
..................................................................................................................................................................
..................................................................................................................................................................
..................................................................................................................................................................
 MỤC LỤC
LỜI MỞ ĐẦU........................................................................................................................................i
DANH MỤC KÝ HIỆU, THUẬT NGỮ VIẾT TẮT.........................................................................ii
DANH MỤC HÌNH ẢNH..................................................................................................................iii
CHƯƠNG 1: GIỚI THIỆU VỀ ĐỀ TÀI............................................................................................1
1.1. Tính cấp thiết của đề tài...........................................................................................................1
1.1.1. Lý do chọn đề tài..................................................................................................................1
1.1.2. Ý nghĩa khoa học.................................................................................................................1
1.1.3. Tính cấp thiết.......................................................................................................................1
1.1.4. Tính khả thi..........................................................................................................................1
1.2. Mục tiêu nghiên cứu của đề tài................................................................................................1
1.3. Đối tượng và phạm vi nghiên cứu............................................................................................1
1.4. Phương pháp nghiên cứu..........................................................................................................1
1.5. Kết cấu của đề tài......................................................................................................................1
CHƯƠNG 2: CƠ SỞ LÝ THUYẾT...................................................................................................2
2.1. Mô hình Classifier Cascade......................................................................................................2
2.1.1. Đặc trưng Haar Like (mô tả đối tượng trong hình ảnh).......................................................2
2.1.2. Thuật toán AdaBoost (huấn luyện các bộ phân loại)...........................................................2
2.1.3. Mô hình phân tầng Cascade (loại bỏ các vùng không quan trọng)......................................3
2.1.4. Tổng quát.............................................................................................................................3
2.2. Thuật toán LBPH......................................................................................................................4
2.3. Thư viện OpenCV.....................................................................................................................6
2.4. Thư viện sqlite3.........................................................................................................................7
2.5. Thư viện PIL..............................................................................................................................7
2.6. Thư viên pySerial......................................................................................................................8
2.7. Thư viện pyttsx3........................................................................................................................8
2.8. Thư viên Time...........................................................................................................................8
2.9. Tổng quát...................................................................................................................................8
CHƯƠNG 3: XÂY DỰNG CHƯƠNG TRÌNH.................................................................................9
3.1. Xây dựng lưu đồ thuật toán.....................................................................................................9
3.1.1. Lưu đồ thuật toán lấy dữ liệu khuôn mặt.............................................................................9
3.1.2. Lưu đồ thuật toán huấn luyện dữ liệu..................................................................................9
3.1.3. Lưu đồ thuật toán nhận diện khuôn mặt.............................................................................10
3.2. Xây dựng chương trình..........................................................................................................11
3.2.1. Lấy dữ liệu khuôn mặt từ wedcam.....................................................................................11
3.2.2. Huấn luyện dữ liệu đưa vào và trích chọn các đặc trưng...................................................14
3.2.3. Xác thực khuôn mặt và điều khiển động cơ.......................................................................15
3.3. Giao diện giao tiếp người dùng..............................................................................................19
 3.3.1. Giới thiệu thư viện Tkinter................................................................................................19
3.3.2. Thành phần của giao diện..................................................................................................19
3.3.3. Kết quả của giao diện.........................................................................................................21
3.4. Xây dựng mô hình......................................................................................................................21
3.4.1. Giới thiệu thiết bị...............................................................................................................22
3.4.2. Cấu thành mô hình.............................................................................................................22
3.4.3. Hoàn thành mô hình...........................................................................................................23
CHƯƠNG 4: SO SÁNH VỚI KIẾN THỨC ĐÃ HỌC...................................................................25
CHƯƠNG 5: KẾT LUẬN.................................................................................................................27
TÀI LIỆU THAM KHẢO.................................................................................................................28
PHỤ LỤC............................................................................................................................................29
 LỜI MỞ ĐẦU
Đầu tiên, chúng em xin gửi lời cảm ơn chân thành đến tập thể quý Thầy Cô
Trường Phân Hiệu Đại học Giao Thông Vận Tải Tp. HCM và quý Thầy Cô
khoa Điện – Điện tử đã giúp cho em có những kiến thức cơ bản làm nên tảng đề
thực hiện đề tài này.

Đặc biệt, em xin gửi lời cảm ơn và lòng biết ơn sâu sắc nhất tới Thầy Mai Văn
Hậu (Giảng viên môn xử lí ảnh trong công nghiệp và giao thông). Thầy đã trực
tiếp hướng dẫn tận tình, sửa chữa và đóng góp nhiều ý kiến quý báu giúp em
hoàn thành tốt bài báo cáo môn học của mình.

Trong thời gian một học kỳ đề thực hiện đề tài, em đã vận dụng những kiến thức
nên tảng đã tích lũy đồng thời kết hợp với việc học hỏi và nghiên cứu những
kiến thức mới. Từ đó, em vận dụng tối đa những gì đã thu thập được để hoàn
thành một báo cáo bài tập lớn tốt nhất. Tuy nhiên, trong quá trình thực hiện, em
không tránh khỏi được những thiếu sót. Chính vì vậy, em rất mong nhận được
những sự góp ý từ phía các Thầy Cô nhằm hoàn thiện những kiến thức mà em
đã học tập và là hành trang để em thực hiện tiếp các đề tài khác trong tương lai.

Em xin chân thành cảm ơn các quý Thầy Cô!

DANH MỤC KÝ HIỆU, THUẬT NGỮ VIẾT TẮT

LBPH Local Binary Patterns Histograms

XML Extensible Markup Language

OpenCV Open Source Computer Vision

API Application Programming Interface

SVM Support Vector Machines

TTS Text-to-Speech

CV Computer Vision

Multiple-Instance Learning with

MILL
Label Propagation

GUI Graphical User Interface

Speech Application Programming

SAPI5
Interface 5

DANH MỤC HÌNH ẢNH

Hình 2.1 Các đặc trưng Haar-Like cơ bản............................................................2

Hình 2.2 Phân loại các đặc trưng Haar-Like.........................................................2

Hình 2.3 Kết hợp các bộ phân loại yếu thành bộ phân loại...................................3

Hình 2.4 Mô hình phân tầng Cascade...................................................................3

Hình 2.5 Phát hiện khuôn mặt người và xác định vùng khuôn mặt....................4

Hình 2.6 Chia hình ảnh thành ô nhỏ và xác định mẫu nhị phân.........................5

Hình 2.7 Ảnh đa cấp xám (trái), LBP (giữa) và biểu đồ (phải) của ảnh LBP....5

Hình 2.8 Quá trình thuật toán LBPH trích xuất các đặc trưng của hình ảnh......6

Hình 2.9 Cấu trúc cơ bản của OpenCV................................................................7

Hình 3.1 Lưu đồ thuật toán lấy dữ liệu................................................................9

Hình 3.2 Lưu đồ thuật toán huấn luyện dữ liệu.................................................11

Hình 3.3 Lưu đồ thuật toán nhận diện khuôn mặt.............................................11

Hình 3.4 Sơ đồ quy trình Nhận dạng khuôn mặt...............................................11

Hình 3.5 Phần thiết lập và cập nhật dữ liệu vào cơ sở dữ liệu SQLite.............12

Hình 3.6 Sử dụng CascadeClassifier và truy cập wedcam................................12

Hình 3.7 Wedcam thu thập dữ liệu hình ảnh, xử lý và lưu vào thư mục..........13

Hình 3.8 Quá trình thu thập................................................................................14

Hình 3.9 Trong “os” đã có các bộ huấn luyện có sẵn........................................15

Hình 3.10 Định nghĩa một hàm phát giọng nói.................................................16

Hình 3.11 Phát tín hiệu âm thanh khi thực hiện nhận diện khuôn mặt.............18

Hình 3.12 Giao diện giao tiếp người dùng được hiển thị..................................21

Hình 3.13 Hình ảnh Arduino Uno......................................................................22

Hình 3.14 Hình ảnh Mạch cầu H........................................................................22

Hình 3.15 Động cơ DC giảm tốc........................................................................22

Hình 3.16 Hình ảnh về cấu tạo mô hình cửa cuốn.............................................23

Hình 3.17 Sơ đồ đấu nối tổng thể mô hình........................................................24

Hình 3.18 Bên ngoài, bên trong mô hình...........................................................24

 CHƯƠNG 1: GIỚI THIỆU VỀ ĐỀ TÀI
1.1. Tính cấp thiết của đề tài
1.1.1. Lý do chọn đề tài
Tính quan trọng của nhận diện khuôn mặt trong nhiều lĩnh vực, như an
ninh, giao thông, nhận dạng cá nhân và giao diện người máy. Độ phức tạp
tương đối thấp của thuật toán LBPH, giúp đơn giản hóa việc nghiên cứu
và triển khai trong các ứng dụng có tài nguyên hạn chế.
1.1.2. Ý nghĩa khoa học
Đóng góp vào lĩnh vực nhận diện khuôn mặt và hiểu rõ hơn về phương
pháp truyền thống như LBPH so với các phương pháp hiện đại khác.
Phân tích đặc điểm khuôn mặt và tương quan giữa chúng, đóng góp vào
việc hiểu và mô phỏng quá trình nhận diện khuôn mặt.
1.1.3. Tính cấp thiết
Ứng dụng thực tế trong nhiều lĩnh vực, giúp giải quyết các vấn đề về an
ninh, quản lý dữ liệu cá nhân và nhận diện cá nhân. Tính chính xác tương
đối của thuật toán LBPH trong điều kiện đơn giản và ánh sáng tốt.
1.1.4. Tính khả thi
Sẵn có trong thư viện OpenCV, giúp giảm thời gian và công sức triển
khai.
Có khả năng điều chỉnh và tối ưu hóa theo yêu cầu của ứng dụng cụ thể
thực tế chẳng hạn như việc đóng mở cửa, tăng cường tính bảo mật.
1.2.Mục tiêu nghiên cứu của đề tài
Với đề tài "Nhận diện khuôn mặt mở cửa" mục đích của chúng tôi là xây
dựng hệ thống nhận diện khuôn mặt và mở cửa tự động, tích hợp OpenCV,
PyCharm và Arduino, với hiệu suất và độ chính xác cao.
1.3. Đối tượng và phạm vi nghiên cứu
- Đối tượng nghiên cứu: Lập trình Python OpenCV, Arduino Uno.
- Phạm vi nghiên cứu: Thuật toán LBPH, các thư viện trong Pycharm:
opencv, numpy, os, serial, time, pyttsx3.
1.4. Phương pháp nghiên cứu
Để thiết kế mô hình nhận dạng khuôn mặt mở khóa cửa dựa trên việc lấy dữ
liệu từ wedcam, sau đó xử lý dữ liệu huấn luyện bằng thuật toán LBPH và
cuối cùng là nhận diện khuôn mặt xuất tín hiệu ra Arduino để lệnh mở hoặc
đóng cửa được thực thi được áp dụng các phương pháp nghiên cứu chính
như phương pháp phân tích, tham khảo tài liệu, phương pháp tổng hợp tài
liệu lý
1.5. Kết cấu của đề tài
Chương 1. GIỚI THIỆU VỀ ĐỀ TÀI
Chương 2. CƠ SỞ LÝ THUYẾT
Chương 3. XÂY DỰNG CHƯƠNG TRÌNH
Chương 4. SO SÁNH VỚI KIẾN THỨC ĐÃ HỌC
 Chương 5. KẾT LUẬN

CHƯƠNG 2: CƠ SỞ LÝ THUYẾT
2.1. Mô hình Classifier Cascade
2.1.1. Đặc trưng Haar Like (mô tả đối tượng trong hình ảnh)
Đặc trưng Haar Like được tạo thành bằng việc kết hợp các hình chữ nhật
đen, trắng với nhau theo một trật tự, một kích thước nào đó.

Hình 2.1 Các đặc trưng Haar-Like cơ bản

Đây là một phương pháp đặc trưng được sử dụng để mô tả các đối tượng
trong hình ảnh, chẳng hạn như khuôn mặt. Nó dựa trên việc tính toán tổng
giá trị pixel của các vùng quan tâm trong hình ảnh. Các đặc trưng Haar-like
bao gồm đặc trưng góc, đặc trưng cạnh và đặc trưng trung tâm, và chúng
được tính toán trên các vùng khác nhau của hình ảnh.
Đặc trưng Haar-like có ba loại chính: góc, cạnh và trung tâm.
- Corner feature: Sử dụng hai ô vuông
lớn và hai ô vuông nhỏ để tính tổng
giá trị pixel. Đặc trưng này giúp
nhận diện góc và biên cạnh trong
hình ảnh.
- Edge feature: Cũng sử dụng hai ô
vuông lớn và hai ô vuông nhỏ,
nhưng tính tổng giá trị pixel khác
nhau. Đặc trưng này giúp nhận diện
các biên cạnh trong hình ảnh.
- Center feature: Bao gồm một ô
vuông lớn và hai ô vuông nhỏ để tính
tổng giá trị pixel. Đặc trưng này giúp Hình 2.2 Phân loại các đặc trưng Haar-
Like
nhận diện sự khác biệt giữa các vùng
trong hình ảnh.
Các đặc trưng này được tính toán trên các vùng khác nhau của hình ảnh và
được sử dụng để xác định các đối tượng quan tâm trong mô hình Classifier
Cascade
2.1.2. Thuật toán AdaBoost (huấn luyện các bộ phân loại)
Đây là một thuật toán học máy được sử dụng để huấn luyện một loạt các bộ
phân loại yếu thành một bộ phân loại mạnh. Trong mô hình Classifier
Cascade, AdaBoost được sử dụng để huấn luyện các bộ phân loại dựa trên
các đặc trưng Haar-like. AdaBoost tập trung vào việc đào tạo các bộ phân
loại yếu trên các mẫu huấn luyện khó khăn hơn để tạo ra một bộ phân loại
tổng thể hiệu quả hơn.

Hình 2.3 Kết hợp các bộ phân loại yếu thành bộ phân loại

2.1.3. Mô hình phân tầng Cascade (loại bỏ các vùng không quan trọng)
Đây là một cấu trúc mô hình được sử dụng để nhanh chóng loại bỏ các vùng
không quan trọng trong hình ảnh không chứa đối tượng quan tâm, như khuôn
mặt. Mô hình phân tầng Cascade bao gồm nhiều giai đoạn (stage), mỗi giai
đoạn chứa một số bộ phân loại. Trong quá trình nhận diện, hình ảnh sẽ được
chạy qua các giai đoạn tuần tự. Các bộ phân loại trong mỗi giai đoạn sẽ kiểm
tra các đặc trưng Haar-like và quyết định xem vùng đó có chứa đối tượng hay
không. Nếu một vùng không vượt qua một giai đoạn nào đó, nó sẽ bị loại bỏ,
giúp tăng tốc quá trình nhận diện.

Hình 2.4 Mô hình phân tầng Cascade

Kết hợp ba thành phần này giúp mô hình đạt được hiệu suất cao và tốc độ xử
lý nhanh trong việc nhận diện đối tượng trong hình ảnh hoặc video.
2.1.4. Tổng quát
Mô hình Cascade Classifier chứa giải thuật Haar Cascade là một phần trong
quá trình xây dựng mô hình Cascade Classifier, và mô hình Cascade
Classifier sử dụng Haar Cascade để nhận diện các đặc trưng và phân loại đối
tượng trong hình ảnh.
Trong thư viện OpenCV, các tệp XML phổ biến nhất liên quan đến Haar
Cascade là các tệp được sử dụng để nhận diện khuôn mặt. Dưới đây là một số
tệp XML khuôn mặt phổ biến:
"haarcascade_frontalface_default.xml": Đây là một tệp XML phổ biến nhất
và được sử dụng rộng rãi để nhận diện khuôn mặt phía trước.
"haarcascade_frontalface_alt.xml": Đây là một phiên bản khác của tệp XML
nhận diện khuôn mặt phía trước, có khả năng nhận diện các khuôn mặt có
 góc nhìn và chi tiết khác nhau.
"haarcascade_profileface.xml": Đây là một tệp XML được sử dụng để nhận
diện khuôn mặt phía bên.
Trong hệ thống nhận diện khuôn mặt được xây dựng trong đề tài, có sử dụng
giải thuật Haar Cascade để xác định lấy dữ liệu khuôn mặt và tiến hành nhận
diện khuôn mặt. Cụ thể là tệp XML "haarcascade_frontalface_default.xml"
2.2. Thuật toán LBPH
-Thuật toán LBPH là một thuật toán phổ biến trong lĩnh vực nhận diện khuôn
mặt và phân loại hình ảnh. Thuật toán này được sử dụng để trích xuất đặc
trưng từ hình ảnh khuôn mặt và xây dựng histogram để biểu diễn các đặc trưng
đó.
-Mô hình nhận diện khuôn mặt bằng thuật toán LBPH trong thư viện OpenCV:
 Chuẩn bị dữ liệu:
Thuật toán LBPH yêu cầu một tập dữ liệu được chuẩn bị trước đó để huấn
luyện mô hình. Quá trình này bao gồm việc thu thập hình ảnh khuôn mặt của
các người dùng và xác định nhãn tương ứng cho từng hình ảnh. Nhãn có thể là
tên của người dùng hoặc một số định danh duy nhất cho mỗi người.

Hình 2.5 Phát hiện khuôn mặt người và xác định vùng khuôn mặt

 Xác định vùng khuôn mặt:

Trước khi áp dụng thuật toán LBPH, chúng ta cần xác định vùng khuôn mặt
trong hình ảnh. Điều này có thể được thực hiện bằng cách sử dụng các thuật
toán phát hiện khuôn mặt như Haar cascades. Thuật toán này giúp xác định vị
trí và đường viền của khuôn mặt trong hình ảnh.
 Chuyển đổi ảnh thành ảnh xám:
Hình ảnh khuôn mặt được chuyển đổi thành ảnh xám để đơn giản hóa quá
trình xử lý. Điều này cũng giúp giảm số lượng thông tin và làm tăng tốc độ xử
lý.
 Chia hình ảnh thành các ô nhỏ:
Sau khi xác định được vùng khuôn mặt và chuyển đổi ảnh thành ảnh xám, hình
ảnh khuôn mặt được chia thành các ô nhỏ có kích thước cố định, chẳng hạn
3x3 pixel. Mỗi ô nhỏ đại diện cho một vùng nhỏ trên khuôn mặt.
 Hình 2.6 Chia hình ảnh thành ô nhỏ và xác định mẫu nhị phân

 Xác định mẫu nhị phân:

Với mỗi ô nhỏ, thuật toán LBPH xác định một mẫu nhị phân bằng cách so
sánh giá trị điểm ảnh tại trung tâm ô với các điểm ảnh xung quanh. Thuật toán
xem xét 8 điểm xung quanh trung tâm ô nhỏ và so sánh giá trị của chúng với
giá trị của điểm ảnh trung tâm. Nếu giá trị điểm ảnh xung quanh lớn hơn hoặc
bằng giá trị điểm ảnh trung tâm, nó được đánh dấu là 1, ngược lại, nó được
đánh dấu là 0. Quá trình này tạo ra một chuỗi nhị phân có độ dài 3 để biểu diễn
mẫu nhị phân của ô nhỏ.

Hình 2.7 Ảnh đa cấp xám (trái), ảnh LBP (giữa) và biểu đồ (phải) của ảnh LBP

 Huấn luyện mô hình:

Histograms của các hình ảnh khuôn mặt trong tập dữ liệu huấn luyện được sử
dụng để huấn luyện mô hình nhận diện khuôn mặt. Mô hình này lưu trữ trạng
thái của histogram và nhãn tương ứng ứng với mỗi khuôn mặt.
 Nhận dạng khuôn mặt:
Khi có histogram cho hình ảnh khuôn mặt đang được nhận diện, thuật toán
LBPH so sánh histogram này với các histogram của các hình ảnh đã được lưu
trữ trong cơ sở dữ liệu. Các phép so sánh thường sử dụng các độ đo như
khoảng cách Euclidean. Khi tìm thấy histogram tương tự nhất trong cơ sở dữ
liệu, thuật toán LBPH sẽ trả về nhãn tương ứng với khuôn mặt được nhận diện.
Đó là quá trình tổng quan của thuật toán LBPH trong việc nhận diện khuôn
mặt bằng thư viện OpenCV. Nó sử dụng mẫu nhị phân và histogram để biểu
diễn đặc trưng của khuôn mặt và so sánh chúng với các khuôn mặt đã được lưu
trữ để nhận dạng. Thuật toán này có thể được sử dụng để xây dựng một hệ
thống nhận diện khuôn mặt đơn giản và hiệu quả.
 Hình 2.8 Quá trình thuật toán LBPH trích xuất các đặc trưng của hình ảnh

2.3. Thư viện OpenCV

OpenCV là một thư viện mã nguồn mở phát triển chủ yếu cho việc xử lý hình
ảnh và thị giác máy tính. Nó cung cấp một loạt các chức năng và công cụ để
xử lý, phân tích và nhận dạng hình ảnh. OpenCV được viết bằng C++ và có
giao diện lập trình ứng dụng (API) cho nhiều ngôn ngữ, bao gồm Python.
Dưới đây là một số chức năng chính của OpenCV:
 Xử lý hình ảnh cơ bản: OpenCV cung cấp các chức năng để đọc, ghi, và
xử lý hình ảnh cơ bản như chuyển đổi màu sắc, điều chỉnh độ tương
phản, cắt và kết hợp hình ảnh, và thay đổi kích thước.
 Phân tích và nhận dạng đối tượng: OpenCV cung cấp các thuật toán và
công cụ để phát hiện, nhận dạng và theo dõi đối tượng trong hình ảnh.
Điều này bao gồm việc sử dụng các kỹ thuật như phát hiện khuôn mặt,
phát hiện vật thể, phát hiện biên, và phát hiện đường viền.
 Xử lý video: OpenCV hỗ trợ xử lý video và dữ liệu video realtime. Nó
cho phép bạn đọc video từ các nguồn đa phương tiện, trích xuất các
khung hình, xử lý và phân tích video frame-by-frame, và ghi lại video.
 Xử lý thị giác máy tính: OpenCV cung cấp các công cụ để xử lý và phân
tích dữ liệu hình ảnh từ các cảm biến như máy ảnh và lidar. Điều này
bao gồm việc calibrate và rectify camera, phát hiện và phân tích dữ liệu
từ cảm biến, và xử lý hình ảnh 3D.
 Machine learning: OpenCV tích hợp tính năng học máy, cho phép bạn
huấn luyện và triển khai các mô hình học máy trên dữ liệu hình ảnh. Các
thuật toán như Support Vector Machines (SVM), Random Forests, và
Neural Networks được tích hợp sẵn trong OpenCV.
 OpenCV đã trở thành một trong những thư viện quan trọng nhất trong lĩnh
vực xử lý hình ảnh và thị giác máy tính. Nó được sử dụng rộng rãi trong các
ứng dụng như nhận dạng khuôn mặt, phân loại đối tượng, xử lý ảnh y tế, xe
tự lái, và nhiều lĩnh vực khác liên quan đến xử lý hình ảnh và thị giác máy

Hình 2.9 Cấu trúc cơ bản của OpenCV

tính.
2.4. Thư viện sqlite3
Thư viện sqlite3 trong Python cung cấp các
công cụ và chức năng để tương tác với cơ
sở dữ liệu SQLite từ trong chương trình
Python. SQLite là một hệ quản trị cơ sở dữ
liệu nhỏ, nhúng và không cần máy chủ,
được sử dụng rộng rãi trong các ứng dụng
nhỏ và đơn giản.
2.5. Thư viện PIL
Thư viện PIL là một thư viện phổ biến trong Python cho việc xử lý và thao tác
với hình ảnh. Nó cung cấp các chức năng để đọc, ghi, chỉnh sửa và chuyển đổi
hình ảnh trong nhiều định dạng khác nhau.
Dưới đây là một số chức năng mà thư viện PIL có thể đáp ứng được
- Đọc và ghi hình ảnh:
Để đọc một hình ảnh từ file, có thể sử dụng phương thức open() của đối
tượng Image. PIL hỗ trợ nhiều định dạng hình ảnh như JPEG, PNG, GIF,
BMP, và nhiều hơn nữa.
Ví dụ: image = Image.open("image.jpg")
Để lưu một hình ảnh đã chỉnh sửa vào file, có thể sử dụng phương thức
save() của đối tượng Image.
Ví dụ: image.save("output.jpg")
- Xử lý hình ảnh:
PIL cung cấp nhiều phương thức để xử lý hình ảnh như thay đổi kích
thước, cắt, xoay, lật, áp dụng bộ lọc, chỉnh sửa màu sắc và độ tương phản,
và nhiều hơn nữa.
 Ví dụ, để thay đổi kích thước hình ảnh, có thể sử dụng phương thức
resize(): resized_image = image.resize((width, height))
- Chuyển đổi định dạng hình ảnh:
Có thể chuyển đổi định dạng hình ảnh từ một định dạng sang định dạng
khác bằng cách sử dụng phương thức convert().
Ví dụ, converted_image = image.convert("PNG")
- Tạo hình ảnh mới:
Có thể tạo hình ảnh mới bằng cách sử dụng hàm new() và chỉ định các
thông số như chế độ màu sắc, kích thước và màu nền.
Ví dụ: new_image = Image.new("RGB", (width, height), (255, 255, 255))
2.6. Thư viên pySerial
Module pySerial là một thư viện Python mạnh mẽ và phổ biến được sử dụng
để tạo và quản lý kết nối với các thiết bị ngoại vi qua giao thức Serial (UART).
Nó cung cấp các lớp và phương thức để giao tiếp với các thiết bị như Arduino,
Raspberry Pi, máy in, cảm biến, và nhiều thiết bị ngoại vi khác.
- Khởi tạo đối tượng Serial:
serial.Serial(port, baudrate, timeout): Tạo đối tượng Serial với các tham số:
port: Tên cổng Serial (ví dụ: 'COM1')
baudrate: Tốc độ baudrate (ví dụ: 9600, 115200).
- Giao tiếp với thiết bị:
serial.write(data): Gửi dữ liệu đến thiết bị qua cổng Serial. data có thể là chuỗi
ký tự hoặc mảng byte.
serial.read(size): Đọc size byte dữ liệu từ cổng Serial và trả về dưới dạng một
chuỗi byte.
2.7. Thư viện pyttsx3
Module pyttsx3 là một thư viện Python
dùng để chuyển đổi văn bản thành giọng
nói (Text-to-Speech). Nó cung cấp một
giao diện đơn giản để phát âm thanh từ văn
bản bằng cách sử dụng các công nghệ
Text-to-Speech khác nhau như Microsoft
Speech Platform hoặc eSpeak.
2.8. Thư viên Time
Thư viện time được import trong đoạn mã trên có chức năng điều khiển thời
gian trong Python. Cụ thể, nó được sử dụng để tạo ra các đợt trễ giữa các hành
động trong quá trình nhận dạng khuôn mặt.
Chức năng được áp dụng của các hàm từ time trong đề tài này:
time.sleep(seconds): Hàm này tạm dừng thực thi chương trình trong một số
giây được chỉ định bởi tham số seconds. Trong đoạn mã, nó được sử dụng để
tạo ra đợt trễ 2 giây và 4 giây trước khi gửi dữ liệu qua kết nối Serial.
2.9. Tổng quát
Hệ thống nhận diện khuôn mặt mở khóa cửa sử dụng các cơ sở lý thuyết và
thư viện: Cascade Classifier, LBPH, pyserial, pyttsx3, time, OpenCV, sqlite3
và PIL để thực hiện các chức năng sau:
-Cascade Classifier: Sử dụng để phát hiện khuôn mặt trong ảnh hoặc video.
LBPH (Local Binary Patterns Histograms): Sử dụng để nhận dạng khuôn mặt
dựa trên các đặc trưng của khuôn mặt.
-pyserial: Sử dụng để giao tiếp với cổng Serial để điều khiển cơ chế mở khóa
cửa.
-pyttsx3: Sử dụng để chuyển đổi văn bản thành giọng nói để thông báo âm
thanh khi khuôn mặt được nhận dạng hoặc không nhận dạng.
-time: Sử dụng để tạo ra các đợt trễ giữa các hành động trong quá trình nhận
dạng.
-OpenCV: Sử dụng để xử lý ảnh và video, bao gồm việc nhận dạng khuôn mặt
và vẽ đường viền xung quanh khuôn mặt.
-sqlite3: Sử dụng để lưu trữ thông tin về khuôn mặt đã được huấn luyện và
thực hiện truy vấn cơ sở dữ liệu.
Tổng thể, hệ thống kết hợp các cơ sở lý thuyết và thư viện này để phát hiện,
nhận dạng và xử lý khuôn mặt, giao tiếp với cơ chế mở khóa cửa và cung cấp
thông báo âm thanh.
CHƯƠNG 3: XÂY DỰNG CHƯƠNG TRÌNH
3.1. Xây dựng lưu đồ thuật toán
3.1.1. Lưu đồ thuật toán lấy dữ liệu khuôn mặt

Giải thích:
- Bắt đầu: khởi động pycharm,
chạy code
- Input: nhập các id và tên đầu
vào
- Khởi động WEDCAM: để
lấy dữ liệu khuôn mặt
- Phát hiện khuôn mặt:
+Nếu có khuôn mặt xuất
hiện trong wedcam thì hệ
thống sẽ lấy dữ liệu khuôn
mặt đó bằng cách chụp 100
ảnh vùng quan tâm của
khuôn mặt và sau đó lưu vào
file data_face để tiến hành
huấn luyện dữ liệu.
+Nếu không thấy phát hiện
khuôn mặt thì wedcam vẫn
xuất hiện trên cửa sổ màn
hình chính.
Hình 3.1 Lưu đồ lấy dữ liệu khuôn mặt
3.1.2. Lưu đồ thuật toán huấn luyện dữ liệu
 Giải thích:
- Tiếp theo đó, ta chạy file
training dữ liệu lên
- Tiến hành lấy dữ liệu hình
ảnh từ file data_face
- Có hình ảnh trong file:
+Nếu có hình ảnh trong file
thì hệ thống dung thuật toán
LBPH xử lý hính ảnh rồi lưu
file train vào trainer.xml
+Nếu không có hình ảnh
trong file data_face thì hệ
thống sẽ báo lỗi và kết thúc
quá trình train.

Hình 3.2 Lưu đồ thuật toán huấn luyện khuôn mặt

3.1.3. Lưu đồ thuật toán nhận diện khuôn mặt
Giải thích:
- Chuẩn bị mô hình nhận
diện khuôn mặt bằng
cách khai báo các thư
viện cần thiết cũng như
giá trị cần thiết
- Tạo 1 vòng lặp quét
khuôn mặt bằng wedcam
+Nếu có khuôn mặt
trong khung hình thì thực
hiện chuyển đổi ảnh xám
và dự đoán kết quả nhận
diện nếu đạt đủ độ tin
cậy thì sẽ ra tín hiệu
UNLOCK ngược lại thì
LOCK
+Nếu không có khuôn
mặt trong khung hình
wedcam thì sẽ xuất tín
hiệu FACE NOT
FOUND
+Sau đó kết thúc vòng
lặp.

Hình 3.3 Lưu đồ thuật toán nhận diện khuôn mặt

3.2. Xây dựng chương trình
Mô hình nhận dạng được chia thành 3 bước chính, bao gồm:
Bước 1: Lấy dữ liệu khuôn mặt từ wed cam.
Bước 2: Huấn luyện dữ liệu đưa vào và trích chọn các đặc trưng.
Bước 3: Xác thực khuôn mặt và điều khiển động cơ

Hình 3.4 Sơ đồ quy trình Nhận dạng khuôn mặt

3.2.1. Lấy dữ liệu khuôn mặt từ wedcam

Phần đầu tiên của mô hình Nhận diện khuôn mặt này là Lấy dữ liệu khuôn
mặt từ wed cam. Sau đây là mô tả cách làm việc của nó theo các đoạn
code như sau:
 Hình 3.5 Phần thiết lập và cập nhật dữ liệu vào cơ sở dữ liệu SQLite

Dòng conn = sqlite3.connect("FaceBase.db") đang thiết lập kết nối tới cơ sở

dữ liệu SQLite có tên "FaceBase.db."
sqlite3: Đây là mô-đun thư viện chuẩn Python cung cấp giao diện để tương
tác với cơ sở dữ liệu SQLite.
connect("FaceBase.db"): Hàm này là một phần của mô-đun sqlite3 và nó tạo
kết nối đến tệp cơ sở dữ liệu SQLite.

Vòng lặp for dùng để kiểm tra trong thư mục đã có tồn tại id nào trùng lặp
không.
- isRecordExist = 1: Bên trong vòng lặp, dòng này đặt biến isRecordExist
thành 1, cho biết rằng đã tìm thấy dữ liệu id này trong cơ sở dữ liệu.
- if isRecordExist == 1: Điều kiện này kiểm tra xem isRecordExist so sánh
với 1 có bằng hay không, nghĩa là id có tồn tại trong cơ sở dữ liệu hay
không.
Ba dòng cuối được sử dụng để thực thi câu truy vấn, lưu thay đổi và đóng kết
nối với cơ sở dữ liệu SQLite.

Hình 3.6 Sử dụng CascadeClassifier và truy cập wedcam

Sử dụng tệp haarcascade_frontalface_default.xml của Mô hình Classifier

Cascade. Đối tượng này được sử dụng để phát hiện khuôn mặt trong ảnh.
Tiếp theo, dòng cap = cv2.VideoCapture(0) khởi tạo một đối tượng
VideoCapture từ thiết bị webcam có chỉ số 0 (thiết bị mặc định). Đối tượng
này được sử dụng để truy cập và lấy các khung hình từ webcam để xử lý.

Dòng mã id = input('Enter User ID: ') và name = input('Enter Your Name: ')
được sử dụng để yêu cầu người dùng nhập ID và tên thông qua giao diện dòng
lệnh. Ở phần giao diện thì không cần sử dụng tới vì ở phần giao diện việc
nhập dữ liệu có thể được thực hiện thông qua các thành phần giao diện như
hộp văn bản hoặc biểu mẫu sẽ được thay bằng:

Hình 3.7 Wedcam thu thập dữ liệu hình ảnh, xử lý và lưu vào thư mục

while True: Điều này tạo ra một vòng lặp vô hạn, cho biết đoạn mã sau sẽ
được thực thi liên tục cho đến khi chương trình bị gián đoạn theo cách thủ
công.

Dòng lệnh này sẽ đọc hình ảnh từ wedcam. Và sau đó sẽ chuyển đổi hình anh
đã chụp sang ảnh xám. Thang độ xám thường được sử dụng để nhận diện
khuôn mặt nhằm đơn giản hóa quá trình xử lý.

Sử dụng face_cascade được xác định trước đó để phát hiện các khuôn mặt
trong khung thang độ xám. Các tham số 1.3 và 5 lần lượt là hệ số tỷ lệ và lân
cận tối thiểu được sử dụng bởi thuật toán nhận diện khuôn mặt.

- for (x, y, w, h) in faces:: Lặp lại danh sách

các khuôn mặt được phát hiện, trong đó
(x, y) là tọa độ của góc trên cùng bên trái
của hình chữ nhật khuôn mặt và (w, h) là
chiều rộng và chiều cao của hình chữ
nhật.

Hình 3.8 Quá trình thu thập

 - Số lượng hình ảnh khuôn mặt được thu thập là 100 hình được lưu vào thư
mục data_face.
- cv2.imwrite('data_face/face.' + str(id) + '.' + str(sample_number) + '.jpg',
img[y:y+h, x:x+w]): Ghi khuôn mặt được phát hiện dưới dạng một tệp
hình ảnh riêng biệt với định dạng JPG.
- cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2): Vẽ một hình chữ
nhật màu xanh lục xung quanh khuôn mặt được phát hiện trong khung
màu gốc img.
Câu lệnh if được sử dụng để xác định nếu hình
ảnh khuôn mặt lấy đủ 100 hình. Nếu đúng thì
wedcam sẽ tự động đóng lại.
3.2.2. Huấn luyện dữ liệu đưa vào và trích chọn các đặc trưng
a) Giới thiệu
Mô tả về mục tiêu: Phát triển một mô hình nhận diện khuôn mặt sử dụng
thuật toán LBPH của OpenCV.
Import các thư viện cần thiết:
 os: Để làm việc với hệ thống tệp và thư mục.
 cv2 (OpenCV): Thư viện xử lý ảnh và video.
 numpy: Để làm việc với các mảng.
b) Khởi tạo Mô hình nhận diện
Sử dụng thư viện OpenCV để tạo một đối tượng nhận diện khuôn mặt sử
dụng thuật toán LBPH.

c) Chuẩn bị dữ liệu đào tạo

Xác định đường dẫn đến thư mục chứa ảnh để đào tạo.

d) Huấn luyện mô hình nhận dạng khuôn mặt

Đoạn mã trên thực hiện các công việc sau:
- Định nghĩa getImagesWithID để
trích xuất ảnh và ID của khuôn
mặt từ thư mục dữ liệu.
- Gọi hàm getImagesWithID(path)
để lấy danh sách các ID và ảnh
khuôn mặt từ thư mục dữ liệu: Ids,
faces = getImagesWithID(path).
 - Huấn luyện mô hình nhận dạng khuôn mặt bằng cách truyền các ảnh
khuôn mặt và danh sách ID vào: recognizer.train(faces, Ids).
- Kiểm tra và tạo thư mục 'trainer' nếu nó chưa tồn tại.
- Lưu mô hình đã huấn luyện vào file 'face-trainner.yml' trong thư mục
'trainer': recognizer.save("trainer/face-trainner.yml").
- Đóng tất cả cửa sổ hiển thị.
Đoạn mã này huấn luyện mô hình nhận dạng khuôn mặt bằng cách trích
xuất ảnh và ID từ thư mục dữ liệu, sau đó sử dụng các ảnh và ID đó để
huấn luyện mô hình. Mô hình được lưu trữ trong file 'face-trainner.yml'
trong thư mục 'trainer'.
Sau đó 2 dòng code này getImagesWithID(path)" và
"recognizer.train(faces, Ids)" sẽ thực hiện chức năng lấy danh sách các ảnh
khuôn mặt và ID tương ứng từ thư mục dữ liệu, sau đó sử dụng chúng để
huấn luyện mô hình nhận dạng khuôn mặt.
e) Tạo file lưu thông tin huấn luyện
Đoạn mã trên kiểm tra xem thư mục có tên "trainer" đã tồn tại hay chưa bằng
cách sử dụng hàm os.path.exists('trainer'). Nếu thư mục không tồn tại, hàm
os.makedirs('trainer') sẽ được gọi để tạo thư mục mới có tên "trainer".
Sau đó, mô hình đã huấn luyện được
lưu vào file "face-trainner.yml" trong
thư mục "trainer" bằng cách sử dụng
Hình 3.9 Trong “os” đã có các bộ huấn
phương thức save() của đối tượng luyện có sẵn
"recognizer".
File YAML ("face-trainner.yml") được tạo và lưu trữ trong thư mục "trainer"
chứa thông tin đã huấn luyện của mô hình nhận dạng khuôn mặt. File này
chứa các thông số và trọng số của mô hình, được sử dụng để tái sử dụng mô
hình trong các ứng dụng khác hoặc để tiếp tục huấn luyện mô hình trong
tương lai mà không cần phải thực hiện quá trình huấn luyện từ đầu.
Mô tả về việc hoàn thành quá trình đào tạo mô hình nhận diện khuôn mặt.
Mô hình đã được lưu trữ và sẵn sàng để sử dụng cho phần nhận diện.
3.2.3. Xác thực khuôn mặt và điều khiển động cơ
a) Import các thư viện và module cần thiết
- Dòng import cv2 từ thư viện OpenCV: để làm việc với xử lý ảnh.
- Dòng import numpy: để làm việc với mảng và ma trận số học.
- Dòng import serial: để kết nối và giao tiếp với các thiết bị qua cổng serial.
- Dòng import time: để làm việc với các hàm và tính toán thời gian.
- Dòng import pyttsx3: để tương tác với hệ thống Text-to-Speech (TTS) và
phát ra giọng nói từ văn bản.
b) Cấu hình phát giọng nói bằng văn bản
Hàm speak(audio) được định nghĩa để phát ra giọng nói từ văn bản sử dụng
engine text-to-speech. Dưới đây là mục đích của các dòng mã trong hàm:
 Hình 3.10 Định nghĩa một hàm phát giọng nói

- engine = pyttsx3.init('sapi5'): Khởi tạo engine text-to-speech sử dụng giao

diện SAPI5 trên Windows.
- voices = engine.getProperty('voices'): Lấy danh sách các giọng nói được hỗ
trợ bởi engine.
- engine.setProperty("voice", voices[0].id): Thiết lập giọng nói mặc định cho
engine.
- engine.setProperty("rate", 140): Thiết lập tốc độ phát giọng nói mặc định.
- engine.setProperty("volume", 1000): Thiết lập âm lượng giọng nói mặc
định.
c) Nhận dạng khuôn mặt từ video camera và hiển thị kết quả lên màn hình
Một vòng lặp vô hạn (while True) được sử dụng để liên tục đọc khung hình
từ camera, phát hiện khuôn mặt và thực hiện nhận dạng

Dòng ret, frame = cap.read() đọc khung hình từ video camera.

Dòng image, face = face_detector(frame) sử dụng hàm face_detector để phát
hiện khuôn mặt trong khung hình và gán kết quả vào biến image (khung hình
gốc) và face (khuôn mặt được phát hiện).

Trong khối try của đoạn mã này, sau khi chuyển đổi khuôn mặt sang ảnh
grayscale (face = cv2.cvtColor(face, cv2.COLOR_BGR2GRAY)), mô hình
(model) được sử dụng để dự đoán kết quả nhận dạng khuôn mặt.
- Dòng result = model.predict(face) dùng để dự đoán nhãn của khuôn
mặt bằng cách sử dụng mô hình model đã được huấn luyện trước đó.
 - Nếu giá trị result[1] (khoảng cách từ khuôn mặt đến các mẫu huấn
luyện) nhỏ hơn 500, độ tin cậy (confidence) được tính toán dựa trên
khoảng cách và hiển thị lên khung hình.
- Nếu độ tin cậy (confidence) lớn hơn hoặc bằng 80, hiển thị thông báo
"UNLOCKED" trên khung hình. Ngược lại, hiển thị thông báo
"LOCKED".
Sau đó, khung hình được hiển thị lên màn hình bằng hàm cv2.imshow('face',
image)
Trong trường hợp ngoại lệ (exception) xảy ra, khi không tìm thấy khuôn mặt,
một thông báo "FACE NOT FOUND" sẽ được hiển thị lên khung hình.

Trong khối except của đoạn mã, nếu xảy ra ngoại lệ (exception) trong quá
trình tìm kiếm khuôn mặt, có thể do không tìm thấy khuôn mặt, một thông
báo "FACE NOT FOUND" sẽ được hiển thị lên khung hình.
Sau đó, một số điều kiện kiểm tra được thực hiện để quyết định liệu vòng lặp
nên thoát hay tiếp tục chạy:
Dòng if cv2.waitKey(1) == 13 or x == 10 or c == 30 or d == 20: kiểm tra nếu
nhấn phím Enter (mã ASCII 13) hoặc đã nhận dạng thành công 10 khuôn mặt
(x == 10) hoặc bị từ chối 30 khuôn mặt (c == 30) hoặc gặp 20 lỗi không tìm
thấy khuôn mặt (d == 20), thì vòng lặp sẽ được thoát (break) và chương trình
kết thúc.
Phần nhận diện khuôn mặt đang sử dụng webcam để đọc khuôn mặt và sau đó
so sánh với dữ liệu trong phần huấn luyện của mô hình. Dựa trên kết quả nhận
dạng, các thông báo "UNLOCKED" và "LOCKED" sẽ được hiển thị lên khung
hình.
Cụ thể, có các quy tắc như sau:
Nếu có 10 khuôn mặt được nhận dạng thành công (giá trị của biến x là 10), thì
thông báo "UNLOCKED" sẽ được hiển thị lên khung hình.
Nếu có 30 khuôn mặt bị từ chối (giá trị của biến c là 30), thì thông báo
"LOCKED" sẽ được hiển thị lên khung hình.
Nếu không tìm thấy khuôn mặt trong 20 ảnh (giá trị của biến d là 20), thì thông
báo "LOCKED" sẽ được hiển thị lên khung hình.
Điều này đồng nghĩa với việc khi có đủ số lượng khuôn mặt nhận dạng thành
công, thông báo "UNLOCKED" sẽ được hiển thị. Ngược lại, khi có đủ số lượng
khuôn mặt bị từ chối hoặc không tìm thấy khuôn mặt, thông báo "LOCKED" sẽ
được hiển thị.
Trong đoạn mã trên, có một số điều kiện và hành động được thực hiện:
- Nếu số lượng khuôn mặt nhận dạng
thành công (x) lớn hơn hoặc bằng 5
- Biến m được gán giá trị là 1 (m = 1).
- Kết nối với cổng COM6 thông qua giao
diện Serial (ard = serial.Serial('com6',
9600)).
- Chờ 2 giây (time.sleep(2)).
- Chuẩn bị dữ liệu gửi đi, trong trường
hợp này là gửi ký tự 'a' (var = 'a' và c =
var.encode()).
- Gọi hàm speak("Face recognition
complete. Welcome back") để phát âm Hình 3.11 Phát tín hiệu âm thanh
thanh thông báo "Face recognition khi thực hiện nhận diện khuôn mặt
complete. Welcome back".
- Gửi dữ liệu đến Arduino thông qua cổng Serial (`ard.write(c)`).
- Chờ 4 giây (time.sleep(4)).
- Nếu có 30 khuôn mặt bị từ chối (c == 30):
- Gọi hàm speak("Face is not matching. Please try again") để phát âm thanh
thông báo "Face is not matching. Please try again".
- Nếu không tìm thấy khuôn mặt trong 20 ảnh (d == 20):
- Gọi hàm speak("Face is not found. Please try again") để phát âm thanh
thông báo "Face is not found. Please try again".
Sau đó, nếu m có giá trị là 1 (m == 1), một số hành động được thực hiện:
- Khởi tạo đối tượng cap để thao tác với webcam (`cap =
cv2.VideoCapture(0)`).
- Giải phóng webcam (cap.release()).
- Đóng các cửa sổ hiển thị (cv2.destroyAllWindows()).
Từ đoạn mã trên có thể hiểu rằng, nếu có ít nhất 5 khuôn mặt được nhận dạng
thành công, thông báo "Face recognition complete. Welcome back" sẽ được phát
âm thanh và gửi tín hiệu tới Arduino thông qua cổng Serial. Trong các trường
hợp khác, thông báo tương ứng sẽ được phát âm thanh. Sau đó, nếu `m` có giá
trị 1, webcam sẽ được khởi tạo và sau đó đóng lại.
3.3. Giao diện giao tiếp người dùng
Giao diện thiết kế để giao tiếp với người dùng một cách dễ dàng trọng việc đưa
dữ liệu khuôn mặt, huấn luyện nó và sử dụng dữ liệu đã được huấn luyện để
nhận diện đúng người để thực hiện chức năng cần thiết. Ở phần giao diện này,
được tạo ra và áp dụng đầy đủ các tính năng của 3 phần trước. Được thiết kế
theo thiết kế bằng sử dụng thư viện đồ họa tkinter trong Python. Thư viện
tkinter cung cấp các công cụ và phương thức để tạo giao diện đồ họa người dùng
trong các ứng dụng máy tính.
3.3.1. Giớ i thiệu thư viện Tkinter
Tkinter là một thư viện giao diện người dùng (GUI) phổ biến trong
Python. Nó dễ sử dụng và đa nền tảng, cho phép bạn tạo các cửa sổ, nút,
nhãn và các thành phần giao diện khác trong ứng dụng desktop. Tkinter
cung cấp các công cụ để tương tác với người dùng và xử lý sự kiện. Nó là
một lựa chọn phổ biến cho việc phát triển ứng dụng GUI đơn giản trong
Python.
3.3.2. Thà nh phầ n củ a giao diện
- Cửa sổ giao diện:
 tk.Tk() tạo một đối tượng cửa
sổ giao diện chính và gán cho
biến win.
 win.title("FACE ID") đặt tiêu
đề của cửa sổ là "FACE ID".
 win.geometry('600x400') thiết
lập kích thước của cửa sổ là 600
pixel chiều rộng và 400 pixel
chiều cao.
- Chèn background cho giao diện:

- Các lớp được chèn vào giao diện:

Các nhãn này được cấu hình với các thuộc tính như văn bản, màu nền,
màu văn bản và vị trí trên giao diện.
Đoạn mã trên tạo ra các nhãn như sau:
Nhãn label có văn bản "HỆ THỐNG NHẬN DIỆN KHUÔN MẶT", màu
nền trắng, màu văn bản đen và kiểu chữ Arial với kích thước 13 và đậm.
Nó được định vị tại cột 1, hàng 0 trên giao diện, với khoảng cách dọc là
10 pixel.
Nhãn label1 có văn bản "ID:", màu nền đen, màu văn bản trắng. Nó được
định vị tại cột 0, hàng 1 trên giao diện, với khoảng cách dọc là 30 pixel.
Nhãn label2 tương tự như label1.
Tạo ra hai ô nhập liệu trên giao diện tkinter và cấu hình chúng

- Các nút nhấn trong giao diện:

Ba nút nhấn btlaydulieu, bttrain, btnhandien được tạo bằng lớp
ttk.Button() của tkinter.
 btlaydulieu có văn bản "Get Data" và liên kết với hàm laydulieu khi
được nhấp.
 bttrain có văn bản "Training" và liên kết với hàm train khi được
nhấp.
 btnhandien có văn bản "Recognize" và liên kết với hàm nhandien
khi được nhấp.
Các nút được đặt trên giao diện theo các cột và hàng được chỉ định.
Thuộc tính pady=20 thêm khoảng cách dọc 20 pixel giữa các nút.
Các cột trong giao diện được cấu hình với trọng số 1, cho phép chúng tự
động điều chỉnh kích thước khi cửa sổ giao diện thay đổi.
3.3.3. Kết quả củ a giao diện

Hình 3.12 Giao diện giao tiếp người dùng được hiển thị

3.4. Xây dựng mô hình

Mô hình có tên là mô hình cửa cuốn mở khóa cửa bằng nhận diện khuôn mặt.
Có để dễ dàng nhận diện và điều khiển cửa đóng mở khi được xác nhận qua
khuôn mặt người chủ. Do mô hình được thiết kế và làm bằng tay, với độ chính
xác chưa cao. Vì thế nên sẽ có một số sai sót xuất hiện trong quá trình chạy thử.
3.4.1. Giớ i thiệu thiết bị
- Arduino Uno:
Là một bo mạch phát triển dựa trên nền tảng
mã nguồn mở. Nó có vi xử lý mạnh mẽ, các
chân GPIO để kết nối với các linh kiện và
cảm biến, hỗ trợ giao tiếp thông qua các
giao thức như UART, I2C và SPI, và có thể

Hình 3.13 Hình ảnh Arduino Uno

 được lập trình bằng ngôn ngữ Arduino. Arduino Uno là một công cụ linh hoạt
và dễ sử dụng cho các dự án điện tử và nhúng.
- Mạch cầu H L289N:
Mạch cầu H (H-bridge) là một mạch điện tử
được sử dụng để điều khiển động cơ hoặc
tải điện có hướng quay và chiều điều khiển
độc lập. Nó cho phép đảo chiều quay của
động cơ và điều chỉnh tốc độ quay thông
qua điều khiển các tín hiệu tương ứng. Mạch
cầu H thường được sử dụng trong các ứng
dụng điện tử, robotica và tự động hóa để
Hình 3.14 Hình ảnh Mạch cầu H
điều khiển động cơ DC hoặc động cơ bước.
- Động cơ DC giảm tốc:
Động cơ DC giảm tốc là một loại động cơ
DC có khả năng giảm tốc độ quay thông qua
hệ thống bánh răng hoặc truyền động khác.
Nó tạo ra lực xoắn lớn và vận tốc quay thấp,
và được sử dụng rộng rãi trong các ứng
dụng như robot, tự động hóa và công Hình 3.15 Động cơ DC giảm tốc
nghiệp.
3.4.2. Cấ u thà nh mô hình
- Thành phần chính cấu tạo nên mô hình gồm có: Arduino Uno, mạch cầu H
L289N 2A, động cơ DC giảm tốc 2 trục, pin 9V.
- Dựng mô hình bằng bìa formex với tấm cửa cuốn được làm từ bìa carton
mỏng nhẹ dễ cuốn. Cài đặt thời gian cho thiết bị chạy khi nhận dữ liệu khuôn
mặt đúng, không đúng hoặc không có khuôn mặt để phát tín hiệu về arduino
sau khi đã thực hiện các bước từ lấy dữ liệu, huấn luyện và nhận diện.
- Nguyên lý làm việc của mô hình: Khi cắm jack vào cổng com của máy tính,
bắt đầu chạy phần code arduino, sau đó nạp vào arduino. Tiếp theo chạy phần
giao diện của chương trình lên, thực hiện các bước từ getData đến Recognize.
Sau đó wedcam hiện liên và nhận diện khuôn mặt rồi nếu đúng với khuôn mặt
đã huấn luyện từ trước, âm thanh sẽ phát ra là “Nhận diện thành công. Chào
mừng bạn trở lại” và cửa cuốn sẽ tự động được mở sau 0.2s và đóng lại sau 5s
khi người chủ đã vào phòng. Và ngược lại, nếu không đúng hoặc không thấy
khuôn mặt. Hệ thống yêu cầu quét lại.
- Code Arduino điều khiển động cơ khi nhận tín hiệu từ hệ thống nhận diện:
 Với đoạn code này có 3 phần chính:
Phần 1: Chân 9 được sử dụng để điều khiển tín
hiệu PWM cho động cơ, và chân 8 và 7 được sử
dụng để điều khiển hướng quay của động cơ.
Phần 2: Hàm setup():
Hàm này được gọi một lần khi Arduino khởi
động, tốc độ truyền dữ liệu của kết nối Serial
được đặt là 9600 bps.
Các chân enA, in1, và in2 được cấu hình là
OUTPUT (đầu ra).
Phần 3: Hàm loop():
Hàm này được thực thi lặp đi lặp lại sau khi
hàm setup() được thực thi.
Chương trình kiểm tra xem có dữ liệu có sẵn từ
kết nối Serial (Serial.available()) hay không.
Nếu có dữ liệu, nó được đọc (Serial.read()) và
gán cho biến d.
Nếu giá trị của d là 'a', chương trình tiến hành
điều khiển động cơ:
Đặt in1 là HIGH và in2 là LOW để quay theo
một hướng.
Trong chương trình này, động cơ được chạy với
tốc độ là 150, chạy trong 0.74s. Các thông số
này là tùy chỉnh theo mô hình được làm ra.
Cuối cùng, biến d được gán giá trị '\0' hoặc 0 để
xóa giá trị của nó.

3.4.3. Hoà n thà nh mô hình

Mô hình sau khi được lắp ráp và chạy thử thành công.

Hình 3.16 Hình ảnh về cấu tạo mô hình cửa cuốn

 Hình 3.17 Sơ đồ đấu nối tổng thể mô hình

Hình 3.18 Bên ngoài , bên trong mô hình

CHƯƠNG 4: SO SÁNH VỚI KIẾN THỨC ĐÃ HỌC

Trong chương trình nhận diện khuôn mặt cửa tự động này, có sử dụng thuật toán
LBP và Histograms:
- Local Binary Patterns (LBP):
LBP là một phương pháp để trích xuất thông tin cục bộ từ khuôn mặt.
 Đầu tiên, ảnh khuôn mặt được chia thành các ô vuông nhỏ, ví dụ 3x3 hoặc
5x5.
 Với mỗi ô vuông, giá trị trung tâm được so sánh với các điểm lân cận
xung quanh nó.
 Nếu giá trị lân cận lớn hơn hoặc bằng giá trị trung tâm, ta gán giá trị 1,
ngược lại gán giá trị 0.
 Quá trình này tạo ra một vector nhị phân cho mỗi ô vuông, biểu thị mẫu
đặc trưng của khuôn mặt tại vùng đó.
 Cuối cùng, tất cả các vector nhị phân được kết hợp thành một vector đặc
trưng duy nhất cho toàn bộ khuôn mặt.
- Histograms:
Histograms được sử dụng để biểu diễn phân phối của các mẫu LBP trên toàn bộ
khuôn mặt.
 Khuôn mặt được chia thành các ô vuông nhỏ (ví dụ 3x3 hoặc 5x5).
 Với mỗi ô vuông, ta tính toán histogram của các mẫu LPB trong ô đó.
Histogram là một biểu đồ thống kê biểu diễn số lượng xuất hiện của từng
giá trị trong mẫu LBP.
 Kết quả là một vector histogram cho mỗi ô vuông, biểu thị phân phối đặc
trưng của khuôn mặt tại vùng đó.
Cuối cùng, tất cả các vector histogram được kết hợp thành một vector đặc trưng
cuối cùng cho toàn bộ khuôn mặt.
LBPH (Local Binary Patterns Histograms) là một thuật toán phổ biến trong nhận
diện khuôn mặt. Nó được sử dụng để trích xuất đặc trưng từ khuôn mặt và tạo ra
một histogram để biểu diễn các đặc trưng đó. LBPH có thể được sử dụng để
nhận diện khuôn mặt dựa trên việc so sánh histogram của một khuôn mặt mới
với các histogram đã được huấn luyện trước.
- So sánh với các thuật toán đã học khác:
 Otsu Thresholding: Đây là một thuật toán tìm ngưỡng toàn cục để phân
ngưỡng ảnh thành hai phân vùng dựa trên phân phối mức xám của ảnh.
Tuy nhiên, Otsu Thresholding không phải là một thuật toán nhận diện
khuôn mặt, mà là một kỹ thuật xử lý ảnh để phân loại các pixel thành hai
nhóm.
 Roberts, Prewitt, Sobel: Đây là các toán tử gradient được sử dụng để tìm
biên của đối tượng trong ảnh. Chúng có thể được sử dụng để trích xuất
đặc trưng từ khuôn mặt nhưng không phải là các thuật toán nhận diện
khuôn mặt đầy đủ.
  Canny Edge Detection: Đây là một thuật toán phát hiện biên dựa trên
nhiều bước, bao gồm làm mịn ảnh, tìm đạo hàm, tìm ngưỡng và làm sạch
biên. Canny cũng không phải là một thuật toán nhận diện khuôn mặt, mà
là một kỹ thuật tách biên tổng quát.
 K-means: Đây là một thuật toán gom cụm được sử dụng để phân nhóm dữ
liệu vào các cụm dựa trên đặc trưng của chúng. K-means không phải là
một thuật toán nhận diện khuôn mặt, mà là một phương pháp gom cụm.
 Mean Shift: Đây là một thuật toán gom cụm không tham số dựa trên việc
di chuyển trọng tâm của cụm. Tương tự như K-means, Mean Shift không
phải là một thuật toán nhận diện khuôn mặt.
 Graph Cuts: Đây là một thuật toán tối ưu hóa được sử dụng trong xử lý
ảnh để phân đoạn ảnh thành các vùng dựa trên một số ràng buộc. Graph
Cuts không phải là một thuật toán nhận diện khuôn mặt.
Các thuật toán Prewitt, Roberts, Sobel, Canny, K-means, Mean Shift và Graph
Cuts không thể thay thế LBPH trong việc nhận diện khuôn mặt vì chúng không
tập trung vào nhận diện khuôn mặt mà thực hiện các tác vụ xử lý ảnh khác nhau.
Tuy nhiên, có một số thuật toán nhận diện khuôn mặt khác như Eigenfaces,
Fisherfaces, và HOG (Histogram of Oriented Gradients) có thể được sử dụng
thay thế cho LBPH trong nhận diện khuôn mặt.
Quá trình chọn thuật toán nhận diện khuôn mặt phụ thuộc vào yêu cầu cụ thể
và dữ liệu đầu vào. Đối với mỗi thuật toán, có những ưu điểm và hạn chế riêng.
Nên tùy yêu cầu sử dụng mà chọn thuật toán để sử dụng cho đề tài, ở đây chúng
em chọn thuật toán LBPH cho đề tài này.

CHƯƠNG 5: KẾT LUẬN

Sau khi được giao đề tài trên, chúng tôi đã bắt đầu nghiên cứu và cho ra một số
kết quả đạt được như sau:
- Nhận diện khuôn mặt chính xác: Mô hình nhận diện khuôn mặt đã được
phát triển và đào tạo bằng sử dụng OpenCV. Kết quả đạt được là khả
năng nhận diện khuôn mặt chính xác và đáng tin cậy. Điều này đảm bảo
rằng chỉ những người được đăng ký và có khuôn mặt đã được lưu trữ
trong hệ thống mới có thể mở khóa cửa.
- Giao diện người dùng thân thiện: Dự án này đã được thiết kế một giao
diện để giao tiếp với người dùng. Việc sử dụng thư việnTkinter trong
OpenCV đã cho phép người dùng dễ dàng thao tác và quản lý hệ thống
mở khóa cửa dựa trên nhận diện khuôn mặt. Giao diện người dùng thân
thiện giúp tăng tính tiện ích và tương tác tốt hơn với người dùng cuối.
- Mô hình mô phỏng thực tế: Hoàn thiện được một mô hình mô phỏng thực
tế bằng cách sử dụng các thiết bị thường gặp như Arduino, Cầu H,… để
tạo ra một mô hình thực tế, mô tả được quá trình làm việc của dự án. Điều
này cho phép bạn thử nghiệm và kiểm tra hiệu suất của hệ thống mở khóa
cửa trong một môi trường giả lập. Và còn có thể đánh giá và cải thiện tính
ổn định và độ tin cậy của hệ thống trước khi triển khai thực tế.
- Ứng dụng tiềm năng: Kết quả đạt được từ dự án này mở ra nhiều ứng
dụng tiềm năng trong lĩnh vực an ninh và quản lý truy cập. Hệ thống nhận
diện khuôn mặt mở khóa cửa có thể được áp dụng trong các tòa nhà, văn
phòng, khách sạn hoặc các khu vực có yêu cầu bảo mật cao, cung cấp một
phương thức mở khóa hiệu quả và an toàn.
Công việc này không chỉ cho thấy khả năng trong việc ứng dụng công nghệ và
lập trình, mà còn mang lại tiềm năng ứng dụng thực tế trong lĩnh vực an ninh và
quản lý truy cập. Bằng cách kết hợp công nghệ nhận diện khuôn mặt và hệ thống
cửa tự động, dự án này có thể cung cấp một giải pháp hiệu quả và tiện lợi cho
việc kiểm soát truy cập và bảo mật, có thể góp phần vào việc phát triển các hệ
thống an ninh tiên tiến và mang lại lợi ích cho cộng đồng.

TÀI LIỆU THAM KHẢO

Tiếng Việt
[1]. Lương Mạnh Bá , Nhập môn xử lí ảnh số , Khoa học kĩ thuật , 2007.
[2]. OpenCV: Cascade Classifier
Website
[3]. https://github.com/opencv/opencv/tree/master/data/haarcascades
[4]. https://poe.com
[5]. https://cuacuonchongtrom.com/tin-tuc/6-loi-ich-khi-lap-dat-cua-cuon-tu-
dong

PHỤ LỤC
Chương trình được chạy bằng ngôn ngữ Python trong môi trường Pycharm với
thư viên chính là OpenCV. Gồm 3 chương trình và 1 giao diện như sau:
+ Lấy dữ liệu khuôn mặt (Get Data):

+ Huấn luyện dữ liệu khuôn mặt (Training):

+ Nhận diện khuôn mặt đã huấn luyện(Recognize):
+ Huấn luyện dữ liệu khuôn mặt (Training) cụ thể:
Link code: https://github.com/Vanng89/BTL_XLA