def run(capital, risk_level, quarter):
start = Zipliner.dates[quarter]
end = Zipliner.dates[quarter + 1]
df = None
if (risk_level == 2):
df = zipline.run_algorithm(start=start,
end=end,
initialize=low_risk.initialize,
capital_base=capital,
handle_data=low_risk.handle_data)
elif (risk_level == 1):
df = zipline.run_algorithm(start=start,
end=end,
initialize=mid_risk.initialize,
capital_base=capital,
handle_data=mid_risk.handle_data)
elif (risk_level == 0):
df = zipline.run_algorithm(
start=start,
end=end,
initialize=high_risk.initialize,
capital_base=capital,
handle_data=None,
before_trading_start=high_risk.before_trading_start)
return df
def train(self, sd, ed):
start = 0 if self.config.resume_from_checkpoint is None else self.config.resume_from_checkpoint
for self.epoch in tqdm(range(start, self.config.n_epochs)):
print("Epoch {}".format(self.epoch))
trading_days = date_range(sd, ed, freq=trading_day)
self.timestep_progress = tqdm(total=len(trading_days) / 21)
run_algorithm(initialize=self.initialize_training_algo,
capital_base=self.capital,
start=sd,
end=ed)
def quickstart_tutorial():
def initialize(context):
context.i = 0
context.asset = zipline.api.symbol("AAPL")
def handle_data(context, data):
# Skip first 300 days to get full windows.
context.i += 1
if context.i < 300:
return
# Compute averages.
# data.history() has to be called with the same params from above and returns a pandas dataframe.
short_mavg = data.history(context.asset,
"price",
bar_count=100,
frequency="1d").mean()
long_mavg = data.history(context.asset,
"price",
bar_count=300,
frequency="1d").mean()
# Trading logic.
if short_mavg > long_mavg:
# order_target orders as many shares as needed to achieve the desired number of shares.
zipline.api.order_target(context.asset, 100)
elif short_mavg < long_mavg:
zipline.api.order_target(context.asset, 0)
# Save values for later inspection.
zipline.api.record(AAPL=data.current(context.asset, "price"),
short_mavg=short_mavg,
long_mavg=long_mavg)
zipline.run_algorithm(
start=pd.Timestamp("2014-01-01", tz="utc"),
end=pd.Timestamp("2018-01-01", tz="utc"),
initialize=initialize,
capital_base=1e7,
handle_data=handle_data,
before_trading_start=None,
analyze=None,
data_frequency="daily",
bundle="quantopian-quandl", # zipline ingest -b quantopian-quandl
bundle_timestamp=None,
trading_calendar=None,
metrics_set="default",
benchmark_returns=None,
default_extension=True,
extensions=(),
strict_extensions=True,
environ=os.environ,
blotter="default")
def run_algorithm(self):
start_time = datetime(2018, 1, 2, 9, 31, 0, 0, pytz.utc)
end_time = datetime(2018, 2, 4, 16, 0, 0, 0, pytz.utc)
zipline.run_algorithm(start=start_time,
end=end_time,
initialize=self.initialize,
capital_base=100000,
handle_data=self.handle_data,
before_trading_start=self.before_trading_start,
data_frequency='minute',
data=self.prepare_data(),
trading_calendar=ChineseStockCalendar(),
analyze=self.analyze)
def run(name, algo, bundle_name, start, end, capital_base, analyze=True):
'''Helper to run algorithm
'''
return (name, run_algorithm(start=start, end=end,
initialize=algo.initialize, handle_data=algo.handle_data, analyze=algo.analyze if analyze else None,
capital_base=capital_base, environ=os.environ, bundle=bundle_name
))
def main(job_id, D):
parsed = {
'symbols': 'SPY',
'start': '2014-01-01',
'end': '2014-12-31',
'algofile': '/home/quant/pta/py/algos/BBANDS-zipday.py',
'capital_base': '100000',
'data_frequency': 'daily',
'conf_file': None,
'source': 'yahoo',
'output': None,
'risk': None,
'algo_params': D
}
# Below what we expect spearmint to pass us
# parsed['algo_params']=[47,88.7,7.7]
# D={}
# D['timeperiod']=10
# D['nbdevup']=1.00
# D['nbdevdn']=1.00
perf = run_algorithm(**parsed)
StartV = perf['portfolio_value'][0]
EndV = perf['portfolio_value'][-1]
# spearmint wants to minimize so return negative profit
BBANDS = (StartV - EndV)
return BBANDS
def apple_run(shares_per_day, capital_base, start_date, end_date, log_channel):
ws = create_connection("ws://alpharithmic.herokuapp.com/ws/logs/%s/" %
log_channel)
msg_placeholder = "{\"message\": \"%s\"}"
ws.send(msg_placeholder % "Link Start")
def init(context):
ws.send(msg_placeholder % "Simulation Start")
pass
def handle(context, data):
order(symbol('AAPL'), shares_per_day)
ws.send(msg_placeholder %
("Ordered %s shares of Apple" % str(shares_per_day)))
start = pd.to_datetime(start_date).tz_localize('US/Eastern')
end = pd.to_datetime(end_date).tz_localize('US/Eastern')
result = run_algorithm(start,
end,
capital_base=capital_base,
initialize=init,
handle_data=handle,
bundle="quandl")
ws.send(msg_placeholder % "Simulation End")
ws.send(msg_placeholder % "Fetching backtest results from Redis Queue...")
result.dropna(inplace=True)
ws.close()
return create_json_response(result)
def run_strategy(strategy_name):
"""
Run an example module from zipline.examples.
"""
mod = None
if strategy_name == "buy_and_hold":
mod = BuyAndHold()
elif strategy_name == "auto_correlation":
mod = AutoCorrelation()
register_calendar("YAHOO", get_calendar("NYSE"), force=True)
print('mod', type(mod), mod.__class__.__name__)
print('mod._test_args()', mod._test_args())
return run_algorithm(
initialize=getattr(mod, 'initialize', None),
handle_data=getattr(mod, 'handle_data', None),
before_trading_start=getattr(mod, 'before_trading_start', None),
analyze=getattr(mod, 'analyze', None),
bundle='quantopian-quandl', # change from quandl -> quantopian-quandl
environ=environ,
# Provide a default capital base, but allow the test to override.
**merge({'capital_base': 1e7}, mod._test_args()))
def run_algorithm(self):
from zipline.api import order, record, symbol, set_benchmark
import zipline
import matplotlib.pyplot as plt
from datetime import datetime
import pytz
from zipline.utils.calendars.exchange_calendar_shsz import SHSZExchangeCalendar
def initialize(context):
set_benchmark(symbol('SH00300'))
def handle_data(context, data):
order(symbol('SH00300'), 10)
record(SPY=data.current(symbol('SH00300'), 'price'))
self.perf = zipline.run_algorithm(
start=datetime(2017, 3, 6, 9, 31, 0, 0,
pytz.timezone("Asia/Shanghai")),
end=datetime(2017, 3, 9, 3, 30, 0, 0,
pytz.timezone("Asia/Shanghai")),
initialize=initialize,
trading_calendar=SHSZExchangeCalendar(),
capital_base=100000,
handle_data=handle_data,
data_frequency='minute',
data=self.panel)
self.perf.head()
def run_strategy(strategy_name):
mod = None
if strategy_name == "buy_and_hold":
mod = BuyAndHold()
elif strategy_name == "auto_correlation":
mod = AutoCorrelation()
elif strategy_name == "scalping":
mod = ScalpBollingerBand()
# register_calendar("YAHOO", get_calendar("NYSE"), force=True)
data_panel, start, end = prepareCSV('csv')
print(data_panel, type(start))
return run_algorithm(
data=data_panel,
trading_calendar=CryptoCalendar(),
initialize=getattr(mod, 'initialize', None),
handle_data=getattr(mod, 'handle_data', None),
before_trading_start=getattr(mod, 'before_trading_start', None),
analyze=getattr(mod, 'analyze', None),
# bundle='quandl',
environ=environ,
data_frequency='minute',
# Provide a default capital base, but allow the test to override.
**merge({
'capital_base': 5000,
'start': start,
'end': end
}, mod._test_args()))
def get_perf(dict_dt_sec_wgt, initial_amount, start, end):
stg_analyze = zl_backtest(dict_dt_sec_wgt)
res = run_algorithm(start=start,
end=end,
initialize=stg_analyze.initialize,
capital_base=initial_amount,
handle_data=stg_analyze.rebalance,
bundle='quantopian-quandl')
res.to_pickle('res3.pkl')
return res
def get_performance(self):
return zipline.run_algorithm(start=self.start_session,
end=self.end_session,
initialize=self.initialize,
trading_calendar=always_open.AlwaysOpenCalendar(),
capital_base=self.initial_portfolio_value,
handle_data=self.handle_data,
data_frequency="minute",
data=self.minute_data)
def analyze(context, perf):
fig, ax = plt.subplots(3, 1, sharex=True, figsize=[16, 9])
# portfolio value
perf.portfolio_value.plot(ax=ax[0])
ax[0].set_ylabel('portfolio value in $')
# asset
perf[['price', 'moving_average']].plot(ax=ax[1])
ax[1].set_ylabel('price in $')
# mark transactions
perf_trans = perf.loc[[t != [] for t in perf.transactions]]
buys = perf_trans.loc[[
t[0]['amount'] > 0 for t in perf_trans.transactions
]]
sells = perf_trans.loc[[
t[0]['amount'] < 0 for t in perf_trans.transactions
]]
ax[1].plot(buys.index,
perf.price.loc[buys.index],
'^',
markersize=10,
color='g',
label='buy')
ax[1].plot(sells.index,
perf.price.loc[sells.index],
'v',
markersize=10,
color='r',
label='sell')
ax[1].legend()
# daily returns
perf.returns.plot(ax=ax[2])
ax[2].set_ylabel('daily returns')
fig.suptitle('Simple Moving Average Strategy - Apple', fontsize=16)
plt.legend()
plt.show()
print('Final portfolio value (including cash): {}$'.format(
np.round(perf.portfolio_value[-1], 2)))
perf = zipline.run_algorithm(start=datetime(2000, 1, 5, 0, 0, 0, 0,
pytz.utc),
end=datetime(2018, 3, 1, 0, 0, 0, 0,
pytz.utc),
initialize=initialize,
capital_base=100,
handle_data=handle_data,
analyze=analyze,
data=panel)
result.append(perf.portfolio_value[-1])
def get_perf(dict_dt_sec_wgt, initial_amount, start, end):
stg_analyze = stg()
res = run_algorithm(start=start,
end=end,
initialize=stg_analyze.initial,
capital_base=initial_amount,
handle_data=stg_analyze.handle_data,
bundle='quantopian-quandl')
res.to_pickle('res_aapl.pkl')
return res
def validate_single_stock(ticker):
def init(context):
symbol(ticker)
def handle_data(context, data):
pass
start = pd.to_datetime("2017-01-09").tz_localize('US/Eastern')
end = pd.to_datetime("2017-01-11").tz_localize('US/Eastern')
try:
run_algorithm(start, end, capital_base=1000000,
initialize=init,
handle_data=handle_data,
bundle="quandl")
return True
except:
return False
def run_strategy(strategy_name):
mod = None
if strategy_name == "buy_and_hold":
mod = BuyAndHold()
register_calendar("YAHOO", get_calendar("NYSE"), force=True)
return run_algorithm(
initialize=getattr(mod, 'initialize', None),
handle_data=getattr(mod, 'handle_data', None),
before_trading_start=getattr(mod, 'before_trading_start', None),
analyze=getattr(mod, 'analyze', None),
bundle='quandl',
environ=environ,
# Definimos un capital inicial que puede ser sobreescrito por el test
**merge({'capital_base': 1e7}, mod._test_args()))
def run_example(example_name, environ):
"""
Run an example module from zipline.examples.
"""
mod = EXAMPLE_MODULES[example_name]
return run_algorithm(
initialize=getattr(mod, 'initialize', None),
handle_data=getattr(mod, 'handle_data', None),
before_trading_start=getattr(mod, 'before_trading_start', None),
analyze=getattr(mod, 'analyze', None),
bundle='test',
environ=environ,
# Provide a default capital base, but allow the test to override.
**merge({'capital_base': 1e7}, mod._test_args())
)
def run(self) -> pd.DataFrame:
"""Function to run the simulation; triggers zipline's `run_algorithm`,
with appropriate function overrides.
Returns:
pd.DataFrame -- Zipline simulation results.
"""
return run_algorithm(start=config.backtest_start,
end=config.backtest_end,
capital_base=config.capital_base,
initialize=self.zipline_initialize,
handle_data=self.zipline_handle_data,
data_frequency=config.backtest_frequency,
bundle='quandl')
def main():
#file_path = 'AAPL.csv'
print("Reading csv file...")
data = OrderedDict()
data['BITMAP'] = pd.read_csv(FILE_PATH,
index_col=0,
parse_dates=['timestamp'])
print(data['BITMAP'].head())
print(data['BITMAP'].keys())
# salvando em arquivo o Dataframe
# convertendo o pandas Dataframe em pandas Panel
panel = pd.Panel(data)
panel.minor_axis = [
'open', 'high', 'low', 'close', 'volume', 'volume_(currency)',
'weighted_price'
]
#panel.minor_axis = ['Open', 'High', 'Low', 'Close', 'Volume']
panel.major_axis = panel.major_axis.tz_localize(pytz.utc)
print(panel)
print("Starting zipline..")
#alg_obj = TradingAlgorithm(initialize=initialize, handle_data=handle_data)
capital_base = 50000
start = datetime(2016, 1, 1, 0, 0, 0, 0, pytz.utc)
end = datetime(2016, 2, 1, 0, 0, 0, 0, pytz.utc)
print("Running zipline..")
run_algorithm(start=start,
end=end,
initialize=initialize,
capital_base=capital_base,
handle_data=handle_data,
analyze=analyze,
data=panel,
data_frequency='minute')
#perf_manual = alg_obj.run(panel)
print("Finished")
def py_run(fly_initialize,
fly_handle_data,
start,
end,
capital_base,
before_trading_start,
analyze,
data_frequency,
data,
bundle,
bundle_timestamp,
trading_calendar,
metrics_set,
default_extension,
#extensions,
strict_extensions #,
#environ
):
def initialize(context):
fly_initialize(context)
return
def handle_data(context, data):
fly_handle_data(context, data)
return
performance = run_algorithm(
initialize = initialize,
handle_data = handle_data,
start = start,
end = end,
capital_base = capital_base,
before_trading_start = before_trading_start,
analyze = analyze,
data_frequency = data_frequency,
data = data,
bundle = bundle,
bundle_timestamp = bundle_timestamp,
trading_calendar = trading_calendar,
metrics_set = metrics_set,
default_extension = default_extension,
#extensions,
strict_extensions = strict_extensions,
environ = os.environ
)
return performance
def main(Ent, Ex):
global zEnter
global zExit
zEnter = Ent
zExit = Ex
eastern = pytz.timezone('US/Eastern')
start = datetime.datetime(2013, 1, 3, 0, 0, 0, 0, eastern)
end = datetime.datetime(2017, 8, 1, 0, 0, 0, 0, eastern)
results = run_algorithm(start=start,
end=end,
initialize=initialize,
capital_base=1000000,
bundle='quantopian-quandl')
return results.portfolio_value[-1]
def run_backtest(self, param_dict):
run = 0
start_date = param_dict["start"]
end_date = param_dict["end"]
while run < self.n_backtests:
start_year = np.random.randint(low=2002, high=2016)
start_month = np.random.randint(low=1, high=13)
start_date = str(start_year) + "-" + str(start_month) + "-1"
try:
backtest = run_algorithm(
start=pd.Timestamp(start_date, tz="US/Eastern"),
end=pd.Timestamp(end_date, tz="US/Eastern"),
initialize=self.initialize_algo,
capital_base=self.cash,
handle_data=self.handle_data,
before_trading_start=self._before_trading_start,
data_frequency="daily",
bundle="quantopian-quandl")
# save_q = "Do you want to save performance? (y/n)"
# if (raw_input(save_q) == 'y'):
# perf_name = "backtests/performance/" + name + \
# "_" + str(run+1) + ".csv"
# perf.to_csv(perf_name)
# log.info("Algorithm succeeded! \
# Saved performance results to: " + perf_name)
# print("Algorithm succeeded! Saved \
# performance results to: " + perf_name)
except OutOfMoney as e:
log.info("Algorithm failed. Ran out of money.")
print("Algorithm failed. Ran out of money")
for strategy in self.strategies:
strategy.__init__(self.param_dict, self.agent)
run += 1
if run % 5 == 0:
self.agent.save()
def run_strategy(strategy_name):
mod = None
if strategy_name == "buy_and_hold":
mod = BuyAndHold()
register_calendar("YAHOO", get_calendar("NYSE"), force=True)
return run_algorithm(
initialize=getattr(mod, 'initialize', None),
handle_data=getattr(mod, 'handle_data', None),
before_trading_start=getattr(mod, 'before_trading_start', None),
analyze=getattr(mod, 'analyze', None),
bundle='quandl',
environ=environ,
# Provide a default capital base, but allow the test to override.
**merge({'capital_base': 1e7}, mod._test_args()))
def test(self, sd, ed, live_start_date, benchmark='SPY'):
trading_days = date_range(sd, ed, freq=trading_day)
self.timestep_progress = tqdm(total=len(trading_days) / 21)
results = run_algorithm(initialize=self.initialize_testing_algo,
capital_base=self.capital,
start=sd,
end=ed)
returns, positions, transactions = pf.utils.extract_rets_pos_txn_from_zipline(
results)
benchmark_returns = get_benchmark_returns(benchmark, sd, ed)
benchmark_returns.ix[sd] = 0.0
pf.create_full_tear_sheet(returns,
positions=positions,
transactions=transactions,
benchmark_rets=benchmark_returns,
live_start_date=live_start_date,
round_trips=True)
def run_strategy(strategy_name):
"""
Run an example module from zipline.examples.
"""
mod = BaseStrategy
register_calendar("YAHOO", get_calendar("NYSE"), force=True)
return run_algorithm(
initialize=getattr(mod, 'initialize', None),
handle_data=getattr(mod, 'handle_data', None),
before_trading_start=getattr(mod, 'before_trading_start', None),
analyze=getattr(mod, 'analyze', None),
bundle='quandl',
environ=environ,
# Provide a default capital base, but allow the test to override.
**merge({'capital_base': 1e7}, mod._test_args()))
def run(self, portfolio, start, end, capital_base=100000):
MovingAverageStrategy._portfolio = portfolio
data, _ = AlphaVantageAPI.get_daily_data_for(portfolio.assets)
data['benchmark'] = data[portfolio.benchmark]
assets_panel = MovingAverageStrategy.to_panel(data)
nyse_calendar = trading_calendars.get_calendar('XNYS')
portfolio.performance = zipline.run_algorithm(
start=start,
end=end,
data_frequency='daily',
capital_base=capital_base,
before_trading_start=MovingAverageStrategy.before_trading_start(),
initialize=MovingAverageStrategy.initialize,
handle_data=MovingAverageStrategy.handle_data,
analyze=MovingAverageStrategy.analyze,
trading_calendar=nyse_calendar,
data=assets_panel)
def test_strategy(params_dict, file_name):
results = OrderedDict()
for key, value in params_dict.items():
global CORR_1, CORR_2, CAP_EXP, VOL_TARGET, REBALANCE
CORR_1, CORR_2, CAP_EXP, VOL_TARGET, REBALANCE = value
test = run_algorithm(
start=pd.Timestamp('2013-01-01', tz='utc'),
end=pd.Timestamp('2018-10-31', tz='utc'),
initialize=initialize,
handle_data=handle_data,
bundle='futures',
capital_base=1e+6,
)
results[key] = test
with open('results/{}.pickle'.format(file_name), 'wb') as file:
pickle.dump(results, file)
def get_performance(self):
start_session = self.end_session - timedelta(
days=self.days_to_trade) + timedelta(minutes=1)
print(self.start_session
if start_session < self.start_session else start_session)
start = self.start_session if start_session < self.start_session else start_session
return zipline.run_algorithm(
start=start + self.start_timedelta,
end=self.end_session,
initialize=self.initialize,
trading_calendar=always_open.AlwaysOpenCalendar(),
capital_base=self.initial_portfolio_value,
handle_data=self.handle_data,
data_frequency="minute",
data=self.minute_data)
def run_algorithm(self,
params_list,
capital_base=800000,
exchange_calendar=TFSExchangeCalendar(),
**kwargs):
#TODO: sortino ratio warning, suppress?
"""
:param params_list: list of parameter to be used for the strategy
:param capital_base: optional. Money to start with
:param exchange_calendar: TradingCalendar
:return: return from zipline.run_algorithm()
"""
if 'trailing_window' not in params_list:
raise KeyError('data history parameter missing')
if self.panel[self.asset_symbol].index[
params_list['trailing_window']].tzinfo:
self.start_session = self.panel[self.asset_symbol].index[
params_list['trailing_window']].tz_convert(
'UTC').to_pydatetime()
self.end_session = self.panel[
self.asset_symbol].index[-1].tz_convert('utc').to_pydatetime()
else:
self.start_session = self.panel[self.asset_symbol].index[
params_list['trailing_window']].tz_localize(
'utc').to_pydatetime()
self.end_session = self.panel[self.asset_symbol].index[
-1].tz_localize('utc').to_pydatetime()
result = zipline.run_algorithm(start = self.start_session,\
end = self.end_session,\
initialize = self.initialize_(params_list=params_list,commission_cost={'cost':0.0075}), \
handle_data= self.handle_data_(),\
data = self.panel,\
capital_base=capital_base,\
data_frequency = self.frequency,\
trading_calendar=exchange_calendar,**kwargs,)
return result
def test_example(self, example):
mod = getattr(examples, example)
actual_perf = run_algorithm(
handle_data=mod.handle_data,
initialize=mod.initialize,
before_trading_start=getattr(mod, 'before_trading_start', None),
analyze=getattr(mod, 'analyze', None),
bundle='test',
environ={
'ZIPLINE_ROOT': self.tmpdir.getpath('example_data/root'),
},
capital_base=1e7,
**mod._test_args())
assert_equal(
actual_perf[self.cols_to_check],
self.expected_perf[example][self.cols_to_check],
# There is a difference in the datetime columns in pandas
# 0.16 and 0.17 because in 16 they are object and in 17 they are
# datetime[ns, UTC]. We will just ignore the dtypes for now.
check_dtype=False,
)
def test_example(self, example):
mod = getattr(examples, example)
actual_perf = run_algorithm(
handle_data=mod.handle_data,
initialize=mod.initialize,
before_trading_start=getattr(mod, 'before_trading_start', None),
analyze=getattr(mod, 'analyze', None),
bundle='test',
environ={
'ZIPLINE_ROOT': self.tmpdir.getpath('example_data/root'),
},
capital_base=1e7,
**mod._test_args()
)
assert_equal(
actual_perf[self.cols_to_check],
self.expected_perf[example][self.cols_to_check],
# There is a difference in the datetime columns in pandas
# 0.16 and 0.17 because in 16 they are object and in 17 they are
# datetime[ns, UTC]. We will just ignore the dtypes for now.
check_dtype=False,
)