Это новый канал для записи моих заметок по курсу нейронной сети и учебных материалов, серийный номер начинается с -2.

Учебное пособие по TensorFlow2 — обзор Keras

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

3 преимущества Кераса:
Удобный для пользователя, модульный и компонуемый, легко расширяемый

1 импорт tf.keras

TensorFlow2 рекомендует использовать tf.keras для построения сетей, распространенные нейронные сети включены в tf.keras.layer (последняя версия tf.keras может отличаться от keras)

import tensorflow as tf
from tensorflow.keras import layers
from tensorflow.keras.callbacks import EarlyStopping, TensorBoard
import numpy as np
from datetime import datetime

gpu_ok = tf.test.is_gpu_available()

print(tf.__version__)
print(tf.keras.__version__)
print(gpu_ok)

2.1.0
2.2.4-tf
True

2 Создайте простую модель

2.1 Стекирование моделей

Наиболее распространенный тип модели — это набор слоев: tf.keras.Sequential model.
После построения сети вы можете просмотреть сетевую модель с помощью функции сводки.
Есть три предварительных условия для использования функции сводки.

1. Вам нужно указать размер входного слоя

2 или вызовите build()

3 или вызвать fit()

Среди них 2 и 3 нужно иметь тренировочный набор
Короче говоря, чтобы узнать размер входного слоя

model = tf.keras.Sequential()
model.add(layers.Dense(32, activation='relu', input_dim=72))
model.add(layers.Dense(32, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))
model.summary()

Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense (Dense)                (None, 32)                2336      
_________________________________________________________________
dense_1 (Dense)              (None, 32)                1056      
_________________________________________________________________
dense_2 (Dense)              (None, 10)                330       
=================================================================
Total params: 3,722
Trainable params: 3,722
Non-trainable params: 0
_________________________________________________________________

2.2 Конфигурация сети

Основные параметры конфигурации сети в tf.keras.layers следующие:
активация: установите функцию активации слоя. Этот параметр может быть строкой имени функции или объектом функции. По умолчанию система не применяет никаких функций активации.
kernel_initializer иbias_initializer: схемы инициализации для создания весов слоев (ядро и смещение). Этот параметр является именем или вызываемым функциональным объектом, который по умолчанию использует инициализатор "Glorotuniform".
kernel_regularizer иbias_regularizer: схема регуляризации для применения весов слоев (ядро и смещение), например регуляризация L1 или L2. По умолчанию система не применяет функции регуляризации.
Цель регуляризации - решить проблему переобучения
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kIAETHSF-1634526387981)(attachment:image.png)]

формула - пропустить

Классификация слева будет иметь большую ошибку, в то время как классификация справа является переподгонкой и имеет плохую способность к обобщению. Хотя на средней картинке есть ошибки, это действительно лучшее решение
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0iHTb6ab-1634526387986)(attachment:image-2.png)]

Теперь давайте взглянем на эту огромную нейронную сеть с глубокой подгонкой. Я знаю, что этот график недостаточно велик и недостаточно глубок, но, как вы понимаете, это нейронная сеть с переобучением. Мы добавляем регулярное слагаемое, что позволяет избежать слишком большого размера матрицы весов данных, но почему это уменьшает переоснащение?

Интуитивное понимание состоит в том, что если регуляризация установлена достаточно большой, матрица весов устанавливается на значение, близкое к 0, то есть вес нескольких скрытых единиц устанавливается равным 0, что в основном устраняет многие эффекты эти скрытые единицы. Если это так, сильно упрощенная нейронная сеть станет очень маленькой сетью, такой же маленькой, как единица логистической регрессии, но очень глубокой, что приблизит сеть к состоянию переобучения. .

Но будет промежуточное значение, поэтому будет промежуточное состояние, близкое к «В самый раз».

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lsCeC1pD-1634526387987)(attachment:image-3.png)]

Если используется часть регуляризации, вес W будет иметь тенденцию к уменьшению, поэтому результирующее значение z=w*A+b будет меньше, и когда оно действует на функцию активации, оно будет близко к части около нулевой точки. горизонтальной оси на приведенном выше рисунке, как показано ниже:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v3inDcAg-1634526387990)(attachment:image-4.png)]

Если значение z попадает в этот диапазон, все относительно небольшие значения g(z) = tanh(z) будут примерно линейными, и каждый слой будет почти линейным, как функция линейной регрессии. Если каждый слой является линейным, то вся сеть является линейной сетью, даже очень глубокая глубокая сеть, из-за характеристик линейной функции активации, в конце концов, мы можем вычислить только линейные функции, поэтому она не подходит для очень сложного решения. и нелинейные границы решений, которые превосходят набор данных.

layers.Dense(32, activation='sigmoid')
layers.Dense(32, activation=tf.sigmoid)
layers.Dense(32, kernel_initializer='orthogonal')
layers.Dense(32, kernel_initializer=tf.keras.initializers.glorot_normal)
layers.Dense(32, kernel_regularizer=tf.keras.regularizers.l2(0.01))
layers.Dense(32, kernel_regularizer=tf.keras.regularizers.l1(0.01))

<tensorflow.python.keras.layers.core.Dense at 0x7ff5c0082390>

3 Обучение и оценка

3.1 Настроить процесс обучения

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

model = tf.keras.Sequential()
model.add(layers.Dense(32, activation='relu'))
model.add(layers.Dense(32, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))
model.compile(optimizer=tf.keras.optimizers.Adam(0.001),
             loss=tf.keras.losses.categorical_crossentropy,
             metrics=[tf.keras.metrics.categorical_accuracy])

После построения сетевой модели необходимо настроить процесс обучения сети, иначе он будет называтьсяfitилиevaluateвызовет исключение. Конфигурацию можно выполнить с помощью компиляции (self, optimizer, loss, metrics=None, sample_weight_mode=None, weighted_metrics=None, target_tensors=None)
compile() в основном получает первые три параметра:

loss: строковый тип, используемый для указания функции потерь, например: categorical_crossentropy, binary_crossentropy
оптимизатор: строковый тип, используемый для указания метода оптимизации, например: rmsprop, adam, sgd
метрики: тип списка, используемый для указания метрик для измерения модели, таких как: точность
model.compile (потеря = 'categorical_crossentropy', оптимизатор = 'sgd', метрики = ['точность'])
Вы также можете добавить другие функции обратного вызова, которые будут обсуждаться позже.

3.2 Ввод данных Numpy

Для небольших наборов данных входные данные можно построить с помощью Numpy.

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

import numpy as np

