首页 理论 架构 工程 规划 文档 白皮书 著作 研究 案例 下载 博客 关于 联系 开始使用 →

第十七章 知识构建与知识组织

第十七章 知识构建与知识组织

  1. 知识信息的获取与处理

  2. 知识元素的提取与定义

  3. 知识属性、关系和方法的组织

  4. 知识结构的组合与关联

  5. 知识结构的保存、检索与更新

第十七章 知识构建与知识组织

知识构建是WSaiOS智能控制后台将需求信息转化为知识结构的核心工程过程。前面的动态语义需求处理解决了不同需求中的语义内容识别、语义单元确认和动态组织问题,动态语义元素与概念定义管理解决了对象、属性、关系及概念定义的创建、修改和管理问题。在此基础上,还需要进一步解决如何将获取的信息转化为具有明确含义的知识元素,如何组织知识元素之间的属性、关系和方法,以及如何将多个知识元素组合为能够被后台解析、匹配和调用的完整知识结构。

知识构建并不是把收集到的信息直接存入数据库,也不是按照固定字段将信息整理成若干记录。信息只有经过识别、处理、定义和结构组织,才能形成具有明确对象、属性、关系、状态和方法的知识内容。不同需求形成的知识结构也不应当受到固定业务模板的限制,而应当根据实际问题和应用对象动态建立。

WSaiOS智能控制后台需要根据需求确定知识构建目标,获取与目标相关的信息,对信息进行处理和分析,识别其中的对象、属性、关系及方法,再依据已经确认的概念定义组织知识元素。随后,后台根据知识元素之间的结构关系形成完整知识结构,并对结构进行完整性检查、保存、检索和动态更新。

本章围绕知识信息获取与处理、知识元素提取与定义、知识属性关系和方法组织、知识结构组合与关联,以及知识结构保存检索与更新展开工程研究,建立从原始信息到结构化知识的完整工程过程。

17.1 知识信息的获取与处理

知识构建首先需要获取与当前需求有关的信息。信息获取不是简单地收集越多越好,而是围绕需求所涉及的对象、问题和预期能力,确定需要获取什么信息、从什么来源获取,以及获取的信息需要经过哪些处理才能用于知识构建。

WSaiOS智能控制后台在接收到一项需求后,首先需要根据需求结构确定知识构建范围。需求可能涉及一个对象,也可能涉及多个对象之间的关系;可能需要建立新的知识结构,也可能只需要扩展已有结构中的某些属性、方法或关系。因此,信息获取必须与需求目标保持关联,不能脱离需求建立无边界的信息集合。

例如,某项工业控制需求要求建立输送设备的运行管理能力。后台需要获取与输送设备有关的对象信息、设备属性、运行状态、设备之间的连接关系、运行条件以及控制操作等内容。如果当前知识库中已经存在输送设备的部分知识定义,就应当先检索已有知识,确定哪些内容可以直接复用,哪些内容需要补充,哪些内容需要重新定义。

这意味着知识信息获取必须同时处理外部信息和系统已有知识。外部信息可以来自用户提供的资料、设备技术文档、业务数据、接口数据、人工录入内容以及经过授权的信息来源;系统内部信息则包括已经建立的语义定义、知识元素、知识结构和历史版本。

不同来源的信息在内容完整性、可信程度和表达形式上存在差异。用户输入可能使用自然语言,设备接口可能返回结构化数据,技术文档可能包含表格和说明文字,历史知识记录则可能已经具有一定的结构。因此,后台需要先识别信息来源和内容形式,再进入统一的信息处理过程。

信息获取程序应当将原始信息与后续处理结果分开保存。原始信息用于保留来源依据,处理结果用于后续知识构建。不能因为信息经过一次解析,就直接丢弃原始内容。否则,当知识定义出现错误或需要重新构建时,后台将无法追溯原始依据。

可以将原始知识信息设计为以下数据结构:

{
    "information_id": "info_000001",
    "requirement_id": "req_000001",
    "source_type": "document",
    "source_id": "source_000001",
    "content_type": "text",
    "content": "输送设备由电机驱动,运行过程中需要监测运行速度和设备温度。",
    "acquired_at": "2026-11-15 10:00:00",
    "processing_status": "pending"
}

这里的requirement_id用于建立信息与当前需求之间的关联,source_type用于说明信息来源类型,content_type用于标识信息表达形式,processing_status用于记录信息处理状态。

信息获取完成后,后台需要进行信息预处理。预处理的目的不是直接生成知识,而是将不同来源、不同形式的信息整理成能够进一步分析的内容。

对于文本信息,需要识别其中的有效语义内容,处理明显的格式噪声、重复内容和无关内容,并保留必要的上下文。对于结构化数据,需要识别字段名称、字段值、数据类型及字段之间的对应关系。对于设备接口信息,需要明确数据来源、接口含义、采集时间和数据单位。对于用户提供的人工定义,需要保留定义者、适用范围和确认状态。

信息处理还需要进行重复识别。不同来源可能重复描述同一个对象或属性,也可能使用不同名称表达同一概念。后台不能仅仅因为两条信息的文字相似就将其合并,而应当根据语义定义、所属对象、适用范围和上下文进行判断。

例如,“设备温度”“运行温度”和“设备工作温度”可能指向同一属性,也可能分别表示设备不同位置或不同运行条件下的温度。系统需要结合定义和来源进行识别。如果能够确认它们表达同一个概念,可以形成统一的知识元素,并保留不同名称作为别名或来源表达;如果含义不同,则应当分别建立元素。

信息处理还包括有效性检查。某些信息可能缺少必要属性,某些数据可能超出定义范围,某些描述可能存在矛盾。后台需要将这些问题标记出来,不能为了完成知识构建而自动填补未经确认的内容。

在程序组织上,可以建立知识信息获取与处理目录:

