@icyfenix-dmla/cli 2026.5.2-7 → 2026.5.3-1019

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icyfenix-dmla/cli",
-  "version": "2026.5.2-7",
+  "version": "2026.5.3-1019",
   "description": "DMLA 沙箱服务命令行工具",
   "type": "module",
   "main": "src/index.js",
@@ -17,16 +17,19 @@
     "bin/",
     "src/",
     "scripts/",
+    "shared_modules/",
+    "version.json",
     "README.md"
   ],
   "dependencies": {
-    "commander": "^12.1.0",
+    "@icyfenix-dmla/install": "*",
+    "adm-zip": "^0.5.17",
     "chalk": "^5.3.0",
-    "enquirer": "^2.4.1",
-    "dockerode": "^5.0.0",
-    "express": "^4.21.2",
+    "commander": "^12.1.0",
     "cors": "^2.8.5",
-    "@icyfenix-dmla/install": "*"
+    "dockerode": "^5.0.0",
+    "enquirer": "^2.4.1",
+    "express": "^4.21.2"
   },
   "devDependencies": {
     "jest": "^29.7.0"

package/scripts/build.js

@@ -1,6 +1,6 @@
 /**
  * 构建脚本：将 local-server 代码复制到 CLI 包中
- * 用于 npm 发布时包含完整的服务器代码
+ * 用于 npm 发布时包含完整的服务器代码和共享模块
  */
 import fs from 'fs'
 import path from 'path'
@@ -11,17 +11,17 @@ const __dirname = path.dirname(__filename)
 
 const rootDir = path.resolve(__dirname, '../../..')
 const localServerSrc = path.resolve(rootDir, 'local-server/src')
+const localServerShared = path.resolve(rootDir, 'local-server/shared_modules')
 const cliServerDest = path.resolve(__dirname, '../src/server')
+const cliSharedDest = path.resolve(__dirname, '../shared_modules')
 
 console.log('📦 构建 CLI 包...')
-console.log(`   源目录: ${localServerSrc}`)
-console.log(`   目标目录: ${cliServerDest}`)
 
 // 递归复制目录
-function copyDir(src, dest) {
+function copyDir(src, dest, filter = null) {
   if (!fs.existsSync(src)) {
     console.error(`❌ 源目录不存在: ${src}`)
-    process.exit(1)
+    return false
   }
 
   // 创建目标目录
@@ -36,15 +36,48 @@ function copyDir(src, dest) {
     const destPath = path.join(dest, entry.name)
 
     if (entry.isDirectory()) {
-      copyDir(srcPath, destPath)
-    } else if (entry.isFile() && entry.name.endsWith('.js')) {
+      copyDir(srcPath, destPath, filter)
+    } else if (entry.isFile()) {
+      // 应用过滤器
+      if (filter && !filter(entry.name)) {
+        continue
+      }
       fs.copyFileSync(srcPath, destPath)
-      console.log(`   ✓ 复制: ${entry.name}`)
+      console.log(`   ✓ ${path.relative(rootDir, srcPath)} → ${path.relative(__dirname, destPath)}`)
     }
   }
+  return true
 }
 
-// 执行复制
-copyDir(localServerSrc, cliServerDest)
+// 复制服务器代码（只复制 .js 文件）
+console.log('\n📋 复制服务器代码...')
+console.log(`   源目录: ${localServerSrc}`)
+console.log(`   目标目录: ${cliServerDest}`)
+copyDir(localServerSrc, cliServerDest, (name) => name.endsWith('.js'))
+
+// 复制共享模块（复制所有 .py 文件和 __init__.py）
+console.log('\n📋 复制共享模块...')
+console.log(`   源目录: ${localServerShared}`)
+console.log(`   目标目录: ${cliSharedDest}`)
+const sharedCopied = copyDir(localServerShared, cliSharedDest, (name) => {
+  // 复制 Python 文件和初始化文件
+  return name.endsWith('.py') || name === '__init__.py'
+})
+
+if (!sharedCopied) {
+  console.log('⚠️ 共享模块目录不存在，跳过')
+}
+
+// 创建版本信息文件（用于 --dev 模式的版本比较）
+const versionInfo = {
+  buildTime: new Date().toISOString(),
+  // 从 package.json 读取版本
+  cliVersion: JSON.parse(fs.readFileSync(path.resolve(__dirname, '../package.json'), 'utf8')).version
+}
+fs.writeFileSync(
+  path.resolve(__dirname, '../version.json'),
+  JSON.stringify(versionInfo, null, 2)
+)
+console.log('\n✅ 版本信息已生成')
 
-console.log('✅ 服务器代码已复制到 CLI 包')
+console.log('\n✅ CLI 包构建完成')

package/shared_modules/__init__.py

@@ -0,0 +1,10 @@
+# shared 模块包初始化
+# 包含统计学习系列文档中可复用的类定义
+
+from .linear import *
+from .cnn import *
+from .bayesian import *
+from .tree import *
+from .svm import *
+from .unsupervised import *
+from .neural import *

package/shared_modules/bayesian/__init__.py

@@ -0,0 +1,6 @@
+# Bayesian 模块
+from .simple_bayesian_network import SimpleBayesianNetwork
+from .gaussian_mixture_model import GaussianMixtureModel
+from .multinomial_naive_bayes import MultinomialNaiveBayes
+
+__all__ = ['SimpleBayesianNetwork', 'GaussianMixtureModel', 'MultinomialNaiveBayes']

package/shared_modules/bayesian/bayesian_network.py

@@ -0,0 +1,105 @@
+"""
+贝叶斯网络实现
+支持离散变量和精确推断（枚举法）
+"""
+
+import numpy as np
+
+
+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_modules/bayesian/gaussian_mixture_model.py

@@ -0,0 +1,141 @@
+# 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_modules/bayesian/gaussian_mixturemodel.py

@@ -0,0 +1,141 @@
+# 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_modules/bayesian/multinomial_naive_bayes.py

@@ -0,0 +1,74 @@
+# MultinomialNaiveBayes 类定义
+# 从文档自动提取生成
+
+import numpy as np
+
+class MultinomialNaiveBayes:
+    """
+    多项式朴素贝叶斯实现
+    适用于离散特征（如文本词频）
+    """
+    
+    def __init__(self, alpha=1.0):
+        """
+        Parameters:
+        alpha : float, 拉普拉斯平滑参数
+        """
+        self.alpha = alpha  # 拉普拉斯平滑
+        self.class_prior_ = None  # P(y)
+        self.feature_prob_ = None  # P(x|y)
+        self.classes_ = None
+    
+    def fit(self, X, y):
+        """
+        训练模型
+        
+        Parameters:
+        X : ndarray, shape (n_samples, n_features)
+            特征矩阵（词频/计数）
+        y : ndarray, shape (n_samples,)
+            类别标签
+        """
+        n_samples, n_features = X.shape
+        self.classes_ = np.unique(y)
+        n_classes = len(self.classes_)
+        
+        # 计算先验概率 P(y)
+        class_counts = np.array([np.sum(y == c) for c in self.classes_])
+        self.class_prior_ = class_counts / n_samples
+        
+        # 计算条件概率 P(x|y)
+        # 对于每个类别，计算每个特征在该类别文档中的总计数
+        self.feature_prob_ = np.zeros((n_classes, n_features))
+        
+        for i, c in enumerate(self.classes_):
+            # 获取类别c的所有样本
+            X_c = X[y == c]
+            # 该类别每个特征的总计数 + 平滑
+            feature_counts = X_c.sum(axis=0) + self.alpha
+            # 归一化得到条件概率
+            total_count = feature_counts.sum()
+            self.feature_prob_[i] = feature_counts / total_count
+        
+        return self
+    
+    def predict_log_proba(self, X):
+        """
+        计算对数概率
+        """
+        # log P(y) + sum(log P(x|y))
+        log_prior = np.log(self.class_prior_)
+        log_likelihood = X @ np.log(self.feature_prob_.T)  # (n_samples, n_classes)
+        return log_prior + log_likelihood
+    
+    def predict(self, X):
+        """
+        预测类别
+        """
+        log_proba = self.predict_log_proba(X)
+        return self.classes_[np.argmax(log_proba, axis=1)]
+    
+    def score(self, X, y):
+        """计算准确率"""
+        y_pred = self.predict(X)
+        return np.mean(y_pred == y)