train_x = np.random.random((1000, 72))
train_y = np.random.random((1000, 10))

val_x = np.random.random((200, 72))
val_y = np.random.random((200, 10))

model.fit(train_x, train_y, epochs=100, batch_size=100,
          validation_data=(val_x, val_y))

Train on 1000 samples, validate on 200 samples
Epoch 1/100
1000/1000 [==============================] - 1s 639us/sample - loss: 12.1864 - categorical_accuracy: 0.1070 - val_loss: 12.2439 - val_categorical_accuracy: 0.0600
Epoch 2/100
1000/1000 [==============================] - 0s 27us/sample - loss: 13.0292 - categorical_accuracy: 0.0950 - val_loss: 13.7217 - val_categorical_accuracy: 0.0650
Epoch 3/100
1000/1000 [==============================] - 0s 25us/sample - loss: 15.0484 - categorical_accuracy: 0.0930 - val_loss: 16.4090 - val_categorical_accuracy: 0.0650
Epoch 4/100
1000/1000 [==============================] - 0s 26us/sample - loss: 18.0353 - categorical_accuracy: 0.0930 - val_loss: 19.7006 - val_categorical_accuracy: 0.0650
Epoch 5/100
1000/1000 [==============================] - 0s 25us/sample - loss: 21.6455 - categorical_accuracy: 0.0930 - val_loss: 24.1038 - val_categorical_accuracy: 0.0650
Epoch 6/100
1000/1000 [==============================] - 0s 25us/sample - loss: 27.2545 - categorical_accuracy: 0.0930 - val_loss: 31.3219 - val_categorical_accuracy: 0.0850
Epoch 7/100
1000/1000 [==============================] - 0s 25us/sample - loss: 35.5471 - categorical_accuracy: 0.0980 - val_loss: 41.1936 - val_categorical_accuracy: 0.0850
Epoch 8/100
1000/1000 [==============================] - 0s 26us/sample - loss: 46.7873 - categorical_accuracy: 0.0940 - val_loss: 54.2268 - val_categorical_accuracy: 0.0850
Epoch 9/100
1000/1000 [==============================] - 0s 54us/sample - loss: 61.4755 - categorical_accuracy: 0.0950 - val_loss: 70.8410 - val_categorical_accuracy: 0.0700
Epoch 10/100
1000/1000 [==============================] - 0s 25us/sample - loss: 79.4868 - categorical_accuracy: 0.0950 - val_loss: 90.7648 - val_categorical_accuracy: 0.0700
Epoch 11/100
1000/1000 [==============================] - 0s 25us/sample - loss: 101.1739 - categorical_accuracy: 0.0900 - val_loss: 114.7025 - val_categorical_accuracy: 0.0700
Epoch 12/100
1000/1000 [==============================] - 0s 25us/sample - loss: 126.8959 - categorical_accuracy: 0.0930 - val_loss: 142.6307 - val_categorical_accuracy: 0.0700
Epoch 13/100
1000/1000 [==============================] - 0s 26us/sample - loss: 156.6893 - categorical_accuracy: 0.0960 - val_loss: 174.7227 - val_categorical_accuracy: 0.0750
Epoch 14/100
1000/1000 [==============================] - 0s 25us/sample - loss: 190.8326 - categorical_accuracy: 0.0960 - val_loss: 211.4004 - val_categorical_accuracy: 0.0650
Epoch 15/100
1000/1000 [==============================] - 0s 26us/sample - loss: 229.5933 - categorical_accuracy: 0.0920 - val_loss: 252.9706 - val_categorical_accuracy: 0.0750
Epoch 16/100
1000/1000 [==============================] - 0s 55us/sample - loss: 273.4981 - categorical_accuracy: 0.0960 - val_loss: 299.2311 - val_categorical_accuracy: 0.0700
Epoch 17/100
1000/1000 [==============================] - 0s 25us/sample - loss: 321.7867 - categorical_accuracy: 0.0980 - val_loss: 349.4678 - val_categorical_accuracy: 0.0700
Epoch 18/100
1000/1000 [==============================] - 0s 25us/sample - loss: 373.7236 - categorical_accuracy: 0.0890 - val_loss: 403.5012 - val_categorical_accuracy: 0.0700
Epoch 19/100
1000/1000 [==============================] - 0s 25us/sample - loss: 430.0553 - categorical_accuracy: 0.0970 - val_loss: 461.5726 - val_categorical_accuracy: 0.0550
Epoch 20/100
1000/1000 [==============================] - 0s 25us/sample - loss: 490.2736 - categorical_accuracy: 0.0970 - val_loss: 523.4989 - val_categorical_accuracy: 0.0650
Epoch 21/100
1000/1000 [==============================] - 0s 24us/sample - loss: 553.6836 - categorical_accuracy: 0.0980 - val_loss: 589.3144 - val_categorical_accuracy: 0.0950
Epoch 22/100
1000/1000 [==============================] - 0s 28us/sample - loss: 620.6393 - categorical_accuracy: 0.0980 - val_loss: 657.2309 - val_categorical_accuracy: 0.0650
Epoch 23/100
1000/1000 [==============================] - 0s 52us/sample - loss: 689.7130 - categorical_accuracy: 0.0990 - val_loss: 727.0188 - val_categorical_accuracy: 0.0700
Epoch 24/100
1000/1000 [==============================] - 0s 26us/sample - loss: 762.0412 - categorical_accuracy: 0.0970 - val_loss: 801.4167 - val_categorical_accuracy: 0.0900
Epoch 25/100
1000/1000 [==============================] - 0s 25us/sample - loss: 834.9594 - categorical_accuracy: 0.0960 - val_loss: 872.5280 - val_categorical_accuracy: 0.0900
Epoch 26/100
1000/1000 [==============================] - 0s 25us/sample - loss: 906.5170 - categorical_accuracy: 0.1030 - val_loss: 943.2008 - val_categorical_accuracy: 0.0600
Epoch 27/100
1000/1000 [==============================] - 0s 25us/sample - loss: 975.0647 - categorical_accuracy: 0.0920 - val_loss: 1009.4395 - val_categorical_accuracy: 0.0650
Epoch 28/100
1000/1000 [==============================] - 0s 25us/sample - loss: 1040.0404 - categorical_accuracy: 0.1020 - val_loss: 1073.9507 - val_categorical_accuracy: 0.0800
Epoch 29/100
1000/1000 [==============================] - 0s 25us/sample - loss: 1104.9380 - categorical_accuracy: 0.1120 - val_loss: 1137.9870 - val_categorical_accuracy: 0.0950
Epoch 30/100
1000/1000 [==============================] - 0s 25us/sample - loss: 1168.8721 - categorical_accuracy: 0.1170 - val_loss: 1202.9854 - val_categorical_accuracy: 0.0950
Epoch 31/100
1000/1000 [==============================] - 0s 55us/sample - loss: 1234.6194 - categorical_accuracy: 0.0960 - val_loss: 1267.8508 - val_categorical_accuracy: 0.0850
Epoch 32/100
1000/1000 [==============================] - 0s 25us/sample - loss: 1301.6757 - categorical_accuracy: 0.0990 - val_loss: 1336.4615 - val_categorical_accuracy: 0.0700
Epoch 33/100
1000/1000 [==============================] - 0s 25us/sample - loss: 1367.7428 - categorical_accuracy: 0.1060 - val_loss: 1402.0927 - val_categorical_accuracy: 0.1000
Epoch 34/100
1000/1000 [==============================] - 0s 25us/sample - loss: 1432.2028 - categorical_accuracy: 0.1030 - val_loss: 1463.5681 - val_categorical_accuracy: 0.0650
Epoch 35/100
1000/1000 [==============================] - 0s 25us/sample - loss: 1497.1898 - categorical_accuracy: 0.1040 - val_loss: 1529.4269 - val_categorical_accuracy: 0.0950
Epoch 36/100
1000/1000 [==============================] - 0s 25us/sample - loss: 1559.5742 - categorical_accuracy: 0.1010 - val_loss: 1588.0530 - val_categorical_accuracy: 0.0550
Epoch 37/100
1000/1000 [==============================] - 0s 25us/sample - loss: 1611.4853 - categorical_accuracy: 0.1010 - val_loss: 1636.0344 - val_categorical_accuracy: 0.0650
Epoch 38/100
1000/1000 [==============================] - 0s 52us/sample - loss: 1642.6731 - categorical_accuracy: 0.1010 - val_loss: 1627.1154 - val_categorical_accuracy: 0.0700
Epoch 39/100
1000/1000 [==============================] - 0s 26us/sample - loss: 1606.4901 - categorical_accuracy: 0.1060 - val_loss: 1573.7168 - val_categorical_accuracy: 0.0750
Epoch 40/100
1000/1000 [==============================] - 0s 25us/sample - loss: 1552.0087 - categorical_accuracy: 0.0960 - val_loss: 1517.2331 - val_categorical_accuracy: 0.1050
Epoch 41/100
1000/1000 [==============================] - 0s 25us/sample - loss: 1484.4402 - categorical_accuracy: 0.0990 - val_loss: 1465.9717 - val_categorical_accuracy: 0.0950
Epoch 42/100
1000/1000 [==============================] - 0s 25us/sample - loss: 1476.1709 - categorical_accuracy: 0.0970 - val_loss: 1470.3436 - val_categorical_accuracy: 0.0900
Epoch 43/100
1000/1000 [==============================] - 0s 24us/sample - loss: 1472.6699 - categorical_accuracy: 0.1140 - val_loss: 1471.9978 - val_categorical_accuracy: 0.0700
Epoch 44/100
1000/1000 [==============================] - 0s 25us/sample - loss: 1466.9905 - categorical_accuracy: 0.1040 - val_loss: 1460.1993 - val_categorical_accuracy: 0.1000
Epoch 45/100
1000/1000 [==============================] - 0s 25us/sample - loss: 1459.5785 - categorical_accuracy: 0.0910 - val_loss: 1452.8042 - val_categorical_accuracy: 0.1000
Epoch 46/100
1000/1000 [==============================] - 0s 56us/sample - loss: 1447.0048 - categorical_accuracy: 0.0960 - val_loss: 1432.1102 - val_categorical_accuracy: 0.0600
Epoch 47/100
1000/1000 [==============================] - 0s 27us/sample - loss: 1418.5652 - categorical_accuracy: 0.1060 - val_loss: 1398.0585 - val_categorical_accuracy: 0.0650
Epoch 48/100
1000/1000 [==============================] - 0s 25us/sample - loss: 1380.7618 - categorical_accuracy: 0.1160 - val_loss: 1358.1672 - val_categorical_accuracy: 0.0700
Epoch 49/100
1000/1000 [==============================] - 0s 26us/sample - loss: 1338.6998 - categorical_accuracy: 0.1000 - val_loss: 1310.9040 - val_categorical_accuracy: 0.0750
Epoch 50/100
1000/1000 [==============================] - 0s 26us/sample - loss: 1300.4685 - categorical_accuracy: 0.0950 - val_loss: 1294.6734 - val_categorical_accuracy: 0.1050
Epoch 51/100
1000/1000 [==============================] - 0s 26us/sample - loss: 1289.1089 - categorical_accuracy: 0.1030 - val_loss: 1287.9561 - val_categorical_accuracy: 0.0600
Epoch 52/100
1000/1000 [==============================] - 0s 26us/sample - loss: 1275.6635 - categorical_accuracy: 0.1000 - val_loss: 1265.8784 - val_categorical_accuracy: 0.0600
Epoch 53/100
1000/1000 [==============================] - 0s 32us/sample - loss: 1244.8945 - categorical_accuracy: 0.0970 - val_loss: 1233.3094 - val_categorical_accuracy: 0.1050
Epoch 54/100
1000/1000 [==============================] - 0s 47us/sample - loss: 1229.7360 - categorical_accuracy: 0.1080 - val_loss: 1213.3581 - val_categorical_accuracy: 0.0600
Epoch 55/100
1000/1000 [==============================] - 0s 26us/sample - loss: 1204.4045 - categorical_accuracy: 0.1000 - val_loss: 1182.9891 - val_categorical_accuracy: 0.1050
Epoch 56/100
1000/1000 [==============================] - 0s 26us/sample - loss: 1178.2038 - categorical_accuracy: 0.0880 - val_loss: 1160.3662 - val_categorical_accuracy: 0.0900
Epoch 57/100
1000/1000 [==============================] - 0s 26us/sample - loss: 1149.1897 - categorical_accuracy: 0.0980 - val_loss: 1129.1326 - val_categorical_accuracy: 0.1050
Epoch 58/100
1000/1000 [==============================] - 0s 25us/sample - loss: 1114.6702 - categorical_accuracy: 0.1070 - val_loss: 1094.9047 - val_categorical_accuracy: 0.0600
Epoch 59/100
1000/1000 [==============================] - 0s 26us/sample - loss: 1074.4851 - categorical_accuracy: 0.1100 - val_loss: 1040.2871 - val_categorical_accuracy: 0.0600
Epoch 60/100
1000/1000 [==============================] - 0s 26us/sample - loss: 1034.7077 - categorical_accuracy: 0.0970 - val_loss: 985.9434 - val_categorical_accuracy: 0.1000
Epoch 61/100
1000/1000 [==============================] - 0s 53us/sample - loss: 976.7049 - categorical_accuracy: 0.1100 - val_loss: 933.5067 - val_categorical_accuracy: 0.1100
Epoch 62/100
1000/1000 [==============================] - 0s 25us/sample - loss: 911.3713 - categorical_accuracy: 0.1010 - val_loss: 853.1591 - val_categorical_accuracy: 0.0650
Epoch 63/100
1000/1000 [==============================] - 0s 25us/sample - loss: 842.8447 - categorical_accuracy: 0.1000 - val_loss: 789.3255 - val_categorical_accuracy: 0.1100
Epoch 64/100
1000/1000 [==============================] - 0s 25us/sample - loss: 775.2145 - categorical_accuracy: 0.0970 - val_loss: 722.6735 - val_categorical_accuracy: 0.0650
Epoch 65/100
1000/1000 [==============================] - 0s 25us/sample - loss: 726.7562 - categorical_accuracy: 0.1070 - val_loss: 698.1979 - val_categorical_accuracy: 0.0600
Epoch 66/100
1000/1000 [==============================] - 0s 25us/sample - loss: 717.8865 - categorical_accuracy: 0.1080 - val_loss: 690.8430 - val_categorical_accuracy: 0.1150
Epoch 67/100
1000/1000 [==============================] - 0s 25us/sample - loss: 703.6470 - categorical_accuracy: 0.1020 - val_loss: 668.8605 - val_categorical_accuracy: 0.1100
Epoch 68/100
1000/1000 [==============================] - 0s 26us/sample - loss: 677.8014 - categorical_accuracy: 0.1130 - val_loss: 658.3235 - val_categorical_accuracy: 0.0600
Epoch 69/100
1000/1000 [==============================] - 0s 55us/sample - loss: 675.8244 - categorical_accuracy: 0.0970 - val_loss: 629.1815 - val_categorical_accuracy: 0.1100
Epoch 70/100
1000/1000 [==============================] - 0s 25us/sample - loss: 653.8402 - categorical_accuracy: 0.0920 - val_loss: 628.9182 - val_categorical_accuracy: 0.1300
Epoch 71/100
1000/1000 [==============================] - 0s 26us/sample - loss: 649.8070 - categorical_accuracy: 0.0970 - val_loss: 600.7431 - val_categorical_accuracy: 0.0600
Epoch 72/100
1000/1000 [==============================] - 0s 25us/sample - loss: 603.2672 - categorical_accuracy: 0.1160 - val_loss: 574.3532 - val_categorical_accuracy: 0.1050
Epoch 73/100
1000/1000 [==============================] - 0s 25us/sample - loss: 584.7944 - categorical_accuracy: 0.1070 - val_loss: 568.0578 - val_categorical_accuracy: 0.1000
Epoch 74/100
1000/1000 [==============================] - 0s 25us/sample - loss: 568.6435 - categorical_accuracy: 0.1030 - val_loss: 527.7212 - val_categorical_accuracy: 0.0650
Epoch 75/100
1000/1000 [==============================] - 0s 25us/sample - loss: 526.5512 - categorical_accuracy: 0.1050 - val_loss: 479.1668 - val_categorical_accuracy: 0.1000
Epoch 76/100
1000/1000 [==============================] - 0s 26us/sample - loss: 509.3205 - categorical_accuracy: 0.1000 - val_loss: 493.5508 - val_categorical_accuracy: 0.1050
Epoch 77/100
1000/1000 [==============================] - 0s 52us/sample - loss: 456.1215 - categorical_accuracy: 0.1070 - val_loss: 401.0019 - val_categorical_accuracy: 0.1000
Epoch 78/100
1000/1000 [==============================] - 0s 25us/sample - loss: 403.5868 - categorical_accuracy: 0.0980 - val_loss: 350.1806 - val_categorical_accuracy: 0.1050
Epoch 79/100
1000/1000 [==============================] - 0s 26us/sample - loss: 345.5986 - categorical_accuracy: 0.0990 - val_loss: 311.8484 - val_categorical_accuracy: 0.1100
Epoch 80/100
1000/1000 [==============================] - 0s 26us/sample - loss: 285.0324 - categorical_accuracy: 0.0960 - val_loss: 258.4336 - val_categorical_accuracy: 0.1050
Epoch 81/100
1000/1000 [==============================] - 0s 26us/sample - loss: 250.0112 - categorical_accuracy: 0.1070 - val_loss: 187.9330 - val_categorical_accuracy: 0.0900
Epoch 82/100
1000/1000 [==============================] - 0s 26us/sample - loss: 192.5750 - categorical_accuracy: 0.1160 - val_loss: 140.8783 - val_categorical_accuracy: 0.1100
Epoch 83/100
1000/1000 [==============================] - 0s 25us/sample - loss: 146.9630 - categorical_accuracy: 0.1090 - val_loss: 121.0113 - val_categorical_accuracy: 0.0750
Epoch 84/100
1000/1000 [==============================] - 0s 56us/sample - loss: 115.7717 - categorical_accuracy: 0.0860 - val_loss: 75.5320 - val_categorical_accuracy: 0.1000
Epoch 85/100
1000/1000 [==============================] - 0s 26us/sample - loss: 105.5616 - categorical_accuracy: 0.0950 - val_loss: 122.1138 - val_categorical_accuracy: 0.1050
Epoch 86/100
1000/1000 [==============================] - 0s 25us/sample - loss: 100.0362 - categorical_accuracy: 0.1080 - val_loss: 108.7261 - val_categorical_accuracy: 0.1350
Epoch 87/100
1000/1000 [==============================] - 0s 25us/sample - loss: 127.4710 - categorical_accuracy: 0.1090 - val_loss: 132.0981 - val_categorical_accuracy: 0.0650
Epoch 88/100
1000/1000 [==============================] - 0s 25us/sample - loss: 141.0293 - categorical_accuracy: 0.1020 - val_loss: 133.2474 - val_categorical_accuracy: 0.1350
Epoch 89/100
1000/1000 [==============================] - 0s 26us/sample - loss: 120.4979 - categorical_accuracy: 0.1150 - val_loss: 117.8078 - val_categorical_accuracy: 0.1000
Epoch 90/100
1000/1000 [==============================] - 0s 25us/sample - loss: 119.5986 - categorical_accuracy: 0.1060 - val_loss: 92.7652 - val_categorical_accuracy: 0.1350
Epoch 91/100
1000/1000 [==============================] - 0s 56us/sample - loss: 104.3861 - categorical_accuracy: 0.0930 - val_loss: 75.7607 - val_categorical_accuracy: 0.0600
Epoch 92/100
1000/1000 [==============================] - 0s 26us/sample - loss: 125.5138 - categorical_accuracy: 0.0900 - val_loss: 141.1569 - val_categorical_accuracy: 0.0950
Epoch 93/100
1000/1000 [==============================] - 0s 26us/sample - loss: 176.3270 - categorical_accuracy: 0.0840 - val_loss: 187.2577 - val_categorical_accuracy: 0.1300
Epoch 94/100
1000/1000 [==============================] - 0s 26us/sample - loss: 147.3037 - categorical_accuracy: 0.1100 - val_loss: 125.9804 - val_categorical_accuracy: 0.1100
Epoch 95/100
1000/1000 [==============================] - 0s 26us/sample - loss: 165.9997 - categorical_accuracy: 0.1060 - val_loss: 107.8639 - val_categorical_accuracy: 0.1350
Epoch 96/100
1000/1000 [==============================] - 0s 26us/sample - loss: 163.7285 - categorical_accuracy: 0.0990 - val_loss: 159.1753 - val_categorical_accuracy: 0.0650
Epoch 97/100
1000/1000 [==============================] - 0s 27us/sample - loss: 145.3247 - categorical_accuracy: 0.1110 - val_loss: 121.4570 - val_categorical_accuracy: 0.1350
Epoch 98/100
1000/1000 [==============================] - 0s 53us/sample - loss: 139.6124 - categorical_accuracy: 0.0960 - val_loss: 141.9158 - val_categorical_accuracy: 0.0650
Epoch 99/100
1000/1000 [==============================] - 0s 27us/sample - loss: 122.9475 - categorical_accuracy: 0.1140 - val_loss: 91.3999 - val_categorical_accuracy: 0.0650
Epoch 100/100
1000/1000 [==============================] - 0s 26us/sample - loss: 135.1131 - categorical_accuracy: 0.0840 - val_loss: 114.3255 - val_categorical_accuracy: 0.1050





