Giúp bảo vệ Great Barrier Reef với TensorFlow trên Kaggle Tham Challenge

Phân loại cơ bản: Phân loại hình ảnh của quần áo

Xem trên TensorFlow.org Xem nguồn trên GitHub Tải xuống sổ ghi chép

Hướng dẫn này đào tạo mô hình mạng thần kinh để phân loại hình ảnh của quần áo, như giày thể thao và áo sơ mi. Không sao cả nếu bạn không hiểu tất cả các chi tiết; đây là tổng quan có nhịp độ nhanh về một chương trình TensorFlow hoàn chỉnh với các chi tiết được giải thích khi bạn tiếp tục.

Hướng dẫn này sử dụng tf.keras , một API cấp cao để xây dựng và đào tạo mô hình trong TensorFlow.

# TensorFlow and tf.keras
import tensorflow as tf

# Helper libraries
import numpy as np
import matplotlib.pyplot as plt

print(tf.__version__)
2.5.0

Nhập tập dữ liệu MNIST Thời trang

Hướng dẫn này sử dụng thời trang MNIST bộ dữ liệu, trong đó có 70.000 hình ảnh màu xám trong 10 hạng mục. Các hình ảnh hiển thị từng mặt hàng quần áo ở độ phân giải thấp (28 x 28 pixel), như được thấy ở đây:

Thời trang MNIST sprite
Hình 1. mẫu thời trang-MNIST (bởi Zalando, MIT License).

Thời trang MNIST được thiết kế như một thả thay thế cho các cổ điển MNIST dataset-thường được sử dụng như "Hello, World" của các chương trình học máy cho computer vision. Tập dữ liệu MNIST chứa hình ảnh các chữ số viết tay (0, 1, 2, v.v.) có định dạng giống với định dạng của các mặt hàng quần áo bạn sẽ sử dụng ở đây.

Hướng dẫn này sử dụng Fashion MNIST vì sự đa dạng và vì nó là một vấn đề khó khăn hơn một chút so với MNIST thông thường. Cả hai tập dữ liệu đều tương đối nhỏ và được sử dụng để xác minh rằng một thuật toán hoạt động như mong đợi. Chúng là những điểm khởi đầu tốt để kiểm tra và gỡ lỗi mã.

Ở đây, 60.000 hình ảnh được sử dụng để huấn luyện mạng và 10.000 hình ảnh để đánh giá mức độ chính xác của mạng đã học để phân loại hình ảnh. Bạn có thể truy cập MNIST Thời trang trực tiếp từ TensorFlow. Nhập khẩu và tải các dữ liệu thời trang MNIST trực tiếp từ TensorFlow:

