コード例 #1
0
def run_monthly_rebalance(tickers, ticker_weights, title, start_date, end_date,
                          initial_equity):
    testing = False
    config = settings.from_file(settings.DEFAULT_CONFIG_FILENAME, testing)

    # Use the Monthly Liquidate And Rebalance strategy
    events_queue = queue.Queue()
    strategy = MonthlyLiquidateRebalanceStrategy(tickers, events_queue)

    # Use the liquidate and rebalance position sizer
    # with prespecified ticker weights
    position_sizer = LiquidateRebalancePositionSizer(ticker_weights)

    # Set up the backtest
    backtest = TradingSession(
        config,
        strategy,
        tickers,
        initial_equity,
        start_date,
        end_date,
        events_queue,
        position_sizer=position_sizer,
        title=[title],
        benchmark=tickers[0],
    )
    results = backtest.start_trading(testing=testing)
    return results
コード例 #2
0
def run(config, testing, tickers, filename):
    # Backtest information
    title = ['Monthly Liquidate/Rebalance on 60%/40% SPY/AGG Portfolio']
    initial_equity = 500000.0
    start_date = datetime.datetime(2006, 11, 1)
    end_date = datetime.datetime(2016, 10, 12)

    # Use the Monthly Liquidate And Rebalance strategy
    events_queue = queue.Queue()
    strategy = MonthlyLiquidateRebalanceStrategy(tickers, events_queue)

    # Use the liquidate and rebalance position sizer
    # with prespecified ticker weights
    ticker_weights = {
        "SPY": 0.6,
        "AGG": 0.4,
    }
    position_sizer = LiquidateRebalancePositionSizer(ticker_weights)

    # Set up the backtest
    backtest = TradingSession(
        config,
        strategy,
        tickers,
        initial_equity,
        start_date,
        end_date,
        events_queue,
        position_sizer=position_sizer,
        title=title,
        benchmark=tickers[0],
    )
    results = backtest.start_trading(testing=testing)
    return results
コード例 #3
0
def run(config, testing, tickers, filename):
    # Backtest information
    title = ['Moving Average Crossover Example on %s: 100x300' % filename]
    initial_equity = 10000.0
    start_date = datetime.datetime(2013, 1, 1)
    end_date = datetime.datetime(2018, 1, 1)
    cycle = 'D'

    # Use the MAC Strategy
    events_queue = queue.Queue()
    strategy = MovingAverageCrossStrategy(tickers[0],
                                          events_queue,
                                          short_window=1,
                                          long_window=20)

    # Set up the backtest
    backtest = TradingSession(config,
                              strategy,
                              tickers,
                              initial_equity,
                              start_date,
                              end_date,
                              events_queue,
                              price_handler='tushare',
                              title=title,
                              benchmark=tickers[1],
                              cycle=cycle)

    results = backtest.start_trading(testing=testing, filename=filename)

    return results
コード例 #4
0
def run(config, testing, tickers, filename):
    # Backtest information

    title = ["Kalman Filter Pairs Trade on %s/%s" % (tickers[0], tickers[1])]
    initial_equity = 100000.0
    start_date = datetime.datetime(2017, 1, 1)
    end_date = datetime.datetime(2018, 8, 19)

    # Use the KalmanPairsTrading Strategy
    events_queue = queue.Queue()
    strategy = KalmanPairsTradingStrategy(tickers, events_queue)

    # Use the Naive Position Sizer where
    # suggested quantities are followed
    position_sizer = NaivePositionSizer()

    # Set up the backtest
    backtest = TradingSession(config,
                              strategy,
                              tickers,
                              initial_equity,
                              start_date,
                              end_date,
                              events_queue,
                              title=title,
                              position_sizer=position_sizer)
    results = backtest.start_trading(testing=testing)
    return results
