def __getFeedFromGenericCsv(self,instrument):
'''mid
使用系统自定义的与数据提供者的数据格式相互独立的csv格式储存的文件
可以作为用户管理各种数据源的统一格式使用
'''
from pyalgotrade.barfeed.csvfeed import GenericBarFeed
from pyalgotrade import bar
frequency = bar.Frequency.DAY
barfeed = GenericBarFeed(frequency)
barfeed.setDateTimeFormat('%Y-%m-%d %H:%M:%S')
dataRoot = os.path.abspath(os.path.join(os.path.dirname(__file__),'data','generic','csv'))
filename = dataRoot+os.sep+'day'+os.sep+('%s.csv'%instrument)
barfeed.addBarsFromCSV(instrument, filename)
return barfeed
def main(plot):
instrument = "mro"
fastSMA = 5
slowSMA = 10
fastEMA = 12
slowEMA = 26
signalEMA = 9
frequency = bar.Frequency.MINUTE
if frequency == bar.Frequency.DAY:
path = MyFiles.dataPath+"mro-2013-yahoofinance.csv"
elif frequency == bar.Frequency.MINUTE:
path = MyFiles.dataIntradayPath+"MRO.csv"
filepath = path
#############################################don't change ############################33
from pyalgotrade.barfeed.csvfeed import GenericBarFeed
feed = GenericBarFeed(frequency)
feed.setDateTimeFormat('%Y/%m/%d %H:%M')
feed.addBarsFromCSV(instrument, filepath)
#feed = yahoofeed.Feed()
#feed.addBarsFromCSV(instrument,MyFiles.dataPath+"mro-2013-yahoofinance.csv")
#feed.addBarsFromCSV(instrument,MyFiles.dataIntradayPath+"MRO.csv")
strat = MyStrategy1(feed, instrument, fastSMA, slowSMA, fastEMA,slowEMA,signalEMA)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
strat.attachAnalyzer(sharpeRatioAnalyzer)
if plot:
plt = plotter.StrategyPlotter(strat, True, True, True)
plt.getOrCreateSubplot("macd").addDataSeries("MACD Value", strat.getMACD())
plt.getOrCreateSubplot("macd").addDataSeries("MACD SignalValue", strat.getSignal())
# plt.getOrCreateSubplot("macd").addDataSeries("MACD Histogram", strat.getHistogram())
plt.getInstrumentSubplot(instrument).addDataSeries("Fast SMA", strat.getSMAF())
plt.getInstrumentSubplot(instrument).addDataSeries("Slow SMA", strat.getSMAS())
#plt.getOrCreateSubplot("rsi").addLine("Overbought", overBoughtThreshold)
#plt.getOrCreateSubplot("rsi").addLine("Oversold", overSoldThreshold)
strat.run()
print "Sharpe ratio: %.2f" % sharpeRatioAnalyzer.getSharpeRatio(0.05)
if plot:
plt.plot()
def backtest(stockcode,date,preclose,prehigh,prelow,p1,p2,p3,p4):
stockcode=stockcode
#date=['2016-02-29','2016-03-02','2016-03-11']
path = "../histdata/tick/bak/"
strat =rbreaker
paras=[preclose,prehigh,prelow,p1,p2,p3,p4]
plot = True
# barfeed = tickcsvfeed.TickBarFeed(bar.Frequency.SECOND)
barfeed=GenericBarFeed(pyalgotrade.bar.Frequency.SECOND)
dstr=''
for d in date:
filepath = path +'stock_'+ stockcode + "_"+d+".csv"
barfeed.addBarsFromCSV(stockcode, filepath)
dstr=dstr+'_'+d
barfeed.setDateTimeFormat('%Y-%m-%d %H:%M:%S')
strat = strat(barfeed, stockcode, *paras)
strat.run()
cash=strat.getBroker()._Broker__cash
#tradeTimes=strat.getTradeTimes()
ticker=open(path +'stock_'+ stockcode+'_' + dstr+".csv", 'a')
ticker.write(str(p1))
ticker.write(',')
ticker.write(str(p2))
ticker.write(',')
ticker.write(str(p3))
ticker.write(',')
ticker.write(str(p4))
ticker.write(',')
ticker.write(str(cash))
ticker.write(',')
#ticker.write(str(tradeTimes))
ticker.write('\n')
ticker.close()
del strat
#return ( stockcode,date,p1,p2,p3,p4,cash,tradeTimes)
return ( stockcode,date,p1,p2,p3,p4,cash)
#############################################path set ############################33
if frequency == bar.Frequency.MINUTE:
path = "..\\histdata\\min\\"
elif frequency == bar.Frequency.DAY:
path = "..\\histdata\\day\\"
elif frequency == bar.Frequency.SECOND:
path = "..\\histdata\\tick\\"
filepath = path +'stock_'+ instrument + "_"+date+".csv"
#############################################don't change ############################33
from pyalgotrade.barfeed.csvfeed import GenericBarFeed
barfeed = GenericBarFeed(frequency)
barfeed.setDateTimeFormat('%Y-%m-%d %H:%M:%S')
barfeed.addBarsFromCSV(instrument, filepath)
strat = strat(barfeed, instrument, *paras)
if plot:
plt = plotter.StrategyPlotter(strat, True, True, True)
mall , mals , masl , mass = strat.getSMA()
# # print type(ma1)
plt.getInstrumentSubplot('indicator').addDataSeries("small", mall)
plt.getInstrumentSubplot('indicator').addDataSeries("smals", mals)
# plt.getInstrumentSubplot('indicator').addDataSeries("smasl", masl)
# plt.getInstrumentSubplot('indicator').addDataSeries("smass", mass)
position = strat.getTest()
plt.getOrCreateSubplot("position").addDataSeries("position", position)
instrument = "000001"
market = "SZ"
fromDate = "20140101"
toDate = "20160101"
frequency = bar.Frequency.DAY
paras = [2, 20, 60, 10]
plot = True
#############################################path set ############################33
if frequency == bar.Frequency.MINUTE:
path = "..\\histdata\\min\\"
elif frequency == bar.Frequency.DAY:
path = "..\\histdata\\day\\"
filepath = path + instrument + market + ".csv"
#############################################don't change ############################33
from pyalgotrade.barfeed.csvfeed import GenericBarFeed
barfeed = GenericBarFeed(frequency)
barfeed.setDateTimeFormat("%Y-%m-%d %H:%M:%S")
barfeed.addBarsFromCSV(instrument, filepath)
strat = strat(barfeed, instrument, *paras)
if plot:
plt = plotter.StrategyPlotter(strat, True, True, True)
strat.run()
if plot:
plt.plot()
instrument = '000001'
market = 'SZ'
fromDate = '20140101'
toDate = '20160101'
frequency = bar.Frequency.DAY
paras = [5, 20]
plot = True
#############################################path set ############################33
if frequency == bar.Frequency.MINUTE:
path = "..\\histdata\\min\\"
elif frequency == bar.Frequency.DAY:
path = "..\\histdata\\day\\"
filepath = path + instrument + market + ".csv"
#############################################don't change ############################33
from pyalgotrade.barfeed.csvfeed import GenericBarFeed
barfeed = GenericBarFeed(frequency)
barfeed.setDateTimeFormat('%Y-%m-%d %H:%M:%S')
barfeed.addBarsFromCSV(instrument, filepath)
strat = strat(barfeed, instrument, *paras)
if plot:
plt = plotter.StrategyPlotter(strat, True, True, True)
strat.run()
if plot:
plt.plot()
def main():
filedir = "testresults"
iteration = 0
resultsdict = {}
for instrument in instrumentListGetter():
if len(instrument.split()) > 1:
instrument, instrumentSource = instrument.split()
print "instrument: %s, source: %s" % (instrument, instrumentSource)
else:
instrumentSource = ""
#feed = yahoofeed.Feed()
#feed.addBarsFromCSV("hm", DATAPATH + "/hm_table.csv")
# Load the feed from the CSV files.
#for params in parameters_generator():
faileddataforinstrument = False
for params in teststrategy.parameters_generator():
# Do not move to outer loop or severe performance problems arise # take the data we have and use
yiter = 0
if "quandl" in instrumentSource: # https://www.quandl.com/data/
'''/home/carl/Projects/algotrader/algotrader/lib64/python2.7/site-packages/pyalgotrade/barfeed/csvfeed.py:171 needs try hack '''
try:
feed = GenericBarFeed(frequency=bar.Frequency.DAY)
feed.setDateTimeFormat("%Y-%m-%d")
feed.setColumnName("datetime", "Date")
feed.setColumnName("adj_close", "Adjusted Close")
#feed.addBarsFromCSV(instrument, DATAPATH)
feed.addBarsFromCSV(instrument,
DATAPATH + "/" + instrument + ".csv")
except:
print sys.exc_info()
faileddataforinstrument = True
else:
for year in range(YEARSOFDATA, 0, -1):
startyear = localtime().tm_year - (YEARSOFDATA - yiter)
try:
feed = build_feed([instrument],
startyear,
2016,
DATAPATH,
frequency=86400,
timezone=None,
skipErrors=False)
except:
print "\n\nFailed downloading %s for year %d yiter %d \n\n" % (
instrument, startyear, yiter)
yiter += 1
if year == (YEARSOFDATA - 1):
faileddataforinstrument = True
if faileddataforinstrument:
break
strat = teststrategy.TestStrat(feed, instrument, *params)
iteration += 1
paramnames = teststrategy.parameters_generator(paramnames=True)
paramsarray = zip(paramnames, [str(p) for p in params])
paramsstring = str([
":".join(t) for t in zip(paramnames, [str(p) for p in params])
])
shortlong = "Short positions:" if strat.TestShort else "Long positions:"
print "\n\nIteration %d / %d; Instrument %s ; %s Params %s" % (
iteration, iterations, instrument, shortlong, paramsstring)
#retAnalyzer = returns.Returns()
#strat.attachAnalyzer(retAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
strat.attachAnalyzer(sharpeRatioAnalyzer)
#drawDownAnalyzer = drawdown.DrawDown()
#strat.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
strat.attachAnalyzer(tradesAnalyzer)
# with instrument
#csvdict["Params"] = [":".join(t) for t in zip(("instrument", "entrySMA", "exitDays", "rsiPeriod", "overBoughtThreshold", "overSoldThreshold"), [str(p) for p in params] )]
# without instrument
print paramsstring
strat.run()
tradetotal = 0
tradetotal = sum(
[t * 100.00 for t in tradesAnalyzer.getAllReturns()])
nr_of_trades = tradesAnalyzer.getCount()
try:
profitable_tradeprcnt = "%.2f" % (
(float(tradesAnalyzer.getProfitableCount()) /
float(tradesAnalyzer.getCount())) * 100)
trade_avg_result_prcnt = "%.2f" % (
tradetotal / float(tradesAnalyzer.getCount()))
except ZeroDivisionError:
profitable_tradeprcnt = "0.0"
trade_avg_result_prcnt = "0.0"
sharpe_ratio = "%.2f" % (sharpeRatioAnalyzer.getSharpeRatio(0.05))
#print "Cumulative returns: %.2f %%" % (retAnalyzer.getCumulativeReturns()[-1] * 100)
print "Trade stats"
print "Nr of trades:\t\t\t%d" % (nr_of_trades)
print "Trade avg:\t\t\t%s%%" % (trade_avg_result_prcnt)
print "Profitable trades:\t\t%s%%" % (profitable_tradeprcnt)
print "Sharpe ratio:\t\t\t", sharpe_ratio
print
returns = tradesAnalyzer.getAllReturns()
if tradesAnalyzer.getProfitableCount() > 0:
trade_max = "%.2f" % (returns.max() * 100)
trade_min = "%.2f" % (returns.min() * 100)
trade_stddev = "%.2f" % (returns.std() * 100)
else:
trade_max = "%.2f" % 0
trade_min = "%.2f" % 0
trade_stddev = "%.2f" % 0
print "Returns std. dev.: %s %%\t\t\t" % trade_stddev
print "Max. return: %s %%\t\t\t" % trade_max
print "Min. return: %s %%\t\t\t" % trade_min
#print "Trade total: %.2f" % ( tradetotal )
#print "Max. drawdown: %.2f %%" % (drawDownAnalyzer.getMaxDrawDown() * 100)
#if tradesAnalyzer.getProfitableCount() > 0:
#profits = tradesAnalyzer.getProfits()
#losses = tradesAnalyzer.getLosses()
#print "Avg. profit: $%2.f" % (profits.mean())
#print "Avg. loss: $%2.f" % (losses.mean())
#returns = tradesAnalyzer.getPositiveReturns()
#returns = tradesAnalyzer.getAllReturns()
#print "Avg. return: %2.f %%" % (returns.mean() * 100) # too much rounding
#print "Returns std. dev.: %2.f %%" % (returns.std() * 100)
#print "Max. return: %2.f %%" % (returns.max() * 100)
#print "Min. return: %2.f %%" % (returns.min() * 100)
#print "Trades std. dev.: $%2.f" % (profits.std())
#print "Max. profit: $%2.f" % (profits.max())
#print "Min. profit: $%2.f" % (profits.min())
if nr_of_trades > 0:
if paramsstring in resultsdict.keys():
try:
resultsdict[paramsstring]['nr_of_trades'] = int(
resultsdict[paramsstring]['nr_of_trades']) + int(
nr_of_trades)
resultsdict[paramsstring][
'profitable_tradeprcnt'] = "%.2f" % (
(float(resultsdict[paramsstring]
['profitable_tradeprcnt']) +
float(profitable_tradeprcnt)) / 2.00)
resultsdict[paramsstring][
'trade_avg_result_prcnt'] = "%.2f" % (
(float(resultsdict[paramsstring]
['trade_avg_result_prcnt']) +
float(trade_avg_result_prcnt)) / 2.00)
resultsdict[paramsstring]['sharpe_ratio'] = "%.2f" % (
(float(resultsdict[paramsstring]['sharpe_ratio']) +
float(sharpe_ratio)) / 2.00)
resultsdict[paramsstring]['trade_max'] = "%.2f" % (
float(resultsdict[paramsstring]['trade_max']) +
float(trade_max) / 2.00)
resultsdict[paramsstring]['trade_min'] = "%.2f" % (
float(resultsdict[paramsstring]['trade_min']) +
float(trade_min) / 2.00)
resultsdict[paramsstring]['trade_stddev'] = "%.2f" % (
float(resultsdict[paramsstring]['trade_stddev']) +
float(trade_stddev) / 2.00)
except ZeroDivisionError:
print "\nError (ZeroDivisionError) trying averaging with: %s\n" % paramsstring
else: # First time with params
resultsdict[paramsstring] = dict(paramsarray)
resultsdict[paramsstring]['params'] = paramsstring
resultsdict[paramsstring]['nr_of_trades'] = nr_of_trades
resultsdict[paramsstring][
'profitable_tradeprcnt'] = profitable_tradeprcnt
resultsdict[paramsstring][
'trade_avg_result_prcnt'] = trade_avg_result_prcnt
resultsdict[paramsstring]['sharpe_ratio'] = sharpe_ratio
resultsdict[paramsstring]['trade_max'] = trade_max
resultsdict[paramsstring]['trade_min'] = trade_min
resultsdict[paramsstring]['trade_stddev'] = trade_stddev
feed.reset() # feed must be reset
del sharpeRatioAnalyzer
del tradesAnalyzer
with open(filedir + "/" + strat.STRATNAME + '.csv', 'wb') as csvfile:
fieldnames = ['params']
fieldnames.extend(paramnames)
fieldnames.extend(
('nr_of_trades', 'profitable_tradeprcnt', 'trade_avg_result_prcnt',
'sharpe_ratio', 'trade_max', 'trade_min', 'trade_stddev'))
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
#csvheader = {'params':'Params: ' + strat.STRATNAME, paramnames, 'nr_of_trades':'Nr of trades',\
# 'profitable_tradeprcnt':'Profitable trades%', 'trade_avg_result_prcnt':'Trade avg %', 'sharpe_ratio': 'Sharpe Ratio'}
csvheader = {'params': 'Params: ' + strat.STRATNAME}
for n in paramnames:
csvheader[n] = n
csvheader['nr_of_trades'] = 'Nr of trades'
csvheader['profitable_tradeprcnt'] = 'Profitable trades%'
csvheader['trade_avg_result_prcnt'] = 'Trade avg %'
csvheader['sharpe_ratio'] = 'Sharpe Ratio'
csvheader['trade_max'] = 'Trade Max'
csvheader['trade_min'] = 'Trade Min'
csvheader['trade_stddev'] = 'Trade Stddev'
writer.writerow(csvheader)
for result in resultsdict.keys():
writer.writerow(resultsdict[result])
print "Wrote: %s" % (filedir + "/" + strat.STRATNAME + '.csv')
