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

username: buffer_Jim
cooked: <p>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?</p>
<code>
import argparse
import os
import numpy as np
import math
import sys
<p>import torchvision.transforms as transforms<br>
from torchvision.utils import save_image</p>
<p>from torch.utils.data import DataLoader<br>
from torchvision import datasets<br>
from torch.autograd import Variable</p>
<p>import torch.nn as nn<br>
import torch.nn.functional as F<br>
import torch</p>
<h1>
<a name="osmakedirsimages-exist_oktrue-1" class="anchor" href="#osmakedirsimages-exist_oktrue-1"></a>os.makedirs(“images”, exist_ok=True)</h1>
<p>parser = argparse.ArgumentParser()<br>
parser.add_argument(“–n_epochs”, type=int, default=200, help=“number of epochs of training”)<br>
parser.add_argument(“–batch_size”, type=int, default=64, help=“size of the batches”)<br>
parser.add_argument(“–lr”, type=float, default=0.00005, help=“learning rate”)<br>
parser.add_argument(“–n_cpu”, type=int, default=8, help=“number of cpu threads to use during batch generation”)<br>
parser.add_argument(“–latent_dim”, type=int, default=100, help=“dimensionality of the latent space”)<br>
parser.add_argument(“–img_size”, type=int, default=28, help=“size of each image dimension”)<br>
parser.add_argument(“–channels”, type=int, default=1, help=“number of image channels”)<br>
parser.add_argument(“–n_critic”, type=int, default=5, help=“number of training steps for discriminator per iter”)<br>
parser.add_argument(“–clip_value”, type=float, default=0.01, help=“lower and upper clip value for disc. weights”)<br>
parser.add_argument(“–sample_interval”, type=int, default=400, help=“interval betwen image samples”)<br>
opt = parser.parse_args()<br>
print(opt)</p>
<p>img_shape = (opt.channels, opt.img_size, opt.img_size)</p>
<p>cuda = True if torch.cuda.is_available() else False</p>
<p>train_dir = “D:/Code/python/GAN/PyTorch-GAN-master/data/Ottawa-test”</p>
<h1>
<a name="h-224224-2" class="anchor" href="#h-224224-2"></a>将图像调整为224×224尺寸并归一化</h1>
<h1>
<a name="mean-0485-0456-0406-3" class="anchor" href="#mean-0485-0456-0406-3"></a>mean = [0.485, 0.456, 0.406]</h1>
<h1>
<a name="std-0229-0224-0225-4" class="anchor" href="#std-0229-0224-0225-4"></a>std = [0.229, 0.224, 0.225]</h1>
<p>train_augs = transforms.Compose([<br>
transforms.RandomResizedCrop(size=224),<br>
transforms.RandomHorizontalFlip(),<br>
transforms.ToTensor(),<br>
# transforms.Normalize(img_shape)<br>
])<br>
train_set = datasets.ImageFolder(train_dir, transform=train_augs)</p>
<p>class Generator(nn.Module):<br>
def <strong>init</strong>(self):<br>
super(Generator, self).<strong>init</strong>()</p>
<pre><code>    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(np.prod(img_shape))),
        nn.Tanh()
    )

def forward(self, z):
    img = self.model(z)
    img = img.view(img.shape[0], *img_shape)
    return img
</code></pre>
<p>class Discriminator(nn.Module):<br>
def <strong>init</strong>(self):<br>
super(Discriminator, self).<strong>init</strong>()</p>
<pre><code>    self.model = nn.Sequential(
        nn.Linear(int(np.prod(img_shape)), 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
</code></pre>
<h1>
<a name="initialize-generator-and-discriminator-5" class="anchor" href="#initialize-generator-and-discriminator-5"></a>Initialize generator and discriminator</h1>
<p>generator = Generator()<br>
discriminator = Discriminator()</p>
<p>if cuda:<br>
generator.cuda()<br>
discriminator.cuda()</p>
<p>batch_size = 32</p>
<h1>
<a name="configure-data-loader-6" class="anchor" href="#configure-data-loader-6"></a>Configure data loader</h1>
<h1>
<a name="osmakedirsdcodepythonganpytorch-gan-masterdataottawa-test-exist_oktrue-7" class="anchor" href="#osmakedirsdcodepythonganpytorch-gan-masterdataottawa-test-exist_oktrue-7"></a>os.makedirs(“D:\Code\python\GAN\PyTorch-GAN-master\data\Ottawa-test”, exist_ok=True)</h1>
<p>dataloader = torch.utils.data.DataLoader(<br>
train_set, batch_size=batch_size, shuffle=True<br>
)</p>
<h1>
<a name="mnist-input_dataread_data_setsdcodepythonganpytorch-gan-masterdataottawa-test-one_hottrue-8" class="anchor" href="#mnist-input_dataread_data_setsdcodepythonganpytorch-gan-masterdataottawa-test-one_hottrue-8"></a>mnist = input_data.read_data_sets(‘D:\Code\python\GAN\PyTorch-GAN-master\data\Ottawa-test’, one_hot=True)</h1>
<h1>
<a name="optimizers-9" class="anchor" href="#optimizers-9"></a>Optimizers</h1>
<p>optimizer_G = torch.optim.RMSprop(generator.parameters(), lr=opt.lr)<br>
optimizer_D = torch.optim.RMSprop(discriminator.parameters(), lr=opt.lr)</p>
<p>Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor</p>
<h1>
<a name="h-10" class="anchor" href="#h-10"></a>----------</h1>
<h1>
<a name="training-11" class="anchor" href="#training-11"></a>Training</h1>
<h1>
<a name="h-12" class="anchor" href="#h-12"></a>----------</h1>
<p>batches_done = 0<br>
for epoch in range(opt.n_epochs):</p>
<pre><code>for i, (imgs, _) in enumerate(dataloader):

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

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

    optimizer_D.zero_grad()

    # 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))

    loss_D.backward()
    optimizer_D.step()

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

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

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

        optimizer_G.zero_grad()

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

        loss_G.backward()
        optimizer_G.step()

        print(
            "[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(gen_imgs.data[:25], "images/%d.png" % batches_done, nrow=5, normalize=True)
    batches_done += 1
</code></pre>
</code>

username: ptrblck
cooked: <p>The error is raised in a linear layer caused by a wrong number of features in the input tensor.<br>
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.<br>
You could add debug <code>print</code> statements to your model’s <code>forward</code> method to check the activation shape in order to narrow down which layer is raising the error.</p>