Sieve in Few Dimensions, Learn in Many: Label-Noise Filtering for Hyperspectral Classifiers

Hyperspectral images record hundreds of narrow color bands per pixel, so each pixel is a long spectrum rather than three numbers. Labels for these pixels come from costly field surveys or expert drawing, so a scene typically has a few hundred labeled pixels, and some of those labels are wrong. The best general tool against wrong labels is to treat training as semi-supervised: watch which samples the network finds hard to fit early in training, strip their labels, and train on them as unlabeled data. This rests on the observation that networks learn clean patterns before they memorize noisy ones. We argue that this observation breaks down for hyperspectral data. When a pixel has 200 dimensions and each class has a few dozen labels, almost any labeling, including a wrong one, can be fit almost immediately. The window in which clean and mislabeled pixels look different therefore closes before the filter can use it.

The proposal is to split the two jobs across two very different input sizes. A small, cheap "sieve" model sees only a handful of locally computed spectral components. It has too few dimensions to memorize wrong labels, so its per-pixel losses keep separating clean labels from wrong ones. A full-spectrum spectral-spatial network does the actual classification in semi-supervised fashion, using the sieve's split of labeled versus unlabeled pixels. The curse of dimensionality, usually treated as a nuisance to compress away, becomes the tuning knob for how long the noise filter stays reliable.

Core Claim

DivideMix fits a two-component Gaussian mixture to per-sample training losses and treats the high-loss component as unlabeled data. Two identical networks divide the data for each other to limit self-confirmation. Its authors name the failure mode that matters here: if the network overfits during warm-up, the loss distributions overlap and the split fails. The claim of this note is that in hyperspectral classification this overlap is not an occasional warm-up accident. It follows structurally from the ratio of input dimension to labels per class, and the two networks, being equally high-dimensional, share the failure rather than correct it.

A counting argument makes the claim concrete. Cover's classical result says that $n$ points in general position in $d$ dimensions can receive any binary labeling from a linear separator when $n \le 2d$. A classifier's capacity to fit arbitrary labels, wrong ones included, therefore grows roughly linearly with its input dimension $d$. With $L \approx 200$ bands and tens of labeled pixels per class, even a linear read-out on raw spectra can fit label noise. With $d$ around 5 to 15 components, it cannot, and wrong labels stay high-loss.

We therefore predict three things. First, loss-based separation of clean from noisy labels, measured as an area under the ROC curve, decays within a few epochs for full-spectrum models and persists for low-dimensional sieves. Second, sieve quality has an interior optimum in $d$: too few dimensions merge spectrally similar classes, too many allow memorization. Third, the advantage shrinks as labeled pixels per class grow, because memorization then slows for the full model too. The third prediction is the one that distinguishes our mechanism from a generic "smaller models are more robust" story.

Research Program

The sieve operates on superpixel-wise principal components. SuperPCA segments the scene into spatially homogeneous regions and runs principal component analysis (PCA) separately inside each region. It reports 96.78% overall accuracy on Indian Pines against 67.27% for global PCA with the same classifier. That paper supplies our input representation, and its global-PCA result constrains the design: a single global projection would make the sieve too weak to separate crops with similar spectra. The sieve is a small multilayer perceptron or logistic model trained on these $d$ components. Every few epochs we fit a two-component mixture to its per-pixel losses, and the result assigns each labeled pixel a probability of being clean.

The learner is a full-spectrum spectral-spatial network. Our default is the dual-channel design of DC-CNN, which runs a one-dimensional convolution along all $L$ bands of a small patch alongside a two-dimensional convolution over a PCA-compressed spatial patch. We train it with the DivideMix semi-supervised objective: MixUp interpolation of inputs and targets, label refinement on pixels judged clean, and label guessing on pixels judged noisy together with the scene's genuinely unlabeled pixels. The one change is where the clean/noisy split comes from. The sieve provides it, and the learner's own loss plays no part.

We add a single feedback path, controlled by a flag we can switch off for ablation. The learner's confident predictions on stripped pixels are passed back as soft targets for the sieve. The two models thus cross-teach across dimensionalities rather than between twin copies. This also answers the doubled-cost complaint against DivideMix, because the second model is tiny.

A secondary analysis borrows from Dimensionality-Driven Learning with Noisy Labels. That paper showed on natural images that networks trained on noisy labels first compress their internal representation and then expand its local intrinsic dimensionality once they start fitting noise. We will track this quantity in the full-spectrum learner, with and without the sieve, to test two things: whether the expansion phase arrives earlier when the input is already high-dimensional, and whether the sieve's split prevents it. The analysis is diagnostic. If intrinsic dimensionality alone predicts noise fitting as well as the sieve, that counts against our design, and we will report it as such.

Baselines

The naive reference is the DC-CNN learner trained directly on the noisy labels with cross-entropy and early stopping on a held-out noisy validation split. It tells us how much any mitigation buys.

