Phân loại hình ảnh CNN trong TensorFlow với các bước và ví dụ

Mạng Nơ-ron Hợp pháp là gì?

Mạng thần kinh chuyển đổi, còn được gọi là convnets hoặc CNN, là một phương pháp nổi tiếng trong các ứng dụng thị giác máy tính. Đây là một lớp mạng nơ-ron sâu được sử dụng để phân tích hình ảnh trực quan. Kiểu kiến ​​trúc này chiếm ưu thế để nhận dạng các đối tượng từ hình ảnh hoặc video. Nó được sử dụng trong các ứng dụng như nhận dạng hình ảnh hoặc video, xử lý ngôn ngữ nơ-ron, v.v.

Archikiến trúc của Mạng lưới thần kinh chuyển đổi

Hãy nghĩ về Facebook vài năm trước, sau khi bạn tải ảnh lên hồ sơ của mình, bạn được yêu cầu thêm tên cho khuôn mặt trên ảnh theo cách thủ công. Ngày nay, Facebook sử dụng convnet để tự động gắn thẻ bạn bè của bạn vào ảnh.

Mạng nơ-ron tích chập để phân loại hình ảnh không quá khó hiểu. Hình ảnh đầu vào được xử lý trong giai đoạn tích chập và sau đó được gán nhãn.

Kiến trúc convnet điển hình có thể được tóm tắt trong hình dưới đây. Trước hết, một hình ảnh được đẩy vào mạng; đây được gọi là hình ảnh đầu vào. Sau đó, hình ảnh đầu vào trải qua vô số bước; đây là phần tích chập của mạng. Cuối cùng, mạng nơ-ron có thể dự đoán chữ số trên hình ảnh.

Một hình ảnh bao gồm một mảng pixel có chiều cao và chiều rộng. Hình ảnh thang độ xám chỉ có một kênh trong khi hình ảnh màu có ba kênh (mỗi kênh dành cho Đỏ, Xanh lục và Xanh lam). Một kênh được xếp chồng lên nhau. Trong hướng dẫn này, bạn sẽ sử dụng hình ảnh thang độ xám chỉ có một kênh. Mỗi pixel có giá trị từ 0 đến 255 để phản ánh cường độ màu. Chẳng hạn, pixel bằng 0 sẽ hiển thị màu trắng trong khi pixel có giá trị gần 255 sẽ tối hơn.

Chúng ta hãy nhìn vào một hình ảnh được lưu trữ trong Tập dữ liệu MNIST. Hình ảnh dưới đây cho thấy cách thể hiện hình ảnh bên trái ở dạng ma trận. Lưu ý rằng, ma trận ban đầu đã được chuẩn hóa từ 0 đến 1. Đối với màu tối hơn, giá trị trong ma trận là khoảng 0.9 trong khi các pixel màu trắng có giá trị là 0.

Hoạt động tích chập

Thành phần quan trọng nhất trong mô hình là lớp tích chập. Phần này nhằm mục đích giảm kích thước của hình ảnh để tính toán trọng số nhanh hơn và cải thiện tính tổng quát của nó.

Trong phần tích chập, mạng giữ các đặc điểm cơ bản của hình ảnh và loại trừ nhiễu không liên quan. Ví dụ: mô hình đang học cách nhận dạng một con voi từ một bức ảnh có ngọn núi ở hậu cảnh. Nếu bạn sử dụng mạng thần kinh truyền thống, mô hình sẽ gán trọng số cho tất cả các pixel, bao gồm cả các pixel từ núi, điều này không cần thiết và có thể đánh lừa mạng.

Thay vào đó, một Máy ảnh mạng nơ-ron tích chập sẽ sử dụng một kỹ thuật toán học để chỉ trích xuất các pixel có liên quan nhất. Hoạt động toán học này được gọi là tích chập. Kỹ thuật này cho phép mạng học các tính năng ngày càng phức tạp ở mỗi lớp. Tích chập chia ma trận thành các phần nhỏ để học các phần tử thiết yếu nhất trong mỗi phần.

