def __init__(self, spar_type, spar_penalty):
# We create a separate model for each action in the environment's
# action space. Alternatively we could somehow encode the action
# into the features, but this way it's easier to code up.
self.models = []
for _ in range(env.action_space.n):
#model=Lasso(alpha=0.01)
model = SGDRegressor(learning_rate='constant',
penalty=spar_type,
l1_ratio=spar_penalty,
max_iter=1000)
model1 = PassiveAggressiveRegressor()
model2 = Lasso(alpha=0.1, normalize=True, warm_start=True)
model3 = FTRL(alpha=1.0,
beta=1.0,
L1=0.00001,
L2=1.0,
D=2**25,
iters=1)
#l2,l1,none,elasticnet
#,penalty='l1',l1_ratio=0)
#learning_rate="constant"
# We need to call partial_fit once to initialize the model
# or we get a NotFittedError when trying to make a prediction
# This is quite hacky.
#model2.fit([self.featurize_state(env.reset())], [0])
#X = np.array([self.featurize_state(env.reset())])
#Y = np.array([0])
#print X.shape, Y.shape
#model.partial_fit(X,Y)
model.partial_fit([self.featurize_state(env.reset())], [0])
self.models.append(model)
def runmodel_sklearn(chromosome, train, test, modelname, feature, label):
model = {
'GBRT': GradientBoostingRegressor(max_depth=7, loss='huber'),
#'xgb': xgb.XGBRegressor(nthread = 10,objective='reg:linear', n_estimators = 10, max_depth = 3),
'SVR': SVR(),
'Lasso': Lasso(),
'Linear': LinearRegression(),
'DecisionTree': DecisionTreeRegressor(max_depth=6),
'RandomForest': RandomForestRegressor(random_state=1, n_jobs=12),
'Ridge': Ridge(),
'AdaBoost': AdaBoostRegressor(),
'BayesianRidge': BayesianRidge(compute_score=True),
'KNN': KNeighborsRegressor(n_neighbors=12),
'ExtraTrees': ExtraTreesRegressor(random_state=1, n_jobs=12),
'SGD': SGDRegressor(loss='huber', penalty='elasticnet',
random_state=1),
'PassiveAggressive': PassiveAggressiveRegressor(),
'ElasticNet': ElasticNet(),
'Lars': Lars(),
#'lgm': lgb.LGBMRegressor(objective='regression',num_leaves=40, learning_rate=0.1,n_estimators=20, num_threads = 10),
#'xgb_parallel': xgb.XGBRegressor(objective='reg:linear', n_estimators = 10, max_depth = 3, nthread = 4)
}
newtrain = make_dataframe(chromosome, train)
if len(newtrain) == 0:
return 1000000000
estimator = model[modelname]
#return pearsonr(estimator.fit(newtrain[feature], newtrain[label]).predict(test[feature]), test[label])[0]
estimator.fit(newtrain[feature], newtrain[label])
return np.sqrt(
np.power(estimator.predict(test[feature]) - test[label],
2).mean()) / np.sqrt(np.power(test[label], 2).mean())
def get_model_from_name(model_name):
model_map = {
# Classifiers
'LogisticRegression': LogisticRegression(n_jobs=-2),
'RandomForestClassifier': RandomForestClassifier(n_jobs=-2),
'RidgeClassifier': RidgeClassifier(),
'XGBClassifier': xgb.XGBClassifier(),
'GradientBoostingClassifier': GradientBoostingClassifier(),
'SGDClassifier': SGDClassifier(n_jobs=-1),
'Perceptron': Perceptron(n_jobs=-1),
'PassiveAggressiveClassifier': PassiveAggressiveClassifier(),
# Regressors
'LinearRegression': LinearRegression(n_jobs=-2),
'RandomForestRegressor': RandomForestRegressor(n_jobs=-2),
'Ridge': Ridge(),
'XGBRegressor': xgb.XGBRegressor(),
'ExtraTreesRegressor': ExtraTreesRegressor(n_jobs=-1),
'AdaBoostRegressor': AdaBoostRegressor(n_estimators=5),
'RANSACRegressor': RANSACRegressor(),
'GradientBoostingRegressor': GradientBoostingRegressor(presort=False),
'Lasso': Lasso(),
'ElasticNet': ElasticNet(),
'LassoLars': LassoLars(),
'OrthogonalMatchingPursuit': OrthogonalMatchingPursuit(),
'BayesianRidge': BayesianRidge(),
'ARDRegression': ARDRegression(),
'SGDRegressor': SGDRegressor(shuffle=False),
'PassiveAggressiveRegressor':
PassiveAggressiveRegressor(shuffle=False),
# Clustering
'MiniBatchKMeans': MiniBatchKMeans(n_clusters=8)
}
return model_map[model_name]
def __init__(self, env, feature_transformer):
self.env = env
self.models = {}
self.feature_transformer = feature_transformer
for a in env.actions_available:
self.models[a] = PassiveAggressiveRegressor(C=1.0,
fit_intercept=True,
n_iter=10)
def __init__(self, X, y, par_params, nfolds=3, n_jobs=1, scoring=None,random_grid=False, n_iter=10, verbose=True):
self._code="par"
if verbose:
print ("Constructed PassiveAggressiveRegressor: " +self._code)
AbstractRegressorPredictiveModel.__init__(self, "regressor", X, y, par_params, nfolds, n_jobs, scoring,random_grid, n_iter, verbose)
self._model = self.constructRegressor(PassiveAggressiveRegressor(), self._random_grid)
def go(self, all_data, totalCols, test_ID, colsP, RFEcv, XGBestCols):
train = all_data.loc[all_data.SalePrice>0 , list(totalCols)].reset_index(drop=True, inplace=False)
y_train = all_data.SalePrice[all_data.SalePrice>0].reset_index(drop=True, inplace=False)
test = all_data.loc[all_data.SalePrice==0 , list(totalCols)].reset_index(drop=True, inplace=False)
scale = RobustScaler()
df = scale.fit_transform(train)
pca = PCA().fit(df) # whiten=True
print('With only 120 features: {:6.4%}'.format(sum(pca.explained_variance_ratio_[:120])),"%\n")
print('After PCA, {:3} features only not explained {:6.4%} of variance ratio from the original {:3}'.format(120,
(sum(pca.explained_variance_ratio_[120:])),
df.shape[1]))
y_train = np.expm1(y_train)
#Common parameters
unionedColumns = list(set(RFEcv).union(set(colsP)))
lengthOfUnionedColumns = len(unionedColumns)
#XGBRegressor
model = Pipeline([('pca', PCA(random_state = self.randomState)), ('model', XGBRegressor(random_state = self.randomState, silent=True))])
gridSearch = self.createGridSearch(model, "XGB", lengthOfUnionedColumns)
xgbRegressor = Pipeline([('sel', select_fetaures(select_cols = unionedColumns)), ('scl', RobustScaler()), ('gs', gridSearch)])
xgbRegressor.fit(train, y_train)
#bayesian ridge
model = Pipeline([('pca', PCA(random_state = self.randomState)), ('model', BayesianRidge())])
gridSearch = self.createGridSearch(model, "Bayesian", lengthOfUnionedColumns)
bayesianRidge = Pipeline([('sel', select_fetaures(select_cols = unionedColumns)), ('scl', RobustScaler()), ('gs', gridSearch)])
bayesianRidge.fit(train, y_train)
#Passive Aggressive Regressor
model = Pipeline([('pca', PCA(random_state = self.randomState)), ('model', PassiveAggressiveRegressor(random_state = self.randomState))])
gridSearch = self.createGridSearch(model, "PassiveAggressive", lengthOfUnionedColumns)
passiveAggressiveRegressor = Pipeline([('sel', select_fetaures(select_cols = unionedColumns)), ('scl', RobustScaler()), ('gs', gridSearch)])
passiveAggressiveRegressor.fit(train, y_train)
averagingModels = AveragingModels(models = (xgbRegressor, bayesianRidge, passiveAggressiveRegressor))
averagingModels.fit(train, y_train)
averagedModelTrainingDataPredictions = averagingModels.predict(train)
averagedModelTestDataPredictions = (averagingModels.predict(test))
meanSquaredError = (np.sqrt(mean_squared_error(y_train, averagedModelTrainingDataPredictions)))
averageModelScore = averagingModels.score(train, y_train)
print('RMSLE score on the train data: {:.4f}'.format(meanSquaredError))
print('Accuracy score: {:.6%}'.format(averageModelScore))
ensemble = averagedModelTestDataPredictions *1
submit = pd.DataFrame()
submit['id'] = test_ID
submit['SalePrice'] = ensemble
return(submit)
def test_isclassifier(self):
"""
Assert that only classifiers can be used with the visualizer.
"""
model = PassiveAggressiveRegressor()
message = ('This estimator is not a classifier; '
'try a regression or clustering score visualizer instead!')
with pytest.raises(yb.exceptions.YellowbrickError, match=message):
ConfusionMatrix(model)
def __init__(self, env, feature_transformer):
self.env = env
self.models = {}
self.feature_transformer = feature_transformer
for a in env.actions_available:
self.models[a] = PassiveAggressiveRegressor(C=1.0,
fit_intercept=True,
shuffle=False)
self.bloom_states = BloomFilter(max_elements=256**2)
self.nonseen_states = 0
def __init__(self, env, feature_transformer):
self.env = env
self.models = {}
self.models_elite = {}
self.feature_transformer = feature_transformer
for a in env.actions_available:
self.models[a] = PassiveAggressiveRegressor(
C=1.0,
fit_intercept=True,
shuffle=False,
loss='epsilon_insensitive',
epsilon=0.1)
self.models_elite[a] = PassiveAggressiveRegressor(
C=1.0,
fit_intercept=True,
shuffle=False,
loss='epsilon_insensitive',
epsilon=0.1)
self.bloom_states = BloomFilter(max_elements=256**2)
def mcFadden_R2(y_true, y_pred):
constant_feature = pd.DataFrame(np.full(len(y_true), 1))
logistic_regression = PassiveAggressiveRegressor()
logistic_regression.fit(constant_feature, y_true)
null_model_prediction = logistic_regression.predict(constant_feature)
print('avg log-likelihood null-model: {}'.format(
log_likelihood(y_true, null_model_prediction)))
L = log_likelihood(y_true, y_pred)
L_null = log_likelihood(y_true, null_model_prediction)
return 1 - L / L_null
def test_model_passive_aggressive_regressor(self):
model, X = fit_regression_model(PassiveAggressiveRegressor())
model_onnx = convert_sklearn(
model, "passive aggressive regressor",
[("input", FloatTensorType([None, X.shape[1]]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(X,
model,
model_onnx,
verbose=False,
basename="SklearnPassiveAggressiveRegressor-Dec4")
def test_isclassifier(self):
model = PassiveAggressiveRegressor()
message = 'This estimator is not a classifier; try a regression or clustering score visualizer instead!'
classes = [
'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven',
'eight', 'nine'
]
with self.assertRaisesRegexp(yellowbrick.exceptions.YellowbrickError,
message):
ConfusionMatrix(model, classes=classes)
def test_regressor_partial_fit():
y_bin = y.copy()
y_bin[y != 1] = -1
for data in (X, X_csr):
reg = PassiveAggressiveRegressor(C=1.0,
fit_intercept=True,
random_state=0)
for t in xrange(50):
reg.partial_fit(data, y_bin)
pred = reg.predict(data)
assert_less(np.mean((pred - y_bin)**2), 1.7)
def get_latent_matrix(_x, _y, _z):
latent_matrix = np.array(
zip(LinearRegression().fit(_x, _y).predict(_z),
BayesianRidge(compute_score=True).fit(_x, _y).predict(_z),
ElasticNet().fit(_x, _y).predict(_z),
PassiveAggressiveRegressor().fit(_x, _y).predict(_z),
RANSACRegressor().fit(_x, _y).predict(_z),
LogisticRegression().fit(_x, _y).predict(_z)))
#SVR(kernel='linear', C=1e3).fit(_x,_y).predict(_z),
#SVR(kernel='poly', C=1e3, degree=2).fit(_x,_y).predict(_z),
#SVR(kernel='rbf', C=1e3, gamma=0.1).fit(_x,_y).predict(_z)))
return latent_matrix
def test_regressor_mse():
y_bin = y.copy()
y_bin[y != 1] = -1
for data in (X, X_csr):
for fit_intercept in (True, False):
reg = PassiveAggressiveRegressor(C=1.0, n_iter=50,
fit_intercept=fit_intercept,
random_state=0)
reg.fit(data, y_bin)
pred = reg.predict(data)
assert_less(np.mean((pred - y_bin) ** 2), 1.7)
def get_hyperparameters_model():
param_dist = {}
clf = PassiveAggressiveRegressor()
model = {
'passive_aggressive_regressor': {
'model': clf,
'param_distributions': param_dist
}
}
return model
def select_regressor(X, y, scoring='neg_mean_squared_error', show=True):
regressors = [
AdaBoostRegressor(),
# ARDRegression(),
BaggingRegressor(),
DecisionTreeRegressor(),
ElasticNet(),
ExtraTreeRegressor(),
ExtraTreesRegressor(),
# GaussianProcessRegressor(),
GradientBoostingRegressor(),
HuberRegressor(),
KNeighborsRegressor(),
Lasso(),
LinearRegression(),
# LogisticRegression(),
MLPRegressor(),
PassiveAggressiveRegressor(),
PLSRegression(),
# RadiusNeighborsRegressor(),
RandomForestRegressor(),
RANSACRegressor(),
Ridge(),
SGDRegressor(),
TheilSenRegressor(),
]
names = [reg.__class__.__name__ for reg in regressors]
# cv = StratifiedShuffleSplit(n_splits=n_splits, test_size=test_size, random_state=random_state)
scores = {}
for i, (name, reg) in enumerate(zip(names, regressors)):
print('Processing {}...'.format(name))
ss = cross_val_score(reg, X, y, scoring=scoring, cv=10)
scores[name] = ss
# for train_index, test_index in cv.split(X, y):
# X_train, X_test = X[train_index], X[test_index]
# y_train, y_test = y[train_index], y[test_index]
# try:
# clf.fit(X_train, y_train)
# train_predictions = clf.predict(X_test)
# rmse = np.sqrt(mean_squared_error(y_test, train_predictions))
# except:
# rmse = 0
# s = scores.get(name, [])
# s.append(acc)
# scores[name] = s
scores = [[n, np.sqrt(-s).mean()] for n, s in scores.items()]
scores = pd.DataFrame(scores,
columns=['Regressor',
'Score']).sort_values(by='Score',
ascending=True)
if show:
print(scores)
return scores.iloc[0, 0], regressors[scores.iloc[0].name], scores
def get_models(models=dict()):
# linear models
models['lr'] = LinearRegression()
models['lasso'] = Lasso()
models['ridge'] = Ridge()
models['en'] = ElasticNet()
models['huber'] = HuberRegressor()
models['llars'] = LassoLars()
models['pa'] = PassiveAggressiveRegressor(max_iter=1000, tol=1e-3)
models['sgd'] = SGDRegressor(max_iter=1000, tol=1e-3)
print('Defined %d models' % len(models))
return models
def ensure_many_models(self, clip_min=None, clip_max=None):
from sklearn.ensemble import GradientBoostingRegressor, RandomForestRegressor
from sklearn.neural_network import MLPRegressor
from sklearn.linear_model import ElasticNet, RANSACRegressor, HuberRegressor, PassiveAggressiveRegressor
from sklearn.neighbors import KNeighborsRegressor
from sklearn.svm import SVR, LinearSVR
from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.exceptions import ConvergenceWarning
warnings.filterwarnings('ignore', category=ConvergenceWarning)
data = self.create_uninformative_ox_dataset()
for propensity_learner in [
GradientBoostingClassifier(n_estimators=10),
RandomForestClassifier(n_estimators=100),
MLPClassifier(hidden_layer_sizes=(5, )),
KNeighborsClassifier(n_neighbors=20)
]:
weight_model = IPW(propensity_learner,
clip_min=clip_min,
clip_max=clip_max)
propensity_learner_name = str(propensity_learner).split(
"(", maxsplit=1)[0]
for outcome_learner in [
GradientBoostingRegressor(n_estimators=10),
RandomForestRegressor(n_estimators=10),
MLPRegressor(hidden_layer_sizes=(5, )),
ElasticNet(),
RANSACRegressor(),
HuberRegressor(),
PassiveAggressiveRegressor(),
KNeighborsRegressor(),
SVR(),
LinearSVR()
]:
outcome_learner_name = str(outcome_learner).split(
"(", maxsplit=1)[0]
outcome_model = Standardization(outcome_learner)
with self.subTest("Test fit & predict using {} & {}".format(
propensity_learner_name, outcome_learner_name)):
model = self.estimator.__class__(outcome_model,
weight_model)
model.fit(data["X"],
data["a"],
data["y"],
refit_weight_model=False)
model.estimate_individual_outcome(data["X"], data["a"])
self.assertTrue(True) # Fit did not crash
def test_regressor_correctness(loss):
y_bin = y.copy()
y_bin[y != 1] = -1
reg1 = MyPassiveAggressive(loss=loss, n_iter=2)
reg1.fit(X, y_bin)
for data in (X, X_csr):
reg2 = PassiveAggressiveRegressor(tol=None, loss=loss, max_iter=2,
shuffle=False)
reg2.fit(data, y_bin)
assert_array_almost_equal(reg1.w, reg2.coef_.ravel(), decimal=2)
def build_linear_model():
"""
Creates a pipeline consisting of feature transformer and passive
aggressive regressor
"""
ft = FeatureTransformer()
scaler = StandardScaler()
reg = PassiveAggressiveRegressor(C=0.1)
pipeline = Pipeline([('ft', ft), ('scaler', scaler), ('reg', reg)])
return pipeline
def choose_regression_algorithm(method = "LR"):
if method == "LR":
regression_algorithm = LinearRegression()
elif method == "Lasso":
regression_algorithm = Lasso()
elif method == "Ridge":
regression_algorithm = Ridge()
elif method == "HR":
regression_algorithm = HuberRegressor()
elif method == "SVR":
regression_algorithm = SVR()
elif method == "LL":
regression_algorithm = LassoLars()
elif method == "ARDR":
regression_algorithm = ARDRegression()
elif method == "BR":
regression_algorithm = BayesianRidge()
elif method == "ElasticNet":
regression_algorithm = ElasticNet()
elif method == "Lars":
regression_algorithm = Lars()
elif method == "PA":
regression_algorithm = PassiveAggressiveRegressor()
elif method == "RANSAC":
regression_algorithm = RANSACRegressor()
elif method == "TS":
regression_algorithm = TheilSenRegressor()
elif method == "LP":
regression_algorithm = lars_path()
elif method == "RR":
regression_algorithm = ridge_regression()
else:
print("You haven't chosen a valide classifier!!!")
print("method used:\t", method)
return regression_algorithm
def main():
import sys
player_name = sys.argv[1]
port = int(sys.argv[2])
regressor = None
expansions = -1
if len(sys.argv) >= 4:
regressor_name = sys.argv[3]
if regressor_name.lower() == "sgd":
regressor = SGDRegressor()
elif regressor_name.lower() == "mlp":
regressor = MLPRegressor((40, 20, 40))
elif regressor_name.lower() == "paggro":
regressor = PassiveAggressiveRegressor()
if len(sys.argv) >= 5:
expansions = int(sys.argv[4])
if regressor is None:
print(
"Invalid regressor given, please choose from the following: sgd, mlp, paggro, knn, hoeffding, forest, bagging"
)
exit()
else:
regressor = SGDRegressor()
player = None
if player_name.lower() == "sarsa":
player = SarsaPlayer(regressor, "sarsa")
elif player_name.lower() == "carl_playout":
player = CarlPlayer("ucb", "sarsa", regressor, expansions,
"Carl with SARSA in playout")
elif player_name.lower() == "carl_selection":
player = CarlPlayer("sucb", "random", regressor, expansions,
"Carl with SARSA in selection")
elif player_name.lower() == "carl_full":
player = CarlPlayer("sucb", "sarsa", regressor, expansions,
"Carl with SARSA in selection and playout")
elif player_name.lower() == "mcts":
player = CarlPlayer("ucb", "random", regressor, expansions, "MCTS")
elif player_name.lower() == "random":
player = RandomPlayer("Random")
else:
print("No valid player chosen")
exit()
play_runner(player, port)
def __build_clf(self):
# type: () -> SVR or SGDRegressor or PassiveAggressiveRegressor or None
"""
Crea un regressore in base a quanto specificato alla creazione dell'oggetto
:return:
"""
clf = None
if self.regressor_name == 'SGD':
clf = linear_model.SGDRegressor()
elif self.regressor_name == 'SVR':
clf = SVR()
elif self.regressor_name == 'PAR':
clf = PassiveAggressiveRegressor()
return clf
def get_models(models=dict()):
# linear models
models['linear regression'] = LinearRegression()
models['lasso'] = Lasso()
models['ridge'] = Ridge()
models['elastic net'] = ElasticNet()
models['huber regressor'] = HuberRegressor()
#models['lars'] = Lars()
models['lasso lars'] = LassoLars()
models['passive aggressive regressor'] = PassiveAggressiveRegressor(max_iter=1000, tol=1e-3)
models['ranscac regressor'] = RANSACRegressor(min_samples=7)
models['sgd regressor'] = SGDRegressor(max_iter=5000, tol=1e-3)
print('Defined %d models' % len(models))
return models
def main():
start = time.time()
prepare_data()
models = [SGDRegressor(), PassiveAggressiveRegressor()]
num_iteration = 100
for i in range(num_iteration):
print('======Iteration #', i)
mini_batches_iter = get_mini_batches_iter(shuffled_train_data,
batch_size)
fit_partially(models, mini_batches_iter)
print('---Evaluation in validation set:')
evaluate(models, valid_data)
print('---Evaluation in test set:')
evaluate(models, test_data)
def init_regressors(self, seed):
return {
'AdaBoostRegressor': AdaBoostRegressor(random_state=seed),
'BaggingRegressor': BaggingRegressor(random_state=seed),
'ExtraTreesRegressor': ExtraTreesRegressor(random_state=seed),
'GradientBoostingRegressor': GradientBoostingRegressor(random_state=seed),
'RandomForestRegressor': RandomForestRegressor(random_state=seed),
'LogisticRegression': LogisticRegression(random_state=seed),
'PassiveAggressiveRegressor': PassiveAggressiveRegressor(random_state=seed),
'SGDRegressor': SGDRegressor(random_state=seed),
'KNeighborsRegressor': KNeighborsRegressor(),
'MLPRegressor': MLPRegressor(random_state=seed),
'DecisionTreeRegressor': DecisionTreeRegressor(random_state=seed),
'ExtraTreeRegressor': ExtraTreeRegressor(random_state=seed),
}
def get_model_from_name(model_name):
model_map = {
# Classifiers
'LogisticRegression': LogisticRegression(n_jobs=-2),
'RandomForestClassifier': RandomForestClassifier(n_jobs=-2),
'RidgeClassifier': RidgeClassifier(),
'GradientBoostingClassifier': GradientBoostingClassifier(),
'ExtraTreesClassifier': ExtraTreesClassifier(n_jobs=-1),
'AdaBoostClassifier': AdaBoostClassifier(n_estimators=10),
'SGDClassifier': SGDClassifier(n_jobs=-1),
'Perceptron': Perceptron(n_jobs=-1),
'PassiveAggressiveClassifier': PassiveAggressiveClassifier(),
# Regressors
# 'DeepLearningRegressor': KerasRegressor(build_fn=make_deep_learning_model, nb_epoch=10, batch_size=10, verbose=1),
'LinearRegression': LinearRegression(n_jobs=-2),
'RandomForestRegressor': RandomForestRegressor(n_jobs=-2),
'Ridge': Ridge(),
'ExtraTreesRegressor': ExtraTreesRegressor(n_jobs=-1),
'AdaBoostRegressor': AdaBoostRegressor(n_estimators=10),
'RANSACRegressor': RANSACRegressor(),
'GradientBoostingRegressor': GradientBoostingRegressor(presort=False),
'Lasso': Lasso(),
'ElasticNet': ElasticNet(),
'LassoLars': LassoLars(),
'OrthogonalMatchingPursuit': OrthogonalMatchingPursuit(),
'BayesianRidge': BayesianRidge(),
'ARDRegression': ARDRegression(),
'SGDRegressor': SGDRegressor(shuffle=False),
'PassiveAggressiveRegressor':
PassiveAggressiveRegressor(shuffle=False),
# Clustering
'MiniBatchKMeans': MiniBatchKMeans(n_clusters=8)
}
if xgb_installed:
model_map['XGBClassifier'] = xgb.XGBClassifier(colsample_bytree=0.8,
min_child_weight=5,
subsample=1.0,
learning_rate=0.1,
n_estimators=200,
nthread=-1)
model_map['XGBRegressor'] = xgb.XGBRegressor(nthread=-1,
n_estimators=200)
return model_map[model_name]
def test_regressor_partial_fit():
y_bin = y.copy()
y_bin[y != 1] = -1
for data in (X, X_csr):
for average in (False, True):
reg = PassiveAggressiveRegressor(random_state=0,
average=average, max_iter=100)
for t in range(50):
reg.partial_fit(data, y_bin)
pred = reg.predict(data)
assert np.mean((pred - y_bin) ** 2) < 1.7
if average:
assert hasattr(reg, 'average_coef_')
assert hasattr(reg, 'average_intercept_')
assert hasattr(reg, 'standard_intercept_')
assert hasattr(reg, 'standard_coef_')
def get_models_multioutput(models=dict()):
# linear models
models['lr'] = MultiOutputRegressor(LinearRegression())
alpha = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
for a in alpha:
models['lasso-' + str(a)] = MultiOutputRegressor(Lasso(alpha=a))
for a in alpha:
models['ridge-' + str(a)] = MultiOutputRegressor(Ridge(alpha=a))
for a1 in alpha:
for a2 in alpha:
name = 'en-' + str(a1) + '-' + str(a2)
models[name] = MultiOutputRegressor(ElasticNet(a1, a2))
models['huber'] = MultiOutputRegressor(HuberRegressor())
models['lars'] = MultiOutputRegressor(Lars())
models['llars'] = MultiOutputRegressor(LassoLars())
models['pa'] = MultiOutputRegressor(
PassiveAggressiveRegressor(max_iter=1000, tol=1e-3))
models['ranscac'] = MultiOutputRegressor(RANSACRegressor())
models['sgd'] = MultiOutputRegressor(SGDRegressor(max_iter=1000, tol=1e-3))
models['theil'] = MultiOutputRegressor(TheilSenRegressor())
# non-linear models
n_neighbors = range(1, 21)
for k in n_neighbors:
models['knn-' + str(k)] = MultiOutputRegressor(
KNeighborsRegressor(n_neighbors=k))
models['cart'] = MultiOutputRegressor(DecisionTreeRegressor())
models['extra'] = MultiOutputRegressor(ExtraTreeRegressor())
models['svml'] = MultiOutputRegressor(SVR(kernel='linear'))
models['svmp'] = MultiOutputRegressor(SVR(kernel='poly'))
c_values = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
for c in c_values:
models['svmr' + str(c)] = SVR(C=c)
# ensemble models
n_trees = 100
models['ada'] = MultiOutputRegressor(
AdaBoostRegressor(n_estimators=n_trees))
models['bag'] = MultiOutputRegressor(
BaggingRegressor(n_estimators=n_trees))
models['rf'] = MultiOutputRegressor(
RandomForestRegressor(n_estimators=n_trees))
models['et'] = MultiOutputRegressor(
ExtraTreesRegressor(n_estimators=n_trees))
models['gbm'] = MultiOutputRegressor(
GradientBoostingRegressor(n_estimators=n_trees))
print('Defined %d models' % len(models))
return models
