Помогают защитить Большой Барьерный Риф с TensorFlow на Kaggle Присоединяйтесь вызов

Базовая классификация: классифицируйте изображения одежды.

Посмотреть на TensorFlow.org Запускаем в Google Colab Посмотреть исходный код на GitHub Скачать блокнот

Это руководство обучает модель нейронной сети классификации изображений одежды, например кроссовок и рубашек. Ничего страшного, если вы не понимаете всех деталей; это быстрый обзор полной программы TensorFlow с подробностями, объясняемыми по ходу дела.

Это руководство использует tf.keras , высокоуровневый API для создания и железнодорожных моделей в 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

Импортируйте набор данных Fashion MNIST

Это руководство использует моды MNIST набор данных , который содержит 70000 черно - белых изображений в 10 категориях. На изображениях показаны отдельные предметы одежды в низком разрешении (28 на 28 пикселей), как показано здесь:

Модный спрайт MNIST
Рисунок 1. Образцы Мода-MNIST (по Zalando, MIT License).

Мода MNIST предназначена как капля замены для классического MNIST набора данных, часто используются как «Hello, World» программ машинного обучения для компьютерного зрения. Набор данных MNIST содержит изображения рукописных цифр (0, 1, 2 и т. Д.) В формате, идентичном формату предметов одежды, которые вы здесь будете использовать.

Это руководство использует Fashion MNIST для разнообразия и потому, что это немного более сложная проблема, чем обычный MNIST. Оба набора данных относительно малы и используются для проверки правильности работы алгоритма. Они являются хорошей отправной точкой для тестирования и отладки кода.

Здесь 60 000 изображений используются для обучения сети и 10 000 изображений для оценки того, насколько точно сеть научилась классифицировать изображения. Вы можете получить доступ к Fashion MNIST прямо из TensorFlow. Импорт и загрузить данные моды MNIST непосредственно из 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

Загрузка набора данных возвращает четыре массива NumPy:

  • В train_images и train_labels массивы обучающего набора -The данных в модели используется , чтобы учиться.
  • Модель проверяется на тест - набор, в test_images и test_labels массивов.

Изображения 28х28 Numpy массивов со значениями пикселей в диапазоне от 0 до 255. этикеток массив целых чисел в диапазоне от 0 до 9. Они соответствуют классу одежды изображения представляет:

Этикетка Класс
0 Футболка / топ
1 Брюки
2 Перетягивать
3 Одеваться
4 Пальто
5 Сандалии
6 Рубашка
7 Кроссовки
8 Сумка
9 Ботинок по щиколотку

Каждое изображение сопоставляется с одной меткой. Поскольку имена классов не включены в набор данных, хранить их здесь , чтобы использовать позже при печати изображений:

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

Изучите данные

Давайте рассмотрим формат набора данных перед обучением модели. Следующее показывает, что в обучающем наборе 60000 изображений, каждое из которых представлено как 28 x 28 пикселей:

train_images.shape
(60000, 28, 28)

Точно так же в обучающем наборе 60000 меток:

len(train_labels)
60000

Каждая метка представляет собой целое число от 0 до 9:

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

В тестовой выборке 10 000 изображений. Опять же, каждое изображение представлено как 28 x 28 пикселей:

test_images.shape
(10000, 28, 28)

А тестовый набор содержит 10000 изображений-этикеток:

len(test_labels)
10000

Предварительно обработать данные

Перед обучением сети данные должны быть предварительно обработаны. Если вы проверите первое изображение в обучающем наборе, вы увидите, что значения пикселей попадают в диапазон от 0 до 255:

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

PNG

Масштабируйте эти значения в диапазоне от 0 до 1, прежде чем передавать их в модель нейронной сети. Для этого разделите значения на 255. Это важно, чтобы обучение множество и множество испытаний будут препроцессором таким же образом:

train_images = train_images / 255.0

test_images = test_images / 255.0

Для того, чтобы убедиться в том , что данные в правильном формате и что вы готовы построить и обучить сеть, давайте отображать первые 25 изображений из обучающего набора и отобразить имя класса ниже каждого изображения.

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

Построить модель

Построение нейронной сети требует настройки слоев модели, а затем компиляции модели.

Настройте слои

Основной структурный элемент нейронной сети является слоем . Слои извлекают представления из введенных в них данных. Надеюсь, эти представления имеют смысл для решения рассматриваемой проблемы.

Большая часть глубокого обучения состоит из объединения простых слоев. Большинство слоев, таких как tf.keras.layers.Dense , имеют параметры, которые выучили во время тренировки.

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

