第115章　SAI Framework 最终实例

前面第100章到第114章已经逐步建立了 SAI 的各个组成部分。

本章不再单独解释某一个组件，而是把这些组件真正串成一个完整运行实例。

为了保持结构清晰，本实例采用一个简单的机器人场景：

Robot_A 正在移动，前方发现一个距离 0.8 米的障碍物。SAI Individual 接收到传感器信息后，感知场景、建立对象和关系，进行认知、记忆读取、推理和决策，然后执行 STOP 行为，通过 Adapter 控制机器人停止，再接收反馈，形成经验，进行学习和更新，最后进入下一次运行。

整个实例全部采用结构化数据、对象、属性、关系、规则、状态和离散逻辑完成。

1. 创建 SAI

首先创建 SAI Framework。

SAI
│
├── Framework
├── Runtime
├── Individual
├── Cognitive
├── Behavior
├── External World
├── Feedback
├── Learning
└── Maintenance

创建：

$sai = new SAI(
    'SAI_001',
    'Simulated Artificial Intelligence'
);

此时：

SAI_001
state = CREATED

启动 Framework：

SAI
 ↓
Framework
 ↓
Kernel
 ↓
Registry
 ↓
Container
 ↓
Manager
 ↓
Runtime

状态：

CREATED
 ↓
INITIALIZING
 ↓
READY
 ↓
RUNNING

这意味着：

SAI Framework 已经进入运行状态。

2. 创建 Individual

Framework 准备完成以后，创建真正运行的人工个体。

$individual = new Individual(
    'Individual_A',
    'SAI Individual A'
);

Individual：

Individual_A
│
├── Identity
├── State
├── Ability
├── Memory
├── Central
└── InformationReceiver

启动：

Individual_A
 ↓
CREATED
 ↓
INITIALIZING
 ↓
READY

此时：

SAI Framework = RUNNING

Individual_A = READY

Individual 已经具备运行条件。

3. 接收信息

机器人上的距离传感器产生信息。

例如：

Sensor: DistanceSensor_A

distance = 0.8m
direction = FRONT
robot_state = MOVING
robot_speed = 1.2m/s

形成 Information：

$information = array(
    'id' => 'Information_001',
    'source' => 'DistanceSensor_A',
    'type' => 'SENSOR_DATA',
    'target' => 'Individual_A',
    'data' => array(
        'robot_id' => 'Robot_A',
        'distance' => 0.8,
        'direction' => 'FRONT',
        'robot_state' => 'MOVING',
        'speed' => 1.2
    )
);

进入：

External Sensor
 ↓
Information
 ↓
InformationReceiver
 ↓
Individual_A

InformationReceiver 只负责：

接收
 ↓
基本验证
 ↓
交给 Central

不负责推理和决策。

4. 采集场景

Individual 接收到信息以后，SceneCollector 对信息进行组织。

建立：

Scene_A

结构：

Scene_A
│
├── Robot_A
├── Obstacle_A
├── Position
├── Motion
├── Relations
├── Environment
└── Time

当前信息：

Robot_A
state = MOVING
speed = 1.2m/s

Obstacle_A
distance = 0.8m
direction = FRONT

于是形成：

Scene_A
{
    robot: Robot_A,
    obstacle: Obstacle_A,
    distance: 0.8,
    direction: FRONT,
    robot_state: MOVING
}

Scene 的意义是：

把当前多个信息组织成一个当前环境结构。

5. 感知

Scene 进入 Perception。

Scene_A
 ↓
Perception

Perception 对信息进行结构化：

distance = 0.8
direction = FRONT
state = MOVING
speed = 1.2

提取：

Element

例如：

Element_001
type = OBJECT
value = Robot_A

Element_002
type = OBJECT
value = Obstacle_A

Element_003
type = PROPERTY
name = distance
value = 0.8
unit = meter

Element_004
type = STATE
object = Robot_A
value = MOVING

Element_005
type = PROPERTY
name = direction
value = FRONT

Perception 的结果：

PerceptionResult
│
├── Elements
├── Objects
├── Properties
├── States
└── Relations

6. 建立元素

现在将感知结果中的基本单位明确建立出来。

Element
│
├── Object
├── Property
├── State
├── Relation
├── Value
├── Location
├── Time
└── Condition

本次运行的核心元素：

E1 = Robot_A
E2 = Obstacle_A
E3 = distance
E4 = 0.8
E5 = FRONT
E6 = MOVING
E7 = 1.2m/s

