knowledge_graph.mbt

// 知识图谱与推理（v48.0.0）
// 知识图谱构建、实体链接、关系抽取、知识推理、问答系统

///|
/// 知识图谱构建方法
pub(all) enum KGConstructionMethod {
  RuleBased
  Statistical
  Neural
  Hybrid
  DistantSupervision
  WeakSupervision
  ActiveLearning
  Unknown
} derive(Eq)

///|
/// 实体链接方法
pub(all) enum EntityLinkingMethod {
  StringMatching
  VectorSimilarity
  GraphBased
  Neural
  Collective
  Probabilistic
  Unknown
} derive(Eq)

///|
/// 关系抽取方法
pub(all) enum RelationExtractionMethod {
  PatternBased
  FeatureBased
  Neural
  DistantSupervision
  FewShot
  ZeroShot
  OpenIE
  Unknown
} derive(Eq)

///|
/// 知识推理方法
pub(all) enum KnowledgeReasoningMethod {
  RuleBased
  DescriptionLogic
  EmbeddingBased
  Neural
  GraphNeuralNetwork
  Probabilistic
  Temporal
  Spatial
  Unknown
} derive(Eq)

///|
/// 知识图谱实体
pub(all) struct KGEntity {
  entity_id : String
  entity_name : String
  entity_type : String
  description : String
  properties : Array[String]
  property_values : Array[String]
  num_relations : Int
  confidence : Double
}

///|
/// 知识图谱关系
pub(all) struct KGRelation {
  relation_id : String
  source_entity_id : String
  target_entity_id : String
  relation_type : String
  relation_label : String
  confidence : Double
  evidence : String
  timestamp : Double
}

///|
/// 知识图谱
pub(all) struct KnowledgeGraph {
  entities : Array[KGEntity]
  relations : Array[KGRelation]
  num_entities : Int
  num_relations : Int
  num_entity_types : Int
  num_relation_types : Int
  construction_method : KGConstructionMethod
}

///|
/// 实体链接结果
pub(all) struct EntityLinkingResult {
  mention : String
  candidate_entities : Array[String]
  candidate_scores : Array[Double]
  linked_entity : String
  confidence : Double
  method_type : EntityLinkingMethod
  num_candidates : Int
}

///|
/// 关系抽取结果
pub(all) struct RelationExtractionResult {
  source_entity : String
  target_entity : String
  relation_type : String
  confidence : Double
  method_type : RelationExtractionMethod
  sentence : String
  evidence_span : Array[Int]
}

///|
/// 知识推理结果
pub(all) struct KnowledgeReasoningResult {
  query : String
  answer : String
  confidence : Double
  reasoning_path : Array[String]
  method_type : KnowledgeReasoningMethod
  num_hops : Int
  supporting_facts : Array[String]
}

///|
/// 知识图谱嵌入
pub(all) struct KGEmbedding {
  entity_embeddings : Array[Array[Double]]
  relation_embeddings : Array[Array[Double]]
  embedding_dim : Int
  num_entities : Int
  num_relations : Int
  model_type : String
  training_loss : Double
}

///|
/// 知识图谱配置
pub(all) struct KGConfig {
  construction_method : KGConstructionMethod
  entity_linking_method : EntityLinkingMethod
  relation_extraction_method : RelationExtractionMethod
  reasoning_method : KnowledgeReasoningMethod
  embedding_dim : Int
  confidence_threshold : Double
  max_hops : Int
  use_temporal : Bool
  use_spatial : Bool
}

///|
/// 创建默认知识图谱配置
pub fn create_default_kg_config() -> KGConfig {
  KGConfig::{
    construction_method: KGConstructionMethod::Hybrid,
    entity_linking_method: EntityLinkingMethod::Neural,
    relation_extraction_method: RelationExtractionMethod::Neural,
    reasoning_method: KnowledgeReasoningMethod::EmbeddingBased,
    embedding_dim: 128,
    confidence_threshold: 0.5,
    max_hops: 3,
    use_temporal: false,
    use_spatial: false,
  }
}

///|
/// 创建空知识图谱
pub fn create_empty_knowledge_graph(
  method_type : KGConstructionMethod,
) -> KnowledgeGraph {
  KnowledgeGraph::{
    entities: [],
    relations: [],
    num_entities: 0,
    num_relations: 0,
    num_entity_types: 0,
    num_relation_types: 0,
    construction_method: method_type,
  }
}

///|
/// 添加实体到知识图谱
pub fn add_entity(kg : KnowledgeGraph, entity : KGEntity) -> KnowledgeGraph {
  let new_entities = kg.entities
  new_entities.push(entity)

  KnowledgeGraph::{
    entities: new_entities,
    relations: kg.relations,
    num_entities: kg.num_entities + 1,
    num_relations: kg.num_relations,
    num_entity_types: kg.num_entity_types + 1,
    num_relation_types: kg.num_relation_types,
    construction_method: kg.construction_method,
  }
}

