Equity · United States · funds · Monthly · United States Free

Volatility Decomposition and Mutual Fund Returns

Academic paper

Mutual Fund Performance and the Sources of Portfolio Volatility

AuthorsNima Vafai; David A. Rakowski

Institute

The University of Texas of the Permian Basin
?The university of Texas Permian Basin
The University of Texas at Arlington
?University of Texas at Arlington

Paper linkhttps://papers.ssrn.com/sol3/papers.cfm?abstract_id=4005351

Strategy in a nutshell

The investment universe consists of all funds in the CRSP mutual fund database. Funds with less than 80% of assets invested in CRSP-covered stocks during the current and previous year are excluded. For mutual funds with multiple share classes, assets are aggregated across classes, and all fund attributes, including returns, are weighted by lagged assets in each class.

Each month, for each mutual fund kkk, calculate the total return variance σ2\sigma^2σ2 using the weighted covariance of all constituent assets. Decompose σ2\sigma^2σ2 into the average holdings’ variance ν\nuν and average holdings’ covariance ψ\psiψ. Compute ν\nuν using daily returns of each security, then derive ψ\psiψ as σ2−ν\sigma^2 - \nuσ2−ν.

Mutual funds are sorted monthly into equally-weighted deciles based on σ2\sigma^2σ2, ν\nuν, and ψ\psiψ. The strategy allocates 50% to the bottom decile of funds with the lowest variance σ2\sigma^2σ2 and 50% to the bottom decile with the lowest average holdings’ covariance ψ\psiψ. Portfolios are equally weighted and rebalanced monthly.

Economic rationale

Financial theory posits that higher expected returns are associated with higher risk. In practice, investors often overpay for risky assets, causing high-volatility assets to be overvalued and low-volatility assets to be undervalued, resulting in lower and higher subsequent returns, respectively.

Following Markowitz (1952, 1959), a portfolio’s total risk (σ2\sigma^2σ2) can be decomposed into variance of holdings (ν\nuν) and covariances of holdings (ψ\psiψ). While diversification reduces ν\nuν toward zero, it does not eliminate ψ\psiψ. Hence, the covariance component ψ\psiψ drives the volatility-based return patterns observed, rather than the overall portfolio variance σ2\sigma^2σ2.

Backtest performance

Annualised return14.52%

Volatility32.33%

Beta0.004

Sharpe ratio0.49

Win rate59%

Full Python code