形成：

Element Set
=
{E1,E2,E3,E4,E5,E6,E7}

元素是后续对象和关系建立的基础。

7. 建立对象

根据元素建立 Object。

Robot Object

Robot_A
{
    id: Robot_A,
    type: ROBOT,
    state: MOVING,
    speed: 1.2
}

Obstacle Object

Obstacle_A
{
    id: Obstacle_A,
    type: OBSTACLE,
    distance: 0.8
}

注意：

Robot_A

是 SAI 内部的结构化对象。

它不是物理机器人本身。

Robot Object ≠ Physical Robot

8. 建立关系

对象之间必须建立 Relation。

例如：

Robot_A
   │
   └── FRONT_OF
          ↓
     Obstacle_A

形成：

Relation_001
{
    source: Robot_A,
    type: FRONT_OF,
    target: Obstacle_A,
    state: ACTIVE
}

同时可以建立：

Robot_A
 └── MOVING

以及：

Obstacle_A
 └── DISTANCE_FROM
        ↓
      Robot_A

因此当前场景已经从：

一组数据

变成：

Objects
+
Properties
+
States
+
Relations

这才成为可供 Cognition 使用的结构。

9. 认知

现在进入 Cognition。

PerceptionResult
 ↓
Cognition

Cognition 分析：

Robot_A
state = MOVING

Obstacle_A
distance = 0.8m

Relation
Robot_A FRONT_OF Obstacle_A

形成认知：

Robot_A 正在移动

Obstacle_A 位于 Robot_A 前方

Obstacle_A 距离 Robot_A 为 0.8 米

Robot_A 正在接近前方障碍物

认知结果：

CognitionResult
{
    object: Robot_A,
    scene: Scene_A,
    obstacle: Obstacle_A,
    relation: FRONT_OF,
    distance: 0.8,
    state: UNDERSTOOD
}

这里非常重要：

Perception = 获取并结构化
Cognition = 理解结构

Cognition 此时还没有决定：

STOP

10. 读取记忆

Cognition 完成以后，需要读取 Memory。

Cognition
 ↓
Memory

读取：

FactMemory
RelationMemory
StateMemory
ExperienceMemory

例如找到规则：

Rule_001

内容：

IF
distance < 1.0
AND
obstacle = FRONT
AND
robot_state = MOVING

THEN

risk = HIGH

同时读取过去经验：

Experience_001

历史记录：

condition:
front obstacle < 1.0m

action:
STOP

result:
SUCCESS

outcome:
SAFE

因此 Memory 为当前运行提供：

事实
+
规则
+
历史经验

11. 推理

现在进入 Reasoning。

输入：

Current Cognition
+
Memory
+
Rule
+
Experience

推理：

distance = 0.8

判断：

0.8 < 1.0

结果：

TRUE

然后：

obstacle = FRONT

结果：

TRUE

以及：

robot_state = MOVING

结果：

TRUE

三个条件同时成立：

TRUE
AND
TRUE
AND
TRUE

因此：

risk = HIGH

形成 Conclusion：

Conclusion_001
{
    subject: Robot_A,
    predicate: risk,
    value: HIGH,
    state: CONFIRMED
}

推理链：

distance = 0.8
      ↓
0.8 < 1.0
      ↓
TRUE

obstacle = FRONT
      ↓
TRUE

robot = MOVING
      ↓
TRUE

      ↓

risk = HIGH

12. 决策

Reasoning 得到：

Robot_A.risk = HIGH

现在进入 Decision。

候选方案：

Candidate
├── CONTINUE
├── SLOW_DOWN
├── STOP
├── TURN_LEFT
└── TURN_RIGHT

Decision 逐一检查：

Condition
Risk
Priority
Capability
Device State
Conflict
Experience

例如：

CONTINUE
Risk = HIGH
→ REJECT

SLOW_DOWN
Risk = HIGH
→ POSSIBLE

STOP
Risk = LOW
→ ACCEPT

最终：

Decision
{
    selected: STOP,
    state: DECIDED,
    reason: HIGH_RISK_FRONT_OBSTACLE
}

因此：

Conclusion = 风险高
Decision = STOP

两者不能混淆。

13. 行为

Decision 选择：

STOP

Behavior 将其组织成一个完整行为：

SAFE_STOP

行为过程：

SAFE_STOP
│
├── CHECK_STATE
├── REDUCE_SPEED
├── STOP
├── READ_STATE
└── VERIFY

