梯度核验通过一次，就能相信整段反向代码吗？

"""Small gradient diagnostics: polynomial oracle, floating difference, and a kink."""
import csv
import json
import math
from fractions import Fraction as F
from pathlib import Path


def polynomial(point):
    x, y = point
    return x * x + 3 * x * y + 2 * y * y


def proposed_gradient(point, bug=False):
    x, y = point
    correct = (2 * x + 3 * y, 3 * x + 4 * y)
    return (correct[0] + 1, correct[1] - 1) if bug else correct


def directional_difference(function, point, direction, step):
    if step <= 0 or len(point) != len(direction):
        raise ValueError("positive step and matching dimensions required")
    plus = tuple(x + step * d for x, d in zip(point, direction))
    minus = tuple(x - step * d for x, d in zip(point, direction))
    return (function(plus) - function(minus)) / (2 * step)


def dot(first, second):
    return sum(a * b for a, b in zip(first, second))


def main():
    point = (F(1), F(2))
    h = F(1, 1000)
    directions = {"both": (F(1), F(1)), "x_only": (F(1), F(0)), "y_only": (F(0), F(1))}
    # Independent hand expansion: f(1+t,2)=15+8t+t*t; f(1,2+t)=15+11t+2*t*t.
    assert polynomial(point) == 15
    assert polynomial((1 + h, F(2))) == 15 + 8 * h + h * h
    assert polynomial((F(1), 2 + h)) == 15 + 11 * h + 2 * h * h
    exact_rows = []
    for name, direction in directions.items():
        numerical = directional_difference(polynomial, point, direction, h)
        for bug in (False, True):
            claimed = dot(proposed_gradient(point, bug), direction)
            exact_rows.append({"direction": name, "gradient": "buggy" if bug else "correct",
                               "numerical": str(numerical), "claimed": str(claimed),
                               "error": str(claimed - numerical), "passed": claimed == numerical})
    assert [r["passed"] for r in exact_rows if r["gradient"] == "buggy"] == [True, False, False]
    assert all(r["passed"] for r in exact_rows if r["gradient"] == "correct")
    # At x=1, d(x^3)/dx=3, while the exact central difference is 3+h^2.
    steps = [10.0 ** (-power) for power in range(1, 17)]
    sweep = []
    for step in steps:
        numerical = ((1.0 + step) ** 3 - (1.0 - step) ** 3) / (2 * step)
        sweep.append({"step": step, "numerical": numerical, "absolute_error": abs(numerical - 3.0),
                      "exact_formula": str(3 + F(str(step)) ** 2),
                      "exact_truncation_error": str(F(str(step)) ** 2)})
    assert all(math.isfinite(r["numerical"]) for r in sweep)
    assert min(r["absolute_error"] for r in sweep) < sweep[0]["absolute_error"]
    assert min(r["absolute_error"] for r in sweep) < sweep[-1]["absolute_error"]
    relu = lambda x: max(F(0), x)
    kink = []
    for x in (F(-1), F(0), F(1)):
        left = (relu(x) - relu(x - h)) / h
        right = (relu(x + h) - relu(x)) / h
        central = (relu(x + h) - relu(x - h)) / (2 * h)
        kink.append({"x": str(x), "left_slope": str(left), "right_slope": str(right),
                     "central": str(central), "differentiable_here": left == right})
    assert kink[1] == {"x": "0", "left_slope": "0", "right_slope": "1",
                       "central": "1/2", "differentiable_here": False}
    assert kink[0]["central"] == "0" and kink[2]["central"] == "1"
    best = min(sweep, key=lambda row: row["absolute_error"])
    report = {"scope": "Hand-written polynomial gradient; exact directional and kink checks; binary64 step sweep. No autograd library or training.",
              "point": ["1", "2"], "hand_gradient": ["8", "11"], "bug_gradient": ["9", "10"],
              "exact_step": str(h), "direction_checks": exact_rows, "relu_checks": kink,
              "float_sweep": {"rows": len(sweep), "best_observed_step": best["step"],
                              "best_error": best["absolute_error"], "first_error": sweep[0]["absolute_error"],
                              "last_error": sweep[-1]["absolute_error"],
                              "note": "Best step belongs only to this function, point, and runtime."}}
    Path("gradient-report.json").write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
    for filename, rows in (("gradient-directions.csv", exact_rows), ("gradient-step-sweep.csv", sweep), ("gradient-kinks.csv", kink)):
        with Path(filename).open("w", newline="", encoding="utf-8") as handle:
            writer = csv.DictWriter(handle, fieldnames=list(rows[0]))
            writer.writeheader()
            writer.writerows(rows)
    print(json.dumps({"status": "PASS", "direction_rows": len(exact_rows), "step_rows": len(sweep),
                      "kink_rows": len(kink), "bug_passes_both_direction": True,
                      "relu_at_zero": "not_differentiable"}))


if __name__ == "__main__":
    main()