Xây dựng Neural Network để tìm hiểu AI

Tạo một Neural Network, rồi huấn luyện nó bằng dữ liệu mẫu và xem nó hành động, nhận diện các con số viết tay như thế nào cùng Quantrimang.com nhé!

Neural Network - Mạng nơ ron là một khái niệm quan trọng trong lĩnh vực trí tuệ nhân tạo và học máy. Chúng bao gồm các node được kết nối với nhau, sắp xếp theo layer và bắt chước cách hoạt động của bộ não con người. Các node đại diện cho những dây thần kinh của con người.

Bạn có thể tự tạo neural network phân đa lớp, chuyển tiếp đơn giản. Đào tạo nó phân loại chữ số viết tay bằng dataset MNIST. Sau đó, bạn có thể dùng thị giác máy tính để phân loại chữ số viết tay của bản thân.

Phân loại đa lớp là gì?

Phân loại đa lớp là một kiểu học máy có thể phân dữ liệu thành nhiều danh mục khác nhau. Neural network dùng trình phân loại softmax để phân phối xác suất hay tỉ lệ trên các class có thể.

Bạn có thể dùng phân loại đa lớp cho ảnh từ dataset MNIST thành 10 danh mục khác nhau. Chúng tương ứng với các con số từ 0 tới 9.

Datset MNIST là gì?

Đây là một dataset benchmark phổ biến cho học máy và các thuật toán thị giác máy tính. Nó chứa 70.000 ảnh chữ viết tay ở kích thước 28x28 pixel. Các con số viết tay nằm trong phạm vi từ 0 tới 9.

Trước khi xây dựng bất kỳ mẫu học máy, bạn cần hiểu dataset chứa những gì. Hiểu dataset sẽ cho bạn cách xử lý dữ liệu tốt hơn.

Chuẩn bị môi trường phát triển

Để làm theo hướng dẫn, bạn cần biết cách dùng Python cơ bản và có kiến thức nền tảng về học máy. Cuối cùng, hãy thoải mái dùng Jupyter Notebook hoặc Google Colab.

Tạo mới Jupyter Notebook hoặc đăng ký Google Colab. Chạy lệnh này để cài đặt gói cần thiết:

!pip install numpy matplotlib tensorflow opencv-python

Bạn sẽ dùng:

• Matplotlib để trực quan hóa dữ liệu.
• NumPy để thao tác với mảng.
• TensorFlow để tạo và đào tạo mô hình của bạn.
• OpenCV để cung cấp cho mô hình các chữ số viết tay của riêng bạn.

Nhập mô đun cần thiết

Nhập các gói bạn đã cài đặt trong môi trường. Điều này cho phép bạn gọi và dùng các hàm và mô đun của chúng trong code sau này.

import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import cv2

Dòng code thứ hai nhập mô đun Keras từ thư viện Google TensorFlow. Bạn sẽ dùng Keras để huấn luyện neural network chuyên sâu với TensorFlow làm backend.

Tải và xem Dataset

Dataset MNIST được tích hợp vào Keras. Tải dataset MNIST và tách nó thành phần training và test. Bạn sẽ dùng phần train để định hướng model và test để đánh giá độ chính xác của mẫu trong phân loại ảnh mới chưa nhìn thấy.

(X_train, y_train) , (X_test, y_test) = keras.datasets.mnist.load_data()

Kiểm tra độ dài của tập train và test. Dataset MNIST có 60.000 ảnh phục vụ cho việc huấn luyện và 10.000 ảnh cho việc kiểm tra.

len(X_train)
len(X_test)

Kiểm tra hình dạng của ảnh đầu tiên trong dataset MNIST ở kích thước 28x28 pixel. Sau đó, in các giá trị pixel và minh họa nó bằng Matplotlib.

X_train[0].shape
X_train[0]
plt.matshow(X_train[0])
y_train[0]

Kết quả như sau:

Xử lý trước dữ liệu

Trước khi dùng dữ liệu trong dataset để đào tạo và kiểm tra mô hình, bạn cần xử lý nó trước. Quá trình này cải thiện độ chính xác bằng cách chuẩn hóa dữ liệu.

