betaFeedback

WorksComputer Science

Latent Fusion: Channel Stacking for Structure-Preserving Image Editing

Abstract

Instruction-based image editing models must condition on the source image, either by sequence concatenation, which appends source tokens to the target sequence (FLUX.1 Kontext), or by channel-wise concatenation, which stacks the source latent onto the noisy latent and widens the input projection (InstructPix2Pix, FLUX.1 Fill). The FLUX.1 Kontext report found channel-wise concatenation worse in initial experiments at 1K resolution with a 12B model and a large corpus. We explore channel-wise concatenation as the lower-cost option for a common production regime: structure-preserving edits that change appearance (sky, exposure, foliage, cleanup) but not layout, about 1,400 training pairs, a 4B non-distilled backbone, and 2K frames. It keeps the sequence at its original length, where sequence concatenation doubles it and roughly quadruples attention cost, and needs only single-scale classifier-free guidance (two forward passes per step instead of three). Starting from FLUX.2 Klein 4B base, we widen only the input projection and train both schemes with the same trainer, data, and hyperparameters. Channel-wise concatenation keeps the output pixel-aligned with the source; in our runs sequence concatenation, which must learn the correspondence between 10,880 target and 10,880 source tokens from fewer than 1,500 pairs, displaced structure, an observation we report without claiming a general ranking. On 29 held-out images the editor reaches 20.3 dB PSNR and 0.198 LPIPS against the human edit (unedited source: 15.0 dB), and counterfactual conditioning tests show it largely learned a global grade of the source rather than a selective edit, which we report as the open problem of this recipe. We also compare against an SD3.5-Medium editor trained with the same surgery and report the full training recipe, including failure modes. Code: https://github.com/complete-dope/LatentFusion

Introduction

Instruction-based image editing [1] has become a standard application of generative models: given a source image and an instruction, a conditional diffusion model produces the edited image with no per-image optimisation. Most benchmarks in this area reward content-changing edits, where the instruction asks for new objects or a rearranged scene and some deviation from the source is acceptable. In many production settings, however, the edit is conservative. A photograph is submitted, and the expected output is the same photograph with a replaced sky, a corrected exposure, healthier foliage, or a distraction removed. The buildings, streets, furniture, and people must remain pixel-aligned with the source, because the result is inspected side by side with the original and any drift is a defect. The two settings place different demands on how the source image is fed to the network.

Transformer-based editors condition on the source image in one of two ways. FLUX.1 Kontext [2] and most recent editors use sequence concatenation: the source-image tokens are appended to the target sequence and distinguished by a positional offset. This design lets the network read the source from any position, which suits content generation, but the correspondence between source and target tokens must be learned through attention, and the sequence length doubles. InstructPix2Pix [1] and FLUX.1 Fill [3] instead use channel-wise concatenation: the source latent is stacked onto the noisy latent along the channel dimension and the first layer of the network is widened. Each token then carries its own source content, the sequence length is unchanged, and the source-target correspondence is fixed by construction. The Kontext report notes that channel-wise concatenation performed worse in their initial experiments, conducted at 1K resolution with a 12B model and a large editing corpus.

In this work we explore channel-wise concatenation on a Flux backbone as the lower-cost conditioning for the structure-preserving regime, and we call the resulting channel-stacked editor LATENT FUSION. The motivation is cost, not a rejection of sequence concatenation: channel-wise concatenation keeps the sequence at LL tokens where sequence concatenation needs 2L2L, so attention cost stays that of the base model, and at inference it needs only standard classifier-free guidance, two forward passes per step, where the InstructPix2Pix two-scale guidance needs three (§ 3.3). Our setting differs from the Kontext comparison on every axis: the edit must leave structure and identity intact, the training set consists of 1,398 pairs from a single professional workflow, the backbone is the 4B non-distilled FLUX.2 Klein base model [4], and the frames are 2048×13602048 \times1360, i.e. 10,880 image tokens. We implement both conditioning schemes in the same trainer and train both on identical data with identical hyperparameters. We observe that channel-wise concatenation preserves object placement and scene structure and changes appearance without moving anything. In our run of sequence concatenation, with the same backbone and data, the source content itself moved: objects shifted and structure was regenerated rather than preserved, so the output was no longer registered to the source (§ 5). We report this as what we saw on this data with a single run of each scheme, not as evidence that sequence concatenation is the weaker design on Flux.

Our contributions are as follows:

  • A recipe for adapting the FLUX.2 Klein 4B base model into a paired editor with channel-wise concatenation conditioning: only the input projection is widened, its new half is zero-initialised and the layer is trained with its own learning rate, and training mixes native-resolution crops with downscaled whole frames under conditioning dropout. All hyperparameters are reported (§ 3).

  • A matched comparison of channel-wise concatenation against sequence concatenation on the same backbone, data, and hyperparameters in the structure-preserving regime, by inspection of held-out outputs, with full-frame metrics against human reference edits for the channel-wise editor, together with the compute and guidance cost of the two schemes (§ 3.3 and § 5).

  • A comparison against an SD3.5-Medium editor trained with the same surgery at the same resolution, and an analysis of what the widened input layer learned, counterfactual conditioning tests that expose copying rather than editing, and a cross-architecture control on SD3-Medium (§ 6).

  • A record of the training failures we encountered and how each was diagnosed (Section A).

Code for the trainer, both conditioning paths, the sampler and the evaluation scripts is released in the LATENT FUSION repository.

Channel-wise concatenation on a Flux backbone is not new; FLUX.1 Fill uses it for inpainting. Our claim is narrower and concerns the regime: when the edit must preserve the source and paired data are scarce, fixing the source-target correspondence by construction is enough to obtain a working editor at the token count and attention cost of the base model, with two-pass guidance rather than the three-pass InstructPix2Pix scheme, and without the doubled sequence that sequence concatenation requires.

Related Work

Instruction-based and paired image editing. Paired-edit models differ mainly in how the source image enters the network. InstructPix2Pix [1] concatenates the clean source latent to the noisy latent along the channel axis and widens the first convolution of a Stable Diffusion 1.5 U-Net; MagicBrush [5] fine-tunes that same InstructPix2Pix model on human-annotated triplets. Emu Edit [6] uses the same channel-concatenation surgery on Meta’s Emu backbone, adding input channels with zero-initialised weights, and supervises it with task embeddings. UltraEdit [7] scales the data to roughly 4M triplets and trains a channel-concatenation editor on SD3.

