Target-aware Image Editing via Cycle-consistent Constraints¶

Conference: ECCV2026
Paper: ECCV Paper
Code: https://github.com/HKUST-LongGroup/FlowCycle
Area: Image Generation
Keywords: target-aware editing, cycle consistency, flow matching, learnable noise, progressive sampling

TL;DR¶

FlowCycle makes the noise defining an editing starting point a per-image optimization variable and preserves unrelated content through dual consistency constraints over a source-to-target-to-source cycle, achieving lower Structure Distance and higher CLIP Score than FlowAlign on PIE-Bench at substantially greater editing time.

Background & Motivation¶

Text-guided image editing commonly corrupts an input into an intermediate noisy state and then restores it under a target prompt. ODE inversion seeks a starting point that reconstructs the source, whereas methods such as SDEdit directly add random noise; both face a shared difficulty when corruption does not account for the particular editing target. Replacing a cat with a tiger and changing bubbles into heart shapes require different content to become editable, yet restoration may start from the same intermediate state.

This choice leaves the difficulty to denoising: preserving too much source detail prevents new shapes from emerging, while excessive corruption changes the background and other objects. Injecting source attention, features, or velocity information during restoration can help, but does not directly resolve the mismatch between the starting point and the target. The paper therefore moves the problem earlier in the process: instead of asking only whether the entire source can be reconstructed, it seeks a state whose corruption is selective for the requested modification.

The source and an ideal edited image offer a symmetry: editing-relevant content should be interchangeable, while unrelated content should be shared. Even without a ground-truth target image, a candidate can be generated and edited back under the original prompt, allowing recovery of the source to test information preservation. Core Idea: jointly constrain source reconstruction after a round trip and alignment of the two noisy states, optimizing only two noises so that the current target determines which source information should be corrupted and which should be retained.

Method¶

Overall Architecture¶

The inputs are a source image, a source prompt, and a target prompt; the output is an edited image matching the target description. The method is named FlowCycle, which also appears as a prefix in the PDF title; this note retains the paper title supplied by the conference listing. It uses a pretrained text-to-image flow model without retraining its weights, optimizing source-side and target-side noises for the current image and prompt pair instead.

Each optimization round first runs source-to-target and then target-to-source: source noise corrupts the source image, which is restored under the target prompt to produce a candidate; target noise corrupts that candidate, which is restored under the source prompt to produce a recovery image. The two intermediate states and the two source-side images are then compared, and the noises are updated through back-propagation. Once optimization finishes, only the source noise is needed for one source-to-target restoration; the reverse branch is no longer required.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Source image + source prompt<br/>+ target prompt"] --> B["Bidirectional Learnable Noises<br/>Construct the editing cycle"]
    B --> C["Dual Cycle Consistency<br/>Update the noises"]
    C --> D["Progressive Sampling Schedule<br/>Control optimization cost"]
    D -->|Next optimization round| B
    C -->|Optimization complete| E["Source image + optimized source noise"]
    E --> F["Denoise under target prompt<br/>Output the edited image"]

The loop in the diagram provides supervision during per-image optimization; it is not a structure that must be repeated at final output time. The progressive sampling schedule determines how many sampling steps each of the two generation passes uses within an optimization round, without adding a network. The source prompt conditions reverse recovery, whereas the final forward edit remains controlled by the target prompt.

Key Designs¶

1. Bidirectional Learnable Noises: adapt corruption to the current target

Source noise is initialized from a standard Gaussian and linearly interpolated with the source image along the flow matching forward path, with the selected noise time controlling the mixture. Starting from this state, the pretrained model predicts velocities under the target prompt and progressively generates a candidate edit. Initially, this resembles direct corruption and restoration: the target object may already appear, but editing-irrelevant content can also change. The crucial difference is that the noise is no longer fixed after a single random draw; subsequent cycle errors can adjust it.

A second learnable noise then corrupts the candidate target at the same corruption level, producing a reverse intermediate state that is restored under the source prompt. The two noises serve different directions and need not be numerically identical; no external target image replaces the generated candidate. Target awareness arises through the complete conditional generation path: changing the target prompt changes the candidate, the cycle error, and ultimately the learned source noise. This is neither a universal source encoding shared by all editing requests nor an explicit edit-mask predictor that adds noise only within a mask.

2. Dual Cycle Consistency: constrain both a shared starting point and the recovered result

