第112章　SAI Framework 完整运行机制

第111章建立了 SAI 的完整数据流，回答了数据从外部世界进入以后，依次经过什么结构。

本章进一步从 Framework Runtime 的角度说明：

SAI Framework 如何启动 Individual，如何启动 Central，如何接收信息、处理场景、完成感知、认知、记忆、推理、决策、行为和执行，再通过反馈形成经验、学习和更新，最后重新进入下一轮生命周期。

因此，本章重点是完整运行过程。

1. Framework 启动

SAI Framework 是整个 SAI 的运行基础。

启动顺序：

Application
    ↓
Framework
    ↓
Kernel
    ↓
Config
    ↓
Registry
    ↓
Container
    ↓
Manager
    ↓
Components

Framework 首先完成自身初始化。

1.1 Framework 启动内容

主要包括：

配置加载
组件注册
运行对象创建
依赖检查
Manager 初始化
Lifecycle 初始化
Event 初始化
Task 初始化
Log 初始化
Exception 初始化

最终：

Framework
STATE = READY

然后进入：

STARTING
    ↓
RUNNING

1.2 Framework 启动模型

CREATE
  ↓
INITIALIZE
  ↓
READY
  ↓
START
  ↓
RUNNING

只有 Framework 进入 RUNNING，后面的 Individual 才应该进入正式运行状态。

2. Individual 启动

Framework 启动以后，创建并启动 Individual。

Framework
    ↓
IndividualManager
    ↓
Individual_A

Individual 生命周期：

CREATED
   ↓
INITIALIZING
   ↓
READY
   ↓
RUNNING

2.1 Individual 启动内容

Individual 需要建立：

Identity
State
Ability
Memory
Central
InformationReceiver

结构：

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

2.2 Individual 启动后的状态

Individual_A
STATE = READY

说明：

Individual 已经具备运行条件，但还没有处理当前信息。

收到信息后：

READY
  ↓
RUNNING

处理完成后：

RUNNING
  ↓
READY

3. Central 启动

Individual 启动以后，需要启动 Central。

Central 是 Individual 内部的运行协调中心。

Individual
     ↓
Central

Central 负责组织：

Information
Scene
Perception
Cognition
Memory
Reasoning
Decision
Behavior
Expression
Learning

3.1 Central 启动

Central
  ↓
Load Components
  ↓
Check Dependencies
  ↓
Initialize
  ↓
READY

例如：

Central_A
STATE = READY

3.2 Central 不负责智能判断

Central 的作用是：

接收
组织
调用
传递
协调
返回

而不是直接负责：

感知
认知
推理
决策

因此：

Central ≠ Cognition
Central ≠ Reasoning
Central ≠ Decision

4. 信息进入

Framework 运行以后，外部信息可以进入 Individual。

信息来源可能是：

Sensor
Camera
Device
Web
API
Operator
External System
Feedback
Internal State

基本路径：

External Source
      ↓
Information
      ↓
InformationReceiver
      ↓
Individual
      ↓
Central

例如：

Information_001
{
    source: DistanceSensor_A,
    type: SENSOR_DATA,
    target: Robot_A,
    data: {
        distance: 0.8,
        direction: FRONT
    }
}

4.1 信息接收

InformationReceiver 首先检查：

是否存在
数据是否有效
来源是否明确
目标是否明确
结构是否正确

通过以后：

Information
STATE = ACCEPTED

然后进入 Central。

5. 场景进入

Information 进入以后，需要形成当前 Scene。

Information
     ↓
SceneCollector
     ↓
Scene

例如：

Scene_A
│
├── Robot_A
│   ├── speed = 1.2
│   └── state = MOVING
│
└── Obstacle_A
    ├── distance = 0.8
    └── direction = FRONT

5.1 Scene 的作用

Scene 不是单个 Information。

它是：

某一时刻或某一时间范围内多个信息经过组织后形成的当前环境结构。

例如：

t1:
distance = 2.0

t2:
distance = 1.5

t3:
distance = 0.8

SceneCollector 可以形成：

distance:
2.0 → 1.5 → 0.8

change:
DECREASING

因此 Scene 为 Perception 和 Cognition 提供当前环境结构。

6. 感知

Scene 和 Information 进入 Perception。

Scene
 ↓
Perception

Perception 对信息进行结构化。

例如：

distance = 0.8
direction = FRONT

形成：

Element

进一步识别：

Object
Property
State
Relation

6.1 感知过程

Information
    ↓
Validation
    ↓
Element Extraction
    ↓
Object Recognition
    ↓
Property Recognition
    ↓
State Recognition
    ↓
Relation Recognition
    ↓
Perception Result

例如：

Obstacle_A
distance = 0.8
direction = FRONT
state = ACTIVE

此时只是：

感知到了什么。

还不是完整认知。

7. 认知

