def initialize(context): schedule_function(func=trade, date_rule=date_rules.every_day(), time_rule=time_rules.market_open(), half_days=True) schedule_function(func=cancel, time_rule=time_rules.market_close(minutes=5), date_rule=date_rules.every_day(), half_days=True) schedule_function(func=reorder, time_rule=time_rules.market_open(minutes=5), date_rule=date_rules.every_day(), half_days=True) context.asserts = symbols('SPY') context.bonds = symbol('SHY') context.rebalance_date = 0 context.fired = False context.rebalance_inteval = 'D' #'Q', #'D', #'M' #'Q' #'Y' context.top_n_by_momentum = pd.Series() #Choose X stocks out of portfolio of Y stocks- how many stocks to hold - top X by momentum context.stocks = 1 #Lookback for momentum calculation context.momentum_days = 60 #set at less than 1 to ensure no leverage context.leverage_buffer = 0.99 #Set to 0 to reject any stocks with negative momentum, set to -1 to accept stocks with negative momentum context.trend = 0.0 context.reorder_dict = {}
def initialize(context): """ Called once at the start of the algorithm. """ set_slippage(slippage.VolumeShareSlippage(volume_limit=0.025, price_impact=0.1)) set_commission(commission.PerShare(cost=0.01, min_trade_cost=1.00)) set_max_leverage(1.0) # Rebalance every day, 1 hour after market open. schedule_function( context.my_rebalance, date_rules.every_day(), time_rules.market_open(hours=1) ) # Close all positions every day, 30 minutes before market close. schedule_function( context.close_positions, date_rules.every_day(), time_rules.market_close(minutes=30) ) # Create risk manager context.risk_manager = RiskManager(context, daily_risk) # Create our dynamic stock selector. attach_pipeline(context.make_screener(), 'stock_screener')
def initialize(self, context): if self.verbose: print("Starting the robo advisor") # Populate Portfolios self.all_portfolios = initialize_portfolio(self.verbose) # Set Commission model self.initialize_commission(country=self.country, platform=self.trading_platform) # Set Slippage model set_slippage(slippage.FixedSlippage(spread=0.0)) # assume spread of 0 # Schedule Rebalancing check rebalance_check_freq = date_rules.month_end() if (self.rebalance_freq == 'daily'): rebalance_check_freq = date_rules.every_day() elif (self.rebalance_freq == 'weekly'): rebalance_check_freq = date_rules.week_end() if self.verbose: print('Rebalance checks will be done %s' % self.rebalance_freq) schedule_function( func=self.before_trading_starts, date_rule=rebalance_check_freq, time_rule=time_rules.market_open(hours=1)) # record daily weights at the end of each day schedule_function( func=record_current_weights, date_rule=date_rules.every_day(), time_rule=time_rules.market_close() )
def initialize(context): """ Called once at the start of the algorithm. """ set_slippage(slippage.FixedSlippage(spread=0.00)) set_commission(commission.PerShare(cost=0, min_trade_cost=0)) schedule_function(rebalance, TRADE_FREQ, date_rules.every_day(), time_rules.market_open(hours=1, minutes=30), ) schedule_function(record_vars, date_rules.every_day(), time_rules.market_close()) ml_pipeline = make_ml_pipeline(universe, n_forward_days=N_FORWARD_DAYS, window_length=TRAINING_PERIOD) # Create our dynamic stock selector. attach_pipeline(ml_pipeline, 'ml_model') context.past_predictions = {} context.ic = 0 context.rmse = 0 context.mae = 0 context.returns_spread_bps = 0
def initialize(context): # Get continuous futures for Light Sweet Crude Oil... context.crude_oil = continuous_future('CL', roll='calendar') # ... and RBOB Gasoline context.gasoline = continuous_future('RB', roll='calendar') # If Zipline has trouble pulling the default benchmark, try setting the # benchmark to something already in your bundle set_benchmark(context.crude_oil) # Ignore commissions and slippage for now set_commission(us_futures=commission.PerTrade(cost=0)) set_slippage(us_futures=slippage.FixedSlippage(spread=0.0)) # Long and short moving average window lengths context.long_ma = 65 context.short_ma = 5 # True if we currently hold a long position on the spread context.currently_long_the_spread = False # True if we currently hold a short position on the spread context.currently_short_the_spread = False # Rebalance pairs every day, 30 minutes after market open schedule_function(func=rebalance_pairs, date_rule=date_rules.every_day(), time_rule=time_rules.market_open(minutes=30)) # Record Crude Oil and Gasoline Futures prices everyday schedule_function(record_price, date_rules.every_day(), time_rules.market_open())
def initialize(context): """ API function to define things to do at the start of the strategy. """ # set strategy parameters context.lookback_data = 60 context.lookback_long = 20 context.leverage = 2.0 context.profit_target = 1.0 # reset everything at start daily_reset(context) # create our universe create_universe(context) # schedule calculation at the end of opening range (30 minutes) schedule_function(calculate_trading_metrics, date_rules.every_day(), time_rules.market_open(hours=0, minutes=30)) # schedule entry rules schedule_function(no_more_entry, date_rules.every_day(), time_rules.market_open(hours=1, minutes=30)) # schedule exit rules schedule_function(unwind, date_rules.every_day(), time_rules.market_close(hours=0, minutes=30)) # set trading costs set_commission(commission.PerShare(cost=0.005, min_trade_cost=0.0)) set_slippage(slippage.FixedSlippage(0.00))
def initialize(context): """ A function to define things to do at the start of the strategy """ # set the account currency, only valid for backtests set_account_currency("USD") # lot-size (mini-lot for most brokers) context.lot_size = 1000 # universe selection context.securities = [ symbol('FXCM:AUD/USD'), symbol('FXCM:EUR/CHF'), symbol('FXCM:EUR/JPY'), symbol('FXCM:EUR/USD'), symbol('FXCM:GBP/USD'), symbol('FXCM:NZD/USD'), symbol('FXCM:USD/CAD'), symbol('FXCM:USD/CHF'), symbol('FXCM:USD/JPY'), ] # define strategy parameters context.params = { 'indicator_lookback': 375, 'indicator_freq': '1m', 'buy_signal_threshold': 0.5, 'sell_signal_threshold': -0.5, 'SMA_period_short': 15, 'SMA_period_long': 60, 'RSI_period': 60, 'trade_freq': 30, 'leverage': 1, 'pip_cost': 0.00003 } # variable to control trading frequency context.bar_count = 0 context.trading_hours = False # variables to track signals and target portfolio context.signals = dict((security, 0) for security in context.securities) context.target_position = dict( (security, 0) for security in context.securities) # set trading cost and slippage to zero set_commission(fx=commission.PipsCost(cost=context.params['pip_cost'])) set_slippage(fx=slippage.FixedSlippage(0.00)) # set a timeout for trading schedule_function(stop_trading, date_rules.every_day(), time_rules.market_close(hours=0, minutes=31)) # call square off to zero out positions 30 minutes before close. schedule_function(daily_square_off, date_rules.every_day(), time_rules.market_close(hours=0, minutes=30))
def initialize(context): # Define Symbol context.security = symbol('MSFT') # Define standard devation threshold context.std_dev_threshold = 0.6 schedule_function(enter_position, date_rule=date_rules.every_day(), time_rule=time_rules.market_open()) schedule_function(square_off, date_rule=date_rules.every_day(), time_rule=time_rules.market_close(minutes=1))
def rebalance_scheduler(context): ''' function to schedule a rebalancing trade. The rebalancing is done based on the weights determined in the strategy core for each of the instruments defined in the trading universe. ''' context.use_handle_data = False rebalance_freq = context.params.get('rebalance_freq',None) if rebalance_freq is None: return if context.params['verbose']: print('setting up {} scheduler'.format(rebalance_freq)) if rebalance_freq == 'monthly': schedule_function(rebalance, date_rules.month_start(days_offset=0), time_rules.market_open(hours=5, minutes=30)) elif rebalance_freq == 'weekly': schedule_function(rebalance, date_rules.week_start(days_offset=0), time_rules.market_open(hours=5, minutes=30)) elif rebalance_freq == 'daily': schedule_function(rebalance, date_rules.every_day(), time_rules.market_open(hours=5, minutes=30)) elif rebalance_freq.endswith('m'): try: context.trade_freq = int(rebalance_freq.split('m')[0]) print('trade freq {}'.format(context.trade_freq)) context.bar_count = 0 context.use_handle_data = True except: raise ValueError('Invalid minute frequency') elif rebalance_freq.endswith('h'): try: context.trade_freq = int(rebalance_freq.split('h')[0])*60 print('trade freq {}'.format(context.trade_freq)) context.bar_count = 0 context.use_handle_data = True except: raise ValueError('Invalid hourly frequency') else: raise ValueError('Un-recognized rebalancing frequency') if context.params['no_overnight_position']: schedule_function(square_off, date_rules.every_day(), time_rules.market_close(hours=3, minutes=30))
def initialize(context): # Turn off the slippage model set_slippage(slippage.FixedSlippage(spread=0.0)) # Set the commission model set_commission(commission.PerShare(cost=0.01, min_trade_cost=1.0)) context.day = -1 # using zero-based counter for days context.set_benchmark(symbol('DIA')) context.assets = [] print('Setup investable assets...') for ticker in asset_tickers: #print(ticker) context.assets.append(symbol(ticker)) context.n_asset = len(context.assets) context.n_portfolio = 40 # num mean-variance efficient portfolios to compute context.today = None context.tau = None context.min_data_window = 756 # min of 3 yrs data for calculations context.first_rebal_date = None context.first_rebal_idx = None context.weights = None # Schedule dynamic allocation calcs to occur 1 day before month end - note that # actual trading will occur on the close on the last trading day of the month schedule_function(rebalance, date_rule=date_rules.month_end(days_offset=1), time_rule=time_rules.market_close()) # Record some stuff every day schedule_function(record_vars, date_rule=date_rules.every_day(), time_rule=time_rules.market_close())
def initialize(context): """ Called once at the start of the algorithm. """ feature_num = 11 context.orders_submitted = False large_num = 9999999 least_num = 0 context.n_components = feature_num context.security = symbol(SYMBOL) # Trade SPY set_benchmark(symbol(SYMBOL)) # Set benchmarks context.model = SVC(kernel='rbf', tol=1e-3, random_state=0, gamma=0.2, C=10.0, verbose=True) # 8.05 for SVM model context.lookback = 350 # Look back 62 days context.history_range = 350 # Only consider the past 400 days' history context.threshold = 4.05 context.longprices = large_num context.shortprices = least_num set_long_only() # Generate a new model every week schedule_function(create_model, date_rules.week_end(), time_rules.market_close(minutes=10)) """ # Generate a new model every week schedule_function(create_model1, date_rules.week_end(), time_rules.market_close(minutes=10)) """ # Trade at the start of every day schedule_function(rebalance, date_rules.every_day(), time_rules.market_open(minutes=1))
def initialize(context): # Set benchmark to short-term Treasury note ETF (SHY) since strategy is dollar neutral set_benchmark(symbol('AAPL')) # Schedule our rebalance function to run at the end of each day. # Modified the timing to 5 mins earlier than the market close to reduce the fail to book warnings # schedule_function(my_rebalance, date_rules.every_day(), time_rules.market_close(minutes=5)) # Try to change it to open and see what happened -- HY schedule_function(my_rebalance, date_rules.every_day(), time_rules.market_open(minutes=5)) # Record variables at the end of each day. # schedule_function(my_record_vars, date_rules.every_day(), time_rules.market_close()) # Get intraday prices today before the close if you are not skipping the most recent data # schedule_function(get_prices,date_rules.every_day(), time_rules.market_close(minutes=10)) # Try to get the price data when the market is opening -- HY # schedule_function(get_prices, date_rules.every_day(), time_rules.market_open(minutes=1)) # Set commissions and slippage to 0 to determine pure alpha set_commission(commission.PerShare(cost=0, min_trade_cost=0)) set_slippage(slippage.FixedSlippage(spread=0)) # Number of quantiles for sorting returns for mean reversion context.nq = 5 # Number of quantiles for sorting volatility over five-day mean reversion period context.nq_vol = 3 # Create our pipeline and attach it to our algorithm. my_pipe = make_pipeline() attach_pipeline(my_pipe, 'my_pipeline')
def initialize(context): attach_pipeline(make_pipeline(), 'pipeline') #Schedule Functions if not IS_LIVE: schedule_function( trade, #date_rules.every_day(), #date_rules.week_end(days_offset=1),#0=Fri 1= Thurs date_rules.month_end(days_offset=3), time_rules.market_close(minutes=30) ) schedule_function(record_vars, date_rules.every_day(), time_rules.market_close()) schedule_function(cancel_open_orders, date_rules.week_end(days_offset=2), time_rules.market_close()) context.spy = symbol('SPY') #sid(8554) #SPY context.TF_filter = False #context.TF_lookback = 60 #Set number of securities to buy and bonds fund (when we are out of stocks) context.Target_securities_to_buy = 15 #10 #15 #2 #1 #5 #10 #5 context.bonds = symbol('IEF') #sid(23870) #IEF context.relative_momentum_lookback = 44 #66 #22 #4 #22 #22 #22 #126 #Momentum lookback context.momentum_skip_days = 1 context.top_n_relative_momentum_to_buy = 10 #15 #10 #15 #1 #5 #5 #10 #5 #Number to buy context.stock_weights = pd.Series() context.bond_weights = pd.Series() context.auto_close = {} #Initialize portfolio auto_close list. context.TRACK_ORDERS_ON = False
def initialize(context): """ Called once at the start of the algorithm. """ feature_num = 11 context.orders_submitted = False large_num = 9999999 least_num = 0 context.n_components = 6 context.security = symbol(SYMBOL) # Trade SPY set_benchmark(symbol(SYMBOL)) # Set benchmarks context.model2 = SVC(kernel='rbf', tol=1e-3, random_state=0, gamma=0.2, C=10.0, verbose=True) # 8.05 for SVM model context.model3 = KNeighborsClassifier(n_neighbors=feature_num, p=3, metric='minkowski') # 7.05 for model context.model = DecisionTreeClassifier(criterion='entropy', max_depth=feature_num, random_state=0) context.model4 = RandomForestClassifier(criterion='entropy', n_estimators=feature_num, random_state=1, n_jobs=2) # 5.2 for randomforest context.model1 = LogisticRegression(random_state=0, solver='lbfgs', multi_class='multinomial') context.modellist = {'SVM':context.model2,'KNeighbors':context.model3,'DecisionTree':context.model,'RandomForest':context.model4,'LogisticRegression':context.model1} context.lookback = 350 # Look back 62 days context.history_range = 350 # Only consider the past 400 days' history context.threshold = 4.05 context.longprices = large_num context.shortprices = least_num context.time_series = 0 context.init = 0 set_long_only() # Generate a new model every week #schedule_function(create_model, date_rules.week_end(), time_rules.market_close(minutes=10)) """ # Generate a new model every week schedule_function(create_model1, date_rules.week_end(), time_rules.market_close(minutes=10)) """ # Trade at the start of every day schedule_function(rebalance, date_rules.every_day(), time_rules.market_open(minutes=1))
def initialize(context): ''' Initialize global vars''' context.long_leverage = 0.1 context.short_leverage = -0.9 context.returns_lookback = 16 context.pct_per_stock = 0.5 context.fastperiod = 12 context.slowperiod = 26 context.signalperiod = 9 context.bar_count = 90 set_commission(commission.PerShare(cost=0.0014, min_trade_cost=1)) # Rebalance on the first trading day of each week at 12AM. schedule_function(rebalance, date_rules.week_start(days_offset=0),time_rules.market_open(hours=0.5)) # Rebalance mid-week schedule_function(cut_losses, date_rules.week_start(days_offset=2),time_rules.market_open(hours=0.5)) # Record tracking variables at the end of each day. schedule_function(record, date_rules.every_day(),time_rules.market_open(minutes=1)) # Create and attach our pipeline (dynamic stock selector), defined below. attach_pipeline(make_pipeline(context), 'mean_reversion_macd_learning')
def initialize(context): # Benchmark against the Dow Jones Industrial Average (DIA) set_benchmark(symbol('DIA')) # stop when trying to handle missing data set_nodata_policy(NoDataPolicy.EXCEPTION) # These are the default commission and slippage settings. Change them to fit your # brokerage fees. These settings only matter for backtesting. When you trade this # algorithm, they are moot - the brokerage and real market takes over. set_commission(commission.PerTrade(cost=0.03)) set_slippage(slippage.VolumeShareSlippage(volume_limit=0.25, price_impact=0.1)) # create an instance of the Dow30 class and set it within context context.dow30 = Dow30() # next trade year context.year = 0 # set to True to trigger a rebalance context.trade = False # for tracking max leverage context.mx_lvrg = 0 # check for possible trade, daily schedule_function(func=rebalance, date_rule=date_rules.every_day(), time_rule=time_rules.market_open(hours=1))
def initialize(context): attach_pipeline(make_pipeline(), 'my_pipeline') # Rebalance each day. In daily mode, this is equivalent to putting # `rebalance` in our handle_data, but in minute mode, it's equivalent to # running at the start of the day each day. schedule_function(rebalance, date_rules.every_day())
def initialize(context): """ Called once at the start of the algorithm. """ feature_num = 11 context.orders_submitted = False large_num = 9999999 least_num = 0 context.n_components = feature_num context.security = symbol(SYMBOL) # Trade SPY set_benchmark(symbol(SYMBOL)) # Set benchmarks context.model = DecisionTreeClassifier(criterion='entropy', max_depth=feature_num, random_state=0) context.lookback = 350 # Look back 62 days context.history_range = 350 # Only consider the past 400 days' history context.threshold = 4.05 context.longprices = large_num context.shortprices = least_num set_long_only() # Generate a new model every week schedule_function(create_model, date_rules.week_end(), time_rules.market_close(minutes=10)) """ # Generate a new model every week schedule_function(create_model1, date_rules.week_end(), time_rules.market_close(minutes=10)) """ # Trade at the start of every day schedule_function(rebalance, date_rules.every_day(), time_rules.market_open(minutes=1))
def initialize(context): # slippage model set_slippage(slippage.FixedSlippage(spread=0)) # stock universe - list of tickers securities = ['AAPL', 'ADBE', 'AIG', 'AMGN', 'BA'] # change string list of tickers into asset list using symbol function context.sec_symbols = [symbol(s) for s in securities] print(len(context.sec_symbols)) # schedule functions schedule_function(trade_market_open, date_rules.every_day(), time_rules.market_open()) schedule_function(cancel_open, date_rules.every_day(), time_rules.market_close())
def initialize(context): # Schedule our rebalance function to run at the start of # each week, when the market opens. schedule_function(func=my_rebalance, date_rule=date_rules.every_day(), time_rule=time_rules.market_open())
def initialize(context): """ function to define things to do at the start of the strategy """ # set the account currency, only valid for backtests set_account_currency("USD") # trading pound parity! # this should work after the European sovereign crisis settled down # and before the Brexit noise started (2012-2015) context.x = symbol('FXCM:GBP/USD') context.y = symbol('FXCM:EUR/USD') context.leverage = 5 context.signal = 0 # Trade entry and exit when the z_score is +/- entry_z_score and exit_z_score respectively context.entry_z_score = 2.0 context.exit_z_score = 0.5 # Lookback window context.lookback = 720 # used for zscore calculation context.z_window = 360 # Call strategy function after the London open every day schedule_function(pair_trading_strategy, date_rules.every_day(), time_rules.market_open(hours=9,minutes=30)) # set trading cost and slippage to zero set_commission(fx=commission.PipsCost(cost=0.00)) set_slippage(fx=slippage.FixedSlippage(0.00)) # square off towards to NYC close context.trading_hours = False # set a timeout for trading schedule_function(stop_trading, date_rules.every_day(), time_rules.market_close(hours=0, minutes=31)) # call square off to zero out positions 30 minutes before close. schedule_function(daily_square_off, date_rules.every_day(), time_rules.market_close(hours=0, minutes=30))
def initialize(context): __build_deeplearn_strategy(context) attach_pipeline(make_pipeline(context), 'my_pipeline') schedule_function(rebalance, date_rules.every_day(), time_rules.every_minute()) # record my portfolio variables at the end of day print("initialize over") pass
def initialize(context): context.params = {'lookback':12, 'min_volume':1E7 } schedule_function(strategy, date_rules.every_day(), time_rules.market_open(minutes=30)) attach_pipeline(make_strategy_pipeline(context), name='strategy_pipeline')
def initialize(context): schedule_function(func=trade, date_rule=date_rules.every_day(), time_rule=time_rules.market_open(), half_days=True) context.asserts = symbols('SPY', 'SHY', 'TLT', 'GLD') context.asserts_position = [0.25, 0.25, 0.25, 0.25] context.rebalance_inteval = 'Q' #'Q', #'D', #'M' #'Q' #'Y' context.rebalance_date = 0 context.fired = False
def initialize(context): context.security = symbol(SYMBOL) # Trade set_benchmark(symbol(SYMBOL)) # Set benchmarks #print(context.security) context.start = True set_long_only() schedule_function(market_open, date_rules.every_day(), time_rules.market_open(minutes=1)) context.orders_submitted = False
def initialize(context): attach_pipeline(make_pipeline(), 'my_pipeline') # Explicitly set the commission/slippage to the "old" value until we can # rebuild example data. # github.com/quantopian/zipline/blob/master/tests/resources/ # rebuild_example_data#L105 context.set_commission(commission.PerShare(cost=.0075, min_trade_cost=1.0)) context.set_slippage(VolumeShareSlippage()) schedule_function(rebalance2, date_rules.every_day())
def initialize(context): """ Called once at the start of the algorithm. """ context.n_longs = N_LONGS context.n_shorts = N_SHORTS context.min_positions = MIN_POSITIONS context.universe = assets set_slippage(slippage.FixedSlippage(spread=0.00)) set_commission(commission.PerShare(cost=0, min_trade_cost=0)) schedule_function(rebalance, date_rules.every_day(), time_rules.market_open(hours=1, minutes=30)) schedule_function(record_vars, date_rules.every_day(), time_rules.market_close()) pipeline = compute_signals() attach_pipeline(pipeline, 'signals')
def initialize(context): attach_pipeline(make_pipeline(), 'data_pipeline') context.technical_indicator_states = {} context.window_length = 7 context.benchmark = deque(maxlen=context.window_length) context.benchmark_asset = symbol('SPY') context.benchmark_assets = symbols('QQQ', 'SPY') #context.classifier = RandomForestClassifier() # Use a random forest classifier context.classifier = DecisionTreeClassifier(max_depth=5, max_leaf_nodes=10) # Clasifier training data context.features = [ 'RSI', 'EMA', 'MACD', 'SMA_5', 'SMA_10', 'bb_lower', 'bb_middle', 'bb_upper' ] context.response = ['Class'] context.X = pd.DataFrame( columns=context.features) # Independent, or input variables context.Y = pd.DataFrame( columns=context.response) # Dependent, or output variable context.prediction = {} # Stores most recent prediction context.tick = 0 context.total_buy = 0 context.positions = None context.position_adjustment_days = 5 # Number of days to wait before adjusting positions context.min_data_points = 500 context.max_data_points = 1500 schedule_function(rebalance, date_rules.every_day(), time_rules.market_open(minutes=1)) schedule_function(record_vars, date_rules.every_day(), time_rules.market_close()) set_benchmark(symbol('SPY')) # Turn off the slippage model set_slippage(slippage.FixedSlippage(spread=0.0)) # Set the commission model (Interactive Brokers Commission) set_commission(commission.PerShare(cost=0.01, min_trade_cost=1.0))
def initialize(context): ''' Called once at the start of the strategy execution. This is the place to define things to do at the start of the strategy. ''' # set the account base currency and strategy parameters set_account_currency('USD') context.params = { 'verbose': False, 'leverage': 1, 'rebalance_freq': '15m', 'no_overnight_position': True, 'pip_cost': 0.00008, 'rollover_spread': 0.00, 'BBands_period': 1440, 'SMA_period_short': 150, 'SMA_period_long': 600, 'indicator_lookback': 1440, # max of all lookbacks!!! 'indicator_freq': '1m', 'buy_signal_threshold': 0.5, 'sell_signal_threshold': -0.5 } # define the strategy instruments universe context.universe = [ symbol('FXCM:AUD/USD'), symbol('FXCM:EUR/USD'), symbol('FXCM:NZD/USD'), symbol('FXCM:USD/CAD'), symbol('FXCM:USD/CHF'), ] context.ccy_universe = [ 'AUD', 'CAD', 'CHF', 'EUR', 'GBP', 'JPY', 'NZD', 'USD' ] # function to schedule roll-overs, at 5 PM EST or 9 PM UTC (3 hours before midnight) schedule_function(compute_rollovers, date_rules.every_day(), time_rules.market_close(hours=3, minutes=0)) # set up cost structures, we assume a $1 per $10K all-in cost set_commission(fx=commission.PipsCost(cost=context.params['pip_cost'])) set_slippage(fx=slippage.FixedSlippage(spread=0.00)) # variables to track signals and target portfolio context.signals = dict((security, 0) for security in context.universe) context.weights = dict((security, 0) for security in context.universe) # Call rebalance function, see below under standard helper functions to modify rebalance_scheduler(context) # make the back-test lighter context.perf_tracker.keep_transactions = False context.perf_tracker.keep_orders = False
def initialize(context): __build_factor_basic_strategy(context) attach_pipeline(make_pipeline(context), 'my_pipeline') schedule_function(rebalance, date_rules.week_end(days_offset=0), half_days=True) # record my portfolio variables at the end of day schedule_function(func=recording_statements, date_rule=date_rules.every_day(), time_rule=time_rules.market_close(), half_days=True) print("initialize over") pass
def initialize(context): attach_pipeline(make_pipeline(), 'my_pipeline') # Rebalance each day. In daily mode, this is equivalent to putting # `rebalance` in our handle_data, but in minute mode, it's equivalent to # running at the start of the day each day. schedule_function(rebalance, date_rules.every_day()) # Explicitly set the commission to the "old" value until we can # rebuild example data. # github.com/quantopian/zipline/blob/master/tests/resources/ # rebuild_example_data#L105 context.set_commission(commission.PerShare(cost=.0075, min_trade_cost=1.0))