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

package/shared_modules/tree/decision_treeclassifier.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)

package/shared_modules/tree/random_forest_classifier.py

@@ -0,0 +1,88 @@
+# RandomForestClassifier 类定义
+# 从文档自动提取生成
+
+import numpy as np
+
+class RandomForestClassifier:
+    """
+    随机森林分类器
+    
+    实现：
+    1. Bootstrap采样（对应理论：样本随机）
+    2. 多棵决策树训练（每棵树使用不同的Bootstrap样本和特征子集）
+    3. 多数投票预测（对应理论：投票机制）
+    
+    参数:
+        n_estimators : int, 默认值 100
+            树的数量（对应理论中的B）
+        max_depth : int, 默认值 10
+            每棵树的最大深度
+        max_features : str or int, 默认值 'sqrt'
+            每次分裂时考虑的特征数量（对应理论中的m）
+    """
+    
+    def __init__(self, n_estimators=100, max_depth=10, max_features='sqrt'):
+        self.n_estimators = n_estimators
+        self.max_depth = max_depth
+        self.max_features = max_features
+        self.trees = []
+    
+    def _bootstrap_sample(self, X, y):
+        """
+        Bootstrap采样（对应理论：有放回重采样）
+        
+        从原始数据集中有放回地抽取n个样本
+        """
+        n_samples = X.shape[0]
+        indices = np.random.choice(n_samples, n_samples, replace=True)
+        return X[indices], y[indices]
+    
+    def fit(self, X, y):
+        """
+        训练随机森林
+        
+        核心步骤：
+        1. 确定特征子集大小m
+        2. 对每棵树：Bootstrap采样 → 训练决策树
+        """
+        n_features = X.shape[1]
+        
+        # 确定特征子集大小m（对应理论：分类用sqrt(d)，回归用d/3）
+        if self.max_features == 'sqrt':
+            max_features = int(np.sqrt(n_features))
+        elif self.max_features == 'log2':
+            max_features = int(np.log2(n_features))
+        else:
+            max_features = n_features
+        
+        self.trees = []
+        for _ in range(self.n_estimators):
+            # Bootstrap采样
+            X_sample, y_sample = self._bootstrap_sample(X, y)
+            
+            # 训练决策树（带特征随机）
+            tree = DecisionTreeForRF(
+                max_depth=self.max_depth,
+                max_features=max_features
+            )
+            tree.fit(X_sample, y_sample)
+            self.trees.append(tree)
+        
+        return self
+    
+    def predict(self, X):
+        """
+        多数投票预测（对应理论：硬投票）
+        
+        每棵树预测一个类别，选择得票最多的类别
+        """
+        predictions = np.array([tree.predict(X) for tree in self.trees])
+        result = []
+        for i in range(X.shape[0]):
+            values, counts = np.unique(predictions[:, i], return_counts=True)
+            result.append(values[np.argmax(counts)])
+        return np.array(result)
+    
+    def score(self, X, y):
+        """计算准确率"""
+        return np.mean(self.predict(X) == y)

package/shared_modules/tree/random_forestclassifier.py

@@ -0,0 +1,88 @@
+# RandomForestClassifier 类定义
+# 从文档自动提取生成
+
+import numpy as np
+
+class RandomForestClassifier:
+    """
+    随机森林分类器
+    
+    实现：
+    1. Bootstrap采样（对应理论：样本随机）
+    2. 多棵决策树训练（每棵树使用不同的Bootstrap样本和特征子集）
+    3. 多数投票预测（对应理论：投票机制）
+    
+    参数:
+        n_estimators : int, 默认值 100
+            树的数量（对应理论中的B）
+        max_depth : int, 默认值 10
+            每棵树的最大深度
+        max_features : str or int, 默认值 'sqrt'
+            每次分裂时考虑的特征数量（对应理论中的m）
+    """
+    
+    def __init__(self, n_estimators=100, max_depth=10, max_features='sqrt'):
+        self.n_estimators = n_estimators
+        self.max_depth = max_depth
+        self.max_features = max_features
+        self.trees = []
+    
+    def _bootstrap_sample(self, X, y):
+        """
+        Bootstrap采样（对应理论：有放回重采样）
+        
+        从原始数据集中有放回地抽取n个样本
+        """
+        n_samples = X.shape[0]
+        indices = np.random.choice(n_samples, n_samples, replace=True)
+        return X[indices], y[indices]
+    
+    def fit(self, X, y):
+        """
+        训练随机森林
+        
+        核心步骤：
+        1. 确定特征子集大小m
+        2. 对每棵树：Bootstrap采样 → 训练决策树
+        """
+        n_features = X.shape[1]
+        
+        # 确定特征子集大小m（对应理论：分类用sqrt(d)，回归用d/3）
+        if self.max_features == 'sqrt':
+            max_features = int(np.sqrt(n_features))
+        elif self.max_features == 'log2':
+            max_features = int(np.log2(n_features))
+        else:
+            max_features = n_features
+        
+        self.trees = []
+        for _ in range(self.n_estimators):
+            # Bootstrap采样
+            X_sample, y_sample = self._bootstrap_sample(X, y)
+            
+            # 训练决策树（带特征随机）
+            tree = DecisionTreeForRF(
+                max_depth=self.max_depth,
+                max_features=max_features
+            )
+            tree.fit(X_sample, y_sample)
+            self.trees.append(tree)
+        
+        return self
+    
+    def predict(self, X):
+        """
+        多数投票预测（对应理论：硬投票）
+        
+        每棵树预测一个类别，选择得票最多的类别
+        """
+        predictions = np.array([tree.predict(X) for tree in self.trees])
+        result = []
+        for i in range(X.shape[0]):
+            values, counts = np.unique(predictions[:, i], return_counts=True)
+            result.append(values[np.argmax(counts)])
+        return np.array(result)
+    
+    def score(self, X, y):
+        """计算准确率"""
+        return np.mean(self.predict(X) == y)

