第14章　Engine

本章大纲

Engine 定义
为什么使用 Engine
PerceptionEngine
CognitionEngine
MemoryEngine
ReasoningEngine
DecisionEngine
BehaviorEngine
LearningEngine
Engine 生命周期
Engine 调用
Engine 组合
完整 Engine 示例

14.1 Engine 定义

在 SAI Framework 中，Engine 是执行特定智能处理过程的核心执行组件。

Model 负责组织和管理数据，而 Engine 负责对这些数据进行处理。

最基本的关系是：

Model
 ↓
提供数据
 ↓
Engine
 ↓
执行处理
 ↓
Result

因此可以定义：

Engine 是 SAI Framework 中负责执行特定处理机制、计算过程或智能过程的软件组件。

例如：

PerceptionEngine
    ↓
处理感知

CognitionEngine
    ↓
处理认知

MemoryEngine
    ↓
处理记忆

ReasoningEngine
    ↓
处理推理

DecisionEngine
    ↓
处理决策

BehaviorEngine
    ↓
处理行为

LearningEngine
    ↓
处理学习

Engine 不是一个“大而全”的智能模块，而是由多个具有明确职责的 Engine 组成 SAI 的运行能力。

14.2 为什么使用 Engine

如果把所有处理逻辑都写进 Individual 或 Central：

Individual
├── 感知
├── 认知
├── 记忆
├── 推理
├── 决策
├── 行为
└── 学习

随着系统扩大，Individual 会变得非常复杂。

因此 SAI Framework 将不同处理过程拆分：

Individual
    │
   Central
    │
    ├── PerceptionEngine
    ├── CognitionEngine
    ├── MemoryEngine
    ├── ReasoningEngine
    ├── DecisionEngine
    ├── BehaviorEngine
    └── LearningEngine

这样可以实现：

1. 职责分离

每个 Engine 只负责一个主要领域。

2. 独立开发

可以单独开发和修改某一个 Engine。

3. 独立测试

例如只测试：

ReasoningEngine

而不需要运行整个 Individual。

4. Engine 组合

不同 Individual 可以使用不同 Engine。

例如：

Individual A
 ↓
ReasoningEngine A

Individual B
 ↓
ReasoningEngine B

5. Extension

未来可以增加：

NavigationEngine
PlanningEngine
DiagnosisEngine
ControlEngine

而不需要改变整个 Framework。

14.3 PerceptionEngine

PerceptionEngine 负责将接收到的信息进行感知处理。

基本流程：

Information
 ↓
PerceptionEngine
 ↓
Element
 ↓
Object

例如收到：

temperature = 32

PerceptionEngine 可以识别：

Element
├── name = temperature
├── value = 32
└── type = numeric

进一步形成：

Object
Room
└── temperature = 32

示例：

<?php

namespace SAI\Perception;

class PerceptionEngine
{
    public function process($information)
    {
        return array(
            'type' => 'element',
            'name' => $information['name'],
            'value' => $information['value']
        );
    }
}

这里的 Engine 负责处理，而不是负责保存所有数据。

14.4 CognitionEngine

CognitionEngine 负责对已经形成的 Element、Object、Property、Relation 等信息进行认知和理解。

可以表示为：

Element
Object
Property
Relation
Fact
 ↓
CognitionEngine
 ↓
Understanding

例如：

temperature = 32

本身只是一个数据。

结合：

Room
temperature = 32

可以形成：

Room temperature is high

再结合规则：

IF temperature > 30
THEN fan should turn on

CognitionEngine 可以形成与当前场景相关的认知结果。

需要注意：

CognitionEngine 负责认知处理，不负责最终决策。

14.5 MemoryEngine

MemoryEngine 负责记忆数据的存储、读取、检索、匹配和管理。

基本结构：

Memory
 ↓
MemoryEngine
 ↓
Store / Retrieve / Match

例如：

$memoryEngine->remember(
    'fact',
    array(
        'room' => 'room01',
        'temperature' => 32
    )
);

之后可以读取：

$result = $memoryEngine->recall(
    'room01'
);

MemoryEngine 可以与：

ShortMemory
LongMemory
FactMemory
StateMemory
ExperienceMemory

配合。

其核心不是简单的文件读写，而是为 Individual 提供可使用的记忆机制。

14.6 ReasoningEngine

ReasoningEngine 是 SAI 中负责推理的 Engine。

它可以使用：

Facts
Objects
Properties
Relations
Rules
Experience
Memory

形成：

Conclusion

基本流程：

Facts
 +
Relations
 +
Rules
 ↓
ReasoningEngine
 ↓
Conclusion

例如：

Fact:
Room.temperature = 32

Fact:
Fan.state = OFF

Rule:
IF temperature > 30
THEN fan.turnOn

