MICCAI 2026 IQA, Interactive

← text notes · Misc › Image Quality Assessment. One widget per paper, each a playable version of that paper's core construct. Every widget runs on small toy numbers in your browser, not on the paper's data. Move the knobs and see where each construct holds and where it breaks. The callout under each widget names the one thing worth trying first.

T-AM-063 · Cross-sectional self-consistency: a pair cannot say who is wrong, the median of all twins can

Top panel: each grey dot is a pair of near-identical cross-sectional patches from a toy dataset, placed by image distance d_I (MSE, in units of 10⁻³, so 1 is the retrieval threshold ε_I) and mask distance d_M = 1 − IoU. About 4% of the dataset's pairs involve a wrong mask. The blue band is the per-bin baseline μ_k ± σ_k. The coloured dots are the pairs one query patch forms with its twins: blue if the twin's own mask is clean, orange if the twin's mask is wrong.

Bottom panel: each pair's residual r_ij = (μ_k − d_M)/(σ_k + ε). Strongly negative means "these masks disagree far more than masks of equally similar images usually do". The black line is the patch score R_i, the median of the query's residuals. The readout turns R_i into the voxel quality q = σ(R_i).

Keep the query clean and raise the share of noisy twins. R_i stays near 0 up to a share of about 0.48, then jumps once noisy twins are the majority (about −2.3 at 0.52, below −3 by 0.6), and a clean patch is blamed. That is the median's 50% breakdown point. Back at a share of 0.2, a query mask error of 0.3 pushes R_i below −3, because now the query disagrees with nearly every twin. Then switch the baseline to median / MAD. The 4% noisy pairs in the dataset were inflating every σ_k (0.070 against 0.030 in the middle bin), and the same query now scores about −12.5 instead of −3.7; even an error of 0.1 is flagged. Also note that a clean patch with R_i ≈ 0 gets q = σ(0) = 0.5, not 1.

T-AM-171 · Learning to distort: the prototype hinge stops pulling at a fixed cosine gap

Left: a slice through the IQA encoder's feature space, drawn as the unit circle because only cosines matter. p₀ is the undistorted prototype, p₁ the distorted one, and z is the encoder feature of a generated volume. Drag z around the circle. The prototype-guidance hinge is L = max(0, cos(z,p₀) − cos(z,p₁) + m). It is zero on the green arc, where z is already at least m more similar to p₁ than to p₀, and active on the orange arc. For comparison, a logistic (BCE) loss on the same cosine gap, −log σ(s·gap), stands in for the classifier-head loss of the ablation.

Right: both losses and the size of their pull on z, |dL/dθ|, as z moves around the circle. Bottom: the weight w_k = ((k − k₀)/(K − k₀))² that each Euler step of the generated trajectory gets.

Drag z onto the green arc. The hinge and its pull are exactly zero once cos(z,p₁) − cos(z,p₀) ≥ m, while the logistic pull shrinks but never reaches zero. So prototype guidance does not keep pulling "deeper" into the distorted cluster; it stops at a cosine gap of m = 0.2. Then close the angle between the prototypes below about 11.5°. The green arc disappears because the largest possible gap, 2 sin(Δ/2), is now smaller than m, and the hinge never switches off.

T-PM-174 · Few-shot bpMRI IQA: prototypes, a b-value nuisance, and a probability that never leaves [0.12, 0.88]

A 2-D picture of the frozen embedding. Blue dots are good-quality query scans, orange dots low-quality ones. Filled dots were acquired at b = 1400 and rings at b = 2000. The b-value tilts every embedding by ±ν/2, and that tilt is the acquisition bias the gradient-reversal adversary is meant to remove (ν = 0 is perfect invariance). The large outlined dots are the few curated support cases per class. The arrows are the prototypes, the means of the normalised support embeddings. The dashed line is the decision boundary: points on either side are closer in angle to one prototype or the other.

The last slider turns the task into PI-QUAL. Only a share ψ of the low-quality exams are low because of DWI distortion. The rest have causes the distortion-trained embedding never learned, so they sit among the good scans.

