Why does decoding a random point in a plain autoencoder's 16-D code space give an off-manifold artefact?

## What the objective actually constrains A plain autoencoder minimises reconstruction error over the training set. Write the code for example `i` as `z_i = f(x_i)`. The loss touches the decoder `g` only at those points `z_1 ... z_N` — a finite set in a 16-dimensional space. At every other point, the decoder's output has no gradient signal at all during training. Whatever it does there is a byproduct of the function class and of optimisation, not of anything you asked for. This is the whole answer to the question, but interviews want the two consequences spelled out. ## Consequence one: the codes have no distribution Nothing in the objective says where codes should go. Any invertible reshuffling of the code space that the decoder can undo is free: multiply all codes by 100, shift them, rotate them, stretch one axis — reconstruction is unchanged as long as the decoder compensates. So the aggregate distribution of codes is arbitrary in scale and shape, and in practice it is lumpy: examples of the same kind get mapped near each other, forming islands, with wide unallocated gaps in between and unbounded empty space around the whole cloud. That means there is no distribution you can sample from. Even if you wanted to draw 'a typical code', you have no idea what typical means here — a standard normal draw in 16 dimensions might sit at a completely wrong radius from where the real codes live. And high dimensionality makes this much worse than the two-dimensional pictures suggest: the occupied islands are a vanishingly small fraction of the volume, so a blind draw essentially never lands on one. ## Consequence two: the decoder extrapolates Even if you drew a point in the right general region, if it falls in a gap between islands the decoder has never been asked what to output there. A neural decoder is smooth-ish but not principled: in a hole it produces some blend or extension of the behaviours it learned nearby, which typically shows up as a superposition of two data modes, a ghosted or smeared output, or a structurally impossible example. This is why straight-line interpolation between two valid codes often works partway and then falls apart in the middle: the segment leaves the occupied region. ## What this leaf's regularizers do and do not fix A denoising objective helps a little and incidentally. Because the encoder sees many corrupted versions of each example, the codes it produces for one example form a small blob rather than a single point, and the decoder gets trained over that blob. That thickens the occupied set slightly around each training code — but it does not connect the islands, does not tell you the overall scale, and does not give you a density to sample from. A sparsity penalty makes things worse, if anything. It concentrates codes onto a union of low-dimensional faces — the sets where only a few coordinates are non-zero — so the occupied region becomes even thinner relative to the ambient space, and the gaps larger. A contractive penalty likewise shapes local sensitivity of the encoder; it says nothing about the aggregate code distribution. ## What genuinely addresses it There are two honest routes and it is worth knowing both. The practical, post-hoc route: run the encoder over the training set, collect the codes, and fit a density model to that cloud — a Gaussian, a mixture, a nearest-neighbour or kernel estimate. Sample from the fitted density instead of from thin air. This works to the extent your density model matches the real code cloud, and it can still put mass in holes, but it at least gets scale and gross shape right and is cheap to try on a model you already trained. The principled route: make the code's distribution part of the training objective rather than an afterthought, so that the aggregate code distribution matches something you can draw from by construction. That is exactly the step from an autoencoder to a probabilistic latent-variable generative model, and it is what the model family in that neighbourhood exists to provide. ## How to say this in an interview The compact version: 'A plain autoencoder is trained for reconstruction, not for generation. The loss pins the decoder only at the encoder's outputs on training data, and nothing pins the distribution of those outputs. So the code space is a set of occupied islands of arbitrary scale surrounded by regions the decoder has never been asked about, and a random draw lands in one of those regions.' Then add the diagnostic you would actually run: encode the training set, look at the per-dimension ranges and the pairwise structure of the codes, and check whether interpolations between pairs stay valid. If they break in the middle, you have found your holes.