def f_unnormalized_inputs(gamma_risk, gamma_tcost, gamma_holding):
fx = np.empty((m, ))
results = {}
policies = {}
policies[(gamma_risk, gamma_tcost,
gamma_holding)] = cp.SinglePeriodOpt(
return_estimate, [
gamma_risk * risk_model,
gamma_tcost * optimization_tcost,
gamma_holding * optimization_hcost
], [cp.LeverageLimit(3)])
warnings.filterwarnings('ignore')
results.update(
dict(
zip(
policies.keys(),
simulator.run_multiple_backtest(
1E8 * w_b,
start_time=start_t,
end_time=end_t,
policies=policies.values(),
parallel=True))))
results_df = pd.DataFrame()
results_df[r'$\gamma^\mathrm{risk}$'] = [
el[0] for el in results.keys()
]
results_df[r'$\gamma^\mathrm{trade}$'] = [
el[1] for el in results.keys()
]
results_df[r'$\gamma^\mathrm{hold}$'] = [
'%g' % el[2] for el in results.keys()
]
results_df['Return'] = [
results[k].excess_returns for k in results.keys()
]
for k in results.keys():
returns = results[k].excess_returns.to_numpy()
returns = returns[:-1]
fx[0] = np.mean(returns) * 100 * 250
fx[1] = -np.std(returns) * 100 * np.sqrt(250)
return fx
# Predicted costs
optimization_tcost = cp.TcostModel(half_spread=0.0005 / 2.,
nonlin_coeff=1.,
sigma=sigmas_pred,
volume=volumes_pred)
optimization_hcost = cp.HcostModel(borrow_costs=0.0001)
# Covariance setup
bl_risk_model = cp.FullSigma(covariance_pred)
# Black Litterman policy
logging.warning('Running backtest')
# Optimization parameters
leverage_limit = cp.LeverageLimit(1)
fully_invested = cp.ZeroCash()
long_only = cp.LongOnly()
# Optimization policy
if mode == 'c':
scns = 1
else:
scns = 5
bl_mps_policy = cp.MultiPeriodScenarioOpt(
alphamodel=ss,
horizon=horizon,
scenarios=scns,
costs=[
grisk * bl_risk_model, gtrd * optimization_tcost,
gamma_hold * optimization_hcost
factor_loadings = pd.get_dummies(pd.Series(np.random.randint(0, 6, 100)))
r_hat_s = pd.Series(np.random.random(100))
r_hat_s.T['USDOLLAR'] = 0
r_hat = pd.DataFrame(r_hat_s, columns=[pd.Timestamp('2017-01-03')]).T
prices_s = pd.Series(np.random.randint(20, 75, 100))
prices_noUSD = pd.DataFrame(prices_s, columns=[pd.Timestamp('2017-01-03')]).T
prices_s.T['USDOLLAR'] = 1.0
prices = pd.DataFrame(prices_s, columns=[pd.Timestamp('2017-01-03')]).T
spo_policy = cp.SinglePeriodOpt(
return_forecast=r_hat,
costs=[],
constraints=[
cp.LeverageLimit(1),
cp.constraints.DollarNeutral(),
cp.constraints.MaxWeights(0.10),
cp.constraints.MinWeights(-0.10),
#cp.FactorMaxLimit(factor_loadings, 1.0),
#cp.FactorMinLimit(factor_loadings, -1.0)
])
current_portfolio = pd.Series(index=r_hat.columns, data=0)
current_portfolio.USDOLLAR = 10000
#import pdb; pdb.set_trace()
shares_to_trade = spo_policy.get_rounded_trades(current_portfolio,
prices,
t=pd.Timestamp('2017-01-04'))
volume_estimate=pd.read_csv(datadir+'volume_estimate.csv.gz',index_col=0,parse_dates=[0]).dropna()
sigma_estimate=pd.read_csv(datadir+'sigma_estimate.csv.gz',index_col=0,parse_dates=[0]).dropna()
optimization_tcost = cp.TcostModel(half_spread=0.0005/2., nonlin_coeff=1.,
sigma=sigma_estimate, volume=volume_estimate)
optimization_hcost=cp.HcostModel(borrow_costs=0.0001)
risk_data = pd.HDFStore(datadir+'risk_model.h5')
risk_model = cp.FactorModelSigma(risk_data.exposures, risk_data.factor_sigma, risk_data.idyos)
results={}
t = datetime(2012,2,1)
print(w_b.shape)
print(locator(risk_model.exposures, t).shape)
print(locator(risk_model.factor_Sigma, t).shape)
print(locator(risk_model.idiosync, t).shape)
policies={}
gamma_risks_coarse=[.1,.3,1,3,10,30,100,300,1000]
gamma_tcosts_coarse=[1,2,5,10,20]
for gamma_risk in gamma_risks_coarse:
for gamma_tcost in gamma_tcosts_coarse :
policies[(gamma_risk, gamma_tcost)] = \
cp.SinglePeriodOpt(return_estimate, [gamma_risk*risk_model,gamma_tcost*optimization_tcost,optimization_hcost],
[cp.LeverageLimit(3)])
import warnings
warnings.filterwarnings('ignore')
results.update(dict(zip(policies.keys(), simulator.run_multiple_backtest(1E8*w_b, start_time=start_t,end_time=end_t,
policies=policies.values(), parallel=True))))
# %%
import cvxpy as cvx
policies = {}
gamma_risks_coarse = [.1, .3, 1, 3, 10, 30, 100, 300, 1000]
gamma_tcosts_coarse = [1, 2, 5, 10, 20]
for gamma_risk in gamma_risks_coarse:
for gamma_tcost in gamma_tcosts_coarse:
policies[(gamma_risk, gamma_tcost)] = cp.MultiPeriodOpt(
return_forecast=returns_forecast,
costs=[
gamma_risk * risk_model, gamma_tcost * optimization_tcost,
optimization_hcost
],
constraints=[cp.LeverageLimit(3)],
trading_times=list(returns.index[(returns.index >= start_t)
& (returns.index <= end_t)]),
lookahead_periods=2,
terminal_weights=None)
results_MPO.update({
k: v
for k, v in zip(
policies.keys(),
simulator.run_multiple_backtest(w_b * 1e8,
start_time=start_t,
end_time=end_t,
policies=policies.values(),
parallel=True))
})
def _evaluate_with_unscaled_input(self, gamma_risk, gamma_tcost,
gamma_holding, bid_ask_spread,
borrow_cost):
# Set up requirements for portfolio simulation
self.experiment_id = str(int(torch.randint(1, 100000,
torch.Size([1]))))
sigmas = pd.read_csv(self.datadir + "sigmas.csv.gz",
index_col=0,
parse_dates=[0]).iloc[:, :-1]
returns = pd.read_csv(self.datadir + "returns.csv.gz",
index_col=0,
parse_dates=[0])
volumes = pd.read_csv(self.datadir + "volumes.csv.gz",
index_col=0,
parse_dates=[0]).iloc[:, :-1]
w_b = pd.Series(index=returns.columns, data=1)
w_b.USDOLLAR = 0.0
w_b /= sum(w_b)
start_t = "2012-01-01"
end_t = "2016-12-31"
simulated_tcost = cp.TcostModel(
half_spread=bid_ask_spread / 2.0,
nonlin_coeff=1.0,
sigma=sigmas,
volume=volumes,
)
simulated_hcost = cp.HcostModel(borrow_costs=borrow_cost)
simulator = cp.MarketSimulator(
returns,
costs=[simulated_tcost, simulated_hcost],
market_volumes=volumes,
cash_key="USDOLLAR",
)
return_estimate = pd.read_csv(self.datadir + "return_estimate.csv.gz",
index_col=0,
parse_dates=[0]).dropna()
volume_estimate = pd.read_csv(self.datadir + "volume_estimate.csv.gz",
index_col=0,
parse_dates=[0]).dropna()
sigma_estimate = pd.read_csv(self.datadir + "sigma_estimate.csv.gz",
index_col=0,
parse_dates=[0]).dropna()
optimization_tcost = cp.TcostModel(
half_spread=bid_ask_spread / 2.0,
nonlin_coeff=1.0,
sigma=sigma_estimate,
volume=volume_estimate,
)
optimization_hcost = cp.HcostModel(borrow_costs=borrow_cost)
copy_of_risk_model_name = "risk_model_" + self.experiment_id + ".h5"
subprocess.call([
"bash",
self.script_dir + "/make_copy_of_risk_model.sh",
self.datadir + "risk_model.h5",
self.datadir + copy_of_risk_model_name,
])
risk_data = pd.HDFStore(self.datadir + copy_of_risk_model_name)
risk_model = cp.FactorModelSigma(risk_data.exposures,
risk_data.factor_sigma,
risk_data.idyos)
results = {}
policies = {}
policies[(gamma_risk, gamma_tcost,
gamma_holding)] = cp.SinglePeriodOpt(
return_estimate,
[
gamma_risk * risk_model,
gamma_tcost * optimization_tcost,
gamma_holding * optimization_hcost,
],
[cp.LeverageLimit(3)],
)
warnings.filterwarnings("ignore")
results.update(
dict(
zip(
policies.keys(),
simulator.run_multiple_backtest(
1e8 * w_b,
start_time=start_t,
end_time=end_t,
policies=policies.values(),
parallel=True,
),
)))
results_df = pd.DataFrame()
results_df[r"$\gamma^\mathrm{risk}$"] = [
el[0] for el in results.keys()
]
results_df[r"$\gamma^\mathrm{trade}$"] = [
el[1] for el in results.keys()
]
results_df[r"$\gamma^\mathrm{hold}$"] = [
"%g" % el[2] for el in results.keys()
]
results_df["Return"] = [
results[k].excess_returns for k in results.keys()
]
for k in results.keys():
returns = results[k].excess_returns.to_numpy()
returns = returns[:-1]
subprocess.call([
"bash",
self.script_dir + "/delete_copy_of_risk_model.sh",
self.datadir + copy_of_risk_model_name,
])
return np.mean(returns) * 100 * 250
