I’m training a Wasserstein GAN with Gradient Penalty (WGAN-GP) but incur mismatch in my real and fake dimensions.
My data (real) is torch.Size([50,1,50,300]). The issue is the conversion from fake_noise (torch.Size([50,300])) to fake(torch.Size([50, 1, 28, 28])) as such: fake = gen(fake_noise).
cur_step = 0
generator_losses = []
critic_losses = []
for epoch in range(n_epochs):
    for real in tqdm(dataloader):
        cur_batch_size = len(real) # len = 50
        real = real.to(device)

        mean_iteration_critic_loss = 0
        for _ in range(crit_repeats):
            crit_opt.zero_grad()
            fake_noise = get_noise(cur_batch_size, z_dim, device=device)
            fake = gen(fake_noise) # len = 50
            crit_fake_pred = crit(fake.detach())
            crit_real_pred = crit(real)
            epsilon = torch.rand(len(real), 1, 1, 1, device=device, requires_grad=True)
            gradient = get_gradient(crit, real, fake.detach(), epsilon)
            gp = gradient_penalty(gradient)
            crit_loss = get_crit_loss(crit_fake_pred, crit_real_pred, gp, c_lambda)

     25             epsilon = torch.rand(len(real), 1, 1, 1, device=device, requires_grad=True)
---> 26             gradient = get_gradient(crit, real, fake.detach(), epsilon)
     27             gp = gradient_penalty(gradient)
     28             crit_loss = get_crit_loss(crit_fake_pred, crit_real_pred, gp, c_lambda)

<ipython-input-28-35150bdb454c> in get_gradient(crit, real, fake, epsilon)
     13     '''
     14     # Mix the images together
---> 15     mixed_images = real * epsilon + fake * (1 - epsilon)
     16 
     17     # Calculate the critic's scores on the mixed images

RuntimeError: The size of tensor a (300) must match the size of tensor b (28) at non-singleton dimension 3

This is my generator class (gen):
class Generator(nn.Module):
    def __init__(self, z_dim=10, im_chan=1, hidden_dim=300 ):
        super(Generator, self).__init__()
        self.z_dim = z_dim
        # Build the neural network
        self.gen = nn.Sequential(
            self.make_gen_block(z_dim, hidden_dim * 4),
            self.make_gen_block(hidden_dim * 4, hidden_dim * 2, kernel_size=4, stride=1),
            self.make_gen_block(hidden_dim * 2, hidden_dim),
            self.make_gen_block(hidden_dim, im_chan, kernel_size=4, final_layer=True),
        )

    def make_gen_block(self, input_channels, output_channels, kernel_size=3, stride=2, final_layer=False):
        if not final_layer:
            return nn.Sequential(
                nn.ConvTranspose2d(input_channels, output_channels, kernel_size, stride),
                nn.BatchNorm2d(output_channels),
                nn.ReLU(inplace=True),
            )
        else:
            return nn.Sequential(
                nn.ConvTranspose2d(input_channels, output_channels, kernel_size, stride),
                nn.Tanh(),
            )

    def forward(self, noise):
        x = noise.view(len(noise), self.z_dim, 1, 1)
        return self.gen(x)