コード例 #5
0
def run(config, testing, tickers, filename):
    # Backtest information
    title = ['Aluminium Smelting Strategy - ARNC/UNG']
    initial_equity = 500000.0
    start_date = datetime.datetime(2014, 11, 11)
    end_date = datetime.datetime(2016, 9, 1)

    # Use the Cointegration Bollinger Bands trading strategy
    events_queue = queue.Queue()
    weights = np.array([1.0, -1.213])
    lookback = 15
    entry_z = 1.5
    exit_z = 0.5
    base_quantity = 10000
    strategy = CointegrationBollingerBandsStrategy(tickers, events_queue,
                                                   lookback, weights, entry_z,
                                                   exit_z, base_quantity)

    # Set the position size to use a
    # fixed base quantity of shares
    position_sizer = FixedPositionSizer(default_quantity=base_quantity)

    # Set up the backtest
    backtest = TradingSession(config,
                              strategy,
                              tickers,
                              initial_equity,
                              start_date,
                              end_date,
                              events_queue,
                              title=title,
                              position_sizer=position_sizer)
    results = backtest.start_trading(testing=testing)
    return results
コード例 #6
0
def run(config, testing, tickers, filename):
    # Backtest information
    title = ['Moving Average Crossover Example']
    initial_equity = 10000.0
    ##start_date = datetime.datetime(2011, 1, 1)
    ##end_date = datetime.datetime(2020, 1, 1)
    start_date = datetime.datetime(2015, 1, 1)
    end_date = datetime.datetime(2020, 1, 1)

    # Use the MAC Strategy
    events_queue = queue.Queue()
    strategy = MovingAverageCrossStrategy(tickers[0],
                                          events_queue,
                                          short_window=50,
                                          long_window=100)

    # Set up the backtest
    backtest = TradingSession(
        config,
        strategy,
        tickers,
        initial_equity,
        start_date,
        end_date,
        events_queue,
        session_type="backtest",
        name="strategy1",
        #benchmark=tickers[1],
        title=title)
    results = backtest.start_trading(testing=testing)
    #print(type(backtest))
    return results
コード例 #7
0
ファイル: month_rebalance.py プロジェクト: cujeu/qalgo
def run(config, testing, tickers, filename):
    # Backtest information
    title = ['Reblance Example']
    initial_equity = 10000.0
    ##start_date = datetime.datetime(2011, 1, 1)
    ##end_date = datetime.datetime(2020, 1, 1)
    start_date = datetime.datetime(2015, 1, 1)
    end_date = datetime.datetime(2020, 1, 1)

    # Use the MAC Strategy
    events_queue = queue.Queue()
    strategy = MonthRebalanceStrategy(tickers, events_queue)

    # Set up the backtest
    backtest = TradingSession(config,
                              strategy,
                              tickers,
                              initial_equity,
                              start_date,
                              end_date,
                              events_queue,
                              session_type="backtest",
                              name="month_reb",
                              title=title,
                              benchmark=None)
    results = backtest.start_trading(testing=testing)
    return results
コード例 #8
0
def run(config, testing, tickers, filename):
    # Backtest information
    title = ['Buy and Hold Example on %s' % tickers[0]]
    initial_equity = 10000.0
    start_date = datetime.datetime(2005, 1, 1)
    end_date = datetime.datetime(2018, 8, 17)

    # Use the Buy and Hold Strategy
    events_queue = queue.Queue()
    strategy = BuyAndHoldStrategy(tickers[0], events_queue)

    # Set up the backtest
    backtest = TradingSession(config,
                              strategy,
                              tickers,
                              initial_equity,
                              start_date,
                              end_date,
                              events_queue,
                              price_handler='tushare',
                              title=title,
                              benchmark=tickers[1])

    results = backtest.start_trading(testing=testing, filename=filename)
    return results
コード例 #9
0
ファイル: test.py プロジェクト: ajmal017/Alpha-1
def run(config, testing, tickers, filename):
    # Backtest information
    title = ['Moving Average Crossover Example on AAPL: 100x300']
    initial_equity = 10000.0
    start_date = datetime.datetime(2000, 1, 1)
    end_date = datetime.datetime(2014, 1, 1)

    # Use the MAC Strategy
    events_queue = queue.Queue()
    strategy = MovingAverageCrossStrategy(tickers[0],
                                          events_queue,
                                          short_window=100,
                                          long_window=300)

    # Set up the backtest
    backtest = TradingSession(
        config,
        strategy,
        tickers,
        initial_equity,
        start_date,
        end_date,
        events_queue,
        title=title,
        benchmark=tickers[1],
    )
    results = backtest.start_trading(testing=testing)
    return results
