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

第四十章 个体执行闭环与运行验证

第四十章 个体执行闭环与运行验证

  1. 任务输入至执行结果的完整流程

  2. 执行结果与预期目标的比较

  3. 执行状态与运行数据记录

  4. 执行失败后的处理与恢复

  5. 个体执行闭环的工程测试

第四十章 个体执行闭环与运行验证

个体执行闭环是WSaiOS个体自主运行工程的完整性验证环节。前面各章已经分别建立了个体运行环境、信息获取、对象识别、知识能力调用、自主运行判断、认知处理、条件判断、决策形成、方法组织、行为执行以及外部设备控制接口。本章需要将这些已经建立的工程机制连接起来,从任务输入开始,经过信息获取、结构匹配、认知、判断、决策、方法形成、行为组织、外部接口调用和实际执行结果获取,最终完成预期目标验证,并根据执行结果决定后续处理路径。

个体执行闭环不是简单地将一组程序按照固定顺序依次运行。实际任务具有动态性,外部对象、环境条件、设备状态和执行结果都可能在运行过程中发生变化。个体必须根据当前任务和实际反馈持续判断执行条件是否仍然成立,并根据结果选择继续执行、等待、暂停、恢复、重新判断或者结束任务。

例如,仓库机器人接收到物料搬运任务后,首先需要获取物料、机器人和运输路线的信息,识别相关对象并匹配已经赋予的知识结构。随后,个体判断当前承载能力、设备状态、路线条件和执行权限是否满足要求,再根据判断结果形成决策,选择适当的搬运方法,组织导航、定位、抓取、运输和释放等行为。行为执行过程中,机器人持续获取位置、物料状态和设备反馈,确认每一个必要步骤是否完成。最终,个体还需要检查物料是否真正到达指定位置,以及任务目标是否已经实现。

如果机器人在运输过程中遇到通道阻塞,原有执行路径就可能失效。个体不能仅仅因为已经形成了搬运指令,就继续执行原计划,而应当根据新的环境信息重新认知和判断。若现有知识能力能够处理当前情况,可以在原有职责和约束范围内重新组织行为;若出现知识能力缺口,则需要保存现场状态和异常信息,等待后台处理或人工干预。

因此,本章的工程重点是建立从任务输入到执行结果的连续数据链和程序调用链,形成预期目标与实际结果之间的验证机制,并通过运行记录、异常处理和恢复机制,使个体能够在动态环境中保持执行过程的连续性和可追溯性。

需要明确的是,个体执行闭环属于WSaiOS应用工程实现,不改变WSaiOS结构智能理论已经确立的核心逻辑。知识结构化构建、知识能力形成与验证、个体智能赋值以及整体任务组织仍然由WSaiOS智能控制后台负责。个体在获得相应知识能力、方法和执行规则后,依据本地运行环境自主完成具体任务,并将执行反馈提供给后台,构成整个WSaiOS工程的运行闭环。

第一节 任务输入至执行结果的完整流程

个体执行闭环首先需要建立完整的任务处理流程。任务输入是整个运行过程的起点,但任务输入本身并不代表任务已经具备执行条件。个体接收到任务后,需要检查任务结构、任务对象、任务目标、所需能力、执行范围和任务上下文,再根据已经赋予的知识能力进行信息获取和处理。

任务输入可以来自WSaiOS智能控制后台,也可以来自个体本地任务队列、预先部署的任务配置或者允许自主接收的外部业务接口。不同来源的任务都需要转换为个体运行引擎能够识别的任务数据结构。

对于由中央控制后台下发的任务,个体需要检查任务标识、目标个体、任务内容、赋值版本和任务约束,确认该任务确实属于当前个体的职责范围。对于无通信运行模式下预先部署的任务,个体则需要根据本地保存的任务定义、有效版本和执行规则进行检查。不能因为任务数据已经存在本地,就认为任务可以无条件执行。

拟定的任务输入数据结构如下:

{
    "task_id": "task_000128",
    "task_type": "material_transport",
    "individual_id": "robot_001",
    "task_source": "central_control",
    "task_target": {
        "object_id": "material_0001",
        "source_location": "area_A",
        "target_location": "area_B"
    },
    "required_capabilities": [
        "material_transport",
        "route_navigation",
        "object_grasp"
    ],
    "expected_result": {
        "material_state": "stored",
        "target_location": "area_B"
    },
    "execution_constraints": {
        "operation_scope": "assigned_area",
        "safety_check_required": true
    },
    "assignment_version": "assignment_001",
    "task_status": "received"
}

任务进入个体运行引擎后,首先由任务接收程序进行数据解析和有效性检查。随后,个体调用第二十九章建立的自主运行判断机制,检查任务要求与当前赋值能力是否匹配,判断当前运行环境、资源、对象信息、执行权限和安全条件是否满足要求。

任务通过自主运行判断后,才进入后续认知和处理过程。这里需要注意,任务接收、任务有效性检查和自主运行判断是不同阶段。任务接收只表示个体获得了任务数据;任务有效性检查确认任务数据可以被正确解析;自主运行判断则确认个体是否具备在当前条件下承担和执行任务的资格。

接下来,个体通过第二十七章的信息获取和对象识别机制获取当前场景信息,建立外部对象实例,并根据第二十八章的知识能力调用机制检索已经赋予的知识结构和能力。第三十一章的认知处理程序将当前场景与已有知识结构匹配,形成对象、属性、关系和状态的结构化认知结果。

认知结果形成后,个体进入第三十二章的判断过程,根据任务目标、对象状态、运行环境、方法前提和执行规则分析当前条件。判断结果提供给第三十三章和第三十四章的决策处理程序,用于建立决策依据、分析候选路径和确定当前处理方式。

决策结果确定之后,第三十五章的决策结果与方法形成机制根据实际需求、已有知识能力和运行条件形成相应方法。第三十六章负责执行方法的数据定义、程序实现映射和方法调用。第三十七章再将决策结果和执行方法组织为行为指令与行为流程,第三十八章则通过外部对象和设备控制接口,将内部方法调用转换为实际的软件操作或设备控制指令。

