docs: self-contained CompressedLinear in README (no SVD-LLM dependency)

README.md

@@ -26,10 +26,10 @@ tokenizer = AutoTokenizer.from_pretrained(repo, subfolder="qwen3_14b/r02/F")
 ## Factored Format — Low-Rank A, B Matrices
 
 Each `F/` directory also contains `factors.pt` with the low-rank factors
-`A (d×r)` and `B (r×n)` for every compressed linear layer. This is ~20%
+`A (d*r)` and `B (r*n)` for every compressed linear layer. This is ~20%
 smaller than the merged weights and preserves the compression structure.
 
-### Loading with factors (for analysis or continued training)
+### Loading factors (for analysis or continued training)
 
 ```python
 import torch
@@ -50,19 +50,44 @@ factors = torch.load(factors_path, map_location="cpu", weights_only=True)
 # factors is a dict: {(layer_idx, sublayer_name): {"A": tensor, "B": tensor}}
 # Example: factors[(0, "self_attn.q_proj")]["A"].shape = (5120, 2048)
 print(f"Loaded {len(factors)} factor pairs")
-print(f"Layer 0 q_proj: A={factors[(0, 'self_attn.q_proj')]['A'].shape}, "
-      f"B={factors[(0, 'self_attn.q_proj')]['B'].shape}")
 ```
 
-### Restoring CompressedLinear modules (for fine-tuning)
+### Restoring low-rank structure (no external dependencies)
 
 ```python
-# After loading factors, replace merged layers with factored versions:
-from src.model.replace import replace_linear_with_compressed
-
-for (layer_idx, name), f in factors.items():
-    replace_linear_with_compressed(model, layer_idx, name, f["A"], f["B"])
-# Now model has CompressedLinear modules — only A, B are trainable
+import torch
+import torch.nn as nn
+
+class CompressedLinear(nn.Module):
+    """Low-rank linear: y = A @ (B @ x) + bias, where A is (d, r) and B is (r, n)."""
+    def __init__(self, A, B, bias=None):
+        super().__init__()
+        d, r = A.shape
+        _, n = B.shape
+        self.first = nn.Linear(n, r, bias=False)
+        self.second = nn.Linear(r, d, bias=bias is not None)
+        self.first.weight = nn.Parameter(B)
+        self.second.weight = nn.Parameter(A)
+        if bias is not None:
+            self.second.bias = nn.Parameter(bias)
+
+    def forward(self, x):
+        return self.second(self.first(x.to(self.first.weight.dtype))).to(x.dtype)
+
+# Replace merged layers with factored versions
+for (layer_idx, sublayer_name), f in factors.items():
+    layer = model.model.layers[layer_idx]
+    parts = sublayer_name.split(".")
+    parent = layer
+    for p in parts[:-1]:
+        parent = getattr(parent, p)
+    original = getattr(parent, parts[-1])
+    bias = original.bias.data if original.bias is not None else None
+    compressed = CompressedLinear(f["A"], f["B"], bias=bias)
+    setattr(parent, parts[-1], compressed)
+
+# Now each compressed sublayer has .first.weight (B) and .second.weight (A)
+# Total trainable params = sum of A and B sizes, ~20% fewer than original
 ```
 
 ### Compression details
@@ -70,7 +95,7 @@ for (layer_idx, name), f in factors.items():
 - **Method**: SVD-LLM whitening + mixed calibration (4096 samples, seqlen=2048)
 - **Compressed sublayers** (7 per transformer block):
   `q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj`
-- **Rank formula**: `r = (1 - ratio) × d × n / (d + n)`
+- **Rank formula**: `r = (1 - ratio) * d * n / (d + n)`
 - **Stage B**: Per-matrix whitened SVD truncation
 - **Stage F**: End-to-end LM-loss refinement of A, B factors