💻 computer science

UniCycleFlow: Bidirectional Unpaired Image Translation with a Shared Rectified Flow

UniCycleFlow introduces a bidirectional unpaired image translation framework that unifies forward and reverse transformations within a single time-conditioned rectified flow by learning deterministic source-conditioned endpoints with adversarial marginal matching, thereby achieving state-of-the-art performance across multiple translation tasks while preserving source-specific structures.

Original authors: Xianhao Zhou, Jianghao Wu, Shaoting Zhang, Guotai Wang

Published 2026-08-10

📖 8 min read🧠 Deep dive

CC BY 4.0

Original authors: Xianhao Zhou, Jianghao Wu, Shaoting Zhang, Guotai Wang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a master translator, but instead of converting words between French and English, you are translating entire worlds. You want to turn a photo of a summer meadow into a snowy winter landscape, or a zebra into a horse, without ever having seen a single pair of "before and after" pictures to guide you. This is the wild frontier of unpaired image translation. In the past, computers struggled with this because they didn't know which specific summer flower should become which specific winter snowflake. They often just guessed, resulting in blurry messes or images that lost their original shape. To fix this, scientists usually taught computers to play a game of "round-trip": translate a summer photo to winter, then try to translate it back to summer. If the final result looked like the original, the computer was doing a good job. But this method was like checking if a round-trip bus ride got you back to the station; it didn't guarantee the bus took a smooth, logical route in between.

Enter UniCycleFlow, a new approach that changes the game by treating image translation not as two separate jobs, but as a single, continuous journey. Instead of building two different translators (one for summer-to-winter and another for winter-to-summer), this method builds one "velocity field"—think of it as a universal wind map that blows in both directions. If you want to go from Summer to Winter, you let the wind blow forward; if you want to go back, you just reverse the wind. The paper's main finding is that by forcing both directions to follow this same invisible wind map, the computer learns to preserve the structure of the original image much better than before. The authors measured this by testing ten different translation tasks (like turning cats into dogs or aerial maps into street views) and found that their method produced the clearest, most realistic images with the fewest errors, achieving a top score of 55.1 on a standard quality test called FID. They also showed that even if you ask the computer to take just one giant step instead of many tiny ones, the result is still excellent, proving the path is incredibly straight and efficient.

The Problem: The "Random Pairing" Trap

Imagine you are trying to teach a robot how to turn a picture of a horse into a zebra. The robot has a box of horse photos and a box of zebra photos, but they aren't matched up. If you just grab a random horse and a random zebra and tell the robot, "Turn this horse into that zebra," the robot gets confused. It might try to turn the horse's legs into the zebra's stripes, or worse, it might try to turn the horse's head into the zebra's tail because the two animals are in different poses. The robot ends up learning a messy mix of "how to change a horse" and "how to change a specific pose," resulting in a weird, distorted creature.

Previous methods tried to fix this by building two separate robots: one to go from A to B, and another to go from B to A. They would check if the robot could go A → B → A and end up with the original image. While this helped, it was like checking if a driver could return to the start; it didn't guarantee the driver took the same road both ways. The two robots might take completely different, zig-zaggy paths that just happened to start and end at the right places.

The Solution: One Wind, Two Directions

The authors of this paper, UniCycleFlow, decided to stop building two robots. Instead, they built one single wind map (a "velocity field") that exists in a shared space between the two worlds.

Think of time as a ruler. At the very beginning of the ruler (time 0), you have your source image (like a horse). At the very end (time 1), you have the target image (like a zebra). The "wind" blows from time 0 to time 1.

To go Horse → Zebra, you just let the wind blow forward.
To go Zebra → Horse, you simply reverse the wind and blow backward from time 1 to time 0.

Because it's the same wind map, the rules for changing a horse into a zebra are exactly the same as the rules for changing a zebra back into a horse, just in reverse. This forces the computer to learn a single, consistent set of rules for the transformation, rather than two separate, conflicting sets.

The Magic Trick: Learning the Right Destination

