一个特别大的数，为什么让其余量化值全变成零？

"""Exact uniform-grid experiment, not packed int4 storage or a model benchmark."""
import csv
import json
from fractions import Fraction as F
from pathlib import Path

QMAX = 7  # Custom symmetric grid [-7, 7]; the int4 code -8 is deliberately unused.
WEIGHTS = ((F(1, 10), F(1, 5), F(3, 10)),
           (F(1, 10), F(1, 5), F(12)))  # [output_channel][input_feature]
INPUTS = {"small_features": (F(1), F(1), F(0)),
          "outlier_feature": (F(0), F(0), F(1))}


def quantize(value, scale):
    if scale <= 0:
        raise ValueError("scale must be positive")
    rounded = round(value / scale)  # Fraction implements nearest, ties to even.
    integer = max(-QMAX, min(QMAX, rounded))
    return integer, integer * scale


def choose_scale(values, cap=None):
    if not values or (cap is not None and cap <= 0):
        raise ValueError("nonempty values and positive cap required")
    peak = max(abs(v) for v in values) if cap is None else cap
    return peak / QMAX if peak else F(1)  # All-zero group has no division by zero.


def matvec(matrix, vector):
    if any(len(row) != len(vector) for row in matrix):
        raise ValueError("shape mismatch")
    return [sum((w * x for w, x in zip(row, vector)), F(0)) for row in matrix]


def mse(first, second):
    if not first or len(first) != len(second):
        raise ValueError("equal nonempty vectors required")
    return sum(((a - b) ** 2 for a, b in zip(first, second)), F(0)) / len(first)


def main():
    flat = [v for row in WEIGHTS for v in row]
    policies = {"whole_tensor": [choose_scale(flat)] * 2,
                "per_output_row": [choose_scale(row) for row in WEIGHTS],
                "clip_at_7_over_10": [choose_scale(flat, F(7, 10))] * 2}
    reports, weight_rows, output_rows = {}, [], []
    for name, scales in policies.items():
        restored = []
        for r, (row, scale) in enumerate(zip(WEIGHTS, scales)):
            restored_row = []
            for c, value in enumerate(row):
                integer, recovered = quantize(value, scale)
                restored_row.append(recovered)
                weight_rows.append({"policy": name, "row": r, "column": c,
                                    "original": str(value), "scale": str(scale),
                                    "integer": integer, "restored": str(recovered),
                                    "error": str(recovered - value),
                                    "outside_grid_range": abs(value) > QMAX * scale})
            restored.append(restored_row)
        outputs = {}
        for input_name, vector in INPUTS.items():
            reference, actual = matvec(WEIGHTS, vector), matvec(restored, vector)
            outputs[input_name] = {"reference": list(map(str, reference)),
                                   "quantized": list(map(str, actual)),
                                   "output_mse": str(mse(reference, actual))}
            for r, (original, recovered) in enumerate(zip(reference, actual)):
                output_rows.append({"policy": name, "input": input_name, "row": r,
                                    "reference": str(original), "actual": str(recovered),
                                    "error": str(recovered - original)})
        reports[name] = {"scales": list(map(str, scales)),
                         "scale_count": 2 if name == "per_output_row" else 1,
                         "restored": [[str(v) for v in row] for row in restored],
                         "weight_mse": str(mse(flat, [v for row in restored for v in row])),
                         "outputs": outputs}
    assert reports["whole_tensor"]["restored"] == [["0", "0", "0"], ["0", "0", "12"]]
    assert reports["per_output_row"]["scales"] == ["3/70", "12/7"]
    assert reports["clip_at_7_over_10"]["restored"] == [["1/10", "1/5", "3/10"], ["1/10", "1/5", "7/10"]]
    expected_weight_mse = {"whole_tensor": "19/600", "per_output_row": "247/29400", "clip_at_7_over_10": "12769/600"}
    expected_outputs = {"whole_tensor": ("9/100", "9/200"),
                        "per_output_row": ("9/200", "0"),
                        "clip_at_7_over_10": ("0", "12769/200")}
    for name in policies:
        assert reports[name]["weight_mse"] == expected_weight_mse[name]
        assert tuple(reports[name]["outputs"][i]["output_mse"] for i in INPUTS) == expected_outputs[name]
    assert choose_scale([F(0), F(0)]) == 1
    assert quantize(F(0), choose_scale([F(0)])) == (0, 0)
    assert [quantize(F(x, 2), F(1))[0] for x in (1, 3, -1, -3)] == [0, 2, 0, -2]
    assert quantize(F(100), F(1)) == (7, 7)
    try:
        quantize(F(1), F(0))
    except ValueError:
        pass
    else:
        raise AssertionError("zero scale accepted")
    report = {"scope": "Exact rational arithmetic on one 2-by-3 matrix; no model inference.",
              "convention": {"shape": "[output_channel,input_feature]", "qmin": -7,
                             "qmax": 7, "zero_point": 0, "rounding": "nearest_ties_even",
                             "all_zero_scale": "1", "inputs_unquantized": True},
              "weights": [[str(v) for v in row] for row in WEIGHTS],
              "inputs": {k: list(map(str, v)) for k, v in INPUTS.items()}, "policies": reports}
    Path("quantization-report.json").write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
    for filename, rows in (("quantization-values.csv", weight_rows), ("quantization-outputs.csv", output_rows)):
        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", "policies": 3, "weight_rows": len(weight_rows),
                      "output_rows": len(output_rows), "weight_mse": expected_weight_mse}))


if __name__ == "__main__":
    main()