def dataPrepare(self):
startTime = datetime.time(self.tradeEndHour, self.tradeStartMin,
0).strftime("%H:%M:%S")
if self.mode == 4:
d, t = self.start_time.split(' ', 1)
y, m, d = d.split('-', 2)
d = datetime.date(int(y), int(m), int(d))
startDate = (
d -
datetime.timedelta(days=self.backwardDay)).strftime("%Y-%m-%d")
endTime = self.start_time
else:
startDate = (
datetime.date.today() -
datetime.timedelta(days=self.backwardDay)).strftime("%Y-%m-%d")
endTime = datetime.date.today().strftime(
"%Y-%m-%d") + ' ' + startTime
sT = startDate + ' ' + startTime
bars = self.get_bars(self.exchange_id + '.' + self.sec_id,
self.K_min * 60, sT, endTime)
#这里数据只用来计算MA
rownum = 0
for bar in bars:
rownum = self.update_dailyBar(bar)
if rownum % self.K_min == 0 and rownum >= self.K_min:
self.update_dailyBarMin(bar)
self.MAdf = MA.MA(self.dailyBarMin.close, self.MA_Short, self.MA_Long)
self.DMIdf = DMI.DMI(self.dailyBarMin, self.DMI_N, self.DMI_M)
kdjdf = KDJ.KDJ(self.dailyBarMin, self.KDJ_N, self.KDJ_M)
kdjdf['KDJ_True'] = 0
kdjdf.loc[(self.KDJ_HLim > kdjdf['KDJ_K']) &
(kdjdf['KDJ_K'] > kdjdf['KDJ_D']), 'KDJ_True'] = 1
kdjdf.loc[(self.KDJ_LLim < kdjdf['KDJ_K']) &
(kdjdf['KDJ_K'] < kdjdf['KDJ_D']), 'KDJ_True'] = -1
self.KDJdf = kdjdf
#下面要再做实盘下当天数据的处理
if self.mode == 2:
pass
if rownum > 0:
self.last_update_time = datetime.datetime.fromtimestamp(
self.dailyBar.iloc[-1].utctime)
print(
"------------------------data prepared-----------------------------"
)
pass
def train(args, model):
model.train()
loader = DataLoader(MA(
'/Users/zhangweidong03/Code/dl/pytorch/github/piwise/MAdata',
input_transform, target_transform),
num_workers=1,
batch_size=1,
shuffle=True)
weight = torch.ones(2)
weight[0] = 0
use_cuda = False
if use_cuda:
criterion = CrossEntropyLoss2d(weight.cuda())
else:
criterion = CrossEntropyLoss2d(weight)
criterion = CrossEntropyLoss2d()
optimizer = SGD(model.parameters(), 1e-4, .9, 2e-5)
for epoch in range(1, 51):
epoch_loss = []
for step, (images, labels) in enumerate(loader):
if use_cuda:
images = images.cuda()
labels = labels.cuda()
inputs = Variable(images)
targets = Variable(labels)
outputs = model(inputs)
optimizer.zero_grad()
loss = criterion(outputs, targets[:, 0])
loss.backward()
optimizer.step()
epoch_loss.append(loss.data[0])
average = sum(epoch_loss) / len(epoch_loss)
print(f'loss: {average} (epoch: {epoch}, step: {step})')
def train(args, model):
model.train()
# loader = DataLoader(MA('/Users/zhangweidong03/Code/dl/pytorch/github/piwise/MAdata', input_transform, target_transform),
# num_workers=1, batch_size=1, shuffle=True)
loader = DataLoader(MA(args.datadir, input_transform, target_transform),
num_workers=args.num_workers,
batch_size=args.batch_size,
shuffle=True)
weight = torch.ones(2)
weight[0] = 0
use_cuda = False
if args.cuda:
criterion = CrossEntropyLoss2d(weight.cuda())
else:
criterion = CrossEntropyLoss2d(weight)
criterion = CrossEntropyLoss2d()
# optimizer = SGD(model.parameters(), 1e-4, .9, 2e-5)
optimizer = Adam(model.parameters())
if args.model.startswith('FCN'):
optimizer = SGD(model.parameters(), 1e-4, .9, 2e-5)
if args.model.startswith('PSP'):
optimizer = SGD(model.parameters(), 1e-2, .9, 1e-4)
if args.model.startswith('Seg'):
optimizer = SGD(model.parameters(), 1e-3, .9)
# for epoch in range(1, 51):
# epoch_loss = []
#
# for step, (images, labels) in enumerate(loader):
# if use_cuda:
# images = images.cuda()
# labels = labels.cuda()
#
# inputs = Variable(images)
# targets = Variable(labels)
# outputs = model(inputs)
#
# optimizer.zero_grad()
# loss = criterion(outputs, targets[:, 0])
# loss.backward()
# optimizer.step()
#
# epoch_loss.append(loss.data[0])
#
# average = sum(epoch_loss) / len(epoch_loss)
# print(f'loss: {average} (epoch: {epoch}, step: {step})')
if args.steps_plot > 0:
board = Dashboard(args.port)
for epoch in range(1, args.num_epochs + 1):
epoch_loss = []
for step, (images, labels) in enumerate(loader):
if args.cuda:
images = images.cuda()
labels = labels.cuda()
inputs = Variable(images)
targets = Variable(labels)
outputs = model(inputs)
optimizer.zero_grad()
loss = criterion(outputs, targets[:, 0])
loss.backward()
optimizer.step()
epoch_loss.append(loss.data[0])
if args.steps_plot > 0 and step % args.steps_plot == 0:
image = inputs[0].cpu().data
image[0] = image[0] * .229 + .485
image[1] = image[1] * .224 + .456
image[2] = image[2] * .225 + .406
board.image(image, f'input (epoch: {epoch}, step: {step})')
board.image(color_transform(outputs[0].cpu().max(0)[1].data),
f'output (epoch: {epoch}, step: {step})')
board.image(color_transform(targets[0].cpu().data),
f'target (epoch: {epoch}, step: {step})')
if args.steps_loss > 0 and step % args.steps_loss == 0:
average = sum(epoch_loss) / len(epoch_loss)
print(f'loss: {average} (epoch: {epoch}, step: {step})')
if args.steps_save > 0 and step % args.steps_save == 0:
filename = f'{args.model}-{epoch:03}-{step:04}.pth'
torch.save(model.state_dict(), filename)
print(f'save: {filename} (epoch: {epoch}, step: {step})')
def LvyiWin(symbolinfo, rawdata, paraset):
setname = paraset['Setname']
KDJ_N = paraset['KDJ_N']
KDJ_M = paraset['KDJ_M']
KDJ_HLim = paraset['KDJ_HLim']
KDJ_LLim = paraset['KDJ_LLim']
DMI_N = paraset['DMI_N']
DMI_M = paraset['DMI_M']
MA_Short = paraset['MA_Short']
MA_Long = paraset['MA_Long']
rawdata['Unnamed: 0'] = range(rawdata.shape[0])
beginindex = rawdata.ix[0, 'Unnamed: 0']
# 处理KDJ数据：KDJ_OPEN做为最终KDJ的触发信号
# KDJ_True=1:80>k>D
# KDJ_True=-1:20<K<D
df_KDJ = KDJ.KDJ(rawdata, N=KDJ_N, M=KDJ_M)
df_KDJ['KDJ_True'] = 0
df_KDJ.loc[(KDJ_HLim > df_KDJ['KDJ_K']) & (df_KDJ['KDJ_K'] > df_KDJ['KDJ_D']), 'KDJ_True'] = 1
df_KDJ.loc[(KDJ_LLim < df_KDJ['KDJ_K']) & (df_KDJ['KDJ_K'] < df_KDJ['KDJ_D']), 'KDJ_True'] = -1
# 处理DMI数据：DMI_GOLD_CROSS做为DMI的触发信号
# DMI_True=1:and PDI>MDI
# DMI_True=-1:and PDI<MDI
df_DMI = DMI.DMI(rawdata, N=DMI_N, M=DMI_M)
'''
#2017-10-26 10:44
DMI_True的计算，移到DMI模块中执行
df_DMI['DMI_True']=0
df_DMI.loc[df_DMI['PDI']> df_DMI['MDI'], 'DMI_True'] = 1
df_DMI.loc[df_DMI['PDI']< df_DMI['MDI'], 'DMI_True'] = -1
'''
# 处理MA数据：MA_Cross做为MA的触发信号
# MA20_True=1:close>MA20
# MA20_True=-1:close<MA20
df_MA = MA.MA(rawdata['close'], MA_Short, MA_Long)
'''
#2017-10-26:
MA的计算转移到MA模块中
df_MA=pd.DataFrame({'close':rawdata['close']})
df_MA['MA_Short']=MA.calMA(df_MA['close'],MA_Short)
df_MA['MA_Long']=MA.calMA(df_MA['close'],MA_Long)
df_MA['MA_True'],df_MA['MA_Cross']=MA.dfCross(df_MA,'MA_Short','MA_Long')
'''
'''
#处理BOLL数据：BOLL_Cross做为BOLL平仓的触发信号
df_BOLL=BOLL.BOLL(rawdata,N=BOLL_N,M=BOLL_M,P=BOLL_P)
df_BOLL['BOLL_True']=0
df_BOLL.loc[df_BOLL['close']< df_BOLL['BOTTOM'], 'BOLL_True'] = -1
df_BOLL.loc[df_BOLL['close']> df_BOLL['TOP'], 'BOLL_True'] = 1
#BOLL的金叉，BOLL_True从0变成1是金叉，从0变成-1是死叉
df_BOLL['BOLL_Cross']=0
df_BOLL['bigger1'] = df_BOLL['BOLL_True'].shift(1).fillna(0)
df_BOLL.loc[(df_BOLL['BOLL_True']==1)&(df_BOLL['bigger1']==0), 'BOLL_Cross'] = 1
df_BOLL.loc[(df_BOLL['BOLL_True']==-1)&(df_BOLL['bigger1']==0), 'BOLL_Cross'] = -1
df_BOLL.drop('bigger1', axis=1, inplace=True)
df_BOLL.to_csv('df_BOLL.csv')
df_BOLL.drop('close',axis=1,inplace=True)
'''
df_MA.drop('close', axis=1, inplace=True)
df = pd.concat([rawdata, df_DMI, df_KDJ, df_MA], axis=1)
# 找出买卖点：
# 1.先找出MA金叉的买卖点
# 2.找到结合判决条件的买点
# 3.从MA买点中滤出真实买卖点
# 取出金叉点
goldcrosslist = pd.DataFrame({'goldcrosstime': df.loc[df['MA_Cross'] == 1, 'strtime']})
goldcrosslist['goldcrossutc'] = df.loc[df['MA_Cross'] == 1, 'utc_time']
goldcrosslist['goldcrossindex'] = df.loc[df['MA_Cross'] == 1, 'Unnamed: 0'] - beginindex
goldcrosslist['goldcrossprice'] = df.loc[df['MA_Cross'] == 1, 'close']
# 取出死叉点
deathcrosslist = pd.DataFrame({'deathcrosstime': df.loc[df['MA_Cross'] == -1, 'strtime']})
deathcrosslist['deathcrossutc'] = df.loc[df['MA_Cross'] == -1, 'utc_time']
deathcrosslist['deathcrossindex'] = df.loc[df['MA_Cross'] == -1, 'Unnamed: 0'] - beginindex
deathcrosslist['deathcrossprice'] = df.loc[df['MA_Cross'] == -1, 'close']
goldcrosslist = goldcrosslist.reset_index(drop=True)
deathcrosslist = deathcrosslist.reset_index(drop=True)
# 生成多仓序列（金叉在前，死叉在后）
if goldcrosslist.ix[0, 'goldcrossindex'] < deathcrosslist.ix[0, 'deathcrossindex']:
longcrosslist = pd.concat([goldcrosslist, deathcrosslist], axis=1)
else: # 如果第一个死叉的序号在金叉前，则要将死叉往上移1格
longcrosslist = pd.concat([goldcrosslist, deathcrosslist.shift(-1).fillna(0)], axis=1)
longcrosslist = longcrosslist.set_index(pd.Index(longcrosslist['goldcrossindex']), drop=True)
# 生成空仓序列（死叉在前，金叉在后）
if deathcrosslist.ix[0, 'deathcrossindex'] < goldcrosslist.ix[0, 'goldcrossindex']:
shortcrosslist = pd.concat([deathcrosslist, goldcrosslist], axis=1)
else: # 如果第一个金叉的序号在死叉前，则要将金叉往上移1格
shortcrosslist = pd.concat([deathcrosslist, goldcrosslist.shift(-1).fillna(0)], axis=1)
shortcrosslist = shortcrosslist.set_index(pd.Index(shortcrosslist['deathcrossindex']), drop=True)
# 取出开多序号和开空序号
openlongindex = df.loc[(df['MA_Cross'] == 1) & (df['KDJ_True'] == 1) & (df['DMI_True'] == 1)].index
openshortindex = df.loc[(df['MA_Cross'] == -1) & (df['KDJ_True'] == -1) & (df['DMI_True'] == -1)].index
# 从多仓序列中取出开多序号的内容，即为开多操作
longopr = longcrosslist.loc[openlongindex]
longopr['tradetype'] = 1
longopr.rename(columns={'goldcrosstime': 'opentime',
'goldcrossutc': 'openutc',
'goldcrossindex': 'openindex',
'goldcrossprice': 'openprice',
'deathcrosstime': 'closetime',
'deathcrossutc': 'closeutc',
'deathcrossindex': 'closeindex',
'deathcrossprice': 'closeprice'}, inplace=True)
# 从空仓序列中取出开空序号的内容，即为开空操作
shortopr = shortcrosslist.loc[openshortindex]
shortopr['tradetype'] = -1
shortopr.rename(columns={'deathcrosstime': 'opentime',
'deathcrossutc': 'openutc',
'deathcrossindex': 'openindex',
'deathcrossprice': 'openprice',
'goldcrosstime': 'closetime',
'goldcrossutc': 'closeutc',
'goldcrossindex': 'closeindex',
'goldcrossprice': 'closeprice'}, inplace=True)
# 结果分析
result = pd.concat([longopr, shortopr])
result = result.sort_index()
result = result.reset_index(drop=True)
result.drop(result.shape[0] - 1, inplace=True)
# 去掉跨合约的操作
# 使用单合约，不用再去掉跨合约
# result = removeContractSwap(result, contractswaplist)
slip = symbolinfo.getSlip()
result['ret'] = ((result['closeprice'] - result['openprice']) * result['tradetype']) - slip
result['ret_r'] = result['ret'] / result['openprice']
results = {}
'''
# 使用单合约，策略核心内不再计算结果
if calcResult:
result['commission_fee'], result['per earn'], result['own cash'], result['hands'] = RS.calcResult(result,
symbolinfo,
initialCash,
positionRatio)
endcash = result['own cash'].iloc[-1]
Annual = RS.annual_return(result)
Sharpe = RS.sharpe_ratio(result)
DrawBack = RS.max_drawback(result)[0]
SR = RS.success_rate(result)
max_single_loss_rate = abs(result['ret_r'].min())
results = {
'Setname':setname,
'opentimes': result.shape[0],
'end_cash': endcash,
'SR': SR,
'Annual': Annual,
'Sharpe': Sharpe,
'DrawBack': DrawBack,
'max_single_loss_rate': max_single_loss_rate
}
closeopr = result.loc[:, 'closetime':'tradetype']
return result, df, closeopr, results
'''
return result
def LvyiNoKDJWin(symbolinfo,
setname,
rawdata,
paraset,
contractswaplist,
calcResult=True):
print setname
DMI_N = paraset['DMI_N']
DMI_M = paraset['DMI_M']
MA_Short = paraset['MA_Short']
MA_Long = paraset['MA_Long']
beginindex = rawdata.ix[0, 'Unnamed: 0']
df_DMI = DMI.DMI(rawdata, N=DMI_N, M=DMI_M)
df_MA = MA.MA(rawdata['close'], MA_Short, MA_Long)
df_MA.drop('close', axis=1, inplace=True)
df = pd.concat([rawdata, df_DMI, df_MA], axis=1)
# 找出买卖点：
# 1.先找出MA金叉的买卖点
# 2.找到结合判决条件的买点
# 3.从MA买点中滤出真实买卖点
# 取出金叉点
goldcrosslist = pd.DataFrame(
{'goldcrosstime': df.loc[df['MA_Cross'] == 1, 'strtime']})
goldcrosslist['goldcrossutc'] = df.loc[df['MA_Cross'] == 1, 'utc_time']
goldcrosslist['goldcrossindex'] = df.loc[df['MA_Cross'] == 1,
'Unnamed: 0'] - beginindex
goldcrosslist['goldcrossprice'] = df.loc[df['MA_Cross'] == 1, 'close']
# 取出死叉点
deathcrosslist = pd.DataFrame(
{'deathcrosstime': df.loc[df['MA_Cross'] == -1, 'strtime']})
deathcrosslist['deathcrossutc'] = df.loc[df['MA_Cross'] == -1, 'utc_time']
deathcrosslist['deathcrossindex'] = df.loc[df['MA_Cross'] == -1,
'Unnamed: 0'] - beginindex
deathcrosslist['deathcrossprice'] = df.loc[df['MA_Cross'] == -1, 'close']
goldcrosslist = goldcrosslist.reset_index(drop=True)
deathcrosslist = deathcrosslist.reset_index(drop=True)
# 生成多仓序列（金叉在前，死叉在后）
if goldcrosslist.ix[0, 'goldcrossindex'] < deathcrosslist.ix[
0, 'deathcrossindex']:
longcrosslist = pd.concat([goldcrosslist, deathcrosslist], axis=1)
else: # 如果第一个死叉的序号在金叉前，则要将死叉往上移1格
longcrosslist = pd.concat(
[goldcrosslist, deathcrosslist.shift(-1).fillna(0)], axis=1)
longcrosslist = longcrosslist.set_index(pd.Index(
longcrosslist['goldcrossindex']),
drop=True)
# 生成空仓序列（死叉在前，金叉在后）
if deathcrosslist.ix[0, 'deathcrossindex'] < goldcrosslist.ix[
0, 'goldcrossindex']:
shortcrosslist = pd.concat([deathcrosslist, goldcrosslist], axis=1)
else: # 如果第一个金叉的序号在死叉前，则要将金叉往上移1格
shortcrosslist = pd.concat(
[deathcrosslist, goldcrosslist.shift(-1).fillna(0)], axis=1)
shortcrosslist = shortcrosslist.set_index(pd.Index(
shortcrosslist['deathcrossindex']),
drop=True)
#取出开多序号和开空序号
openlongindex = df.loc[(df['MA_Cross'] == 1) & (df['DMI_True'] == 1)].index
openshortindex = df.loc[(df['MA_Cross'] == -1)
& (df['DMI_True'] == -1)].index
# 从多仓序列中取出开多序号的内容，即为开多操作
longopr = longcrosslist.loc[openlongindex]
longopr['tradetype'] = 1
longopr.rename(columns={
'goldcrosstime': 'opentime',
'goldcrossutc': 'openutc',
'goldcrossindex': 'openindex',
'goldcrossprice': 'openprice',
'deathcrosstime': 'closetime',
'deathcrossutc': 'closeutc',
'deathcrossindex': 'closeindex',
'deathcrossprice': 'closeprice'
},
inplace=True)
# 从空仓序列中取出开空序号的内容，即为开空操作
shortopr = shortcrosslist.loc[openshortindex]
shortopr['tradetype'] = -1
shortopr.rename(columns={
'deathcrosstime': 'opentime',
'deathcrossutc': 'openutc',
'deathcrossindex': 'openindex',
'deathcrossprice': 'openprice',
'goldcrosstime': 'closetime',
'goldcrossutc': 'closeutc',
'goldcrossindex': 'closeindex',
'goldcrossprice': 'closeprice'
},
inplace=True)
# 结果分析
result = pd.concat([longopr, shortopr])
result = result.sort_index()
result = result.reset_index(drop=True)
result.drop(result.shape[0] - 1, inplace=True)
# 去掉跨合约的操作
result = removeContractSwap(result, contractswaplist)
initial_cash = 20000
margin_rate = 0.2
slip = symbolinfo.getSlip()
multiplier = symbolinfo.getMultiplier()
poundgeType, poundgeFee, poundgeRate = symbolinfo.getPoundage()
result['ret'] = ((result['closeprice'] - result['openprice']) *
result['tradetype']) - slip
result['ret_r'] = result['ret'] / result['openprice']
results = {}
if calcResult:
firsttradecash = initial_cash / margin_rate
result['commission_fee'] = 0
if poundgeType == symbolinfo.POUNDGE_TYPE_RATE:
result.ix[0, 'commission_fee'] = firsttradecash * poundgeRate * 2
else:
result.ix[0, 'commission_fee'] = firsttradecash / (
multiplier * result.ix[0, 'openprice']) * poundgeFee * 2
result['per earn'] = 0 # 单笔盈亏
result['own cash'] = 0 # 自有资金线
result['trade money'] = 0 # 杠杆后的可交易资金线
result.ix[0, 'per earn'] = firsttradecash * result.ix[0, 'ret_r']
result.ix[0, 'own cash'] = initial_cash + result.ix[
0, 'per earn'] - result.ix[0, 'commission_fee']
result.ix[0, 'trade money'] = result.ix[0, 'own cash'] / margin_rate
oprtimes = result.shape[0]
for i in np.arange(1, oprtimes):
# 根据手续费类型计算手续费
if poundgeType == symbolinfo.POUNDGE_TYPE_RATE:
commission = result.ix[i - 1, 'trade money'] * poundgeRate * 2
else:
commission = result.ix[i - 1, 'trade money'] / (
multiplier * result.ix[i, 'openprice']) * poundgeFee * 2
perearn = result.ix[i - 1, 'trade money'] * result.ix[i, 'ret_r']
owncash = result.ix[i - 1, 'own cash'] + perearn - commission
result.ix[i, 'own cash'] = owncash
result.ix[i, 'commission_fee'] = commission
result.ix[i, 'per earn'] = perearn
result.ix[i, 'trade money'] = owncash / margin_rate
endcash = result.ix[oprtimes - 1, 'own cash']
Annual = RS.annual_return(result)
Sharpe = RS.sharpe_ratio(result)
DrawBack = RS.max_drawback(result)[0]
SR = RS.success_rate(result)
max_single_loss_rate = abs(result['ret_r'].min())
results = {
'Setname': setname,
'MA_Short': MA_Short,
'MA_Long': MA_Long,
'DMI_N': DMI_N,
'opentimes': oprtimes,
'end_cash': endcash,
'SR': SR,
'Annual': Annual,
'Sharpe': Sharpe,
'DrawBack': DrawBack,
'max_single_loss_rate': max_single_loss_rate
}
closeopr = result.loc[:, 'closetime':'tradetype']
return result, df, closeopr, results
def LvyiWin_wave(rawdata, paraset):
# 计算双均线的金叉死叉，形成多空操作文件
MA_Short = paraset['MA_Short']
MA_Long = paraset['MA_Long']
rawdata['Unnamed: 0'] = range(rawdata.shape[0])
beginindex = rawdata.ix[0, 'Unnamed: 0']
df_MA = MA.MA(rawdata['close'], MA_Short, MA_Long)
df_MA.drop('close', axis=1, inplace=True)
df = pd.concat([rawdata, df_MA], axis=1)
goldcrosslist = pd.DataFrame(
{'goldcrosstime': df.loc[df['MA_Cross'] == 1, 'strtime']})
goldcrosslist['goldcrossutc'] = df.loc[df['MA_Cross'] == 1, 'utc_time']
goldcrosslist['goldcrossindex'] = df.loc[df['MA_Cross'] == 1,
'Unnamed: 0'] - beginindex
goldcrosslist['goldcrossprice'] = df.loc[df['MA_Cross'] == 1, 'close']
# 取出死叉点
deathcrosslist = pd.DataFrame(
{'deathcrosstime': df.loc[df['MA_Cross'] == -1, 'strtime']})
deathcrosslist['deathcrossutc'] = df.loc[df['MA_Cross'] == -1, 'utc_time']
deathcrosslist['deathcrossindex'] = df.loc[df['MA_Cross'] == -1,
'Unnamed: 0'] - beginindex
deathcrosslist['deathcrossprice'] = df.loc[df['MA_Cross'] == -1, 'close']
goldcrosslist = goldcrosslist.reset_index(drop=True)
deathcrosslist = deathcrosslist.reset_index(drop=True)
# 生成多仓序列（金叉在前，死叉在后）
if goldcrosslist.ix[0, 'goldcrossindex'] < deathcrosslist.ix[
0, 'deathcrossindex']:
longcrosslist = pd.concat([goldcrosslist, deathcrosslist], axis=1)
else: # 如果第一个死叉的序号在金叉前，则要将死叉往上移1格
longcrosslist = pd.concat(
[goldcrosslist, deathcrosslist.shift(-1)], axis=1)
longcrosslist = longcrosslist.set_index(pd.Index(
longcrosslist['goldcrossindex']),
drop=True)
# 生成空仓序列（死叉在前，金叉在后）
if deathcrosslist.ix[0, 'deathcrossindex'] < goldcrosslist.ix[
0, 'goldcrossindex']:
shortcrosslist = pd.concat([deathcrosslist, goldcrosslist], axis=1)
else: # 如果第一个金叉的序号在死叉前，则要将金叉往上移1格
shortcrosslist = pd.concat(
[deathcrosslist, goldcrosslist.shift(-1)], axis=1)
shortcrosslist = shortcrosslist.set_index(pd.Index(
shortcrosslist['deathcrossindex']),
drop=True)
longcrosslist['tradetype'] = 1
longcrosslist.rename(columns={
'goldcrosstime': 'opentime',
'goldcrossutc': 'openutc',
'goldcrossindex': 'openindex',
'goldcrossprice': 'openprice',
'deathcrosstime': 'closetime',
'deathcrossutc': 'closeutc',
'deathcrossindex': 'closeindex',
'deathcrossprice': 'closeprice'
},
inplace=True)
shortcrosslist['tradetype'] = -1
shortcrosslist.rename(columns={
'deathcrosstime': 'opentime',
'deathcrossutc': 'openutc',
'deathcrossindex': 'openindex',
'deathcrossprice': 'openprice',
'goldcrosstime': 'closetime',
'goldcrossutc': 'closeutc',
'goldcrossindex': 'closeindex',
'goldcrossprice': 'closeprice'
},
inplace=True)
# 结果分析
result = pd.concat([longcrosslist, shortcrosslist])
result = result.sort_index()
result = result.reset_index(drop=True)
result['wave_time'] = result['closeindex'] - result['openindex']
result['wave_height'] = np.abs(result['closeprice'] -
result['openprice']) # 高度取绝对值
result.dropna(inplace=True)
return result
#Conver output label to one hot vector
Ytrain = to_categorical(Ytrain, number_of_classes)
Ytest = to_categorical(Ytest, number_of_classes)
# 10% of this reduced sample is used as the reduced validation set.
Xtrain, Xvalid, Ytrain, Yvalid = train_test_split(Xtrain, Ytrain,
test_size = int(Xtrain.shape[0] * 0.1), random_state = 42)
print("Shape of training features: {}".format(Xtrain.shape))
print("Shape of training lables: {}".format(Ytrain.shape))
print("Shape of testing features: {}".format(Xvalid.shape))
print("Shape of testing lables: {}".format(Yvalid.shape))
# Hyper parameters
learning_rate = 0.0001
batch_size = 32
Xtrain = Xtrain.astype('float32')
Xvalid = Xvalid.astype('float32')
# MO (Microcanonical Optimization) Parameters
parameters = {'x_train': Xtrain , 'y_train': Ytrain, 'x_valid': Xvalid, 'y_valid': Yvalid, 'batch_size':batch_size, 'learning_rate':0.0001}
# Start MO Algorithm (MA == MO)
alg = microcanonical.MA(**parameters)
alg.startAlgorithm()
## Outputs:
# model_history.txt: The loss and accuracy values (per epoch) of each model produced for training and validation are stored.
# models.txt: Store iteration number, model_no, #parameters, Flops, train accuracy, validation accuracy and model topology
# *.json files: Stores information about the topology of solutions on the Pareto front (Keras Model).
def LvyiLtrWin(symbolinfo, rawdata, paraset):
setname = paraset['Setname']
LTR_TIME = paraset['LTR_TIME']
KDJ_N = paraset['KDJ_N']
KDJ_M = paraset['KDJ_M']
KDJ_HLim = paraset['KDJ_HLim']
KDJ_LLim = paraset['KDJ_LLim']
DMI_N = paraset['DMI_N']
DMI_M = paraset['DMI_M']
MA_Short = paraset['MA_Short']
MA_Long = paraset['MA_Long']
rawdata['Unnamed: 0'] = range(rawdata.shape[0])
beginindex = rawdata.ix[0, 'Unnamed: 0']
# 处理KDJ数据：KDJ_OPEN做为最终KDJ的触发信号
df_KDJ = KDJ.KDJ(rawdata, N=KDJ_N, M=KDJ_M)
df_KDJ['KDJ_True'] = 0
df_KDJ.loc[(KDJ_HLim > df_KDJ['KDJ_K']) &
(df_KDJ['KDJ_K'] > df_KDJ['KDJ_D']), 'KDJ_True'] = 1
df_KDJ.loc[(KDJ_LLim < df_KDJ['KDJ_K']) &
(df_KDJ['KDJ_K'] < df_KDJ['KDJ_D']), 'KDJ_True'] = -1
df_DMI = DMI.DMI(rawdata, N=DMI_N, M=DMI_M)
df_MA = MA.MA(rawdata['close'], MA_Short, MA_Long)
df_MA.drop('close', axis=1, inplace=True)
df = pd.concat([rawdata, df_DMI, df_KDJ, df_MA], axis=1)
goldcrosslist = pd.DataFrame(
{'goldcrosstime': df.loc[df['MA_Cross'] == 1, 'strtime']})
goldcrosslist['goldcrossutc'] = df.loc[df['MA_Cross'] == 1, 'utc_time']
goldcrosslist['goldcrossindex'] = df.loc[df['MA_Cross'] == 1,
'Unnamed: 0'] - beginindex
goldcrosslist['goldcrossprice'] = df.loc[df['MA_Cross'] == 1, 'close']
# 取出死叉点
deathcrosslist = pd.DataFrame(
{'deathcrosstime': df.loc[df['MA_Cross'] == -1, 'strtime']})
deathcrosslist['deathcrossutc'] = df.loc[df['MA_Cross'] == -1, 'utc_time']
deathcrosslist['deathcrossindex'] = df.loc[df['MA_Cross'] == -1,
'Unnamed: 0'] - beginindex
deathcrosslist['deathcrossprice'] = df.loc[df['MA_Cross'] == -1, 'close']
goldcrosslist = goldcrosslist.reset_index(drop=True)
deathcrosslist = deathcrosslist.reset_index(drop=True)
# 生成多仓序列（金叉在前，死叉在后）
if goldcrosslist.ix[0, 'goldcrossindex'] < deathcrosslist.ix[
0, 'deathcrossindex']:
longcrosslist = pd.concat([goldcrosslist, deathcrosslist], axis=1)
else: # 如果第一个死叉的序号在金叉前，则要将死叉往上移1格
longcrosslist = pd.concat(
[goldcrosslist, deathcrosslist.shift(-1).fillna(0)], axis=1)
longcrosslist = longcrosslist.set_index(pd.Index(
longcrosslist['goldcrossindex']),
drop=True)
# 生成空仓序列（死叉在前，金叉在后）
if deathcrosslist.ix[0, 'deathcrossindex'] < goldcrosslist.ix[
0, 'goldcrossindex']:
shortcrosslist = pd.concat([deathcrosslist, goldcrosslist], axis=1)
else: # 如果第一个金叉的序号在死叉前，则要将金叉往上移1格
shortcrosslist = pd.concat(
[deathcrosslist, goldcrosslist.shift(-1).fillna(0)], axis=1)
shortcrosslist = shortcrosslist.set_index(pd.Index(
shortcrosslist['deathcrossindex']),
drop=True)
longcrosslist['tradetype'] = 1
longcrosslist.rename(columns={
'goldcrosstime': 'opentime',
'goldcrossutc': 'openutc',
'goldcrossindex': 'openindex',
'goldcrossprice': 'openprice',
'deathcrosstime': 'closetime',
'deathcrossutc': 'closeutc',
'deathcrossindex': 'closeindex',
'deathcrossprice': 'closeprice'
},
inplace=True)
shortcrosslist['tradetype'] = -1
shortcrosslist.rename(columns={
'deathcrosstime': 'opentime',
'deathcrossutc': 'openutc',
'deathcrossindex': 'openindex',
'deathcrossprice': 'openprice',
'goldcrosstime': 'closetime',
'goldcrossutc': 'closeutc',
'goldcrossindex': 'closeindex',
'goldcrossprice': 'closeprice'
},
inplace=True)
result = pd.concat([longcrosslist, shortcrosslist])
result = result.sort_index()
result = result.reset_index(drop=True)
result['wave_time'] = result['closeindex'] - result['openindex']
result['wave_height'] = np.abs(result['closeprice'] -
result['openprice']) # 高度取绝对值
result['ltr_flag'] = 0
result.loc[result['wave_time'] > LTR_TIME, 'ltr_flag'] = 1
result['wave_index'] = range(0, result.shape[0])
result.loc[result['ltr_flag'] == 1, 'ltr_index'] = result['wave_index']
result.fillna(method='ffill', axis=0, inplace=True)
result.fillna(0, inplace=True)
result.loc[
result['ltr_index'] == 0,
'ltr_index'] = result['wave_index'] + 1 # 加1是为了确保开始没有大行情的操作的距离为0
result['ltr_distance'] = result['wave_index'] - result['ltr_index'].shift(
1).fillna(0)
result.fillna(0, inplace=True)
# 从多仓序列中取出开多序号的内容，即为开多操作
longopr = result.loc[(df['MA_Cross'] == 1) & (df['KDJ_True'] == 1) &
(df['DMI_True'] == 1)]
# 从空仓序列中取出开空序号的内容，即为开空操作
shortopr = result.loc[(df['MA_Cross'] == -1) & (df['KDJ_True'] == -1) &
(df['DMI_True'] == -1)]
# 结果分析
result1 = pd.concat([longopr, shortopr])
result1 = result1.sort_index()
result1 = result1.reset_index(drop=True)
result1.dropna(inplace=True)
slip = symbolinfo.getSlip()
result1['ret'] = ((result1['closeprice'] - result1['openprice']) *
result1['tradetype']) - slip
result1['ret_r'] = result1['ret'] / result1['openprice']
return result1
def bar(code,
conn=None,
start_date=None,
end_date=None,
freq='D',
asset='E',
market='',
adj=None,
ma=[],
factors=[],
retry_count=3):
"""
BAR数据
Parameters:
------------
code:证券代码，支持股票,ETF/LOF,期货/期权,港股
con:服务器连接 ，通过ts.api()或者ts.xpi()获得
start_date:开始日期 YYYY-MM-DD/YYYYMMDD
end_date:结束日期 YYYY-MM-DD/YYYYMMDD
freq:支持1/5/15/30/60分钟,周/月/季/年
asset:证券类型 E:股票和交易所基金，INDEX:沪深指数,X:期货/期权/港股/中概美国/中证指数/国际指数
market:市场代码，通过ts.get_markets()获取
adj:复权类型,None不复权,qfq:前复权,hfq:后复权
ma:均线,支持自定义均线频度，如：ma5/ma10/ma20/ma60/maN
factors因子数据，目前支持以下两种：
vr:量比,默认不返回，返回需指定：factor=['vr']
tor:换手率，默认不返回，返回需指定：factor=['tor']
以上两种都需要：factor=['vr', 'tor']
retry_count:网络重试次数
Return
----------
DataFrame
code:代码
open：开盘close/high/low/vol成交量/amount成交额/maN均价/vr量比/tor换手率
期货(asset='X')
code/open/close/high/low/avg_price：均价 position：持仓量 vol：成交总量
"""
code = code.strip().upper()
for _ in range(retry_count):
try:
if conn is None:
print(ct.MSG_NOT_CONNECTED)
return None
api, xapi = conn
ktype = freq.strip().upper()
asset = asset.strip().upper()
mkcode = _get_mkcode(code, asset=asset,
xapi=xapi) if market == '' else market
if asset in ['E', 'INDEX']:
func = getattr(api, ct.ASSET[asset])
else:
ktype = 'XD' if ktype == 'D' else ktype
func = getattr(xapi, ct.ASSET['X'])
if ktype in ct.KTYPE_LOW_COLS:
data = pd.DataFrame()
for i in range(100):
ds = func(ct.KTYPE[ktype], mkcode, code, i * 800, 800)
df = api.to_df(ds)
data = data.append(df) if i == 0 else df.append(
data, ignore_index=True)
if len(ds) < 800:
break
data['datetime'] = data['datetime'].apply(
lambda x: str(x[0:10]))
if ktype in ct.KTYPE_ARR:
data = pd.DataFrame()
for i in range(100):
ds = func(ct.KTYPE[ktype], mkcode, code, i * 800, 800)
df = api.to_df(ds)
data = data.append(df) if i == 0 else df.append(
data, ignore_index=True)
if len(ds) < 800:
break
data['datetime'] = pd.to_datetime(data['datetime'])
data = data.assign(code=str(code)) \
.set_index('datetime', drop=True, inplace=False) \
.drop(ct.T_DROP_COLS, axis=1)[ None if start_date == '' else start_date :
None if end_date == '' else end_date]
data = data.sort_index(ascending=False)
if asset in ['E', 'INDEX']:
data = data[ct.BAR_E_COLS]
if ktype in ct.KTYPE_ARR:
data['vol'] = data['vol'] / 100
else:
data = data[ct.BAR_X_COLS]
if mkcode in [28, 29, 30, 47, 60]:
data.columns = ct.BAR_X_FUTURE_COLS
data = data[ct.BAR_X_FUTURE_RL_COLS]
else:
data = data.drop(['price', 'position'], axis=1)
data.columns = ct.BAR_X_OTHER_COLS
if asset == 'E':
if adj is not None:
df = factor_adj(code)
if ktype in ct.KTYPE_LOW_COLS:
data = data.merge(df,
left_index=True,
right_index=True)
data['adj_factor'] = data['adj_factor'].fillna(
method='bfill')
else:
def get_val(day):
return df.loc[day]['adj_factor']
data['adj_factor'] = data.index.map(
lambda x: get_val(str(x)[0:10]))
for col in ct.BAR_E_COLS[1:5]:
if adj == 'hfq':
data[col] = data[col] * data['adj_factor']
else:
data[col] = data[col] * data['adj_factor'] / float(
df['adj_factor'][0])
data[col] = data[col].map(ct.FORMAT)
data = data.drop('adj_factor', axis=1)
if factors is not None and len(factors) > 0:
if 'tor' in factors:
df = factor_shares(code)
if ktype in ct.KTYPE_LOW_COLS:
data = data.merge(df,
left_index=True,
right_index=True)
data['floats'] = data['floats'].fillna(
method='bfill')
else:
def get_val(day):
return df.loc[day]['floats']
data['floats'] = data.index.map(
lambda x: get_val(str(x)[0:10]))
data['tor'] = data['vol'] / data['floats']
data['tor'] = data['tor'].map(ct.FORMAT)
data['tor'] = data['tor'].astype(float)
data = data.drop('floats', axis=1)
if 'vr' in factors:
data['vol5'] = MA(data['vol'], 5)
data['mean'] = data['vol5'].shift(-5)
data['vr'] = (data['vol'] / data['mean']).map(
ct.FORMAT)
data['vr'] = data['vr'].astype(float)
data = data.drop(['vol5', 'mean'], axis=1)
if ma is not None and len(ma) > 0:
for a in ma:
if isinstance(a, int):
data['ma%s' % a] = MA(data['close'],
a).map(ct.FORMAT).shift(-(a - 1))
data['ma%s' % a] = data['ma%s' % a].astype(float)
for col in ['open', 'high', 'low', 'close']:
data[col] = data[col].astype(float)
data['p_change'] = data['close'].pct_change(-1) * 100
data['p_change'] = data['p_change'].map(ct.FORMAT).astype(float)
return data
except:
return None
else:
data['p_change'] = data['close'].pct_change(-1) * 100
data['p_change'] = data['p_change'].map(ct.FORMAT).astype(float)
return data
raise IOError(ct.NETWORK_URL_ERROR_MSG)
def threeMACloseCal(sn, exchange_id, sec_id, K_MIN, oprset, slip, step,
oprresultpath):
print sn
symbol = '.'.join([exchange_id, sec_id])
initial_cash = 20000
margin_rate = 0.2
commission_ratio = 0.00012
#计算mamid，并计算ma和cross
mashort = oprset['MA_Short']
malong = oprset['MA_Long']
#mamid=int((mashort+malong)/2)
madelta = (malong - mashort) / 4.0
mamid = mashort + int(step * madelta)
if mamid == malong:
mamid -= 1
bardata = DC.getBarData(symbol, K_MIN, '2016-01-01 00:00:00',
'2018-01-01 00:00:00')
df_MA = MA.MA(bardata['close'], mashort, mamid)
df_MA.drop('close', axis=1, inplace=True)
df = pd.concat([bardata, df_MA], axis=1)
#读取opr
oprfilename = symbol + str(K_MIN) + ' ' + oprset['Setname'] + ' result.csv'
oprresult = pd.read_csv(oprresultpath + "\\" + oprfilename)
oprresult['new_ret'] = oprresult['ret']
oprresult['new_ret_r'] = oprresult['ret_r']
oprresult['new_closetime'] = oprresult['closetime']
oprresult['new_closeindex'] = oprresult['closeindex']
oprresult['new_closeutc'] = oprresult['closeutc']
oprresult['new_closeprice'] = oprresult['closeprice']
oprnum = oprresult.shape[0]
for i in range(oprnum):
#print i
opr = oprresult.iloc[i]
oprtype = opr['tradetype']
openutc = opr['openutc']
closeutc = opr['closeutc']
#判断是否有mamid的交叉导致新的平仓
crossdf = df.loc[(df['utc_time'] >= openutc)
& (df['utc_time'] <= closeutc)]
if oprtype == 1:
cross = crossdf.loc[crossdf['MA_Cross'] == -1]
else:
cross = crossdf.loc[crossdf['MA_Cross'] == 1]
if cross.shape[0] > 0:
c = cross.iloc[0]
openprice = opr['openprice']
newcloseprice = c['close']
newclosetime = c['strtime']
newcloseutc = c['utc_time']
newcloseindex = c['Unnamed: 0']
newret = ((newcloseprice - openprice) * oprtype) - slip
oprresult.ix[i, 'new_ret'] = newret
oprresult.ix[i, 'new_ret_r'] = newret / openprice
oprresult.ix[i, 'new_closetime'] = newclosetime
oprresult.ix[i, 'new_closeindex'] = newcloseindex
oprresult.ix[i, 'new_closeutc'] = newcloseutc
oprresult.ix[i, 'new_closeprice'] = newcloseprice
firsttradecash = initial_cash / margin_rate
# 2017-12-08:加入滑点
oprresult['new_commission_fee'] = firsttradecash * commission_ratio * 2
oprresult['new_per earn'] = 0 # 单笔盈亏
oprresult['new_own cash'] = 0 # 自有资金线
oprresult['new_trade money'] = 0 # 杠杆后的可交易资金线
oprresult['new_retrace rate'] = 0 # 回撤率
oprresult.ix[0,
'new_per earn'] = firsttradecash * oprresult.ix[0,
'new_ret_r']
# 加入maxcash用于计算最大回撤
maxcash = initial_cash + oprresult.ix[0, 'new_per earn'] - oprresult.ix[
0, 'new_commission_fee']
oprresult.ix[0, 'new_own cash'] = maxcash
oprresult.ix[
0, 'new_trade money'] = oprresult.ix[0, 'new_own cash'] / margin_rate
for i in range(1, oprnum):
commission = oprresult.ix[i - 1,
'new_trade money'] * commission_ratio * 2
perearn = oprresult.ix[
i - 1, 'new_trade money'] * oprresult.iloc[i]['new_ret_r']
owncash = oprresult.ix[i - 1, 'new_own cash'] + perearn - commission
maxcash = max(maxcash, owncash)
retrace_rate = (maxcash - owncash) / maxcash
oprresult.ix[i, 'new_own cash'] = owncash
oprresult.ix[i, 'new_commission_fee'] = commission
oprresult.ix[i, 'new_per earn'] = perearn
oprresult.ix[i, 'new_trade money'] = owncash / margin_rate
oprresult.ix[i, 'new_retrace rate'] = retrace_rate
endcash = oprresult.ix[oprnum - 1, 'own cash']
newendcash = oprresult.ix[oprnum - 1, 'new_own cash']
successrate = (
oprresult.loc[oprresult['new_ret'] > 0]).shape[0] / float(oprnum)
max_single_loss_rate = abs(oprresult['new_ret_r'].min())
max_retrace_rate = oprresult['new_retrace rate'].max()
oprresult.to_csv(oprresultpath + '\\ThreeMAClose' + str(step) + 'to4\\' +
symbol + str(K_MIN) + ' ' + oprset['Setname'] +
' 3MAresult' + str(step) + '.csv')
return [
oprset['Setname'], mamid, endcash, newendcash, successrate,
max_single_loss_rate, max_retrace_rate
]
