一、实际应用场景描述（基于心理健康与创新能力视角）

在心理健康与创新能力研究中，"迭代思维（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解决实际问题，如果你觉得这个工具好用，欢迎关注长安牧笛！