Advanced Portfolio Construction Techniques › Integrating Multiple Techniques

def integrated_portfolio_optimization(
    returns,
    market_weights,
    views_P=None,
    views_Q=None,
    views_confidence=None,
    risk_budget=None,
    min_weight=0.0,
    max_weight=0.4,
    prev_weights=None,
    max_turnover=0.2,
    transaction_cost=0.001,
):
    """
    Integrated portfolio construction combining multiple techniques.
    """
    n = returns.shape[1]

    # Step 1: Estimate covariance with shrinkage
    lw = LedoitWolf().fit(returns)
    cov = lw.covariance_ * 12

    # Step 2: Black-Litterman expected returns
    delta = 2.5
    tau = 0.05
    pi = delta * cov @ market_weights

    if views_P is not None and views_Q is not None:
        omega = (
            np.diag(views_confidence)
            if views_confidence is not None
            else np.eye(len(views_Q)) * 0.01
        )
        mu, _ = black_litterman(pi, cov, views_P, views_Q, omega, tau)
    else:
        mu = pi

    # Step 3: Risk-aware optimization
    def objective(w):
        # Expected return component
        ret = w @ mu

        # Risk component with risk budgeting penalty
        port_var = w @ cov @ w
        port_vol = np.sqrt(port_var + 1e-10)

        if risk_budget is not None:
            rc = w * (cov @ w) / port_vol
            rc_pct = rc / port_vol
            risk_penalty = 10 * np.sum((rc_pct - risk_budget) ** 2)
        else:
            risk_penalty = 0

        # Transaction cost penalty
        if prev_weights is not None:
            tc_penalty = transaction_cost * np.sum(np.abs(w - prev_weights))
        else:
            tc_penalty = 0

        return -(ret - 2.5 * port_var - risk_penalty - tc_penalty)

    # Constraints
    constraints = [{"type": "eq", "fun": lambda w: np.sum(w) - 1}]

    if prev_weights is not None and max_turnover is not None:
        constraints.append(
            {
                "type": "ineq",
                "fun": lambda w: (
                    max_turnover - 0.5 * np.sum(np.abs(w - prev_weights))
                ),
            }
        )

    bounds = [(min_weight, max_weight) for _ in range(n)]

    w0 = prev_weights if prev_weights is not None else np.ones(n) / n
    result = minimize(
        objective,
        w0,
        method="SLSQP",
        constraints=constraints,
        bounds=bounds,
        options={"maxiter": 1000},
    )

    return result.x, mu, cov


# Define parameters
risk_budget_target = np.array([0.18, 0.22, 0.22, 0.18, 0.20])
min_w_int, max_w_int = 0.05, 0.35
max_turn_int = 0.15
tc_cost = 0.001

# Apply integrated approach
w_integrated, mu_integrated, cov_integrated = integrated_portfolio_optimization(
    returns,
    w_mkt,
    views_P=P,
    views_Q=Q,
    views_confidence=[0.02**2, 0.01**2],
    risk_budget=risk_budget_target,
    min_weight=min_w_int,
    max_weight=max_w_int,
    prev_weights=prev_weights,
    max_turnover=max_turn_int,
    transaction_cost=tc_cost,
)