コード例 #10
0
def run(config, testing, tickers, filename):
    # Set up variables needed for backtest
    events_queue = queue.Queue()
    csv_dir = config.CSV_DATA_DIR
    initial_equity = PriceParser.parse(100000.00)

    # Use Yahoo Daily Price Handler
    start_date = datetime.datetime(2009, 8, 3)
    end_date = datetime.datetime(2019, 8, 1)
    price_handler = YahooDailyCsvBarPriceHandler(csv_dir,
                                                 events_queue,
                                                 tickers,
                                                 start_date=start_date,
                                                 end_date=end_date)
    # Use the KalmanPairsTrading Strategy
    strategy = KalmanPairsTradingStrategy(tickers, events_queue)
    strategy = Strategies(strategy)

    # Use the Naive Position Sizer (suggested quantities are followed)
    position_sizer = NaivePositionSizer()

    # Use an example Risk Manager
    risk_manager = ExampleRiskManager()

    # Use the default Portfolio Handler
    portfolio_handler = PortfolioHandler(initial_equity, events_queue,
                                         price_handler, position_sizer,
                                         risk_manager)

    # Use the ExampleCompliance component
    compliance = ExampleCompliance(config)

    # Use a simulated IB Execution Handler
    execution_handler = IBSimulatedExecutionHandler(events_queue,
                                                    price_handler, compliance)

    # Use the Tearsheet Statistics
    title = ["Kalman Filter Pairs Trade on TLT/IEI"]
    statistics = TearsheetStatistics(config, portfolio_handler, title)

    # Set up the backtest
    backtest = TradingSession(config,
                              strategy,
                              tickers,
                              initial_equity,
                              start_date,
                              end_date,
                              events_queue,
                              price_handler=price_handler,
                              portfolio_handler=portfolio_handler,
                              execution_handler=execution_handler,
                              position_sizer=position_sizer,
                              risk_manager=risk_manager,
                              statistics=statistics)

    results = backtest.start_trading(testing=testing)
    statistics.save(filename)
    return results
コード例 #11
0
def run(config, testing, tickers, filename):
    # Set up variables needed for backtest
    title = ["Intraday AREX Machine Learning Prediction Strategy"]
    events_queue = queue.Queue()
    csv_dir = "/path/to/your/csv/data/"
    initial_equity = 500000.0

    # Use DTN IQFeed Intraday Bar Price Handler
    start_date = datetime.datetime(2013, 1, 1)
    end_date = datetime.datetime(2014, 3, 11)
    price_handler = IQFeedIntradayCsvBarPriceHandler(csv_dir,
                                                     events_queue,
                                                     tickers,
                                                     start_date=start_date)

    # Use the ML Intraday Prediction Strategy
    model_pickle_file = '/path/to/your/ml_model_lda.pkl'
    strategy = IntradayMachineLearningPredictionStrategy(tickers,
                                                         events_queue,
                                                         model_pickle_file,
                                                         lags=5)

    # Use the Naive Position Sizer where
    # suggested quantities are followed
    position_sizer = NaivePositionSizer()

    # Use an example Risk Manager
    risk_manager = ExampleRiskManager()

    # Use the default Portfolio Handler
    portfolio_handler = PortfolioHandler(PriceParser.parse(initial_equity),
                                         events_queue, price_handler,
                                         position_sizer, risk_manager)

    # Use the Tearsheet Statistics
    statistics = TearsheetStatistics(
        config,
        portfolio_handler,
        title=title,
        periods=int(252 * 6.5 * 60)  # Minutely periods
    )

    # Set up the backtest
    backtest = TradingSession(config,
                              strategy,
                              tickers,
                              initial_equity,
                              start_date,
                              end_date,
                              events_queue,
                              title=title,
                              portfolio_handler=portfolio_handler,
                              position_sizer=position_sizer,
                              price_handler=price_handler,
                              statistics=statistics)
    results = backtest.start_trading(testing=testing)
    return results