///|
/// 添加关系到知识图谱
pub fn add_relation(
  kg : KnowledgeGraph,
  relation : KGRelation,
) -> KnowledgeGraph {
  let new_relations = kg.relations
  new_relations.push(relation)

  KnowledgeGraph::{
    entities: kg.entities,
    relations: new_relations,
    num_entities: kg.num_entities,
    num_relations: kg.num_relations + 1,
    num_entity_types: kg.num_entity_types,
    num_relation_types: kg.num_relation_types + 1,
    construction_method: kg.construction_method,
  }
}

///|
/// 实体链接（简化版）
pub fn link_entity(
  mention : String,
  kg : KnowledgeGraph,
  config : KGConfig,
) -> EntityLinkingResult {
  let candidate_entities : Array[String] = []
  let candidate_scores : Array[Double] = []

  // 简化的实体链接：基于字符串相似度
  let mut best_entity = ""
  let mut best_score = 0.0

  for entity in kg.entities {
    // 简化的字符串相似度
    let mut common_chars = 0
    let mention_lower = mention
    let name_lower = entity.entity_name

    // 简化的字符串相似度
    if name_lower.contains(mention_lower) || mention_lower.contains(name_lower) {
      common_chars = mention_lower.length()
    }

    let similarity = if mention.length() > 0 {
      common_chars.to_double() / mention.length().to_double()
    } else {
      0.0
    }

    if similarity > config.confidence_threshold {
      candidate_entities.push(entity.entity_id)
      candidate_scores.push(similarity)

      if similarity > best_score {
        best_score = similarity
        best_entity = entity.entity_id
      }
    }
  }

  EntityLinkingResult::{
    mention,
    candidate_entities,
    candidate_scores,
    linked_entity: best_entity,
    confidence: best_score,
    method_type: config.entity_linking_method,
    num_candidates: candidate_entities.length(),
  }
}

///|
/// 关系抽取（简化版）
pub fn extract_relation(
  sentence : String,
  source_entity : String,
  target_entity : String,
  config : KGConfig,
) -> RelationExtractionResult {
  // 简化的关系抽取：基于关键词匹配
  let relation_types = [
    "is_a", "part_of", "located_in", "works_for", "has_property", "caused_by", "similar_to",
    "contradicts",
  ]
  let keywords = [
    "is a", "part of", "located in", "works for", "has", "caused by", "similar to",
    "contradicts",
  ]

  let mut best_relation = "related_to"
  let mut best_confidence = 0.3

  for i in 0..<relation_types.length() {
    if sentence.contains(keywords[i]) {
      best_relation = relation_types[i]
      best_confidence = 0.8
      break
    }
  }

  RelationExtractionResult::{
    source_entity,
    target_entity,
    relation_type: best_relation,
    confidence: best_confidence,
    method_type: config.relation_extraction_method,
    sentence,
    evidence_span: [0, sentence.length()],
  }
}

///|
/// 知识推理（简化版）
pub fn reason_over_kg(
  query : String,
  kg : KnowledgeGraph,
  config : KGConfig,
) -> KnowledgeReasoningResult {
  let reasoning_path : Array[String] = []
  let supporting_facts : Array[String] = []

  // 简化的知识推理：基于路径搜索
  let mut answer = "unknown"
  let mut confidence = 0.3
  let mut num_hops = 0

  // 查找查询中的实体
  for entity in kg.entities {
    if query.contains(entity.entity_name) {
      reasoning_path.push(entity.entity_id)

      // 查找相关关系
      for relation in kg.relations {
        if relation.source_entity_id == entity.entity_id {
          reasoning_path.push(relation.relation_type)
          reasoning_path.push(relation.target_entity_id)
          supporting_facts.push(relation.relation_label)
          num_hops += 1

          if num_hops >= config.max_hops {
            break
          }
        }
      }

      if num_hops > 0 {
        answer = "found " + num_hops.to_string() + " relations"
        confidence = 0.7
      }
      break
    }
  }

  KnowledgeReasoningResult::{
    query,
    answer,
    confidence,
    reasoning_path,
    method_type: config.reasoning_method,
    num_hops,
    supporting_facts,
  }
}

///|
/// 训练知识图谱嵌入（简化版）
pub fn train_kg_embedding(
  kg : KnowledgeGraph,
  config : KGConfig,
) -> KGEmbedding {
  let entity_embeddings : Array[Array[Double]] = []
  let relation_embeddings : Array[Array[Double]] = []

  let mut state = 42
  // 初始化实体嵌入
  for _ in 0..<kg.num_entities {
    let embedding : Array[Double] = []
    for _ in 0..<config.embedding_dim {
      state = (state * 11035 + 12345) % 1000000
      embedding.push((state % 1000).to_double() / 1000.0 - 0.5)
    }
    entity_embeddings.push(embedding)
  }

  // 初始化关系嵌入
  for _ in 0..<kg.num_relation_types {
    let embedding : Array[Double] = []
    for _ in 0..<config.embedding_dim {
      state = (state * 11035 + 12345) % 1000000
      embedding.push((state % 1000).to_double() / 1000.0 - 0.5)
    }
    relation_embeddings.push(embedding)
  }

  KGEmbedding::{
    entity_embeddings,
    relation_embeddings,
    embedding_dim: config.embedding_dim,
    num_entities: kg.num_entities,
    num_relations: kg.num_relation_types,
    model_type: "TransE",
    training_loss: 0.1,
  }
}

