thị giác máy tính nhận diện kí tự

Tóm Tắt Bài tập lớn sẽ tập trung vào giải thuật Convolution Neural Network CNN để nhận diện kí tự.. OpenCV sẽ dùng để tiền xử lý ảnh ngõ vào trước khi cho vào mạng neural... Lớp Convolut

ĐẠI HỌC QUỐC GIA TP.HỒ CHÍ MINH

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

Nguyễn Hữu Tài - 1413371

TP HỒ CHÍ MINH, 4 THÁNG 12 NĂM 2017

Tóm Tắt

Bài tập lớn sẽ tập trung vào giải thuật Convolution Neural Network (CNN) để nhận diện kí tự Kí tự bao gồm từ 0-9, a-z và A-Z OpenCV sẽ dùng để tiền xử lý ảnh ngõ vào trước khi cho vào mạng neural

Mục Lục

1 Giới thiệu 4

2 Lý thuyết 4

2.1 Deep neural network 4

2.2 Convolution neural network 7

2.3 Thuật toán cải thiện hiệu năng 9

3 Giải thuật 11

3.1 Tạo ảnh huấn luyện 11

3.2 Cấu trúc mạng CNN 13

3.3 Hàm cost 15

3.4 Thuật toán 16

4 Kết quả 24

5 Tài liệu tham khảo 26

1 Giới thiệu

Nhận diện kí tự được dùng phổ biến rộng rãi ngày nay, đặc biệt là ứng dụng vào OCR(Optical Character Recognition) Với OCR, con người không cần phải đánh văn bản hay nhập dữ liệu từ 1 văn bản hay đoạn văn, thay vào đó OCR sẽ giúp trích xuất dữ liệu hình ảnh khi quét văn bản và tự động tạo ra văn bản y chang trên máy tính

Có nhiều phương pháp để nhận diện kí tự bao gồm PCA(Principal Component analysis), LDA(Linear Discriminant Analysis), DNN(Deep Neural Network) hay CNN(Convolutional Neural Network) Trong bài báo cáo này, CNN sẽ được dùng làm phương pháp chính cho nhận diện kí tự vì độ chính xác cao và khả năng nhận dạng được nhiều vật thể Thuật toán này hiện nay đang được phát triển và nghiên cứu rất nhiều trên thế giới cho nên việc dùng phương pháp này vào nhận diện kí tự

là 1 hướng đi đúng đắn

2 Lý thuyết

2.1 Deep neural network

Neuron network mô phỏng mạng thần kinh neural giống như bộ não của con người Mỗi neuron tiếp nhận tín hiệu từ các neuron khác và xử lý đặc trưng theo từng neuron

đó và xuất ra kết quả cho các neuron khác để tiếp tục xử lý

Hình 1 Mạng neuron điển hình 2 lớp

Mạng neuron này gồm 3 lớp Lớp ngõ vào, một lớp ẩn và lớp ngõ ra Ngõ vào gồm

3 đơn vị (unit), lớp ẩn gồm 3 unit và lớp ngõ ra chỉ có 1 unit

Ta đặt ( ) là “activation” của unit i tại lớp j, ( ) là ma trận hệ số chuyển từ lớp j sang lớp j+1 Ta có giá trị của các nút như sau:

Ta kí hiệu ℎ ( ) là ngõ ra của kth trong vector y

Số hạng đầu tiên là tổng của tất cả các node trong ngõ ra từ k = 1 -> K

Số hạng thứ 2 là dùng cho regularization Tổng đầu tiên là lặp tất cả các theta trong mạng neuron, tổng thứ 2 và 3 là lặp lại các phần tử theta để cộng lại

Thuật toán backpropagation

Forward propagation

Hình 2 Mạng neuron sâu

Ta sẽ dùng forward propagation trong backpropagation

Ta làm theo các bước sau

Thuật toán backpropagation làm minimize hàm cost

Đặt ( ) = “sai số” của node j tại lớp l

Với mỗi node trong output y ( lớp 4 như hình trên)

( )

= ( )−

( ) = ( ) ( ) ∗ .∗ (1 − )

Dùng thuật toán forward propagation để tính a(l)

Từ y(t) tính ngược lại ( ), ( ), … , ( )

