RuntimeError: mat1 and mat2 shapes cannot be multiplied (20x150528 and 784x512)

I used GAN to generate a new image for the first time, but there was an error like the title, how can I solve it?

import argparse import os import numpy as np import math import sys

import torchvision.transforms as transforms
from torchvision.utils import save_image

from import DataLoader
from torchvision import datasets
from torch.autograd import Variable

import torch.nn as nn
import torch.nn.functional as F
import torch

os.makedirs(“images”, exist_ok=True)

parser = argparse.ArgumentParser()
parser.add_argument(“–n_epochs”, type=int, default=200, help=“number of epochs of training”)
parser.add_argument(“–batch_size”, type=int, default=64, help=“size of the batches”)
parser.add_argument(“–lr”, type=float, default=0.00005, help=“learning rate”)
parser.add_argument(“–n_cpu”, type=int, default=8, help=“number of cpu threads to use during batch generation”)
parser.add_argument(“–latent_dim”, type=int, default=100, help=“dimensionality of the latent space”)
parser.add_argument(“–img_size”, type=int, default=28, help=“size of each image dimension”)
parser.add_argument(“–channels”, type=int, default=1, help=“number of image channels”)
parser.add_argument(“–n_critic”, type=int, default=5, help=“number of training steps for discriminator per iter”)
parser.add_argument(“–clip_value”, type=float, default=0.01, help=“lower and upper clip value for disc. weights”)
parser.add_argument(“–sample_interval”, type=int, default=400, help=“interval betwen image samples”)
opt = parser.parse_args()

img_shape = (opt.channels, opt.img_size, opt.img_size)

cuda = True if torch.cuda.is_available() else False

train_dir = “D:/Code/python/GAN/PyTorch-GAN-master/data/Ottawa-test”


mean = [0.485, 0.456, 0.406]

std = [0.229, 0.224, 0.225]

train_augs = transforms.Compose([
# transforms.Normalize(img_shape)
train_set = datasets.ImageFolder(train_dir, transform=train_augs)

class Generator(nn.Module):
def init(self):
super(Generator, self).init()

    def block(in_feat, out_feat, normalize=True):
        layers = [nn.Linear(in_feat, out_feat)]
        if normalize:
            layers.append(nn.BatchNorm1d(out_feat, 0.8))
        layers.append(nn.LeakyReLU(0.2, inplace=True))
        return layers

    self.model = nn.Sequential(
        *block(opt.latent_dim, 128, normalize=False),
        *block(128, 256),
        *block(256, 512),
        *block(512, 1024),
        nn.Linear(1024, int(,

def forward(self, z):
    img = self.model(z)
    img = img.view(img.shape[0], *img_shape)
    return img

class Discriminator(nn.Module):
def init(self):
super(Discriminator, self).init()

    self.model = nn.Sequential(
        nn.Linear(int(, 512),
        nn.LeakyReLU(0.2, inplace=True),
        nn.Linear(512, 256),
        nn.LeakyReLU(0.2, inplace=True),
        nn.Linear(256, 1),

def forward(self, img):
    img_flat = img.view(img.shape[0], -1)
    validity = self.model(img_flat)
    return validity

Initialize generator and discriminator

generator = Generator()
discriminator = Discriminator()

if cuda:

batch_size = 32

Configure data loader

os.makedirs(“D:\Code\python\GAN\PyTorch-GAN-master\data\Ottawa-test”, exist_ok=True)

dataloader =
train_set, batch_size=batch_size, shuffle=True

mnist = input_data.read_data_sets(‘D:\Code\python\GAN\PyTorch-GAN-master\data\Ottawa-test’, one_hot=True)


optimizer_G = torch.optim.RMSprop(generator.parameters(),
optimizer_D = torch.optim.RMSprop(discriminator.parameters(),

Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor




batches_done = 0
for epoch in range(opt.n_epochs):

for i, (imgs, _) in enumerate(dataloader):

    # Configure input
    real_imgs = Variable(imgs.type(Tensor))

    # ---------------------
    #  Train Discriminator
    # ---------------------


    # Sample noise as generator input
    z = Variable(Tensor(np.random.normal(0, 1, (imgs.shape[0], opt.latent_dim))))

    # Generate a batch of images
    fake_imgs = generator(z).detach()
    # Adversarial loss
    loss_D = -torch.mean(discriminator(real_imgs)) + torch.mean(discriminator(fake_imgs))


    # Clip weights of discriminator
    for p in discriminator.parameters():, opt.clip_value)

    # Train the generator every n_critic iterations
    if i % opt.n_critic == 0:

        # -----------------
        #  Train Generator
        # -----------------


        # Generate a batch of images
        gen_imgs = generator(z)
        # Adversarial loss
        loss_G = -torch.mean(discriminator(gen_imgs))


            "[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]"
            % (epoch, opt.n_epochs, batches_done % len(dataloader), len(dataloader), loss_D.item(), loss_G.item())

    if batches_done % opt.sample_interval == 0:
        save_image([:25], "images/%d.png" % batches_done, nrow=5, normalize=True)
    batches_done += 1

The error is raised in a linear layer caused by a wrong number of features in the input tensor.
Your code is not easily readable as you did not format it properly by wrapping it into three backticks ```, so I’m unsure which layer exactly causes the error.
You could add debug print statements to your model’s forward method to check the activation shape in order to narrow down which layer is raising the error.