5.10.5 Case study: estimating beta and hedge ratios

Beta and alpha by regression

The data are case study 3.5.5's 60 invented months, rebuilt from the same seed. They are the index's monthly return $R_M$ , which that case study used as the future's, and the stock's return $R$ . Both are rounded to 0.01%.

They were built with a beta of 1.2. Each month the stock returned 0.3%, plus 1.2 times the index, plus a move of its own of typical size 3.5%. Real data never reveals its beta; here every estimate can be checked against 1.2.

The capital asset pricing model (lesson 4.6.3) is about returns in excess of the risk-free rate. Take $r_f$ = 3% a year, Level 4's rate, which is 0.25% a month.

Rule: Beta and alpha by regression

\begin{gathered} R_t - r_f = \alpha + \beta\,(R_{M,t} - r_f) + \varepsilon_t \end{gathered}

$t$ numbers the months. The slope $\beta$ is lesson 4.6.3's beta and the intercept $\alpha$ the stock's alpha against the index, per month. The error $\varepsilon_t$ is the stock's own move, its specific risk.

Least squares (lesson 5.10.1) gives $\hat{\beta} = 1.1518$ , exactly case study 3.5.5's hedge ratio. Subtracting $r_f$ shifts both series by a constant and leaves every covariance alone, so the slope $\frac{s_{xy}}{s_x^2}$ does not change. $R^2 = 0.7259$ is case study 3.5.5's $\rho^2$ , the share of the stock's variance that the index explains.

The intercept is $\hat{\alpha} = -0.1384\%$ a month, or $-1.66\%$ a year. The residual standard deviation $s$ is 3.31% a month, against the true 3.5%: the stock's specific volatility.

The true alpha is not 0.3%. In excess returns the stock is $(0.003 + 0.2r_f) + 1.2(R_M - r_f) + \varepsilon$ , so $\alpha = 0.003 + 0.2 \times 0.0025 = 0.35\%$ a month, 4.2% a year. The estimate even has the wrong sign.

\hat{\alpha}

import numpy as np rng = np.random.default_rng(355) index = rng.normal(0.006, 0.045, 60) stock = 0.003 + 1.2 * index + rng.normal(0, 0.035, 60) f, x = np.round(index, 4), np.round(stock, 4) rf = 0.0025 X = np.column_stack([np.ones(60), f - rf]) y = x - rf b = np.linalg.lstsq(X, y, rcond=None)[0] e = y - X @ b r2 = 1 - (e @ e) / ((y - y.mean()) ** 2).sum() print(np.round(b, 6), round(r2, 4), round(np.sqrt(e @ e / 58), 4)) print(round(np.cov(x, f)[0, 1] / np.var(f, ddof=1), 4), round(12 * b[0], 4))

⌘/Ctrl + Enter runs the cell

How precise are beta and alpha?

Lesson 5.10.3 gives each estimate a standard error, $s\sqrt{[(X^\top X)^{-1}]_{jj}}$ , with $n - k = 58$ degrees of freedom. The t quantile is $t_{0.975,\,58} = 2.0017$ .

per month	estimate	standard error	95% interval	t for 0	p
alpha	$-0.1384\%$	0.436%	$-1.011\%$ to 0.734%	$-0.3175$	0.752
beta	1.1518	0.0929	0.9658 to 1.3379	12.3927	$6 \times 10^{-18}$

Beta is far from 0. A t statistic of 12.39 leaves no doubt that the stock moves with the index. The interval covers the true 1.2.

Is beta above 1? The test of $\beta = 1$ gives $t = \frac{1.1518 - 1}{0.0929} = 1.6335$ and $p = 0.1078$ , and the interval includes 1. Five years of data cannot show that the stock amplifies the index, although its true beta is 1.2.

Alpha cannot be seen. Its t statistic is $-0.3175$ , with $p = 0.752$ . In a year the interval runs from $-12.13\%$ to 8.81%: it covers 0, and it covers the true 4.2%.

Here the market's mean excess return is small next to its spread, so $\operatorname{se}(\hat{\alpha})$ is close to $\frac{s}{\sqrt{n}}$ . An alpha of 0.35% a month with specific risk of 3.5% reaches $t = 2$ only when $\sqrt{n} = \frac{2 \times 0.035}{0.0035} = 20$ : 400 months, or 33.3 years. Case study 5.8.5 meets the same problem with a Sharpe ratio.

\frac{s}{\sqrt{n}}

