Statistically valid explainable black-box machine learning: applications in sex classification across species using brain imaging.

Code ↔ Paper

9 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 9 matches

[1] § Materials and methods › Simulated datasets ↔ treeple/datasets/hyppo.py, lines 428–568 · score 0.74 · identity covariance matrix, Trunk simulation, Gaussian, closer, vector, dimension
[2] § Materials and methods › Oblique random forest ↔ treeple/ensemble/_supervised_forest.py, lines 346–583 · score 0.66 · Sparse Projection Oblique, axis aligned decision, Oblique Random Forest, treeple, traditional, partitions
[3] § Materials and methods › Feature importance testing ↔ examples/sparse_oblique_trees/plot_extra_oblique_random_forest.py, lines 1–78 · score 0.62 · computationally expensive, machine learning, high dimensional, predictions, algorithms, tree
[4] § Results › Hyper-parameter tuning ↔ treeple/ensemble/_supervised_forest.py, lines 645–909 · score 0.61 · max patch dim, OOB score, max_features, split, classification
[5] § Materials and methods › Oblique random forest ↔ yggdrasil_decision_forests/port/python/ydf/learner/specialized_learners_pre_generated.py, lines 53–482 · score 0.60 · cross validation, expensive, overfitting, bag, OOB, bootstrap
[6] § Results › Performance of the sex classifier ↔ yggdrasil_decision_forests/port/python/ydf/metric/display_metric.py, lines 70–185 · score 0.58 · receiver operating characteristic, ROC curves, AUC, volume, thresholds, classifier
[7] § Materials and methods › Feature importance testing ↔ treeple/ensemble/_honest_forest.py, lines 99–449 · score 0.57 · Gini impurity, split nodes, Random Forest, subset, predictions, trees
[8] § Materials and methods › Simulated datasets ↔ treeple/ensemble/_eiforest.py, lines 6–160 · score 0.57 · Gaussian distributions, high dimensional, covariance, sparse, selection, algorithms
[9] § Materials and methods › Feature importance testing ↔ yggdrasil_decision_forests/port/python/ydf/learner/specialized_learners_pre_generated.py, lines 1290–1840 · score 0.51 · model predictions, Additive, machine, global, computationally, permutations

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The paper is loaded by your browser, with JavaScript: read it at doi.org or on Europe PMC.

The authors' code

Python · 1,931 lines · 80 KB · other · 2 matches

