SliderEdit++: Improved Slider Trajectories in Instruction-Based Image Editing

AI summary

Overview

Research area: Computer Vision — instruction-based (text-guided) image editing, specifically continuous “slider” control over edit strength.

Technical level: Intermediate. The paper assumes familiarity with diffusion / rectified-flow editing models, LoRA adapters, and velocity-field prediction, but its core idea (regularize the path between slider endpoints, not just the endpoints) is easy to grasp without that background.

Scope: The paper builds a benchmark (SlideBench) for measuring how smooth, monotonic, and disentangled slider-based edits are, and proposes a training method (SliderEdit++) that makes sliders behave far better while running roughly 3× to 20× faster than prior slider methods.

What This Paper Is About

Recent image editors can follow natural-language instructions, but they normally produce a single fixed edit, so users cannot dial an edit up or down gradually. “Slider” methods add that dial — a value from 0 to 1 that should continuously vary edit strength — yet in practice dragging the slider produces abrupt visual jumps, non-monotonic changes, and interference between multiple sliders. This paper first builds a rigorous benchmark to measure those failures, then proposes a training scheme that explicitly regularizes the intermediate slider trajectory so that equal slider steps produce equal, predictable visual changes.

Key Contributions

1. SlideBench, a benchmark for continuous image editing spanning 7 high-level categories (Lighting, Composition, Camera, Environment, Character, Style, Object) and 57 fine-grained subcategories with five samples each, totaling 285 samples. Each sample pairs a source image with an instruction defining a continuous transformation between two semantic endpoints.
2. A unified evaluation suite with three metric families: monotonic progression (pairwise VLM judgments of whether consecutive frames increase edit strength), perceptual continuity / frame uniformity (uniformity of feature-space distances between consecutive frames, weighted by overall edit strength), and multi-slider disentanglement (how much non-target attributes drift when one slider moves).
3. SliderEdit++, a training framework that regularizes the slider trajectory rather than only its endpoints, combining a velocity-space midpoint regularizer, a semantic (DINOv2) feature-space midpoint regularizer, a spectral-norm regularizer on the LoRA updates, and an orthogonality-based disentanglement objective for multi-slider settings.
4. State-of-the-art results on SlideBench: an 18.5% relative improvement in overall score over the strongest baseline, top performance in every SlideBench category, and roughly 3× to 20× faster operation than existing slider-based approaches.

Main Findings

• Existing sliders are not actually continuous. Baseline methods show large fluctuations in DINOv2 feature distance between consecutive slider positions, meaning a small change in slider value can cause a disproportionately large change in the generated image (e.g., a sudden hair-color transition).
• Overall score of 0.8116 versus 0.6847 for the strongest baseline. In Table 1, SliderEdit++ reaches an overall score of 0.8116, versus 0.6847 for the highest-scoring baseline (VeloEdit), corresponding to the reported +18.5% relative gain.
• Large gains on both metric families. Monotonic progression averages 0.7845 (GPT-5 judge 0.7801, Opus-4.8 judge 0.7890), and VLM-weighted frame uniformity averages 0.8386 (LPIPS 0.8272, CLIP 0.8431, SigLIP 0.8443, DINOv2 0.8399). Reported relative gains per column range from +10.3% (Opus-4.8 monotonic progression) to +26.7% (LPIPS uniformity).
• Best in every benchmark category. Figure 2 is reported as showing SliderEdit++ achieving the best performance in every SlideBench category, not just on average.
• Improved efficiency, not just quality. By using a few-step editing backbone, the method runs approximately 3× to 20× faster than existing slider-based approaches, giving the best performance–latency trade-off among compared methods.
• Every regularizer helps, and they are complementary. Ablation on the same backbone: baseline 0.7209 overall; + semantic regularizer 0.7851; + velocity regularizer 0.7726; + spectral regularizer 0.7692; all three together 0.8116.
• Multi-slider control improves substantially. Adding the disentanglement objective raises the multi-slider overall score from 0.7097 (SliderEdit) to 0.8811 (SliderEdit++), with disentanglement averaging 0.9869 (CLIP 0.9932, SigLIP 0.9957, BLIP 0.9719).
• Human raters agree with the automatic metrics. In a human study where annotators chose the smoothest and most edit-faithful sweep among randomized methods, SliderEdit++ outperformed all baselines by a substantial margin, and was significantly preferred over the baseline in a separate comparison of training strategies.
• Spectral regularization replaces early stopping. The original SliderEdit needed early stopping to keep sliders smooth; SliderEdit++ trains to convergence (1000 steps) while bounding adapter sensitivity to the slider value directly.
• Extends to localized editing. A masked latent-blending scheme (replacing out-of-mask latents with a re-noised source copy during the last k = 2 denoising steps) gives continuous control inside a user-specified region while preserving the rest of the image.

Methodology in Plain English

The starting point is SliderEdit, which attaches small low-rank adapters (LoRA) to a frozen image-editing model. At slider value α = 0 the adapter does nothing and the instruction is applied at full strength; at α = 1 the adapter is trained to fully suppress the instruction, pulling the model toward a neutral “keep the image the same” prompt. Sweeping α therefore sweeps from “fully edited” to “unchanged.”

The problem is that this training only pins down the two ends of the slider. Nothing constrains what happens in between, so two adapters with identical endpoints can behave wildly differently at α = 0.5, producing jumps.

The authors’ fix is to inject supervision at intermediate slider values:

• Velocity midpoint check. Sample two random slider values, compute their midpoint, and penalize any deviation between the model’s prediction at the midpoint and the average of its predictions at the two neighbors (with stop-gradients on the neighbors). Repeated everywhere in [0, 1], this pushes the slider response toward being affine — equal slider steps, equal output steps.
• Semantic midpoint check. The same idea, but applied after decoding the model’s one-step clean-image estimate and encoding it with a frozen DINOv2-L encoder. This catches discontinuities that are invisible in latent velocity space but visible on screen.
• Spectral-norm penalty. Penalize the squared spectral norm of each layer’s effective scaled update. Large per-layer operator norms are what turn a small α change into a switch-like jump; bounding them lets training run to convergence instead of relying on early stopping.
• Disentanglement penalty (multi-slider). For two different instructions, compute each one’s isolated effect direction (its velocity shift relative to the unsuppressed baseline) and penalize the absolute cosine similarity between them, pushing different sliders toward orthogonal directions.

Training combines these with the original suppression loss using weights λ_vel = 10.0, λ_sem = 1.0, λ_spec = 0.1, on a FLUX-Klein 4B backbone with rank-32 adapters at every linear layer, 1000 steps of Adam at learning rate 4×10⁻⁵ and global batch size 32 on 8×H100 GPUs. Inference uses a first-order Euler ODE solver with 8 denoising steps; each slider is rendered at 8 uniformly spaced positions and evaluated over the 285 benchmark samples. Baselines include KontinuousKontext, SDE-Edit, VeloEdit, the original SliderEdit, and a re-trained SliderEdit on the same Klein-4B backbone to isolate the effect of the regularizers. The excerpt does not report the size of the training set.

Why This Matters

Impact on research. Slider-based editing has been evaluated with method-specific datasets and ad-hoc metrics, which makes cross-paper comparison unreliable. SlideBench supplies a shared dataset and a metric suite that scores three distinct properties — monotonicity, continuity, and disentanglement — including a continuity score explicitly weighted by edit strength so that a “do-nothing” slider cannot score well by being trivially smooth. The paper also reframes slider quality as a trajectory-regularization problem rather than an endpoint-fitting problem, which is a transferable idea for any continuously parameterized adapter.

Real-world applications:

• Interactive photo editing tools where users drag a control to taste (lighting, time of day, smile intensity, saturation) instead of retyping prompts.
• Design and content-creation workflows needing gradual, repeatable variation of a concept across a series of assets.
• Region-specific retouching: the mask-conditioned extension lets a user dial an edit inside a selected area while leaving the surroundings untouched.
• Any latency-sensitive creative UI, where the reported 3×–20× speedup makes real-time dragging feasible rather than a batch operation.

Industry relevance. The work comes from Adobe Research with University of Maryland collaborators, and it targets precisely the failure mode that makes generative sliders feel unreliable in shipping products: a dial that jerks instead of gliding. Replacing early stopping with an explicit spectral constraint is also an operational win, since it converts a hand-tuned training heuristic into a principled objective.

Future Directions

• Richer disentanglement for many sliders. The orthogonality penalty is defined over pairs of effect directions; how it scales to larger sets of simultaneously active instructions, and whether pairwise orthogonality is sufficient, is left open.
• Beyond the evaluated backbone. All reported results use FLUX-Klein 4B with rank-32 adapters; whether the same regularizers transfer to other editing backbones (the paper cites FLUX-Kontext, Qwen-Image-Edit, FLUX.2, Nano Banana, and GPT-Image as context) is not established.
• Localized and compositional control. The mask-conditioned extension is demonstrated qualitatively with k = 2 blending steps; combining masks with multiple independent sliders, and quantifying localized control with the SlideBench metrics, remains future work.
• Metric validation at scale. The human study supports the automatic metrics, but broader validation of the VLM-judge-based monotonic progression and edit-strength weighting across more editing categories and annotator pools would strengthen confidence in the benchmark itself.

Target Audience

Researchers and engineers working on controllable generative image editing — particularly those building interactive tools on top of instruction-following diffusion or rectified-flow models. It is also useful for practitioners who need a ready-made evaluation protocol for continuous control (SlideBench and its metrics are usable independently of the proposed method), and for anyone studying parameter-efficient adaptation who wants a concrete example of why supervising only the endpoints of an adapter-scale sweep is insufficient. Readers without a generative-model background can still follow the problem framing, the metric design, and the empirical comparisons.

Authors’ abstract

Slider-based control aims to give users continuous, fine-grained control over the intensity of individual edits in instruction-based image editing. However, existing approaches fail to deliver reliable continuous controllability: traversing a slider can produce abrupt visual jumps and non-monotonic changes, while jointly controlled sliders can interfere with one another. To systematically study these limitations, we introduce SlideBench, a comprehensive benchmark for continuous image editing spanning diverse editing categories and equipped with a unified suite of metrics quantifying monotonic progression, perceptual continuity, and inter-slider disentanglement. Building on these observations, we propose SliderEdit++, which explicitly regularizes the intermediate editing trajectory rather than supervising only its endpoints. Our method combines velocity- and semantic-space trajectory regularization with spectral control to encourage smooth, predictable slider traversal, together with a disentanglement objective that reduces interference between independently controlled edits. On SlideBench, SliderEdit++ achieves state-of-the-art performance, improving the overall score by 18.5% relative to the strongest baseline. At the same time, using a few-step editing backbone makes our method approximately 3x to 20x faster than existing slider-based approaches, enabling substantially more responsive interactive editing.