Các thành phần của Mạng thần kinh chuyển đổi (ConvNet hoặc CNN)

Có bốn thành phần của Convnets

1. sự quấn lại
2. Tính phi tuyến tính (ReLU)
3. Pooling hoặc Lấy mẫu phụ
4. Phân loại (Lớp được kết nối đầy đủ)

sự quấn lại

Mục đích của phép tích chập là trích xuất cục bộ các đặc điểm của đối tượng trên ảnh. Điều đó có nghĩa là mạng sẽ tìm hiểu các mẫu cụ thể trong ảnh và có thể nhận ra nó ở mọi nơi trong ảnh.

Tích chập là phép nhân từng phần tử. Khái niệm này dễ hiểu. Máy tính sẽ quét một phần của hình ảnh, thường có kích thước 3×3 và nhân nó với một bộ lọc. Đầu ra của phép nhân từng phần tử được gọi là bản đồ đặc điểm. Bước này được lặp lại cho đến khi toàn bộ hình ảnh được quét. Lưu ý rằng, sau khi tích chập, kích thước của hình ảnh sẽ giảm đi.

Bên dưới, có một URL để xem cách hoạt động của tích chập.

Có rất nhiều kênh có sẵn. Dưới đây, chúng tôi liệt kê một số kênh. Bạn có thể thấy rằng mỗi bộ lọc đều có một mục đích cụ thể. Lưu ý, trong hình bên dưới; Kernel là từ đồng nghĩa của bộ lọc.

Số học đằng sau tích chập

Pha tích chập sẽ áp dụng bộ lọc trên một mảng nhỏ các điểm ảnh trong hình ảnh. Bộ lọc sẽ di chuyển dọc theo hình ảnh đầu vào với hình dạng chung là 3×3 hoặc 5×5. Điều này có nghĩa là mạng sẽ trượt các cửa sổ này trên toàn bộ hình ảnh đầu vào và tính toán tích chập. Hình ảnh bên dưới cho thấy cách thức hoạt động của tích chập. Kích thước của bản vá là 3×3 và ma trận đầu ra là kết quả của phép toán từng phần tử giữa ma trận hình ảnh và bộ lọc.

Bạn nhận thấy rằng chiều rộng và chiều cao của đầu ra có thể khác với chiều rộng và chiều cao của đầu vào. Nó xảy ra vì hiệu ứng biên giới.

Hiệu ứng viền

Hình ảnh có bản đồ tính năng 5 × 5 và bộ lọc 3 × 3. Chỉ có một cửa sổ ở trung tâm nơi bộ lọc có thể sàng lọc lưới 3 × 3. Bản đồ tính năng đầu ra sẽ thu nhỏ lại bằng hai ô cùng với kích thước 3 × 3.

Để có cùng thứ nguyên đầu ra với thứ nguyên đầu vào, bạn cần thêm phần đệm. Phần đệm bao gồm việc thêm đúng số hàng và cột ở mỗi bên của ma trận. Nó sẽ cho phép tích chập tập trung vào trung tâm của mọi ô đầu vào. Trong hình ảnh bên dưới, ma trận đầu vào/đầu ra có cùng kích thước 5×5

Khi bạn xác định mạng, các tính năng tích hợp được kiểm soát bởi ba tham số:

1. Độ sâu: Nó xác định số lượng bộ lọc sẽ áp dụng trong quá trình tích chập. Trong ví dụ trước, bạn thấy độ sâu là 1, nghĩa là chỉ sử dụng một bộ lọc. Trong hầu hết các trường hợp, có nhiều hơn một bộ lọc. Hình ảnh bên dưới hiển thị các thao tác được thực hiện trong tình huống có ba bộ lọc

2. Sải bước: Nó xác định số lượng "bước nhảy pixel" giữa hai lát cắt. Nếu bước nhảy bằng 1, các cửa sổ sẽ di chuyển với độ lan truyền của một pixel là một. Nếu bước nhảy bằng hai, các cửa sổ sẽ nhảy 2 pixel. Nếu bạn tăng bước nhảy, bạn sẽ có các bản đồ đặc trưng nhỏ hơn.

