Maximiser le MSE d'un modèle de keras

J'ai des réseaux contradictoires génératifs, où le discriminateur est minimisé avec le MSE et le générateur devrait être maximisé. Parce que les deux sont des adversaires qui poursuivent le but opposé.

generator = Sequential()
generator.add(Dense(units=50, activation='sigmoid', input_shape=(15,)))
generator.add(Dense(units=1, activation='sigmoid'))
generator.compile(loss='mse', optimizer='adam')

generator.train_on_batch(x_data, y_data)

Que dois-je adapter pour obtenir un modèle de générateur bénéficiant d'une valeur MSE élevée?

MISE À JOUR:

L' implémentation MSE d' origine se présente comme suit:

def mean_squared_error(y_true, y_pred):
    if not K.is_tensor(y_pred):
        y_pred = K.constant(y_pred)
    y_true = K.cast(y_true, y_pred.dtype)
    return K.mean(K.square(y_pred - y_true), axis=-1)

Je pense que la fonction de perte de maximiseur correcte:

def mean_squared_error_max(y_true, y_pred):
    if not K.is_tensor(y_pred):
        y_pred = K.constant(y_pred)
    y_true = K.cast(y_true, y_pred.dtype)
    return K.mean(K.square(1 / (y_pred - y_true)), axis=-1)

De cette façon, nous obtenons toujours une valeur de perte positive, comme dans le cas de la fonction MSE, mais avec un effet inversé.

MISE À JOUR 2: Au départ, j'ai écrit que la première pensée intuitive de simplement annuler la perte ne donnera PAS le résultat que nous attendions en raison du concept de base des méthodes d'optimisation (vous pouvez lire une discussion intéressante ici ). Après avoir vérifié les deux méthodes tête à tête, le résultat dans une tâche d'apprentissage particulière (Remarque: je n'ai pas fait de test complet) était que les deux méthodes donnaient la maximisation de la perte, bien que l' -lossapproche ait convergé un peu plus rapidement. Je ne sais pas si cela donne toujours la meilleure solution ou toute autre solution en raison du problème possible décrit ici . Si quelqu'un a une autre expérience, faites-le moi savoir.

Donc, si quelqu'un veut essayer -lossaussi:

def mean_squared_error(y_true, y_pred):
    if not K.is_tensor(y_pred):
        y_pred = K.constant(y_pred)
    y_true = K.cast(y_true, y_pred.dtype)
    return - K.mean(K.square(y_pred - y_true), axis=-1)

Détails supplémentaires:

OP a écrit:

J'ai des réseaux contradictoires génératifs, où le discriminateur est minimisé avec le MSE et le générateur devrait être maximisé. Parce que les deux sont des adversaires qui poursuivent le but opposé.

À partir du lien fourni par Ibragil:

Pendant ce temps, le générateur crée de nouvelles images synthétiques qu'il transmet au discriminateur. Il le fait dans l'espoir qu'eux aussi seront considérés comme authentiques, même s'ils sont faux. Le but du générateur est de générer des chiffres manuscrits praticables: mentir sans se faire attraper. L'objectif du discriminateur est d'identifier les images provenant du générateur comme fausses.

C'est donc un problème mal posé:

Dans le GAN, notre objectif final est de former nos deux contreparties, le discriminateur et le générateur, pour qu'ils fonctionnent le mieux possible l'un contre l'autre. Cela signifie que les deux algorithmes d'apprentissage de base ont des tâches différentes mais que la fonction de perte avec laquelle ils peuvent obtenir la solution optimale est la même, c'est binary_crossentropy-à- dire que les tâches des modèles sont de minimiser cette perte.

Un discriminateur modèle est la méthode de compilation:

self.discriminator.compile(loss='binary_crossentropy', optimizer=optimizer)

Un générateur de modèle du procédé de compilation:

self.generator.compile(loss='binary_crossentropy', optimizer=optimizer)

C'est la même chose que l'objectif de deux coureurs de minimiser leur temps pour atteindre l'arrivée même s'ils sont des concurrents dans cette tâche.

Ainsi, le "but opposé" ne signifie pas une tâche opposée, c'est-à-dire minimiser la perte (c'est-à-dire minimiser le temps dans l'exemple du coureur).

J'espère que ça aide.

La question n'est pas très claire pour moi. Je suppose que vous voulez maximiser au lieu de minimiser, tout en utilisant le critère du MSE.

Vous pouvez implémenter votre propre fonction de perte personnalisée, qui calcule le -MSE; renverser le signe de la perte, et ainsi réaliser un retournement dans la direction de descente du gradient.

def negative_mse(y,yhat): 
    return - K.mean(K.sum(K.square(y-yhat)))

model.compile(loss=negative_mse, optimizer='adam')

Une autre option consiste simplement à fournir une étape d'apprentissage négative - mais je ne suis pas sûr que Keras vous permette de le faire. Ça vaut le coup d'essayer.