ĐẠI HỌC KỸ THUẬT-CÔNG NGHỆ CẦN THƠ

KHOA CÔNG NGHỆ THÔNG TIN

---

TIỂU LUẬN TỐT NGHIỆP

Đề tài:

XÂY DỰNG HỆ THỐNG NHẬN DIỆN THỦ NGỮ ĐỂ

GIAO TIẾP VỚI NGƯỜI KHUYẾT TẬT

GIẢNG VIÊN HƯỚNG DẪN SINH VIÊN THỰC HIỆN:

-ThS.NGUYỄN NHỰT QUỲNH VŨ VĂN TIẾN DŨNG

-ThS.HÀ LÊ NGỌC DUNG MSSV:1800704

NGÀNH:KHOA HỌC MÁY TÍNH

Cần Thơ, 2022

 NHẬN XÉT CỦA GIÁO VIÊN HƯỚNG DẪN
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
Cần Thơ, ngày …tháng…năm 2022
Ký tên

2
 NHẬN XÉT CỦA GIÁO VIÊN PHẢN BIỆN
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
…………………………………………………………………………………………
Cần Thơ, ngày …tháng…năm 2022
Ký tên

3
 LỜI CAM ĐOAN
Tôi xin cam đoan tiểu luận tốt nghiệp: “XÂY DỰNG HỆ THỐNG NHẬN DIỆN
THỦ NGỮ ĐỂ GIAO TIẾP VỚI NGƯỜI KHUYẾT TẬT” là công trình nghiên
cứu của bản thân. Những phần sử dụng tài liệu tham khảo trong luận văn đã được nêu
rõ trong phần tài liệu tham khảo. Các số liệu, kết quả trình bày trong luận văn là hoàn
toàn trung thực, nếu sai tôi xin chịu hoàn toàn trách nhiệm và chịu mọi kỷ luật của bộ
môn và nhà trường đề ra.

Cần Thơ, ngày …tháng…năm 2022

Sinh viên thực hiện

4
 LỜI CẢM ƠN

“Để hoàn thành tiểu luận này, em xin gửi lời cảm ơn chân thành:

ban giám hiệu trường Đại Học kỹ thuật-công nghê Cần Thơ vì đã tạo điều kiện về cơ
sở vật chất với hệ thống thư viện hiện đại, đa dạng các loại sách, tài liệu thuận lợi cho
việc tìm kiếm, nghiên cứu thông tin.

Xin cảm ơn giảng viên bộ môn – Cô Nguyễn Nhựt Quỳnh và Cô Hà Lê Ngọc Dung đã
giảng dạy tận tình, chi tiết để tôi có đủ kiến thức và vận dụng vào bài tiểu luận này.

Do chưa có nhiều kinh nghiệm làm để tài cũng như những hạn chế về kiến thức, trong
bài tiểu luận chắc chắn sẽ không tránh khỏi những thiếu sót. Rất mong nhận được sự
nhận xét, ý kiến đóng góp từ phía Thầy,cô để bài tiểu luận được hoàn thiện hơn.

Lời cuối cùng, tôi xin kính chúc thầy nhiều sức khỏe, thành công và hạnh phúc.”

Cần Thơ, ngày …tháng…năm 2022

Sinh viên thực hiện

5
Mục lục:

PHẦN 1 : MỞ ĐẦU................................................................................................................8
1.1 Lý do chọn đề tài..............................................................................................................8
1.2 Mục tiêu nghiên cứu.........................................................................................................8
1.3 Phương pháp nghiên cứu..................................................................................................8
1.4 Kết quả dự kiến đạt được.................................................................................................8
PHẦN 2: NỘI DUNG............................................................................................................9
CHƯƠNG 1: CƠ SỞ LÝ LUẬN.......................................................................................9
1.1. TỔNG QUAN THỦ NGỮ ( CỬ CHỈ TAY) CỦA NGƯỜI KHUYẾT TẬT........9
1.2. CÁC NGHIÊN CỨU VÀ ĐỀ TÀI LIÊN QUAN..................................................10
1.3. CƠ SỞ DỮ LIỆU.....................................................................................................10
1.4. LÝ THUYẾT VỀ NHẬN DIỆN ẢNH...................................................................11
a. Neural network là gì?..........................................................................................11
Biểu diễn dưới dạng ma trận............................................................................................16
a. Convolutional neural network............................................................................18
Convolutional layer..........................................................................................................18
Pooling layer....................................................................................................................22
Fully connected layer.......................................................................................................24
Visualise convolutional neural network...........................................................................24
b. Mạng VGG 16......................................................................................................25
1.5. THUẬT TOÁN TỐI ƯU.........................................................................................26
a. Định nghĩa............................................................................................................26
b. Thuật toán Adam - Adaptive Moment Estimation...........................................26
CHƯƠNG 2 :THỰC NGHIỆM..............................................................................................28
a.Đường đi dữ liệu dự đoán..............................................................................................29
b.Thiết kế hệ thống...........................................................................................................29
2.1. Xử lý dữ liệu.............................................................................................................30
a) Hàm xử lý ảnh resize về 224x224 và chuyển về numpy array.........................30
b) Xử lý dữ liệu đầu vào...........................................................................................31
c) Hàm duyệt thư mục để train...............................................................................31
d) Load dữ liệu vào X,Y đi qua hàm duyệt............................................................32
2.2. Xây dựng mô hình training....................................................................................32
a) Chia dữ liệu:.........................................................................................................32
b) Đặt các checkpoint...............................................................................................32
c) Khởi tạo model.....................................................................................................32
d) Thêm các lớp bên trên.........................................................................................33
e) Tiến hành training...............................................................................................33
f) Kiểm tra độ chính xác của phần mô hình sau khi train.......................................34
2.3. Tạo giao diện phần mềm.........................................................................................35
CHƯƠNG 3 : KẾT LUẬN.....................................................................................................40
Tài Liệu tham khảo..................................................................................................................41

6
Hình 1. Bảng thủ ngữ của người khuyết tật……………………………….. 9

Hình 2: bộ dữ liệu đã thu thập…………………………………………….. 11

Hình 3: Hoạt động của các nơ-ron………………………………………... 12

Hình 4. Mô hình logistic regression………………………………………. 13

Hình 5 .Mô hình neural network………………………………………….. 14

Hình 6 .Mô hình neural network………………………………………….. 15

Hình 7 .Mô hình neural network………………………………………….. 18

Hình 8 . nput layer và hidden layer……………………………………….. 18

Hình 9 . Phép tính convolution thực hiện trên ảnh xám với biểu diễn ảnh

