Why is a GAN's discriminator never trained to convergence between generator updates?

## The gap between the notation and the algorithm `min_G max_D V(D, G)` reads like a nested optimization: for each candidate generator, solve the inner maximization, then take a step on the outer one. That is not what any GAN training loop does. The standard loop is: 1. Take k gradient steps on the discriminator, each on a fresh batch of real samples and a fresh batch of generated ones, holding the generator's parameters fixed. 2. Take one gradient step on the generator, holding the discriminator's parameters fixed. 3. Repeat. The original formulation used exactly this alternating scheme with a small k, and reported experiments at k = 1. The inner maximization is therefore approximated by a handful of steps that never converge, and the discriminator is always chasing a generator that keeps moving. ## Reason one: cost Each inner solve would need many passes over data before the discriminator settled, and you would need one such solve per generator update. The generator typically needs tens or hundreds of thousands of updates. The nested version is simply not affordable, and since the generator only moves a little between updates, most of that work would be re-derived from scratch to reach an answer barely different from the last one. Warm-starting from the previous discriminator is exactly what the alternating loop already does — the k steps are the continuation of an optimization that never restarts. ## Reason two: a converged discriminator overfits The theory's `D*(x) = p_data(x)/(p_data(x) + p_g(x))` is defined over *distributions*. Your discriminator sees a finite training set. Given enough capacity and enough steps, the best thing it can do on that empirical objective is memorize: output near 1 on the specific training points and near 0 everywhere else, including on regions where the true data density is high but no training sample happens to land. That function is a perfect classifier of the sample and a useless estimate of the density ratio, and the generator that chases it is being pushed toward the training points themselves rather than toward the distribution they came from. ## Reason three: a perfect judge gives no gradient This is the one that bites in practice. The generator learns only through the discriminator, and the amount of signal it receives depends on the discriminator's confidence. As the discriminator approaches a perfect separator, its output saturates on generated samples, and the gradient reaching the generator shrinks toward zero. Push the inner maximization all the way and you can arrive at a state where the discriminator is right about everything and the generator has stopped learning — technically the correct inner solution, practically a dead run. So the discriminator is deliberately kept in a middle band: ahead of the generator, since a discriminator that lags gives noisy or misleading feedback and lets the generator drift toward whatever the current weak judge happens to dislike, but never finished. ## Choosing k - **k = 1** is the common default: cheapest, and it keeps the two players moving on similar timescales. - **Larger k (say 5)** is chosen when the discriminator is visibly underfitting the current generator — its accuracy on freshly generated samples sits near chance — so each generator step is guided by a more accurate estimate of the ratio, at roughly k times the discriminator's cost per generator update. - The symptom of **k too large** is the stall described above: the discriminator separates the batches almost perfectly, and the gradient reaching the generator collapses. - The symptom of **k too small** is a generator that exploits a judge which has not caught up, moving in directions that stop helping as soon as the discriminator does catch up. Step count is not the only knob. Giving the two players different learning rates achieves a similar asymmetry without duplicating batches — a two-timescale schedule where the discriminator moves faster is a published and widely used alternative. Capacity is a third: a discriminator much larger than the generator behaves like a large k even at k = 1. ## Why none of this converges the way an ordinary loss does Alternating gradient steps on two coupled objectives is not gradient descent on any single scalar function. There is no quantity guaranteed to decrease each iteration, and the parameter pair can orbit an equilibrium rather than approach it — an effect familiar from simple two-player games where each player's best response keeps chasing the other's last move. Tuning the update ratio is partly an attempt to damp exactly this circling, which is why the answer is a band to stay inside rather than a single correct number. ## Interview framing Say the notation implies a nested solve, say the algorithm does something else, and give the three reasons: cost, overfitting on a finite sample, and vanishing generator signal from a saturated judge. Then name the knobs — step ratio, learning-rate asymmetry, relative capacity — and describe how you would tell which direction to move.