fashion_mnist = tf.keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
32768/29515 [=================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
26427392/26421880 [==============================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
8192/5148 [===============================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz
4423680/4422102 [==============================] - 0s 0us/step

Tải tập dữ liệu trả về bốn mảng NumPy:

  • Các train_imagestrain_labels mảng là đào tạo thiết -the dữ liệu việc sử dụng mô hình để học hỏi.
  • Mô hình này được thử nghiệm chống lại các thiết lập kiểm tra, các test_images , và test_labels mảng.

Các hình ảnh được 28x28 mảng NumPy, với giá trị pixel từ 0 đến 255. Các nhãn được một mảng các số nguyên, dao động từ 0 đến 9. Những tương ứng với các lớp quần áo hình ảnh đại diện:

Nhãn mác Lớp
0 Áo phông / áo sơ mi
1 Ống quần
2 Kéo qua
3 Đầm
4 Áo choàng
5 Sandal
6 Áo sơ mi
7 Giày thể thao
số 8 Cái túi
9 Ủng cổ chân

Mỗi hình ảnh được ánh xạ tới một nhãn duy nhất. Kể từ khi tên lớp không được bao gồm trong các tập dữ liệu, lưu trữ chúng ở đây để sử dụng sau khi vẽ hình ảnh:

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

Khám phá dữ liệu

Hãy cùng khám phá định dạng của tập dữ liệu trước khi huấn luyện mô hình. Phần sau cho thấy có 60.000 hình ảnh trong tập huấn luyện, với mỗi hình ảnh được biểu thị là 28 x 28 pixel:

train_images.shape
(60000, 28, 28)

Tương tự như vậy, có 60.000 nhãn trong tập huấn luyện:

len(train_labels)
60000

Mỗi nhãn là một số nguyên từ 0 đến 9:

train_labels
array([9, 0, 0, ..., 3, 0, 5], dtype=uint8)

Có 10.000 hình ảnh trong bộ thử nghiệm. Một lần nữa, mỗi hình ảnh được biểu thị dưới dạng 28 x 28 pixel:

test_images.shape
(10000, 28, 28)

Và bộ thử nghiệm bao gồm 10.000 nhãn hình ảnh:

len(test_labels)
10000

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

Dữ liệu phải được xử lý trước trước khi huấn luyện mạng. Nếu bạn kiểm tra hình ảnh đầu tiên trong tập huấn luyện, bạn sẽ thấy rằng các giá trị pixel nằm trong phạm vi từ 0 đến 255:

plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.grid(False)
plt.show()

png

Chia tỷ lệ các giá trị này thành một phạm vi từ 0 đến 1 trước khi đưa chúng vào mô hình mạng thần kinh. Để làm như vậy, chia các giá trị bằng 255. Điều quan trọng là tập huấn luyệnthử nghiệm các thiết lập được xử lý trước theo cách tương tự là:

train_images = train_images / 255.0

test_images = test_images / 255.0

Để xác minh rằng các dữ liệu có định dạng chính xác và rằng bạn đã sẵn sàng để xây dựng và đào tạo mạng, hãy hiển thị 25 hình ảnh đầu tiên từ tập huấn luyện và hiển thị tên lớp bên dưới mỗi hình ảnh.

plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.show()

png

Xây dựng mô hình

Xây dựng mạng nơ-ron yêu cầu cấu hình các lớp của mô hình, sau đó biên dịch mô hình.

Thiết lập các lớp

Các khối xây dựng cơ bản của một mạng lưới thần kinh là lớp . Các lớp trích xuất các đại diện từ dữ liệu được đưa vào chúng. Hy vọng rằng, những biểu diễn này có ý nghĩa đối với vấn đề đang giải quyết.

Hầu hết học sâu bao gồm việc xâu chuỗi các lớp đơn giản lại với nhau. Hầu hết các lớp, chẳng hạn như tf.keras.layers.Dense , có tham số được học trong đào tạo.

model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10)
])

Lớp đầu tiên trong mạng này, tf.keras.layers.Flatten , biến đổi định dạng của các hình ảnh từ một mảng hai chiều (28 28 pixel) vào một mảng một chiều (28 * 28 = 784 pixel). Hãy nghĩ về lớp này giống như các hàng pixel trong hình ảnh và xếp chúng thành hàng. Lớp này không có tham số để học; nó chỉ định dạng lại dữ liệu.

Sau khi các điểm ảnh được san phẳng, mạng bao gồm một chuỗi các hai tf.keras.layers.Dense lớp. Đây là các lớp thần kinh được kết nối dày đặc, hoặc được kết nối đầy đủ. Đầu tiên Dense lớp có 128 nút (hoặc tế bào thần kinh). Lớp thứ hai (và cuối cùng) trả về một mảng logits có độ dài là 10. Mỗi nút chứa một điểm cho biết hình ảnh hiện tại thuộc về một trong 10 lớp.

Biên dịch mô hình

Trước khi mô hình sẵn sàng để đào tạo, nó cần thêm một số cài đặt. Đây là những bổ sung trong thời gian của mô hình biên dịch bước:

  • Chức năng mất -đây biện pháp như thế nào chính xác mô hình này là quá trình đào tạo. Bạn muốn thu nhỏ chức năng này để "chèo lái" mô hình đi đúng hướng.
  • Optimizer -Đây là cách mô hình được cập nhật dựa trên các dữ liệu mà nó nhìn thấy và chức năng bị mất của mình.
  • Metrics -Dùng để giám sát công tác đào tạo và các bước thử nghiệm. Ví dụ sau sử dụng chính xác, cho phần của hình ảnh được phân loại một cách chính xác.
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

