# GAN -- GCGAN : Lost Function weird behaviour

Hello everyone, I’m pretty new in Pytorch game, and need some help, hope you can help me !

Let me explain my problem. As a newbie, I’m training myself with the mnist DataSet to implement a DCGAN. Ok so I took very basic Network for my Generator and Discriminator (as you can see in my code below), and then I’m training my model. The problem is that I think the Loss Function of my Generator is fucked up : it’s value is either 100 or 0 at the first iteration and then I think that it breaks the whole network, here is what I get :

iteration 0 / 329 – epoch 0 ---- Loss_D : 2.2673 Loss_G : 0.0 D(x) : 0.2363 D(G(z1)) : 0.35204 D(G(z2)) : 1.0
iteration 50 / 329 – epoch 0 ---- Loss_D : 100.0 Loss_G : 0.0 D(x) : 1.0 D(G(z1)) : 1.0 D(G(z2)) : 1.0

Can you help me on that and maybe explain me what’s wrong with my code ? I let you know just below the interesting section of my code (Generator, Discriminator and training loop). If you think you neew more to figure it out, let me know.

Generator and Discriminator :

``````class Generator(nn.Module):
def __init__(self, ngpu):
super(Generator, self).__init__()
self.ngpu = ngpu
self.main = nn.Sequential(
# input is Z, going into a convolution
nn.ConvTranspose2d( nz, ngf * 8, 4, 1, 0, bias=False),
nn.BatchNorm2d(ngf * 8),
nn.ReLU(True),
# state size. (ngf*8) x 4 x 4
nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
nn.BatchNorm2d(ngf * 4),
nn.ReLU(True),
# state size. (ngf*4) x 8 x 8
nn.ConvTranspose2d( ngf * 4, ngf * 2, 4, 2, 1, bias=False),
nn.BatchNorm2d(ngf * 2),
nn.ReLU(True),
# state size. (ngf*2) x 16 x 16
nn.ConvTranspose2d( ngf * 2, ngf, 4, 2, 1, bias=False),
nn.BatchNorm2d(ngf),
nn.ReLU(True),
# state size. (ngf) x 32 x 32
nn.ConvTranspose2d( ngf, nc, 4, 2, 1, bias=False),
nn.Tanh()
# state size. (nc) x 64 x 64
)

def forward(self, input):
return self.main(input)

class Discriminator(nn.Module):
def __init__(self, ngpu):
super(Discriminator, self).__init__()
self.ngpu = ngpu
self.main = nn.Sequential(
# input is (nc) x 64 x 64
nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),
nn.LeakyReLU(0.2, inplace=True),
# state size. (ndf) x 32 x 32
nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
nn.BatchNorm2d(ndf * 2),
nn.LeakyReLU(0.2, inplace=True),
# state size. (ndf*2) x 16 x 16
nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
nn.BatchNorm2d(ndf * 4),
nn.LeakyReLU(0.2, inplace=True),
# state size. (ndf*4) x 8 x 8
nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
nn.BatchNorm2d(ndf * 8),
nn.LeakyReLU(0.2, inplace=True),
# state size. (ndf*8) x 4 x 4
nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
nn.Sigmoid()
)

def forward(self, input):
return self.main(input)

``````

Weight init, Loss Function, Optimizer :

``````def weights_init(m):
classname = m.__class__.__name__
if classname.find('Conv') != -1:
nn.init.normal_(m.weight.data, 0.0, 0.02)
elif classname.find('BatchNorm') != -1:
nn.init.normal_(m.weight.data, 1.0, 0.02)
nn.init.constant_(m.bias.data, 0)

G = Generator(1).to(device)
D = Discriminator(1).to(device)

G.apply(weights_init)
D.apply(weights_init)

BCE_loss = nn.BCELoss()
G_optimizer = optim.Adam(G.parameters(), lr=learning_rate, betas=(beta1, 0.999))
D_optimizer = optim.Adam(D.parameters(), lr=learning_rate, betas=(beta1, 0.999))

real_label = 1
fake_label = 0

G_loss_l = []
D_loss_l = []

``````

The Training Loop :

``````print("Starting Training Loop...")

for epoch in range(num_epoch) :
for i, data in enumerate(dataloader, 0):

#-------------------- Discriminator (maximize log(D(x)) + log(1 - D(G(z))))----------------------

#real datas

real = data[0].to(device) #gpu
b_size = real.size(0)
label = torch.full((b_size,), real_label, dtype=torch.float, device=device)
outputD_real = D(real).view(-1)
loss_D_real = BCE_loss(outputD_real, label)

#fake datas

noise = torch.randn(b_size, nz, 1, 1, device=device) #noise tensor
fake = G(noise)
label.fill_(fake_label)
outputD_fake = D(fake.detach()).view(-1)
loss_D_fake = BCE_loss(outputD_fake, label)
loss_D_fake.backward()
D_G_z1 = outputD_fake.mean().item()

loss_D = loss_D_real + loss_D_fake
D_optimizer.step()

#----------------- Generator (maximize log(D(G(z))))----------------------------

label.fill_(real_label)
outputD2 = D(fake).view(-1)
loss_G = BCE_loss(outputD2, label)
loss_G.backward()

D_G_z2 = outputD2.mean().item()
G_optimizer.step()  #on améliore G

G_loss_l.append(loss_G.item())
D_loss_l.append(loss_D.item())

if i%50==0 :
print("iteration ", i, "/", len(dataloader),"-- epoch", epoch, "---- Loss_D : ", loss_D.item(), " Loss_G : ", loss_G.item(),
" D(x) : ", D_x, " D(G(z1)) : ", D_G_z1, " D(G(z2)) : ", D_G_z2)

``````