A Causal Fix for Shortcut Learning in Retinal AI Models

The shortcut problem hiding inside medical imaging datasets

Retinal fundus photographs are one of the more quietly useful tools in modern medicine. A single photograph of the back of the eye, taken through the pupil with no incision and no injection, can reveal signs of diabetic retinopathy, but recent deep learning research has also pulled cardiovascular risk factors and even neurological disorder signals out of the same images. That versatility is exactly why the images are attractive training data, and exactly why the confounding problem this paper addresses matters so much.

Large fundus image collections are almost never gathered under laboratory conditions. They come from routine clinical screening across many sites, different camera manufacturers, different lighting setups, different levels of pupil dilation, and different patient populations. None of that variation is random. A particular hospital tends to use a particular camera. A particular hospital also tends to treat a particular patient population, shaped by geography, referral patterns, and insurance networks. The paper’s own illustrative example lays this out plainly. Imagine a dataset assembled from two hospitals using cameras from different manufacturers, where camera A produces images with a noticeably different hue than camera B, and the first hospital happens to treat predominantly Latin American patients while the second treats predominantly Caucasian patients. A deep learning model asked to predict ethnicity from these images has an easy way out. It can key off the hue difference between cameras rather than learning anything about the actual phenotypic features tied to ethnicity.

This pattern has a name in the machine learning literature, shortcut learning, described in foundational work the authors cite from Geirhos and colleagues. A model exploiting a shortcut can score very well on a held out test set drawn from the same hospitals and cameras, then fail unpredictably the moment it sees a new clinic with different equipment. Worse, if researchers try to interpret the model’s internal representations to understand what drives its predictions, a shortcut riddled latent space produces a plausible looking but false story about the underlying medicine.

A causal way of framing the problem

Rather than treating this purely as a statistics cleanup task, the Tübingen team frames it through a small causal graph. Three variables drive how a fundus image gets generated in their simplified model, patient attribute B such as age or ethnicity, camera C, and a catch all style variable D that absorbs everything else needed to produce a realistic image but that is not tied to specific content labels. Sitting above all three is an unknown confounder A representing the messy real world processes, hospital assignment, geography, equipment purchasing decisions, that create statistical association between B, C, and D even though none of these three variables directly cause one another.

In an ideal world you would address the confounder directly through controlled experiments, deliberately varying camera assignment independent of patient population and observing the result. That kind of intervention is not remotely feasible with retrospective clinical data collected during routine care. So the team’s strategy is to work around the confounder rather than eliminate it, by forcing the causal variables B, C, and D to be encoded into statistically independent regions of a learned latent space even though the raw data itself carries their spurious association.

Building a population model that separates biology from equipment

The technical heart of the paper is what the authors call a population model, a generative system trained not just to produce realistic fundus images but to organize its internal representation into clean, separable subspaces. Two versions get built and tested. A simpler predictive encoder model first, to prove the core disentanglement idea works, then a full generative image model layered on top for controllable, high resolution image synthesis.

Step one, an encoder that learns where to put information

The encoder model starts from a straightforward premise. Take a neural network \( f_\theta \) that maps a fundus image to a feature vector \( w \), then split that vector into subspaces, one per attribute of interest, and attach a small linear classifier to each subspace. If a subspace \( w_k \) genuinely encodes a given factor of variation, a linear classifier trained on top of it should be able to recover that factor. The encoder is a ResNet-18 trained from scratch, and optimizing it to route information into the right subspaces is equivalent to minimizing a cross entropy loss across all the classification heads at once.

On its own, this setup has an obvious hole. Nothing stops information from leaking across subspaces. A classifier attached to the age subspace could still learn to decode camera type if camera information happens to sit inside that subspace too, because the cross entropy loss above never penalizes shared information between \( w_1 \) and \( w_2 \). That gap is exactly what the paper’s second contribution addresses.

The disentanglement loss, built on distance correlation

To force subspaces apart, the authors add a second loss term that directly penalizes statistical dependence between every pair of subspaces, measured with distance correlation, a dependence measure introduced by Székely and colleagues in 2007. Distance correlation has a property that makes it well suited to this job. Unlike ordinary Pearson correlation, which only catches straight line relationships, distance correlation captures both linear and nonlinear dependence between two random vectors of any dimension, and it equals exactly zero if and only if the two vectors are truly statistically independent.