Here is the tricky part: Since the computer doesn't have matched pairs, how does it know which specific horse should turn into which specific zebra? If it just guesses, it will still make the "random pairing" mistake we talked about earlier.

UniCycleFlow solves this with a clever trick called adversarial boundary matching. Instead of forcing the computer to match a specific horse to a specific zebra from the dataset, the computer learns to create its own perfect destination.

The computer looks at a horse and says, "I will create a zebra that looks exactly like a real zebra."
It creates a fake zebra.
A "judge" (a discriminator) looks at the fake zebra and the real zebras. If the judge can tell them apart, the computer tries again.
Once the judge can't tell the difference, the computer has found a "perfect match" for that specific horse, even though it wasn't in the original dataset.

Now, the computer has a clear path: Horse → Perfect Fake Zebra. It draws a straight line between them and learns the wind needed to travel that line. Because the destination was created specifically for that source, the path is clean and logical, avoiding the confusion of random pairings.

Keeping the Journey Smooth

Just knowing the start and end points isn't enough. The computer needs to make sure the journey in the middle is smooth and doesn't warp the image strangely. The authors added three safety nets to ensure the path is perfect:

Self-Flow Matching: Imagine the computer is walking along the path. It checks its own steps to make sure the wind feels consistent. If the wind suddenly changes direction in the middle of the journey, the computer corrects itself. This ensures the path is a straight line, not a wobbly mess.
Cycle Closure: This is the "round-trip" check, but smarter. The computer goes Horse → Zebra → Horse and checks if it ends up exactly where it started. If the two steps don't cancel each other out perfectly, the computer learns to fix the wind map so the loop closes tightly.
Representation Path-Velocity Regularization: This is the most subtle check. Sometimes, an image might look okay, but the "feeling" of the image changes too much in the middle. For example, the texture of the fur might get too fuzzy before it sharpens again. The computer uses a frozen "eye" (a pre-trained encoder) to look at the image at every tiny step of the journey. It makes sure that the features (like fur texture or eye shape) change slowly and steadily, rather than jumping around wildly.

The Results: A Clearer Picture

The authors tested this new method on ten different translation tasks, including turning summer into winter, horses into zebras, and cats into dogs. They compared their results against many other famous methods.

The results were impressive. When the computer was allowed to take just one single step (a "one-step inference") to translate the image, UniCycleFlow achieved the best score (lowest error) in 7 out of 10 tasks. Its average score across all ten tasks was 55.1, which was better than the previous best method (DCLGAN) that scored 62.6.

Even more surprisingly, the method worked almost as well whether the computer took one giant step or five smaller steps. This suggests that the path the computer learned is so straight and direct that it doesn't need to take tiny, cautious steps to get there. It can just leap from the source to the target with confidence.

Why This Matters

UniCycleFlow shows that we don't need to build complex, separate systems for every direction of translation. By treating the transformation as a single, continuous journey governed by one set of rules, we can get clearer, more stable results. It's like realizing that to get from home to school and back, you don't need two different maps; you just need one good map and the ability to walk it in reverse. This approach not only saves computing power but also ensures that the "story" of the image remains consistent, no matter which way you travel.

Technical Summary of UniCycleFlow

Problem Definition
Bidirectional unpaired image translation seeks to transform images between two visual domains without aligned source–target pairs. A central challenge in this setting is preserving the specific structure of the source image while learning coherent transformations in both directions. Existing methods typically rely on two direction-specific generators or separate one-way models linked by cycle consistency. While cycle objectives enforce endpoint reconstruction, they do not require the two directions to obey a common local transformation rule. Furthermore, standard rectified flow formulations, which construct interpolation paths from prescribed endpoint couplings, fail in unpaired settings because independently sampling real images from two domains mixes the desired domain shift with arbitrary differences in content, pose, and spatial layout, resulting in poorly aligned velocity targets.

Methodology
The authors propose UniCycleFlow, a framework that models bidirectional translation as the forward and reverse integration of a single time-conditioned velocity field, $v_\theta(x, t)$ , rather than using separate generators.

