def fancy_text_model(x_train, y_train, x_test, x_valid, cache_name, use_cache=False): if use_cache: fhand = open(cache_name, 'r') data_dict = pickle.load(fhand) return data_dict['test_pred'], data_dict['valid_pred'] np.random.seed(seed=123) model = PassiveAggressiveRegressor(n_iter=100, C=1, shuffle=True, random_state=123) model.fit(x_train, y_train) test_pred = model.predict(x_test) valid_pred = model.predict(x_valid) data_dict = {'test_pred': test_pred, 'valid_pred': valid_pred} fhand = open(cache_name, 'w') pickle.dump(data_dict, fhand) fhand.close() return test_pred, valid_pred
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_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 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 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 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 range(50): reg.partial_fit(data, y_bin) pred = reg.predict(data) assert_less(np.mean((pred - y_bin) ** 2), 1.7)
class _PassiveAggressiveRegressorImpl: def __init__(self, **hyperparams): self._hyperparams = hyperparams self._wrapped_model = Op(**self._hyperparams) def fit(self, X, y=None): if y is not None: self._wrapped_model.fit(X, y) else: self._wrapped_model.fit(X) return self def predict(self, X): return self._wrapped_model.predict(X)
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 test_regressor_mse(): y_bin = y.copy() y_bin[y != 1] = -1 for data in (X, X_csr): for fit_intercept in (True, False): for average in (False, True): reg = PassiveAggressiveRegressor( C=1.0, fit_intercept=fit_intercept, random_state=0, average=average, max_iter=5) reg.fit(data, y_bin) pred = reg.predict(data) assert_less(np.mean((pred - y_bin) ** 2), 1.7) if average: assert_true(hasattr(reg, 'average_coef_')) assert_true(hasattr(reg, 'average_intercept_')) assert_true(hasattr(reg, 'standard_intercept_')) assert_true(hasattr(reg, 'standard_coef_'))
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( C=1.0, fit_intercept=True, random_state=0, average=average, max_iter=100) for t in range(50): reg.partial_fit(data, y_bin) pred = reg.predict(data) assert_less(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 test_regressor_mse(): y_bin = y.copy() y_bin[y != 1] = -1 for data in (X, X_csr): for fit_intercept in (True, False): for average in (False, True): reg = PassiveAggressiveRegressor( C=1.0, fit_intercept=fit_intercept, random_state=0, average=average, max_iter=5) reg.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 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(C=1.0, fit_intercept=True, random_state=0, average=average) for t in range(50): reg.partial_fit(data, y_bin) pred = reg.predict(data) assert_less(np.mean((pred - y_bin) ** 2), 1.7) if average: assert_true(hasattr(reg, 'average_coef_')) assert_true(hasattr(reg, 'average_intercept_')) assert_true(hasattr(reg, 'standard_intercept_')) assert_true(hasattr(reg, 'standard_coef_'))
n_features=5, random_state=1000) # Create the model par = PassiveAggressiveRegressor(C=0.01, loss='squared_epsilon_insensitive', epsilon=0.001, max_iter=2000, random_state=1000) # Fit the model incrementally and collect the squared errors squared_errors = [] for (x, y) in zip(X, Y): par.partial_fit(x.reshape(1, -1), y.ravel()) y_pred = par.predict(x.reshape(1, -1)) squared_errors.append(np.power(y_pred - y, 2)) # Show the error plot fig, ax = plt.subplots(figsize=(18, 8)) ax.plot(squared_errors) ax.set_xlabel('Sample') ax.set_ylabel('Squared error') ax.grid() plt.show() # Repeat the example with a discontinuous dataset X1, Y1 = make_regression(n_samples=nb_samples_2, n_features=5,
def main(): X, y, coef = make_regression(1000, 200, 10, 1, noise=0.05, coef=True, random_state=42) # X = np.column_stack((X, np.ones(X.shape[0]))) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42) # sca = StandardScaler() # sca.fit(X_train) # X_train = sca.transform(X_train) # X_test = sca.transform(X_test) # print X.shape # print y.shape # print coef.shape param_grid = { "C": [0.0000001, 0.000001, 0.00001, 0.0001, 0.001, 0.01, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 10, 100, 1000], "epsilon": [0.0001, 0.001, 0.01, 0.1]} param_grid_kern = { "C": [0.0000001, 0.000001, 0.00001, 0.0001, 0.001, 0.01, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 10, 100, 1000], "epsilon": [0.0001, 0.001, 0.01, 0.1], "gamma": [0.00001, 0.0001, 0.001, 0.01, 0.1, 1, 10, 100]} # "loss": ["pa", "pai", "paii"]}} my_pa = PARegressor(loss="paii", C=1, epsilon=0.001, n_iter=1, fit_intercept=False) # # search = GridSearchCV(my_pa, param_grid, # scoring='mean_absolute_error', n_jobs=8, iid=True, refit=True, cv=5, # verbose=1) # search.fit(X_train, y_train) # print search.best_params_ my_pa.fit(X_train, y_train) print my_pa.coef_ # y_preds = search.predict(X_test) y_preds = my_pa.predict(X_test) mae_my_pa = mean_absolute_error(y_test, y_preds) print "My PA MAE = %2.4f" % mae_my_pa my_kpa_linear = KernelPARegressor(kernel="linear", loss="paii", C=1, epsilon=0.001, n_iter=1, fit_intercept=False) my_kpa_linear.fit(X_train, y_train) print "alphas", len(my_kpa_linear.alphas_), my_kpa_linear.alphas_ y_preds = my_kpa_linear.predict(X_test) mae_kpa_linear = mean_absolute_error(y_test, y_preds) print "My KPA linear MAE = %2.4f" % mae_kpa_linear my_kpa_rbf = KernelPARegressor(kernel="rbf", loss="paii", gamma=0.001, C=1, epsilon=0.001, n_iter=1, fit_intercept=False) # search = GridSearchCV(my_kpa_rbf, param_grid_kern, # scoring='mean_absolute_error', n_jobs=8, iid=True, refit=True, cv=5, # verbose=1) # search.fit(X_train, y_train) my_kpa_rbf.fit(X_train, y_train) print "alphas", len(my_kpa_rbf.alphas_), my_kpa_rbf.alphas_ print "support", len(my_kpa_rbf.support_) # print "alphas", len(search.best_estimator_.alphas_) # , my_kpa_rbf.alphas_ # print "support", len(search.best_estimator_.support_) # print search.best_params_ y_preds = my_kpa_rbf.predict(X_test) # y_preds = search.predict(X_test) mae_my_kpa = mean_absolute_error(y_test, y_preds) print "My Kernel PA MAE = %2.4f" % mae_my_kpa # print search.best_estimator_ # print np.corrcoef(search.best_estimator_.coef_, coef) # param_grid = { # "C": [0.001, 0.01, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 10, # 100, 1000, 10000], # "epsilon": [0.0001, 0.001, 0.01, 0.1], # # "loss": ["epsilon_insensitive", "squared_epsilon_insensitive"]} # "loss": ["squared_epsilon_insensitive"]} # search = GridSearchCV(PassiveAggressiveRegressor(fit_intercept=True), # param_grid, scoring='mean_absolute_error', n_jobs=8, iid=True, # refit=True, cv=5, verbose=1) # search.fit(X_train, y_train) sk_pa = PassiveAggressiveRegressor(loss="squared_epsilon_insensitive", C=1, epsilon=0.001, n_iter=1, fit_intercept=False, warm_start=True) for i in xrange(X_train.shape[0]): # for x_i, y_i in zip(X_train, y_train): x = np.array(X_train[i], ndmin=2) y = np.array(y_train[i], ndmin=1) # print x.shape # print y sk_pa.partial_fit(x, y) # sk_pa.fit(X_train, y_train) # y_preds = search.predict(X_test) y_preds = sk_pa.predict(X_test) mae_sk_pa = mean_absolute_error(y_preds, y_test) print "Sklearn PA MAE = %2.4f" % mae_sk_pa
暂时未知 对于算法的具体过程还不是很清楚,所以暂时作为一个黑箱吧 ''' rg = PassiveAggressiveRegressor(C=1.0, fit_intercept=True, n_iter=5, shuffle=True, verbose=0, loss='epsilon_insensitive', epsilon=0.1, random_state=None, warm_start=False) rg.fit(X_train, Y_train) rg.partial_fit(X_train, Y_train) # 增量学习 Y_pre = rg.predict(X_test) rg.score(X_test, Y_test) rg.coef_ rg.intercept_ ''' C 正则化项系数 fit_intercept 是否计算截距 n_iter 迭代次数 shuffle 是否洗牌 verbose 哈 loss 损失函数 epsilon 阈值 random_state 随机器 warm_start=False 新的迭代开始后,是否用上一次的最后结果作为初始化 '''
br.fit(x, y) br_sts_scores = br.predict(xt) # Elastic Net print 'elastic net' enr = ElasticNet() #enr.fit(x[:, np.newaxis], y) #enr_sts_scores = enr.predict(xt[:, np.newaxis]) enr.fit(x, y) enr_sts_scores = enr.predict(xt) # Passive Aggressive Regression print 'passive aggressive' par = PassiveAggressiveRegressor() par.fit(x, y) par_sts_scores = par.predict(xt) #par.fit(x[:, np.newaxis], y) #par_sts_scores = par.predict(xt[:, np.newaxis]) # RANSAC Regression print 'ransac' ransac = RANSACRegressor() #ransac.fit(x[:, np.newaxis], y) #ransac_sts_scores = ransac.predict(xt[:, np.newaxis]) ransac.fit(x, y) ransac_sts_scores = ransac.predict(xt) # Logistic Regression print 'logistic' lgr = LogisticRegression() #lgr.fit(x[:, np.newaxis], y)
axis='columns') #Convert features to sparse matrices validation_features = csr_matrix(validation_features.values) #Combine sparse arrays validation = hstack([ validation_summary_dtm, validation_text_dtm, validation_features ]) #Scale validation = scaler.transform(validation) #Predict validation_pred_chunk = lm.predict(validation) validation_pred.extend(validation_pred_chunk) validation_score.extend(list(validation_score_chunk)) #Evaluate and save validation score fold_scores.append( mean_squared_error(validation_score, validation_pred)) ###Train on entire evaluation set #Instantiate hashing vectorizers text_vectorizer = HashingVectorizer(ngram_range=(1, 3), n_features=2**20) summary_vectorizer = HashingVectorizer(ngram_range=(1, 3), n_features=2**20)
# Filter by coeficient variation var_thres = VarianceThreshold(best_var).fit(X_train_pre) X_train_pre = var_thres.transform(X_train_pre) X_test_pre = var_thres.transform(X_test_pre) for gene in genes: # Assemble prediction variables X_train = X_train_pre y_train = train_ess.ix[:, gene] X_test = X_test_pre # Feature selection fs = SelectKBest(f_regression, k=best_k).fit(X_train, y_train) X_train = fs.transform(X_train) X_test = fs.transform(X_test) # Estimation clf = PassiveAggressiveRegressor(epsilon=best_epsilon, n_iter=best_n_iter).fit(X_train, y_train) y_pred = clf.predict(X_test) # Store results predictions.ix[gene] = y_pred print gene filename = save_gct_data(predictions, submission_filename_prefix) print '[DONE]: Saved to file ' + filename submit_solution(filename, filename.split('/')[1], ev_code_sc1) print '[SUBMITED]'
name_folder = folder.split("/")[6] train_data = np.array(pd.read_csv('train_data.csv', sep= ';')) test_data = np.array(pd.read_csv('test_data.csv', sep= ';')) train_labels = np.array(pd.read_csv('train_labels.csv', sep= ';')) test_labels = np.array(pd.read_csv('test_labels.csv', sep= ';')) inicio = time.time() # importar o modelo de regressão from sklearn.linear_model import PassiveAggressiveRegressor # treinar o modelo no conjunto de dados regression = PassiveAggressiveRegressor().fit(train_data, train_labels) # prever predictions_labels = regression.predict(test_data) fim = time.time() df_time = pd.DataFrame({'Execution Time:' : [fim-inicio]}) output_path = os.path.join('/home/isadorasalles/Documents/Regressao/passive_aggressive', 'time_'+name_folder) df_time.to_csv(output_path, sep=';') from sklearn import metrics df_metrics = pd.DataFrame({'Mean Absolute Error' : [metrics.mean_absolute_error(test_labels, predictions_labels)], 'Mean Squared Error' : [metrics.mean_squared_error(test_labels, predictions_labels)], 'Root Mean Squared Error': [np.sqrt(metrics.mean_squared_error(test_labels, predictions_labels))], 'R2 Score': [metrics.r2_score(test_labels, predictions_labels)]}) output_path = os.path.join('/home/isadorasalles/Documents/Regressao/passive_aggressive', 'metrics_'+name_folder) df_metrics.to_csv(output_path, sep=';')
#y = [0.5, 2.5] #clf = MLPRegressor(hidden_layer_sizes=(1000,), random_state=1, max_iter=1, warm_start=True) clf = PassiveAggressiveRegressor(random_state=1, warm_start=True, max_iter=100) st = time.time() ttList = [] for i in range(len(Xtrain)): tt = time.time() clf = clf.partial_fit(Xtrain, Ytrain) print(i / len(Xtrain)) ttList.append(time.time() - tt) trainTime = time.time() - st joblib.dump(clf, 'currentModel.mod') pred = [] st = time.time() for x in range(len(Xtest)): pred.append(clf.predict([Xtest[x]])) score = metrics.mean_absolute_error(Ytest, clf.predict(Xtest)) predictTime = time.time() - st print("Time to import: " + str(importTime)) print("Time to Read File: " + str(readFileTime)) print("Time to split and Scale Data: " + str(scaleTime)) print("Time to train: " + str(trainTime)) print("Time to predict: " + str(time.time() - st)) print("Mean ABS error: %f" % score) fig, ax = plt.subplots() ax.plot(pred) ax.plot(Ytest) plt.show()
ARDRegression BayesianRidge ElasticNet ElasticNetCV Hinge Huber Lars LarsCV Lasso LassoCV LassoLars LassoLarsCV LassoLarsIC PassiveAggressiveRegressor Ridge SGDRegressor LinearRegression ModifiedHuber MultiTaskElasticNet """ print "training using PassiveAggressiveRegressor" par = PassiveAggressiveRegressor() par.fit(quesparse,y) pred = par.predict(tquesparse) pred[pred<0] = 0 #for i in range(q): # temp = dict() # temp['__ans__'] = pred[i] # temp['question_key'] = tquestion_key[i] # print """{"__ans__": %s, "question_key":"%s"}""" % (temp['__ans__'], temp["question_key"])
cfscaler = preprocessing.StandardScaler().fit(contextfollowers) tfscaler = preprocessing.StandardScaler().fit(topicsfollowers) quesparse = quevectorizer.fit_transform(question) topsparse = topvectorizer.fit_transform(topics) cfscaled = cfscaler.transform(contextfollowers) tfscaled = tfscaler.transform(topicsfollowers) tquesparse = quevectorizer.transform(tquestion) ttopsparse = topvectorizer.transform(ttopics) tcfscaled = cfscaler.transform(tcontextfollowers) ttfscaled = tfscaler.transform(ttopicsfollowers) par = PassiveAggressiveRegressor() par.fit(topsparse, y) pred = par.predict(ttopsparse) pred[pred < 0] = 0 temp = pl.figure("train y") temp = pl.subplot(2, 1, 1) temp = pl.hist(y, 1000) temp = pl.subplot(2, 1, 2) yy = y.copy() yy[yy == 0] = 1 temp = pl.hist(np.log10(yy), 1000) temp = pl.figure("test y") temp = pl.subplot(4, 1, 1) temp = pl.hist(pred, 1000) temp = pl.subplot(4, 1, 2) yy = pred.copy()
# Assemble prediction variables X_train = X_train_pre.loc[:, important_features_top_100] X_test = X_test_pre.loc[:, important_features_top_100] for gene in prioritized_genes: y_train = train_ess.ix[:, gene] y_preds_test = [] y_preds_scores = [] # Training cv = ShuffleSplit(len(y_train), n_iter=5) for train_i, test_i in cv: clf = PassiveAggressiveRegressor(epsilon=0.01, n_iter=7).fit(X_train.ix[train_i, :], y_train[train_i]) y_preds_scores.append(spearm_cor_func(clf.predict(X_train.ix[test_i, :]), y_train[test_i])) y_preds_test.append(clf.predict(X_test)) y_preds_scores = Series(y_preds_scores) y_preds_test = DataFrame(y_preds_test) # Predict y_pred = np.mean(y_preds_test[y_preds_scores.notnull()], axis=0).values print gene, X_train.shape # Store results predictions.ix[gene] = y_pred filename_gct = save_gct_data(predictions, submission_filename_prefix) print '[DONE]: Saved to file ' + filename_gct
from sklearn.model_selection import train_test_split setX, setY = importcsv() X_train, X_test, y_train, y_test = train_test_split(setX, setY, test_size=0.01, random_state=42) regr = PassiveAggressiveRegressor(max_iter=100, random_state=0,tol=1e-3) regr.fit(X_train, y_train) #PassiveAggressiveRegressor(C=1.0, average=False, early_stopping=False,epsilon=0.1, fit_intercept=True, loss='epsilon_insensitive', max_iter=100, n_iter_no_change=5, random_state=0,shuffle=True, tol=0.001, validation_fraction=0.1,verbose=0, warm_start=False) print(regr.score(X_test, y_test)) regr.densify() pred = regr.predict(X_test) result=[] for k in range(len(pred)): if pred[k]<0.1: value = 0 else: value =1 if value == y_test[k]: result.append('O') else: result.append('X') print(pred)
train, test = shuffle(train).astype(np.float32), shuffle(test).astype(np.float32) train_x, train_y = train.iloc[:, 1:], train.iloc[:, 0] test_x, test_y = test.iloc[:, 1:], test.iloc[:, 0] dg.add_drift(0.5, True) n, d = train_x.shape _n += n for i in range(0, n, batch_size): count += 1 pa.partial_fit(train_x[i:i + batch_size], train_y[i:i + batch_size]) sgd.partial_fit(train_x[i:i + batch_size], train_y[i:i + batch_size]) if i % 50 == 0 or i == n - 1: pred1 = pa.predict(test_x) pred2 = sgd.predict(test_x) mse1, mae1 = np.sqrt(mean_squared_error(test_y, pred1)), mean_absolute_error(test_y, pred1) mse2, mae2 = np.sqrt(mean_squared_error(test_y, pred2)), mean_absolute_error(test_y, pred2) pa_mse_arr.append(mse1) pa_mae_arr.append(mae1) sgd_mse_arr.append(mse2) sgd_mae_arr.append(mae2) count_arr.append(count) print("pa %f %f, sgd %f %f" % (mse1, mae1, mse2, mae2)) print("writing stats to directory : %s" % directory1) err_df = pd.DataFrame({"count": count_arr, "mse": pa_mse_arr, "mae": pa_mae_arr})
quesparse = quevectorizer.fit_transform(question) topsparse = topvectorizer.fit_transform(topics) cfscaled = cfscaler.transform(contextfollowers) tfscaled = tfscaler.transform(topicsfollowers) tquesparse = quevectorizer.transform(tquestion) ttopsparse = topvectorizer.transform(ttopics) tcfscaled = cfscaler.transform(tcontextfollowers) ttfscaled = tfscaler.transform(ttopicsfollowers) par = PassiveAggressiveRegressor() par.fit(topsparse,y) pred = par.predict(ttopsparse) pred[pred<0] = 0 temp = pl.figure("train y") temp = pl.subplot(2,1,1) temp = pl.hist(y,1000) temp = pl.subplot(2,1,2) yy = y.copy() yy[yy==0] = 1 temp = pl.hist(np.log10(yy),1000) temp = pl.figure("test y") temp = pl.subplot(4,1,1) temp = pl.hist(pred,1000) temp = pl.subplot(4,1,2)
# Elastic Net print 'elastic net' enr = ElasticNet() #enr.fit(x[:, np.newaxis], y) #enr_sts_scores = enr.predict(xt[:, np.newaxis]) enr.fit(x, y) enr_sts_scores = enr.predict(xt) # Passive Aggressive Regression print 'passive aggressive' par = PassiveAggressiveRegressor() par.fit(x, y) par_sts_scores = par.predict(xt) #par.fit(x[:, np.newaxis], y) #par_sts_scores = par.predict(xt[:, np.newaxis]) # RANSAC Regression print 'ransac' ransac = RANSACRegressor() #ransac.fit(x[:, np.newaxis], y) #ransac_sts_scores = ransac.predict(xt[:, np.newaxis]) ransac.fit(x, y) ransac_sts_scores = ransac.predict(xt) # Logistic Regression print 'logistic' lgr = LogisticRegression()
C=1.0, average=False, epsilon=0.1, fit_intercept=True, loss='epsilon_insensitive', max_iter=None, n_iter=None, shuffle=True, tol=None, verbose=0, warm_start=False) regr.fit(X, y) print(regr.score(x_train, y_train)) #Train Error: 32.86 #PassiveAggressiveRegressor() predictions = regr.predict(x_test) for i, prediction in enumerate(predictions): print 'Predicted: %s' % (prediction) ############################################################################################################ #Support Vector Machine Regression from sklearn import svm clf1 = svm.SVR(C=1.0, cache_size=200, coef0=0.0, degree=8, epsilon=0.1, gamma='auto', kernel='linear', max_iter=-1, shrinking=True,
# In[56]: model2.fit(x_train, y_train) # In[57]: model3.fit(x_train, y_train) # In[58]: pred1 = model1.predict(x_test) pred1 # In[59]: pred2 = model2.predict(x_test) pred2 # In[60]: pred3 = model3.predict(x_test) pred3 # In[61]: from sklearn.metrics import r2_score # In[62]: acc1 = r2_score(y_test, pred1) acc1 * 100