コード例 #12
0
def run(config, testing, tickers, filename):

    # Set up variables needed for backtest
    events_queue = queue.Queue()
    csv_dir = config.CSV_DATA_DIR
    initial_equity = PriceParser.parse(500000.00)

    # Use Yahoo Daily Price Handler
    start_date = datetime.datetime(2013, 7, 1)
    end_date = datetime.datetime(2019, 6, 1)
    price_handler = YahooDailyCsvBarPriceHandler(csv_dir, events_queue, tickers, start_date=start_date, end_date=end_date)

    # Use the Cointegration Bollinger Bands trading strategy
    weights = np.array([1.0, -1.213])
    lookback = 15
    entry_z = 1.5
    exit_z = 0.5
    base_quantity = 10000
    strategy = CointegrationBollingerBandsStrategy(tickers[1:], events_queue, lookback, weights, entry_z, exit_z, base_quantity)
    strategy = Strategies(strategy)

    # Use the Naive Position Sizer
    # where suggested quantities are followed
    position_sizer = NaivePositionSizer()

    # Use an example Risk Manager
    risk_manager = ExampleRiskManager()

    # Use the default Portfolio Handler
    portfolio_handler = PortfolioHandler(initial_equity, events_queue, price_handler, position_sizer, risk_manager)

    # Use the ExampleCompliance component
    compliance = ExampleCompliance(config)

    # Use a simulated IB Execution Handler
    execution_handler = IBSimulatedExecutionHandler(events_queue, price_handler, compliance)

    # Use the Tearsheet Statistics
    title = ["Aluminum Smelting Strategy - ARNC/UNG"]
    statistics = TearsheetStatistics(config, portfolio_handler, title, benchmark=tickers[0])
    
    # Set up the backtest
    backtest = TradingSession(config, strategy, 
        tickers[1:], initial_equity, start_date, end_date,
        events_queue, price_handler=price_handler,
        portfolio_handler=portfolio_handler, 
        execution_handler=execution_handler, 
        position_sizer=position_sizer, 
        risk_manager=risk_manager, 
        statistics=statistics, benchmark=tickers[0])

    results = backtest.start_trading(testing=testing)
    statistics.save(filename)
    return results
コード例 #13
0
def run(config, testing, tickers, filename):
    # Backtest information
    events_queue = queue.Queue()
    title = [
        'Sentiment Sentdex Strategy - Tech Stocks'
        #'Sentiment Sentdex Strategy - Defence Stocks'
        #'Sentiment Sentdex Strategy - Energy Stocks'
    ]
    initial_equity = 500000.0
    start_date = datetime.datetime(2012, 10, 15)
    end_date = datetime.datetime(2016, 2, 2)

    # Use the Sentdex Sentiment trading strategy
    sentiment_handler = SentdexSentimentHandler(config.CSV_DATA_DIR,
                                                "sentdex_sample.csv",
                                                events_queue,
                                                tickers=tickers,
                                                start_date=start_date,
                                                end_date=end_date)

    # Use the Sentdex Sentiment trading strategy
    base_quantity = 500
    sent_buy = 6
    sent_sell = -1
    strategy = SentdexSentimentStrategy(tickers, events_queue, sent_buy,
                                        sent_sell, base_quantity)

    # Use the Fixed Position Sizer where
    # suggested quantities are followed
    position_sizer = FixedPositionSizer(default_quantity=base_quantity)

    # Set up the backtest
    backtest = TradingSession(config,
                              strategy,
                              tickers,
                              initial_equity,
                              start_date,
                              end_date,
                              events_queue,
                              title=title,
                              position_sizer=position_sizer,
                              sentiment_handler=sentiment_handler,
                              benchmark="SPY")
    results = backtest.start_trading(testing=testing)
    return results
