算法之随机森林算法：群体智慧的森林法则

import java.util.*;

public class RandomForest {
    private List<DecisionTree> trees;
    private int numTrees;
    private int maxDepth;
    private int maxFeatures;

    public RandomForest(int numTrees, int maxDepth, int maxFeatures) {
        this.numTrees = numTrees;
        this.maxDepth = maxDepth;
        this.maxFeatures = maxFeatures;
        this.trees = new ArrayList<>();
    }

    // 训练森林
    public void train(double[][] X, int[] y) {
        for (int i = 0; i < numTrees; i++) {
            // 1. Bootstrap采样
            int[][] sample = bootstrapSample(X, y);
            
            // 2. 构建决策树
            DecisionTree tree = new DecisionTree(maxDepth, maxFeatures);
            tree.train(sample[0], sample[1]);
            trees.add(tree);
        }
    }

    // 预测（多数投票）
    public int predict(double[] x) {
        Map<Integer, Integer> votes = new HashMap<>();
        for (DecisionTree tree : trees) {
            int pred = tree.predict(x);
            votes.put(pred, votes.getOrDefault(pred, 0) + 1);
        }
        return Collections.max(votes.entrySet(), Map.Entry.comparingByValue()).getKey();
    }

    // 生成Bootstrap样本
    private int[][] bootstrapSample(double[][] X, int[] y) {
        int n = X.length;
        double[][] X_sample = new double[n][];
        int[] y_sample = new int[n];
        Random rand = new Random();
        
        for (int i = 0; i < n; i++) {
            int idx = rand.nextInt(n);
            X_sample[i] = X[idx];
            y_sample[i] = y[idx];
        }
        return new int[][]{X_sample, y_sample};
    }

    public static void main(String[] args) {
        // 示例数据：花瓣长度、宽度 -> 鸢尾花种类
        double[][] X = {{5.1, 3.5}, {6.2, 2.8}, {4.9, 3.0}};
        int[] y = {0, 1, 0}; // 0=setosa, 1=versicolor
        
        RandomForest rf = new RandomForest(100, 5, 1);
        rf.train(X, y);
        System.out.println(rf.predict(new double[]{5.4, 3.2})); // 输出0
    }
}

// 简化的决策树节点
class DecisionTree {
    // 实际需实现树结构、特征选择、分裂逻辑等
    public int predict(double[] x) { return 0; } 
    public void train(double[][] X, int[] y) {}
}

// 网格搜索寻找最佳参数组合
for (int trees : Arrays.asList(50, 100, 200)) {
    for (int depth : Arrays.asList(5, 10)) {
        RandomForest model = new RandomForest(trees, depth, 3);
        // 交叉验证评估效果
    }
}

// 多线程构建决策树
ExecutorService executor = Executors.newFixedThreadPool(8);
List<Future<DecisionTree>> futures = new ArrayList<>();
for (int i=0; i<numTrees; i++) {
    futures.add(executor.submit(() -> buildTree()));
}

// 跨设备联合训练
public class FederatedForest {
    public void aggregateUpdates(Map<Device, Model> localModels) {
        // 安全聚合各设备模型更新
    }
}