@simulatte/doppler 0.1.9 → 0.2.0

package/src/debug/reference/hf_qwen35_linear_attn_debug.py

@@ -1,268 +0,0 @@
-#!/usr/bin/env python3
-"""
-Dump intermediate values from Qwen3.5 linear attention (GatedDeltaNet) for comparison with Doppler.
-
-Usage:
-    HF_HOME=/media/x/models/huggingface_cache python3 src/debug/reference/hf_qwen35_linear_attn_debug.py
-"""
-
-import os
-import torch
-import numpy as np
-
-os.environ.setdefault("HF_HOME", "/media/x/models/huggingface_cache")
-
-from transformers import AutoModelForCausalLM, AutoTokenizer
-
-MODEL_ID = "Qwen/Qwen3.5-0.8B"
-PROMPT = "Hello"
-
-
-def stats(name, tensor):
-    t = tensor.float().detach().flatten()
-    print(f"  {name}: shape={list(tensor.shape)}, "
-          f"min={t.min().item():.6f}, max={t.max().item():.6f}, "
-          f"mean={t.mean().item():.6f}, absMax={t.abs().max().item():.6f}")
-    first8 = t[:8].tolist()
-    print(f"    first8: {[f'{v:.6f}' for v in first8]}")
-
-
-def main():
-    print(f"Loading {MODEL_ID}...")
-    model = AutoModelForCausalLM.from_pretrained(MODEL_ID, dtype=torch.float32)
-    tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
-    model.eval()
-
-    inputs = tokenizer(PROMPT, return_tensors="pt")
-    input_ids = inputs["input_ids"]
-    print(f"Prompt: '{PROMPT}', Token IDs: {input_ids[0].tolist()}")
-    num_tokens = input_ids.shape[1]
-
-    # Dump key weight values for layer 0
-    layer0 = model.model.layers[0]
-    attn = layer0.linear_attn
-
-    print(f"\n=== Layer 0 weights ===")
-    if hasattr(attn, 'A_log'):
-        a_log = attn.A_log.detach().float()
-        a_neg_exp = -torch.exp(a_log)
-        stats("A_log", a_log)
-        stats("a_neg_exp", a_neg_exp)
-    if hasattr(attn, 'dt_bias'):
-        stats("dt_bias", attn.dt_bias.detach().float())
-    stats("conv1d.weight", attn.conv1d.weight.detach().float())
-    stats("norm.weight", attn.norm.weight.detach().float())
-
-    # Hook into the linear_attn module to capture its input and output
-    captured = {}
-
-    def hook_linear_attn_input(module, args, kwargs):
-        if len(args) > 0:
-            captured['linear_attn_input'] = args[0].detach().clone()
-        return None
-
-    def hook_linear_attn_output(module, args, kwargs, output):
-        if isinstance(output, tuple):
-            captured['linear_attn_output'] = output[0].detach().clone()
-        else:
-            captured['linear_attn_output'] = output.detach().clone()
-        return None
-
-    # Hook into individual projection layers
-    def make_hook(name):
-        def hook(module, input, output):
-            captured[name] = output.detach().clone()
-        return hook
-
-    hooks = []
-    hooks.append(attn.register_forward_pre_hook(hook_linear_attn_input, with_kwargs=True))
-    hooks.append(attn.register_forward_hook(hook_linear_attn_output, with_kwargs=True))
-    hooks.append(attn.in_proj_qkv.register_forward_hook(make_hook('qkv_proj')))
-    hooks.append(attn.in_proj_z.register_forward_hook(make_hook('z_proj')))
-    hooks.append(attn.in_proj_a.register_forward_hook(make_hook('a_proj')))
-    hooks.append(attn.in_proj_b.register_forward_hook(make_hook('b_proj')))
-    hooks.append(attn.out_proj.register_forward_hook(make_hook('out_proj')))
-    hooks.append(attn.conv1d.register_forward_hook(make_hook('conv1d_raw')))
-    hooks.append(attn.norm.register_forward_hook(make_hook('gated_norm')))
-
-    # Also hook input_layernorm
-    hooks.append(layer0.input_layernorm.register_forward_hook(make_hook('input_layernorm')))
-
-    print(f"\n=== Running forward pass ===")
-    with torch.no_grad():
-        outputs = model(input_ids, output_hidden_states=True)
-
-    # Remove hooks
-    for h in hooks:
-        h.remove()
-
-    print(f"\n=== Captured intermediates ===")
-    for name in ['input_layernorm', 'qkv_proj', 'z_proj', 'a_proj', 'b_proj',
-                  'conv1d_raw', 'gated_norm', 'linear_attn_input', 'linear_attn_output', 'out_proj']:
-        if name in captured:
-            stats(name, captured[name])
-        else:
-            print(f"  {name}: NOT CAPTURED")
-
-    # Hidden states per layer
-    print(f"\n=== Hidden states per layer (last token) ===")
-    for i in range(min(6, len(outputs.hidden_states) - 1)):
-        hs = outputs.hidden_states[i + 1]
-        t = hs[0, -1]  # last token
-        vals = t[:8].tolist()
-        max_abs = t.abs().max().item()
-        mean_abs = t.abs().mean().item()
-        layer_type = type(model.model.layers[i]).__name__
-        attn_type = "linear" if hasattr(model.model.layers[i], 'linear_attn') else "full"
-        print(f"  Layer {i} ({attn_type}): first8={[f'{v:.4f}' for v in vals]}, "
-              f"maxAbs={max_abs:.4f}, meanAbs={mean_abs:.4f}")
-
-    # Logits
-    logits = outputs.logits[0, -1]
-    top5 = torch.topk(logits, 5)
-    print(f"\nTop-5 logits: {[(tokenizer.decode([idx.item()]), f'{val.item():.2f}') for val, idx in zip(top5.values, top5.indices)]}")
-
-    # Also trace through the linear attention manually to compare with Doppler's kernel
-    print(f"\n=== Manual linear attention trace (layer 0) ===")
-    with torch.no_grad():
-        embed = model.model.embed_tokens(input_ids)
-        normed = layer0.input_layernorm(embed)
-        stats("normed_input", normed)
-
-        qkv = attn.in_proj_qkv(normed)
-        stats("qkv", qkv)
-
-        # The HF Qwen3.5 GatedDeltaNet does conv1d on the QKV, then applies SiLU
-        # The conv1d expects [batch, channels, seq_len] format
-        qkv_t = qkv.transpose(1, 2)  # [1, 6144, 1]
-
-        # Use the conv1d module directly (it has padding configured)
-        conv_raw = attn.conv1d(qkv_t)
-        stats("conv_raw (from module)", conv_raw.transpose(1, 2))
-
-        # Truncate to seq_len (causal conv padding)
-        conv_causal = conv_raw[..., :num_tokens]
-        stats("conv_causal (truncated)", conv_causal.transpose(1, 2))
-
-        # Apply SiLU
-        conv_silu = torch.nn.functional.silu(conv_causal)
-        stats("conv_silu", conv_silu.transpose(1, 2))
-
-        # Split Q, K, V
-        conv_out = conv_silu.transpose(1, 2)  # [1, seq_len, 6144]
-        num_k_heads = 16
-        head_k_dim = 128
-        head_v_dim = 128
-        num_v_heads = 16
-        q_size = num_k_heads * head_k_dim  # 2048
-        k_size = q_size
-        v_size = num_v_heads * head_v_dim  # 2048
-
-        q = conv_out[..., :q_size]
-        k = conv_out[..., q_size:q_size + k_size]
-        v = conv_out[..., q_size + k_size:]
-        stats("Q (raw)", q)
-        stats("K (raw)", k)
-        stats("V (raw)", v)
-
-        # Reshape for per-head processing
-        # Q and K: [batch, seq, num_k_heads, head_k_dim]
-        q_heads = q.view(1, num_tokens, num_k_heads, head_k_dim)
-        k_heads = k.view(1, num_tokens, num_k_heads, head_k_dim)
-        v_heads = v.view(1, num_tokens, num_v_heads, head_v_dim)
-
-        # L2 normalize Q and K
-        eps = 1e-6
-        q_norm = torch.nn.functional.normalize(q_heads, p=2, dim=-1, eps=eps)
-        k_norm = torch.nn.functional.normalize(k_heads, p=2, dim=-1, eps=eps)
-
-        # Scale Q by 1/sqrt(head_k_dim)
-        head_scale = 1.0 / (head_k_dim ** 0.5)
-        q_scaled = q_norm * head_scale
-
-        stats("Q_normed_scaled (per-head)", q_scaled.reshape(1, num_tokens, -1))
-        stats("K_normed (per-head)", k_norm.reshape(1, num_tokens, -1))
-
-        # Projections for gating
-        z = attn.in_proj_z(normed)
-        a_out = attn.in_proj_a(normed)
-        b_out = attn.in_proj_b(normed)
-        stats("z", z)
-        stats("a", a_out)
-        stats("b", b_out)
-
-        # Compute gating values
-        a_log = attn.A_log.detach().float()
-        a_neg_exp = -torch.exp(a_log)
-        dt_bias = attn.dt_bias.detach().float()
-
-        softplus_input = a_out.squeeze(0).squeeze(0) + dt_bias
-        softplus_val = torch.nn.functional.softplus(softplus_input)
-        g = a_neg_exp * softplus_val
-        g_exp = torch.exp(g)
-        beta = torch.sigmoid(b_out.squeeze(0).squeeze(0))
-
-        stats("softplus(a + dt_bias)", softplus_val.unsqueeze(0).unsqueeze(0))
-        stats("g (decay)", g.unsqueeze(0).unsqueeze(0))
-        stats("g_exp (decay factor)", g_exp.unsqueeze(0).unsqueeze(0))
-        stats("beta (sigmoid(b))", beta.unsqueeze(0).unsqueeze(0))
-
-        # Recurrent state update (for first token, state is all zeros)
-        # state[head, kd, vd] = state * g_exp + k[kd] * delta[vd]
-        # where delta[vd] = (v[vd] - state^T @ k * beta
-        # For zero state: delta[vd] = v[vd] * beta, state = k ⊗ delta
-        state = torch.zeros(num_v_heads, head_k_dim, head_v_dim)
-
-        # Apply decay (no-op for zero state)
-        for head in range(num_v_heads):
-            state[head] *= g_exp[head].item()
-
-            k_head = k_norm[0, 0, head % num_k_heads]  # broadcast q_rep
-            v_head = v_heads[0, 0, head]
-
-            # kv_mem = state @ k
-            kv_mem = state[head].t() @ k_head  # [head_v_dim]
-
-            # delta = (v - kv_mem) * beta
-            delta = (v_head - kv_mem) * beta[head].item()
-
-            # state += outer(k, delta)
-            state[head] += torch.outer(k_head, delta)
-
-        # Output: out = state^T @ q
-        output_per_head = torch.zeros(1, num_tokens, num_v_heads, head_v_dim)
-        for head in range(num_v_heads):
-            q_head = q_scaled[0, 0, head % num_k_heads]
-            out_head = state[head].t() @ q_head  # [head_v_dim]
-            output_per_head[0, 0, head] = out_head
-
-        raw_out = output_per_head.reshape(1, num_tokens, num_v_heads * head_v_dim)
-        stats("Recurrent output (raw)", raw_out)
-
-        # RMS norm per head + SiLU gate
-        z_reshaped = z.view(1, num_tokens, num_v_heads, head_v_dim)
-        norm_weight = attn.norm.weight.detach().float()  # [head_v_dim] (shared mode)
-        rms_eps = 1e-6
-
-        for head in range(num_v_heads):
-            head_out = output_per_head[0, 0, head]  # [head_v_dim]
-            mean_sq = (head_out ** 2).mean()
-            inv_rms = 1.0 / torch.sqrt(mean_sq + rms_eps)
-            z_gate = torch.nn.functional.silu(z_reshaped[0, 0, head])
-            output_per_head[0, 0, head] = head_out * inv_rms * norm_weight * z_gate
-
-        gated_out = output_per_head.reshape(1, num_tokens, num_v_heads * head_v_dim)
-        stats("After RMSNorm + SiLU gate", gated_out)
-
-        # Output projection
-        o_result = torch.nn.functional.linear(gated_out, attn.out_proj.weight)
-        stats("After out_proj", o_result)
-
-        # Compare with captured output
-        if 'linear_attn_output' in captured:
-            diff = (o_result - captured['linear_attn_output']).abs()
-            print(f"\n  Diff vs captured output: maxDiff={diff.max().item():.6f}")
-
-
-if __name__ == "__main__":
-    main()

