OSIE: One-Step Inversion and Editing

• OSIE is a one-step framework for text-guided image editing that merges real-image inversion with prompt-conditioned editing in a single feed-forward pass.
• It employs a pretrained text-to-image generator with mask-guided attention rescaling to achieve localized edits while preserving background integrity.
• Empirical evaluations show OSIE delivers competitive image quality with significant speedups, reducing inference times from seconds to fractions of a second.

Searching arXiv for papers on OSIE / one-step inversion-and-editing to ground the article. {"query":"One-Step Inversion-and-Editing OSIE SwiftEdit FlashEdit training-free inversion one-step diffusion image editing", "max_results": 10} One-Step Inversion-and-Editing (OSIE) denotes a family of text-guided image editing frameworks for one-step diffusion models in which real-image inversion and prompt-conditioned editing are collapsed into a single feed-forward regime rather than executed as separate multi-step inversion and denoising procedures. In the formulation introduced with SwiftEdit, OSIE is described as a framework that enables “one-step image reconstruction via inversion” and supports localized editing through a mask-guided mechanism with attention rescaling, yielding end-to-end editing in $0.23$ s and making it “at least 50 times faster” than previous multi-step methods while maintaining competitive editing performance (Nguyen et al., 2024). Subsequent work generalized the term: TFinv situated OSIE within the broader problem of one-step diffusion inversion and editing, while FlashEdit characterized OSIE as the core module that “bypasses costly iterative processes” and delivers an “over 150$\times$” speedup relative to prior multi-step pipelines (Wu et al., 31 May 2026, Wu et al., 26 Sep 2025).

1. Conceptual definition and problem setting

OSIE arises from a specific bottleneck in text-guided image editing with diffusion models. In the conventional pipeline, a real image is first inverted into a diffusion latent by an iterative procedure such as DDIM or DDPM inversion, and then a second iterative denoising process applies the target text prompt. This two-phase structure is effective but computationally expensive. SwiftEdit explicitly contrasts its one-step inversion with a “typical multi-step DDIM inversion,” noting the difference as “1 U-Net call vs. 50 iterative denoising steps” for inversion alone (Nguyen et al., 2024). FlashEdit extends this comparison to the full editing pipeline and states that traditional editing requires iterative inversion and iterative editing, each costing roughly $O(T \cdot \text{UNet-cost})$, whereas OSIE replaces both with a single-shot procedure (Wu et al., 26 Sep 2025).

In SwiftEdit, the inversion objective is defined for a pretrained one-step text-to-image generator $G$ as follows: given an image $x$, invert it into a noise variable $\epsilon$ such that

$z = G(\epsilon, c_y) \simeq E(x),$

where $E$ is the pretrained VAE encoder and $c_y$ is the CLIP embedding of the source prompt $y$ (Nguyen et al., 2024). This formulation places inversion in the latent space of a one-step model rather than in the iterative trajectory of a multi-step sampler.

A closely related perspective appears in TFinv, which frames the one-step inversion problem around two obstacles: “Initial Latent Editability,” associated with the distance between the initial noise and the ideal Gaussian distribution, and “Caption Gap,” referring to the alignment between text captions and image representations (Wu et al., 31 May 2026). This suggests that OSIE is not merely a latency optimization; it is also a reformulation of how invertibility and editability are jointly constrained in one-step generative models.

2. Core architecture in SwiftEdit

SwiftEdit instantiates OSIE with a pretrained one-step text-to-image generator $\times$0, specifically SwiftBrushv2, and an inversion network $\times$1 that uses the “same U-Net backbone as $\times$2, initialized from SwiftBrushv2” (Nguyen et al., 2024). The architecture also includes an IP-Adapter branch, described as “a lightweight decoupled cross-attention module (two linear layers $\times$3)” that injects image features

$\times$4

into the denoiser (Nguyen et al., 2024).

SwiftEdit introduces the following notation (Nguyen et al., 2024):

• $\times$5: input RGB image
• $\times$6: latent via frozen VAE encoder
• $\times$7: text condition
• $\times$8: predicted inverted noise
• $\times$9: one-step reconstructed latent

The central equations are

$O(T \cdot \text{UNet-cost})$0

In this system, $O(T \cdot \text{UNet-cost})$1 predicts an inverted latent-noise representation from the encoded image and prompt, and the generator with IP-Adapter reconstructs the image latent in one step (Nguyen et al., 2024).

