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

第十九章 知识能力的程序化实现

第十九章 知识能力的程序化实现

  1. 知识能力的数据模型设计

  2. 知识能力与结构定义的关联

  3. 知识能力与方法实现的映射

  4. 知识能力的加载与调用程序

  5. 知识能力的运行测试与结果验证

第十九章 知识能力的程序化实现

知识能力形成之后,需要进一步转化为能够被智能控制后台识别、加载、调用和执行的程序化对象。知识能力并不是一段独立的程序代码,也不是将知识内容简单保存到数据库后即可直接运行。它是由知识结构、结构关系、适用条件、方法定义、方法实现以及运行约束共同构成的动态能力对象。只有建立知识能力与结构定义、方法实现和实际运行对象之间的关联,才能使知识能力从知识构建结果转化为可调用、可验证、可赋值的工程能力。

在WSaiOS工程中,知识能力的程序化实现由智能控制后台负责。后台根据需求驱动形成的知识结构和能力定义,建立统一的数据模型,将能力所依赖的结构定义、方法调用关系、运行条件和验证规则组织起来。个体获得知识能力赋值后,并不是重新构建整套知识体系,而是依据赋值结果加载相应的知识能力,在自身运行环境中完成对象识别、结构匹配、条件判断、方法调用和结果反馈。

因此,本章的工程重点不是单纯建立一个知识能力数据库,而是建立知识能力从定义、关联、映射到运行调用的完整程序机制,使知识能力能够被后台统一管理,又能够根据不同个体的任务职责进行独立配置和运行。

19.1 知识能力的数据模型设计

知识能力的数据模型设计首先要解决知识能力如何在程序中被准确描述的问题。第十八章已经讨论了知识结构与能力形成之间的关系,明确了知识能力由知识结构、结构关系和方法组合共同形成。本章需要将这些已经形成的能力关系转化为可以保存、检索、加载和执行的数据对象。

知识能力的数据模型不能仅使用一个能力名称和一段能力描述来表达。例如,将某个能力定义为“识别设备故障”,只能说明能力的业务含义,却无法说明该能力需要识别什么对象、读取哪些属性、判断哪些状态、依据什么关系形成判断,以及最终调用什么方法。这样的描述无法直接进入程序运行过程。

因此,知识能力的数据模型必须包含能力定义本身,也必须包含能力所依赖的知识结构、结构关系、方法集合、适用条件和验证依据。能力定义负责表达能力对象的基本信息,结构关联负责确定能力所依据的知识范围,方法映射负责确定能力如何转化为可执行操作,运行条件负责限制能力的适用范围,验证定义负责判断能力是否达到预期结果。

在工程实现中,可以将知识能力设计为独立的数据实体,并通过关联标识连接结构定义、方法定义和验证规则。能力数据不直接复制所有结构内容和方法代码,而是保存对应的引用关系。这样既能避免同一结构被不同能力重复保存,也能使知识结构更新后,通过版本和依赖关系判断哪些能力需要重新验证。

知识能力的基础数据模型可以采用JSON形式表达:

{
    "capability_id": "cap_001",
    "capability_name": "设备状态识别能力",
    "capability_version": "1.0.0",
    "description": "依据设备对象属性和状态关系识别设备当前运行状态",
    "status": "active",
    "structure_refs": [
        {
            "structure_id": "str_device",
            "structure_version": "1.0.0",
            "relation_type": "required"
        },
        {
            "structure_id": "str_device_state",
            "structure_version": "1.0.0",
            "relation_type": "required"
        }
    ],
    "method_refs": [
        {
            "method_id": "method_object_match",
            "method_version": "1.0.0",
            "sequence": 1
        },
        {
            "method_id": "method_state_match",
            "method_version": "1.0.0",
            "sequence": 2
        },
        {
            "method_id": "method_result_verify",
            "method_version": "1.0.0",
            "sequence": 3
        }
    ],
    "conditions": {
        "required_objects": [
            "device"
        ],
        "required_attributes": [
            "running_status",
            "temperature"
        ]
    },
    "validation": {
        "validator_id": "validator_device_state",
        "required": true
    }
}

这个数据模型表达的是知识能力与其他工程对象之间的关系,而不是把所有运行程序写入一个JSON文件。capability_id用于确定能力的唯一身份,capability_version用于区分能力的不同版本,structure_refs保存能力依赖的结构定义,method_refs保存能力执行所需的方法引用,conditions保存能力运行前需要满足的条件,validation保存能力结果验证的依据。

这里的sequence表示方法在当前能力执行流程中的组织顺序,但并不意味着所有方法都必须按照固定的线性顺序运行。对于存在条件分支、重复判断或关系依赖的能力,应进一步建立方法之间的执行关系,由能力运行程序根据当前对象状态和条件匹配结果决定实际调用路径。

在数据库设计上,可以将知识能力本身、结构关联、方法关联和验证定义分别保存。这样做的目的是使能力定义具有稳定的主体结构,同时允许能力依赖关系动态调整。