package/src/debug/reference/hf_rope_check.py

@@ -1,116 +0,0 @@
-#!/usr/bin/env python3
-"""
-Verify RoPE (Rotary Position Embedding) values match between HF and DOPPLER.
-
-Usage:
-    python hf_rope_check.py <config.json>
-
-Config (JSON):
-    {
-      "model": "google/gemma-2-2b-it",
-      "pos": 6,
-      "dim": 256,
-      "theta": 10000.0
-    }
-
-Requires: pip install torch transformers
-"""
-
-import json
-import math
-import sys
-import torch
-from transformers import AutoModelForCausalLM
-
-
-def compute_rope_freqs(head_dim: int, theta: float = 10000.0):
-    """Compute RoPE frequencies for a given head dimension."""
-    freqs = 1.0 / (theta ** (torch.arange(0, head_dim, 2).float() / head_dim))
-    return freqs
-
-
-def apply_rope_to_vector(x: torch.Tensor, pos: int, freqs: torch.Tensor):
-    """Apply RoPE to a single vector at a given position."""
-    # x shape: [head_dim]
-    angles = pos * freqs
-    cos = torch.cos(angles)
-    sin = torch.sin(angles)
-
-    # Split into pairs
-    x_even = x[0::2]
-    x_odd = x[1::2]
-
-    # Apply rotation
-    out_even = x_even * cos - x_odd * sin
-    out_odd = x_even * sin + x_odd * cos
-
-    # Interleave back
-    out = torch.zeros_like(x)
-    out[0::2] = out_even
-    out[1::2] = out_odd
-
-    return out
-
-
-def main():
-    if len(sys.argv) != 2:
-        raise SystemExit("Usage: python hf_rope_check.py <config.json>")
-    path = sys.argv[1]
-    with open(path, "r", encoding="utf-8") as handle:
-        config = json.load(handle)
-    if not isinstance(config, dict):
-        raise SystemExit("Config must be a JSON object")
-
-    model_id = config.get("model")
-    pos = config.get("pos")
-    dim = config.get("dim")
-    theta = config.get("theta")
-
-    if not isinstance(model_id, str) or not model_id.strip():
-        raise SystemExit('Config "model" must be a non-empty string')
-    if not isinstance(pos, int):
-        raise SystemExit('Config "pos" must be an integer')
-    if not isinstance(dim, int):
-        raise SystemExit('Config "dim" must be an integer')
-    if not isinstance(theta, (int, float)):
-        raise SystemExit('Config "theta" must be a number')
-
-    print(f"RoPE Check for position {pos}, head_dim={dim}, theta={theta}")
-
-    # Compute frequencies
-    freqs = compute_rope_freqs(dim, theta)
-    print(f"\nFrequencies (first 8): {freqs[:8].tolist()}")
-
-    # Compute angles at position
-    angles = pos * freqs
-    print(f"Angles at pos {pos} (first 8): {angles[:8].tolist()}")
-
-    # Compute cos/sin
-    cos = torch.cos(angles)
-    sin = torch.sin(angles)
-    print(f"Cos at pos {pos} (first 8): {cos[:8].tolist()}")
-    print(f"Sin at pos {pos} (first 8): {sin[:8].tolist()}")
-
-    # Test with a sample vector
-    test_vec = torch.randn(dim)
-    test_vec[0] = 1.0
-    test_vec[1] = 0.0
-    print(f"\nTest vector (first 8): {test_vec[:8].tolist()}")
-
-    rotated = apply_rope_to_vector(test_vec, pos, freqs)
-    print(f"After RoPE (first 8): {rotated[:8].tolist()}")
-
-    # Also load model and check actual RoPE config
-    print(f"\nLoading model to verify config: {model_id}")
-    model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.float32, device_map="cpu")
-    config = model.config
-
-    print(f"\nModel RoPE config:")
-    print(f"  rope_theta: {getattr(config, 'rope_theta', 'not set')}")
-    print(f"  head_dim: {config.head_dim}")
-    if hasattr(config, 'rope_scaling'):
-        print(f"  rope_scaling: {config.rope_scaling}")
-
-
-if __name__ == "__main__":
-    main()