Computing distance correlation itself involves building a full pairwise Euclidean distance matrix across a batch of samples for each subspace, double centering it, and comparing the resulting distance covariances between the two subspaces against each subspace’s distance covariance with itself. That is more computationally involved than a simple correlation coefficient, but it is far cheaper than trying to estimate mutual information directly, which the paper notes remains a genuinely hard problem in high dimensional spaces, with most available estimators only providing loose lower bounds that are not even usable for a minimization objective like this one.

Step two, turning the encoder into a full image generator

Proving disentanglement works inside a classification style encoder is a useful first step, but the more ambitious half of the paper extends the idea into a full generative model capable of producing convincing new fundus images and reconstructing real ones. For this the team chose StyleGAN2, described in the paper as a state of the art generative adversarial network for high fidelity, high resolution image synthesis. StyleGAN2 has two structural features that make it a natural fit for disentanglement work. It routes latent codes through a mapping network into an intermediate space that then controls styles at each layer of the generator through adaptive instance normalization, and it generates images at progressively finer scales, which gives coarse and fine image details separate points of control.

Because GANs are not built with an encoder by default, the team extended the discriminator itself to double as an encoder, a GAN inversion technique inspired by prior work called invGAN. Three inversion related losses keep this honest. A latent reconstruction loss checks that an encoded and then regenerated latent code matches the original. A pixel space reconstruction loss, computed using the discriminator’s own internal features as a learned distance function, checks that a real image and its reconstruction actually look alike, and because this loss runs the generator twice it doubles as a cycle consistency check. On top of the standard StyleGAN2 architecture, the researchers added a third subspace beyond patient attribute and camera, a content agnostic style subspace with no dedicated classification head, whose only job is to absorb whatever remaining visual information the model needs to reconstruct a convincing image while staying independent of the labeled subspaces.

The full training objective folds all of this together. The generator is optimized against the standard adversarial GAN loss plus the inversion losses. The discriminator, playing double duty as an encoder, is optimized against the adversarial loss, the same inversion losses, the classification losses for the labeled subspaces, and the distance correlation penalty across all subspace pairs. Getting that many competing objectives to cooperate rather than collapse into each other is, by the authors’ own account in the discussion section, one of the harder practical challenges in the whole project, and over-weighting the disentanglement term specifically was found to wreck both the encoding and the generation quality if pushed too far.

The data behind the model

All of this was trained on retinal fundus images provided by EyePACS, described in the paper as an adaptable telemedicine system for diabetic retinopathy screening based in California. After filtering down to healthy images with no reported eye disease and a quality label of good or excellent, the researchers ended up with 75,989 macula centered fundus images from 24,336 individual patients, split by patient identity into 60 percent training, 20 percent validation, and 20 percent test sets so that no single patient’s images crossed between splits.

Images came with real metadata the team used as ground truth labels, age grouped into three classes, ethnicity across seven categories, and camera model, which included some duplicate manufacturer naming that the team consolidated down to 14 distinct camera classes. The ethnicity distribution in this dataset skews heavily toward one group, with Latin American patients making up roughly 71 percent of the cohort, a figure the authors point to directly when explaining why ethnicity decoding accuracy stayed comparatively low even for the dedicated ethnicity subspace. Before training, every image was cropped to a tightly centered circle, resized to 256 by 256 pixels, masked to a uniform visible area to remove inconsistent black borders, and horizontally flipped as needed so every optic disc sat on the left side of the frame, a set of preprocessing steps designed to strip out easy visual shortcuts that had nothing to do with genuine biological or technical variation.

Did the disentanglement actually work

To judge success, the authors built a predictor based disentanglement metric using a k nearest neighbor classifier with k equal to 30, generating a confusion matrix between each subspace and each available label. A well disentangled model should show high classification accuracy along the diagonal, meaning each subspace strongly predicts its intended attribute, and low accuracy off the diagonal, meaning no subspace leaks information about an attribute it was not meant to carry.

In the age and camera encoder experiment, the baseline model without the distance correlation loss showed real entanglement. Camera type could be decoded from the age subspace with an accuracy improvement of 28 percent above chance, nearly as strong as the 45 percent improvement achieved from the dedicated camera subspace, meaning the age subspace was quietly carrying a lot of camera information it had no business holding. After adding the distance correlation loss, that cross subspace leak dropped sharply while the legitimate within-subspace accuracy for age stayed essentially unchanged, evidence that the disentanglement loss was removing shared information rather than just degrading the whole representation.