FLUX.1 Fill [3] applies the same construction to the 12B FLUX.1 rectified-flow transformer [8], concatenating a masked image and a binary mask for inpainting. The alternative is to append the conditioning image as extra tokens. FLUX.1 Kontext [2] appends the source-image tokens to the target sequence inside FLUX.1, and tells the two apart by offsetting their 3D RoPE positions rather than by any extra input channel; its report states that channel concatenation was the weaker of the two in their early experiments. IЦEdit [9] builds an in-context editor on FLUX.1 Fill with LoRA [10], and OmniGen [11] embeds image patches as visual tokens in a single Phi-3-initialised transformer with the SDXL VAE. Step1X-Edit [12] pairs an MLLM with a DiT decoder, Qwen-Image-Edit [13] conditions its own MMDiT on both semantic and reconstructive image encodings, and BAGEL [14] uses a Qwen2.5-initialised mixture-of-transformer-experts over FLUX VAE latents. DiT-VTON [15] compares token concatenation, channel concatenation and ControlNet conditioning, but only for virtual try-on and on an undisclosed DiT. The two conditioning schemes have not, to our knowledge, been compared for paired editing on a common Flux backbone under matched data and hyperparameters.

Why the regime matters. The Kontext comparison was made with the resources of a large lab: a 12B model and a corpus large enough to learn any correspondence attention needs. Under sequence concatenation the correspondence between a target token and its source token is not given to the network; it has to be learned from data, through attention, over a sequence twice as long. Under channel concatenation it is fixed by construction. Which of the two is better should therefore depend on how much data there is to learn the correspondence from, and on whether the task even wants a free correspondence. Content-changing edits do; structure-preserving edits do not. The two also differ in cost: sequence concatenation doubles the token count, and the InstructPix2Pix guidance scheme usually paired with channel concatenation costs three passes per step where a single text guidance scale costs two. None of the works above vary these factors while holding the backbone fixed. We do.

Backbone. Rectified-flow transformers [16, 17, 18] with rotary position embeddings [19] are the current standard for image generation; DiT [20] fixed the patch-token layout they use. FLUX.2 Klein 4B [4] is a small member of this family, released in both a distilled and a non-distilled (base) form. We use the base form; our distilled-checkpoint runs are reported as indicative only.

Positioning. We train InstructPix2Pix-style channel-concatenation conditioning on a non-distilled FLUX.2 Klein 4B base model for structure-preserving paired editing at 2048×13602048 \times1360, on about 1,400 pairs, and compare it against sequence-concatenation conditioning on the same backbone, data and hyperparameters, and against an SD3.5-Medium editor with the same surgery. We present channel concatenation as the cheaper of the two schemes for this regime, not as a replacement for sequence concatenation in general.

Method

Problem

Given a source photograph IsI_s and a tag prompt pp, produce the edited photograph IeI_e at 2048×13602048 \times1360. Training pairs (Is,Ie,p)(I_s, I_e, p) come from a professional editing workflow; IeI_e is a human-finished edit of IsI_s, so the two are pixel-aligned, and the edit changes appearance (sky, exposure, foliage, cleanup) but not the layout or identity of what is in the frame. This is the InstructPix2Pix setting [1] with paired supervision, restricted to structure-preserving edits.

Backbone

We use FLUX.2 Klein 4B base, the non-distilled checkpoint [4]. It is a rectified-flow transformer with 5 double-stream and 20 single-stream blocks, hidden size 3072, and 24 attention heads. Positions are encoded with rotary embeddings over four axes [19]. The text encoder is a frozen Qwen3-4B. The VAE shrinks the image by 8×8\times in each direction and produces 32 channels. Each 2×22 \times2 block of latent pixels is then folded into one token, so a token covers a 16×1616 \times16 pixel block and has 128 channels. A 2048×13602048 \times1360 frame is 128×85=10,880128 \times85 = 10{,}880 image tokens.

We first tried the distilled Klein 4B checkpoint, at 512 pixels with LoRA and without channel concatenation; its edits did not meet our fidelity bar. § 6 reports those runs as indicative only; no matched comparison exists. All results below use the base checkpoint.

Two ways to condition on the source

Let x0∈RL×128x_0 \in\mathbb{R}^{L \times128} be the token sequence of the edited image IeI_e and c∈RL×128c \in\mathbb{R}^{L \times128} that of the source image IsI_s, both normalised with the VAE’s stored per-channel mean and variance, with L=10,880L = 10{,}880.

Channel concatenation (ours). The only change to the network is to its first layer, the input projection xembedderx_{\mathrm{embedder}}. It is a linear layer without bias, W∈R3072×128W \in\mathbb{R}^{3072 \times128}. We replace it with W′∈R3072×256W' \in\mathbb{R}^{3072 \times256},

W′=[W 0],(1)W' = [W\ 0], \tag*{(1)}

that is, the pretrained weights are kept and the new half is set to zero. At the start of training the model therefore ignores cc and behaves exactly like the pretrained one. Each input token is the noisy token stacked with its source token, [xt∥c][x_t \mathbin{\|} c]. The number of tokens does not change, the output layer does not change and still predicts 128 channels, and cc is never noised. Token ii of the input holds the source pixels of exactly the 16×1616 \times16 block it will predict; the correspondence between source and target is fixed by construction and costs no attention. InstructPix2Pix does the same thing on a U-Net and FLUX.1 Fill does it on a Flux transformer for inpainting; we apply it to paired editing on the base model.

Sequence concatenation (reference scheme). The alternative, used by FLUX.1 Kontext [2] and most recent transformer editors, leaves the input projection unchanged and appends the tokens of cc after those of xtx_t, giving a sequence of 2L=21,7602L = 21{,}760 tokens. The source tokens receive the same spatial positions as their target counterparts and an offset on a non-spatial RoPE axis, so the two images can be told apart. The network reads the source through attention: every target token can attend to every source token, and it has to learn from data that the useful one is the token at its own position. Only the LL target positions are supervised; the source positions produce outputs that are discarded. The Kontext report states that channel-wise concatenation performed worse than sequence concatenation in their initial experiments, at 1K resolution with a 12B model and a large edit corpus. We implement both schemes in the same trainer, behind a single flag, and everything else in this section applies to both.

Cost. With LL image tokens, channel-wise concatenation leaves the sequence at LL and widens only the input projection, so attention cost, which grows as L2L^2, activation memory and step time stay those of the base model. Sequence concatenation doubles the sequence to 2L2L, or (k+1)L(k+1)L for kk reference images: attention FLOPs per layer rise about four times and the linear layers twice, so a step costs roughly two to four times the compute and activation memory. Here L=10,880L = 10{,}880. Guidance adds a second axis of cost, discussed below: channel-wise concatenation with a single text guidance scale needs two forward passes per sampling step, while the InstructPix2Pix two-scale scheme needs three.

Training objective

We use the standard rectified-flow objective [16, 17, 18]: the network predicts the straight-line velocity from noise to the clean image. With noise ϵ∼N(0,I)\epsilon\sim\mathcal{N}(0, I) and noise level σt∈(0,1]\sigma_t \in(0,1],

