Python 检查输入时出错：预期输入_49具有形状（512、512、1），但获得具有形状（28、28、1）的数组

我正在使用一个模型，该模型采用MNIST数据集并生成输出，但我想将我自己的数据集提供给该模型，数据集中的图像大小为（512x512），但该模型采用大小为（28x28）的图像。现在，当我将数据集图像转换为（28x28）模型时，效果很好，但我必须以512x512的大小输入图像。有人能帮我解决这个问题吗。 我也在这里分享完整的代码。您可以在（加载数据集）上看到，我正在加载自己的数据集并将其转换为28x28，但实际上我想加载大小为512x512的图像

class DCGAN():
def init(self):
# Input shape
self.img_rows = 28
self.img_cols = 28
self.channels = 1
self.img_shape = (self.img_rows, self.img_cols, self.channels)
self.latent_dim = 100

    optimizer = Adam(0.0002, 0.5)

    # Build and compile the discriminator
    self.discriminator = self.build_discriminator()
    self.discriminator.compile(loss='binary_crossentropy',
        optimizer=optimizer,
        metrics=['accuracy'])

    # Build the generator
    self.generator = self.build_generator()

    # The generator takes noise as input and generates imgs
    z = Input(shape=(self.latent_dim,))
    img = self.generator(z)

    # For the combined model we will only train the generator
    self.discriminator.trainable = False

    # The discriminator takes generated images as input and determines validity
    valid = self.discriminator(img)

    # The combined model  (stacked generator and discriminator)
    # Trains the generator to fool the discriminator
    self.combined = Model(z, valid)
    self.combined.compile(loss='binary_crossentropy', optimizer=optimizer)

def build_generator(self):

    model = Sequential()

    model.add(Dense(128 * 7 * 7, activation="relu", input_dim=self.latent_dim))
    model.add(Reshape((7, 7, 128)))
    model.add(UpSampling2D())
    model.add(Conv2D(128, kernel_size=3, padding="same"))
    model.add(BatchNormalization(momentum=0.8))
    model.add(Activation("relu"))
    model.add(UpSampling2D())
    model.add(Conv2D(64, kernel_size=3, padding="same"))
    model.add(BatchNormalization(momentum=0.8))
    model.add(Activation("relu"))
    model.add(Conv2D(self.channels, kernel_size=3, padding="same"))
    model.add(Activation("tanh"))

    model.summary()

    noise = Input(shape=(self.latent_dim,))
    img = model(noise)

    return Model(noise, img)

def build_discriminator(self):

    model = Sequential()

    model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=self.img_shape, padding="same"))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))
    model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
    model.add(ZeroPadding2D(padding=((0,1),(0,1))))
    model.add(BatchNormalization(momentum=0.8))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))
    model.add(Conv2D(128, kernel_size=3, strides=2, padding="same"))
    model.add(BatchNormalization(momentum=0.8))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))
    model.add(Conv2D(256, kernel_size=3, strides=1, padding="same"))
    model.add(BatchNormalization(momentum=0.8))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.25))
    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))

    model.summary()

    img = Input(shape=self.img_shape)
    validity = model(img)

    return Model(img, validity)

def train(self, epochs, batch_size=128, save_interval=50):

    # Load the dataset
    #(X_train, _), (_, _) = mnist.load_data()
    files_name = os.listdir('./Dataset/Train')
    train_x = []
    #train_y = []
    for _,i in enumerate(files_name):
      train_x.append(cv2.imread(os.path.join('./Dataset/Train',i),0))
    train_x = np.asarray(train_x).reshape(-1, 512,512, 1)

    train_x_28 = []
    for i in range(len(train_x)):
      train_x_28.append(cv2.resize(train_x[i], (28, 28)))

    X_train = np.asarray(train_x_28).reshape(-1, 28,28)

    # Rescale -1 to 1
    X_train = X_train / 127.5 - 1.
    X_train = np.expand_dims(X_train, axis=3)

    # Adversarial ground truths
    valid = np.ones((batch_size, 1))
    fake = np.zeros((batch_size, 1))

    for epoch in range(epochs):

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

        # Select a random half of images
        idx = np.random.randint(0, X_train.shape[0], batch_size)
        imgs = X_train[idx]

        # Sample noise and generate a batch of new images
        noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
        gen_imgs = self.generator.predict(noise)

        # Train the discriminator (real classified as ones and generated as zeros)
        d_loss_real = self.discriminator.train_on_batch(imgs, valid)
        d_loss_fake = self.discriminator.train_on_batch(gen_imgs, fake)
        d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

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

        # Train the generator (wants discriminator to mistake images as real)
        g_loss = self.combined.train_on_batch(noise, valid)

        # Plot the progress
        print ("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss))

        # If at save interval => save generated image samples
        if epoch % save_interval == 0:
            self.save_imgs(epoch)

def save_imgs(self, epoch):
    r, c = 2, 2
    noise = np.random.normal(0, 1, (r * c, self.latent_dim))
    gen_imgs = self.generator.predict(noise)

    # Rescale images 0 - 1
    gen_imgs = 0.5 * gen_imgs + 0.5

    fig, axs = plt.subplots(r, c)
    cnt = 0
    for i in range(r):
        for j in range(c):
            axs[i,j].imshow(gen_imgs[cnt, :,:,0], cmap='gray')
            axs[i,j].axis('off')
            cnt += 1
    fig.savefig("dcgan/images/mnist_%d.png" % epoch) 
    plt.close()
if name == 'main':
dcgan = DCGAN()
dcgan.train(epochs=4000, batch_size=32, save_interval=50)

---

检查输入时出错：预期输入_49具有形状（512、512、1），但获得具有形状（28、28、1）的数组。

您需要修改生成器以生成与数据集大小相同的图像。如果您只是想要运行的东西，您可以继续重复您的放大块：

model.add（UpSampling2D（））
添加（Conv2D（num\u过滤器，kernel\u size=3，padding=“same”））
模型添加（批量标准化（动量=0.8））
添加（激活（“relu”））

典型的网络会将每个向上采样的过滤器数量减半。这使每个分辨率的操作数保持不变（尽管每个层的内存需求增加了一倍）

---

你走得越深，麻烦就越多。您可能需要增加潜在尺寸标注的大小，或在初始“稠密/重塑”中使用的过滤器的数量。如何做好这一点是一个开放的研究问题。

那么我该如何做呢？我的意思是，我可以缩小数据集中图像的大小，但我仍然需要比28更大的图像。那么，我该如何修改我的生成器呢？投入研究，阅读论文，花上几年的时间辛苦工作。简言之，这很难。我添加了一个部分，介绍如何以这样的方式运行它。你最终会遇到麻烦-我猜在你达到512 x 512之前就已经很好了-但是在事情变得糟糕之前，你可能会得到一些分辨率的提升。