精华内容
下载资源
问答
  • Update NLopt

    2020-11-29 23:20:16
    <div><p>Update to newer upstream <a href="https://github.com/stevengj/nlopt">NLopt</a>. This fixes the build if strict linking is enabled and fixes how testing is handled (such that drake could drive ...
  • NLOpt Support

    2021-01-03 13:52:13
    - Will NLOpt Integration be a part of the core library? Right now, I only use it in an example. - How should we impose stopping criteria? At the moment, in all of the other optimization algorithms we ...
  • Interface NLopt

    2020-12-29 06:07:24
    <div><p>NLopt (http://ab-initio.mit.edu/wiki/index.php/NLopt) is a library for NLP. It includes some interesting algorithms, for example for global optimization and derivative-free optimization. There...
  • Nlopt integration

    2020-11-29 10:12:58
    <div><p><a href="url">Fix</a> #1627 by including NLopt as a solver if SNOPT isn't available. <p>There are some TODO items present which don't have any tests (and represent some not-yet-...
  • Updating NLopt

    2020-12-07 09:34:00
    <div><p>Mainly due to this: https://github.com/stevengj/nlopt/pull/128</p> <p>Our failure: https://drake-cdash.csail.mit.edu/viewDynamicAnalysisFile.php?id=141209 <p><a href=...
  • roboptim-core-plugin-nlopt 有关该项目的一般信息,请参阅其主页: :
  • Use system nlopt

    2020-12-07 09:20:47
    re building <a href="https://nlopt.readthedocs.io/en/latest">nlopt</a> in bazel build. I'm wondering if we can switch to use the one in a system. FYI, both of macOS (via homebrew) and Xenial ...
  • NLopt.jl:从Julia语言调用NLopt非线性优化库的程序包
  • nlopt程序包

    2017-12-05 11:32:04
    nlopt官网程序包,进行优化的一个C++的优化包,可以用于C++,已经生成lib文件
  • NLopt详细介绍

    千次阅读 2019-10-22 11:28:49
    NLopt 介绍 在本手册的这一章中,我们首先概述NLopt解决的优化问题,不同类型的优化算法之间的主要区别,并评论以NLopt要求的形式转换各种问题的方法。我们还将描述NLopt的背景和目标

    NLopt 介绍(NLopt Introduction)

    在本手册的这一章中,我们首先概述NLopt解决的优化问题,不同类型的优化算法之间的主要区别,并评论以NLopt要求的形式转换各种问题的方法。我们还将描述NLopt的背景和目标

    1 优化问题(Optimization problems)

    • NLopt解决了以下形式的一般非线性优化问题
      minxRnf(x)\min_{\mathbf{x}\in\mathbb{R}^n} f(\mathbf{x})
      其中 f 是目标函数,x表示n优化参数(也称为设计变量或决策参数)。
    • 此问题可以有选择地受到边界约束(也称为box约束):
      lbixiubilb_i \leq x_i \leq ub_ii=1,,ni=1,\ldots,n
      给定下限lb和上限ub(对于部分或完全无约束的问题分别为-∞和/或+∞)。如果lbi=ubilb_i = ub_i,则该参数将被消除。
    • 一个参数也可以选择具有m非线性不等式约束(有时称为非线性规划问题):
      fci(x)0fc_i(\mathbf{x}) \leq 0i=1,,mi=1,\ldots,m
    • 对于约束函数fci(x)。一些NLopt算法还支持p个非线性等式约束:

    hi(x)=0h_i(\mathbf{x}) = 0i=1,,pi=1,\ldots,p

    • 更一般地,几个约束可以一次组合成一个返回向量值结果的函数。
    • 满足所有边界约束、不等式和等式约束的点x称为可行点,所有可行点的集合为可行区域
    • 【注意】:在本简介中,我们遵循通常的数学惯例,即让我们的索引(序号)从1开始。然而,在C编程语言中,NLopt遵循C的从零开始的约定(例如,约束 i 为从0到m -1)。

    2 全局优化与局部优化(Global versus local optimization)

    • NLopt包含尝试对目标进行全局局部优化的算法。

    2.1 全局优化(Global optimization)

    • 全局优化是找到在整个可行区域内使目标fx)最小的可行点x的问题。
    • 通常,这可能是一个非常困难的问题,随着参数数量n的增加,难度将成倍增加。
    • 实际上,除非知道有关 f 的特殊信息,否则甚至无法确定是否找到了真正的全局最优值,因为可能会出现 f 值的突然下降,且这个值隐藏在您尚未查找的参数空间中。
    • 但是,NLopt包含几种全局优化算法,如果维度n不太大(if the dimension n is not too large),它们可以很好且合理地处理优化问题(work well on reasonably well-behaved problems)。

    2.2 局部优化(Local optimization)

    • 局部优化是一个容易得多的问题。
    • 它的目标是找到一个仅是局部最小值的可行点x:f(x)小于或等于所有附近可行点的f值(可行区域与x的至少某个小邻域的交点(the intersection of the feasible region with at least some small neighborhood of x)不知道该怎么翻译,这句话也不重要)。
    • 通常,非线性优化问题可能有很多局部最小值,算法确定的最小值位置通常取决于用户提供给算法的起点。
    • 另一方面,即使在非常高维的问题中(尤其是使用基于梯度的算法),局部优化算法通常也可以快速定位局部最小值。
    • 在某种程度上令人迷惑的是,一个算法,如果可以保证从任何可行的起点找到局部最小值,则称为全局收敛。

    2.3 凸函数优化的问题

    • 在特殊类别的凸优化问题中,目标和不等式约束函数都是 凸函数 (并且等式约束是仿射变换,或者在任何情况下都具有凸水平集),因此只有一个局部最小值f,因此局部优化方法能找到一个全局最优解。
    • 但是,可能会有不止一个点x产生相同的最小值f(x),最优点形成(凸)可行区域的凸子集。
    • 通常,凸问题是由特殊分析形式的功能引起的,例如线性规划问题,半定规划,二次规划等,并且可以使用专门的技术非常有效地解决这些问题。
    • NLopt仅包含不假定凸性的常规方法;
    • 如果您遇到了凸的问题,最好使用其他软件包,例如Stanford 的 CVX 软件包

    3 基于梯度算法与无导数算法(Gradient-based versus derivative-free algorithms)

    3.1 梯度算法

    • 尤其是对于局部优化,最高效的算法通常要求用户提供梯度∇ ˚F来得到任何给定点X的˚F(X)值(以及类似地用于任何非线性约束)。
    • 这利用了以下事实:原则上,几乎可以使用很少的额外计算量(最坏的情况是与第二次评估f相同)在计算f的值同时计算梯度。
    • 如果用一个快速的方法来计算的导数F不明显,人们通常认为计算∇ F使用了伴随方法,或可能使用自动区分工具。
    • 基于梯度的方法对于非常高维的参数空间(例如,成千上万个n或更大的n)的有效优化至关重要。

    3.2 无导数算法

    • 另一方面,如果将目标函数作为复杂程序提供,则计算梯度有时会很麻烦且不便。
    • 如果f是不可导的(或更糟的是不连续的),可能是不可计算的。
    • 在这种情况下,通常使用无导数算法进行优化更简单,该算法仅要求用户提供给定点x的函数值 f(x)。
    • 这种方法通常必须对f进行至少几倍n点的评估(Such methods typically must evaluate f for at least several-times-n points),因此,当n比较小或中等(最多数百个)时,最好使用它们。

    3.3 NLopt对于上述算法的处理

    • NLopt提供具有公共接口的无导数算法和基于梯度的算法。

    3.4 注意事项

    • 如果你发现自己通过有限差分近似来计算梯度,比如(在一维中)
      f/x[f(x+Δx)f(xΔx)]/2Δx\partial f/\partial x \approx [f(x+\Delta x) - f(x -\Delta x)]/2\Delta x
      你应该使用一个无导数的算法。
    • 有限差分近似不仅昂贵(使用中心差异对梯度进行2n函数评估),而且它们也很容易受到舍入误差的影响,除非你非常小心。
    • 在另一方面,有限差分近似是非常有用的检查你的分析梯度计算是否正确的方式。
    • 这是一个好主意,因为根据我的经验,梯度代码很容易产生bug。
    • 不正确的梯度将会引起基于梯度的优化算法的奇怪问题。

    4 优化问题的等效公式(Equivalent formulations of optimization problems)

    There are many equivalent ways to formulate a given optimization problem, even within the framework defined above, and finding the best formulation can be something of an art.
    即使在上述定义的框架内,也存在许多等效的方法来公式化给定的优化问题,而寻找最佳公式可以被称为是一种艺术

    • 从一个简单的例子开始,假设你想要找到函数g(x)的最大值。其实这可以等效为求函数 f(x)=−g(x) 的最小值。因此,除了求最小例程外,NLopt没必要去提供一个求最大的例程,用户只需翻转符号即可进行最大化。但是,为方便起见,NLopt提供了一个最大化接口(该接口在内部为您执行必要的符号翻转)。
    • 一个更有趣的示例是极大极小优化问题,其中目标函数 f(x) 是N个函数的最大值:
      f(x)=max{g1(x),g2(x),,gN(x)}f(\mathbf{x}) = \max \{ g_1(\mathbf{x}), g_2(\mathbf{x}), \ldots, g_N(\mathbf{x}) \}
    • 当然,您可以将此目标函数直接传递给NLopt,但是这里存在一个问题: f(x) 并非在所有地方都是可微的(假设 gk 是可微的, f(x) 只是分段可微的)。这不仅意味着最有效的基于梯度的算法不适用,而且甚至无导数算法也可能会大大减慢速度。取而代之的是,可以通过添加虚拟变量t和N个新的非线性约束(以及任何其他约束)来将相同的问题表述为可微问题:
      minxRn,tRt\min_{x\in\mathbb{R}^n, t\in\mathbb{R}} t
      gk(x)t0,k=1,2,,Ng_k(\mathbf{x}) - t \leq 0,k=1,2,\ldots,N
    • 这完全解决了相同的最大最小问题,但是现在我们有了一个可微分的目标和约束条件。假设每个 gk 都可以被微分,注意,在这种情况下,目标函数本身就是无聊的线性函数 t,所有有趣的东西都在约束中。这是许多非线性编程问题的典型特征。
    • 另一个例子是最小化函数 g(x) 的绝对值 g(x)|g(\mathbf{x})|,这等价于最小化max{g(x),g(x)}\max \{ g(\mathbf{x}), -g(\mathbf{x}) \}。但是,这可以像上面的minimax示例中一样转换为可微分的非线性约束。

    5 等式约束(Equality constraints)

    • 假设您具有一个或多个非线性等式约束
      hi(x)=0h_i(\mathbf{x}) = 0.
    • 理论上,每个等式约束可以用两个不等式约束表示。hi(x)0h_i(\mathbf{x}) \leq 0hi(x)0-h_i(\mathbf{x}) \leq 0。因此您可能会认为任何可以处理不等式约束的代码都可以自动处理等式约束。但是在实践中,这是不正确的——如果您尝试将等式约束表示为一对非线性不等式约束,则某些算法将无法收敛。
    • 等式约束有时需要特殊处理,因为它们会减小可行区域的维度,而不仅仅是不等式约束的大小。当前只有某些NLopt算法(AUGLAG,COBYLA和ISRES)支持非线性等式约束。

    5.1 消除(Elimination)

    • 有时,可以通过消除过程来处理相等约束:您可以使用等式约束,根据其他未知参数,显式求解某些参数。然后将这个未知参数作为优化参数传入NLopt。

    Sometimes, it is possible to handle equality constraints by an elimination procedure: you use the equality constraint to explicitly solve for some parameters in terms of other unknown parameters, and then only pass the latter as optimization parameters to NLopt.

    • 举个例子,假设你有一个线性等式约束:
      Ax=bA\mathbf{x} = \mathbf{b}
    • 对于某个常数矩阵 A ,给定这些方程的一个特解 ξ 和一个矩阵 N ,其中 N 的列决定了 A零空间。则可以用以下形式表示这些线性方程的所有可能解:

    for some constant matrix A. Given a particular solution ξ of these equations and a matrix N whose columns are a basis for the nullspace of A, one can express all possible solutions of these linear equations in the form:

    x=ξ+Nz\mathbf{x} = \boldsymbol{\xi} + N\mathbf{z}

    • 对于未知向量 z 。随后,您可以将 z 作为优化参数传递给NLopt而不是 x ,从而消除等式约束。
    • 【注意】在矩阵 N 的数值计算零空间时需要注意,因为舍入误差会倾向于使矩阵 A 的奇异值比应有的少。一种技术标准就是去计算矩阵 A奇异值分解(SVD, Singular value decomposition) 并且将所有小于阈值的奇异值设置为0

    5.2 惩罚函数(Penalty functions)

    • 解决等式约束(以及不等式约束)的另一种流行方法是在目标函数中包含某种惩罚函数(又称为罚函数),该函数惩罚违反约束的x值。这种标准技术被称为增强拉格朗日方法,该方法的一种变体是在NLopt的AUGLAG算法中实现的。
    • (对于不等式约束,惩罚概念的一种变体是一种障碍方法:这只是一种惩罚,随着接近约束而发散,这迫使优化保持在可行范围内。)

    6 终止条件(Termination conditions)

    • 对于任何优化算法,必须提供一些终止条件,以指定算法何时停止。理想情况下,当发现最佳值在某个所需的公差范围内时,算法应停止运行。然而,实际上,由于真正的最优值是不会提前知道的,因此人们对解决方案中的误差使用启发式估计,而不是实际误差。
    • NLopt为用户提供了几种不同的终止条件的选择。对于任何给定的问题,你无需指定所有的终止条件。您应该只设置所需的条件。当满足第一个指定终止条件(即,您指定的最弱条件是最重要的条件)时,NLopt将终止。
    • NLopt支持的终止条件如下:

    6.1 函数值和参数公差(Function value and parameter tolerances)

    • 首先,您可以在函数值上指定分数公差ftol_rel和绝对公差ftol_abs。理想情况下,与确切的最小函数值相比,它们将是最大分数和绝对误差,但这是不可能的,因为最小值未知。取而代之的是,大多数算法将其实现为函数值从一个迭代到下一个迭代(或类似迭代)减小Δf的容差:如果|Δf| / | f | 小于ftol_rel或|Δf| 小于ftol_abs,算法就会停止。
    • 同样,您可以在参数x上指定分数公差xtol_rel和绝对公差xtol_absi 。同样,实际误差 Δx与(未知的)最小值相比得到误差是不可能的,所以在实际中Δx通常是测量x从一次迭代到下一次迭代的变化,或者是搜索区域的直径等。然后算法停止于|Δxi| < xtol_absi 或 |Δxi|/|xi| < xtol_rel。
    • Note: generally, you can only ask for about half as many decimal places in the xtol as in the ftol. The reason is that, near the minimum, Δff(Δx)2/2\Delta f \approx f'' (\Delta x)^2 / 2 from the Taylor expansion, and so (assuming f1f'' \approx 1 for simplicity) a change in x by 10–7 gives a change in f by around 10–14. In particular, this means that it is generally hopeless to request an xtol_rel much smaller than the square root of machine precision.

    In most cases, the fractional tolerance (tol_rel) is the most useful one to specify, because it is independent of any absolute scale factors or units. Absolute tolerance (tol_abs) is mainly useful if you think that the minimum function value or parameters might occur at or close to zero.

    If you don’t want to use a particular tolerance termination, you can just set that tolerance to zero and it will be ignored.

    Stopping function value

    Another termination test that NLopt supports is that you can tell the optimization to stop when the objective function value f(x) reaches some specified value, stopval, for any feasible point x.

    This termination test is especially useful when comparing algorithms for a given problem. After running one algorithm for a long time to find the minimum to the desired accuracy, you can ask how many iterations algorithms require to obtain the optimum to the same accuracy or to some better accuracy.

    Bounds on function evaluations and wall-clock time

    Finally, one can also set a termination condition by specifying a maximum number of function evaluations (maxeval) or a maximum wall-clock time (maxtime). That is, the simulation terminates when the number of function evaluations reaches maxeval, or when the total elapsed time exceeds some specified maxtime.

    These termination conditions are useful if you want to ensure that the algorithm gives you some answer in a reasonable amount of time, even if it is not absolutely optimal, and are also useful ways to control global optimization.

    Note that these are only rough maximums; a given algorithm may exceed the specified maximum time or number of function evaluations slightly.

    Termination tests for global optimization

    In general, deciding when to terminate a global optimization algorithm is a rather difficult problem, because there is no way to be certain (without special information about a particular f) that you have truly reached the global minimum, or even come close. You never know when there might be a much smaller value of the objective function lurking in some tiny corner of the feasible region.

    Because of this, the most reasonable termination criterion for global optimization problems seems to be setting bounds on the run time. That is, set an upper bound on how long you are willing to wait for an answer, and use that as the maximum run time. Another strategy is to start with a shorter run time, and repeatedly double the run time until the answer stops changing to your satisfaction. (Although there can be no guarantee that increasing the time further won’t lead to a much better answer, there’s not much you can do about it.)

    I would advise you not to use function-value (ftol) or parameter tolerances (xtol) in global optimization. I made a half-hearted attempt to implement these tests in the various global-optimization algorithms, but it doesn’t seem like there is any really satisfactory way to go about this, and I can’t claim that my choices were especially compelling.

    For the MLSL algorithm, you need to set the ftol and xtol parameters of the local optimization algorithm control the tolerances of the local searches, not of the global search; you should definitely set these, lest the algorithm spend an excessive amount of time trying to run local searches to machine precision.

    Background and goals of NLopt

    NLopt was started because some of the students in our group needed to use an optimization algorithm for a nonlinear problem, but it wasn’t clear which algorithm would work best (or work at all). One student started by downloading one implementation from the Web, figuring out how to plug it into her Matlab program, getting it to work, only to find that it didn’t converge very quickly so she needed another one, and so on… Then another student went through the same process, only his program was in C and he needed to get the algorithms to work with that language, and he obtained a different set of algorithms. It quickly became apparent that the duplication of effort was untenable, and the considerable labor required to decipher each new subroutine, figure out how to build it, figure out how to bridge the gap from one language (e.g. Fortran) to another (e.g. Matlab or C), and so on, was so substantial that it was hard to justify trying more than one or two. Even though the first two algorithms tried might converge poorly, or might be severely limited in the types of constraints they could handle, or have other limitations, effective experimentation was impractical.

    Instead, since I had some experience in wrapping C and Fortran routines and making them callable from C and Matlab and other languages, it made sense to put together a common wrapper interface for a few of the more promising of the free/open-source subroutines I could find online. Soon, it became clear that I wanted at least one decent algorithm in each major category (constrained/unconstrained, global/local, gradient-based/derivative-free, bound/nonlinear constraints), but there wasn’t always free code available. Reading the literature turned up tantalizing hints of algorithms that were claimed to be very powerful, but again had no free code. And some algorithms had free code, but only in a language like Matlab that was impractical to use in stand-alone fashion from C. So, in addition to wrapping existing code, I began to write my own implementations of various algorithms that struck my interest or seemed to fill a need.

    Initially, my plan was to handle only bound constraints, and leave general nonlinear constraints to others—who needs such things? That attitude lasted until we found that we needed to solve a 10,000-dimensional minimax-type problem, which seemed intractable unless gradient-based algorithms could be brought to bear…as discussed above, this requires nonlinear constraints to make the problem differentiable. After some reading, I came across the MMA algorithm, which turned out to be easy to implement (300 lines of C), and worked beautifully (at least for my problem), so I expanded the NLopt interface to support nonlinear constraints.

    Overall, I’ve found that this has been surprisingly fun. Every once in a while, I come across a new algorithm to try, and now that I’ve implemented a few algorithms and built up a certain amount of infrastructure, it is relatively easy to add new ones (much more so than when I first started out). So, I expect that NLopt will continue to grow, albeit perhaps more slowly now that it seems to include decent algorithms for a wide variety of problems.

    展开全文
  • <div><p>I am a beginner trying to use the NLOpt toolbox with Matlab. I am following the example given <a href="http://ab-initio.mit.edu/wiki/index.php/NLopt_Tutorial#Example_in_Matlab_or_GNU_Octave">...
  • Improved the NLopt interface

    2020-12-09 11:58:45
    <div><p>It is now possible to map nlopt algorithms names with nlopt algorithms IDs. New shortcuts are also provided for the following algorithms: MMA/CCSAQ/COBYLA/BOBYQA</p><p>该提问来源于开源项目&#...
  • PKG Add nlopt package

    2021-01-11 09:26:18
    <div><p>The inclusion of <a href="https://nlopt.readthedocs.io/en/latest/">nlopt</a> will address issues #834 and #522 where the current SciPy minimize library is not functional due to Fortran ...
  • <div><p>My nlopt Python wheel builder is almost done, it already works on Linux and MacOS, but I am getting a compile error on Windows. I am not a Windows expert, so help would be very much apreciated...
  • added the nlopt guard

    2021-01-07 09:01:46
    This should fix the building failure when nlopt is missing <p>see http://buildbot.shogun-toolbox.org/builders/bsd1%20-%20libshogun/builds/2699</p><p>该提问来源于开源项目:shogun-toolbox/shogun...
  • bad nlopt library reference

    2020-12-01 16:53:45
    s on my mac which touch drakeOptimization when nlopt is built. <p>The symptom is <pre><code> drake008% drake/bin/acrobotURDFDynamicsTest dyld: Library not loaded: /Users/russt/drake-distro/build/lib/...
  • It does not list nlopt as dependency. <p>The symptom I am seeing is: my drake-distro is in a state where it downloads nlopt and has it in the list-of-things-to-superbuild, but doesn't think that ...
  • cmake -DENABLE_NLOPT=OFF -DPythonModular=ON .. make </code></pre> <p>l even removed nlopt : <code>sudo apt-get remove python-nlopt</code></p> <p>if the problem comes from nlopt how to solve ...
  • <div><p>I am tryhing to build nlopt under Ubuntu 18.04.1 and I am getting this error: <pre><code> arrigo-Z370N-WIFI:~/nlopt/nlopt-2.5.0$ cmake . -- NLopt version 2.5.0 Traceback (most recent call last...
  • <div><p>There is a nlopt package on PyPI which seems to be maintained by other developers. https://pypi.org/project/nlopt/</p> <p>This package does not work on OSX and possibly other systems. The ...
  • <div><p>I am quite new to Linux system, and trying to follow the installation instructions in https://nlopt.readthedocs.io/en/latest/NLopt_Installation/ I have many issues and ...stevengj/nlopt</p></div>
  • <div><p>Create missing nlopt.hpp and nlopt.f when building with CMake Use CMake's GNUInstallDIrs (e.g, ${CMAKE_INSTALL_LIBDIR} instead of lib) depending on platform Fix for MSVC 2015 compiler</p>...
  • <div><p>and remove subclasses as NLopt does not expose any algorithm-specific interface. Also for consistency, why add only some shortcuts (to SLSQP, BFGS, ...) and not all of them.</p><p>该提问来源于...
  • NLOPT ros下的使用

    2020-03-22 23:17:39
    NLOPT是优化库,在路径规划中可以用于对目标函数的优化,在这里对它的使用进行记录,这个是初稿,后面还会进行修改。 1.NLOPT的安装 sudo apt-get install libnlopt-dev 2.NLOPT的导入 #include "nlopt.h" 3....

    NLOPT是优化库,在路径规划中可以用于对目标函数的优化,在这里对它的使用进行记录,这个是初稿,后面还会进行修改。

    1.NLOPT的安装

    直接使用安装包进行编译安装,否则ros下会无法找到这个包。

    2.NLOPT的导入

    cmake的写法(以一个具体的cmake为例)

    cmake_minimum_required(VERSION 2.8.3)
    project(nlop_learning)
    
    find_package(catkin REQUIRED COMPONENTS
      roscpp
      rospy
      std_msgs
    )
    
    find_package(NLopt REQUIRED)
    
    set(NLopt_INCLUDE_DIRS ${NLOPT_INCLUDE_DIR})
    
    catkin_package(
      INCLUDE_DIRS include
    )
    
    include_directories(
        include 
        SYSTEM 
        third_party
        ${catkin_INCLUDE_DIRS}  
        ${NLOPT_INCLUDE_DIR}
    )
    
    set(CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS} -O3 -Wall") # -Wextra -Werror
    
    add_executable( basic_node
       src/basic.cpp
    )
    
    target_link_libraries( basic_node
       ${catkin_LIBRARIES}
       ${NLOPT_LIBRARIES}
    )
    

    头文件的引入

    #include "nlopt.h"

    3.求解优化

    展开全文
  • nimnlopt:非线性优化库Nlopt的包装
  • nlopt的python环境安装

    2019-10-20 11:21:22
    1.1 什么是nlopt? 一款轻量级的线性优化库,支持多种语言,包括c、c++、matlab、python等 GitHub地址:https://github.com/stevengj/nlopt/ 官方文档:https://nlopt.readthedocs.io/en/latest/ PyPI地址:...

    1 前言

    1.1 什么是nlopt?

    1.2 为什么单独讲一下要怎么安装这个nlopt

    • 因为他的安装过程容易踩很多坑,并且网上很少有中文的教程。
    • 很多人直接下载了nlopt的GitHub库,然后成功装了很多和python屁用没有的东西
    • 装这个python的包根本就不需要下载他的GitHub库!!!!
    • 直接pip install nlopt可能会报错,原因未知

    1.3 前期准备

    • 因为我使用的是python,所以需要先装一下python和编译器,python的安装过程网上比较多,在这里就不提供了
    • 编译器我推荐PyCharm,网上也有许多安装教程。提示一下,如果你是学生党并且还在纠结如何破解PyCharm的话,你就不用再纠结了。学生可以申请免费的正版pycharm,只需要填写验证一些信息就可以了。安装并免费使用Pychram专业版(学生/教师)
    • 安装wheel
      打开cmd命令行,输入pip install wheel
      是否装好可以用pip list命令来看已经装的包

    1.4 环境说明

    • 系统:Windows10,64位
    • python3.8

    2 开始安装nlopt

    • 首先确定你上面的内容都已安装完成
    • 打开nlopt的文档,找到有关windows的网页https://nlopt.readthedocs.io/en/latest/NLopt_on_Windows/
    • 在这里插入图片描述
    • 点击如上图所示的链接
    • 在这里插入图片描述
    • 因为我的环境是python3.8,所以选择了最后一个文件。具体选择什么视python版本和系统决定。
    • 定位到你下载的位置,我是C:\Users\username\Downloads,然后在这个路径下运行cmd
    • 在地址栏输入cmd,敲回车。在这里插入图片描述
    • 安装这个包。输入指令,最后那个是刚刚下载的文件的名字,具体视你下载的文件名而定
    pip install NLopt-2.6.1-cp38-cp38-win_amd64.whl
    
    • 安装结束
    • 说实话我装了一天,踩了无数的坑。。。。
    展开全文
  • I am using several optimizers from nlopt in Python. I sometimes encounter an unexpected result when using the COBYLA optimizer. <p>I am trying to minimize a function subject to a non-linear constraint...
  • Add nlopt in setup scripts

    2020-11-29 00:44:53
    <p>When this PR is merged and CI images are updated, I will open another PR to use system nlopt in Drake. <p>This change is <a href="https://reviewable.io/reviews/robotlocomotion/drake/7358"><img ...
  • <div><p>It would the great to expose the DIRECT algorithm that is available in NLopt.</p><p>该提问来源于开源项目:esa/pagmo2</p></div>
  • NLopt中的无导数算法

    2020-09-06 15:02:10
    NLopt中的无导数算法无导数全局最优算法DIRECT和DIRECT-L (本文所涉及各量皆为C风格,即包含头文件的是nlopt.h而非nlopt.hpp) 首先说一下NLopt中算法的命名规则,C风格的命名规则为NLOPT_{G,L}{N,D}_xxxx,其中G/L...


    (本文所涉及各量皆为C风格,即包含的头文件是nlopt.h而非nlopt.hpp
    首先说一下NLopt中算法的命名规则,C风格的命名规则为NLOPT_{G,L}{N,D}_xxxx,其中G/L代表全局最优与局部最优,N/D代表无导数与有导数。例如NLOPT_LN_COBYLA则表示无导数局部最优的COBYLA算法。
    这里的导数是我们算完之后填入

    if (grad)
    {
    	/* 各变量的导数 */
    }
    

    中的,但是在很多情况下,当问题很复杂时,很难求解出其导数,这个时候就需要使用无导数的算法。

    无导数全局最优算法

    这种算法的命名为NLOPT_GN_xxxx。最简单的方法就是在编译器中输入NLOPT_GN_,然后它会自己弹出来有哪些算法,一个一个试,看哪个满足自己的要求即可:)。

    DIRECT和DIRECT-L

    DIRECT指的是Dividing Rectangles算法。
    首先是基本的NLOPT_GN_DIRECTNLOPT_GN_DIRECT_L。其中NLOPT_GN_DIRECT将更多的精力放在了全局,而NLOPT_GN_DIRECT_L算法在局部的表现会更好,其适用于没有过多局部最小值的函数。
    其次是NLOPT_GN_DIRECT_L_RAND,该变体加入了一点随机性以帮助确定将哪个维度二等分。
    由于DIRECT算法将各约束缩放为超立方体(与正方体类似,只是正方体为三维,而超立方体为指定维度),因此所有维度的搜索权重是相同的。如果你要搜索的空间与超立方体相差甚远,则更适合用DIRECT的变体NLOPT_GNL_DIRECT_NOSCAL, NLOPT_GN_DIRECT_L_NOSCALNLOPT_GN_DIRECT_L_RAND_NOSCAL
    同时,还可以使用基于原始的Fortran语言写的NLopt算法NLOPT_GN_ORIG_DIRECT, NLOPT_GN_ORIG_DIRECT_L,在不同的情况下,这两个的表现可能会更好,不过也可能会变差,需要实际尝试。

    Controlled Random Search (CRS) with local mutation

    CRS算法有点像遗传算法,它俩都是从一群随机种群点开始,通过启发式规则来随机进化这些点。
    CRS的初始种群大小在n个维度上默认为10×(n+1),但这可以通过nlopt_set_population函数来改变;初始总体必须至少是n+1。同时,该算法只支持有界约束问题。
    具备局部突变的CRS算法在NLopt中的名字为NLopt_GN_CRS2_LM

    MLSL (Multi-Level Single-Linkage)

    MLSL都是一种“多启动”算法:它通过从随机的或低差异的起始点执行一系列局部优化(使用一些其他的局部优化算法)来工作。MLSL是有区别的,但是“聚类”启发式帮助它避免重复搜索相同的局部最优解,并有一些理论保证在有限数量的局部最小化中找到所有的局部最优解。
    MLSL的本地搜索部分可以使用NLopt中的任何其他算法,可以使用基于梯度(D)或无梯度算法(N)。本地搜索使用由nlopt_opt_set_local_optimizer设置的导数/非导数算法。
    基于LDS的MLSL算法被指定为NLOPT_G_MLSL_LDS,而原始的非LDS原始MLSL(使用伪随机数,目前通过Mersenne twister算法)由NLOPT_G_MLSL表示。在这两种情况下,都必须通过nlopt_opt_set_local_optimizer指定本地优化算法(可以是基于梯度的,也可以是无衍生的)。
    注意:如果用户没有设置停止容忍度,MLSL默认为ftol_rel=10−15,xtol_rel=10−7用于局部搜索。请注意,为这些本地搜索设置一个相对较大的容错,运行MLSL,然后在最后运行另一个容错较低的本地优化(使用MLSL结果作为起点),将最优值“清除”到高精度,这是完全合理的。
    默认情况下,MLSL的每次迭代都采样4个随机的新试验点,但是这可以通过nlopt_set_population函数进行更改。
    该算法只支持有界约束的问题。

    StoGo

    StoGO是一种全局优化算法,其系统地把搜索空间(必须是有界约束)分成小的超矩形(通过一种分支界定技术),然后通过一个基于梯度的局部搜索算法(一种BFGS变体)进行搜索,可选地包括一些随机性(因此“Sto”代表“随机”)。
    StoGO是用C++编写的,这意味着只有在编译启用C++算法才能包含它,在这种情况下(在Unix上)必须链接到-lnlopt_cxx而不是-lnlopt
    StoGO在NLopt中由NLOPT_GD_STOGO指定,或NLOPT_GD_STOGO_RAND指定其包含随机性的变体。
    该算法只支持有界约束的问题。

    AGS

    AGS可以处理任意目标和非线性不等式约束。这个方法还需要绑定约束。为了保证收敛性,目标和约束必须在指定的超矩形上满足Lipschitz条件。该算法是无导数的,利用希尔伯特曲线将源问题简化为单变量问题。该算法将单变量空间划分为区间,利用后验概率生成新的点。在每次试验中,AGS试图逐个评估约束条件。如果此时违反了某些约束,则不会计算下一个约束。如果保留了所有的约束条件,即试验点是可行的,那么AGS将对目标进行评估。因此,一些约束(除了第一个)和目标可以在搜索超矩形内部分未定义。当前的AGS算法不支持向量约束。
    当空间维数大于5时,机器算法的局限性不允许为希尔伯特建立一个紧密的近似值,所以这种AGS的实现在这个意义上受到限制。它最多支持10个维度,但是该方法可以在6个或更多维度的情况下提前停止。
    和StoGO一样,AGS也是用C++写的,但是AGS需要编译器支持C++11且库需要使用C++来built。
    AGS在NLopt中由NLOPT_GN_AGS指定。在ags.h中声明和描述了通用NLOpt接口中不能调整的AGS附加参数。在AGS源文件夹中给出了一个解决约束问题的例子。

    ISRES(改进的随机排序进化策略)

    (经本人试验,该算法在没有约束的多维线性问题中表现良好,推荐使用)
    该进化策略基于突变规则(具有对数正态步长更新和指数平滑)和微分变异(类似于nelder - meadist的更新规则)的组合。对于没有非线性约束的问题,适应度排序简单地通过目标函数进行,但当包含非线性约束时,采用Runarsson和Yao提出的随机排序。ISRES的种群大小在n个维度中默认为20×(n+1),但这可以通过nlopt_set_population函数进行更改。
    该方法除了支持约束外,还支持任意的非线性不等式和等式约束,并且在NLopt中指定为NLOPT_GN_ISRES

    ESCH(进化算法)

    这是一种改进的全局优化进化算法,该算法只支持边界约束,不支持非线性约束。在NLopt中指定为NLOPT_GN_ESCH

    无导数局部最优算法

    在无导数局部最优算法中,目前只有COBYLA算法支持任意非线性不等式与等式约束,其他算法只支持有界约束或无约束问题。(但是,通过与增广拉格朗日方法相结合,它们中的任何一个都可以应用于非线性约束问题。)
    当使用局部无导数算法时,需要考虑的是优化器必须以某种方式决定初始步长。默认情况下,NLopt选择这个初始步长,但这可能并不总是最好的选择。如果不合适的话,可以修改初始步长。

    COBYLA(线性逼近的约束优化)

    该算法通过n维n+1点的单纯形构造目标函数和约束的连续线性逼近,并在每一步的信赖区域中优化这些逼近。
    NLopt的版本在几个方面进行了轻微的修改。首先,合并了所有的NLopt终止条件;其次,我们添加了对边界约束的显式支持(尽管原始的COBYLA可以将边界约束处理为线性约束,但它有时会采取违反边界约束的步骤)。第三,我们允许COBYLA增加信任区域半径,如果预测的改进是近似正确的和单纯形是OK的,遵循一个建议,在SAS手册的PROC NLP似乎提高收敛速度。第四,我们在COBYLA算法中伪随机化单纯形步骤,通过避免不小心采取不能改善条件的步骤来提高鲁棒性(这种情况有时似乎在主动约束中发生);然而,算法仍然是确定性的(使用确定性种子)。此外,我们还支持不同参数的初始步长大小不相等(通过简单的内部调整参数与初始步长成比例),这在不同参数具有非常不同的尺度时非常重要。
    底层的COBYLA代码只支持不等式约束,然而等式约束被自动转换为不等式约束对,因此在这个算法中也可以使用等式约束。
    该算法在NLopt中指定为NLOPT_LN_COBYLA

    BOBYQA

    因为BOBYQA构造了目标的二次逼近,所以对于不能二次可微的目标函数,它可能执行得很差。
    NLopt BOBYQA接口支持不同参数中不相等的初始步长(通过简单的内部调整参数与初始步长成比例),当不同参数具有相差悬殊的尺度时这点非常重要。
    该算法在NLopt中指定为NLOPT_LN_BOBYQA,且在很大程度上取代了下面的NEWUOA算法,NEWUOA算法是Powell提出的相同思想的早期版本。

    具有边界约束的NEWUOA

    因为NEWUOA构造了一个目标的二次逼近,所以它对于非二次可微的目标函数可能表现不佳。
    原算法在NLopt中指定为NLOPT_LN_NEWUOA,只支持无约束问题。对于具有边界约束的问题,其变体为NLOPT_LN_NEWUOA_BOUND
    在原有的NEWUOA算法中,Powell通过截断共轭梯度算法求解了一个球形信任区域内的二次子问题(例为TRSAPP和BIGLAG)。在有界约束变体中,使用MMA算法来解决这些子问题的有界约束和球形信任区域。原则上,我们也应该以类似的方式改变BIGDEN子例程(因为BIGDEN也近似地解决了一个信任区域子问题),但是作者只是将它的结果截断为边界(这可能会给出次优收敛,但BIGDEN在极少数情况下才被调用)。
    在作者将边界约束添加到NEWUOA后不久,Powell发布了他自己的NEWUOA版本,用于边界约束以及一些数值稳定性和收敛性增强,称为BOBYQA。NLopt现在也合并了BOBYQA,它似乎在很大程度上取代了NEWUOA。
    注:NEWUOA要求参数空间的维数n≥2,即实现不处理一维优化问题。

    PRAXIS(PRincipal AXIS)

    在NLopt中指定为NLOPT_LN_PRAXIS
    该算法最初是为无约束优化设计的。在NLopt中,在实践中通过在违反约束时返回无穷大(Inf)的简单权能来“实现”绑定约束(这是自动完成的—您不必在自己的函数中这样做)。如果您有约束条件,那么最好使用COBYLA或BOBYQA。

    Nelder-Mead Simplex

    在NLopt中指定为NLOPT_LN_NELDERMEAD
    这种方法很简单,而且经久不衰,尽管后来发现它在一些函数中完全不收敛(在一些例子中,它可能收敛到不是局部最小值的点)。坊间证据表明,即使在嘈杂和/或不连续的目标函数中,它也经常表现良好。然而,作者更推荐Subplex方法(下面)。

    Sbplx (based on Subplex)

    在NLopt中指定为NLOPT_LN_SBPLX
    Subplex (Nelder-Mead的一种变体,它在子空间序列上使用Nelder-Mead)声称比最初的Nelder-Mead更有效、更可靠,同时保留了后者的设施,但目标不连续,根据我的经验,这些说法在很多情况下似乎都是正确的。(然而,并没有什么证据表明Subplex是全局收敛的,也许它会在一些目标上失败,比如Nelder-Mead)

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 337
精华内容 134
关键字:

NLopt