comment mettre en œuvre des mesures personnalisées dans keras?

J'obtiens cette erreur :

somme() a obtenu un inattendu argument mot-clé "out"

lorsque j'exécute ce code:

import pandas as pd, numpy as np
import keras
from keras.layers.core import Dense, Activation
from keras.models import Sequential
def AUC(y_true,y_pred):
not_y_pred=np.logical_not(y_pred)
y_int1=y_true*y_pred
y_int0=np.logical_not(y_true)*not_y_pred
TP=np.sum(y_pred*y_int1)
FP=np.sum(y_pred)-TP
TN=np.sum(not_y_pred*y_int0)
FN=np.sum(not_y_pred)-TN
TPR=np.float(TP)/(TP+FN)
FPR=np.float(FP)/(FP+TN)
return((1+TPR-FPR)/2)
# Input datasets
train_df = pd.DataFrame(np.random.rand(91,1000))
train_df.iloc[:,-2]=(train_df.iloc[:,-2]>0.8)*1
model = Sequential()
model.add(Dense(output_dim=60, input_dim=91, init="glorot_uniform"))
model.add(Activation("sigmoid"))
model.add(Dense(output_dim=1, input_dim=60, init="glorot_uniform"))
model.add(Activation("sigmoid"))
model.compile(optimizer='rmsprop',loss='binary_crossentropy',metrics=[AUC])
train_df.iloc[:,-1]=np.ones(train_df.shape[0]) #bias
X=train_df.iloc[:,:-1].values
Y=train_df.iloc[:,-1].values
print X.shape,Y.shape
model.fit(X, Y, batch_size=50,show_accuracy = False, verbose = 1)

Est-il possible de mettre en œuvre une métrique personnalisée à part de faire une boucle sur les lots et modifier le code source?

OriginalL'auteur Philippe C | 2016-06-06

  1. 8

    Ce code ne fonctionne pas car y_pred et y_true ne sont pas des tableaux numpy mais soit Théano ou Tenseur de Flux de tenseurs. C'est pourquoi vous avez eu cette erreur.

    Vous pouvez définir vos mesures personnalisées, mais vous devez vous rappeler que ses arguments sont ceux Tenseurs - pas de tableaux numpy.

    Pourriez-vous élaborer comment résoudre ce problème? Comment puis-je transformer un Tenseur pour un tableau numpy?
    Vous devez penser à un tenseur d'une variable algébrique. Vous ne pouvez pas transformer un tableau numpy pour tenseur. On ne pouvait attribuer le tableau numpy comme une valeur d'un tenseur.
    Je ne veux pas transformer un tableau numpy pour un tenseur mais dans l'autre sens. Si nous prenons l'OP de la fonction, j'ai essayé: def AUC(y_true,y_pred): numpy_y_true = y_true.eval() ... return ... mais il ne fonctionne pas. Comment voulez-vous résoudre OP problème?
    Une métrique personnalisée ne peut pas être un nombre typique-le retour de fonction. Même "def asc(y_true, y_pred): return 1.0" ne fonctionne pas. La métrique de la fonction est appelée au moment de la compilation une fois, avant que tous les exemples d'apprentissage sont considérés.
    C'est vrai. Mais encore entrées doivent être tenseurs

    OriginalL'auteur Marcin Możejko

  2. 10

    Ici, je vais répondre à l'OP de la question le sujet plutôt que son problème exact. Je suis en train de faire ce que la question s'affiche en haut quand je google le sujet problème.

    Vous pouvez mettre en œuvre une métrique personnalisée de deux façons.

    1. Comme mentionné dans Keras docu. 

      import keras.backend as K
def mean_pred(y_true, y_pred):
return K.mean(y_pred)
model.compile(optimizer='sgd',
loss='binary_crossentropy',
metrics=['accuracy', mean_pred])

      Mais ici, vous devez vous rappeler que mentionné dans Marcin Możejko réponse que y_true et y_pred sont des tenseurs. Afin de calculer correctement la métrique, vous devez utiliser keras.backend fonctionnalité. S'il vous plaît regardez ce DONC, la question pour plus de détails Comment calculer F1 Macro dans Keras?

    2. Ou vous pouvez la mettre en œuvre dans un hacky façon comme mentionné dans Keras GH problème. Pour cela, vous devez utiliser callbacks argument de model.fit. 

      import keras as keras
import numpy as np
from keras.optimizers import SGD
from sklearn.metrics import roc_auc_score
model = keras.models.Sequential()
# ...
sgd = SGD(lr=0.001, momentum=0.9)
model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy'])
class Metrics(keras.callbacks.Callback):
def on_train_begin(self, logs={}):
self._data = []
def on_epoch_end(self, batch, logs={}):
X_val, y_val = self.validation_data[0], self.validation_data[1]
y_predict = np.asarray(model.predict(X_val))
y_val = np.argmax(y_val, axis=1)
y_predict = np.argmax(y_predict, axis=1)
self._data.append({
'val_rocauc': roc_auc_score(y_val, y_predict),
})
return
def get_data(self):
return self._data
metrics = Metrics()
history = model.fit(X_train, y_train, epochs=100, validation_data=(X_val, y_val), callbacks=[metrics])
metrics.get_data()
    Je suggère l'utilisation de l'auto.modèle plutôt que de modèle, de sorte que cette classe peut être caché loin dans un fichier différent.

    OriginalL'auteur vogdb

  3. 4

    vous pouvez passer d'un modèle.predict() dans votre AUC métrique de la fonction. [cela va itérer sur bacthes de sorte que vous feriez mieux d'utiliser le modèle.predict_on_batch(). En supposant que vous avez quelque chose comme un softmax de la couche de sortie (quelque chose que les sorties de probabilités), alors vous pouvez l'utiliser avec sklearn.métrique pour obtenir de l'ASC.

    from sklearn.metrics import roc_curve, auc

    de ici

    def sklearnAUC(test_labels,test_prediction):
n_classes = 2
# Compute ROC curve and ROC area for each class
fpr = dict()
tpr = dict()
roc_auc = dict()
for i in range(n_classes):
# ( actual labels, predicted probabilities )
fpr[i], tpr[i], _ = roc_curve(test_labels[:, i], test_prediction[:, i])
roc_auc[i] = auc(fpr[i], tpr[i])
return round(roc_auc[0],3) , round(roc_auc[1],3)

    maintenant faire de votre métrique

    # gives a numpy array like so [ [0.3,0.7] , [0.2,0.8] ....]    
Y_pred = model.predict_on_batch ( X_test  ) 
# Y_test looks something like [ [0,1] , [1,0] .... ]
# auc1 and auc2 should be equal
auc1 , auc2 = sklearnAUC(  Y_test ,  Y_pred )

    OriginalL'auteur ahmedhosny