Python for Algorithmic Trading¶
Using Machine & Deep Learning for Algorithmic FX Trading
Dr Yves J Hilpisch | The AI Machine
Imports¶
In [1]:
import math
import tpqoa
import cufflinks
import numpy as np
import pandas as pd
from pylab import plt
plt.style.use('seaborn')
%matplotlib inline
cufflinks.set_config_file(offline=True)
In [2]:
import warnings
warnings.simplefilter('ignore')
Oanda for FX Trading¶
Why Oanda and why FX?
- technology and APIs first in algorithmic trading
- proper APIs and good Python wrapper packages
- low transaction costs and simple cost model
- fully symmetric markets (long/short)
- high liquidity and long trading hours
- high leverage possible but not required
- all typical order types available (trailing stop, etc.)
- basically all single instrument strategies straighforward to trade
- pair and basket strategies also possible
- free data — both historical and streaming
- full data history for all instruments
- good trading apps (phone, pad, mac, win, browser)
- ...
The Data¶
In [3]:
api = tpqoa.tpqoa('dyjh.cfg')
In [4]:
api.get_instruments()[:4]
Out[4]:
In [5]:
sym = 'EUR_USD'
In [6]:
raw_a = api.get_history(sym, '2019-02-04', '2019-02-06', 'M1', 'A')
In [7]:
raw_b = api.get_history(sym, '2019-02-04', '2019-02-06', 'M1', 'B')
In [8]:
raw_a.info()
In [9]:
sel = list('c')
In [10]:
spread = (raw_a['c'] - raw_b['c']).mean()
spread # average spread
Out[10]:
In [11]:
data = ((raw_a[sel] + raw_b[sel]) / 2)
In [12]:
ptc = spread / data['c'].mean()
ptc # mean spread relative to mean mid price
Out[12]:
In [13]:
data.head()
Out[13]:
In [14]:
data['c'].plot();
Efficient Markets¶
In [15]:
lags = 7
In [16]:
cols = []
for lag in range(1, lags + 1):
col = 'lag_{}'.format(lag)
data[col] = data['c'].shift(lag) # lagged prices
cols.append(col)
In [17]:
data.dropna(inplace=True)
In [18]:
reg = np.linalg.lstsq(data[cols], data['c'], rcond=-1)[0]
In [19]:
np.set_printoptions(precision=4)
In [20]:
reg
Out[20]:
In [21]:
pd.DataFrame(reg, index=cols).plot(kind='bar');
Patterns Defined¶
Investopedia writes:
Chart patterns look at the big picture and help to identify trading signals — or signs of future price movements.
The theory behind chart patterns is based on this assumption — that certain patterns consistently reappear and tend to produce the same outcomes.
The process of identifying chart patterns based on these criteria can be subjective in nature, which is why charting is often seen as more of an art than a science.
In [22]:
data['r'] = np.log(data['c'] / data['c'].shift(1))
In [23]:
cols = []
for lag in range(1, lags + 1):
col = 'lag_{}'.format(lag)
data[col] = data['r'].shift(lag) # lagged returns
cols.append(col)
In [24]:
data.dropna(inplace=True)
In [25]:
data[cols] = np.where(data[cols] > 0, 1, -1)
data[cols] = data[cols].astype(int)
In [26]:
data.head(5)
Out[26]:
Frequency Approach¶
Simple¶
In [27]:
data['d'] = np.sign(data['r']).astype(int)
In [28]:
data.groupby(cols[:2])['d'].count()
Out[28]:
In [29]:
data.groupby(cols[:2] + ['d'])['r'].count()
Out[29]:
In [30]:
(data.groupby(cols[:2] + ['d'])['r'].count() / len(data) * 100).round(2)
Out[30]:
Advanced¶
In [31]:
cols[:3] + ['d']
Out[31]:
In [32]:
grouped = data[cols[:3] + ['d']].groupby(cols[:3] + ['d'])
In [33]:
res = grouped['d'].size().unstack()
In [34]:
res
Out[34]:
In [35]:
res['prob_up'] = (res[1] / (res[1] + res[-1])).round(3)
res['prob_down'] = 1 - res['prob_up']
In [36]:
res
Out[36]:
Classification¶
In [37]:
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
from sklearn.naive_bayes import GaussianNB
from sklearn.neural_network import MLPClassifier
from sklearn.linear_model import LogisticRegression
Logistic Regression¶
In [38]:
lr = LogisticRegression(solver='lbfgs', multi_class='auto')
In [39]:
lr.fit(data[cols], data['d'])
Out[39]:
In [40]:
y_lr = lr.predict(data[cols])
In [41]:
accuracy_score(y_lr, data['d'])
Out[41]:
Gaussian Naive Bayes¶
In [42]:
nb = GaussianNB()
In [43]:
nb.fit(data[cols], data['d'])
Out[43]:
In [44]:
y_nb = nb.predict(data[cols])
In [45]:
accuracy_score(y_nb, data['d'])
Out[45]:
Support Vector Machine¶
In [46]:
kernels = ['linear', 'rbf', 'poly']
In [47]:
models = {}
for kernel in kernels:
svm = SVC(C=5, kernel=kernel, gamma='auto')
svm.fit(data[cols], data['d'])
y_svm = svm.predict(data[cols])
acc = accuracy_score(y_svm, data['d'])
print('kernel: {:8s} | accuracy: {:6.3f}'.format(kernel, acc))
models[kernel] = svm
In [48]:
models
Out[48]:
Deep Neural Network¶
In [49]:
dnn = MLPClassifier(hidden_layer_sizes=3 * [96], activation='relu',
max_iter=2500, verbose=False)
In [50]:
%time dnn.fit(data[cols], data['d'])
Out[50]:
In [51]:
y_dnn = dnn.predict(data[cols])
In [52]:
accuracy_score(y_dnn, data['d'])
Out[52]:
Vectorized Backtesting¶
NO TRANSACTION COSTS | ONLY IN-SAMPLE PERFORMANCE</style>
In [53]:
data['p'] = models['rbf'].predict(data[cols])
data['s_svm'] = data['r'] * data['p']
In [54]:
(data['p'].diff() != 0).sum()
Out[54]:
In [55]:
data['p'] = dnn.predict(data[cols])
data['s_dnn'] = data['r'] * data['p']
In [56]:
(data['p'].diff() != 0).sum()
Out[56]:
In [57]:
data[['s_svm', 's_dnn', 'r']].cumsum().apply(np.exp).plot();
