Как реализовать сверточные нейронные сети с экспоненциальными затухающими скоростями обучения в Keras или Theano

Question

Я хочу реализовать сверточные нейронные сети (CNN) с экспоненциально разлагающейся скоростью обучения в Keras или Theano. Скорость обучения динамически изменяется в соответствии со следующим законом обновления:

eta = et0*exp(LossFunction) 
where et0 is the initial learning rate and LossFunction is a cost function 

Я знаю Keras позволяет настроить синг оптимизатор:

SGD(lr, momentum0, decay, nesterov) 

Термин распада позволяет только для фиксированного гнилого распада Учится скоростью над каждая эпоха.

Как настроить или закодировать SGD, используя скорость обучения, экспоненциально затухающую по отношению к функции стоимости? Для вас информации, я выкладываю исходный код СГДА в Keras:

class SGD(Optimizer): 

'''Stochastic gradient descent, with support for momentum, 
learning rate decay, and Nesterov momentum. 


# Arguments 
    lr: float >= 0. Learning rate. 
    momentum: float >= 0. Parameter updates momentum. 
    decay: float >= 0. Learning rate decay over each update. 
    nesterov: boolean. Whether to apply Nesterov momentum. 
''' 

def __init__(self, lr=0.01, momentum=0., decay=0., 

      nesterov=False, **kwargs): 

    super(SGD, self).__init__(**kwargs) 
    self.__dict__.update(locals()) 
    self.iterations = K.variable(0.) 
    self.lr = K.variable(lr) 
    self.momentum = K.variable(momentum) 
    self.decay = K.variable(decay) 
    self.inital_decay = decay 

def get_updates(self, params, constraints, loss): 
    grads = self.get_gradients(loss, params) 
    self.updates = [] 

    lr = self.lr 
    if self.inital_decay > 0: 
     lr *= (1./(1. + self.decay * self.iterations)) 
     self.updates .append(K.update_add(self.iterations, 1)) 

    # momentum 
    shapes = [K.get_variable_shape(p) for p in params] 
    moments = [K.zeros(shape) for shape in shapes] 
    self.weights = [self.iterations] + moments 

    for p, g, m in zip(params, grads, moments): 
     v = self.momentum * m - lr * g # velocity 
     self.updates.append(K.update(m, v)) 

     if self.nesterov: 
      new_p = p + self.momentum * v - lr * g 
     else: 
      new_p = p + v 

     # apply constraints 
     if p in constraints: 
      c = constraints[p] 
      new_p = c(new_p) 

     self.updates.append(K.update(p, new_p)) 
    return self.updates 

def get_config(self): 
    config = {'lr': float(K.get_value(self.lr)), 
       'momentum': float(K.get_value(self.momentum)), 
       'decay': float(K.get_value(self.decay)), 
       'nesterov': self.nesterov} 

    base_config = super(SGD, self).get_config() 
    return dict(list(base_config.items()) + list(config.items())) 

Answer 1

Я думаю, что вы могли бы получить поведение, используя следующую схему:

1. Создать новый класс скорости обучения Controler с использованием this.
2. Сделайте это конструктором, чтобы принять набор для обучения и начальную скорость обучения, если он предоставлен для метода fit.
3. Сделайте это, чтобы вычислить потерю после каждой эпохи и обновить скорость обучения.