 Посмотреть на TensorFlow.org |  Запускаем в Google Colab |  Посмотреть исходный код на GitHub |  Скачать блокнот |
Настраивать
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np
Вступление
Keras предоставляет стандартные циклы обучения и оценки, fit() и evaluate() . Их использование описано в руководстве « Обучение и оценка с помощью встроенных методов» .
Если вы хотите настроить алгоритм обучения своей модели, по-прежнему используя удобство fit() (например, для обучения GAN с помощью fit() ), вы можете train_step() подкласс класса Model и реализовать свой собственный train_step() , который вызывается повторно во время fit() . Это описано в руководстве Настройка того, что происходит в fit() .
Теперь, если вам нужен очень низкоуровневый контроль над обучением и оценкой, вы должны написать свои собственные циклы обучения и оценки с нуля. Это то, о чем это руководство.
Использование GradientTape : первый сквозной пример
Вызов модели внутри области GradientTape позволяет получить градиенты обучаемых весов слоя по отношению к значению потерь. Используя экземпляр оптимизатора, вы можете использовать эти градиенты для обновления этих переменных (которые вы можете получить с помощью model.trainable_weights ).
Рассмотрим простую модель MNIST:
inputs = keras.Input(shape=(784,), name="digits")
x1 = layers.Dense(64, activation="relu")(inputs)
x2 = layers.Dense(64, activation="relu")(x1)
outputs = layers.Dense(10, name="predictions")(x2)
model = keras.Model(inputs=inputs, outputs=outputs)
Давайте обучим его, используя мини-пакетный градиент с настраиваемым циклом обучения.
Во-первых, нам понадобится оптимизатор, функция потерь и набор данных:
# Instantiate an optimizer.
optimizer = keras.optimizers.SGD(learning_rate=1e-3)
# Instantiate a loss function.
loss_fn = keras.losses.SparseCategoricalCrossentropy(from_logits=True)
# Prepare the training dataset.
batch_size = 64
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = np.reshape(x_train, (-1, 784))
x_test = np.reshape(x_test, (-1, 784))
# Reserve 10,000 samples for validation.
x_val = x_train[-10000:]
y_val = y_train[-10000:]
x_train = x_train[:-10000]
y_train = y_train[:-10000]
# Prepare the training dataset.
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(batch_size)
# Prepare the validation dataset.
val_dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val))
val_dataset = val_dataset.batch(batch_size)
Вот наш цикл обучения:
- Мы открываем цикл
forкоторый повторяется по эпохам - Для каждой эпохи мы открываем цикл
forкоторый выполняет итерацию по набору данных партиями. - Для каждой партии мы открываем область
GradientTape() - Внутри этой области мы вызываем модель (прямой проход) и вычисляем потери.
- За пределами области видимости мы получаем градиенты весов модели с учетом потерь
- Наконец, мы используем оптимизатор для обновления весов модели на основе градиентов.
epochs = 2
for epoch in range(epochs):
print("\nStart of epoch %d" % (epoch,))
# Iterate over the batches of the dataset.
for step, (x_batch_train, y_batch_train) in enumerate(train_dataset):
# Open a GradientTape to record the operations run
# during the forward pass, which enables auto-differentiation.
with tf.GradientTape() as tape:
# Run the forward pass of the layer.
# The operations that the layer applies
# to its inputs are going to be recorded
# on the GradientTape.
logits = model(x_batch_train, training=True) # Logits for this minibatch
# Compute the loss value for this minibatch.
loss_value = loss_fn(y_batch_train, logits)
# Use the gradient tape to automatically retrieve
# the gradients of the trainable variables with respect to the loss.
grads = tape.gradient(loss_value, model.trainable_weights)
# Run one step of gradient descent by updating
# the value of the variables to minimize the loss.
optimizer.apply_gradients(zip(grads, model.trainable_weights))
# Log every 200 batches.
if step % 200 == 0:
print(
"Training loss (for one batch) at step %d: %.4f"
% (step, float(loss_value))
)
print("Seen so far: %s samples" % ((step + 1) * 64))
Start of epoch 0 Training loss (for one batch) at step 0: 121.1988 Seen so far: 64 samples Training loss (for one batch) at step 200: 1.8102 Seen so far: 12864 samples Training loss (for one batch) at step 400: 0.2878 Seen so far: 25664 samples Training loss (for one batch) at step 600: 0.6135 Seen so far: 38464 samples Start of epoch 1 Training loss (for one batch) at step 0: 0.4283 Seen so far: 64 samples Training loss (for one batch) at step 200: 0.9015 Seen so far: 12864 samples Training loss (for one batch) at step 400: 0.2759 Seen so far: 25664 samples Training loss (for one batch) at step 600: 0.3553 Seen so far: 38464 samples
Низкоуровневая обработка метрик
Давайте добавим в этот базовый цикл мониторинг метрик.
Вы можете легко повторно использовать встроенные метрики (или пользовательские метрики, которые вы написали) в таких циклах обучения, написанных с нуля. Вот поток:
- Создайте метрику в начале цикла
- Вызов
metric.update_state()после каждого пакета - Вызов
metric.result()когда вам нужно отобразить текущее значение метрики - Вызов
metric.reset_states()когда вам нужно очистить состояние метрики (обычно в конце эпохи)
Давайте воспользуемся этими знаниями, чтобы вычислить SparseCategoricalAccuracy по данным проверки в конце каждой эпохи:
# Get model
inputs = keras.Input(shape=(784,), name="digits")
x = layers.Dense(64, activation="relu", name="dense_1")(inputs)
x = layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = layers.Dense(10, name="predictions")(x)
model = keras.Model(inputs=inputs, outputs=outputs)
# Instantiate an optimizer to train the model.
optimizer = keras.optimizers.SGD(learning_rate=1e-3)
# Instantiate a loss function.
loss_fn = keras.losses.SparseCategoricalCrossentropy(from_logits=True)
# Prepare the metrics.
train_acc_metric = keras.metrics.SparseCategoricalAccuracy()
val_acc_metric = keras.metrics.SparseCategoricalAccuracy()
Вот наш цикл обучения и оценки:
import time
epochs = 2
for epoch in range(epochs):
print("\nStart of epoch %d" % (epoch,))
start_time = time.time()
# Iterate over the batches of the dataset.
for step, (x_batch_train, y_batch_train) in enumerate(train_dataset):
with tf.GradientTape() as tape:
logits = model(x_batch_train, training=True)
loss_value = loss_fn(y_batch_train, logits)
grads = tape.gradient(loss_value, model.trainable_weights)
optimizer.apply_gradients(zip(grads, model.trainable_weights))
# Update training metric.
train_acc_metric.update_state(y_batch_train, logits)
# Log every 200 batches.
if step % 200 == 0:
print(
"Training loss (for one batch) at step %d: %.4f"
% (step, float(loss_value))
)
print("Seen so far: %d samples" % ((step + 1) * 64))
# Display metrics at the end of each epoch.
train_acc = train_acc_metric.result()
print("Training acc over epoch: %.4f" % (float(train_acc),))
# Reset training metrics at the end of each epoch
train_acc_metric.reset_states()
# Run a validation loop at the end of each epoch.
for x_batch_val, y_batch_val in val_dataset:
val_logits = model(x_batch_val, training=False)
# Update val metrics
val_acc_metric.update_state(y_batch_val, val_logits)
val_acc = val_acc_metric.result()
val_acc_metric.reset_states()
print("Validation acc: %.4f" % (float(val_acc),))
print("Time taken: %.2fs" % (time.time() - start_time))
Start of epoch 0 Training loss (for one batch) at step 0: 135.0892 Seen so far: 64 samples Training loss (for one batch) at step 200: 1.5598 Seen so far: 12864 samples Training loss (for one batch) at step 400: 1.2157 Seen so far: 25664 samples Training loss (for one batch) at step 600: 0.7209 Seen so far: 38464 samples Training acc over epoch: 0.6987 Validation acc: 0.7861 Time taken: 6.25s Start of epoch 1 Training loss (for one batch) at step 0: 0.8004 Seen so far: 64 samples Training loss (for one batch) at step 200: 0.8705 Seen so far: 12864 samples Training loss (for one batch) at step 400: 0.5630 Seen so far: 25664 samples Training loss (for one batch) at step 600: 0.2715 Seen so far: 38464 samples Training acc over epoch: 0.8193 Validation acc: 0.8534 Time taken: 6.21s
Ускорение тренировок с помощью функции tf.function
Среда выполнения по умолчанию в TensorFlow 2.0 - это активное выполнение . Таким образом, наш тренировочный цикл выше выполняется с готовностью.
Это отлично подходит для отладки, но компиляция графов имеет определенное преимущество в производительности. Описание ваших вычислений в виде статического графика позволяет фреймворку применять глобальную оптимизацию производительности. Это невозможно, когда фреймворк вынужден жадно выполнять одну операцию за другой, не зная, что будет дальше.
Вы можете скомпилировать в статический график любую функцию, которая принимает на вход тензоры. Просто добавьте на @tf.function декоратор @tf.function , например:
@tf.function
def train_step(x, y):
with tf.GradientTape() as tape:
logits = model(x, training=True)
loss_value = loss_fn(y, logits)
grads = tape.gradient(loss_value, model.trainable_weights)
optimizer.apply_gradients(zip(grads, model.trainable_weights))
train_acc_metric.update_state(y, logits)
return loss_value
Сделаем то же самое с этапом оценки:
@tf.function
def test_step(x, y):
val_logits = model(x, training=False)
val_acc_metric.update_state(y, val_logits)
Теперь давайте повторно запустим наш цикл обучения с этим скомпилированным этапом обучения:
import time
epochs = 2
for epoch in range(epochs):
print("\nStart of epoch %d" % (epoch,))
start_time = time.time()
# Iterate over the batches of the dataset.
for step, (x_batch_train, y_batch_train) in enumerate(train_dataset):
loss_value = train_step(x_batch_train, y_batch_train)
# Log every 200 batches.
if step % 200 == 0:
print(
"Training loss (for one batch) at step %d: %.4f"
% (step, float(loss_value))
)
print("Seen so far: %d samples" % ((step + 1) * 64))
# Display metrics at the end of each epoch.
train_acc = train_acc_metric.result()
print("Training acc over epoch: %.4f" % (float(train_acc),))
# Reset training metrics at the end of each epoch
train_acc_metric.reset_states()
# Run a validation loop at the end of each epoch.
for x_batch_val, y_batch_val in val_dataset:
test_step(x_batch_val, y_batch_val)
val_acc = val_acc_metric.result()
val_acc_metric.reset_states()
print("Validation acc: %.4f" % (float(val_acc),))
print("Time taken: %.2fs" % (time.time() - start_time))
Start of epoch 0 Training loss (for one batch) at step 0: 0.5371 Seen so far: 64 samples Training loss (for one batch) at step 200: 0.4763 Seen so far: 12864 samples Training loss (for one batch) at step 400: 0.3543 Seen so far: 25664 samples Training loss (for one batch) at step 600: 0.5230 Seen so far: 38464 samples Training acc over epoch: 0.8582 Validation acc: 0.8548 Time taken: 1.54s Start of epoch 1 Training loss (for one batch) at step 0: 0.4145 Seen so far: 64 samples Training loss (for one batch) at step 200: 0.4044 Seen so far: 12864 samples Training loss (for one batch) at step 400: 0.5638 Seen so far: 25664 samples Training loss (for one batch) at step 600: 0.5348 Seen so far: 38464 samples Training acc over epoch: 0.8766 Validation acc: 0.8740 Time taken: 1.19s
Намного быстрее, не правда ли?
Низкоуровневая обработка убытков, отслеживаемых моделью
Слои и модели рекурсивно отслеживают любые потери, создаваемые во время прямого прохода слоями, которые вызывают self.add_loss(value) . Результирующий список значений скалярных потерь доступен через свойство model.losses в конце прямого прохода.
Если вы хотите использовать эти компоненты потерь, вам следует суммировать их и добавить к основным потерям на этапе обучения.
Рассмотрим этот слой, который создает потерю регуляризации деятельности:
class ActivityRegularizationLayer(layers.Layer):
def call(self, inputs):
self.add_loss(1e-2 * tf.reduce_sum(inputs))
return inputs
Давайте построим действительно простую модель, которая ее использует:
inputs = keras.Input(shape=(784,), name="digits")
x = layers.Dense(64, activation="relu")(inputs)
# Insert activity regularization as a layer
x = ActivityRegularizationLayer()(x)
x = layers.Dense(64, activation="relu")(x)
outputs = layers.Dense(10, name="predictions")(x)
model = keras.Model(inputs=inputs, outputs=outputs)
Вот как теперь должен выглядеть наш тренировочный шаг:
@tf.function
def train_step(x, y):
with tf.GradientTape() as tape:
logits = model(x, training=True)
loss_value = loss_fn(y, logits)
# Add any extra losses created during the forward pass.
loss_value += sum(model.losses)
grads = tape.gradient(loss_value, model.trainable_weights)
optimizer.apply_gradients(zip(grads, model.trainable_weights))
train_acc_metric.update_state(y, logits)
return loss_value
Резюме
Теперь вы знаете все, что нужно знать об использовании встроенных обучающих циклов и написании собственных с нуля.
В заключение, вот простой сквозной пример, который связывает воедино все, что вы узнали в этом руководстве: DCGAN, обученный цифрам MNIST.
Сквозной пример: цикл обучения GAN с нуля
Возможно, вы знакомы с генеративными состязательными сетями (GAN). GAN могут генерировать новые изображения, которые выглядят почти реальными, изучая скрытое распределение обучающего набора данных изображений («скрытое пространство» изображений).
GAN состоит из двух частей: модели «генератора», которая сопоставляет точки в скрытом пространстве с точками в пространстве изображений, модель «дискриминатор», классификатор, который может отличить реальные изображения (из набора обучающих данных) от поддельных. изображения (выход генератора сети).
Цикл обучения GAN выглядит так:
1) Обучите дискриминатор. - Образец партии случайных точек в скрытом пространстве. - Превратите точки в поддельные изображения с помощью модели «генератор». - Получите пакет реальных изображений и объедините их с созданными изображениями. - Обучите модель "дискриминатора" классифицировать сгенерированные и реальные изображения.
2) Обучить генератор. - Выборка случайных точек в скрытом пространстве. - Превратите точки в фейковые изображения через сеть «генератор». - Получите пакет реальных изображений и объедините их с созданными изображениями. - Обучите «генераторную» модель «обмануть» дискриминатор и классифицировать поддельные изображения как настоящие.
Более подробный обзор работы GAN см. В разделе Deep Learning with Python .
Давайте реализуем этот цикл обучения. Сначала создайте дискриминатор, предназначенный для классификации поддельных и настоящих цифр:
discriminator = keras.Sequential(
[
keras.Input(shape=(28, 28, 1)),
layers.Conv2D(64, (3, 3), strides=(2, 2), padding="same"),
layers.LeakyReLU(alpha=0.2),
layers.Conv2D(128, (3, 3), strides=(2, 2), padding="same"),
layers.LeakyReLU(alpha=0.2),
layers.GlobalMaxPooling2D(),
layers.Dense(1),
],
name="discriminator",
)
discriminator.summary()
Model: "discriminator" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d (Conv2D) (None, 14, 14, 64) 640 _________________________________________________________________ leaky_re_lu (LeakyReLU) (None, 14, 14, 64) 0 _________________________________________________________________ conv2d_1 (Conv2D) (None, 7, 7, 128) 73856 _________________________________________________________________ leaky_re_lu_1 (LeakyReLU) (None, 7, 7, 128) 0 _________________________________________________________________ global_max_pooling2d (Global (None, 128) 0 _________________________________________________________________ dense_4 (Dense) (None, 1) 129 ================================================================= Total params: 74,625 Trainable params: 74,625 Non-trainable params: 0 _________________________________________________________________
Затем давайте создадим сеть генераторов, которая преобразует скрытые векторы в выходные данные формы (28, 28, 1) (представляющие цифры MNIST):
latent_dim = 128
generator = keras.Sequential(
[
keras.Input(shape=(latent_dim,)),
# We want to generate 128 coefficients to reshape into a 7x7x128 map
layers.Dense(7 * 7 * 128),
layers.LeakyReLU(alpha=0.2),
layers.Reshape((7, 7, 128)),
layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding="same"),
layers.LeakyReLU(alpha=0.2),
layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding="same"),
layers.LeakyReLU(alpha=0.2),
layers.Conv2D(1, (7, 7), padding="same", activation="sigmoid"),
],
name="generator",
)
Вот ключевой момент: цикл обучения. Как видите, это довольно просто. Функция шага обучения занимает всего 17 строк.
# Instantiate one optimizer for the discriminator and another for the generator.
d_optimizer = keras.optimizers.Adam(learning_rate=0.0003)
g_optimizer = keras.optimizers.Adam(learning_rate=0.0004)
# Instantiate a loss function.
loss_fn = keras.losses.BinaryCrossentropy(from_logits=True)
@tf.function
def train_step(real_images):
# Sample random points in the latent space
random_latent_vectors = tf.random.normal(shape=(batch_size, latent_dim))
# Decode them to fake images
generated_images = generator(random_latent_vectors)
# Combine them with real images
combined_images = tf.concat([generated_images, real_images], axis=0)
# Assemble labels discriminating real from fake images
labels = tf.concat(
[tf.ones((batch_size, 1)), tf.zeros((real_images.shape[0], 1))], axis=0
)
# Add random noise to the labels - important trick!
labels += 0.05 * tf.random.uniform(labels.shape)
# Train the discriminator
with tf.GradientTape() as tape:
predictions = discriminator(combined_images)
d_loss = loss_fn(labels, predictions)
grads = tape.gradient(d_loss, discriminator.trainable_weights)
d_optimizer.apply_gradients(zip(grads, discriminator.trainable_weights))
# Sample random points in the latent space
random_latent_vectors = tf.random.normal(shape=(batch_size, latent_dim))
# Assemble labels that say "all real images"
misleading_labels = tf.zeros((batch_size, 1))
# Train the generator (note that we should *not* update the weights
# of the discriminator)!
with tf.GradientTape() as tape:
predictions = discriminator(generator(random_latent_vectors))
g_loss = loss_fn(misleading_labels, predictions)
grads = tape.gradient(g_loss, generator.trainable_weights)
g_optimizer.apply_gradients(zip(grads, generator.trainable_weights))
return d_loss, g_loss, generated_images
Давайте train_step наш GAN, многократно вызывая train_step для пакетов изображений.
Поскольку наш дискриминатор и генератор являются свертками, вы захотите запустить этот код на графическом процессоре.
import os
# Prepare the dataset. We use both the training & test MNIST digits.
batch_size = 64
(x_train, _), (x_test, _) = keras.datasets.mnist.load_data()
all_digits = np.concatenate([x_train, x_test])
all_digits = all_digits.astype("float32") / 255.0
all_digits = np.reshape(all_digits, (-1, 28, 28, 1))
dataset = tf.data.Dataset.from_tensor_slices(all_digits)
dataset = dataset.shuffle(buffer_size=1024).batch(batch_size)
epochs = 1 # In practice you need at least 20 epochs to generate nice digits.
save_dir = "./"
for epoch in range(epochs):
print("\nStart epoch", epoch)
for step, real_images in enumerate(dataset):
# Train the discriminator & generator on one batch of real images.
d_loss, g_loss, generated_images = train_step(real_images)
# Logging.
if step % 200 == 0:
# Print metrics
print("discriminator loss at step %d: %.2f" % (step, d_loss))
print("adversarial loss at step %d: %.2f" % (step, g_loss))
# Save one generated image
img = tf.keras.preprocessing.image.array_to_img(
generated_images[0] * 255.0, scale=False
)
img.save(os.path.join(save_dir, "generated_img" + str(step) + ".png"))
# To limit execution time we stop after 10 steps.
# Remove the lines below to actually train the model!
if step > 10:
break
Start epoch 0 discriminator loss at step 0: 0.70 adversarial loss at step 0: 0.73
Вот и все! Вы получите красивые фальшивые цифры MNIST всего через ~ 30 секунд тренировки на графическом процессоре Colab.