twinflow-one-step-generation

name	twinflow-one-step-generation
title	TwinFlow: Realizing One-step Generation on Large Models with Self-adversarial Flows
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2512.05150
keywords	["one-step generation","self-adversarial flows","diffusion models","efficient inference","generative models"]
description	Train single-step image generators without teacher models or standard adversarial networks. Achieves 0.83 GenEval score at 1-NFE with 100× computational efficiency gains—when you need real-time image synthesis from pre-trained diffusion models.

Overview

TwinFlow simplifies training efficient one-step generators by eliminating the need for pretrained teacher models and external adversarial networks. The core innovation is "self-adversarial flows," which provides adversarial training benefits through an internal mechanism, reducing memory overhead while maintaining performance parity with multi-step models.

When to Use

• Real-time image generation from pre-trained diffusion models (1 function evaluation needed)
• Scaling generation across large models (successfully demonstrated on Qwen-Image-20B)
• Scenarios where teacher models or auxiliary networks add memory burden
• Applications requiring high-quality output with minimal computational cost

When NOT to Use

• Tasks requiring iterative refinement or control over output quality
• Models that already have optimized inference pipelines
• Scenarios where you need multi-turn interaction for content generation

Core Technique

The self-adversarial flows framework trains generators through internal adversarial mechanisms:

# Simplified conceptual overview of self-adversarial training
class SelfAdversarialGenerator:
    def __init__(self, base_model):
        self.generator = base_model

    def train_step(self, batch):
        # Generate one-step output
        output = self.generator(batch, steps=1)

        # Internal adversarial mechanism computes loss
        # without external discriminator or teacher
        loss = self.compute_internal_adversarial_loss(output)
        return loss

    def compute_internal_adversarial_loss(self, output):
        # Quantifies deviation from multi-step baseline
        # through latent-space comparison
        reference = self.generator(output.detach(), steps=)
         mse_loss(output, reference)