xt=(1−σt)x0+σtϵ,(2)x_t = (1-\sigma_t)x_0 + \sigma_t\epsilon, \tag*{(2)}
L=Et,ϵ∥vθ(xt,c,t,Ep)−(ϵ−x0)∥22,(3)\mathcal{L} = \mathbb{E}_{t,\epsilon}\left\|v_\theta(x_t,c,t,E_p) - (\epsilon-x_0)\right\|_2^2, \tag*{(3)}

where vθ(xt,c,⋅)v_\theta(x_t,c,\cdot) is vθ([xt∥c],⋅)v_\theta([x_t \mathbin{\|} c],\cdot) under channel concatenation and the first LL outputs of vθ([xt;c],⋅)v_\theta([x_t;c],\cdot) under sequence concatenation. EpE_p is the prompt embedding. Noise levels are drawn uniformly from the checkpoint’s schedule and every level is weighted equally. Following InstructPix2Pix, we sometimes hide the conditioning during training, with q=0.05q = 0.05: with probability qq the text is replaced by the empty prompt, with probability qq the source image is zeroed, and with probability qq both are. This makes it possible to use two separate guidance scales at inference,

v~=v(∅,∅)+gi[v(c,∅)−v(∅,∅)]+gt[v(c,p)−v(c,∅)],(4)\tilde{v}=v(\varnothing,\varnothing)+g_i[v(c,\varnothing)-v(\varnothing,\varnothing)]+g_t[v(c,p)-v(c,\varnothing)], \tag*{(4)}

where gig_i controls how strongly the output follows the source image and gtg_t how strongly it follows the text, at the cost of three forward passes per step. Because the source enters through the input channels and is never noised, the image term is not needed to keep the output on the source; dropping it and keeping a single text scale gt>1g_t > 1 reduces Eq. (4) to standard classifier-free guidance, v~=v(c,∅)+gt[v(c,p)−v(c,∅)]\tilde{v} = v(c, \varnothing) + g_t[v(c,p) - v(c,\varnothing)], at two passes per step. Our SD3.5-M baseline uses the three-pass form of Eq. (4). The Flux editors reported here use neither: Klein 4B has no guidance embedding, and our sampler runs one conditional pass per step; no unconditional or image-only pass is computed, so every output of the main run is unguided (the follow-up’s held-out scoring in § 6 is the exception).

Data pipeline and resolution

Each training pair is stored at 4096×27284096 \times2728. At every step, with probability 0.5 we cut a random 2048×13602048 \times1360 window out of the frame at full pixel scale; otherwise we shrink the whole frame by exactly 2×2\times to 2048×13642048 \times1364 and trim 4 rows to reach 2048×13602048 \times1360. The source and the edit get the same cut, so their tokens stay aligned pixel for pixel, and window offsets are multiples of the 16-pixel token size. The network therefore sees fine detail at native scale in half of its steps and the whole layout in the other half, always as 10,880 tokens. We do not flip images horizontally.

Optimisation

We fine-tune every weight of the transformer; the VAE and text encoder stay frozen. The optimiser is AdamW with β=(0.9,0.999)\beta= (0.9, 0.999) and weight decay 10−410^{-4}. The learning rate is 10−510^{-5} for the transformer body and 10−310^{-3} for the widened input layer, because its new half starts at zero and has to grow. The rate warms up over 400 steps and then follows a cosine decay over 20,000 steps. Gradients are clipped at norm 1.0. Each of 3 H100-80GB GPUs processes 8 crops per micro-batch and accumulates 3 micro-batches per update, for 72 crops per optimiser step. Compute runs in bf16 with fp32 master weights, and the model is sharded across GPUs with FSDP. The sequence concatenation run uses the same settings with the conditioning flag flipped; its input projection is not widened, so it has no separate learning-rate group. The channel-wise concatenation model was trained for 20,000 steps on 3 H100-80GB GPUs. At 41 s per optimiser step this is about 230 hours of wall-clock time, or roughly 680 GPU-hours. No training log survives for the sequence concatenation run, so its step count and wall time are not reported (§ 7).

Inference

At inference the 2048×13602048 \times1360 source is encoded once into cc and the output is denoised in a single pass with N=28N = 28 Euler steps, the noise level going from 1 down to 1/N1/N, and the checkpoint’s schedule shift at its value for L=10,880L = 10{,}880. Under channel concatenation the sequence is LL tokens per step; under sequence concatenation it is 2L2L, so each step costs about four times the attention compute and twice the rest (§ 3.3).

Experiments

Data

The dataset has 1,427 training pairs and a 24-pair test split from one professional editing workflow. We hold out 2% of the training pairs (29, fixed seed) for evaluation and train on the remaining 1,398; the test split is not trained on and supplies the pairs for the counterfactual tests in § 6.1. Each pair is a raw capture and its human-finished edit (sky, ground and foliage, exposure and white balance, structural cleanup). All frames are landscape. 180 training pairs were edited entirely by hand, without any AI tool; the remaining edits were AI-assisted and human-finished. Source frames are 4096×27284096 \times2728; the model trains on 2048×13602048 \times1360 windows and 2×2\times downscaled frames (§ 3.5). Prompts are short tag lists naming the target attributes rather than free-form instructions, of the form clear sky, balanced exposure, green foliage; the four tags in the data cover sky, exposure, foliage and structure, and the tag vocabulary itself is not released with the data.

Held-out evaluation set

The held-out set is the 2% split above: 29 pairs drawn with a fixed seed and excluded from training. Each pair is evaluated at 2048×13602048 \times1360 from a 2×2\times downscale of the source, with one output per image, 28 sampling steps, and the seed set to the image index.1 Each has a human ground-truth edit. Metrics on this set for every saved checkpoint are in Table 2 and Figure 3.

StepPSNR↑LPIPS↓ρ\rho
2,00018.430.2271.06
5,00019.970.2061.20
10,00020.300.2021.29
15,00020.250.1991.31
19,50020.290.1981.31

Table 2. OURS on the 29 held-out images at selected checkpoints, mean over images. ρ\rho is the conditioning-weight ratio of § 6. All 36 checkpoints are plotted in Figure 3.

Figure 3. OURS on the 29 held-out images at every checkpoint (every 500 steps). Left: PSNR against the human edit. Middle: LPIPS. Right: the weight ratio ρ\rho of the widened input projection. Both metrics plateau by step 10,000; ρ\rho saturates at 1.31 by step 14,500.

Metrics

We report PSNR, SSIM, and LPIPS [21] between each output and the human edit over the whole frame.

Baselines

  • Source (no edit). The unedited source, as a floor for every metric.

  • SD3.5-M IP2P. An SD3.5-M editor with the same channel-concatenation surgery, trained at 2048×13602048 \times1360 on the same data.

  • Klein 4B base, sequence concatenation. The same trainer, data and hyperparameters as ours, with the source appended as tokens (§ 3.3).

  • Klein 4B base, pretrained sequence concatenation path. The pretrained model, no fine-tuning, driven by a natural-language instruction through its own image-conditioning path, with an image-guidance sweep on one frame (§ 5).

  • Ours. FLUX.2 Klein 4B base, channel-wise concatenation.

