自动化交易#

In [1]: import math
import time
import numpy as np
import pandas as pd
import datetime as dt
import cufflinks as cf
from pylab import plt
In [2]: np.random.seed(1000)
plt.style.use('seaborn')
%matplotlib inline

In [3]: p = 0.55
In [4]: f = p - (1 - p)
In [5]: f
Out[5]: 0.10000000000000009
In [6]: I = 50
In [7]: n = 100

In [8]: def run_simulation(f):
    c = np.zeros((n, I)) ①
    c[0] = 100 ②
    for i in range(I): ③
    for t in range(1, n): ④
    o = np.random.binomial(1, p) ⑤
    if o > 0: ⑥
    c[t, i] = (1 + f) * c[t - 1, i] ⑦
    else: ⑧
    c[t, i] = (1 - f) * c[t - 1, i] ⑨
    return c

In [10]: c_1.round(2)
Out[10]: array([[100. , 100. , 100. , ..., 100. , 100. , 100. ],
    [ 90. , 110. , 90. , ..., 110. , 90. , 110. ],
    [ 99. , 121. , 99. , ..., 121. , 81. , 121. ],
    ...
    [226.35, 338.13, 413.27, ..., 123.97, 123.97, 123.97],
    [248.99, 371.94, 454.6 , ..., 136.37, 136.37, 136.37],
    [273.89, 409.14, 409.14, ..., 122.73, 150.01, 122.73]])

In [11]: plt.figure(figsize=(10, 6))
plt.plot(c_1, 'b', lw=0.5)
plt.plot(c_1.mean(axis=1), 'r', lw=2.5);

In [14]: c_4 = run_simulation(0.5) 3

In [15]: plt.figure(figsize=(10, 6))
plt.plot(c_1.mean(axis=1), 'r', label='f^*=0.1$')
plt.plot(c_2.mean(axis=1), 'b', label='f=0.05$')
plt.plot(c_3.mean(axis=1), 'y', label='f=0.25$')

plt.plot(c_4.mean(axis=1), 'm', label='f=0.5')
plt.legend(loc=0);

In [16]: raw = pd.read_csv('../source/tr_eikon_eod_data.csv', index_col=0, parse_dates=True)

In [21]: data.tail()
Out[21]: .SPX returns
Date
2018-06-252717.07 -0.0138202018-06-262723.060.0022022018-06-272699.63 -0.0086422018-06-282716.310.0061602018-06-292718.370.000758

In [22]: mu = data_returns.mean() * 252
In [23]: mu
Out[23]: 0.09898579893004976
In [24]: sigma = data_returns.std() * 252 ** 0.5
In [25]: sigma
Out[25]: 0.1488567510081967
In [26]: r = 0.0
In [27]: f = (mu - r) / sigma ** 2
In [28]: f
Out[28]: 4.4672043679706865

In [29]: equs = []

In [30]: def kelly_strategy(f):
    global equs
    equ = 'equity_{:.2f}'.format(f)
    equs.append(equ)
    cap = 'capital_{:.2f}'.format(f)
    data[equ] = 1 ①
    data[cap] = data[equ] * f ②
``````python
for i, t in enumerate(data.index[1:]):
    t_1 = data.index[i] ③
    data.loc[t, cap] = data[cap].loc[t_1] * \
    math.exp(data['returns'].loc[t]) ④
    data.loc[t, equ] = data[cap].loc[t] - \
    data[cap].loc[t_1] + \
    data[equ].loc[t_1] ⑤
    data.loc[t, cap] = data[equ].loc[t] * f ⑥

In [31]: kelly_strategy(f * 0.5)

In [32]: kelly_strategy(f * 0.66)

In [33]: kelly_strategy(f) ⑨

In [34]: print(data[equs].tail())
    equity_2.23    equity_2.95    equity_4.47
Date
2018-06-254.7070706.3673408.7943422018-06-264.7302486.4087278.8809522018-06-274.6393406.2461478.5395932018-06-284.7033656.3599328.7752962018-06-294.7113326.3741528.805026