Perception 的结果进入 Cognition。

Perception
    ↓
Cognition

Cognition 对：

Object
Property
State
Relation
Condition
Scene

进行组织和理解。

例如：

Robot_A
    │
    │ FRONT_OF
    ↓
Obstacle_A

Obstacle_A.distance = 0.8
Robot_A.state = MOVING

Cognition 可以形成：

Robot_A 正在运动

Obstacle_A 位于 Robot_A 前方

Obstacle_A 距离 Robot_A 0.8m

当前存在前方障碍物

最终：

CognitionResult
STATE = UNDERSTOOD

8. 记忆

认知结果进入 Memory，同时读取历史 Memory。

             ┌──────────────┐
             │    Memory    │
             └──────┬───────┘
                    ↑ ↓
             Current Cognition
                    │
                    ↓
                 Reasoning

Memory 中可能存在：

ShortMemory
LongMemory
FactMemory
RelationMemory
StateMemory
ExperienceMemory

8.1 当前记忆

例如：

ShortMemory
{
    robot: Robot_A,
    obstacle: Obstacle_A,
    distance: 0.8,
    state: MOVING
}

8.2 历史记忆

例如：

FactMemory
distance < 1.0 → high risk

ExperienceMemory
类似情况下 STOP → SUCCESS

于是当前运行同时拥有：

当前场景
+
历史资源

9. 推理

Cognition 和 Memory 的结果进入 Reasoning。

Cognition
   +
Memory
   +
Rules
   ↓
Reasoning

例如：

distance = 0.8

规则：

IF distance < 1.0
THEN risk = HIGH

计算：

0.8 < 1.0

得到：

TRUE

形成：

Conclusion
{
    target: Robot_A,
    property: risk,
    value: HIGH,
    state: CONFIRMED
}

9.1 推理的核心

Known Facts
+
Current Conditions
+
Rules
+
Experience
+
Memory
      ↓
Reasoning
      ↓
Conclusion

Reasoning 的作用是：

从已有结构中得到新的结构化结论。

10. 决策

Reasoning 得到 Conclusion：

risk = HIGH

进入 Decision。

Conclusion
    ↓
Decision

Decision 建立候选：

CONTINUE
SLOW_DOWN
STOP
TURN_LEFT
TURN_RIGHT

然后检查：

Condition
Capability
Risk
Priority
Conflict
State
Experience

最终：

Decision = STOP

10.1 Decision 的核心

Reasoning
   ↓
Conclusion
   ↓
Candidates
   ↓
Risk / Priority / Condition
   ↓
Selection
   ↓
Decision

所以：

Conclusion = 得到了什么结论
Decision = 选择做什么

11. 行为

Decision 产生以后进入 Behavior。

Decision
    ↓
Behavior

例如：

Decision = STOP

形成：

Behavior = SAFE_STOP

行为可以组织多个 Action：

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

11.1 Behavior 的作用

Behavior 负责：

执行顺序
执行状态
等待
暂停
失败处理
完成处理

所以：

Decision = 选择
Behavior = 组织执行过程
Action = 具体操作

12. 表现

Action 产生以后，如果需要通过某种外部接口表示，需要形成 Expression。

Action
   ↓
Expression

例如：

Action:
STOP Robot_A

形成：

Expression
{
    type: ACTION,
    target: Robot_A,
    action: STOP
}

然后根据目标：

Expression
    ↓
Template
    ↓
Renderer

例如设备控制：

Expression
    ↓
Device Template
    ↓
DeviceRenderer

形成设备能够识别的数据结构。

12.1 表现不改变决策

Expression 只负责：

表达
组织
转换

不能重新决定：

STOP

还是：

TURN

因此：

Decision → Expression

而不是：

Expression → Decision

13. 外部执行

表现结果或者 Action 最终通过 Adapter 连接外部环境。

设备控制：

Action
 ↓
DeviceAdapter
 ↓
DeviceCommand
 ↓
External Device

例如：

Action:
STOP Robot_A

转换为：

DeviceCommand
{
    robot_id: Robot_A,
    command: STOP
}

发送：

RobotAdapter
      ↓
Robot Controller
      ↓
Physical Robot

真实机器人：

MOVING
   ↓
STOPPING
   ↓
STOPPED

速度：

1.2m/s
   ↓
0m/s

这才是外部执行。

14. 反馈

外部执行完成后产生 Feedback。

例如：

DeviceResponse
{
    robot_id: Robot_A,
    state: STOPPED,
    speed: 0
}

转换为：

Feedback
{
    source: Robot_A,
    action: STOP,
    state: STOPPED,
    changes: {
        speed: 1.2 → 0
    }
}

反馈重新进入 SAI：

External Device
      ↓
Device Response
      ↓
Adapter
      ↓
Feedback
      ↓
Information
      ↓
Perception

