API: Tuning

The cross-validation specification. The schema is described in The [tuning] schema.

Public names

VisualGeometryToolkitEval.Tuning — Module
Tuning

The cross-validation (CV) specification. It holds the grid spacings and the grid constructor grid, the window rules, the persisted grid specs and their extension (extend), the objectives (TuningCriterion), the scene splits and unit samplings of a CrossValidation, the validation-budget draws (BudgetSampling), the schemes that bundle them (TuningScheme), the [tuning] TOML parser and writer (tuning_spec, tuning_table), the tuning-artifact writer and reader (save_tuning_artifact, load_tuning_artifact), the scale-prior strategies (PriorSpec) and the deployment corruption of the miscalibration protocol (corrupt_native).

Every strategy is a type whose fields are its complete parameter set, and its defaults live in configs/tuning.toml.

source
VisualGeometryToolkitEval.Tuning.RNG_ALGORITHMS — Constant
RNG_ALGORITHMS

The RNG algorithms a spec may name (rng = "StableRNG"): StableRNGs' StableRNG only — its streams are fixed across Julia versions, which Julia's own MersenneTwister/Xoshiro are not, so a persisted sample or stream reproduces on any Julia. (MersenneTwister and Xoshiro were accepted until tuning format v4.)

source
VisualGeometryToolkitEval.Tuning.TUNING_TAGS — Constant
TUNING_TAGS