1from AlgorithmImports import *
2from dateutil.relativedelta import relativedelta
3from itertools import combinations
4#endregion
5
6class VolatilityDecompositionandMutualFundReturns(QCAlgorithm):
7
8def Initialize(self):
9self.SetStartDate(2010, 1, 1)
10self.SetCash(100000)
11
12self.period:int = 3 * 21
13self.quantile:int = 5
14self.leverage:int = 5
15self.price_data:dict[Symbol, RollingWindow] = {}
16
17self.holdings_by_fund:dict[str, FundHoldings] = {}
18self.ticker_universe:set = set()  # every ticker stored in hedge fund holdings data
19self.weight:dict[Symbol, float] = {}
20
21hedge_fund_file_content:str = self.Download('data.quantpedia.com/backtesting_data/equity/hedge_fund_holdings/hedge_funds_holdings.json')
22hedge_funds_data:dict = json.loads(hedge_fund_file_content)
23
24for index, hedge_fund_data in enumerate(hedge_funds_data):
25    hedge_fund_names:list[str] = list(hedge_fund_data.keys())
26    hedge_fund_names.remove('date')
27    date:datetime.date = datetime.strptime(hedge_fund_data['date'], '%d.%m.%Y').date()
28
29    for hedge_fund_name in hedge_fund_names:
30        if hedge_fund_name not in self.holdings_by_fund:
31            self.holdings_by_fund[hedge_fund_name] = FundHoldings(hedge_fund_name)
32
33        holding_list:list[StockHolding] = []
34        holdings:list[dict] = hedge_fund_data[hedge_fund_name]['stocks']
35        for holding in holdings:
36            ticker:str = holding['ticker']
37            number_of_shares:int = int(holding['#_of_shares'])
38            weight:float = float(holding['weight'])
39
40            self.ticker_universe.add(ticker)
41
42            holding_list.append(StockHolding(ticker, number_of_shares, weight))
43        
44        self.holdings_by_fund[hedge_fund_name].update_holdings_by_date(date, holding_list)
45
46self.selection_flag:bool = False
47self.market:Symbol = self.AddEquity('SPY', Resolution.Daily).Symbol
48self.UniverseSettings.Resolution = Resolution.Daily
49self.AddUniverse(self.CoarseSelectionFunction, self.FineSelectionFunction)
50self.Settings.MinimumOrderMarginPortfolioPercentage = 0.
51self.Schedule.On(self.DateRules.MonthStart(self.market), self.TimeRules.BeforeMarketClose(self.market), self.Selection)
52
53def OnSecuritiesChanged(self, changes):
54for security in changes.AddedSecurities:
55    security.SetFeeModel(CustomFeeModel())
56    security.SetLeverage(self.leverage)
57
58def CoarseSelectionFunction(self, coarse):
59# store daily prices
60for stock in coarse:
61    symbol:Symbol = stock.Symbol
62    ticker:str = symbol.Value
63
64    if ticker in self.ticker_universe:
65        if symbol in self.price_data:
66            self.price_data[symbol].Add(stock.AdjustedPrice)
67    
68if not self.selection_flag:
69    return Universe.Unchanged
70
71selected:list[Symbol] = [x.Symbol for x in coarse if x.Symbol.Value in self.ticker_universe]
72
73# warmup price rolling windows
74for symbol in selected:
75    if symbol in self.price_data:
76        continue
77    
78    self.price_data[symbol] = RollingWindow[float](self.period)
79   
80    history:pd.DataFrame = self.History(symbol, self.period, Resolution.Daily)
81    if history.empty:
82        continue
83
84    closes = history.loc[symbol].close
85    for time, close in closes.iteritems():
86        self.price_data[symbol].Add(close)
87
88return [x for x in selected if self.price_data[x].IsReady]
89
90def FineSelectionFunction(self, fine):
91symbol_by_ticker:dict[str, Symbol] = {x.Symbol.Value : x.Symbol for x in fine}
92
93# get previous month's holdings
94prev_month:datetime = self.Time.date() - timedelta(days=self.Time.day) - relativedelta(months=2)
95
96portfolio_volatility:dict[str, float] = {}
97covariance_average:dict[str, float] = {}
98
99for fund in self.holdings_by_fund:
100    if prev_month in self.holdings_by_fund[fund].holdings_by_date:
101        # previous month's holdings for fund performance calculation
102        prev_months_holdings = self.holdings_by_fund[fund].holdings_by_date[prev_month]
103        
104        # calculate portfolio volatility and weighted average of constituent holdings’ covariances
105        p_vol:float = 0.
106        cov_avg:float = 0.
107
108        n = len(prev_months_holdings)
109        if n > 2:
110            for i_holding in prev_months_holdings:
111                i_ticker:str = i_holding.ticker
112                i_weight:float = i_holding.weight / 100
113                
114                for j_holding in prev_months_holdings:
115                    j_ticker:str = j_holding.ticker
116                    j_weight:float = j_holding.weight / 100
117
118                    # both price series are ready
119                    if i_ticker in symbol_by_ticker and j_ticker in symbol_by_ticker:
120                        x:np.ndarray = np.array([[x for x in self.price_data[symbol_by_ticker[i_ticker]]], [x for x in self.price_data[symbol_by_ticker[j_ticker]]]])
121                        cov:float = np.cov(x)[0][1]
122
123                        # covariance average
124                        if i_holding != j_holding:
125                            cov_avg += (i_weight * j_weight * cov)
126                        
127                        # portfolio volatility
128                        p_vol += (i_weight * j_weight * cov)
129        
130        if p_vol != 0 and cov_avg != 0:
131            portfolio_volatility[fund] = p_vol
132            covariance_average[fund] = cov_avg
133
134if len(portfolio_volatility) >= self.quantile:
135    # pick bottom funds
136    quantile:int = int(len(portfolio_volatility) / self.quantile)
137
138    sorted_by_volatility = sorted(portfolio_volatility.items(), key = lambda x: x[1], reverse=True)
139    bottom_by_volatility:list = [x[0] for x in sorted_by_volatility][-quantile:]
140    
141    sorted_by_covariance = sorted(covariance_average.items(), key = lambda x: x[1], reverse=True)
142    bottom_by_covariance:list = [x[0] for x in sorted_by_covariance][-quantile:]
143
144    # hold fund constituents instead of fund etfs
145    fund_c:int = len(bottom_by_volatility + bottom_by_covariance)
146    for fund in bottom_by_volatility + bottom_by_covariance:
147        holdings = self.holdings_by_fund[fund].holdings_by_date[prev_month]
148        for holding in prev_months_holdings:
149            ticker:str = holding.ticker
150            weight:float = holding.weight / 100
151            if ticker in symbol_by_ticker:
152                self.weight[symbol_by_ticker[ticker]] = (1 / fund_c) * weight
153
154return list(self.weight.keys())
155
156def OnData(self, data):
157if not self.selection_flag:
158    return
159self.selection_flag = False
160
161invested:list[Symbol] = [x.Key for x in self.Portfolio if x.Value.Invested]
162for symbol in invested:
163    if symbol not in self.weight:
164        self.Liquidate(symbol)
165
166for symbol, w in self.weight.items():
167    if symbol in data and data[symbol]:
168        self.SetHoldings(symbol, w)
169
170self.weight.clear()
171
172def Selection(self):
173# rabalance once a quarter
174if self.Time.month % 3 == 0:
175    self.selection_flag = True
176
177class StockHolding():
178def __init__(self, ticker:str, n_of_shares:int, weight:float):
179self.ticker:str = ticker
180self.n_of_shares:int = n_of_shares
181self.weight:float = weight
182
183class FundHoldings():
184def __init__(self, fund_name:str):
185self.fund_name:str = fund_name
186self.holdings_by_date:dict[datetime, list[StockHolding]] = {}
187
188def update_holdings_by_date(self, date:datetime.date, holdings:list):
189self.holdings_by_date[date] = holdings
190
191# Custom fee model
192class CustomFeeModel():
193def GetOrderFee(self, parameters):
194fee = parameters.Security.Price * parameters.Order.AbsoluteQuantity * 0.00005
195return OrderFee(CashAmount(fee, "USD"))