机器学习稳定性基石：深度学习Bagging（Bootstrap Aggregating）算法的原理、手动计算与Python/Java双代码实战

import numpy as np
from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier

class Bagging:
    def __init__(self, base_estimator=None, n_estimators=10, task='regression'):
        self.base_estimator = base_estimator or (
            DecisionTreeRegressor(max_depth=5) if task == 'regression' 
            else DecisionTreeClassifier(max_depth=5)
        )
        self.n_estimators = n_estimators
        self.task = task
        self.estimators = []

    def fit(self, X, y):
        n_samples = X.shape[0]
        self.estimators = []
        
        for _ in range(self.n_estimators):
            # Bootstrap 采样（有放回）
            indices = np.random.choice(n_samples, size=n_samples, replace=True)
            X_boot, y_boot = X[indices], y[indices]
            
            # 训练基模型
            estimator = self.base_estimator
            if hasattr(estimator, 'fit'):
                estimator = self.base_estimator.__class__(**self.base_estimator.get_params())
            estimator.fit(X_boot, y_boot)
            self.estimators.append(estimator)

    def predict(self, X):
        if self.task == 'regression':
            predictions = np.array([est.predict(X) for est in self.estimators])
            return np.mean(predictions, axis=0)
        else:  # classification
            predictions = np.array([est.predict(X) for est in self.estimators])
            # 多数投票
            return np.array([np.bincount(preds).argmax() for preds in predictions.T])

# === 测试回归 ===
X = np.array([[50], [70], [90], [110], [130]])
y = np.array([100, 140, 180, 220, 260])
bag_reg = Bagging(task='regression', n_estimators=3)
bag_reg.fit(X, y)
print("Bagging预测(100):", bag_reg.predict())  # ≈215

# === 测试分类 ===
X_cls = np.array([[1], [2], [3], [4], [5]])
y_cls = np.array([0, 0, 1, 1, 1])
bag_cls = Bagging(task='classification', n_estimators=3)
bag_cls.fit(X_cls, y_cls)
print("Bagging分类(3.5):", bag_cls.predict())  # 应为1

import weka.classifiers.trees.J48;
import weka.core.Instances;
import weka.core.Instance;
import java.util.Random;

public class Bagging {
    private weka.classifiers.Classifier[] models;
    private int numModels;
    private Random rand = new Random();

    public void buildClassifier(Instances data, int numModels) throws Exception {
        this.numModels = numModels;
        models = new weka.classifiers.Classifier[numModels];
        
        for (int i = 0; i < numModels; i++) {
            // Bootstrap 采样
            Instances bootstrap = new Instances(data, data.numInstances());
            for (int j = 0; j < data.numInstances(); j++) {
                int idx = rand.nextInt(data.numInstances());
                bootstrap.add(data.instance(idx));
            }
            
            // 训练基模型（以J48为例）
            J48 tree = new J48();
            tree.buildClassifier(bootstrap);
            models[i] = tree;
        }
    }

    public double[] distributionForInstance(Instance inst) throws Exception {
        double[] avgDist = new double[inst.numClasses()];
        for (weka.classifiers.Classifier model : models) {
            double[] dist = model.distributionForInstance(inst);
            for (int i = 0; i < avgDist.length; i++) {
                avgDist[i] += dist[i];
            }
        }
        // 平均概率分布
        for (int i = 0; i < avgDist.length; i++) {
            avgDist[i] /= numModels;
        }
        return avgDist;
    }

    // 分类预测：取概率最大类
    public double classifyInstance(Instance inst) throws Exception {
        double[] dist = distributionForInstance(inst);
        int bestClass = 0;
        for (int i = 1; i < dist.length; i++) {
            if (dist[i] > dist[bestClass]) bestClass = i;
        }
        return bestClass;
    }
}