optimization - Optim.jl : negative inverse Hessian

Question

我使用BFGS算法使用Optim.jl库来最小化Julia中的函数。今天，我问了一个关于同一个库的question，但是为了避免混淆，我决定将它分成两部分。

我还想对优化后的负逆黑森州进行估算，以进行进一步的计算。

在Optim库的GitHub网站上，我找到了以下工作示例:

using Optim
rosenbrock(x) = (1.0 - x[1])^2 + 100.0 * (x[2] - x[1]^2)^2
result        = optimize(rosenbrock, zeros(2), BFGS())

优化后如何从 结果中获得负逆粗麻布？它中是否有任何字段标识Hessian，逆Hessian或负逆Hessian？

编辑

感谢您的评论。您是否认为编辑“optimize.jl”会更有效，以便函数也返回反黑森州？参见下面的工作示例-编辑已在第226行中进行了介绍:

 if state.method_string == "BFGS"
         return MultivariateOptimizationResults(state.method_string,
                                                initial_x,
                                                f_increased ? state.x_previous : state.x,
                                                f_increased ? state.f_x_previous : state.f_x,
                                                iteration,
                                                iteration == options.iterations,
                                                x_converged,
                                                options.x_tol,
                                                f_converged,
                                                options.f_tol,
                                                g_converged,
                                                options.g_tol,
                                                f_increased,
                                                tr,
                                                state.f_calls,
                                                state.g_calls,
                                                state.h_calls), state.invH
    else
         return MultivariateOptimizationResults(state.method_string,
                                                 initial_x,
                                                 f_increased ? state.x_previous : state.x,
                                                 f_increased ? state.f_x_previous : state.f_x,
                                                 iteration,
                                                 iteration == options.iterations,
                                                 x_converged,
                                                 options.x_tol,
                                                 f_converged,
                                                 options.f_tol,
                                                 g_converged,
                                                 options.g_tol,
                                                 f_increased,
                                                 tr,
                                                 state.f_calls,
                                                 state.g_calls,
                                                 state.h_calls)
     end

要不就:

return MultivariateOptimizationResults(state.method_string,
                                        initial_x,
                                        f_increased ? state.x_previous : state.x,
                                        f_increased ? state.f_x_previous : state.f_x,
                                        iteration,
                                        iteration == options.iterations,
                                        x_converged,
                                        options.x_tol,
                                        f_converged,
                                        options.f_tol,
                                        g_converged,
                                        options.g_tol,
                                        f_increased,
                                        tr,
                                        state.f_calls,
                                        state.g_calls,
                                        state.h_calls), state

优化后可以完全访问“状态”。

编辑2

由于此更改将在Optim.jl库的新版本中引入，因此无需继续讨论。现在，extended_trace和after_while!技巧工作。就个人而言，我更喜欢后者，因此我将结束讨论，为@Dan Getz提供正确答案。

Answer 1

另一种可行的方法不是最优方法，就是连接到内部Optim函数after_while!，该函数当前不执行任何操作，并使用它从最后一个状态中获取信息。

在Julia代码中，这看起来像:

julia> using Optim

julia> rosenbrock(x) = (1.0 - x[1])^2 + 100.0 * (x[2] - x[1]^2)^2
rosenbrock (generic function with 1 method)

julia> Optim.after_while!{T}(d, state::Optim.BFGSState{T}, method::BFGS, options)
  = global invH = state.invH

julia> result        = optimize(rosenbrock, zeros(2), BFGS())
Results of Optimization Algorithm
 * Algorithm: BFGS
 * Starting Point: [0.0,0.0]
 * Minimizer: [0.9999999926033423,0.9999999852005353]
 * Minimum: 5.471433e-17
 * Iterations: 16
 * Convergence: true
   * |x - x'| < 1.0e-32: false
   * |f(x) - f(x')| / |f(x)| < 1.0e-32: false
   * |g(x)| < 1.0e-08: true
   * f(x) > f(x'): false
   * Reached Maximum Number of Iterations: false
 * Objective Function Calls: 69
 * Gradient Calls: 69

julia> invH
2×2 Array{Float64,2}:
 0.498092  0.996422
 0.996422  1.9983  

这对于使用全局变量并取决于在运行/编译 after_while!之前定义 optimize并没有吸引力(但是在v0.6中可能已经解决了)。

正如@DSM在他的回答中指出的那样，很自然要访问优化程序的最后状态。如果跟踪不是答案，也许是。