def futures_system(sim_data=arg_not_supplied,
config_filename="systems.provided.rob_system.config.yaml"):
if sim_data is arg_not_supplied:
sim_data = dbFuturesSimData()
config = Config(config_filename)
system = System(
[
Risk(),
accountForOptimisedStage(),
optimisedPositions(),
Portfolios(),
PositionSizing(),
myFuturesRawData(),
ForecastCombine(),
volAttenForecastScaleCap(),
Rules(),
],
sim_data,
config,
)
system.set_logging_level("on")
return system
def test_simple_system_config_import(self, data):
my_config = Config("systems.provided.example.simplesystemconfig.yaml")
my_config.risk_overlay = arg_not_supplied
my_config.exclude_instrument_lists = dict(
ignore_instruments=["MILK"],
trading_restrictions=["BUTTER"],
bad_markets=["CHEESE"],
)
print(my_config)
my_system = System(
[
Account(),
Portfolios(),
PositionSizing(),
ForecastCombine(),
ForecastScaleCap(),
Rules(),
RawData(),
],
data,
my_config,
)
print(my_system.rules.get_raw_forecast("EDOLLAR", "ewmac32").tail(5))
print(my_system.rules.get_raw_forecast("EDOLLAR", "ewmac8").tail(5))
print(
my_system.forecastScaleCap.get_capped_forecast("EDOLLAR", "ewmac32").tail(5)
)
print(my_system.forecastScaleCap.get_forecast_scalar("EDOLLAR", "ewmac32"))
print(my_system.combForecast.get_combined_forecast("EDOLLAR").tail(5))
print(my_system.combForecast.get_forecast_weights("EDOLLAR").tail(5))
print(my_system.positionSize.get_subsystem_position("EDOLLAR").tail(5))
print(my_system.portfolio.get_notional_position("EDOLLAR").tail(5))
def simplesystem(data=None, config=None, log_level="on"):
"""
Example of how to 'wrap' a complete system
"""
if config is None:
config = Config("systems.provided.example.simplesystemconfig.yaml")
if data is None:
data = csvFuturesSimData()
my_system = System(
[
Account(),
Portfolios(),
PositionSizing(),
ForecastCombine(),
ForecastScaleCap(),
Rules(),
],
data,
config,
)
my_system.set_logging_level(log_level)
return my_system
def random_system_for_regression(config, rules, log_level="on"):
my_system = System([Account(), PortfoliosFixed(), PositionSizing(), ForecastCombineEstimated(), ForecastScaleCapEstimated(), rules,
RawData()], csvFuturesData(), config)
my_system.set_logging_level(log_level)
return my_system
def futures_system(data=None, config=None, trading_rules=None, log_level="on"):
"""
:param data: data object (defaults to reading from csv files)
:type data: sysdata.data.Data, or anything that inherits from it
:param config: Configuration object (defaults to futuresconfig.yaml in this directory)
:type config: sysdata.configdata.Config
:param trading_rules: Set of trading rules to use (defaults to set specified in config object)
:type trading_rules: list or dict of TradingRules, or something that can be parsed to that
:param log_level: How much logging to do
:type log_level: str
>>> system=futures_system(log_level="off")
>>> system
System with stages: accounts, portfolio, positionSize, rawdata, combForecast, forecastScaleCap, rules
>>> system.rules.get_raw_forecast("EDOLLAR", "ewmac2_8").dropna().head(2)
ewmac2_8
1983-10-10 0.695929
1983-10-11 -0.604704
ewmac2_8
2015-04-21 0.172416
2015-04-22 -0.477559
>>> system.rules.get_raw_forecast("EDOLLAR", "carry").dropna().head(2)
carry
1983-10-10 0.952297
1983-10-11 0.854075
carry
2015-04-21 0.350892
2015-04-22 0.350892
"""
if data is None:
data = csvFuturesData()
if config is None:
config = Config(
"systems.provided.futures_chapter15.futuresconfig.yaml")
rules = Rules(trading_rules)
system = System([
Account(),
PortfoliosFixed(),
PositionSizing(),
FuturesRawData(),
ForecastCombine(),
ForecastScaleCap(), rules
], data, config)
system.set_logging_level(log_level)
return system
def get_test_object_futures_with_pos_sizing():
"""
Returns some standard test data
"""
data = csvFuturesData("sysdata.tests")
rawdata = FuturesRawData()
rules = Rules()
config = Config("systems.provided.example.exampleconfig.yaml")
capobject = ForecastScaleCap()
combobject = ForecastCombine()
posobject = PositionSizing()
return (posobject, combobject, capobject, rules, rawdata, data, config)
def setUp(self):
(comb, fcs, rules, rawdata, data,
config) = get_test_object_futures_with_comb_forecasts()
system = System([rawdata, rules, fcs, comb,
PositionSizing()], data, config)
self.system = system
self.config = config
self.rules = rules
self.rawdata = rawdata
self.fcs = fcs
self.forecast_combine = comb
self.data = data
self.position_sizing = PositionSizing
def get_test_object_futures_with_pos_sizing():
"""
Returns some standard test data
"""
data = csvFuturesSimData(datapath_dict=dict(
config_data="sysdata.tests.configtestdata",
adjusted_prices="sysdata.tests.adjtestdata",
spot_fx_data="sysdata.tests.fxtestdata",
multiple_price_data="sysdata.tests.multiplepricestestdata"))
rawdata = FuturesRawData()
rules = Rules()
config = Config("systems.provided.example.exampleconfig.yaml")
capobject = ForecastScaleCap()
combobject = ForecastCombine()
posobject = PositionSizing()
return (posobject, combobject, capobject, rules, rawdata, data, config)
def futures_system(
data=None,
config=None,
trading_rules=None,
log_level="terse"):
"""
:param data: data object (defaults to reading from csv files)
:type data: sysdata.data.simData, or anything that inherits from it
:param config: Configuration object (defaults to futuresconfig.yaml in this directory)
:type config: sysdata.configdata.Config
:param trading_rules: Set of trading rules to use (defaults to set specified in config object)
:param trading_rules: list or dict of TradingRules, or something that can be parsed to that
:param log_level: Set of trading rules to use (defaults to set specified in config object)
:type log_level: str
"""
if data is None:
data = csvFuturesSimData()
if config is None:
config = Config(
"systems.provided.futures_chapter15.futuresestimateconfig.yaml")
rules = Rules(trading_rules)
system = System(
[
Account(),
Portfolios(),
PositionSizing(),
FuturesRawData(),
ForecastCombine(),
ForecastScaleCap(),
rules,
],
data,
config,
)
system.set_logging_level(log_level)
return system
def futures_system(data, config):
system = System(
[
Risk(),
accountForOptimisedStage(),
optimisedPositions(),
Portfolios(),
PositionSizing(),
RawData(),
ForecastCombine(),
ForecastScaleCap(),
Rules(),
],
data,
config,
)
system.set_logging_level("on")
return system
def update(self, message):
"""
Subscriber pattern main method. Will be called each time a registered
event occurs.
:param message: dict with instrument names as keys and pd.Dataframe
as values.
"""
data = self.get_data(message)
# Ib data Object. This is the Object that manage the data from ibAPI.
my_data = ib_Data(data)
# create a list with the instruments for the config object
my_config = Config("private.config.yaml") # create a config object.
my_config.instruments = my_data.get_instruments_list()
# Setting the rules.
my_rules = Rules(dict(ewmac=ewmac))
my_rules.trading_rules()
# Initializing the system with all the stages.
my_stages = [
Account(),
Portfolios(),
PositionSizing(),
ForecastCombine(),
ForecastScaleCap(), my_rules
]
my_system = System(stage_list=my_stages,
data=my_data,
config=my_config)
# Forecast for each instrument.
for i in message.keys():
print("\n{} forecast:\n".format(i))
position = my_system.portfolio.get_notional_position(i)
# Publishing forecast.
message = dict(ticker=i, forecast=int(position.iloc[-1]))
print(position.tail(5))
self.pub.dispatch(i, message)
def test_simple_system_risk_overlay(self, data, ewmac_8, ewmac_32):
my_config = Config(
dict(
trading_rules=dict(ewmac8=ewmac_8, ewmac32=ewmac_32),
instrument_weights=dict(US10=0.1, EDOLLAR=0.4, CORN=0.3, SP500=0.2),
instrument_div_multiplier=1.5,
forecast_scalars=dict(ewmac8=5.3, ewmac32=2.65),
forecast_weights=dict(ewmac8=0.5, ewmac32=0.5),
forecast_div_multiplier=1.1,
percentage_vol_target=25.00,
notional_trading_capital=500000,
base_currency="GBP",
risk_overlay=dict(
max_risk_fraction_normal_risk=1.4,
max_risk_fraction_stdev_risk=3.6,
max_risk_limit_sum_abs_risk=3.4,
max_risk_leverage=13.0,
),
exclude_instrument_lists=dict(
ignore_instruments=["MILK"],
trading_restrictions=["BUTTER"],
bad_markets=["CHEESE"],
),
)
)
print(my_config)
my_system = System(
[
Account(),
Portfolios(),
PositionSizing(),
ForecastCombine(),
ForecastScaleCap(),
Rules(),
RawData(),
],
data,
my_config,
)
print(my_system.portfolio.get_notional_position("EDOLLAR").tail(5))
import inspect
import sys; sys.path.append('../..')
import numpy as np
from systems.basesystem import System
from systems.forecast_combine import ForecastCombineEstimated
from sysdata.csvdata import csvFuturesData
from systems.futures.rawdata import FuturesRawData
from systems.forecasting import Rules
from sysdata.configdata import Config
from systems.forecast_scale_cap import ForecastScaleCapFixed, ForecastScaleCapEstimated
from systems.account import Account
data = csvFuturesData("sysdata.tests")
rawdata = FuturesRawData()
rules = Rules()
config = Config("examples.test14.yaml")
fcs = ForecastScaleCapEstimated()
accounts=Account()
from systems.portfolio import PortfoliosEstimated
from systems.positionsizing import PositionSizing
system=System([accounts, rawdata, rules, fcs, ForecastCombineEstimated(), PositionSizing(), PortfoliosEstimated()], data, config)
print (system.portfolio.get_instrument_correlation_matrix().corr_list)
#array([[ 1. , 0.87041785],
# [ 0.87041785, 1. ]])
# fixed:
my_config.forecast_weights = dict(ewmac8=0.5, ewmac32=0.5)
my_config.forecast_div_multiplier = 1.1
my_config.use_forecast_weight_estimates = False
my_config.use_forecast_div_mult_estimates = False
combiner = ForecastCombine()
my_system = System([fcs, empty_rules, combiner], data,
my_config) # no need for accounts if no estimation done
my_system.combForecast.get_combined_forecast("EDOLLAR").tail(5)
# size positions
from systems.positionsizing import PositionSizing
possizer = PositionSizing()
my_config.percentage_vol_target = 25
my_config.notional_trading_capital = 500000
my_config.base_currency = "GBP"
my_system = System([fcs, my_rules, combiner, possizer], data, my_config)
print(my_system.positionSize.get_price_volatility("EDOLLAR").tail(5))
print(my_system.positionSize.get_block_value("EDOLLAR").tail(5))
print(my_system.positionSize.get_instrument_sizing_data("EDOLLAR"))
print(my_system.positionSize.get_instrument_value_vol("EDOLLAR").tail(5))
print(my_system.positionSize.get_volatility_scalar("EDOLLAR").tail(5))
print(my_system.positionSize.get_daily_cash_vol_target())
print(my_system.positionSize.get_subsystem_position("EDOLLAR").tail(5))
# portfolio - estimated
from systems.forecasting import Rules
from systems.forecasting import TradingRule
from systems.portfolio import PortfoliosEstimated
from systems.positionsizing import PositionSizing
data = csvFuturesData()
my_config = Config()
my_config.instruments = ["US20", "SP500"]
ewmac_8 = TradingRule((ewmac, [], dict(Lfast=8, Lslow=32)))
ewmac_32 = TradingRule(
dict(function=ewmac, other_args=dict(Lfast=32, Lslow=128)))
my_rules = Rules(dict(ewmac8=ewmac_8, ewmac32=ewmac_32))
my_system = System([
Account(),
PortfoliosEstimated(),
PositionSizing(),
ForecastScaleCap(), my_rules,
ForecastCombine()
], data, my_config)
my_system.config.forecast_weight_estimate['method'] = "equal_weights"
my_system.config.instrument_weight_estimate['method'] = "bootstrap"
my_system.config.instrument_weight_estimate["monte_runs"] = 1
my_system.config.instrument_weight_estimate["bootstrap_length"] = 250
print(my_system.portfolio.get_instrument_weights())
print(my_system.portfolio.get_instrument_diversification_multiplier())
# 10,250 weights=0.75,0.25 idm=1.26
# 30,250 weights=0.75,0.25
# fixed:
my_config.forecast_weights = dict(ewmac8=0.5, ewmac32=0.5)
my_config.forecast_div_multiplier = 1.1
my_config.use_forecast_weight_estimates = False
my_config.use_forecast_div_mult_estimates = False
combiner = ForecastCombine()
my_system = System([fcs, empty_rules, combiner], data,
my_config) # no need for accounts if no estimation done
my_system.combForecast.get_combined_forecast("EDOLLAR").tail(5)
# size positions
from systems.positionsizing import PositionSizing
possizer = PositionSizing()
my_config.percentage_vol_target = 25
my_config.notional_trading_capital = 500000
my_config.base_currency = "GBP"
my_system = System([fcs, my_rules, combiner, possizer], data, my_config)
print(my_system.positionSize.get_price_volatility("EDOLLAR").tail(5))
print(my_system.positionSize.get_block_value("EDOLLAR").tail(5))
print(my_system.positionSize.get_instrument_sizing_data("EDOLLAR"))
print(my_system.positionSize.get_instrument_value_vol("EDOLLAR").tail(5))
print(my_system.positionSize.get_volatility_scalar("EDOLLAR").tail(5))
print(my_system.positionSize.get_daily_cash_vol_target())
print(my_system.positionSize.get_subsystem_position("EDOLLAR").tail(5))
# portfolio - estimated
def test_simple_system(self):
"""
This is (mostly) the code from 'examples.introduction.simplesystem',
but without graph plotting
"""
data = csvFuturesSimData()
my_rules = Rules(ewmac)
print(my_rules.trading_rules())
my_rules = Rules(dict(ewmac=ewmac))
print(my_rules.trading_rules())
my_system = System([my_rules], data)
print(my_system)
print(my_system.rules.get_raw_forecast("EDOLLAR", "ewmac").tail(5))
ewmac_rule = TradingRule(ewmac)
my_rules = Rules(dict(ewmac=ewmac_rule))
print(ewmac_rule)
ewmac_8 = TradingRule((ewmac, [], dict(Lfast=8, Lslow=32)))
ewmac_32 = TradingRule(
dict(function=ewmac, other_args=dict(Lfast=32, Lslow=128)))
my_rules = Rules(dict(ewmac8=ewmac_8, ewmac32=ewmac_32))
print(my_rules.trading_rules()["ewmac32"])
my_system = System([my_rules], data)
my_system.rules.get_raw_forecast("EDOLLAR", "ewmac32").tail(5)
my_config = Config()
print(my_config)
empty_rules = Rules()
my_config.trading_rules = dict(ewmac8=ewmac_8, ewmac32=ewmac_32)
my_system = System([empty_rules], data, my_config)
my_system.rules.get_raw_forecast("EDOLLAR", "ewmac32").tail(5)
# we can estimate these ourselves
my_config.instruments = ["US10", "EDOLLAR", "CORN", "SP500"]
my_config.use_forecast_scale_estimates = True
fcs = ForecastScaleCap()
my_system = System([fcs, my_rules], data, my_config)
my_config.forecast_scalar_estimate["pool_instruments"] = False
print(
my_system.forecastScaleCap.get_forecast_scalar(
"EDOLLAR", "ewmac32").tail(5))
# or we can use the values from the book
my_config.forecast_scalars = dict(ewmac8=5.3, ewmac32=2.65)
my_config.use_forecast_scale_estimates = False
fcs = ForecastScaleCap()
my_system = System([fcs, my_rules], data, my_config)
print(
my_system.forecastScaleCap.get_capped_forecast(
"EDOLLAR", "ewmac32").tail(5))
# defaults
combiner = ForecastCombine()
my_system = System([fcs, my_rules, combiner], data, my_config)
print(my_system.combForecast.get_forecast_weights("EDOLLAR").tail(5))
print(
my_system.combForecast.get_forecast_diversification_multiplier(
"EDOLLAR").tail(5))
# estimates:
my_account = Account()
combiner = ForecastCombine()
my_config.forecast_weight_estimate = dict(method="one_period")
my_config.use_forecast_weight_estimates = True
my_config.use_forecast_div_mult_estimates = True
my_system = System([my_account, fcs, my_rules, combiner], data,
my_config)
# this is a bit slow, better to know what's going on
my_system.set_logging_level("on")
print(my_system.combForecast.get_forecast_weights("US10").tail(5))
print(
my_system.combForecast.get_forecast_diversification_multiplier(
"US10").tail(5))
# fixed:
my_config.forecast_weights = dict(ewmac8=0.5, ewmac32=0.5)
my_config.forecast_div_multiplier = 1.1
my_config.use_forecast_weight_estimates = False
my_config.use_forecast_div_mult_estimates = False
combiner = ForecastCombine()
my_system = System(
[fcs, empty_rules, combiner], data,
my_config) # no need for accounts if no estimation done
my_system.combForecast.get_combined_forecast("EDOLLAR").tail(5)
# size positions
possizer = PositionSizing()
my_config.percentage_vol_target = 25
my_config.notional_trading_capital = 500000
my_config.base_currency = "GBP"
my_system = System([fcs, my_rules, combiner, possizer], data,
my_config)
print(my_system.positionSize.get_price_volatility("EDOLLAR").tail(5))
print(my_system.positionSize.get_block_value("EDOLLAR").tail(5))
print(my_system.positionSize.get_underlying_price("EDOLLAR"))
print(
my_system.positionSize.get_instrument_value_vol("EDOLLAR").tail(5))
print(my_system.positionSize.get_volatility_scalar("EDOLLAR").tail(5))
print(my_system.positionSize.get_vol_target_dict())
print(my_system.positionSize.get_subsystem_position("EDOLLAR").tail(5))
# portfolio - estimated
portfolio = Portfolios()
my_config.use_instrument_weight_estimates = True
my_config.use_instrument_div_mult_estimates = True
my_config.instrument_weight_estimate = dict(method="shrinkage",
date_method="in_sample")
my_system = System(
[my_account, fcs, my_rules, combiner, possizer, portfolio], data,
my_config)
my_system.set_logging_level("on")
print(my_system.portfolio.get_instrument_weights().tail(5))
print(my_system.portfolio.get_instrument_diversification_multiplier().
tail(5))
# or fixed
portfolio = Portfolios()
my_config.use_instrument_weight_estimates = False
my_config.use_instrument_div_mult_estimates = False
my_config.instrument_weights = dict(US10=0.1,
EDOLLAR=0.4,
CORN=0.3,
SP500=0.2)
my_config.instrument_div_multiplier = 1.5
my_system = System([fcs, my_rules, combiner, possizer, portfolio],
data, my_config)
print(my_system.portfolio.get_notional_position("EDOLLAR").tail(5))
my_system = System(
[fcs, my_rules, combiner, possizer, portfolio, my_account], data,
my_config)
profits = my_system.accounts.portfolio()
print(profits.percent().stats())
# have costs data now
print(profits.gross.percent().stats())
print(profits.net.percent().stats())
my_config = Config(
dict(trading_rules=dict(ewmac8=ewmac_8, ewmac32=ewmac_32),
instrument_weights=dict(US10=0.1,
EDOLLAR=0.4,
CORN=0.3,
SP500=0.2),
instrument_div_multiplier=1.5,
forecast_scalars=dict(ewmac8=5.3, ewmac32=2.65),
forecast_weights=dict(ewmac8=0.5, ewmac32=0.5),
forecast_div_multiplier=1.1,
percentage_vol_target=25.00,
notional_trading_capital=500000,
base_currency="GBP"))
print(my_config)
my_system = System(
[
Account(),
Portfolios(),
PositionSizing(),
ForecastCombine(),
ForecastScaleCap(),
Rules()
],
data,
my_config,
)
print(my_system.portfolio.get_notional_position("EDOLLAR").tail(5))
my_config = Config("systems.provided.example.simplesystemconfig.yaml")
print(my_config)
my_system = System(
[
Account(),
Portfolios(),
PositionSizing(),
ForecastCombine(),
ForecastScaleCap(),
Rules()
],
data,
my_config,
)
print(my_system.rules.get_raw_forecast("EDOLLAR", "ewmac32").tail(5))
print(my_system.rules.get_raw_forecast("EDOLLAR", "ewmac8").tail(5))
print(
my_system.forecastScaleCap.get_capped_forecast(
"EDOLLAR", "ewmac32").tail(5))
print(
my_system.forecastScaleCap.get_forecast_scalar(
"EDOLLAR", "ewmac32"))
print(my_system.combForecast.get_combined_forecast("EDOLLAR").tail(5))
print(my_system.combForecast.get_forecast_weights("EDOLLAR").tail(5))
print(my_system.positionSize.get_subsystem_position("EDOLLAR").tail(5))
print(my_system.portfolio.get_notional_position("EDOLLAR").tail(5))
def possizer():
return PositionSizing()
subsys_positions = pd.concat(subsys_positions, axis=1).ffill()
subsys_positions.columns = instrument_list
instrument_weights = fix_weights_vs_pdm(raw_instr_weights, subsys_positions)
weighting=system.config.instrument_weight_ewma_span
instrument_weights = pd.ewma(instrument_weights, weighting)
return instrument_weights
if __name__ == "__main__":
random.seed(0)
np.random.seed(0)
data = csvFuturesData()
my_config = Config()
my_config.instruments=["US20", "SP500"]
ewmac_8 = TradingRule((ewmac, [], dict(Lfast=8, Lslow=32)))
ewmac_32 = TradingRule(dict(function=ewmac, other_args=dict(Lfast=32, Lslow=128)))
my_rules = Rules(dict(ewmac8=ewmac_8, ewmac32=ewmac_32))
my_system = System([Account(), PortfoliosEstimated(), PositionSizing(), ForecastScaleCap(), my_rules, ForecastCombine()], data, my_config)
my_system.config.forecast_weight_estimate['method']="equal_weights"
my_system.config.instrument_weight_estimate['method']="bootstrap"
my_system.config.instrument_weight_estimate["monte_runs"]=1
my_system.config.instrument_weight_estimate["bootstrap_length"]=250
print(my_system.portfolio.get_instrument_diversification_multiplier(my_system))
# 10,250 weights=0.75,0.25 idm=1.26
# 30,250 weights=0.75,0.25
data = csvFuturesSimData()
system = System([
Account(), Portfolios(), PositionSizeWithStopLoss(), FuturesRawData(),
ForecastCombine(), ForecastScaleCap(), Rules(simple_mav_rule)
], data, config)
system.set_logging_level("on")
system_no_stop = System([
Account(), Portfolios(), PositionSizeWithConstantPosition(), FuturesRawData(),
ForecastCombine(), ForecastScaleCap(), Rules(simple_mav_rule)
], data, config)
system.set_logging_level("on")
system_no_stop_no_binary = System([
Account(), Portfolios(), PositionSizing(), FuturesRawData(),
ForecastCombine(), ForecastScaleCap(), Rules(simple_mav_rule_with_vol)
], data, config_3)
system.set_logging_level("on")
with_stop_loss = system.accounts.portfolio()
without_stop_loss = system_no_stop.accounts.portfolio()
without_stop_loss_no_binary = system_no_stop_no_binary.accounts.portfolio()
# returns
def SR_error_bars_from_values(annual_SR, len_data):
daily_SR = annual_SR/16
var_of_SR_estimator_daily = (1+0.5*(daily_SR**2))/len_data
