Upload 2 files

gguf.py

@@ -462,12 +462,14 @@ def _is_attention_projection(name: str) -> bool:
 
 def _is_tiny_ssm_gate(name: str, dims: tuple[int, ...]) -> bool:
     """True for low-rank recurrent step-size/decay gates (e.g. ssm_alpha, ssm_beta, ssm_f_a/b)."""
+    if len(dims) < 2 or max(int(d) for d in dims) < 1024:
+        return False
     if any(
         k in name
         for k in ("ssm_alpha", "ssm_beta", "ssm_f_a", "ssm_f_b", "ssm_g_a", "ssm_g_b")
     ):
         return True
-    if ".ssm_" in name and len(dims) >= 2 and min(int(dims[0]), int(dims[1])) <= 128:
+    if ".ssm_" in name and min(int(dims[0]), int(dims[1])) <= 128:
         return True
     return False
 
@@ -517,6 +519,8 @@ def is_q1_0_eligible(
     """True for 128-aligned 2D/3D weight tensors eligible for Q1_0."""
     if _is_skipped_metadata_tensor(name, dims):
         return False
+    if _is_tiny_ssm_gate(name, dims):
+        return False
     if _is_embd_or_head(name) and not include_embd:
         return False
     if len(dims) < 2 or dims[0] % QK1_0 != 0:

q1_0.py

@@ -152,43 +152,39 @@ def _quantize_q1_0_hpc_cpu(
     lam_vw = (float(cfg.vw_lambda) / QK1_0) if cfg.use_spectral else 0.0
     half = QK1_0 // 2
 
-    # 1. Analog + WLS seed for d* (bounded around d_mean so outlier imatrix channels cannot collapse/explode d):
+    # 1. Iso-Energy / Geometric-Projection Analog + WLS seed for d*:
+    # Standard d_mean = mean(|x|) attenuates each linear projection by 2/pi (~0.637),
+    # shrinking SwiGLU FFN residual updates to 0.30x across layers.
+    # Projecting onto the geometric mean of the Iso-Energy RMS scale d_rms and the
+    # unbiased linear-projection scale d_proj = d_rms^2 / d_mean restores multi-layer
+    # residual norm (~0.82x == cos_theta) and improves multi-layer cosine similarity.
     d_mean = np.mean(np.abs(X_f32), axis=1).astype(np.float32)
-    d_lo = (0.80 * d_mean).astype(np.float32)
-    d_hi = (1.25 * d_mean).astype(np.float32)
     wsum = np.maximum(np.sum(W_f32, axis=1, keepdims=True), 1.0e-30)
-    d_wls_init = np.clip(
-        (np.sum(W_f32 * np.abs(X_f32), axis=1, keepdims=True) / wsum)[:, 0].astype(np.float32),
-        d_lo,
-        d_hi,
-    )
-    mu = np.sum(W_f32 * X_f32, axis=1, keepdims=True) / wsum
-    var = np.sum(W_f32 * (X_f32 - mu) ** 2, axis=1, keepdims=True) / wsum
-    sig = np.sqrt(np.maximum(var, 1.0e-30))
-    x_comp = mu + sig * 1.85 * np.tanh((X_f32 - mu) / (1.85 * sig))
-    d_analog = np.clip(
-        (np.sum(W_f32 * np.abs(x_comp), axis=1, keepdims=True) / wsum)[:, 0].astype(np.float32),
-        d_lo,
-        d_hi,
-    )
+    d_wls_l1 = (np.sum(W_f32 * np.abs(X_f32), axis=1, keepdims=True) / wsum)[:, 0].astype(np.float32)
+    d_wls_rms = np.sqrt(np.maximum((np.sum(W_f32 * X_f32 * X_f32, axis=1, keepdims=True) / wsum)[:, 0], 0.0)).astype(np.float32)
+    if cfg.use_weight_analogs:
+        ratio = np.clip(d_wls_rms / np.maximum(d_wls_l1, 1.0e-30), 1.0, 1.45).astype(np.float32)
+        d_center = (d_wls_rms * np.sqrt(ratio)).astype(np.float32)
+        d_lo = (0.85 * d_wls_rms).astype(np.float32)
+        d_hi = (1.35 * d_wls_rms).astype(np.float32)
+    else:
+        d_center = d_wls_l1
+        d_lo = (0.80 * d_mean).astype(np.float32)
+        d_hi = (1.25 * d_mean).astype(np.float32)
+
+    d_center = np.clip(d_center, d_lo, d_hi).astype(np.float32)
+    gain = (d_center / np.maximum(d_wls_l1, 1.0e-30))[:, None].astype(np.float32)
+    X_target = (X_f32 * gain).astype(np.float32)
 
     q_sign = (X_f32 >= 0.0).astype(np.float32)
     c_sign = 2.0 * q_sign - 1.0
-    wls_d = d_mean.copy()
-    best_seed_sse = np.full(B, np.inf, dtype=np.float64)
-    for d_start in (d_mean, d_wls_init, d_analog):
-        df = from_fp16_bits(to_fp16_bits(np.clip(d_start, d_lo, d_hi).astype(np.float32)))
-        e = X_f32 - df[:, None] * c_sign
-        sse = np.sum(W_f32 * e * e, axis=1, dtype=np.float64)
-        take = sse < best_seed_sse
-        best_seed_sse = np.where(take, sse, best_seed_sse)
-        wls_d = np.where(take, df, wls_d)
-
-    # 2. 24-Candidate Field with Extended Spectral Objective (clamped to [0.80*d_mean, 1.25*d_mean]):
+    wls_d = from_fp16_bits(to_fp16_bits(d_center))
+
+    # 2. 24-Candidate Field with Extended Spectral Objective (clamped to [d_lo, d_hi]):
     cand_raw = np.clip(wls_d[:, None] * MULTS_D[None, :], d_lo[:, None], d_hi[:, None]).astype(np.float32)
     cand_d16 = to_fp16_bits(cand_raw)                           # (B, 24)
     cand_d = from_fp16_bits(cand_d16)                           # (B, 24)
-    e_c = X_f32[:, None, :] - cand_d[:, :, None] * c_sign[:, None, :]  # (B, 24, 128)
+    e_c = X_target[:, None, :] - cand_d[:, :, None] * c_sign[:, None, :]  # (B, 24, 128)
     sse_c = np.sum(W_f32[:, None, :] * e_c * e_c, axis=2)
     if cfg.use_spectral and (lam_dc > 0.0 or lam_vw > 0.0):
         v_c = e_c[:, :, :half] + e_c[:, :, half:]
@@ -202,17 +198,17 @@ def _quantize_q1_0_hpc_cpu(
     rows = np.arange(B)
     d_sel = cand_d[rows, best_cand]
 
-    # 4. FP16-ULP Polish (+/-rad ULPs around d_sel, wls_d, and d_mean within [d_lo, d_hi]):
+    # 4. FP16-ULP Polish (+/-rad ULPs around d_sel, wls_d, and d_wls_rms within [d_lo, d_hi]):
     rad = max(int(cfg.ulp_radius), 4)
     deltas = np.arange(-rad, rad + 1, dtype=np.int32)
     lo_b = to_fp16_bits(d_lo).astype(np.int32)[:, None]
     hi_b = np.maximum(to_fp16_bits(d_hi).astype(np.int32)[:, None], lo_b)
     sel_b = np.clip(to_fp16_bits(np.abs(d_sel)).astype(np.int32)[:, None] + deltas[None, :], lo_b, hi_b).astype(np.uint16)
     wls_b = np.clip(to_fp16_bits(np.abs(wls_d)).astype(np.int32)[:, None] + deltas[None, :], lo_b, hi_b).astype(np.uint16)
-    ref_b = np.clip(to_fp16_bits(np.abs(d_mean)).astype(np.int32)[:, None] + deltas[None, :], lo_b, hi_b).astype(np.uint16)
+    ref_b = np.clip(to_fp16_bits(np.abs(d_wls_rms if cfg.use_weight_analogs else d_mean)).astype(np.int32)[:, None] + deltas[None, :], lo_b, hi_b).astype(np.uint16)
     all_b = np.concatenate([sel_b, wls_b, ref_b], axis=1)
     all_d = from_fp16_bits(all_b)
-    e_u = X_f32[:, None, :] - all_d[:, :, None] * c_sign[:, None, :]
+    e_u = X_target[:, None, :] - all_d[:, :, None] * c_sign[:, None, :]
     sse_u = np.sum(W_f32[:, None, :] * e_u * e_u, axis=2, dtype=np.float64)
     if cfg.use_spectral and (lam_dc > 0.0 or lam_vw > 0.0):
         v_u = e_u[:, :, :half] + e_u[:, :, half:]
@@ -232,13 +228,13 @@ def _quantize_q1_0_hpc_cpu(
         c_f = (2 * best_q - 1).astype(np.float64)
         d_f64 = best_d.astype(np.float64)[:, None]
         step_f64 = 2.0 * d_f64
-        e = X_f32.astype(np.float64) - d_f64 * c_f
+        e = X_target.astype(np.float64) - d_f64 * c_f
         sse_live = np.sum(W_f32 * e * e, axis=1, dtype=np.float64)
         sse_cap = sse_live * (1.0 + cfg.sse_budget)
         v = e[:, :half] + e[:, half:]
         dc = np.sum(e, axis=1)
         denom = (W_f32 + lam_vw + lam_dc) * (step_f64 * step_f64)
-        near_zero = np.abs(X_f32) <= 0.10 * d_f64
+        near_zero = np.abs(X_target) <= 0.10 * d_f64
         act_b = (d_f64 > 1.0e-15) & near_zero
         s_den = np.where(act_b & (denom > 1.0e-30), denom, 1.0)
         v_full = np.concatenate([v, v], axis=1)
@@ -246,7 +242,7 @@ def _quantize_q1_0_hpc_cpu(
         dq = np.where(act_b, nearest_int((grad / s_den).astype(np.float32)), 0)
         q_new = np.clip(best_q + dq, 0, 1)
         c_new = (2 * q_new - 1).astype(np.float64)
-        e_new = X_f32.astype(np.float64) - d_f64 * c_new
+        e_new = X_target.astype(np.float64) - d_f64 * c_new
         sse_new = np.sum(W_f32 * e_new * e_new, axis=1, dtype=np.float64)
         v_new = e_new[:, :half] + e_new[:, half:]
         dc_new = np.sum(e_new, axis=1)
@@ -278,42 +274,33 @@ def _quantize_q1_0_hpc_cuda(
         X = torch.from_numpy(X_np).to(dev, dtype=torch.float32)
         W = torch.from_numpy(W_np).to(dev, dtype=torch.float32)
 
-        # 1. Analog + WLS seed (bounded around d_mean so outlier imatrix channels cannot collapse/explode d):
+        # 1. Iso-Energy / Geometric-Projection Analog + WLS seed on GPU:
         d_mean = torch.mean(torch.abs(X), dim=1)
-        d_lo = 0.80 * d_mean
-        d_hi = 1.25 * d_mean
         wsum = torch.clamp(torch.sum(W, dim=1, keepdim=True), min=1.0e-30)
-        d_wls_init = torch.clamp(
-            (torch.sum(W * torch.abs(X), dim=1, keepdim=True) / wsum).squeeze(1),
-            min=d_lo,
-            max=d_hi,
-        )
-        mu = torch.sum(W * X, dim=1, keepdim=True) / wsum
-        var = torch.sum(W * (X - mu) ** 2, dim=1, keepdim=True) / wsum
-        sig = torch.sqrt(torch.clamp(var, min=1.0e-30))
-        x_comp = mu + sig * 1.85 * torch.tanh((X - mu) / (1.85 * sig))
-        d_analog = torch.clamp(
-            (torch.sum(W * torch.abs(x_comp), dim=1, keepdim=True) / wsum).squeeze(1),
-            min=d_lo,
-            max=d_hi,
-        )
+        d_wls_l1 = (torch.sum(W * torch.abs(X), dim=1, keepdim=True) / wsum).squeeze(1)
+        d_wls_rms = torch.sqrt(torch.clamp((torch.sum(W * X * X, dim=1, keepdim=True) / wsum).squeeze(1), min=0.0))
+        if cfg.use_weight_analogs:
+            ratio = torch.clamp(d_wls_rms / torch.clamp(d_wls_l1, min=1.0e-30), min=1.0, max=1.45)
+            d_center = d_wls_rms * torch.sqrt(ratio)
+            d_lo = 0.85 * d_wls_rms
+            d_hi = 1.35 * d_wls_rms
+        else:
+            d_center = d_wls_l1
+            d_lo = 0.80 * d_mean
+            d_hi = 1.25 * d_mean
+
+        d_center = torch.clamp(d_center, min=d_lo, max=d_hi)
+        gain = (d_center / torch.clamp(d_wls_l1, min=1.0e-30)).unsqueeze(1)
+        X_target = X * gain
 
         c_sign = torch.where(X >= 0.0, 1.0, -1.0)
-        wls_d = d_mean.clone()
-        best_seed_sse = torch.full((B,), float("inf"), dtype=torch.float32, device=dev)
-        for d_start in (d_mean, d_wls_init, d_analog):
-            df = torch.clamp(d_start, min=d_lo, max=d_hi).to(torch.float16).to(torch.float32)
-            e = X - df[:, None] * c_sign
-            sse = torch.sum(W * e * e, dim=1)
-            take = sse < best_seed_sse
-            best_seed_sse = torch.where(take, sse, best_seed_sse)
-            wls_d = torch.where(take, df, wls_d)
-
-        # 2. 24-Candidate Field with Extended Spectral Objective on GPU (clamped to [0.80*d_mean, 1.25*d_mean]):
+        wls_d = d_center.to(torch.float16).to(torch.float32)
+
+        # 2. 24-Candidate Field with Extended Spectral Objective on GPU (clamped to [d_lo, d_hi]):
         mults = torch.tensor(MULTS_D, dtype=torch.float32, device=dev)
         cand_raw = torch.clamp(wls_d[:, None] * mults[None, :], min=d_lo[:, None], max=d_hi[:, None])
         cand_d = cand_raw.to(torch.float16).to(torch.float32)  # (B, 24)
-        e_c = X[:, None, :] - cand_d[:, :, None] * c_sign[:, None, :]
+        e_c = X_target[:, None, :] - cand_d[:, :, None] * c_sign[:, None, :]
         sse_c = torch.sum(W[:, None, :] * e_c * e_c, dim=2)
         if cfg.use_spectral and (lam_dc > 0.0 or lam_vw > 0.0):
             v_c = e_c[:, :, :half] + e_c[:, :, half:]
@@ -328,20 +315,21 @@ def _quantize_q1_0_hpc_cuda(
         rows = torch.arange(B, device=dev)
         d_sel = cand_d[rows, best_cand_t]
 
-        # 4. FP16-ULP Polish (+/-rad ULPs around d_sel, wls_d, and d_mean within [d_lo, d_hi]):
+        # 4. FP16-ULP Polish (+/-rad ULPs around d_sel, wls_d, and d_wls_rms within [d_lo, d_hi]):
         rad = max(int(cfg.ulp_radius), 4)
         deltas = torch.arange(-rad, rad + 1, dtype=torch.int32, device=dev)
         lo_bits = (d_lo.to(torch.float16).view(torch.int16).to(torch.int32) & 0x7FFF)[:, None]
         hi_bits = torch.maximum((d_hi.to(torch.float16).view(torch.int16).to(torch.int32) & 0x7FFF)[:, None], lo_bits)
         abs_bits = torch.abs(d_sel).to(torch.float16).view(torch.int16).to(torch.int32) & 0x7FFF
         wls_bits = torch.abs(wls_d).to(torch.float16).view(torch.int16).to(torch.int32) & 0x7FFF
-        ref_bits = torch.abs(d_mean).to(torch.float16).view(torch.int16).to(torch.int32) & 0x7FFF
+        ref_src = d_wls_rms if cfg.use_weight_analogs else d_mean
+        ref_bits = torch.abs(ref_src).to(torch.float16).view(torch.int16).to(torch.int32) & 0x7FFF
         pos_b = torch.clamp(abs_bits[:, None] + deltas[None, :], lo_bits, hi_bits)
         wls_b = torch.clamp(wls_bits[:, None] + deltas[None, :], lo_bits, hi_bits)
         mean_b = torch.clamp(ref_bits[:, None] + deltas[None, :], lo_bits, hi_bits)
         all_b = torch.cat([pos_b, wls_b, mean_b], dim=1)
         all_d = all_b.to(torch.int16).view(torch.float16).to(torch.float32)
-        e_u = X[:, None, :] - all_d[:, :, None] * c_sign[:, None, :]
+        e_u = X_target[:, None, :] - all_d[:, :, None] * c_sign[:, None, :]
         sse_u = torch.sum(W[:, None, :] * e_u * e_u, dim=2)
         if cfg.use_spectral and (lam_dc > 0.0 or lam_vw > 0.0):
             v_u = e_u[:, :, :half] + e_u[:, :, half:]
@@ -360,13 +348,13 @@ def _quantize_q1_0_hpc_cuda(
         if cfg.use_spectral and (lam_vw > 0.0 or lam_dc > 0.0):
             d_col = best_d[:, None]
             step_col = 2.0 * d_col
-            e = X - d_col * (2.0 * best_q.to(torch.float32) - 1.0)
+            e = X_target - d_col * (2.0 * best_q.to(torch.float32) - 1.0)
             sse_live = torch.sum(W * e * e, dim=1)
             sse_cap = sse_live * (1.0 + float(cfg.sse_budget))
             v = e[:, :half] + e[:, half:]
             dc = torch.sum(e, dim=1)
             denom = (W + lam_vw + lam_dc) * (step_col * step_col)
-            near_zero = torch.abs(X) <= 0.10 * d_col
+            near_zero = torch.abs(X_target) <= 0.10 * d_col
             act_b = (d_col > 1.0e-15) & near_zero
             s_den = torch.where(act_b & (denom > 1.0e-30), denom, torch.ones_like(denom))
             v_full = torch.cat([v, v], dim=1)
@@ -378,7 +366,7 @@ def _quantize_q1_0_hpc_cuda(
                 torch.zeros_like(best_q),
             )
             q_new = torch.clamp(best_q + dq, 0, 1)
-            e_new = X - d_col * (2.0 * q_new.to(torch.float32) - 1.0)
+            e_new = X_target - d_col * (2.0 * q_new.to(torch.float32) - 1.0)
             sse_new = torch.sum(W * e_new * e_new, dim=1)
             v_new = e_new[:, :half] + e_new[:, half:]
             dc_new = torch.sum(e_new, dim=1)