Thinking One Move Ahead: Multi-Period Portfolio Optimization

Chinese

In the earlier article Portfolio Optimization for Long-Only Multi-Factor Equity Strategies, I gave a fairly complete introduction to how the problem of solving single-period portfolio weights can be transformed into a quadratic program. This article summarizes the key ideas of the Stanford and BlackRock collaboration paper Multi-Period Trading via Convex Optimization. Published in 2017, that paper offered one of the first systematic treatments of multi-period optimization in portfolio management.

This article includes AI-assisted writing.

Model

Assets and Cash

Consider a portfolio consisting of \(n\) assets and one cash account over a finite horizon of \(T\) discrete time periods. Let \(h_t \in \mathbb{R}^{n+1}\) denote the holdings at time \(t\), where \((h_t)i\) is the dollar value of asset \(i\) and \((h_t){n+1}\) is the cash balance. The total portfolio value is \(v_t = 1^T h_t\), and the portfolio weights are \(w_t = h_t / v_t\).

Trading

Assume all trades occur at the beginning of each period. The trade vector \(u_t \in \mathbb{R}^n\) represents dollar trades at time \(t\), where \(u_{ti} > 0\) means buying asset \(i\) and \(u_{ti} < 0\) means selling asset \(i\). The post-trade holdings satisfy \(h_{t+1} = h_t + u_t\), and post-trade cash is

$$ (h_{t+1})_{n+1} = (h_t)_{n+1} - 1^T u_t $$

Transaction Costs

For example, transaction costs can be modeled as a combination of linear and fixed costs:

$$ \text{transaction cost} = \gamma^T |u_t| + \delta^T \mathbf{1}_{|u_t| > 0} $$

where \(\gamma\) is the per-unit trading cost vector and \(\delta\) is the fixed cost vector for each trade.

Holding Costs

Holding costs can include borrowing costs and management fees:

$$ \text{holding cost} = \lambda^T h_t + \mu^T \mathbf{1}_{h_t < 0} $$

where \(\lambda\) is the per-unit holding cost and \(\mu\) is the per-unit borrowing cost.

Self-Financing Constraint

The self-financing condition requires that the cash balance remain nonnegative in each period:

$$ (h_{t+1})_{n+1} = (h_t)_{n+1} - 1^T u_t \geq 0 $$

Single-Period Optimization (SPO)

Single-period optimization (SPO) is a common portfolio optimization approach that seeks to maximize expected return over one period while controlling risk and trading costs. Its defining feature is that the decision is made only for the current period, without explicitly modeling future periods.

Objective Function

In SPO, the objective is typically to maximize risk-adjusted return. A representative formulation is

$$ \max_{w_t} \left( r_t^T w_t - \gamma_t \psi_t(w_t) - \phi_{\text{hold}, t} (w_t) - \phi_{\text{trade}, t} (w_t - w_{t-1}) \right) $$

where:

• \(w_t\) is the asset weight vector at time \(t\).
• \(r_t\) is the expected return vector at time \(t\).
• \(\gamma_t\) is the risk-aversion parameter.
• \(\psi_t(w_t)\) is the risk function at time \(t\).
• \(\phi_{\text{hold}, t}(w_t)\) is the holding cost.
• \(\phi_{\text{trade}, t}(w_t - w_{t-1})\) is the trading cost.

Constraints

The SPO problem must satisfy a set of constraints to ensure feasibility and portfolio discipline. Common constraints include:

• The weights sum to one:

  $$ \sum_{i=1}^{n} (w_{t})_i = 1 $$

• The weights are nonnegative:

  $$ w_t \geq 0 $$

These ensure the portfolio is a valid long-only allocation.

Solving the Problem

Single-period optimization is usually solved by convex optimization tools such as cvxpy. A simple example is shown below:

import cvxpy as cp
import numpy as np

# Set parameters
n = 5  # number of assets
r_t = np.random.randn(n)  # expected returns for the current period
gamma_t = 10  # risk aversion
Sigma_t = np.random.rand(n, n)  # risk matrix
Sigma_t = np.dot(Sigma_t, Sigma_t.T)  # make it positive semidefinite
phi_hold_t = np.random.rand(n)  # holding cost
phi_trade_t = np.random.rand(n)  # trading cost
w_t_1 = np.ones(n) / n  # weights in the previous period

# Decision variable
w_t = cp.Variable(n)

# Objective
objective = cp.Maximize(
    r_t.T @ w_t
    - gamma_t * cp.quad_form(w_t, Sigma_t)
    - phi_hold_t.T @ w_t
    - phi_trade_t.T @ cp.abs(w_t - w_t_1)
)

# Constraints
constraints = [cp.sum(w_t) == 1, w_t >= 0]

# Optimization problem
prob = cp.Problem(objective, constraints)
prob.solve()

# Output
print("Optimal asset weights:")
print(w_t.value)

Summary

SPO is a portfolio optimization method tailored to a single time period. Its goal is to maximize current-period risk-adjusted return. While it can produce effective allocation decisions for the next step, it does not account for future periods or the impact of today’s decision on tomorrow’s position. For long-horizon investing, that is a real limitation.

Multi-Period Optimization (MPO)

