refactor(officefile): 按 md/latex/word 三层结构重组文档目录
将 Markdown 源文件移入 md/，LaTeX 工作目录保留在 latex/， Word 导出移入 word/；删除临时脚本、调试截图和空 stub。 Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,634 @@
|
||||
# 03.1 工作流编排原理
|
||||
|
||||
## 核心问题
|
||||
|
||||
> 如何设计复杂的多步骤分析流程？
|
||||
> DAG（有向无环图）如何表达工作流？
|
||||
> 如何处理工作流中的条件分支和错误？
|
||||
|
||||
---
|
||||
|
||||
## 概念讲解
|
||||
|
||||
### 工作流编排的核心
|
||||
|
||||
工作流编排是指**协调多个处理步骤按顺序执行**的能力：
|
||||
|
||||
```
|
||||
简单顺序 复杂编排
|
||||
│ │
|
||||
↓ ↓
|
||||
┌─────┐ ┌─────┐ ┌─────┐ ╔═════════════════╗
|
||||
│Step1│───→│Step2│───→│Step3│ ║ 条件分支 ║
|
||||
└─────┘ └─────┘ └─────┘ ║ ║
|
||||
║ ┌─────┐ ║
|
||||
一维流程 ║ │ │ ║
|
||||
║ ↓ ↓ ║
|
||||
║ Yes No ║
|
||||
║ │ │ ║
|
||||
║ ↓ ↓ ║
|
||||
║┌─────┐ ┌─────┐ ║
|
||||
║│StepA│ │StepB│ ║
|
||||
║└─────┘ └─────┘ ║
|
||||
║ │ ║
|
||||
║ └────┬─── ║
|
||||
║ │ ║
|
||||
╔═════════════════╝
|
||||
```
|
||||
|
||||
### DAG：有向无环图
|
||||
|
||||
**DAG** (Directed Acyclic Graph) 是工作流编排的基础数据结构：
|
||||
|
||||
```python
|
||||
"""
|
||||
DAG的数学表示
|
||||
|
||||
DAG = (V, E)
|
||||
其中：
|
||||
- V: 节点集合（处理步骤）
|
||||
- E: 边集合（依赖关系）
|
||||
- 条件：无环（没有节点能通过边回到自己）
|
||||
|
||||
性质：
|
||||
1. 有方向：边从上游指向下游
|
||||
2. 无环：没有循环依赖
|
||||
3. 可拓扑排序：可以找到线性执行顺序
|
||||
"""
|
||||
```
|
||||
|
||||
**为什么DAG适合工作流？**
|
||||
|
||||
| 特性 | 说明 |
|
||||
|-----|------|
|
||||
| **明确依赖** | 边定义了步骤间的依赖关系 |
|
||||
| **可并行化** | 无依赖的步骤可并行执行 |
|
||||
| **可验证** | 可以检测循环依赖 |
|
||||
| **可可视化** | 容易理解和调试 |
|
||||
|
||||
### 工作流的组成要素
|
||||
|
||||
```
|
||||
工作流 = 节点 + 边 + 条件 + 错误处理
|
||||
|
||||
┌─────────────────────────────────────────────────────────────┐
|
||||
│ │
|
||||
│ ┌──────────────┐ │
|
||||
│ │ 节点 │ ←───────────────────────────────────── │
|
||||
│ │ ────────── │ │
|
||||
│ │ - 执行函数 │ 输入 → 处理 → 输出 │
|
||||
│ │ - 输入/输出 │ │
|
||||
│ │ - 副后置 │ before(), execute(), after() │
|
||||
│ └──────────────┘ │
|
||||
│ │ │
|
||||
│ ↓ │
|
||||
│ ┌──────────────┐ │
|
||||
│ │ 边 │ ←───────────────────────────────────── │
|
||||
│ │ ────────── │ │
|
||||
│ │ - 数据流 │ 上游输出 → 下游输入 │
|
||||
│ │ - 依赖关系 │ 顺序执行 │
|
||||
│ │ - 条件路由 │ 基于状态选择路径 │
|
||||
│ └──────────────┘ │
|
||||
│ │ │
|
||||
│ ↓ │
|
||||
│ ┌──────────────┐ │
|
||||
│ │ 条件分支 │ ←───────────────────────────────────── │
|
||||
│ │ ────────── │ │
|
||||
│ │ - 分支条件 │ if state.value > threshold: ... │
|
||||
│ │ - 路由选择 │ switch-case模式 │
|
||||
│ │ - 合并点 │ 多路径汇聚 │
|
||||
│ └──────────────┘ │
|
||||
│ │ │
|
||||
│ ↓ │
|
||||
│ ┌──────────────┐ │
|
||||
│ │ 错误处理 │ ←───────────────────────────────────── │
|
||||
│ │ ────────── │ │
|
||||
│ │ - 重试 │ 失败后重新执行 │
|
||||
│ │ - 回滚 │ 恢复到之前状态 │
|
||||
│ │ - 降级 │ 使用备选方案 │
|
||||
│ │ - 告警 │ 通知相关人员 │
|
||||
│ └──────────────┘ │
|
||||
│ │
|
||||
└─────────────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 设计原理
|
||||
|
||||
### 工作流设计模式
|
||||
|
||||
**1. 线性流水线 (Linear Pipeline)**
|
||||
|
||||
```python
|
||||
class LinearWorkflow:
|
||||
"""最简单的工作流：顺序执行"""
|
||||
|
||||
def __init__(self):
|
||||
self.steps = []
|
||||
|
||||
def add_step(self, func, name=None):
|
||||
"""添加步骤"""
|
||||
self.steps.append({
|
||||
'function': func,
|
||||
'name': name or func.__name__
|
||||
})
|
||||
return self
|
||||
|
||||
def execute(self, initial_data):
|
||||
"""执行工作流"""
|
||||
result = initial_data
|
||||
|
||||
for step in self.steps:
|
||||
print(f"执行: {step['name']}")
|
||||
result = step['function'](result)
|
||||
|
||||
return result
|
||||
|
||||
# 使用示例
|
||||
workflow = LinearWorkflow()
|
||||
workflow.add_step(load_data, "加载数据")
|
||||
workflow.add_step(clean_data, "清理数据")
|
||||
workflow.add_step(analyze_data, "分析数据")
|
||||
|
||||
result = workflow.execute("data.geojson")
|
||||
```
|
||||
|
||||
**2. 条件分支工作流 (Conditional Workflow)**
|
||||
|
||||
```python
|
||||
class ConditionalWorkflow:
|
||||
"""带条件分支的工作流"""
|
||||
|
||||
def __init__(self):
|
||||
self.steps = {}
|
||||
self.conditions = {}
|
||||
self.transitions = {}
|
||||
|
||||
def add_step(self, name, func):
|
||||
"""添加步骤"""
|
||||
self.steps[name] = func
|
||||
return self
|
||||
|
||||
def add_condition(self, name, condition_func):
|
||||
"""添加条件判断"""
|
||||
self.conditions[name] = condition_func
|
||||
return self
|
||||
|
||||
def add_transition(self, from_step, condition, to_step):
|
||||
"""添加状态转换"""
|
||||
if from_step not in self.transitions:
|
||||
self.transitions[from_step] = {}
|
||||
self.transitions[from_step][condition] = to_step
|
||||
return self
|
||||
|
||||
def execute(self, initial_data, start_step='start'):
|
||||
"""执行工作流"""
|
||||
current_step = start_step
|
||||
state = {'data': initial_data}
|
||||
|
||||
while current_step != 'end':
|
||||
print(f"当前步骤: {current_step}")
|
||||
|
||||
# 执行步骤
|
||||
if current_step in self.steps:
|
||||
result = self.steps[current_step](state['data'])
|
||||
state['data'] = result
|
||||
|
||||
# 检查条件
|
||||
if current_step in self.transitions:
|
||||
transition = self.transitions[current_step]
|
||||
matched = False
|
||||
|
||||
for condition_name, next_step in transition.items():
|
||||
if condition_name in self.conditions:
|
||||
if self.conditions[condition_name](state):
|
||||
current_step = next_step
|
||||
matched = True
|
||||
break
|
||||
|
||||
if not matched and 'default' in transition:
|
||||
current_step = transition['default']
|
||||
elif not matched:
|
||||
current_step = 'end'
|
||||
else:
|
||||
current_step = 'end'
|
||||
|
||||
return state['data']
|
||||
|
||||
# 使用示例：生态网络工作流
|
||||
workflow = ConditionalWorkflow()
|
||||
|
||||
# 添加步骤
|
||||
workflow.add_step('load_data', load_data)
|
||||
workflow.add_step('identify_sources', identify_sources)
|
||||
workflow.add_step('human_review', human_review)
|
||||
workflow.add_step('build_resistance', build_resistance)
|
||||
|
||||
# 添加条件
|
||||
workflow.add_condition('high_uncertainty',
|
||||
lambda s: s.get('uncertainty', 0) > 0.3)
|
||||
workflow.add_condition('approved',
|
||||
lambda s: s.get('decision') == 'approve')
|
||||
|
||||
# 添加转换
|
||||
workflow.add_transition('identify_sources', 'high_uncertainty', 'human_review')
|
||||
workflow.add_transition('identify_sources', 'default', 'build_resistance')
|
||||
workflow.add_transition('human_review', 'approved', 'build_resistance')
|
||||
workflow.add_transition('human_review', 'default', 'identify_sources') # 重做
|
||||
workflow.add_transition('build_resistance', 'default', 'end')
|
||||
```
|
||||
|
||||
**3. 并行工作流 (Parallel Workflow)**
|
||||
|
||||
```python
|
||||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||||
|
||||
class ParallelWorkflow:
|
||||
"""支持并行执行的工作流"""
|
||||
|
||||
def __init__(self, max_workers=4):
|
||||
self.max_workers = max_workers
|
||||
self.parallel_groups = {}
|
||||
|
||||
def add_parallel_group(self, group_name, tasks):
|
||||
"""添加可并行执行的任务组"""
|
||||
self.parallel_groups[group_name] = tasks
|
||||
return self
|
||||
|
||||
def execute_group(self, group_name, shared_data):
|
||||
"""执行一个并行任务组"""
|
||||
if group_name not in self.parallel_groups:
|
||||
raise ValueError(f"未知的任务组: {group_name}")
|
||||
|
||||
tasks = self.parallel_groups[group_name]
|
||||
results = {}
|
||||
|
||||
with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
|
||||
# 提交所有任务
|
||||
future_to_task = {
|
||||
executor.submit(task['func'], shared_data): task['name']
|
||||
for task in tasks
|
||||
}
|
||||
|
||||
# 收集结果
|
||||
for future in as_completed(future_to_task):
|
||||
task_name = future_to_task[future]
|
||||
try:
|
||||
results[task_name] = future.result()
|
||||
except Exception as e:
|
||||
results[task_name] = {'error': str(e)}
|
||||
|
||||
return results
|
||||
|
||||
# 使用示例：同时处理多个区域
|
||||
workflow = ParallelWorkflow(max_workers=4)
|
||||
|
||||
workflow.add_parallel_group('process_regions', [
|
||||
{'name': 'region_north', 'func': process_north_region},
|
||||
{'name': 'region_south', 'func': process_south_region},
|
||||
{'name': 'region_east', 'func': process_east_region},
|
||||
{'name': 'region_west', 'func': process_west_region},
|
||||
])
|
||||
|
||||
results = workflow.execute_group('process_regions', shared_data)
|
||||
```
|
||||
|
||||
### 错误处理模式
|
||||
|
||||
```python
|
||||
class WorkflowErrorHandling:
|
||||
"""工作流错误处理"""
|
||||
|
||||
class RetryPolicy:
|
||||
"""重试策略"""
|
||||
def __init__(self, max_retries=3, backoff=2.0):
|
||||
self.max_retries = max_retries
|
||||
self.backoff = backoff # 指数退避因子
|
||||
|
||||
def should_retry(self, attempt, error):
|
||||
return attempt < self.max_retries
|
||||
|
||||
def get_delay(self, attempt):
|
||||
return self.backoff ** attempt
|
||||
|
||||
def execute_with_retry(self, func, *args, retry_policy=None, **kwargs):
|
||||
"""带重试的执行"""
|
||||
if retry_policy is None:
|
||||
retry_policy = self.RetryPolicy()
|
||||
|
||||
last_error = None
|
||||
for attempt in range(retry_policy.max_retries + 1):
|
||||
try:
|
||||
return func(*args, **kwargs)
|
||||
except Exception as e:
|
||||
last_error = e
|
||||
if retry_policy.should_retry(attempt, e):
|
||||
delay = retry_policy.get_delay(attempt)
|
||||
print(f"尝试 {attempt + 1} 失败，{delay}秒后重试...")
|
||||
time.sleep(delay)
|
||||
else:
|
||||
break
|
||||
|
||||
raise last_error
|
||||
|
||||
def execute_with_fallback(self, primary_func, fallback_func, *args, **kwargs):
|
||||
"""带降级的执行"""
|
||||
try:
|
||||
return primary_func(*args, **kwargs)
|
||||
except Exception as e:
|
||||
print(f"主函数失败: {e}，使用降级方案")
|
||||
return fallback_func(*args, **kwargs)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 代码示例
|
||||
|
||||
### 生态网络六阶段工作流
|
||||
|
||||
```python
|
||||
"""
|
||||
ENAgent的完整工作流编排实现
|
||||
|
||||
六阶段：
|
||||
1. 数据准备
|
||||
2. 源地识别
|
||||
3. 阻力面构建
|
||||
4. MCR分析
|
||||
5. 廊道提取
|
||||
6. 结果评估
|
||||
"""
|
||||
import time
|
||||
from typing import Dict, List, Optional, Callable
|
||||
from enum import Enum
|
||||
from dataclasses import dataclass
|
||||
|
||||
class Stage(Enum):
|
||||
"""工作流阶段"""
|
||||
DATA_PREPARATION = "data_preparation"
|
||||
SOURCE_IDENTIFICATION = "source_identification"
|
||||
RESISTANCE_SURFACE = "resistance_surface"
|
||||
MCR_ANALYSIS = "mcr_analysis"
|
||||
CORRIDOR_EXTRACTION = "corridor_extraction"
|
||||
RESULT_EVALUATION = "result_evaluation"
|
||||
COMPLETED = "completed"
|
||||
ERROR = "error"
|
||||
|
||||
@dataclass
|
||||
class WorkflowState:
|
||||
"""工作流状态"""
|
||||
current_stage: Stage
|
||||
data: Dict
|
||||
results: Dict
|
||||
errors: List[str]
|
||||
stage_history: List[Stage]
|
||||
checkpoint_data: Optional[Dict] = None
|
||||
|
||||
class EcologicalNetworkWorkflow:
|
||||
"""生态网络分析工作流"""
|
||||
|
||||
def __init__(self):
|
||||
self.stages = {
|
||||
Stage.DATA_PREPARATION: self._data_preparation,
|
||||
Stage.SOURCE_IDENTIFICATION: self._source_identification,
|
||||
Stage.RESISTANCE_SURFACE: self._resistance_surface,
|
||||
Stage.MCR_ANALYSIS: self._mcr_analysis,
|
||||
Stage.CORRIDOR_EXTRACTION: self._corridor_extraction,
|
||||
Stage.RESULT_EVALUATION: self._result_evaluation,
|
||||
}
|
||||
|
||||
self.transitions = {
|
||||
Stage.DATA_PREPARATION: Stage.SOURCE_IDENTIFICATION,
|
||||
Stage.SOURCE_IDENTIFICATION: Stage.RESISTANCE_SURFACE,
|
||||
Stage.RESISTANCE_SURFACE: Stage.MCR_ANALYSIS,
|
||||
Stage.MCR_ANALYSIS: Stage.CORRIDOR_EXTRACTION,
|
||||
Stage.CORRIDOR_EXTRACTION: Stage.RESULT_EVALUATION,
|
||||
Stage.RESULT_EVALUATION: Stage.COMPLETED,
|
||||
}
|
||||
|
||||
# HITL审查点
|
||||
self.checkpoints = {
|
||||
Stage.SOURCE_IDENTIFICATION: True,
|
||||
Stage.RESISTANCE_SURFACE: True,
|
||||
Stage.CORRIDOR_EXTRACTION: False,
|
||||
}
|
||||
|
||||
def execute(self, initial_data: Dict) -> WorkflowState:
|
||||
"""执行完整工作流"""
|
||||
state = WorkflowState(
|
||||
current_stage=Stage.DATA_PREPARATION,
|
||||
data=initial_data,
|
||||
results={},
|
||||
errors=[],
|
||||
stage_history=[Stage.DATA_PREPARATION]
|
||||
)
|
||||
|
||||
while state.current_stage != Stage.COMPLETED:
|
||||
if state.current_stage == Stage.ERROR:
|
||||
print("工作流因错误终止")
|
||||
break
|
||||
|
||||
# 执行当前阶段
|
||||
state = self._execute_stage(state)
|
||||
|
||||
# 检查是否需要审查
|
||||
if self.checkpoints.get(state.current_stage, False):
|
||||
state = self._handle_checkpoint(state)
|
||||
|
||||
# 转换到下一阶段
|
||||
if state.current_stage != Stage.ERROR:
|
||||
next_stage = self.transitions.get(
|
||||
state.current_stage,
|
||||
Stage.COMPLETED
|
||||
)
|
||||
state.current_stage = next_stage
|
||||
state.stage_history.append(next_stage)
|
||||
|
||||
return state
|
||||
|
||||
def _execute_stage(self, state: WorkflowState) -> WorkflowState:
|
||||
"""执行单个阶段"""
|
||||
stage = state.current_stage
|
||||
print(f"\n{'='*50}")
|
||||
print(f"执行阶段: {stage.value}")
|
||||
print('='*50)
|
||||
|
||||
try:
|
||||
# 执行阶段函数
|
||||
result = self.stages[stage](state.data, state.results)
|
||||
|
||||
# 保存结果
|
||||
state.results[stage.value] = result
|
||||
|
||||
except Exception as e:
|
||||
print(f"阶段 {stage.value} 执行失败: {e}")
|
||||
state.errors.append(str(e))
|
||||
state.current_stage = Stage.ERROR
|
||||
|
||||
return state
|
||||
|
||||
def _handle_checkpoint(self, state: WorkflowState) -> WorkflowState:
|
||||
"""处理HITL审查点"""
|
||||
stage = state.current_stage
|
||||
print(f"\n[审查点: {stage.value}]")
|
||||
|
||||
# 实际实现中，这里会等待人类输入
|
||||
# 模拟审查通过
|
||||
approval = self._get_human_approval(state)
|
||||
|
||||
if not approval:
|
||||
print("审查未通过，调整参数后重新执行...")
|
||||
# 可以在这里修改state.data后返回同一阶段
|
||||
|
||||
return state
|
||||
|
||||
def _get_human_approval(self, state: WorkflowState) -> bool:
|
||||
"""获取人类批准（模拟）"""
|
||||
print(f"待审查结果: {list(state.results.keys())}")
|
||||
# 实际实现中等待输入
|
||||
return True
|
||||
|
||||
# === 阶段实现 ===
|
||||
|
||||
def _data_preparation(self, data: Dict, results: Dict) -> Dict:
|
||||
"""阶段1：数据准备"""
|
||||
print("加载和处理原始数据...")
|
||||
time.sleep(0.5)
|
||||
return {
|
||||
'landcover': 'loaded',
|
||||
'elevation': 'loaded',
|
||||
'boundary': 'loaded'
|
||||
}
|
||||
|
||||
def _source_identification(self, data: Dict, results: Dict) -> Dict:
|
||||
"""阶段2：源地识别"""
|
||||
print("识别生态源地...")
|
||||
sources = [
|
||||
{'id': 1, 'area': 1500, 'type': 'forest'},
|
||||
{'id': 2, 'area': 800, 'type': 'wetland'}
|
||||
]
|
||||
return {'sources': sources, 'n_sources': len(sources)}
|
||||
|
||||
def _resistance_surface(self, data: Dict, results: Dict) -> Dict:
|
||||
"""阶段3：阻力面构建"""
|
||||
print("构建生态阻力面...")
|
||||
return {
|
||||
'resistance_surface': 'computed',
|
||||
'weights': {'forest': 1, 'urban': 100}
|
||||
}
|
||||
|
||||
def _mcr_analysis(self, data: Dict, results: Dict) -> Dict:
|
||||
"""阶段4：MCR分析"""
|
||||
print("执行最小累积阻力分析...")
|
||||
return {'mcr_surface': 'computed'}
|
||||
|
||||
def _corridor_extraction(self, data: Dict, results: Dict) -> Dict:
|
||||
"""阶段5：廊道提取"""
|
||||
print("提取生态廊道...")
|
||||
corridors = [
|
||||
{'from': 1, 'to': 2, 'length': 3500}
|
||||
]
|
||||
return {'corridors': corridors, 'n_corridors': len(corridors)}
|
||||
|
||||
def _result_evaluation(self, data: Dict, results: Dict) -> Dict:
|
||||
"""阶段6：结果评估"""
|
||||
print("评估分析结果...")
|
||||
return {
|
||||
'connectivity_index': 0.75,
|
||||
'network_efficiency': 0.82
|
||||
}
|
||||
|
||||
# 使用示例
|
||||
if __name__ == "__main__":
|
||||
print("=== 生态网络分析工作流 ===\n")
|
||||
|
||||
workflow = EcologicalNetworkWorkflow()
|
||||
|
||||
initial_data = {
|
||||
'landcover_path': 'data/landcover.tif',
|
||||
'species': 'target_species',
|
||||
'parameters': {}
|
||||
}
|
||||
|
||||
final_state = workflow.execute(initial_data)
|
||||
|
||||
print("\n=== 工作流完成 ===")
|
||||
print(f"执行的阶段数: {len(final_state.stage_history)}")
|
||||
print(f"产生的错误: {final_state.errors}")
|
||||
print(f"最终结果: {list(final_state.results.keys())}")
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 案例分析
|
||||
|
||||
### LangGraph的工作流实现
|
||||
|
||||
```python
|
||||
from langgraph.graph import StateGraph, END
|
||||
from typing import TypedDict
|
||||
|
||||
class ENAgentState(TypedDict):
|
||||
"""ENAgent工作流状态"""
|
||||
stage: str
|
||||
data: dict
|
||||
results: dict
|
||||
requires_review: bool
|
||||
|
||||
def build_enagent_workflow():
|
||||
"""构建ENAgent工作流"""
|
||||
|
||||
# 创建图
|
||||
workflow = StateGraph(ENAgentState)
|
||||
|
||||
# 添加节点
|
||||
workflow.add_node("prepare_data", prepare_data_node)
|
||||
workflow.add_node("identify_sources", identify_sources_node)
|
||||
workflow.add_node("build_resistance", build_resistance_node)
|
||||
workflow.add_node("mcr_analysis", mcr_analysis_node)
|
||||
workflow.add_node("extract_corridors", extract_corridors_node)
|
||||
workflow.add_node("evaluate_results", evaluate_results_node)
|
||||
|
||||
# 添加边（线性流程）
|
||||
workflow.set_entry_point("prepare_data")
|
||||
workflow.add_edge("prepare_data", "identify_sources")
|
||||
workflow.add_edge("identify_sources", "build_resistance")
|
||||
workflow.add_edge("build_resistance", "mcr_analysis")
|
||||
workflow.add_edge("mcr_analysis", "extract_corridors")
|
||||
workflow.add_edge("extract_corridors", "evaluate_results")
|
||||
workflow.add_edge("evaluate_results", END)
|
||||
|
||||
# 编译
|
||||
return workflow.compile()
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 反思与延伸
|
||||
|
||||
### 思考问题
|
||||
|
||||
1. **工作流设计**：你的项目中有哪些可以自动化的步骤？
|
||||
|
||||
2. **错误处理**：当某个步骤失败时，应该重试、跳过还是终止？
|
||||
|
||||
3. **审查点**：在你的工作流中，哪些地方需要人类介入？
|
||||
|
||||
4. **并行化**：哪些步骤可以并行执行以提升效率？
|
||||
|
||||
### 延伸阅读
|
||||
|
||||
- **"Dataflow Programming"** - 数据流编程范式
|
||||
- **"Workflow Patterns"** (Van der Aalst) - 工作流模式
|
||||
- **Apache Airflow 文档** - 工作流调度系统
|
||||
|
||||
---
|
||||
|
||||
## 关键要点
|
||||
|
||||
1. **DAG是工作流的核心数据结构**，表达依赖关系
|
||||
2. **节点**是处理步骤，**边**定义执行顺序
|
||||
3. **条件分支**根据状态动态选择执行路径
|
||||
4. **错误处理**是生产工作流的关键
|
||||
5. **并行执行**可以显著提升效率
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,95 @@
|
||||
# 第四部分：自主设计
|
||||
|
||||
## 本部分目标
|
||||
|
||||
理解自主系统的设计模式和工作流编排：
|
||||
- 工作流编排的原理与模式
|
||||
- Agent的设计范式
|
||||
- 技能组合与复用的方法
|
||||
- 记忆与上下文管理
|
||||
- 规划与执行机制
|
||||
|
||||
---
|
||||
|
||||
## 章节导航
|
||||
|
||||
| 章节 | 文件 | 核心内容 | 实践 |
|
||||
|-----|------|---------|------|
|
||||
| 03.1 | [工作流编排原理](./03.1-workflow-orchestration.md) | DAG、节点与边、条件分支、错误处理 | 生态网络六阶段工作流 |
|
||||
| 03.2 | [Agent设计模式](./03.2-agent-design-patterns.md) | Reflex、Model-based、Goal-based、Utility-based | 对比四种Agent类型 |
|
||||
| 03.3 | [技能组合与复用](./03.3-skill-composition.md) | 技能抽象、接口设计、组合模式 | QGIS技能集成管理器 |
|
||||
| 03.4 | [记忆与上下文](./03.4-memory-and-context.md) | 短期/长期记忆、状态持久化、检索 | 专家知识积累系统 |
|
||||
| 03.5 | [规划与执行](./03.5-planning-and-execution.md) | 前向/后向搜索、分层规划、重规划 | RL训练工作流 |
|
||||
|
||||
---
|
||||
|
||||
## 核心概念图
|
||||
|
||||
```
|
||||
┌─────────────────────────────────────────────────────────────┐
|
||||
│ 自主设计体系 │
|
||||
├─────────────────────────────────────────────────────────────┤
|
||||
│ │
|
||||
│ ┌─────────────┐ │
|
||||
│ │ 目标设定 │ │
|
||||
│ └──────┬──────┘ │
|
||||
│ │ │
|
||||
│ ↓ │
|
||||
│ ┌────────────────────────┐ │
|
||||
│ │ 工作流编排 │ │
|
||||
│ │ (DAG + 状态机) │ │
|
||||
│ └────────────┬───────────┘ │
|
||||
│ │ │
|
||||
│ ┌────────────────┼────────────────┐ │
|
||||
│ ↓ ↓ ↓ │
|
||||
│ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │
|
||||
│ │ Agent设计 │ │ 技能组合 │ │ 记忆管理 │ │
|
||||
│ │ - 反应式 │ │ - 抽象接口 │ │ - 短期记忆 │ │
|
||||
│ │ - 基于模型 │ │ - 组合模式 │ │ - 长期记忆 │ │
|
||||
│ │ - 基于目标 │ │ - 技能发现 │ │ - 检索机制 │ │
|
||||
│ │ - 基于效用 │ │ - 动态加载 │ │ - 知识库 │ │
|
||||
│ └───────┬───────┘ └───────┬───────┘ └───────┬───────┘ │
|
||||
│ │ │ │ │
|
||||
│ └─────────────────┼─────────────────┘ │
|
||||
│ │ │
|
||||
│ ↓ │
|
||||
│ ┌──────────────────┐ │
|
||||
│ │ 规划与执行 │ │
|
||||
│ │ - 搜索算法 │ │
|
||||
│ │ - 任务分解 │ │
|
||||
│ │ - 执行监控 │ │
|
||||
│ │ - 动态重规划 │ │
|
||||
│ └──────────────────┘ │
|
||||
│ │
|
||||
└─────────────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 实践案例
|
||||
|
||||
### 实践案例04：设计一个自主空间分析Agent
|
||||
|
||||
详见 [practice/autonomous-agent](./practice/autonomous-agent/)
|
||||
|
||||
### 实践案例05：实现Human-in-the-Loop审查机制
|
||||
|
||||
详见 [practice/hitl-implementation](./practice/hitl-implementation/)
|
||||
|
||||
---
|
||||
|
||||
## 关键要点预览
|
||||
|
||||
1. **工作流编排**基于DAG和状态机，是复杂系统的核心
|
||||
2. **Agent设计**有四种经典模式，各有适用场景
|
||||
3. **技能组合**通过抽象接口实现复用和动态加载
|
||||
4. **记忆管理**区分短期和长期，支持检索和知识积累
|
||||
5. **规划与执行**需要平衡前瞻性和实时响应
|
||||
|
||||
---
|
||||
|
||||
## 延伸资源
|
||||
|
||||
- **"Artificial Intelligence: A Modern Approach"** (Russell & Norvig) - AI设计理论
|
||||
- **"Multi-Agent Systems"** (Wooldridge) - 多Agent系统
|
||||
- **LangGraph文档** - 实际工作流编排框架
|
||||
Reference in New Issue
Block a user