WGAN生成器损失函数使用时机及实现相关技术疑问

Great question—WGAN’s training loop is a bit different from standard GANs, so it’s totally reasonable to get confused about when the generator’s loss comes into play. Let’s start by confirming your existing understanding, then dive into the generator part.

Your Critic Training Understanding is Correct #

• You’re right that the critic (the WGAN version of the discriminator) first trains on real data batches, then on fake batches generated from noise.
• Its loss function is designed to maximize the Earth-Mover (EM) distance between the real and fake distributions, which translates to computing E[C(real)] - E[C(fake)] and maximizing that value (or equivalently minimizing E[C(fake)] - E[C(real)] as a loss term).
• Weight clipping is applied after each critic update to enforce the 1-Lipschitz constraint, which is critical for the WGAN theory to hold.

When the Generator’s Loss is Used #

The generator’s loss isn’t updated every time the critic is—it’s only calculated and applied after the critic has completed several rounds of training (the original WGAN paper recommends 5 critic updates per generator update, though this can vary based on your dataset).

Here’s why: WGAN relies on the critic being a good estimator of the EM distance before the generator tries to minimize that distance. If we update the generator too frequently, the critic hasn’t had enough time to learn to distinguish real vs. fake distributions properly, so the generator’s update direction will be unreliable.

In practice, here’s how this looks in Keras code (simplified):

# Setup optimizers (note the specific beta values from WGAN paper)
critic_opt = tf.keras.optimizers.Adam(learning_rate=5e-5, beta_1=0.0, beta_2=0.9)
gen_opt = tf.keras.optimizers.Adam(learning_rate=5e-5, beta_1=0.0, beta_2=0.9)

noise_dim = 100
batch_size = 64
critic_train_steps = 5  # 5 critic updates per generator update

for epoch in range(total_epochs):
    # Step 1: Train the critic multiple times
    for _ in range(critic_train_steps):
        # Get real data batch
        real_imgs = get_real_data_batch(batch_size)
        
        # Generate fake data (generator stays frozen here)
        noise = tf.random.normal(shape=(batch_size, noise_dim))
        fake_imgs = generator(noise, training=False)
        
        # Calculate critic loss
        with tf.GradientTape() as tape:
            real_score = critic(real_imgs, training=True)
            fake_score = critic(fake_imgs, training=True)
            critic_loss = tf.reduce_mean(fake_score) - tf.reduce_mean(real_score)
        
        # Update critic weights
        grads = tape.gradient(critic_loss, critic.trainable_variables)
        critic_opt.apply_gradients(zip(grads, critic.trainable_variables))
        
        # Clip weights to enforce 1-Lipschitz constraint
        for var in critic.trainable_variables:
            var.assign(tf.clip_by_value(var, -0.01, 0.01))
    
    # Step 2: Now train the generator once
    with tf.GradientTape() as tape:
        # Generate new fake data (generator is trainable here)
        noise = tf.random.normal(shape=(batch_size, noise_dim))
        fake_imgs = generator(noise, training=True)
        # Get critic's score for fake data (critic stays frozen here)
        fake_score = critic(fake_imgs, training=False)
        # Generator loss: minimize -E[C(fake)] (since we want to maximize E[C(fake)])
        gen_loss = -tf.reduce_mean(fake_score)
    
    # Update generator weights
    grads = tape.gradient(gen_loss, generator.trainable_variables)
    gen_opt.apply_gradients(zip(grads, generator.trainable_variables))

Key notes about the generator loss:

• Unlike standard GANs, there’s no cross-entropy here. The generator’s goal is to make the critic assign as high a score as possible to fake samples, which directly reduces the EM distance between real and fake distributions.
• The critic is frozen during generator training so we’re using its current best estimate of the distance to guide the generator’s updates.

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