7.3. Modeling and Optimization with CVXPY

CVXPY is a domain-specific language (DSL) based on Python for modeling and solving convex optimization problems. It supports multiple solvers (e.g., ECOS, SCS) and is renowned for its concise mathematical syntax and automatic differentiation. It is widely used in fields such as machine learning, finance, and engineering optimization.

Currently, with the CVXPY plugin we provide, users can model problems using CVXPY and invoke MindOpt for solving. For more details about CVXPY, please refer to the CVXPY Official Documentation.

In this section, we will demonstrate how to use the CVXPY API to implement a Mixed-Integer Linear Programming (MILP) model for optimizing a stock portfolio under budget constraints, risk constraints, and minimum trade lot restrictions.

7.3.1. Installing CVXPY

Users must first install mindoptpy. For installation and configuration of mindoptpy, please refer to Install mindoptpy Library. After installing mindoptpy, users can install CVXPY via the following pip command:

pip install cvxpy

For detailed CVXPY installation instructions, refer to CVXPY Installation.

7.3.2. CVXPY Interface

MindOpt provides two distinct plugin interfaces for CVXPY: mindopt_qpif.py and mindopt_conif.py.

Using these plugins, users can model and solve linear programming problems (LP), mixed-integer linear programming problems (MILP), convex quadratic programming problems (convex QP), second-order cone programming problems (SOCP), and mixed-integer convex quadratic programming problems (convex MIQP).

7.3.2.1. Modeling and Solving with CVXPY Interface

MindOpt defines the required implementations for CVXPY to call MindOpt in the interface files (mindopt_qpif.py, mindopt_conif.py). These interfaces inherit from CVXPY’s QPSolver and ConicSolver classes. For implementation details, refer to the interface files in the installation package:

<MDOHOME>/<VERSION>/<PLATFORM>/lib/cvxpy/mindopt_conif.py
<MDOHOME>/<VERSION>/<PLATFORM>/lib/cvxpy/mindopt_qpif.py

To use them, users must first copy these two interface files to the project directory as part of the source code and import the relevant implementations in Python:

from mindopt_conif import *
from mindopt_qpif import *

Next, we use the CVXPY API to build a stock portfolio optimization problem. For detailed CVXPY API documentation, refer to the CVXPY API Official Documentation.

stocks = ["AAPL", "MSFT", "GOOG", "AMZN", "META"]  # Stock tickers
n_assets = len(stocks)

current_prices = np.array([180, 320, 140, 130, 350])  # Current stock prices (USD/share)

expected_returns = np.array(
    [0.08, 0.12, 0.10, 0.15, 0.18]
)  # Expected annual returns (decimal)

betas = np.array([1.2, 0.9, 1.1, 1.4, 1.3])  # Stock beta coefficients (systematic risk)

total_budget = 100000  # Total investment budget (USD)

min_lot_size = (
    100  # # Minimum trading lot size (shares per lot, standard for Chinese A-shares)
)

max_beta = 1.2  # Maximum portfolio beta threshold

x = cp.Variable(
    n_assets, integer=True
)  # Integer variable: number of lots to purchase per stock
y = cp.Variable(nonneg=True)  # Auxiliary variable for linearization (if needed)

invest_amount = cp.multiply(
    current_prices * min_lot_size, x
)  # Investment amount per stock (USD)

total_return = cp.sum(
    cp.multiply(expected_returns, invest_amount)
)  # Objective: Maximize portfolio return
objective = cp.Maximize(total_return)

constraints = [
    # Budget constraint
    cp.sum(invest_amount) <= total_budget,
    # Risk constraint (linearized form)
    cp.sum(cp.multiply(betas, invest_amount)) <= max_beta * cp.sum(invest_amount),
    # Diversification: single asset limit
    invest_amount <= 0.4 * total_budget,
    # Non-negativity
    x >= 0,
]

When solving, we specify the use of the MindOpt solver and configure relevant solver parameters (for solver parameters, see Parameters):

prob = cp.Problem(objective, constraints)
solver_options = {'MaxTime': 3, 'NumThreads': 2}
prob.solve(solver=cp.MINDOPT, verbose=True, **solver_options) # Solve using MindOpt solver

