Video models today are too slow/expensive and lack sufficient controls. Creativity is an iterative process. You make, you tweak, you get better. In our opinion, they're not usable yet for storytelling.

When we set out to build Linum v3 (our next video model) earlier this year, the primary goal was to bring the cost envelope of inference down significantly. If our model is fast and cheap, it's the first step (of many) towards useful creative tools.

Typically, you see "latent diffusion models". A VAE (Variational Autoencoder) compresses the input data into a smaller "latent space" and the diffusion model learns how to generate within this subspace.

Over the past few months, we've been publishing our work on efficient pixel-space diffusion models. These throw away the VAE, having the diffusion model learn a latent-space optimized for its exact task.

This serves 3 purposes: 1) Simplify Architecture (no 2-stage model training) 2) Faster Convergence (11x faster convergence vs. our latent diffusion counterpart) 3) Cheaper Inference (4x more aggressive token reduction in attention context-windows, without significant loss in quality)

This past month we were pressure testing our latest architecture (Pyramid-JiT) by training a text-to-image model longer than the typical one-off experiment. Specifically, we trained it for ~$20K on 660M samples.

We were surprised by the quality of results, so we thought we'd release it as open weights for the community (Apache 2.0). The research itself is already public, on our website.

For us, it's a big stepping stone towards cheaper video models, since pretty much all video models start as image models. We like to say these models have to learn nouns before they learn verbs.

Comments URL: https://news.ycombinator.com/item?id=50368208

Points: 284

# Comments: 29

Empirically they learn an approximation to the derivative of the likelihood (Ie the score function). So we have a bound on the true likelihood distribution, but don’t have exact likelihoods (which we do have in LLMs).

In practice this bound is too loose to be used for train with GRPO effectively (though folks have tried).

The linear patchificaion is per patch, so if it works on 360p 2 seconds (really short low res) it should adapt naturally (given ROPE3D). The final layers of the DiT start moving us from latent space to pixel space.

Net net the compression is as much as H3 (32x32xTime) so it should be comparable to the best VAEs in terms of expense

Very related; our models are quite literally cousins, as we’re both interesting on the work of JiT from last fall.

Architecture is roughly the same up to some minor differences (they use MM-DiT from FLUX, we use single stream from Z-Image).

The biggest delta is that we’re going with 32x32 token reduction and they go for 16x16. Our goal here was to cut attention windows 4x to speed up training inference. And have been publishing work (this included) on how to match models with less compression to than us.

In this blog specifically there are 3 things we stack on top of each other to get good results:

1) transformer blocks per modality before they enter shared single stream transformer blocks

2) very different noise schedules during training than those proposed in prior work

3) predicting the output at k different resolutions along the depth of the diffusion transformer to provide gradient signal earlier in the network to learn better (and faster)

The other work does a great job scaling up the JiT to 3B parameter; this is purely an experimental release highlighting how we make up the gap.

The jumping point for this no-VAE work was three-fold:

1) Our goal here is to get 32x32 token reduction to make video training and inference downstream cheaper. To date, the best open-weight Image VAEs like Flux-2 seem to cap out at 16x16 token reduction (8x8 VAE + 2x2 linear patchification). Others like H3 have pushed to 32x32 reduction but requires them swapping out the small VAE decoder with a 2B parameter decoder. So, this is a foray to get 32x32 compression without compromising quality.

2) We believe that end-to-end trained networks will tend to perform better than modularly trained networks (e.g. VAE + DiT). This hypothesis comes from work like REPA-E, where authors are able to get much better results by backpropagating through the pretrained VAE. The latent space for perception / reconstruction seems to have a different "optimal" configuration than a latent space specifically built for generation. That's why we liked the idea of trained E2E here.

3) There's work with VAEs that show that providing additional modalities (e.g. text captions) can help the VAEs improve as well. That's natural to this construction, so we thought language might actually help with the compression, not hurt. To be honest, this this is the most hypothetical of three ideas; and definitely warrants specific ablations.

From our POV, this quite an experimental checkpoint. That's why we've dubbed it a research release. Our goal is to share our findings (and checkpoints) along the way to a legit image and video release for Linum v3.

Image release should be out in the coming weeks, so stay tuned for that. Video will take a little longer (we're doing on-going research atm on pixel-space video training).

If we have extra compute lying around in the coming weeks, we’ll try this out and report back. It’s a good idea :)

Can you confirm I'm understanding correctly?

1) Linear unpatchify as usual to go from hidden states to pixel space

2) Attention within a local window (e.g. 3x3, 5x5) to "blend" pixel space data and come up with a better image (as an alternative to MLP or Convolution)

