ISOM-R1-Reasoning-1.5B-Instruct (Upgraded with ISOM-R2 1M Engine)

Bounded-State Recurrent Manifold • ISOM-R2 1,000,000-Token Virtual SVD Cache • Verified on NVIDIA Tesla T4 Cloud GPU

🚀 ISOM-R2 1,000,000-Token Engine Upgrade

This repository has been upgraded with the ISOM-R2 architecture (ISOMR2VirtualSVDCache + ISOMR2Engine), the same 1M-token streaming-retrieval engine powering Prannesshkva/Aazhi-Coder-1.5B (verified 1,000,000-token benchmark notebook):

• Hierarchical Paged Virtual SVD Cache (ISOMR2VirtualSVDCache): Streams up to 1,048,576 tokens in 2,048-token chunks while keeping the active GPU KV buffer strictly under 400 MB VRAM (64 attention sinks + 2,048 rolling window + $2 \times 1,024$ retrieved salient micro-windows).
• Tier-2 Resonance Needle Vault (NeedleVaultBuffer) & Multi-Scale Spectral State (ISOMSpectralStateV2): Preserves high-saliency key-value pairs in a 26.37 MB CPU RAM vault and absorbs evicted keys into 8-channel $SO(2)$ Lie-algebra spectral accumulators ($\tau \approx 14$ to $\tau \approx 689\text{K}$ tokens).
• Hybrid Lexical + Dense Micro-Window Retrieval: Automatically intercepts prompts $> 2,048$ tokens inside model.generate() when use_isom_r2_svd=True (enabled by default in config.json), or via the standalone ISOMR2Engine in isom_r2_engine.py.

Overview

ISOM-R1-Reasoning-1.5B-Instruct-Beta is built on the Qwen2.5-1.5B-Instruct foundation, upgraded with both the native ISOM bounded-cache inference engine (IsomStateCache) and the ISOM-R2 1M Virtual SVD Cache (ISOMR2VirtualSVDCache). By pairing dynamic symmetric INT8 key-value quantization with multi-head landmark Shannon saliency pruning and host-assisted holographic anchor preservation, ISOM bounds active KV-cache growth to a constant memory footprint (e.g. 56.88 MB at budget 4,096, or 113.76 MB at budget 8,192). This eliminates linear KV memory expansion and mitigates activation spikes on resource-constrained edge accelerators (e.g., 8GB–16GB GPUs).

Memory derivation (budget = 4,096): The raw KV tensor cost is 28 layers × 2 KV-heads × 64 head-dim × 4,096 tokens × 1 byte (INT8) × 2 (K and V) = 56,000,768 bytes ≈ 56.00 MB. The remaining 0.88 MB is the per-token INT8 scale tensor: 28 × 2 KV-heads × 4,096 tokens × 2 bytes (float16) × 2 (K and V) = 917,504 bytes ≈ 0.88 MB. Total = 56.88 MB. At budget 8,192 both terms double to 113.76 MB. All stated figures are exact and include this overhead.

Compression ratio context: The 15.8× physical reduction figure is a peak measurement at 32,768-token sequences (ISOM 56.88 MB vs. vanilla BF16 32K KV cache 896.00 MB). The ratio scales linearly with sequence length: at 4,096 tokens the vanilla baseline uses 112 MB, giving a 2.0× ratio; at 8,192 tokens 224 MB for a 3.9× ratio. The headline 15.8× applies only at the 32K upper bound tested.

📊 Audited Empirical Hardware Telemetry (NVIDIA Tesla T4, Kaggle Cloud)

The following benchmark was executed on NVIDIA Tesla T4 (14.56 GB / 14,911.7 MB total VRAM, PyTorch 2.10.0+cu128, CUDA 12.8, Kaggle Cloud) directly comparing Prannesshkva/ISOM-R1-Reasoning-1.5B-Instruct-Beta against baseline Qwen/Qwen2-1.5B-Instruct using authentic literary prose (Pride and Prejudice, 728,846 characters, unpadded):

Authentic Literature Long-Context A/B Comparison

Key Hardware Findings:

1. Immediate Memory Wall Crash in Vanilla: Standard attention triggers a fatal CUDA OutOfMemoryError at 8,192 tokens of continuous reasoning, exceeding the 14.9 GB VRAM ceiling of the Tesla T4.
2. Bounded Execution: ISOM successfully deliberates across 8,192 tokens in 2.20 seconds within a stable 9,168.6 MB footprint.
3. Throughput Scaling: At 4,096 tokens, ISOM executes in 1.12 seconds versus 2.09 seconds for the baseline (nearly 2x faster).

Quickstart Inference

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "Prannesshkva/ISOM-R1-Reasoning-1.5B-Instruct-Beta"

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True
)
model.eval()

prompt = """<|im_start|>user
Let G be a finite group with |G| = 35. Prove that G is cyclic.<|im_end|>
<|im_start|>assistant
<thought>
"""

inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=512,
        temperature=0.6,
        do_sample=True
    )

print(tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True))

Citation & Licensing

@article{prannessh2026isom_reasoning,
  title={ISOM-R1-Reasoning-1.5B-Instruct: Bounded-Memory Deliberative Reasoning Engine},
  author={Prannessh K.V.A.},
  journal={CERN Zenodo},
  year={2026},
  doi={10.5281/zenodo.22649142},
  url={https://doi.org/10.5281/zenodo.22649142}
}

• Author & Architect: Prannessh K.V.A.
• LinkedIn: Prannessh K.V.A.
• License: Governed by CC BY-NC-ND 4.0 (Non-Commercial Research) & Enterprise Commercial Terms. See LICENSE.

Notice of Non-Endorsement & Independent Lineage

[!IMPORTANT] Independent Derivative Work: ISOM-R1-Reasoning-1.5B-Instruct is an independent development engineered solely by Prannessh K.V.A. (Author & Architect). It builds upon Qwen/Qwen2.5-1.5B-Instruct under the Apache 2.0 License. This research is not affiliated with, endorsed by, or sponsored by Alibaba Cloud or the Qwen team. All continuous isometric state operator manifolds, Cayley SO(d) projection operators, and memory-bounding integrations are proprietary contributions of the author.