Ранняя остановка и график обучения на основе пользовательских метрик в Керасе

Question

У меня есть модель обнаружения объектов в Керасе, и я хочу отслеживать и контролировать свое обучение на основе средней средней точности (mAP), рассчитанной по набору валидации.

Я перенес код из tenorflow-models в мои сценарии, которые запускают оценку, используя модель и предоставленные данные.Это не реализовано как метрика Кераса, но как отдельный класс:

evaluation = SSDEvaluation(model, data, data_size)
mAP = evaluation.evaluate()

Я полностью согласен с таким.На самом деле, я не хочу, чтобы он рассчитывался для тренировочных пакетов, поскольку это замедлит обучение.

Мой вопрос: как повторно использовать ReduceLROnPlateau и EarlyStopping обратные вызовы на основе этого показателярассчитывается после каждой эпохи?

Answer 1

Вы можете сделать это с помощью LambdaCallback , который обновляет ваш logs объект:

Предполагая, что ваш evaluation.evaluate() возвращает словарь типа {'val/mAP': value}, вы можете сделать это следующим образом:

eval_callback = LambdaCallback(
     on_epoch_end=lambda epoch, logs: logs.update(evaluation.evaluate())
) 

Хитрость в том, что logs будет передан другим обратным вызовам, поэтому они могут напрямую получить доступ к значению:

early_stopping = EarlyStopping(monitor='val/mAP', min_delta=0.0, patience=10, verbose=1, mode='max') 

. Это автоматически появится вCSVLogger и любой другой обратный вызов.Но обратите внимание, что eval_callback должен предшествовать любому обратному вызову с использованием значения в списке обратных вызовов:

callbacks = [eval_callback, early_stopping]

Answer 2

Я не уверен, что такое SSDEvaluation, но если допустимо какое-либо среднее вычисление прецизионности без накладных расходов, я предлагаю следующий метод с использованием keras callbacks .

Основная идея, чтоВы хотите использовать два callbacl - EarlyStopping и ReduceLROnPlateau - оба действуют на конце эпохи и отслеживают значение loss или metric.Они получают это значение из аргумента logs метода

 def on_epoch_end(self, epoch, logs=None):
     """Called at the end of an epoch.
     ...
     """

- отправляя фактическое map в лог-значение, мы форсируем этот метод и все обратные вызовы, которые получаютЗначение точности из журналов, чтобы использовать его.Callbcaks выбирает отсюда значение ( this в коде - ранняя остановка и this единица для Reduce LR).
Итак, мы должны "фальсифицировать" журналы для обоихобратные вызовы.Я думаю, это не идеальное, но рабочее решение.

Эти классы наследуют от обратных вызовов и вычисления значения map , также они избегают пересчета map через общий объект Hub.

from sklearn.metrics import average_precision_score

import keras
from keras.callbacks import Callback, EarlyStopping, ReduceLROnPlateau


class MAPHub:
    def __init__(self):
        self.map_value = None

- это просто концентратор для обмена значением map .Может быть, это вызывает некоторые побочные эффекты.Вы можете попытаться избежать его использования.

def on_epoch_end(self, epoch, logs):
    """self just a callbcak instance"""
    if self.last_metric_for_epoch == epoch:
        map_ = self.hub.map_value
    else:
        prediction = self.model.predict(self._data, verbose=1)
        map_ = average_precision_score(self._target, prediction)
        self.hub.map_value = map_
        self.last_metric_for_epoch = epoch

- эта функция кальцилирует и разделяет карту

class EarlyStoppingByMAP(EarlyStopping):
    def __init__(self, data, target, hub, *args, **kwargs):
        """
        data, target - values and target for the map calculation
        hub - shared object to store _map_ value 
        *args, **kwargs for the super __init__
        """
        # I've set monitor to 'acc' here, because you're interested in metric, not loss
        super(EarlyStoppingByMAP, self).__init__(monitor='acc', *args, **kwargs)
        self._target = target
        self._data = data 
        self.last_metric_for_epoch = -1
        self.hub = hub

    def on_epoch_end(self, epoch, logs):
        """
        epoch is the number of epoch, logs is a dict logs with 'loss' value 
        and metric 'acc' values
        """
        on_epoch_end(self, epoch, logs)      
        logs['acc'] = self.hub.map_value  # "fake" metric with calculated value
        print('Go callback from the {}, logs: \n{}'.format(EarlyStoppingByMAP.__name__, logs))
        super(EarlyStoppingByMAP, self).on_epoch_end(epoch, logs)  # works as a callback fn