from sklearn.utils._param_validation import StrOptions
from .._lib.sklearn.ensemble._forest import ForestClassifier, ForestRegressor
from ..tree import (
ExtraObliqueDecisionTreeClassifier,
ExtraObliqueDecisionTreeRegressor,
ObliqueDecisionTreeClassifier,
ObliqueDecisionTreeRegressor,
PatchObliqueDecisionTreeClassifier,
PatchObliqueDecisionTreeRegressor,
)
from ..tree._neighbors import SimMatrixMixin
from ._extensions import ForestClassifierMixin, ForestMixin
class ObliqueRandomForestClassifier(
SimMatrixMixin, ForestClassifierMixin, ForestMixin, ForestClassifier
):
"""
An oblique random forest classifier.
A oblique random forest is a meta estimator similar to a random
forest that fits a number of oblique decision tree classifiers
on various sub-samples of the dataset and uses averaging to
improve the predictive accuracy and control over-fitting.
The sub-sample size is controlled with the `max_samples` parameter if
`bootstrap=True` (default), otherwise the whole dataset is used to build
each tree.
Read more in the :ref:`User Guide <sklearn:forest>`.
Parameters
----------
n_estimators : int, default=100
The number of trees in the forest.
criterion : {"gini", "entropy"}, default="gini"
The function to measure the quality of a split. Supported criteria are
"gini" for the Gini impurity and "entropy" for the information gain.
Note: this parameter is tree-specific.
max_depth : int, default=None
The maximum depth of the tree. If None, then nodes are expanded until
all leaves are pure or until all leaves contain less than
min_samples_split samples.
min_samples_split : int or float, default=2
The minimum number of samples required to split an internal node:
- If int, then consider `min_samples_split` as the minimum number.
- If float, then `min_samples_split` is a fraction and
`ceil(min_samples_split * n_samples)` are the minimum
number of samples for each split.
min_samples_leaf : int or float, default=1
The minimum number of samples required to be at a leaf node.
A split point at any depth will only be considered if it leaves at
least ``min_samples_leaf`` training samples in each of the left and
right branches. This may have the effect of smoothing the model,
especially in regression.
- If int, then consider `min_samples_leaf` as the minimum number.
- If float, then `min_samples_leaf` is a fraction and
`ceil(min_samples_leaf * n_samples)` are the minimum
number of samples for each node.
min_weight_fraction_leaf : float, default=0.0
The minimum weighted fraction of the sum total of weights (of all
the input samples) required to be at a leaf node. Samples have
equal weight when sample_weight is not provided.
max_features : {"sqrt", "log2", None}, int or float, default="sqrt"
The number of features to consider when looking for the best split:
- If int, then consider `max_features` features at each split.
- If float, then `max_features` is a fraction and
`round(max_features * n_features)` features are considered at each
split.
- If "auto", then `max_features=sqrt(n_features)`.
- If "sqrt", then `max_features=sqrt(n_features)`.
- If "log2", then `max_features=log2(n_features)`.
- If None, then `max_features=n_features`.
Note: the search for a split does not stop until at least one
valid partition of the node samples is found, even if it requires to
effectively inspect more than ``max_features`` features.
max_leaf_nodes : int, default=None
Grow trees with ``max_leaf_nodes`` in best-first fashion.
Best nodes are defined as relative reduction in impurity.
If None then unlimited number of leaf nodes.
min_impurity_decrease : float, default=0.0
A node will be split if this split induces a decrease of the impurity
greater than or equal to this value.
The weighted impurity decrease equation is the following::
N_t / N * (impurity - N_t_R / N_t * right_impurity
- N_t_L / N_t * left_impurity)
where ``N`` is the total number of samples, ``N_t`` is the number of
samples at the current node, ``N_t_L`` is the number of samples in the
left child, and ``N_t_R`` is the number of samples in the right child.
``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum,
if ``sample_weight`` is passed.
bootstrap : bool, default=True
Whether bootstrap samples are used when building trees. If False, the
whole dataset is used to build each tree.
oob_score : bool, default=False
Whether to use out-of-bag samples to estimate the generalization score.
Only available if bootstrap=True.
n_jobs : int, default=None
The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`,
:meth:`decision_path` and :meth:`apply` are all parallelized over the
trees. ``None`` means 1 unless in a `joblib.parallel_backend`
context. ``-1`` means using all processors. See :term:`Glossary
<n_jobs>` for more details.
random_state : int, RandomState instance or None, default=None
Controls both the randomness of the bootstrapping of the samples used
when building trees (if ``bootstrap=True``) and the sampling of the
features to consider when looking for the best split at each node
(if ``max_features < n_features``).
See :term:`Glossary <random_state>` for details.
verbose : int, default=0
Controls the verbosity when fitting and predicting.
warm_start : bool, default=False
When set to ``True``, reuse the solution of the previous call to fit
and add more estimators to the ensemble, otherwise, just fit a whole
new forest. See :term:`the Glossary <warm_start>`.
class_weight : {"balanced", "balanced_subsample"}, dict or list of dicts, \
default=None
Weights associated with classes in the form ``{class_label: weight}``.
If not given, all classes are supposed to have weight one. For
multi-output problems, a list of dicts can be provided in the same
order as the columns of y.
Note that for multioutput (including multilabel) weights should be
defined for each class of every column in its own dict. For example,
for four-class multilabel classification weights should be
[{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of
[{1:1}, {2:5}, {3:1}, {4:1}].
The "balanced" mode uses the values of y to automatically adjust
weights inversely proportional to class frequencies in the input data
as ``n_samples / (n_classes * np.bincount(y))``
The "balanced_subsample" mode is the same as "balanced" except that
weights are computed based on the bootstrap sample for every tree
grown.
For multi-output, the weights of each column of y will be multiplied.
Note that these weights will be multiplied with sample_weight (passed
through the fit method) if sample_weight is specified.
max_samples : int or float, default=None
If bootstrap is True, the number of samples to draw from X
to train each base estimator.
- If None (default), then draw `X.shape[0]` samples.
- If int, then draw `max_samples` samples.
- If float, then draw `max_samples * X.shape[0]` samples. Thus,
`max_samples` should be in the interval `(0.0, 1.0]`.
feature_combinations : float, default=None
The number of features to combine on average at each split
of the decision trees. If ``None``, then will default to the minimum of
``(1.5, n_features)``. This controls the number of non-zeros is the
projection matrix. Setting the value to 1.0 is equivalent to a
traditional decision-tree. ``feature_combinations * max_features``
gives the number of expected non-zeros in the projection matrix of shape
``(max_features, n_features)``. Thus this value must always be less than
``n_features`` in order to be valid.
Attributes
----------
estimators_ : list of treeple.tree.ObliqueDecisionTreeClassifier
The collection of fitted sub-estimators.
classes_ : ndarray of shape (n_classes,) or a list of such arrays
The classes labels (single output problem), or a list of arrays of
class labels (multi-output problem).
n_classes_ : int or list
The number of classes (single output problem), or a list containing the
number of classes for each output (multi-output problem).
n_features_ : int
The number of features when ``fit`` is performed.
n_features_in_ : int
Number of features seen during :term:`fit`.
feature_names_in_ : ndarray of shape (`n_features_in_`,)
Names of features seen during :term:`fit`. Defined only when `X`
has feature names that are all strings.
n_outputs_ : int
The number of outputs when ``fit`` is performed.
feature_importances_ : ndarray of shape (n_features,)
The impurity-based feature importances.
The higher, the more important the feature.
The importance of a feature is computed as the (normalized)
total reduction of the criterion brought by that feature. It is also
known as the Gini importance.
Warning: impurity-based feature importances can be misleading for
high cardinality features (many unique values). See
:func:`sklearn.inspection.permutation_importance` as an alternative.
oob_score_ : float
Score of the training dataset obtained using an out-of-bag estimate.
This attribute exists only when ``oob_score`` is True.
oob_decision_function_ : ndarray of shape (n_samples, n_classes) or \
(n_samples, n_classes, n_outputs)
Decision function computed with out-of-bag estimate on the training
set. If n_estimators is small it might be possible that a data point
was never left out during the bootstrap. In this case,
`oob_decision_function_` might contain NaN. This attribute exists
only when ``oob_score`` is True.
See Also
--------
treeple.tree.ObliqueDecisionTreeClassifier : An oblique decision
tree classifier.
sklearn.ensemble.RandomForestClassifier : An axis-aligned decision
forest classifier.
Notes
-----
The default values for the parameters controlling the size of the trees
(e.g. ``max_depth``, ``min_samples_leaf``, etc.) lead to fully grown and
unpruned trees which can potentially be very large on some data sets. To
reduce memory consumption, the complexity and size of the trees should be
controlled by setting those parameter values.
The features are always randomly permuted at each split. Therefore,
the best found split may vary, even with the same training data,
``max_features=n_features`` and ``bootstrap=False``, if the improvement
of the criterion is identical for several splits enumerated during the
search of the best split. To obtain a deterministic behaviour during
fitting, ``random_state`` has to be fixed.
References
----------
.. [1] L. Breiman, "Random Forests", Machine Learning, 45(1), 5-32, 2001.
Examples
--------
>>> from treeple.ensemble import ObliqueRandomForestClassifier
>>> from sklearn.datasets import make_classification
>>> X, y = make_classification(n_samples=1000, n_features=4,
... n_informative=2, n_redundant=0,
... random_state=0, shuffle=False)
>>> clf = ObliqueRandomForestClassifier(max_depth=2, random_state=0)
>>> clf.fit(X, y)
ObliqueRandomForestClassifier(...)
>>> print(clf.predict([[0, 0, 0, 0]]))
[1]
"""
tree_type = "oblique"
_parameter_constraints: dict = {
**ForestClassifier._parameter_constraints,
**ObliqueDecisionTreeClassifier._parameter_constraints,
"class_weight": [
StrOptions({"balanced_subsample", "balanced"}),
dict,
list,
None,
],
}
_parameter_constraints.pop("splitter")
def __init__(
self,
n_estimators=100,
*,
criterion="gini",
max_depth=None,
min_samples_split=2,
min_samples_leaf=1,
min_weight_fraction_leaf=0.0,
max_features="sqrt",
max_leaf_nodes=None,
min_impurity_decrease=0.0,
bootstrap=True,
oob_score=False,
n_jobs=None,
random_state=None,
verbose=0,
warm_start=False,
class_weight=None,
max_samples=None,
feature_combinations=None,
):
super().__init__(
estimator=ObliqueDecisionTreeClassifier(),
n_estimators=n_estimators,
estimator_params=(
"criterion",
"max_depth",
"min_samples_split",
"min_samples_leaf",
"min_weight_fraction_leaf",
"max_features",
"max_leaf_nodes",
"min_impurity_decrease",
"random_state",
"feature_combinations",
),
bootstrap=bootstrap,
oob_score=oob_score,
n_jobs=n_jobs,
random_state=random_state,
verbose=verbose,
warm_start=warm_start,
class_weight=class_weight,
max_samples=max_samples,
)
self.criterion = criterion
self.max_depth = max_depth
self.min_samples_split = min_samples_split
self.min_samples_leaf = min_samples_leaf
self.max_features = max_features
self.feature_combinations = feature_combinations
# unused by oblique forests
self.min_weight_fraction_leaf = min_weight_fraction_leaf
self.max_leaf_nodes = max_leaf_nodes
self.min_impurity_decrease = min_impurity_decrease
class ObliqueRandomForestRegressor(SimMatrixMixin, ForestMixin, ForestRegressor):
"""An oblique random forest regressor.
A oblique random forest is a meta estimator similar to a random
forest that fits a number of oblique decision tree regressor
on various sub-samples of the dataset and uses averaging to
improve the predictive accuracy and control over-fitting.
The sub-sample size is controlled with the `max_samples` parameter if
`bootstrap=True` (default), otherwise the whole dataset is used to build
each tree.
Read more in the :ref:`User Guide <sklearn:forest>`.
Parameters
----------
n_estimators : int, default=100
The number of trees in the forest.
criterion : {"squared_error", "absolute_error", "friedman_mse", "poisson"}, \
default="squared_error"
The function to measure the quality of a split. Supported criteria
are "squared_error" for the mean squared error, which is equal to
variance reduction as feature selection criterion and minimizes the L2
loss using the mean of each terminal node, "friedman_mse", which uses
mean squared error with Friedman's improvement score for potential
splits, "absolute_error" for the mean absolute error, which minimizes
the L1 loss using the median of each terminal node, and "poisson" which
uses reduction in Poisson deviance to find splits.
Training using "absolute_error" is significantly slower
than when using "squared_error".
max_depth : int, default=None
The maximum depth of the tree. If None, then nodes are expanded until
all leaves are pure or until all leaves contain less than
min_samples_split samples.
min_samples_split : int or float, default=2
The minimum number of samples required to split an internal node:
- If int, then consider `min_samples_split` as the minimum number.
- If float, then `min_samples_split` is a fraction and
`ceil(min_samples_split * n_samples)` are the minimum
number of samples for each split.
min_samples_leaf : int or float, default=1
The minimum number of samples required to be at a leaf node.
A split point at any depth will only be considered if it leaves at
least ``min_samples_leaf`` training samples in each of the left and
right branches. This may have the effect of smoothing the model,
especially in regression.
- If int, then consider `min_samples_leaf` as the minimum number.
- If float, then `min_samples_leaf` is a fraction and
`ceil(min_samples_leaf * n_samples)` are the minimum
number of samples for each node.
min_weight_fraction_leaf : float, default=0.0
The minimum weighted fraction of the sum total of weights (of all
the input samples) required to be at a leaf node. Samples have
equal weight when sample_weight is not provided.
max_features : {"sqrt", "log2", None}, int or float, default="sqrt"
The number of features to consider when looking for the best split:
- If int, then consider `max_features` features at each split.
- If float, then `max_features` is a fraction and
`round(max_features * n_features)` features are considered at each
split.
- If "auto", then `max_features=sqrt(n_features)`.
- If "sqrt", then `max_features=sqrt(n_features)`.
- If "log2", then `max_features=log2(n_features)`.
- If None, then `max_features=n_features`.
Note: the search for a split does not stop until at least one
valid partition of the node samples is found, even if it requires to
effectively inspect more than ``max_features`` features.
max_leaf_nodes : int, default=None
Grow trees with ``max_leaf_nodes`` in best-first fashion.
Best nodes are defined as relative reduction in impurity.
If None then unlimited number of leaf nodes.
min_impurity_decrease : float, default=0.0
A node will be split if this split induces a decrease of the impurity
greater than or equal to this value.
The weighted impurity decrease equation is the following::
N_t / N * (impurity - N_t_R / N_t * right_impurity
- N_t_L / N_t * left_impurity)
where ``N`` is the total number of samples, ``N_t`` is the number of
samples at the current node, ``N_t_L`` is the number of samples in the
left child, and ``N_t_R`` is the number of samples in the right child.
``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum,
if ``sample_weight`` is passed.
bootstrap : bool, default=True
Whether bootstrap samples are used when building trees. If False, the
whole dataset is used to build each tree.
oob_score : bool, default=False
Whether to use out-of-bag samples to estimate the generalization score.
Only available if bootstrap=True.
n_jobs : int, default=None
The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`,
:meth:`decision_path` and :meth:`apply` are all parallelized over the
trees. ``None`` means 1 unless in a `joblib.parallel_backend`
context. ``-1`` means using all processors. See :term:`Glossary
<n_jobs>` for more details.
random_state : int, RandomState instance or None, default=None
Controls both the randomness of the bootstrapping of the samples used
when building trees (if ``bootstrap=True``) and the sampling of the
features to consider when looking for the best split at each node
(if ``max_features < n_features``).
See :term:`Glossary <random_state>` for details.
verbose : int, default=0
Controls the verbosity when fitting and predicting.
warm_start : bool, default=False
When set to ``True``, reuse the solution of the previous call to fit
and add more estimators to the ensemble, otherwise, just fit a whole
new forest. See :term:`the Glossary <warm_start>`.
max_samples : int or float, default=None
If bootstrap is True, the number of samples to draw from X
to train each base estimator.
- If None (default), then draw `X.shape[0]` samples.
- If int, then draw `max_samples` samples.
- If float, then draw `max_samples * X.shape[0]` samples. Thus,
`max_samples` should be in the interval `(0.0, 1.0]`.
feature_combinations : float, default=None
The number of features to combine on average at each split
of the decision trees. If ``None``, then will default to the minimum of
``(1.5, n_features)``. This controls the number of non-zeros is the
projection matrix. Setting the value to 1.0 is equivalent to a
traditional decision-tree. ``feature_combinations * max_features``
gives the number of expected non-zeros in the projection matrix of shape
``(max_features, n_features)``. Thus this value must always be less than
``n_features`` in order to be valid.
Attributes
----------
estimators_ : list of ObliqueDecisionTreeRegressor
The collection of fitted sub-estimators.
n_features_ : int
The number of features when ``fit`` is performed.
n_features_in_ : int
Number of features seen during :term:`fit`.
feature_names_in_ : ndarray of shape (`n_features_in_`,)
Names of features seen during :term:`fit`. Defined only when `X`
has feature names that are all strings.
n_outputs_ : int
The number of outputs when ``fit`` is performed.
feature_importances_ : ndarray of shape (n_features,)
The impurity-based feature importances.
The higher, the more important the feature.
The importance of a feature is computed as the (normalized)
total reduction of the criterion brought by that feature. It is also
known as the Gini importance.
Warning: impurity-based feature importances can be misleading for
high cardinality features (many unique values). See
:func:`sklearn.inspection.permutation_importance` as an alternative.
oob_score_ : float
Score of the training dataset obtained using an out-of-bag estimate.
This attribute exists only when ``oob_score`` is True.
oob_decision_function_ : ndarray of shape (n_samples, n_classes) or \
(n_samples, n_classes, n_outputs)
Decision function computed with out-of-bag estimate on the training
set. If n_estimators is small it might be possible that a data point
was never left out during the bootstrap. In this case,
`oob_decision_function_` might contain NaN. This attribute exists
only when ``oob_score`` is True.
See Also
--------
treeple.tree.ObliqueDecisionTreeRegressor : An oblique decision
tree regressor.
sklearn.ensemble.RandomForestRegressor : An axis-aligned decision
forest regressor.
Notes
-----
The default values for the parameters controlling the size of the trees
(e.g. ``max_depth``, ``min_samples_leaf``, etc.) lead to fully grown and
unpruned trees which can potentially be very large on some data sets. To
reduce memory consumption, the complexity and size of the trees should be
controlled by setting those parameter values.
The features are always randomly permuted at each split. Therefore,
the best found split may vary, even with the same training data,
``max_features=n_features`` and ``bootstrap=False``, if the improvement
of the criterion is identical for several splits enumerated during the
search of the best split. To obtain a deterministic behaviour during
fitting, ``random_state`` has to be fixed.
References
----------
.. [1] L. Breiman, "Random Forests", Machine Learning, 45(1), 5-32, 2001.
.. [2] T. Tomita, "Sparse Projection Oblique Randomer Forests", \
Journal of Machine Learning Research, 21(104), 1-39, 2020.
Examples
--------
>>> from treeple.ensemble import ObliqueRandomForestRegressor
>>> from sklearn.datasets import make_regression
>>> X, y = make_regression(n_features=4, n_informative=2,
... random_state=0, shuffle=False)
>>> regr = ObliqueRandomForestRegressor(max_depth=2, random_state=0)
>>> regr.fit(X, y)
ObliqueRandomForestRegressor(...)
>>> print(regr.predict([[0, 0, 0, 0]]))
[-5.86327109]
"""
tree_type = "oblique"
_parameter_constraints: dict = {
**ForestRegressor._parameter_constraints,
**ObliqueDecisionTreeRegressor._parameter_constraints,
}
_parameter_constraints.pop("splitter")
def __init__(
self,
n_estimators=100,
*,
criterion="squared_error",
max_depth=None,
min_samples_split=2,
min_samples_leaf=1,
min_weight_fraction_leaf=0.0,
max_features=1.0,
max_leaf_nodes=None,
min_impurity_decrease=0.0,
bootstrap=True,
oob_score=False,
n_jobs=None,
random_state=None,
verbose=0,
warm_start=False,
max_samples=None,
feature_combinations=None,
):
super().__init__(
estimator=ObliqueDecisionTreeRegressor(),
n_estimators=n_estimators,
estimator_params=(
"criterion",
"max_depth",
"min_samples_split",
"min_samples_leaf",
"min_weight_fraction_leaf",
"max_features",
"max_leaf_nodes",
"min_impurity_decrease",
"random_state",
"feature_combinations",
),
bootstrap=bootstrap,
oob_score=oob_score,
n_jobs=n_jobs,
random_state=random_state,
verbose=verbose,
warm_start=warm_start,
max_samples=max_samples,
)
self.criterion = criterion
self.max_depth = max_depth
self.min_samples_split = min_samples_split
self.min_samples_leaf = min_samples_leaf
self.min_weight_fraction_leaf = min_weight_fraction_leaf
self.max_features = max_features
self.max_leaf_nodes = max_leaf_nodes
self.min_impurity_decrease = min_impurity_decrease
self.feature_combinations = feature_combinations
# unused by oblique forests
self.min_weight_fraction_leaf = min_weight_fraction_leaf
self.max_leaf_nodes = max_leaf_nodes
self.min_impurity_decrease = min_impurity_decrease
class PatchObliqueRandomForestClassifier(
SimMatrixMixin, ForestClassifierMixin, ForestMixin, ForestClassifier
):
"""A patch-oblique random forest classifier.
A patch-oblique random forest is a meta estimator similar to a random
forest that fits a number of patch oblique decision tree classifiers
on various sub-samples of the dataset and uses averaging to
improve the predictive accuracy and control over-fitting. For more
details, see :footcite:`Li2023manifold`.
Parameters
----------
n_estimators : int, default=100
The number of trees in the forest.
criterion : {"gini", "entropy"}, default="gini"
The function to measure the quality of a split. Supported criteria are
"gini" for the Gini impurity and "entropy" for the information gain.
Note: this parameter is tree-specific.
max_depth : int, default=None
The maximum depth of the tree. If None, then nodes are expanded until
all leaves are pure or until all leaves contain less than
min_samples_split samples.
min_samples_split : int or float, default=2
The minimum number of samples required to split an internal node:
- If int, then consider `min_samples_split` as the minimum number.
- If float, then `min_samples_split` is a fraction and
`ceil(min_samples_split * n_samples)` are the minimum
number of samples for each split.
min_samples_leaf : int or float, default=1
The minimum number of samples required to be at a leaf node.
A split point at any depth will only be considered if it leaves at
least ``min_samples_leaf`` training samples in each of the left and
right branches. This may have the effect of smoothing the model,
especially in regression.
- If int, then consider `min_samples_leaf` as the minimum number.
- If float, then `min_samples_leaf` is a fraction and
`ceil(min_samples_leaf * n_samples)` are the minimum
number of samples for each node.
min_weight_fraction_leaf : float, default=0.0
The minimum weighted fraction of the sum total of weights (of all
the input samples) required to be at a leaf node. Samples have
equal weight when sample_weight is not provided.
max_features : {"sqrt", "log2", None}, int or float, default="sqrt"
The number of features to consider when looking for the best split:
- If int, then consider `max_features` features at each split.
- If float, then `max_features` is a fraction and
`round(max_features * n_features)` features are considered at each
split.
- If "auto", then `max_features=sqrt(n_features)`.
- If "sqrt", then `max_features=sqrt(n_features)`.
- If "log2", then `max_features=log2(n_features)`.
- If None, then `max_features=n_features`.
Note: the search for a split does not stop until at least one
valid partition of the node samples is found, even if it requires to
effectively inspect more than ``max_features`` features.
max_leaf_nodes : int, default=None
Grow trees with ``max_leaf_nodes`` in best-first fashion.
Best nodes are defined as relative reduction in impurity.
If None then unlimited number of leaf nodes.
min_impurity_decrease : float, default=0.0
A node will be split if this split induces a decrease of the impurity
greater than or equal to this value.
The weighted impurity decrease equation is the following::
N_t / N * (impurity - N_t_R / N_t * right_impurity
- N_t_L / N_t * left_impurity)
where ``N`` is the total number of samples, ``N_t`` is the number of
samples at the current node, ``N_t_L`` is the number of samples in the
left child, and ``N_t_R`` is the number of samples in the right child.
``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum,
if ``sample_weight`` is passed.
bootstrap : bool, default=True
Whether bootstrap samples are used when building trees. If False, the
whole dataset is used to build each tree.
oob_score : bool, default=False
Whether to use out-of-bag samples to estimate the generalization score.
Only available if bootstrap=True.
n_jobs : int, default=None
The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`,
:meth:`decision_path` and :meth:`apply` are all parallelized over the
trees. ``None`` means 1 unless in a `joblib.parallel_backend`
context. ``-1`` means using all processors. See :term:`Glossary
<n_jobs>` for more details.
random_state : int, RandomState instance or None, default=None
Controls both the randomness of the bootstrapping of the samples used
when building trees (if ``bootstrap=True``) and the sampling of the
features to consider when looking for the best split at each node
(if ``max_features < n_features``).
See :term:`Glossary <random_state>` for details.
verbose : int, default=0
Controls the verbosity when fitting and predicting.
warm_start : bool, default=False
When set to ``True``, reuse the solution of the previous call to fit
and add more estimators to the ensemble, otherwise, just fit a whole
new forest. See :term:`the Glossary <warm_start>`.
class_weight : {"balanced", "balanced_subsample"}, dict or list of dicts, \
default=None
Weights associated with classes in the form ``{class_label: weight}``.
If not given, all classes are supposed to have weight one. For
multi-output problems, a list of dicts can be provided in the same
order as the columns of y.
Note that for multioutput (including multilabel) weights should be
defined for each class of every column in its own dict. For example,
for four-class multilabel classification weights should be
[{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of
[{1:1}, {2:5}, {3:1}, {4:1}].
The "balanced" mode uses the values of y to automatically adjust
weights inversely proportional to class frequencies in the input data
as ``n_samples / (n_classes * np.bincount(y))``
The "balanced_subsample" mode is the same as "balanced" except that
weights are computed based on the bootstrap sample for every tree
grown.
For multi-output, the weights of each column of y will be multiplied.
Note that these weights will be multiplied with sample_weight (passed
through the fit method) if sample_weight is specified.
max_samples : int or float, default=None
If bootstrap is True, the number of samples to draw from X
to train each base estimator.
- If None (default), then draw `X.shape[0]` samples.
- If int, then draw `max_samples` samples.
- If float, then draw `max_samples * X.shape[0]` samples. Thus,
`max_samples` should be in the interval `(0.0, 1.0]`.
min_patch_dims : array-like, optional
The minimum dimensions of a patch, by default 1 along all dimensions.
max_patch_dims : array-like, optional
The maximum dimensions of a patch, by default 1 along all dimensions.
dim_contiguous : array-like of bool, optional
Whether or not each patch is sampled contiguously along this dimension.
data_dims : array-like, optional
The presumed dimensions of the un-vectorized feature vector, by default
will be a 1D vector with (1, n_features) shape.
boundary : optional, str {'wrap'}
The boundary condition to use when sampling patches, by default None.
'wrap' corresponds to the boundary condition as is in numpy and scipy.
feature_weight : array-like of shape (n_features,), default=None
Feature weights. If None, then features are equally weighted as is.
If provided, then the feature weights are used to weight the
patches that are generated. The feature weights are used
as follows: for every patch that is sampled, the feature weights over
the entire patch is summed and normalizes the patch.
Attributes
----------
estimators_ : list of PatchObliqueDecisionTreeClassifier
The collection of fitted sub-estimators.
classes_ : ndarray of shape (n_classes,) or a list of such arrays
The classes labels (single output problem), or a list of arrays of
class labels (multi-output problem).
n_classes_ : int or list
The number of classes (single output problem), or a list containing the
number of classes for each output (multi-output problem).
n_features_ : int
The number of features when ``fit`` is performed.
n_features_in_ : int
Number of features seen during :term:`fit`.
feature_names_in_ : ndarray of shape (`n_features_in_`,)
Names of features seen during :term:`fit`. Defined only when `X`
has feature names that are all strings.
n_outputs_ : int
The number of outputs when ``fit`` is performed.
feature_importances_ : ndarray of shape (n_features,)
The impurity-based feature importances.
The higher, the more important the feature.
The importance of a feature is computed as the (normalized)
total reduction of the criterion brought by that feature. It is also
known as the Gini importance.
Warning: impurity-based feature importances can be misleading for
high cardinality features (many unique values). See
:func:`sklearn.inspection.permutation_importance` as an alternative.
oob_score_ : float
Score of the training dataset obtained using an out-of-bag estimate.
This attribute exists only when ``oob_score`` is True.
oob_decision_function_ : ndarray of shape (n_samples, n_classes) or \
(n_samples, n_classes, n_outputs)
Decision function computed with out-of-bag estimate on the training
set. If n_estimators is small it might be possible that a data point
was never left out during the bootstrap. In this case,
`oob_decision_function_` might contain NaN. This attribute exists
only when ``oob_score`` is True.
See Also
--------
treeple.tree.ObliqueDecisionTreeClassifier : An oblique decision
tree classifier.
sklearn.ensemble.RandomForestClassifier : An axis-aligned decision
forest classifier.
Notes
-----
The default values for the parameters controlling the size of the trees
(e.g. ``max_depth``, ``min_samples_leaf``, etc.) lead to fully grown and
unpruned trees which can potentially be very large on some data sets. To
reduce memory consumption, the complexity and size of the trees should be
controlled by setting those parameter values.
The features are always randomly permuted at each split. Therefore,
the best found split may vary, even with the same training data,
``max_features=n_features`` and ``bootstrap=False``, if the improvement
of the criterion is identical for several splits enumerated during the
search of the best split. To obtain a deterministic behaviour during
fitting, ``random_state`` has to be fixed.
References
----------
.. footbibliography::
"""
tree_type = "oblique"
_parameter_constraints: dict = {
**ForestClassifier._parameter_constraints,
**PatchObliqueDecisionTreeClassifier._parameter_constraints,
"class_weight": [
StrOptions({"balanced_subsample", "balanced"}),
dict,
list,
None,
],
}
_parameter_constraints.pop("splitter")
def __init__(
self,
n_estimators=100,
*,
criterion="gini",
max_depth=None,
min_samples_split=2,
min_samples_leaf=1,
min_weight_fraction_leaf=0.0,
max_features="sqrt",
max_leaf_nodes=None,
min_impurity_decrease=0.0,
bootstrap=True,
oob_score=False,
n_jobs=None,
random_state=None,
verbose=0,
warm_start=False,
class_weight=None,
max_samples=None,
min_patch_dims=None,
max_patch_dims=None,
dim_contiguous=None,
data_dims=None,
boundary=None,
feature_weight=None,
):
super().__init__(
estimator=PatchObliqueDecisionTreeClassifier(),
n_estimators=n_estimators,
estimator_params=(
"criterion",
"max_depth",
"min_samples_split",
"min_samples_leaf",
"min_weight_fraction_leaf",
"max_features",
"max_leaf_nodes",
"min_impurity_decrease",
"random_state",
"min_patch_dims",
"max_patch_dims",
"dim_contiguous",
"data_dims",
"boundary",
"feature_weight",
),
bootstrap=bootstrap,
oob_score=oob_score,
n_jobs=n_jobs,
random_state=random_state,
verbose=verbose,
warm_start=warm_start,
class_weight=class_weight,
max_samples=max_samples,
)
self.criterion = criterion
self.max_depth = max_depth
self.min_samples_split = min_samples_split
self.min_samples_leaf = min_samples_leaf
self.max_features = max_features
self.min_patch_dims = min_patch_dims
self.max_patch_dims = max_patch_dims
self.dim_contiguous = dim_contiguous
self.data_dims = data_dims
self.boundary = boundary
self.feature_weight = feature_weight
# unused by oblique forests
self.min_weight_fraction_leaf = min_weight_fraction_leaf
self.max_leaf_nodes = max_leaf_nodes
self.min_impurity_decrease = min_impurity_decrease
class PatchObliqueRandomForestRegressor(SimMatrixMixin, ForestMixin, ForestRegressor):
"""A patch-oblique random forest regressor.
A patch-oblique random forest is a meta estimator similar to a random
forest that fits a number of patch oblique decision tree regressors
on various sub-samples of the dataset and uses averaging to
improve the predictive accuracy and control over-fitting. For more
details, see :footcite:`Li2023manifold`.
Parameters
----------
n_estimators : int, default=100
The number of trees in the forest.
criterion : {"squared_error", "absolute_error", "friedman_mse", "poisson"},\
default="squared_error"
The function to measure the quality of a split. Supported criteria
are "squared_error" for the mean squared error, which is equal to
variance reduction as feature selection criterion and minimizes the L2
loss using the mean of each terminal node, "friedman_mse", which uses
mean squared error with Friedman's improvement score for potential
splits, "absolute_error" for the mean absolute error, which minimizes
the L1 loss using the median of each terminal node, and "poisson" which
uses reduction in Poisson deviance to find splits.
Training using "absolute_error" is significantly slower
than when using "squared_error".
max_depth : int, default=None
The maximum depth of the tree. If None, then nodes are expanded until
all leaves are pure or until all leaves contain less than
min_samples_split samples.
min_samples_split : int or float, default=2
The minimum number of samples required to split an internal node:
- If int, then consider `min_samples_split` as the minimum number.
- If float, then `min_samples_split` is a fraction and
`ceil(min_samples_split * n_samples)` are the minimum
number of samples for each split.
min_samples_leaf : int or float, default=1
The minimum number of samples required to be at a leaf node.
A split point at any depth will only be considered if it leaves at
least ``min_samples_leaf`` training samples in each of the left and
right branches. This may have the effect of smoothing the model,
especially in regression.
- If int, then consider `min_samples_leaf` as the minimum number.
- If float, then `min_samples_leaf` is a fraction and
`ceil(min_samples_leaf * n_samples)` are the minimum
number of samples for each node.
min_weight_fraction_leaf : float, default=0.0
The minimum weighted fraction of the sum total of weights (of all
the input samples) required to be at a leaf node. Samples have
equal weight when sample_weight is not provided.
max_features : {"sqrt", "log2", None}, int or float, default="sqrt"
The number of features to consider when looking for the best split:
- If int, then consider `max_features` features at each split.
- If float, then `max_features` is a fraction and
`round(max_features * n_features)` features are considered at each
split.
- If "auto", then `max_features=sqrt(n_features)`.
- If "sqrt", then `max_features=sqrt(n_features)`.
- If "log2", then `max_features=log2(n_features)`.
- If None, then `max_features=n_features`.
Note: the search for a split does not stop until at least one
valid partition of the node samples is found, even if it requires to
effectively inspect more than ``max_features`` features.
max_leaf_nodes : int, default=None
Grow trees with ``max_leaf_nodes`` in best-first fashion.
Best nodes are defined as relative reduction in impurity.
If None then unlimited number of leaf nodes.
min_impurity_decrease : float, default=0.0
A node will be split if this split induces a decrease of the impurity
greater than or equal to this value.
The weighted impurity decrease equation is the following::
N_t / N * (impurity - N_t_R / N_t * right_impurity
- N_t_L / N_t * left_impurity)
where ``N`` is the total number of samples, ``N_t`` is the number of
samples at the current node, ``N_t_L`` is the number of samples in the
left child, and ``N_t_R`` is the number of samples in the right child.
``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum,
if ``sample_weight`` is passed.
bootstrap : bool, default=True
Whether bootstrap samples are used when building trees. If False, the
whole dataset is used to build each tree.
oob_score : bool, default=False
Whether to use out-of-bag samples to estimate the generalization score.
Only available if bootstrap=True.
n_jobs : int, default=None
The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`,
:meth:`decision_path` and :meth:`apply` are all parallelized over the
trees. ``None`` means 1 unless in a `joblib.parallel_backend`
context. ``-1`` means using all processors. See :term:`Glossary
<n_jobs>` for more details.
random_state : int, RandomState instance or None, default=None
Controls both the randomness of the bootstrapping of the samples used
when building trees (if ``bootstrap=True``) and the sampling of the
features to consider when looking for the best split at each node
(if ``max_features < n_features``).
See :term:`Glossary <random_state>` for details.
verbose : int, default=0
Controls the verbosity when fitting and predicting.
warm_start : bool, default=False
When set to ``True``, reuse the solution of the previous call to fit
and add more estimators to the ensemble, otherwise, just fit a whole
new forest. See :term:`the Glossary <warm_start>`.
max_samples : int or float, default=None
If bootstrap is True, the number of samples to draw from X
to train each base estimator.
- If None (default), then draw `X.shape[0]` samples.
- If int, then draw `max_samples` samples.
- If float, then draw `max_samples * X.shape[0]` samples. Thus,
`max_samples` should be in the interval `(0.0, 1.0]`.
min_patch_dims : array-like, optional
The minimum dimensions of a patch, by default 1 along all dimensions.
max_patch_dims : array-like, optional
The maximum dimensions of a patch, by default 1 along all dimensions.
dim_contiguous : array-like of bool, optional
Whether or not each patch is sampled contiguously along this dimension.
data_dims : array-like, optional
The presumed dimensions of the un-vectorized feature vector, by default
will be a 1D vector with (1, n_features) shape.
boundary : optional, str {'wrap'}
The boundary condition to use when sampling patches, by default None.
'wrap' corresponds to the boundary condition as is in numpy and scipy.
feature_weight : array-like of shape (n_features,), default=None
Feature weights. If None, then features are equally weighted as is.
If provided, then the feature weights are used to weight the
patches that are generated. The feature weights are used
as follows: for every patch that is sampled, the feature weights over
the entire patch is summed and normalizes the patch.
Attributes
----------
estimators_ : list of PatchObliqueDecisionTreeRegressor
The collection of fitted sub-estimators.
n_features_ : int
The number of features when ``fit`` is performed.
n_features_in_ : int
Number of features seen during :term:`fit`.
feature_names_in_ : ndarray of shape (`n_features_in_`,)
Names of features seen during :term:`fit`. Defined only when `X`
has feature names that are all strings.
n_outputs_ : int
The number of outputs when ``fit`` is performed.
feature_importances_ : ndarray of shape (n_features,)
The impurity-based feature importances.
The higher, the more important the feature.
The importance of a feature is computed as the (normalized)
total reduction of the criterion brought by that feature. It is also
known as the Gini importance.
Warning: impurity-based feature importances can be misleading for
high cardinality features (many unique values). See
:func:`sklearn.inspection.permutation_importance` as an alternative.
oob_score_ : float
Score of the training dataset obtained using an out-of-bag estimate.
This attribute exists only when ``oob_score`` is True.
oob_prediction_ : ndarray of shape (n_samples,) or (n_samples, n_outputs)
Prediction computed with out-of-bag estimate on the training set.
This attribute exists only when ``oob_score`` is True.
See Also
--------
treeple.tree.ObliqueDecisionTreeRegressor : An oblique decision
tree regressor.
sklearn.ensemble.RandomForestRegressor : An axis-aligned decision
forest regressor.
Notes
-----
The default values for the parameters controlling the size of the trees
(e.g. ``max_depth``, ``min_samples_leaf``, etc.) lead to fully grown and
unpruned trees which can potentially be very large on some data sets. To
reduce memory consumption, the complexity and size of the trees should be
controlled by setting those parameter values.
The features are always randomly permuted at each split. Therefore,
the best found split may vary, even with the same training data,
``max_features=n_features`` and ``bootstrap=False``, if the improvement
of the criterion is identical for several splits enumerated during the
search of the best split. To obtain a deterministic behaviour during
fitting, ``random_state`` has to be fixed.
References
----------
.. footbibliography::
Examples
--------
>>> from treeple.ensemble import PatchObliqueRandomForestRegressor
>>> from sklearn.datasets import make_regression
>>> X, y = make_regression(n_features=4, n_informative=2,
... random_state=0, shuffle=False)
>>> regressor = PatchObliqueRandomForestRegressor(max_depth=2, random_state=0)
>>> regressor.fit(X, y)
PatchObliqueRandomForestRegressor(...)
>>> print(regressor.predict([[0, 0, 0, 0]]))
[-5.82818509]
"""
tree_type = "oblique"
_parameter_constraints: dict = {
**ForestRegressor._parameter_constraints,
**PatchObliqueDecisionTreeRegressor._parameter_constraints,
}
_parameter_constraints.pop("splitter")
def __init__(
self,
n_estimators=100,
*,
criterion="squared_error",
max_depth=None,
min_samples_split=2,
min_samples_leaf=1,
min_weight_fraction_leaf=0.0,
max_features=1.0,
max_leaf_nodes=None,
min_impurity_decrease=0.0,
bootstrap=True,
oob_score=False,
n_jobs=None,
random_state=None,
verbose=0,
warm_start=False,
max_samples=None,
min_patch_dims=None,
max_patch_dims=None,
dim_contiguous=None,
data_dims=None,
boundary=None,
feature_weight=None,
):
super().__init__(
estimator=PatchObliqueDecisionTreeRegressor(),
n_estimators=n_estimators,
estimator_params=(
"criterion",
"max_depth",
"min_samples_split",
"min_samples_leaf",
"min_weight_fraction_leaf",
"max_features",
"max_leaf_nodes",
"min_impurity_decrease",
"random_state",
"min_patch_dims",
"max_patch_dims",
"dim_contiguous",
"data_dims",
"boundary",
"feature_weight",
),
bootstrap=bootstrap,
oob_score=oob_score,
n_jobs=n_jobs,
random_state=random_state,
verbose=verbose,
warm_start=warm_start,
max_samples=max_samples,
)
self.criterion = criterion
self.max_depth = max_depth
self.min_samples_split = min_samples_split
self.min_samples_leaf = min_samples_leaf
self.max_features = max_features
self.min_patch_dims = min_patch_dims
self.max_patch_dims = max_patch_dims
self.dim_contiguous = dim_contiguous
self.data_dims = data_dims
self.boundary = boundary
self.feature_weight = feature_weight
# unused by oblique forests
self.min_weight_fraction_leaf = min_weight_fraction_leaf
self.max_leaf_nodes = max_leaf_nodes
self.min_impurity_decrease = min_impurity_decrease
class ExtraObliqueRandomForestClassifier(
SimMatrixMixin, ForestClassifierMixin, ForestMixin, ForestClassifier
):
"""
An extra oblique random forest classifier.
An extra oblique random forest is a meta estimator similar to a random
forest that fits a number of extra oblique decision tree classifiers
on various sub-samples of the dataset and uses averaging to
improve the predictive accuracy and control over-fitting.
The sub-sample size is controlled with the `max_samples` parameter if
`bootstrap=True` (default), otherwise the whole dataset is used to build
each tree.
Read more in the :ref:`User Guide <sklearn:forest>`.
Parameters
----------
n_estimators : int, default=100
The number of trees in the forest.
criterion : {"gini", "entropy"}, default="gini"
The function to measure the quality of a split. Supported criteria are
"gini" for the Gini impurity and "entropy" for the information gain.
Note: this parameter is tree-specific.
max_depth : int, default=None
The maximum depth of the tree. If None, then nodes are expanded until
all leaves are pure or until all leaves contain less than
min_samples_split samples.
min_samples_split : int or float, default=2
The minimum number of samples required to split an internal node:
- If int, then consider `min_samples_split` as the minimum number.
- If float, then `min_samples_split` is a fraction and
`ceil(min_samples_split * n_samples)` are the minimum
number of samples for each split.
min_samples_leaf : int or float, default=1
The minimum number of samples required to be at a leaf node.
A split point at any depth will only be considered if it leaves at
least ``min_samples_leaf`` training samples in each of the left and
right branches. This may have the effect of smoothing the model,
especially in regression.
- If int, then consider `min_samples_leaf` as the minimum number.
- If float, then `min_samples_leaf` is a fraction and
`ceil(min_samples_leaf * n_samples)` are the minimum
number of samples for each node.
min_weight_fraction_leaf : float, default=0.0
The minimum weighted fraction of the sum total of weights (of all
the input samples) required to be at a leaf node. Samples have
equal weight when sample_weight is not provided.
max_features : {"sqrt", "log2", None}, int or float, default="sqrt"
The number of features to consider when looking for the best split:
- If int, then consider `max_features` features at each split.
- If float, then `max_features` is a fraction and
`round(max_features * n_features)` features are considered at each
split.
- If "auto", then `max_features=sqrt(n_features)`.
- If "sqrt", then `max_features=sqrt(n_features)`.
- If "log2", then `max_features=log2(n_features)`.
- If None, then `max_features=n_features`.
Note: the search for a split does not stop until at least one
valid partition of the node samples is found, even if it requires to
effectively inspect more than ``max_features`` features.
max_leaf_nodes : int, default=None
Grow trees with ``max_leaf_nodes`` in best-first fashion.
Best nodes are defined as relative reduction in impurity.
If None then unlimited number of leaf nodes.
min_impurity_decrease : float, default=0.0
A node will be split if this split induces a decrease of the impurity
greater than or equal to this value.
The weighted impurity decrease equation is the following::
N_t / N * (impurity - N_t_R / N_t * right_impurity
- N_t_L / N_t * left_impurity)
where ``N`` is the total number of samples, ``N_t`` is the number of
samples at the current node, ``N_t_L`` is the number of samples in the
left child, and ``N_t_R`` is the number of samples in the right child.
``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum,
if ``sample_weight`` is passed.
bootstrap : bool, default=True
Whether bootstrap samples are used when building trees. If False, the
whole dataset is used to build each tree.
oob_score : bool, default=False
Whether to use out-of-bag samples to estimate the generalization score.
Only available if bootstrap=True.
n_jobs : int, default=None
The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`,
:meth:`decision_path` and :meth:`apply` are all parallelized over the
trees. ``None`` means 1 unless in a :obj:`joblib.parallel_backend`
context. ``-1`` means using all processors. See :term:`Glossary
<n_jobs>` for more details.
random_state : int, RandomState instance or None, default=None
Controls both the randomness of the bootstrapping of the samples used
when building trees (if ``bootstrap=True``) and the sampling of the
features to consider when looking for the best split at each node
(if ``max_features < n_features``).
See :term:`Glossary <random_state>` for details.
verbose : int, default=0
Controls the verbosity when fitting and predicting.
warm_start : bool, default=False
When set to ``True``, reuse the solution of the previous call to fit
and add more estimators to the ensemble, otherwise, just fit a whole
new forest. See :term:`the Glossary <warm_start>`.
class_weight : {"balanced", "balanced_subsample"}, dict or list of dicts, \
default=None
Weights associated with classes in the form ``{class_label: weight}``.
If not given, all classes are supposed to have weight one. For
multi-output problems, a list of dicts can be provided in the same
order as the columns of y.
Note that for multioutput (including multilabel) weights should be
defined for each class of every column in its own dict. For example,
for four-class multilabel classification weights should be
[{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of
[{1:1}, {2:5}, {3:1}, {4:1}].
The "balanced" mode uses the values of y to automatically adjust
weights inversely proportional to class frequencies in the input data
as ``n_samples / (n_classes * np.bincount(y))``
The "balanced_subsample" mode is the same as "balanced" except that
weights are computed based on the bootstrap sample for every tree
grown.
For multi-output, the weights of each column of y will be multiplied.
Note that these weights will be multiplied with sample_weight (passed
through the fit method) if sample_weight is specified.
max_samples : int or float, default=None
If bootstrap is True, the number of samples to draw from X
to train each base estimator.
- If None (default), then draw `X.shape[0]` samples.
- If int, then draw `max_samples` samples.
- If float, then draw `max_samples * X.shape[0]` samples. Thus,
`max_samples` should be in the interval `(0.0, 1.0]`.
feature_combinations : float, default=None
The number of features to combine on average at each split
of the decision trees. If ``None``, then will default to the minimum of
``(1.5, n_features)``. This controls the number of non-zeros is the
projection matrix. Setting the value to 1.0 is equivalent to a
traditional decision-tree. ``feature_combinations * max_features``
gives the number of expected non-zeros in the projection matrix of shape
``(max_features, n_features)``. Thus this value must always be less than
``n_features`` in order to be valid.
Attributes
----------
estimators_ : list of treeple.tree.ExtraObliqueDecisionTreeClassifier
The collection of fitted sub-estimators.
classes_ : ndarray of shape (n_classes,) or a list of such arrays
The classes labels (single output problem), or a list of arrays of
class labels (multi-output problem).
n_classes_ : int or list
The number of classes (single output problem), or a list containing the
number of classes for each output (multi-output problem).
n_features_ : int
The number of features when ``fit`` is performed.
n_features_in_ : int
Number of features seen during :term:`fit`.
feature_names_in_ : ndarray of shape (`n_features_in_`,)
Names of features seen during :term:`fit`. Defined only when `X`
has feature names that are all strings.
n_outputs_ : int
The number of outputs when ``fit`` is performed.
feature_importances_ : ndarray of shape (n_features,)
The impurity-based feature importances.
The higher, the more important the feature.
The importance of a feature is computed as the (normalized)
total reduction of the criterion brought by that feature. It is also
known as the Gini importance.
Warning: impurity-based feature importances can be misleading for
high cardinality features (many unique values). See
:func:`sklearn.inspection.permutation_importance` as an alternative.
oob_score_ : float
Score of the training dataset obtained using an out-of-bag estimate.
This attribute exists only when ``oob_score`` is True.
oob_decision_function_ : ndarray of shape (n_samples, n_classes) or \
(n_samples, n_classes, n_outputs)
Decision function computed with out-of-bag estimate on the training
set. If n_estimators is small it might be possible that a data point
was never left out during the bootstrap. In this case,
`oob_decision_function_` might contain NaN. This attribute exists
only when ``oob_score`` is True.
See Also
--------
treeple.tree.ExtraObliqueDecisionTreeClassifier : An extremely randomized oblique decision
tree classifier.
treeple.tree.ObliqueDecisionTreeClassifier : An oblique decision tree classifier.
sklearn.ensemble.RandomForestClassifier : An axis-aligned decision
forest classifier.
Notes
-----
The default values for the parameters controlling the size of the trees
(e.g. ``max_depth``, ``min_samples_leaf``, etc.) lead to fully grown and
unpruned trees which can potentially be very large on some data sets. To
reduce memory consumption, the complexity and size of the trees should be
controlled by setting those parameter values.
The features are always randomly permuted at each split. Therefore,
the best found split may vary, even with the same training data,
``max_features=n_features`` and ``bootstrap=False``, if the improvement
of the criterion is identical for several splits enumerated during the
search of the best split. To obtain a deterministic behaviour during
fitting, ``random_state`` has to be fixed.
References
----------
.. [1] L. Breiman, "Random Forests", Machine Learning, 45(1), 5-32, 2001.
.. [2] P. Geurts, D. Ernst., and L. Wehenkel, "Extremely randomized trees",
Machine Learning, 63(1), 3-42, 2006.
Examples
--------
>>> from treeple.ensemble import ExtraObliqueRandomForestClassifier
>>> from sklearn.datasets import make_classification
>>> X, y = make_classification(n_samples=1000, n_features=4,
... n_informative=2, n_redundant=0,
... random_state=0, shuffle=False)
>>> clf = ExtraObliqueRandomForestClassifier(max_depth=2, random_state=0)
>>> clf.fit(X, y)
ExtraObliqueRandomForestClassifier(...)
>>> print(clf.predict([[0, 0, 0, 0]]))
[1]
"""
_parameter_constraints: dict = {
**ForestClassifier._parameter_constraints,
**ExtraObliqueDecisionTreeClassifier._parameter_constraints,
"class_weight": [
StrOptions({"balanced_subsample", "balanced"}),
dict,
list,
None,
],
}
_parameter_constraints.pop("splitter")
def __init__(
self,
n_estimators=100,
*,
criterion="gini",
max_depth=None,
min_samples_split=2,
min_samples_leaf=1,
min_weight_fraction_leaf=0.0,
max_features="sqrt",
max_leaf_nodes=None,
min_impurity_decrease=0.0,
bootstrap=True,
oob_score=False,
n_jobs=None,
random_state=None,
verbose=0,
warm_start=False,
class_weight=None,
max_samples=None,
feature_combinations=None,
):
super().__init__(
estimator=ExtraObliqueDecisionTreeClassifier(),
n_estimators=n_estimators,
estimator_params=(
"criterion",
"max_depth",
"min_samples_split",
"min_samples_leaf",
"min_weight_fraction_leaf",
"max_features",
"max_leaf_nodes",
"min_impurity_decrease",
"random_state",
"feature_combinations",
),
bootstrap=bootstrap,
oob_score=oob_score,
n_jobs=n_jobs,
random_state=random_state,
verbose=verbose,
warm_start=warm_start,
class_weight=class_weight,
max_samples=max_samples,
)
self.criterion = criterion
self.max_depth = max_depth
self.min_samples_split = min_samples_split
self.min_samples_leaf = min_samples_leaf
self.max_features = max_features
self.feature_combinations = feature_combinations
# unused by oblique forests
self.min_weight_fraction_leaf = min_weight_fraction_leaf
self.max_leaf_nodes = max_leaf_nodes
self.min_impurity_decrease = min_impurity_decrease
class ExtraObliqueRandomForestRegressor(SimMatrixMixin, ForestMixin, ForestRegressor):
"""An extra oblique random forest regressor.
An extra oblique random forest is a meta estimator similar to a random
forest that fits a number of extra oblique decision tree regressor
on various sub-samples of the dataset and uses averaging to
improve the predictive accuracy and control over-fitting.
The sub-sample size is controlled with the `max_samples` parameter if
`bootstrap=True` (default), otherwise the whole dataset is used to build
each tree.
Read more in the :ref:`User Guide <sklearn:forest>`.
Parameters
----------
n_estimators : int, default=100
The number of trees in the forest.
criterion : {"squared_error", "absolute_error", "friedman_mse", "poisson"}, \
default="squared_error"
The function to measure the quality of a split. Supported criteria
are "squared_error" for the mean squared error, which is equal to
variance reduction as feature selection criterion and minimizes the L2
loss using the mean of each terminal node, "friedman_mse", which uses
mean squared error with Friedman's improvement score for potential
splits, "absolute_error" for the mean absolute error, which minimizes
the L1 loss using the median of each terminal node, and "poisson" which
uses reduction in Poisson deviance to find splits.
Training using "absolute_error" is significantly slower
than when using "squared_error".
max_depth : int, default=None
The maximum depth of the tree. If None, then nodes are expanded until
all leaves are pure or until all leaves contain less than
min_samples_split samples.
min_samples_split : int or float, default=2
The minimum number of samples required to split an internal node:
- If int, then consider `min_samples_split` as the minimum number.
- If float, then `min_samples_split` is a fraction and
`ceil(min_samples_split * n_samples)` are the minimum
number of samples for each split.
min_samples_leaf : int or float, default=1
The minimum number of samples required to be at a leaf node.
A split point at any depth will only be considered if it leaves at
least ``min_samples_leaf`` training samples in each of the left and
right branches. This may have the effect of smoothing the model,
especially in regression.
- If int, then consider `min_samples_leaf` as the minimum number.
- If float, then `min_samples_leaf` is a fraction and
`ceil(min_samples_leaf * n_samples)` are the minimum
number of samples for each node.
min_weight_fraction_leaf : float, default=0.0
The minimum weighted fraction of the sum total of weights (of all
the input samples) required to be at a leaf node. Samples have
equal weight when sample_weight is not provided.
max_features : {"sqrt", "log2", None}, int or float, default="sqrt"
The number of features to consider when looking for the best split:
- If int, then consider `max_features` features at each split.
- If float, then `max_features` is a fraction and
`round(max_features * n_features)` features are considered at each
split.
- If "auto", then `max_features=sqrt(n_features)`.
- If "sqrt", then `max_features=sqrt(n_features)`.
- If "log2", then `max_features=log2(n_features)`.
- If None, then `max_features=n_features`.
Note: the search for a split does not stop until at least one
valid partition of the node samples is found, even if it requires to
effectively inspect more than ``max_features`` features.
max_leaf_nodes : int, default=None
Grow trees with ``max_leaf_nodes`` in best-first fashion.
Best nodes are defined as relative reduction in impurity.
If None then unlimited number of leaf nodes.
min_impurity_decrease : float, default=0.0
A node will be split if this split induces a decrease of the impurity
greater than or equal to this value.
The weighted impurity decrease equation is the following::
N_t / N * (impurity - N_t_R / N_t * right_impurity
- N_t_L / N_t * left_impurity)
where ``N`` is the total number of samples, ``N_t`` is the number of
samples at the current node, ``N_t_L`` is the number of samples in the
left child, and ``N_t_R`` is the number of samples in the right child.
``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum,
if ``sample_weight`` is passed.
bootstrap : bool, default=True
Whether bootstrap samples are used when building trees. If False, the
whole dataset is used to build each tree.
oob_score : bool, default=False
Whether to use out-of-bag samples to estimate the generalization score.
Only available if bootstrap=True.
n_jobs : int, default=None
The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`,
:meth:`decision_path` and :meth:`apply` are all parallelized over the
trees. ``None`` means 1 unless in a :obj:`joblib.parallel_backend`
context. ``-1`` means using all processors. See :term:`Glossary
<n_jobs>` for more details.
random_state : int, RandomState instance or None, default=None
Controls both the randomness of the bootstrapping of the samples used
when building trees (if ``bootstrap=True``) and the sampling of the
features to consider when looking for the best split at each node
(if ``max_features < n_features``).
See :term:`Glossary <random_state>` for details.
verbose : int, default=0
Controls the verbosity when fitting and predicting.
warm_start : bool, default=False
When set to ``True``, reuse the solution of the previous call to fit
and add more estimators to the ensemble, otherwise, just fit a whole
new forest. See :term:`the Glossary <warm_start>`.
max_samples : int or float, default=None
If bootstrap is True, the number of samples to draw from X
to train each base estimator.
- If None (default), then draw `X.shape[0]` samples.
- If int, then draw `max_samples` samples.
- If float, then draw `max_samples * X.shape[0]` samples. Thus,
`max_samples` should be in the interval `(0.0, 1.0]`.
feature_combinations : float, default=None
The number of features to combine on average at each split
of the decision trees. If ``None``, then will default to the minimum of
``(1.5, n_features)``. This controls the number of non-zeros is the
projection matrix. Setting the value to 1.0 is equivalent to a
traditional decision-tree. ``feature_combinations * max_features``
gives the number of expected non-zeros in the projection matrix of shape
``(max_features, n_features)``. Thus this value must always be less than
``n_features`` in order to be valid.
Attributes
----------
estimators_ : list of ExtraObliqueDecisionTreeRegressor
The collection of fitted sub-estimators.
n_features_ : int
The number of features when ``fit`` is performed.
n_features_in_ : int
Number of features seen during :term:`fit`.
feature_names_in_ : ndarray of shape (`n_features_in_`,)
Names of features seen during :term:`fit`. Defined only when `X`
has feature names that are all strings.
n_outputs_ : int
The number of outputs when ``fit`` is performed.
feature_importances_ : ndarray of shape (n_features,)
The impurity-based feature importances.
The higher, the more important the feature.
The importance of a feature is computed as the (normalized)
total reduction of the criterion brought by that feature. It is also
known as the Gini importance.
Warning: impurity-based feature importances can be misleading for
high cardinality features (many unique values). See
:func:`sklearn.inspection.permutation_importance` as an alternative.
oob_score_ : float
Score of the training dataset obtained using an out-of-bag estimate.
This attribute exists only when ``oob_score`` is True.
oob_decision_function_ : ndarray of shape (n_samples, n_classes) or \
(n_samples, n_classes, n_outputs)
Decision function computed with out-of-bag estimate on the training
set. If n_estimators is small it might be possible that a data point
was never left out during the bootstrap. In this case,
`oob_decision_function_` might contain NaN. This attribute exists
only when ``oob_score`` is True.
See Also
--------
treeple.tree.ExtraObliqueDecisionTreeRegressor : An extra oblique decision
tree regressor.
treeple.tree.ObliqueDecisionTreeRegressor : An oblique decision
tree regressor.
sklearn.ensemble.RandomForestRegressor : An axis-aligned decision
forest regressor.
Notes
-----
The default values for the parameters controlling the size of the trees
(e.g. ``max_depth``, ``min_samples_leaf``, etc.) lead to fully grown and
unpruned trees which can potentially be very large on some data sets. To
reduce memory consumption, the complexity and size of the trees should be
controlled by setting those parameter values.
The features are always randomly permuted at each split. Therefore,
the best found split may vary, even with the same training data,
``max_features=n_features`` and ``bootstrap=False``, if the improvement
of the criterion is identical for several splits enumerated during the
search of the best split. To obtain a deterministic behaviour during
fitting, ``random_state`` has to be fixed.
References
----------
.. [1] L. Breiman, "Random Forests", Machine Learning, 45(1), 5-32, 2001.
.. [2] T. Tomita, "Sparse Projection Oblique Randomer Forests", \
Journal of Machine Learning Research, 21(104), 1-39, 2020.
.. [3] P. Geurts, D. Ernst., and L. Wehenkel, "Extremely randomized trees", \
Machine Learning, 63(1), 3-42, 2006.
Examples
--------
>>> from treeple.ensemble import ExtraObliqueRandomForestRegressor
>>> from sklearn.datasets import make_regression
>>> X, y = make_regression(n_features=4, n_informative=2,
... random_state=0, shuffle=False)
>>> regr = ExtraObliqueRandomForestRegressor(max_depth=2, random_state=0)
>>> regr.fit(X, y)
ExtraObliqueRandomForestRegressor(...)
>>> print(regr.predict([[0, 0, 0, 0]]))
[-3.05063517]
"""
_parameter_constraints: dict = {
**ForestRegressor._parameter_constraints,
**ExtraObliqueDecisionTreeRegressor._parameter_constraints,
}
_parameter_constraints.pop("splitter")
def __init__(
self,
n_estimators=100,
*,
criterion="squared_error",
max_depth=None,
min_samples_split=2,
min_samples_leaf=1,
min_weight_fraction_leaf=0.0,
max_features=1.0,
max_leaf_nodes=None,
min_impurity_decrease=0.0,
bootstrap=True,
oob_score=False,
n_jobs=None,
random_state=None,
verbose=0,
warm_start=False,
max_samples=None,
feature_combinations=None,
):
super().__init__(
estimator=ExtraObliqueDecisionTreeRegressor(),
n_estimators=n_estimators,
estimator_params=(
"criterion",
"max_depth",
"min_samples_split",
"min_samples_leaf",
"min_weight_fraction_leaf",
"max_features",
"max_leaf_nodes",
"min_impurity_decrease",
"random_state",
"feature_combinations",
),
bootstrap=bootstrap,
oob_score=oob_score,
n_jobs=n_jobs,
random_state=random_state,
verbose=verbose,
warm_start=warm_start,
max_samples=max_samples,
)
self.criterion = criterion
self.max_depth = max_depth
self.min_samples_split = min_samples_split
self.min_samples_leaf = min_samples_leaf
self.min_weight_fraction_leaf = min_weight_fraction_leaf
self.max_features = max_features
self.max_leaf_nodes = max_leaf_nodes
self.min_impurity_decrease = min_impurity_decrease
self.feature_combinations = feature_combinations
# unused by oblique forests
self.min_weight_fraction_leaf = min_weight_fraction_leaf
self.max_leaf_nodes = max_leaf_nodes
self.min_impurity_decrease = min_impurity_decrease

