The Advanced Proximal Optimization Toolbox

Project Name | Stars | Downloads | Repos Using This | Packages Using This | Most Recent Commit | Total Releases | Latest Release | Open Issues | License | Language |
---|---|---|---|---|---|---|---|---|---|---|

Awesome Robotics Libraries | 1,804 | 25 days ago | 2 | cc0-1.0 | ||||||

:sunglasses: A curated list of robotics libraries and software | ||||||||||

Rl Baselines3 Zoo | 1,285 | 13 days ago | 44 | mit | Python | |||||

A training framework for Stable Baselines3 reinforcement learning agents, with hyperparameter optimization and pre-trained agents included. | ||||||||||

Teaser Plusplus | 1,250 | 16 days ago | 35 | mit | C++ | |||||

A fast and robust point cloud registration library | ||||||||||

Symforce | 1,184 | 1 | 7 days ago | 5 | June 29, 2022 | 144 | apache-2.0 | C++ | ||

Fast symbolic computation, code generation, and nonlinear optimization for robotics | ||||||||||

Control Toolbox | 838 | a year ago | 53 | bsd-2-clause | C++ | |||||

The Control Toolbox - An Open-Source C++ Library for Robotics, Optimal and Model Predictive Control | ||||||||||

Awesome Robotics | 677 | 3 months ago | 2 | |||||||

A curated list of awesome links and software libraries that are useful for robots. | ||||||||||

Ifopt | 527 | 9 months ago | 8 | bsd-3-clause | C++ | |||||

An Eigen-based, light-weight C++ Interface to Nonlinear Programming Solvers (Ipopt, Snopt) | ||||||||||

Pypose | 435 | 2 days ago | 7 | February 18, 2022 | 29 | apache-2.0 | Python | |||

To connect classic robotics with modern learning methods seamlessly. | ||||||||||

G2opy | 259 | 3 years ago | 30 | C++ | ||||||

Python binding of SLAM graph optimization framework g2o | ||||||||||

Minisam | 230 | 3 years ago | 11 | bsd-3-clause | C++ | |||||

A general and flexible factor graph non-linear least square optimization framework |

Alternatives To ProxsuiteSelect To Compare

Alternative Project Comparisons

Readme

**ProxSuite** is a collection of open-source, numerically robust, precise and efficient numerical solvers (e.g., LPs, QPs, etc.) rooted in revisited primal-dual proximal algorithms.
Through **ProxSuite**, we aim to offer the community scalable optimizers that can deal with dense, sparse or matrix-free problems. While the first targeted application is Robotics, **ProxSuite** can be used in other contexts without limits.

**ProxSuite** is actively developped and supported by the Willow and Sierra research groups, joint research teams between Inria, École Normale Supérieure de Paris and Centre National de la Recherche Scientifique localized in France.

**ProxSuite** is already integrated into:

- CVXPY modeling language for convex optimization problems,
- CasADi's symbolic framework for numerical optimization in general and optimal control. ProxQP is available in CasADi as plugin to solve quadratic programs,
- TSID: robotic software for efficient robot inverse dynamics with contacts and based on Pinocchio.

We are ready to integrate **ProxSuite** within other optimization ecosystems.

**Proxsuite** is fast:

- C++ template library,
- cache-friendly.

**Proxsuite** is versatile, offering through a unified API advanced algorithms specialized for efficiently exploiting problem structures:

- dense, sparse and matrix-free matrix factorization backends,
- advanced warm-starting options (e.g., equality-constrained initial guess, warm-start or cold-start options from previous results).

**Proxsuite** is flexible:

- header only,
- C++ 14/17/20 compliant,
- Python and Julia bindings for easy code prototyping without sacrificing performance.

**Proxsuite** is extensible.
**Proxsuite** is reliable and extensively tested, showing the best performances on the hardest problems of the literature.
**Proxsuite** is supported and tested on Windows, Mac OS X, Unix and Linux.

The online **ProxSuite** documentation of the last release is available here.

**ProxSuite** is distributed on many well-known package managers.

```
pip install proxsuite
```

This approach is available on Linux, Windows and Mac OS X.

```
conda install proxsuite -c conda-forge
```

This approach is available on Linux, Windows and Mac OS X.

```
brew install proxsuite
```

This approach is available on Linux and Mac OS X.

Installation from source is presented here.

