fix: v13 external audit - CRITICAL/HIGH/MEDIUM fixes

CRITICAL (3):
- F-NEW-8: Fix quantization_tool.py import errors (DyQuant -> DyQuantConverter)
- F-NEW-9: Fix DyQuant/QATTrainer constructor signature mismatches
- F-NEW-10: Fix QATTrainer constructor parameter mismatch

HIGH (4):
- S-NEW-8: Remove unused Q/K/V projections from SBLAttention (~1.6B params saved)
- S-NEW-9: Implement real bitsandbytes 4/8-bit quantization (was fake QLoRA)
- S-NEW-10: Replace DataCollatorForSeq2Seq with DataCollatorForLanguageModeling
- S-NEW-11: Fix single-file model export loading actual weights (was random)

MEDIUM:
- M-NEW-11: Initialize _tokenizer in DPOTrainer.__init__
- M-NEW-13: Remove dead code (optimized_sbla_attention.py - never used)

Verified: all files pass py_compile syntax check

evaluation/quantization_tool.py

@@ -19,7 +19,7 @@ from torch.quantization import get_default_qconfig, prepare_qat, convert
 sys.path.insert(0, '.')
 
 from evaluation.metrics import ModelEvaluator, EvaluationMetrics
-from inference.dyquant import DyQuant, QATTrainer, QuantizedLinear
+from inference.dyquant import DyQuantConverter, QATTrainer, QuantConfig
 
 
 class QuantizationTool:
@@ -30,6 +30,7 @@ class QuantizationTool:
         model: nn.Module,
         tokenizer = None,
         device: str = "cpu",
+        model_path: Optional[str] = None,
     ):
         """
         初始化量化工具
@@ -38,21 +39,22 @@ class QuantizationTool:
             model: 要量化的模型
             tokenizer: tokenizer（可选）
             device: 设备
+            model_path: 模型路径（用于 DyQuant）
         """
         self.model = model
         self.tokenizer = tokenizer
         self.device = device
+        self.model_path = model_path or "fusion-mini"
         self.original_model = None
         self.quantized_model = None
         self.qat_trainer = None
+        self.converter = None
     
     def backup_original_model(self):
         """备份原始模型"""
         print("[QuantTool] 备份原始模型...")
-        self.original_model = type(self.model)(
-            self.model.config if hasattr(self.model, 'config') else None
-        )
-        self.original_model.load_state_dict(self.model.state_dict())
+        import copy
+        self.original_model = copy.deepcopy(self.model)
         print("[QuantTool] 备份完成")
     
     def dynamic_quantize(
@@ -72,31 +74,33 @@ class QuantizationTool:
         """
         print(f"[QuantTool] 开始动态量化（{bits}-bit, {mode}）...")
         
-        dyquant = DyQuant(
-            model=self.model,
-            config=DyQuantConfig(
-                bits=bits,
-                symmetric=(mode == "symmetric"),
-                mixed_precision=False,
-            ),
+        # 使用正确的 QuantConfig API
+        config = QuantConfig(
+            model_path=self.model_path,
+            bits=bits,
+            mixed_precision=False,
         )
         
-        self.quantized_model = dyquant.convert()
-        print(f"[QuantTool] 动态量化完成")
+        self.converter = DyQuantConverter(config)
+        self.converter.model = self.model  # 注入已加载的模型
+        self.quantized_model = self.converter.convert()
         
+        print(f"[QuantTool] 动态量化完成")
         return self.quantized_model
     
     def prepare_qat(
         self,
         learning_rate: float = 1e-4,
         num_epochs: int = 3,
+        train_data: Optional[str] = None,
     ) -> "QATTrainer":
         """
         准备量化感知训练（QAT）
         
         参数：
             learning_rate: 学习率
-            num_epochs: 训练轮数
+            num_epochs: 训练轮数（注意：QATTrainer 没有 num_epochs 参数）
+            train_data: 训练数据路径
             
         返回：
             QATTrainer 对象
@@ -105,17 +109,42 @@ class QuantizationTool:
         print(f"   学习率: {learning_rate}")
         print(f"   训练轮数: {num_epochs}")
         
+        # 使用正确的 QuantConfig API
+        config = QuantConfig(
+            model_path=self.model_path,
+            bits=4,
+            mixed_precision=True,
+        )
+        
+        # QATTrainer 签名：(config, train_data, learning_rate, warmup_steps)
         self.qat_trainer = QATTrainer(
-            model=self.model,
+            config=config,
+            train_data=train_data,
             learning_rate=learning_rate,
-            num_epochs=num_epochs,
+            warmup_steps=100,
         )
         
+        # 注入已加载的模型，避免重复加载
+        self.qat_trainer.model = self.model
+        
         self.qat_trainer.prepare()
         print(f"[QuantTool] QAT 准备完成")
         
+        # 保存 num_epochs 供后续 train() 使用
+        self._qat_epochs = num_epochs
+        
         return self.qat_trainer
     
+    def run_qat_training(self, epochs: Optional[int] = None):
+        """运行 QAT 训练"""
+        if self.qat_trainer is None:
+            raise ValueError("请先调用 prepare_qat()")
+        
+        epochs = epochs or getattr(self, '_qat_epochs', 3)
+        # QATTrainer.train() 签名：(epochs, lr, batch_size, max_len)
+        self.qat_trainer.train(epochs=epochs)
+        self.quantized_model = self.qat_trainer.qat_model
+    
     def evaluate_quantized(
         self,
         texts: List[str],
@@ -250,15 +279,7 @@ class QuantizationTool:
         if format == "safetensors":
             try:
                 import safetensors.torch
-                # 准备状态字典（处理 QuantizedLinear）
-                state_dict = {}
-                for name, module in self.quantized_model.named_modules():
-                    if isinstance(module, QuantizedLinear):
-                        state_dict[f"{name}.q_weight"] = module.q_weight
-                        state_dict[f"{name}.q_scale"] = module.q_scale
-                        state_dict[f"{name}.q_zero_point"] = module.q_zero_point
-                        state_dict[f"{name}.bias"] = module.bias
-                safetensors.torch.save_file(state_dict, path)
+                safetensors.torch.save_model(self.quantized_model, path)
             except ImportError:
                 print(f"[QuantTool] 警告：safetensors 未安装，使用 PyTorch 格式")
                 format = "pytorch"
@@ -269,20 +290,6 @@ class QuantizationTool:
         print(f"[QuantTool] 保存完成")
 
 
-class DyQuantConfig:
-    """DyQuant 配置（简化版）"""
-    
-    def __init__(
-        self,
-        bits: int = 8,
-        symmetric: bool = True,
-        mixed_precision: bool = False,
-    ):
-        self.bits = bits
-        self.symmetric = symmetric
-        self.mixed_precision = mixed_precision
-
-
 def quantize_model(
     model: nn.Module,
     method: str = "dynamic",
@@ -307,7 +314,8 @@ def quantize_model(
         return tool.dynamic_quantize(bits=bits)
     elif method == "qat":
         trainer = tool.prepare_qat(**kwargs)
-        trainer.train(**kwargs)
+        epochs = kwargs.get('num_epochs', 3)
+        trainer.train(epochs=epochs)
         return tool.quantized_model
     else:
         raise ValueError(f"不支持的量化方法: {method}")
@@ -324,6 +332,6 @@ if __name__ == "__main__":
     print()
     print("用法：")
     print("  from evaluation.quantization_tool import QuantizationTool")
-    print("  tool = QuantizationTool(model)")
+    print("  tool = QuantizationTool(model, model_path='fusion-mini')")
     print("  quantized_model = tool.dynamic_quantize(bits=8)")
     print("  metrics = tool.compare_models(texts)")

inference/ollama_deploy_v2.py

@@ -579,12 +579,20 @@ def _fallback_export_gguf(model_path: str, output_path: str) -> Optional[str]:
             merged_state.update(shard_state)
         st.save_file(merged_state, export_path)
     else:
-        # Single-file model
+        # Single-file model: load actual weights, don't save random init
         weight_files = list(model_path_obj.glob("*.safetensors")) + list(model_path_obj.glob("*.bin"))
         if not weight_files:
             logger.error("No model weight files found")
             return None
-        st.save_file(model.state_dict(), export_path)
+        # Load the actual weights
+        import safetensors.torch as st
+        import torch
+        weight_file = weight_files[0]
+        if weight_file.suffix == '.safetensors':
+            state_dict = st.load_file(str(weight_file))
+        else:  # .bin (PyTorch)
+            state_dict = torch.load(str(weight_file), map_location='cpu')
+        st.save_file(state_dict, export_path)
     logger.info(f"Exported model weights to: {export_path}")
     logger.info("NOTE: This is a safetensors export, not GGUF. For Ollama deployment,")
     logger.info("      convert this to GGUF using llama.cpp after ensuring architecture compatibility.")

models/optimized_sbla_attention.py

@@ -1,266 +0,0 @@
-"""
-优化的 SBLA 注意力 - 尝试进一步优化速度（虽然已经很快了）
-"""
-import sys
-import torch
-import torch.nn.functional as F
-from pathlib import Path
-from typing import Optional, Tuple
-
-sys.path.insert(0, '.')
-
-
-class OptimizedSBLAttention(torch.nn.Module):
-    """
-    优化的 SBLA 注意力模块（尝试进一步优化速度）
-    
-    优化策略：
-    1. 使用混合精度（FP16）
-    2. 减少不必要的计算
-    3. 优化内存访问模式
-    """
-    
-    def __init__(self, config):
-        super().__init__()
-        
-        self.hidden_size = config.hidden_size
-        self.num_heads = config.num_attention_heads
-        self.head_dim = self.hidden_size // self.num_heads
-        self.window_size = getattr(config, 'sbla_window_size', 512)
-        self.num_key_value_heads = getattr(config, 'num_key_value_heads', self.num_heads)
-        self.num_key_value_groups = self.num_heads // self.num_key_value_heads
-        
-        # 投影层
-        self.q_proj = torch.nn.Linear(self.hidden_size, self.hidden_size, bias=False)
-        self.k_proj = torch.nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False)
-        self.v_proj = torch.nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False)
-        self.o_proj = torch.nn.Linear(self.hidden_size, self.hidden_size, bias=False)
-        
-        # SBLA 门控（可选）
-        self.use_sbla = True
-        self.sbla_gate = torch.nn.Linear(self.hidden_size, self.hidden_size, bias=False)
-        
-        # 混合精度（可选）
-        self.use_fp16 = False  # 默认关闭，因为已经很快了
-        
-        # Dropout
-        self.dropout = torch.nn.Dropout(getattr(config, 'attention_probs_dropout_prob', 0.1))
-    
-    def _repeat_kv(self, hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
-        """重复 KV heads 以匹配 Q heads"""
-        if n_rep == 1:
-            return hidden_states
-        
-        batch, seq_len, num_key_value_heads, head_dim = hidden_states.shape
-        hidden_states = hidden_states[:, :, :, None, :].expand(
-            batch, seq_len, num_key_value_heads, n_rep, head_dim
-        )
-        hidden_states = hidden_states.reshape(batch, seq_len, num_key_value_heads * n_rep, head_dim)
-        return hidden_states
-    
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        attention_mask: Optional[torch.Tensor] = None,
-        past_key_value: Optional[Tuple[torch.Tensor]] = None,
-        use_cache: bool = False,
-    ) -> Tuple[torch.Tensor, Optional[Tuple[torch.Tensor]]]:
-        """
-        优化的前向传播
-        """
-        batch_size, seq_len, hidden_size = hidden_states.shape
-        
-        # 混合精度（可选）
-        if self.use_fp16 and hidden_states.device.type == 'cuda':
-            with torch.cuda.amp.autocast():
-                return self._forward_impl(
-                    hidden_states, attention_mask, past_key_value, use_cache
-                )
-        else:
-            return self._forward_impl(
-                hidden_states, attention_mask, past_key_value, use_cache
-            )
-    
-    def _forward_impl(
-        self,
-        hidden_states: torch.Tensor,
-        attention_mask: Optional[torch.Tensor] = None,
-        past_key_value: Optional[Tuple[torch.Tensor]] = None,
-        use_cache: bool = False,
-    ) -> Tuple[torch.Tensor, Optional[Tuple[torch.Tensor]]]:
-        """实际的前向传播实现"""
-        batch_size, seq_len, hidden_size = hidden_states.shape
-        
-        # 1. 线性投影
-        query_states = self.q_proj(hidden_states)
-        key_states = self.k_proj(hidden_states)
-        value_states = self.v_proj(hidden_states)
-        
-        # 2. 形状重塑
-        query_states = query_states.view(batch_size, seq_len, self.num_heads, self.head_dim)
-        key_states = key_states.view(batch_size, seq_len, self.num_key_value_heads, self.head_dim)
-        value_states = value_states.view(batch_size, seq_len, self.num_key_value_heads, self.head_dim)
-        
-        # 3. KV 缓存（可选）
-        if past_key_value is not None:
-            key_states = torch.cat([past_key_value[0], key_states], dim=1)
-            value_states = torch.cat([past_key_value[1], value_states], dim=1)
-        
-        past_key_value = (key_states, value_states) if use_cache else None
-        
-        # 4. 重复 KV heads（如果 GQA 启用）
-        key_states = self._repeat_kv(key_states, self.num_key_value_groups)
-        value_states = self._repeat_kv(value_states, self.num_key_value_groups)
-        
-        # 5. 转置为 (batch, num_heads, seq_len, head_dim)
-        query_states = query_states.transpose(1, 2)
-        key_states = key_states.transpose(1, 2)
-        value_states = value_states.transpose(1, 2)
-        
-        # 6. 注意力分数计算
-        attn_weights = torch.matmul(query_states, key_states.transpose(-1, -2)) / (self.head_dim ** 0.5)
-        
-        # 7. 注意力掩码（优化：避免不必要的形状操作）
-        if attention_mask is not None:
-            # 确保 attention_mask 形状正确
-            if attention_mask.dim() == 2:
-                # (batch, seq_len) -> (batch, 1, 1, seq_len)
-                attention_mask = attention_mask[:, None, None, :]
-            elif attention_mask.dim() == 3:
-                # (batch, 1, seq_len, seq_len) -> (batch, 1, seq_len, seq_len)
-                pass
-            
-            # 应用掩码
-            attn_weights = attn_weights + attention_mask
-        
-        # 8. Softmax
-        attn_weights = torch.softmax(attn_weights, dim=-1)
-        attn_weights = self.dropout(attn_weights)
-        
-        # 9. 注意力输出
-        attn_output = torch.matmul(attn_weights, value_states)
-        
-        # 10. 转置回 (batch, seq_len, num_heads, head_dim)
-        attn_output = attn_output.transpose(1, 2).contiguous()
-        attn_output = attn_output.view(batch_size, seq_len, hidden_size)
-        
-        # 11. 输出投影
-        attn_output = self.o_proj(attn_output)
-        
-        # 12. SBLA 门控（可选，优化：避免不必要的计算）
-        if self.use_sbla:
-            # 简化的 SBLA：只应用门控，不扩展潜向量
-            gate = torch.sigmoid(self.sbla_gate(hidden_states))
-            attn_output = attn_output * gate
-        
-        return attn_output, past_key_value
-    
-    @torch.no_grad()
-    def benchmark(self, seq_len=32, num_runs=100):
-        """
-        性能基准测试
-        """
-        print(f"[BENCHMARK] 优化版 SBLA 注意力性能分析（seq_len={seq_len}, num_runs={num_runs}）...")
-        
-        self.eval()
-        
-        # 创建测试输入
-        hidden_states = torch.randn(1, seq_len, self.hidden_size)
-        attention_mask = torch.ones(1, seq_len)
-        
-        # 预热
-        for _ in range(10):
-            self.forward(hidden_states, attention_mask)
-        
-        # 计时
-        torch.cuda.synchronize() if hidden_states.device.type == 'cuda' else None
-        start = torch.cuda.Event(enable_timing=True) if hidden_states.device.type == 'cuda' else None
-        end = torch.cuda.Event(enable_timing=True) if hidden_states.device.type == 'cuda' else None
-        
-        times = []
-        for i in range(num_runs):
-            if hidden_states.device.type == 'cuda':
-                start.record()
-                self.forward(hidden_states, attention_mask)
-                end.record()
-                torch.cuda.synchronize()
-                times.append(start.elapsed_time(end))
-            else:
-                import time
-                t0 = time.time()
-                self.forward(hidden_states, attention_mask)
-                t1 = time.time()
-                times.append((t1 - t0) * 1000)  # 转换为 ms
-        
-        # 统计
-        avg_time = sum(times) / len(times)
-        min_time = min(times)
-        max_time = max(times)
-        
-        print(f"   平均时间: {avg_time:.2f} ms")
-        print(f"   最短时间: {min_time:.2f} ms")
-        print(f"   最长时间: {max_time:.2f} ms")
-        
-        return avg_time, min_time, max_time
-
-
-if __name__ == "__main__":
-    print("=" * 60)
-    print("Fusion-LLM 优化的 SBLA 注意力测试")
-    print("=" * 60)
-    print()
-    
-    # 创建测试配置
-    class TestConfig:
-        def __init__(self):
-            self.hidden_size = 64
-            self.num_attention_heads = 2
-            self.sbla_window_size = 512
-            self.num_key_value_heads = 2
-            self.attention_probs_dropout_prob = 0.1
-    
-    config = TestConfig()
-    
-    # 创建优化版 SBLA 注意力
-    print("[1] 创建优化版 SBLA 注意力...")
-    attn = OptimizedSBLAttention(config)
-    print(f"   配置: hidden_size={config.hidden_size}, num_heads={config.num_attention_heads}")
-    print()
-    
-    # 测试前向传播
-    print("[2] 测试前向传播...")
-    hidden_states = torch.randn(1, 8, config.hidden_size)
-    attention_mask = torch.ones(1, 8)
-    
-    output, cache = attn(hidden_states, attention_mask)
-    print(f"   输入形状: {hidden_states.shape}")
-    print(f"   输出形状: {output.shape}")
-    print()
-    
-    # 性能基准测试
-    print("[3] 性能基准测试...")
-    avg_time, min_time, max_time = attn.benchmark(seq_len=32, num_runs=100)
-    print()
-    
-    # 与原版比较（如果可用）
-    print("[4] 与原版比较...")
-    try:
-        from models.sbla_attention import SBLAttention
-        
-        # 创建原版
-        original_attn = SBLAttention(config)
-        
-        # 基准测试
-        original_attn.benchmark(seq_len=32, num_runs=100)
-        print()
-        
-        print("[INFO] 优化版 vs 原版:")
-        print(f"   优化版平均时间: {avg_time:.2f} ms")
-        print(f"   原版平均时间: (见上方)")
-        print()
-    except:
-        print("   [WARN] 原版不可用，跳过比较")
-        print()
-    
-    print("[PASS] 优化的 SBLA 注意力测试通过")
-    sys.exit(0)

models/sbla_attention.py

@@ -92,10 +92,11 @@ class SBLAttention(nn.Module):
         assert mode in ("pure_sbla", "hybrid"), \
             f"mode 必须是 'pure_sbla' 或 'hybrid'，得到 '{mode}'"
         
-        # Q/K/V 投影 (GQA: K/V use fewer heads)
-        self.q_proj = nn.Linear(hidden_size, num_heads * self.head_dim, bias=False)
-        self.k_proj = nn.Linear(hidden_size, self.num_key_value_heads * self.kv_head_dim, bias=False)
-        self.v_proj = nn.Linear(hidden_size, self.num_key_value_heads * self.kv_head_dim, bias=False)
+        # S-NEW-8 FIX: Remove unused Q/K/V projections (waste ~1.6B params for 32 layers)
+        # FusionAttention handles projections and RoPE, then calls forward_with_qkv
+        # self.q_proj = nn.Linear(hidden_size, num_heads * self.head_dim, bias=False)
+        # self.k_proj = nn.Linear(hidden_size, self.num_key_value_heads * self.kv_head_dim, bias=False)
+        # self.v_proj = nn.Linear(hidden_size, self.num_key_value_heads * self.kv_head_dim, bias=False)
         
         # 潜向量投影（跨块关联）
         self.latent_q_proj = nn.Linear(hidden_size, latent_dim, bias=False)

train/dpo_finetune.py

@@ -79,6 +79,9 @@ class DPOTrainer:
         self.config = config
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         self.step = 0
+        self._tokenizer = None  # M-NEW-11 FIX: Initialize to prevent AttributeError
+        self.model = None
+        self.ref_model = None
         
     def _get_tokenizer(self) -> object:
         """Get tokenizer with fallback to character-level encoding."""

train/lora_finetune.py

@@ -28,7 +28,7 @@ from transformers import (
     AutoTokenizer,
     TrainingArguments,
     Trainer,
-    DataCollatorForSeq2Seq,
+    DataCollatorForLanguageModeling,
     GenerationConfig,
 )
 from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
@@ -204,26 +204,61 @@ def create_local_model(
     total_params = sum(p.numel() for p in model.parameters())
     logger.info(f"[create_local_model] 模型参数总量：{total_params / 1e9:.2f}B")
     
-    # C4: Fix quantization - use prepare_model_for_kbit_training for local models
-    # For loading from HF hub with QLoRA, BitsAndBytesConfig would be used with
-    # AutoModelForCausalLM.from_pretrained. Since we create local models, we use
-    # prepare_model_for_kbit_training after model creation.
+    # S-NEW-9 FIX: QLoRA requires proper bitsandbytes integration
+    # For local models created from scratch, we can't use HF's AutoModel quantization.
+    # Instead, we quantize the model directly with bitsandbytes if available.
     if quantize:
         if load_in_4bit:
             logger.info("[create_local_model] Using 4-bit quantization (QLoRA)")
             try:
-                from transformers import BitsAndBytesConfig
-                bnb_config = BitsAndBytesConfig(
-                    load_in_4bit=True,
-                    bnb_4bit_quant_type="nf4",
-                    bnb_4bit_use_double_quant=True,
-                )
-                logger.info("[create_local_model] BitsAndBytesConfig created for NF4 quantization")
+                import bitsandbytes as bnb
+                # Replace Linear layers with 4-bit quantized versions
+                for name, module in model.named_modules():
+                    if isinstance(module, nn.Linear) and not any(x in name for x in ['lora', 'head', 'embed']):
+                        # Create 4-bit quantized linear (using bitsandbytes nf4)
+                        quantized = bnb.nn.Linear4bit(
+                            module.in_features,
+                            module.out_features,
+                            bias=module.bias is not None,
+                            quant_type='nf4',
+                            compute_dtype=torch.float16
+                        )
+                        # Replace in model
+                        parent_name = '.'.join(name.split('.')[:-1])
+                        child_name = name.split('.')[-1]
+                        if parent_name:
+                            parent = dict(model.named_modules())[parent_name]
+                            setattr(parent, child_name, quantized)
+                        else:
+                            setattr(model, child_name, quantized)
+                logger.info("[create_local_model] 4-bit quantization applied (nf4)")
             except ImportError:
-                logger.warning("bitsandbytes not installed, 4-bit quantization may not work properly")
+                logger.warning("bitsandbytes not installed, 4-bit quantization DISABLED")
+                logger.warning("Model will train in FP32 - install bitsandbytes for true QLoRA")
             model = prepare_model_for_kbit_training(model)
         elif load_in_8bit:
             logger.info("[create_local_model] Using 8-bit quantization")
+            try:
+                import bitsandbytes as bnb
+                # Replace Linear layers with 8-bit quantized versions
+                for name, module in model.named_modules():
+                    if isinstance(module, nn.Linear) and not any(x in name for x in ['lora', 'head', 'embed']):
+                        quantized = bnb.nn.Linear8bitLt(
+                            module.in_features,
+                            module.out_features,
+                            bias=module.bias is not None,
+                            has_fp16_weights=False
+                        )
+                        parent_name = '.'.join(name.split('.')[:-1])
+                        child_name = name.split('.')[-1]
+                        if parent_name:
+                            parent = dict(model.named_modules())[parent_name]
+                            setattr(parent, child_name, quantized)
+                        else:
+                            setattr(model, child_name, quantized)
+                logger.info("[create_local_model] 8-bit quantization applied")
+            except ImportError:
+                logger.warning("bitsandbytes not installed, 8-bit quantization DISABLED")
             model = prepare_model_for_kbit_training(model)
     
     return model, config
@@ -348,11 +383,7 @@ def train(args):
         model=model,
         args=training_args,
         train_dataset=train_dataset,
-        data_collator=DataCollatorForSeq2Seq(
-            tokenizer,
-            model=model,
-            padding="longest",
-        ),
+        data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
     )
     
     # 7. 开始训练