def test_ZeroCount():
"""Assert that ZeroCount operator returns correct transformed X."""
op = ZeroCount()
X_transformed = op.transform(X)
zero_col = np.array([3, 2, 1, 4])
non_zero = np.array([2, 3, 4, 1])
assert np.allclose(zero_col, X_transformed[:, 0])
assert np.allclose(non_zero, X_transformed[:, 1])
def test_ZeroCount():
"""Assert that ZeroCount operator returns correct transformed X."""
op = ZeroCount()
X_transformed = op.transform(X)
zero_col = np.array([3, 2, 1, 4])
non_zero = np.array([2, 3, 4, 1])
assert np.allclose(zero_col, X_transformed[:, 0])
assert np.allclose(non_zero, X_transformed[:, 1])
def get_model_v4():
exported_pipeline = make_pipeline(
StackingEstimator(estimator=XGBClassifier(learning_rate=0.001, max_depth=2, min_child_weight=17, n_estimators=100, nthread=1, subsample=0.8)),
ZeroCount(),
VarianceThreshold(threshold=0.2),
RFE(estimator=ExtraTreesClassifier(criterion="entropy", max_features=0.15000000000000002, n_estimators=100), step=0.2),
GradientBoostingClassifier(learning_rate=0.5, max_depth=7, max_features=0.15000000000000002, min_samples_leaf=2, min_samples_split=3, n_estimators=100, subsample=1.0)
)
# Fix random state for all the steps in exported pipeline
set_param_recursive(exported_pipeline.steps, 'random_state', 37)
return exported_pipeline
def pipeline_suggested_by_tpot(self):
# Copied from optimal pipeline suggested by tpot in file "optimal_pipeline.py"
# Initialize
exported_pipeline = make_pipeline(
PolynomialFeatures(degree=2, include_bias=False, interaction_only=False),
VarianceThreshold(threshold=0.2),
ZeroCount(),
GradientBoostingClassifier(learning_rate=1.0, max_depth=10, max_features=0.9000000000000001, min_samples_leaf=16, min_samples_split=3, n_estimators=100, subsample=0.7000000000000001)
)
# Init training
exported_pipeline.fit(self.x_train, self.y_train)
print(f"Train acc: {exported_pipeline.score(self.x_train, self.y_train)}")
print(f"Test acc: {exported_pipeline.score(self.x_test, self.y_test)}")
def clf(in_put, out_put):
from sklearn.decomposition import PCA
from sklearn.linear_model import LassoLarsCV
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.svm import LinearSVR
from tpot.builtins import StackingEstimator, ZeroCount
exported_pipeline = make_pipeline(
PolynomialFeatures(degree=2, include_bias=False, interaction_only=False),
StackingEstimator(estimator=LinearSVR(C=15.0, dual=True, epsilon=1.0, loss="epsilon_insensitive", tol=1e-05)),
PCA(iterated_power=7, svd_solver="randomized"),
ZeroCount(),
LassoLarsCV(normalize=True)
)
exported_pipeline.fit(in_put, out_put)
results = exported_pipeline.predict(in_put)
return results
def __init__(self):
#On lit le fichier CSV grace a pd qui contient les memes données que dans la base de donnée
tpot_data = pd.read_csv('cryptodata.csv', sep=',')
#On s'interesse que au prix moyen du DASH, de son volume google trend et son sentiment twitter pour notre Variable X
X = tpot_data[tpot_data["symbol"] == "DASH"][[
"price_ave", "volume", "google_trend", "twitter_sent"
]].values
#Pour la variable Y on s'interesse seulement a la variable prix
y = tpot_data[tpot_data["symbol"] == "DASH"][["price"]].values
training_features, testing_features, training_target, testing_target = \
train_test_split(X, y, random_state=42)
self.__std = stdev([item[0] for item in y])
# Le score sur l'ensemble de formation était:-6.2249531865813035
self.exported_pipeline = make_pipeline(
VarianceThreshold(threshold=0.05), ZeroCount(),
PCA(iterated_power=1, svd_solver="randomized"),
StackingEstimator(estimator=ElasticNetCV(
l1_ratio=0.8500000000000001, tol=0.001)),
StackingEstimator(
estimator=LinearSVR(C=20.0,
dual=False,
epsilon=0.01,
loss="squared_epsilon_insensitive",
tol=0.01)),
ExtraTreesRegressor(bootstrap=False,
max_features=0.8,
min_samples_leaf=1,
min_samples_split=2,
n_estimators=100))
self.exported_pipeline.fit(training_features, training_target.ravel())
self.y_predict = self.exported_pipeline.predict(testing_features)
self.y_real = testing_target.ravel()
self.score = self.exported_pipeline.score(testing_features,
testing_target)
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures
from tpot.builtins import ZeroCount
from tpot.export_utils import set_param_recursive
# NOTE: Make sure that the outcome column is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1)
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'], random_state=1)
# Average CV score on the training set was: 0.9347254053136407
exported_pipeline = make_pipeline(
PolynomialFeatures(degree=2, include_bias=False, interaction_only=False),
VarianceThreshold(threshold=0.2), ZeroCount(),
GradientBoostingClassifier(learning_rate=1.0,
max_depth=10,
max_features=0.9000000000000001,
min_samples_leaf=16,
min_samples_split=3,
n_estimators=100,
subsample=0.7000000000000001))
# Fix random state for all the steps in exported pipeline
set_param_recursive(exported_pipeline.steps, 'random_state', 1)
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
import numpy as np
import pandas as pd
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from tpot.builtins import DatasetSelector, ZeroCount
# NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'].values, random_state=39)
# Average CV score on the training set was:0.6838260869565218
exported_pipeline = make_pipeline(
DatasetSelector(sel_subset=4, subset_list="module23.csv"), ZeroCount(),
ExtraTreesClassifier(bootstrap=True,
criterion="entropy",
max_features=0.6500000000000001,
min_samples_leaf=14,
min_samples_split=18,
n_estimators=100))
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import BernoulliNB, GaussianNB
from sklearn.pipeline import make_pipeline, make_union
from tpot.builtins import StackingEstimator, ZeroCount
# NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'].values, random_state=42)
# Score on the training set was:0.8686359265648864
exported_pipeline = make_pipeline(
StackingEstimator(estimator=BernoulliNB(alpha=0.1, fit_prior=True)),
StackingEstimator(estimator=GaussianNB()), ZeroCount(),
RandomForestClassifier(bootstrap=True,
criterion="gini",
max_features=0.4,
min_samples_leaf=12,
min_samples_split=3,
n_estimators=100))
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
from sklearn.gaussian_process.kernels import Matern
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline, make_union
from sklearn.preprocessing import RobustScaler
from tpot.builtins import StackingEstimator, ZeroCount
from tpot.export_utils import set_param_recursive
from sklearn.preprocessing import FunctionTransformer
from copy import copy
# NOTE: Make sure that the outcome column is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1)
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'], random_state=123)
# Average CV score on the training set was: 0.9837855826340283
exported_pipeline = make_pipeline(
make_union(FunctionTransformer(copy), FunctionTransformer(copy)),
RobustScaler(), ZeroCount(),
GaussianProcessRegressor(kernel=Matern(length_scale=4.3999999999999995,
nu=2.5),
n_restarts_optimizer=60,
normalize_y=False))
# Fix random state for all the steps in exported pipeline
set_param_recursive(exported_pipeline.steps, 'random_state', 123)
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
from copy import copy
# NOTE: Make sure that the outcome column is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1)
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'], random_state=None)
# Average CV score on the training set was: 0.8336787977583366
exported_pipeline = make_pipeline(
make_union(
make_pipeline(
make_union(
make_union(Normalizer(norm="l2"), MaxAbsScaler()),
StackingEstimator(
estimator=DecisionTreeClassifier(criterion="entropy",
max_depth=2,
min_samples_leaf=11,
min_samples_split=17))),
StackingEstimator(
estimator=MLPClassifier(alpha=0.01, learning_rate_init=0.001)),
SelectPercentile(score_func=f_classif, percentile=54)),
FunctionTransformer(copy)), ZeroCount(),
StackingEstimator(estimator=BernoulliNB(alpha=1.0, fit_prior=True)),
MultinomialNB(alpha=0.01, fit_prior=True))
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
from metstab_shap.data import load_data
# load data (and change to classification if needed)
data_cfg = parse_data_config('configs/data/rat.cfg')
repr_cfg = parse_representation_config('configs/repr/maccs.cfg')
task_cfg = parse_task_config('configs/task/regression.cfg')
x, y, _, test_x, test_y, smiles, test_smiles = load_data(
data_cfg, **repr_cfg[utils_section])
training_features = x
training_target = y
testing_features = test_x
# Average CV score on the training set was: -0.15289999993179348
exported_pipeline = make_pipeline(
ZeroCount(), MinMaxScaler(),
StackingEstimator(estimator=DecisionTreeRegressor(max_depth=5,
max_features=0.25,
min_samples_leaf=3,
min_samples_split=14,
splitter="best")),
StackingEstimator(
estimator=ExtraTreesRegressor(bootstrap=False,
max_depth=4,
max_features=0.7500000000000001,
max_samples=None,
min_samples_leaf=1,
min_samples_split=10,
n_estimators=1000)),
Binarizer(threshold=0.9),
ExtraTreesRegressor(bootstrap=False,
from sklearn.preprocessing import Normalizer
from tpot.builtins import StackingEstimator, ZeroCount
from xgboost import XGBClassifier
# NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'].values, random_state=42)
# Score on the training set was:0.8666666666666668
exported_pipeline = make_pipeline(
StackingEstimator(estimator=XGBClassifier(learning_rate=0.1,
max_depth=3,
min_child_weight=4,
n_estimators=100,
nthread=1,
subsample=0.1)),
Normalizer(norm="l1"), ZeroCount(),
RandomForestClassifier(bootstrap=False,
criterion="entropy",
max_features=0.1,
min_samples_leaf=11,
min_samples_split=20,
n_estimators=100))
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
import numpy as np
import pandas as pd
from sklearn.linear_model import LassoLarsCV
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from tpot.builtins import ZeroCount
# NOTE: Make sure that the class is labeled 'class' in the data file
tpot_data = np.recfromcsv('../../input/train.csv',
delimiter=',',
dtype=np.float64)
features = np.delete(tpot_data.view(np.float64).reshape(tpot_data.size, -1),
tpot_data.dtype.names.index('class'),
axis=1)
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['class'], random_state=42)
exported_pipeline = make_pipeline(ZeroCount(), LassoLarsCV(normalize=True))
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
max_depth=1,
min_child_weight=3,
n_estimators=100,
n_jobs=1,
objective="reg:squarederror",
subsample=0.9500000000000001,
verbosity=0)), MinMaxScaler(),
StackingEstimator(estimator=SGDRegressor(alpha=0.01,
eta0=0.01,
fit_intercept=False,
l1_ratio=0.0,
learning_rate="constant",
loss="huber",
penalty="elasticnet",
power_t=0.0)),
StackingEstimator(estimator=LinearSVR(
C=25.0, dual=True, epsilon=0.1, loss="epsilon_insensitive",
tol=0.0001)),
FeatureAgglomeration(affinity="manhattan", linkage="complete"),
SelectPercentile(score_func=f_regression, percentile=6),
StackingEstimator(estimator=ExtraTreesRegressor(bootstrap=False,
max_features=0.8,
min_samples_leaf=19,
min_samples_split=10,
n_estimators=400)),
ZeroCount(), FeatureAgglomeration(affinity="l1", linkage="complete"),
RidgeCV())
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
import pandas as pd
from sklearn.decomposition import FastICA
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline, make_union
from tpot.builtins import StackingEstimator, ZeroCount
from sklearn.preprocessing import FunctionTransformer
from copy import copy
# NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'].values, random_state=42)
# Score on the training set was:0.8453186610518303
exported_pipeline = make_pipeline(
make_union(make_pipeline(ZeroCount(), FastICA(tol=0.2)),
FunctionTransformer(copy)),
ExtraTreesClassifier(bootstrap=False,
criterion="entropy",
max_features=0.2,
min_samples_leaf=1,
min_samples_split=4,
n_estimators=100))
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
knr_params3 = {'n_neighbors' : 15}
knr_params4 = {'n_neighbors' : 25}
SEED = 0
level_1_models = [XgbWrapper(seed=SEED, params=xgb_params, cv_fold=4),
]
# level_1_models = level_1_models + [SklearnWrapper(clf=KNeighborsRegressor, params=knr_params1),
# SklearnWrapper(clf=KNeighborsRegressor, params=knr_params2),
# SklearnWrapper(clf=KNeighborsRegressor, params=knr_params3),
# SklearnWrapper(clf=KNeighborsRegressor, params=knr_params4)]
level_1_models = level_1_models + [SklearnWrapper(make_pipeline( ZeroCount(), LassoLarsCV(normalize=True))),#LB 0.55797
SklearnWrapper(make_pipeline(StackingEstimator(estimator=LassoLarsCV(normalize=True)),
StackingEstimator(estimator=GradientBoostingRegressor(learning_rate=0.001,
loss="huber", max_depth=3, max_features=0.55, min_samples_leaf=18,
min_samples_split=14, subsample=0.7)), LassoLarsCV()))
]
params_list = [rf_params1, rf_params2, et_params1, et_params2, gb_params1, #gb_params2,
rd_params, ls_params,
eln_params,
lcv_params,
llcv_params
]
func_list = [RandomForestRegressor, RandomForestRegressor, ExtraTreesRegressor, ExtraTreesRegressor,
def test_ZeroCount_fit():
"""Assert that fit() in ZeroCount does nothing."""
op = ZeroCount()
ret_op = op.fit(X)
assert ret_op==op
# tpot_data = pd.read_csv('PATH/TO/DATA/FILE', sep='COLUMN_SEPARATOR', dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'].values, random_state=None)
# Average CV score on the training set was:-747046.8597394783
exported_pipeline = make_pipeline(
StackingEstimator(estimator=ElasticNetCV(l1_ratio=1.0, tol=0.001)),
FastICA(tol=0.8),
PolynomialFeatures(degree=2, include_bias=False, interaction_only=False),
StackingEstimator(estimator=ExtraTreesRegressor(bootstrap=True,
max_features=0.5,
min_samples_leaf=14,
min_samples_split=11,
n_estimators=100)),
ZeroCount(), MaxAbsScaler(), LassoLarsCV(normalize=False))
# exported_pipeline = TransformedTargetRegressor(regressor=exported_pipeline, transformer=QuantileTransformer(output_distribution='normal'))
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
train_results = exported_pipeline.predict(training_features)
from pylab import *
# figure(1)
# clf()
# ion()
# plot(training_target, train_results, 'bo')
# plot(testing_target, results, 'ro')
# show()
competitions.plot_predict(exported_pipeline)
RobustScaler(), MinMaxScaler(),
StackingEstimator(estimator=LinearSVR(C=25.0,
dual=True,
epsilon=0.01,
loss="epsilon_insensitive",
tol=0.0001)),
StackingEstimator(estimator=DecisionTreeRegressor(
max_depth=8, min_samples_leaf=17, min_samples_split=9)),
FeatureAgglomeration(affinity="l2", linkage="average"),
RBFSampler(gamma=0.75),
StackingEstimator(estimator=LinearSVR(C=1.0,
dual=True,
epsilon=1.0,
loss="squared_epsilon_insensitive",
tol=0.1)),
StackingEstimator(
estimator=KNeighborsRegressor(n_neighbors=9, p=1, weights="uniform")),
StackingEstimator(estimator=LassoLarsCV(normalize=True)),
SelectPercentile(score_func=f_regression, percentile=26), StandardScaler(),
PCA(iterated_power=7, svd_solver="randomized"),
StackingEstimator(estimator=LinearSVR(C=10.0,
dual=True,
epsilon=0.01,
loss="squared_epsilon_insensitive",
tol=1e-05)), ZeroCount(),
SelectFwe(score_func=f_regression, alpha=0.039),
PCA(iterated_power=5, svd_solver="randomized"), RidgeCV())
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
import numpy as np
import pandas as pd
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from tpot.builtins import DatasetSelector, ZeroCount
# NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'].values, random_state=96)
# Average CV score on the training set was:0.7070745272525027
exported_pipeline = make_pipeline(
DatasetSelector(sel_subset=0, subset_list="subsets.csv"), ZeroCount(),
ExtraTreesClassifier(bootstrap=False,
criterion="gini",
max_features=0.8,
min_samples_leaf=1,
min_samples_split=8,
n_estimators=100))
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
def test_ZeroCount_fit():
"""Assert that fit() in ZeroCount does nothing."""
op = ZeroCount()
ret_op = op.fit(X)
assert ret_op == op
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1)
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'], random_state=None)
# Average CV score on the training set was: 0.6933333333333334
exported_pipeline = make_pipeline(
VarianceThreshold(threshold=0.0005),
StackingEstimator(estimator=XGBClassifier(learning_rate=0.1,
max_depth=1,
min_child_weight=17,
n_estimators=100,
nthread=1,
subsample=0.6000000000000001)),
StackingEstimator(estimator=DecisionTreeClassifier(criterion="gini",
max_depth=2,
min_samples_leaf=19,
min_samples_split=14)),
StackingEstimator(estimator=BernoulliNB(alpha=1.0, True)), ZeroCount(),
GradientBoostingClassifier(learning_rate=0.01,
max_depth=4,
max_features=0.8500000000000001,
min_samples_leaf=6,
min_samples_split=15,
n_estimators=100,
subsample=0.6500000000000001))
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline, make_union
from tpot.builtins import StackingEstimator, ZeroCount
from xgboost import XGBClassifier
from sklearn.preprocessing import FunctionTransformer
from copy import copy
# NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'].values, random_state=42)
# Score on the training set was:0.504247990815155
exported_pipeline = make_pipeline(
make_union(FunctionTransformer(copy), ZeroCount()),
XGBClassifier(learning_rate=0.001,
max_depth=3,
min_child_weight=3,
n_estimators=100,
nthread=1,
subsample=0.1))
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.feature_selection import SelectFwe, f_classif
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from tpot.builtins import ZeroCount
from tpot.export_utils import set_param_recursive
# NOTE: Make sure that the outcome column is labeled 'target' in the data file
tpot_data = pd.read_csv("data.csv")
features = tpot_data.drop('PSL_Won', axis=1)
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['PSL_Won'], random_state=42)
# Average CV score on the training set was: 0.8671594508975712
exported_pipeline = make_pipeline(
SelectFwe(score_func=f_classif, alpha=0.011), ZeroCount(),
ExtraTreesClassifier(bootstrap=False,
criterion="entropy",
max_features=1.0,
min_samples_leaf=7,
min_samples_split=20,
n_estimators=100))
# Fix random state for all the steps in exported pipeline
set_param_recursive(exported_pipeline.steps, 'random_state', 42)
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
## Plot
from mlxtend.plotting import plot_confusion_matrix
from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score, mean_squared_error
import pandas as pd
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures, RobustScaler, StandardScaler
from tpot.builtins import ZeroCount
# NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'].values, random_state=None)
# Average CV score on the training set was:0.8591858482523443
exported_pipeline = make_pipeline(
StandardScaler(), ZeroCount(),
PolynomialFeatures(degree=2, include_bias=False, interaction_only=False),
RobustScaler(),
GradientBoostingClassifier(learning_rate=1.0,
max_depth=6,
max_features=0.45,
min_samples_leaf=10,
min_samples_split=15,
n_estimators=100,
subsample=0.7000000000000001))
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline, make_union
from tpot.builtins import StackingEstimator, ZeroCount
from sklearn.preprocessing import FunctionTransformer
from copy import copy
# NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'].values, random_state=42)
# Average CV score on the training set was:0.8342718814237802
exported_pipeline = make_pipeline(
make_union(ZeroCount(), FunctionTransformer(copy)),
RFE(estimator=ExtraTreesClassifier(criterion="gini",
max_features=0.6000000000000001,
n_estimators=100),
step=0.7000000000000001),
ExtraTreesClassifier(bootstrap=False,
criterion="gini",
max_features=0.9000000000000001,
min_samples_leaf=4,
min_samples_split=15,
n_estimators=100))
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
from sklearn.preprocessing import FunctionTransformer
from copy import copy
# NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'].values, random_state=42)
# Average CV score on the training set was:0.84550605863897
exported_pipeline = make_pipeline(
make_union(
make_pipeline(
OneHotEncoder(minimum_fraction=0.25, sparse=False, threshold=10),
RFE(estimator=ExtraTreesClassifier(criterion="gini",
max_features=0.5,
n_estimators=100),
step=0.2), ZeroCount(), MinMaxScaler()),
FunctionTransformer(copy)), Normalizer(norm="max"),
XGBClassifier(learning_rate=0.01,
max_depth=6,
min_child_weight=7,
n_estimators=600,
nthread=1,
subsample=0.9500000000000001))
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
import numpy as np
import pandas as pd
from sklearn.feature_selection import SelectPercentile, f_classif
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from tpot.builtins import ZeroCount
# NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'].values, random_state=None)
# Average CV score on the training set was:0.7291721934005595
exported_pipeline = make_pipeline(
ZeroCount(), SelectPercentile(score_func=f_classif, percentile=66),
LogisticRegression(C=0.0001, dual=False, penalty="l2"))
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import BernoulliNB
from sklearn.pipeline import make_pipeline, make_union
from sklearn.preprocessing import MinMaxScaler
from tpot.builtins import StackingEstimator, ZeroCount
# NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'].values, random_state=42)
# Score on the training set was:0.47500297900297905
exported_pipeline = make_pipeline(
make_union(MinMaxScaler(), make_pipeline(ZeroCount(), MinMaxScaler())),
ZeroCount(),
StackingEstimator(estimator=BernoulliNB(alpha=100.0, fit_prior=False)),
LogisticRegression(C=0.01, dual=True, penalty="l2"))
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from tpot.builtins import ZeroCount
from xgboost import XGBRegressor
# NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'].values, random_state=42)
# Score on the training set was:-0.0004955828805812525
exported_pipeline = make_pipeline(
ZeroCount(),
XGBRegressor(learning_rate=0.1,
max_depth=8,
min_child_weight=16,
n_estimators=100,
nthread=1,
subsample=1.0))
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
from sklearn.pipeline import make_pipeline, make_union
from sklearn.preprocessing import PolynomialFeatures
from tpot.builtins import StackingEstimator, ZeroCount
from xgboost import XGBRegressor
# NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE',
sep='COLUMN_SEPARATOR',
dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
train_test_split(features, tpot_data['target'].values, random_state=42)
# Score on the training set was:-15.336456888232188
exported_pipeline = make_pipeline(
SelectPercentile(score_func=f_regression, percentile=89), ZeroCount(),
StackingEstimator(
estimator=GradientBoostingRegressor(alpha=0.75,
learning_rate=0.01,
loss="quantile",
max_depth=1,
max_features=0.35000000000000003,
min_samples_leaf=4,
min_samples_split=17,
n_estimators=100,
subsample=0.9000000000000001)),
PolynomialFeatures(degree=2, include_bias=False, interaction_only=False),
XGBRegressor(learning_rate=0.01,
max_depth=6,
min_child_weight=9,
n_estimators=100,