Shared Temporal Dynamics: The two domains are assigned to opposite ends of a temporal interval ( $t=0$ for domain A, $t=1$ for domain B). Translation is achieved by integrating the same velocity field forward ( $A \to B$ ) or backward ( $B \to A$ ). The network always predicts velocity in a canonical $A \to B$ orientation; the direction is determined solely by the sign of the time increment during Euler integration.
Source-Conditioned Endpoint Construction: To address the lack of meaningful source–target coupling in unpaired data, UniCycleFlow learns deterministic endpoints for each source image. Instead of pairing a source with an independently sampled real image, the model generates a target endpoint $\hat{x}_B$ from $x_A$ (and vice versa). The marginal distributions of these generated endpoints are adversarially matched to the opposite domains using PatchGAN discriminators. This creates translation-specific straight trajectories $(x_A, \hat{x}_B)$ and $(\hat{x}_A, x_B)$ without relying on arbitrary pairings of unrelated real images.
Trajectory Regularization: Since endpoint supervision alone does not constrain intermediate states or guarantee consistent composition, three regularization terms are introduced:
- Stop-Gradient Self-Flow Matching (SelfFM): This transfers the boundary displacement to intermediate field predictions. By detaching the boundary velocities, the model supervises intermediate states along the induced path without simultaneously altering the endpoint displacement through the same objective.
- Discrete Cycle Closure: This constrains the composition of the discrete forward and reverse endpoint maps, ensuring that translating an image forward and then backward returns it close to the original.
- Representation Path-Velocity Regularization (RPV): This measures finite-difference feature changes between neighboring trajectory states using a frozen dense encoder (e.g., VGG16). It controls localized feature changes along the trajectory in representation space, preventing excessive localized variations that might occur even with a straight path in pixel space.

Key Contributions

Unified Dynamics: The paper introduces a formulation where bidirectional translation is governed by a single time-indexed transformation model, directly coupling forward and reverse changes rather than relying on separate generators or discrete conditioning.
Adversarial Endpoint Learning for Unpaired Flow: The authors propose a method to construct valid rectified flow trajectories for unpaired data by learning deterministic, source-conditioned endpoints whose marginals are adversarially matched to the target domains.
Comprehensive Regularization: The framework integrates stop-gradient self-flow matching, discrete cycle closure, and representation path-velocity regularization to ensure consistency at the intermediate, compositional, and perceptual levels.

Results
The method was evaluated on ten translation directions across five domain pairs (Summer/Winter, Horse/Zebra, Cat/Dog, Wild/Dog, Aerial/Map).

Performance: Using a single Euler evaluation step ($NFE=1$), UniCycleFlow achieved the lowest Fréchet Inception Distance (FID) on 7 out of 10 tasks. It obtained the best average FID of 55.1 and the best average Kernel Inception Distance (KID $\times$ 100) of 2.107 across all ten directions.
Comparison: These results outperform strong baselines such as DCLGAN (average FID 62.6) and UNSB. Increasing the integration budget to 5 steps further improved the average FID to 54.2.
Ablation: Experiments confirmed that learning source-conditioned endpoints provided the largest improvement over independent-pair rectified flow. The combination of SelfFM, cycle closure, and RPV progressively refined the results, with the full model achieving the best metrics.

Significance and Claims
The paper claims that UniCycleFlow provides a unified rectified-flow framework for bidirectional unpaired translation that organizes both directions within the same continuous dynamics. By replacing arbitrary pairings with learned source-conditioned endpoints and enforcing consistency through trajectory-level regularization, the method achieves high-quality translation with a single-step inference. The authors note that while the current design uses a deterministic shared field and does not explicitly model one-to-many outputs, the approach offers a strong baseline for structure-preserving translation. They also acknowledge limitations, such as the potential bias in intermediate supervision if boundary predictions are inaccurate early in training, and the dependence of RPV on the geometry of the frozen representation.