<tensorflow.python.keras.callbacks.History at 0x7ff5c4705630>

3.3 входные данные tf.data

Для больших наборов данных входные данные для обучения могут быть построены с использованием tf.data.

Вообще говоря, объем данных в нашей обучающей сети очень велик, и объем данных также велик, поэтому мы используем tf.data для управления и повышения эффективности чтения и записи.

dataset = tf.data.Dataset.from_tensor_slices((train_x, train_y))
dataset = dataset.batch(32)
dataset = dataset.repeat() #防止循环次数*batch大于数据总量的情况下报错
val_dataset = tf.data.Dataset.from_tensor_slices((val_x, val_y))
val_dataset = val_dataset.batch(32)
val_dataset = val_dataset.repeat()

model.fit(dataset, epochs=10, steps_per_epoch=30,
          validation_data=val_dataset, validation_steps=3)

Train for 30 steps, validate for 3 steps
Epoch 1/10
30/30 [==============================] - 0s 10ms/step - loss: 162.7071 - categorical_accuracy: 0.0948 - val_loss: 132.7141 - val_categorical_accuracy: 0.0625
Epoch 2/10
30/30 [==============================] - 0s 3ms/step - loss: 151.5471 - categorical_accuracy: 0.1026 - val_loss: 156.8644 - val_categorical_accuracy: 0.0833
Epoch 3/10
30/30 [==============================] - 0s 2ms/step - loss: 149.6497 - categorical_accuracy: 0.1004 - val_loss: 157.7960 - val_categorical_accuracy: 0.0521
Epoch 4/10
30/30 [==============================] - 0s 2ms/step - loss: 185.5166 - categorical_accuracy: 0.0994 - val_loss: 147.6869 - val_categorical_accuracy: 0.1146
Epoch 5/10
30/30 [==============================] - 0s 3ms/step - loss: 233.9934 - categorical_accuracy: 0.0994 - val_loss: 261.1310 - val_categorical_accuracy: 0.0938
Epoch 6/10
30/30 [==============================] - 0s 2ms/step - loss: 248.8591 - categorical_accuracy: 0.0919 - val_loss: 153.8509 - val_categorical_accuracy: 0.1146
Epoch 7/10
30/30 [==============================] - 0s 3ms/step - loss: 260.5320 - categorical_accuracy: 0.1004 - val_loss: 254.9412 - val_categorical_accuracy: 0.0938
Epoch 8/10
30/30 [==============================] - 0s 2ms/step - loss: 192.3668 - categorical_accuracy: 0.0972 - val_loss: 203.8111 - val_categorical_accuracy: 0.1146
Epoch 9/10
30/30 [==============================] - 0s 2ms/step - loss: 227.1097 - categorical_accuracy: 0.0951 - val_loss: 241.0869 - val_categorical_accuracy: 0.1354
Epoch 10/10
30/30 [==============================] - 0s 3ms/step - loss: 267.9791 - categorical_accuracy: 0.0791 - val_loss: 209.5756 - val_categorical_accuracy: 0.1146





