Python SVR.get_params方法代码示例

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import get_params [as 别名]
class SVR(PlayerModel):
    ### a wrapper for support vector regression using scikit-learn for this project
    def __init__(self):
        PlayerModel.__init__(self)
        # configure support vector regression and start training
        self.regr = SupportVectorRegression(kernel = 'linear', C = 1000)
        self.regr.fit(self.dataset_X_train, self.dataset_Y_train)
        print "Finish building player model."
        print "Parameters: ", self.regr.get_params()
        print "============================================================"

    def testScore(self, test_X):
        score = self.regr.predict(self.normalizeTest(test_X))
        return np.mean(score)

    def getParams(self):
        return self.regr.get_params()

    def visualize(self):
        x = np.zeros((10, self.col - 1))
        mean = self.dataset_X_train.mean(0)
        for i in range(10):
            x[i, :] = mean
        x[:, 0:1] = np.array([np.arange(0.0, 1.1, 0.11)]).T
        # print x
        y = self.regr.predict(x)
        # print y
        pyplot.scatter(self.dataset_X_train[:, 0:1], self.dataset_Y_train, c='k', label='data')
        pyplot.hold('on')
        pyplot.plot(x[:, 0:1], y, c = "r", label='Support Vector Regression')
        pyplot.xlabel('data collect from player')
        pyplot.ylabel('score')
        pyplot.title('Support Vector Regression')
        pyplot.legend()
        pyplot.show()

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import get_params [as 别名]
class sumSVR(object):

    def __init__(self, dim=None,  *args, **kwargs):
        self.dim = dim if dim is not None else 1

        w = kwargs.pop("w", None)

        self.kernel_functions = kwargs.pop("kernel_functions", [])
        if self.kernel_functions is not None:
            self.kernel_kwargs = kwargs.pop("kernel_kwargs", [{} for i in self.kernel_functions])
        else:
            self.kernel_kwargs = []

        kwargs["kernel"] = "precomputed"
        if w is None:
            w = np.ones(dim)

        self.w = w / np.linalg.norm(w)
        self.x = kwargs.pop('x', None)



        self.SVR = SVR(*args, **kwargs)

    def fit(self, x, y):
        self.x = x
        kernel_train = np.zeros((x.shape[0], x.shape[0]))
        for i in range(self.dim):
            x_i = x[:,i]
            kernel_i = self.kernel_functions[i](x_i, **self.kernel_kwargs[i])
            kernel_train += self.w[i] * kernel_i

        self.SVR.fit(kernel_train,y)

    def predict(self, x):
        kernel_test = np.zeros((x.shape[0], self.x.shape[0]))
        for i in range(self.dim):
            x_i = x[:,i]
            tr_i = self.x[:,i]
            kernel_i = self.kernel_functions[i](x_i, tr_i, **self.kernel_kwargs[i])
            kernel_test += self.w[i] * kernel_i

        return self.SVR.predict(kernel_test)

    def get_params(self, deep=False):
        params = self.SVR.get_params()
        params['dim'] = self.dim
        params['w'] = self.w
        params['kernel_functions'] = self.kernel_functions
        params['kernel_kwargs'] = self.kernel_kwargs
        params['x'] = self.x
        return params

    def set_params(self, **params):
        self.__init__(**params)
        return self

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import get_params [as 别名]

