OptimizationProfiler{S, opType, optsType}

A profiler method that uses stepwise re-optimization to profile the likelihood function.

Fields

• stepper::S: The algorithm used to compute the next profile point. Supported steppers include:
  • FixedStep: Proposes steps from the configured step rule in the profiling direction (Default).
  • AdaptiveStep: Adapts the step size based on trial objective increases.
• optimizer::opType: The optimizer used for the optimization process.
• optimizer_opts::optsType: Options for the optimizer. Defaults to NamedTuple().

Stepping Options

The stepper argument controls how the next profile point is chosen. For example:

• stepper = FixedStep(initial_step=0.1): Use a constant step size of 0.1.
• stepper = AdaptiveStep(predictor=LinearPredictor()): Use adaptive stepping with a secant-like linear predictor.

See the documentation for each stepper type (e.g., ?FixedStep, ?AdaptiveStep) for more details and customization options.

Example

using OptimizationLBFGSB
profiler = OptimizationProfiler(; optimizer = LBFGSB(), optimizer_opts = (reltol=1e-4,))

AdaptiveInitialStep(; rel_step=0.005, abs_step=1e-4, min_step=1e-5, max_step=Inf)

Initial profile step rule that adapts to the current profiled parameter value.

The proposed step is max(rel_step * abs(x), abs_step), where x is the current profiled parameter value. The result is finally clamped to [min_step, max_step].

This is useful when parameters have different numerical scales and a single fixed absolute step would be inefficient.

FixedStep{S}

Profiler stepper that proposes each profile point from the configured initial_step rule without adapting to trial objective values.

Constructors

FixedStep(;initial_step=AdaptiveInitialStep())

Keyword arguments

• initial_step=AdaptiveInitialStep(): The step rule to use for each profile step. This can be a number (for a constant absolute step size), an AdaptiveInitialStep, or a function ctx -> step for custom logic depending on the current profiler cache. If a number is provided, it is automatically wrapped as a function.

AdaptiveStep(; initial_step=AdaptiveInitialStep(),
               predictor=LinearPredictor(),
               controller=ObjectiveStepControl())

Profiler stepper that adapts the profile step length based on the observed objective increase from trial points.

The first profile step uses initial_step. Later steps use predictor to choose the direction in parameter space and controller to keep the next objective increase in a useful range.

ObjectiveStepControl(; threshold_fraction=0.1,
           target_factor=1.25,
                       lower_factor=0.25,
                       min_obj_step=1e-3,
                       max_obj_step=Inf,
                       min_x_step=1e-4,
                       max_x_step=Inf,
                       step_factor=1.5,
                       max_x_step_growth=5.0,
                       maxiters=15)

Controls adaptive profile stepping by defining acceptable objective and profile-axis step ranges.

For finite likelihood thresholds, the target objective increase is based on threshold_fraction * threshold. For infinite thresholds, the target increase is based on target_factor * abs(obj_cur - obj_prev).

The previous optimized profile objective change is used to nudge the first trial step up or down. Trial points below the upper objective target are then treated as safe to grow until the upper target, profile bound, or iteration limit is reached. The next profile-axis step is additionally capped by max_x_step_growth * previous_step to avoid abrupt jumps in flat profile regions.

LinearPredictor()

Extrapolates all parameters using linear extrapolation based on the last two successful profile points.

SingleAxisPredictor()

Extrapolates only the profiled parameter using linear extrapolation based on the last two successful profile points.

IntegrationProfiler{opType, optsType, DEAlg, DEOpts}

A profiler method that uses integration of differential equations system to profile the likelihood function.

Fields

• reoptimize::Bool: Indicates whether to re-optimization after each step of the integrator. Defaults to false.
• optimizer::opType: The optimizer used for the optimization process. Defaults to nothing.
• optimizer_opts::optsType: Options for the optimizer. Defaults to NamedTuple().
• integrator::DEAlg: The differential equation algorithm used for integration.
• integrator_opts::DEOpts: Options for the differential equation solver. Defaults to NamedTuple().
• matrix_type::Symbol: The type of matrix to be used for the Hessian approximation. Possible options are: :hessian, :identity. Defaults to :hessian.
• gamma::Float64: Correction factor used in integration if full hessian is not computed (e.g. matrix_type = :identity). Defaults to 1.0.

Example

using OrdinaryDiffEq
profiler = IntegrationProfiler(integrator = Tsit5(), integrator_opts = (dtmax=0.3,), matrix_type = :hessian)

CICOProfiler

Confidence Intervals by Constrained Optimization (CICO) method to find the intersections of the likelihood function with the threshold. See CICOBase docs for more details. Requires using CICOBase.

Fields

• optimizer::Symbol: The optimizer used for the optimization process. Defaults to NLopt :LN_NELDERMEAD.
• scan_tol::Float64: The tolerance for the endpoints scan. Defaults to 1e-3.

Example

profiler = CICOProfiler(optimizer = :LN_NELDERMEAD, scan_tol = 1e-3)

QuadraticApproxProfiler

Quadratic-approximation confidence intervals (Wald approximation) based on local curvature at the optimum. The curvature is approximated by the Fisher Information Matrix/Hessian, so the resulting confidence intervals reflect the local quadratic approximation of the likelihood around optpars. By default this method reuses Hessian logic from OptimizationProblem (user-supplied Hessian or AD backend). The confidence interval is computed as θ̂ ± z * sqrt(Σ[idx, idx]), where - θ̂ is the optpars[idx], - z is the quantile of the chi-squared distribution corresponding to the conf_level and df parameters of the ProfileLikelihoodProblem, - Σ is the covariance matrix obtained by inverting the FIM.

cov_factor controls Hessian/objective scaling conventions. Common choices are:

• 1.0 when Hessian is for -logL.
• 2.0 when Hessian is for -2logL and you want covariance on the -logL scale.

Any strictly positive value is allowed (not only 1 or 2), which can be useful for calibrated or robust variance scaling.

Fields

• inversion::Symbol: Matrix inversion strategy (:cholesky, :pinv).
• clamp_to_bounds::Bool: Clip estimated interval endpoints to profile bounds.
• cov_factor::Real: Multiplicative factor applied to inv(H) to obtain covariance (Σ = cov_factor * inv(H)).
• resolution::Int: Number of points per branch (left/right) used to sample the quadratic approximation.