def _lasso(*, train, test, x_predict=None, metrics, alpha=1.0, fit_intercept=True, normalize=False,
precompute=False, copy_X=True, max_iter=1000, tol=0.0001, warm_start=False, positive=False,
random_state=None, selection='cyclic'):
"""For for info visit :
https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Lasso.html#sklearn.linear_model.Lasso
"""
model = Lasso(alpha=alpha, fit_intercept=fit_intercept, normalize=normalize, precompute=precompute, copy_X=copy_X,
max_iter=max_iter, tol=tol, warm_start=warm_start, positive=positive, random_state=random_state, selection=selection)
model.fit(train[0], train[1])
model_name = 'Lasso'
y_hat = model.predict(test[0])
if metrics == 'mse':
accuracy = _mse(test[1], y_hat)
if metrics == 'rmse':
accuracy = _rmse(test[1], y_hat)
if metrics == 'mae':
accuracy = _mae(test[1], y_hat)
if x_predict is None:
return (model_name, accuracy, None)
y_predict = model.predict(x_predict)
return (model_name, accuracy, y_predict)
def _random_forest_regression(*, train, test, x_predict=None, metrics, n_estimators=100, max_depth=None,
min_samples_split=2,
min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features='auto',
max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None, bootstrap=True, oob_score=False,
n_jobs=None, random_state=76,
verbose=0, warm_start=False):
"""For for info visit :
https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestRegressor.html
"""
model = RandomForestRegressor(n_estimators=n_estimators, max_depth=max_depth, min_samples_split=min_samples_split,
min_samples_leaf=min_samples_leaf, min_weight_fraction_leaf=min_weight_fraction_leaf,
max_features=max_features,
max_leaf_nodes=max_leaf_nodes,
min_impurity_decrease=min_impurity_decrease, min_impurity_split=min_impurity_split,
bootstrap=bootstrap, oob_score=oob_score,
n_jobs=n_jobs, random_state=random_state,
verbose=verbose, warm_start=warm_start)
model.fit(train[0], train[1])
model_name = 'RandomForestRegressor'
y_hat = model.predict(test[0])
if metrics == 'mse':
accuracy = _mse(test[1], y_hat)
if metrics == 'rmse':
accuracy = _rmse(test[1], y_hat)
if metrics == 'mae':
accuracy = _mae(test[1], y_hat)
if x_predict is None:
return model_name, accuracy, None
y_predict = model.predict(x_predict)
return model_name, accuracy, y_predict
def _bayesianridge(*, train, test, x_predict=None, metrics, n_iter=300, tol=0.001,
alpha_1=1e-06, alpha_2=1e-06, lambda_1=1e-06, lambda_2=1e-06, alpha_init=None,
lambda_init=None, compute_score=False, fit_intercept=True, normalize=False, copy_X=True,
verbose=False):
"""For more info visit :
https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.BayesianRidge.html#sklearn.linear_model.BayesianRidge
"""
model = BayesianRidge(n_iter=n_iter, tol=tol, alpha_1=alpha_1, alpha_2=alpha_2, lambda_1=lambda_1,
lambda_2=lambda_2, alpha_init=alpha_init, lambda_init=lambda_init, compute_score=compute_score,
fit_intercept=fit_intercept, normalize=normalize, copy_X=copy_X, verbose=verbose)
model.fit(train[0], train[1])
model_name = 'Bayesian Ridge'
y_hat = model.predict(test[0])
if metrics == 'mse':
accuracy = _mse(test[1], y_hat)
if metrics == 'rmse':
accuracy = _rmse(test[1], y_hat)
if metrics == 'mae':
accuracy = _mae(test[1], y_hat)
if x_predict is None:
return (model_name, accuracy, None)
y_predict = model.predict(x_predict)
return (model_name, accuracy, y_predict)
def _lassocv(*, train, test, x_predict=None, metrics, eps=0.001, n_alphas=100, alphas=None, fit_intercept=True,
normalize=False, precompute='auto', max_iter=1000, tol=0.0001, copy_X=True, cv=None, verbose=False,
n_jobs=None, positive=False, random_state=None, selection='cyclic'):
"""For for info visit :
https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LassoCV.html#sklearn.linear_model.LassoCV
"""
model = LassoCV(eps=eps, n_alphas=n_alphas, alphas=alphas, fit_intercept=fit_intercept, normalize=normalize,
precompute=precompute, max_iter=max_iter, tol=tol, copy_X=copy_X, cv=cv, verbose=verbose, n_jobs=n_jobs,
positive=positive, random_state=random_state, selection=selection)
model.fit(train[0], train[1])
model_name = 'LassoCV'
y_hat = model.predict(test[0])
if metrics == 'mse':
accuracy = _mse(test[1], y_hat)
if metrics == 'rmse':
accuracy = _rmse(test[1], y_hat)
if metrics == 'mae':
accuracy = _mae(test[1], y_hat)
if x_predict is None:
return (model_name, accuracy, None)
y_predict = model.predict(x_predict)
return (model_name, accuracy, y_predict)
def _omp(*,
train,
test,
x_predict=None,
metrics,
n_nonzero_coefs=None,
tol=None,
fit_intercept=True,
normalize=True,
precompute='auto'):
"""For more info visit :
https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.OrthogonalMatchingPursuit.html#sklearn.linear_model.OrthogonalMatchingPursuit
"""
model = OrthogonalMatchingPursuit(n_nonzero_coefs=n_nonzero_coefs,
tol=tol,
fit_intercept=fit_intercept,
normalize=normalize,
precompute=precompute)
model.fit(train[0], train[1])
model_name = 'OrthogonalMatchingPursuit'
y_hat = model.predict(test[0])
if metrics == 'mse':
accuracy = _mse(test[1], y_hat)
if metrics == 'rmse':
accuracy = _rmse(test[1], y_hat)
if metrics == 'mae':
accuracy = _mae(test[1], y_hat)
if x_predict is None:
return (model_name, accuracy, None)
y_predict = model.predict(x_predict)
return (model_name, accuracy, y_predict)
def _linear_regression(*,
train,
test,
x_predict=None,
metrics,
fit_intercept=True,
normalize=False,
copy_X=True,
n_jobs=None):
"""For more info visit :
https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html
"""
model = LinearRegression(fit_intercept=fit_intercept,
normalize=normalize,
copy_X=copy_X,
n_jobs=n_jobs)
model.fit(train[0], train[1])
model_name = 'Linear Regression'
y_hat = model.predict(test[0])
if metrics == 'mse':
accuracy = _mse(test[1], y_hat)
if metrics == 'rmse':
accuracy = _rmse(test[1], y_hat)
if metrics == 'mae':
accuracy = _mae(test[1], y_hat)
if x_predict is None:
return (model_name, accuracy, None)
y_predict = model.predict(x_predict)
return (model_name, accuracy, y_predict)
def _ard(*,
train,
test,
x_predict=None,
metrics,
n_iter=300,
tol=0.001,
alpha_1=1e-06,
alpha_2=1e-06,
lambda_1=1e-06,
lambda_2=1e-06,
compute_score=False,
threshold_lambda=10000.0,
fit_intercept=True,
normalize=False,
copy_X=True,
verbose=False):
"""For more info visit :
https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.ARDRegression.html#sklearn.linear_model.ARDRegression
"""
model = ARDRegression(n_iter=n_iter,
tol=tol,
alpha_1=alpha_1,
alpha_2=alpha_2,
lambda_1=lambda_1,
lambda_2=lambda_2,
compute_score=compute_score,
threshold_lambda=threshold_lambda,
fit_intercept=fit_intercept,
normalize=normalize,
copy_X=copy_X,
verbose=verbose)
model.fit(train[0], train[1])
model_name = 'ARDRegression'
y_hat = model.predict(test[0])
if metrics == 'mse':
accuracy = _mse(test[1], y_hat)
if metrics == 'rmse':
accuracy = _rmse(test[1], y_hat)
if metrics == 'mae':
accuracy = _mae(test[1], y_hat)
if x_predict is None:
return (model_name, accuracy, None)
y_predict = model.predict(x_predict)
return (model_name, accuracy, y_predict)
def _lassolars(*,
train,
test,
x_predict=None,
metrics,
alpha=1.0,
fit_intercept=True,
verbose=False,
normalize=True,
precompute='auto',
max_iter=500,
eps=2.220446049250313e-16,
copy_X=True,
fit_path=True,
positive=False,
jitter=None,
random_state=None):
"""For more info visit :
https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LassoLars.html#sklearn.linear_model.LassoLars
"""
model = LassoLars(alpha=alpha,
fit_intercept=fit_intercept,
verbose=verbose,
normalize=normalize,
precompute=precompute,
max_iter=max_iter,
eps=eps,
copy_X=copy_X,
fit_path=fit_path,
positive=positive,
jitter=jitter,
random_state=random_state)
model.fit(train[0], train[1])
model_name = 'LassoLars'
y_hat = model.predict(test[0])
if metrics == 'mse':
accuracy = _mse(test[1], y_hat)
if metrics == 'rmse':
accuracy = _rmse(test[1], y_hat)
if metrics == 'mae':
accuracy = _mae(test[1], y_hat)
if x_predict is None:
return (model_name, accuracy, None)
y_predict = model.predict(x_predict)
return (model_name, accuracy, y_predict)
def _lassolarscv(*,
train,
test,
x_predict=None,
metrics,
fit_intercept=True,
verbose=False,
max_iter=500,
normalize=True,
precompute='auto',
cv=None,
max_n_alphas=1000,
n_jobs=None,
eps=2.220446049250313e-16,
copy_X=True,
positive=False):
"""For more info visit :
https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LassoLarsCV.html#sklearn.linear_model.LassoLarsCV
"""
model = LassoLarsCV(fit_intercept=fit_intercept,
verbose=verbose,
max_iter=max_iter,
normalize=normalize,
precompute=precompute,
cv=cv,
max_n_alphas=max_n_alphas,
n_jobs=n_jobs,
eps=eps,
copy_X=copy_X,
positive=positive)
model.fit(train[0], train[1])
model_name = 'LassoLarsCV'
y_hat = model.predict(test[0])
if metrics == 'mse':
accuracy = _mse(test[1], y_hat)
if metrics == 'rmse':
accuracy = _rmse(test[1], y_hat)
if metrics == 'mae':
accuracy = _mae(test[1], y_hat)
if x_predict is None:
return (model_name, accuracy, None)
y_predict = model.predict(x_predict)
return (model_name, accuracy, y_predict)
def _ridge(*,
train,
test,
x_predict=None,
metrics,
alpha=1.0,
fit_intercept=True,
normalize=False,
copy_X=True,
max_iter=None,
tol=0.001,
solver='auto',
random_state=None):
"""For for info visit :
https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Ridge.html#sklearn.linear_model.Ridge
"""
model = Ridge(alpha=alpha,
fit_intercept=fit_intercept,
normalize=normalize,
copy_X=copy_X,
max_iter=max_iter,
tol=tol,
solver=solver,
random_state=random_state)
model.fit(train[0], train[1])
model_name = 'Ridge'
y_hat = model.predict(test[0])
if metrics == 'mse':
accuracy = _mse(test[1], y_hat)
if metrics == 'rmse':
accuracy = _rmse(test[1], y_hat)
if metrics == 'mae':
accuracy = _mae(test[1], y_hat)
if x_predict is None:
return (model_name, accuracy, None)
y_predict = model.predict(x_predict)
return (model_name, accuracy, y_predict)
def _ompcv(*,
train,
test,
x_predict=None,
metrics,
copy=True,
fit_intercept=True,
normalize=True,
max_iter=None,
cv=None,
n_jobs=None,
verbose=False):
"""For more info visit :
https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.OrthogonalMatchingPursuitCV.html#sklearn.linear_model.OrthogonalMatchingPursuitCV
"""
model = OrthogonalMatchingPursuitCV(fit_intercept=fit_intercept,
copy=copy,
normalize=normalize,
max_iter=max_iter,
cv=cv,
n_jobs=n_jobs,
verbose=verbose)
model.fit(train[0], train[1])
model_name = 'OrthogonalMatchingPursuitCV'
y_hat = model.predict(test[0])
if metrics == 'mse':
accuracy = _mse(test[1], y_hat)
if metrics == 'rmse':
accuracy = _rmse(test[1], y_hat)
if metrics == 'mae':
accuracy = _mae(test[1], y_hat)
if x_predict is None:
return (model_name, accuracy, None)
y_predict = model.predict(x_predict)
return (model_name, accuracy, y_predict)
def _ridgecv(*,
train,
test,
x_predict=None,
metrics,
alphas=(0.1, 1.0, 10.0),
fit_intercept=True,
normalize=False,
scoring=None,
cv=None,
gcv_mode=None,
store_cv_values=False):
"""For more info visit:
https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.RidgeCV.html#sklearn.linear_model.RidgeCV
"""
model = RidgeCV(alphas=alphas,
fit_intercept=fit_intercept,
normalize=normalize,
scoring=scoring,
cv=cv,
gcv_mode=gcv_mode,
store_cv_values=store_cv_values)
model.fit(train[0], train[1])
model_name = 'RidgeCV'
y_hat = model.predict(test[0])
if metrics == 'mse':
accuracy = _mse(test[1], y_hat)
if metrics == 'rmse':
accuracy = _rmse(test[1], y_hat)
if metrics == 'mae':
accuracy = _mae(test[1], y_hat)
if x_predict is None:
return (model_name, accuracy, None)
y_predict = model.predict(x_predict)
return (model_name, accuracy, y_predict)
def _sgd(*,
train,
test,
x_predict=None,
metrics,
loss='squared_loss',
penalty='l2',
alpha=0.0001,
l1_ratio=0.15,
fit_intercept=True,
max_iter=1000,
tol=0.001,
shuffle=True,
verbose=0,
epsilon=0.1,
random_state=None,
learning_rate='invscaling',
eta0=0.01,
power_t=0.25,
early_stopping=False,
validation_fraction=0.1,
n_iter_no_change=5,
warm_start=False,
average=False):
"""For more info visit :
https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.SGDRegressor.html#sklearn.linear_model.SGDRegressor
"""
model = SGDRegressor(loss=loss,
penalty=penalty,
alpha=alpha,
l1_ratio=l1_ratio,
fit_intercept=fit_intercept,
max_iter=max_iter,
tol=tol,
shuffle=shuffle,
verbose=verbose,
epsilon=epsilon,
random_state=random_state,
learning_rate=learning_rate,
eta0=eta0,
power_t=power_t,
early_stopping=early_stopping,
validation_fraction=validation_fraction,
n_iter_no_change=n_iter_no_change,
warm_start=warm_start,
average=average)
model.fit(train[0], train[1])
model_name = 'SGDRegressor'
y_hat = model.predict(test[0])
if metrics == 'mse':
accuracy = _mse(test[1], y_hat)
if metrics == 'rmse':
accuracy = _rmse(test[1], y_hat)
if metrics == 'mae':
accuracy = _mae(test[1], y_hat)
if x_predict is None:
return (model_name, accuracy, None)
y_predict = model.predict(x_predict)
return (model_name, accuracy, y_predict)
def _gradient_boosting_regression(*,
train,
test,
x_predict=None,
metrics,
loss='ls',
learning_rate=0.1,
n_estimators=100,
subsample=1.0,
min_samples_split=2,
min_samples_leaf=1,
min_weight_fraction_leaf=0.0,
max_depth=3,
min_impurity_decrease=0.0,
min_impurity_split=None,
init=None,
random_state=None,
max_features=None,
alpha=0.9,
verbose=0,
max_leaf_nodes=None,
warm_start=False,
presort='deprecated',
validation_fraction=0.1,
n_iter_no_change=None,
tol=0.0001,
ccp_alpha=0.0):
"""For more info visit :
https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingRegressor.html
"""
model = GradientBoostingRegressor(
loss=loss,
learning_rate=learning_rate,
n_estimators=n_estimators,
subsample=subsample,
min_samples_split=min_samples_split,
min_samples_leaf=min_samples_leaf,
min_weight_fraction_leaf=min_weight_fraction_leaf,
max_depth=max_depth,
min_impurity_decrease=min_impurity_decrease,
min_impurity_split=min_impurity_split,
init=init,
random_state=random_state,
max_features=max_features,
alpha=alpha,
verbose=verbose,
max_leaf_nodes=max_leaf_nodes,
warm_start=warm_start,
presort=presort,
validation_fraction=validation_fraction,
n_iter_no_change=n_iter_no_change,
tol=tol,
ccp_alpha=ccp_alpha)
model.fit(train[0], train[1])
model_name = 'GradientBoostingRegressor'
y_hat = model.predict(test[0])
if metrics == 'mse':
accuracy = _mse(test[1], y_hat)
if metrics == 'rmse':
accuracy = _rmse(test[1], y_hat)
if metrics == 'mae':
accuracy = _mae(test[1], y_hat)
if x_predict is None:
return model_name, accuracy, None
y_predict = model.predict(x_predict)
return model_name, accuracy, y_predict
def test_mse():
a = np.array([0, 1, 2])
b = np.array([1, 2, 3])
assert _mae(a, b) == 1.0