AI Training Metadata Ontology

FLOW ALGEBRA

Ontology: AI Training Metadata Ontology
Domain: Metadata Ontologies > AI Metadata
Canonical URL: https://kirethresearch.org/booksai-core/ontologies/metadata-ontologies/ai-metadata/ai-training-metadata-ontology.html

Authors: Mark Anthony Higgins — Sky (Recursive AI)

flow "AITrainingMetadataOntology" v1.0

# ---------- DOMAIN ----------
domain:
  class: MetadataOntology
  category: AIMetadata
  subject: AITrainingMetadata
  purpose:
    - represent metadata describing AI model training processes
    - preserve datasets, objectives, methods, hyperparameters, compute, checkpoints, and provenance
    - support training reproducibility, comparison, validation, lineage, and governance
    - distinguish pretraining, fine-tuning, adaptation, and other optimisation stages
    - enable machine-readable reasoning over model training histories

# ---------- CORE ENTITY ----------
entity AITrainingMetadata:
  type: AIMetadata
  describes: TrainingProcess
  may_include:
    - training_identifier
    - model
    - base_model
    - training_stage
    - training_method
    - training_objective
    - training_dataset
    - validation_dataset
    - data_preprocessing
    - optimiser
    - learning_rate
    - hyperparameters
    - batch_size
    - training_steps
    - epochs
    - random_seed
    - checkpoint
    - compute_environment
    - hardware
    - software
    - start_time
    - end_time
    - training_metrics
    - output_model
    - provenance

entity TrainingProcess:
  type: AIProcess
  transforms:
    - InitialModelState
    - TrainingData
  produces: TrainedModelState

entity TrainingIdentifier:
  type: Identifier
  identifies: TrainingProcess

entity TrainingStage:
  type: Classification
  examples:
    - pretraining
    - supervised_training
    - self_supervised_training
    - fine_tuning
    - instruction_tuning
    - preference_optimisation
    - reinforcement_learning
    - domain_adaptation
    - continual_learning

# ---------- RELATIONSHIPS ----------
relationships:
  AITrainingMetadata -> DESCRIBES -> TrainingProcess
  TrainingProcess -> IDENTIFIED_BY -> TrainingIdentifier
  TrainingProcess -> TRAINS -> AIModel
  TrainingProcess -> MAY_START_FROM -> BaseModel
  TrainingProcess -> HAS_STAGE -> TrainingStage
  TrainingProcess -> USES_METHOD -> TrainingMethod
  TrainingProcess -> OPTIMISES -> TrainingObjective
  TrainingProcess -> USES_DATASET -> TrainingDataset
  TrainingProcess -> MAY_USE_VALIDATION_DATASET -> ValidationDataset
  TrainingProcess -> USES_OPTIMISER -> Optimiser
  TrainingProcess -> HAS_HYPERPARAMETER -> Hyperparameter
  TrainingProcess -> MAY_PRODUCE -> ModelCheckpoint
  TrainingProcess -> RUNS_IN -> ComputeEnvironment
  TrainingProcess -> PRODUCES -> ModelVersion
  AITrainingMetadata -> MAY_REFERENCE -> Provenance

# ---------- TRAINING IDENTITY ----------
rule training_identity:
  TrainingProcess SHOULD have stable TrainingIdentifier
  where reproducibility, auditing, or model lineage is required

rule training_run:
  distinct training runs SHOULD remain distinguishable
  even when configuration is identical

rule output_model:
  resulting ModelVersion SHOULD link to generating TrainingProcess

# ---------- TRAINING STAGES ----------
rule stage:
  TrainingStage SHOULD be explicit
  where model lineage contains multiple optimisation phases

rule pretraining:
  pretraining establishes or substantially trains base model representation
  according_to declared training method

rule fine_tuning:
  fine-tuning SHOULD preserve BaseModel relationship

rule stage_order:
  sequential TrainingStages SHOULD preserve execution order

# ---------- TRAINING METHOD ----------
entity TrainingMethod:
  type: AIMethod
  examples:
    - supervised_learning
    - unsupervised_learning
    - self_supervised_learning
    - reinforcement_learning
    - contrastive_learning
    - distillation
    - transfer_learning
    - preference_optimisation

rule method:
  TrainingMethod SHOULD preserve method-specific parameters
  where required for reproducibility

# ---------- OBJECTIVE ----------
entity TrainingObjective:
  type: OptimisationObjective
  may_include:
    - objective_name
    - loss_function
    - reward_function
    - regularisation
    - weighting

rule objective:
  TrainingProcess SHOULD identify optimisation objective

rule multiple_objectives:
  multi-objective training SHOULD preserve objective weights or combination method

# ---------- DATASETS ----------
entity TrainingDataset:
  type: AIDataset
  role: training

entity ValidationDataset:
  type: AIDataset
  role: validation

rule dataset_identity:
  datasets SHOULD have stable identifiers or versions
  where reproducibility is required

