同样预测全对，为什么重要特征排名相反？

"""Fit two toy stumps, then enumerate permutation reliance on one fixed holdout.

Only Python's standard library is used. Data is synthetic. This is not causal
inference, a real dataset benchmark, a full decision-tree package, or a p-value.
"""
import csv
import json
import math
from collections import Counter
from copy import deepcopy
from itertools import permutations
from pathlib import Path

FEATURES = ("signal", "copy", "background")


def make_rows(values, prefix):
    return [{"id": f"{prefix}-{i}", "signal": x, "copy": x,
             "background": i % 2, "y": int(x >= 0)} for i, x in enumerate(values)]


def validate_rows(rows):
    if not rows or len({row["id"] for row in rows}) != len(rows):
        raise ValueError("nonempty rows with unique IDs required")
    for row in rows:
        if type(row["y"]) is not int or row["y"] not in (0, 1):
            raise ValueError("integer binary labels required")
        for feature in FEATURES:
            x = row[feature]
            if isinstance(x, bool) or not isinstance(x, (int, float)) or not math.isfinite(x):
                raise ValueError("finite numeric features required")


def predict(model, row):
    return model["high_label"] if row[model["feature"]] >= model["threshold"] else 1 - model["high_label"]


def errors(model, rows):
    return sum(predict(model, row) != row["y"] for row in rows)


def fit_stump(training_rows, feature_order):
    validate_rows(training_rows)
    if len(feature_order) != len(FEATURES) or set(feature_order) != set(FEATURES):
        raise ValueError("feature order must contain each declared feature once")
    candidates = []
    for rank, feature in enumerate(feature_order):
        values = sorted({row[feature] for row in training_rows})
        for left, right in zip(values, values[1:]):
            threshold = left / 2 + right / 2
            for high_label in (0, 1):
                model = {"feature": feature, "threshold": threshold, "high_label": high_label}
                count = errors(model, training_rows)
                candidates.append(((count, rank, threshold, high_label), model))
    if not candidates:
        raise ValueError("this toy learner requires at least one varying feature")
    key, model = min(candidates, key=lambda pair: pair[0])
    return {**model, "training_errors": key[0], "feature_tie_order": list(feature_order),
            "candidate_count": len(candidates)}


def permute_features(rows, columns, order):
    if len(order) != len(rows) or sorted(order) != list(range(len(rows))):
        raise ValueError("order must be a permutation of every row index")
    if not columns or len(set(columns)) != len(columns) or not set(columns) <= set(FEATURES):
        raise ValueError("nonempty, unique declared feature group required")
    changed = deepcopy(rows)
    for target, source in enumerate(order):
        for column in columns:
            changed[target][column] = rows[source][column]
    return changed


def rejected(action):
    try:
        action()
    except ValueError:
        return
    raise AssertionError("invalid teaching input was accepted")


training = make_rows([-8, -6, -4, -2, 2, 4, 6, 8], "train")
holdout = make_rows([-7, -3, -1, 1, 3, 7], "holdout")
validate_rows(holdout)
assert not {row["id"] for row in training} & {row["id"] for row in holdout}
assert not {row["signal"] for row in training} & {row["signal"] for row in holdout}
frozen_training, frozen_holdout = deepcopy(training), deepcopy(holdout)
models = {"A": fit_stump(training, ["signal", "copy", "background"]),
          "B": fit_stump(training, ["copy", "signal", "background"])}
assert models["A"]["feature"] == "signal" and models["B"]["feature"] == "copy"
assert all(model["threshold"] == 0 and model["training_errors"] == 0 for model in models.values())
assert [predict(models["A"], row) for row in holdout] == [predict(models["B"], row) for row in holdout]
assert all(errors(model, holdout) == 0 for model in models.values())
model_snapshot = deepcopy(models)

groups = {"signal": ("signal",), "copy": ("copy",), "background": ("background",),
          "signal+copy": ("signal", "copy")}