///|
/// 计算知识图谱统计
pub fn compute_kg_statistics(kg : KnowledgeGraph) -> (Double, Double, Double) {
  // 计算平均度、密度、聚类系数
  let total_degree = kg.num_relations * 2
  let avg_degree = if kg.num_entities > 0 {
    total_degree.to_double() / kg.num_entities.to_double()
  } else {
    0.0
  }

  let max_possible_relations = if kg.num_entities > 1 {
    kg.num_entities * (kg.num_entities - 1) / 2
  } else {
    1
  }
  let density = kg.num_relations.to_double() /
    max_possible_relations.to_double()

  // 简化的聚类系数
  let clustering_coefficient = 0.3

  (avg_degree, density, clustering_coefficient)
}

///|
/// 生成知识图谱报告
pub fn knowledge_graph_report_to_string(
  kg : KnowledgeGraph,
  config : KGConfig,
  embedding : KGEmbedding,
) -> String {
  let stats = compute_kg_statistics(kg)
  let avg_degree = stats.0
  let density = stats.1
  let clustering = stats.2

  let mut report = "## 知识图谱与推理报告\n\n"

  report = report + "### 知识图谱统计\n\n"
  report = report + "| 指标 | 值 |\n|------|------|\n"
  report = report + "| 实体数 | " + kg.num_entities.to_string() + " |\n"
  report = report + "| 关系数 | " + kg.num_relations.to_string() + " |\n"
  report = report +
    "| 实体类型数 | " +
    kg.num_entity_types.to_string() +
    " |\n"
  report = report +
    "| 关系类型数 | " +
    kg.num_relation_types.to_string() +
    " |\n"
  report = report + "| 平均度 | " + avg_degree.to_string() + " |\n"
  report = report + "| 密度 | " + density.to_string() + " |\n"
  report = report + "| 聚类系数 | " + clustering.to_string() + " |\n"

  report = report + "\n### 构建配置\n\n"
  report = report + "| 指标 | 值 |\n|------|------|\n"
  report = report +
    "| 构建方法 | " +
    (match kg.construction_method {
      KGConstructionMethod::RuleBased => "基于规则"
      KGConstructionMethod::Statistical => "统计"
      KGConstructionMethod::Neural => "神经"
      KGConstructionMethod::Hybrid => "混合"
      _ => "未知"
    }) +
    " |\n"
  report = report +
    "| 实体链接方法 | " +
    (match config.entity_linking_method {
      EntityLinkingMethod::StringMatching => "字符串匹配"
      EntityLinkingMethod::VectorSimilarity => "向量相似度"
      EntityLinkingMethod::Neural => "神经"
      _ => "未知"
    }) +
    " |\n"
  report = report +
    "| 关系抽取方法 | " +
    (match config.relation_extraction_method {
      RelationExtractionMethod::PatternBased => "基于模式"
      RelationExtractionMethod::Neural => "神经"
      RelationExtractionMethod::OpenIE => "开放IE"
      _ => "未知"
    }) +
    " |\n"
  report = report +
    "| 推理方法 | " +
    (match config.reasoning_method {
      KnowledgeReasoningMethod::RuleBased => "基于规则"
      KnowledgeReasoningMethod::EmbeddingBased => "基于嵌入"
      KnowledgeReasoningMethod::Neural => "神经"
      KnowledgeReasoningMethod::GraphNeuralNetwork => "图神经网络"
      _ => "未知"
    }) +
    " |\n"
  report = report +
    "| 嵌入维度 | " +
    config.embedding_dim.to_string() +
    " |\n"
  report = report +
    "| 置信度阈值 | " +
    config.confidence_threshold.to_string() +
    " |\n"
  report = report + "| 最大跳数 | " + config.max_hops.to_string() + " |\n"

  report = report + "\n### 嵌入训练\n\n"
  report = report + "| 指标 | 值 |\n|------|------|\n"
  report = report + "| 模型类型 | " + embedding.model_type + " |\n"
  report = report +
    "| 实体嵌入数 | " +
    embedding.num_entities.to_string() +
    " |\n"
  report = report +
    "| 关系嵌入数 | " +
    embedding.num_relations.to_string() +
    " |\n"
  report = report +
    "| 嵌入维度 | " +
    embedding.embedding_dim.to_string() +
    " |\n"
  report = report +
    "| 训练损失 | " +
    embedding.training_loss.to_string() +
    " |\n"

  report
}
src\process\knowledge_graph\knowledge_graph.mbt

83.00%