外部执行结果返回之后,个体通过结果解析、对象状态更新和行为验证机制确认实际执行情况。结果符合当前目标时,可以继续后续行为步骤;如果结果不符合预期,则需要重新判断当前条件,必要时重新决策或调整方法。

因此,完整执行流程并不是单向的线性程序,而是由任务处理主流程和运行过程中的反馈分支共同构成。

任务输入
   |
   v
任务接收与有效性检查
   |
   v
自主运行判断
   |
   v
信息获取与对象识别
   |
   v
知识能力匹配与调用
   |
   v
认知处理
   |
   v
条件判断
   |
   v
决策依据与决策形成
   |
   v
执行方法形成
   |
   v
执行方法调用
   |
   v
行为指令与行为流程组织
   |
   v
外部对象与设备控制
   |
   v
实际执行结果获取
   |
   v
执行结果验证
   |
   +------符合预期------> 后续步骤/任务完成
   |
   +------条件变化------> 重新认知与判断
   |
   +------方法不足------> 能力缺口反馈
   |
   +------异常发生------> 暂停、恢复或人工干预

这一流程中的每个环节都应当形成可追溯的数据对象。任务输入对应任务实例,认知处理对应认知结果,判断过程对应判断记录,决策过程对应决策结果,方法形成对应方法实例,行为组织对应行为实例,外部设备调用对应外部指令和调用记录,最终执行结果对应结果验证记录。

这些数据对象通过稳定标识建立关联,形成从任务到实际执行结果的完整追溯链。个体运行引擎可以通过任务标识查询整个处理过程,也可以从某一次设备控制记录反向追溯到对应行为、方法、决策和任务。

在程序组织上,建议将完整执行流程的协调程序设置在个体运行引擎内部,而不是把全部逻辑集中写在一个任务处理文件中。这样可以使每个工程环节独立维护,并通过明确接口形成连续调用。

拟定的目录结构如下:

IndividualRuntime/
├── execution/
│   ├── workflow/
│   │   ├── IndividualExecutionWorkflow.php   # 组织完整任务执行流程
│   │   ├── ExecutionStageResolver.php        # 确定当前任务处理阶段
│   │   ├── ExecutionStageDispatcher.php      # 调度各阶段处理程序
│   │   └── ExecutionDependencyResolver.php   # 检查阶段之间的依赖关系
│   ├── task/
│   │   ├── TaskInputReceiver.php             # 接收外部或本地任务输入
│   │   ├── TaskDefinitionReader.php          # 读取任务定义
│   │   ├── TaskInputValidator.php             # 验证任务输入数据
│   │   └── TaskContextBuilder.php             # 建立任务执行上下文
│   ├── integration/
│   │   ├── CognitionStageAdapter.php         # 调用认知处理程序
│   │   ├── JudgmentStageAdapter.php          # 调用判断处理程序
│   │   ├── DecisionStageAdapter.php          # 调用决策处理程序
│   │   ├── MethodStageAdapter.php            # 调用方法形成与调用程序
│   │   ├── BehaviorStageAdapter.php          # 调用行为执行程序
│   │   └── ExternalStageAdapter.php          # 调用外部设备接口
│   └── result/
│       ├── ExecutionResultCollector.php      # 收集各阶段执行结果
│       ├── ExecutionResultBuilder.php        # 建立完整执行结果
│       └── ExecutionResultRepository.php     # 保存任务执行结果

IndividualExecutionWorkflow是整个任务执行闭环的协调入口。它不直接实现对象识别、认知、判断、决策或设备控制,而是根据当前任务状态调用相应的程序组件。这样既能保持各章工程机制之间的衔接,也能避免形成一个无法独立验证和维护的庞大程序。

以下给出拟定的完整执行流程组织示例,采用PHP 7.0.10兼容语法:

<?php

class IndividualExecutionWorkflow
{
    private $taskValidator;
    private $readinessChecker;
    private $stageDispatcher;
    private $resultCollector;

    public function __construct(
        $taskValidator,
        $readinessChecker,
        $stageDispatcher,
        $resultCollector
    ) {
        $this->taskValidator = $taskValidator;
        $this->readinessChecker = $readinessChecker;
        $this->stageDispatcher = $stageDispatcher;
        $this->resultCollector = $resultCollector;
    }

    public function run($task, $context)
    {
        $validation = $this->taskValidator->validate(
            $task
        );

        if (empty($validation['valid'])) {
            return array(
                'status' => 'rejected',
                'reason' => '任务输入验证失败'
            );
        }

        $readiness = $this->readinessChecker->check(
            $task,
            $context
        );

        if (empty($readiness['ready'])) {
            return array(
                'status' => 'waiting',
                'reason' => '个体当前不具备执行条件',
                'details' => $readiness
            );
        }

        $stages = array(
            'information',
            'cognition',
            'judgment',
            'decision',
            'method',
            'behavior',
            'external_execution',
            'result_verification'
        );

        foreach ($stages as $stage) {
            $result = $this->stageDispatcher->dispatch(
                $stage,
                $task,
                $context
            );

            $this->resultCollector->collect(
                $task['task_id'],
                $stage,
                $result
            );

            if (!isset($result['status']) ||
                $result['status'] !== 'completed') {
                return array(
                    'status' => isset($result['status'])
                        ? $result['status']
                        : 'unknown',
                    'current_stage' => $stage,
                    'result' => $result
                );
            }
        }

        return array(
            'status' => 'completed',
            'task_id' => $task['task_id']
        );
    }
}

该程序用于说明完整任务执行的协调关系。实际工程中,阶段不能全部无条件按照数组顺序执行。认知、判断、决策和行为执行之间可能存在循环关系;某一阶段也可能返回等待、能力缺口、暂停、需要重新判断等状态。因此,正式实现时应当由ExecutionStageResolver根据阶段结果和任务上下文决定下一步,而不是只依靠固定数组。

例如,机器人在导航过程中发现通道已经关闭,行为执行程序返回recheck_required,执行协调程序就应当重新调用信息获取、认知和判断程序,而不是继续执行原来的抓取和运输步骤。若发现当前个体不具备新的绕行能力,则应当将能力缺口记录下来,停止超出当前赋值范围的操作。

