Làm thế nào để xây dựng một mạng lưới thần kinh để nhận ra các chữ số viết tay với TensorFlow

Mạng nơ-ron được sử dụng như là một phương pháp sâu học tập, một trong những subfields nhiều của trí tuệ nhân tạo. Họ đã đầu tiên được đề xuất xung quanh 70 năm trước đây như là một nỗ lực nhằm mô phỏng cách bộ não con người hoạt động, mặc dù trong một hình thức đơn giản hơn nhiều. Cá nhân ‘tế bào thần kinh’ được kết nối trong lớp, với trọng lượng được chỉ định để xác định làm thế nào tế bào thần kinh phản ứng khi tín hiệu được truyền qua mạng. Trước đó, mạng nơ-ron đã được giới hạn trong số họ đã có thể để mô phỏng các tế bào thần kinh, và do đó là sự phức tạp của việc học mà họ có thể đạt được. Nhưng những năm gần đây, do tiến bộ mới trong phát triển phần cứng, chúng tôi đã có thể để xây dựng mạng lưới rất sâu sắc, và đào tạo cho họ trên datasets rất lớn để đạt được những đột phá trong máy tình báo.

Đột phá này đã cho phép máy để phù hợp và vượt quá khả năng của con người lúc thực hiện nhiệm vụ nhất định. Một trong những nhiệm vụ như vậy là công nhận đối tượng. Mặc dù máy trong lịch sử đã không thể để phù hợp với tầm nhìn của con người, các tiến bộ gần đây ở sâu học tập đã làm cho nó có thể để xây dựng mạng nơ-ron có thể nhận ra các đối tượng, khuôn mặt, văn bản và thậm chí cả những cảm xúc.

Trong hướng dẫn này, bạn sẽ thực hiện một khoản nhỏ của đối tượng nhận — nhận dạng chữ số. Bằng cách sử dụng TensorFlow, một thư viện Python mã nguồn mở được phát triển bởi các phòng thí nghiệm Google não sâu học tập nghiên cứu, bạn sẽ có tay vẽ hình ảnh của những con số 0-9 và xây dựng và huấn luyện một mạng nơron để nhận ra và dự đoán nhãn chính xác cho các chữ số Hiển thị.

Trong khi bạn sẽ không cần kinh nghiệm trước khi trong thực tế học sâu hoặc TensorFlow để làm theo cùng với hướng dẫn này, chúng tôi sẽ giả định quen với máy tính học tập điều khoản và khái niệm như đào tạo và kiểm tra, tính năng và nhãn, tối ưu hóa, và đánh giá. Bạn có thể tìm hiểu thêm về những khái niệm An Introduction to máy học.

Điều kiện tiên quyết
Để hoàn thành hướng dẫn này, bạn sẽ cần:

Một địa phương Python 3 môi trường phát triển, bao gồm cả pip, một công cụ để cài đặt các gói Python và venv, để tạo môi trường ảo.
Bước 1-Cấu hình các dự án
Trước khi bạn có thể phát triển chương trình nhận dạng, bạn sẽ cần phải cài đặt một vài phụ thuộc và tạo ra việc tổ chức các tập tin của bạn.

Chúng tôi sẽ sử dụng một môi trường ảo Python 3 quản lý phụ thuộc dự án của chúng tôi. Tạo một thư mục mới cho dự án của bạn và điều hướng đến thư mục mới:

mkdir tensorflow-demo
cd tensorflow-demo
Thực hiện các lệnh sau để thiết lập môi trường ảo cho hướng dẫn này:

python3 -m venv tensorflow-demo
source tensorflow-demo/bin/activate
Tiếp theo, cài đặt các thư viện mà bạn sẽ sử dụng trong hướng dẫn này. Chúng tôi sẽ sử dụng các phiên bản cụ thể của các thư viện bằng cách tạo ra một tập tin requirements.txt vào thư mục dự án mà xác định các yêu cầu và các phiên bản mà chúng ta cần. Tạo tập tin requirements.txt :

touch requirements.txt
Mở tập tin trong trình soạn thảo văn bản của bạn và thêm dòng sau đây để xác định các thư viện hình ảnh, NumPy và TensorFlow và các phiên bản của họ:

requirements.txt
image==1.5.20
numpy==1.14.3
tensorflow==1.4.0
Lưu file và thoát khỏi trình biên tập. Sau đó cài đặt các thư viện với các lệnh sau đây:

pip install -r requirements.txt
Với quan hệ phụ thuộc cài đặt, chúng tôi có thể bắt đầu làm việc trên dự án của chúng tôi.

Bước 2-Nhập khẩu bộ dữ liệu MNIST
Số liệu chúng tôi sẽ sử dụng trong hướng dẫn này được gọi là bộ dữ liệu MNIST , và nó là một kinh điển trong máy học tập cộng đồng. Số liệu này được thực hiện hình ảnh của các chữ số viết tay, 28 x 28 điểm ảnh ở kích thước. Dưới đây là một số ví dụ các chữ số bao gồm trong bộ dữ liệu:

Examples of MNIST images

Hãy tạo một chương trình Python để làm việc với số liệu này. Chúng tôi sẽ sử dụng một tập tin cho tất cả các công việc trong hướng dẫn này. Tạo một tập tin mới được gọi là main.py:

touch main.py
Bây giờ mở tệp này trong trình soạn thảo văn bản của bạn của sự lựa chọn và thêm dòng mã này vào tệp để chuyển nhập các thư viện TensorFlow:

Main.py
import tensorflow as tf
Thêm các dòng mã sau vào tập tin để nhập khẩu bộ dữ liệu MNIST và lưu trữ các dữ liệu hình ảnh trong biến mnist:

main.py
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets(“MNIST_data/”, one_hot=True) # y labels are oh-encoded
When reading in the data, we are using one-hot-encoding to represent the labels (the actual digit drawn, e.g. “3”) of the images. One-hot-encoding uses a vector of binary values to represent numeric or categorical values. As our labels are for the digits 0-9, the vector contains ten values, one for each possible digit. One of these values is set to 1, to represent the digit at that index of the vector, and the rest are set to 0. For example, the digit 3 is represented using the vector [0, 0, 0, 1, 0, 0, 0, 0, 0, 0]. As the value at index 3 is stored as 1, the vector therefore represents the digit 3.

To represent the actual images themselves, the 28×28 pixels are flattened into a 1D vector which is 784 pixels in size. Each of the 784 pixels making up the image is stored as a value between 0 and 255. This determines the grayscale of the pixel, as our images are presented in black and white only. So a black pixel is represented by 255, and a white pixel by 0, with the various shades of gray somewhere in between.

We can use the mnist variable to find out the size of the dataset we have just imported. Looking at the num_examples for each of the three subsets, we can determine that the dataset has been split into 55,000 images for training, 5000 for validation, and 10,000 for testing. Add the following lines to your file:

main.py
n_train = mnist.train.num_examples # 55,000
n_validation = mnist.validation.num_examples # 5000
n_test = mnist.test.num_examples # 10,000
Now that we have our data imported, it’s time to think about the neural network.

Step 3 — Defining the Neural Network Architecture
The architecture of the neural network refers to elements such as the number of layers in the network, the number of units in each layer, and how the units are connected between layers. As neural networks are loosely inspired by the workings of the human brain, here the term unit is used to represent what we would biologically think of as a neuron. Like neurons passing signals around the brain, units take some values from previous units as input, perform a computation, and then pass on the new value as output to other units. These units are layered to form the network, starting at a minimum with one layer for inputting values, and one layer to output values. The term hidden layer is used for all of the layers in between the input and output layers, i.e. those “hidden” from the real world.

Kiến trúc khác nhau có thể mang lại kết quả đáng kể khác nhau, như hiệu suất có thể được dùng như một chức năng của kiến trúc trong số những thứ khác, chẳng hạn như các thông số, dữ liệu và thời gian đào tạo.

Thêm các dòng mã sau vào tập tin để lưu trữ số lượng đơn vị cho mỗi lớp trong biến toàn cầu. Điều này cho phép chúng tôi để làm thay đổi kiến trúc mạng ở một nơi, và ở phần cuối của hướng dẫn bạn có thể thử nghiệm cho bản thân các con số như thế nào khác nhau của các lớp và các đơn vị sẽ tác động đến kết quả của mô hình của chúng tôi:

Main.py
n_input = 784 # input layer (28×28 pixels)
n_hidden1 = 512 # 1st hidden layer
n_hidden2 = 256 # 2nd hidden layer
n_hidden3 = 128 # 3rd hidden layer
n_output = 10 # output layer (0-9 digits)
Sơ đồ dưới đây cho thấy một hình ảnh của kiến trúc, chúng tôi đã thiết kế, với mỗi lớp đầy đủ kết nối với các lớp xung quanh:

Diagram of a neural network

Thuật ngữ “mạng nơ-ron sâu” liên quan đến số lượng ẩn lớp, với “cạn” thường có nghĩa là chỉ một ẩn lớp, và “sâu” đề cập đến nhiều ẩn lớp. Cho đủ dữ liệu đào tạo, một mạng lưới thần kinh cạn với một số lượng đầy đủ của đơn vị về lý thuyết có thể đại diện cho bất kỳ chức năng mạng nơ-ron sâu có thể. Nhưng thường nhiều hơn nữa hiệu quả computationally sử dụng một mạng lưới thần kinh nhỏ sâu để đạt được nhiệm vụ tương tự sẽ đòi hỏi một mạng lưới nông với các đơn vị theo cấp số nhân nhiều ẩn. Mạng nơ-ron nông cũng thường gặp overfitting, nơi mà mạng cơ bản memorizes dữ liệu đào tạo rằng nó đã thấy, và không thể khái quát những kiến thức để dữ liệu mới. Đây là lý do tại sao mạng nơ-ron sâu hơn thường được sử dụng: nhiều lớp giữa nguyên dữ liệu đầu vào và đầu ra nhãn cho phép mạng để tìm hiểu các tính năng ở các cấp độ trừu tượng, làm cho các mạng riêng của mình tốt hơn có thể khái quát.

Các yếu tố khác của mạng nơ-ron mà cần phải được xác định ở đây là các hyperparameters. Không giống như các thông số sẽ nhận được Cập Nhật trong thời gian đào tạo, các giá trị này được thiết lập ban đầu và vẫn không đổi trong suốt quá trình. Trong tập tin của bạn, thiết lập các biến và các giá trị sau:

Main.py
learning_rate = 1e-4
n_iterations = 1000
batch_size = 128
dropout = 0.5
Tỷ lệ học đại diện cho ow nhiều các thông số sẽ điều chỉnh ở mỗi bước của quá trình học tập. Những điều chỉnh là một thành phần quan trọng của đào tạo: sau mỗi vượt qua thông qua mạng chúng tôi điều chỉnh trọng lượng hơi để thử và làm giảm sự mất mát. Tỷ lệ học tập lớn hơn có thể hội tụ nhanh hơn, nhưng cũng có tiềm năng để vượt qua các giá trị tối ưu như họ được Cập Nhật. Số lặp đi lặp lại đề cập đến bao nhiêu lần chúng tôi đi qua các bước đào tạo, và kích thước lô dùng để ví dụ đào tạo bao nhiêu, chúng tôi đang sử dụng tại mỗi bước. dropout biến đại diện cho một ngưỡng mà chúng tôi elimanate một số đơn vị tại ngẫu nhiên. Chúng tôi sẽ sử dụng dropout trong lớp ẩn cuối cùng của chúng tôi để cung cấp cho mỗi đơn vị một cơ hội 50% đang được loại bỏ từng bước đào tạo. Điều này giúp ngăn chặn overfitting.

Bây giờ, chúng tôi đã xác định kiến trúc của mạng lưới thần kinh, và hyperparameters ảnh hưởng đến quá trình học tập. Bước tiếp theo là xây dựng mạng lưới như một đồ thị TensorFlow.

Bước 4-Xây dựng biểu đồ TensorFlow
Để xây dựng mạng lưới của chúng tôi, chúng tôi sẽ thiết lập mạng như một đồ thị tính toán cho TensorFlow để thực hiện. Khái niệm cốt lõi TensorFlow là tensor, một cấu trúc dữ liệu tương tự như một mảng hoặc danh sách. khởi tạo, thao túng như họ được thông qua thông qua các đồ thị và cập nhật thông qua quá trình học tập.

Chúng tôi sẽ bắt đầu bằng cách xác định ba vec như placeholders, mà vec mà chúng ta sẽ ăn các giá trị vào sau đó. Thêm sau vào tập tin:

main.py
X = tf.placeholder(“float”, [None, n_input])
Y = tf.placeholder(“float”, [None, n_output])
keep_prob = tf.placeholder(tf.float32)
Các tham số duy nhất mà cần phải được xác định tại tờ khai của nó là kích thước dữ liệu chúng tôi sẽ ăn ở. X chúng tôi sử dụng một hình dạng của [None, 784], nơi None đại diện cho bất kỳ số tiền, như chúng ta sẽ ăn trong một số hình ảnh 784-pixel undefined. Hình dạng của Y là [None, 10] như chúng tôi sẽ sử dụng nó cho một số lượng không xác định kết quả đầu ra nhãn, với các lớp học có thể 10. keep_prob tensor được sử dụng để kiểm soát mức dropout, và chúng ta khởi tạo nó như là một giữ chỗ chứ không phải là một biến không thay đổi bởi vì chúng tôi muốn sử dụng tensor cùng cả đào tạo (khi dropout được thiết lập để 0.5) và thử nghiệm (khi dropout được thiết lập để 1.0).

Các thông số mạng sẽ Cập Nhật trong quá trình đào tạo là các giá trị weight và bias , vì vậy, cho chúng ta cần phải thiết lập một giá trị ban đầu chứ không phải là một giữ chỗ trống. Những giá trị này là cơ bản nơi mạng nào học tập của mình, như họ đang được sử dụng trong các chức năng kích hoạt các tế bào thần kinh, đại diện cho sức mạnh của các kết nối giữa các đơn vị.

Kể từ khi các giá trị được tối ưu hóa trong đào tạo, chúng tôi có thể đặt chúng bằng không cho bây giờ. Nhưng giá trị ban đầu thực sự có một tác động đáng kể về độ chính xác cuối cùng của các mô hình. Chúng tôi sẽ sử dụng các giá trị ngẫu nhiên từ một phân phối bình thường cắt ngắn cho các trọng lượng. Chúng tôi muốn họ phải được gần số không, do đó, họ có thể điều chỉnh theo hướng tích cực hay tiêu cực, và hơi khác nhau, do đó, họ tạo ra các lỗi khác nhau. Điều này sẽ đảm bảo rằng các mô hình học một cái gì đó hữu ích. Thêm những dòng này:

Main.py
weights = {
‘w1’: tf.Variable(tf.truncated_normal([n_input, n_hidden1], stddev=0.1)),
‘w2’: tf.Variable(tf.truncated_normal([n_hidden1, n_hidden2], stddev=0.1)),
‘w3’: tf.Variable(tf.truncated_normal([n_hidden2, n_hidden3], stddev=0.1)),
‘out’: tf.Variable(tf.truncated_normal([n_hidden3, n_output], stddev=0.1)),
}
Thiên vị, chúng tôi sử dụng một giá trị hằng số nhỏ để đảm bảo rằng các vec kích hoạt trong khi giai đoạn và do đó góp phần tuyên truyền. Trọng lượng và thiên vị vec được lưu trữ trong các đối tượng từ điển để dễ dàng truy cập. Thêm mã này vào tập tin để xác định những biases:

Main.py

biases = {
‘b1’: tf.Variable(tf.constant(0.1, shape=[n_hidden1])),
‘b2’: tf.Variable(tf.constant(0.1, shape=[n_hidden2])),
‘b3’: tf.Variable(tf.constant(0.1, shape=[n_hidden3])),
‘out’: tf.Variable(tf.constant(0.1, shape=[n_output]))
}
Tiếp theo, thiết lập các lớp mạng bằng cách xác định các hoạt động sẽ thao tác các vec. Thêm những dòng này vào tập tin:

Main.py
layer_1 = tf.add(tf.matmul(X, weights[‘w1’]), biases[‘b1’])
layer_2 = tf.add(tf.matmul(layer_1, weights[‘w2’]), biases[‘b2’])
layer_3 = tf.add(tf.matmul(layer_2, weights[‘w3’]), biases[‘b3’])
layer_drop = tf.nn.dropout(layer_3, keep_prob)
output_layer = tf.matmul(layer_3, weights[‘out’]) + biases[‘out’]
Mỗi lớp ẩn sẽ thực hiện phép nhân ma trận trên các lớp trước kết quả đầu ra và trọng lượng lớp hiện tại, và thêm thiên vị cho những giá trị này. Ở ẩn lớp cuối cùng, chúng tôi sẽ áp dụng một dropout hoạt động bằng cách sử dụng của chúng tôi giá trị keep_prob 0.5.

