:mod:`sklearn.ensemble`

- |Fix| Do not allow to compute out-of-bag (OOB) score in

:class:`ensemble.RandomForestClassifier` and

:class:`ensemble.ExtraTreesClassifier` with multiclass-multioutput target

def _map_to_bins(const X_DTYPE_C [:, :] data,

list binning_thresholds,

const unsigned char missing_values_bin_idx,

X_BINNED_DTYPE_C [::1, :] binned):

"""Bin continuous and categorical values to discrete integer-coded levels.

cdef:

int feature_idx

_map_col_to_bins(data[:, feature_idx],

binning_thresholds[feature_idx],

missing_values_bin_idx,

binned[:, feature_idx])

cdef void _map_col_to_bins(const X_DTYPE_C [:] data,

const X_DTYPE_C [:] binning_thresholds,

const unsigned char missing_values_bin_idx,

X_BINNED_DTYPE_C [:] binned):

"""Binary search to find the bin index for each value in the data."""

cdef:

int right

int middle

if isnan(data[i]):

binned[i] = missing_values_bin_idx

else:

def _update_raw_predictions(

Y_DTYPE_C [::1] raw_predictions, # OUT

"""Update raw_predictions with the predictions of the newest tree.

values = np.array([leaf.value for leaf in leaves], dtype=Y_DTYPE)

_update_raw_predictions_helper(raw_predictions, starts, stops, partition,

cdef inline void _update_raw_predictions_helper(

Y_DTYPE_C [::1] raw_predictions, # OUT

const unsigned int [::1] starts,

const unsigned int [::1] stops,

const unsigned int [::1] partition,

cdef:

unsigned int position

int leaf_idx

int n_leaves = starts.shape[0]

for position in range(starts[leaf_idx], stops[leaf_idx]):

raw_predictions[partition[position]] += values[leaf_idx]

def _update_gradients_least_squares(

G_H_DTYPE_C [::1] gradients, # OUT

const Y_DTYPE_C [::1] y_true, # IN

cdef:

int n_samples

int i

n_samples = raw_predictions.shape[0]

# Note: a more correct expression is 2 * (raw_predictions - y_true)

# but since we use 1 for the constant hessian value (and not 2) this

# is strictly equivalent for the leaves values.

G_H_DTYPE_C [::1] hessians, # OUT

const Y_DTYPE_C [::1] y_true, # IN

const Y_DTYPE_C [::1] raw_predictions, # IN

cdef:

int n_samples

int i

n_samples = raw_predictions.shape[0]

# Note: a more correct exp is 2 * (raw_predictions - y_true) * sample_weight

# but since we use 1 for the constant hessian value (and not 2) this

# is strictly equivalent for the leaves values.

G_H_DTYPE_C [::1] hessians, # OUT

const Y_DTYPE_C [::1] y_true, # IN

const Y_DTYPE_C [::1] raw_predictions, # IN

cdef:

int n_samples

int i

n_samples = raw_predictions.shape[0]

# gradient = sign(raw_predicition - y_pred) * sample_weight

gradients[i] = sample_weight[i] * (2 *

(y_true[i] - raw_predictions[i] < 0) - 1)

def _update_gradients_least_absolute_deviation(

G_H_DTYPE_C [::1] gradients, # OUT

const Y_DTYPE_C [::1] y_true, # IN

cdef:

int n_samples

int i

n_samples = raw_predictions.shape[0]

# gradient = sign(raw_predicition - y_pred)

gradients[i] = 2 * (y_true[i] - raw_predictions[i] < 0) - 1

G_H_DTYPE_C [::1] hessians, # OUT

const Y_DTYPE_C [::1] y_true, # IN

const Y_DTYPE_C [::1] raw_predictions, # IN

cdef:

int n_samples

int i

Y_DTYPE_C y_pred

n_samples = raw_predictions.shape[0]

if sample_weight is None:

# Note: We use only half of the deviance loss. Therefore, there is

# no factor of 2.

y_pred = exp(raw_predictions[i])

gradients[i] = (y_pred - y_true[i])

hessians[i] = y_pred

else:

# Note: We use only half of the deviance loss. Therefore, there is

# no factor of 2.

y_pred = exp(raw_predictions[i])

G_H_DTYPE_C [::1] hessians, # OUT

const Y_DTYPE_C [::1] y_true, # IN

const Y_DTYPE_C [::1] raw_predictions, # IN

cdef:

int n_samples

Y_DTYPE_C p_i # proba that ith sample belongs to positive class

int i

n_samples = raw_predictions.shape[0]

if sample_weight is None:

p_i = _cexpit(raw_predictions[i])

gradients[i] = p_i - y_true[i]

hessians[i] = p_i * (1. - p_i)

else:

p_i = _cexpit(raw_predictions[i])

gradients[i] = (p_i - y_true[i]) * sample_weight[i]

hessians[i] = p_i * (1. - p_i) * sample_weight[i]

G_H_DTYPE_C [:, ::1] hessians, # OUT

const Y_DTYPE_C [::1] y_true, # IN

const Y_DTYPE_C [:, ::1] raw_predictions, # IN

cdef:

int prediction_dim = raw_predictions.shape[0]

int n_samples = raw_predictions.shape[1]

Y_DTYPE_C p_i_k

if sample_weight is None:

# first compute softmaxes of sample i for each class

for k in range(prediction_dim):

p[i, k] = raw_predictions[k, i] # prepare softmax

gradients[k, i] = p_i_k - (y_true[i] == k)

hessians[k, i] = p_i_k * (1. - p_i_k)

else:

# first compute softmaxes of sample i for each class

for k in range(prediction_dim):

p[i, k] = raw_predictions[k, i] # prepare softmax

const BITSET_INNER_DTYPE_C [:, ::1] raw_left_cat_bitsets,

const BITSET_INNER_DTYPE_C [:, ::1] known_cat_bitsets,

const unsigned int [::1] f_idx_map,

Y_DTYPE_C [:] out):

cdef:

int i

out[i] = _predict_one_from_raw_data(

nodes, numeric_data, raw_left_cat_bitsets,

known_cat_bitsets,

const X_BINNED_DTYPE_C [:, :] binned_data,

BITSET_INNER_DTYPE_C [:, :] binned_left_cat_bitsets,

const unsigned char missing_values_bin_idx,

Y_DTYPE_C [:] out):

cdef:

int i

out[i] = _predict_one_from_binned_data(nodes,

binned_data,

binned_left_cat_bitsets, i,

from ...utils import check_random_state, check_array

from ...base import BaseEstimator, TransformerMixin

from ...utils.validation import check_is_fitted

from ._binning import _map_to_bins

from .common import X_DTYPE, X_BINNED_DTYPE, ALMOST_INF, X_BITSET_INNER_DTYPE

from ._bitset import set_bitset_memoryview

is_categorical=None,

known_categories=None,

random_state=None,

):

self.n_bins = n_bins

self.subsample = subsample

self.is_categorical = is_categorical

self.known_categories = known_categories

self.random_state = random_state

def fit(self, X, y=None):

"""Fit data X by computing the binning thresholds.

"This estimator was fitted with {} features but {} got passed "

"to transform()".format(self.n_bins_non_missing_.shape[0], X.shape[1])

)

binned = np.zeros_like(X, dtype=X_BINNED_DTYPE, order="F")

return binned

def make_known_categories_bitsets(self):