|
| 1 | +# SPDX-License-Identifier: MIT |
| 2 | +"""Frame generation (#96): splitting weight blobs (clean/fg/reference/blobs.py), on synthetic blobs only. |
| 3 | +
|
| 4 | + python -m unittest clean.fg.tests.test_fg_blobs |
| 5 | +""" |
| 6 | +import struct |
| 7 | +import unittest |
| 8 | + |
| 9 | +import numpy as np |
| 10 | + |
| 11 | +from clean.fg import layout as L |
| 12 | +from clean.fg.reference import blobs as B |
| 13 | + |
| 14 | + |
| 15 | +def rand_halves(rng, n): |
| 16 | + return rng.uniform(-2, 2, n).astype("<f2") |
| 17 | + |
| 18 | + |
| 19 | +def synthetic_blobs(rng): |
| 20 | + out = {} |
| 21 | + for l in L.NET1: |
| 22 | + out[l.name] = B.build_net1(l, rand_halves(rng, l.weight_elements), rand_halves(rng, l.out)) |
| 23 | + for l in L.NET2: |
| 24 | + out[l.name + "_w"] = rand_halves(rng, l.weight_elements).tobytes() |
| 25 | + out[l.name + "_b"] = rand_halves(rng, l.out).tobytes() |
| 26 | + return out |
| 27 | + |
| 28 | + |
| 29 | +class SplitNet1(unittest.TestCase): |
| 30 | + def test_round_trip_and_layout(self): |
| 31 | + rng = np.random.default_rng(1) |
| 32 | + l = L.NET1[0] |
| 33 | + w, b = rand_halves(rng, l.weight_elements), rand_halves(rng, l.out) |
| 34 | + blob = B.build_net1(l, w, b) |
| 35 | + self.assertEqual(len(blob), l.blob_bytes) |
| 36 | + gw, gb = B.split_net1(l, blob) |
| 37 | + np.testing.assert_array_equal(gw.view("<u2"), w.view("<u2")) |
| 38 | + np.testing.assert_array_equal(gb.view("<u2"), b.view("<u2")) |
| 39 | + # the bias of channel c is at element bias_offset + net1_bias_index(c), read here byte by byte |
| 40 | + for c in (0, 7, 8, l.out - 1): |
| 41 | + e = l.bias_offset + L.net1_bias_index(c) |
| 42 | + self.assertEqual(blob[2 * e:2 * e + 2], struct.pack("<e", float(b[c]))) |
| 43 | + |
| 44 | + def test_checks(self): |
| 45 | + rng = np.random.default_rng(2) |
| 46 | + l = L.NET1[16] |
| 47 | + blob = bytearray(B.build_net1(l, rand_halves(rng, l.weight_elements), rand_halves(rng, l.out))) |
| 48 | + # -0 in the zero area is still zero |
| 49 | + neg = bytearray(blob) |
| 50 | + neg[2 * l.zero_offset + 1] = 0x80 |
| 51 | + B.split_net1(l, bytes(neg)) |
| 52 | + bad_zero = bytearray(blob) |
| 53 | + bad_zero[2 * (l.bias_offset - 1)] = 0x01 |
| 54 | + with self.assertRaises(B.BlobError): |
| 55 | + B.split_net1(l, bytes(bad_zero)) |
| 56 | + B.split_net1(l, bytes(bad_zero), check=False) |
| 57 | + bad_copy = bytearray(blob) |
| 58 | + e = l.bias_offset + L.net1_bias_index(9) + 5 * L.NET1_BIAS_GROUP # copy 5 of channel 9 |
| 59 | + bad_copy[2 * e] ^= 0x01 |
| 60 | + with self.assertRaises(B.BlobError): |
| 61 | + B.split_net1(l, bytes(bad_copy)) |
| 62 | + _, gb = B.split_net1(l, bytes(bad_copy), check=False) # copy 0 is still taken |
| 63 | + _, want = B.split_net1(l, bytes(blob)) |
| 64 | + np.testing.assert_array_equal(gb.view("<u2"), want.view("<u2")) |
| 65 | + with self.assertRaises(B.BlobError): |
| 66 | + B.split_net1(l, bytes(blob[:-2])) |
| 67 | + |
| 68 | + |
| 69 | +class SplitAll(unittest.TestCase): |
| 70 | + def test_every_layer(self): |
| 71 | + rng = np.random.default_rng(3) |
| 72 | + blobs = synthetic_blobs(rng) |
| 73 | + self.assertEqual(sum(len(v) for v in blobs.values()), L.totals()["bytes"]) |
| 74 | + parts = B.split_all(blobs) |
| 75 | + self.assertEqual(len(parts), len(L.NET1) + len(L.NET2)) |
| 76 | + for l in L.NET1: |
| 77 | + w, b = parts[l.name] |
| 78 | + self.assertEqual((w.size, b.size, w.dtype.str, b.dtype.str), (l.weight_elements, l.out, "<f2", "<f2")) |
| 79 | + self.assertEqual(B.build_net1(l, w, b), blobs[l.name]) |
| 80 | + for l in L.NET2: |
| 81 | + w, b = parts[l.name] |
| 82 | + self.assertEqual(w.tobytes(), blobs[l.name + "_w"]) |
| 83 | + self.assertEqual(b.tobytes(), blobs[l.name + "_b"]) |
| 84 | + self.assertEqual(sum(w.size + b.size for w, b in parts.values()), |
| 85 | + L.totals()["net1_params"] + L.totals()["net2_params"]) |
| 86 | + |
| 87 | + def test_blob_set_and_sizes(self): |
| 88 | + rng = np.random.default_rng(4) |
| 89 | + blobs = synthetic_blobs(rng) |
| 90 | + less = dict(blobs) |
| 91 | + del less["net2_25_b"] |
| 92 | + with self.assertRaises(B.BlobError): |
| 93 | + B.split_all(less) |
| 94 | + with self.assertRaises(B.BlobError): |
| 95 | + B.split_all(dict(blobs, extra=b"\0\0")) |
| 96 | + l = L.NET2[0] |
| 97 | + with self.assertRaises(B.BlobError): |
| 98 | + B.split_net2(l, blobs[l.name + "_w"][:-2], blobs[l.name + "_b"]) |
| 99 | + with self.assertRaises(B.BlobError): |
| 100 | + B.split_net2(l, blobs[l.name + "_w"], blobs[l.name + "_b"] + b"\0\0") |
| 101 | + |
| 102 | + |
| 103 | +if __name__ == "__main__": |
| 104 | + unittest.main() |
0 commit comments