ReasoningEngine 处理：

32 > 30

得到：

Conclusion:
Fan should turn on

这里仍然不是执行。

推理得到的是：

应该做什么

而不是：

已经执行了什么

14.7 DecisionEngine

DecisionEngine 负责从推理结果和候选行为中选择具体决策。

例如 ReasoningEngine 得到：

Fan should turn on

DecisionEngine 可以进一步考虑：

Fan 是否可用？
当前是否有人？
风险是否允许？
是否存在更高优先级任务？

然后形成：

Decision
{
    action: fan.turnOn
}

流程：

Reasoning
 ↓
Candidates
 ↓
Condition
 ↓
Risk
 ↓
Priority
 ↓
DecisionEngine
 ↓
Decision

因此：

Reasoning = 得出结论
Decision = 选择行动

两者不能简单等同。

14.8 BehaviorEngine

BehaviorEngine 负责把 Decision 转换为可以执行的 Behavior。

例如：

Decision
fan.turnOn

转换为：

Behavior
TurnOnFan

进一步：

Behavior
 ↓
Action

例如：

$behavior = $behaviorEngine->create(
    'fan.turn_on',
    array(
        'device' => 'fan01'
    )
);

最终：

Behavior
├── type = device
├── target = fan01
└── action = turnOn

然后由执行层或 Adapter 将行为发送给实际设备。

14.9 LearningEngine

LearningEngine 负责根据反馈和经验进行学习处理。

基本流程：

Behavior
 ↓
Action
 ↓
Result
 ↓
Feedback
 ↓
Experience
 ↓
LearningEngine
 ↓
Update

例如：

温度 32℃
 ↓
打开风扇
 ↓
温度下降到 29℃

可以形成：

Experience
{
    condition: temperature > 30,
    action: fan.turnOn,
    result: temperature_decreased
}

LearningEngine 可以对经验进行整理：

Experience
 ↓
Pattern
 ↓
Knowledge
 ↓
Ability / Memory Update

需要注意：

LearningEngine 的学习是基于数据、经验、规则、状态和关系等可处理资源进行的机制设计，而不是通过大模型训练实现。

14.10 Engine 生命周期

Engine 本身也需要生命周期。

可以定义为：

Created
 ↓
Initialized
 ↓
Started
 ↓
Running
 ↓
Stopping
 ↓
Stopped

例如：

<?php

namespace SAI\Core;

abstract class Engine
{
    protected $state = 'created';

    public function initialize()
    {
        $this->state = 'initialized';
    }

    public function start()
    {
        $this->state = 'started';
    }

    public function stop()
    {
        $this->state = 'stopped';
    }

    public function getState()
    {
        return $this->state;
    }

    abstract public function process($input);
}

具体 Engine：

class ReasoningEngine extends Engine
{
    public function process($input)
    {
        return array(
            'type' => 'conclusion',
            'result' => 'fan_should_turn_on'
        );
    }
}

Engine 的生命周期由 Framework Runtime 管理。

14.11 Engine 调用

Engine 通常不会自己随意运行。

可以由 Central 或相应的协调组件进行调用。

例如：

Information
 ↓
Central
 ↓
PerceptionEngine
 ↓
CognitionEngine
 ↓
MemoryEngine
 ↓
ReasoningEngine
 ↓
DecisionEngine
 ↓
BehaviorEngine

代码形式可以是：

$element = $perceptionEngine->process(
    $information
);

$cognition = $cognitionEngine->process(
    $element
);

$memory = $memoryEngine->process(
    $cognition
);

$reasoning = $reasoningEngine->process(
    $memory
);

$decision = $decisionEngine->process(
    $reasoning
);

$behavior = $behaviorEngine->process(
    $decision
);

这里体现的是 Engine 的流水式调用。

14.12 Engine 组合

实际 SAI 不一定只有一条简单的 Engine 链。

Engine 可以形成组合。

例如：

                    Central
                       │
        ┌──────────────┼──────────────┐
        ↓              ↓              ↓
 Perception       Memory         Cognition
        │              │              │
        └──────────────┼──────────────┘
                       ↓
                  Reasoning
                       ↓
                   Decision
                       ↓
                   Behavior
                       ↓
                    Action
                       ↓
                   Feedback
                       ↓
                   Learning

还可以存在辅助 Engine：

ReasoningEngine
├── FactResolver
├── RuleResolver
└── RelationResolver

DecisionEngine：

DecisionEngine
├── CandidateManager
├── RiskEngine
└── PriorityEngine

LearningEngine：

LearningEngine
├── ExperienceAnalyzer
├── KnowledgeExtractor
└── AbilityUpdater

因此 Engine 可以继续组合内部组件。

14.13 完整 Engine 示例

下面使用：

房间温度 32℃
风扇 OFF
有人在房间