The ethnicity and camera experiment told a more complicated story. In the baseline model, camera type could already be decoded from the ethnicity subspace with a 44 percent accuracy improvement, almost matching the 47 percent achieved in the dedicated camera subspace, while ethnicity decoding itself only reached a marginal 9 percent improvement in its own subspace and 8 percent from the camera subspace, a result the authors attribute in part to the class imbalance from that 71 percent Latin American majority. After the disentanglement loss was applied, cross subspace camera leakage from the ethnicity subspace dropped meaningfully, though it did not fall anywhere near zero, and a t-SNE visualization of the learned representation revealed a specific stubborn pattern, Indian patients in the dataset clustered together with images from the Canon CR-2 AF camera even after disentanglement was applied. That is not a failure of the algorithm so much as an honest reflection of a real correlation baked into the underlying data that no amount of representation learning can fully invent its way around.

That table matters because it answers a question a skeptical reader would reasonably ask right away. Does forcing a generative model to disentangle its subspaces come at the cost of image quality. Based on Frechet Inception Distance, a standard measure of how closely generated images match the statistical distribution of real ones where lower is better, the answer here is no. Every configuration lands in a tight range between 11 and 14, and the disentangled models are not systematically worse than their baselines. If anything, the age camera configuration with the full disentanglement loss produced the best FID score of the group.

Proving the subspaces actually control image content

Numbers on a confusion matrix are convincing, but the paper’s more intuitive evidence comes from directly manipulating the model. The researchers took real patient images, encoded them into the disentangled latent space, then swapped individual subspaces between different patients’ encodings before decoding the result back into an image. If the age subspace really and only carries age information, swapping it between two patients should shift the apparent age of the resulting image without disturbing anything else.

That is roughly what happened. Swapping age subspaces produced subtle but real visual shifts, most notably in bright, reflective features around the thickest retinal blood vessels, structures the authors note are more common in younger patients and tend to fade with age, a pattern consistent with older clinical literature on retinal light reflexes. Swapping the camera subspace produced smaller, occasionally identity affecting changes to the optic disc and vasculature appearance. Swapping the large 16 dimensional style subspace, by contrast, preserved the overall look of vasculature, optic disc position, and fundus pigmentation across every swap, exactly what you would expect if that subspace really was absorbing generic image detail rather than any specific labeled content.

The strongest quantitative evidence came from a follow up experiment. The team trained an independent age classifier on the model’s image reconstructions, then tested it under three conditions, standard reconstructions, reconstructions with swapped age subspaces paired with the correct new age label, and reconstructions with swapped age subspaces still paired with the original, now incorrect, label.

Read the third column carefully because it is the clever part of this experiment. If the age subspace swap genuinely changed the image’s age relevant features, then evaluating against the original, now wrong, label should tank accuracy toward chance level, since the classifier is correctly reading the new, swapped age but being scored against the old one. That is exactly what happened, dropping to 40 percent and 47 percent respectively, close to the random chance baselines of 37 percent and 57 percent. Meanwhile scoring the same swapped images against their correct new labels held accuracy nearly as high as the standard, unswapped case. Together that is about as clean a confirmation as you can get that the age subspace is doing real, controllable work rather than just passing a classification benchmark.

Ethnicity subspace swaps produced a visually stronger effect than age swaps, most clearly in fundus pigmentation, which the authors describe as biologically plausible given known associations between retinal pigmentation and ethnicity documented in prior clinical research. Some ethnicity swaps also altered vasculature appearance, a side effect the authors flag as a sign that full separation between ethnicity and other content features was not perfectly achieved, consistent with the residual entanglement already visible in the confusion matrix results.

Ethnicity is not biology. Title of a cited work by Rajesh and colleagues on retinal pigment scoring, referenced by the authors when discussing why pigmentation changes during ethnicity subspace swaps are biologically plausible rather than purely a data artifact

Clinical translation gap

It is worth being explicit about how far this sits from an actual clinical tool. Every image used in this study came from a single telemedicine screening system serving California, and every image was filtered down to healthy eyes with no reported disease and a quality label of good or excellent. That is a deliberately narrow slice of the real world of ophthalmology, chosen specifically so the researchers could study representation and bias questions without the added complexity of disease features tangled into the same latent space. The paper’s discussion section is candid that extending this work to disease relevant subspaces, for example encoding diabetic retinopathy severity as its own disentangled factor, is future work rather than something demonstrated here, and the authors note this earlier exploration was set aside partly because of how imbalanced the diseased versus healthy classes are in datasets like this one.