<tensorflow.python.keras.callbacks.History at 0x7ff5a060a7f0>

На основе API tf.data мы можем создавать сложные конвейеры ввода с помощью простого кода.
Например, чтение данных из распределенной файловой системы, предварительная обработка, объединение в пакеты и использование наборов данных в обучении;
В качестве альтернативы конвейер ввода текстовой модели должен извлекать символы из необработанных текстовых данных, преобразовывать их во встроенные идентификаторы в соответствии с таблицей поиска, объединять последовательности разной длины в пакетные данные и т. д.
Большие объемы данных, различные форматы данных и сложные преобразования можно легко обрабатывать с помощью API tf.data.
API tf.data вводит две новые концепции в TensorFlow:
(1) tf.data.Dataset: представляет серию элементов, каждый из которых содержит один или несколько объектов Tensor. Например, в конвейере изображений элемент может быть одним обучающим примером с парой тензоров, представляющих данные изображения и метки. Наборы данных могут быть созданы двумя различными способами.

 直接从 Tensor 创建 Dataset（例如 Dataset.from_tensor_slices()）；当然 Numpy 也是可以的，TensorFlow 会自动将其转换为 Tensor。

通过对一个或多个 tf.data.Dataset 对象来使用变换（例如 Dataset.batch()）来创建 Dataset

