def main():
returns, cov_mat, avg_rets = pfopt.create_test_data()
section("Example returns")
print(returns.head(10))
print("...")
section("Average returns")
print(avg_rets)
section("Covariance matrix")
print(cov_mat)
section("Minimum variance portfolio (long only)")
weights = pfopt.min_var_portfolio(cov_mat)
print_portfolio_info(returns, avg_rets, weights)
section("Minimum variance portfolio (long/short)")
weights = pfopt.min_var_portfolio(cov_mat, allow_short=True)
print_portfolio_info(returns, avg_rets, weights)
# Define some target return, here the 70% quantile of the average returns
target_ret = avg_rets.quantile(0.7)
section("Markowitz portfolio (long only, target return: {:.5f})".format(
target_ret))
weights = pfopt.markowitz_portfolio(cov_mat, avg_rets, target_ret)
print_portfolio_info(returns, avg_rets, weights)
section("Markowitz portfolio (long/short, target return: {:.5f})".format(
target_ret))
weights = pfopt.markowitz_portfolio(cov_mat,
avg_rets,
target_ret,
allow_short=True)
print_portfolio_info(returns, avg_rets, weights)
section(
"Markowitz portfolio (market neutral, target return: {:.5f})".format(
target_ret))
weights = pfopt.markowitz_portfolio(cov_mat,
avg_rets,
target_ret,
allow_short=True,
market_neutral=True)
print_portfolio_info(returns, avg_rets, weights)
section("Tangency portfolio (long only)")
weights = pfopt.tangency_portfolio(cov_mat, avg_rets)
weights = pfopt.truncate_weights(weights) # Truncate some tiny weights
print_portfolio_info(returns, avg_rets, weights)
section("Tangency portfolio (long/short)")
weights = pfopt.tangency_portfolio(cov_mat, avg_rets, allow_short=True)
print_portfolio_info(returns, avg_rets, weights)
def main():
# returns, cov_mat, avg_rets = pfopt.create_test_data(num_days=1000)
returns, cov_mat, avg_rets = load_data()
# yy = returns['asset_a']
# xx = [ii for ii in range(len(yy))]
# plt.plot(xx, yy)
# plt.hlines(avg_rets[0], xmin=0, xmax=100, colors='black')
# plt.show()
# return 0
section("Example returns")
print(returns.head(5))
print("...")
section("Average returns")
print(avg_rets)
section("Covariance matrix")
print(cov_mat)
section("Minimum variance portfolio (long only)")
weights = pfopt.min_var_portfolio(cov_mat)
print_portfolio_info(returns, avg_rets, weights)
section("Minimum variance portfolio (long/short)")
weights = pfopt.min_var_portfolio(cov_mat, allow_short=True)
print_portfolio_info(returns, avg_rets, weights)
# Define some target return, here the 70% quantile of the average returns
target_ret = avg_rets.quantile(0.7)
section("Markowitz portfolio (long only, target return: {:.5f})".format(target_ret))
weights = pfopt.markowitz_portfolio(cov_mat, avg_rets, target_ret)
print_portfolio_info(returns, avg_rets, weights)
section("Markowitz portfolio (long/short, target return: {:.5f})".format(target_ret))
weights = pfopt.markowitz_portfolio(cov_mat, avg_rets, target_ret, allow_short=True)
print_portfolio_info(returns, avg_rets, weights)
section("Markowitz portfolio (market neutral, target return: {:.5f})".format(target_ret))
weights = pfopt.markowitz_portfolio(cov_mat, avg_rets, target_ret, allow_short=True,
market_neutral=True)
print_portfolio_info(returns, avg_rets, weights)
section("Tangency portfolio (long only)")
weights = pfopt.tangency_portfolio(cov_mat, avg_rets)
weights = pfopt.truncate_weights(weights) # Truncate some tiny weights
print_portfolio_info(returns, avg_rets, weights)
section("Tangency portfolio (long/short)")
weights = pfopt.tangency_portfolio(cov_mat, avg_rets, allow_short=True)
print_portfolio_info(returns, avg_rets, weights)
def get_markowitz_analysis(self,forecasts=0):
start_index = len(self.historical_returns) - 253
end_index = len(self.historical_returns) - 1
return_grid = 100 * self.returns_grid[:, start_index:end_index].T
returns = pd.DataFrame(return_grid)
avgs = [self.yearly_expected_ret(returns[col]) for col in returns.columns]
cov_mat = pd.DataFrame(np.cov(return_grid.T))
if forecasts == 0:
avg_rets = pd.Series(avgs, index=returns.columns)
else:
avg_rets = pd.Series(forecasts.values(), index=returns.columns)
w_opt = pfopt.tangency_portfolio(cov_mat, avg_rets, allow_short=False)
ret_opt = (w_opt * avg_rets).sum()
std_opt = (w_opt * returns).sum(1).std()
smallest_target = max(min(avg_rets), 0)
biggest_target = max(avg_rets)
target_returns = np.arange(smallest_target, biggest_target, .0005)
X = []
Y = []
for yi in target_returns:
w = pfopt.markowitz_portfolio(cov_mat, avg_rets, yi)
ret = (w * avg_rets).sum()
std = (w * returns).sum(1).std()
Y.append(ret)
X.append(std)
#coefs = np.polyfit(Y,X,2) #highest power first
curve = {"risks":X,"returns":Y,"min_return":smallest_target,"max_return":biggest_target}
tangency_port = {'weights': dict(w_opt),'X':std_opt,'Y':ret_opt}
return {"tangency_port":tangency_port,"curve":curve}
def markowitz_portfolios(self):
pf = self.panelframe
returns = (pf['Close'] - pf['Close'].shift(1)) / pf['Close'].shift(1)
returns.fillna(0, inplace=True)
market = returns['market']
returns = returns.iloc[:, :-1]
cov_mat = np.cov(returns, rowvar=False, ddof=1)
cov_mat = pd.DataFrame(cov_mat,
columns=returns.keys(),
index=returns.keys())
avg_rets = returns.mean(0).astype(np.float64)
mrk = []
weights = pfopt.min_var_portfolio(cov_mat)
case = self._one_pfopt_case(cov_mat, returns, market, weights,
'Minimum variance portfolio')
mrk.append(case)
for t in [0.50, 0.75, 0.90]:
target = avg_rets.quantile(t)
weights = pfopt.markowitz_portfolio(cov_mat, avg_rets, target)
case = self._one_pfopt_case(
cov_mat, returns, market, weights,
'Target: more than {:.0f}% of stock returns'.format(t * 100))
mrk.append(case)
weights = pfopt.tangency_portfolio(cov_mat, avg_rets)
case = self._one_pfopt_case(cov_mat, returns, market, weights,
'Tangency portfolio')
mrk.append(case)
return mrk
def test_allow_short(self):
returns, cov_mat, avg_rets = create_test_data()
calc_weights = pfopt.tangency_portfolio(cov_mat, avg_rets, allow_short=True).values
exp_weights = [0.048052417309504825, 0.63522794399754601, -0.53498204281249118,
0.93698599544795846, -0.085284313942518161]
self.assertTrue(np.allclose(calc_weights, exp_weights))
def test_long_only(self):
returns, cov_mat, avg_rets = create_test_data()
calc_weights = pfopt.tangency_portfolio(cov_mat, avg_rets).values
exp_weights = [0.013637652162222968, 0.37065128018786714, 1.6549667634656901e-09,
0.61571105705720952, 8.9377335719926867e-09]
self.assertTrue(np.allclose(calc_weights, exp_weights))
def test_allow_short(self):
returns, cov_mat, avg_rets = create_test_data()
calc_weights = pfopt.tangency_portfolio(cov_mat, avg_rets, allow_short=True).values
exp_weights = [0.048052417309504825, 0.63522794399754601, -0.53498204281249118,
0.93698599544795846, -0.085284313942518161]
self.assertTrue(np.allclose(calc_weights, exp_weights))
def test_long_only(self):
returns, cov_mat, avg_rets = create_test_data()
calc_weights = pfopt.tangency_portfolio(cov_mat, avg_rets).values
exp_weights = [0.013637652162222968, 0.37065128018786714, 1.6549667634656901e-09,
0.61571105705720952, 8.9377335719926867e-09]
self.assertTrue(np.allclose(calc_weights, exp_weights))
def main():
returns, cov_mat, avg_rets = pfopt.create_test_data()
section("Example returns")
print(returns.head(10))
print("...")
section("Average returns")
print(avg_rets)
section("Covariance matrix")
print(cov_mat)
section("Minimum variance portfolio (long only)")
weights = pfopt.min_var_portfolio(cov_mat)
print_portfolio_info(returns, avg_rets, weights)
section("Minimum variance portfolio (long/short)")
weights = pfopt.min_var_portfolio(cov_mat, allow_short=True)
print_portfolio_info(returns, avg_rets, weights)
# Define some target return, here the 70% quantile of the average returns
target_ret = avg_rets.quantile(0.7)
section("Markowitz portfolio (long only, target return: {:.5f})".format(target_ret))
weights = pfopt.markowitz_portfolio(cov_mat, avg_rets, target_ret)
print_portfolio_info(returns, avg_rets, weights)
section("Markowitz portfolio (long/short, target return: {:.5f})".format(target_ret))
weights = pfopt.markowitz_portfolio(cov_mat, avg_rets, target_ret, allow_short=True)
print_portfolio_info(returns, avg_rets, weights)
section("Markowitz portfolio (market neutral, target return: {:.5f})".format(target_ret))
weights = pfopt.markowitz_portfolio(cov_mat, avg_rets, target_ret, allow_short=True,
market_neutral=True)
print_portfolio_info(returns, avg_rets, weights)
section("Tangency portfolio (long only)")
weights = pfopt.tangency_portfolio(cov_mat, avg_rets)
weights = pfopt.truncate_weights(weights) # Truncate some tiny weights
print_portfolio_info(returns, avg_rets, weights)
section("Tangency portfolio (long/short)")
weights = pfopt.tangency_portfolio(cov_mat, avg_rets, allow_short=True)
print_portfolio_info(returns, avg_rets, weights)
def markowitz_portfolios(self):
"""
Estimate Markowitz portfolios
Inputs: daily returns by stock, avg returns by stock, cov_matrix
"""
# pf = self._daily
# returns = (pf['close'] - pf['close'].shift(1))/pf['close'].shift(1)
# returns.fillna(0, inplace=True)
# market = returns['market']
# returns = returns.iloc[:, :-1]
# cov_mat = np.cov(returns, rowvar=False, ddof=1)
# cov_mat = pd.DataFrame(
# cov_mat,
# columns=returns.keys(),
# index=returns.keys())
# avg_rets = returns.mean(0).astype(np.float64)
# prepare inputs
returns = self.stocks_daily
market = returns['SPY']
returns.drop('SPY', axis=1, inplace=True)
avg_rets = returns.mean(0).astype(np.float64)
cov_mat = self.stocks_covar
cov_mat.drop('SPY', axis=0, inplace=True)
cov_mat.drop('SPY', axis=1, inplace=True)
mrk = []
weights = pfopt.min_var_portfolio(cov_mat)
case = self._one_pfopt_case(returns, market, weights,
'Minimum variance portfolio')
mrk.append(case)
for t in [0.50, 0.75, 0.90]:
target = avg_rets.quantile(t)
weights = pfopt.markowitz_portfolio(cov_mat, avg_rets, target)
case = self._one_pfopt_case(
returns, market, weights,
'Target: more than {:.0f}% of stock returns'.format(t * 100))
mrk.append(case)
weights = pfopt.tangency_portfolio(cov_mat, avg_rets)
case = self._one_pfopt_case(returns, market, weights,
'Tangency portfolio')
mrk.append(case)
return mrk
def market_tangent_point(returns_data):
avg_rets = returns_data.mean()
cov_mat = returns_data.cov()
# calculate the Markowitz optimal allocations for each target return value
optimal_weights = pfopt.tangency_portfolio(cov_mat=cov_mat,
exp_rets=avg_rets)
matrix_rets = avg_rets.as_matrix()
matrix_cov = cov_mat.as_matrix()
reward = optimal_weights.dot(matrix_rets)
risk = np.sqrt(optimal_weights.dot(matrix_cov.dot(optimal_weights)))
return reward, risk
def tangency_opt(df_daily_returns):
cov_mat = df_daily_returns.cov()
avg_rets = df_daily_returns.mean()
weights = pfopt.tangency_portfolio(cov_mat, avg_rets)
weights = pfopt.truncate_weights(weights) # Truncate some tiny weights
weights = weights[weights != 0]
weights = weights.round(decimals=4)
ret = (weights * avg_rets).sum()
ret = ret.round(decimals=4)
std = (weights * df_daily_returns).sum(1).std()
std = std.round(decimals=4)
return weights, ret, std
print('-' * len(caption))
def print_portfolio_info(returns, avg_rets, weights):
"""
Print information on expected portfolio performance.
"""
ret = (weights * avg_rets).sum()
std = (weights * returns).sum(1).std()
sharpe = ret / std
print("Optimal weights:\n{}\n".format(weights))
print("Expected return: {}".format(ret))
print("Expected variance: {}".format(std**2))
print("Expected Sharpe: {}".format(sharpe))
# Define some target return, here the 70% quantile of the average returns
target_ret = avg_rets.quantile(0.9)
weights = pfopt.min_var_portfolio(cov_mat)
print_portfolio_info(returns, avg_rets, weights)
section("Markowitz portfolio (long only, target return: {:.5f})".format(
target_ret))
weights = pfopt.markowitz_portfolio(cov_mat, avg_rets, target_ret)
print_portfolio_info(returns, avg_rets, weights)
section("Tangency portfolio (long only)")
weights = pfopt.tangency_portfolio(cov_mat, avg_rets)
weights = pfopt.truncate_weights(weights) # Truncate some tiny weights
print_portfolio_info(returns, avg_rets, weights)
## preprocess daily returns of previous month ##
dailyreturn = pd.read_csv('returns_17_10.csv')
data = dailyreturn
d = {}
for i in data.columns.values:
dval = data[i].tolist()
d[i] = dval
# d is the dictionary we can use to put into the blm model
stk_list = list(d.keys())
data = list(d.values())
n = len(data[0])
cov_m = pd.DataFrame(np.cov(data))
rtn_m = pd.Series([np.mean(each) for each in data])
#tangency_portfolio(pandas.DataFrame, pandas.Series)
w_neutral = pfopt.tangency_portfolio(cov_m, rtn_m, allow_short=True)
w_neutral = pd.DataFrame([round(each, 4) for each in w_neutral],
index=stk_list,
columns=['Weights'])
### The asolute views obtained from view prediction AI-model
##############
view = {}
view['view1'] = (['LQD'], [1], 0.003507782)
view['view2'] = (['SPY'], [1], 0.000190048)
view['view3'] = (['VOT'], [1], 0.007558567)
view['view4'] = (['IWV'], [1], 0.001878394)
view['view5'] = (['IWP'], [1], 0.004234864)
view['view6'] = (['IJK'], [1], 0.019953683)
view['view7'] = (['IVV'], [1], 0.01048204)
##############
#计算目标收益的权重 (markowitz_portfolio方法)
portfolio_1 = opt.markowitz_portfolio(cov_mat,
exp_rets,
0.2,
allow_short=False,
market_neutral=False)
#需输入协方差矩阵cov_mat,年预期收益exp_rets,0.2代表想要的年收益,allow_short表示是否允许做空,market_neutral表示是否具有市场中性
print(portfolio_1)
#得到的结果表示若要实现0.2的年收益,则分别需买入这些股票的比重分别为
#计算最小方差的权重 (opt.min_var_portfolio)
portfolio_mv = opt.min_var_portfolio(cov_mat, allow_short=False)
print(portfolio_mv)
#计算最优组合的权重 (opt.tangency_portfolio) (夏普比率最高的比重)
portfolio_tp = opt.tangency_portfolio(
cov_mat, exp_rets, allow_short=False) #需输入协方差矩阵cov_mat,年预期收益exp_rets
print(portfolio_tp)
#去除少于0.01权重的股票,低于0.01权重的不建议购买
weigth_t = opt.truncate_weights(portfolio_tp, min_weight=0.01, rescale=True)
print(weigth_t)
#计算组合风险
import numpy as np
Portfolio_v = np.dot(weigth_t.T,
np.dot(cov_mat,
weigth_t)) #weigth_t.T表示weigth_t的转置,cov_mat是协方差矩阵
P_sigma = np.sqrt(Portfolio_v) #开方求标准差
P_sigma
#Markowitz可视化 (求最高夏普比率) ？？？