app/
└── Intelligence/                              # WSaiOS智能控制后台的智能处理程序
    └── Knowledge/                             # 知识结构化与知识能力构建程序
        └── Construction/                      # 知识构建工程程序
            └── Information/                   # 知识信息获取与处理程序
                ├── KnowledgeInformationManager.php    # 统一管理知识信息获取与处理流程
                ├── InformationCollector.php            # 从用户输入、文件和授权接口获取原始信息
                ├── InformationSourceManager.php        # 管理信息来源及来源关联
                ├── InformationFormatRecognizer.php     # 识别文本、结构化数据和其他信息形式
                ├── InformationPreprocessor.php         # 对原始信息进行清理和规范化处理
                ├── InformationDuplicateChecker.php     # 识别重复信息并保留来源依据
                ├── InformationRelevanceAnalyzer.php    # 判断信息与当前需求及知识构建目标的关联程度
                ├── InformationCompletenessChecker.php  # 检查信息内容是否满足后续构建要求
                ├── InformationConflictDetector.php     # 识别不同来源信息之间的矛盾
                ├── InformationSetBuilder.php            # 将处理后的信息组织为知识构建信息集合
                └── InformationRepository.php            # 负责原始信息和处理结果的数据保存与读取

KnowledgeInformationManager.php负责统一调度信息获取和处理流程。InformationCollector.php根据当前需求确定信息获取方式,InformationSourceManager.php记录来源信息,InformationFormatRecognizer.php识别不同的信息表达形式,InformationPreprocessor.php处理原始内容。经过处理的信息由重复识别、关联分析、完整性检查和冲突检查程序进一步处理,最终由InformationSetBuilder.php形成供知识元素提取使用的信息集合。

这些程序不能各自独立形成信息处理结果,而应当通过统一的数据结构传递处理状态和来源信息。

信息处理的基本调用过程可以设计为:

当前需求及知识构建目标
          ↓
KnowledgeInformationManager
          ↓
InformationCollector
          ↓
原始信息保存
          ↓
InformationFormatRecognizer
          ↓
InformationPreprocessor
          ↓
重复信息与关联性检查
          ↓
完整性与冲突检查
          ↓
InformationSetBuilder
          ↓
形成知识构建信息集合

其中,知识构建信息集合不是最终知识结构,而是后续知识元素提取的输入。它应当包含原始信息引用、处理后的内容、信息来源、关联需求和当前处理状态。

可以通过PHP程序组织这一过程:

<?php

class KnowledgeInformationManager
{
    private $collector;
    private $preprocessor;
    private $analyzer;
    private $setBuilder;

    public function __construct(
        $collector,
        $preprocessor,
        $analyzer,
        $setBuilder
    ) {
        $this->collector = $collector;
        $this->preprocessor = $preprocessor;
        $this->analyzer = $analyzer;
        $this->setBuilder = $setBuilder;
    }

    public function buildInformationSet($requirement)
    {
        $information = $this->collector->collect(
            $requirement
        );

        $processed = $this->preprocessor->process(
            $information
        );

        $analysis = $this->analyzer->analyze(
            $processed,
            $requirement
        );

        return $this->setBuilder->build(
            $processed,
            $analysis
        );
    }
}

该程序体现了知识信息获取和处理的统一调度关系。具体信息采集、预处理和分析过程由独立程序完成。实际工程还需要在各阶段增加错误处理、来源记录、处理状态管理和数据事务控制。

经过这一过程,后台获得的是与当前需求相关、具有来源依据并经过初步处理的信息集合。下一步才是从这些信息中提取知识元素,确定每个元素所表达的实际含义。

17.2 知识元素的提取与定义

知识信息经过处理后,需要从中识别能够构成知识结构的基本元素。知识元素提取不是简单地从文本中抽取名词和动词,而是根据实际信息含义识别对象、属性、关系和方法,并确定它们在当前知识结构中的位置。

同一个词语在不同场景中可能具有不同的结构意义。例如,“温度”可以是设备属性,也可以是环境对象的属性;“启动”可以表示一个操作方法,也可以出现在描述设备当前状态的语句中。仅凭词语本身无法确定其知识元素类型,必须结合所属对象、上下文和概念定义进行判断。

因此,知识元素提取需要以语义定义为基础。第十六章和第十七章前一阶段建立的动态语义处理机制,为本章提供了语义单元和概念定义依据。知识构建程序根据当前信息集合识别候选元素,再与已有语义元素及概念定义进行匹配,确定元素是否已经存在。

对于能够匹配已有定义的信息,应当优先复用已有元素。对于无法匹配的信息,则需要形成新的元素候选,并判断其是否具有独立的概念含义。只有经过定义确认的元素,才能进入正式知识结构。

知识元素的提取首先需要识别对象。对象是知识结构中需要描述、分析或操作的主体。它可以是物理设备、人员、组织、软件系统、业务事项,也可以是抽象概念。对象识别需要确定对象名称、概念定义、对象类型和适用范围。

例如,在输送设备运行管理需求中,“输送设备”“驱动电机”“温度传感器”都可以成为对象元素。它们之间具有不同的属性和关系,不能将其全部当作普通文本字段处理。

对象识别完成后,需要提取对象属性。属性用于描述对象的特征、状态和取值。属性提取需要确定属性名称、属性定义、所属对象、数据类型和必要的取值约束。

例如,“运行速度”属于输送设备的属性,“额定功率”可以属于驱动电机的属性,“测量温度”可以属于温度传感器的属性。属性归属必须根据实际定义确定,不能仅仅根据信息中词语出现的先后顺序建立。

关系提取则需要识别对象之间或元素之间的关联。关系可以表示组成、连接、驱动、检测、控制、从属、依赖等不同含义。关系必须具有明确的关系定义,并能够确定关系两端的元素。

方法提取需要识别知识结构中可以执行的操作。方法不是普通动作词语的集合,而是具有明确操作对象、输入条件、处理规则和预期结果的操作定义。例如,“检查设备温度”需要明确检查哪个设备的哪个温度属性,采用什么判断条件,以及检查结果如何返回。

