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

package/shared_modules/svm/simple_s_v_m.py

@@ -0,0 +1,111 @@
+# SimpleSVM 类定义
+# 从文档自动提取生成
+
+import numpy as np
+
+class SimpleSVM:
+    """
+    简化版软间隔SVM实现
+    
+    使用梯度上升优化对偶问题，支持软间隔（通过参数C控制）
+    
+    核心步骤：
+    1. 预计算核矩阵 K = X @ X.T（线性核）
+    2. 迭代更新拉格朗日乘子 alpha
+    3. 根据alpha找出支持向量
+    4. 计算超平面参数 w 和 b
+    """
+    
+    def __init__(self, learning_rate=0.01, n_iterations=1000, C=1.0):
+        self.lr = learning_rate       # 梯度上升的学习率
+        self.n_iterations = n_iterations  # 迭代次数
+        self.C = C                    # 软间隔惩罚系数
+        self.alpha = None             # 拉格朗日乘子（训练后获得）
+        self.w = None                 # 超平面法向量
+        self.b = None                 # 超平面截距
+        self.support_vectors_ = None  # 支持向量集合
+    
+    def fit(self, X, y):
+        """
+        训练SVM模型
+        
+        对偶问题的目标函数：
+        max sum(alpha_i) - 0.5 * sum(alpha_i * alpha_j * y_i * y_j * x_i^T x_j)
+        约束：0 <= alpha_i <= C, sum(alpha_i * y_i) = 0
+        
+        使用梯度上升迭代优化，每次更新一个alpha_i
+        """
+        n_samples, n_features = X.shape
+        
+        # 初始化拉格朗日乘子（全零）
+        self.alpha = np.zeros(n_samples)
+        
+        # 预计算核矩阵（线性核：样本内积）
+        # K[i,j] = x_i^T x_j，用于加速目标函数计算
+        K = X @ X.T
+        
+        # 梯度上升优化对偶问题
+        for iteration in range(self.n_iterations):
+            for i in range(n_samples):
+                # 计算alpha_i的梯度
+                # 目标函数对alpha_i的偏导：1 - y_i * sum_j(alpha_j * y_j * K[j,i])
+                gradient = 1 - y[i] * np.sum(self.alpha * y * K[:, i])
+                
+                # 梯度上升更新
+                self.alpha[i] += self.lr * gradient
+                
+                # 投影到约束区间 [0, C]
+                # 对应软间隔的约束：0 <= alpha_i <= C
+                self.alpha[i] = np.clip(self.alpha[i], 0, self.C)
+            
+            # 约束修正：确保 sum(alpha * y) = 0
+            # 通过减去均值偏差来近似满足线性约束
+            bias = np.mean(self.alpha * y)
+            self.alpha = self.alpha - bias * y
+            self.alpha = np.clip(self.alpha, 0, self.C)
+        
+        # 找出支持向量（alpha > 阈值的样本）
+        sv_threshold = 1e-5
+        sv_indices = self.alpha > sv_threshold
+        self.support_vectors_ = X[sv_indices]
+        sv_labels = y[sv_indices]
+        sv_alpha = self.alpha[sv_indices]
+        
+        # 计算超平面参数 w = sum(alpha_i * y_i * x_i)
+        # 只有支持向量参与计算（其他样本alpha=0）
+        self.w = np.zeros(n_features)
+        for i, (sv, label, a) in enumerate(zip(self.support_vectors_, sv_labels, sv_alpha)):
+            self.w += a * label * sv
+        
+        # 计算截距 b
+        # 使用支持向量计算：对于支持向量，y_i(w^T x_i + b) = 1（硬间隔）
+        # 或 y_i(w^T x_i + b) = 1 - xi_i（软间隔）
+        # 这里取所有支持向量的平均值
+        if len(self.support_vectors_) > 0:
+            self.b = np.mean(sv_labels - self.support_vectors_ @ self.w)
+        else:
+            self.b = 0
+        
+        return self
+    
+    def decision_function(self, X):
+        """
+        决策函数值：w^T x + b
+        
+        正值表示预测为正类，负值表示预测为负类
+        绝对值大小反映样本到超平面的距离
+        """
+        return X @ self.w + self.b
+    
+    def predict(self, X):
+        """
+        预测类别标签
+        
+        sign(w^T x + b): +1 表示正类，-1 表示负类
+        """
+        return np.sign(self.decision_function(X)).astype(int)
+    
+    def score(self, X, y):
+        """计算分类准确率"""
+        predictions = self.predict(X)
+        return np.mean(predictions == y)

package/shared_modules/svm/simple_svm.py

