While metrics like Fréchet Inception Distance (FID) and Inception Score (IS) provide valuable insights into the overall quality and diversity of generated samples compared to a real dataset, they don't tell the whole story about the generator's behavior. Specifically, they don't directly assess the smoothness or interpretability of the GAN's latent space. Imagine you want to interpolate between two generated faces or edit a specific attribute; a well-behaved latent space should allow for smooth, gradual changes in the output image as you move through the latent space. Abrupt, nonsensical changes indicate a poorly structured or "entangled" latent space. This is where the Perceptual Path Length (PPL) metric comes in, offering a way to quantify this smoothness. It was introduced alongside StyleGAN but is applicable to other GAN architectures.

PPL measures how much the generated image changes perceptually for a small step taken in the latent space. The core idea is that if the latent space is well-structured and disentangled, a small perturbation to a latent vector should result in only a small, semantically meaningful change in the corresponding output image. Conversely, if a tiny step in the latent space causes a large, jarring visual change, it suggests the latent space hasn't effectively learned to map continuous variations in the input noise to continuous variations in the perceptual features of the output image.

Calculating Perceptual Path Length

To calculate PPL, we simulate moving through the latent space and measure the perceptual distance between the images generated at infinitesimally close points along that path. Here's a breakdown of the process:

Sample Latent Vectors: Randomly sample two latent vectors, $z_1$ and $z_2$ , from the GAN's prior distribution $P(z)$ (typically a standard Gaussian).
Interpolate: Define a path between these points. While linear interpolation ( $lerp$ ) can be used, spherical linear interpolation ( $slerp$ ) is often preferred, especially if latent vectors are normalized: $z(t) = slerp(z_1, z_2, t) \quad \text{for} \quad t \in [0, 1]$ Here, $t$ parameterizes the position along the path.
Generate Images at Close Points: Generate images for two points that are infinitesimally close on this path, say at $t$ and $t + \epsilon$ , where $\epsilon$ is a very small step size. Let these images be $G(z(t))$ and $G(z(t + \epsilon))$ .
Measure Perceptual Distance: Calculate the distance between these two images using a perceptual distance metric, denoted as $d(\cdot, \cdot)$ . This metric should align with human perception of image similarity. Common choices include metrics based on deep network features, such as LPIPS (Learned Perceptual Image Patch Similarity), which often uses activations from networks like VGG-16 or AlexNet. Simple pixel-wise distances like L1 or L2 are generally insufficient as they don't capture perceptual similarity well.
Average Over Path Segments: The instantaneous perceptual change for a step $\epsilon$ at position $t$ is approximated by $d(G(z(t)), G(z(t + \epsilon)))$ . PPL aims to find the expected value of this change, normalized by the step size. More formally, it's defined as the expectation over all possible endpoints ( $z_1, z_2$ ) and all positions ( $t$ ) along the paths: $\text{PPL} = \mathbb{E}_{z_1, z_2 \sim P(z), t \sim U(0, 1)} \left[ \frac{1}{\epsilon^2} d(G(slerp(z_1, z_2, t)), G(slerp(z_1, z_2, t + \epsilon))) \right]$ The division by $\epsilon^2$ arises from the definition involving Jacobian calculations in the original paper, but practically, the average distance over small fixed steps $\epsilon$ is computed.

In practice, the expectation is approximated by averaging over many randomly sampled pairs $(z_1, z_2)$ and dividing the path between them into small, fixed steps of size $\epsilon$ . The perceptual distance $d$ is computed between images generated at consecutive steps, and these distances are averaged.

Interpretation of PPL Scores

Low PPL: Indicates a smoother latent space. Small steps in the latent space consistently result in small perceptual changes in the generated image. This is desirable, suggesting better disentanglement and making the model more suitable for tasks like image editing or style mixing via latent space manipulation.
High PPL: Suggests that the latent space is "choppy" or entangled. Small movements can lead to large, often non-semantic shifts in the image, making smooth interpolations difficult.

PPL in Z-Space vs. W-Space (StyleGAN)

For architectures like StyleGAN that employ a mapping network to transform the initial latent code $z$ (from the prior $P(z)$ ) into an intermediate latent code $w \in W$ , PPL can be calculated in either space:

$PPL_Z$ : Interpolation and steps are performed in the initial $Z$ space.
$PPL_W$ : Interpolation and steps are performed in the intermediate $W$ space (after the mapping network).

The $W$ space in StyleGAN is intentionally designed to be more disentangled than the $Z$ space. Therefore, interpolation in $W$ typically yields much smoother visual transitions. Consequently, $PPL_W$ (PPL calculated using paths in the $W$ space) usually gives significantly lower (better) scores than $PPL_Z$ and is the more commonly reported metric for evaluating the effectiveness of the mapping network and the overall smoothness of the learned synthesis process.

This diagram contrasts low and high PPL. With low PPL, moving a small distance along a path in the latent space (Z or W) results in a correspondingly small, smooth change in the generated image's perceptual features. High PPL indicates that similar small steps can cause large, discontinuous jumps in the perceived appearance.

Practical Considerations

Calculating PPL is computationally more demanding than FID or IS. It involves generating numerous images along multiple interpolation paths and repeatedly computing pairwise perceptual distances using another deep network. The choice of the perceptual distance function (e.g., specific layers in VGG or LPIPS variants) and the sampling parameters (number of paths, step size $\epsilon$ ) can influence the absolute PPL score, so consistency in these settings is important when comparing different models.

PPL serves as a complementary metric to FID and IS. While FID assesses the overall match between the distributions of real and generated images, PPL specifically probes the internal structure and continuity of the generator's latent space mapping. A GAN might achieve a good FID score by capturing the diversity of the target data but could still have a high PPL if its latent space lacks smooth transitions, hindering its usability for fine-grained control and editing. Therefore, considering PPL alongside other metrics provides a more complete picture of a GAN's performance, particularly regarding the quality and usability of its latent space.

Was this section helpful?