@icyfenix-dmla/cli 2026.5.29-2018 → 2026.6.5-1204

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icyfenix-dmla/cli",
-  "version": "2026.5.29-2018",
+  "version": "2026.6.5-1204",
   "description": "DMLA 沙箱服务命令行工具",
   "type": "module",
   "main": "src/index.js",

package/shared/llm/__init__.py

@@ -1,7 +1,9 @@
 # LLM 模块
+from .dpodataset import DPODataset
+from .logits_to_log_probs import logits_to_log_probs, dpo_loss
 from .mini_mind_config import MiniMindConfig, RMSNorm, Attention, FeedForward, MiniMindBlock, MiniMindModel, MiniMindForCausalLM, precompute_freqs_cis, apply_rotary_pos_emb, repeat_kv
 from .pretrain_dataset import PretrainDataset
 from .reward_model import RewardModel
 from .sftdataset import SFTDataset, pre_processing_chat
 
-__all__ = ['MiniMindConfig', 'RMSNorm', 'Attention', 'FeedForward', 'MiniMindBlock', 'MiniMindModel', 'MiniMindForCausalLM', 'precompute_freqs_cis', 'apply_rotary_pos_emb', 'repeat_kv', 'PretrainDataset', 'RewardModel', 'SFTDataset', 'pre_processing_chat']
+__all__ = ['DPODataset', 'logits_to_log_probs', 'dpo_loss', 'MiniMindConfig', 'RMSNorm', 'Attention', 'FeedForward', 'MiniMindBlock', 'MiniMindModel', 'MiniMindForCausalLM', 'precompute_freqs_cis', 'apply_rotary_pos_emb', 'repeat_kv', 'PretrainDataset', 'RewardModel', 'SFTDataset', 'pre_processing_chat']

package/shared/llm/dpodataset.py

@@ -0,0 +1,108 @@
+# DPODataset 定义
+# 从文档自动提取生成
+
+import json
+import os
+import torch
+from datasets import load_dataset, Features, Value
+from datasets import logging as datasets_logging
+from torch.utils.data import Dataset
+
+class DPODataset(Dataset):
+    """
+    DPO 数据集：将偏好对比数据 tokenize 为模型可训练的格式
+
+    每条样本格式：{"chosen": [{role, content}, ...], "rejected": [{role, content}, ...]}
+    输出 chosen 和 rejected 的 input_ids、目标 ids 和 loss_mask
+    loss_mask 仅在 assistant 回答部分为 1，其余为 0
+    """
+    CHATML_TEMPLATE = (
+        "{% for message in messages %}<|im_start|>{{ message.role }}\n"
+        "{{ message.content }}<|im_end|>\n"
+        "{% endfor %}"
+        "{% if add_generation_prompt %}<|im_start|>assistant\n{% endif %}"
+    )
+
+    def __init__(self, jsonl_path, tokenizer, max_length=768):
+        super().__init__()
+        os.environ["TOKENIZERS_PARALLELISM"] = "false"
+        self.tokenizer = tokenizer
+        if not tokenizer.chat_template:
+            tokenizer.chat_template = self.CHATML_TEMPLATE
+        self.max_length = max_length
+        self.padding = tokenizer.pad_token_id if tokenizer.pad_token_id is not None else 0
+        # 定位 assistant 回答的起止 token ID
+        self.bos_id = tokenizer(f'{tokenizer.bos_token}assistant\n', add_special_tokens=False).input_ids
+        self.eos_id = tokenizer(f'{tokenizer.eos_token}\n', add_special_tokens=False).input_ids
+        features = Features({
+            'chosen': [{'role': Value('string'), 'content': Value('string')}],
+            'rejected': [{'role': Value('string'), 'content': Value('string')}]
+        })
+        datasets_logging.set_verbosity_error()
+        self.samples = load_dataset('json', data_files=jsonl_path, split='train', features=features)
+        datasets_logging.set_verbosity_warning()
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, index):
+        sample = self.samples[index]
+        chosen = sample['chosen']
+        rejected = sample['rejected']
+
+        # 将对话转为 ChatML 格式文本
+        chosen_prompt = self.tokenizer.apply_chat_template(
+            chosen, tokenize=False, add_generation_prompt=False
+        )
+        rejected_prompt = self.tokenizer.apply_chat_template(
+            rejected, tokenize=False, add_generation_prompt=False
+        )
+
+        # Tokenize 并填充到固定长度
+        chosen_encoding = self.tokenizer(
+            chosen_prompt, truncation=True, max_length=self.max_length, padding='max_length'
+        )
+        rejected_encoding = self.tokenizer(
+            rejected_prompt, truncation=True, max_length=self.max_length, padding='max_length'
+        )
+
+        chosen_input_ids = chosen_encoding['input_ids']
+        chosen_loss_mask = self.generate_loss_mask(chosen_input_ids)
+
+        rejected_input_ids = rejected_encoding['input_ids']
+        rejected_loss_mask = self.generate_loss_mask(rejected_input_ids)
+
+        # DPO 采用 next-token prediction 的输入-目标对齐方式
+        # x 为输入序列（去掉最后一个 token），y 为目标序列（去掉第一个 token）
+        # mask 对齐 y 的位置，用于在 DPO loss 中只计算 assistant 回答部分
+        x_chosen = torch.tensor(chosen_input_ids[:-1], dtype=torch.long)
+        y_chosen = torch.tensor(chosen_input_ids[1:], dtype=torch.long)
+        mask_chosen = torch.tensor(chosen_loss_mask[1:], dtype=torch.long)
+
+        x_rejected = torch.tensor(rejected_input_ids[:-1], dtype=torch.long)
+        y_rejected = torch.tensor(rejected_input_ids[1:], dtype=torch.long)
+        mask_rejected = torch.tensor(rejected_loss_mask[1:], dtype=torch.long)
+
+        return {
+            'x_chosen': x_chosen, 'y_chosen': y_chosen, 'mask_chosen': mask_chosen,
+            'x_rejected': x_rejected, 'y_rejected': y_rejected, 'mask_rejected': mask_rejected
+        }
+
+    def generate_loss_mask(self, input_ids):
+        """生成 loss 掩码：仅在 assistant 回答部分为 1"""
+        loss_mask = [0] * len(input_ids)
+        i = 0
+        while i < len(input_ids):
+            if input_ids[i:i + len(self.bos_id)] == self.bos_id:
+                start = i + len(self.bos_id)
+                end = start
+                while end < len(input_ids):
+                    if input_ids[end:end + len(self.eos_id)] == self.eos_id:
+                        break
+                    end += 1
+                for j in range(start, min(end + len(self.eos_id), self.max_length)):
+                    loss_mask[j] = 1
+                i = end + len(self.eos_id) if end < len(input_ids) else len(input_ids)
+            else:
+                i += 1
+        return loss_mask

package/shared/llm/logits_to_log_probs.py

@@ -0,0 +1,55 @@
+# logits_to_log_probs, dpo_loss 定义
+# 从文档自动提取生成
+
+import torch
+import torch.nn.functional as F
+
+def logits_to_log_probs(logits, labels):
+    """
+    从模型输出的 logits 计算每个 token 位置的对数概率
+
+    Args:
+        logits: 模型输出, shape [batch, seq_len, vocab_size]
+        labels: 目标 token ids, shape [batch, seq_len]
+
+    Returns:
+        每个位置的对数概率, shape [batch, seq_len]
+    """
+    log_probs = F.log_softmax(logits, dim=2)
+    log_probs_per_token = torch.gather(log_probs, dim=2, index=labels.unsqueeze(2)).squeeze(-1)
+    return log_probs_per_token
+
+
+def dpo_loss(ref_log_probs, policy_log_probs, mask, beta):
+    """
+    计算 DPO 损失
+
+    Args:
+        ref_log_probs: 参考模型的对数概率, shape [batch, seq_len]
+        policy_log_probs: 策略模型的对数概率, shape [batch, seq_len]
+        mask: loss 掩码, shape [batch, seq_len]
+        beta: DPO 温度参数
+
+    Returns:
+        标量损失值
+    """
+    # 沿序列求和（仅在 mask 为 1 的位置）
+    ref_log_probs = (ref_log_probs * mask).sum(dim=1)
+    policy_log_probs = (policy_log_probs * mask).sum(dim=1)
+
+    # 将 chosen 和 rejected 数据分开
+    # batch 中前半部分是 chosen，后半部分是 rejected
+    batch_size = ref_log_probs.shape[0]
+    chosen_ref_log_probs = ref_log_probs[:batch_size // 2]
+    reject_ref_log_probs = ref_log_probs[batch_size // 2:]
+    chosen_policy_log_probs = policy_log_probs[:batch_size // 2]
+    reject_policy_log_probs = policy_log_probs[batch_size // 2:]
+
+    # 计算隐式奖励差值
+    pi_logratios = chosen_policy_log_probs - reject_policy_log_probs
+    ref_logratios = chosen_ref_log_probs - reject_ref_log_probs
+    logits = pi_logratios - ref_logratios
+
+    # DPO 损失 = -log(sigmoid(beta * logits))
+    loss = -F.logsigmoid(beta * logits)
+    return loss.mean()

package/shared/llm/sftdataset.py

@@ -11,14 +11,15 @@ from torch.utils.data import Dataset
 
 class SFTDataset(Dataset):
     """
-    SFT 数据集：将对话数据 tokenize 为 next-token prediction 格式
+    SFT 数据集：将对话数据 tokenize 为 ChatML 格式
 
-    与 PretrainDataset 的核心差异：
+    与 PretrainDataset 的主要差异：
     - 数据格式从 {"text": "..."} 变为 {"conversations": [...]}
-    - 标签掩码：仅 assistant 回答部分参与 loss，其余标记为 -100
+    - 标签掩码：仅 assistant 回答部分参与 loss，其余标记为 -100（PyTorch CrossEntropyLoss 默认忽略 -100 对应的位置）
     - 使用 apply_chat_template 将对话转为 ChatML 格式
+    - SFT 数据集仍然支持工具调用训练，只要将训练集从 sft_t2t_tiny.jsonl 换回带有工具调用样例的 sft_t2t_mini.jsonl 即可
     """
-    # MiniMind 使用 ChatML 格式：<|im_start|>role\ncontent<|im_end|>\n
+    # 使用 ChatML 格式：<|im_start|>role\ncontent<|im_end|>\n
     # tokenizer 本身未内置 chat_template，需手动设置
     CHATML_TEMPLATE = (
         "{% for message in messages %}<|im_start|>{{ message.role }}\n"
@@ -31,7 +32,7 @@ class SFTDataset(Dataset):
         super().__init__()
         os.environ["TOKENIZERS_PARALLELISM"] = "false"
         self.tokenizer = tokenizer
-        # MiniMind tokenizer 未内置 chat_template，需手动设置 ChatML 格式
+        # Tokenizer 未内置 chat_template，需手动设置 ChatML 格式
         if not tokenizer.chat_template:
             tokenizer.chat_template = self.CHATML_TEMPLATE
         self.max_length = max_length
@@ -44,9 +45,11 @@ class SFTDataset(Dataset):
         datasets_logging.set_verbosity_error()
         self.samples = load_dataset('json', data_files=jsonl_path, split='train', features=features)
         datasets_logging.set_verbosity_warning()
-        # 预计算 assistant 回答的起止标记 ID
-        self.bos_id = tokenizer(f'{tokenizer.bos_token}assistant\n', add_special_tokens=False).input_ids
-        self.eos_id = tokenizer(f'{tokenizer.eos_token}\n', add_special_tokens=False).input_ids
+        # 预计算 assistant 回答的起止 token ID
+        # 即 <|im_start|>assistant\n 对应的 token ID 序列，用于定位助手回答的起始位置
+        self.bos_id = tokenizer(f'{tokenizer.bos_token}assistant\n', add_special_tokens=False).input_ids  
+        # 即 <|im_end|>\n 对应的 token ID 序列，用于定位助手回答的结束位置
+        self.eos_id = tokenizer(f'{tokenizer.eos_token}\n', add_special_tokens=False).input_ids  
 
     def __len__(self):
         return len(self.samples)
@@ -94,7 +97,8 @@ class SFTDataset(Dataset):
         prompt = self.create_chat_prompt(conversations)
         input_ids = self.tokenizer(prompt).input_ids[:self.max_length]
         # 填充到固定长度
-        input_ids += [self.tokenizer.pad_token_id] * (self.max_length - len(input_ids))
+        # 右侧填充至固定长度，填充部分的标签已由 generate_labels 设为 -100，不参与 loss
+        input_ids += [self.tokenizer.pad_token_id] * (self.max_length - len(input_ids))  
         labels = self.generate_labels(input_ids)
         return torch.tensor(input_ids, dtype=torch.long), torch.tensor(labels, dtype=torch.long)
 

package/src/commands/data.js

@@ -83,10 +83,19 @@ const DATASETS = [
     id: 'minimind-sft',
     name: 'MiniMind SFT (LLM监督微调语料)',
     url: 'https://www.modelscope.cn/datasets/icyfenix/Minimind_SFT.git',
-    size: '~1.7GB',
+    size: '~90MB',
     format: 'git',
     targetDir: 'datasets/minimind-sft',
     source: 'ModelScope (icyfenix)'
+  },
+  {
+    id: 'minimind-alignment',
+    name: 'MiniMind Alignment (LLM对齐语料)',
+    url: 'https://www.modelscope.cn/datasets/icyfenix/Minimind_Alignment.git',
+    size: '~54MB',
+    format: 'git',
+    targetDir: 'datasets/minimind-alignment',
+    source: 'ModelScope (icyfenix)'
   }
 ]
 
@@ -95,9 +104,11 @@ const DATASETS = [
  * enquirer 可能抛出空字符串错误或包含 'cancel' 的消息
  */
 function isUserCancel(error) {
-  return !error.message ||
+  return !error ||
+         !error.message ||
          error.message === '' ||
-         error.message.includes('cancel')
+         error.message.includes('cancel') ||
+         error.code === 'ERR_USE_AFTER_CLOSE'
 }
 
 /**
@@ -1049,6 +1060,19 @@ async function downloadDataset(dataPath, dataset) {
 export async function runDataTUI() {
   showBanner()
 
+  // 处理 enquirer 在 Ctrl+C 时抛出的 ERR_USE_AFTER_CLOSE
+  // enquirer 的 cancel() 方法关闭 readline 后又调用 pause()，导致此错误
+  const handleUncaught = (err) => {
+    if (err.code === 'ERR_USE_AFTER_CLOSE') {
+      console.log()
+      console.log(chalk.gray('已退出数据管理'))
+      console.log()
+      process.exit(0)
+    }
+    throw err
+  }
+  process.on('uncaughtException', handleUncaught)
+
   let dataPath = getDataVolumePath()
 
   // 确保配置目录存在
@@ -1152,6 +1176,7 @@ export async function runDataTUI() {
           console.log()
           console.log(chalk.gray('已退出数据管理'))
           console.log()
+          process.off('uncaughtException', handleUncaught)
           return
       }
 
@@ -1163,6 +1188,7 @@ export async function runDataTUI() {
         console.log()
         console.log(chalk.gray('已退出数据管理'))
         console.log()
+        process.off('uncaughtException', handleUncaught)
         return
       }
       throw error

package/src/server/kernel_runner.py

@@ -306,10 +306,45 @@ matplotlib.use('module://matplotlib_inline.backend_inline')
 
             # 处理不同类型的输出
             if msg_type == 'stream':
+                stream_name = content.get('name', 'stdout')
+                stream_text = content.get('text', '')
+
+                # 从 stderr 中提取 ProgressReporter 的 progress JSON，
+                # 作为独立的 progress 类型消息发送，避免与普通 stderr 输出混合
+                if stream_name == 'stderr':
+                    progress_lines = []
+                    other_lines = []
+                    for line in stream_text.split('\n'):
+                        if line.startswith('{"type": "progress"') or line.startswith('{"type":"progress"'):
+                            progress_lines.append(line)
+                        else:
+                            other_lines.append(line)
+
+                    # 将 progress JSON 作为独立消息发送（字段展开到顶层，与前端 progress case 匹配）
+                    for pline in progress_lines:
+                        if not pline.strip():
+                            continue
+                        try:
+                            import json as _json
+                            progress_data = _json.loads(pline)
+                            progress_data['type'] = 'progress'
+                            if stream:
+                                output_json(progress_data)
+                            else:
+                                outputs.append(progress_data)
+                        except Exception:
+                            # JSON 解析失败，作为普通文本处理
+                            other_lines.append(pline)
+
+                    # 剩余 stderr 内容正常传递
+                    stream_text = '\n'.join(other_lines)
+                    if not stream_text.strip():
+                        continue
+
                 stream_output = {
                     'type': 'stream',
-                    'name': content.get('name', 'stdout'),
-                    'text': content.get('text', '')
+                    'name': stream_name,
+                    'text': stream_text
                 }
 
                 if stream:
@@ -317,7 +352,7 @@ matplotlib.use('module://matplotlib_inline.backend_inline')
                     output_json(stream_output)
                 else:
                     outputs.append(stream_output)
-                log_debug(f'Stream output: {content.get("name")} len={len(content.get("text", ""))}')
+                log_debug(f'Stream output: {stream_name} len={len(stream_text)}')
 
             elif msg_type == 'display_data':
                 display_output = {

package/src/server/sandbox.js

@@ -982,10 +982,11 @@ export async function runPythonCodeStreaming(code, useGpu = false, res, imageOve
               if (isJsonComplete(text)) {
                 log(`Forwarding complete JSON message: ${text.length} bytes`)
                 res.write(text + '\n')
-                // chat 模式：检测 idle 消息，设置 ChatManager 就绪
+                // chat 模式：将消息转发给 ChatManager 处理
                 if (mode === 'chat') {
                   try {
                     const msg = JSON.parse(text)
+                    chatManager.handleDockerStream(Buffer.from(text + '\n'))
                     if (msg.type === 'idle') {
                       chatManager.setReady(true)
                       log('ChatManager ready (idle message received)')

package/version.json

@@ -1,4 +1,4 @@
 {
-  "buildTime": "2026-05-29T12:19:03.854Z",
-  "cliVersion": "2026.5.29-2018"
+  "buildTime": "2026-06-05T12:04:28.715Z",
+  "cliVersion": "2026.6.5-1204"
 }