import numpy as np from scipy import stats rng = np.random.default_rng(355) index = rng.normal(0.006, 0.045, 60) stock = 0.003 + 1.2 * index + rng.normal(0, 0.035, 60) f, x = np.round(index, 4), np.round(stock, 4) X = np.column_stack([np.ones(60), f - 0.0025]) y = x - 0.0025 b = np.linalg.lstsq(X, y, rcond=None)[0] e = y - X @ b se = np.sqrt(e @ e / 58 * np.diag(np.linalg.inv(X.T @ X))) q = stats.t.ppf(0.975, 58) print(np.round(se, 6), round(q, 4)) print(np.round(b[0] + np.array([-q, q]) * se[0], 5), np.round(b[1] + np.array([-q, q]) * se[1], 4)) t0 = b / se print(np.round(t0, 4), round(2 * stats.t.sf(abs(t0[0]), 58), 4), f"{2 * stats.t.sf(t0[1], 58):.0e}") t1 = (b[1] - 1) / se[1] print(round(t1, 4), round(2 * stats.t.sf(t1, 58), 4)) print(np.round(12 * (b[0] + np.array([-q, q]) * se[0]), 4), round(np.sqrt(e @ e / 58 / 60), 5)) print(round((2 * 0.035 / 0.0035) ** 2), round((2 * 0.035 / 0.0035) ** 2 / 12, 1))

⌘/Ctrl + Enter runs the cell

Check yourself

The stock's beta is 1.1518 with standard error 0.0929 from 60 months. A colleague says the stock is significantly more sensitive to the index than the index itself, since 1.15 is above 1. What do you reply?

Agreed: the estimate is above 1, so the true beta is above 1Not shown: the test of beta equal to 1 gives t = 1.63 and p = 0.11, and the 95% interval, 0.97 to 1.34, contains 1Beta is not significant at all, since its interval is wide

What the uncertainty costs the hedge

The interval for beta runs from 0.9658 to 1.3379: from $9.66 million to $13.38 million of futures on $10 million of stock. That looks wide, but the hedged risk hardly changes across it.

On the same 60 months, hedging at either end of the interval leaves 11.74% a year. The estimate leaves 11.36%, and the true 1.2 leaves 11.38%.

Case study 3.5.5's parabola of variance against the hedge ratio is flat near its lowest point. So an error of two standard errors in beta costs less than half a point of volatility.

Try it The loop computes the annual volatility of the stock hedged at each ratio, on case study 3.5.5's 60 months. The ratios are the two ends of the interval, the estimate and the truth; the middle column is the futures sold on $10 million of stock.

⌘/Ctrl + Enter runs the cell

Rolling estimates

Case study 3.5.5 estimated the hedge ratio on every run of 24 months and found values from 0.9518 to 1.3486. It warned that the ratio drifts. In these data the true beta was 1.2 in every month, so the whole of that drift is sampling noise.

Regression says how much noise to expect. Each 24-month window has 22 degrees of freedom, and its beta has a standard error between 0.1102 and 0.1797. With $t_{0.975,\,22} = 2.0739$ , each 95% interval reaches 0.23 to 0.37 either side of its estimate, and 36 of the 37 cover 1.2.

Rolling 24-month betas with their 95% intervals. The beta that made the data never changed, yet the estimates wander by about 0.4: noise of the size the band shows.

How often does a constant beta produce a range this wide? In 2,000 simulated five-year histories with beta 1.2 throughout, the 37 rolling betas span a median of 0.3942. In 49.25% of the histories they span at least these data's 0.3969.

Longer windows wobble less. Here 36-month windows run from 1.076 to 1.1875, with standard errors from 0.0993 to 0.1263. They would also react more slowly to a real change in beta: the window length trades noise against speed.

\frac{s_{xy}}{s_x^2}

