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

第二十八章 个体知识能力调用

第二十八章 个体知识能力调用

个体完成运行信息获取、对象识别和结构匹配后,需要根据当前任务和实际对象状态,调用已经赋予自身的知识结构与知识能力,对当前问题进行处理。知识能力调用是连接个体运行信息与后续认知、判断、决策及方法执行的重要工程环节。它决定个体如何从已加载的知识结构中检索所需内容,如何确定当前任务适用的能力,如何选择具体方法,以及如何将多个方法组织成能够完成任务的连续处理过程。

在WSaiOS工程架构中,知识能力的构建和验证由智能控制后台负责。后台依据需求驱动智能机制,对需求进行理解和结构分析,组织知识结构化构建,形成知识能力,并完成相应验证。经过验证的知识能力按照个体职能和任务要求进行智能赋值,进入个体运行环境。个体在自主运行时,主要负责对已赋值的知识结构和知识能力进行检索、识别、调用与组合,不需要在每次任务执行时重新构建完整的知识体系。

因此,个体知识能力调用并不是简单地根据一个任务名称查找一个程序函数,也不是将所有知识结构和方法预先写入固定业务流程。它需要根据当前运行上下文、对象结构匹配结果、任务目标、能力定义、方法关联和执行规则,建立从任务需求到知识能力、从知识能力到具体方法的调用关系。

本章所研究的知识能力调用,主要解决知识结构检索、能力识别与调用、方法匹配与选择、多方法组合以及调用结果处理等工程问题。通过这些机制,使个体能够根据实际运行信息调用不同的知识能力,并将处理结果交给后续自主运行判断和决策过程。

1. 个体知识结构的检索

个体知识结构检索的工程目标,是根据当前任务和运行信息,从本地已经加载的知识结构中找到与当前处理对象、任务条件和问题内容相对应的结构定义及其关联数据。知识结构检索不是单纯查询某个文件或数据库记录,而是需要结合结构定义、对象实例、属性、关系、状态和结构版本,形成能够支持能力调用的完整知识结构上下文。

在第二十七章中,个体已经建立了外部对象与内部对象实例之间的对应关系,并通过属性、状态和关系匹配形成运行信息。第二十八章的知识结构检索需要利用这些匹配结果,找到对应的知识结构定义及其关联内容。检索过程应当优先使用已经建立的对象映射和结构标识,避免在每次调用时重新识别相同对象。

例如,机器人在执行通道巡检任务时,已经识别出机器人对象、通道对象和障碍物对象,并取得各对象的当前属性和状态信息。此时,个体需要根据当前任务检索与机器人移动、通道通行、障碍物识别和避障处理有关的知识结构,而不是重新读取全部知识库。检索结果应当包括对象所对应的结构定义、结构关系、必要属性、状态条件以及与这些结构相关联的能力定义。

知识结构检索必须区分结构定义和对象实例。结构定义描述某类对象的组成方式、属性、关系和方法;对象实例保存某个具体对象的标识、属性值和当前状态。检索时需要同时取得两类信息,但不能把对象实例中的某个属性值直接当作结构定义的一部分。

例如,structure_robot描述机器人对象的通用结构,object_robot_001表示某个具体机器人实例。个体检索机器人结构时,需要取得structure_robot的定义,同时取得object_robot_001的当前属性和状态。这样,能力调用既能使用通用知识结构,又能根据具体对象的实际运行情况进行处理。

个体知识结构检索还需要考虑结构版本。个体接受智能赋值时,后台会将适用于该个体的结构、能力和方法版本关联到赋值清单。运行期间,检索程序必须依据当前有效赋值版本加载结构,不能任意使用本地其他版本的结构定义。否则,可能出现能力定义使用新版本,而对象实例仍按照旧版本组织的情况,导致属性和关系不一致。

因此,知识结构检索应当与个体赋值版本、结构版本和运行上下文保持一致。结构版本不匹配时,检索程序需要返回明确的版本异常,而不是自动选取一个名称相同的结构继续执行。

工程目录可以组织为:

IndividualRuntime/
└── individual_001/
    ├── structures/
    │   ├── definitions/                 # 已赋值知识结构定义
    │   ├── elements/                    # 结构元素及其属性、方法定义
    │   ├── relations/                   # 结构元素之间的关系定义
    │   ├── states/                      # 结构对象的状态定义
    │   ├── indexes/                     # 结构检索索引
    │   └── versions/                    # 结构版本与赋值版本关联记录
    │
    ├── capabilities/
    │   ├── definitions/                 # 已赋值知识能力定义
    │   ├── structure_maps/              # 能力与知识结构的关联
    │   └── indexes/                     # 知识能力检索索引
    │
    ├── retrieval/
    │   ├── StructureRepository.php      # 知识结构查询接口
    │   ├── StructureIndex.php            # 结构索引管理
    │   ├── StructureResolver.php         # 结构关联解析
    │   ├── StructureDependencyLoader.php # 结构依赖加载
    │   ├── StructureVersionChecker.php   # 结构版本检查
    │   └── KnowledgeRetrievalManager.php # 知识结构检索组织
    │
    └── runtime/
        └── RuntimeContext.php            # 当前任务及对象运行上下文

