两个模型算得一样，平均参数为什么反而算错？

"""Constructed two-unit ReLU example; no training or checkpoint merging."""
import csv
import json
import math
from dataclasses import asdict, dataclass
from itertools import permutations
from pathlib import Path


def finite(value):
    if isinstance(value, bool) or not isinstance(value, (int, float)):
        raise ValueError("finite numeric value required")
    if not math.isfinite(value):
        raise ValueError("finite numeric value required")
    return value


@dataclass(frozen=True)
class Network:
    incoming: tuple
    hidden_bias: tuple
    outgoing: tuple
    output_bias: float = 0.0

    def __post_init__(self):
        if not (len(self.incoming) == len(self.hidden_bias) == len(self.outgoing) == 2):
            raise ValueError("this experiment requires exactly two hidden units")
        if not all(isinstance(v, tuple) for v in (self.incoming, self.hidden_bias, self.outgoing)):
            raise ValueError("immutable tuple parameters required")
        for value in self.flat():
            finite(value)

    def flat(self):
        return self.incoming + self.hidden_bias + self.outgoing + (self.output_bias,)

    def trace(self, x):
        finite(x)
        pre = [finite(w * x + b) for w, b in zip(self.incoming, self.hidden_bias)]
        hidden = [max(0.0, z) for z in pre]
        output = finite(sum(w * z for w, z in zip(self.outgoing, hidden)) + self.output_bias)
        return {"x": x, "preactivation": pre, "hidden": hidden, "prediction": output}

    def predict(self, x):
        return self.trace(x)["prediction"]


def permute(network, order, incoming_only=False):
    if any(type(i) is not int for i in order) or sorted(order) != [0, 1]:
        raise ValueError("order must be a permutation of (0, 1)")
    return Network(tuple(network.incoming[i] for i in order),
                   tuple(network.hidden_bias[i] for i in order),
                   network.outgoing if incoming_only else tuple(network.outgoing[i] for i in order),
                   network.output_bias)


def interpolate(a, b, alpha):
    finite(alpha)
    if not 0 <= alpha <= 1:
        raise ValueError("alpha must be between zero and one")
    values = tuple((1 - alpha) * x + alpha * y for x, y in zip(a.flat(), b.flat()))
    return Network(values[0:2], values[2:4], values[4:6], values[6])


def distance(a, b):
    return sum((x - y) ** 2 for x, y in zip(a.flat(), b.flat()))


def align_by_parameters(reference, candidate):
    # Deliberately takes no probe inputs or target labels.
    trials = [{"order": list(order), "parameter_distance_squared": distance(reference, permute(candidate, order))}
              for order in permutations((0, 1))]
    chosen = min(trials, key=lambda row: (row["parameter_distance_squared"], row["order"]))
    return permute(candidate, chosen["order"]), {"criterion": "squared distance over all seven parameters",
                                                  "selection_uses_inputs_or_targets": False,
                                                  "trials": trials, "chosen_order": chosen["order"]}


def mse(predictions, targets):
    if not predictions or len(predictions) != len(targets):
        raise ValueError("nonempty equal lengths required")
    return sum((finite(p) - finite(y)) ** 2 for p, y in zip(predictions, targets)) / len(targets)


def near(a, b):
    assert math.isclose(a, b, rel_tol=1e-12, abs_tol=1e-12), (a, b)


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


def write_json(name, value):
    Path(name).write_text(json.dumps(value, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")


def write_csv(name, rows):
    with Path(name).open("w", encoding="utf-8", newline="") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0]))
        writer.writeheader()
        writer.writerows(rows)


def main():
    a = Network((1.0, -1.0), (0.0, 0.0), (1.0, -1.0))
    b = permute(a, (1, 0))
    original_parameters = (a.flat(), b.flat())
    aligned_b, audit = align_by_parameters(a, b)
    assert audit["chosen_order"] == [1, 0]
    assert [row["parameter_distance_squared"] for row in audit["trials"]] == [16.0, 0.0]
    assert aligned_b == a
    # Declared probes illustrate behavior; they are not a held-out benchmark.
    probes = [-3.0, -1.0, 1.0, 3.0]
    targets = list(probes)
    networks = {"A": a, "B_swapped_both_sides": b,
                "wrong_incoming_only": permute(a, (1, 0), incoming_only=True),
                "naive_parameter_mean": interpolate(a, b, 0.5),
                "B_realigned": aligned_b, "aligned_parameter_mean": interpolate(a, aligned_b, 0.5)}
    predictors = {name: network.predict for name, network in networks.items()}
    predictors["output_mean"] = lambda x: (a.predict(x) + b.predict(x)) / 2
    prediction_rows, scores = [], {}
    for name, predict in predictors.items():
        values = [predict(x) for x in probes]
        scores[name] = mse(values, targets)
        prediction_rows += [{"variant": name, "x": x, "target": y, "prediction": p,
                             "squared_error": (p - y) ** 2} for x, y, p in zip(probes, targets, values)]
    expected = {"A": 0, "B_swapped_both_sides": 0, "wrong_incoming_only": 20,
                "naive_parameter_mean": 5, "B_realigned": 0, "aligned_parameter_mean": 0, "output_mean": 0}
    for name, value in expected.items():
        near(scores[name], value)
    curve_rows = []
    for alpha in (0.0, 0.25, 0.5, 0.75, 1.0):
        unaligned = [interpolate(a, b, alpha).predict(x) for x in probes]
        aligned = [interpolate(a, aligned_b, alpha).predict(x) for x in probes]
        output_mix = [(1 - alpha) * a.predict(x) + alpha * b.predict(x) for x in probes]
        for x, value in zip(probes, unaligned):
            near(value, (1 - 2 * alpha) ** 2 * x)
        unaligned_mse = mse(unaligned, targets)
        near(unaligned_mse, 5 * ((1 - 2 * alpha) ** 2 - 1) ** 2)
        near(mse(aligned, targets), 0)
        near(mse(output_mix, targets), 0)
        curve_rows.append({"alpha": alpha, "unaligned_parameter_mse": unaligned_mse,
                           "aligned_parameter_mse": mse(aligned, targets), "output_mix_mse": mse(output_mix, targets)})
    rejected(lambda: Network((1.0,), (0.0,), (1.0,)))
    rejected(lambda: Network((float("nan"), 1.0), (0.0, 0.0), (1.0, 1.0)))
    rejected(lambda: a.predict(float("inf")))
    rejected(lambda: permute(a, (0, 0)))
    rejected(lambda: permute(a, (False, True)))
    rejected(lambda: interpolate(a, b, 1.5))
    rejected(lambda: mse([1], []))
    assert original_parameters == (a.flat(), b.flat())
    write_json("constructed-models.json", {name: asdict(net) for name, net in networks.items()})
    write_json("alignment-audit.json", audit)
    write_json("comparison-report.json", {"scope": "constructed finite example; no training or paper reproduction",
               "probe_role": "predeclared illustration, not an independent generalization estimate",
               "probes": probes, "targets": targets, "mse": scores, "curve": curve_rows,
               "traces": {name: [net.trace(x) for x in probes] for name, net in networks.items()}})
    write_csv("predictions.csv", prediction_rows)
    write_csv("interpolation-curve.csv", curve_rows)
    print("PASS: parameter-only alignment; 28 prediction rows; 5 curve rows; MSE naive=5, aligned=0, outputs=0, wrong=20")


if __name__ == "__main__":
    main()