Nothing in this paper trains, validates, or claims to improve a disease detection or diagnostic model. The generative and encoding tools described here are aimed at researchers studying how confounding factors move through a training dataset and a learned representation, not at clinicians or patients. Any path from this kind of representation learning research toward an actual bias corrected diagnostic pipeline would require substantially more work, including validation on datasets from multiple countries and populations beyond the single EyePACS cohort used here, explicit handling of disease relevant features the authors set aside in this study, and the full regulatory and clinical evaluation process any medical software would need before clinical use.

Honest limitations

Several constraints deserve to be named plainly, using only what the paper itself reports. The dataset, while reasonably large at 75,989 images across 24,336 patients, comes from one telemedicine screening provider in one geographic setting, and the ethnicity label distribution is heavily skewed, with Latin American patients making up roughly 71 percent of the cohort and other groups such as Native American and multi-racial patients represented by only a few hundred images each based on the histogram the authors provide. That imbalance directly limited how well the ethnicity subspace could be evaluated and is the authors’ own explanation for why ethnicity decoding accuracy improvements stayed in the single digits even in the best performing configuration.

The authors are also explicit that their method’s ability to separate correlated factors has a hard ceiling set by the data itself. Disentangling age from camera turned out to be considerably easier than disentangling ethnicity from camera, and the paper attributes this directly to how strongly ethnicity and camera happen to correlate within the EyePACS cohort, a correlation the algorithm can reduce but evidently cannot eliminate when the underlying data genuinely confounds the two. Reconstruction quality also showed measurable weakness specifically in fine vascular detail, visible in the difference maps between original and reconstructed images, which matters clinically because thin vessel structure is exactly the kind of feature that carries diagnostic signal in real ophthalmology. On the technical side, the distance correlation computation itself proved sensitive to batch size, requiring the team to build a custom data ring buffer for multi GPU training, and larger latent subspaces needed correspondingly larger batches to estimate distance correlation reliably, which the authors flag as a real constraint on how far this approach can scale to bigger or higher resolution latent spaces without further engineering work.

Where this could go next

The authors point toward several concrete follow ups. Weakly supervised training, where the classification loss only needs to be applied to a subset of labeled images rather than the full training set, could make the approach usable on datasets where complete demographic and technical metadata is harder to come by. They also flag interest in comparing distance correlation against alternative dependence measures such as maximum mean discrepancy or adversarial classifier based approaches, each of which carries different trade offs around convergence speed and batch size sensitivity. Most notably for anyone thinking about actual clinical deployment, the authors describe adding a disentangled disease subspace, potentially using EyePACS diabetic retinopathy labels, as an interesting future test case, specifically to study whether a disentangled disease representation holds up better than a standard one when tested on a shifted distribution such as a different hospital’s patient population.

Conclusion

The achievement at the center of this paper is narrower and more useful than it might first sound. The authors did not claim to have solved bias in medical imaging AI. What they built and carefully validated is a specific, well tested mechanism for pulling apart three sources of variation in a retinal image dataset, patient biology, camera hardware, and everything else, and for proving through direct experiment that the separation is real rather than cosmetic. The subspace swap experiment, where changing only the age subspace correctly and predictably shifted an independent classifier’s age prediction, is the kind of concrete, falsifiable evidence that is easy to skip past in an abstract but genuinely hard to fake.

The conceptual shift worth sitting with is the choice to frame a representation learning problem in explicitly causal terms before ever touching a loss function. Drawing the small causal graph, patient attribute, camera, and style, all statistically linked through an unmeasured confounder, gave the team a principled reason to reach for distance correlation rather than a simpler, more familiar correlation measure, because only a measure sensitive to nonlinear dependence could plausibly catch the kind of subtle, nonlinear shortcut a deep network is prone to exploit.

Where this transfers beyond fundus photography is genuinely broad. The authors state plainly that their general prerequisites, prior knowledge of the confounding factors at play and labels for both the primary attribute and the confounder, can be met in plenty of other medical imaging contexts, chest radiographs confounded by scanner manufacturer, dermatology datasets confounded by lighting rigs, MRI cohorts confounded by field strength or coil hardware. The specific StyleGAN2 based architecture is fundus specific in its details, but the causal framing and the distance correlation loss are not.

The honest remaining limitation is that disentanglement here is a matter of degree rather than a solved problem, and the paper says so without hedging. When a technical factor and a patient attribute are genuinely, deeply correlated in the source data, as ethnicity and camera type are in this particular EyePACS cohort, no representation learning trick fully untangles them, because there is a sense in which the confound really is present in the world the data was drawn from, not just in the model’s interpretation of it. What this method offers instead is a meaningful reduction, one that the authors demonstrate clearly moves cross subspace leakage down without damaging image quality, alongside an unusually direct way to check the work through controllable image generation rather than trusting an opaque latent space at face value.