Finally, check the solution status and retrieve the results:

if prob.status not in [cp.OPTIMAL, cp.OPTIMAL_INACCURATE]:
    raise ValueError("Solver failed to find solution")

print("\nSolver status:", prob.status)
print("Expected annual return: ${:.2f}".format(prob.value))
print("\nOptimal Portfolio:")
total_investment = 0
for i in range(n_assets):
    shares = x.value[i] * min_lot_size
    if shares > 1e-4:  # Filter trivial positions
        position_value = shares * current_prices[i]
        print(
            f"{stocks[i]}: {int(x.value[i])} lots ({shares} shares), "
            f"${position_value:,.2f} ({position_value/total_budget:.1%})"
        )
        total_investment += position_value
# Calculate actual portfolio beta
portfolio_beta = (
    np.sum(betas * (current_prices * min_lot_size * x.value)) / total_investment
)

7.3.3. Example: cvxpy_mip_finance

The full code is provided in the file cvxpy_mip_finance.py:

"""
Portfolio Optimization Model with MindOpt (MILP Example)
Objective: Maximize expected return under risk constraints
"""

from mindopt_conif import *
from mindopt_qpif import *
import numpy as np

stocks = ["AAPL", "MSFT", "GOOG", "AMZN", "META"]  # Stock tickers
n_assets = len(stocks)

current_prices = np.array([180, 320, 140, 130, 350])  # Current stock prices (USD/share)

expected_returns = np.array(
    [0.08, 0.12, 0.10, 0.15, 0.18]
)  # Expected annual returns (decimal)

betas = np.array([1.2, 0.9, 1.1, 1.4, 1.3])  # Stock beta coefficients (systematic risk)

total_budget = 100000  # Total investment budget (USD)

min_lot_size = (
    100  # # Minimum trading lot size (shares per lot, standard for Chinese A-shares)
)

max_beta = 1.2  # Maximum portfolio beta threshold

x = cp.Variable(
    n_assets, integer=True
)  # Integer variable: number of lots to purchase per stock
y = cp.Variable(nonneg=True)  # Auxiliary variable for linearization (if needed)

invest_amount = cp.multiply(
    current_prices * min_lot_size, x
)  # Investment amount per stock (USD)

total_return = cp.sum(
    cp.multiply(expected_returns, invest_amount)
)  # Objective: Maximize portfolio return
objective = cp.Maximize(total_return)

constraints = [
    # Budget constraint
    cp.sum(invest_amount) <= total_budget,
    # Risk constraint (linearized form)
    cp.sum(cp.multiply(betas, invest_amount)) <= max_beta * cp.sum(invest_amount),
    # Diversification: single asset limit
    invest_amount <= 0.4 * total_budget,
    # Non-negativity
    x >= 0,
]

prob = cp.Problem(objective, constraints)
solver_options = {'MaxTime': 3, 'NumThreads': 2}
prob.solve(solver=cp.MINDOPT, verbose=True, **solver_options) # Solve using MindOpt solver

if prob.status not in [cp.OPTIMAL, cp.OPTIMAL_INACCURATE]:
    raise ValueError("Solver failed to find solution")

print("\nSolver status:", prob.status)
print("Expected annual return: ${:.2f}".format(prob.value))
print("\nOptimal Portfolio:")
total_investment = 0
for i in range(n_assets):
    shares = x.value[i] * min_lot_size
    if shares > 1e-4:  # Filter trivial positions
        position_value = shares * current_prices[i]
        print(
            f"{stocks[i]}: {int(x.value[i])} lots ({shares} shares), "
            f"${position_value:,.2f} ({position_value/total_budget:.1%})"
        )
        total_investment += position_value
# Calculate actual portfolio beta
portfolio_beta = (
    np.sum(betas * (current_prices * min_lot_size * x.value)) / total_investment
)
print(f"\nTotal invested: ${total_investment:,.2f}")
print(f"Portfolio beta: {portfolio_beta:.2f}")
print(f"Cash remaining: ${total_budget - total_investment:,.2f}")

For other CVXPY examples, refer to CVXPY Examples.