△ Mechanism confirmed, baseline not beaten 2026

Cut-Aware Augmentation Filtering

Implementation & benchmark of arXiv:2607.07513 — Fast Rates for Semi-Supervised Learning via Data-Augmentation Graph Regularization

Usefulness6/10

Difficulty3/10

Novelty6/10

Regularization Accuracy Sample efficiency Generalization Data augmentation Graph nn Regularization Fine tuning Graph theory Spectral theory Statistics

Source paper: Fast Rates for Semi-Supervised Learning via Data-Augmentation Graph Regularization arXiv:2607.07513 ⓘ · analyzed Aug 30, 2026

AI-generated research hypothesis, automatically tested. Not peer-reviewed.

Idea description

Estimate how often each augmentation policy creates graph connections across different classes, then downweight policies with high estimated boundary-crossing mass. This directly targets the paper's augmentation-alignment term rather than tuning augmentation strength only by validation accuracy.

Formulas

$$R_{\mathrm{DA}}(y)\propto\frac{\operatorname{cut}_{W}(y)}{\operatorname{vol}(W)},\qquad \operatorname{cut}_{W}(y)=\sum_{i,j}W_{ij}\mathbf{1}[y_i\neq y_j],\qquad \operatorname{vol}(W)=\sum_{i,j}W_{ij}.$$

$$\widehat{R}_a=\frac{\sum_{i,j}W^{(a)}_{ij}\mathbf{1}[\widehat{y}_i\neq\widehat{y}_j]}{\sum_{i,j}W^{(a)}_{ij}+\varepsilon},\qquad q_a=\frac{\exp(-\beta\widehat{R}_a)}{\sum_b\exp(-\beta\widehat{R}_b)}.$$

$$W=\sum_a q_a W^{(a)},\qquad \min_\theta L_{\mathrm{sup}}(\theta)+\frac{\lambda}{2m^2}\sum_{i,j}W_{ij}\|p_i-p_j\|^2.$$

Mathematical statement

For a weighted graph W and node labels y_i, define the weighted cut mass cut_W(y) = sum_{i,j} W_ij 1[y_i != y_j] and graph volume vol(W) = sum_{i,j} W_ij. The paper's augmentation alignment error satisfies R_DA(y) proportional to cut_W(y)/vol(W). For augmentation policy a, construct its graph W^(a), estimate labels y_hat_i using ground-truth labels where available and high-confidence predictions otherwise, and compute R_hat_a = [sum_{i,j} W^(a)_ij 1[y_hat_i != y_hat_j]]/[sum_{i,j} W^(a)_ij + epsilon]. Combine policies with q_a = exp(-beta R_hat_a)/sum_b exp(-beta R_hat_b), where beta controls filtering sharpness. The final graph is W = sum_a q_a W^(a), and its Laplacian penalty is (lambda/(2m^2)) sum_{i,j} W_ij ||p_i-p_j||^2. The mathematical assumption is that lower graph-cut mass means a smaller irreducible alignment error, while the exponential weighting is an engineering adaptation.

Implementation notes

(1) Integration point: place the method in the augmentation sampler or graph-construction stage of semi-supervised fine-tuning. Maintain A candidate policies, for example crop, color jitter, blur, rotation, and stronger combinations. Each policy produces augmented views and a separate sparse k-nearest-neighbor graph W^(a) over detached encoder embeddings. (2) Pseudocode: for each policy a, generate views, compute embeddings, build W^(a), compute classifier probabilities p_i, and set y_hat_i = argmax_c p_ic only if max_c p_ic exceeds confidence threshold gamma; use known labels instead whenever available. Compute R_hat_a = sum_ij W^(a)_ij 1[y_hat_i != y_hat_j]/(sum_ij W^(a)_ij + epsilon). Update an exponential moving average of each R_hat_a, calculate q_a = softmax(-beta R_hat_a), combine W = sum_a q_a W^(a), and apply the combined graph penalty to the prediction vectors. Stop gradients through q_a during the first implementation. (3) The cut-mass criterion is the direct transfer from the paper. The exponential policy weighting, confidence threshold gamma, smoothing decay, neighbor count k, beta, and lambda are empirical choices. To prevent early wrong pseudo-labels from suppressing useful policies, initialize q_a uniformly, use only labeled-labeled and labeled-confident pairs for the first warmup epochs, and impose q_a >= q_min followed by renormalization. (4) First cheap experiment: use CIFAR-10 or STL-10 with 100, 500, and 1,000 labels, a small WideResNet, and a fixed candidate set containing both valid and deliberately harmful transformations such as 90-degree rotation or extreme color inversion. Compare uniform policy mixing, random policy dropping, and cut-aware weighting. Record test accuracy, estimated cut error, per-class recall, graph regularization magnitude, and accuracy as harmful-policy probability increases. Success is lower estimated cut mass and higher accuracy at equal training compute, with the largest gain when the candidate set contains label-destroying augmentations.