(2) tf.data.Iterator: это основной метод извлечения элементов из набора данных. Инструкция Iterator.get_next() создает следующий элемент набора данных при выполнении, и эта инструкция обычно действует как интерфейс между входным конвейером и моделью. Самый простой итератор — это «одиночный итератор», который выполняет одну итерацию над обрабатываемым набором данных. Для более сложных применений вы можете использоватьIterator.initializerДирективы повторно инициализируют и параметризируют итераторы с разными наборами данных, так что вы можете повторять данные обучения и проверки несколько раз в одной и той же программе (например).

Объект набора данных содержит несколько элементов, каждый из которых имеет одинаковую структуру. Каждый элемент содержит один или несколько объектов tf.Tensor, которые называются компонентами. Каждый компонент имеет свойство tf.DType, которое представляет тип элементов в тензоре, и свойство tf.TensorShape, которое представляет (возможно, частично указанную) статическую форму каждого элемента. Вы можете проверить типы и формы отдельных компонентов элемента набора данных с помощью свойств Dataset.output_types и Dataset.output_shapes. Свойства набора данных сопоставляются со свойствами элементов, составляющих набор данных, и элементы могут быть одиночным тензором, кортежем тензоров или вложенным кортежем тензоров. Например:

dataset1 = tf.data.Dataset.from_tensor_slices(tf.random.uniform([4, 10]))
print(dataset1)  # ==> "tf.float32"
 
