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

package/shared_modules/linear/lasso_regression.py

@@ -0,0 +1,93 @@
+# LassoRegression 类定义
+# 从文档自动提取生成
+
+import numpy as np
+
+class LassoRegression:
+    """
+    Lasso回归实现（L1正则化）
+    使用坐标下降算法
+    
+    适用于：
+    1. 需要自动特征选择
+    2. 特征数量多，部分特征可能无关
+    3. 追求稀疏、可解释的模型
+    """
+    
+    def __init__(self, alpha=1.0, n_iterations=1000, tol=1e-4):
+        self.alpha = alpha          # 正则化强度λ
+        self.n_iterations = n_iterations  # 最大迭代次数
+        self.tol = tol              # 收敛阈值
+        self.coef_ = None
+        self.intercept_ = None
+    
+    def soft_threshold(self, rho, lambda_):
+        """
+        软阈值函数（Lasso的核心操作）
+        
+        将参数"推向"零，可能精确到达零
+        """
+        if rho < -lambda_:
+            return rho + lambda_
+        elif rho > lambda_:
+            return rho - lambda_
+        else:
+            return 0.0
+    
+    def fit(self, X, y):
+        """
+        训练模型（坐标下降）
+        
+        每次更新一个参数，轮流迭代直至收敛
+        """
+        n_samples, n_features = X.shape
+        
+        # 初始化参数
+        self.coef_ = np.zeros(n_features)
+        self.intercept_ = np.mean(y)
+        y_centered = y - self.intercept_
+        
+        # 数据标准化（加速收敛，保证公平惩罚）
+        X_mean = np.mean(X, axis=0)
+        X_std = np.std(X, axis=0)
+        X_std[X_std == 0] = 1  # 避免除零
+        X_normalized = (X - X_mean) / X_std
+        
+        # 坐标下降迭代
+        for iteration in range(self.n_iterations):
+            coef_old = self.coef_.copy()
+            
+            for j in range(n_features):
+                # 计算当前特征的"部分残差"
+                # 即：去掉第j个特征后的预测残差
+                residual = y_centered - X_normalized @ self.coef_ + self.coef_[j] * X_normalized[:, j]
+                
+                # 计算rho（未正则化的梯度项）
+                rho = X_normalized[:, j] @ residual / n_samples
+                
+                # 应用软阈值（Lasso的关键步骤）
+                self.coef_[j] = self.soft_threshold(rho, self.alpha)
+            
+            # 检查收敛（在标准化空间中比较）
+            if np.max(np.abs(self.coef_ - coef_old)) < self.tol:
+                break
+        
+        # 还原到原始尺度（迭代结束后执行一次）
+        self.coef_ = self.coef_ / X_std
+        
+        return self
+    
+    def predict(self, X):
+        """预测"""
+        return X @ self.coef_ + self.intercept_
+    
+    def score(self, X, y):
+        """R²得分"""
+        y_pred = self.predict(X)
+        ss_res = np.sum((y - y_pred) ** 2)
+        ss_tot = np.sum((y - np.mean(y)) ** 2)
+        return 1 - ss_res / ss_tot
+    
+    def get_selected_features(self, threshold=0.01):
+        """返回被选中的特征索引（非零系数）"""
+        return np.where(np.abs(self.coef_) > threshold)[0]

package/shared_modules/linear/logistic_regression.py

