第36章　行为运行时

第35章完成了从抽象结构到具体实例的转换：

Method
   ↓
Method Instance
   ↓
Behavior
   ↓
Behavior Instance
   ↓
Action
   ↓
Action Instance

但是，实例化并不等于运行。

一个 Behavior Instance 被创建之后，必须进入一个持续运行的过程：

State
   ↓
Method
   ↓
Behavior
   ↓
Action
   ↓
Feedback

反馈又会改变下一时刻的 State：

State(t)
   ↓
Method
   ↓
Behavior
   ↓
Action
   ↓
Execution
   ↓
Feedback
   ↓
State(t+1)
   ↺

因此，本章定义：

行为运行时（Behavior Runtime）是人工个体在当前认知状态下，使方法、行为和动作持续进入执行过程，并通过实时反馈不断更新状态、行为和后续动作的动态运行结构。

36.1 什么是行为运行时

Runtime 的核心不是“运行一个程序”，而是：

让已经形成的结构在时间中真正持续存在、变化、执行和结束。

对于 ICAI：

Definition
    ↓
Instance
    ↓
Runtime

分别代表三个不同层次。

Definition

描述：

它是什么？

Instance

描述：

当前具体是什么？

Runtime

描述：

当前正在怎样运行？

因此：

Method
   ↓
Method Instance
   ↓
Method Runtime

Behavior
   ↓
Behavior Instance
   ↓
Behavior Runtime

Action
   ↓
Action Instance
   ↓
Action Execution

行为运行时就是把这些结构连接成一个持续过程。

36.2 行为运行时的核心循环

本章核心结构：

State
  ↓
Method
  ↓
Behavior
  ↓
Action
  ↓
Feedback
  ↓
State
  ↺

进一步展开：

Current State
     ↓
Method Selection
     ↓
Method Instance
     ↓
Behavior Instance
     ↓
Behavior State
     ↓
Action Instance
     ↓
Execution
     ↓
Actual Result
     ↓
Feedback
     ↓
State Update
     ↺

这意味着 Behavior Runtime 不是一次性的执行函数，而是：

State → Action → Feedback → State 的持续循环系统。

36.3 State：运行时的起点

行为运行时从 State 开始。

因为人工个体不能脱离当前状态决定行为。

当前状态可能包括：

Object State
Scene State
Environment State
Cognitive State
Goal State
Capability State
Behavior State
Resource State
Risk State

因此：

State(t)
   ↓
Current Situation
   ↓
Method

当前状态决定：

当前目标是否仍然有效；
当前方法是否仍然可用；
当前行为是否能够继续；
当前动作是否可以执行；
当前参数是否需要调整。

所以：

State 是行为运行时的输入状态。

36.4 State 不是静态数据

行为运行过程中，State 会持续变化：

State(t)
   ↓
Action
   ↓
State(t+1)

例如：

Approach
   ↓
Contact
   ↓
Grasp
   ↓
Move
   ↓
Hold
   ↓
Release
   ↓
Complete

这些不仅是 Behavior State 的变化，同时也反映对象、环境和认知状态的变化。

因此：

$Statet+1=F(Statet,Actiont,Environmentt)State_{t+1}=F(State_t,Action_t,Environment_t)$

Behavior Runtime 的本质，就是不断处理：

$Statet→Statet+1State_t \rightarrow State_{t+1}$

36.5 Method：运行时的处理规则

State 确定之后，需要确定当前采用的方法。

State
   ↓
Goal
   ↓
Capability
   ↓
Method

Method 在运行时承担：

根据当前状态和目标，规定应该如何产生后续行为和动作。

因此：

State
   ↓
Method
   ↓
Behavior

不是：

State → fixed Action

而是：

State
   ↓
Method
   ↓
Behavior
   ↓
Action

Method 是行为运行时的组织规则。

36.6 Method 在运行时并非永远固定

Behavior Runtime 是动态的。

因此当前 Method 也可能失效。

例如：

State
   ↓
Method A
   ↓
Behavior
   ↓
Action
   ↓
Environment Change
   ↓
Feedback
   ↓
State Change
   ↓
Method A Invalid

此时：

Method Re-Evaluation
      ↓
Method B

于是：

State
   ↓
Method A
   ↓
Feedback
   ↓
New State
   ↓
Method B
   ↓
Behavior Continue

因此行为运行时允许：

Method Continue
Method Adapt
Method Switch
Method Recover

36.7 Behavior：运行时的过程结构

Method 确定之后进入 Behavior。

Behavior 负责把方法组织成一个连续过程：

Method
   ↓
Behavior
   ↓
Behavior State
   ↓
Current Action

Behavior 不只是“动作列表”。

它还维护：

Current State
Action
Transition
Condition
Constraint
Feedback
History
Goal

因此 Behavior Runtime 实际上运行的是：