import numpy as np from numpy.lib.stride_tricks import sliding_window_view from scipy import stats rng = np.random.default_rng(355) index = rng.normal(0.006, 0.045, 60) stock = 0.003 + 1.2 * index + rng.normal(0, 0.035, 60) f, x = np.round(index, 4) - 0.0025, np.round(stock, 4) - 0.0025 def beta_se(fw, xw): X = np.column_stack([np.ones(len(fw)), fw]) b = np.linalg.lstsq(X, xw, rcond=None)[0] e = xw - X @ b return b[1], np.sqrt(e @ e / (len(fw) - 2) * np.linalg.inv(X.T @ X)[1, 1]) for w in (24, 36): bs, ses = np.array([beta_se(f[i:i + w], x[i:i + w]) for i in range(61 - w)]).T q = stats.t.ppf(0.975, w - 2) print(w, round(bs.min(), 4), round(bs.max(), 4), round(ses.min(), 4), round(ses.max(), 4), round(q, 4), int(np.sum(np.abs(bs - 1.2) <= q * ses)), len(bs)) print(round(q * ses.min(), 2), round(q * ses.max(), 2)) g = np.random.default_rng(5105) M = g.normal(0.006, 0.045, (2000, 60)) S = 0.003 + 1.2 * M + g.normal(0, 0.035, (2000, 60)) Mw, Sw = sliding_window_view(M, 24, axis=1), sliding_window_view(S, 24, axis=1) Mc, Sc = Mw - Mw.mean(axis=2, keepdims=True), Sw - Sw.mean(axis=2, keepdims=True) B = (Mc * Sc).sum(axis=2) / (Mc**2).sum(axis=2) spread = B.max(axis=1) - B.min(axis=1) print(B.shape, round(np.median(spread), 4), round(np.mean(spread >= 1.348637 - 0.951770), 4))

⌘/Ctrl + Enter runs the cell

Two factors

An invented airline's stock moves with the market and against the price of oil, which it burns. The data use the same 60 months of the index, plus a seeded oil future's monthly return $R_O$ . Oil has a volatility of 7.71% a month and a correlation of 0.2456 with the index.

The airline was built as 0.2% plus 1.1 times the index, minus 0.35 times oil, plus a move of its own of typical size 4%. So its true market beta is 1.1, and its true oil beta is $-0.35$ .

Rule: A two-factor regression

\begin{gathered} R_t - r_f = \alpha + \beta_M(R_{M,t} - r_f) \\ + \beta_O R_{O,t} + \varepsilon_t \end{gathered}

$\beta_M$ is the market beta with oil held fixed, and $\beta_O$ the oil beta with the market held fixed (lesson 5.10.2). The oil future's return needs no $r_f$ subtracted: a future costs nothing to enter, as case study 3.5.5 assumed.

fit	market beta	oil beta	$R^2$
market alone	0.9627 (se 0.1439)		0.4355
market and oil	1.0994 (se 0.1303)	$-0.3346$ (se 0.0783)	0.5724

The oil beta has $t = -4.27$ , with a p-value of 0.0001: oil matters, and its interval, $-0.4915$ to $-0.1777$ , covers the true $-0.35$ . The market beta's interval with oil in the model runs from 0.8384 to 1.3605.

Leaving oil out lowers the market beta by lesson 5.10.2's rule: $1.0994 + (-0.3346) \times 0.4087 = 0.9627$ , where 0.4087 is the slope of oil on the index. Oil tends to rise with the market and hurts the airline. So on its own, the market seems to move the airline less than it does.

Which beta hedges?

It depends on what the desk trades. With index futures alone, the best ratio is the one-factor slope, 0.9627, the $\frac{\operatorname{Cov}}{\operatorname{Var}}$ of case study 3.5.5. It cuts the airline's 6.76% a month to 5.08%; selling 1.0994 instead would leave 5.12%.

With oil futures too, case study 3.5.5's several-hedge equations are this regression's normal equations. Sell $1.0994 of index futures and buy $0.3346 of oil futures per dollar of airline, and 4.42% is left: 57.24% of the variance removed, against 43.55% with the index alone.

R^2

import numpy as np from scipy import stats rng = np.random.default_rng(355) index = rng.normal(0.006, 0.045, 60) f = np.round(index, 4) g = np.random.default_rng(5108) oil = np.round(0.5 * (index - 0.006) + g.normal(0.004, 0.08, 60), 4) air = np.round(0.002 + 1.1 * index - 0.35 * oil + g.normal(0, 0.04, 60), 4) print(round(np.std(oil, ddof=1), 4), round(np.corrcoef(f, oil)[0, 1], 4)) def fit(X, y): b = np.linalg.lstsq(X, y, rcond=None)[0] e = y - X @ b se = np.sqrt(e @ e / (len(y) - X.shape[1]) * np.diag(np.linalg.inv(X.T @ X))) return b, se, 1 - (e @ e) / ((y - y.mean()) ** 2).sum() y = air - 0.0025 b1, se1, r1 = fit(np.column_stack([np.ones(60), f - 0.0025]), y) b2, se2, r2 = fit(np.column_stack([np.ones(60), f - 0.0025, oil]), y) print(np.round(b1[1:], 4), np.round(se1[1:], 4), round(r1, 4)) print(np.round(b2[1:], 4), np.round(se2[1:], 4), round(r2, 4)) q = stats.t.ppf(0.975, 57) print(np.round(b2[1:] / se2[1:], 2), round(2 * stats.t.sf(abs(b2[2] / se2[2]), 57), 4), np.round(b2[1:] - q * se2[1:], 4), np.round(b2[1:] + q * se2[1:], 4)) delta = np.cov(oil, f)[0, 1] / np.var(f, ddof=1) print(round(delta, 4), round(b2[1] + b2[2] * delta, 4)) vol = lambda r: round(100 * np.std(r, ddof=1), 2) print(vol(air), vol(air - b1[1] * f), vol(air - b2[1] * f), vol(air - b2[1] * f - b2[2] * oil))

