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

第七篇 个体认知、决策与方法形成工程

第七篇 个体认知、决策与方法形成工程

本篇将WSaiOS结构智能逻辑落实到个体的实际处理过程,研究个体在获得知识能力赋值并进入自主运行之后,如何根据当前任务、实际场景、对象信息和已有知识结构形成认知结果,并进一步完成判断、决策和方法形成。前面章节已经建立了个体运行环境、信息获取、对象识别、知识能力调用和自主运行程序,本篇将在这些工程基础上,进一步研究个体如何利用已有知识结构处理当前场景,形成与实际任务相对应的认知、判断和决策结果。

个体认知不是独立于知识结构和运行过程之外的另一套智能系统,也不是将外部信息简单转换为文字描述。它是在个体已经获得的知识结构和知识能力基础上,对当前场景中的对象、属性、关系、状态和条件进行综合处理,使当前实际信息与已有知识结构建立对应关系,并形成能够用于后续判断和决策的结构化结果。

本篇特别需要区分认知、判断、决策与方法形成之间的工程关系。认知解决当前场景及其对象关系如何被理解和组织的问题;判断解决当前对象状态、条件和关系是否符合特定要求的问题;决策根据需求目标、认知结果、判断结果、知识能力和执行约束确定处理方向;方法形成则根据决策目标和实际条件组织适当的操作步骤及其调用关系。方法形成不能被简化为从预先编写的函数库中选择一个函数。预设方法可以作为已有的方法资源,但当现有方法不能直接满足需求时,还需要依据已经赋予个体的知识结构、能力和规则,组织适合当前任务的处理方法,并对其适用条件和执行边界进行验证。

本篇的工程主线是:个体获取当前场景信息,利用已赋予的知识结构进行场景匹配,对对象、属性、关系和状态进行综合处理,形成结构化认知结果,再进入判断、决策和方法形成程序。其运行结果可以进一步进入方法执行和反馈环节。对于个体自身知识能力无法解决的新问题,则形成能力缺口和运行反馈,由WSaiOS智能控制后台根据整体需求开展知识构建、能力形成与验证,再向相应个体进行赋值。

第三十一章 个体认知处理机制

  1. 个体认知的数据基础

  2. 当前场景与已有知识结构的匹配

  3. 对象、属性、关系和状态的综合处理

  4. 认知结果的结构化表达

  5. 认知处理程序与运行引擎衔接

第三十一章 个体认知处理机制

个体认知处理是个体自主运行从信息处理进入认知与决策过程的工程环节。前面章节已经建立了个体信息获取与对象识别程序,使个体能够获得外部对象信息、读取对象属性和状态,并将实际信息与已赋值的知识结构进行匹配。本章进一步研究如何在这些信息和结构基础上形成完整的认知结果。

在工程实现中,认知处理不能仅仅依靠某个对象识别程序,也不能将一次结构匹配的结果直接当作完整认知。当前场景通常包含多个对象,不同对象具有各自的属性和状态,对象之间还存在空间、功能、控制、依赖、从属或其他关系。个体需要将这些信息组织起来,形成能够反映当前场景实际情况的结构化认知内容。

例如,仓库机器人接收到物料搬运任务后,获取到的并不只是一个物料对象的信息。当前场景还可能包含机器人自身状态、物料位置、目标区域、通道状态、其他设备状态以及安全条件。单独识别出物料,并不能说明机器人已经理解了当前搬运场景。只有将物料、机器人、目标区域、路线和运行条件之间的关系组织起来,才能形成支持后续判断和决策的认知结果。

个体认知的工程实现以已经赋予个体的知识结构和知识能力为基础。个体不需要在每次任务运行时重新构建全部知识,也不需要复制智能控制后台的完整知识构建逻辑。它根据当前任务加载相应的结构定义,读取实际对象信息,建立结构对应关系,处理对象及其属性、关系和状态,形成当前任务所需的认知结果。

1. 个体认知的数据基础

个体认知首先需要明确数据来源及其结构关系。当前场景中的信息来自个体运行环境、外部设备、传感器、业务系统、本地数据和任务输入等不同来源。这些信息在格式、内容和更新频率上可能存在差异,如果直接将原始信息交给认知处理程序,程序就需要不断适应不同数据来源,难以建立稳定的认知处理过程。

因此,个体认知的数据基础需要在第二十七章信息获取与对象识别的基础上进一步组织,将当前运行信息转换为能够与知识结构建立关系的数据对象。这里需要区分实际场景信息、知识结构定义、对象实例、属性值、对象关系、状态信息和任务上下文。它们之间存在关联,但不是同一种数据。

知识结构定义描述某类对象具有什么结构元素、属性、关系和方法,是个体通过赋值获得的相对稳定的知识内容。实际对象信息则描述当前运行环境中某个具体对象的情况。对象实例将实际对象与知识结构定义关联起来,属性值记录对象在特定时刻的实际属性内容,状态信息描述对象当前所处的运行状态,关系信息描述对象与其他对象之间的联系。

例如,仓库中存在一个实际物料对象,其知识结构定义可以包含物料标识、物料类型、尺寸、重量、存放位置和物料状态等属性。当前场景采集到的物料信息则可能是物料标识为material_0001、重量为12.5kg、当前位置为area_A_03、状态为available。这些数据不是新的知识结构定义,而是已有知识结构下的实际对象实例信息。

认知数据的基本关系可以设计为:

个体运行任务
    |
    v