上述目录中,definitions保存完整的结构定义,elements保存结构元素信息,relations保存结构关系,states保存状态定义,indexes保存便于检索的索引数据,versions保存结构版本与个体赋值版本之间的关联。retrieval负责组织检索过程,但不负责修改知识结构本身。

知识结构检索需要建立统一的查询入口。查询条件不应局限于结构名称,还应当支持结构标识、对象标识、元素标识、关系标识、任务关联和能力依赖等查询条件。具体采用哪些条件,应当根据当前任务和已取得的运行信息确定。

可以建立知识结构检索请求:

{
    "retrieval_id": "retrieval_000021",
    "individual_id": "individual_001",
    "task_id": "task_000105",
    "assignment_version": "3.0",
    "object_ids": [
        "object_robot_001",
        "object_corridor_001",
        "object_obstacle_001"
    ],
    "structure_ids": [
        "structure_robot",
        "structure_corridor",
        "structure_obstacle"
    ],
    "required_relations": [
        "relation_robot_position",
        "relation_corridor_obstacle"
    ],
    "retrieval_status": "pending"
}

该请求描述当前任务需要检索的对象和结构范围,同时保留任务标识和赋值版本。检索程序根据这些条件读取本地结构定义,并解析其关联的元素、属性、关系和状态定义。

在数据库层面,可以通过结构定义表、结构元素表、结构关系表和结构版本表组织数据:

CREATE TABLE individual_structure_definitions (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    individual_id VARCHAR(64) NOT NULL,
    structure_id VARCHAR(64) NOT NULL,
    structure_version VARCHAR(32) NOT NULL,
    structure_name VARCHAR(128),
    definition_data LONGTEXT NOT NULL,
    assignment_version VARCHAR(32),
    structure_status VARCHAR(30),
    created_at DATETIME,
    updated_at DATETIME,
    UNIQUE KEY uk_structure_version (
        individual_id,
        structure_id,
        structure_version
    )
);

CREATE TABLE individual_structure_elements (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    individual_id VARCHAR(64) NOT NULL,
    structure_id VARCHAR(64) NOT NULL,
    structure_version VARCHAR(32),
    element_id VARCHAR(64) NOT NULL,
    element_type VARCHAR(40),
    element_definition LONGTEXT,
    created_at DATETIME,
    KEY idx_structure_element (
        individual_id,
        structure_id,
        element_id
    )
);

CREATE TABLE individual_structure_relations (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    individual_id VARCHAR(64) NOT NULL,
    structure_id VARCHAR(64) NOT NULL,
    structure_version VARCHAR(32),
    relation_id VARCHAR(64) NOT NULL,
    source_element VARCHAR(64),
    target_element VARCHAR(64),
    relation_type VARCHAR(40),
    relation_definition LONGTEXT,
    created_at DATETIME,
    KEY idx_structure_relation (
        individual_id,
        structure_id,
        relation_id
    )
);

结构定义表保存知识结构的完整定义及版本,结构元素表保存结构内部元素,结构关系表保存元素之间的关系。实际工程中还需要将结构属性、状态定义和方法关联按照已经确立的数据模型组织,避免所有信息都以不受约束的文本形式存储。

知识结构检索程序应当先检查当前个体是否具有相应的赋值记录,再根据赋值版本检索结构定义,随后解析结构依赖。结构依赖是指某个结构在运行时需要引用的其他结构、元素、关系、状态定义或方法定义。如果只检索到主结构,而没有加载其必要依赖,后续能力调用就可能因为缺少关联信息而失败。

可以采用如下程序组织:

<?php

class KnowledgeRetrievalManager
{
    private $structureRepository;
    private $versionChecker;
    private $dependencyLoader;

    public function __construct(
        $structureRepository,
        $versionChecker,
        $dependencyLoader
    ) {
        $this->structureRepository = $structureRepository;
        $this->versionChecker = $versionChecker;
        $this->dependencyLoader = $dependencyLoader;
    }

    public function retrieve(array $request)
    {
        $individualId = $request['individual_id'];
        $assignmentVersion = $request['assignment_version'];

        $result = array();

        foreach ($request['structure_ids'] as $structureId) {
            $structure = $this->structureRepository->find(
                $individualId,
                $structureId
            );

            if (!$structure) {
                return array(
                    'status' => 'structure_not_found',
                    'structure_id' => $structureId
                );
            }

            $versionResult = $this->versionChecker->check(
                $structure,
                $assignmentVersion
            );

            if (!$versionResult['valid']) {
                return array(
                    'status' => 'version_mismatch',
                    'structure_id' => $structureId
                );
            }

            $dependencies = $this->dependencyLoader->load(
                $structure
            );

            $result[$structureId] = array(
                'definition' => $structure,
                'dependencies' => $dependencies
            );
        }

        return array(
            'status' => 'retrieved',
            'individual_id' => $individualId,
            'assignment_version' => $assignmentVersion,
            'structures' => $result
        );
    }
}