Multi-period optimization explicitly considers asset allocation and trading decisions across multiple future periods. By planning over a longer horizon, it can improve total portfolio performance. For example, suppose we expect short-term returns to be positive but long-term returns to be negative. SPO may chase the next-period gain and leave the portfolio trapped in an unfavorable future position, forcing a costly exit. MPO can do better by accounting for both transaction costs and the changing return outlook.

Objective Function

The multi-period problem is typically solved over a planning horizon extending several periods into the future. At each time step we choose a trade vector \(z_t\), and use an optimization problem to plan over the next \(H\) periods:

$$ t, t+1, \ldots, t+H-1 $$

The objective is to maximize risk-adjusted return over the full horizon. For the planning range from \(t\) to \(t+H-1\), the problem can be written as

$$ \sum_{\tau=t}^{t+H-1} \left( r_{\tau|t}^T (w_\tau + z_\tau) - \gamma_\tau \psi_\tau(w_\tau + z_\tau) - \phi_{\text{hold}, \tau} (w_\tau + z_\tau) - \phi_{\text{trade}, \tau} (z_\tau) \right) $$

where:

• \(r_{\tau|t}\) is the estimate made at time \(t\) of return in period \(\tau\).
• \(w_\tau\) is the asset weight vector at period \(\tau\).
• \(z_\tau\) is the trade vector at period \(\tau\).
• \(\gamma_\tau\) is the risk-aversion parameter.
• \(\psi_\tau\) is the risk function.
• \(\phi_{\text{hold}, \tau}\) is the holding-cost function.
• \(\phi_{\text{trade}, \tau}\) is the trading-cost function.

The dynamics of portfolio weights can be written as

$$ w_{t+1} = \frac{1}{1 + R_t^p} (1 + r_t) \circ (w_t + z_t) $$

where \(R_t^p\) is the risk-free rate, \(r_t\) is the asset return vector, and \(\circ\) denotes elementwise multiplication.

Under a simplifying assumption, we ignore changes in weights caused by price movements:

$$ w_{\tau+1} = w_\tau + z_\tau, \quad \tau = t, \ldots, t+H-1 $$

The problem is then equivalent to

$$ \max \sum_{\tau=t+1}^{t+H} \left( r_{\tau|t}^T w_\tau - \gamma_\tau \psi_\tau (w_\tau) - \phi_{\text{hold}, \tau} (w_\tau) - \phi_{\text{trade}, \tau} (w_\tau - w_{\tau-1}) \right) $$

with decision variables given by the future weights \(w_{t+1}, \ldots, w_{t+H}\).

Solving the Problem

Below is a simple example showing how to implement multi-period optimization in cvxpy:

import cvxpy as cp
import numpy as np

# Set parameters
n = 5  # number of assets
T = 10  # number of periods

# Generate random data
np.random.seed(42)
r = np.random.randn(T, n)  # asset returns
gamma = 0.1  # risk-aversion parameter
phi_hold = np.random.rand(T, n)  # holding costs
phi_trade = np.random.rand(T, n)  # trading costs
Sigma = np.random.rand(T, n, n)  # risk matrices
Sigma = np.array([np.dot(S, S.T) for S in Sigma])  # make them positive semidefinite

# Initial portfolio weights
w0 = np.ones(n) / n

# Decision variables
w = cp.Variable((T, n))  # weights in each period
z = cp.Variable((T, n))  # trades in each period

# Objective
objective = 0
for t in range(T):
    if t == 0:
        prev_w = w0
    else:
        prev_w = w[t - 1]
    objective += (
        r[t] @ w[t]
        - gamma * cp.quad_form(w[t], Sigma[t])
        - phi_hold[t] @ w[t]
        - phi_trade[t] @ cp.abs(z[t])
    )

# Constraints
constraints = []
for t in range(T):
    if t > 0:
        constraints.append(w[t] == w[t - 1] + z[t])
    constraints.append(cp.sum(w[t]) == 1)
    constraints.append(w[t] >= 0)

# Optimization problem
prob = cp.Problem(cp.Maximize(objective), constraints)
prob.solve()

# Output
print("Optimal asset weights:")
print(w.value)
print("Optimal trade vectors:")
print(z.value)

Code notes

1. Parameter setup

   • n is the number of assets.
   • T is the number of periods.
   • H is the planning horizon.

2. Random data generation

   • r is the matrix of asset returns with shape (T, n).
   • gamma is the risk-aversion parameter.
   • phi_hold and phi_trade are holding-cost and trading-cost matrices with shape (T, n).
   • Sigma is the risk tensor with shape (T, n, n).

3. Initial weights

   • w0 is the initial portfolio, assumed to be equally weighted.

4. Decision variables

   • w stores the asset weights in each period.
   • z stores the trade vectors in each period.

5. Objective

   • The goal is to maximize risk-adjusted return over the full horizon.

6. Constraints

   • w[t] is the weight vector in period t.
   • z[t] is the trade vector in period t.
   • The constraints enforce full investment and nonnegative weights.

7. Optimization

   • The problem is defined and solved with cvxpy.

8. Output

   • The code prints the optimal weights and trade vectors.

This example illustrates how cvxpy can be used to implement MPO. The approach can handle allocation and trading decisions across multiple future periods and thereby improve overall portfolio behavior.