コード例 #14
0
def run(config, testing, tickers, filename):
    # Backtest information
    title = ['Monthly Liquidate/Rebalance on 60%/40% SPY/AGG Portfolio']
    initial_equity = 500000.0
    start_date = datetime.datetime(2006, 11, 1)
    end_date = datetime.datetime(2016, 10, 12)

    # Use the Monthly Liquidate And Rebalance strategy
    events_queue = queue.Queue()
    strategy = MonthlyLiquidateRebalanceStrategy(tickers, events_queue)

    # Use the liquidate and rebalance position sizer
    # with prespecified ticker weights
    ticker_weights = {
        "ewg.us": 0.4,
        "ewq.us": 0.6,
    }
    position_sizer = LiquidateRebalancePositionSizer(ticker_weights)

    # Set up the backtest
    backtest = TradingSession(
        config,
        strategy,
        tickers,
        initial_equity,
        start_date,
        end_date,
        events_queue,
        position_sizer=position_sizer,
        price_handler=DailyCsvBarPriceHandler('~/Desktop/stock-data/ETFs',
                                              ext_data='txt',
                                              init_tickers=tickers,
                                              events_queue=events_queue,
                                              start_date=start_date,
                                              end_date=end_date),
        title=title,
        benchmark=tickers[0],
    )
    results = backtest.start_trading(testing=testing)
    return results
コード例 #15
0
def run(config, testing, tickers, filename):
    # Backtest information
    title = [
        'Monthly Liquidate/Rebalance on 40%/30% 30% sz50/zz500/cyb Portfolio'
    ]
    initial_equity = 300000.0
    start_date = datetime.datetime(2010, 11, 1)
    end_date = datetime.datetime(2018, 8, 18)

    # Use the Monthly Liquidate And Rebalance strategy
    events_queue = queue.Queue()
    strategy = MonthlyLiquidateRebalanceStrategy(tickers, events_queue)

    # Use the liquidate and rebalance position sizer
    # with prespecified ticker weights
    ticker_weights = {
        "510050": 0.4,
        "510500": 0.3,
        "159915": 0.3,
    }
    position_sizer = LiquidateRebalancePositionSizer(ticker_weights)

    # Set up the backtest
    backtest = TradingSession(
        config,
        strategy,
        tickers,
        initial_equity,
        start_date,
        end_date,
        events_queue,
        price_handler='tushare',
        position_sizer=position_sizer,
        title=title,
        benchmark=tickers[0],
    )
    results = backtest.start_trading(testing=testing)
    return results
コード例 #16
0
def run(config, testing, tickers, filename):
    #build_HMM_model()
    build_HMM_model2()
    title = ["Trend Following Regime Detection without HMM"]
    #pickle_path = "hmm_model_spy.pkl"
    pickle_path = "hmm_model_spy2.pkl"
    #pickle_path = "hmm_model_fx.pkl"
    events_queue = queue.Queue()
    csv_dir = config.CSV_DATA_DIR
    initial_equity = 100000.00
    start_date = datetime.datetime(2011, 1, 1)
    end_date = datetime.datetime(2018, 3, 31)
    # Use the Moving Average Crossover trading strategy
    base_quantity = 10000
    strategy = MovingAverageCrossStrategy(tickers,
                                          events_queue,
                                          base_quantity,
                                          short_window=10,
                                          long_window=30)
    # Use Yahoo Daily Price Handler
    price_handler = YahooDailyCsvBarPriceHandler(csv_dir,
                                                 events_queue,
                                                 tickers,
                                                 start_date=start_date,
                                                 end_date=end_date,
                                                 calc_adj_returns=True)
    # Use the Naive Position Sizer
    # where suggested quantities are followed
    position_sizer = NaivePositionSizer()
    # Use an example Risk Manager
    #risk_manager = ExampleRiskManager()
    # Use regime detection HMM risk manager
    hmm_model = pickle.load(open(pickle_path, "rb"))
    risk_manager = RegimeHMMRiskManager(hmm_model)
    # Use the default Portfolio Handler
    portfolio_handler = PortfolioHandler(PriceParser.parse(initial_equity),
                                         events_queue, price_handler,
                                         position_sizer, risk_manager)
    # Use the Tearsheet Statistics class
    statistics = TearsheetStatistics(
        config,
        portfolio_handler,
        #title,benchmark = "EEM"
        title,
        benchmark="VWO")

    # Set up the backtest
    backtest = TradingSession(config,
                              strategy,
                              tickers,
                              initial_equity,
                              start_date,
                              end_date,
                              events_queue,
                              title=title,
                              price_handler=price_handler,
                              position_sizer=position_sizer,
                              risk_manager=risk_manager,
                              statistics=statistics,
                              portfolio_handler=portfolio_handler)
    results = backtest.start_trading(testing=testing)
    return results