该程序展示了知识结构检索的基本调用关系。首先根据个体标识和结构标识查询本地结构定义,然后检查其版本是否与当前赋值版本相容,再加载结构依赖。只有结构及其必要依赖均能够满足当前运行条件时,才将检索结果交给后续能力识别程序。

在实际工程中,结构检索还需要考虑缓存。对于频繁使用且版本稳定的结构,可以在个体运行内存或本地缓存中保留已解析的结构对象,减少重复读取。但是缓存必须与结构版本绑定。结构版本发生变化时,应当使对应缓存失效,不能让个体继续使用旧结构处理新任务。

知识结构检索的最终结果不是一个简单的结构文件路径,而是包含结构定义、结构元素、关系、状态、版本和依赖信息的运行结构集合。该集合将作为能力识别与调用的知识依据。

2. 个体能力的识别与调用

个体知识结构检索完成后,需要根据当前任务确定应该调用哪一种或哪几种知识能力。知识结构描述对象及其属性、关系和方法,知识能力则是利用这些结构及其方法解决特定问题的能力。结构检索与能力调用之间存在关联,但两者不能混为一谈。

同一知识结构可以支持不同能力。同一个机器人结构,既可以支持位置判断,也可以支持路径通行判断、障碍物处理和设备状态检查。反过来,一个知识能力也可能需要多个知识结构共同支持。例如,机器人避障能力可能同时依赖机器人结构、障碍物结构、通道结构和空间关系结构。

因此,个体能力识别不能只根据当前对象的结构名称决定,而应当结合当前任务目标、对象匹配结果、必要属性、状态条件、能力定义及其结构依赖进行判断。

能力识别的工程目标,是从个体已经接受智能赋值的能力集合中,找出当前任务可以使用的能力,并确认其调用条件是否满足。这里的能力集合是个体实际获得的赋值范围,不是后台全部知识能力的完整集合。即使智能控制后台已经构建某种能力,如果该能力没有赋予当前个体,个体也不能自行调用。

个体能力定义应当包含能力标识、能力名称、能力适用对象、能力目标、关联结构、必要属性、前置条件、关联方法、执行规则和版本信息。这样,运行引擎才能根据当前上下文判断能力是否适用。

例如:

{
    "capability_id": "capability_obstacle_avoidance",
    "capability_name": "obstacle_avoidance",
    "capability_version": "1.1",
    "assignment_version": "3.0",
    "target_objects": [
        "structure_robot",
        "structure_obstacle",
        "structure_corridor"
    ],
    "required_attributes": [
        "position",
        "distance",
        "movement_direction"
    ],
    "required_relations": [
        "relation_robot_obstacle",
        "relation_robot_corridor"
    ],
    "required_states": [
        "robot_ready"
    ],
    "methods": [
        "method_distance_compare",
        "method_path_condition_check",
        "method_obstacle_direction_check"
    ],
    "rules": [
        "rule_safe_distance",
        "rule_allowed_movement"
    ],
    "capability_status": "enabled"
}

该能力定义描述了避障能力需要使用的对象结构、属性、关系、状态、方法和规则。它并不是一段直接控制电机的程序,而是一个可以由个体运行引擎识别和组织的能力定义。具体方法实现和设备控制接口仍由相应程序负责。

能力识别程序需要检查当前任务是否与能力目标相符,并检查必要的知识结构是否已经检索、对象是否匹配、关键属性是否有效、状态条件是否满足、方法是否存在以及执行规则是否允许调用。

能力识别结果应当区分可调用、条件不足、能力未赋值、版本不一致、能力停用和执行条件不允许等状态。不能把所有失败情况都返回为“未找到能力”,否则无法准确确定后续应当采取重新采集信息、补充赋值还是暂停任务等处理方式。

在工程目录中,可以建立:

capabilities/
├── definitions/                     # 个体已赋值能力定义
├── assignments/                     # 能力与个体的赋值关联
├── indexes/                         # 能力检索索引
├── conditions/                      # 能力调用条件定义
├── dependencies/                    # 能力依赖的结构和方法
├── results/                         # 能力调用结果记录
└── runtime/
    ├── CapabilityResolver.php       # 当前任务适用能力识别
    ├── CapabilityMatcher.php        # 能力与运行上下文匹配
    ├── CapabilityConditionChecker.php # 能力调用条件检查
    ├── CapabilityLoader.php         # 能力定义和依赖加载
    ├── CapabilityDispatcher.php     # 能力调用分发
    └── CapabilityInvocation.php     # 能力调用过程管理

能力识别与调用需要保持明确的程序边界。CapabilityResolver负责从已赋值能力集合中检索候选能力,CapabilityMatcher负责判断能力与当前运行上下文是否对应,CapabilityConditionChecker负责检查调用条件,CapabilityLoader负责加载能力定义及其依赖,CapabilityDispatcher负责将调用请求交给对应的能力处理程序。

能力识别可以采用以下基本逻辑:

<?php

class CapabilityMatcher
{
    private $capabilityRepository;
    private $conditionChecker;

