DCGAN PyTorch Deep learning

Question

This DCGAN PyTorch code is designed for image of size 6464, and i modified the code for generator and discriminator for 256256, also the batch size is given as 64

# Training Loop

# Lists to keep track of progress
img_list = []
G_losses = []
D_losses = []
iters = 0
generator = Generator(ngpu)
discriminator = Discriminator(ngpu)
print("Starting Training Loop...")
# For each epoch
for epoch in range(num_epochs):
    # For each batch in the dataloader
    for i, data in enumerate(dataloader, 0):

        ############################
        # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))
        ###########################
        ## Train with all-real batch
        netD.zero_grad()
        # Format batch
        real_cpu = data[0].to(device)
        b_size = real_cpu.size(0)
        label = torch.full((b_size,), real_label, dtype=torch.float, device=device)
        # Forward pass real batch through D
        output = netD(real_cpu).view(-1)
        # Calculate loss on all-real batch
        errD_real = criterion(output, label)
        # Calculate gradients for D in backward pass
        errD_real.backward()
        D_x = output.mean().item()

        ## Train with all-fake batch
        # Generate batch of latent vectors
        noise = torch.randn(b_size, nz, 1, 1, device=device)
        # Generate fake image batch with G
        fake = netG(noise)
        label.fill_(fake_label)
        # Classify all fake batch with D
        output = netD(fake.detach()).view(-1)
        # Calculate D's loss on the all-fake batch
        errD_fake = criterion(output, label)
        # Calculate the gradients for this batch, accumulated (summed) with previous gradients
        errD_fake.backward()
        D_G_z1 = output.mean().item()
        # Compute error of D as sum over the fake and the real batches
        errD = errD_real + errD_fake
        # Update D
        optimizerD.step()

        ############################
        # (2) Update G network: maximize log(D(G(z)))
        ###########################
        netG.zero_grad()
        label.fill_(real_label)  # fake labels are real for generator cost
        # Since we just updated D, perform another forward pass of all-fake batch through D
        output = netD(fake).view(-1)
        # Calculate G's loss based on this output
        errG = criterion(output, label)
        # Calculate gradients for G
        errG.backward()
        D_G_z2 = output.mean().item()
        # Update G
        optimizerG.step()

        # Output training stats
        if i % 50 == 0:
            print('[%d/%d][%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f\tD(x): %.4f\tD(G(z)): %.4f / %.4f'
                  % (epoch, num_epochs, i, len(dataloader),
                     errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))
        # Save Losses for plotting later
        G_losses.append(errG.item())
        D_losses.append(errD.item())
        # Check how the generator is doing by saving G's output on fixed_noise
        if (iters % 500 == 0) or ((epoch == num_epochs-1) and (i == len(dataloader)-1)):
            with torch.no_grad():
                fake = netG(fixed_noise).detach().cpu()
            img_list.append(vutils.make_grid(fake, padding=2, normalize=True))
        iters += 1
    torch.save(discriminator.state_dict(),
                   "%s/discriminator_epoch_%03d.pth" % ('/content/output/pth_model', epoch))
    torch.save(generator.state_dict(),
                   "%s/generator_epoch_%03d.pth" % ('/content/output/pth_model', epoch))

I tried to give image of size if size 256256 and the model was optimized for 6464, somehow i modified Generator and Discriminator, also, I'm getting error in training loop like:

Starting Training Loop...
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-22-44ba20a42bdc> in <cell line: 12>()
     26         output = netD(real_cpu).view(-1)
     27         # Calculate loss on all-real batch
---> 28         errD_real = criterion(output, label)
     29         # Calculate gradients for D in backward pass
     30         errD_real.backward()

3 frames
/usr/local/lib/python3.10/dist-packages/torch/nn/functional.py in binary_cross_entropy(input, target, weight, size_average, reduce, reduction)
   3111         reduction_enum = _Reduction.get_enum(reduction)
   3112     if target.size() != input.size():
-> 3113         raise ValueError(
   3114             "Using a target size ({}) that is different to the input size ({}) is deprecated. "
   3115             "Please ensure they have the same size.".format(target.size(), input.size())

ValueError: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([10816])) is deprecated. Please ensure they have the same size.