Optimization

ObjectiveFunction(f, g)

A bundle of an objective value f and its analytic gradient g, passed to minimize.

Fields

• f: objective function f(θ) -> value.
• g: gradient g(θ) -> vector.

minimize(obj, θ0; method=:lbfgs, iterations=nothing, store_trace=false, g_tol=nothing, …)

Minimize an ObjectiveFunction (a value plus its analytic gradient) starting from θ0 with the native L-BFGS (:lbfgs), BFGS (:bfgs), or adaptive regularization (:arc) method.

Theory

A differentiable objective $f(\theta)$ is minimized where its gradient vanishes, $\nabla f = 0$. The quasi-Newton methods here build a successive approximation $B_k$ of the inverse Hessian and take descent steps $\theta_{k+1} = \theta_k - B_k \nabla f(\theta_k)$, so each iterate moves downhill without ever forming $\nabla^2 f$. L-BFGS keeps only the last mem curvature pairs $(s, y)$, giving a bounded-memory approximation.

Arguments

• obj: an ObjectiveFunction bundling f(θ) and g(θ).
• θ0: the starting point.

Keyword options

• method = :lbfgs: :lbfgs, :bfgs, or :arc.
• iterations = nothing: the iteration budget (default 300).
• store_trace = false: record the iterate history in trace.
• g_tol = nothing: the gradient-norm tolerance (default 1e-8).
• callback = nothing: called once per iterate (including the starting point, pseudo_iteration = 0) with a named tuple (; x, f_x, g_x, pseudo_iteration); return true to stop early.
• linesearch = :morethuente: the step-size rule.
• mem = 10: the L-BFGS memory (number of curvature pairs).

Returns

A named tuple (minimizer, minimum, iterations, trace).

Example

julia> obj = ObjectiveFunction(θ -> (θ[1]-3)^2 + (θ[2]-4)^2, θ -> [2(θ[1]-3), 2(θ[2]-4)]);

julia> minimize(obj, [0.0, 0.0]).minimum == 0.0
true

See also: solve_nonlinear, brent_minimize.

brent_minimize(f, lo, hi; tol, maxiter) -> (x, f(x))

Brent's 1-D minimization of f over the bracket [lo, hi] (golden-section search combined with parabolic interpolation), assuming f is unimodal on the interval. Returns the minimizer x and its value f(x).

Example

julia> using Rasmah

julia> brent_minimize(x -> (x - 0.3)^2, 0.0, 1.0)
(0.3, 0.0)

remesh_optimize(build, θ0; remesh=:on_quality, quality_threshold=0.2, step=0.05, max_iter=50) -> RemeshOptimizationResult

Optimize a problem whose geometry must be remeshed along the way. build(θ) returns (mesh_at, obj, grad) for the current parameters; remesh ∈ :local, :on_quality, :every_iteration, :frozen controls when the mesh is rebuilt. Returns a RemeshOptimizationResult.

RemeshOptimizationResult

The result of remesh_optimize: the minimizer, the objective_history per iterate, and the number of remeshes performed (remesh_count).

@problem begin
    x = bounded(lo, hi)      # scalar, lo ≤ x ≤ hi
    y = free()               # free scalar
    z = positive()           # z > 0
    s = simplex(n)           # length-n probability simplex (xᵢ ≥ 0, Σ xᵢ = 1)
    M = psd(n)               # n×n PSD matrix
    v = free(3)              # length-3 vector
    minimize(obj_expression)
    subject_to(lhs == rhs)   # equality
    subject_to(lhs <= rhs)   # inequality
    subject_to(lhs >= rhs)   # inequality
end

Build an OptimizationProblem from a domain-declaration + expression DSL. Variable declarations use the domain constructors; minimize(...) sets the objective and subject_to(...) adds equality/inequality constraints.

free()          # scalar
free(n)         # length-n vector
free(n, m, …)   # n×m×… array

Unbounded real variable(s) of the given shape.

bounded(lo, hi)

Scalar variable constrained to lo ≤ x ≤ hi.

positive()

Scalar variable constrained to x > 0.

simplex(n)

Length-n vector variable constrained to the probability simplex {x : xᵢ ≥ 0, Σᵢ xᵢ = 1}.

psd(n)

Symmetric positive-semidefinite n×n matrix variable.

optimize(prob::OptimizationProblem, θ0; algorithm=:auglag, reparam=true, …)

Solve a constrained OptimizationProblem (built with @problem) from the starting point θ0.

Theory

A constrained problem is minimized over a feasible set — the points that satisfy every equality, inequality, bound, simplex, and PSD constraint. Rasmah handles the feasible set in two complementary ways. With reparam = true the variable domains are baked into a smooth change of variables (bounds become logistic, positivity becomes exp, a simplex becomes stick-breaking, a PSD cone becomes an unconstrained lower-triangular factor), so a plain unconstrained method can drive the search. For the constraints that cannot be absorbed that way, the solvers build an augmented Lagrangian — the objective plus a penalty on the constraint violations — and solve a sequence of unconstrained subproblems.

Arguments

• prob: the OptimizationProblem to solve.
• θ0: the initial flat parameter vector.

Keyword options

• algorithm = :auglag: the solver — :auglag (augmented Lagrangian), :lbfgs, :arc, :mma / :mma_nullspace / :mma_hybrid / :mma_aggregate, :interior_point, :sqp, :bayes, :direct, :cmaes, :nelder_mead, :memetic, :multistart, :hyperband, :asha, :bohb, :dehb.
• reparam = true: bake bounds/positivity/simplex/PSD into the variable transform.
• penalty_rule = :lancelot: the augmented-Lagrangian penalty update (:lancelot, :birgin_martinez, or :spectral).
• psd_form = :prox: the PSD-cone treatment (:prox or :classic).
• linear_eq / linear_ineq / bounds / psd: extra linear constraints, box bounds, and PSD blocks appended to those implied by prob.

Returns

A solver result with at least minimizer and minimum.

Example

julia> prob = @problem begin
           x = bounded(0.0, 1.0)
           y = free()
           minimize((x - 1)^2 + (y - 2)^2)
           subject_to(x + y == 2)
       end;

julia> r = optimize(prob, [0.5, 0.5]);

julia> isapprox(r.minimizer[1], 0.5; atol=1e-4) && isapprox(r.minimizer[2], 1.5; atol=1e-4)
true

optimize(prob::TopOptProblem; algorithm=:mma, volfrac=0.5, …)

Run topology optimization. algorithm ∈ :mma, :beso, :tobs. Returns (; x, history) — the per-element densities and the objective trace.