当前场景信息
    |
    +---- 对象信息
    |        |
    |        +---- 对象标识
    |        +---- 对象类型
    |        +---- 属性值
    |        +---- 当前状态
    |
    +---- 关系信息
    |        |
    |        +---- 对象之间的关系
    |        +---- 关系方向
    |        +---- 关系条件
    |
    +---- 环境信息
    |        |
    |        +---- 位置
    |        +---- 通道
    |        +---- 设备状态
    |        +---- 环境条件
    |
    +---- 任务信息
             |
             +---- 任务目标
             +---- 任务对象
             +---- 执行条件
             +---- 约束范围

              |
              v
       当前场景数据组织
              |
              v
       已有知识结构关联
              |
              v
          认知数据基础

从数据组织角度看,认知处理至少需要建立场景、对象、属性、关系、状态和任务之间的关联。场景是当前认知处理的范围,对象是场景中的具体实体,属性描述对象的特征,关系描述对象之间的联系,状态描述对象当前的实际情况,任务则限定当前认知需要解决的问题和处理目标。

场景本身也需要具有独立标识。相同的对象可能在不同时间出现在不同场景中,同一场景中的对象状态也会随运行过程变化。如果仅仅保存对象当前属性值,而不保存对应的场景标识和采集时间,程序就无法判断不同对象信息是否属于同一个运行时刻,也无法正确处理场景变化。

因此,可以建立场景数据模型:

{
    "scene_id": "scene_000128",
    "individual_id": "individual_001",
    "task_instance_id": "task_instance_000128",
    "scene_type": "warehouse_transport",
    "scene_time": "2026-11-15 10:40:00",
    "objects": [
        {
            "object_id": "material_0001",
            "structure_id": "material_structure",
            "attributes": {
                "weight": 12.5,
                "location": "area_A_03",
                "material_type": "component"
            },
            "state": "available"
        },
        {
            "object_id": "robot_001",
            "structure_id": "robot_structure",
            "attributes": {
                "location": "area_A_01",
                "load_capacity": 30
            },
            "state": "ready"
        }
    ],
    "relations": [
        {
            "source_object": "robot_001",
            "target_object": "material_0001",
            "relation_type": "near"
        }
    ]
}

这个场景数据模型将当前任务、实际对象、结构引用、属性值、状态和对象关系组织在同一个场景范围内。它不要求所有对象必须具有相同的属性集合。不同对象根据其已赋值的结构定义保存各自的属性,关系也根据结构定义确定具体类型和适用条件。

实际工程中,场景数据不能完全依赖一个固定JSON结构。因为不同任务涉及的对象类型、属性内容和关系种类可能不同,所以数据模型需要支持动态结构。程序应当通过结构标识找到对应定义,再根据结构定义解释当前对象的属性和关系,而不是将物料、机器人、路线等业务字段全部写死在认知程序中。

个体认知的数据来源还需要保留来源信息。一个属性值可能来自传感器,也可能来自业务系统、本地文件或者任务输入。不同来源的数据在可信程度、更新时间和有效条件方面可能不同。认知程序不能仅仅因为某个属性存在,就认为该属性可以直接用于判断。例如,设备位置数据如果已经超过有效时间,可能不能继续作为当前路线判断的依据。

因此,实际对象属性值可以附带来源和时间信息:

{
    "object_id": "material_0001",
    "attribute_values": {
        "weight": {
            "value": 12.5,
            "source": "sensor_003",
            "collected_at": "2026-11-15 10:39:58",
            "valid": true
        },
        "location": {
            "value": "area_A_03",
            "source": "warehouse_position_system",
            "collected_at": "2026-11-15 10:39:59",
            "valid": true
        }
    }
}

认知数据基础还需要考虑同一对象的多次采集结果。当一个对象在运行过程中发生变化时,个体不能简单地把所有历史信息都当作当前状态使用。程序需要根据采集时间、数据来源、对象状态变化规则和任务要求,确定当前有效信息,并保留必要的历史记录,以支持状态变化分析和运行追溯。

为此,个体认知数据可以组织在以下工程目录中:

IndividualRuntime/
└── cognition/
    ├── data/
    │   ├── SceneDataBuilder.php             # 根据当前任务和运行信息建立场景数据
    │   ├── SceneDataReader.php              # 读取当前场景及其关联数据
    │   ├── SceneIdentityManager.php         # 管理场景标识及场景归属
    │   ├── ObjectDataReader.php             # 读取场景中的实际对象数据
    │   ├── AttributeDataReader.php          # 读取对象属性及其来源信息
    │   ├── RelationDataReader.php            # 读取对象之间的关系数据
    │   ├── StateDataReader.php               # 读取对象和环境当前状态
    │   └── DataValidityChecker.php           # 检查认知数据的完整性和有效性
    ├── context/
    │   ├── CognitionContext.php              # 保存认知处理所需的运行上下文
    │   ├── SceneContextBuilder.php           # 建立当前场景的认知上下文
    │   └── CognitionDataBinder.php           # 关联任务、对象、结构和关系数据
    └── repository/
        ├── SceneRepository.php               # 管理场景数据的保存与读取
        ├── ObjectInstanceRepository.php       # 管理实际对象实例
        └── CognitionDataRepository.php       # 管理认知处理所需的关联数据

SceneDataBuilder.php负责将第二十七章已经获取和处理的运行信息组织为当前场景数据。它不负责重新采集全部信息,也不负责重新定义知识结构,而是根据当前任务确定需要纳入认知处理的对象及其信息。CognitionContext.php则将场景数据与任务标识、个体标识、赋值版本和结构版本关联起来,使后续认知程序能够在统一上下文中工作。