dạng ma trận………………………………………………………………… 19

Hình 10.Phép tính convolution trên ảnh màu với k=3……………………… 20

Hình 11.Tensor X, W 3 chiều được viết dưới dạng 3 matrix……………...... 20

Hình 12.Thực hiện phép tính convolution trên ảnh màu……………………. 21

Hình 13.Convolutional layer đầu tiên……………………………………..... 21

Hình 14.max pooling layer với size=(3,3), stride=1, padding=0…………... 23

Hình 15.Sau pooling layer (2*2)…………………………………………… 23

Hình 16.Ví dụ về pooling layer…………………………………………….. 25

Hình 17.Sau pooling layer (2*2)……………………………………..……... 25

Hình 18.Kiến trúc vgg16……………………………………………………. 25

Hình 19. Đường đi dữ liệu …………………………………………………. 29

Hình 20. Sơ đồ mô hình hệ thống từ train đến test………………….……… 29

Hình 21. Hình vẽ đường đi dữ liệu khi train………………………………… 39

Hình 22 .Giao diện phần mềm sau khi hoàn thành…………………………. 39

Hình 23. Kết quả đạt được……………………………………………..……. 39

7
 PHẦN 1 : MỞ ĐẦU

1.1 Lý do chọn đề tài

-Phương diện lý thuyết: Giúp cho người khuyết tật có thể giao tiếp, sử dụng máy tính
và các công cụ công nghệ cao một cách thuận tiện dễ dàng mà không cần thông qua
người phiên dịch, thuận tiện cho người khuyết tật đặc biệt là những người khiếm
thính.

-Phương diện thực tiễn: Người dùng chỉ cần sử dụng các động tác tay trong bảng chữ
cái của thủ ngữ thì chương trình có thể nhận diện và xác định được thủ ngữ người
dùng muốn là gì và đưa ra chữ dưới dạng bảng chữ cái lating ra màn hình cho người
khác hiểu. Người dùng có thể mình tự học tập và sử dụng các thiết bị điện tử cũng như
giao tiếp với người khác thông qua phần mềm mà không tốn quá nhiều công sức.

1.2 Mục tiêu nghiên cứu

-Mục tiêu tổng quát: Xây dựng được một ứng dụng nhận diện cử chỉ tay của người
dùng, sau đó từ cử chỉ nhận dạng xuất ra màn hình chữ được nhận diện

-Mục tiêu cụ thể: Học và hiểu cơ bản bảng chữ cái thủ ngữ, về phương diện chuyên
môn cần phải nắm rõ các kiến thức về máy học. nắm rõ cấu trúc thuật toán sử dụng,
tìm kiếm thông tin về bảng chữ cái thủ ngữ dưới dạng hình ảnh. Thiết lập cấu hình
giao diện máy tính để máy nhận diện qua camera thiết bị. Thể hiện rõ ràng hình ảnh,
nhận diện chính xác từ được sử dụng của người dùng.

1.3 Phương pháp nghiên cứu

- Tìm hiểu về bảng chữ cái thủ ngữ cho người khuyết tật ở đây tôi dùng bảng chữ cái
American Sign Laguage(ASL)

-Tìm kiếm bộ CSDL trên Kaggle bộ ảnh về thủ ngữ American Sign Laguage”ASL”

-Nghiên cứu các đề tài hoặc bài toán tương tự trên internet

-Chọn mô hình thực hiện: CNN, VGG, … Ở đây tôi chọn VGG16

-Nghiên cứu và sử dụng pycharm bắt đầu thiết kế giao diện người dùng

1.4 Kết quả dự kiến đạt được

- Phầm mềm xây dựng có thể đạt được hiểu quả lên đến 90% độ chính xác, sau khi
hoàn thành phần mềm có thể nhận diện ít nhất 5 ký hiệu thủ ngữ và đưa kết quả ra
màn hình.

8
PHẦN 2: NỘI DUNG
CHƯƠNG 1: CƠ SỞ LÝ LUẬN
1.1. TỔNG QUAN THỦ NGỮ ( CỬ CHỈ TAY) CỦA NGƯỜI
KHUYẾT TẬT
-Thủ ngữ là gì? Là ngôn ngữ ký hiệu hay ngôn ngữ dấu hiệu, thủ ngữ là ngôn ngữ
dùng những biểu hiện của bàn tay thay cho âm thanh của tiếng nói. Ngôn ngữ ký hiệu
do người khiếm thính tạo ra nhằm giúp họ có thể giao tiếp với nhau trong cộng đồng
của mình và tiếp thu tri thức của xã hội.(wikipedia.org)

-Bảng chữ cái thủ ngữ:

Hình 1. Bảng thủ ngữ của người khuyết tật

9
1.2. CÁC NGHIÊN CỨU VÀ ĐỀ TÀI LIÊN QUAN
-Đề tài nhận dạng ngôn ngữ dấu hiệu với camera Kinect và đặc trưng gist ( Theo
tạp chí Khoa học Trường Đại học kỹ thuật công nghệ Cần Thơ ): Trong bài báo này,
họ đề xuất một phương pháp mới cho việc nhận dạng ngôn ngữ dấu hiệu. Với dữ liệu
được thu nhận từ camera Kinect, họ trích các đặc trưng chuyển động của bàn tay. Họ
đề xuất một phương pháp biểu diễn quỹ đạo chuyển động của bàn tay bằng cách chia
quỹ đạo thành k (e.g. k = 4) đoạn và sau đó tính tổ chức đồ (orientation histogram) của
hướng di chuyển cho từng đoạn. Với phương pháp này, đặc trưng chuyển động không
phụ thuộc vào độ dài của quỹ đạo. Ngoài ra, để tăng cường khả năng phân biệt, thông
tin trực quan (visual) về hình dạng của bàn tay cũng trích xuất với đặt trưng GIST. Tất
cả các đặc trưng trên được sử dụng để huấn luyện bộ nhận dạng được huấn luyện bằng
mô hình máy học véc-tơ hỗ trợ. Họ đã thu thập dữ liệu từ 5 bạn học viên trường dạy
trẻ khuyết tật thành phố Cần Thơ. Bộ dữ liệu gồm 14 từ, mỗi người thực hiện 4 lần.
Tổng cộng là 280 phần tử. Thực nghiệm cho thấy kết quả nhận dạng đạt 90%.

