Portfolio Optimization with Stock Data

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import yfinance as yf

from scipy.optimize import minimize

pd.set_option("display.float_format", lambda x: f"{x:.4f}")

# ------------------------------------------------------------
# SETTINGS
# ------------------------------------------------------------

# Assets used in the original assignment.
tickers = ["AAPL", "AMZN", "BRK-B", "DAX", "DOW", "NKE"]

start_date = "2020-01-01"
end_date = "2023-01-01"
trading_days = 252

# ------------------------------------------------------------
# DOWNLOAD PRICE DATA
# ------------------------------------------------------------

price_data = yf.download(
    tickers,
    start=start_date,
    end=end_date,
    auto_adjust=False,
    progress=False
)

# With several tickers, yfinance returns a DataFrame with multi-level columns.
# For the portfolio calculation we only need closing prices.
if isinstance(price_data.columns, pd.MultiIndex):
    raw_data = price_data["Close"].copy()
else:
    raw_data = price_data[["Close"]].copy()
    raw_data.columns = tickers

# Keep the downloaded tickers in the same order as the original ticker list.
available_tickers = [ticker for ticker in tickers if ticker in raw_data.columns]
missing_tickers = sorted(set(tickers) - set(available_tickers))

if missing_tickers:
    print("Missing tickers from the downloaded data:", missing_tickers)

raw_data = raw_data[available_tickers]
raw_data = raw_data.dropna(how="all").ffill().dropna()

# ------------------------------------------------------------
# LOG RETURNS AND ANNUALIZED MOMENTS
# ------------------------------------------------------------

log_returns = np.log(raw_data / raw_data.shift(1)).dropna()

expected_returns = log_returns.mean() * trading_days
cov_matrix = log_returns.cov() * trading_days

summary_table = pd.DataFrame({
    "Annualized expected return": expected_returns,
    "Annualized volatility": np.sqrt(np.diag(cov_matrix))
})

print("First rows of the price data:")
display(raw_data.head())

print("Annualized return and risk measures:")
display(summary_table)

print("Annualized covariance matrix:")
display(cov_matrix)

def solve_min_variance_portfolio(target_return, allow_short=True):
    # Solve the minimum-variance portfolio problem for a given target return.
    mu = expected_returns.to_numpy()
    sigma = cov_matrix.to_numpy()
    asset_names = expected_returns.index
    n_assets = len(asset_names)

    def portfolio_variance(weights):
        return float(weights.T @ sigma @ weights)

    constraints = [
        {
            "type": "eq",
            "fun": lambda weights: np.sum(weights) - 1
        },
        {
            "type": "eq",
            "fun": lambda weights: weights @ mu - target_return
        }
    ]

    bounds = None if allow_short else [(0, 1) for _ in range(n_assets)]
    initial_weights = np.repeat(1 / n_assets, n_assets)

    result = minimize(
        portfolio_variance,
        initial_weights,
        method="SLSQP",
        bounds=bounds,
        constraints=constraints,
        options={"ftol": 1e-12, "maxiter": 1000}
    )

    if not result.success:
        raise RuntimeError(f"Optimization failed: {result.message}")

    weights = pd.Series(result.x, index=asset_names, name="Weight")
    portfolio_return = float(weights @ expected_returns)
    portfolio_variance_value = portfolio_variance(weights.to_numpy())
    portfolio_volatility = np.sqrt(portfolio_variance_value)

    return {
        "weights": weights,
        "return": portfolio_return,
        "variance": portfolio_variance_value,
        "volatility": portfolio_volatility
    }


# ------------------------------------------------------------
# EFFICIENT PORTFOLIO WITH AN 8% TARGET RETURN, SHORT-SELLING ALLOWED
# ------------------------------------------------------------

target_return = 0.08
portfolio_8_short = solve_min_variance_portfolio(
    target_return=target_return,
    allow_short=True
)

weights_8_short = portfolio_8_short["weights"].to_frame()
weights_8_short["Weight, %"] = 100 * weights_8_short["Weight"]

performance_8_short = pd.DataFrame({
    "Measure": ["Target return", "Achieved expected return", "Variance", "Volatility"],
    "Value": [
        target_return,
        portfolio_8_short["return"],
        portfolio_8_short["variance"],
        portfolio_8_short["volatility"]
    ]
})

print("Optimal portfolio weights for an 8% target return, with short-selling:")
display(weights_8_short)

print("Portfolio performance measures:")
display(performance_8_short)

def build_frontier(target_returns, allow_short=True):
    # Compute frontier portfolios over a grid of target returns.
    rows = []

    for target in target_returns:
        try:
            solution = solve_min_variance_portfolio(
                target_return=target,
                allow_short=allow_short
            )

            rows.append({
                "target_return": target,
                "expected_return": solution["return"],
                "volatility": solution["volatility"],
                "variance": solution["variance"]
            })
        except RuntimeError:
            # Some targets may be infeasible, especially under no-short-sales constraints.
            # Skipping infeasible points makes the function usable in both cases.
            continue

    return pd.DataFrame(rows)