14.1 为什么必须反馈

SAI 不能简单认为：

Action SUCCESS

就等于：

External Result SUCCESS

例如：

发送 STOP

不代表：

机器人已经停止

必须通过 Feedback 获得实际状态。

因此：

Command
≠
Actual Result

15. 经验

完整执行过程结束以后形成 Experience。

Condition
+
Decision
+
Behavior
+
Action
+
Result
+
Feedback
      ↓
Experience

例如：

Experience_001
{
    condition: {
        obstacle_distance: 0.8
    },

    decision: STOP,

    behavior: SAFE_STOP,

    action: STOP,

    result: SUCCESS,

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

    outcome: SAFE
}

Experience 保存的是：

这一次运行发生了什么。

而不是单纯保存一个最终值。

16. 学习

Experience 进入 Learning。

Experience
     ↓
Learning

Learning 可以结合：

Experience
Feedback
Memory
Information
Existing Knowledge

进行：

比较
分析
提取
验证
归纳
更新

例如多次经历：

distance < 1.0
      ↓
STOP
      ↓
SUCCESS

经过验证以后形成结构化知识：

Knowledge
{
    condition: distance < 1.0,
    action: STOP,
    result: SAFE,
    state: VERIFIED
}

这里的学习是：

从已有运行数据和经验中获取可重复使用的知识资源。

17. 更新

Learning 形成知识以后，需要更新系统内部资源。

Learning
    ↓
Knowledge
    ↓
Update

更新对象可以包括：

Memory
Fact
Relation
State
Experience
Rule
Knowledge
Ability Resource
History

例如：

Experience
     ↓
Learning
     ↓
Knowledge
     ↓
Memory Update

如果新知识经过严格验证，也可以进入规则资源：

Knowledge
     ↓
Rule Update

如果形成新的能力资源：

Knowledge
     ↓
Ability Resource Update

18. 生命周期重新开始

更新不是 SAI 运行的终点。

更新完成以后：

UPDATE
   ↓
WAITING / READY
   ↓
NEW INFORMATION

新的外部变化再次进入：

信息
 ↓
场景
 ↓
感知
 ↓
认知
 ↓
记忆
 ↓
推理
 ↓
决策
 ↓
行为
 ↓
表现
 ↓
执行
 ↓
反馈
 ↓
经验
 ↓
学习
 ↓
更新

于是生命周期重新开始。

19. 完整运行实例

假设：

Robot_A
speed = 1.2m/s

Obstacle_A
distance = 0.8m

完整运行：

Framework
   ↓
Individual_A
   ↓
Central
   ↓
Information
   ↓
Scene
   ↓
Perception
   ↓
Object + Property + State + Relation
   ↓
Cognition
   ↓
Memory
   ↓
Reasoning
   ↓
Conclusion: risk = HIGH
   ↓
Decision
   ↓
STOP
   ↓
Behavior
   ↓
SAFE_STOP
   ↓
Action
   ↓
STOP Robot_A
   ↓
Expression
   ↓
Template / Renderer
   ↓
RobotAdapter
   ↓
Physical Robot
   ↓
Robot STOPPED
   ↓
Feedback
   ↓
Experience
   ↓
Learning
   ↓
Knowledge
   ↓
Update Memory
   ↓
等待新的 Information

20. SAI Framework 的完整运行循环

从 Framework 的角度，可以压缩成：

Framework
   ↓
Individual
   ↓
Central
   ↓
Information
   ↓
Scene
   ↓
Perception
   ↓
Cognition
   ↓
Memory
   ↓
Reasoning
   ↓
Decision
   ↓
Behavior
   ↓
Expression
   ↓
External Execution
   ↓
Feedback
   ↓
Experience
   ↓
Learning
   ↓
Update
   ↓
New Information
   ↺

21. Framework、Individual、Central 三层关系

三者必须严格区分。

SAI Framework
│
│ 负责整个系统运行
│
└── Individual
      │
      │ 负责人工个体运行
      │
      └── Central
            │
            │ 负责个体内部协调
            │
            ├── Perception
            ├── Cognition
            ├── Memory
            ├── Reasoning
            ├── Decision
            ├── Behavior
            ├── Action
            └── Learning

因此：

Framework = 系统运行
Individual = 个体运行
Central = 个体内部协调

22. SAI Framework 的完整生命周期

Framework 自身：

CREATED
   ↓
INITIALIZING
   ↓
READY
   ↓
STARTING
   ↓
RUNNING
   ↓
STOPPING
   ↓
STOPPED
   ↓
SHUTDOWN

Individual：

CREATED
   ↓
INITIALIZING
   ↓
READY
   ↓
RUNNING
   ↓
WAITING
   ↓
RUNNING
   ↓
...

因此 Framework 的生命周期是系统级生命周期，Individual 的生命周期是个体级生命周期。