-Thiết bị giao tiếp thông minh giành cho người khiếm thanh, khiếm thính (speak
your mind - sym) của nhóm tác nhả trường ĐH Bách Khoa ĐHQG-HCM (theo
iptc.vn):Thiết bị SYM của họ sử dụng công nghệ AI để chuyển thủ ngữ của những
người này sang dạng văn bản và giọng nói phát ra từ các thiết bị điện thoại thông minh
trong thời đại công nghiệp 4.0.

 Ý tưởng: dự án “Thiết bị giao tiếp thông minh dành cho người khiếm thanh,
khiếm thính – Speak your mind” (thiết bị SYM) là thiết bị giao tiếp chuyển
ngôn ngữ ký hiệu sang văn bản và giọng nói để những người khiếm thanh,
khiếm thính dễ dàng trao đổi thông tin với mọi người.
1.3. CƠ SỞ DỮ LIỆU
-Tạo bộ dữ liệu: Có 2 cách để tạo bộ cơ sở dữ liệu training này

 Tìm trên mạng: trong Kaggle.com tìm từ khóa Hand Gesture Recognition, lựa
chọn những bộ dữ liệu cần thiết và set up bộ CSDL cho mô hình train.
 Dùng photoshop phương pháp quen thuộc với bất kỳ ai đã từng sử dụng
Photoshop. nếu bạn chụp ảnh bàn tay của bạn rồi đưa vào photoshop, loại trừ
nền khỏi hình ảnh của mình, sau đó sử dụng ngưỡng nhị phân để làm cho cử
chỉ tay chỉ hoàn toàn trắng và nền hoàn toàn đen.

-Bộ dữ liệu data bao gồm: 2000 ảnh train và gần 300 ảnh test

10
 Hình 2: bộ dữ liệu đã thu thập

1.4. LÝ THUYẾT VỀ NHẬN DIỆN ẢNH

a. Neural network là gì?

Con chó có thể phân biệt được người thân trong gia đình và người lạ hay đứa trẻ có
thể phân biệt được các con vật. Những việc tưởng chừng như rất đơn giản nhưng lại
cực kì khó để thực hiện bằng máy tính. Vậy sự khác biệt nằm ở đâu? Câu trả lời nằm
ở bộ não với lượng lớn các nơ-ron thần kinh liên kết với nhau. Thế thì máy tính có nên
mô phỏng lại mô hình ấy để giải các bài toán trên ???

Neural là tính từ của neuron (nơ-ron), network chỉ cấu trúc đồ thị nên neural network
(NN) là một hệ thống tính toán lấy cảm hứng từ sự hoạt động của các nơ-ron trong hệ
thần kin

Hình 3: Hoạt động của các nơ-ron

11
Nơ-ron là đơn vị cơ bản cấu tạo hệ thống thần kinh và là một phần quan trọng nhất
của não. Não chúng ta gồm khoảng 10 triệu nơ-ron và mỗi nơ-ron liên kết với 10.000
nơ-ron khác.

Ở mỗi nơ-ron có phần thân (soma) chứa nhân, các tín hiệu đầu vào qua sợi nhánh
(dendrites) và các tín hiệu đầu ra qua sợi trục (axon) kết nối với các nơ-ron khác. Hiểu
đơn giản mỗi nơ-ron nhận dữ liệu đầu vào qua sợi nhánh và truyền dữ liệu đầu ra qua
sợi trục, đến các sợi nhánh của các nơ-ron khác.

Mỗi nơ-ron nhận xung điện từ các nơ-ron khác qua sợi nhánh. Nếu các xung điện này
đủ lớn để kích hoạt nơ-ron, thì tín hiệu này đi qua sợi trục đến các sợi nhánh của các
nơ-ron khác. => Ở mỗi nơ-ron cần quyết định có kích hoạt nơ-ron đấy hay không.

Tuy nhiên NN chỉ là lấy cảm hứng từ não bộ và cách nó hoạt động, chứ không phải
bắt chước toàn bộ các chức năng của nó. Việc chính của chúng ta là dùng mô hình đấy
đi giải quyết các bài toán chúng ta cần.

-Mô hình neural network

VD:Logistic regression

Logistic regression là mô hình neural network đơn giản nhất chỉ với input layer và
output layer.

Mô hình của logistic regression từ bài trước là: y^=σ(w0+w1∗x1+w2∗x2).Có 2

bước:

 Tính tổng linear: z = 1∗w0+x1∗w1+x2∗w2

 Áp dụng sigmoid function: y^=σ(z)

12
Để biểu diễn gọn lại ta sẽ gộp hai bước trên thành một trên biểu đồ

Hình 4. Mô hình logistic regresion

Hệ số w0 được gọi là bias. Để ý từ những bài trước đến giờ dữ liệu khi tính toán luôn
được thêm 1 để tính hệ số bias w0 .Tại sao lại cần hệ số bias? Quay lại với bài 1,
phương trình đường thẳng sẽ thế nào nếu bỏ w0 , phương trình giờ có dạng: w1∗x+w2
∗y=0 , sẽ luôn đi qua gốc tọa độ và nó không tổng quát hóa phương trình đường thẳng
nên có thể không tìm được phương trình mong muốn. => Việc thêm bias (hệ số tự do)
là rất quan trọng.

Hàm sigmoid ở đây được gọi là activation function.

13
 Hình 5 .Mô hình neural network

Layer đầu tiên là input layer, các layer ở giữa được gọi là hidden layer, layer cuối
cùng được gọi là output layer. Các hình tròn được gọi là node.

Mỗi mô hình luôn có 1 input layer, 1 output layer, có thể có hoặc không các hidden
layer. Tổng số layer trong mô hình được quy ước là số layer – 1 (Không tính input
layer).

Ví dụ như ở hình trên có 1 input layer, 2 hidden layer và 1 output layer. Số lượng
layer của mô hình là 3 layer.

Mỗi node trong hidden layer và output layer :

 Liên kết với tất cả các node ở layer trước đó với các hệ số w riêng.
 Mỗi node có 1 hệ số bias b riêng.
 Diễn ra 2 bước: tính tổng linear và áp dụng activation function.

*Kí hiệu:

Số node trong hidden layer thứ i là l(i).

Ma trận W(k) kích thước  l(k−1)∗l(k) là ma trận hệ số giữa layer (k-1) và layer k, trong
đó wij(k) là hệ số kết nối từ node thứ i của layer k-1 đến node thứ j của layer k.

14
Vector b(k) kích thước lk∗1 là hệ số bias của các node trong layer k, trong đó bi(k) là bias
của node thứ i trong layer k.

Với node thứ i trong layer l có bias bi(l) thực hiện 2 bước:

 Tính tổng linear: Là tổng tất cả các node trong layer trước nhân với hệ số w
