def run_strategy(cash):
instruments = ["000001"]
feeds = tools.build_feed(instruments, 2016, 2018, "histdata")
# 设置手续费
broker_commision = broker.backtesting.TradePercentage(0.0003)
brk = broker.backtesting.Broker(cash, feeds, broker_commision)
myStrategy = MyStrategy(feeds, instruments[0], brk)
retAnalyzer = returns.Returns()
myStrategy.attachAnalyzer(retAnalyzer)
sharpeAnalyzer = sharpe.SharpeRatio()
myStrategy.attachAnalyzer(sharpeAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
myStrategy.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
myStrategy.attachAnalyzer(tradesAnalyzer)
# 以沪深300为基准#
instruments300 = ["510300"]
feeds300 = tools.build_feed(instruments300, 2016, 2018, "histdata300")
# 设置手续费
broker_commision = broker.backtesting.TradePercentage(0.0003)
brk = broker.backtesting.Broker(cash, feeds300, broker_commision)
myStrategy300 = MyStrategy(feeds300, instruments300[0], brk)
retAnalyzer300 = returns.Returns()
myStrategy300.attachAnalyzer(retAnalyzer300)
sharpeAnalyzer300 = sharpe.SharpeRatio()
myStrategy300.attachAnalyzer(sharpeAnalyzer300)
drawDownAnalyzer300 = drawdown.DrawDown()
myStrategy300.attachAnalyzer(drawDownAnalyzer300)
tradesAnalyzer300 = trades.Trades()
myStrategy300.attachAnalyzer(tradesAnalyzer300)
plter = plotter.StrategyPlotter(myStrategy)
plter.getOrCreateSubplot("return").addDataSeries("retuens",
retAnalyzer.getReturns())
plter.getOrCreateSubplot("CumReturn").addDataSeries(
"CumReturn", retAnalyzer.getCumulativeReturns())
plter.getOrCreateSubplot("return").addDataSeries(
"retuens300", retAnalyzer300.getReturns())
plter.getOrCreateSubplot("CumReturn").addDataSeries(
"CumReturn300", retAnalyzer300.getCumulativeReturns())
myStrategy.run()
myStrategy300.run()
plter.savePlot("testdata.png")
# print("交易次数:%d" % (tradesAnalyzer.getCount()))
print("策略回测指标")
analyzer((retAnalyzer, sharpeAnalyzer, drawDownAnalyzer, tradesAnalyzer))
print("基准回测指标")
analyzer((retAnalyzer300, sharpeAnalyzer300, drawDownAnalyzer300,
tradesAnalyzer300))
# 计算阿尔法 β 信息比例等值
calculater(retAnalyzer, retAnalyzer300)
return (myStrategy, retAnalyzer, sharpeAnalyzer, drawDownAnalyzer,
tradesAnalyzer)
def run_strategy(cash):
# instruments = ["000001"]
# feeds = tools.build_feed(instruments, 2016, 2018, "histdata")
instruments = ["000989"]
feeds = buildFeed(instruments[0], downloadData(instruments[0]))
# 设置手续费, 万分之一
broker_commision = broker.backtesting.TradePercentage(0.0001)
brk = broker.backtesting.Broker(cash, feeds, broker_commision)
myStrategy = MyStrategy(feeds, instruments[0], brk)
retAnalyzer = returns.Returns()
myStrategy.attachAnalyzer(retAnalyzer)
sharpeAnalyzer = sharpe.SharpeRatio()
myStrategy.attachAnalyzer(sharpeAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
myStrategy.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
myStrategy.attachAnalyzer(tradesAnalyzer)
plter = plotter.StrategyPlotter(myStrategy)
plter.getOrCreateSubplot("return").addDataSeries("retuens",
retAnalyzer.getReturns())
plter.getOrCreateSubplot("CumReturn").addDataSeries(
"CumReturn", retAnalyzer.getCumulativeReturns())
myStrategy.run()
plter.savePlot("testdata.png")
print("交易次数:%d" % (tradesAnalyzer.getCount()))
return (myStrategy, retAnalyzer, sharpeAnalyzer, drawDownAnalyzer,
tradesAnalyzer)
def testDrawDownIGE_SPY_Broker(self):
# This testcase is based on an example from Ernie Chan's book:
# 'Quantitative Trading: How to Build Your Own Algorithmic Trading Business'
barFeed = yahoofeed.Feed()
barFeed.addBarsFromCSV("ige", common.get_data_file_path("sharpe-ratio-test-ige.csv"))
barFeed.addBarsFromCSV("spy", common.get_data_file_path("sharpe-ratio-test-spy.csv"))
strat = strategy_test.TestStrategy(barFeed, 1000)
strat.getBroker().setUseAdjustedValues(True)
strat.setBrokerOrdersGTC(True)
stratAnalyzer = drawdown.DrawDown()
strat.attachAnalyzer(stratAnalyzer)
# Manually place IGE order to get it filled on the first bar.
order = strat.getBroker().createMarketOrder(broker.Order.Action.BUY, "ige", 1, True) # Adj. Close: 42.09
order.setGoodTillCanceled(True)
strat.getBroker().placeOrder(order)
strat.addOrder(datetime.datetime(2007, 11, 13), strat.getBroker().createMarketOrder, broker.Order.Action.SELL, "ige", 1, True) # Adj. Close: 127.64
# Manually place SPY order to get it filled on the first bar.
order = strat.getBroker().createMarketOrder(broker.Order.Action.SELL_SHORT, "spy", 1, True) # Adj. Close: 105.52
order.setGoodTillCanceled(True)
strat.getBroker().placeOrder(order)
strat.addOrder(datetime.datetime(2007, 11, 13), strat.getBroker().createMarketOrder, broker.Order.Action.BUY_TO_COVER, "spy", 1, True) # Adj. Close: 147.67
strat.run()
self.assertTrue(round(strat.getBroker().getCash(), 2) == round(1000 + (127.64 - 42.09) + (105.52 - 147.67), 2))
self.assertTrue(strat.getOrderUpdatedEvents() == 4)
self.assertTrue(round(stratAnalyzer.getMaxDrawDown(), 5) == 0.09448)
self.assertTrue(stratAnalyzer.getMaxDrawDownDuration()== 229)
def __testIGE_BrokerImpl(self, quantity):
initialCash = 42.09 * quantity
# This testcase is based on an example from Ernie Chan's book:
# 'Quantitative Trading: How to Build Your Own Algorithmic Trading Business'
barFeed = yahoofeed.Feed()
barFeed.addBarsFromCSV(
"ige", common.get_data_file_path("sharpe-ratio-test-ige.csv"))
strat = strategy_test.TestStrategy(barFeed, initialCash)
strat.getBroker().setUseAdjustedValues(True)
strat.setBrokerOrdersGTC(True)
stratAnalyzer = drawdown.DrawDown()
strat.attachAnalyzer(stratAnalyzer)
# Manually place the order to get it filled on the first bar.
order = strat.getBroker().createMarketOrder(broker.Order.Action.BUY,
"ige", quantity,
True) # Adj. Close: 42.09
order.setGoodTillCanceled(True)
strat.getBroker().placeOrder(order)
strat.addOrder(strategy_test.datetime_from_date(2007, 11, 13),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL, "ige", quantity,
True) # Adj. Close: 127.64
strat.run()
self.assertTrue(
round(strat.getBroker().getCash(), 2) == initialCash +
(127.64 - 42.09) * quantity)
self.assertTrue(strat.getOrderUpdatedEvents() == 4)
self.assertTrue(round(stratAnalyzer.getMaxDrawDown(), 5) == 0.31178)
self.assertTrue(
stratAnalyzer.getLongestDrawDownDuration() == datetime.timedelta(
days=623))
def __init__(self, feed, brk, instrument):
super(LiveStrategy, self).__init__(feed, brk)
brk.addBitmexFeed(feed)
feed.getNewValuesEvent().subscribe(self.__onBarsImpl)
self.initial_capital = self.getResult()
brk.setStrategy(self)
self.positions = {}
for symbol in instrument:
self.positions[symbol] = brk.get_synced_position(self, symbol)
retAnalyzer = returns.Returns()
self.attachAnalyzerEx(retAnalyzer, 'retAnalyzer')
sharpeRatioAnalyzer = sharpe.SharpeRatio()
self.attachAnalyzerEx(sharpeRatioAnalyzer, 'sharpeRatioAnalyzer')
drawDownAnalyzer = drawdown.DrawDown()
self.attachAnalyzerEx(drawDownAnalyzer, 'drawDownAnalyzer')
tradesAnalyzer = trades.Trades()
self.attachAnalyzerEx(tradesAnalyzer, 'tradesAnalyzer')
self.plt = plotter.StrategyPlotter(self)
self.plt.getOrCreateSubplot("returns").addDataSeries(
"Net return", retAnalyzer.getReturns())
self.plt.getOrCreateSubplot("returns").addDataSeries(
"Cum. return", retAnalyzer.getCumulativeReturns())
self.strategy_id = brk.getStrategyId()
if not os.path.exists(self.strategy_id + '.csv'):
with open(self.strategy_id + '.csv', 'w') as f:
f.write('Date,Type,Signal,Symbol,Price,Shares,PnL,Cash\n')
if not os.path.exists(self.strategy_id + '_orders.csv'):
with open(self.strategy_id + '_orders.csv', 'w') as f:
f.write(
'Date,OrderDate,OrderId,Type,Signal,Symbol,Price,Size,Filled,Timedelta,StopHit\n'
)
def __init__(self,
instrument,
startYear,
endYear,
strategy,
base="510300",
cash=1000000,
feeRate=0.0003):
self.__instrument = instrument
self.__startYear = startYear
self.__endYear = endYear
self.__strategy = strategy
self.__base = []
self.__base.append(base)
self.__cash = cash
self.__feeRate = feeRate
# 要创建的内部变量
self.__strategyTest = None
self.__feed = None
self.__strategyBase = None
self.__feedBase = None
self.__brk = None
self.__brkBase = None
self.__return = returns.Returns()
self.__returnBase = returns.Returns()
self.__sharpe = sharpe.SharpeRatio()
self.__drawdown = drawdown.DrawDown()
self.__trade = trades.Trades()
self.__result = pd.DataFrame()
self.__plter = None
# 使用pyalgotrade绘图要加上，不然报错
register_matplotlib_converters()
def __init__(self, feed, instrument):
super(SimpleBacktestStrategy, self).__init__(feed)
self.initial_capital = self.getResult()
self.positions = {}
for symbol in instrument:
self.positions[symbol] = {}
retAnalyzer = returns.Returns()
self.attachAnalyzerEx(retAnalyzer, 'retAnalyzer')
sharpeRatioAnalyzer = sharpe.SharpeRatio()
self.attachAnalyzerEx(sharpeRatioAnalyzer, 'sharpeRatioAnalyzer')
drawDownAnalyzer = drawdown.DrawDown()
self.attachAnalyzerEx(drawDownAnalyzer, 'drawDownAnalyzer')
tradesAnalyzer = trades.Trades()
self.attachAnalyzerEx(tradesAnalyzer, 'tradesAnalyzer')
self.plt = plotter.StrategyPlotter(self)
self.plt.getOrCreateSubplot("returns").addDataSeries(
"Net return", retAnalyzer.getReturns())
self.plt.getOrCreateSubplot("returns").addDataSeries(
"Cum. return", retAnalyzer.getCumulativeReturns())
self.strategy_id = 'backtest'
if not os.path.exists(self.strategy_id + '.csv'):
with open(self.strategy_id + '.csv', 'w') as f:
f.write('Date,Type,Signal,Symbol,Price,Shares,PnL,Cash\n')
def run_strategy(smaPeriod):
# Load the yahoo feed from the CSV file
feed = yahoofeed.Feed()
feed.addBarsFromCSV("zggf", "E:/PythonData/CSV/000938.csv")
# Evaluate the strategy with the feed.
myStrategy = MyStrategy(feed, "zggf", smaPeriod)
returnsAnalyzer=returns.Returns()
myStrategy.attachAnalyzer(returnsAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
myStrategy.attachAnalyzer(sharpeRatioAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
myStrategy.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
myStrategy.attachAnalyzer(tradesAnalyzer)
myStrategy.run()
print(myStrategy.getResult())
print("Final portfolio value: $%.2f" % myStrategy.getResult())
print("Cumulative returns: %.2f %%" % (returnsAnalyzer.getCumulativeReturns()[-1] * 100))
print(returnsAnalyzer.getCumulativeReturns())
print("Sharpe ratio: %.2f" % (sharpeRatioAnalyzer.getSharpeRatio(0.05)))
print("Max. drawdown: %.2f %%" % (drawDownAnalyzer.getMaxDrawDown() * 100))
print("Longest drawdown duration: %s" % (drawDownAnalyzer.getLongestDrawDownDuration()))
print()
print("Total trades: %d" % (tradesAnalyzer.getCount()))
def main():
instrument = "yhoo"
bBandsPeriod = 40
# Download the bars.
# feed = yahoofinance.build_feed([instrument], 2011, 2012, ".")
feed = yahoofeed.Feed()
feed.addBarsFromCSV(instrument, "dat\\yhoo-201x.csv")
strat = BBands(feed, instrument, bBandsPeriod)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
strat.attachAnalyzer(sharpeRatioAnalyzer)
retAnalyzer = returns.Returns()
strat.attachAnalyzer(retAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
strat.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
strat.attachAnalyzer(tradesAnalyzer)
# ------
mpl.style.use('seaborn-whitegrid');
plt = plotter.StrategyPlotter(strat, True, True, True)
plt.getInstrumentSubplot(instrument).addDataSeries("upper", strat.getBollingerBands().getUpperBand())
plt.getInstrumentSubplot(instrument).addDataSeries("middle", strat.getBollingerBands().getMiddleBand())
plt.getInstrumentSubplot(instrument).addDataSeries("lower", strat.getBollingerBands().getLowerBand())
strat.run()
plt.plot()
# ==============================
print("最终资产价值 Final portfolio value: $%.2f" % strat.getResult())
print("累计回报率 Cumulative returns: %.2f %%" % (retAnalyzer.getCumulativeReturns()[-1] * 100))
print("夏普比率 Sharpe ratio: %.2f" % (sharpeRatioAnalyzer.getSharpeRatio(0.05)))
print("最大回撤率 Max. drawdown: %.2f %%" % (drawDownAnalyzer.getMaxDrawDown() * 100))
print("最长回撤时间 Longest drawdown duration: %s" % (drawDownAnalyzer.getLongestDrawDownDuration()))
def analyze_and_draw(feed, instrument, period, cash=10000):
my_strategy = MyStrategy(feed, instrument, period, cash)
# 在执行前添加不同的分析器
ret_analyzer = returns.Returns()
my_strategy.attachAnalyzer(ret_analyzer)
sharpe_ratio_analyzer = sharpe.SharpeRatio()
my_strategy.attachAnalyzer(sharpe_ratio_analyzer)
draw_down_analyzer = drawdown.DrawDown()
my_strategy.attachAnalyzer(draw_down_analyzer)
trades_analyzer = trades.Trades()
my_strategy.attachAnalyzer(trades_analyzer)
# 设置中文等线字体以显示中文
plts.rcParams['font.sans-serif'] = ['DengXian']
plt = plotter.StrategyPlotter(my_strategy, True, False, True)
plt.getInstrumentSubplot(instrument).addDataSeries("SMA",
my_strategy.getSMA())
# 开始执行策略
my_strategy.run()
plt.plot()
# 现金+有价证券
print("最终资产价值 Final portfolio value: ￥%.2f" %
my_strategy.getBroker().getEquity())
print("最终资产价值 Final portfolio value: ￥%.2f" % my_strategy.getResult())
print("累计回报率 Cumulative returns: %.2f %%" %
(ret_analyzer.getCumulativeReturns()[-1] * 100))
print("夏普比率 Sharpe ratio: %.2f" %
(sharpe_ratio_analyzer.getSharpeRatio(0.05)))
print("最大回撤率 Max. drawdown: %.2f %%" %
(draw_down_analyzer.getMaxDrawDown() * 100))
print("最长回撤时间 Longest drawdown duration: %s" %
(draw_down_analyzer.getLongestDrawDownDuration()))
def __init__(self, strategy, index_code=None):
"""
:param strategy: 策略
:param index_code: index基准利率代码应该同tushare保持一致
sh 上证指数 sz 深圳成指 hs300 沪深300指数 sz50 上证50指数 zxb 中小板指数 cyb 创业板指数
:return:
"""
self.__baseRet_code = index_code
self.__baseRet_data = None
self.__currBaseRet = []
self.__last_baseRet = 0.0
self.__baseRet = dataseries.SequenceDataSeries()
self.__betaRet = dataseries.SequenceDataSeries()
self.__alphaRet = dataseries.SequenceDataSeries()
self.__sharpeRet = dataseries.SequenceDataSeries()
self.__LongestDrawDown = dataseries.SequenceDataSeries()
self.__MaxDrawDown = dataseries.SequenceDataSeries()
self.__ret_analyzer = returns.Returns()
self.__sharpe_ratio = sharpe.SharpeRatio(False)
self.__draw_down = drawdown.DrawDown()
self.__beta = Beta()
strategy.attachAnalyzer(self.__ret_analyzer)
strategy.attachAnalyzer(self.__sharpe_ratio)
strategy.attachAnalyzer(self.__draw_down)
strategy.attachAnalyzer(self.__beta)
strategy.attachAnalyzer(self)
def main(start_date, end_date, maxLen=MAX_BAR_NUM, peried='D'):
all_df = get_stock_pool(start_date, end_date)
codes = list(set(all_df.code.tolist()))
#每只股票可投资的金额
cash = 100000
stockNum = 10
totalRisk = 0.01
duaration = 10 #调仓周期
feed = get_feed(all_df, codes, start_date, end_date, peried, duaration)
if feed is None: return False
macdStrategy = MACDStrategy(totalRisk, codes, feed, cash, SHORT, LONG, MID,
maxLen, stockNum, duaration)
# Attach a drawdown analyzer to the strategy
drawdownAnalyzer = drawdown.DrawDown()
macdStrategy.attachAnalyzer(drawdownAnalyzer)
# Attach a sharpe ratio analyzers to the strategy
sharpeRatioAnalyzer = sharpe.SharpeRatio()
macdStrategy.attachAnalyzer(sharpeRatioAnalyzer)
# Attach the plotter to the strategy
plt = plotter.StrategyPlotter(macdStrategy, False, True, True)
plt.getOrCreateSubplot("sharpRatio").addDataSeries(
"sharpRatio", sharpeRatioAnalyzer.getReturns())
# Run Strategy
macdStrategy.run()
macdStrategy.info("Get Max Downdown: %.2f" %
drawdownAnalyzer.getMaxDrawDown())
macdStrategy.info("Final portfolio value: %.2f" % macdStrategy.getResult())
plt.plot()
def RSIBacktest(nper):
# Create Instruments object with stock tickers
instruments = ["BANKNIFTY"]
# create feed object, add bars to the data feed
feed = csvfeed.GenericBarFeed(bar.Frequency.DAY)
feed.addBarsFromCSV(instruments[0], "Data//bnf.csv")
# create object to run strategy
rsi_strat = RSIStrategy(feed, instruments[0], nper)
# Attach Strategy Plotter
plt = plotter.StrategyPlotter(rsi_strat,
plotAllInstruments=True,
plotBuySell=True,
plotPortfolio=False)
plt.getOrCreateSubplot("RSI").addDataSeries("RSI", rsi_strat.getRSI())
plt.getOrCreateSubplot("RSI").addLine("Upper Threshold", 70)
plt.getOrCreateSubplot("RSI").addLine("Lower Threshold", 40)
# plt.getOrCreateSubplot("RSI").addLine("Center Line", 40)
retAnalyzer = ret.Returns()
rsi_strat.attachAnalyzer(retAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
rsi_strat.attachAnalyzer(sharpeRatioAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
rsi_strat.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
rsi_strat.attachAnalyzer(tradesAnalyzer)
# Run Strategy
rsi_strat.run()
# Print Strategy Trading Statistics
print
print "------------------------------"
print "1. Portfolio statistics"
print
print "Portfolio initial equity: $100000.00"
print "Portfolio final equity: $%.2f" % rsi_strat.getBroker().getEquity()
print "Portfolio net trading p&l: $%.2f" % tradesAnalyzer.getAll().sum()
print "Portfolio maximum drawdown: %.2f %%" % (
drawDownAnalyzer.getMaxDrawDown() * 100)
print "Portfolio annualized return: %.2f %%" % (
retAnalyzer.getCumulativeReturns()[-1] * 100)
print "Portfolio annualized Sharpe ratio (Rf = 0%%): %.2f" % (
sharpeRatioAnalyzer.getSharpeRatio(0.0))
print "------------------------------"
print "2. Total trades statistics"
print "Total trades: %d" % (tradesAnalyzer.getCount())
if tradesAnalyzer.getCount() > 0:
tradesProfits = tradesAnalyzer.getAll()
print "Total trades average p&l: $%2.f" % (tradesProfits.mean())
print "Largest Winning Trade: $%2.f" % (tradesProfits.max())
print "Largest Losing Trade: $%2.f" % (tradesProfits.min())
tradesReturns = tradesAnalyzer.getAllReturns()
print "Average return: %2.f %%" % (tradesReturns.mean() * 100)
print "Largest Winning Trade Return: %2.f %%" % (tradesReturns.max() *
100)
print "Largest Losing Trade Return: %2.f %%" % (tradesReturns.min() *
100)
print "------------------------------"
# Plot Strategy
plt.plot()
def main(plot):
instrument = ["price_diff", 'SHFE_AU', 'COMEX_AU']
bBandsPeriod = 20
# Download the bars.
feed = GenericBarFeed(Frequency.DAY, None, None)
feed.addBarsFromCSV('price_diff', 'price_oneyear_diff.csv')
feed.addBarsFromCSV('SHFE_AU', 'AU_oneyear_samedate.csv')
feed.addBarsFromCSV('COMEX_AU', 'GC_oneyear_samedate.csv')
# 3. broker setting
broker_commission = broker.backtesting.FixedPerTrade(390) # 2230
fill_stra = broker.fillstrategy.DefaultStrategy(volumeLimit=1)
sli_stra = broker.slippage.VolumeShareSlippage(priceImpact=0.2)
fill_stra.setSlippageModel(sli_stra)
brk = broker.backtesting.Broker(10000000, feed, broker_commission)
brk.setFillStrategy(fill_stra)
strat = BBands(feed, instrument[0], instrument[1], instrument[2],
bBandsPeriod, brk)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
strat.attachAnalyzer(sharpeRatioAnalyzer)
trade_situation = trades.Trades()
strat.attachAnalyzer(trade_situation)
draw_down = drawdown.DrawDown()
strat.attachAnalyzer(draw_down)
returning = returns.Returns()
strat.attachAnalyzer(returning)
if plot:
plt = plotter.StrategyPlotter(strat, True, True, True)
plt.getInstrumentSubplot(instrument[0]).addDataSeries(
"upper",
strat.getBollingerBands().getUpperBand())
plt.getInstrumentSubplot(instrument[0]).addDataSeries(
"middle",
strat.getBollingerBands().getMiddleBand())
plt.getInstrumentSubplot(instrument[0]).addDataSeries(
"lower",
strat.getBollingerBands().getLowerBand())
strat.run()
strat.info('最终资产值: ¥ %.2f' % strat.getResult()) #info表示记录每一次的交易
print '夏普率: ', sharpeRatioAnalyzer.getSharpeRatio(0.05,
False) #print表示只打印一次
print '累计收益率：', (returning.getCumulativeReturns()[-1])
print '最大回撤：', draw_down.getMaxDrawDown()
print '总交易次数：', trade_situation.getCount()
print '每次交易的手续费：', trade_situation.getCommissionsForAllTrades()
print '赚钱的交易次数：', trade_situation.getProfitableCount()
print '亏损的交易次数：', trade_situation.getUnprofitableCount()
print '不赚不亏的交易次数：', trade_situation.getEvenCount()
print '每次交易的盈亏：', trade_situation.getAll()
if plot:
plt.plot()
def testStrategy():
from pyalgotrade import bar
from pyalgotrade import plotter
strat = thrSMA
instrument = '600519'
market = 'SH'
fromDate = '20101001'
toDate = '20150601'
frequency = bar.Frequency.DAY
paras = [5, 17, 40, 10]
plot = True
import os
filepath = os.path.join(r'E:\xsj\day', instrument + market + ".csv")
#############################################don't change ############################33
from pyalgotrade.cn.csvfeed import Feed
barfeed = Feed(frequency)
barfeed.setDateTimeFormat('%Y-%m-%d')
barfeed.loadBars(instrument, market, fromDate, toDate, filepath)
pyalgotrade_id = instrument + '.' + market
strat = strat(barfeed, pyalgotrade_id, *paras)
from pyalgotrade.stratanalyzer import returns
from pyalgotrade.stratanalyzer import sharpe
from pyalgotrade.stratanalyzer import drawdown
from pyalgotrade.stratanalyzer import trades
retAnalyzer = returns.Returns()
strat.attachAnalyzer(retAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
strat.attachAnalyzer(sharpeRatioAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
strat.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
strat.attachAnalyzer(tradesAnalyzer)
if plot:
plt = plotter.StrategyPlotter(strat, True, True, True)
strat.run()
if plot:
plt.plot()
#夏普率
sharp = sharpeRatioAnalyzer.getSharpeRatio(0.05)
#最大回撤
maxdd = drawDownAnalyzer.getMaxDrawDown()
#收益率
return_ = retAnalyzer.getCumulativeReturns()[-1]
#收益曲线
return_list = []
for item in retAnalyzer.getCumulativeReturns():
return_list.append(item)
def turtle_test(code,start=None,plot=True,dl=60):
feed = ptc.get_tdx_barfeed(code,start,dl=dl)
#myStrategy = pyalg_test.SMACrossOver(feed, "orcl", 20)
pars=[2, 20, 60, 10]
# myStrategy = thrSMA_dayinfo(feed, "orcl",*pars)
myStrategy = BBands(feed, code,20,dl)
# Attach a returns analyzers to the strategy.
# returnsAnalyzer = returns.Returns()
# myStrategy.attachAnalyzer(returnsAnalyzer)
# if dataString =='pyalg_util':
# ds = pyalg_utils.dataSet(myStrategy) #抽取交易数据集语句，若使用系统自带画图功能则不需要该项
from pyalgotrade.stratanalyzer import returns
from pyalgotrade.stratanalyzer import sharpe
from pyalgotrade.stratanalyzer import drawdown
from pyalgotrade.stratanalyzer import trades
retAnalyzer = returns.Returns()
myStrategy.attachAnalyzer(retAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
myStrategy.attachAnalyzer(sharpeRatioAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
myStrategy.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
myStrategy.attachAnalyzer(tradesAnalyzer)
# Attach the plotter to the strategy.
# plt = plotter.StrategyPlotter(myStrategy)
# Plot the simple returns on each bar.
if plot:
plt = plotter.StrategyPlotter(myStrategy, True, True, True)
plt.getOrCreateSubplot("returns").addDataSeries("Simple returns", retAnalyzer.getReturns())
myStrategy.run()
myStrategy.info("Final portfolio value: $%.2f" % myStrategy.getResult())
# if dataString =='pyalg_util':
# rs = ds.getDefault() #获取默认的交易信息，dic格式
# plot(rs["cumulativeReturns"][:,0],rs["cumulativeReturns"][:,1]) #简单作图示例
#夏普率
sharp = sharpeRatioAnalyzer.getSharpeRatio(0.05)
#最大回撤
maxdd = drawDownAnalyzer.getMaxDrawDown()
#收益率
return_ = retAnalyzer.getCumulativeReturns()[-1]
#收益曲线
return_list = []
for item in retAnalyzer.getCumulativeReturns():
return_list.append(item)
print "Sharpe ratio: %.2f maxdown:%.2f%% return:%.2f%%" %(sharp,maxdd*100,return_*100)
myStrategy.get_max_min()
plt.plot()
def main(mode = ct.PAPER_TRADING, start_date = '20170815', end_date = '20171113'):
if mode == ct.PAPER_TRADING:
cash = 100000
beta = 9.49
mean = -0.282
std = 34.73
feed = dataFramefeed.Feed()
instruments = ['300296', '300613']
fpath = '/Users/hellobiek/Documents/workspace/python/quant/smart_deal_tool/configure/tushare.json'
ts_client = get_tushare_client(fpath)
for code in instruments:
df = ts.pro_bar(pro_api = ts_client, ts_code = add_suffix(code), adj = 'qfq', start_date = start_date, end_date = end_date)
df = df.rename(columns = {"ts_code": "code", "trade_date": "date", "vol": "volume", "pct_change": "pchange"})
df['date'] = df.date.apply(lambda x: time.strftime('%Y-%m-%d', time.strptime(x, "%Y%m%d")))
df = df.set_index("date")
feed.addBarsFromDataFrame(code, df)
# broker setting
# broker commission类设置
broker_commission = broker.backtesting.TradePercentage(0.002)
# fill strategy设置
fill_stra = broker.fillstrategy.DefaultStrategy(volumeLimit = 1.0)
sli_stra = broker.slippage.NoSlippage()
fill_stra.setSlippageModel(sli_stra)
# 完善broker类
brk = broker.backtesting.Broker(cash, feed, broker_commission)
brk.setFillStrategy(fill_stra)
pStrategy = PairTradingStrategy(feed, instruments, brk, beta, mean, std, cash)
returnsAnalyzer = sreturn.Returns()
pStrategy.attachAnalyzer(returnsAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
pStrategy.attachAnalyzer(sharpeRatioAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
pStrategy.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
pStrategy.attachAnalyzer(tradesAnalyzer)
plt = plotter.StrategyPlotter(pStrategy)
# Plot the simple returns on each bar.
plt.getOrCreateSubplot("returns").addDataSeries("Simple returns", returnsAnalyzer.getReturns())
pStrategy.run()
plt.plot()
print("Final portfolio value: $%.2f" % pStrategy.getResult())
print("Cumulative returns: %.2f %%" % (returnsAnalyzer.getCumulativeReturns()[-1] * 100))
print("Sharpe ratio: %.2f" % (sharpeRatioAnalyzer.getSharpeRatio(0.05)))
print("Max. drawdown: %.2f %%" % (drawDownAnalyzer.getMaxDrawDown() * 100))
print("Longest drawdown duration: %s" % (drawDownAnalyzer.getLongestDrawDownDuration()))
def initAnalyzer(self):
from pyalgotrade.stratanalyzer import sharpe
from pyalgotrade.stratanalyzer import returns
from pyalgotrade.stratanalyzer import drawdown
from pyalgotrade.stratanalyzer import trades
self.returnsAnalyzer = returns.Returns()
self.sharpeRatioAnalyzer = sharpe.SharpeRatio()
self.drawdownAnalyzer = drawdown.DrawDown()
self.tradesAnalyzer = trades.Trades()
def __init__(self, myStrategy):
self.__myStrategy = myStrategy
self.returnsAnalyzer = returns.Returns()
self.sharpeRatioAnalyzer = sharpe.SharpeRatio()
self.drawdownAnalyzer = drawdown.DrawDown()
self.tradeAyalyzer = trades.Trades()
myStrategy.attachAnalyzer(self.returnsAnalyzer)
myStrategy.attachAnalyzer(self.sharpeRatioAnalyzer)
myStrategy.attachAnalyzer(self.drawdownAnalyzer)
myStrategy.attachAnalyzer(self.tradeAyalyzer)
def testStrategy():
from pyalgotrade import bar
from pyalgotrade import plotter
strat = DoubleMA
frequency = bar.Frequency.MINUTE
paras = [5, 20]
plot = True
#############################################path set ############################33
feed = Feed(frequency)
feed.loadBars('bitmex_BCHZ18', test_back=True)
strat = strat(feed, "bitmex_BCHZ18", *paras)
from pyalgotrade.stratanalyzer import returns
from pyalgotrade.stratanalyzer import sharpe
from pyalgotrade.stratanalyzer import drawdown
from pyalgotrade.stratanalyzer import trades
retAnalyzer = returns.Returns()
strat.attachAnalyzer(retAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
strat.attachAnalyzer(sharpeRatioAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
strat.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
strat.attachAnalyzer(tradesAnalyzer)
if plot:
plt = plotter.StrategyPlotter(strat, True, True, True)
strat.run()
if plot:
plt.plot()
# 夏普率
sharp = sharpeRatioAnalyzer.getSharpeRatio(0.02)
print(sharp)
# 最大回撤
maxdd = drawDownAnalyzer.getMaxDrawDown()
print(maxdd)
# 收益率
return_ = retAnalyzer.getCumulativeReturns()[-1]
print(return_)
# 收益曲线
return_list = []
for item in retAnalyzer.getCumulativeReturns():
return_list.append(item)
print(return_list)
def test_strat(plot):
# instrument = '600288SH'
instrument = 'FG0'
# plot = True
# instrument = "600281SH"
# short_ma_Period = 10
# medium_ma_period = 20
# long_ma_period = 99
# Download the bars.
# feed = yahoofinance.build_feed([instrument], 2011, 2012, ".")
# csv_path = os.path.abspath('../histdata/day') + '/' + instrument + '.csv'
csv_path = os.path.abspath(
'../histdata/commodity') + '/' + instrument + '.csv'
# feed = sf.Feed(frequency=bar.Frequency.MINUTE)
feed = sf.Feed()
feed.addBarsFromCSV(instrument, csv_path)
# feed = csvfeed.Feed('Date', )
strat = ArimaGarch(feed,
instrument,
window=500,
arima_order=(5, 0, 5),
garch_order=(1, 1))
sharpeRatioAnalyzer = sharpe.SharpeRatio()
strat.attachAnalyzer(sharpeRatioAnalyzer)
returnsAnalyzer = returns.Returns()
strat.attachAnalyzer(returnsAnalyzer)
ddAnalyzer = drawdown.DrawDown()
strat.attachAnalyzer(ddAnalyzer)
if plot:
plt = plotter.StrategyPlotter(strat, True, True, True)
# plt.getInstrumentSubplot("FG0").addDataSeries("close")
plt.getOrCreateSubplot("returns").addDataSeries(
"Simple returns", returnsAnalyzer.getReturns())
# plt.getInstrumentSubplot(instrument).addDataSeries("short sma", strat.getShortSMA())
# plt.getInstrumentSubplot(instrument).addDataSeries("medium sma", strat.getMediumSMA())
# plt.getInstrumentSubplot(instrument).addDataSeries("long sma", strat.getLongSMA())
# plt.getInstrumentSubplot(instrument).addDataSeries("middle", strat.getBollingerBands().getMiddleBand())
# plt.getInstrumentSubplot(instrument).addDataSeries("lower", strat.getBollingerBands().getLowerBand())
strat.run()
print("Sharpe ratio: %.2f" % sharpeRatioAnalyzer.getSharpeRatio(0.05))
print(
"max dd : %.2f, duration: %s" %
(ddAnalyzer.getMaxDrawDown(), ddAnalyzer.getLongestDrawDownDuration()))
if plot:
plt.plot()
pass
def algo_test(target_name,
target_csv,
model_name,
model_csv,
model_prediction_std=0.0):
# Load the bar feed from the CSV file
feed = csvfeed.GenericBarFeed(pyalgotrade.bar.Frequency.DAY)
feed.addBarsFromCSV(target_name, target_csv)
feed.addBarsFromCSV(model_name, model_csv)
# Evaluate the strategy with the feed's bars.
myStrategy = MyStrategy(feed, target_name, model_prediction_std)
# myStrategy = MyBasicStrategy(feed, target_name)
# Attach analyzers.
retAnalyzer = returns.Returns()
myStrategy.attachAnalyzer(retAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
myStrategy.attachAnalyzer(sharpeRatioAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
myStrategy.attachAnalyzer(drawDownAnalyzer)
sortinoRatioAnalyzer = sortino.SortinoRatio()
myStrategy.attachAnalyzer(sortinoRatioAnalyzer)
# Run the strategy
myStrategy.run()
# Print the results.
print("Final portfolio value: $%.2f" % myStrategy.getResult())
print("Total return: %.2f %%" %
(retAnalyzer.getCumulativeReturns()[-1] * 100))
print("Average daily return: %.2f %%" %
(stats.mean(retAnalyzer.getReturns()) * 100))
print("Std. dev. daily return: %.4f" %
(stats.stddev(retAnalyzer.getReturns())))
print("Sharpe ratio: %.2f" % (sharpeRatioAnalyzer.getSharpeRatio(0)))
print("Sortino ratio: %.2f" % (sortinoRatioAnalyzer.getSortinoRatio(0)))
returnsPerDay = stats.mean(retAnalyzer.getReturns())
# print("shares list : ")
# print(myStrategy.getShares())
output = {
'sharpe': sharpeRatioAnalyzer.getSharpeRatio(0),
'sortino': sortinoRatioAnalyzer.getSortinoRatio(0),
'returnAnalyzer': retAnalyzer,
'annualReturns': returnsPerDay * 252
}
return output
def testNoTrades(self):
barFeed = yahoofeed.Feed()
barFeed.addBarsFromCSV("ige", common.get_data_file_path("sharpe-ratio-test-ige.csv"))
barFeed.addBarsFromCSV("spy", common.get_data_file_path("sharpe-ratio-test-spy.csv"))
strat = strategy_test.TestStrategy(barFeed, 1000)
strat.setBrokerOrdersGTC(True)
strat.getBroker().setUseAdjustedValues(True)
stratAnalyzer = drawdown.DrawDown()
strat.attachAnalyzer(stratAnalyzer)
strat.run()
self.assertTrue(strat.getBroker().getCash() == 1000)
self.assertTrue(strat.getOrderUpdatedEvents() == 0)
self.assertTrue(stratAnalyzer.getMaxDrawDown() == 0)
self.assertTrue(stratAnalyzer.getMaxDrawDownDuration()== 0)
def __testManualImpl(self, closingPrices, cash):
barFeed = TestBarFeed(bar.Frequency.DAY)
bars = build_bars_from_closing_prices(closingPrices)
barFeed.addBarsFromSequence("orcl", bars)
strat = strategy_test.TestStrategy(barFeed, cash)
stratAnalyzer = drawdown.DrawDown()
strat.attachAnalyzer(stratAnalyzer)
# Manually place the order to get it filled on the first bar.
order = strat.getBroker().createMarketOrder(broker.Order.Action.BUY, "orcl", 1, True)
order.setGoodTillCanceled(True)
strat.getBroker().submitOrder(order)
strat.run()
return stratAnalyzer
def __run_backtesting(cls, strategy):
retAnalyzer = returns.Returns()
strategy.attachAnalyzer(retAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
strategy.attachAnalyzer(sharpeRatioAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
strategy.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
strategy.attachAnalyzer(tradesAnalyzer)
plt = plotter.StrategyPlotter(strategy, True, True, True)
#plt.getOrCreateSubplot('position').addDataSeries('position', strategy.get_position())
for k, v in strategy.get_sma().iteritems():
plt.getInstrumentSubplot('indicator').addDataSeries(k, v)
strategy.run()
print '[收益率: ', strategy.getBroker().getEquity(
) / CONFIG['START_CAPTIAL'], ']'
print '[STRATEGY FINISH]'
# 夏普率
sharp = sharpeRatioAnalyzer.getSharpeRatio(0.05)
print '[夏普率: ', sharp, ']'
# 最大回撤
maxdd = drawDownAnalyzer.getMaxDrawDown()
print '[最大回撤: ', maxdd, ']'
# 收益率
return_ = retAnalyzer.getCumulativeReturns()[-1]
print '[收益率: ', return_, ']'
# 收益曲线
return_list = []
for item in retAnalyzer.getCumulativeReturns():
return_list.append(item)
plt.plot()
def runStrategy(code, csv_file, stdout=False):
feed = yahoofeed.Feed()
# feed.addBarsFromCSV("000001", "download\\000001.csv")
feed.addBarsFromCSV(code, csv_file)
myStrategy = MyStrategy(feed, code)
# init analyzers
returnsAnalyzer = returns.Returns()
drawDownAnalyzer = drawdown.DrawDown()
tradesAnalyzer = trades.Trades()
# attach analyzers
myStrategy.attachAnalyzer(returnsAnalyzer)
myStrategy.attachAnalyzer(drawDownAnalyzer)
myStrategy.attachAnalyzer(tradesAnalyzer)
# add subplot to plot
plt = plotter.StrategyPlotter(myStrategy)
# add sma 10 dataseries to plot
plt.getInstrumentSubplot(code).addDataSeries("SMA10",
myStrategy.getSMA10())
# add sma 10 dataseries to plot
plt.getInstrumentSubplot(code).addDataSeries("SMA25",
myStrategy.getSMA25())
# create returns subplot
plt.getOrCreateSubplot("returns").addDataSeries(
"Simple returns", returnsAnalyzer.getReturns())
myStrategy.run()
result = myStrategy.getResult()
cumReturn = returnsAnalyzer.getCumulativeReturns()[-1] * 100
maxDrawdown = drawDownAnalyzer.getMaxDrawDown() * 100
tradeCount = tradesAnalyzer.getCount()
if stdout:
print("Total trades: %d" % tradeCount)
print("Final portfolio value: $%.2f" % result)
print("Cumulative returns: %.2f %%" % cumReturn)
print("Max. drawdown: %.2f %%" % maxDrawdown)
plt.plot()
return cumReturn, maxDrawdown, tradeCount
def initAnalyzer(self):
from pyalgotrade.stratanalyzer import sharpe
from pyalgotrade.stratanalyzer import returns
from pyalgotrade.stratanalyzer import drawdown
from pyalgotrade.stratanalyzer import trades
# 1.0) 策略结果
self.returnsAnalyzer = returns.Returns()
# 1.1) 夏普比率
self.sharpeRatioAnalyzer = sharpe.SharpeRatio()
# 1.2)
self.drawdownAnalyzer = drawdown.DrawDown()
# 1.3)
self.tradesAnalyzer = trades.Trades()
self.attachAnalyzer(self.sharpeRatioAnalyzer)
self.attachAnalyzer(self.returnsAnalyzer)
self.attachAnalyzer(self.tradesAnalyzer)
self.attachAnalyzer(self.drawdownAnalyzer)
def run_strategy(m):
feed = yahoofeed.Feed()
feed.addBarsFromCSV("test1", "../dataFile/orcl-2000.csv")
myStrategy = SMACrossOver(feed, "test1", m)
retAnalyzer = returns.Returns()
myStrategy.attachAnalyzer(retAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
myStrategy.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
myStrategy.attachAnalyzer(tradesAnalyzer)
myStrategy.run()
print "total trades: %d" % (tradesAnalyzer.getCount())
"""
def main(plot):
instrument = "TSLA"
vwapWindowSize = 60
threshold = 0.00000001
# Download the bars.
feed = quandl.build_feed("WIKI", [instrument], 2007, 2018, ".")
strat = VWAPMomentum(feed, instrument, vwapWindowSize, threshold)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
strat.attachAnalyzer(sharpeRatioAnalyzer)
retAnalyzer = returns.Returns()
strat.attachAnalyzer(retAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
strat.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
strat.attachAnalyzer(tradesAnalyzer)
returns3 = tradesAnalyzer.getAllReturns()
if plot:
plt = plotter.StrategyPlotter(strat, True, False, True)
plt.getInstrumentSubplot(instrument).addDataSeries(
"vwap", strat.getVWAP())
strat.run()
print("Final portfolio value: $%.2f" % strat.getResult())
print("Cumulative returns: %.2f %%" %
(retAnalyzer.getCumulativeReturns()[-1] * 100))
print("Sharpe ratio: %.2f" % (sharpeRatioAnalyzer.getSharpeRatio(0.05)))
print("Max. drawdown: %.2f %%" % (drawDownAnalyzer.getMaxDrawDown() * 100))
print("Longest drawdown duration: %s" %
(drawDownAnalyzer.getLongestDrawDownDuration()))
print(retAnalyzer.getReturns())
print("")
print("Total trades: %d" % (tradesAnalyzer.getCount()))
if tradesAnalyzer.getCount() > 0:
profits = tradesAnalyzer.getAll()
print("Avg. profit: $%2.f" % (profits.mean()))
print("Profits std. dev.: $%2.f" % (profits.std()))
print("Max. profit: $%2.f" % (profits.max()))
print("Min. profit: $%2.f" % (profits.min()))
print(stats.ttest_1samp(tradesAnalyzer.getAllReturns(), 0))
if plot:
plt.plot()
def run_strategy(paras):
feed = dataframefeed.Feed()
feed.addBarsFromDataFrame(instrument, dat)
strat = singleMA.SingleMA(feed, instrument, paras, initialCash)
# attach analyzersgc
returnsAnalyzer = returns.Returns()
strat.attachAnalyzer(returnsAnalyzer)
drawdownAnalyzer = drawdown.DrawDown()
strat.attachAnalyzer(drawdownAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
strat.attachAnalyzer(sharpeRatioAnalyzer)
tradeAnalyzer = trades.Trades()
strat.attachAnalyzer(tradeAnalyzer)
strat.run()
print "Final portfolio value: $%.2f with paras %d" % (
strat.getBroker().getEquity(), paras)
return {
'returns':
returnsAnalyzer.getCumulativeReturns()[-1],
'drawdown':
drawdownAnalyzer.getMaxDrawDown(),
'longestDrawDownDuration':
drawdownAnalyzer.getLongestDrawDownDuration(),
'sr':
sharpeRatioAnalyzer.getSharpeRatio(0.03),
'total trades':
tradeAnalyzer.getCount(),
'win':
tradeAnalyzer.getProfitableCount(),
'lose':
tradeAnalyzer.getUnprofitableCount(),
'average win profit':
tradeAnalyzer.getPositiveReturns().mean(),
'average lose loss':
tradeAnalyzer.getNegativeReturns().mean(),
'wining ratio':
tradeAnalyzer.getProfitableCount() / tradeAnalyzer.getCount(),
'odds':
-tradeAnalyzer.getPositiveReturns().mean() /
tradeAnalyzer.getNegativeReturns().mean()
}