2.2 Convolution neural network

Convolution trong ảnh nghĩa là tích chập Tích chập 2 ảnh với nhau theo cách sau

và lớp ngõ ra

Lớp Convolution sẽ dùng 1 mặt nạ ảnh có kích thước (nw,nh,nc,nc0), nw và nh là chiều rộng và chiều cao của ảnh ngõ vào, nc là chiều sâu của ngõ vào, nc0 là chiều sâu của mặt nạ Lớp Convolution sẽ giảm kích cỡ của ảnh ngõ vào đi theo công thức

Với nh, nw là chiều rộng và chiều cao của ngõ vào, p là số padding(padding tức thêm

0 vào các bên của ảnh ngõ vào), f là kích thước của mặt nạ, và s là stride (stride là

số trượt của mặt nạ trên ảnh)

Lớp Pooling có chức năng sẽ làm giảm kích cỡ của ngõ vào giống như lớp Convolution, đồng thời trích xuất được đặc trưng của ảnh Như trong hình, avg pool

sẽ lấy trung bình các giá trị của ảnh mà nó chọn Thông thường, lớp pooling phổ biến là lớp max pooling, tức lấy giá trị lớn nhất của ngõ vào, loại bỏ các giá trị nhỏ

đi

Lớp Full Connected(FC) như bên phần Deep Neural Network, ngõ vào FC sẽ phải lấy tất cả các pixels của ảnh ngõ vào và trải thành 1 cột Lớp FC cuối cùng sẽ có tổng ngõ ra bằng với số lớp cần nhận dạng Lớp FC sẽ áp dụng forward propagation

và back-propagation để học các weights giữa các lớp

2.3 Thuật toán cải thiện hiệu năng

a Bộ dữ liệu Train/Test

Khi sử dụng mạng neural network làm phương pháp nhận diện, ta phải có 2 bộ dữ liệu chính là tập huấn luyện và tập kiểm tra 2 tập này được chia theo 90%/10% của tổng bộ dữ liệu Có 2 bộ này để ta có thể kiểm tra được độ chính xác của thuật toán, kiểm tra được bias và variance, sau đó có thể hiệu chỉnh được các thông số của cả

hệ thống

b Bias và Variance

Bias và Variance là 2 thuật ngữ chỉ sai số của thuật toán Khi thuật toán dự đoán không chính xác thì hiện tượng bias xảy ra, khi thuật toán dự đoán rất chính xác tập

dữ liệu huấn luyện thì hiện tượng variance xảy ra

Hình 4 Hiện tượng bias

Khi hiện tượng bias xảy ra như trong hình thì ta thấy đường dự đoán không chia được chính xác 2 vùng miền đỏ và đen

Hình 5 HIện tượng variance Khi hiện tượng variance xảy ra thì ta thấy đường dự đoán chính xác 2 vùng miền Tuy nhiên, khi cho giá trị mới vào thì sẽ chưa chắc dự đoán đúng được vì ta chỉ đang thực hiện trên tập huấn luyện chứ chưa thực hiện được tổng quát nhất

Hình 6 Dự đoán hợp lý nhất Khi thuật toán không chịu bias hoặc variance thì sẽ cho ta ra kết quả hợp lý nhất, gọi

là just right Mặc dù với mẫu thử có 1 vài sai số nhưng nó sẽ là tổng quan nhất cho tất cả các mẫu dữ liệu

c Regularization

Regulariazation là 1 phương pháp để tránh High variance Regularization sẽ áp dụng vào hàm Cost và hệ số weights của mạng CNN và DNN

keep_prob và thường dao động trong khoảng 0.5 – 0.9

3 Giải thuật

3.1 Tạo ảnh huấn luyện

Ảnh huấn luyện gồm 62 chữ cái từ 0-9, a-z và A-Z, mỗi ảnh có kích thước là 128x128, định dạng png, nền trắng, chữ đen Mỗi kí tự trung bình có trên 3000 ảnh, được lấy từ nguồn https://www.nist.gov/srd/nist-special-database-19

Hình 8 62 thư mục chứa bộ ảnh huấn luyện

Sau khi có được ảnh huấn luyện, ta sẽ chạy file load_data.py để lấy ảnh huấn luyện