package/src/debug/reference/hf_weights.py

@@ -1,75 +0,0 @@
-#!/usr/bin/env python3
-"""
-Dump weight values for Q/K/V/O projections from HuggingFace model.
-
-Usage:
-    python hf_weights.py <config.json>
-
-Config (JSON):
-    {
-      "model": "google/gemma-2-2b-it",
-      "layer": 0,
-      "proj": "all"
-    }
-
-Requires: pip install torch transformers
-"""
-
-import json
-import sys
-import torch
-from transformers import AutoModelForCausalLM
-
-
-def main():
-    if len(sys.argv) != 2:
-        raise SystemExit("Usage: python hf_weights.py <config.json>")
-    path = sys.argv[1]
-    with open(path, "r", encoding="utf-8") as handle:
-        config = json.load(handle)
-    if not isinstance(config, dict):
-        raise SystemExit("Config must be a JSON object")
-
-    model_id = config.get("model")
-    layer_index = config.get("layer")
-    proj = config.get("proj")
-
-    if not isinstance(model_id, str) or not model_id.strip():
-        raise SystemExit('Config "model" must be a non-empty string')
-    if not isinstance(layer_index, int):
-        raise SystemExit('Config "layer" must be an integer')
-    if proj not in ["q", "k", "v", "o", "all"]:
-        raise SystemExit('Config "proj" must be one of: q, k, v, o, all')
-
-    print(f"Loading model: {model_id}")
-    model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.float32, device_map="cpu")
-
-    layer = model.model.layers[layer_index]
-    attn = layer.self_attn
-
-    projections = {
-        "q": attn.q_proj,
-        "k": attn.k_proj,
-        "v": attn.v_proj,
-        "o": attn.o_proj,
-    }
-
-    projs_to_show = list(projections.keys()) if proj == "all" else [proj]
-
-    for name in projs_to_show:
-        proj = projections[name]
-        weight = proj.weight.data  # [out_features, in_features]
-
-        print(f"\n{name.upper()}_proj weight shape: {weight.shape}")
-        print(f"{name.upper()}_proj weight[0, :8] (first row, first 8 cols):")
-        print(f"  {weight[0, :8].tolist()}")
-        print(f"{name.upper()}_proj weight[:8, 0] (first 8 rows, first col):")
-        print(f"  {weight[:8, 0].tolist()}")
-
-        # Some specific indices for comparison
-        if weight.shape[1] > 100:
-            print(f"{name.upper()}_proj weight[0, 100]: {weight[0, 100].item():.6f}")
-
-
-if __name__ == "__main__":
-    main()

