Interpretable Human-Label-Free Deep Learning for Real-Bogus Classification with Uncertainty Quantification

Summary§

This paper proposes a method for real-bogus classification of transient candidates in time-domain astronomy that requires no human-labeled data. It uses injected simulated transients as positive samples and contaminated survey data as negative samples, training a dual-network model with asymmetric co-teaching to handle label noise. A novel hybrid uncertainty quantification (UQ) approach combines MC dropout and deep ensembles efficiently.

Methodology§

Problem Setup§

Let $x_i$ be a transient candidate (image or light curve). The goal is binary classification: real (astrophysical transient) vs. bogus (artifact). Training data consists of:

• Positive set $P$: simulated transients injected into real images (clean labels).
• Negative set $N$: survey data dominated by bogus but containing unknown real transients (noisy labels, class contamination rate $\epsilon$).

Asymmetric Co-Teaching§

Two networks $f_{\theta_1}$ and $f_{\theta_2}$ are trained alternately. For each mini-batch, network 1 selects samples with small loss from noisy set $N$ (assumed to be likely bogus) and uses them as negative examples to update network 2, and vice versa. Positive samples from $P$ are always used. This prevents memorization of noisy labels.

Loss Function§

For clean positives: cross-entropy $\mathcal{L}_{ce}(f(x), y=1)$. For selected negatives from $N$: cross-entropy $\mathcal{L}_{ce}(f(x), y=0)$. Formally, the loss for network $k$ at iteration $t$ is: $$ \mathcal{L}_k = \frac{1}{|P|} \sum_{x \in P} \mathcal{L}_{ce}(f_k(x),1) + \frac{1}{|\mathcal{R}_k|} \sum_{x \in \mathcal{R}_k} \mathcal{L}_{ce}(f_k(x),0) $$ where $\mathcal{R}_k$ is the set of samples from $N$ selected by the other network based on low loss.

Uncertainty Quantification§

Two standard UQ methods are adapted:

• MC Dropout: Dropout at inference, multiple forward passes, variance as uncertainty.
• Deep Ensembles: Train $M$ networks with different initializations, average predictions and compute variance.

Hybrid UQ§

Leveraging the dual-network architecture, they propose a low-cost hybrid: use the two already trained networks as a minimal ensemble (size 2), then apply MC dropout within each network. This yields $2 \times T$ predictions (T dropout samples per network). Uncertainty is estimated as: $$ \text{Uncertainty} = \frac{1}{2T} \sum_{m=1}^{2} \sum_{t=1}^{T} (p_{m,t} - \bar{p})^2 $$ where $p_{m,t}$ is the prediction of network $m$ with dropout mask $t$.

Code Snippet§

import torch
import torch.nn as nn

class RealBogusClassifier(nn.Module):
    def __init__(self, input_dim=64):
        super().__init__()
        self.fc = nn.Sequential(
            nn.Linear(input_dim, 128),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(128, 1),
            nn.Sigmoid()
        )
    def forward(self, x):
        return self.fc(x)

# Asymmetric co-teaching training loop
def train_step(net1, net2, optimizer1, optimizer2, clean_loader, noisy_loader, epsilon=0.2):
    net1.train(); net2.train()
    for (clean_batch, noisy_batch) in zip(clean_loader, noisy_loader):
        # clean_batch: positive samples, labels=1
        # noisy_batch: unlabeled, assume mostly bogus
        # Forward pass
        out1_clean = net1(clean_batch)
        out2_clean = net2(clean_batch)
        out1_noisy = net1(noisy_batch)
        out2_noisy = net2(noisy_batch)
        
        # Compute loss for clean (always positive)
        loss1_clean = nn.BCELoss()(out1_clean, torch.ones_like(out1_clean))
        loss2_clean = nn.BCELoss()(out2_clean, torch.ones_like(out2_clean))
        
        # Select low-loss samples from noisy for each network (cross selection)
        with torch.no_grad():
            loss1_noisy = nn.BCELoss(reduction='none')(out1_noisy, torch.zeros_like(out1_noisy))
            loss2_noisy = nn.BCELoss(reduction='none')(out2_noisy, torch.zeros_like(out2_noisy))
            # For net1 training, use samples where net2 loss is low (assumed bogus)
            mask2 = (loss2_noisy < torch.quantile(loss2_noisy, 1-epsilon)).float()
            # For net2 training, use samples where net1 loss is low
            mask1 = (loss1_noisy < torch.quantile(loss1_noisy, 1-epsilon)).float()
        
        # Selected noisy loss
        loss1_noisy = (nn.BCELoss(reduction='none')(out1_noisy, torch.zeros_like(out1_noisy)) * mask2).mean()
        loss2_noisy = (nn.BCELoss(reduction='none')(out2_noisy, torch.zeros_like(out2_noisy)) * mask1).mean()
        
        # Total loss
        loss1 = loss1_clean + loss1_noisy
        loss2 = loss2_clean + loss2_noisy
        
        optimizer1.zero_grad()
        loss1.backward()
        optimizer1.step()
        
        optimizer2.zero_grad()
        loss2.backward()
        optimizer2.step()

Results§

• Achieves >95% accuracy on a labeled benchmark despite being trained without human labels.
• Robust to class contamination up to 30% in the negative set.
• Hybrid UQ achieves calibration error comparable to deep ensembles (5 models) at half the cost.
• Latent space reveals subclasses: bogus split into multiple clusters (e.g., cosmic rays, bad pixels).