The strongest general-purpose competitor is DivideMix run end-to-end on the same full-spectrum DC-CNN, with its usual two-network co-division. This is the "obvious" combination at this intersection, and the file shows nobody has reported it for hyperspectral data. There is no reported result found on Lacuna for DivideMix on Indian Pines, Pavia University, or Salinas. For orientation only, DivideMix reports 76.0% accuracy on CIFAR-10 at 90% symmetric noise. We give it the same warm-up search, epochs, augmentation, and hyperparameter budget as our method, including a sweep over warm-up length. Its failure then cannot be blamed on a poorly chosen warm-up.

The strongest hyperspectral-specific competitor is RLPA from Hyperspectral Image Classification in the Presence of Noisy Labels. It cleans labels offline by propagating them over a superpixel-constrained spectral-spatial transition matrix across 100 random subsamplings, then takes a majority vote. It reports that an extreme learning machine trained on RLPA-cleaned Indian Pines labels reaches approximately 86.78% accuracy at 50% flip noise, against 67.86% on raw noisy labels. Averaged over its three scenes and noise levels, it reports gains of 9.18% overall accuracy and 0.1043 Kappa. Their training splits need not match ours, so we re-run RLPA ourselves and feed its cleaned labels to both the extreme learning machine and the same DC-CNN learner. The comparison is then about cleaning, not classifier strength.

We also run the self-training pipeline of Spatial-Regulated Self-Training on noisy seeds. It combines CNN features, constrained clustering, and distance-weighted spatial smoothing of pseudo-labels. It reports 87.35% on Indian Pines and 97.37% on Salinas with clean seeds, and its authors warn that early mislabels propagate.

Three ablations isolate the key ingredient. The first uses the full-spectrum DC-CNN as its own sieve, which isolates dimensionality. The second uses a global-PCA sieve instead of superpixel-wise PCA, which isolates locality. The third uses a non-learned sieve that scores each labeled pixel by a leave-one-out nearest-class-subspace residual in the SuperPCA space. That tests whether training the sieve matters at all.

Beating the field means two things on at least two of the three scenes at 30% and 50% noise. The method must exceed both RLPA+DC-CNN and full-spectrum DivideMix in overall accuracy by more than the seed-to-seed standard deviation. It must also show higher clean/noisy separation than the self-sieve ablation.

Why not just…?

Why not just compress to a few PCA components and run off-the-shelf DivideMix? This hands the whole problem to low dimensions, and SuperPCA's own 67.27% global-PCA figure shows how much class information a crude projection loses. DC-CNN keeps a full-band spectral stream because diagnostic material signatures live there. Our ablation that trains the learner as well as the sieve on the $d$ components tests this directly. If it matches the full method, the "learn in many dimensions" half of the claim is wrong, and we would recommend the simpler pipeline.

Why not just clean the labels with RLPA and then train any network? RLPA is a serious threat, since it already uses superpixel structure and reports large gains. Its cleaning, however, is fixed before training and relies on raw spectral similarity, which is exactly what the Hughes phenomenon makes unreliable. It also needs a pixel-by-pixel transition matrix and 100 propagation runs. The RLPA+DC-CNN baseline settles this. We also report results separately for boundary pixels, where RLPA zeroes cross-superpixel transitions and so cannot borrow evidence.

Why not just regularize the full network harder (weight decay, dropout, early stopping) instead of adding a sieve? If lower memorization capacity were all that mattered, a heavily regularized full-spectrum self-sieve would do as well. We sweep regularization strength on the self-sieve ablation under the same tuning budget. The third prediction, that the advantage shrinks as labels per class grow, separates the explanations. Generic regularization has no reason to depend on the ratio of dimension to labels in that way.

Proposed Experiments

We use Indian Pines, Pavia University, and Salinas. Training and test regions are spatially disjoint blocks, so that patch overlap does not leak labels. Training uses 10, 25, and 50 labeled pixels per class. Noise comes in three forms: symmetric flips at 10–50%; class-dependent flips between spectrally similar crops; and a structured regime in which labels near class boundaries are flipped to the neighboring class and whole superpixels occasionally receive a wrong label, mimicking polygon annotation errors. Metrics are overall accuracy, average per-class accuracy, and Kappa, plus accuracy on boundary pixels.

For the sieve itself, we track the ROC area separating truly clean from truly noisy labels at every epoch. We also track precision of the clean set, and the learner's local intrinsic dimensionality over training.

Three checks decide the question. First, separation area against epoch: the full-spectrum self-sieve should collapse toward chance within the warm-up window at 10–25 labels per class, while the low-dimensional sieve holds. If both hold, our premise is false and plain DivideMix suffices. Second, a sweep of $d$ from 2 to 60: separation should peak at an interior value that moves upward as labels per class grow, roughly as the counting argument suggests. A flat or monotone curve refutes the mechanism. Third, the label-budget sweep: the gain over full-spectrum DivideMix should be largest at 10 labels per class and should shrink at 50. Every configuration runs over five seeds on a matched GPU-hour budget, and the sieve's compute is reported separately so the cost claim can be checked.