@icyfenix-dmla/cli 2026.5.14-2 → 2026.5.24-16

package/package.json

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

package/shared/__init__.py

@@ -1,19 +1,9 @@
 # shared 模块包初始化
 # 包含统计学习系列文档中可复用的类定义
 #
-# 注意：不在此处自动导入子模块，避免加载不必要的依赖
-# 使用时请直接导入需要的模块，例如：
-#   from shared.sequence_models.poetry_lstm import PoetryLSTM
-#   from shared.linear.logistic_regression import LogisticRegression
+# 使用方式：显式导入需要的模块
+#   from shared.sequence_models import PoetryLSTM, PoetryDataset
+#   from shared.cnn import AlexNet
+#   from shared.linear import LogisticRegression
 
-__all__ = [
-    'bayesian',
-    'cnn',
-    'gan',
-    'linear',
-    'neural',
-    'sequence_models',
-    'svm',
-    'tree',
-    'unsupervised',
-]
+__all__ = ['bayesian', 'cnn', 'gan', 'linear', 'llm', 'neural', 'sequence_models', 'svm', 'tree', 'unsupervised']

package/shared/bayesian/gaussian_mixture_model.py

@@ -1,6 +1,7 @@
-# GaussianMixtureModel 类定义
+# GaussianMixtureModel 定义
 # 从文档自动提取生成
 
+import matplotlib.pyplot as plt
 import numpy as np
 
 class GaussianMixtureModel:

package/shared/bayesian/multinomial_naive_bayes.py

@@ -1,6 +1,7 @@
-# MultinomialNaiveBayes 类定义
+# MultinomialNaiveBayes 定义
 # 从文档自动提取生成
 
+import matplotlib.pyplot as plt
 import numpy as np
 
 class MultinomialNaiveBayes:

package/shared/bayesian/simple_bayesian_network.py

@@ -1,6 +1,8 @@
-# SimpleBayesianNetwork 类定义
+# SimpleBayesianNetwork 定义
 # 从文档自动提取生成
 