一个不断发生状态转换的行为过程。

36.8 Behavior Runtime 与 Behavior Instance

二者必须区分。

Behavior Instance

表示：

当前这个具体行为对象。

而：

Behavior Runtime

表示：

这个行为对象正在时间中运行的过程。

因此：

Behavior Instance
       ↓
Behavior Runtime
       ↓
State Transition
       ↓
Action Execution

可以理解为：

Behavior Instance = 当前行为是谁
Behavior Runtime  = 当前行为如何运行

36.9 Action：运行时的具体动作

Behavior Runtime 最终必须产生 Action。

Behavior
   ↓
Current Behavior State
   ↓
Action

Action 是运行时中的具体操作单元。

例如：

Behavior = Object Transfer

Action 1 = Approach
Action 2 = Contact
Action 3 = Grasp
Action 4 = Lift
Action 5 = Move
Action 6 = Hold
Action 7 = Release

Behavior Runtime 按当前状态决定：

现在应该产生哪一个 Action。

36.10 Action 不是一次性静态命令

Action 在 Runtime 中必须具有当前上下文：

Action Instance
├── Target
├── Parameter
├── Condition
├── Constraint
├── Expected Result
└── Execution Context

因此运行时过程：

Behavior State
      ↓
Action Selection
      ↓
Action Instantiation
      ↓
Action Instance
      ↓
Execution

Action Instance 才是进入实际执行的具体动作结构。

36.11 Feedback：运行时的闭环

如果没有 Feedback：

State
 ↓
Method
 ↓
Behavior
 ↓
Action
 ↓
Execution

系统就只能单向运行。

它不知道：

动作是否成功？
状态是否变化？
目标是否达成？
环境是否变化？
风险是否增加？
方法是否仍然有效？

所以必须：

Action
   ↓
Execution
   ↓
Feedback

Feedback 将现实结果重新送回行为运行时。

36.12 Feedback 的内容

Feedback 不只是：

Success / Failure

而可以包含：

Actual State
Actual Position
Actual Force
Actual Result
Deviation
Unexpected Event
Environment Change
Risk Change
Constraint Change
Progress
Failure

因此：

Action
   ↓
Actual Result
   ↓
Feedback

Feedback 实际上是一次新的状态认知输入。

36.13 Feedback → State Update

Behavior Runtime 最关键的一步：

Feedback
   ↓
State Update

例如：

State(t)
   ↓
Move Action
   ↓
Execution
   ↓
Feedback
   ↓
Position Changed
   ↓
State(t+1)

所以：

$Statet+1=Update(Statet,Feedbackt)State_{t+1} = Update(State_t,Feedback_t)$

这意味着 Feedback 不是运行时的终点。

它是：

下一轮运行的起点。

36.14 行为运行时的状态机

Behavior Runtime 可以表示为：

Created
   ↓
Initialized
   ↓
Ready
   ↓
Running
   ↓
Action Processing
   ↓
Feedback Processing
   ↓
State Update
   ↓
Next Action
   ↺

如果完成：

Running
   ↓
Goal Achieved
   ↓
Complete

如果失败：

Running
   ↓
Failure
   ↓
Recovery / Re-Evaluation

如果无法恢复：

Failure
   ↓
Terminate

36.15 行为运行时不是线性流程

传统程序经常表现为：

A
↓
B
↓
C
↓
D

而 ICAI Behavior Runtime 是：

State
 ↓
Method
 ↓
Behavior
 ↓
Action
 ↓
Feedback
 ↓
State
 ↺

因为每次 Feedback 都可能改变下一步。

例如：

Action A
   ↓
Success
   ↓
Action B

或者：

Action A
   ↓
Failure
   ↓
Method Re-Evaluation
   ↓
Action B

或者：

Action A
   ↓
Unexpected Event
   ↓
State Update
   ↓
Behavior Adjustment
   ↓
Action C

所以：

Behavior Runtime 是条件驱动、状态驱动和反馈驱动的循环过程。

36.16 行为运行时的时间性

Runtime 最大的特点之一是时间。

t0
 ↓
State0
 ↓
Action0
 ↓
Feedback0
 ↓
t1
 ↓
State1
 ↓
Action1
 ↓
Feedback1
 ↓
t2

因此：

$BehaviorRuntime={State(t),Method(t),Behavior(t),Action(t),Feedback(t)}BehaviorRuntime = \{State(t),Method(t),Behavior(t),Action(t),Feedback(t)\}$

它不是一个静态对象，而是一个时间序列。

36.17 当前动作与下一动作

Runtime 必须维护：

Current Action
Next Action

例如：

Behavior State = Grasp

Current Action
= Close Gripper

Expected Result
= Object Controlled

执行之后：

Feedback
= Grasp Success

于是：

Next Action
= Lift

但如果：