认知数据读取程序需要检查数据是否完整、有效,以及是否与当前任务相符。对于缺少关键属性的对象,程序应当形成信息缺口;对于对象标识无法对应已有结构的情况,应当形成结构匹配问题;对于对象状态无法确认的情况,应当保留不确定状态,而不能擅自补充一个看似合理的状态值。

数据库可以采用场景与对象实例分离的方式组织认知数据。场景表保存当前认知处理范围,对象实例表保存具体对象,属性值表保存动态属性,关系表保存对象关联。

场景表可以设计为:

CREATE TABLE individual_scenes (
    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    scene_id VARCHAR(100) NOT NULL,
    individual_id VARCHAR(100) NOT NULL,
    task_instance_id VARCHAR(100) NOT NULL,
    scene_type VARCHAR(100) DEFAULT NULL,
    scene_status VARCHAR(50) NOT NULL,
    scene_time DATETIME NOT NULL,
    created_at DATETIME NOT NULL,
    UNIQUE KEY uk_scene_id (scene_id),
    KEY idx_scene_task (task_instance_id)
);

场景对象关联表可以设计为:

CREATE TABLE individual_scene_objects (
    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    scene_id VARCHAR(100) NOT NULL,
    object_id VARCHAR(100) NOT NULL,
    structure_id VARCHAR(100) NOT NULL,
    structure_version VARCHAR(100) DEFAULT NULL,
    object_type VARCHAR(100) DEFAULT NULL,
    object_state VARCHAR(100) DEFAULT NULL,
    collected_at DATETIME DEFAULT NULL,
    KEY idx_scene_object (scene_id, object_id)
);

对象属性值表可以设计为:

CREATE TABLE individual_object_attributes (
    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    scene_id VARCHAR(100) NOT NULL,
    object_id VARCHAR(100) NOT NULL,
    attribute_id VARCHAR(100) NOT NULL,
    attribute_value TEXT,
    value_type VARCHAR(50) DEFAULT NULL,
    source_id VARCHAR(100) DEFAULT NULL,
    collected_at DATETIME DEFAULT NULL,
    validity_status VARCHAR(30) DEFAULT NULL,
    KEY idx_object_attribute (
        object_id,
        attribute_id
    ),
    KEY idx_scene_object (scene_id, object_id)
);

对象关系表可以设计为:

CREATE TABLE individual_object_relations (
    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    scene_id VARCHAR(100) NOT NULL,
    source_object_id VARCHAR(100) NOT NULL,
    target_object_id VARCHAR(100) NOT NULL,
    relation_id VARCHAR(100) NOT NULL,
    relation_value TEXT,
    relation_status VARCHAR(50) DEFAULT NULL,
    collected_at DATETIME DEFAULT NULL,
    KEY idx_source_object (source_object_id),
    KEY idx_target_object (target_object_id),
    KEY idx_scene_relation (scene_id, relation_id)
);

上述数据表是认知运行数据的保存设计。知识结构定义本身仍然由个体已经加载的结构知识库管理,不能将每一次场景采集都写入知识结构定义表。实际场景数据与知识结构定义应当保持分离,前者可以随着运行过程频繁变化,后者则根据后台知识构建、验证和赋值机制进行更新。

2. 当前场景与已有知识结构的匹配

个体获得当前场景数据之后,需要将当前场景与已有知识结构进行匹配。这是认知处理的核心环节。场景匹配并不是简单地比较两个对象名称是否相同,也不是只检查某个对象是否具有预先规定的几个字段,而是根据当前场景中的实际对象、属性、关系和状态,寻找与其相对应的已有结构定义,并确认这些结构定义是否能够解释当前场景中的实际信息。

在WSaiOS结构智能工程中,语义理解与结构匹配存在直接联系。个体获取实际场景信息后,需要将场景中的对象和结构元素与已有公共概念定义及已赋值知识结构建立对应关系。结构匹配结果用于确定当前场景中的实际对象属于什么结构、具备哪些属性、与其他对象存在什么关系,以及当前状态是否能够在已有结构定义中得到解释。

例如,机器人获取到一个实际物体的信息,可能包括物体标识、外形尺寸、重量、位置和当前状态。个体需要根据已经赋予的物料结构定义,对这些信息进行匹配。如果物体能够对应到已有物料结构,并且关键属性和关系满足结构定义要求,就可以建立实际对象与知识结构之间的关联。

但是,结构匹配不能只根据对象名称进行判断。两个对象可能名称不同但具有相同的结构定义,也可能名称相同但实际结构不同。匹配过程需要考虑结构标识、属性定义、属性类型、属性值范围、对象关系、状态定义和结构依赖等内容。

因此,当前场景与已有知识结构的匹配应当按照实际数据关系进行。首先读取当前场景中的对象信息,确定对象所引用或可能对应的结构类型;然后读取结构定义及其版本;再根据属性定义检查实际属性值是否具有对应关系;之后处理对象之间的关系和当前状态;最后形成结构匹配结果。

匹配过程可以表示为:

当前场景
    |
    v
场景对象提取
    |
    v
已有结构定义读取
    |
    v
对象结构对应
    |
    v
属性定义与属性值匹配
    |
    v
对象关系匹配
    |
    v
状态定义与当前状态匹配
    |
    v
结构依赖检查
    |
    v
形成场景结构匹配结果

场景匹配需要处理一对一、一对多和多对象关联等情况。一个实际对象通常对应一个主要结构定义,但一个对象可能同时参与多种关系;一个场景则可能包含多个不同结构类型的对象。对于复合对象,还可能需要通过多个结构元素形成更高层次的对象结构。