于是：

Decision
 ↓
Behavior

Decision 是：

做什么？

Behavior 是：

如何组织这个行为过程？

14. Action

Behavior 进一步产生具体 Action。

例如：

Action 1

CHECK_STATE

Action 2

SET_SPEED
target = 0.5m/s

Action 3

STOP

Action 4

READ_STATE

Action 5

VERIFY

例如最终 Action：

Action_003
{
    id: Action_003,
    type: DEVICE_ACTION,
    target: Robot_A,
    method: STOP,
    parameters: {},
    state: READY
}

此时：

Decision
 ↓
Behavior
 ↓
Action

已经形成完整执行链。

15. Expression

Action 不能直接等同于外部表示。

因此产生 Expression。

Action
 ↓
Expression

例如：

$expression = array(
    'type' => 'ROBOT_COMMAND',
    'target' => 'Robot_A',
    'action' => 'STOP',
    'parameters' => array()
);

Expression 是：

把内部行动结构转换成可以继续传递和表现的结构。

此时仍然没有直接操作物理机器人。

16. SATE

Expression 进入 SATE。

Expression
 ↓
SATE
 ↓
Template

使用：

robot_command

模板：

{
    "robot_id": "{{robot.id}}",
    "command": "{{action}}",
    "parameters": "{{parameters}}"
}

输入：

robot.id = Robot_A
action = STOP
parameters = {}

得到结构化输出：

{
    robot_id: Robot_A,
    command: STOP,
    parameters: {}
}

SATE 负责：

Template
+
Data
→
Structured Output

它不进行：

认知
推理
决策
学习

17. Renderer

SATE 输出交给 Renderer。

SATE
 ↓
Renderer

本实例使用：

DeviceRenderer

将结构转换为设备命令表示。

例如：

RenderedResult
{
    format: DEVICE_COMMAND,
    robot_id: Robot_A,
    command: STOP,
    parameters: {}
}

Renderer 的职责是：

表现成什么形式。

它不决定：

是否应该 STOP

这个决定早已由 Decision 完成。

18. Adapter

Renderer 完成以后：

RenderedResult
 ↓
RobotAdapter

Adapter 连接 SAI 与真实机器人控制环境。

RobotAdapter
{
    target: Robot_A,
    state: CONNECTED
}

发送：

RobotCommand
{
    robot_id: Robot_A,
    command: STOP,
    parameters: {}
}

完整关系：

Action
 ↓
Expression
 ↓
SATE
 ↓
Renderer
 ↓
RobotAdapter

其中：

Renderer = 转换表现形式
Adapter = 连接外部环境

19. Device

RobotAdapter 将命令发送给真实设备。

RobotAdapter
 ↓
Robot Controller
 ↓
Physical Robot

Robot_A 当前：

state = MOVING
speed = 1.2m/s

接收到：

STOP

设备执行：

MOVING
 ↓
STOPPING
 ↓
STOPPED

速度：

1.2m/s
 ↓
0.8m/s
 ↓
0.3m/s
 ↓
0m/s

最终：

Robot_A
state = STOPPED
speed = 0

这里才是真正的：

External Execution

20. Feedback

机器人执行以后返回：

RobotResponse

例如：

{
    robot_id: Robot_A,
    command: STOP,
    state: STOPPED,
    speed: 0,
    result: SUCCESS
}

Adapter 接收以后形成：

Feedback

Feedback_001
{
    source: Robot_A,
    action: STOP,
    previous_state: MOVING,
    current_state: STOPPED,
    previous_speed: 1.2,
    current_speed: 0,
    result: SUCCESS
}

然后：

Feedback
 ↓
Information
 ↓
Perception

形成新的认知输入。

因此不能简单认为：

Action SUCCESS
=
目标一定成功

必须检查实际反馈。

21. Experience

Feedback 确认：

Robot_A
MOVING
 ↓
STOPPED

于是形成完整 Experience。

Experience_001
{
    task: AVOID_OBSTACLE,

    condition: {
        distance: 0.8,
        direction: FRONT,
        state: MOVING
    },

    decision: STOP,

    behavior: SAFE_STOP,

    action: STOP,

    result: SUCCESS,

    feedback: {
        state: STOPPED,
        speed: 0
    },

    outcome: SAFE,

    state: VERIFIED
}

Experience 保存的是：

条件
+
决策
+
行为
+
行动
+
结果
+
反馈

所以它不是简单的一条日志。

22. Learning