_supervised_forest.py at commit 75c2cf9, under other · at the source

Overview

Authors: Tingshan Liu¹, Jayanta Dey¹, Beiya Xu¹, Eric W. Bridgeford², Samuel Alldritt³, Karl-Heinz Nenning⁴, Kyoungseob Byeon³, Ting Xu³, Joshua T. Vogelstein⁵

ORCID iDs: Tingshan Liu, Jayanta Dey, Beiya Xu, Eric W. Bridgeford, Karl-Heinz Nenning, Ting Xu, Joshua T. Vogelstein

Institutions: Johns Hopkins University (United States); The University of Texas at San Antonio (United States); Child Mind Institute (United States)

Journal: PloS one, volume 21, issue 4, article e0346575

Dates: received 17 July 2025; accepted 21 March 2026; published online 16 April 2026

Type: Research article · Language: English

License: CC BY

Identifiers: DOI 10.1371/journal.pone.0346575 · PMID 41989998 · PMCID PMC13086332 · OpenAlex W4412440324

Open access: gold, a free copy (OpenAlex)

Preprint: doi:10.1101/2025.07.09.664026

Status: code verified

Categories: structural MRI / diffusion (modality), human (organism), non-human primate (organism), methods / tools (subfield)

Methods: Connectivity, Statistics, Machine learning, Preprocessing

