我正在研究拉曼光谱数据集。拉曼光谱使用的波数/频率范围从151.25开始到1999.17结束。这些值用于x轴。而振幅/强度范围从100到1675用于y轴。
我有一个名为“data_df”的数据框，它包含62行和1871列。这意味着我已经在这个数据框“data_df”中存储了我的62个数据样本。我已经完成了预处理，并对它进行了规范化。
该 Dataframe 的从第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）
如何修复此错误？