AI PRO·Loop Day 2 设计你的第一个Loop

从零开始构建一个文本改进Loop · 实战入门

---

引言：动手实践

在上一篇中，我们了解了Loop Engineering的核心概念。现在，让我们动手设计一个真实的Loop。

目标：设计一个文本改进Loop，让AI自动改进一篇文章，直到质量达标。

学习收获：

• 理解Loop的四个核心组件
• 掌握Loop的设计方法
• 学会评估Loop的效果

---

场景定义

1 任务描述

输入：一篇初稿文章

输出：一篇改进后的文章

目标：自动改进文章质量，直到达到标准

2 改进维度

维度	说明	权重

|——|——|——|

清晰度	表达是否清楚	30%
完整性	内容是否完整	25%
逻辑性	结构是否合理	25%
可读性	是否易于阅读	20%

3 终止条件

• 质量分数 ≥ 8分（满分10分）
• 或达到最大迭代次数（5次）

---

Loop架构设计

1 整体架构

`

┌─────────────────────────────────────────────┐

│ TextImprover │

│ │

│ ┌──────────┐ ┌──────────┐ │

│ │ Executor │───→│Evaluator │ │

│ │ 执行器 │ │ 评估器 │ │

│ └──────────┘ └──────────┘ │

│ ↑ │ │

│ │ ↓ │

│ ┌──────────┐ ┌──────────┐ │

│ │Improver │←───│ Feedback │ │

│ │ 改进器 │ │ 反馈器 │ │

│ └──────────┘ └──────────┘ │

│ │

└─────────────────────────────────────────────┘

`

2 四个核心组件

组件	职责	输入	输出

|——|——|——|——|

Executor	执行改进	文章 + 改进建议	改进后的文章
Evaluator	评估质量	文章	质量分数 + 问题列表
Feedback	生成反馈	评估结果	改进建议
Improver	整合改进	当前状态	下一步策略

---

代码实现

1 基础框架

`python

from dataclasses import dataclass

from typing import List, Dict, Optional

import json

@dataclass

class EvaluationResult:

“””评估结果”””

score: float # 总分（0-10）

dimensions: Dict[str, float] # 各维度分数

issues: List[str] # 问题列表

suggestions: List[str] # 建议列表

@dataclass

class IterationState:

“””迭代状态”””

iteration: int # 当前迭代次数

article: str # 当前文章

evaluation: Optional[EvaluationResult] # 评估结果

history: List[Dict] # 历史记录

`

2 执行器（Executor）

`python

class Executor:

“””执行器：负责改进文章”””

def __init__(self, llm):

self.llm = llm

def execute(self, article: str, suggestions: List[str]) -> str:

“””执行改进”””

# 构建提示词

prompt = f”””

请根据以下建议改进文章：

## 原文

{article}

## 改进建议

{chr(10).join(f’- {s}’ for s in suggestions)}

## 要求

1. 保持原文的核心观点

2. 按照建议进行改进

3. 确保改进后文章流畅自然

## 输出

请直接输出改进后的文章，不要添加任何说明。

“””

# 调用LLM

improved_article = self.llm.generate(prompt)

return improved_article

`

3 评估器（Evaluator）

`python

class Evaluator:

“””评估器：负责评估文章质量”””

def __init__(self, llm):

self.llm = llm

def evaluate(self, article: str) -> EvaluationResult:

“””评估文章质量”””

# 构建提示词

prompt = f”””

请评估以下文章的质量：

## 文章

{article}

## 评估维度

1. 清晰度（30%）：表达是否清楚易懂

2. 完整性（25%）：内容是否完整全面

3. 逻辑性（25%）：结构是否合理有序

4. 可读性（20%）：是否易于阅读理解

## 输出格式

请按以下JSON格式输出：

{{

“dimensions”: {{

“clarity”: ,

“completeness”: ,

“logic”: ,

“readability”:

}},

“issues”: [“问题1”, “问题2”, …],

“suggestions”: [“建议1”, “建议2”, …]

}}

分数范围：0-10，保留一位小数。

“””

# 调用LLM

response = self.llm.generate(prompt)

# 解析结果

result = json.loads(response)

# 计算总分

weights = {

“clarity”: 0.3,

“completeness”: 0.25,

“logic”: 0.25,

“readability”: 0.2

}

total_score = sum(

result[“dimensions”][dim] * weight

for dim, weight in weights.items()

)

return EvaluationResult(

score=total_score,

dimensions=result[“dimensions”],

issues=result[“issues”],

suggestions=result[“suggestions”]

)

`

4 反馈器（Feedback）