MeSH: Brain*, Machine Learning*, Neuroimaging*, Algorithms, Animals, Classification Algorithms, Female, Humans, Macaca, Magnetic Resonance Imaging, Male, Random Forest, Sex Characteristics (* major topic)

Journal subjects: Biology and life sciences, Organisms, Eukaryota, Animals, Vertebrates, Amniotes, Mammals, Primates, Monkeys, Old World monkeys, Macaque, Zoology, Medicine and Health Sciences, Diagnostic Medicine, Diagnostic Radiology, Magnetic Resonance Imaging, Research and Analysis Methods, Imaging Techniques, Radiology and Imaging, Neuroimaging, Neuroscience, Plants, Trees, Physical Sciences, Mathematics, Applied Mathematics, Algorithms, Simulation and Modeling, Anatomy, Nervous System, Central Nervous System, Discrete Mathematics, Combinatorics, Permutation, Computer and Information Sciences, Artificial Intelligence, Machine Learning

Topic: Genetic Associations and Epidemiology (Genetics, Biochemistry, Genetics and Molecular Biology), according to OpenAlex

Funding: NIH (2U19NS104653, 1RF1MH128696); National Science Foundation (NSF 20–540)

Citations: not cited yet (Europe PMC); 34 references in the paper

Abstract

Sex classification using neuroimaging data has the potential to revolutionize personalized diagnostics by revealing subtle structural brain differences that underlie sex-specific disease risks. Despite the promise of machine learning, traditional methods often fall short in providing both high classification accuracy and interpretable, statistically validated feature importance scores for high-dimensional imaging data. This gap is particularly evident when conventional techniques such as random forests, LIME, and SHAP are applied, as they struggle with complex feature interactions and managing noise in large datasets. We address this challenge by developing an integrated framework that combines Oblique Random Forests (ORFs) with a novel, permutation-based feature importance testing algorithm. ORFs extend traditional random forests by employing oblique decision boundaries through linear combinations of features, thereby capturing intricate interactions inherent in neuroimaging data. Our feature importance testing method, NEOFIT, rigorously quantifies the significance of each feature by generating null distributions and corrected p-values. We first validate our approach using simulated datasets, establishing its robustness and scalability under controlled conditions. We then apply our method to classify sex from both voxel-wise structural MRI and cortical thickness data in humans and macaques, facilitating direct cross-species comparisons. ORFs achieves AUC > 0.80 on human data, and >0.70 on macaque data, while NEOFIT identifies statistically significant features aligned with sex-dimorphic neuroanatomy. Our results demonstrate that the proposed framework not only enhances classification performance but also provides clear, interpretable insights into the neuroanatomical features that distinguish sexes. These methodological advancements pave the way for improved diagnostic tools and contribute to a deeper understanding of the evolutionary basis of sex differences in brain structure.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repositories

Its files are read in the Code ↔ Paper reader above, with 9 matches between paragraphs and lines of code.

google/yggdrasil-decision-forests

License: Apache-2.0

State: the link answers, verified on 29 September 2026

Evidence: files inventoried

Commit: 240fd063a047033d683d739c7b5b2f556cf7a5a9, 29 September 2026

Languages: C++ (350), C/C++ (229), Python (184), Jupyter (42), Go (41), Shell (24), JavaScript (10), TypeScript (7), NEURON (1), Java (1)

Size: 1,608 files, 889 scripts

Software Heritage: archived

Found in: the text, “Future work”

Holds: README, license file, CITATION.cff, environment (documentation/public/requirements.txt, yggdrasil_decision_forests/port/python/Dockerfile, yggdrasil_decision_forests/port/python/requirements.txt, yggdrasil_decision_forests/port/python/requirements_lock.txt, yggdrasil_decision_forests/port/python/config/setup.py, yggdrasil_decision_forests/port/tensorflow/pip_pkg/setup.py), tests, continuous integration, documentation, 42 notebooks

Tools: NumPy (84 files), pandas (63 files), JAX (21 files), TensorFlow (17 files), scikit-learn (11 files), Matplotlib (7 files), xarray (5 files), SciPy (2 files), UMAP (2 files), Plotly (1 file), PyTorch (1 file), seaborn (1 file), Hugging Face Transformers (1 file)

Availability: 1 check, the latest on 29 September 2026: the link answers

29 September 2026: the link answers

891 files