FlashEdit uses related but not identical terminology. It defines a learned “Inversion-and-Editing network” $O(T \cdot \text{UNet-cost})$2 that predicts a diffusion noise latent from the autoencoder latent $O(T \cdot \text{UNet-cost})$3, a text embedding $O(T \cdot \text{UNet-cost})$4, and a direct visual adapter feature $O(T \cdot \text{UNet-cost})$5, followed by a one-step UNet decoder $O(T \cdot \text{UNet-cost})$6 (Wu et al., 26 Sep 2025). The forward path is given as

$O(T \cdot \text{UNet-cost})$7

At test time, the same network can be conditioned on $O(T \cdot \text{UNet-cost})$8 to produce a one-shot edited latent (Wu et al., 26 Sep 2025). A plausible implication is that OSIE has evolved from an inversion-plus-generation decomposition in SwiftEdit toward a more tightly unified inversion-and-editing parameterization in FlashEdit.

3. Training procedures and optimization objectives

SwiftEdit trains OSIE in two stages (Nguyen et al., 2024). In Stage 1, using synthetic data, the model samples $O(T \cdot \text{UNet-cost})$9, generates $G$0, and trains $G$1 together with the IP-Adapter using a reconstruction loss and a regression loss: $G$2

$G$3

$G$4

In Stage 2, on real data, the model computes $G$5, $G$6, and $G$7, decodes $G$8, and applies a perceptual loss via DISTS together with an SDS-inspired regularization term: $G$9

$x$0

where $x$1, $x$2 is the teacher UNet, and $x$3 is the timestep weight. The total loss is

$x$4

This procedure is designed to preserve reconstruction quality while keeping the predicted inverted noise close to $x$5 (Nguyen et al., 2024).

FlashEdit describes a comparable two-stage training strategy under the label “Anchor-and-Refine” (Wu et al., 26 Sep 2025). Stage 1 “anchors” the network on synthetic pairs and optimizes

$x$6

Stage 2 “refines” the model on real images via teacher-student distillation: $x$7 The correspondence between SwiftEdit’s synthetic-plus-real two-stage training and FlashEdit’s Anchor-and-Refine design suggests a stable pattern in OSIE research: supervised prior matching on generated data followed by distillation-based adaptation to real-image inversion (Nguyen et al., 2024, Wu et al., 26 Sep 2025).

SwiftEdit also reports ablations on reconstruction and editing performance. For real-image reconstruction, removing Stage 1 yields “PSNR$x$8 vs. full $x$9,” removing Stage 2 yields “PSNR$\epsilon$0,” and removing the IP-Adapter yields “PSNR$\epsilon$1” (Nguyen et al., 2024). For editing alignment, the full setting with both regression losses gives “CLIP-Whole$\epsilon$2” and “CLIP-Edited$\epsilon$3,” outperforming ablated variants (Nguyen et al., 2024).

4. Inference workflow and single-shot execution

The defining operational property of OSIE is the absence of iterative test-time loops. SwiftEdit provides high-level pseudocode for one-step inversion: $\times$15 and contrasts it with “Multi-Step (DDIM) Inversion (50 steps),” which repeatedly queries a diffusion U-Net across timesteps (Nguyen et al., 2024).

For editing, SwiftEdit executes: $\times$16 The inversion is thus performed once, and the generator applies the target prompt under the mask-guided attention-rescaling mechanism in one step (Nguyen et al., 2024).

FlashEdit gives a more integrated pseudocode summary: $\times$17 It emphasizes: “No loops. Exactly one forward through $\epsilon$4 + one through the UNet decoder” (Wu et al., 26 Sep 2025).

TFinv, although explicitly “training-free,” preserves the broader OSIE objective of one-step editing after inversion. Its pipeline performs inversion by optimizing the latent and suffix prompt tokens, then uses “one forward pass per edit” for editing (Wu et al., 31 May 2026). This suggests that OSIE can denote both a trained feed-forward architecture and a broader operational regime in which final edits are executed in one step once an editable latent has been obtained.

5. Localized editing and region control

Localized editing is a central technical issue because naive text-guided edits often alter irrelevant regions. SwiftEdit addresses this with “Mask-Guided Editing & Attention-Rescaling (ARaM)” (Nguyen et al., 2024). The goal is to “localize edits to regions $\epsilon$5 so that background is preserved.” The mask is constructed from two inverted noises,

