केरास में कस्टम उद्देश्य फ़ंक्शन कैसे बनाएं?

Question

कई उद्देश्य कार्यों कैसे आप अपने खुद के उद्देश्य समारोह बना सकते हैं Keras here.

में कर रहे हैं लेकिन, मैं एक बहुत ही मूल उद्देश्य समारोह बनाने की कोशिश की, लेकिन यह एक त्रुटि देता है और मैं कोई रास्ता नहीं के आकार का पता करने के लिए नहीं है पैरामीटर रन रन पर फ़ंक्शन को पास कर दिया गया।

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 

2 का खंडन त्रुटियों,

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. 

इसे कहते हैं लागत या हानि समारोह में लौटे एक अदिश होना चाहिए, लेकिन हो रही है अगर मैं नुकसान = T.vector ('से लाइन 2 को बदलने float64 ')
को
नुकसान = T.scalar (' float64 ')

यह इस त्रुटि

से पता चलता

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

(फिक्स्ड उत्तर) यह Keras बैकएंड बुला रहा है क्या करने के लिए एक आसान तरीका:

import keras.backend as K 

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

तब:

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

कि

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

Answer 2

के बराबर होती है यहाँ मेरी छोटा-सा स्निपेट है नए नुकसान कार्यों को लिखने और उपयोग करने से पहले उनका परीक्षण करें:

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() 

यहाँ के रूप में आप मैं binary_crossentropy नुकसान का परीक्षण कर रहा हूँ देख सकते हैं, और 2 अलग नुकसान को परिभाषित किया है एक numpy संस्करण (_loss_np) एक और टेन्सर संस्करण (_loss_tensor) [ध्यान दें: अगर आप सिर्फ keras कार्यों तब का उपयोग यह काम करेंगे Theano और Tensorflow दोनों के साथ ... लेकिन यदि आप उनमें से किसी एक के आधार पर हैं तो आप उन्हें K.theano.tensor.function या K.tf.function]

बाद में मैं आउटपुट आकार की तुलना कर रहा हूं और आउटपुट के एल 2 मानदंड (जो लगभग बराबर होना चाहिए) और अंतर के एल 2 मानदंड (0 की ओर होना चाहिए)

एक बार जब आप संतुष्ट हो जाएं कि आपका नुकसान कार्य ठीक से काम कर रहा है के रूप में उपयोग कर सकते हैं:

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