tương ứng, rồi cộng với bias b.
 Áp dụng activation function: ai(l)=σ(zi(l))

Vector z(k) kích thước l(k)∗1 là giá trị các node trong layer k sau bước tính tổng linear.

Vector a(k) kích thước l(k)∗1 là giá trị của các node trong layer k sau khi áp dụng hàm
activation function.

Hình 6 .Mô hình neural network

Mô hình neural network trên gồm 3 layer. Input layer có 2 node (l(0)=2), hidden layer 1
có 3 node, hidden layer 2 có 3 node và output layer có 1 node.

15
Do mỗi node trong hidden layer và output layer đều có bias nên trong input layer và
hidden layer cần thêm node 1 để tính bias (nhưng không tính vào tổng số node layer
có).

Tại node thứ 2 ở layer 1, ta có:

 z2(1)=x1∗w12(1)+x2∗w22(1)+b2(1)
 a2(1)=σ(z2(1))

Hay tại node thứ 3 ở layer 2, ta có:

 z3(2)=a1(1)∗w13(2)+a2(1)∗w23(2)+a3(1)∗w33(2)+b3(2)

 a3(2)=σ(z3(2))

Feedforward

Để nhất quán về mặt ký hiệu, gọi input layer là a(0) (= x) kích thước 2*1.

z(2)=(W(2))T∗a(1)+b(2)

a(2)=σ(z(2))

z(3)=(W(3))T∗a(2)+b(3)

y^=a(3)=σ(z(3))

Biểu diễn dưới dạng ma trận

Tuy nhiên khi làm việc với dữ liệu ta cần tính dự đoán cho nhiều dữ liệu một lúc, nên
gọi X là ma trận n*d, trong đó n là số dữ liệu và d là số trường trong mỗi dữ liệu, trong
đó xj[i] là giá trị trường dữ liệu thứ j của dữ liệu thứ i. Ví dụ dataset

Lương Thời gian làm việc

10 1

5 2

6 1.8

16
 7 1

thì n=4, d=2, x1[1] = 10, x2[1] = 1, x1[3] = 6, x2[2] = 2.

[ ]
x [11] x [21 ] … x [d1]
x [ 2] x [22 ] … x [d2]
X= 1 =¿
… … …
x1[ n] x [2n ] x [dn]

Biểu diễn dạng ma trận của nhiều dữ liệu trong dataset

Do x[1] là vector kích thước d*1 tuy nhiên ở X mỗi dữ liệu được viết theo hàng nên cần
transpose  x[1] thành kích thước 1*d, kí hiệu: −(x[1])T−Gọi ma trận Z(i) kích thước 
N∗l(i) trong đó  zj(i)[k] là giá trị thứ j trong layer i sau bước tính tổng linear của dữ liệu
thứ k trong dataset.

*Kí hiệu (i) là layer thứ i và kí hiệu [k] là dữ liệu thứ k trong dataset.

Tương tự, gọi ma trận A^{(i)}A(i) kích thước  N∗l(i) trong đó aj(i)[k] là giá trị thứ j trong
layer i sau khi áp dụng activation function của dữ liệu thứ k trong dataset.

[ ]
z1
(i)(1)
z (i2 )(1) … z(i)(1
i
)
( i)

(i)(1) (i )(2) (i)(1 )

z z … z
Z(I )= 1 2 i
( i)
=¿
… … … …
z (i)(1)
1 z (i)(n)
2
… z(i)(1)
1i
(i)

Do đó:

[ ]
( 1 ) [1 ] T
(z )
( 1) ( z (1 )[2 ])T
Z = ≡¿
…
( z (1 )[n ])T

Phép tính cuối cùng không đúng nhưng để viết công thức cho gọn lại.

A =∂ ( Z )
( 1) 1

( 2) ( 1) ( 2) ( 2)
Z = A ∗W +b

A =∂ ( Z )
( 2) ( 2)

Z( 3)= A (2)∗W (3 )+ b(3 )

17
Y = A =∂ ( Z )
(3 ) ( 2)

Vậy là có thể tính được giá trị dự đoán của nhiều dữ liệu 1 lúc dưới dạng ma trận.

Giờ từ input X ta có thể tính được giá trị dự đoán Y, tuy nhiên việc chính cần làm là đi
tìm hệ số W và b. Có thể nghĩ ngay tới thuật toán gradient descent và việc quan trọng
nhất trong thuật toán gradient descent là đi tìm đạo hàm của các hệ số đối với loss
function. Và việc tính đạo hàm của các hệ số trong neural network được thực hiện bởi
thuật toán backpropagation

a. Convolutional neural network

Convolutional layer

Hình 7 .Mô hình neural network

Mỗi hidden layer được gọi là fully connected layer, tên gọi theo đúng ý nghĩa, mỗi
node trong hidden layer được kết nối với tất cả các node trong layer trước. Cả mô hình
được gọi là fully connected neural network (FCN).

18
Vấn đề của fully connected neural network với xử lý ảnh
Về xử lý ảnh, thì ảnh màu 64*64 được biểu diễn dưới dạng 1 tensor 64*64*3. Nên để
biểu thị hết nội dung của bức ảnh thì cần truyền vào input layer tất cả các pixel
(64*64*3 = 12288). Nghĩa là input layer giờ có 12288 nodes.

Hình 8 . nput layer và hidden layer 1

Giả sử số lượng node trong hidden layer 1 là 1000. Số lượng weight W giữa input
layer và hidden layer 1 là 12288*1000 = 12288000, số lượng bias là 1000 => tổng số
parameter là: 12289000. Đấy mới chỉ là số parameter giữa input layer và hidden layer
1, trong model còn nhiều layer nữa, và nếu kích thước ảnh tăng, ví dụ 512*512 thì số
lượng parameter tăng cực kì nhanh => Cần giải pháp tốt hơn !!!

Nhận xét:

 Trong ảnh các pixel ở cạnh nhau thường có liên kết với nhau hơn là những
pixel ở xa. Ví dụ như phép tính convolution trên ảnh ở bài trước. Để tìm các
đường trong ảnh, ta áp dụng sobel kernel trên mỗi vùng kích thước 3*3. Hay
làm nét ảnh ta áp dụng sharpen kernel cũng trên vùng có kích thước 3*3.
 Trong phép tính convolution trong ảnh, chỉ 1 kernel được dùng trên toàn bộ
bức ảnh. Hay nói cách khác là các pixel ảnh chia sẻ hệ số với nhau.