@@ -0,0 +1,78 @@
+# LogisticRegression 类定义
+# 从文档自动提取生成
+
+import numpy as np
+
+class LogisticRegression:
+    """
+    手写逻辑回归实现
+    使用梯度下降优化交叉熵损失
+    """   
+    def __init__(self, learning_rate=0.1, n_iterations=1000):
+        self.lr = learning_rate           # 学习率，控制梯度下降的步长
+        self.n_iterations = n_iterations  # 迭代次数，梯度下降的最大迭代轮数
+        self.coef_ = None                 # 特征系数（权重），训练后保存
+        self.intercept_ = None            # 截距项，训练后保存
+        self.loss_history = []            # 损失历史记录，用于可视化收敛过程，供后续可视化使用
+    
+    def sigmoid(self, z):
+        """Sigmoid 函数"""
+        z = np.clip(z, -500, 500)
+        return 1 / (1 + np.exp(-z))
+    
+    def cross_entropy_loss(self, y, p):
+        """交叉熵损失"""
+        # 避免 log(0)
+        eps = 1e-15
+        p = np.clip(p, eps, 1 - eps)
+        return -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))
+    
+    def fit(self, X, y):
+        """
+        训练模型（梯度下降）
+        
+        Parameters:
+        X : ndarray, shape (n_samples, n_features)
+            特征矩阵
+        y : ndarray, shape (n_samples,)
+            标签向量 (0 或 1)
+        """
+        n_samples, n_features = X.shape
+        
+        # 初始化参数
+        self.coef_ = np.zeros(n_features)
+        self.intercept_ = 0
+        
+        # 梯度下降迭代
+        for i in range(self.n_iterations):
+            # 计算预测概率
+            z = X @ self.coef_ + self.intercept_
+            p = self.sigmoid(z)
+            
+            # 记录损失
+            self.loss_history.append(self.cross_entropy_loss(y, p))
+            
+            # 计算梯度（交叉熵损失的简洁梯度）
+            gradient_coef = (1 / n_samples) * (X.T @ (p - y))
+            gradient_intercept = (1 / n_samples) * np.sum(p - y)
+            
+            # 更新参数
+            self.coef_ -= self.lr * gradient_coef
+            self.intercept_ -= self.lr * gradient_intercept
+        
+        return self
+    
+    def predict_proba(self, X):
+        """预测概率"""
+        z = X @ self.coef_ + self.intercept_
+        return self.sigmoid(z)
+    
+    def predict(self, X, threshold=0.5):
+        """预测类别"""
+        proba = self.predict_proba(X)
+        return (proba >= threshold).astype(int)
+    
+    def score(self, X, y):
+        """计算准确率"""
+        y_pred = self.predict(X)
+        return np.mean(y_pred == y)

package/shared_modules/linear/naive_bayes.py

@@ -0,0 +1,141 @@
+"""
+朴素贝叶斯分类器实现
+包含多项式朴素贝叶斯和高斯朴素贝叶斯
+"""
+
+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)
+
+
+class GaussianNaiveBayes:
+    """
+    高斯朴素贝叶斯实现
+    适用于连续特征
+    """
+
+    def __init__(self):
+        self.classes_ = None
+        self.class_prior_ = None
+        self.mu_ = None  # 每个类别每个特征的均值
+        self.sigma_ = None  # 每个类别每个特征的标准差
+
+    def fit(self, X, y):
+        """训练模型"""
+        n_samples, n_features = X.shape
+        self.classes_ = np.unique(y)
+        n_classes = len(self.classes_)
+
+        # 先验概率
+        class_counts = np.array([np.sum(y == c) for c in self.classes_])
+        self.class_prior_ = class_counts / n_samples
+
+        # 计算每个类别的均值和标准差
+        self.mu_ = np.zeros((n_classes, n_features))
+        self.sigma_ = np.zeros((n_classes, n_features))
+
+        for i, c in enumerate(self.classes_):
+            X_c = X[y == c]
+            self.mu_[i] = X_c.mean(axis=0)
+            self.sigma_[i] = X_c.std(axis=0) + 1e-9  # 防止除零
+
+        return self
+
+    def predict_log_proba(self, X):
+        """计算对数概率"""
+        n_samples = X.shape[0]
+        n_classes = len(self.classes_)
+        log_proba = np.zeros((n_samples, n_classes))
+
+        for i in range(n_classes):
+            # log P(y) + sum(log P(x|y))
+            log_prior = np.log(self.class_prior_[i])
+            # 对数概率密度（避免数值溢出）
+            log_likelihood = np.sum(
+                -0.5 * np.log(2 * np.pi)
+                - np.log(self.sigma_[i])
+                - 0.5 * ((X - self.mu_[i]) / self.sigma_[i])**2,
+                axis=1
+            )
+            log_proba[:, i] = log_prior + log_likelihood
+
+        return log_proba
+
+    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)

package/shared_modules/linear/ridge_regression.py