例如,仓库机器人搬运物料时,场景中的机器人、物料、货架、通道和目标区域分别对应不同结构定义。它们之间通过位置关系、承载关系、通行关系和目标关系构成当前场景。个体不能只识别机器人和物料,而忽略通道与目标区域,因为后两者可能直接影响任务是否能够继续执行。

结构匹配结果应当包含匹配对象、对应结构、属性匹配情况、关系匹配情况、状态匹配情况和未能匹配的内容。对于完整匹配的对象,可以进入后续综合认知处理;对于部分匹配的对象,需要明确缺少哪些信息;对于无法匹配的对象,则不能强行归入已有结构,应当形成结构缺口记录。

场景匹配结果可以采用以下数据结构:

{
    "scene_match_id": "scene_match_000128",
    "scene_id": "scene_000128",
    "assignment_version": "assignment_v003",
    "matches": [
        {
            "object_id": "material_0001",
            "structure_id": "material_structure",
            "match_status": "matched",
            "attribute_match": "complete",
            "relation_match": "complete",
            "state_match": "matched"
        },
        {
            "object_id": "robot_001",
            "structure_id": "robot_structure",
            "match_status": "matched",
            "attribute_match": "complete",
            "relation_match": "partial",
            "state_match": "matched"
        }
    ],
    "unmatched_items": [],
    "overall_status": "partial"
}

这里机器人对象的关系匹配为部分匹配,说明其对象结构和属性可能已经识别,但某些关系信息尚未完整。整个场景的匹配结果因此为partial。这并不意味着场景认知完全失败,而是表示后续处理必须保留关系缺口,并判断缺少的关系是否影响当前任务。

结构匹配程序可以组织为:

IndividualRuntime/
└── cognition/
    └── matching/
        ├── SceneStructureMatcher.php        # 组织当前场景与已有知识结构的匹配
        ├── SceneObjectMatcher.php            # 匹配场景中的实际对象与结构定义
        ├── StructureDefinitionReader.php     # 读取已赋值的结构定义
        ├── AttributeStructureMatcher.php    # 匹配属性定义与实际属性值
        ├── RelationStructureMatcher.php     # 匹配对象关系及关系定义
        ├── StateStructureMatcher.php        # 匹配当前状态与结构状态定义
        ├── StructureDependencyChecker.php   # 检查结构之间的依赖关系
        ├── SceneMatchResultBuilder.php       # 组织完整场景匹配结果
        └── SceneMatchValidator.php           # 验证场景匹配结果的完整性

SceneStructureMatcher.php是场景匹配的组织程序,它根据当前任务确定需要匹配的对象和结构范围,再调用对象、属性、关系和状态匹配程序。它不直接完成所有具体比较操作,而是根据结构定义中的内容调用相应匹配程序,最终由SceneMatchResultBuilder.php形成统一结果。

场景匹配程序需要明确结构版本。个体可能同时保存多个知识结构版本,但当前任务必须按照其运行上下文确定的赋值版本和结构版本进行匹配。不能在同一任务中随意混用不同版本的结构定义,否则可能出现属性定义、关系定义和状态规则不一致的问题。

匹配程序还应当支持部分匹配。现实场景的信息可能不完整,某些属性暂时无法读取,某些关系需要通过后续信息进一步确认。程序需要区分完全匹配、部分匹配、不匹配和无法判断等结果,避免将未知情况直接当作不匹配,也避免把不完整的信息当作已经确认。

例如,物料的重量信息已经读取,但位置数据暂时无法获取。此时物料结构仍然可能匹配成功,但位置属性处于未知状态。如果当前任务只需要判断物料类型,则该缺失属性可能不影响当前认知;如果当前任务要求机器人移动到物料所在位置,则该缺失属性将直接影响后续决策。

因此,场景匹配结果不仅要记录是否匹配,还要将匹配结果与当前任务要求关联起来。匹配完整程度和任务可用程度是两个不同的判断层次。一个对象可能在结构层面部分匹配,但对于某项任务仍然具备足够信息;也可能结构匹配完整,却因为对象当前状态不满足任务条件而不能执行。

个体认知处理需要将这一差异保留到后续综合处理环节,而不能在结构匹配阶段就直接把所有信息简化为一个成功或失败标识。

3. 对象、属性、关系和状态的综合处理

场景结构匹配完成后,个体需要对对象、属性、关系和状态进行综合处理,形成能够反映当前实际情况的场景认知结构。

对象、属性、关系和状态并不是相互独立的信息集合。对象通过属性描述自身特征,通过关系与其他对象建立联系,并通过状态反映当前实际情况。属性值可能影响对象状态,关系可能限制对象的可操作范围,状态变化也可能改变对象与其他对象之间的关系。因此,认知处理需要把这些信息放在同一个场景结构中进行组织。

例如,机器人和物料之间存在距离关系,物料与货架之间存在存放关系,机器人与通道之间存在通行关系。物料虽然处于可搬运状态,但如果机器人无法进入物料所在区域,或者通道当前处于关闭状态,那么当前场景就不具备直接执行搬运任务的条件。个体需要综合处理物料属性、机器人状态、通道状态和对象关系,才能形成符合实际情况的认知结果。

综合处理首先需要建立对象关联。场景中的每个对象都应当具有稳定标识,并且能够关联对应的结构定义和实际属性值。不同对象之间通过关系记录建立联系。程序根据任务范围确定需要参与认知处理的对象集合,避免将与当前任务无关的全部本地对象都纳入处理。

其次,需要对属性进行综合处理。对象属性可能具有不同类型和不同意义。有些属性是相对稳定的对象特征,例如设备型号、物料类别和最大承载能力;有些属性则随时间变化,例如当前位置、温度、速度、剩余电量和运行状态。认知程序需要根据结构定义识别属性类型,并结合数据来源、更新时间和有效条件判断其当前可用性。