documentation/public/copy_external.py, Python, 43 lines
documentation/public/docs/js/mathjax.js, JavaScript, 26 lines
documentation/public/docs/tutorial/anomaly_detection.ipynb, Jupyter, 193 lines
documentation/public/docs/tutorial/categorical_feature.ipynb, Jupyter, 55 lines
documentation/public/docs/tutorial/categorical_set_feature.ipynb, Jupyter, 152 lines
documentation/public/docs/tutorial/classification.ipynb, Jupyter, 94 lines
documentation/public/docs/tutorial/compose_with_jax.ipynb, Jupyter, 362 lines
documentation/public/docs/tutorial/compose_with_tf.ipynb, Jupyter, 330 lines
documentation/public/docs/tutorial/compose_with_tf_plots.ipynb, Jupyter, 43 lines
documentation/public/docs/tutorial/counterfactual.ipynb, Jupyter, 217 lines
documentation/public/docs/tutorial/cpp.ipynb, Jupyter, 81 lines
documentation/public/docs/tutorial/cpp_standalone.ipynb, Jupyter, 237 lines
documentation/public/docs/tutorial/cross_validation.ipynb, Jupyter, 36 lines
documentation/public/docs/tutorial/custom_loss.ipynb, Jupyter, 293 lines
documentation/public/docs/tutorial/distributed_training.ipynb, Jupyter, 137 lines
documentation/public/docs/tutorial/distributed_training_vertex_ai.ipynb, Jupyter, 374 lines
documentation/public/docs/tutorial/editing_trees.ipynb, Jupyter, 159 lines
documentation/public/docs/tutorial/feature_selection.ipynb, Jupyter, 134 lines
documentation/public/docs/tutorial/getting_started.ipynb, Jupyter, 181 lines
documentation/public/docs/tutorial/inspecting_trees.ipynb, Jupyter, 74 lines
documentation/public/docs/tutorial/java_standalone.ipynb, Jupyter, 202 lines
documentation/public/docs/tutorial/log_book.ipynb, Jupyter, 228 lines
documentation/public/docs/tutorial/migrating_to_ydf.ipynb, Jupyter, 200 lines
documentation/public/docs/tutorial/model_understanding.ipynb, Jupyter, 114 lines
documentation/public/docs/tutorial/monotonic_feature.ipynb, Jupyter, 50 lines
documentation/public/docs/tutorial/multidimensional_feature.ipynb, Jupyter, 70 lines
documentation/public/docs/tutorial/numerical_feature.ipynb, Jupyter, 69 lines
documentation/public/docs/tutorial/numerical_vector_sequence.ipynb, Jupyter, 254 lines
documentation/public/docs/tutorial/numpy.ipynb, Jupyter, 60 lines
documentation/public/docs/tutorial/pandas.ipynb, Jupyter, 84 lines
documentation/public/docs/tutorial/prediction_understanding.ipynb, Jupyter, 52 lines
documentation/public/docs/tutorial/pretrained_embedding.ipynb, Jupyter, 104 lines
documentation/public/docs/tutorial/ranking.ipynb, Jupyter, 73 lines
documentation/public/docs/tutorial/regression.ipynb, Jupyter, 66 lines
documentation/public/docs/tutorial/tf_dataset.ipynb, Jupyter, 98 lines
documentation/public/docs/tutorial/tf_serving.ipynb, Jupyter, 318 lines
documentation/public/docs/tutorial/time_sequences.ipynb, Jupyter, 196 lines
documentation/public/docs/tutorial/to_docker.ipynb, Jupyter, 99 lines
documentation/public/docs/tutorial/train_and_test.ipynb, Jupyter, 52 lines
documentation/public/docs/tutorial/tuning.ipynb, Jupyter, 145 lines
documentation/public/docs/tutorial/uplifting.ipynb, Jupyter, 83 lines
documentation/public/docs/tutorial/usage_example.ipynb, Jupyter, 44 lines
documentation/public/docs/tutorial/xarray.ipynb, Jupyter, 43 lines
documentation/public/update_scs_paths.py, Python, 37 lines
examples/beginner.cc, C++, 207 lines
examples/beginner.sh, Shell, 115 lines
examples/distributed_training.sh, Shell, 151 lines
examples/fast_8bits_numerical.cc, C++, 218 lines
examples/hyperparameter_sweep/manager_main.cc, C++, 246 lines
examples/hyperparameter_sweep/plot_results.ipynb, Jupyter, 115 lines
examples/hyperparameter_sweep/prepare_data.py, Python, 65 lines
examples/hyperparameter_sweep/run_local.sh, Shell, 36 lines
examples/hyperparameter_sweep/worker.cc, C++, 197 lines
examples/hyperparameter_tuning.sh, Shell, 210 lines
examples/standalone/beginner.cc, C++, 192 lines
examples/standalone/compile_and_run.sh, Shell, 35 lines
examples/text_classification.sh, Shell, 136 lines
examples/vizier_tuning_python/main.py, Python, 187 lines
tools/build_binary_release.sh, Shell, 100 lines
tools/build_binary_release_in_docker.sh, Shell, 36 lines
tools/generate_go_proto_wrappers.sh, Shell, 137 lines
tools/https_server.py, Python, 66 lines
tools/test_bazel.sh, Shell, 83 lines
tools/test_go.sh, Shell, 25 lines
tools/test_windows.sh, Shell, 66 lines
yggdrasil_decision_forests/api/serving.h, C/C++, 91 lines
yggdrasil_decision_forests/api/training.h, C/C++, 106 lines
yggdrasil_decision_forests/cli/analyze_model_and_dataset.cc, C++, 91 lines
yggdrasil_decision_forests/cli/benchmark_inference.cc, C++, 192 lines
yggdrasil_decision_forests/cli/cli_test.sh, Shell, 98 lines
yggdrasil_decision_forests/cli/compute_variable_importances.cc, C++, 103 lines
yggdrasil_decision_forests/cli/convert_dataset.cc, C++, 129 lines
yggdrasil_decision_forests/cli/edit_model.cc, C++, 133 lines
yggdrasil_decision_forests/cli/evaluate.cc, C++, 116 lines
yggdrasil_decision_forests/cli/infer_dataspec.cc, C++, 80 lines
yggdrasil_decision_forests/cli/monitoring/benchmark_training.cc, C++, 976 lines
yggdrasil_decision_forests/cli/monitoring/compare_benchmark.py, Python, 68 lines
yggdrasil_decision_forests/cli/monitoring/run_benchmark_training.sh, Shell, 33 lines
yggdrasil_decision_forests/cli/predict.cc, C++, 213 lines
yggdrasil_decision_forests/cli/show_dataspec.cc, C++, 70 lines
yggdrasil_decision_forests/cli/show_model.cc, C++, 154 lines
yggdrasil_decision_forests/cli/train.cc, C++, 141 lines
yggdrasil_decision_forests/cli/utils/synthetic_dataset.cc, C++, 103 lines
yggdrasil_decision_forests/dataset/avro.cc, C++, 687 lines
yggdrasil_decision_forests/dataset/avro.h, C/C++, 190 lines
yggdrasil_decision_forests/dataset/avro_example.cc, C++, 915 lines
yggdrasil_decision_forests/dataset/avro_example.h, C/C++, 132 lines
yggdrasil_decision_forests/dataset/avro_example_test.cc, C++, 648 lines
yggdrasil_decision_forests/dataset/avro_test.cc, C++, 348 lines
yggdrasil_decision_forests/dataset/csv_example_reader.cc, C++, 443 lines
yggdrasil_decision_forests/dataset/csv_example_reader.h, C/C++, 124 lines
yggdrasil_decision_forests/dataset/csv_example_writer.cc, C++, 64 lines
yggdrasil_decision_forests/dataset/csv_example_writer.h, C/C++, 82 lines
yggdrasil_decision_forests/dataset/data_spec.cc, C++, 1,046 lines
yggdrasil_decision_forests/dataset/data_spec.h, C/C++, 259 lines
yggdrasil_decision_forests/dataset/data_spec_inference.cc, C++, 839 lines
yggdrasil_decision_forests/dataset/data_spec_inference.h, C/C++, 218 lines
yggdrasil_decision_forests/dataset/data_spec_inference_test.cc, C++, 1,251 lines
yggdrasil_decision_forests/dataset/data_spec_test.cc, C++, 727 lines
yggdrasil_decision_forests/dataset/example_builder.cc, C++, 83 lines
yggdrasil_decision_forests/dataset/example_builder.h, C/C++, 58 lines
yggdrasil_decision_forests/dataset/example_builder_test.cc, C++, 61 lines
yggdrasil_decision_forests/dataset/example_reader.cc, C++, 72 lines
yggdrasil_decision_forests/dataset/example_reader.h, C/C++, 78 lines
yggdrasil_decision_forests/dataset/example_reader_interface.h, C/C++, 56 lines
yggdrasil_decision_forests/dataset/example_reader_test.cc, C++, 99 lines
yggdrasil_decision_forests/dataset/example_writer.cc, C++, 57 lines
yggdrasil_decision_forests/dataset/example_writer.h, C/C++, 57 lines
yggdrasil_decision_forests/dataset/example_writer_interface.h, C/C++, 50 lines
yggdrasil_decision_forests/dataset/example_writer_test.cc, C++, 94 lines
yggdrasil_decision_forests/dataset/formats.cc, C++, 185 lines
yggdrasil_decision_forests/dataset/formats.h, C/C++, 72 lines
yggdrasil_decision_forests/dataset/formats_test.cc, C++, 47 lines
yggdrasil_decision_forests/dataset/synthetic_dataset.cc, C++, 894 lines
yggdrasil_decision_forests/dataset/synthetic_dataset.h, C/C++, 72 lines
yggdrasil_decision_forests/dataset/synthetic_dataset_test.cc, C++, 244 lines
yggdrasil_decision_forests/dataset/tensorflow/tf_example.cc, C++, 503 lines
yggdrasil_decision_forests/dataset/tensorflow/tf_example.h, C/C++, 67 lines
yggdrasil_decision_forests/dataset/tensorflow/tf_example_io_interface.cc, C++, 539 lines
yggdrasil_decision_forests/dataset/tensorflow/tf_example_io_interface.h, C/C++, 161 lines
yggdrasil_decision_forests/dataset/tensorflow/tf_example_io_interface_test.cc, C++, 162 lines
yggdrasil_decision_forests/dataset/tensorflow/tf_example_io_tfrecord.cc, C++, 20 lines
yggdrasil_decision_forests/dataset/tensorflow/tf_example_io_tfrecord.h, C/C++, 88 lines
yggdrasil_decision_forests/dataset/tensorflow/tf_example_test.cc, C++, 327 lines
yggdrasil_decision_forests/dataset/tensorflow_no_dep/tf_example.cc, C++, 58 lines
yggdrasil_decision_forests/dataset/tensorflow_no_dep/tf_example.h, C/C++, 47 lines
yggdrasil_decision_forests/dataset/tensorflow_no_dep/tf_record.cc, C++, 212 lines
yggdrasil_decision_forests/dataset/tensorflow_no_dep/tf_record.h, C/C++, 195 lines
yggdrasil_decision_forests/dataset/tensorflow_no_dep/tf_record_test.cc, C++, 190 lines
yggdrasil_decision_forests/dataset/tensorflow_no_dep/tf_record_tf_example.cc, C++, 18 lines
yggdrasil_decision_forests/dataset/tensorflow_no_dep/tf_record_tf_example.h, C/C++, 142 lines
yggdrasil_decision_forests/dataset/tensorflow_no_dep/tf_record_tf_example_test.cc, C++, 231 lines
yggdrasil_decision_forests/dataset/types.cc, C++, 42 lines
yggdrasil_decision_forests/dataset/types.h, C/C++, 56 lines
yggdrasil_decision_forests/dataset/vertical_dataset.cc, C++, 1,136 lines
yggdrasil_decision_forests/dataset/vertical_dataset.h, C/C++, 1,206 lines
yggdrasil_decision_forests/dataset/vertical_dataset_column.cc, C++, 192 lines
yggdrasil_decision_forests/dataset/vertical_dataset_html.cc, C++, 119 lines
yggdrasil_decision_forests/dataset/vertical_dataset_html.h, C/C++, 50 lines
yggdrasil_decision_forests/dataset/vertical_dataset_html_test.cc, C++, 116 lines
yggdrasil_decision_forests/dataset/vertical_dataset_io.cc, C++, 270 lines
yggdrasil_decision_forests/dataset/vertical_dataset_io.h, C/C++, 87 lines
yggdrasil_decision_forests/dataset/vertical_dataset_io_test.cc, C++, 216 lines
yggdrasil_decision_forests/dataset/vertical_dataset_test.cc, C++, 746 lines
yggdrasil_decision_forests/dataset/weight.cc, C++, 298 lines
yggdrasil_decision_forests/dataset/weight.h, C/C++, 83 lines
yggdrasil_decision_forests/dataset/weight_test.cc, C++, 367 lines
yggdrasil_decision_forests/learner/abstract_learner.cc, C++, 1,353 lines
yggdrasil_decision_forests/learner/abstract_learner.h, C/C++, 357 lines
yggdrasil_decision_forests/learner/abstract_learner_test.cc, C++, 438 lines
yggdrasil_decision_forests/learner/cart/cart.cc, C++, 636 lines
yggdrasil_decision_forests/learner/cart/cart.h, C/C++, 103 lines
yggdrasil_decision_forests/learner/cart/cart_test.cc, C++, 355 lines
yggdrasil_decision_forests/learner/decision_tree/decision_tree_test.cc, C++, 3,338 lines
yggdrasil_decision_forests/learner/decision_tree/generic_parameters.cc, C++, 1,371 lines
yggdrasil_decision_forests/learner/decision_tree/generic_parameters.h, C/C++, 186 lines
yggdrasil_decision_forests/learner/decision_tree/generic_parameters_test.cc, C++, 393 lines
yggdrasil_decision_forests/learner/decision_tree/gpu.cc, C++, 283 lines
yggdrasil_decision_forests/learner/decision_tree/gpu.cu.cc, C++, 361 lines
yggdrasil_decision_forests/learner/decision_tree/gpu.h, C/C++, 179 lines
yggdrasil_decision_forests/learner/decision_tree/gpu_test.cc, C++, 291 lines
yggdrasil_decision_forests/learner/decision_tree/label.cc, C++, 232 lines
yggdrasil_decision_forests/learner/decision_tree/label.h, C/C++, 148 lines
yggdrasil_decision_forests/learner/decision_tree/oblique.cc, C++, 1,492 lines
yggdrasil_decision_forests/learner/decision_tree/oblique.h, C/C++, 310 lines
yggdrasil_decision_forests/learner/decision_tree/preprocessing.cc, C++, 147 lines
yggdrasil_decision_forests/learner/decision_tree/preprocessing.h, C/C++, 112 lines
yggdrasil_decision_forests/learner/decision_tree/preprocessing_test.cc, C++, 68 lines
yggdrasil_decision_forests/learner/decision_tree/splitter_accumulator.h, C/C++, 2,149 lines
yggdrasil_decision_forests/learner/decision_tree/splitter_scanner.h, C/C++, 2,105 lines
yggdrasil_decision_forests/learner/decision_tree/training.cc, C++, 4,499 lines
yggdrasil_decision_forests/learner/decision_tree/training.h, C/C++, 1,075 lines
yggdrasil_decision_forests/learner/decision_tree/training_test.cc, C++, 974 lines
yggdrasil_decision_forests/learner/decision_tree/uplift.h, C/C++, 708 lines
yggdrasil_decision_forests/learner/decision_tree/utils.cc, C++, 87 lines
yggdrasil_decision_forests/learner/decision_tree/utils.h, C/C++, 128 lines
yggdrasil_decision_forests/learner/decision_tree/vector_sequence.cc, C++, 433 lines
yggdrasil_decision_forests/learner/decision_tree/vector_sequence.h, C/C++, 68 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/dataset_cache/column_cache.cc, C++, 638 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/dataset_cache/column_cache.h, C/C++, 424 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/dataset_cache/column_cache_test.cc, C++, 301 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/dataset_cache/dataset_cache.cc, C++, 749 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/dataset_cache/dataset_cache.h, C/C++, 171 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/dataset_cache/dataset_cache_common.cc, C++, 247 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/dataset_cache/dataset_cache_common.h, C/C++, 196 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/dataset_cache/dataset_cache_common_test.cc, C++, 76 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/dataset_cache/dataset_cache_reader.cc, C++, 1,109 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/dataset_cache/dataset_cache_reader.h, C/C++, 353 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/dataset_cache/dataset_cache_reader_test.cc, C++, 219 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/dataset_cache/dataset_cache_test.cc, C++, 682 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/dataset_cache/dataset_cache_worker.cc, C++, 920 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/dataset_cache/dataset_cache_worker.h, C/C++, 100 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/label_accessor.h, C/C++, 364 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/load_balancer/load_balancer.cc, C++, 635 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/load_balancer/load_balancer.h, C/C++, 296 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/load_balancer/load_balancer_test.cc, C++, 351 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/splitter.h, C/C++, 1,359 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/training.cc, C++, 1,421 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/training.h, C/C++, 391 lines
yggdrasil_decision_forests/learner/distributed_decision_tree/training_test.cc, C++, 604 lines
yggdrasil_decision_forests/learner/distributed_gradient_boosted_trees/common.cc, C++, 66 lines
yggdrasil_decision_forests/learner/distributed_gradient_boosted_trees/common.h, C/C++, 74 lines
yggdrasil_decision_forests/learner/distributed_gradient_boosted_trees/distributed_gradient_boosted_trees.cc, C++, 2,131 lines
yggdrasil_decision_forests/learner/distributed_gradient_boosted_trees/distributed_gradient_boosted_trees.h, C/C++, 495 lines
yggdrasil_decision_forests/learner/distributed_gradient_boosted_trees/distributed_gradient_boosted_trees_test.cc, C++, 716 lines
yggdrasil_decision_forests/learner/distributed_gradient_boosted_trees/worker.cc, C++, 1,438 lines
yggdrasil_decision_forests/learner/distributed_gradient_boosted_trees/worker.h, C/C++, 364 lines
yggdrasil_decision_forests/learner/export_doc.cc, C++, 312 lines
yggdrasil_decision_forests/learner/export_doc.h, C/C++, 57 lines
yggdrasil_decision_forests/learner/export_doc_main.cc, C++, 61 lines
yggdrasil_decision_forests/learner/export_doc_test.cc, C++, 109 lines
yggdrasil_decision_forests/learner/generic_worker/generic_worker.cc, C++, 155 lines
yggdrasil_decision_forests/learner/generic_worker/generic_worker.h, C/C++, 70 lines
yggdrasil_decision_forests/learner/generic_worker/generic_worker_test.cc, C++, 108 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/early_stopping/early_stopping.cc, C++, 93 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/early_stopping/early_stopping.h, C/C++, 104 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/early_stopping/early_stopping_test.cc, C++, 126 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/gradient_boosted_trees.cc, C++, 3,558 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/gradient_boosted_trees.h, C/C++, 487 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/gradient_boosted_trees_hparams_templates.cc, C++, 89 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/gradient_boosted_trees_test.cc, C++, 3,327 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/gradient_boosted_trees_tuner_test.cc, C++, 92 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_binary_focal.cc, C++, 348 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_binary_focal.h, C/C++, 155 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_binary_focal_test.cc, C++, 245 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_binomial.cc, C++, 329 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_binomial.h, C/C++, 139 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_binomial_test.cc, C++, 234 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_cox.cc, C++, 287 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_cox.h, C/C++, 141 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_cox_test.cc, C++, 342 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_cross_entropy_ndcg.cc, C++, 219 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_cross_entropy_ndcg.h, C/C++, 105 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_custom_binary_classification.cc, C++, 122 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_custom_binary_classification.h, C/C++, 118 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_custom_binary_classification_test.cc, C++, 257 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_custom_multi_classification.cc, C++, 136 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_custom_multi_classification.h, C/C++, 120 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_custom_multi_classification_test.cc, C++, 279 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_custom_regression.cc, C++, 119 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_custom_regression.h, C/C++, 117 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_custom_regression_test.cc, C++, 233 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_mean_average_error.cc, C++, 186 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_mean_average_error.h, C/C++, 92 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_mean_average_error_test.cc, C++, 234 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_mean_square_error.cc, C++, 218 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_mean_square_error.h, C/C++, 112 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_mean_square_error_test.cc, C++, 264 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_multinomial.cc, C++, 369 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_multinomial.h, C/C++, 140 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_multinomial_test.cc, C++, 234 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_ndcg.cc, C++, 439 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_ndcg.h, C/C++, 119 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_ndcg_test.cc, C++, 432 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_poisson.cc, C++, 245 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_poisson.h, C/C++, 101 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_imp_poisson_test.cc, C++, 348 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_interface.cc, C++, 312 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_interface.h, C/C++, 386 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_library.cc, C++, 89 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_library.h, C/C++, 53 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_library_test.cc, C++, 232 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_utils.cc, C++, 272 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_utils.h, C/C++, 98 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/loss/loss_utils_test.cc, C++, 84 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/plot_training.cc, C++, 186 lines
yggdrasil_decision_forests/learner/gradient_boosted_trees/plot_training.h, C/C++, 38 lines
yggdrasil_decision_forests/learner/hyperparameters_optimizer/hyperparameters_optimizer.cc, C++, 923 lines
yggdrasil_decision_forests/learner/hyperparameters_optimizer/hyperparameters_optimizer.h, C/C++, 209 lines
yggdrasil_decision_forests/learner/hyperparameters_optimizer/hyperparameters_optimizer_test.cc, C++, 432 lines
yggdrasil_decision_forests/learner/hyperparameters_optimizer/optimizer_interface.h, C/C++, 124 lines
yggdrasil_decision_forests/learner/hyperparameters_optimizer/optimizers/random.cc, C++, 264 lines
yggdrasil_decision_forests/learner/hyperparameters_optimizer/optimizers/random.h, C/C++, 121 lines
yggdrasil_decision_forests/learner/hyperparameters_optimizer/optimizers/random_test.cc, C++, 260 lines
yggdrasil_decision_forests/learner/isolation_forest/isolation_forest.cc, C++, 971 lines
yggdrasil_decision_forests/learner/isolation_forest/isolation_forest.h, C/C++, 155 lines
yggdrasil_decision_forests/learner/isolation_forest/isolation_forest_test.cc, C++, 566 lines
yggdrasil_decision_forests/learner/learner_library.cc, C++, 66 lines
yggdrasil_decision_forests/learner/learner_library.h, C/C++, 49 lines
yggdrasil_decision_forests/learner/learner_library_test.cc, C++, 51 lines
yggdrasil_decision_forests/learner/multitasker/multitasker.cc, C++, 399 lines
yggdrasil_decision_forests/learner/multitasker/multitasker.h, C/C++, 80 lines
yggdrasil_decision_forests/learner/multitasker/multitasker_test.cc, C++, 334 lines
yggdrasil_decision_forests/learner/postprocessor/postprocessor_library.cc, C++, 55 lines
yggdrasil_decision_forests/learner/postprocessor/postprocessor_library.h, C/C++, 41 lines
yggdrasil_decision_forests/learner/postprocessor/postprocessor_library_test.cc, C++, 133 lines
yggdrasil_decision_forests/learner/postprocessor/smoothed_pav_calibrator/smoothed_pav_calibrator.cc, C++, 130 lines
yggdrasil_decision_forests/learner/postprocessor/smoothed_pav_calibrator/smoothed_pav_calibrator.h, C/C++, 44 lines
yggdrasil_decision_forests/learner/postprocessor/smoothed_pav_calibrator/smoothed_pav_calibrator_test.cc, C++, 245 lines
yggdrasil_decision_forests/learner/random_forest/random_forest.cc, C++, 1,709 lines
yggdrasil_decision_forests/learner/random_forest/random_forest.h, C/C++, 449 lines
yggdrasil_decision_forests/learner/random_forest/random_forest_hparams_templates.cc, C++, 138 lines
yggdrasil_decision_forests/learner/random_forest/random_forest_test.cc, C++, 1,949 lines
yggdrasil_decision_forests/learner/random_forest/random_forest_tuner_test.cc, C++, 88 lines
yggdrasil_decision_forests/metric/comparison.cc, C++, 371 lines
yggdrasil_decision_forests/metric/comparison.h, C/C++, 79 lines
yggdrasil_decision_forests/metric/comparison_test.cc, C++, 252 lines
yggdrasil_decision_forests/metric/labels.h, C/C++, 53 lines
yggdrasil_decision_forests/metric/metric.cc, C++, 2,616 lines
yggdrasil_decision_forests/metric/metric.h, C/C++, 399 lines
yggdrasil_decision_forests/metric/metric_test.cc, C++, 1,971 lines
yggdrasil_decision_forests/metric/ranking_ap.cc, C++, 50 lines
yggdrasil_decision_forests/metric/ranking_ap.h, C/C++, 47 lines
yggdrasil_decision_forests/metric/ranking_mrr.cc, C++, 42 lines
yggdrasil_decision_forests/metric/ranking_mrr.h, C/C++, 47 lines
yggdrasil_decision_forests/metric/ranking_ndcg.cc, C++, 133 lines
yggdrasil_decision_forests/metric/ranking_ndcg.h, C/C++, 79 lines
yggdrasil_decision_forests/metric/ranking_utils.h, C/C++, 45 lines
yggdrasil_decision_forests/metric/report.cc, C++, 741 lines
yggdrasil_decision_forests/metric/report.h, C/C++, 71 lines
yggdrasil_decision_forests/metric/report_test.cc, C++, 203 lines
yggdrasil_decision_forests/metric/uplift.cc, C++, 225 lines
yggdrasil_decision_forests/metric/uplift.h, C/C++, 80 lines
yggdrasil_decision_forests/metric/uplift_test.cc, C++, 146 lines
yggdrasil_decision_forests/model/abstract_model.cc, C++, 1,735 lines
yggdrasil_decision_forests/model/abstract_model.h, C/C++, 762 lines
yggdrasil_decision_forests/model/abstract_model_test.cc, C++, 673 lines
yggdrasil_decision_forests/model/decision_tree/builder.cc, C++, 96 lines
yggdrasil_decision_forests/model/decision_tree/builder.h, C/C++, 68 lines
yggdrasil_decision_forests/model/decision_tree/builder_test.cc, C++, 77 lines
yggdrasil_decision_forests/model/decision_tree/decision_forest_interface.h, C/C++, 96 lines
yggdrasil_decision_forests/model/decision_tree/decision_tree.cc, C++, 2,308 lines
yggdrasil_decision_forests/model/decision_tree/decision_tree.h, C/C++, 508 lines
yggdrasil_decision_forests/model/decision_tree/decision_tree_io.cc, C++, 173 lines
yggdrasil_decision_forests/model/decision_tree/decision_tree_io.h, C/C++, 75 lines
yggdrasil_decision_forests/model/decision_tree/decision_tree_io_blob_sequence.cc, C++, 67 lines
yggdrasil_decision_forests/model/decision_tree/decision_tree_io_interface.h, C/C++, 61 lines
yggdrasil_decision_forests/model/decision_tree/decision_tree_test.cc, C++, 1,449 lines
yggdrasil_decision_forests/model/decision_tree/structure_analysis.cc, C++, 208 lines
yggdrasil_decision_forests/model/decision_tree/structure_analysis.h, C/C++, 91 lines
yggdrasil_decision_forests/model/describe.cc, C++, 742 lines
yggdrasil_decision_forests/model/describe.h, C/C++, 50 lines
yggdrasil_decision_forests/model/describe_test.cc, C++, 101 lines
yggdrasil_decision_forests/model/evaluate_on_disk.cc, C++, 160 lines
yggdrasil_decision_forests/model/evaluate_on_disk.h, C/C++, 43 lines
yggdrasil_decision_forests/model/fast_engine_factory.cc, C++, 37 lines
yggdrasil_decision_forests/model/fast_engine_factory.h, C/C++, 63 lines
yggdrasil_decision_forests/model/gradient_boosted_trees/gradient_boosted_trees.cc, C++, 1,058 lines
yggdrasil_decision_forests/model/gradient_boosted_trees/gradient_boosted_trees.h, C/C++, 320 lines
yggdrasil_decision_forests/model/gradient_boosted_trees/gradient_boosted_trees_test.cc, C++, 472 lines
yggdrasil_decision_forests/model/isolation_forest/isolation_forest.cc, C++, 659 lines
yggdrasil_decision_forests/model/isolation_forest/isolation_forest.h, C/C++, 179 lines
yggdrasil_decision_forests/model/isolation_forest/isolation_forest_test.cc, C++, 302 lines
yggdrasil_decision_forests/model/metadata.cc, C++, 58 lines
yggdrasil_decision_forests/model/metadata.h, C/C++, 65 lines
yggdrasil_decision_forests/model/model_engine_wrapper.cc, C++, 59 lines
yggdrasil_decision_forests/model/model_engine_wrapper.h, C/C++, 87 lines
yggdrasil_decision_forests/model/model_library.cc, C++, 273 lines
yggdrasil_decision_forests/model/model_library.h, C/C++, 89 lines
yggdrasil_decision_forests/model/model_library_test.cc, C++, 72 lines
yggdrasil_decision_forests/model/model_testing.h, C/C++, 61 lines
yggdrasil_decision_forests/model/multitasker/multitasker.cc, C++, 126 lines
yggdrasil_decision_forests/model/multitasker/multitasker.h, C/C++, 94 lines
yggdrasil_decision_forests/model/postprocessor/abstract_postprocessor.cc, C++, 104 lines
yggdrasil_decision_forests/model/postprocessor/abstract_postprocessor.h, C/C++, 128 lines
yggdrasil_decision_forests/model/postprocessor/abstract_postprocessor_test.cc, C++, 162 lines
yggdrasil_decision_forests/model/postprocessor/postprocessor_library.cc, C++, 52 lines
yggdrasil_decision_forests/model/postprocessor/postprocessor_library.h, C/C++, 36 lines
yggdrasil_decision_forests/model/postprocessor/postprocessor_library_test.cc, C++, 65 lines
yggdrasil_decision_forests/model/postprocessor/smoothed_pav_calibrator/smoothed_pav_calibrator.cc, C++, 156 lines
yggdrasil_decision_forests/model/postprocessor/smoothed_pav_calibrator/smoothed_pav_calibrator.h, C/C++, 99 lines
yggdrasil_decision_forests/model/postprocessor/smoothed_pav_calibrator/smoothed_pav_calibrator_test.cc, C++, 224 lines
yggdrasil_decision_forests/model/random_forest/random_forest.cc, C++, 823 lines
yggdrasil_decision_forests/model/random_forest/random_forest.h, C/C++, 320 lines
yggdrasil_decision_forests/model/random_forest/random_forest_test.cc, C++, 542 lines
yggdrasil_decision_forests/port/go/cli/benchmark_inference/benchmark_inference.go, Go, 279 lines
yggdrasil_decision_forests/port/go/cli/benchmark_inference/benchmark_inference_test.go, Go, 38 lines
yggdrasil_decision_forests/port/go/dataset/proto/data_spec.pb.go, Go, 2,546 lines
yggdrasil_decision_forests/port/go/dataset/proto/proto.go, Go, 31 lines
yggdrasil_decision_forests/port/go/dataset/proto/weight.pb.go, Go, 683 lines
yggdrasil_decision_forests/port/go/go.mod, NEURON, 7 lines
yggdrasil_decision_forests/port/go/metric/proto/metric.pb.go, Go, 3,962 lines
yggdrasil_decision_forests/port/go/metric/proto/proto.go, Go, 28 lines
yggdrasil_decision_forests/port/go/model/canonical/canonical.go, Go, 42 lines
yggdrasil_decision_forests/port/go/model/decisiontree/decisiontree.go, Go, 143 lines
yggdrasil_decision_forests/port/go/model/decisiontree/decisiontree_test.go, Go, 37 lines
yggdrasil_decision_forests/port/go/model/decisiontree/io/blobsequence/blob_sequence.go, Go, 144 lines
yggdrasil_decision_forests/port/go/model/decisiontree/io/canonical/canonical.go, Go, 22 lines
yggdrasil_decision_forests/port/go/model/decisiontree/io/io.go, Go, 103 lines
yggdrasil_decision_forests/port/go/model/decisiontree/proto/decision_tree.pb.go, Go, 1,467 lines
yggdrasil_decision_forests/port/go/model/decisiontree/proto/proto.go, Go, 28 lines
yggdrasil_decision_forests/port/go/model/gradientboostedtrees/gradientboostedtrees.go, Go, 104 lines
yggdrasil_decision_forests/port/go/model/gradientboostedtrees/gradientboostedtrees_test.go, Go, 42 lines
yggdrasil_decision_forests/port/go/model/gradientboostedtrees/proto/gradient_boosted_trees.pb.go, Go, 634 lines
yggdrasil_decision_forests/port/go/model/gradientboostedtrees/proto/proto.go, Go, 28 lines
yggdrasil_decision_forests/port/go/model/io/canonical/canonical.go, Go, 46 lines
yggdrasil_decision_forests/port/go/model/io/io.go, Go, 109 lines
yggdrasil_decision_forests/port/go/model/io/io_test.go, Go, 33 lines
yggdrasil_decision_forests/port/go/model/model.go, Go, 61 lines
yggdrasil_decision_forests/port/go/model/proto/abstract_model.pb.go, Go, 911 lines
yggdrasil_decision_forests/port/go/model/proto/hyperparameter.pb.go, Go, 1,740 lines
yggdrasil_decision_forests/port/go/model/proto/prediction.pb.go, Go, 690 lines
yggdrasil_decision_forests/port/go/model/proto/proto.go, Go, 34 lines
yggdrasil_decision_forests/port/go/model/randomforest/proto/proto.go, Go, 28 lines
yggdrasil_decision_forests/port/go/model/randomforest/proto/random_forest.pb.go, Go, 360 lines
yggdrasil_decision_forests/port/go/model/randomforest/randomforest.go, Go, 104 lines
yggdrasil_decision_forests/port/go/model/randomforest/randomforest_test.go, Go, 42 lines
yggdrasil_decision_forests/port/go/serving/decisionforest/decisionforest.go, Go, 572 lines
yggdrasil_decision_forests/port/go/serving/decisionforest/decisionforest_test.go, Go, 42 lines
yggdrasil_decision_forests/port/go/serving/engine/engine.go, Go, 93 lines
yggdrasil_decision_forests/port/go/serving/example/example.go, Go, 417 lines
yggdrasil_decision_forests/port/go/serving/serving.go, Go, 124 lines
yggdrasil_decision_forests/port/go/serving/serving_test.go, Go, 301 lines
yggdrasil_decision_forests/port/go/utils/file/file.go, Go, 107 lines
yggdrasil_decision_forests/port/go/utils/proto/distribution.pb.go, Go, 516 lines
yggdrasil_decision_forests/port/go/utils/proto/proto.go, Go, 28 lines
yggdrasil_decision_forests/port/go/utils/test/test.go, Go, 38 lines
yggdrasil_decision_forests/port/javascript/inference/externs.js, JavaScript, 177 lines
yggdrasil_decision_forests/port/javascript/inference/inference.cc, C++, 431 lines
yggdrasil_decision_forests/port/javascript/inference/karma.conf.js, JavaScript, 93 lines
yggdrasil_decision_forests/port/javascript/inference/npm/test/inference.test.js, JavaScript, 96 lines
yggdrasil_decision_forests/port/javascript/inference/wrapper.js, JavaScript, 667 lines
yggdrasil_decision_forests/port/javascript/inference/wrapper_test.js, JavaScript, 520 lines
yggdrasil_decision_forests/port/javascript/tools/build_and_run_local_server.sh, Shell, 63 lines
yggdrasil_decision_forests/port/javascript/tools/build_zipped_library.sh, Shell, 54 lines
yggdrasil_decision_forests/port/javascript/training/dataset/dataset.cc, C++, 298 lines
yggdrasil_decision_forests/port/javascript/training/dataset/dataset.h, C/C++, 48 lines
yggdrasil_decision_forests/port/javascript/training/dataset/dataset.ts, TypeScript, 74 lines
yggdrasil_decision_forests/port/javascript/training/karma.conf.js, JavaScript, 66 lines
yggdrasil_decision_forests/port/javascript/training/learner/learner.cc, C++, 142 lines
yggdrasil_decision_forests/port/javascript/training/learner/learner.h, C/C++, 47 lines
yggdrasil_decision_forests/port/javascript/training/learner/learner.ts, TypeScript, 125 lines
yggdrasil_decision_forests/port/javascript/training/model/model.cc, C++, 261 lines
yggdrasil_decision_forests/port/javascript/training/model/model.h, C/C++, 118 lines
yggdrasil_decision_forests/port/javascript/training/model/model.ts, TypeScript, 418 lines
yggdrasil_decision_forests/port/javascript/training/npm/test/training.test.js, JavaScript, 69 lines
yggdrasil_decision_forests/port/javascript/training/training.cc, C++, 81 lines
yggdrasil_decision_forests/port/javascript/training/training.ts, TypeScript, 37 lines
yggdrasil_decision_forests/port/javascript/training/training_for_types.d.ts, TypeScript, 126 lines
yggdrasil_decision_forests/port/javascript/training/training_test.ts, TypeScript, 264 lines
yggdrasil_decision_forests/port/javascript/training/util/conversion.ts, TypeScript, 117 lines
yggdrasil_decision_forests/port/javascript/training/util/status_casters.cc, C++, 44 lines
yggdrasil_decision_forests/port/javascript/training/util/status_casters.h, C/C++, 22 lines
yggdrasil_decision_forests/port/javascript/training/webpack.config.js, JavaScript, 41 lines
yggdrasil_decision_forests/port/python/config/setup.py, Python, 157 lines
yggdrasil_decision_forests/port/python/examples/minimal.py, Python, 66 lines
yggdrasil_decision_forests/port/python/tools/build_test_linux.sh, Shell, 71 lines
yggdrasil_decision_forests/port/python/tools/change_version.sh, Shell, 127 lines
yggdrasil_decision_forests/port/python/tools/collect_pip_files.py, Python, 92 lines
yggdrasil_decision_forests/port/python/tools/local_copybara_export.sh, Shell, 50 lines
yggdrasil_decision_forests/port/python/tools/package_linux.sh, Shell, 160 lines
yggdrasil_decision_forests/port/python/tools/release_linux.sh, Shell, 69 lines
yggdrasil_decision_forests/port/python/tools/release_macos.sh, Shell, 38 lines
yggdrasil_decision_forests/port/python/tools/simple_test.py, Python, 25 lines
yggdrasil_decision_forests/port/python/ydf/__init__.py, Python, 142 lines
yggdrasil_decision_forests/port/python/ydf/api/__init__.py, Python, 14 lines
yggdrasil_decision_forests/port/python/ydf/api/experimental.py, Python, 54 lines
yggdrasil_decision_forests/port/python/ydf/api/help.py, Python, 21 lines
yggdrasil_decision_forests/port/python/ydf/api/internal.py, Python, 20 lines
yggdrasil_decision_forests/port/python/ydf/api/util.py, Python, 26 lines
yggdrasil_decision_forests/port/python/ydf/api_test.py, Python, 332 lines
yggdrasil_decision_forests/port/python/ydf/cc/__init__.py, Python, 14 lines
yggdrasil_decision_forests/port/python/ydf/cc/ydf.cc, C++, 46 lines
yggdrasil_decision_forests/port/python/ydf/dataset/__init__.py, Python, 14 lines
yggdrasil_decision_forests/port/python/ydf/dataset/dataset.cc, C++, 1,273 lines
yggdrasil_decision_forests/port/python/ydf/dataset/dataset.h, C/C++, 27 lines
yggdrasil_decision_forests/port/python/ydf/dataset/dataset.py, Python, 1,584 lines
yggdrasil_decision_forests/port/python/ydf/dataset/dataset_test.py, Python, 3,899 lines
yggdrasil_decision_forests/port/python/ydf/dataset/dataset_with_tf_test.py, Python, 53 lines
yggdrasil_decision_forests/port/python/ydf/dataset/dataspec.py, Python, 1,042 lines
yggdrasil_decision_forests/port/python/ydf/dataset/dataspec_test.py, Python, 638 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/__init__.py, Python, 14 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/dataset_io.py, Python, 318 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/dataset_io_test.py, Python, 111 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/dataset_io_types.py, Python, 91 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/generator.py, Python, 55 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/numpy_io.py, Python, 54 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/numpy_io_test.py, Python, 69 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/pandas_io.py, Python, 113 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/pandas_io_test.py, Python, 73 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/polars_io.py, Python, 70 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/polars_io_test.py, Python, 37 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/pyarrow_io.py, Python, 131 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/pyarrow_io_test.py, Python, 251 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/pygrain_io.py, Python, 109 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/pygrain_io_test.py, Python, 221 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/tensorflow_io.py, Python, 55 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/xarray_io.py, Python, 66 lines
yggdrasil_decision_forests/port/python/ydf/dataset/io/xarray_io_test.py, Python, 82 lines
yggdrasil_decision_forests/port/python/ydf/deep/__init__.py, Python, 14 lines
yggdrasil_decision_forests/port/python/ydf/deep/analysis.py, Python, 472 lines
yggdrasil_decision_forests/port/python/ydf/deep/analysis_test.py, Python, 723 lines
yggdrasil_decision_forests/port/python/ydf/deep/dataset.py, Python, 34 lines
yggdrasil_decision_forests/port/python/ydf/deep/dataset_test.py, Python, 36 lines
yggdrasil_decision_forests/port/python/ydf/deep/generic_jax.py, Python, 1,438 lines
yggdrasil_decision_forests/port/python/ydf/deep/hyperparameter.py, Python, 133 lines
yggdrasil_decision_forests/port/python/ydf/deep/hyperparameter_test.py, Python, 56 lines
yggdrasil_decision_forests/port/python/ydf/deep/jax_fallback.py, Python, 43 lines
yggdrasil_decision_forests/port/python/ydf/deep/layer.py, Python, 115 lines
yggdrasil_decision_forests/port/python/ydf/deep/layer_test.py, Python, 49 lines
yggdrasil_decision_forests/port/python/ydf/deep/metric.py, Python, 127 lines
yggdrasil_decision_forests/port/python/ydf/deep/metric_test.py, Python, 68 lines
yggdrasil_decision_forests/port/python/ydf/deep/mlp.py, Python, 217 lines
yggdrasil_decision_forests/port/python/ydf/deep/mlp_test.py, Python, 248 lines
yggdrasil_decision_forests/port/python/ydf/deep/model_lib.py, Python, 85 lines
yggdrasil_decision_forests/port/python/ydf/deep/preprocessor.py, Python, 230 lines
yggdrasil_decision_forests/port/python/ydf/deep/preprocessor_test.py, Python, 127 lines
yggdrasil_decision_forests/port/python/ydf/deep/safetensors_lib.py, Python, 55 lines
yggdrasil_decision_forests/port/python/ydf/deep/safetensors_lib_test.py, Python, 57 lines
yggdrasil_decision_forests/port/python/ydf/deep/tabular_transformer.py, Python, 389 lines
yggdrasil_decision_forests/port/python/ydf/deep/tabular_transformer_test.py, Python, 262 lines
yggdrasil_decision_forests/port/python/ydf/learner/__init__.py, Python, 14 lines
yggdrasil_decision_forests/port/python/ydf/learner/abstract_feature_selector.py, Python, 91 lines
yggdrasil_decision_forests/port/python/ydf/learner/cart_learner_test.py, Python, 479 lines
yggdrasil_decision_forests/port/python/ydf/learner/custom_loss.cc, C++, 344 lines
yggdrasil_decision_forests/port/python/ydf/learner/custom_loss.h, C/C++, 99 lines
yggdrasil_decision_forests/port/python/ydf/learner/custom_loss.py, Python, 268 lines
yggdrasil_decision_forests/port/python/ydf/learner/custom_loss_test.py, Python, 754 lines
yggdrasil_decision_forests/port/python/ydf/learner/custom_metric.cc, C++, 144 lines
yggdrasil_decision_forests/port/python/ydf/learner/custom_metric.h, C/C++, 87 lines
yggdrasil_decision_forests/port/python/ydf/learner/custom_metric.py, Python, 149 lines
yggdrasil_decision_forests/port/python/ydf/learner/custom_metric_test.py, Python, 59 lines
yggdrasil_decision_forests/port/python/ydf/learner/distributed_learner_test.py, Python, 278 lines
yggdrasil_decision_forests/port/python/ydf/learner/feature_selector.py, Python, 352 lines
yggdrasil_decision_forests/port/python/ydf/learner/feature_selector_test.py, Python, 304 lines
yggdrasil_decision_forests/port/python/ydf/learner/generic_learner.py, Python, 872 lines
yggdrasil_decision_forests/port/python/ydf/learner/generic_learner_test.py, Python, 366 lines
yggdrasil_decision_forests/port/python/ydf/learner/gradient_boosted_trees_learner_test.py, Python, 628 lines
yggdrasil_decision_forests/port/python/ydf/learner/hyperparameters.py, Python, 165 lines
yggdrasil_decision_forests/port/python/ydf/learner/hyperparameters_test.py, Python, 170 lines
yggdrasil_decision_forests/port/python/ydf/learner/isolation_forest_learner_test.py, Python, 240 lines
yggdrasil_decision_forests/port/python/ydf/learner/learner.cc, C++, 385 lines
yggdrasil_decision_forests/port/python/ydf/learner/learner.h, C/C++, 27 lines
yggdrasil_decision_forests/port/python/ydf/learner/learner_test_utils.py, Python, 133 lines
yggdrasil_decision_forests/port/python/ydf/learner/learner_with_tf_test.py, Python, 61 lines
yggdrasil_decision_forests/port/python/ydf/learner/learner_with_xarray_test.py, Python, 72 lines
yggdrasil_decision_forests/port/python/ydf/learner/random_forest_learner_test.py, Python, 984 lines
yggdrasil_decision_forests/port/python/ydf/learner/specialized_learners_pre_generated.py, Python, 3,295 lines, 2 matches
yggdrasil_decision_forests/port/python/ydf/learner/tuner.py, Python, 542 lines
yggdrasil_decision_forests/port/python/ydf/learner/tuner_test.py, Python, 392 lines
yggdrasil_decision_forests/port/python/ydf/learner/worker.cc, C++, 124 lines
yggdrasil_decision_forests/port/python/ydf/learner/worker.h, C/C++, 27 lines
yggdrasil_decision_forests/port/python/ydf/learner/worker.py, Python, 72 lines
yggdrasil_decision_forests/port/python/ydf/learner/worker_main.py, Python, 29 lines
yggdrasil_decision_forests/port/python/ydf/learner/wrapper/generate_wrapper.cc, C++, 29 lines
yggdrasil_decision_forests/port/python/ydf/learner/wrapper/wrapper_generator.cc, C++, 1,001 lines
yggdrasil_decision_forests/port/python/ydf/learner/wrapper/wrapper_generator.h, C/C++, 89 lines
yggdrasil_decision_forests/port/python/ydf/learner/wrapper/wrapper_test.cc, C++, 461 lines
yggdrasil_decision_forests/port/python/ydf/metric/__init__.py, Python, 14 lines
yggdrasil_decision_forests/port/python/ydf/metric/display_metric.py, Python, 719 lines, 1 match
yggdrasil_decision_forests/port/python/ydf/metric/evaluate.cc, C++, 367 lines
yggdrasil_decision_forests/port/python/ydf/metric/evaluate.h, C/C++, 27 lines
yggdrasil_decision_forests/port/python/ydf/metric/evaluate.py, Python, 438 lines
yggdrasil_decision_forests/port/python/ydf/metric/evaluate_test.py, Python, 423 lines
yggdrasil_decision_forests/port/python/ydf/metric/metric.cc, C++, 61 lines
yggdrasil_decision_forests/port/python/ydf/metric/metric.h, C/C++, 27 lines
yggdrasil_decision_forests/port/python/ydf/metric/metric.py, Python, 611 lines
yggdrasil_decision_forests/port/python/ydf/metric/metric_test.py, Python, 370 lines
yggdrasil_decision_forests/port/python/ydf/model/__init__.py, Python, 14 lines
yggdrasil_decision_forests/port/python/ydf/model/analysis.py, Python, 304 lines
yggdrasil_decision_forests/port/python/ydf/model/decision_forest_model/__init__.py, Python, 14 lines
yggdrasil_decision_forests/port/python/ydf/model/decision_forest_model/decision_forest_model.py, Python, 259 lines
yggdrasil_decision_forests/port/python/ydf/model/decision_forest_model/decision_forest_model_test.py, Python, 133 lines
yggdrasil_decision_forests/port/python/ydf/model/decision_forest_model/decision_forest_wrapper.cc, C++, 145 lines
yggdrasil_decision_forests/port/python/ydf/model/decision_forest_model/decision_forest_wrapper.h, C/C++, 90 lines
yggdrasil_decision_forests/port/python/ydf/model/export_cc_generator.py, Python, 52 lines
yggdrasil_decision_forests/port/python/ydf/model/export_cc_run_test.cc, C++, 61 lines
yggdrasil_decision_forests/port/python/ydf/model/export_docker.py, Python, 277 lines
yggdrasil_decision_forests/port/python/ydf/model/export_docker_test.py, Python, 167 lines
yggdrasil_decision_forests/port/python/ydf/model/export_jax.py, Python, 1,311 lines
yggdrasil_decision_forests/port/python/ydf/model/export_sklearn.py, Python, 455 lines
yggdrasil_decision_forests/port/python/ydf/model/export_tf.py, Python, 752 lines
yggdrasil_decision_forests/port/python/ydf/model/feature_selector_logs.py, Python, 65 lines
yggdrasil_decision_forests/port/python/ydf/model/generic_model.py, Python, 2,544 lines
yggdrasil_decision_forests/port/python/ydf/model/gradient_boosted_trees_model/__init__.py, Python, 14 lines
yggdrasil_decision_forests/port/python/ydf/model/gradient_boosted_trees_model/gradient_boosted_trees_model.py, Python, 308 lines
yggdrasil_decision_forests/port/python/ydf/model/gradient_boosted_trees_model/gradient_boosted_trees_model_test.py, Python, 1,036 lines
yggdrasil_decision_forests/port/python/ydf/model/gradient_boosted_trees_model/gradient_boosted_trees_wrapper.cc, C++, 128 lines
yggdrasil_decision_forests/port/python/ydf/model/gradient_boosted_trees_model/gradient_boosted_trees_wrapper.h, C/C++, 102 lines
yggdrasil_decision_forests/port/python/ydf/model/isolation_forest_model/__init__.py, Python, 14 lines
yggdrasil_decision_forests/port/python/ydf/model/isolation_forest_model/isolation_forest_model.py, Python, 28 lines
yggdrasil_decision_forests/port/python/ydf/model/isolation_forest_model/isolation_forest_model_test.py, Python, 107 lines
yggdrasil_decision_forests/port/python/ydf/model/isolation_forest_model/isolation_forest_wrapper.cc, C++, 43 lines
yggdrasil_decision_forests/port/python/ydf/model/isolation_forest_model/isolation_forest_wrapper.h, C/C++, 65 lines
yggdrasil_decision_forests/port/python/ydf/model/jax_model_test.py, Python, 1,400 lines
yggdrasil_decision_forests/port/python/ydf/model/model.cc, C++, 295 lines
yggdrasil_decision_forests/port/python/ydf/model/model.h, C/C++, 35 lines
yggdrasil_decision_forests/port/python/ydf/model/model_lib.py, Python, 260 lines
yggdrasil_decision_forests/port/python/ydf/model/model_metadata.py, Python, 85 lines
yggdrasil_decision_forests/port/python/ydf/model/model_test.py, Python, 1,454 lines
yggdrasil_decision_forests/port/python/ydf/model/model_wrapper.cc, C++, 584 lines
yggdrasil_decision_forests/port/python/ydf/model/model_wrapper.h, C/C++, 219 lines
yggdrasil_decision_forests/port/python/ydf/model/optimizer_logs.py, Python, 92 lines
yggdrasil_decision_forests/port/python/ydf/model/optimizer_logs_test.py, Python, 76 lines
yggdrasil_decision_forests/port/python/ydf/model/random_forest_model/__init__.py, Python, 14 lines
yggdrasil_decision_forests/port/python/ydf/model/random_forest_model/random_forest_model.py, Python, 159 lines
yggdrasil_decision_forests/port/python/ydf/model/random_forest_model/random_forest_model_test.py, Python, 113 lines
yggdrasil_decision_forests/port/python/ydf/model/random_forest_model/random_forest_wrapper.cc, C++, 42 lines
yggdrasil_decision_forests/port/python/ydf/model/random_forest_model/random_forest_wrapper.h, C/C++, 67 lines
yggdrasil_decision_forests/port/python/ydf/model/sklearn_model_test.py, Python, 246 lines
yggdrasil_decision_forests/port/python/ydf/model/template_cpp_export.py, Python, 267 lines
yggdrasil_decision_forests/port/python/ydf/model/tf_model_test.py, Python, 1,475 lines
yggdrasil_decision_forests/port/python/ydf/model/tree/__init__.py, Python, 49 lines
yggdrasil_decision_forests/port/python/ydf/model/tree/condition.py, Python, 718 lines
yggdrasil_decision_forests/port/python/ydf/model/tree/condition_test.py, Python, 617 lines
yggdrasil_decision_forests/port/python/ydf/model/tree/node.py, Python, 204 lines
yggdrasil_decision_forests/port/python/ydf/model/tree/node_test.py, Python, 40 lines
yggdrasil_decision_forests/port/python/ydf/model/tree/plot.py, Python, 123 lines
yggdrasil_decision_forests/port/python/ydf/model/tree/plot_test.py, Python, 83 lines
yggdrasil_decision_forests/port/python/ydf/model/tree/plotter.js, JavaScript, 457 lines
yggdrasil_decision_forests/port/python/ydf/model/tree/tree.py, Python, 170 lines
yggdrasil_decision_forests/port/python/ydf/model/tree/tree_test.py, Python, 156 lines
yggdrasil_decision_forests/port/python/ydf/model/tree/value.py, Python, 267 lines
yggdrasil_decision_forests/port/python/ydf/model/tree/value_test.py, Python, 150 lines
yggdrasil_decision_forests/port/python/ydf/monitoring/__init__.py, Python, 14 lines
yggdrasil_decision_forests/port/python/ydf/monitoring/benchmark_inference_speed.py, Python, 568 lines
yggdrasil_decision_forests/port/python/ydf/monitoring/benchmark_inference_speed_test.py, Python, 73 lines
yggdrasil_decision_forests/port/python/ydf/monitoring/benchmark_io_speed.py, Python, 153 lines
yggdrasil_decision_forests/port/python/ydf/monitoring/benchmark_io_speed_main.py, Python, 59 lines
yggdrasil_decision_forests/port/python/ydf/monitoring/benchmark_train_speed.py, Python, 180 lines
yggdrasil_decision_forests/port/python/ydf/monitoring/benchmark_train_speed_main.py, Python, 109 lines
yggdrasil_decision_forests/port/python/ydf/monitoring/benchmark_train_speed_test.py, Python, 30 lines
yggdrasil_decision_forests/port/python/ydf/util/__init__.py, Python, 14 lines
yggdrasil_decision_forests/port/python/ydf/util/dataset_io.py, Python, 33 lines
yggdrasil_decision_forests/port/python/ydf/util/help.py, Python, 97 lines
yggdrasil_decision_forests/port/python/ydf/util/log_book.py, Python, 290 lines
yggdrasil_decision_forests/port/python/ydf/util/log_book_test.py, Python, 169 lines
yggdrasil_decision_forests/port/python/ydf/util/tf_example.py, Python, 159 lines
yggdrasil_decision_forests/port/python/ydf/util/tf_example_impl.py, Python, 437 lines
yggdrasil_decision_forests/port/python/ydf/util/tf_example_test.py, Python, 151 lines
yggdrasil_decision_forests/port/python/ydf/util/vertex_ai.py, Python, 100 lines
yggdrasil_decision_forests/port/python/ydf/util/vertex_ai_test.py, Python, 98 lines
yggdrasil_decision_forests/port/python/ydf/utils/__init__.py, Python, 14 lines
yggdrasil_decision_forests/port/python/ydf/utils/concurrency.py, Python, 36 lines
yggdrasil_decision_forests/port/python/ydf/utils/custom_casters.h, C/C++, 35 lines
yggdrasil_decision_forests/port/python/ydf/utils/documentation.py, Python, 26 lines
yggdrasil_decision_forests/port/python/ydf/utils/filesystem.py, Python, 15 lines
yggdrasil_decision_forests/port/python/ydf/utils/filesystem_default.py, Python, 18 lines
yggdrasil_decision_forests/port/python/ydf/utils/filesystem_google.py, Python, 19 lines
yggdrasil_decision_forests/port/python/ydf/utils/filesystem_test.py, Python, 37 lines
yggdrasil_decision_forests/port/python/ydf/utils/func_helpers.py, Python, 43 lines
yggdrasil_decision_forests/port/python/ydf/utils/func_helpers_test.py, Python, 79 lines
yggdrasil_decision_forests/port/python/ydf/utils/html.py, Python, 118 lines
yggdrasil_decision_forests/port/python/ydf/utils/html_test.py, Python, 55 lines
yggdrasil_decision_forests/port/python/ydf/utils/log.cc, C++, 37 lines
yggdrasil_decision_forests/port/python/ydf/utils/log.h, C/C++, 28 lines
yggdrasil_decision_forests/port/python/ydf/utils/log.py, Python, 366 lines
yggdrasil_decision_forests/port/python/ydf/utils/numpy_data.cc, C++, 80 lines
yggdrasil_decision_forests/port/python/ydf/utils/numpy_data.h, C/C++, 109 lines
yggdrasil_decision_forests/port/python/ydf/utils/paths.py, Python, 50 lines
yggdrasil_decision_forests/port/python/ydf/utils/paths_test.py, Python, 51 lines
yggdrasil_decision_forests/port/python/ydf/utils/pybind.h, C/C++, 67 lines
yggdrasil_decision_forests/port/python/ydf/utils/pybind_test.py, Python, 66 lines
yggdrasil_decision_forests/port/python/ydf/utils/pybind_test_helper.cc, C++, 91 lines
yggdrasil_decision_forests/port/python/ydf/utils/status_casters.h, C/C++, 217 lines
yggdrasil_decision_forests/port/python/ydf/utils/string_lib.py, Python, 164 lines
yggdrasil_decision_forests/port/python/ydf/utils/string_lib_test.py, Python, 183 lines
yggdrasil_decision_forests/port/python/ydf/utils/test_utils.py, Python, 271 lines
yggdrasil_decision_forests/port/python/ydf/utils/test_utils_test.py, Python, 86 lines
yggdrasil_decision_forests/port/python/ydf/version.py, Python, 15 lines
yggdrasil_decision_forests/port/tensorflow/pip_pkg/setup.py, Python, 98 lines
yggdrasil_decision_forests/port/tensorflow/pip_pkg/test_pkg.py, Python, 28 lines
yggdrasil_decision_forests/port/tensorflow/tools/build_pip_pkg.sh, Shell, 229 lines
yggdrasil_decision_forests/port/tensorflow/tools/build_pip_pkg_macos.sh, Shell, 213 lines
yggdrasil_decision_forests/port/tensorflow/ydf_tf/__init__.py, Python, 17 lines
yggdrasil_decision_forests/port/tensorflow/ydf_tf/api.py, Python, 1,189 lines
yggdrasil_decision_forests/port/tensorflow/ydf_tf/kernel.cc, C++, 1,699 lines
yggdrasil_decision_forests/port/tensorflow/ydf_tf/op.cc, C++, 269 lines
yggdrasil_decision_forests/port/tensorflow/ydf_tf/op.py, Python, 15 lines
yggdrasil_decision_forests/port/tensorflow/ydf_tf/op_dynamic.py, Python, 42 lines
yggdrasil_decision_forests/port/tensorflow/ydf_tf/test_utils.py, Python, 552 lines
yggdrasil_decision_forests/port/tensorflow/ydf_tf/tf1_test.py, Python, 342 lines
yggdrasil_decision_forests/port/tensorflow/ydf_tf/tf2_test.py, Python, 235 lines
yggdrasil_decision_forests/serving/decision_forest/8bits_numerical_features.cc, C++, 399 lines
yggdrasil_decision_forests/serving/decision_forest/8bits_numerical_features.h, C/C++, 197 lines
yggdrasil_decision_forests/serving/decision_forest/8bits_numerical_features_test.cc, C++, 252 lines
yggdrasil_decision_forests/serving/decision_forest/benchmark_8bits_numerical_features.cc, C++, 145 lines
yggdrasil_decision_forests/serving/decision_forest/decision_forest.cc, C++, 1,461 lines
yggdrasil_decision_forests/serving/decision_forest/decision_forest.h, C/C++, 179 lines
yggdrasil_decision_forests/serving/decision_forest/decision_forest_serving.cc, C++, 862 lines
yggdrasil_decision_forests/serving/decision_forest/decision_forest_serving.h, C/C++, 643 lines
yggdrasil_decision_forests/serving/decision_forest/decision_forest_test.cc, C++, 861 lines
yggdrasil_decision_forests/serving/decision_forest/quick_scorer_extended.cc, C++, 983 lines
yggdrasil_decision_forests/serving/decision_forest/quick_scorer_extended.h, C/C++, 743 lines
yggdrasil_decision_forests/serving/decision_forest/quick_scorer_extended_hwy.cc, C++, 384 lines
yggdrasil_decision_forests/serving/decision_forest/quick_scorer_extended_internal.h, C/C++, 163 lines
yggdrasil_decision_forests/serving/decision_forest/quick_scorer_extended_test.cc, C++, 605 lines
yggdrasil_decision_forests/serving/decision_forest/register_engines.cc, C++, 947 lines
yggdrasil_decision_forests/serving/decision_forest/register_engines.h, C/C++, 45 lines
yggdrasil_decision_forests/serving/decision_forest/utils.cc, C++, 105 lines
yggdrasil_decision_forests/serving/decision_forest/utils.h, C/C++, 104 lines
yggdrasil_decision_forests/serving/embed/common.cc, C++, 700 lines
yggdrasil_decision_forests/serving/embed/common.h, C/C++, 370 lines
yggdrasil_decision_forests/serving/embed/cpp/cpp_embed.cc, C++, 63 lines
yggdrasil_decision_forests/serving/embed/cpp/cpp_embed.h, C/C++, 157 lines
yggdrasil_decision_forests/serving/embed/cpp/cpp_embed_pred_test.cc, C++, 472 lines
yggdrasil_decision_forests/serving/embed/cpp/cpp_embed_test.cc, C++, 361 lines
yggdrasil_decision_forests/serving/embed/cpp/cpp_emitter.cc, C++, 452 lines
yggdrasil_decision_forests/serving/embed/cpp/cpp_emitter.h, C/C++, 85 lines
yggdrasil_decision_forests/serving/embed/cpp/cpp_ir.h, C/C++, 145 lines
yggdrasil_decision_forests/serving/embed/cpp/cpp_target_lowering.cc, C++, 850 lines
yggdrasil_decision_forests/serving/embed/cpp/cpp_target_lowering.h, C/C++, 113 lines
yggdrasil_decision_forests/serving/embed/cpp/cpp_target_lowering_test.cc, C++, 162 lines
yggdrasil_decision_forests/serving/embed/embed.cc, C++, 53 lines
yggdrasil_decision_forests/serving/embed/embed.h, C/C++, 34 lines
yggdrasil_decision_forests/serving/embed/ir/builder.cc, C++, 631 lines
yggdrasil_decision_forests/serving/embed/ir/builder.h, C/C++, 89 lines
yggdrasil_decision_forests/serving/embed/ir/builder_test.cc, C++, 363 lines
yggdrasil_decision_forests/serving/embed/ir/model_ir.h, C/C++, 133 lines
yggdrasil_decision_forests/serving/embed/java/java_embed.cc, C++, 1,247 lines
yggdrasil_decision_forests/serving/embed/java/java_embed.h, C/C++, 91 lines
yggdrasil_decision_forests/serving/embed/java/java_embed_test.cc, C++, 152 lines
yggdrasil_decision_forests/serving/embed/java/model_data_bank.cc, C++, 458 lines
yggdrasil_decision_forests/serving/embed/java/model_data_bank.h, C/C++, 173 lines
yggdrasil_decision_forests/serving/embed/java/model_data_bank_test.cc, C++, 569 lines
yggdrasil_decision_forests/serving/embed/javatests/ydf/JavaPredTest.java, Java, 575 lines
yggdrasil_decision_forests/serving/embed/utils.cc, C++, 524 lines
yggdrasil_decision_forests/serving/embed/utils.h, C/C++, 145 lines
yggdrasil_decision_forests/serving/embed/utils_test.cc, C++, 149 lines
yggdrasil_decision_forests/serving/embed/write_embed.cc, C++, 112 lines
yggdrasil_decision_forests/serving/example_set.cc, C++, 471 lines
yggdrasil_decision_forests/serving/example_set.h, C/C++, 1,643 lines
yggdrasil_decision_forests/serving/example_set_model_wrapper.h, C/C++, 86 lines
yggdrasil_decision_forests/serving/example_set_test.cc, C++, 762 lines
yggdrasil_decision_forests/serving/fast_engine.h, C/C++, 144 lines
yggdrasil_decision_forests/serving/tf_example.cc, C++, 208 lines
yggdrasil_decision_forests/serving/tf_example.h, C/C++, 36 lines
yggdrasil_decision_forests/serving/tf_example_test.cc, C++, 309 lines
yggdrasil_decision_forests/serving/utils.cc, C++, 347 lines
yggdrasil_decision_forests/serving/utils.h, C/C++, 139 lines
yggdrasil_decision_forests/serving/utils_test.cc, C++, 242 lines
yggdrasil_decision_forests/utils/accurate_sum.h, C/C++, 91 lines
yggdrasil_decision_forests/utils/accurate_sum_test.cc, C++, 147 lines
yggdrasil_decision_forests/utils/adaptive_work.cc, C++, 65 lines
yggdrasil_decision_forests/utils/adaptive_work.h, C/C++, 68 lines
yggdrasil_decision_forests/utils/adaptive_work_test.cc, C++, 47 lines
yggdrasil_decision_forests/utils/benchmark/inference.cc, C++, 345 lines
yggdrasil_decision_forests/utils/benchmark/inference.h, C/C++, 85 lines
yggdrasil_decision_forests/utils/benchmark/inference_test.cc, C++, 119 lines
yggdrasil_decision_forests/utils/bitmap.cc, C++, 457 lines
yggdrasil_decision_forests/utils/bitmap.h, C/C++, 330 lines
yggdrasil_decision_forests/utils/bitmap_test.cc, C++, 507 lines
yggdrasil_decision_forests/utils/blob_sequence.cc, C++, 154 lines
yggdrasil_decision_forests/utils/blob_sequence.h, C/C++, 157 lines
yggdrasil_decision_forests/utils/blob_sequence_test.cc, C++, 114 lines
yggdrasil_decision_forests/utils/bytestream.cc, C++, 98 lines
yggdrasil_decision_forests/utils/bytestream.h, C/C++, 133 lines
yggdrasil_decision_forests/utils/bytestream_test.cc, C++, 45 lines
yggdrasil_decision_forests/utils/cast.h, C/C++, 60 lines
yggdrasil_decision_forests/utils/circular_buffer.h, C/C++, 148 lines
yggdrasil_decision_forests/utils/circular_buffer_test.cc, C++, 105 lines
yggdrasil_decision_forests/utils/compatibility.h, C/C++, 52 lines
yggdrasil_decision_forests/utils/concurrency.cc, C++, 126 lines
yggdrasil_decision_forests/utils/concurrency.h, C/C++, 220 lines
yggdrasil_decision_forests/utils/concurrency_channel.h, C/C++, 107 lines
yggdrasil_decision_forests/utils/concurrency_default.cc, C++, 72 lines
yggdrasil_decision_forests/utils/concurrency_default.h, C/C++, 88 lines
yggdrasil_decision_forests/utils/concurrency_streamprocessor.h, C/C++, 209 lines
yggdrasil_decision_forests/utils/concurrency_test.cc, C++, 340 lines
yggdrasil_decision_forests/utils/csv.cc, C++, 254 lines
yggdrasil_decision_forests/utils/csv.h, C/C++, 163 lines
yggdrasil_decision_forests/utils/csv_test.cc, C++, 264 lines
yggdrasil_decision_forests/utils/distribute/core.cc, C++, 66 lines
yggdrasil_decision_forests/utils/distribute/core.h, C/C++, 258 lines
yggdrasil_decision_forests/utils/distribute/distribute.cc, C++, 49 lines
yggdrasil_decision_forests/utils/distribute/distribute.h, C/C++, 100 lines
yggdrasil_decision_forests/utils/distribute/distribute_test.cc, C++, 106 lines
yggdrasil_decision_forests/utils/distribute/implementations/grpc/grpc_common.cc, C++, 55 lines
yggdrasil_decision_forests/utils/distribute/implementations/grpc/grpc_common.h, C/C++, 38 lines
yggdrasil_decision_forests/utils/distribute/implementations/grpc/grpc_common_test.cc, C++, 44 lines
yggdrasil_decision_forests/utils/distribute/implementations/grpc/grpc_manager.cc, C++, 731 lines
yggdrasil_decision_forests/utils/distribute/implementations/grpc/grpc_manager.h, C/C++, 283 lines
yggdrasil_decision_forests/utils/distribute/implementations/grpc/grpc_test.cc, C++, 232 lines
yggdrasil_decision_forests/utils/distribute/implementations/grpc/grpc_worker.cc, C++, 430 lines
yggdrasil_decision_forests/utils/distribute/implementations/grpc/grpc_worker.h, C/C++, 233 lines
yggdrasil_decision_forests/utils/distribute/implementations/grpc/grpc_worker_main.cc, C++, 46 lines
yggdrasil_decision_forests/utils/distribute/implementations/multi_thread/multi_thread.cc, C++, 219 lines
yggdrasil_decision_forests/utils/distribute/implementations/multi_thread/multi_thread.h, C/C++, 137 lines
yggdrasil_decision_forests/utils/distribute/test_utils.cc, C++, 257 lines
yggdrasil_decision_forests/utils/distribute/test_utils.h, C/C++, 97 lines
yggdrasil_decision_forests/utils/distribute/toy_worker.cc, C++, 25 lines
yggdrasil_decision_forests/utils/distribute/toy_worker.h, C/C++, 155 lines
yggdrasil_decision_forests/utils/distribute/utils.cc, C++, 38 lines
yggdrasil_decision_forests/utils/distribute/utils.h, C/C++, 40 lines
yggdrasil_decision_forests/utils/distribute_cli/common.cc, C++, 63 lines
yggdrasil_decision_forests/utils/distribute_cli/common.h, C/C++, 47 lines
yggdrasil_decision_forests/utils/distribute_cli/distribute_cli.cc, C++, 219 lines
yggdrasil_decision_forests/utils/distribute_cli/distribute_cli.h, C/C++, 132 lines
yggdrasil_decision_forests/utils/distribute_cli/distribute_cli_test.cc, C++, 63 lines
yggdrasil_decision_forests/utils/distribute_cli/distribute_cli_worker.cc, C++, 303 lines
yggdrasil_decision_forests/utils/distribute_cli/distribute_cli_worker.h, C/C++, 68 lines
yggdrasil_decision_forests/utils/distribution.cc, C++, 121 lines
yggdrasil_decision_forests/utils/distribution.h, C/C++, 1,023 lines
yggdrasil_decision_forests/utils/distribution_test.cc, C++, 688 lines
yggdrasil_decision_forests/utils/documentation.cc, C++, 19 lines
yggdrasil_decision_forests/utils/documentation.h, C/C++, 45 lines
yggdrasil_decision_forests/utils/endian.h, C/C++, 23 lines
yggdrasil_decision_forests/utils/endian_default.h, C/C++, 90 lines
yggdrasil_decision_forests/utils/endian_google.h, C/C++, 50 lines
yggdrasil_decision_forests/utils/endian_test.cc, C++, 68 lines
yggdrasil_decision_forests/utils/evaluation.cc, C++, 348 lines
yggdrasil_decision_forests/utils/evaluation.h, C/C++, 112 lines
yggdrasil_decision_forests/utils/evaluation_test.cc, C++, 429 lines
yggdrasil_decision_forests/utils/feature_importance.cc, C++, 498 lines
yggdrasil_decision_forests/utils/feature_importance.h, C/C++, 113 lines
yggdrasil_decision_forests/utils/filesystem.cc, C++, 56 lines
yggdrasil_decision_forests/utils/filesystem.h, C/C++, 87 lines
yggdrasil_decision_forests/utils/filesystem_default.cc, C++, 451 lines
yggdrasil_decision_forests/utils/filesystem_default.h, C/C++, 216 lines
yggdrasil_decision_forests/utils/filesystem_default_gcs.cc, C++, 282 lines
yggdrasil_decision_forests/utils/filesystem_default_gcs_test.cc, C++, 237 lines
yggdrasil_decision_forests/utils/filesystem_interface.h, C/C++, 66 lines
yggdrasil_decision_forests/utils/filesystem_tensorflow.cc, C++, 122 lines
yggdrasil_decision_forests/utils/filesystem_tensorflow.h, C/C++, 182 lines
yggdrasil_decision_forests/utils/filesystem_tensorflow_impl.cc, C++, 323 lines
yggdrasil_decision_forests/utils/filesystem_tensorflow_interface.cc, C++, 39 lines
yggdrasil_decision_forests/utils/filesystem_tensorflow_interface.h, C/C++, 33 lines
yggdrasil_decision_forests/utils/filesystem_test.cc, C++, 201 lines
yggdrasil_decision_forests/utils/fold_generator.cc, C++, 417 lines
yggdrasil_decision_forests/utils/fold_generator.h, C/C++, 103 lines
yggdrasil_decision_forests/utils/fold_generator_test.cc, C++, 266 lines
yggdrasil_decision_forests/utils/hash.h, C/C++, 51 lines
yggdrasil_decision_forests/utils/histogram.h, C/C++, 256 lines
yggdrasil_decision_forests/utils/histogram_test.cc, C++, 191 lines
yggdrasil_decision_forests/utils/html.cc, C++, 93 lines
yggdrasil_decision_forests/utils/html.h, C/C++, 340 lines
yggdrasil_decision_forests/utils/html_content.cc, C++, 133 lines
yggdrasil_decision_forests/utils/html_content.h, C/C++, 55 lines
yggdrasil_decision_forests/utils/html_content_test.cc, C++, 38 lines
yggdrasil_decision_forests/utils/html_test.cc, C++, 81 lines
yggdrasil_decision_forests/utils/hyper_parameters.cc, C++, 102 lines
yggdrasil_decision_forests/utils/hyper_parameters.h, C/C++, 69 lines
yggdrasil_decision_forests/utils/hyper_parameters_test.cc, C++, 73 lines
yggdrasil_decision_forests/utils/logging.h, C/C++, 25 lines
yggdrasil_decision_forests/utils/logging_default.cc, C++, 52 lines
yggdrasil_decision_forests/utils/logging_default.h, C/C++, 66 lines
yggdrasil_decision_forests/utils/logging_test.cc, C++, 30 lines
yggdrasil_decision_forests/utils/math.cc, C++, 97 lines
yggdrasil_decision_forests/utils/math.h, C/C++, 47 lines
yggdrasil_decision_forests/utils/math_test.cc, C++, 97 lines
yggdrasil_decision_forests/utils/model_analysis.cc, C++, 1,621 lines
yggdrasil_decision_forests/utils/model_analysis.h, C/C++, 118 lines
yggdrasil_decision_forests/utils/model_analysis_test.cc, C++, 647 lines
yggdrasil_decision_forests/utils/own_or_borrow.h, C/C++, 80 lines
yggdrasil_decision_forests/utils/own_or_borrow_test.cc, C++, 67 lines
yggdrasil_decision_forests/utils/partial_dependence_plot.cc, C++, 752 lines
yggdrasil_decision_forests/utils/partial_dependence_plot.h, C/C++, 147 lines
yggdrasil_decision_forests/utils/partial_dependence_plot_test.cc, C++, 1,482 lines
yggdrasil_decision_forests/utils/plot.cc, C++, 559 lines
yggdrasil_decision_forests/utils/plot.h, C/C++, 317 lines
yggdrasil_decision_forests/utils/plot_test.cc, C++, 210 lines
yggdrasil_decision_forests/utils/protobuf.h, C/C++, 135 lines
yggdrasil_decision_forests/utils/protobuf_test.cc, C++, 45 lines
yggdrasil_decision_forests/utils/random.h, C/C++, 46 lines
yggdrasil_decision_forests/utils/regex.cc, C++, 47 lines
yggdrasil_decision_forests/utils/regex.h, C/C++, 39 lines
yggdrasil_decision_forests/utils/regex_test.cc, C++, 32 lines
yggdrasil_decision_forests/utils/registration.cc, C++, 26 lines
yggdrasil_decision_forests/utils/registration.h, C/C++, 198 lines
yggdrasil_decision_forests/utils/registration_test.cc, C++, 190 lines
yggdrasil_decision_forests/utils/reliability_diagram.cc, C++, 96 lines
yggdrasil_decision_forests/utils/reliability_diagram.h, C/C++, 83 lines
yggdrasil_decision_forests/utils/reliability_diagram_test.cc, C++, 228 lines
yggdrasil_decision_forests/utils/shap.cc, C++, 534 lines
yggdrasil_decision_forests/utils/shap.h, C/C++, 162 lines
yggdrasil_decision_forests/utils/shap_test.cc, C++, 1,059 lines
yggdrasil_decision_forests/utils/sharded_io.cc, C++, 88 lines
yggdrasil_decision_forests/utils/sharded_io.h, C/C++, 216 lines
yggdrasil_decision_forests/utils/sharded_io_blob_sequence.h, C/C++, 135 lines
yggdrasil_decision_forests/utils/sharded_io_test.cc, C++, 204 lines
yggdrasil_decision_forests/utils/sharded_io_tfrecord.h, C/C++, 140 lines
yggdrasil_decision_forests/utils/smoothed_pav_calibration_fit.cc, C++, 532 lines
yggdrasil_decision_forests/utils/smoothed_pav_calibration_fit.h, C/C++, 405 lines
yggdrasil_decision_forests/utils/smoothed_pav_calibration_fit_test.cc, C++, 467 lines
yggdrasil_decision_forests/utils/smoothed_pav_calibration_inference.cc, C++, 123 lines
yggdrasil_decision_forests/utils/smoothed_pav_calibration_inference.h, C/C++, 210 lines
yggdrasil_decision_forests/utils/smoothed_pav_calibration_inference_test.cc, C++, 339 lines
yggdrasil_decision_forests/utils/snapshot.cc, C++, 97 lines
yggdrasil_decision_forests/utils/snapshot.h, C/C++, 56 lines
yggdrasil_decision_forests/utils/snapshot_test.cc, C++, 83 lines
yggdrasil_decision_forests/utils/status_macros.h, C/C++, 55 lines
yggdrasil_decision_forests/utils/status_macros_default.h, C/C++, 98 lines
yggdrasil_decision_forests/utils/status_macros_test.cc, C++, 89 lines
yggdrasil_decision_forests/utils/synchronization_primitives.h, C/C++, 186 lines
yggdrasil_decision_forests/utils/test.cc, C++, 286 lines
yggdrasil_decision_forests/utils/test.h, C/C++, 153 lines
yggdrasil_decision_forests/utils/test_utils.cc, C++, 1,146 lines
yggdrasil_decision_forests/utils/test_utils.h, C/C++, 480 lines
yggdrasil_decision_forests/utils/testing_macros.h, C/C++, 31 lines
yggdrasil_decision_forests/utils/testing_macros_test.cc, C++, 52 lines
yggdrasil_decision_forests/utils/time.cc, C++, 65 lines
yggdrasil_decision_forests/utils/time.h, C/C++, 31 lines
yggdrasil_decision_forests/utils/time_test.cc, C++, 40 lines
yggdrasil_decision_forests/utils/uid.h, C/C++, 48 lines
yggdrasil_decision_forests/utils/usage.h, C/C++, 81 lines
yggdrasil_decision_forests/utils/usage_default.cc, C++, 61 lines
yggdrasil_decision_forests/utils/zlib.cc, C++, 289 lines
yggdrasil_decision_forests/utils/zlib.h, C/C++, 114 lines
yggdrasil_decision_forests/utils/zlib_test.cc, C++, 188 lines
LICENSE, License, 247 lines
README.md, Text, 145 lines