dataset2 = tf.data.Dataset.from_tensor_slices(
   (tf.random.uniform([4]),
    tf.random.uniform([4, 100], maxval=100, dtype=tf.int32)))
print(dataset2)  # ==> "(tf.float32, tf.int32)"
 
dataset3 = tf.data.Dataset.zip((dataset1, dataset2))
print(dataset3)  # ==> (tf.float32, (tf.float32, tf.int32))

<TensorSliceDataset shapes: (10,), types: tf.float32>
<TensorSliceDataset shapes: ((), (100,)), types: (tf.float32, tf.int32)>
<ZipDataset shapes: ((10,), ((), (100,))), types: (tf.float32, (tf.float32, tf.int32))>

print(list(dataset3.take(1)))

[(<tf.Tensor: shape=(10,), dtype=float32, numpy=
array([0.19765472, 0.7021023 , 0.22192502, 0.39844525, 0.02671063,
       0.7148951 , 0.98842084, 0.61563957, 0.4822532 , 0.5023855 ],
      dtype=float32)>, (<tf.Tensor: shape=(), dtype=float32, numpy=0.19682515>, <tf.Tensor: shape=(100,), dtype=int32, numpy=
array([83, 54, 11, 67, 36, 11,  7, 21, 98, 79, 54, 38, 28, 95, 24, 50, 39,
       21, 80, 84, 80, 62, 89, 15, 27,  6, 87, 22, 87, 36, 83, 95, 21, 69,
       93, 70, 99, 24, 41, 30, 50, 63, 90,  2, 87, 49, 30, 12, 18, 46, 63,
       88, 65,  0, 46, 11, 22, 69, 52, 12, 75, 82, 66, 30, 53, 88, 87, 51,
       24,  0, 48, 51, 22, 25, 15, 96, 60, 22, 17,  5, 21, 21, 67, 30, 24,
       24, 22, 65, 27,  7, 19,  9, 74, 78, 33, 97, 58, 25,  9, 82],
      dtype=int32)>))]

3.4 Оценка и прогноз

Функции оценки и прогнозирования: методы tf.keras.Model.evaluate и tf.keras.Model.predict, оба из которых могут оцениваться и прогнозироваться с использованием входных данных, созданных из NumPy и tf.data.Dataset.
Цель оценки и прогнозирования различна.
Мы видим, что уровень точности ужасен, потому что данные, которые мы используем для обучения, не являются обучаемыми данными.

# 模型评估
test_x = np.random.random((1000, 72))
test_y = np.random.random((1000, 10))
model.evaluate(test_x, test_y, batch_size=32)
test_data = tf.data.Dataset.from_tensor_slices((test_x, test_y))
test_data = test_data.batch(32).repeat()
model.evaluate(test_data, steps=30)

1000/1000 [==============================] - 0s 153us/sample - loss: 210.7485 - categorical_accuracy: 0.0990
30/30 [==============================] - 0s 2ms/step - loss: 210.3705 - categorical_accuracy: 0.0969





[210.37054392496745, 0.096875]

# 模型预测
result = model.predict(test_x, batch_size=32)
print(result)

[[2.3885893e-13 3.6062306e-14 3.4597181e-04 ... 1.7771703e-05
  3.9381185e-13 9.9959689e-01]
 [5.8199810e-13 1.8029461e-13 3.8594753e-04 ... 1.5929958e-05
  1.5820349e-12 9.9956590e-01]
 [4.2835317e-14 1.3064033e-14 1.4652881e-04 ... 4.7101612e-06
  2.4650025e-13 9.9983656e-01]
 ...
 [5.8543299e-14 2.9437414e-14 2.3781681e-04 ... 7.5260905e-06
  2.9730737e-13 9.9974018e-01]
 [1.6417090e-13 9.9574679e-14 3.1998276e-04 ... 2.0455815e-05
  1.0056686e-12 9.9963164e-01]
 [1.0115633e-13 3.9613386e-14 2.0342070e-04 ... 1.2408743e-05
  8.3384054e-13 9.9976581e-01]]

4 Построение сложных моделей

4.1 Функциональный API

tf.keras.Sequential модели представляют собой простые наборы слоев и не могут представлять произвольные модели. Используя функциональный API Keras, можно создавать сложные топологии моделей, такие как:

модели с несколькими входами,
модели с несколькими выходами,
модели с общими слоями (один и тот же слой вызывается несколько раз),
Модели с непоследовательными потоками данных (например, остаточные соединения).

Модели, построенные с использованием функционального API, имеют следующие характеристики:

Экземпляры слоя являются вызываемыми и возвращают тензоры.
Входные тензоры и выходные тензоры используются для определения экземпляров tf.keras.Model.
Эта модель обучается так же, как и последовательная модель.

input_x = tf.keras.Input(shape=(72,))
hidden1 = layers.Dense(32, activation='relu')(input_x)
hidden2 = layers.Dense(16, activation='relu')(hidden1)
pred = layers.Dense(10, activation='softmax')(hidden2)
# 构建tf.keras.Model实例
model = tf.keras.Model(inputs=input_x, outputs=pred)
model.compile(optimizer=tf.keras.optimizers.Adam(0.001),
             loss=tf.keras.losses.categorical_crossentropy,
             metrics=['accuracy'])