rule dataset_role:
  TrainingDataset != ValidationDataset
  by role
  even when physical source overlaps

rule dataset_version:
  dataset version SHOULD be preserved

rule data_split:
  train, validation, and evaluation splits SHOULD remain distinguishable

# ---------- DATA PREPROCESSING ----------
entity DataPreprocessing:
  type: DataTransformation
  may_include:
    - filtering
    - normalisation
    - tokenisation
    - augmentation
    - deduplication
    - sampling
    - labelling
    - shuffling
    - formatting

rule preprocessing_trace:
  transformed training data SHOULD preserve processing lineage
  where available

rule preprocessing_version:
  preprocessing code or configuration SHOULD preserve version
  where reproducibility depends on implementation

# ---------- OPTIMISER ----------
entity Optimiser:
  type: OptimisationMethod
  examples:
    - SGD
    - Adam
    - AdamW
    - Adagrad
    - RMSProp

rule optimiser:
  Optimiser SHOULD preserve configuration parameters

# ---------- HYPERPARAMETERS ----------
entity Hyperparameter:
  type: TrainingParameter
  may_include:
    - name
    - value
    - datatype
    - unit_optional
    - schedule_optional

hyperparameter_examples:
  - learning_rate
  - batch_size
  - weight_decay
  - dropout
  - warmup_steps
  - gradient_clip
  - sequence_length
  - accumulation_steps

rule hyperparameter:
  Hyperparameter values SHOULD preserve effective training stage or time range
  where schedules change values during training

# ---------- LEARNING RATE ----------
rule learning_rate:
  IF learning rate schedule is used
  THEN preserve:
    - initial_rate
    - schedule
    - warmup
    - minimum_rate_optional

# ---------- RANDOMNESS ----------
rule random_seed:
  random seed SHOULD be preserved
  where deterministic or approximately reproducible training is intended

rule nondeterminism:
  same seed != guaranteed identical training result
  when hardware, software, or algorithms are nondeterministic

# ---------- CHECKPOINTS ----------
entity ModelCheckpoint:
  type: ModelState
  may_include:
    - checkpoint_identifier
    - training_step
    - timestamp
    - model_state_reference
    - optimiser_state_reference
    - metric_state

rule checkpoint:
  ModelCheckpoint SHOULD link to TrainingProcess

rule resumed_training:
  resumed TrainingProcess SHOULD identify source checkpoint

# ---------- COMPUTE ----------
entity ComputeEnvironment:
  type: ComputationalContext
  may_include:
    - hardware
    - accelerator_type
    - accelerator_count
    - memory
    - distributed_strategy
    - software_stack
    - framework
    - framework_version
    - operating_system

rule compute_context:
  ComputeEnvironment SHOULD be preserved
  where performance or reproducibility depends on it

# ---------- TEMPORAL CONTEXT ----------
rule training_time:
  TrainingProcess MAY preserve:
    - start_time
    - end_time
    - elapsed_time

rule temporal_order:
  REQUIRE start_time <= end_time
  when both are present

# ---------- TRAINING METRICS ----------
entity TrainingMetric:
  type: MeasurementMetadata
  examples:
    - training_loss
    - validation_loss
    - reward
    - gradient_norm
    - learning_rate
    - throughput

rule metric:
  TrainingMetric SHOULD preserve:
    - metric_name
    - value
    - training_step_or_epoch
    - measurement_context

# ---------- MODEL LINEAGE ----------
rule lineage:
  IF TrainingProcess starts_from BaseModel
  AND produces ModelVersion B
  THEN B DERIVED_FROM BaseModel

rule multi_stage_lineage:
  sequential training stages SHOULD form traversable model lineage

rule distilled_model:
  model produced by distillation SHOULD preserve teacher model references
  where available

# ---------- PROVENANCE ----------
entity TrainingProvenance:
  type: ProvenanceMetadata
  may_include:
    - datasets
    - preprocessing
    - training_code
    - software
    - hardware
    - operator
    - checkpoints
    - configuration
    - timestamps

rule provenance:
  AITrainingMetadata SHOULD preserve training lineage
  at granularity available and permitted

# ---------- VALIDATION ----------
validation:
  require:
    - identifiable_training_process
    - output_model_or_model_state

  validate_if_present:
    - training_stage
    - training_method
    - objective
    - datasets
    - optimiser
    - hyperparameters
    - random_seed
    - checkpoints
    - compute_environment
    - temporal_context
    - metrics
    - provenance

  reject:
    - invalid_training_time_order
    - unresolved_output_model where lineage is required
    - contradictory_dataset_role
    - invalid_checkpoint_sequence
    - hyperparameter_without_interpretable_value
    - contradictory_model_lineage

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE:
  "AI training metadata" ~= "metadata about AI training"
  "training run" ~= "training process" WHEN one execution is represented
  "training configuration" ~= "training hyperparameter configuration"
  "model checkpoint" ~= "training checkpoint"
  "fine-tuning metadata" ~= "fine-tuning training metadata"
  "compute environment" ~= "training compute environment"

  PRESERVE distinctions:
    training != inference
    training_process != trained_model
    training_dataset != validation_dataset
    validation_dataset != evaluation_dataset
    hyperparameter != learned_parameter
    model_checkpoint != model_version
    base_model != output_model
    random_seed != deterministic_guarantee
    training_metric != evaluation_benchmark