=> Áp dụng phép tính convolution vào layer trong neural network ta có thể giải quyết
được vấn đề lượng lớn parameter mà vẫn lấy ra được các đặc trưng của ảnh.

19
Convolutional layer đầu tiên
Phép tính convolution thực hiện trên ảnh xám với biểu diễn ảnh dạng ma trận

Hình 9 . Phép tính convolution thực hiện trên ảnh xám với biểu diễn ảnh dạng ma trận

Tuy nhiên ảnh màu có tới 3 channels red, green, blue nên khi biểu diễn ảnh dưới dạng
tensor 3 chiều. Nên ta cũng sẽ định nghĩa kernel là 1 tensor 3 chiều kích thước k*k*3.

Hình 10.Phép tính convolution trên ảnh màu với k=3.

20
Ta định nghĩa kernel có cùng độ sâu (depth) với biểu diễn ảnh, rồi sau đó thực hiện di
chuyển khối kernel tương tự như khi thực hiện trên ảnh xám.

Hình 11.Tensor X, W 3 chiều được viết dưới dạng 3 matrix.

Khi biểu diễn ma trận ta cần 2 chỉ số hàng và cột: i và j, thì khi biểu diễn ở dạng ten-
sor 3 chiều cần thêm chỉ số độ sâu k. Nên chỉ số mỗi phần tử trong tensor là xijk.

21
 Hình 12.Thực hiện phép tính convolution trên ảnh màu

Nhận xét:

 Output Y của phép tính convolution trên ảnh màu là 1 matrix.

 Có 1 hệ số bias được cộng vào sau bước tính tổng các phần tử của phép tính el-
ement-wise

*Các quy tắc đối với padding và stride

Với mỗi kernel khác nhau ta sẽ học được những đặc trưng khác nhau của ảnh, nên
trong mỗi convolutional layer ta sẽ dùng nhiều kernel để học được nhiều thuộc
tính của ảnh. Vì mỗi kernel cho ra output là 1 matrix nên k kernel sẽ cho ra k output
matrix. Ta kết hợp k output matrix này lại thành 1 tensor 3 chiều có chiều sâu k.

Hình 13.Convolutional layer đầu tiên

Output của convolutional layer đầu tiên sẽ thành input của convolutional layer tiếp
theo.

Convolutional layer tổng quát

Giả sử input của 1 convolutional layer tổng quát là tensor kích thước H * W * D.

Kernel có kích thước F * F * D (kernel luôn có depth bằng depth của input và F là số
lẻ), stride: S, padding: P.

Convolutional layer áp dụng K kernel.

=> Output của layer là tensor 3 chiều có kích thước:

22
Lưu ý:

 Output của convolutional layer sẽ qua hàm activation function trước khi trở

thành input của convolutional layer tiếp theo.
 Tổng số parameter của layer: Mỗi kernel có kích thước F*F*D và có 1 hệ số
bias, nên tổng parameter của 1 kernel là F*F*D + 1. Mà convolutional layer áp
dụng K kernel => Tổng số parameter trong layer này là K * (F*F*D + 1).

Pooling layer
Pooling layer thường được dùng giữa các convolutional layer, để giảm kích thước dữ
liệu nhưng vẫn giữ được các thuộc tính quan trọng. Kích thước dữ liệu giảm giúp
giảm việc tính toán trong model.

Gọi pooling size kích thước K*K. Input của pooling layer có kích thước H*W*D, ta
tách ra làm D ma trận kích thước H*W. Với mỗi ma trận, trên vùng kích thước K*K
trên ma trận ta tìm maximum hoặc average của dữ liệu rồi viết vào ma trận kết quả.
Quy tắc về stride và padding áp dụng như phép tính convolution trên ảnh.

Hình 14.max pooling layer với size=(3,3), stride=1, padding=0

23
Nhưng hầu hết khi dùng pooling layer thì sẽ dùng size=(2,2), stride=2, padding=0.
Khi đó output width và height của dữ liệu giảm đi một nửa, depth thì được giữ
nguyên.

Hình 15.Sau pooling layer (2*2).

* ghi chú: Source: http://cs231n.github.io/convolutional-networks/

Có 2 loại pooling layer phổ biến là: max pooling và average pooling.

24
 Hình 16.Ví dụ về pooling layer

Trong một số model người ta dùng convolutional layer với stride > 1 để giảm kích
thước dữ liệu thay cho pooling layer.

Fully connected layer

Sau khi ảnh được truyền qua nhiều convolutional layer và pooling layer thì model đã
học được tương đối các đặc điểm của ảnh (ví dụ mắt, mũi, khung mặt,…) thì tensor
của output của layer cuối cùng, kích thước H*W*D, sẽ được chuyển về 1 vector kích
thước (H*W*D)

Sau đó ta dùng các fully connected layer để kết hợp các đặc điểm của ảnh để ra được out-
put của model

25
Visualise convolutional neural network
Mô hình convolutional neural network:

Input image -> Convolutional layer (Conv) + Pooling layer (Pool) -> Fully connected
layer (FC) -> Output.

Hình 17.Ví dụ mô hình convolutional neural network.

b. Mạng VGG 16

VGG16 là mạng convolutional neural network được đề xuất bởi K. Simonyan and A.
Zisserman, University of Oxford. Model sau khi train bởi mạng VGG16 đạt độ chính
xác 92.7% top-5 test trong dữ liệu ImageNet gồm 14 triệu hình ảnh thuộc 1000 lớp
khác nhau. Giờ áp dụng kiến thức ở trên để phân tích mạng VGG

Hình 18.Kiến trúc vgg16

conv: convolutional layer, pool: pooling layer, fc: fully connected layer

Phân tích:

26
  Convolutional layer: kích thước 3*3, padding=1, stride=1. Tại sao không ghi
stride, padding mà vẫn biết? Vì mặc định sẽ là stride=1 và padding để cho out-
put cùng width và height với input.
 Pool/2 : max pooling layer với size 2*2
 3*3 conv, 64: thì 64 là số kernel áp dụng trong layer đấy, hay depth của output
của layer đấy.
 Càng các convolutional layer sau thì kích thước width, height càng giảm nhưng
depth càng tăng.
 Sau khá nhiều convolutional layer và pooling layer thì dữ liệu được flatten và
cho vào fully connected layer.

1.5. THUẬT TOÁN TỐI ƯU

a. Định nghĩa

Thuật toán tối ưu là thuật toán sử dụng ít thời gian, ít bộ nhớ, ít phép toán, giải bài
toán trên máy tính thường được tiến hành qua 5 bước xác định bài toán, lựa chọn hoặc
thiết kế thuật toán, viết chương trình, hiệu chỉnh và viết tài liệu.