    public function __construct(
        $capabilityRepository,
        $conditionChecker
    ) {
        $this->capabilityRepository = $capabilityRepository;
        $this->conditionChecker = $conditionChecker;
    }

    public function identify(
        $individualId,
        $task,
        $context
    ) {
        $capabilities = $this->capabilityRepository
            ->findAssignedByTask(
                $individualId,
                $task['task_type']
            );

        $matched = array();

        foreach ($capabilities as $capability) {
            if ($capability['capability_status'] !== 'enabled') {
                continue;
            }

            $check = $this->conditionChecker->check(
                $capability,
                $context
            );

            $matched[] = array(
                'capability_id' => $capability['capability_id'],
                'available' => $check['available'],
                'reasons' => $check['reasons']
            );
        }

        return $matched;
    }
}

该程序首先从当前个体已经赋值的能力集合中查询与任务类型有关的能力,然后逐一检查能力状态和运行条件。需要注意,任务类型只是检索候选能力的一个条件,不能单独作为能力调用依据。最终是否可以调用,还要由能力定义中的结构、属性、状态、关系和规则条件决定。

能力识别完成后,个体还需要确定调用顺序和调用方式。某些能力可以独立调用,某些能力必须依赖其他能力的处理结果,还有些能力需要多个能力共同完成任务。能力之间的依赖关系应当在后台知识能力构建和赋值过程中定义,并由个体在运行时按照已赋予的关联关系进行组织。

例如,机器人执行移动任务时,可能需要先调用位置识别能力,再调用路径条件判断能力,最后调用移动控制相关能力。若位置识别能力未能提供有效结果,路径判断能力就不能直接使用过期位置数据继续处理。个体需要根据能力依赖关系检查前置能力是否已经完成,以及其结果是否满足后续能力的输入要求。

能力调用应当建立唯一的调用记录,并关联任务、对象、能力版本、赋值版本、结构匹配结果和调用时间。这样,后续可以追踪某次运行为什么选择某种能力,以及该能力实际使用了哪些知识结构和方法。

能力调用记录可以采用如下数据模型:

{
    "invocation_id": "invocation_000051",
    "individual_id": "individual_001",
    "task_id": "task_000105",
    "capability_id": "capability_obstacle_avoidance",
    "capability_version": "1.1",
    "assignment_version": "3.0",
    "input_context_id": "context_000105",
    "invocation_status": "prepared",
    "created_at": "2026-11-15 10:40:00"
}

该记录用于建立一次能力调用的完整追踪入口。能力执行完成后,还需要追加输入摘要、方法执行记录、规则检查结果、输出结果和最终调用状态。

3. 方法匹配与方法选择

知识能力并不是一个孤立的程序函数。它由知识结构、结构关系和相关方法共同形成。方法是具体操作,负责对输入信息进行比较、计算、判断、匹配、概率处理、排序和验证等运算。能力则依据问题解决目标,将多个结构要素和方法组织起来,形成可以处理某一类问题的整体能力。

因此,个体完成能力识别后,还需要根据能力定义和当前运行上下文,确定具体需要调用哪些方法。方法匹配解决当前处理任务需要什么操作,方法选择则解决在满足条件的方法中采用哪一种实现。

例如,机器人需要判断与障碍物之间的距离是否满足安全要求。该任务可能需要调用距离读取方法、数值比较方法和安全条件判断方法。若障碍物具有运动状态,还需要调用运动方向判断方法。能力定义规定了这些方法之间的关联关系,而运行引擎根据当前输入信息和方法调用条件选择实际可用的方法。

方法定义与方法实现需要分开管理。方法定义描述方法标识、输入、输出、适用对象、执行条件和调用关系;方法实现则是实际运行的程序代码或设备接口调用程序。这样,方法的结构定义可以与具体程序实现保持关联,但不会被混为一体。

方法定义可以采用以下数据结构:

{
    "method_id": "method_distance_compare",
    "method_name": "distance_compare",
    "method_type": "comparison",
    "input": [
        "current_distance",
        "safe_distance"
    ],
    "output": [
        "comparison_result"
    ],
    "operation": "compare",
    "applicable_structures": [
        "structure_robot",
        "structure_obstacle"
    ],
    "preconditions": [
        "distance_valid"
    ],
    "implementation": "DistanceCompareMethod",
    "method_version": "1.0",
    "method_status": "enabled"
}

这里的operation表示方法执行的具体操作类型,implementation表示实际程序实现的关联标识。方法定义不直接包含完整的业务执行过程,而是由方法注册表将方法标识与经过验证的程序实现关联起来。

方法匹配首先需要检查方法是否存在于个体已赋值的方法集合中,然后检查输入数据是否齐全、数据类型是否符合要求、适用结构是否与当前对象匹配、方法前置条件是否满足,以及方法版本是否与当前能力版本兼容。

方法选择不能只依靠方法名称,也不能因为某个方法可以执行就认为它适合当前任务。相同的输入信息可能支持不同的处理方法,但具体选择必须遵循能力定义和执行规则。例如,比较两个数值可以使用普通数值比较方法,但对于带有单位的物理量,需要先确认单位一致或完成单位转换,再执行比较操作。

