fix(v11): resolve remaining 5 defects (S-NEW-1/2, M-NEW-2/3, MI-NEW-1)

SERIOUS:
- S-NEW-1: dashboard token count len(tokens[0]) -> .shape[1] for correct seq_len
- S-NEW-2: dyquant convert() relies on load_model side effect -> check return value

MODERATE:
- M-NEW-2: 4 overlapping data scripts merged into manage_mini_data.py (create|fix|enrich|dedup|all)
- M-NEW-3: replace all emoji in print/logger with ASCII tags for GBK console compatibility

MINOR:
- MI-NEW-1: test_sbla_integration has_sblla typo -> has_sbla

data_pipeline/bilingual_filter.py

@@ -61,7 +61,7 @@ class BilingualTrueFilter:
         else:
             logger.warning("langid not installed, language detection disabled")
         
-        logger.info(f"✅ 初始化 {lang.upper()} 数据过滤器")
+        logger.info(f"[OK] 初始化 {lang.upper()} 数据过滤器")
         
     def process(self, data: List[str]) -> List[str]:
         """
@@ -73,7 +73,7 @@ class BilingualTrueFilter:
         返回：
             清洗后的文本列表
         """
-        logger.info(f"📊 开始处理 {len(data)} 条数据...")
+        logger.info(f"[CHART] 开始处理 {len(data)} 条数据...")
         
         clean_data = []
         
@@ -99,7 +99,7 @@ class BilingualTrueFilter:
             
             clean_data.append(text)
         
-        logger.info(f"✅ 清洗完成：{len(clean_data)}/{len(data)} 条保留")
+        logger.info(f"[OK] 清洗完成：{len(clean_data)}/{len(data)} 条保留")
         
         return clean_data
     
@@ -141,17 +141,17 @@ class BilingualTrueFilter:
         """
         # 1. 剔除"小编体"
         if self._is_xiaobian_style(text):
-            logger.debug("❌ 剔除小编体")
+            logger.debug("[FAIL] 剔除小编体")
             return False
         
         # 2. 剔除机翻内容
         if self._is_machine_translation(text):
-            logger.debug("❌ 剔除机翻内容")
+            logger.debug("[FAIL] 剔除机翻内容")
             return False
         
         # 3. 剔除低质量内容
         if self._is_low_quality_chinese(text):
-            logger.debug("❌ 剔除低质量内容")
+            logger.debug("[FAIL] 剔除低质量内容")
             return False
         
         return True
@@ -166,12 +166,12 @@ class BilingualTrueFilter:
         """
         # 1. 剔除直译中文语料
         if self._is_translated_from_chinese(text):
-            logger.debug("❌ 剔除直译中文语料")
+            logger.debug("[FAIL] 剔除直译中文语料")
             return False
         
         # 2. 剔除低质量内容
         if self._is_low_quality_english(text):
-            logger.debug("❌ 剔除低质量内容")
+            logger.debug("[FAIL] 剔除低质量内容")
             return False
         
         return True
@@ -298,7 +298,7 @@ class BalancedSampler:
         self.en_data = en_data
         self.zh_ratio = zh_ratio
         
-        logger.info(f"📊 平衡采样器初始化")
+        logger.info(f"[CHART] 平衡采样器初始化")
         logger.info(f"   中文数据：{len(zh_data)} 条")
         logger.info(f"   英文数据：{len(en_data)} 条")
         logger.info(f"   中文占比：{zh_ratio:.1%}")
@@ -331,7 +331,7 @@ class BalancedSampler:
         
         random.shuffle(sampled)
         
-        logger.info(f"✅ 采样 {len(sampled)} 条平衡数据")
+        logger.info(f"[OK] 采样 {len(sampled)} 条平衡数据")
         logger.info(f"   中文：{n_zh} 条，英文：{n_en} 条")
         
         return sampled
@@ -352,10 +352,10 @@ def process_data_pipeline(
         output_path: 输出路径
         n_samples: 采样数量
     """
-    logger.info("🚀 启动双母语数据处理管道...")
+    logger.info("[GO] 启动双母语数据处理管道...")
     
     # 1. 加载原始数据
-    logger.info("📦 加载原始数据...")
+    logger.info("[LOAD] 加载原始数据...")
     
     with open(zh_raw_path, 'r', encoding='utf-8') as f:
         zh_raw = json.load(f)
@@ -367,33 +367,33 @@ def process_data_pipeline(
     logger.info(f"   英文原始数据：{len(en_raw)} 条")
     
     # 2. 清洗中文数据
-    logger.info("\n🧹 清洗中文数据...")
+    logger.info("\n[CLEAN] 清洗中文数据...")
     zh_filter = BilingualTrueFilter(lang="zh")
     zh_clean = zh_filter.process(zh_raw)
     
     # 3. 清洗英文数据
-    logger.info("\n🧹 清洗英文数据...")
+    logger.info("\n[CLEAN] 清洗英文数据...")
     en_filter = BilingualTrueFilter(lang="en")
     en_clean = en_filter.process(en_raw)
     
     # 4. 平衡采样
-    logger.info("\n⚖️  平衡采样...")
+    logger.info("\n[BALANCE][LOGO]  平衡采样...")
     sampler = BalancedSampler(zh_clean, en_clean, zh_ratio=0.5)
     balanced_data = sampler.sample(n_samples)
     
     # 5. 保存
-    logger.info(f"\n💾 保存到 {output_path}...")
+    logger.info(f"\n[SAVE] 保存到 {output_path}...")
     with open(output_path, 'w', encoding='utf-8') as f:
         json.dump(balanced_data, f, ensure_ascii=False, indent=2)
     
-    logger.info("✅ 数据处理管道完成！")
+    logger.info("[OK] 数据处理管道完成！")
     
     return balanced_data
 
 
 if __name__ == "__main__":
     # 单元测试（模拟数据）
-    print("🧪 测试 Bi-Lingual TrueFilter...")
+    print("[LOGO] 测试 Bi-Lingual TrueFilter...")
     
     # 模拟中文数据
     zh_test_data = [
@@ -413,16 +413,16 @@ if __name__ == "__main__":
     # 测试中文过滤器
     zh_filter = BilingualTrueFilter(lang="zh")
     zh_clean = zh_filter.process(zh_test_data)
-    print(f"✅ 中文过滤：{len(zh_clean)}/{len(zh_test_data)} 条保留")
+    print(f"[OK] 中文过滤：{len(zh_clean)}/{len(zh_test_data)} 条保留")
     
     # 测试英文过滤器
     en_filter = BilingualTrueFilter(lang="en")
     en_clean = en_filter.process(en_test_data)
-    print(f"✅ 英文过滤：{len(en_clean)}/{len(en_test_data)} 条保留")
+    print(f"[OK] 英文过滤：{len(en_clean)}/{len(en_test_data)} 条保留")
     
     # 测试平衡采样
     sampler = BalancedSampler(zh_clean, en_clean, zh_ratio=0.5)
     balanced = sampler.sample(10)
-    print(f"✅ 平衡采样：{len(balanced)} 条")
+    print(f"[OK] 平衡采样：{len(balanced)} 条")
     
-    print("\n✅ Bi-Lingual TrueFilter 测试通过！")
+    print("\n[OK] Bi-Lingual TrueFilter 测试通过！")

data_pipeline/t_kd_distillation.py

@@ -47,7 +47,7 @@ class TKDDistiller:
             device: 设备（cuda/cpu）
             torch_dtype: 数据类型
         """
-        print(f"📚 加载教师模型：{teacher_model}")
+        print(f"[BOOK] 加载教师模型：{teacher_model}")
         
         self.device = device
         self.tokenizer = AutoTokenizer.from_pretrained(
@@ -64,7 +64,7 @@ class TKDDistiller:
         
         self.model.eval()
         
-        print(f"✅ 教师模型加载成功")
+        print(f"[OK] 教师模型加载成功")
         print(f"   设备：{self.model.device}")
         print(f"   参数量：{sum(p.numel() for p in self.model.parameters()) / 1e9:.2f}B")
         
@@ -164,7 +164,7 @@ class TKDDistiller:
         返回：
             蒸馏结果列表
         """
-        print(f"\n📚 开始 T-KD 蒸馏...")
+        print(f"\n[BOOK] 开始 T-KD 蒸馏...")
         print(f"   主题数：{len(topics)}")
         print(f"   数据源：{source_type}")
         
@@ -195,7 +195,7 @@ class TKDDistiller:
                     with open(output_path, 'a', encoding='utf-8') as f:
                         f.write(json.dumps(result, ensure_ascii=False) + '\n')
                 
-                print(f"✅ 完成（生成 {len(text)} 字符）")
+                print(f"[OK] 完成（生成 {len(text)} 字符）")
                 
                 # 避免 GPU 过热
                 if i % 10 == 0:
@@ -203,10 +203,10 @@ class TKDDistiller:
                     time.sleep(1)
                     
             except Exception as e:
-                print(f"❌ 失败：{e}")
+                print(f"[FAIL] 失败：{e}")
                 continue
         
-        print(f"\n🎉 蒸馏完成！共生成 {len(results)} 个样本")
+        print(f"\n[DONE] 蒸馏完成！共生成 {len(results)} 个样本")
         
         return results
 
@@ -330,9 +330,9 @@ def main():
             output_path=output_path,
         )
         
-        print(f"\n✅ {source} 蒸馏完成，结果保存至：{output_path}")
+        print(f"\n[OK] {source} 蒸馏完成，结果保存至：{output_path}")
     
-    print(f"\n🎉 所有数据源蒸馏完成！")
+    print(f"\n[DONE] 所有数据源蒸馏完成！")
     print(f"   输出目录：{Path(args.output_path).parent}")
 
 

data_pipeline/t_kd_distillation_train.py

@@ -57,7 +57,7 @@ class DistillationDataset(Dataset):
                 if line.strip():
                     self.data.append(json.loads(line))
         
-        logger.info(f"✅ 加载数据：{len(self.data)} 条")
+        logger.info(f"[OK] 加载数据：{len(self.data)} 条")
     
     def __len__(self):
         return len(self.data)
@@ -127,7 +127,7 @@ class DistillationTrainer:
         self.grad_accum_steps = grad_accum_steps
         
         # 1. 加载教师模型（冻结）
-        logger.info(f"📚 加载教师模型：{teacher_model_name}")
+        logger.info(f"[BOOK] 加载教师模型：{teacher_model_name}")
         self.teacher_tokenizer = AutoTokenizer.from_pretrained(
             teacher_model_name,
             trust_remote_code=True,
@@ -144,10 +144,10 @@ class DistillationTrainer:
         for param in self.teacher_model.parameters():
             param.requires_grad = False
         
-        logger.info(f"✅ 教师模型加载完成（参数已冻结）")
+        logger.info(f"[OK] 教师模型加载完成（参数已冻结）")
         
         # 2. 加载学生模型（可训练）
-        logger.info(f"🎓 加载学生模型：{student_model_name}")
+        logger.info(f"[GRAD] 加载学生模型：{student_model_name}")
         self.student_tokenizer = AutoTokenizer.from_pretrained(
             student_model_name,
             trust_remote_code=True,
@@ -162,7 +162,7 @@ class DistillationTrainer:
         
         self.student_model.train()
         
-        logger.info(f"✅ 学生模型加载完成（可训练）")
+        logger.info(f"[OK] 学生模型加载完成（可训练）")
         
         # 3. 优化器 + 学习率调度器
         self.optimizer = torch.optim.AdamW(
@@ -171,7 +171,7 @@ class DistillationTrainer:
             weight_decay=0.01,
         )
         
-        logger.info(f"✅ 优化器初始化完成（lr={learning_rate}）")
+        logger.info(f"[OK] 优化器初始化完成（lr={learning_rate}）")
     
     def compute_distillation_loss(
         self,
@@ -269,7 +269,7 @@ class DistillationTrainer:
         )
         
         # 3. 训练循环
-        logger.info(f"🚀 开始蒸馏训练...")
+        logger.info(f"[GO] 开始蒸馏训练...")
         logger.info(f"   轮数：{num_epochs}")
         logger.info(f"   批次大小：{self.batch_size}")
         logger.info(f"   梯度累积：{self.grad_accum_steps}")
@@ -365,7 +365,7 @@ class DistillationTrainer:
             self.student_model.save_pretrained(checkpoint_dir)
             self.student_tokenizer.save_pretrained(checkpoint_dir)
             
-            logger.info(f"   ✅ 检查点保存至：{checkpoint_dir}")
+            logger.info(f"   [OK] 检查点保存至：{checkpoint_dir}")
         
         # 4. 保存最终模型
         output_path = Path(output_dir) / "final"
@@ -374,7 +374,7 @@ class DistillationTrainer:
         self.student_model.save_pretrained(output_path)
         self.student_tokenizer.save_pretrained(output_path)
         
-        logger.info(f"🎉 蒸馏训练完成！模型保存至：{output_path}")
+        logger.info(f"[DONE] 蒸馏训练完成！模型保存至：{output_path}")
     
     def evaluate(
         self,
@@ -390,7 +390,7 @@ class DistillationTrainer:
             max_length: 最大序列长度
             num_samples: 评估样本数
         """
-        logger.info(f"📊 开始评估...")
+        logger.info(f"[CHART] 开始评估...")
         
         self.student_model.eval()
         
@@ -430,7 +430,7 @@ class DistillationTrainer:
         
         avg_loss = total_loss / max(num_batches, 1)
         
-        logger.info(f"✅ 评估完成")
+        logger.info(f"[OK] 评估完成")
         logger.info(f"   Average Loss: {avg_loss:.4f}")
         logger.info(f"   Perplexity: {torch.exp(torch.tensor(avg_loss)).item():.2f}")
 
@@ -547,7 +547,7 @@ def main():
         max_length=args.max_length,
     )
     
-    logger.info("🎉 蒸馏训练完成！")
+    logger.info("[DONE] 蒸馏训练完成！")
 
 
 if __name__ == "__main__":

inference/dashboard.py

@@ -252,7 +252,8 @@ class InferenceEngine:
                 self.kv_cache = outputs.past_key_values
         
         # Decode only new tokens
-        new_tokens = generated[len(self._tokenize(prompt)[0]):]
+        prompt_len = self._tokenize(prompt).shape[1]
+        new_tokens = generated[prompt_len:]
         return self._detokenize(new_tokens)
     
     def _generate_stream(self, input_ids, cfg) -> Generator:

inference/dyquant.py

@@ -432,8 +432,10 @@ class DyQuantConverter:
         
         # 1. 加载模型
         if self.model is None:
-            self.load_model()
-        
+            result = self.load_model()
+            if result is not None:
+                self.model = result
+            
         if self.model is None:
             print(f"[DyQuant] 无法加载模型，返回 None")
             return None

inference/ollama_deploy.py

@@ -34,14 +34,14 @@ def check_dependencies():
     """
     检查依赖项
     """
-    logger.info("🔍 检查依赖项...")
+    logger.info("[SEARCH] 检查依赖项...")
     
     # 检查 llama.cpp 转换脚本
     llama_cpp_dir = os.environ.get("LLAMA_CPP_DIR", "")
     convert_script = os.path.join(llama_cpp_dir, "convert-hf-to-gguf.py")
     
     if not os.path.exists(convert_script):
-        logger.warning(f"⚠️  未找到 llama.cpp 转换脚本：{convert_script}")
+        logger.warning(f"[WARN][LOGO]  未找到 llama.cpp 转换脚本：{convert_script}")
         logger.warning("   请设置环境变量 LLAMA_CPP_DIR 或手动下载 llama.cpp")
         logger.warning("   下载地址：<ADDRESS_REMOVED>
         return False
@@ -54,17 +54,17 @@ def check_dependencies():
             text=True,
         )
         if result.returncode == 0:
-            logger.info(f"✅ Ollama 已安装：{result.stdout.strip()}")
+            logger.info(f"[OK] Ollama 已安装：{result.stdout.strip()}")
         else:
-            logger.warning("⚠️  Ollama 未安装或无法运行")
+            logger.warning("[WARN][LOGO]  Ollama 未安装或无法运行")
             logger.warning("   请访问 https://ollama.com 安装")
             return False
     except FileNotFoundError:
-        logger.warning("⚠️  Ollama 未安装")
+        logger.warning("[WARN][LOGO]  Ollama 未安装")
         logger.warning("   请访问 https://ollama.com 安装")
         return False
     
-    logger.info("✅ 依赖项检查通过")
+    logger.info("[OK] 依赖项检查通过")
     return True
 
 
@@ -81,7 +81,7 @@ def convert_to_gguf(
         output_path: 输出路径
         quantize: 量化级别（q4_k_m, q5_k_m, q8_0 等）
     """
-    logger.info("🔄 转换为 GGUF 格式...")
+    logger.info("[SYNC] 转换为 GGUF 格式...")
     
     llama_cpp_dir = os.environ.get("LLAMA_CPP_DIR", "")
     convert_script = os.path.join(llama_cpp_dir, "convert-hf-to-gguf.py")
@@ -99,14 +99,14 @@ def convert_to_gguf(
     result = subprocess.run(cmd, capture_output=True, text=True)
     
     if result.returncode != 0:
-        logger.error(f"❌ 转换失败：{result.stderr}")
+        logger.error(f"[FAIL] 转换失败：{result.stderr}")
         raise RuntimeError("GGUF 转换失败")
     
-    logger.info(f"✅ GGUF 转换完成：{output_path}")
+    logger.info(f"[OK] GGUF 转换完成：{output_path}")
     
     # 量化（可选）
     if quantize:
-        logger.info(f"🔧 量化模型（{quantize}）...")
+        logger.info(f"[TOOL] 量化模型（{quantize}）...")
         
         quantize_cmd = [
             os.path.join(llama_cpp_dir, "llama-quantize"),
@@ -118,11 +118,11 @@ def convert_to_gguf(
         result = subprocess.run(quantize_cmd, capture_output=True, text=True)
         
         if result.returncode != 0:
-            logger.warning(f"⚠️  量化失败：{result.stderr}")
+            logger.warning(f"[WARN][LOGO]  量化失败：{result.stderr}")
             logger.warning("   继续使用未量化模型")
         else:
             output_path = output_path.replace(".gguf", f"_{quantize}.gguf")
-            logger.info(f"✅ 量化完成：{output_path}")
+            logger.info(f"[OK] 量化完成：{output_path}")
     
     return output_path
 
@@ -144,7 +144,7 @@ def create_modelfile(
         context_size: 上下文窗口大小
         thinking_dial: 是否启用 Thinking Dial
     """
-    logger.info("📝 创建 Modelfile...")
+    logger.info("[NOTE] 创建 Modelfile...")
     
     # Modelfile 内容
     content = f"""# Fusion 模型：{model_name}
@@ -189,7 +189,7 @@ TEMPLATE \"\"\"{{ if .System }}<|im_start|>system
     with open(modelfile_path, 'w', encoding='utf-8') as f:
         f.write(content)
     
-    logger.info(f"✅ Modelfile 创建完成：{modelfile_path}")
+    logger.info(f"[OK] Modelfile 创建完成：{modelfile_path}")
 
 
 def create_ollama_model(modelfile_path: str, model_name: str):
@@ -200,7 +200,7 @@ def create_ollama_model(modelfile_path: str, model_name: str):
         modelfile_path: Modelfile 路径
         model_name: 模型名称
     """
-    logger.info(f"🚀 创建 Ollama 模型：{model_name}...")
+    logger.info(f"[GO] 创建 Ollama 模型：{model_name}...")
     
     # 删除已存在的模型
     subprocess.run(
@@ -216,10 +216,10 @@ def create_ollama_model(modelfile_path: str, model_name: str):
     result = subprocess.run(cmd, capture_output=True, text=True)
     
     if result.returncode != 0:
-        logger.error(f"❌ 创建失败：{result.stderr}")
+        logger.error(f"[FAIL] 创建失败：{result.stderr}")
         raise RuntimeError("Ollama 模型创建失败")
     
-    logger.info(f"✅ Ollama 模型创建成功：{model_name}")
+    logger.info(f"[OK] Ollama 模型创建成功：{model_name}")
     logger.info(f"   运行 `ollama run {model_name}` 开始使用")
 
 
@@ -242,13 +242,13 @@ def deploy(
         context_size: 上下文窗口
         thinking_dial: 是否启用 Thinking Dial
     """
-    logger.info("🚀 开始 Ollama 部署流程...")
+    logger.info("[GO] 开始 Ollama 部署流程...")
     logger.info(f"   模型路径：{model_path}")
     logger.info(f"   模型名称：{model_name}")
     
     # 1. 检查依赖
     if not check_dependencies():
-        logger.error("❌ 依赖项检查失败，请先安装所需工具")
+        logger.error("[FAIL] 依赖项检查失败，请先安装所需工具")
         return False
     
     # 2. 创建输出目录
@@ -263,7 +263,7 @@ def deploy(
             quantize=quantize,
         )
     except RuntimeError as e:
-        logger.error(f"❌ GGUF 转换失败：{e}")
+        logger.error(f"[FAIL] GGUF 转换失败：{e}")
         return False
     
     # 4. 创建 Modelfile
@@ -283,14 +283,14 @@ def deploy(
             model_name=model_name,
         )
     except RuntimeError as e:
-        logger.error(f"❌ Ollama 模型创建失败：{e}")
+        logger.error(f"[FAIL] Ollama 模型创建失败：{e}")
         return False
     
     # 6. 生成使用示例
     example_path = os.path.join(output_dir, "USAGE.md")
     generate_usage_example(model_name, example_path)
     
-    logger.info("✅ 部署完成！")
+    logger.info("[OK] 部署完成！")
     logger.info(f"   运行：`ollama run {model_name}`")
     logger.info(f"   示例：见 {example_path}")
     
@@ -392,7 +392,7 @@ ollama run {model_name} --top_p 0.95
     with open(output_path, 'w', encoding='utf-8') as f:
         f.write(content)
     
-    logger.info(f"📖 使用示例已生成：{output_path}")
+    logger.info(f"[LOGO] 使用示例已生成：{output_path}")
 
 
 def main():
@@ -426,9 +426,9 @@ def main():
     )
     
     if success:
-        logger.info("🎉 部署成功！")
+        logger.info("[DONE] 部署成功！")
     else:
-        logger.error("❌ 部署失败")
+        logger.error("[FAIL] 部署失败")
 
 
 if __name__ == "__main__":

models/__init__.py

@@ -2,10 +2,10 @@
 Fusion 模型架构
 
 包含：
-- fusion_mini.py: 极简可运行版本（用于验证流程）✅ 已实现
-- fusion_model.py: 完整 Transformer 模型定义（SBLA + Thinking Dial）✅ 已实现
-- sbla_attention.py: SBLA 注意力（滑动分块潜注意力）✅ 已实现
-- thinking_dial.py: 动态推理强度调节器（Thinking Dial）✅ 已实现
+- fusion_mini.py: 极简可运行版本（用于验证流程）[OK] 已实现
+- fusion_model.py: 完整 Transformer 模型定义（SBLA + Thinking Dial）[OK] 已实现
+- sbla_attention.py: SBLA 注意力（滑动分块潜注意力）[OK] 已实现
+- thinking_dial.py: 动态推理强度调节器（Thinking Dial）[OK] 已实现
 
 使用方法：
     # 极简版本（字符级训练验证）

models/fusion_mini.py

@@ -481,7 +481,7 @@ class FusionMini(PreTrainedModel):
 
 if __name__ == "__main__":
     # 单元测试
-    print("🧪 测试 Fusion Mini 模型...")
+    print("[LOGO] 测试 Fusion Mini 模型...")
     
     # 创建配置
     config = FusionMiniConfig(
@@ -492,7 +492,7 @@ if __name__ == "__main__":
         intermediate_size=512,
     )
     
-    print(f"✅ 配置创建成功")
+    print(f"[OK] 配置创建成功")
     print(f"   词表大小：{config.vocab_size}")
     print(f"   隐层大小：{config.hidden_size}")
     print(f"   层数：{config.num_hidden_layers}")
@@ -500,7 +500,7 @@ if __name__ == "__main__":
     # 创建模型
     model = FusionMini(config)
     
-    print(f"\n✅ 模型创建成功")
+    print(f"\n[OK] 模型创建成功")
     print(f"   参数量：{sum(p.numel() for p in model.parameters()) / 1e3:.1f}K")
     
     # 测试前向传播
@@ -517,7 +517,7 @@ if __name__ == "__main__":
         return_dict=True,
     )
     
-    print(f"\n✅ 前向传播测试通过")
+    print(f"\n[OK] 前向传播测试通过")
     print(f"   Loss: {outputs['loss'].item():.4f}")
     print(f"   Logits 形状: {outputs['logits'].shape}")
     
@@ -527,11 +527,11 @@ if __name__ == "__main__":
         max_new_tokens=20,
     )
     
-    print(f"\n✅ 生成测试通过")
+    print(f"\n[OK] 生成测试通过")
     print(f"   生成形状: {generated.shape}")
     
-    print("\n🎉 Fusion Mini 测试完成！")
-    print("\n💡 下一步：")
+    print("\n[DONE] Fusion Mini 测试完成！")
+    print("\n[TIP] 下一步：")
     print("   1. 使用真实数据训练这个 mini 模型")
     print("   2. 验证训练流程")
     print("   3. 然后实现 SBLA 和 Thinking Dial")

scripts/add_depth3_samples.py

@@ -1,42 +0,0 @@
-#!/usr/bin/env python3
-"""Add depth=3 samples to mini_data.json for Thinking Dial coverage."""
-
-import json
-
-DEPTH_3_SAMPLES = [
-    {"prompt": "Prove the Pythagorean theorem", "response": "Consider a right triangle with legs a, b and hypotenuse c. Construct a square of side (a+b) and arrange four copies of the triangle inside. The inner quadrilateral is a square of side c, so (a+b)^2 = c^2 + 4*(ab/2), which simplifies to a^2 + b^2 = c^2.", "think_rank": 3},
-    {"prompt": "Derive the quadratic formula", "response": "Starting from ax^2 + bx + c = 0, divide by a, complete the square: (x + b/2a)^2 = (b^2 - 4ac)/4a^2. Taking the square root gives x = (-b +- sqrt(b^2 - 4ac)) / 2a.", "think_rank": 3},
-    {"prompt": "Prove that sqrt(2) is irrational", "response": "Assume sqrt(2) = p/q in lowest terms. Then 2q^2 = p^2, so p is even. Write p = 2k, then 2q^2 = 4k^2, so q^2 = 2k^2, meaning q is also even. This contradicts p/q being in lowest terms.", "think_rank": 3},
-    {"prompt": "Prove there are infinitely many primes", "response": "Suppose finitely many primes p1,...,pn exist. Let N = p1*p2*...*pn + 1. N is not divisible by any pi (remainder 1). So N is either prime itself or has a prime factor not in the list. Contradiction.", "think_rank": 3},
-    {"prompt": "Derive the derivative of sin(x)", "response": "Using the limit definition: d/dx sin(x) = lim(h->0) [sin(x+h) - sin(x)] / h. Apply the angle addition formula: sin(x+h) = sin(x)cos(h) + cos(x)sin(h). This gives lim [sin(x)(cos(h)-1)/h + cos(x)sin(h)/h] = sin(x)*0 + cos(x)*1 = cos(x).", "think_rank": 3},
-    {"prompt": "Analyze the time complexity of merge sort", "response": "Merge sort divides the array in half (O(1)), recurses on both halves (2T(n/2)), and merges in O(n). The recurrence T(n) = 2T(n/2) + O(n) solves to O(n log n) by the master theorem (case 2). This holds for worst, average, and best cases.", "think_rank": 3},
-    {"prompt": "Prove the sum of first n natural numbers is n(n+1)/2", "response": "By induction: Base case n=1: 1 = 1(2)/2 = 1. Inductive step: assume S(k) = k(k+1)/2. Then S(k+1) = S(k) + (k+1) = k(k+1)/2 + (k+1) = (k+1)(k/2 + 1) = (k+1)(k+2)/2. QED.", "think_rank": 3},
-    {"prompt": "Prove that e^x converges for all x", "response": "The Taylor series e^x = sum(x^n/n!) has ratio test: |a_(n+1)/a_n| = |x|/(n+1) -> 0 as n -> infinity. Since the limit is 0 < 1 for all x, the series converges absolutely for all real x by the ratio test.", "think_rank": 3},
-]
-
-def main():
-    with open('data/mini_data.json', 'r', encoding='utf-8') as f:
-        data = json.load(f)
-
-    old_dist = {}
-    for item in data:
-        r = item.get('think_rank', 0)
-        old_dist[r] = old_dist.get(r, 0) + 1
-    print(f"Before: {old_dist}")
-
-    data.extend(DEPTH_3_SAMPLES)
-
-    new_dist = {}
-    for item in data:
-        r = item.get('think_rank', 0)
-        new_dist[r] = new_dist.get(r, 0) + 1
-    print(f"After: {new_dist}")
-
-    with open('data/mini_data.json', 'w', encoding='utf-8') as f:
-        json.dump(data, f, ensure_ascii=False, indent=2)
-
-    print(f"Total: {len(data)} items")
-
-
-if __name__ == '__main__':
-    main()

scripts/create_mini_data.py

@@ -1,126 +0,0 @@
-"""
-创建 Fusion Mini 训练数据
-
-生成极简的训练数据（字符级），用于验证完整训练流程。
-
-使用方法：
-    python tests/create_mini_data.py
-    
-    # 会生成 data/mini_data.json
-
-作者：zhan1206
-项目：Fusion - 六边形开源大模型
-许可证：Apache 2.0
-"""
-
-import json
-import random
-from pathlib import Path
-
-
-def create_mini_dataset(output_path: str, num_samples: int = 100):
-    """
-    创建 mini 训练数据集
-    
-    参数：
-        output_path: 输出文件路径
-        num_samples: 样本数量
-    """
-    print("[数据] 创建 mini 训练数据集...")
-    print(f"   输出路径：{output_path}")
-    print(f"   样本数量：{num_samples}")
-    
-    data = []
-    
-    # 预定义一些简单的中文和英文句子
-    chinese_samples = [
-        ("你好", "你好！我是 Fusion Mini 模型。"),
-        ("什么是人工智能", "人工智能是计算机科学的一个分支，致力于创建智能机器。"),
-        ("解释机器学习", "机器学习是人工智能的子领域，使计算机能够从数据中学习。"),
-        ("深度学习是什么", "深度学习是机器学习的一个分支，使用多层神经网络模拟人脑。"),
-        ("什么是自然语言处理", "自然语言处理是AI的一个分支，帮助计算机理解人类语言。"),
-        ("Python 有什么特点", "Python 是一种简单易学、功能强大的编程语言。"),
-        ("如何学习编程", "学习编程需要理论与实践相结合，多写代码多思考。"),
-        ("什么是大数据", "大数据是指规模巨大、类型多样的数据集合。"),
-        ("云计算的优势", "云计算提供弹性扩展、成本节约、易于维护等优势。"),
-        ("区块链的原理", "区块链是一种分布式账本技术，确保数据不可篡改。"),
-    ]
-    
-    english_samples = [
-        ("Hello", "Hello! I am Fusion Mini model."),
-        ("What is AI", "AI stands for Artificial Intelligence."),
-        ("Explain machine learning", "Machine learning is a subset of AI."),
-        ("What is deep learning", "Deep learning uses neural networks with many layers."),
-        ("What is NLP", "NLP helps computers understand human language."),
-        ("Python features", "Python is simple, powerful, and versatile."),
-        ("How to learn coding", "Practice coding regularly and build projects."),
-        ("What is big data", "Big data refers to extremely large datasets."),
-        ("Benefits of cloud computing", "Cloud computing offers scalability and cost savings."),
-        ("How blockchain works", "Blockchain is a distributed ledger technology."),
-    ]
-    
-    # 生成样本
-    for i in range(num_samples):
-        # 随机选择中文或英文
-        if random.random() > 0.5:
-            prompt, response = random.choice(chinese_samples)
-        else:
-            prompt, response = random.choice(english_samples)
-        
-        # Assign think_rank based on content depth
-        if any(kw in prompt for kw in ["Prove", "Derive", "Analyze", "\u8bc1\u660e", "\u63a8\u5bfc", "\u5206\u6790"]):
-            think_rank = 3
-        elif any(kw in prompt for kw in ["Explain", "How", "Why", "\u89e3\u91ca", "\u5982\u4f55", "\u4e3a\u4ec0\u4e48"]):
-            think_rank = 2
-        elif any(kw in prompt for kw in ["Write", "Implement", "\u5199", "\u5b9e\u73b0"]):
-            think_rank = 1
-        else:
-            think_rank = 0
-
-        data.append({
-            "prompt": prompt,
-            "response": response,
-            "think_rank": think_rank,
-        })
-    
-    # 保存为 JSON
-    output_file = Path(output_path)
-    output_file.parent.mkdir(parents=True, exist_ok=True)
-    
-    with open(output_file, 'w', encoding='utf-8') as f:
-        json.dump(data, f, ensure_ascii=False, indent=2)
-    
-    print("[完成] 数据集创建成功！")
-    print(f"   文件路径：{output_path}")
-    print(f"   样本数量：{len(data)}")
-    
-    # 显示几个示例
-    print("\n[示例] 数据示例：")
-    for i, item in enumerate(data[:3]):
-        print(f"   [{i+1}] Prompt: {item['prompt']}")
-        print(f"       Response: {item['response'][:50]}...")
-        print()
-
-
-def main():
-    print("=" * 60)
-    print("创建 Fusion Mini 训练数据")
-    print("=" * 60)
-    
-    # 创建输出目录
-    output_dir = Path("data")
-    output_dir.mkdir(exist_ok=True)
-    
-    # 生成训练数据
-    output_path = output_dir / "mini_data.json"
-    create_mini_dataset(output_path, num_samples=100)
-    
-    print(f"\n[完成] 数据创建完成！")
-    print(f"\n下一步：")
-    print(f"   1. 检查数据文件：{output_path}")
-    print(f"   2. 开始训练：python train/train_mini.py")
-    print(f"   3. 或者运行完整测试：python tests/run_tests.py")
-
-
-if __name__ == "__main__":
-    main()

scripts/dedup_mini_data.py

@@ -1,120 +0,0 @@
-#!/usr/bin/env python3
-"""
-Deduplicate and expand mini_data.json to reduce duplication rate.
-Target: <20% duplication, >= 80 unique prompts.
-
-Author: Zhu Zizhan
-Project: Fusion-LLM
-License: Apache 2.0
-"""
-
-import json
-import random
-from pathlib import Path
-
-# Diverse samples covering all think_rank levels
-NEW_SAMPLES = [
-    # think_rank=0: Simple Q&A
-    {"prompt": "Hello", "response": "Hello! How can I help you today?", "think_rank": 0},
-    {"prompt": "What is Python", "response": "Python is a high-level programming language known for its readability and versatility.", "think_rank": 0},
-    {"prompt": "Define API", "response": "API stands for Application Programming Interface, a set of rules for software communication.", "think_rank": 0},
-    {"prompt": "What is HTML", "response": "HTML is the standard markup language for creating web pages.", "think_rank": 0},
-    {"prompt": "Name a search engine", "response": "Google is the most widely used search engine.", "think_rank": 0},
-    {"prompt": "What does CPU stand for", "response": "CPU stands for Central Processing Unit, the brain of a computer.", "think_rank": 0},
-    {"prompt": "What is RAM", "response": "RAM is Random Access Memory, used for temporary data storage during program execution.", "think_rank": 0},
-    {"prompt": "What is WiFi", "response": "WiFi is a wireless networking technology for internet connectivity.", "think_rank": 0},
-    {"prompt": "What is a database", "response": "A database is an organized collection of structured data stored electronically.", "think_rank": 0},
-    {"prompt": "What is an operating system", "response": "An operating system manages hardware and software resources on a computer.", "think_rank": 0},
-    {"prompt": "What is cloud storage", "response": "Cloud storage saves data on remote servers accessed via the internet.", "think_rank": 0},
-    {"prompt": "What is encryption", "response": "Encryption converts data into a coded format to prevent unauthorized access.", "think_rank": 0},
-    {"prompt": "What is a URL", "response": "A URL is a web address that specifies the location of a resource on the internet.", "think_rank": 0},
-    {"prompt": "What is a browser", "response": "A browser is software for accessing and viewing websites on the internet.", "think_rank": 0},
-    {"prompt": "What is open source", "response": "Open source software has source code that anyone can inspect, modify, and distribute.", "think_rank": 0},
-
-    # think_rank=1: Writing/implementation tasks
-    {"prompt": "Write a function to reverse a string", "response": "def reverse_string(s): return s[::-1]", "think_rank": 1},
-    {"prompt": "Implement a function to check if a number is prime", "response": "def is_prime(n): return n > 1 and all(n % i != 0 for i in range(2, int(n**0.5) + 1))", "think_rank": 1},
-    {"prompt": "Write a function to calculate factorial", "response": "def factorial(n): return 1 if n <= 1 else n * factorial(n - 1)", "think_rank": 1},
-    {"prompt": "Implement binary search in Python", "response": "def binary_search(arr, target):\n    lo, hi = 0, len(arr) - 1\n    while lo <= hi:\n        mid = (lo + hi) // 2\n        if arr[mid] == target: return mid\n        elif arr[mid] < target: lo = mid + 1\n        else: hi = mid - 1\n    return -1", "think_rank": 1},
-    {"prompt": "Write a function to sort a list", "response": "def sort_list(lst): return sorted(lst)", "think_rank": 1},
-    {"prompt": "Implement a stack data structure", "response": "class Stack:\n    def __init__(self): self.items = []\n    def push(self, item): self.items.append(item)\n    def pop(self): return self.items.pop() if self.items else None", "think_rank": 1},
-    {"prompt": "Write code to read a CSV file", "response": "import csv\nwith open('file.csv') as f:\n    reader = csv.reader(f)\n    for row in reader: print(row)", "think_rank": 1},
-    {"prompt": "Implement a linked list node", "response": "class Node:\n    def __init__(self, val, next=None):\n        self.val = val\n        self.next = next", "think_rank": 1},
-    {"prompt": "Write a function to count words in text", "response": "def count_words(text): return len(text.split())", "think_rank": 1},
-    {"prompt": "Implement a simple HTTP GET request", "response": "import requests\nresponse = requests.get('https://api.example.com/data')\nprint(response.json())", "think_rank": 1},
-
-    # think_rank=2: Explain/compare/analyze
-    {"prompt": "Explain how neural networks learn", "response": "Neural networks learn through backpropagation: they compute predictions, measure error using a loss function, calculate gradients of the loss with respect to weights, and update weights using gradient descent to minimize error.", "think_rank": 2},
-    {"prompt": "Compare REST and GraphQL", "response": "REST uses fixed endpoints returning predetermined data structures. GraphQL uses a single endpoint where clients specify exactly which fields they need, reducing over-fetching but adding query complexity.", "think_rank": 2},
-    {"prompt": "Explain the difference between SQL and NoSQL", "response": "SQL databases use structured tables with fixed schemas and ACID transactions. NoSQL databases use flexible document/key-value/graph models optimized for scale and schema evolution, often trading consistency for availability.", "think_rank": 2},
-    {"prompt": "How does garbage collection work in Python", "response": "Python uses reference counting as the primary mechanism and a cyclic garbage collector for detecting and collecting reference cycles. Objects with zero references are freed immediately; cycles are detected periodically.", "think_rank": 2},
-    {"prompt": "Explain the Transformer attention mechanism", "response": "Self-attention computes queries, keys, and values from input. Attention scores are the dot product of queries and keys, scaled by sqrt(d_k), softmaxed, then multiplied by values. This lets each position attend to all other positions.", "think_rank": 2},
-    {"prompt": "Why is batch normalization important", "response": "Batch normalization stabilizes training by normalizing layer inputs to zero mean and unit variance. This reduces internal covariate shift, allows higher learning rates, and acts as a regularizer, improving convergence.", "think_rank": 2},
-    {"prompt": "How does DNS resolution work", "response": "DNS resolution follows a hierarchy: browser cache -> OS cache -> recursive resolver -> root server -> TLD server -> authoritative server. Each step either returns the answer or delegates to the next level.", "think_rank": 2},
-    {"prompt": "Explain the difference between threads and processes", "response": "Threads share memory within a process, making communication fast but requiring synchronization. Processes have separate memory spaces, providing isolation but slower inter-process communication. Threads are lighter; processes are safer.", "think_rank": 2},
-    {"prompt": "How does caching improve performance", "response": "Caching stores frequently accessed data in fast-access storage (memory vs disk). This reduces latency, decreases backend load, and improves throughput. Cache invalidation strategies (TTL, LRU) balance freshness with hit rate.", "think_rank": 2},
-    {"prompt": "Explain how gradient descent optimization works", "response": "Gradient descent iteratively updates parameters in the opposite direction of the gradient of the loss function. Learning rate controls step size. Variants include SGD (mini-batches), Adam (adaptive rates), and momentum (acceleration).", "think_rank": 2},
-
-    # think_rank=3: Prove/derive/complex analysis
-    {"prompt": "Prove the Pythagorean theorem", "response": "Consider a right triangle with legs a, b and hypotenuse c. Construct a square of side (a+b) with four copies of the triangle. The inner quadrilateral has side c and is a square, so (a+b)^2 = c^2 + 4*(ab/2), yielding a^2 + b^2 = c^2.", "think_rank": 3},
-    {"prompt": "Derive the quadratic formula", "response": "From ax^2 + bx + c = 0, divide by a, complete the square: (x + b/2a)^2 = (b^2 - 4ac)/4a^2. Taking the square root gives x = (-b +/- sqrt(b^2 - 4ac)) / 2a.", "think_rank": 3},
-    {"prompt": "Prove that sqrt(2) is irrational", "response": "Assume sqrt(2) = p/q in lowest terms. Then 2q^2 = p^2, so p is even. Write p = 2k, then 2q^2 = 4k^2, so q^2 = 2k^2, meaning q is also even. Contradiction: both p and q are even, not in lowest terms.", "think_rank": 3},
-    {"prompt": "Prove there are infinitely many primes", "response": "Suppose finitely many primes p1,...,pn. Let N = p1*p2*...*pn + 1. N is not divisible by any pi (remainder 1). So N is prime or has a prime factor not in the list. Either way, contradiction.", "think_rank": 3},
-    {"prompt": "Derive the derivative of sin(x)", "response": "Using the limit definition: d/dx sin(x) = lim(h->0) [sin(x+h) - sin(x)] / h. Apply angle addition: sin(x+h) = sin(x)cos(h) + cos(x)sin(h). This gives sin(x)(cos(h)-1)/h + cos(x)sin(h)/h -> sin(x)*0 + cos(x)*1 = cos(x).", "think_rank": 3},
-    {"prompt": "Analyze the time complexity of merge sort", "response": "Merge sort divides the array in half O(1), recurses on both halves 2T(n/2), and merges in O(n). The recurrence T(n) = 2T(n/2) + O(n) solves to O(n log n) by the master theorem case 2. This holds for worst, average, and best cases.", "think_rank": 3},
-    {"prompt": "Prove that the harmonic series diverges", "response": "Group terms: 1 + 1/2 + (1/3+1/4) + (1/5+...+1/8) + ... Each group >= 1/2 (since each of the 2^k terms in group k is >= 1/2^(k+1)). The partial sums grow without bound, so the series diverges.", "think_rank": 3},
-    {"prompt": "Derive the normal distribution formula", "response": "The normal distribution maximizes entropy subject to fixed mean and variance. Using Lagrange multipliers on the variational problem with constraints on integral, mean, and variance, we get f(x) = (1/sqrt(2*pi*sigma^2)) * exp(-(x-mu)^2/(2*sigma^2)).", "think_rank": 3},
-
-    # Chinese samples (all ranks)
-    {"prompt": "你好", "response": "你好！很高兴见到你，有什么可以帮助你的吗？", "think_rank": 0},
-    {"prompt": "什么是���法", "response": "算法是解决特定问题的一系列明确步骤或规则。", "think_rank": 0},
-    {"prompt": "什么是互联网", "response": "互联网是全球计算机网络的互联系统，提供信息交流和资源共享。", "think_rank": 0},
-    {"prompt": "什么是编程", "response": "编程是使用编程语言编写指令，让计算机执行特定任务的过程。", "think_rank": 0},
-    {"prompt": "什么是数据结构", "response": "数据结构是组织和存储数据的方式，如数组、链表、树和图。", "think_rank": 0},
-    {"prompt": "什么是人工智能", "response": "人工智能是计算机科学的一个分支，致力于创建智能机器。", "think_rank": 0},
-    {"prompt": "写一个快速排序函数", "response": "def quicksort(arr):\n    if len(arr) <= 1: return arr\n    pivot = arr[len(arr)//2]\n    left = [x for x in arr if x < pivot]\n    middle = [x for x in arr if x == pivot]\n    right = [x for x in arr if x > pivot]\n    return quicksort(left) + middle + quicksort(right)", "think_rank": 1},
-    {"prompt": "写一个斐波那契数列函数", "response": "def fibonacci(n):\n    if n <= 1: return n\n    a, b = 0, 1\n    for _ in range(2, n+1):\n        a, b = b, a+b\n    return b", "think_rank": 1},
-    {"prompt": "实现一个简单的HTTP服务器", "response": "from http.server import HTTPServer, BaseHTTPRequestHandler\nclass Handler(BaseHTTPRequestHandler):\n    def do_GET(self):\n        self.send_response(200)\n        self.end_headers()\n        self.wfile.write(b'Hello')\nHTTPServer(('', 8000), Handler).serve_forever()", "think_rank": 1},
-    {"prompt": "解释深度学习与传统机器学习的区别", "response": "传统机器学习需要手动特征工程，模型较浅。深度学习使用多层神经网络自动学习特征表示，在图像、语音、文本等任务上表现更优，但需要更多数据和计算资源。", "think_rank": 2},
-    {"prompt": "为什么需要正则化", "response": "正则化防止模型过拟合训练数据。L1正则化产生稀疏权重（特征选择），L2正则化惩罚大权重（权重衰减）。Dropout是另一种正则化方式，随机屏蔽神经元防止共适应。", "think_rank": 2},
-    {"prompt": "解释TCP三次握手", "response": "客户端发送SYN包，服务端回复SYN-ACK包，客户端再发送ACK包确认。三次握手确保双方都具备收发能力，防止旧连接请求导致的资源浪费，建立可靠的双向通信通道。", "think_rank": 2},
-    {"prompt": "证明勾股定理", "response": "构造直角三角形三边为a,b,c。以(a+b)为边构造正方形，内部放置四个全等直角三角形，中心形成边长c的正方形。面积关系：(a+b)^2 = c^2 + 4*(ab/2)，化简得a^2+b^2=c^2。", "think_rank": 3},
-    {"prompt": "推导欧拉公式", "response": "由泰勒展开：e^(ix) = 1 + ix + (ix)^2/2! + (ix)^3/3! + ... = (1-x^2/2!+...) + i(x-x^3/3!+...) = cos(x) + i*sin(x)。令x=pi得e^(i*pi) + 1 = 0。", "think_rank": 3},
-]
-
-
-def main():
-    data_path = Path("data/mini_data.json")
-    with open(data_path, 'r', encoding='utf-8') as f:
-        old_data = json.load(f)
-
-    # Deduplicate by prompt (keep first occurrence)
-    seen_prompts = set()
-    deduped = []
-    for item in old_data:
-        if item['prompt'] not in seen_prompts:
-            deduped.append(item)
-            seen_prompts.add(item['prompt'])
-
-    # Merge deduplicated old data with new diverse samples
-    data = deduped + list(NEW_SAMPLES)
-
-    # Count
-    from collections import Counter
-    prompts = [d['prompt'] for d in data]
-    counter = Counter(prompts)
-    dup_rate = (len(prompts) - len(counter)) / len(prompts) * 100
-    rank_dist = Counter(d['think_rank'] for d in data)
-
-    print(f"Old: {len(old_data)} items, unique: {len(set(d['prompt'] for d in old_data))}")
-    print(f"New: {len(data)} items, unique: {len(counter)}, dup rate: {dup_rate:.1f}%")
-    print(f"Think rank distribution: {dict(sorted(rank_dist.items()))}")
-
-    with open(data_path, 'w', encoding='utf-8') as f:
-        json.dump(data, f, ensure_ascii=False, indent=2)
-
-    print(f"Written {len(data)} items to {data_path}")
-
-
-if __name__ == '__main__':
-    main()

scripts/fix_mini_data.py

@@ -1,61 +0,0 @@
-#!/usr/bin/env python3
-"""Fix mini_data.json: distribute think_rank 0-3 based on prompt content."""
-
-import json
-import re
-
-# Keywords suggesting different thinking depths
-DEPTH_3_KEYWORDS = ['prove', 'theorem', 'proof', 'derive', 'mathematical', 'complex',
-                    'prove', 'derive', 'calculate', 'analyze deeply',
-                    '\u8bc1\u660e', '\u63a8\u5bfc', '\u5b9a\u7406', '\u590d\u6742', '\u6df1\u5165\u5206\u6790']
-DEPTH_2_KEYWORDS = ['explain', 'why', 'how does', 'compare', 'difference',
-                    'algorithm', 'design', 'optimize',
-                    '\u89e3\u91ca', '\u4e3a\u4ec0\u4e48', '\u5982\u4f55', '\u6bd4\u8f83', '\u7b97\u6cd5', '\u8bbe\u8ba1', '\u4f18\u5316']
-DEPTH_1_KEYWORDS = ['write', 'implement', 'code', 'function', 'create',
-                    '\u5199', '\u5b9e\u73b0', '\u7f16\u5199', '\u4ee3\u7801', '\u521b\u5efa']
-
-
-def assign_depth(item):
-    text = (item.get('prompt', '') + ' ' + item.get('response', '')).lower()
-    for kw in DEPTH_3_KEYWORDS:
-        if kw.lower() in text:
-            return 3
-    for kw in DEPTH_2_KEYWORDS:
-        if kw.lower() in text:
-            return 2
-    for kw in DEPTH_1_KEYWORDS:
-        if kw.lower() in text:
-            return 1
-    return 0
-
-
-def main():
-    with open('data/mini_data.json', 'r', encoding='utf-8') as f:
-        data = json.load(f)
-
-    # Count current distribution
-    old_dist = {}
-    for item in data:
-        r = item.get('think_rank', 0)
-        old_dist[r] = old_dist.get(r, 0) + 1
-    print(f"Before fix: {old_dist}")
-
-    # Fix
-    for item in data:
-        item['think_rank'] = assign_depth(item)
-
-    # Count new distribution
-    new_dist = {}
-    for item in data:
-        r = item.get('think_rank', 0)
-        new_dist[r] = new_dist.get(r, 0) + 1
-    print(f"After fix: {new_dist}")
-
-    with open('data/mini_data.json', 'w', encoding='utf-8') as f:
-        json.dump(data, f, ensure_ascii=False, indent=2)
-
-    print(f"Fixed {len(data)} items")
-
-
-if __name__ == '__main__':
-    main()

scripts/manage_mini_data.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""Manage mini_data.json: create, fix think_rank, add depth samples, dedup.
+
+Usage:
+    python manage_mini_data.py create   # Create initial dataset
+    python manage_mini_data.py fix      # Re-assign think_rank by keywords
+    python manage_mini_data.py enrich   # Add diverse samples for all depths
+    python manage_mini_data.py dedup    # Remove duplicates
+    python manage_mini_data.py all      # Run fix + enrich + dedup
+"""
+
+import json
+import re
+import sys
+from pathlib import Path
+
+DATA_PATH = Path("data/mini_data.json")
+
+# --- Depth assignment keywords ---
+DEPTH_3_KEYWORDS = ['prove', 'theorem', 'proof', 'derive', 'mathematical', 'complex',
+                     'calculate', 'analyze deeply',
+                     '\u8bc1\u660e', '\u63a8\u5bfc', '\u5b9a\u7406', '\u590d\u6742', '\u6df1\u5165\u5206\u6790']
+DEPTH_2_KEYWORDS = ['explain', 'why', 'how does', 'compare', 'difference',
+                     'algorithm', 'design', 'optimize',
+                     '\u89e3\u91ca', '\u4e3a\u4ec0\u4e48', '\u5982\u4f55', '\u6bd4\u8f83', '\u7b97\u6cd5', '\u8bbe\u8ba1', '\u4f18\u5316']
+DEPTH_1_KEYWORDS = ['write', 'implement', 'code', 'function', 'create',
+                     '\u5199', '\u5b9e\u73b0', '\u7f16\u5199', '\u4ee3\u7801', '\u521b\u5efa']
+
+# --- Extra diverse samples ---
+EXTRA_SAMPLES = [
+    # Depth 0 (simple)
+    {"prompt": "What is 2+2?", "response": "4", "think_rank": 0},
+    {"prompt": "Capital of France?", "response": "Paris", "think_rank": 0},
+    {"prompt": "Hello", "response": "Hi! How can I help you?", "think_rank": 0},
+    # Depth 1 (coding)
+    {"prompt": "Write a function to reverse a string", "response": "def reverse_string(s): return s[::-1]", "think_rank": 1},
+    {"prompt": "Write a function to calculate factorial", "response": "def factorial(n): return 1 if n <= 1 else n * factorial(n - 1)", "think_rank": 1},
+    {"prompt": "Write a function to sort a list", "response": "def sort_list(lst): return sorted(lst)", "think_rank": 1},
+    {"prompt": "Write code to read a CSV file", "response": "import csv\nwith open('file.csv') as f:\n    reader = csv.reader(f)\n    for row in reader: print(row)", "think_rank": 1},
+    {"prompt": "Write a function to count words in text", "response": "def count_words(text): return len(text.split())", "think_rank": 1},
+    # Depth 2 (reasoning)
+    {"prompt": "Explain how neural networks learn", "response": "Neural networks learn by adjusting weights via backpropagation. The loss function measures prediction error; gradients indicate how each weight affects loss. An optimizer (e.g., SGD, Adam) updates weights in the direction that reduces loss, iteratively improving predictions.", "think_rank": 2},
+    {"prompt": "Compare BFS and DFS graph traversal", "response": "BFS explores level by level using a queue (O(V+E)), guaranteeing shortest path in unweighted graphs. DFS goes deep before backtracking using a stack (O(V+E)), useful for topological sort and cycle detection. BFS uses more memory; DFS can be iterative or recursive.", "think_rank": 2},
+    {"prompt": "Why does quicksort have O(n^2) worst case?", "response": "Quicksort's worst case occurs when the pivot is consistently the smallest or largest element, creating maximally unbalanced partitions. Each partition takes O(n) and we need n partitions, giving O(n^2). Median-of-three or random pivot selection mitigates this.", "think_rank": 2},
+    # Depth 3 (math proof)
+    {"prompt": "Prove that sqrt(2) is irrational", "response": "Assume sqrt(2) = p/q in lowest terms. Then 2q^2 = p^2, so p is even. Write p = 2k, then 2q^2 = 4k^2, so q^2 = 2k^2, meaning q is also even. This contradicts p/q being in lowest terms.", "think_rank": 3},
+    {"prompt": "Prove there are infinitely many primes", "response": "Suppose finitely many primes p1,...,pn exist. Let N = p1*p2*...*pn + 1. N is not divisible by any pi (remainder 1). So N is either prime itself or has a prime factor not in the list. Contradiction.", "think_rank": 3},
+    {"prompt": "Derive the quadratic formula", "response": "Starting from ax^2 + bx + c = 0, divide by a, complete the square: (x + b/2a)^2 = (b^2 - 4ac)/4a^2. Taking the square root gives x = (-b +- sqrt(b^2 - 4ac)) / 2a.", "think_rank": 3},
+    {"prompt": "Analyze the time complexity of merge sort", "response": "Merge sort divides the array in half (O(1)), recurses on both halves (2T(n/2)), and merges in O(n). The recurrence T(n) = 2T(n/2) + O(n) solves to O(n log n) by the master theorem (case 2).", "think_rank": 3},
+    {"prompt": "Prove the Pythagorean theorem", "response": "Consider a right triangle with legs a, b and hypotenuse c. Construct a square of side (a+b) and arrange four copies of the triangle inside. The inner quadrilateral is a square of side c, so (a+b)^2 = c^2 + 4*(ab/2), which simplifies to a^2 + b^2 = c^2.", "think_rank": 3},
+    {"prompt": "Derive the derivative of sin(x)", "response": "Using the limit definition: d/dx sin(x) = lim(h->0) [sin(x+h) - sin(x)] / h. Apply the angle addition formula: sin(x+h) = sin(x)cos(h) + cos(x)sin(h). This gives lim [sin(x)(cos(h)-1)/h + cos(x)sin(h)/h] = sin(x)*0 + cos(x)*1 = cos(x).", "think_rank": 3},
+    # Chinese samples
+    {"prompt": "Explain the difference between TCP and UDP", "response": "TCP is connection-oriented, reliable, and ordered. UDP is connectionless, unreliable, and unordered. TCP handles retransmission and flow control, UDP does not. TCP is used for web, email; UDP for streaming, DNS.", "think_rank": 2},
+    {"prompt": "Implement a simple HTTP server in Python", "response": "from http.server import HTTPServer, BaseHTTPRequestHandler\nclass Handler(BaseHTTPRequestHandler):\n    def do_GET(self):\n        self.send_response(200)\n        self.end_headers()\n        self.wfile.write(b'Hello')\nHTTPServer(('', 8000), Handler).serve_forever()", "think_rank": 1},
+]
+
+
+def load_data():
+    if DATA_PATH.exists():
+        with open(DATA_PATH, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    return []
+
+
+def save_data(data):
+    DATA_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with open(DATA_PATH, 'w', encoding='utf-8') as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+    print(f"Saved {len(data)} items to {DATA_PATH}")
+
+
+def show_dist(data):
+    dist = {}
+    for item in data:
+        r = item.get('think_rank', 0)
+        dist[r] = dist.get(r, 0) + 1
+    print(f"Distribution: {dict(sorted(dist.items()))}")
+
+
+def assign_depth(item):
+    text = (item.get('prompt', '') + ' ' + item.get('response', '')).lower()
+    for kw in DEPTH_3_KEYWORDS:
+        if kw.lower() in text:
+            return 3
+    for kw in DEPTH_2_KEYWORDS:
+        if kw.lower() in text:
+            return 2
+    for kw in DEPTH_1_KEYWORDS:
+        if kw.lower() in text:
+            return 1
+    return 0
+
+
+def cmd_fix(data):
+    for item in data:
+        item['think_rank'] = assign_depth(item)
+    print("Fixed think_rank distribution:")
+    show_dist(data)
+    return data
+
+
+def cmd_enrich(data):
+    existing_prompts = {item['prompt'] for item in data}
+    added = 0
+    for sample in EXTRA_SAMPLES:
+        if sample['prompt'] not in existing_prompts:
+            data.append(sample)
+            existing_prompts.add(sample['prompt'])
+            added += 1
+    print(f"Added {added} new diverse samples")
+    show_dist(data)
+    return data
+
+
+def cmd_dedup(data):
+    seen = set()
+    deduped = []
+    for item in data:
+        key = item.get('prompt', '')
+        if key not in seen:
+            seen.add(key)
+            deduped.append(item)
+    removed = len(data) - len(deduped)
+    print(f"Removed {removed} duplicates")
+    return deduped
+
+
+def cmd_create(data):
+    """Create initial mini dataset."""
+    print("Creating initial dataset...")
+    return EXTRA_SAMPLES.copy()
+
+
+def cmd_all(data):
+    data = cmd_fix(data)
+    data = cmd_enrich(data)
+    data = cmd_dedup(data)
+    return data
+
+
+COMMANDS = {
+    'create': cmd_create,
+    'fix': cmd_fix,
+    'enrich': cmd_enrich,
+    'dedup': cmd_dedup,
+    'all': cmd_all,
+}
+
+
+def main():
+    if len(sys.argv) < 2 or sys.argv[1] not in COMMANDS:
+        print(f"Usage: {sys.argv[0]} [{'|'.join(COMMANDS)}]")
+        sys.exit(1)
+
+    cmd = sys.argv[1]
+    data = load_data()
+    print(f"Loaded {len(data)} items")
+    show_dist(data)
+
+    result = COMMANDS[cmd](data)
+    save_data(result)
+
+
+if __name__ == '__main__':
+    main()

tests/run_tests.py

@@ -24,7 +24,7 @@ from pathlib import Path
 project_root = Path(__file__).parent.parent
 sys.path.insert(0, str(project_root))
 
-print("🧪 Fusion 项目单元测试")
+print("[LOGO] Fusion 项目单元测试")
 print("=" * 50)
 
 
@@ -54,7 +54,7 @@ class TestSBLAAttention(unittest.TestCase):
         output, _ = attn(hidden_states=x, attention_mask=attention_mask)
         
         self.assertEqual(output.shape, (batch_size, seq_len, hidden_size))
-        print("✅ SBLA 前向传播测试通过")
+        print("[OK] SBLA 前向传播测试通过")
     
     def test_long_sequence(self):
         """测试长序列处理"""
@@ -75,7 +75,7 @@ class TestSBLAAttention(unittest.TestCase):
         output, _ = attn(hidden_states=x, attention_mask=attention_mask)
         
         self.assertEqual(output.shape, (1, 8192, 256))
-        print("✅ SBLA 长序列测试通过")
+        print("[OK] SBLA 长序列测试通过")
 
 
 class TestThinkingDial(unittest.TestCase):
@@ -92,7 +92,7 @@ class TestThinkingDial(unittest.TestCase):
         
         self.assertEqual(depth, 2)
         self.assertEqual(clean, "证明勾股定理")
-        print("✅ Thinking Dial 解析测试通过")
+        print("[OK] Thinking Dial 解析测试通过")
     
     def test_inject_token(self):
         """测试注入控制 token"""
@@ -104,7 +104,7 @@ class TestThinkingDial(unittest.TestCase):
         )
         
         self.assertIn("<|think_depth_1|>", result)
-        print("✅ Thinking Dial 注入测试通过")
+        print("[OK] Thinking Dial 注入测试通过")
 
 
 class TestBilingualFilter(unittest.TestCase):
@@ -126,7 +126,7 @@ class TestBilingualFilter(unittest.TestCase):
             "量子纠缠是量子力学中的一种现象，指两个或多个粒子之间存在一种特殊的关联。"
         ))
         
-        print("✅ 中文过滤器测试通过")
+        print("[OK] 中文过滤器测试通过")
     
     def test_english_filter(self):
         """测试英文质量过滤"""
@@ -139,7 +139,7 @@ class TestBilingualFilter(unittest.TestCase):
             "Quantum entanglement is a phenomenon in quantum mechanics."
         ))
         
-        print("✅ 英文过滤器测试通过")
+        print("[OK] 英文过滤器测试通过")
 
 
 class TestFusionModel(unittest.TestCase):
@@ -159,7 +159,7 @@ class TestFusionModel(unittest.TestCase):
         model = FusionModel(config)
         
         self.assertIsNotNone(model)
-        print("✅ Fusion 模型创建测试通过")
+        print("[OK] Fusion 模型创建测试通过")
     
     def test_forward_pass(self):
         """测试前向传播"""
@@ -186,7 +186,7 @@ class TestFusionModel(unittest.TestCase):
         
         self.assertIn("loss", outputs)
         self.assertIn("logits", outputs)
-        print("✅ Fusion 模型前向传播测试通过")
+        print("[OK] Fusion 模型前向传播测试通过")
 
 
 class TestDataPipeline(unittest.TestCase):
@@ -212,7 +212,7 @@ class TestDataPipeline(unittest.TestCase):
             self.assertIn("think_rank", item)
             self.assertIn(item["think_rank"], [0, 1, 2, 3])
         
-        print("✅ 示例数据格式测试通过")
+        print("[OK] 示例数据格式测试通过")
 
 
 def run_all_tests():
@@ -258,9 +258,9 @@ def run_all_tests():
     success = result.wasSuccessful()
     
     if success:
-        print("\n🎉 所有测试通过！")
+        print("\n[DONE] 所有测试通过！")
     else:
-        print("\n❌ 部分测试失败，请检查代码")
+        print("\n[FAIL] 部分测试失败，请检查代码")
     
     return success
 

tests/test_sbla_integration.py

@@ -44,8 +44,8 @@ print()
 
 # 4. 验证 SBLA 是否使用
 print("[4] 验证 SBLA 注意力...")
-has_sblla = any("SBLAttention" in str(module) for module in model.modules())
-if has_sblla:
+has_sbla = any("SBLAttention" in str(module) for module in model.modules())
+if has_sbla:
     print("   SBLA 注意力已集成到模型中")
 else:
     print("   未检测到 SBLA 注意力（可能使用了标准注意力）")