What is the good way of solving batched QPs?

[PierreQuinton]

We are trying to transition our library from relying on qpsolvers to proxsuite. We have to solve a batched qp of the form: minimizin $v_i^\top G v_i$ subject to $u_i \preceq v_i$ (elementwise inequality) for each row $u_i$ of $U$ ($G$ is an arbitrary PSD matrix of dimension $m\times m$). We put the resulting $v_i$ as rows into the matrix $V$.

I tried looking into the documentation of BatchQP and it seems that I am supposed to solve every problem one by one still, so I'm feeling like I did something wrong:

batch_qps = proxqp.dense.BatchQP()

for i in range(n):
    qp = batch_qps.init_qp_in_place(m, 0, m)
    qp.settings.primal_infeasibility_solving = False
    qp.init(H=G, g=np.zeros(m), A=None, b=None, C=-np.eye(m), l=np.zeros(m), u=U[i], rho=5.0e-5)

for i in range(n):
    batch_qps.get(i).solve()

V = torch.empty((n, m), dtype=torch.float64)
for i in range(n):
    V[i] = torch.from_numpy(batch_qps.get(i).results.x)

Is that the intended usage? what advantage is there over not using BatchQP? Any suggestion to help me improve performances?

[fabinsch]

Hi @PierreQuinton, thanks for trying proxsuite!

You are on the right track, BatchQP + init_qp_in_place is the intended pattern, but you're missing solve_in_parallel. Solving them one by one in a Python loop gives you no advantage over a list of plain QP objects. The point of BatchQP is to hand the whole batch to a single OpenMP-parallel solve on the C++ side.

import os
import proxsuite

batch_qps = proxsuite.proxqp.dense.BatchQP()
for i in range(n):
    qp = batch_qps.init_qp_in_place(..)
    qp.init(...)

num_threads = max(1, (os.cpu_count() or 2) // 2)
proxsuite.proxqp.dense.solve_in_parallel(num_threads=num_threads, qps=batch_qps)

A couple of things to be aware of:

solve_in_parallel only does anything if proxsuite was built with OpenMP support. The pip wheels are built with it, if you build from source, make sure -DBUILD_WITH_OPENMP_SUPPORT=ON is set. Otherwise, it falls back to sequential.

You can have a look at:

test/src/parallel_qp_solve.py: Python test of BatchQP + solve_in_parallel
test/src/parallel_qp_solve.cpp: the equivalent on the C++ side
bindings/python/proxsuite/torch/qplayer.py: the same pattern in use for our differentiable qp layer

Hope that helps, and good luck with the migration!

[ValerianRey]

Hi @fabinsch, and thanks for the support!

The pip wheels are built with it

I think this is not the case anymore with the release of 0.7.3. In a fresh python 3.13.10 environment, with proxsuite==0.7.3, running:

import proxsuite
proxsuite.proxqp.dense.solve_in_parallel

yields:

AttributeError: module 'proxsuite.proxsuite_pywrap_avx2.proxqp.dense' has no attribute 'solve_in_parallel'

But with proxsuite==0.7.2, running the same two lines yields the expected:

<nanobind.nb_func object at 0x725fda3915d0>

Is this intended? It may be linked to the change that was recently made on how proxsuite is built: #463

[nim65s]

That was build without OpenMP support, I'll enable it on linux and rebuild it. For macos, iirc, that require a bit more work.

[ValerianRey]

Thanks for the quick reply. Looking forward to it!

[nim65s]

>>> import proxsuite
>>> proxsuite.__version__
'0.7.3'
>>> proxsuite.proxqp.dense.solve_in_parallel
<nanobind.nb_func object at 0x79894a325d00>

[ValerianRey]

Tyvm! It now works on linux on my side too.