sodec-diffusion-compression

name	sodec-diffusion-compression
title	SODEC - Steering One-Step Diffusion for Fast Image Compression
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2508.04979
keywords	["image-compression","diffusion-models","generative-models","single-step-decoding"]
description	Replaces iterative diffusion with single-step decoding for image compression. Combines VAE latents with fidelity guidance and rate annealing training. Achieves 20× decoding speedup with improved perceptual quality.

SODEC: Steering One-Step Diffusion for Fast Image Compression

Core Concept

Traditional generative compression uses iterative diffusion refinement that requires dozens of denoising steps, making inference prohibitively slow. SODEC demonstrates that information-rich latent representations eliminate the need for iteration. By combining pre-trained VAE encodings with a fidelity guidance module and rate-annealing training strategy, the approach achieves single-step decoding with 20× speedup while maintaining or improving perceptual quality.

Architecture Overview

• VAE-Based Latent Generation: High-information-density latent representation
• Fidelity Guidance Module: Keeps generated images faithful to originals
• Single-Step Decoding: Direct latent-to-image generation without iteration
• Rate Annealing Training: Progressive adjustment of compression-quality trade-off
• Adaptive Rate Control: Dynamic bit allocation based on image complexity

Implementation Steps

Step 1: Build Information-Rich Latent Space

Create VAE-based latent representation that captures sufficient information for reconstruction.

import torch
import torch.nn as nn
from typing import Tuple

class InformationRichVAE(nn.Module):
    """
    VAE encoder that creates information-rich latents for compression.
    """

    def __init__(self, in_channels=3, latent_dim=16, hidden_dim=128):
        super().__init__()
        self.latent_dim = latent_dim

        # Encoder: image -> latent
        self.encoder = nn.Sequential(
            nn.Conv2d(in_channels, hidden_dim, 4, stride=2, padding=1),
            nn.ReLU(),
            nn.Conv2d(hidden_dim, hidden_dim * 2, , stride=, padding=),
            nn.ReLU(),
            nn.Conv2d(hidden_dim * , hidden_dim * , , stride=, padding=),
            nn.ReLU(),
            nn.AdaptiveAvgPool2d((, )),
            nn.Flatten()
        )

        .fc_mu = nn.Linear(hidden_dim *  * , latent_dim)
        .fc_logvar = nn.Linear(hidden_dim *  * , latent_dim)

        
        .fc_decode = nn.Linear(latent_dim, hidden_dim *  *  * )

        .decoder = nn.Sequential(
            nn.ConvTranspose2d(hidden_dim * , hidden_dim * , , stride=, padding=),
            nn.ReLU(),
            nn.ConvTranspose2d(hidden_dim * , hidden_dim, , stride=, padding=),
            nn.ReLU(),
            nn.ConvTranspose2d(hidden_dim, in_channels, , stride=, padding=),
            nn.Tanh()
        )

     () -> [torch.Tensor, torch.Tensor]:
        
        h = .encoder(x)
        mu = .fc_mu(h)
        logvar = .fc_logvar(h)

         mu, logvar

     () -> torch.Tensor:
        
        std = torch.exp( * logvar)
        eps = torch.randn_like(std)
         mu + eps * std

     () -> torch.Tensor:
        
        h = .fc_decode(z)
        h = h.view(h.shape[], -, , )
        x_recon = .decoder(h)

         x_recon

     () -> [torch.Tensor, torch.Tensor, torch.Tensor]:
        
        mu, logvar = .encode(x)
        z = .reparameterize(mu, logvar)
        x_recon = .decode(z)

         x_recon, mu, logvar