`python

class Feedback:

“””反馈器：负责生成改进建议”””

def __init__(self, llm):

self.llm = llm

def generate_feedback(self, evaluation: EvaluationResult,

iteration: int) -> List[str]:

“””生成改进建议”””

# 构建提示词

prompt = f”””

根据以下评估结果，生成具体的改进建议：

## 评估结果

• 总分：{evaluation.score}/10
• 各维度分数：
• 清晰度：{evaluation.dimensions.get(‘clarity’, 0)}/10
• 完整性：{evaluation.dimensions.get(‘completeness’, 0)}/10
• 逻辑性：{evaluation.dimensions.get(‘logic’, 0)}/10
• 可读性：{evaluation.dimensions.get(‘readability’, 0)}/10

## 发现的问题

{chr(10).join(f’- {issue}’ for issue in evaluation.issues)}

## 迭代次数

当前是第{iteration}次迭代

## 要求

1. 优先改进分数最低的维度

2. 每个建议要具体可执行

3. 不超过5条建议

## 输出格式

请直接输出改进建议列表，每条建议一行，以”- “开头。

“””

# 调用LLM

response = self.llm.generate(prompt)

# 解析建议

suggestions = [

line.strip().lstrip(“- “)

for line in response.split(“n”)

if line.strip().startswith(“-“)

]

return suggestions

`

5 主循环（Main Loop）

`python

class TextImprover:

“””文本改进器：主循环”””

def __init__(self, llm, max_iterations=5, target_score=8.0):

self.llm = llm

self.max_iterations = max_iterations

self.target_score = target_score

# 初始化组件

self.executor = Executor(llm)

self.evaluator = Evaluator(llm)

self.feedback = Feedback(llm)

def improve(self, article: str) -> Dict:

“””改进文章”””

state = IterationState(

iteration=0,

article=article,

evaluation=None,

history=[]

)

for i in range(self.max_iterations):

state.iteration = i + 1

print(f”n{‘=’*50}”)

print(f”迭代 {state.iteration}/{self.max_iterations}”)

print(f”{‘=’*50}”)

# 1. 评估当前文章

print(“n📊 评估中…”)

evaluation = self.evaluator.evaluate(state.article)

state.evaluation = evaluation

print(f” 总分：{evaluation.score:.1f}/10″)

print(f” 清晰度：{evaluation.dimensions.get(‘clarity’, 0):.1f}”)

print(f” 完整性：{evaluation.dimensions.get(‘completeness’, 0):.1f}”)

print(f” 逻辑性：{evaluation.dimensions.get(‘logic’, 0):.1f}”)

print(f” 可读性：{evaluation.dimensions.get(‘readability’, 0):.1f}”)

# 2. 检查是否达标

if evaluation.score >= self.target_score:

print(f”n✅ 达标！总分 {evaluation.score:.1f} >= {self.target_score}”)

break

# 3. 生成反馈

print(“n💡 生成改进建议…”)

suggestions = self.feedback.generate_feedback(

evaluation, state.iteration

)

print(” 建议：”)

for j, suggestion in enumerate(suggestions, 1):

print(f” {j}. {suggestion}”)

# 4. 执行改进

print(“n✏️ 执行改进…”)

improved_article = self.executor.execute(

state.article, suggestions

)

# 5. 记录历史

state.history.append({

“iteration”: state.iteration,

“score”: evaluation.score,

“issues”: evaluation.issues,

“suggestions”: suggestions

})

# 6. 更新状态

state.article = improved_article

# 如果达到最大迭代次数

if state.iteration == self.max_iterations:

print(f”n⚠️ 达到最大迭代次数 {self.max_iterations}”)

return {

“final_article”: state.article,

“final_score”: state.evaluation.score,

“iterations”: state.iteration,

“history”: state.history

}

`

---

完整示例

1 测试代码

`python

# 示例LLM（实际使用时替换为真实的LLM）

class MockLLM:

def generate(self, prompt):

# 这里返回模拟响应

# 实际使用时调用OpenAI、Anthropic等API

return “模拟响应”

# 创建改进器

llm = MockLLM()

improver = TextImprover(llm, max_iterations=3, target_score=8.0)

# 初始文章

initial_article = “””

Python是一种编程语言。它很简单。很多人都用它。

Python可以做很多事。比如写网站、做数据分析。

学Python很有用。

“””

# 执行改进

result = improver.improve(initial_article)

# 输出结果

print(“n” + “=”*50)

print(“最终结果”)

print(“=”*50)

print(f”迭代次数：{result[‘iterations’]}”)

print(f”最终分数：{result[‘final_score’]:.1f}/10″)

print(f”n最终文章：n{result[‘final_article’]}”)

`

2 执行过程示例