In [35]: ax = data['returns'].cumsum().apply(np.exp).plot(legend=True, figsize=(10, 6))
data[equs].plot(ax=ax, legend=True);

In [36]: import fxcmpy

In [37]: fxcmpy.__version__
Out[37]: '1.1.33'

In [38]: api = fxcmpy.fxcmpy(config_file='../fxcm.cfg') ①

In [39]: data = api.get_candles('EUR/USD', period='m5',
    start='2018-06-0100:00:00',
    stop='2018-06-3000:00:00') ①

In [40]: data.iloc[-5:, 4:]
Out[40]: askopen askclose askhigh asklow tickqty
date
2018-06-2920:35:001.168621.168821.168961.168396012018-06-2920:40:001.168821.168531.168981.168523872018-06-2920:45:001.168531.168261.168621.168225922018-06-2920:50:001.168261.168361.168461.168198422018-06-2920:55:001.168361.168611.168761.16834540

In [41]: data.info()
<class 'pandas.core.frame.DataFrame'>
DatetimeIndex: 6083 entries, 2018-06-0100:00:00 to 2018-06-2920:55:00
Data columns (total 9 columns):
bidopen 6083 non-null float64
bidclose 6083 non-null float64
bidhigh 6083 non-null float64
bidlow 6083 non-null float64
askopen 6083 non-null float64
askclose 6083 non-null float64
askhigh 6083 non-null float64
asklow 6083 non-null float64
tickqty 6083 non-null int64
dtypes: float64(8), int64(1)
memory usage: 475.2 KB

In [42]: spread = (data['askclose'] - data['bidclose']).mean() ②
spread ②
Out[42]: 2.6338977478217845e-05

In [43]: data['midclose'] = (data['askclose'] + data['bidclose']) / 2 ③
In [44]: ptc = spread / data['midclose'].mean() ④
ptc ④
Out[44]: 2.255685318140426e-05

In [46]: data['returns'] = np.log(data['midclose'] / data['midclose'].shift(1))

In [49]: cols = []
    for lag in range(1, lags + 1):

col = 'lag_{}'.format(lag)
data[col] = data['returns'].shift(lag) ①
cols.append(col)

In [50]: data.dropna(inplace=True)

In [51]: data[cols] = np.where(data[cols] > 0, 1, 0) ②

In [52]: data['direction'] = np.where(data['returns'] > 0, 1, -1) ③

In [53]: data[cols + ['direction']].head()
Out[53]: lag_1 lag_2 lag_3 lag_4 lag_5 direction
date
2018-06-0100:30:001010112018-06-0100:35:001101012018-06-0100:40:001110112018-06-0100:45:001111012018-06-0100:50:0011111 -1

In [54]: from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

In [55]: model = SVC(C=1, kernel='linear', gamma='auto')

In [56]: split = int(len(data) * 0.80)

In [57]: train = data.iloc[:split].copy()

In [58]: model.fit(train[cols], train['direction'])
Out[58]: SVC(C=1, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape='ovr', degree=3, gamma='auto', kernel='linear',
    max_iter=-1, probability=False, random_state=None, shrinking=True,
    tol=0.001, verbose=False)

In [59]: accuracy_score(train['direction'], model.predict(train[cols])) ①
Out[59]: 0.5198518823287389

In [60]: test = data.iloc[split:].copy()

In [61]: test['position'] = model.predict(test[col s])

In [62]: accuracy_score(test['direction'], test['position'])
Out[62]: 0.5419407894736842

In [63]: test['strategy'] = test['position'] * test['returns']

In [64]: sum(test['position'].diff() != 0)
Out[64]: 660

In [65]: test['strategy_tc'] = np.where(test['position'].diff() != 0, test['strategy'] - ptc, test['strategy'])

In [66]: test[['returns', 'strategy', 'strategy_tc']].sum().apply(np.exp)
Out[66]: returns 0.999324
strategy 1.026141
strategy_tc 1.010977
dtype: float64

In [67]: test[['returns', 'strategy', 'strategy_tc']].cumsum().apply(np.exp).plot(figsize=(10, 6));

