🥮 mooncakes.io

    decision-tree

    Deterministic classification and regression decision trees for MoonBit

    machine-learning
    decision-tree
    classification
    regression
    Download zip
    Version
    0.2.0
    License
    Apache-2.0
    Repository
    Last updated
    3 months ago
    Downloads
    39

    No dependencies

    #MoonBit Decision Tree

    A deterministic decision-tree library written in MoonBit for dense, finite numeric datasets. The current release trains classification and regression trees with optional per-row sample weights, predicts single rows or batches, reports metrics and model structure, performs deterministic validation and configuration selection, applies cost-complexity pruning, diagnoses feature effects, and exports unweighted trees as text, JSON, or Graphviz DOT.

    #Installation

    Install the published 0.2.0 package from Mooncakes:

    moon add chenzexin02-hash/decision-tree

    Import it from moon.pkg:

    import {
      "chenzexin02-hash/decision-tree" @tree,
    }

    For source development, clone the repository and run the verification commands below.

    #Classification

    let dataset = @tree.classification_dataset(
      [[0.0], [1.0], [2.0], [3.0]],
      [0, 0, 1, 1],
      2,
    ).unwrap()
    let model = @tree.train_classifier(
      dataset,
      @tree.ClassificationConfig::default(),
    ).unwrap()
    let label = model.predict([2.5]).unwrap()
    let probabilities = model.predict_proba([2.5]).unwrap()

    Classification supports Gini and entropy criteria. Equal-gain splits are resolved by feature index and then by sorted threshold order. A leaf predicts the lowest class index among tied class counts.

    #Regression

    let dataset = @tree.regression_dataset(
      [[0.0], [1.0], [2.0], [3.0]],
      [0.0, 2.0, 4.0, 6.0],
    ).unwrap()
    let model = @tree.train_regressor(
      dataset,
      @tree.RegressionConfig::default(),
    ).unwrap()
    let prediction = model.predict([2.5]).unwrap()

    Regression splits minimize weighted population variance and leaves predict their training-target mean.

    #Sample-Weighted Training

    weighted_classification_dataset and weighted_regression_dataset accept one finite, nonnegative weight per row and require a positive total weight. Their typed training functions use weighted impurity or variance reduction and return independent weighted model types with prediction, batch prediction, depth, node and leaf counts, decision paths, and normalized feature importance. Weighted accuracy, mean squared error, and mean absolute error helpers are also provided.

    #Training Controls

    Both model types expose explicit configuration for maximum depth, minimum samples required to split, minimum samples in each leaf, and minimum impurity decrease. Classification also selects Gini or entropy. Invalid configuration and malformed datasets return typed TreeError values.

    #Evaluation and Inspection

    Implemented evaluation functions:

    • classification accuracy and confusion matrix;
    • mean squared error, mean absolute error, root mean squared error, and R-squared;
    • deterministic K-fold and stratified K-fold index generation;
    • classification and regression cross-validation summaries;
    • repeated cross-validation with mean, standard deviation, minimum, and maximum summaries;
    • validation-based selection from caller-supplied cost-complexity pruning strengths.

    Trained models expose tree depth, node count, leaf count, normalized impurity-based feature importance, and the decision path for one row. prune(alpha) returns a new cost-complexity-pruned model and leaves the source model unchanged.

    classification_report provides per-class precision, recall, specificity and F1 plus macro and support-weighted aggregates. Probability outputs can be evaluated with multiclass Brier score and log loss. regression_report combines MSE, MAE, RMSE, R-squared, maximum error, mean signed error and explained variance.

    Configuration grids and select_classifier / select_regressor evaluate candidates through deterministic cross-validation. pruning_path returns distinct models at increasing cost-complexity strengths. Prediction explanations include the stable leaf ID, path, leaf statistics and confidence or variance; rules extracts every leaf as structured conditions.

    Permutation importance measures validation-score degradation after deterministic feature rotation. Partial-dependence APIs average class probabilities or regression predictions at caller-supplied feature values.

    #Export

    to_text, to_json, and to_dot require feature names; classification export also requires class names. Name counts are validated. JSON and DOT labels escape quotes, backslashes, and control whitespace. Exports retain split features, thresholds, predictions, sample counts, impurity or variance, and child structure.

    #Runnable Examples

    moon run examples/classification
moon run examples/regression
moon run examples/validation
moon run examples/export
moon run examples/weighted

    The examples use only public APIs and are executed by CI.

    #Verification

    moon clean
