Existe-t-il un solveur de programmation non linéaire de haute qualité pour Python?

J'ai plusieurs problèmes d'optimisation globale non convexe difficiles à résoudre. Actuellement, j'utilise la boîte à outils Optimization de MATLAB (en particulier, fmincon()avec algorithm = 'sqp'), ce qui est assez efficace . Cependant, la majeure partie de mon code est en Python et j'aimerais également en faire l'optimisation. Existe-t-il un solutionneur de PNL avec des liaisons Python pouvant rivaliser fmincon()? Il doit

• être capable de gérer les contraintes non linéaires d'égalité et d'inégalité
• pas obliger l'utilisateur à fournir un jacobien.

Ce n'est pas grave si cela ne garantit pas un optimum global ( fmincon()ne le fait pas). Je recherche quelque chose qui converge fortement vers un optimum local, même pour des problèmes difficiles, et même légèrement plus lent que fmincon().

J'ai essayé plusieurs des solveurs disponibles via OpenOpt et les ai trouvés inférieurs à ceux de MATLAB fmincon/sqp.

Juste pour souligner, j'ai déjà une formulation simple et un bon solveur. Mon objectif est simplement de changer de langue afin d'avoir un flux de travail plus simple.

Geoff souligne que certaines caractéristiques du problème peuvent être pertinentes. Elles sont:

• 10-400 variables de décision
• 4 à 100 contraintes d'égalité polynomiale (le degré polynomial varie de 1 à environ 8)
• Un nombre de contraintes d'inégalité rationnelles égal à environ deux fois le nombre de variables de décision
• La fonction objectif est l'une des variables de décision

Le jacobien des contraintes d'égalité est dense, tout comme le jacobien des contraintes d'inégalité.

fmincon(), comme vous l'avez mentionné, utilise plusieurs stratégies bien connues en optimisation non linéaire qui tentent de trouver un minimum local sans trop se préoccuper de savoir si l'optimum global a été trouvé. Si cela vous convient, alors je pense que vous avez bien formulé la question (optimisation non linéaire).

Le meilleur package que je connaisse pour l'optimisation non linéaire générale est IPOPT [1]. Apparemment, Matthew Xu gère un ensemble de liaisons Python vers IPOPT , ce qui pourrait donc être un point de départ.

[1]: Andreas Wachter est un ami personnel, alors je suis peut-être un peu partial.

Je travaille dans un laboratoire qui optimise globalement les problèmes à nombres entiers et non convexes. Mon expérience avec les solveurs d’optimisation open source a été que les meilleurs sont généralement écrits dans un langage compilé et qu’ils se comparent mal aux packages d’optimisation commerciaux.

Si vous pouvez formuler votre problème comme un système d’équations explicite et que vous avez besoin d’un résolveur gratuit, votre meilleur choix est probablement IPOPT, comme l’a dit Aron. Vous pouvez trouver d’autres solveurs gratuits sur le site Web COIN-OR . À ma connaissance, les solveurs non linéaires ne disposent pas de liaisons Python fournies par les développeurs; toute liaison que vous trouverez serait une tierce partie. Pour obtenir de bonnes solutions, vous devez également envelopper tout solveur convexe et non linéaire que vous avez trouvé dans une heuristique d'optimisation globale stochastique appropriée ou dans un algorithme d'optimisation globale déterministe tel que branch-and-bound. Vous pouvez également utiliser Bonmin ou Couenne, qui sont tous deux des résolveurs d’optimisation déterministes non convexes, dont les performances sont satisfaisantes par rapport au BARON , le solveur à la pointe de la technologie .

