cgan shape problem (shape [64,3,64,64] is invalid for input of size 2952192) - runtime-error

Question

This is original github source:
https://github.com/otepencelik/GAN-Artwork-Generation
I want to rerun this model (CGAN) and use it in another area.
I want to change the network to generate multiple label and increase the performance but it didn't work well. I need somebody to help me! Thanks~ Error information as follow. I think the problem is reshape problem but I don't know how to figure it out! Need some help
Input attributes :#Number of all images (81474)!!!
# Root directory for dataset
dataroot = "***"
# Number of workers for dataloader
workers = 2
# Batch size during training
batch_size = 64
# Spatial size of training images. All images will be resized to this
# size using a transformer.
image_size = 64
#number of calsses lable
n_class = 27
# Number of channels in the training images. For color images this is 3
nc = 3
# Size of z latent vector (i.e. size of generator input)
nz = 100
# Size of feature maps in generator （output)
ngf = 64
# Size of feature maps in discriminator
ndf = 64
# Number of training epochs
num_epochs = 5
# Learning rate for optimizers
lr = 0.0002
# Beta1 hyperparam for Adam optimizers
beta1 = 0.5
# Number of GPUs available. Use 0 for CPU mode.
ngpu = 1
Generator model design
def __init__(self, ngpu=1):
super(Generator, self).__init__()
self.label_emb = nn.Embedding(n_class, n_class)
self.ngpu = ngpu
self.main = nn.Sequential(
# input is Z, going into a convolution
nn.ConvTranspose2d( nz + n_class, ngf * 16, 4, 1, 0, bias=False),
nn.BatchNorm2d(ngf * 16),
nn.ReLU(True),
# state size. (ngf*8) x 4 x 4
nn.ConvTranspose2d(ngf * 16, ngf * 8, 4, 2, 1, bias=False),
nn.BatchNorm2d(ngf * 8),
nn.ReLU(True),
# state size. (ngf*4) x 8 x 8
nn.ConvTranspose2d( ngf * 8, ngf * 4, 4, 2, 1, bias=False),
nn.BatchNorm2d(ngf * 4),
nn.ReLU(True),
# state size. (ngf*2) x 16 x 16
nn.ConvTranspose2d( ngf * 4, ngf, 4, 4, 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, noise_input, labels):
# Concatenate label embedding and image to produce input
#print(self.label_emb(labels).unsqueeze(2).unsqueeze(3).shape, noise_input.shape, labels.shape)
gen_input = torch.cat((self.label_emb(labels).unsqueeze(2).unsqueeze(3), noise_input), 1)
img = self.main(gen_input)
img = img.view(img.size(0), *(nc, image_size, image_size))
return img
netG = Generator(ngpu).to(device)
Training model
# Training Loop
# Lists to keep track of progress
img_list = []
G_losses = []
D_losses = []
iters = 0
print("Starting Training Loop...")
# For each epoch
for epoch in range(num_epochs):
# For each batch in the dataloader
for i, (data, real_style_labels) 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.to(device)
b_size = real_cpu.size(0)
label = torch.full((b_size,), real_label, dtype=torch.float, device=device)
# style labels - iso
real_style_labels = real_style_labels.to(device)
fake_style_labels = torch.tensor(np.random.choice(n_class, size = b_size)).type(torch.LongTensor).to(device)
# Forward pass real batch through D
output = netD(gaussian(real_cpu, mean=0, stddev=0.5*0.01**(epoch/num_epochs)), real_style_labels).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, fake_style_labels)
label.fill_(fake_label)
# Classify all fake batch with D
output = netD(fake.detach(), fake_style_labels).view(-1)
# Calculate D's loss on the all-fake batch
errD_fake = criterion(output, label)
# Calculate the gradients for this batch
errD_fake.backward()
D_G_z1 = output.mean().item()
# Add the gradients from the all-real and all-fake 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, fake_style_labels).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 % 200 == 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 % 2000 == 0) or ((epoch == num_epochs-1) and (i == len(dataloader)-1)):
if (i == len(dataloader)-1):
with torch.no_grad():
fake = netG(fixed_noise, fixed_label).detach().cpu()
img_list.append(vutils.make_grid(fake, nrow = example_size,padding=2, normalize=True))
save_image(fake.data, img_save_path + '/%d-%d.png' % (epoch,iters), nrow=example_size, normalize=True)
iters += 1
error information:
RuntimeError Traceback (most recent call last)
<ipython-input-65-50e58bbfe414> in <module>
37 noise = torch.randn(b_size, nz, 1, 1, device=device)
38 # Generate fake image batch with G
---> 39 fake = netG(noise, fake_style_labels)
40 label.fill_(fake_label)
41 # Classify all fake batch with D
~/opt/anaconda3/lib/python3.8/site-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs)
1100 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
1101 or _global_forward_hooks or _global_forward_pre_hooks):
-> 1102 return forward_call(*input, **kwargs)
1103 # Do not call functions when jit is used
1104 full_backward_hooks, non_full_backward_hooks = [], []
<ipython-input-61-cb81d45887cf> in forward(self, noise_input, labels)
31 gen_input = torch.cat((self.label_emb(labels).unsqueeze(2).unsqueeze(3), noise_input), 1)
32 img = self.main(gen_input)
---> 33 img = img.view(img.size(0), *(nc, image_size, image_size))
34 return img
35
RuntimeError: shape '[64, 3, 64, 64]' is invalid for input of size 2952192
I spent a few days to figure out the logic but I failed. Hope somebody can help me out!! Thanks