# 00.3 自主设计的含义

## 核心问题

> "自动"和"自主"有什么本质区别？
> 在设计工作中，AI应该扮演什么角色？工具还是伙伴？
> Human-in-the-Loop不是落后，而是高级的设计哲学？

---

## 概念讲解

### 自动 vs 自主

这两个词经常被混用，但在AI系统设计中有重要区别：

```
┌─────────────────────────────────────────────────────────────┐
│                      自动化(Automation)                      │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   设定 → [固定脚本] → 执行 → 结果                            │
│      ↑                           ↓                          │
│   预定义规则                  完全确定                      │
│                                                             │
│   特点：                                                    │
│   - 按预定规则执行                                          │
│   - 遇到异常停止                                            │
│   - 重复性任务                                              │
│   - 人类设定后不再介入                                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│                      自主化(Autonomy)                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   目标 → [智能体] → 观察 → 决策 → 行动 → 反馈               │
│      ↑       ↑                    ↑      ↓                  │
│   高层意图  持续学习         适应调整  环境变化              │
│                                                             │
│   特点：                                                    │
│   - 追求目标而非执行步骤                                    │
│   - 能处理意外情况                                          │
│   - 从经验中学习                                            │
│   - 在约束下自主决策                                        │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 理解的层级

自主系统的智能程度可以分层：

```
Level 0: 无智能 (No Intelligence)
    └── 简单机械，完全由外部控制

Level 1: 反应式智能 (Reactive Intelligence)
    └── 基于当前状态直接反应，无记忆
        例如：恒温器、简单的自动门

Level 2: 基于规则的智能 (Rule-based Intelligence)
    └── 遵循预定义规则，有分支逻辑
        例如：专家系统、决策树

Level 3: 学习型智能 (Learning Intelligence)
    └── 能从数据中学习，改进性能
        例如：机器学习模型

Level 4: 自主智能 (Autonomous Intelligence)
    └── 设定目标，规划执行，处理意外
        例如：自动驾驶、智能体系统

Level 5: 协作智能 (Collaborative Intelligence)
    └── 与人类协同，理解意图和上下文
        例如：设计伙伴AI
```

### 设计智能的演进

从CAD工具到AI设计伙伴的演进：

```
1980s: CAD时代
    └── 数字化绘图，提高效率
        设计师 → [绘图工具] → 图纸

2000s: 参数化设计时代
    └── 规则驱动，生成变体
        设计师 → [参数+规则] → [生成器] → 多方案

2010s: 优化时代
    └── 目标驱动，搜索最优解
        设计师 → [目标函数] → [优化算法] → 最优方案

2020s: AI生成时代
    └── 意图驱动，智能生成
        设计师 → [意图描述] → [AI模型] → 设计方案

未来: 协作设计时代
    └── 人机协同，共同创造
        设计师 ⇄ [AI伙伴] ⇄ 设计结果
              共享理解
```

---

## 设计原理

### Human-in-the-Loop (HITL) 的设计哲学

HITL不是"半自动"的妥协，而是深思熟虑的设计选择。

**为什么需要HITL？**

1. **空间问题的复杂性**
   - 多目标权衡（生态 vs 经济 vs 社会）
   - 隐性知识无法完全编码
   - 价值判断需要人类

2. **责任归属**
   - 重大决策不能完全交给机器
   - 设计师需要对结果负责
   - 伦理考量需要人类判断

3. **信任建立**
   - 逐步建立对AI的信任
   - 可解释性增强信任
   - 控制感增强接受度

**HITL的三种模式**：

```python
# 模式1: 决策前审查 (Pre-decision Review)
def hitl_pre_review(agent_decision, human_expert):
    """
    人类在AI决策前审查
    """
    proposal = agent.generate_proposal()
    approval = human_expert.review(proposal)

    if approval:
        return agent.execute(proposal)
    else:
        feedback = human_expert.provide_feedback()
        return agent.regenerate(feedback)