b. Thuật toán Adam - Adaptive Moment Estimation

Adam optimizer là một thuật toán kết hợp kỹ thuật của RMS prop và momentum.
Thuật toán sử dụng hai internal states momentum (m) và squared momentum (v) của
gradient cho các tham số. Sau mỗi batch huấn luyện, giá trị của m và v được cập nhật
lại sử dụng exponential weighted averaging.
Mã giải của việc cập nhật m và v

mt=β1mt−1+(1−β1)gt

vt=β2vt−1+(1−β2)gt2

trong đó, beta được xem như là một siêu tham số. Công thức cập nhật theta như sau:

θt=θt−1−α*(mt/ vt+ϵ)

trong đó, alpha là learning rate, epsion là giá trị được thêm vào để ngăng việc chia cho
0

Để việc descent được thực hiện nhanh hơn, thuật toán đã sử dụng hai kỹ thuật:

 Tính exponential moving average của giá trị đạo hàm lưu vào biến m và sử
dụng nó là tử số của việc cập nhật hướng. Với ý nghĩa là nếu m có giá trị lớn,
thì việc descent đang đi đúng hướng và chúng ta cần bước nhảy lớn hơn để đi
nhanh hơn. Tương tự, nếu giá trị m nhỏ, phần descent có thể không đi về
hướng tối tiểu và chúng ta nên đi 1 bước nhỏ để thăm dò. Đây là phần momen-
tum của thuật toán.
27
  Tính exponential moving average của bình phương gía trị đạo hàm lưu vào
biến v và sử dụng nó là phần mẫu số của việc cập nhật hướng. Với ý nghĩa như
sau: Giả sử gradient mang các giá trị dương, âm lẫn lộn, thì khi cộng các giá trị
lại theo công thức tính m ta sẽ được giá trị m gần số 0. Do âm dương lẫn lộn
nên nó bị triệt tiêu lẫn nhau. Nhưng trong trường hợp này thì v sẽ mang giá trị
lớn. Do đó, trong trường hợp này, chúng ta sẽ không hướng tới cực tiểu, chúng
ta sẽ không muốn đi theo hướng đạo hàm trong trường hợp này. Chúng ta để v
ở phần mẫu vì khi chia cho một giá trị cao, giá trị của các phần cập nhật sẽ nhỏ,
và khi v có giá trị thấp, phần cập nhật sẽ lớn. Đây chính là phần tối ưu RM -
SProp của thuật toán.

Ở đây, m được xem như là moment thứ nhất, v xem như là moment thứ hai, nên thuật
toán có tên là “Adaptive moment estimation”.

Để lý giải vì sao Adam lại hội tụ nhanh hơn so với SGD, chúng ta có thể giải thích
như sau: Exponential weighted averaging cho chúng ta giá trị xấp xỉ gradient mượt
hơn qua mỗi lần lặp, dẫn tới tăng tínhs dừng. Sau đó, việc chia cho căng bậc 2 của giá
trị v làm số lước của chúng ta giảm mạnh khi phương sai của giá trị gradient tăng lên.
Điều này , như giải thích ở trên, có nghĩa là, khi hướng đi của mô hình chỉ ra không rõ
ràng, thuật toán Adam thực hiện các bước đi nhỏ coi như là thăm dò thôi. Và sẽ thực
hiện các bước đi lớn, nhanh khi hướng đi rõ ràng.

Thuật toán Adam hoạt động khá hiệu quả, nhưng bản thân nó cũng có những vấn đề.
Tác giả của AdaBelief đã chỉ ra một vài điểm không hiệu quả của thuật toán

28
 CHƯƠNG 2 :THỰC NGHIỆM

Bài toán của chúng ta là sẽ xây dựng một hệ thống nhận dạng bàn tay để đoán ra các
ký tự mà người khuyết tật muốn nói. Ví dụ trong tiểu luận này tôi sẽ làm với 5 kí tự
sample là: V, L,E,F và B

Trong bảng thủ ngữ sau:

29
1.1 Phân tích hệ thống

a.Đường đi dữ liệu dự đoán.

Sử dụng Star UML để thể hiện đường đi dữ liệu cho mô hình train

Hình 19. Đường đi dữ liệu

b.Thiết kế hệ thống

Hình 20. Sơ đồ mô hình hệ thống từ train đến test

30
*Định nghĩa các biến

gestures = {'L_': 'L',

'fi': 'E',
'ok': 'F',
'pe': 'V',
'pa': 'B'
}

gestures_map = {

'E': 0,
'L': 1,
'F': 2,
'V': 3,
'B': 4
}
gesture_names = {

0: 'E',
1: 'L',
2: 'F',
3: 'V',
4: 'B'}
image_path = 'data'
models_path = 'models/saved_model1.hdf5'
rgb = False
imageSize = 224

2.1. Xử lý dữ liệu
a) Hàm xử lý ảnh resize về 224x224 và chuyển về numpy array
- Để chuyển đổi dữ liệu ta cần 1 hàm để gọi vào ở đây là(img):

Code:

def process_image(path):
img = Image.open(path)
img = img.resize((imageSize, imageSize))
img = np.array(img)
return img

31
b) Xử lý dữ liệu đầu vào
- Bắt đầu tạo hàm chuyển đổi dữ liệu để máy dễ nhận diện, chịa bộ khi đưa vào
làm X_data và y_data. Với X_data có kiểu dữ liệu là :’Float32’ và kích thước
là 224x224
- y_data là mảng chuyển đổi vectơ lớp(số nguyên) thành một ma trận nhị phân

Code:

def process_data(X_data, y_data):

X_data = np.array(X_data, dtype = 'float32')
if rgb:
pass
else:
X_data = np.stack((X_data,)*3, axis=-1)
X_data /= 255
y_data = np.array(y_data)
y_data = to_categorical(y_data)
return X_data, y_data

c) Hàm duyệt thư mục để train

- Dữ liệu muốn được train cần có 1 người kiểm duyệt để được xử lý và xác định
danh tính, ở đây người kiểm duyệt là hàm duyệt để thư hàm xử lý có thể xử lý
dữ liệu được đưa vào

Code:
def walk_file_tree(image_path):
X_data = []
y_data = []
for directory, subdirectories, files in os.walk(image_path):
for file in files:
if not file.startswith('.'):
path = os.path.join(directory, file)
gesture_name = gestures[file[0:2]]
print(gesture_name)
print(gestures_map[gesture_name])
y_data.append(gestures_map[gesture_name])
X_data.append(process_image(path))

