最小核心：场景参数化 + 一个可判成败的 oracle + 失败档案 + DT/RF
代理 + 两种选择策略。105 行 Python 够了（scikit-learn，uv run --with scikit-learn mini_fate.py）。oracle
是一个人造的"失败成簇"世界（四个规则簇），这不是作弊——demo
要检验的是机制本身：当失败结构可学时，学习引导能不能把命中率打上去。
"""mini-FATE：把 FATE-VLA 的两种测试策略压缩成一个可跑的玩具对照。
论文（arXiv 2606.02307）在 SimplerEnv 的真实 VLA 上做实验；这里用合成
oracle 代替 VLA，保留循环结构：场景 = (物体, x, y, 朝向)；
B1=Random、B2=FSCS-ART、Sorting_DT=算法1、Weighted_RF=算法2。
运行：uv run --with scikit-learn python mini_fate.py
"""
import random
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier
OBJECTS = ["redbull", "bottle", "eggplant", "carrot", "apple", "spoon", "sponge"]
X_RANGE, Y_RANGE, ORIENTS = (-0.5, -0.05), (0.0, 0.4), (0, 90, 180, 270)
K, N = 20, 200 # 候选集大小 / 测试预算（论文未披露 k 值，这里取 20）
def oracle(s):
"""合成 'VLA under test'：失败稀疏且成簇（论文动机的玩具版）。"""
obj, x, y, o = s
if obj == "eggplant" and x < -0.35 and y < 0.15: # 簇 1：左下角细长物体
return 1
if obj == "apple" and o == 90: # 簇 2：特定朝向
return 1
if obj == "carrot" and y > 0.32: # 簇 3：台面深处
return 1
if x > -0.12 and y < 0.08: # 簇 4：跨物体的近角区域
return 1
return 0
def rand_scene(rng):
return (rng.choice(OBJECTS),
rng.uniform(*X_RANGE), rng.uniform(*Y_RANGE), rng.choice(ORIENTS))
def near_scene(s, rng):
"""失败档案邻域采样 + 全局混合（算法 2 的 GenerateCandidates）。"""
if rng.random() < 0.5:
obj, x, y, o = s
return (obj, min(max(x + rng.gauss(0, 0.06), X_RANGE[0]), X_RANGE[1]),
min(max(y + rng.gauss(0, 0.06), Y_RANGE[0]), Y_RANGE[1]),
o if rng.random() < 0.8 else rng.choice(ORIENTS))
return rand_scene(rng)
def feats(s):
obj, x, y, o = s
return [OBJECTS.index(obj), x, y, o / 90.0]
def min_dist(c, S):
if not S:
return 1.0
return min(sum((a - b) ** 2 for a, b in zip(feats(c), feats(s))) ** 0.5 for s in S)
def run(mode, seed):
rng = random.Random(seed)
D, S, F = [], [], [] # 标注档案 / 已测场景 / 失败档案
fails = 0
for i in range(N):
# 1) 生成候选集：算法 2 混入失败档案邻域；其余全局随机
anchor = rng.choice(F) if (F and mode == "weighted") else None
C = [near_scene(anchor, rng) if anchor else rand_scene(rng) for _ in range(K)]
# 2) 选择
if mode == "random":
s = rng.choice(C)
elif mode == "art": # B2：FSCS-ART max-min 距离
s = max(C, key=lambda c: min_dist(c, S))
else:
C_sorted = sorted(C, key=lambda c: -min_dist(c, S))
two = len({d[1] for d in D}) == 2 # 论文：两类齐才训练代理
if not two:
s = C_sorted[0]
elif mode == "sorting": # 算法 1：DT 代理
dt = DecisionTreeClassifier(max_depth=8).fit([feats(d[0]) for d in D], [d[1] for d in D])
s = next((c for c in C_sorted if dt.predict([feats(c)])[0] == 1), C_sorted[0])
else: # 算法 2：RF 概率加权
rf = RandomForestClassifier(n_estimators=150, max_depth=12,
min_samples_split=3).fit([feats(d[0]) for d in D], [d[1] for d in D])
dists = [min_dist(c, S) for c in C]
dmin, dmax = min(dists), max(dists)
alpha = min(0.85, (i + 1) / N)
def score(c, d):
norm_d = (d - dmin) / (dmax - dmin + 1e-9)
return alpha * rf.predict_proba([feats(c)])[0][1] + (1 - alpha) * norm_d
s = max(zip(C, dists), key=lambda cd: score(cd[0], cd[1]))[0]
# 3) 执行 + 归档（代理每轮用全量 D 重训练，与论文一致）
f = oracle(s)
fails += f
D.append((s, f))
S.append(s)
if f:
F.append(s)
return fails / N
if __name__ == "__main__":
import statistics as st
print(f"toy domain: {len(OBJECTS)} objects x x-range x y-range x 4 orientations, N={N}, k={K}")
for name, mode in [("B1 Random", "random"), ("B2 FSCS-ART", "art"),
("Sorting_DT (Algo 1)", "sorting"), ("Weighted_RF (Algo 2)", "weighted")]:
frs = [run(mode, s) for s in range(10)]
print(f"{name:22s} mean FR = {st.mean(frs):.3f} (10 seeds)")
200 次测试 × 10 种子，失败发现率：
| 方法 |
失败发现率 |
机制要点 |
| B1 Random |
0.112 |
随机抽题 |
| B2 FSCS-ART |
0.146 |
纯多样性，无学习——与 B1 差距很小 |
| Sorting_DT |
0.445 |
算法 1 + 决策树 |
| Weighted_RF |
0.588 |
算法 2 + 随机森林，α 调度 + 失败邻域采样 |
论文的三条定性结论全部复现：① B1≈B2，多样性-only 几乎不涨；②
接入学习信号后跳升一个量级；③ RF 的平滑概率比 DT
硬分区更均衡。同时诚实地记录边界：demo 的 oracle
结构是构造出来的——它验证机制能利用可学结构，不证明真实
VLA 有这种结构；后者是论文四个模型实验才立的证据。