# 模式2: 关键点介入 (Checkpoint Intervention)
def hitl_checkpoint(workflow, checkpoints):
    """
    在关键决策点人类介入
    """
    for step in workflow:
        result = step.execute()

        if step.name in checkpoints:
            # 只在关键点需要人类确认
            if not human.confirm(result):
                result = human.modify(result)

    return result

# 模式3: 异常处理 (Exception Handling)
def hitl_exception(agent, task):
    """
    AI正常运行，异常时人类介入
    """
    try:
        return agent.execute(task)
    except UncertainSituation as e:
        # AI遇到不确定情况，请求人类帮助
        return human.resolve(e)
```

### ENAgent的三个审查点

ENAgent项目的HITL设计：

```
┌────────────────────────────────────────────────────────────┐
│                   ENAgent 工作流程                          │
├────────────────────────────────────────────────────────────┤
│                                                            │
│  1. 数据准备                                                │
│     └── 自动化执行                                          │
│                                                            │
│  2. 生态源地识别  ──→ [审查点1] ──→ 确认/调整源地           │
│     (AI识别)        (人类专家)        (最终决策)           │
│                                                            │
│  3. 阻力面构建    ──→ [审查点2] ──→ 确认/调整权重           │
│     (AI建议)        (人类专家)        (最终参数)           │
│                                                            │
│  4. MCR分析                                                 │
│     └── 自动化执行                                          │
│                                                            │
│  5. 廊道提取      ──→ [审查点3] ──→ 确认/优化廊道           │
│     (AI识别)        (人类专家)        (最终方案)           │
│                                                            │
│  6. 结果评估                                                │
│     └── AI + 人类共同评估                                   │
│                                                            │
└────────────────────────────────────────────────────────────┘
```

**为什么选择这三个点？**

| 审查点 | 原因 | 人类贡献 |
|-------|------|---------|
| 源地识别 | 需要本地知识，遥感可能误判 | 地面实况，专家经验 |
| 阻力权重 | 价值判断，物种特性不同 | 生态学知识，实地经验 |
| 廊道优化 | 多目标权衡，不能完全量化 | 规划要求，社会因素 |

---

## 代码示例

### HITL工作流示意

```python
from typing import Callable, Optional
from dataclasses import dataclass
from enum import Enum

class ReviewDecision(Enum):
    APPROVE = "approve"
    MODIFY = "modify"
    REJECT = "reject"

@dataclass
class ReviewResult:
    decision: ReviewDecision
    feedback: Optional[str] = None
    modifications: Optional[dict] = None

class HumanReviewer:
    """
    人类审查者的抽象接口
    实际实现可以是CLI界面、Web界面等
    """

    def review(self, proposal: dict, context: str) -> ReviewResult:
        """
        审查AI的提案

        Args:
            proposal: AI生成的提案
            context: 审查上下文信息

        Returns:
            审查决定
        """
        print(f"\n=== 审查点: {context} ===")
        print(f"AI提案: {proposal}")

        # 实际实现中，这里会显示GUI或调用外部接口
        decision = input("决策 (approve/modify/reject): ")

        if decision == "approve":
            return ReviewDecision.APPROVE
        elif decision == "modify":
            feedback = input("修改意见: ")
            return ReviewDecision(ReviewDecision.MODIFY, feedback=feedback)
        else:
            return ReviewDecision(ReviewDecision.REJECT)