这种可循环的执行组织方式,才是个体执行闭环区别于普通固定流程程序的关键。它使个体能够根据实际环境和运行反馈改变当前处理路径,同时保持每一次处理都能够追溯到任务、知识能力、决策和执行规则。

第二节 执行结果与预期目标的比较

个体完成某个行为或方法调用之后,必须进一步判断实际结果是否达到任务预期目标。执行结果与预期目标比较,是整个执行闭环中确认任务是否真正完成的核心机制。

预期目标来自任务定义和决策结果,实际结果来自外部对象反馈、设备状态、软件处理结果以及对象状态变化。两者需要转换为可以比较的结构化数据,再根据目标定义和判断方法进行比较。

预期目标不是单一的结果字符串,而是由目标对象、目标属性、目标状态、目标关系和完成条件共同构成。例如,仓库机器人搬运物料的预期目标不仅是机器人到达某个位置,还包括物料已经被抓取、运输路线已经完成、物料已经放置到目标区域,以及物料最终状态符合任务要求。

如果只检查机器人是否到达目标位置,就不能证明物料搬运任务已经完成。因为机器人可能到达了区域B,但物料仍然留在货架A;也可能机器人已经放下物料,但物料位置不符合指定范围。因此,必须根据任务目标建立完整的结果比较条件。

预期目标数据需要与任务输入保持关联,并且在任务开始时形成目标快照。对于运行过程中允许变化的目标,可以通过经过验证的决策更新机制建立新的目标版本,保留原始目标和调整依据,避免直接覆盖导致执行结果失去比较基准。

拟定的预期目标数据如下:

{
    "target_definition_id": "target_000128",
    "task_id": "task_000128",
    "target_objects": [
        {
            "object_id": "material_0001",
            "expected_attributes": {
                "material_state": "stored",
                "location": "area_B"
            }
        },
        {
            "object_id": "robot_001",
            "expected_attributes": {
                "operation_status": "ready"
            }
        }
    ],
    "completion_conditions": {
        "material_stored": true,
        "target_location_confirmed": true,
        "robot_safe_state": true
    },
    "target_version": "1.0.0"
}

实际执行结果则需要根据外部反馈形成对应结构。例如,机器人通过设备接口返回实际位置,通过传感器确认物料是否已经释放,通过对象状态管理程序确认物料当前所在区域,再将这些信息组织为结构化结果。

{
    "actual_result_id": "actual_result_000128",
    "task_id": "task_000128",
    "observed_objects": [
        {
            "object_id": "material_0001",
            "actual_attributes": {
                "material_state": "stored",
                "location": "area_B"
            },
            "data_source": "object_sensor",
            "verification_status": "verified"
        },
        {
            "object_id": "robot_001",
            "actual_attributes": {
                "operation_status": "ready"
            },
            "data_source": "device_controller",
            "verification_status": "verified"
        }
    ],
    "result_time": "2026-11-15 10:10:00"
}

目标比较程序需要根据目标定义中的对象和属性关系,解析实际结果,并调用相应的比较、判断、匹配和验证方法。对于简单的数值属性,可以检查实际值是否处于允许范围;对于状态属性,可以检查实际状态是否属于目标状态;对于对象关系,则需要确认对象之间的实际关系是否符合预期。

不同类型的目标不能采用同一种比较方式。例如,位置坐标可以根据允许误差进行比较,设备运行状态需要根据状态定义进行判断,物料是否已经存放则需要检查物料与目标区域之间的实际关系。对于多条件目标,需要根据条件之间的AND、OR和依赖关系进行综合判断。

尤其需要避免把所有执行结果转换成一个简单的数值评分,再用统一阈值判断任务成功。不同任务的目标具有不同语义和约束,必须根据知识结构中的属性定义、方法定义和任务目标确定相应的验证方法。

拟定的目标比较程序目录如下:

IndividualRuntime/
├── execution/
│   ├── comparison/
│   │   ├── ExpectedTargetReader.php          # 读取任务预期目标
│   │   ├── ActualResultReader.php             # 读取实际执行结果
│   │   ├── TargetObjectMatcher.php            # 匹配预期对象与实际对象
│   │   ├── AttributeResultComparator.php      # 比较对象属性结果
│   │   ├── StateResultComparator.php          # 比较对象状态结果
│   │   ├── RelationResultComparator.php       # 比较对象关系结果
│   │   └── TargetConditionEvaluator.php       # 综合判断目标完成条件
│   ├── verification/
│   │   ├── ResultEvidenceResolver.php         # 解析结果验证依据
│   │   ├── ResultSourceChecker.php            # 检查结果数据来源
│   │   ├── ResultFreshnessChecker.php         # 检查数据时间有效性
│   │   ├── ResultConsistencyChecker.php       # 检查多来源结果一致性
│   │   └── TargetVerificationBuilder.php      # 建立目标验证结果
│   └── difference/
│       ├── TargetDifferenceAnalyzer.php       # 分析目标与实际结果的差异
│       ├── DifferenceImpactAnalyzer.php      # 分析差异对任务的影响
│       └── DifferenceHandlingResolver.php     # 确定差异处理路径

比较程序不仅需要得出符合或不符合的结论,还需要保留具体差异。例如,目标位置是区域B,实际位置是区域C;目标状态是stored,实际状态仍然是available;要求机器人返回ready状态,而实际设备仍处于running状态。差异记录可以帮助个体确定下一步是继续执行、补充操作、重新判断还是停止任务。

比较结果应当支持至少四种状态:符合、不符合、未知和部分符合。符合表示所有必要目标条件均已得到验证;不符合表示存在明确的目标偏差;未知表示缺少足够证据或结果存在冲突;部分符合表示部分目标已经完成,但仍有必要条件未完成。

例如,机器人已经将物料放置到区域B,但机器人自身仍处于故障状态。如果任务要求物料存放完成且机器人恢复到可接收任务状态,那么当前结果只能认定为部分符合,不能直接认定整个任务完成。

拟定的目标比较结果如下:

{
    "comparison_id": "comparison_000128",
    "task_id": "task_000128",
    "target_version": "1.0.0",
    "actual_result_id": "actual_result_000128",
    "conditions": [
        {
            "condition_id": "condition_001",
            "target": "material_state=stored",
            "actual": "material_state=stored",
            "result": "satisfied"
        },
        {
            "condition_id": "condition_002",
            "target": "location=area_B",
            "actual": "location=area_B",
            "result": "satisfied"
        },
        {
            "condition_id": "condition_003",
            "target": "robot_status=ready",
            "actual": "robot_status=ready",
            "result": "satisfied"
        }
    ],
    "overall_result": "matched",
    "verification_status": "verified"
}

比较结果必须建立在有效的实际信息之上。如果设备返回的状态已经过期,或者多个传感器对同一对象给出互相冲突的数据,就不能直接认定目标已经满足。此时需要重新获取对象信息,必要时重新进行认知和判断。

此外,预期目标与实际结果比较还需要考虑任务目标是否发生过合法调整。某些动态任务在执行过程中可能因为环境变化而改变目标路线或处理对象,但目标调整必须来自有效的决策过程,并且保留原目标、调整后的目标和调整依据。不能为了让执行结果看起来成功,而在任务完成之后随意修改目标定义。

当比较结果为不符合或部分符合时,个体需要进一步分析差异的性质。如果只是某个可补充步骤尚未执行,可以继续组织行为;如果外部对象状态发生变化,则需要重新认知和判断;如果方法执行失败,则需要进入异常处理;如果当前知识能力无法解决差异,则需要反馈后台。

因此,结果比较不仅用于判断任务是否完成,也为下一阶段的自主运行提供依据。

第三节 执行状态与运行数据记录

完整的执行闭环需要保存持续运行过程中产生的状态和数据。没有完整记录,个体就无法准确判断当前执行到什么阶段,也无法在程序中断、设备异常或通信恢复后恢复原有任务,更无法对执行结果进行追溯和验证。

执行数据记录不能只保存任务开始和结束时间,而应当覆盖任务输入、运行上下文、认知结果、判断结果、决策结果、方法实例、行为步骤、外部调用、设备反馈、结果比较和最终任务状态。

这些数据属于不同的工程对象,不能全部写入同一个任务记录字段。应当根据数据用途分别建立任务主记录、阶段处理记录、行为执行记录、设备调用记录、状态变化记录和结果验证记录,并通过任务标识和阶段标识建立关联。

首先,任务主记录用于保存任务整体信息,包括任务标识、个体标识、任务来源、目标版本、赋值版本、当前状态和最终结果。任务执行过程中,任务状态随着实际处理阶段发生变化,但历史状态不能被简单覆盖。

其次,阶段处理记录用于保存任务经过认知、判断、决策、方法形成和行为执行等环节的处理情况。每个阶段需要记录开始时间、结束时间、输入数据引用、输出数据引用、处理状态和异常信息。

再次,方法和行为执行记录用于保存具体执行步骤。方法调用记录需要关联方法定义版本、程序实现版本、参数、返回结果和异常;行为执行记录需要关联行为实例、行为步骤、外部对象和实际执行结果。

最后,状态变化记录用于保存外部对象和个体运行状态的变化。例如机器人从ready变为running,物料从available变为grasped,路线从open变为blocked,都需要记录变化来源和时间。

拟定的运行记录数据可以采用如下结构:

{
    "execution_record_id": "execution_record_000128",
    "task_id": "task_000128",
    "individual_id": "robot_001",
    "assignment_version": "assignment_001",
    "execution_stage": "behavior_execution",
    "stage_status": "running",
    "related_objects": [
        "robot_001",
        "material_0001",
        "route_001"
    ],
    "related_records": {
        "cognition_id": "cognition_000128",
        "judgment_id": "judgment_000128",
        "decision_id": "decision_000128",
        "behavior_instance_id": "behavior_instance_000128"
    },
    "started_at": "2026-11-15 10:00:00",
    "completed_at": null,
    "exception_id": null
}

在状态记录中,还需要区分任务状态、个体运行状态、行为状态、方法调用状态和外部设备状态。它们虽然相互影响,但不能使用同一套状态字段。

例如,任务可能处于running,个体运行状态可能是waiting,行为状态可能是suspended,而外部设备可能已经进入ready。出现这种状态组合并不一定意味着数据错误,因为个体可能正在等待新的任务条件,而设备本身已经处于待机状态。

因此,状态管理程序需要根据不同对象建立各自的状态转换规则,并通过任务上下文关联。不能因为任务进入completed,就直接将所有设备状态修改为ready;也不能因为个体处于error,就把所有外部对象的状态一并标记为error。

状态变化记录还需要保存变化原因。例如,机器人从running变为suspended,可能是因为安全条件触发、人工暂停、通信异常或者方法执行失败。只有保存具体原因,后续恢复程序才能选择正确的处理路径。

拟定的目录组织如下:

IndividualRuntime/
├── execution/
│   ├── record/
│   │   ├── ExecutionRecordBuilder.php        # 建立任务执行记录
│   │   ├── ExecutionRecordRepository.php     # 保存和读取执行记录
│   │   ├── ExecutionStageRecorder.php        # 保存各阶段处理情况
│   │   └── ExecutionTraceResolver.php        # 追溯完整执行过程
│   ├── state/
│   │   ├── TaskExecutionStateManager.php     # 管理任务执行状态
│   │   ├── IndividualRuntimeStateRecorder.php # 记录个体运行状态
│   │   ├── BehaviorExecutionStateRecorder.php # 记录行为执行状态
│   │   ├── ExternalObjectStateRecorder.php   # 记录外部对象状态
│   │   └── StateTransitionValidator.php      # 验证状态转换规则
│   ├── log/
│   │   ├── ExecutionEventLogger.php          # 记录执行事件
│   │   ├── ExecutionExceptionLogger.php      # 记录执行异常
│   │   ├── ExecutionAuditLogger.php          # 记录关键操作审计信息
│   │   └── ExecutionTraceLogger.php          # 记录程序调用链
│   └── checkpoint/
│       ├── ExecutionCheckpointBuilder.php   # 建立执行检查点
│       ├── ExecutionCheckpointRepository.php # 保存检查点数据
│       └── ExecutionSnapshotReader.php       # 读取运行快照

