В этом руководстве используется машинное обучение для классификации ирисов по видам. Он использует Eager Execution TensorFlow для выполнения следующих задач:
- строить модели,
- обучить модель, используя образцы данных, и
- Используйте эту модель, чтобы делать прогнозы по неизвестным данным.
Программирование TensorFlow
В этом руководстве используются следующие расширенные концепции TensorFlow:
- Включите среду разработки Eager Execution,
- импортировать данные с помощью Datasets API,
- Создавайте модели и слои с помощью Keras API от TensorFlow.
В этом руководстве используется структура, аналогичная многим программам TensorFlow:
- Импорт и анализ наборов данных.
- Выберите тип модели.
- Обучите модель.
- Оцените производительность модели.
- Используйте обученную модель, чтобы делать прогнозы.
программа установки
Импорт конфигурации и быстрое выполнение
Импортируйте нужный модуль Python (включая Tensorflow) и включите Eager Execution для этой программы. С Eager Execution Tensorflow немедленно оценит операции и вернется к конкретным значениям вместо создания вычислений, выполняемых позже. Если вы привыкли использовать интерактивную консоль REPL или PYTHON, вы будете использовать ее для Eager Execution. Eager Execution предоставляется в Tensorflow 1.8 и выше.
После включения Eager Execution нельзя отключить в той же программе. Для получения дополнительной информации см.Руководство по нетерпеливому исполнению.
from __future__ import absolute_import, division, print_function
import os
import matplotlib.pyplot as plt
import tensorflow as tf
import tensorflow.contrib.eager as tfe
tf.enable_eager_execution()
print("TensorFlow version: {}".format(tf.VERSION))
print("Eager execution: {}".format(tf.executing_eagerly()))
TensorFlow version: 1.13.1
Eager execution: True
Проблема классификации ирисов
Представьте, что вы ботаник, который ищет способ автоматически классифицировать каждый найденный вами ирис. Машинное обучение предоставляет множество алгоритмов для статистической классификации цветов. Например, сложная программа машинного обучения может классифицировать цветы на основе фотографий. Требования у нас не высокие - будем классифицировать ирисы по длине и ширине их чашелистиков и лепестков.
Род Iris насчитывает около 300 видов, но наша программа классифицирует только следующие три вида:
- Горный ирис
- Вирджиния Ирис
- ирис разноцветный
Рисунок 1. Iris montane (автор: Radomil, используется в рамках CC BY-SA 3.0), Iris versicolor (автор: Dlanglois, используется в соответствии с CC BY-SA 3.0) и Iris virginica (автор: Frank Mayfield, используется в соответствии с CC BY-SA 3.0) 3.0) Использование CC BY-SA 2.0).
К счастью, кто-то создал набор данных из 120 ирисов (с измерениями чашелистиков и лепестков). Это классический набор данных, который часто используется в задачах классификации машинного обучения начального уровня.
Импорт и анализ обучающего набора данных
Загрузите файл набора данных и преобразуйте его в структуру, которую можно использовать в этой программе Python.
Скачать набор данных
Загрузите файл набора обучающих данных с помощью функции tf.keras.utils.get_file. Эта функция возвращает путь к загруженному файлу.
train_dataset_url = "http://download.tensorflow.org/data/iris_training.csv"
train_dataset_fp = tf.keras.utils.get_file(fname=os.path.basename(train_dataset_url),
origin=train_dataset_url)
print("Local copy of the dataset file: {}".format(train_dataset_fp))
Local copy of the dataset file: C:\Users\Administrator\.keras\datasets\iris_training.csv
Проверить данные
Набор данных iris_training.csv представляет собой обычный текстовый файл, в котором хранятся табличные данные в формате значений, разделенных запятыми (CSV). Используйте команду head -n5, чтобы увидеть первые 5 записей:
import pandas as pd
data = pd.read_csv(train_dataset_fp,nrows =5)
print(data)
120 4 setosa versicolor virginica
0 6.4 2.8 5.6 2.2 2
1 5.0 2.3 3.3 1.0 1
2 4.9 2.5 4.5 1.7 2
3 4.9 3.1 1.5 0.1 0
4 5.7 3.8 1.7 0.3 0
Мы можем заметить следующую информацию из этого представления набора данных:
- Первая строка — это заголовок, который содержит информацию о наборе данных:
- Всего 120 образцов. Каждый образец имеет четыре функции и имя метки, а также три возможных имени метки.
- Следующие строки представляют собой записи данных, по одной для каждого образца, где:
- Первые четыре поля — это признаки, то есть характеристики выборки. В этом наборе данных в этих полях хранятся числа с плавающей запятой, представляющие измерения цветов.
- Последний столбец — это метка: значение, которое мы хотим предсказать. Для этого набора данных значение представляет собой целочисленное значение 0, 1 или 2 (каждое значение соответствует названию цветка).
Мы выражаем это в коде:
# column order in CSV file
column_names = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'species']
feature_names = column_names[:-1]
label_name = column_names[-1]
print("Features: {}".format(feature_names))
print("Label: {}".format(label_name))
Features: ['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
Label: species
Каждая метка индивидуально связана с именем строки (например, «setosa»), но машинное обучение часто использует числовые значения. Номер метки сопоставляется с указанным обозначением, например:
- 0: горный ирис
- 1: меняющая цвет радужка
- 2: Вирджиния Ирис
Дополнительные сведения о функциях и метках см.Ускоренный курс по машинному обучениюв разделе «Терминология машинного обучения».
class_names = ['Iris setosa', 'Iris versicolor', 'Iris virginica']
Создайте tf.data.Dataset
API набора данных TensorFlow обрабатывает многие распространенные ситуации, возникающие при загрузке данных в модель. Это высокоуровневый API для чтения данных и преобразования их в формат, который можно использовать для обучения. Для получения дополнительной информации см.Краткое руководство по набору данных.
Поскольку набор данных представляет собой текстовый файл в формате CSV, используйте функцию make_csv_dataset для преобразования данных в подходящий формат. Поскольку эта функция генерирует данные для обучения модели, поведение по умолчанию заключается в перемешивании данных (shuffle=True, shuffle_buffer_size=10000) и бесконечном повторении набора данных (num_epochs=None). Мы также устанавливаем параметр batch_size.
batch_size = 32
train_dataset = tf.contrib.data.make_csv_dataset(
train_dataset_fp,
batch_size,
column_names=column_names,
label_name=label_name,
num_epochs=1)
WARNING:tensorflow:From <ipython-input-6-b38e4b2864a1>:8: make_csv_dataset (from tensorflow.contrib.data.python.ops.readers) is deprecated and will be removed in a future version.
Instructions for updating:
Use `tf.data.experimental.make_csv_dataset(...)`.
Функция make_csv_dataset возвращает tf.data.Dataset из пар (функций, меток), где функции — это словарь: {'feature_name': значение}
Эти объекты набора данных можно повторять, когда включено Eager Execution. Давайте взглянем на набор функций:
features, labels = next(iter(train_dataset))
features
WARNING:tensorflow:From e:\program files\python37\lib\site-packages\tensorflow\python\data\ops\iterator_ops.py:532: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.
Instructions for updating:
Colocations handled automatically by placer.
OrderedDict([('sepal_length',
<tf.Tensor: id=58, shape=(32,), dtype=float32, numpy=
array([4.8, 5. , 5.5, 7.7, 7.7, 5.8, 6.3, 6.7, 6.3, 4.4, 7. , 6.3, 4.4,
6.5, 4.9, 7.2, 6. , 4.8, 6.9, 6.4, 7.7, 5.8, 6.1, 4.6, 6. , 5.7,
6.7, 5.6, 6.7, 5. , 4.9, 7.2], dtype=float32)>),
('sepal_width',
<tf.Tensor: id=59, shape=(32,), dtype=float32, numpy=
array([3. , 3.5, 3.5, 2.8, 3. , 2.7, 2.3, 3. , 2.5, 3.2, 3.2, 3.3, 2.9,
2.8, 2.5, 3. , 3. , 3.1, 3.1, 3.1, 2.6, 4. , 2.8, 3.4, 2.7, 2.8,
3.3, 2.5, 3. , 2.3, 2.4, 3.2], dtype=float32)>),
('petal_length',
<tf.Tensor: id=56, shape=(32,), dtype=float32, numpy=
array([1.4, 1.3, 1.3, 6.7, 6.1, 5.1, 4.4, 5.2, 5. , 1.3, 4.7, 6. , 1.4,
4.6, 4.5, 5.8, 4.8, 1.6, 5.1, 5.5, 6.9, 1.2, 4.7, 1.4, 5.1, 4.5,
5.7, 3.9, 5. , 3.3, 3.3, 6. ], dtype=float32)>),
('petal_width',
<tf.Tensor: id=57, shape=(32,), dtype=float32, numpy=
array([0.1, 0.3, 0.2, 2. , 2.3, 1.9, 1.3, 2.3, 1.9, 0.2, 1.4, 2.5, 0.2,
1.5, 1.7, 1.6, 1.8, 0.2, 2.3, 1.8, 2.3, 0.2, 1.2, 0.3, 1.6, 1.3,
2.1, 1.1, 1.7, 1. , 1. , 1.8], dtype=float32)>)])Обратите внимание, что похожие функции группируются вместе, т. е. в пакет. Поля для каждой выборочной строки добавляются к соответствующему массиву признаков. Измените batch_size, чтобы установить количество образцов, хранящихся в этих массивах функций.
После построения нескольких функций в пакете вы начинаете видеть некоторую кластеризацию:
plt.scatter(features['petal_length'],
features['sepal_length'],
c=labels,
cmap='viridis')
plt.xlabel("Petal length")
plt.ylabel("Sepal length");
Чтобы упростить этап построения модели, создайте функцию для переупаковки словаря объектов в единый массив формы (batch_size, num_features).
Эта функция использует метод tf.stack, который берет значения из списка тензоров и создает комбинированный тензор указанных размерностей.
def pack_features_vector(features, labels):
"""Pack the features into a single array."""
features = tf.stack(list(features.values()), axis=1)
return features, labels
Затем используйте метод tf.data.Dataset.map, чтобы упаковать функции для каждой пары (функции, метки) в набор обучающих данных:
train_dataset = train_dataset.map(pack_features_vector)
Элемент функций набора данных теперь представляет собой массив формы (размер_пакета, число_функций). Давайте взглянем на первые несколько образцов:
features, labels = next(iter(train_dataset))
print(features[:5])
tf.Tensor(
[[7.6 3. 6.6 2.1]
[6.3 2.5 5. 1.9]
[7.9 3.8 6.4 2. ]
[5. 3.5 1.3 0.3]
[5.8 2.6 4. 1.2]], shape=(5, 4), dtype=float32)
Выберите тип модели
Зачем использовать модели?
Модель относится к взаимосвязи между функциями и метками. Для задачи классификации радужной оболочки модель определяет взаимосвязь между размерами чашечек и лепестков и предсказанными видами радужной оболочки. Некоторые простые модели можно описать несколькими строками алгебры, но сложные модели машинного обучения имеют большое количество параметров, которые сложно обобщить.
Можете ли вы определить взаимосвязь между четырьмя признаками и видами ирисов, не используя машинное обучение? То есть можете ли вы создать модель, используя традиционные методы программирования, такие как множество условных операторов? Возможно, при условии повторного анализа набора данных и окончательного определения размеров лепестков и чашечек по отношению к конкретному сорту. Для более сложных наборов данных это становится очень сложным или даже невозможным. Хороший метод машинного обучения может определить модель для вас. Если вы подадите достаточное количество репрезентативных образцов для модели машинного обучения нужного типа, программа выяснит взаимосвязь за вас.
Выберите модель
Нам нужно выбрать тип модели для обучения. Моделей существует множество, и для того, чтобы выбрать подходящую, требуется некоторый опыт. В этом руководстве нейронная сеть используется для решения задачи классификации радужной оболочки. Нейронные сети могут обнаруживать сложные отношения между функциями и метками. Нейронная сеть — это высокоструктурированный граф, содержащий один или несколько скрытых слоев. Каждый скрытый слой содержит один или несколько нейронов. Существуют различные категории нейронных сетей, и программа использует плотные нейронные сети, также известные как полносвязные нейронные сети: нейроны в одном слое получают входные соединения от каждого нейрона в предыдущем слое. Например, на рисунке 2 показана плотная нейронная сеть с 1 входным слоем, 2 скрытыми слоями и 1 выходным слоем:
Рисунок 2. Нейронная сеть с признаками, скрытыми слоями и предсказаниями
Когда модель на рис. 2 обучена и имеет немаркированные образцы, она выдает 3 прогноза: вероятность того, что соответствующий цветок ириса принадлежит к указанному виду. Это предсказание называется выводом. В этом примере сумма выходных прогнозов равна 1,0. На рисунке 2 этот прогноз разбит следующим образом: 0,02 для ириса калифорнийского, 0,95 для ириса разноцветного и 0,03 для ириса виргинского. Это означает, что модель предсказывает 95% вероятность того, что немаркированный образец радужной оболочки является разноцветным.
Создайте модель с помощью Keras
TensorFlow tf.keras API — предпочтительный способ создания моделей и слоев. API позволяет легко создавать модели и экспериментировать, а Keras выполняет сложную работу по соединению всех частей вместе.
Модель tf.keras.Sequential представляет собой линейный набор слоев. Конструктор модели принимает ряд экземпляров слоев, в данном случае 2 плотных слоя (по 10 узлов в каждом) и 1 выходной слой (3 узла, представляющих предсказания меток). Параметр input_shape первого слоя соответствует количеству объектов в наборе данных и является обязательным параметром.
model = tf.keras.Sequential([
tf.keras.layers.Dense(10, activation=tf.nn.relu, input_shape=(4,)), # input shape required
tf.keras.layers.Dense(10, activation=tf.nn.relu),
tf.keras.layers.Dense(3)
])
Функция активации определяет выходную форму каждого узла в слое. Эти нелинейные отношения важны, без них модель была бы эквивалентна одному слою. Есть много функций активации, но скрытый слой обычно использует ReLU.
Идеальное количество скрытых слоев и нейронов зависит от задачи и набора данных. Как и во многих аспектах машинного обучения, выбор наилучшей формы нейронной сети требует определенного уровня знаний и экспериментов. Как правило, увеличение количества скрытых слоев и нейронов обычно приводит к созданию более мощной модели, для эффективного обучения которой требуется больше данных.
использовать модель
Давайте кратко рассмотрим, как эта модель обрабатывает набор функций:
predictions = model(features)
predictions[:5]
<tf.Tensor: id=228, shape=(5, 3), dtype=float32, numpy=
array([[ 0.95559144, -0.00489247, 2.4814172 ],
[ 0.6847803 , 0.02102977, 1.8848104 ],
[ 0.72697794, -0.03433874, 2.188088 ],
[-0.7955599 , -0.20675494, -0.01517881],
[ 0.4162066 , -0.03564358, 1.3207582 ]], dtype=float32)>Выполнение операции tf.argmax для каждой категории дает прогнозируемый индекс категории. Однако модель не обучалась, поэтому эти прогнозы не идеальны.
print("Prediction: {}".format(tf.argmax(predictions, axis=1)))
print(" Labels: {}".format(labels))
Prediction: [2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]
Labels: [2 2 2 0 1 2 1 1 0 1 1 0 2 1 0 0 0 2 1 1 2 0 1 2 2 0 2 0 2 0 2 1]
Обучите модель
Обучение — это этап машинного обучения, на котором модель постепенно оптимизируется, то есть модель изучает набор данных. Цель состоит в том, чтобы полностью понять структуру обучающего набора данных, чтобы делать прогнозы на невидимых данных. Если вы получите слишком много информации из обучающего набора данных, прогнозы будут применяться только к данным, которые видела модель, но не будут обобщаться. Эта проблема называется переоснащением, и это похоже на запоминание ответов без понимания того, как проблема была решена.
Задача классификации радужной оболочки — пример машинного обучения с учителем: модель обучается на образцах, содержащих метки. В неконтролируемом машинном обучении образцы не содержат меток. Вместо этого модель обычно находит некоторые закономерности в функциях.
Определение функций потерь и градиента
На этапах обучения и оценки нам необходимо рассчитать потери модели. Он измеряет, насколько прогнозы модели отклоняются от ожидаемых меток, то есть насколько плохо работает модель. Мы хотим максимально уменьшить или оптимизировать это значение.
Наша модель вычисляет свои потери с помощью функции tf.losses.sparse_softmax_cross_entropy, которая принимает прогнозы вероятности класса модели и ожидаемые метки и возвращает средние потери для выборок.
def loss(model, x, y):
y_ = model(x)
return tf.losses.sparse_softmax_cross_entropy(labels=y, logits=y_)
l = loss(model, features, labels)
print("Loss test: {}".format(l))
WARNING:tensorflow:From e:\program files\python37\lib\site-packages\tensorflow\python\ops\losses\losses_impl.py:209: to_float (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use tf.cast instead.
Loss test: 1.191253900527954
Используйте контекст tf.GradientTape для вычисления градиентов, используемых для оптимизации модели. Дополнительные примеры см. в руководстве Eager Execution.
def grad(model, inputs, targets):
with tf.GradientTape() as tape:
loss_value = loss(model, inputs, targets)
return loss_value, tape.gradient(loss_value, model.trainable_variables)
Создать оптимизатор
Оптимизатор применит вычисленные градиенты к переменным модели, чтобы минимизировать функцию потерь. Вы можете думать о функции потерь как о поверхности (см. рис. 3), и мы хотим найти самую низкую точку этой поверхности путем обхода. Градиент указывает в направлении наискорейшего подъема, поэтому мы будем двигаться вниз в противоположном направлении. Мы итеративно вычисляем потери и градиент для каждой партии, чтобы настроить модель во время обучения. Модель постепенно находит наилучшее сочетание весов и смещений, чтобы минимизировать потери. Чем меньше потери, тем лучше предсказание модели.
Рисунок 3. Визуализация алгоритма оптимизации во времени в трехмерном пространстве. (Источник: курс Стэнфордского университета CS231n, лицензия Массачусетского технологического института)
В TensorFlow есть множество оптимизированных алгоритмов для обучения. В этой модели используется tf.train.GradientDescentOptimizer, реализующий стохастический градиентный спуск (SGD). Learning_rate используется для установки размера шага для каждой итерации (проходя вниз). Это гиперпараметр, который обычно необходимо настраивать для получения лучших результатов.
Установим счетчик оптимизатора и global_step:
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
global_step = tf.train.get_or_create_global_step()
Мы будем использовать это для вычисления одного шага оптимизации:
loss_value, grads = grad(model, features, labels)
print("Step: {}, Initial Loss: {}".format(global_step.numpy(),
loss_value.numpy()))
optimizer.apply_gradients(zip(grads, model.variables), global_step)
print("Step: {}, Loss: {}".format(global_step.numpy(),
loss(model, features, labels).numpy()))
Step: 0, Initial Loss: 1.191253900527954
Step: 1, Loss: 1.1708548069000244
тренировочный цикл
Когда все готово, пора приступать к обучению модели! Цикл обучения передает образцы набора данных в модель, чтобы помочь модели делать более точные прогнозы. Следующий блок кода устанавливает эти шаги обучения:
- Повторяйте каждый цикл. Один проход по набору данных — это один цикл.
- В одну эпоху выполните итерацию по каждой выборке в обучающем наборе данных и получите характеристики (x) и метки (y) выборок.
- Делайте прогнозы на основе характеристик образцов и сравнивайте прогнозы и метки. Измерьте неточность прогнозов и используйте полученные значения для расчета потерь и градиента модели.
- Используйте оптимизатор для обновления переменных модели.
- Отслеживайте некоторую статистику для визуализации.
- Повторите вышеуказанные шаги для каждого цикла. Переменная num_epochs — это количество обходов коллекции наборов данных. Вопреки интуиции, более длительное обучение модели не гарантирует получение лучшей модели. num_epochs — это гиперпараметр, который можно настраивать. Выбор правильного количества раз обычно требует определенного опыта и экспериментов.
## Note: Rerunning this cell uses the same model variables
# keep results for plotting
train_loss_results = []
train_accuracy_results = []
num_epochs = 201
for epoch in range(num_epochs):
epoch_loss_avg = tfe.metrics.Mean()
epoch_accuracy = tfe.metrics.Accuracy()
# Training loop - using batches of 32
for x, y in train_dataset:
# Optimize the model
loss_value, grads = grad(model, x, y)
optimizer.apply_gradients(zip(grads, model.variables),
global_step)
# Track progress
epoch_loss_avg(loss_value) # add current batch loss
# compare predicted label to actual label
epoch_accuracy(tf.argmax(model(x), axis=1, output_type=tf.int32), y)
# end epoch
train_loss_results.append(epoch_loss_avg.result())
train_accuracy_results.append(epoch_accuracy.result())
if epoch % 50 == 0:
print("Epoch {:03d}: Loss: {:.3f}, Accuracy: {:.3%}".format(epoch,
epoch_loss_avg.result(),
epoch_accuracy.result()))
Epoch 000: Loss: 1.183, Accuracy: 35.000%
Epoch 050: Loss: 0.512, Accuracy: 70.000%
Epoch 100: Loss: 0.354, Accuracy: 90.000%
Epoch 150: Loss: 0.253, Accuracy: 95.833%
Epoch 200: Loss: 0.192, Accuracy: 98.333%
Визуализируйте, как функция потерь изменяется с течением времени
Хотя процесс обучения выходной модели полезен, часто бывает полезнее взглянуть на этот процесс. TensorBoard — отличный инструмент визуализации, упакованный с TensorFlow, но мы можем использовать модуль matplotlib для создания базовых графиков.
Интерпретация этих графиков требует некоторого опыта, но вы хотите, чтобы потери снижались, а точность росла.
fig, axes = plt.subplots(2, sharex=True, figsize=(12, 8))
fig.suptitle('Training Metrics')
axes[0].set_ylabel("Loss", fontsize=14)
axes[0].plot(train_loss_results)
axes[1].set_ylabel("Accuracy", fontsize=14)
axes[1].set_xlabel("Epoch", fontsize=14)
axes[1].plot(train_accuracy_results);
Оцените эффект модели
Модель обучена, и теперь мы можем получить некоторую статистику ее производительности.
Оценка относится к определению того, насколько хорошо модель делает прогнозы. Чтобы определить, насколько хорошо модель работает с классификацией ирисов, передайте модели некоторые измерения чашечек и лепестков и попросите модель предсказать, какие виды ирисов они представляют. Затем сравните прогнозы модели с фактическими метками. Например, если модель правильно предсказывает породы для половины входных выборок, точность составляет 0,5. На рис. 4 показана немного лучшая модель, которая сделала 5 прогнозов, 4 из которых оказались правильными, с точностью 80%:
| Примеры функций | Этикетка | Предсказание модели | |||
|---|---|---|---|---|---|
| 5.9 | 3.0 | 4.3 | 1.5 | 1 | 1 |
| 6.9 | 3.1 | 5.4 | 2.1 | 2 | 2 |
| 5.1 | 3.3 | 1.7 | 0.5 | 0 | 0 |
| 6.0 | 3.4 | 4.5 | 1.6 | 1 | 2 |
| 5.5 | 2.5 | 4.0 | 1.3 | 1 | 1 |
Настроить тестовый набор данных
Оценка модели аналогична обучению модели. Самое большое отличие состоит в том, что образцы поступают из отдельного тестового набора, а не из обучающего набора. Чтобы объективно оценить производительность модели, образцы, используемые для оценки модели, должны отличаться от образцов, используемых для обучения модели.
Настройка тестового набора данных аналогична настройке обучающего набора данных. Загрузите текстовый файл CSV и проанализируйте соответствующие значения, а затем немного рандомизируйте данные:
test_url = "http://download.tensorflow.org/data/iris_test.csv"
test_fp = tf.keras.utils.get_file(fname=os.path.basename(test_url),
origin=test_url)
test_dataset = tf.contrib.data.make_csv_dataset(
train_dataset_fp,
batch_size,
column_names=column_names,
label_name='species',
num_epochs=1,
shuffle=False)
test_dataset = test_dataset.map(pack_features_vector)
Оцените модель по тестовому набору данных
В отличие от этапа обучения, модель оценивается только для одной эпохи тестовых данных. В следующей ячейке кода мы перебираем каждый образец в тестовом наборе и сравниваем прогнозы модели с фактическими метками. Это необходимо для измерения точности модели по всему набору тестов.
test_accuracy = tfe.metrics.Accuracy()
for (x, y) in test_dataset:
logits = model(x)
prediction = tf.argmax(logits, axis=1, output_type=tf.int32)
test_accuracy(prediction, y)
print("Test set accuracy: {:.3%}".format(test_accuracy.result()))
Test set accuracy: 95.000%
Например, мы можем видеть, что для последней партии данных модель обычно правильно предсказывает:
tf.stack([y,prediction],axis=1)
<tf.Tensor: id=107996, shape=(24, 2), dtype=int32, numpy=
array([[0, 0],
[2, 2],
[1, 2],
[0, 0],
[0, 0],
[1, 1],
[0, 0],
[1, 1],
[0, 0],
[0, 0],
[0, 0],
[0, 0],
[1, 1],
[0, 0],
[2, 2],
[1, 1],
[0, 0],
[2, 2],
[0, 0],
[1, 2],
[1, 1],
[0, 0],
[0, 0],
[1, 1]])>Используйте обученную модель, чтобы делать прогнозы
Мы обучили модель и «доказали», что она работает, но этого недостаточно, когда дело доходит до классификации видов ирисов. Теперь мы используем обученную модель, чтобы сделать некоторые прогнозы для немаркированных образцов (то есть образцов, которые содержат функции, но не имеют меток).
В реальной жизни немаркированные образцы могут поступать из разных источников, включая приложения, CSV-файлы и потоки данных. В настоящее время мы вручную предоставим три немаркированных образца, чтобы предсказать их метки. Напомним, что номера меток сопоставляются с определенной нотацией:
- 0: горный ирис
- 1: меняющая цвет радужка
- 2: Вирджиния Ирис
predict_dataset = tf.convert_to_tensor([
[5.1, 3.3, 1.7, 0.5,],
[5.9, 3.0, 4.2, 1.5,],
[6.9, 3.1, 5.4, 2.1]
])
predictions = model(predict_dataset)
for i, logits in enumerate(predictions):
class_idx = tf.argmax(logits).numpy()
p = tf.nn.softmax(logits)[class_idx]
name = class_names[class_idx]
print("Example {} prediction: {} ({:4.1f}%)".format(i, name, 100*p))
Example 0 prediction: Iris setosa (96.4%)
Example 1 prediction: Iris versicolor (80.8%)
Example 2 prediction: Iris virginica (77.0%)