⌘/Ctrl + Enter runs the cell

Check yourself

The airline's beta is 0.96 against the market alone and 1.10 with oil in the regression. The desk can trade index futures but not oil futures. Which ratio should it sell per dollar of airline?

0.96: with the index alone, the one-factor slope is the minimum-variance hedge1.10: it is the true market beta, free of the omitted-variable bias1.10 − 0.33 = 0.77, to allow for oil

On the desk: conventions and traps

Excess or raw returns. Regressing raw returns gives the same beta but the intercept $-0.1764\%$ a month instead of $-0.1384\%$ . The two differ by $r_f(\hat{\beta} - 1) = 0.038\%$ , small here because beta is near 1. Report alpha from excess returns.
Units. Coefficients here are per month. Multiply alpha and its standard error by 12 for a year: alpha is a mean, which grows with time. Beta has no units. With every return in percent, alpha and its standard error are 100 times larger, and beta and every t statistic are unchanged.
The assumptions behind the standard errors. They assume constant variance and uncorrelated errors (lesson 5.10.3). Volatility that changes over time breaks the first; overlapping returns, such as 12-month returns taken every month, break the second. Robust standard errors are the usual check.
Outliers. A crash month can have high leverage (lesson 5.10.2) and move beta alone. Refit without it and compare; real returns have fat tails (case study 5.4.6).
The index sets the beta. A beta against a national stock index is not a beta against the whole market (lesson 4.6.3).
Daily data. More observations shrink standard errors. But a stock that trades rarely reacts to the index a day late, which pulls a daily beta towards 0.
The window. Here 60 months give a standard error of 0.093 and 24 months 0.11 to 0.18. Do not read a trend into rolling betas before comparing their moves with their standard errors.

Try it The first lines fit the raw returns and check the gap between the two intercepts. The last line refits everything in percent.

import numpy as np rng = np.random.default_rng(355) index = rng.normal(0.006, 0.045, 60) stock = 0.003 + 1.2 * index + rng.normal(0, 0.035, 60) f, x = np.round(index, 4), np.round(stock, 4) def fit(fm, xs): X = np.column_stack([np.ones(len(fm)), fm]) b = np.linalg.lstsq(X, xs, rcond=None)[0] e = xs - X @ b return b, np.sqrt(e @ e / (len(fm) - 2) * np.diag(np.linalg.inv(X.T @ X))) raw, _ = fit(f, x) ex, se = fit(f - 0.0025, x - 0.0025) print(np.round(raw, 6), np.round(ex, 6), round(ex[0] - raw[0], 6), round(0.0025 * (ex[1] - 1), 6)) pc, se_pc = fit(100 * (f - 0.0025), 100 * (x - 0.0025)) print(np.round(pc, 4), np.round(se_pc, 4), np.round(ex / se, 4), np.round(pc / se_pc, 4))

⌘/Ctrl + Enter runs the cell

Exercise

Beta, alpha and rolling betas by regression

Write two functions with NumPy, as in this case study.

capm_regression(stock, market, rf) returns (alpha, beta, se_alpha, se_beta), per period. It regresses the stock's excess returns on the market's; rf is one number or one rate per period. The standard errors are those of lesson 5.10.3, with $n - 2$ degrees of freedom.
rolling_beta(stock, market, rf, window) returns two arrays, (betas, ses): beta and its standard error on each run of window consecutive periods, in time order. There are $n -$ window $+ 1$ of them.

Raise ValueError when the series have different lengths or fewer than three periods, or when the market's excess return is constant. Raise it too when window is not a whole number from 3 to $n$ .