Held-out metrics are reported for OURS and the source; the other three are compared qualitatively in § 5. The distilled-checkpoint variant and the recipe ablations are reported in § 6.

Implementation

Our model’s training settings are in § 3. The SD3.5-Medium baseline is a full fine-tune with the same channel-stacking change, on 16-channel latents (16 noisy + 16 source). It uses logit-normal noise-level sampling, learning rate 10−510^{-5}, batch 1 with 4 accumulation steps, 500 warmup steps, and 20,000 steps in bf16; it took 38.4 hours on 3 RTX PRO 6000 GPUs. It is sampled with Eq. (4) at gt=2.4g_t = 2.4, gi=1.4g_i = 1.4; these values were fixed by hand and not swept on this checkpoint. A sweep on a separate 4K SD3.5-M checkpoint preferred gi=1.2g_i = 1.2 by about 0.2 dB, so the baseline may be slightly under-tuned.

Results

Channel against sequence concatenation. We trained both conditioning schemes on the same data with the same trainer and hyperparameters and compared their outputs on held-out images by inspection at 100% zoom. With sequence concatenation the source content itself moved: objects shifted and structure was rebuilt rather than kept, so the output no longer registered against the source pixel for pixel. With channel-wise concatenation the appearance changed and everything held its position, which is what the task needs, since the human reference edit is pixel-aligned with the source. The sequence-concatenation model was not scored on the held-out set, so Table 1 reports metrics for OURS alone; the comparison between the two schemes rests on this visual inspection of one run each. We do not read it as a rejection of sequence concatenation on Flux, which remains the established design for content-changing edits; the point of this paper is that channel-wise concatenation, at the token count and guidance cost of the base model, is sufficient for the structure-preserving case. On the 29 held-out images OURS reaches 20.3 dB PSNR, 0.720 SSIM and 0.198 LPIPS against the human edit, where the unedited source scores 15.0 dB and 0.553 SSIM; PSNR improves over the source on 28 of the 29 images. Figure 2 shows the three images at the quartiles of PSNR. The gain over the source is largely a global grade: sky, exposure and foliage move toward the human edit across the frame, and the structure of the scene is untouched. The counterfactual tests in § 6.1 show that this is also the limit of what the model learned; it reproduces the source it is handed and grades it, rather than reading the source and changing it selectively.

MethodPSNR↑SSIM↑LPIPS↓
Source (no edit)14.98 ± 1.970.553 ± 0.193–
OURS (Klein 4B base, channel-wise concatenation)20.29 ± 3.020.720 ± 0.1430.198 ± 0.050

Table 1. Held-out set (29 images) at 2048 × 1360, OURS at step 19,500. Full-frame metrics against the human edit, mean ± std over images. The source row is the unedited input; its LPIPS was not computed.

Held-out results at step 19,500

Figure 2. Held-out results at step 19,500. Columns: source, Ours, human edit. Rows are the held-out images at the 25th, 50th and 75th percentile of PSNR, not hand-picked. The edits change sky, exposure and foliage; buildings, roads, fences and furniture stay in place. Frames are downscaled from 2048 × 1360.

Held-out metrics over training. Table 2 and Figure 3 track the held-out set across the 36 checkpoints. PSNR rises from 18.4 dB at step 2,000 to 20.3 dB at step 10,000 and LPIPS falls from 0.227 to 0.202; both are flat over the second half of training, as is the training loss (0.568 averaged over steps 9,500–10,500, 0.564 over the last 1,000 steps), and ρ\rho stops growing at 1.31. The model does not overfit the held-out set, and the second half of training buys about 0.004 LPIPS.

The pretrained sequence concatenation path. Klein 4B base ships with a sequence concatenation editing path of its own, so we also ran the pretrained model without fine-tuning on one 2048 × 1360 frame, with a natural-language instruction to keep the scene unchanged and brighten it, sweeping the image-guidance scale over 1, 5 and 10 at text guidance 4 and 50 steps (Figure 1). This frame is not in the held-out set and has no human reference, so we measure only how far each output departs from its source. At image guidance 1 the output is essentially a new render in the same layout: 8.3 dB PSNR and 0.43 SSIM against the source, with saturated colour across the frame. At 5 and 10 the output stays registered to the source, with 24.4 and 19.9 dB PSNR and 0.88 and 0.73 SSIM against it, and phase correlation on nine 256 × 256 patches measures no shift at either scale; the edit is a mild global brightening. The pretrained path therefore preserves structure once image guidance is high enough, at the cost of three forward passes per step over 2L2L tokens, and it does not perform the domain-specific edit that the paired data encode. The structural drift we observed under sequence concatenation (previous paragraph) was in the fine-tuned run, not in the pretrained path.

Four-column comparison of source and edited aerial images, with boxed-region crops below

Figure 1. The pretrained Klein 4B base model through its own sequence concatenation editing path, without fine-tuning, on one 2048 × 1360 frame with the instruction to keep the scene unchanged and brighten, white-balance and add contrast. Columns: source, then image-guidance scale 1, 5 and 10 at text guidance 4, 50 steps, seed 0. Bottom row: the boxed region at 100%. At scale 1 the source is largely ignored and the colours blow out; at 5 and 10 the output is pixel-registered to the source and the edit is a mild brightening.

Against the SD3.5-Medium editor. The SD3.5-Medium editor with the same surgery (16-channel latent, 2.5B MMDiT) produced edits of comparable quality to OURS on this data; we did not find a consistent gap between the two on inspection, and we did not score it on the held-out set. We chose Klein over SD3.5-Medium for its position encoding rather than for quality: SD3.5-Medium adds a fixed-size two-dimensional sinusoidal position table to its patches [16], which caps the token grid it can address, whereas Klein encodes position with rotary embeddings that extend to any grid, so the same weights serve the 2048 × 1360 frames here and larger ones later.

Ablations

Each row of Table 3 is a single training run; we did not repeat runs with different seeds. Run identifiers are recorded in the source comments.

Table 3: Subset runs on FLUX.2 Klein 4B: 16 training pairs, 4 validation pairs; base runs evaluated every 250 steps at 2048 × 1360, the distilled run every 100 steps at 512. Steps is the last evaluated step. Best validation PSNR (dB) and LPIPS over training with the step at which each occurred; ρ\rho is the final ratio of mean absolute weight in the conditioning half of the input projection to the pretrained half. Distilled rows use a different resolution and are indicative only.

