用随机森林进行回归gbdt多分类用java实现

以下是使用Java实现随机森林进行回归的示例代码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class RandomForestRegressor {
    private final int numTrees;
    private final int maxDepth;
    private final int minSamplesSplit;
    private final int minSamplesLeaf;
    private final List<DecisionTreeRegressor> trees;

    public RandomForestRegressor(int numTrees, int maxDepth, int minSamplesSplit, int minSamplesLeaf) {
        this.numTrees = numTrees;
        this.maxDepth = maxDepth;
        this.minSamplesSplit = minSamplesSplit;
        this.minSamplesLeaf = minSamplesLeaf;
        this.trees = new ArrayList<>(numTrees);
    }

    public void fit(List<double[]> X, List<Double> y) {
        for (int i = 0; i < numTrees; i++) {
            List<double[]> XTrain = new ArrayList<>(X.size());
            List<Double> yTrain = new ArrayList<>(y.size());

            // Bootstrap sampling
            Random rand = new Random();
            for (int j = 0; j < X.size(); j++) {
                int idx = rand.nextInt(X.size());
                XTrain.add(X.get(idx));
                yTrain.add(y.get(idx));
            }

            DecisionTreeRegressor tree = new DecisionTreeRegressor(maxDepth, minSamplesSplit, minSamplesLeaf);
            tree.fit(XTrain, yTrain);
            trees.add(tree);
        }
    }

    public double predict(double[] X) {
        List<Double> predictions = new ArrayList<>(numTrees);
        for (DecisionTreeRegressor tree : trees) {
            predictions.add(tree.predict(X));
        }
        return Collections.max(predictions); // Return the maximum prediction
    }
}

以下是使用Java实现GBDT进行回归的示例代码：

import java.util.ArrayList;
import java.util.List;

public class GradientBoostingRegressor {
    private final int numTrees;
    private final double learningRate;
    private final List<RegressionTree> trees;

    public GradientBoostingRegressor(int numTrees, double learningRate) {
        this.numTrees = numTrees;
        this.learningRate = learningRate;
        this.trees = new ArrayList<>(numTrees);
    }

    public void fit(List<double[]> X, List<Double> y) {
        List<Double> yPred = new ArrayList<>(y);
        for (int i = 0; i < numTrees; i++) {
            RegressionTree tree = new RegressionTree();
            tree.fit(X, yPred);
            trees.add(tree);

            List<Double> yPredNew = new ArrayList<>(y.size());
            for (int j = 0; j < y.size(); j++) {
                double[] x = X.get(j);
                double pred = tree.predict(x);
                yPredNew.add(yPred.get(j) - learningRate * pred);
            }
            yPred = yPredNew;
        }
    }

    public double predict(double[] X) {
        double pred = 0;
        for (RegressionTree tree : trees) {
            pred += learningRate * tree.predict(X);
        }
        return pred;
    }
}

以下是使用Java实现多分类的示例代码：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class RandomForestClassifier {
    private final int numTrees;
    private final int maxDepth;
    private final int minSamplesSplit;
    private final int minSamplesLeaf;
    private final List<DecisionTreeClassifier> trees;

    public RandomForestClassifier(int numTrees, int maxDepth, int minSamplesSplit, int minSamplesLeaf) {
        this.numTrees = numTrees;
        this.maxDepth = maxDepth;
        this.minSamplesSplit = minSamplesSplit;
        this.minSamplesLeaf = minSamplesLeaf;
        this.trees = new ArrayList<>(numTrees);
    }

    public void fit(List<double[]> X, List<Integer> y) {
        for (int i = 0; i < numTrees; i++) {
            List<double[]> XTrain = new ArrayList<>(X.size());
            List<Integer> yTrain = new ArrayList<>(y.size());

            // Bootstrap sampling
            Random rand = new Random();
            for (int j = 0; j < X.size(); j++) {
                int idx = rand.nextInt(X.size());
                XTrain.add(X.get(idx));
                yTrain.add(y.get(idx));
            }

            DecisionTreeClassifier tree = new DecisionTreeClassifier(maxDepth, minSamplesSplit, minSamplesLeaf);
            tree.fit(XTrain, yTrain);
            trees.add(tree);
        }
    }

    public int predict(double[] X) {
        Map<Integer, Integer> votes = new HashMap<>();
        for (DecisionTreeClassifier tree : trees) {
            int pred = tree.predict(X);
            votes.put(pred, votes.getOrDefault(pred, 0) + 1);
        }
        int maxVotes = 0;
        int predClass = -1;
        for (Map.Entry<Integer, Integer> entry : votes.entrySet()) {
            if (entry.getValue() > maxVotes) {
                maxVotes = entry.getValue();
                predClass = entry.getKey();
            }
        }
        return predClass;
    }
}
``