def _fit(self, X, Y=None):
import sklearn.ensemble
self.n_estimators = int(self.n_estimators)
if check_none(self.max_depth):
self.max_depth = None
else:
self.max_depth = int(self.max_depth)
self.min_samples_split = int(self.min_samples_split)
self.min_samples_leaf = int(self.min_samples_leaf)
if check_none(self.max_leaf_nodes):
self.max_leaf_nodes = None
else:
self.max_leaf_nodes = int(self.max_leaf_nodes)
self.min_weight_fraction_leaf = float(self.min_weight_fraction_leaf)
self.bootstrap = check_for_bool(self.bootstrap)
self.preprocessor = sklearn.ensemble.RandomTreesEmbedding(
n_estimators=self.n_estimators,
max_depth=self.max_depth,
min_samples_split=self.min_samples_split,
min_samples_leaf=self.min_samples_leaf,
max_leaf_nodes=self.max_leaf_nodes,
sparse_output=self.sparse_output,
n_jobs=self.n_jobs,
random_state=self.random_state
)
self.preprocessor.fit(X, Y)
return self
def fit(self, X, y, sample_weight=None):
from sklearn.tree import DecisionTreeClassifier
self.max_features = float(self.max_features)
# Heuristic to set the tree depth
if check_none(self.max_depth_factor):
max_depth_factor = self.max_depth_factor = None
else:
num_features = X.shape[1]
self.max_depth_factor = int(self.max_depth_factor)
max_depth_factor = max(
1,
int(np.round(self.max_depth_factor * num_features, 0)))
self.min_samples_split = int(self.min_samples_split)
self.min_samples_leaf = int(self.min_samples_leaf)
if check_none(self.max_leaf_nodes):
self.max_leaf_nodes = None
else:
self.max_leaf_nodes = int(self.max_leaf_nodes)
self.min_weight_fraction_leaf = float(self.min_weight_fraction_leaf)
self.min_impurity_decrease = float(self.min_impurity_decrease)
self.estimator = DecisionTreeClassifier(
criterion=self.criterion,
max_depth=max_depth_factor,
min_samples_split=self.min_samples_split,
min_samples_leaf=self.min_samples_leaf,
max_leaf_nodes=self.max_leaf_nodes,
min_weight_fraction_leaf=self.min_weight_fraction_leaf,
min_impurity_decrease=self.min_impurity_decrease,
class_weight=self.class_weight,
random_state=self.random_state)
self.estimator.fit(X, y, sample_weight=sample_weight)
return self
def iterative_fit(self, X, y, sample_weight=None, n_iter=1, refit=False):
# Special fix for gradient boosting!
if isinstance(X, np.ndarray):
X = np.ascontiguousarray(X, dtype=X.dtype)
if refit:
self.estimator = None
if self.estimator is None:
self.learning_rate = float(self.learning_rate)
self.n_estimators = int(self.n_estimators)
self.subsample = float(self.subsample)
self.min_samples_split = int(self.min_samples_split)
self.min_samples_leaf = int(self.min_samples_leaf)
self.min_weight_fraction_leaf = float(
self.min_weight_fraction_leaf)
if check_none(self.max_depth):
self.max_depth = None
else:
self.max_depth = int(self.max_depth)
self.max_features = float(self.max_features)
if check_none(self.max_leaf_nodes):
self.max_leaf_nodes = None
else:
self.max_leaf_nodes = int(self.max_leaf_nodes)
self.min_impurity_decrease = float(self.min_impurity_decrease)
self.verbose = int(self.verbose)
self.estimator = sklearn.ensemble.GradientBoostingClassifier(
loss=self.loss,
learning_rate=self.learning_rate,
n_estimators=n_iter,
subsample=self.subsample,
min_samples_split=self.min_samples_split,
min_samples_leaf=self.min_samples_leaf,
min_weight_fraction_leaf=self.min_weight_fraction_leaf,
max_depth=self.max_depth,
criterion=self.criterion,
max_features=self.max_features,
max_leaf_nodes=self.max_leaf_nodes,
random_state=self.random_state,
verbose=self.verbose,
warm_start=True,
)
else:
self.estimator.n_estimators += n_iter
self.estimator.n_estimators = min(self.estimator.n_estimators,
self.n_estimators)
self.estimator.fit(X, y, sample_weight=sample_weight)
# Apparently this if is necessary
if self.estimator.n_estimators >= self.n_estimators:
self.fully_fit_ = True
return self
def iterative_fit(self, X, y, sample_weight=None, n_iter=1, refit=False):
from sklearn.ensemble import RandomForestClassifier
if refit:
self.estimator = None
if self.estimator is None:
self.n_estimators = int(self.n_estimators)
if check_none(self.max_depth):
self.max_depth = None
else:
self.max_depth = int(self.max_depth)
self.min_samples_split = int(self.min_samples_split)
self.min_samples_leaf = int(self.min_samples_leaf)
self.min_weight_fraction_leaf = float(
self.min_weight_fraction_leaf)
if self.max_features not in ("sqrt", "log2", "auto"):
max_features = int(X.shape[1] ** float(self.max_features))
else:
max_features = self.max_features
self.bootstrap = check_for_bool(self.bootstrap)
if check_none(self.max_leaf_nodes):
self.max_leaf_nodes = None
else:
self.max_leaf_nodes = int(self.max_leaf_nodes)
self.min_impurity_decrease = float(self.min_impurity_decrease)
# initial fit of only increment trees
self.estimator = RandomForestClassifier(
n_estimators=n_iter,
criterion=self.criterion,
max_features=max_features,
max_depth=self.max_depth,
min_samples_split=self.min_samples_split,
min_samples_leaf=self.min_samples_leaf,
min_weight_fraction_leaf=self.min_weight_fraction_leaf,
bootstrap=self.bootstrap,
max_leaf_nodes=self.max_leaf_nodes,
min_impurity_decrease=self.min_impurity_decrease,
random_state=self.random_state,
n_jobs=self.n_jobs,
class_weight=self.class_weight,
warm_start=True)
else:
self.estimator.n_estimators += n_iter
self.estimator.n_estimators = min(self.estimator.n_estimators,
self.n_estimators)
self.estimator.fit(X, y, sample_weight=sample_weight)
return self
def _fit(self, X, Y=None):
import sklearn.decomposition
self.whiten = check_for_bool(self.whiten)
if check_none(self.n_components):
self.n_components = None
else:
self.n_components = int(self.n_components)
self.preprocessor = sklearn.decomposition.FastICA(
n_components=self.n_components,
algorithm=self.algorithm,
fun=self.fun,
whiten=self.whiten,
random_state=self.random_state)
# Make the RuntimeWarning an Exception!
with warnings.catch_warnings():
warnings.filterwarnings(
"error", message='array must not contain infs or NaNs')
try:
return self.preprocessor.fit_transform(X)
except ValueError as e:
if 'array must not contain infs or NaNs' in e.args[0]:
raise ValueError(
"Bug in scikit-learn: https://github.com/scikit-learn/scikit-learn/pull/2738"
)
return self
def fit(self, X, Y):
import sklearn.discriminant_analysis
import sklearn.multiclass
if check_none(self.shrinkage):
self.shrinkage_ = None
solver = 'svd'
elif self.shrinkage == "auto":
self.shrinkage_ = 'auto'
solver = 'lsqr'
elif self.shrinkage == "manual":
self.shrinkage_ = float(self.shrinkage_factor)
solver = 'lsqr'
else:
raise ValueError(self.shrinkage)
self.n_components = int(self.n_components)
self.tol = float(self.tol)
estimator = sklearn.discriminant_analysis.LinearDiscriminantAnalysis(
n_components=self.n_components, shrinkage=self.shrinkage_,
tol=self.tol, solver=solver)
if len(Y.shape) == 2 and Y.shape[1] > 1:
self.estimator = sklearn.multiclass.OneVsRestClassifier(
estimator, n_jobs=1)
else:
self.estimator = estimator
self.estimator.fit(X, Y)
return self
def fit(self, X, Y):
import sklearn.svm
from sklearn.feature_selection import SelectFromModel
self.C = float(self.C)
self.tol = float(self.tol)
self.dual = check_for_bool(self.dual)
self.fit_intercept = check_for_bool(self.fit_intercept)
self.intercept_scaling = float(self.intercept_scaling)
if check_none(self.class_weight):
self.class_weight = None
estimator = sklearn.svm.LinearSVC(
penalty=self.penalty,
loss=self.loss,
dual=self.dual,
tol=self.tol,
C=self.C,
class_weight=self.class_weight,
fit_intercept=self.fit_intercept,
intercept_scaling=self.intercept_scaling,
multi_class=self.multi_class,
random_state=self.random_state)
estimator.fit(X, Y)
self.preprocessor = SelectFromModel(estimator=estimator,
threshold='mean',
prefit=True)
return self
def fit(self, X, Y):
import sklearn.svm
import sklearn.multiclass
self.C = float(self.C)
self.tol = float(self.tol)
self.dual = check_for_bool(self.dual)
self.fit_intercept = check_for_bool(self.fit_intercept)
self.intercept_scaling = float(self.intercept_scaling)
if check_none(self.class_weight):
self.class_weight = None
estimator = sklearn.svm.LinearSVC(penalty=self.penalty,
loss=self.loss,
dual=self.dual,
tol=self.tol,
C=self.C,
class_weight=self.class_weight,
fit_intercept=self.fit_intercept,
intercept_scaling=self.intercept_scaling,
multi_class=self.multi_class,
random_state=self.random_state)
if len(Y.shape) == 2 and Y.shape[1] > 1:
self.estimator = sklearn.multiclass.OneVsRestClassifier(
estimator, n_jobs=1)
else:
self.estimator = estimator
self.estimator.fit(X, Y)
return self
def fit(self, X, Y, sample_weight=None):
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.feature_selection import SelectFromModel
self.n_estimators = int(self.n_estimators)
if check_none(self.max_leaf_nodes):
self.max_leaf_nodes = None
else:
self.max_leaf_nodes = int(self.max_leaf_nodes)
if check_none(self.max_depth):
self.max_depth = None
else:
self.max_depth = int(self.max_depth)
self.bootstrap = check_for_bool(self.bootstrap)
self.n_jobs = int(self.n_jobs)
self.min_impurity_decrease = float(self.min_impurity_decrease)
self.max_features = self.max_features
self.min_samples_leaf = int(self.min_samples_leaf)
self.min_samples_split = int(self.min_samples_split)
self.verbose = int(self.verbose)
max_features = int(X.shape[1]**float(self.max_features))
estimator = ExtraTreesClassifier(
n_estimators=self.n_estimators,
criterion=self.criterion,
max_depth=self.max_depth,
min_samples_split=self.min_samples_split,
min_samples_leaf=self.min_samples_leaf,
bootstrap=self.bootstrap,
max_features=max_features,
max_leaf_nodes=self.max_leaf_nodes,
min_impurity_decrease=self.min_impurity_decrease,
oob_score=self.oob_score,
n_jobs=self.n_jobs,
verbose=self.verbose,
random_state=self.random_state,
class_weight=self.class_weight)
estimator.fit(X, Y, sample_weight=sample_weight)
self.preprocessor = SelectFromModel(estimator=estimator,
threshold='mean',
prefit=True)
return self
def __init__(self,
n_estimators,
criterion,
min_samples_leaf,
min_samples_split,
max_features,
bootstrap,
max_leaf_nodes,
max_depth,
min_weight_fraction_leaf,
min_impurity_decrease,
oob_score=False,
n_jobs=1,
random_state=None,
verbose=0,
class_weight=None):
self.n_estimators = int(n_estimators)
self.estimator_increment = 10
if criterion not in ("gini", "entropy"):
raise ValueError("'criterion' is not in ('gini', 'entropy'): "
"%s" % criterion)
self.criterion = criterion
if check_none(max_depth):
self.max_depth = None
else:
self.max_depth = int(max_depth)
if check_none(max_leaf_nodes):
self.max_leaf_nodes = None
else:
self.max_leaf_nodes = int(max_leaf_nodes)
self.min_samples_leaf = int(min_samples_leaf)
self.min_samples_split = int(min_samples_split)
self.max_features = float(max_features)
self.bootstrap = check_for_bool(bootstrap)
self.min_weight_fraction_leaf = float(min_weight_fraction_leaf)
self.min_impurity_decrease = float(min_impurity_decrease)
self.oob_score = oob_score
self.n_jobs = int(n_jobs)
self.random_state = random_state
self.verbose = int(verbose)
self.class_weight = class_weight
self.estimator = None
def fit(self, X, Y):
import sklearn.svm
# Calculate the size of the kernel cache (in MB) for sklearn's LibSVM. The cache size is
# calculated as 2/3 of the available memory (which is calculated as the memory limit minus
# the used memory)
try:
# Retrieve memory limits imposed on the process
soft, hard = resource.getrlimit(resource.RLIMIT_AS)
if soft > 0:
# Convert limit to units of megabytes
soft /= 1024 * 1024
# Retrieve memory used by this process
maxrss = resource.getrusage(resource.RUSAGE_SELF)[2] / 1024
# In MacOS, the MaxRSS output of resource.getrusage in bytes; on other platforms,
# it's in kilobytes
if sys.platform == 'darwin':
maxrss = maxrss / 1024
cache_size = (soft - maxrss) / 1.5
if cache_size < 0:
cache_size = 200
else:
cache_size = 200
except Exception:
cache_size = 200
self.C = float(self.C)
if self.degree is None:
self.degree = 3
else:
self.degree = int(self.degree)
if self.gamma is None:
self.gamma = 0.0
else:
self.gamma = float(self.gamma)
if self.coef0 is None:
self.coef0 = 0.0
else:
self.coef0 = float(self.coef0)
self.tol = float(self.tol)
self.max_iter = float(self.max_iter)
self.shrinking = check_for_bool(self.shrinking)
if check_none(self.class_weight):
self.class_weight = None
self.estimator = sklearn.svm.SVC(C=self.C,
kernel=self.kernel,
degree=self.degree,
gamma=self.gamma,
coef0=self.coef0,
shrinking=self.shrinking,
tol=self.tol,
class_weight=self.class_weight,
max_iter=self.max_iter,
random_state=self.random_state,
cache_size=cache_size,
decision_function_shape='ovr')
self.estimator.fit(X, Y)
return self