def __init__(self,
n_estimators=10,
criterion="gini",
max_depth=None,
min_samples_split=2,
min_samples_leaf=1,
min_weight_fraction_leaf=0.,
max_features="auto",
max_leaf_nodes=None,
min_impurity_decrease=0.,
min_impurity_split=None,
bootstrap=True,
oob_score=False,
n_jobs=1,
random_state=None,
verbose=0,
warm_start=False,
class_weight=None):
n_estimators = int(n_estimators)
_skRandomForestClassifier.__init__(
self, n_estimators, criterion, max_depth, min_samples_split,
min_samples_leaf, min_weight_fraction_leaf, max_features,
max_leaf_nodes, min_impurity_decrease, min_impurity_split,
bootstrap, oob_score, n_jobs, random_state, verbose, warm_start,
class_weight)
BaseWrapperClf.__init__(self)
def __init__(self,
eta=0.5,
epochs=50,
hidden_layers=None,
n_classes=None,
momentum=0.0,
l1=0.0,
l2=0.0,
dropout=1.0,
decrease_const=0.0,
minibatches=1,
random_seed=None,
print_progress=0):
epochs = int(epochs)
warnings.filterwarnings(module='mlxtend*',
action='ignore',
category=FutureWarning)
warnings.filterwarnings(module='mlxtend*',
action='ignore',
category=RuntimeWarning)
if hidden_layers is None:
hidden_layers = [50]
_MultiLayerPerceptron.__init__(self, eta, epochs, hidden_layers,
n_classes, momentum, l1, l2, dropout,
decrease_const, minibatches,
random_seed, print_progress)
BaseWrapperClf.__init__(self)
def __init__(self,
loss="hinge",
penalty='l2',
alpha=0.0001,
l1_ratio=0.15,
fit_intercept=True,
max_iter=1000,
tol=None,
shuffle=True,
verbose=0,
epsilon=DEFAULT_EPSILON,
n_jobs=1,
random_state=None,
learning_rate="optimal",
eta0=0.0,
power_t=0.5,
class_weight=None,
warm_start=False,
average=False,
n_iter=None):
_skSGDClassifier.__init__(self, loss, penalty, alpha, l1_ratio,
fit_intercept, max_iter, tol, shuffle,
verbose, epsilon, n_jobs, random_state,
learning_rate, eta0, power_t, class_weight,
warm_start, average, n_iter)
BaseWrapperClf.__init__(self)
def __init__(self,
alpha=1.0,
binarize=.0,
fit_prior=True,
class_prior=None):
_skBernoulliNB.__init__(self, alpha, binarize, fit_prior, class_prior)
BaseWrapperClf.__init__(self)
def __init__(self, C=1.0, kernel='rbf', degree=3, gamma='auto', coef0=0.0, shrinking=True, probability=True,
tol=1e-3, cache_size=200, class_weight=None, verbose=False, max_iter=-1, decision_function_shape='ovr',
random_state=None):
_SVC.__init__(
self, C, kernel, degree, gamma, coef0, shrinking, probability, tol, cache_size, class_weight, verbose,
max_iter, decision_function_shape, random_state)
BaseWrapperClf.__init__(self)
def __init__(self, base_estimator=None, n_estimators=10, max_samples=1.0, max_features=1.0, bootstrap=True,
bootstrap_features=False, oob_score=False, warm_start=False, n_jobs=1, random_state=None, verbose=0):
n_estimators = int(n_estimators)
_BaggingClassifier.__init__(
self, base_estimator, n_estimators, max_samples, max_features, bootstrap, bootstrap_features, oob_score,
warm_start, n_jobs, random_state, verbose)
BaseWrapperClf.__init__(self)
def __init__(self,
max_depth=3,
learning_rate=0.1,
n_estimators=100,
silent=True,
objective="binary:logistic",
booster='gbtree',
n_jobs=1,
nthread=None,
gamma=0,
min_child_weight=1,
max_delta_step=0,
subsample=1,
colsample_bytree=1,
colsample_bylevel=1,
reg_alpha=0,
reg_lambda=1,
scale_pos_weight=1,
base_score=0.5,
random_state=0,
seed=None,
missing=None,
**kwargs):
xgb.XGBClassifier.__init__(self, max_depth, learning_rate,
n_estimators, silent, objective, booster,
n_jobs, nthread, gamma, min_child_weight,
max_delta_step, subsample, colsample_bytree,
colsample_bylevel, reg_alpha, reg_lambda,
scale_pos_weight, base_score, random_state,
seed, missing, **kwargs)
BaseWrapperClf.__init__(self)
warnings.filterwarnings(module='sklearn*',
action='ignore',
category=DeprecationWarning)
def __init__(self,
estimators,
voting='hard',
weights=None,
n_jobs=1,
flatten_transform=None):
_skVotingClassifier.__init__(self, estimators, voting, weights, n_jobs,
flatten_transform)
BaseWrapperClf.__init__(self)
def __init__(self, eta=0.1, epochs=50, random_seed=None, print_progress=0):
epochs = int(epochs)
warnings.filterwarnings(module='mlxtend*',
action='ignore',
category=FutureWarning)
_Perceptron.__init__(self, eta, epochs, random_seed, print_progress)
BaseWrapperClf.__init__(self)
def __init__(self, **kwargs):
# logging_level = 'Silent'
# silent = True
# kwargs['silent'] = True
warnings.filterwarnings(module='sklearn*',
action='ignore',
category=DeprecationWarning)
BaseWrapperClf.__init__(self)
_CatBoostClassifier.__init__(self, **kwargs)
def __init__(self, loss='deviance', learning_rate=0.1, n_estimators=100, subsample=1.0, criterion='friedman_mse',
min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0., max_depth=3,
min_impurity_decrease=0., min_impurity_split=None, init=None, random_state=None, max_features=None,
verbose=0, max_leaf_nodes=None, warm_start=False, presort='auto'):
n_estimators = int(n_estimators)
_skGradientBoostingClassifier.__init__(
self, loss, learning_rate, n_estimators, subsample, criterion, min_samples_split, min_samples_leaf,
min_weight_fraction_leaf, max_depth, min_impurity_decrease, min_impurity_split, init, random_state,
max_features, verbose, max_leaf_nodes, warm_start, presort)
BaseWrapperClf.__init__(self)
def __init__(self,
alphas=(0.1, 1.0, 10.0),
fit_intercept=True,
normalize=False,
scoring=None,
cv=None,
class_weight=None):
_RidgeClassifierCV.__init__(self, alphas, fit_intercept, normalize,
scoring, cv, class_weight)
BaseWrapperClf.__init__(self)
def __init__(self, hidden_layer_sizes=(100,), activation="relu", solver='adam', alpha=0.0001, batch_size='auto',
learning_rate="constant", learning_rate_init=0.001, power_t=0.5, max_iter=200, shuffle=True,
random_state=None, tol=1e-4, verbose=False, warm_start=False, momentum=0.9, nesterovs_momentum=True,
early_stopping=False, validation_fraction=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-8):
warnings.filterwarnings(module='sklearn*', action='ignore', category=ConvergenceWarning)
BaseWrapperClf.__init__(self)
_skMLPClassifier.__init__(
self, hidden_layer_sizes, activation, solver, alpha, batch_size, learning_rate, learning_rate_init, power_t,
max_iter, shuffle, random_state, tol, verbose, warm_start, momentum, nesterovs_momentum, early_stopping,
validation_fraction, beta_1, beta_2, epsilon)
def __init__(self,
alpha=1.0,
fit_intercept=True,
normalize=False,
copy_X=True,
max_iter=None,
tol=1e-3,
class_weight=None,
solver="auto",
random_state=None):
_RidgeClassifier.__init__(self, alpha, fit_intercept, normalize,
copy_X, max_iter, tol, class_weight, solver,
random_state)
BaseWrapperClf.__init__(self)
def __init__(self,
eta=0.01,
epochs=50,
l2=0.0,
minibatches=1,
n_classes=None,
random_seed=None,
print_progress=0):
warnings.filterwarnings(module='mlxtend*',
action='ignore',
category=FutureWarning)
epochs = int(epochs)
_SoftmaxRegression.__init__(self, eta, epochs, l2, minibatches,
n_classes, random_seed, print_progress)
BaseWrapperClf.__init__(self)
def __init__(self,
eta=0.01,
epochs=50,
l2_lambda=0.0,
minibatches=1,
random_seed=None,
print_progress=0):
epochs = int(epochs)
warnings.filterwarnings(module='mlxtend*',
action='ignore',
category=FutureWarning)
_LogisticRegression.__init__(self, eta, epochs, l2_lambda, minibatches,
random_seed, print_progress)
BaseWrapperClf.__init__(self)
def __init__(self,
n_neighbors=5,
weights='uniform',
algorithm='auto',
leaf_size=30,
p=2,
metric='minkowski',
metric_params=None,
n_jobs=1,
**kwargs):
leaf_size = int(leaf_size)
n_neighbors = int(n_neighbors)
_KNeighborsClassifier.__init__(self, n_neighbors, weights, algorithm,
leaf_size, p, metric, metric_params,
n_jobs, **kwargs)
BaseWrapperClf.__init__(self)
def __init__(self,
kernel=None,
optimizer="fmin_l_bfgs_b",
n_restarts_optimizer=0,
max_iter_predict=100,
warm_start=False,
copy_X_train=True,
random_state=None,
multi_class="one_vs_rest",
n_jobs=1):
n_jobs = 4
_skGaussianProcessClassifier.__init__(self, kernel, optimizer,
n_restarts_optimizer,
max_iter_predict, warm_start,
copy_X_train, random_state,
multi_class, n_jobs)
BaseWrapperClf.__init__(self, )
def __init__(self,
penalty='l2',
loss='squared_hinge',
dual=True,
tol=1e-4,
C=1.0,
multi_class='ovr',
fit_intercept=True,
intercept_scaling=1,
class_weight=None,
verbose=0,
random_state=None,
max_iter=1000):
_skLinearSVC.__init__(self, penalty, loss, dual, tol, C, multi_class,
fit_intercept, intercept_scaling, class_weight,
verbose, random_state, max_iter)
BaseWrapperClf.__init__(self)
def __init__(self,
classifiers,
meta_classifier=None,
use_probas=False,
average_probas=False,
verbose=0,
use_features_in_secondary=False,
store_train_meta_features=False,
use_clones=True):
warnings.filterwarnings(module='mlxtend*',
action='ignore',
category=FutureWarning)
if meta_classifier is None:
meta_classifier = skBernoulli_NBClf()
BaseWrapperClf.__init__(self)
_StackingClassifier.__init__(self, classifiers, meta_classifier,
use_probas, average_probas, verbose,
use_features_in_secondary,
store_train_meta_features, use_clones)
def __init__(self,
boosting_type="gbdt",
num_leaves=31,
max_depth=-1,
learning_rate=0.1,
n_estimators=100,
subsample_for_bin=200000,
objective=None,
class_weight=None,
min_split_gain=0.,
min_child_weight=1e-3,
min_child_samples=20,
subsample=1.,
subsample_freq=1,
colsample_bytree=1.,
reg_alpha=0.,
reg_lambda=0.,
random_state=None,
n_jobs=-1,
silent=True,
**kwargs):
kwargs['verbose'] = -1
num_leaves = int(num_leaves)
min_child_samples = int(min_child_samples)
n_estimators = int(n_estimators)
warnings.filterwarnings(module='sklearn*',
action='ignore',
category=DeprecationWarning)
lightgbm.LGBMClassifier.__init__(
self, boosting_type, num_leaves, max_depth, learning_rate,
n_estimators, subsample_for_bin, objective, class_weight,
min_split_gain, min_child_weight, min_child_samples, subsample,
subsample_freq, colsample_bytree, reg_alpha, reg_lambda,
random_state, n_jobs, silent, **kwargs)
BaseWrapperClf.__init__(self)
def __init__(self, metric='euclidean', shrink_threshold=None):
_NearestCentroid.__init__(self, metric, shrink_threshold)
BaseWrapperClf.__init__(self)
def __init__(self, priors=None, reg_param=0., store_covariance=False, tol=1.0e-4, store_covariances=None):
warnings.filterwarnings(module='sklearn*', action='ignore', category=Warning)
BaseWrapperClf.__init__(self)
_skQDA.__init__(self, priors, reg_param, store_covariance, tol, store_covariances)
def __init__(self, alpha=1.0, fit_prior=True, class_prior=None):
_skMultinomialNB.__init__(self, alpha, fit_prior, class_prior)
BaseWrapperClf.__init__(self)
def __init__(self, base_estimator=None, n_estimators=50, learning_rate=1., algorithm='SAMME.R', random_state=None):
n_estimators = int(n_estimators)
_skAdaBoostClassifier.__init__(self, base_estimator, n_estimators, learning_rate, algorithm, random_state)
BaseWrapperClf.__init__(self)
def __init__(self, radius=1.0, weights='uniform', algorithm='auto', leaf_size=30, p=2, metric='minkowski',
outlier_label=None, metric_params=None, **kwargs):
_RadiusNeighborsClassifier.__init__(
self, radius, weights, algorithm, leaf_size, p, metric, outlier_label, metric_params, **kwargs)
BaseWrapperClf.__init__(self)
def __init__(self, priors=None):
_skGaussianNB.__init__(self, priors)
BaseWrapperClf.__init__(self)