Feedback
= Grasp Failure

则：

Next Action
≠ Lift

可能进入：

Retry
Recovery
Re-Grasp
Method Re-Evaluation

因此 Next Action 由 Runtime 状态动态决定。

36.18 行为运行时中的条件判断

每个 Action 执行之前，都需要判断当前条件。

Current State
      ↓
Condition Check
      ↓
Constraint Check
      ↓
Risk Check
      ↓
Action

如果条件满足：

Condition Valid
      ↓
Execute Action

如果条件失效：

Condition Invalid
      ↓
Action Blocked
      ↓
Method / Behavior Update

因此 Runtime 不是无条件执行。

36.19 行为运行时与动态行为

第33章定义：

Dynamic Behavior

第36章则说明：

Dynamic Behavior 如何真正运行。

两者关系：

Dynamic Behavior
       ↓
Behavior Runtime
       ↓
Current State
       ↓
Current Action
       ↓
Feedback
       ↓
Behavior Update

因此：

Dynamic Behavior = 行为变化机制
Behavior Runtime = 行为持续运行机制

一个描述：

行为如何改变。

另一个描述：

行为如何持续运行并产生改变。

36.20 运行时中的行为调整

当 Feedback 表明当前行为仍然可以完成目标，但参数需要变化：

Feedback
   ↓
Parameter Update
   ↓
Action Update
   ↓
Continue Behavior

例如：

Move
Velocity = 1.0

反馈：

Obstacle Detected

于是：

Velocity = 0.6
Direction = D'

行为没有结束：

Behavior Instance B1
        ↓
Continue

只是 Action 参数发生变化。

36.21 运行时中的方法切换

如果 Feedback 表明：

当前 Method 已经无法继续实现目标。

则：

Feedback
   ↓
State Update
   ↓
Method Re-Evaluation
   ↓
Method Selection
   ↓
New Method Instance
   ↓
Behavior Continue

因此 Runtime 可以从：

Method A

切换到：

Method B

而不一定结束整个 Behavior。

这就是：

方法层面的动态恢复。

36.22 运行时中的行为终止

Behavior Runtime 最终可能进入：

Complete

完成条件可能是：

Goal Achieved
Target State Reached
Expected Result Achieved

例如：

Current Position = P2
Goal Position = P2

于是：

Goal Achieved
   ↓
Behavior Complete

36.23 运行时中的失败

如果 Action 无法产生预期结果：

Action
   ↓
Execution
   ↓
Failure
   ↓
Feedback

Runtime 必须进一步判断：

Can Continue?
Can Adjust?
Can Recover?
Need New Method?
Need New Behavior?
Terminate?

形成：

Failure
   ↓
Failure Analysis
   ↓
State Update
   ↓
Recovery Decision
   ├── Retry
   ├── Adjust Action
   ├── Change Method
   ├── Change Behavior
   └── Terminate

因此 Failure 也是 Runtime 的一种输入，而不是单纯的终点。

36.24 行为运行时与认知循环

Behavior Runtime 并不是孤立系统。

它与 Cognitive System 形成循环：

Cognition
   ↓
Goal
   ↓
Capability
   ↓
Method
   ↓
Behavior Runtime
   ↓
Action
   ↓
Execution
   ↓
Feedback
   ↓
Cognitive Update
   ↓
Re-Cognition
   ↺

所以：

Behavior Runtime 是 Cognition 与 World 之间的动态执行桥梁。

36.25 行为运行时与世界状态

完整世界交互：

WORLD STATE
    ↓
Perception
    ↓
Cognitive State
    ↓
Behavior Runtime
    ↓
Action
    ↓
Execution
    ↓
WORLD STATE CHANGE
    ↓
Perception
    ↺

因此 Runtime 的真正意义不是：

让程序循环。

而是：

让人工个体持续根据世界状态变化产生新的行为动作，并通过现实反馈重新形成下一时刻状态。

36.26 Behavior Runtime 数据结构

可以建立：

BehaviorRuntime
│
├── Runtime Identity
├── Behavior Instance
├── Method Instance
├── Current State
├── Previous State
├── Goal
├── Current Behavior State
├── Current Action Instance
├── Next Action
├── Parameters
├── Conditions
├── Constraints
├── Risk
├── Execution Context
├── Feedback
├── Result
├── History
└── Runtime Status

Runtime Status 可以包括：

Idle
Initializing
Running
Waiting
Paused
Recovering
Completed
Failed
Terminated

36.27 行为运行时的核心状态转移

可以进一步形式化：

$St→Mt→Bt→At→Ft→St+1S_t \rightarrow M_t \rightarrow B_t \rightarrow A_t \rightarrow F_t \rightarrow S_{t+1}$

其中：