Ví dụ sải bước 1

sải bước 2

3. Không lót: Phần đệm là thao tác thêm số hàng và cột tương ứng ở mỗi bên của bản đồ tính năng đầu vào. Trong trường hợp này, đầu ra có cùng kích thước với đầu vào.

Tính phi tuyến tính (ReLU)

Khi kết thúc hoạt động tích chập, đầu ra phải tuân theo chức năng kích hoạt để cho phép phi tuyến tính. Chức năng kích hoạt thông thường cho convnet là Relu. Tất cả pixel có giá trị âm sẽ được thay thế bằng 0.

Pooling Operasản xuất

Bước này dễ hiểu. Mục đích của việc gộp nhóm là giảm số chiều của hình ảnh đầu vào. Các bước được thực hiện để giảm độ phức tạp tính toán của hoạt động. Bằng cách giảm số chiều, mạng có trọng số thấp hơn để tính toán, do đó ngăn ngừa tình trạng quá khớp.

Ở giai đoạn này, bạn cần xác định kích thước và bước tiến. Một cách chuẩn để gộp ảnh đầu vào là sử dụng giá trị lớn nhất của bản đồ đặc điểm. Hãy xem hình ảnh bên dưới. “Gộp” sẽ sàng lọc bốn ma trận con của bản đồ đặc điểm 4×4 và trả về giá trị lớn nhất. Gộp lấy giá trị lớn nhất của mảng 2×2 rồi di chuyển các cửa sổ này hai pixel. Ví dụ, ma trận con đầu tiên là [3,1,3,2], gộp sẽ trả về giá trị lớn nhất là 3.

Có một phép toán gộp khác như phép toán trung bình.

Hoạt động này làm giảm đáng kể kích thước của bản đồ đối tượng

Các lớp được kết nối đầy đủ

Bước cuối cùng bao gồm việc xây dựng một hệ thống truyền thống mạng lưới thần kinh nhân tạo như bạn đã làm trong hướng dẫn trước. Bạn kết nối tất cả các nơ-ron từ lớp trước đến lớp tiếp theo. Bạn sử dụng hàm kích hoạt softmax để phân loại số trên ảnh đầu vào.

Tóm tắt lại

Mạng thần kinh chuyển đổi TensorFlow biên dịch các lớp khác nhau trước khi đưa ra dự đoán. Một mạng lưới thần kinh có:

• Một lớp chập
• Chức năng kích hoạt Relu
• Poolinlớp g
• Lớp kết nối dày đặc

Các lớp tích chập áp dụng các bộ lọc khác nhau trên một vùng phụ của hình ảnh. Hàm kích hoạt Relu thêm tính phi tuyến tính và các lớp gộp làm giảm tính đa chiều của bản đồ đặc điểm.

Tất cả các lớp này trích xuất thông tin cần thiết từ hình ảnh. Cuối cùng, bản đồ tính năng được cung cấp cho lớp được kết nối đầy đủ chính với chức năng softmax để đưa ra dự đoán.

Đào tạo CNN với TensorFlow

Bây giờ bạn đã quen với khối xây dựng của một mạng, bạn đã sẵn sàng xây dựng một khối với TensorFlow. Chúng tôi sẽ sử dụng bộ dữ liệu MNIST để phân loại hình ảnh CNN.

Chuẩn bị dữ liệu giống như hướng dẫn trước. Bạn có thể chạy mã và chuyển trực tiếp đến kiến ​​trúc của CNN.

Bạn sẽ làm theo các bước dưới đây để phân loại hình ảnh bằng CNN:

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 chập

Bước 4: Poolinlớp g

Bước 5: Lớp chập thứ hai và Pooling Lớ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 để tìm hiểu về điều này URL. Vui lòng tải xuống và lưu trữ trong Tải xuống. Bạn có thể tải nó lên bằng Fetch_mldata('MNIST original').