@@ -0,0 +1,111 @@
+# SimpleSVM 类定义
+# 从文档自动提取生成
+
+import numpy as np
+
+class SimpleSVM:
+    """
+    简化版软间隔SVM实现
+    
+    使用梯度上升优化对偶问题，支持软间隔（通过参数C控制）
+    
+    核心步骤：
+    1. 预计算核矩阵 K = X @ X.T（线性核）
+    2. 迭代更新拉格朗日乘子 alpha
+    3. 根据alpha找出支持向量
+    4. 计算超平面参数 w 和 b
+    """
+    
+    def __init__(self, learning_rate=0.01, n_iterations=1000, C=1.0):
+        self.lr = learning_rate       # 梯度上升的学习率
+        self.n_iterations = n_iterations  # 迭代次数
+        self.C = C                    # 软间隔惩罚系数
+        self.alpha = None             # 拉格朗日乘子（训练后获得）
+        self.w = None                 # 超平面法向量
+        self.b = None                 # 超平面截距
+        self.support_vectors_ = None  # 支持向量集合
+    
+    def fit(self, X, y):
+        """
+        训练SVM模型
+        
+        对偶问题的目标函数：
+        max sum(alpha_i) - 0.5 * sum(alpha_i * alpha_j * y_i * y_j * x_i^T x_j)
+        约束：0 <= alpha_i <= C, sum(alpha_i * y_i) = 0
+        
+        使用梯度上升迭代优化，每次更新一个alpha_i
+        """
+        n_samples, n_features = X.shape
+        
+        # 初始化拉格朗日乘子（全零）
+        self.alpha = np.zeros(n_samples)
+        
+        # 预计算核矩阵（线性核：样本内积）
+        # K[i,j] = x_i^T x_j，用于加速目标函数计算
+        K = X @ X.T
+        
+        # 梯度上升优化对偶问题
+        for iteration in range(self.n_iterations):
+            for i in range(n_samples):
+                # 计算alpha_i的梯度
+                # 目标函数对alpha_i的偏导：1 - y_i * sum_j(alpha_j * y_j * K[j,i])
+                gradient = 1 - y[i] * np.sum(self.alpha * y * K[:, i])
+                
+                # 梯度上升更新
+                self.alpha[i] += self.lr * gradient
+                
+                # 投影到约束区间 [0, C]
+                # 对应软间隔的约束：0 <= alpha_i <= C
+                self.alpha[i] = np.clip(self.alpha[i], 0, self.C)
+            
+            # 约束修正：确保 sum(alpha * y) = 0
+            # 通过减去均值偏差来近似满足线性约束
+            bias = np.mean(self.alpha * y)
+            self.alpha = self.alpha - bias * y
+            self.alpha = np.clip(self.alpha, 0, self.C)
+        
+        # 找出支持向量（alpha > 阈值的样本）
+        sv_threshold = 1e-5
+        sv_indices = self.alpha > sv_threshold
+        self.support_vectors_ = X[sv_indices]
+        sv_labels = y[sv_indices]
+        sv_alpha = self.alpha[sv_indices]
+        
+        # 计算超平面参数 w = sum(alpha_i * y_i * x_i)
+        # 只有支持向量参与计算（其他样本alpha=0）
+        self.w = np.zeros(n_features)
+        for i, (sv, label, a) in enumerate(zip(self.support_vectors_, sv_labels, sv_alpha)):
+            self.w += a * label * sv
+        
+        # 计算截距 b
+        # 使用支持向量计算：对于支持向量，y_i(w^T x_i + b) = 1（硬间隔）
+        # 或 y_i(w^T x_i + b) = 1 - xi_i（软间隔）
+        # 这里取所有支持向量的平均值
+        if len(self.support_vectors_) > 0:
+            self.b = np.mean(sv_labels - self.support_vectors_ @ self.w)
+        else:
+            self.b = 0
+        
+        return self
+    
+    def decision_function(self, X):
+        """
+        决策函数值：w^T x + b
+        
+        正值表示预测为正类，负值表示预测为负类
+        绝对值大小反映样本到超平面的距离
+        """
+        return X @ self.w + self.b
+    
+    def predict(self, X):
+        """
+        预测类别标签
+        
+        sign(w^T x + b): +1 表示正类，-1 表示负类
+        """
+        return np.sign(self.decision_function(X)).astype(int)
+    
+    def score(self, X, y):
+        """计算分类准确率"""
+        predictions = self.predict(X)
+        return np.mean(predictions == y)

package/shared_modules/tree/__init__.py

@@ -0,0 +1,6 @@
+# Tree 模块
+from .decision_tree_classifier import DecisionTreeClassifier
+from .random_forest_classifier import RandomForestClassifier
+from .ada_boost import AdaBoost
+
+__all__ = ['DecisionTreeClassifier', 'RandomForestClassifier', 'AdaBoost']

package/shared_modules/tree/ada_boost.py

