CVXPY

1.8.2 · active · verified Fri Apr 10

CVXPY is a Python-embedded modeling language for convex optimization problems. It allows users to express optimization problems in a natural way that follows mathematical notation, automatically transforming them into standard form, calling a solver, and unpacking the results. It is actively maintained with frequent patch releases, and major versions (e.g., 1.8.x) are supported with bugfixes while the next major release (e.g., 1.9) is under development, with older major versions no longer officially supported.

Warnings

breaking CVXPY 1.8.0 dropped support for Python 3.10 and NumPy versions older than 2.0.0.
Fix: Ensure your Python environment is 3.11 or newer and NumPy is >= 2.0.0. Upgrade with `pip install --upgrade python numpy` if necessary (after updating Python itself).
deprecated CVXPY 1.7 and older major versions are no longer officially supported since the release of CVXPY 1.8.
Fix: Upgrade to CVXPY 1.8.x or newer for continued support and bug fixes: `pip install --upgrade cvxpy`.
gotcha Matrix multiplication behavior changed: `*` is deprecated for matrix-matrix or matrix-vector multiplication. Use `@` for matrix multiplication and dot products. Use `*` for scalar multiplication. For element-wise multiplication, use `cp.multiply`.
Fix: Update your code to use the `@` operator for matrix multiplication and `cp.multiply` for element-wise multiplication. Example: `A @ x` instead of `A * x` for matrix-vector product.
gotcha Problems in CVXPY are immutable. If you need to change an objective or constraints (e.g., for parametric programming), you must construct a new `cp.Problem` instance.
Fix: Instead of modifying `prob.objective` or `prob.constraints` directly, create a new `cp.Problem(new_objective, new_constraints)`.
gotcha For atoms like `cp.sum`, `cp.sum_squares`, `cp.maximum`, `cp.minimum`, always use the CVXPY versions from the `cp` module instead of Python's built-in `sum()`, `max()`, `min()`. The built-in functions do not integrate with CVXPY's modeling language.
Fix: Replace Python built-ins with their CVXPY equivalents, e.g., `cp.sum(expr)` instead of `sum(expr)`.
gotcha CVXPY 1.8 changed the default solver for Mixed-Integer Linear Programs (MILPs) from ECOS_BB (or similar) to HiGHS. If you relied on the behavior or performance of a specific default solver, explicitly specify it using `prob.solve(solver='ECOS_BB')`.
Fix: If specific solver behavior is critical, explicitly set the solver parameter: `prob.solve(solver='ECOS_BB')` or `prob.solve(solver='GLPK_MI')`, etc.

Install

pip install cvxpy Base installation
pip install cvxpy clarabel osqp scs highspy With default open-source solvers
pip install cvxpy[full] With all optional open-source solvers (may require system dependencies for some)

Imports

cp
```
import cvxpy as cp
```
Importing all symbols with `*` can lead to namespace pollution and make code harder to read and debug. Using `import cvxpy as cp` is the standard and recommended practice.
np
```
import numpy as np
```
NumPy is commonly used alongside CVXPY for data generation and manipulation.

Quickstart

This example demonstrates how to solve a least-squares problem with box constraints using CVXPY. It defines variables, an objective function, and constraints, then solves the problem and prints the optimal variable values and duals.

import cvxpy as cp
import numpy as np

# Problem data.
m = 30
n = 20
np.random.seed(1)
A = np.random.randn(m, n)
b = np.random.randn(m)

# Construct the problem.
x = cp.Variable(n)
objective = cp.Minimize(cp.sum_squares(A @ x - b))
constraints = [0 <= x, x <= 1]
prob = cp.Problem(objective, constraints)

# The optimal objective value is returned by `prob.solve()`.
result = prob.solve()

# The optimal value for x is stored in `x.value`.
print("Optimal x:\n", x.value)
# The optimal Lagrange multiplier for a constraint is stored in
# `constraint.dual_value`.
print("Dual value for 0 <= x constraint:\n", constraints[0].dual_value)

view raw JSON →