Claude Code

# =========================
# BOP-Elites（Python风格伪代码）
# 说明：这是“伪代码”，用于表达流程与关键计算，不保证可直接运行。
# =========================

def bop_elites(f, b_funcs, X_bounds, regions, N_max, n0, omega):
    """
    f: 黑盒目标函数，输入 x -> y（标量性能）
    b_funcs: 行为描述符函数列表 [b1(x), ..., bm(x)]；黑盒或白盒都可
    X_bounds: 搜索空间边界（盒约束）
    regions: 预先离散化好的描述符空间分区集合 R（每个 region 有各维 partition 的上下界）
    N_max: 总评估预算
    n0: 初始Sobol采样点数
    omega: 概率截断阈值（用于 EJIE+ 中忽略不太可能的区域）
    """
    # ---------- 初始化：Sobol采样得到初始数据集 D0 ----------
    X0 = sobol_sample(X_bounds, n0)  # 从 X 中Sobol采样 n0 个点
    D = []  # 数据集 D = [(x_i, y_i, b_i), ...]
    archive = init_archive(regions)  # MAP-Elites式档案：每个region存当前最优 elite（或空）

    for x in X0:
        y = f(x)                      # 评估目标函数
        b = eval_descriptors(b_funcs, x)  # 评估描述符向量 b(x) = [b1(x),...,bm(x)]
        D.append((x, y, b))

        r = region_of(b, regions)     # 用“真实描述符”决定所属region（初始化阶段直接用真值）
        update_elite_if_better(archive, r, x, y)  # 若更好则更新该region elite

    # ---------- 构建GP代理模型：目标 +（若描述符是黑盒）每个描述符维度 ----------
    gp_y = fit_gp([(x, y) for (x, y, b) in D])          # 目标 y 的GP
    gp_b = [fit_gp([(x, b[j]) for (x, y, b) in D]) for j in range(len(b_funcs))]  # 每一维描述符的GP

    n = len(D)

    # ---------- 主循环：BO式逐点选择 ----------
    while n < N_max:

        # 1) 生成候选集合 X_d（论文里是每次迭代在一批点上算EJIE并选最大者）
        X_d = sobol_sample(X_bounds, n_candidates())  # 伪：候选点数量可自定

        best_x = None
        best_acq = -float("inf")

        # 2) 对每个候选点计算 EJIE+(x)
        for x in X_d:
            acq = ejie_plus(x, gp_y, gp_b, archive, regions, omega)  # 核心采集函数
            if acq > best_acq:
                best_acq = acq
                best_x = x

        x_n = best_x

        # 3) 真实评估黑盒函数
        y_n = f(x_n)
        b_n = eval_descriptors(b_funcs, x_n)
        D.append((x_n, y_n, b_n))

        # 4) 用真实描述符确定所属region，并按MAP-Elites规则更新elite
        r_i = region_of(b_n, regions)
        update_elite_if_better(archive, r_i, x_n, y_n)

        # 5) 更新后验模型（增量或重训都行，这里写成重训伪代码）
        gp_y = fit_gp([(x, y) for (x, y, b) in D])
        gp_b = [fit_gp([(x, b[j]) for (x, y, b) in D]) for j in range(len(b_funcs))]

        n += 1

    # 返回：观测得到的精英档案（observed elites）
    return archive