コード例 #17
0
def run(config, testing, tickers, cliente, strat_set):

    events_queue = queue.Queue()
    initial_equity = 30000.0

    end_session_time = datetime(2018, 2, 23, 16, 1, 00)
    if end_session_time < datetime.now():
        print("########################################")
        print("  Yoe, Increase \"end_section time\" please")
        print("########################################")
        exit()

    start_date = None
    end_date = None

    #
    # Defining up to 3 contracts in case Mean Reversing Strategies were used in the future
    #

    contract_1 = Contract()
    contract_1.symbol = tickers[0]
    contract_1.secType = "STK"
    contract_1.currency = "USD"
    contract_1.exchange = "SMART"
    contract_1.primaryExchange = "ISLAND"

    contract_2 = Contract()
    if len(tickers) > 1:
        contract_2.symbol = tickers[1]
    contract_2.secType = "STK"
    contract_2.currency = "USD"
    contract_2.exchange = "SMART"
    contract_2.primaryExchange = "ISLAND"

    contract_3 = Contract()
    if len(tickers) > 2:
        contract_3.symbol = tickers[2]
    contract_3.secType = "STK"
    contract_3.currency = "USD"
    contract_3.exchange = "SMART"
    contract_3.primaryExchange = "ISLAND"

    contract = [contract_1, contract_2, contract_3]

    #
    # Defining the Conection to TWS ######################################################
    #
    current_directory = os.getcwd()
    app = conexion(tickers=tickers,
                   port=7497,
                   cliente=cliente,
                   currentDir=current_directory)  # devuelto en: currentTime
    #
    #   Checking open positions on the market ############################################
    #
    app.reqAccountUpdates(True, "DU931045")

    tiempo = datetime.now()
    continua = False
    while not continua:
        open_position = app.open_position
        if open_position[0] != None or datetime.now() > tiempo + timedelta(
                seconds=3):
            continua = True
        time.sleep(0.5)
    if open_position[0] == tickers[0]:
        print(" *******************************************************")
        print("")
        print(" There is an open possition for %s, please check in the " %
              tickers[0])
        print(" market whether it is convenient to proced automatically")
        print("")
        print(" *******************************************************")

    app.reqAccountUpdates(False, "DU931045")

    #
    # Requesting real time data from the Market ##########################################
    #
    reqId = [None for i in range(len(tickers))]
    for i in range(len(tickers)):
        reqId[i] = app.nuevoId()
        app.reqMarketDataType(1)
        app.reqMktData(reqId[i],
                       contract[i],
                       genericTickList='',
                       snapshot=False,
                       regulatorySnapshot=False,
                       mktDataOptions=[])
        print("request Id: ", reqId[i])