CheckpointRecipeRes.StepsPSNR↑ @stepLPIPS↓ @stepρ\rho
distilledLoRA, no concat, lr 10−410^{-4}5123,90017.23 31000.366 1300—
basechannel-wise concatenation, full FT (A)20484,75017.32 10000.332 12501.97
basechannel-wise concatenation, full FT (B, resumed from A)20489,25017.22 90000.339 67502.36
basechannel-wise concatenation, full FT, crops 0.5, dropout 0.0520485,50017.87 20000.317 35001.23

Table 3.

Distilled vs base. The existing distilled runs are 512 px, LoRA rank 4, without channel concatenation, so they are not a matched pair with the base run; Table 3 reports them as indicative only. The fidelity failure we saw with the distilled checkpoint was on one crop, before any of the recipe was in place.

Sanity checks on a 20-image subset. Before the full run we trained on 16 pairs and held out 4, evaluating the base runs every 250 steps at 2048 × 1360 with 28 sampling steps (Table 3, Figure 4 and Figure 5). Three things are visible at this scale. First, the widened layer is used. We track ρ\rho, the mean absolute weight of the new source half of the input layer divided by that of the pretrained half. It starts at 0, passes 1 between steps 1,250 and 2,500 in every base run, and passes 2 by step 5,000 in the longest run (B). Second, training half the time on native-resolution crops, together with conditioning dropout, gives the best validation PSNR and LPIPS of any subset run: 0.55 dB and 0.015 LPIPS better than run A, which trained on whole frames only and also used a constant learning rate instead of warmup and cosine decay, so the two differ in schedule as well as in crops. Third, in every base run validation PSNR peaks within the first 2K steps from the pretrained weights and is flat or falling afterwards, while the training loss keeps dropping (Figure 4d). Under crops the training loss stays about five times higher than on whole frames by step 5,000 (0.60 against 0.12, 50-step mean), because half the steps see random windows the model cannot memorise.

Figure 4. Subset runs (Table 3), validation metrics every 250 steps and training loss, cut to the first 5,500 steps, the length of the crops run. (a) PSNR of every base run peaks within the first 2K steps from the pretrained weights and does not improve after. (b) LPIPS. (c) The conditioning-weight ratio ρ\rho starts at zero and passes 1 (thin line) between 1,250 and 2,500 steps, so the widened projection is used; runs without crops keep pushing ρ\rho up while validation quality is flat. The base curve is run A continued by run B from A’s checkpoint at step 4,750 (dotted line). The distilled 512 px run is dashed grey, indicative only, and has no ρ\rho because its input layer is not widened. (d) Training loss, 50-step running mean: crops and dropout keep it high while whole-frame training memorises the 16 pairs; the crops run also uses warmup and cosine decay, which would lower the loss rather than raise it. Run B beyond step 5,500 is in Table 3.

Two validation pairs showing source, human edit, and output

Figure 5. Two of the four validation pairs of the subset run with crops, at its best-PSNR step (2000). Each row: source, human edit, our output, downscaled from 2048 × 1360. The edit is sky and exposure; structure is preserved.

model cannot memorise. (Run B continues from A’s checkpoint and never beats A’s peak.) On 16 pairs the model memorises rather than generalises, so we do not read these numbers as a measure of editing quality. The distilled checkpoint at 512 pixels reaches a lower training loss than the base runs (median of the last 200 micro-batches 0.009, against 0.014 and 0.034) with no better validation PSNR.

What the widened input layer learned

The recipe’s only architectural change is the widened input projection W′=[Wpre  Wcond]W' = [W_{\mathrm{pre}}\; W_{\mathrm{cond}}], so we ask what its new half learned and what the change cost the pretrained half. Table 4 inspects three editors: the main channel-wise concatenation run (§ 3), a follow-up channel-wise concatenation run from the same base that restricts the higher learning rate (10−410^{-4}) to the new half, leaves the pretrained half at the body rate, and weights the loss on changed regions three times (its role in the copying test is described below), and, as a cross-architecture control, an SD3-Medium (2B) editor trained with the same surgery at the same resolution; this is a separate checkpoint from the SD3.5-Medium baseline of § 4. Three quantities are reported: the Frobenius norm of WcondW_{\mathrm{cond}} relative to WpreW_{\mathrm{pre}}, the fraction of WcondW_{\mathrm{cond}} that lies outside the column space of WpreW_{\mathrm{pre}}, and the relative drift of the pretrained weights from the base checkpoint. The effective rank of WcondW_{\mathrm{cond}} is 117 of 128 in the main run and 119 in the follow-up run.

EditorRatioOutsideDrift WpreW_{\mathrm{pre}}Drift body
Klein, main run, step 17K1.1097%87%2–4%
Klein, follow-up, step 1.5K0.5399%13%7–9%
SD3-M control, step 10.2K1.1699%27%25–45%

Table 4. The input projection after training. Ratio: ∥Wcond∥F/∥Wpre∥F\lVert W_{\mathrm{cond}}\rVert_F/\lVert W_{\mathrm{pre}}\rVert_F. Outside: fraction of WcondW_{\mathrm{cond}} outside the column space of WpreW_{\mathrm{pre}}. Drift: relative change of the pretrained input half and of the transformer body from the base checkpoint. For the main run the abs-mean ratio ρ\rho of Table 2 is 1.31 at this checkpoint; the Frobenius ratio here is 1.10.

In the main run the new half is as large as the pretrained half, spans nearly the full 128 dimensions (rank 117), and lies almost entirely outside the pretrained column space: the network built a separate reading path for the source rather than a scaled copy of the noise path. Every one of the 32 VAE channels is read with similar strength: the column norms of the new half span 3.2 to 5.1 against 3.2 to 4.3 for the pretrained half, and none is near zero.

Copying versus editing. Having a separate reading path does not by itself mean the source is used to edit. We test this with counterfactual conditioning on held-out pairs: the flow-matching loss at fixed noise levels with the true source, with zeros, and with the target itself in the conditioning channels. Averaged over three pairs, loss with the source is lower than with zeros only at the highest noise level (σ=0.95\sigma= 0.95: 0.54 against 0.83); at σ≤0.7\sigma\le0.7 the source is worse than zeros (at σ=0.5\sigma= 0.5: 0.96 against 0.77), while the target in the conditioning channels lowers the loss two and a half to five times relative to zeros over σ=0.3\sigma= 0.3 to 0.7 (0.19 at σ=0.5\sigma= 0.5).

The follow-up run of Table 4, which weights the changed-region loss three times and uses the separate input-layer learning rate, does not fix it. At steps 3,000 and 5,000 of that run the changed-region loss with the source remains above the loss