At the source: github.com/google/yggdrasil-decision-forests

neurodata/sex_classification

License: none: the authors keep all their rights

State: the link answers, verified on 29 September 2026

Evidence: files inventoried

Commit: 27c99d80b11f647b665a2dd5ec4a8430d234453a, 6 June 2024

Languages: Jupyter (22), Python (18)

Size: 46 files, 40 scripts

Software Heritage: archived

Found in: “Code availability”

Holds: README, 11 notebooks

Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation

Tools: pandas (40 files), Matplotlib (38 files), NiBabel (38 files), NumPy (38 files), scikit-learn (38 files), SciPy (30 files), Numba (2 files)

Availability: 1 check, the latest on 29 September 2026: the link answers

29 September 2026: the link answers

41 files

.ipynb_checkpoints/April10_2024-checkpoint.ipynb, Jupyter, 408 lines
.ipynb_checkpoints/April3_2024-checkpoint.ipynb, Jupyter, 364 lines
.ipynb_checkpoints/Feb21_2024-checkpoint.ipynb, Jupyter, 121 lines
.ipynb_checkpoints/Feb28_2024-checkpoint.ipynb, Jupyter, 183 lines
.ipynb_checkpoints/March13_2024-checkpoint.ipynb, Jupyter, 364 lines
.ipynb_checkpoints/accuracy_run-checkpoint.py, Python, 137 lines
.ipynb_checkpoints/cortical_thickness-checkpoint.ipynb, Jupyter, 272 lines
.ipynb_checkpoints/cortical_thickness_cross_species-checkpoint.ipynb, Jupyter, 256 lines
.ipynb_checkpoints/cortical_thickness_pval-checkpoint.ipynb, Jupyter, 272 lines
.ipynb_checkpoints/delete_files-checkpoint.ipynb, Jupyter, 37 lines
.ipynb_checkpoints/eval_acc-checkpoint.py, Python, 114 lines
.ipynb_checkpoints/primary_analysis-NHP-checkpoint.ipynb, Jupyter, 114 lines
.ipynb_checkpoints/primary_analysis-checkpoint.ipynb, Jupyter, 121 lines
.ipynb_checkpoints/run-checkpoint.py, Python, 52 lines
.ipynb_checkpoints/run_test-checkpoint.py, Python, 122 lines
.ipynb_checkpoints/run_test_diff_parallel-checkpoint.py, Python, 119 lines
.ipynb_checkpoints/train_morf-checkpoint.py, Python, 158 lines
.ipynb_checkpoints/train_morf_NHP-checkpoint.py, Python, 195 lines
.ipynb_checkpoints/train_rf-checkpoint.py, Python, 109 lines
.ipynb_checkpoints/transfer-checkpoint.py, Python, 111 lines
April10_2024.ipynb, Jupyter, 384 lines
April3_2024.ipynb, Jupyter, 420 lines
Feb21_2024.ipynb, Jupyter, 162 lines
Feb28_2024.ipynb, Jupyter, 183 lines
March13_2024.ipynb, Jupyter, 364 lines
accuracy_run.py, Python, 137 lines
cortical_thickness.ipynb, Jupyter, 272 lines
cortical_thickness_cross_species.ipynb, Jupyter, 237 lines
cortical_thickness_pval.ipynb, Jupyter, 451 lines
delete_files.ipynb, Jupyter, 37 lines
eval_acc.py, Python, 114 lines
primary_analysis-NHP.ipynb, Jupyter, 125 lines
primary_analysis.ipynb, Jupyter, 121 lines
run.py, Python, 52 lines
run_test.py, Python, 122 lines
run_test_diff_parallel.py, Python, 119 lines
train_morf.py, Python, 158 lines
train_morf_NHP.py, Python, 195 lines
train_rf.py, Python, 109 lines
transfer.py, Python, 111 lines
README.md, Text, 2 lines