对于存在多个可用方法的情况,可以根据已赋予的选择规则确定采用方式。选择规则可以包括方法适用范围、输入完整性、执行约束、资源要求、执行优先级和版本兼容性。不能在没有依据的情况下任意选择一个方法,也不能将所有方法都执行一遍后再决定哪个结果有效。

在程序组织上,可以建立方法注册、方法检索、方法匹配和方法分发程序:

methods/
├── definitions/                     # 方法结构定义
├── implementations/                 # 方法程序实现
├── registry/
│   ├── MethodRegistry.php           # 方法标识与实现注册
│   └── MethodVersionRegistry.php    # 方法版本管理
├── matching/
│   ├── MethodResolver.php           # 方法检索
│   ├── MethodMatcher.php            # 方法适用性匹配
│   ├── MethodInputValidator.php     # 方法输入验证
│   └── MethodSelector.php           # 方法选择
└── execution/
    ├── MethodDispatcher.php         # 方法调用分发
    ├── MethodExecutor.php           # 方法执行组织
    └── MethodResult.php             # 方法执行结果

MethodRegistry维护方法标识与实际实现之间的对应关系;MethodResolver根据能力定义检索所需方法;MethodMatcher检查方法与当前对象及上下文的适用性;MethodInputValidator验证输入;MethodSelector按照能力关联和规则确定调用方法;MethodDispatcher负责实际调用。

方法接口可以采用统一定义:

<?php

interface RuntimeMethodInterface
{
    public function getMethodId();

    public function validateInput(array $input);

    public function execute(array $input, array $context);
}

具体方法实现需要遵循这一接口。例如:

<?php

class DistanceCompareMethod implements RuntimeMethodInterface
{
    public function getMethodId()
    {
        return 'method_distance_compare';
    }

    public function validateInput(array $input)
    {
        return isset($input['current_distance'])
            && isset($input['safe_distance'])
            && is_numeric($input['current_distance'])
            && is_numeric($input['safe_distance']);
    }

    public function execute(array $input, array $context)
    {
        if (!$this->validateInput($input)) {
            return array(
                'status' => 'invalid_input'
            );
        }

        $distance = floatval($input['current_distance']);
        $safeDistance = floatval($input['safe_distance']);

        return array(
            'status' => 'success',
            'comparison' => $distance > $safeDistance
                ? 'greater'
                : ($distance < $safeDistance
                    ? 'less'
                    : 'equal')
        );
    }
}

该方法只负责完成两个距离数值的比较,不负责决定机器人是否移动,也不直接操作设备。比较结果交由所属知识能力继续处理。例如,安全距离比较结果为less时,能力可能继续调用条件判断方法,检查当前运动状态、障碍物方向和可用空间,再将结果交给后续决策过程。

方法执行程序还需要检查方法实现是否与方法定义匹配。方法标识相同并不代表程序实现一定正确,必须通过赋值时的验证记录、版本记录和运行时输入检查保证调用关系有效。个体不能绕过后台验证机制,随意加载一个未被赋值或未被允许的程序实现。

方法选择还需要区分能力内部的方法调用与运行引擎对能力的选择。运行引擎首先选择适用能力,再由能力定义确定其关联方法。不能把方法选择直接提升为独立的任务决策,否则可能出现方法能够执行,但其所属能力并不适用于当前任务的情况。

4. 多个方法的组合调用

复杂任务通常不能依靠一个方法完成。知识能力需要根据问题结构和处理目标,将多个方法按照一定的依赖关系、执行顺序和条件关系组合起来。多个方法组合调用,是将基础操作组织为完整问题处理过程的工程机制。

方法组合不是简单地将多个函数依次执行。不同方法之间可能存在输入依赖、结果依赖、条件分支和执行约束。某个方法的输出可能是下一个方法的输入,某个方法的结果也可能决定是否继续执行其他方法。因此,方法组合必须依据能力定义中已经建立的关联关系组织执行。

例如,机器人执行障碍物处理任务时,可能先读取机器人与障碍物之间的距离,再比较距离与安全距离,随后判断障碍物是否处于当前行驶路径,最后根据判断结果形成可通行条件。这里的距离读取、数值比较、路径关系判断和条件验证属于不同方法,但它们共同构成障碍物处理能力中的一个处理链。

其调用关系可以表示为:

当前任务与运行上下文
        ↓
障碍物对象信息
        ↓
距离信息读取
        ↓
距离比较方法
        ↓
路径关系判断方法
        ↓
安全条件判断方法
        ↓
组合处理结果
        ↓
提交自主运行判断

如果距离比较结果表明障碍物距离足够远,后续处理可以按照能力定义继续判断路径关系;如果距离低于安全要求,则需要进入相应的限制条件处理分支。方法组合的分支关系应当来自已经赋值的能力定义和执行规则,不能在运行时随意生成未验证的执行路径。

方法组合可以采用有向依赖关系描述。每个方法节点具有唯一标识、输入来源、输出标识、执行条件和依赖节点。方法节点之间的连接关系描述执行顺序和数据传递关系。这样,运行引擎可以根据组合定义建立执行计划,并检查是否存在缺失方法、循环依赖或输入输出不匹配。