@@ -0,0 +1,77 @@
+# AdaBoost 类定义
+# 从文档自动提取生成
+
+import numpy as np
+
+class AdaBoost:
+    """
+    AdaBoost 分类器
+    
+    核心思想：序列训练多个弱学习器，加权组合成强学习器
+    """
+    
+    def __init__(self, n_estimators=50):
+        self.n_estimators = n_estimators
+        self.stumps = []   # 存储所有弱学习器
+        self.alphas = []   # 存储所有学习器权重
+    
+    def fit(self, X, y):
+        """
+        训练 AdaBoost
+        
+        核心步骤（对应理论中的迭代流程）：
+        1. 初始化样本权重
+        2. 每轮迭代：训练弱学习器 → 计算错误率 → 计算学习器权重 → 更新样本权重
+        3. 保存所有弱学习器及其权重
+        """
+        n_samples = X.shape[0]
+        
+        # 初始化权重：所有样本权重相等（对应理论中的 w_i^(1) = 1/n）
+        weights = np.ones(n_samples) / n_samples
+        
+        self.stumps = []
+        self.alphas = []
+        
+        for t in range(self.n_estimators):
+            # 步骤一：训练弱学习器（决策桩）
+            stump = DecisionStump()
+            stump.fit(X, y, weights)
+            
+            # 步骤二：计算加权错误率 ε_t
+            predictions = stump.predict(X)
+            error = np.sum(weights[predictions != y])
+            
+            # 防止极端情况（错误率为 0 或 1）
+            error = max(error, 1e-10)
+            error = min(error, 1 - 1e-10)
+            
+            # 步骤三：计算学习器权重 α_t（对应理论中的公式）
+            alpha = 0.5 * np.log((1 - error) / error)
+            
+            # 步骤四：更新样本权重（对应理论中的权重更新公式）
+            # 预测正确的样本权重减小，预测错误的样本权重增大
+            weights = weights * np.exp(-alpha * y * predictions)
+            weights = weights / np.sum(weights)  # 归一化
+            
+            self.stumps.append(stump)
+            self.alphas.append(alpha)
+        
+        return self
+    
+    def predict(self, X):
+        """
+        加权投票预测
+        
+        对应理论中的 H(x) = sign(Σ α_t * h_t(x))
+        """
+        n_samples = X.shape[0]
+        scores = np.zeros(n_samples)
+        
+        for stump, alpha in zip(self.stumps, self.alphas):
+            scores += alpha * stump.predict(X)
+        
+        return np.sign(scores).astype(int)
+    
+    def score(self, X, y):
+        """计算准确率"""
+        return np.mean(self.predict(X) == y)

package/shared_modules/tree/decision_tree_classifier.py