package/shared_modules/unsupervised/__init__.py

@@ -0,0 +1,5 @@
+# Unsupervised 模块
+from .kmeans import KMeans
+from .pca import PCA
+
+__all__ = ['KMeans', 'PCA']

package/shared_modules/unsupervised/k_means.py

@@ -0,0 +1,127 @@
+# KMeans 类定义
+# 从文档自动提取生成
+
+import numpy as np
+
+class KMeans:
+    """
+    K-means聚类算法实现
+    
+    参数:
+        n_clusters : int, 簇的数量K
+        max_iter : int, 最大迭代次数
+        tol : float, 收敛阈值（中心变化小于此值时停止）
+        n_init : int, 随机初始化的次数（取最优结果）
+    """
+    
+    def __init__(self, n_clusters=3, max_iter=300, tol=1e-4, n_init=10):
+        self.n_clusters = n_clusters
+        self.max_iter = max_iter
+        self.tol = tol
+        self.n_init = n_init
+        
+        self.cluster_centers_ = None  # 簇中心
+        self.labels_ = None           # 每个样本的簇分配
+        self.inertia_ = None          # 目标函数值（距离平方和）
+    
+    def _init_centers(self, X):
+        """
+        随机初始化簇中心
+        
+        从数据中随机选择K个样本作为初始中心
+        """
+        indices = np.random.choice(len(X), self.n_clusters, replace=False)
+        return X[indices].copy()
+    
+    def _assign_clusters(self, X, centers):
+        """
+        分配步骤：将每个样本分配到最近的簇中心
+        
+        计算每个样本到所有中心的距离平方，返回最近的簇编号
+        """
+        distances = np.zeros((len(X), self.n_clusters))
+        for k in range(self.n_clusters):
+            # 计算样本到第k个中心的距离平方（对应目标函数中的||x - μ||²）
+            distances[:, k] = np.sum((X - centers[k]) ** 2, axis=1)
+        return np.argmin(distances, axis=1)
+    
+    def _update_centers(self, X, labels):
+        """
+        更新步骤：重新计算每个簇的中心
+        
+        簇中心 = 簇内样本的均值（这就是"means"的含义）
+        """
+        centers = np.zeros((self.n_clusters, X.shape[1]))
+        for k in range(self.n_clusters):
+            mask = labels == k
+            if np.sum(mask) > 0:
+                # 取簇内样本的均值作为新中心
+                centers[k] = X[mask].mean(axis=0)
+            else:
+                # 空簇的罕见情况：随机重新初始化
+                centers[k] = X[np.random.randint(len(X))]
+        return centers
+    
+    def _compute_inertia(self, X, labels, centers):
+        """
+        计算目标函数值J
+        
+        J = 所有样本到其所属簇中心的距离平方和
+        """
+        inertia = 0
+        for k in range(self.n_clusters):
+            mask = labels == k
+            inertia += np.sum((X[mask] - centers[k]) ** 2)
+        return inertia
+    
+    def fit(self, X):
+        """
+        训练K-means模型
+        
+        执行多次随机初始化，取目标函数最小的结果
+        """
+        best_inertia = float('inf')
+        best_centers = None
+        best_labels = None
+        
+        for init in range(self.n_init):
+            # 初始化簇中心
+            centers = self._init_centers(X)
+            
+            # 迭代直到收敛
+            for i in range(self.max_iter):
+                # 步骤2：分配样本到最近的簇
+                labels = self._assign_clusters(X, centers)
+                
+                # 步骤3：更新簇中心
+                new_centers = self._update_centers(X, labels)
+                
+                # 检查收敛：中心变化是否小于阈值
+                if np.max(np.abs(new_centers - centers)) < self.tol:
+                    break
+                
+                centers = new_centers
+            
+            # 计算本次初始化的目标函数值
+            inertia = self._compute_inertia(X, labels, centers)
+            
+            # 保留最优结果
+            if inertia < best_inertia:
+                best_inertia = inertia
+                best_centers = centers.copy()
+                best_labels = labels.copy()
+        
+        # 存储最优结果
+        self.cluster_centers_ = best_centers
+        self.labels_ = best_labels
+        self.inertia_ = best_inertia
+        
+        return self
+    
+    def predict(self, X):
+        """
+        预测新样本所属的簇
+        
+        根据训练得到的簇中心，将新样本分配到最近的簇
+        """
+        return self._assign_clusters(X, self.cluster_centers_)