Tạo tập huấn luyện/kiểm tra

Bạn cần chia tập dữ liệu bằng train_test_split

Quy mô các tính năng

Cuối cùng, bạn có thể mở rộng quy mô tính năng bằng MinMaxScaler như được hiển thị trong phân loại hình ảnh bên dưới bằng ví dụ TensorFlow CNN.

import numpy as np
import tensorflow as tf
from sklearn.datasets import fetch_mldata

#Change USERNAME by the username of your 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

X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

print(X_train.shape, y_train.shape,y_test.shape )
## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))
feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]
X_train_scaled.shape[1:]

Định nghĩa CNN

CNN sử dụng bộ lọc trên pixel thô của hình ảnh để tìm hiểu mẫu chi tiết so với mẫu toàn cục với mạng nơ-ron truyền thống. Để xây dựng CNN, bạn cần xác định:

1. Lớp tích chập: Áp dụng n số bộ lọc cho bản đồ đối tượng. Sau khi tích chập, bạn cần sử dụng chức năng kích hoạt Relu để thêm tính phi tuyến tính vào mạng.
2. Pooling layer: Bước tiếp theo sau khi tích chập là lấy mẫu xuống đặc điểm max. Mục đích là giảm chiều của bản đồ đặc điểm để tránh quá khớp và cải thiện tốc độ tính toán. Max pooling là kỹ thuật thông thường, chia bản đồ đặc điểm thành các vùng phụ (thường có kích thước 2×2) và chỉ giữ lại các giá trị tối đa.
3. Các lớp được kết nối đầy đủ: Tất cả các neuron từ các lớp trước được kết nối với các lớp tiếp theo. CNN sẽ phân loại nhãn theo các đặc điểm từ các lớp tích chập và giảm với lớp gộp.

Kiến trúc CNN

• Convolutional Layer: Áp dụng 14 bộ lọc 5×5 (trích xuất các vùng con 5×5 pixel), có chức năng kích hoạt ReLU
• Pooling Lớp: Thực hiện gộp nhóm tối đa với bộ lọc 2×2 và bước tiến là 2 (chỉ định rằng các vùng gộp nhóm không chồng lấn)
• Lớp tích chập: Áp dụng 36 bộ lọc 5×5, có chức năng kích hoạt ReLU
• Pooling Lớp #2: Một lần nữa, thực hiện gộp nhóm tối đa với bộ lọc 2×2 và bước tiến là 2
• 1,764 nơ-ron, với tỷ lệ chính quy bỏ học là 0.4 (xác suất 0.4 mà bất kỳ phần tử nhất định nào sẽ bị loại bỏ trong quá trình huấn luyện)
• Lớp dày đặc (Lớp nhật ký): 10 nơ-ron, một nơ-ron cho mỗi lớp mục tiêu chữ số (0–9).

Có ba mô-đun quan trọng cần sử dụng để tạo CNN:

• conv2d(). Xây dựng một lớp tích chập hai chiều với số lượng bộ lọc, kích thước hạt nhân bộ lọc, phần đệm và hàm kích hoạt làm đối số.
• max_pooling2d(). Xây dựng một lớp gộp hai chiều bằng thuật toán gộp tối đa.
• ngu độn(). Xây dựng một lớp dày đặc với các lớp và đơn vị ẩn

Bạn sẽ xác định một hàm để xây dựng CNN. Chúng ta hãy xem chi tiết cách xây dựng từng khối xây dựng trước đó để gói mọi thứ lại với nhau trong hàm.

Bước 2: Lớp đầu vào

def cnn_model_fn(features, labels, mode):
    input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Bạn cần xác định một tensor với hình dạng của dữ liệu. Để làm được điều đó, bạn có thể sử dụng mô-đun tf.reshape. Trong mô-đun này, bạn cần khai báo tensor để định hình lại và hình dạng của tensor. Đối số đầu tiên là các tính năng của dữ liệu, được xác định trong đối số của hàm.

