同一个样本，为什么和谁一起计算会影响结果？

"""Scalar BatchNorm formula demonstration; does not import or execute PyTorch."""
import json
import math
from pathlib import Path

EPS = 1e-5


def moments(values):
    if len(values) < 2 or not all(math.isfinite(x) for x in values):
        raise ValueError("this scalar teaching batch needs at least two finite values")
    mean = sum(values) / len(values)
    square_sum = sum((value - mean) ** 2 for value in values)
    return mean, square_sum / len(values), square_sum / (len(values) - 1)


def normalize(values, mean, variance):
    if variance < 0 or not math.isfinite(mean) or not math.isfinite(variance):
        raise ValueError("invalid stored statistics")
    return [(value - mean) / math.sqrt(variance + EPS) for value in values]


def current_batch(values):
    mean, biased, _ = moments(values)
    return normalize(values, mean, biased)


def stored_eval(values, running):
    return normalize(values, running["mean"], running["variance"])


def update_running(values, running, momentum=0.1):
    mean, _, unbiased = moments(values)
    return {"mean": (1 - momentum) * running["mean"] + momentum * mean,
            "variance": (1 - momentum) * running["variance"] + momentum * unbiased}


def close(left, right):
    return len(left) == len(right) and all(
        math.isclose(a, b, rel_tol=0, abs_tol=1e-12) for a, b in zip(left, right))


near = [2.0, 0.0, 1.0, 3.0]
far = [2.0, 10.0, 11.0, 12.0]
training_near, training_far = current_batch(near), current_batch(far)
assert training_near[0] > 0 > training_far[0]

# Snapshot held fixed for both requests; deliberately not estimated from them.
frozen = {"mean": 1.5, "variance": 1.25}
snapshot = dict(frozen)
evaluation_near, evaluation_far = stored_eval(near, frozen), stored_eval(far, frozen)
assert evaluation_near[0] == evaluation_far[0]
assert frozen == snapshot

data = [0.0, 2.0, 10.0, 12.0]
full = current_batch(data)
split = current_batch(data[:2]) + current_batch(data[2:])
assert not close(full, split)
assert close(stored_eval(data, frozen), stored_eval(data[:2], frozen) + stored_eval(data[2:], frozen))

# In the documented track_running_stats=False setting, eval also uses current-batch stats.
without_running_near, without_running_far = current_batch(near), current_batch(far)
assert without_running_near[0] != without_running_far[0]
updated = update_running([0.0, 2.0], {"mean": 0.0, "variance": 1.0})
assert math.isclose(updated["mean"], 0.1)
assert math.isclose(updated["variance"], 1.1)  # Current biased variance=1; unbiased update variance=2.
assert current_batch([7.0, 7.0]) == [0.0, 0.0]
assert not close([], [1.0])
assert not close([1.0], [1.0, 2.0])
for invalid in ([], [1.0], [1.0, float("nan")]):
    try:
        current_batch(invalid)
    except ValueError:
        pass
    else:
        raise AssertionError("invalid teaching batch accepted")

report = {"scope": "stdlib scalar formula, gamma=1 beta=0; no framework, gradients or training",
          "epsilon": EPS, "sample_of_interest": 2.0,
          "train_mode_sample_outputs": [training_near[0], training_far[0]],
          "frozen_eval_sample_outputs": [evaluation_near[0], evaluation_far[0]],
          "full_batch": full, "split_batches": split,
          "frozen_statistics": frozen, "one_running_update": updated,
          "track_running_stats_false_sample_outputs": [without_running_near[0], without_running_far[0]]}
Path("batch-neighbors-report.json").write_text(json.dumps(report, indent=2), encoding="utf-8")
print("same_sample_in_train_mode", [round(x, 6) for x in report["train_mode_sample_outputs"]])
print("same_sample_with_frozen_stats", [round(x, 6) for x in report["frozen_eval_sample_outputs"]])
print("one_running_update", updated)
print("PASS: neighbor, split, frozen, and variance checks; batch-neighbors-report.json saved")