如何使用GAN生成拉曼光谱的合成数据样本？

Question

我正在研究拉曼光谱数据集。拉曼光谱使用的波数/频率范围从 151.25 开始，到 1999.17 结束。这些值用于 x 轴。 y 轴上使用的振幅/强度范围为 100 到 1675。

我有一个名为“data_df”的数据框，由 62 行和 1871 列组成。这意味着我已经将 62 个数据样本存储在这个数据框“data_df”中。我已经完成了预处理并对其进行了归一化。

此数据帧的第 1 行到第 62 行的第一个整列包含类标签“D”。

每 62 行中从 2 到 936 的列具有与 x 轴上使用的相同的频率值。

此外，从第 937 列到第 1871 列的每 62 行都包含用于 y 轴的幅度值。每行和每列（从 937 到 1871）包含不同的幅度值。

这样，我们就有了总共 935 个频率值（每 62 行中相同）和 935 个幅度值（每 62 行中不同值）以及一列包含“D”作为标签的类标签。 [935+935+1 =1871 列]

我使用了以下网站上提供的 GAN 代码：https://machinelearningmastery.com/how-to-develop-a-conditional-generative-adversarial-network-from-scratch/

这个 GAN 代码用于生成合成图像，但我根据我之前提到的场景对其进行了修改。用于生成合成拉曼光谱的修改后的 GAN 代码如下

#Extracting relevant columns from the DataFrame
    frequency data = data_df.iloc[:, 1:936].values  # Frequency values (same for all data)
    amplitude_data = data_df.iloc[:, 936:].values   # Amplitude values

    Defining the standalone discriminator model**
    def define_discriminator(input_shape):
        model = Sequential()
        model.add(Conv1D(128, 3, strides=2, padding='same', input_shape=input_shape))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Conv1D(128, 3, strides=2, padding='same'))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Flatten())
        model.add(Dense(1, activation='sigmoid'))
    
    opt = Adam(lr=0.0002, beta_1=0.5)
    model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy'])
    
    return model

# Defining the standalone generator model
def define_generator(latent_dim, n_outputs):
    model = Sequential()
    model.add(Dense(128 * 7, input_dim=latent_dim))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Reshape((7, 128)))
    model.add(UpSampling1D(2))
    model.add(Conv1D(128, 3, padding='same'))
    model.add(LeakyReLU(alpha=0.2))
    model.add(UpSampling1D(2))
    model.add(Conv1D(128, 3, padding='same'))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Conv1D(n_outputs, 3, padding='same', activation='tanh'))
    
    return model

# Defining the combined generator and discriminator model
def define_gan(generator, discriminator):
    discriminator.trainable = False
    model = Sequential()
    model.add(generator)
    model.add(discriminator)
    opt = Adam(lr=0.0002, beta_1=0.5)
    model.compile(loss='binary_crossentropy', optimizer=opt)
    return model

# Loading real samples (frequency and amplitude data)
def load_real_samples():
    return frequency_data, amplitude_data

# Generate real samples (frequency and amplitude data)
def generate_real_samples(dataset, n_samples):
    ix = np.random.randint(0, dataset.shape[0], n_samples)
    X = dataset[ix]
    y = np.ones((n_samples, 1))
    return X, y

# Generate points in latent space as input for the generator
def generate_latent_points(latent_dim, n_samples):
    return randn(n_samples, latent_dim)

# Generate fake samples using the generator
def generate_fake_samples(generator, latent_dim, n_samples):
    x_input = generate_latent_points(latent_dim, n_samples)
    X = generator.predict(x_input)
    y = np.zeros((n_samples, 1))
    return X, y

# Train the GAN model
def train(g_model, d_model, gan_model, dataset, latent_dim, n_epochs=100, n_batch=64):
    bat_per_epo = int(dataset.shape[0] / n_batch)
    half_batch = int(n_batch / 2)
    
    for i in range(n_epochs):
        for j in range(bat_per_epo):
            X_real_freq, X_real_amplitude = generate_real_samples(dataset, half_batch)
            d_loss1, _ = d_model.train_on_batch(X_real_freq, X_real_amplitude)
            
            X_fake_freq, X_fake_amplitude = generate_fake_samples(g_model, latent_dim, half_batch)
            d_loss2, _ = d_model.train_on_batch(X_fake_freq, X_fake_amplitude)
            
            X_gan = generate_latent_points(latent_dim, n_batch)
            y_gan = np.ones((n_batch, 1))
            g_loss = gan_model.train_on_batch(X_gan, y_gan)
            
            print('>%d, %d/%d, d1=%.3f, d2=%.3f g=%.3f' % (i+1, j+1, bat_per_epo, d_loss1, d_loss2, g_loss))

# Size of the latent space
latent_dim = 100

# Create the discriminator
discriminator = define_discriminator((935, 1))

# Create the generator
generator = define_generator(latent_dim, 935)

# Create the GAN
gan_model = define_gan(generator, discriminator)

# Load real Raman Spectra data
dataset_freq, dataset_amplitude = load_real_samples()
dataset_freq = dataset_freq.reshape((-1, 935, 1))
dataset_amplitude = dataset_amplitude.reshape((-1, 935, 1))

# Train the GAN model
train(generator, discriminator, gan_model, dataset_freq, latent_dim)

我使用 jupyter 笔记本来实现。我收到了生成器输出与鉴别器输入的尺寸错误：

“dense_16”层的输入 0 与该层不兼容：输入形状的预期轴 -1 的值为 29952，但收到的输入形状为（无，896）

如何修复这个错误？

Answer 1

据我了解，问题出现在生成器定义的第二行。 “model.add(密集(128 * 7, input_dim=latent_dim))” 这明确给出了输入大小 128*7 = 896。 然后将其重塑为 (7,128)。然而，从 NN 的另一侧开始，在两次上采样和三次 Conv1D 操作之后，您希望 n_outputs = 935 的大小。有很多选项可以解决这个问题。更改步幅、填充或转换层中的过滤器数量。或者，在末尾添加一个全连接层。我强烈建议在每次操作后打印形状语句并调试神经网络的形状。