In [68]: mean = test[['returns', 'strategy_tc']].mean() * len(data) * 12
    mean
Out[68]: returns -0.040535
    strategy_tc 0.654711
    dtype: float64

In [69]: var = test[['returns', 'strategy_tc']].var() * len(data) * 12
    var
Out[69]: returns 0.007861
    strategy_tc 0.007837
    dtype: float64

In [70]: vol = var ** 0.5
    vol
Out[70]: returns 0.088663
    strategy_tc 0.088524
    dtype: float64

In [71]: mean / var
Out[71]: returns -5.156448
    strategy_tc 83.545792
    dtype: float64

In [72]: mean / var * 0.5
Out[72]: returns -2.578224
    strategy_tc 41.772896
    dtype: float64

In [73]: to_plot = ['returns', 'strategy_tc']

In [74]: for lev in [10, 20, 30, 40, 50]:
    label = 'lstrategy_tc_%d' % lev
    test[label] = test['strategy_tc'] * lev
    to_plot.append(label)

In [75]: test[to_plot].cumsum().apply(np.exp).plot(figsize=(10, 6));

In [76]: equity = 3333
In [77]: risk = pd.DataFrame(test['lstrategy_tc_30']) ②
In [78]: risk['equity'] = risk['lstrategy_tc_30'].cumsum().apply(np.exp) * equity ③
In [79]: risk['cummax'] = risk['equity'].cummax() ④
In [80]: risk['drawdown'] = risk['cummax'] - risk['equity'] ⑤
In [81]: risk['drawdown'].max() ⑥
Out[81]: 781.7073602069818
In [82]: t_max = risk['drawdown'].idxmax() ⑦
t_max ⑦
Out[82]: Timestamp('2018-06-2902:45:00')

In [83]: temp = risk['drawdown'][risk['drawdown'] == 0] ①
In [84]: periods = (temp.index[1:].to_pydatetime() - temp.index[:-1].to_pydatetime()) ②
In [85]: periods[20:30] ②
Out[85]: array([datetime.timedelta(seconds=68700), datetime.timedelta(seconds=72000), datetime.timedelta(seconds=1800), datetime.timedelta(seconds=300), datetime.timedelta(seconds=600), datetime.timedelta(seconds=300), datetime.timedelta(seconds=17400), datetime.timedelta(seconds=4500), datetime.timedelta(seconds=1500), datetime.timedelta(seconds=900)], dtype=object)
In [86]: t_per = periods.max() ③
In [87]: t_per ③
Out[87]: datetime.timedelta(seconds=76500)
In [88]: t_per.seconds / 60 / 60 ④
Out[88]: 21.25
In [89]: risk[['equity', 'cummax']].plot(figsize=(10, 6))
plt.axvline(t_max, c='r', alpha=0.5);

In [91]: import scipy.stats as scs
In [92]: percs = np.array([0.01, 0.1, 1., 2.5, 5.0, 10.0])
In [93]: risk['returns'] = np.log(risk['equity'] /
    risk['equity'].shift(1))
In [94]: VaR = scs.scoreatpercentile(equity * risk['returns'], percs)
In [95]: def print_var():
    print('%16s %16s' % ('Confidence Level', 'Value-at-Risk'))
    print(33 * '-')
    for pair in zip(percs, VaR):
    print('%16.2f %16.3f' % (100 - pair[0], -pair[1]))
In [96]: print_var()
    Confidence Level    Value-at-Risk
    99.99400.854

In [97]: hourly = risk.resample('1H', label='right').last()

In [98]: hourly['returns'] = np.log(hourly['equity'] / hourly['equity'].shift(1))

In [99]: VaR = scs.scoreatpercentile(equity * hourly['returns'], percsc)

In [100]: print_var()
Confidence Level Value-at-Risk
99.99389.52499.90372.65799.00205.66297.50186.99995.00164.86990.00101.835

In [101]: import pickle

In [102]: pickle.dump(model, open('algorithm.pkl', 'wb'))

