Policy Management
Novomodelo stores the trained future-cost function (cuts) and the LP bases of each
forward-pass scenario in a policy directory, together with the trial states
the cuts were computed at when level1 selection or
exports.states stores them. The policy
section of config.json controls where that directory lives and whether
training starts from scratch or from a prior checkpoint.
Policy Modes
Seção intitulada “Policy Modes”The policy.mode field selects one of three initialization strategies. The
default is "fresh".
policy.path (default ./policy) resolves against the run’s output directory,
<case>/output unless novomodelo run --output names another (an absolute path is
used as is), so the default checkpoint is <case>/output/policy. Training writes
it there; warm-start, resume and simulation-only read it there.
policy.boundary.path differs: it resolves against the case
directory.
Fresh (Default)
Seção intitulada “Fresh (Default)”Training starts from an empty future-cost function. All prior cuts in
policy.path are ignored (or the directory does not yet exist).
{ "policy": { "mode": "fresh" } }Use "fresh" for new studies or when you want a clean training run with no
influence from earlier iterations.
Warm Start
Seção intitulada “Warm Start”Novomodelo loads the cuts from an existing policy checkpoint before training begins. Training then continues, adding new cuts on top of the loaded ones. The loaded cuts count as the initial future-cost approximation.
{ "policy": { "mode": "warm_start", "path": "./policy" } }Use "warm_start" to continue training from a previous run’s cuts, for example
with more iterations or other stopping rules. The loop runs up to the largest
iteration_limit in training.stopping_rules, and that limit counts only the new
iterations: a warm start with limit 20 runs up to 20 iterations on top of the
loaded cuts, whereas under Resume the limit also counts the completed
iterations. A warm-start load reads the whole saved policy, so it must pass every
check of the Policy Load Contract.
Each loaded cut keeps the iteration that generated it in the source run. A cut
the source run scored — its writing run stored the trial state the cut was
computed at, under level1 or with exports.states — is selected like a cut
the new run generates: when a level1 run warm-starts from such a policy, a
loaded scored cut competes at every trial state the new run stores, the one
loaded with it included, and is active after a selection pass exactly when it
owns at least one. With a lookback_iterations window w, a loaded state
counts as one from before the run’s first iteration, so it leaves the window at
the run’s iteration w. A loaded cut the source did not score keeps the
activity flag it was stored with. The binding counters of the loaded cuts (per
cut, how often and when it last bound, read by max_active_per_stage and
dynamic) restart with the run on a warm start; a resume restores them.
Resume continues training from the checkpoint at policy.path (the one written
when training ended, or the latest periodic checkpoint; see
Checkpointing Configuration),
whichever stopping rule ended the earlier run. Novomodelo reads the checkpoint’s
completed_iterations count and the loop continues from the next iteration. The
load is a full-FCF load, so the checkpoint must pass every check of the
Policy Load Contract.
{ "policy": { "mode": "resume", "path": "./policy" } }Training writes a checkpoint when it ends, so resume needs no checkpointing
key; with periodic checkpoints on, it also writes one on each scheduled
iteration, and each replaces the last. A job killed before the end-of-training
write, for example by a scheduler’s wall-time limit, keeps the latest checkpoint
written before: the latest periodic one, or the previous run’s.
An interrupted write that replaces a checkpoint leaves a complete one, old or new;
an interrupted first write can leave none (see
Checkpoint Directory Contents).
Train in Slices fits a long training into wall-time-limited
jobs.
The loop runs up to the largest iteration_limit in training.stopping_rules.
That limit counts all iterations, the completed ones included; when the
checkpoint has already reached it, Novomodelo warns and trains no further.
The seed comes from config.json, not from the checkpoint, and each iteration’s
forward-pass noise derives from the seed and the iteration number. With the
training run’s seed, a resumed iteration therefore samples the same forward-pass
noise as that iteration in a run without a resume.
Resume restores the cuts, each at the pool slot it held, with its role (loaded
or generated), activity flag and binding counters; the stored trial states; the
per-scenario LP bases that fit; the iteration count; and the lower bound of
every completed iteration. A scenario whose basis the checkpoint does not hold
starts its first solve cold. Everything else comes from the current run: the
inflow model and the opening tree, which it builds from the case and
config.json as a fresh run does, the seed, the stopping rules, its check_frequency, max_active_per_stage value
and modeling.cost_scale_factor, and the wall-clock timer that time_limit
reads, which starts when the resumed training starts. The checkpoint does not
depend on the rank count of the run that wrote it, so a resume may use another
number of MPI ranks.
Identical resume
Seção intitulada “Identical resume”When both runs stop on an iteration limit and the resume uses the settings that
wrote the checkpoint, a run resumed from the checkpoint of iteration k and
trained to iteration n ends in the state of the run trained to n without
interruption. These are identical bit for bit:
- in every pool, the cut values, the activity flags, the iteration and forward pass that generated each cut, the binding counters, the role of each slot, the stored trial states and the ownership record built from them;
- the final upper bound, the forward and backward simplex counts of the iterations after the checkpoint, and the pool row counts those iterations report;
- the per-scenario bases the resume seeds, against the ones the checkpoint holds;
- the final checkpoint, except its
created_atfield and its lower-bound fields.
The lower-bound series, and the checkpoint’s copy of it, agree within a relative
1e-6 rather than bit for bit: the uninterrupted run rebuilds the lower-bound
LP warm and the resumed run builds it cold. A stopping rule that reads the lower
bound can therefore stop the two runs one iteration apart; an iteration limit
cannot.
Resume refusals
Seção intitulada “Resume refusals”A resume checks that the checkpoint carries the state needed to continue the
interrupted run. Five checks run in a fixed order, after the
Policy Load Contract checks, and the first that fails
stops the run. Each refusal message starts with resume needs, names the
setting and what the checkpoint holds, and gives the way out. novomodelo validate,
novomodelo run and the Python bindings report the same line. A warm_start load
of the same checkpoint reads none of these fields and loads.
| # | The resume is refused when | Way out |
|---|---|---|
| 1 | The study’s forward-pass count differs from the count that wrote the checkpoint. The slot layout and the stored scenarios follow the count. | Set training.selection.forward_passes to the stored value, or continue with policy.mode = "warm_start". |
| 2 | The run uses level1, the study has a stage strictly between the first and the last, and the checkpoint holds no trial-state history because the run that wrote it stored none (a run without level1 or exports.states). | Continue with warm_start, or retrain. |
| 3 | The run keeps every trial state (lookback_iterations unset) and the checkpoint holds a window, or the run’s window is longer than the checkpoint’s. A stored window longer than the run’s is admitted; the extra states leave at the first selection pass. | Set lookback_iterations to at most the stored value, or continue with warm_start. |
| 4 | max_active_per_stage or the dynamic method reads the binding counters, and the checkpoint holds none because the run that wrote it configured neither. | Continue with warm_start, or retrain. |
| 5 | The checkpoint’s per-scenario bases are not whole: it was written when a run failed (see A failed run). | Resume from the last whole checkpoint, or continue with warm_start. |
For example, check 2 reads:
resume needs the trial-state history of training.cut_selection.selection.method = level1; the checkpoint holds none (it was written by a run without level1 or exports.states); continue with policy.mode = warm_start or retrainA resume of a run that declared policy.boundary has one further refusal, on
the boundary rows; see Resuming with a boundary.
Simulation-Only Mode
Seção intitulada “Simulation-Only Mode”With training.enabled set to false and simulation enabled, novomodelo run skips
training, loads the checkpoint at policy.path, and simulates it.
policy.mode is ignored in this mode.
The load is a full-FCF load, so the checkpoint must pass every check of the
Policy Load Contract: it comes from the running novomodelo
version. Each loaded cut keeps the role it had in the run that wrote it, so
under simulation.cut_set "all"
(the default) the simulation holds the rows that run’s "all" held, the rows
selection deactivated and the cap evicted included, and under "active" the
rows active when its training ended.
Start from the config.json that trained the policy and change only
training.enabled and the simulation settings. training.selection and
training.stopping_rules stay required even though training does not run, and
every key that shapes the stage LP must equal the training run’s (a stored basis
whose stage LP changed is left out, see Stored-basis gate). For
example, a policy trained with modeling.inflow_non_negativity set to
{ "method": "none" } loads without its stored bases if the simulation-only config omits the key:
it then defaults to "truncation_with_penalty", which adds slack columns (one per hydro) to the
stage LP.
The keys to change, merged into that config.json (all other keys stay as in
training):
{ "training": { "enabled": false, "selection": { "method": "sampled", "forward_passes": 1 }, "stopping_rules": [{ "type": "iteration_limit", "limit": 128 }] }, "simulation": { "enabled": true, "selection": { "method": "sampled", "num_scenarios": 100 } }, "policy": { "path": "./policy" }}With these keys in config.json, novomodelo validate accepts the case.
Validate reads the checkpoint at policy.path and applies the same load, so
this confirms the config and the policy load:
Valid case: 1 buses, 1 hydros, 2 thermals, 0 linesUse this mode to run additional simulation scenarios on a policy that has already converged, or to compare multiple saved policies on the same scenarios.
Train in Slices
Seção intitulada “Train in Slices”Split a training into slices when a scheduler’s wall-time limit is shorter than
the training needs. Each slice is a separate job that resumes from the
previous slice’s checkpoint and trains up to a larger iteration total. A slice
must finish, and write its checkpoint, before its wall time ends: a job killed
first keeps only the iterations up to its latest checkpoint: the latest periodic
one with policy.checkpointing.enabled, or the previous slice’s. Run every slice on the
same case with the same output directory: each slice reads the previous
checkpoint from policy.path and writes its own checkpoint back to it. Under
MPI every rank loads that checkpoint, so the output directory is visible at the
same path on every node.
Slicing by iteration_limit works on any rank count. Size each slice from
the time_total_ms trend
in the previous slice’s training/convergence.parquet, which holds only the
iterations of the slice that wrote it. Per-iteration time grows as cuts
accumulate, so leave a margin.
Slice 1 trains to the first iteration total:
{ "training": { "stopping_rules": [{ "type": "iteration_limit", "limit": 50 }] }}Every later slice sets policy.mode to "resume" and raises limit to the new
total, which counts the iterations of all earlier slices:
{ "training": { "stopping_rules": [{ "type": "iteration_limit", "limit": 100 }] }, "policy": { "mode": "resume" }}A slice may end on a time_limit rule, measured
from the start of that slice’s training. Keep an iteration_limit holding the
total in the set (every rule set needs one), and leave
stopping_mode at its default, "any",
so that time_limit alone ends a slice. Novomodelo checks time_limit after each
iteration, so a slice runs up to one iteration past seconds. Set seconds
below the job’s wall time by that iteration, the case load, and the checkpoint
write. The same set serves every slice, with policy.mode set to
"resume" from the second slice on. This set ends each slice after 50 minutes of
a one-hour job and stops the training at 200 iterations:
{ "training": { "stopping_rules": [ { "type": "time_limit", "seconds": 3000 }, { "type": "iteration_limit", "limit": 200 } ] }}Checkpointing Configuration
Seção intitulada “Checkpointing Configuration”With policy.checkpointing.enabled set to true, training writes a checkpoint
to policy.path after each scheduled iteration that does not end training:
initial_iteration (default interval_iterations), then every
interval_iterations, in absolute iteration numbers. The iteration that ends
training writes only the end-of-training checkpoint. Each checkpoint replaces
the previous one and holds the same files as the end-of-training one, with
completed_iterations set to its iteration. Rank 0 writes it. A failed write
ends training on every rank with checkpoint write at iteration {n} failed: {e}.
store_basis and compress have no effect; the keys are listed under
Configuration.
Checkpoint Directory Contents
Seção intitulada “Checkpoint Directory Contents”A written checkpoint has the following layout under policy.path (resolved
against the output directory, as described in Policy Modes);
policy/ below stands for that directory:
policy/ manifest.bin -- study-global manifest: study graph, stage count, provenance, the format_version marker and the producer facts a resume checks (FlatBuffers, written last as the commit signal) cuts/ 000.bin -- cuts of pool 0: slots, coefficients, intercepts, activity flags and binding counters, in the writing run's scaled cost units (each self-describing its own cost scale and graph identity) 001.bin -- cuts of pool 1 ... basis/ 000.bin -- LP bases of node 0, one per forward-pass scenario 001.bin ... states/ -- only for pools that store trial states 000.bin -- trial states of pool 0, one per scored cut, by slot 001.bin ...File names are zero-padded to three digits (NNN.bin). Under cuts/ and
states/, the id is the pool id; under basis/, it is the policy-graph
node’s canonical 0-based position (not its declared node id). On a stage chain
each stage is one node with its own pool, so both ids equal the stage position.
The file name itself is not read for identity — each buffer carries its own
id internally, and the reader derives pool and node identity from the payload,
never from the name.
basis/ is written even when no node holds a basis. A load reads a checkpoint
without basis/ as one with no stored bases, so a checkpoint unpacked from an
archive that dropped the empty directory still loads; every node then starts
without a stored basis.
states/ holds, for every pool that stores trial states, the state each scored
cut was computed at, keyed by the cut’s slot. Under level1, every pool of a
stage strictly between the first and the last stores them (the last
lookback_iterations iterations when a window is set). With
exports.states, every pool that receives
cuts stores them, the first stage’s pool included, whatever the selection
method.
manifest.bin is written last. Every write is staged in
<policy.path>.staging; the commit renames an existing <policy.path> to
<policy.path>.previous, renames the staged copy into place, then removes
.previous. Every reader (novomodelo run, novomodelo validate, the boundary load and
Python load_policy) uses the first of <policy.path>, .staging and
.previous that holds a manifest.bin.
An interrupted write that replaces a checkpoint leaves a complete one, old or new;
an interrupted first write can leave none. A load refuses a directory with no
manifest.bin, in itself or in either sibling. Before staging, a write refuses a
policy.path, or a .staging or .previous sibling, that is not a directory or
that holds an entry a checkpoint write does not leave there, and changes nothing
on disk; a checkpoint holds only manifest.bin, manifest.bin.tmp and
metadata.json at its top level, and only *.bin and *.bin.tmp files in its
cuts/, basis/ and states/ directories. The message is
refusing to write a checkpoint: {entry}, found in {dir}, is not part of a checkpoint (manifest.bin, metadata.json, cuts/, basis/, states/); move it elsewhere or write the checkpoint to another directory.
A symbolic link at policy.path is followed once: the commit runs at its target,
the siblings are the target’s, and the link is kept.
Before anything is written, the payloads themselves are checked, and a refusal
names the first offending file (cuts/<pool>.bin, basis/<node>.bin,
states/<pool>.bin or manifest.bin) and the rule it breaks. A write is
refused when two payloads of one kind carry the same id
(more than one payload carries this id), when the checkpoint would be one a
load rejects (for example, entity manifests whose dates disagree), and when a
file’s encoded size could exceed the 2 GiB FlatBuffers buffer limit:
{file}: encoded size bound {bound} bytes exceeds the FlatBuffers limit of {limit} bytesmanifest.bin is read first: its format_version marker is checked before
any cut, basis, or state payload is parsed (step 1 of the
check order).
manifest.bin records the study graph, the number of stages, the producing
novomodelo version, and the producer provenance (completed iterations, lower- and
upper-bound values, forward passes per iteration, the RNG seed, and the
trial-state history, binding-counter and whole-basis-store facts that a resume
checks) — see
Policy Checkpoint for the full
field-by-field table. Whether a checkpoint loads into the current study is
decided by the Policy Load Contract.
A failed run
Seção intitulada “A failed run”A run whose training ends in an error never replaces the policy directory. It
writes its policy to a sibling directory named after the policy directory with
.partial appended (./policy.partial for ./policy), and the failure message
names that directory. The policy directory keeps the last whole checkpoint, so
the next resume continues from it. A second failed run replaces the .partial
directory. No load reads it unless policy.path names it. A resume from a
.partial directory is refused by check 5 of
Resume refusals, because the bases of a failed run are not
whole and the failed iteration may be half applied; a warm_start from it
loads.
Policy Load Contract
Seção intitulada “Policy Load Contract”Warm-start, resume, and simulation-only runs are full-FCF loads: they read
every cut pool of the future-cost function (FCF), the study graph, and the
stored LP bases from the checkpoint at policy.path. The checks below run in
order; a refusal at steps 1–4 stops the run before training or simulation
starts, and step 5 leaves out the stored bases that do not fit.
A boundary load runs its own checks, listed under
Compatibility requirements.
Check order
Seção intitulada “Check order”- Read.
manifest.binis present and its wireformat_versionis4(theformat_versiongate). Amanifest.binstamped with another value, a version-3 checkpoint included, is refused with:unsupported checkpoint manifest format_version {format_version}; expected 4; re-run the program that produced it with novomodelo {running}; for a converted boundary policy, convert it again - Cost scale. Every pool records a
cost_scale_factorthat is a finite positive number (see Cost-Scale Canonicalization). - Software and version. The recorded
softwareandsoftware_versionequal the running software’s name and version exactly (see Version gate). - State and graph. The state dimension, stage count, pool count, per-slot entity identity, and study graph (nodes and edges) equal the current study’s.
- Stored bases. A stored LP basis that does not fit its stage LP is left out with one warning, and the load proceeds (see Stored-basis gate).
A refusal at step 4 means the study differs from the one that trained the policy. The message names the mismatch; restore the matching inputs, or train a new policy for the changed study.
Version gate
Seção intitulada “Version gate”A policy loads only in the software and version that wrote it. Every load path —
warm-start, resume, simulation-only, and boundary, from the CLI and from Python —
requires the software and software_version recorded in manifest.bin to
equal the running software’s name and version exactly. An older or newer version is refused, and so is a different
patch or pre-release build (for example 0.17.0 against 0.17.1).
The refusal reads:
policy was written by {writer}, but this is novomodelo {running}; a policy loads only in the software and version that wrote it: re-run the program that produced it with novomodelo {running}; for a converted boundary policy, convert it again{writer} names the recorded software and version: <software> <version>,
<software>, which recorded no version, software that recorded no name, version <version>,
or software that recorded no name or version; {running} is the version of
the novomodelo that is loading it. novomodelo run reports
the refusal as a validation error before training or simulation starts;
Error Codes lists the exit code
and the Python exception.
To load the policy, retrain it with the running version. Alternatively,
re-export it by re-running the pipeline that wrote the checkpoint under the
running version: the script that calls
novomodelo.write_policy_checkpoint,
or the boundary import of Case Conversion (novomodelo-bridge).
A manifest that parses (step 1) is not thereby accepted: this gate decides whether the running version may load it. FlatBuffers Policy Schema — Versioning policy covers the wire level.
Stored-basis gate
Seção intitulada “Stored-basis gate”A full-FCF load uses a stored LP basis only when it fits its stage LP, leaves
the others out with one warning, and proceeds. For example, novomodelo run prints:
warning: stored bases not used: 4 of 4 do not fit the current LP (first: node 0, 27 columns, the LP has 28); a stored basis is used only when its column count equals the LP's, its row count equals the LP's template rows plus its recorded cut rows, its basic count equals its row count, and every recorded cut-row slot holds a loaded cut; the policy was trained on a different LPThe node and the counts come from an example case and differ per study. The counts are of stored bases, one per node and forward-pass scenario.
A stored LP basis fits when its column count equals its stage LP’s, its row
count equals that LP’s template rows (the rows before any cut) plus the cut rows
the basis itself records, its count of basic entries equals its row count, and
every cut-row slot it records holds a loaded cut. The last rule names the slot
in the warning: a cut row at slot {slot}, which holds no loaded cut. The
warning ends with the full rule:
a stored basis is used only when its column count equals the LP's, its row count equals the LP's template rows plus its recorded cut rows, its basic count equals its row count, and every recorded cut-row slot holds a loaded cut; the policy was trained on a different LPWarm-start and resume check the bases a checkpoint carries, simulation-only always checks them, and a boundary load checks none.
A stored basis that fits seeds a solve only in a phase that warm-starts
(use_warm_start). Under the
built-in HiGHS profiles simulation solves start cold, so a simulation-only run
starts from its checkpoint bases only with
simulation.solver.use_warm_start: true. On a stage chain a warm-start or
resume run starts from them through the forward pass, which warm-starts by
default, because the backward pass reads the bases the forward pass captures;
setting training.solver.forward.use_warm_start: false leaves them unread. On a
branching graph the backward pass also
starts from them at the successor nodes a scenario’s first forward path did not
visit. On CLP every phase starts from them. The
LP Warm-Start implementation notes
trace the store through each phase.
Every checkpoint holds the LP bases of the run’s forward-pass scenarios, and
policy.checkpointing.store_basis has no effect on that. Any
change that alters the column count of a stage LP therefore leaves out the
stored bases of the stages it changes: in training those nodes start their first
solve cold and then reuse the bases they capture, and in a simulation-only run
they solve without a stored basis.
Examples are a different block count, a different entity set, and a different
block mode on a stage with hydro plants and more than one block.
novomodelo validate runs the same load
and reports the same warning.
Cost-Scale Canonicalization
Seção intitulada “Cost-Scale Canonicalization”Novomodelo’s objective cost-scale factor
(modeling.cost_scale_factor)
is configurable per study. A checkpoint stores every cut’s intercept and
coefficients exactly as the cut pool holds them in memory, in the writing
study’s scaled cost units. Each cuts/<pool>.bin (see the field table in
Policy Checkpoint) carries its
own cost_scale_factor, which records that scale, so the checkpoint is
self-describing per pool.
Every load path — warm-start, resume, simulation-only, and boundary-cut injection — converts each pool by its own recorded factor:
| Pool’s recorded factor | Behaviour on load |
|---|---|
| Bit-equal to the loading study’s factor | Values used unchanged; a same-factor round trip, a resume included, is bit for bit. |
| Any other value | Every value becomes (value * source) / loading: multiplied by the source factor first, then divided by the loading factor. |
Every load path requires each resolved pool to carry a factor that is a
finite positive number. A full-FCF load refuses a pool whose cost_scale_factor
reads absent with
policy checkpoint predates self-describing cuts (its cuts/<pool>.bin for pool {pool} carries no cost_scale_factor); re-run the program that produced it with novomodelo {running}; for a converted boundary policy, convert it againand a pool whose factor is not a finite positive number with
policy checkpoint pool {pool} records cost_scale_factor {factor}, which is not a finite positive number; re-run the program that produced it with novomodelo {running}; for a converted boundary policy, convert it againA boundary load refuses a pool without the factor with its own message, quoted in item 3 of the boundary load order, and a pool whose factor is not a finite positive number with the second message above.
To read a coefficient or an intercept outside Novomodelo in currency units, multiply
it by the pool’s cost_scale_factor. A load at another factor rounds twice, once
in the multiplication and once in the division, so its values can differ in the
last bits from those of a run that used the loading factor throughout; the
difference is below solver tolerance.
Boundary Cuts
Seção intitulada “Boundary Cuts”Boundary cuts allow a Novomodelo study to load terminal-stage future cost function (FCF) approximations from a different Novomodelo policy checkpoint. This is the mechanism for chained studies: a downstream study imports one cut pool of an upstream study’s policy as its terminal boundary condition, so its end-of-horizon decisions account for the upstream study’s future cost of water. The downstream study may have a shorter horizon or finer stages than the upstream one. For the method, see Post-Study Boundary & Chained Studies §5.
How it works
Seção intitulada “How it works”- Run the upstream study to produce a policy checkpoint, or author the checkpoint in Python (Read and Write Checkpoints from Python).
- Run the downstream study with
policy.boundarypointing to the upstream checkpoint. Novomodelo selects the source pool priced at the downstream study’s terminal boundary date — the last non-negative stage’send_date— and injects its cuts into the terminal stage’s row pool as fixed boundary conditions. There is no stage-index knob: the pool is chosen by matching that date against each source pool’s own priced-state date.
The imported boundary cuts are not updated by the SDDP training algorithm.
Their coefficients remain fixed throughout training and simulation, and the
active ones provide a floor on the terminal-stage future cost.
The training.cut_selection.max_active_per_stage setting
(cut_selection) never evicts
an imported boundary cut: it caps only the pools of stages strictly between the
first and the last, and counts only the cuts the run generated.
Which boundary rows a run uses
Seção intitulada “Which boundary rows a run uses”The boundary pool replaces the terminal stage’s row pool. Its rows keep the activity flag and the scored mark of their source records, and the run uses them as follows:
| Where the run reads the pool | Boundary rows used |
|---|---|
| Training and the lower bound | The active rows. |
Simulation with simulation.cut_set = "active" | The active rows. |
Simulation with simulation.cut_set = "all" | The active rows, plus the rows the source scored (for example a level1 source of a longer horizon), whatever their flag. |
A row the source did not score and left inactive (for example a row a capped source evicted) is in neither set. See Simulation cut set for the rules of the other loaded rows.
The dynamic method’s lazy solve reads only active rows. A dynamic run that
simulates with simulation.cut_set = "all" is therefore refused when the
boundary pool holds an inactive row that "all" includes, that is, a scored
inactive row. The message names the method and simulation.cut_set, the pool
with its row counts, and the way out: set simulation.cut_set = "active", or
use the level1 method. A run that does not simulate is not checked.
Configuration
Seção intitulada “Configuration”Add a boundary object to the policy section of config.json:
{ "policy": { "mode": "fresh", "boundary": { "path": "../upstream_study/output/policy", "strict": false } }}| Field | Type | Default | Description |
|---|---|---|---|
path | string | — | Path to the source checkpoint directory; see policy.boundary for how it resolves. |
strict | boolean | false | Governs a superset source (one pricing an entity or commitment this study does not model). false drops the surplus, records it in the reconciliation report, and loads; true rejects the load. |
When boundary is absent or null, no boundary cuts are loaded (the default).
Compatibility requirements
Seção intitulada “Compatibility requirements”Unlike a full-FCF load — which requires the saved
policy’s state dimension and per-slot entity layout to match the current study
exactly (step 4 of the check order, a check that cannot be
disabled) — boundary injection tolerates a source of a different state
shape. The source’s terminal state is reconciled onto the current study’s own
state per slot by entity identity and its per-family slot dates (the
inflow-lag reference_date, the forward-family interval_start/interval_end),
not by position: a source trained with a different
set of state coordinates — no in-transit buckets, or monthly anticipated slots
feeding a differently-shaped study — still injects, each source coefficient
binding to the current study’s slot for the same entity. A source coordinate
that couples a state slot the current study does not model cannot be carried; it
is reported in a per-family reconciliation summary and dropped, and the load
still succeeds by default. See
Post-Study Boundary & Chained Studies §4 for the
reconciliation mechanism.
That leniency is the default reconcile path, but the load still enforces hard requirements. A boundary load runs its checks in this order, and the first failure stops the run:
- Read. The checkpoint at
policy.boundary.pathcan be read; a read failure is refused withfailed to read boundary policy checkpoint at {path}: {e}, where{e}is the underlying error. - Pool selection. Exactly one pool of the source is priced at the study’s terminal boundary date.
- Cost scale. The resolved pool records a
cost_scale_factorthat is a finite positive number (see Cost-Scale Canonicalization); a pool without it is refused withboundary policy checkpoint at {path} predates self-describing cuts (its resolved cuts/<pool>.bin carries no cost_scale_factor); re-run the program that produced it with novomodelo {running}; for a converted boundary policy, convert it again. - Single-node source. The resolved pool is a single-node terminal pool, not
one shared across several study nodes. A shared pool is refused with
boundary policy at {path}: a boundary source must be a single-node terminal pool; the resolved pool is shared by multiple nodes. - Inflow-lag depth. Before building the study, Novomodelo reads the deepest
inflow-lag slot that any cut pool of the boundary checkpoint references and
extends the study’s inflow-lag state to at least that depth
(Post-Study Boundary & Chained Studies §5.2);
when the depth is above zero,
novomodelo runwithout--quietprintsBoundary policy: inflow-lag depth {d}while loading. This check confirms that the resolved pool references no lag deeper than the extended state, so a user case does not trigger it. A message startinginternal:is a Novomodelo defect; report it. - Season and PAR order. When the study declares a season cycle, the
source’s
season_manifestis present and agrees with the study’s season cycle, season count, and per-hydro PAR orders. - Topology subset. When both checkpoints carry an entity manifest, the source prices every hydro storage slot and every inflow-lag slot of the current study.
- Software and version. The software and version recorded in the source checkpoint equal the running software’s name and version exactly (see Version gate); the checks above run first, so a source written by another software or version can fail one of them before this one.
- State dimension. If either checkpoint has no entity manifest, slots cannot
be matched by identity, so the topology-subset and slot-date checks are
skipped and the source pool’s state dimension must equal the study’s. The
refusal starts
boundary policy state_dimension mismatch: policy has {n}, current system has {n}. - Slot dates. Every dated in-transit or anticipated slot of the source has
an
interval_startandinterval_endthat decode to a date range of positive length. A slot that fails is refused with one of:boundary policy source forward-family slot (entity_id={entity_id}, subindex={subindex}) has an undecodable interval_start {interval_start}boundary policy source forward-family slot (entity_id={entity_id}, subindex={subindex}) has an undecodable interval_end {interval_end}boundary policy source forward-family slot (entity_id={entity_id}, subindex={subindex}) has a non-positive delivery interval: interval_start={interval_start}, interval_end={interval_end}
- Superset. Applies only with
strict: true: a source that prices more than the study models is refused (withstrict: falsethe surplus is dropped and reported).
Every check except Superset is independent of strict.
Date-selection rejects. Before any coefficient is reconciled, Novomodelo resolves the source to exactly one pool priced at the study’s terminal boundary date (list item 2). Three conditions abort the load with a named error:
- Undated source — no pool in the source checkpoint records a priced-state
date:
boundary policy checkpoint at {path} carries no priced_state_date on any pool (a pool written before priced dates were recorded); re-run the program that produced it with novomodelo {running}; for a converted boundary policy, convert it again. - No pool at the date — no source pool is priced at the boundary date:
boundary policy at {path}: no pool is priced at the study's boundary date {date} (available: {dates}). - More than one pool at the date — the source is ambiguous:
boundary policy at {path}: more than one pool is priced at the study's boundary date {date} (pools {pools}); boundary injection requires a unique priced source.
Season / PAR-order rejects. When the loading study models a seasonal or
per-hydro autoregressive (PAR) inflow process, the boundary source’s season
descriptor (season_manifest) must agree with the study’s. This check is
always-on — it is not gated by strict, and fires whenever the loading
study declares a season cycle (a study modelling no seasonal/PAR inflow skips it
entirely). It aborts the load with a validation error on the boundary-load
path — distinct from the version gate refusal. A boundary
source is rejected when its season_manifest:
- is absent — the source predates the season descriptor:
boundary policy checkpoint at {path} predates the season descriptor (its manifest carries no season cycle or PAR orders); re-run the program that produced it with novomodelo {running}; for a converted boundary policy, convert it again. - disagrees on the season cycle —
boundary policy at {path}: season cycle mismatch (study is {monthly|weekly|custom}, source is {…}). - disagrees on the season count —
boundary policy at {path}: season count mismatch (study has {n} seasons, source has {n}). - omits a hydro the study models —
boundary policy at {path}: hydro {id} has a modeled inflow season/PAR-order entry in the current study but none in the boundary source (the boundary was fitted on a different set of inflow processes). - disagrees on a hydro’s PAR-order count —
boundary policy at {path}: hydro {id} carries {n} PAR orders in the current study but {n} in the boundary source. - disagrees on a per-season PAR-order value (naming the hydro and the first
differing season) —
boundary policy at {path}: hydro {id} PAR order mismatch at season index {season} (the season's 0-based position in the cycle, not its id; study has order {n}, source has order {n}).
The season_manifest field shape is documented in
Policy Checkpoint.
Subset rejects. If the source prices less than this study needs, the load
is rejected regardless of strict:
- Missing storage — the source does not price a hydro the study models:
boundary policy does not price {names}; it was trained on a different set of plants. - Missing inflow-lag — the source has no inflow-lag coefficient at a depth
the study needs:
boundary policy has no inflow-lag coefficient for {names}: the boundary is lag-depth-incompatible with the current study.
Lag-date reject. A source inflow-lag coefficient and the current study’s
inflow-lag slot for the same hydro and depth may each carry a reference date.
When both are dated and the dates differ, the load is rejected regardless of
strict; this reject runs after list item 10 and before list item 11:
boundary policy's inflow-lag coefficient for hydro {id} at lag depth {depth} references a different past than the current study: boundary {date}, current {date}.
Lag coverage and dating. An interior source pool, any pool other than the
upstream study’s terminal pool, carries inflow-lag coefficients only when its
successor stage’s
stages[].state_variables
selection includes inflow_lags, which defaults to false. The terminal pool
of a trained upstream study is sized by that study’s full state, with every
inflow-lag slot of that state, whatever the selection; training never adds a
cut to it, so it holds only the cuts loaded into it, such as that study’s own
boundary cuts. The current (downstream) study’s terminal state has inflow-lag
slots when its own inflow model is autoregressive or when any pool of the
source references a lag (the extension of list item 5), and a source pool that
lacks a coefficient for any of those slots is rejected with the
Missing inflow-lag message. An autoregressive upstream study always
triggers that extension, because its terminal pool references every lag of its
state even when it holds no cuts. To chain from an interior pool, set
inflow_lags: true on the upstream stage that follows the source pool’s stage.
Each study dates its own lags: lag 1 by the start date of the pool’s own stage,
and each deeper lag by the start date of one stage further back in that
study’s full stage list, pre-study stages included. The source pool’s stage and
the current study’s last stage must therefore start on the same date, and so
must each pair of stages the same number of places before them, down to the
deepest lag both sides date, or the lag-date reject applies. In particular, it
applies wherever several stages of the current study together span one source
stage within that depth.
Superset behavior (strict). When the source prices more than the study
models, the surplus source slots are dropped during reconciliation either way.
With strict: false (the default) the drop is recorded in the reconciliation
report and the load proceeds; with strict: true the same condition rejects the
load: boundary policy at {path} is a superset: {summary}; see the reconciliation report or set policy.boundary.strict = false, where {summary} names every
dropping family and its count. strict governs only this superset case — it
does not relax the subset rejects or loosen the date-selection rejects. A source
storage slot used to fill an in-transit bucket is not dropped, so it does not
trigger the rejection.
Where the reconciliation report appears. When the load proceeds (a strict rejection shows only the superset message’s summary), the
per-family reconciliation is surfaced on three
paths:
novomodelo runprints a Boundary policy block to stdout while it loads the case, before training —Cuts loaded: N (priced at {date}),Source: {path}, and aReconciliation:lineN copied, N fanned out, N filled from storage, N defaulted to 0.0, N dropped.novomodelo validate --jsonemits a boundary object withconfigured,boundary_date, andreportfields carrying the full per-family report (worked example under Configuration — boundary).novomodelo validate(human mode) printsboundary policy priced at {date}followed by the one-line summaryboundary reconciliation: N copied, N fanned out, N filled from storage, N defaulted to 0.0, N source slots dropped.
novomodelo validate reconciles policy.boundary only when the run trains, as
novomodelo run applies it only then; with training.enabled set to false, the
JSON configured field is false.
Resuming with a boundary
Seção intitulada “Resuming with a boundary”A run that declared policy.boundary trains against the boundary rows in its
terminal pool, and its checkpoint carries those rows together with the binding
counters the run recorded for them. A resume of that run must declare the same
boundary again. Novomodelo compares the declared boundary rows with the terminal rows
of the checkpoint: the state dimension, the slot count, and then, slot by slot,
the role, the active flag, and the exact bits of the intercept and of each
coefficient.
- When the rows match, the resumed run keeps the binding counters the checkpoint
holds for them, so
max_active_per_stageor thedynamicmethod continues as in the interrupted run. - When any row differs, the resume is refused:
resume needs the policy.boundary and modeling.cost_scale_factor the interrupted run used: the boundary pool (pool {n}) differs from the checkpoint's at {difference}; resume with that policy.boundary and cost scale or continue with policy.mode = warm_startnovomodelo validate, novomodelo run and the Python bindings give the same line. A
modeling.cost_scale_factor that differs from the interrupted run’s is refused
only when the boundary rows it produces then differ from the checkpoint’s, which
happens when the boundary file’s factor also differs from the interrupted
run’s: the checkpoint rows are then converted twice and the boundary rows once.
Otherwise the resume applies its own scale. A warm start and a simulation-only
load do not compare: a warm start with a new boundary is accepted, and it
restarts the binding counters of the loaded rows.
Production coupling workflow
Seção intitulada “Production coupling workflow”A chained-study pipeline uses boundary cuts as follows:
The upstream study writes a policy checkpoint whose cut pools are each priced at
a date. The downstream study names that checkpoint in policy.boundary.path,
and the pool priced at the downstream study’s terminal boundary date becomes its
terminal future cost function. The dependency runs one way: the upstream study
never reads the downstream one. The conditions under which the imported cuts
apply to the downstream study’s state are in
Post-Study Boundary & Chained Studies §5.2.
Interaction with warm-start
Seção intitulada “Interaction with warm-start”Boundary cuts and warm-start are independent features. You can combine them:
{ "policy": { "mode": "warm_start", "path": "./policy", "boundary": { "path": "../upstream_study/output/policy" } }}This loads the downstream study’s own cuts from its previous run via warm-start AND loads the upstream policy’s boundary cuts at the terminal stage. Both sets of cuts contribute to the lower bound.
Read and Write Checkpoints from Python
Seção intitulada “Read and Write Checkpoints from Python”novomodelo.results.load_policy reads a policy checkpoint into plain Python dicts,
and novomodelo.write_policy_checkpoint writes one from dicts of the same shape, so
a loaded checkpoint round-trips: load, edit, write. The supported use is
authoring an external boundary future-cost function, for example one derived
analytically or produced by another tool, as a checkpoint that Novomodelo loads
through policy.boundary. The on-disk AffinePiece layout is
documented in the FlatBuffers Policy Schema.
A study loads the checkpoint only in the novomodelo version that wrote it
(Version gate); novomodelo.results.load_policy does not check the version.
Load a policy
Seção intitulada “Load a policy”novomodelo.results.load_policy(output_dir, policy_subdir="policy")output_dir is the study’s output directory; load_policy reads the
checkpoint from <output_dir>/<policy_subdir> (policy_subdir defaults to
"policy"). It returns a dict with four top-level keys:
| Key | Type | Description |
|---|---|---|
metadata | dict | format_version, software, software_version, created_at, num_stages, graph_manifest, season_manifest, producer |
stage_cuts | list[dict] | One entry per cut pool (one per stage on a stage chain) — see below |
stage_bases | list[dict] | One entry per node with stored bases: stage_id (the node position), iteration, and entries, one per forward-pass scenario, each with scenario, column_status, row_status and piece_row_slots (the pool slot of each cut row the basis holds) |
stage_states | list[dict] | One entry per pool that stores trial states: stage_id (the pool id), node_id, state_dimension, count, slots (the slot of the cut written at each state, ascending), data (count * state_dimension values, row-major) and entity_manifest; empty when no pool stores them |
Each stage_cuts entry carries:
| Key | Type | Description |
|---|---|---|
stage_id | int | Pool id (0-based), the key that names cuts/<pool>.bin; the 0-based stage position on a stage chain |
state_dimension | int | Length every cut’s coefficients must have |
capacity | int | Cut-pool slot capacity |
warm_start_count | int | Cuts loaded from a previous artifact at run start |
populated_count | int | Number of populated cut slots; optional on write, where it defaults to the number of cuts |
cost_scale_factor | float | Cost-scale factor of the values this pool holds (see Cost-Scale Canonicalization); required on write, finite and positive |
node_id | int | Policy-graph id of the node that owns the pool; -1 for a pool with no single owning node |
graph_stage_id | int | Graph-stage id of the node that owns the pool; -1 when unresolved |
priced_state_date | int | The owning stage’s end_date encoded YYYYMMDD, the date the pool’s cuts price; the int32-minimum sentinel when not recorded. A boundary load selects its source pool by this date |
entity_manifest | list[dict] | Per-slot entity markers — see below |
cuts | list[dict] | Cut records — see below |
Each entry in cuts carries slot_index (the cut’s identity in the pool),
iteration, forward_pass_index, intercept, coefficients, is_active, and
scored (whether the writing run stored the trial state the cut was computed
at), plus active_count and last_active_iteration when the checkpoint carries
binding counters. On write, scored defaults to False and the two counters to
absent.
entity_manifest is a list of per-slot markers,
{entity_type, entity_id, subindex, was_active, reference_date, interval_start, interval_end},
that let an externally authored boundary-cut checkpoint round-trip through
write_policy_checkpoint without losing slot identity. Which date marker a slot
carries follows from its family. A HydroInflowLag slot carries
reference_date, the start_date of its reference past stage, encoded
YYYYMMDD. The forward families (HydroTransitBucket,
AnticipatedThermalState) carry the half-open interval_start/interval_end
window, both encoded YYYYMMDD; an anticipated slot carries it only while it
holds a live commitment at the pool’s stage. A date field that does not apply
reads the int32-minimum sentinel (-2147483648): every other slot reads it in
all three fields, and so does an anticipated slot that holds no live commitment
at the pool’s stage.
load_policy applies no load gate: it reads any checkpoint this build can parse,
whichever novomodelo version wrote it, and returns the recorded software and version
as metadata["software"] and metadata["software_version"], without comparing
them with a study. A missing directory, or one without manifest.bin, raises
FileNotFoundError when neither <policy_subdir>.staging nor
<policy_subdir>.previous holds a manifest.bin, and an unreadable buffer
raises OutputError. Error Codes
lists the failure class of every load path.
Write a checkpoint
Seção intitulada “Write a checkpoint”novomodelo.write_policy_checkpoint(path, stage_cuts, metadata, stage_bases=None, stage_states=None, inflow_lag_depth=None)stage_cuts, metadata, stage_bases and stage_states mirror the
load_policy shapes above, so a checkpoint loaded from disk round-trips through
Python without reshaping. stage_bases and stage_states default to empty when
omitted. A pool dict holding active_cut_indices, a cut dict holding cut_id,
or a basis dict holding num_cut_rows, num_columns or num_rows is refused
with {position}: key '{key}' is not part of a policy checkpoint (format 4); remove it.
An authored metadata needs created_at, num_stages, and a producer with
completed_iterations, final_lower_bound, max_iterations, forward_passes,
warm_start_cuts, and rng_seed. format_version, graph_manifest,
season_manifest, and the other producer keys (best_upper_bound,
warm_start_counts, total_visited_states, training_block_mode,
training_block_mode_per_stage, cost_scale_factor, lower_bound_history (a
list of floats, empty when omitted), state_history (None, "whole" or a
positive window), activity_counters and basis_store_complete (both False
when omitted)) are optional. basis_store_complete set to True with no basis
in stage_bases is refused. The payloads then pass the checks of a checkpoint
write (Checkpoint Directory Contents), and a
refusal raises ValueError with its message.
inflow_lag_depth, when set to N > 0, has Novomodelo reserve N canonical
HydroInflowLag state slots per storage hydro in every stage’s manifest and
place each cut’s inflow_lag_coefficients at their (hydro, depth) positions,
so a boundary policy authored for a case with no autoregressive inflow model can
still carry an inflow-lag-coupled terminal cost-to-go. Absent or 0, the
written checkpoint is byte-identical.
The function writes manifest.bin, cuts/, and basis/ directly under path,
and states/ only when stage_states is non-empty. That is the
Checkpoint Directory Contents layout, so
path should be a policy/-style directory. To use it as
policy.boundary.path, pass it relative to the consuming case directory, or as
an absolute path. load_policy joins policy_subdir onto the directory it is
given, so a checkpoint written to <dir>/policy is read back with load_policy
on its parent directory, <dir>.
write_policy_checkpoint stamps the running novomodelo version into the checkpoint
and ignores software, software_version or novomodelo_version keys in metadata, so the checkpoint loads only in
that version (see Version gate). A checkpoint written without
stage_bases is not subject to the stored-basis gate: it
carries no bases to check.
Round-trip example
Seção intitulada “Round-trip example”The following example is copy-runnable. To edit a trained policy, load it with
novomodelo.results.load_policy("output/") and apply the edit step below to
loaded["stage_cuts"]; the example authors a checkpoint from scratch so it runs
without a study. It writes the checkpoint, loads it back, appends a third cut,
writes the edited policy back to the same path, and prints the reloaded cut
count and the novomodelo version recorded in the checkpoint.
import tempfile
import novomodeloimport novomodelo.results
parent = tempfile.mkdtemp()
stage_cuts = [ { "stage_id": 0, "state_dimension": 3, "capacity": 10, "cost_scale_factor": 2_500_000.0, "cuts": [ { "slot_index": 0, "iteration": 1, "forward_pass_index": 0, "intercept": 42.0, "coefficients": [1.0, 2.0, 3.0], "is_active": True, }, { "slot_index": 1, "iteration": 1, "forward_pass_index": 1, "intercept": 10.5, "coefficients": [0.5, -1.5, 2.5], "is_active": True, }, ], }]
metadata = { "created_at": "2026-07-30T00:00:00Z", "num_stages": 1, "producer": { "completed_iterations": 5, "final_lower_bound": 123.45, "best_upper_bound": 130.0, "max_iterations": 10, "forward_passes": 4, "warm_start_cuts": 0, "warm_start_counts": [0], "rng_seed": 42, "total_visited_states": 0, "training_block_mode": "parallel", "training_block_mode_per_stage": [], "cost_scale_factor": 2_500_000.0, },}
# Write to `<parent>/policy` — `load_policy` joins policy_subdir="policy" onto# the directory it is given, so it is loaded from `parent` below.novomodelo.write_policy_checkpoint(f"{parent}/policy", stage_cuts, metadata)
loaded = novomodelo.results.load_policy(parent)assert loaded["metadata"]["format_version"] == 4assert loaded["stage_cuts"][0]["populated_count"] == 2
# Edit: append a third cut. Its coefficients must match state_dimension (3).# Keep slot_index unique, and set populated_count to the new cut count.cuts = loaded["stage_cuts"][0]["cuts"]cuts.append( { "slot_index": 2, "iteration": 2, "forward_pass_index": 0, "intercept": -5.0, "coefficients": [4.0, -2.0, 0.0], "is_active": True, })loaded["stage_cuts"][0]["populated_count"] = len(cuts)
# Write back: same round-trip shape, one more cut than before.novomodelo.write_policy_checkpoint( f"{parent}/policy", loaded["stage_cuts"], loaded["metadata"])
# The reloaded checkpoint holds three cuts and records the running novomodelo version.reloaded = novomodelo.results.load_policy(parent)print(len(reloaded["stage_cuts"][0]["cuts"]), reloaded["metadata"]["software_version"])The script prints the reloaded cut count and the version that
write_policy_checkpoint stamped:
3 0.21.0Input validation
Seção intitulada “Input validation”write_policy_checkpoint raises ValueError when any of the following holds.
The message locates the problem: the position of a retired key, the stage and
cut slot for the two per-cut checks, the pool’s states file for a state-data
mismatch, and the hydro for an unplaceable inflow-lag coefficient.
- a pool, cut or basis dict holds a retired key (see Write a checkpoint);
- a pool’s
cost_scale_factoris missing, not finite or not positive; - a cut’s
coefficientslength does not match its stage’sstate_dimension; - a cut carries
inflow_lag_coefficientswithout a positiveinflow_lag_depth; - (under
inflow_lag_depth) a manifest lacks a leading storage block; - (under
inflow_lag_depth) an inflow-lag coefficient is unplaceable; - the producer sets
basis_store_completewith no basis instage_bases; - a producer
state_historyis other thanNone,"whole"or a positive window; - the payloads break a checkpoint rule (slot order, row counts, counter
presence, dates, a repeated id, size limits), a
stage_statesentry whosedatalength differs fromcount * state_dimensionincluded; the message isserialization error for entity {entity}: {message}, where{message}names the file and the rule; or path(for a link, its target) or its.stagingor.previoussibling holds an entry no checkpoint writer leaves there (novomodelo.errors.ValidationError, aValueError, with therefusing to write a checkpoint: …text; nothing on disk changes).
Each snippet below uses metadata from the round-trip example. The second also
uses its stage_cuts; the third defines its own. Each snippet ends with the
exception text it raises.
A cut whose coefficients length disagrees with its stage’s
state_dimension:
bad_cuts = [ { "stage_id": 0, "state_dimension": 3, "capacity": 10, "cost_scale_factor": 2_500_000.0, "cuts": [ { "slot_index": 0, "iteration": 1, "forward_pass_index": 0, "intercept": 42.0, "coefficients": [1.0, 2.0], # length 2, but state_dimension=3 "is_active": True, }, ], }]
novomodelo.write_policy_checkpoint("output/policy", bad_cuts, metadata)# ValueError: stage 0 cut at slot 0: coefficients has 2 entries, expected state_dimension=3A stage_states entry whose flat data length disagrees with
count * state_dimension:
stage_states = [ { "stage_id": 0, "state_dimension": 3, "count": 2, "slots": [0, 1], "data": [1.0, 2.0, 3.0], # length 3, but count * state_dimension = 6 }]
novomodelo.write_policy_checkpoint( "output/policy", stage_cuts, metadata, stage_states=stage_states)# ValueError: serialization error for entity policy_checkpoint_structure: states/000.bin: data holds 3 values, not count 2 times state_dimension 3A cut carrying inflow_lag_coefficients with no inflow_lag_depth passed to
reserve the lag slots (keyed by integer hydro id; list index 0 = lag
depth 1):
stage_cuts = [ { "stage_id": 0, "state_dimension": 3, "capacity": 10, "cost_scale_factor": 2_500_000.0, "cuts": [ { "slot_index": 0, "iteration": 1, "forward_pass_index": 0, "intercept": 42.0, "coefficients": [1.0, 2.0, 3.0], "is_active": True, "inflow_lag_coefficients": {0: [0.5]}, }, ], }]
novomodelo.write_policy_checkpoint("output/policy", stage_cuts, metadata)# ValueError: stage 0 cut at slot 0: inflow_lag_coefficients supplied without inflow_lag_depth; pass inflow_lag_depth=N to reserve the lag slotsSee Also
Seção intitulada “See Also”- Theory: Cut Management — the cut pool that a policy checkpoint persists across runs.
- Configuration — every
config.jsonfield documented - Running Studies — common workflows including training-only and simulation-only runs
- Output Format — detailed description of every output file