Maximizar o MSE de um modelo keras

Eu tenho redes adversárias generativas, onde o discriminador é minimizado com o MSE e o gerador deve ser maximizado. Porque ambos são oponentes que buscam o objetivo oposto.

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)

O que preciso adaptar para obter um modelo de gerador que lucre com um alto valor de MSE?

ATUALIZAR:

A implementação original do MSE tem a seguinte aparência:

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)

Eu acho que a função correta de perda de maximizador:

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)

Dessa forma, obtemos sempre um valor de perda positivo, como no caso da função MSE, mas com efeito reverso.

ATUALIZAÇÃO 2: Inicialmente, escrevi que o primeiro pensamento intuitivo de simplesmente negar a perda NÃO dará ao resultado o que esperávamos, devido ao conceito básico dos métodos de otimização (você pode ler uma discussão interessante aqui ). Depois que verifiquei os dois métodos duas vezes, para obter o resultado em uma tarefa de aprendizado específica (Nota: não fiz um teste completo), o método deu a maximização da perda, embora a -lossabordagem tenha convergido um pouco mais rápido. Não tenho certeza se ela sempre oferece a melhor solução ou qualquer solução devido ao possível problema descrito aqui . Se alguém tiver outra experiência, entre em contato.

Portanto, se alguém quiser tentar -losstambém:

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)

Detalhes adicionais:

OP escreveu:

Eu tenho redes contraditórias generativas, onde o discriminador é minimizado com o MSE e o gerador deve ser maximizado. Porque ambos são oponentes que buscam o objetivo oposto.

No link fornecido pela Ibragil:

Enquanto isso, o gerador está criando novas imagens sintéticas que são transmitidas ao discriminador. Fá-lo na esperança de que eles também sejam considerados autênticos, mesmo sendo falsos. O objetivo do gerador é gerar dígitos manuscritos passáveis: mentir sem ser pego. O objetivo do discriminador é identificar imagens falsas do gerador.

Portanto, este é um problema incorreto:

Na GAN, nosso objetivo final é treinar nossas duas contrapartes, o discriminador e o gerador, para que tenham o melhor desempenho possível entre si. Isso significa que o algoritmo de aprendizado de duas bases tem tarefas diferentes, mas a função de perda com a qual eles podem alcançar a solução ideal é a mesmabinary_crossentropy , ou seja , portanto, as tarefas dos modelos são minimizar esse desperdício.

O método de compilação de um modelo discriminador :

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

O método de compilação de um modelo de gerador :

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

É o mesmo objetivo de dois corredores para minimizar o tempo de chegar à final, mesmo assim eles são concorrentes nessa tarefa.

Portanto, o "objetivo oposto" não significa tarefa oposta, ou seja, minimizar a perda (ou seja, minimizar o tempo no exemplo do corredor).

Espero que ajude.

A questão não está muito clara para mim. Suponho que você deseja maximizar em vez de minimizar, enquanto usa o critério do MSE.

Você pode implementar sua própria função de perda customizada, que calcula o -MSE; inverter o sinal da perda e, assim, conseguir um giro na direção da descida do gradiente.

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

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

Outra opção é simplesmente fornecer uma etapa negativa de aprendizado - mas não tenho certeza de que o Keras permita que você faça isso. Vale a pena tentar.