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

第三十二章 个体判断与条件分析

第三十二章 个体判断与条件分析

  1. 判断对象与判断条件的建立

  2. 多条件关联判断程序

  3. 状态变化与条件冲突处理

  4. 判断结果与知识能力关联

  5. 判断过程的验证与异常处理

    第三十二章 个体判断与条件分析

    个体认知处理形成当前场景的结构化认知结果,使个体能够明确当前场景中有哪些对象、对象具有什么属性、对象之间存在什么关系,以及对象当前处于什么状态。但是,认知结果本身并不直接代表任务可以执行,也不直接代表某种操作已经具备实施条件。个体还需要根据当前任务目标、知识能力和执行规则,对认知结果中的对象、属性、关系和状态进行判断,分析当前实际条件是否满足任务要求。

    判断与认知具有不同的工程职责。认知侧重于当前场景信息与已有知识结构的匹配和综合组织,判断则是在认知结果基础上,根据明确的判断对象、判断条件和条件之间的关系,确定当前情况是否符合特定要求。认知结果提供判断依据,判断程序对这些依据进行处理,形成可以用于后续决策的判断结果。

    例如,仓库机器人接收到物料搬运任务后,已经通过认知处理确认物料对象、物料重量、物料状态、机器人当前位置、机器人运行状态以及目标区域和通道信息。接下来,个体需要判断机器人是否具备搬运该物料的条件。这个判断不能只检查物料是否存在,还需要分析物料重量是否超过机器人承载能力、机器人是否处于可运行状态、通道是否可以通行、目标区域是否允许进入,以及当前执行规则是否允许执行该项操作。

    如果这些条件分别由不同的知识结构和方法提供,个体还需要建立条件之间的关联关系,确定哪些条件必须同时满足,哪些条件可以通过不同路径满足,哪些条件发生冲突时应当停止处理。由此形成的判断结果,才能成为后续决策的有效输入。

    本章以第三十一章形成的结构化认知结果为基础,研究判断对象与判断条件的建立、多条件关联判断、状态变化与条件冲突处理、判断结果与知识能力关联,以及判断过程的验证和异常处理。工程实现重点是建立动态判断机制,使判断对象、条件和处理方法能够根据不同任务及知识结构进行组织,而不是将所有业务判断写成固定的程序分支。

    1. 判断对象与判断条件的建立

    个体判断首先需要确定判断对象。判断对象是当前任务中需要确认其属性、状态、关系或者适用条件的实际对象,也可以是多个对象之间形成的关系对象,或者由若干对象和条件共同构成的任务场景。

    判断对象不能简单地等同于第三十一章中的场景对象。场景对象是当前认知范围内已经识别和组织的对象,判断对象则是在特定任务和判断目标下,从场景对象中确定的具体判断目标。同一个场景对象,在不同任务中可能成为不同判断过程的对象。

    例如,机器人执行物料搬运任务时,物料是搬运状态判断的对象,机器人是承载能力和运行状态判断的对象,通道是通行条件判断的对象,目标区域是进入条件判断的对象。机器人与通道之间的通行关系、机器人与物料之间的距离关系,也可以分别成为判断对象。

    判断对象还可以是一个复合对象。例如,机器人是否能够完成某项搬运任务,不能只针对机器人自身进行判断,而需要将机器人、物料、路线、目标区域和当前环境组合为一个任务判断对象。这个判断对象代表一个由多个实际对象及其关系形成的判断范围。

    因此,判断对象需要关联当前任务、认知场景和知识结构,不能脱离实际任务单独建立。判断程序首先从任务上下文中读取当前目标,确定任务涉及的对象集合,再从认知结果中提取与任务目标相关的对象、属性、关系和状态,形成判断对象集合。

    判断对象的数据结构可以设计为:

    {
        "judgment_object_id": "judgment_object_000128",
        "task_instance_id": "task_instance_000128",
        "scene_id": "scene_000128",
        "object_scope": [
            {
                "object_id": "robot_001",
                "structure_id": "robot_structure",
                "object_role": "executor"
            },
            {
                "object_id": "material_0001",
                "structure_id": "material_structure",
                "object_role": "target"
            },
            {
                "object_id": "route_001",
                "structure_id": "route_structure",
                "object_role": "route"
            },
            {
                "object_id": "area_B",
                "structure_id": "area_structure",
                "object_role": "destination"
            }
        ],
        "judgment_scope": "material_transport",
        "assignment_version": "assignment_v003"
    }

    这里的object_role表示对象在当前任务中的关系角色,不是对象本身的固定类型。机器人在搬运任务中是执行主体,在设备检查任务中则可能成为被检查对象。角色应当由当前任务及其结构关系确定,而不能将对象角色固定写入对象定义。

    判断对象建立之后,需要进一步建立判断条件。判断条件是根据任务目标和知识结构确定的、需要通过实际信息验证的要求。它可以来自对象属性定义、对象状态定义、对象关系定义、能力适用条件、方法执行前提和执行规则。

    例如,机器人搬运物料时,判断条件可能涉及物料重量、机器人最大承载能力、物料当前状态、机器人运行状态、通道宽度、通道开放状态和目标区域进入权限。这些条件并非全部属于同一种类型。有些是数值比较条件,有些是状态匹配条件,有些是关系判断条件,还有些是执行规则条件。

    判断条件应当与其来源建立关联。条件来源可以是任务定义,也可以是知识结构中的属性约束、状态定义、关系定义、知识能力的适用范围或者执行规则。这样设计可以使判断结果能够追溯到具体的判断依据,而不是只返回一个没有来源的布尔值。

    判断条件的数据结构可以设计为:

    {
        "judgment_id": "judgment_000128",
        "judgment_object_id": "judgment_object_000128",
        "judgment_type": "transport_readiness",
        "conditions": [
            {
                "condition_id": "condition_001",
                "condition_source": "capability_requirement",
                "object_id": "material_0001",
                "attribute_id": "weight",
                "operator": "<=",
                "reference_object": "robot_001",
                "reference_attribute": "load_capacity",
                "required": true
            },
            {
                "condition_id": "condition_002",
                "condition_source": "object_state",
                "object_id": "material_0001",
                "state_requirement": "available",
                "required": true
            },
            {
                "condition_id": "condition_003",
                "condition_source": "runtime_state",
                "object_id": "robot_001",
                "state_requirement": "ready",
                "required": true
            },
            {
                "condition_id": "condition_004",
                "condition_source": "execution_rule",
                "object_id": "route_001",
                "state_requirement": "open",
                "required": true
            }
        ],
        "condition_relation": {
            "operator": "AND"
        }
    }

    上述条件定义表示物料重量不能超过机器人承载能力,物料状态必须满足可搬运要求,机器人必须处于允许执行的状态,通道必须处于开放状态。四项条件通过AND关系组织,表示全部必要条件都满足后,当前搬运任务才具备相应的运行条件。

    这里的条件只是示例。实际项目中不能将所有条件都写成固定字段,也不能预先规定所有任务必须具有物料重量、机器人承载能力等字段。判断条件应当根据当前任务所需的知识结构动态形成。某项任务可能需要判断温度、距离、速度、权限或其他属性,也可能只需要处理对象关系和状态条件。

    因此,判断条件需要有独立的数据模型。每项条件应当包含条件标识、条件类型、作用对象、数据来源、判断操作、参考对象或参考值、适用范围、必要程度和条件状态。对于需要调用特定方法的条件,还应当关联方法标识和方法版本。

    判断对象与判断条件的程序可以组织为:

    IndividualRuntime/
    └── judgment/
        ├── object/
        │   ├── JudgmentObjectBuilder.php       # 根据任务和认知结果建立判断对象
        │   ├── JudgmentObjectResolver.php      # 确定判断对象及其关联对象
        │   ├── JudgmentScopeResolver.php       # 确定当前判断的对象范围
        │   └── JudgmentObjectValidator.php     # 检查判断对象及结构引用
        ├── condition/
        │   ├── JudgmentConditionBuilder.php    # 根据任务要求和知识结构建立判断条件
        │   ├── ConditionDefinitionReader.php   # 读取已有判断条件定义
        │   ├── ConditionSourceResolver.php     # 确定判断条件的数据和规则来源
        │   ├── ConditionDependencyBuilder.php  # 建立条件之间的依赖关系
        │   └── ConditionValidator.php          # 检查条件定义和参数完整性
        └── context/
            ├── JudgmentContextBuilder.php      # 建立判断对象、条件和任务上下文
            └── JudgmentContextReader.php       # 读取当前判断所需的认知数据

    JudgmentObjectBuilder.php从当前任务和认知结果中提取判断对象。JudgmentConditionBuilder.php则根据任务目标、能力定义和执行规则建立条件。两者形成的结果由JudgmentContextBuilder.php组织,作为后续多条件判断程序的输入。

    判断条件不能在建立时就默认全部满足。条件定义只是说明需要检查什么,实际判断结果必须由当前认知数据提供依据。例如,条件要求机器人处于ready状态,但如果当前认知结果中的机器人状态为running,该条件就不能被认定为满足。

    同样,条件所需的数据缺失时,也不能将其默认转换为满足或不满足。程序应当区分条件满足、条件不满足、条件未知、条件冲突和条件不适用。只有保留这些不同结果,后续程序才能准确确定处理路径。

    2. 多条件关联判断程序

    实际任务通常不是由单一条件决定的,而是由多个条件共同构成。多个条件之间可能存在同时满足、任选其一、先后依赖、互相排斥或者优先约束等关系。个体需要根据条件之间的结构关系组织判断过程,而不是把所有条件简单地放进一个布尔表达式中。

    多条件判断首先需要确定条件之间的逻辑关系。对于必须同时满足的条件,可以采用AND关系;对于允许多个条件路径中任意一条满足的情况,可以采用OR关系;对于存在否定要求的条件,可以使用相应的否定关系;对于具有先后依赖的条件,则需要建立判断顺序和前置条件。

    例如,机器人执行搬运任务时,物料状态正常、机器人状态允许、承载能力满足和通道开放可能都属于必须满足的条件。若机器人存在两条允许通行的路线,则路线条件可能采用OR关系,只要其中一条路线满足要求即可。若执行设备控制前必须先完成安全检查,则安全检查与设备控制之间还存在先后依赖关系。

    因此,条件关联不能只使用一个统一的AND或OR字段,而需要形成可嵌套的条件结构。条件结构应当能够表达多个条件组合、条件分组和条件依赖,并且能够追溯每个判断结果对应的原始条件。

    条件组合可以设计为:

    {
        "condition_group_id": "group_transport_001",
        "relation": "AND",
        "conditions": [
            {
                "condition_id": "material_state_check"
            },
            {
                "condition_id": "robot_state_check"
            },
            {
                "condition_id": "load_capacity_check"
            },
            {
                "condition_group_id": "route_selection",
                "relation": "OR",
                "conditions": [
                    {
                        "condition_id": "route_001_check"
                    },
                    {
                        "condition_id": "route_002_check"
                    }
                ]
            }
        ]
    }

    这里表示物料状态、机器人状态和承载能力必须同时满足,而两条路线中至少有一条满足即可。整个条件结构通过嵌套关系形成,能够表达不同层次的条件组合。

    多条件判断程序需要先读取条件定义,再从认知结果中取得相关属性值、对象状态和关系数据,最后根据条件类型选择适当的判断方法。对于数值比较条件,可以调用比较方法;对于对象状态条件,可以调用状态匹配方法;对于对象关系条件,可以调用关系判断方法;对于多个条件之间的组合关系,则由条件组合处理程序组织计算。

    这里需要注意,判断程序不应当将不同类型的条件都交给同一个简单的数值比较函数。对象状态判断、关系判断、权限判断和条件依赖处理具有不同的数据要求,需要根据条件定义选择对应的方法。比较、计算、判断、匹配、验证等方法是具体的操作单元,而完整的多条件判断能力由知识结构、条件关系和方法组合共同形成。

    多条件判断程序可以组织为:

    IndividualRuntime/
    └── judgment/
        ├── evaluator/
        │   ├── MultiConditionEvaluator.php      # 组织多个判断条件的执行
        │   ├── ConditionGroupEvaluator.php      # 处理嵌套条件组
        │   ├── ConditionResultCollector.php     # 收集各项条件判断结果
        │   └── ConditionDependencyResolver.php  # 处理条件之间的先后依赖
        ├── methods/
        │   ├── ComparisonJudgment.php            # 执行数值及属性比较
        │   ├── StateJudgment.php                 # 执行对象状态判断
        │   ├── RelationJudgment.php              # 执行对象关系判断
        │   ├── ScopeJudgment.php                 # 执行范围和适用条件判断
        │   └── PermissionJudgment.php            # 执行权限与授权条件判断
        └── result/
            ├── ConditionGroupResultBuilder.php   # 形成条件组合结果
            └── JudgmentResultBuilder.php         # 形成完整判断结果

    MultiConditionEvaluator.php是多条件判断的组织入口。它根据判断条件结构读取各项条件,将具体条件交给对应的判断方法执行,再根据条件组之间的关系形成综合结果。

    例如,比较判断方法可以设计为:

    <?php
    
    class ComparisonJudgment
    {
        public function execute($left, $operator, $right)
        {
            switch ($operator) {
                case '>':
                    $matched = $left > $right;
                    break;
    
                case '>=':
                    $matched = $left >= $right;
                    break;
    
                case '<':
                    $matched = $left < $right;
                    break;
    
                case '<=':
                    $matched = $left <= $right;
                    break;
    
                case '==':
                    $matched = $left == $right;
                    break;
    
                case '===':
                    $matched = $left === $right;
                    break;
    
                default:
                    return array(
                        'status' => 'invalid_operator'
                    );
            }
    
            return array(
                'status' => $matched
                    ? 'satisfied'
                    : 'unsatisfied',
                'result' => $matched
            );
        }
    }

    该方法只负责比较操作,不负责决定整个任务是否允许执行。调用前,程序还需要检查两个比较值是否存在、类型是否适合比较、数据是否有效,以及比较条件是否来自当前任务所引用的知识结构和规则。

    条件组合程序则负责处理多个条件之间的关系:

    <?php
    
    class ConditionGroupEvaluator
    {
        public function evaluate($relation, $results)
        {
            if (empty($results)) {
                return array(
                    'status' => 'unknown',
                    'result' => null
                );
            }
    
            $hasUnknown = false;
            $hasUnsatisfied = false;
            $hasSatisfied = false;
    
            foreach ($results as $result) {
                if ($result === 'unknown') {
                    $hasUnknown = true;
                } elseif ($result === 'unsatisfied') {
                    $hasUnsatisfied = true;
                } elseif ($result === 'satisfied') {
                    $hasSatisfied = true;
                }
            }
    
            if ($relation === 'AND') {
                if ($hasUnsatisfied) {
                    return array(
                        'status' => 'unsatisfied',
                        'result' => false
                    );
                }
    
                if ($hasUnknown) {
                    return array(
                        'status' => 'unknown',
                        'result' => null
                    );
                }
    
                return array(
                    'status' => 'satisfied',
                    'result' => true
                );
            }
    
            if ($relation === 'OR') {
                if ($hasSatisfied) {
                    return array(
                        'status' => 'satisfied',
                        'result' => true
                    );
                }
    
                if ($hasUnknown) {
                    return array(
                        'status' => 'unknown',
                        'result' => null
                    );
                }
    
                return array(
                    'status' => 'unsatisfied',
                    'result' => false
                );
            }
    
            return array(
                'status' => 'invalid_relation',
                'result' => null
            );
        }
    }

    这里采用三种基本条件结果:satisfied、unsatisfied和unknown。其目的在于防止信息缺失时产生错误的肯定判断。对于AND条件组,只要存在明确不满足的必要条件,整个条件组就不满足;如果没有明确不满足的条件,但存在未知条件,则整体结果为未知。对于OR条件组,只要存在一条明确满足的路径,整体结果就可以满足;如果没有满足路径但存在未知条件,则整体结果仍然未知。

    实际工程还需要扩展条件冲突、条件不适用和条件无效等状态。尤其是安全条件和执行约束,不能简单地将未知状态按照普通条件处理。涉及安全联锁、操作许可和设备保护的必要条件,如果无法确认,应当按照对应的安全规则进入禁止执行或等待确认路径。

    多条件判断还需要处理条件之间的依赖关系。例如,机器人承载能力判断依赖物料重量和机器人承载参数。如果物料重量尚未获取,承载能力判断就不能直接执行。又如,路线可通行判断可能依赖机器人尺寸、通道宽度、通道状态和障碍物信息。如果其中一个必要对象未被识别,就不能形成完整的通行判断。

    因此,条件执行顺序需要由条件依赖关系决定。程序可以先处理不依赖其他条件的基础条件,再处理依赖这些结果的复合条件。若某项条件依赖的前置条件未满足或无法确定,则应当保留依赖状态,不得伪造判断结果。

    多条件关联判断的工程结果不能只返回true或false。它还应当包含各项条件的执行结果、条件组结果、未满足条件、未知条件、依赖关系和判断依据。这样,后续决策程序才能确定任务应当继续、等待、调整还是终止。

    3. 状态变化与条件冲突处理

    个体判断不是在一个静止不变的场景中完成的。实际运行环境中的对象属性、对象关系和对象状态可能持续变化。个体在判断开始时读取的认知结果,可能在判断结束前已经发生变化。对于持续时间较长的任务,这种情况更加明显。

    例如,机器人在开始搬运任务时确认通道开放,但在准备执行移动操作时,通道状态可能已经变为关闭。此时,如果程序仍然使用最初的判断结果,就可能根据过期条件执行操作。因此,个体判断程序需要建立状态变化识别和条件有效性检查机制。

    状态变化首先需要区分对象状态变化、属性值变化、对象关系变化和环境条件变化。对象状态变化可能是设备从ready变为running,属性变化可能是电量从较高水平下降到不足以支持当前任务,关系变化可能是机器人与某条路线之间的通行关系失效,环境条件变化则可能是通道关闭或工作区域出现障碍。

    这些变化对不同判断条件的影响并不相同。某些属性变化可能不影响当前任务,某些状态变化则可能立即使当前判断结果失效。因此,程序需要将变化对象与当前判断所依赖的条件关联起来,分析变化是否影响已经形成的判断结果。

    判断结果需要保存其依据的认知版本或场景时间。当前场景发生变化时,程序可以检查变化对象是否属于当前判断范围,以及变化属性是否被判断条件引用。如果变化与当前判断无关,可以保留原有结果;如果变化涉及关键条件,则需要重新执行相关条件判断;如果变化涉及安全条件,则应当优先暂停相关执行路径,并重新确认当前状态。

    状态变化记录可以设计为:

    {
        "change_id": "change_000128",
        "scene_id": "scene_000128",
        "object_id": "route_001",
        "change_type": "state_changed",
        "attribute_or_state": "route_status",
        "previous_value": "open",
        "current_value": "closed",
        "changed_at": "2026-11-15 10:45:00",
        "source_id": "route_sensor_001",
        "affected_conditions": [
            "route_001_check"
        ]
    }

    通过这一记录,判断程序能够确定通道状态已经变化,并且影响当前判断中的route_001_check条件。程序可以据此将相关判断结果标记为需要重新验证,而不是继续沿用之前的满足状态。

    条件冲突是另一个需要处理的问题。条件冲突是指多个判断条件、状态信息或规则要求之间出现不一致,导致当前判断无法按照原有条件关系直接形成确定结果。

    例如,业务任务要求机器人进入某区域,但设备安全规则禁止进入该区域;某个传感器报告通道开放,而另一个有效信息源报告通道关闭;任务要求在指定时间内完成操作,但当前设备状态不允许在该时间范围内安全执行。这些情况都需要形成明确的冲突处理路径。

    条件冲突不能通过简单地选择其中一个条件来解决。程序首先需要确定冲突发生在哪个层次,是实际数据之间的冲突、认知结构之间的冲突、任务要求之间的冲突,还是任务要求与执行规则之间的冲突。不同冲突的处理方式不同。

    实际数据冲突需要检查数据来源、采集时间、有效性和对象对应关系。若两个来源提供了不同状态,程序需要根据已赋予的数据规则判断是否可以确定有效值;如果不能确定,应当保留冲突状态并等待进一步确认。

    认知结构冲突需要检查对象是否匹配了错误结构、属性是否存在不一致定义、关系是否违反已有结构约束。对于超出个体已赋值结构范围的情况,应当形成结构缺口反馈,而不能直接修改知识结构定义。

    任务要求之间的冲突需要由任务组织和决策机制分析。例如,任务目标和时间要求不能同时满足时,个体应当根据已赋予的任务优先级和调整规则形成可处理结果。如果超出了个体允许调整的职责范围,则需要反馈智能控制后台。

    任务要求与安全规则之间的冲突则需要严格处理。任务指令不能自动覆盖执行约束。若任务要求的操作违反个体已经获得的安全规则、权限或操作范围,判断程序应当阻止相应操作,并记录冲突依据。个体不能为了完成任务而自行取消安全约束。

    状态变化和冲突处理程序可以组织为:

    IndividualRuntime/
    └── judgment/
        ├── change/
        │   ├── StateChangeCollector.php        # 收集对象及环境状态变化
        │   ├── ConditionImpactAnalyzer.php     # 分析变化对判断条件的影响
        │   ├── JudgmentInvalidator.php         # 标记失效或需要重新验证的判断
        │   └── JudgmentRechecker.php           # 重新执行受影响的判断条件
        ├── conflict/
        │   ├── ConditionConflictDetector.php   # 识别多个条件之间的冲突
        │   ├── DataConflictAnalyzer.php        # 分析实际信息来源之间的数据冲突
        │   ├── RuleConflictChecker.php         # 检查任务要求与执行规则的冲突
        │   ├── StructureConflictChecker.php    # 检查结构定义和关系约束冲突
        │   └── ConflictHandler.php             # 组织冲突处理和结果记录
        └── recovery/
            ├── JudgmentRecoveryManager.php     # 管理判断结果失效后的恢复
            └── JudgmentConsistencyChecker.php  # 检查重新判断后的条件一致性

    StateChangeCollector.php接收来自信息更新程序和运行环境的变化记录。ConditionImpactAnalyzer.php根据当前判断条件与变化对象之间的关联关系,确定哪些判断结果需要重新验证。JudgmentInvalidator.php负责将受到影响的判断结果标记为失效或待验证状态,避免后续决策继续使用过期结果。

    对于条件冲突,ConditionConflictDetector.php负责发现冲突,ConflictHandler.php则根据冲突类型调用相应处理程序。对于不能在个体本地职责范围内解决的冲突,程序应当形成待处理记录并反馈后台。

    条件冲突的记录结构可以设计为:

    {
        "conflict_id": "conflict_000128",
        "task_instance_id": "task_instance_000128",
        "conflict_type": "task_rule_conflict",
        "conflict_objects": [
            "robot_001",
            "area_B"
        ],
        "related_conditions": [
            "task_target_area",
            "operation_scope_check"
        ],
        "conflict_description": "任务目标区域超出当前允许操作范围",
        "handling_result": "blocked",
        "requires_central_review": true,
        "created_at": "2026-11-15 10:46:00"
    }

    条件冲突处理还需要考虑冲突解除后的重新判断。假设通道关闭导致任务等待,之后通道重新开放,个体不能仅凭收到一个开放信号就直接恢复全部任务。它需要重新读取当前场景信息,确认通道状态有效,再检查相关对象关系、机器人状态和其他必要条件,重新形成判断结果。

    对于运行中已经产生实际动作的任务,还需要将状态变化与方法执行记录关联。例如,机器人已经移动到通道入口,随后发现通道关闭,个体应当根据当前设备状态和执行规则确定安全停止位置、任务暂停状态和后续恢复条件。判断程序不能只更新一个条件结果,而忽略实际设备已经发生的动作。

    4. 判断结果与知识能力关联

    判断结果不是独立存在的数据,它必须与形成该结果所使用的知识结构、知识能力和方法建立关联。只有这样,个体才能明确当前判断依据来自哪里、使用了哪些知识能力、执行了哪些判断方法,以及这些结果是否处于当前赋值范围内。

    在WSaiOS工程中,个体的知识能力由智能控制后台根据需求驱动的知识结构化构建形成,并经过验证后赋予个体。个体在运行时根据任务需要调用已赋予的知识能力,使用相应结构定义、属性关系和方法完成判断。

    因此,判断程序不应当把所有判断逻辑写成一个与知识能力无关的通用代码库。通用判断方法可以作为基础程序存在,但具体判断内容应当由当前任务所需的知识能力及其关联定义确定。

    例如,机器人承载能力判断需要调用与物料结构、机器人结构和承载关系相关的知识能力。路线可通行判断需要调用路线结构、机器人尺寸结构、通道状态结构及相应关系处理方法。它们可能使用相同的比较方法,但其判断对象、条件定义、结构依赖和结果意义并不相同。

    因此,知识能力与判断之间需要建立明确的映射关系。一个知识能力可以关联多个判断类型,一个判断过程也可能需要组合多个知识能力。判断程序应当根据当前任务和认知结果确定所需能力,再检查这些能力是否已经赋予当前个体。

    能力关联信息可以设计为:

    {
        "judgment_capability_id": "transport_judgment",
        "capability_id": "material_transport",
        "required_structures": [
            "material_structure",
            "robot_structure",
            "route_structure"
        ],
        "judgment_methods": [
            {
                "method_id": "compare_load_capacity",
                "method_version": "v001"
            },
            {
                "method_id": "match_object_state",
                "method_version": "v002"
            },
            {
                "method_id": "check_route_relation",
                "method_version": "v001"
            }
        ],
        "assignment_required": true
    }

    这里的transport_judgment代表搬运任务中的判断能力组织关系,它关联已有的知识能力、结构和方法。具体任务运行时,个体需要检查这些内容是否属于当前赋值版本,并且是否满足当前任务的适用条件。

    判断结果还需要记录实际调用过的能力和方法。对于一个复合判断过程,可能有多项能力共同参与。例如,物料搬运准备判断需要调用物料状态判断、承载能力判断和路线条件判断。最终结果应当保留这些子判断与总体判断之间的关联。

    判断结果可以采用以下结构:

    {
        "judgment_result_id": "judgment_result_000128",
        "task_instance_id": "task_instance_000128",
        "individual_id": "individual_001",
        "assignment_version": "assignment_v003",
        "cognition_id": "cognition_000128",
        "judgment_status": "completed",
        "capabilities_used": [
            "material_transport",
            "robot_state_check",
            "route_access_check"
        ],
        "method_results": [
            {
                "method_id": "compare_load_capacity",
                "result": "satisfied"
            },
            {
                "method_id": "match_object_state",
                "result": "satisfied"
            },
            {
                "method_id": "check_route_relation",
                "result": "satisfied"
            }
        ],
        "condition_results": {
            "overall": "satisfied"
        },
        "decision_input": {
            "task_ready": true
        }
    }

    上述结果表示当前任务相关的判断条件已经满足,可以将判断结果交给后续决策程序。需要注意,task_ready只是判断结果中的条件结论,并不代表个体已经自动获得执行授权,也不代表具体设备操作已经发生。是否进入决策和方法形成阶段,还需要结合任务目标、执行规则和当前运行状态处理。

    知识能力关联程序需要处理能力缺失的情况。如果判断程序需要调用某项能力,但当前个体没有获得该能力,或者能力依赖的结构和方法没有完整加载,程序不能临时寻找一个名称相似的方法代替,也不能直接调用其他个体的能力。它应当形成明确的能力缺口记录。

    例如,个体已经具备物料识别和状态判断能力,但没有路线关系判断能力。此时,个体可以完成物料对象认知,却不能据此认定搬运任务的路线条件已经满足。它应当将路线判断能力缺口记录下来,按照任务规则等待后台补充能力,或者进入允许的其他处理路径。

    能力缺口记录可以设计为:

    {
        "capability_gap_id": "gap_000128",
        "individual_id": "individual_001",
        "task_instance_id": "task_instance_000128",
        "required_capability": "route_access_check",
        "gap_type": "capability_not_assigned",
        "required_structures": [
            "route_structure",
            "robot_structure"
        ],
        "required_methods": [
            "check_route_relation"
        ],
        "handling_status": "reported"
    }

    个体可以将该记录保存在本地,并在通信可用时反馈给智能控制后台。后台根据整体任务和其他个体的能力配置决定是否构建或调整相关知识能力,再经过验证和赋值将其部署到需要的个体。

    判断结果与知识能力之间的关系,还需要考虑版本一致性。判断结果必须记录所依据的赋值版本、知识结构版本和方法版本。如果能力在任务运行期间发生更新,原有判断结果不能自动认为仍然有效。程序需要根据版本变化和任务执行阶段判断是否需要重新认知、重新判断或继续使用原有结果。

    判断能力的程序组织可以设计为:

    IndividualRuntime/
    └── judgment/
        └── capability/
            ├── JudgmentCapabilityResolver.php   # 根据任务确定所需判断能力
            ├── JudgmentCapabilityChecker.php    # 检查能力是否已经赋予个体
            ├── CapabilityStructureChecker.php   # 检查判断所需结构依赖
            ├── CapabilityMethodChecker.php      # 检查相关判断方法是否可用
            ├── CapabilityVersionChecker.php     # 检查能力及方法版本
            ├── JudgmentCapabilityBinder.php     # 建立判断与能力之间的关联
            └── CapabilityGapBuilder.php         # 形成判断能力缺口记录

    通过这些程序,个体可以明确当前判断依赖哪些知识能力,并能够在能力不足时形成可追溯的反馈信息。这样,判断结果不再是一个脱离知识体系的孤立结论,而是具有明确结构依据、能力来源、方法记录和赋值版本的工程数据。

    5. 判断过程的验证与异常处理

    判断结果直接影响后续决策和方法形成,因此必须建立判断验证机制。一个判断程序即使返回了true,也不能直接说明判断正确。还需要检查判断对象是否正确、条件是否完整、数据是否有效、所调用的知识能力是否适用、方法执行是否符合定义,以及最终结果是否与各项条件的实际情况一致。

    判断验证首先需要检查判断输入。程序应当确认当前判断对象与任务目标相符,所需认知结果已经形成,属性值和状态信息具有有效来源,关系信息能够关联到正确的对象,并且所引用的知识结构版本与当前赋值版本一致。

    如果判断输入不完整,程序应当明确返回信息不足,而不是继续计算。对于必要条件缺失的情况,需要确定是暂时无法获取信息、对象无法识别、结构定义缺失,还是当前个体没有获得相应知识能力。这几类问题虽然都可能导致判断无法完成,但后续处理方式不同。

    其次,需要检查条件定义本身。条件定义中的判断操作必须有效,条件之间的关联关系必须能够解析,条件依赖不能形成无法处理的循环,条件引用的对象和属性必须存在于当前认知范围或相应的知识结构中。若条件定义不合法,程序应当返回条件定义错误,而不能将其当作普通条件不满足。

    再次,需要检查具体判断方法的执行结果。方法返回的结果必须符合方法接口约定,不能只检查程序是否成功返回。对于数值比较,应当检查输入数据类型和单位是否一致;对于状态判断,应当检查状态定义是否有效;对于关系判断,应当检查关系方向和关系条件;对于权限判断,应当检查当前任务是否处于允许的授权范围。

    判断结果形成后,还需要进行综合验证。综合验证需要确认所有必要条件是否已经处理,条件组结果是否符合关联逻辑,是否存在未解决的冲突,以及最终判断结论是否与条件结果一致。

    例如,一个判断过程包含四项必须同时满足的条件,其中三项满足、一项未知,则总体结果不能标记为满足;如果四项都满足,但存在一条未处理的安全约束冲突,也不能形成允许执行的结论。判断验证程序必须能够识别这些情况。

    判断验证程序可以组织为:

    IndividualRuntime/
    └── judgment/
        └── validation/
            ├── JudgmentInputValidator.php       # 检查判断输入信息是否完整有效
            ├── JudgmentConditionValidator.php   # 检查条件定义及条件关系
            ├── JudgmentMethodValidator.php      # 检查判断方法及执行结果
            ├── JudgmentDependencyValidator.php # 检查条件依赖和结构依赖
            ├── JudgmentResultValidator.php      # 检查最终判断结果是否正确形成
            ├── JudgmentRuleValidator.php        # 检查判断结果是否违反执行规则
            └── JudgmentAuditBuilder.php         # 形成判断过程验证记录

    判断异常需要按照问题来源进行分类。数据异常可能表现为关键属性缺失、数据类型错误、数据来源冲突或数据已经过期;结构异常可能表现为对象无法匹配、结构引用不存在或关系定义不完整;条件异常可能表现为条件定义错误、条件依赖无法解析或条件关系冲突;能力异常可能表现为所需能力未赋值、方法未加载或版本不一致;执行异常则可能表现为判断方法调用失败、运行资源不足或外部接口异常。

    不同异常不能采用同一种处理方式。例如,属性数据暂时缺失时,可以重新获取信息;结构定义缺失时,应当形成知识结构缺口;判断方法执行失败时,可以根据方法的恢复规则决定是否重试;安全约束冲突时,应当阻止相关操作;能力未赋值时,应当反馈后台,而不是绕过能力检查。

    判断异常记录可以设计为:

    {
        "judgment_exception_id": "judgment_exception_000128",
        "task_instance_id": "task_instance_000128",
        "judgment_id": "judgment_000128",
        "exception_type": "condition_data_missing",
        "related_condition": "robot_load_capacity",
        "related_object": "robot_001",
        "exception_level": "task_blocking",
        "handling_path": "wait_for_information",
        "requires_rejudgment": true,
        "created_at": "2026-11-15 10:50:00"
    }

    该记录表示机器人承载能力属性缺失,导致相关判断无法完成。程序应当等待有效数据或者进入相应信息补充流程,不能默认机器人承载能力满足要求。

    判断异常处理还需要与运行引擎的任务状态管理衔接。如果判断过程正常完成,运行引擎可以将任务处理阶段更新为判断完成,并将结果交给后续决策程序;如果判断结果未知,任务可以进入等待状态;如果判断存在明确不满足的必要条件,则需要交给决策程序确定是否调整任务;如果涉及安全约束冲突,则应当阻止相关执行路径;如果出现无法恢复的判断程序异常,则应当保存运行上下文和异常记录,再由运行引擎执行相应的停止或恢复处理。

    判断结果的数据表可以设计为:

    CREATE TABLE individual_judgment_results (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        judgment_result_id VARCHAR(100) NOT NULL,
        task_instance_id VARCHAR(100) NOT NULL,
        individual_id VARCHAR(100) NOT NULL,
        cognition_id VARCHAR(100) NOT NULL,
        assignment_version VARCHAR(100) NOT NULL,
        judgment_type VARCHAR(100) NOT NULL,
        judgment_status VARCHAR(50) NOT NULL,
        judgment_conclusion VARCHAR(50) DEFAULT NULL,
        judgment_data LONGTEXT,
        created_at DATETIME NOT NULL,
        UNIQUE KEY uk_judgment_result (
            judgment_result_id
        ),
        KEY idx_task_judgment (
            task_instance_id,
            judgment_type
        )
    );

    判断条件明细表可以设计为:

    CREATE TABLE individual_judgment_conditions (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        judgment_result_id VARCHAR(100) NOT NULL,
        condition_id VARCHAR(100) NOT NULL,
        condition_source VARCHAR(100) DEFAULT NULL,
        condition_status VARCHAR(50) NOT NULL,
        actual_value TEXT,
        reference_value TEXT,
        method_id VARCHAR(100) DEFAULT NULL,
        reason TEXT,
        created_at DATETIME NOT NULL,
        KEY idx_judgment_condition (
            judgment_result_id,
            condition_id
        )
    );

    判断异常表可以设计为:

    CREATE TABLE individual_judgment_exceptions (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        exception_id VARCHAR(100) NOT NULL,
        judgment_result_id VARCHAR(100) DEFAULT NULL,
        task_instance_id VARCHAR(100) NOT NULL,
        exception_type VARCHAR(100) NOT NULL,
        exception_status VARCHAR(50) NOT NULL,
        handling_path VARCHAR(100) DEFAULT NULL,
        exception_data LONGTEXT,
        created_at DATETIME NOT NULL,
        UNIQUE KEY uk_exception_id (exception_id),
        KEY idx_task_exception (task_instance_id)
    );

    这些表分别保存判断结果、条件明细和判断异常。实际运行时,判断结果通过judgment_result_id与各项条件记录关联,通过task_instance_id与任务实例关联,通过cognition_id追溯第三十一章形成的认知结果,通过assignment_version追溯当前个体使用的知识能力版本。

    判断过程的组织程序可以进一步形成统一入口:

    <?php
    
    class IndividualJudgmentProcessor
    {
        private $objectBuilder;
        private $conditionBuilder;
        private $conditionEvaluator;
        private $conflictHandler;
        private $capabilityChecker;
        private $resultValidator;
        private $recordWriter;
    
        public function __construct(
            $objectBuilder,
            $conditionBuilder,
            $conditionEvaluator,
            $conflictHandler,
            $capabilityChecker,
            $resultValidator,
            $recordWriter
        ) {
            $this->objectBuilder = $objectBuilder;
            $this->conditionBuilder = $conditionBuilder;
            $this->conditionEvaluator = $conditionEvaluator;
            $this->conflictHandler = $conflictHandler;
            $this->capabilityChecker = $capabilityChecker;
            $this->resultValidator = $resultValidator;
            $this->recordWriter = $recordWriter;
        }
    
        public function process($context)
        {
            $objects = $this->objectBuilder->build(
                $context
            );
    
            if (!$objects['success']) {
                return array(
                    'success' => false,
                    'status' => 'object_build_failed'
                );
            }
    
            $conditions = $this->conditionBuilder->build(
                $context,
                $objects
            );
    
            if (!$conditions['success']) {
                return array(
                    'success' => false,
                    'status' => 'condition_build_failed'
                );
            }
    
            $capability = $this->capabilityChecker->check(
                $conditions
            );
    
            if (!$capability['available']) {
                return array(
                    'success' => false,
                    'status' => 'capability_unavailable',
                    'gap' => $capability['gap']
                );
            }
    
            $conflicts = $this->conflictHandler->check(
                $context,
                $conditions
            );
    
            if ($conflicts['blocked']) {
                return array(
                    'success' => false,
                    'status' => 'condition_conflict',
                    'conflicts' => $conflicts
                );
            }
    
            $judgment = $this->conditionEvaluator->evaluate(
                $conditions
            );
    
            $validation = $this->resultValidator->validate(
                $judgment,
                $conditions
            );
    
            if (!$validation['valid']) {
                return array(
                    'success' => false,
                    'status' => 'judgment_invalid',
                    'validation' => $validation
                );
            }
    
            $result = array(
                'success' => true,
                'status' => $judgment['status'],
                'judgment_result' => $judgment,
                'assignment_version' =>
                    $context['assignment_version']
            );
    
            $this->recordWriter->save($result);
    
            return $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小时技术值守