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

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

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

Phân công công việc

Nguyễn Minh Hiếu

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

- Code và train mạng CNN bằng ngôn ngữ Python

- Code lớp Max_pooling

Nguyễn Đức Hoàn - Tìm hiểu mạng CNN, viết báo cáo

- Code lớp Convolution Phạm Công Minh - Tìm hiểu mạng CNN, viết báo cáo

- Code lớp Fully-connected

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

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

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, … 𝐶

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, //height in

4 parameter WI = 6, //width in

5 parameter K = 3, //height filter = width filter = K

6 parameter SI = HI*WI, //size in

7 parameter HO = HI - K + 1, //height out

8 parameter WO = WI - K + 1, //width out

9 parameter SO = HO*WO, //size out

10 parameter B = 9 //bits

11 )

12 (

13 input wire [B*SI - 1:0] data_stream,

14 input wire [B*K*K-1:0] filter_stream,

15 output wire [(B*2+1)*SO-1:0] conv_stream

16 );

17

18

19 function [B*2:0] conv;

20 input [B*K*K-1:0] a,c;

21 reg [B*2:0] temp;

22 reg signed [B-1:0] A,C;

23 integer x;

24 begin

25 temp = 1'b0;

26 for(x=0; x<K*K; x=x+1) begin

27 A = a[B*x+:B]; //B*x+B-1:B*x

28 C = c[B*x+:B];

29 temp = temp + A*C;

30 end

31

32 conv = temp;

33 end

34 endfunction

35

36 // slice data to blocks

37 wire [B*K*K-1:0] block [0:SO-1];

38 genvar i,j,k;

39 generate

40 for(i=0; i<HO; i=i+1) begin //slice_data_axis_0

41 for(j=0; j<WO; j=j+1) begin //slice_data_axis_1

42 for(k=0; k<K; k=k+1) begin //select_data

43 assign block[i*WO+j][B*k*K+:B*K] = data_stream[B*(i*WI+j) + B*WI*k +: B*K];

44 end

45 end

46 end

47 endgenerate

48

49 // convolution

50 genvar n;

51 generate

52 for(n=0; n<SO; n=n+1) begin //convolution

53 assign 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

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

2.1.4 Testbench

Hình 2.2: Testbench lớp Convolution

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, //height in

4 parameter WI = 4, //width in

5 parameter K = 2, //height filter = width filter = K

6 parameter SI = HI*WI, //size in

7 parameter HO = 2, //height out

8 parameter WO = 2, //width out

9 parameter SO = HO*WO, //size out

10 parameter B = 4 //bit width

11 )

12 (

13 input wire [B*SI - 1:0] data_stream,

14 output wire [B-1:0] max_stream1,

15 output wire [B-1:0] max_stream2,

16 output wire [B-1:0] max_stream3,

17 output wire [B-1:0] max_stream4

18 );

19

20

21 function [B-1:0] max;

22 input [B*K*K-1:0] a;

23 reg signed [B-1:0] temp;

24 reg signed [B-1:0] A;

25 integer x;

26 begin

27 temp = 4'b1000;

28 for(x=0; x<K*K; x=x+1)

29 begin

30 A = a[B*x+:B]; //B*x+B-1:B*x

31 temp = A>temp?A:temp;

32 end

33 max = temp;

34 end

35 endfunction

36

37 // slice data to blocks

38 wire [B*K*K-1:0] filter [0:SO-1];

39 genvar i,j,k;

40 generate

41 for(i=0; i<=HO; i=i+2) begin //slice_data_axis_0

42 for(j=0; j<=WO; j=j+2) begin //slice_data_axis_1

43 for(k=0; k<K; k=k+1) begin //select_data

44 assign 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; n<SO; n=n+1) begin

54 //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

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 unit in

4 parameter SO = 4, //number of unit out

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; i<SO; i=i+1) begin

28 assign filter[i][B-1:0] = data[B*i +: B];

29 end

30 endgenerate

31

32 genvar n;

33 generate

34 for(n=0; n<SO; n=n+1) begin

35 assign window[n*B +: B] = ReLu(filter[n]);

36 end

37 endgenerate

38

39 endmodule

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

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

# 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())