Первый слой в этой сети, tf.keras.layers.Flatten , преобразует формат изображений из двумерного массива (от 28 до 28 пикселей) для одномерного массива (28 * 28 = 784 пикселей). Думайте об этом слое как о разделении рядов пикселей на изображении и их выравнивании. У этого слоя нет параметров для изучения; он только переформатирует данные.

После того, как пиксели сплющены, сеть состоит из последовательности двух tf.keras.layers.Dense слоев. Это плотно связанные или полностью связанные нейронные слои. Первый Dense слой имеет 128 узлов (или нейроны). Второй (и последний) уровень возвращает массив логитов длиной 10. Каждый узел содержит оценку, которая указывает, что текущее изображение принадлежит одному из 10 классов.

Скомпилируйте модель

Прежде чем модель будет готова к обучению, ей нужно сделать еще несколько настроек. Они добавляются в ходе модели компиляции шага:

  • Функция Loss -Этот меры , насколько точна модель является во время тренировки. Вы хотите минимизировать эту функцию, чтобы «направить» модель в правильном направлении.
  • Оптимизатор -Этот как модель обновляется на основе данных , которые он видит и его функции потерь.
  • Метрики -Используются контролировать подготовку и тестирование шагов. Следующий пример использует точность, долю изображений, которые правильно классифицированы.
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

Обучите модель

Обучение модели нейронной сети требует следующих шагов:

  1. Загрузите данные обучения в модель. В этом примере данные тренировок в train_images и train_labels массивов.
  2. Модель учится связывать изображения и ярлыки.
  3. Вы спросите модель , чтобы делать прогнозы о множестве, в данном примере, тест - test_images массива.
  4. Убедитесь в том, что предсказания совпадают метки из test_labels массива.

Накормите модель

Для того, чтобы начать обучение, вызовите model.fit метод, так называемый , потому что он «соответствует» модель для подготовки данных:

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>

По мере обучения модели отображаются метрики потерь и точности. Эта модель достигает точности около 0,91 (или 91%) на данных обучения.

Оцените точность

Затем сравните, как модель работает на тестовом наборе данных:

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

Оказывается, точность тестового набора данных немного меньше точности обучающего набора данных. Этот разрыв между точностью обучения и точностью теста представляет переобучения. Переобучение происходит, когда модель машинного обучения работает хуже с новыми, ранее невидимыми входными данными, чем с данными обучения. Переобученная модель «запоминает» шум и детали в наборе обучающих данных до такой степени, что это отрицательно влияет на производительность модели в отношении новых данных. Для получения дополнительной информации см. Следующее:

Делать предсказания

Обучив модель, вы можете использовать ее для прогнозирования некоторых изображений. В модели линейных выходов, логит - анализ . Прикрепите слой softmax, чтобы преобразовать логиты в вероятности, которые легче интерпретировать.

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

Здесь модель предсказала метку для каждого изображения в наборе для тестирования. Давайте посмотрим на первый прогноз:

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)

Прогноз - это массив из 10 чисел. Они отражают «уверенность» модели в том, что изображение соответствует каждому из 10 различных предметов одежды. Вы можете увидеть, какая метка имеет наибольшее значение достоверности:

np.argmax(predictions[0])
9

Таким образом, модель наиболее уверен , что этот образ является полусапожки или class_names[9] . Изучение этикетки теста показывает, что эта классификация верна:

test_labels[0]
9

Изобразите график, чтобы увидеть полный набор из 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')

Проверить прогнозы

Обучив модель, вы можете использовать ее для прогнозирования некоторых изображений.

Давайте посмотрим на 0-е изображение, прогнозы и массив прогнозов. Метки правильного прогноза отображаются синим цветом, а метки неверного прогноза - красным. Число показывает процент (из 100) предсказанной метки.

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

Построим несколько изображений с их предсказаниями. Учтите, что модель может ошибаться, даже если очень уверена.

# 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

Используйте обученную модель

Наконец, используйте обученную модель, чтобы сделать прогноз для одного изображения.

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

print(img.shape)
(28, 28)

tf.keras модель оптимизирована , чтобы сделать прогнозы на партии, или коллекцию, примеры сразу. Соответственно, даже если вы используете одно изображение, вам необходимо добавить его в список:

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

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

Теперь предскажите правильную метку для этого изображения:

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 возвращает список списков, один список для каждого изображения в пакете данных. Возьмите прогнозы для нашего (единственного) изображения в пакете:

np.argmax(predictions_single[0])
2

И модель предсказывает метку, как и ожидалось.

# 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.