Python SVR.predict方法代码示例

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import predict [as 别名]
def evaluate_learner(X_train, X_test, y_train, y_test):
    '''
    Run multiple times with different algorithms to get an idea of the
    relative performance of each configuration.
    Returns a sequence of tuples containing:
        (title, expected values, actual values)
    for each learner.
    '''

    # Use a support vector machine for regression
    from sklearn.svm import SVR

    # Train using a radial basis function
    svr = SVR(kernel='rbf', gamma=0.1)
    svr.fit(X_train, y_train)
    y_pred = svr.predict(X_test)
    r_2 = svr.score(X_test, y_test)
    yield 'RBF Model ($R^2={:.3f}$)'.format(r_2), y_test, y_pred

    # Train using a linear kernel
    svr = SVR(kernel='linear')
    svr.fit(X_train, y_train)
    y_pred = svr.predict(X_test)
    r_2 = svr.score(X_test, y_test)
    yield 'Linear Model ($R^2={:.3f}$)'.format(r_2), y_test, y_pred

    # Train using a polynomial kernel
    svr = SVR(kernel='poly', degree=2)
    svr.fit(X_train, y_train)
    y_pred = svr.predict(X_test)
    r_2 = svr.score(X_test, y_test)
    yield 'Polynomial Model ($R^2={:.3f}$)'.format(r_2), y_test, y_pred

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import predict [as 别名]
def compute_mse(regressor, horizon):
    # get wind park and corresponding target. 
    windpark = NREL().get_windpark(NREL.park_id['tehachapi'], 3, 2004, 2005)
    target = windpark.get_target()

    # use power mapping for pattern-label mapping. 
    feature_window = 3
    mapping = PowerMapping()
    X = mapping.get_features_park(windpark, feature_window, horizon)
    y = mapping.get_labels_turbine(target, feature_window, horizon)

    # train roughly for the year 2004, test for 2005.
    train_to = int(math.floor(len(X) * 0.5))
    test_to = len(X)
    train_step, test_step = 25, 25
    X_train=X[:train_to:train_step]
    y_train=y[:train_to:train_step]
    X_test=X[train_to:test_to:test_step]
    y_test=y[train_to:test_to:test_step]

    if(regressor == 'svr'):
        reg = SVR(kernel='rbf', epsilon=0.1, C = 100.0,\
                gamma = 0.0001).fit(X_train,y_train)
        mse = mean_squared_error(reg.predict(X_test),y_test)
    elif(regressor == 'knn'):
        reg = KNeighborsRegressor(10, 'uniform').fit(X_train,y_train)
        mse = mean_squared_error(reg.predict(X_test),y_test)
    return mse

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import predict [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 predict [as 别名]
def supportVectorRegression(X, Y_casual, Y_registered, testSet_final):
	svr1 = SVR(kernel='rbf', gamma=0.1)
	svr2 = SVR(kernel='rbf', gamma=0.1)
	svr1.fit(X, Y_casual)
	svr2.fit(X, Y_registered)
	svr1_Y = np.exp(svr1.predict(testSet_final))-1
	svr2_Y = np.exp(svr2.predict(testSet_final))-1
	final_prediction = np.intp(np.around(svr1_Y + svr2_Y))
	return final_prediction

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import predict [as 别名]
def svr_predict(sampled_data_FC1,sampled_data_FC2,len_real=1800,len_train=1100):    
    sampled_data_FC1_minus_FC2=sampled_data_FC2
    sampled_data_FC1_minus_FC2=np.array(sampled_data_FC1_minus_FC2)
#    sampled_data_FC1_minus_FC2=FC1_minus_FC2.FC1_minus_FC2(sampled_data_FC1,sampled_data_FC2)
    
    ## solve method 2: normalize
    sampled_data_FC=[]
    for sdF in sampled_data_FC1_minus_FC2:
        sampled_data_FC.append(sdF[1])
    
    
    ## time normalize
    temp_time_end=sampled_data_FC1_minus_FC2[-1,0]
    sampled_data_FC1_minus_FC2[:,0]=sampled_data_FC1_minus_FC2[:,0]/temp_time_end
    
    sampled_data=np.column_stack((sampled_data_FC1_minus_FC2[:,0],sampled_data_FC)) 
    
    X = sampled_data[0:len_real,0]  # X is the all real  time_data
    Y =sampled_data[0:len_real,1]   # Y is the all real value_data
    
    
    pat_list=[]
    for i in range(len_train-regressors_num+1):
        pat_list.append(list(sampled_data[i:i+regressors_num,1])+[sampled_data[i+regressors_num,0],sampled_data[i+regressors_num,1]])  # make the value couple,like [[x1,x2,x3,x4],[x5]]
    pat_list=np.array(pat_list)
    
    X1=pat_list[:,0:regressors_num+1]
    X=X.reshape([len_real,1])
    Y1=pat_list[:,regressors_num+1]   # Y1 is the train real value_data
    
    ###############################################################################
    # Fit regression model
    
    svr_rbf = SVR(kernel='rbf', epsilon=0.0083, C=1000, gamma=0.05)
    svr_rbf.fit(X1, Y1)
    
    ########################################################################
    # prognostic phase
    y_rbf_prog=[]
    
    for i in range(len_real-len_train):
        if i ==0:
            X_temp1=list(X1[-1][:-1])+[sampled_data[len_train,0]]
            X_temp1=np.array(X_temp1)
            y_rbf_prog.append(float(svr_rbf.predict(X_temp1)))
        elif i < regressors_num:
    
            X_temp=list(X1[-1][-(regressors_num-i)-1:-1])+y_rbf_prog+[sampled_data[i+len_train,0]]
            X_temp=np.array(X_temp)
            y_rbf_prog.append(float(svr_rbf.predict(X_temp)))
        elif i >= regressors_num:
            X_temp=y_rbf_prog[-regressors_num:]+[sampled_data[i+len_train,0]]
            X_temp=np.array(X_temp)
            y_rbf_prog.append(float(svr_rbf.predict(X_temp)))
    
    FC2_prog_pred=sampled_data_FC1[len_train:len_real,1]-y_rbf_prog
#    return FC2_prog_pred 
    return y_rbf_prog

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import predict [as 别名]
def SVM(Xtrain, ytrain, Xtest=None, C=1):
    model = SVR(C=C)  ## module imported from Scikit-Learn
    model.fit(Xtrain, ytrain)
    pred = model.predict(Xtrain)
    if Xtest is None:
        return pred
    else:
        pred_test = model.predict(Xtest)
    return pred, pred_test

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import predict [as 别名]
class W2VPool:
    def __init__(self, poolingDim = 20):
        self.clf = SVR(C = 0.5)
        self.model = Word2Vec.load("vectors.bin")
        self.poolingDim = poolingDim
    def getFeatures(self, data):
        sentenceAs = [data[0] for data in data]
        sentenceBs = [data[1] for data in data]
        scores = [float(data[2]) for data in data]
        features = []
        for i in range(len(sentenceAs)):
            mat = self.simMatrix(self.model, sentenceAs[i], sentenceBs[i])
            mat = self.dynamicPooling(mat, self.poolingDim)
            features.append(np.ndarray.flatten(mat))
        return features, scores
    def simMatrix(self, model, sentence1, sentence2):
        tokens1 = word_tokenize(sentence1)
        tokens2 = word_tokenize(sentence2)
        mat = np.zeros((len(tokens1), len(tokens2)))
        for index1, token1 in enumerate(tokens1):
            for index2, token2 in enumerate(tokens2):
                vec1 = model[token1] if token1 in model else np.zeros((len(model['the'])))
                vec2 = model[token2] if token2 in model else np.zeros((len(model['the'])))
                mat[index1][index2] = cosine(vec1, vec2)
        return mat
    def dynamicPooling(self, matrix, finalDim):
        finalMatrix = np.zeros((finalDim, finalDim))
        for i in range(finalDim):
            for j in range(finalDim):
                compressionArea = []
                for a in range(int(float(i) / finalDim * matrix.shape[0]), int(float(i + 1) / finalDim * matrix.shape[0])):
                    for b in range(int(float(j) / finalDim * matrix.shape[1]), int(float(j + 1) / finalDim * matrix.shape[1])):
                        compressionArea.append(matrix[a][b])
                if len(compressionArea) == 0:
                    finalMatrix[i][j] = matrix[int(float(i) / finalDim * matrix.shape[0])][int(float(j) / finalDim * matrix.shape[1])]
                else:
                    finalMatrix[i][j] = min(compressionArea)

        return np.nan_to_num(finalMatrix)

    def train(self, trainData):
        features, scores = self.getFeatures(trainData)
        self.clf.fit(features, scores)
        results = self.clf.predict(features)
        print("Training Error")
        print(sklearn.metrics.mean_squared_error(results, np.array(scores)))

    def test(self, test):
        features, scores = self.getFeatures(test)
        results = self.clf.predict(features)
        print("Testing Error")
        print(sklearn.metrics.mean_squared_error(results, np.array(scores)))

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import predict [as 别名]
def svr_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 = SVR()
    model.fit(x_train, np.log(y_train))
    test_pred = np.exp(model.predict(x_test))
    valid_pred = np.exp(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

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import predict [as 别名]
def learn(X, y):
    # do pca
    pca = PCA(n_components=6)
    pca_6 = pca.fit(X)

    print('variance ratio')
    print(pca_6.explained_variance_ratio_)
    X = pca.fit_transform(X)

    # X = np.concatenate((X_pca[:, 0].reshape(X.shape[0], 1), X_pca[:, 5].reshape(X.shape[0], 1)), axis=1)
    # do svr
    svr_rbf = SVR(kernel='rbf', C=1)
    svr_rbf.fit(X, y)
    # print(model_rbf)

    y_rbf = svr_rbf.predict(X)
    print(y_rbf)
    print(y)

    # see difference
    y_rbf = np.transpose(y_rbf)
    deviation(y, y_rbf)

    # pickle model
    with open('rbfmodel.pkl', 'wb') as f:
        pickle.dump(svr_rbf, f)

    with open('pcamodel.pkl', 'wb') as f:
        pickle.dump(pca_6, f)

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import predict [as 别名]
def train_model(train, test, labels):
    clf = SVR(C=1.0, epsilon=0.2)
    clf.fit(train, labels)
    #clf = GaussianNB()
    #clf.fit(train, labels)
    print "Good!"
    predictions = clf.predict(test)
    print predictions.shape
    predictions = pd.DataFrame(predictions, columns = ['relevance'])
    print "Good again!"
    print "Predictions head -------"
    print predictions.head()
    print predictions.shape
    print "TEST head -------"
    print test.head()
    print test.shape
    test['id'].to_csv("TEST_TEST.csv",index=False)
    predictions.to_csv("PREDICTIONS.csv",index=False)
    #test = test.reset_index()
    #predictions = predictions.reset_index()
    #test = test.groupby(level=0).first()
    #predictions = predictions.groupby(level=0).first()
    predictions = pd.concat([test['id'],predictions], axis=1, verify_integrity=False)
    print predictions
    return predictions

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import predict [as 别名]
def test4():
	'''
	We assume that for each year, 7.1~9.30 belongs to summer model(model-1),
		12.1~2.28 belongs to winter model(model-3),
		the others, 3.1~6.30, 10.1~11.30 belongs to spring model(model-2)'''
	model_1_train_x = x[:15]+x[285:375]+x[645:745]+x[1015:1105]+x[1375:1465]
	model_1_train_y = y[:15]+y[285:375]+y[645:745]+y[1015:1105]+y[1375:1465]
	model_2_train_x = x[15:75]+x[375:435]+x[745:805]+x[1105:1165]
	model_2_train_y = y[15:75]+y[375:435]+y[745:805]+y[1105:1165]
	model_3_train_x = x[75:165]+x[435:525]+x[805:895]+x[1165:1255]
	model_3_train_y = y[75:165]+y[435:525]+y[805:895]+y[1165:1255]
	model_4_train_x = x[165:285]+x[525:645]+x[895:1015]+x[1255:1375]
	model_4_train_y = y[165:285]+y[525:645]+y[895:1015]+y[1255:1375]
	model_1, model_2, model_3, model_4 = SVR(), SVR(), SVR(), SVR()
	model_1.fit(model_1_train_x, model_1_train_y)
	model_2.fit(model_2_train_x, model_2_train_y)
	model_3.fit(model_3_train_x, model_3_train_y)
	model_4.fit(model_4_train_x, model_4_train_y)
	model_1_test_x = x[1735:1825]
	model_1_test_y = y[1735:1825]
	model_2_test_x = x[1465:1525]+x[1825:1885]
	model_2_test_y = y[1465:1525]+y[1825:1885]
	model_3_test_x = x[1525:1615]+x[1885:1975]
	model_3_test_y = y[1525:1615]+y[1885:1975]
	model_4_test_x = x[1615:1735]+x[1975:]
	model_4_test_y = y[1615:1735]+y[1975:]
	model_1_pred, model_2_pred, model_3_pred, model_4_pred = model_1.predict(model_1_test_x), model_2.predict(model_2_test_x), model_3.predict(model_3_test_x), model_4.predict(model_4_test_x)
	calc_err(model_1_pred, model_1_test_y)
	calc_err(model_2_pred, model_2_test_y)
	calc_err(model_3_pred, model_3_test_y)
	calc_err(model_4_pred, model_4_test_y)
	calc_err(list(model_1_pred)+list(model_2_pred)+list(model_3_pred)+list(model_4_pred), model_1_test_y+model_2_test_y+model_3_test_y+model_4_test_y)

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

    def __init__(self, kernel="linear", C=1e3, gamma=0.1, degree=2, verbose = False):
		self.name = "{} Support Vector Machine Learner".format(kernel.capitalize())
		self.kernel=kernel
		if kernel=="linear":
			self.svr = SVR(kernel=kernel, C=C)
		elif kernel=="rbf":
			self.svr = SVR(kernel=kernel, C=C, gamma=gamma)
		elif kernel=="poly":
			self.svr = SVR(kernel=kernel, C=C, degree=degree)

    def addEvidence(self,dataX,dataY):
        """
        @summary: Add training data to learner
        @param dataX: X values of data to add
        @param dataY: the Y training values
        """
        # build and save the model
        self.svr.fit(dataX, dataY)
        
    def query(self,points):
        """
        @summary: Estimate a set of test points given the model we built.
        @param points: should be a numpy array with each row corresponding to a specific query.
        @returns the estimated values according to the saved model.
        """
        return self.svr.predict(points)

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import predict [as 别名]
    def fit(self, start_date, end_date):

        for ticker in self.tickers:
            self.stocks[ticker] = Stock(ticker)

        params_svr = [{
            'kernel': ['rbf', 'sigmoid', 'linear'],
            'C': [0.01, 0.1, 1, 10, 100],
            'epsilon': [0.0000001, 0.000001, 0.00001]
            }]
        params = ParameterGrid(params_svr)

        # Find the split for training and CV
        mid_date = train_test_split(start_date, end_date)
        for ticker, stock in self.stocks.items():

            X_train, y_train = stock.get_data(start_date, mid_date, fit=True)
            # X_train = self.pca.fit_transform(X_train.values)
            X_train = X_train.values
            # pdb.set_trace()
            X_cv, y_cv = stock.get_data(mid_date, end_date)
            # X_cv = self.pca.transform(X_cv.values)
            X_cv = X_cv.values

            lowest_mse = np.inf
            for i, param in enumerate(params):
                svr = SVR(**param)
                # ada = AdaBoostRegressor(svr)
                svr.fit(X_train, y_train.values)
                mse = mean_squared_error(
                    y_cv, svr.predict(X_cv))
                if mse <= lowest_mse:
                    self.models[ticker] = svr

        return self

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import predict [as 别名]
def compute_rmse(features, labels, train_index, test_index):
    x_train, x_test = features[train_index], features[test_index]
    y_train, y_test = labels[train_index], labels[test_index]

    r, c = x_train.shape
    if r < 15:
        return None

    if NORMALIZATION_FLAG:
        feature_scaler = StandardScaler().fit(x_train)
        x_train = feature_scaler.transform(x_train)
        x_test = feature_scaler.transform(x_test)
        label_scaler = StandardScaler().fit(y_train)
        y_train = label_scaler.transform(y_train).ravel()

    clf = SVR(C=100, gamma=0.001, kernel='rbf').fit(x_train, y_train)
    y_pred = clf.predict(x_test)

    if NORMALIZATION_FLAG:
        y_pred = y_pred*label_scaler.scale_ + label_scaler.mean_

    if LOG_FLAG:
        actual_pred = numpy.array([10 ** y for y in y_pred])
        actual_price = numpy.array([10 ** y for y in y_test])
    else:
        actual_pred = y_pred
        actual_price = y_test

    actual_rmse_pc = numpy.sqrt(numpy.mean(((actual_pred - actual_price) / actual_price) ** 2))
    actual_rmse = numpy.sqrt(numpy.mean((actual_pred - actual_price) ** 2))

    return actual_rmse, actual_rmse_pc

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import predict [as 别名]
def CaSVRModel(X_train, Y_train, X_test, Y_test, cv_iterator):
#     
#     param_grid = {'C':[10000],
#                    'epsilon':[0.001, 0.01, 0.05, 0.1, 0.15, 1]
#                    }
#       
#     svr = SVR(random_state=42, cache_size=1000, verbose=2)
#     search = GridSearchCV(svr, param_grid, scoring="mean_squared_error", n_jobs= 1, iid=True, cv=cv_iterator)
#     search.fit(X_train, Y_train["Ca"])
#     #search.grid_scores_
#       
#     model = search.best_estimator_

    #scaler = StandardScaler()

    model = SVR(C=10000, epsilon = 0.01, cache_size=1000)
    model.fit(X_train, Y_train["Ca"])
    #model.fit(X_train, Y_train["Ca"])
    
    #model.fit(X_train, Y_train["Ca"])
    
    #test = cross_val_score(svr, X_train.astype('float64'), Y_train["Ca"].astype('float64'), scoring="mean_squared_error", cv=cv_iterator)
    
    yhat_svr = model.predict(X_test)
    test_error = math.sqrt(mean_squared_error(Y_test["Ca"], yhat_svr))
    
    return model, test_error