对于同一个属性存在多个来源数据的情况,不能简单地把所有值合并。程序需要依据已经赋予的知识结构和数据处理规则确定适用来源。例如,设备本地传感器提供当前温度,后台业务系统提供历史登记温度,两者的时间和用途不同。当前设备运行判断应当优先使用符合当前任务要求的有效数据,而历史登记数据可以用于辅助核对。

关系处理需要确定对象之间是否存在实际联系、关系方向是否正确、关系条件是否满足,以及关系是否与其他结构信息一致。关系不能仅仅被保存为两个对象之间的字符串关联。例如,机器人与物料之间的near关系,必须依据位置和距离条件形成;机器人与通道之间的can_pass关系,则可能需要结合机器人尺寸、通道宽度和通道状态判断。关系定义可以是结构化的,也可以关联相应的计算、判断和验证方法。

状态处理则需要区分对象当前状态和对象历史状态。当前状态用于描述对象在本次认知处理时所处的实际情况,历史状态用于分析状态变化过程。状态不能仅根据某一个属性值随意确定,而应当依据已有结构定义中的状态条件及其关系进行判断。

例如,机器人电量充足并不一定表示机器人处于ready状态。如果设备正在执行其他任务、处于维护模式或者安全联锁已经触发,就不能仅凭电量条件将其认定为可运行。状态处理需要综合相关属性和约束,形成符合结构定义的状态结果。

综合处理还需要考虑对象之间的关联变化。某个对象状态发生变化后,可能影响其他对象的关系判断。例如,通道由开放状态变为关闭状态,可能导致机器人与目标区域之间的可通行关系失效。个体需要根据已赋予的关系定义和状态处理规则更新相关关系,而不是只更新通道自身的状态。

综合处理可以形成一个场景关系模型:

{
    "scene_id": "scene_000128",
    "objects": [
        {
            "object_id": "robot_001",
            "structure_id": "robot_structure",
            "attributes": {
                "location": "area_A_01",
                "load_capacity": 30,
                "battery_level": 82
            },
            "state": "ready"
        },
        {
            "object_id": "material_0001",
            "structure_id": "material_structure",
            "attributes": {
                "weight": 12.5,
                "location": "area_A_03"
            },
            "state": "available"
        },
        {
            "object_id": "route_001",
            "structure_id": "route_structure",
            "attributes": {
                "route_status": "open",
                "width": 1.8
            },
            "state": "available"
        }
    ],
    "relations": [
        {
            "source_object": "robot_001",
            "target_object": "material_0001",
            "relation_type": "distance",
            "relation_value": 3.2,
            "relation_status": "matched"
        },
        {
            "source_object": "robot_001",
            "target_object": "route_001",
            "relation_type": "route_access",
            "relation_status": "available"
        },
        {
            "source_object": "route_001",
            "target_object": "material_0001",
            "relation_type": "route_connects",
            "relation_status": "matched"
        }
    ],
    "scene_status": "recognized"
}

该模型把对象、属性、状态和关系放在一个场景范围内,后续判断程序可以根据这些内容分析当前场景是否满足任务条件。

综合处理程序可以组织为:

IndividualRuntime/
└── cognition/
    └── processing/
        ├── CognitionProcessor.php            # 组织当前场景的综合认知处理
        ├── SceneObjectOrganizer.php          # 组织当前场景中的对象集合
        ├── ObjectAttributeProcessor.php      # 综合处理对象属性及其有效值
        ├── ObjectRelationProcessor.php       # 处理对象之间的结构关系
        ├── ObjectStateProcessor.php          # 处理对象当前状态及状态关联
        ├── RelationConditionResolver.php     # 根据关系条件解析对象关联
        ├── SceneConsistencyChecker.php       # 检查场景对象、属性和关系的一致性
        ├── SceneChangeAnalyzer.php            # 分析当前场景相对已有记录的变化
        └── CognitionCompletenessChecker.php  # 检查当前认知内容是否满足任务要求

CognitionProcessor.php负责组织综合认知过程。它读取场景匹配结果,再调用对象、属性、关系和状态处理程序,形成统一的场景认知数据。SceneConsistencyChecker.php检查对象标识、结构引用、属性值和关系记录之间是否存在冲突。CognitionCompletenessChecker.php则结合当前任务要求检查认知结果是否包含必要信息。

例如,任务要求机器人搬运某个物料时,认知完整性检查需要确认物料对象已经识别,物料状态能够确定,目标位置已经明确,机器人自身状态能够确认,相关通道信息能够获得。若其中某项信息缺失,程序需要判断它是否为当前任务的必要信息,并据此形成信息缺口。

认知综合处理可以采用以下基本程序:

<?php

class CognitionProcessor
{
    private $sceneReader;
    private $objectProcessor;
    private $attributeProcessor;
    private $relationProcessor;
    private $stateProcessor;
    private $consistencyChecker;

    public function __construct(
        $sceneReader,
        $objectProcessor,
        $attributeProcessor,
        $relationProcessor,
        $stateProcessor,
        $consistencyChecker
    ) {
        $this->sceneReader = $sceneReader;
        $this->objectProcessor = $objectProcessor;
        $this->attributeProcessor = $attributeProcessor;
        $this->relationProcessor = $relationProcessor;
        $this->stateProcessor = $stateProcessor;
        $this->consistencyChecker = $consistencyChecker;
    }

