Come creare una funzione obiettivo personalizzata in Keras?

Question

Ci sono molte funzioni obiettivo in Keras here.

Ma come è possibile creare la propria funzione obiettivo, ho cercato di creare una funzione obiettivo molto semplice, ma dà un errore e non c'è modo di sapere le dimensioni del parametri passati alla funzione in fase di esecuzione.

def loss(y_true,y_pred): 
    loss = T.vector('float64') 
    for i in range(1): 
     flag = True 
     for j in range(y_true.ndim): 
      if(y_true[i][j] == y_pred[i][j]): 
       flag = False 
     if(flag): 
      loss = loss + 1.0 
    loss /= y_true.shape[0] 
    print loss.type 
    print y_true.shape[0] 
    return loss 

sto ottenendo 2 errori contraddittorie,

model.compile(loss=loss, optimizer=ada) 
    File "/usr/local/lib/python2.7/dist-packages/Keras-0.0.1-py2.7.egg/keras/models.py", line 75, in compile 
    updates = self.optimizer.get_updates(self.params, self.regularizers, self.constraints, train_loss) 
    File "/usr/local/lib/python2.7/dist-packages/Keras-0.0.1-py2.7.egg/keras/optimizers.py", line 113, in get_updates 
    grads = self.get_gradients(cost, params, regularizers) 
    File "/usr/local/lib/python2.7/dist-packages/Keras-0.0.1-py2.7.egg/keras/optimizers.py", line 23, in get_gradients 
    grads = T.grad(cost, params) 
    File "/usr/local/lib/python2.7/dist-packages/theano/gradient.py", line 432, in grad 
    raise TypeError("cost must be a scalar.") 
TypeError: cost must be a scalar. 

Dice costo o perdita restituiti nella funzione deve essere uno scalare, ma se cambio la linea 2 da perdita = T.vector (' float64 ')
a
perdita = T.scalar (' float64')

mostra questo errore

model.compile(loss=loss, optimizer=ada) 
    File "/usr/local/lib/python2.7/dist-packages/Keras-0.0.1-py2.7.egg/keras/models.py", line 75, in compile 
    updates = self.optimizer.get_updates(self.params, self.regularizers, self.constraints, train_loss) 
    File "/usr/local/lib/python2.7/dist-packages/Keras-0.0.1-py2.7.egg/keras/optimizers.py", line 113, in get_updates 
    grads = self.get_gradients(cost, params, regularizers) 
    File "/usr/local/lib/python2.7/dist-packages/Keras-0.0.1-py2.7.egg/keras/optimizers.py", line 23, in get_gradients 
    grads = T.grad(cost, params) 
    File "/usr/local/lib/python2.7/dist-packages/theano/gradient.py", line 529, in grad 
    handle_disconnected(elem) 
    File "/usr/local/lib/python2.7/dist-packages/theano/gradient.py", line 516, in handle_disconnected 
    raise DisconnectedInputError(message) 
theano.gradient.DisconnectedInputError: grad method was asked to compute the gradient with respect to a variable that is not part of the computational graph of the cost, or is used only by a non-differentiable operator: <TensorType(float64, matrix)> 

Answer 1

(Risposta fisso) Un modo semplice per farlo è chiamata Keras backend:

import keras.backend as K 

def custom_loss(y_true,y_pred): 
    return K.mean((y_true - y_pred)**2) 

Poi:

model.compile(loss=custom_loss, optimizer=sgd,metrics = ['accuracy']) 

che equivale

model.compile(loss='mean_squared_error', optimizer=sgd,metrics = ['accuracy']) 

Answer 2

Ecco il mio piccolo frammento scrivere nuove funzioni di perdita e testarle prima dell'uso:

import numpy as np 

from keras import backend as K 

_EPSILON = K.epsilon() 

def _loss_tensor(y_true, y_pred): 
    y_pred = K.clip(y_pred, _EPSILON, 1.0-_EPSILON) 
    out = -(y_true * K.log(y_pred) + (1.0 - y_true) * K.log(1.0 - y_pred)) 
    return K.mean(out, axis=-1) 

def _loss_np(y_true, y_pred): 
    y_pred = np.clip(y_pred, _EPSILON, 1.0-_EPSILON) 
    out = -(y_true * np.log(y_pred) + (1.0 - y_true) * np.log(1.0 - y_pred)) 
    return np.mean(out, axis=-1) 

def check_loss(_shape): 
    if _shape == '2d': 
     shape = (6, 7) 
    elif _shape == '3d': 
     shape = (5, 6, 7) 
    elif _shape == '4d': 
     shape = (8, 5, 6, 7) 
    elif _shape == '5d': 
     shape = (9, 8, 5, 6, 7) 

    y_a = np.random.random(shape) 
    y_b = np.random.random(shape) 

    out1 = K.eval(_loss_tensor(K.variable(y_a), K.variable(y_b))) 
    out2 = _loss_np(y_a, y_b) 

    assert out1.shape == out2.shape 
    assert out1.shape == shape[:-1] 
    print np.linalg.norm(out1) 
    print np.linalg.norm(out2) 
    print np.linalg.norm(out1-out2) 


def test_loss(): 
    shape_list = ['2d', '3d', '4d', '5d'] 
    for _shape in shape_list: 
     check_loss(_shape) 
     print '======================' 

if __name__ == '__main__': 
    test_loss() 

Qui, come potete vedere sto testando la perdita binary_crossentropy, e hanno 2 sconfitte separati definito, una versione NumPy (_loss_np) un'altra versione tensore (_loss_tensor) [Nota: se si utilizza le funzioni Keras allora funzionerà sia con Theano che con Tensorflow ... ma se dipendi da uno di essi puoi anche fare riferimento a K.theano.tensor.function o K.tf.function]

Più avanti sto confrontando le forme di output e il Norma L2 delle uscite (che dovrebbe essere quasi uguale) e la norma L2 della differenza (che dovrebbe essere verso 0)

Una volta che sei soddisfatto del corretto funzionamento della tua funzione di perdita può essere utilizzato come:

model.compile(loss=_loss_tensor, optimizer=sgd)