model.fit(train_x, train_y, batch_size=32, epochs=5)

Train on 1000 samples
Epoch 1/5
1000/1000 [==============================] - 0s 351us/sample - loss: 12.2272 - accuracy: 0.0990
Epoch 2/5
1000/1000 [==============================] - 0s 65us/sample - loss: 18.5298 - accuracy: 0.0850
Epoch 3/5
1000/1000 [==============================] - 0s 91us/sample - loss: 33.0864 - accuracy: 0.0940
Epoch 4/5
1000/1000 [==============================] - 0s 66us/sample - loss: 56.0615 - accuracy: 0.0940
Epoch 5/5
1000/1000 [==============================] - 0s 65us/sample - loss: 88.7252 - accuracy: 0.0880





<tensorflow.python.keras.callbacks.History at 0x7ff5a052a320>

4.2 Подклассы моделей

Полностью настраиваемые модели могут быть созданы путем создания подкласса tf.keras.Model и определения собственного прямого прохода.

существует_init_для создания слоев и установки их в качестве свойств экземпляра класса.
Определите прямое распространение в методе __call__

class MyModel(tf.keras.Model):
    def __init__(self, num_classes=10):
        super(MyModel, self).__init__(name='my_model')
        self.num_classes = num_classes
        # 定义网络层
        self.layer1 = layers.Dense(32, activation='relu')
        self.layer2 = layers.Dense(num_classes, activation='softmax')
    def call(self, inputs):
        # 定义前向传播
        h1 = self.layer1(inputs)
        out = self.layer2(h1)
        return out
    
    def compute_output_shape(self, input_shape):
        # 计算输出shape
        shape = tf.TensorShape(input_shape).as_list()
        shape[-1] = self.num_classes
        return tf.TensorShape(shape)
# 实例化模型类，并训练
model = MyModel(num_classes=10)
model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001),
             loss=tf.keras.losses.categorical_crossentropy,
             metrics=['accuracy'])

model.fit(train_x, train_y, batch_size=16, epochs=5)

Train on 1000 samples
Epoch 1/5
1000/1000 [==============================] - 0s 453us/sample - loss: 13.3207 - accuracy: 0.1050
Epoch 2/5
1000/1000 [==============================] - 0s 163us/sample - loss: 15.3926 - accuracy: 0.1040
Epoch 3/5
1000/1000 [==============================] - 0s 135us/sample - loss: 17.8175 - accuracy: 0.1050
Epoch 4/5
1000/1000 [==============================] - 0s 163us/sample - loss: 20.3278 - accuracy: 0.1060
Epoch 5/5
1000/1000 [==============================] - 0s 167us/sample - loss: 23.4035 - accuracy: 0.1070





<tensorflow.python.keras.callbacks.History at 0x7ff5a02fb080>

4.3 Пользовательские слои

Создайте пользовательские слои, создав подкласс tf.keras.layers.Layer и реализовав следующие методы:

_init_: (необязательно) определяет подслой, который будет использоваться для этого слоя.
build: веса создаваемого слоя. Используйте метод add_weight для добавления весов.
вызов: определяет прямое распространение.
calculate_output_shape: указывает, как вычислять выходную форму слоя с учетом входной формы.
При желании уровень можно сериализовать, реализуя метод get_config и метод класса from_config.

class MyLayer(layers.Layer):
    def __init__(self, output_dim, **kwargs):
        self.output_dim = output_dim
        super(MyLayer, self).__init__(**kwargs)
    
    def build(self, input_shape):
        shape = tf.TensorShape((input_shape[1], self.output_dim))
        self.kernel = self.add_weight(name='kernel1', shape=shape,
                                   initializer='uniform', trainable=True)
        super(MyLayer, self).build(input_shape)
    
    def call(self, inputs):
        return tf.matmul(inputs, self.kernel)

    def compute_output_shape(self, input_shape):
        shape = tf.TensorShape(input_shape).as_list()
        shape[-1] = self.output_dim
        return tf.TensorShape(shape)

    def get_config(self):
        base_config = super(MyLayer, self).get_config()
        base_config['output_dim'] = self.output_dim
        return base_config

    @classmethod
    def from_config(cls, config):
        return cls(**config)

# 使用自定义网络层构建模型
model = tf.keras.Sequential(
[
    MyLayer(10),
    layers.Activation('softmax')
])


model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001),
             loss=tf.keras.losses.categorical_crossentropy,
             metrics=['accuracy'])

model.fit(train_x, train_y, batch_size=16, epochs=5)
model.summary()

Train on 1000 samples
Epoch 1/5
1000/1000 [==============================] - 0s 377us/sample - loss: 11.6191 - accuracy: 0.1030
Epoch 2/5
1000/1000 [==============================] - 0s 144us/sample - loss: 11.6184 - accuracy: 0.1060
Epoch 3/5
1000/1000 [==============================] - 0s 115us/sample - loss: 11.6159 - accuracy: 0.1040
Epoch 4/5
1000/1000 [==============================] - 0s 141us/sample - loss: 11.6138 - accuracy: 0.1000
Epoch 5/5
1000/1000 [==============================] - 0s 113us/sample - loss: 11.6103 - accuracy: 0.1010
Model: "sequential_2"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
my_layer (MyLayer)           multiple                  720       
_________________________________________________________________
activation (Activation)      multiple                  0         
=================================================================
Total params: 720
Trainable params: 720
Non-trainable params: 0
_________________________________________________________________

4.3 Обратный вызов

Обратные вызовы — это объекты, которые передаются модели для настройки и расширения ее поведения во время обучения. Мы можем написать свои собственные обратные вызовы или использовать встроенные функции в tf.keras.callbacks.Обычно используемые встроенные функции обратного вызова следующие:

tf.keras.callbacks.ModelCheckpoint: периодически сохраняет контрольные точки модели.
tf.keras.callbacks.LearningRateScheduler: Динамическое изменение скорости обучения.
tf.keras.callbacks.EarlyStopping: Остановить обучение, когда производительность проверки перестанет улучшаться.
tf.keras.callbacks.TensorBoard: отслеживайте поведение модели с помощью TensorBoard.

%load_ext tensorboard

logdir="./tb/" + datetime.now().strftime("%Y%m%d-%H%M%S")

callbacks = [
    tf.keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'),
    tf.keras.callbacks.TensorBoard(log_dir=logdir)
]
model.fit(train_x, train_y, batch_size=16, epochs=5,
         callbacks=callbacks, validation_data=(val_x, val_y))