执行记录程序需要与实际执行程序保持适当的解耦。执行程序负责完成操作,记录程序负责保存过程数据。不能因为日志保存失败就假定外部设备操作没有发生,也不能在设备动作成功后因为数据库写入失败就直接重复设备操作。

对于具有物理副作用的设备控制,需要特别处理执行记录与实际设备动作之间的时间差。可以在发送指令前保存调用准备记录,收到外部确认后更新调用状态,设备反馈验证后再形成最终结果。即使程序在中途异常,也可以根据已有记录和设备状态判断实际执行到了哪个阶段。

例如,机器人抓取物料时,程序可以先保存grasp_command_prepared记录,再发送设备指令;设备返回已接收后保存command_accepted;传感器确认物料已经抓取后保存grasp_verified。如果程序在第二阶段之后发生异常,恢复时就可以查询设备任务状态和物料实际状态,而不是盲目重复抓取。

在数据库设计上,建议建立以下几类核心记录表:

CREATE TABLE individual_task_executions (
    id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
    task_id VARCHAR(100) NOT NULL,
    individual_id VARCHAR(100) NOT NULL,
    assignment_version VARCHAR(100) NOT NULL,
    target_version VARCHAR(50) NOT NULL,
    task_status VARCHAR(30) NOT NULL,
    current_stage VARCHAR(50) DEFAULT NULL,
    started_at DATETIME DEFAULT NULL,
    completed_at DATETIME DEFAULT NULL,
    created_at DATETIME NOT NULL,
    updated_at DATETIME DEFAULT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_task_individual (
        task_id,
        individual_id
    ),
    KEY idx_execution_status (
        task_status,
        current_stage
    )
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
CREATE TABLE individual_execution_stages (
    id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
    stage_record_id VARCHAR(100) NOT NULL,
    task_id VARCHAR(100) NOT NULL,
    individual_id VARCHAR(100) NOT NULL,
    stage_name VARCHAR(50) NOT NULL,
    stage_status VARCHAR(30) NOT NULL,
    input_reference VARCHAR(150) DEFAULT NULL,
    output_reference VARCHAR(150) DEFAULT NULL,
    error_data LONGTEXT,
    started_at DATETIME DEFAULT NULL,
    completed_at DATETIME DEFAULT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_stage_record (
        stage_record_id
    ),
    KEY idx_task_stage (
        task_id,
        stage_name
    )
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
CREATE TABLE individual_execution_events (
    id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
    event_id VARCHAR(100) NOT NULL,
    task_id VARCHAR(100) NOT NULL,
    individual_id VARCHAR(100) NOT NULL,
    event_type VARCHAR(80) NOT NULL,
    object_id VARCHAR(100) DEFAULT NULL,
    previous_state VARCHAR(50) DEFAULT NULL,
    current_state VARCHAR(50) DEFAULT NULL,
    event_data LONGTEXT,
    event_time DATETIME NOT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_event_id (
        event_id
    ),
    KEY idx_task_event (
        task_id,
        event_time
    )
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
CREATE TABLE individual_execution_checkpoints (
    id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
    checkpoint_id VARCHAR(100) NOT NULL,
    task_id VARCHAR(100) NOT NULL,
    individual_id VARCHAR(100) NOT NULL,
    behavior_instance_id VARCHAR(100) DEFAULT NULL,
    current_stage VARCHAR(50) NOT NULL,
    checkpoint_data LONGTEXT NOT NULL,
    assignment_version VARCHAR(100) NOT NULL,
    created_at DATETIME NOT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY uk_checkpoint_id (
        checkpoint_id
    ),
    KEY idx_task_checkpoint (
        task_id,
        created_at
    )
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

以上数据库结构是拟定工程设计示例,实际项目还需要根据任务并发、设备执行频率和数据保留要求进行调整。尤其需要注意,执行记录不能只保留最新状态,还应当保留关键状态变化和外部调用历史,以便在发生异常时重建实际执行过程。

运行数据记录还需要处理不同数据的保存周期。任务定义、决策结果、方法实例和最终执行结果属于重要工程记录,应当长期保留相应版本和关联关系;高频传感器数据可能需要采用独立的数据存储方式,根据任务和设备要求保留原始数据或摘要;临时运行缓存则可以在任务完成并满足保留条件后清理。

数据记录本身也需要受到访问权限和完整性约束。个体只能修改自身允许管理的运行数据,关键执行记录应当保留来源和操作时间。涉及工业设备、机器人和无人机的关键控制行为,还应当保存必要的审计信息,以便在异常和事故分析时追溯实际控制过程。

通过完整的运行数据记录,个体才能形成可恢复、可分析和可验证的执行过程,为后续自主控制和智能进化提供可靠依据。

第四节 执行失败后的处理与恢复

个体自主运行环境并不总是能够按照预期条件完成任务。执行过程中可能发生信息缺失、对象状态变化、结构匹配失败、能力不足、方法调用异常、设备故障、资源不足、通信中断和执行结果不符合预期等情况。

因此,执行闭环必须具备失败处理和运行恢复机制。失败处理不是简单地将任务标记为failed,也不是发生异常后统一重新执行,而是根据异常发生阶段、实际执行状态、影响范围和可恢复性确定后续处理方式。

首先,需要区分不同类型的执行失败。任务输入异常通常发生在任务接收阶段,例如缺少目标对象、任务标识重复或者任务结构不完整。信息异常可能表现为传感器数据缺失、数据过期或者外部对象无法识别。知识能力异常表现为当前个体没有获得完成任务所需的结构、能力或方法。判断和决策异常可能表现为执行条件不满足、候选路径全部失效或者决策依据发生变化。方法执行异常则可能表现为程序错误、参数不合法或返回结果异常。设备执行异常可能表现为设备故障、接口超时、控制器拒绝执行或实际动作与指令不一致。

这些异常具有不同的处理路径。例如,信息缺失可以通过重新读取或补充数据处理;方法参数错误需要检查方法实例和映射关系;能力缺口需要反馈后台进行知识能力构建;设备故障可能需要暂停任务和人工维护;执行结果未知则需要先核实外部对象实际状态。

拟定的异常数据结构如下:

{
    "exception_id": "execution_exception_000128",
    "task_id": "task_000128",
    "individual_id": "robot_001",
    "behavior_instance_id": "behavior_instance_000128",
    "exception_type": "external_device_failure",
    "exception_stage": "external_execution",
    "related_object": "robot_device_001",
    "related_method": "robot_navigation",
    "exception_status": "unresolved",
    "impact_scope": "current_task",
    "recoverability": "conditional",
    "actual_execution_state": "unknown",
    "handling_path": "verify_device_state",
    "created_at": "2026-11-15 10:08:00"
}

其中,exception_stage用于确定异常发生位置,impact_scope用于描述异常影响范围,recoverability用于描述当前恢复可能性,actual_execution_state用于记录实际动作是否已经发生,handling_path用于确定后续处理方式。

异常处理程序需要首先保存异常事实,而不是立即修改任务状态或重新调用方法。随后分析异常是否影响当前任务目标、是否影响已经完成的行为步骤、是否涉及其他外部对象,以及是否存在可用的恢复方法。

恢复处理可以分为继续执行、重新获取信息、重新判断、重新决策、重新形成方法、重新建立外部连接、恢复行为流程、等待后台处理和人工干预等路径。

对于可恢复的软件执行异常,例如一次数据读取超时,可以在确认请求没有产生副作用的情况下重新读取。对于具有物理副作用的设备操作,例如机器人抓取、机械臂运动和无人机飞行,则必须先确认实际设备状态,再决定是否恢复或重新执行。

恢复过程的关键是不能把程序中断位置直接当作实际执行位置。程序可能已经发送设备指令,但尚未保存调用结果;设备可能已经完成动作,但传感器反馈尚未返回;也可能设备只执行了一部分动作。因此,恢复程序必须通过执行记录、外部任务标识、设备状态和对象信息重新确定实际状态。

例如,机器人执行抓取操作时发生控制程序中断。恢复程序不能简单地重新执行抓取方法,而应当先读取机械臂当前状态和物料位置。如果确认物料已经被抓取,则可以在安全条件满足的情况下恢复后续运输步骤;如果确认物料仍在原位置,则需要重新检查抓取条件;如果无法确定物料状态,则应当保持未知状态并暂停相关动作。

这也是执行检查点机制的重要作用。检查点保存的不只是程序运行位置,还应当包括任务标识、赋值版本、当前行为实例、已完成步骤、当前方法调用、对象状态快照、外部设备任务标识和异常信息。

拟定的恢复检查点数据如下:

{
    "checkpoint_id": "checkpoint_000128",
    "task_id": "task_000128",
    "individual_id": "robot_001",
    "assignment_version": "assignment_001",
    "behavior_instance_id": "behavior_instance_000128",
    "current_stage": "external_execution",
    "current_method_id": "robot_grasp",
    "completed_steps": [
        "robot_navigation",
        "robot_positioning"
    ],
    "current_execution": {
        "command_id": "external_command_000128",
        "device_task_id": "device_task_00128",
        "execution_state": "unknown"
    },
    "object_snapshot": {
        "material_0001": {
            "last_known_state": "available",
            "last_known_location": "area_A"
        }
    },
    "recovery_status": "pending_verification"
}

恢复程序读取检查点之后,还必须重新检查当前赋值版本和方法版本。如果个体在中断期间已经收到新的知识能力赋值,旧任务是否能够继续使用原版本,需要根据版本兼容规则和运行任务管理机制决定,不能直接混用新旧方法定义。

对于任务运行中发生的环境变化,还需要重新执行相关认知和判断过程。原来的决策结果只在其适用条件下有效。一旦影响决策依据的对象状态、环境状态或者执行约束发生变化,就应当重新验证原决策是否仍然成立。

例如,机器人运输物料时,原路线突然出现障碍。个体需要重新获取路线信息,更新相关对象状态,并重新判断原路线是否可用。如果已有知识能力包含绕行方法,可以在当前职责和安全约束范围内重新形成处理路径;如果没有相应能力,则应当停止原行为,保存当前状态并向后台反馈能力缺口。

对于涉及多个个体的任务,还需要区分单一个体失败和整体任务失败。某一个体出现异常,不代表整个任务必然终止。中央控制后台可以根据其他个体的能力、任务进度和组织关系重新安排整体任务,但单一个体不能自行将自己的任务转交给其他个体,也不能擅自改变整体分工。

无通信运行模式下,个体可以根据本地已经部署的恢复规则和知识能力处理允许自主恢复的异常。如果异常超出本地知识能力、涉及权限变化或者需要重新组织多个个体,则应当按照预先定义的处理规则暂停、等待或进入人工干预状态。通信恢复后,个体再将异常和恢复记录同步到后台。

建议建立以下恢复程序目录:

IndividualRuntime/
├── execution/
│   ├── exception/
│   │   ├── ExecutionExceptionCollector.php  # 收集执行过程中的异常
│   │   ├── ExecutionExceptionClassifier.php # 分类识别执行异常
│   │   ├── ExceptionImpactAnalyzer.php       # 分析异常影响范围
│   │   ├── ExceptionRecoverabilityChecker.php # 判断异常是否可恢复
│   │   └── ExceptionHandlingResolver.php    # 确定异常处理路径
│   ├── recovery/
│   │   ├── ExecutionRecoveryManager.php      # 组织完整执行恢复过程
│   │   ├── ExecutionCheckpointLoader.php     # 加载执行检查点
│   │   ├── ExecutionStateReconciler.php      # 核对程序与实际执行状态
│   │   ├── ExternalStateRecovery.php         # 重新获取外部对象状态
│   │   ├── BehaviorRecoveryController.php   # 恢复行为执行流程
│   │   └── RecoveryValidator.php             # 验证恢复条件
│   └── intervention/
│       ├── CentralFeedbackBuilder.php        # 建立后台异常反馈
│       ├── CapabilityGapReporter.php         # 报告知识能力缺口
│       ├── ManualInterventionManager.php     # 管理人工干预状态
│       └── ExecutionStopController.php       # 管理执行停止和安全处理

在恢复程序中,ExecutionStateReconciler尤其重要。它负责将检查点中的最后已知状态与当前实际状态进行核对,避免程序状态与外部设备状态不一致。只有核对结果满足恢复条件,才能允许行为流程继续。

以下给出拟定的恢复管理程序示例:

<?php

class ExecutionRecoveryManager
{
    private $checkpointLoader;
    private $stateReconciler;
    private $recoveryValidator;
    private $behaviorRecovery;

    public function __construct(
        $checkpointLoader,
        $stateReconciler,
        $recoveryValidator,
        $behaviorRecovery
    ) {
        $this->checkpointLoader = $checkpointLoader;
        $this->stateReconciler = $stateReconciler;
        $this->recoveryValidator = $recoveryValidator;
        $this->behaviorRecovery = $behaviorRecovery;
    }

    public function recover($taskId, $context)
    {
        $checkpoint = $this->checkpointLoader->load(
            $taskId
        );

        if (empty($checkpoint)) {
            return array(
                'status' => 'blocked',
                'reason' => '没有可用的执行检查点'
            );
        }

        $actualState = $this->stateReconciler->reconcile(
            $checkpoint,
            $context
        );

        if (!isset($actualState['verified']) ||
            !$actualState['verified']) {
            return array(
                'status' => 'waiting',
                'reason' => '实际执行状态尚未确认',
                'details' => $actualState
            );
        }

        $validation = $this->recoveryValidator->validate(
            $checkpoint,
            $actualState,
            $context
        );

        if (empty($validation['allowed'])) {
            return array(
                'status' => 'blocked',
                'reason' => '当前条件不允许恢复',
                'details' => $validation
            );
        }

        return $this->behaviorRecovery->resume(
            $checkpoint,
            $actualState,
            $context
        );
    }
}

该示例说明恢复程序必须先读取检查点,再核实实际状态,最后检查恢复条件。不能在没有实际状态核实的情况下,直接调用行为恢复程序。

对于已经无法通过本地知识能力恢复的异常,个体应当保存异常对象、影响范围、已完成操作、当前设备状态和缺失能力信息,并根据运行模式决定反馈后台或请求人工干预。后台接收到反馈后,可以分析知识结构缺口,重新构建知识能力并验证,再决定是否重新赋值。

由此,执行失败不再只是一个终止状态,而是成为个体运行闭环中的一个处理分支。通过异常分类、状态核实、检查点恢复和能力缺口反馈,个体能够在可控范围内处理运行中断,并将无法解决的问题交给后台智能构建和整体控制机制。

第五节 个体执行闭环的工程测试

个体执行闭环的工程测试,需要验证任务输入、认知处理、判断、决策、方法形成、行为执行、外部设备控制、结果比较、异常处理和恢复机制之间是否形成了真实有效的程序调用关系。

测试不能只检查某个PHP文件是否存在,也不能只检查程序语法是否正确。单个程序语法通过,只能说明代码在语法层面符合要求,不能证明不同模块之间能够正确传递数据,更不能证明外部设备已经完成实际动作。

因此,个体执行闭环需要分层验证。首先验证数据结构和接口关系,确认任务、对象、认知、判断、决策、方法、行为和执行结果之间的标识与数据关联正确。其次验证程序调用关系,确认各个处理阶段能够按照预定接口传递输入和输出。然后验证运行状态和异常处理,确认程序能够正确处理等待、失败、暂停和恢复。最后再通过真实软件对象或实际设备验证完整执行过程。

测试应当从最小运行单元逐步扩展到完整任务。最初可以验证任务输入程序、对象解析程序和结果比较程序,再验证认知、判断、决策和方法调用之间的衔接。之后建立模拟外部对象,检查行为指令是否正确转换、外部接口是否正确调用、返回数据是否能够转换为内部结构。完成软件层面的验证后,再接入实际设备进行设备级测试。

模拟测试和真实设备测试必须明确区分。模拟环境可以用于验证程序调用顺序、数据结构、异常分支和状态转换,但不能证明实际设备的物理行为符合预期。只有在真实设备和真实运行环境中完成接口调用、状态获取和结果验证,才能形成相应的设备运行验证结论。

首先需要验证任务输入和任务上下文。测试不同任务来源、任务字段缺失、目标对象不存在、个体标识不匹配、赋值版本失效和任务重复提交等情况,确认个体能够正确接收合法任务,并拒绝不符合要求的任务。

随后验证认知和判断过程。测试对象信息完整、对象属性缺失、数据过期、对象关系变化、环境状态改变和知识结构不匹配等情况,确认认知程序能够形成有效结果,判断程序能够正确识别满足、不满足和未知条件。

决策和方法形成测试则需要检查候选路径、执行约束、能力依赖和方法组合。应当验证在存在可行路径时能够形成相应决策,在没有可行路径时能够返回等待、能力缺口或禁止执行等结果,而不是强制生成一个无法执行的方法组合。

行为执行和外部控制测试需要检查方法顺序、前置依赖、控制参数映射、外部指令格式和接口适配。对于模拟设备,需要检查指令转换结果与预期协议是否一致;对于真实设备,需要确认控制器实际接收到指令,并且设备产生了符合预期的动作和状态变化。

结果验证测试则需要人为构造符合、不符合、部分符合和未知等不同结果,确认目标比较程序能够识别各种状态,并正确更新行为和任务状态。尤其要测试接口返回成功但设备实际未完成动作的情况,防止程序将接口调用成功误认为任务完成。

异常与恢复测试需要覆盖程序中断、设备掉线、通信中断、传感器数据缺失、外部状态冲突、方法执行失败和任务恢复等情况。需要确认个体在恢复之前能够重新获取实际对象状态,并根据检查点决定继续、等待、重新判断或者进入人工干预。

拟定的测试程序目录如下:

IndividualRuntime/
├── tests/
│   ├── task/
│   │   ├── TaskInputTest.php                 # 测试任务输入和数据验证
│   │   └── TaskReadinessTest.php             # 测试自主运行条件判断
│   ├── cognition/
│   │   ├── ObjectRecognitionTest.php         # 测试对象识别和结构匹配
│   │   └── CognitionResultTest.php           # 测试认知结果形成
│   ├── judgment/
│   │   ├── ConditionJudgmentTest.php         # 测试多条件判断
│   │   └── JudgmentExceptionTest.php         # 测试判断异常处理
│   ├── decision/
│   │   ├── DecisionProcessTest.php           # 测试决策过程
│   │   └── MethodFormationTest.php           # 测试方法形成
│   ├── behavior/
│   │   ├── BehaviorFlowTest.php              # 测试行为流程组织
│   │   └── BehaviorRecoveryTest.php           # 测试行为恢复
│   ├── external/
│   │   ├── AttributeMappingTest.php          # 测试外部属性映射
│   │   ├── CommandConversionTest.php         # 测试执行指令转换
│   │   └── ExternalInterfaceTest.php         # 测试外部接口调用
│   ├── execution/
│   │   ├── ResultComparisonTest.php          # 测试预期目标与实际结果比较
│   │   ├── ExecutionStateTest.php            # 测试运行状态转换
│   │   ├── ExecutionRecoveryTest.php         # 测试执行失败恢复
│   │   └── FullExecutionWorkflowTest.php     # 测试完整执行闭环
│   └── integration/
│       ├── SoftwareObjectIntegrationTest.php # 测试软件对象完整执行
│       ├── DeviceIntegrationTest.php         # 测试实体设备完整执行
│       └── IndividualRuntimeAcceptanceTest.php # 测试个体运行工程验收条件

为了避免测试只停留在程序内部,可以建立统一的任务执行测试数据。以下以仓库机器人搬运物料为例,定义一个完整的测试场景。

{
    "test_case_id": "full_execution_test_001",
    "task_id": "test_task_001",
    "individual_id": "robot_test_001",
    "scenario": "material_transport",
    "initial_state": {
        "robot_status": "ready",
        "material_state": "available",
        "source_location": "area_A",
        "target_location": "area_B",
        "route_status": "open"
    },
    "expected_result": {
        "material_state": "stored",
        "material_location": "area_B",
        "robot_status": "ready"
    },
    "test_mode": "simulation",
    "expected_execution_status": "completed",
    "expected_verification_status": "passed"
}

该测试场景首先用于模拟环境中的完整流程验证。测试程序向个体运行引擎输入任务,检查是否能够完成对象识别、认知、判断、决策和方法形成。随后检查行为指令是否正确建立,方法是否按照依赖顺序调用,外部模拟对象是否返回预期状态,最终比较结果是否能够正确认定任务完成。

在这一过程中,需要检查每个阶段的输入和输出是否与前一阶段保持关联。例如,决策结果引用的认知和判断标识必须属于当前任务,行为实例引用的方法实例必须属于当前有效赋值版本,外部执行指令引用的对象必须与行为实例中的目标对象一致。

测试不能只验证最终状态为completed,还必须检查中间记录。否则,即使某个程序直接将任务状态修改为completed,也可能绕过了实际的认知、判断和执行过程。

接下来需要进行异常场景测试。可以将路线状态从open修改为blocked,检查机器人是否停止原有导航步骤,重新获取路线信息,并根据当前知识能力重新判断是否存在可行路径。如果没有可行路径,应当返回等待或能力缺口处理结果,而不是继续向设备发送原有导航指令。

还需要模拟抓取指令已经发送但设备反馈丢失的情况。此时测试程序应当将执行状态设置为unknown,恢复程序需要读取原设备任务状态和物料实际状态。如果无法确认物料是否已经被抓取,就必须保持暂停,不能直接重复执行抓取动作。

对于真实设备测试,还应当在正式任务之外建立专门的测试环境和测试任务,明确设备运行范围、测试对象、安全限制和人工干预方式。测试期间应当先验证设备状态读取和无动作查询,再验证低风险控制操作,最后在具备安全条件时进行完整行为测试。涉及设备运动、机械臂抓取、无人机飞行和工业执行机构的测试,必须遵循设备自身安全规范,不能通过普通软件模拟结果代替实际安全验证。

测试数据和验证结果需要形成阶段性报告。报告应当保存测试环境、软件版本、知识能力赋值版本、外部设备型号、接口版本、测试任务、输入数据、预期结果、实际结果、异常情况和测试结论。对于没有进行真实设备测试的项目,应当明确标记为模拟验证或接口验证,不能将其描述为设备实际运行成功。

在整个测试过程中,还需要检查通信与无通信模式。通信模式下,个体应当能够接收后台任务、执行本地处理、返回运行状态和执行结果。无通信模式下,应当能够依靠本地已经部署的任务、知识能力、方法、设备接口和执行规则完成允许自主执行的任务。通信恢复后,应当能够同步任务状态、执行记录、对象变化和异常信息,并由后台进一步核对整体任务进展。

个体执行闭环的工程验收,最终应当能够证明:一个合法任务能够进入个体运行环境;个体能够依据已赋予的知识能力完成认知、判断和决策;决策结果能够形成具体方法和行为指令;方法能够通过对应控制接口作用于外部对象;外部对象的实际执行结果能够被获取和验证;运行状态和数据能够完整记录;发生异常时能够依据实际状态进行安全处理和恢复;任务完成后能够形成可以追溯的最终结果。

只有这些环节都具备相应的程序实现和验证证据,才能认定个体执行闭环在工程上形成。单个程序运行成功、单次接口调用成功或者模拟测试通过,都不能代替完整的个体执行闭环验收。

至此,第八篇“个体方法执行与自主控制工程”所涉及的执行方法、行为组织、外部对象接入、设备控制和执行闭环已经形成连续的工程体系。个体通过本地运行环境获得并调用已经赋予的知识能力,在自身职责和执行约束范围内完成自主行为,并通过实际运行反馈形成可追溯的执行结果。

这一执行闭环也为下一阶段的自主智能进化学习建立了工程基础。个体执行过程中产生的新问题、运行异常、对象变化和知识能力缺口,将成为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小时技术值守