Proposal: Use semantic compression as input diffusion to read sessions larger than the context window [R]
Our take
The challenge of maintaining coherence in extended AI sessions is a persistent one, and the proposal for "diffusive semantic compression" offers a compelling, if nascent, approach. Current strategies often involve context window limitations or aggressive compaction, both of which can sacrifice vital nuance and non-local information—the subtle connections that give a session its depth and meaning. As explored in [Contrastive Decoding Diffing (CDD): recovering verbatim finetuning data from logits alone, no weight access needed[R]], the ability to extract and preserve verbatim data from LLMs is increasingly vital, yet challenging. This proposed technique attempts to sidestep those issues by drawing inspiration from image diffusion models, applying a coarse-to-fine processing strategy to long text sequences. It’s refreshing to see an exploration that isn’t solely focused on brute-force scaling of context windows, and instead considers a more elegant, structured approach to long-context understanding. The core idea – using compression as a form of “noise” and progressively refining the output – is conceptually intriguing and deserves further investigation, particularly as the field grapples with the limitations of existing retrieval methods.
The novelty, as the author notes, lies in the application of compression as a dynamic input mechanism, rather than simply masking tokens as seen in traditional diffusion models. This position-aware process, combined with semantic compression ensuring structural integrity, differentiates it from existing recursive language models like those discussed in [Recursive Language Models is one of the closest (source and output on disk, process recursively)]. While initial testing with smaller models like Qwen2.5 7B hasn't yet yielded consistently reliable end-to-end success against a simple dense read – a finding mirrored in the struggles to prevent models from exhibiting a subtle "Sameness" creeping into model outputs lately [Does anyone have a name for that subtle "Sameness" creeping into model outputs lately? [R]] – the potential remains significant. The acknowledgement of the substantial overlap with prior art is commendable and demonstrates a grounded understanding of the landscape. The focus on designing nuance evaluation metrics, rather than solely relying on factual recall or numerical composition, is particularly important for assessing the true impact of this technique.
The proposed workflow, visualized at the provided demo link, offers a clear picture of the process. The idea of progressively revealing detail, starting with a compressed outline and then iteratively refining with less compressed slices, mirrors how humans often process complex information. The ability for the model to adapt its behavior based on the "pass" it’s on – whether to generate an outline or add detail – also speaks to a level of control not always present in current LLM interactions. The author’s commitment to transparency, publishing pre-registered failures and parser bugs, builds trust and encourages collaborative development. The immediate next step – a small model fine-tune with position-aware training – represents a crucial test of the core hypothesis, and the call for external collaboration and compute resources is a valuable contribution to the open-source AI community.
Ultimately, the success of diffusive semantic compression hinges on whether position-aware training can unlock its full potential. While the initial results are preliminary, the underlying concept tackles a fundamental limitation in current long-context AI systems. The approach offers a pathway to preserving the holistic understanding that is often lost in fragmented retrieval or aggressive compaction. The question now is whether this innovative application of compression can truly bridge the gap between linear context windows and the complex, interconnected nature of human thought, and what new avenues of exploration it might unlock for AI-native spreadsheet technology and beyond.
I've been trying to come up with a solution for keeping extremely long ai sessions coherent. Sometimes there is too much substance to risk compaction. With so much buzz around diffusion going on it got me thinking, what if we treat the context like a progressive render, blurry>sharp.
The practical way to make text "blurry" is compression. This is a "diffusion inspired" system which borrows the coarse-to-fine process, not the formal math. It uses semantic compression so the overall structure of the session stays intact. Read the compressed version first to build an outline. Then read progressively less compressed slices until you're reading small verbatim chunks that give full detail.
So you're basically using compression as noise on the input side, then progressively building an output. Each slice is compressed to fit within the context window, so the model only ever needs to read the current slice+input+current output.
Tell the model what pass it's on, so it knows whether to write an outline or add detail.
The thing I'm actually trying to preserve is what you'd call "non-local information". Think of it as stuff that surfaces when looking at the whole session & doesn't survive fragmented retrieval. Retrieval misses it, compaction deletes it. Both miss what only exists in a holistic view.
Here is a visual demonstration to get a general idea of the workflow. https://dev-boz.github.io/diffusive-semantic-compression/demo/architecture-demo.html
There is substantial overlap with lots of prior art, Recursive Language Models is one of the closest (source and output on disk, process recursively). I wrote most of this before I found RLM and nearly gave up before realising there was still a small part that was novel. As far as I can tell there's no exact match for this particular implementation. Please let me know if I've missed one.
The difference to regular masked diffusion is in changing the length of the input rather than just masking.
What seems to be new ground is using compression as noise and a position-aware process.
I've done some basic testing. Mainly to see if it was at all viable. Just some basic tests using small models like Qwen2.5 7B. The untrained models show that they can do each part (outline, refine, add detail) but they struggle with the full end-to-end process. There 's occasional end-to-end success, but it's nowhere near reliable. On untrained models it also hasn't yet beaten a cheap dense read of the same document. The main bet is whether position-aware training changes that, I haven't been able to test that yet. I've published all the pre-registered failures, parser bugs I found etc.
Another note: the goal is preserving structure and nuance, but the tests so far measure planted facts and split-up numeric composition. Mainly because the experiments needed answers you can actually score. The nuance evaluation is being designed but isn't ready yet.
The next step is a small model fine tune to test if position aware training can help.
If you have the time to look at the idea, it really needs a prior art check from anyone who knows the diffusion-LM/long-context space. And if anyone wanted to help expand the idea or contribute with compute or collaboration for the fine-tune please do.
Here is the repo for the proposal. Links to testing repo and prior art inside.
https://github.com/dev-boz/diffusive-semantic-compression
[link] [comments]
Read on the original site
Open the publisher's page for the full experience