知识元素提取后,需要进行元素定义确认。定义确认应当区分已有定义匹配、新元素候选和含义不明确的内容。对于已有定义能够准确覆盖的信息,可以建立引用;对于新的明确概念,可以进入定义创建流程;对于存在多种解释的信息,应当保留为待确认候选。

可以将提取结果组织为以下结构:

{
    "requirement_id": "req_000001",
    "knowledge_elements": [
        {
            "element_name": "输送设备",
            "element_type": "object",
            "definition_id": "def_000101",
            "element_status": "confirmed"
        },
        {
            "element_name": "运行速度",
            "element_type": "attribute",
            "owner_element": "输送设备",
            "definition_id": "def_000102",
            "element_status": "confirmed"
        },
        {
            "element_name": "驱动电机",
            "element_type": "object",
            "definition_id": "def_000103",
            "element_status": "confirmed"
        },
        {
            "element_name": "驱动",
            "element_type": "relation",
            "source_element": "驱动电机",
            "target_element": "输送设备",
            "element_status": "pending_confirmation"
        },
        {
            "element_name": "检查运行速度",
            "element_type": "method",
            "owner_element": "输送设备",
            "element_status": "pending_definition"
        }
    ]
}

这里的结构用于表达知识元素提取结果。实际保存时,应当使用系统内部的元素标识和定义版本标识,不能仅依赖名称建立关联。

知识元素提取程序可以组织为:

app/
└── Intelligence/                              # 智能控制后台的智能处理程序
    └── Knowledge/                             # 知识结构化与知识能力构建程序
        └── Construction/                      # 知识构建工程程序
            └── Extraction/                    # 知识元素提取与定义程序
                ├── KnowledgeElementExtractor.php       # 统一调度知识元素提取过程
                ├── ObjectElementExtractor.php          # 从信息集合中识别对象元素
                ├── AttributeElementExtractor.php       # 识别属性元素及其所属对象
                ├── RelationElementExtractor.php        # 识别对象和元素之间的关系
                ├── MethodElementExtractor.php          # 识别具有明确操作含义的方法元素
                ├── ElementDefinitionMatcher.php        # 将候选元素与已有概念定义进行匹配
                ├── ElementCandidateBuilder.php         # 建立尚未确认的知识元素候选
                ├── ElementDefinitionResolver.php       # 确定候选元素应引用已有定义还是建立新定义
                ├── ElementExtractionValidator.php      # 检查提取结果和元素定义的完整性
                └── KnowledgeElementRepository.php     # 保存和读取知识元素及提取结果

KnowledgeElementExtractor.php是知识元素提取的统一入口。它根据处理后的信息集合调用对象、属性、关系和方法提取程序。ElementDefinitionMatcher.php负责与已有概念定义匹配,ElementCandidateBuilder.php负责建立候选元素,ElementDefinitionResolver.php根据匹配结果确定定义处理方式,最终由验证程序检查提取结果。

知识元素提取程序不能把所有识别结果直接写入正式知识库。候选元素与正式知识元素之间必须存在明确的确认边界。只有经过定义匹配或新定义确认的元素,才能被正式知识结构引用。

可以建立知识元素基础数据表:

CREATE TABLE knowledge_elements (
    id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
    element_code VARCHAR(120) NOT NULL,
    element_name VARCHAR(200) NOT NULL,
    element_type VARCHAR(50) NOT NULL,
    definition_id BIGINT UNSIGNED DEFAULT NULL,
    definition_version INT DEFAULT NULL,
    source_requirement_id BIGINT UNSIGNED DEFAULT NULL,
    element_status VARCHAR(30) NOT NULL,
    created_at DATETIME NOT NULL,
    updated_at DATETIME DEFAULT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_element_code (element_code),
    KEY idx_element_type (element_type),
    KEY idx_definition (definition_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

知识元素表保存元素身份、类型、定义引用和来源需求等信息。概念定义内容仍由定义管理体系维护,知识构建过程通过定义标识引用定义,不应在多个知识结构中重复保存不同版本的定义文本。

知识元素提取完成后,后台得到一组具有明确类型和定义依据的元素。接下来需要组织这些元素的属性、关系和方法,使它们能够形成具有内部逻辑的知识结构。

17.3 知识属性、关系和方法的组织

知识元素提取解决了知识结构中有哪些元素的问题,但仅仅获得一组对象、属性、关系和方法,还不能形成完整知识。知识的结构意义来自元素之间的组织关系。对象需要通过属性描述自身特征,通过关系与其他对象建立联系,并通过方法形成可执行的操作。

因此,知识组织必须解决元素归属、属性组织、关系方向、方法依赖和结构约束等问题。

对象与属性的组织首先需要建立明确的归属关系。一个对象可以具有多个属性,一个属性也可能在不同对象中被引用。但属性的引用不代表其定义可以随意改变。对于同一个概念属性,多个对象可以引用同一属性定义,同时通过不同的属性实例保存各自的实际值。

例如,输送设备和包装设备都可能具有运行速度属性。两个对象可以引用相同的“运行速度”概念定义,但各自具有不同的属性值和运行状态。后台必须区分属性定义与属性实例,不能因为两个对象使用同一个属性定义,就将它们的属性值合并。

对象与属性的组织结构可以表示为:

{
    "object_element": {
        "element_id": "ke_000001",
        "element_name": "输送设备"
    },
    "attributes": [
        {
            "attribute_id": "ke_000002",
            "attribute_name": "运行速度",
            "definition_id": "def_000102",
            "data_type": "number",
            "unit": "m/s"
        },
        {
            "attribute_id": "ke_000003",
            "attribute_name": "运行状态",
            "definition_id": "def_000104",
            "data_type": "defined_value"
        }
    ]
}

这里的attributes表示对象所具有的属性定义引用,不是设备当前运行时的属性值。实际运行对象的属性值需要保存在对象实例或状态数据中。知识结构负责说明对象具有哪些属性以及属性含义,运行数据负责记录对象在具体时间和环境下的实际状态。

关系组织需要建立明确的关系定义和关系实例。关系定义说明某种关系具有什么含义、方向和约束;关系实例则说明具体哪些对象之间实际存在这种关系。

例如,“驱动”是一种关系定义,表示一个对象为另一个对象提供驱动力。某台驱动电机与某台输送设备之间存在驱动关系,则需要建立具体的关系实例。这样,同一种关系定义可以被不同设备实例复用。

关系结构可以表示为:

{
    "relation_id": "kr_000001",
    "relation_definition": "驱动",
    "source_element_id": "ke_000010",
    "target_element_id": "ke_000001",
    "direction": "source_to_target",
    "conditions": {
        "relation_status": "active"
    }
}

关系方向必须由定义决定,不能在查询或执行时任意交换起点和终点。对于具有双向含义的关系,也需要在定义中明确是否允许双向使用,不能因为两个对象存在关联就默认关系可以互换。

关系组织还需要支持多层关系和关系约束。例如,驱动电机与输送设备之间存在驱动关系,输送设备与温度传感器之间存在检测关系,多个输送设备之间还可能存在连接关系。后台需要将这些关系组织成能够进行结构解析的关联网络。

关系组织不能只保存孤立的关系记录,还必须检查关系两端的元素是否存在,关系定义是否有效,以及关系是否符合所属知识结构的约束。

方法组织则需要将知识结构中的操作定义与对象、属性和关系建立关联。方法不能只保存一个名称或一段描述,而应当明确其操作目标、输入参数、执行条件、处理过程和输出结果。

例如,“检查运行速度”方法需要引用输送设备对象及其运行速度属性,并根据需求中的速度范围进行比较。该方法的输入可以是设备实例和当前运行速度,输出可以是符合条件、不符合条件或数据不足等判断结果。

方法定义可以设计为:

{
    "method_id": "km_000001",
    "method_name": "检查运行速度",
    "owner_element_id": "ke_000001",
    "input": [
        {
            "name": "object_instance",
            "type": "object"
        },
        {
            "name": "current_speed",
            "type": "number"
        }
    ],
    "operation": "compare",
    "conditions": {
        "required_attribute": "ke_000002"
    },
    "output": {
        "type": "judgment_result"
    }
}

该结构表达方法与对象、属性和操作类型之间的关联。具体的比较操作由方法实现程序执行,方法定义本身负责说明操作依据和调用条件。

在WSaiOS结构智能体系中,方法是操作,不等同于能力。知识结构中的方法定义为后续程序调用提供操作依据,但一个完整的知识能力还需要将知识结构、方法实现、运行条件和处理规则组织起来,并经过验证才能形成可使用的能力。

因此,知识构建阶段应当区分方法定义和方法实现。方法定义说明需要执行什么操作以及操作依据,方法实现负责具体执行过程。这样,同一方法定义可以根据运行环境调用不同的程序实现,而不会因为程序代码变化就破坏知识结构中的方法含义。

属性、关系和方法的组织程序可以设计为:

app/
└── Intelligence/                              # WSaiOS智能控制后台的智能处理程序
    └── Knowledge/                             # 知识结构化与知识能力构建程序
        └── Construction/                      # 知识构建工程程序
            └── Organization/                  # 知识元素组织程序
                ├── KnowledgeOrganizer.php              # 统一调度知识元素的结构组织
                ├── ObjectAttributeOrganizer.php        # 建立对象与属性之间的归属和引用关系
                ├── RelationOrganizer.php               # 建立关系定义、关系实例及关系方向
                ├── MethodOrganizer.php                  # 组织方法定义及其对象、属性依赖
                ├── MethodDependencyAnalyzer.php        # 分析方法执行所依赖的知识元素
                ├── ElementOwnershipResolver.php        # 确定属性、方法等元素的所属对象
                ├── RelationConstraintChecker.php       # 检查关系两端元素和关系约束
                ├── KnowledgeOrganizationValidator.php # 验证元素组织结果的完整性
                └── KnowledgeOrganizationRepository.php # 保存和读取知识元素组织关系

KnowledgeOrganizer.php负责统一组织知识元素,属性组织程序建立对象与属性的关系,关系组织程序建立对象之间的结构关联,方法组织程序建立方法与对象及属性之间的依赖。MethodDependencyAnalyzer.php负责分析方法运行需要哪些知识元素,KnowledgeOrganizationValidator.php负责检查整个组织结果是否满足结构要求。

数据库中可以通过独立关系表保存对象、属性和关系之间的组织关系:

CREATE TABLE knowledge_element_relations (
    id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
    structure_id BIGINT UNSIGNED NOT NULL,
    source_element_id BIGINT UNSIGNED NOT NULL,
    target_element_id BIGINT UNSIGNED NOT NULL,
    relation_definition_id BIGINT UNSIGNED NOT NULL,
    relation_direction VARCHAR(30) DEFAULT NULL,
    relation_status VARCHAR(30) NOT NULL,
    created_at DATETIME NOT NULL,
    PRIMARY KEY (id),
    KEY idx_structure (structure_id),
    KEY idx_source (source_element_id),
    KEY idx_target (target_element_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

方法定义与知识元素之间的依赖关系可以单独保存:

CREATE TABLE knowledge_method_dependencies (
    id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
    method_element_id BIGINT UNSIGNED NOT NULL,
    dependent_element_id BIGINT UNSIGNED NOT NULL,
    dependency_type VARCHAR(50) NOT NULL,
    required_flag TINYINT(1) NOT NULL DEFAULT 1,
    created_at DATETIME NOT NULL,
    PRIMARY KEY (id),
    KEY idx_method (method_element_id),
    KEY idx_dependent (dependent_element_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

通过独立的数据表,知识元素之间的归属、关系和方法依赖可以分别管理。一个元素可以被多个结构引用,一个方法也可以依赖多个属性和关系,而不需要将所有关联信息固定写入某个对象的数据字段。

知识元素组织完成后,后台就能够明确每个对象具有什么属性、对象之间存在什么关系,以及对象能够调用哪些方法。这些内容共同构成知识结构组合的基础。

17.4 知识结构的组合与关联

知识结构不是多个知识元素的简单集合,而是根据需求目标和对象关系形成的整体结构。对象、属性、关系和方法虽然已经完成提取和组织,但还需要进一步确定它们之间的组合方式、结构边界和相互依赖关系。

知识结构组合首先需要确定结构的核心对象。一个需求可能涉及多个对象,但并不是所有对象都处于相同的结构层次。有些对象是主要处理对象,有些对象是组成部分,有些对象是关联对象,还有些对象只是运行环境中的外部对象。

例如,在输送设备运行管理中,输送设备可以作为核心对象,驱动电机和温度传感器作为关联对象,运行速度和运行状态作为输送设备的属性。后台需要根据需求确定这些对象的组织关系,而不是将所有元素平铺保存。

结构组合需要明确对象之间的关系层次。一个对象可能包含多个组成对象,也可能与其他对象形成连接、驱动或检测关系。不同关系具有不同的结构意义,必须按照关系定义进行组织。

例如,输送设备由机架、输送带和驱动电机等部分组成,这属于组成关系;驱动电机向输送设备提供动力,属于驱动关系;温度传感器获取设备温度信息,属于检测关系。这些关系不能全部归并为一般的“关联”,否则后续结构解析程序将无法准确理解不同关系的含义。

知识结构组合还需要考虑方法与对象之间的关联。一个方法可能作用于单个对象,也可能需要同时访问多个对象和关系。例如,检查输送设备运行状态的方法,需要读取输送设备的运行状态属性,也可能需要读取驱动电机状态和传感器检测结果。此时,方法的依赖关系必须纳入知识结构,而不是仅仅在程序代码中隐含。

知识结构还需要具有明确的结构边界。某个需求形成的知识结构可以引用已有公共知识元素,但不应当将所有被引用的知识都复制到当前结构中。结构引用应当保留原始元素身份、定义版本和来源关系,以便后续进行统一维护。

例如,多个设备管理知识结构都需要引用“运行速度”属性定义。它们可以共同引用同一个属性定义,但各自保留独立的结构关系和对象实例信息。这样,公共知识元素可以复用,而不同知识结构之间仍然保持各自的完整性。

知识结构可以采用分层组织方式。上层结构描述当前需求涉及的整体对象及其主要关系,中间层组织对象属性和对象之间的关联,下层组织具体方法、方法依赖和执行条件。分层并不意味着知识只能按照固定层数存储,而是为了便于结构解析、引用管理和后续扩展。

可以将知识结构定义为:

{
    "structure_id": "ks_000001",
    "structure_name": "输送设备运行管理结构",
    "requirement_id": "req_000001",
    "structure_version": 1,
    "root_element_id": "ke_000001",
    "elements": [
        {
            "element_id": "ke_000001",
            "element_role": "root_object"
        },
        {
            "element_id": "ke_000010",
            "element_role": "related_object"
        },
        {
            "element_id": "ke_000020",
            "element_role": "related_object"
        }
    ],
    "relations": [
        {
            "relation_id": "kr_000001",
            "source_element_id": "ke_000010",
            "target_element_id": "ke_000001"
        },
        {
            "relation_id": "kr_000002",
            "source_element_id": "ke_000020",
            "target_element_id": "ke_000001"
        }
    ],
    "methods": [
        {
            "method_element_id": "km_000001",
            "owner_element_id": "ke_000001"
        }
    ],
    "structure_status": "pending_validation"
}

这里的structure_id用于标识知识结构,root_element_id表示结构的核心对象,elements记录结构引用的知识元素,relations记录结构内部关系,methods记录结构中的方法引用。

结构组合完成后,还需要处理不同知识结构之间的关联。一个新需求可能只需要引用已有知识结构中的一部分内容,也可能需要将多个知识结构组合成一个更大的知识结构。

例如,输送设备运行管理结构可以引用设备基础结构、运行状态结构和传感器检测结构。三个结构分别维护自己的对象、属性和方法,通过明确的结构引用建立关联。这样既可以保持已有知识结构的独立性,也可以形成面向新需求的综合知识结构。

知识结构之间的关联需要明确关联方式。一个结构可以引用另一个结构的完整内容,也可以只引用其中的部分元素;可以建立上下位结构关系,也可以建立依赖关系或组合关系。不同关联方式需要具有明确的定义,不能全部采用简单的结构编号引用。

结构组合还必须检查循环依赖和引用冲突。如果结构A依赖结构B,而结构B又依赖结构A,就可能形成无法正确解析的循环依赖。某些情况下,结构之间的双向关系是合理的,但结构的构建依赖不能因此无限循环。后台需要区分对象关系与构建依赖,不能将二者混为一谈。

如果多个知识结构引用了不同版本的同一个概念定义,后台也需要进行版本兼容检查。对于能够兼容的版本,可以继续引用;对于定义含义已经发生变化的版本,需要判断是否需要重新验证结构。

知识结构组合与关联程序可以组织为:

app/
└── Intelligence/                              # WSaiOS智能控制后台的智能处理程序
    └── Knowledge/                             # 知识结构化与知识能力构建程序
        └── Construction/                      # 知识构建工程程序
            └── Structure/                     # 知识结构组合与关联程序
                ├── KnowledgeStructureBuilder.php      # 根据知识元素和组织关系建立知识结构
                ├── StructureElementAssembler.php      # 将对象、属性、关系和方法组合为结构内容
                ├── StructureRelationAssembler.php     # 组织结构内部及跨对象关系
                ├── StructureMethodAssembler.php       # 将方法定义及其依赖组织到结构中
                ├── StructureReferenceManager.php      # 管理结构对已有知识元素和知识结构的引用
                ├── StructureDependencyAnalyzer.php    # 分析结构之间的构建依赖和调用依赖
                ├── StructureCycleChecker.php           # 检查结构依赖中的循环引用
                ├── StructureCompatibilityChecker.php  # 检查不同定义版本和结构之间的兼容性
                ├── StructureIntegrityValidator.php     # 检查结构元素、关系和方法的整体完整性
                └── KnowledgeStructureRepository.php   # 保存和读取知识结构及其组合关系

KnowledgeStructureBuilder.php负责组织整个结构构建过程。StructureElementAssembler.php组合对象、属性等元素,StructureRelationAssembler.php建立结构内部关系,StructureMethodAssembler.php将方法及其依赖纳入结构。StructureReferenceManager.php负责引用已有知识,StructureDependencyAnalyzer.php分析结构依赖,循环检查和兼容性检查程序负责排除不合理的结构组合。

知识结构组合程序的主要调用关系可以设计为:

已确认的知识元素
          ↓
知识元素组织结果
          ↓
KnowledgeStructureBuilder
          ↓
确定核心对象
          ↓
组合对象、属性和关系
          ↓
组织方法及方法依赖
          ↓
建立已有知识结构引用
          ↓
分析结构依赖与兼容性
          ↓
检查循环引用
          ↓
整体结构完整性验证
          ↓
形成待验证知识结构

结构组合完成后,还需要进行知识结构完整性验证。验证内容包括核心对象是否明确、元素定义是否有效、属性是否具有正确归属、关系两端是否存在、方法依赖是否完整、结构引用是否有效,以及不同定义版本之间是否兼容。

结构完整性验证通过,只说明结构在组织层面满足基本要求,并不代表其中所有方法已经具备可执行能力。方法实现和能力验证仍然需要进入后续知识能力构建工程。

17.5 知识结构的保存、检索与更新

知识结构完成组合和完整性检查后,需要进入统一的知识存储体系。知识存储不仅要保存结构内容,还必须保存结构所引用的元素、定义版本、关系、方法和来源信息,使知识结构能够被后台持续检索、解析、匹配和更新。

知识结构存储首先需要区分结构定义和结构实例。结构定义描述某类对象或问题的知识组织方式,结构实例则表示具体对象或具体运行环境中形成的实际结构。

例如,“输送设备运行管理结构”可以作为结构定义,说明输送设备需要哪些属性、具有什么关系以及能够使用哪些方法。某一台具体输送设备的运行速度、运行状态和实际关联设备,则属于具体对象实例或运行数据。

结构定义不能直接保存某台设备的动态运行值,运行数据也不能替代结构定义。两者应当通过明确的结构标识和对象实例标识建立关联。

知识结构保存还需要保留版本信息。知识结构可能随着新需求不断扩展,例如增加一个新的属性、增加一种关系或增加一种检查方法。每次正式结构变化都需要形成可追溯的版本记录,不能直接覆盖原有结构内容。

版本管理的目的不仅是保留历史,还包括支持结构差异分析、历史知识检索、能力依赖检查和个体部署更新。某个个体可能仍然运行在旧版本结构上,后台不能因为新版本已经生成,就立即删除旧版本。

知识结构可以建立独立的基础表:

CREATE TABLE knowledge_structures (
    id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
    structure_code VARCHAR(120) NOT NULL,
    structure_name VARCHAR(200) NOT NULL,
    requirement_id BIGINT UNSIGNED DEFAULT NULL,
    root_element_id BIGINT UNSIGNED NOT NULL,
    current_version INT NOT NULL DEFAULT 1,
    structure_status VARCHAR(30) NOT NULL,
    created_at DATETIME NOT NULL,
    updated_at DATETIME DEFAULT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_structure_code (structure_code),
    KEY idx_requirement (requirement_id),
    KEY idx_root_element (root_element_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

结构版本表用于保存每次正式形成的结构版本:

CREATE TABLE knowledge_structure_versions (
    id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
    structure_id BIGINT UNSIGNED NOT NULL,
    version_no INT NOT NULL,
    structure_data LONGTEXT NOT NULL,
    change_description TEXT,
    validation_status VARCHAR(30) NOT NULL,
    created_at DATETIME NOT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_structure_version (
        structure_id,
        version_no
    ),
    KEY idx_validation_status (validation_status)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

这里的structure_data用于保存该版本的结构定义内容。实际工程可以根据数据规模和查询需求,将结构元素、关系和方法依赖分别保存到关联表中。无论采用整体结构数据保存,还是采用多表关系保存,都必须保证结构版本能够完整恢复,不能出现结构版本记录存在但所引用的元素定义已经无法查询的情况。

结构元素引用关系可以单独保存:

CREATE TABLE knowledge_structure_elements (
    id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
    structure_id BIGINT UNSIGNED NOT NULL,
    structure_version INT NOT NULL,
    element_id BIGINT UNSIGNED NOT NULL,
    definition_id BIGINT UNSIGNED DEFAULT NULL,
    definition_version INT DEFAULT NULL,
    element_role VARCHAR(50) NOT NULL,
    created_at DATETIME NOT NULL,
    PRIMARY KEY (id),
    KEY idx_structure_version (
        structure_id,
        structure_version
    ),
    KEY idx_element (element_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

该表保存结构版本对知识元素和定义版本的引用关系。通过它可以查询某个元素被哪些结构引用,也可以查询某个结构版本包含哪些元素。

知识结构检索需要支持不同的检索入口。后台可能根据需求编号查询结构,也可能根据对象元素查询包含该对象的结构,还可能根据属性、关系或方法查询相关知识内容。个体运行时也可能根据已经赋值的知识能力标识,读取相应知识结构。

因此,结构检索不能只支持结构名称查询,而应当建立多种明确的查询条件,并保持查询结果与结构版本之间的关联。

例如,后台根据一个对象元素检索相关知识结构时,需要返回包含该元素的结构标识、结构版本、元素角色以及定义引用信息。这样,后续结构解析程序才能准确读取对应结构,而不是只获得一条结构名称记录。

结构检索程序可以组织为:

app/
└── Intelligence/                              # WSaiOS智能控制后台的智能处理程序
    └── Knowledge/                             # 知识结构化与知识能力构建程序
        └── Storage/                            # 知识结构保存与检索程序
            ├── KnowledgeStorageManager.php    # 统一调度知识结构保存、读取和更新
            ├── KnowledgeStructureSaver.php    # 保存经过验证的知识结构及其版本
            ├── KnowledgeStructureLoader.php   # 根据结构标识和版本读取完整知识结构
            ├── KnowledgeStructureFinder.php   # 根据对象、属性、关系和方法检索相关结构
            ├── StructureVersionManager.php    # 管理知识结构版本及当前有效版本
            ├── StructureReferenceRepository.php # 管理知识结构与知识元素之间的引用记录
            ├── StructureSnapshotManager.php   # 保存结构版本快照并支持历史恢复
            ├── StructureUpdateManager.php     # 调度知识结构变更和版本更新
            ├── StructureDifferenceAnalyzer.php # 分析新旧结构之间的元素和关系差异
            ├── StructureUpdateValidator.php   # 验证结构更新是否满足完整性和兼容性要求
            └── KnowledgeStorageRepository.php # 统一负责知识结构相关数据访问

KnowledgeStorageManager.php负责统一调度存储、读取和更新操作。KnowledgeStructureSaver.php只接收经过相应验证的结构并完成保存,KnowledgeStructureLoader.php负责根据结构标识和版本恢复结构,KnowledgeStructureFinder.php负责按元素及结构条件进行检索。版本管理和快照管理程序负责保留历史状态,更新程序则负责组织结构变更。

知识结构更新是动态知识构建的重要组成部分。随着新需求产生、原有需求变化或运行反馈出现,原有知识结构可能需要增加元素、修改定义、调整关系、增加方法或者停用某些内容。

结构更新不能简单地重新构建一份结构并覆盖旧结构。后台必须先读取当前有效版本,分析本次变更内容,确定变更影响范围,再形成新的结构版本。

例如,输送设备运行管理结构原来只有运行速度和运行状态两个属性。新需求要求增加设备振动监测,后台需要分析新属性是否已有定义、该属性属于哪个对象、是否需要增加传感器对象、传感器与输送设备之间是否需要建立检测关系,以及现有检查方法是否需要扩展。

如果只是增加一个属性定义,可能不需要重新组织整个知识结构;如果新增传感器对象和检测关系,就需要同时更新对象组合、关系组织和方法依赖。结构更新必须根据实际变化分析,而不能使用统一的覆盖操作。

结构更新可以按照以下过程组织:

接收知识结构更新请求
          ↓
读取当前有效结构版本
          ↓
识别本次变更内容
          ↓
分析元素、属性、关系和方法差异
          ↓
分析相关知识结构引用
          ↓
形成结构调整结果
          ↓
建立新的结构版本
          ↓
执行完整性与兼容性验证
          ↓
验证通过?
     ┌────┴────┐
     ↓         ↓
    是         否
     ↓         ↓
发布新版本   保留原版本
     ↓         ↓
更新当前指针 记录失败原因
     ↓
通知相关知识能力管理程序

这里的发布操作必须建立在新结构验证通过的基础上。对于验证未通过的结构,不能将其设置为当前有效版本,更不能直接替换正在被个体使用的旧结构。

结构更新还需要考虑多个知识结构之间的关联。如果一个公共知识元素发生变化,可能影响多个知识结构。后台需要通过结构引用关系查询受影响范围,并判断这些结构是否需要重新验证。对于没有受到实际影响的结构,不必无条件重新构建。

如果某个知识结构已经被个体使用,更新还需要考虑个体当前运行状态。后台可以先完成新版本构建和验证,再根据个体部署规则决定是否立即更新、等待任务结束后更新,或者保留旧版本继续运行。知识结构更新与个体运行版本之间必须保持明确的对应关系。

结构更新程序可以设计为:

<?php

class StructureUpdateManager
{
    private $loader;
    private $differenceAnalyzer;
    private $builder;
    private $validator;
    private $repository;

    public function __construct(
        $loader,
        $differenceAnalyzer,
        $builder,
        $validator,
        $repository
    ) {
        $this->loader = $loader;
        $this->differenceAnalyzer = $differenceAnalyzer;
        $this->builder = $builder;
        $this->validator = $validator;
        $this->repository = $repository;
    }

    public function update($structureId, $changes)
    {
        $current = $this->loader->loadCurrent(
            $structureId
        );

        $difference = $this->differenceAnalyzer->analyze(
            $current,
            $changes
        );

        $newStructure = $this->builder->applyChanges(
            $current,
            $difference
        );

        $result = $this->validator->validate(
            $newStructure
        );

        if (!$result['valid']) {
            return array(
                'success' => false,
                'errors' => $result['errors']
            );
        }

        return $this->repository->saveNewVersion(
            $structureId,
            $newStructure,
            $difference
        );
    }
}

该程序展示了结构更新的基本调度关系。真实工程中还需要在读取版本、生成新版本和更新当前版本指针之间增加事务控制,并处理并发修改问题。特别是多个需求同时更新同一个公共知识结构时,需要检查当前版本是否已经发生变化,避免后提交的更新无意覆盖先前的结构变更。

知识结构保存、检索和更新最终需要与WSaiOS智能控制后台的其他智能处理过程衔接。

知识结构保存后,可以被结构解析程序加载,被结构匹配程序用于实际对象和状态匹配,也可以被知识能力构建程序用于形成可执行的能力。运行过程中产生的新信息和反馈,则可以重新进入需求驱动和知识构建过程,形成知识结构的持续扩展与修订。

因此,知识结构并不是一次建立后永久不变的数据,而是能够随着需求、信息和应用环境变化持续更新的动态结构。其更新必须保留历史版本,分析结构影响,并经过必要验证后才能进入正式使用状态。

本章工程衔接与验证

本章建立了从知识信息获取到知识结构保存和更新的工程过程。知识信息获取与处理为知识构建提供原始依据,知识元素提取将信息转化为具有明确含义的对象、属性、关系和方法,知识组织进一步建立元素之间的归属、关联和依赖关系,知识结构组合则将这些元素组织为能够被后台解析和使用的整体,最后通过版本化保存、检索和更新机制,使知识结构能够持续维护。

在WSaiOS智能控制后台中,这些过程不是彼此独立的应用程序,而是知识结构化智能的内部工程实现。需求驱动机制确定知识构建目标,动态语义机制提供语义识别和定义依据,知识构建程序形成结构化知识,结构验证程序检查构建结果,后续知识能力构建程序则依据知识结构形成可供个体使用的知识能力。

本章所设计的工程目录与程序关系可以汇总为:

app/
└── Intelligence/                              # WSaiOS智能控制后台核心智能处理体系
    └── Knowledge/                             # 知识结构化与知识能力构建体系
        └── Construction/                      # 知识构建核心工程程序
            ├── Information/                   # 获取原始知识信息并完成预处理和关联分析
            │   ├── KnowledgeInformationManager.php    # 统一调度信息获取与处理
            │   ├── InformationCollector.php            # 获取用户输入、文件和授权接口信息
            │   ├── InformationPreprocessor.php         # 处理原始信息并形成规范化内容
            │   ├── InformationRelevanceAnalyzer.php    # 判断信息与当前知识构建目标的关联性
            │   └── InformationSetBuilder.php            # 形成知识元素提取所需的信息集合
            ├── Extraction/                    # 从信息集合中提取并确认知识元素
            │   ├── KnowledgeElementExtractor.php       # 统一调度知识元素提取
            │   ├── ObjectElementExtractor.php          # 提取对象元素
            │   ├── AttributeElementExtractor.php       # 提取属性元素
            │   ├── RelationElementExtractor.php        # 提取关系元素
            │   ├── MethodElementExtractor.php          # 提取方法元素
            │   └── ElementDefinitionMatcher.php        # 将候选元素与已有概念定义匹配
            ├── Organization/                  # 组织知识元素之间的结构关系
            │   ├── KnowledgeOrganizer.php              # 统一调度知识元素组织
            │   ├── ObjectAttributeOrganizer.php        # 建立对象与属性的归属关系
            │   ├── RelationOrganizer.php               # 建立对象及元素之间的关系
            │   ├── MethodOrganizer.php                 # 组织方法及其依赖元素
            │   └── KnowledgeOrganizationValidator.php # 验证元素组织的完整性
            ├── Structure/                     # 组合知识元素并建立知识结构关联
            │   ├── KnowledgeStructureBuilder.php      # 根据知识元素组织结果建立知识结构
            │   ├── StructureElementAssembler.php      # 组合对象、属性和方法元素
            │   ├── StructureReferenceManager.php      # 管理结构之间及结构对元素的引用
            │   ├── StructureDependencyAnalyzer.php    # 分析结构之间的依赖关系
            │   └── StructureIntegrityValidator.php    # 验证知识结构整体完整性
            └── Storage/                       # 保存、检索和更新知识结构
                ├── KnowledgeStorageManager.php        # 统一调度知识结构存储与维护
                ├── KnowledgeStructureSaver.php        # 保存经过验证的知识结构
                ├── KnowledgeStructureLoader.php       # 按结构标识和版本加载知识结构
                ├── KnowledgeStructureFinder.php       # 按对象、属性、关系和方法检索知识结构
                ├── StructureVersionManager.php        # 管理知识结构版本
                ├── StructureUpdateManager.php         # 调度知识结构动态更新
                └── StructureDifferenceAnalyzer.php   # 分析知识结构新旧版本之间的差异

该目录是本章知识构建工程的组织设计,不代表所有程序已经完成编码。正式实施时,应当先建立目录和基础数据模型,再逐步实现各程序之间的调用关系,避免在多个程序中重复处理同一类数据。

工程验证不能仅检查知识结构是否能够写入数据库,还需要检查整个知识构建过程是否能够正确处理不同类型的信息。

信息获取验证需要检查不同来源的信息能否进入统一处理流程,原始信息和处理结果能否保持关联,重复信息和冲突信息能否得到识别。元素提取验证需要检查对象、属性、关系和方法能否被正确区分,已有定义能否被复用,新元素能否进入确认流程。元素组织验证需要检查属性归属、关系方向和方法依赖是否正确。结构组合验证需要检查多对象结构、跨结构引用、版本兼容和循环依赖。存储与更新验证则需要检查结构能否按照指定版本完整恢复,新版本是否保留历史数据,更新失败时是否能够维持原有有效版本。

此外,还必须验证知识结构与后续程序之间的数据衔接。结构解析程序应当能够加载保存的结构,结构匹配程序应当能够根据结构中的对象、属性和关系进行匹配,方法调用程序应当能够读取方法定义及其依赖,知识能力构建程序应当能够依据完整结构组织能力内容。

这些验证应当在实际开发环境中逐步实施,并区分程序语法检查、单项功能测试、数据关联测试、结构完整性测试和实际运行验证。不能因为某个PHP文件通过语法检查,就认定整个知识构建流程已经具备运行能力。

通过本章的工程设计,WSaiOS智能控制后台形成了将需求相关信息持续转化为知识结构的基本机制。知识信息不再只是被动保存的资料,而是经过获取、处理、定义和组织,最终形成具有明确结构关系、能够被解析和调用的知识内容。

知识结构形成以后,还需要进一步研究如何从结构化知识中形成具有实际处理能力的知识能力,以及如何验证这些能力是否能够满足需求。下一阶段将围绕知识能力形成、能力组织和能力验证展开工程实现,使知识结构能够进一步转化为可以赋予个体并支持自主运行的能力。

Leave a Reply

Your email address will not be published. Required fields are marked *

客服咨询
● 欢迎咨询与合作
您好!欢迎咨询。 我可以帮助您了解人工智能技术研发、智能软件系统开发、网站建设、搜索优化及项目定制等相关信息。 请问有什么可以帮您?
免费申请
请填写以下信息,方便我们进一步沟通。
欢迎咨询 AI 系统开发、网站建设、搜索优化、项目定制合作
电话:15089196448
邮箱:1602401899@qq.com
地址:陕西省渭南市
服务时间:周一至周五 09:00 - 18:00 | 7×24小时技术值守