Si vous pouvez acheter un solveur d’optimisation commercial, vous pouvez envisager de consulter le langage de modélisation GAMS , qui comprend plusieurs solveurs d’optimisation non linéaires. Les interfaces avec les solveurs CONOPT, SNOPT et BARON sont particulièrement citées. (CONOPT et SNOPT sont des solveurs convexes.) Une solution kludgey que j’ai utilisée par le passé consiste à utiliser les liaisons de langage Fortran (ou Matlab) à GAMS pour écrire un fichier GAMS et appeler GAMS à partir de Fortran (ou Matlab) pour calculer le fichier. solution d'un problème d'optimisation. GAMS dispose de liens en langage Python et d’un personnel d’assistance très réactif, prêt à vous aider en cas de problème. (Avertissement: je n'ai aucune affiliation avec GAMS, mais mon laboratoire possède une licence GAMS.) Les solveurs commerciaux ne devraient pas être pires quefmincon; En fait, je serais surpris s'ils n'étaient pas beaucoup mieux. Si la taille de vos problèmes est suffisamment petite, vous n’auriez peut-être même pas besoin d’acheter une licence GAMS et des licences pour les solveurs, car une copie d’évaluation de GAMS peut être téléchargée à partir de leur site Web. Sinon, vous voudrez probablement choisir les solveurs à acheter avec une licence GAMS. Il est intéressant de noter que BARON nécessite un solveur de programmation linéaire à nombres entiers mixtes et que les licences pour les deux meilleurs solveurs de programmation linéaire à nombres entiers mélangés CPLEX et GUROBI sont gratuites pour les universitaires. Vous pourrez donc vous en tirer en achetant simplement les interfaces GAMS. que les interfaces et les licences de solveur, ce qui peut vous faire économiser beaucoup d’argent.

Ce point mérite d'être répété: pour tout résolveur d'optimisation non convexe déterministe que j'ai mentionné ci-dessus, vous devez être capable de formuler le modèle comme un ensemble explicite d'équations. Sinon, les algorithmes d'optimisation non convexes ne fonctionneront pas, car ils reposent tous sur une analyse symbolique pour construire des relaxations convexes pour des algorithmes de type ramification et délimitation.

MISE À JOUR: Une idée qui ne me venait pas à l'esprit à première vue était que vous pouviez également appeler la boîte à outils pour l'optimisation avancée ( TAO ) et PETSc en utilisant tao4py et petsc4py , ce qui aurait l'avantage supplémentaire de faciliter la parallélisation et de tirer parti de la familiarité avec PETSc. et les outils ACTS .

MISE À JOUR # 2: Sur la base des informations supplémentaires que vous avez mentionnées, les méthodes de programmation séquentielle quadratique (SQP) seront votre meilleur choix. Les méthodes SQP sont généralement considérées comme plus robustes que les méthodes à point intérieur, mais présentent l'inconvénient de nécessiter des solutions linéaires denses. Puisque vous vous souciez plus de la robustesse que de la vitesse, SQP sera votre meilleur pari. Je ne trouve pas de bon solutionneur de SQP écrit en Python (et apparemment, Sven Leyffer d’Argonne ne le pouvait pas non plus dans ce rapport technique ). Je suppose que les algorithmes implémentés dans des packages tels que SciPy et OpenOpt ont le squelette de base de certains algorithmes SQP, mais sans l'heuristique spécialisée que des codes plus avancés utilisent pour surmonter les problèmes de convergence. Vous pouvez essayer NLopt, écrit par Steven Johnson au MIT. Je n'ai pas beaucoup d'espoir, car il n'a aucune réputation à ma connaissance, mais Steven Johnson est un type brillant qui écrit de bons logiciels (après tout, il a co-écrit FFTW). Il implémente une version de SQP; si c'est un bon logiciel, faites le moi savoir.

J'espérais que TAO aurait un rôle de résolveur d'optimisation contraint, mais ce n'est pas le cas. Vous pouvez certainement utiliser ce qu'ils ont pour en construire un; ils ont beaucoup de composants là-bas. Comme vous l'avez fait remarquer, cependant, il vous demanderait beaucoup plus de travail. Si vous rencontrez ce type de problème, vous pourriez aussi bien être un développeur TAO.

Avec ces informations supplémentaires, vous obtiendrez de meilleurs résultats en appelant GAMS à partir de Python (si c'est une option du tout) ou en essayant de corriger l'interface Python IPOPT. Etant donné qu'IPOPT utilise une méthode de point intérieur, elle ne sera pas aussi robuste, mais la mise en œuvre par Andreas d'une méthode de point intérieur est considérablement meilleure que celle de Matlab avec SQP. Dans ce cas, vous ne sacrifiez peut-être pas la robustesse. Il faudrait mener des études de cas pour en être certain.

Vous êtes déjà au courant de l'astuce pour reformuler les contraintes d'inégalité rationnelles en contraintes d'inégalité polynomiales (c'est dans votre livre); La raison pour laquelle cela aiderait BARON et certains autres solveurs non-convexes est qu’il peut utiliser l’analyse par terme pour générer d’autres inégalités valides qu’il peut utiliser pour réduire et améliorer la convergence des solveurs.

Si l'on exclut les liaisons GAMS Python et l'interface Python vers IPOPT, la réponse est non, il n'y a pas encore de solutionneur de programmation non linéaire de haute qualité pour Python. Peut-être que @Dominique changera cela avec NLPy.

MISE À JOUR # 3: Des solutions plus sauvages pour trouver un solutionneur basé sur Python ont abouti à PyGMO , un ensemble de liaisons Python à PaGMO, un solutionneur d'optimisation multiobjectif global basé sur C ++. Bien qu'il ait été créé pour l'optimisation multiobjectif, il peut également être utilisé pour la programmation non linéaire à objectif unique et possède des interfaces Python pour IPOPT et SNOPT, entre autres solutions. Il a été développé au sein de l' Agence spatiale européenne , alors espérons qu'il y a une communauté derrière cela. Il a également été publié relativement récemment (24 novembre 2011).

Mise à jour: voir le nouveau package GEKKO que nous venons de publier.

APM Python est une boîte à outils d’optimisation gratuite dotée d’interfaces pour APOPT, BPOPT, IPOPT et d’autres solveurs. Il fournit une première (jacobienne) et une deuxième (hessienne) informations aux solveurs et fournit une interface Web optionnelle pour visualiser les résultats. Le client APM Python est installé avec pip:

 pip install APMonitor

Il peut également être installé dans un script Python avec:

try:
    from APMonitor.apm import *
except:
    # Automatically install APMonitor
    import pip
    pip.main(['install','APMonitor'])
    from APMonitor.apm import *

Nous avons effectué quelques tests de référence et constaté que la combinaison de APOPT (méthode de définition active) et IPOPT (méthode de point intérieur) peut résoudre un pourcentage élevé de problèmes de référence. Un certain nombre d'exemples de problèmes sont inclus avec le fichier zip de téléchargement. Le problème avec lequel vous voudrez probablement commencer est le problème de Hock Schittkowski n ° 71. C'est l'exemple le plus simple qui montre comment résoudre les problèmes d'optimisation sous contraintes.

Il existe une interface de navigateur et une API pour Python / MATLAB. L'API de Python est un script unique (apm.py) disponible au téléchargement à partir de la page d'accueil d'apmonitor.com. Une fois que le script est chargé dans un code Python, il donne la possibilité de résoudre les problèmes de:

• Équations non linéaires
• Programmation non linéaire à nombres entiers mixtes
• Équations différentielles et algébriques
• Ajustement des moindres carrés
• Estimation d'horizon mobile
• Contrôle prédictif par modèle non linéaire
• etc.

Pour le nouvel utilisateur, le logiciel APM Python dispose d'un forum Google Groupes où un utilisateur peut poser des questions. Certains webinaires présentent des problèmes d'optimisation dans les domaines de la recherche opérationnelle et de l'ingénierie.

Vous trouverez ci-dessous un exemple de problème d'optimisation (hs71.apm).

Model
  Variables
    x[1] = 1, >=1, <=5
    x[2] = 5, >=1, <=5
    x[3] = 5, >=1, <=5
    x[4] = 1, >=1, <=5
  End Variables

  Equations
    x[1] * x[2] * x[3] * x[4] > 25
    x[1]^2 + x[2]^2 + x[3]^2 + x[4]^2 = 40

    minimize  x[1] * x[4] * (x[1]+x[2]+x[3]) + x[3]
  End Equations
End Model

Le problème d'optimisation est résolu avec le script Python suivant:

from APMonitor.apm import *
server = 'http://byu.apmonitor.com'

# Application name
app = 'eqn'

# Clear previous application
apm(server,app,'clear all')

# Load model file
apm_load(server,app,'hs71.apm')

# Option to select solver (1=APOPT, 2=BPOPT, 3=IPOPT)
apm_option(server,app,'nlc.solver',3)

# Solve on APM server
solver_output = apm(server,app,'solve')

# Display solver output
print(solver_output)

# Retrieve results
results = apm_sol(server,app)

# Display results
print('--- Results of the Optimization Problem ---')
print(results)

# Display Results in Web Viewer 
url = apm_var(server,app)
print("Opened Web Viewer: " + url)

APM Python est un service Web gratuit d'optimisation. Les problèmes d'optimisation sont résolus sur des serveurs distants et les résultats sont renvoyés au script Python local. Un serveur local APMonitor est également disponible au téléchargement, de sorte qu'une connexion Internet n'est pas nécessaire ( serveur de téléchargement ). Nous avons récemment ajouté la prise en charge du traitement parallèle pour MATLAB et Python. Le module Python est compatible avec Python 2.7 ou Python 3+.

Bien que cela ne réponde pas entièrement à votre question, je crée un package Python pour la programmation non linéaire nommé NLPy. La version la plus récente est disponible sur https://github.com/dpo/nlpy.

Je dois souligner que NLPy est de type recherche et que les solveurs inclus ne sont en aucun cas aussi robustes que des codes plus aguerris comme IPOPT. De plus, ils exigent actuellement que des jacobiens soient fournis. Cela étant dit, l'objectif de NLPy est de fournir les outils nécessaires aux chercheurs pour assembler des solveurs personnalisés s'ils en ont besoin. Quoi qu'il en soit, je serais intéressé d'entendre vos commentaires hors ligne si vous le testez. Vous pouvez également trouver les packages associés https://github.com/dpo/pykrylov et https://github.com/dpo/pyorder utiles. Actuellement, la documentation de NLPy fait définitivement défaut. Les deux autres devraient être raisonnables.

pyomo est un environnement de modélisation complet, similaire à GAMS / AMPL, destiné à l'optimisation en python. Il est extrêmement puissant, possède des interfaces avec tous les solveurs supportés par AMPL, et génère automatiquement des jacobiens, etc. Cependant, du fait qu’il fonctionne dans un «environnement python virtuel», il peut ne pas être simple de le lier au code existant.

Nous avons récemment publié (2018) le package GEKKO Pythonpour la programmation non linéaire avec des solveurs tels que IPOPT, APOPT, BPOPT, MINOS et SNOPT avec les méthodes set actif et point intérieur. L’un des problèmes liés à l’utilisation de ces solveurs est qu’il est normalement nécessaire de fournir au moins les premières dérivés et éventuellement les seconds dérivés. Il existe plusieurs beaux langages de modélisation qui peuvent le faire pour vous, comme mentionné avec d'autres réponses. GEKKO compile les équations en code octet pour que ce soit comme si vous aviez écrit le modèle en Fortran ou en C ++ en termes de vitesse. La différenciation automatique fournit les dérivées 1 et 2 sous forme fragmentée aux solveurs basés sur les gradients. GEKKO a été conçu pour des problèmes de contrôle optimaux, mais il peut également résoudre des problèmes similaires à fmincon. Vous trouverez ci-dessous un exemple rapide d’un problème de programmation non linéaire avec des contraintes d’égalité et d’inégalité. Tout d'abord, vous

pip install gekko

Le problème de Hock Schittkowski n ° 71 est présenté ci-dessous à titre d'exemple d'une fonction d'objectif, d'une contrainte d'inégalité, d'une contrainte d'égalité et de quatre variables avec des limites supérieure et inférieure.

from gekko import GEKKO
m = GEKKO() # Initialize gekko
# Initialize variables
x1 = m.Var(value=1,lb=1,ub=5)
x2 = m.Var(value=5,lb=1,ub=5)
x3 = m.Var(value=5,lb=1,ub=5)
x4 = m.Var(value=1,lb=1,ub=5)
# Equations
m.Equation(x1*x2*x3*x4>=25)
m.Equation(x1**2+x2**2+x3**2+x4**2==40)
m.Obj(x1*x4*(x1+x2+x3)+x3) # Objective
m.options.IMODE = 3 # Steady state optimization
m.solve() # Solve
print('Results')
print('x1: ' + str(x1.value))
print('x2: ' + str(x2.value))
print('x3: ' + str(x3.value))
print('x4: ' + str(x4.value))    

GEKKO fonctionne sur toutes les plateformes (Windows, MacOS, Linux, processeurs ARM) et avec Python 2.7 et 3+. Une option entièrement locale est disponible sans connexion Internet en définissant l'option "distant = Faux". L'option locale est actuellement disponible uniquement pour Windows et nous travaillons sur d'autres versions telles que Linux, MacOS, processeurs ARM pour s'exécuter localement sans connexion Internet. La version locale n'inclut que les solveurs gratuits ne nécessitant pas de licence. Par défaut, le problème est envoyé à un serveur public où la solution est calculée et renvoyée à Python.

Bien que cette question concerne spécifiquement la résolution de la programmation non linéaire en Python, je soulignerai également quelques autres types de problèmes que GEKKO peut résoudre, ainsi que des ressources pour l'optimisation de l'apprentissage. GEKKO résout également des équations algébriques à nombres entiers et différentiels et dispose de plusieurs objets préprogrammés pour les contrôles avancés (similaires à DMC, RMPCT, etc.). Les modes de fonctionnement incluent la réconciliation des données, l'optimisation en temps réel, la simulation dynamique et le contrôle prédictif non linéaire.

J'enseigne deux cours sur l'optimisation (optimisation de la conception et optimisation dynamique ) et j'ai mis en ligne le matériel de cours. Le cours d’optimisation dynamique est offert chaque année à partir de janvier et nous utilisons le progiciel GEKKO Python (et MATLAB) pour le cours. GEKKO est une extension de la suite d’optimisation APMonitor, mais a intégré la modélisation et la visualisation de la solution directement dans Python. Les références APMonitor et GEKKO donnent un exemple des types d'applications pouvant être résolues avec ce package. GEKKO est développé dans le cadre de la subvention de recherche de la National Science Foundation n ° 1547110 .

Qu'en est-il de scipy.fmin_slsqp?

http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.fmin_slsqp.html

PyGMO contient plusieurs solveurs, leur fournissant la même interface. IPOPT et scipy slsqp sont inclus dans le cas où vous compilez le code et téléchargez / installez le code tiers de manière indépendante.

En bonus, l'utilisation parallèle du solveur est très facile (multi-partages) via la classe archipel!

Il y a cvxmod , un wrapper Python autour du logiciel d'optimisation convexe de Stephen Boyd. Cela fait partie du paquet Sage .

fmincon peut maintenant être utilisé depuis Python via le framework OpenOpt, avec éventuellement une différenciation automatique dense / sparse par FuncDesigner http://openopt.org/fmincon

$\to$ $\to$

Les sauts de bassin via scipy suffisent-ils à vos besoins? S'il renvoie un minimum local et non un minimum global, vous pouvez modifier le nombre d'itérations et / ou appliquer des limites.

Qu'en est-il de CMA-ES? Il possède des liaisons Python et est bien adapté aux problèmes d’optimisation non convexes et non linéaires et je l’utilise assez souvent: https://www.lri.fr/~hansen/cmaesintro.html

Installation par pip:

pip install cma

Voici un exemple de code de leur site web:

import cma
help(cma)  # "this" help message, use cma? in ipython
help(cma.fmin)
help(cma.CMAEvolutionStrategy)
help(cma.CMAOptions)
cma.CMAOptions('tol')  # display 'tolerance' termination options
cma.CMAOptions('verb') # display verbosity options
res = cma.fmin(cma.Fcts.tablet, 15 * [1], 1)
res[0]  # best evaluated solution
res[5]  # mean solution, presumably better with noise

Puisque MATLAB a un compilateur JIT alors que CPython ne l’a pas encore (du moins, jusqu’à ce que pypy obtienne une prise en charge complète de numpy). Il semble que vous souhaitiez un résolveur gratuit plus performant que celui produit commercialement fmincon. N'est-ce pas trop?

Parmi les solveurs de PNL commerciaux, IIRC, seul snopt a jusqu’à présent fourni une API Python (bien que ce soit plutôt moche).

Quels solveurs OpenOpt avez-vous essayé? Combien de variables et de contraintes avez-vous dans votre tâche non-convexe?

Vous pouvez essayer IPOPT via l'API OpenOpt / Funcdesigner sans installation sur le serveur OpenOpt Sage ( observez l'image "Basculement de Sage en Python").

$10^{300}(x-0.1)^2 + 10^{-300}(y-0.2)^2$$(x,y) = (1,1)$

pour les problèmes globaux, vous pourriez être intéressé par http://openopt.org/interalg et d'autres solutions globales openopt (http://openopt.org/GLP) pour l'optimisation locale openopt fournit également une variété de solutions: http://openopt.org / PNL

Il est bon de mentionner ici que le résolveur Google Ceres est en réalité un optimiseur non linéaire très puissant, utilisé dans de nombreux projets.

Il existe également un wrapper Python disponible ici: https://github.com/rll/cyres

KNITRO possède des interfaces Python et MATLAB, entre autres. Considérez-le comme un remplacement FMINCON, mais beaucoup plus performant et plus coûteux. https://www.artelys.com/fr/optimization-tools/knitro#doc-tab .

Je suis un utilisateur de KNITRO, mais je ne suis pas affilié au produit.