Bước cuối cùng trong xây dựng biểu đồ là để xác định các chức năng giảm cân mà chúng tôi muốn tối ưu hóa. Một lựa chọn phổ biến mất chức năng trong chương trình TensorFlow là cross-mất cân bằng, còn được gọi là Nhật ký giảm cân, mà lượng sự khác biệt giữa hai phân bố xác suất (các dự đoán và các nhãn). Một phân loại hoàn hảo sẽ cho kết quả trong một cross-mất cân bằng 0, với tổn thất hoàn toàn được giảm thiểu.

Chúng tôi cũng cần phải chọn các thuật toán tối ưu hóa mà sẽ được sử dụng để giảm thiểu chức năng giảm cân. Một quá trình đặt tên gradient descent optimization là một phương pháp phổ biến cho việc tìm kiếm tối thiểu (địa phương) là một chức năng bằng cách lặp đi lặp lại các bước dọc theo gradient theo một hướng tiêu cực (giảm dần). Có rất nhiều lựa chọn gradient descent tối ưu hóa các thuật toán đã thực hiện trong TensorFlow, và trong hướng dẫn này chúng tôi sẽ sử dụng trình tối ưu hoá Adam. Điều này mở rộng khi gradient descent tối ưu hóa bằng cách sử dụng đà để tăng tốc quá trình thông qua các máy tính trung bình theo cấp số nhân trọng các gradient và sử dụng mà ở những điều chỉnh. Thêm mã sau vào tập tin:

Main.py
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=output_layer))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
Bây giờ, chúng tôi đã xác định mạng và xây dựng nó ra với TensorFlow. Bước tiếp theo là nguồn cấp dữ liệu dữ liệu qua biểu đồ đào tạo nó, và sau đó kiểm tra rằng nó thực sự đã học được một cái gì đó.

Bước 5-Đào tạo và thử nghiệm
Quá trình đào tạo liên quan đến nuôi dưỡng bộ dữ liệu đào tạo thông qua các đồ thị và tối ưu hóa chức năng giảm cân. Mỗi khi mạng iterates thông qua một loạt các hình ảnh đào tạo chi tiết, nó Cập nhật các thông số để giảm bớt thiệt hại để chính xác hơn dự đoán các chữ số hiển thị. Quá trình thử nghiệm liên quan đến việc chạy bộ dữ liệu thử nghiệm của chúng tôi thông qua các đồ thị được đào tạo, và theo dõi số lượng hình ảnh một cách chính xác là dự đoán, do đó chúng tôi có thể tính toán chính xác.

Trước khi bắt đầu quá trình đào tạo, chúng tôi sẽ xác định phương pháp của chúng tôi đánh giá tính chính xác, vì vậy chúng tôi có thể in nó ra trên mini-lô của dữ liệu trong khi chúng tôi đào tạo. Các báo cáo in sẽ cho phép chúng tôi để kiểm tra xem từ lặp đầu tiên đến cuối cùng, giảm cân và làm tăng độ chính xác; họ cũng sẽ cho phép chúng tôi để theo dõi hay không, chúng tôi đã chạy lặp đi lặp lại đủ để đạt được một kết quả phù hợp và tối ưu:

Main.py
correct_pred = tf.equal(tf.argmax(output_layer, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
Tại correct_pred, chúng tôi sử dụng chức năng arg_max để so sánh những hình ảnh đang được dự đoán một cách chính xác bằng cách nhìn vào output_layer (dự báo) và Y (nhãn) và chúng tôi sử dụng các chức năng equal để trở về đây là một danh sách các [phép toán luận] (tps: / /www.digitalocean.com/community/tutorials/understanding-data-types-in-python-3#booleans). Sau đó, chúng tôi có thể diễn viên danh sách này để nổi và tính toán có nghĩa là để có được một số điểm chính xác tất cả.

Chúng tôi đã sẵn sàng để khởi tạo một phiên chạy trên đồ thị. Trong phiên này chúng ta sẽ ăn mạng với các ví dụ huấn luyện của chúng tôi, và sau khi được đào tạo, chúng tôi ăn cùng một đồ thị với các ví dụ bài kiểm tra mới để xác định tính chính xác của mô hình. Thêm các dòng mã sau vào tập tin:

Main.py
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
Bản chất của quá trình đào tạo, học sâu là để tối ưu hóa chức năng giảm cân. Ở đây chúng tôi là nhằm giảm thiểu sự khác biệt giữa các nhãn dự đoán của các hình ảnh, và các nhãn đúng hình ảnh. Quá trình này bao gồm bốn bước lặp đi lặp lại cho một số thiết lập của lặp đi lặp lại:

Quảng bá giá trị chuyển tiếp thông qua mạng
Tính toán thiệt hại
Quảng bá giá trị ngược qua mạng
Cập nhật các thông số
Tại mỗi bước đào tạo, các thông số được điều chỉnh một chút để thử và làm giảm sự mất mát cho bước tiếp theo. Như tiến trình học tập, chúng ta sẽ thấy một sự giảm trong mất mát, và cuối cùng chúng tôi có thể ngừng đào tạo và sử dụng mạng như là một mẫu thử nghiệm của chúng tôi dữ liệu mới.

Thêm mã này để các tập tin:

Main.py
# train on mini batches
for i in range(n_iterations):
batch_x, batch_y = mnist.train.next_batch(batch_size)
sess.run(train_step, feed_dict={X: batch_x, Y: batch_y, keep_prob:dropout})

# print loss and accuracy (per minibatch)
if i%100==0:
minibatch_loss, minibatch_accuracy = sess.run([cross_entropy, accuracy], feed_dict={X: batch_x, Y: batch_y, keep_prob:1.0})
print(“Iteration”, str(i), “\t| Loss =”, str(minibatch_loss), “\t| Accuracy =”, str(minibatch_accuracy))
Sau khi lặp đi lặp lại 100 của mỗi bước đào tạo mà chúng ta ăn một lô nhỏ của hình ảnh thông qua mạng, chúng tôi sẽ in ra thiệt hại và tính chính xác của lô đó. Lưu ý rằng chúng tôi nên không được mong muốn giảm cân và tăng độ chính xác ở đây, là các giá trị cho mỗi lô, không cho các mô hình toàn bộ. Chúng tôi sử dụng mini-lô của hình ảnh chứ không phải là cho ăn chúng thông qua các cá nhân để tăng tốc quá trình đào tạo và cho phép mạng để xem một số ví dụ khác nhau trước khi cập nhật các thông số.

Sau khi đào tạo xong, chúng tôi có thể chạy các phiên họp về hình ảnh kiểm tra. Thời gian này chúng tôi đang sử dụng một keep_prob dropout lệ 1.0 để đảm bảo tất cả các đơn vị đang hoạt động trong quá trình thử nghiệm.

Thêm mã này để các tập tin:

Main.py
test_accuracy = sess.run(accuracy, feed_dict={X: mnist.test.images, Y: mnist.test.labels, keep_prob:1.0})
print(“\nAccuracy on test set:”, test_accuracy)
Nó bây giờ là thời gian để chạy chương trình của chúng tôi và xem làm thế nào chính xác mạng lưới thần kinh có thể nhận ra những chữ số viết tay. Lưu các tập tin main.py và thực thi lệnh sau trong terminal để chạy script:

python3 main.py
Bạn sẽ thấy một đầu ra tương tự như sau đây, mặc dù các kết quả cá nhân của mất mát và độ chính xác có thể khác nhau chút ít:

Output
Iteration 0 | Loss = 3.67079 | Accuracy = 0.140625
Iteration 100 | Loss = 0.492122 | Accuracy = 0.84375
Iteration 200 | Loss = 0.421595 | Accuracy = 0.882812
Iteration 300 | Loss = 0.307726 | Accuracy = 0.921875
Iteration 400 | Loss = 0.392948 | Accuracy = 0.882812
Iteration 500 | Loss = 0.371461 | Accuracy = 0.90625
Iteration 600 | Loss = 0.378425 | Accuracy = 0.882812
Iteration 700 | Loss = 0.338605 | Accuracy = 0.914062
Iteration 800 | Loss = 0.379697 | Accuracy = 0.875
Iteration 900 | Loss = 0.444303 | Accuracy = 0.90625

Accuracy on test set: 0.9206
Để thử và cải thiện tính chính xác của mô hình của chúng tôi, hoặc để tìm hiểu thêm về tác động của điều chỉnh hyperparameters, chúng tôi có thể kiểm tra hiệu quả của việc thay đổi tỷ lệ học tập, ngưỡng dropout, kích thước hàng loạt và số lặp đi lặp lại. Chúng tôi cũng có thể thay đổi số lượng các đơn vị trong lớp chúng tôi ẩn, và thay đổi số lượng ẩn lớp mình, để xem làm thế nào khác nhau kiến trúc tăng hoặc giảm độ chính xác của mô hình.

Để chứng minh rằng mạng thực sự công nhận những hình ảnh vẽ tay, hãy kiểm tra nó trên một hình ảnh duy nhất của riêng của chúng tôi.

Đầu tiên, hoặc tải về này mẫu thử nghiệm hình ảnh hoặc mở một trình soạn thảo đồ họa và tạo ra hình ảnh của riêng bạn 28 x 28 pixel của chữ số một.

Mở main.py file trong biên tập của bạn và thêm dòng mã, sau đầu của tập tin cần nhập hai thư viện cần thiết cho hình ảnh thao tác.

Main.py
import numpy as np
from PIL import Image

Sau đó vào cuối của tập tin, hãy thêm dòng sau mã để tải hình ảnh kiểm tra chữ viết tay:

Main.py
img = np.invert(Image.open(“test_img.png”).convert(‘L’)).ravel()

Chức năng open thư viện Image tải hình ảnh thử nghiệm như là một mảng 4 D chứa các kênh màu RGB ba và minh bạch Alpha. Đây không phải là đại diện cùng chúng tôi sử dụng trước khi đọc sách trong bộ dữ liệu với TensorFlow, do đó, chúng tôi sẽ cần phải làm một số công việc thêm để phù hợp với các định dạng.

Trước tiên, chúng tôi sử dụng chức năng convert với tham số L giảm 4 D RGBA đại diện cho một màu xám màu channel. Chúng tôi lưu trữ này như là một mảng numpy và hoán đổi nó bằng cách sử dụng np.invert, vì hiện tại ma trận đen như 0 và trắng như 255, trong khi chúng tôi cần các đối diện. Cuối cùng, chúng tôi gọi ravel để làm phẳng các mảng.

Bây giờ mà hình ảnh dữ liệu có cấu trúc một cách chính xác, chúng tôi có thể chạy một phiên làm việc trong cùng một cách như trước đây, nhưng thời gian này chỉ cho ăn trong hình ảnh duy nhất để thử nghiệm. Thêm mã sau vào tập tin của bạn để kiểm tra các hình ảnh và in nhãn outputted.

Main.py
prediction = sess.run(tf.argmax(output_layer,1), feed_dict={X: [img]})
print (“Prediction for test image:”, np.squeeze(prediction))
Chức năng np.squeeze được gọi là dự báo để trả lại số nguyên đơn từ mảng (tức là đến từ [2] 2). Kết quả đầu ra chứng tỏ rằng mạng đã công nhận hình ảnh này là các chữ số 2.

Output
Prediction for test image: 2
Bạn có thể thử thử nghiệm mạng với hình ảnh phức tạp hơn–chữ số mà trông giống như chữ số khác, ví dụ, hoặc chữ số đã được rút ra kém hoặc không chính xác–để xem như thế nào giá vé.

Kết luận
Trong hướng dẫn này bạn đã đào tạo một mạng lưới thần kinh để phân loại số liệu MNIST với khoảng 92% độ chính xác và thử nghiệm nó trên một hình ảnh của riêng bạn. Nghiên cứu hiện tại của nhà nước-of-the-art đạt được khoảng 99% trên cùng một vấn đề này, bằng cách sử dụng kiến trúc mạng phức tạp liên quan đến mã lớp. Các sử dụng cơ cấu 2D của hình ảnh tốt hơn để đại diện cho nội dung, không giống như các phương pháp của chúng tôi mà tất cả các điểm ảnh phẳng thành một vector đơn vị 784. Bạn có thể đọc thêm về chủ đề này trên trang web TensorFlow, và xem các nghiên cứu giấy tờ chi tiết kết quả chính xác nhất trên trang web MNIST.

Bây giờ mà bạn biết làm thế nào để xây dựng và huấn luyện một mạng lưới thần kinh, bạn có thể thử và sử dụng này thực hiện trên dữ liệu của bạn, hoặc kiểm tra nó trên các datasets phổ biến như Google StreetView nhà sốhoặc số liệu CIFAR-10 cho hình ảnh tổng quát hơn công nhận