Maximieren Sie die MSE eines Keras-Modells

Ich habe ein generatives gegnerisches Netzwerk, in dem der Diskriminator mit der MSE minimiert wird und der Generator maximiert werden sollte. Weil beide Gegner sind, die das entgegengesetzte Ziel verfolgen.

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)

Was muss ich anpassen, um ein Generatormodell zu erhalten, das von einem hohen MSE-Wert profitiert?

AKTUALISIEREN:

Die ursprüngliche MSE- Implementierung sieht folgendermaßen aus:

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)

Ich denke die richtige Maximiererverlustfunktion:

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)

Auf diese Weise erhalten wir wie bei der MSE-Funktion immer einen positiven Verlustwert, jedoch mit umgekehrter Wirkung.

UPDATE 2: Anfangs schrieb ich, dass der intuitive erste Gedanke, den Verlust einfach zu negieren, aufgrund des Grundkonzepts der Optimierungsmethoden NICHT das Ergebnis liefert , was wir erwartet hatten (eine interessante Diskussion können Sie hier lesen ). Nachdem ich beide Methoden Kopf an Kopf überprüft hatte, ergab das Ergebnis einer bestimmten Lernaufgabe (Hinweis: Ich habe keinen vollständigen Test durchgeführt), dass beide Methoden die Verlustmaximierung ergaben, obwohl der -lossAnsatz etwas schneller konvergierte. Ich bin mir nicht sicher, ob es aufgrund des hier beschriebenen möglichen Problems immer die beste Lösung oder eine Lösung gibt . Wenn jemand andere Erfahrungen hat, lassen Sie es mich bitte wissen.

Also, wenn jemand es auch versuchen möchte -loss:

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)

Zusätzliche Details:

OP schrieb:

Ich habe ein generatives gegnerisches Netzwerk, in dem der Diskriminator mit der MSE minimiert wird und der Generator maximiert werden sollte. Weil beide Gegner sind, die das entgegengesetzte Ziel verfolgen.

Aus dem von Ibragil bereitgestellten Link:

In der Zwischenzeit erstellt der Generator neue synthetische Bilder, die er an den Diskriminator weiterleitet. Dies in der Hoffnung, dass auch sie als authentisch gelten, obwohl sie gefälscht sind. Das Ziel des Generators ist es, passable handgeschriebene Ziffern zu generieren: zu liegen, ohne erwischt zu werden. Das Ziel des Diskriminators ist es, vom Generator kommende Bilder als Fälschung zu identifizieren.

Das ist also ein schlecht gestelltes Problem:

In GAN unser letztes Ziel, unsere beiden Gegenparteien, den Diskriminator und den Generator , so zu trainieren , dass sie so gut wie möglich gegeneinander abschneiden. Dies bedeutet, dass die beiden Basislernalgorithmen unterschiedliche Aufgaben haben, aber die Verlustfunktion, mit der sie die optimale Lösung erzielen können, dieselbe ist, dh binary_crossentropydie Aufgaben der Modelle bestehen darin, diesen Verlust zu minimieren.

Kompilierungsmethode eines Diskriminatormodells :

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

Kompilierungsmethode eines Generatormodells :

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

Es ist dasselbe wie das Ziel von zwei Läufern, ihre Zeit bis zum Erreichen des Ziels zu minimieren, auch wenn sie bei dieser Aufgabe Konkurrenten sind.

Das "entgegengesetzte Ziel" bedeutet also nicht die entgegengesetzte Aufgabe, dh den Verlust zu minimieren (dh die Zeit im Läufer-Beispiel zu minimieren).

Ich hoffe, es hilft.

Die Frage ist mir nicht sehr klar. Ich nehme an, Sie möchten maximieren, anstatt zu minimieren, während Sie das Kriterium der MSE verwenden.

Sie können Ihre eigene benutzerdefinierte Verlustfunktion implementieren, die die -MSE berechnet. Umdrehen des Vorzeichens des Verlusts und somit Erzielen eines Umklappens in der Gradientenabstiegsrichtung.

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

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

Eine andere Möglichkeit besteht darin, einfach einen negativen Lernschritt anzugeben - aber ich bin mir nicht sicher, ob Keras dies zulässt. Einen Versuch wert.