With the tilt at ν = 30° and every support case taken at b = 1400 (the default), the prototypes inherit the tilt and the b = 2000 good scans fall across the boundary: specificity drops to about 0.52 and balanced accuracy to 0.76. Set ν = 0, which is what the adversary aims for, and balanced accuracy returns to 0.96 whatever the support mix. Then lower ψ to 0.6. Sensitivity falls to about 0.6 and stays there, because the frozen embedding places the other causes next to the good prototype. Finally, look at the probability range in the readout. At τ = 1 no query ever gets a probability outside [0.12, 0.88], so its loss never falls below 0.127.

W-AM-041 · MedQ-Engine: persistent failures, error-weighted budgets and confidence routing

Three rules from the data engine, each on its own toy. Left: a dev question is answered R times and enters the failure pool when more than a share γ of the answers are wrong. The curve is the chance of being flagged for a question whose per-answer error probability is p. Right: the annotation budget of B = 2000 samples is split over six capability cells in proportion to e_k^α, where e_k is the cell's dev error rate.

Bottom: the self-evolution routing for 1200 toy samples. Each dot is one new sample, placed by the student model's per-token negative log-likelihood of its own answer, H (the paper's "trajectory entropy"), and by its agreement δ with GPT-4o's answer. Right of τ_H, GPT-4o's label is adopted unreviewed. Top-left, where the student is confident and agrees, its own label is adopted. Bottom-left, where it is confident but disagrees, the sample goes to an expert. Colour shows what ends up in the training set. In the toy the student is right 72% of the time and GPT-4o 65%, close to its benchmark score.

Look at p = 0.5 on the left: a question the model gets right half the time is flagged only 19% of the time, so the pool holds persistent failures, not bad luck. In the routing panel, raise the shared-error share ρ. The review rate falls, because student and oracle agree more often, while the wrong labels kept through the top-left route rise: agreement is weak evidence exactly when the two models share their mistakes. Then lower the calibration c. Confidently wrong answers slide left of τ_H and are kept on the student's word or sent to the expert, depending only on whether GPT-4o happens to agree.

W-AM-042 · LaST: a loss GMM separates hard-to-fit from easy-to-fit, and a uniform prior equalises phases

Top: the per-frame losses of the 600 frames that carry one pseudo-label, as a stacked histogram. Blue frames have the right label. Orange frames have a wrong label that the small model still finds hard to fit. Purple frames have a wrong label from a systematic confusion of the foundation model, which the small model fits easily. A two-component Gaussian mixture is fitted to all the losses by EM (thin curves). The black curve is the posterior P(clean | ℓ) of the lower-mean component, and frames above the threshold τ are kept as clean.

Bottom: the class-balance prior. Grey bars are the true phase shares of a Cholec80-like video, with two long dissection phases. The loss D_KL(u ‖ p̄) pulls the video-average prediction p̄ towards uniform. If the only other pressure were a cross-entropy to the true shares q, the compromise would be p̄ = (q + λu)/(1 + λ) (orange). This is a simplification, since the real losses act frame by frame, but the direction of the pull is the same. LaST weights the two terms equally (λ = 1).

At the defaults the kept set is almost perfectly clean (99.6%). Now raise the systematic share κ. The purple frames have clean-looking losses, fall in the clean component and pass τ = 0.9, and the clean ratio drops to about 86% at κ = 0.3 and 79% at 0.6. The GMM separates labels that are hard to fit from labels that are easy to fit, not wrong labels from right ones. Lowering the loss separation, as early in training, lets hard wrong labels through as well (about 78% clean at 0.3). In the bottom panel, λ = 1 puts the predicted shares halfway between truth and uniform: the two long dissection phases shrink from about 39% and 35% to 27% and 25%.

W-PM-008 · GeoCAN: one pooling knob from min to max, and a "causal" matrix that is a tournament

Top: the generalised Lehmer mean pools a spatial activation map (grey bars) into one number. It can be rewritten as GLM = (1/κ)·ln Σ_s π_s e^{κF(s)} with weights π = softmax(βκF) (blue bars) and κ = ln α. So β decides which positions the pool listens to, and κ how max-like the averaging over them is. The orange line is the pooled value, always between the min and the max.