Hình ảnh có chiều cao, chiều rộng và kênh. Bộ dữ liệu MNIST là một bức ả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 tính năng [“x”]. Ưu điểm là làm cho các siêu tham số kích thước lô có thể điều chỉnh được. Nếu kích thước lô được đặt thành 7 thì tensor sẽ cung cấp 5,488 giá trị (28*28*7).

Bước 3: Lớp chập

# first Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=14,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

Lớp tích chập đầu tiên có 14 bộ lọc với kích thước hạt nhân là 5 × 5 với cùng một phần đệm. Phần đệm giống nhau có nghĩa là cả tensor đầu ra và tensor đầu vào phải có cùng chiều cao và chiều rộng. Tensorflow sẽ thêm số XNUMX vào các hàng và cột để đảm bảo cùng kích thước.

Bạn sử dụng chức năng kích hoạt Relu. Kích thước đầu ra sẽ là [28, 28, 14].

Bước 4: Poolinlớp g

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ẽ giảm chiều của dữ liệu. Bạn có thể sử dụng mô-đun max_pooling2d với kích thước 2×2 và bước nhảy là 2. Bạn sử dụng lớp trước làm đầu vào. Kích thước đầu ra sẽ là [batch_size, 14, 14, 14]

# first Pooling Layer 
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Bước 5: Lớp chập thứ hai và Pooling Lớp

Lớp tích chập thứ hai có 32 bộ lọc, với kích thước đầu ra là [batch_size, 14, 14, 32]. Lớp pooling có cùng kích thước như trước và hình dạng đầu ra là [batch_size, 14, 14, 18].

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: Lớp dày đặc

Sau đó, bạn cần xác định lớp được kết nối đầy đủ. Bản đồ đặc trưng phải được làm phẳng trước khi được kết nối với lớp dày đặc. Bạn 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 nơ-ron. Bạn thêm chức năng kích hoạt Relu. Ngoài ra, bạn thêm thuật ngữ chính quy bỏ học với tỷ lệ 0.3, nghĩa là 30 phần trăm trọng số sẽ được đặt thành 0. Lưu ý rằng việc bỏ học chỉ diễn ra trong giai đoạn huấn luyện. Hàm cnn_model_fn có chế độ đối số để khai báo xem mô hình có cần được huấn luyện hay để đánh giá như trong ví dụ TensorFlow phân loại hình ảnh CNN bên dưới hay không.

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 đăng nhập

Cuối cùng trong ví dụ phân loại hình ảnh TensorFlow, bạn có thể xác định lớp cuối cùng bằng dự đoán của mô hình. Hình dạng đầu ra bằng kích thước lô và 10, tổng số hình ảnh.

# Logits Layer
logits = tf.layers.dense(inputs=dropout, units=10)

Bạn có thể tạo một từ điển chứa các lớp và xác suất của mỗi lớp. Mô-đun tf.argmax() trả về giá trị cao nhất 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")  }			

Bạn chỉ muốn trả về dự đoán từ điển khi chế độ được đặt thành dự đoán. Bạn thêm mã này để phân tán 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. Trong hướng dẫn trước, bạn đã học rằng hàm tổn thất cho mô hình đa lớp là entropy chéo. Tổn thất có thể dễ dàng được tính toán bằng mã sau:

# Calculate Loss (for both TRAIN and EVAL modes)
loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

Bước cuối cùng của ví dụ TensorFlow CNN là tối ưu hóa mô hình, tức là tìm các giá trị tốt nhất của các trọng số. Để làm được điều đó, bạn sử dụng trình tối ưu hóa giảm dần độ dốc với tốc độ học tập là 0.001. Mục tiêu là giảm thiểu tổn thất

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())

Bạn đã xong việc với CNN. Tuy nhiên, bạn 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 nhiều lớp là số liệu chính xác. Tensorflow được trang bị độ chính xác của mô-đun 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)

Đó là nó. Bạn đã tạo CNN đầu tiên của mình và bạn đã sẵn sàng gói mọi thứ vào một hàm để sử dụng nó nhằm đà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)