$\epsilon$6

followed by an absolute difference and min-max normalization: $\epsilon$7 SwiftEdit then replaces a single global image-condition scale with three region-specific scales, $\epsilon$8, $\epsilon$9, and $z = G(\epsilon, c_y) \simeq E(x),$0, yielding the attention-rescaled activation

$z = G(\epsilon, c_y) \simeq E(x),$1

Here, $z = G(\epsilon, c_y) \simeq E(x),$2 is the strength of the edit prompt inside $z = G(\epsilon, c_y) \simeq E(x),$3, $z = G(\epsilon, c_y) \simeq E(x),$4 is the residual image-condition scale within $z = G(\epsilon, c_y) \simeq E(x),$5, and $z = G(\epsilon, c_y) \simeq E(x),$6 is the image-condition scale outside $z = G(\epsilon, c_y) \simeq E(x),$7 (Nguyen et al., 2024). The reported default scales are $z = G(\epsilon, c_y) \simeq E(x),$8, $z = G(\epsilon, c_y) \simeq E(x),$9, and $E$0 (Nguyen et al., 2024).

TFinv also includes a “mask-based editing technique for localized edits while preserving background integrity” (Wu et al., 31 May 2026). After inversion, it extracts an object-region mask $E$1 “from the average cross-attention maps during the inversion pass” and fuses edited and reconstructed latents: $E$2 This directly mixes edited content inside the mask with reconstructed content outside the mask (Wu et al., 31 May 2026).

FlashEdit positions OSIE alongside two additional modules: “Background Shield (BG-Shield),” which “guarantees background preservation by selectively modifying features only within the edit region,” and “Sparsified Spatial Cross-Attention (SSCA),” which “ensures precise, localized edits by suppressing semantic leakage to the background” (Wu et al., 26 Sep 2025). A plausible implication is that later systems increasingly decouple inversion speed from spatial control, treating OSIE as the temporal backbone and separate modules as spatial safeguards.

6. Empirical performance, comparisons, and model variants

SwiftEdit reports experiments on PieBench with 700 edits, using “Background maintenance: PSNR$E$3, MSE$E$4 on unedited region” and “Editing alignment: CLIP-Whole$E$5 (full image), CLIP-Edited$E$6 (region $E$7)” (Nguyen et al., 2024). The selected quantitative comparison is as follows:

Method	PSNR↑	CLIP-Whole↑
DDIM+P2P (50 s)	17.87	25.01
NT-Inv+P2P (134 s)	27.03	24.75
TurboEdit (4 s)	22.43	25.49
OSIE (ours)	23.33	25.16
OSIE+GT-mask	23.31	25.56

The same table reports runtime and region-specific metrics: OSIE has “MSE $E$8,” “CLIP-Edited $E$9,” and runtime “0.23” s, while “OSIE+GT-mask” reaches “CLIP-Edited $c_y$0” with the same runtime (Nguyen et al., 2024). SwiftEdit further states that its end-to-end editing time is $c_y$1 s, whereas “Multi-step baselines (50 steps) $c_y$2–$c_y$3 s” and “Few-step (4 steps) $c_y$4–$c_y$5 s” (Nguyen et al., 2024). In a user study with $c_y$6, “OSIE is preferred in 47.8 % cases for editing semantics and 40 % for background” (Nguyen et al., 2024).

TFinv evaluates on PIE-Bench over 700 images and 10 edit types with metrics including “Structure-Distance,” “Background PSNR,” “LPIPS,” “MSE,” “SSIM,” and “CLIP-Similarity” (Wu et al., 31 May 2026). It reports:

Method	PSNR↑	CLIP whole↑
TurboEdit	16.81	25.29
SwiftEdit (trained)	23.33	25.16
TFinv (ours)	24.15	24.26

The full TFinv row is “Struct. Dist. $c_y$7, PSNR $c_y$8, LPIPS $c_y$9, MSE $y$0, SSIM $y$1, CLIP whole $y$2, CLIP edit $y$3” (Wu et al., 31 May 2026). Efficiency is reported on a single A40 GPU as “Inversion: $y$4 s once per image (600 iter)” and “Each edit: $y$5 s (one forward pass)” (Wu et al., 31 May 2026). These numbers indicate that TFinv improves edit-time efficiency while retaining a substantial optimization cost during inversion.

