Tải bản đầy đủ

Mô phỏng mạng CNN trên FPGA

A. Lời nói đầu
Deep Learning là một thuật toán dựa trên một số ý tưởng từ não bộ tới việc tiếp
thu nhiều tầng biểu đạt, cả cụ thể lẫn trừu tượng, qua đó làm rõ nghĩa của các loại dữ
liệu. Deep Learning được ứng dụng trong nhận diện hình ảnh, nhận diện giọng nói,
xử lý ngôn ngữ tự nhiên .
Hiện nay rất nhiều các bài toán nhận dạng sử dụng Deep Learning để giải quyết
do Deep Learning có thể giải quyết các bài toán với số lượng lớn, kích thước đầu vào
lớn với hiệu năng cũng như độ chính xác cao.
Những năm gần đây, ta đã chứng kiến được nhiều thành tựu vượt bậc của Deep
Learning trong ngành Thị giác máy tính (Computer Vision), các tập đoàn lón như
Facebook, Google hay Amazon đã, và đang sự dụng điều đó như một phần không thể
thiếu trong sản phẩm của mình, đó có thể là nhận diện khuôn mặt người dùng, phát
triển xe hơi tự lái hay drone giao hàng tự động,…Chính những thứ đó đã góp phần
giúp cho cuộc sống của chúng ta hiện nay ngày càng tiện nghi, thoải mái hơn.
Trong đó, Convolutional Neural Network (CNNs – Mạng nơ-ron tích chập) là
một trong những mô hình Deep Learning tiên tiến giúp cho chúng ta xây dựng được
những hệ thống thông minh như trên. Vậy nên chúng em chọn đề tài “Mô phỏng
mạng CNN trên FPGA” làm đề tài cho bài tập lớn môn thiết kế IC số.
Do kiến thức còn nhiều hạn chế, nên sẽ còn nhiều sai sót, chúng em hi vọng sẽ
được thầy giúp đỡ để đề tài của chúng em được hoàn thiện. Chúng em chân thành
cảm ơn thầy.



Mục Lục
A.

Lời nói đầu ................................................................................................................................ 1

B.

Nội dung .................................................................................................................................... 5
Chương 1: Tổng quan về CNN ................................................................................................... 5
1.1

Giới thiệu về CNN ........................................................................................................ 5

1.2

Giới thiệu các layer cơ bản của mạng CNN ............................................................... 6

1.3

Giới thiệu về các hàm Activation ................................................................................ 7

Chương 2: Mô phỏng CNN bằng ngôn ngữ Verilog ................................................................. 8
2.1 Convolution layer ............................................................................................................... 8
2.2 Max-Pooling layer ............................................................................................................ 11
2.3 ReLU ................................................................................................................................. 13
C.

Phụ lục..................................................................................................................................... 15

D.

Tài liệu tham khảo ................................................................................................................. 17

2


Mục lục hình ảnh
Hình 1.1: Sơ đồ mạng Neural Network……………………………………………..5
Hình 1.2: Sơ đồ mạng CNN…………………………………………………………6
Hình 2.1: Mạch RTL lớp Convolution……………………………………………..10
Hình 2.2: Testbench lớp Convolution……………………………………………...10
Hình 2.3: Mạch RTL lớp Max-pooling…………………………………………….12
Hình 2.4: Testbench lớp Max-pooling……………………………………………..12
Hình 2.5: Mạch RTL của ReLU……………………………………………………14
Hình 2.6: Testbench của ReLU…………………………………………………….14

3


Phân công công việc
Tên thành viên

Công việc
- Tìm hiểu mạng CNN, viết báo cáo

Nguyễn Minh Hiếu

- Code và train mạng CNN bằng ngôn ngữ Python
- Code lớp Max_pooling

Nguyễn Đức Hoàn

Phạm Công Minh

- Tìm hiểu mạng CNN, viết báo cáo
- Code lớp Convolution
- Tìm hiểu mạng CNN, viết báo cáo
- Code lớp Fully-connected

4


B. Nội dung
Chương 1: Tổng quan về CNN
1.1 Giới thiệu về CNN
Mạng nơ-ron tích chập (CNN - Convolutional Neural Network) là một trong
những mô hình mạng “Deep Learning” phổ biến nhất hiện nay, có khả năng nhận
dạng và phân loại hình ảnh với độ chính xác rất cao, thậm chí còn tốt hơn con người
trong nhiều trường hợp. Mô hình này đã và đang được phát triển, ứng dụng vào các
hệ thống xử lý ảnh lớn của Facebook, Google hay Amazon… cho các mục đích khác
nhau như các thuật toán tagging tự động, tìm kiếm ảnh hoặc gợi ý sản phẩm cho người
tiêu dung.
Sự ra đời của mạng CNN là dựa trên ý tưởng cải tiến cách thức các mạng nơron nhân tạo truyền thống. Do sử dụng các liên kết đầy đủ giữa các điểm ảnh vào
node, các mạng nơ-ron nhân tạo (Neural Network) bị hạn chế rất nhiều bởi kích thước
của ảnh, ảnh càng lớn thì số lượng liên kết càng tăng nhanh và kéo theo sự bùng nổ
khối lượng tính toán. Ngoài ra sự liên kết đầy đủ này cũng là sự dư thừa khi với mỗi
bức ảnh, các thông tin chủ yếu thể hiện qua sự phụ thuộc giữa các điểm ảnh với những
điểm xung quanh nó mà không quan tâm nhiều đến các điểm ảnh ở cách xa nhau.
Mạng CNN ra đời với kiến trúc thay đổi, có khả năng xây dựng liên kết chỉ sử dụng
một phần cục bộ trong ảnh kết nối đến node trong lớp tiếp theo thay vì toàn bộ ảnh
như trong mạng nơ-ron truyền thẳng.

Hình 1.1: Sơ đồ mạng Neural Network

5


Hình 1.2: Sơ đồ mạng CNN

1.2 Giới thiệu các layer cơ bản của mạng CNN
1.2.1 Convolution layer
Convolution: bao gồm Convolution Filter và Convolutional Layer


Convolution Layer : Chính là các hidden layer – 1 tập các feature map , mỗi

feature là 1 bản scan của input ban đầu nhưng được trích xuất ra các feature với đặc
tính cụ thể.


Convolution Filter( Kernel): Đây là một ma trận sẽ quét qua ma trận dữ liệu

đầu vào, từ trái qua phải, trên xuống dưới, và nhân tương ứng từng giá trị của ma trận
đầu vào mà ma trận kernel rồi cộng tổng lại, đưa qua activation funciton (sigmoid,
relu, elu, ... ), kết quả sẽ là một con số cụ thể, tập hợp các con số này lại là 1 ma trận
nữa, chính là feature map.


Stride: Là khoảng cách giữa 2 kernel khi quét

1.2.2 Pooling layer
Pooling: Mục đích của pooling rất đơn giản, nó làm giảm số hyperparameter mà
ta cần phải tính toán, từ đó giảm thời gian tính toán, tránh overfitting. Loại pooling ta
thường gặp nhất là max pooling, lấy giá trị lớn nhất trong một pooling window.
Pooling hoạt động gần giống với convolution, nó cũng có 1 cửa sổ trượt gọi là pooling
window, cửa sổ này trượt qua từng giá trị của ma trận dữ liệu đầu vào (thường là các

6


feature map trong convolutional layer), chọn ra một giá trị từ các gía trị nằm trong cửa
sổ trượt (với max pooling ta sẽ lấy giá trị lớn nhất).

1.2.3 Fully-Connected layer
Fully Connected : Sau các lớp Convolution và Pooling thì sẽ là 2 lớp Fully
connected, 1 layer để tập hợp các feature layer mà ta đã tìm ra, chuyển đổi dữ liệu từ
3D, hoặc 2D thành 1D, tức chỉ còn là 1 vector. Còn 1 layer nữa là output, số neuron
của layer này phụ thuộc vào số output mà ta muốn tìm ra.

1.3 Giới thiệu về các hàm Activation
1.3.1 ReLU
Rectified Linear Unit (ReLU) được sử dụng rộng rãi gần đây vì tính đơn giản
của nó. Một vài ưu điểm của ReLU:


ReLU được chứng minh giúp cho việc training các Deep Networks nhanh hơn

rất nhiều. Sự tăng tốc này được cho là vì ReLU được tính toán gần như tức thời và
gradient của nó cũng được tính cực nhanh với gradient bằng 1 nếu đầu vào lớn hơn
0, bằng 0 nếu đầu vào nhỏ hơn 0.


Mặc dù hàm ReLU không có đạo hàm tại s=0, trong thực nghiệm, người ta

vẫn thường định nghĩa ReLU′(0)= và khẳng định thêm rằng, xác suất để input của
một unit bằng 0 là rất nhỏ.
Công thức của ReLU:
f(x) = max(0, x)

1.3.2 Softmax
Các hàm softmax thường được sử dụng trong lớp cuối cùng của thuật toán phân
loại sử dụng mạng neuron, với chức năng làm nổi bật giá trị lớn nhất và làm mờ các
giá trị bé hơn đáng kể so với giá trị lớn nhất.
Công thức của hàm Softmax:
ai =

exp(𝑧𝑖)
∑ exp(𝑧𝑖 )