%tensorboard --logdir tb/ --host=0.0.0.0

Train on 1000 samples, validate on 200 samples
Epoch 1/5
1000/1000 [==============================] - 0s 348us/sample - loss: 11.6089 - accuracy: 0.1040 - val_loss: 11.3648 - val_accuracy: 0.0950
Epoch 2/5
1000/1000 [==============================] - 0s 198us/sample - loss: 11.6075 - accuracy: 0.1010 - val_loss: 11.3608 - val_accuracy: 0.1000
Epoch 3/5
1000/1000 [==============================] - 0s 202us/sample - loss: 11.6062 - accuracy: 0.1060 - val_loss: 11.3627 - val_accuracy: 0.0950
Epoch 4/5
1000/1000 [==============================] - 0s 203us/sample - loss: 11.6062 - accuracy: 0.1020 - val_loss: 11.3591 - val_accuracy: 0.1100
Epoch 5/5
1000/1000 [==============================] - 0s 201us/sample - loss: 11.6032 - accuracy: 0.1030 - val_loss: 11.3598 - val_accuracy: 0.1000

5 Сохранение и восстановление модели

5.1 Снижение веса

model = tf.keras.Sequential([
layers.Dense(64, activation='relu', input_shape=(32,)),  # 需要有input_shape
layers.Dense(10, activation='softmax')])

model.compile(optimizer=tf.keras.optimizers.Adam(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# 权重保存与重载
model.save_weights('./weights/model')
model.load_weights('./weights/model')
# 保存为h5格式
model.save_weights('./model.h5', save_format='h5')
model.load_weights('./model.h5')

5.2 Сохраните структуру сети

# 序列化成json
import json
import pprint
json_str = model.to_json()
pprint.pprint(json.loads(json_str))
# 从json中重建模型
fresh_model = tf.keras.models.model_from_json(json_str)

# 保持为yaml格式  #需要提前安装pyyaml

yaml_str = model.to_yaml()
print(yaml_str)
# 从yaml数据中重新构建模型
fresh_model = tf.keras.models.model_from_yaml(yaml_str)

Примечание. Модель подкласса не сериализуема, поскольку ее архитектура определяется кодом Python в теле метода вызова.

5.3 Сохраните всю модель

model = tf.keras.Sequential([
  layers.Dense(10, activation='softmax', input_shape=(72,)),
  layers.Dense(10, activation='softmax')
])
model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['accuracy'])
model.fit(train_x, train_y, batch_size=32, epochs=5)
# 保存整个模型
model.save('all_model.h5')
# 导入整个模型
model = tf.keras.models.load_model('all_model.h5')

6 Использование keras для Estimator

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

model = tf.keras.Sequential([layers.Dense(10,activation='softmax'),
                          layers.Dense(10,activation='softmax')])

model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

estimator = tf.keras.estimator.model_to_estimator(model)

7 Eager execution

Стремительное выполнение — это среда программирования динамического выполнения, которая немедленно оценивает операции. Keras не требует этой функции, но она поддерживается программой tf.keras и полезна для проверки и отладки программы.

Все API-интерфейсы построения моделей tf.keras совместимы с выполнением Eager. Хотя доступны как последовательные, так и функциональные API, выполнение Eager облегчает создание подклассов модели и создание пользовательских слоев: для этого требуется, чтобы API прямого прохода был написан в коде (а не API, который создает модель путем сборки существующих слоев).

8 работает на нескольких графических процессорах

Модели tf.keras можно запускать на нескольких графических процессорах с помощью tf.distribute.Strategy. API обеспечивает распределенное обучение на нескольких графических процессорах практически без изменений существующего кода.

В настоящее время tf.distribute.MirroredStrategy является единственной поддерживаемой стратегией распространения. MirroredStrategy использует полное сокращение для синхронного обучения на одной машине для репликации в графе. Чтобы использовать распределите.Strategys, вложите создание оптимизатора, построение и компиляцию модели в Strategy.scope(), а затем обучите модель.

Следующий пример выделения нескольких GPU для tf.keras.Model на одной машине.

Сначала определите модель в рамках распределенной стратегии:

strategy = tf.distribute.MirroredStrategy()
with strategy.scope():
    model = tf.keras.Sequential()
    model.add(layers.Dense(16, activation='relu', input_shape=(10,)))
    model.add(layers.Dense(1, activation='sigmoid'))
    optimizer = tf.keras.optimizers.SGD(0.2)
    model.compile(loss='binary_crossentropy', optimizer=optimizer)
model.summary()

Затем обучите модель на данных, например, на одном графическом процессоре.

x = np.random.random((1024, 10))
y = np.random.randint(2, size=(1024, 1))
x = tf.cast(x, tf.float32)
dataset = tf.data.Dataset.from_tensor_slices((x, y))
dataset = dataset.shuffle(buffer_size=1024).batch(32)
model.fit(dataset, epochs=1)

# define some hyper parameters
batch_size = 100 
n_inputs = 784
n_classes = 10 
n_epochs = 100 

# get the data
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

# reshape the two dimensional 28 x 28 pixels
# sized images into a single vector of 784 pixels
x_train = x_train.reshape(60000, n_inputs)
x_test = x_test.reshape(10000, n_inputs)

# convert the input values to float32
x_train = x_train.astype(np.float32)
x_test = x_test.astype(np.float32)

# normalize the values of image vectors to fit under 1
x_train /= 255
x_test /= 255

# convert output data into one hot encoded format
y_train = tf.keras.utils.to_categorical(y_train, n_classes)
y_test = tf.keras.utils.to_categorical(y_test, n_classes)

# build a sequential model
model = tf.keras.Sequential()
# the first layer has to specify the dimensions of the input vector
model.add(layers.Dense(units=128, activation='sigmoid', input_shape=(n_inputs,)))
# add dropout layer for preventing overfitting
model.add(layers.Dropout(0.1))
model.add(layers.Dense(units=128, activation='sigmoid'))
model.add(layers.Dropout(0.1))
# output layer can only have the neurons equal to the number of outputs
model.add(layers.Dense(units=n_classes, activation='softmax'))

# print the summary of our model
model.summary()

# compile the model
model.compile(loss='categorical_crossentropy',
              optimizer=tf.keras.optimizers.SGD(),
              metrics=['accuracy'])

# train the model
model.fit(x_train, y_train,
          batch_size=batch_size,
          epochs=n_epochs)

# evaluate the model and print the accuracy score
scores = model.evaluate(x_test, y_test)

print('\n loss:', scores[0])
print('\n accuracy:', scores[1])