package/shared_modules/unsupervised/kmeans.py

@@ -0,0 +1,127 @@
+# KMeans 类定义
+# 从文档自动提取生成
+
+import numpy as np
+
+class KMeans:
+    """
+    K-means聚类算法实现
+    
+    参数:
+        n_clusters : int, 簇的数量K
+        max_iter : int, 最大迭代次数
+        tol : float, 收敛阈值（中心变化小于此值时停止）
+        n_init : int, 随机初始化的次数（取最优结果）
+    """
+    
+    def __init__(self, n_clusters=3, max_iter=300, tol=1e-4, n_init=10):
+        self.n_clusters = n_clusters
+        self.max_iter = max_iter
+        self.tol = tol
+        self.n_init = n_init
+        
+        self.cluster_centers_ = None  # 簇中心
+        self.labels_ = None           # 每个样本的簇分配
+        self.inertia_ = None          # 目标函数值（距离平方和）
+    
+    def _init_centers(self, X):
+        """
+        随机初始化簇中心
+        
+        从数据中随机选择K个样本作为初始中心
+        """
+        indices = np.random.choice(len(X), self.n_clusters, replace=False)
+        return X[indices].copy()
+    
+    def _assign_clusters(self, X, centers):
+        """
+        分配步骤：将每个样本分配到最近的簇中心
+        
+        计算每个样本到所有中心的距离平方，返回最近的簇编号
+        """
+        distances = np.zeros((len(X), self.n_clusters))
+        for k in range(self.n_clusters):
+            # 计算样本到第k个中心的距离平方（对应目标函数中的||x - μ||²）
+            distances[:, k] = np.sum((X - centers[k]) ** 2, axis=1)
+        return np.argmin(distances, axis=1)
+    
+    def _update_centers(self, X, labels):
+        """
+        更新步骤：重新计算每个簇的中心
+        
+        簇中心 = 簇内样本的均值（这就是"means"的含义）
+        """
+        centers = np.zeros((self.n_clusters, X.shape[1]))
+        for k in range(self.n_clusters):
+            mask = labels == k
+            if np.sum(mask) > 0:
+                # 取簇内样本的均值作为新中心
+                centers[k] = X[mask].mean(axis=0)
+            else:
+                # 空簇的罕见情况：随机重新初始化
+                centers[k] = X[np.random.randint(len(X))]
+        return centers
+    
+    def _compute_inertia(self, X, labels, centers):
+        """
+        计算目标函数值J
+        
+        J = 所有样本到其所属簇中心的距离平方和
+        """
+        inertia = 0
+        for k in range(self.n_clusters):
+            mask = labels == k
+            inertia += np.sum((X[mask] - centers[k]) ** 2)
+        return inertia
+    
+    def fit(self, X):
+        """
+        训练K-means模型
+        
+        执行多次随机初始化，取目标函数最小的结果
+        """
+        best_inertia = float('inf')
+        best_centers = None
+        best_labels = None
+        
+        for init in range(self.n_init):
+            # 初始化簇中心
+            centers = self._init_centers(X)
+            
+            # 迭代直到收敛
+            for i in range(self.max_iter):
+                # 步骤2：分配样本到最近的簇
+                labels = self._assign_clusters(X, centers)
+                
+                # 步骤3：更新簇中心
+                new_centers = self._update_centers(X, labels)
+                
+                # 检查收敛：中心变化是否小于阈值
+                if np.max(np.abs(new_centers - centers)) < self.tol:
+                    break
+                
+                centers = new_centers
+            
+            # 计算本次初始化的目标函数值
+            inertia = self._compute_inertia(X, labels, centers)
+            
+            # 保留最优结果
+            if inertia < best_inertia:
+                best_inertia = inertia
+                best_centers = centers.copy()
+                best_labels = labels.copy()
+        
+        # 存储最优结果
+        self.cluster_centers_ = best_centers
+        self.labels_ = best_labels
+        self.inertia_ = best_inertia
+        
+        return self
+    
+    def predict(self, X):
+        """
+        预测新样本所属的簇
+        
+        根据训练得到的簇中心，将新样本分配到最近的簇
+        """
+        return self._assign_clusters(X, self.cluster_centers_)