def __init__(self, data=None, classifier='linear', save=True, load=False, train=True, fname='FASMA_ML.pkl'): self.classifier = classifier self.data = data self.save = save self.fname = fname if data is not None: self.X_train, self.y_train = data.X, data.y self.xlabel = data.xlabel if self.classifier == 'linear': self.clf = linear_model.LinearRegression(n_jobs=-1, normalize=True) elif self.classifier == 'lasso': self.clf = linear_model.Lasso(alpha=0.001, tol=0.001, max_iter=1000) elif self.classifier == 'lassolars': self.clf = linear_model.LassoLars(alpha=0.1) elif self.classifier == 'multilasso': self.clf = linear_model.MultiTaskLasso(alpha=0.1) elif self.classifier == 'ridgeCV': self.clf = linear_model.RidgeCV(alphas=[0.1, 1., 10., 100.]) elif self.classifier == 'ridge': self.clf = linear_model.Ridge(alpha=0.0001) elif self.classifier == 'bayes': self.clf = linear_model.BayesianRidge() elif self.classifier == 'huber': self.clf = linear_model.HuberRegressor() # Train the classifier if not load or train: t = time() self.train_classifier() print('Trained classifier in {}s'.format(round(time()-t, 2))) else: self.clf, self.data = Model.load_model(self.fname)
def multi_task_weighted_elastic_net(X, q, L, alpha=0.001, rho=0.99999, path=False, measure_time=False): ''' Since sklearn does not support weighted version(for us weighted L2 regularization) of Elastic Net, we transform multitask elastic net to multitask lasso solve it and then transform the solution back to elastic net L is the accelerations that composes the weight matrix, i.e. W = L'* L ''' time0 = time.time() N = q.shape[0] d = q.shape[1] # 7 lamb1 = 2*N*alpha*rho lamb2 = N*alpha*(1-rho) q_bar = np.vstack((q, np.zeros((N, d)))) mult = np.sqrt(1.0/(1+lamb2)) Xdot2 = L # create_acc_weight_mat(c, w, t, include_intercept=True) # print Xdot2[0:5, 0:5] X_bar = mult * np.vstack((X, np.sqrt(lamb2)*Xdot2)) # clf = lm.MultiTaskLassoCV(eps=1e-3, n_alphas=100, alphas=None, # fit_intercept=False, cv=10, verbose=True, n_jobs=-1) clf = lm.MultiTaskLasso(alpha=alpha, fit_intercept=False) clf.fit(X_bar, q_bar) theta = clf.coef_.T * mult res = q - np.dot(X, theta) if path: res = clf.path(X_bar, q_bar, l1_ratio=0.5, n_alphas=100) coefs = res[1] theta_path = coefs.T * mult else: theta_path = [] if measure_time: time_elapsed = time.time() - time0 print 'Elastic net took {0} sec'.format(time_elapsed) return theta, res, theta_path
def train_models(mod): print('Selected model: %s' % mod) if mod == 'linear': clf = linear_model.LinearRegression(n_jobs=-1) elif mod == 'lasso': clf = linear_model.Lasso(alpha=0.001, max_iter=10000, tol=0.001, normalize=True, positive=True) elif mod == 'lassolars': clf = linear_model.LassoLars(alpha=0.001) elif mod == 'multilasso': clf = linear_model.MultiTaskLasso(alpha=0.1) elif mod == 'ridgeCV': clf = linear_model.RidgeCV( alphas=[0.01, 0.1, 1.0, 10.0, 100.0, 1000.0]) elif mod == 'ridge': clf = linear_model.Ridge(alpha=[0.001]) elif mod == 'bayes': clf = linear_model.BayesianRidge() elif mod == 'huber': clf = linear_model.HuberRegressor() elif mod == 'poly': clf = poly_clf() clf, continuum = train(clf, mod, save=True, plot=True) return clf, continuum
def test_lasso_alpha(*data): X_train, X_test, y_train, y_test = data alphas = [0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000] scores = [] for i, alpha in enumerate(alphas): lassoRegression = linear_model.MultiTaskLasso(alpha=alpha) lassoRegression.fit(X_train, y_train) scores.append(lassoRegression.score(X_test, y_test)) return alphas, scores
def test_compare_lasso(self): from mr_utils.recon.reordering import scr_reordering_adluru from sklearn import linear_model reg = linear_model.MultiTaskLasso(alpha=.0001) reg.fit(self.t[None, :], np.abs(self.smooth_sig_corrupted)[None, :]) print(reg) recon = reg.coef_.reshape(-1, 1) print(recon) plt.plot(recon) plt.show()
def __init__(self, regressorType): self.regressorType = regressorType if regressorType == "ridge": self.regModel = linear_model.Ridge(alpha=0.5) elif regressorType == "logistic": self.regModel = linear_model.LogisticRegression(fit_intercept=True,penalty='l2') elif regressorType == "linear": self.regModel = linear_model.LinearRegression() elif regressorType == "lasso": self.regModel = linear_model.MultiTaskLasso(alpha=0.1) else: print("Regressor Not Initialized")
def test_model_multi_task_lasso(self): model, X = fit_regression_model(linear_model.MultiTaskLasso(), n_targets=2) model_onnx = convert_sklearn( model, "multi-task lasso", [("input", FloatTensorType([None, X.shape[1]]))], target_opset=TARGET_OPSET) self.assertIsNotNone(model_onnx) dump_data_and_model(X, model, model_onnx, verbose=False, basename="SklearnMultiTaskLasso-Dec4")
def multi_task_lasso(X, q, cv=False, alpha=0.002): ''' Multi Task Lasso with dimensions forced to share features Running multi task Lasso with cross-validation gives 0.002 ''' if cv: clf = lm.MultiTaskLassoCV(eps=1e-3, n_alphas=100, alphas=None, fit_intercept=False, cv=10, verbose=True, n_jobs=-1) else: clf = lm.MultiTaskLasso(alpha=alpha, fit_intercept=False) clf.fit(X, q) theta = clf.coef_.T res = q - np.dot(X, theta) return theta, res
def test_model_multi_task_lasso(self): model, X = _fit_model_multi(linear_model.MultiTaskLasso()) model_onnx = convert_sklearn(model, "linear regression", [("input", FloatTensorType([None, 4]))]) self.assertIsNotNone(model_onnx) dump_data_and_model( X.astype(numpy.float32), model, model_onnx, verbose=False, basename="SklearnMultiTaskLasso-Dec4", allow_failure="StrictVersion(" "onnxruntime.__version__)" "<= StrictVersion('0.2.1')", )
def test_model_multi_task_lasso(self): model, X = fit_regression_model(linear_model.MultiTaskLasso(), n_targets=2) model_onnx = convert_sklearn( model, "multi-task lasso", [("input", FloatTensorType([None, X.shape[1]]))]) self.assertIsNotNone(model_onnx) dump_data_and_model( X, model, model_onnx, verbose=False, basename="SklearnMultiTaskLasso-Dec4", allow_failure="StrictVersion(" "onnxruntime.__version__)" "<= StrictVersion('0.2.1')", )
def sklearn_liner_model_regressions(xTrain, xTest, yTrain, yTest): modelForConsideration: DataFrame = pd.DataFrame() LinerModels = \ [ linear_model.ARDRegression(), linear_model.BayesianRidge(), linear_model.ElasticNet(), linear_model.ElasticNetCV(), linear_model.HuberRegressor(), linear_model.Lars(), linear_model.LarsCV(), linear_model.Lasso(), linear_model.LassoCV(), linear_model.LassoLars(), linear_model.LassoLarsCV(), linear_model.LassoLarsIC(), linear_model.LinearRegression(), linear_model.MultiTaskLasso(), linear_model.MultiTaskElasticNet(), linear_model.MultiTaskLassoCV(), linear_model.MultiTaskElasticNetCV(), linear_model.OrthogonalMatchingPursuit(), linear_model.OrthogonalMatchingPursuitCV(), linear_model.PassiveAggressiveClassifier(), linear_model.PassiveAggressiveRegressor(), linear_model.Perceptron(), linear_model.RANSACRegressor(), linear_model.Ridge(), linear_model.RidgeClassifier(), linear_model.RidgeClassifierCV(), linear_model.RidgeCV(), linear_model.SGDClassifier(), linear_model.SGDRegressor(), linear_model.TheilSenRegressor(), linear_model.enet_path(xTrain, yTrain), linear_model.lars_path(xTrain, yTrain), linear_model.lasso_path(xTrain, yTrain), # linear_model.LogisticRegression() # ,linear_model.LogisticRegressionCV(),linear_model.logistic_regression_path(xTrain, yTrain), linear_model.orthogonal_mp(xTrain, yTrain), linear_model.orthogonal_mp_gram(), linear_model.ridge_regression() ] for model in LinerModels: modelName: str = model.__class__.__name__ try: # print(f"Preparing Model {modelName}") if modelName == "LogisticRegression": model = linear_model.LogisticRegression(random_state=0) model.fit(xTrain, yTrain) yTrainPredict = model.predict(xTrain) yTestPredict = model.predict(xTest) errorList = calculate_prediction_error(modelName, yTestPredict, yTest, yTrainPredict, yTrain) if errorList["Test Average Error"][0] < 30 and errorList[ "Train Average Error"][0] < 30: try: modelForConsideration = modelForConsideration.append( errorList) except (Exception) as e: print(e) except (Exception, ArithmeticError) as e: print(f"Error occurred while preparing Model {modelName}") return modelForConsideration
def multitask_lasso(): rng = np.random.RandomState(42) n_samples, n_features, n_tasks = 100, 30, 40 n_relevant_features = 5 coef = np.zeros((n_tasks, n_features)) times = np.linspace(0, 2 * np.pi, n_tasks) for k in range(n_relevant_features): coef[:, k] = np.sin((1. + rng.randn(1)) * times + 3 * rng.randn(1)) X = rng.randn(n_samples, n_features) Y = np.dot(X, coef.T) + rng.randn(n_samples, n_tasks) coef_lasso_ = np.array([linear_model.Lasso( alpha=0.5).fit(X, y).coef_ for y in Y.T]) coef_multi_task_lasso_ = linear_model.MultiTaskLasso( alpha=1.).fit(X, Y).coef_
def __init__(self, data, classifier='linear', save=True, load=False, alpha=0.01, fname='FASMA_ML.pkl'): self.classifier = classifier self.data = data self.save = save self.load = load self.alpha = alpha self.fname = fname self.X_train, self.y_train = data.Xml, data.yml if self.classifier == 'linear': self.clf = Pipeline([('poly', PolynomialFeatures(degree=2)), ('linear', linear_model.LinearRegression(n_jobs=-1))]) elif self.classifier == 'lasso': self.clf = Pipeline([('poly', PolynomialFeatures(degree=2)), ('lasso', linear_model.Lasso(alpha=0.0001, max_iter=5000))]) elif self.classifier == 'lassolars': self.clf = Pipeline([('poly', PolynomialFeatures(degree=2)), ('lassolars', linear_model.LassoLars(alpha=1e-06))]) elif self.classifier == 'multilasso': self.clf = Pipeline([('poly', PolynomialFeatures(degree=2)), ('multilasso', linear_model.MultiTaskLasso(alpha=1e-06))]) elif self.classifier == 'ridge': self.clf = Pipeline([('poly', PolynomialFeatures(degree=2)), ('ridge', linear_model.Ridge(alpha=alpha))]) print(self.clf) # Train the classifier if not self.load: t = time() self.train_classifier() print('Trained classifier in {}s'.format(round(time() - t, 2))) else: with open(self.fname, 'rb') as f: self.clf = cPickle.load(f)
def model_training(X, Ys, mode='single', model_name='lasso', alpha=0.001, xgb_depth=3, xgb_trees=100, nn_solver='lbfgs', nn_size=(30, 30)): clf_models = [] # single-task: train one model for predicting each resource if mode == 'single': for i in range(Ys.shape[1]): Y = Ys[:, i] clf = None if model_name == 'lasso': clf = linear_model.Lasso(alpha=alpha) elif model_name == 'xgb': clf = xgb.XGBRegressor(max_depth=xgb_depth, n_estimators=xgb_trees) elif model_name == 'ann': clf = MLPRegressor(solver=nn_solver, hidden_layer_sizes=nn_size, random_state=0) clf.fit(X, Y) clf_models.append(clf) # multi-task: train one model for predicting all resources elif mode == 'multi': if model_name == 'lasso': clf = linear_model.MultiTaskLasso(alpha=alpha) elif model_name == 'ann': clf = MLPRegressor(solver=nn_solver, hidden_layer_sizes=nn_size, random_state=0) clf.fit(X, Ys) clf_models.append(clf) # return the trained model(s) return clf_models
def multiTaskLasso_reg(): """ 多任务 lasso 多元回归稀疏系数的线性模型 y 是一个 (n_samples, n_tasks) 的二维数组,其约束条件和其他回归问题(也称为任务)是一样的,都是所选的特征值。 """ rng = np.random.RandomState(42) n_samples, n_features, n_tasks = 100, 30, 40 n_relevant_features = 5 coef = np.zeros((n_tasks, n_features)) times = np.linspace(0, 2 * np.pi, n_tasks) for k in range(n_relevant_features): coef[:, k] = np.sin((1. + rng.randn(1)) * times + 3 * rng.randn(1)) X = rng.randn(n_samples, n_features) Y = np.dot(X, coef.T) + rng.randn(n_samples, n_tasks) coef_lasso_ = np.array([linear_model.Lasso(alpha=0.5).fit(X, y).coef_ for y in Y.T]) coef_multi_task_lasso_ =linear_model.MultiTaskLasso(alpha=1.).fit(X, Y).coef_ fig = plt.figure(figsize=(8, 5)) plt.subplot(1, 2, 1) plt.spy(coef_lasso_) plt.xlabel('Feature') plt.ylabel('Time (or Task)') plt.text(10, 5, 'Lasso') plt.subplot(1, 2, 2) plt.spy(coef_multi_task_lasso_) plt.xlabel('Feature') plt.ylabel('Time (or Task)') plt.text(10, 5, 'MultiTaskLasso') fig.suptitle('Coefficient non-zero location') feature_to_plot = 0 plt.figure() lw = 2 plt.plot(coef[:, feature_to_plot], color='seagreen', linewidth=lw,label='Truth Value') plt.plot(coef_lasso_[:, feature_to_plot], color='cornflowerblue', linewidth=lw,label='Lasso') plt.plot(coef_multi_task_lasso_[:, feature_to_plot], color='gold', linewidth=lw,label='MultiTaskLasso') plt.legend(loc='upper center') plt.axis('tight') plt.ylim([-1.1, 1.1]) plt.show()
def dtc05(self): #将y转化为一维形式:self.y_train,self.y_test self.y01_train = list() self.y01_test = list() for a in range(len(self.y_train)): self.y01_train.append(self.y_train[a][0]) for b in range(len(self.y_test)): self.y01_test.append(self.y_test[b][0]) if not self.mu_edit.text().strip(): self.mu_alpha = 1.0 else: self.mu_alpha = float(self.mu_edit.text()) #LR算法实现 self.clf_mu = linear_model.MultiTaskLasso(alpha = self.mu_alpha) self.clf_mu.fit(self.x_train, self.y01_train) self.y_pred = self.clf_mu.predict(self.x_test) self.x_pred = self.clf_mu.predict(self.x_train) #设置值 self.stab(self.mu_table02, self.mu_table03) self.eetab(self.mu_table01)
def train_models(mod, save=True, cutoff=0.999, percent=50, plot=True, scale=False): if mod == 'linear': clf = linear_model.LinearRegression(n_jobs=-1) elif mod == 'lasso': clf = linear_model.Lasso(alpha=1000, max_iter=10000, tol=0.001, normalize=True, positive=True) elif mod == 'lassolars': clf = linear_model.LassoLars(alpha=0.001) elif mod == 'multilasso': clf = linear_model.MultiTaskLasso(alpha=0.1) elif mod == 'ridgeCV': clf = linear_model.RidgeCV(alphas=[0.01, 0.1, 1.0, 10.0]) elif mod == 'ridge': clf = linear_model.Ridge(alpha=[1000]) elif mod == 'bayes': clf = linear_model.BayesianRidge() elif mod == 'huber': clf = linear_model.HuberRegressor() elif mod == 'poly': #clf = poly_clf() clf = PolynomialFeatures(degree=2) clf, continuum = train(clf, mod, save=save, cutoff=cutoff, percent=percent, plot=plot, scale=scale) return clf, continuum
def __init__(self, data, classifier='linear', save=True, load=False, fname='FASMA_ML.pkl'): self.classifier = classifier self.data = data self.save = save self.load = load self.fname = fname self.X_train, self.y_train = data.X, data.y if self.classifier == 'linear': self.clf = linear_model.LinearRegression(n_jobs=-1) elif self.classifier == 'lasso': self.clf = linear_model.Lasso(alpha=0.00001) elif self.classifier == 'lassolars': self.clf = linear_model.LassoLars(alpha=1000) elif self.classifier == 'multilasso': self.clf = linear_model.MultiTaskLasso(alpha=1000) elif self.classifier == 'ridgeCV': self.clf = linear_model.RidgeCV(alphas=[0.1, 1.0, 10.0, 100]) elif self.classifier == 'ridge': self.clf = linear_model.Ridge(alpha=10) elif self.classifier == 'bayes': self.clf = linear_model.BayesianRidge() elif self.classifier == 'huber': self.clf = linear_model.HuberRegressor() # Train the classifier if not self.load: t = time() self.train_classifier() print('Trained classifier in {}s'.format(round(time() - t, 2))) else: with open(self.fname, 'rb') as f: self.clf = cPickle.load(f)
# std_Y = labels #Standardizes features xscaler = preprocessing.StandardScaler().fit(features) std_X = xscaler.transform(features) # std_X = features # In[ ]: test_size = 0.25 num_perm = 1000 num_alpha = 50 cv = ShuffleSplit(n_splits=num_perm, test_size=test_size, random_state=2909591) lrp = linear_model.MultiTaskLasso(max_iter=10000, normalize=False) param_range = np.logspace(-3, 1, num_alpha) path = np.zeros((std_Y.shape[1], num_alpha, std_X.shape[1])) train_scores_mean = np.zeros((num_alpha)) train_scores_std = np.zeros((num_alpha)) for i, v in enumerate(param_range): lrp.set_params(alpha=v) lrp.fit(std_X, std_Y) path[:, i, :] = lrp.coef_ cvs = cross_val_score(lrp, std_X, std_Y, cv=cv, scoring='neg_mean_squared_error')
import pytest from sklearn import linear_model import numpy import chaospy LINEAR_MODELS = { "none": None, "linear": linear_model.LinearRegression(fit_intercept=False), "elastic_net": linear_model.MultiTaskElasticNet(alpha=0.0001, fit_intercept=False), "lasso": linear_model.MultiTaskLasso(alpha=0.001, fit_intercept=False), "lasso_lars": linear_model.LassoLars(alpha=0.0001, fit_intercept=False), "lars": linear_model.Lars(n_nonzero_coefs=10, fit_intercept=False), "matching_pursuit": linear_model.OrthogonalMatchingPursuit(n_nonzero_coefs=10, fit_intercept=False), "ridge": linear_model.Ridge(alpha=0.1, fit_intercept=False), } @pytest.fixture def samples(joint): return joint.sample(1000, rule="sobol")
def __init__(self, args): alpha = 1 - float(args.sparse) if args.sparse is not None else 1.0 self.linear = linear_model.MultiTaskLasso(alpha=alpha)
def estimate_baseline_lasso(Ton, Tamb=273.0, order=0, timechunk=80, cv=None, progress=True, **kwargs): """Estimate ultra-wideband baseline using the multi-task LASSO. Args: Ton (xarray.DataArray): Calibrated De:code array of ON point. Tamb (float, optional): Ambient temperature used in calibration. order (int, optional): Maximum order of a polynomial function which is assumed to represent a continuum emission spectrum. Default is 0 (flat continuum emission). timechunk (int, optional): The number of samples to be used for a multi-task LASSO. Default is 80 (~0.5 s for DESHIMA data). cv (int, optional): The number of fold for cross validation (CV). If not spacified, CV is not conducted (default alpha is used). progress (bool, optional): If True, then a progress bar is shown. kwargs (dict, optional): Keyword arguments for model initialization. Returns: Tbase (xarray.DataArray): De:code array of estimated baseline. """ freq = np.asarray(Ton.kidfq).copy() slope = fn.models._calculate_dtau_dpwv(freq) freq -= np.median(freq) N_freq = len(freq) N_poly = order + 1 X = np.zeros([N_freq, N_poly + 1]) X[:, 0] = slope / np.linalg.norm(slope) for i in range(N_poly): poly = freq**i X[:, i + 1] = poly / np.linalg.norm(poly) default_kwargs = {'fit_intercept': False} kwargs = {**default_kwargs, **kwargs} n_chunk = int(len(Ton) / timechunk) is_cv = cv is not None and cv > 1 if is_cv: model = linear_model.MultiTaskLassoCV(cv=cv, **kwargs) else: model = linear_model.MultiTaskLasso(**kwargs) with tqdm(total=n_chunk, disable=not progress) as bar: def func(Ton_): model.fit(X, Ton_.values.T) Tbase_ = np.outer(model.coef_[:, 0], X[:, 0]) Tbase_ = dc.full_like(Ton_, Tbase_) for i in range(N_poly + 1): Tbase_.coords[f'basis_{i}'] = 'ch', X[:, i] Tbase_.coords[f'coeff_{i}'] = 't', model.coef_[:, i] if is_cv: alpha = np.full(len(Ton_), model.alpha_) Tbase_.coords['alpha'] = 't', alpha bar.update(1) return Tbase_ return Ton.groupby_bins('t', n_chunk).apply(func)
def multi_lasso_plot(X,CO_response,ethylene_response,supress=False): """ Multi Task Lasso # X is the (m x n) feature vector. This can be an array or a pandas data frame. # CO_response is the m dimensional vector with the true CO values # ethylene_response is the m dimensional vector with the true ethylene values #If suppress is true, the plots are supressed. """ from sklearn import linear_model # Create an array-type matrix with CO and ethylene values. # This is just the format MultiTaskLasso takes y=[] for i in range(0,395): y.append([CO_response[i],ethylene_response[i]]) model2 = linear_model.MultiTaskLasso(alpha=1200) #Create MultiTaskLasso object. n=int(len(CO_response)*0.7) #70 % for training if isinstance(X,pd.core.frame.DataFrame): X=np.asarray(X) X_train=X[:n,:] y_train=y[:n] X_test=X[n:,:] y_test=y[n:] model2.fit(X_train, y_train) ypred=model2.predict(X_test) #ypred=np.matmul(np.asarray(X),model2.coef_.T) #Multiply matrices out #Collect predicted values co_pred=[] eth_pred=[] for i in range(0,len(ypred)): co_pred.append(ypred[i][0]) eth_pred.append(ypred[i][1]) # Add intercepts #co_pred=[x+model2.intercept_[0] for x in co_pred] #eth_pred=[x+model2.intercept_[1] for x in eth_pred] if supress==False : plt.figure(1,figsize=(30,20)) plt.plot(CO_response[n:],color='blue') plt.plot(co_pred,color='red') plt.legend(['CO_pred', 'CO_true'],fontsize=36) plt.figure(2,figsize=(30,20)) plt.plot(ethylene_response[n:],color='orange') plt.plot(eth_pred,color='purple') plt.legend(['eth_pred', 'eth_true'],fontsize=36) plt.show() return [co_pred,eth_pred]
def get_regression_estimators(r, regression_models): if r == 'ARDRegression': regression_models[r] = linear_model.ARDRegression() elif r == 'BayesianRidge': regression_models[r] = linear_model.BayesianRidge() elif r == 'ElasticNet': regression_models[r] = linear_model.ElasticNet() elif r == 'ElasticNetCV': regression_models[r] = linear_model.ElasticNetCV() elif r == 'HuberRegressor': regression_models[r] = linear_model.HuberRegressor() elif r == 'Lars': regression_models[r] = linear_model.Lars() elif r == 'LarsCV': regression_models[r] = linear_model.LarsCV() elif r == 'Lasso': regression_models[r] = linear_model.Lasso() elif r == 'LassoCV': regression_models[r] = linear_model.LassoCV() elif r == 'LassoLars': regression_models[r] = linear_model.LassoLars() elif r == 'LassoLarsCV': regression_models[r] = linear_model.LassoLarsCV() elif r == 'LassoLarsIC': regression_models[r] = linear_model.LassoLarsIC() elif r == 'LinearRegression': regression_models[r] = linear_model.LinearRegression() elif r == 'LogisticRegression': regression_models[r] = linear_model.LogisticRegression() elif r == 'LogisticRegressionCV': regression_models[r] = linear_model.LogisticRegressionCV() elif r == 'MultiTaskElasticNet': regression_models[r] = linear_model.MultiTaskElasticNet() elif r == 'MultiTaskElasticNetCV': regression_models[r] = linear_model.MultiTaskElasticNetCV() elif r == 'MultiTaskLasso': regression_models[r] = linear_model.MultiTaskLasso() elif r == 'MultiTaskLassoCV': regression_models[r] = linear_model.MultiTaskLassoCV() elif r == 'OrthogonalMatchingPursuit': regression_models[r] = linear_model.OrthogonalMatchingPursuit() elif r == 'OrthogonalMatchingPursuitCV': regression_models[r] = linear_model.OrthogonalMatchingPursuitCV() elif r == 'PassiveAggressiveClassifier': regression_models[r] = linear_model.PassiveAggressiveClassifier() elif r == 'PassiveAggressiveRegressor': regression_models[r] = linear_model.PassiveAggressiveRegressor() elif r == 'Perceptron': regression_models[r] = linear_model.Perceptron() elif r == 'RANSACRegressor': regression_models[r] = linear_model.RANSACRegressor() elif r == 'Ridge': regression_models[r] = linear_model.Ridge() elif r == 'RidgeClassifier': regression_models[r] = linear_model.RidgeClassifier() elif r == 'RidgeClassifierCV': regression_models[r] = linear_model.RidgeClassifierCV() elif r == 'RidgeCV': regression_models[r] = linear_model.RidgeCV() elif r == 'SGDClassifier': regression_models[r] = linear_model.SGDClassifier() elif r == 'SGDRegressor': regression_models[r] = linear_model.SGDRegressor() elif r == 'TheilSenRegressor': regression_models[r] = linear_model.TheilSenRegressor() else: print( r + " is an unsupported regression type. Check if you have misspelled the name." )
def __init__(self, alpha): self.alpha = alpha self.clf = linear_model.MultiTaskLasso(alpha=self.alpha)
from sklearn import linear_model from sklearn import datasets from sklearn.model_selection import train_test_split from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score, explained_variance_score import matplotlib.pyplot as plt import numpy as np # 多任务岭回归 x, y = datasets.make_regression(n_samples=1000, n_features=1, n_targets=10, noise=10, random_state=0) x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=0) # 弹性网络 reg = linear_model.MultiTaskElasticNet(0.1) # 多任务弹性网络回归 reg = linear_model.MultiTaskLasso(0.1) # 多任务lasso回归 reg = linear_model.MultiTaskLassoCV(0.1) # 多任务lasso回归 reg = linear_model.MultiTaskElasticNetCV(0.1) # 多任务弹性网络回归 reg.fit(x_train, y_train) print(reg.coef_, reg.intercept_) y_pred = reg.predict(x_test) # 平均绝对误差 print(mean_absolute_error(y_test, y_pred)) # 均方误差 print(mean_squared_error(y_test, y_pred))
"elnet": lm.ElasticNet(), "sgd_class": lm.SGDClassifier(), "sgd_reg": lm.SGDRegressor(), "ridge": lm.Ridge(), "gp": GaussianProcess(), "tree_reg": tree.DecisionTreeRegressor(), "tree_class": tree.DecisionTreeClassifier(), "extra_class": ensemble.ExtraTreesClassifier(), "extra_reg": tree.ExtraTreeRegressor(), "nn_class": KNeighborsClassifier(), "rf_reg": ensemble.RandomForestRegressor(), "rf_class": ensemble.RandomForestClassifier(), "svc": svm.SVC(), "linear_svc": svm.LinearSVC(), "logistic_reg": lm.LogisticRegression(), "multitask_lasso": lm.MultiTaskLasso(), "linear_reg": lm.LinearRegression() } MULTITASK_MODELS = ["multitask_lasso"] ############################################################################### # Helper functions ############################################################################### def get_model_dict(theta, cur_fold, cur_exper, responses, seed,
plt.plot(user_forecast_response, label="predicted") plt.plot(actual_values_response, label="actual") plt.legend() plt.title("1 January 2016") plt.ylabel("Solar Power (W/m2)") plt.xlabel("Hour") #%% [markdown] # ElasticNet is underfitting. #%% [markdown] # ## MultiTask Lasso Regression #%% # training a multi-task lasso model _prng = np.random.RandomState(42) lasso_regression = linear_model.MultiTaskLasso(random_state=_prng) lasso_regression.fit(transformed_training_features, training_target) #%% # measure training error _predictions = lasso_regression.predict(transformed_training_features) np.sqrt(metrics.mean_squared_error(training_target, _predictions)) #%% # measure validation error _predictions = lasso_regression.predict(transformed_validation_features) np.sqrt(metrics.mean_squared_error(validation_target, _predictions)) #%% # user requests forecast for 1 January 2016 which we predict using data from 31 December 2015! user_forecast_request = transformed_training_features[[-1], :]
import matplotlib.pyplot as plt import numpy as np from sklearn import datasets from sklearn.model_selection import train_test_split from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score, explained_variance_score x, y = datasets.make_regression(n_samples=1000, n_features=1, n_targets=10, noise=10, random_state=0) x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=0) reg = linear_model.MultiTaskLasso(0.1) reg.fit(x_train, y_train) print(reg.coef_, reg.intercept_) y_pred = reg.predict(x_test) # 平均绝对误差 print(mean_absolute_error(y_test, y_pred)) # 均方绝对误差 print(mean_squared_error(y_test, y_pred)) # R2评分 print(r2_score(y_test, y_pred)) # explained_variance
####======================================================================== ## fill in the incomp tensor (with tissue mean) --> for group LASSO ## here the global mean is just 0, as we take Z score for all samples of multi-tissues for k in range(K): for n in range(N): if math.isnan(Y_train[k][n][0]): Y_train[k][n] = np.zeros(J) ####======================================================================== ## solve the group LASSO beta_tensor = [] for j in range(J): Data = m_factor # X: (n_samples, n_features) Target = Y_train[:, :, j].T # Y: (n_samples, n_tasks) clf = linear_model.MultiTaskLasso(alpha=0.01) clf.fit(Data, Target) #clf.coef_ # (n_tasks, n_features) #clf.intercept_ # (n_tasks,) intercept = (np.array([clf.intercept_])).T beta = np.concatenate((clf.coef_, intercept), axis=1) beta_tensor.append(beta) beta_tensor = np.array(beta_tensor) # beta_tensor: (J, K, (D+1)) init_beta_cellfactor2 = np.transpose(beta_tensor, (1, 2, 0)) print "init_beta_cellfactor2 shape (exp: K, D+1, J):", print init_beta_cellfactor2.shape ## checked above code (Mar.24)