#.........这里部分代码省略.........
		self.features = self.features.values
		#choose different target variables for regression vs classification
		if kind == "regression":
			self.targets = self.trainLoanData['days_to_zero_dollars'].values
			self.y_test = self.testLoanData['days_to_zero_dollars'].values
		elif kind == "classification":
			self.targets = self.trainLoanData['loan_status'].values
			self.y_test = self.testLoanData['loan_status'].values

	def preprocess(self):
		(self.X_train, 
		 self.X_cv, 
		 self.y_train, 
		 self.y_cv) = dm.split_train_test(features=self.features, 
		 									targets=self.targets, 
		 									test_size=0.1)
		self.X_test = self.testLoanData.drop(['loan_status', 
											  'days_to_zero_dollars',
											  'id'], 1).values
		(self.X_train, self.X_cv) = dm.standardize_samples(self.X_train, 
														  self.X_cv)
		(self.X_train, self.X_cv) = dm.scale_samples_to_range(self.X_train, 
																self.X_cv)
		(self.X_test, _) = dm.standardize_samples(self.X_test, 
														  self.X_test)
		(self.X_test, _) = dm.scale_samples_to_range(self.X_test, 
																self.X_test)

	def define_dummy_classifier(self):
		self.clf = DummyClassifier()

	def define_rfr(self, n_estimators=10):
		self.regr = RandomForestRegressor(n_estimators=n_estimators, oob_score=True)
		print self.regr.get_params()

	def define_linear_regressor(self):
		self.regr = LinearRegression()
		print self.regr.get_params()

	def define_SVR(self, C=1, gamma=0.1):
		self.regr = SVR(C=C, gamma=gamma, verbose=3)
		print self.regr.get_params()

	def define_logistic_regressor(self, penalty="l2", C=1.0, class_weight=None):
		self.clf = LogisticRegression(penalty=penalty, 
									  C=C, 
									  class_weight=class_weight)
		print self.clf.get_params()

	def define_rfc(self, n_estimators=10):
		self.clf = RandomForestClassifier(n_estimators=n_estimators, oob_score=True)
		print self.clf.get_params()

	def train(self, kind="regression"):
		print "Fitting training data"
		if kind == "regression":
			self.regr.fit(self.X_train, self.y_train)
		elif kind == "classification":
			self.clf.fit(self.X_train, self.y_train)

	def predict(self, X, kind="regression"):
		if kind == "regression":
			self.prediction = self.regr.predict(X)
		elif kind == "classification":
			self.prediction = self.clf.predict(X)

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import get_params [as 别名]
    imax = np.argmin(mses)



    #fitter = AdaBoostRegressor(n_estimators=50)
    #fitter = gaussian_process.GaussianProcess()
    #fitter = LinearRegression()





    fitter2 = SVR(kernel='rbf',C=cs[imax])
    tec_validate_fit = fitter2.fit(data_train,tec_train).predict(data_validate)

    print fitter.get_params(deep=True)
    #coefs = fitter.coef_
    #print abs(coefs[0:6]).sum()
    #print abs(coefs[6:12]).sum()
    #print abs(coefs[12:18]).sum()
    #print coefs[-1]

    #MSE: 
    mse = np.mean((tec_validate_fit-tec_validate)**2)
    #print "smse",np.sqrt(mse)
    #print fitter.coef_


    #plot 
    import matplotlib.pyplot as plt

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import get_params [as 别名]
print ''

svc = SVC(gamma=0.001, kernel='linear')
print 'SVC config:'
print svc.get_params()
svc.fit(smr_train.feature_matrix, smr_train.labels)
svc_score_train = svc.score(smr_train.feature_matrix, smr_train.labels)
print 'SVC precision train: {}'.format(svc_score_train)
svc_score_test = svc.score(smr_test.feature_matrix, smr_test.labels)
print 'SVC precision test: {}'.format(svc_score_test)
# plot_learning_curve(svc, 'SVC Curve', smr_train.feature_matrix, smr_train.labels, n_jobs=4)
print ''

svr = SVR()
print 'SVR config:'
print svr.get_params()
svr.fit(smr_train.feature_matrix, smr_train.labels)
svr_score_train = svr.score(smr_train.feature_matrix, smr_train.labels)
print 'SVR precision train: {}'.format(svr_score_train)
svr_score_test = svr.score(smr_test.feature_matrix, smr_test.labels)
print 'SVR precision test: {}'.format(svr_score_test)
# plot_learning_curve(svr, 'SVR Curve', smr_train.feature_matrix, smr_train.labels, n_jobs=4)
print ''

lsvc = LinearSVC()
print 'LinearSVC config:'
print lsvc.get_params()
lsvc.fit(smr_train.feature_matrix, smr_train.labels)
lsvc_score_train = lsvc.score(smr_train.feature_matrix, smr_train.labels)
print 'LinearSVC precision train: {}'.format(lsvc_score_train)
lsvc_score_test = lsvc.score(smr_test.feature_matrix, smr_test.labels)

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import get_params [as 别名]
#result_X = preprocessing.scale(result_X)

X_feats = result_X[:, 2:]
X_target = result_X[:, 1]

#pca = PCA(100)
#X_feats = pca.fit_transform(X_feats)

############clf = sv reg###############
clf = SVR(C = 1.0, epsilon = 0.2)
clf.fit(X_feats, X_target)

X_test = X_feats
Y_test = X_target
############

predicted_x = clf.predict(X_test)

a = normalized_gini(predicted_x, Y_test)
print a#("GINI Score : ", a)

P = clf.get_params()
#np.savetxt('svr1.txt', clf.coef_)
#result_X = np.column_stack(result + [[1]*len(result[0])])
#beta_hat = np.linalg.lstsq(result[1:[1, 2, 3]], result[1:,[0]].T)[0]
#print clf.coef_

with open('svr1.csv', 'wb') as csvfile:
    swriter = csv.writer(csvfile, delimiter=',')
    swriter.writerow([x for x in P])