Experience 进入 Learning。

Experience
 ↓
Learning

Learning 对历史经历进行：

比较
 ↓
分析
 ↓
提取
 ↓
验证
 ↓
形成知识

例如：

Knowledge_001

可以形成：

Condition:
front obstacle
AND
distance < 1.0m
AND
robot moving

Knowledge:
STOP is a safe response

State:
VERIFIED

也可以形成结构化规则：

IF
obstacle = FRONT
AND
distance < 1.0
AND
robot_state = MOVING

THEN

candidate = STOP

注意：

Learning 是获取知识的过程，不是简单把 Experience 原样保存。

23. Update

Learning 完成以后进行 Update。

Learning
 ↓
Knowledge
 ↓
Update

可能更新：

Memory
FactMemory
RelationMemory
StateMemory
ExperienceMemory
Rule
Knowledge
Ability Resource
History

例如：

Memory_A

新增：

Rule_002

同时保留：

Experience_001

以及历史状态：

t1 = MOVING
t2 = STOPPING
t3 = STOPPED

因此：

Update ≠ Delete + Replace

而是：

在保留历史的基础上形成新的有效状态和知识资源。

24. 再次运行

这是整个实例最重要的一步。

SAI 并不会：

执行一次
 ↓
结束

而是重新进入 Runtime。

Update
 ↓
READY / WAITING
 ↓
New Information
 ↓
New Scene
 ↓
Perception
 ↓
Cognition
 ↓
Memory
 ↓
Reasoning
 ↓
Decision
 ↓
Behavior
 ↓
Action
 ↓
External World
 ↓
Feedback
 ↓
Experience
 ↓
Learning
 ↓
Update
 ↓
再次运行

24.1 第二次信息

假设新的传感器信息：

Robot_A
state = STOPPED
speed = 0

Obstacle_A
distance = 1.5m
direction = FRONT

进入：

Information
 ↓
Scene
 ↓
Perception
 ↓
Cognition

现在：

distance = 1.5

检查规则：

1.5 < 1.0

结果：

FALSE

同时：

robot_state = STOPPED

所以之前：

risk = HIGH

不能直接继续使用。

必须重新推理。

这体现了：

Memory 提供历史资源，但不能替代当前感知。

24.2 第二次推理

当前状态：

Robot_A = STOPPED
Obstacle_A = FRONT
distance = 1.5m

规则：

distance < 1.0

结果：

FALSE

所以：

risk = HIGH

不成立。

可能形成：

risk = NORMAL

或者：

risk = LOW

具体结果由当前系统定义的规则决定。

24.3 第二次决策

候选：

CONTINUE
SLOW_DOWN
STOP

当前：

risk = NORMAL
robot_state = STOPPED
distance = 1.5

可能选择：

START / CONTINUE

如果系统已有对应能力、规则和安全条件，则重新形成：

Decision
 ↓
Behavior
 ↓
Action
 ↓
Adapter
 ↓
Robot

于是第二个运行周期开始。

24.4 SAI 已经形成连续循环

因此：

Run 1
 ↓
Feedback
 ↓
Experience
 ↓
Learning
 ↓
Update
 ↓
Run 2
 ↓
Feedback
 ↓
Experience
 ↓
Learning
 ↓
Update
 ↓
Run 3
 ↓
...

这才是：

SAI 的连续运行。

24.5 最终完整数据流

把本章24个步骤全部连接起来：

SAI
 ↓
Framework
 ↓
Runtime
 ↓
Individual
 ↓
InformationReceiver
 ↓
Information
 ↓
SceneCollector
 ↓
Scene
 ↓
Perception
 ↓
Element
 ↓
Object
 ↓
Relation
 ↓
Cognition
 ↓
Memory
 ↓
Reasoning
 ↓
Conclusion
 ↓
Decision
 ↓
Behavior
 ↓
Action
 ↓
Expression
 ↓
SATE
 ↓
Template
 ↓
Renderer
 ↓
Adapter
 ↓
Device
 ↓
External World
 ↓
Feedback
 ↓
Information
 ↓
Experience
 ↓
Learning
 ↓
Knowledge
 ↓
Update
 ↓
Memory
 ↓
New Information
 ↓
再次运行

115章最终闭环

最终可以把整个 SAI Framework 表示为三个主要循环。

第一部分：认知循环

Information
 ↓
Scene
 ↓
Perception
 ↓
Element
 ↓
Object
 ↓
Relation
 ↓
