一、实际应用场景描述（基于心理健康与创新能力视角）
在心理健康与创新能力研究中，"迭代思维（Iterative Thinking）" 和 "孵化效应（Incubation Effect）" 被认为是创造性问题解决的核心机制。
一个典型的创新场景：
你在设计一个新功能、写一篇文章、或优化一个算法。
第一版出来了，但不够好。
你有两个选择：
1. 扔掉重来
2. 在现有基础上逐步改进
传统数据筛选程序（如 ETL 管道、数据清洗脚本、特征选择工具）几乎一致地选择 方案 1：
- 只保留"最优"结果
- 丢弃"次优"的中间产物
- 以最终指标（accuracy、F1、loss）为唯一筛选标准
这在工程优化场景中合理，但在创新探索场景中存在根本性盲区：
- 中间结果往往包含被当前评价函数低估的潜在价值
- 丢弃它们等于切断了迭代进化的可能性
- 创作者失去了对"过程"的感知，只剩"结果焦虑"
本程序的目标是颠覆这一逻辑：
✅ 不只要最优结果
✅ 系统性留存中等质量的中间数据
✅ 在新问题语境下，复用旧方案碎片生成新方案
二、引入痛点（中立、去情绪化）
1. 传统筛选程序的隐含假设
隐含假设 在创新场景中的问题
最优 = 全部 忽视了局部最优中的可用结构
中间产物 = 垃圾 切断了迭代进化的路径
指标可完全量化 创新价值常存在于"不可量化"部分
2. 创新能力视角的结构性问题
- 沉没成本谬误（Sunk Cost Fallacy）的反面效应人们倾向于认为"既然不够好，就该丢掉"，实际上中等质量方案是宝贵的"认知半成品"。
- 评估函数单一化同一组数据，换一个评估维度（用户满意度 vs 技术复杂度），"次优"可能变成"最优"。
- 过程失忆（Process Amnesia）丢弃中间结果导致每次都从零开始，无法形成积累式创新。
3. 心理层面的代价
- 创作者陷入"要么完美要么重来"的二元思维
- 中间尝试得不到正反馈，降低探索意愿
- 长期只关注终点，削弱对过程的觉察（与正念理念相悖）
三、核心逻辑讲解（心理模型 → 工程模型）
1️⃣ 核心心理模型：双过程理论（Dual-Process Theory）
创造力研究普遍认同：
发散思维（Divergent） 生成选项
收敛思维（Convergent） 筛选选项
传统程序只做第二步。本程序把两步都纳入，并在收敛阶段保留"候选项"。
2️⃣ 工程化抽象
每个方案被记录为一个"迭代节点"：
IterationNode:
- id: 唯一标识
- generation: 第几代
- parent_id: 父节点（追溯来源）
- score: 综合评分
- features: 方案特征向量
- is_kept: 是否被保留
- discarded_by: 被哪版筛选规则淘汰（如保留则空）
程序核心行为：
1. 生成阶段：产生一批候选方案（允许质量参差不齐）
2. 评估阶段：打分，但不删除低于阈值的方案
3. 归档阶段：中等质量方案进入"候选手库（Candidate Pool）"
4. 迭代阶段：新问题到来时，从候选手库中召回相关碎片，组合生成新方案
3️⃣ 核心筛选公式（保留而非淘汰）
def should_keep(score, threshold_low, threshold_high):
if score >= threshold_high:
return "primary" # 主选方案
elif score >= threshold_low:
return "candidate" # 候补方案（保留）
else:
return "discard" # 真正丢弃（极少）
关键设计理念：
默认只丢弃最差的 10%~20%，其余全部保留，留给未来自己。
四、代码模块化实现（Python）
项目结构
iterative_keeper/
├── README.md
├── requirements.txt
├── config.yaml
├── main.py
├── core/
│ ├── generator.py # 方案生成器
│ ├── evaluator.py # 多维评估引擎
│ ├── keeper.py # 留存与召回机制
│ └── mutator.py # 基于旧碎片生成新方案
└── utils/
├── logger.py
└── id_utils.py
requirements.txt
pyyaml>=6.0
rich>=13.0.0
numpy>=1.24.0
config.yaml
iteration:
candidate_pool_ratio: 0.3 # 中间方案保留比例
min_keep_ratio: 0.8 # 至少保留 80% 的方案
discard_threshold_percentile: 10 # 只丢弃最差的 10%
evaluation:
weights:
quality: 0.4
novelty: 0.3
feasibility: 0.3
core/generator.py
"""
方案生成器模块
模拟产生一批候选方案（在真实场景中可替换为模型/算法输出）
"""
import random
from typing import List, Dict, Any
from utils.id_utils import generate_id
from utils.logger import setup_logger
logger = setup_logger("Generator")
class Solution:
"""表示一个候选方案"""
def __init__(self, content: str, features: Dict[str, float]):
self.id = generate_id()
self.content = content
self.features = features
self.generation = 0
self.parent_id = None
def to_dict(self):
return {
"id": self.id,
"content": self.content,
"features": self.features,
"generation": self.generation,
"parent_id": self.parent_id
}
def generate_solutions(n: int = 10) -> List[Solution]:
"""生成 n 个模拟方案"""
solutions = []
for i in range(n):
s = Solution(
content=f"方案 {i+1}",
features={
"quality": random.uniform(0.3, 0.95),
"novelty": random.uniform(0.2, 0.9),
"feasibility": random.uniform(0.4, 0.85)
}
)
solutions.append(s)
logger.info(f"生成 {len(solutions)} 个候选方案")
return solutions
core/evaluator.py
"""
多维评估引擎
对方案进行多维度打分，而非单一指标筛选
"""
from typing import List, Dict, Any
from core.generator import Solution
from utils.logger import setup_logger
logger = setup_logger("Evaluator")
class Evaluator:
def __init__(self, weights: Dict[str, float]):
self.weights = weights
def score(self, solution: Solution) -> float:
"""加权综合评分"""
total = 0.0
for dim, w in self.weights.items():
total += solution.features.get(dim, 0.0) * w
return round(total, 4)
def evaluate_batch(self, solutions: List[Solution]) -> List[Dict[str, Any]]:
"""批量评估并返回结果列表"""
results = []
for s in solutions:
sc = self.score(s)
results.append({
**s.to_dict(),
"score": sc
})
# 按分数降序排列
results.sort(key=lambda x: x["score"], reverse=True)
return results
core/keeper.py
"""
留存与召回机制
核心模块：决定什么保留、什么丢弃、什么归档
"""
from typing import List, Dict, Any
from utils.logger import setup_logger
logger = setup_logger("Keeper")
class Keeper:
def __init__(
self,
min_keep_ratio: float = 0.8,
discard_percentile: int = 10
):
self.min_keep_ratio = min_keep_ratio
self.discard_percentile = discard_percentile
self.candidate_pool: List[Dict[str, Any]] = []
def filter(self, evaluated: List[Dict[str, Any]]) -> Dict[str, Any]:
"""
核心筛选逻辑：
- 前 (100 - discard_percentile)% 全部保留
- 其中最优的标记为主选（primary）
- 其余标记为准候补（candidate）
"""
n = len(evaluated)
keep_n = max(int(n * self.min_keep_ratio), 1)
discard_n = n - keep_n
# 前 keep_n 个保留（已经按分数降序排列）
kept = evaluated[:keep_n]
discarded = evaluated[keep_n:]
for item in kept:
item["is_primary"] = (item == kept[0])
item["status"] = "primary" if item["is_primary"] else "candidate"
if not item["is_primary"]:
self.candidate_pool.append(item)
report = {
"total": n,
"kept": len(kept),
"discarded": len(discarded),
"primary": kept[0] if kept else None,
"candidates": [k for k in kept if not k["is_primary"]],
"discarded_items": discarded
}
logger.info(
f"筛选完成: 保留 {report['kept']}/{n}, "
f"丢弃 {report['discarded']}/{n}"
)
return report
def recall(self, min_score: float = 0.0) -> List[Dict[str, Any]]:
"""从候补池中召回指定分数以上的方案"""
recalled = [c for c in self.candidate_pool if c["score"] >= min_score]
logger.info(f"召回 {len(recalled)} 个候补方案 (min_score={min_score})")
return recalled
core/mutator.py
"""
变异器模块
基于旧方案的碎片特征，组合生成新方案
模拟"跨界重组"式的创新过程
"""
import random
from typing import List, Dict, Any
from utils.id_utils import generate_id
from utils.logger import setup_logger
logger = setup_logger("Mutator")
def extract_features(solutions: List[Dict[str, Any]]) -> Dict[str, List[float]]:
"""提取各维度的特征值列表"""
dims = ["quality", "novelty", "feasibility"]
return {
d: [s["features"].get(d, 0.0) for s in solutions]
for d in dims
}
def mutate(solutions: List[Dict[str, Any]], n_new: int = 5) -> List[Dict[str, Any]]:
"""
从旧方案中抽样特征，重组为新方案
核心逻辑：每个新方案从不同旧方案中"借用"不同维度
"""
if not solutions:
return []
dims = ["quality", "novelty", "feasibility"]
new_solutions = []
for i in range(n_new):
# 随机选 3 个不同的父方案
parents = random.sample(solutions, min(3, len(solutions)))
# 每个维度从不同的父方案继承
new_features = {}
for j, dim in enumerate(dims):
parent = parents[j % len(parents)]
# 加入微小扰动模拟变异
inherited = parent["features"].get(dim, 0.5)
mutated = min(1.0, max(0.0, inherited + random.uniform(-0.1, 0.1)))
new_features[dim] = round(mutated, 4)
new_sol = {
"id": generate_id(),
"content": f"迭代方案 {i+1}（重组生成）",
"features": new_features,
"generation": max(s.get("generation", 0) for s in parents) + 1,
"parent_ids": [p["id"] for p in parents],
"score": 0.0 # 待评估
}
new_solutions.append(new_sol)
logger.info(f"生成 {len(new_solutions)} 个迭代方案")
return new_solutions
utils/id_utils.py
"""唯一 ID 生成工具"""
import uuid
def generate_id() -> str:
return str(uuid.uuid4())[:8]
utils/logger.py
from rich.logging import RichHandler
import logging
def setup_logger(name: str):
logger = logging.getLogger(name)
logger.setLevel(logging.INFO)
handler = RichHandler()
handler.setFormatter(logging.Formatter("%(message)s"))
logger.addHandler(handler)
return logger
main.py
"""
主程序入口
演示完整流程：生成 → 评估 → 筛选留存 → 迭代召回
"""
import yaml
from pathlib import Path
from core.generator import generate_solutions
from core.evaluator import Evaluator
from core.keeper import Keeper
from core.mutator import mutate
from utils.logger import setup_logger
from rich.console import Console
from rich.table import Table
logger = setup_logger("Main")
console = Console()
def load_config(path: str = "config.yaml"):
return yaml.safe_load(Path(path).read_text(encoding="utf-8"))
def display_report(report: dict):
console.print("\n[bold cyan]📊 筛选报告[/bold cyan]\n")
if report["primary"]:
p = report["primary"]
console.print(
f"[green]✅ 主选方案:[/green] {p['content']} "
f"(得分: {p['score']})"
)
table = Table(show_header=True, header_style="bold magenta")
table.add_column("方案", style="white")
table.add_column("得分", justify="center", style="cyan")
table.add_column("状态", justify="center", style="yellow")
for c in report["candidates"]:
table.add_row(c["content"], f"{c['score']:.4f}", c["status"])
console.print(table)
console.print(f"\n[dim]丢弃: {report['discarded']} 个（最差 {report['discarded']} 个）[/dim]\n")
def main():
config = load_config()
# Step 1: 生成候选方案
solutions = generate_solutions(n=10)
# Step 2: 多维评估
eval_cfg = config["evaluation"]
evaluator = Evaluator(weights=eval_cfg["weights"])
evaluated = evaluator.evaluate_batch(solutions)
# Step 3: 留存筛选
keep_cfg = config["iteration"]
keeper = Keeper(
min_keep_ratio=keep_cfg["min_keep_ratio"],
discard_percentile=keep_cfg["discard_threshold_percentile"]
)
report = keeper.filter(evaluated)
display_report(report)
# Step 4: 迭代 —— 从候补池召回并生成新方案
recalled = keeper.recall(min_score=0.0)
new_solutions = mutate(recalled, n_new=3)
# Step 5: 评估新方案
new_evaluated = evaluator.evaluate_batch(new_solutions)
console.print("[bold cyan]🧬 迭代生成的新方案:[/bold cyan]\n")
for s in new_evaluated:
console.print(
f" {s['content']} | 得分: {s['score']:.4f} | "
f"代际: {s['generation']}"
)
logger.info("迭代流程完成")
if __name__ == "__main__":
main()
五、README.md
# Iterative Keeper — 中间数据留存与迭代创新工具
## 是什么
一个基于心理健康与创新理论的 Python 工具，用于：
- 在方案筛选中保留中等质量的中间数据
- 基于旧方案碎片迭代生成新方案
- 把"丢弃"从默认行为变成"最后手段"
## 核心思想
> 不是"只保留最好的"，而是"让过去的尝试都有未来"。
## 安装
bash
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
## 使用
bash
python main.py
## 配置说明
yaml
iteration:
min_keep_ratio: 0.8 # 至少保留 80%
discard_threshold_percentile: 10 # 只丢弃最差 10%
evaluation:
weights:
quality: 0.4
novelty: 0.3
feasibility: 0.3
## 模块说明
| 模块 | 职责 |
|----|----|
| core/generator.py | 方案生成器 |
| core/evaluator.py | 多维评估引擎 |
| core/keeper.py | 留存与召回机制 |
| core/mutator.py | 基于旧碎片生成新方案 |
## 许可
MIT License
六、核心知识点卡片（去营销、中立）
┌─────────────────────────────────────────────┐
│ 知识点 #1：Incubation Effect（孵化效应） │
├─────────────────────────────────────────────┤
│ 未被立即使用的想法在潜意识中持续加工 │
│ 留存中间数据 = 为孵化提供"原材料" │
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│ 知识点 #2：Iterative Thinking（迭代思维） │
├─────────────────────────────────────────────┤
│ 创新不是一蹴而就，而是逐步逼近 │
│ 每个中间产物都是下一版的起点 │
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│ 知识点 #3：Sunk Cost Fallacy（沉没成本谬误） │
├─────────────────────────────────────────────┤
│ 其"反面"同样有害：认为不够好就该丢弃 │
│ 中等质量方案有结构性复用价值 │
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│ 知识点 #4：Multi-objective Evaluation │
├─────────────────────────────────────────────┤
│ 单一指标筛选会丢失维度信息 │
│ 多维加权评估保留方案的"侧面价值" │
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│ 知识点 #5：Recombination（组合创新） │
├─────────────────────────────────────────────┤
│ 创新 ≈ 已有要素的新组合 │
│ 变异器从多个父方案中抽样不同维度重组 │
└─────────────────────────────────────────────┘
七、总结（中立、工程视角）
传统筛选程序的核心假设是"最优解即终点"，这在确定性工程问题中成立，但在探索性创新任务中是一种认知 shortcuts。
本方案做了三件不同的事：
1. 翻转默认行为：从"默认丢弃"变为"默认留存，极少丢弃"
2. 多维评估：拒绝用单一指标概括方案价值
3. 迭代闭环：旧方案的碎片成为新方案的种子
从工程角度看，这是一个轻量级、规则驱动、可解释的系统；
从心理角度看，它帮助创作者建立对"过程"的信任，减少对"一步到位"的执念，更符合正念（Mindfulness）与成长型思维（Growth Mindset）的理念。
利用AI解决实际问题，如果你觉得这个工具好用，欢迎关注长安牧笛！
![[C++]内存管理：串顺序存储的内存回收](http://pic.xiahunao.cn/yaotu/[C++]内存管理：串顺序存储的内存回收)
