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

第三十七章 个体行为与任务执行

第三十七章 个体行为与任务执行

  1. 行为对象与行为数据模型

  2. 决策结果与行为指令转换

  3. 行为过程的组织与执行

  4. 执行状态与结果反馈

  5. 行为执行程序及其验证

    第三十七章 个体行为与任务执行

    个体行为与任务执行是个体自主运行从内部认知、判断、决策和方法形成进入实际行动的关键工程环节。第三十一章至第三十四章已经建立了个体认知处理、条件判断、决策依据构建和决策过程实现机制,第三十五章进一步将决策结果转换为执行方法,第三十六章完成了执行方法的数据定义、程序实现映射和调用机制。本章则在这些工程基础上,研究如何将已经形成并经过检查的执行方法组织为具体行为,如何把决策结果转换为可执行的行为指令,如何协调多个行为之间的先后关系和执行条件,以及如何通过运行状态和实际结果反馈确认任务是否完成。

    在WSaiOS工程架构中,行为不是一个脱离知识结构和决策过程的独立动作,也不是简单地向设备发送一条控制命令。行为是个体依据任务目标、认知结果、判断结果和决策结果,调用已经赋予的知识能力及其执行方法,在具体对象、环境和运行条件下形成的实际处理过程。行为可以表现为软件个体的数据处理、业务操作和程序调用,也可以表现为机器人移动、抓取、搬运,无人机起飞、飞行、巡检,以及工业设备启动、停止、调节和状态切换。

    因此,必须区分行为形成、行为指令生成、行为程序调用和实际行为完成这几个不同阶段。决策结果确定个体应该采取什么处理路径,方法形成过程确定实现该路径所需要的方法,程序调用机制负责找到并调用对应的程序实现,而行为执行过程则进一步组织这些方法,使其在具体任务和对象条件下形成连续的实际行动。对于实体设备,程序调用成功并不意味着设备已经完成动作,只有结合设备状态、传感器反馈和执行结果验证,才能确认实际行为是否发生以及是否达到预期目标。

    本章的工程研究重点,是建立决策、方法、行为和任务执行之间的数据关系与程序关系,使个体能够在不依赖中央控制后台持续参与的情况下,根据已经赋予的知识能力、方法和执行规则自主组织行为。同时,个体行为必须受到任务职责、赋值范围、运行条件和安全约束的限制。涉及多个个体的整体任务仍由WSaiOS智能控制后台负责组织和协调,单一个体只能在自身被赋予的职责范围内自主执行,不能因为具备某项局部能力而擅自改变整体任务分工。

    第一节 行为对象与行为数据模型

    个体行为的工程实现首先需要明确行为对象。行为对象不是单纯指机器人、无人机或者某一台工业设备,而是指行为实际作用的对象以及行为执行过程中涉及的相关对象。对于不同类型的个体,行为对象可以是物理设备、业务数据、软件对象、空间位置、物料、环境区域,也可以是由多个对象及其关系共同构成的复合场景。

    例如,仓库机器人执行物料搬运任务时,机器人本身是行为主体,待搬运物料是主要行为对象,取货位置、运输路线和目标存放区域是关联对象。机器人需要读取物料状态,判断当前位置和目标位置之间的关系,根据已经形成的决策结果组织移动、定位、抓取、运输和放置等行为。这里的每一个行为都可能涉及多个对象,但这些对象的角色并不是固定不变的,而是由当前任务和运行上下文决定。

    在工程设计中,需要将行为主体、行为对象、关联对象和行为结果分别建模。行为主体通过individual_id与第二十一章建立的个体对象保持关联;行为对象通过对象实例标识与第二十七章的信息获取和对象识别机制保持关联;行为方法则与第三十六章的执行方法定义和程序实现映射保持关联。这样可以避免将行为直接绑定到某一类设备或者固定业务字段,使同一套行为组织机制能够适用于不同类型的智能个体。

    行为数据模型需要区分行为定义、行为实例和行为执行记录。行为定义描述一种行为的结构、适用条件、行为方法和预期结果,是可以被多个任务复用的工程定义。行为实例则是某个个体在具体任务中形成的一次实际行为安排,必须关联当前任务、行为主体、行为对象、决策结果和方法实例。行为执行记录用于保存实际执行过程中的调用、状态变化、反馈信息和最终结果。三者不能混为一体,否则行为定义更新、任务运行和执行记录之间容易发生数据覆盖或状态混乱。

    行为定义可以采用结构化数据表达。以下是拟定的行为定义JSON设计示例:

    {
        "behavior_id": "robot_material_transport",
        "behavior_name": "物料搬运行为",
        "behavior_type": "physical_operation",
        "applicable_individual_type": "warehouse_robot",
        "behavior_objects": [
            {
                "object_role": "target_material",
                "object_type": "material"
            },
            {
                "object_role": "source_location",
                "object_type": "storage_location"
            },
            {
                "object_role": "target_location",
                "object_type": "storage_location"
            }
        ],
        "method_sequence": [
            {
                "method_id": "robot_navigation",
                "sequence": 1
            },
            {
                "method_id": "robot_positioning",
                "sequence": 2
            },
            {
                "method_id": "robot_grasp",
                "sequence": 3
            },
            {
                "method_id": "robot_transport",
                "sequence": 4
            },
            {
                "method_id": "robot_release",
                "sequence": 5
            }
        ],
        "expected_result": {
            "material_state": "stored",
            "location": "target_location"
        },
        "definition_version": "1.0.0",
        "status": "active"
    }

    该数据描述的是一种可复用的行为定义,并不表示所有机器人都必须按照完全相同的方式完成物料搬运。实际执行时,个体还需要根据自身赋值的能力、设备类型、当前环境和任务条件,解析行为定义中的方法及其依赖关系。对于不具备某项方法或者不适用当前执行条件的个体,不能直接按照行为定义强制执行,而应当返回能力不匹配或者运行条件不满足的判断结果。

    行为实例则需要记录某一次任务中具体的执行对象和方法安排。例如,同样是物料搬运行为,第一次执行可能针对物料material_0001,从货架A移动到区域B;第二次执行可能针对另一件物料,从货架C移动到区域D。两次执行可以引用同一个行为定义,但行为实例中的对象标识、执行参数、运行上下文和决策依据必须分别保存。

    拟定的行为实例数据如下:

    {
        "behavior_instance_id": "behavior_instance_000128",
        "behavior_id": "robot_material_transport",
        "individual_id": "robot_001",
        "task_id": "task_000128",
        "decision_id": "decision_000128",
        "method_instance_ids": [
            "method_instance_001",
            "method_instance_002",
            "method_instance_003",
            "method_instance_004",
            "method_instance_005"
        ],
        "behavior_objects": {
            "target_material": "material_0001",
            "source_location": "area_A",
            "target_location": "area_B"
        },
        "behavior_status": "prepared",
        "definition_version": "1.0.0",
        "assignment_version": "assignment_001"
    }

    在这一模型中,behavior_id用于识别行为定义,behavior_instance_id用于识别具体行为实例,task_id用于关联任务,decision_id用于追溯决策依据。行为实例还需要保存方法实例标识和赋值版本,以便确认行为所使用的方法是否属于当前个体已经获得并验证的知识能力范围。

    行为执行记录与行为实例进一步分离。一个行为实例可能包含多个方法调用,也可能因为条件变化而暂停、恢复或重新组织,因此不能仅用一个行为状态字段代表全部执行情况。行为实例负责描述整体行为,行为执行记录负责保存具体执行阶段。

    拟定的行为执行记录可以采用以下结构:

    {
        "behavior_execution_id": "behavior_execution_000128",
        "behavior_instance_id": "behavior_instance_000128",
        "individual_id": "robot_001",
        "task_id": "task_000128",
        "current_method_id": "robot_navigation",
        "execution_stage": "navigation",
        "execution_status": "running",
        "input_snapshot": {
            "current_location": "area_A",
            "target_location": "area_B"
        },
        "feedback": {
            "device_status": "moving",
            "position_status": "in_progress"
        },
        "started_at": "2026-11-15 10:00:00",
        "completed_at": null
    }

    行为数据还需要处理对象状态与行为状态之间的区别。对象状态描述外部对象当前实际情况,例如物料处于待搬运、已抓取或者已存放状态;行为状态描述行为本身的运行阶段,例如准备中、执行中、等待、暂停或者完成。行为执行可能改变对象状态,但不能仅凭行为状态推断对象状态已经改变。

    例如,机器人执行抓取方法后,程序返回调用成功,但抓取传感器没有检测到物料,说明程序调用已经完成,而实际抓取行为没有得到确认。此时行为不能被标记为完整成功,物料也不能直接更新为已抓取状态。必须通过对象信息重新获取和状态验证,确认实际结果之后才能更新相关数据。

    为了使行为数据能够进入个体运行引擎,建议在个体运行目录下建立独立的行为管理程序组织。以下为拟定的目录架构:

    IndividualRuntime/
    ├── behavior/
    │   ├── definition/
    │   │   ├── BehaviorDefinitionReader.php      # 读取行为定义及其版本
    │   │   └── BehaviorDefinitionValidator.php   # 检查行为定义的数据完整性
    │   ├── instance/
    │   │   ├── BehaviorInstanceBuilder.php       # 根据任务和决策结果建立行为实例
    │   │   └── BehaviorObjectResolver.php        # 解析行为主体及关联对象
    │   ├── execution/
    │   │   ├── BehaviorExecutionManager.php      # 管理行为实例的执行过程
    │   │   └── BehaviorExecutionRepository.php   # 保存和读取行为执行记录
    │   ├── state/
    │   │   ├── BehaviorStateManager.php          # 管理行为运行状态
    │   │   └── ObjectStateUpdater.php            # 根据验证后的结果更新对象状态
    │   └── validation/
    │       ├── BehaviorValidator.php             # 验证行为定义、实例和执行结果
    │       └── BehaviorResultValidator.php       # 验证实际行为结果

    行为程序由个体运行引擎统一调度。行为定义读取程序不直接调用设备,行为实例建立程序不直接改变外部对象,行为执行管理程序则负责将已经验证的行为实例交给第三十六章建立的方法调用机制。实际设备操作仍由对应的方法实现和设备适配接口完成。

    行为模型建立以后,个体才能将任务目标、决策结果和具体方法组织为一个可以执行、记录、检查和恢复的工程对象。这也是行为与普通程序函数调用之间的重要区别:函数调用可以只处理一次输入和输出,而行为通常包含多个方法、多个对象、多个状态变化以及持续性的任务执行过程。

    第二节 决策结果与行为指令转换

    决策结果是行为形成的依据,但决策结果本身并不是直接发送给设备的控制指令。第三十四章已经完成决策过程的工程实现,形成了决策选择、决策依据、约束条件、风险信息和下一阶段处理要求。第三十五章则进一步根据决策结果形成执行方法。本节需要解决的是如何将这些已经形成的决策和方法组织为能够被个体运行引擎识别、调度和执行的行为指令。

    这里首先要明确三个层次之间的关系。决策结果回答当前任务应该采取什么处理路径,执行方法回答实现该路径需要进行什么操作,行为指令则回答个体在当前任务和运行上下文中应该如何组织这些操作。三者具有明确的上下游关系,但不能相互替代。

    以仓库机器人搬运物料为例,决策过程可能已经确定将物料从货架A转移至区域B,并且判断机器人具备相应能力、路线符合当前运行约束。方法形成过程进一步确定需要调用导航、定位、抓取、运输和释放方法。行为指令转换过程则需要将这些方法按照实际任务条件组织起来,明确行为主体、操作对象、方法顺序、前置条件、执行参数、状态检查点和预期结果。

    因此,行为指令不是简单地把几个方法名称排列在一起,而是一个具有对象关联、方法关联、条件关联和执行约束的结构化数据对象。

    拟定的行为指令可以采用以下JSON模型:

    {
        "behavior_command_id": "behavior_command_000128",
        "task_id": "task_000128",
        "individual_id": "robot_001",
        "decision_id": "decision_000128",
        "behavior_instance_id": "behavior_instance_000128",
        "command_type": "execute_behavior",
        "target": {
            "material_id": "material_0001",
            "source_location": "area_A",
            "target_location": "area_B"
        },
        "execution_plan": [
            {
                "sequence": 1,
                "method_instance_id": "method_instance_001",
                "method_id": "robot_navigation",
                "precondition": "route_available"
            },
            {
                "sequence": 2,
                "method_instance_id": "method_instance_002",
                "method_id": "robot_positioning",
                "precondition": "target_location_reached"
            },
            {
                "sequence": 3,
                "method_instance_id": "method_instance_003",
                "method_id": "robot_grasp",
                "precondition": "grasp_condition_satisfied"
            },
            {
                "sequence": 4,
                "method_instance_id": "method_instance_004",
                "method_id": "robot_transport",
                "precondition": "material_grasped"
            },
            {
                "sequence": 5,
                "method_instance_id": "method_instance_005",
                "method_id": "robot_release",
                "precondition": "target_area_available"
            }
        ],
        "constraints": {
            "operation_scope": "assigned_area",
            "safety_rule_required": true,
            "assignment_version": "assignment_001"
        },
        "expected_result": {
            "material_state": "stored",
            "target_location": "area_B"
        },
        "command_status": "prepared"
    }

    这一指令描述的是行为执行计划,而不是绕过方法调用机制直接控制设备。每一个方法实例都必须能够在第三十六章的方法注册表和实现映射中找到对应定义,并且需要检查其版本、适用环境、执行参数和赋值范围。

    行为指令转换程序首先读取决策结果。读取过程中需要检查决策是否属于当前个体、当前任务和当前赋值版本。决策结果如果已经失效,例如原有路线已经关闭、物料状态发生变化或者设备进入维护状态,就不能继续按照旧决策生成行为指令,而应当重新进入认知和判断过程,必要时重新决策。

    随后,程序根据决策结果读取方法形成记录,将方法实例与行为定义进行关联。这里需要注意,行为定义中的方法顺序可以是一个初始组织结构,但实际执行顺序必须根据方法之间的依赖关系、条件关系和当前环境确定。对于可以并行执行的操作,可以在满足资源和安全条件时组织并行;对于存在前置依赖的操作,则必须等待前置方法完成并验证结果之后才能继续。

    行为指令生成还需要进行执行参数转换。决策结果可能只包含目标位置、目标对象和处理路径,而具体方法需要更详细的输入参数。例如,导航方法需要目标坐标和路线信息,抓取方法需要目标对象标识、抓取位置和抓取模式。参数转换程序必须从已经建立的任务上下文、对象实例、方法实例和运行信息中获取相应数据,并检查数据来源、数据类型、单位和有效时间。

    对于实体设备,行为指令还需要明确设备控制边界。行为指令只能引用已经赋予个体的操作范围和权限,不能因为某个方法可以调用,就认为该方法在任何场景下都可以执行。尤其涉及机器人运动、无人机飞行和工业设备控制时,指令生成必须结合当前环境、设备状态、安全联锁和运行规则。

    拟定的程序目录如下:

    IndividualRuntime/
    ├── behavior/
    │   ├── command/
    │   │   ├── DecisionResultReader.php          # 读取当前有效决策结果
    │   │   ├── DecisionMethodResolver.php        # 解析决策结果关联的方法实例
    │   │   ├── BehaviorCommandBuilder.php        # 根据决策和方法建立行为指令
    │   │   ├── BehaviorParameterResolver.php     # 解析行为指令所需的参数
    │   │   ├── BehaviorDependencyResolver.php    # 确定方法之间的依赖关系
    │   │   ├── BehaviorSequenceBuilder.php       # 建立行为执行顺序
    │   │   └── BehaviorCommandValidator.php      # 检查行为指令的完整性和合法性
    │   ├── constraint/
    │   │   ├── BehaviorScopeChecker.php          # 检查行为是否处于个体职责范围
    │   │   ├── BehaviorPermissionChecker.php     # 检查行为执行权限
    │   │   └── BehaviorSafetyChecker.php         # 检查行为安全约束
    │   └── dispatch/
    │       └── BehaviorCommandDispatcher.php     # 将有效行为指令交给行为执行管理程序

    在程序组织上,BehaviorCommandBuilder负责形成指令,BehaviorCommandValidator负责检查指令,BehaviorCommandDispatcher负责将通过验证的指令交给执行管理程序。指令生成程序不能直接操作设备,也不能自行绕过第三十六章的方法映射和调用机制。

    以下给出一个简化的PHP程序设计示例,说明行为指令生成与验证之间的关系。该代码采用PHP 7.0.10兼容语法,属于拟定工程设计示例,并非已经部署运行的项目代码。

    <?php
    
    class BehaviorCommandBuilder
    {
        public function build($decision, $methodInstances, $context)
        {
            if (empty($decision['decision_id'])) {
                throw new InvalidArgumentException(
                    '决策标识不能为空'
                );
            }
    
            if (empty($decision['selected_path'])) {
                throw new InvalidArgumentException(
                    '缺少有效决策路径'
                );
            }
    
            if (empty($context['individual_id']) ||
                empty($context['task_id'])) {
                throw new InvalidArgumentException(
                    '行为执行上下文不完整'
                );
            }
    
            $steps = array();
            $sequence = 1;
    
            foreach ($methodInstances as $method) {
                if (empty($method['method_instance_id']) ||
                    empty($method['method_id'])) {
                    throw new InvalidArgumentException(
                        '方法实例数据不完整'
                    );
                }
    
                $steps[] = array(
                    'sequence' => $sequence,
                    'method_instance_id' =>
                        $method['method_instance_id'],
                    'method_id' => $method['method_id'],
                    'precondition' =>
                        isset($method['precondition'])
                        ? $method['precondition']
                        : null
                );
    
                $sequence++;
            }
    
            if (empty($steps)) {
                throw new RuntimeException(
                    '决策结果没有可执行方法'
                );
            }
    
            return array(
                'behavior_command_id' =>
                    uniqid('behavior_command_'),
                'decision_id' => $decision['decision_id'],
                'individual_id' => $context['individual_id'],
                'task_id' => $context['task_id'],
                'assignment_version' =>
                    $context['assignment_version'],
                'execution_plan' => $steps,
                'command_status' => 'prepared'
            );
        }
    }

    该程序完成的是方法实例到行为指令的初步组织。实际工程中还必须增加决策版本检查、赋值版本检查、方法适用范围检查、对象关联检查、方法依赖检查和安全约束检查。尤其需要避免只根据方法实例是否存在就生成有效指令,因为方法实例可能已经失效,或者其所属赋值版本已经被替换。

    行为指令生成之后,还需要进行完整性验证。验证内容包括决策结果是否有效,方法实例是否属于当前个体,方法定义和程序实现版本是否兼容,行为对象是否存在,参数是否完整,方法依赖是否成立,以及行为执行是否符合个体职责范围和安全规则。

    验证通过的行为指令可以进入行为执行阶段。验证失败时,应当根据失败原因选择处理路径。如果只是缺少某个可重新获取的对象属性,可以等待补充信息;如果方法版本不兼容,应当重新加载或重新赋值;如果决策依据已经失效,则应当重新进行判断和决策;如果行为超出个体职责或权限范围,则必须阻止执行。

    这一过程使决策结果不再停留在抽象的选择记录,而是转化为能够由个体运行引擎组织和调度的实际行为计划,同时保留从行为指令追溯到决策依据、方法定义和知识能力赋值的完整关系。

    第三节 行为过程的组织与执行

    行为过程的组织,是将行为指令转化为连续运行过程的工程机制。一个实际任务往往不是通过一次方法调用就能完成,而是需要多个方法按照一定的依赖关系依次执行,并根据每个阶段的结果决定下一阶段是否继续。

    例如,机器人搬运物料需要先确认目标物料和当前位置,再规划路线并完成导航,随后进行定位和抓取,确认抓取成功后才能运输,抵达目标位置后还需要判断放置条件,最后执行释放并验证物料状态。每一个阶段都具有自己的输入、执行条件、输出和异常处理路径。某个阶段未完成时,后续依赖该阶段的行为不能直接开始。

    因此,行为执行不能简单采用固定顺序循环调用所有方法,而应当建立行为流程组织机制。行为流程需要明确各方法之间的前置依赖、执行顺序、条件分支、并行关系和中断恢复条件。

    行为流程可以采用有向依赖关系进行描述。每一个行为步骤是一个执行节点,节点之间通过依赖关系连接。对于必须顺序执行的操作,后一个节点需要等待前一个节点成功并通过结果验证。对于可以并行的操作,可以在资源允许和相互独立的情况下同时调度。对于条件分支,则根据前置方法的实际返回结果选择后续路径。

    例如,机器人到达物料所在区域之后,需要先检查物料是否仍然存在。如果物料存在并且状态允许抓取,则进入抓取流程;如果物料已经被其他设备取走,则不能继续调用抓取方法,而应当将对象状态变化反馈到认知和判断程序,重新确认任务是否仍然成立。

    拟定的行为流程可以采用以下结构表达:

    {
        "behavior_flow_id": "flow_000128",
        "behavior_instance_id": "behavior_instance_000128",
        "nodes": [
            {
                "node_id": "node_001",
                "method_id": "robot_navigation",
                "depends_on": [],
                "next": "node_002"
            },
            {
                "node_id": "node_002",
                "method_id": "robot_positioning",
                "depends_on": ["node_001"],
                "next": "node_003"
            },
            {
                "node_id": "node_003",
                "method_id": "robot_grasp",
                "depends_on": ["node_002"],
                "next": "node_004"
            },
            {
                "node_id": "node_004",
                "method_id": "robot_transport",
                "depends_on": ["node_003"],
                "next": "node_005"
            },
            {
                "node_id": "node_005",
                "method_id": "robot_release",
                "depends_on": ["node_004"],
                "next": null
            }
        ],
        "flow_status": "prepared"
    }

    这个流程描述了一个简单的顺序依赖关系。实际工程中还需要加入条件节点、异常分支、等待节点和人工干预节点。对于涉及多个设备或者多个行为主体的复杂任务,还需要引入并行节点、资源占用关系和任务协调关系。

    行为执行管理程序需要在个体运行引擎内部运行,并通过方法调用调度器执行具体方法。其基本调用关系可以表示为:

    RuntimeKernel
          |
          v
    BehaviorExecutionManager
          |
          v
    BehaviorFlowResolver
          |
          v
    BehaviorStepScheduler
          |
          v
    BehaviorConditionChecker
          |
          v
    MethodCallExecutor
          |
          v
    MethodImplementation
          |
          v
    BehaviorResultCollector
          |
          v
    BehaviorStateManager
          |
          v
    NextStepResolver

    RuntimeKernel负责接收任务并建立运行上下文。BehaviorExecutionManager根据行为实例建立执行过程,BehaviorFlowResolver解析方法之间的依赖关系,BehaviorStepScheduler决定当前可以执行的步骤。BehaviorConditionChecker负责检查步骤的前置条件和运行约束,只有检查通过之后,才将方法调用交给第三十六章的MethodCallExecutor。

    方法执行完成后,返回结果由BehaviorResultCollector接收。该程序需要检查返回结果的结构和有效性,并将结果交给行为状态管理程序。NextStepResolver再根据当前节点的执行结果、后续节点依赖和条件分支决定下一步处理路径。

    这里需要强调,行为调度程序不能把所有返回结果都理解为成功。方法执行可能返回成功、失败、等待、暂停、执行状态未知或者需要重新判断等不同结果。只有满足当前行为流程规定的完成条件,才能进入后续依赖节点。

    拟定的程序目录如下:

    IndividualRuntime/
    ├── behavior/
    │   ├── flow/
    │   │   ├── BehaviorFlowReader.php            # 读取行为流程定义
    │   │   ├── BehaviorFlowResolver.php           # 解析行为流程和节点关系
    │   │   ├── BehaviorDependencyResolver.php    # 解析节点前置依赖
    │   │   └── BehaviorBranchResolver.php        # 解析条件分支和执行路径
    │   ├── scheduler/
    │   │   ├── BehaviorStepScheduler.php         # 调度当前可执行行为步骤
    │   │   ├── BehaviorSequenceManager.php       # 管理行为步骤的执行顺序
    │   │   ├── BehaviorParallelManager.php       # 管理允许并行的行为节点
    │   │   └── BehaviorResourceCoordinator.php   # 协调行为执行所需资源
    │   ├── executor/
    │   │   ├── BehaviorExecutionManager.php      # 组织完整行为执行过程
    │   │   ├── BehaviorStepExecutor.php          # 执行单个行为步骤
    │   │   ├── BehaviorConditionChecker.php      # 检查行为步骤执行条件
    │   │   └── BehaviorResultCollector.php       # 收集方法调用和行为结果
    │   └── recovery/
    │       ├── BehaviorCheckpointManager.php     # 保存行为执行检查点
    │       ├── BehaviorRecoveryManager.php       # 根据检查点恢复行为过程
    │       └── BehaviorInterruptHandler.php      # 处理暂停、中断和终止

    行为执行过程中需要建立检查点机制。检查点不是简单地记录当前执行到第几个方法,而是保存当前行为实例、已经完成的步骤、正在执行的步骤、相关对象状态、方法调用标识、执行结果、资源占用情况和当前运行上下文。只有具备这些信息,个体在发生异常或者重新启动时,才能判断应该继续执行、重新判断还是进入人工干预。

    例如,机器人在完成物料抓取之后发生通信中断。如果本地运行引擎仍然正常,机器人可以依据本地已经赋值的行为流程、方法和规则继续执行后续任务。但如果机器人本身发生异常停机,恢复运行时不能直接从运输步骤开始,而应先确认物料是否仍然被抓取、机械臂是否处于安全位置、当前路线是否仍然可用。只有这些状态经过重新获取和验证之后,才能决定恢复行为流程。

    特别是对于具有物理副作用的行为,必须处理程序调用与实际动作之间的不确定性。数据库记录可以通过事务管理,但机械动作无法与数据库事务形成真正的原子操作。程序可能已经向设备发送控制指令,但在保存执行结果之前设备或控制程序发生故障。此时不能仅根据数据库中缺少成功记录,就认定设备没有执行动作并直接重复调用。必须通过设备状态、传感器反馈、设备任务编号或其他可用的本地执行证据核实实际情况。

    对于不可安全重复的行为,需要为每次调用建立唯一执行标识和幂等控制机制。重复请求应当首先检查原执行记录及设备实际状态,而不是直接产生新的动作。对于可以安全重复的读取、检查和计算方法,可以根据方法定义采用适当的重试机制;对于设备移动、抓取、释放和启动等具有实际影响的操作,则必须依据方法的重复执行属性和当前设备状态决定是否允许重试。

    多行为组织还需要处理资源竞争。例如,同一机器人不能在机械臂执行抓取操作的同时,执行一个与机械臂运动冲突的操作;同一台工业设备也不能在维护锁生效时接受普通生产任务。行为资源协调程序需要根据个体运行环境中的资源管理机制,检查设备、执行机构、处理器、存储和数据访问资源的占用情况。

    当行为由多个个体共同完成时,行为组织还涉及个体之间的职责和任务边界。WSaiOS智能控制后台根据整体任务和各个体的知识能力,形成任务分工和组织关系。个体接收到属于自己的任务后,可以自主组织本地行为,但不能擅自改变其他个体的职责,也不能随意将整体任务转交给其他个体。需要调整多智能个体任务分配时,应当由智能控制后台根据整体运行状态重新组织。

    在通信模式下,个体可以向中央控制后台报告行为状态和执行结果,后台根据整体任务状态进行协调。在无通信模式下,个体依据已经部署的本地任务、行为流程、知识能力和执行规则自主运行。无通信并不意味着个体可以取消原有约束,也不意味着可以无限扩展任务范围。通信恢复后,需要同步本地行为执行记录、对象状态变化、异常信息和版本信息,供后台进行整体状态核对。

    因此,行为过程的组织机制既要保证单个行为的连续执行,也要保证多方法、多对象和多资源之间的协调,并且在中断、异常和通信变化时保留可恢复的执行依据。

    第四节 执行状态与结果反馈

    行为执行状态是个体自主运行过程中判断任务进展的重要依据。由于行为通常包含多个方法和多个处理阶段,不能只设置一个简单的成功或失败状态。实际工程中,需要同时管理行为整体状态、行为步骤状态、方法调用状态、对象状态和任务状态。

    行为整体状态用于描述行为实例的生命周期。行为可以处于待准备、待执行、执行中、等待条件、暂停、恢复中、完成、失败、取消或者执行结果未知等状态。行为步骤状态则用于记录某个具体方法节点的处理情况。方法调用状态来自第三十六章的方法调用机制,而对象状态则由实际信息获取和结果验证程序维护。

    这几种状态之间存在关联,但不能直接等同。例如,行为处于执行中,可能意味着当前某一个方法正在调用,也可能意味着多个允许并行的步骤正在运行;行为处于暂停状态,并不一定意味着设备已经停止运动,必须进一步确认设备侧的实际状态;行为处于完成状态,也必须明确其表示行为流程完成,还是已经通过最终结果验证。

    因此,建议建立统一的行为状态定义,并将状态转换条件与执行证据关联起来。

    拟定的行为状态如下:

    {
        "behavior_states": [
            "prepared",
            "ready",
            "running",
            "waiting",
            "suspended",
            "recovering",
            "completed",
            "failed",
            "cancelled",
            "unknown"
        ],
        "step_states": [
            "pending",
            "ready",
            "running",
            "waiting",
            "completed",
            "failed",
            "skipped",
            "unknown"
        ]
    }

    prepared表示行为实例已经建立,但尚未完成执行准备;ready表示行为执行所需的前置条件已经满足,可以进入调度;running表示行为正在执行;waiting表示等待外部条件、设备反馈或者前置步骤;suspended表示行为已被暂停;recovering表示个体正在根据检查点和当前实际状态恢复行为;completed表示行为已经完成规定的执行流程并通过相应验证;failed表示行为无法按照当前定义完成;cancelled表示行为已被取消;unknown则用于表达执行结果无法确认的状态。

    其中,unknown尤其重要。在设备控制过程中,未知状态不能被自动解释为失败,也不能被自动解释为成功。如果程序在发送控制指令后发生异常,而设备状态尚未获取,就必须保留未知状态,并进入实际状态核实过程。未经核实不得盲目重新执行可能造成重复物理动作的操作。

    行为状态转换需要受到条件约束。例如,行为从prepared进入ready,需要检查行为定义、方法实例、执行参数、对象信息和运行权限。行为从ready进入running,还需要检查当前环境和设备状态。行为从running进入completed,则需要确认所有必要步骤已经完成,并且最终结果符合预期定义。

    对于中途失败的行为,不能简单地将整个任务直接标记为失败,而应当分析失败发生在哪一个方法、涉及哪些对象、已经完成了哪些实际动作,以及后续是否存在可恢复路径。如果失败发生在导航阶段,机器人可能尚未改变物料状态;如果失败发生在抓取阶段,则物料可能已经被抓起,也可能仍然留在原位置。这两种情况对恢复处理具有完全不同的要求。

    行为执行结果需要通过独立的反馈机制收集。反馈来源包括方法调用返回值、传感器数据、设备状态、对象属性变化、本地程序运行记录和任务执行结果。对于软件个体,反馈可以来自数据库记录、文件状态、业务接口和程序返回值;对于机器人、无人机和工业设备,则还需要结合传感器、控制器和设备运行状态。

    拟定的行为反馈数据结构如下:

    {
        "feedback_id": "feedback_000128",
        "behavior_instance_id": "behavior_instance_000128",
        "individual_id": "robot_001",
        "task_id": "task_000128",
        "feedback_type": "object_state_change",
        "source": "device_sensor",
        "object_id": "material_0001",
        "observed_state": {
            "grasp_status": "detected",
            "location": "robot_gripper"
        },
        "expected_state": {
            "grasp_status": "grasped"
        },
        "verification_status": "passed",
        "feedback_time": "2026-11-15 10:02:00"
    }

    反馈数据不能未经检查就直接更新知识结构或者对象状态。首先需要确认反馈来源是否可信、数据是否完整、时间是否有效、对象标识是否一致,以及反馈内容是否与当前行为实例相对应。对于同一对象存在多个反馈来源的情况,还需要结合数据时间和来源可靠性判断是否存在冲突。

    例如,机器人控制程序返回抓取成功,但视觉传感器检测到物料仍然处于货架位置。此时不能简单地选择程序返回值作为最终结果,而应当将两类信息记录为不一致状态,触发对象信息重新获取、认知更新和条件判断。必要时暂停后续运输步骤,避免在没有确认物料已经抓取的情况下启动运输。

    行为结果验证还需要区分局部结果和整体结果。局部结果是某个方法执行后产生的状态变化,例如机器人已经到达目标位置;整体结果则是整个行为是否达到任务要求,例如物料已经被放置在指定区域,并且物料状态和目标位置均符合预期。局部方法返回成功并不能自动证明整体任务完成。

    行为执行结果与任务结果之间也需要建立独立关系。一个行为可能是任务的一部分,一个任务可能包含多个行为实例。只有所有必要行为均完成,并且任务的整体完成条件得到验证,才能将任务状态更新为完成。如果一个行为失败但存在替代路径,任务仍可能继续;如果行为结果未知,则任务通常需要进入等待核实或暂停状态,而不是直接标记为失败。

    拟定的行为反馈和状态管理程序目录如下:

    IndividualRuntime/
    ├── behavior/
    │   ├── state/
    │   │   ├── BehaviorStateReader.php           # 读取行为当前状态
    │   │   ├── BehaviorStateManager.php          # 管理行为状态及转换
    │   │   ├── BehaviorStepStateManager.php      # 管理单个行为步骤状态
    │   │   └── BehaviorStateValidator.php        # 检查状态转换是否合法
    │   ├── feedback/
    │   │   ├── BehaviorFeedbackCollector.php     # 收集方法、设备和对象反馈
    │   │   ├── FeedbackSourceResolver.php        # 确定反馈数据来源
    │   │   ├── FeedbackDataValidator.php         # 验证反馈数据完整性
    │   │   ├── ObjectStateVerifier.php           # 核实对象实际状态
    │   │   └── FeedbackConflictAnalyzer.php      # 分析反馈信息冲突
    │   ├── result/
    │   │   ├── BehaviorResultBuilder.php         # 建立行为执行结果
    │   │   ├── BehaviorResultVerifier.php        # 验证行为预期结果
    │   │   ├── BehaviorCompletionChecker.php     # 检查行为是否满足完成条件
    │   │   └── TaskResultUpdater.php             # 将验证结果反馈至任务管理
    │   └── report/
    │       ├── BehaviorExecutionReporter.php    # 生成行为执行报告
    │       └── BehaviorExceptionReporter.php    # 整理行为异常和能力缺口信息

    行为结果可以采用统一的数据结构保存:

    {
        "behavior_result_id": "behavior_result_000128",
        "behavior_instance_id": "behavior_instance_000128",
        "task_id": "task_000128",
        "individual_id": "robot_001",
        "execution_status": "completed",
        "verification_status": "passed",
        "completed_steps": 5,
        "required_steps": 5,
        "object_results": {
            "material_0001": {
                "previous_state": "available",
                "current_state": "stored",
                "current_location": "area_B"
            }
        },
        "expected_result_match": true,
        "exception_count": 0,
        "assignment_version": "assignment_001"
    }

    在实际数据存储中,行为实例、行为步骤、行为反馈和行为结果应当分别保存,并通过稳定标识关联。拟定的数据库结构可以包括individual_behavior_instances、individual_behavior_steps、individual_behavior_executions、individual_behavior_feedback和individual_behavior_results等数据表。

    其中,individual_behavior_instances保存行为实例的主体、任务、决策和行为定义版本;individual_behavior_steps保存每个行为步骤的方法实例、依赖关系和执行状态;individual_behavior_executions保存实际调用和执行记录;individual_behavior_feedback保存来自程序、设备和对象的信息;individual_behavior_results保存行为最终结果及其验证情况。

    这些表之间应当通过行为实例标识、行为步骤标识、方法调用标识和任务标识建立关联。对于每一次状态变化,应当保留原状态、新状态、变化来源和变化时间,不能直接覆盖所有历史数据。这样既能支持运行恢复,也能为后台分析个体运行表现和知识能力缺口提供依据。

    行为反馈还具有智能进化方面的意义。个体执行过程中出现的新对象状态、新环境条件、方法失败和能力不足,都可能反映现有知识能力与实际任务之间存在差距。但是,个体运行反馈不等于个体自动修改知识结构。个体负责记录事实、保存异常和报告能力缺口,知识结构调整、知识能力构建、验证及重新赋值仍由WSaiOS智能控制后台负责。

    例如,机器人多次遇到一种此前未处理过的通道障碍。个体可以记录障碍对象的结构信息、发生位置、影响范围和现有方法无法完成的处理情况,并在通信可用时将反馈提交中央控制后台。后台根据实际需求分析是否需要增加新的对象结构、属性定义、关系定义或处理方法,构建新的知识能力并完成验证,再决定是否向相关个体重新赋值。

    由此,行为反馈不仅用于确认当前任务执行情况,也成为WSaiOS整体需求驱动和自主智能进化闭环的重要工程数据来源。

    第五节 行为执行程序及其验证

    行为执行程序是前述行为数据、行为指令、行为流程、方法调用和执行反馈机制的统一组织部分。它需要将行为实例从建立阶段推进到实际执行和结果验证阶段,并在执行过程中管理方法调用、状态转换、异常处理和检查点。

    从程序结构上看,行为执行程序不应直接承担第三十一章至第三十五章全部认知、判断和决策逻辑,也不应复制WSaiOS智能控制后台的知识结构化构建机制。它的职责是在个体已经获得的知识能力、方法和执行规则范围内,依据有效的决策结果组织实际行为,并将执行情况反馈到个体运行引擎。

    因此,行为执行程序需要与前面已经建立的多个工程对象保持明确接口。它从第三十四章读取有效决策结果,从第三十五章读取方法形成结果,从第三十六章调用方法执行机制,从第二十六章的运行引擎获取个体上下文和资源管理能力,从第二十九章的自主运行判断结果确认任务是否允许进入执行阶段。

    整个调用过程可以归纳为以下工程关系:

    IndividualRuntime
            |
            v
    RuntimeKernel
            |
            v
    AutonomousRunJudgment
            |
            v
    DecisionResultReader
            |
            v
    BehaviorInstanceBuilder
            |
            v
    BehaviorCommandBuilder
            |
            v
    BehaviorCommandValidator
            |
            v
    BehaviorExecutionManager
            |
            v
    BehaviorStepScheduler
            |
            v
    MethodCallExecutor
            |
            v
    MethodImplementation
            |
            v
    BehaviorFeedbackCollector
            |
            v
    BehaviorResultVerifier
            |
            v
    BehaviorStateManager
            |
            v
    TaskResultUpdater
            |
            v
    RuntimeKernel

    这里的AutonomousRunJudgment表示个体已经完成自主运行判断,并确认当前任务具备进入相应处理阶段的条件。行为执行管理程序仍然需要在每一个关键执行节点检查当前条件,不能把任务启动时的判断结果当作整个执行过程永久有效的依据。

    为使这一程序能够逐步进入实际工程实现,建议建立统一的行为执行入口BehaviorExecutionManager,由它组织行为实例建立、指令检查、执行调度和结果验证。以下给出拟定的PHP程序设计示例。

    <?php
    
    class BehaviorExecutionManager
    {
        private $commandBuilder;
        private $commandValidator;
        private $stepExecutor;
        private $resultVerifier;
    
        public function __construct(
            $commandBuilder,
            $commandValidator,
            $stepExecutor,
            $resultVerifier
        ) {
            $this->commandBuilder = $commandBuilder;
            $this->commandValidator = $commandValidator;
            $this->stepExecutor = $stepExecutor;
            $this->resultVerifier = $resultVerifier;
        }
    
        public function execute(
            $decision,
            $methodInstances,
            $context
        ) {
            $command = $this->commandBuilder->build(
                $decision,
                $methodInstances,
                $context
            );
    
            $validation = $this->commandValidator->validate(
                $command,
                $context
            );
    
            if (empty($validation['valid'])) {
                return array(
                    'status' => 'blocked',
                    'reason' => isset($validation['reason'])
                        ? $validation['reason']
                        : '行为指令验证失败'
                );
            }
    
            $execution = $this->stepExecutor->execute(
                $command,
                $context
            );
    
            if (!isset($execution['status'])) {
                return array(
                    'status' => 'unknown',
                    'reason' => '执行程序没有返回有效状态'
                );
            }
    
            if ($execution['status'] !== 'completed') {
                return array(
                    'status' => $execution['status'],
                    'execution' => $execution
                );
            }
    
            $result = $this->resultVerifier->verify(
                $command,
                $execution,
                $context
            );
    
            if (empty($result['verified'])) {
                return array(
                    'status' => 'verification_failed',
                    'execution' => $execution,
                    'verification' => $result
                );
            }
    
            return array(
                'status' => 'completed',
                'command_id' => $command['behavior_command_id'],
                'execution' => $execution,
                'verification' => $result
            );
        }
    }

    这一示例展示了行为执行入口的基本组织方式。BehaviorCommandBuilder负责将决策和方法实例转换为行为指令;BehaviorCommandValidator负责检查行为指令;BehaviorStepExecutor负责按照流程调度具体方法;BehaviorResultVerifier负责对最终执行结果进行验证。

    这里的BehaviorStepExecutor不应当简单地对方法数组进行循环并全部执行,而应当内部调用行为流程解析器和步骤调度器,根据依赖关系决定当前能够执行的节点。对于需要等待外部反馈的节点,程序应当保存当前状态并返回waiting;对于执行状态无法确认的节点,应当返回unknown,并触发实际状态核实;对于违反执行约束的节点,应当立即阻止相应行为。

    此外,实际工程中的BehaviorExecutionManager还需要增加事务管理、执行标识、幂等控制、运行日志、异常分类和检查点保存等机制。上面的程序只是整体调用关系的简化表达,不能直接作为完整设备控制程序使用。

    行为执行验证需要覆盖从行为数据建立到实际任务完成的整个过程。首先检查行为定义是否完整,行为主体和行为对象是否能够正确关联,行为实例是否属于当前任务和当前个体。其次检查决策结果和方法实例是否有效,方法定义版本、程序实现版本和赋值版本是否匹配。再次检查行为指令中的执行参数、前置条件、方法依赖和执行范围。进入实际执行阶段后,还需要验证方法调用是否成功、设备是否按照指令产生动作、对象状态是否发生预期变化,以及最终行为结果是否满足任务目标。

    验证过程不能只依赖程序返回值。对于软件行为,可以通过数据库状态、文件变化、业务接口结果和处理记录验证;对于实体设备行为,需要结合控制器返回状态、传感器信息和实际对象状态验证。不同来源的信息发生冲突时,应当保留冲突记录并重新判断,不能通过简单覆盖消除不一致。

    行为执行测试还需要覆盖异常和恢复情况。例如,方法调用失败时,行为调度程序是否停止后续依赖步骤;运行条件变化时,行为是否能够及时暂停;设备状态未知时,是否阻止危险的重复调用;个体运行中断后,是否能够根据检查点恢复;通信中断时,是否能够依照本地已赋值能力和规则继续允许的任务;通信恢复后,是否能够正确同步执行记录和对象状态。

    在多智能个体运行环境中,还需要验证不同个体的行为是否符合各自的任务职责。一个个体不能调用另一个个体未赋予给自己的方法,也不能擅自改变中央控制后台确定的整体任务组织关系。涉及多个个体的协同任务,需要检查各个体行为之间的依赖、资源占用、执行状态和结果关联,避免某个个体的局部完成被误认为整体任务已经完成。

    为了使上述程序能够逐步形成可维护的工程实现,建议将行为执行的数据库记录与前面章节的任务、决策、方法实例和执行记录关联起来。拟定的数据表可以采用以下结构:

    CREATE TABLE individual_behavior_instances (
        id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
        behavior_instance_id VARCHAR(100) NOT NULL,
        behavior_id VARCHAR(100) NOT NULL,
        individual_id VARCHAR(100) NOT NULL,
        task_id VARCHAR(100) NOT NULL,
        decision_id VARCHAR(100) NOT NULL,
        assignment_version VARCHAR(100) NOT NULL,
        behavior_status VARCHAR(30) NOT NULL,
        definition_version VARCHAR(50) NOT NULL,
        created_at DATETIME NOT NULL,
        updated_at DATETIME DEFAULT NULL,
        PRIMARY KEY (id),
        UNIQUE KEY uk_behavior_instance (
            behavior_instance_id
        ),
        KEY idx_individual_task (
            individual_id,
            task_id
        )
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    CREATE TABLE individual_behavior_steps (
        id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
        behavior_step_id VARCHAR(100) NOT NULL,
        behavior_instance_id VARCHAR(100) NOT NULL,
        method_instance_id VARCHAR(100) NOT NULL,
        method_id VARCHAR(100) NOT NULL,
        sequence_number INT NOT NULL,
        dependency_data TEXT,
        step_status VARCHAR(30) NOT NULL,
        started_at DATETIME DEFAULT NULL,
        completed_at DATETIME DEFAULT NULL,
        PRIMARY KEY (id),
        UNIQUE KEY uk_behavior_step (
            behavior_step_id
        ),
        KEY idx_behavior_sequence (
            behavior_instance_id,
            sequence_number
        )
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    CREATE TABLE individual_behavior_feedback (
        id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
        feedback_id VARCHAR(100) NOT NULL,
        behavior_instance_id VARCHAR(100) NOT NULL,
        behavior_step_id VARCHAR(100) DEFAULT NULL,
        source_type VARCHAR(50) NOT NULL,
        source_id VARCHAR(100) DEFAULT NULL,
        feedback_data LONGTEXT NOT NULL,
        verification_status VARCHAR(30) NOT NULL,
        created_at DATETIME NOT NULL,
        PRIMARY KEY (id),
        UNIQUE KEY uk_feedback_id (
            feedback_id
        ),
        KEY idx_feedback_behavior (
            behavior_instance_id
        )
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    CREATE TABLE individual_behavior_results (
        id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
        behavior_result_id VARCHAR(100) NOT NULL,
        behavior_instance_id VARCHAR(100) NOT NULL,
        task_id VARCHAR(100) NOT NULL,
        individual_id VARCHAR(100) NOT NULL,
        execution_status VARCHAR(30) NOT NULL,
        verification_status VARCHAR(30) NOT NULL,
        result_data LONGTEXT,
        exception_data LONGTEXT,
        completed_at DATETIME DEFAULT NULL,
        created_at DATETIME NOT NULL,
        PRIMARY KEY (id),
        UNIQUE KEY uk_behavior_result (
            behavior_result_id
        ),
        KEY idx_result_task (
            task_id,
            individual_id
        )
    ) 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小时技术值守