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

第九章 结构匹配与智能处理机制

第九章 结构匹配与智能处理机制

  1. 对象识别与结构匹配的实现

  2. 属性匹配与状态匹配程序

  3. 结构关系判断与条件处理

  4. 比较、计算、判断、匹配等方法的程序组织

  5. 结构匹配结果与后续处理过程的衔接

    第九章 结构匹配与智能处理机制

    结构解析完成后,WSaiOS智能控制后台已经能够将结构定义加载为可识别、可访问和可处理的运行结构对象。但是,结构对象本身并不直接等于对实际对象的理解,也不意味着后台已经能够根据结构完成问题处理。结构定义表达的是对象应当具有的组成、属性、方法和关系,实际运行过程中获取的信息则反映具体对象在特定场景和状态下的真实情况。

    要使结构定义参与智能处理,就需要建立实际对象信息与已有结构定义之间的匹配机制。后台通过对象识别确定当前处理对象,通过属性匹配确认对象信息与结构定义之间的对应关系,通过状态匹配识别对象当前状态,通过关系判断确定对象与其他对象之间的联系,再根据处理条件调用比较、计算、判断、匹配等基础方法,形成后续认知、决策和方法执行所需要的处理结果。

    因此,结构匹配不是简单地比较两个名称是否相同,也不是单独的数据检索过程。它是将实际信息与结构定义建立对应关系,并依据结构元素、属性、状态和关系进行判断与处理的工程机制。

    在WSaiOS工程体系中,结构匹配属于智能控制后台内部的结构智能处理过程。它以第七章建立的结构数据管理机制和第八章形成的结构解析结果为基础,将实际对象信息引入结构处理过程,为后续知识能力调用、认知判断和决策形成提供结构化依据。

    9.1 对象识别与结构匹配的实现

    对象识别是结构匹配的起点。后台在处理某项需求或运行任务时,首先需要确定当前信息涉及什么对象。对象可能是一个具体设备、一个软件系统、一个运行个体、一个任务对象,也可能是由多个元素组成的复杂对象。不同对象具有不同的结构特征,不能在尚未确定对象范围的情况下直接进行属性匹配和关系判断。

    对象识别需要将外部获取的信息与后台已经掌握的对象定义和结构知识进行关联。外部信息可能来自用户输入、设备接口、传感器数据、软件接口、文件数据或其他允许接入的信息来源。不同来源提供的信息格式可能不同,但进入结构匹配程序之前,应当先按照统一的数据约定进行整理。

    例如,后台接收到一组设备信息,其中包含设备编号、设备类型、工作状态和运行参数。对象识别程序首先需要确定这些信息描述的是一个设备对象,而不是将其中每个字段分别作为独立对象处理。随后,根据设备编号、对象类别和已有结构定义,确定需要匹配的对象结构。

    对象识别与结构匹配必须区分两个不同的对象。

    结构定义对象是后台已有的结构知识,描述某一类对象应当具备的结构组成、属性和关系。实际对象是当前需要处理的具体对象,包含从外部信息来源获得的实际数据。结构匹配就是在两者之间建立对应关系。

    例如,后台已有一个设备结构定义,其中包含设备编号、设备类型、工作状态和运行参数等属性。当前接收到某台设备的实际信息后,程序需要判断这些信息是否符合设备结构定义,并确定实际数据分别对应哪些结构属性。

    为了支持这一过程,需要建立统一的对象信息数据模型。

    <?php
    
    class ObjectInformation
    {
        private $objectId;
        private $objectType;
        private $source;
        private $attributes;
        private $relations;
        private $collectedAt;
    
        public function __construct($data)
        {
            $this->objectId = $data['object_id'];
            $this->objectType = $data['object_type'];
            $this->source = $data['source'];
    
            $this->attributes = isset($data['attributes'])
                ? $data['attributes']
                : array();
    
            $this->relations = isset($data['relations'])
                ? $data['relations']
                : array();
    
            $this->collectedAt = isset($data['collected_at'])
                ? $data['collected_at']
                : null;
        }
    
        public function getObjectId()
        {
            return $this->objectId;
        }
    
        public function getObjectType()
        {
            return $this->objectType;
        }
    
        public function getSource()
        {
            return $this->source;
        }
    
        public function getAttributes()
        {
            return $this->attributes;
        }
    
        public function getRelations()
        {
            return $this->relations;
        }
    
        public function getCollectedAt()
        {
            return $this->collectedAt;
        }
    }

    ObjectInformation用于统一组织实际对象信息。它不负责判断对象属于什么结构,也不负责执行具体匹配,而是将外部输入整理为具有明确对象标识、对象类型、信息来源、属性集合、关系信息和采集时间的数据对象。

    这里的object_id用于标识具体对象,不能直接使用结构定义ID代替。一个结构定义可以对应多个实际对象,而多个实际对象又可以分别具有不同的运行状态和属性值。

    对象信息进入结构匹配程序之前,还需要经过必要的数据规范化处理。例如,不同设备接口可能分别使用device_status、status或其他字段表达工作状态。后台应当依据已经建立的结构定义和数据映射规则,将这些来源字段转换为统一的属性标识。不能在匹配程序中随意猜测字段含义,也不能将名称相似直接视为语义相同。

    对象识别程序的工程目录可以设计为:

    app/
    ├── Intelligence/
    │   ├── ObjectRecognition/
    │   │   ├── ObjectRecognizer.php          # 组织实际对象识别过程
    │   │   ├── ObjectInformation.php          # 统一封装实际对象信息
    │   │   ├── ObjectIdentifier.php           # 根据对象标识定位实际对象
    │   │   └── ObjectTypeResolver.php         # 根据对象信息确定对象类型
    │   │
    │   └── Structure/
    │       ├── StructureMatcher.php           # 组织实际对象与结构定义的匹配
    │       ├── StructureCandidateResolver.php # 确定可能适用的结构定义
    │       └── StructureMatchResult.php       # 保存结构匹配结果
    │
    └── Repositories/
        └── Object/
            └── ObjectRepository.php            # 查询和保存实际对象的基础记录

    ObjectRecognizer负责组织对象识别流程,ObjectIdentifier根据已有标识定位对象,ObjectTypeResolver根据对象信息确定对象类型,StructureCandidateResolver根据对象类型和结构定义范围确定待匹配的结构候选对象。

    结构候选对象的确定并不等于最终匹配。对象类型相同的实际对象,可能因为组成、属性或运行用途不同而需要使用不同结构。因此,后台不能只根据对象名称或类型字段就认定结构匹配成功,还需要继续检查结构元素、属性和关系。

    结构匹配程序可以采用以下基本实现:

    <?php
    
    class StructureMatcher
    {
        private $candidateResolver;
        private $elementMatcher;
        private $relationMatcher;
    
        public function __construct(
            StructureCandidateResolver $candidateResolver,
            ElementMatcher $elementMatcher,
            RelationMatcher $relationMatcher
        ) {
            $this->candidateResolver = $candidateResolver;
            $this->elementMatcher = $elementMatcher;
            $this->relationMatcher = $relationMatcher;
        }
    
        public function match($objectInformation, $structures)
        {
            $candidates = $this->candidateResolver
                ->resolve(
                    $objectInformation,
                    $structures
                );
    
            $results = array();
    
            foreach ($candidates as $structure) {
    
                $elementResult = $this->elementMatcher
                    ->match(
                        $objectInformation,
                        $structure
                    );
    
                $relationResult = $this->relationMatcher
                    ->match(
                        $objectInformation,
                        $structure
                    );
    
                $results[] = array(
                    'structure_code' => $structure['structure_code'],
                    'version_id' => $structure['version_id'],
                    'elements' => $elementResult,
                    'relations' => $relationResult
                );
            }
    
            return $results;
        }
    }

    这段程序展示了结构匹配的组织关系。首先确定候选结构,再分别执行元素匹配和关系匹配,最后汇总各结构的匹配结果。实际工程中还需要根据属性匹配结果和状态匹配结果补充匹配条件,并形成统一的匹配判定规则。

    结构匹配不应当被设计为只有成功和失败两种结果。实际对象可能只提供了部分信息,某些属性可能尚未采集,某些关系可能需要进一步确认。后台应当区分完整匹配、部分匹配、不匹配和信息不足等情况。

    完整匹配表示当前信息满足结构定义规定的必要条件;部分匹配表示已经确认部分元素和属性对应关系,但仍有未确认内容;不匹配表示已经发现明确的结构冲突;信息不足表示现有数据无法支持可靠判断。

    这些结果需要传递给后续处理程序,而不能将所有未能完全匹配的情况都直接判定为错误。

    9.2 属性匹配与状态匹配程序

    对象识别确定了当前处理对象,结构候选确定了可能适用的结构定义,接下来需要对实际对象信息中的属性进行匹配。

    属性匹配的基本任务是建立实际信息字段与结构属性定义之间的对应关系,并检查实际数据是否符合属性定义所规定的数据类型、取值范围、格式和必要性要求。

    属性匹配首先需要确认属性标识。实际对象信息可能使用外部系统提供的字段名称,结构定义则使用后台内部统一的属性编码。程序需要通过明确的数据映射关系,将外部字段转换为结构属性编码。

    例如,某设备接口返回:

    {
        "device_no": "D1001",
        "temperature": 36.5,
        "running": true
    }

    而后台结构定义中对应的属性编码可能为:

    {
        "device_code": "设备编号",
        "working_temperature": "工作温度",
        "running_state": "运行状态"
    }

    这两组数据不能因为名称不同就被认定为不匹配,也不能仅仅因为含义看起来相近就自动认定为完全一致。后台需要根据已经确认的数据映射规则,建立外部字段与内部属性编码之间的对应关系。

    属性映射关系应当具有明确来源和适用范围。某个外部字段在一个设备接口中表达工作温度,不代表其他系统中同名字段也具有相同含义。属性映射还应当考虑数据单位、数据类型和取值定义。例如,摄氏度与华氏度虽然都表示温度,但数值不能在没有单位转换的情况下直接比较。

    属性匹配的工程目录可以组织为:

    app/
    └── Intelligence/
        └── Matching/
            ├── AttributeMatcher.php          # 组织实际属性与结构属性的匹配
            ├── AttributeMapper.php           # 根据已确认的映射规则转换属性标识
            ├── AttributeTypeChecker.php      # 检查实际属性数据类型
            ├── AttributeValueChecker.php     # 检查实际属性值与定义约束
            └── AttributeMatchResult.php      # 保存属性匹配结果

    AttributeMapper负责属性标识和必要的数据格式映射,AttributeTypeChecker负责类型检查,AttributeValueChecker负责取值约束检查,AttributeMatcher组织这些程序并形成匹配结果。

    属性匹配程序可以设计为:

    <?php
    
    class AttributeMatcher
    {
        private $mapper;
        private $typeChecker;
        private $valueChecker;
    
        public function __construct(
            AttributeMapper $mapper,
            AttributeTypeChecker $typeChecker,
            AttributeValueChecker $valueChecker
        ) {
            $this->mapper = $mapper;
            $this->typeChecker = $typeChecker;
            $this->valueChecker = $valueChecker;
        }
    
        public function match($actualAttributes, $definitions)
        {
            $results = array();
    
            foreach ($actualAttributes as $sourceCode => $value) {
    
                $attributeCode = $this->mapper
                    ->resolve($sourceCode);
    
                if (!$attributeCode ||
                    !isset($definitions[$attributeCode])) {
    
                    $results[$sourceCode] = array(
                        'status' => 'unmatched',
                        'reason' => '没有对应的结构属性定义'
                    );
    
                    continue;
                }
    
                $definition = $definitions[$attributeCode];
    
                $typeValid = $this->typeChecker
                    ->check(
                        $value,
                        $definition['data_type']
                    );
    
                if (!$typeValid) {
                    $results[$attributeCode] = array(
                        'status' => 'invalid',
                        'reason' => '属性数据类型不符合定义'
                    );
    
                    continue;
                }
    
                $valueValid = $this->valueChecker
                    ->check(
                        $value,
                        $definition
                    );
    
                $results[$attributeCode] = array(
                    'status' => $valueValid
                        ? 'matched'
                        : 'invalid',
                    'value' => $value
                );
            }
    
            return $results;
        }
    }

    上述代码展示属性匹配的基本组织方式。AttributeMapper的映射规则必须来自已经确认的映射定义,不能通过程序临时猜测外部字段的语义。属性类型检查和属性值检查则需要根据结构定义中保存的类型与验证规则执行。

    属性匹配还需要检查结构定义中的必需属性是否已经获得实际信息。如果某个必需属性没有采集到,后台应当将其标记为缺失,而不是默认认定其值为空或自动补充一个未经确认的值。对于允许使用默认值的属性,则需要依据结构定义中的默认值规则处理,并明确区分实际采集值和默认值。

    属性匹配结果不仅需要记录是否匹配,还应保留原始信息、映射后的属性编码、实际值、数据类型和验证结果。这样,后续程序能够根据匹配结果继续处理,也能够在出现冲突时追溯数据来源。

    状态匹配则是在属性匹配的基础上,进一步识别实际对象当前处于什么状态。

    状态本身通常也是对象属性的一部分,但状态具有明显的动态特征。对象的结构定义可能规定其具有运行状态、工作模式、连接状态和异常状态等属性,而实际运行过程中这些属性会不断变化。因此,状态匹配需要同时考虑结构定义、状态值、状态来源和状态更新时间。

    例如,一个设备结构定义规定设备状态可以是待机、运行、暂停、故障和停止。实际设备当前返回的状态值可能是running。后台需要依据已经建立的状态映射规则,将其转换为结构定义中的运行状态,而不能直接把不同系统中的状态编码混合使用。

    状态匹配还必须检查状态转换是否合理。某些对象的状态变化受到明确约束,例如设备从停止状态进入运行状态之前,可能必须经过初始化或准备状态。状态匹配程序需要区分当前状态是否有效与状态变化是否符合规则。前者属于状态识别,后者属于状态转换判断。

    状态匹配程序可以设计为:

    <?php
    
    class StateMatcher
    {
        private $stateMapper;
        private $stateRuleRepository;
    
        public function __construct(
            StateMapper $stateMapper,
            StateRuleRepository $stateRuleRepository
        ) {
            $this->stateMapper = $stateMapper;
            $this->stateRuleRepository = $stateRuleRepository;
        }
    
        public function match(
            $actualState,
            $stateDefinition,
            $previousState = null
        ) {
            $normalizedState = $this->stateMapper
                ->resolve($actualState);
    
            if ($normalizedState === null) {
                return array(
                    'matched' => false,
                    'status' => 'unknown'
                );
            }
    
            if (!in_array(
                $normalizedState,
                $stateDefinition['allowed_states'],
                true
            )) {
                return array(
                    'matched' => false,
                    'status' => 'invalid'
                );
            }
    
            if ($previousState !== null) {
    
                $allowed = $this->stateRuleRepository
                    ->canTransition(
                        $previousState,
                        $normalizedState
                    );
    
                if (!$allowed) {
                    return array(
                        'matched' => false,
                        'status' => 'transition_invalid'
                    );
                }
            }
    
            return array(
                'matched' => true,
                'status' => 'matched',
                'current_state' => $normalizedState
            );
        }
    }

    这段程序展示了状态值规范化、状态定义检查和状态转换检查之间的关系。实际状态规则必须由对应对象结构定义或经过确认的状态规则提供。对于没有明确状态转换约束的对象,程序不能擅自假设所有状态都必须遵循某一种固定顺序。

    属性匹配与状态匹配最终都应当形成结构化结果。属性匹配确认实际数据与属性定义之间的关系,状态匹配确认实际对象当前状态是否符合结构定义和转换约束。两类结果共同提供给后续关系判断和条件处理程序。

    9.3 结构关系判断与条件处理

    属性匹配解决的是实际信息与结构属性之间的对应问题,状态匹配解决的是对象当前状态的识别问题,而结构关系判断则进一步确定对象、元素及其状态之间是否满足结构定义所规定的关联条件。

    在复杂对象中,一个对象可能由多个子对象构成,也可能与其他对象存在依赖、连接、控制或协作关系。仅仅识别各个对象和属性,并不能确定整个结构当前是否满足某项任务要求。后台必须结合关系定义和实际对象关系进行判断。

    例如,某个设备控制结构中存在控制器、传感器和执行机构。结构定义规定控制器与传感器之间存在数据读取关系,控制器与执行机构之间存在控制关系。实际运行时,后台需要检查控制器是否能够识别传感器,传感器是否提供有效数据,以及执行机构是否属于当前控制器允许控制的对象范围。

    这里需要区分结构定义中的关系和实际对象之间的关系。结构定义中的关系说明对象结构应当具有什么联系,实际关系信息说明当前运行环境中是否存在对应联系。结构关系判断就是将两者进行对应,并判断实际关系是否符合结构定义。

    关系判断首先需要确定实际关系的两端对象,再将其映射到结构元素。随后根据关系类型检查关系方向、关系状态和关系约束。

    例如,某个结构定义规定元素A通过控制关系关联元素B,那么实际运行数据必须能够确认A与B之间存在对应的控制联系。如果实际关系方向相反,或者实际对象之间只存在普通数据关联,而结构要求的是控制关系,就不能直接判定关系匹配成功。

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

    app/
    └── Intelligence/
        └── Matching/
            ├── RelationMatcher.php          # 组织结构关系与实际关系的匹配
            ├── RelationResolver.php         # 定位实际关系两端对象
            ├── RelationTypeChecker.php      # 检查实际关系类型
            ├── RelationDirectionChecker.php # 检查关系方向
            └── RelationConditionEvaluator.php # 判断关系是否满足条件

    RelationMatcher负责统一组织关系匹配过程,RelationResolver负责定位实际关系对象,关系类型和方向检查程序负责验证关系定义,RelationConditionEvaluator则根据具体关系约束形成条件判断结果。

    关系判断并不是只检查两个对象是否同时存在。对于依赖关系,还需要判断被依赖对象是否处于可用状态;对于控制关系,还需要检查控制主体是否具有相应权限;对于组成关系,还需要确认组成对象是否属于当前整体对象;对于连接关系,则需要检查连接是否真实存在且处于有效状态。

    因此,关系判断必须允许调用属性匹配和状态匹配结果。例如,两个设备之间已经建立连接关系,但其中一个设备处于故障状态,那么关系本身可能存在,然而当前任务条件可能不允许继续使用该关系。

    这就引出了条件处理机制。

    条件处理是将结构定义、实际属性、对象状态和关系判断结果组织起来,对某项需求或任务所要求的条件进行检查。条件可以涉及单个属性,也可以涉及多个属性的组合,还可以涉及对象之间的关系和状态约束。

    例如,某个任务要求设备处于运行状态,工作温度处于规定范围,并且控制器与传感器之间的数据关系有效。后台需要分别取得设备状态、温度属性和对象关系匹配结果,再依据任务条件形成综合判断。

    条件处理程序可以设计为:

    <?php
    
    class RelationConditionEvaluator
    {
        public function evaluate($conditions, $matchResults)
        {
            $results = array();
    
            foreach ($conditions as $condition) {
    
                $type = $condition['type'];
                $code = $condition['code'];
    
                if (!isset($matchResults[$type][$code])) {
                    $results[] = array(
                        'condition' => $code,
                        'status' => 'unknown'
                    );
    
                    continue;
                }
    
                $actual = $matchResults[$type][$code];
    
                $results[] = array(
                    'condition' => $code,
                    'status' => $this->checkCondition(
                        $condition,
                        $actual
                    )
                );
            }
    
            return $results;
        }
    
        private function checkCondition($condition, $actual)
        {
            if ($condition['operator'] === 'equals') {
                return $actual == $condition['expected']
                    ? 'satisfied'
                    : 'not_satisfied';
            }
    
            if ($condition['operator'] === 'exists') {
                return $actual !== null
                    ? 'satisfied'
                    : 'not_satisfied';
            }
    
            return 'unsupported';
        }
    }

    这段程序只是基础条件处理示例,实际工程中需要根据条件类型建立统一的条件表达式定义,支持数值范围、状态判断、关系存在性、关系方向、组合条件和依赖条件等不同处理方式。

    对于组合条件,还需要明确逻辑关系。例如,多个条件之间可能是全部满足、任一满足或者按照指定顺序执行。条件组合关系必须由任务要求或结构规则明确给出,不能由程序开发人员随意决定。

    条件处理的结果应当保留每个条件的判断状态,而不是只输出一个总结果。这样,后续决策程序能够知道究竟是哪个属性不满足、哪个对象状态异常,或者哪一条关系尚未建立。

    对于信息不足的条件,应当单独标记为未知或待确认,不能自动等同于满足条件。特别是在设备控制、机器人和无人机运行等应用场景中,缺少必要状态信息时不应当被程序默认解释为允许执行。

    9.4 比较、计算、判断、匹配等方法的程序组织

    结构匹配和条件处理需要调用一组基础处理方法。比较、计算、判断、匹配、概率、排序和验证等方法,是后台对结构数据及实际信息进行处理时可以使用的基本操作。

    这些方法不应当散布在对象识别、属性匹配、关系判断和条件处理程序中,形成大量重复代码。工程上需要建立统一的方法组织机制,使不同智能处理程序能够按照明确的参数定义调用相应方法。

    这里需要明确方法与能力的区别。比较、计算、判断和匹配是具体操作方法,知识能力则是通过结构化知识、方法及其组织关系形成的可用于解决问题的能力。一个方法可以被多个能力调用,同一个能力也可能需要多个方法共同完成。不能把某一个方法直接等同于完整的智能能力。

    基础方法的工程组织可以采用统一的方法接口。每种方法具有明确的方法编码、输入参数和输出结果,并通过方法注册机制供其他程序调用。

    拟定目录结构如下:

    app/
    └── Intelligence/
        └── Methods/
            ├── MethodInterface.php          # 定义基础方法的统一调用接口
            ├── MethodRegistry.php           # 注册和查询基础方法实现
            ├── MethodDispatcher.php         # 根据方法标识分派具体方法
            ├── ComparisonMethod.php         # 实现对象、属性和值的比较操作
            ├── CalculationMethod.php        # 实现数值和表达式计算操作
            ├── JudgmentMethod.php           # 实现条件与规则判断操作
            ├── MatchingMethod.php           # 实现结构与信息的匹配操作
            ├── ProbabilityMethod.php        # 实现概率计算操作
            ├── SortingMethod.php            # 实现数据与对象排序操作
            └── VerificationMethod.php       # 实现结果和约束验证操作

    MethodInterface定义统一调用约定,具体方法类分别实现各自的操作。MethodRegistry负责管理方法编码与实现类之间的对应关系,MethodDispatcher负责根据调用请求找到方法实现并完成分派。

    基础方法接口可以设计为:

    <?php
    
    interface MethodInterface
    {
        public function execute($parameters);
    }

    比较方法负责比较两个数据对象或属性值之间的关系。它可以支持相等、不相等、大于、小于以及其他经过定义的比较操作。

    <?php
    
    class ComparisonMethod implements MethodInterface
    {
        public function execute($parameters)
        {
            $left = $parameters['left'];
            $right = $parameters['right'];
            $operator = $parameters['operator'];
    
            switch ($operator) {
    
                case 'equal':
                    return $left == $right;
    
                case 'not_equal':
                    return $left != $right;
    
                case 'greater':
                    return $left > $right;
    
                case 'less':
                    return $left < $right;
    
                default:
                    throw new Exception('不支持的比较操作');
            }
        }
    }

    计算方法负责执行明确的数值运算或经过定义的表达式计算。计算方法应当检查输入数据类型、运算符和运算边界,不能直接执行未经约束的任意程序字符串。

    <?php
    
    class CalculationMethod implements MethodInterface
    {
        public function execute($parameters)
        {
            $left = $parameters['left'];
            $right = $parameters['right'];
            $operator = $parameters['operator'];
    
            switch ($operator) {
    
                case 'add':
                    return $left + $right;
    
                case 'subtract':
                    return $left - $right;
    
                case 'multiply':
                    return $left * $right;
    
                case 'divide':
                    if ($right == 0) {
                        throw new Exception('除数不能为零');
                    }
    
                    return $left / $right;
    
                default:
                    throw new Exception('不支持的计算操作');
            }
        }
    }

    判断方法根据条件和判断规则形成判断结果。它可以调用比较方法,但不应当在每个判断场景中重复编写比较逻辑。

    <?php
    
    class JudgmentMethod implements MethodInterface
    {
        private $comparisonMethod;
    
        public function __construct(
            ComparisonMethod $comparisonMethod
        ) {
            $this->comparisonMethod = $comparisonMethod;
        }
    
        public function execute($parameters)
        {
            return $this->comparisonMethod->execute(
                array(
                    'left' => $parameters['actual'],
                    'right' => $parameters['expected'],
                    'operator' => $parameters['operator']
                )
            );
        }
    }

    匹配方法则根据已经明确的匹配规则,对两个结构对象、属性集合或关系集合进行对应处理。它不能只依靠名称相同进行判断,而应当使用结构定义中的对象标识、属性编码、类型和关系约束。

    概率方法用于执行明确的概率计算。概率计算的输入条件、计算范围和结果含义必须清楚,不能将概率方法变成不透明的外部预测模型,也不能用概率结果替代结构定义、必要条件或执行安全约束。

    排序方法负责按照明确的排序规则组织对象或数据。验证方法则用于检查某个结果是否满足规定的约束。它们分别解决不同的操作问题,不应当因为都属于基础方法而被混合为一个通用处理程序。

    方法注册程序可以采用如下方式:

    <?php
    
    class MethodRegistry
    {
        private $methods = array();
    
        public function register($methodCode, MethodInterface $method)
        {
            $this->methods[$methodCode] = $method;
        }
    
        public function get($methodCode)
        {
            if (!isset($this->methods[$methodCode])) {
                throw new Exception('方法不存在:' . $methodCode);
            }
    
            return $this->methods[$methodCode];
        }
    }

    方法分派程序则根据方法标识调用对应实现:

    <?php
    
    class MethodDispatcher
    {
        private $registry;
    
        public function __construct(MethodRegistry $registry)
        {
            $this->registry = $registry;
        }
    
        public function dispatch($methodCode, $parameters)
        {
            $method = $this->registry->get($methodCode);
    
            return $method->execute($parameters);
        }
    }

    这套机制使基础方法具有统一的调用入口。结构匹配程序需要比较两个属性值时,可以调用比较方法;条件处理程序需要执行数值范围判断时,可以调用判断方法;关系处理程序需要检查关联对象是否符合规定时,可以调用匹配和验证方法。

    方法调用必须遵守明确的参数约定。调用程序不能只传递一个含义不清的数组,再由具体方法随意解释其中字段。实际工程中,应当根据方法定义建立参数验证程序,检查必需参数、参数类型、允许操作和输出格式。

    对于可能产生外部影响的方法,还必须与基础计算方法区分。例如,比较和计算通常只处理数据,而启动设备、改变机器人动作或控制无人机飞行则属于具有外部执行影响的方法。后者必须经过个体权限、执行规则和安全约束检查,不能因为它们也能够通过MethodDispatcher调用,就与普通数据运算采用相同的执行条件。

    9.5 结构匹配结果与后续处理过程的衔接

    结构匹配并不是整个智能处理过程的终点。它的工程意义在于,将实际对象信息与结构定义建立对应关系,并形成可以被后续程序使用的处理结果。

    这些结果需要进入知识能力调用、认知判断、决策依据构建和方法形成过程。不同的匹配结果应当引导不同的后续处理路径,而不是无论匹配结果如何都直接进入执行阶段。

    结构匹配结果首先需要统一数据格式。结果中应当包含当前实际对象标识、匹配使用的结构标识、结构版本、元素匹配结果、属性匹配结果、状态匹配结果、关系匹配结果以及条件处理结果。

    例如,后台完成某个设备对象的结构匹配后,结果可以组织为:

    {
        "object_id": "D1001",
        "structure_code": "device_structure",
        "version_id": 12,
        "match_status": "partial",
        "elements": {
            "device": "matched",
            "controller": "matched",
            "sensor": "unconfirmed"
        },
        "attributes": {
            "device_code": "matched",
            "working_temperature": "matched",
            "running_state": "matched"
        },
        "relations": {
            "controller_sensor": "unconfirmed",
            "controller_device": "matched"
        },
        "conditions": {
            "device_available": "satisfied",
            "sensor_data_available": "unknown"
        }
    }

    这是一种结构匹配结果的数据表达示例,不代表已经建立了某个真实设备的运行记录。它说明后台不仅要记录最终匹配状态,还应当保留各个组成部分的具体结果。

    结构匹配结果的处理需要根据实际情况区分不同路径。

    当结构匹配完整、必要属性有效、状态信息明确、关系约束满足时,后台可以将匹配结果交给后续知识能力调用和认知判断程序。

    当结构匹配部分完成,但仍然缺少某些必要信息时,后台应当根据缺失内容决定是否继续获取信息、补充结构定义或等待进一步确认。对于能够通过正常信息采集补齐的数据,可以进入信息获取流程;对于结构定义本身缺少必要元素的情况,则需要反馈给知识结构化机制进行调整。

    当结构匹配发现明确冲突时,例如对象类型不一致、属性数据违反定义约束或关系方向不符合结构要求,后台应当保留冲突信息,并将其交给相应的处理程序。不能通过简单降低匹配要求的方式,将明确不符合结构定义的信息强行认定为匹配成功。

    当匹配结果显示信息来源不可靠、状态已经过期或关键属性无法确认时,应当将其标记为信息不足或待确认。尤其在涉及设备和个体自主控制的情况下,未知状态不能自动转化为允许执行的条件。

    为了使匹配结果能够稳定进入后续程序,需要建立统一的结果对象。

    <?php
    
    class StructureMatchResult
    {
        private $objectId;
        private $structureCode;
        private $versionId;
        private $status;
        private $elements;
        private $attributes;
        private $relations;
        private $conditions;
    
        public function __construct($data)
        {
            $this->objectId = $data['object_id'];
            $this->structureCode = $data['structure_code'];
            $this->versionId = $data['version_id'];
            $this->status = $data['match_status'];
    
            $this->elements = $data['elements'];
            $this->attributes = $data['attributes'];
            $this->relations = $data['relations'];
            $this->conditions = $data['conditions'];
        }
    
        public function getStatus()
        {
            return $this->status;
        }
    
        public function getElements()
        {
            return $this->elements;
        }
    
        public function getAttributes()
        {
            return $this->attributes;
        }
    
        public function getRelations()
        {
            return $this->relations;
        }
    
        public function getConditions()
        {
            return $this->conditions;
        }
    
        public function toArray()
        {
            return array(
                'object_id' => $this->objectId,
                'structure_code' => $this->structureCode,
                'version_id' => $this->versionId,
                'match_status' => $this->status,
                'elements' => $this->elements,
                'attributes' => $this->attributes,
                'relations' => $this->relations,
                'conditions' => $this->conditions
            );
        }
    }

    匹配结果对象为后续处理提供统一接口。后续程序不必重新读取原始数据,也不必重复执行结构匹配,而是可以根据结果对象取得已经确认的元素、属性、关系和条件状态。

    在后台整体调用关系中,结构匹配结果应当进入后续智能处理协调程序。

    实际对象信息
            │
            ▼
    对象识别
            │
            ▼
    结构候选确定
            │
            ▼
    结构匹配
            │
            ├── 元素匹配
            ├── 属性匹配
            ├── 状态匹配
            └── 关系匹配
            │
            ▼
    条件处理
            │
            ▼
    结构匹配结果
            │
            ├── 匹配完整
            │       └── 进入知识能力调用与认知处理
            │
            ├── 部分匹配
            │       └── 补充信息或继续结构确认
            │
            ├── 信息不足
            │       └── 进入信息获取与确认过程
            │
            └── 明确冲突
                    └── 返回结构修正或异常处理过程

    结构匹配结果与后续处理过程之间还需要建立结果追溯关系。后台应当能够知道某个判断使用了哪个结构版本、哪些实际对象信息、哪些属性匹配结果和哪些关系判断结果。这样,当后续认知或决策出现问题时,才能追溯问题究竟来自结构定义、外部信息、属性映射、关系识别还是条件判断。

    结构匹配结果还可以成为自主智能进化学习的输入。当个体运行过程中反复出现某类对象无法匹配、属性缺失或关系定义不完整的情况时,中央控制后台可以根据反馈识别现有结构知识的缺口,形成新的需求,再进入需求驱动的知识构建过程。

    但匹配失败本身不能直接等同于需要学习或结构扩展。它也可能是外部数据采集错误、设备状态异常、接口数据格式变化或实际对象不符合原有结构定义。后台必须先识别问题来源,再确定是否需要形成新的结构定义或知识能力。

    因此,结构匹配结果不仅服务于当前任务处理,也为后台持续识别知识缺口、调整结构定义和构建新知识能力提供数据依据。

    本章小结

    结构匹配与智能处理机制解决的是实际对象信息如何与已有结构定义建立对应关系,以及匹配结果如何进入后续智能处理的问题。

    对象识别确定当前处理对象,结构候选确定可能适用的结构定义,属性匹配建立实际数据与结构属性之间的对应关系,状态匹配识别实际对象的当前状态,结构关系判断确认对象之间的实际联系是否符合结构定义,条件处理则将属性、状态和关系结果组织为明确的条件判断。

    比较、计算、判断、匹配、概率、排序和验证等方法为这些处理过程提供统一的基础操作机制。通过方法接口、方法注册和方法分派,后台能够避免重复编写处理逻辑,并使基础方法能够被不同结构处理程序和知识能力共同调用。

    结构匹配最终形成结构化结果,并根据匹配完整性、信息不足、部分匹配和明确冲突等情况进入不同后续处理路径。匹配完整的结果可以进入知识能力调用、认知和决策过程;存在缺口的结果可以进入信息获取、结构修正或知识构建过程;存在明确冲突的结果则需要进入相应的异常处理和结构校正过程。

    由此,结构定义、结构解析、结构匹配和智能处理形成了连续的工程链条。结构定义提供处理依据,结构解析形成运行对象,结构匹配建立实际信息与结构知识的对应关系,基础方法完成具体运算和判断,匹配结果再进入后台更高层次的智能处理过程。

    下一章将进一步讨论智能控制后台的核心运行机制,研究如何将结构解析、结构匹配、基础方法调用以及需求驱动、知识构建和能力处理组织为统一的后台智能运行过程。

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