with zeros (0.978 against 0.910, and 0.976 against 0.915; the main run at step 19,500 gives 0.988 against 0.901), the pull toward the source is unchanged (cosine 0.26, 0.24, 0.27), and the prompt still moves the output by under 4%. Reweighting the loss makes the model copy slightly less blindly (loss with the target in the conditioning channels 0.41–0.43 against 0.33) without converting that into the edit. We report this as a negative result. Its checkpoints were also scored on the held-out set, but with text guidance 4 and image guidance 1.5, unlike every other Flux number in this paper, so we do not compare them to Figure 3. A second follow-up with a higher learning rate, flips

and photometric augmentation was still training at submission and is not reported.

Cross-architecture control. The SD3-Medium control behaves differently on the same tests. There the source helps: loss with the source is 2.5 to 3.9 times lower than with zeros at σ≥0.7\sigma\ge0.7 and 1.6 times lower at σ=0.5\sigma= 0.5, ties at σ=0.3\sigma= 0.3, and hurts only at σ=0.1\sigma= 0.1; the cosine with the copy direction is negative at high noise (−0.23-0.23 at σ=0.95\sigma= 0.95) and turns positive only at σ≤0.5\sigma\le0.5. The two architectures also fail in opposite directions: SD3-Medium overshoots the editor’s sky and lands closer to the source by LPIPS despite doing more work, while Klein under-drives the edit. Both ignore prompt content outside the training tag vocabulary, which we attribute to the captions being permutations of four tags. One difference is procedural: the SD3 trainer parsed the conditioning-dropout flag but never applied it, and that editor produces a flat grey image when the source is zeroed, whereas the Klein editor, trained with dropout 0.05, draws a plausible scene; this is why the recipe keeps conditioning dropout.

Limitations

Private data and weights. The training set is private professional photography. We cannot release images or weights. We release the code, the full recipe, hyperparameters, and the evaluation protocol in the LATENT FUSION repository.

Single domain, single edit type. All training and evaluation images are wide-field and close-range scenes from one editing workflow, and every edit is structure-preserving. We make no claim about content-changing edits, where a free source-target correspondence may be exactly what is needed, and the Kontext ranking may well hold.

Scale. About 1,400 pairs is small. Our findings may not hold for a model trained on a large edit dataset, where sequence concatenation has enough data to learn the correspondence.

Evaluation. Our metrics are full-reference PSNR, SSIM, and LPIPS against a single human-produced edit per image. There are many good edits of the same image, so a good output can still score poorly against the one reference we have. All outputs of the main run are sampled without guidance; the follow-up run was scored on the held-out set only with guidance (§ 6), so it is not compared against it. We did not evaluate the follow-up unguided, so the region loss is not isolated from guidance. The two-pass guidance cost stated in § 3.3 is the cost of the scheme, not a setting we swept.

Compute. Fine-tuning every weight of a 4B model at 10,880 tokens is expensive; the configuration is in § 3. The channel-wise concatenation run cost roughly 680 GPU-hours. The sequence concatenation run has no surviving training log, so its cost and exact step count are not recorded, and the comparison in § 5 rests on the evaluated checkpoints of a single run, which is not a verdict on the scheme. The pretrained sequence concatenation sweep in § 5 is one frame without a reference edit. We did not sweep the design space; each ablation row is a single run.

Conclusion

We explored channel-wise concatenation on FLUX.2 Klein 4B base as the lower-cost way of feeding a source image to a transformer editor, in the regime where the edit must leave structure and identity alone and fewer than 1,500 pairs are available. Stacking the source onto the channels fixes the source-target correspondence by construction, keeps the sequence at its original length, and needs only two-pass classifier-free guidance where the InstructPix2Pix scheme needs three; appending it as tokens leaves that correspondence to be learned by attention over a sequence twice as long. In our runs, one of each scheme, the first kept the scene in place and the second moved it; we report that as an observation on this data, not as a verdict on sequence concatenation, which remains the design of choice for content-changing edits. The recipe is one widened input layer with a zero-initialised half and its own learning rate, training on native-resolution crops mixed with downscaled frames under conditioning dropout, and about 1,400 images. Whether sequence concatenation catches up with more data, as the Kontext report suggests it should, is a question we leave open. We hope the failure record in Section A saves others time.

Lessons from training

Each item below cost us days. All are from our own runs; none are measured claims about other setups.

Vertical stripes are learned, not decoded. Our SD3 2K editor produced regular vertical stripes. We encoded and decoded the ground-truth images through the same VAE and got clean images back, so the VAE was not the cause. The transformer had learned to produce the stripes.

--scale_lr multiplies the learning rate. This Diffusers-style flag multiplies the learning rate by the number of GPUs, the per-GPU batch size, and the number of accumulation steps. Two SD3.5-M runs configured at 2×10−62 \times10^{-6} trained at 2×10−52 \times10^{-5} and 4×10−54 \times10^{-5} (factors of 10 and 20 from 2 GPUs, batch 1 or 2, accumulation 5) and both crashed. Check the effective learning rate logged to wandb, not the flag.

Precision. All reported runs compute in bf16; the Flux runs keep a full-precision fp32 copy of the weights for the optimiser.

Resize to clean ratios. Shrinking sources by a factor that was not a whole number produced resampling artifacts, and the model learned to reproduce them. We now keep every training and inference resolution at an exact multiple of the 16-pixel token size, and place crop windows on that grid too.

The sky shortcut. For sky replacement the model learned “sky is at the top of the frame” rather than reading the image. Drone shots and low-horizon frames broke. Adding negative examples (frames where the top of the image is not sky and must not change) removed the shortcut.

The stock pipeline cannot sample a channel-wise concatenation checkpoint. The Flux inference pipeline appends the conditioning image as tokens, which is the sequence-concatenation layout. It cannot drive a widened input layer, so the trainer skips its built-in final inference for channel-wise concatenation runs. We sample those checkpoints with our own denoising loop; the stock pipeline is used only for the sequence concatenation baseline.

Loss logging. Our SD3-era trainer logs two losses: train_loss, averaged over GPUs and accumulation steps, and step_loss, the raw value for one micro-batch. Our Flux trainer logs only the raw micro-batch loss, indexed by optimiser step, so with kk accumulation steps there are kk points at each x-value. Curves from different trainers are not comparable, and we only compare like with like. We also log ρ\rho, the ratio of mean absolute weight in the new half of the input layer to the pretrained half; it starts at zero and shows whether the source channels are being used.

Rotary position embeddings: what they do and how they scale

Rotary position embeddings. RoPE, how it behaves when the frame grows, and how it relates to channel-wise concatenation cost us the most time to understand; Section B collects it.

The formula. A transformer sees its input as an unordered set of tokens; position has to be added. Rotary position embeddings (RoPE) [19] add it by rotating the query and key vectors. Split a dd-dimensional query qq into d/2d/2 pairs of channels. For a token at position mm, pair jj is rotated by the angle mθjm\theta_j,

