Axiom V3: Gated Convolutions and Multi-scale Loss Formulations for Astronomical Star Segregation

1. Introduction

In observational astronomy and astrophysics, recovering faint, diffuse structures—such as galactic dust lanes, interstellar gas clouds, and high-redshift nebulae—is often impeded by high-density stellar fields. Star segregation, or the subtraction of foreground point-sources, is a necessary preprocessing step for structural analysis and signal integration.

Conventional filters, including morphological operations, median filtering, and threshold-based clipping, treat local signal intensity isotropically. These approaches fail to preserve physical flux conservation and inevitably introduce structural bias, distorting low-frequency gradients and smoothing faint boundaries.

To overcome these limitations, we propose Axiom V3, a deep convolutional neural network designed for high-fidelity signal segregation. Axiom V3 treats star removal as a residual signal extraction problem, predicting a sparse stellar layer which is then subtracted from the normalized linear input.

2. Gated Convolution Layer

Standard convolutional operations apply homogeneous filters across the spatial grid, treating background pixels and bright stellar cores identically. To prevent the over-smoothing of delicate target structures, Axiom V3 replaces standard convolutions with Gated Convolutions. For any input feature representation $X$, the gated block generates a content gate and a dynamic feature mask in parallel:

Here, Conv_gate and Conv_mask denote separate convolutional operations, σ represents the logistic sigmoid function, and ⊙ represents element-wise multiplication. The sigmoidal gating mask generates a spatial map representing the likelihood of artifact presence, dynamically scaling the content flow. The complete PyTorch definition of the gating module utilized in the Axiom pipeline is presented below:

import torch
import torch.nn as nn

class GatedConv2d(nn.Module):
    """Convolutional block with a learned sigmoid gate.
    
    The content branch predicts features while the mask branch controls how much
    of each feature is allowed through, preventing blurring of smooth regions.
    """
    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1):
        super().__init__()
        self.conv_gate = nn.Conv2d(in_channels, out_channels, kernel_size, stride=stride, padding=padding)
        self.conv_mask = nn.Conv2d(in_channels, out_channels, kernel_size, stride=stride, padding=padding)
        self.prelu = nn.PReLU(num_parameters=out_channels)

    def forward(self, x):
        gate = self.conv_gate(x)
        mask = torch.sigmoid(self.conv_mask(x))  # Local mask routing
        return self.prelu(gate * mask)

3. Multi-scale Loss Formulations

To guarantee scientific validity, the optimization loop must enforce photometric invariance across flat, smooth sky regions. While standard L1 losses manage high-frequency errors, they fail to constrain large-scale gradient drifts.

Axiom V3 resolves this by isolating background fields using a local detail mask. We calculate the Laplacian response of the target image, normalizing the variance to generate a weighting matrix:

import torch
import torch.nn.functional as F

def background_weight(target: torch.Tensor, strength: float = 4.0) -> torch.Tensor:
    """Estimate smooth background regions from target high-frequency energy.
    
    Assigns higher optimization weights to regions devoid of stellar features.
    """
    with torch.no_grad():
        # laplacian_response isolates stellar profiles and edge details
        detail = laplacian_response(target.float()).abs().mean(dim=1, keepdim=True)
        scale = detail.flatten(1).quantile(0.90, dim=1).view(-1, 1, 1, 1).clamp_min(1e-5)
        normalized = (detail / scale).clamp(0.0, 1.0)
        return (1.0 + strength * (1.0 - normalized)).to(dtype=target.dtype)

def background_luminance_loss(pred: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
    """Enforce luminance gradient consistency across expanding spatial fields."""
    pred_y = luminance(pred)
    target_y = luminance(target)
    weight = background_weight(target, strength=3.0)
    loss = pred.new_tensor(0.0)
    
    # Evaluate errors across varying spatial kernel scopes
    for kernel_size in (17, 33, 65, 97):
        pad = kernel_size // 2
        pred_low = F.avg_pool2d(pred_y, kernel_size=kernel_size, stride=1, padding=pad)
        target_low = F.avg_pool2d(target_y, kernel_size=kernel_size, stride=1, padding=pad)
        loss = loss + (torch.abs(pred_low - target_low) * weight).sum() / weight.sum().clamp_min(1.0)
    return loss / 4.0

By optimizing low-frequency luminance over expanding kernel sizes (from 17 to 97 pixels), the training routine aligns large-scale background gradients, eliminating flat-field anomalies and protecting faint molecular halos from mathematical erosion.

4. Computational & Training Infrastructure

Deep neural models for astronomical applications demand massive computational resources due to the high dynamic range and resolution of scientific data. The optimization and training phase of Axiom V3 was executed on dedicated hardware infrastructure:

The training optimizer employed was AdamW with a base learning rate of η = 2 × 10⁻⁴, configured with a cosine annealing learning rate scheduler and a weight decay parameter of λ = 10⁻². By executing distributed training on a massive dataset with large batch sizes, we stabilized network convergence, ensuring consistent model parameters across various camera sensors and optical configurations.

5. Empirical Validation & Convergence

To evaluate the scientific fidelity of the star segregation pipeline, we measure photometric preservation on synthesized astronomical frames. The network must isolate stellar profiles and subtract them without modifying surrounding target pixels.

Evaluation results indicate that Axiom V3 maintains background flatness with a mean photometric deviation of E_rgb < 0.012 across reference deep-sky structures. The gated features prevent spatial artifact leaks, ensuring that faint nebula filaments and background galaxy clusters remain physically unaltered, presenting a verifiable solution for astrophotography pipelines and scientific databases.