class ReduceLROnPlateauByMAP(ReduceLROnPlateau):
    def __init__(self, data, target, hub, *args, **kwargs):
        # the same as in previous
        # I've set monitor to 'acc' here, because you're interested in metric, not loss
        super(ReduceLROnPlateauByMAP, self).__init__(monitor='acc', *args, **kwargs)
        self._target = target
        self._data = data 
        self.last_metric_for_epoch = -1
        self.hub = hub


    def on_epoch_end(self, epoch, logs):
        on_epoch_end(self, epoch, logs)
        logs['acc'] = self.hub.map_value   # "fake" metric with calculated value
        print('Go callback from the {}, logs: \n{}'.format(ReduceLROnPlateau.__name__, logs))
        super(ReduceLROnPlateauByMAP, self).on_epoch_end(epoch, logs)  # works as a callback fn

- NB неиспользуйте аргумент monitor в конструкторе!Вы должны использовать 'acc', для параметра уже установлено правильное значение.

Некоторые тесты:

from keras.datasets import mnist
from keras.models import Model
from keras.layers import Dense, Input
import numpy as np

(X_tr, y_tr), (X_te, y_te) = mnist.load_data()
X_tr = (X_tr / 255.).reshape((60000, 784))
X_te = (X_te / 255.).reshape((10000, 784))


def binarize_labels(y):
    y_bin = np.zeros((len(y), len(np.unique(y)))) 
    y_bin[range(len(y)), y] = 1
    return y_bin

y_train_bin, y_test_bin = binarize_labels(y_tr), binarize_labels(y_te)


inp = Input(shape=(784,))
x = Dense(784, activation='relu')(inp)
x = Dense(256, activation='relu')(x)
out = Dense(10, activation='softmax')(x)

model = Model(inp, out)
model.compile(loss='categorical_crossentropy', optimizer='adam')

- простой "набор тестов".Теперь приступайте к этому:

hub = MAPHub()  # instentiate a hub
# I will use default params except patience as example, set it to 1 and 5
early_stop = EarlyStoppingByMAP(X_te, y_test_bin, hub, patience=1)  # Patience is EarlyStopping's param
reduce_lt = ReduceLROnPlateauByMAP(X_te, y_test_bin, hub, patience=5)  # Patience is ReduceLR's param

history = model.fit(X_tr, y_train_bin, epochs=10, callbacks=[early_stop, reduce_lt])
Out:
Epoch 1/10
60000/60000 [==============================] - 12s 207us/step - loss: 0.1815
10000/10000 [==============================] - 1s 59us/step
Go callback from the EarlyStoppingByMAP, logs: 
{'loss': 0.18147853660446903, 'acc': 0.9934216252519924}
10000/10000 [==============================] - 0s 40us/step
Go callback from the ReduceLROnPlateau, logs: 
{'loss': 0.18147853660446903, 'acc': 0.9934216252519924}
Epoch 2/10
60000/60000 [==============================] - 12s 197us/step - loss: 0.0784
10000/10000 [==============================] - 0s 40us/step
Go callback from the EarlyStoppingByMAP, logs: 
{'loss': 0.07844233275586739, 'acc': 0.9962269038764738}
10000/10000 [==============================] - 0s 41us/step
Go callback from the ReduceLROnPlateau, logs: 
{'loss': 0.07844233275586739, 'acc': 0.9962269038764738}
Epoch 3/10
60000/60000 [==============================] - 12s 197us/step - loss: 0.0556
10000/10000 [==============================] - 0s 40us/step
Go callback from the EarlyStoppingByMAP, logs: 
{'loss': 0.05562876497630107, 'acc': 0.9972085346550085}
10000/10000 [==============================] - 0s 40us/step
Go callback from the ReduceLROnPlateau, logs: 
{'loss': 0.05562876497630107, 'acc': 0.9972085346550085}
Epoch 4/10
60000/60000 [==============================] - 12s 198us/step - loss: 0.0389
10000/10000 [==============================] - 0s 41us/step
Go callback from the EarlyStoppingByMAP, logs: 
{'loss': 0.0388911374788188, 'acc': 0.9972696414934574}
10000/10000 [==============================] - 0s 41us/step
Go callback from the ReduceLROnPlateau, logs: 
{'loss': 0.0388911374788188, 'acc': 0.9972696414934574}
Epoch 5/10
60000/60000 [==============================] - 12s 197us/step - loss: 0.0330
10000/10000 [==============================] - 0s 39us/step
Go callback from the EarlyStoppingByMAP, logs: 
{'loss': 0.03298293751536124, 'acc': 0.9959456176387349}
10000/10000 [==============================] - 0s 39us/step
Go callback from the ReduceLROnPlateau, logs: 
{'loss': 0.03298293751536124, 'acc': 0.9959456176387349}

Хорошо, похоже, что по крайней мере ранняя остановка работает.Я думаю, ReduceLROnPlateau до, потому что они используют одни и те же журналы и похожую логику - если там были установлены соответствующие параметры.

Если вы не хотите использовать функцию sklearn, но SSDEvaluation (Iпросто не могу найти, что это) - вы можете легко принять функцию on_epoch_method, чтобы справиться с этой функцией оценки.

Надеюсь, это поможет.