def _calculation_of_raw_instrument_weights(system, NotUsed1, this_stage,
weighting_func, **weighting_params):
print(__file__ + ":" + str(inspect.getframeinfo(inspect.currentframe())[:3][1]) + ":" +"Calculating raw instrument weights")
instrument_codes=system.get_instrument_list()
weight_func=weighting_func(log=this_stage.log.setup(call="weighting"), **weighting_params)
if weight_func.need_data():
if hasattr(system, "accounts"):
pandl=this_stage.pandl_across_subsystems()
(pandl_gross, pandl_costs) = decompose_group_pandl([pandl])
weight_func.set_up_data(data_gross = pandl_gross, data_costs = pandl_costs)
else:
error_msg="You need an accounts stage in the system to estimate instrument weights"
this_stage.log.critical(error_msg)
else:
## equal weights doesn't need data
positions=this_stage._get_all_subsystem_positions()
weight_func.set_up_data(weight_matrix=positions)
SR_cost_list = [this_stage.get_instrument_subsystem_SR_cost(instr_code) for instr_code in instrument_codes]
weight_func.optimise(ann_SR_costs=SR_cost_list)
return weight_func
def _calculation_of_raw_forecast_weights(system, instrument_code, this_stage,
codes_to_use, weighting_func, pool_costs=False, **weighting_params):
this_stage.log.terse("Calculating raw forecast weights over %s" % ", ".join(codes_to_use))
if hasattr(system, "accounts"):
## returns a list of accountCurveGroups
pandl_forecasts=[this_stage.pandl_for_instrument_rules_unweighted(code)
for code in codes_to_use]
## the current curve is special
pandl_forecasts_this_code=this_stage.pandl_for_instrument_rules_unweighted(instrument_code)
## have to decode these
## returns two lists of pd.DataFrames
(pandl_forecasts_gross, pandl_forecasts_costs) = decompose_group_pandl(pandl_forecasts, pandl_forecasts_this_code, pool_costs=pool_costs)
else:
error_msg="You need an accounts stage in the system to estimate forecast weights"
this_stage.log.critical(error_msg)
## The weighting function requires two lists of pd.DataFrames, one gross, one for costs
output=weighting_func(pandl_forecasts_gross, pandl_forecasts_costs,
log=self.log.setup(call="weighting"), **weighting_params)
return output
def _calculation_of_raw_instrument_weights(system, NotUsed1, this_stage,
weighting_func, **weighting_params):
this_stage.log.terse("Calculating raw instrument weights")
instrument_codes=system.get_instrument_list()
weight_func=weighting_func(log=this_stage.log.setup(call="weighting"), **weighting_params)
if weight_func.need_data():
if hasattr(system, "accounts"):
pandl=this_stage.pandl_across_subsystems()
(pandl_gross, pandl_costs) = decompose_group_pandl([pandl])
weight_func.set_up_data(data_gross = pandl_gross, data_costs = pandl_costs)
else:
error_msg="You need an accounts stage in the system to estimate instrument weights"
this_stage.log.critical(error_msg)
else:
## equal weights doesn't need data
positions=this_stage._get_all_subsystem_positions()
weight_func.set_up_data(weight_matrix=positions)
SR_cost_list = [this_stage.get_instrument_subsystem_SR_cost(instr_code) for instr_code in instrument_codes]
weight_func.optimise(ann_SR_costs=SR_cost_list)
return weight_func
def _calculation_of_raw_forecast_weights(system, instrument_code,
this_stage, codes_to_use,
weighting_func, pool_costs,
**weighting_params):
this_stage.log.terse(
"Calculating raw forecast weights for %s, over %s" %
(instrument_code, ", ".join(codes_to_use)))
rule_list = self.apply_cost_weighting(instrument_code)
weight_func = weighting_func(log=self.log.setup(call="weighting"),
**weighting_params)
if weight_func.need_data():
# returns a list of accountCurveGroups
pandl_forecasts = [
this_stage.get_returns_for_optimisation(code)
for code in codes_to_use
]
# the current curve is special
pandl_forecasts_this_code = this_stage.get_returns_for_optimisation(
instrument_code)
# have to decode these
# returns two lists of pd.DataFrames
(pandl_forecasts_gross,
pandl_forecasts_costs) = decompose_group_pandl(
pandl_forecasts,
pandl_forecasts_this_code,
pool_costs=pool_costs)
# The weighting function requires two lists of pd.DataFrames,
# one gross, one for costs
weight_func.set_up_data(data_gross=pandl_forecasts_gross,
data_costs=pandl_forecasts_costs)
else:
# in the case of equal weights, don't need data
forecasts = this_stage.get_all_forecasts(
instrument_code, rule_list)
weight_func.set_up_data(weight_matrix=forecasts)
SR_cost_list = [
this_stage.get_SR_cost_for_instrument_forecast(
instrument_code, rule_variation_name)
for rule_variation_name in rule_list
]
weight_func.optimise(ann_SR_costs=SR_cost_list)
return weight_func
def _calculation_of_fully_pooled_raw_forecast_weights(self, codes_to_use):
"""
Estimate forecast weights for several instruments, using returns that are pooled
(both costs and gross returns)
:param codes_to_use: list of instrument_code
:returns: TxK pd.DataFrame containing weights, columns are trading rule variation names, T covers all
"""
# Get some useful stuff from the config
weighting_params = copy(self.parent.config.forecast_weight_estimate)
# which function to use for calculation
weighting_func = resolve_function(weighting_params.pop("func"))
instrument_code_ref = "_".join(codes_to_use)
self.log.terse(
"Calculating pooled raw forecast weights over instruments: %s" %
instrument_code_ref)
# an example of a weighting function is syscore.optimisation.GenericOptimiser
# FIXME: change the way log is passed to a 'parent' style
weight_func = weighting_func(
log=self.log.setup(
call="weighting"),
**weighting_params)
# returns a list of accountCurveGroups
# cost pooling will already have been applied - huh?
pandl_forecasts = [self.get_returns_for_optimisation(code)
for code in codes_to_use]
# have to split these into gross and net costs
# returns two lists of pd.DataFrames
# FIXME: WHY do this? Instead get the optimiser to do it??
(pandl_forecasts_gross, pandl_forecasts_costs) = decompose_group_pandl(
pandl_forecasts, pool_costs=True)
# The weighting function requires two lists of pd.DataFrames,
# one gross, one for costs
weight_func.set_up_data(
data_gross=pandl_forecasts_gross,
data_costs=pandl_forecasts_costs)
weight_func.optimise()
return weight_func
def _calculation_of_pooled_raw_forecast_weights(
system, instrument_code_ref, this_stage, codes_to_use,
weighting_func, **weighting_params):
print(
__file__ + ":" +
str(inspect.getframeinfo(inspect.currentframe())[:3][1]) +
":" +
"Calculating pooled raw forecast weights over instruments: %s"
% instrument_code_ref)
rule_list = self.apply_cost_weighting(instrument_code)
weight_func = weighting_func(log=self.log.setup(call="weighting"),
**weighting_params)
if weight_func.need_data():
## returns a list of accountCurveGroups
## cost pooling will already have been applied
pandl_forecasts = [
this_stage.get_returns_for_optimisation(code)
for code in codes_to_use
]
## have to decode these
## returns two lists of pd.DataFrames
(pandl_forecasts_gross,
pandl_forecasts_costs) = decompose_group_pandl(
pandl_forecasts, pool_costs=True)
## The weighting function requires two lists of pd.DataFrames, one gross, one for costs
weight_func.set_up_data(data_gross=pandl_forecasts_gross,
data_costs=pandl_forecasts_costs)
else:
## in the case of equal weights, don't need data
forecasts = this_stage.get_all_forecasts(
instrument_code, rule_list)
weight_func.set_up_data(weight_matrix=forecasts)
SR_cost_list = [
this_stage.get_SR_cost_for_instrument_forecast(
instrument_code, rule_variation_name)
for rule_variation_name in rule_list
]
weight_func.optimise(ann_SR_costs=SR_cost_list)
return weight_func
def _calculation_of_raw_forecast_weights(system, instrument_code, this_stage,
codes_to_use, weighting_func, pool_costs, **weighting_params):
this_stage.log.terse(
"Calculating raw forecast weights for %s, over %s" %
(instrument_code, ", ".join(codes_to_use)))
rule_list = self.apply_cost_weighting(instrument_code)
weight_func = weighting_func(
log=self.log.setup(
call="weighting"),
**weighting_params)
if weight_func.need_data():
# returns a list of accountCurveGroups
pandl_forecasts = [this_stage.get_returns_for_optimisation(code)
for code in codes_to_use]
# the current curve is special
pandl_forecasts_this_code = this_stage.get_returns_for_optimisation(
instrument_code)
# have to decode these
# returns two lists of pd.DataFrames
(pandl_forecasts_gross, pandl_forecasts_costs) = decompose_group_pandl(
pandl_forecasts, pandl_forecasts_this_code, pool_costs=pool_costs)
# The weighting function requires two lists of pd.DataFrames,
# one gross, one for costs
weight_func.set_up_data(
data_gross=pandl_forecasts_gross,
data_costs=pandl_forecasts_costs)
else:
# in the case of equal weights, don't need data
forecasts = this_stage.get_all_forecasts(
instrument_code, rule_list)
weight_func.set_up_data(weight_matrix=forecasts)
SR_cost_list = [this_stage.get_SR_cost_for_instrument_forecast(instrument_code, rule_variation_name)
for rule_variation_name in rule_list]
weight_func.optimise(ann_SR_costs=SR_cost_list)
return weight_func
def _calculation_of_raw_instrument_weights(system, NotUsed1, this_stage,
weighting_func, **weighting_params):
this_stage.log.terse("Calculating raw instrument weights")
instrument_codes=system.get_instrument_list()
if hasattr(system, "accounts"):
pandl=this_stage.pandl_across_subsystems()
else:
error_msg="You need an accounts stage in the system to estimate instrument weights"
this_stage.log.critical(error_msg)
(pandl_gross, pandl_costs) = decompose_group_pandl([pandl])
instrument_weight_results=weighting_func(pandl_gross, pandl_costs, log=self.log.setup(call="weighting"), **weighting_params)
return instrument_weight_results
def _calculation_of_pooled_raw_forecast_weights(system, instrument_code_ref, this_stage,
codes_to_use, weighting_func, **weighting_params):
this_stage.log.terse(
"Calculating pooled raw forecast weights over instruments: %s" %
instrument_code_ref)
rule_list = self.apply_cost_weighting(instrument_code)
weight_func = weighting_func(
log=self.log.setup(
call="weighting"),
**weighting_params)
if weight_func.need_data():
# returns a list of accountCurveGroups
# cost pooling will already have been applied
pandl_forecasts = [this_stage.get_returns_for_optimisation(code)
for code in codes_to_use]
# have to decode these
# returns two lists of pd.DataFrames
(pandl_forecasts_gross, pandl_forecasts_costs) = decompose_group_pandl(
pandl_forecasts, pool_costs=True)
# The weighting function requires two lists of pd.DataFrames,
# one gross, one for costs
weight_func.set_up_data(
data_gross=pandl_forecasts_gross,
data_costs=pandl_forecasts_costs)
else:
# in the case of equal weights, don't need data
forecasts = this_stage.get_all_forecasts(
instrument_code, rule_list)
weight_func.set_up_data(weight_matrix=forecasts)
SR_cost_list = [this_stage.get_SR_cost_for_instrument_forecast(instrument_code, rule_variation_name)
for rule_variation_name in rule_list]
weight_func.optimise(ann_SR_costs=SR_cost_list)
return weight_func
def calculation_of_raw_instrument_weights(self):
"""
Estimate the instrument weights
Done like this to expose calculations
:returns: TxK pd.DataFrame containing weights, columns are instrument names, T covers all
"""
# Get some useful stuff from the config
weighting_params = copy(self.parent.config.instrument_weight_estimate)
# which function to use for calculation
weighting_func = resolve_function(weighting_params.pop("func"))
system = self.parent
self.log.terse("Calculating raw instrument weights")
instrument_codes = system.get_instrument_list()
weight_func = weighting_func(log=self.log.setup(call="weighting"),
**weighting_params)
if hasattr(system, "accounts"):
pandl = self.pandl_across_subsystems()
(pandl_gross, pandl_costs) = decompose_group_pandl([pandl])
weight_func.set_up_data(data_gross=pandl_gross,
data_costs=pandl_costs)
else:
error_msg = "You need an accounts stage in the system to estimate instrument weights"
self.log.critical(error_msg)
SR_cost_list = [
self.get_instrument_subsystem_SR_cost(instr_code)
for instr_code in instrument_codes
]
weight_func.optimise()
return weight_func
def _calculation_of_raw_forecast_weights(system,
instrument_code,
this_stage,
codes_to_use,
weighting_func,
pool_costs=False,
**weighting_params):
this_stage.log.terse("Calculating raw forecast weights over %s" %
", ".join(codes_to_use))
if hasattr(system, "accounts"):
## returns a list of accountCurveGroups
pandl_forecasts = [
this_stage.pandl_for_instrument_rules_unweighted(code)
for code in codes_to_use
]
## the current curve is special
pandl_forecasts_this_code = this_stage.pandl_for_instrument_rules_unweighted(
instrument_code)
## have to decode these
## returns two lists of pd.DataFrames
(pandl_forecasts_gross,
pandl_forecasts_costs) = decompose_group_pandl(
pandl_forecasts,
pandl_forecasts_this_code,
pool_costs=pool_costs)
else:
error_msg = "You need an accounts stage in the system to estimate forecast weights"
this_stage.log.critical(error_msg)
## The weighting function requires two lists of pd.DataFrames, one gross, one for costs
output = weighting_func(pandl_forecasts_gross,
pandl_forecasts_costs,
log=self.log.setup(call="weighting"),
**weighting_params)
return output
def _calculation_of_raw_instrument_weights(system, NotUsed1,
this_stage, weighting_func,
**weighting_params):
this_stage.log.terse("Calculating raw instrument weights")
instrument_codes = system.get_instrument_list()
if hasattr(system, "accounts"):
pandl = this_stage.pandl_across_subsystems()
else:
error_msg = "You need an accounts stage in the system to estimate instrument weights"
this_stage.log.critical(error_msg)
(pandl_gross, pandl_costs) = decompose_group_pandl([pandl])
instrument_weight_results = weighting_func(
pandl_gross,
pandl_costs,
log=self.log.setup(call="weighting"),
**weighting_params)
return instrument_weight_results
def _calculation_of_raw_forecast_weights_for_instrument(
self, instrument_code):
"""
Does an optimisation for a single instrument
We do this if we can't do the special case of a fully pooled optimisation (both costs and returns pooled)
Estimate the forecast weights for this instrument
We store this intermediate step to expose the calculation object
:param instrument_code:
:type str:
:returns: TxK pd.DataFrame containing weights, columns are trading rule variation names, T covers all
"""
# usual pool fix
# Get some useful stuff from the config
weighting_params = copy(self.parent.config.forecast_weight_estimate)
# do we pool our estimation? (note if both are pooled would better calling the function for full pooling
# eithier gross returns or costs can be pooled
pooling_returns = str2Bool(
self.parent.config.forecast_weight_estimate["pool_gross_returns"])
pool_costs = str2Bool(
self.parent.config.forecast_cost_estimates["use_pooled_costs"])
# which function to use for calculation
weighting_func = resolve_function(weighting_params.pop("func"))
# FIXME: Returns and costs are pooled in different places, very confusing
if pooling_returns:
# find set of instruments with same trading rules as I have
codes_to_use = self.has_same_cheap_rules_as_code(instrument_code)
else:
codes_to_use = [instrument_code]
self.log.terse(
"Calculating raw forecast weights for %s, over %s" %
(instrument_code, ", ".join(codes_to_use)))
rule_list = self.check_for_cheap_enough_rules(instrument_code)
# FIXME: change the way log is passed to a 'parent' style
weight_func = weighting_func(
log=self.log.setup(
call="weighting"),
**weighting_params)
# returns a list of accountCurveGroups
pandl_forecasts = [self.get_returns_for_optimisation(code)
for code in codes_to_use]
# the current curve is special
# FIXME couldn't the optimiser do this?:
pandl_forecasts_this_code = self.get_returns_for_optimisation(
instrument_code)
# have to decode these
# returns two lists of pd.DataFrames
# FIXME: WHY do this? Instead get the optimiser to do it??
(pandl_forecasts_gross, pandl_forecasts_costs) = decompose_group_pandl(
pandl_forecasts, pandl_forecasts_this_code, pool_costs=pool_costs)
# The weighting function requires two lists of pd.DataFrames,
# one gross, one for costs
weight_func.set_up_data(
data_gross=pandl_forecasts_gross,
data_costs=pandl_forecasts_costs)
weight_func.optimise()
return weight_func
