CS460 : Midway Report

Assuming three lags for the regression, the feature vectors are constructed, using a rolling window of length three, to extract the immediately three preceding exchange rate tick values.

dataLags=np.lib.stride_tricks.sliding_window_view(data['close'], lags)[:-1,:]

The optimal regression parameters returned by numpy.linalg.lstsq() reinforce the hypothesis that the exchange rate is a random walk, with the best indicator of the upcoming exchange rate tick is the current tick value.

The results are not that encouraging with the predicted value of the next minute's exchange rate being roughly the current exchange rate, with the shift of the tick values of the original exchange-rate by one minute into the future.

Constructing the feature vectors from the log returns instead of the absolute exchange rates led to better results. The log returns are defined by and implemented as

$$\log{returns}= log\left(\frac{Current\,Exchange \,Rate}{Preceeding\,Exchange\,Rate}\right)$$

As before, the feature vectors are created with a lag number of preceding tick values of the exchange rate.

data['return']=np.log(data['price']/data['price'].shift(1))
data.dropna(inplace=True)
lags=2
x=np.lib.stride_tricks.sliding_window_view(data['return'], lags)[:-1,:]
y=np.sign(data['return'][lags:])

Applying logistic regression on the dataset

model=LogisticRegression(C=1e7, max_iter=1000)
model=model.fit(x, y)
data['predict']=model.predict(x)
print(accuracy_score(data['predict'], np.sign(data['return'])))
print(confusion_matrix(np.sign(data['return']), data['predict']))
print(classification_report(np.sign(data['return']), data['predict']))

Output:
0.5050038491147036

[[386   0 264]
 [  2   0   1]
 [376   0 270]]
 
              precision    recall  f1-score   support

        -1.0       0.51      0.59      0.55       650
         0.0       0.00      0.00      0.00         3
         1.0       0.50      0.42      0.46       646

    accuracy                           0.51      1299
   macro avg       0.34      0.34      0.33      1299
weighted avg       0.50      0.51      0.50      1299

return      0.950105
strategy    1.010645
dtype: float64

Although logistic regression looked promising, it performed badly on the training data. And this so-so performance was obtained on daily closing exchange rate values for the currency pair USD/EUR, with a lag period of 3.

Increasing the lag period to 5, affects performance adversely

Decreasing the lag period to 2, does not affect performance greatly

However, the greatest setback was that logistic regression seemed to not work at all when applied with tick values of exchange rates at an interval of a minute.

Output:
return      1.009064
strategy    1.009038

An ARIMA model is fitted to the stationary data using pmdarima.arima.auto_arima.

model=pm.auto_arima(data['logs'][0:100], start_p=0, strat_q=0, start_P=0, start_Q=0, d=0, max_p=5, max_q=5, max_P=5, max_Q=5, seasonal=False)

And the prediction is validated over the next 100 tick points of the exchange rate.

validate=pm.model_selection.SlidingWindowForecastCV(window_size=100)
preds=pm.model_selection.cross_val_predict(model, data['logs'], cv=validate)
data['predict']=np.concatenate((data['logs'][0:100], preds))

The resulting plot of actual and the predicted exchange rate are

To get the performance of the model, the returns were calculated by implementing the ARIMA strategy.

preds, conf_int=model.predict_in_sample(start=100, end=1999, dynamic=False, return_conf_int=True)
data['predict']=np.concatenate((data['logs'][0:99], preds))
data['predictReturns']=data['predict']-data['predict'].shift(1)
data['strategy']=np.sign(data['predictReturns'])*data['returns']

Output:
returns     1.001775
strategy    1.090382
dtype: float64

The returns from the ARIMA model were comparable to the linear regression implemented.

The sole problem with ARIMA models is that the model is essentially "backward looking" and is bad at forecasting turning tick values, where it always lags by an observation.

Following the documentation, the DataFrame was prepared to match the required input for the fbProphet model, a ds(datestamp) column and the corresponding y(measurement to predict) column.