`

==================================================

迭代 1/3

==================================================

📊 评估中…

总分：4.5/10

清晰度：5.0

完整性：4.0

逻辑性：4.5

可读性：4.5

💡 生成改进建议…

建议：

1. 增加Python的具体特点说明

2. 补充Python的应用场景示例

3. 添加学习Python的建议

4. 改善段落结构，增加过渡句

5. 使用更专业的术语

✏️ 执行改进…

==================================================

迭代 2/3

==================================================

📊 评估中…

总分：6.8/10

清晰度：7.0

完整性：6.5

逻辑性：7.0

可读性：6.5

💡 生成改进建议…

建议：

1. 增加代码示例

2. 补充Python版本信息

3. 添加学习资源推荐

4. 优化标题和小节结构

✏️ 执行改进…

==================================================

迭代 3/3

==================================================

📊 评估中…

总分：8.2/10

清晰度：8.5

完整性：8.0

逻辑性：8.0

可读性：8.0

✅ 达标！总分 8.2 >= 8.0

==================================================

最终结果

==================================================

迭代次数：3

最终分数：8.2/10

`

---

优化策略

1 提示词优化

问题：LLM生成的建议不够具体

解决方案：

`python

prompt = f”””

根据以下评估结果，生成具体可执行的改进建议：

要求

1. 每条建议必须包含：

• 问题描述：哪里有问题
• 改进方法：具体怎么做
• 预期效果：改进后会怎样

1. 示例：

• 问题：第一段缺少引言
• 方法：添加一个引人入胜的开头
• 效果：吸引读者继续阅读

“””

`

2 评估优化

问题：评估结果不稳定

解决方案：

`python

def evaluate_with_retry(self, article: str, max_retries=3):

“””带重试的评估”””

for attempt in range(max_retries):

try:

result = self.evaluate(article)

# 验证结果格式

if self.validate_result(result):

return result

except Exception as e:

print(f”评估失败（尝试 {attempt+1}/{max_retries}）：{e}”)

# 返回默认结果

return EvaluationResult(

score=5.0,

dimensions={“clarity”: 5, “completeness”: 5, “logic”: 5, “readability”: 5},

issues=[“评估失败”],

suggestions=[“请人工检查”]

)

`

3 成本控制

问题：多次迭代消耗大量token

解决方案：

`python

class CostAwareTextImprover(TextImprover):

def __init__(self, *args, max_cost=1.0, **kwargs):

super().__init__(*args, **kwargs)

self.max_cost = max_cost

self.total_cost = 0

def track_cost(self, tokens_used):

“””追踪成本”””

cost = tokens_used * 0.00002 # 假设价格

self.total_cost += cost

if self.total_cost >= self.max_cost:

raise CostLimitExceeded(f”成本超限：{self.total_cost:.4f}”)

`

4 并行评估

问题：评估耗时长

解决方案：

`python

import asyncio

async def parallel_evaluate(self, articles: List[str]):

“””并行评估多篇文章”””

tasks = [

self.evaluator.evaluate_async(article)

for article in articles

]

results = await asyncio.gather(*tasks)

return results

`

---

进阶：带记忆的Loop

1 添加记忆组件

`python

class Memory:

“””记忆组件”””

def __init__(self):

self.short_term = {} # 短期记忆

self.long_term = [] # 长期记忆

def remember(self, key, value, persist=False):

“””存储记忆”””

self.short_term[key] = value

if persist:

self.long_term.append({

“key”: key,

“value”: value,

“timestamp”: time.time()

})

def recall(self, key):

“””检索记忆”””

if key in self.short_term:

return self.short_term[key]

# 搜索长期记忆

for item in reversed(self.long_term):

if item[“key”] == key:

return item[“value”]

return None

def get_similar(self, query, top_k=3):

“””获取相似记忆”””

# 这里可以使用向量搜索

pass

`

2 使用记忆的Loop

`python

class MemoryAwareTextImprover(TextImprover):

def __init__(self, *args, **kwargs):

super().__init__(*args, **kwargs)

self.memory = Memory()

def improve(self, article: str) -> Dict:

“””带记忆的改进”””

# 存储初始文章

self.memory.remember(“initial_article”, article)

# 执行改进

result = super().improve(article)

# 存储改进经验

self.memory.remember(

“improvement_experience”,

{

“iterations”: result[“iterations”],

“final_score”: result[“final_score”],

“history”: result[“history”]

},

persist=True

)

return result

def get_improvement_suggestions(self, evaluation):

“””基于历史经验生成建议”””

# 检索类似案例

similar_cases = self.memory.get_similar(

str(evaluation.dimensions), top_k=3

)

if similar_cases:

# 基于历史经验生成建议

return self.generate_suggestions_from_history(

evaluation, similar_cases

)

# 使用默认方法

return self.feedback.generate_feedback(evaluation, 0)

`

---

测试与验证

1 单元测试

