Capital Market Theory - CAPM and the Efficient Frontier › Complete CAPM Implementation

import numpy as np
from scipy import stats


class CAPMAnalysis:
    """
    Complete CAPM analysis toolkit for portfolio and security analysis.
    """

    def __init__(self, returns_df, market_returns, rf_rate):
        """
        Initialize with return data.

        Parameters:
        -----------
        returns_df : pd.DataFrame
            Asset returns with assets as columns
        market_returns : pd.Series
            Market index returns
        rf_rate : float
            Risk-free rate (same frequency as returns)
        """
        self.returns = returns_df
        self.market_returns = market_returns
        self.rf = rf_rate
        self.excess_returns = returns_df.subtract(rf_rate, axis=0)
        self.market_excess = market_returns - rf_rate
        self.betas = {}
        self.alphas = {}
        self.r_squared = {}

    def estimate_betas(self):
        """Estimate beta for each asset using OLS regression."""
        for asset in self.returns.columns:
            slope, intercept, r_value, _, _ = stats.linregress(
                self.market_excess, self.excess_returns[asset]
            )
            self.betas[asset] = slope
            self.alphas[asset] = intercept
            self.r_squared[asset] = r_value**2
        return self.betas

    def get_capm_expected_return(self, beta):
        """Calculate CAPM expected return for a given beta."""
        market_premium = self.market_returns.mean() - self.rf
        return self.rf + beta * market_premium

    def security_market_line(self, beta_range=None):
        """Generate Security Market Line data."""
        if beta_range is None:
            beta_range = np.linspace(0, 2, 100)
        market_premium = self.market_returns.mean() - self.rf
        expected_returns = self.rf + beta_range * market_premium
        return beta_range, expected_returns

    def portfolio_beta(self, weights):
        """Calculate portfolio beta as weighted average."""
        if not self.betas:
            self.estimate_betas()
        beta_values = [self.betas[asset] for asset in self.returns.columns]
        return np.dot(weights, beta_values)

    def tracking_error(self, weights, target_beta=1.0):
        """Calculate deviation from target beta."""
        return abs(self.portfolio_beta(weights) - target_beta)

# Generate realistic simulated data for demonstration
np.random.seed(2024)
n_periods_full = 60  # 5 years monthly

# Market returns
market_ret = np.random.normal(0.008, 0.04, n_periods_full)

# Asset characteristics
assets = {
    "Tech_Growth": {"beta": 1.4, "alpha": 0.003, "idio_vol": 0.06},
    "Large_Value": {"beta": 0.9, "alpha": 0.001, "idio_vol": 0.03},
    "Utilities": {"beta": 0.5, "alpha": 0.0005, "idio_vol": 0.02},
    "Healthcare": {"beta": 0.7, "alpha": 0.002, "idio_vol": 0.035},
    "Financials": {"beta": 1.2, "alpha": -0.001, "idio_vol": 0.05},
    "Consumer": {"beta": 0.85, "alpha": 0.0015, "idio_vol": 0.03},
    "Energy": {"beta": 1.1, "alpha": -0.002, "idio_vol": 0.055},
    "Real_Estate": {"beta": 0.95, "alpha": 0.001, "idio_vol": 0.04},
}

rf_monthly = 0.003  # ~3.6% annual

# Generate returns
returns_data = {}
for name, params in assets.items():
    idio = np.random.normal(0, params["idio_vol"], n_periods_full)
    returns_data[name] = (
        rf_monthly
        + params["alpha"]
        + params["beta"] * (market_ret - rf_monthly)
        + idio
    )

returns_df = pd.DataFrame(returns_data)
market_series = pd.Series(market_ret, name="Market")

# Run CAPM analysis
capm = CAPMAnalysis(returns_df, market_series, rf_monthly)
capm.estimate_betas()

# Create summary DataFrame
summary_data = []
for asset in returns_df.columns:
    actual_ret = returns_df[asset].mean()
    expected_ret = capm.get_capm_expected_return(capm.betas[asset])
    summary_data.append(
        {
            "Asset": asset,
            "Beta": capm.betas[asset],
            "R²": capm.r_squared[asset],
            "Actual Return": actual_ret * 12,  # Annualized
            "CAPM Expected": expected_ret * 12,  # Annualized
            "Alpha (Annual)": capm.alphas[asset] * 12,
        }
    )

summary_df = pd.DataFrame(summary_data)