from prophet import Prophet
raw=pd.read_csv('./USDEUR.csv')
data=raw[["time","close"]]
data=data.rename(columns={"time": "ds", "close": "y"})
data.head()

The data was fit to an fbProphet model with a call to the fit() method.

model=Prophet(changepoint_prior_scale=0.01)
fit=model.fit(data)

A call to the predict() method predicts the future values yhat.

future=model.make_future_dataframe(periods=365)
forecast=model.predict(future)
forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail()

The plot is generated by the plot() method.

fig=model.plot(forecast)

Zooming into the recent predictions...

When Facebook Prophet was implemented on the data of the exchange rate at one minute intervals, the model underfits the data as the predicted values do not match the original values at all.

A realistic picture of the performance of the model is obtained by training the model, or fitting the model on some portion of the data and evaluating the performance of the model on the testing data (unseen for the model while training). The number of lags is taken as an input by the script.

The prediction of the returns for the test data are

The performance of the regression based model with a lag of 5 days, without transaction costs is

Output:
Gross Performance: 0.013829

Hit Performance:
 1.0    1382
-1.0    1250
 0.0     364
dtype: int64

A second linear model was also implemented where the sign of the returns of the previous few return values of the exchange rate tick was used to determine the sign of the immediately upcoming return value for the exchange rate tick. Since, the sign can have only two possible values (+1, -1), the problem is equivalent to classifying whether the next return would be positive or negative, a classification problem. The number of lags is taken as an input in this script too.

The performance of the perceptron like model with a lag of 5 days, without transaction costs is

Output:
Gross Performance: 0.013691
 1.0    1351
-1.0    1281
 0.0     364
dtype: int64

The performance of the perceptron model is not much worse than the linear-regression based model, with a minor decrease in the hit ratio.

Logistic regression was implemented to predict whether the next return would be positive or negative using the returns for the previous few return values of the exchange rate tick. Since the return can have only two possible values (+1, -1), the problem is a classification problem. Logistic regression does not perform at all on trades at an interval of a minute. The number of lags is taken as an input in this script too.

The performance of the logistic regression model with a lag of 3 days, without transaction costs results in a loss making strategy for executing trades at an interval of a day

Output:
Gross Performance: -0.027518
-1.0    155
 1.0    140
 0.0      2
dtype: int64

The performance improves when the lag is increased to 7 days, without transaction costs results in profits executing trades at an interval of a day, but does not work for executing trades at the interval of a minute

Output:
Gross Performance: 0.027408
 1.0    156
-1.0    135
 0.0      2
dtype: int64

The performance of the logistic-regression based model does not seem suitable for the execution of intra-day (15 minute) trades.

The arima.auto_arima() is used to fit an optimal parameter ARIMA model. It conducts differencing tests to determine the parameter d, and fits an optimal value in the range start_p, max_p and start_q, max_q, by grid search. The fit plots for the ARIMA model are

• The normalized residuals (difference between the predicted and actual values) in the first plot are noise-like or uncorrelated, and have a zero mean (no bias) and near-zero variance.
• The second plot has a histogram of the observed distribution, an estimated density plot of the normalized residuals (green plot) and a normalized Gaussian (red plot) for comparison.
• The quantile-quantile plot roughly follows a straight-line indicating a Normal distribution, with 'curve-off' at the extremities indicating 'heavy tails' (the data has more extreme values than expected from a normal distribution).
• The correlogram in the fourth plot reinforces the 'random-walk' hypothesis as the correlation falls to zero immediately on a small shift.

The performance of the ARIMA model on the testing-data for the prediction of the future exchange-rate by this script is

Using an ARIMA model to execute trades, the gross performance for the next 3000 tick values is

Output:
Gross Performance: 0.009446
-1.0    1360
 1.0    1290
 0.0     348
dtype: int64

The gross return for 3000 predictions in the future is