Đào tạo mô hình

Đào tạo mô hình mạng nơ-ron yêu cầu các bước sau:

  1. Cung cấp dữ liệu đào tạo vào mô hình. Trong ví dụ này, dữ liệu huấn luyện là trong train_imagestrain_labels mảng.
  2. Mô hình học cách liên kết hình ảnh và nhãn.
  3. Bạn hỏi các mô hình để đưa ra dự đoán về một thử nghiệm thiết trong ví dụ này, test_images mảng.
  4. Xác minh rằng các dự đoán phù hợp với nhãn từ test_labels mảng.

Nuôi mô hình

Để bắt đầu đào tạo, gọi model.fit phương pháp-gọi như vậy vì nó "phù hợp" mô hình dữ liệu huấn luyện:

model.fit(train_images, train_labels, epochs=10)
Epoch 1/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.4982 - accuracy: 0.8256
Epoch 2/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3747 - accuracy: 0.8658
Epoch 3/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3356 - accuracy: 0.8770
Epoch 4/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3112 - accuracy: 0.8856
Epoch 5/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2941 - accuracy: 0.8915
Epoch 6/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2776 - accuracy: 0.8972
Epoch 7/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2678 - accuracy: 0.9000
Epoch 8/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2564 - accuracy: 0.9049
Epoch 9/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2467 - accuracy: 0.9083
Epoch 10/10
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2399 - accuracy: 0.9103
<tensorflow.python.keras.callbacks.History at 0x7fe108a0c150>

Khi mô hình đào tạo, các số liệu về tổn thất và độ chính xác được hiển thị. Mô hình này đạt độ chính xác khoảng 0,91 (hoặc 91%) trên dữ liệu đào tạo.

Đánh giá độ chính xác

Tiếp theo, so sánh cách mô hình hoạt động trên tập dữ liệu thử nghiệm:

test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)

print('\nTest accuracy:', test_acc)
313/313 - 0s - loss: 0.3413 - accuracy: 0.8814

Test accuracy: 0.8813999891281128

Nó chỉ ra rằng độ chính xác trên tập dữ liệu thử nghiệm ít hơn một chút so với độ chính xác trên tập dữ liệu đào tạo. Khoảng cách này giữa độ chính xác đào tạo và chính xác kiểm tra đại diện cho overfitting. Việc trang bị quá mức xảy ra khi một mô hình học máy hoạt động kém hơn trên các đầu vào mới, chưa từng thấy trước đây so với mô hình học trên dữ liệu đào tạo. Một mô hình được trang bị quá mức sẽ "ghi nhớ" tiếng ồn và chi tiết trong tập dữ liệu huấn luyện đến một điểm mà nó tác động tiêu cực đến hiệu suất của mô hình trên dữ liệu mới. Để biết thêm thông tin, hãy xem phần sau:

Dự đoán

Với mô hình được đào tạo, bạn có thể sử dụng nó để đưa ra dự đoán về một số hình ảnh. Mô hình của kết quả đầu ra tuyến tính, logits . Đính kèm một lớp softmax để chuyển đổi nhật ký thành xác suất, dễ hiểu hơn.

probability_model = tf.keras.Sequential([model, 
                                         tf.keras.layers.Softmax()])
predictions = probability_model.predict(test_images)

Ở đây, mô hình đã dự đoán nhãn cho mỗi hình ảnh trong bộ thử nghiệm. Hãy cùng xem dự đoán đầu tiên:

predictions[0]
array([2.9212106e-07, 1.6208847e-10, 1.3363140e-08, 2.7341349e-09,
       5.5379962e-10, 4.5457238e-04, 4.2226111e-06, 4.4925120e-03,
       5.8868943e-07, 9.9504781e-01], dtype=float32)

Dự đoán là một dãy 10 số. Chúng đại diện cho "sự tự tin" của người mẫu rằng hình ảnh tương ứng với mỗi trong số 10 mặt hàng quần áo khác nhau. Bạn có thể xem nhãn nào có giá trị tin cậy cao nhất:

np.argmax(predictions[0])
9

Vì vậy, mô hình này là tự tin nhất mà hình ảnh này là một khởi động mắt cá chân, hoặc class_names[9] . Kiểm tra nhãn thử nghiệm cho thấy rằng phân loại này là chính xác:

test_labels[0]
9

Vẽ biểu đồ này để xem toàn bộ dự đoán lớp 10.

def plot_image(i, predictions_array, true_label, img):
  true_label, img = true_label[i], img[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])

  plt.imshow(img, cmap=plt.cm.binary)

  predicted_label = np.argmax(predictions_array)
  if predicted_label == true_label:
    color = 'blue'
  else:
    color = 'red'

  plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                100*np.max(predictions_array),
                                class_names[true_label]),
                                color=color)

def plot_value_array(i, predictions_array, true_label):
  true_label = true_label[i]
  plt.grid(False)
  plt.xticks(range(10))
  plt.yticks([])
  thisplot = plt.bar(range(10), predictions_array, color="#777777")
  plt.ylim([0, 1])
  predicted_label = np.argmax(predictions_array)

  thisplot[predicted_label].set_color('red')
  thisplot[true_label].set_color('blue')

Xác minh dự đoán

Với mô hình được đào tạo, bạn có thể sử dụng nó để đưa ra dự đoán về một số hình ảnh.

Hãy xem hình ảnh thứ 0, dự đoán và mảng dự đoán. Nhãn dự đoán đúng có màu xanh lam và nhãn dự đoán không chính xác có màu đỏ. Con số cho biết tỷ lệ phần trăm (trong số 100) cho nhãn được dự đoán.

i = 0
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i],  test_labels)
plt.show()

png

i = 12
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i],  test_labels)
plt.show()

png

Hãy vẽ một số hình ảnh với dự đoán của họ. Lưu ý rằng mô hình có thể sai ngay cả khi rất tự tin.

# Plot the first X test images, their predicted labels, and the true labels.
# Color correct predictions in blue and incorrect predictions in red.
num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
  plt.subplot(num_rows, 2*num_cols, 2*i+1)
  plot_image(i, predictions[i], test_labels, test_images)
  plt.subplot(num_rows, 2*num_cols, 2*i+2)
  plot_value_array(i, predictions[i], test_labels)
plt.tight_layout()
plt.show()

png

Sử dụng mô hình được đào tạo

Cuối cùng, sử dụng mô hình được đào tạo để đưa ra dự đoán về một hình ảnh duy nhất.

# Grab an image from the test dataset.
img = test_images[1]

print(img.shape)
(28, 28)

tf.keras mô hình được tối ưu hóa để đưa ra dự đoán về một lô, hoặc bộ sưu tập, ví dụ cùng một lúc. Do đó, mặc dù bạn đang sử dụng một hình ảnh duy nhất, bạn cần phải thêm nó vào danh sách:

# Add the image to a batch where it's the only member.
img = (np.expand_dims(img,0))

print(img.shape)
(1, 28, 28)

Bây giờ hãy dự đoán nhãn chính xác cho hình ảnh này:

predictions_single = probability_model.predict(img)

print(predictions_single)
[[8.8914348e-05 1.3264636e-13 9.9108773e-01 1.2658383e-10 8.1463791e-03
  1.6905785e-08 6.7695131e-04 2.7492119e-17 5.1699739e-10 7.1339325e-17]]
plot_value_array(1, predictions_single[0], test_labels)
_ = plt.xticks(range(10), class_names, rotation=45)
plt.show()

png

tf.keras.Model.predict trả về một danh sách liệt kê-một danh sách cho mỗi hình ảnh trong hàng loạt dữ liệu. Lấy các dự đoán cho hình ảnh (duy nhất) của chúng tôi trong lô:

np.argmax(predictions_single[0])
2

Và mô hình dự đoán một nhãn như mong đợi.

# MIT License
#
# Copyright (c) 2017 François Chollet
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.