Setting up a DO system

[j1404]

So far I've managed to get data for 140 instruments and used provided rob_system to get optimal positions. Now I'm trying to set up same thing as a system for production. I'm having trouble in understanding how everything fits together, namely stuff in systems/provided/rob_system and sysproduction/strategy_code/.

For the one time runs I've used systems/provided/rob_system/run_system.py and systems/provided/rob_system/config.yaml, but how should this be configured as a system? Should I be referring to systems/provided/rob_system/run_system.py or sysproduction.strategy_code.run_dynamic_optimised_system.runSystemCarryTrendDynamic? As there is no system_method function in run_system.py, the following is my best guess. Is this correct configuration or have I missed something fundamental here?

private_config.yaml

strategy_list:
  rob_system:
    load_backtests:
      object: sysproduction.strategy_code.run_dynamic_optimised_system.runSystemCarryTrendDynamic
      function: system_method
    reporting_code:
      function: sysproduction.strategy_code.report_system_dynamic_optimised.report_system_dynamic

private_control_config.yaml

process_configuration_methods:
  run_systems:
    rob_system:
      max_executions: 1
      object: sysproduction.strategy_code.run_dynamic_optimised_system.runSystemCarryTrendDynamic
      backtest_config_filename: private.rob_system.config.yaml # copied from systems/provided/rob_system/
  run_strategy_order_generator:
    rob_system:
      object: sysexecution.strategies.classic_buffered_positions.orderGeneratorForBufferedPositions
      max_executions: 1

Edit: Forgot to mention that I'm assuming something is missing because strategy report gives list index out of range error.

[j1404]

I've tried the following but no success. I should have the basic stuff in place according to production and production_strategy_changes doc pages, and have updated capital etc.

Firstly I copied run_dynamic_optimised_system.py from @tgibson11 repo, which is now referring to rob_system. Then I have the following private configs:

private_config.yaml

strategy_list:
  rob_system:
    load_backtests:
      object: sysproduction.strategy_code.run_dynamic_optimised_system.runSystemCarryTrendDynamic
      function: system_method
    reporting_code:
      function: sysproduction.strategy_code.report_system_dynamic_optimised.report_system_dynamic

strategy_capital_allocation:
  function: sysproduction.strategy_code.strategy_allocation.weighted_strategy_allocation
  strategy_weights:
    rob_system: 100.0

private_control_config.yaml

  run_systems:
    rob_system:
      max_executions: 1
      object: sysproduction.strategy_code.run_dynamic_optimised_system.runSystemCarryTrendDynamic
      backtest_config_filename: private.rob_system.config.yaml
  run_strategy_order_generator:
    rob_system:
      object: sysexecution.strategies.dynamic_optimised_positions.orderGeneratorForDynamicPositions
      max_executions: 1

But still no luck, running backtest does nothing:

$ python pysystemtrade/sysproduction/update_system_backtests.py
Configuring sim logging

[frankcodespoorly]

If you're running each script manually instead of scheduling via cron using run_systems, you need to also run the update_strategy_orders script after update_system_backtests to generate positions

[oldlore]

My setup is as follows:

strategy_list:
  dynamic_system:
    load_backtests:
      object: sysproduction.strategy_code.run_dynamic_optimised_system.runSystemCarryTrendDynamic
      function: system_method
    reporting_code:
      function: sysproduction.strategy_code.report_system_dynamic_optimised.report_system_dynamic

strategy_capital_allocation:
  function: sysproduction.strategy_code.strategy_allocation.weighted_strategy_allocation
  strategy_weights:
    dynamic_system: 100.0

-------------

process_configuration_methods:
  run_systems:
    dynamic_system:  # strategy name
      max_executions: 1
      object: sysproduction.strategy_code.run_dynamic_optimised_system.runSystemCarryTrendDynamic # additional parameter
      backtest_config_filename: private.private_config.yaml #additional parameter
  run_strategy_order_generator:
    dynamic_system: # strategy_name
      object: sysexecution.strategies.dynamic_optimised_positions.orderGeneratorForDynamicPositions # additional parameter passed
      max_executions: 1

This ought to run the backtest: pysystemtrade/sysproduction/run_systems.py

After it is finished running you should run this to generate positions: pysystemtrade/sysproduction/run_strategy_order_generator.py

Then you should be able to run interactive_order_stack.py and see what orders have been generated.

[j1404]

I'm getting slowly forward and scripts from provided crontab seems to run succesfully. Now I'm scratching my head why I get different results from same backtest depending on how it is being run.

I'm using systems/provided/rob_system/config.yaml as my config. When run "manually" with systems/provided/rob_system/run_system.py, it wants to be long NIKKEI400, SP500_micro, NASDAQ_micro and DOW. But when I run it "automatically" as a system with run_dynamic_optimised_system.py from @tgibson11 repo, optimal positions are long EUROSTX and FTSETAIWAN. I'm assuming rob_system and its config are imported correctly, as log file run_systems.txt shows correct rules and weights being used.

I expected to get same results with same data and configs, but why are they different and which one should I believe?!

[robcarver17]

"But when I run it "automatically" as a system with run_dynamic_optimised_system.py from @tgibson11 repo..."

I have no idea what this means, but I would pickle each backtest and then compare the dataframes to see where any differences are.

