proxsuite

O Proxsuite é uma coleção de solucionadores numéricos numericamente robustos, precisos e eficientes (por exemplo, LPS, QPs, etc.) enraizados nos algoritmos proximais primpos-duplos revisitados. Através do Proxsuite , pretendemos oferecer aos otimizadores escalonáveis ​​da comunidade que lidam com problemas densos, escassos ou sem matrizes. Embora o primeiro aplicativo direcionado seja a robótica, o proxsuite pode ser usado em outros contextos sem limites.

O Proxsuite é desenvolvido e apoiado ativamente pelos grupos de pesquisa de Willow e Sierra, equipes de pesquisa conjuntas entre a INRIA, École Normale Supérrieure de Paris e Centro National de la Recherche Scientifique localizada na França.

Proxsuite já está integrado a:

• Linguagem de modelagem CVXPY para problemas de otimização convexa,
• A estrutura simbólica de Casadi para otimização numérica em geral e controle ideal. O ProxQP está disponível em Casadi como um plug -in para resolver programas quadráticos,
• TSID: Software robótico para dinâmica inversa eficiente de robô com contatos e com base em Pinocchio.

Estamos prontos para integrar proxsuite em outros ecossistemas de otimização.

Proxsuite Principais recursos

Proxsuite é rápido:

• Biblioteca de modelos C ++,
• amigável ao cache.

O proxsuite é versátil, oferecendo por meio de algoritmos avançados de API unificados especializados para explorar com eficiência estruturas de problemas:

• Densos, esparsos e livres de matrizes-fatores de matriz backends,
• Opções avançadas de iniciação quente (por exemplo, palpite inicial com restrição de igualdade, opções de partida acolhedora ou de partida a frio dos resultados anteriores),

com recursos dedicados para

• Lidando com mais eficiência restrições de caixas, programas lineares, QP com hessiano diagonal ou com muito mais restrições do que variáveis ​​primárias,
• Resolvendo qps não -convexos,
• Resolvendo lotes de QPs em paralelo,
• resolver o QP mais próximo viável se o QP parecer inviável primordial,
• QPs viáveis ​​e inviáveis ​​diferenciados.

Proxsuite é flexível:

• apenas cabeçalho,
• C ++ 14/17/20 Compiliante,
• As ligações de Python e Julia para facilitar a prototipagem de código sem sacrificar o desempenho.

Proxsuite é extensível. O proxsuite é confiável e testado extensivamente, mostrando as melhores performances sobre os problemas mais difíceis da literatura. O Proxsuite é suportado e testado no Windows, Mac OS X, UNIX e Linux.

Documentação

A documentação on -line do ProxSuite da última versão está disponível aqui.

Começando

O Proxsuite é distribuído a muitos gerentes de pacotes conhecidos.

Instalação rápida com:

   pip install proxsuite

Esta abordagem está disponível no Linux, Windows e Mac OS X.

Instalação rápida com:

   conda install proxsuite -c conda-forge

Esta abordagem está disponível no Linux, Windows e Mac OS X.

Instalação rápida com:

   brew install proxsuite

Esta abordagem está disponível no Linux e Mac OS X.

Abordagens alternativas

A instalação da fonte é apresentada aqui.

Compilar um primeiro programa de exemplo

Para o desempenho mais rápido, use o seguinte comando para ativar a vetorização ao compilar o exemplo simples.

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

Usando proxsuite com cmake

Se você deseja usar o proxsuite com cmake, o seguinte exemplo deve ajudá -lo:

 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" )

Se você compilou o ProxSuite com o suporte à vetorização, também poderá usar o CMake Target proxsuite::proxsuite-vectorized para também vincular o SIMDE. Não se esqueça de usar -march=native para obter o melhor desempenho.

Proxqp

O algoritmo Proxqp é uma abordagem de otimização numérica para resolver problemas de programação quadrática do formulário:

$$ begin {align} min_ {x} & ~ frac {1} {2} x^{t} hx+g^{t} x \ text {st} & ~ a x = b \ & ~ l leq c x leq u end {alig

onde $ x em mathbb {r}^n $ é a variável de otimização. A função objetivo é definida por uma matriz semidefinita positiva $ H em mathcal {s}^n _+$ e um vetor $ g in mathbb {r}^n $ . As restrições lineares são definidas pela matriz de igualdade-contorno $ A in mathbb {r}^{n_ text {eq} times n} $ e a matriz de restrição de desigualdade $ C in mathbb {r}^{n_ text {in} times n} $ e os vetores $ b in mathbb {r}^{n_ text {eq}} $ , Assim, $ l in mathbb {r}^{n_ text {in}} $ e $ u in mathbb {r}^{n_ text {in}} $ para que $ b_i in mathbb {r}, ~ forall i = 1, ..., n_ text {eq} $ e $ l_i in mathbb {r} cup { - infty} $ e $ u_i in mathbb {r} cup { + infty}, ~ forall i = 1, ..., n_ text {in} $ .

Citando proxqp

Se você estiver usando o Proxqp para o seu trabalho, incentivamos você a citar o artigo relacionado.

Benchmarks numéricos

Os benchmarks numéricos do ProxQP contra outros solucionadores de código aberto e de código aberto estão disponíveis aqui.

Para programas quadráticos convexos densos com restrições de desigualdade e igualdade, ao solicitar uma precisão relativamente alta (por exemplo, 1E-6), obtém-se os seguintes resultados.

No eixo y, você pode ver os horários em segundos e na dimensão do eixo x WRT para a variável primordial dos problemas quadráticos aleatórios gerados (o número de restrições do problema gerado é metade do tamanho de sua dimensão primordial). Para cada dimensão, o problema é gerado em diferentes sementes e os horários são obtidos como médias em execuções sucessivas para os mesmos problemas. Este gráfico mostra para todos os programas de solucionador de referência e quadrática aleatória gerados, com os valores de barrot, incluindo mediana (como um ponto) e valores mínimos e máximos obtidos (definindo a amplitude da barra). Você pode ver que o ProxQP está sempre abaixo dos solucionadores, o que significa que é o mais rápido para este teste.

Para problemas difíceis do conjunto de testes de Maros Meszaros, ao solicitar alta precisão (por exemplo, 1E-9), um obtém os resultados abaixo.

O gráfico acima relata os perfis de desempenho de diferentes solucionadores. É clássico para os solucionadores de benchmarking. Os perfis de desempenho correspondem à fração de problemas resolvidos (no eixo y) em função de um determinado tempo de execução (no eixo x, medido em termos de um múltiplo de tempo de execução do solucionador mais rápido para esse problema). Então, quanto mais alto, melhor. Você pode ver que o Proxqp resolve os mais rápidos mais de 60% dos problemas (ou seja, para $ tau = 1 $ ) e que, para resolver cerca de 90% dos problemas, é no máximo 2 vezes mais lento que os solucionadores mais rápidos que resolvem esses problemas (ou seja, para $ tau aprox2 $ ).

Nota: Todos esses resultados foram obtidos com um núcleo de 11ª geração Intel (R) (TM) i7-11850H @ 2,50GHz CPU.

QPLAYER

O QPLAYER permite usar um QP como uma camada nas arquiteturas de aprendizado padrão. Mais precisamente, o QPLAYER DIFERIA $ theta $ as soluções primordiais e duplas do QP da forma

$$ Begin {align} min_ {x} & ~ frac {1} {2} x^{t} h ( theta) x+g ( theta)^{t} x text {} & ~ a ( theta) x = x = l) C ( theta) x leq u ( theta) end {align} $$

onde $ x em mathbb {r}^n $ é a variável de otimização. A função objetivo é definida por uma matriz semidefinita positiva $ H ( theta) em mathcal {s}^n _+$ e um vetor $ g ( theta) em mathbb {r}^n $ . As restrições lineares são definidas pela matriz de igualdade-contorno $ A ( theta) em mathbb {r}^{n_ text {eq} times n} $ e a matriz de restrição de desigualdade $ C ( theta) em mathbb {r}^{n_ text {in} times n} $ e os vetores $ b in mathbb {r}^{n_ text {eq}} $ , Assim, $ l ( theta) em mathbb {r}^{n_ text {in}} $ e $ u ( theta) em mathbb {r}^{n_ text {in}} $ para que $ b_i in mathbb {r}, ~ forall i = 1, ..., n_ text {eq} $ e $ l_i in mathbb {r} cup { - infty} $ e $ u_i in mathbb {r} cup { + infty}, ~ forall i = 1, ..., n_ text {in} $ .

O QPLAYER é capaz de aprender arquiteturas mais estruturadas. Por exemplo, $ theta $ pode consistir apenas em aprender alguns elementos de $ A $ enquanto deixava $ B $ Corrigido (ver por exemplo, o exemplo sobre como incluir o QPLAYER em um pipeline de aprendizado). O QPLAYER também pode se diferenciar em relação ao LPS. O QPLAYER permite cálculo paralelo sobre as CPUs e é interfocado por pytorch .

Citando QPLAYER

Se você estiver usando o QPLAYER para o seu trabalho, incentivamos você a citar o artigo relacionado.

Procedimento de instalação

Siga o procedimento de instalação aqui.