Cognition
 ↓
Memory
 ↓
Reasoning
 ↓
Decision

解决：

世界是什么？发生了什么？应该怎么选择？

第二部分：行为循环

Decision
 ↓
Behavior
 ↓
Action
 ↓
Expression
 ↓
SATE
 ↓
Renderer
 ↓
Adapter
 ↓
Device
 ↓
External World

解决：

选择以后如何作用于外部世界？

第三部分：学习循环

External World
 ↓
Feedback
 ↓
Experience
 ↓
Learning
 ↓
Knowledge
 ↓
Update
 ↓
Memory
 ↓
Next Runtime

解决：

这次发生了什么？从中获得什么？以后如何使用？

SAI Framework 最终结构

因此，一个完整的 SAI 不应该理解成：

一个 Engine

也不应该理解成：

一个 Object

而应该理解为：

                    SAI Framework
                          │
                       Runtime
                          │
                      Individual
                          │
          ┌───────────────┴───────────────┐
          │                               │
     Cognitive Layer                 Behavior Layer
          │                               │
 Information→Scene                  Decision→Behavior
 →Perception→Object                       ↓
 →Cognition→Memory                     Action
 →Reasoning→Decision                      ↓
          │                           Expression
          │                               ↓
          │                           SATE/Renderer
          │                               ↓
          │                            Adapter
          │                               ↓
          │                        External World
          │                               │
          └───────────────┬───────────────┘
                          ↓
                       Feedback
                          ↓
                     Experience
                          ↓
                       Learning
                          ↓
                       Update
                          ↓
                       Memory
                          ↓
                    New Information
                          ↺

第115章核心定义

SAI Framework

SAI Framework 是提供模拟人工个体运行环境、生命周期、组件管理和运行机制的基础框架。

Runtime

Runtime 是驱动 Individual 持续接收信息、处理信息、执行行为、获取反馈并进入下一周期的运行机制。

Individual

Individual 是 SAI 的模拟人工主体，统一组织感知、认知、记忆、推理、决策、行为、学习和维护。

Cognitive

Cognitive 是 Individual 对外部世界进行感知、理解、记忆、推理和决策的认知系统。

Behavior

Behavior 是 Individual 将 Decision 组织成为连续执行过程的行为系统。

External World

External World 是 Individual 所感知、作用并产生实际变化的外部环境。

Feedback

Feedback 是外部执行产生的实际状态、结果、变化和错误重新进入 Individual 的信息。

Experience

Experience 是 Individual 对一次完整条件、决策、行为、行动、结果和反馈过程的历史记录。

Learning

Learning 是 Individual 从 Experience、Feedback、Memory 和其他信息中获取、验证和形成知识资源的过程。

Update

Update 是将新的知识、事实、关系、状态、规则和能力资源重新写入 Individual 运行体系的过程。

本章最终模型

Framework
   ↓
Runtime
   ↓
Individual
   ↓
Perception
   ↓
Cognition
   ↓
Memory
   ↓
Reasoning
   ↓
Decision
   ↓
Behavior
   ↓
Action
   ↓
External Execution
   ↓
Feedback
   ↓
Experience
   ↓
Learning
   ↓
Update
   ↓
Individual
   ↺

由此，第100章开始的“开发一个简单 SAI”，经过对象、Engine、Module、Extension、Framework、Individual、认知、行为、外部世界、反馈和学习等逐步展开，到第115章已经形成了一个完整的 SAI Framework → Runtime → Individual → Cognitive → Behavior → External World → Feedback → Learning 的闭环实例。

第115章 SAI Framework 最终实例

第115章 SAI Framework 最终实例

1. 创建 SAI

2. 创建 Individual

3. 接收信息

4. 采集场景

5. 感知

6. 建立元素

7. 建立对象

Robot Object

Obstacle Object

8. 建立关系

9. 认知

10. 读取记忆

11. 推理

12. 决策

13. 行为

14. Action

Action 1

Action 2

Action 3

Action 4

Action 5

15. Expression

16. SATE

17. Renderer

18. Adapter

19. Device

20. Feedback

21. Experience

22. Learning

23. Update

24. 再次运行

24.1 第二次信息

24.2 第二次推理

24.3 第二次决策

24.4 SAI 已经形成连续循环

24.5 最终完整数据流

115章最终闭环

第一部分：认知循环

第二部分：行为循环

第三部分：学习循环

SAI Framework 最终结构

第115章核心定义

本章最终模型