For a field where confounded training data is closer to the rule than the exception, that combination, a causal framing, a principled independence loss, and a built in way to visually audit whether the separation actually worked, is a more durable contribution than any single accuracy number in the paper’s tables.

Complete proposed model implementation in PyTorch

The following is an original, simplified, runnable PyTorch implementation inspired by the encoder, subspace classifier, distance correlation loss, and generator decoder components described in the paper. It is a compact educational reconstruction of the core disentanglement mechanism, not the authors’ own StyleGAN2 based code, built to illustrate the architecture on dummy data with a working smoke test.

# retinal_subspace_disentanglement.py
# Educational reimplementation of the encoder, subspace classifiers, distance
# correlation disentanglement loss, and a simplified generator decoder,
# inspired by "Disentangling representations of retinal images with
# generative models", Medical Image Analysis, 2025.

import torch
import torch.nn as nn
import torch.nn.functional as F

IMG_SIZE = 64
AGE_DIM = 4
CAM_DIM = 12
STYLE_DIM = 16
NUM_AGE_CLASSES = 3
NUM_CAM_CLASSES = 14


class FeatureEncoder(nn.Module):
    """Maps a fundus image to a combined feature vector w, later split into
    the age, camera, and style subspaces, mirroring f_theta in Fig. 3."""
    def __init__(self):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(3, 32, 4, stride=2, padding=1), nn.ReLU(),
            nn.Conv2d(32, 64, 4, stride=2, padding=1), nn.ReLU(),
            nn.Conv2d(64, 128, 4, stride=2, padding=1), nn.ReLU(),
            nn.AdaptiveAvgPool2d(1),
        )
        self.fc = nn.Linear(128, AGE_DIM + CAM_DIM + STYLE_DIM)

    def forward(self, x):
        h = self.conv(x).flatten(1)
        w = self.fc(h)
        w_age = w[:, :AGE_DIM]
        w_cam = w[:, AGE_DIM:AGE_DIM + CAM_DIM]
        w_style = w[:, AGE_DIM + CAM_DIM:]
        return w_age, w_cam, w_style


class SubspaceClassifier(nn.Module):
    """Linear classification head C_psi_k attached to one subspace."""
    def __init__(self, subspace_dim, num_classes):
        super().__init__()
        self.linear = nn.Linear(subspace_dim, num_classes)

    def forward(self, w_k):
        return self.linear(w_k)


def distance_correlation(w1, w2, eps=1e-9):
    """Empirical distance correlation between two batches of subspace
    vectors, following Eq. 5 to 7 in the paper. Returns a scalar in
    the range zero to one, equal to zero only when w1 and w2 are
    statistically independent in the batch sample."""
    n = w1.shape[0]

    def double_centered_distances(w):
        diff = w.unsqueeze(1) - w.unsqueeze(0)
        dist = torch.sqrt((diff ** 2).sum(-1) + eps)
        row_mean = dist.mean(dim=1, keepdim=True)
        col_mean = dist.mean(dim=0, keepdim=True)
        total_mean = dist.mean()
        return dist - row_mean - col_mean + total_mean

    A = double_centered_distances(w1)
    B = double_centered_distances(w2)

    d_cov_xy = torch.sqrt((A * B).sum() / (n ** 2) + eps)
    d_cov_xx = torch.sqrt((A * A).sum() / (n ** 2) + eps)
    d_cov_yy = torch.sqrt((B * B).sum() / (n ** 2) + eps)

    return d_cov_xy / torch.sqrt(d_cov_xx * d_cov_yy + eps)


def disentanglement_loss(subspaces):
    """Averages pairwise distance correlation across every unique subspace
    pair, following Eq. 4 in the paper, with K equal to len(subspaces)."""
    k = len(subspaces)
    total = 0.0
    pairs = 0
    for i in range(k):
        for j in range(i):
            total = total + distance_correlation(subspaces[i], subspaces[j])
            pairs += 1
    return total / max(pairs, 1)