Bình thường hóa các giá trị pixel

Bình thường hóa các giá trị pixel của ảnh trong dataset bằng cách chia từng giá trị cho 255. Các giá trị pixel của phạm vi dataset chưa chuẩn hóa nằm trong phạm vi từ 0 tới 255 với 0 là màu đen, còn 255 là màu trắng. Chia từng giá trị pixel cho 255 đảm bảo mỗi pixel ở phạm vi giữa 0 và 1. Điều này giúp model dễ học các tính năng và mẫu liên quan trong dữ liệu.

X_train = X_train / 255
X_test = X_test / 255

Sau đó in các giá trị pixel của ảnh đầu tiên.

X_train[0]

Giờ chúng nằm trong phạm vi giữa 0 và 1.

Chuyển đổi ma trận ảnh thành mảng 1D

Lớp nhập vào của neural network thường yêu cầu đầu vào 1D, vì thế, tạo một mảng 1D cho các giá trị pixel trong ảnh. Để làm việc này, dùng hàm reshape() cùng với số ảnh thô để đặt số ảnh trong dataset.

X_train_flattened = X_train.reshape(len(X_train), 28 * 28)
X_test_flattened = X_test.reshape(len(X_test), 28 * 28)
X_train_flattened.shape
X_train_flattened[0]

Các hình ảnh của bạn giờ đã sẵn sàng huấn luyện và kiểm tra model.

Tạo mẫu neural network chuyên sâu

Tạo mô hình tuần tự với môđun Keras của Tensorflow bằng 1 lớp đầu vào, 2 lớp ẩn và 1 lớp đầu ra. Đặt hình dạng đầu vào là 28 x 28 vì đây là hình dạng của hình ảnh gốc trong tập dữ liệu. Sử dụng 128 node cho các lớp ẩn. Lớp đầu ra chỉ nên có 10 nơ-ron vì bạn chỉ phân loại các chữ số từ 0 đến 9.

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),

    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(128, activation='relu'),

    keras.layers.Dense(10, activation='softmax')
])

Biên dịch mô hình bằng cách sử dụng trình tối ưu hóa adam, sparse_categorical_crossentropy làm hàm loss và số liệu để đánh giá hiệu suất của mô hình làm độ chính xác. Sau đó, điều chỉnh dữ liệu đào tạo vào mô hình và đặt số giai đoạn sang 5.

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(X_train, y_train, epochs=5)

Bạn cần đợi vài phút để hoàn tất quá trình “train” model. Sau khi kết thúc, đánh giá hiệu quả của nó ở phần kiểm tra (test).

model.evaluate(X_test, y_test)

Hàm đánh giá sẽ trả về loss và độ chính xác của model. Mẫu này cho độ chính xác 98%.

Dùng model để phân loại số viết tay

Bạn cần chuẩn bị ảnh để khớp với những con số trong dataset MNIST. Nếu không làm như vậy, model được tạo sẽ hoạt động kém hiệu quả.

Để xử lý trước hình ảnh:

1. Tải ảnh chứa số bằng OpenCV.
2. Chuyển đổi nó sang thang xám và chỉnh lại kích thước ở 28x28 pixel.
3. Lật và chuẩn hóa các giá trị pixel.
4. Cuối cùng làm phẳng ảnh bằng mảng 1D.

Chuyển ảnh đã xử lý trước vào model để dự đoán và in giá trị dự đoán trên màn hình.

img = cv2.imread('digits/digit1.png', cv2.IMREAD_GRAYSCALE)
img_resize = cv2.resize(img, (28, 28))
img_flip = cv2.bitwise_not(img_resize)
img_normalized = img_flip.astype('float32') / 255.0

# Flatten the image into a 1D array
input_data = img_normalized.flatten().reshape( 1,28,28)

# Make a prediction using the model
prediction = model.predict(input_data)
print (f'Prediction: {np.argmax(prediction)}')

Chuyển ảnh đã xử lý trước chứa một số vào mẫu:

Kết quả:

Trên đây là cách xây dựng mạng thần kinh nhân tạo. Hi vọng bài viết hữu ích với các bạn.