và lưu vào 1 file, chỉ toàn hệ số của ảnh đã được tối ưu hóa

Đoạn code load_data

training_files = int(90/100 * total_files)

test_files = total_files - training_files

else:

training_files = int(90/100 * 2000)

test_files = 2000 - training_files

lim = 0

for file_name in os.listdir(path):

tva = imageprepare(path + '/' + file_name)

input_image = np.array(tva)

return training_inputs, training_outputs, test_inputs, test_outputs

Đoạn code trên sẽ lấy 2000 mẫu của mỗi kí tự, 90% sẽ làm training và 10% để làm test Trước khi ảnh được lưu vào file tương ứng, ảnh sẽ được resize thàng 32x32, đồng thời, giá trị pixel được chuẩn hóa từ 0 đến 1

Mạng CNN bao gồm 2 lớp Convolution, 2 lớp Max-Pooling, 2 lớp Full Connected

và 1 lớp Soft-max để có giá trị ngõ ra Lớp ngõ vào chỉ có 32x32x1, giá trị pixel trong khoảng 0-1

Đoạn code cho CNN

def forward_propagation(X, keep_prob):

tf.set_random_seed(1)

# CONV 1

W1 = tf.get_variable("W1", [4,4,1,64], initializer =

tf.contrib.layers.xavier_initializer(seed = 0))

b1 = tf.get_variable("b1", [64,1], initializer = tf.zeros_initializer())

Z1 = tf.nn.conv2d(input = X, filter = W1, strides = [1,1,1,1], padding = "SAME")

b2 = tf.get_variable("b2", [128,1], initializer = tf.zeros_initializer())

Z2 = tf.nn.conv2d(input = P1, filter = W2, strides = [1,1,1,1], padding = "SAME") A2 = tf.nn.relu(Z2)

# FULL CONNECT 2

W4 = tf.get_variable('W4', [256, 512], initializer =

tf.contrib.layers.xavier_initializer(seed=0))

b4 = tf.get_variable('b4', [256,1], initializer = tf.zeros_initializer())

A4_drop = tf.nn.dropout(A3, keep_prob)

b5 = tf.get_variable('b5', [63,1], initializer = tf.zeros_initializer())

A5_drop = tf.nn.dropout(A4, keep_prob)

back-3.3 Giá trị hàm Cost

def compute_cost(Z3, Y):

cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = Z3, labels = Y))

Bước 2 Chạy model từ file edit_cnn.py

def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.001, keep_prob_prob = 1, num_epochs = 400, minibatch_size = 64, print_cost = True):

minibatch_cost = 0

num_minibatches = int(m / minibatch_size)

seed = seed + 1

minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)

for minibatch in minibatches:

minibatch_X, minibatch_Y = minibatch

_, temp_cost = sess.run([optimizer, cost], {X:minibatch_X, Y:minibatch_Y, keep_prob :keep_prob_prob})

minibatch_cost += temp_cost / num_minibatches

plt.xlabel('iterations (per tens)')

plt.title("Learning rate = " + str(learning_rate))

plt.show()

saver = tf.train.Saver()

saver.save(sess, 'my-model.ckpt')

predict_op = tf.argmax(Z3, 1)

correct_prediction = tf.equal(predict_op, tf.argmax(Y,1))

accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

Trước tiên, ta sẽ lấy được kích thước của X và Y, lưu vào m, n_H0, n_W0, n_C0 để tạo placeholder trong Tensor-flow Khi được X,Y và keep_prob để dùng tối ưu bằng dropout, ta sẽ cho vào mạng CNN bằng câu lệnh

optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)

Sau khi xong, ta sẽ tạo Session trong Tensorflow để chạy và bắt đầu chạy vòng lặp sau đây:

for epoch in range(num_epochs):

minibatch_cost = 0

num_minibatches = int(m / minibatch_size)

seed = seed + 1

minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)

for minibatch in minibatches:

minibatch_X, minibatch_Y = minibatch

_, temp_cost = sess.run([optimizer, cost], {X:minibatch_X, Y:minibatch_Y, keep_prob :keep_prob_prob})

minibatch_cost += temp_cost / num_minibatches

if print_cost == True:

print("Cost after epoch %i %f" %(epoch, minibatch_cost))

costs.append(minibatch_cost)

plt.plot(np.squeeze(costs))

plt.ylabel('cost')

plt.xlabel('iterations (per tens)')

plt.title("Learning rate = " + str(learning_rate))

for minibatch in minibatches:

minibatch_X, minibatch_Y = minibatch

_, temp_cost = sess.run([optimizer, cost], {X:minibatch_X, Y:minibatch_Y, keep_prob :keep_prob_prob})

minibatch_cost += temp_cost / num_minibatches

Với mỗi vòng lặp, ta sẽ tính hàm cost và cộng dồn với nhau Sau khi chạy xong hết mẫu, ta sẽ lưu vào biến costs để vẽ hàm cost theo vòng lặp

Ta thấy trên hình thì sau mỗi vòng lặp, giá trị hàm Cost sẽ giảm

Sau khi chạy xong, ta sẽ dùng 2 đoạn lệnh sau để lưu session vào 1 file Từ đó, ta có thể load lại session này và chạy phần dự đoán sau đó

saver = tf.train.Saver()

saver.save(sess, 'my-model.ckpt')

Bước 3 Kiểm tra kết quả

Đoạn code khi kiểm tra

Giải thích đoạn code:

Trước hết, chúng ta cũng lấy các kích thước của ngõ vào, ngõ ra để tạo placeholder Những bước này phải giống với phần chạy CNN, nếu không thì khi load phần session được lưu sẽ bị lỗi Sau đó thì load phần session đã lưu khi huấn luyện vào bằng 2 dòng code sau:

saver = tf.train.Saver()

new_saver = tf.train.import_meta_graph('my-model.ckpt.meta')

Sau đó, sẽ cho vòng lặp vô hạn, mỗi vòng lặp sẽ dùng openCV để lấy 1 frame ảnh,

và xử lý như khi load data từ bộ dữ liệu:

ret,frame = cap.read()

frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

frame = preprocess(frame)

Tiếp tục, ta sẽ tạo prediction là phần tử cao nhất của ngõ ra Z3 từ forward_propagation

4 Kết quả

Hình 10 Kết quả nhận diện kí tự Z

Nhìn từ trên hình, ta thấy khi kí tự là Z, thì phần terminal hiện lên chữ Z Chữ này

có thể là z thường hoặc Z hoa Khi nhận dạng dùng CNN không thể biết được các dáng chữ giống nhau là chữ thường hay chữ hoa( ví dụ như z,Z, o,O, w,W)

Hình 10 Kết quả nhận diện kí tự q

Kí tự q được nhận diện chính xác Q hoa và q thường là khác nhau nên không khó

để CNN có thể nhận dạng kí tự này

Hình 12 Kết quả nhận diện số 3 Kết quả nhận diện số 3 cũng chính xác

Kết quả của 3 hình này được dựa vào dữ liệu chung của các kí tự từ 0-9, a-z và

A-Z Kết quả này sẽ chính xác hơn nữa nếu dùng dữ liệu nhiều hơn và số lần lặp tăng lên Việc sử dụng nhiều dữ liệu để huấn luyện sẽ gây giới hạn lên máy tính vì máy tính yếu thì không thể chạy được nhiều dữ liệu, máy sẽ bị lổi memory Cho nên 1 cách tốt nhất khi huấn luyện trên máy yếu là sử dụng ít dữ liệu và cho vòng lặp chạy nhiều

5 Tài liệu tham khảo

[1] Michael Nielsen (Aug 2017), Neural networks and Deep learning

[Online] Available: http://neuralnetworksanddeeplearning.com/index.html

[2] Rafael C Gonzalez and Richard E Woods, Digital Image Processing(2nd Edition), Pearson, 2002

[3] Convolution Neural Network – Coursera[Online] Available:

https://www.coursera.org/learn/convolutional-neural-networks/home/welcome[4] Jan Erik Solem(June 2012), Programming Computer Vision with Python: Tools and algorithms for analyzing images O’Reilly Media; 1st edition

[5] Ian Goodfellow, Yoshua Bengio, Aaron Courville, Deep Learning(Adaptive Computation and Machine Learning series) The MIT Press(November 2016)