How to use

DecisionTree

in

smile.classification

  @Override
  public DecisionTree train(double[][] x, int[] y) {
    return new DecisionTree(attributes, x, y, maxNodes, nodeSize, rule);
  }
}

  @Override
  int predictFromModel(double[] data) {
    return classifierModel.predict(data);
  }
}

/**
 * Returns the maximum depth" of the tree -- the number of
 * nodes along the longest path from the root node
 * down to the farthest leaf node.*/
public int maxDepth() {
  return maxDepth(root);
}

trees[t] = new DecisionTree(attributes, x, y, maxNodes, 1, x[0].length, DecisionTree.SplitRule.GINI, samples, order);
  err[i] = trees[t].predict(x[i]) != y[i];
double[] imp = tree.importance();
for (int i = 0; i < imp.length; i++) {
  importance[i] += imp[i];

DecisionTree tree = new DecisionTree(attributes, x, y, maxNodes, nodeSize, mtry, rule, samples.clone(), order);
  if (samples[i] == 0) {
    oob++;
    int p = tree.predict(x[i]);
    if (p == y[i]) correct++;
    synchronized (prediction[i]) {

double[] imp = tree.tree.importance();
for (int i = 0; i < imp.length; i++) {
  importance[i] += imp[i];

public int predict(double[] data) {
  return classifierModel.predict(data);
}

private DecisionTree(int maxNodes, int[] classArray, NumericColumn... columns) {
  double[][] data = DoubleArrays.to2dArray(columns);
  this.classifierModel = new smile.classification.DecisionTree(data, classArray, maxNodes);
}

private int maxDepth(Node node) {
  if (node == null)
    return 0;
  // compute the depth of each subtree
  int lDepth = maxDepth(node.trueChild);
  int rDepth = maxDepth(node.falseChild);
  // use the larger one
  if (lDepth > rDepth)
    return (lDepth + 1);
  else
    return (rDepth + 1);
}

@Override
public int predict(double[] x) {
  double[] y = new double[k];
  for (int i = 0; i < trees.length; i++) {
    y[trees[i].predict(x)] += alpha[i];
  }
    
  return Math.whichMax(y);
}

@Override
public int predict(double[] x) {
  int[] y = new int[k];
  
  for (Tree tree : trees) {
    y[tree.tree.predict(x)]++;
  }
  
  return Math.whichMax(y);
}

@Override
public int predict(double[] x, double[] posteriori) {
  if (posteriori.length != k) {
    throw new IllegalArgumentException(String.format("Invalid posteriori vector size: %d, expected: %d", posteriori.length, k));
  }
  Arrays.fill(posteriori, 0.0);
  int[] y = new int[k];
  double[] pos = new double[k];
  for (Tree tree : trees) {
    y[tree.tree.predict(x, pos)]++;
    for (int i = 0; i < k; i++) {
      posteriori[i] += tree.weight * pos[i];
    }
  }
  Math.unitize1(posteriori);
  return Math.whichMax(y);
}    

/**
 * Predicts the class label of an instance and also calculate a posteriori
 * probabilities. Not supported.
 */
@Override
public int predict(double[] x, double[] posteriori) {
  Arrays.fill(posteriori, 0.0);
  for (int i = 0; i < trees.length; i++) {
    posteriori[trees[i].predict(x)] += alpha[i];
  }
  double sum = Math.sum(posteriori);
  for (int i = 0; i < k; i++) {
    posteriori[i] /= sum;
  }
  return Math.whichMax(posteriori);
}

/**
 * Test the model on a validation dataset.
 * 
 * @param x the test data set.
 * @param y the test data labels.
 * @param measures the performance measures of classification.
 * @return performance measures with first 1, 2, ..., decision trees.
 */
public double[][] test(double[][] x, int[] y, ClassificationMeasure[] measures) {
  int T = trees.size();
  int m = measures.length;
  double[][] results = new double[T][m];
  int n = x.length;
  int[] label = new int[n];
  double[][] prediction = new double[n][k];
  for (int i = 0; i < T; i++) {
    for (int j = 0; j < n; j++) {
      prediction[j][trees.get(i).tree.predict(x[j])]++;
      label[j] = Math.whichMax(prediction[j]);
    }
    for (int j = 0; j < m; j++) {
      results[i][j] = measures[j].measure(y, label);
    }
  }
  return results;
}

/**
 * Test the model on a validation dataset.
 * 
 * @param x the test data set.
 * @param y the test data response values.
 * @return accuracies with first 1, 2, ..., decision trees.
 */
public double[] test(double[][] x, int[] y) {
  int T = trees.size();
  double[] accuracy = new double[T];
  int n = x.length;
  int[] label = new int[n];
  int[][] prediction = new int[n][k];
  Accuracy measure = new Accuracy();
  
  for (int i = 0; i < T; i++) {
    for (int j = 0; j < n; j++) {
      prediction[j][trees.get(i).tree.predict(x[j])]++;
      label[j] = Math.whichMax(prediction[j]);
    }
    accuracy[i] = measure.measure(y, label);
  }
  return accuracy;
}

for (int i = 0; i < T; i++) {
  for (int j = 0; j < n; j++) {
    prediction[j] += alpha[i] * trees[i].predict(x[j]);
    label[j] = prediction[j] > 0 ? 1 : 0;
for (int i = 0; i < T; i++) {
  for (int j = 0; j < n; j++) {
    prediction[j][trees[i].predict(x[j])] += alpha[i];
    label[j] = Math.whichMax(prediction[j]);

for (int i = 0; i < T; i++) {
  for (int j = 0; j < n; j++) {
    prediction[j] += alpha[i] * trees[i].predict(x[j]);
    label[j] = prediction[j] > 0 ? 1 : 0;
for (int i = 0; i < T; i++) {
  for (int j = 0; j < n; j++) {
    prediction[j][trees[i].predict(x[j])] += alpha[i];
    label[j] = Math.whichMax(prediction[j]);