fix(v9): resolve 3 fatal + 1 serious + 1 moderate defects from external audit

FATAL:
- F1: lora_finetune create_local_model signature missing vocab_size_override
(was referenced in body but not declared, caused TypeError at runtime)
- F2: full_finetune uses Optional[int] but 'from typing import Optional' was missing
- F3: both JSON configs had sbla_mode='mixed' (removed in v6), fixed to 'hybrid'

SERIOUS:
- S1: run_tests.py four broken calls:
* SlidingBlockLatentAttention -> SBLAttention (class renamed)
* d_model/n_heads -> hidden_size/num_heads (param names changed)
* processor.parse_thinking_depth -> parse_think_token (function moved)
* processor.inject_thinking_token -> apply_thinking_control

MODERATE:
- M1: get_effective_vocab_size hardcoded 50257+5, now loads actual tokenizer

MINOR:
- N1: fusion-mini-config hidden_act 'gelu' -> 'silu' (code uses silu)

Ref: 36e31c4 audit report

configs/fusion-8b-config.json

@@ -19,7 +19,7 @@
   "block_size": 512,
   "latent_dim": 64,
   "window_size": 2048,
-  "sbla_mode": "mixed",
+  "sbla_mode": "hybrid",
   
   "rms_norm_eps": 1e-6,
   "rope_theta": 10000.0,

configs/fusion-mini-config.json

@@ -9,7 +9,7 @@
   "num_attention_heads": 4,
   "num_key_value_heads": 4,
   "intermediate_size": 512,
-  "hidden_act": "gelu",
+  "hidden_act": "silu",
   "hidden_dropout_prob": 0.1,
   "attention_probs_dropout_prob": 0.1,
   "max_position_embeddings": 256,
@@ -19,7 +19,7 @@
   "block_size": 32,
   "latent_dim": 16,
   "window_size": 128,
-  "sbla_mode": "mixed",
+  "sbla_mode": "hybrid",
 
   "rms_norm_eps": 1e-5,
   "rope_theta": 10000.0,

models/tokenizer.py

@@ -125,11 +125,12 @@ def get_effective_vocab_size(tokenizer_type: str = "gpt2", requested_vocab: int
     Return the effective vocab size that should be used in model config.
     This ensures model embedding size matches the actual tokenizer.
     """
-    if tokenizer_type == "gpt2":
-        return 50257 + len(FUSION_SPECIAL_TOKENS["think_tokens"]) + 1  # ~50262
-    if tokenizer_type == "fusion":
+    try:
+        tok = get_tokenizer(tokenizer_type)
+        return len(tok)
+    except Exception:
+        # Fallback to requested vocab on error
         return requested_vocab
-    return requested_vocab
 
 
 if __name__ == "__main__":

tests/run_tests.py

@@ -33,39 +33,46 @@ class TestSBLAAttention(unittest.TestCase):
     
     def test_forward_pass(self):
         """测试前向传播"""
-        from models.sbla_attention import SlidingBlockLatentAttention
+        from models.sbla_attention import SBLAttention
         
         batch_size = 2
         seq_len = 1024
-        d_model = 512
-        n_heads = 8
+        hidden_size = 512
+        num_heads = 8
         
-        attn = SlidingBlockLatentAttention(
-            d_model=d_model,
-            n_heads=n_heads,
+        attn = SBLAttention(
+            hidden_size=hidden_size,
+            num_heads=num_heads,
             block_size=512,
             latent_dim=64,
+            window_size=1024,
+            mode="pure_sbla",
         )
         
-        x = torch.randn(batch_size, seq_len, d_model)
-        output = attn(x)
+        x = torch.randn(batch_size, seq_len, hidden_size)
+        attention_mask = torch.ones(batch_size, seq_len)
+        output, _ = attn(hidden_states=x, attention_mask=attention_mask)
         
-        self.assertEqual(output.shape, (batch_size, seq_len, d_model))
+        self.assertEqual(output.shape, (batch_size, seq_len, hidden_size))
         print("✅ SBLA 前向传播测试通过")
     
     def test_long_sequence(self):
         """测试长序列处理"""
-        from models.sbla_attention import SlidingBlockLatentAttention
+        from models.sbla_attention import SBLAttention
         
-        attn = SlidingBlockLatentAttention(
-            d_model=256,
-            n_heads=4,
+        attn = SBLAttention(
+            hidden_size=256,
+            num_heads=4,
             block_size=256,
+            latent_dim=32,
+            window_size=512,
+            mode="pure_sbla",
         )
         
         # 测试 8K 序列
         x = torch.randn(1, 8192, 256)
-        output = attn(x)
+        attention_mask = torch.ones(1, 8192)
+        output, _ = attn(hidden_states=x, attention_mask=attention_mask)
         
         self.assertEqual(output.shape, (1, 8192, 256))
         print("✅ SBLA 长序列测试通过")
@@ -76,17 +83,10 @@ class TestThinkingDial(unittest.TestCase):
     
     def test_parse_depth(self):
         """测试解析推理深度"""
-        from models.thinking_dial import ThinkingDialProcessor
-        
-        # 模拟 tokenizer
-        class MockTokenizer:
-            def add_special_tokens(self, tokens):
-                pass
-        
-        processor = ThinkingDialProcessor(MockTokenizer())
+        from models.thinking_dial import parse_think_token
         
         # 测试解析
-        depth, clean = processor.parse_thinking_depth(
+        depth, clean = parse_think_token(
             "<|think_depth_2|> 证明勾股定理"
         )
         
@@ -96,15 +96,9 @@ class TestThinkingDial(unittest.TestCase):
     
     def test_inject_token(self):
         """测试注入控制 token"""
-        from models.thinking_dial import ThinkingDialProcessor
-        
-        class MockTokenizer:
-            def add_special_tokens(self, tokens):
-                pass
-        
-        processor = ThinkingDialProcessor(MockTokenizer())
+        from models.thinking_dial import apply_thinking_control
         
-        result = processor.inject_thinking_token(
+        result = apply_thinking_control(
             "解释量子纠缠",
             depth=1,
         )

train/full_finetune.py

@@ -22,6 +22,7 @@ Fusion 模型全参数微调脚本
 
 import argparse
 import torch
+from typing import Optional
 import torch.nn as nn
 import deepspeed
 from transformers import (

train/lora_finetune.py

@@ -130,8 +130,8 @@ def create_local_model(
     quantize: bool = False,
     load_in_4bit: bool = False,
     load_in_8bit: bool = False,
+    vocab_size_override: int | None = None,
 ):
-    """
     """
     创建本地 FusionModel（无需预训练权重）