Cơ sở dữ liệu MNIST (Cơ sở dữ liệu đã được sửa đổi của Viện Công nghệ Tiêu chuẩn Quốc gia) là một cơ sở dữ liệu mở rộng về các chữ số viết tay, được sử dụng để đào tạo các hệ thống xử lý ảnh khác nhau. Nó được tạo ra bằng cách “tích hợp lại” các mẫu từ tập dữ liệu ban đầu của MNIST.
Nếu chúng ta đã quen thuộc với các khối xây dựng của Connects, chúng ta sẵn sàng xây dựng một khối với TensorFlow. Chúng tôi sử dụng tập dữ liệu MNIST để phân loại hình ảnh.
Chuẩn bị dữ liệu giống như trong hướng dẫn trước. Chúng tôi có thể chạy mã và nhảy trực tiếp vào kiến trúc của CNN.
Ở đây, chúng tôi đang thực thi mã của mình trong Google Colab (một trình chỉnh sửa trực tuyến của máy học).
Chúng ta có thể vào trình chỉnh sửa TensorFlow thông qua liên kết dưới đây: https://colab.research.google.com
Đây là các bước được sử dụng để training CNN (Convolutional Neural Network).
Các bước:
- Bước 1: Tải lên tập dữ liệu
- Bước 2: Lớp đầu vào
- Bước 3: Lớp chuyển đổi
- Bước 4: Lớp gộp
- Bước 5: Lớp chuyển đổi và Lớp tổng hợp
- Bước 6: Lớp dày đặc
- Bước 7: Lớp đăng nhập
Bước 1: Tải lên tập dữ liệu
Bộ dữ liệu MNIST có sẵn với scikit để học trong URL này (Bộ định vị tài nguyên hợp nhất). Chúng tôi có thể tải xuống và lưu trữ trong phần tải xuống của chúng tôi. Chúng tôi có thể tải nó lên bằng fetch_mldata (‘MNIST Original’).
Tạo một bộ thử nghiệm / đào tạo
Chúng ta cần chia tập dữ liệu thành train_test_split.
import numpy as np
import tensorflow as tf
from sklearn.datasets import fetch_mldata
#Change USERNAME by the username of the machine
##Windows USER
mnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')
## Mac User
mnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')
print(mnist.data.shape)
print(mnist.target.shape)
from sklearn.model_selection import train_test_split
A_train, A_test, B_train, B_test = train_test_split(mnist.data,mnist.target, test_size=0.2, random_state=45)
B_train = B_train.astype(int)
B_test = B_test.astype(int)
batch_size =len(X_train)
print(A_train.shape, B_train.shape,B_test.shape )
## rescale
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train the Dataset
X_train_scaled = scaler.fit_transform(A_train.astype(np.float65)) #test the dataset
X_test_scaled = scaler.fit_transform(A_test.astype(np.float65))
feature_columns = [tf.feature_column.numeric_column('x',shape=A_train_scaled.shape[1:])]
X_train_scaled.shape[1:] Hãy xem chi tiết cách tạo mọi khối xây dựng trước khi gói mọi thứ vào trong hàm.
Bước 2: Lớp đầu vào
#Input layer def cnn_model_fn(mode, features, labels): input_layer = tf.reshape(tensor= features["x"],shape=[-1, 26, 26, 1])
Chúng ta cần xác định một tensor với hình dạng của dữ liệu. Để làm được điều đó, chúng ta có thể sử dụng mô-đun tf.reshape. Trong mô-đun này, chúng ta cần khai báo tensor để định hình lại và định hình tensor. Đối số đầu tiên là đặc điểm của dữ liệu, được định nghĩa trong đối số của một hàm.
Một bức tranh có chiều rộng, chiều cao và kênh. Tập dữ liệu MNIST là một ảnh đơn sắc có kích thước 28×28. Chúng tôi đặt kích thước lô thành -1 trong đối số hình dạng để nó có hình dạng của các đối tượng [“x”]. Ưu điểm là điều chỉnh kích thước lô thành siêu tham số. Nếu kích thước lô là 7, tensor cấp 5,488 giá trị (28 * 28 * 7).
Bước 3: Lớp kết hợp
# first CNN Layer conv1 = tf.layers.conv2d( inputs= input_layer, filters= 18, kernel_size= [7, 7], padding="same", activation=tf.nn.relu)
Lớp chập đầu tiên có 18 bộ lọc với kích thước hạt nhân là 7×7 với phần đệm bằng nhau. Cùng một phần đệm có cả tenxơ đầu ra và tenxơ đầu vào có cùng chiều rộng và chiều cao. TensorFlow sẽ thêm các số không trong các hàng và cột để đảm bảo có cùng kích thước.
Chúng tôi sử dụng chức năng kích hoạt Relu. Kích thước đầu ra sẽ là [28, 28 và 14].
Bước 4: Lớp gộp
Bước tiếp theo sau khi tích chập là tính toán gộp. Tính toán gộp sẽ làm giảm phần mở rộng của dữ liệu. Chúng ta có thể sử dụng mô-đun max_pooling2d với kích thước 3×3 và sải chân là 2. Chúng tôi sử dụng lớp trước đó làm đầu vào. Kích thước đầu ra có thể là [batch_size, 14, 14 và 15].
##first Pooling Layer pool1 = tf.layers.max_pooling2d (inputs=conv1, pool_size=[3, 3], strides=2)
Bước 5: Lớp gộp và lớp kết hợp thứ hai
CNN thứ hai có chính xác 32 bộ lọc, với kích thước đầu ra là [batch_size, 14, 14, 32]. Kích thước của lớp gộp có giống như phía trước và hình dạng đầu ra là [batch_size, 14, 14, and18].
conv2 = tf.layers.conv2d(
inputs=pool1,
filters=36,
kernel_size=[5, 5],
padding="same",
activation=tf.nn.relu)
pool2 = tf.layers.max_pooling2d (inputs=conv2, pool_size=[2, 2],strides=2). Bước 6: Kết nối đầy đủ (dày đặc) lớp
Chúng ta phải xác định lớp được kết nối đầy đủ. Bản đồ đối tượng địa lý phải được nén trước để được kết hợp với lớp dày đặc. Chúng ta có thể sử dụng mô-đun định hình lại với kích thước 7 * 7 * 36.
Lớp dày đặc sẽ kết nối 1764 tế bào thần kinh. Chúng tôi thêm chức năng kích hoạt Relu và có thể thêm chức năng kích hoạt Relu. Chúng tôi thêm thuật ngữ quy định bỏ học với tỷ lệ 0,3, nghĩa là 30 phần trăm trọng số sẽ là 0. Việc bỏ học chỉ diễn ra trong giai đoạn đào tạo. Cnn_model_fn () có một chế độ đối số để khai báo nếu mô hình cần được đào tạo hoặc được đánh giá.
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36]) dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu) dropout = tf.layers.dropout( inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)
Bước 7: Lớp ghi nhật ký
Cuối cùng, chúng tôi xác định lớp cuối cùng với dự đoán của mô hình. Hình dạng đầu ra bằng kích thước lô 12, bằng tổng số hình ảnh trong lớp.
#Logit Layer logits = tf.layers.dense(inputs=dropout, units=12)
Chúng ta có thể tạo một từ điển chứa các lớp và khả năng của mỗi lớp. Mô-đun trả về giá trị cao nhất với tf.argmax () nếu các lớp logit. Hàm softmax trả về xác suất của mọi lớp.
predictions= {
# Generate predictions
"classes":tf.argmax(input=logits, axis=1),
"probabilities":tf.nn.softmax (logits, name="softmax_tensor")} Chúng tôi chỉ muốn trả lại dự đoán từ điển khi chế độ được đặt thành dự đoán. Chúng tôi thêm các mã này để hiển thị các dự đoán.
If mode== tf.estimator.ModeKeys.PREDICT: return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
Bước tiếp theo bao gồm tính toán tổn thất của mô hình. Sự mất mát được tính toán dễ dàng với mã sau:
# Calculate Loss (for both EVAL and TRAIN modes) loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)
Bước cuối cùng là tối ưu hóa mô hình, tức là tìm các giá trị tốt nhất của trọng số. Để làm được điều đó, chúng tôi sử dụng trình tối ưu hóa độ dốc gradient với tỷ lệ học tập là 0,001. Mục tiêu là giảm tổn thất.
optimizer= tf.train.GradientDescentOptimizer(learning_rate=0.0001) train_op= optimizer.minimize( loss=loss, global_step=tf.train.get_global_step())
Chúng tôi đã hoàn thành với CNN. Tuy nhiên, chúng tôi muốn hiển thị số liệu hiệu suất trong chế độ đánh giá. Số liệu hiệu suất cho mô hình đa lớp là số liệu về độ chính xác. TensorFlow được trang bị mô hình độ chính xác với hai đối số, nhãn và giá trị dự đoán.
eval_metric_ops = {
"accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}
return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops) Chúng tôi có thể tạo CNN đầu tiên của mình và chúng tôi sẵn sàng gói gọn mọi thứ trong một chức năng để sử dụng nó cũng như đào tạo và đánh giá mô hình.
def cnn_model_fn(features, labels, mode):
""Model function for CNN.""
# Input Layer
input_layer = tf.reshape(features["x"], [-1, 28, 28, 1])
# Convolutional Layer
conv1 = tf.layers.conv2d(
inputs=input_layer,
filters=32,
kernel_size=[5, 5],
padding="same",
activation=tf.nn.relu)
# Pooling Layer
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
# Convolutional Layer #2 and Pooling Layer
conv2 = tf.layers.conv2d(
inputs=pool1,
filters=36,
kernel_size=[5, 5],
padding="same",
activation=tf.nn.relu)
pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)
# Dense Layer
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])
dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
dropout = tf.layers.dropout(
inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)
# Logits Layer
logits = tf.layers.dense(inputs=dropout, units=10)
predictions = {
# Generate predictions (for PREDICT and EVAL mode)
"classes": tf.argmax(input=logits, axis=1),
"probabilities": tf.nn.softmax(logits, name="softmax_tensor")
}
if mode == tf.estimator.ModeKeys.PREDICT:
return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
# Calculate Loss
loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)
# Configure the Training Op (for TRAIN mode)
if mode == tf.estimator.ModeKeys.TRAIN:
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
train_op = optimizer.minimize(
loss=loss,
global_step=tf.train.get_global_step())
return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)
# Add evaluation metrics Evaluation mode
eval_metric_ops = {
"accuracy": tf.metrics.accuracy(
labels=labels, predictions=predictions["classes"])}
return tf.estimator.EstimatorSpec(
mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)
Một CNN mất nhiều lần để đào tạo, do đó, chúng tôi tạo một móc ghi nhật ký để lưu trữ các giá trị của các lớp phần mềm trong mỗi 50 lần lặp lại.
# Set up logging for predictions
tensors_to_log = {"probabilities": "softmax_tensor"}
logging_hook =tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50) Chúng tôi đã sẵn sàng để ước tính mô hình. Chúng tôi có kích thước lô là 100 và xáo trộn dữ liệu thành nhiều phần. Lưu ý rằng, chúng tôi đặt các bước đào tạo là 18000, có thể mất rất nhiều thời gian để đào tạo.
#Train the model
train_input_fn = tf.estimator.inputs.numpy_input_fn(
x={"x": X_train_scaled},
y=y_train,
batch_size=100,
num_epochs=None,
shuffle=True)
mnist_classifier.train(
input_fn=train_input_fn,
steps=18000,
hooks=[logging_hook]) Bây giờ, mô hình được đào tạo, chúng tôi có thể đánh giá nó và in kết quả một cách dễ dàng.
# Evaluate the model and print the results
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
x= {"x": X_test_scaled},
y=y_test,
num_epochs=1,
shuffle=False)
eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)
print(eval_results) INFO:tensorflow:Calling model_fn
INFO:tensorflow:Done calling model_fn
INFO:tensorflow:Starting evaluation at 2019-08-10-12:53:40
INFO:tensorflow:Graph is finalized.
INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652
INFO:tensorflow: Running local_init_op
INFO:tensorflow: Running local_init_op
INFO:tensorflow:Finished evaluation at 2019-07-05-12:52:56
INFO:tensorflow: Saving dict for global step 15652: accuracy = 0.9589586, global_step = 15852, loss = 0.13894269{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652} Với sự trợ giúp của kiến trúc, chúng tôi nhận được độ chính xác là 97%. Chúng tôi có thể thay đổi kiến trúc, kích thước lô và số lần lặp lại để cải thiện độ chính xác. Kiến trúc, kích thước lô và số lần lặp lại để cải thiện độ chính xác.
Mạng nơ-ron CNN đã hoạt động tốt hơn nhiều so với ANN hoặc hồi quy logistic. Trong hướng dẫn về mạng nơ-ron nhân tạo, chúng tôi có độ chính xác là 96%, đây là CNN thấp. Màn trình diễn của CNN rất ấn tượng với bộ hình ảnh mở rộng, cả về tính toán tốc độ và độ chính xác.
Để xây dựng CNN, chúng ta cần làm theo sáu bước sau:
1) Lớp đầu vào:
Bước này đặt lại dữ liệu. Kích thước bằng căn bậc hai của số pixel. Ví dụ: nếu một hình ảnh có 156 pixel, hình ảnh đó là 26×26. Chúng ta cần xác định xem hình ảnh có chứa màu hay không. Nếu vậy, chúng tôi có kích thước 3 đến 3 cho RGB-, nếu không thì 1.
Input_layer = tf.reshape (tensor = features ["x"], shape = [-1,30,30,1])
2) Lớp chuyển đổi
Chúng ta cần tạo các lớp nhất quán. Chúng tôi áp dụng các bộ lọc khác nhau để tìm hiểu các tính năng quan trọng của mạng. Chúng tôi xác định kích thước của hạt nhân và khối lượng của bộ lọc.
conv1= tf.layers.conv2d( inputs=input_layer, filters=14, kernel_size=[6, 6], padding="same", activation= tf.nn.relu)
3) Lớp gộp
Trong bước thứ ba, chúng tôi thêm một lớp gộp. Lớp này làm giảm kích thước của đầu vào. Nó thực hiện bằng cách lấy giá trị lớn nhất của ma trận con.
pool1 = tf.layers.max_pooling2d(inputs=conv1, strides=2, pool_size=[2, 2])
4)Thêm Lớp kết hợp và Lớp tổng hợp
Trong bước này, chúng ta có thể thêm bao nhiêu lớp gộp tùy thích. Nó sử dụng kiến trúc của Google với hơn 20 lớp cứng.
5) Lớp dày đặc
Bước 5 làm phẳng phần trước để tạo thành các lớp nối hoàn chỉnh. Trong bước này, chúng ta có thể sử dụng một chức năng kích hoạt khác và thêm hiệu ứng bỏ học.
pool2_flat = tf.reshape(pool2, [-1, 8 * 8 * 36]) dense = tf.layers.dense(inputs=pool3_flat, units=8 * 8 * 36, activation=tf.nn.relu) dropout = tf.layers.dropout( Inputs=dense, rate=0.3, trainingmode == tf.estimator.ModeKeys.TRAIN)
6) Lớp đăng nhập
Bước cuối cùng là dự đoán.
logits = tf.layers.dense(inputs=dropout, units=12)
