Optimizing Large-Scale Linear Programming Problems with Sparse Constraints Using Highs Solvers in SciPy

in

Do you have sparse constraints that are causing headaches?

Introducing our latest hack: optimizing large-scale linear programming problems with sparse constraints using highs solvers in SciPy. Say what?! Let me break it down for you.

Before anything else, why this is a big deal. Linear programming involves finding the optimal solution to a problem that can be represented as a system of linear equations. However, when dealing with large-scale problems (think thousands or even millions of variables and constraints), traditional solvers like Simplex Algorithm become inefficient due to their exponential time complexity.

Enter sparse constraints! These are constraints where only a small subset of the variables have nonzero coefficients. This is common in real-world applications such as portfolio optimization, resource allocation, and supply chain management. However, traditional solvers struggle with these types of problems because they require solving dense systems of equations that can be computationally expensive.

That’s where highs (High Performance Solvers) come into play! Highs are a collection of linear programming solvers designed for large-scale sparse optimization problems. They use advanced techniques such as interior point methods and barrier functions to solve these types of problems efficiently.

So, how do we implement this in Python using SciPy? First, let’s create an example problem with 10,000 variables and 5,000 sparse constraints:

# Import necessary libraries
import numpy as np
from scipy.optimize import linprog

# Define the objective function (minimizing a quadratic cost)
def obj(x):
    return 1/2 * x.T @ A @ x + b.T @ x # Calculates the objective function value for a given solution x

# Generate random data for our problem
n = 10000 # number of variables
m = 5000 # number of constraints (sparse)
A = np.random.rand(m, n) # coefficient matrix
b = np.random.rand(m, 1) # right-hand side vector
c = np.zeros((n, 1)) # cost coefficients
x_start = np.ones(n) * 0.5 # initial solution (all variables are half)
bounds = [(-np.inf, np.inf)]*n # no bounds on any variable
constraints = ({'type': 'eq', 'fun': lambda x: A @ x - b}, {'type': 'ineq', 'fun': lambda x: A_sparse @ x <= sparse_b}) # constraints (linear and sparse)

# Solve the problem using linprog() from SciPy's optimize module
result = linprog(c, bounds=bounds, constraints=constraints, options={'disp': True}, method='trust-constr') # Solves the optimization problem using the specified method and returns the optimal solution and objective function value





# Note: The options parameter in the linprog() function allows for additional settings to be specified, such as displaying the optimization progress.

# Note: The method parameter in the linprog() function specifies the optimization method to be used. In this case, the trust-constr method is used, which is suitable for problems with both equality and inequality constraints.

In this example, we generate random data for our problem and define the objective function as a quadratic cost. We also create sparse constraints using SciPy’s linprog() solver with the ‘trust-constr’ method (which is specifically designed for solving large-scale problems).

The output of this code will be the optimal solution to our problem, along with various statistics such as the objective value and runtime. You now have an efficient way to solve your linear programming problems with sparse constraints using highs solvers in SciPy.

SICORPS