(Note a small difference in pre DO positions could cause a bigger difference in post DO positions especially if, as it sounds, you have small capital. A first step would be to look at pre DO positions and/or positions with larger capital).

[j1404]

Let me first rephrase the "automatically" part.. To be sure, is the following correct way to run the provided rob_system? First I copied systems/provided/rob_system/ to private/. Then I've used a modified sysproduction/strategy_code/run_dynamic_optimised_system.py as follows to run the system. It has one added line to load the futures_system from private.rob_system.run_system and then the predefined system removed.

# run_dynamic_optimised_system.py

import datetime
from syscore.constants import arg_not_supplied

from sysdata.config.configdata import Config
from sysdata.data_blob import dataBlob
from sysobjects.production.optimal_positions import (
    optimalPositionWithReference,
)
from sysobjects.production.tradeable_object import instrumentStrategy

from sysproduction.data.sim_data import get_sim_data_object_for_production
from sysproduction.strategy_code.run_system_classic import (
    runSystemClassic,
)
from sysproduction.data.contracts import dataContracts
from sysproduction.data.optimal_positions import dataOptimalPositions
from sysproduction.data.backtest import store_backtest_state

from syslogging.logger import *

from systems.basesystem import System
from private.rob_system.run_system import futures_system	# addedd

class runSystemCarryTrendDynamic(runSystemClassic):

    # DO NOT CHANGE THE NAME OF THIS FUNCTION; IT IS HARDCODED INTO CONFIGURATION FILES
    # BECAUSE IT IS ALSO USED TO LOAD BACKTESTS
    def system_method(
        self,
        notional_trading_capital: float = arg_not_supplied,
        base_currency: str = arg_not_supplied,
    ) -> System:
        data = self.data
        backtest_config_filename = self.backtest_config_filename

        system = dynamic_system(
            data,
            backtest_config_filename,
            log=data.log,
            notional_trading_capital=notional_trading_capital,
            base_currency=base_currency,
        )

        return system

    @property
    def function_to_call_on_update(self):
        return updated_optimal_positions_for_dynamic_system


def dynamic_system(
    data: dataBlob,
    config_filename: str,
    log=get_logger("futures_system"),
    notional_trading_capital: float = arg_not_supplied,
    base_currency: str = arg_not_supplied,
) -> System:

    sim_data = get_sim_data_object_for_production(data)
    config = Config(config_filename)

    # Overwrite capital and base currency
    if notional_trading_capital is not arg_not_supplied:
        config.notional_trading_capital = notional_trading_capital

    if base_currency is not arg_not_supplied:
        config.base_currency = base_currency

    system = futures_system(sim_data=sim_data, config=config)
    system._log = log

    return system


# removed
#
#from systems.forecasting import Rules
#from systems.basesystem import System
#from systems.forecast_combine import ForecastCombine
#from systems.forecast_scale_cap import ForecastScaleCap
#from systems.rawdata import RawData
#from systems.positionsizing import PositionSizing
#from systems.portfolio import Portfolios
#from systems.provided.dynamic_small_system_optimise.optimised_positions_stage import (
#    optimisedPositions,
#)
#from systems.risk import Risk
#from systems.provided.dynamic_small_system_optimise.accounts_stage import (
#    accountForOptimisedStage,
#)
#
#def futures_system(data, config):
#
#    system = System(
#        [
#            Risk(),
#            accountForOptimisedStage(),
#            optimisedPositions(),
#            Portfolios(),
#            PositionSizing(),
#            RawData(),
#            ForecastCombine(),
#            ForecastScaleCap(),
#            Rules(),
#        ],
#        data,
#        config,
#    )
#
#    return system


def updated_optimal_positions_for_dynamic_system(
    data: dataBlob, strategy_name: str, system: System
):
    log = data.log

    data_optimal_positions = dataOptimalPositions(data)

    list_of_instruments = system.get_instrument_list()
    for instrument_code in list_of_instruments:
        position_entry = construct_optimal_position_entry(
            data=data,
            system=system,
            instrument_code=instrument_code,
        )
        instrument_strategy = instrumentStrategy(
            instrument_code=instrument_code, strategy_name=strategy_name
        )
        data_optimal_positions.update_optimal_position_for_instrument_strategy(
            instrument_strategy=instrument_strategy,
            raw_positions=True,
            position_entry=position_entry,
        )

        log.debug("New Optimal position %s %s" % (str(position_entry), instrument_code))


def construct_optimal_position_entry(
    data: dataBlob, system: System, instrument_code: str
) -> optimalPositionWithReference:

    diag_contracts = dataContracts(data)

    optimal_position = get_optimal_position_from_system(system, instrument_code)

    reference_price = system.rawdata.get_daily_prices(instrument_code).iloc[-1]
    reference_date = system.rawdata.get_daily_prices(instrument_code).index[-1]
    reference_contract = diag_contracts.get_priced_contract_id(instrument_code)
    position_entry = optimalPositionWithReference(
        date=datetime.datetime.now(),
        optimal_position=optimal_position,
        reference_price=reference_price,
        reference_contract=reference_contract,
        reference_date=reference_date,
    )

    return position_entry


def get_optimal_position_from_system(system: System, instrument_code: str) -> float:

    optimal_position = system.portfolio.get_notional_position(instrument_code)

    return float(optimal_position.iloc[-1])

[craigmediaservices]

Thanks everyone. This thread was very helpful.