23. 一次运行与整个生命周期

必须区分：

一次运行

Information
→ Perception
→ Cognition
→ Reasoning
→ Decision
→ Behavior
→ Action
→ Execution
→ Feedback

一次运行结束后的学习

Feedback
→ Experience
→ Learning
→ Update

整个生命周期

Information
→ ...
→ Update
→ New Information
→ ...
→ Update
→ New Information
→ ...

所以 SAI 不是：

输入一次
处理一次
结束

而是：

接收
→ 理解
→ 决策
→ 执行
→ 反馈
→ 学习
→ 更新
→ 再接收
→ 再运行

24. 本章核心模型

                         SAI Framework
                              │
                              ↓
                         Individual
                              │
                              ↓
                           Central
                              │
                              ↓
                         信息进入
                              │
                              ↓
                           场景
                              │
                              ↓
                           感知
                              │
                              ↓
                           认知
                              │
                              ↓
                           记忆
                              │
                              ↓
                           推理
                              │
                              ↓
                           决策
                              │
                              ↓
                           行为
                              │
                              ↓
                           表现
                              │
                              ↓
                         外部执行
                              │
                              ↓
                           反馈
                              │
                              ↓
                           经验
                              │
                              ↓
                           学习
                              │
                              ↓
                           更新
                              │
                              ↓
                      生命周期重新开始
                              │
                              ↓
                         新的信息
                              ↺

第112章核心定义

Framework 启动：

建立 SAI 的运行环境，使 Kernel、Container、Registry、Manager 及相关组件进入可运行状态。

Individual 启动：

创建并初始化一个可以独立运行的 SAI 人工个体。

Central 启动：

建立 Individual 内部各功能组件之间的运行协调机制。

信息进入：

外部或内部信息通过 InformationReceiver 进入 Individual。

场景进入：

将一个或多个信息组织为当前 Scene。

感知：

将信息转换为 Element、Object、Property、State、Relation 等结构。

认知：

对感知形成的结构进行组织、匹配和理解。

记忆：

保存和提供当前及历史认知资源。

推理：

使用事实、规则、条件、经验和记忆形成新的结论。

决策：

根据结论、候选、风险、优先级、状态和能力选择处理方案。

行为：

将决策组织成连续执行过程。

表现：

将内部结果按照 Template、Renderer 等机制形成外部可使用的结构。

外部执行：

通过 Adapter 将 Action 或执行结构作用于外部设备或系统。

反馈：

获取外部执行后的真实结果和状态变化。

经验：

保存一次完整运行中的条件、决策、行为、行动、结果和反馈。

学习：

从经验、反馈、信息和已有资源中获取可重复使用的知识资源。

更新：

将经过学习和验证的知识更新到 Memory、Rule、Knowledge、Ability Resource 等内部资源。

第112章最终结论

SAI Framework 的完整运行机制可以定义为：

Framework 负责启动和维持运行环境，Individual 负责作为人工个体运行，Central 负责个体内部协调；信息进入后形成场景，经感知、认知、记忆、推理和决策形成行为与行动，再通过表现和外部接口作用于世界；外部世界产生反馈，反馈形成经验，经验经过学习形成知识并更新内部资源，随后 Individual 再次接收新的信息，进入下一轮生命周期。

最终形成：

Framework
→ Individual
→ Central
→ Information
→ Scene
→ Perception
→ Cognition
→ Memory
→ Reasoning
→ Decision
→ Behavior
→ Expression
→ Execution
→ Feedback
→ Experience
→ Learning
→ Update
→ New Information
→ ...

这就是 SAI Framework 的完整运行机制。

第112章 SAI Framework 完整运行机制

第112章 SAI Framework 完整运行机制

1. Framework 启动

1.1 Framework 启动内容

1.2 Framework 启动模型

2. Individual 启动

2.1 Individual 启动内容

2.2 Individual 启动后的状态

3. Central 启动

3.1 Central 启动

3.2 Central 不负责智能判断

4. 信息进入

4.1 信息接收

5. 场景进入

5.1 Scene 的作用

6. 感知

6.1 感知过程

7. 认知

8. 记忆

8.1 当前记忆

8.2 历史记忆

9. 推理

9.1 推理的核心

10. 决策

10.1 Decision 的核心

11. 行为

11.1 Behavior 的作用

12. 表现

12.1 表现不改变决策

13. 外部执行

14. 反馈

14.1 为什么必须反馈

15. 经验

16. 学习

17. 更新

18. 生命周期重新开始

19. 完整运行实例

20. SAI Framework 的完整运行循环

21. Framework、Individual、Central 三层关系

22. SAI Framework 的完整生命周期

23. 一次运行与整个生命周期

一次运行

一次运行结束后的学习

整个生命周期

24. 本章核心模型

第112章核心定义

第112章最终结论