diff --git a/clean/converter/README.md b/clean/converter/README.md index f9055bd6..f4746517 100644 --- a/clean/converter/README.md +++ b/clean/converter/README.md @@ -58,17 +58,17 @@ the key is made from is searched first: when it is missing, the file has no fram message); any other missing blob is exit 13. A map without the field is still read as preset M (so it must have W, D and K) unless the caller names the preset (`--preset FG`). -Its map is `data/fg.v1.map.json` (the spec side's v1; 67 sources `A01`..`A17`, `B01w`/`B01b`..`B25w`/`B25b`; 42 -stages `dl1.l01`..`dl2.l25`): `wronggpu-convert --map data\fg.v1.map.json --dll --out `. -It uses two map features of its own: +Its map is `data/fg.v1.map.json` (the spec side's revision v1.1; 67 sources `A01`..`A17`, `B01w`/`B01b`..`B25w`/`B25b`; +42 stages `dl1.l01`..`dl2.l25`): `wronggpu-convert --map data\fg.v1.map.json --dll --out `. +Each stage has `W` in natural order ([out, in, 3, 3] or [out, in]) and `b` [out]. It uses a map feature of its own: -- `"channel_order": "storage"`: the weight tensors (`W_storage`) are the blobs' weight spans as stored, 1-D, not yet - reshaped to natural axes (that follows in a later map revision). Accepted only in a version-1 map of preset FG; the - converter reads the tensors the same way either way. - An axis given by **explicit offsets** (`{"offsets": [o0, o1, ...]}`, one per index, in place of `stride` and `perm`; - map versions 1 and 4): the axis contributes `offsets[i]` to the element index. The net1 biases use it to take copy 0 - of each group of eight. The index range is checked when the map is loaded (smallest and largest offset); a list of - the wrong length, a non-integer, or `offsets` together with `stride` or `perm` is "converter data damaged". + map versions 1 and 4): the axis contributes `offsets[i]` to the element index. Every weight axis of the FG map uses + it, and the net1 biases use it to take copy 0 of each group of eight. The index range is checked when the map is + loaded (smallest and largest offset); a list of the wrong length, a non-integer, or `offsets` together with `stride` + or `perm` is "converter data damaged". +- `"channel_order": "storage"` (the form of the map's first revision: weight tensors as the stored spans, 1-D) is + still accepted, only in a version-1 map of preset FG; the converter reads the tensors the same way either way. `tests/run_tests.py` pins the map's SHA-256 (`FG_MAP_SHA256`), checks its sources and stages against [`clean/fg/layout.py`](../fg/layout.py), and converts a synthetic library with our own random blobs in exactly the map's diff --git a/clean/converter/tests/run_tests.py b/clean/converter/tests/run_tests.py index fad0923d..91a22d12 100644 --- a/clean/converter/tests/run_tests.py +++ b/clean/converter/tests/run_tests.py @@ -407,40 +407,46 @@ def test_l_shaped(r, m_map_path): MSG_NO_PRESET_FG = "This DLSS Frame Generation file has no frame-generation model. Version 310.1 or newer is needed." -# data/fg.v1.map.json as the spec side delivered it (v1, 2026-11-14): its bytes must not change without a new digest here -FG_MAP_SHA256 = "6dbdc84945817affcbbd8e50bdc1ea6976636137e5c4edd64b5481cc0d51a940" +# data/fg.v1.map.json as the spec side delivered it (revision v1.1, natural order, 2026-11-14): its bytes must not change +# without a new digest here +FG_MAP_SHA256 = "b32d9195ab76e14f9c4e318bc55e5d8def83698e0a10d7581689fedf6e1c7ad5" def test_fg_real_map(r, fgmap): - """Frame generation (#96): the delivered map (data/fg.v1.map.json, the spec side's v1: map version 1, "preset": "FG", - channel_order "storage", 67 block sources A01..A17, B01w/B01b..B25w/B25b, 42 stages, bias reads by explicit offsets). - Its bytes are pinned by digest; its layout is the one of clean/fg/layout.py; it validates, and a file without the - blobs gives preset FG's message.""" + """Frame generation (#96): the delivered map (data/fg.v1.map.json, the spec side's revision v1.1: map version 1, + "preset": "FG", channel_order "natural", 67 block sources A01..A17, B01w/B01b..B25w/B25b, 42 stages; every weight + tensor W in natural order [out, in, 3, 3] or [out, in] by explicit offsets; net1 biases by offsets, net2 biases by + stride). Its bytes are pinned by digest; its layout is the one of clean/fg/layout.py; it validates, and a file without + the blobs gives preset FG's message.""" with open(fgmap, "rb") as f: raw = f.read() r.check("FG map: file digest", hashlib.sha256(raw).hexdigest() == FG_MAP_SHA256, hashlib.sha256(raw).hexdigest()) m = json.loads(raw) L = cases._fg_layout() names = list(m["sources"]) - r.check("FG map: version 1, preset FG, channel_order storage, key from A01, no perms", - (m["version"], m["preset"], m["channel_order"], m["key"]["from"], m["perms"]) == (1, "FG", "storage", "A01", {})) + r.check("FG map: version 1, preset FG, channel_order natural, key from A01, no perms", + (m["version"], m["preset"], m["channel_order"], m["key"]["from"], m["perms"]) == (1, "FG", "natural", "A01", {})) r.check("FG map: 67 sources in upload order with the layout's lengths", names == ["A%02d" % i for i in range(1, 18)] + ["B%02d%s" % (i, x) for i in range(1, 26) for x in "wb"] and [m["sources"][n]["length"] for n in names] == [b.nbytes for b in L.blobs()]) stages = m["stages"] r.check("FG map: 42 stages dl1.l01..l17, dl2.l01..l25", [s["stage"] for s in stages] == ["dl1.l%02d" % i for i in range(1, 18)] + ["dl2.l%02d" % i for i in range(1, 26)]) - ok1 = all([t["name"] for t in s["tensors"]] == ["W_storage", "b"] and - s["tensors"][0]["shape"] == [l.weight_elements] and s["tensors"][0]["base"] == 0 and + def offsets_only(t): + return all(set(a) == {"offsets"} for a in t["axes"]) + ok1 = all([t["name"] for t in s["tensors"]] == ["W", "b"] and + s["tensors"][0]["shape"] == ([l.out, l.cin, 3, 3] if l.taps == 9 else [l.out, l.cin]) and + s["tensors"][0]["base"] == 0 and offsets_only(s["tensors"][0]) and s["tensors"][1]["base"] == l.bias_offset and s["tensors"][1]["axes"] == [{"offsets": [L.net1_bias_index(c) for c in range(l.out)]}] for s, l in zip(stages[:17], L.NET1)) - r.check("FG map: net1 stages read the weight span and copy 0 of each bias group, skipping the zero area", ok1) - ok2 = all([t["name"] for t in s["tensors"]] == ["W_storage", "b_storage"] and + r.check("FG map: net1 stages read natural weights and copy 0 of each bias group, skipping the zero area", ok1) + ok2 = all([t["name"] for t in s["tensors"]] == ["W", "b"] and [t["src"] for t in s["tensors"]] == ["B%02dw" % l.index, "B%02db" % l.index] and - s["tensors"][0]["shape"] == [l.weight_elements] and s["tensors"][1]["shape"] == [l.out] + s["tensors"][0]["shape"] == [l.out, l.cin_used, 3, 3] and offsets_only(s["tensors"][0]) and + s["tensors"][1]["shape"] == [l.out] and s["tensors"][1]["axes"] == [{"stride": 1}] for s, l in zip(stages[17:], L.NET2)) - r.check("FG map: net2 stages read the whole weight and bias blobs", ok2) + r.check("FG map: net2 stages read natural weights (layer 1: its 10 used inputs) and the whole bias blob", ok2) fake = r.write("fg-real/random.dll", random_bytes_for_test(1 << 20)) code, so, se = r.run(fgmap, [fake], r.path("fg-real", "out", "x")[:-2]) r.check("FG map: validates; a file without the blobs -> exit 12, preset FG's message", @@ -480,13 +486,21 @@ def test_fg(r, fgmap): del plain["preset"] pp = r.write("fg/map-no-field.json", plain) code, so, se = r.run(pp, [dll], r.path("fg", "out-fail", "x")[:-2]) - r.check("FG map without its field and without --preset: read as preset M, whose maps are natural -> damaged", - code == EXIT["map_damaged"] and MSG["map_damaged"] in so and "channel_order" in se, so + se[-300:]) - natural = copy.deepcopy(plain) - natural["channel_order"] = "natural" - code, so, se = r.run(r.write("fg/map-no-field-natural.json", natural), [dll], r.path("fg", "out-fail", "x")[:-2]) - r.check("...and as natural, preset M's sources W, D and K are missing -> damaged", - code == EXIT["map_damaged"] and "missing source W" in se, so + se[-300:]) + r.check("FG map without its field and without --preset: read as preset M, W, D and K missing -> damaged", + code == EXIT["map_damaged"] and MSG["map_damaged"] in so and "missing source W" in se, so + se[-300:]) + storage = copy.deepcopy(plain) + storage["channel_order"] = "storage" + code, so, se = r.run(r.write("fg/map-no-field-storage.json", storage), [dll], r.path("fg", "out-fail", "x")[:-2]) + r.check("...and with channel_order storage, which only preset FG may use -> damaged", + code == EXIT["map_damaged"] and "channel_order" in se, so + se[-300:]) + named_storage = copy.deepcopy(case.map) + named_storage["channel_order"] = "storage" # the v1 form: names what the tensors hold, read the same way + nsp = r.write("fg/map-storage.json", named_storage) + out3 = r.path("fg", "out-storage", "x")[:-2] + code, so, se = r.run(nsp, [dll], out3) + r.check("FG map with channel_order storage (map v1's form): converts the same tensors", code == 0, so + se[-300:]) + with open(nsp, "rb") as f: + check_output(r, "FG storage order", case, out3, f.read()) out2 = r.path("fg", "out-hint", "x")[:-2] code, so, se = r.run(pp, [dll], out2, extra=["--preset", "FG"]) r.check("FG map without its field, --preset FG: converts", code == 0 and "preset FG" in se, so + se[-300:]) @@ -514,7 +528,12 @@ def test_fg(r, fgmap): # a map that reads net1's zero area (or a bias copy other than 0) meets the test's NaN: exit 22. This shows the # success case above really skipped them. - for label, fn in (("zero area", lambda t: t.update(base=t["shape"][0])), + def zero_area_base(t): # net1 blob: the zero area starts right after the out * K weights + n = 1 + for d in t["shape"]: + n *= d + t.update(base=n) + for label, fn in (("zero area", zero_area_base), ("bias copy 1", lambda t: t.update(base=t["base"] + 8))): bad = copy.deepcopy(case.map) st = bad["stages"][0] diff --git a/clean/fg/FORMATS.md b/clean/fg/FORMATS.md index ed6e8e39..b25fc565 100644 --- a/clean/fg/FORMATS.md +++ b/clean/fg/FORMATS.md @@ -17,21 +17,23 @@ delivered by the spec side; the code never guesses it (it raises, or takes the c - Splitting a blob into its parts: [`reference/blobs.py`](reference/blobs.py). net1: the weights in stored order, the zero area checked to hold only +0 / -0, the bias as copy 0 of each group of eight with the other fifteen copies checked to be bit-identical (`check=False` skips both checks). net2: weight and bias blob sizes checked. The weights - stay flat until the in-blob axis order (OPEN item 2) is delivered. + come out flat in stored order; [`reference/natural.py`](reference/natural.py) puts them in natural order with the + map's own offsets. +- net1's blob 2 is a 1 x 1 convolution (32 -> 64). net2's first layer stores 16 input channels and reads 10: its + natural weights are [32, 10, 3, 3]. ## Converter map - Map version 1 with `"preset": "FG"` (converter README, "Preset FG"): one block source per blob, located by length and hashes, `f16` reads. net1's zero area is skipped by the tensor's base; its bias is read as copy 0 of each group of eight (`layout.net1_bias_index`). -- The map is `data/fg.v1.map.json` (the spec side's v1; digest pinned in `tests/test_fg_map.py` and the converter's - tests): sources `A01`..`A17` (net1) and `B01w`/`B01b`..`B25w`/`B25b` (net2), stages `dl1.l01`..`dl1.l17` and - `dl2.l01`..`dl2.l25`, in upload order, exactly the blobs and spans of `layout.py`. Per stage: `W_storage` (the - weight span as stored, 1-D) and `b` (net1: copy 0 of each bias group, natural order) or `b_storage` (net2: the bias - blob as stored). -- `"channel_order": "storage"`: the weights are not yet in natural axes. The natural view comes with a later map - revision (v1.1), with the same shapes and spans; whether net2's stored bias order is the natural channel order is - confirmed then too (OPEN until it is). +- The map is `data/fg.v1.map.json`, the spec side's revision v1.1 (digest pinned in `tests/test_fg_map.py` and the + converter's tests): sources `A01`..`A17` (net1) and `B01w`/`B01b`..`B25w`/`B25b` (net2), stages `dl1.l01`..`dl1.l17` + and `dl2.l01`..`dl2.l25`, in upload order, exactly the blobs and spans of `layout.py`. `"channel_order": "natural"`. + Per stage: `W` in natural order, [out, in, 3, 3] for 3 x 3 layers and [out, in] for 1 x 1 layers, every axis by + explicit offsets into the blob; `b` [out] (net1: copy 0 of each bias group; net2: the bias blob, natural order). +- The first revision (v1) gave the weights as stored (`"channel_order": "storage"`, 1-D `W_storage`); the converter + still accepts that form for preset FG. - A conversion of a real library is checked by digests only (the converter compares every stage digest the map gives); no value or byte of it is ever written into the repository or any public text. `tools/real_check.py` runs that check and keeps only the verdict and digests (`python -m clean.fg.tools.real_check --exe --dll @@ -40,7 +42,8 @@ delivered by the spec side; the code never guesses it (it raises, or takes the c ## CPU reference (`reference/ops.py`) - Tensors are channel-first `x[c, y, x]`; weights use the module's own canonical order `w[out, ky, kx, in]` - (`weight_shape(layer)` for every layout layer). Converting a blob into that order waits for item 2 below. + (`weight_shape(layer)` for every layout layer). `natural.py` turns the map's natural `W` ([out, in, ky, kx] or + [out, in]) into that order (`to_canonical`), and stored blob weights into natural ones with the map's offsets. - Settled and implemented: float16 operands and outputs; convolution with bias, one float16 rounding of the output, then ReLU; 2x pooling over 2 x 2 blocks; bilinear 2x upscale in the align-corners form (output sample i reads input position i (n - 1) / (2n - 1)); element-wise add and channel concatenation; net1's features: luma with fixed RGB @@ -56,17 +59,16 @@ delivered by the spec side; the code never guesses it (it raises, or takes the c ## Forward pass (`reference/forward.py`) -- Parameters per layer (layout names `net1_01`..`net2_25`): storage-order weights and the bias, from blobs - (`params_from_blobs`) or from the converter's `--raw` output of the preset-FG map (`params_from_raw`, stages - `dl1.lNN` / `dl2.lNN`; every value checked to be exact in float16). +- Parameters per layer (layout names `net1_01`..`net2_25`): canonical natural weights `[out, k, k, in]` and the bias, + from blobs (`params_from_blobs`: stored weights gathered with the map's offsets) or from the converter's `--raw` + output of the preset-FG map (`params_from_raw`, stages `dl1.lNN` / `dl2.lNN`, tensors `W` and `b`; every value + checked to be exact in float16). - `run_layer`: one convolution with `ops.conv2d`. `run_graph`: a network as a list of steps (`conv` with its layer and ReLU flag, `pool` with its kind, `upscale`, `add`, `concat`, `slice`), checked before it runs (known steps, exact fields, buffers written once before they are read, each layer used at most once). `net1_forward` adds the 2 x 2 fold before and the unfold (16 values per cell to 4 per pixel) after; `net2_forward` returns the named buffers. -- Required arguments (OPEN): `wiring` (the steps); `weight_view` (storage to natural `[out, k, k, in]`: map v1 holds - the weights as stored, the natural view comes with v1.1; `view_by_axes` covers a plain axis reorder); `pad`; `blob2` - ("1x1" runs net1's blob 2 as a 1 x 1 convolution, "2x2" raises `OpenItem`); `fold_order`. The real wiring plugs in - as data; the layers do not change. +- Required arguments (OPEN): `wiring` (the steps), `pad`, `fold_order`. The weight order and net1's blob 2 are settled + by map v1.1 and are no longer arguments. The real wiring plugs in as data; the layers do not change. ## Configuration (`reference/config.py`) @@ -81,10 +83,10 @@ delivered by the spec side; the code never guesses it (it raises, or takes the c ## OPEN (waiting for the spec side) -1. The converter map's natural-order revision (v1.1). v1 is delivered (`data/fg.v1.map.json`, weights as stored). -2. The in-blob axis order of the weights (tap, input channel, output channel, any tiling), for both networks. +1. (closed: map v1.1, natural order, is `data/fg.v1.map.json`.) +2. (closed: the in-blob axis order is the map's offsets.) 3. Which launch reads which blob (upload order is known; launch order is not). -4. net1's blob 2: a 1 x 1 convolution or a 2 x 2 one. +4. (closed: net1's blob 2 is a 1 x 1 convolution.) 5. Both networks' grid sizes relative to the output size. 6. What the UI-recomposition preset changes in the stage order. 7. Launch order, the motion-field scatter, the pull pyramid and the UI handling (part 3). diff --git a/clean/fg/README.md b/clean/fg/README.md index fbc0029e..89687d4a 100644 --- a/clean/fg/README.md +++ b/clean/fg/README.md @@ -11,10 +11,12 @@ front end or the launcher yet. Status, open items and formats: [FORMATS.md](FORM | `tests/test_fg_layout.py` | the table against the totals the spec side gives | | `reference/ops.py` | NumPy CPU reference of the networks' building blocks: float16 convolution (3 x 3, 1 x 1) with bias and ReLU, 2x pooling, bilinear 2x upscale (align corners), element-wise combines, net1's input features and 2 x 2 fold; each open behaviour is a required argument or raises `OpenItem` | | `tests/test_fg_reference.py` | the building blocks against plain loop versions, on synthetic data | -| `reference/forward.py` | both networks' forward pass: each layer from its stage's parameters (from blobs or the converter's raw output), and a network run from a wiring the caller supplies (conv / pool / upscale / add / concat / slice steps); the wiring, the natural weight order, the border rule and net1's blob 2 are required arguments | +| `reference/forward.py` | both networks' forward pass: each layer from its stage's natural parameters (from blobs or the converter's raw output), and a network run from a wiring the caller supplies (conv / pool / upscale / add / concat / slice steps); the wiring, the border rule and the fold order are required arguments | | `tests/test_fg_forward.py` | every layer of both networks against a direct NumPy convolution on synthetic weights; each step kind; wiring checks; stand-in wirings against layers composed by hand; parameters from blobs and from raw files | | `../converter` (preset FG) | the converter reads a version-1 map with `"preset": "FG"`: one block source per weight blob; see the converter's README, "Preset FG" | -| `../../data/fg.v1.map.json` | the spec side's converter map v1 (weights as stored); `tests/test_fg_map.py` pins its digest and checks it against `layout.py` | +| `../../data/fg.v1.map.json` | the spec side's converter map, revision v1.1 (weights in natural order); `tests/test_fg_map.py` pins its digest and checks it against `layout.py` | +| `reference/natural.py` | the natural weight order from the map itself: its offsets as gather indices (stored blob weights to natural), natural to canonical `[out, k, k, in]` | +| `tests/test_fg_natural.py` | natural weights scattered into synthetic blobs with the map's gathers come back unchanged, for every layer; the gathers cover each weight span | | `tools/real_check.py` | runs the converter once on one given frame-generation library (execute-only) and records only the verdict, the map's digest, the file version and size, the matching stage digests and the converted file's digest; deletes the converted file. Offsets and bytes of the library are never recorded | | `tests/test_fg_real_check.py` | the tool on made-up converter output and a stand-in converter | | `reference/config.py` | the settled per-call configuration: the multi-frame intermediate time (one single-precision division), the index checks and flags, UI recomposition (FG preset A / B) with the profile values that force it | diff --git a/clean/fg/layout.py b/clean/fg/layout.py index 9990f665..3eeb2699 100644 --- a/clean/fg/layout.py +++ b/clean/fg/layout.py @@ -15,10 +15,10 @@ Network 2 ("net2"): two small encoder-decoders (sub-nets A and B), 25 layers, all 3 x 3, each a weight blob of 9 * in * out float16 followed by a bias blob of out float16 (50 blobs). -The blob order below is the order the library uploads them, which is also their data order. OPEN (not delivered yet; -see FORMATS.md): the in-blob axis order of the weights (tap, input and output channel, any tiling), which launch reads -which blob, whether net1's blob 2 is a 1 x 1 or a 2 x 2 convolution, the grid sizes of both networks relative to the -output, and the converter map itself. Nothing here guesses them. +The blob order below is the order the library uploads them, which is also their data order. The order of the weights +inside each blob is given by the converter map (data/fg.v1.map.json, revision v1.1: natural order by explicit offsets; +clean/fg/reference/natural.py). net1's blob 2 is a 1 x 1 convolution. OPEN (not delivered yet; see FORMATS.md): which +launch reads which blob and the grid sizes of both networks relative to the output. Nothing here guesses them. """ from dataclasses import dataclass @@ -32,12 +32,12 @@ class Net1Layer: index: int # 1-based, upload order out: int # output channels (= distinct bias values) k: int # taps * input channels - taps: object # 9 (3 x 3), 1 (1 x 1), or None where the reading is OPEN + taps: int # 9 (3 x 3) or 1 (1 x 1) @property def cin(self): - """Input channels, or None while the tap count is OPEN.""" - return None if self.taps is None else self.k // self.taps + """Input channels.""" + return self.k // self.taps @property def weight_elements(self): @@ -108,7 +108,7 @@ def name(self): def _net1(): rows = [ # (out, K, taps) (32, 432, 9), # 3 x 3, 48 -> 32 (level 0) - (64, 32, None), # 32 -> 64: 1 x 1, or 2 x 2 over 8 channels (OPEN) + (64, 32, 1), # 32 -> 64, 1 x 1 (map v1.1) (128, 576, 9), (128, 1152, 9), (256, 1152, 9), diff --git a/clean/fg/reference/blobs.py b/clean/fg/reference/blobs.py index 585ae26d..bef40624 100644 --- a/clean/fg/reference/blobs.py +++ b/clean/fg/reference/blobs.py @@ -9,8 +9,8 @@ holds only zeros (+0 or -0) and that the 16 copies of every group are bit-identical, unless told not to. - net2: a weight blob of 9 * in * out values and a bias blob of out values; split_net2 checks the sizes. -The order of the weights inside a blob (tap, input and output channel, any tiling) is OPEN, so the weights stay flat in -stored order; reshaping them into clean/fg/reference/ops.py's canonical order waits for it. +The weights stay flat in stored order here; clean/fg/reference/natural.py puts them in natural order with the converter +map's own offsets. """ import numpy as np diff --git a/clean/fg/reference/forward.py b/clean/fg/reference/forward.py index 9ec8929a..fa827ba9 100644 --- a/clean/fg/reference/forward.py +++ b/clean/fg/reference/forward.py @@ -1,25 +1,22 @@ # SPDX-License-Identifier: MIT """Frame generation (issue #96): CPU reference of both networks' forward pass, as far as it is delivered. -Written for this project. The layers are settled: their shapes (clean/fg/layout.py), the weights and biases the -converter map gives per stage, float16 convolutions with bias, ReLU, 2x pooling, bilinear 2x upscale, element-wise -combines, and net1's 2 x 2 fold (clean/fg/reference/ops.py). How they are connected is not delivered, so the network -is run from a wiring the caller supplies. When the real wiring arrives it is passed in as data; the layers do not -change. +Written for this project. The layers are settled: their shapes (clean/fg/layout.py), the weights in natural order and +the biases the converter map gives per stage (data/fg.v1.map.json, revision v1.1; clean/fg/reference/natural.py), +float16 convolutions with bias, ReLU, 2x pooling, bilinear 2x upscale, element-wise combines, and net1's 2 x 2 fold +(clean/fg/reference/ops.py). net1's blob 2 is a 1 x 1 convolution. How the layers are connected is not delivered, so a +network is run from a wiring the caller supplies. When the real wiring arrives it is passed in as data; the layers do +not change. Required arguments for what is OPEN (clean/fg/FORMATS.md): - `wiring`: the list of steps (which layer reads which buffers, where the pooling, upscales, combines and channel splits sit, ReLU after each convolution, the pooling kind). Format: see run_graph. -- `weight_view`: a function (storage weights [n] float16, layer) -> natural weights [out, k, k, in]. The converter - map v1 gives the weights as stored (the matrix unit's own tiling), so the natural view comes with map v1.1. - `view_by_axes` makes one for a plain axis order, for tests and for a map revision that is a plain reorder. - `pad`: the border rule of the 3 x 3 convolutions (ops.PAD_MODES). -- `blob2`: net1's blob 2 is a 1 x 1 or a 2 x 2 convolution. "1x1" runs; "2x2" raises OpenItem (its stride and its - grouping of the 32 input values into 4 taps x 8 channels are not delivered). +- `fold_order`: the order of the values inside net1's 48-value cells. -Parameters are {layer name: (storage weights [n] float16, bias [out] float16)} with the layout's layer names -(net1_01 .. net1_17, net2_01 .. net2_25): from synthetic or converted blobs (params_from_blobs) or from the -converter's raw output (params_from_raw: stages dl1.lNN / dl2.lNN of the preset-FG map). +Parameters are {layer name: (weights [out, k, k, in] float16, bias [out] float16)} with the layout's layer names +(net1_01 .. net1_17, net2_01 .. net2_25): from blobs (params_from_blobs: stored weights put in natural order by the +map's own offsets) or from the converter's raw output (params_from_raw: stages dl1.lNN / dl2.lNN, tensors W and b). """ import os @@ -27,102 +24,75 @@ from clean.fg import layout as L from clean.fg.reference import blobs as _blobs +from clean.fg.reference import natural as _natural from clean.fg.reference import ops -from clean.fg.reference.ops import OpenItem LAYERS = {l.name: l for l in list(L.NET1) + list(L.NET2)} -BLOB2_FORMS = ("1x1", "2x2") # ---- parameters ------------------------------------------------------------------------------------------------- -def params_from_blobs(blob_bytes, *, check=True): - """{layer name: (weights, bias)} from {blob name: bytes} (layout.blobs() names), via blobs.split_all.""" - return _blobs.split_all(blob_bytes, check=check) +def params_from_blobs(blob_bytes, m=None, *, check=True): + """{layer name: (canonical weights, bias)} from {blob name: bytes} (layout.blobs() names): blobs.split_all, then the + map's natural view (m: the parsed map; default data/fg.v1.map.json).""" + m = m if m is not None else _natural.load_map() + return _natural.canonical_params(_blobs.split_all(blob_bytes, check=check), m) -def map_stage_name(layer): - """The preset-FG map's stage of a layout layer: net1_NN -> dl1.lNN, net2_NN -> dl2.lNN.""" - net, idx = layer.name.split("_") - return "dl%s.l%s" % (net[-1], idx) +map_stage_name = _natural.stage_name -def params_from_raw(raw_dir): - """{layer name: (weights, bias)} from the converter's --raw output (raw//.bin, float32 little - endian; tensors W_storage and b (net1) or b_storage (net2)). Every value must be exact in float16.""" +def params_from_raw(raw_dir, m=None): + """{layer name: (canonical weights, bias)} from the converter's --raw output of the preset-FG map + (raw//W.bin in the map's natural shape, raw//b.bin; float32 little endian). Every value must be exact + in float16.""" + m = m if m is not None else _natural.load_map() out = {} for name, l in LAYERS.items(): st = os.path.join(raw_dir, map_stage_name(l)) - w = np.fromfile(os.path.join(st, "W_storage.bin"), dtype=", "in": , "out": , "relu": true|false} {"op": "pool", "in": , "out": , "kind": "max"|"avg"} @@ -175,8 +144,7 @@ def run_graph(wiring, inputs, params, *, weight_view, pad, blob2=None): for s in wiring: kind = s["op"] if kind == "conv": - y = run_layer(s["layer"], buf[s["in"]], params, weight_view=weight_view, pad=pad, relu_after=s["relu"], - blob2=blob2) + y = run_layer(s["layer"], buf[s["in"]], params, pad=pad, relu_after=s["relu"]) elif kind == "pool": y = ops.pool2x(buf[s["in"]], kind=s["kind"]) elif kind == "upscale": @@ -197,21 +165,21 @@ def run_graph(wiring, inputs, params, *, weight_view, pad, blob2=None): return buf -def net1_forward(features, params, *, wiring, weight_view, pad, blob2, fold_order, output): +def net1_forward(features, params, *, wiring, pad, fold_order, output): """net1 on its per-pixel features [10, H, W] (ops.net1_features): fold 2 x 2 into 48-value cells (fold_order: OPEN, required), run the wiring on the input buffer "cells", and unfold the buffer named `output` (16 values per cell) back to 4 values per pixel -> [4, H, W].""" if features.shape[0] != ops.NET1_FEATURES: raise ValueError("net1 takes %d features per pixel" % ops.NET1_FEATURES) cells = ops.fold2x2(features, order=fold_order) - buf = run_graph(wiring, {"cells": cells}, params, weight_view=weight_view, pad=pad, blob2=blob2) + buf = run_graph(wiring, {"cells": cells}, params, pad=pad) out = buf[output] if out.shape[0] != 16: raise ValueError("net1's output has 16 values per cell, got %d" % out.shape[0]) return ops.unfold2x2(out, 4, order=fold_order) -def net2_forward(inputs, params, *, wiring, weight_view, pad, outputs): +def net2_forward(inputs, params, *, wiring, pad, outputs): """net2 on its input buffers {name: [c, H, W]}: runs the wiring and returns {name: buffer} for `outputs`.""" - buf = run_graph(wiring, inputs, params, weight_view=weight_view, pad=pad) + buf = run_graph(wiring, inputs, params, pad=pad) return {n: buf[n] for n in outputs} diff --git a/clean/fg/reference/natural.py b/clean/fg/reference/natural.py new file mode 100644 index 00000000..01245b66 --- /dev/null +++ b/clean/fg/reference/natural.py @@ -0,0 +1,100 @@ +# SPDX-License-Identifier: MIT +"""Frame generation (issue #96): the natural order of the weights, taken from the converter map itself. + +Written for this project. The preset-FG map (data/fg.v1.map.json, revision v1.1) gives every weight tensor `W` in +natural order through explicit per-axis offsets into its blob: shape [out, in, 3, 3] for 3 x 3 layers and [out, in] for +1 x 1 layers. This module turns those offsets into gather indices, so stored weights (blobs.split_*) become natural +weights with exactly the converter's element mapping, and converts natural weights into ops.py's canonical +[out, k, k, in]. Nothing here restates the storage order: the map is the only source of it. +""" +import json +import os + +import numpy as np + +from clean.fg import layout as L + +DEFAULT_MAP = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..", "data", + "fg.v1.map.json")) + + +def load_map(path=DEFAULT_MAP): + with open(path, "rb") as f: + m = json.load(f) + if m.get("preset") != "FG" or m.get("channel_order") != "natural": + raise ValueError("%s: not a natural-order preset-FG map" % path) + return m + + +def stage_name(layer): + """The map's stage of a layout layer: net1_NN -> dl1.lNN, net2_NN -> dl2.lNN.""" + net, idx = layer.name.split("_") + return "dl%s.l%s" % (net[-1], idx) + + +def _stage(m, layer): + name = stage_name(layer) + for st in m["stages"]: + if st["stage"] == name: + return st + raise KeyError("map has no stage %s" % name) + + +def _tensor(st, name): + for t in st["tensors"]: + if t["name"] == name: + return t + raise KeyError("stage %s has no tensor %s" % (st["stage"], name)) + + +def gather_index(tensor): + """Element index into the tensor's source for every element of the tensor (row-major over its shape): base plus, + per axis, offsets[i] or stride * i (the converter's index rule without perms; the FG map has none).""" + idx = np.array(tensor["base"], dtype=np.int64) + for ax, n in zip(tensor["axes"], tensor["shape"]): + if "perm" in ax: + raise ValueError("perms are not used by the preset-FG map") + o = np.asarray(ax["offsets"], dtype=np.int64) if "offsets" in ax else ax["stride"] * np.arange(n, dtype=np.int64) + if o.shape != (n,): + raise ValueError("axis length does not match the shape") + idx = idx[..., None] + o + return idx + + +def to_canonical(natural): + """Natural [out, in, 3, 3] or [out, in] -> ops.py's canonical [out, k, k, in].""" + a = np.asarray(natural) + if a.ndim == 4: + return a.transpose(0, 2, 3, 1) + if a.ndim == 2: + return a[:, None, None, :] + raise ValueError("natural weights are 4-D (3 x 3) or 2-D (1 x 1)") + + +def natural_weights(layer, stored, m): + """Natural weights (map shape) of one layer from its stored weight span (blobs.split_net1 / split_net2).""" + t = _tensor(_stage(m, layer), "W") + idx = gather_index(t) + stored = np.asarray(stored).reshape(-1) + if idx.min() < 0 or idx.max() >= stored.size: + raise ValueError("%s: the map reads outside the stored weights" % layer.name) + return stored[idx] + + +def natural_bias_index(layer, m): + """Element indices of the bias in its source (net1: into the whole blob; net2: into the bias blob).""" + return gather_index(_tensor(_stage(m, layer), "b")) + + +def weight_shape(layer, m): + """The map's natural shape of a layer's W.""" + return tuple(_tensor(_stage(m, layer), "W")["shape"]) + + +def canonical_params(stored_params, m): + """{layer: (stored weights, bias)} (blobs.split_all) -> {layer: (canonical weights [out, k, k, in] float16, bias)}.""" + out = {} + for l in list(L.NET1) + list(L.NET2): + w, b = stored_params[l.name] + out[l.name] = (to_canonical(natural_weights(l, w, m)), np.asarray(b)) + return out diff --git a/clean/fg/reference/ops.py b/clean/fg/reference/ops.py index 459dc384..c25c0142 100644 --- a/clean/fg/reference/ops.py +++ b/clean/fg/reference/ops.py @@ -10,7 +10,7 @@ argument (the caller states it, and tests run every allowed value), or the function raises OpenItem. Tensors are channel-first: x[c, y, x]. Weights here are in this module's own canonical order w[out, ky, kx, in]; -the order inside the library's blobs is OPEN, so converting a blob into this order is not part of this module. +converting stored blob weights into this order is clean/fg/reference/natural.py's job (the converter map's offsets). """ import numpy as np @@ -195,13 +195,11 @@ def unfold2x2(cells, c, *, order): # ---- the layers of clean/fg/layout.py in this module's canonical order ----------------------------------------------- def weight_shape(layer): - """Canonical weight shape [out, k, k, in] of a layout layer (layout.Net1Layer or layout.Net2Layer). net1's blob 2 - (1 x 1 or 2 x 2) raises OpenItem.""" + """Canonical weight shape [out, k, k, in] of a layout layer (layout.Net1Layer or layout.Net2Layer). `in` is the + number of input channels that carry data: net2's first layer stores 16 and reads 10 (the map reads only those).""" taps = getattr(layer, "taps", 9) - if taps is None: - raise OpenItem("net1 blob 2: 1 x 1 or 2 x 2") k = 3 if taps == 9 else 1 - return (layer.out, k, k, layer.cin) + return (layer.out, k, k, getattr(layer, "cin_used", layer.cin)) # ---- the networks as a whole ---------------------------------------------------------------------------------------- diff --git a/clean/fg/tests/test_fg_forward.py b/clean/fg/tests/test_fg_forward.py index 0cd16498..cfe24ecf 100644 --- a/clean/fg/tests/test_fg_forward.py +++ b/clean/fg/tests/test_fg_forward.py @@ -13,32 +13,19 @@ import numpy as np from numpy.lib.stride_tricks import sliding_window_view -from clean.fg import layout as L -from clean.fg.reference import blobs as B from clean.fg.reference import forward as F +from clean.fg.reference import natural as N from clean.fg.reference import ops -ORDER = "out in ky kx" # the stand-in storage order of the synthetic weights - def f16(x): return np.asarray(x, dtype=np.float64).astype(np.float16).astype(np.float64) -def natural_shape(l): - return (l.out, 1, 1, l.k) if l.name == "net1_02" else ops.weight_shape(l) - - def synthetic_params(rng, scale=0.05): - """{layer: (storage weights, bias)} with natural weights stored in ORDER; also returns the natural weights.""" - params, natural = {}, {} - for name, l in F.LAYERS.items(): - cout, k, _, cin = natural_shape(l) - nat = rng.uniform(-scale, scale, (cout, k, k, cin)).astype(np.float16) - stored = nat.transpose(0, 3, 1, 2).reshape(-1) # out, in, ky, kx - params[name] = (stored, rng.uniform(-0.1, 0.1, cout).astype(np.float16)) - natural[name] = nat.astype(np.float64) - return params, natural + """{layer: (canonical weights [out, k, k, in] float16, bias float16)} of every layer.""" + return {name: (rng.uniform(-scale, scale, ops.weight_shape(l)).astype(np.float16), + rng.uniform(-0.1, 0.1, l.out).astype(np.float16)) for name, l in F.LAYERS.items()} def direct_conv(x, w, b, pad, relu): @@ -53,72 +40,52 @@ def direct_conv(x, w, b, pad, relu): return np.maximum(y, 0.0) if relu else y -VIEW = F.view_by_axes(ORDER) - - class Layers(unittest.TestCase): @classmethod def setUpClass(cls): - cls.params, cls.natural = synthetic_params(np.random.default_rng(1)) + cls.params = synthetic_params(np.random.default_rng(1)) def test_every_layer_against_direct(self): rng = np.random.default_rng(2) for name, l in F.LAYERS.items(): - cin = natural_shape(l)[3] - x = f16(rng.uniform(-1, 1, (cin, 5, 4))) + w, b = self.params[name] + x = f16(rng.uniform(-1, 1, (w.shape[3], 5, 4))) for pad in ("zero", "mirror"): - got = F.run_layer(name, x, self.params, weight_view=VIEW, pad=pad, relu_after=True, blob2="1x1") - want = direct_conv(x, self.natural[name], self.params[name][1], pad, True) - np.testing.assert_array_equal(got, want, err_msg="%s pad=%s" % (name, pad)) - got = F.run_layer(name, x, self.params, weight_view=VIEW, pad="replicate", relu_after=False, blob2="1x1") - np.testing.assert_array_equal(got, direct_conv(x, self.natural[name], self.params[name][1], "replicate", False)) + got = F.run_layer(name, x, self.params, pad=pad, relu_after=True) + np.testing.assert_array_equal(got, direct_conv(x, w, b, pad, True), err_msg="%s pad=%s" % (name, pad)) + got = F.run_layer(name, x, self.params, pad="replicate", relu_after=False) + np.testing.assert_array_equal(got, direct_conv(x, w, b, "replicate", False)) - def test_blob2_is_required(self): - x = f16(np.ones((32, 2, 2))) - with self.assertRaises(ValueError): - F.run_layer("net1_02", x, self.params, weight_view=VIEW, pad="zero", relu_after=True) - with self.assertRaises(ops.OpenItem): - F.run_layer("net1_02", x, self.params, weight_view=VIEW, pad="zero", relu_after=True, blob2="2x2") - # other layers do not need it - F.run_layer("net1_16", x, self.params, weight_view=VIEW, pad="zero", relu_after=True) + def test_shapes(self): + self.assertEqual(self.params["net1_02"][0].shape, (64, 1, 1, 32)) # blob 2: 1 x 1 + self.assertEqual(self.params["net2_01"][0].shape, (32, 3, 3, 10)) # 10 input channels carry data + self.assertEqual(self.params["net2_14"][0].shape, (16, 3, 3, 18)) def test_required_arguments(self): x = f16(np.ones((32, 2, 2))) - for missing in ("weight_view", "pad", "relu_after"): - kw = {"weight_view": VIEW, "pad": "zero", "relu_after": True} + for missing in ("pad", "relu_after"): + kw = {"pad": "zero", "relu_after": True} del kw[missing] with self.assertRaises(TypeError, msg=missing): F.run_layer("net1_16", x, self.params, **kw) - def test_weight_view_checks(self): + def test_parameter_checks(self): x = f16(np.ones((32, 2, 2))) - bad = lambda w, l: np.zeros((1, 1, 1, 1)) # noqa: E731 - with self.assertRaises(ValueError): - F.run_layer("net1_16", x, self.params, weight_view=bad, pad="zero", relu_after=True) - with self.assertRaises(ValueError): - F.view_by_axes("out in ky") p = dict(self.params) - p["net1_16"] = (p["net1_16"][0][:-1], p["net1_16"][1]) + p["net1_16"] = (p["net1_16"][0][:, :, :, :-1], p["net1_16"][1]) with self.assertRaises(ValueError): - F.run_layer("net1_16", x, p, weight_view=VIEW, pad="zero", relu_after=True) - - def test_view_by_axes_orders(self): - rng = np.random.default_rng(3) - l = F.LAYERS["net2_14"] - nat = rng.standard_normal(ops.weight_shape(l)) - for order in ("out ky kx in", "out in ky kx", "in ky kx out", "ky kx in out"): - axes = order.split() - stored = nat.transpose([("out", "ky", "kx", "in").index(a) for a in axes]).reshape(-1) - np.testing.assert_array_equal(F.view_by_axes(order)(stored, l), nat, err_msg=order) + F.run_layer("net1_16", x, p, pad="zero", relu_after=True) + with self.assertRaises(KeyError): + F.run_layer("net9_01", x, self.params, pad="zero", relu_after=True) class GraphSteps(unittest.TestCase): def setUp(self): self.rng = np.random.default_rng(4) - self.params, _ = synthetic_params(np.random.default_rng(5)) + self.params = synthetic_params(np.random.default_rng(5)) def run_one(self, step, inputs): - return F.run_graph([step], inputs, self.params, weight_view=VIEW, pad="zero")[step["out"]] + return F.run_graph([step], inputs, self.params, pad="zero")[step["out"]] def test_pool_upscale_add_concat_slice(self): a = f16(self.rng.uniform(-2, 2, (3, 4, 6))) @@ -127,8 +94,8 @@ def test_pool_upscale_add_concat_slice(self): av = f16(a.reshape(3, 2, 2, 3, 2).mean(axis=(2, 4))) np.testing.assert_array_equal(self.run_one({"op": "pool", "in": "a", "out": "y", "kind": "max"}, {"a": a}), mx) np.testing.assert_array_equal(self.run_one({"op": "pool", "in": "a", "out": "y", "kind": "avg"}, {"a": a}), av) - # bilinear, align corners: separable linear interpolation at i * (n - 1) / (2n - 1) - def interp(v, n, axis): + + def interp(v, n, axis): # bilinear, align corners: linear interpolation at i * (n - 1) / (2n - 1) pos = np.arange(2 * n) * (n - 1) / (2 * n - 1) return np.apply_along_axis(lambda r: np.interp(pos, np.arange(n), r), axis, v) up = f16(interp(interp(a, 4, 1), 6, 2)) @@ -159,10 +126,9 @@ def test_wiring_checks(self): ] for w in bad: with self.assertRaises(ValueError, msg=w): - F.run_graph(w, x, self.params, weight_view=VIEW, pad="zero") + F.run_graph(w, x, self.params, pad="zero") with self.assertRaises(ValueError): - F.run_graph([{"op": "slice", "in": "x", "out": "s", "channels": [30, 40]}], x, self.params, - weight_view=VIEW, pad="zero") + F.run_graph([{"op": "slice", "in": "x", "out": "s", "channels": [30, 40]}], x, self.params, pad="zero") class Networks(unittest.TestCase): @@ -171,10 +137,11 @@ class Networks(unittest.TestCase): @classmethod def setUpClass(cls): - cls.params, cls.natural = synthetic_params(np.random.default_rng(6)) + cls.params = synthetic_params(np.random.default_rng(6)) def direct(self, name, x, pad, relu): - return direct_conv(x, self.natural[name], self.params[name][1], pad, relu) + w, b = self.params[name] + return direct_conv(x, w, b, pad, relu) def test_net1_stand_in(self): rng = np.random.default_rng(7) @@ -191,31 +158,29 @@ def test_net1_stand_in(self): {"op": "conv", "layer": "net1_17", "in": "d0b", "out": "out", "relu": False}, # 32 -> 16 ] for pad in ("zero", "replicate"): - got = F.net1_forward(feats, self.params, wiring=wiring, weight_view=VIEW, pad=pad, blob2="1x1", - fold_order="dy dx c", output="out") + got = F.net1_forward(feats, self.params, wiring=wiring, pad=pad, fold_order="dy dx c", output="out") cells = ops.fold2x2(feats, order="dy dx c") - e0 = self.direct("net1_01", cells, pad, True) - e1 = self.direct("net1_02", e0, pad, True) + e1 = self.direct("net1_02", self.direct("net1_01", cells, pad, True), pad, True) d1 = self.direct("net1_14", ops.pool2x(e1, kind="max"), pad, True) s1 = f16(ops.upscale2x_bilinear(d1) + e1) d0 = self.direct("net1_16", self.direct("net1_15", s1, pad, True), pad, True) - out = self.direct("net1_17", d0, pad, False) - want = ops.unfold2x2(out, 4, order="dy dx c") + want = ops.unfold2x2(self.direct("net1_17", d0, pad, False), 4, order="dy dx c") self.assertEqual(got.shape, (4, 8, 12)) np.testing.assert_array_equal(got, want, err_msg=pad) - for missing in ("wiring", "weight_view", "pad", "blob2", "fold_order", "output"): - kw = dict(wiring=wiring, weight_view=VIEW, pad="zero", blob2="1x1", fold_order="dy dx c", output="out") + for missing in ("wiring", "pad", "fold_order", "output"): + kw = dict(wiring=wiring, pad="zero", fold_order="dy dx c", output="out") del kw[missing] with self.assertRaises(TypeError, msg=missing): F.net1_forward(feats, self.params, **kw) with self.assertRaises(ValueError): # the output must have 16 values per cell - F.net1_forward(feats, self.params, wiring=wiring, weight_view=VIEW, pad="zero", blob2="1x1", - fold_order="dy dx c", output="d0") + F.net1_forward(feats, self.params, wiring=wiring, pad="zero", fold_order="dy dx c", output="d0") def test_net2_stand_in(self): rng = np.random.default_rng(8) + x10 = f16(rng.uniform(-1, 1, (10, 8, 8))) x18 = f16(rng.uniform(-1, 1, (18, 8, 8))) wiring = [ + {"op": "conv", "layer": "net2_01", "in": "x10", "out": "a", "relu": True}, # 10 -> 32 {"op": "conv", "layer": "net2_14", "in": "x18", "out": "h", "relu": True}, # 18 -> 16 {"op": "pool", "in": "h", "out": "hp", "kind": "avg"}, {"op": "conv", "layer": "net2_15", "in": "hp", "out": "q", "relu": True}, # 16 -> 32 @@ -227,7 +192,7 @@ def test_net2_stand_in(self): {"op": "add", "in": ["g0", "g1", "h"], "out": "s"}, {"op": "conv", "layer": "net2_25", "in": "s", "out": "y", "relu": False}, # 16 -> 8 ] - got = F.net2_forward({"x18": x18}, self.params, wiring=wiring, weight_view=VIEW, pad="mirror", outputs=["y", "q"]) + got = F.net2_forward({"x10": x10, "x18": x18}, self.params, wiring=wiring, pad="mirror", outputs=["y", "q", "a"]) h = self.direct("net2_14", x18, "mirror", True) q = self.direct("net2_15", ops.pool2x(h, kind="avg"), "mirror", True) g = self.direct("net2_24", self.direct("net2_16", q, "mirror", True), "mirror", False) @@ -235,6 +200,7 @@ def test_net2_stand_in(self): s = f16(f16(gu[:16] + gu[16:32]) + h) np.testing.assert_array_equal(got["y"], self.direct("net2_25", s, "mirror", False)) np.testing.assert_array_equal(got["q"], q) + np.testing.assert_array_equal(got["a"], self.direct("net2_01", x10, "mirror", True)) def test_same_layers_under_two_wirings(self): rng = np.random.default_rng(9) @@ -243,40 +209,33 @@ def test_same_layers_under_two_wirings(self): w2 = [{"op": "concat", "in": ["x", "x"], "out": "xx"}, {"op": "slice", "in": "xx", "out": "x2", "channels": [32, 64]}, {"op": "conv", "layer": "net1_16", "in": "x2", "out": "a", "relu": True}] - a1 = F.run_graph(w1, {"x": x}, self.params, weight_view=VIEW, pad="zero")["a"] - a2 = F.run_graph(w2, {"x": x}, self.params, weight_view=VIEW, pad="zero")["a"] + a1 = F.run_graph(w1, {"x": x}, self.params, pad="zero")["a"] + a2 = F.run_graph(w2, {"x": x}, self.params, pad="zero")["a"] np.testing.assert_array_equal(a1, a2) -class Params(unittest.TestCase): - def test_from_blobs_and_raw(self): - rng = np.random.default_rng(10) - blobs = {} - for l in L.NET1: - blobs[l.name] = B.build_net1(l, rng.uniform(-1, 1, l.weight_elements).astype(" map shape + self.assertEqual(nat.shape, N.weight_shape(l, m)) + nat.astype("= 0 and idx.max() < l.weight_elements, l.name) + if l.name == "net2_01": + self.assertEqual(idx.size, 9 * l.cin_used * l.out) # 10 of 16 stored inputs are read + else: + self.assertEqual(idx.size, l.weight_elements, l.name) # a permutation of the span + + def test_shapes(self): + for l in L.NET1: + want = (l.out, l.cin, 3, 3) if l.taps == 9 else (l.out, l.cin) + self.assertEqual(N.weight_shape(l, self.m), want, l.name) + for l in L.NET2: + self.assertEqual(N.weight_shape(l, self.m), (l.out, l.cin_used, 3, 3), l.name) + + def test_bias_indices(self): + for l in L.NET1: + np.testing.assert_array_equal(N.natural_bias_index(l, self.m), + [l.bias_offset + L.net1_bias_index(c) for c in range(l.out)]) + for l in L.NET2: + np.testing.assert_array_equal(N.natural_bias_index(l, self.m), np.arange(l.out)) + + def test_round_trip_through_blobs(self): + rng = np.random.default_rng(1) + blobs, want = {}, {} + for l in list(L.NET1) + list(L.NET2): + nat = rng.uniform(-1, 1, N.weight_shape(l, self.m)).astype("32): [weights | zero area | bias x16]", @@ -550,12 +550,15 @@ "stages": [ { "stage": "dl1.l01", - "digest": "227ca9c577799dabcce1421ebaa043eb0129d6654b789bc1ef60cfb291f4043f", + "digest": "7e23bf56ad8196947f695b76323c3d539c0eb6285dfced03fdd9b43d1f8adba4", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 13824 + 32, + 48, + 3, + 3 ], "dtype": "float32", "src": "A01", @@ -565,7 +568,106 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 3456, + 3472, + 3488, + 3504, + 3520, + 3536, + 3552, + 3568, + 6912, + 6928, + 6944, + 6960, + 6976, + 6992, + 7008, + 7024, + 10368, + 10384, + 10400, + 10416, + 10432, + 10448, + 10464, + 10480 + ] + }, + { + "offsets": [ + 0, + 1, + 4, + 5, + 8, + 9, + 12, + 13, + 2, + 3, + 6, + 7, + 10, + 11, + 14, + 15, + 128, + 129, + 132, + 133, + 136, + 137, + 140, + 141, + 130, + 131, + 134, + 135, + 138, + 139, + 142, + 143, + 256, + 257, + 260, + 261, + 264, + 265, + 268, + 269, + 258, + 259, + 262, + 263, + 266, + 267, + 270, + 271 + ] + }, + { + "offsets": [ + 0, + 1152, + 2304 + ] + }, + { + "offsets": [ + 0, + 384, + 768 + ] } ] }, @@ -623,12 +725,13 @@ }, { "stage": "dl1.l02", - "digest": "9c6c696569e67936e4f54efaaa8e56ae76d3c0c92b83fd8d219abd0884cac77d", + "digest": "0ce0da7b6346155e9b47a8c117ca8f1c685368d4cc48f93aa5e492439d11c037", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 2048 + 64, + 32 ], "dtype": "float32", "src": "A02", @@ -638,7 +741,108 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 256, + 272, + 288, + 304, + 320, + 336, + 352, + 368, + 512, + 528, + 544, + 560, + 576, + 592, + 608, + 624, + 768, + 784, + 800, + 816, + 832, + 848, + 864, + 880, + 1024, + 1040, + 1056, + 1072, + 1088, + 1104, + 1120, + 1136, + 1280, + 1296, + 1312, + 1328, + 1344, + 1360, + 1376, + 1392, + 1536, + 1552, + 1568, + 1584, + 1600, + 1616, + 1632, + 1648, + 1792, + 1808, + 1824, + 1840, + 1856, + 1872, + 1888, + 1904 + ] + }, + { + "offsets": [ + 0, + 1, + 4, + 5, + 8, + 9, + 12, + 13, + 2, + 3, + 6, + 7, + 10, + 11, + 14, + 15, + 128, + 129, + 132, + 133, + 136, + 137, + 140, + 141, + 130, + 131, + 134, + 135, + 138, + 139, + 142, + 143 + ] } ] }, @@ -728,12 +932,15 @@ }, { "stage": "dl1.l03", - "digest": "f766b092d260b1f4dff36df020a13522280e20c01df20015e9a8ebcd8483ad04", + "digest": "b28648f634ff719f254061eda679beb62b2ce92923ce9a51221499abe8e10128", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 73728 + 128, + 64, + 3, + 3 ], "dtype": "float32", "src": "A03", @@ -743,7 +950,218 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 4608, + 4624, + 4640, + 4656, + 4672, + 4688, + 4704, + 4720, + 9216, + 9232, + 9248, + 9264, + 9280, + 9296, + 9312, + 9328, + 13824, + 13840, + 13856, + 13872, + 13888, + 13904, + 13920, + 13936, + 18432, + 18448, + 18464, + 18480, + 18496, + 18512, + 18528, + 18544, + 23040, + 23056, + 23072, + 23088, + 23104, + 23120, + 23136, + 23152, + 27648, + 27664, + 27680, + 27696, + 27712, + 27728, + 27744, + 27760, + 32256, + 32272, + 32288, + 32304, + 32320, + 32336, + 32352, + 32368, + 36864, + 36880, + 36896, + 36912, + 36928, + 36944, + 36960, + 36976, + 41472, + 41488, + 41504, + 41520, + 41536, + 41552, + 41568, + 41584, + 46080, + 46096, + 46112, + 46128, + 46144, + 46160, + 46176, + 46192, + 50688, + 50704, + 50720, + 50736, + 50752, + 50768, + 50784, + 50800, + 55296, + 55312, + 55328, + 55344, + 55360, + 55376, + 55392, + 55408, + 59904, + 59920, + 59936, + 59952, + 59968, + 59984, + 60000, + 60016, + 64512, + 64528, + 64544, + 64560, + 64576, + 64592, + 64608, + 64624, + 69120, + 69136, + 69152, + 69168, + 69184, + 69200, + 69216, + 69232 + ] + }, + { + "offsets": [ + 0, + 1, + 4, + 5, + 8, + 9, + 12, + 13, + 2, + 3, + 6, + 7, + 10, + 11, + 14, + 15, + 128, + 129, + 132, + 133, + 136, + 137, + 140, + 141, + 130, + 131, + 134, + 135, + 138, + 139, + 142, + 143, + 256, + 257, + 260, + 261, + 264, + 265, + 268, + 269, + 258, + 259, + 262, + 263, + 266, + 267, + 270, + 271, + 384, + 385, + 388, + 389, + 392, + 393, + 396, + 397, + 386, + 387, + 390, + 391, + 394, + 395, + 398, + 399 + ] + }, + { + "offsets": [ + 0, + 1536, + 3072 + ] + }, + { + "offsets": [ + 0, + 512, + 1024 + ] } ] }, @@ -897,12 +1315,15 @@ }, { "stage": "dl1.l04", - "digest": "2bee3ab15cb9680bf4fa3d5aeede01426191c57019e2637ad11aa767434c6b00", + "digest": "53ad59f3f1b28029263d9dd84ac0a4210ba88b731271e0e512c5ca7e799d5e72", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 147456 + 128, + 128, + 3, + 3 ], "dtype": "float32", "src": "A04", @@ -912,7 +1333,282 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 9216, + 9232, + 9248, + 9264, + 9280, + 9296, + 9312, + 9328, + 18432, + 18448, + 18464, + 18480, + 18496, + 18512, + 18528, + 18544, + 27648, + 27664, + 27680, + 27696, + 27712, + 27728, + 27744, + 27760, + 36864, + 36880, + 36896, + 36912, + 36928, + 36944, + 36960, + 36976, + 46080, + 46096, + 46112, + 46128, + 46144, + 46160, + 46176, + 46192, + 55296, + 55312, + 55328, + 55344, + 55360, + 55376, + 55392, + 55408, + 64512, + 64528, + 64544, + 64560, + 64576, + 64592, + 64608, + 64624, + 73728, + 73744, + 73760, + 73776, + 73792, + 73808, + 73824, + 73840, + 82944, + 82960, + 82976, + 82992, + 83008, + 83024, + 83040, + 83056, + 92160, + 92176, + 92192, + 92208, + 92224, + 92240, + 92256, + 92272, + 101376, + 101392, + 101408, + 101424, + 101440, + 101456, + 101472, + 101488, + 110592, + 110608, + 110624, + 110640, + 110656, + 110672, + 110688, + 110704, + 119808, + 119824, + 119840, + 119856, + 119872, + 119888, + 119904, + 119920, + 129024, + 129040, + 129056, + 129072, + 129088, + 129104, + 129120, + 129136, + 138240, + 138256, + 138272, + 138288, + 138304, + 138320, + 138336, + 138352 + ] + }, + { + "offsets": [ + 0, + 1, + 4, + 5, + 8, + 9, + 12, + 13, + 2, + 3, + 6, + 7, + 10, + 11, + 14, + 15, + 128, + 129, + 132, + 133, + 136, + 137, + 140, + 141, + 130, + 131, + 134, + 135, + 138, + 139, + 142, + 143, + 256, + 257, + 260, + 261, + 264, + 265, + 268, + 269, + 258, + 259, + 262, + 263, + 266, + 267, + 270, + 271, + 384, + 385, + 388, + 389, + 392, + 393, + 396, + 397, + 386, + 387, + 390, + 391, + 394, + 395, + 398, + 399, + 512, + 513, + 516, + 517, + 520, + 521, + 524, + 525, + 514, + 515, + 518, + 519, + 522, + 523, + 526, + 527, + 640, + 641, + 644, + 645, + 648, + 649, + 652, + 653, + 642, + 643, + 646, + 647, + 650, + 651, + 654, + 655, + 768, + 769, + 772, + 773, + 776, + 777, + 780, + 781, + 770, + 771, + 774, + 775, + 778, + 779, + 782, + 783, + 896, + 897, + 900, + 901, + 904, + 905, + 908, + 909, + 898, + 899, + 902, + 903, + 906, + 907, + 910, + 911 + ] + }, + { + "offsets": [ + 0, + 3072, + 6144 + ] + }, + { + "offsets": [ + 0, + 1024, + 2048 + ] } ] }, @@ -1066,12 +1762,15 @@ }, { "stage": "dl1.l05", - "digest": "d9b84dcb0499747041551f1168d651780ac48147fbc59ba067057ccf6b800ac8", + "digest": "4f7c19f6461836556ea5fcd794f15ec8dd930317ce4d2dbd8b3da143da8a2cb6", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 294912 + 256, + 128, + 3, + 3 ], "dtype": "float32", "src": "A05", @@ -1081,84 +1780,487 @@ "base": 0, "axes": [ { - "stride": 1 - } - ] - }, - { - "name": "b", - "shape": [ - 256 - ], - "dtype": "float32", - "src": "A05", - "op": { - "name": "f16" - }, - "base": 589824, - "axes": [ + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 9216, + 9232, + 9248, + 9264, + 9280, + 9296, + 9312, + 9328, + 18432, + 18448, + 18464, + 18480, + 18496, + 18512, + 18528, + 18544, + 27648, + 27664, + 27680, + 27696, + 27712, + 27728, + 27744, + 27760, + 36864, + 36880, + 36896, + 36912, + 36928, + 36944, + 36960, + 36976, + 46080, + 46096, + 46112, + 46128, + 46144, + 46160, + 46176, + 46192, + 55296, + 55312, + 55328, + 55344, + 55360, + 55376, + 55392, + 55408, + 64512, + 64528, + 64544, + 64560, + 64576, + 64592, + 64608, + 64624, + 73728, + 73744, + 73760, + 73776, + 73792, + 73808, + 73824, + 73840, + 82944, + 82960, + 82976, + 82992, + 83008, + 83024, + 83040, + 83056, + 92160, + 92176, + 92192, + 92208, + 92224, + 92240, + 92256, + 92272, + 101376, + 101392, + 101408, + 101424, + 101440, + 101456, + 101472, + 101488, + 110592, + 110608, + 110624, + 110640, + 110656, + 110672, + 110688, + 110704, + 119808, + 119824, + 119840, + 119856, + 119872, + 119888, + 119904, + 119920, + 129024, + 129040, + 129056, + 129072, + 129088, + 129104, + 129120, + 129136, + 138240, + 138256, + 138272, + 138288, + 138304, + 138320, + 138336, + 138352, + 147456, + 147472, + 147488, + 147504, + 147520, + 147536, + 147552, + 147568, + 156672, + 156688, + 156704, + 156720, + 156736, + 156752, + 156768, + 156784, + 165888, + 165904, + 165920, + 165936, + 165952, + 165968, + 165984, + 166000, + 175104, + 175120, + 175136, + 175152, + 175168, + 175184, + 175200, + 175216, + 184320, + 184336, + 184352, + 184368, + 184384, + 184400, + 184416, + 184432, + 193536, + 193552, + 193568, + 193584, + 193600, + 193616, + 193632, + 193648, + 202752, + 202768, + 202784, + 202800, + 202816, + 202832, + 202848, + 202864, + 211968, + 211984, + 212000, + 212016, + 212032, + 212048, + 212064, + 212080, + 221184, + 221200, + 221216, + 221232, + 221248, + 221264, + 221280, + 221296, + 230400, + 230416, + 230432, + 230448, + 230464, + 230480, + 230496, + 230512, + 239616, + 239632, + 239648, + 239664, + 239680, + 239696, + 239712, + 239728, + 248832, + 248848, + 248864, + 248880, + 248896, + 248912, + 248928, + 248944, + 258048, + 258064, + 258080, + 258096, + 258112, + 258128, + 258144, + 258160, + 267264, + 267280, + 267296, + 267312, + 267328, + 267344, + 267360, + 267376, + 276480, + 276496, + 276512, + 276528, + 276544, + 276560, + 276576, + 276592, + 285696, + 285712, + 285728, + 285744, + 285760, + 285776, + 285792, + 285808 + ] + }, { "offsets": [ 0, 1, - 2, - 3, 4, 5, + 8, + 9, + 12, + 13, + 2, + 3, 6, 7, + 10, + 11, + 14, + 15, 128, 129, - 130, - 131, 132, 133, + 136, + 137, + 140, + 141, + 130, + 131, 134, 135, + 138, + 139, + 142, + 143, 256, 257, - 258, - 259, 260, 261, + 264, + 265, + 268, + 269, + 258, + 259, 262, 263, + 266, + 267, + 270, + 271, 384, 385, - 386, - 387, 388, 389, + 392, + 393, + 396, + 397, + 386, + 387, 390, 391, + 394, + 395, + 398, + 399, 512, 513, - 514, - 515, 516, 517, + 520, + 521, + 524, + 525, + 514, + 515, 518, 519, + 522, + 523, + 526, + 527, 640, 641, - 642, - 643, 644, 645, + 648, + 649, + 652, + 653, + 642, + 643, 646, 647, + 650, + 651, + 654, + 655, 768, 769, - 770, - 771, 772, 773, + 776, + 777, + 780, + 781, + 770, + 771, 774, 775, + 778, + 779, + 782, + 783, 896, 897, - 898, - 899, + 900, + 901, + 904, + 905, + 908, + 909, + 898, + 899, + 902, + 903, + 906, + 907, + 910, + 911 + ] + }, + { + "offsets": [ + 0, + 3072, + 6144 + ] + }, + { + "offsets": [ + 0, + 1024, + 2048 + ] + } + ] + }, + { + "name": "b", + "shape": [ + 256 + ], + "dtype": "float32", + "src": "A05", + "op": { + "name": "f16" + }, + "base": 589824, + "axes": [ + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 512, + 513, + 514, + 515, + 516, + 517, + 518, + 519, + 640, + 641, + 642, + 643, + 644, + 645, + 646, + 647, + 768, + 769, + 770, + 771, + 772, + 773, + 774, + 775, + 896, + 897, + 898, + 899, 900, 901, 902, @@ -1363,12 +2465,13 @@ }, { "stage": "dl1.l06", - "digest": "99c31ac71f6d0ce2a1fca0eb251a2e9617902a6cb978e25dfc71ef80d13ea51e", + "digest": "8d3c80b2829cd42b1ffaf2a07aa9b473c6d9d0520a43a1a47c58f0177b4bc417", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 131072 + 512, + 256 ], "dtype": "float32", "src": "A06", @@ -1378,7 +2481,780 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 2048, + 2064, + 2080, + 2096, + 2112, + 2128, + 2144, + 2160, + 4096, + 4112, + 4128, + 4144, + 4160, + 4176, + 4192, + 4208, + 6144, + 6160, + 6176, + 6192, + 6208, + 6224, + 6240, + 6256, + 8192, + 8208, + 8224, + 8240, + 8256, + 8272, + 8288, + 8304, + 10240, + 10256, + 10272, + 10288, + 10304, + 10320, + 10336, + 10352, + 12288, + 12304, + 12320, + 12336, + 12352, + 12368, + 12384, + 12400, + 14336, + 14352, + 14368, + 14384, + 14400, + 14416, + 14432, + 14448, + 16384, + 16400, + 16416, + 16432, + 16448, + 16464, + 16480, + 16496, + 18432, + 18448, + 18464, + 18480, + 18496, + 18512, + 18528, + 18544, + 20480, + 20496, + 20512, + 20528, + 20544, + 20560, + 20576, + 20592, + 22528, + 22544, + 22560, + 22576, + 22592, + 22608, + 22624, + 22640, + 24576, + 24592, + 24608, + 24624, + 24640, + 24656, + 24672, + 24688, + 26624, + 26640, + 26656, + 26672, + 26688, + 26704, + 26720, + 26736, + 28672, + 28688, + 28704, + 28720, + 28736, + 28752, + 28768, + 28784, + 30720, + 30736, + 30752, + 30768, + 30784, + 30800, + 30816, + 30832, + 32768, + 32784, + 32800, + 32816, + 32832, + 32848, + 32864, + 32880, + 34816, + 34832, + 34848, + 34864, + 34880, + 34896, + 34912, + 34928, + 36864, + 36880, + 36896, + 36912, + 36928, + 36944, + 36960, + 36976, + 38912, + 38928, + 38944, + 38960, + 38976, + 38992, + 39008, + 39024, + 40960, + 40976, + 40992, + 41008, + 41024, + 41040, + 41056, + 41072, + 43008, + 43024, + 43040, + 43056, + 43072, + 43088, + 43104, + 43120, + 45056, + 45072, + 45088, + 45104, + 45120, + 45136, + 45152, + 45168, + 47104, + 47120, + 47136, + 47152, + 47168, + 47184, + 47200, + 47216, + 49152, + 49168, + 49184, + 49200, + 49216, + 49232, + 49248, + 49264, + 51200, + 51216, + 51232, + 51248, + 51264, + 51280, + 51296, + 51312, + 53248, + 53264, + 53280, + 53296, + 53312, + 53328, + 53344, + 53360, + 55296, + 55312, + 55328, + 55344, + 55360, + 55376, + 55392, + 55408, + 57344, + 57360, + 57376, + 57392, + 57408, + 57424, + 57440, + 57456, + 59392, + 59408, + 59424, + 59440, + 59456, + 59472, + 59488, + 59504, + 61440, + 61456, + 61472, + 61488, + 61504, + 61520, + 61536, + 61552, + 63488, + 63504, + 63520, + 63536, + 63552, + 63568, + 63584, + 63600, + 65536, + 65552, + 65568, + 65584, + 65600, + 65616, + 65632, + 65648, + 67584, + 67600, + 67616, + 67632, + 67648, + 67664, + 67680, + 67696, + 69632, + 69648, + 69664, + 69680, + 69696, + 69712, + 69728, + 69744, + 71680, + 71696, + 71712, + 71728, + 71744, + 71760, + 71776, + 71792, + 73728, + 73744, + 73760, + 73776, + 73792, + 73808, + 73824, + 73840, + 75776, + 75792, + 75808, + 75824, + 75840, + 75856, + 75872, + 75888, + 77824, + 77840, + 77856, + 77872, + 77888, + 77904, + 77920, + 77936, + 79872, + 79888, + 79904, + 79920, + 79936, + 79952, + 79968, + 79984, + 81920, + 81936, + 81952, + 81968, + 81984, + 82000, + 82016, + 82032, + 83968, + 83984, + 84000, + 84016, + 84032, + 84048, + 84064, + 84080, + 86016, + 86032, + 86048, + 86064, + 86080, + 86096, + 86112, + 86128, + 88064, + 88080, + 88096, + 88112, + 88128, + 88144, + 88160, + 88176, + 90112, + 90128, + 90144, + 90160, + 90176, + 90192, + 90208, + 90224, + 92160, + 92176, + 92192, + 92208, + 92224, + 92240, + 92256, + 92272, + 94208, + 94224, + 94240, + 94256, + 94272, + 94288, + 94304, + 94320, + 96256, + 96272, + 96288, + 96304, + 96320, + 96336, + 96352, + 96368, + 98304, + 98320, + 98336, + 98352, + 98368, + 98384, + 98400, + 98416, + 100352, + 100368, + 100384, + 100400, + 100416, + 100432, + 100448, + 100464, + 102400, + 102416, + 102432, + 102448, + 102464, + 102480, + 102496, + 102512, + 104448, + 104464, + 104480, + 104496, + 104512, + 104528, + 104544, + 104560, + 106496, + 106512, + 106528, + 106544, + 106560, + 106576, + 106592, + 106608, + 108544, + 108560, + 108576, + 108592, + 108608, + 108624, + 108640, + 108656, + 110592, + 110608, + 110624, + 110640, + 110656, + 110672, + 110688, + 110704, + 112640, + 112656, + 112672, + 112688, + 112704, + 112720, + 112736, + 112752, + 114688, + 114704, + 114720, + 114736, + 114752, + 114768, + 114784, + 114800, + 116736, + 116752, + 116768, + 116784, + 116800, + 116816, + 116832, + 116848, + 118784, + 118800, + 118816, + 118832, + 118848, + 118864, + 118880, + 118896, + 120832, + 120848, + 120864, + 120880, + 120896, + 120912, + 120928, + 120944, + 122880, + 122896, + 122912, + 122928, + 122944, + 122960, + 122976, + 122992, + 124928, + 124944, + 124960, + 124976, + 124992, + 125008, + 125024, + 125040, + 126976, + 126992, + 127008, + 127024, + 127040, + 127056, + 127072, + 127088, + 129024, + 129040, + 129056, + 129072, + 129088, + 129104, + 129120, + 129136 + ] + }, + { + "offsets": [ + 0, + 1, + 4, + 5, + 8, + 9, + 12, + 13, + 2, + 3, + 6, + 7, + 10, + 11, + 14, + 15, + 128, + 129, + 132, + 133, + 136, + 137, + 140, + 141, + 130, + 131, + 134, + 135, + 138, + 139, + 142, + 143, + 256, + 257, + 260, + 261, + 264, + 265, + 268, + 269, + 258, + 259, + 262, + 263, + 266, + 267, + 270, + 271, + 384, + 385, + 388, + 389, + 392, + 393, + 396, + 397, + 386, + 387, + 390, + 391, + 394, + 395, + 398, + 399, + 512, + 513, + 516, + 517, + 520, + 521, + 524, + 525, + 514, + 515, + 518, + 519, + 522, + 523, + 526, + 527, + 640, + 641, + 644, + 645, + 648, + 649, + 652, + 653, + 642, + 643, + 646, + 647, + 650, + 651, + 654, + 655, + 768, + 769, + 772, + 773, + 776, + 777, + 780, + 781, + 770, + 771, + 774, + 775, + 778, + 779, + 782, + 783, + 896, + 897, + 900, + 901, + 904, + 905, + 908, + 909, + 898, + 899, + 902, + 903, + 906, + 907, + 910, + 911, + 1024, + 1025, + 1028, + 1029, + 1032, + 1033, + 1036, + 1037, + 1026, + 1027, + 1030, + 1031, + 1034, + 1035, + 1038, + 1039, + 1152, + 1153, + 1156, + 1157, + 1160, + 1161, + 1164, + 1165, + 1154, + 1155, + 1158, + 1159, + 1162, + 1163, + 1166, + 1167, + 1280, + 1281, + 1284, + 1285, + 1288, + 1289, + 1292, + 1293, + 1282, + 1283, + 1286, + 1287, + 1290, + 1291, + 1294, + 1295, + 1408, + 1409, + 1412, + 1413, + 1416, + 1417, + 1420, + 1421, + 1410, + 1411, + 1414, + 1415, + 1418, + 1419, + 1422, + 1423, + 1536, + 1537, + 1540, + 1541, + 1544, + 1545, + 1548, + 1549, + 1538, + 1539, + 1542, + 1543, + 1546, + 1547, + 1550, + 1551, + 1664, + 1665, + 1668, + 1669, + 1672, + 1673, + 1676, + 1677, + 1666, + 1667, + 1670, + 1671, + 1674, + 1675, + 1678, + 1679, + 1792, + 1793, + 1796, + 1797, + 1800, + 1801, + 1804, + 1805, + 1794, + 1795, + 1798, + 1799, + 1802, + 1803, + 1806, + 1807, + 1920, + 1921, + 1924, + 1925, + 1928, + 1929, + 1932, + 1933, + 1922, + 1923, + 1926, + 1927, + 1930, + 1931, + 1934, + 1935 + ] } ] }, @@ -1916,12 +3792,13 @@ }, { "stage": "dl1.l07", - "digest": "0e3da7c7db8000a7bc6fa63c6752ab9caed5d4b2b059857906a30285ae6b9282", + "digest": "3feede1ce30aac5a8dac05c097044c8da86add7804ec72aeceff8f499b346985", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 131072 + 256, + 512 ], "dtype": "float32", "src": "A07", @@ -1931,306 +3808,782 @@ "base": 0, "axes": [ { - "stride": 1 - } - ] - }, - { - "name": "b", - "shape": [ - 256 - ], - "dtype": "float32", - "src": "A07", - "op": { - "name": "f16" - }, - "base": 262144, - "axes": [ + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 4096, + 4112, + 4128, + 4144, + 4160, + 4176, + 4192, + 4208, + 8192, + 8208, + 8224, + 8240, + 8256, + 8272, + 8288, + 8304, + 12288, + 12304, + 12320, + 12336, + 12352, + 12368, + 12384, + 12400, + 16384, + 16400, + 16416, + 16432, + 16448, + 16464, + 16480, + 16496, + 20480, + 20496, + 20512, + 20528, + 20544, + 20560, + 20576, + 20592, + 24576, + 24592, + 24608, + 24624, + 24640, + 24656, + 24672, + 24688, + 28672, + 28688, + 28704, + 28720, + 28736, + 28752, + 28768, + 28784, + 32768, + 32784, + 32800, + 32816, + 32832, + 32848, + 32864, + 32880, + 36864, + 36880, + 36896, + 36912, + 36928, + 36944, + 36960, + 36976, + 40960, + 40976, + 40992, + 41008, + 41024, + 41040, + 41056, + 41072, + 45056, + 45072, + 45088, + 45104, + 45120, + 45136, + 45152, + 45168, + 49152, + 49168, + 49184, + 49200, + 49216, + 49232, + 49248, + 49264, + 53248, + 53264, + 53280, + 53296, + 53312, + 53328, + 53344, + 53360, + 57344, + 57360, + 57376, + 57392, + 57408, + 57424, + 57440, + 57456, + 61440, + 61456, + 61472, + 61488, + 61504, + 61520, + 61536, + 61552, + 65536, + 65552, + 65568, + 65584, + 65600, + 65616, + 65632, + 65648, + 69632, + 69648, + 69664, + 69680, + 69696, + 69712, + 69728, + 69744, + 73728, + 73744, + 73760, + 73776, + 73792, + 73808, + 73824, + 73840, + 77824, + 77840, + 77856, + 77872, + 77888, + 77904, + 77920, + 77936, + 81920, + 81936, + 81952, + 81968, + 81984, + 82000, + 82016, + 82032, + 86016, + 86032, + 86048, + 86064, + 86080, + 86096, + 86112, + 86128, + 90112, + 90128, + 90144, + 90160, + 90176, + 90192, + 90208, + 90224, + 94208, + 94224, + 94240, + 94256, + 94272, + 94288, + 94304, + 94320, + 98304, + 98320, + 98336, + 98352, + 98368, + 98384, + 98400, + 98416, + 102400, + 102416, + 102432, + 102448, + 102464, + 102480, + 102496, + 102512, + 106496, + 106512, + 106528, + 106544, + 106560, + 106576, + 106592, + 106608, + 110592, + 110608, + 110624, + 110640, + 110656, + 110672, + 110688, + 110704, + 114688, + 114704, + 114720, + 114736, + 114752, + 114768, + 114784, + 114800, + 118784, + 118800, + 118816, + 118832, + 118848, + 118864, + 118880, + 118896, + 122880, + 122896, + 122912, + 122928, + 122944, + 122960, + 122976, + 122992, + 126976, + 126992, + 127008, + 127024, + 127040, + 127056, + 127072, + 127088 + ] + }, { "offsets": [ 0, 1, - 2, - 3, 4, 5, + 8, + 9, + 12, + 13, + 2, + 3, 6, 7, + 10, + 11, + 14, + 15, 128, 129, - 130, - 131, 132, 133, + 136, + 137, + 140, + 141, + 130, + 131, 134, 135, + 138, + 139, + 142, + 143, 256, 257, - 258, - 259, 260, 261, + 264, + 265, + 268, + 269, + 258, + 259, 262, 263, + 266, + 267, + 270, + 271, 384, 385, - 386, - 387, 388, 389, + 392, + 393, + 396, + 397, + 386, + 387, 390, 391, + 394, + 395, + 398, + 399, 512, 513, - 514, - 515, 516, 517, + 520, + 521, + 524, + 525, + 514, + 515, 518, 519, + 522, + 523, + 526, + 527, 640, 641, - 642, - 643, 644, 645, + 648, + 649, + 652, + 653, + 642, + 643, 646, 647, + 650, + 651, + 654, + 655, 768, 769, - 770, - 771, 772, 773, + 776, + 777, + 780, + 781, + 770, + 771, 774, 775, + 778, + 779, + 782, + 783, 896, 897, - 898, - 899, 900, 901, + 904, + 905, + 908, + 909, + 898, + 899, 902, 903, + 906, + 907, + 910, + 911, 1024, 1025, - 1026, - 1027, 1028, 1029, + 1032, + 1033, + 1036, + 1037, + 1026, + 1027, 1030, 1031, + 1034, + 1035, + 1038, + 1039, 1152, 1153, - 1154, - 1155, 1156, 1157, + 1160, + 1161, + 1164, + 1165, + 1154, + 1155, 1158, 1159, + 1162, + 1163, + 1166, + 1167, 1280, 1281, - 1282, - 1283, 1284, 1285, + 1288, + 1289, + 1292, + 1293, + 1282, + 1283, 1286, 1287, + 1290, + 1291, + 1294, + 1295, 1408, 1409, - 1410, - 1411, 1412, 1413, + 1416, + 1417, + 1420, + 1421, + 1410, + 1411, 1414, 1415, + 1418, + 1419, + 1422, + 1423, 1536, 1537, - 1538, - 1539, 1540, 1541, + 1544, + 1545, + 1548, + 1549, + 1538, + 1539, 1542, 1543, + 1546, + 1547, + 1550, + 1551, 1664, 1665, - 1666, - 1667, 1668, 1669, + 1672, + 1673, + 1676, + 1677, + 1666, + 1667, 1670, 1671, + 1674, + 1675, + 1678, + 1679, 1792, 1793, - 1794, - 1795, 1796, 1797, + 1800, + 1801, + 1804, + 1805, + 1794, + 1795, 1798, 1799, + 1802, + 1803, + 1806, + 1807, 1920, 1921, - 1922, - 1923, 1924, 1925, + 1928, + 1929, + 1932, + 1933, + 1922, + 1923, 1926, 1927, + 1930, + 1931, + 1934, + 1935, 2048, 2049, - 2050, - 2051, 2052, 2053, + 2056, + 2057, + 2060, + 2061, + 2050, + 2051, 2054, 2055, + 2058, + 2059, + 2062, + 2063, 2176, 2177, - 2178, - 2179, 2180, 2181, + 2184, + 2185, + 2188, + 2189, + 2178, + 2179, 2182, 2183, + 2186, + 2187, + 2190, + 2191, 2304, 2305, - 2306, - 2307, 2308, 2309, + 2312, + 2313, + 2316, + 2317, + 2306, + 2307, 2310, 2311, + 2314, + 2315, + 2318, + 2319, 2432, 2433, - 2434, - 2435, 2436, 2437, + 2440, + 2441, + 2444, + 2445, + 2434, + 2435, 2438, 2439, + 2442, + 2443, + 2446, + 2447, 2560, 2561, - 2562, - 2563, 2564, 2565, + 2568, + 2569, + 2572, + 2573, + 2562, + 2563, 2566, 2567, + 2570, + 2571, + 2574, + 2575, 2688, 2689, - 2690, - 2691, 2692, 2693, + 2696, + 2697, + 2700, + 2701, + 2690, + 2691, 2694, 2695, + 2698, + 2699, + 2702, + 2703, 2816, 2817, - 2818, - 2819, 2820, 2821, + 2824, + 2825, + 2828, + 2829, + 2818, + 2819, 2822, 2823, + 2826, + 2827, + 2830, + 2831, 2944, 2945, - 2946, - 2947, 2948, 2949, + 2952, + 2953, + 2956, + 2957, + 2946, + 2947, 2950, 2951, + 2954, + 2955, + 2958, + 2959, 3072, 3073, - 3074, - 3075, 3076, 3077, + 3080, + 3081, + 3084, + 3085, + 3074, + 3075, 3078, 3079, + 3082, + 3083, + 3086, + 3087, 3200, 3201, - 3202, - 3203, 3204, 3205, + 3208, + 3209, + 3212, + 3213, + 3202, + 3203, 3206, 3207, + 3210, + 3211, + 3214, + 3215, 3328, 3329, - 3330, - 3331, 3332, 3333, + 3336, + 3337, + 3340, + 3341, + 3330, + 3331, 3334, 3335, + 3338, + 3339, + 3342, + 3343, 3456, 3457, - 3458, - 3459, 3460, 3461, + 3464, + 3465, + 3468, + 3469, + 3458, + 3459, 3462, 3463, + 3466, + 3467, + 3470, + 3471, 3584, 3585, - 3586, - 3587, 3588, 3589, + 3592, + 3593, + 3596, + 3597, + 3586, + 3587, 3590, 3591, + 3594, + 3595, + 3598, + 3599, 3712, 3713, - 3714, - 3715, 3716, 3717, + 3720, + 3721, + 3724, + 3725, + 3714, + 3715, 3718, 3719, + 3722, + 3723, + 3726, + 3727, 3840, 3841, - 3842, - 3843, 3844, 3845, + 3848, + 3849, + 3852, + 3853, + 3842, + 3843, 3846, 3847, + 3850, + 3851, + 3854, + 3855, 3968, 3969, - 3970, - 3971, 3972, 3973, + 3976, + 3977, + 3980, + 3981, + 3970, + 3971, 3974, - 3975 + 3975, + 3978, + 3979, + 3982, + 3983 ] } ] - } - ] - }, - { - "stage": "dl1.l08", - "digest": "8a537b342e633b7ac793e2069c3eebbf087fc7264ad45c9a7290b3d9cc6e98dd", - "tensors": [ - { - "name": "W_storage", - "shape": [ - 65536 - ], - "dtype": "float32", - "src": "A08", - "op": { - "name": "f16" - }, - "base": 0, - "axes": [ - { - "stride": 1 - } - ] }, { "name": "b", @@ -2238,11 +4591,11 @@ 256 ], "dtype": "float32", - "src": "A08", + "src": "A07", "op": { "name": "f16" }, - "base": 131072, + "base": 262144, "axes": [ { "offsets": [ @@ -2509,206 +4862,555 @@ ] }, { - "stage": "dl1.l09", - "digest": "e95f330b36b57a86dccffdb382a7274ba9a95e78ef039fdb52dfb8548cf8a68e", + "stage": "dl1.l08", + "digest": "415a1bbfa3cbb7e483f4eed24f46fdb3a098d9d4e4ae521bdab5bdd1c34348be", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 32768 + 256, + 256 ], "dtype": "float32", - "src": "A09", + "src": "A08", "op": { "name": "f16" }, "base": 0, "axes": [ { - "stride": 1 - } - ] - }, - { - "name": "b", - "shape": [ - 128 - ], - "dtype": "float32", - "src": "A09", - "op": { - "name": "f16" - }, - "base": 65536, - "axes": [ + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 2048, + 2064, + 2080, + 2096, + 2112, + 2128, + 2144, + 2160, + 4096, + 4112, + 4128, + 4144, + 4160, + 4176, + 4192, + 4208, + 6144, + 6160, + 6176, + 6192, + 6208, + 6224, + 6240, + 6256, + 8192, + 8208, + 8224, + 8240, + 8256, + 8272, + 8288, + 8304, + 10240, + 10256, + 10272, + 10288, + 10304, + 10320, + 10336, + 10352, + 12288, + 12304, + 12320, + 12336, + 12352, + 12368, + 12384, + 12400, + 14336, + 14352, + 14368, + 14384, + 14400, + 14416, + 14432, + 14448, + 16384, + 16400, + 16416, + 16432, + 16448, + 16464, + 16480, + 16496, + 18432, + 18448, + 18464, + 18480, + 18496, + 18512, + 18528, + 18544, + 20480, + 20496, + 20512, + 20528, + 20544, + 20560, + 20576, + 20592, + 22528, + 22544, + 22560, + 22576, + 22592, + 22608, + 22624, + 22640, + 24576, + 24592, + 24608, + 24624, + 24640, + 24656, + 24672, + 24688, + 26624, + 26640, + 26656, + 26672, + 26688, + 26704, + 26720, + 26736, + 28672, + 28688, + 28704, + 28720, + 28736, + 28752, + 28768, + 28784, + 30720, + 30736, + 30752, + 30768, + 30784, + 30800, + 30816, + 30832, + 32768, + 32784, + 32800, + 32816, + 32832, + 32848, + 32864, + 32880, + 34816, + 34832, + 34848, + 34864, + 34880, + 34896, + 34912, + 34928, + 36864, + 36880, + 36896, + 36912, + 36928, + 36944, + 36960, + 36976, + 38912, + 38928, + 38944, + 38960, + 38976, + 38992, + 39008, + 39024, + 40960, + 40976, + 40992, + 41008, + 41024, + 41040, + 41056, + 41072, + 43008, + 43024, + 43040, + 43056, + 43072, + 43088, + 43104, + 43120, + 45056, + 45072, + 45088, + 45104, + 45120, + 45136, + 45152, + 45168, + 47104, + 47120, + 47136, + 47152, + 47168, + 47184, + 47200, + 47216, + 49152, + 49168, + 49184, + 49200, + 49216, + 49232, + 49248, + 49264, + 51200, + 51216, + 51232, + 51248, + 51264, + 51280, + 51296, + 51312, + 53248, + 53264, + 53280, + 53296, + 53312, + 53328, + 53344, + 53360, + 55296, + 55312, + 55328, + 55344, + 55360, + 55376, + 55392, + 55408, + 57344, + 57360, + 57376, + 57392, + 57408, + 57424, + 57440, + 57456, + 59392, + 59408, + 59424, + 59440, + 59456, + 59472, + 59488, + 59504, + 61440, + 61456, + 61472, + 61488, + 61504, + 61520, + 61536, + 61552, + 63488, + 63504, + 63520, + 63536, + 63552, + 63568, + 63584, + 63600 + ] + }, { "offsets": [ 0, 1, - 2, - 3, 4, 5, + 8, + 9, + 12, + 13, + 2, + 3, 6, 7, + 10, + 11, + 14, + 15, 128, 129, - 130, - 131, 132, 133, + 136, + 137, + 140, + 141, + 130, + 131, 134, 135, + 138, + 139, + 142, + 143, 256, 257, - 258, - 259, 260, 261, + 264, + 265, + 268, + 269, + 258, + 259, 262, 263, + 266, + 267, + 270, + 271, 384, 385, - 386, - 387, 388, 389, + 392, + 393, + 396, + 397, + 386, + 387, 390, 391, + 394, + 395, + 398, + 399, 512, 513, - 514, - 515, 516, 517, + 520, + 521, + 524, + 525, + 514, + 515, 518, 519, + 522, + 523, + 526, + 527, 640, 641, - 642, - 643, 644, 645, + 648, + 649, + 652, + 653, + 642, + 643, 646, 647, + 650, + 651, + 654, + 655, 768, 769, - 770, - 771, 772, 773, + 776, + 777, + 780, + 781, + 770, + 771, 774, 775, + 778, + 779, + 782, + 783, 896, 897, - 898, - 899, 900, 901, + 904, + 905, + 908, + 909, + 898, + 899, 902, 903, + 906, + 907, + 910, + 911, 1024, 1025, - 1026, - 1027, 1028, 1029, + 1032, + 1033, + 1036, + 1037, + 1026, + 1027, 1030, 1031, + 1034, + 1035, + 1038, + 1039, 1152, 1153, - 1154, - 1155, 1156, 1157, + 1160, + 1161, + 1164, + 1165, + 1154, + 1155, 1158, 1159, + 1162, + 1163, + 1166, + 1167, 1280, 1281, - 1282, - 1283, 1284, 1285, + 1288, + 1289, + 1292, + 1293, + 1282, + 1283, 1286, 1287, + 1290, + 1291, + 1294, + 1295, 1408, 1409, - 1410, - 1411, 1412, 1413, + 1416, + 1417, + 1420, + 1421, + 1410, + 1411, 1414, 1415, + 1418, + 1419, + 1422, + 1423, 1536, 1537, - 1538, - 1539, 1540, 1541, + 1544, + 1545, + 1548, + 1549, + 1538, + 1539, 1542, 1543, + 1546, + 1547, + 1550, + 1551, 1664, 1665, - 1666, - 1667, 1668, 1669, + 1672, + 1673, + 1676, + 1677, + 1666, + 1667, 1670, 1671, + 1674, + 1675, + 1678, + 1679, 1792, 1793, - 1794, - 1795, 1796, 1797, + 1800, + 1801, + 1804, + 1805, + 1794, + 1795, 1798, 1799, + 1802, + 1803, + 1806, + 1807, 1920, 1921, - 1922, - 1923, 1924, 1925, + 1928, + 1929, + 1932, + 1933, + 1922, + 1923, 1926, - 1927 + 1927, + 1930, + 1931, + 1934, + 1935 ] } ] - } - ] - }, - { - "stage": "dl1.l10", - "digest": "3136497d03e63b575caf9d96741019eb45ab236685acf8d1ed9e5dc4b85bc684", - "tensors": [ + }, { - "name": "W_storage", + "name": "b", "shape": [ - 16384 + 256 ], "dtype": "float32", - "src": "A10", + "src": "A08", "op": { "name": "f16" }, - "base": 0, - "axes": [ - { - "stride": 1 - } - ] - }, - { - "name": "b", - "shape": [ - 128 - ], - "dtype": "float32", - "src": "A10", - "op": { - "name": "f16" - }, - "base": 32768, + "base": 131072, "axes": [ { "offsets": [ @@ -2839,7 +5541,135 @@ 1924, 1925, 1926, - 1927 + 1927, + 2048, + 2049, + 2050, + 2051, + 2052, + 2053, + 2054, + 2055, + 2176, + 2177, + 2178, + 2179, + 2180, + 2181, + 2182, + 2183, + 2304, + 2305, + 2306, + 2307, + 2308, + 2309, + 2310, + 2311, + 2432, + 2433, + 2434, + 2435, + 2436, + 2437, + 2438, + 2439, + 2560, + 2561, + 2562, + 2563, + 2564, + 2565, + 2566, + 2567, + 2688, + 2689, + 2690, + 2691, + 2692, + 2693, + 2694, + 2695, + 2816, + 2817, + 2818, + 2819, + 2820, + 2821, + 2822, + 2823, + 2944, + 2945, + 2946, + 2947, + 2948, + 2949, + 2950, + 2951, + 3072, + 3073, + 3074, + 3075, + 3076, + 3077, + 3078, + 3079, + 3200, + 3201, + 3202, + 3203, + 3204, + 3205, + 3206, + 3207, + 3328, + 3329, + 3330, + 3331, + 3332, + 3333, + 3334, + 3335, + 3456, + 3457, + 3458, + 3459, + 3460, + 3461, + 3462, + 3463, + 3584, + 3585, + 3586, + 3587, + 3588, + 3589, + 3590, + 3591, + 3712, + 3713, + 3714, + 3715, + 3716, + 3717, + 3718, + 3719, + 3840, + 3841, + 3842, + 3843, + 3844, + 3845, + 3846, + 3847, + 3968, + 3969, + 3970, + 3971, + 3972, + 3973, + 3974, + 3975 ] } ] @@ -2847,206 +5677,427 @@ ] }, { - "stage": "dl1.l11", - "digest": "e731d04eddeee4bfa3c1da910cf17edc817538a8b40d54c91bcabd6c0703ac7d", + "stage": "dl1.l09", + "digest": "f150cc09c290aea3ff6e11f752ffacc4e51cae69cc811b1efdbac7d928bdf936", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 16384 + 128, + 256 ], "dtype": "float32", - "src": "A11", + "src": "A09", "op": { "name": "f16" }, "base": 0, "axes": [ { - "stride": 1 - } - ] - }, - { - "name": "b", - "shape": [ - 128 - ], - "dtype": "float32", - "src": "A11", - "op": { - "name": "f16" - }, - "base": 32768, - "axes": [ + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 2048, + 2064, + 2080, + 2096, + 2112, + 2128, + 2144, + 2160, + 4096, + 4112, + 4128, + 4144, + 4160, + 4176, + 4192, + 4208, + 6144, + 6160, + 6176, + 6192, + 6208, + 6224, + 6240, + 6256, + 8192, + 8208, + 8224, + 8240, + 8256, + 8272, + 8288, + 8304, + 10240, + 10256, + 10272, + 10288, + 10304, + 10320, + 10336, + 10352, + 12288, + 12304, + 12320, + 12336, + 12352, + 12368, + 12384, + 12400, + 14336, + 14352, + 14368, + 14384, + 14400, + 14416, + 14432, + 14448, + 16384, + 16400, + 16416, + 16432, + 16448, + 16464, + 16480, + 16496, + 18432, + 18448, + 18464, + 18480, + 18496, + 18512, + 18528, + 18544, + 20480, + 20496, + 20512, + 20528, + 20544, + 20560, + 20576, + 20592, + 22528, + 22544, + 22560, + 22576, + 22592, + 22608, + 22624, + 22640, + 24576, + 24592, + 24608, + 24624, + 24640, + 24656, + 24672, + 24688, + 26624, + 26640, + 26656, + 26672, + 26688, + 26704, + 26720, + 26736, + 28672, + 28688, + 28704, + 28720, + 28736, + 28752, + 28768, + 28784, + 30720, + 30736, + 30752, + 30768, + 30784, + 30800, + 30816, + 30832 + ] + }, { "offsets": [ 0, 1, - 2, - 3, 4, 5, + 8, + 9, + 12, + 13, + 2, + 3, 6, 7, + 10, + 11, + 14, + 15, 128, 129, - 130, - 131, 132, 133, + 136, + 137, + 140, + 141, + 130, + 131, 134, 135, + 138, + 139, + 142, + 143, 256, 257, - 258, - 259, 260, 261, + 264, + 265, + 268, + 269, + 258, + 259, 262, 263, + 266, + 267, + 270, + 271, 384, 385, - 386, - 387, 388, 389, + 392, + 393, + 396, + 397, + 386, + 387, 390, 391, + 394, + 395, + 398, + 399, 512, 513, - 514, - 515, 516, 517, + 520, + 521, + 524, + 525, + 514, + 515, 518, 519, + 522, + 523, + 526, + 527, 640, 641, - 642, - 643, 644, 645, + 648, + 649, + 652, + 653, + 642, + 643, 646, 647, + 650, + 651, + 654, + 655, 768, 769, - 770, - 771, 772, 773, + 776, + 777, + 780, + 781, + 770, + 771, 774, 775, + 778, + 779, + 782, + 783, 896, 897, - 898, - 899, 900, 901, + 904, + 905, + 908, + 909, + 898, + 899, 902, 903, + 906, + 907, + 910, + 911, 1024, 1025, - 1026, - 1027, 1028, 1029, + 1032, + 1033, + 1036, + 1037, + 1026, + 1027, 1030, 1031, + 1034, + 1035, + 1038, + 1039, 1152, 1153, - 1154, - 1155, 1156, 1157, + 1160, + 1161, + 1164, + 1165, + 1154, + 1155, 1158, 1159, + 1162, + 1163, + 1166, + 1167, 1280, 1281, - 1282, - 1283, 1284, 1285, + 1288, + 1289, + 1292, + 1293, + 1282, + 1283, 1286, 1287, + 1290, + 1291, + 1294, + 1295, 1408, 1409, - 1410, - 1411, 1412, 1413, + 1416, + 1417, + 1420, + 1421, + 1410, + 1411, 1414, 1415, + 1418, + 1419, + 1422, + 1423, 1536, 1537, - 1538, - 1539, 1540, 1541, + 1544, + 1545, + 1548, + 1549, + 1538, + 1539, 1542, 1543, + 1546, + 1547, + 1550, + 1551, 1664, 1665, - 1666, - 1667, 1668, 1669, + 1672, + 1673, + 1676, + 1677, + 1666, + 1667, 1670, 1671, + 1674, + 1675, + 1678, + 1679, 1792, 1793, - 1794, - 1795, 1796, 1797, + 1800, + 1801, + 1804, + 1805, + 1794, + 1795, 1798, 1799, + 1802, + 1803, + 1806, + 1807, 1920, 1921, - 1922, - 1923, 1924, 1925, + 1928, + 1929, + 1932, + 1933, + 1922, + 1923, 1926, - 1927 + 1927, + 1930, + 1931, + 1934, + 1935 ] } ] - } - ] - }, - { - "stage": "dl1.l12", - "digest": "4c1701b8743d9710d803e71c84fd71d6e6f986acb2659bff786fff32a3cea54c", - "tensors": [ + }, { - "name": "W_storage", + "name": "b", "shape": [ - 16384 + 128 ], "dtype": "float32", - "src": "A12", + "src": "A09", "op": { "name": "f16" }, - "base": 0, - "axes": [ - { - "stride": 1 - } - ] - }, - { - "name": "b", - "shape": [ - 128 - ], - "dtype": "float32", - "src": "A12", - "op": { - "name": "f16" - }, - "base": 32768, + "base": 65536, "axes": [ { "offsets": [ @@ -3185,142 +6236,299 @@ ] }, { - "stage": "dl1.l13", - "digest": "2601e2404933d0b976015adc1a37273980fe66bb6fb5b6f5118dc699550017aa", + "stage": "dl1.l10", + "digest": "51342765344b32690063e85bf71e66383cf91d905f04948a9d859734266cd885", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 8192 + 128, + 128 ], "dtype": "float32", - "src": "A13", + "src": "A10", "op": { "name": "f16" }, "base": 0, "axes": [ { - "stride": 1 - } - ] - }, - { - "name": "b", - "shape": [ - 64 - ], - "dtype": "float32", - "src": "A13", - "op": { - "name": "f16" - }, - "base": 16384, - "axes": [ + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 1024, + 1040, + 1056, + 1072, + 1088, + 1104, + 1120, + 1136, + 2048, + 2064, + 2080, + 2096, + 2112, + 2128, + 2144, + 2160, + 3072, + 3088, + 3104, + 3120, + 3136, + 3152, + 3168, + 3184, + 4096, + 4112, + 4128, + 4144, + 4160, + 4176, + 4192, + 4208, + 5120, + 5136, + 5152, + 5168, + 5184, + 5200, + 5216, + 5232, + 6144, + 6160, + 6176, + 6192, + 6208, + 6224, + 6240, + 6256, + 7168, + 7184, + 7200, + 7216, + 7232, + 7248, + 7264, + 7280, + 8192, + 8208, + 8224, + 8240, + 8256, + 8272, + 8288, + 8304, + 9216, + 9232, + 9248, + 9264, + 9280, + 9296, + 9312, + 9328, + 10240, + 10256, + 10272, + 10288, + 10304, + 10320, + 10336, + 10352, + 11264, + 11280, + 11296, + 11312, + 11328, + 11344, + 11360, + 11376, + 12288, + 12304, + 12320, + 12336, + 12352, + 12368, + 12384, + 12400, + 13312, + 13328, + 13344, + 13360, + 13376, + 13392, + 13408, + 13424, + 14336, + 14352, + 14368, + 14384, + 14400, + 14416, + 14432, + 14448, + 15360, + 15376, + 15392, + 15408, + 15424, + 15440, + 15456, + 15472 + ] + }, { "offsets": [ 0, 1, - 2, - 3, 4, 5, + 8, + 9, + 12, + 13, + 2, + 3, 6, 7, + 10, + 11, + 14, + 15, 128, 129, - 130, - 131, 132, 133, + 136, + 137, + 140, + 141, + 130, + 131, 134, 135, + 138, + 139, + 142, + 143, 256, 257, - 258, - 259, 260, 261, + 264, + 265, + 268, + 269, + 258, + 259, 262, 263, + 266, + 267, + 270, + 271, 384, 385, - 386, - 387, 388, 389, + 392, + 393, + 396, + 397, + 386, + 387, 390, 391, + 394, + 395, + 398, + 399, 512, 513, - 514, - 515, 516, 517, + 520, + 521, + 524, + 525, + 514, + 515, 518, 519, + 522, + 523, + 526, + 527, 640, 641, - 642, - 643, 644, 645, + 648, + 649, + 652, + 653, + 642, + 643, 646, 647, + 650, + 651, + 654, + 655, 768, 769, - 770, - 771, 772, 773, + 776, + 777, + 780, + 781, + 770, + 771, 774, 775, + 778, + 779, + 782, + 783, 896, 897, - 898, - 899, 900, 901, + 904, + 905, + 908, + 909, + 898, + 899, 902, - 903 + 903, + 906, + 907, + 910, + 911 ] } ] - } - ] - }, - { - "stage": "dl1.l14", - "digest": "07c365af348c83a108582e929d5a93ab50866170d4132c3fb6e14ecf54eaa79c", - "tensors": [ - { - "name": "W_storage", - "shape": [ - 4096 - ], - "dtype": "float32", - "src": "A14", - "op": { - "name": "f16" - }, - "base": 0, - "axes": [ - { - "stride": 1 - } - ] }, { "name": "b", "shape": [ - 64 + 128 ], "dtype": "float32", - "src": "A14", + "src": "A10", "op": { "name": "f16" }, - "base": 8192, + "base": 32768, "axes": [ { "offsets": [ @@ -3387,7 +6595,71 @@ 900, 901, 902, - 903 + 903, + 1024, + 1025, + 1026, + 1027, + 1028, + 1029, + 1030, + 1031, + 1152, + 1153, + 1154, + 1155, + 1156, + 1157, + 1158, + 1159, + 1280, + 1281, + 1282, + 1283, + 1284, + 1285, + 1286, + 1287, + 1408, + 1409, + 1410, + 1411, + 1412, + 1413, + 1414, + 1415, + 1536, + 1537, + 1538, + 1539, + 1540, + 1541, + 1542, + 1543, + 1664, + 1665, + 1666, + 1667, + 1668, + 1669, + 1670, + 1671, + 1792, + 1793, + 1794, + 1795, + 1796, + 1797, + 1798, + 1799, + 1920, + 1921, + 1922, + 1923, + 1924, + 1925, + 1926, + 1927 ] } ] @@ -3395,86 +6667,1593 @@ ] }, { - "stage": "dl1.l15", - "digest": "ed7003b81858ad93be1ec1ba54c627581050124e2e307603c84cb5cc9383e858", + "stage": "dl1.l11", + "digest": "c0e54c1b3b4439e445017f7b207be625e4a955baa93b23cbde1d6fef1fbede90", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 2048 + 128, + 128 ], "dtype": "float32", - "src": "A15", + "src": "A11", "op": { "name": "f16" }, "base": 0, "axes": [ { - "stride": 1 - } - ] - }, - { - "name": "b", - "shape": [ - 32 - ], - "dtype": "float32", - "src": "A15", - "op": { - "name": "f16" - }, - "base": 4096, - "axes": [ + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 1024, + 1040, + 1056, + 1072, + 1088, + 1104, + 1120, + 1136, + 2048, + 2064, + 2080, + 2096, + 2112, + 2128, + 2144, + 2160, + 3072, + 3088, + 3104, + 3120, + 3136, + 3152, + 3168, + 3184, + 4096, + 4112, + 4128, + 4144, + 4160, + 4176, + 4192, + 4208, + 5120, + 5136, + 5152, + 5168, + 5184, + 5200, + 5216, + 5232, + 6144, + 6160, + 6176, + 6192, + 6208, + 6224, + 6240, + 6256, + 7168, + 7184, + 7200, + 7216, + 7232, + 7248, + 7264, + 7280, + 8192, + 8208, + 8224, + 8240, + 8256, + 8272, + 8288, + 8304, + 9216, + 9232, + 9248, + 9264, + 9280, + 9296, + 9312, + 9328, + 10240, + 10256, + 10272, + 10288, + 10304, + 10320, + 10336, + 10352, + 11264, + 11280, + 11296, + 11312, + 11328, + 11344, + 11360, + 11376, + 12288, + 12304, + 12320, + 12336, + 12352, + 12368, + 12384, + 12400, + 13312, + 13328, + 13344, + 13360, + 13376, + 13392, + 13408, + 13424, + 14336, + 14352, + 14368, + 14384, + 14400, + 14416, + 14432, + 14448, + 15360, + 15376, + 15392, + 15408, + 15424, + 15440, + 15456, + 15472 + ] + }, { "offsets": [ 0, 1, - 2, - 3, 4, 5, + 8, + 9, + 12, + 13, + 2, + 3, 6, 7, + 10, + 11, + 14, + 15, 128, 129, - 130, - 131, 132, 133, + 136, + 137, + 140, + 141, + 130, + 131, 134, 135, + 138, + 139, + 142, + 143, 256, 257, - 258, - 259, 260, 261, + 264, + 265, + 268, + 269, + 258, + 259, 262, 263, + 266, + 267, + 270, + 271, 384, 385, - 386, - 387, 388, 389, + 392, + 393, + 396, + 397, + 386, + 387, 390, - 391 + 391, + 394, + 395, + 398, + 399, + 512, + 513, + 516, + 517, + 520, + 521, + 524, + 525, + 514, + 515, + 518, + 519, + 522, + 523, + 526, + 527, + 640, + 641, + 644, + 645, + 648, + 649, + 652, + 653, + 642, + 643, + 646, + 647, + 650, + 651, + 654, + 655, + 768, + 769, + 772, + 773, + 776, + 777, + 780, + 781, + 770, + 771, + 774, + 775, + 778, + 779, + 782, + 783, + 896, + 897, + 900, + 901, + 904, + 905, + 908, + 909, + 898, + 899, + 902, + 903, + 906, + 907, + 910, + 911 ] } ] - } - ] - }, - { + }, + { + "name": "b", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "A11", + "op": { + "name": "f16" + }, + "base": 32768, + "axes": [ + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 512, + 513, + 514, + 515, + 516, + 517, + 518, + 519, + 640, + 641, + 642, + 643, + 644, + 645, + 646, + 647, + 768, + 769, + 770, + 771, + 772, + 773, + 774, + 775, + 896, + 897, + 898, + 899, + 900, + 901, + 902, + 903, + 1024, + 1025, + 1026, + 1027, + 1028, + 1029, + 1030, + 1031, + 1152, + 1153, + 1154, + 1155, + 1156, + 1157, + 1158, + 1159, + 1280, + 1281, + 1282, + 1283, + 1284, + 1285, + 1286, + 1287, + 1408, + 1409, + 1410, + 1411, + 1412, + 1413, + 1414, + 1415, + 1536, + 1537, + 1538, + 1539, + 1540, + 1541, + 1542, + 1543, + 1664, + 1665, + 1666, + 1667, + 1668, + 1669, + 1670, + 1671, + 1792, + 1793, + 1794, + 1795, + 1796, + 1797, + 1798, + 1799, + 1920, + 1921, + 1922, + 1923, + 1924, + 1925, + 1926, + 1927 + ] + } + ] + } + ] + }, + { + "stage": "dl1.l12", + "digest": "06bcae448b141da4d6e2ca0142e2c796926dfd91f52081ae1e472ccfc8b219d9", + "tensors": [ + { + "name": "W", + "shape": [ + 128, + 128 + ], + "dtype": "float32", + "src": "A12", + "op": { + "name": "f16" + }, + "base": 0, + "axes": [ + { + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 1024, + 1040, + 1056, + 1072, + 1088, + 1104, + 1120, + 1136, + 2048, + 2064, + 2080, + 2096, + 2112, + 2128, + 2144, + 2160, + 3072, + 3088, + 3104, + 3120, + 3136, + 3152, + 3168, + 3184, + 4096, + 4112, + 4128, + 4144, + 4160, + 4176, + 4192, + 4208, + 5120, + 5136, + 5152, + 5168, + 5184, + 5200, + 5216, + 5232, + 6144, + 6160, + 6176, + 6192, + 6208, + 6224, + 6240, + 6256, + 7168, + 7184, + 7200, + 7216, + 7232, + 7248, + 7264, + 7280, + 8192, + 8208, + 8224, + 8240, + 8256, + 8272, + 8288, + 8304, + 9216, + 9232, + 9248, + 9264, + 9280, + 9296, + 9312, + 9328, + 10240, + 10256, + 10272, + 10288, + 10304, + 10320, + 10336, + 10352, + 11264, + 11280, + 11296, + 11312, + 11328, + 11344, + 11360, + 11376, + 12288, + 12304, + 12320, + 12336, + 12352, + 12368, + 12384, + 12400, + 13312, + 13328, + 13344, + 13360, + 13376, + 13392, + 13408, + 13424, + 14336, + 14352, + 14368, + 14384, + 14400, + 14416, + 14432, + 14448, + 15360, + 15376, + 15392, + 15408, + 15424, + 15440, + 15456, + 15472 + ] + }, + { + "offsets": [ + 0, + 1, + 4, + 5, + 8, + 9, + 12, + 13, + 2, + 3, + 6, + 7, + 10, + 11, + 14, + 15, + 128, + 129, + 132, + 133, + 136, + 137, + 140, + 141, + 130, + 131, + 134, + 135, + 138, + 139, + 142, + 143, + 256, + 257, + 260, + 261, + 264, + 265, + 268, + 269, + 258, + 259, + 262, + 263, + 266, + 267, + 270, + 271, + 384, + 385, + 388, + 389, + 392, + 393, + 396, + 397, + 386, + 387, + 390, + 391, + 394, + 395, + 398, + 399, + 512, + 513, + 516, + 517, + 520, + 521, + 524, + 525, + 514, + 515, + 518, + 519, + 522, + 523, + 526, + 527, + 640, + 641, + 644, + 645, + 648, + 649, + 652, + 653, + 642, + 643, + 646, + 647, + 650, + 651, + 654, + 655, + 768, + 769, + 772, + 773, + 776, + 777, + 780, + 781, + 770, + 771, + 774, + 775, + 778, + 779, + 782, + 783, + 896, + 897, + 900, + 901, + 904, + 905, + 908, + 909, + 898, + 899, + 902, + 903, + 906, + 907, + 910, + 911 + ] + } + ] + }, + { + "name": "b", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "A12", + "op": { + "name": "f16" + }, + "base": 32768, + "axes": [ + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 512, + 513, + 514, + 515, + 516, + 517, + 518, + 519, + 640, + 641, + 642, + 643, + 644, + 645, + 646, + 647, + 768, + 769, + 770, + 771, + 772, + 773, + 774, + 775, + 896, + 897, + 898, + 899, + 900, + 901, + 902, + 903, + 1024, + 1025, + 1026, + 1027, + 1028, + 1029, + 1030, + 1031, + 1152, + 1153, + 1154, + 1155, + 1156, + 1157, + 1158, + 1159, + 1280, + 1281, + 1282, + 1283, + 1284, + 1285, + 1286, + 1287, + 1408, + 1409, + 1410, + 1411, + 1412, + 1413, + 1414, + 1415, + 1536, + 1537, + 1538, + 1539, + 1540, + 1541, + 1542, + 1543, + 1664, + 1665, + 1666, + 1667, + 1668, + 1669, + 1670, + 1671, + 1792, + 1793, + 1794, + 1795, + 1796, + 1797, + 1798, + 1799, + 1920, + 1921, + 1922, + 1923, + 1924, + 1925, + 1926, + 1927 + ] + } + ] + } + ] + }, + { + "stage": "dl1.l13", + "digest": "97ef22d220e4103c9070aef7278dbd342e1760dfd21d5b1645f858ca30c21adc", + "tensors": [ + { + "name": "W", + "shape": [ + 64, + 128 + ], + "dtype": "float32", + "src": "A13", + "op": { + "name": "f16" + }, + "base": 0, + "axes": [ + { + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 1024, + 1040, + 1056, + 1072, + 1088, + 1104, + 1120, + 1136, + 2048, + 2064, + 2080, + 2096, + 2112, + 2128, + 2144, + 2160, + 3072, + 3088, + 3104, + 3120, + 3136, + 3152, + 3168, + 3184, + 4096, + 4112, + 4128, + 4144, + 4160, + 4176, + 4192, + 4208, + 5120, + 5136, + 5152, + 5168, + 5184, + 5200, + 5216, + 5232, + 6144, + 6160, + 6176, + 6192, + 6208, + 6224, + 6240, + 6256, + 7168, + 7184, + 7200, + 7216, + 7232, + 7248, + 7264, + 7280 + ] + }, + { + "offsets": [ + 0, + 1, + 4, + 5, + 8, + 9, + 12, + 13, + 2, + 3, + 6, + 7, + 10, + 11, + 14, + 15, + 128, + 129, + 132, + 133, + 136, + 137, + 140, + 141, + 130, + 131, + 134, + 135, + 138, + 139, + 142, + 143, + 256, + 257, + 260, + 261, + 264, + 265, + 268, + 269, + 258, + 259, + 262, + 263, + 266, + 267, + 270, + 271, + 384, + 385, + 388, + 389, + 392, + 393, + 396, + 397, + 386, + 387, + 390, + 391, + 394, + 395, + 398, + 399, + 512, + 513, + 516, + 517, + 520, + 521, + 524, + 525, + 514, + 515, + 518, + 519, + 522, + 523, + 526, + 527, + 640, + 641, + 644, + 645, + 648, + 649, + 652, + 653, + 642, + 643, + 646, + 647, + 650, + 651, + 654, + 655, + 768, + 769, + 772, + 773, + 776, + 777, + 780, + 781, + 770, + 771, + 774, + 775, + 778, + 779, + 782, + 783, + 896, + 897, + 900, + 901, + 904, + 905, + 908, + 909, + 898, + 899, + 902, + 903, + 906, + 907, + 910, + 911 + ] + } + ] + }, + { + "name": "b", + "shape": [ + 64 + ], + "dtype": "float32", + "src": "A13", + "op": { + "name": "f16" + }, + "base": 16384, + "axes": [ + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 512, + 513, + 514, + 515, + 516, + 517, + 518, + 519, + 640, + 641, + 642, + 643, + 644, + 645, + 646, + 647, + 768, + 769, + 770, + 771, + 772, + 773, + 774, + 775, + 896, + 897, + 898, + 899, + 900, + 901, + 902, + 903 + ] + } + ] + } + ] + }, + { + "stage": "dl1.l14", + "digest": "dedf27b0ccfaaa64061ebc133f43773136820b56473ad17790076622d27c1b94", + "tensors": [ + { + "name": "W", + "shape": [ + 64, + 64 + ], + "dtype": "float32", + "src": "A14", + "op": { + "name": "f16" + }, + "base": 0, + "axes": [ + { + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 512, + 528, + 544, + 560, + 576, + 592, + 608, + 624, + 1024, + 1040, + 1056, + 1072, + 1088, + 1104, + 1120, + 1136, + 1536, + 1552, + 1568, + 1584, + 1600, + 1616, + 1632, + 1648, + 2048, + 2064, + 2080, + 2096, + 2112, + 2128, + 2144, + 2160, + 2560, + 2576, + 2592, + 2608, + 2624, + 2640, + 2656, + 2672, + 3072, + 3088, + 3104, + 3120, + 3136, + 3152, + 3168, + 3184, + 3584, + 3600, + 3616, + 3632, + 3648, + 3664, + 3680, + 3696 + ] + }, + { + "offsets": [ + 0, + 1, + 4, + 5, + 8, + 9, + 12, + 13, + 2, + 3, + 6, + 7, + 10, + 11, + 14, + 15, + 128, + 129, + 132, + 133, + 136, + 137, + 140, + 141, + 130, + 131, + 134, + 135, + 138, + 139, + 142, + 143, + 256, + 257, + 260, + 261, + 264, + 265, + 268, + 269, + 258, + 259, + 262, + 263, + 266, + 267, + 270, + 271, + 384, + 385, + 388, + 389, + 392, + 393, + 396, + 397, + 386, + 387, + 390, + 391, + 394, + 395, + 398, + 399 + ] + } + ] + }, + { + "name": "b", + "shape": [ + 64 + ], + "dtype": "float32", + "src": "A14", + "op": { + "name": "f16" + }, + "base": 8192, + "axes": [ + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 512, + 513, + 514, + 515, + 516, + 517, + 518, + 519, + 640, + 641, + 642, + 643, + 644, + 645, + 646, + 647, + 768, + 769, + 770, + 771, + 772, + 773, + 774, + 775, + 896, + 897, + 898, + 899, + 900, + 901, + 902, + 903 + ] + } + ] + } + ] + }, + { + "stage": "dl1.l15", + "digest": "785caeb8bad0b97c48474ddb3af30fd311f39f745ea64e41faaaa7555234904d", + "tensors": [ + { + "name": "W", + "shape": [ + 32, + 64 + ], + "dtype": "float32", + "src": "A15", + "op": { + "name": "f16" + }, + "base": 0, + "axes": [ + { + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 512, + 528, + 544, + 560, + 576, + 592, + 608, + 624, + 1024, + 1040, + 1056, + 1072, + 1088, + 1104, + 1120, + 1136, + 1536, + 1552, + 1568, + 1584, + 1600, + 1616, + 1632, + 1648 + ] + }, + { + "offsets": [ + 0, + 1, + 4, + 5, + 8, + 9, + 12, + 13, + 2, + 3, + 6, + 7, + 10, + 11, + 14, + 15, + 128, + 129, + 132, + 133, + 136, + 137, + 140, + 141, + 130, + 131, + 134, + 135, + 138, + 139, + 142, + 143, + 256, + 257, + 260, + 261, + 264, + 265, + 268, + 269, + 258, + 259, + 262, + 263, + 266, + 267, + 270, + 271, + 384, + 385, + 388, + 389, + 392, + 393, + 396, + 397, + 386, + 387, + 390, + 391, + 394, + 395, + 398, + 399 + ] + } + ] + }, + { + "name": "b", + "shape": [ + 32 + ], + "dtype": "float32", + "src": "A15", + "op": { + "name": "f16" + }, + "base": 4096, + "axes": [ + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391 + ] + } + ] + } + ] + }, + { "stage": "dl1.l16", - "digest": "e16eff6f1f0d70142cb6c7afbd204be8799085eadb978d20cfc55f44f3097d5d", + "digest": "23812b7ffe292a14f51b4d447f6fc3fdd175de5b934d165479c89ff6cad3c7b3", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 1024 + 32, + 32 ], "dtype": "float32", "src": "A16", @@ -3484,7 +8263,76 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 256, + 272, + 288, + 304, + 320, + 336, + 352, + 368, + 512, + 528, + 544, + 560, + 576, + 592, + 608, + 624, + 768, + 784, + 800, + 816, + 832, + 848, + 864, + 880 + ] + }, + { + "offsets": [ + 0, + 1, + 4, + 5, + 8, + 9, + 12, + 13, + 2, + 3, + 6, + 7, + 10, + 11, + 14, + 15, + 128, + 129, + 132, + 133, + 136, + 137, + 140, + 141, + 130, + 131, + 134, + 135, + 138, + 139, + 142, + 143 + ] } ] }, @@ -3542,12 +8390,13 @@ }, { "stage": "dl1.l17", - "digest": "222628c396d386e8bb6fd0eddc17ca43f6885c6884627315362d33c569738bef", + "digest": "37137aca3f8f94b591d6b10d43aa29c1e88668ef17b16d9e86bc1f5f07334595", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 512 + 16, + 32 ], "dtype": "float32", "src": "A17", @@ -3557,7 +8406,60 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 16, + 32, + 48, + 64, + 80, + 96, + 112, + 256, + 272, + 288, + 304, + 320, + 336, + 352, + 368 + ] + }, + { + "offsets": [ + 0, + 1, + 4, + 5, + 8, + 9, + 12, + 13, + 2, + 3, + 6, + 7, + 10, + 11, + 14, + 15, + 128, + 129, + 132, + 133, + 136, + 137, + 140, + 141, + 130, + 131, + 134, + 135, + 138, + 139, + 142, + 143 + ] } ] }, @@ -3599,12 +8501,15 @@ }, { "stage": "dl2.l01", - "digest": "87da0623b0529ed06c72efc2b7c87f0dadf6a2aef17100139e298fbaf7dbb093", + "digest": "821f9bf8ad91a25f0ab654b60d79d9cafca372db8c8ce3b275f8be767b099b90", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 4608 + 32, + 10, + 3, + 3 ], "dtype": "float32", "src": "B01w", @@ -3614,12 +8519,73 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 1152, + 1160, + 1168, + 1176, + 1184, + 1192, + 1200, + 1208, + 2304, + 2312, + 2320, + 2328, + 2336, + 2344, + 2352, + 2360, + 3456, + 3464, + 3472, + 3480, + 3488, + 3496, + 3504, + 3512 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65 + ] + }, + { + "offsets": [ + 0, + 384, + 768 + ] + }, + { + "offsets": [ + 0, + 128, + 256 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 32 ], @@ -3639,12 +8605,15 @@ }, { "stage": "dl2.l02", - "digest": "d8f21628ae51b04523eb262dbf5ad038f879f698cb488e97a63a6d7a5e5835f6", + "digest": "97545012c47f77492262b3c79e61807f2d1c6e2a20ce8f2dcf143b8c108d1f2a", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 9216 + 32, + 32, + 3, + 3 ], "dtype": "float32", "src": "B02w", @@ -3654,12 +8623,95 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 2304, + 2312, + 2320, + 2328, + 2336, + 2344, + 2352, + 2360, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 6912, + 6920, + 6928, + 6936, + 6944, + 6952, + 6960, + 6968 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199 + ] + }, + { + "offsets": [ + 0, + 768, + 1536 + ] + }, + { + "offsets": [ + 0, + 256, + 512 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 32 ], @@ -3679,12 +8731,15 @@ }, { "stage": "dl2.l03", - "digest": "09985bdaa0949d83479812532cfa4be1c0961626cf595ce3ddd125eb41eba28e", + "digest": "fa45e2bff96d5cbebad2e9b077343f817d6930e107a44cb4434a802797708b65", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 18432 + 64, + 32, + 3, + 3 ], "dtype": "float32", "src": "B03w", @@ -3694,12 +8749,127 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 2304, + 2312, + 2320, + 2328, + 2336, + 2344, + 2352, + 2360, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 6912, + 6920, + 6928, + 6936, + 6944, + 6952, + 6960, + 6968, + 9216, + 9224, + 9232, + 9240, + 9248, + 9256, + 9264, + 9272, + 11520, + 11528, + 11536, + 11544, + 11552, + 11560, + 11568, + 11576, + 13824, + 13832, + 13840, + 13848, + 13856, + 13864, + 13872, + 13880, + 16128, + 16136, + 16144, + 16152, + 16160, + 16168, + 16176, + 16184 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199 + ] + }, + { + "offsets": [ + 0, + 768, + 1536 + ] + }, + { + "offsets": [ + 0, + 256, + 512 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 64 ], @@ -3719,12 +8889,15 @@ }, { "stage": "dl2.l04", - "digest": "2d709975f0e6e2cd2acfe30fe3f835ca02a97d413a4d93ea31e4a22dda754651", + "digest": "0393cc524d5eac266f0175504c7e69c427c0bbc407f73170a2ecc94b85654737", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 36864 + 64, + 64, + 3, + 3 ], "dtype": "float32", "src": "B04w", @@ -3734,12 +8907,159 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 9216, + 9224, + 9232, + 9240, + 9248, + 9256, + 9264, + 9272, + 13824, + 13832, + 13840, + 13848, + 13856, + 13864, + 13872, + 13880, + 18432, + 18440, + 18448, + 18456, + 18464, + 18472, + 18480, + 18488, + 23040, + 23048, + 23056, + 23064, + 23072, + 23080, + 23088, + 23096, + 27648, + 27656, + 27664, + 27672, + 27680, + 27688, + 27696, + 27704, + 32256, + 32264, + 32272, + 32280, + 32288, + 32296, + 32304, + 32312 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455 + ] + }, + { + "offsets": [ + 0, + 1536, + 3072 + ] + }, + { + "offsets": [ + 0, + 512, + 1024 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 64 ], @@ -3759,12 +9079,15 @@ }, { "stage": "dl2.l05", - "digest": "f1d710e1fe1ff6c72858bd7c5278e0fb9ab22ab902d789d9b51438c5677ba336", + "digest": "6c6a28c570dba15f85ec099862e6b15ef64fe11013774f64fb1e61325e43ef5a", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 36864 + 64, + 64, + 3, + 3 ], "dtype": "float32", "src": "B05w", @@ -3774,12 +9097,159 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 9216, + 9224, + 9232, + 9240, + 9248, + 9256, + 9264, + 9272, + 13824, + 13832, + 13840, + 13848, + 13856, + 13864, + 13872, + 13880, + 18432, + 18440, + 18448, + 18456, + 18464, + 18472, + 18480, + 18488, + 23040, + 23048, + 23056, + 23064, + 23072, + 23080, + 23088, + 23096, + 27648, + 27656, + 27664, + 27672, + 27680, + 27688, + 27696, + 27704, + 32256, + 32264, + 32272, + 32280, + 32288, + 32296, + 32304, + 32312 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455 + ] + }, + { + "offsets": [ + 0, + 1536, + 3072 + ] + }, + { + "offsets": [ + 0, + 512, + 1024 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 64 ], @@ -3799,12 +9269,15 @@ }, { "stage": "dl2.l06", - "digest": "67aebc37c612647e4dabbe602d14e7c587d476268b5e4e51fcd0f137134f7c5a", + "digest": "7a18ae601cc926cbab2add8164f1ac2becb5e82108aca438b13d88ecd241580a", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 36864 + 64, + 64, + 3, + 3 ], "dtype": "float32", "src": "B06w", @@ -3814,12 +9287,159 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 9216, + 9224, + 9232, + 9240, + 9248, + 9256, + 9264, + 9272, + 13824, + 13832, + 13840, + 13848, + 13856, + 13864, + 13872, + 13880, + 18432, + 18440, + 18448, + 18456, + 18464, + 18472, + 18480, + 18488, + 23040, + 23048, + 23056, + 23064, + 23072, + 23080, + 23088, + 23096, + 27648, + 27656, + 27664, + 27672, + 27680, + 27688, + 27696, + 27704, + 32256, + 32264, + 32272, + 32280, + 32288, + 32296, + 32304, + 32312 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455 + ] + }, + { + "offsets": [ + 0, + 1536, + 3072 + ] + }, + { + "offsets": [ + 0, + 512, + 1024 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 64 ], @@ -3839,12 +9459,15 @@ }, { "stage": "dl2.l07", - "digest": "55845bdd1b2b05be011ebf8c8bf2ef429803c48a894ab1be431ee35ff4343f7f", + "digest": "94088846a88677ac25f62e93e778a2386c0bc5b486ee25a246c1c5b6fc866e00", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 36864 + 64, + 64, + 3, + 3 ], "dtype": "float32", "src": "B07w", @@ -3854,12 +9477,159 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 9216, + 9224, + 9232, + 9240, + 9248, + 9256, + 9264, + 9272, + 13824, + 13832, + 13840, + 13848, + 13856, + 13864, + 13872, + 13880, + 18432, + 18440, + 18448, + 18456, + 18464, + 18472, + 18480, + 18488, + 23040, + 23048, + 23056, + 23064, + 23072, + 23080, + 23088, + 23096, + 27648, + 27656, + 27664, + 27672, + 27680, + 27688, + 27696, + 27704, + 32256, + 32264, + 32272, + 32280, + 32288, + 32296, + 32304, + 32312 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455 + ] + }, + { + "offsets": [ + 0, + 1536, + 3072 + ] + }, + { + "offsets": [ + 0, + 512, + 1024 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 64 ], @@ -3879,12 +9649,15 @@ }, { "stage": "dl2.l08", - "digest": "d94fb884b0bc227f8bd2940bfa49bfe9f5c71545daf5d6503205f17d1bacba86", + "digest": "1c81e5b5dcde8d67ed3f6199eae56aa7b45b1e0683bc85ece5c82b0113576823", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 36864 + 64, + 64, + 3, + 3 ], "dtype": "float32", "src": "B08w", @@ -3894,12 +9667,159 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 9216, + 9224, + 9232, + 9240, + 9248, + 9256, + 9264, + 9272, + 13824, + 13832, + 13840, + 13848, + 13856, + 13864, + 13872, + 13880, + 18432, + 18440, + 18448, + 18456, + 18464, + 18472, + 18480, + 18488, + 23040, + 23048, + 23056, + 23064, + 23072, + 23080, + 23088, + 23096, + 27648, + 27656, + 27664, + 27672, + 27680, + 27688, + 27696, + 27704, + 32256, + 32264, + 32272, + 32280, + 32288, + 32296, + 32304, + 32312 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455 + ] + }, + { + "offsets": [ + 0, + 1536, + 3072 + ] + }, + { + "offsets": [ + 0, + 512, + 1024 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 64 ], @@ -3919,12 +9839,15 @@ }, { "stage": "dl2.l09", - "digest": "b9363f6337c33b2d77c975a838d9a1f11a32be0171a9d74ff3f0679369d5f45c", + "digest": "27732fdba6b1d978d95a957ac15685338cae1830d08b55b4d823bf9d84e16a79", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 36864 + 64, + 64, + 3, + 3 ], "dtype": "float32", "src": "B09w", @@ -3934,12 +9857,159 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 9216, + 9224, + 9232, + 9240, + 9248, + 9256, + 9264, + 9272, + 13824, + 13832, + 13840, + 13848, + 13856, + 13864, + 13872, + 13880, + 18432, + 18440, + 18448, + 18456, + 18464, + 18472, + 18480, + 18488, + 23040, + 23048, + 23056, + 23064, + 23072, + 23080, + 23088, + 23096, + 27648, + 27656, + 27664, + 27672, + 27680, + 27688, + 27696, + 27704, + 32256, + 32264, + 32272, + 32280, + 32288, + 32296, + 32304, + 32312 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455 + ] + }, + { + "offsets": [ + 0, + 1536, + 3072 + ] + }, + { + "offsets": [ + 0, + 512, + 1024 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 64 ], @@ -3959,12 +10029,15 @@ }, { "stage": "dl2.l10", - "digest": "58186c682a039dc7b8c1b96e0c17c7ac68c80507eb650041258a9a5797da8f6c", + "digest": "be26e6b38d2234e516f3127be831bd7cc5f4491656af1b13c724f63ed81a671e", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 36864 + 64, + 64, + 3, + 3 ], "dtype": "float32", "src": "B10w", @@ -3974,12 +10047,159 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 9216, + 9224, + 9232, + 9240, + 9248, + 9256, + 9264, + 9272, + 13824, + 13832, + 13840, + 13848, + 13856, + 13864, + 13872, + 13880, + 18432, + 18440, + 18448, + 18456, + 18464, + 18472, + 18480, + 18488, + 23040, + 23048, + 23056, + 23064, + 23072, + 23080, + 23088, + 23096, + 27648, + 27656, + 27664, + 27672, + 27680, + 27688, + 27696, + 27704, + 32256, + 32264, + 32272, + 32280, + 32288, + 32296, + 32304, + 32312 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455 + ] + }, + { + "offsets": [ + 0, + 1536, + 3072 + ] + }, + { + "offsets": [ + 0, + 512, + 1024 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 64 ], @@ -3999,12 +10219,15 @@ }, { "stage": "dl2.l11", - "digest": "e1f162b3c41f24bdbac32eee96bc16ae742d1015e920bbf28b776916740fc9b1", + "digest": "5d69953a0e9f3dea10b527361a107c5dcb599f36876d5689a130266fe4add5f1", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 36864 + 64, + 64, + 3, + 3 ], "dtype": "float32", "src": "B11w", @@ -4014,12 +10237,159 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 9216, + 9224, + 9232, + 9240, + 9248, + 9256, + 9264, + 9272, + 13824, + 13832, + 13840, + 13848, + 13856, + 13864, + 13872, + 13880, + 18432, + 18440, + 18448, + 18456, + 18464, + 18472, + 18480, + 18488, + 23040, + 23048, + 23056, + 23064, + 23072, + 23080, + 23088, + 23096, + 27648, + 27656, + 27664, + 27672, + 27680, + 27688, + 27696, + 27704, + 32256, + 32264, + 32272, + 32280, + 32288, + 32296, + 32304, + 32312 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455 + ] + }, + { + "offsets": [ + 0, + 1536, + 3072 + ] + }, + { + "offsets": [ + 0, + 512, + 1024 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 64 ], @@ -4039,12 +10409,15 @@ }, { "stage": "dl2.l12", - "digest": "bbeaf1caacca4490774b21063b82224a33d993226a2b1c3cfaac0391a19e7518", + "digest": "741a9368783a78b74f0ea107260194844419b2fd148e382da6b070662656264a", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 55296 + 96, + 64, + 3, + 3 ], "dtype": "float32", "src": "B12w", @@ -4054,12 +10427,191 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 9216, + 9224, + 9232, + 9240, + 9248, + 9256, + 9264, + 9272, + 13824, + 13832, + 13840, + 13848, + 13856, + 13864, + 13872, + 13880, + 18432, + 18440, + 18448, + 18456, + 18464, + 18472, + 18480, + 18488, + 23040, + 23048, + 23056, + 23064, + 23072, + 23080, + 23088, + 23096, + 27648, + 27656, + 27664, + 27672, + 27680, + 27688, + 27696, + 27704, + 32256, + 32264, + 32272, + 32280, + 32288, + 32296, + 32304, + 32312, + 36864, + 36872, + 36880, + 36888, + 36896, + 36904, + 36912, + 36920, + 41472, + 41480, + 41488, + 41496, + 41504, + 41512, + 41520, + 41528, + 46080, + 46088, + 46096, + 46104, + 46112, + 46120, + 46128, + 46136, + 50688, + 50696, + 50704, + 50712, + 50720, + 50728, + 50736, + 50744 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455 + ] + }, + { + "offsets": [ + 0, + 1536, + 3072 + ] + }, + { + "offsets": [ + 0, + 512, + 1024 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 96 ], @@ -4079,12 +10631,15 @@ }, { "stage": "dl2.l13", - "digest": "853c80dae991ec68fe8d1b4b353f2dd45699c4040a8b163f888ab289d3ba0c0f", + "digest": "6ccbe3e1285021230883cb4b051d80234663e3015f049ef5c63de2f59e34beb4", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 2304 + 8, + 32, + 3, + 3 ], "dtype": "float32", "src": "B13w", @@ -4094,12 +10649,71 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199 + ] + }, + { + "offsets": [ + 0, + 768, + 1536 + ] + }, + { + "offsets": [ + 0, + 256, + 512 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 8 ], @@ -4119,12 +10733,15 @@ }, { "stage": "dl2.l14", - "digest": "3af50f878cd718fc74232f8748ad2e01de32ca78e3a8d1a29ec907c3f3be5fc7", + "digest": "92f6f6fef08cfa53208c4cabc5a11d9157502c401f6f96ecbaa3ece72864cd5f", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 2592 + 16, + 18, + 3, + 3 ], "dtype": "float32", "src": "B14w", @@ -4134,12 +10751,65 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 162, + 324, + 486, + 648, + 810, + 972, + 1134, + 1296, + 1458, + 1620, + 1782, + 1944, + 2106, + 2268, + 2430 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17 + ] + }, + { + "offsets": [ + 0, + 54, + 108 + ] + }, + { + "offsets": [ + 0, + 18, + 36 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 16 ], @@ -4159,12 +10829,15 @@ }, { "stage": "dl2.l15", - "digest": "aabc4f6d40f7862f04aa6e9c3df5cf418c18a50109b0e2bc967e17fa06077839", + "digest": "e68718a10e93796537c8056f11cc0c8bc5f69b5ead5d25f69c86d95a5ae1c25a", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 4608 + 32, + 16, + 3, + 3 ], "dtype": "float32", "src": "B15w", @@ -4174,12 +10847,79 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 1152, + 1160, + 1168, + 1176, + 1184, + 1192, + 1200, + 1208, + 2304, + 2312, + 2320, + 2328, + 2336, + 2344, + 2352, + 2360, + 3456, + 3464, + 3472, + 3480, + 3488, + 3496, + 3504, + 3512 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71 + ] + }, + { + "offsets": [ + 0, + 384, + 768 + ] + }, + { + "offsets": [ + 0, + 128, + 256 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 32 ], @@ -4199,12 +10939,15 @@ }, { "stage": "dl2.l16", - "digest": "71247b01d659365ed4055027b23d8fce45a2b9d28ea0c2127cbe859f5058174f", + "digest": "2ea2d27d3b7cb197b48c6357b47168ea17376ee14836326da9e13f2d13b45a5b", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 9216 + 32, + 32, + 3, + 3 ], "dtype": "float32", "src": "B16w", @@ -4214,12 +10957,95 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 2304, + 2312, + 2320, + 2328, + 2336, + 2344, + 2352, + 2360, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 6912, + 6920, + 6928, + 6936, + 6944, + 6952, + 6960, + 6968 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199 + ] + }, + { + "offsets": [ + 0, + 768, + 1536 + ] + }, + { + "offsets": [ + 0, + 256, + 512 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 32 ], @@ -4239,12 +11065,15 @@ }, { "stage": "dl2.l17", - "digest": "aba92780dbb81ce8873eee797056a9f829f364d95254b7dbc1446fb5870b4866", + "digest": "09ab3392de98b09d5cb3eb602adbf6bd1305fdf47d63e6bf510c886c98baeb5d", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 9216 + 32, + 32, + 3, + 3 ], "dtype": "float32", "src": "B17w", @@ -4254,12 +11083,95 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 2304, + 2312, + 2320, + 2328, + 2336, + 2344, + 2352, + 2360, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 6912, + 6920, + 6928, + 6936, + 6944, + 6952, + 6960, + 6968 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199 + ] + }, + { + "offsets": [ + 0, + 768, + 1536 + ] + }, + { + "offsets": [ + 0, + 256, + 512 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 32 ], @@ -4279,12 +11191,15 @@ }, { "stage": "dl2.l18", - "digest": "10dde96b92d3ae18452c0d1525a978478338111185c0e587e9fa9c8e1c2e15d5", + "digest": "606639738db6e841a29290de42b0b26ec667f80f5e5b5f857c0c2a889fe2646b", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 9216 + 32, + 32, + 3, + 3 ], "dtype": "float32", "src": "B18w", @@ -4294,12 +11209,95 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 2304, + 2312, + 2320, + 2328, + 2336, + 2344, + 2352, + 2360, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 6912, + 6920, + 6928, + 6936, + 6944, + 6952, + 6960, + 6968 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199 + ] + }, + { + "offsets": [ + 0, + 768, + 1536 + ] + }, + { + "offsets": [ + 0, + 256, + 512 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 32 ], @@ -4319,12 +11317,15 @@ }, { "stage": "dl2.l19", - "digest": "ea09b8b33e7ad3bdaaa782e688570418eca1db3e55e2e22b1403790bd3d7193b", + "digest": "59d64c2102a60da8a222293a3a45058e0e379e355b5f3db9d7669d50cac6a58b", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 9216 + 32, + 32, + 3, + 3 ], "dtype": "float32", "src": "B19w", @@ -4334,12 +11335,95 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 2304, + 2312, + 2320, + 2328, + 2336, + 2344, + 2352, + 2360, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 6912, + 6920, + 6928, + 6936, + 6944, + 6952, + 6960, + 6968 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199 + ] + }, + { + "offsets": [ + 0, + 768, + 1536 + ] + }, + { + "offsets": [ + 0, + 256, + 512 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 32 ], @@ -4359,12 +11443,15 @@ }, { "stage": "dl2.l20", - "digest": "dd6ba9d71eca72d493fda68a50b58424c120124ceb963459ceaba3ceefd04c96", + "digest": "6e9d2c32fe1bb3a3d946c8fc468e2df5799a085904af20bced2707a54d4bad1a", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 9216 + 32, + 32, + 3, + 3 ], "dtype": "float32", "src": "B20w", @@ -4374,12 +11461,95 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 2304, + 2312, + 2320, + 2328, + 2336, + 2344, + 2352, + 2360, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 6912, + 6920, + 6928, + 6936, + 6944, + 6952, + 6960, + 6968 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199 + ] + }, + { + "offsets": [ + 0, + 768, + 1536 + ] + }, + { + "offsets": [ + 0, + 256, + 512 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 32 ], @@ -4399,12 +11569,15 @@ }, { "stage": "dl2.l21", - "digest": "cdfaa497903c22eba5bf8bce5be70aa3d1a2b08aa2fe44f4e55a5eb29338c912", + "digest": "4fbd088105fde994b4ee1e1afe8af84e137a82841fab6769a2ee777e4b6722c7", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 9216 + 32, + 32, + 3, + 3 ], "dtype": "float32", "src": "B21w", @@ -4414,12 +11587,95 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 2304, + 2312, + 2320, + 2328, + 2336, + 2344, + 2352, + 2360, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 6912, + 6920, + 6928, + 6936, + 6944, + 6952, + 6960, + 6968 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199 + ] + }, + { + "offsets": [ + 0, + 768, + 1536 + ] + }, + { + "offsets": [ + 0, + 256, + 512 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 32 ], @@ -4439,12 +11695,15 @@ }, { "stage": "dl2.l22", - "digest": "94fc412e0f0564cd241466a89ffbbd44ae58d26699c55a2035c5e63d566ff01f", + "digest": "cfee997bcac6ac728b066892f3fe005f783919a9f890733bdb34a799343b1103", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 9216 + 32, + 32, + 3, + 3 ], "dtype": "float32", "src": "B22w", @@ -4454,12 +11713,95 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 2304, + 2312, + 2320, + 2328, + 2336, + 2344, + 2352, + 2360, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 6912, + 6920, + 6928, + 6936, + 6944, + 6952, + 6960, + 6968 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199 + ] + }, + { + "offsets": [ + 0, + 768, + 1536 + ] + }, + { + "offsets": [ + 0, + 256, + 512 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 32 ], @@ -4479,12 +11821,15 @@ }, { "stage": "dl2.l23", - "digest": "92163a4839cf0a227af5ab567b3a213e5f6404f9ac925ef07f66d73c79d2aa27", + "digest": "0dab9916730ec01020327afbb2939622fa15e2d6d43511ee27ad281cf5047d3f", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 9216 + 32, + 32, + 3, + 3 ], "dtype": "float32", "src": "B23w", @@ -4494,12 +11839,95 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 2304, + 2312, + 2320, + 2328, + 2336, + 2344, + 2352, + 2360, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 6912, + 6920, + 6928, + 6936, + 6944, + 6952, + 6960, + 6968 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199 + ] + }, + { + "offsets": [ + 0, + 768, + 1536 + ] + }, + { + "offsets": [ + 0, + 256, + 512 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 32 ], @@ -4519,12 +11947,15 @@ }, { "stage": "dl2.l24", - "digest": "d6540d449e7c28050415d3ed04b5b9f747907695a92f0138348b8ed2ad1e832a", + "digest": "bfea94cea69a7cee1cf9df364f15d74a12e844b97ab270e3c7e6bd9e554294d5", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 13824 + 48, + 32, + 3, + 3 ], "dtype": "float32", "src": "B24w", @@ -4534,12 +11965,111 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56, + 2304, + 2312, + 2320, + 2328, + 2336, + 2344, + 2352, + 2360, + 4608, + 4616, + 4624, + 4632, + 4640, + 4648, + 4656, + 4664, + 6912, + 6920, + 6928, + 6936, + 6944, + 6952, + 6960, + 6968, + 9216, + 9224, + 9232, + 9240, + 9248, + 9256, + 9264, + 9272, + 11520, + 11528, + 11536, + 11544, + 11552, + 11560, + 11568, + 11576 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199 + ] + }, + { + "offsets": [ + 0, + 768, + 1536 + ] + }, + { + "offsets": [ + 0, + 256, + 512 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 48 ], @@ -4559,12 +12089,15 @@ }, { "stage": "dl2.l25", - "digest": "8d15ef21125af97fd32593dfcfdfa907b3091d8a64641baa84d5dbcd809866e5", + "digest": "b0a67649348eacca42c1d96dff047d825ec4bcae6e02cc94a36aed62a46e8776", "tensors": [ { - "name": "W_storage", + "name": "W", "shape": [ - 1152 + 8, + 16, + 3, + 3 ], "dtype": "float32", "src": "B25w", @@ -4574,12 +12107,55 @@ "base": 0, "axes": [ { - "stride": 1 + "offsets": [ + 0, + 8, + 16, + 24, + 32, + 40, + 48, + 56 + ] + }, + { + "offsets": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71 + ] + }, + { + "offsets": [ + 0, + 384, + 768 + ] + }, + { + "offsets": [ + 0, + 128, + 256 + ] } ] }, { - "name": "b_storage", + "name": "b", "shape": [ 8 ],