def ejie_plus(x, gp_y, gp_b_list, archive, regions, omega):
    """
    EJIE+ 采集函数（论文算法2风格）：
    - 对每个region r，计算 EI_r(x)（相对该region当前elite）
    - 计算该点属于该region的概率 P(x -> r | D)
    - 若 P < omega 则置0
    - 归一化概率后做加权求和：EJIE = sum_r P_r * EI_r
    """
    # ---- (A) 预测“区域成员概率”：P(x -> region r | D) ----
    # 论文做法：对每个描述符维度 j，用GP得到均值/方差，然后计算落在partition区间的概率Φ差分
    P_region = {}
    for r in regions:
        p = 1.0
        for j, gp_bj in enumerate(gp_b_list):
            mu_bj, std_bj = gp_predict_mean_std(gp_bj, x)  # 描述符第j维的后验均值与标准差

            LB, UB = r.partition_bounds[j]  # region r 在第j维对应partition的下/上界

            # 该维落入[LB, UB]的概率：Φ((UB - mu)/std) - Φ((LB - mu)/std)
            # （等价写法：Φ((mu - LB)/std) - Φ((mu - UB)/std)，本质一样）
            p_j = normal_cdf((UB - mu_bj) / std_bj) - normal_cdf((LB - mu_bj) / std_bj)

            p *= max(p_j, 0.0)  # 数值安全：避免微小负数

        # 概率截断：低于omega就忽略该region
        if p < omega:
            p = 0.0
        P_region[r] = p

    # ---- (B) 归一化这些 region 概率（论文算法2第10步）----
    Z = sum(P_region.values())
    if Z <= 0:
        # 如果全被截断掉了，按论文“过度特异/无可改进”的精神，这里给一个退化处理
        return 0.0
    for r in regions:
        P_region[r] /= Z

    # ---- (C) 计算每个 region 的 EI_r(x)，并加权求和（EJIE）----
    mu_y, std_y = gp_predict_mean_std(gp_y, x)  # 目标的后验均值/标准差

    ejie = 0.0
    for r in regions:
        elite = archive.get(r)  # 当前region的elite（可能为空）
        if elite is None:
            # 论文：若region为空，假设 elite 性能为0（驱动“填region”的行为）
            f_best = 0.0
        else:
            f_best = elite.y  # elite的真实观测性能

        # EI公式：EI = (mu - f_best)*Φ(z) + std*φ(z)，z=(mu - f_best)/std
        EI_r = expected_improvement(mu_y, std_y, f_best)

        ejie += P_region[r] * EI_r

    return ejie


# -------------------------
# 下面是一些“伪”辅助函数（表达意图即可）
# -------------------------

def sobol_sample(X_bounds, n):
    """Sobol采样：在盒约束X_bounds内生成n个点（伪实现）"""
    pass

def eval_descriptors(b_funcs, x):
    """评估描述符向量 b(x)"""
    return [bj(x) for bj in b_funcs]

def region_of(b_vec, regions):
    """把真实描述符 b 映射到离散region（按各维partition落点确定）"""
    pass

def init_archive(regions):
    """初始化档案：每个region存一个elite或None"""
    return {r: None for r in regions}

def update_elite_if_better(archive, r, x, y):
    """若该region为空或y更高，则更新elite"""
    elite = archive[r]
    if elite is None or y > elite.y:
        archive[r] = Elite(x=x, y=y)

def fit_gp(xy_pairs):
    """拟合高斯过程代理模型（伪实现）"""
    pass

def gp_predict_mean_std(gp, x):
    """GP后验预测均值/标准差（伪实现）"""
    pass

def normal_cdf(z):
    """标准正态CDF Φ(z)（伪实现）"""
    pass

def normal_pdf(z):
    """标准正态PDF φ(z)（伪实现）"""
    pass

def expected_improvement(mu, sigma, f_best):
    """期望改进EI（与论文Eqn. 12一致的经典EI）"""
    if sigma <= 1e-12:
        return max(mu - f_best, 0.0)

    z = (mu - f_best) / sigma
    return (mu - f_best) * normal_cdf(z) + sigma * normal_pdf(z)


class Elite:
    def __init__(self, x, y):
        self.x = x
        self.y = y


def n_candidates():
    """每轮用于评估采集函数的候选点数（可自行设定）"""
    return 1000

循环：
x0, f
x_i = x_0
while:
    y_i = f(x_i)
    

一个任务只做 f: A -> B, f 是 agent
planner agent: spec -> plan
coder agent: plan -> pr
reviewer agent: pr -> comment or merge
learner agent: spec, pr, comment -> spec
productor agent: idea -> spec
user agent: brainstorm -> idea
client agent: app -> feedback
marketing agent: -> marketing idea
improving agent: -> improving idea