class HITLWorkflow:
    """
    带人类审查的自主工作流
    """

    def __init__(self, reviewer: HumanReviewer):
        self.reviewer = reviewer
        self.checkpoints = []

    def add_checkpoint(self, name: str, condition: Callable = None):
        """
        添加审查点

        Args:
            name: 审查点名称
            condition: 触发审查的条件函数
        """
        self.checkpoints.append({
            'name': name,
            'condition': condition or (lambda _: True)
        })

    def run(self, steps: list) -> dict:
        """
        执行工作流，在审查点进行人类介入

        Args:
            steps: 工作流步骤列表

        Returns:
            最终结果
        """
        context = {}

        for i, step in enumerate(steps):
            # 执行步骤
            step_name = step.get('name', f'step_{i}')
            step_func = step['execute']

            print(f"\n执行步骤: {step_name}")
            result = step_func(context)
            context[step_name] = result

            # 检查是否需要审查
            for checkpoint in self.checkpoints:
                if checkpoint['name'] == step_name:
                    if checkpoint['condition'](context):
                        review_result = self.reviewer.review(
                            result, step_name
                        )

                        if review_result.decision == ReviewDecision.REJECT:
                            # 拒绝，重新执行
                            print("提案被拒绝，重新执行...")
                            return self.run(steps)

                        elif review_result.decision == ReviewDecision.MODIFY:
                            # 修改，更新上下文
                            print(f"应用修改: {review_result.feedback}")
                            context[step_name] = self._apply_modifications(
                                result, review_result.modifications
                            )

                        # APPROVE: 继续执行

        return context

    def _apply_modifications(self, original: dict, modifications: dict) -> dict:
        """应用人类修改"""
        if modifications:
            original.update(modifications)
        return original

# 使用示例：生态网络分析的HITL工作流
if __name__ == "__main__":
    # 创建审查者
    reviewer = HumanReviewer()

    # 创建工作流
    workflow = HITLWorkflow(reviewer)

    # 添加审查点
    workflow.add_checkpoint('identify_sources')
    workflow.add_checkpoint('build_resistance')
    workflow.add_checkpoint('extract_corridors')

    # 定义工作流步骤
    def step_load_data(context):
        return {'data_loaded': True}

    def step_identify_sources(context):
        # 模拟AI识别源地
        return {
            'sources': [
                {'id': 1, 'area': 1500, 'type': 'forest'},
                {'id': 2, 'area': 800, 'type': 'wetland'}
            ],
            'confidence': 0.85
        }

    def step_build_resistance(context):
        # 模拟AI构建阻力面
        return {
            'weights': {
                'forest': 1,
                'grassland': 10,
                'urban': 100,
                'water': 50
            }
        }

    def step_extract_corridors(context):
        # 模拟AI提取廊道
        return {
            'corridors': [
                {'from': 1, 'to': 2, 'length': 3500, 'quality': 'high'}
            ]
        }

    steps = [
        {'name': 'load_data', 'execute': step_load_data},
        {'name': 'identify_sources', 'execute': step_identify_sources},
        {'name': 'build_resistance', 'execute': step_build_resistance},
        {'name': 'extract_corridors', 'execute': step_extract_corridors},
    ]

    # 执行工作流
    result = workflow.run(steps)
    print("\n=== 工作流完成 ===")
    print(result)
```

---

## 反思与延伸

### 思考问题

1. **角色定位**：在你自己的工作中，你希望AI扮演什么角色？工具、助手还是伙伴？

2. **审查点设计**：如果要为你熟悉的工作流程设计HITL，你会选择哪些审查点？为什么？

3. **信任边界**：在什么情况下你会完全信任AI的决策？在什么情况下必须人类介入？

4. **责任归属**：如果HITL系统做出了错误决策导致损失，责任应该如何划分？

### 延伸阅读

- **"Human-in-the-Loop Machine Learning"** - HITL的系统论述
- **"Human-Centered AI"** (Ben Shneiderman) - 以人为本的AI设计
- **"Designing Autonomous Agents"** - 自主智能体设计理论

---

## 关键要点

1. **自动 ≠ 自主**：自动执行预定义步骤，自主追求目标并适应环境
2. **智能有层级**：从反应式到协作式，逐级递进
3. **HITL不是妥协**：而是深思熟虑的设计选择，在复杂、重要的决策中必不可少
4. **审查点选择是关键**：选择需要人类独特能力的决策点
5. **从工具到伙伴**：AI在设计中角色的演进，目标是协作而非替代