`python

import unittest

class TestTextImprover(unittest.TestCase):

def setUp(self):

self.llm = MockLLM()

self.improver = TextImprover(self.llm, max_iterations=3)

def test_basic_improvement(self):

“””测试基本改进流程”””

article = “Python是一种编程语言。”

result = self.improver.improve(article)

self.assertIn(“final_article”, result)

self.assertIn(“final_score”, result)

self.assertGreater(result[“iterations”], 0)

def test_termination_condition(self):

“””测试终止条件”””

# 模拟高质量文章

high_quality_article = “””

Python是一种高级编程语言，由Guido van Rossum于1991年创建。

它的设计哲学强调代码的可读性和简洁性。

Python支持多种编程范式，包括面向对象、命令式、函数式和过程式编程。

“””

result = self.improver.improve(high_quality_article)

# 应该很快达标

self.assertLessEqual(result[“iterations”], 2)

def test_max_iterations(self):

“””测试最大迭代次数”””

# 模拟难以改进的文章

bad_article = “a” * 100 # 无意义内容

result = self.improver.improve(bad_article)

# 应该达到最大迭代次数

self.assertEqual(result[“iterations”], 3)

`

2 集成测试

`python

class TestIntegration(unittest.TestCase):

def test_with_real_llm(self):

“””使用真实LLM测试”””

# 跳过如果没有API密钥

if not os.getenv(“OPENAI_API_KEY”):

self.skipTest(“需要OpenAI API密钥”)

from langchain.llms import OpenAI

llm = OpenAI()

improver = TextImprover(llm, max_iterations=2)

article = “””

机器学习是人工智能的一个分支。

它让计算机能从数据中学习。

“””

result = improver.improve(article)

# 验证结果

self.assertGreater(result[“final_score”], 5.0)

self.assertLess(result[“iterations”], 3)

`

---

实际应用场景

1 代码改进Loop

`python

class CodeImprover:

“””代码改进器”””

def improve_code(self, code, requirements):

“””改进代码”””

for attempt in range(self.max_attempts):

# 执行代码

result = self.run_code(code)

# 检查是否有错误

if result.has_errors:

# 分析错误

error_analysis = self.analyze_error(result.error)

# 修复代码

code = self.fix_code(code, error_analysis)

continue

# 运行测试

test_results = self.run_tests(code)

# 检查测试是否通过

if test_results.all_passed:

return code

# 分析失败的测试

failure_analysis = self.analyze_failures(test_results.failures)

# 改进代码

code = self.improve_based_on_failures(code, failure_analysis)

return code

`

2 文章写作Loop

`python

class ArticleWriter:

“””文章写作器”””

def write_article(self, topic, requirements):

“””写文章”””

# 1. 生成大纲

outline = self.generate_outline(topic, requirements)

# 2. 写初稿

draft = self.write_draft(outline)

# 3. 改进Loop

improved = self.improve_article(draft, requirements)

# 4. 最终审查

final = self.final_review(improved)

return final

`

3 数据分析Loop

`python

class DataAnalyzer:

“””数据分析器”””

def analyze_data(self, data, questions):

“””分析数据”””

results = []

for question in questions:

# 1. 生成分析代码

code = self.generate_analysis_code(question, data)

# 2. 执行代码

result = self.execute_code(code)

# 3. 验证结果

if self.validate_result(result, question):

results.append(result)

else:

# 4. 改进代码

improved_code = self.improve_code(code, result)

result = self.execute_code(improved_code)

results.append(result)

return results

`

---

最佳实践

1 设计原则

1. 明确终止条件：避免无限循环
2. 控制成本：设置token和时间上限
3. 保持可追溯：记录每轮执行
4. 渐进式改进：每次只改一个问题
5. 人机协作：关键决策需要人类确认

2 常见陷阱

1. ❌ 没有终止条件：循环永远不停
2. ❌ 评估不准确：改进方向错误
3. ❌ 反馈太笼统：AI不知道怎么改
4. ❌ 忽略成本：token消耗过大
5. ❌ 缺少监控：不知道发生了什么

3 调试技巧

1. 查看历史记录：了解每轮做了什么
2. 分析评估结果：检查评估是否准确
3. 检查改进建议：建议是否具体可执行
4. 监控成本：避免超支
5. 设置断点：在关键步骤暂停

---

下一讲预告

下一讲：《AI PRO·Loop Day 3：反馈循环设计》

我们将深入讲解：

• 反馈循环的核心模式
• 如何设计有效的反馈
• 反馈的粒度和时机
• 实际案例分析

---

参考资料

官方文档

• Anthropic: Building Effective Agents
• LangChain: LangGraph

中文资料

• 知乎: Loop Engineering入门
• CSDN: Loop Engineering实战

开源项目

• LangGraph
• AutoGen

---

💡 一句话总结：Loop Engineering的核心是设计一个能自我迭代的系统，让AI自动改进直到达标。