Checking only whether the final result returns to the source does not directly require compatible intermediate representations. FlowCycle therefore adds latent-space alignment: the corrupted source and the corrupted candidate target should be close. Intuitively, differences such as cat versus tiger should be weakened at the noisy level, while shared content such as a fish tank should remain on both sides. The complementary recovery constraint compares the recovered image with the original source, requiring retained information to support reconstruction rather than merely making two noisy tensors similar.

Both constraints use mean squared error. Their supervision is entirely internal to the current cycle: intermediate states align with each other, and the recovery aligns with the input source; there is no ground-truth edited target, segmentation annotation, or additional semantic discriminator. Target semantics primarily come from the frozen generator's text conditioning, while consistency constrains the use of source information. The main text also states that final restoration requires no additional source-condition injection. This is a mechanism supported by the authors' experiments, not a proof that cycle consistency necessarily discovers the true editing region or rules out conservative under-editing.

3. Progressive Sampling Schedule: reserve finer generation for later optimization

Every optimization round generates both a target and a recovery image, so the computational bottleneck is not the number of noise variables but the function evaluations along two denoising trajectories. Fine-grained sampling in every early round wastes computation while the noise is still far from a useful solution; increasing trajectory resolution later permits finer updates near convergence. The paper therefore increases sampling steps monotonically across optimization rounds rather than reducing the total number of rounds or replacing the generator with a smaller model.

The paper compares weak, medium, and strong schedules. The medium schedule grows linearly, while the weak and strong variants use different curves. These save different amounts of early sampling computation and consequently yield different time-quality trade-offs. The cached scheduling formulas contain damaged characters, so this note retains the reliable monotonic-growth mechanism and measured results without presenting reconstructed expressions as the authors' exact formulas. Scheduling affects optimization; final generation still starts from the source-side state produced by the optimized noise.

A Worked Example¶

Consider the white-dog example in Figure 7: the source prompt describes a white dog, and the target changes it to a husky. The first source-to-target generation may change the breed but also alter the background. Editing that candidate back under the white-dog prompt exposes information loss if its background cannot return to the source. Intermediate alignment additionally requires the two corrupted states to support a shared starting point rather than preserving incompatible animal details on each side.

After optimization, the learned source noise corrupts the original white-dog image again, and restoration under the husky prompt produces the output. The authors also reuse this state for a golden retriever, a lion, and a lion with a crown: similar animal replacements benefit, but optimizing separately for each target generally works better. This suggests some reuse potential, not that arbitrary new targets can skip optimization; adding a crown changes the content that needs to become editable.

Loss & Training¶

Here, “training” means test-time noise optimization; the pretrained generator remains frozen. To avoid reproducing cached equations with missing operators, the following expression uses note-specific names to summarize the MSE objectives explicitly described in the text, rather than reconstructing the original equation formatting:

\[ \mathcal{L}=\operatorname{MSE}(\mathrm{recovery},\mathrm{source})+\lambda\operatorname{MSE}(\mathrm{source\_state},\mathrm{target\_state}). \]

Both state terms are noisy latent states, and recovery is the result of the target-to-source branch; back-propagation updates only the two noises. This notation highlights the quantities compared by each error, without implying whether the implementation uses sum or mean normalization or any gradient stopping not specified in the main text.

The main experiments use SD-3-medium with 50 overall timesteps and a corruption position reported as step 33; 33 is a discrete sampling setting, not a value in the continuous flow matching time interval. Adam uses a learning rate of 0.1 for 100 optimization rounds, with alignment weight 0.2. Every new input and editing target incurs this optimization, so “no model fine-tuning” must not be confused with “no per-example optimization.”

Key Experimental Results¶

Main Results¶

PIE-Bench contains 700 source-image/source-prompt/target-prompt tuples covering nine editing types at 512 × 512 resolution. The other evaluation uses a DIV2K subset with over 70 real images and around 280 editing tuples at 1024 × 1024, with longer prompts that can contain multiple targets; DIV2K is not being used here as a super-resolution training set.

CLIP Score measures semantic agreement between the result and target text, with higher values preferred. Structure Distance assesses structural consistency with the source, with lower values preferred; it should not be interpreted as a pixel error rate. The table below excerpts the PIE-Bench evaluation in the paper's Table 1. Time is per-image editing time on a single A800-80GB. FlowAlign, iRFDS, and FlowCycle use the SD3 setup; Qwen-Image-Edit is a separate editing model, identified in the text as Qwen-Image-Edit-2509, not a shared-SD3-backbone ablation.