@@ -0,0 +1,58 @@
+# RidgeRegression 类定义
+# 从文档自动提取生成
+
+import numpy as np
+
+class RidgeRegression:
+    """
+    岭回归实现（L2正则化）
+    
+    适用于：
+    1. 特征之间存在共线性
+    2. 参数估计不稳定
+    3. 需要防止过拟合
+    """
+    
+    def __init__(self, alpha=1.0):
+        self.alpha = alpha  # 正则化强度λ
+        self.coef_ = None   # 特征系数
+        self.intercept_ = None  # 截距
+    
+    def fit(self, X, y):
+        """
+        训练模型（闭式解）
+        
+        Parameters:
+        X : ndarray, shape (n_samples, n_features)
+            特征矩阵
+        y : ndarray, shape (n_samples,)
+            目标向量
+        """
+        n_samples = X.shape[0]
+        X_augmented = np.column_stack([np.ones(n_samples), X])
+        
+        # 岭回归闭式解：β = (X^T X + λI)^(-1) X^T y
+        # 注意：不对截距项正则化（I的第一行第一列为0）
+        I = np.eye(X_augmented.shape[1])
+        I[0, 0] = 0  # 截距项不参与正则化
+        
+        XtX = X_augmented.T @ X_augmented
+        Xty = X_augmented.T @ y
+        
+        self.beta_ = np.linalg.solve(XtX + self.alpha * I, Xty)
+        
+        self.intercept_ = self.beta_[0]
+        self.coef_ = self.beta_[1:]
+        
+        return self
+    
+    def predict(self, X):
+        """预测"""
+        return X @ self.coef_ + self.intercept_
+    
+    def score(self, X, y):
+        """R²得分"""
+        y_pred = self.predict(X)
+        ss_res = np.sum((y - y_pred) ** 2)
+        ss_tot = np.sum((y - np.mean(y)) ** 2)
+        return 1 - ss_res / ss_tot

package/shared_modules/neural/__init__.py

@@ -0,0 +1,4 @@
+# Neural 模块
+from .perceptron import Perceptron
+
+__all__ = ['Perceptron']

package/shared_modules/neural/perceptron.py

@@ -0,0 +1,80 @@
+# Perceptron 类定义
+# 从文档自动提取生成
+
+import numpy as np
+
+class Perceptron:
+    """
+    感知机实现
+    
+    使用错误驱动的权重更新规则：
+    w = w + eta * y * x (当预测错误时)
+    """
+    def __init__(self, learning_rate=1.0, max_iterations=1000):
+        self.lr = learning_rate
+        self.max_iter = max_iterations
+        self.w = None  # 权重向量（包含偏置）
+        self.errors_history = []  # 每轮迭代错误数
+    
+    def fit(self, X, y):
+        """
+        训练感知机
+        
+        Parameters:
+        X : ndarray, shape (n_samples, n_features)
+            输入特征矩阵
+        y : ndarray, shape (n_samples,)
+            标签向量，取值为 {1, -1}
+        """
+        n_samples, n_features = X.shape
+        
+        # 增广向量形式：添加常数1列（对应偏置）
+        X_aug = np.column_stack([X, np.ones(n_samples)])
+        
+        # 初始化权重为零向量
+        self.w = np.zeros(n_features + 1)
+        
+        # 训练循环
+        for iteration in range(self.max_iter):
+            errors = 0
+            for i in range(n_samples):
+                # 计算预测值
+                prediction = np.sign(self.w @ X_aug[i])
+                if prediction == 0:
+                    prediction = -1  # 符号函数边界情况
+                
+                # 若预测错误，更新权重
+                if prediction != y[i]:
+                    self.w += self.lr * y[i] * X_aug[i]
+                    errors += 1
+            
+            self.errors_history.append(errors)
+            
+            # 若所有样本正确分类，提前终止
+            if errors == 0:
+                print(f"在第 {iteration + 1} 轮迭代后收敛")
+                break
+        
+        return self
+    
+    def predict(self, X):
+        """
+        预测
+        
+        Parameters:
+        X : ndarray, shape (n_samples, n_features)
+        
+        Returns:
+        predictions : ndarray, shape (n_samples,)
+            预测标签 {1, -1}
+        """
+        n_samples = X.shape[0]
+        X_aug = np.column_stack([X, np.ones(n_samples)])
+        predictions = np.sign(X_aug @ self.w)
+        predictions[predictions == 0] = -1
+        return predictions
+    
+    def score(self, X, y):
+        """计算准确率"""
+        predictions = self.predict(X)
+        return np.mean(predictions == y)

