Python SVR.fit方法代码示例

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import fit [as 别名]
def train_svm(train_file):
    test_X, test_Y, weight = load_data(train_file, get_avg(train_file))
    svr = SVR(kernel='rbf', C=100, gamma=1)
    print("start train")
    svr.fit(test_X, test_Y)
    print("train finish")
    return svr

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import fit [as 别名]
def getError1(signal, normedDay, period, phase):
    '''
    Gets the error for a list of points across a normed day given a sklean 
    model, the period, and the phase of the fitted signal.
    
    Here I'm using the Euclidean distance as the error measurement.  This 
    requires a little more computation due to the need to fit an inverse
    model, but provides better fits.
    
    Returns the squared Euclidean error.
    '''
    
    if rank(normedDay.index[0]) > 0:
        t0= round((array(normedDay.index.get_level_values(0))- phase)%period,3)
    else:
        t0 = round((array(normedDay.index,dtype=float) - phase)%period,3)
    nD = Series(normedDay, index=t0)
    
    tUp = array([arange(0,period+.1,.1)]).T
    invSignal = SVR(kernel='rbf', C=signal.C, gamma=signal.gamma, 
                    epsilon=signal.epsilon)
    
    invSignal.fit(array([signal.predict(tUp)]).T, tUp.flatten())
    
    xDiff = nD - signal.predict(array([array(nD)]).T)
    yDiff = nD - signal.predict(array([nD.index]).T)
    
    error = sum(pow(xDiff/period,2) + pow(yDiff/2,2))
    return error

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import fit [as 别名]
def train_svm(data):
    test_X, test_Y = load_data(data)
    svr = SVR(kernel='rbf', C=100, gamma=1)
    print("start train")
    svr.fit(test_X, test_Y)
    print("train finish")
    return svr

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import fit [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 fit [as 别名]
    def RunSVRScikit():
      totalTimer = Timer()

      # Load input dataset.
      Log.Info("Loading dataset", self.verbose)
      # Use the last row of the training set as the responses.
      X, y = SplitTrainData(self.dataset)

      # Get all the parameters.
      opts = {}
      if "c" in options:
        opts["C"] = float(options.pop("c"))
      if "epsilon" in options:
        opts["epsilon"] = float(options.pop("epsilon"))
      if "gamma" in options:
        opts["gamma"] = float(options.pop("gamma"))
      opts["kernel"] = "rbf"

      if len(options) > 0:
        Log.Fatal("Unknown parameters: " + str(options))
        raise Exception("unknown parameters")

      try:
        with totalTimer:
          # Perform SVR.
          model = SSVR(**opts)
          model.fit(X, y)
      except Exception as e:
        return -1

      return totalTimer.ElapsedTime()

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import fit [as 别名]
def main(args):
    (training_file, label_file, test_file, test_label, c, e) = args
    svr = SVR(C=float(c), epsilon=float(e), kernel='rbf')
    X = load_feat(training_file)
    y = [float(line.strip()) for line in open(label_file)]
    
    X = np.asarray(X)
     
    y = np.asarray(y)
    
    test_X = load_feat(test_file)
    test_X = np.asarray(test_X)
    test_X[np.isnan(test_X)] = 0

    svr.fit(X, y)
    
    pred = svr.predict(test_X)
    if test_label != 'none':
        test_y = [float(line.strip()) for line in open(test_label)]
        test_y = np.asarray(test_y)
        print 'MAE: ', mean_absolute_error(test_y, pred)
        print 'RMSE: ', sqrt(mean_squared_error(test_y, pred))
        print 'corrpearson: ', sp.stats.pearsonr(test_y, pred)
        print 'r-sqr: ', sp.stats.linregress(test_y, pred)[2] ** 2
        print mquantiles(test_y, prob=[0.10, 0.90])
        print mquantiles(pred, prob=[0.10, 0.90])
    with open(test_file + '.svr.pred', 'w') as output:
        for p in pred:
            print >>output, p
    return

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import fit [as 别名]
    def train(self, x, y, param_names, random_search=100,
              kernel_cache_size=2000, **kwargs):
        if self._debug:
            print "First training sample\n", x[0]
        start = time.time()
        scaled_x = self._set_and_preprocess(x=x, param_names=param_names)

        # Check that each input is between 0 and 1
        self._check_scaling(scaled_x=scaled_x)

        if self._debug:
            print "Shape of training data: ", scaled_x.shape
            print "Param names: ", self._used_param_names
            print "First training sample\n", scaled_x[0]
            print "Encode: ", self._encode

        # Do a random search
        c, gamma = self._random_search(random_iter=random_search, x=scaled_x,
                                       y=y, kernel_cache_size=kernel_cache_size)

        # Now train model
        try:
            svr = SVR(gamma=gamma, C=c, random_state=self._rng,
                      cache_size=kernel_cache_size)
            svr.fit(scaled_x, y)
            self._model = svr
        except Exception, e:
            print "Training failed", e.message
            svr = None

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import fit [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 fit [as 别名]
    def RunSVRScikit(q):
      totalTimer = Timer()

      # Load input dataset.
      Log.Info("Loading dataset", self.verbose)
      # Use the last row of the training set as the responses.
      X, y = SplitTrainData(self.dataset)

      # Get all the parameters.
      c = re.search("-c (\d+\.\d+)", options)
      e = re.search("-e (\d+\.\d+)", options)
      g = re.search("-g (\d+\.\d+)", options)

      C = 1.0 if not c else float(c.group(1))
      epsilon = 1.0 if not e else float(e.group(1))
      gamma = 0.1 if not g else float(g.group(1))

      try:
        with totalTimer:
          # Perform SVR.
          model = SSVR(kernel='rbf', C=C, epsilon=epsilon, gamma=gamma)
          model.fit(X, y)
      except Exception as e:
        q.put(-1)
        return -1

      time = totalTimer.ElapsedTime()
      q.put(time)
      return time

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import fit [as 别名]
def svr_main(X, Y):
    X_train = X[:TRAIN_SIZE]
    Y_train = Y[:TRAIN_SIZE]
    X_test = X[TRAIN_SIZE:]
    Y_test = Y[TRAIN_SIZE:]

    clf = SVR(kernel='rbf', C=1e3, gamma=0.00001)
    #clf.fit(X_train,Y_train)
    #y_pred = clf.predict(X_test)
    #plt.plot(X_test, y_pred, linestyle='-', color='red') 

    #clf = GradientBoostingRegressor(n_estimators=100,max_depth=1)
    #clf = DecisionTreeRegressor(max_depth=25)
    #clf = ExtraTreesRegressor(n_estimators=2000,max_depth=14)
    #clf = xgb.XGBRegressor(n_estimators=2000,max_depth=25)
    #clf = RandomForestRegressor(n_estimators=1000,max_depth=26,n_jobs=7)
    predict_list = []
    for i in xrange(TEST_SIZE):
        X = [ [x] for x in xrange(i, TRAIN_SIZE+i)]
        clf.fit(X, Y[i:TRAIN_SIZE+i])
        y_pred = clf.predict([TRAIN_SIZE+1+i])
        predict_list.append(y_pred)

    print "mean_squared_error:%s"%mean_squared_error(Y_test, predict_list)
    print "sqrt of mean_squared_error:%s"%np.sqrt(mean_squared_error(Y_test, predict_list))
    origin_data = Y_test
    print "origin data:%s"%origin_data
    plt.plot([ x for x in xrange(TRAIN_SIZE+1, TRAIN_SIZE+TEST_SIZE+1)], predict_list, linestyle='-', color='red', label='prediction model')  
    plt.plot(X_test, Y_test, linestyle='-', color='blue', label='actual model') 
    plt.legend(loc=1, prop={'size': 12})
    plt.show()

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import fit [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 fit [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 fit [as 别名]
 def train(self, pairings):
     X, Y = self.getXY(pairings)
     self.svms = []
     for i in range(self.wine_feat_len):
         svm = SVR(kernel='rbf')
         svm.fit(X, Y[:, i])
         self.svms.append(svm)

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

    X, y = make_regression(n_samples=1000,
                           n_features=5,
                           n_informative=2,
                           n_targets=1,
                           random_state=123,
                           shuffle=False)

    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.3, random_state=123)

    svm = SVR(kernel='rbf', gamma='auto')
    svm.fit(X_train, y_train)

    imp_vals, imp_all = feature_importance_permutation(
        predict_method=svm.predict,
        X=X_test,
        y=y_test,
        metric=mean_squared_error,
        num_rounds=1,
        seed=123)

    norm_imp_vals = imp_vals / np.abs(imp_vals).max()

    assert imp_vals.shape == (X_train.shape[1], )
    assert imp_all.shape == (X_train.shape[1], 1)
    assert norm_imp_vals[0] == -1.

# 需要导入模块: from sklearn.svm import SVR [as 别名]
# 或者: from sklearn.svm.SVR import fit [as 别名]
def train_SVR(viper):

	from sklearn.svm import SVR
	model = SVR(C=10, kernel='rbf', shrinking=False, verbose=True)
	model.fit(viper.train_feat, viper.train_y)

	return model