Các bước bên dưới cũng giống như các hướng dẫn trước.

Trước hết, bạn xác định công cụ ước tính bằng mô hình CNN để phân loại hình ảnh.

# Create the Estimator
mnist_classifier = tf.estimator.Estimator(
    model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")

Một CNN mất nhiều thời gian để huấn luyện, do đó, bạn tạo một Logging hook để lưu trữ các giá trị của các lớp softmax sau mỗi 50 lần lặp.

# Set up logging for predictions
tensors_to_log = {"probabilities": "softmax_tensor"}
logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)

Bạn đã sẵn sàng để ước tính mô hình. Bạn đặt kích thước lô là 100 và xáo trộn dữ liệu. Lưu ý rằng chúng ta đặt bước huấn luyện là 16.000, có thể mất rất nhiều thời gian để huấn luyện. Kiên nhẫn.

# 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=16000,
    hooks=[logging_hook])

Bây giờ mô hình đã được huấn luyện, bạn có thể đánh giá nó và in kết quả

# Evaluate the model and print 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 2018-08-05-12:52:41
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56
INFO:tensorflow:Saving dict for global step 15652: accuracy = 0.9589286, global_step = 15652, loss = 0.13894269
{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652}

Với kiến ​​trúc hiện tại, bạn có được độ chính xác là 97%. Bạn có thể thay đổi kiến ​​trúc, kích thước lô và số lần lặp để 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, bạn đã có độ chính xác là 96%, thấp hơn CNN. Hiệu suất của CNN rất ấn tượng với hình ảnh lớn hơn định, cả về tốc độ tính toán và độ chính xác.

Tổng kết

Mạng nơ-ron tích chập hoạt động rất tốt để đánh giá hình ảnh. Kiểu kiến ​​trúc này chiếm ưu thế trong việc nhận dạng các đối tượng từ hình ảnh hoặc video.

Để xây dựng TensorFlow CNN, bạn cần làm theo Bảy bước:

Bước 1: Tải lên tập dữ liệu:

Bộ dữ liệu MNIST có sẵn với scikit để tìm hiểu. Vui lòng tải xuống và lưu trữ trong Tải xuống. Bạn có thể tải nó lên bằng Fetch_mldata('MNIST original').

Bước 2: Lớp đầu vào:

Bước này định hình lại dữ liệu. Hình dạng bằng căn bậc hai của số pixel. Ví dụ, nếu một hình ảnh có 156 pixel, thì hình dạng là 26×26. Bạn cần chỉ định xem hình ảnh có màu hay không. Nếu có, thì bạn có 3 cho hình dạng - 3 cho RGB-, nếu không thì 1.

input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Bước 3: Lớp chập

Tiếp theo, bạn cần tạo các lớp chập. Bạn áp dụng các bộ lọc khác nhau để cho phép mạng tìm hiểu tính năng quan trọng. Bạn chỉ định kích thước của kernel và số lượng bộ lọc.

conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=14,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

Bước 4: Poolinlớp g

Ở bước thứ ba, bạn thêm một lớp pooling. Lớp này làm giảm kích thước của đầu vào. Nó thực hiện điều này bằng cách lấy giá trị lớn nhất của ma trận con a. Ví dụ, nếu ma trận con là [3,1,3,2], thì pooling sẽ trả về giá trị lớn nhất là 3.

pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Bước 5: Thêm lớp chập và Pooling Lớp

Trong bước này, bạn có thể thêm nhiều lớp conv và lớp pooling tùy thích. Google sử dụng kiến ​​trúc với hơn 20 lớp conv.

Bước 6: Lớp dày đặc

Bước 6 làm phẳng bước trước để tạo ra một lớp được kết nối đầy đủ. Trong bước này, bạn có thể sử dụng chức năng kích hoạt khác và thêm hiệu ứng loại bỏ.

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 logit

Bước cuối cùng là dự đoán.

logits = tf.layers.dense(inputs=dropout, units=10)