#
# Defining modules ###################################################################
#

    price_handler = IBAPI_yoe(events_queue,
                              init_tickers=tickers,
                              app=app,
                              reqId=reqId)

    #    start_date = datetime.datetime(2015, 1, 1)
    #    end_date = datetime.datetime(2016, 9, 30)
    #    price_handler = IQFeedIntradayCsvBarPriceHandler(
    #        csv_dir, events_queue, tickers, start_date=start_date
    #    )
    contract_dict = {
        contract_1.symbol: contract_1,
        contract_2.symbol: contract_2,
        contract_3.symbol: contract_3
    }

    LiveCompl = LiveCompliance(config, tickers)

    # Use the ML Intraday Prediction Strategy

    model_pickle_file = current_directory + "/" + tickers[0] + "_Full_time.pkl"
    strategy = IntradayMachineLearningPredictionStrategy(
        tickers, events_queue, model_pickle_file, strat_set, open_position)

    execution_handler = IB_execution_yoe(events_queue,
                                         price_handler,
                                         compliance=LiveCompl,
                                         app=app,
                                         contract_dict=contract_dict,
                                         currentDir=current_directory,
                                         Id=reqId,
                                         strategy=strategy)

    # Use the Naive Position Sizer where
    # suggested quantities are followed
    position_sizer = NaivePositionSizer()

    # Use an example Risk Manager
    risk_manager = ExampleRiskManager()

    # Use the default Portfolio Handler
    portfolio_handler = PortfolioHandler(PriceParser.parse(initial_equity),
                                         events_queue, price_handler,
                                         position_sizer, risk_manager)

    title = [tickers[0] + "Machine Learning_Long_lags3"]
    # Use the Tearsheet Statistics
    statistics = TearsheetStatistics(
        config,
        portfolio_handler,
        title=title,
        periods=int(252 * 6.5 * 60)  # Minutely periods
    )

    # Set up the backtest

    backtest = TradingSession(config,
                              strategy,
                              tickers,
                              initial_equity,
                              start_date,
                              end_date,
                              events_queue,
                              session_type="live",
                              end_session_time=end_session_time,
                              price_handler=price_handler,
                              portfolio_handler=portfolio_handler,
                              compliance=None,
                              position_sizer=position_sizer,
                              execution_handler=execution_handler,
                              risk_manager=None,
                              statistics=statistics,
                              sentiment_handler=None,
                              title=None,
                              benchmark=None)
    results = backtest.start_trading(testing=testing)

    return results
    for i in range(len(tickers)):
        app.cancelMktData(i)
        app.disconnect()
    app.f.close()
コード例 #18
0
def run(config, testing, tickers, csv_filepath, pklfile, start_date, end_date,
        lags, title, folder_name, model, return_win, percent_factor, salida):
    # Set up variables needed for backtest
    #    title = [
    #        "Intraday AREX Machine Learning Prediction Strategy"
    #    ]
    events_queue = queue.Queue()
    csv_dir = csv_filepath
    initial_equity = 30000.0

    # Use DTN IQFeed Intraday Bar Price Handler
    #    start_date = datetime.datetime(2016, 1, 1)
    #    end_date = datetime.datetime(2014, 3, 11)

    #    start_date = datetime.datetime(2013, 1, 1)
    #    end_date = datetime.datetime(2014, 3, 11)
    price_handler = IQFeedIntradayCsvBarPriceHandler(csv_dir, events_queue,
                                                     tickers, start_date,
                                                     end_date)

    # Use the ML Intraday Prediction Strategy
    model_pickle_file = pklfile
    strategy = IntradayMachineLearningPredictionStrategy(
        tickers, events_queue, model_pickle_file, lags, model, return_win,
        percent_factor, salida)

    # Use the Naive Position Sizer where
    # suggested quantities are followed
    position_sizer = NaivePositionSizer()

    # Use an example Risk Manager
    risk_manager = ExampleRiskManager()

    # Use the default Portfolio Handler
    portfolio_handler = PortfolioHandler(PriceParser.parse(initial_equity),
                                         events_queue, price_handler,
                                         position_sizer, risk_manager)

    # Use the Tearsheet Statistics
    statistics = TearsheetStatistics(
        config,
        portfolio_handler,
        title=title,
        periods=int(252 * 6.5 * 60)  # Minutely periods
    )

    # Set up the backtest

    compliance = LiveCompliance(config, tickers)

    execution_handler = IBSimulatedExecutionHandler(
        events_queue=events_queue,
        price_handler=price_handler,
        compliance=compliance)

    backtest = TradingSession(config,
                              strategy,
                              tickers,
                              initial_equity,
                              start_date,
                              end_date,
                              events_queue,
                              title=title,
                              portfolio_handler=portfolio_handler,
                              compliance=compliance,
                              position_sizer=position_sizer,
                              execution_handler=execution_handler,
                              price_handler=price_handler,
                              statistics=statistics)
    results = backtest.start_trading(testing=testing, folder_name=folder_name)
    return results