FlashEdit isolates “OSIE (without BG-Shield or SSCA)” on PieBench and reports “PSNR=23.33, LPIPS=0.092, MSE=6.60×10$y$6, SSIM=0.7997, CLIP-Whole=24.14, CLIP-Edited=21.23” (Wu et al., 26 Sep 2025). With the full FlashEdit stack, the numbers improve to “PSNR=25.29, LPIPS=0.0626, MSE=4.36×10$y$7, SSIM=0.8321, CLIP-Whole=25.43, CLIP-Edited=22.13” (Wu et al., 26 Sep 2025). Efficiency is summarized as “DDIM+P2P (multi-step): 1.00× baseline,” “TurboEdit (few-step): 19.7×,” and “OSIE(Edit only): 150.8×” (Wu et al., 26 Sep 2025).

SwiftEdit also reports that “$y$8 ARaM works with InstaFlow, DMD2, SBv1, SBv2,” with “Best editing scores with SBv2 backbone” (Nguyen et al., 2024). This suggests that OSIE is not bound to a single one-step generative backbone, although the best reported editing behavior in that study was achieved with SBv2.

7. Relation to training-free inversion, implementation considerations, and limitations

TFinv is directly relevant to OSIE because it identifies two factors that “hamper real-image inversion and editing”: the “distribution gap,” referring to deviation of the inverted latent from $y$9, and the “caption gap,” referring to prompt-image misalignment (Wu et al., 31 May 2026). It addresses these with “iterative noise alignment (iterNA),” which optimizes the latent via

$\times$00

and “suffix learning (suffL),” which appends trainable suffix tokens and minimizes

$\times$01

Because TFinv requires “without any additional network training,” it serves as a counterpoint to trained OSIE systems such as SwiftEdit and FlashEdit (Wu et al., 31 May 2026). A plausible implication is that OSIE can be understood both as a concrete trained architecture and as a target operating point—namely, editable one-step generation from real images.

SwiftEdit provides explicit implementation guidance for on-device and real-time deployment (Nguyen et al., 2024). It states that one-step editing needs only “1 forward pass through $\times$02 (one U-Net)” and “1 forward pass through $\times$03 (same U-Net with IP-Adapter),” with “No iterative loop $\times$04 ideal for mobile/edge.” Reported practical notes include “Model size: $\times$05 MB (FP32); quantize to FP16 or INT8 yields $\times$06 MB,” “Use half-precision and ONNX / TensorRT for sub-0.1 s latency on powerful GPUs,” “On CPU, expect $\times$07–$\times$08 s; on mid-range GPU $\times$09–$\times$10 s per edit,” and “Batch multiple images ($\times$11) with minimal overhead since no time loop” (Nguyen et al., 2024). These observations are consistent with the broader OSIE premise that latency savings derive primarily from eliminating the timestep loop.

FlashEdit likewise emphasizes that OSIE “never needs iterative noise estimation at test time” and identifies its computational cost as a “Single forward of $\times$12 + single forward of $\times$13” (Wu et al., 26 Sep 2025). Its implementation details specify initialization from SwiftBrush v2, a “lightweight branch built on a frozen CLIP-image encoder plus two linear ‘adapter’ layers,” and an inversion head $\times$14 described as “a 4-block residual MLP” (Wu et al., 26 Sep 2025).

The principal limitation recorded in the provided material concerns training-free inversion rather than trained OSIE itself. TFinv notes that “The inversion stage (600 GD steps) is still computationally heavy” and that the method “assumes access to cross-attention maps for mask generation” (Wu et al., 31 May 2026). SwiftEdit’s own results indicate that background preservation and semantic alignment can be improved with a ground-truth mask, as seen in the “OSIE+GT-mask” row (Nguyen et al., 2024). This suggests that mask quality remains a meaningful factor in localized one-step editing performance.

Taken together, the available literature presents OSIE as a technically specific response to the latency and editability constraints of diffusion-based image editing: it replaces iterative inversion and denoising with a one-shot or effectively one-shot pipeline, aligns real-image latents with the one-step model prior, and increasingly incorporates explicit spatial control mechanisms to preserve background structure while applying prompt-driven edits (Nguyen et al., 2024, Wu et al., 31 May 2026, Wu et al., 26 Sep 2025).