方法组合定义可以采用以下结构:

{
    "composition_id": "composition_obstacle_001",
    "capability_id": "capability_obstacle_avoidance",
    "composition_version": "1.0",
    "steps": [
        {
            "step_id": "step_001",
            "method_id": "method_distance_compare",
            "input_source": "runtime_context.distance",
            "output_target": "result.distance_comparison",
            "depends_on": []
        },
        {
            "step_id": "step_002",
            "method_id": "method_path_condition_check",
            "input_source": "runtime_context.path",
            "output_target": "result.path_condition",
            "depends_on": [
                "step_001"
            ]
        },
        {
            "step_id": "step_003",
            "method_id": "method_safe_condition_check",
            "input_source": "result",
            "output_target": "result.safe_condition",
            "depends_on": [
                "step_001",
                "step_002"
            ]
        }
    ],
    "composition_status": "enabled"
}

该示例定义了三个方法之间的依赖关系。第二个方法依赖第一个方法的处理结果,第三个方法同时依赖前两个方法的结果。具体输入映射、数据类型和执行条件需要在能力定义及方法定义中进一步明确。

方法组合程序需要解决方法依赖解析、输入数据准备、方法执行、结果传递、条件分支、失败处理和组合结果生成等问题。不能只建立一个循环,按数组顺序执行所有方法,因为实际组合关系可能包含并行处理、条件分支和可选步骤。

对于存在并行条件的处理过程,如果多个方法之间不存在数据依赖,并且各自的运行资源允许,可以由调度程序分别执行。对于存在依赖关系的方法,则必须等待前置方法完成并取得有效结果后,才能启动后续方法。

对于存在条件分支的方法组合,应当根据前置方法结果选择已经定义的分支。例如,障碍物距离比较结果为less时,进入限制移动的处理分支;结果为greater时,进入进一步路径条件判断。每个分支都必须具有明确的进入条件和退出条件,不能将不确定结果默认解释为安全结果。

方法组合还需要处理执行失败。如果某个方法输入不完整、执行超时、返回异常或结果不符合定义,组合调用程序必须停止依赖该结果的后续步骤,并记录失败位置。对于不依赖该方法的其他处理分支,可以根据能力定义决定是否继续。对于关键方法失败的情况,则应当将整个能力调用标记为未完成或失败。

可以建立方法组合执行程序:

<?php

class MethodCompositionExecutor
{
    private $methodDispatcher;
    private $dependencyResolver;

    public function __construct(
        $methodDispatcher,
        $dependencyResolver
    ) {
        $this->methodDispatcher = $methodDispatcher;
        $this->dependencyResolver = $dependencyResolver;
    }

    public function execute(
        array $composition,
        array $context
    ) {
        $steps = $this->dependencyResolver->resolve(
            $composition['steps']
        );

        if (!$steps['valid']) {
            return array(
                'status' => 'invalid_composition',
                'errors' => $steps['errors']
            );
        }

        $results = array();

        foreach ($steps['ordered_steps'] as $step) {
            $input = $this->buildInput(
                $step,
                $context,
                $results
            );

            if (!$input['valid']) {
                return array(
                    'status' => 'input_unavailable',
                    'failed_step' => $step['step_id']
                );
            }

            $result = $this->methodDispatcher->dispatch(
                $step['method_id'],
                $input['data'],
                $context
            );

            if ($result['status'] !== 'success') {
                return array(
                    'status' => 'method_failed',
                    'failed_step' => $step['step_id'],
                    'method_result' => $result,
                    'completed_results' => $results
                );
            }

            $results[$step['step_id']] = $result;
        }

        return array(
            'status' => 'completed',
            'composition_id' => $composition['composition_id'],
            'results' => $results
        );
    }

    private function buildInput(
        array $step,
        array $context,
        array $results
    ) {
        return array(
            'valid' => true,
            'data' => array(
                'context' => $context,
                'previous_results' => $results,
                'input_source' => $step['input_source']
            )
        );
    }
}

该示例展示方法组合执行的基本组织方式。首先解析方法之间的依赖关系,再按依赖顺序准备输入,随后调用方法分发程序,并保存每一步的结果。示例中的buildInput()只展示输入组织接口,正式实现需要根据方法定义中的输入字段、输出标识和数据映射规则,提取实际数据,不能直接把上下文和全部历史结果无差别地传递给每个方法。

方法组合还需要与运行上下文关联。每个组合调用应当保存组合标识、能力标识、方法列表、输入数据引用、执行顺序、方法版本和执行结果。这样,当任务出现异常时,可以根据执行记录追踪是哪一个方法产生了异常,前置方法提供了什么输入,以及后续方法是否已经执行。

对于实体设备和机器人控制场景,方法组合还需要明确计算方法与设备操作方法之间的边界。距离比较、关系判断和条件验证属于信息处理方法;移动、制动、启动和停止等属于涉及外部设备的执行方法。后者不能因为前面的计算方法已经完成就自动执行,还必须经过后续自主运行判断、决策形成和执行规则检查。第二十八章中的方法组合主要解决能力内部的信息处理和方法组织问题,不替代后续章节对行为执行和设备控制的工程设计。