In [103]: algorithm = pickle.load(open('algorithm.pkl', 'rb'))
In [104]: algorithm
Out[104]: SVC(C=1, cache_size=200, class_weight=None, coef0=0.0, decision_function_shape='ovr', degree=3, gamma='auto', kernel='linear', max_iter=-1, probability=False, random_state=None, shrinking=True, tol=0.001, verbose=False)
In [105]: sel = ['tradeId', 'amountK', 'currency', 'grossPL', 'isBuy'] ①
In [106]: def print_positions(pos):
    print('\n\n' + 50 * '=')

print('Going {}.\n'.format(pos))
time.sleep(1.5) ②
print(api.get_open_positions()[sel])
print(50 * '=' + '\n\n')

In [107]: symbol = 'EUR/USD'
bar = '15s'
amount = 100
position = 0
min_bars = lags + 1
df = pd.DataFrame()

In [108]: def automated_strategy(data, dataframe):
    global min_bars, position, df
    ldf = len(dataframe) ①
    df = dataframe.resample(bar, label='right').last().ffill() ②
    if ldf % 20 == 0:
    print('%3d' % len(dataframe), end=',)

    if len(df) > min_bars:
    min_bars = len(df)
    df['Mid'] = df[['Bid', 'Ask']].mean(axis=1)
    df['Returns'] = np.log(df['Mid'] / df['Mid'].shift(1))
    df['Direction'] = np.where(df['Returns'] > 0, 1, -1)
    features = df['Direction'].iloc[-(lags + 1):-1] ③

features = features.values.reshape(1, -1)
signal = algorithm.predict(features)[0]
if position in [0, -1] and signal == 1:
    api.create_market_buy_order(
    symbol, amount - position * amount)
    position = 1
    print_positions('LONG')

elif position in [0, 1] and signal == -1:
    api.create_market_sell_order(
    symbol, amount + position * amount)
    position = -1
    print_positions('SHORT')

if len(dataframe) > 350:
    api unsubscribe_market_data('EUR/USD')
    api.close_all()

2018-07-2509:16:15.568208
====================
NUMBER OF BARS: 24
====================
MOST RECENT DATA
Mid Returns Direction
2018-07-2507:15:301.168885 -0.000009 -12018-07-2507:15:451.1689450.00004312018-07-2507:16:001.168895 -0.000051 -12018-07-2507:16:151.168895 -0.000009 -12018-07-2507:16:301.168885 -0.000017 -1
====================
features: [[ 1 -11 -1 -1]]
position: -1
signal: -12018-07-2509:16:15.581453
====================
no trade placed
*****END OF CYCLE***

2018-07-2509:16:30.069737
====================
NUMBER OF BARS: 25
====================
MOST RECENT DATA
Mid Returns Direction
2018-07-2507:15:451.1689450.00004312018-07-2507:16:001.168895 -0.000051 -12018-07-2507:16:151.168895 -0.000009 -12018-07-2507:16:301.1689500.00003412018-07-2507:16:451.168945 -0.000017 -1
====================
features: [[-11 -1 -11]]
position: -1
signal: 12018-07-2509:16:33.035094
====================
Going LONG.
tradeId amountK currency grossPL isBuy
061476318100 EUR/USD -2 True
====================

#
# FXCM 自动化基于机器学习的交易策略
# 在线算法、日志记录、监控
#


#
import zmq

import time
import pickle
import fxcmpy
import numpy as np
import pandas as pd
import datetime as dt

sel = ['tradeId', 'amountK', 'currency',
    'grossPL', 'isBuy']

log_file = 'automated_strategy.log'

# 加载持久化的算法对象
algorithm = pickle.load(open('algorithm.pkl', 'rb'))

# 通过 ZeroMQ 建立套接字通信（此处为"发布者"）
context = zmq.Context()
socket = context.socket(zmq.PUB)

# 将套接字通信绑定到机器的所有 IP 地址
socket.bind('tcp://0.0.0.0:5555')

def logger_monitor(message, time=True, sep=True):
    ''' 自定义日志记录和监控函数。
    '''
    with open(log_file, 'a') as f:
    t = str(dt.datetime.now())
    msg = ''
    if time:
    msg += '\n' + t + '\n'
    if sep:
    msg += 66 * '=' + '\n'
    msg += message + '\n\n'
    # 通过套接字发送消息
    socket.send_string(msg)
    # 将消息写入日志文件
    f.write(msg)

def report_positions(pos):
    ''' 打印、记录和发送头寸数据。
    '''
    out = '\n\n' + 50 * '=' + '\n'
    out += 'Going {}.\n'.format(pos) + '\n'
    time.sleep(2)  # 等待订单执行
    out += str(api.get_open_positions()[sel]) + '\n'
    out += 50 * '=' + '\n'
    logger_monitor(out)
    print(out)

def automated_strategy(data, dataframe):
    ''' 封装交易逻辑的回调函数。
    '''
    global min_bars, position, df
    # 重采样刻数据
    df = dataframe.resample(bar, label='right').last().ffill()

    if len(df) > min_bars:
    min_bars = len(df)
    logger_monitor('NUMBER OF TICKS: {} | '.format(len(dataframe)) +
    'NUMBER OF BARS: {}'.format(min_bars))
    # 数据处理和特征准备
    df['Mid'] = df[['Bid', 'Ask']].mean(axis=1)
    df['Returns'] = np.log(df['Mid'] / df['Mid'].shift(1))
    df['Direction'] = np.where(df['Returns'] > 0, 1, -1)
    # 选取相关数据点
    features = df['Direction'].iloc[-(lags + 1):-1]
    # 必要的重塑
    features = features.values.reshape(1, -1)
    # 生成信号（+1 或 -1）
    signal = algorithm.predict(features)[0]

    # 记录和发送主要金融信息
    logger_monitor('MOST RECENT DATA\n' +
    str(df[['Mid', 'Returns', 'Direction']].tail()), False)
    logger_monitor('features: ' + str(features) + '\n' +
    'position: ' + str(position) + '\n' +
    'signal: ' + str(signal), False)

    # 交易逻辑
    if position in [0, -1] and signal == 1: # 是否做多？
    api.create_market_buy_order(
    symbol, size - position * size) # 下达买入订单
    position = 1 # 将头寸更改为多头
    report_positions('LONG')

    elif position in [0, 1] and signal == -1: # 是否做空？
    api.create_market_sell_order(
    symbol, size + position * size) # 下达卖出订单
    position = -1 # 将头寸更改为空头
    report_positions('SHORT')

    else: # 不交易
    logger_monitor('no trade placed')

    logger_monitor('****END OF CYCLE***\n\n', False, False)

    if len(dataframe) > 350: # 停止条件
    api.%subscribe_market_data('EUR/USD') # 取消订阅数据流
    report_positions('CLOSE OUT')
    api.%close_all() # 关闭所有未平仓头寸
    logger_monitor('***CLOSING OUT ALL POSITIONS**')

if__name__ == '__main__':
    symbol = 'EUR/USD'  # 要交易的交易品种
    bar = '15s'  # 柱长度；根据测试和部署情况调整
    size = 100  # 头寸规模（千货币单位）
    position = 0  # 初始头寸
    lags = 5  # 特征数据的滞后数量
    min_bars = lags + 1  # 重采样 DataFrame 的最小长度
    df = pd.DataFrame()
    # 根据实际情况调整配置文件位置
    api = fxcmpy.fxcmpy(config_file='../fxcm.cfg')
    # 使用回调函数的主异步循环
    api.subscribe_market_data(symbol, (automated_strategy,))

#
# FXCM 自动化基于机器学习的交易策略
# 通过套接字通信实现策略监控
#


#
import zmq

# 通过 ZeroMQ 建立套接字通信（此处为"订阅者"）
context = zmq.Context()
socket = context.socket(zmq.SUB)

# 调整 IP 地址以反映远程位置
socket.connect('tcp://REMOTE_IP_ADDRESS:5555')

# 配置套接字以检索所有消息
socket.setsockopt_string(zmq.SUBSCRIBE,）

while True:
    msg = socket.recv_string()
    print(msg)