作为完整案例。

说明：以下代码为教程中的设计示例，用于说明 Engine 之间如何协作，并非已经实际部署或验证运行的 SAI Framework。

第一步：Information

$information = array(
    'type' => 'sensor',
    'room' => 'room01',
    'temperature' => 32
);

第二步：PerceptionEngine

$element = $perceptionEngine->process(
    $information
);

得到：

temperature = 32

第三步：CognitionEngine

$cognition = $cognitionEngine->process(
    $element
);

形成：

Room room01
temperature = 32

第四步：MemoryEngine

$memoryEngine->remember(
    'state',
    array(
        'room' => 'room01',
        'temperature' => 32,
        'fan' => 'OFF'
    )
);

第五步：ReasoningEngine

规则：

IF
temperature > 30
AND
fan = OFF

THEN
fan.turnOn

调用：

$reasoning = $reasoningEngine->process(
    array(
        'temperature' => 32,
        'fan' => 'OFF'
    )
);

结果：

fan should turn on

第六步：DecisionEngine

$decision = $decisionEngine->process(
    $reasoning
);

得到：

Decision:
fan.turnOn

第七步：BehaviorEngine

$behavior = $behaviorEngine->process(
    $decision
);

得到：

Behavior:
TurnOnFan

第八步：Action

Behavior
 ↓
Action
 ↓
fan01.turnOn()

设备状态：

OFF
 ↓
ON

第九步：Feedback

设备返回：

Fan ON
Temperature = 29℃

进入：

Feedback
 ↓
Information

第十步：LearningEngine

$experience = array(
    'condition' => 'temperature > 30',
    'action' => 'fan.turnOn',
    'result' => 'temperature_decreased'
);

$learningEngine->process(
    $experience
);

形成：

Experience
 ↓
Learning
 ↓
Memory Update

完整 Engine 数据流

最终整个过程：

                    Information
                         │
                         ▼
                PerceptionEngine
                         │
                         ▼
                      Element
                         │
                         ▼
                 CognitionEngine
                         │
                         ▼
                    Cognition
                         │
                         ▼
                   MemoryEngine
                         │
                         ▼
                     Memory
                         │
                         ▼
                 ReasoningEngine
                         │
                         ▼
                    Conclusion
                         │
                         ▼
                  DecisionEngine
                         │
                         ▼
                     Decision
                         │
                         ▼
                  BehaviorEngine
                         │
                         ▼
                     Behavior
                         │
                         ▼
                      Action
                         │
                         ▼
                     Device
                         │
                         ▼
                     Feedback
                         │
                         ▼
                  LearningEngine
                         │
                         ▼
                    Experience
                         │
                         ▼
                    Memory Update

这就是 SAI Framework 中 Engine 协作形成的基本运行链。

本章小结

Engine 是 SAI Framework 的处理执行层。

Model 负责：

数据
对象
属性
关系
状态
记忆
经验

Engine 负责：

感知
认知
记忆处理
推理
决策
行为
学习

核心 Engine 可以表示为：

PerceptionEngine
       ↓
CognitionEngine
       ↓
MemoryEngine
       ↓
ReasoningEngine
       ↓
DecisionEngine
       ↓
BehaviorEngine
       ↓
Action
       ↓
Feedback
       ↓
LearningEngine

最重要的关系是：

Model = 数据与对象资源
Engine = 数据处理与执行机制
Central = Engine 协调中心
Individual = 最终运行主体

因此 SAI Framework 可以进一步形成：

Individual
    │
    ▼
 Central
    │
    ├── Model
    │
    └── Engine
          │
          ├── Perception
          ├── Cognition
          ├── Memory
          ├── Reasoning
          ├── Decision
          ├── Behavior
          └── Learning

Model 让 Individual 拥有可组织的数据，Engine 让这些数据能够被处理，而 Central 则把多个 Engine 组织成连续运行过程。

第14章 Engine

第14章 Engine

本章大纲

14.1 Engine 定义

14.2 为什么使用 Engine

1. 职责分离

2. 独立开发

3. 独立测试

4. Engine 组合

5. Extension

14.3 PerceptionEngine

14.4 CognitionEngine

14.5 MemoryEngine

14.6 ReasoningEngine

14.7 DecisionEngine

14.8 BehaviorEngine

14.9 LearningEngine

14.10 Engine 生命周期

14.11 Engine 调用

14.12 Engine 组合

14.13 完整 Engine 示例

第一步：Information

第二步：PerceptionEngine

第三步：CognitionEngine

第四步：MemoryEngine

第五步：ReasoningEngine

第六步：DecisionEngine

第七步：BehaviorEngine

第八步：Action

第九步：Feedback

第十步：LearningEngine

完整 Engine 数据流

本章小结