class SimpleDecoder(nn.Module):
    """A compact stand in for the StyleGAN2 generator used in the paper,
    reconstructing an image from the concatenated subspaces w = [w_age,
    w_cam, w_style], enough to demonstrate controllable subspace swapping."""
    def __init__(self):
        super().__init__()
        total_dim = AGE_DIM + CAM_DIM + STYLE_DIM
        self.fc = nn.Linear(total_dim, 128 * 8 * 8)
        self.deconv = nn.Sequential(
            nn.ConvTranspose2d(128, 64, 4, stride=2, padding=1), nn.ReLU(),
            nn.ConvTranspose2d(64, 32, 4, stride=2, padding=1), nn.ReLU(),
            nn.ConvTranspose2d(32, 3, 4, stride=2, padding=1), nn.Sigmoid(),
        )

    def forward(self, w_age, w_cam, w_style):
        w = torch.cat([w_age, w_cam, w_style], dim=-1)
        h = self.fc(w).reshape(-1, 128, 8, 8)
        return self.deconv(h)


class RetinalPopulationModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.encoder = FeatureEncoder()
        self.age_head = SubspaceClassifier(AGE_DIM, NUM_AGE_CLASSES)
        self.cam_head = SubspaceClassifier(CAM_DIM, NUM_CAM_CLASSES)
        self.decoder = SimpleDecoder()

    def forward(self, x):
        w_age, w_cam, w_style = self.encoder(x)
        y_age_hat = self.age_head(w_age)
        y_cam_hat = self.cam_head(w_cam)
        recon = self.decoder(w_age, w_cam, w_style)
        return y_age_hat, y_cam_hat, recon, (w_age, w_cam, w_style)

    def training_step(self, x, y_age, y_cam, lambda_dc=0.5):
        y_age_hat, y_cam_hat, recon, subspaces = self.forward(x)
        ce_loss = F.cross_entropy(y_age_hat, y_age) + F.cross_entropy(y_cam_hat, y_cam)
        recon_loss = F.mse_loss(recon, x)
        dc_loss = disentanglement_loss(list(subspaces))
        total = ce_loss + recon_loss + lambda_dc * dc_loss
        return total, {"ce_loss": float(ce_loss), "recon_loss": float(recon_loss), "dc_loss": float(dc_loss)}

    def swap_age_subspace(self, x_a, x_b):
        """Encodes two images, swaps their age subspaces, and decodes both
        results, reproducing the subspace swap experiment in Fig. 11."""
        w_age_a, w_cam_a, w_style_a = self.encoder(x_a)
        w_age_b, w_cam_b, w_style_b = self.encoder(x_b)
        recon_a_with_b_age = self.decoder(w_age_b, w_cam_a, w_style_a)
        recon_b_with_a_age = self.decoder(w_age_a, w_cam_b, w_style_b)
        return recon_a_with_b_age, recon_b_with_a_age


def evaluate_disentanglement(model, x, y_age, y_cam):
    """Reports classification accuracy per subspace, the predictor based
    disentanglement metric described in Section 5 of the paper, using
    the model's own linear heads as a lightweight stand in for the kNN
    classifier the authors used."""
    model.eval()
    with torch.no_grad():
        y_age_hat, y_cam_hat, _, _ = model(x)
        age_acc = (y_age_hat.argmax(-1) == y_age).float().mean().item()
        cam_acc = (y_cam_hat.argmax(-1) == y_cam).float().mean().item()
    model.train()
    return {"age_subspace_accuracy": age_acc, "camera_subspace_accuracy": cam_acc}


def smoke_test():
    """Runs one forward and backward pass on random dummy data, plus a
    subspace swap and an evaluation call, to confirm every module is
    wired together correctly."""
    torch.manual_seed(0)
    model = RetinalPopulationModel()
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

    batch = 8
    dummy_images = torch.rand(batch, 3, IMG_SIZE, IMG_SIZE)
    dummy_age_labels = torch.randint(0, NUM_AGE_CLASSES, (batch,))
    dummy_cam_labels = torch.randint(0, NUM_CAM_CLASSES, (batch,))

    loss, logs = model.training_step(dummy_images, dummy_age_labels, dummy_cam_labels)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    metrics = evaluate_disentanglement(model, dummy_images, dummy_age_labels, dummy_cam_labels)

    recon_a, recon_b = model.swap_age_subspace(dummy_images[:4], dummy_images[4:])

    print("Training loss", float(loss))
    print("Loss components", logs)
    print("Disentanglement metrics", metrics)
    print("Swapped reconstruction shapes", recon_a.shape, recon_b.shape)
    print("Smoke test completed without errors")


if __name__ == "__main__":
    smoke_test()

Frequently asked questions

Related reading