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_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(),