orders = list(permutations(range(len(holdout))))
assert len(orders) == 720
summary = {}
csv_rows = []
for name, model in models.items():
    baseline = errors(model, holdout)
    summary[name] = {}
    for group_name, columns in groups.items():
        counts, broken_counts = [], []
        for permutation_id, order in enumerate(orders):
            changed = permute_features(holdout, columns, order)
            count = errors(model, changed)
            broken = sum(row["signal"] != row["copy"] for row in changed)
            assert [row["id"] for row in changed] == [row["id"] for row in holdout]
            assert [row["y"] for row in changed] == [row["y"] for row in holdout]
            counts.append(count)
            broken_counts.append(broken)
            csv_rows.append([name, group_name, permutation_id, ":".join(map(str, order)),
                             baseline, count, (count - baseline) / len(holdout), broken])
        summary[name][group_name] = {
            "permutations": len(orders), "baseline_error_rate": baseline / len(holdout),
            "mean_error_increase": (sum(counts) / len(orders) - baseline) / len(holdout),
            "error_count_histogram": dict(sorted(Counter(counts).items())),
            "mean_broken_copy_rows": sum(broken_counts) / len(orders)}

for name, used, unused in (("A", "signal", "copy"), ("B", "copy", "signal")):
    assert summary[name][used]["mean_error_increase"] == 0.5
    assert summary[name][unused]["mean_error_increase"] == 0
    assert summary[name]["background"]["mean_error_increase"] == 0
    assert summary[name]["signal+copy"]["mean_error_increase"] == 0.5
    assert summary[name]["signal+copy"]["mean_broken_copy_rows"] == 0
    assert summary[name][used]["error_count_histogram"] == {0: 36, 2: 324, 4: 324, 6: 36}
    assert summary[name][used]["mean_broken_copy_rows"] == 5

visible_order = [3, 1, 2, 0, 4, 5]  # Swap a negative row and a positive row.
single_example = permute_features(holdout, ("signal",), visible_order)
group_example = permute_features(holdout, ("signal", "copy"), visible_order)
assert single_example[0]["signal"] == 1 and single_example[0]["copy"] == -7
assert all(row["signal"] == row["copy"] for row in group_example)
assert training == frozen_training and holdout == frozen_holdout and models == model_snapshot
assert len(csv_rows) == 5760  # 2 fitted models x 4 groups x 720 permutations.
rejected(lambda: fit_stump([], FEATURES))
rejected(lambda: fit_stump(training, ["signal", "signal", "background"]))
rejected(lambda: fit_stump([{**training[0], "y": False}], FEATURES))
rejected(lambda: permute_features(holdout, ("y",), range(len(holdout))))
rejected(lambda: permute_features(holdout, ("signal",), [0] * len(holdout)))

report = {"scope": "synthetic fitted stumps; finite-holdout permutation enumeration, not causal inference",
          "protocol": {"training_rows": 8, "holdout_rows": 6, "permutations_per_group": 720,
                       "metric": "permuted error rate minus baseline error rate",
                       "retraining_during_permutations": False, "random_seed_selection": "none"},
          "summary": summary,
          "visible_example": {"order": visible_order, "original": holdout,
                              "single_signal_permutation": single_example,
                              "joint_signal_copy_permutation": group_example},
          "limits": ["No p-values or population confidence intervals are calculated.",
                     "Group permutation preserves only the declared within-group relationship.",
                     "Deleting a column and retraining asks a different question."]}
for filename, value in (("training-data.json", training), ("holdout-data.json", holdout),
                        ("fitted-models.json", models), ("importance-report.json", report)):
    Path(filename).write_text(json.dumps(value, indent=2), encoding="utf-8")
with Path("permutation-results.csv").open("w", encoding="utf-8", newline="") as stream:
    writer = csv.writer(stream)
    writer.writerow(["model", "feature_group", "permutation_id", "source_row_order",
                     "baseline_errors", "permuted_errors", "error_rate_increase", "broken_copy_rows"])
    writer.writerows(csv_rows)
for name in models:
    print(name, "uses", models[name]["feature"], "baseline_error_rate=0.0")
    print({group: stats["mean_error_increase"] for group, stats in summary[name].items()})
print("PASS: 720 permutations/group; 5760 CSV rows; five artifacts saved; no causal claim")