For the fastest performance use the following command to enable vectorization when compiling the simple example.

```
g++ -O3 -march=native -DNDEBUG -std=gnu++17 -DPROXSUITE_VECTORIZE examples/first_example_dense.cpp -o first_example_dense $(pkg-config --cflags proxsuite)
```

If you want to use ProxSuite with CMake, the following tiny example should help you:

```
cmake_minimum_required(VERSION 3.10)
project(Example CXX)
find_package(proxsuite REQUIRED)
set(CMAKE_CXX_STANDARD 17) # set(CMAKE_CXX_STANDARD 14) will work too
add_executable(example example.cpp)
target_link_libraries(example PUBLIC proxsuite::proxsuite)
# Vectorization support via SIMDE and activated by the compilation options '-march=native' or `-mavx2 -mavx512f`
add_executable(example_with_full_vectorization_support example.cpp)
target_link_libraries(example_with_full_vectorization_support PUBLIC proxsuite::proxsuite-vectorized)
target_compile_options(example_with_full_vectorization_support PUBLIC "-march=native")
```

If you have compiled ProxSuite with the vectorization support, you might also use the CMake target `proxsuite::proxsuite-vectorized`

to also link against SIMDE.
Don't forget to use `-march=native`

for getting the best performance.

The **ProxQP** algorithm is a numerical optimization approach for solving quadratic programming problems of the form:

$$ \begin{align} \min_{x} & ~\frac{1}{2}x^{T}Hx+g^{T}x \ \text{s.t.} & ~A x = b \ & ~l \leq C x \leq u \end{align} $$

where $x \in \mathbb{R}^n$ is the optimization variable. The objective function is defined by a positive semidefinite matrix $H \in \mathcal{S}^n_+$ and a vector $g \in \mathbb{R}^n$. The linear constraints are defined by the equality-contraint matrix $A \in \mathbb{R}^{n_\text{eq} \times n}$ and the inequality-constraint matrix $C \in \mathbb{R}^{n_\text{in} \times n}$ and the vectors $b \in \mathbb{R}^{n_\text{eq}}$, $l \in \mathbb{R}^{n_\text{in}}$ and $u \in \mathbb{R}^{n_\text{in}}$ so that $b_i \in \mathbb{R},~ \forall i = 1,...,n_\text{eq}$ and $l_i \in \mathbb{R} \cup { -\infty }$ and $u_i \in \mathbb{R} \cup { +\infty }, ~\forall i = 1,...,n_\text{in}$.

If you are using **ProxQP** for your work, we encourage you to cite the related paper.

The numerical benchmarks of **ProxQP** against other commercial and open-source solvers are available here.

For dense Convex Quadratic Programs with inequality and equality constraints, when asking for relatively high accuracy (e.g., 1e-6), one obtains the following results.

On the y-axis, you can see timings in seconds, and on the x-axis dimension wrt to the primal variable of the random Quadratic problems generated (the number of constraints of the generated problem is half the size of its primal dimension). For every dimension, the problem is generated over different seeds and timings are obtained as averages over successive runs for the same problems. This chart shows for every benchmarked solver and random Quadratic program generated, barplot timings including median (as a dot) and minimal and maximal values obtained (defining the amplitude of the bar). You can see that **ProxQP** is always below over solvers, which means it is the quickest for this test.

For hard problems from the Maros Meszaros testset, when asking for high accuracy (e.g., 1e-9), one obtains the results below.

The chart above reports the performance profiles of different solvers. It is classic for benchmarking solvers. Performance profiles correspond to the fraction of problems solved (on y-axis) as a function of certain runtime (on x-axis, measured in terms of a multiple of the runtime of the fastest solver for that problem). So the higher on the chart the better. You can see that **ProxQP** solves the quickest over 60% of the problems (i.e., for $\tau=1$), and that for solving about 90% of the problems, it is at most 2 times slower than the fastest solvers solving these problems (i.e., for $\tau\approx2$).

*Note: All these results have been obtained with a 11th Gen Intel(R) Core(TM) i7-11850H @ 2.50GHz CPU.*

Please follow the installation procedure here.

Popular Optimization Projects

Popular Robotics Projects

Popular Software Performance Categories

Related Searches

Get A Weekly Email With Trending Projects For These Categories

No Spam. Unsubscribe easily at any time.

C Plus Plus

Cpp

Optimization

Robotics