机器学习算法：弱分类器中决策桩（Decision Stump）原理、手动计算与Python/Java双代码实战

if (特征_i <= 阈值_t):
    预测 = A
else:
    预测 = B

import numpy as np

class DecisionStump:
    def __init__(self):
        self.feature_idx = None
        self.threshold = None
        self.polarity = 1  # 1 表示 <= 为正类，-1 表示 > 为正类
        self.alpha = None  # AdaBoost 权重

    def fit(self, X, y, sample_weights):
        n_samples, n_features = X.shape
        min_error = float('inf')

        # 尝试每个特征
        for feat in range(n_features):
            feature_vals = X[:, feat]
            thresholds = np.unique(feature_vals)
            
            # 尝试每个阈值
            for t in thresholds:
                # 两种极性：<= 为正 或 > 为正
                for polarity in [1, -1]:
                    pred = np.ones(n_samples)
                    if polarity == 1:
                        pred[feature_vals <= t] = -1
                    else:
                        pred[feature_vals > t] = -1
                    
                    error = np.sum(sample_weights[pred != y])
                    
                    if error < min_error:
                        min_error = error
                        self.feature_idx = feat
                        self.threshold = t
                        self.polarity = polarity
        
        # 避免除零
        if min_error == 0:
            min_error = 1e-10
        elif min_error == 1:
            min_error = 1 - 1e-10

        # 计算桩的权重（用于AdaBoost）
        self.alpha = 0.5 * np.log((1 - min_error) / min_error)

    def predict(self, X):
        n_samples = X.shape[0]
        pred = np.ones(n_samples)
        if self.polarity == 1:
            pred[X[:, self.feature_idx] <= self.threshold] = -1
        else:
            pred[X[:, self.feature_idx] > self.threshold] = -1
        return pred

# === AdaBoost with Decision Stumps ===
class AdaBoost:
    def __init__(self, n_stumps=10):
        self.n_stumps = n_stumps
        self.stumps = []

    def fit(self, X, y):
        n_samples = X.shape[0]
        weights = np.full(n_samples, 1 / n_samples)

        for _ in range(self.n_stumps):
            stump = DecisionStump()
            stump.fit(X, y, weights)
            pred = stump.predict(X)

            # 更新样本权重
            correctness = (pred == y)
            weights *= np.exp(-stump.alpha * correctness.astype(int))
            weights /= np.sum(weights)  # 归一化

            self.stumps.append(stump)

    def predict(self, X):
        stump_preds = np.array([stump.alpha * stump.predict(X) for stump in self.stumps])
        return np.sign(np.sum(stump_preds, axis=0))

# 测试
X = np.array([[1,2], [2,3], [3,1], [4,4], [5,2]])
y = np.array([1, -1, -1, 1, 1])  # +1/-1

ada = AdaBoost(n_stumps=3)
ada.fit(X, y)
print("预测:", ada.predict(X))  # 应接近 [1, -1, -1, 1, 1]

public class DecisionStump {
    private int featureIndex;
    private double threshold;
    private int polarity; // 1 or -1
    private double alpha;

    public void fit(double[][] X, int[] y, double[] weights) {
        int nSamples = X.length;
        int nFeatures = X[0].length;
        double minError = Double.MAX_VALUE;

        for (int f = 0; f < nFeatures; f++) {
            // 获取特征列并去重
            java.util.Set<Double> uniqueVals = new java.util.HashSet<>();
            for (double[] row : X) uniqueVals.add(row[f]);
            Double[] thresholds = uniqueVals.toArray(new Double[0]);

            for (double t : thresholds) {
                for (int pol : new int[]{1, -1}) {
                    int[] pred = new int[nSamples];
                    java.util.Arrays.fill(pred, 1);
                    for (int i = 0; i < nSamples; i++) {
                        if ((pol == 1 && X[i][f] <= t) || (pol == -1 && X[i][f] > t)) {
                            pred[i] = -1;
                        }
                    }

                    double error = 0.0;
                    for (int i = 0; i < nSamples; i++) {
                        if (pred[i] != y[i]) error += weights[i];
                    }

                    if (error < minError) {
                        minError = error;
                        featureIndex = f;
                        threshold = t;
                        polarity = pol;
                    }
                }
            }
        }

        // 防止数值问题
        if (minError == 0) minError = 1e-10;
        if (minError == 1) minError = 1 - 1e-10;
        alpha = 0.5 * Math.log((1 - minError) / minError);
    }

    public int[] predict(double[][] X) {
        int n = X.length;
        int[] pred = new int[n];
        java.util.Arrays.fill(pred, 1);
        for (int i = 0; i < n; i++) {
            if ((polarity == 1 && X[i][featureIndex] <= threshold) ||
                (polarity == -1 && X[i][featureIndex] > threshold)) {
                pred[i] = -1;
            }
        }
        return pred;
    }

    public double getAlpha() { return alpha; }
}