mojolearn.ExtraTreesClassifier

class mojolearn.ExtraTreesClassifier(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=False, oob_score=False, n_jobs=None, random_state=None, verbose=0, warm_start=False, class_weight=None, ccp_alpha=0.0, max_samples=None, monotonic_cst=None, device='gpu', inference_engine='auto', numeric_mode=None)

Bases: _ExtraTreesBase

Extra-trees classifier with scikit-learn’s defaults.

Extremely randomized trees: each split draws one random threshold per candidate feature (scikit-learn’s random splitter, Geurts, Ernst and Wehenkel 2006) instead of searching for the best one. Defaults are scikit-learn’s, name for name. Every scikit-learn parameter is either honoured or refused by name; none is accepted and ignored.

X is converted to float32; NaN or infinity in X raises ValueError. y may hold numbers or strings; NaN labels are refused. Supports the fast, deterministic and identical numeric modes through numeric_mode.

Parameters:

• n_estimators (int, default 100) – Number of trees.

• criterion ({‘gini’, ‘entropy’, ‘log_loss’}, default ‘gini’) – Split criterion; ‘log_loss’ is an alias of ‘entropy’. Other names raise NotImplementedError.

• max_depth (int or None, default None) – Maximum tree depth; None means unlimited.

• min_samples_split (int, default 2) – Minimum rows needed to split a node.

• min_samples_leaf (int, default 1) – Minimum rows in a leaf.

• min_weight_fraction_leaf (float, default 0.0) – Only 0.0 is accepted; sample weights are not supported.

• max_features ({‘sqrt’, ‘log2’}, int, float or None, default ‘sqrt’) – Features drawn per split: a name, a count, a fraction, or None for all features.

• max_leaf_nodes (int or None, default None) – scikit-learn’s best-first growth: an int grows each tree to exactly that many leaves, expanding the node with the largest impurity improvement first (ties go to the smaller node id). None keeps depth-wise growth. The improvement is computed in float32.

• min_impurity_decrease (float, default 0.0) – Minimum impurity decrease required to split.

• bootstrap (bool, default False) – Sample rows with replacement for each tree.

• oob_score (bool, default False) – Only False is accepted; out-of-bag scoring is not implemented.

• n_jobs (None, default None) – Only None is accepted; any other value raises NotImplementedError.

• random_state (int or None, default None) – Seed. None means seed 0, so the default fit is deterministic, unlike scikit-learn.

• verbose (int, default 0) – Only 0 is accepted; any other value raises NotImplementedError.

• warm_start (bool, default False) – Only False is accepted; there is no incremental fit.

• class_weight (None, default None) – Only None is accepted; any other value raises NotImplementedError in fit.

• ccp_alpha (float, default 0.0) – Only 0.0 is accepted; cost-complexity pruning is not implemented.

• max_samples (int, float or None, default None) – Rows drawn per tree when bootstrap=True, resolved as in scikit-learn: None means all rows, an int is a count, a float f means max(int(f * n_samples), 1). Setting it without bootstrap raises an error, as in scikit-learn.

• monotonic_cst (None, default None) – Only None is accepted.

• device ({‘gpu’}, default ‘gpu’) – Only ‘gpu’ is accepted; other values raise ValueError. On a CPU-only install the same calls run the host build of the trainer.

• inference_engine ({‘auto’, ‘sequential’, ‘parallel_groves’}, default ‘auto’) – How predict reduces over trees. ‘auto’ uses ‘parallel_groves’ in fast mode and ‘sequential’ otherwise.

• numeric_mode ({‘fast’, ‘deterministic’, ‘identical’} or None, default None) – Numeric mode for this estimator; None uses the package default.

Variables:

• classes_ (list) – Class labels in sorted order (numbers by value, strings by code point).

• n_features_in_ (int) – Number of features seen in fit.

Examples

>>> import numpy as np, mojolearn
>>> rng = np.random.default_rng(0)
>>> X = rng.random((1000, 8), dtype=np.float32)
>>> y = (X[:, 0] > 0.5).astype(np.int64)
>>> model = mojolearn.ExtraTreesClassifier(n_estimators=50).fit(X, y)
>>> proba = model.predict_proba(X)

__init__(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=False, oob_score=False, n_jobs=None, random_state=None, verbose=0, warm_start=False, class_weight=None, ccp_alpha=0.0, max_samples=None, monotonic_cst=None, device='gpu', inference_engine='auto', numeric_mode=None)

Methods

apply(X)	Return tree-relative leaf IDs, shape (rows, trees), from the native walk.
fit(X, y)	Fit the forest.
get_params([deep])
load(path)	Load a forest saved by save.
numeric_mode_used()	The numeric mode this estimator runs in.
predict(X)	Predicted class labels: the argmax of predict_proba, first maximum winning, mapped through classes_.
predict_proba(X)	Class probabilities: the average of the trees' leaf class distributions.
predict_with_leaves(X)	Return ordered raw mean scores (rows, outputs) and leaf IDs (rows, trees).
save(path)	Write the fitted forest to path as an npz file.
score(X, y[, sample_weight])	Mode-aware GPU accuracy or Float32 R², weighted when sample_weight is given (scikit-learn's weighted accuracy and R² on the pinned-sum path of metrics.accuracy_score and metrics.r2_score).
set_params(**params)	Set constructor parameters.
staged_predict(X)	Return eager mean prefixes, shape (rows, trees, outputs), in tree order.
vendor_used()	The GPU backend this estimator runs on.

fit(X, y)

Fit the forest.

Parameters:

• X (array-like of shape (n_samples, n_features)) – Training data, converted to float32.

• y (array-like of shape (n_samples,)) – Targets.

Returns:

self

predict_proba(X)

Class probabilities: the average of the trees’ leaf class distributions.

Returns:

Array of shape (n_samples, n_classes), float64 – Columns in classes_ order.

predict(X)

Predicted class labels: the argmax of predict_proba, first maximum winning, mapped through classes_.

Returns:

Array or list of shape (n_samples,) – An int64 or float64 Array for numeric labels, a Python list for string labels.