Nhận diện phương tiện ô tô | Báo cáo giữa kì môn Học sâu (deep learning) | Trường Đại học Phenikaa

TRƯỜNG ĐẠI HỌC PHENIKAA
Khoa Điện – Điện tử
BÁO CÁO GIỮA KÌ MÔN HỌC SÂU
Đề tài: Nhận diện phương tiện ô tô Giảng viên hướng dẫn: TS.Lê Minh Huy Sinh viên thực hiện : Bùi Thị Huệ - 21012923
Trần Sơn Dương - 21011224
Hà Nội, tháng 05 năm 2024 MỤC LỤC
MỞ ĐẦU ............................................................................................................... 1
1.Lý do chọn đề tài ............................................................................................ 1
2.Mục đích của đề tài ......................................................................................... 1
3.Ý nghĩa khoa học và thực tiễn ........................................................................ 1
I. TỔNG QUAN TÀI LIỆU NGHIÊN CỨU ......................................................... 3
1.1. Mạng neural là gì? ...................................................................................... 3
1.2. Đặc điểm của Mạng neural ......................................................................... 3
1.3. Kiến trúc mạng neural ................................................................................. 3
1.4. Hàm Activation ........................................................................................... 5
II. XÂY DỰNG THUẬT TOÁN ........................................................................... 8
2.1.Thu thập dữ liệu ........................................................................................... 8
2.2.Loading data................................................................................................. 8
2.3. Parts of algorithm ...................................................................................... 13
2.3.1. Hàm sigmoid ...................................................................................... 13
2.3.2. Hàm ReLU ......................................................................................... 14
2.3.3. Hàm initialize_parameters_deep ....................................................... 14
2.3.4. Hàm L_model_forward ...................................................................... 15
2.3.5. Hàm compute_cost ............................................................................ 16
2.3.6. Hàm L_model_backward ................................................................... 16
2.3.7. Hàm update_parameters .................................................................... 17
2.3.8. Hàm predict ........................................................................................ 17
2.4. Training Model ......................................................................................... 18
2.5.Kết quả của mô hình .................................................................................. 20
2.6.Thử nghiệm kết quả ................................................................................... 21
III. LINKS ............................................................................................................ 23
IV. TÀI LIỆU THAM KHẢO .............................................................................. 24 DANH MỤC HÌNH ẢNH
Hình 1: Cấu trúc mạng lưới thần kinh 4
Hình 2: Activation Function..................................................................................5
Hình 3: Một số hàm Activation phổ biến..............................................................6
Hình 4: Mạng Neural có 1 Hidden Layer..............................................................7
Hình 5: Tính toán đầu ra của các Hidden Layer bằng hàm Sigmoid.....................7
Hình 6: Hàm Forward và Backward......................................................................7
Hình 7: Kích thước hình ảnh ban đầu....................................................................9
Hình 8: Kích thước hình ảnh sau khi chuyển đổi................................................10
Hình 9 : Biểu đồ cost theo số lần lặp...................................................................20
Hình 10: Kết quả dự đoán hình ảnh ô tô..............................................................21
Hình 11: Kết quả hiển thị không phải xe ô tô......................................................22
Hình 12: Kết quả hiển thị sai với ảnh có ô tô......................................................23 LỜI NÓI ĐẦU
Ngày nay, khoa học kĩ thuật, công nghệ thông tin, tự động hóa và phát triển
tiến bộ không ngừng. Và đang được phát triển mạnh mẽ trên mọi mặt của đời sống
của con người. Học sâu (deep learning) được coi là một lĩnh vực có tính ứng dụng
quan trọng trong đời sống.
Hiện nay, các công nghệ liên quan đến hình ảnh ngày càng nhiều, khối
lượng xử lý ngày càng lớn, đòi hỏi chúng ta cần phải có cách thứ xử lý lượng ảnh
đó hiệu quả nhất. Vì vậy nhóm sinh viên chúng em quyết định thực hiện dự án
“Nhận diện phương tiện ô tô”.
Do kiến thức còn hạn hẹp và thời gian chuẩn bị không có nhiều nên bài tập lớn
của chúng em còn nhiều thiếu sót. Chúng em mong sự ghi nhận đóng góp và sửa
chữa của các thầy để đề tài này để có thể được hoàn thiện hơn.
Chúng em xin chân thành cảm ơn, Thầy Lê Minh Huy đã hướng dẫn giúp chúng
em hoàn thành được đề tài này! MỞ ĐẦU
1.Lý do chọn đề tài
Thuật toán nhận diện là một phần của lĩnh vực trí tuệ nhân tạo và xử lý hình ảnh,
được sử dụng để tự động nhận biết và phân loại các đối tượng trong hình ảnh hoặc
video. Có nhiều thuật toán khác nhau được phát triển để giải quyết vấn đề này, từ
các phương pháp cơ bản như phát hiện biên đến các mô hình học sâu phức tạp như
mạng nơ-ron sâu (deep neural networks). Các thuật toán nhận diện thường được
sử dụng trong nhiều ứng dụng như nhận diện khuôn mặt, nhận diện vật thể, nhận
diện biển số xe, và nhiều ứng dụng khác trong thực tế.
Công nghệ nhận diện hình ảnh đã và đang được áp dụng rộng rãi trong nhiều lĩnh
vực như giao thông, an ninh, và thương mại điện tử. Việc phân biệt ô tô (car) và
không phải ô tô (non-car) là một trong những ứng dụng cơ bản và thiết thực của
công nghệ này.Với sự gia tăng nhanh chóng của phương tiện giao thông, việc phân
biệt và nhận diện ô tô một cách tự động là rất quan trọng. Nó giúp cải thiện hiệu
quả của các hệ thống giám sát giao thông, quản lý bãi đỗ xe và hỗ trợ trong các hệ thống xe tự lái.
2.Mục đích của đề tài -
Phát triển một mô hình hiệu quả để phân biệt ô tô và không phải ô tô. Xây
dựngvà huấn luyện một mô hình mạng nơ-ron có khả năng phân loại chính xác
hình ảnh giữa ô tô và các đối tượng khác. -
Đánh giá hiệu suất và khả năng ứng dụng thực tế của mô hình. Đo lường
độchính xác, độ nhạy, và độ đặc hiệu của mô hình để đảm bảo rằng nó có thể được
triển khai trong các hệ thống thực tế với độ tin cậy cao. -
Nâng cao kiến thức và kỹ năng trong lĩnh vực học sâu và xử lý hình ảnh.
Thôngqua việc thực hiện đề tài này, người thực hiện có thể nâng cao kiến thức và
kỹ năng trong các công nghệ học sâu (deep learning) và xử lý hình ảnh (image processing).
3.Ý nghĩa khoa học và thực tiễn -
Ứng dụng trong các hệ thống giám sát và an ninh: Mô hình phân biệt ô tô
vàkhông phải ô tô có thể được sử dụng trong các hệ thống giám sát giao thông,
phát hiện và nhận diện phương tiện trong thời gian thực. 1 -
Hỗ trợ cho các hệ thống xe tự lái và bãi đỗ xe thông minh: Kết quả từ đề tài
nàycó thể được áp dụng để cải thiện độ chính xác và hiệu quả của các hệ thống xe
tự lái và quản lý bãi đỗ xe thông minh. -
Giảm thiểu chi phí và nâng cao hiệu quả: Việc sử dụng mô hình tự động
đểphân biệt ô tô giúp giảm thiểu sự phụ thuộc vào lao động thủ công, từ đó giảm
thiểu chi phí và nâng cao hiệu quả hoạt động. 2
I. TỔNG QUAN TÀI LIỆU NGHIÊN CỨU
1.1. Mạng neural là gì?
Mạng neural là một mạng lưới thần kinh nhân tạo. Đây là một chuỗi các thuật toán
tìm kiếm mối quan hệ trong một tập hợp dữ liệu hệ thống dựa trên cách thức hoạt
động của bộ não con người1.
Mạng nơ-ron nhân tạo được coi là hệ thống kết nối các nơ-ron nhân tạo trong tự
nhiên hoặc hữu cơ. Mạng nơ-ron thích ứng với mọi điều chỉnh từ đầu vào, mang
lại đầu ra tốt nhất. Khái niệm này xuất phát từ lĩnh vực trí tuệ nhân tạo, phổ biến
trong hệ thống giao dịch điện tử hiện nay.
1.2. Đặc điểm của Mạng neural. •
Mạng neural hoạt động giống như tế bào thần kinh trong não người. Trong
đó, mỗi nơ-ron là một hàm toán học, có nhiệm vụ thu thập, phân loại dữ liệu, thông
tin theo một cấu trúc chi tiết. •
Mạng nơ-ron tương tự như phương pháp thống kê theo đồ thị đường cong
hoặc phân tích hồi quy. Để giải thích đơn giản nhất, hãy tưởng tượng một mạng
nơ-ron bao gồm các nút mạng được kết nối với nhau. •
Mỗi nút là một tập hợp các nhận thức, có cấu trúc tương tự như hàm hồi
quy đa tuyến tính, được sắp xếp liên kết với nhau. Các lớp này sẽ thu thập thông
tin, sau đó phân loại và đưa ra tín hiệu đầu ra tương ứng.2
1.3. Kiến trúc mạng neural.
Mỗi mạng nơ-ron nhân tạo là một Perceptron nhiều lớp, Mạng nơ-ron thường bao
gồm 3 loại lớp khác nhau:
• Input Layer : nằm ở phía bên trái của hệ thống, bao gồm dữ liệu thông tin đầu vào.
• Output Layer : nằm ở phía bên phải của hệ thống, bao gồm thông tin dữ liệu đầu ra.
• Hidden Layer: nằm ở giữa, thể hiện quá trình suy luận và xử lý thông tin của hệ thống.
1 [NN] Mạng nơ-ron nhân tạo - Neural Networks (viblo.asia) , [NN] Mạng nơ-ron nhân tạo - Neural Networks
2 [NN] Mạng nơ-ron nhân tạo - Neural Networks (viblo.asia) , [NN] Mạng nơ-ron nhân tạo - Neural Networks 3
Lưu ý: Mỗi Mạng neural chỉ có một Input Layer và Output Layer nhưng sẽ có nhiều Hidden Layer
Hình 1: Cấu trúc của mạng lưới thần kinh
Mỗi nút trong Mạng nơ-ron là một Sigmoid neural. Thông thường các nút mạng
này sẽ có chức năng kích hoạt khác nhau nhưng hiện tại đang áp dụng thuật toán
thống nhất để dễ vận hành hơn .
Ở mỗi layer, số lượng sigmoid neural khác nhau tùy thuộc vào cách xử lý dữ liệu.
Trong quá trình hoạt động, mô hình sẽ sử dụng các hidden layer với số lượng khác
nhau tùy thuộc nhu cầu của người thiết lập
Các neural ở các layer khác nhau cũng sẽ kết nối với nhau để tạo thành mạng lưới
chặt chẽ và hoàn chỉnh nhất. Sau đó, người dùng sẽ biết kích thước của network
dựa trên số lượng các layer và số lượng neural.
Các nút mạng kết hợp theo một hướng duy nhất từ Input Layer vào đến Output
Layer . Mỗi nút trong một layer sẽ nhận được thông tin về các ghi chú của layer trước đó.3
3 [NN] Mạng nơ-ron nhân tạo - Neural Networks (viblo.asia) , [NN] Mạng nơ-ron nhân tạo - Neural Networks 4 1.4. Hàm Activation
Hàm Activation là một thành phần rất quan trọng của mạng neural. Nó quyết định
khi nào một tế bào thần kinh được kích hoạt hay không. Điều này có nghĩa là hàm
Activation xác định xem thông tin mà nơ-ron nhận được có liên quan và nên được
truyền đến đầu ra hay không. Hình 2: Activation Function
Hàm Activation là một phép biến đổi phi tuyến tính mà chúng ta thực hiện trên tín
hiệu đầu vào của nơ-ron. Đầu ra đã được biến đổi này sẽ được sử dụng làm đầu
vào cho nơ-ron ở lớp tiếp theo. Nếu không có hàm kích hoạt, các trọng số và độ
lệch chỉ đơn giản tạo thành một phép biến đổi tuyến tính. Mặc dù việc giải một
hàm tuyến tính sẽ đơn giản hơn, nhưng nó không đủ khả năng mô hình hóa và giải
quyết các bài toán phức tạp.
Mạng nơ-ron không có hàm kích hoạt thực chất chỉ là một mô hình hồi quy tuyến
tính, và không thể thực hiện các nhiệm vụ phức tạp như dịch ngôn ngữ hoặc phân
loại hình ảnh. Do đó, hàm kích hoạt là cần thiết để mạng nơ-ron có thể học và mô
hình hóa các mối quan hệ phi tuyến trong dữ liệu, giúp giải quyết các bài toán phức tạp.
Hàm Activation hỗ trợ quá trình lan truyền ngược bằng cách cung cấp các lỗi để
các trọng số và độ lệch có thể được cập nhật, giúp mô hình tự điều chỉnh.4
4 Các hàm kích hoạt (activation function) trong neural network (aicurious.io) , Các hàm kích hoạt (activation
function) trong neural network 5
Hình 3: Một số hàm Activation phổ biến Cách chọn hàm activation:
- Hàm sigmoid và các kết hợp của chúng thường phù hợp cho các bài toán phân loại.
- Đôi khi nên tránh sử dụng Sigmoid và Tanh vì chúng có thể gây ra hiện tượng mất gradient.
- ReLU là một trong những hàm kích hoạt phổ biến và được sử dụng rộng rãi
nhất hiện nay. Nếu có trường hợp có các nơ-ron chết trong mạng, thì Leaky
ReLU là một lựa chọn hoàn hảo.
- Hàm ReLU chỉ có thể được sử dụng trong các hidden layer.5
Hình 4: Mạng Neural có 1 Hidden Layer
5 Các hàm kích hoạt (activation function) trong neural network (aicurious.io) , Các hàm kích hoạt (activation
function) trong neural network 6
Hình 5: Tính toán đầu ra của các Hidden Layer bằng hàm Sigmoid
Hình 6: Hàm Forward và Backward 7
II. XÂY DỰNG THUẬT TOÁN
2.1.Thu thập dữ liệu
Tập dữ liệu chúng ta cần tạo bao gồm các thư mục hình ảnh: train_car và test_car.
Thư mục train_car và test_car đều chứa 2 tập dữ liệu con gồm car và non_car.
Bộ dữ liệu này sẽ được sử dụng trong thuật toán khai thác dữ liệu để nhận diện ô
tô. Thuật toán sẽ được đào tạo trên các đặc điểm nhận diện này để có thể đưa ra
dự đoán về phương tiện ô tô.
Thư mục test_car cũng chứa 2 thư mục con có tên car và non_car, tương tự như
train_car nhưng với kích thước nhỏ hơn vài lần. Dữ liệu này sẽ được sử dụng để
kiểm tra độ chính xác của các dự đoán từ thuật toán, giúp chúng tôi thực hiện các
điều chỉnh cần thiết để tăng độ chính xác cho các dự đoán của thuật toán. 2.2.Loading data
Tải hai tập dữ liệu lên Google Drive: Sử dụng lệnh để truy cập Google Drive
from google.colab import drive drive.mount('/content/drive')
Điều hướng truy cập đến thư mục cửa dự án
cd /content/drive/MyDrive/Mid_term
Nhập các thư viện cần thiết để có thể truy cập, đọc và hiển thị thông tin của tập dữ liệu: import time import numpy as np import matplotlib.pyplot as plt import scipy from PIL
import Image from scipy import ndimage import os import random import cv2
Truy cập vào các tệp Dữ liệu được tải lên Google Drive:
train_car="/content/drive/MyDrive/Mid_term/dataset/train_car"
test_car="/content/drive/MyDrive/Mid_term/dataset/test_car"
Đọc dữ liệu từ tập dữ liệu: 8
CLASSES = ['non-car','car'] # tên của các folder con trong tập DATA TRAIN và TEST
for classes in CLASSES: # truy cập lần lượt vào các ảnh trong DATA
path = os.path.join(train_car, classes)
path1 = os.path.join(test_car, classes)
for img in os.listdir(path): # đọc các ảnh trong trong tập TRAIN
img_array = cv2.imread(os.path.join(path,img), cv2.IMREAD_COLOR)
for img in os.listdir(path1): # đọc các ảnh trong tập Test
img_array_test =cv2.imread(os.path.join(path1,img), cv2.IMREAD_COLOR)
Truy cập và hiển thị hình ảnh bất kì trong file DATA
for classes in CLASSES : path =
os.path.join(train_car, classes); for img in os.listdir(path): img_array =
cv2.imread(os.path.join(path,img),cv2.IMREAD_COLOR) plt.imshow(img_array) plt.show() print(img_array.shape) break break
Hình 7: Kích thước hình ảnh ban đầu
Một bộ DATA được tạo ra bao gồm nhiều hình ảnh và kích thước khác nhau nên
chúng ta phải đưa các hình ảnh về cùng kích thước: 9
demention = 64 # đặt kích thước của ảnh là 64
new_img = cv2.resize(img_array,(demention,demention)) # sử dụng
lệnh resize để đưa về kích thước mong muốn
new_img_test=cv2.resize(img_array_test,
(demention,demention))################++++++++++++++++++++++
plt.imshow(new_img) # hiển thị ảnh sau khi đã thay đổi kích thước plt.show print(new_img.shape) print(new_img_test.shape)
Hình 8: Kích thước hình ảnh sau khi chuyển đổi
Tạo lại các thư mục training_data và test_data bao gồm các hình ảnh đã được thay đổi kích thước: TRAINNING_DATA: training_data =[] def
creat_training_data(): for classes in
CLASSES: path = os.path.join(train_car, classes);
class_num = CLASSES.index(classes) # label của các ảnh: 0 and 1 t print(class_num)
for img in os.listdir(path): try:
img_array = cv2.imread(os.path.join(path,img), cv2.IMREAD_COLOR)
new_img = cv2.resize(img_array,(demention,demention))
training_data.append([new_img, class_num]) except Exception as e: pass creat_training_data() TESTTING_DATA: 10 testting_data =[] def
creat_testting_data(): for category in
CATEGORY: path1 = os.path.join(test_car, category); class_num_test = CATEGORY.index(category) print(class_num_test)
for img in os.listdir(path1): try:
img_array_test = cv2.imread(os.path.join(path1,img), cv2.IMREAD_COLOR)
new_img_test = cv2.resize(img_array_test, (demention,demention))
testting_data.append([new_img_test,
class_num_test]) except Exception as e: pass creat_testting_data()
Xáo trộn dữ liệu trong Data set: import random
random.shuffle(trainning_data) random.shuffle(testting_data) for sample in trainning_data:
print(sample[1]) #in ra danh sách label sau khi đã xáo trộn
for sample in trainning_data: print(sample[0]) #in ra danh
sách feature sau khi đã xáo trộn
Tách dữ liệu hình ảnh và nhãn từ hai tập dữ liệu trainning_data và testting_data,
sau đó lưu chúng vào các danh sách riêng biệt để chuẩn bị cho việc huấn luyện và kiểm tra mô hình: X_train = [] #
Y_train = [] for image, label in trainning_data:
X_train.append(image) # tạo tập feature của Y_train.append(label) X_test = [] Y_test = []
for image, label in testting_data: X_test.append(image) Y_test.append(label)
Chuyển đổi các danh sách chứa dữ liệu huấn luyện và kiểm tra thành các mảng
NumPy và in ra kích thước của các mảng này: 11 import numpy as np
# Chuyển đổi danh sách thành mảng NumPy train_X = np.array(X_train) test_X = np.array(X_test) print(train_X.shape) print(test_X.shape) test_Y = np.array(Y_test) print(test_Y.shape) train_Y = np.array(Y_train) print(train_Y.shape)
Thay đổi hình dạng của các mảng nhãn “ train_Y” và “test_Y”:
train_y = train_Y.reshape((1, -1)) print(train_y.shape) #(1,292)
#*****************************************##########
test_y = test_Y.reshape((1,-1)) print(test_y.shape) #(1,63)
Hiển thị tập dữ liệu của mô hình: m_train = train_X.shape[0] num_px = train_X.shape[1] m_test = test_X.shape[0]
print("Number of training examples: " + str(m_train))
print("Number of testing examples: " + str(m_test))
print("Each image is of size: (" + str(num_px) + ", " + str(num_px) + ", 3)")
print("train_x shape: " + str(train_X.shape))
print("train_y shape: " + str(train_y.shape))
print("test_x shape: " + str(test_X.shape))
print("test_y shape: " + str(test_y.shape))
Cấu hình và chuẩn hóa lại dữ liệu đầu vào: 12
# Reshape the training and test examples
train_x_flatten = train_X.reshape(train_X.shape[0], -1).T
test_x_flatten = test_X.reshape(test_X.shape[0], -1).T train_x = train_x_flatten/255 test_x = test_x_flatten/255
print ("train_x's shape: " + str(train_x.shape))
print ("test_x's shape: " + str(test_x.shape))
2.3. Parts of algorithm
Thuật toán sẽ được xây dựng từ các phần sau:
• Thiết lập HÀM sigmoid.
• Không đồng bộ hóa các giá trị trọng số (Weight) và tham số b ban đầu.
• Tính toán giá trị hàm cost với các tham số weight và b được khởi tạo.
• Cập nhật các giá trị weight và b cho đến khi hàm giá trị được tối ưu. • Tạo dự đoán.
• Kiểm tra độ chính xác so với các tập train_car và test_car. 2.3.1. Hàm sigmoid def sigmoid(Z): """
Implements the sigmoid activation in numpy Arguments:
Z -- numpy array of any shape Returns:
A -- output of sigmoid(z), same shape as Z
cache -- returns Z as well, useful during backpropagation """ A = 1/(1+np.exp(-Z)) cache = Z return A, cache 13 2.3.2. Hàm ReLU def relu(Z): """ Implement the RELU function. Arguments:
Z -- Output of the linear layer, of any shape Returns:
A -- Post-activation parameter, of the same shape as Z
cache -- a python dictionary containing "A" ; stored for computing the backward pass efficiently """ A =
np.maximum(0,Z) assert(A.shape == Z.shape) cache = Z return A, cache
2.3.3. Hàm initialize_parameters_deep
Khởi tạo các tham số của mạng neural, bao gồm trọng số (weights) và tham số bias (b)
def initialize_parameters_deep(layer_dims): """
Arguments: layer_dims -- python array (list) containing
the dimensions of each layer in our network
Returns: parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL":
Wl -- weight matrix of shape (layer_dims[l], layer_dims[l-1])
bl -- bias vector of shape (layer_dims[l], 1) """ np.random.seed(1) parameters = {}
L = len(layer_dims) # number of layers in the network
for l in range(1, L): parameters['W' + str(l)] =
np.random.randn(layer_dims[l],
layer_dims[l-1]) / np.sqrt(layer_dims[l-1]) #*0.01
parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))
assert(parameters['W' + str(l)].shape == (layer_dims[l], 14