Bottom: four factor maps on a 24 × 24 grid (drag the blobs). GeoCAN's matrix C_ij = GLM(F_i ⊙ F_j) / GLM(F_j) reads like P(i | j), "how much of j's activation also lies under i", using the pooling set above. Its antisymmetric part A = C − Cᵀ becomes a tournament P = σ(A/τ) with P_ij + P_ji = 1. Each factor's score is the second-order tournament score P²1, standardised into g, and each factor map is rescaled by 1 + r·tanh(g).

With the pooling near the mean, factor 2 sits inside factor 1, so C₁₂ is large and C₂₁ small, and factor 1 wins the tournament. Drag factor 2 out of factor 1 and C₁₂ collapses. Now set β = 8 (max-like pooling) and watch the same geometry give a different "causal" matrix: the direction of dominance depends on a pooling knob, not on any intervention. The readout also checks two identities. (1 − σ(A/τ))ᵀ equals σ(A/τ), so the second factor in the paper's Eq. (3) adds nothing. And the multi-hop matrix Σλⁿ(CCᵀ)ⁿ used by the ranking loss is exactly symmetric, so the direction is gone before the loss sees it.

W-PM-121 · SlideGuard: Dice under class imbalance, and artefacts that vanish at the 25% patch rule

Top: a detector with fixed sensitivity and specificity, scored on tissue where artefacts cover a share π. The two curves are the benchmark's two scores, artefact Dice = 2TP/(2TP + FP + FN) and artefact-free Dice = 2TN/(2TN + FP + FN), as π changes. Nothing about the detector changes along the curves; only how rare the artefacts are.

Bottom: how a patch-level method is scored. A toy tissue region with a fold, an air bubble, an ink mark, two knife marks or scratches and some dust is cut into patches. A patch counts as artefact only if annotations cover more than a threshold share of it (25% in the paper). Solid colour marks artefact pixels that end up in an artefact patch. Grey marks artefact pixels that drop out of the patch-level ground truth altogether.

At π = 2% (log₁₀ π = −1.7), 80% sensitivity and 98% specificity give an artefact Dice of 0.58 and an artefact-free Dice of 0.99. The false positives are only 2% of the clean tissue, but that is as much area as the artefacts themselves. Slide π up to 20% and the same detector scores 0.85, so a ceiling below 0.6 on rare artefacts says as much about the metric as about the tools. In the slide, at 16-pixel patches and the 25% rule, the knife marks, scratch and dust all but vanish from the patch ground truth while the fold, bubble and ink survive. Patch-level scores are computed on an easier task.

W-PM-123 · DICOM series: a set encoder tells "missing" from "zero"; zero imputation cannot

Five DICOM tags of one slice, in a 2-D toy of the sparse metadata encoder. Each tag has a learned identity vector e_f (faint arrow). Its value v rescales and shifts that vector by FiLM, ẽ_f = e_f ⊙ (1 + α(v)) + β(v) (coloured arrow). The slice's metadata embedding is the mean over the tags that are present (blue dot). A missing tag simply drops out of the mean. For comparison, the orange square is a dense encoder that fills missing tags with 0 and applies a linear map, as in the concatenation baselines.

Pick a tag to compare. The hollow blue ring shows where the set encoder lands if that tag is missing, the small blue dot where it lands if the tag is present with value 0. For the dense encoder the two cases are the same input.

Choose "contrast agent" and read the two distances in the readout. The dense encoder cannot tell a missing tag from a present tag with value 0 (distance exactly 0), so imputation has to guess and the guess is baked in. The set encoder can, because a present tag still contributes its identity e_f even when its value is 0. Now switch pooling to sum and untick tags one by one. The embedding shrinks with the number of present tags. The mean discards that count, which is why the notes flag it: how many tags a vendor writes is itself a clue.

W-PM-139 · FunPiQ: the unbiased PU risk goes negative, and nnPU holds it at zero