拟定的数据表结构如下:

CREATE TABLE knowledge_capabilities (
    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    capability_id VARCHAR(100) NOT NULL,
    capability_name VARCHAR(200) NOT NULL,
    capability_version VARCHAR(30) NOT NULL,
    description TEXT,
    status VARCHAR(30) NOT NULL DEFAULT 'draft',
    definition_json LONGTEXT,
    created_at DATETIME,
    updated_at DATETIME,
    UNIQUE KEY uk_capability_version (
        capability_id,
        capability_version
    )
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

该表保存知识能力的主体定义。definition_json用于保存能力定义中的扩展信息,避免在能力结构尚未完全稳定时频繁修改数据库字段。能力的身份、名称、版本和状态则使用独立字段保存,以便进行检索、版本管理和状态控制。

知识能力与结构定义之间需要建立独立的关联表:

CREATE TABLE capability_structures (
    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    capability_id VARCHAR(100) NOT NULL,
    capability_version VARCHAR(30) NOT NULL,
    structure_id VARCHAR(100) NOT NULL,
    structure_version VARCHAR(30) NOT NULL,
    relation_type VARCHAR(50) NOT NULL,
    required_flag TINYINT(1) NOT NULL DEFAULT 1,
    created_at DATETIME,
    KEY idx_capability (
        capability_id,
        capability_version
    ),
    KEY idx_structure (
        structure_id,
        structure_version
    )
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

该表用于记录某项能力需要哪些结构定义,以及每个结构在能力中的关联性质。required_flag表示该结构是否属于能力运行的必要依赖。对于可选结构,可以在运行时根据实际对象和需求情况决定是否加载。

知识能力与方法之间同样需要独立的关联表:

CREATE TABLE capability_methods (
    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    capability_id VARCHAR(100) NOT NULL,
    capability_version VARCHAR(30) NOT NULL,
    method_id VARCHAR(100) NOT NULL,
    method_version VARCHAR(30) NOT NULL,
    sequence_no INT NOT NULL DEFAULT 0,
    relation_type VARCHAR(50) NOT NULL DEFAULT 'execute',
    condition_json LONGTEXT,
    created_at DATETIME,
    KEY idx_capability_method (
        capability_id,
        capability_version
    ),
    KEY idx_method (
        method_id,
        method_version
    )
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

该表解决方法定义与知识能力之间的映射问题。一个知识能力可以关联多个方法,同一个方法也可以被多个知识能力引用。方法关联记录中的condition_json可以保存方法执行的前置条件、调用限制或分支条件。

对于能力验证,还需要保存验证规则与能力之间的关系:

CREATE TABLE capability_validators (
    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    capability_id VARCHAR(100) NOT NULL,
    capability_version VARCHAR(30) NOT NULL,
    validator_id VARCHAR(100) NOT NULL,
    validator_version VARCHAR(30) NOT NULL,
    required_flag TINYINT(1) NOT NULL DEFAULT 1,
    created_at DATETIME,
    KEY idx_capability_validator (
        capability_id,
        capability_version
    )
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

以上数据表构成知识能力的基础数据模型。实际工程中还需要建立方法定义表、结构定义表以及相应的版本管理机制。这里的关联表只保存引用关系,不应将方法源代码直接写入能力关联记录。方法的具体实现由独立的方法程序管理,知识能力只负责确定调用哪些方法以及在什么条件下调用。

程序目录可以按照以下方式组织:

app/                                           # 智能控制后台应用程序目录
└── Intelligence/                              # 智能控制后台核心智能程序
    └── Knowledge/                             # 知识构建与知识能力管理程序
        └── Capability/                        # 知识能力程序化实现目录
            ├── Models/                         # 知识能力及关联对象的数据模型
            │   ├── Capability.php              # 知识能力主体模型
            │   ├── CapabilityStructure.php     # 能力与结构定义的关联模型
            │   ├── CapabilityMethod.php        # 能力与方法的关联模型
            │   └── CapabilityValidator.php     # 能力验证规则关联模型
            ├── Repositories/                   # 知识能力数据访问程序
            │   ├── CapabilityRepository.php    # 能力定义的数据读取与保存
            │   ├── StructureRepository.php     # 能力依赖结构的读取程序
            │   ├── MethodRepository.php        # 能力关联方法的读取程序
            │   └── ValidatorRepository.php     # 能力验证定义的读取程序
            └── CapabilityDefinitionManager.php # 知识能力定义的统一管理入口

这里的Models负责描述数据对象,Repositories负责与数据库中的定义记录交互,CapabilityDefinitionManager.php负责组织能力定义的创建、读取、修改和状态管理。模型本身不承担数据库查询和实际方法执行职责,数据访问程序也不负责决定能力是否能够运行。这样的程序边界有利于后续将能力构建、能力加载和能力执行分别实现。

知识能力的数据模型建立后,智能控制后台便可以将知识构建过程中形成的能力定义转换为正式的工程数据对象。后续结构关联和方法映射均以这一能力对象为中心展开。

19.2 知识能力与结构定义的关联

知识能力不是脱离结构而独立存在的程序对象。能力的形成依赖于知识结构所提供的对象定义、属性定义、关系定义和状态定义。程序化实现必须明确每项能力依赖哪些结构,以及这些结构之间如何构成能力运行所需要的完整条件。

例如,设备状态识别能力需要设备对象结构、设备属性结构和设备状态关系结构。设备对象结构用于确认当前处理对象属于什么对象类型,属性结构用于确定设备有哪些可识别属性,状态关系结构用于描述属性值与运行状态之间的关系。只有这些结构能够按照能力定义正确关联,程序才具备执行状态识别的知识依据。

这里需要区分结构定义与知识能力之间的关系。结构定义负责描述对象及其内部组成,知识能力负责利用这些结构完成特定问题的处理。结构定义本身不等于能力,能力也不应重新复制一份完整结构定义。两者通过明确的引用关系连接,结构定义提供知识依据,能力定义确定这些知识依据在具体问题中的组织方式和使用范围。

在程序中,可以为知识能力建立结构依赖描述对象:

<?php

class CapabilityStructure
{
    private $capabilityId;
    private $structureId;
    private $structureVersion;
    private $relationType;
    private $required;

    public function __construct($data)
    {
        $this->capabilityId = $data['capability_id'];
        $this->structureId = $data['structure_id'];
        $this->structureVersion = $data['structure_version'];
        $this->relationType = $data['relation_type'];
        $this->required = !empty($data['required']);
    }

    public function getStructureId()
    {
        return $this->structureId;
    }

    public function getStructureVersion()
    {
        return $this->structureVersion;
    }

    public function getRelationType()
    {
        return $this->relationType;
    }

    public function isRequired()
    {
        return $this->required;
    }
}

该类只表达能力与结构之间的关联信息,不负责解析结构内容。结构的读取和解析仍然由后台已有的结构管理与结构解析程序完成。这样可以避免知识能力程序与结构解析程序形成重复实现。

知识能力加载结构时,需要根据能力定义读取结构引用,并检查结构版本是否符合能力要求。若能力要求的是某个确定版本,就不能在不检查兼容性的情况下直接加载最新版本。否则,结构中的属性、关系或状态定义发生变化后,原有方法可能无法按照预期处理新结构。

因此,结构加载过程需要建立依赖检查。其基本过程是:读取能力定义,取得结构依赖清单,根据结构标识和版本读取对应定义,检查结构是否存在、是否有效、是否完整,再将结构解析结果交给能力运行环境。

结构依赖加载程序可以设计为:

<?php

class CapabilityStructureLoader
{
    private $structureRepository;
    private $structureParser;

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

    public function load($references)
    {
        $loaded = array();

        foreach ($references as $reference) {
            $definition = $this->structureRepository->find(
                $reference['structure_id'],
                $reference['structure_version']
            );

            if (!$definition) {
                if (!empty($reference['required'])) {
                    throw new Exception(
                        'Required structure not found: ' .
                        $reference['structure_id']
                    );
                }

                continue;
            }

            $structure = $this->structureParser->parse(
                $definition
            );

            $loaded[] = $structure;
        }

        return $loaded;
    }
}

这里的StructureRepository负责根据结构标识和版本读取结构定义,StructureParser负责将结构定义转换为后台能够使用的结构对象。CapabilityStructureLoader只负责按照能力依赖关系组织加载过程。

结构依赖加载完成后,还需要检查结构之间的关联完整性。单独存在的对象结构、属性结构和关系结构,并不一定能够组成能力所需要的知识结构。例如,某项能力要求识别设备的温度状态,但设备结构中没有温度属性定义,或者温度属性没有与状态判断关系建立有效关联,那么即使相关结构记录都存在,能力仍然无法正常运行。

因此,结构依赖检查不能只验证结构记录是否存在,还要检查能力所需要的对象、属性、关系和状态是否能够通过结构定义建立完整关联。

可以建立独立的结构依赖验证程序:

<?php

class CapabilityStructureValidator
{
    public function validate($capability, $structures)
    {
        $errors = array();

        if (empty($structures)) {
            $errors[] = 'No structures loaded';
        }

        foreach ($capability['required_elements'] as $elementId) {
            $found = false;

            foreach ($structures as $structure) {
                if ($structure->hasElement($elementId)) {
                    $found = true;
                    break;
                }
            }

            if (!$found) {
                $errors[] = 'Required element missing: ' .
                    $elementId;
            }
        }

        return array(
            'valid' => count($errors) === 0,
            'errors' => $errors
        );
    }
}

其中的hasElement()代表结构对象提供的元素查询接口,实际实现应当与第六章的结构元素模型及第八章的结构解析程序衔接。示例中的required_elements是能力定义中用于声明必要元素的字段,具体项目中应根据已经确定的结构数据模型统一命名,不能在不同程序之间随意使用不同字段。

对于一个知识能力依赖多个结构的情况,还需要处理结构之间的关系。例如,设备对象与控制器对象之间可能存在控制关系,设备状态与执行条件之间可能存在约束关系。这些关系不应仅以两个结构标识同时存在作为关联成立的依据,而应由结构关系定义提供明确的关系类型、方向和约束条件。

当结构定义发生变化时,后台需要依据关联表查找受影响的知识能力。若变化仅涉及不影响能力运行的描述信息,可以保留原有能力版本;若变化涉及能力依赖的属性、关系或状态定义,则需要将相关能力标记为待检查状态,并通过后续验证确定是否可以继续使用。

因此,知识能力与结构定义的关联不仅是加载时的查询关系,也是后台进行知识变更管理、能力版本控制和影响范围分析的重要依据。

19.3 知识能力与方法实现的映射

知识能力通过知识结构获得处理问题所需的依据,但知识结构本身并不会自动完成比较、计算、判断、匹配和验证等操作。要使能力真正进入程序运行过程,还必须建立知识能力与方法实现之间的映射关系。

方法与能力之间具有不同的工程职责。方法是可以被程序调用的操作,能力是多个知识结构及相关方法组合后形成的问题处理能力。例如,设备状态识别能力可能需要调用对象匹配方法、属性匹配方法、状态判断方法和结果验证方法。这些方法分别完成局部操作,但单独调用其中一个方法,并不等于完成设备状态识别能力。

因此,能力定义需要明确方法的用途、输入条件、输出结果、调用关系以及执行约束。方法程序则负责具体运算和操作。能力运行程序依据结构匹配结果和当前条件组织方法调用,使多个独立方法按照能力定义形成完整处理过程。

方法映射首先需要建立统一的方法定义。一个方法定义至少应当包含方法标识、方法名称、版本、输入定义、输出定义、适用条件和实现程序标识。

例如:

{
    "method_id": "method_state_match",
    "method_name": "设备状态匹配",
    "method_version": "1.0.0",
    "input": {
        "object": "device",
        "attributes": [
            "running_status",
            "temperature"
        ]
    },
    "output": {
        "type": "state_match_result"
    },
    "implementation": {
        "class": "DeviceStateMatcher",
        "method": "match"
    },
    "status": "active"
}

该定义用于说明方法的程序入口和输入输出约定。具体方法实现仍然保存在独立的PHP程序中,不能把JSON中的类名和方法名当成可以不经检查就执行的任意代码。实际调用时,后台必须通过受控的方法注册表确认方法是否已经登记、是否允许当前能力调用,以及输入输出是否符合方法定义。

方法实现可以使用统一接口约束:

<?php

interface MethodInterface
{
    public function execute($input);
}

不同方法按照这一接口实现。例如,设备状态匹配方法可以写成:

<?php

class DeviceStateMatcher implements MethodInterface
{
    public function execute($input)
    {
        if (!isset($input['attributes'])) {
            throw new InvalidArgumentException(
                'Device attributes are required'
            );
        }

        $attributes = $input['attributes'];

        if (!isset($attributes['running_status'])) {
            throw new InvalidArgumentException(
                'Running status is missing'
            );
        }

        $status = $attributes['running_status'];

        if ($status === 'running') {
            return array(
                'matched' => true,
                'state' => 'normal'
            );
        }

        if ($status === 'stopped') {
            return array(
                'matched' => true,
                'state' => 'stopped'
            );
        }

        return array(
            'matched' => false,
            'state' => 'unknown'
        );
    }
}

这段程序仅展示方法实现的基本形式。真实的设备状态判断不能仅依靠running_status一个属性完成,还应依据实际设备结构、属性定义、状态关系和适用条件组织判断。这里的代码重点是说明方法实现与能力定义之间的程序接口,而不是将设备状态识别简化为固定业务字段。

方法注册程序负责将经过确认的方法标识与实际程序类建立映射:

<?php

class MethodRegistry
{
    private $methods = array();

    public function register($methodId, $method)
    {
        if (!$method instanceof MethodInterface) {
            throw new InvalidArgumentException(
                'Invalid method implementation'
            );
        }

        $this->methods[$methodId] = $method;
    }

    public function get($methodId)
    {
        if (!isset($this->methods[$methodId])) {
            throw new Exception(
                'Method not registered: ' . $methodId
            );
        }

        return $this->methods[$methodId];
    }
}

MethodRegistry不负责判断当前能力是否需要调用某个方法,只负责提供已经登记的方法实现。能力定义管理程序负责维护能力与方法的关联,能力运行程序根据关联记录取得方法标识,再向注册表请求对应的实现对象。

方法调用程序可以采用统一调度方式:

<?php

class MethodDispatcher
{
    private $registry;

    public function __construct($registry)
    {
        $this->registry = $registry;
    }

    public function dispatch($methodId, $input)
    {
        $method = $this->registry->get($methodId);

        return $method->execute($input);
    }
}

这种方式将方法定义、方法实现和方法调用分开。知识能力不需要知道某个方法内部使用什么具体算法,只需要根据方法标识和输入输出约定组织调用。

对于方法之间存在前后依赖的情况,能力运行程序需要根据能力定义组织执行过程。例如,先完成对象匹配,再进行属性匹配,随后根据结构关系调用状态判断,最后对结果进行验证。若前置方法未能形成有效结果,后续方法就不应当继续按照正常路径执行。

方法之间还可能存在条件分支。例如,设备状态识别完成后,如果状态正常,可以进入正常运行判断;如果状态异常,则转入异常状态处理;如果必要属性缺失,则应返回信息不足,而不是直接形成一个确定的状态结论。

因此,能力与方法的映射不应只是一张简单的顺序表,还应当能够描述方法间的输入输出传递关系、前置条件和分支条件。对于复杂能力,可以进一步建立方法执行关系表,将方法之间的依赖关系独立保存,使能力执行流程能够随着知识结构和任务需求变化而调整。

在实际工程中,方法调用还需要受到安全边界约束。能力定义中的方法标识只能调用后台已经登记并允许使用的实现程序,不能直接执行数据库中任意提供的PHP类名、文件路径或动态代码。方法注册、参数验证和调用权限应由后台统一管理。

通过上述映射机制,知识能力便可以将结构定义提供的知识依据与方法实现提供的操作能力组织起来。结构说明处理什么对象、依据什么关系进行处理,方法负责执行具体操作,知识能力负责确定这些结构和方法如何组合以解决特定问题。

19.4 知识能力的加载与调用程序

知识能力完成数据定义、结构关联和方法映射之后,需要建立从能力标识到实际运行程序的加载与调用机制。这是知识能力从静态数据对象进入动态运行过程的关键环节。

在WSaiOS智能控制后台中,能力加载不能简单理解为读取一个数据库记录。能力加载需要同时处理能力主体定义、结构依赖、方法关联、运行条件和版本状态。只有这些内容满足能力运行要求,才能将能力交给运行程序。

能力加载首先根据能力标识读取能力主体定义,并检查能力状态。如果能力处于草稿、停用或待验证状态,就不能作为正式运行能力直接加载。对于已发布的能力,还需要检查调用方请求的版本是否与当前赋值版本一致。

随后,加载程序读取能力所依赖的结构定义,并通过结构解析程序转换为可供匹配和判断使用的结构对象。接着,程序读取能力关联的方法定义,通过方法注册表取得经过登记的方法实现。最后,加载程序检查能力的必要条件和依赖关系,形成完整的能力运行对象。

整个过程可以表示为:

能力调用请求
      |
      v
读取知识能力定义
      |
      v
检查能力状态与版本
      |
      v
读取能力依赖结构
      |
      v
结构解析与依赖验证
      |
      v
读取能力关联方法
      |
      v
方法注册与实现检查
      |
      v
运行条件检查
      |
      v
形成能力运行对象
      |
      v
进入能力执行程序

在程序目录中,需要将能力加载、运行环境和能力调用分别组织:

app/                                               # 智能控制后台应用程序目录
└── Intelligence/                                  # 后台智能处理程序
    └── Knowledge/                                 # 知识与知识能力处理程序
        └── Capability/                            # 知识能力工程实现目录
            ├── Loading/                            # 知识能力加载程序
            │   ├── CapabilityLoader.php           # 能力定义及依赖内容的统一加载入口
            │   ├── CapabilityStructureLoader.php  # 能力依赖结构的加载程序
            │   ├── CapabilityMethodLoader.php     # 能力关联方法的加载程序
            │   └── CapabilityDependencyChecker.php # 能力结构与方法依赖检查程序
            ├── Runtime/                            # 知识能力运行程序
            │   ├── CapabilityRuntime.php           # 能力运行环境及执行上下文管理
            │   ├── CapabilityContext.php           # 保存当前能力运行所需的输入和状态
            │   ├── CapabilityExecutor.php          # 按能力定义组织方法执行
            │   └── CapabilityResult.php            # 统一封装能力运行结果
            ├── Dispatch/                           # 知识能力调用与调度程序
            │   ├── CapabilityDispatcher.php        # 根据能力标识发起能力调用
            │   ├── CapabilityResolver.php          # 根据需求和调用条件解析目标能力
            │   └── CapabilityCallValidator.php     # 检查能力调用请求及调用条件
            └── CapabilityService.php               # 对外提供知识能力加载和调用的统一服务入口

CapabilityLoader.php是加载过程的组织入口。它不直接实现结构解析或方法执行,而是协调各个加载程序完成依赖准备。CapabilityRuntime.php负责为能力执行建立独立上下文,CapabilityExecutor.php负责组织方法调用,CapabilityDispatcher.php负责处理调用请求与目标能力之间的关系。

能力加载程序可以按照以下方式实现:

<?php

class CapabilityLoader
{
    private $capabilityRepository;
    private $structureLoader;
    private $methodLoader;
    private $dependencyChecker;

    public function __construct(
        $capabilityRepository,
        $structureLoader,
        $methodLoader,
        $dependencyChecker
    ) {
        $this->capabilityRepository = $capabilityRepository;
        $this->structureLoader = $structureLoader;
        $this->methodLoader = $methodLoader;
        $this->dependencyChecker = $dependencyChecker;
    }

    public function load($capabilityId, $version)
    {
        $definition = $this->capabilityRepository->find(
            $capabilityId,
            $version
        );

        if (!$definition) {
            throw new Exception('Capability not found');
        }

        if ($definition['status'] !== 'active') {
            throw new Exception('Capability is not active');
        }

        $structures = $this->structureLoader->load(
            $definition['structure_refs']
        );

        $methods = $this->methodLoader->load(
            $definition['method_refs']
        );

        $check = $this->dependencyChecker->check(
            $definition,
            $structures,
            $methods
        );

        if (!$check['valid']) {
            throw new Exception(
                'Capability dependency check failed'
            );
        }

        return array(
            'definition' => $definition,
            'structures' => $structures,
            'methods' => $methods
        );
    }
}

这里的CapabilityRepository负责读取能力定义,CapabilityStructureLoader负责加载结构,CapabilityMethodLoader负责取得方法实现,CapabilityDependencyChecker负责检查能力依赖是否完整。只有所有必要依赖通过检查,加载程序才返回可供运行程序使用的能力对象。

上述代码中的structure_refs和method_refs表示已经通过数据访问程序整理后的关联数据。真实工程中,数据库关联表的记录需要经过Repository转换,不能直接假定数据库返回的数据天然具有这一结构。

能力加载完成后,还需要建立能力运行上下文。运行上下文用于保存当前调用所需的实际对象信息、结构匹配结果、方法执行结果、运行状态和错误信息。这样可以避免将某次运行的数据写入知识能力定义本身,造成能力定义与运行状态混合。

例如:

<?php

class CapabilityContext
{
    private $capability;
    private $input;
    private $structures;
    private $methods;
    private $results = array();
    private $status = 'initialized';

    public function __construct(
        $capability,
        $input,
        $structures,
        $methods
    ) {
        $this->capability = $capability;
        $this->input = $input;
        $this->structures = $structures;
        $this->methods = $methods;
    }

    public function getInput()
    {
        return $this->input;
    }

    public function getStructures()
    {
        return $this->structures;
    }

    public function getMethods()
    {
        return $this->methods;
    }

    public function addResult($methodId, $result)
    {
        $this->results[$methodId] = $result;
    }

    public function getResults()
    {
        return $this->results;
    }

    public function setStatus($status)
    {
        $this->status = $status;
    }

    public function getStatus()
    {
        return $this->status;
    }
}

运行上下文与能力定义相互独立。多个个体可以使用同一个知识能力定义,但每个个体的实际对象信息、运行状态和方法结果都应保存在各自的运行上下文中。这样可以避免不同个体调用同一能力时出现数据混用。

能力执行程序负责根据能力定义调用方法。对于已经建立方法依赖关系的能力,应当按照依赖关系决定调用顺序,并将前一方法的输出作为后续方法的输入依据。以下代码展示一个基础执行过程:

<?php

class CapabilityExecutor
{
    private $dispatcher;

    public function __construct($dispatcher)
    {
        $this->dispatcher = $dispatcher;
    }

    public function execute($context, $methodSequence)
    {
        $context->setStatus('running');

        try {
            $input = $context->getInput();

            foreach ($methodSequence as $method) {
                $methodId = $method['method_id'];

                $result = $this->dispatcher->dispatch(
                    $methodId,
                    $input
                );

                $context->addResult($methodId, $result);

                if (isset($method['stop_on_failure']) &&
                    $method['stop_on_failure'] &&
                    isset($result['matched']) &&
                    !$result['matched']) {

                    $context->setStatus('stopped');

                    return $context->getResults();
                }

                $input = $result;
            }

            $context->setStatus('completed');

            return $context->getResults();

        } catch (Exception $e) {
            $context->setStatus('failed');
            throw $e;
        }
    }
}

该示例采用简单的顺序调用方式,用于说明方法输入输出的传递关系。实际工程中的能力执行不应将所有方法结果都直接覆盖为下一方法的输入。对于不同方法具有不同输入结构的情况,应当根据方法定义建立输入映射,将对象信息、属性匹配结果、状态判断结果分别传递给对应方法。对于条件分支、循环判断和多对象处理,还需要由能力执行关系决定具体运行路径。

能力调用程序则负责根据当前任务或需求选择能力,并将调用请求交给加载程序和执行程序。其基本调用关系如下:

智能控制后台
    |
    v
需求处理与能力匹配
    |
    v
CapabilityDispatcher
    |
    v
CapabilityLoader
    |
    +------> 读取能力定义
    |
    +------> 加载结构定义
    |
    +------> 加载方法实现
    |
    v
CapabilityContext
    |
    v
CapabilityExecutor
    |
    v
MethodDispatcher
    |
    v
具体方法实现
    |
    v
CapabilityResult

在完整的WSaiOS工程中,知识能力调用不是独立于后台智能逻辑之外的另一个智能系统。能力调用属于智能控制后台的知识能力运行机制。后台的需求理解、结构匹配和能力匹配过程确定当前问题需要什么能力,能力加载程序准备相关结构和方法,能力执行程序完成具体处理,最终将结果返回后台的认知、决策和任务组织过程。

当知识能力被赋予个体后,个体也可以在自身运行环境中依据赋值结果加载本地能力。此时需要明确后台能力定义与个体运行实例之间的关系。后台负责能力构建、版本管理和赋值管理,个体依据已获得的能力定义及运行依赖完成本地调用。个体不需要在每次执行任务时都向后台请求完整的知识结构和方法程序。

对于支持通信的运行模式,个体可以根据后台管理规则接收能力更新和运行任务;对于无通信运行模式,个体则需要在部署阶段获得完成自主运行所需的能力定义、结构数据、方法实现和执行约束。两种模式使用的是同一套知识能力定义和调用逻辑,区别在于能力更新、任务传递和运行反馈的传输方式。

19.5 知识能力的运行测试与结果验证

知识能力能够被程序加载和调用,并不意味着它已经具备稳定的问题处理能力。工程上必须通过运行测试验证能力定义、结构依赖、方法映射和实际运行结果是否相互一致。能力测试的对象不是某一个PHP方法是否能够返回结果,而是整个知识能力是否能够依据定义完成预定的问题处理过程。

例如,设备状态识别能力在测试时,不能只检查DeviceStateMatcher是否能够返回一个状态字符串。还必须检查设备对象能否被正确识别,所需属性能否从实际对象信息中取得,属性与结构定义是否匹配,状态判断是否符合知识结构中的关系定义,最终结果是否满足能力定义中的验证要求。

因此,知识能力的测试应当围绕能力定义建立完整的验证过程。首先检查能力定义本身是否完整,确认能力标识、版本、结构依赖、方法关联和验证规则都能够正确读取。随后检查结构依赖是否满足要求,确认能力所需要的对象、属性、关系和状态定义均已加载。接着检查方法映射,确认能力关联的方法均已登记,方法版本与能力定义一致,输入输出约定能够衔接。最后通过不同的实际对象信息执行能力,检查运行结果是否符合预先定义的验证规则。

知识能力运行测试需要覆盖正常条件、异常条件、缺少必要信息、结构不匹配和方法执行失败等情况。只有通过不同条件下的测试,才能判断能力是否真正具有稳定的运行边界。

可以为知识能力建立测试数据模型:

{
    "test_id": "test_cap_001",
    "capability_id": "cap_001",
    "capability_version": "1.0.0",
    "test_name": "设备状态识别测试",
    "input": {
        "object_type": "device",
        "attributes": {
            "running_status": "running",
            "temperature": 35
        }
    },
    "expected": {
        "state": "normal"
    },
    "validation_rules": [
        "object_match",
        "attribute_match",
        "state_match",
        "result_consistency"
    ]
}

测试数据必须与能力依赖的结构定义保持一致。这里的设备属性仅用于说明测试数据的组织方式,实际字段名称和允许值应从设备知识结构中读取,不能将示例中的字段直接固化为WSaiOS的通用能力字段。

测试程序可以建立独立的执行入口:

app/                                                # 智能控制后台应用程序目录
└── Intelligence/                                   # 后台智能处理程序
    └── Knowledge/                                  # 知识能力管理与运行程序
        └── Capability/                             # 知识能力实现目录
            └── Testing/                            # 知识能力测试与结果验证
                ├── CapabilityTestRunner.php        # 组织能力测试用例并执行测试
                ├── CapabilityTestCase.php          # 描述单项能力测试的输入和预期结果
                ├── CapabilityTestDataProvider.php  # 提供不同运行条件下的测试数据
                ├── CapabilityResultValidator.php   # 对实际运行结果进行验证
                ├── CapabilityRegressionTester.php  # 检查能力更新后的原有能力表现
                └── CapabilityTestReport.php        # 组织测试结果和问题记录

CapabilityTestRunner.php负责组织测试过程,CapabilityTestCase.php保存单项测试的输入与预期结果,CapabilityTestDataProvider.php负责提供不同条件下的测试数据,CapabilityResultValidator.php负责比较实际结果与预期要求,CapabilityRegressionTester.php负责检查能力版本更新后原有测试是否仍然通过,CapabilityTestReport.php负责整理测试结果。

测试执行程序可以采用如下形式:

<?php

class CapabilityTestRunner
{
    private $capabilityLoader;
    private $runtime;
    private $resultValidator;

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

    public function run($testCase)
    {
        $capability = $this->capabilityLoader->load(
            $testCase['capability_id'],
            $testCase['capability_version']
        );

        $actual = $this->runtime->execute(
            $capability,
            $testCase['input']
        );

        $validation = $this->resultValidator->validate(
            $actual,
            $testCase['expected'],
            $testCase['validation_rules']
        );

        return array(
            'test_id' => $testCase['test_id'],
            'capability_id' => $testCase['capability_id'],
            'actual_result' => $actual,
            'validation' => $validation
        );
    }
}

该程序将能力加载、能力执行和结果验证串联起来。测试程序不应当直接绕过能力加载和执行过程,单独调用某个方法后就认定能力测试通过。否则,测试只能证明单个方法可以运行,不能证明整个知识能力的结构依赖和方法组织正确。

结果验证程序需要根据不同能力的定义采用不同的验证规则。对于能够明确确定结果的能力,可以检查实际结果是否符合预期值;对于由多个结构关系共同决定的能力,可以检查结果是否满足相应的关系约束;对于涉及多个条件和执行过程的能力,则需要验证各个必要步骤是否完成,以及最终结果是否满足能力定义。

基础结果验证程序可以设计为:

<?php

class CapabilityResultValidator
{
    public function validate(
        $actual,
        $expected,
        $rules
    ) {
        $errors = array();

        foreach ($expected as $key => $value) {
            if (!array_key_exists($key, $actual)) {
                $errors[] = 'Missing result field: ' . $key;
                continue;
            }

            if ($actual[$key] !== $value) {
                $errors[] = 'Result mismatch: ' . $key;
            }
        }

        return array(
            'valid' => count($errors) === 0,
            'errors' => $errors,
            'checked_rules' => $rules
        );
    }
}

这里的验证程序采用严格值比较,仅适用于能够直接比较的测试结果。实际能力验证还应根据验证规则扩展结构完整性检查、关系一致性检查、条件满足检查和方法执行结果检查。对于不适合进行简单值比较的结果,必须调用相应的结构验证方法,而不能仅依靠字段值相等来判断能力是否有效。

知识能力测试还必须建立版本回归机制。知识能力并不是一次形成后永久不变的静态对象。需求变化、知识结构更新、方法实现调整以及运行反馈,都可能导致能力需要修改。当能力版本发生变化时,后台必须保留原有版本的定义和测试记录,并使用原有测试用例重新检查新版本能力。

例如,某项设备状态识别能力原来依赖设备运行状态和温度两个属性,后续知识结构增加了设备负载属性。如果新版本能力将负载属性作为必要判断依据,那么测试程序不仅需要检查新属性是否能够正确读取,还需要确认原有状态识别场景是否仍然得到正确结果。新增能力不能以破坏原有有效能力为代价。

为此,测试记录应与能力版本绑定。测试结果可以采用以下数据结构保存:

CREATE TABLE capability_test_results (
    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    test_id VARCHAR(100) NOT NULL,
    capability_id VARCHAR(100) NOT NULL,
    capability_version VARCHAR(30) NOT NULL,
    test_status VARCHAR(30) NOT NULL,
    actual_result LONGTEXT,
    expected_result LONGTEXT,
    validation_result LONGTEXT,
    executed_at DATETIME,
    KEY idx_capability_test (
        capability_id,
        capability_version
    )
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

该表保存不同能力版本的测试记录,使后台能够追溯某项能力在特定版本下的测试情况。测试失败时,应当记录失败发生在哪一个环节,是结构依赖缺失、方法映射错误、运行条件不满足,还是最终结果不符合验证规则。只有明确失败原因,才能将问题反馈给对应的知识构建、结构管理或方法实现程序。

能力测试通过后,也不应当立即认为该能力在所有个体和所有运行环境中都能正常工作。后台测试主要确认能力定义及其依赖在预设条件下满足要求。个体部署后的运行环境可能具有不同的对象类型、设备接口、数据来源和执行约束,因此还需要在实际赋值对象和运行环境中进行适配检查。

尤其是在机器人、无人机和工业设备等应用场景中,知识能力的运行结果可能进一步影响实际控制行为。此时,能力验证与设备执行授权不能混为一谈。知识能力通过验证,只能说明它在已定义的条件和测试范围内符合要求;实际设备执行仍然需要经过设备接口检查、运行约束检查和必要的安全控制。对于无法确认对象状态或输入信息不足的情况,能力应当返回不确定或信息不足的结果,而不能为了完成调用而强行产生确定判断。

知识能力的测试结果还需要进入智能控制后台的知识管理过程。若测试发现结构定义不完整,应返回知识结构构建过程;若方法实现无法满足输入输出要求,应返回方法定义和方法实现环节;若能力无法覆盖当前需求,则应返回需求分析和能力构建过程。这样,能力测试不只是开发阶段的一次性检查,而是知识能力形成、发布、赋值和后续演化过程中的持续验证机制。

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