Every tagged strategy family of a [tuning] spec and its tag registry (VisualGeometryToolkitCore's TagRegistry: TOML tag → type, the tag snake_case of the type's name minus the family's suffix; retired tags name their successor). A tagged table names its type with the key type.

source
VisualGeometryToolkitEval.Tuning.CoarseFine — Type
CoarseFine(coarse, extension, edge_margin, fine, criterion, cross_validation)

The coarse-fine search of one scalar (Evaluation cvprobe.jl): the one-axis case of JointCoarseFine, its axis spelled flat — sweep the coarse axis, extend it by extension.npts points on a side whenever the argmin lies within `edgemarginpoints of that edge (at mostextension.maxroundsper side), then sweepfineover the coarse argmin's bracketing neighbours and take the free argmin.criterionaggregates a candidate's validation errors over the validation units ofcrossvalidation. TOML tag"coarse_fine"`.

source
VisualGeometryToolkitEval.Tuning.CoarseFineAxis — Type
CoarseFineAxis(coarse, extension, fine, expensive)

One axis of a JointCoarseFine search: its coarse axis (window rule

  • spacing), its expand-on-boundary rule, the fine spacing over the coarse

argmin's bracket, and whether it is expensive — a value of an expensive axis costs a run the cheap axes reuse (a detection run, say), so the search asks for the grid points one expensive value at a time. Untagged; defaults [types.coarse_fine_axis].

source
VisualGeometryToolkitEval.Tuning.CoverageWindow — Type
CoverageWindow(q_lo, q_hi, log_margin, zeta_octaves)

The COVERAGE window of a native axis (outlier half-width, loss width): every native the efficiency-constant window can request at any reference scale the validation pool can produce, [native(lo, ŝ_min/ζ)·e^{-m}, native(hi, ŝ_max·ζ)·e^{m}] with [lo, hi] the efficiency-constant window, (ŝ_min, ŝ_max) = scale_bounds(s2, (q_lo, q_hi)), ζ = 2^zeta_octaves (the scale corruptions the run reads out at, 0 for none) and m = log_margin (log headroom so a request at the bounds sits strictly inside). TOML tag "coverage".

The name is the GUARANTEE, not the mechanism: the realized grid contains every native the window can request at any scale the pool produces, so a windowed free argmin provably cannot leave its grid. That is what the validation-budget mode needs, where 3500 draws share one sweep and each has its own ŝ(n).

q_lo == q_hi is legal and is the ONE-ANCHOR case: both sides anchor on the same √quantile(σ̂², q), and at q = 0.5 that is reference_scale(s2), so coverage { q_lo = 0.5, q_hi = 0.5, zeta_octaves = 0.0 } is the WINDOW-MATCHED grid — the native image of the efficiency-constant window and nothing more. A tune has one reference scale, so this is the tuning case; a spread band is for the modes that have many. (It replaced a separate StandardizedNativeWindow rule, which was this rule with its band collapsed and was a distinct type only because the constructor forbade q_lo == q_hi.)

source
VisualGeometryToolkitEval.Tuning.CrossValidation — Type
CrossValidation(scene_split::SceneSplit, validation::UnitSampling, test::UnitSampling)

The data side of a tuning: the scenes it tunes on and reports on (scene_split), and the units of each side it reads (validation, test). A driver states which samplings it supports by the signature of the method it calls (say cv::CrossValidation{<:SceneSplit, StratifiedSampling}), so an unsupported spec is a MethodError. Applied by validation_units and test_units.

source
VisualGeometryToolkitEval.Tuning.EfficiencyConstantWindow — Type
EfficiencyConstantWindow(lo, hi)

The standardized window [lo, hi] of efficiency constants (a width as a multiple of the estimated inlier scale, σ-units) of a tuning run: the dimensionless window every windowed free argmin searches, mapped to a native axis at the supplied scale (window_columns), and the window of the efficiency-constant axis itself (StandardizedWindow). It carries no grid: the grids are built by the spacings.

source
VisualGeometryToolkitEval.Tuning.Factorial — Type
Factorial(axes, criterion, cross_validation)

Every combination of the named axes (hand-chosen settings of a method's configuration keys), scored by criterion over the validation units of cross_validation. TOML tag "factorial".

NOT a windowed scheme: there is no reference scale and no standardized window, and nothing about it is extended on a boundary. Its consumers live outside this package: a downstream product-grid spec reads its axes through it, and a joint operating-point search is one. Deleting it on the strength of a grep over src/ and test/ alone breaks them.

source
VisualGeometryToolkitEval.Tuning.GridExtension — Type
GridExtension(npts, max_rounds)

The expand-on-boundary rule of a GRID axis: on a boundary argmin, extend the grid by npts points on the clipped side, at most max_rounds rounds (a still-clipped argmin is then recorded and refused by the readers).

source
VisualGeometryToolkitEval.Tuning.Incumbent — Type
Incumbent(values, confidence, n_resamples, seed)

The setting in force before a search (values: axis name → value). The search's selection replaces it only when a paired bootstrap of the units (n_resamples draws, StableRNG(seed)) puts the selection's objective below the incumbent's with probability at least confidence. Untagged; defaults [types.incumbent].

source
VisualGeometryToolkitEval.Tuning.JointCoarseFine — Type
JointCoarseFine(axes, edge_margin, criterion, cross_validation, incumbent = nothing)

The coarse-fine search over the product of named axes (CoarseFineAxis), jointly: the coarse product grid, each axis extended on a side while the joint argmin lies within edge_margin points of that face, then the product of each axis's fine bracket about the joint argmin and its free argmin. CoarseFine is its one-axis case. An optional Incumbent is kept unless the selection beats it (Evaluation fine_search). TOML tag "joint_coarse_fine".

source
VisualGeometryToolkitEval.Tuning.ListedGrid — Type
ListedGrid(values)

A grid given by its values (finite, strictly increasing): the factorial tunings whose axes are hand-chosen settings. It has no spacing, so it cannot be extended. TOML tag "listed".

source
VisualGeometryToolkitEval.Tuning.LogPerDecade — Type
LogPerDecade(per_decade)

Log spacing at a DENSITY: d = log10(hi / lo) decades hold d·per_decade intervals, so the grid has round(Int, d·per_decade) + 1 points (at least 2) and its log10 step is d / (n - 1) — 1 / per_decade when d·per_decade is an integer. (d·per_decade POINTS would space them coarser than advertised: the fencepost.) TOML tag "log_per_decade".

source
VisualGeometryToolkitEval.Tuning.LogPerOctave — Type
LogPerOctave(per_octave)

Log spacing at a density per factor of two: round(Int, log2(hi / lo)·per_octave) + 1 points (at least 2) — the half-octave ladders (per_octave = 2) of the PnP and detector tunings. TOML tag "log_per_octave".

source
VisualGeometryToolkitEval.Tuning.MeanAverageAccuracy — Type
MeanAverageAccuracy(max_error)

The continuous mAA@max_error of the validation errors (VisualGeometryToolkitCore Synthetic.mean_average_accuracy; a non-finite error is a failure that stays in the denominator), MAXIMISED (the objective is its negative). TOML tag "mean_average_accuracy".

UNITS-NEUTRAL: max_error is in the errors' own unit — degrees on a pose error, mm for BlobBoards' bmvc2026 inter-board invariance. The one mAA criterion: a second spelling MAA(max_error_deg) carried the identical statistic under a field name that asserted degrees, which a criterion handed millimetres cannot. It is retired (2026-10-03) along with its "maa" tag; the [schemes.factorial] default that named it now names this one. The statistic itself is VisualGeometryToolkitCore's, the stack's one definition.

source
VisualGeometryToolkitEval.Tuning.RegisteredSceneSplit — Type
RegisteredSceneSplit(name, validation_scenes, test_scenes)

A scene split registered under name in configs/splits.toml (the one file of record of every scene list). A config names it (scene_split = { type = "registered", name = "..." }); the parser fills in the lists from the registry, so the complete table — and with it the spec hash and every artifact — carries the lists the run used. Both lists are nonempty, free of duplicates and DISJOINT; they are kept sorted. TOML tag "registered".

source
VisualGeometryToolkitEval.Tuning.RobustFit — Type
RobustFit(alpha0 = 1.0)

Robust median-based fitting of an inverse-gamma prior: β₀ = α₀ · median(σ²s) with fixed shape α₀ (default 1.0). Median is robust to heavy-tailed σ̂² distributions (HEB).

source
VisualGeometryToolkitEval.Tuning.SceneMeanMedian — Type
SceneMeanMedian()

The mean over scenes of each scene's median FINITE validation error (Stats scene_mean_median: scenes without a finite error are left out; NaN when none is left). errors is one error vector per scene. TOML tag "scene_mean_median".

source
VisualGeometryToolkitEval.Tuning.StratifiedSampling — Type
StratifiedSampling(fraction, cap_per_scene, seed, rng)

A uniform random sample of each scene (the stratum) separately, so the scene mix is preserved: of a scene's n units, max(1, round(fraction·n)) drawn without replacement, then at most cap_per_scene of those (0 = no cap), returned in the scene's own order. Scene s draws from rng(stable_seed(seed, s)) — its NAME, so adding or reordering other scenes leaves its sample unchanged. TOML tag "stratified".

source
VisualGeometryToolkitEval.Tuning.TuningArtifact — Type
TuningArtifact

A loaded tuning artifact (load_tuning_artifact): spec (the TuningSpec it ran under), hash, grid_specs and the realized grids (Dict{Symbol,…}, rebuilt from the specs), unit (the SamplingUnit its cross-validation drew), code (the code identity) and data (the run's own keys). Indexing with a string reads data: art["arms"]. format is the :tuning format the FILE was written in: an earlier one was carried over in memory by its version steps (load_tuning_artifact), and recorded_hash is the hash the file records (hash is the current table's; the two differ only for such a file).

source
VisualGeometryToolkitEval.Tuning.TuningScheme — Type
TuningScheme

A family of cross-validation, with every parameter it runs under: CoarseFine and JointCoarseFine (the one coarse-fine search of Evaluation cv_probe.jl, in one and in N dimensions), WindowedBootstrap, Factorial.

A new search backend (a surrogate model over the same axes, say) is a new TuningScheme whose search returns the record of Evaluation coarse_search / fine_search — selected, boundary_hit, evaluated — so the artifact, its gated reader and the bootstrap serve it unchanged.

source
VisualGeometryToolkitEval.Tuning.UniformSampling — Type
UniformSampling(fraction, cap, seed, rng)

A uniform random sample of the units of all the side's scenes POOLED: of the N units, max(1, round(fraction·N)) drawn without replacement, then at most cap of those (0 = no cap), returned in the data's order (scenes by name, each scene's units in its own order). The draw is rng(stable_seed(seed, "simple_random")) over that order — the salt keeps its historical spelling, so a sample is unchanged by the type's rename. TOML tag "uniform" (retired: "simple_random").

source
VisualGeometryToolkitEval.Tuning.WindowRule — Type
WindowRule

How an axis's window (lo, hi) is found: FixedWindow, StandardizedWindow, CoverageWindow, CenteredWindow. window_bounds(rule; context...) evaluates it; each rule takes only the context it needs and refuses a missing one.

Factored, a window is STATED or PLACED, and the placed ones differ only in their ANCHOR and how their endpoints leave it:

ruleanchorendpoints
FixedWindow—its own two native numbers
StandardizedWindow—the efficiency-constant window verbatim
CoverageWindow(ŝ_min/ζ, ŝ_max·ζ), per sidethe window through native, ± margin
CenteredWindowa supplied native point÷/× factor

Note where ζ sits: it scales the ANCHOR, never the endpoints. A window whose anchor spreads is asserting that the scale could be anywhere in that spread — right for a ζ ladder or a budget sweep, wrong for a tune, which has one reference scale. Anchor spread is bought with the grid's resolution.

source
VisualGeometryToolkitEval.Tuning.WindowedBootstrap — Type
WindowedBootstrap(efficiency_constant_window, outlier_halfwidth, loss_width,
                  efficiency_constant, criterion, cross_validation, budget_sampling)

The bootstrap tuning harness (Evaluation WindowedGridMethod): per draw of budget_sampling from the validation units of cross_validation, the free argmin of criterion over the native-grid columns inside the efficiency-constant window at the draw's reference scale. outlier_halfwidth and loss_width are the native grids, efficiency_constant the standardized display axis. TOML tag "windowed_bootstrap".

source
VisualGeometryToolkitEval.Tuning.bootstrap_argmin — Method
bootstrap_argmin(criterion::TuningCriterion, stats, rng; n_resamples) -> Vector{Int}

The sampling distribution of a cross-validation's selection: stats[c] is candidate c's unit_statistics (one row per sampling unit — a frame, a pair, a scene). Each of n_resamples resamples draws the units WITH replacement (rand(rng, 1:n, n), n the number of units) and returns the candidate whose criterion objective over the resampled rows is smallest (the first such candidate on a tie). The candidates are any flat set — the cells of an N-dimensional search included; the caller maps the indices to their coordinates and reads the interval it wants (per-axis quantiles, say).

This is the bootstrap of the SELECTION over a fixed candidate set. The windowed budget bootstrap (Evaluation bootstrap_trials) differs in what it resamples — budget draws of n validation units for a tuner, each draw evaluated on the test side — and is not a special case of it.

source
VisualGeometryToolkitEval.Tuning.code_identity — Method
code_identity(code) -> Dict{String,Any}

The code a tuning result came from: for this package and every module of code (the caller's packages whose code determines the result — the estimator and scorer packages it ran, say), version (the loaded package version); and the julia version with the RNG algorithms the run may draw from (rng, RNG_ALGORITHMS) — the streams are StableRNG's, but a bootstrap CI resamples from Julia's own default stream (Stats bootstrap_ci), which only the Julia version pins. The code's git state is the run's record, not this one: the code_trees (code_trees) its run records and _provenance.toml keep, the one rule a stored result is reused by.

source
VisualGeometryToolkitEval.Tuning.corrupt_native — Method
corrupt_native(native::Real, ζ::Real) -> Float64

The deployment-corruption map (docs/src/protocol.md §3, miscalibration): a tuned-at-CALIBRATION native width (selection outlier half-width, loss width, or the oracle supplied scale a native is formed from) scaled by the deployment error ζ — the model of a mis-estimated inlier scale at deployment time. Every ζ-scaling of a calibrated native goes through this one function so the corruption sites are greppable.

PARTITION-ANCHORED quantities never go through it: a tuned efficiency constant, a seed-partition Student-t ŝ², or any quantity re-derived from the deployed data's own partition is immune to calibration error by construction — that immunity IS the claim the miscal experiment measures.

source
VisualGeometryToolkitEval.Tuning.extend — Method
extend(w::EfficiencyConstantWindow, sides; factor) -> EfficiencyConstantWindow

The expand-on-boundary widening of a window (WindowExtension): its lo divided by factor if :lo in sides, its hi multiplied if :hi in sides (sides ⊆ (:lo, :hi), factor > 1); the grid's twin is extend(::SpacedGrid, sides; npts).

source
VisualGeometryToolkitEval.Tuning.extend — Method
extend(spec::SpacedGrid, sides; npts) -> (spec′, n_lo)

The expand-on-boundary extension of a grid: npts more points on each side in sides ⊆ (:lo, :hi), continuing the base step. Every point of grid(spec) reappears (to rounding) in grid(spec′) at index + n_lo, the count prepended, so already-computed columns stay valid by index (see extension_offset). A ListedGrid has no spacing to continue and refuses.

source
VisualGeometryToolkitEval.Tuning.extension_offset — Method
extension_offset(base::GridSpec, sup::GridSpec) -> Int | nothing

The offset n_lo ≥ 0 at which grid(base) sits inside grid(sup) when sup is base or an extension of it — same window and spacing, at least as many points on each side — else nothing. The compatibility test of a resumed checkpoint, a merged sidecar and a pinned grid: specs are compared, never realized values.

source
VisualGeometryToolkitEval.Tuning.fit_prior — Method
fit_prior(::InverseGamma, ::MLE, σ²s) -> IGPrior

MLE of the inverse-gamma shape/scale (α, β). Distributions.jl does not implement fit_mle(InverseGamma, ·) directly, so we use the closed-form transformation

X ~ InverseGamma(α, β)  ⇔  1/X ~ Gamma(shape = α, scale = 1/β)

and call fit_mle(Gamma, 1 ./ x). Returns nothing for n < 2.

source
VisualGeometryToolkitEval.Tuning.fit_prior — Method
fit_prior(::InverseGamma, fit::RobustFit, σ²s) -> IGPrior

Robust empirical prior: fixed shape α₀ = fit.alpha0, scale β₀ = α₀ · median(σ̂²). The IG prior mean is β₀/(α₀−1); with α₀=1 the mean is undefined but the mode β₀/(α₀+1) = α₀ · median(σ̂²) / 2 anchors near the data median.

Used for HEB-like datasets where per-pair σ̂² estimates are heavy-tailed (low-n_in pairs and non-planar GT-inlier sets contaminate MLE Gamma fits). The median is unaffected by individual outlier σ̂² values, so the prior location stays stable even with single-digit val-pool sizes.

source
VisualGeometryToolkitEval.Tuning.grid — Method
grid(lo, hi, spacing::GridSpacing) -> AbstractRange{Float64}
grid(spec::GridSpec) -> AbstractVector{Float64}

The tuning-grid constructor: npoints(lo, hi, spacing) points of spacing over [lo, hi] — Base range(lo, hi; length) for a linear spacing, Base logrange(lo, hi, n) for a log one (both hit lo and hi exactly). The second form realizes a persisted GridSpec, its extension included.

source
VisualGeometryToolkitEval.Tuning.layer_tuning — Method
layer_tuning(lower, upper) -> Dict

upper's [tuning.<name>] table layered over lower's, the way the parser layers a config over the defaults: a key of upper wins; a nested table merges key by key — unless both name a type and the types differ, when upper's table replaces lower's (a different strategy does not inherit another's parameters). The one way a paper's protocol-level tuning table and a cell's overrides are combined before tuning_spec / resolve_tuning! read them.

source
VisualGeometryToolkitEval.Tuning.layered_tuning_entry — Method
layered_tuning_entry(cfg, name; under = Dict(), over = Dict()) -> Dict{String,Any}
layered_tuning_entry(path::AbstractString, name; under, over) -> Dict{String,Any}

The [tuning.<name>] entry of a config (a parsed TOML Dict or a file path) with a campaign's protocol layered around it, as tuning_spec reads it but before it is read: no shipped defaults filled in, no key checked beyond the entry's scheme type. under is layered beneath the entry, keeping only the keys that are TOML keys of the entry's scheme (VgtkCore.allowed_keys: a Greek field by its ASCII spelling, skipped fields left out); over is layered above it, unfiltered; an over that names another scheme type replaces the entry, and under is filtered against the new scheme. With both empty it is the entry as it is. The result is always a fresh Dict, a deep copy: editing it never edits cfg, under or over. A project that folds the layered entry into a run key, or writes it as a config of its own, reads it here.

source
VisualGeometryToolkitEval.Tuning.load_tuning_artifact — Method
load_tuning_artifact(path) -> TuningArtifact

The reader of a tuning artifact: refuses another format first (an ArgumentError naming the file: regenerate it by re-running its tuning), then reads the spec (complete — nothing inherited), checks its hash, and rebuilds every grid from its spec.

A format-6 file (before the efficiency-constant names) is read through its version step, in memory (VisualGeometryToolkitIO's migrate_record); the file is never rewritten. Its efficiency constants are stored as the value each arm's ctor took then: an arm's is read through its roster-declared format6_constant hook (Evaluation.tuned_width; the identity by default). format and recorded_hash of the result say which file it was.

source
VisualGeometryToolkitEval.Tuning.nearest_column — Method
nearest_column(grid, x) -> Int

Index of the grid column nearest x in LOG space — the deployment evaluation helper (e.g. the column of the ζ-scaled tuned native). Evaluation only; tuning is always a windowed free argmin, never nearest-column selection.

source
VisualGeometryToolkitEval.Tuning.read_tuning — Method
read_tuning(::Type{T}, table) -> T

A persisted COMPLETE table back to its type (no defaults inherited: a missing key is an error). The reader of every spec and grid spec stored in an artifact.

source
VisualGeometryToolkitEval.Tuning.resolve_tuning! — Method
resolve_tuning!(cfg) -> cfg

Replace every [tuning.<name>] entry of a parsed config by its COMPLETE table (every parameter, defaults resolved — tuning_spec then tuning_table), in place. Experiments' run_key and write_run_records key and record a config resolved, so its run key and its recorded _config.toml cover every tuning parameter, including the ones it inherits from this package's defaults.

source
VisualGeometryToolkitEval.Tuning.sample_units — Method
sample_units(sampling::UnitSampling, units_by_scene) -> Dict{String,Vector}

The units sampling keeps of each scene of units_by_scene (an AbstractDict scene name ⇒ that scene's units, in the data's order): a Dict with every scene of the input, each holding its kept units in their original order (possibly none, for a pooled sample).

source
VisualGeometryToolkitEval.Tuning.save_tuning_artifact — Method
save_tuning_artifact(path, spec::TuningSpec; grids, unit, code, data...) -> path

The writer of a tuning artifact: the spec (complete table — its cross-validation's scene lists included — name, hash), the grids (Dict{Symbol,<:GridSpec}, one per axis the run tuned on), the sampling unit its cross-validation drew (the data's sampling_unit), the code_identity of code (the caller's modules whose code determines the result; this package is always recorded) and the run's data (keyword values: arms, tuned indices, validation matrices, …), stamped with the :tuning format.

source
VisualGeometryToolkitEval.Tuning.tune_objective — Method
tune_objective(criterion::TuningCriterion, errors) -> Real

The value a cross-validation MINIMIZES for one candidate: criterion applied to its validation errors (one vector per scene for a per-scene criterion).

source
VisualGeometryToolkitEval.Tuning.tuning_hash — Method
tuning_hash(spec) -> String

The identity of a tuning protocol: the SHA-256 (hex, first 16) of its complete scheme table's canonical JSON (_content_key). Two specs with equal parameters hash equal whatever their names or how their configs spelled them; any parameter change moves it.

source
VisualGeometryToolkitEval.Tuning.tuning_spec — Method
tuning_spec(cfg, name; under = Dict(), over = Dict()) -> TuningSpec
tuning_spec(path::AbstractString, name; under, over) -> TuningSpec

The [tuning.<name>] entry of a config (a parsed TOML Dict or a file path), its absent keys inherited from the shipped defaults (configs/tuning.toml of this package). The entry must name its scheme (type); unknown keys and tags are an ArgumentError naming the key path.

under and over layer a campaign's protocol around the entry (layer_tuning): under (a protocol-level table of parameters shared by every entry, such as a cross_validation) is layered beneath the entry, keeping only the keys that are fields of the entry's scheme, so one table serves entries of different schemes; over (a cell's overrides) is layered above it, unfiltered. An over that names another scheme type replaces the entry, as layer_tuning replaces a nested table: the new scheme keeps none of the entry's keys (not even those both schemes have, such as cross_validation or criterion), and under is filtered against the new scheme's fields. With both empty (the default) the entry is read as it is. The layered entry itself, before it is read, is layered_tuning_entry.

source
VisualGeometryToolkitEval.Tuning.unit_statistics — Method
unit_statistics(criterion::TuningCriterion, errors::AbstractMatrix) -> Matrix{Float64}

What the bootstrap of a selection needs of one candidate's validation errors (a units × items matrix, one row per sampling unit): one row per unit, from which the criterion's objective over ANY multiset of units is exact (bootstrap_argmin). For MeanAverageAccuracy — a mean of per-item scores — the row is the unit's score sum and item count (VisualGeometryToolkitCore maa_score), two numbers in place of items; for any other criterion it is the errors themselves.

source
VisualGeometryToolkitEval.Tuning.validation_units — Method
validation_units(cv::CrossValidation, units_by_scene) -> Vector{Pair{String,Vector}}

The units a tuning reads: the validation scenes of cv.scene_split (sorted) ⇒ the units cv.validation keeps of each. units_by_scene maps scene names to their units in the data's order and must hold every validation scene (other scenes are ignored).

source
VisualGeometryToolkitEval.Tuning.window_bounds — Method
window_bounds(rule::WindowRule; efficiency_constant_window = nothing, native = nothing,
       s2 = nothing, center = nothing) -> (lo, hi)

Evaluate a window rule. efficiency_constant_window is the run's EfficiencyConstantWindow, native(efficiency_constant, scale) the axis's native map (the caller's native_map(axis; d_g)), s2 the validation pool's per-pair σ̂², center the axis's centre; a rule refuses a context it needs and is not given.

source

Internals

These names are not public; they are listed for contributors.