多个方法组合的定义和版本也必须与能力版本关联。后台发布新版本能力时,应当同时明确其方法依赖和组合定义。个体只有在相应版本通过赋值和初始化验证后,才能使用新的方法组合。旧版本组合需要保留必要的历史记录,避免任务恢复时找不到原有方法执行依据。

5. 能力调用结果的处理

知识能力调用完成后,个体还需要对调用结果进行统一组织、有效性检查和运行上下文更新。能力调用结果不是一个简单的返回值,而是反映当前能力依据哪些知识结构、对象信息和方法处理了什么问题,以及最终得出了什么处理结果。

能力调用结果需要能够被后续认知、判断和决策过程直接使用,同时还应当支持运行记录、异常分析和反馈管理。因此,结果处理必须保留能力标识、任务标识、对象标识、结构版本、方法执行记录、输入信息引用、结果状态和完成时间等信息。

例如,机器人调用避障能力后,结果可能包含障碍物对象标识、当前位置、距离比较结果、路径关系判断结果和安全条件判断结果。这个结果并不等同于最终决策,也不直接表示机器人已经完成避障动作。它只是说明当前知识能力已经完成规定的信息处理,并形成了可供后续自主运行判断使用的结果。

能力调用结果应当区分成功完成、部分完成、条件不足、调用失败、执行中断和结果待确认等状态。不同状态对应不同的后续处理方式。成功完成的结果可以进入后续判断环节;部分完成的结果可能需要补充信息或调用其他能力;条件不足时需要重新获取信息;调用失败时需要检查能力依赖和方法实现;结果待确认时则不能作为确定性判断依据。

能力结果还需要进行结构化组织。建议统一采用如下结果模型:

{
    "result_id": "capability_result_000051",
    "invocation_id": "invocation_000051",
    "individual_id": "individual_001",
    "task_id": "task_000105",
    "capability_id": "capability_obstacle_avoidance",
    "capability_version": "1.1",
    "assignment_version": "3.0",
    "input_objects": [
        "object_robot_001",
        "object_obstacle_001",
        "object_corridor_001"
    ],
    "method_results": {
        "method_distance_compare": "less",
        "method_path_condition_check": "blocked",
        "method_safe_condition_check": "restricted"
    },
    "result_data": {
        "obstacle_detected": true,
        "path_available": false,
        "safe_condition": "restricted"
    },
    "result_status": "completed",
    "created_at": "2026-11-15 10:45:00"
}

该结果说明,个体通过已赋值的避障能力处理了机器人、障碍物和通道对象之间的关系,方法组合得出了路径受阻和安全条件受限的结果。该信息应当提交给后续自主运行判断和决策过程,由后续环节依据任务目标和执行规则确定下一步处理方式。

能力结果处理首先需要检查方法执行是否完整。某些能力可能包含多个方法,如果其中一个关键方法失败,即使其他方法已经产生结果,也不能将整个能力调用标记为完整成功。结果组织程序需要依据能力定义中的关键方法和必要结果,判断调用是否满足完成条件。

其次需要检查结果是否符合能力定义的输出结构。方法返回值可能在程序层面没有异常,但其数据结构、字段类型或结果范围可能不符合能力要求。例如,某个判断方法应该返回明确的条件判断结果,却返回了无法识别的字符串。此时,能力结果处理程序应当将其标记为输出格式异常,不能直接提交给后续处理。

再次,需要检查结果所依据的信息是否仍然有效。对于运行环境变化较快的任务,能力调用可能持续一段时间。在调用期间,机器人位置、障碍物位置或设备状态可能已经变化。如果结果使用的是过期信息,即使方法执行过程完全成功,也可能不再适用于当前运行环境。因此,结果处理需要关联输入信息的采集时间和版本,并根据任务要求检查结果有效期限。

能力调用结果还需要与当前运行上下文建立关联。运行引擎应当将结果写入上下文,供后续认知、判断和决策程序读取。对于同一个任务中的多个能力调用,应当明确各个结果之间的依赖关系,避免后续程序读取到其他任务或旧版本能力的结果。

在程序组织上,可以建立能力结果验证、结果保存、上下文更新和结果分发程序:

capabilities/
└── results/
    ├── CapabilityResult.php              # 能力结果数据对象
    ├── CapabilityResultValidator.php     # 能力输出完整性检查
    ├── CapabilityResultRepository.php    # 能力结果保存
    ├── CapabilityResultProcessor.php     # 调用结果处理
    ├── RuntimeContextUpdater.php         # 运行上下文更新
    └── CapabilityResultDispatcher.php    # 结果向后续程序分发

CapabilityResultValidator检查结果字段、方法完成情况和结果有效性;CapabilityResultRepository保存调用记录和结果数据;CapabilityResultProcessor组织结果处理;RuntimeContextUpdater将有效结果写入当前运行上下文;CapabilityResultDispatcher将结果提交给后续认知和判断程序。