moon fmt --check
moon info
moon check --deny-warn
moon build
moon test
moon run examples/classification
moon run examples/regression
moon run examples/validation
moon run examples/export
moon run examples/weighted
powershell -NoProfile -ExecutionPolicy Bypass -File scripts/source-audit.ps1
moon publish --dry-run

    At the repository state documented for 0.2.0, moon test runs 70 tests. The source-audit script reports physical and substantive production/test lines separately and rejects placeholder markers in MoonBit source.

    #Current Scope

    The current release accepts only non-empty dense numeric rows with finite values. Class labels are zero-based integers, and classification requires an explicit class count. Models and datasets are in-memory MoonBit values.

    Categorical feature handling, missing-value policies, ensembles, incremental or multi-output learning, persistence import, and performance benchmarking remain candidates for later releases. Version 0.2.0 does not claim those capabilities. Network services, databases, and parallel or distributed training are outside the current package implementation.

    #Project Status

    This is an original MoonBit implementation, not a line-by-line port. Standard decision-tree concepts and evaluation definitions are listed in docs/references.md. Implementation evidence and acceptance commands are recorded in docs/development-report.md and docs/acceptance-checklist.md.

    Licensed under the Apache License 2.0.

    ClassMetrics

    source
    pub(all) struct ClassMetrics {
      class_index : Int
      support : Int
      true_positive : Int
      false_positive : Int
      false_negative : Int
      true_negative : Int
      precision : Double
      recall : Double
      specificity : Double
      f1 : Double
    } derive(Eq, 
    Debug    )

    ClassificationCandidate

    source
    pub(all) struct ClassificationCandidate {
      config : ClassificationConfig
      mean_accuracy : Double
    } derive(Eq, 
    Debug    )

    ClassificationConfig

    source
    pub(all) struct ClassificationConfig {
      max_depth : Int
      min_samples_split : Int
      min_samples_leaf : Int
      min_impurity_decrease : Double
      criterion : ClassificationCriterion
    } derive(Eq, 
    Debug    )

    Configures deterministic classification-tree training.

    ClassificationConfig::default

    source

    ClassificationCriterion

    source
    pub(all) enum ClassificationCriterion {
      Gini
      Entropy
    } derive(Eq, 
    Debug    )

    Selects the impurity measure used for classification splits.

    ClassificationDataset

    source
    pub(all) struct ClassificationDataset {
      rows : Array[Array[Double]]
      labels : Array[Int]
      feature_total : Int
      class_total : Int
    } derive(Eq, 
    Debug    )

    Stores validated dense numeric rows and integer class labels.

    ClassificationDataset::class_count

    source
    fn ClassificationDataset::class_count(self : ClassificationDataset) -> Int

    ClassificationDataset::feature_count

    source
    fn ClassificationDataset::feature_count(self : ClassificationDataset) -> Int

    ClassificationDataset::label

    source
    fn ClassificationDataset::label(self : ClassificationDataset, index : Int) -> Int

    ClassificationDataset::row

    source
    fn ClassificationDataset::row(self : ClassificationDataset, index : Int) -> Array[Double]

    ClassificationDataset::row_count

    source
    fn ClassificationDataset::row_count(self : ClassificationDataset) -> Int

    ClassificationExplanation

    source
    pub(all) struct ClassificationExplanation {
      prediction : Int
      probabilities : Array[Double]
      confidence : Double
      leaf_id : Int
      leaf_samples : Int
      leaf_impurity : Double
      path : Array[DecisionStep]
    } derive(Eq, 
    Debug    )

    ClassificationNode

    source
    pub(all) enum ClassificationNode {
      ClassificationLeaf(Int, Array[Double], Int, Double)
      ClassificationBranch(Int, Double, ClassificationNode, ClassificationNode, Int, Double, Double)
    } derive(Eq, 
    Debug    )

    Retains all statistics needed for prediction, export, and pruning.

    ClassificationPartialDependence

    source
    pub(all) struct ClassificationPartialDependence {
      feature_index : Int
      values : Array[Double]
      average_probabilities : Array[Array[Double]]
    } derive(Eq, 
    Debug    )

    ClassificationPruningCandidate

    source
    pub(all) struct ClassificationPruningCandidate {
      alpha : Double
      mean_accuracy : Double
      node_count : Int
      leaf_count : Int
    } derive(Eq, 
    Debug    )

    ClassificationPruningSelection

    source
    pub(all) struct ClassificationPruningSelection {
      best_alpha : Double
      best_accuracy : Double
      model : ClassificationTree
      candidates : Array[ClassificationPruningCandidate]
    } derive(Eq, 
    Debug    )

    ClassificationPruningStep

    source
    pub(all) struct ClassificationPruningStep {
      alpha : Double
      model : ClassificationTree
      node_count : Int
      leaf_count : Int
    } derive(Eq, 
    Debug    )

    ClassificationReport

    source
    pub(all) struct ClassificationReport {
      accuracy : Double
      macro_precision : Double
      macro_recall : Double
      macro_f1 : Double
      weighted_precision : Double
      weighted_recall : Double
      weighted_f1 : Double
      classes : Array[ClassMetrics]
    } derive(Eq, 
    Debug    )

    ClassificationRule

    source
    pub(all) struct ClassificationRule {
      leaf_id : Int
      conditions : Array[RuleCondition]
      prediction : Int
      probabilities : Array[Double]
      samples : Int
      impurity : Double
    } derive(Eq, 
    Debug    )

    ClassificationSelection

    source
    pub(all) struct ClassificationSelection {
      best_config : ClassificationConfig
      best_accuracy : Double
      candidates : Array[ClassificationCandidate]
    } derive(Eq, 
    Debug    )

    ClassificationTree

    source
    pub(all) struct ClassificationTree {
      root : ClassificationNode
      feature_total : Int
      class_total : Int
      config : ClassificationConfig
    } derive(Eq, 
    Debug    )

    Stores one immutable trained classification tree.

    ClassificationTree::apply

    source
    fn ClassificationTree::apply(self : ClassificationTree, features : Array[Double]) -> Result[Int, TreeError]

    ClassificationTree::apply_batch

    source
    fn ClassificationTree::apply_batch(self : ClassificationTree, rows : Array[Array[Double]]) -> Result[Array[Int], TreeError]

    ClassificationTree::decision_path

    source
    fn ClassificationTree::decision_path(self : ClassificationTree, features : Array[Double]) -> Result[Array[DecisionStep], TreeError]

    ClassificationTree::depth

    source
    fn ClassificationTree::depth(self : ClassificationTree) -> Int

    ClassificationTree::explain

    source
    fn ClassificationTree::explain(self : ClassificationTree, features : Array[Double]) -> Result[ClassificationExplanation, TreeError]

    ClassificationTree::feature_importance

    source
    fn ClassificationTree::feature_importance(self : ClassificationTree) -> Array[Double]

    ClassificationTree::leaf_count

    source
    fn ClassificationTree::leaf_count(self : ClassificationTree) -> Int

    ClassificationTree::node_count

    source
    fn ClassificationTree::node_count(self : ClassificationTree) -> Int

    ClassificationTree::predict

    source
    fn ClassificationTree::predict(self : ClassificationTree, features : Array[Double]) -> Result[Int, TreeError]

    ClassificationTree::predict_batch

    source
    fn ClassificationTree::predict_batch(self : ClassificationTree, rows : Array[Array[Double]]) -> Result[Array[Int], TreeError]

    ClassificationTree::predict_proba

    source
    fn ClassificationTree::predict_proba(self : ClassificationTree, features : Array[Double]) -> Result[Array[Double], TreeError]

    ClassificationTree::prune

    source
    fn ClassificationTree::prune(self : ClassificationTree, alpha : Double) -> Result[ClassificationTree, TreeError]

    Returns a pruned copy using leaf-risk plus alpha times leaf count.

    ClassificationTree::pruning_path

    source

    Generates distinct models at increasing cost-complexity strengths.

    ClassificationTree::rules

    source

    ClassificationTree::to_dot

    source
    fn ClassificationTree::to_dot(self : ClassificationTree, feature_names : Array[String], class_names : Array[String]) -> Result[String, TreeError]

    ClassificationTree::to_json

    source
    fn ClassificationTree::to_json(self : ClassificationTree, feature_names : Array[String], class_names : Array[String]) -> Result[String, TreeError]

    ClassificationTree::to_text

    source
    fn ClassificationTree::to_text(self : ClassificationTree, feature_names : Array[String], class_names : Array[String]) -> Result[String, TreeError]

    ClassificationValidation

    source
    pub(all) struct ClassificationValidation {
      fold_scores : Array[Double]
      mean_accuracy : Double
    } derive(Eq, 
    Debug    )

    DecisionDirection

    source
    pub(all) enum DecisionDirection {
      GoLeft
      GoRight
    } derive(Eq, 
    Debug    )

    DecisionStep

    source
    pub(all) enum DecisionStep {
      DecisionStep(Int, Double, DecisionDirection)
    } derive(Eq, 
    Debug    )

    Fold

    source
    pub(all) struct Fold {
      train_indices : Array[Int]
      test_indices : Array[Int]
    } derive(Eq, 
    Debug    )

    RegressionCandidate

    source
    pub(all) struct RegressionCandidate {
      config : RegressionConfig
      mean_mse : Double
      mean_mae : Double
    } derive(Eq, 
    Debug    )

    RegressionConfig

    source
    pub(all) struct RegressionConfig {
      max_depth : Int
      min_samples_split : Int
      min_samples_leaf : Int
      min_impurity_decrease : Double
    } derive(Eq, 
    Debug    )

    Configures deterministic regression-tree training.

    RegressionConfig::default

    source

    RegressionDataset

    source
    pub(all) struct RegressionDataset {
      rows : Array[Array[Double]]
      targets : Array[Double]
      feature_total : Int
    } derive(Eq, 
    Debug    )

    Stores validated dense numeric rows and continuous targets.

    RegressionDataset::feature_count

    source
    fn RegressionDataset::feature_count(self : RegressionDataset) -> Int

    RegressionDataset::row

    source
    fn RegressionDataset::row(self : RegressionDataset, index : Int) -> Array[Double]

    RegressionDataset::row_count

    source
    fn RegressionDataset::row_count(self : RegressionDataset) -> Int

    RegressionDataset::target

    source
    fn RegressionDataset::target(self : RegressionDataset, index : Int) -> Double

    RegressionExplanation

    source
    pub(all) struct RegressionExplanation {
      prediction : Double
      leaf_id : Int
      leaf_samples : Int
      leaf_variance : Double
      path : Array[DecisionStep]
    } derive(Eq, 
    Debug    )

    RegressionNode

    source
    pub(all) enum RegressionNode {
      RegressionLeaf(Double, Int, Double)
      RegressionBranch(Int, Double, RegressionNode, RegressionNode, Int, Double, Double)
    } derive(Eq, 
    Debug    )

    Retains prediction and variance statistics for traversal and pruning.

    RegressionPartialDependence

    source
    pub(all) struct RegressionPartialDependence {
      feature_index : Int
      values : Array[Double]
      average_predictions : Array[Double]
    } derive(Eq, 
    Debug    )

    RegressionPruningCandidate

    source
    pub(all) struct RegressionPruningCandidate {
      alpha : Double
      mean_mse : Double
      mean_mae : Double
      node_count : Int
      leaf_count : Int
    } derive(Eq, 
    Debug    )

    RegressionPruningSelection

    source
    pub(all) struct RegressionPruningSelection {
      best_alpha : Double
      best_mse : Double
      best_mae : Double
      model : RegressionTree
      candidates : Array[RegressionPruningCandidate]
    } derive(Eq, 
    Debug    )

    RegressionPruningStep

    source
    pub(all) struct RegressionPruningStep {
      alpha : Double
      model : RegressionTree
      node_count : Int
      leaf_count : Int
    } derive(Eq, 
    Debug    )

    RegressionReport

    source
    pub(all) struct RegressionReport {
      mse : Double
      mae : Double
      rmse : Double
      r2 : Double
      max_error : Double
      mean_error : Double
      explained_variance : Double
    } derive(Eq, 
    Debug    )

    RegressionRule

    source
    pub(all) struct RegressionRule {
      leaf_id : Int
      conditions : Array[RuleCondition]
      prediction : Double
      samples : Int
      variance : Double
    } derive(Eq, 
    Debug    )

    RegressionSelection

    source
    pub(all) struct RegressionSelection {
      best_config : RegressionConfig
      best_mse : Double
      best_mae : Double
      candidates : Array[RegressionCandidate]
    } derive(Eq, 
    Debug    )

    RegressionTree

    source
    pub(all) struct RegressionTree {
      root : RegressionNode
      feature_total : Int
      config : RegressionConfig
    } derive(Eq, 
    Debug    )

    Stores one immutable trained regression tree.

    RegressionTree::apply

    source
    fn RegressionTree::apply(self : RegressionTree, features : Array[Double]) -> Result[Int, TreeError]

    RegressionTree::apply_batch

    source
    fn RegressionTree::apply_batch(self : RegressionTree, rows : Array[Array[Double]]) -> Result[Array[Int], TreeError]

    RegressionTree::decision_path

    source
    fn RegressionTree::decision_path(self : RegressionTree, features : Array[Double]) -> Result[Array[DecisionStep], TreeError]

    RegressionTree::depth

    source
    fn RegressionTree::depth(self : RegressionTree) -> Int

    RegressionTree::explain

    source
    fn RegressionTree::explain(self : RegressionTree, features : Array[Double]) -> Result[RegressionExplanation, TreeError]

    RegressionTree::feature_importance

    source
    fn RegressionTree::feature_importance(self : RegressionTree) -> Array[Double]

    RegressionTree::leaf_count

    source
    fn RegressionTree::leaf_count(self : RegressionTree) -> Int

    RegressionTree::node_count

    source
    fn RegressionTree::node_count(self : RegressionTree) -> Int

    RegressionTree::predict

    source
    fn RegressionTree::predict(self : RegressionTree, features : Array[Double]) -> Result[Double, TreeError]

    RegressionTree::predict_batch

    source
    fn RegressionTree::predict_batch(self : RegressionTree, rows : Array[Array[Double]]) -> Result[Array[Double], TreeError]

    RegressionTree::prune

    source
    fn RegressionTree::prune(self : RegressionTree, alpha : Double) -> Result[RegressionTree, TreeError]

    Returns a pruned copy using leaf-risk plus alpha times leaf count.

    RegressionTree::pruning_path

    source

    Generates distinct models at increasing cost-complexity strengths.

    RegressionTree::rules

    source

    RegressionTree::to_dot

    source
    fn RegressionTree::to_dot(self : RegressionTree, feature_names : Array[String]) -> Result[String, TreeError]

    RegressionTree::to_json

    source
    fn RegressionTree::to_json(self : RegressionTree, feature_names : Array[String]) -> Result[String, TreeError]

    RegressionTree::to_text

    source
    fn RegressionTree::to_text(self : RegressionTree, feature_names : Array[String]) -> Result[String, TreeError]

    RegressionValidation

    source
    pub(all) struct RegressionValidation {
      fold_mse : Array[Double]
      fold_mae : Array[Double]
      mean_mse : Double
      mean_mae : Double
    } derive(Eq, 
    Debug    )

    RepeatedClassificationValidation

    source
    pub(all) struct RepeatedClassificationValidation {
      repeat_means : Array[Double]
      fold_scores : Array[Double]
      mean_accuracy : Double
      standard_deviation : Double
      minimum_accuracy : Double
      maximum_accuracy : Double
    } derive(Eq, 
    Debug    )

    RepeatedRegressionValidation

    source
    pub(all) struct RepeatedRegressionValidation {
      repeat_mse : Array[Double]
      repeat_mae : Array[Double]
      fold_mse : Array[Double]
      fold_mae : Array[Double]
      mean_mse : Double
      mean_mae : Double
      mse_standard_deviation : Double
      mae_standard_deviation : Double
    } derive(Eq, 
    Debug    )

    RuleCondition

    source
    pub(all) enum RuleCondition {
      RuleCondition(Int, Double, DecisionDirection)
    } derive(Eq, 
    Debug    )

    TreeError

    source
    pub(all) enum TreeError {
      InvalidMaxDepth(Int)
      InvalidMinSamplesSplit(Int)
      InvalidMinSamplesLeaf(Int)
      InvalidMinImpurityDecrease(Double)
      InvalidClassCount(Int)
      EmptyDataset
      EmptyFeatureRow(Int)
      TargetCountMismatch(Int, Int)
      InconsistentFeatureCount(Int, Int, Int)
      InvalidClassLabel(Int, Int, Int)
      NonFiniteFeature(Int, Int)
      NonFiniteTarget(Int)
      PredictionFeatureCountMismatch(Int, Int)
      ModelNotTrained
      InvalidFoldCount(Int, Int)
      InvalidFeatureNameCount(Int, Int)
      InvalidClassNameCount(Int, Int)
      InvalidPruningAlpha(Double)
      MetricLengthMismatch(Int, Int)
      EmptyConfigurationGrid
      InvalidTestCount(Int, Int)
      ProbabilityRowCountMismatch(Int, Int)
      InvalidProbabilityWidth(Int, Int, Int)
      InvalidProbabilityValue(Int, Int)
      InvalidProbabilitySum(Int)
      InvalidFeatureIndex(Int, Int)
      WeightCountMismatch(Int, Int)
      InvalidSampleWeight(Int)
      ZeroTotalWeight
      InvalidRepeatCount(Int)
      EmptyPruningGrid
    } derive(Eq, 
    Debug    )

    Reports invalid input without discarding the value or source position.

    WeightedClassificationDataset

    source
    pub(all) struct WeightedClassificationDataset {
      rows : Array[Array[Double]]
      labels : Array[Int]
      weights : Array[Double]
      feature_total : Int
      class_total : Int
      weight_total : Double
    } derive(Eq, 
    Debug    )

    WeightedClassificationDataset::class_count

    source

    WeightedClassificationDataset::feature_count

    source

    WeightedClassificationDataset::row_count

    source

    WeightedClassificationDataset::total_weight

    source

    WeightedClassificationNode

    source
    pub(all) enum WeightedClassificationNode {
      WeightedClassificationLeaf(Int, Array[Double], Int, Double, Double)
      WeightedClassificationBranch(Int, Double, WeightedClassificationNode, WeightedClassificationNode, Int, Double, Double, Double)
    } derive(Eq, 
    Debug    )

    WeightedClassificationTree

    source
    pub(all) struct WeightedClassificationTree {
      root : WeightedClassificationNode
      feature_total : Int
      class_total : Int
      config : ClassificationConfig
    } derive(Eq, 
    Debug    )

    WeightedClassificationTree::decision_path

    source
    fn WeightedClassificationTree::decision_path(self : WeightedClassificationTree, features : Array[Double]) -> Result[Array[DecisionStep], TreeError]

    WeightedClassificationTree::depth

    source

    WeightedClassificationTree::feature_importance

    source
    fn WeightedClassificationTree::feature_importance(self : WeightedClassificationTree) -> Array[Double]

    WeightedClassificationTree::leaf_count

    source

    WeightedClassificationTree::node_count

    source

    WeightedClassificationTree::predict

    source
    fn WeightedClassificationTree::predict(self : WeightedClassificationTree, features : Array[Double]) -> Result[Int, TreeError]

    WeightedClassificationTree::predict_batch

    source
    fn WeightedClassificationTree::predict_batch(self : WeightedClassificationTree, rows : Array[Array[Double]]) -> Result[Array[Int], TreeError]

    WeightedClassificationTree::predict_proba

    source
    fn WeightedClassificationTree::predict_proba(self : WeightedClassificationTree, features : Array[Double]) -> Result[Array[Double], TreeError]

    WeightedRegressionDataset

    source
    pub(all) struct WeightedRegressionDataset {
      rows : Array[Array[Double]]
      targets : Array[Double]
      weights : Array[Double]
      feature_total : Int
      weight_total : Double
    } derive(Eq, 
    Debug    )

    WeightedRegressionDataset::feature_count

    source
    fn WeightedRegressionDataset::feature_count(self : WeightedRegressionDataset) -> Int

    WeightedRegressionDataset::row_count

    source

    WeightedRegressionDataset::total_weight

    source
    fn WeightedRegressionDataset::total_weight(self : WeightedRegressionDataset) -> Double

    WeightedRegressionNode

    source
    pub(all) enum WeightedRegressionNode {
      WeightedRegressionLeaf(Double, Int, Double, Double)
      WeightedRegressionBranch(Int, Double, WeightedRegressionNode, WeightedRegressionNode, Int, Double, Double, Double)
    } derive(Eq, 
    Debug    )

    WeightedRegressionTree

    source
    pub(all) struct WeightedRegressionTree {
      root : WeightedRegressionNode
      feature_total : Int
      config : RegressionConfig
    } derive(Eq, 
    Debug    )

    WeightedRegressionTree::decision_path

    source
    fn WeightedRegressionTree::decision_path(self : WeightedRegressionTree, features : Array[Double]) -> Result[Array[DecisionStep], TreeError]

    WeightedRegressionTree::depth

    source

    WeightedRegressionTree::feature_importance

    source
    fn WeightedRegressionTree::feature_importance(self : WeightedRegressionTree) -> Array[Double]

    WeightedRegressionTree::leaf_count

    source
    fn WeightedRegressionTree::leaf_count(self : WeightedRegressionTree) -> Int

    WeightedRegressionTree::node_count

    source
    fn WeightedRegressionTree::node_count(self : WeightedRegressionTree) -> Int

    WeightedRegressionTree::predict

    source
    fn WeightedRegressionTree::predict(self : WeightedRegressionTree, features : Array[Double]) -> Result[Double, TreeError]

    WeightedRegressionTree::predict_batch

    source
    fn WeightedRegressionTree::predict_batch(self : WeightedRegressionTree, rows : Array[Array[Double]]) -> Result[Array[Double], TreeError]

    checked_entropy_impurity

    source
    fn checked_entropy_impurity(labels : Array[Int], class_count : Int) -> Result[Double, TreeError]

    Validates labels before calculating entropy impurity.

    checked_gini_impurity

    source
    fn checked_gini_impurity(labels : Array[Int], class_count : Int) -> Result[Double, TreeError]

    Validates labels before calculating Gini impurity.

    classification_accuracy

    source
    fn classification_accuracy(actual : Array[Int], predicted : Array[Int]) -> Result[Double, TreeError]

    classification_config_grid

    source
    fn classification_config_grid(max_depths : Array[Int], min_samples_leaf_values : Array[Int], criteria : Array[ClassificationCriterion]) -> Result[Array[ClassificationConfig], TreeError]

    Builds a validated Cartesian product of classification controls.

    classification_dataset

    source
    fn classification_dataset(rows : Array[Array[Double]], labels : Array[Int], class_count : Int) -> Result[ClassificationDataset, TreeError]

    Validates and copies a classification dataset.

    classification_report

    source
    fn classification_report(actual : Array[Int], predicted : Array[Int], class_count : Int) -> Result[ClassificationReport, TreeError]

    Computes one-vs-rest class metrics and macro/weighted aggregates.

    classifier_partial_dependence

    source
    fn classifier_partial_dependence(model : ClassificationTree, dataset : ClassificationDataset, feature_index : Int, values : Array[Double]) -> Result[ClassificationPartialDependence, TreeError]

    classifier_permutation_importance

    source
    fn classifier_permutation_importance(model : ClassificationTree, dataset : ClassificationDataset, seed : Int) -> Result[Array[Double], TreeError]

    Returns baseline accuracy minus accuracy after deterministic column rotation.

    confusion_matrix

    source
    fn confusion_matrix(actual : Array[Int], predicted : Array[Int], class_count : Int) -> Result[Array[Array[Int]], TreeError]

    Rows are actual classes and columns are predicted classes.

    cross_validate_classifier

    source
    fn cross_validate_classifier(dataset : ClassificationDataset, config : ClassificationConfig, fold_count : Int, seed : Int) -> Result[ClassificationValidation, TreeError]

    cross_validate_regressor

    source
    fn cross_validate_regressor(dataset : RegressionDataset, config : RegressionConfig, fold_count : Int, seed : Int) -> Result[RegressionValidation, TreeError]

    entropy_impurity

    source
    fn entropy_impurity(labels : Array[Int], class_count : Int) -> Double

    gini_impurity

    source
    fn gini_impurity(labels : Array[Int], class_count : Int) -> Double

    holdout_indices

    source
    fn holdout_indices(row_count : Int, test_count : Int, seed : Int) -> Result[Fold, TreeError]

    Selects a contiguous seed-rotated test segment and sorted training indices.

    k_fold_indices

    source
    fn k_fold_indices(row_count : Int, fold_count : Int, seed : Int) -> Result[Array[Fold], TreeError]

    Creates deterministic folds from a seed-controlled cyclic order.

    mean_absolute_error

    source
    fn mean_absolute_error(actual : Array[Double], predicted : Array[Double]) -> Result[Double, TreeError]

    mean_squared_error

    source
    fn mean_squared_error(actual : Array[Double], predicted : Array[Double]) -> Result[Double, TreeError]

    mean_value

    source
    fn mean_value(values : Array[Double]) -> Double

    multiclass_brier_score

    source
    fn multiclass_brier_score(actual : Array[Int], probabilities : Array[Array[Double]], class_count : Int) -> Result[Double, TreeError]

    Returns the mean summed squared probability error per row.

    multiclass_log_loss

    source
    fn multiclass_log_loss(actual : Array[Int], probabilities : Array[Array[Double]], class_count : Int) -> Result[Double, TreeError]

    Computes natural-log loss with probabilities clamped at 1e-15.

    r_squared

    source
    fn r_squared(actual : Array[Double], predicted : Array[Double]) -> Result[Double, TreeError]

    Returns 1 for an exact constant-target prediction and 0 otherwise.

    regression_config_grid

    source
    fn regression_config_grid(max_depths : Array[Int], min_samples_leaf_values : Array[Int]) -> Result[Array[RegressionConfig], TreeError]

    Builds a validated Cartesian product of regression controls.

    regression_dataset

    source
    fn regression_dataset(rows : Array[Array[Double]], targets : Array[Double]) -> Result[RegressionDataset, TreeError]

    Validates and copies a regression dataset.

    regression_report

    source
    fn regression_report(actual : Array[Double], predicted : Array[Double]) -> Result[RegressionReport, TreeError]

    regressor_partial_dependence

    source
    fn regressor_partial_dependence(model : RegressionTree, dataset : RegressionDataset, feature_index : Int, values : Array[Double]) -> Result[RegressionPartialDependence, TreeError]

    regressor_permutation_importance

    source
    fn regressor_permutation_importance(model : RegressionTree, dataset : RegressionDataset, seed : Int) -> Result[Array[Double], TreeError]

    Returns shuffled-feature MSE minus baseline MSE.

    repeated_cross_validate_classifier

    source
    fn repeated_cross_validate_classifier(dataset : ClassificationDataset, config : ClassificationConfig, fold_count : Int, repeat_count : Int, seed : Int) -> Result[RepeatedClassificationValidation, TreeError]

    Repeats stratified cross-validation with deterministic derived seeds.

    repeated_cross_validate_regressor

    source
    fn repeated_cross_validate_regressor(dataset : RegressionDataset, config : RegressionConfig, fold_count : Int, repeat_count : Int, seed : Int) -> Result[RepeatedRegressionValidation, TreeError]

    Repeats regression cross-validation with deterministic derived seeds.

    root_mean_squared_error

    source
    fn root_mean_squared_error(actual : Array[Double], predicted : Array[Double]) -> Result[Double, TreeError]

    select_classifier

    source
    fn select_classifier(dataset : ClassificationDataset, configs : Array[ClassificationConfig], fold_count : Int, seed : Int) -> Result[ClassificationSelection, TreeError]

    Evaluates candidates in input order and keeps the first score tie.

    select_classifier_pruning_alpha

    source
    fn select_classifier_pruning_alpha(dataset : ClassificationDataset, config : ClassificationConfig, alphas : Array[Double], fold_count : Int, seed : Int) -> Result[ClassificationPruningSelection, TreeError]

    Selects alpha by mean validation accuracy, then by fewer full-data nodes.

    select_regressor

    source
    fn select_regressor(dataset : RegressionDataset, configs : Array[RegressionConfig], fold_count : Int, seed : Int) -> Result[RegressionSelection, TreeError]

    Evaluates candidates in input order and keeps the first MSE tie.

    select_regressor_pruning_alpha

    source
    fn select_regressor_pruning_alpha(dataset : RegressionDataset, config : RegressionConfig, alphas : Array[Double], fold_count : Int, seed : Int) -> Result[RegressionPruningSelection, TreeError]

    Selects alpha by mean validation MSE, then by fewer full-data nodes.

    stratified_k_fold_indices

    source
    fn stratified_k_fold_indices(labels : Array[Int], class_count : Int, fold_count : Int, seed : Int) -> Result[Array[Fold], TreeError]

    Distributes each class round-robin while retaining deterministic order.

    train_classifier

    source
    fn train_classifier(dataset : ClassificationDataset, config : ClassificationConfig) -> Result[ClassificationTree, TreeError]

    Trains one deterministic classification tree.

    train_regressor

    source
    fn train_regressor(dataset : RegressionDataset, config : RegressionConfig) -> Result[RegressionTree, TreeError]

    Trains one deterministic regression tree.

    train_weighted_classifier

    source
    fn train_weighted_classifier(dataset : WeightedClassificationDataset, config : ClassificationConfig) -> Result[WeightedClassificationTree, TreeError]

    train_weighted_regressor

    source
    fn train_weighted_regressor(dataset : WeightedRegressionDataset, config : RegressionConfig) -> Result[WeightedRegressionTree, TreeError]

    variance_value

    source
    fn variance_value(values : Array[Double]) -> Double

    weighted_classification_accuracy

    source
    fn weighted_classification_accuracy(actual : Array[Int], predicted : Array[Int], weights : Array[Double]) -> Result[Double, TreeError]

    weighted_classification_dataset

    source
    fn weighted_classification_dataset(rows : Array[Array[Double]], labels : Array[Int], weights : Array[Double], class_count : Int) -> Result[WeightedClassificationDataset, TreeError]

    weighted_mean_absolute_error

    source
    fn weighted_mean_absolute_error(actual : Array[Double], predicted : Array[Double], weights : Array[Double]) -> Result[Double, TreeError]

    weighted_mean_squared_error

    source
    fn weighted_mean_squared_error(actual : Array[Double], predicted : Array[Double], weights : Array[Double]) -> Result[Double, TreeError]

    weighted_regression_dataset

    source
    fn weighted_regression_dataset(rows : Array[Array[Double]], targets : Array[Double], weights : Array[Double]) -> Result[WeightedRegressionDataset, TreeError]

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io