And follow up questions:

1) How do you handle boundaries between your "attention windows"? Do you move the window just like a convolution does or are the "attention windows" all mutually exclusive from one another?

2) How much faster/slower is this operation vs. a linear layer + MLP?

GenEval and GenEval2 prompts are very terse (~10 tokens) while these models are primarily trained on long-dense captions. So, it's pretty common to upsample prompts before running them through benchmarks. That way you're testing the model as it was trained, rather than testing it on prompts that are out of distribution.

If you look at the Qwen-Image Report before they enhanced it for their 12-25 release, upsampled prompts score 0.87 on GenEval* In this paper they take it from 0.74 to 0.81.

To me that reads to me that they're basically getting the model to adapt to the benchmarks' terse prompts. And it's unclear to me if simply finetuning the model on shorter prompts would work just as well as the RL solution.

* https://arxiv.org/pdf/2508.02324v1#page=21

For context, we're a 2-person lab training generative video models. Goal is a new set of controllable, animation tools (you can read more about that here https://www.linum.ai/about if you're curious).

The biggest bottleneck for our last text-to-video model in terms of training and inference cost is attention. Video models are incredibly token dense (e.g. 110K tokens for a several second clip). If we can condense that context window more aggressively, we can train bigger models for a lot less $$ and offer them to prosumers at reasonable price points (unlike the big models today like Seedance, which cost an arm and a leg to run).

Traditionally, image and video models have two disjoint components: VAE (Variational Autoencoder) and Diffusion Transformer (DiT). They're trained separately, and empirically VAEs seems to struggle to get past 16x16 token reduction.

Here, we're switching to pixel-space, throwing away the VAE, and achieving 32x32 token reduction (4x smaller context windows) while learning a better overall model in a fraction of the training samples.

The central thesis is "simpler is better". If we can put the compression problem into the more powerful Diffusion Transformer (DiT) would should be able to learn a "latent space" optimized for generation and get better compression without hurting generation quality.

I'll be checking this post off and on the next couple of hours, so feel free to drop questions below. And I'll try to answer them to the best of my ability.

P.S. The model checkpoints from this blog are Apache 2.0, so feel to try playing with it yourself on a GPU!

Comments URL: https://news.ycombinator.com/item?id=49983582

Points: 55

# Comments: 19

For us specifically, we want to target prosumers who aren’t gonna pay $1 for a few seconds of footage. It has to be 1/50th of the cost of the big guys. It helps that our ultimate focus/niche is animation, so we can get away with smaller models.

But to answer question more broadly, I think you have to ask the questions:

1) How will this lab front run the hyperscalers? Is there someone thing they’re doing (or if executed correctly) could break right such that they could have a hook for customers to use the product over hypscaler (eg crazy low cost of inference)?

2) If this lab lands the hook and gets small lead how could they maintain and grow it? This doesn’t have to be technical per say. It could be a clear land and expand sales motion at the enterprise level, for example.

Startup history is littered with examples of companies that seemed too close to a big guy to sprout up in the first place (eg stripes adjacency to PayPal).

From the outside looking in it might seem likes there no space for the lab to bloom; so you’ll have to bring the specifics of the lab and your on the ground expertise of the space / company’s situation to come to an answer for yourself.

When it comes to multi-resolution training (e.g. matryoshka training), there are precedents that don't require this AR formulation.

They cite MAR (https://arxiv.org/pdf/2406.11838), which I think is a much clearer articulation of "autoregressive diffusion". MAR uses an autoregressive base (like an LLM) and staples on a small MLP on-top that's trained as a diffusion head. That makes more sense to me, since you can leverage the "knowledge prior" from an LLM and have it generate images. That's probably how nano-bannana and GPT-Image broadly work.

Zooming out, it's not clear to me from any of the work WHY autoregressive diffusion on it's own is better than regular diffusion. Most autoregressive diffusion models use speculative decoding, because pure autoregressive diffusion is too slow to run at inference time.

The one ~magical~ thing about auto-regressive diffusion (IMO) has nothing to do with autoregressive vs. fully-bidirectional diffusion. But simply, the face that you can do it on-top of a LLM. That means the LLM can look at it's generation, assess it's quality, think on what's broken, and then call itself to edit the image and fix it. With methods like RLVR, that means you can essentially guarantee the correctness of your image (along the axes you've RLVR-ed).

When it comes to inference it should also be cheaper (since we’ve cut attention sequence length by 4x), but I don’t have a hard number for you how much cheaper for inference

Comments URL: https://news.ycombinator.com/item?id=49729816

Points: 56

# Comments: 10