package/src/debug/signals.d.ts

@@ -1,63 +0,0 @@
-/**
- * DOPPLER Debug Module - Completion Signals
- *
- * Standard completion signal prefixes for CLI/automation detection.
- *
- * Usage:
- *   console.log(`${SIGNALS.DONE} ${JSON.stringify({status: 'success', elapsed: 1234})}`);
- *   console.log(`${SIGNALS.RESULT} ${JSON.stringify(benchmarkData)}`);
- *   console.log(`${SIGNALS.ERROR} ${JSON.stringify({error: 'message'})}`);
- *
- * Detection (CLI/Puppeteer):
- *   if (text.startsWith('[DOPPLER:DONE]')) { ... }
- *
- * @module debug/signals
- */
-
-/**
- * Standard completion signal prefixes for CLI/automation detection.
- */
-export declare const SIGNALS: {
-  /** Task completed (success or error) - always emitted at end */
-  readonly DONE: '[DOPPLER:DONE]';
-  /** Full result payload (JSON) - emitted before DONE for data extraction */
-  readonly RESULT: '[DOPPLER:RESULT]';
-  /** Error occurred - can be emitted before DONE */
-  readonly ERROR: '[DOPPLER:ERROR]';
-  /** Progress update (optional) */
-  readonly PROGRESS: '[DOPPLER:PROGRESS]';
-};
-
-export type SignalType = keyof typeof SIGNALS;
-
-/**
- * Completion payload for DONE signal.
- */
-export interface DonePayload {
-  status: 'success' | 'error';
-  elapsed: number;
-  tokens?: number;
-  tokensPerSecond?: number;
-  error?: string;
-}
-
-/**
- * Emit a completion signal to console.
- * This is the standard way to signal task completion for CLI detection.
- */
-export declare function signalDone(payload: DonePayload): void;
-
-/**
- * Emit a result signal with full data payload.
- */
-export declare function signalResult(data: Record<string, unknown>): void;
-
-/**
- * Emit an error signal.
- */
-export declare function signalError(error: string, details?: Record<string, unknown>): void;
-
-/**
- * Emit a progress signal.
- */
-export declare function signalProgress(percent: number, message?: string): void;

