Exemplo n.º 1
0
    def __init__(self,
                 balance,
                 tickers=None,
                 base_model=LinearRegression(),
                 n_prev=2,
                 wait=100,
                 steps_ahead=100,
                 k=5,
                 envelope='proportional',
                 log=False,
                 commission=.0002,
                 flat_rate=8):

        if tickers is None:
            tickers = s_and_p_names('2014-1-1', '2015-11-02')

        super(TSEBuyAndHoldStrategy, self).__init__(balance,
                                                    tickers,
                                                    log=log,
                                                    commission=commission,
                                                    wait=wait,
                                                    flat_rate=flat_rate)

        self.model = TimeSeriesRegressor(base_model, n_ahead=1, n_prev=n_prev)
        self.steps_ahead = steps_ahead
        self.k = k
        self.envelope = envelope
Exemplo n.º 2
0
def get_data_dependece(X,
                       data_sizes,
                       folds=20,
                       test_size=30,
                       n_prev=2,
                       log=True):
    bests = np.empty((len(data_sizes), folds, X.shape[1]))
    for i, data_size in enumerate(data_sizes):
        pairs = cascade_cv(len(X),
                           folds,
                           data_size=data_size,
                           test_size=test_size,
                           number=True)
        for j, pair in enumerate(pairs):
            if log:
                print('data size: {} trial {} '.format(data_size, j))
            X_train, X_test = np.array(X.iloc[pair[0], :]), np.array(
                X.iloc[pair[1], :])
            tsr = TimeSeriesRegressor(LinearRegression(), n_prev=n_prev)
            tsr.fit(X_train)
            fc = tsr.forecast(X_train, len(X_test))

            def changes(X, start=0, end=-1):
                return np.array(
                    [X[end, i] - X[start, i] for i in range(X.shape[1])])

            best_is = changes(fc).argsort()[::-1]
            for k in range(X.shape[1]):
                bests[i, j, k] = changes(X_test)[best_is[k]] - np.mean(
                    changes(X_test))

    return bests
Exemplo n.º 3
0
from TimeSeriesEstimator import TimeSeriesRegressor, time_series_split


def mse(X1, X2, multioutput='raw_values'):
    if multioutput == 'raw_values':
        return np.mean((X1 - X2)**2, axis=0)**.5
    if multioutput == 'uniform_average':
        return np.mean(np.mean((X1 - X2)**2, axis=0)**.5)


X = datasets('sp500')
names = list(X.columns.values)
X_train, X_test = time_series_split(X)

n_prev = 2
tsr = TimeSeriesRegressor(LinearRegression(), n_prev=n_prev)
tsr.fit(X_train)
fc = tsr.forecast(X_train, len(X_test), noise=.2, n_paths=200)
fc_mean = tsr.forecast(X_train,
                       len(X_test),
                       noise=.2,
                       n_paths=200,
                       combine='mean')
#or for speed
#fc_mean = np.mean(fc, axis=0)

plt.plot(np.transpose(fc[:, :, 1]), 'r', alpha=.05)
plt.plot(np.transpose(fc_mean[:, 1]), 'b', label='Mean Forecast')
plt.plot(X_test[:, 1], 'g', label='Actual Price')
plt.legend()
plt.xlabel('days')