训练GAN模型时持续出现ValueError的问题求助

问题背景 #

训练基于128×128灰度图像的GAN时，反复触发维度不匹配的ValueError，错误发生在真实图像reshape步骤：

ValueError: cannot reshape array of size 1048576 into shape (64,28,28,1)

错误根源 #

1. 真实图像尺寸与硬编码不匹配：预处理后的图像是128×128单通道，但代码强行将其reshape为28×28，总元素数（64×128×128=1048576）远大于目标形状的元素数（64×28×28×1=50176），直接导致维度冲突。
2. 生成器输出尺寸不符：当前生成器的输出是28×28，和真实图像的128×128尺寸不一致，无法用于判别器的训练。
3. 判别器输入定义错误：判别器的输入形状被定义为(28,28,1)，无法接收128×128的真实图像。

修复步骤 #

1. 修正真实图像的reshape操作 #

将真实图像reshape为匹配预处理后的128×128单通道形状：

real_images = images[idx].reshape(batch_size, 128, 128, 1)

2. 重新设计生成器，输出128×128图像 #

调整生成器的全连接层输出、转置卷积层的步数和数量，通过4轮转置卷积将初始8×8的特征图逐步放大到128×128：

• 初始全连接层输出设为8×8×256，作为转置卷积的起始特征图
• 每轮转置卷积使用strides=2，将特征图尺寸翻倍

3. 调整判别器适配128×128输入 #

• 将判别器的输入形状改为(128,128,1)
• 添加多轮卷积层，逐步缩小128×128的输入特征图，最终输出判别结果

完整修正代码 #

import cv2
import numpy as np
import pandas as pd
import tensorflow as tf

# 读取标签CSV文件
labels_df = pd.read_csv('labels.csv')

# 图像预处理函数：转灰度、 resize、归一化
def preprocess_image(image, target_size):
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    resized_image = cv2.resize(gray_image, target_size)
    normalized_image = resized_image / 255.0
    return normalized_image

images = []
labels = []
target_size = (128, 128)

# 批量加载并预处理图像
for index, row in labels_df.iterrows():
    image_filename = row['image_filename']
    label = row['label']
    image = cv2.imread(image_filename)
    preprocessed_image = preprocess_image(image, target_size)
    images.append(preprocessed_image)
    labels.append(label)

# 转换为numpy数组并保存
images = np.array(images)
labels = np.array(labels)
np.save('preprocessed_images.npy', images)
np.save('labels.npy', labels)

# 加载预处理后的数据
images = np.load('preprocessed_images.npy')
labels = np.load('labels.npy')

generator_input_shape = 100

# 修正后的生成器：输出128×128单通道图像
generator = tf.keras.Sequential([
    tf.keras.layers.Dense(8 * 8 * 256, input_dim=generator_input_shape),
    tf.keras.layers.Reshape((8, 8, 256)),
    # 8×8 → 16×16
    tf.keras.layers.Conv2DTranspose(128, kernel_size=4, strides=2, padding='same'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.LeakyReLU(alpha=0.2),
    # 16×16 → 32×32
    tf.keras.layers.Conv2DTranspose(64, kernel_size=4, strides=2, padding='same'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.LeakyReLU(alpha=0.2),
    # 32×32 → 64×64
    tf.keras.layers.Conv2DTranspose(32, kernel_size=4, strides=2, padding='same'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.LeakyReLU(alpha=0.2),
    # 64×64 → 128×128
    tf.keras.layers.Conv2DTranspose(16, kernel_size=4, strides=2, padding='same'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.LeakyReLU(alpha=0.2),
    # 输出128×128×1的灰度图
    tf.keras.layers.Conv2D(1, kernel_size=7, activation='sigmoid', padding='same')
])

# 修正后的判别器：接收128×128单通道图像
discriminator = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, kernel_size=4, strides=2, input_shape=(128, 128, 1), padding='same'),
    tf.keras.layers.LeakyReLU(alpha=0.2),
    tf.keras.layers.Dropout(0.4),
    # 128×128 → 64×64
    tf.keras.layers.Conv2D(64, kernel_size=4, strides=2, padding='same'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.LeakyReLU(alpha=0.2),
    tf.keras.layers.Dropout(0.4),
    # 64×64 → 32×32
    tf.keras.layers.Conv2D(128, kernel_size=4, strides=2, padding='same'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.LeakyReLU(alpha=0.2),
    tf.keras.layers.Dropout(0.4),
    # 展平后输出判别结果
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

batch_size = 64
epochs = 10

# 定义真实/假图像的标签
real_labels = np.ones((batch_size, 1))
fake_labels = np.zeros((batch_size, 1))

# 构建GAN模型
gan = tf.keras.Sequential([generator, discriminator])

# 编译模型（注意：训练生成器时需冻结判别器）
discriminator.compile(loss='binary_crossentropy', optimizer=tf.keras.optimizers.Adam(learning_rate=0.0002, beta_1=0.5))
gan.compile(loss='binary_crossentropy', optimizer=tf.keras.optimizers.Adam(learning_rate=0.0002, beta_1=0.5))

# 训练循环
for epoch in range(epochs):
    # 随机选取真实图像批次
    idx = np.random.randint(0, images.shape[0], batch_size)
    # 修正reshape为128×128单通道
    real_images = images[idx].reshape(batch_size, 128, 128, 1)
    
    # 生成假图像
    noise = np.random.normal(0, 1, (batch_size, generator_input_shape))
    fake_images = generator.predict(noise, verbose=0)

    # 训练判别器
    d_loss_real = discriminator.train_on_batch(real_images, real_labels)
    d_loss_fake = discriminator.train_on_batch(fake_images, fake_labels)
    d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

    # 训练生成器（冻结判别器）
    discriminator.trainable = False
    noise = np.random.normal(0, 1, (batch_size, generator_input_shape))
    fool_labels = np.ones((batch_size, 1))
    g_loss = gan.train_on_batch(noise, fool_labels)
    discriminator.trainable = True

    # 打印训练进度
    print(f"Epoch {epoch+1}/{epochs} | Discriminator loss: {d_loss[0]:.4f} | Generator loss: {g_loss:.4f}")

# 打印模型结构
discriminator.summary()
generator.summary()

额外说明 #

• 训练生成器时需临时冻结判别器，避免判别器在生成器训练阶段更新参数，这是GAN训练的标准流程
• 调整了Adam优化器的参数写法（原lr已被弃用，改为learning_rate），避免版本兼容问题

内容的提问来源于stack exchange，提问作者Pratik Vairat