Method	Structure Distance ↓	CLIP Score ↑	Time (seconds) ↓	GPU Memory (GB) ↓
FlowAlign	0.028	25.28	4	16
Qwen-Image-Edit	0.054	25.20	92	60
iRFDS	0.069	25.12	132	34
FlowCycle	0.013	25.48	247	16

Compared with FlowAlign, full FlowCycle reduces Structure Distance from 0.028 to 0.013 and increases CLIP Score from 25.28 to 25.48, but increases time from 4 seconds to 247 seconds. Its advantage is a better editing-preservation trade-off in this evaluation, not real-time performance or superiority under an equal-time compute budget.

Ablation Study¶

The following sampling-schedule analysis comes from Table 1 and Section 4.3. It ablates acceleration strategies, not the removal of the two cycle losses. The dataset, hardware, and FlowCycle backbone match those above.

Config	Structure Distance ↓	CLIP Score ↑	Time (seconds) ↓	GPU Memory (GB) ↓
No acceleration	0.013	25.48	247	16
Weak acceleration	0.014	25.41	160	16
Medium acceleration	0.014	25.34	126	16
Strong acceleration	0.017	25.31	90	16

Strong acceleration reduces time from 247 seconds to 90 seconds, approximately a 2.74-fold speedup calculated from the table, at the cost of a 0.004 increase in Structure Distance and a 0.17 decrease in CLIP Score. It remains slower than FlowAlign, so the authors' cost advantage primarily concerns comparisons with iRFDS and Qwen-Image-Edit, not every baseline.

Key Findings¶

Figure 6 shows results at 0, 20, 60, and 100 rounds: target semantics often appear in the initial result, while later improvement mainly restores unrelated content. The cached paper does not include the corresponding quantitative appendix results, so no scores are inferred for these rounds.
Figure 7 shows that intermediate states transfer across similar edits, but per-target optimization works better. This supports dependence on the specific target rather than demonstrating a universal inversion encoding.
Figure 4 also compares an SD-1.5 implementation and DIV2K results. The cache preserves captions and textual conclusions but not reliably readable complete coordinates, so no additional exact values are reported.

Highlights & Insights¶

Moving optimization from model weights or prompts to corruption noise lets target requirements influence the editing starting point through cycle errors. This changes how source information enters generation rather than merely strengthening conditioning during denoising.
Noisy-state alignment and source recovery respectively check intermediate compatibility and recoverability of information. Together, they express the assumption of shared backgrounds and editable differences more explicitly than final reconstruction alone.
Sampling precision can be part of the test-time optimization budget. Coarse-to-fine scheduling leaves the optimization variables unchanged while substantially reducing repeated generation cost.

Limitations & Future Work¶

Acknowledged by the authors: per-image optimization is expensive relative to optimization-free methods. Even strong acceleration takes 90 seconds, far above FlowAlign's 4 seconds in the table.
Boundary shown by the authors: cross-target transfer is inferior to optimization for the new target, and the magnitude of deviation from the source affects reuse. It does not directly eliminate waiting time in multi-turn interactive editing.
Reader assessment: cycle consistency does not establish target-semantic correctness, and CLIP plus Structure Distance do not fully measure fine-grained changes or perceptual quality. Stronger validation would include target-region evaluation, human preferences, and independent ablation of both losses.
Evidence scope: the available cache contains the main paper and references, not the repeatedly cited appendix; complete hyperparameter curves, per-round quantitative results, and further implementation details cannot be verified from it. Early stopping and noise reuse are possible directions, but the paper does not quantify their benefits here.

vs SDEdit: both can corrupt an image and restore it under target text, but FlowCycle optimizes noise for the current target and adds supervision through returning to the source instead of relying on one random corruption.
vs FlowEdit / FlowAlign: these inversion-free methods offer faster editing routes; FlowCycle invests per-example optimization in the intermediate state to improve source preservation. Comparisons must include time rather than editing metrics alone.
vs classical cycle-consistency methods: the method does not train a domain translator on two image-domain datasets; it constructs a cycle between the current source and a generated target using a frozen text-conditioned generator. The transferable lesson is to exploit reversible tasks for self-supervision, while target conditioning still depends on the generative prior.

Rating¶

Novelty: 4/5. Target-aware corruption is implemented clearly through dual noises and dual consistency constraints.
Experimental Thoroughness: 3/5. Two evaluation resolutions and cost analysis are covered, but the available main paper cannot verify all appendix experiments.
Writing Quality: 4/5. Motivation and method connect clearly, although damaged cached equations limit exact implementation checks.
Value: 4/5. Relevant to fidelity-oriented offline editing, with per-image optimization still limiting interactive use.