Como o gerador em um GAN é treinado?

O artigo sobre GANs diz que o discriminador usa o seguinte gradiente para treinar:

$$\nabla _{\theta_d} \frac{1}{m}\sum^{m}_{i=1} [\log{D(x^{(i)})} + \log{(1-D(G(z^{(i)})))}]$$

Os valores são amostrados, passados ​​através do gerador para gerar amostras de dados e, em seguida, o discriminador é reproprogado usando as amostras de dados geradas. Uma vez que o gerador gera os dados, ele não desempenha mais nenhum papel no treinamento do discriminador. Em outras palavras, o gerador pode ser completamente removido da métrica, gerando amostras de dados e depois trabalhando apenas com as amostras.$z$

Estou um pouco mais confuso sobre como o gerador é treinado. Ele usa o seguinte gradiente:

$$\nabla _{\theta_g} \frac{1}{m}\sum^{m}_{i=1} [\log{(1-D(G(z^{(i)})))}]$$

Nesse caso, o discriminador faz parte da métrica. Não pode ser removido como no caso anterior. Coisas como mínimos quadrados ou probabilidade logarítmica em modelos discriminativos regulares podem ser facilmente diferenciadas porque possuem uma definição agradável e bem formada. No entanto, estou um pouco confuso sobre como você retropropõe quando a métrica depende de outra rede neural. Você basicamente liga as saídas do gerador às entradas do discriminador e depois trata a coisa toda como uma rede gigante em que os pesos na porção do discriminador são constantes?

Ajuda a pensar nesse processo em pseudocódigo. Let generator(z)Ser uma função que pega um vetor de ruído amostrado uniformemente ze retorna um vetor do mesmo tamanho que o vetor de entrada X; vamos chamar esse comprimento d. Let discriminator(x)Ser uma função que pega um dvetor dimensional e retorna uma probabilidade escalar que xpertence à verdadeira distribuição de dados. Para treinamento:

G_sample = generator(Z)
D_real = discriminator(X)
D_fake = discriminator(G_sample)

D_loss = maximize mean of (log(D_real) + log(1 - D_fake))
G_loss = maximize mean of log(D_fake)

# Only update D(X)'s parameters
D_solver = Optimizer().minimize(D_loss, theta_D)
# Only update G(X)'s parameters
G_solver = Optimizer().minimize(G_loss, theta_G)

# theta_D and theta_G are the weights and biases of D and G respectively
Repeat the above for a number of epochs

Então, sim, você está certo que pensamos essencialmente no gerador e no discriminador como uma rede gigante para minibatches alternados à medida que usamos dados falsos. A função de perda do gerador cuida dos gradientes dessa metade. Se você pensar isoladamente nesse treinamento de rede, ele será treinado da mesma maneira que você treinaria normalmente um MLP, cuja entrada será a saída da última camada da rede do gerador.

Você pode seguir uma explicação detalhada com o código no Tensorflow aqui (entre muitos lugares): http://wiseodd.github.io/techblog/2016/09/17/gan-tensorflow/

Deve ser fácil seguir uma vez que você olha o código.

Você basicamente liga as saídas do gerador às entradas do discriminador e, em seguida, trata a coisa toda como uma rede gigante em que os pesos na porção do discriminador são constantes?

Em pouco tempo: Sim. (Eu procurei algumas das fontes da GAN para checar isso)

Também há muito mais no treinamento da GAN, como: devemos atualizar D e G toda vez ou D em iterações ímpares e G em pares e muito mais. Há também um artigo muito bom sobre esse tópico:

"Técnicas aprimoradas para treinamento de GANs"

Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, Xi Chen

https://arxiv.org/abs/1606.03498

Recentemente, enviei uma coleção de vários modelos GAN no repositório do github. É baseado em torch7 e muito fácil de executar. O código é simples o suficiente para entender com resultados experimentais. Espero que isso ajude

https://github.com/nashory/gans-collection.torch