+import matplotlib.pyplot as plt
+
 class SimpleBayesianNetwork:
     """
     简单贝叶斯网络实现

package/shared/cnn/__init__.py

@@ -1,11 +1,15 @@
 # CNN 模块
 from .alexnet import AlexNet
-from .lmdb_dataset import LMDBDataset
-from .lmdb_dataset import LMDBValDataset
-from .lmdbpreprocess_cache import LMDBPreprocessCache
+try:
+    from .lmdb_dataset import LMDBDataset, LMDBValDataset
+except ImportError:
+    pass  # 可选依赖 lmdb 未安装
+try:
+    from .lmdbpreprocess_cache import LMDBPreprocessCache
+except ImportError:
+    pass  # 可选依赖 lmdb 未安装
 from .minimal_preprocess_cache import MinimalPreprocessCache
-from .realtime_dataset import RealtimeAugmentDataset
-from .realtime_dataset import RealtimeValDataset
+from .realtime_dataset import RealtimeAugmentDataset, RealtimeValDataset, _get_perf_log
 from .tiny_imagenet_dataset import TinyImageNetDataset
 
-__all__ = ['AlexNet', 'LMDBDataset', 'LMDBValDataset', 'LMDBPreprocessCache', 'MinimalPreprocessCache', 'RealtimeAugmentDataset', 'RealtimeValDataset', 'TinyImageNetDataset']
+__all__ = ['AlexNet', 'LMDBDataset', 'LMDBValDataset', 'LMDBPreprocessCache', 'MinimalPreprocessCache', 'RealtimeAugmentDataset', 'RealtimeValDataset', '_get_perf_log', 'TinyImageNetDataset']

package/shared/cnn/alexnet.py

@@ -1,4 +1,4 @@
-# AlexNet 类定义
+# AlexNet 定义
 # 从文档自动提取生成
 
 import torch

package/shared/cnn/lmdbpreprocess_cache.py

@@ -1,7 +1,9 @@
-# LMDBPreprocessCache 类定义
+# LMDBPreprocessCache 定义
 # 从文档自动提取生成
 
+import json
 import os
+from dmla_progress import ProgressReporter
 from PIL import Image
 
 class LMDBPreprocessCache:

package/shared/gan/dcgan_generator.py

@@ -1,4 +1,4 @@
-# DCGANGenerator 类定义
+# DCGANGenerator 定义
 # 从文档自动提取生成
 
 import torch

package/shared/gan/image_vae.py

@@ -1,8 +1,15 @@
-# ImageVAE 类定义
+# ImageVAE 定义
 # 从文档自动提取生成
 
+import gzip
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+import struct
 import torch
 import torch.nn as nn
+import torch.nn.functional as F
+from dmla_progress import ProgressReporter
 from PIL import Image
 
 class ImageVAE(nn.Module):

package/shared/linear/__init__.py

@@ -1,8 +1,7 @@
 # LINEAR 模块
 from .lasso_regression import LassoRegression
 from .logistic_regression import LogisticRegression
-from .naive_bayes import MultinomialNaiveBayes
-from .naive_bayes import GaussianNaiveBayes
+from .naive_bayes import MultinomialNaiveBayes, GaussianNaiveBayes
 from .ridge_regression import RidgeRegression
 
 __all__ = ['LassoRegression', 'LogisticRegression', 'MultinomialNaiveBayes', 'GaussianNaiveBayes', 'RidgeRegression']

package/shared/linear/lasso_regression.py

@@ -1,4 +1,4 @@
-# LassoRegression 类定义
+# LassoRegression 定义
 # 从文档自动提取生成
 
 import numpy as np

package/shared/linear/logistic_regression.py

@@ -1,6 +1,7 @@
-# LogisticRegression 类定义
+# LogisticRegression 定义
 # 从文档自动提取生成
 
+import matplotlib.pyplot as plt
 import numpy as np
 
 class LogisticRegression:

package/shared/linear/ridge_regression.py

@@ -1,4 +1,4 @@
-# RidgeRegression 类定义
+# RidgeRegression 定义
 # 从文档自动提取生成
 
 import numpy as np

package/shared/llm/__init__.py

@@ -0,0 +1,5 @@
+# LLM 模块
+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
+
+__all__ = ['MiniMindConfig', 'RMSNorm', 'Attention', 'FeedForward', 'MiniMindBlock', 'MiniMindModel', 'MiniMindForCausalLM', 'precompute_freqs_cis', 'apply_rotary_pos_emb', 'repeat_kv', 'PretrainDataset']

package/shared/llm/mini_mind_config.py

@@ -0,0 +1,296 @@
+# MiniMindConfig, RMSNorm, precompute_freqs_cis, apply_rotary_pos_emb, repeat_kv, Attention, FeedForward, MiniMindBlock, MiniMindModel, MiniMindForCausalLM 定义
+# 从文档自动提取生成
+
+import math
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import PreTrainedModel, GenerationMixin, PretrainedConfig
+from transformers.activations import ACT2FN
+from transformers.modeling_outputs import MoeCausalLMOutputWithPast
+from typing import Optional, Tuple, List, Dict
+
+class MiniMindConfig(PretrainedConfig):
+    """MiniMind 模型配置"""
+    model_type = "minimind"
+    def __init__(self, hidden_size=768, num_hidden_layers=8, use_moe=False, **kwargs):
+        super().__init__(**kwargs)
+        self.hidden_size = hidden_size
+        self.num_hidden_layers = num_hidden_layers
+        self.use_moe = use_moe
+        self.dropout = kwargs.get("dropout", 0.0)
+        self.vocab_size = kwargs.get("vocab_size", 6400)
+        self.bos_token_id = kwargs.get("bos_token_id", 1)
+        self.eos_token_id = kwargs.get("eos_token_id", 2)
+        self.flash_attn = kwargs.get("flash_attn", True)
+        self.num_attention_heads = kwargs.get("num_attention_heads", 8)
+        self.num_key_value_heads = kwargs.get("num_key_value_heads", 4)
+        self.head_dim = kwargs.get("head_dim", self.hidden_size // self.num_attention_heads)
+        self.hidden_act = kwargs.get("hidden_act", 'silu')
+        self.intermediate_size = kwargs.get("intermediate_size", math.ceil(hidden_size * math.pi / 64) * 64)
+        self.max_position_embeddings = kwargs.get("max_position_embeddings", 32768)
+        self.rms_norm_eps = kwargs.get("rms_norm_eps", 1e-6)
+        self.rope_theta = kwargs.get("rope_theta", 1e6)
+        self.tie_word_embeddings = kwargs.get("tie_word_embeddings", True)
+        self.inference_rope_scaling = kwargs.get("inference_rope_scaling", False)
+        self.rope_scaling = {
+            "beta_fast": 32, "beta_slow": 1, "factor": 16,
+            "original_max_position_embeddings": 2048,
+            "attention_factor": 1.0, "type": "yarn"
+        } if self.inference_rope_scaling else None
+
+
+class RMSNorm(nn.Module):
+    """RMS 归一化：比 LayerNorm 更高效，省去均值计算"""
+    def __init__(self, dim, eps=1e-5):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(dim))
+
+    def norm(self, x):
+        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
+
+    def forward(self, x):
+        return (self.weight * self.norm(x.float())).type_as(x)
+
+
+def precompute_freqs_cis(dim, end=32768, rope_base=1e6, rope_scaling=None):
+    """预计算 RoPE 旋转位置编码的 cos 和 sin 值"""
+    freqs = 1.0 / (rope_base ** (torch.arange(0, dim, 2)[: (dim // 2)].float() / dim))
+    attn_factor = 1.0
+    if rope_scaling is not None:
+        orig_max = rope_scaling.get("original_max_position_embeddings", 2048)
+        factor = rope_scaling.get("factor", 16)
+        beta_fast = rope_scaling.get("beta_fast", 32.0)
+        beta_slow = rope_scaling.get("beta_slow", 1.0)
+        attn_factor = rope_scaling.get("attention_factor", 1.0)
+        if end / orig_max > 1.0:
+            inv_dim = lambda b: (dim * math.log(orig_max / (b * 2 * math.pi))) / (2 * math.log(rope_base))
+            low = max(math.floor(inv_dim(beta_fast)), 0)
+            high = min(math.ceil(inv_dim(beta_slow)), dim // 2 - 1)
+            ramp = torch.clamp((torch.arange(dim // 2, device=freqs.device).float() - low) / max(high - low, 0.001), 0, 1)
+            freqs = freqs * (1 - ramp + ramp / factor)
+    t = torch.arange(end, device=freqs.device)
+    freqs = torch.outer(t, freqs).float()
+    freqs_cos = torch.cat([torch.cos(freqs), torch.cos(freqs)], dim=-1) * attn_factor
+    freqs_sin = torch.cat([torch.sin(freqs), torch.sin(freqs)], dim=-1) * attn_factor
+    return freqs_cos, freqs_sin
+
+
+def apply_rotary_pos_emb(q, k, cos, sin, unsqueeze_dim=1):
+    """应用旋转位置编码到查询和键"""
+    def rotate_half(x):
+        return torch.cat((-x[..., x.shape[-1] // 2:], x[..., : x.shape[-1] // 2]), dim=-1)
+    q_embed = ((q * cos.unsqueeze(unsqueeze_dim)) + (rotate_half(q) * sin.unsqueeze(unsqueeze_dim))).to(q.dtype)
+    k_embed = ((k * cos.unsqueeze(unsqueeze_dim)) + (rotate_half(k) * sin.unsqueeze(unsqueeze_dim))).to(k.dtype)
+    return q_embed, k_embed
+
+
+def repeat_kv(x, n_rep):
+    """重复 KV 头以匹配查询头数（GQA 推理时使用）"""
+    bs, slen, num_kv_heads, head_dim = x.shape
+    if n_rep == 1:
+        return x
+    return x[:, :, :, None, :].expand(bs, slen, num_kv_heads, n_rep, head_dim).reshape(bs, slen, num_kv_heads * n_rep, head_dim)
+
+
+class Attention(nn.Module):
+    """GQA 分组查询注意力"""
+    def __init__(self, config):
+        super().__init__()
+        self.num_key_value_heads = config.num_attention_heads if config.num_key_value_heads is None else config.num_key_value_heads
+        self.n_local_heads = config.num_attention_heads
+        self.n_local_kv_heads = self.num_key_value_heads
+        self.n_rep = self.n_local_heads // self.n_local_kv_heads
+        self.head_dim = config.head_dim
+        self.is_causal = True
+        self.q_proj = nn.Linear(config.hidden_size, config.num_attention_heads * self.head_dim, bias=False)
+        self.k_proj = nn.Linear(config.hidden_size, self.num_key_value_heads * self.head_dim, bias=False)
+        self.v_proj = nn.Linear(config.hidden_size, self.num_key_value_heads * self.head_dim, bias=False)
+        self.o_proj = nn.Linear(config.num_attention_heads * self.head_dim, config.hidden_size, bias=False)
+        self.q_norm = RMSNorm(self.head_dim, eps=config.rms_norm_eps)
+        self.k_norm = RMSNorm(self.head_dim, eps=config.rms_norm_eps)
+        self.attn_dropout = nn.Dropout(config.dropout)
+        self.resid_dropout = nn.Dropout(config.dropout)
+        self.dropout = config.dropout
+        self.flash = hasattr(torch.nn.functional, 'scaled_dot_product_attention') and config.flash_attn
+
+    def forward(self, x, position_embeddings, past_key_value=None, use_cache=False, attention_mask=None):
+        bsz, seq_len, _ = x.shape
+        xq, xk, xv = self.q_proj(x), self.k_proj(x), self.v_proj(x)
+        xq = xq.view(bsz, seq_len, self.n_local_heads, self.head_dim)
+        xk = xk.view(bsz, seq_len, self.n_local_kv_heads, self.head_dim)
+        xv = xv.view(bsz, seq_len, self.n_local_kv_heads, self.head_dim)
+        # QK-Norm：对查询和键做 RMS 归一化，提升训练稳定性
+        xq, xk = self.q_norm(xq), self.k_norm(xk)
+        cos, sin = position_embeddings
+        xq, xk = apply_rotary_pos_emb(xq, xk, cos, sin)
+        # KV Cache：推理时拼接历史 KV
+        if past_key_value is not None:
+            xk = torch.cat([past_key_value[0], xk], dim=1)
+            xv = torch.cat([past_key_value[1], xv], dim=1)
+        past_kv = (xk, xv) if use_cache else None
+        xq, xk, xv = (xq.transpose(1, 2), repeat_kv(xk, self.n_rep).transpose(1, 2), repeat_kv(xv, self.n_rep).transpose(1, 2))
+        # 优先使用 Flash Attention（GPU 上更快更省显存）
+        if self.flash and (seq_len > 1) and (not self.is_causal or past_key_value is None) and (attention_mask is None or torch.all(attention_mask == 1)):
+            output = F.scaled_dot_product_attention(xq, xk, xv, dropout_p=self.dropout if self.training else 0.0, is_causal=self.is_causal)
+        else:
+            scores = (xq @ xk.transpose(-2, -1)) / math.sqrt(self.head_dim)
+            if self.is_causal:
+                scores[:, :, :, -seq_len:] += torch.full((seq_len, seq_len), float("-inf"), device=scores.device).triu(1)
+            if attention_mask is not None:
+                scores += (1.0 - attention_mask.unsqueeze(1).unsqueeze(2)) * -1e9
+            output = self.attn_dropout(F.softmax(scores.float(), dim=-1).type_as(xq)) @ xv
+        output = output.transpose(1, 2).reshape(bsz, seq_len, -1)
+        output = self.resid_dropout(self.o_proj(output))
+        return output, past_kv
+
+
+class FeedForward(nn.Module):
+    """SwiGLU 前馈网络：gate 和 up 两条路径，门控选择信息通道"""
+    def __init__(self, config, intermediate_size=None):
+        super().__init__()
+        intermediate_size = intermediate_size or config.intermediate_size
+        self.gate_proj = nn.Linear(config.hidden_size, intermediate_size, bias=False)
+        self.down_proj = nn.Linear(intermediate_size, config.hidden_size, bias=False)
+        self.up_proj = nn.Linear(config.hidden_size, intermediate_size, bias=False)
+        self.act_fn = ACT2FN[config.hidden_act]
+
+    def forward(self, x):
+        return self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
+
+
+class MiniMindBlock(nn.Module):
+    """单个 Transformer 层：Pre-Norm + Attention + FFN"""
+    def __init__(self, layer_id, config):
+        super().__init__()
+        self.self_attn = Attention(config)
+        self.input_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+        self.post_attention_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+        self.mlp = FeedForward(config)
+
+    def forward(self, hidden_states, position_embeddings, past_key_value=None, use_cache=False, attention_mask=None):
+        residual = hidden_states
+        hidden_states, present_key_value = self.self_attn(
+            self.input_layernorm(hidden_states), position_embeddings,
+            past_key_value, use_cache, attention_mask
+        )
+        hidden_states += residual
+        hidden_states = hidden_states + self.mlp(self.post_attention_layernorm(hidden_states))
+        return hidden_states, present_key_value
+
+
+class MiniMindModel(nn.Module):
+    """MiniMind 主体：词嵌入 + 多层 Transformer + 最终归一化"""
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.vocab_size = config.vocab_size
+        self.num_hidden_layers = config.num_hidden_layers
+        self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size)
+        self.dropout = nn.Dropout(config.dropout)
+        self.layers = nn.ModuleList([MiniMindBlock(l, config) for l in range(self.num_hidden_layers)])
+        self.norm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+        # 预计算 RoPE 的 cos/sin 缓冲区
+        freqs_cos, freqs_sin = precompute_freqs_cis(
+            dim=config.head_dim, end=config.max_position_embeddings,
+            rope_base=config.rope_theta, rope_scaling=config.rope_scaling
+        )
+        self.register_buffer("freqs_cos", freqs_cos, persistent=False)
+        self.register_buffer("freqs_sin", freqs_sin, persistent=False)
+
+    def forward(self, input_ids, attention_mask=None, past_key_values=None, use_cache=False, **kwargs):
+        batch_size, seq_length = input_ids.shape
+        if hasattr(past_key_values, 'layers'):
+            past_key_values = None
+        past_key_values = past_key_values or [None] * len(self.layers)
+        start_pos = past_key_values[0][0].shape[1] if past_key_values[0] is not None else 0
+        hidden_states = self.dropout(self.embed_tokens(input_ids))
+        # 重新计算可能因 meta device 丢失的 RoPE 缓冲区
+        if self.freqs_cos[0, 0] == 0:
+            freqs_cos, freqs_sin = precompute_freqs_cis(
+                dim=self.config.head_dim, end=self.config.max_position_embeddings,
+                rope_base=self.config.rope_theta, rope_scaling=self.config.rope_scaling
+            )
+            self.freqs_cos, self.freqs_sin = freqs_cos.to(hidden_states.device), freqs_sin.to(hidden_states.device)
+        position_embeddings = (self.freqs_cos[start_pos:start_pos + seq_length], self.freqs_sin[start_pos:start_pos + seq_length])
+        presents = []
+        for layer, past_key_value in zip(self.layers, past_key_values):
+            hidden_states, present = layer(
+                hidden_states, position_embeddings,
+                past_key_value=past_key_value, use_cache=use_cache,
+                attention_mask=attention_mask
+            )
+            presents.append(present)
+        hidden_states = self.norm(hidden_states)
+        return hidden_states, presents, hidden_states.new_zeros(1).squeeze()
+
+
+class MiniMindForCausalLM(PreTrainedModel, GenerationMixin):
+    """MiniMind 因果语言模型：用于预训练和推理"""
+    config_class = MiniMindConfig
+    _tied_weights_keys = {"lm_head.weight": "model.embed_tokens.weight"}
+    def __init__(self, config=None):
+        self.config = config or MiniMindConfig()
+        super().__init__(self.config)
+        self.model = MiniMindModel(self.config)
+        self.lm_head = nn.Linear(self.config.hidden_size, self.config.vocab_size, bias=False)
+        if self.config.tie_word_embeddings:
+            self.model.embed_tokens.weight = self.lm_head.weight
+        self.post_init()
+
+    def forward(self, input_ids, attention_mask=None, past_key_values=None, use_cache=False, logits_to_keep=0, labels=None, **kwargs):
+        hidden_states, past_key_values, aux_loss = self.model(input_ids, attention_mask, past_key_values, use_cache, **kwargs)
+        slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep
+        logits = self.lm_head(hidden_states[:, slice_indices, :])
+        loss = None
+        if labels is not None:
+            x, y = logits[..., :-1, :].contiguous(), labels[..., 1:].contiguous()
+            loss = F.cross_entropy(x.view(-1, x.size(-1)), y.view(-1), ignore_index=-100)
+        return MoeCausalLMOutputWithPast(loss=loss, aux_loss=aux_loss, logits=logits, past_key_values=past_key_values, hidden_states=hidden_states)
+
+    @torch.inference_mode()
+    def generate(self, inputs=None, attention_mask=None, max_new_tokens=512, temperature=0.85, top_p=0.85, top_k=50, eos_token_id=2, streamer=None, use_cache=True, num_return_sequences=1, do_sample=True, repetition_penalty=1.0, **kwargs):
+        """自回归生成：逐 token 采样，支持 top-k、top-p、重复惩罚"""
+        input_ids = kwargs.pop("input_ids", inputs).repeat(num_return_sequences, 1)
+        attention_mask = attention_mask.repeat(num_return_sequences, 1) if attention_mask is not None else None
+        past_key_values = kwargs.pop("past_key_values", None)
+        finished = torch.zeros(input_ids.shape[0], dtype=torch.bool, device=input_ids.device)
+        if streamer:
+            streamer.put(input_ids.cpu())
+        for _ in range(max_new_tokens):
+            past_len = past_key_values[0][0].shape[1] if past_key_values else 0
+            outputs = self.forward(input_ids[:, past_len:], attention_mask, past_key_values, use_cache=use_cache, **kwargs)
+            attention_mask = torch.cat([attention_mask, attention_mask.new_ones(attention_mask.shape[0], 1)], -1) if attention_mask is not None else None
+            logits = outputs.logits[:, -1, :] / temperature
+            # 重复惩罚：降低已出现 token 的概率
+            if repetition_penalty != 1.0:
+                for i in range(input_ids.shape[0]):
+                    seen = torch.unique(input_ids[i])
+                    score = logits[i, seen]
+                    logits[i, seen] = torch.where(score > 0, score / repetition_penalty, score * repetition_penalty)
+            # Top-k 过滤
+            if top_k > 0:
+                logits[logits < torch.topk(logits, top_k)[0][..., -1, None]] = -float('inf')
+            # Top-p（nucleus）过滤
+            if top_p < 1.0:
+                sorted_logits, sorted_indices = torch.sort(logits, descending=True)
+                mask = torch.cumsum(torch.softmax(sorted_logits, dim=-1), dim=-1) > top_p
+                mask[..., 1:], mask[..., 0] = mask[..., :-1].clone(), 0
+                logits[mask.scatter(1, sorted_indices, mask)] = -float('inf')
+            # 采样或贪心选择
+            next_token = torch.multinomial(torch.softmax(logits, dim=-1), num_samples=1) if do_sample else torch.argmax(logits, dim=-1, keepdim=True)
+            if eos_token_id is not None:
+                next_token = torch.where(finished.unsqueeze(-1), next_token.new_full((next_token.shape[0], 1), eos_token_id), next_token)
+            input_ids = torch.cat([input_ids, next_token], dim=-1)
+            past_key_values = outputs.past_key_values if use_cache else None
+            if streamer:
+                streamer.put(next_token.cpu())
+            if eos_token_id is not None:
+                finished |= next_token.squeeze(-1).eq(eos_token_id)
+                if finished.all():
+                    break
+        if streamer:
+            streamer.end()
+        return input_ids

package/shared/llm/pretrain_dataset.py

@@ -0,0 +1,55 @@
+# PretrainDataset 定义
+# 从文档自动提取生成
+
+import json
+import torch
+from torch.utils.data import Dataset
+
+class PretrainDataset(Dataset):
+    """
+    预训练数据集：从 JSONL 文件加载文本，tokenize 为 next-token prediction 格式
+    
+    每条样本格式：{"text": "一段文本"}
+    输出：(input_ids, labels)，其中 labels 是 input_ids 的右移一位版本，
+    用于计算 next-token prediction 的交叉熵损失
+    """
+    def __init__(self, data_path, tokenizer, max_length=512):
+        super().__init__()
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+        # 预读取所有样本的文本
+        self.samples = []
+        with open(data_path, 'r', encoding='utf-8') as f:
+            for line in f:
+                try:
+                    data = json.loads(line.strip())
+                    if 'text' in data and data['text'].strip():
+                        self.samples.append(data['text'])
+                except json.JSONDecodeError:
+                    continue
+    
+    def __len__(self):
+        return len(self.samples)
+    
+    def __getitem__(self, index):
+        text = self.samples[index]
+        # tokenize：截断到 max_length - 2（预留 BOS 和 EOS 的位置）
+        tokens = self.tokenizer(
+            str(text), 
+            add_special_tokens=False, 
+            max_length=self.max_length - 2, 
+            truncation=True
+        ).input_ids
+        
+        # 添加 BOS 和 EOS 标记
+        tokens = [self.tokenizer.bos_token_id] + tokens + [self.tokenizer.eos_token_id]
+        
+        # 填充到固定长度
+        input_ids = tokens + [self.tokenizer.pad_token_id] * (self.max_length - len(tokens))
+        input_ids = torch.tensor(input_ids, dtype=torch.long)
+        
+        # 标签与输入相同，填充位置标记为 -100（交叉熵损失忽略）
+        labels = input_ids.clone()
+        labels[input_ids == self.tokenizer.pad_token_id] = -100
+        
+        return input_ids, labels

package/shared/neural/perceptron.py

@@ -1,6 +1,7 @@
-# Perceptron 类定义
+# Perceptron 定义
 # 从文档自动提取生成
 
+import matplotlib.pyplot as plt
 import numpy as np
 
 class Perceptron:

package/shared/sequence_models/__init__.py

@@ -1,4 +1,5 @@
 # SEQUENCE_MODELS 模块
+from .poetry_dataset import PoetryDataset
 from .poetry_lstm import PoetryLSTM
 
-__all__ = ['PoetryLSTM']
+__all__ = ['PoetryDataset', 'PoetryLSTM']

package/shared/sequence_models/poetry_dataset.py

@@ -0,0 +1,132 @@
+# PoetryDataset 定义
+# 从文档自动提取生成
+
+import json
+import os
+import re
+from collections import Counter, defaultdict, deque
+from torch.utils.data import Dataset, DataLoader
+
+class PoetryDataset:
+    """古诗词数据集（字符级语言模型）
+
+    从 chinese-poetry 数据集加载诗词，构建字符级词汇表，
+    将诗词文本转换为数值序列用于 LSTM 训练。
+    """
+    def __init__(self, data_dir, min_length=10, max_length=100, vocab_size=4000):
+        self.min_length = min_length
+        self.max_length = max_length
+        self.vocab_size = vocab_size
+
+        # 加载诗词文本
+        self.poems = self._load_poems(data_dir)
+        print(f"加载完成: {len(self.poems)} 首诗词")
+
+        # 构建词汇表
+        self.char2idx, self.idx2char = self._build_vocab()
+        print(f"词汇表大小: {len(self.char2idx)}")
+
+        # 将诗词转换为序列
+        self.sequences = self._encode_poems()
+        print(f"有效序列数: {len(self.sequences)}")
+
+    def _load_poems(self, data_dir):
+        """加载诗词数据"""
+        poems = []
+
+        # 定义要加载的数据集
+        datasets = ['全唐诗', '宋词', '诗经', '楚辞']
+
+        for dataset in datasets:
+            dataset_path = os.path.join(data_dir, dataset)
+            if not os.path.exists(dataset_path):
+                continue
+
+            json_files = [f for f in os.listdir(dataset_path) if f.endswith('.json')]
+
+            for jf in json_files:
+                file_path = os.path.join(dataset_path, jf)
+                try:
+                    with open(file_path, 'r', encoding='utf-8') as f:
+                        data = json.load(f)
+
+                    for poem in data:
+                        # 提取诗词正文
+                        text = self._extract_text(poem)
+                        if text and self._is_valid(text):
+                            poems.append(text)
+                except Exception as e:
+                    print(f"加载 {jf} 失败: {e}")
+
+        return poems
+
+    def _extract_text(self, poem):
+        """从诗词数据中提取正文"""
+        # 尝试不同的字段名
+        if 'text' in poem:
+            text = poem['text']
+        elif 'paragraphs' in poem:
+            text = ''.join(poem['paragraphs'])
+        elif 'content' in poem:
+            # content 可能是字符串或列表
+            content = poem['content']
+            if isinstance(content, list):
+                text = ''.join(content)
+            else:
+                text = content
+        else:
+            return None
+
+        # 清理文本：去除标点符号，只保留汉字
+        # 保留常用标点用于断句
+        text = re.sub(r'[^一-龥，。！？、；：""''（）]', '', text)
+
+        return text
+
+    def _is_valid(self, text):
+        """检查文本是否有效"""
+        # 长度检查
+        if len(text) < self.min_length or len(text) > self.max_length:
+            return False
+
+        # 过滤包含缺字标记的诗句
+        if '□' in text or '■' in text:
+            return False
+
+        return True
+
+    def _build_vocab(self):
+        """构建字符级词汇表"""
+        # 统计字符频率
+        char_counter = Counter()
+        for poem in self.poems:
+            char_counter.update(poem)
+
+        # 选择高频字符
+        most_common = char_counter.most_common(self.vocab_size - 2)  # 预留两个位置给特殊标记
+
+        # 构建映射
+        char2idx = {'<PAD>': 0, '<UNK>': 1}
+        for i, (char, _) in enumerate(most_common, start=2):
+            char2idx[char] = i
+
+        idx2char = {idx: char for char, idx in char2idx.items()}
+
+        return char2idx, idx2char
+
+    def _encode_poems(self):
+        """将诗词转换为数值序列"""
+        sequences = []
+        for poem in self.poems:
+            seq = [self.char2idx.get(c, self.char2idx['<UNK>']) for c in poem]
+            sequences.append(seq)
+        return sequences
+
+    def __len__(self):
+        return len(self.sequences)
+
+    def __getitem__(self, idx):
+        seq = self.sequences[idx]
+        # 输入序列：去掉最后一个字符
+        # 目标序列：去掉第一个字符
+        return seq[:-1], seq[1:]

package/shared/sequence_models/poetry_lstm.py

@@ -1,4 +1,4 @@
-# PoetryLSTM 类定义
+# PoetryLSTM 定义
 # 从文档自动提取生成
 
 import torch

package/shared/svm/kernel_svm.py

@@ -1,4 +1,4 @@
-# KernelSVM 类定义
+# KernelSVM 定义
 # 从文档自动提取生成
 
 import numpy as np

package/shared/svm/simple_svm.py

@@ -1,4 +1,4 @@
-# SimpleSVM 类定义
+# SimpleSVM 定义
 # 从文档自动提取生成
 
 import numpy as np

package/shared/tree/ada_boost.py

@@ -1,4 +1,4 @@
-# AdaBoost 类定义
+# AdaBoost 定义
 # 从文档自动提取生成
 
 import numpy as np

package/shared/tree/decision_tree_classifier.py

@@ -1,7 +1,9 @@
-# DecisionTreeClassifier 类定义
+# DecisionTreeClassifier 定义
 # 从文档自动提取生成
 
+import matplotlib.pyplot as plt
 import numpy as np
+from sklearn.datasets import load_iris
 
 class DecisionTreeClassifier:
     """