package/shared_modules/svm/__init__.py

@@ -0,0 +1,5 @@
+# SVM 模块
+from .kernel_svm import KernelSVM
+from .simple_svm import SimpleSVM
+
+__all__ = ['KernelSVM', 'SimpleSVM']

package/shared_modules/svm/kernel_s_v_m.py

@@ -0,0 +1,98 @@
+# KernelSVM 类定义
+# 从文档自动提取生成
+
+import numpy as np
+
+class KernelSVM:
+    """
+    核SVM实现
+    支持线性核、多项式核、RBF核
+    """
+    def __init__(self, kernel='rbf', C=1.0, gamma=1.0, degree=3, coef0=1):
+        self.kernel = kernel
+        self.C = C
+        self.gamma = gamma
+        self.degree = degree
+        self.coef0 = coef0  # 多项式核的常数项
+        
+        self.alpha = None
+        self.b = None
+        self.X_train = None
+        self.y_train = None
+        self.support_vectors_ = None
+        self.support_vector_labels_ = None
+        self.alpha_sv = None
+    
+    def _kernel(self, X1, X2):
+        """计算核矩阵"""
+        if self.kernel == 'linear':
+            return X1 @ X2.T
+        
+        elif self.kernel == 'poly':
+            return (X1 @ X2.T + self.coef0) ** self.degree
+        
+        elif self.kernel == 'rbf':
+            # ||x - x'||^2 = ||x||^2 + ||x'||^2 - 2*x^T*x'
+            X1_norm = np.sum(X1 ** 2, axis=1).reshape(-1, 1)
+            X2_norm = np.sum(X2 ** 2, axis=1).reshape(1, -1)
+            distances = X1_norm + X2_norm - 2 * X1 @ X2.T
+            return np.exp(-self.gamma * distances)
+        
+        else:
+            raise ValueError(f"未知核函数: {self.kernel}")
+    
+    def fit(self, X, y, lr=0.01, n_iterations=500):
+        """训练模型（简化版SMO思想）"""
+        n_samples = X.shape[0]
+        self.X_train = X
+        self.y_train = y
+        
+        # 计算核矩阵
+        K = self._kernel(X, X)
+        
+        # 初始化
+        self.alpha = np.zeros(n_samples)
+        
+        # 梯度上升优化
+        for _ in range(n_iterations):
+            for i in range(n_samples):
+                # 梯度
+                gradient = 1 - y[i] * np.sum(self.alpha * y * K[:, i])
+                self.alpha[i] += lr * gradient
+                self.alpha[i] = np.clip(self.alpha[i], 0, self.C)
+            
+            # 约束修正：满足等式约束 sum(alpha * y) = 0
+            # 减去均值偏差后，需再次投影到边界约束 [0, C]
+            self.alpha = self.alpha - np.mean(self.alpha * y) * y
+            self.alpha = np.clip(self.alpha, 0, self.C)
+            # 注意：投影后等式约束可能不再精确满足，但迭代过程中误差会累积抵消
+        
+        # 支持向量
+        sv_mask = self.alpha > 1e-5
+        self.support_vectors_ = X[sv_mask]
+        self.support_vector_labels_ = y[sv_mask]
+        self.alpha_sv = self.alpha[sv_mask]
+        
+        # 计算b
+        if len(self.support_vectors_) > 0:
+            K_sv = self._kernel(self.support_vectors_, self.support_vectors_)
+            margins = np.sum(self.alpha_sv * self.support_vector_labels_ * K_sv, axis=1)
+            self.b = np.mean(self.support_vector_labels_ - margins)
+        else:
+            self.b = 0
+        
+        return self
+    
+    def decision_function(self, X):
+        """决策函数"""
+        K = self._kernel(X, self.support_vectors_)
+        return K @ (self.alpha_sv * self.support_vector_labels_) + self.b
+    
+    def predict(self, X):
+        """预测类别"""
+        return np.sign(self.decision_function(X)).astype(int)
+    
+    def score(self, X, y):
+        """计算准确率"""
+        y_pred = self.predict(X)
+        return np.mean(y_pred == y)

