"""Tests for int8_layer.py. Run: /Volumes/M2-Dev/conda/envs/toptech/bin/python -m pytest -q""" from __future__ import annotations import numpy as np import pytest import int8_layer as L @pytest.fixture(scope="module") def result() -> dict: return L.build() def test_dataset_is_reproducible() -> None: x1, y1 = L.make_dataset(5, 7) x2, y2 = L.make_dataset(5, 7) assert np.array_equal(x1, x2) and np.array_equal(y1, y2) assert x1.shape == (50, 64) and x1.min() >= 0.0 and x1.max() <= 1.0 def test_quantize_multiplier_accuracy() -> None: rng = np.random.default_rng(1) for m in rng.uniform(1e-9, 0.999, size=2000): m0, shift = L.quantize_multiplier(float(m)) assert (1 << 30) <= m0 < (1 << 31) assert 0 <= shift <= 31 assert abs(m0 * 2.0 ** -(31 + shift) - m) <= m * 2.0 ** -30 def test_quantize_multiplier_rejects_out_of_range() -> None: with pytest.raises(ValueError): L.quantize_multiplier(1.5) with pytest.raises(ValueError): L.quantize_multiplier(1e-12) # would need a shift above 31 def test_requantize_matches_real_rounding() -> None: rng = np.random.default_rng(2) for _ in range(5000): m = float(rng.uniform(1e-6, 0.99)) m0, shift = L.quantize_multiplier(m) acc = int(rng.integers(-2**31, 2**31)) bias = int(rng.integers(-2**20, 2**20)) zp = int(rng.integers(-128, 128)) exact = (acc + bias) * m0 / 2.0 ** (31 + shift) expect = max(-128, min(127, int(np.floor(exact + 0.5)) + zp)) assert L.requantize(acc, bias, m0, shift, zp) == expect def test_requantize_relu_clamps_at_zero_point() -> None: m0, shift = L.quantize_multiplier(0.01) assert L.requantize(-5000, 0, m0, shift, zp=-20, relu=True) == -20 assert L.requantize(-5000, 0, m0, shift, zp=-20, relu=False) == -70 def test_tiled_matmul_equals_full() -> None: rng = np.random.default_rng(3) a = rng.integers(-128, 128, size=(9, 37)) b = rng.integers(-128, 128, size=(37, 10)) for n in (1, 2, 4, 5): assert np.array_equal(L.tiled_matmul(a, b, n), L.int_matmul(a, b)) def test_zero_point_folding(result: dict) -> None: lay, qx = result["layer"], result["qx"] qb = lay.bias_eff + lay.zx * lay.qw.sum(axis=1) # undo the folding direct = (qx - lay.zx) @ lay.qw.T + qb # sum qw (qx - zx) + qb assert np.array_equal(result["acc"] + lay.bias_eff, direct) def test_integer_path_tracks_float(result: dict) -> None: lay = result["layer"] deq = lay.sy * (result["qy"] - lay.zy) err = np.abs(deq - result["logits_f"]) # Output step is sy; input and weight rounding add a little more. assert err.max() < 2.0 * lay.sy assert result["agree"] >= 0.99 assert abs(result["acc_int8"] - result["acc_float"]) <= 0.01 assert result["acc_float"] > 0.9 def test_accumulators_fit_int32(result: dict) -> None: assert np.abs(result["acc"]).max() < 2**31 # Worst case for K = 64: |qx| <= 128 and |qw| <= 127. assert 64 * 128 * 127 < 2**31