@@ -0,0 +1,235 @@
+# DecisionTreeClassifier 类定义
+# 从文档自动提取生成
+
+import numpy as np
+
+class DecisionTreeClassifier:
+    """
+    CART 决策树分类器
+    
+    使用 Gini 指数作为分裂准则，构建二叉决策树。
+    支持预剪枝策略：最大深度限制和叶节点最小样本数限制。
+    
+    参数:
+        max_depth : int, 默认值 10
+            树的最大深度，防止过拟合
+        min_samples_split : int, 默认值 2
+            分裂所需的最小样本数，防止学习孤例
+    """
+    
+    def __init__(self, max_depth=10, min_samples_split=2, min_gain_threshold=0.0):
+        self.max_depth = max_depth
+        self.min_samples_split = min_samples_split
+        self.min_gain_threshold = min_gain_threshold
+        self.tree = None
+    
+    def _gini(self, y):
+        """
+        计算数据集的 Gini 指数
+        
+        Gini 指数衡量数据的不纯度，值越小越纯净。
+        
+        参数:
+            y : ndarray
+                目标变量数组
+        
+        返回:
+            float : Gini 指数值
+        """
+        if len(y) == 0:
+            return 0
+        _, counts = np.unique(y, return_counts=True)
+        probs = counts / len(y)
+        return 1 - np.sum(probs ** 2)
+    
+    def _gini_split(self, y_left, y_right):
+        """
+        计算分裂后的加权 Gini 指数
+        
+        加权平均两个子集的 Gini 指数，权重为样本数比例。
+        
+        参数:
+            y_left : ndarray
+                左分支的目标变量
+            y_right : ndarray
+                右分支的目标变量
+        
+        返回:
+            float : 分裂后的加权 Gini 指数
+        """
+        n = len(y_left) + len(y_right)
+        return (len(y_left) / n) * self._gini(y_left) + \
+               (len(y_right) / n) * self._gini(y_right)
+    
+    def _best_split(self, X, y):
+        """
+        寻找最佳分裂特征和分割点
+        
+        遍历所有特征的所有候选分割点，选择 Gini 指数最小的分裂方案。
+        候选分割点是特征的唯一值（CART 的标准策略）。
+        
+        参数:
+            X : ndarray, shape (n_samples, n_features)
+                特征矩阵
+            y : ndarray, shape (n_samples,)
+                目标变量
+        
+        返回:
+            tuple : (最佳特征索引, 最佳分割点, 对应的 Gini 指数)
+        """
+        best_gini = float('inf')
+        best_feature = None
+        best_threshold = None
+        
+        n_features = X.shape[1]
+        
+        for feature in range(n_features):
+            # 获取该特征的所有唯一值作为候选分割点
+            # 使用相邻唯一值的中点作为候选阈值（标准 CART 算法策略）
+            thresholds = np.unique(X[:, feature])
+            thresholds = (thresholds[:-1] + thresholds[1:]) / 2
+            
+            for threshold in thresholds:
+                # 按阈值分裂数据
+                left_mask = X[:, feature] <= threshold
+                right_mask = ~left_mask
+                
+                y_left = y[left_mask]
+                y_right = y[right_mask]
+                
+                # 忽略无效分裂（某分支为空）
+                if len(y_left) == 0 or len(y_right) == 0:
+                    continue
+                
+                gini = self._gini_split(y_left, y_right)
+                
+                # 更新最优分裂
+                if gini < best_gini:
+                    best_gini = gini
+                    best_feature = feature
+                    best_threshold = threshold
+        
+        return best_feature, best_threshold, best_gini
+    
+    def _build_tree(self, X, y, depth):
+        """
+        递归构建决策树
+        
+        核心步骤：
+        1. 检查终止条件（深度限制、样本数限制、纯净度）
+        2. 若满足终止条件，返回叶节点（多数类）
+        3. 否则寻找最优分裂，创建内部节点
+        4. 递归构建左右子树
+        
+        参数:
+            X : ndarray
+                特征矩阵
+            y : ndarray
+                目标变量
+            depth : int
+                当前深度
+        
+        返回:
+            dict : 树节点（字典表示）
+        """
+        n_samples = len(y)
+        
+        # 检查预剪枝终止条件
+        if (depth >= self.max_depth or 
+            n_samples < self.min_samples_split or 
+            len(np.unique(y)) == 1):
+            # 返回叶节点，预测值为多数类
+            values, counts = np.unique(y, return_counts=True)
+            return {'leaf': True, 'class': values[np.argmax(counts)]}
+        
+        # 寻找最优分裂
+        feature, threshold, gini = self._best_split(X, y)
+        
+        # 若无法分裂或分裂增益不足，返回叶节点
+        if feature is None or gini > self._gini(y) - self.min_gain_threshold:
+            values, counts = np.unique(y, return_counts=True)
+            return {'leaf': True, 'class': values[np.argmax(counts)]}
+        
+        # 分裂数据
+        left_mask = X[:, feature] <= threshold
+        right_mask = ~left_mask
+        
+        # 递归构建子树
+        left_tree = self._build_tree(X[left_mask], y[left_mask], depth + 1)
+        right_tree = self._build_tree(X[right_mask], y[right_mask], depth + 1)
+        
+        return {
+            'leaf': False,
+            'feature': feature,
+            'threshold': threshold,
+            'left': left_tree,
+            'right': right_tree
+        }
+    
+    def fit(self, X, y):
+        """
+        训练决策树
+        
+        参数:
+            X : ndarray, shape (n_samples, n_features)
+                特征矩阵
+            y : ndarray, shape (n_samples,)
+                目标变量
+        
+        返回:
+            self : 训练后的模型实例
+        """
+        self.tree = self._build_tree(X, y, depth=0)
+        return self
+    
+    def _predict_one(self, x, node):
+        """
+        预测单个样本
+        
+        从根节点开始，根据分裂条件选择分支，直到到达叶节点。
+        
+        参数:
+            x : ndarray
+                单个样本的特征向量
+            node : dict
+                当前树节点
+        
+        返回:
+            int : 预测类别
+        """
+        if node['leaf']:
+            return node['class']
+        
+        if x[node['feature']] <= node['threshold']:
+            return self._predict_one(x, node['left'])
+        else:
+            return self._predict_one(x, node['right'])
+    
+    def predict(self, X):
+        """
+        批量预测
+        
+        参数:
+            X : ndarray, shape (n_samples, n_features)
+                特征矩阵
+        
+        返回:
+            ndarray : 预测类别数组
+        """
+        return np.array([self._predict_one(x, self.tree) for x in X])
+    
+    def score(self, X, y):
+        """
+        计算准确率
+        
+        参数:
+            X : ndarray
+                特征矩阵
+            y : ndarray
+                真实类别
+        
+        返回:
+            float : 准确率
+        """
+        y_pred = self.predict(X)
+        return np.mean(y_pred == y)