A 1-D toy of EFIQA-CP's training problem. Each pixel has one feature x; think of it as how visible the vessels are. Bad-quality pixels (positives) sit on the left and good ones on the right. We get 40 labelled bad pixels (orange bars) and 400 unlabelled pixels (grey bars), a mix in which a share π is bad.

Rather than train a network, the widget shows what a flexible network is tempted to do. Start from the best possible classifier (the true posterior, dashed) and let it memorise the labelled pixels: add a narrow bump of height k to its logit at each one (blue curve). The bottom panel plots, against k, the three training objectives a network could minimise, each computed from the 40 + 400 training pixels, next to the true risk on fresh, correctly labelled pixels (black dashed). "PN" treats every unlabelled pixel as good. "uPU" is the unbiased PU risk π·R̂_p⁺ + R̂_u⁻ − π·R̂_p⁻. "nnPU" clamps its last two terms at zero, as in the paper's Eq. (1).

Slide the memorisation k up with narrow bumps. The classifier only grows more confident on the 40 labelled pixels, yet the uPU objective keeps falling and crosses zero before k = 1, a negative value no real loss can take. Meanwhile the true risk climbs from about 0.19 to 1.6 and the test error from 8% to about 16%. A flexible network minimising uPU is rewarded for exactly this memorisation. The nnPU objective can fall only to zero, so the reward runs out. Widen the bumps to 0.15 and the uPU objective rises instead: only narrow, memorising bumps fool it. Last, set k = 0 and switch to strict threshold. Even the best possible classifier now gets a negative uPU value, because the labelled positives are no longer a random sample of the bad pixels, and the correction π·R̂_p⁻ subtracts too much.

W-PM-194 · ICHOR: how much of masked reconstruction is plain interpolation

A 2-D stand-in for one slice of a CBF map: smooth perfusion blobs plus optional fine texture. It is cut into square patches, and a share ρ of them is hidden at random (grey), as in MAE pretraining. The third image fills the hidden patches with no learning at all, just a Gaussian-weighted average of the nearest visible pixels (normalised convolution). The readout compares that fill with the no-information guess, the mean of the visible pixels. The share of hidden-pixel variance that interpolation already explains is the part of the pretext task a network could solve by smoothness alone. The curve repeats the comparison for every masking ratio.

At ρ = 0.5 with smooth blobs, interpolation from the visible patches already explains most of the hidden-patch variance, so a large part of the pixel-MSE objective can be met by smoothing. Raise the fine texture and the share drops: what interpolation cannot explain is what the encoder actually has to learn. Push ρ towards 0.9 and interpolation fails too, because whole regions lose every visible neighbour. The paper's best downstream ratio, 0.5, sits where interpolation is still strong, which is one reason to ask how much of its pretext task is about perfusion patterns at all.

W-PM-212 · AC-MIL: CORN's products stay ordered, and attention cosine punishes flatness

Top: ordinal grading with four quality grades. CORN has three binary heads, and head k estimates a conditional probability f_k = P(grade > k | grade > k − 1). The cumulative probabilities are products, P(grade > k) = f₁·…·f_k, so they can only fall as k grows, and every grade probability (a difference of neighbours) is non-negative. Switch to "independent heads", where each head predicts P(grade > k) directly, to see what the product structure prevents.

Bottom: the spatial attention diversity penalty. Two concept heads spread attention over 32 patches (softmax of a bump, one map drawn up and one down). L_SAD penalises the cosine similarity of the two maps; the paper's evaluation reports their Jensen–Shannon divergence instead.

In the top panel, switch to independent heads and drag head 2's logit above head 1's. P(grade > 2) now exceeds P(grade > 1) and the probability of grade 2 goes negative, which CORN's chained products cannot produce whatever the logits. In the bottom panel, set both sharpness values to 0. Two uniform maps have cosine 1 even though neither attends to anything in particular, so L_SAD punishes flatness itself, not only overlap. Then sharpen them with the centres apart: the cosine falls towards 0 only once the two maps stop overlapping, while the JSD saturates at 1 bit.