else:
continue

32
 X_data, y_data = process_data(X_data, y_data)
return X_data, y_data

d) Load dữ liệu vào X,Y đi qua hàm duyệt

X_data, y_data = walk_file_tree(image_path)
2.2. Xây dựng mô hình training
Sau khi xử lý xong dữ liệu bắt đầu xử dụng mộ hình đã tìm hiểu ở phần nội dung để
cho máy có thể học và nhận diện.

a) Chia dữ liệu:
- Tôi chia dữ liệu với train và test theo tỷ lệ 80/20 với 80 là dữ liệu train và 20
với dữ liệu test
- Đối tượng điều khiển sự ngẫu nhiên trong quá trình tách là 12 và dùng y_data
để phân tần

Code:

X_train, X_test, y_train, y_test = train_test_split(X_data, y_data, test_size =

0.2, random_state=12, stratify=y_data)
b) Đặt các checkpoint
- Check point là điểm lưu của model khi dữ liệu đã train đi qua.

Code:

model_checkpoint = ModelCheckpoint(filepath=models_path,
save_best_only=True)
early_stopping = EarlyStopping(monitor='val_acc',
min_delta=0,
patience=10,
verbose=1,
mode='auto',
restore_best_weights=True)
c) Khởi tạo model
- Bắt đầu sử dụng model đã tìm hiểu ở phần lý thuyết để cấu tạo nên phần nơ-ron
thần kinh cho máy tính
- Và tối ưu nó bằng thuật toán Adam đã tìm hiểu ở chương trước

Code:

base_model = tf.keras.applications.VGG16(weights='imagenet',
include_top=False, input_shape=(imageSize,imageSize, 3))
tf.optimizers.Adam()
VGG16 = base_model

33
d) Thêm các lớp bên trên
- Thông thường để kiến trúc được mạng học sâu như VGG16 cần đến 6 lớp bao
gồm :

Cấu trúc VGG16

- Tuy nhiên do max pooling layer với size 2*2 chỉ có 224 nên ta chỉ cần lấy 2 lớp
pool 1/2 đầu tiên là size 224 và size 112 là đủ

Code:

x = base_model.output
x = Flatten()(x)
x = Dense(128, activation='relu', name='fc1')(x)
x = Dense(128, activation='relu', name='fc2')(x)
x = Dense(128, activation='relu', name='fc2a')(x)
x = Dense(128, activation='relu', name='fc3')(x)
x = Dropout(0.5)(x)
x = Dense(64, activation='relu', name='fc4')(x)

predictions = Dense(5, activation='softmax')(x)

model = Model(inputs=base_model.input, outputs=predictions)

e) Tiến hành training

- Đóng bănng các lớp dưới

Code:

for layer in base_model.layers:

layer.trainable = False
- Bắt đầu training model chú ý ở đây tôi chỉ training các dữ liệu mà trong data đã
có.

Code:

for layer in base_model.layers:

layer.trainable = False
model.compile(optimizer='Adam', loss='categorical_crossentropy', metrics=['accu-

34
racy'])
model.fit(X_train, y_train, epochs=50, batch_size=64, validation_data=(X_test,
y_test), verbose=1,
callbacks=[early_stopping, model_checkpoint])

f) Kiểm tra độ chính xác của phần mô hình sau khi train
- Sau khi training mô hình đạt được tỉ lệ chỉ số accuracy trên 0.6 và chỉ số
loss :0.2
- Ta có biểu đồ sau train:

Hình 21. Hình vẽ đường đi dữ liệu khi train

Code:

start = time()
x_train, X_test, y_train, y_test = process_data (X_data, y_data)
print('Loading:', time() - start)

classes = 5
batch = 128
epochs = 3
learning_rate = 0.0001

def results(model):
adam = Adam(lr=learning_rate)

model.compile(optimizer=adam, loss='categorical_crossentropy', metrics=['accu-

racy'])
start = time()
history = model.fit(x_train, y_train, batch_size=batch, epochs=epochs,
validation_split=0.1, shuffle=True, verbose=1)
train_time = time() - start

35
 model.summary()

plt.figure(figsize=(12, 12))
plt.subplot(3, 2, 1)
plt.plot(history.history['accuracy'], label='train_accuracy')
plt.plot(history.history['val_accuracy'], label='val_accuracy')
plt.xlabel('epoch')
plt.ylabel('accuracy')
plt.legend()
plt.subplot(3, 2, 2)
plt.plot(history.history['loss'], label='train_loss')
plt.plot(history.history['val_loss'], label='val_loss')
plt.xlabel('epoch')
plt.ylabel('accuracy')
plt.legend()
plt.show()

start = time()
test_loss, test_acc = model.evaluate(X_test, y_test)
test_time = time() - start
print('\nTrain time: ', train_time)
print('Test accuracy:', test_acc)
print('Test loss:', test_loss)
print('Test time: ', test_time)

2.3. Tạo giao diện phần mềm

Để có thể sử dụng được model đã training ta bắt đầu vào bước thiết kế trang giao diện
người dùng

Bước 1: Khai báo biến

prediction = ''
score = 0
bgModel = None

gesture_names = {0: 'E',

1: 'L',
2: 'F',
3: 'V',

36
 4: 'B'
}

Bước 2: Load model từ file đã train

model = load_model('models/mymodel.h5')

Bước 3: Tạo các hàm cần thiết

- Hàm predict để thông báo ký tự được nhận diện lên màn hình
def predict_rgb_image_vgg(image):
image = np.array(image, dtype='float32')
image /= 255
pred_array = model.predict(image)
print(f'pred_array: {pred_array}')
result = gesture_names[np.argmax(pred_array)]
print(f'Result: {result}')
print(max(pred_array[0]))
score = float("%0.2f" % (max(pred_array[0]) * 100))
print(result)
return result, score
- Hàm xóa nền khỏi ảnh
def remove_background(frame):
fgmask = bgModel.apply(frame, learningRate=learningRate)
kernel = np.ones((3, 3), np.uint8)
fgmask = cv2.erode(fgmask, kernel, iterations=1)
res = cv2.bitwise_and(frame, frame, mask=fgmask)
return res

Bước 4: Khai báo kích thước vùng nhận ảnh

cap_region_x_begin = 0.5
cap_region_y_end = 0.8

Bước 5: Các thông số lấy từ threshold

threshold = 60
blurValue = 41
bgSubThreshold = 50#50
learningRate = 0

Bước 6: Thiết lập camera máy tính

37
 camera = cv2.VideoCapture(0)
camera.set(10,200)
camera.set(cv2.CAP_PROP_AUTO_EXPOSURE, 0.01)

while camera.isOpened():.

a. Đọc ảnh từ webcam

ret, frame = camera.read()
b)Lam min anh
frame = cv2.bilateralFilter(frame, 5, 50, 100)
c. Lật ngang ảnh
frame = cv2.flip(frame, 1)

d. Vẽ khung hình chữ nhật vùng detection region

cv2.rectangle(frame, (int(cap_region_x_begin * frame.shape[1]), 0),
(frame.shape[1], int(cap_region_y_end * frame.shape[0])), (255, 0, 0), 2)

e. Nêu cả capture được nén

if isBgCaptured == 1:
f) Tach nen
img = remove_background(frame)

g. Lấy vùng detection

img = img[0:int(cap_region_y_end * frame.shape[0]),
int(cap_region_x_begin * frame.shape[1]):frame.shape[1]] # clip the ROI
h. Chuyển về đen trắng
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(gray, (blurValue, blurValue), 0)

cv2.imshow('original1', cv2.resize(blur, dsize=None, fx=0.5, fy=0.5))

ret, thresh = cv2.threshold(blur, threshold, 255, cv2.THRESH_BINARY +

cv2.THRESH_OTSU)

cv2.imshow('thresh', cv2.resize(thresh, dsize=None, fx=0.5, fy=0.5))

if (np.count_nonzero(thresh)/(thresh.shape[0]*thresh.shape[0])>0.2):
# Neu nhu ve duoc hinh ban tay
if (thresh is not None):
# Dua vao mang de predict
target = np.stack((thresh,) * 3, axis=-1)

38
 target = cv2.resize(target, (224, 224))
target = target.reshape(1, 224, 224, 3)
prediction, score = predict_rgb_image_vgg(target)

# Neu probality >

print(score,prediction)
if (score>=predThreshold):
cv2.putText(frame, "Sign:" + prediction, (20, 150), cv2.FONT_HER-
SHEY_SIMPLEX, 3,
(0, 0, 255), 10, lineType=cv2.LINE_AA)
thresh = None

Bước 7:Xử lý phím bấm

k = cv2.waitKey(10)
if k == ord('q'):
break
elif k == ord('b'):
bgModel = cv2.createBackgroundSubtractorMOG2(0, bgSubThreshold)

isBgCaptured = 1
cv2.putText(frame, "Background captured", (20, 150), cv2.FONT_HER-
SHEY_SIMPLEX, 3,
(0, 0, 255), 10, lineType=cv2.LINE_AA)
time.sleep(2)
print('Background captured')

elif k == ord('r'):

bgModel = None
isBgCaptured = 0
cv2.putText(frame, "Background reset", (20, 150),
cv2.FONT_HERSHEY_SIMPLEX, 3,
(0, 0, 255),10,lineType=cv2.LINE_AA)
print('Background reset')
time.sleep(1)

cv2.imshow('original', cv2.resize(frame, dsize=None, fx=0.5, fy=0.5))

39
 cv2.destroyAllWindows()
camera.release()

Từ các bước trên ta có 1 giao diện như sau:

Hình 22 .Giao diện phần mềm sau khi hoàn thành

Hình 23a. Kết quả đạt được

Phần mềm có thể nhận diện được 5 cử chỉ tay đã được khai báo biến gồm 5 chữ L,
E,B,V và E gồm:

Hình 23b. Các cử chỉ máy nhận diện được

40
 CHƯƠNG 3 : KẾT LUẬN

Tổng quan : Phần mềm cơ bản có thể nhân diện được 5 ký tự tay trong bản chữ cái
của người khuyết tật, sử dụng đơn giản dễ dàng.

3.1. Đánh giá về cơ sở lý thuyết trong nghiên cứu

Qua nghiên cứu giúp tôi nắm bắt được cấu trúc mạng nơ ron trong “neural network”
và bộ mô hình “CNN” đặc biệt là mô hình VGG16 trong học máy, hiểu được các
phân lớp nền và các quá trình dữ liệu được học qua các lớp. Ngoài ra còn có thể cơ
bản năm được một vài vấn đề từ các thuật toán liên quan đến trí tuệ con người, từ
những nghiên cứu và thực nghiệm trên có thể áp dụng vào nhiều lĩnh vực khác đòi hỏi
sự chính xác cáo mà con người khó có thể làm được

3.2. Đánh giá về phần mô hình sau khi train.

Mô hình đạt được chỉ số chính xác như mong đơi, không xảy ra vấn đề gì khi train, dễ
dàng sử dụng cũng như lưu trữ.

3.3. Đánh giá phần mềm.

Phần mềm cơ bản có thể nhận ra được ít nhất 5 cử chỉ của người khuyết tật, có các
khung vẽ rõ ràng cho người sử dụng, thể hiện cả ảnh sau khi chuyển đổi qua camera
và ảnh đã xóa nền của máy. Giúp cho người dùng có thể hiểu được người khuyết tật
cần gì thông qua cử chỉ tay

3.4. Điểm hạn chế.

Phần mềm tuy nhận ra được cử chỉ tay, nhưng giao diện chưa tối ưu, dễ bị ngoại cảnh
ảnh hưởng. Dữ liệu còn thô sơ, chưa sát với thực tế, cần cãi thiện CSDL để hoàn thể
phần mềm đầy đủ, mô hình train chưa tối ưu, thời gian train còn chậm, trong thời gian
train làm lãng phí tài nguyên.

3.5.Hướng phát triển phần mềm

Phần mềm có thể thay người phiên dịch để có thể hiểu và dịch 1 cách chính xác thủ
ngữ của người khuyết tật. Ngoài ra còn có thể ứng dụng với các thiết bị nhà thông
minh để ra lệnh bằng cử chỉ tay thay vì lời nói.

Tài Liệu tham khảo

Ở bài báo cáo này tôi đã tìm hiểu thủ ngữ thông qua “Wikipedia”, tìm kiếm dữ liệu
ảnh thông thông qua Kaggle, thuật toán được tìm hiểu thông qua trang “quantri-

41
mang.org” và nhiều bài viết khác. Và tham khảo các bài viết, nghiên cứu tương tự trên
Gifhub.

-Các hình được lấy ở trang quantrimang.vn

-Thuật toán được tham khảo trên hand-gesture-recognition-database-with-cnn.com

- Các thông tin khác lấy trên các bài báo cáo của các nhóm nghiêm cứu thuộc Đại
học quốc gia Hồ Chí Minh và Hà Nội

42
4
3