$StS_t$ ：当前状态
$MtM_t$ ：当前方法
$BtB_t$ ：当前行为
$AtA_t$ ：当前动作
$FtF_t$ ：执行反馈
$St+1S_{t+1}$ ：更新后的状态

因此：

$St+1=F(St,Mt,Bt,At,Feedbackt)S_{t+1} = F(S_t,M_t,B_t,A_t,Feedback_t)$

这就是行为运行时的基本动态模型。

36.28 行为运行时的完整结构

综合本章：

                  Behavior Runtime
                         │
                         ↓
                    Current State
                         │
                         ↓
                       Goal
                         │
                         ↓
                       Method
                         │
                         ↓
                  Method Instance
                         │
                         ↓
                      Behavior
                         │
                         ↓
                 Behavior Instance
                         │
                         ↓
                  Behavior State
                         │
                         ↓
                       Action
                         │
                         ↓
                  Action Instance
                         │
                         ↓
                     Execution
                         │
                         ↓
                    Actual Result
                         │
                         ↓
                      Feedback
                         │
                         ↓
                    State Update
                         │
                         └──────────────→ Runtime Loop

36.29 行为运行时的核心闭环

最终可以将本章压缩为：

        ┌──────────────┐
        │    State     │
        └──────┬───────┘
               ↓
        ┌──────────────┐
        │    Method    │
        └──────┬───────┘
               ↓
        ┌──────────────┐
        │   Behavior   │
        └──────┬───────┘
               ↓
        ┌──────────────┐
        │    Action    │
        └──────┬───────┘
               ↓
        ┌──────────────┐
        │  Execution   │
        └──────┬───────┘
               ↓
        ┌──────────────┐
        │   Feedback   │
        └──────┬───────┘
               ↓
        ┌──────────────┐
        │ State Update │
        └──────┬───────┘
               │
               └──────────────→ State

这就是 ICAI 的 Behavior Runtime Loop。

36.30 本章核心结论

第36章定义了行为运行时。

其核心不是简单地把 Behavior “运行起来”，而是建立：

状态驱动、方法组织、行为展开、动作执行、反馈更新的连续动态闭环。

核心关系：

State
↓
Method
↓
Behavior
↓
Action
↓
Execution
↓
Feedback
↓
State Update
↺

其中：

State
→ 决定当前运行条件

Method
→ 决定如何处理当前目标

Behavior
→ 组织整个行为过程

Action
→ 产生具体动作

Execution
→ 让动作实际发生

Feedback
→ 把现实结果返回系统

State Update
→ 产生下一轮运行状态

因此：

Behavior Runtime 是 ICAI 将“方法—行为—动作”从静态结构转化为时间连续运行过程的核心机制。

从系统层次看：

Cognition
   ↓
Capability
   ↓
Method
   ↓
Method Instance
   ↓
Behavior
   ↓
Behavior Instance
   ↓
Behavior Runtime
   ↓
Action
   ↓
Action Instance
   ↓
Execution
   ↓
Feedback
   ↓
Re-Cognition

至此，ICAI 已经完成了从：

认知
→ 能力
→ 方法
→ 行为
→ 动作

到：

认知
→ 能力
→ 方法实例
→ 行为实例
→ 行为运行时
→ 动作实例
→ 执行
→ 反馈
→ 再认知

的完整连接。

第34章解决“Action 是什么”；第35章解决“Behavior 和 Action 如何实例化”；第36章解决“实例化后的行为如何持续运行”。

因此下一层自然进入：

Behavior Runtime
        ↓
Action
        ↓
Action Execution
        ↓
Execution State
        ↓
Action Feedback
        ↓
Action Result

也就是从行为运行时正式进入动作执行运行时。

第36章 行为运行时

第36章 行为运行时

36.1 什么是行为运行时

Definition

Instance

Runtime

36.2 行为运行时的核心循环

36.3 State：运行时的起点

36.4 State 不是静态数据

36.5 Method：运行时的处理规则

36.6 Method 在运行时并非永远固定

36.7 Behavior：运行时的过程结构

36.8 Behavior Runtime 与 Behavior Instance

36.9 Action：运行时的具体动作

36.10 Action 不是一次性静态命令

36.11 Feedback：运行时的闭环

36.12 Feedback 的内容

36.13 Feedback → State Update

36.14 行为运行时的状态机

36.15 行为运行时不是线性流程

36.16 行为运行时的时间性

36.17 当前动作与下一动作

36.18 行为运行时中的条件判断

36.19 行为运行时与动态行为

36.20 运行时中的行为调整

36.21 运行时中的方法切换

36.22 运行时中的行为终止

36.23 运行时中的失败

36.24 行为运行时与认知循环

36.25 行为运行时与世界状态

36.26 Behavior Runtime 数据结构

36.27 行为运行时的核心状态转移

36.28 行为运行时的完整结构

36.29 行为运行时的核心闭环

36.30 本章核心结论