@icyfenix-dmla/cli 2026.5.13-2349 → 2026.5.14-2

package/package.json

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

package/src/commands/server.js

@@ -369,12 +369,12 @@ function findProgressReporterPath() {
  * --dev 模式下需要挂载此目录
  */
 function findSharedModulesPath() {
-  // 开发环境路径：packages/cli/src/commands -> ../../../local-server/shared_modules
-  const devPath = path.resolve(__dirname, '../../../local-server/shared_modules')
-  // npm 包路径：packages/cli/src/commands -> ../../shared_modules（构建后）
-  const npmPath = path.resolve(__dirname, '../../shared_modules')
-  // CLI 包根目录下的 shared_modules（构建后）
-  const cliRootPath = path.resolve(__dirname, '../../shared_modules')
+  // 开发环境路径：packages/cli/src/commands -> ../../../local-server/shared
+  const devPath = path.resolve(__dirname, '../../../local-server/shared')
+  // npm 包路径：packages/cli/src/commands -> ../../shared（构建后）
+  const npmPath = path.resolve(__dirname, '../../shared')
+  // CLI 包根目录下的 shared（构建后）
+  const cliRootPath = path.resolve(__dirname, '../../shared')
 
   // 优先使用开发环境路径（如果 local-server 存在）
   if (fs.existsSync(devPath) && fs.readdirSync(devPath).length > 0) {
@@ -473,7 +473,7 @@ export async function startServerSync(port, useGpu = false, dev = false, shmSize
 
   if (dev && !sharedModulesPath) {
     console.log(chalk.yellow('⚠️ --dev 模式需要共享模块目录'))
-    console.log(chalk.gray('   未找到 shared_modules，将仅使用镜像内置模块'))
+    console.log(chalk.gray('   未找到 shared 目录，将仅使用镜像内置模块'))
   }
   if (dev && !kernelRunnerPath) {
     console.log(chalk.yellow('⚠️ --dev 模式需要 kernel_runner.py'))

package/version.json

@@ -1,4 +1,4 @@
 {
-  "buildTime": "2026-05-13T15:50:26.143Z",
-  "cliVersion": "2026.5.13-2349"
+  "buildTime": "2026-05-13T16:02:49.085Z",
+  "cliVersion": "2026.5.14-2"
 }

package/shared/bayesian/gaussian_mixturemodel.py

@@ -1,141 +0,0 @@
-# GaussianMixtureModel 类定义
-# 从文档自动提取生成
-
-import numpy as np
-
-class GaussianMixtureModel:
-    """
-    高斯混合模型实现
-    使用EM算法求解
-    """
-    def __init__(self, n_components=3, max_iter=100, tol=1e-4):
-        self.n_components = n_components
-        self.max_iter = max_iter
-        self.tol = tol  # 收敛阈值
-        
-        self.weights_ = None   # 混合系数 (K,)
-        self.means_ = None     # 均值 (K, n_features)
-        self.covariances_ = None  # 协方差矩阵 (K, n_features, n_features)
-        self.log_likelihood_history_ = []
-    
-    def _initialize(self, X):
-        """初始化参数"""
-        n_samples, n_features = X.shape
-        K = self.n_components
-        
-        # 随机初始化均值（从数据中随机选择K个点）
-        indices = np.random.choice(n_samples, K, replace=False)
-        self.means_ = X[indices].copy()
-        
-        # 初始化协方差为数据协方差的对角线
-        data_cov = np.cov(X.T)
-        self.covariances_ = np.array([np.diag(np.diag(data_cov)) + 1e-6 * np.eye(n_features) 
-                                       for _ in range(K)])
-        
-        # 初始化混合系数为均匀分布
-        self.weights_ = np.ones(K) / K
-    
-    def _gaussian_pdf(self, X, mean, cov):
-        """计算多元高斯概率密度"""
-        n_features = X.shape[1]
-        diff = X - mean
-        
-        # 加小值保证数值稳定
-        cov_reg = cov + 1e-6 * np.eye(n_features)
-        
-        # 使用Cholesky分解计算行列式和逆
-        try:
-            L = np.linalg.cholesky(cov_reg)
-            log_det = 2 * np.sum(np.log(np.diag(L)))
-            diff_L = np.linalg.solve(L, diff.T).T
-            mahalanobis = np.sum(diff_L ** 2, axis=1)
-        except np.linalg.LinAlgError:
-            # 如果Cholesky失败，使用标准方法
-            sign, log_det = np.linalg.slogdet(cov_reg)
-            cov_inv = np.linalg.inv(cov_reg)
-            mahalanobis = np.sum(diff @ cov_inv * diff, axis=1)
-        
-        log_prob = -0.5 * (n_features * np.log(2 * np.pi) + log_det + mahalanobis)
-        return log_prob
-    
-    def _e_step(self, X):
-        """E步：计算责任度"""
-        n_samples = X.shape[0]
-        K = self.n_components
-        
-        # 计算每个成分的对数概率
-        log_probs = np.zeros((n_samples, K))
-        for k in range(K):
-            log_probs[:, k] = (np.log(self.weights_[k] + 1e-10) + 
-                               self._gaussian_pdf(X, self.means_[k], self.covariances_[k]))
-        
-        # 计算对数似然
-        log_likelihood = np.sum(np.log(np.sum(np.exp(log_probs), axis=1)))
-        
-        # 计算责任度（使用log-sum-exp trick避免数值下溢）
-        log_max = log_probs.max(axis=1, keepdims=True)
-        log_sum = np.log(np.sum(np.exp(log_probs - log_max), axis=1, keepdims=True)) + log_max
-        responsibilities = np.exp(log_probs - log_sum)
-        
-        return responsibilities, log_likelihood
-    
-    def _m_step(self, X, responsibilities):
-        """M步：更新参数"""
-        n_samples, n_features = X.shape
-        K = self.n_components
-        
-        # 计算每个成分的有效样本数
-        N_k = responsibilities.sum(axis=0) + 1e-10
-        
-        # 更新混合系数
-        self.weights_ = N_k / n_samples
-        
-        # 更新均值
-        self.means_ = (responsibilities.T @ X) / N_k[:, np.newaxis]
-        
-        # 更新协方差
-        for k in range(K):
-            diff = X - self.means_[k]
-            weighted_diff = responsibilities[:, k:k+1] * diff
-            self.covariances_[k] = (weighted_diff.T @ diff) / N_k[k]
-            # 添加正则化
-            self.covariances_[k] += 1e-6 * np.eye(n_features)
-    
-    def fit(self, X):
-        """训练模型"""
-        self._initialize(X)
-        self.log_likelihood_history_ = []
-        
-        prev_log_likelihood = -np.inf
-        
-        for iteration in range(self.max_iter):
-            # E步
-            responsibilities, log_likelihood = self._e_step(X)
-            self.log_likelihood_history_.append(log_likelihood)
-            
-            # 检查收敛
-            if abs(log_likelihood - prev_log_likelihood) < self.tol:
-                print(f"EM收敛于第{iteration}次迭代")
-                break
-            
-            # M步
-            self._m_step(X, responsibilities)
-            
-            prev_log_likelihood = log_likelihood
-        
-        return self
-    
-    def predict(self, X):
-        """预测聚类标签"""
-        responsibilities, _ = self._e_step(X)
-        return np.argmax(responsibilities, axis=1)
-    
-    def predict_proba(self, X):
-        """预测属于各成分的概率"""
-        responsibilities, _ = self._e_step(X)
-        return responsibilities
-    
-    def score(self, X):
-        """计算对数似然"""
-        _, log_likelihood = self._e_step(X)
-        return log_likelihood

package/shared/bayesian/simple_bayesiannetwork.py

@@ -1,99 +0,0 @@
-# SimpleBayesianNetwork 类定义
-# 从文档自动提取生成
-
-class SimpleBayesianNetwork:
-    """
-    简单贝叶斯网络实现
-    支持离散变量和精确推断（枚举法）
-    """
-    def __init__(self):
-        self.nodes = {}  # 节点信息：{name: {'parents': [], 'values': []}}
-        self.cpts = {}   # 条件概率表：{name: {parent_values: {value: prob}}}
-        self.topo_order = []  # 拓扑排序
-    
-    def add_node(self, name, values, parents=None):
-        """添加节点"""
-        if parents is None:
-            parents = []
-        self.nodes[name] = {'parents': parents, 'values': values}
-        self._update_topo_order()
-    
-    def set_cpt(self, name, cpt):
-        """
-        设置条件概率表
-        
-        cpt格式：{parent_value_tuple: {value: prob}}
-        对于无父节点的变量：{(): {value: prob}}
-        """
-        self.cpts[name] = cpt
-    
-    def _update_topo_order(self):
-        """计算拓扑排序"""
-        visited = set()
-        order = []
-        
-        def visit(node):
-            if node in visited:
-                return
-            visited.add(node)
-            for parent in self.nodes[node]['parents']:
-                visit(parent)
-            order.append(node)
-        
-        for node in self.nodes:
-            visit(node)
-        
-        self.topo_order = order
-    
-    def get_prob(self, name, value, parent_values):
-        """获取条件概率 P(name=value | parent_values)"""
-        parent_key = tuple(parent_values) if parent_values else ()
-        return self.cpts[name].get(parent_key, {}).get(value, 0)
-    
-    def joint_prob(self, assignment):
-        """计算联合概率 P(X1, X2, ...)"""
-        prob = 1.0
-        for node in self.topo_order:
-            parents = self.nodes[node]['parents']
-            parent_values = [assignment[p] for p in parents]
-            value = assignment[node]
-            prob *= self.get_prob(node, value, parent_values)
-        return prob
-    
-    def enumerate_inference(self, query, evidence):
-        """
-        枚举推断：计算 P(query | evidence)
-        
-        query: {node: '?'} 返回分布
-        evidence: {node: value}
-        """
-        query_nodes = list(query.keys())
-        hidden = [n for n in self.nodes if n not in query_nodes and n not in evidence]
-        
-        def enumerate_assignments(variables, current):
-            if not variables:
-                yield current.copy()
-                return
-            var = variables[0]
-            for value in self.nodes[var]['values']:
-                current[var] = value
-                yield from enumerate_assignments(variables[1:], current)
-            del current[var]
-        
-        query_values = {}
-        total = 0.0
-        
-        query_node = query_nodes[0]
-        for qv in self.nodes[query_node]['values']:
-            prob_sum = 0.0
-            for assignment in enumerate_assignments(hidden, {}):
-                assignment.update(evidence)
-                assignment[query_node] = qv
-                prob_sum += self.joint_prob(assignment)
-            query_values[qv] = prob_sum
-            total += prob_sum
-        
-        # 归一化
-        for k in query_values:
-            query_values[k] /= total
-        return query_values

package/shared/cnn/alex_net.py

@@ -1,65 +0,0 @@
-# AlexNet 类定义
-# 从文档自动提取生成
-
-import torch
-import torch.nn as nn
-from PIL import Image
-
-class AlexNet(nn.Module):
-    """
-    AlexNet 网络结构
-    适配 Tiny ImageNet 200 类分类任务
-    
-    原始 AlexNet 为 1000 类，这里修改最后一层为 200 类
-    使用 AdaptiveAvgPool2d 确保输出尺寸固定为 6x6
-    """
-    def __init__(self, num_classes=200):
-        super(AlexNet, self).__init__()
-        
-        # 特征提取层 (5 个卷积层)
-        self.features = nn.Sequential(
-            # Conv1: 11x11 卷积，步长 4，输出 96 通道
-            nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=2),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-            
-            # Conv2: 5x5 卷积，输出 256 通道
-            nn.Conv2d(96, 256, kernel_size=5, stride=1, padding=2),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-            
-            # Conv3: 3x3 卷积，输出 384 通道
-            nn.Conv2d(256, 384, kernel_size=3, stride=1, padding=1),
-            nn.ReLU(inplace=True),
-            
-            # Conv4: 3x3 卷积，输出 384 通道
-            nn.Conv2d(384, 384, kernel_size=3, stride=1, padding=1),
-            nn.ReLU(inplace=True),
-            
-            # Conv5: 3x3 卷积，输出 256 通道
-            nn.Conv2d(384, 256, kernel_size=3, stride=1, padding=1),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-            
-            # 自适应池化，确保输出固定为 6x6
-            nn.AdaptiveAvgPool2d((6, 6))
-        )
-        
-        # 分类层 (3 个全连接层)
-        self.classifier = nn.Sequential(
-            nn.Dropout(p=0.5),
-            nn.Linear(256 * 6 * 6, 4096),
-            nn.ReLU(inplace=True),
-            
-            nn.Dropout(p=0.5),
-            nn.Linear(4096, 4096),
-            nn.ReLU(inplace=True),
-            
-            nn.Linear(4096, num_classes)
-        )
-    
-    def forward(self, x):
-        x = self.features(x)
-        x = torch.flatten(x, 1)
-        x = self.classifier(x)
-        return x

package/shared/cnn/t_e_r_m1.py

@@ -1,65 +0,0 @@
-# AlexNet 类定义
-# 从文档自动提取生成
-
-import torch
-import torch.nn as nn
-from PIL import Image
-
-class AlexNet(nn.Module):
-    """
-    AlexNet 网络结构
-    适配 Tiny ImageNet 200 类分类任务
-    
-    原始 AlexNet 为 1000 类，这里修改最后一层为 200 类
-    使用 AdaptiveAvgPool2d 确保输出尺寸固定为 6x6
-    """
-    def __init__(self, num_classes=200):
-        super(AlexNet, self).__init__()
-        
-        # 特征提取层 (5 个卷积层)
-        self.features = nn.Sequential(
-            # Conv1: 11x11 卷积，步长 4，输出 96 通道
-            nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=2),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-            
-            # Conv2: 5x5 卷积，输出 256 通道
-            nn.Conv2d(96, 256, kernel_size=5, stride=1, padding=2),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-            
-            # Conv3: 3x3 卷积，输出 384 通道
-            nn.Conv2d(256, 384, kernel_size=3, stride=1, padding=1),
-            nn.ReLU(inplace=True),
-            
-            # Conv4: 3x3 卷积，输出 384 通道
-            nn.Conv2d(384, 384, kernel_size=3, stride=1, padding=1),
-            nn.ReLU(inplace=True),
-            
-            # Conv5: 3x3 卷积，输出 256 通道
-            nn.Conv2d(384, 256, kernel_size=3, stride=1, padding=1),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-            
-            # 自适应池化，确保输出固定为 6x6
-            nn.AdaptiveAvgPool2d((6, 6))
-        )
-        
-        # 分类层 (3 个全连接层)
-        self.classifier = nn.Sequential(
-            nn.Dropout(p=0.5),
-            nn.Linear(256 * 6 * 6, 4096),
-            nn.ReLU(inplace=True),
-            
-            nn.Dropout(p=0.5),
-            nn.Linear(4096, 4096),
-            nn.ReLU(inplace=True),
-            
-            nn.Linear(4096, num_classes)
-        )
-    
-    def forward(self, x):
-        x = self.features(x)
-        x = torch.flatten(x, 1)
-        x = self.classifier(x)
-        return x

package/shared/cnn/tiny_image_net_dataset.py

@@ -1,67 +0,0 @@
-# TinyImageNetDataset 类定义
-# 从文档自动提取生成
-
-import os
-from PIL import Image
-from torch.utils.data import Dataset, DataLoader
-
-class TinyImageNetDataset(Dataset):
-    """
-    Tiny ImageNet 200 数据集加载器
-
-    训练集按类别子目录读取，验证集从标注文件解析标签。
-    支持自定义预处理变换，适配 AlexNet 训练需求。
-    """
-    def __init__(self, root_dir, transform=None, is_train=True):
-        self.root_dir = root_dir
-        self.transform = transform
-        self.is_train = is_train
-
-        self.samples = []
-        self.classes = []
-
-        if is_train:
-            train_dir = os.path.join(root_dir, 'train')
-            self.classes = sorted(os.listdir(train_dir))
-            self.class_to_idx = {cls: idx for idx, cls in enumerate(self.classes)}
-
-            for cls in self.classes:
-                cls_dir = os.path.join(train_dir, cls)
-                images_dir = os.path.join(cls_dir, 'images')
-                if os.path.exists(images_dir):
-                    for img_name in os.listdir(images_dir):
-                        if img_name.endswith('.JPEG'):
-                            self.samples.append((
-                                os.path.join(images_dir, img_name),
-                                self.class_to_idx[cls]
-                            ))
-        else:
-            val_dir = os.path.join(root_dir, 'val')
-            val_images_dir = os.path.join(val_dir, 'images')
-            val_annotations = os.path.join(val_dir, 'val_annotations.txt')
-
-            if os.path.exists(val_annotations):
-                with open(val_annotations, 'r') as f:
-                    for line in f:
-                        parts = line.strip().split('\t')
-                        if len(parts) >= 2:
-                            img_name = parts[0]
-                            cls = parts[1]
-                            if cls not in self.classes:
-                                self.classes.append(cls)
-                            self.samples.append((
-                                os.path.join(val_images_dir, img_name),
-                                self.classes.index(cls)
-                            ))
-
-    def __len__(self):
-        return len(self.samples)
-
-    def __getitem__(self, idx):
-        img_path, label = self.samples[idx]
-        image = Image.open(img_path).convert('RGB')
-
-        if self.transform:
-            image = self.transform(image)
-
-        return image, label

package/shared/cnn/tiny_imagenetdataset.py

@@ -1,67 +0,0 @@
-# TinyImageNetDataset 类定义
-# 从文档自动提取生成
-
-import os
-from PIL import Image
-from torch.utils.data import Dataset, DataLoader
-
-class TinyImageNetDataset(Dataset):
-    """
-    Tiny ImageNet 200 数据集加载器
-
-    训练集按类别子目录读取，验证集从标注文件解析标签。
-    支持自定义预处理变换，适配 AlexNet 训练需求。
-    """
-    def __init__(self, root_dir, transform=None, is_train=True):
-        self.root_dir = root_dir
-        self.transform = transform
-        self.is_train = is_train
-
-        self.samples = []
-        self.classes = []
-
-        if is_train:
-            train_dir = os.path.join(root_dir, 'train')
-            self.classes = sorted(os.listdir(train_dir))
-            self.class_to_idx = {cls: idx for idx, cls in enumerate(self.classes)}
-
-            for cls in self.classes:
-                cls_dir = os.path.join(train_dir, cls)
-                images_dir = os.path.join(cls_dir, 'images')
-                if os.path.exists(images_dir):
-                    for img_name in os.listdir(images_dir):
-                        if img_name.endswith('.JPEG'):
-                            self.samples.append((
-                                os.path.join(images_dir, img_name),
-                                self.class_to_idx[cls]
-                            ))
-        else:
-            val_dir = os.path.join(root_dir, 'val')
-            val_images_dir = os.path.join(val_dir, 'images')
-            val_annotations = os.path.join(val_dir, 'val_annotations.txt')
-
-            if os.path.exists(val_annotations):
-                with open(val_annotations, 'r') as f:
-                    for line in f:
-                        parts = line.strip().split('\t')
-                        if len(parts) >= 2:
-                            img_name = parts[0]
-                            cls = parts[1]
-                            if cls not in self.classes:
-                                self.classes.append(cls)
-                            self.samples.append((
-                                os.path.join(val_images_dir, img_name),
-                                self.classes.index(cls)
-                            ))
-
-    def __len__(self):
-        return len(self.samples)
-
-    def __getitem__(self, idx):
-        img_path, label = self.samples[idx]
-        image = Image.open(img_path).convert('RGB')
-
-        if self.transform:
-            image = self.transform(image)
-
-        return image, label

package/shared/cnn/tinyimagenetdataset.py

@@ -1,67 +0,0 @@
-# TinyImageNetDataset 类定义
-# 从文档自动提取生成
-
-import os
-from PIL import Image
-from torch.utils.data import Dataset, DataLoader
-
-class TinyImageNetDataset(Dataset):
-    """
-    Tiny ImageNet 200 数据集加载器
-
-    训练集按类别子目录读取，验证集从标注文件解析标签。
-    支持自定义预处理变换，适配 AlexNet 训练需求。
-    """
-    def __init__(self, root_dir, transform=None, is_train=True):
-        self.root_dir = root_dir
-        self.transform = transform
-        self.is_train = is_train
-
-        self.samples = []
-        self.classes = []
-
-        if is_train:
-            train_dir = os.path.join(root_dir, 'train')
-            self.classes = sorted(os.listdir(train_dir))
-            self.class_to_idx = {cls: idx for idx, cls in enumerate(self.classes)}
-
-            for cls in self.classes:
-                cls_dir = os.path.join(train_dir, cls)
-                images_dir = os.path.join(cls_dir, 'images')
-                if os.path.exists(images_dir):
-                    for img_name in os.listdir(images_dir):
-                        if img_name.endswith('.JPEG'):
-                            self.samples.append((
-                                os.path.join(images_dir, img_name),
-                                self.class_to_idx[cls]
-                            ))
-        else:
-            val_dir = os.path.join(root_dir, 'val')
-            val_images_dir = os.path.join(val_dir, 'images')
-            val_annotations = os.path.join(val_dir, 'val_annotations.txt')
-
-            if os.path.exists(val_annotations):
-                with open(val_annotations, 'r') as f:
-                    for line in f:
-                        parts = line.strip().split('\t')
-                        if len(parts) >= 2:
-                            img_name = parts[0]
-                            cls = parts[1]
-                            if cls not in self.classes:
-                                self.classes.append(cls)
-                            self.samples.append((
-                                os.path.join(val_images_dir, img_name),
-                                self.classes.index(cls)
-                            ))
-
-    def __len__(self):
-        return len(self.samples)
-
-    def __getitem__(self, idx):
-        img_path, label = self.samples[idx]
-        image = Image.open(img_path).convert('RGB')
-
-        if self.transform:
-            image = self.transform(image)
-
-        return image, label