    public function process($context)
    {
        $scene = $this->sceneReader->read(
            $context['scene_id']
        );

        if (!$scene) {
            return array(
                'success' => false,
                'status' => 'scene_not_found'
            );
        }

        $objects = $this->objectProcessor->process(
            $scene['objects']
        );

        $attributes = $this->attributeProcessor->process(
            $objects
        );

        $relations = $this->relationProcessor->process(
            $scene['relations'],
            $objects
        );

        $states = $this->stateProcessor->process(
            $objects,
            $attributes,
            $relations
        );

        $result = array(
            'scene_id' => $context['scene_id'],
            'objects' => $objects,
            'attributes' => $attributes,
            'relations' => $relations,
            'states' => $states
        );

        $check = $this->consistencyChecker->check(
            $result
        );

        return array(
            'success' => true,
            'status' => $check['valid']
                ? 'processed'
                : 'inconsistent',
            'cognition_data' => $result,
            'consistency' => $check
        );
    }
}

上述程序展示的是综合认知处理的调用组织方式。具体的属性处理、关系判断和状态处理,需要根据个体已经加载的知识结构定义及相关方法实现。程序本身不应当在代码中写死所有业务对象、属性名称和关系类型,而应当通过结构定义和注册机制确定处理内容。

综合认知还需要支持场景变化处理。个体执行任务期间,当前场景可能不断变化。对象位置、设备状态、环境条件和对象关系都可能发生改变。因此,认知结果不能被当作任务启动时一次性形成的固定信息,而应当随着有效运行信息更新。

但是,场景数据更新与知识结构更新必须区分。个体可以更新对象实例、属性值、关系状态和认知结果,这属于当前运行数据的变化;如果实际场景中出现了已有知识结构无法描述的新对象、新属性或新关系,则应当形成结构缺口反馈,由智能控制后台根据需求开展知识构建和能力调整。个体不能把一次未匹配信息直接写入正式知识结构定义。

4. 认知结果的结构化表达

对象、属性、关系和状态综合处理完成后,需要形成结构化认知结果。认知结果是当前个体对实际场景形成的结构化表达,也是后续判断和决策程序的重要输入。

如果认知结果只以自然语言描述,例如“机器人附近有一个物料,通道目前可以通行”,那么后续程序还需要再次解析这段文字,才能确定物料标识、距离数值、通道状态和对象关系。这不仅增加程序处理环节,也不利于判断结果追溯。因此,认知结果应当保留对象标识、结构标识、属性值、关系定义、状态信息、信息来源和场景上下文之间的对应关系。

结构化认知结果不是简单复制场景原始数据。原始场景数据可能包含大量尚未确认的信息,而认知结果需要体现经过结构匹配和综合处理后已经确认的内容,同时保留部分匹配、未知、冲突和缺失信息。这样,后续判断程序才能区分已经确认的事实、尚未确认的信息和需要进一步处理的内容。

认知结果至少需要关联当前场景、任务实例、个体标识、赋值版本和结构版本。对于每个对象,应当记录对象标识、对应结构、属性处理结果、关系处理结果和状态处理结果。对于整个场景,则应当记录认知完整程度、结构匹配情况、信息缺口和场景一致性检查结果。

例如,仓库机器人完成场景认知后,可以形成如下结果:

{
    "cognition_id": "cognition_000128",
    "scene_id": "scene_000128",
    "task_instance_id": "task_instance_000128",
    "individual_id": "individual_001",
    "assignment_version": "assignment_v003",
    "cognition_status": "completed",
    "objects": [
        {
            "object_id": "robot_001",
            "structure_id": "robot_structure",
            "state": {
                "value": "ready",
                "confirmed": true
            },
            "attributes": {
                "location": {
                    "value": "area_A_01",
                    "confirmed": true
                },
                "battery_level": {
                    "value": 82,
                    "confirmed": true
                }
            }
        },
        {
            "object_id": "material_0001",
            "structure_id": "material_structure",
            "state": {
                "value": "available",
                "confirmed": true
            },
            "attributes": {
                "weight": {
                    "value": 12.5,
                    "confirmed": true
                },
                "location": {
                    "value": "area_A_03",
                    "confirmed": true
                }
            }
        }
    ],
    "relations": [
        {
            "source_object": "robot_001",
            "target_object": "material_0001",
            "relation_type": "distance",
            "relation_value": 3.2,
            "confirmed": true
        },
        {
            "source_object": "robot_001",
            "target_object": "route_001",
            "relation_type": "route_access",
            "relation_value": "available",
            "confirmed": true
        }
    ],
    "information_gaps": [],
    "consistency_status": "valid",
    "created_at": "2026-11-15 10:41:00"
}

该认知结果明确表达了当前场景中已经确认的对象、属性、状态和关系。后续判断程序可以直接读取这些结构化内容,判断机器人是否能够接近物料、物料是否允许搬运、路线是否满足任务条件等。

认知结果还需要表达不确定内容。实际运行环境不一定能够一次性获得所有信息。例如,机器人可以识别物料,但由于传感器遮挡无法确认物料的某项属性;或者目标区域的状态信息暂时未更新。此时认知结果不能简单地标记为completed,也不能将未知值转换为默认值。

因此,可以为认知结果定义不同状态:

processing       # 认知处理正在进行
completed        # 任务所需的认知内容已经形成
partial          # 已形成部分认知内容,存在未解决的信息缺口
inconsistent     # 结构或对象关系存在冲突
insufficient     # 当前信息不足以支持任务认知
failed           # 认知处理无法完成

这些状态描述的是认知处理结果,不等同于个体运行状态或者任务状态。例如,个体整体运行状态可以是running,但当前任务的认知结果可能是partial。此时个体仍在运行,只是当前认知结果还不能支持某些后续判断。

