GANs: gerador e discriminador
Teoria dos jogos minimax, instabilidade do treinamento de GANs, colapso de modos e implementação de DCGAN.
GANs: gerador e discriminador é uma aula grátis de Learn AI with Python no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn AI with Python, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn AI with Python inclui 4 aulas no total.
O que é uma GAN?
Uma Rede Generativa Adversária coloca duas redes em competição: um Generator que cria dados falsos e um Discriminator que julga o que é real e o que é falso. Elas competem, e o gerador aprende a produzir amostras convincentes.
O jogo adversário
Pense em um falsificador (gerador) e um detetive (discriminador). O falsificador melhora as falsificações para enganar o detetive; o detetive aguça seu olhar. Essa disputa faz os dois melhorarem, até que as falsificações pareçam reais.
O gerador
O gerador transforma um vetor de ruído aleatório em uma imagem falsa. Ele aprende a transformar números aleatórios sem significado em dados estruturados e de aparência realista.
class Generator(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Linear(100, 256), nn.ReLU(),
nn.Linear(256, 784), nn.Tanh()
)
def forward(self, z):
return self.net(z)O vetor de ruído
A entrada z é amostrada de uma normal padrão. Vetores de ruído diferentes produzem imagens diferentes, portanto o ruído é a "semente" da geração. Sua dimensão (aqui, 100) é o tamanho latente.
z = torch.randn(batch_size, 100)
fake_images = generator(z)O discriminador
O discriminador recebe uma imagem e produz uma única probabilidade: a probabilidade de ela ser real. Um Sigmoid fornece um valor no intervalo [0,1], em que 1 significa real e 0 significa falso.
class Discriminator(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Linear(784, 256), nn.LeakyReLU(0.2),
nn.Linear(256, 1), nn.Sigmoid()
)Treinando o discriminador
Treine D com um lote de imagens reais rotuladas como 1 e imagens falsas rotuladas como 0. Ele aprende a aumentar as pontuações das imagens reais e diminuir as das falsas usando entropia cruzada binária.
d_real = criterion(D(real), ones)
d_fake = criterion(D(fake.detach()), zeros)
d_loss = d_real + d_fake
d_loss.backward()Por que aplicar detach() às falsificações?
Ao treinar D, usamos fake.detach() para impedir que os gradientes fluam para o gerador. Nesta etapa, atualizamos apenas o discriminador; o gerador será treinado separadamente.
Treinando o gerador
Agora treine G para enganar D: passe as falsificações por D e recompense o gerador quando D produzir real (rótulo 1). O gerador melhora ao fazer D acreditar que suas falsificações são reais.
g_loss = criterion(D(fake), ones) # want D to say "real"
g_loss.backward()
g_optimizer.step()Treinamento alternado
Cada iteração alterna as etapas: primeiro atualize D e depois atualize G. Mantê-los aproximadamente equilibrados é essencial: se D ficar forte demais, G não receberá um gradiente útil; se ficar fraco demais, G não terá um desafio.
# per step
# 1) update Discriminator
# 2) update GeneratorColapso de modos
Uma falha clássica é o colapso de modos: o gerador encontra uma ou algumas saídas que enganam D e produz apenas essas saídas, ignorando a variedade dos dados. Sintoma: todas as amostras geradas parecem quase idênticas.
Instabilidade do treinamento
As GANs são notoriamente instáveis: as perdas oscilam, uma rede pode dominar a outra e a convergência é frágil. Técnicas como LeakyReLU, taxas de aprendizado cuidadosas e suavização de rótulos ajudam a estabilizar o treinamento.
Verificação rápida
Teste sua compreensão sobre GANs.
Recapitulação: GANs
Você aprendeu a configuração adversária: um gerador transforma um vetor de ruído em falsificações; um discriminador produz uma probabilidade de real ou falso; e os dois são treinados alternadamente, primeiro D e depois G. Você também aprendeu a identificar o colapso de modos e a instabilidade geral que torna as GANs difíceis de treinar.
Perguntas Frequentes
A aula “GANs: gerador e discriminador” é grátis?
Sim — o texto completo de “GANs: gerador e discriminador” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn AI with Python, atualize para CoddyKit PRO. O curso de Learn AI with Python inclui 4 aulas no total.
O que vou aprender em “GANs: gerador e discriminador”?
Teoria dos jogos minimax, instabilidade do treinamento de GANs, colapso de modos e implementação de DCGAN. Você pratica Learn AI with Python com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Learn AI with Python?
Nenhuma experiência prévia é necessária. Learn AI with Python no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “GANs: gerador e discriminador”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Learn AI with Python?
Sim. Cada aula de Learn AI with Python inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Autoencoders para aprendizado de representações
- Autoencoders variacionais (VAE)
- GANs: gerador e discriminador
- GANs condicionais e transferência de estilo