𝑣ớ𝑖 𝑖 = 0,1,2, … 𝐶

7


Chương 2: Mô phỏng CNN bằng ngôn ngữ Verilog
2.1 Convolution layer
2.1.1 Yêu cầu kĩ thuật
❖ Mạch bao gồm:
- Hai đầu vào
+ Đầu vào data_stream chứa giá trị của ma trận đầu vào
+ Đầu vào filter_stream chứa giá trị của ma trận lọc
- Đầu ra bit: conv_stream của ma trận ra
❖ Nguyên lý hoạt động
- Lần lượt trượt ma trận lọc từ trái sang phải, từ trên xuống dưới trên ma
trận đầu vào, sau đó nhân ma trận lọc với các giá trị tương ứng của ma trận
đầu vào và cộng tổng các giá trị đó. Cuối cùng, các giá trị tổng sẽ được gán cho
ma trận đầu ra

2.1.2 Code
1. module conv2d
2.
#(
3.
parameter HI = 6,
4.
parameter WI = 6,
5.
parameter K = 3,
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.

parameter
parameter
parameter
parameter
parameter

SI = HI*WI,
HO = HI - K + 1,
WO = WI - K + 1,
SO = HO*WO,
B = 9

//height in
//width in
//height filter = width filter = K
//size in
//height out
//width out
//size out
//bits

)
(
input wire [B*SI - 1:0] data_stream,
input wire [B*K*K-1:0] filter_stream,
output wire [(B*2+1)*SO-1:0] conv_stream
);

function [B*2:0] conv;
input [B*K*K-1:0] a,c;
reg [B*2:0] temp;
reg signed [B-1:0] A,C;
integer x;
begin

8


25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.