能力结果处理程序可以采用以下基本实现:

<?php

class CapabilityResultProcessor
{
    private $validator;
    private $repository;
    private $contextUpdater;

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

    public function process(
        array $capability,
        array $result,
        array $context
    ) {
        $validation = $this->validator->validate(
            $capability,
            $result,
            $context
        );

        if (!$validation['valid']) {
            $result['result_status'] = 'invalid_result';
            $result['validation_errors'] = $validation['errors'];

            $this->repository->save($result);

            return array(
                'status' => 'rejected',
                'errors' => $validation['errors']
            );
        }

        $result['result_status'] = 'completed';

        $saved = $this->repository->save($result);

        if (!$saved) {
            return array(
                'status' => 'save_failed'
            );
        }

        $updated = $this->contextUpdater->update(
            $context['context_id'],
            $result
        );

        if (!$updated) {
            return array(
                'status' => 'context_update_failed',
                'result_id' => $result['result_id']
            );
        }

        return array(
            'status' => 'processed',
            'result' => $result
        );
    }
}

该程序首先验证能力结果,再保存结果记录,最后将有效结果更新到运行上下文。正式工程中,结果持久化和上下文更新需要考虑事务一致性及异常恢复。如果结果已经保存,但上下文更新失败,运行引擎应当能够根据调用标识恢复处理,而不是重新执行全部方法。对于可能触发外部设备操作的方法,还需要通过调用标识和执行记录避免重复执行。

能力结果进入运行上下文后,并不意味着任务已经完成。它只是为后续认知、判断和决策提供依据。个体还需要结合当前任务目标、对象状态、执行规则和其他能力结果,形成下一阶段的处理过程。

例如,避障能力返回“路径受阻”后,个体还需要进一步判断是否存在其他可用通道,是否允许等待障碍物移开,是否需要调整任务路径,或者是否需要请求中央控制后台重新组织任务。这些属于后续自主运行判断和决策处理范畴,不能在能力调用结果处理程序中直接把某一种方法结果当成最终执行命令。

能力调用结果还承担运行反馈的作用。当某项能力经常因为缺少某个属性而无法完成,或者当前赋值的方法无法处理某种新情况时,个体需要记录失败条件、缺失信息、涉及结构和相关任务,形成反馈数据。反馈数据提交给智能控制后台后,后台可以分析其是否构成新的需求,是否需要扩展知识结构,是否需要增加方法,是否需要形成新的知识能力,以及是否需要向其他个体重新赋值。

需要强调的是,个体调用结果的异常并不必然意味着知识能力定义错误。异常可能来自外部信息缺失、传感器故障、对象映射错误、结构版本不一致、方法输入异常、执行资源不足或实际环境超出当前能力范围。反馈进入后台之前,应当尽可能保留这些区别,避免把所有运行失败都归结为知识缺口。

能力结果处理也需要支持无通信运行。通信中断时,个体仍然可以在本地保存调用结果、方法执行记录和运行上下文,继续调用已经赋值的其他能力。恢复通信后,再按照同步规则将必要记录提交给智能控制后台。后台可以依据这些结果进行项目规划、需求分析、知识能力调整和后续智能赋值。

由此,能力调用结果形成了个体自主运行与后台自主智能进化学习之间的连接。个体通过本地能力调用完成当前任务处理,后台则利用运行反馈发现新的需求和知识能力缺口,进一步推动知识结构化构建和能力更新。

本章小结

个体知识能力调用建立了从已赋值知识结构到实际问题处理能力的运行通道。个体首先根据当前任务和运行信息检索相应的知识结构,取得结构定义、元素、属性、关系、状态和版本信息;随后从已经赋值的能力集合中识别适用能力,检查其结构依赖、输入条件和执行规则;再依据能力定义检索并选择具体方法,按照方法之间的依赖关系组织多个方法组合调用。

在方法调用过程中,知识能力与方法始终保持不同层次。知识能力是利用知识结构和方法组合形成的问题处理能力,方法是具体执行比较、计算、判断、匹配、概率处理、排序和验证等操作的程序。个体运行引擎负责依据能力定义组织方法调用,而不是将方法名称直接等同于能力,也不是把单个方法的执行结果直接当成最终决策。

能力调用完成后,个体还需要检查结果完整性、输出结构、信息有效性和版本一致性,将有效结果写入运行上下文,并交给后续认知、判断和决策程序。无法完成的调用则需要记录原因,区分信息缺失、结构不匹配、能力未赋值、方法执行失败和知识能力缺口等不同情况。

本章建立的工程机制,使个体能够利用后台已经构建、验证并赋予的知识能力,在自身运行环境中自主检索知识、识别能力、选择方法、组合调用并处理结果。个体不需要复制智能控制后台的完整知识构建智能,而是根据自身职能调用已经获得的知识能力,并将实际运行中的新问题和能力缺口反馈给后台。

下一章将在知识能力调用的基础上,进一步研究个体如何依据当前任务、对象状态、运行条件和已赋值执行规则,判断是否具备自主运行条件,以及如何确定当前任务能否由个体独立处理。

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