# ------------------------------------------------------------
# FRONTIER PORTFOLIOS WITH SHORT-SELLING
# ------------------------------------------------------------

min_target = expected_returns.min() - 0.10
max_target = expected_returns.max() + 0.10
frontier_targets_short = np.linspace(min_target, max_target, 200)

frontier_short = build_frontier(
    target_returns=frontier_targets_short,
    allow_short=True
)

plt.figure(figsize=(8, 5))
plt.plot(
    frontier_short["volatility"],
    frontier_short["expected_return"],
    label="Frontier with short-selling"
)
plt.scatter(
    portfolio_8_short["volatility"],
    portfolio_8_short["return"],
    marker="o",
    label="8% target return"
)
plt.axhline(target_return, linestyle="--", linewidth=1)

plt.xlabel("Annualized volatility")
plt.ylabel("Annualized expected return")
plt.title("Frontier portfolios with short-selling")
plt.grid(True, linestyle="--", alpha=0.6)
plt.legend()
plt.show()

# ------------------------------------------------------------
# EFFICIENT PORTFOLIO WITH AN 8% TARGET RETURN, NO SHORT-SELLING
# ------------------------------------------------------------

portfolio_8_no_short = solve_min_variance_portfolio(
    target_return=target_return,
    allow_short=False
)

weights_8_no_short = portfolio_8_no_short["weights"].to_frame()
weights_8_no_short["Weight, %"] = 100 * weights_8_no_short["Weight"]

performance_8_no_short = pd.DataFrame({
    "Measure": ["Target return", "Achieved expected return", "Variance", "Volatility"],
    "Value": [
        target_return,
        portfolio_8_no_short["return"],
        portfolio_8_no_short["variance"],
        portfolio_8_no_short["volatility"]
    ]
})

print("Optimal portfolio weights for an 8% target return, without short-selling:")
display(weights_8_no_short)

print("Portfolio performance measures:")
display(performance_8_no_short)

# ------------------------------------------------------------
# FRONTIER PORTFOLIOS WITHOUT SHORT-SELLING
# ------------------------------------------------------------

frontier_targets_no_short = np.linspace(
    expected_returns.min(),
    expected_returns.max(),
    200
)

frontier_no_short = build_frontier(
    target_returns=frontier_targets_no_short,
    allow_short=False
)

plt.figure(figsize=(8, 5))
plt.plot(
    frontier_no_short["volatility"],
    frontier_no_short["expected_return"],
    label="Frontier without short-selling"
)
plt.scatter(
    portfolio_8_no_short["volatility"],
    portfolio_8_no_short["return"],
    marker="o",
    label="8% target return"
)
plt.axhline(target_return, linestyle="--", linewidth=1)

plt.xlabel("Annualized volatility")
plt.ylabel("Annualized expected return")
plt.title("Frontier portfolios without short-selling")
plt.ylim(expected_returns.min() - 0.02, expected_returns.max() + 0.02)
plt.grid(True, linestyle="--", alpha=0.6)
plt.legend()
plt.show()

# ------------------------------------------------------------
# COMPARISON OF SHORT-SELLING AND NO-SHORT-SALES RESULTS
# ------------------------------------------------------------

comparison_table = pd.DataFrame({
    "With short-selling": [
        portfolio_8_short["return"],
        portfolio_8_short["variance"],
        portfolio_8_short["volatility"]
    ],
    "Without short-selling": [
        portfolio_8_no_short["return"],
        portfolio_8_no_short["variance"],
        portfolio_8_no_short["volatility"]
    ]
}, index=["Achieved expected return", "Variance", "Volatility"])

comparison_table["Difference, no-short minus short"] = (
    comparison_table["Without short-selling"] - comparison_table["With short-selling"]
)

weights_comparison = pd.DataFrame({
    "With short-selling": portfolio_8_short["weights"],
    "Without short-selling": portfolio_8_no_short["weights"]
})
weights_comparison["Difference, no-short minus short"] = (
    weights_comparison["Without short-selling"] - weights_comparison["With short-selling"]
)

print("Comparison of the portfolios with an 8% target return:")
display(comparison_table)

print("Comparison of portfolio weights:")
display(weights_comparison)

plt.figure(figsize=(8, 5))
plt.plot(
    frontier_short["volatility"],
    frontier_short["expected_return"],
    label="With short-selling"
)
plt.plot(
    frontier_no_short["volatility"],
    frontier_no_short["expected_return"],
    label="Without short-selling"
)
plt.scatter(
    portfolio_8_short["volatility"],
    portfolio_8_short["return"],
    marker="o",
    label="8%, with short-selling"
)
plt.scatter(
    portfolio_8_no_short["volatility"],
    portfolio_8_no_short["return"],
    marker="x",
    label="8%, without short-selling"
)
plt.axhline(target_return, linestyle="--", linewidth=1)

plt.xlabel("Annualized volatility")
plt.ylabel("Annualized expected return")
plt.title("Comparison of short-selling and no-short-sales frontiers")
plt.grid(True, linestyle="--", alpha=0.6)
plt.legend()
plt.show()