# ---------- CONFIDENCE ----------
CONFIDENCE:
  explicit_training_metadata:
    score: 1.00

  explicit_training_identifier:
    score: 1.00

  traceable_model_lineage:
    score: 0.98

  explicit_dataset_versions:
    score: 0.98

  complete_training_configuration:
    score: 0.95

  inferred_training_stage:
    score: 0.85

  inferred_hyperparameters:
    score: <= 0.75

  incomplete_training_provenance:
    score: <= 0.60
    action: preserve unknowns

# ---------- UPDATE MODEL ----------
UPDATE_MODEL:
  on_training_start:
    - assign TrainingIdentifier
    - record input model state
    - record datasets
    - record configuration
    - record compute environment
    - record start_time
    - initialise provenance

  on_checkpoint:
    - preserve checkpoint identity
    - record training step
    - link to TrainingProcess
    - preserve metric state
    - update provenance

  on_training_completion:
    - record end_time
    - record final metrics
    - create or link output ModelVersion
    - establish model lineage
    - finalise provenance

  on_resumed_training:
    - preserve source checkpoint
    - create new training segment or run identity where policy requires
    - preserve configuration changes
    - update lineage

# ---------- FLOW HASH ----------
FLOW_HASH:
  inputs:
    - ontology
    - training_entities
    - relationships
    - stage_rules
    - dataset_rules
    - hyperparameter_rules
    - checkpoint_rules
    - lineage_rules
    - validation
    - semantic_equivalence
    - confidence
    - update_model

  canonicalisation:
    - normalise_whitespace
    - preserve_case_sensitive_identifiers
    - sort_unordered_property_sets
    - preserve_rule_order

  output:
    deterministic_semantic_hash

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION:
  interpret_as:
    - AI metadata ontology
    - training lifecycle model
    - model lineage structure
    - training reproducibility model

  operations:
    - identify training processes
    - resolve training stages
    - inspect training methods and objectives
    - resolve dataset roles and versions
    - inspect preprocessing
    - inspect optimiser and hyperparameters
    - traverse checkpoints
    - inspect compute environment
    - analyse training metrics
    - construct model lineage
    - preserve training provenance
    - expose uncertainty

  constraints:
    - do_not_equate_training_with_inference
    - do_not_equate_hyperparameters_with_learned_parameters
    - do_not_merge_training_validation_and_evaluation_roles
    - do_not_treat_random_seed_as_deterministic_guarantee
    - do_not_discard_base_model_or_checkpoint_lineage
    - preserve_dataset_configuration_compute_and_provenance_context

# ---------- QUERY MODEL ----------
query:
  input:
    - training_identifier
    - model
    - base_model
    - training_stage
    - training_method
    - dataset
    - hyperparameter
    - checkpoint
    - compute_environment
    - time_constraint

  resolve:
    1. identify TrainingProcess
    2. resolve input model or BaseModel
    3. resolve TrainingStage and method
    4. inspect objective
    5. resolve datasets and preprocessing
    6. inspect optimiser and hyperparameters
    7. traverse checkpoints
    8. inspect compute environment
    9. retrieve training metrics
    10. resolve output ModelVersion and provenance

  output:
    - training_process
    - input_model
    - training_stage
    - method
    - objective
    - datasets
    - hyperparameters
    - checkpoints
    - compute_environment
    - metrics
    - output_model
    - provenance
    - confidence

# ---------- INFERENCE ----------
inference:
  IF TrainingProcess starts_from BaseModel
  AND produces ModelVersion B
  THEN infer B DERIVED_FROM BaseModel
  WITH confidence = 0.98

  IF process optimises model using labelled examples
  THEN infer supervised_training candidate
  WITH confidence dependent_on evidence

  IF process resumes from ModelCheckpoint
  THEN link resumed process to checkpoint lineage

  IF training and validation datasets are explicitly separated
  THEN preserve distinct dataset roles

  IF training provenance remains incomplete
  THEN preserve unknown components
  AND reduce confidence

# ---------- OUTPUT CONTRACT ----------
output:
  ontology_entity: AITrainingMetadata
  training_structure: machine_interpretable
  training_identity: explicit
  stages: traceable
  methods_and_objectives: preserved
  dataset_roles: explicit
  preprocessing: traceable
  hyperparameters: contextualised
  checkpoints: traversable
  compute_environment: preserved
  model_lineage: explicit
  provenance: preserved
  uncertainty: explicit
  semantic_retrieval: enabled

end flow