R(mθj)=(cos⁡mθj−sin⁡mθjsin⁡mθjcos⁡mθj),θj=b−2j/d,(5)R(m\theta_j) = \begin{pmatrix} \cos m\theta_j & -\sin m\theta_j \\ \sin m\theta_j & \cos m\theta_j \end{pmatrix}, \qquad \theta_j = b^{-2j/d}, \tag*{(5)}

for j=0,…,d/2−1j = 0,\ldots,d/2-1 and a fixed base bb. Writing RmR_m for the block-diagonal matrix of all d/2d/2 rotations, the attention score between a query at position mm and a key at position nn is

(Rmq)T(Rnk)=qTRn−mk,(6)(R_m q)^\mathsf{T}(R_n k) = q^\mathsf{T}R_{n-m}k, \tag*{(6)}

because two rotations compose into one by the difference of their angles. The score therefore depends only on the relative position n−mn-m.

Images need more than one coordinate. FLUX.2 splits the 128-dimensional head into four chunks of d=32d = 32 and rotates each by one coordinate of the token’s position p=(t,h,w,l)p = (t,h,w,l): an image index tt, the row hh, the column ww, and a layer index ll, all with base b=2000b = 2000. Equation (6) holds per chunk, so a score depends on the offset Δp=(Δt,Δh,Δw,Δl)\Delta p = (\Delta t,\Delta h,\Delta w,\Delta l). The generated image’s tokens get p=(0,h,w,0)p = (0,h,w,0).

How often each pair repeats. Pair jj comes back to its starting angle when mθj=2πm\theta_j = 2\pi, that is after

λj=2πb2j/d(7)\lambda_j = 2\pi b^{2j/d} \tag*{(7)}

tokens. One token covers 16×1616 \times16 pixels, so 16λj16\lambda_j is the same distance in pixels. Table 5 gives λj\lambda_j along one spatial axis of Klein. A 2048 × 1360 frame is 128 tokens wide and a 4096 × 2720 frame is 256.

jj\multicolumn{2}{c}{b=2000b = 2000}\multicolumn{2}{c}{b=4189b = 4189 (NTK)}
tokenspixelstokenspixels
06.31016.3101
44267250809
82814,4964076,507
121,87930,0663,27252,348
157,814125,03015,629250,061

Table 5. Tokens per full turn, λj\lambda_j, for pairs of one spatial RoPE axis of FLUX.2 Klein (d=32d = 32), at the pretrained base and at the NTK base used for 4K inference.

Fast and slow pairs. The low-index pairs turn quickly. Pair 0 completes a turn every 6.3 tokens, so it cannot tell a token 1 step away from one 7.3 steps away; it is useful only for telling apart immediate neighbours, which is what local detail needs. The high-index pairs turn slowly. From j=8j = 8 upward a pair does not complete a turn across a whole 2K frame, so its angle changes little between any two tokens in the image and it acts as a coarse, long-range signal; the query-key match on those channels is then decided by content rather than by position. In an editor this suggests fast pairs for detail and slow pairs for layout.

Train short, infer long. A model trained at one sequence length and run at a longer one sees offsets Δp\Delta p it never saw in training: at 4096×27204096 \times2720 a token’s neighbours reach up to 255 positions away, against 127 at 2K. The common fixes slow the rotations down so the new offsets map back onto angles seen in training. Let ss be the length ratio, here s=2s = 2 per spatial axis. Position interpolation (PI) divides every angle by ss, θj′=θj/s\theta'_j = \theta_j/s, which also blurs the fast pairs that local detail relies on. NTK-aware scaling instead raises the base,

b′=b sd/(d−2),θj′=θj s−2j/(d−2),(8)b' = b\,s^{d/(d-2)}, \qquad\theta'_j = \theta_j\,s^{-2j/(d-2)}, \tag*{(8)}

so the fastest pair is left alone and only the slowest is slowed by the full ss; for Klein, b′=2000⋅232/30≈4189b' = 2000 \cdot2^{32/30} \approx4189. YaRN splits the pairs into three bands: fast pairs are untouched, slow pairs are divided by ss, and the pairs between them blend the two, θj′=(1−γj)θj/s+γjθj\theta'_j = (1-\gamma_j)\theta_j/s + \gamma_j\theta_j with γj\gamma_j falling from 1 to 0 across the band. Figure 6 compares the three.

Plot showing how much each RoPE pair is slowed under PI, NTK and YaRN

Figure 6. How much each RoPE pair is slowed under PI, NTK and YaRN, for an illustrative length ratio s=4s = 4; the YaRN ramp from 0.4 to 0.8 is also illustrative. PI slows every pair equally; NTK slows pairs progressively; YaRN keeps the fast pairs exact, slows the slow pairs fully and blends the middle band.

What we found at 4K. We ran the main 2048×13602048 \times1360 channel-wise concatenation checkpoint at 4096×27204096 \times2720 inference. With NTK scaling the base went from 2000 to 4189. Turning RoPE off ruins the image, so the network depends on it. NTK scaling and attention sharpening, which scales the attention logits up so that four times as many keys do not flatten the softmax, barely changed the output: at this ratio RoPE copes with 4K frames as it is. Our tests agree with the picture above, with the fast pairs carrying detail and the slow pairs carrying structure. At 4K each query attends over 43,520 tokens instead of 10,880, and this attention dilution mostly weakens the edit rather than the detail copied from the source. That is what channel-wise concatenation predicts: the source detail reaches each token through its own input channels, not through attention, so spreading attention thinner leaves it in place.

How sequence concatenation uses RoPE. Under sequence concatenation the source tokens are appended to the sequence and need positions of their own. The Klein pipeline gives the ii-th reference image p=(10+10i,h,w,0)p = (10 + 10i, h, w, 0): the same rows and columns as the target, shifted on the image axis. For a target token and the source token at the same pixel block, the offset is Δp=(10,0,0,0)\Delta p = (10, 0, 0, 0). Nothing else marks that token as the one to copy from. The network has to learn, through attention over all 2L tokens, that the useful source token is the one with Δh=Δw=0\Delta h = \Delta w = 0, and to keep looking there at every layer. With enough data this is learned; with about 1,400 pairs our sequence concatenation run let the scene drift (§ 5), which is what a correspondence that is only softly learned would look like.

Carrying InstructPix2Pix over to a transformer. Instruct-Pix2Pix [1] stacks the source latent onto the noisy latent along the channel axis of a U-Net. There, alignment comes for free: the first convolution reads both stacks at the same pixel. The question for a transformer was what plays the role of that shared pixel. The answer is the token position. If the source block is stacked in the same token as the target block, as [xt,i∥ci][x_{t,i} \Vert c_i], both inherit the one position pi=(0,hi,wi,0)p_i = (0, h_i, w_i, 0), and their offset is Δp=0\Delta p = 0 by construction. No new positions are created, no RoPE axis is offset, the sequence stays at LL, and the pretrained position grid is reused unchanged. The only new parameters are the zero-initialised half of the input projection (§ 3.3).