package/shared/tree/random_forest_classifier.py

@@ -1,7 +1,9 @@
-# RandomForestClassifier 类定义
+# RandomForestClassifier 定义
 # 从文档自动提取生成
 
 import numpy as np
+from sklearn.datasets import load_digits
+from sklearn.model_selection import train_test_split
 
 class RandomForestClassifier:
     """

package/shared/unsupervised/kmeans.py

@@ -1,6 +1,7 @@
-# KMeans 类定义
+# KMeans 定义
 # 从文档自动提取生成
 
+import matplotlib.pyplot as plt
 import numpy as np
 
 class KMeans:

package/shared/unsupervised/pca.py

@@ -1,7 +1,8 @@
-# PCA 类定义
+# PCA 定义
 # 从文档自动提取生成
 
 import numpy as np
+from sklearn.datasets import load_iris
 
 class PCA:
     """

package/src/commands/data.js

@@ -70,6 +70,15 @@ const DATASETS = [
     format: 'git',
     targetDir: 'datasets/chinese-poetry',
     source: 'ModelScope (icyfenix)'
+  },
+  {
+    id: 'minimind-pretrain',
+    name: 'MiniMind Pretrain (LLM预训练语料)',
+    url: 'https://www.modelscope.cn/datasets/icyfenix/minimind_pretrain.git',
+    size: '~1.2GB',
+    format: 'git',
+    targetDir: 'datasets/minimind-pretrain',
+    source: 'ModelScope (icyfenix)'
   }
 ]
 

package/src/server/native_env_check.js

@@ -25,7 +25,10 @@ const SOFT_DEPS = [
   'jupyter_client',
   'ipykernel',
   'lmdb',
-  'requests'
+  'requests',
+  'transformers',
+  'tokenizers',
+  'datasets'
 ]
 
 // 环境检测结果缓存

package/version.json

@@ -1,4 +1,4 @@
 {
-  "buildTime": "2026-05-13T16:02:49.085Z",
-  "cliVersion": "2026.5.14-2"
+  "buildTime": "2026-05-23T16:41:15.404Z",
+  "cliVersion": "2026.5.24-16"
 }