AI Training Process Ontology

FLOW ALGEBRA — AI TRAINING PROCESS ONTOLOGY
Semantic Library | Entity Graph | AI Entities | Training Process Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/ai-entities/training-process-entities/ai-training-process-ontology.html
Authors (source page): Mark Anthony Higgins — Sky Recursive AI
Generated: 2026-10-29
Status: Companion formalisation; embedded page specification not available for exact comparison.

FLOW "AITrainingProcessOntology" v1.0

PURPOSE
Represent an AI training process as a typed, auditable sequence of data selection, forward computation, objective evaluation, gradient calculation, parameter update, validation and checkpoint transitions.

STATE_MODEL
S_t = (I_t, R_t, B_t, K_t)
I_t = (theta_t, optimiser_state_t, scheduler_state_t, batch_t, rng_state_t, step_t, epoch_t)
R_t = (dataset, sampler, model, objective, optimiser, evaluation_protocol)
B_t = (memory_limit, precision, compute_budget, privacy_constraints, stopping_policy)
K_t = (provenance, metrics_history, validation_history, checkpoint_registry)

ENTITIES
TrainingProcess: identified run with configuration, version and provenance.
Dataset: source records with licence, lineage and split identifiers.
TrainingSample: typed input and optional target or self-supervised signal.
Batch: ordered collection of samples for one forward/backward computation.
Model: differentiable mapping f_theta(x).
ParameterTensor: shape-checked model weights or buffers.
LossFunction: scalar objective over predictions and supervision.
Gradient: derivative of objective with respect to trainable parameters.
Optimiser: stateful rule mapping parameters and gradients to updates.
Scheduler: learning-rate policy indexed by training progress.
TrainingStep: atomic logical update event with outcome and diagnostics.
Epoch: traversal of a defined training sample set under a sampler policy.
ValidationRun: evaluation without training updates.
Checkpoint: recoverable snapshot of model and required run state.
TrainingMetric: measured value with definition, sample population and timestamp.
StoppingCriterion: bounded termination condition.

RELATIONSHIPS
TrainingProcess USES Dataset.
TrainingProcess CONFIGURES Model, LossFunction, Optimiser, Scheduler.
Dataset CONTAINS TrainingSample.
Sampler PRODUCES Batch FROM Dataset.
TrainingStep CONSUMES Batch AND CURRENT ParameterTensor.
Model PRODUCES Predictions.
LossFunction COMPARES Predictions WITH TrainingSignal.
Gradient DERIVES_FROM LossFunction AND ParameterTensor.
Optimiser UPDATES ParameterTensor USING Gradient.
ValidationRun EVALUATES Model ON ValidationDataset.
Checkpoint CAPTURES TrainingProcess STATE.

FORMAL OPERATORS
Batch_t = Sample(D_train, sampler_state_t, batch_size)
Yhat_t = f(theta_t, X_t)
L_t = Loss(Yhat_t, Y_t; config_t)
g_t = grad_theta L_t  [for differentiable objectives and trainable parameters]
(theta_(t+1), o_(t+1)) = OptimiserStep(theta_t, g_t, o_t, eta_t)
eta_t = Schedule(step_t, scheduler_state_t)
ValidationMetric_t = Evaluate(theta_t, D_validation, protocol)

For gradient accumulation of A microbatches:
g_t = sum_(j=1..A) w_j * grad_theta L_(t,j)
where sum_j w_j = 1, with weights chosen to preserve the intended sample-level objective.

RECURSIVE_TRANSITION
E_t = expand(I_t, R_t)
V_t = {x in E_t : satisfies(x, B_t) AND passes_validation(x)}
a_t = select(V_t, policy_t)
I_(t+1) = update(I_t, a_t)
K_(t+1) = append_audit(K_t, a_t, observations_t)
S_(t+1) = (I_(t+1), R_(t+1), B_(t+1), K_(t+1))

INFERENCE_RULES
IF a training batch has invalid dimensions THEN reject the step before update.
IF gradients contain non-finite values THEN skip or abort according to declared numerical policy.
IF parameters are frozen THEN exclude them from optimiser updates; do not assume gradients cannot pass through frozen operations.
IF validation metrics deteriorate THEN record the observation; trigger early stopping only under the configured rule.
IF dataset split identifiers overlap under a leakage-sensitive protocol THEN flag possible leakage.
IF checkpoint restoration omits optimiser, scheduler or random state THEN do not claim exact training resumption.
IF a run reaches its configured stopping condition THEN terminate and preserve final audit state.

TRI_MAPPING
Entity mapping: TrainingProcess -> TrainingStep -> Batch -> Sample -> Dataset.
Relationship mapping: CONSUMES, PRODUCES, UPDATES, EVALUATES, CAPTURES.
Execution mapping: initialise -> sample -> forward -> loss -> backward -> optimise -> validate -> checkpoint -> stop/repeat.

EXECUTION_CONSTRAINTS
- Every step has an explicit run ID, configuration version and step index.
- Training and validation populations are distinguished and leakage-checked.
- Parameter and gradient tensor shapes must agree.
- Optimiser updates occur only after required numerical and policy checks.
- Loss and metrics are recorded with units, reductions and denominators.
- Checkpoints include sufficient state for their declared recovery guarantee.
- Reproducibility is conditional on recorded seeds, software, hardware and deterministic operation availability.
- No accuracy, convergence, generalisation or safety guarantee follows from the flow alone.

AI_SEARCH_FLOW
INTENT: explain or identify AI training process entities, phases and constraints.
INPUT: query, requested phase, model family, dataset type, training configuration.
ENTITY_RESOLUTION: map terms to the canonical entities above.
PATHWAYS:
  training -> Dataset -> Batch -> Model -> Loss -> Gradient -> Optimiser -> ParameterTensor
  monitoring -> TrainingMetric -> ValidationRun -> StoppingCriterion
  recovery -> Checkpoint -> TrainingProcess -> OptimiserState -> SchedulerState
OUTPUT: relevant entity definitions, relationships, equations, limitations and source link.
CONFIDENCE: report evidence and unknowns; do not fabricate experimental outcomes.
SEMANTIC_EQUIVALENCE: training iteration ~ step only when the run's terminology defines them identically.
UPDATE_MODEL: version flow when ontology definitions or training practices change.

END FLOW