package/src/debug/signals.js

@@ -1,39 +0,0 @@
-
-
-
-export const SIGNALS = {
-  
-  DONE: '[DOPPLER:DONE]',
-  
-  RESULT: '[DOPPLER:RESULT]',
-  
-  ERROR: '[DOPPLER:ERROR]',
-  
-  PROGRESS: '[DOPPLER:PROGRESS]',
-};
-
-
-export function signalDone(payload) {
-  console.log(`${SIGNALS.DONE} ${JSON.stringify(payload)}`);
-}
-
-
-export function signalResult(data) {
-  console.log(`${SIGNALS.RESULT} ${JSON.stringify(data)}`);
-}
-
-
-export function signalError(error, details) {
-  if (details != null && (typeof details !== 'object' || Array.isArray(details))) {
-    throw new Error('signalError details must be an object when provided.');
-  }
-  if (details && Object.hasOwn(details, 'error')) {
-    throw new Error('signalError details.error is reserved. Pass the primary error as the first argument.');
-  }
-  console.log(`${SIGNALS.ERROR} ${JSON.stringify({ error, ...(details ?? {}) })}`);
-}
-
-
-export function signalProgress(percent, message) {
-  console.log(`${SIGNALS.PROGRESS} ${JSON.stringify({ percent, message })}`);
-}

