def predict(self, X):
"""Predict regression target for X.
The predicted regression target of an input sample is computed as the
mean predicted regression targets of the trees in the forest.
Parameters
----------
X : array-like of shape = [n_samples, n_features]
The input samples.
Returns
-------
y: array of shape = [n_samples] or [n_samples, n_outputs]
The predicted values.
"""
# Check data
if getattr(X, "dtype", None) != DTYPE or X.ndim != 2:
X = array2d(X, dtype=DTYPE)
# Assign chunk of trees to jobs
n_jobs, n_trees, starts = _partition_estimators(self)
# Parallel loop
all_y_hat = Parallel(n_jobs=n_jobs, verbose=self.verbose,
backend="threading")(
delayed(_parallel_predict_regression)(
self.estimators_[starts[i]:starts[i + 1]], X)
for i in range(n_jobs))
# Reduce
y_hat = sum(all_y_hat) / len(self.estimators_)
return y_hat
def predict_proba(self, X):
check_is_fitted(self, "classes_")
# Check data
X = check_array(X, accept_sparse=['csr', 'csc'])
if self.n_features_ != X.shape[1]:
raise ValueError("Number of features of the model must "
"match the input. Model n_features is {0} and "
"input n_features is {1}."
"".format(self.n_features_, X.shape[1]))
# Parallel loop
n_jobs, n_estimators, starts = _partition_estimators(self.n_estimators,
self.n_jobs)
all_proba = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
delayed(_parallel_predict_proba)(
self.estimators_[starts[i]:starts[i + 1]],
X,
self.n_classes_)
for i in range(n_jobs))
# Reduce
proba = sum(all_proba) / self.n_estimators
return proba
def predict(self, X):
"""Predict regression target for X.
The predicted regression target of an input sample is computed as the
mean predicted regression targets of the trees in the forest.
Parameters
----------
X : array-like of shape = [n_samples, n_features]
The input samples.
Returns
-------
y: array of shape = [n_samples] or [n_samples, n_outputs]
The predicted values.
"""
# Check data
if getattr(X, "dtype", None) != DTYPE or X.ndim != 2:
X = array2d(X, dtype=DTYPE)
# Assign chunk of trees to jobs
n_jobs, n_trees, starts = _partition_estimators(self)
# Parallel loop
all_y_hat = Parallel(n_jobs=n_jobs,
verbose=self.verbose,
backend="threading")(
delayed(_parallel_predict_regression)
(self.estimators_[starts[i]:starts[i + 1]], X)
for i in range(n_jobs))
# Reduce
y_hat = sum(all_y_hat) / len(self.estimators_)
return y_hat
def predict(self, X):
"""Predict regression target for X.
The predicted regression target of an input sample is computed as the
mean predicted regression targets of the estimators in the ensemble.
Parameters
----------
X : {array-like, sparse matrix} of shape = [n_samples, n_features]
The training input samples. Sparse matrices are accepted only if
they are supported by the base estimator.
Returns
-------
y : array of shape = [n_samples]
The predicted values.
"""
check_is_fitted(self, "estimators_features_")
# Check data
X = check_array(X, accept_sparse=['csr', 'csc'])
# Parallel loop
n_jobs, n_estimators, starts = _partition_estimators(
self.n_estimators, self.n_jobs)
all_y_hat = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
delayed(_parallel_predict_regression)(
self.estimators_[starts[i]:starts[i + 1]],
self.estimators_features_[starts[i]:starts[i + 1]], X)
for i in range(n_jobs))
# Reduce
y_hat = sum(all_y_hat) / self.n_estimators
return y_hat
def predict_proba(self, X):
"""Predict class probabilities for X.
The predicted class probabilities of an input sample are computed as
the mean predicted class probabilities of the trees in the forest. The
class probability of a single tree is the fraction of samples of the same
class in a leaf.
Parameters
----------
X : array-like or sparse matrix of shape = [n_samples, n_features]
The input samples. Internally, its dtype will be converted to
``dtype=np.float32``. If a sparse matrix is provided, it will be
converted into a sparse ``csr_matrix``.
Returns
-------
p : array of shape = [n_samples, n_classes], or a list of n_outputs
such arrays if n_outputs > 1.
The class probabilities of the input samples. The order of the
classes corresponds to that in the attribute `classes_`.
"""
check_is_fitted(self, 'estimators_')
# Check data
validate_X(X)
check_X_is_univariate(X)
X = self._validate_X_predict(X)
# Assign chunk of trees to jobs
n_jobs, _, _ = _partition_estimators(self.n_estimators, self.n_jobs)
all_proba = Parallel(n_jobs=n_jobs,
verbose=self.verbose)(delayed(e.predict_proba)(X)
for e in self.estimators_)
return np.sum(all_proba, axis=0) / len(self.estimators_)
def _condense_parallel(self, X, function):
r"""Runs a function of the trees in parallel and condenses the results."""
check_is_fitted(self, 'n_outputs_')
# Check data
X = check_array(X, dtype=DTYPE, accept_sparse=False, order='C')
# Assign chunk of trees to jobs
n_jobs, n_trees, starts = _partition_estimators(
self.n_estimators, self.n_jobs)
# Parallel loop
all_res = Parallel(
n_jobs=n_jobs, verbose=self.verbose, backend="threading")(
delayed(_parallel_helper)(e, function, X, check_input=False)
for e in self.estimators_)
# Reduce
res = all_res[0]
# Single output assumed
for j in range(1, len(all_res)):
res += all_res[j]
res /= len(self.estimators_)
return res
def predict_proba(self, X):
print("ribes: empieza predict_proba de ribes_RandomForestClassifier_method2")
#############################
n_RFF = self.n_RFF
if n_RFF is None:
n_RFF = X.shape[1]
sampler = ribes_RFFSampler(n_components = n_RFF)
junk = sampler.fit_transform(X)
#################################
check_is_fitted(self, 'estimators_')
# Check data
junk = self._validate_X_predict(junk)
# Assign chunk of trees to jobs
n_jobs, _, _ = _partition_estimators(self.n_estimators, self.n_jobs)
# avoid storing the output of every estimator by summing them here
all_proba = [np.zeros((X.shape[0], j), dtype=np.float64)
for j in np.atleast_1d(self.n_classes_)]
lock = threading.Lock()
Parallel(n_jobs=n_jobs, verbose=self.verbose, backend="threading")(
delayed(accumulate_prediction)(e.predict_proba, X, all_proba, lock)
for e in self.estimators_)
for proba in all_proba:
proba /= len(self.estimators_)
if len(all_proba) == 1:
return all_proba[0]
else:
return all_proba
def decision_function(self, X):
check_is_fitted(self, "classes_")
# Check data
X = check_array(X, accept_sparse=['csr', 'csc'])
if self.n_features_ != X.shape[1]:
raise ValueError("Number of features of the model must "
"match the input. Model n_features is {1} and "
"input n_features is {2} "
"".format(self.n_features_, X.shape[1]))
# Parallel loop
n_jobs, n_estimators, starts = _partition_estimators(
self.n_estimators, self.n_jobs)
all_decisions = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
delayed(_parallel_decision_function)(
self.estimators_[starts[i]:starts[i + 1]],
self.estimators_features_[starts[i]:starts[i + 1]], X)
for i in range(n_jobs))
print 'decision_function>>>>>>'
print all_decisions
print 'decision_function>>>>>>'
# Reduce
decisions = sum(all_decisions) / self.n_estimators
return decisions
def _predict(self, predict_fn, X):
check_is_fitted(self, 'estimators_')
# Check data
X = self._validate_X_predict(X)
# Assign chunk of trees to jobs
n_jobs, _, _ = _partition_estimators(self.n_estimators, self.n_jobs)
# avoid storing the output of every estimator by summing them here
if predict_fn == "predict":
y_hat = np.zeros((X.shape[0]), dtype=np.float64)
else:
y_hat = np.zeros((X.shape[0], self.n_outputs_), dtype=np.float64)
# Parallel loop
lock = threading.Lock()
Parallel(n_jobs=n_jobs,
verbose=self.verbose,
**_joblib_parallel_args(require="sharedmem"))(
delayed(_accumulate_prediction)(getattr(e, predict_fn), X,
[y_hat], lock)
for e in self.estimators_)
y_hat /= len(self.estimators_)
return y_hat
def predict_all_estimators(self, sample):
"""Get the prediction of every estimator separated"""
X, _ = extract_features.get_matrices_from_samples([sample])
X = filter_feature_matrix(X, self.features)
# Most of the code is directly copied from Scikit
# Check data
check_is_fitted(self.regressor, 'n_outputs_')
# Check data
X = check_array(X, dtype=DTYPE, accept_sparse="csr")
if issparse(X) and (X.indices.dtype != np.intc or
X.indptr.dtype != np.intc):
raise ValueError("No support for np.int64 index based "
"sparse matrices")
# Assign chunk of trees to jobs
n_jobs, n_trees, starts = _partition_estimators(self.regressor.n_estimators,
self.regressor.n_jobs)
# Parallel loop
all_y_hat = Parallel(n_jobs=n_jobs, verbose=self.regressor.verbose,
backend="threading")(
delayed(_parallel_helper)(e, 'predict', X, check_input=False)
for e in self.regressor.estimators_)
return all_y_hat
def _mean_fn(self, X, fn, acc, slice=None):
# Helper class that accumulates an arbitrary function in parallel on the accumulator acc
# and calls the function fn on each tree e and returns the mean output. The function fn
# should take as input a tree e, and return another function g_e, which takes as input X, check_input
# If slice is not None, but rather a tuple (start, end), then a subset of the trees from
# index start to index end will be used. The returned result is essentially:
# (mean over e in slice)(g_e(X)).
check_is_fitted(self, 'estimators_')
# Check data
X = self._validate_X_predict(X)
if slice is None:
estimator_slice = self.estimators_
else:
estimator_slice = self.estimators_[slice[0]:slice[1]]
# Assign chunk of trees to jobs
n_jobs, _, _ = _partition_estimators(len(estimator_slice), self.n_jobs)
lock = threading.Lock()
Parallel(n_jobs=n_jobs,
verbose=self.verbose,
**_joblib_parallel_args(require="sharedmem"))(
delayed(_accumulate_prediction)(fn(e), X, [acc], lock)
for e in estimator_slice)
acc /= len(estimator_slice)
return acc
def predict(self, X):
"""Predict regression target for X.
The predicted regression target of an input sample is computed as the
mean predicted regression targets of the trees in the forest.
Parameters
----------
X : array-like or sparse matrix of shape = [n_samples, n_features]
The input samples. Internally, its dtype will be converted to
``dtype=np.float32``. If a sparse matrix is provided, it will be
converted into a sparse ``csr_matrix``.
Returns
-------
y : array of shape = [n_samples] or [n_samples, n_outputs]
The predicted values.
"""
check_is_fitted(self, 'estimators_')
# Check data
validate_X(X)
X = self._validate_X_predict(X)
# Assign chunk of trees to jobs
n_jobs, _, _ = _partition_estimators(self.n_estimators, self.n_jobs)
# Parallel loop
y_hat = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
delayed(e.predict)(X, check_input=True) for e in self.estimators_)
return np.sum(y_hat, axis=0) / len(self.estimators_)
def predict_log_proba(self, X):
check_is_fitted(self, "classes_")
if hasattr(self.base_estimator_, "predict_log_proba"):
X = check_array(X, accept_sparse=['csr', 'csc'])
if self.n_features_ != X.shape[1]:
raise ValueError("Number of features of the model must "
"match the input. Model n_features is {0} "
"and input n_features is {1} "
"".format(self.n_features_, X.shape[1]))
n_jobs, n_estimators, starts = _partition_estimators(
self.n_estimators, self.n_jobs)
all_log_proba = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
delayed(_parallel_predict_log_proba)
(self.estimators_[starts[i]:starts[i + 1]], self.
estimators_features_[starts[i]:starts[i +
1]], X, self.n_classes_)
for i in range(n_jobs))
log_proba = all_log_proba[0]
for j in range(1, len(all_log_proba)):
log_proba = np.logaddexp(log_proba, all_log_proba[j])
log_proba -= np.log(self.n_estimators)
return log_proba
else:
return np.log(self.predict_proba(X))
def predict(self, X, eval_MSE=False):
check_is_fitted(self, 'estimators_')
# Check data
X = self._check_X(X)
X = self._validate_X_predict(X)
# Assign chunk of trees to jobs
n_jobs, _, _ = _partition_estimators(self.n_estimators, self.n_jobs)
# avoid storing the output of every estimator by summing them here
if self.n_outputs_ > 1:
y_hat_all = np.zeros(
(X.shape[0], self.n_outputs_, self.n_estimators),
dtype=np.float64)
else:
y_hat_all = np.zeros((X.shape[0], self.n_estimators),
dtype=np.float64)
# Parallel loop
Parallel(n_jobs=n_jobs, verbose=self.verbose,
backend="threading")(delayed(save)(e.predict, X, i, y_hat_all)
for i, e in enumerate(self.estimators_))
y_hat = np.mean(y_hat_all, axis=1).flatten()
if eval_MSE:
sigma2 = np.std(y_hat_all, axis=1, ddof=1)**2.
sigma2 = sigma2.flatten()
return (y_hat, sigma2) if eval_MSE else y_hat
def fit(self, X, y, sample_weight=None):
# classes_ = self.classes_
random_state = check_random_state(self.random_state)
# Convert data
X, y = check_X_y(X, y, ['csr', 'csc'])
# Remap output
n_samples, self.n_features_ = X.shape
y = self._validate_y(y)
# Check parameters
self._validate_estimator()
if not self.warm_start or len(self.estimators_) == 0:
# Free allocated memory, if any
self.estimators_ = []
self.estimators_switches_ = []
n_more_estimators = self.n_estimators - len(self.estimators_)
if n_more_estimators < 0:
raise ValueError('n_estimators=%d must be larger or equal to '
'len(estimators_)=%d when warm_start==True'
% (self.n_estimators, len(self.estimators_)))
elif n_more_estimators == 0:
warn("Warm-start fitting without increasing n_estimators does not "
"fit new trees.")
return self
# Parallel loop
n_jobs, n_estimators, starts = _partition_estimators(n_more_estimators,
self.n_jobs)
# Advance random state to state after training
# the first n_estimators
if self.warm_start and len(self.estimators_) > 0:
random_state.randint(MAX_INT, size=len(self.estimators_))
seeds = random_state.randint(MAX_INT, size=n_more_estimators)
all_results = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
delayed(_parallel_build_estimators)(
n_estimators[i],
self,
X,
y,
seeds[starts[i]:starts[i + 1]],
verbose=self.verbose)
for i in range(n_jobs))
# Reduce
self.estimators_ += list(itertools.chain.from_iterable(
t[0] for t in all_results))
self.estimators_switches_ += list(itertools.chain.from_iterable(
t[1] for t in all_results))
return self
def predict_proba(self, X):
"""Predict class probabilities for X.
The predicted class probabilities of an input sample is computed as
the mean predicted class probabilities of the trees in the forest.
Parameters
----------
X : array-like of shape = [n_samples, n_features]
The input samples.
Returns
-------
p : array of shape = [n_samples, n_classes], or a list of n_outputs
such arrays if n_outputs > 1.
The class probabilities of the input samples. The order of the
classes corresponds to that in the attribute `classes_`.
"""
# Check data
if getattr(X, "dtype", None) != DTYPE or X.ndim != 2:
X = array2d(X, dtype=DTYPE)
# Assign chunk of trees to jobs
n_jobs, n_trees, starts = _partition_estimators(self)
# Bugfix for _parallel_predict_proba which expects a list for multi-label and integer for single-label problems
if not isinstance(self.n_classes_, int) and len(self.n_classes_) == 1:
n_classes_ = self.n_classes_[0]
else:
n_classes_ = self.n_classes_
# Parallel loop
all_proba = Parallel(n_jobs=n_jobs, verbose=self.verbose,
backend="threading")(
delayed(_parallel_predict_proba)(
self.estimators_[starts[i]:starts[i + 1]],
X,
n_classes_,
self.n_outputs_)
for i in range(n_jobs))
# Reduce
proba = all_proba[0]
if self.n_outputs_ == 1:
for j in xrange(1, len(all_proba)):
proba += all_proba[j]
proba /= len(self.estimators_)
else:
for j in xrange(1, len(all_proba)):
for k in xrange(self.n_outputs_):
proba[k] += all_proba[j][k]
for k in xrange(self.n_outputs_):
proba[k] /= self.n_estimators
return proba
def predict_proba(self, X):
"""Predict class probabilities for X.
The predicted class probabilities of an input sample is computed as
the mean predicted class probabilities of the trees in the forest.
Parameters
----------
X : array-like of shape = [n_samples, n_features]
The input samples.
Returns
-------
p : array of shape = [n_samples, n_classes], or a list of n_outputs
such arrays if n_outputs > 1.
The class probabilities of the input samples. The order of the
classes corresponds to that in the attribute `classes_`.
"""
# Check data
if getattr(X, "dtype", None) != DTYPE or X.ndim != 2:
X = array2d(X, dtype=DTYPE)
# Assign chunk of trees to jobs
n_jobs, n_trees, starts = _partition_estimators(self)
# Bugfix for _parallel_predict_proba which expects a list for multi-label and integer for single-label problems
if not isinstance(self.n_classes_, int) and len(self.n_classes_) == 1:
n_classes_ = self.n_classes_[0]
else:
n_classes_ = self.n_classes_
# Parallel loop
all_proba = Parallel(n_jobs=n_jobs,
verbose=self.verbose,
backend="threading")(
delayed(_parallel_predict_proba)
(self.estimators_[starts[i]:starts[i + 1]], X,
n_classes_, self.n_outputs_)
for i in range(n_jobs))
# Reduce
proba = all_proba[0]
if self.n_outputs_ == 1:
for j in xrange(1, len(all_proba)):
proba += all_proba[j]
proba /= len(self.estimators_)
else:
for j in xrange(1, len(all_proba)):
for k in xrange(self.n_outputs_):
proba[k] += all_proba[j][k]
for k in xrange(self.n_outputs_):
proba[k] /= self.n_estimators
return proba
def predict_proba(self, X):
"""Predict class probabilities for X.
The predicted class probabilities of an input sample is computed as
the mean predicted class probabilities of the trees in the forest. The
class probability of a single tree is the fraction of samples of the same
class in a leaf.
Parameters
----------
X : array-like or sparse matrix of shape = [n_samples, n_features]
The input samples. Internally, it will be converted to
``dtype=np.float32`` and if a sparse matrix is provided
to a sparse ``csr_matrix``.
Returns
-------
p : array of shape = [n_samples, n_classes], or a list of n_outputs
such arrays if n_outputs > 1.
The class probabilities of the input samples. The order of the
classes corresponds to that in the attribute `classes_`.
"""
# Check data
if self.scaling:
X = self._scale(X)
X = self._validate_X_predict(X)
# Assign chunk of trees to jobs
n_jobs, _, _ = _partition_estimators(self.n_estimators, self.n_jobs)
# Parallel loop
all_proba = Parallel(n_jobs=n_jobs,
verbose=self.verbose,
backend="threading")(delayed(_parallel_helper)(
e, 'predict_proba', X, check_input=False)
for e in self.estimators_)
# Reduce
proba = all_proba[0]
if self.n_outputs_ == 1:
for j in range(1, len(all_proba)):
proba += self.estimator_weights[j] * all_proba[j]
#proba /= len(self.estimators_)
proba /= np.sum(self.estimator_weights[j])
else:
for j in range(1, len(all_proba)):
for k in range(self.n_outputs_):
proba[k] += self.estimator_weights[j] * all_proba[j][k]
for k in range(self.n_outputs_):
proba[k] /= np.sum(self.estimator_weights[j])
return proba
def predict_proba(self, X):
"""Predict class probabilities for X.
The predicted class probabilities of an input sample is computed as
the mean predicted class probabilities of the trees in the forest. The
class probability of a single tree is the fraction of samples of the same
class in a leaf.
Parameters
----------
X : array-like or sparse matrix of shape = [n_samples, n_features]
The input samples. Internally, it will be converted to
``dtype=np.float32`` and if a sparse matrix is provided
to a sparse ``csr_matrix``.
Returns
-------
p : array of shape = [n_samples, n_classes], or a list of n_outputs
such arrays if n_outputs > 1.
The class probabilities of the input samples. The order of the
classes corresponds to that in the attribute `classes_`.
"""
# Check data
if self.scaling:
X = self._scale(X)
X = self._validate_X_predict(X)
# Assign chunk of trees to jobs
n_jobs, _, _ = _partition_estimators(self.n_estimators, self.n_jobs)
# Parallel loop
all_proba = Parallel(n_jobs=n_jobs, verbose=self.verbose,
backend="threading")(
delayed(_parallel_helper)(e, 'predict_proba', X,
check_input=False)
for e in self.estimators_)
# Reduce
proba = all_proba[0]
if self.n_outputs_ == 1:
for j in range(1, len(all_proba)):
proba += self.estimator_weights[j]*all_proba[j]
#proba /= len(self.estimators_)
proba /= np.sum(self.estimator_weights[j])
else:
for j in range(1, len(all_proba)):
for k in range(self.n_outputs_):
proba[k] += self.estimator_weights[j]*all_proba[j][k]
for k in range(self.n_outputs_):
proba[k] /= np.sum(self.estimator_weights[j])
return proba
def predict(self, X, mask):
"""Predict regression target for X.
The predicted regression target of an input sample is computed as the
mean predicted regression targets of the trees in the forest.
Parameters
----------
X : array-like or sparse matrix of shape = [n_samples, n_features]
The input samples. Internally, its dtype will be converted to
``dtype=np.float32``. If a sparse matrix is provided, it will be
converted into a sparse ``csr_matrix``.
mask : array que armazena a informaçao de haver ou não haver a arvore na floresta.
fileCache : Rota onde se encontra as arvores que seram trabalhadas, lembrando que cada colecao e cada fold
possui um conjunto unico de arvores
Returns
-------
y : array of shape = [n_samples] or [n_samples, n_outputs]
The predicted values.
"""
mask = [i == '1' or i == 1 for i in mask]
self.n_outputs_ = 1
check_is_fitted(self, 'estimators_')
# Check data
X = self._validate_X_predict(X)
# Assign chunk of trees to jobs
n_jobs, _, _ = _partition_estimators(self.n_estimators, self.n_jobs)
# avoid storing the output of every estimator by summing them here
if self.n_outputs_ > 1:
y_hat = np.zeros((X.shape[0], self.n_outputs_), dtype=np.float64)
else:
y_hat = np.zeros((X.shape[0]), dtype=np.float64)
# Parallel loop
lock = threading.Lock()
Parallel(n_jobs=n_jobs,
verbose=self.verbose,
**_joblib_parallel_args(require="sharedmem"))(
delayed(_accumulate_prediction_mod)(e.predict, X, gene,
[y_hat], lock)
for e, gene in zip(self.estimators_, mask))
n_trees = 0
for g in mask:
if g:
n_trees += 1
y_hat /= n_trees
return y_hat
def oob_predict(self, X, y, genes, parallel=True):
"""
Compute out-of-bag prediction.
"""
X = check_array(X, dtype=DTYPE, accept_sparse='csr')
n_samples = y.shape[0]
predictions = np.zeros((n_samples, self.n_outputs_))
n_predictions = np.zeros((n_samples, self.n_outputs_))
n_samples_bootstrap = _get_n_samples_bootstrap(n_samples, None)
genes = [i == '1' or i == 1 for i in genes]
if parallel:
# Assign chunk of trees to jobs
n_jobs, _, _ = _partition_estimators(self.n_estimators,
self.n_jobs)
# Parallel loop
lock = threading.Lock()
Parallel(n_jobs=n_jobs,
verbose=self.verbose,
**_joblib_parallel_args(require="sharedmem"))(
delayed(_oob_accumulate_prediction)
(e.predict, X, gene, [predictions, n_predictions],
lock, n_samples, n_samples_bootstrap,
self.n_outputs_, e.random_state)
for e, gene in zip(self.estimators_, genes))
else:
for e, gene in zip(self.estimators_, genes):
if gene:
unsampled_indices = _generate_unsampled_indices(
e.random_state, n_samples, n_samples_bootstrap)
p_estimator = e.predict(X[unsampled_indices, :],
check_input=False)
if self.n_outputs_ == 1:
p_estimator = p_estimator[:, np.newaxis]
predictions[unsampled_indices, :] += p_estimator
n_predictions[unsampled_indices, :] += 1
else:
pass
if (n_predictions == 0).any():
warn("Some inputs do not have OOB scores. "
"This probably means too few trees were used "
"to compute any reliable oob estimates.")
n_predictions[n_predictions == 0] = 1
predictions /= n_predictions
return predictions
def predict_log_proba(self, X):
"""Predict class log-probabilities for X.
The predicted class log-probabilities of an input sample is computed as
the log of the mean predicted class probabilities of the base
estimators in the ensemble.
Parameters
----------
X : {array-like, sparse matrix} of shape = [n_samples, n_features]
The training input samples. Sparse matrices are accepted only if
they are supported by the base estimator.
Returns
-------
p : array of shape = [n_samples, n_classes]
The class log-probabilities of the input samples. The order of the
classes corresponds to that in the attribute `classes_`.
"""
check_is_fitted(self, "classes_")
if hasattr(self.base_estimator_, "predict_log_proba"):
# Check data
X = check_array(X, accept_sparse=['csr', 'csc'])
if self.n_features_ != X.shape[1]:
raise ValueError("Number of features of the model must "
"match the input. Model n_features is {0} "
"and input n_features is {1} "
"".format(self.n_features_, X.shape[1]))
# Parallel loop
n_jobs, n_estimators, starts = _partition_estimators(
self.n_estimators, self.n_jobs)
all_log_proba = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
delayed(_parallel_predict_log_proba)(
self.estimators_[starts[i]:starts[i + 1]],
self.estimators_features_[starts[i]:starts[i + 1]],
X,
self.n_classes_)
for i in range(n_jobs))
# Reduce
log_proba = all_log_proba[0]
for j in range(1, len(all_log_proba)):
log_proba = np.logaddexp(log_proba, all_log_proba[j])
log_proba -= np.log(self.n_estimators)
return log_proba
else:
return np.log(self.predict_proba(X))
def predict(self, X):
"""Predict anomaly score of X with the IsolationForest algorithm.
The anomaly score of an input sample is computed as
the mean anomaly scores of the trees in the forest.
The measure of normality of an observation given a tree is the depth
of the leaf containing this observation, which is equivalent to
the number of splitting required to isolate this point. In case of
several observations n_left in the leaf, the average length path of
a n_left samples isolation tree is added.
Parameters
----------
X : array-like or sparse matrix of shape (n_samples, n_features)
The input samples. Internally, it will be converted to
``dtype=np.float32`` and if a sparse matrix is provided
to a sparse ``csr_matrix``.
Returns
-------
scores : array of shape (n_samples,)
The anomaly score of the input samples.
The lower, the more normal.
"""
# code structure from ForestClassifier/predict_proba
# Check data
X = check_array(X, dtype=DTYPE, accept_sparse="csr")
n_samples = X.shape[0]
# Assign chunk of trees to jobs
n_jobs, n_trees, starts = _partition_estimators(self.n_estimators,
self.n_jobs)
# Parallel loop
results = Parallel(n_jobs=self.n_jobs, verbose=self.verbose,
backend="threading")(
delayed(_parallel_helper)(tree.tree_, 'apply_depth', X)
for tree in self.estimators_)
# Reduce
results = np.array(results)
scores = np.zeros(n_samples)
depth = np.mean(results, axis=0)
for k in range(n_samples):
scores[k] = np.power(2, - depth[k] / self._cost(self.max_samples))
return scores
def predict(self, X):
"""Predict anomaly score of X with the IsolationForest algorithm.
The anomaly score of an input sample is computed as
the mean anomaly scores of the trees in the forest.
The measure of normality of an observation given a tree is the depth
of the leaf containing this observation, which is equivalent to
the number of splitting required to isolate this point. In case of
several observations n_left in the leaf, the average length path of
a n_left samples isolation tree is added.
Parameters
----------
X : array-like or sparse matrix of shape (n_samples, n_features)
The input samples. Internally, it will be converted to
``dtype=np.float32`` and if a sparse matrix is provided
to a sparse ``csr_matrix``.
Returns
-------
scores : array of shape (n_samples,)
The anomaly score of the input samples.
The lower, the more normal.
"""
# code structure from ForestClassifier/predict_proba
# Check data
X = check_array(X, dtype=DTYPE, accept_sparse="csr")
n_samples = X.shape[0]
# Assign chunk of trees to jobs
n_jobs, n_trees, starts = _partition_estimators(
self.n_estimators, self.n_jobs)
# Parallel loop
results = Parallel(
n_jobs=self.n_jobs, verbose=self.verbose, backend="threading")(
delayed(_parallel_helper)(tree.tree_, 'apply_depth', X)
for tree in self.estimators_)
# Reduce
results = np.array(results)
scores = np.zeros(n_samples)
depth = np.mean(results, axis=0)
for k in range(n_samples):
scores[k] = np.power(2, -depth[k] / self._cost(self.max_samples))
return scores
def predict_proba(self, X):
"""Predict class probabilities for X.
The predicted class probabilities of an input sample is computed as
the mean predicted class probabilities of the base estimators in the
ensemble. If base estimators do not implement a ``predict_proba``
method, then it resorts to voting and the predicted class probabilities
of an input sample represents the proportion of estimators predicting
each class.
Parameters
----------
X : {array-like, sparse matrix} of shape = [n_samples, n_features]
The training input samples. Sparse matrices are accepted only if
they are supported by the base estimator.
Returns
-------
p : array of shape = [n_samples, n_classes]
The class probabilities of the input samples. The order of the
classes corresponds to that in the attribute `classes_`.
"""
check_is_fitted(self, "classes_")
# Check data
X = check_array(X, accept_sparse=['csr', 'csc'])
if self.n_features_ != X.shape[1]:
raise ValueError("Number of features of the model must "
"match the input. Model n_features is {0} and "
"input n_features is {1}."
"".format(self.n_features_, X.shape[1]))
# Parallel loop
n_jobs, n_estimators, starts = _partition_estimators(self.n_estimators,
self.n_jobs)
all_proba = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
delayed(_parallel_predict_proba)(
self.estimators_[starts[i]:starts[i + 1]],
self.estimators_features_[starts[i]:starts[i + 1]],
X,
self.n_classes_)
for i in range(n_jobs))
# Reduce
proba = sum(all_proba) / self.n_estimators
return proba
def predict(self, X):
""" Predict regression target for X.
The predicted regression target of an input sample is computed as the
averaged predicted distributions of the estimators in the ensemble.
Parameters
----------
X : {array-like, sparse matrix} of shape = [n_samples, n_features]
The training input samples. Sparse matrices are accepted only if
they are supported by the base estimator.
Returns
-------
y : skpro.base.Distribution = [n_samples]
The predicted bagged distributions.
"""
# Ensure estimator were being fitted
check_is_fitted(self, "estimators_features_")
# Check data
X = check_array(X, accept_sparse=['csr', 'csc'])
# Parallel loop
from sklearn.ensemble.base import _partition_estimators
n_jobs, n_estimators, starts = _partition_estimators(
self.n_estimators, self.n_jobs)
def _parallel_predict_regression(estimators, estimators_features, X):
""" Private function used to compute predictions within a job. """
return [
estimator.predict(X[:, features])
for estimator, features in zip(estimators, estimators_features)
]
# Obtain predictions
all_y_hat = [
_parallel_predict_regression(
self.estimators_[starts[i]:starts[i + 1]],
self.estimators_features_[starts[i]:starts[i + 1]], X)
for i in range(n_jobs)
]
# Reduce
return self._distribution()(self, X, all_y_hat, n_estimators)
def predict_proba(self, X):
check_is_fitted(self, "classes_")
# Check data
X = check_array(X, accept_sparse=['csr', 'csc'])
# Parallel loop
n_jobs, n_estimators, starts = _partition_estimators(
self.n_estimators, self.n_jobs)
all_proba = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
delayed(_parallel_predict_proba)(
self.estimators_[starts[i]:starts[i + 1]], X, self.n_classes_)
for i in range(n_jobs))
# Reduce
proba = sum(all_proba) / self.n_estimators
return proba
def decision_function(self, X):
"""Average of the decision functions of the base classifiers.
Parameters
----------
X : {array-like, sparse matrix} of shape = [n_samples, n_features]
The training input samples. Sparse matrices are accepted only if
they are supported by the base estimator.
Returns
-------
score : array, shape = [n_samples, k]
The decision function of the input samples. The columns correspond
to the classes in sorted order, as they appear in the attribute
``classes_``. Regression and binary classification are special
cases with ``k == 1``, otherwise ``k==n_classes``.
"""
check_is_fitted(self, "classes_")
# Check data
X = check_array(X, accept_sparse=['csr', 'csc'])
if self.n_features_ != X.shape[1]:
raise ValueError("Number of features of the model must "
"match the input. Model n_features is {0} and "
"input n_features is {1} "
"".format(self.n_features_, X.shape[1]))
# Parallel loop
n_jobs, n_estimators, starts = _partition_estimators(self.n_estimators,
self.n_jobs)
all_decisions = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
delayed(_parallel_decision_function)(
self.estimators_[starts[i]:starts[i + 1]],
self.estimators_features_[starts[i]:starts[i + 1]],
X)
for i in range(n_jobs))
# Reduce
decisions = sum(all_decisions) / self.n_estimators
return decisions
def forest_regressor_predict(self, X):
"""Copy of the RandomForest Regression predict code, while retaining the entire ensemble in self.all_y_hat """
# Check data
X = self._validate_X_predict(X)
# Assign chunk of trees to jobs
n_jobs, _, _ = _partition_estimators(self.n_estimators, self.n_jobs)
# Parallel loop
all_y_hat = Parallel(
n_jobs=n_jobs, verbose=self.verbose, backend="threading")(
delayed(_parallel_helper)(e, 'predict', X, check_input=False)
for e in self.estimators_)
# Reduce
y_hat = sum(all_y_hat) / len(self.estimators_)
""" This is the ONLY line changed: Save the decision tree results to the object for external use """
self.all_y_hat = all_y_hat
return y_hat
def predict_proba(self, X):
check_is_fitted(self, "classes_")
# Check data
X = check_array(X, accept_sparse=['csr', 'csc'])
# Parallel loop
n_jobs, n_estimators, starts = _partition_estimators(self.n_estimators,
self.n_jobs)
all_proba = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
delayed(_parallel_predict_proba)(
self.estimators_[starts[i]:starts[i + 1]],
X,
self.n_classes_)
for i in range(n_jobs))
# Reduce
proba = sum(all_proba) / self.n_estimators
return proba
def fit(self, X, Y):
X, Y = map(np.atleast_2d, (X, Y))
assert X.shape[0] == Y.shape[0]
Ny = Y.shape[1]
self.estimators_ = []
n_jobs, n_estimators, starts = _partition_estimators(Ny, self.n_jobs)
results = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
delayed(_parallel_build_estimator)(
n_estimators[i],
self,
X,
Y,
starts[i],
verbose=self.verbose)
for i in range(n_jobs))
self.estimators_ += list(itertools.chain.from_iterable(results))
return self
def predict(self, X):
"""Predict regression target for X.
The predicted regression target of an input sample is computed as the
mean predicted regression targets of the trees in the forest.
Parameters
----------
X : array-like or sparse matrix of shape = [n_samples, n_features]
The input samples. Internally, its dtype will be converted to
``dtype=np.float32``. If a sparse matrix is provided, it will be
converted into a sparse ``csr_matrix``.
Returns
-------
y : array of shape = [n_samples] or [n_samples, n_outputs]
The predicted values.
"""
check_is_fitted(self, 'estimators_')
# Check data
X = self._validate_X_predict(X)
# Assign chunk of trees to jobs
n_jobs, _, _ = _partition_estimators(self.n_estimators, self.n_jobs)
# avoid storing the output of every estimator by summing them here
if self.n_outputs_ > 1:
y_hat = np.zeros((X.shape[0], self.n_outputs_), dtype=np.float64)
else:
y_hat = np.zeros((X.shape[0]), dtype=np.float64)
# Parallel loop
lock = threading.Lock()
Parallel(n_jobs=n_jobs, verbose=self.verbose, backend="threading")(
delayed(accumulate_prediction)(e.predict, X, [y_hat], lock)
for e in self.estimators_)
y_hat /= len(self.estimators_)
return y_hat
def oob_predict_buffer(self, X, y, parallel=True):
X = check_array(X, dtype=DTYPE, accept_sparse='csr')
n_samples = X.shape[0]
n_samples_bootstrap = _get_n_samples_bootstrap(n_samples, None)
prediction_buffer = np.zeros(
(n_samples_bootstrap, len(self.estimators_)), dtype='float32')
prediction_buffer[:, :] = np.nan
if parallel:
# Assign chunk of trees to jobs
n_jobs, _, _ = _partition_estimators(self.n_estimators,
self.n_jobs)
# Parallel loop
lock = threading.Lock()
Parallel(
n_jobs=n_jobs,
verbose=self.verbose,
**_joblib_parallel_args(require="sharedmem"))(
delayed(_oob_bufferize_prediction)
(e.predict, X, estimator, prediction_buffer, lock,
n_samples, n_samples_bootstrap, self.n_outputs_,
e.random_state) for e, estimator in zip(
self.estimators_, range(0, len(self.estimators_))))
else:
for e, estimator in zip(self.estimators_,
range(0, len(self.estimators_))):
unsampled_indices = _generate_unsampled_indices(
e.random_state, n_samples, n_samples_bootstrap)
p_estimator = e.predict(X[unsampled_indices, :],
check_input=False)
prediction_buffer[unsampled_indices, estimator] = p_estimator
self.__buffer = prediction_buffer
def predict_proba(self, X):
# Check data
X = self.check_X(X)
# Assign chunk of trees to jobs
n_jobs, _, _ = _partition_estimators(self.n_estimators, 2)
# avoid storing the output of every estimator by summing them here
all_proba = [np.zeros((X.shape[0], j), dtype=np.float64)
for j in np.atleast_1d(self.n_classes_)]
lock = threading.Lock()
Parallel(n_jobs=n_jobs, backend="threading")(
delayed(accumulate_prediction)(e.predict_proba, X, all_proba, lock)
for e in self.estimators_)
for proba in all_proba:
proba /= len(self.estimators_)
if len(all_proba) == 1:
return all_proba[0]
else:
return all_proba
def decision_function(self, X):
"""Average of the decision functions of the base classifiers."""
check_is_fitted(self, "classes_")
X = check_array(X, accept_sparse=['csr', 'csc'])
if self.n_features_ != X.shape[1]:
raise ValueError("Number of features of the model must "
"match the input. Model n_features is {0} and "
"input n_features is {1} "
"".format(self.n_features_, X.shape[1]))
n_jobs, n_estimators, starts = _partition_estimators(
self.n_estimators, self.n_jobs)
all_decisions = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
delayed(_parallel_decision_function)(
self.estimators_[starts[i]:starts[i + 1]],
self.estimators_features_[starts[i]:starts[i + 1]], X)
for i in range(n_jobs))
decisions = sum(all_decisions) / self.n_estimators
return decisions
def _fit(self, X, y, max_samples=None, max_depth=None, sample_weight=None):
"""Build an ensemble of estimators from the training
set (X, y) using a sliding window.
Parameters
----------
X : {array-like, sparse matrix} of shape = [n_samples, n_features]
The training input samples. Sparse matrices are accepted only if
they are supported by the base estimator.
y : array-like, shape = [n_samples]
The target values (class labels in classification, real numbers in
regression).
max_samples : int or float, optional (default=None)
Argument to use instead of self.max_samples.
max_depth : int, optional (default=None)
Override value used when constructing base estimator. Only
supported if the base estimator has a max_depth parameter.
sample_weight : array-like, shape = [n_samples] or None
Sample weights. If None, then samples are equally weighted.
Note that this is supported only if the base estimator supports
sample weighting.
Returns
-------
self : object
Returns self.
"""
random_state = check_random_state(self.random_state)
# Convert data
X, y = check_X_y(X, y, ['csr', 'csc'])
# Remap output
n_samples, self.n_features_ = X.shape
self._n_samples = n_samples
y = self._validate_y(y)
if not 0 < self.window_size <= self.n_features_:
raise ValueError("window_size not valid")
if not 0 < self.stride <= self.window_size:
raise ValueError("stride not valid")
# Check parameters
if not self.circular_features:
self.n_windows_ = int(
np.ceil((self.n_features_ - self.window_size) / self.stride) +
1)
else:
# it is independent from window_size
self.n_windows_ = len(range(0, self.n_features_, self.stride))
if self.n_estimators is None:
self.n_estimators = self.n_estimators_window * self.n_windows_
else:
self.n_estimators_window = int(self.n_estimators / self.n_windows_)
self.n_estimators = self.n_estimators_window * self.n_windows_
# _check_estimator(self.base_estimator) # ?
self._validate_estimator()
if max_depth is not None:
self.base_estimator_.max_depth = max_depth
# Validate max_samples
if max_samples is None:
max_samples = self.max_samples
elif not isinstance(max_samples, (numbers.Integral, np.integer)):
max_samples = int(max_samples * X.shape[0])
if not 0 < max_samples <= X.shape[0]:
raise ValueError("max_samples must be in (0, n_samples]")
# Store validated integer row sampling value
self._max_samples = max_samples
# Validate max_features
if isinstance(self.max_features, (numbers.Integral, np.integer)):
max_features = self.max_features
else: # float
max_features = int(self.max_features * self.window_size)
if (self.bootstrap_features and max_features <= 0) or \
not 0 < max_features <= self.window_size:
raise ValueError("max_features must be in (0, window_size] if not"
" bootstrap_features.")
# Store validated integer feature sampling value
self._max_features = max_features
# Other checks
if not self.bootstrap and self.oob_score and \
self._max_samples >= n_samples:
raise ValueError("Out of bag estimation only available"
" if bootstrap=True or max_samples < n_samples")
# if self.warm_start and self.oob_score:
# raise ValueError("Out of bag estimate only available"
# " if warm_start=False")
# if hasattr(self, "oob_score_") and self.warm_start:
# del self.oob_score_
# if not self.warm_start or len(self.estimators_) == 0:
# if len(self.estimators_) == 0: # TODO think about warm_start or adding estimators
# Free allocated memory, if any
self.estimators_ = []
self.estimators_features_ = []
self._estimators_samples = []
n_more_estimators = self.n_estimators - len(self.estimators_)
if n_more_estimators < 1:
raise ValueError('n_estimators=%d must be larger or equal to 1' %
(self.n_estimators))
# using oob_score, take only "code_size" best estimators
if isinstance(self.code_size, (numbers.Integral, np.integer)):
self.code_size_ = self.code_size
elif isinstance(self.code_size, (numbers.Real, np.float)): # float
self.code_size_ = int(self.code_size * self.n_estimators)
elif self.code_size is None or self.code_size == 'auto':
self.code_size_ = self.n_estimators
elif self.code_size == 'sqrt':
self.code_size_ = int(np.sqrt(self.n_estimators))
elif self.code_size == 'log2':
self.code_size_ = int(np.log2(self.n_estimators))
else:
raise ValueError("Value for code_size '{}' unrecognized".format(
self.code_size))
if self.code_size <= 0:
raise ValueError("code_size should be greater than 0, got {1}"
"".format(self.code_size))
if self.verbose:
print("You are about to generate {0} estimators for {1} windows, "
"for a total of {2} estimators.".format(
self.n_estimators_window, self.n_windows_,
self.n_estimators))
# Parallel loop
n_jobs, n_estimators, starts = _partition_estimators(
n_more_estimators, self.n_jobs)
total_n_estimators = sum(n_estimators)
# Advance random state to state after training
# the first n_estimators
# if self.warm_start and len(self.estimators_) > 0:
# random_state.randint(MAX_INT, size=len(self.estimators_))
if self.single_seed_features:
# different features inside a single windows, then shift
seeds_features = np.tile(
random_state.randint(MAX_INT, size=self.n_estimators_window),
self.n_windows_)
seeds_max_features = np.tile(
random_state.randint(MAX_INT, size=self.n_estimators_window),
self.n_windows_)
else:
seeds_features = random_state.randint(MAX_INT,
size=n_more_estimators)
seeds_max_features = random_state.randint(MAX_INT,
size=n_more_estimators)
self._seeds_features = seeds_features
self._seeds_max_features = seeds_max_features
if self.verbose > 1:
print("Seeds features: %s" % seeds_features)
if self.single_seed_samples:
seeds = np.tile(random_state.randint(MAX_INT, size=1),
n_more_estimators)
else:
seeds = random_state.randint(MAX_INT, size=n_more_estimators)
self._seeds = seeds
if self.verbose > 1:
print("Seeds samples: %s" % seeds)
start_index = (iter(
sorted(self.n_estimators_window *
range(0, self.n_features_, self.stride))))
self.estimators_splits_ = []
all_results = jl.Parallel(n_jobs=n_jobs, verbose=self.verbose)(
jl.delayed(_parallel_build_estimators)
(n_estimators[i],
self,
X,
y,
sample_weight,
seeds_features[starts[i]:starts[i + 1]],
seeds[starts[i]:starts[i + 1]],
seeds_max_features[starts[i]:starts[i + 1]],
total_n_estimators,
start_index=list(itertools.islice(start_index, n_estimators[i])),
verbose=self.verbose,
circular_features=self.circular_features,
draw_max_features=self.draw_max_features) for i in range(n_jobs))
# Reduce
self.estimators_ += list(
itertools.chain.from_iterable(t[0] for t in all_results))
self.estimators_features_ += list(
itertools.chain.from_iterable(t[1] for t in all_results))
self._estimators_samples += list(
itertools.chain.from_iterable(t[2] for t in all_results))
self.estimators_splits_ += list(
itertools.chain.from_iterable(t[3] for t in all_results))
if self.oob_score:
self._set_oob_score(X, y)
# sliding window
# for start in range(0, n_features - self.window_size + 1 + (
# n_features - self.window_size) % self.stride, self.stride):
# samples, features = [], []
# y_binary_splits = []
# for p in range(self.n_estimators):
# random_state = check_random_state(self.random_state)
#
# # prepare the features
# # 1. choose randomly the max features belonging to [0, k-1]
# # 1a. how many?
# n_features_window = np.random.randint(1, min(
# self.max_features, n_features - start - 1))
# # 1b. which ones?
# features.append(np.random.randint(
# start,
# min(start + self.window_size, n_features),
# n_features_window))
#
# # 2. split y and binarise it
# y_binary_splits.append(random_binarizer(y))
#
# estimators_ = jl.Parallel(n_jobs=self.n_jobs)(
# jl.delayed(_fit_binary)(
# self.base_estimator, X[mask][:, feats], y_binary[mask])
# for mask, feats, y_binary in zip(samples, features, y_binary_splits))
#
# self.estimators_.extend(estimators_)
# self.estimator_features_.extend(features)
# self.estimator_splits_.extend(y_binary_splits)
return self
def fit(self, X, y):
"""Build a Bagging ensemble of estimators from the training
set (X, y).
Parameters
----------
X : {array-like, sparse matrix} of shape = [n_samples, n_features]
The training input samples. Sparse matrices are accepted only if
they are supported by the base estimator.
y : array-like, shape = [n_samples]
The target values (class labels in classification, real numbers in
regression).
Returns
-------
self : object
Returns self.
"""
random_state = check_random_state(self.random_state)
# Convert data
X, y = check_X_y(X, y, ['csr', 'csc'])
# Remap output
n_samples, self.n_features_ = X.shape
y = self._validate_y(y)
# Check parameters
self._validate_estimator()
if isinstance(self.max_samples, (numbers.Integral, np.integer)):
max_samples = self.max_samples
else: # float
max_samples = int(self.max_samples * X.shape[0])
if not (0 < max_samples <= X.shape[0]):
raise ValueError("max_samples must be in (0, n_samples]")
if isinstance(self.max_features, (numbers.Integral, np.integer)):
max_features = self.max_features
else: # float
max_features = int(self.max_features * self.n_features_)
if not (0 < max_features <= self.n_features_):
raise ValueError("max_features must be in (0, n_features]")
if not self.bootstrap and self.oob_score:
raise ValueError("Out of bag estimation only available"
" if bootstrap=True")
if self.warm_start and self.oob_score:
raise ValueError("Out of bag estimate only available"
" if warm_start=False")
if hasattr(self, "oob_score_") and self.warm_start:
del self.oob_score_
if not self.warm_start or len(self.estimators_) == 0:
# Free allocated memory, if any
self.estimators_ = []
self.estimators_samples_ = []
self.estimators_features_ = []
n_more_estimators = self.n_estimators - len(self.estimators_)
if n_more_estimators < 0:
raise ValueError('n_estimators=%d must be larger or equal to '
'len(estimators_)=%d when warm_start==True' %
(self.n_estimators, len(self.estimators_)))
elif n_more_estimators == 0:
warn("Warm-start fitting without increasing n_estimators does not "
"fit new trees.")
return self
# Parallel loop
n_jobs, n_estimators, starts = _partition_estimators(
n_more_estimators, self.n_jobs)
# Advance random state to state after training
# the first n_estimators
if self.warm_start and len(self.estimators_) > 0:
random_state.randint(MAX_INT, size=len(self.estimators_))
seeds = random_state.randint(MAX_INT, size=n_more_estimators)
all_results = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
# TEF: changed following call to balanced procedure:
delayed(_parallel_build_balanced_estimators)(
n_estimators[i],
self,
X,
y,
seeds[starts[i]:starts[i + 1]],
verbose=self.verbose) for i in range(n_jobs))
# Reduce
self.estimators_ += list(
itertools.chain.from_iterable(t[0] for t in all_results))
self.estimators_samples_ += list(
itertools.chain.from_iterable(t[1] for t in all_results))
self.estimators_features_ += list(
itertools.chain.from_iterable(t[2] for t in all_results))
if self.oob_score:
self._set_oob_score(X, y)
return self
def fit(self, X, y, sample_weight=None):
"""Build a Bagging ensemble of estimators from the training
set (X, y).
Parameters
----------
X : {array-like, sparse matrix} of shape = [n_samples, n_features]
The training input samples. Sparse matrices are accepted only if
they are supported by the base estimator.
y : array-like, shape = [n_samples]
The target values (class labels in classification, real numbers in
regression).
sample_weight : array-like, shape = [n_samples] or None
Sample weights. If None, then samples are equally weighted.
Note that this is supported only if the base estimator supports
sample weighting.
Returns
-------
self : object
Returns self.
"""
random_state = check_random_state(self.random_state)
# Convert data
X, y = check_X_y(X, y, ['csr', 'csc', 'coo'])
# Remap output
n_samples, self.n_features_ = X.shape
y = self._validate_y(y)
# Check parameters
self._validate_estimator()
if isinstance(self.max_samples, (numbers.Integral, np.integer)):
max_samples = self.max_samples
else: # float
max_samples = int(self.max_samples * X.shape[0])
if not (0 < max_samples <= X.shape[0]):
raise ValueError("max_samples must be in (0, n_samples]")
if isinstance(self.max_features, (numbers.Integral, np.integer)):
max_features = self.max_features
else: # float
max_features = int(self.max_features * self.n_features_)
if not (0 < max_features <= self.n_features_):
raise ValueError("max_features must be in (0, n_features]")
if not self.bootstrap and self.oob_score:
raise ValueError("Out of bag estimation only available"
" if bootstrap=True")
# Free allocated memory, if any
self.estimators_ = None
# Parallel loop
n_jobs, n_estimators, starts = _partition_estimators(self.n_estimators,
self.n_jobs)
seeds = random_state.randint(MAX_INT, size=self.n_estimators)
all_results = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
delayed(_parallel_build_estimators)(
n_estimators[i],
self,
X,
y,
sample_weight,
seeds[starts[i]:starts[i + 1]],
verbose=self.verbose)
for i in range(n_jobs))
# Reduce
self.estimators_ = list(itertools.chain.from_iterable(
t[0] for t in all_results))
self.estimators_samples_ = list(itertools.chain.from_iterable(
t[1] for t in all_results))
self.estimators_features_ = list(itertools.chain.from_iterable(
t[2] for t in all_results))
if self.oob_score:
self._set_oob_score(X, y)
return self