На этом шаге мы рассмотрим пример совместного использования fit() и нестандартного цикла обучения.

    Ранее мы с нуля написали полный цикл обучения. Этот подход дает максимальную гибкость, но не только требует написать много кода, но и лишает множества удобных возможностей fit(), таких как обратные вызовы или встроенная поддержка распределенного обучения.

    А получится ли применить свой алгоритм обучения и сохранить всю мощь встроенной логики обучения Keras? На самом деле существует золотая середина между использованием fit() и реализацией своего цикла обучения: можно написать свою функцию шага обучения, а все остальные задачи переложить на фреймворк.

    Для этого достаточно переопределить метод train_step() класса Model, который вызывается функцией fit() для обработки каждого пакета данных, и использовать fit() как обычно, а функция будет запускать ваш алгоритм обучения.

    Вот простой пример:

• создадим новый класс, наследующий класс keras.Model;
  
  
• переопределим метод train_step(self, data), почти полностью повторив все, что мы написали выше. Теперь метод будет возвращать словарь, отображающий имена метрик (включая метрику потерь) в их текущие значения;
  
  
• реализуем свойство metrics для отслеживания экземпляров класса Metric в модели. Это позволит модели автоматически вызывать reset_state() для метрик в начале каждой эпохи и в начале вызова функции evaluate(), чтобы не делать этого вручную.
  
  

# Данный объект метрики будет использоваться для слежения за 
# средним значением потерь на пакетах в ходе обучения и оценки
loss_fn = keras.losses.SparseCategoricalCrossentropy()
loss_tracker = keras.metrics.Mean(name="loss")

class CustomModel(keras.Model): 
  
  # Мы переопределяем метод train_step
  def train_step(self, data): 
    inputs, targets = data 
    with tf.GradientTape() as tape: 
      # Здесь вместо model(inputs, training=True) используется 
      # self(inputs, training=True), потому что моделью является 
      # сам экземпляр класса
      predictions = self(inputs, training=True) 
      loss = loss_fn(targets, predictions) 
      
    gradients = tape.gradient(loss, model.trainable_weights) 
    optimizer.apply_gradients(zip(gradients, model.trainable_weights)) 
    
    # Обновить метрику потерь, в которой хранится среднее значение потерь
    loss_tracker.update_state(loss) 
    # Вернуть среднее значение потерь, получившееся к данному моменту, 
    # обратившись к экземпляру метрики loss_tracker
    return {"loss": loss_tracker.result()}
    
@property
# Список всех метрик, которые должны сбрасываться в 
# исходное состояние в начале каждой эпохи
def metrics(self):
  return [loss_tracker]

    Теперь можно создать экземпляр модели, скомпилировать ее (в данном случае мы передаем только оптимизатор, потому что потери определены вне модели) и обучить, используя fit() как обычно:

inputs = keras.Input(shape=(28 * 28,))
features = layers.Dense(512, activation="relu")(inputs)
features = layers.Dropout(0.5)(features)
outputs = layers.Dense(10, activation="softmax")(features)
model = CustomModel(inputs, outputs)

model.compile(optimizer=keras.optimizers.RMSprop())
model.fit(train_images, train_labels, epochs=3)

    Отметим несколько важных моментов:

• данный подход можно использовать также при построении моделей с помощью функционального API - он не зависит от способа построения модели: с применением класса Sequential, функционального API или наследованием класса Model;
  
  
• при переопределении метода train_step() не нужно использовать декоратор @tf.function - фреймворк сделает это автоматически.
  
  

    А что насчет метрик и функции потерь, которые настраиваются с помощью compile()? После вызова compile() вы получаете доступ к:

• self.compiled_loss - функции потерь, переданной в вызов compile();
  
  
• self.compiled_metrics - обертке для списка метрик, которая позволяет вызвать self.compiled_metrics.update_state() и обновить сразу все метрики;
  
  
• self.metrics - фактическому списку метрик, переданному в вызов compile(). Обратите внимание, что он также включает метрику, предназначенную для отслеживания потерь, подобно тому как мы делали это вручную с помощью нашей метрики loss_tracking_metric.
  
  

    То есть мы можем написать такой класс:

class CustomModel(keras.Model): 
  
  def train_step(self, data): 
    inputs, targets = data 
    with tf.GradientTape() as tape: 
      predictions = self(inputs, training=True) 
      # Вычислить величину потерь вызовом self.compiled_loss
      loss = self.compiled_loss(targets, predictions) 
      
    gradients = tape.gradient(loss, model.trainable_weights) 
    optimizer.apply_gradients(zip(gradients, model.trainable_weights)) 
    # Обновить метрики модели с помощью обертки self.compiled_metrics
    self.compiled_metrics.update_state(targets, predictions) 
    # Вернуть словарь, отображающий имена метрик в их текущие значения
    return {m.name: m.result() for m in self.metrics}

    Давайте опробуем его:

inputs = keras.Input(shape=(28 * 28,))
features = layers.Dense(512, activation="relu")(inputs)
features = layers.Dropout(0.5)(features)
outputs = layers.Dense(10, activation="softmax")(features)
model = CustomModel(inputs, outputs)

model.compile(optimizer=keras.optimizers.RMSprop(),
              loss=keras.losses.SparseCategoricalCrossentropy(),
              metrics=[keras.metrics.SparseCategoricalAccuracy()])
model.fit(train_images, train_labels, epochs=3)

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

    На следующем шаге мы подведем итоги по изученному материалу.

Предыдущий шаг Содержание Следующий шаг