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.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)
: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 = csvFuturesData()
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 get_test_object_futures():
"""
Returns some standard test data
"""
data = csvFuturesData("sysdata.tests")
config = Config("systems.provided.example.exampleconfig.yaml")
return (data, config)
def testCallingTradingRule(self):
# config=Config(dict(trading_rules=dict(ewmac=dict(function="systems.provided.example.rules.ewmac_forecast_with_defaults"))))
data = csvFuturesData("sysdata.tests")
rawdata = RawData()
rules = Rules()
system = System([rawdata, rules], data)
# Call with default data and config
rule = TradingRule(ewmac_forecast_with_defaults)
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.iloc[-1][0], 2.1384223788141838, 5)
# Change the data source
rule = TradingRule(("systems.provided.example.rules.ewmac_forecast_with_defaults_no_vol",
["rawdata.daily_prices", "rawdata.daily_returns_volatility"], dict()))
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.iloc[-1][0], 0.029376, 5)
rule = TradingRule(dict(function="systems.provided.example.rules.ewmac_forecast_with_defaults_no_vol",
data=["rawdata.daily_prices",
"rawdata.daily_returns_volatility"],
other_args=dict(Lfast=50, Lslow=200)))
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.iloc[-1][0], 3.84426755)
def get_test_object_futures():
"""
Returns some standard test data
"""
data = csvFuturesData("sysdata.tests")
config = Config("systems.provided.example.exampleconfig.yaml")
return ( data, config)
def testRules(self):
# config=Config(dict(trading_rules=dict(ewmac=dict(function="systems.provided.example.rules.ewmac_forecast_with_defaults"))))
data = csvFuturesData("sysdata.tests")
rules = Rules(
dict(function="systems.provided.example.rules.ewmac_forecast_with_defaults"))
system = System([rules], data)
ans = system.rules.get_raw_forecast("EDOLLAR", "rule0")
self.assertAlmostEqual(ans.iloc[-1][0], 2.1384223788141838, 5)
config = Config(dict(trading_rules=dict(ewmac=dict(
function="systems.provided.example.rules.ewmac_forecast_with_defaults"))))
rules = Rules()
system = System([rules], data, config)
ans = system.rules.get_raw_forecast("EDOLLAR", "ewmac")
self.assertAlmostEqual(ans.iloc[-1][0], 0.542369955, 5)
config = Config("systems.provided.example.exampleconfig.yaml")
rawdata = RawData()
rules = Rules()
system = System([rules, rawdata], data, config)
ans = system.rules.get_raw_forecast("EDOLLAR", "ewmac8")
self.assertAlmostEqual(ans.iloc[-1][0], 0.16438313875, 5)
def testRules(self):
# config=Config(dict(trading_rules=dict(ewmac=dict(function="systems.provided.example.rules.ewmac_forecast_with_defaults"))))
data = csvFuturesData("sysdata.tests")
rules = Rules(
dict(
function=
"systems.provided.example.rules.ewmac_forecast_with_defaults"))
system = System([rules], data)
ans = system.rules.get_raw_forecast("EDOLLAR", "rule0")
self.assertAlmostEqual(ans.tail(1).values[0], 2.1384223788141838, 5)
config = Config(
dict(trading_rules=dict(ewmac=dict(
function=
"systems.provided.example.rules.ewmac_forecast_with_defaults"))
))
rules = Rules()
system = System([rules], data, config)
ans = system.rules.get_raw_forecast("EDOLLAR", "ewmac")
self.assertAlmostEqual(ans.tail(1).values[0], 2.1384223788141838, 5)
config = Config("systems.provided.example.exampleconfig.yaml")
rawdata = RawData()
rules = Rules()
system = System([rules, rawdata], data, config)
ans = system.rules.get_raw_forecast("EDOLLAR", "ewmac8")
self.assertAlmostEqual(ans.tail(1).values[0], 0.16438313875, 5)
def testCallingTradingRule(self):
# config=Config(dict(trading_rules=dict(ewmac=dict(function="systems.provided.example.rules.ewmac_forecast_with_defaults"))))
data = csvFuturesData("sysdata.tests")
rawdata = RawData()
rules = Rules()
system = System([rawdata, rules], data)
# Call with default data and config
rule = TradingRule(ewmac_forecast_with_defaults)
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.tail(1).values[0], 2.1384223788141838, 5)
# Change the data source
rule = TradingRule((
"systems.provided.example.rules.ewmac_forecast_with_defaults_no_vol",
["rawdata.get_daily_prices",
"rawdata.daily_returns_volatility"], dict()))
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.tail(1).values[0], 0.029376, 5)
rule = TradingRule(
dict(
function=
"systems.provided.example.rules.ewmac_forecast_with_defaults_no_vol",
data=[
"rawdata.get_daily_prices",
"rawdata.daily_returns_volatility"
],
other_args=dict(Lfast=50, Lslow=200)))
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.tail(1).values[0], 3.84426755)
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_rules():
"""
Returns some standard test data
"""
data = csvFuturesData("sysdata.tests")
rawdata = FuturesRawData()
rules = Rules()
config = Config("systems.provided.example.exampleconfig.yaml")
return (rules, rawdata, data, config)
def testCarryRule(self):
data = csvFuturesData("sysdata.tests")
rawdata = FuturesRawData()
rules = Rules()
system = System([rawdata, rules], data)
rule=TradingRule(carry, ["rawdata.daily_annualised_roll", "rawdata.daily_returns_volatility"], dict(smooth_days=90))
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.iloc[-1][0], 0.411686026, 5)
def get_test_object_futures_with_rules():
"""
Returns some standard test data
"""
data = csvFuturesData("sysdata.tests")
rawdata = FuturesRawData()
rules = Rules()
config = Config("systems.provided.example.exampleconfig.yaml")
return (rules, rawdata, data, config)
def get_test_object_futures_with_rules_and_capping():
"""
Returns some standard test data
"""
data = csvFuturesData("sysdata.tests")
rawdata = FuturesRawData()
rules = Rules()
config = Config("systems.provided.example.exampleconfig.yaml")
capobject = ForecastScaleCapFixed()
return (capobject, rules, rawdata, data, config)
def get_test_object_futures_with_rules_and_capping():
"""
Returns some standard test data
"""
data = csvFuturesData("sysdata.tests")
rawdata = FuturesRawData()
rules = Rules()
config = Config("systems.provided.example.exampleconfig.yaml")
capobject = ForecastScaleCap()
return (capobject, rules, rawdata, data, config)
def testCarryRule(self):
data = csvFuturesData("sysdata.tests")
rawdata = FuturesRawData()
rules = Rules()
system = System([rawdata, rules], data)
rule = TradingRule(carry, [
"rawdata.daily_annualised_roll", "rawdata.daily_returns_volatility"
], dict(smooth_days=90))
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.iloc[-1][0], 0.411686026, 5)
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(), Portfolios(), 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 = ForecastScaleCapFixed()
combobject = ForecastCombineFixed()
posobject = PositionSizing()
return (posobject, combobject, capobject, rules, rawdata, data, config)
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 simplesystem(data=None, config=None):
"""
Example of how to 'wrap' a complete system
"""
if config is None:
config = Config("systems.provided.example.simplesystemconfig.yaml")
if data is None:
data = csvFuturesData()
my_system = System([Account(), PortfoliosFixed(), PositionSizing(), ForecastCombineFixed(), ForecastScaleCapFixed(), Rules()
], data, config)
return my_system
def testCarryRule(self):
data = csvFuturesData("sysdata.tests")
rawdata = FuturesRawData()
rules = Rules()
system = System([rawdata, rules], data)
rule = TradingRule(
carry2, [
"rawdata.daily_annualised_roll",
],
dict(smooth_days=90))
ans = rule.call(system, "EDOLLAR")
self.assertAlmostEqual(ans.tail(1).values[0], 0.37666175, 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 = csvFuturesData()
my_system = System([Account(), PortfoliosFixed(), PositionSizing(), ForecastCombineFixed(), ForecastScaleCapFixed(), Rules()
], data, config)
my_system.set_logging_level(log_level)
return my_system
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.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)
: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 = csvFuturesData()
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=None, config=None, trading_rules=None):
"""
: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)
:param trading_rules: list or dict of TradingRules, or something that can be parsed to that
>>> system=futures_system()
>>> system
System with stages: accounts, portfolio, positionSize, rawdata, combForecast, forecastScaleCap, rules
>>> system.rules.get_raw_forecast("EDOLLAR", "ewmac2_8").tail(2)
ewmac2_8
2015-04-21 0.172416
2015-04-22 -0.477559
>>> system.rules.get_raw_forecast("EDOLLAR", "carry").tail(2)
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(), ForecastCombineFixed(),
ForecastScaleCapFixed(), rules], data, config)
return system
import pandas as pd
from pprint import pprint
from matplotlib import pyplot as plt
from private.estimatedsystemavanti import futures_system
from sysdata.configdata import Config
from sysdata.csvdata import csvFuturesData
pandl_df = pd.DataFrame()
# Initializing system.
my_config = Config("private.nocarryconfig2.yaml")
data = csvFuturesData("private.noCarryData")
#This is the path to the CSV data.
system = futures_system(log_level="on", config=my_config, data=data)
# Making the backtest for the complete portfolio.
instruments = system.config.instruments
portfolio = system.accounts.portfolio()
info = {}
for item in instruments:
series = []
series.append(data.daily_prices(item))
series.append(system.accounts.get_buffered_position(item))
series.append(system.combForecast.get_combined_forecast(item))
series.append(portfolio.to_frame()[item])
series.append(portfolio.to_frame()[item].cumsum())
return combined_forecast
'''
Created on 4 Mar 2016
@author: rob
'''
from systems.provided.futures_chapter15.estimatedsystem import PortfoliosEstimated
from systems.provided.futures_chapter15.basesystem import *
from syscore.correlations import get_avg_corr
from copy import copy
import numpy as np
data=csvFuturesData()
all_instruments=data.keys()
config=Config("examples.smallaccountsize.smallaccount.yaml")
all_accounts=[]
for instrument_code in all_instruments:
config.instruments=[instrument_code]
system1 = System([Account(), PortfoliosEstimated(), PositionSizing(), FuturesRawData(), ForecastCombineFixed(),
ForecastScaleCapFixed(), Rules()], csvFuturesData(), config)
system1.set_logging_level("on")
max_position=float(system1.positionSize.get_volatility_scalar(instrument_code).mean()*2.0)
bin_count = int(number_of_runs / 50)
plt.hist(diff_dist, bin_count)
legend_string = "Mean difference %.5f" % np.mean(diff_dist)
plt.title(legend_string)
plt.show()
count_positive = len([x for x in diff_dist if x > 0.0])
count_fraction = float(count_positive) / len(diff_dist)
print("Proportion positive %.5f" % count_fraction)
# get data
vix_spot = get_vix_data()
my_data_handler = csvFuturesData()
sp500future = my_data_handler.get_raw_price("SP500")
vixfuture = my_data_handler.get_raw_price("VIX")
# we don't use this, but can check the results with it
# note this is monthly data
# You'd need to adjust 'frequency' and time_horizon appropriately
usequitylong = get_us_long_data().USA_TR
vix_spot.plot()
plt.show()
# start with unconditional plot
do_a_plot(sp500future,
"""
# Get some data
from sysdata.csvdata import csvFuturesData
""""
Let's get some data
We can get data from various places; however for now we're going to use prepackaged 'legacy' data stored
in csv files
"""
data = csvFuturesData()
print(data)
"""
We get stuff out of data with methods
"""
print(data.get_instrument_list())
print(data.get_daily_price("EDOLLAR").tail(5))
"""
data can also behave in a dict like manner (though it's not a dict)
"""
print(data['SP500'])
return combined_forecast
'''
Created on 4 Mar 2016
@author: rob
'''
from systems.provided.futures_chapter15.estimatedsystem import PortfoliosEstimated
from systems.provided.futures_chapter15.basesystem import *
from syscore.correlations import get_avg_corr
from copy import copy
import numpy as np
data = csvFuturesData()
all_instruments = data.keys()
config = Config("examples.smallaccountsize.smallaccount.yaml")
all_accounts = []
for instrument_code in all_instruments:
config.instruments = [instrument_code]
system1 = System([
Account(), PortfoliosEstimated(), PositionSizing(), FuturesRawData(),
ForecastCombineFixed(), ForecastScaleCapFixed(), Rules()
], csvFuturesData(), config)
system1.set_logging_level("on")
""" Let's recap: We got some data and created a trading rule """ from sysdata.csvdata import csvFuturesData data = csvFuturesData() from systems.provided.example.rules import ewmac_forecast_with_defaults as ewmac """ Okay, I wonder how this would work for a number of instruments? For this we need to build a system A system is made up of SystemStages - essentially stages in the process, and it needs data, and perhaps a configuration The minimum stage you would have would be Rules - which is where you put trading rules """ from systems.forecasting import Rules """ We can create rules in a number of different ways Note that to make our rule work it needs to have """ my_rules = Rules(ewmac) print(my_rules.trading_rules()) my_rules = Rules(dict(ewmac=ewmac))
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. ]])
from matplotlib.pyplot import plot, scatter
from sysdata.csvdata import csvFuturesData
import pandas as pd
import numpy as np
from scipy.stats import linregress
from syscore.algos import robust_vol_calc
from syscore.dateutils import fit_dates_object
from syscore.genutils import progressBar
code = "US10"
data_object = csvFuturesData()
prices = data_object[code]
perc = (prices - prices.shift(1)
) / data_object.get_instrument_raw_carry_data(code)['PRICE']
perc[abs(perc) > 0.03] = np.nan
def get_expost_data(perc):
fitting_dates = generate_fitting_dates(
perc, "rolling") ## only using annual dates rolling doesn't matter
expost_data = [
perc[fit_date.period_start:fit_date.period_end]
for fit_date in fitting_dates[1:]
]
return expost_data
def calc_historic_confidence(perc, function_to_use, rollperiods=250):
return combined_forecast
'''
Created on 4 Mar 2016
@author: rob
'''
from systems.provided.futures_chapter15.estimatedsystem import PortfoliosEstimated
from systems.provided.futures_chapter15.basesystem import *
from syscore.correlations import get_avg_corr
from copy import copy
import numpy as np
data = csvFuturesData()
all_instruments = data.keys()
config = Config("examples.smallaccountsize.smallaccount.yaml")
all_accounts = []
for instrument_code in all_instruments:
config.instruments = [instrument_code]
system1 = System([
Account(),
PortfoliosEstimated(),
PositionSizing(),
FuturesRawData(),
ForecastCombineFixed(),