认知结果结构化表达程序可以组织为:

IndividualRuntime/
└── cognition/
    └── result/
        ├── CognitionResultBuilder.php        # 根据综合处理结果生成认知结果
        ├── CognitionResultValidator.php      # 检查认知结果结构及数据完整性
        ├── CognitionStatusResolver.php       # 确定认知处理结果状态
        ├── CognitionGapBuilder.php           # 组织信息缺口和结构缺口
        ├── CognitionVersionBinder.php        # 关联认知结果所依据的赋值与结构版本
        ├── CognitionResultRepository.php     # 保存和读取认知结果
        └── CognitionResultExporter.php       # 将认知结果传递给判断和决策程序

认知结果数据库可以设计为:

CREATE TABLE individual_cognition_results (
    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    cognition_id VARCHAR(100) NOT NULL,
    scene_id VARCHAR(100) NOT NULL,
    task_instance_id VARCHAR(100) NOT NULL,
    individual_id VARCHAR(100) NOT NULL,
    assignment_version VARCHAR(100) NOT NULL,
    cognition_status VARCHAR(50) NOT NULL,
    cognition_data LONGTEXT,
    information_gaps LONGTEXT,
    consistency_status VARCHAR(50) DEFAULT NULL,
    created_at DATETIME NOT NULL,
    UNIQUE KEY uk_cognition_id (cognition_id),
    KEY idx_task_cognition (task_instance_id)
);

这里将完整认知结果以结构化数据保存,同时保留场景、任务和个体之间的关联。实际工程中,如果需要高频查询某个对象的认知属性或关系,可以进一步拆分对象认知结果表、属性认知结果表和关系认知结果表,不必将所有查询都依赖于一个完整JSON字段。

认知结果形成后,应当经过结构完整性和一致性检查。检查内容包括对象是否具有有效结构引用,属性是否符合结构定义,关系两端的对象是否存在,状态是否具有合法定义,赋值版本是否一致,以及当前任务所需的关键信息是否已经形成。

认知结果的完整性并不意味着场景中的所有对象都必须被识别。认知范围由当前任务确定,与任务无关的对象可以不纳入当前认知结果。相反,某个看似无关的对象如果会影响任务安全、资源使用或执行条件,就可能成为必须纳入的认知对象。

因此,认知完整性需要根据任务需求确定,而不能采用固定字段数量或固定对象数量作为判断标准。当前任务要求识别的对象、属性、关系和状态已经得到有效处理,才能认为当前认知结果满足任务要求。

认知结果还需要支持版本追溯。每次认知结果都应当关联其所依据的知识结构版本和赋值版本。个体在运行期间即使获得了新的能力赋值,也不能无条件修改正在运行任务的认知依据。若需要切换版本,应当由任务版本管理程序判断当前任务是否允许切换,并保留切换前后的认知结果记录。

结构化认知结果最终交给后续判断程序。判断程序不需要重新读取全部原始场景信息,而是根据认知结果及其关联上下文,执行当前任务需要的条件分析。对于认知结果中仍然存在的信息缺口,判断程序需要根据任务要求决定是否可以继续处理、是否需要补充信息,或者是否必须暂停任务。

5. 认知处理程序与运行引擎衔接

个体认知处理程序必须与第二十六章建立的运行引擎、第二十七章建立的信息获取程序、第二十八章建立的知识能力调用程序以及第三十章建立的自主运行程序形成统一的调用关系。认知程序不能脱离任务运行环境单独运行,也不能在每次认知处理时重新建立一套独立的任务管理和状态管理机制。

运行引擎负责管理任务生命周期和运行上下文。信息获取程序负责提供当前场景的实际信息。结构匹配程序负责将当前对象信息与已有知识结构建立对应关系。综合认知程序负责组织对象、属性、关系和状态处理。认知结果程序负责形成结构化认知结果,并将其交给后续判断与决策环节。

在这个调用关系中,认知处理属于运行引擎所组织的一个处理阶段。运行引擎根据任务定义确定当前是否需要进入认知阶段,并将任务上下文传递给认知处理程序。认知处理程序执行完毕后,向运行引擎返回认知结果及处理状态。运行引擎根据返回结果决定继续进入判断阶段、等待补充信息,还是进入异常处理路径。

认知程序的调用关系可以设计为:

RuntimeKernel
      |
      v
RuntimeScheduler
      |
      v
TaskProcessor
      |
      v
RuntimeContextManager
      |
      v
RuntimeInformationReader
      |
      v
SceneDataBuilder
      |
      v
SceneStructureMatcher
      |
      v
CognitionProcessor
      |
      +---- SceneObjectOrganizer
      |
      +---- ObjectAttributeProcessor
      |
      +---- ObjectRelationProcessor
      |
      +---- ObjectStateProcessor
      |
      v
CognitionResultBuilder
      |
      v
CognitionResultValidator
      |
      v
CognitionResultRepository
      |
      v
RuntimeKernel
      |
      v
后续判断程序

运行引擎在调用认知程序之前,应当确认当前任务仍处于允许执行的状态,并将任务标识、场景标识、个体标识、赋值版本和结构版本传递给认知上下文。认知程序完成后,运行引擎需要检查返回结果是否有效,并更新任务的运行阶段。

例如,认知程序返回completed,说明当前任务要求的认知内容已经形成,可以进入后续判断阶段;返回partial,说明认知结果尚有信息缺口,需要由运行引擎根据任务要求决定是否补充信息;返回inconsistent,说明场景数据存在结构或关系冲突,应当进入异常处理;返回insufficient,说明当前信息不足以支持所需认知,不能直接进入依赖这些信息的判断环节。