temp = 1'b0;
for(x=0; xA = a[B*x+:B]; //B*x+B-1:B*x
C = c[B*x+:B];
temp = temp + A*C;
end
conv = temp;
end
endfunction
// slice data to blocks
wire [B*K*K-1:0] block [0:SO-1];
genvar i,j,k;
generate
for(i=0; ifor(j=0; jfor(k=0; kassign block[i*WO+j][B*k*K+:B*K] = data_stream[B*(i*WI+j) +
B*WI*k +: B*K];
end
end
end
endgenerate

// convolution
genvar n;
generate
for(n=0; nassign conv_stream[n*(B*2+1) +: (B*2+1)] = conv(filter_stream, bloc
k[n]);
54.
end
55.
endgenerate
56.
//assign conv_stream = conv(filter_stream, data_stream[8*9-1:0]);
57.
58. endmodule

2.1.3 Mạch RTL

9


Hình 2.1: Mạch RTL lớp Convolution

2.1.4 Testbench

Hình 2.2: Testbench lớp Convolution

10


2.2 Max-Pooling layer
2.2.1 Yêu cầu kĩ thuật
- Mạch bao gồm:
• Một đầu vào data_stream
• Bốn đầu ra max_stream1, max_stream2, max_stream3, max_stream4
- Nguyên lý hoạt động: quét một cửa sổ 2x2 lần lượt từ trái sang phải, từ trên xuống
dưới và tìm max ở mỗi cửa sổ đó

2.2.2 Code
1. module max_pooling
2.
#(
3.
parameter HI = 4,
4.
parameter WI = 4,
5.
parameter K = 2,
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.

parameter
parameter
parameter
parameter
parameter

//height in
//width in
//height filter = width filter = K

SI = HI*WI,
HO = 2,
WO = 2,
SO = HO*WO,
B = 4

//size in
//height out
//width out
//size out
//bit width

)
(
input wire
output wire
output wire
output wire
output wire

[B*SI [B-1:0]
[B-1:0]
[B-1:0]
[B-1:0]

1:0] data_stream,
max_stream1,
max_stream2,
max_stream3,
max_stream4

);

function [B-1:0] max;
input [B*K*K-1:0] a;
reg signed [B-1:0] temp;
reg signed [B-1:0] A;
integer x;
begin
temp = 4'b1000;
for(x=0; xbegin
A = a[B*x+:B]; //B*x+B-1:B*x
temp = A>temp?A:temp;
end
max = temp;
end
endfunction
// slice data to blocks
wire [B*K*K-1:0] filter [0:SO-1];
genvar i,j,k;
generate
for(i=0; i<=HO; i=i+2) begin//slice_data_axis_0
for(j=0; j<=WO; j=j+2) begin//slice_data_axis_1

11


43.
44.

for(k=0; kassign filter[(i*WO+j)/2][B*k*K+:B*K] = data_stream[B*(i*WI
+j) + B*WI*k +: B*K];
45.
end
46.
end
47.
end
48.
endgenerate
49.
50.
// max
51. // genvar n;
52. // generate
53.
//for(n=0; n54.
//assign max_stream[n*B +: B] = max(filter[n]);
55.
//end
56.
//endgenerate
57.
//assign conv_stream = conv(filter_stream, data_stream[8*9-1:0]);
58.
assign max_stream1 = max(filter[0]);
59.
assign max_stream2 = max(filter[1]);
60.
assign max_stream3 = max(filter[2]);
61.
assign max_stream4 = max(filter[3]);
62. endmodule

2.2.3 Mạch RTL

Hình 2.3: Mạch RTL lớp Max-pooling

2.2.4 Testbench

Hình 2.4: Testbench lớp Max-pooling
12


2.3 ReLU
2.3.1 Yêu cầu kĩ thuật



Mạch bao gồm
Một đầu vào: data
Một đầu ra : window
Nguyên lí hoạt động của mạch:

- Mạch sẽ cắt đầu vào data thành các số B bit và đưa nó qua hàm Relu. Nếu số đó
lớn hơn 0 thì đầu ra là chính nó,nếu số đó nhỏ hơn 0 thì đầu ra bằng 0

2.3.2 Code
1. module Relu
2.
#(
3.
parameter SI = 4,
//number of
4.
parameter SO = 4,
//number of
5.
parameter B = 4
6.
)
7.
(
8.
input wire [B*SI-1:0] data,
9.
output wire [B*SI-1:0] window
10.
);
11.
12.
function [B-1:0] ReLu;
13.
input signed [B-1:0] a;
14.
reg signed [B-1:0] b;
15.
begin
16.
b = a;
17.
if(a<0)
18.
ReLu = 1'b0;
19.
else
20.
ReLu = a;
21.
end
22.
endfunction
23.
24.
wire [B-1:0] filter [0:SO-1];
25.
genvar i;
26.
generate
27.
for(i=0; i28.
assign filter[i][B-1:0]
29.
end
30.
endgenerate
31.
32.
genvar n;
33.
generate
34.
for(n=0; n35.
assign window[n*B +: B]
36.
end
37.
endgenerate
38.
39. endmodule

unit in
unit out

= data[B*i +: B];

= ReLu(filter[n]);

13


2.3.3 Mạch RTL

Hình 2.5: Mạch RTL của ReLU

2.3.4 Testbench

Hình 2.6: Testbench của ReLU

14


C. Phụ lục
Mọt mạng CNN được train bằng Python:
import tensorflow as tf
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

import matplotlib.pyplot as plt
%matplotlib inline # Only use this if using iPython
image_index = 7777 # You may select anything up to 60,000
print(y_train[image_index]) # The label is 8
plt.imshow(x_train[image_index], cmap='Greys')

# Reshaping the array to 4-dims so that it can work with the Keras API
x_train = x_train.reshape(x_train.shape[0], 28, 28, 1)
x_test = x_test.reshape(x_test.shape[0], 28, 28, 1)
input_shape = (28, 28, 1)
# Making sure that the values are float so that we can get decimal points after
division
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
# Normalizing the RGB codes by dividing it to the max RGB value.
x_train /= 255
x_test /= 255
print('x_train shape:', x_train.shape)
print('Number of images in x_train', x_train.shape[0])
print('Number of images in x_test', x_test.shape[0])

# Importing the required Keras modules containing model and layers
from keras.models import Sequential
from keras.layers import Dense, Conv2D, Dropout, Flatten, MaxPooling2D
15


# Creating a Sequential Model and adding the layers
model = Sequential()
model.add(Conv2D(5, kernel_size=(3,3), input_shape=input_shape))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten()) # Flattening the 2D arrays for fully connected layers
model.add(Dense(128, activation=tf.nn.relu))
#model.add(Dropout(0.2))
model.add(Dense(10,activation=tf.nn.softmax))

model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x=x_train,y=y_train, epochs=10)

image_index = 1230
img_rows = 28
img_cols = 28
plt.imshow(x_test[image_index].reshape(28, 28),cmap='Greys')
pred = model.predict(x_test[image_index].reshape(1, img_rows, img_cols, 1))
print(pred.argmax())

16


D. Tài liệu tham khảo
[1] Aurélien Géron, Hands-On Machine Learning with Scikit-Learn and TensorFlow,
2017
[2] Vũ Hữu Tiệp, Machine Learning cơ bản, 2017
[3] Pong P. Chu, FPGA PROTOTYPING BY VERILOG EXAMPLES, 2008
[4] https://www.tensorflow.org/

17



Tài liệu bạn tìm kiếm đã sẵn sàng tải về

Tải bản đầy đủ ngay

×

×