The tests use case study 3.5.5's 60 months: the beta, alpha and standard errors above, and the rolling 24-month betas. They also try $r_f = 0$ , a rate per month, percent units and each bad input.

See the tests

import numpy as np


def _data():
    rng = np.random.default_rng(355)
    index = rng.normal(0.006, 0.045, 60)
    stock = 0.003 + 1.2 * index + rng.normal(0, 0.035, 60)
    return np.round(stock, 4), np.round(index, 4)


def _raises(f, *args, what=""):
    try:
        f(*args)
    except ValueError:
        return
    raise AssertionError(f"expected ValueError: {what}")


def test_beta():
    """The 60 months give beta 1.1518 with standard error 0.0929"""
    stock, market = _data()
    alpha, beta, se_a, se_b = capm_regression(stock, market, 0.0025)
    expect_close(beta, np.cov(stock, market)[0, 1] / np.var(market, ddof=1), what="beta")
    expect_close(se_b, 0.092944, rel=1e-4, what="se of beta")


def test_alpha():
    """The 60 months give alpha −0.1384% a month with standard error 0.436%"""
    stock, market = _data()
    alpha, beta, se_a, se_b = capm_regression(stock, market, 0.0025)
    expect_close(alpha, -0.001384, rel=1e-3, what="alpha")
    expect_close(se_a, 0.00436, rel=1e-3, what="se of alpha")


def test_rf_moves_alpha_not_beta():
    """With rf = 0 beta is unchanged and alpha moves by rf(1 − beta)"""
    stock, market = _data()
    a0, b0, _, se0 = capm_regression(stock, market, 0.0)
    a1, b1, _, se1 = capm_regression(stock, market, 0.0025)
    expect_close(b0, b1, what="beta with rf = 0")
    expect_close(se0, se1, what="se of beta with rf = 0")
    expect_close(a1 - a0, -0.0025 * (1 - b1), what="change in alpha")


def test_rf_per_month():
    """A risk-free rate given month by month gives the same answers as one number"""
    stock, market = _data()
    expect_close(capm_regression(stock, market, np.full(60, 0.0025)), capm_regression(stock, market, 0.0025), what="rf as an array")


def test_percent_units():
    """Returns in percent give the same beta and an alpha 100 times larger"""
    stock, market = _data()
    a, b, _, _ = capm_regression(stock, market, 0.0025)
    ap, bp, _, _ = capm_regression(100 * stock, 100 * market, 0.25)
    expect_close(bp, b, what="beta in percent")
    expect_close(ap, 100 * a, what="alpha in percent")


def test_rolling():
    """Rolling 24-month betas: 37 of them, from 0.9518 to 1.3486, with standard errors from 0.1102 to 0.1797"""
    stock, market = _data()
    betas, ses = rolling_beta(stock, market, 0.0025, 24)
    expect_equal(len(betas), 37, what="number of 24-month windows in 60 months")
    expect_close([betas.min(), betas.max()], [0.951770, 1.348637], rel=1e-5, what="smallest and largest beta")
    expect_close([ses.min(), ses.max()], [0.110216, 0.179719], rel=1e-5, what="smallest and largest standard error")


def test_full_window():
    """A window of all 60 months gives one beta, the full-sample one"""
    stock, market = _data()
    betas, ses = rolling_beta(stock, market, 0.0025, 60)
    expect_close(betas, [capm_regression(stock, market, 0.0025)[1]], what="betas with window 60")


def test_bad_inputs():
    """Different lengths, a constant market, a window below 3 or above the data raise ValueError"""
    stock, market = _data()
    _raises(capm_regression, stock, market[:59], 0.0025, what="60 and 59 returns")
    _raises(capm_regression, stock, np.full(60, 0.01), 0.0025, what="a constant market")
    _raises(capm_regression, stock[:2], market[:2], 0.0025, what="two periods")
    _raises(rolling_beta, stock, market, 0.0025, 2, what="window 2")
    _raises(rolling_beta, stock, market, 0.0025, 61, what="window 61 with 60 months")
    _raises(rolling_beta, stock, market[:50], 0.0025, 24, what="different lengths")

R_t - r_f = \alpha + \beta(R_{M,t} - r_f) + \varepsilon_t

Case study: estimating beta and hedge ratios

Beta and alpha by regression

Rule: Beta and alpha by regression

How precise are beta and alpha?

What the uncertainty costs the hedge

Rolling estimates

Two factors

Rule: A two-factor regression

Which beta hedges?

Beta, alpha and rolling betas by regression

Summary card

Free further reading