The lesson we draw is narrow. RoPE only tells a token how far away another token is; it does not tell it which one to copy from. When source and target are pixel-aligned, that choice is known in advance, and putting both in the same token states it directly instead of leaving attention to discover it. When the edit moves content, the choice is not known in advance, and the freedom of sequence concatenation is what the task needs.

References

  1. [1]T. Brooks, A. Holynski, and A. A. Efros, “InstructPix2Pix: Learning to follow image editing instructions,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 18392–18402, 2023.arxiv.org/abs/2211.09800
  2. [2]S. Batifol, A. Blattmann, F. Boesel, S. Consul, C. Diagne, T. Dockhorn, J. English, Z. English, P. Esser, S. Kulal, K. Lacey, Y. Levi, C. Li, D. Lorenz, J. Müller, D. Podell, R. Rombach, H. Saini, A. Sauer, and L. Smith, “FLUX.1 Kontext: Flow matching for in-context image generation and editing in latent space,” arXiv preprint arXiv:2506.15742, 2025.arxiv.org/abs/2506.15742
  3. [3]Black Forest Labs, “FLUX.1 Fill [dev].” https://huggingface.co/black-forest-labs/FLUX.1-Fill-dev, 2024. Release note: https://bfl.ai/blog/24-11-21-tools.
  4. [4]Black Forest Labs, “FLUX.2 [klein] 4B Base.” https://huggingface.co/black-forest-labs/FLUX.2-klein-base-4B, 2026. Code: https://github.com/black-forest-labs/flux2.
  5. [5]K. Zhang, L. Mo, W. Chen, H. Sun, and Y. Su, “MagicBrush: A manually annotated dataset for instruction-guided image editing,” in Advances in Neural Information Processing Systems (NeurIPS), 2023.arxiv.org/abs/2306.10012
  6. [6]S. Sheynin, A. Polyak, U. Singer, Y. Kirstain, A. Zohar, O. Ashual, D. Parikh, and Y. Taigman, “Emu Edit: Precise image editing via recognition and generation tasks,” arXiv preprint arXiv:2311.10089, 2023.arxiv.org/abs/2311.10089
  7. [7]H. Zhao, X. Ma, L. Chen, S. Si, R. Wu, K. An, P. Yu, M. Zhang, Q. Li, and B. Chang, “UltraEdit: Instruction-based fine-grained image editing at scale,” in Advances in Neural Information Processing Systems (NeurIPS), Datasets and Benchmarks Track, 2024.arxiv.org/abs/2407.05282
  8. [8]Black Forest Labs, “FLUX.1.” https://github.com/black-forest-labs/flux, 2024.
  9. [9]Z. Zhang, J. Xie, Y. Lu, Z. Yang, and Y. Yang, “In-context edit: Enabling instructional image editing with in-context generation in large scale diffusion transformer,” in Advances in Neural Information Processing Systems (NeurIPS), 2025.
  10. [10]E. J. Hu, Y. Shen, P. Wallis, Z. Allen-Zhu, Y. Li, S. Wang, L. Wang, and W. Chen, “LoRA: Low-rank adaptation of large language models,” in International Conference on Learning Representations (ICLR), 2022.arxiv.org/abs/2106.09685
  11. [11]S. Xiao, Y. Wang, J. Zhou, H. Yuan, X. Xing, R. Yan, C. Li, S. Wang, T. Huang, and Z. Liu, “OmniGen: Unified image generation,” arXiv preprint arXiv:2409.11340, 2024.arxiv.org/abs/2409.11340
  12. [12]S. Liu, Y. Han, P. Xing, F. Yin, R. Wang, W. Cheng, J. Liao, Y. Wang, H. Fu, C. Han, G. Li, Y. Peng, Q. Sun, J. Wu, Y. Cai, Z. Ge, R. Ming, L. Xia, X. Zeng, Y. Zhu, B. Jiao, X. Zhang, G. Yu, and D. Jiang, “Step1X-Edit: A practical framework for general image editing,” arXiv preprint arXiv:2504.17761, 2025.arxiv.org/abs/2504.17761
  13. [13]C. Wu, J. Li, J. Zhou, J. Lin, K. Gao, K. Yan, et al., “Qwen-Image technical report,” arXiv preprint arXiv:2508.02324, 2025.arxiv.org/abs/2508.02324
  14. [14]C. Deng, D. Zhu, K. Li, C. Gou, F. Li, Z. Wang, S. Zhong, W. Yu, X. Nie, Z. Song, G. Shi, and H. Fan, “Emerging properties in unified multimodal pretraining,” arXiv preprint arXiv:2505.14683, 2025.arxiv.org/abs/2505.14683
  15. [15]Q. Li, S. Qiu, J. Han, X. Xu, M. S. Seyfioglu, K. K. Koo, and K. Bouyarmane, “DiT-VTON: Diffusion transformer framework for unified multi-category virtual try-on and virtual try-all with integrated image editing,” arXiv preprint arXiv:2510.04797, 2025. CVPR 2025 AI for Content Creation Workshop.arxiv.org/abs/2510.04797
  16. [16]P. Esser, S. Koulal, A. Blattmann, R. Entzeari, J. Müller, H. Saini, Y. Levi, D. Lorenz, A. Sauer, F. Boesel, D. Podell, T. Dockhorn, Z. English, and R. Rombach, “Scaling rectified flow transformers for high-resolution image synthesis,” in Proceedings of the 41st International Conference on Machine Learning (ICML), vol. 235 of PMLR, pp. 12606–12633, 2024.arxiv.org/abs/2403.03206
  17. [17]X. Liu, C. Gong, and Q. Liu, “Flow straight and fast: Learning to generate and transfer data with rectified flow,” in International Conference on Learning Representations (ICLR), 2023.arxiv.org/abs/2209.03003
  18. [18]Y. Lipman, R. T. Q. Chen, H. Ben-Hamu, M. Nickel, and M. Le, “Flow matching for generative modeling,” in International Conference on Learning Representations (ICLR), 2023.arxiv.org/abs/2210.02747
  19. [19]J. Su, Y. Lu, S. Pan, A. Murtadha, B. Wen, and Y. Liu, “Ro-Former: Enhanced transformer with rotary position embedding,” arXiv preprint arXiv:2104.09864, 2021.arxiv.org/abs/2104.09864
  20. [20]W. Peebles and S. Xie, “Scalable diffusion models with transformers,” in Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), 2023.arxiv.org/abs/2212.09748
  21. [21]R. Zhang, P. Isola, A. A. Efros, E. Shechtman, and O. Wang, “The unreasonable effectiveness of deep features as a perceptual metric,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2018.arxiv.org/abs/1801.03924

Paper details

vlnc:W_cf8bv6tv
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents