AI Model Metadata Ontology

FLOW ALGEBRA

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

Authors: Mark Anthony Higgins — Sky (Recursive AI)

flow "AIModelMetadataOntology" v1.0

# ---------- DOMAIN ----------
domain:
  class: MetadataOntology
  category: AIMetadata
  subject: AIModelMetadata
  purpose:
    - represent metadata describing artificial intelligence models
    - preserve model identity, family, architecture, parameters, capabilities, limitations, and versions
    - connect models with training, evaluation, deployment, inference, and provenance
    - support model discovery, comparison, validation, reproducibility, and governance
    - enable machine-readable reasoning over AI model lifecycle states

# ---------- CORE ENTITY ----------
entity AIModelMetadata:
  type: AIMetadata
  describes: AIModel
  may_include:
    - model_identifier
    - model_name
    - model_family
    - model_type
    - architecture
    - parameter_metadata
    - model_version
    - creator
    - provider
    - training_metadata
    - dataset_metadata
    - capability_metadata
    - limitation_metadata
    - evaluation_metadata
    - performance_metadata
    - deployment_metadata
    - inference_metadata
    - licence
    - status
    - provenance

entity AIModel:
  type: ComputationalModel
  may_be:
    - MachineLearningModel
    - NeuralNetwork
    - LanguageModel
    - VisionModel
    - MultimodalModel
    - GenerativeModel
    - ClassificationModel
    - RegressionModel
    - ReinforcementLearningModel
    - EmbeddingModel

entity ModelIdentifier:
  type: Identifier
  identifies: AIModel

entity ModelFamily:
  type: ModelClassification
  groups: RelatedAIModels

entity ModelType:
  type: Classification
  describes: FunctionalOrArchitecturalModelCategory

# ---------- RELATIONSHIPS ----------
relationships:
  AIModelMetadata -> DESCRIBES -> AIModel
  AIModel -> IDENTIFIED_BY -> ModelIdentifier
  AIModel -> BELONGS_TO_FAMILY -> ModelFamily
  AIModel -> HAS_TYPE -> ModelType
  AIModel -> HAS_ARCHITECTURE -> ModelArchitecture
  AIModel -> MAY_HAVE_PARAMETERS -> ParameterMetadata
  AIModel -> HAS_VERSION -> ModelVersion
  AIModel -> TRAINED_BY -> TrainingProcess
  AIModel -> TRAINED_ON -> TrainingDataset
  AIModel -> MAY_BE_FINE_TUNED_ON -> Dataset
  AIModel -> EVALUATED_BY -> EvaluationProcess
  AIModel -> MAY_BE_DEPLOYED_AS -> AIService
  AIModel -> PRODUCES -> AIOutput
  AIModelMetadata -> MAY_REFERENCE -> Provenance

# ---------- MODEL IDENTITY ----------
rule model_identity:
  AIModel SHOULD have stable ModelIdentifier
  where persistent reference, deployment, or auditing is required

rule model_name:
  ModelName MUST NOT be assumed globally unique

rule provider_namespace:
  model identity SHOULD preserve provider or identifier namespace
  where names may collide

rule family_identity:
  ModelFamily != AIModel

# ---------- MODEL TYPES ----------
model_types:
  - predictive
  - generative
  - discriminative
  - classification
  - regression
  - ranking
  - embedding
  - language
  - vision
  - speech
  - multimodal
  - reinforcement_learning
  - agentic

rule multiple_types:
  AIModel MAY have multiple compatible ModelTypes

rule type_context:
  model type SHOULD preserve classification scheme
  where categories overlap or differ across systems

# ---------- ARCHITECTURE ----------
entity ModelArchitecture:
  type: AIModelStructure
  may_include:
    - architecture_name
    - architecture_family
    - layers
    - components
    - attention_structure
    - encoder
    - decoder
    - modality_components
    - context_mechanism

architecture_examples:
  - transformer
  - convolutional_network
  - recurrent_network
  - graph_neural_network
  - diffusion_model
  - mixture_of_experts
  - ensemble
  - hybrid_model

rule architecture:
  ModelArchitecture SHOULD describe structural properties
  relevant to model interpretation

rule architecture_not_version:
  ModelArchitecture != ModelVersion

# ---------- PARAMETERS ----------
entity ParameterMetadata:
  type: ModelMetadata
  may_include:
    - parameter_count
    - trainable_parameter_count
    - precision
    - quantisation
    - context_length
    - embedding_dimension
    - hidden_dimension

rule parameter_count:
  parameter count SHOULD identify counting method
  where sparse, shared, frozen, or expert parameters complicate interpretation

rule parameter_count_not_capability:
  larger parameter count != guaranteed higher capability

# ---------- VERSION ----------
entity ModelVersion:
  type: VersionMetadata
  may_include:
    - version_identifier
    - release_date
    - predecessor
    - successor
    - change_description
    - status

rule model_version:
  material change to weights, architecture, behaviour, or interface
  SHOULD create distinguishable ModelVersion
  according_to provider version policy

rule version_family_distinction:
  ModelVersion != ModelFamily

rule historical_version:
  superseded ModelVersion SHOULD remain traceable
  where historical AIOutput depends on it

# ---------- TRAINING ----------
entity ModelTrainingMetadata:
  type: TrainingMetadata
  may_include:
    - training_method
    - training_objective
    - training_dataset
    - optimiser
    - hyperparameters
    - training_steps
    - compute_environment
    - checkpoint
    - random_seed
    - training_time
    - provenance

rule training:
  AIModel SHOULD reference TrainingMetadata
  where training context is available and relevant

rule fine_tuning:
  fine-tuned model SHOULD preserve relationship to base model
  where model lineage is known

rule model_lineage:
  derived model SHOULD preserve:
    - base_model
    - transformation_or_training_activity
    - resulting_model_version
    - provenance

# ---------- CAPABILITIES ----------
entity ModelCapability:
  type: AIMetadata
  may_include:
    - capability_name
    - modality
    - supported_task
    - evaluation_evidence
    - constraints
    - confidence

capability_examples:
  - text_generation
  - classification
  - summarisation
  - translation
  - reasoning
  - retrieval
  - image_generation
  - image_understanding
  - speech_recognition
  - code_generation
  - tool_use

rule capability_evidence:
  capability claim SHOULD reference evaluation or documented support
  where available

rule capability_not_guarantee:
  declared capability != guaranteed performance on every input

# ---------- LIMITATIONS ----------
entity ModelLimitation:
  type: AIMetadata
  may_include:
    - limitation_type
    - affected_task
    - affected_context
    - severity
    - evidence
    - mitigation

rule limitation:
  known limitations SHOULD remain associated with relevant ModelVersion

rule context_limitation:
  limitation MAY apply only under specified domain, language, modality, or input conditions

# ---------- EVALUATION ----------
entity ModelEvaluationMetadata:
  type: EvaluationMetadata
  may_include:
    - benchmark
    - evaluation_dataset
    - metric
    - score
    - evaluation_method
    - evaluator
    - timestamp
    - model_version
    - provenance

rule evaluation:
  evaluation result MUST identify ModelVersion
  where multiple versions exist

rule score_context:
  EvaluationScore SHOULD preserve metric, dataset, and method

rule score_comparison:
  model scores SHOULD be compared only under compatible evaluation conditions

# ---------- PERFORMANCE ----------
entity ModelPerformanceMetadata:
  type: PerformanceMetadata
  may_include:
    - latency
    - throughput
    - memory_usage
    - compute_usage
    - energy_usage
    - cost
    - reliability

rule performance:
  performance measurements SHOULD preserve hardware and workload context

# ---------- DEPLOYMENT ----------
entity ModelDeploymentMetadata:
  type: DeploymentMetadata
  may_include:
    - deployment_identifier
    - model_version
    - environment
    - endpoint
    - configuration
    - hardware
    - software
    - region
    - deployment_time
    - status

rule deployment_version:
  deployment MUST identify applicable ModelVersion
  where deterministic model attribution is required

# ---------- INFERENCE ----------
entity ModelInferenceMetadata:
  type: InferenceMetadata
  may_include:
    - model_version
    - input
    - inference_parameters
    - context
    - tools
    - retrieval_sources
    - output
    - timestamp
    - provenance

rule inference_model:
  AIOutput SHOULD link to generating ModelVersion

rule inference_configuration:
  generation parameters SHOULD be preserved
  where reproducibility depends on them

# ---------- STATUS ----------
model_status:
  - development
  - experimental
  - active
  - production
  - deprecated
  - superseded
  - retired

rule status:
  model status SHOULD be explicit and temporally contextualised

# ---------- LICENCE ----------
entity ModelLicence:
  type: RightsMetadata
  may_include:
    - licence_identifier
    - usage_rights
    - redistribution_rights
    - modification_rights
    - attribution_requirement
    - restrictions

rule licence:
  model use SHOULD respect declared ModelLicence

# ---------- PROVENANCE ----------
entity ModelProvenance:
  type: ProvenanceMetadata
  may_include:
    - creator
    - provider
    - base_model
    - training_process
    - datasets
    - checkpoints
    - conversion
    - quantisation
    - release_history

rule provenance:
  AIModelMetadata SHOULD preserve model lineage
  where available

rule transformed_model:
  quantised, distilled, converted, or fine-tuned model
  SHOULD preserve relationship to source model

# ---------- VALIDATION ----------
validation:
  require:
    - identifiable_ai_model

  validate_if_present:
    - model_identifier
    - model_family
    - model_type
    - architecture
    - parameters
    - model_version
    - training_metadata
    - capabilities
    - limitations
    - evaluation
    - deployment
    - licence
    - provenance

  reject:
    - contradictory_model_identity
    - invalid_model_version_chain
    - evaluation_without_model_version where version is required
    - unsupported_capability_claim presented_as verified
    - model_family_presented_as exact_model_identity
    - deployment_without_resolvable_model where attribution is mandatory

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE:
  "AI model metadata" ~= "metadata about an AI model"
  "model identifier" ~= "AI model identifier"
  "model family" ~= "AI model family"
  "model architecture" ~= "AI architecture" WHEN describing model structure
  "model lineage" ~= "AI model provenance" WHEN describing derivation
  "model capability" ~= "supported AI capability" WHEN evidence context is preserved

  PRESERVE distinctions:
    model != model_family
    model != model_version
    model_version != architecture
    architecture != parameter_count
    parameter_count != capability
    capability != guaranteed_performance
    training != inference
    base_model != fine_tuned_model
    evaluation_score != universal_quality
    model_status != deployment_status

# ---------- CONFIDENCE ----------
CONFIDENCE:
  explicit_model_identifier:
    score: 1.00

  explicit_model_version:
    score: 1.00

  explicit_architecture_metadata:
    score: 1.00

  traceable_model_lineage:
    score: 0.98

  evaluation_supported_capability:
    score: 0.95

  inferred_model_family:
    score: 0.85

  inferred_architecture:
    score: <= 0.75

  ambiguous_model_identity:
    score: <= 0.60
    action: preserve candidates

# ---------- UPDATE MODEL ----------
UPDATE_MODEL:
  on_model_revision:
    - preserve previous ModelVersion
    - create new version
    - record architecture, weights, or behaviour changes
    - reassess capabilities and limitations
    - update provenance

  on_fine_tuning:
    - preserve base model identity
    - create derived model identity or version
    - record fine-tuning dataset and method
    - update model lineage

  on_evaluation:
    - preserve previous evaluation results
    - attach result to ModelVersion
    - preserve benchmark and dataset context
    - update provenance

  on_deployment:
    - preserve previous deployment state
    - link deployed ModelVersion
    - record environment and configuration
    - update provenance

# ---------- FLOW HASH ----------
FLOW_HASH:
  inputs:
    - ontology
    - model_metadata_entities
    - relationships
    - identity_rules
    - architecture_rules
    - training_rules
    - capability_rules
    - evaluation_rules
    - provenance_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
    - AI model identity model
    - model lifecycle structure
    - model lineage and evaluation model

  operations:
    - identify AI models
    - resolve model identifiers
    - resolve model families and types
    - inspect architecture
    - inspect parameter metadata
    - traverse model versions
    - trace training and fine-tuning
    - evaluate capability metadata
    - inspect limitations
    - compare compatible evaluations
    - resolve deployment state
    - trace model provenance
    - preserve uncertainty

  constraints:
    - do_not_equate_model_family_with_model_identity
    - do_not_equate_parameter_count_with_capability
    - do_not_treat_capability_claim_as guaranteed_performance
    - do_not_detach_evaluation_from_model_version
    - do_not_discard_base_model_lineage
    - preserve_model_version_training_evaluation_and_provenance

# ---------- QUERY MODEL ----------
query:
  input:
    - model_identifier
    - model_name
    - model_family
    - model_type
    - architecture
    - capability
    - model_version
    - evaluation_metric
    - deployment_status
    - provenance

  resolve:
    1. identify AIModel
    2. resolve ModelIdentifier
    3. resolve ModelFamily and ModelType
    4. inspect ModelArchitecture
    5. inspect ParameterMetadata
    6. resolve ModelVersion
    7. trace TrainingMetadata and model lineage
    8. inspect capabilities and limitations
    9. inspect evaluation and deployment
    10. return provenance and confidence

  output:
    - ai_model
    - model_identifier
    - model_family
    - model_type
    - architecture
    - parameters
    - model_version
    - capabilities
    - limitations
    - evaluation
    - deployment
    - provenance
    - confidence

# ---------- INFERENCE ----------
inference:
  IF authoritative ModelIdentifier resolves uniquely
  THEN identify AIModel
  WITH confidence = 1.00

  IF ModelVersion explicitly references predecessor
  THEN construct model version lineage

  IF model is fine-tuned from BaseModel
  THEN infer derived_model relationship
  WITH confidence according_to provenance evidence

  IF capability is supported by compatible evaluation evidence
  THEN associate ModelCapability
  WITH confidence <= 0.95

  IF model identity remains ambiguous
  THEN preserve candidate models
  AND do_not force resolution

# ---------- OUTPUT CONTRACT ----------
output:
  ontology_entity: AIModelMetadata
  model_identity: machine_interpretable
  family_and_type: explicit
  architecture: preserved
  parameters: contextualised
  versions: traversable
  training_lineage: traceable
  capabilities: evidence_qualified
  limitations: preserved
  evaluation: model_version_linked
  deployment: resolvable
  provenance: preserved
  uncertainty: explicit
  semantic_retrieval: enabled

end flow