认知处理与运行引擎之间可以建立统一接口:

<?php

interface CognitionInterface
{
    public function process($context);
}

运行引擎通过该接口调用认知处理程序,避免直接依赖具体的场景对象和属性处理类。

<?php

class CognitionStage
{
    private $cognitionProcessor;
    private $resultValidator;

    public function __construct(
        $cognitionProcessor,
        $resultValidator
    ) {
        $this->cognitionProcessor = $cognitionProcessor;
        $this->resultValidator = $resultValidator;
    }

    public function execute($context)
    {
        $result = $this->cognitionProcessor->process(
            $context
        );

        if (
            !isset($result['success']) ||
            !$result['success']
        ) {
            return array(
                'success' => false,
                'stage' => 'cognition',
                'status' => 'failed',
                'result' => $result
            );
        }

        $validation = $this->resultValidator->validate(
            $result
        );

        if (!$validation['valid']) {
            return array(
                'success' => false,
                'stage' => 'cognition',
                'status' => 'invalid_result',
                'validation' => $validation
            );
        }

        return array(
            'success' => true,
            'stage' => 'cognition',
            'status' => $result['status'],
            'cognition_result' => $result
        );
    }
}

这里的CognitionStage负责将认知处理封装为运行引擎能够调用的阶段程序。它不负责替代运行内核,也不负责直接形成后续决策。认知处理结果经过验证后,才返回给运行引擎。

运行引擎可以按照任务定义组织完整的处理阶段:

<?php

class RuntimeKernel
{
    private $contextManager;
    private $cognitionStage;
    private $judgmentStage;
    private $decisionStage;

    public function __construct(
        $contextManager,
        $cognitionStage,
        $judgmentStage,
        $decisionStage
    ) {
        $this->contextManager = $contextManager;
        $this->cognitionStage = $cognitionStage;
        $this->judgmentStage = $judgmentStage;
        $this->decisionStage = $decisionStage;
    }

    public function processTask($task)
    {
        $context = $this->contextManager->create(
            $task
        );

        $cognition = $this->cognitionStage->execute(
            $context
        );

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

        if (
            $cognition['status'] !== 'completed'
        ) {
            return array(
                'success' => false,
                'stage' => 'cognition',
                'status' => $cognition['status'],
                'result' => $cognition
            );
        }

        $context['cognition_result'] =
            $cognition['cognition_result'];

        $judgment = $this->judgmentStage->execute(
            $context
        );

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

        $context['judgment_result'] = $judgment;

        return $this->decisionStage->execute(
            $context
        );
    }
}

上述程序展示了认知阶段与后续判断、决策阶段的基本衔接关系。这里假设认知结果必须达到completed才能进入后续处理。实际工程中,还可以根据任务定义允许部分认知结果进入特定判断环节。例如,某项任务只需要确认对象类型,不要求读取全部对象属性,那么只要对象类型和相关结构已经确认,就可以继续执行该任务对应的判断。但这种处理必须由任务要求和已赋予的规则确定,不能由认知程序自行降低任务要求。

运行引擎还需要处理认知过程中的动态变化。如果认知处理期间场景信息发生变化,原有认知结果可能不再适用。此时,运行引擎应当根据数据更新时间、对象状态变化和任务阶段决定是否重新采集信息、更新场景数据并重新执行认知处理。对于已经完成的设备操作,不能仅因认知结果更新就自动重复执行;需要将新的认知结果与原有执行记录结合起来判断。

个体认知处理程序还应当支持本地独立运行。通信模式下,个体可以将认知结果和相关运行记录同步到智能控制后台;无通信模式下,认知处理依赖本地已经赋值的知识结构、能力和运行数据完成。只要当前任务所需知识能力已经部署,且运行条件和执行约束允许,认知程序就可以在本地运行环境中形成认知结果。

如果当前场景中出现了本地已有结构无法匹配的新对象,或者当前对象关系超出了已赋予个体的知识能力范围,个体应当记录具体缺口,形成反馈信息。通信可用时,可以将反馈发送到智能控制后台;通信不可用时,则保存在本地,待通信恢复后同步。后续由后台开展需求分析、知识结构化构建、能力验证和重新赋值。

这也说明,个体认知并不是一个封闭的固定处理程序。它依赖后台已经形成并赋予的知识能力,同时通过运行反馈为后台后续知识构建提供实际依据。后台负责知识能力的形成、调整和验证,个体负责在本地运行环境中使用已赋予的知识能力完成认知处理。两者通过赋值和反馈形成持续联系,但不需要将全部智能构建过程放到每个个体内部重复实现。

本章建立的认知处理程序,完成了从当前场景信息到结构化认知结果的工程组织。其核心不是增加一个独立的认知模块,而是在个体自主运行链中建立场景数据、知识结构匹配、对象属性关系处理和认知结果形成之间的程序联系。

经过这一处理,个体能够将分散的实际对象信息组织为具有明确结构关系的当前场景认知结果,并将其交给后续判断程序。认知结果说明个体当前掌握了哪些场景信息、对象之间存在什么关系、对象处于什么状态,以及哪些信息仍然缺失或存在冲突。至于当前条件是否满足任务要求、是否允许执行某项操作,则需要由后续判断程序进一步处理。

下一章将进入第三十二章 个体判断与条件分析,研究如何利用本章形成的结构化认知结果,对对象属性、状态、关系、任务条件和执行约束进行判断,形成能够支持后续决策的条件分析结果。

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小时技术值守