At the source: github.com/neurodata/sex_classification

neurodata/treeple

License: other

State: the link answers, verified on 29 September 2026

Evidence: files inventoried

Commit: 75c2cf919939574e4240fe261f053162039495cf, 25 February 2025

Languages: Python (110), Jupyter (6)

Size: 233 files, 116 scripts

Software Heritage: archived

Found in: “Code availability”

Holds: README, license file, CITATION.cff, environment (pyproject.toml), tests, continuous integration, documentation, 6 notebooks

Tools: NumPy (81 files), scikit-learn (62 files), Matplotlib (36 files), SciPy (23 files), seaborn (22 files), pandas (17 files)

Availability: 1 check, the latest on 29 September 2026: the link answers

29 September 2026: the link answers

118 files

.spin/cmds.py, Python, 208 lines
benchmarks/__init__.py, Python, 1 line
benchmarks/common.py, Python, 282 lines
benchmarks/datasets.py, Python, 161 lines
benchmarks/ensemble_supervised.py, Python, 74 lines
benchmarks/utils.py, Python, 46 lines
benchmarks_nonasv/bench_forestht.py, Python, 209 lines
benchmarks_nonasv/bench_mnist.py, Python, 188 lines
benchmarks_nonasv/bench_morf.py, Python, 244 lines
benchmarks_nonasv/bench_oblique_tree.py, Python, 170 lines
benchmarks_nonasv/bench_plot_urf.py, Python, 90 lines
benchmarks_nonasv/cancer/bench_multiview_hyppo.ipynb, Jupyter, 1,460 lines
benchmarks_nonasv/cancer/bench_multiview_pvalue_hyppo.ipynb, Jupyter, 942 lines
benchmarks_nonasv/cancer/plot_pvalue_cancer.ipynb, Jupyter, 308 lines
benchmarks_nonasv/cancer/validate_cancer_data.ipynb, Jupyter, 108 lines
benchmarks_nonasv/notebooks/compare_coleman_and_permutation_forest.ipynb, Jupyter, 430 lines
benchmarks_nonasv/notebooks/forest_ht_independent_data.ipynb, Jupyter, 191 lines
doc/conf.py, Python, 410 lines
doc/sphinxext/add_toctree_functions.py, Python, 157 lines
doc/sphinxext/allow_nan_estimators.py, Python, 54 lines
doc/sphinxext/doi_role.py, Python, 48 lines
doc/sphinxext/github_link.py, Python, 82 lines
doc/sphinxext/sphinx_issues.py, Python, 210 lines
examples/calibration/plot_honest_tree.py, Python, 117 lines
examples/calibration/plot_overlapping_gaussians.py, Python, 186 lines
examples/multiview/plot_multiview_dtc.py, Python, 181 lines
examples/outlier_detection/plot_extended_isolation_forest.py, Python, 228 lines
examples/quantile_predictions/plot_quantile_interpolation_with_RF.py, Python, 113 lines
examples/quantile_predictions/plot_quantile_regression_intervals_with_RF.py, Python, 195 lines
examples/quantile_predictions/plot_quantile_toy_example_with_RF.py, Python, 106 lines
examples/quantile_predictions/plot_quantile_vs_standard_oblique_forest.py, Python, 93 lines
examples/sklearn_vs_treeple/plot_iris_dtc.py, Python, 97 lines
examples/sparse_oblique_trees/plot_extra_oblique_random_forest.py, Python, 194 lines, 1 match
examples/sparse_oblique_trees/plot_extra_orf_sample_size.py, Python, 148 lines
examples/sparse_oblique_trees/plot_oblique_axis_aligned_forests_sparse_parity.py, Python, 97 lines
examples/sparse_oblique_trees/plot_oblique_forests_iris.py, Python, 155 lines
examples/sparse_oblique_trees/plot_oblique_random_forest.py, Python, 129 lines
examples/splitters/plot_multiview_axis_aligned_splitter.py, Python, 193 lines
examples/splitters/plot_projection_matrices.py, Python, 322 lines
examples/splitters/plot_sparse_projection_matrix.py, Python, 130 lines
examples/treeple/treeple_tutorial_0_GMM.py, Python, 210 lines
examples/treeple/treeple_tutorial_1_1a_SA98.py, Python, 146 lines
examples/treeple/treeple_tutorial_1_1b_MI.py, Python, 114 lines
examples/treeple/treeple_tutorial_1_1c_pAUC.py, Python, 147 lines
examples/treeple/treeple_tutorial_1_1d_HD.py, Python, 108 lines
examples/treeple/treeple_tutorial_1_2_pvalue.py, Python, 140 lines
examples/treeple/treeple_tutorial_2_1a_SA98_multiview.py, Python, 165 lines
examples/treeple/treeple_tutorial_2_1b_CMI.py, Python, 169 lines
examples/treeple/treeple_tutorial_2_2_pvalue_multiview.py, Python, 188 lines
treeple/__init__.py, Python, 93 lines
treeple/_build_utils/gcc_build_bitness.py, Python, 21 lines
treeple/_lib/__init__.py, Python, 1 line
treeple/conftest.py, Python, 10 lines
treeple/datasets/__init__.py, Python, 9 lines
treeple/datasets/hyppo.py, Python, 882 lines, 1 match
treeple/datasets/multiview.py, Python, 356 lines
treeple/datasets/tests/__init__.py, Python, 1 line
treeple/datasets/tests/test_hyppo.py, Python, 200 lines
treeple/datasets/tests/test_multiview.py, Python, 123 lines
treeple/ensemble/__init__.py, Python, 12 lines
treeple/ensemble/_eiforest.py, Python, 196 lines, 1 match
treeple/ensemble/_extensions.py, Python, 147 lines
treeple/ensemble/_honest_forest.py, Python, 861 lines, 1 match
treeple/ensemble/_multiview.py, Python, 315 lines
treeple/ensemble/_supervised_forest.py, Python, 1,931 lines, 2 matches
treeple/ensemble/_unsupervised_forest.py, Python, 832 lines
treeple/experimental/__init__.py, Python, 13 lines
treeple/experimental/distributions.py, Python, 1 line
treeple/experimental/monte_carlo.py, Python, 219 lines
treeple/experimental/mutual_info.py, Python, 447 lines
treeple/experimental/sdf.py, Python, 263 lines
treeple/experimental/simulate.py, Python, 223 lines
treeple/experimental/tests/__init__.py, Python, 1 line
treeple/experimental/tests/test_monte_carlo.py, Python, 196 lines
treeple/experimental/tests/test_mutual_info.py, Python, 58 lines
treeple/experimental/tests/test_sdf.py, Python, 123 lines
treeple/experimental/tests/test_simulate.py, Python, 38 lines
treeple/neighbors.py, Python, 214 lines
treeple/stats/__init__.py, Python, 11 lines
treeple/stats/baseline.py, Python, 252 lines
treeple/stats/forest.py, Python, 340 lines
treeple/stats/permuteforest.py, Python, 484 lines
treeple/stats/tests/__init__.py, Python, 1 line
treeple/stats/tests/test_baseline.py, Python, 104 lines
treeple/stats/tests/test_coleman.py, Python, 216 lines
treeple/stats/tests/test_forest.py, Python, 466 lines
treeple/stats/tests/test_permuteforest.py, Python, 66 lines
treeple/stats/tests/test_utils.py, Python, 136 lines
treeple/stats/utils.py, Python, 537 lines
treeple/tests/__init__.py, Python, 1 line
treeple/tests/test_eiforest.py, Python, 316 lines
treeple/tests/test_extensions.py, Python, 108 lines
treeple/tests/test_honest_forest.py, Python, 565 lines
treeple/tests/test_multiview_forest.py, Python, 179 lines
treeple/tests/test_neighbors.py, Python, 99 lines
treeple/tests/test_supervised_forest.py, Python, 458 lines
treeple/tests/test_unsupervised_forest.py, Python, 114 lines
treeple/tree/__init__.py, Python, 37 lines
treeple/tree/_classes.py, Python, 3,285 lines
treeple/tree/_honest_tree.py, Python, 949 lines
treeple/tree/_marginalize.py, Python, 254 lines
treeple/tree/_multiview.py, Python, 669 lines
treeple/tree/_neighbors.py, Python, 66 lines
treeple/tree/honesty/__init__.py, Python, 1 line
treeple/tree/kernels.py, Python, 12 lines
treeple/tree/manifold/__init__.py, Python, 1 line
treeple/tree/tests/__init__.py, Python, 1 line
treeple/tree/tests/test_all_trees.py, Python, 185 lines
treeple/tree/tests/test_honest_prune.py, Python, 72 lines
treeple/tree/tests/test_honest_tree.py, Python, 246 lines
treeple/tree/tests/test_marginal.py, Python, 144 lines
treeple/tree/tests/test_multiview.py, Python, 275 lines
treeple/tree/tests/test_tree.py, Python, 559 lines
treeple/tree/tests/test_unsupervised_tree.py, Python, 224 lines
treeple/tree/tests/test_utils.py, Python, 204 lines
treeple/tree/unsupervised/__init__.py, Python, 1 line
LICENSE, License, 131 lines
README.md, Text, 69 lines