package/src/debug/stats.d.ts

@@ -1,47 +0,0 @@
-export interface SampleStats {
-  mean: number;
-  median: number;
-  min: number;
-  max: number;
-  p95: number;
-  p99: number;
-  stdDev: number;
-  ci95: number;
-  samples: number;
-  samplesAfterOutlierRemoval: number;
-  outliersRemoved: number;
-}
-
-export interface ArrayStats {
-  min: number;
-  max: number;
-  mean: number;
-  std: number;
-  maxAbs: number;
-  nanCount: number;
-  infCount: number;
-  zeroCount: number;
-  validCount: number;
-}
-
-export interface BasicStats {
-  mean: number;
-  min: number;
-  max: number;
-  total: number;
-  count: number;
-}
-
-export declare function percentile(sorted: number[], p: number): number;
-export declare function median(sorted: number[]): number;
-export declare function removeOutliersIQR(values: number[], multiplier?: number): {
-  filtered: number[];
-  removed: number;
-  lower: number;
-  upper: number;
-};
-export declare function sampleStdDev(values: number[], meanValue: number): number;
-export declare function confidenceInterval95(stdDev: number, n: number): number;
-export declare function computeSampleStats(values: number[], options?: { outlierIqrMultiplier?: number }): SampleStats;
-export declare function computeArrayStats(values: ArrayLike<number>, limit?: number): ArrayStats;
-export declare function computeBasicStats(values: number[]): BasicStats;