package/shared_modules/svm/kernel_svm.py

@@ -0,0 +1,98 @@
+# KernelSVM 类定义
+# 从文档自动提取生成
+
+import numpy as np
+
+class KernelSVM:
+    """
+    核SVM实现
+    支持线性核、多项式核、RBF核
+    """
+    def __init__(self, kernel='rbf', C=1.0, gamma=1.0, degree=3, coef0=1):
+        self.kernel = kernel
+        self.C = C
+        self.gamma = gamma
+        self.degree = degree
+        self.coef0 = coef0  # 多项式核的常数项
+        
+        self.alpha = None
+        self.b = None
+        self.X_train = None
+        self.y_train = None
+        self.support_vectors_ = None
+        self.support_vector_labels_ = None
+        self.alpha_sv = None
+    
+    def _kernel(self, X1, X2):
+        """计算核矩阵"""
+        if self.kernel == 'linear':
+            return X1 @ X2.T
+        
+        elif self.kernel == 'poly':
+            return (X1 @ X2.T + self.coef0) ** self.degree
+        
+        elif self.kernel == 'rbf':
+            # ||x - x'||^2 = ||x||^2 + ||x'||^2 - 2*x^T*x'
+            X1_norm = np.sum(X1 ** 2, axis=1).reshape(-1, 1)
+            X2_norm = np.sum(X2 ** 2, axis=1).reshape(1, -1)
+            distances = X1_norm + X2_norm - 2 * X1 @ X2.T
+            return np.exp(-self.gamma * distances)
+        
+        else:
+            raise ValueError(f"未知核函数: {self.kernel}")
+    
+    def fit(self, X, y, lr=0.01, n_iterations=500):
+        """训练模型（简化版SMO思想）"""
+        n_samples = X.shape[0]
+        self.X_train = X
+        self.y_train = y
+        
+        # 计算核矩阵
+        K = self._kernel(X, X)
+        
+        # 初始化
+        self.alpha = np.zeros(n_samples)
+        
+        # 梯度上升优化
+        for _ in range(n_iterations):
+            for i in range(n_samples):
+                # 梯度
+                gradient = 1 - y[i] * np.sum(self.alpha * y * K[:, i])
+                self.alpha[i] += lr * gradient
+                self.alpha[i] = np.clip(self.alpha[i], 0, self.C)
+            
+            # 约束修正：满足等式约束 sum(alpha * y) = 0
+            # 减去均值偏差后，需再次投影到边界约束 [0, C]
+            self.alpha = self.alpha - np.mean(self.alpha * y) * y
+            self.alpha = np.clip(self.alpha, 0, self.C)
+            # 注意：投影后等式约束可能不再精确满足，但迭代过程中误差会累积抵消
+        
+        # 支持向量
+        sv_mask = self.alpha > 1e-5
+        self.support_vectors_ = X[sv_mask]
+        self.support_vector_labels_ = y[sv_mask]
+        self.alpha_sv = self.alpha[sv_mask]
+        
+        # 计算b
+        if len(self.support_vectors_) > 0:
+            K_sv = self._kernel(self.support_vectors_, self.support_vectors_)
+            margins = np.sum(self.alpha_sv * self.support_vector_labels_ * K_sv, axis=1)
+            self.b = np.mean(self.support_vector_labels_ - margins)
+        else:
+            self.b = 0
+        
+        return self
+    
+    def decision_function(self, X):
+        """决策函数"""
+        K = self._kernel(X, self.support_vectors_)
+        return K @ (self.alpha_sv * self.support_vector_labels_) + self.b
+    
+    def predict(self, X):
+        """预测类别"""
+        return np.sign(self.decision_function(X)).astype(int)
+    
+    def score(self, X, y):
+        """计算准确率"""
+        y_pred = self.predict(X)
+        return np.mean(y_pred == y)