Verification

Mechanism confirmed, baseline not beaten

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Confirmed ✓

Stage 2 · Practical benchmark result: No measurable effect

Methodology: 8 paired seeds, permutation test (p<0.05) against a learning-rate-tuned baseline. How verification works

Stage 1 — Mechanism check agent confidence 8/10

Built a self-contained cut-aware augmentation graph filter with cut-ratio computation, exponential policy weighting, graph regularization, and fixed-seed synthetic evaluation. The math check confirmed scale invariance and strongly favored the low-cut graph; across three seeds, cut-aware weighting reduced predicted cut mass from 0.2366 to 0.0092 and improved accuracy from 0.9802 to 0.9975. This is a clear toy-benchmark signal, not yet evidence of CIFAR-scale effectiveness.

Agent confidence: 8/10

Baseline: Uniform policy mixing: mean accuracy 0.98025 +/- 0.00175; mean predicted cut ratio 0.23663 +/- 0.00581.
Idea: Cut-aware weighting: mean accuracy 0.99753 +/- 0.00349; mean predicted cut ratio 0.00923 +/- 0.00303; harmful shuffled-policy weight approximately 0.00018-0.00020.

Limitations: Tested only a three-class 2D Gaussian toy dataset with feature-built graphs and ground-truth labels for policy scoring. Confidence-threshold pseudo-labeling, EMA estimates, q_min/warmup, random policy dropping, real image augmentations, CIFAR/STL-10, sparse graph implementation, GPU behavior, and matched FLOP/runtime measurements were not tested.

How to run: python3 experiment.py && /home/maxwelhelp/main/bin/python3 robustness.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2607.07513) Sep 4, 2026

No significant difference vs. the tuned baseline (+0.1%, p=1, wins 0 / 8 paired seeds).

Benchmark: Vision (image classification)
Model: cnn_small
Paired seeds: 8
Baseline mean: 0.8213
Idea mean: 0.8219
Effect (Δ): 0.0006 (+0.1%; negative = idea better)
Wins: 0 / 8 paired seeds
p-value: 1 (permutation test, 20 000 shuffles)
Smallest detectable effect: ±0.2%
Mechanism: Confirmed ✓
Practical effect: No effect
Baseline tuning: swept over 3 configs

Limitations:

The run used the small standard vision subset with 400 training examples, 200 test examples, and 8 epochs. Confidence-threshold pseudo-labeling, EMA cut estimates, q_min, warmup, sparse graph storage, and larger-scale CIFAR experiments were not tested.

How to run: python3 stage2_bench.py

Verdict computed by deterministic test code from paired-seed statistics — not by the language model.

Stage 2 — Benchmark Sep 4, 2026 latest Failed ✗

Agent confidence: 10/10

Cut-aware augmentation filtering was implemented with the shared cnn_small model on the CIFAR-10 vision track. The idea had test error 0.821875 versus 0.821250 for the tuned uniform baseline, paired delta +0.000625 and permutation p-value 1.0; therefore it did not produce a significant win.

Baseline: mean test error 0.8212500066, std 0.0441411053, best lr 0.003
Idea: mean test error 0.8218750060, std 0.0427885403, paired delta +0.0006249994, p-value 1.0

Benchmark result