At the source: github.com/neurodata/treeple

Code availability

The code used to perform the analysis and generate results for sex classification can be accessed at https://github.com/neurodata/sex_classification. NEOFIT implementation can be tracked at https://github.com/neurodata/treeple.

Reproduced under the paper's license (CC BY), from the paper cited above.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

3 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
1,045 scripts, each with its path and the digest of its content;
9 matches between paragraphs of the paper and lines of the code (method lexical-v1);
neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data Availability

All relevant links to the data are within the manuscript and its Supporting Information files.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 29 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 9 authors, 13 MeSH terms, 2 funders, 27 references.

Cite

This paper

Liu, T., Dey, J., Xu, B., Bridgeford, E. W., Alldritt, S., Nenning, K.-H., Byeon, K., Xu, T., & Vogelstein, J. T. (2026). Statistically valid explainable black-box machine learning: applications in sex classification across species using brain imaging. PloS one, 21(4), e0346575. https://doi.org/10.1371/journal.pone.0346575

BibTeX

@article{liu2026statistically, author = {Liu, Tingshan and Dey, Jayanta and Xu, Beiya and Bridgeford, Eric W. and Alldritt, Samuel and Nenning, Karl-Heinz and Byeon, Kyoungseob and Xu, Ting and Vogelstein, Joshua T.}, title = {{Statistically valid explainable black-box machine learning: applications in sex classification across species using brain imaging}}, journal = {PloS one}, year = {2026}, month = apr, volume = {21}, number = {4}, pages = {e0346575}, publisher = {PLOS}, issn = {1932-6203}, doi = {10.1371/journal.pone.0346575}, url = {https://doi.org/10.1371/journal.pone.0346575}, pmid = {41989998}, pmcid = {PMC13086332} }

RIS

TY - JOUR AU - Liu, Tingshan AU - Dey, Jayanta AU - Xu, Beiya AU - Bridgeford, Eric W. AU - Alldritt, Samuel AU - Nenning, Karl-Heinz AU - Byeon, Kyoungseob AU - Xu, Ting AU - Vogelstein, Joshua T. TI - Statistically valid explainable black-box machine learning: applications in sex classification across species using brain imaging T2 - PloS one J2 - PLoS One PY - 2026 DA - 2026/04/16 VL - 21 IS - 4 SP - e0346575 SN - 1932-6203 PB - PLOS DO - 10.1371/journal.pone.0346575 UR - https://doi.org/10.1371/journal.pone.0346575 LA - en ER -

CSL-JSON

{ "id": "10.1371/journal.pone.0346575", "type": "article-journal", "title": "Statistically valid explainable black-box machine learning: applications in sex classification across species using brain imaging", "container-title": "PloS one", "author": [ { "family": "Liu", "given": "Tingshan" }, { "family": "Dey", "given": "Jayanta" }, { "family": "Xu", "given": "Beiya" }, { "family": "Bridgeford", "given": "Eric W." }, { "family": "Alldritt", "given": "Samuel" }, { "family": "Nenning", "given": "Karl-Heinz" }, { "family": "Byeon", "given": "Kyoungseob" }, { "family": "Xu", "given": "Ting" }, { "family": "Vogelstein", "given": "Joshua T." } ], "container-title-short": "PLoS One", "volume": "21", "issue": "4", "page": "e0346575", "DOI": "10.1371/journal.pone.0346575", "PMID": "41989998", "PMCID": "PMC13086332", "ISSN": "1932-6203", "publisher": "PLOS", "URL": "https://doi.org/10.1371/journal.pone.0346575", "language": "en", "issued": { "date-parts": [ [ 2026, 4, 16 ] ] } }

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s42003-026-10957-8 [code]: Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: JAX, Hugging Face Transformers, UMAP, 10 other tools
[2] doi:10.1038/s41467-026-75959-w [code]: Charting higher-order models of brain function beyond pairwise interactions.
Journal: Nature communications
In common: JAX, xarray, Numba, 7 other tools, 2 references
[3] doi:10.1038/s41467-026-72253-7 [code]: Spurious alignment between large language models and brains can emerge from non-robust methods and overlooked confounds.
Journal: Nature communications
In common: xarray, Hugging Face Transformers, Plotly, 8 other tools, methods / tools
[4] doi:10.3389/fnsys.2026.1822122 [code]: Convergence-divergence circuits for multimodal integration of innate and learned opponent valences.
Journal: Frontiers in systems neuroscience
In common: UMAP, Numba, TensorFlow, 9 other tools
[5] doi:10.1038/s41467-026-73996-z [code]: Genetic architecture of white matter microstructure captured by unsupervised deep representation learning of fractional anisotropy maps.
Journal: Nature communications
In common: UMAP, Plotly, NiBabel, 7 other tools, structural MRI / diffusion, 2 references
[6] doi:10.1126/sciadv.aed4944 [code]: Focused ultrasound blood-brain barrier opening reveals a paradoxical remote metabolic response in the primate brain.
Journal: Science advances
In common: JAX, Numba, TensorFlow, 7 other tools, non-human primate, structural MRI / diffusion
[7] doi:10.1038/s41467-026-72057-9 [code]: Sex-specific behavioral feedback modulates sensorimotor processing and drives flexible social behavior.
Journal: Nature communications
In common: xarray, UMAP, Numba, 8 other tools
[8] doi:10.1038/s41467-026-76011-7 [code]: Human cortex organizes dynamic co-fluctuations along the sensorimotor-association axis.
Journal: Nature communications
In common: NiBabel, PyTorch, SciPy, 2 other tools, 3 references, author Ting Xu
[9] doi:10.21203/rs.3.rs-9326213/v1 [code]: Multi-task fMRI outperforms resting-state fMRI for revealing task-invariant organization of the human brain
Journal: Research Square (preprint)
In common: Numba, Plotly, NiBabel, 7 other tools, 2 references
[10] doi:10.1523/eneuro.0023-26.2026 [code]: Real-Time Segmentation and Classification of Birdsong Syllables for Learning Experiments.
Journal: eNeuro
In common: UMAP, Numba, TensorFlow, 8 other tools

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.

Statistically valid explainable black-box machine learning: applications in sex classification across species using brain imaging.

Code ↔ Paper

Paper

The authors' code

Overview

Abstract

Repositories

google/yggdrasil-decision-forests

neurodata/sex_classification

neurodata/treeple

Code availability

Tracing map

Data

Data Availability

Versions

Version 1, 29 September 2026: the first record

Cite

This paper

Similar papers

Contribute

Claim this paper

Correct its record

Validate its tracing map

Add the badge to its README

Request its removal

Discussion, reproductions, activity