Convolutional Neural Network (Deep Learning)

Kết quả hình ảnh cho convolution neural network

Nguồn: Internet

Trong xử lý ảnh, do ảnh màu có 3 kênh R, G, B nên ta thường biểu diễn ảnh về dạng một tensor 3 chiều. Do đó lượng parameters được truyền vào Neural Network là rất lớn. Ví dụ ta có một tensor 3 chiều 64*64*3. Như vậy có nghĩa Input layer của chúng ta có 64*64*3 = 12288 nodes. Giả sử số lượng node trong hidden layer là 1000, đồng nghĩa với việc số lượng parameters giữa Input layer và hidden layer là 1000*12288 ( do mỗi node trong hidden layer liên kết với tất cả các node trong input layer). Số lượng parameter sinh ra trong Neural network sẽ rất khổng lồ, do đó chúng ta cần đi tìm một phương án khác hiệu quả hơn.

1. Phép toán Convolution

1.1. Nội dung phép toán Convolution

Phép toán convolution được hình dung dễ hiểu như sau:

Ví dụ chúng ta có một ảnh biểu diễn dưới dạng ma trận X kích thước m*n. Ta sẽ có một ma trận kernel (lõi) có kích thước k*k. Phép toán sẽ thực hiện như sau:

Nguồn: Deep learning cơ bản https://nttuan8.com

Chúng ta sẽ chọn ra phần tử ở giữa thứ (i,j) của ma trận X. Lần lượt nhân từng phần tử nằm xung quanh nó trong phạm vi k*k với ma trận kernel. Sau đó cộng lại sẽ ra một phần tử mới trong ma trận Y.

Ví dụ trường hợp trên: y11 = x11*w11 + x12*w12 + x13*w13 + … + x31*w31.

Như vậy chúng ta thấy, ma trận kết quả Y sau khi thực hiện phép tính Convolution sẽ có kích thước nhỏ hơn ma trận X, cụ thể kích thước của nó là (m-k+1; n-k+1).

Tuy nhiên, nếu muốn ma trận thu được sau phép tính Convolution có kích thước không đổi, chúng ta sẽ thêm các phần tử 0 ở ngoài rìa như sau:

Nguồn: Deep learning cơ bản https://nttuan8.com

Lúc này, ta gọi chỉ số Padding = 1 ( thêm 1 viền số 0 bên ngoài ma trận X ). Tương tự nếu Padding = 2, 3… thì thêm 2, 3 viền số 0.

Lúc này do Kernel có kích thước 3*3, cho nên ma trận Y kết quả thu được sẽ có kích thước như ma trận ban đầu.

Bênh cạnh đó, chúng ta còn có một chỉ số gọi là Stride. Có nghĩa là bước nhảy của phần tử trung tâm (i,j). Ví dụ nếu Stride = 1, khung kernel sẽ di chuyển từ phần tử trung tâm thứ (2,2) sang phần tử (2,3), rồi (2,4), rồi (2,5). Nhưng nếu Stride = 2, khung kernel sẽ di chuyển vượt 1 phần tử. Từ (2,2) sang (2,4) sang (2,6). Tương tự với Stride =3,4,5,…

Nguồn: Deep learning cơ bản https://nttuan8.com

Tổng kết lại, chúng ta có công thức tổng quát cho kích thước của ma trận Y sau khi thực hiện convolution với các chỉ số kích thước m*n, kích thước kernel k*k, padding(p), stride(p):

1.2. Python Code

Để minh họa dễ hiểu phép toán Convolution được thực hiện như thế nào, chúng ta theo dõi đoạn code sau đây:

from mxnet import autograd, npx, np
from mxnet.gluon import nn
npx.set_np()

# Saved in the d2l package for later use
def corr2d(X, K):
    """Compute 2D cross-correlation."""
    h, w = K.shape
    Y = np.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1))
    for i in range(Y.shape[0]):
        for j in range(Y.shape[1]):
            Y[i, j] = (X[i: i + h, j: j + w] * K).sum()
    return Y

Trong đoạn code trên, chủ yếu là hàm corr2d chính là biểu diễn cho cách thức mà phép toán convolution hoạt động ( hàm này chỉ thực hiện được convolution với ảnh được biểu diễn dưới dạng một ma trận)

Ví dụ chúng ta có một Input ảnh có kích thước là một ma trận 3×3 và ma trận kernel có kích thước 2×2 có những giá trị sau:

X = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
K = np.array([[0, 1], [2, 3]])

Chúng ta gọi hàm corr2d để xem kết quả:

corr2d(X, K)

Và kết quả thu được:

A= [[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]
K= [[0. 1.]
 [2. 3.]]

array([[19., 25.],
       [37., 43.]])

Đến đây các bạn hãy thử tự tính tay lại để kiểm tra kết quả 😀

Convolutional Neural Network

Mô hình chung của CNN:

Input layer -> Convolution -> Pooling -> FC à Output

Ảnh xám: ảnh xám được biểu diễn dưới dạng một ma trận pixel với mỗi phần tử biểu diễn cho một điểm ảnh, cụ thể là chỉ mức xám của điểm ảnh đó. Giá trị mỗi phần tử dao động từ 0 -> 255 (gần 0 thì càng đen và gần 255 thì càng trắng).

Ảnh màu: ảnh màu được biểu diễn dưới dạng một tensor 3 chiều m*n*3 do có tới 3 kênh màu Red, green, blue. Tưởng tượng ảnh màu là 3 ma trận Red, Green, Blue được xếp chồng lên nhau. Tương tự như ảnh xám, mỗi ma trận Red, Green, Blue chứa các phần tử dao động từ 0 -> 255.

Để thực hiện phép tính Convolution trên ảnh màu, thay vì chúng ta dùng ma trận kernel k*k, chúng ta cần phải sử dụng một tensor kernel 3 chiều k*k*d (với d trùng với chiều sâu của ảnh).

Ví dụ input là một ảnh màu được biểu diễn dưới dạng tensor 3 chiều:

Nguồn: Deep learning cơ bản https://nttuan8.com

Khối kernel sẽ di chuyển theo thứ tự zic zac như hình trên. Như hình trên do chúng ta thấy ảnh màu có 3 chanel Red, Green, Blue, do đó ảnh có chiều sâu là 3 à tensor kernel cũng có chiều sâu là 3. Từng phần tử trong tensor ảnh nằm trong phạm vi của khối kernel được nhân với từng phần tử trong khối kernel, sau đó cộng tất cả lại với nhau. Chúng ta có thể xem dưới dạng 2D sau đây:

Nguồn: Deep learning cơ bản https://nttuan8.com

Tensor X có chiều sâu 3 được cắt ra thành 3 ma trận (Red, Green, Blue), khối kernel cũng được cắt ra làm 3. Do kết quả của phép tính convolution là nhân từng phần tử trong X nằm trong phạm vi khối kernel với từng phần tử trong khối kernel rồi cộng lại, do đó output là một ma trận Y có kích thước (m-k+1,n-k+1). Tuy nhiên, theo hình trên thì Input là một tensor 3 chiều kích thước 4*4*3, thực hiện phép nhân convolution với Padding = 1 (thêm 1 viền số 0 vào bên ngoài), do đó ma trận output Y thu được có kích thước như ban đầu là 4*4. Tổng quát hơn, khi thực hiện phép nhân convolution với tinh chỉnh các chỉ số như Padding, Stride thì sẽ thu được ma trận output Y có kích thước như đã trình bày ở phần trước: )

Trở lại hình trên, chúng ta ví dụ phần tử output Y11 đầu tiên được tính như sau:

Y11 = X(red)22*w22 + X(red)23*w23 + X(red)32*w32 + x(red)33*w33 + X(green)22*w22 + X(green)23*w23 + X(green)32*w32 + x(green)33*w33 + X(blue)22*w22 + X(blue)23*w23 + X(blue)32*w32 + x(blue)33*w33.

Tương tự với các phần tử còn lại. Trong thực tế, sẽ có thêm một hệ số bias b được cộng vào:

Y11 = X(red)22*w22 + X(red)23*w23 + X(red)32*w32 + x(red)33*w33 + X(green)22*w22 + X(green)23*w23 + X(green)32*w32 + x(green)33*w33 + X(blue)22*w22 + X(blue)23*w23 + X(blue)32*w32 + x(blue)33*w33 + b

Bên cạnh đó chúng ta không chỉ dùng một tensor Kernel để tính toán, mà cần dùng nhiều tensor Kernel ( k kernel) để có thể thu được các đặc điểm ảnh, và có k kernel thì output thu được sẽ có chiều sâu là k. (input(H*W*D) à Convolution(k Kernel F*F*d) à Output(H*W*k))

Convolution layer tổng quát:

Vậy, một input ảnh có độ lớn m*n*D sau khi qua một lớp convolution có k kernel kích thước F*F*D, với chỉ số padding = p, stride = s, sẽ thu được một tensor output có kích thước:

Nguồn: Deep learning cơ bản https://nttuan8.com

Pooling layer:

Pooling layer(lớp pooling) nằm giữa các lớp convolution để giảm kích thước dữ liệu. Ví dụ một tensor ảnh H*W*D sau khi qua một lớp pooling layer với các chỉ số tương ứng thì kích thước chỉ còn (H/2)*(W/2)*D (chiều sâu vẫn giữa nguyên).

Với một tensor ảnh 3 chiều H*W*D, ta tách thành D ma trận kích thước H*W, sau đó mỗi ma trận sử dụng một ma trận kernel kích thước k*k. Ma trận kernel này sẽ trượt trên mỗi ma trận H*W của ảnh, và tìm phần tử lớn nhất( hoặc lấy trung bình các phần tử ) nằm trong phạm vi khối kernel trong ma trận Input H*W thứ i

Nguồn: Deep learning cơ bản https://nttuan8.com

Đây là một ví dụ kernel 3*3 (màu xanh) lấy trung bình các phần tử trong ma trận 5*5 thứ i của tensor input X nào đó (màu cam). Dễ thấy phần tử (1,1) của ma trận kernel được tính như sau:

Như đã trình bày, thay vì lấy trung bình các phần tử(avarage pooling), ta có thể lấy phần tử lớn nhất trong phạm vi đó (max pooling) tùy vào người sử dụng.

Trong pooling vẫn có thể áp dụng Padding và Stride, với nội dung kiến thức như Convolution

Thông thường, chúng ta sẽ dùng pooling kernel kích thước 2*2, stride = 2 và padding = 0 để giảm kích thước dữ liệu xuống còn một nửa, chiều sâu vẫn được giữ nguyên

Nguồn: Deep learning cơ bản https://nttuan8.com

Fully Connected layer:

Sau khi qua nhiều lớp convolution, máy đã học được các đặc điểm ảnh thì ở output tenser sau lớp convolution cuối cùng kích thước H*W*D sẽ được chuyển về vector 1 chiều có H*W*D phần tử:

Nguồn: Deep learning cơ bản https://nttuan8.com