diff --git a/clean/converter/README.md b/clean/converter/README.md index 00564caf..f69bf582 100644 --- a/clean/converter/README.md +++ b/clean/converter/README.md @@ -31,10 +31,16 @@ data damaged". This is how a further preset that reuses an existing map version **Preset L** (Model L, issue #89) is such a row: `"preset": "L"` in a map of version 1 or 4. Its maps use the record kinds of preset M's (no new element format, op or source kind); its parameters are a block of their own in the same -library file as preset M's, found by its own length and hashes like any source. The map file itself -(`data/preset-L.v1.map.json`) comes with the converter data; until it exists, `tests/run_tests.py` covers preset L with a -synthetic library file holding an L block directly before an M block, and maps for both: each converts its own block, -and a file without a preset's block fails with that preset's message. It also converts an **L-shaped** map +library file as preset M's, found by its own length and hashes like any source. Its map, +`data/preset-L.v1.map.json` (map version 1; sources W, D and K), has no `"preset"` field, so the caller names the +preset: `wronggpu-convert --map data\preset-L.v1.map.json --preset L --dll --out ` (API: +`load_map_bytes(..., "L")`). `--preset` reads a map without the field as that preset when the preset uses the map's +version; a map with the field must name the same preset; anything else is "converter data damaged", and an unknown +`--preset` is a usage error (exit 1). Without `--preset` the preset-L map reads as a version-1 map (preset M's message). +`tests/run_tests.py` checks the real map (validation, the messages, `--preset` mismatches) and converts our own random +data in its exact layout at two placements. It also covers preset L with a synthetic library file holding an L block +directly before an M block, and maps for both: each converts its own block, and a file without a preset's block fails +with that preset's message. It also converts an **L-shaped** map (`tests/cases.py` `l_shaped_map`): preset M's map layout with the input encoder's output linear 64 x 128, and two new stages of L's record kinds (two linears and a C = 32 Swin block before `enc0`, a C = 32 Swin block before `dec0`), filled with our own random data. Its stage names and placement are stand-ins; the real map defines its own. A map of diff --git a/clean/converter/src/api.cpp b/clean/converter/src/api.cpp index bf17981a..396754e2 100644 --- a/clean/converter/src/api.cpp +++ b/clean/converter/src/api.cpp @@ -200,17 +200,18 @@ Result convert_rest_v5(const Map& map, const std::vector& data, co } // namespace -Result load_map_bytes(const std::string& bytes, LoadedMap& out, const LogSink& log) { +Result load_map_bytes(const std::string& bytes, LoadedMap& out, const LogSink& log, const std::string& expected_preset) { out.map = std::make_unique(); MapError me; - if (!load_map(bytes, *out.map, me)) { + if (!load_map(bytes, *out.map, me, expected_preset)) { emit(log, "map: " + me.detail); out.map.reset(); const bool range = me.kind == MapErrorKind::IndexRange; return fail(range ? kMapDoesNotFit : kMapDamaged, range ? kMsgMapDoesNotFit : kMsgMapDamaged); } emit(log, "map sha256 " + to_hex(out.map->file_sha256) + ", " + std::to_string(out.map->stages.size()) + - " stages, model: " + out.map->model); + " stages, model: " + out.map->model + + (expected_preset.empty() ? std::string() : ", preset " + out.map->preset_name)); return Result{}; } diff --git a/clean/converter/src/api.h b/clean/converter/src/api.h index e0f95f25..ff753c91 100644 --- a/clean/converter/src/api.h +++ b/clean/converter/src/api.h @@ -66,8 +66,9 @@ struct LoadedMap { std::unique_ptr map; }; -// Parses and validates a map (no DLL is read). On failure the result carries code 20 or 21. -Result load_map_bytes(const std::string& bytes, LoadedMap& out, const LogSink& log); +// Parses and validates a map (no DLL is read). On failure the result carries code 20 or 21. `expected_preset`: the +// preset the caller loads the map for ("" : the map's own field, or its version's preset; map.h load_map). +Result load_map_bytes(const std::string& bytes, LoadedMap& out, const LogSink& log, const std::string& expected_preset = ""); // One converted file, held in memory (nothing is written). struct Converted { diff --git a/clean/converter/src/main.cpp b/clean/converter/src/main.cpp index e9549be4..e03c0c26 100644 --- a/clean/converter/src/main.cpp +++ b/clean/converter/src/main.cpp @@ -31,11 +31,12 @@ void log_line(const std::string& line) { std::cerr << "[wronggpu-convert] " << l void usage() { std::cout << "usage: wronggpu-convert --map --dll [--dll ...]\n" - " --out [--raw] [--threads N]\n" + " --out [--raw] [--threads N] [--preset M|K|F|L]\n" " --dll may be given several times; the files are tried in order: the first that converts\n" " completely is used (for a map with an optional group, such as preset M's output filter: the\n" " first that has the group, if any has it). The map names its preset (field \"preset\", or by its\n" - " version: 1 and 4 M, 2 and 3 K, 5 F).\n" + " version: 1 and 4 M, 2 and 3 K, 5 F). --preset names the preset the map is for: a map without the\n" + " field is read as that preset (data/preset-L.v1.map.json: --preset L); a map with it must agree.\n" " --raw also writes /raw//.bin for every tensor.\n"; } @@ -43,6 +44,7 @@ int run(const std::vector& args) { fs::path map_path, out_dir; std::vector dlls; bool raw = false; + std::string preset; // --preset: the preset the map is loaded for ("" : the map's field, or its version's preset) SearchOptions opt; for (std::size_t i = 0; i < args.size(); ++i) { const std::string a = args[i].u8string(); @@ -59,6 +61,15 @@ int run(const std::vector& args) { fs::path p; if (!value(p)) return usage(), kUsage; dlls.push_back(p); + } else if (a == "--preset") { + fs::path p; + if (!value(p)) return usage(), kUsage; + preset = p.u8string(); + if (!find_preset(preset)) { + std::cout << "unknown preset: " << preset << "\n"; + usage(); + return kUsage; + } } else if (a == "--raw") { raw = true; } else if (a == "--threads") { @@ -99,7 +110,7 @@ int run(const std::vector& args) { } LoadedMap lm; log_line("map " + map_path.u8string()); - const Result mr = load_map_bytes(map_bytes, lm, log_line); + const Result mr = load_map_bytes(map_bytes, lm, log_line, preset); if (mr.code != kOk) { std::cout << mr.message << std::endl; return mr.code; diff --git a/clean/converter/src/map.cpp b/clean/converter/src/map.cpp index e01f5e97..9dfca8f4 100644 --- a/clean/converter/src/map.cpp +++ b/clean/converter/src/map.cpp @@ -257,6 +257,7 @@ class Loader { if (!p->allows(version_)) return damaged("map: preset " + pj->text + " does not use map version " + std::to_string(version_)); m.preset_name = p->name; + m.preset_named = true; } else { m.preset_name = preset_for_version(version_); } @@ -1397,6 +1398,28 @@ std::string preset_for_version(int version) { return ""; } +bool load_map(const std::string& file_bytes, Map& out, MapError& err, const std::string& expected_preset) { + if (!load_map(file_bytes, out, err)) return false; + if (expected_preset.empty()) return true; + auto damaged = [&](const std::string& detail) { + err.kind = MapErrorKind::Damaged; + err.detail = detail; + out = Map(); + return false; + }; + const PresetInfo* p = find_preset(expected_preset); + if (!p) return damaged("map: preset \"" + expected_preset + "\" asked for is not known"); + if (out.preset_named) { // the map's own field decides; the caller's name must agree with it + if (out.preset_name != p->name) + return damaged("map: the map names preset " + out.preset_name + ", preset " + expected_preset + " was asked for"); + return true; + } + if (!p->allows(out.version)) + return damaged("map: preset " + expected_preset + " does not use map version " + std::to_string(out.version)); + out.preset_name = p->name; + return true; +} + bool load_map(const std::string& file_bytes, Map& out, MapError& err) { out = Map(); err = MapError(); diff --git a/clean/converter/src/map.h b/clean/converter/src/map.h index e3005a91..ca1e79b8 100644 --- a/clean/converter/src/map.h +++ b/clean/converter/src/map.h @@ -241,6 +241,7 @@ struct Map { // The preset, by name ("M", "K", "F"): the map's "preset" field, or preset_for_version(version) without one. // load_map checks it is a known preset that allows the map's version. std::string preset_name; + bool preset_named = false; // the map has the field "preset" (else the name came from the version, or the caller) std::vector sources; // in file order std::vector arrays; // what tensors index int key_source = -1; @@ -275,6 +276,11 @@ struct MapError { // Parses and fully validates a map, including every index range (source lengths are part of the map). bool load_map(const std::string& file_bytes, Map& out, MapError& err); +// The same, for a caller that knows which preset it loads the map for (`expected_preset`, e.g. "L"; "" : as above). A map +// without the field "preset" then gets that preset, when it allows the map's version; a map with the field must name +// the same preset. Anything else (an unknown name, a version the preset does not use, another name): damaged. This is +// how a map written before maps named their preset (the delivered preset-L map has no field) is read as its preset. +bool load_map(const std::string& file_bytes, Map& out, MapError& err, const std::string& expected_preset); // Hex helpers shared with the tests: optional 0x prefix, then 1..max_digits hex digits. bool parse_hex_u64(const std::string& s, int max_digits, std::uint64_t& out); diff --git a/clean/converter/tests/run_tests.py b/clean/converter/tests/run_tests.py index c0279d21..901d7dcc 100644 --- a/clean/converter/tests/run_tests.py +++ b/clean/converter/tests/run_tests.py @@ -29,6 +29,8 @@ DEFAULT_MAP = os.path.normpath(os.path.join(HERE, "..", "..", "..", "data", "preset-M.v1.map.json")) DEFAULT_KMAP = os.path.normpath(os.path.join(HERE, "..", "..", "..", "data", "preset-K.v1.map.json")) +DEFAULT_LMAP = os.path.normpath(os.path.join(HERE, "..", "..", "..", "data", "preset-L.v1.map.json")) +MSG_NO_PRESET_L = "This DLSS file has no preset-L model." # the message's start (its minimum version: api.cpp) DEFAULT_T5 = os.path.normpath(os.path.join(HERE, "..", "..", "..", "data", "k48-capped-softmax-test.json")) DEFAULT_T7 = os.path.normpath(os.path.join(HERE, "..", "..", "..", "data", "lz4-block-test.json")) DTYPE_CODE = {"float32": 0, "uint8": 1, "int32": 2} @@ -267,6 +269,47 @@ def test_shipped_map_validates(r, shipped_map): r.check("real map: nothing written", not os.path.exists(os.path.join(out, "model.wgcm"))) +def test_l_real_map(r, lmap): + """Model L (#89): the delivered preset-L map (data/preset-L.v1.map.json; map version 1, W, D, K; no "preset" field, + so it is loaded with --preset L). It validates; our own random file gives preset L's message (and, without + --preset, preset M's, as for any version-1 map); a mismatching --preset is refused; and its exact layout converts + our own random data at two placements, every tensor of every stage checked against the reference.""" + import random + with open(lmap, "rb") as f: + m = json.load(f) + r.check("preset-L map: version 1, sources W, D and K, no \"preset\" field", + m["version"] == 1 and sorted(m["sources"]) == ["D", "K", "W"] and "preset" not in m, (m["version"], sorted(m["sources"]))) + rng = random.Random(29) + lw = m["sources"]["W"]["length"] + out = r.path("l-real/out", "x")[:-2] + big = r.write("l-real/nomodel.dll", rng.randbytes(lw + 100_000)) + code, so, se = r.run(lmap, [big], out, extra=("--preset", "L")) + r.check("preset-L map --preset L: valid, W absent -> exit 12, preset L's message", code == EXIT["no_preset_m"] and MSG_NO_PRESET_L in so, so + se[-400:]) + r.check("...the log names the preset", "preset L" in se, se[-400:]) + code, so, se = r.run(lmap, [big], out) + r.check("preset-L map without --preset: read as version 1 (preset M's message)", code == EXIT["no_preset_m"] and MSG["no_preset_m"] in so, so) + for asked in ("K", "F"): + code, so, se = r.run(lmap, [big], out, extra=("--preset", asked)) + r.check("preset-L map --preset %s: converter data damaged" % asked, code == EXIT["map_damaged"] and MSG["map_damaged"] in so, so) + code, so, se = r.run(lmap, [big], out, extra=("--preset", "Q")) + r.check("--preset Q (unknown): usage error", code == EXIT["usage"] and "unknown preset" in so, so) + r.check("preset-L map: nothing written", not os.path.exists(os.path.join(out, "model.wgcm"))) + for seed, w_off in ((21, 4096), (22, 4096 + 6)): + t0 = time.time() + case = shipped_like_case(lmap, seed=seed, w_offset=w_off) + label = "preset-L layout(seed %d, W at %d)" % (seed, w_off) + dll = r.write("l-real/%d/fake.dll" % seed, case.file) + mp = r.write("l-real/%d/map.json" % seed, case.map) + o = r.path("l-real/%d/out" % seed, "x")[:-2] + code, so, se = r.run(mp, [dll], o, extra=("--preset", "L")) + r.check(label + ": exit 0", code == 0 and SUCCESS in so, so + se[-600:]) + with open(mp, "rb") as f: + check_output(r, label, case, o, f.read()) + r.check(label + ": offsets", logged_offsets(se) == case.placements, "%s vs %s" % (logged_offsets(se), case.placements)) + r.check(label + ": every stage digest matches", ("all %d stage digests match" % len(case.map["stages"])) in se, se[-400:]) + print("%s: %.1f s" % (label, time.time() - t0)) + + def test_preset_l(r): """Model L (#89): a map that names preset L ("preset": "L", map version 1) next to a preset-M map, both reading one synthetic library file in which L's parameter block lies directly before M's. Each map converts its own block, and @@ -1087,6 +1130,7 @@ def main(): ap.add_argument("--work", default=os.path.join(HERE, "..", "build", "test-work")) ap.add_argument("--map", default=DEFAULT_MAP, help="the shipped map (only its layout is used)") ap.add_argument("--kmap", default=DEFAULT_KMAP, help="the shipped preset-K map (only its layout is used)") + ap.add_argument("--lmap", default=DEFAULT_LMAP, help="the shipped preset-L map (only its layout is used)") ap.add_argument("--t5", default=DEFAULT_T5, help="spec 48-T5 capped_softmax vectors") ap.add_argument("--t7", default=DEFAULT_T7, help="spec 08-T7 block decompression vectors") ap.add_argument("--quick", action="store_true", help="skip the large cases") @@ -1113,6 +1157,10 @@ def main(): test_k_shipped_like(r, args.kmap) else: print("note: preset-K map not found at %s; skipping its layout tests" % args.kmap) + if os.path.exists(args.lmap): + test_l_real_map(r, args.lmap) + else: + print("note: preset-L map not found at %s; skipping its layout tests" % args.lmap) if os.path.exists(args.t5): test_k_t5(r, args.t5) if not args.quick: diff --git a/clean/converter/tests/unit_tests.cpp b/clean/converter/tests/unit_tests.cpp index 658e7be0..4c89b3c1 100644 --- a/clean/converter/tests/unit_tests.cpp +++ b/clean/converter/tests/unit_tests.cpp @@ -626,6 +626,23 @@ static void test_api_files(const fs::path& work) { lm1.map->preset() == 'L' && lm1.map->preset_info() == find_preset("L")); CHECK(load_map_bytes(with_preset(u.map_v4, "4", "\"L\""), lm4, sink).code == kOk && lm4.map && lm4.map->preset_name == "L" && lm4.map->stages.size() == m4.map->stages.size()); + // the caller's preset (load_map_bytes expected_preset; wronggpu-convert --preset): a map without the field is read + // as that preset when it allows the version; a map with the field must agree + { + LoadedMap h1, h2, h3, h4; + CHECK(load_map_bytes(u.map_v1, h1, sink, "L").code == kOk && h1.map && h1.map->preset_name == "L" && !h1.map->preset_named && + h1.map->preset_info() == find_preset("L")); + CHECK(load_map_bytes(u.map_v4, h2, sink, "M").code == kOk && h2.map && h2.map->preset_name == "M"); + CHECK(load_map_bytes(with_preset(u.map_v1, "1", "\"L\""), h3, sink, "L").code == kOk && h3.map && h3.map->preset_named); + CHECK(load_map_bytes(u.map_v1, h4, sink, "").code == kOk && h4.map && h4.map->preset_name == "M"); + for (const char* asked : {"K", "F", "X", "l"}) { + LoadedMap hb; + CHECK(load_map_bytes(u.map_v1, hb, sink, asked).code == kMapDamaged && !hb.map); + } + LoadedMap hm; + CHECK(load_map_bytes(with_preset(u.map_v1, "1", "\"M\""), hm, sink, "L").code == kMapDamaged && !hm.map); + CHECK(logged("the map names preset M, preset L was asked for") && logged("preset \"X\" asked for is not known")); + } for (const char* bad : {"\"K\"", "\"F\"", "\"X\"", "\"m\"", "\"l\"", "\"\"", "7", "null"}) { LoadedMap bm; const Result r = load_map_bytes(with_preset(u.map_v1, "1", bad), bm, sink); diff --git a/data/README.md b/data/README.md index 07d960ef..fec26cd6 100644 --- a/data/README.md +++ b/data/README.md @@ -6,8 +6,9 @@ only layout information and the digests the converter uses to verify the player' ## Converter maps -`preset-M.v1.map.json` (Model M, map version 4), `preset-F.v1.map.json` (Ray Reconstruction, version 5) and -`preset-K.v1.map.json` (Model K, version 3) tell the converter (`clean/converter`) how to read the network's parameters +`preset-M.v1.map.json` (Model M, map version 4), `preset-F.v1.map.json` (Ray Reconstruction, version 5), +`preset-K.v1.map.json` (Model K, version 3) and `preset-L.v1.map.json` (Model L, version 1; read with the converter's +`--preset L`, since it has no `preset` field) tell the converter (`clean/converter`) how to read the network's parameters from the player's own DLSS file. Each map holds: - `format`, `version`, `channel_order`, and a `model` line naming the DLSS product and the first DLSS version the map diff --git a/data/preset-L.v1.map.json b/data/preset-L.v1.map.json new file mode 100644 index 00000000..42a15906 --- /dev/null +++ b/data/preset-L.v1.map.json @@ -0,0 +1,3362 @@ +{ + "format": "wronggpu-converter-map", + "version": 1, + "model": "super-resolution preset L (same model family as preset M)", + "channel_order": "natural", + "sources": { + "W": { + "what": "preset-L parameter block", + "element": "f16le", + "length": 3214796, + "locate": "block", + "fnv1a64": "0x3472db02b349424f", + "sha256": "2cf66f95aab29303a614358a2b665e7cff131a7cc8b1d9fb0f45485485ea6d39" + }, + "D": { + "what": "input-encoder dither table", + "element": "u16le", + "length": 4096, + "locate": "block", + "fnv1a64": "0x5ce0e80308d2a34b", + "sha256": "4707682a85d793cafcfe746e70d181190ba59bd989b88e27dee9edf1f20305b8" + }, + "K": { + "what": "two 32-bit input-encoder constants of preset L (immediate operands in the DLL code)", + "element": "u32le", + "length": 8, + "locate": "pair", + "gaps": [ + 10 + ], + "keyed": true, + "fnv1a64": "0x5d90fa7ae4646e91", + "sha256": "0aba3cfc3b879f9ffee70f5c54219d60b86c934a255a50964e9daa6d2c6eac90" + } + }, + "key": { + "label": "WrongGPU converter key v1", + "from": "W" + }, + "perms": { + "dec0_values": [ + 0, + 1, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ] + }, + "stages": [ + { + "stage": "enc0", + "digest": "8b50ffe2aa88e92001487af1a22d00d6a5345ad7d41812b86d5397779ebe6c3d", + "tensors": [ + { + "name": "W", + "shape": [ + 64, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 16832, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b", + "shape": [ + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 25024, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "T", + "shape": [ + 8, + 16, + 16 + ], + "dtype": "uint8", + "src": "D", + "op": { + "name": "u16_shr", + "shift": 9 + }, + "base": 0, + "axes": [ + { + "stride": 256 + }, + { + "stride": 16 + }, + { + "stride": 1 + } + ] + }, + { + "name": "sigma1", + "shape": [ + 1 + ], + "dtype": "float32", + "src": "K", + "op": { + "name": "u32_as_f32" + }, + "base": 0, + "axes": [ + { + "stride": 0 + } + ] + }, + { + "name": "sigma2", + "shape": [ + 1 + ], + "dtype": "float32", + "src": "K", + "op": { + "name": "u32_as_f32" + }, + "base": 1, + "axes": [ + { + "stride": 0 + } + ] + }, + { + "name": "Win1", + "shape": [ + 32, + 20 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 0, + "axes": [ + { + "stride": 20 + }, + { + "stride": 1 + } + ] + }, + { + "name": "bin1", + "shape": [ + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 640, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "Win2", + "shape": [ + 32, + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 672, + "axes": [ + { + "stride": 32 + }, + { + "stride": 1 + } + ] + }, + { + "name": "bin2", + "shape": [ + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1696, + "axes": [ + { + "stride": 1 + } + ] + } + ] + }, + { + "stage": "enc0_block", + "digest": "da18533f11417681b9ad89e00083220828bf903b5640c7a2bab851110e5c77a9", + "tensors": [ + { + "name": "gamma1", + "shape": [ + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x40b504f3", + "div": "0x40b504f3", + "note": "mul = div = sqrt(32)" + }, + "base": 1728, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "gamma2", + "shape": [ + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x40b504f3", + "div": "0x40b504f3", + "note": "mul = div = sqrt(32)" + }, + "base": 8448, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "Wqk", + "shape": [ + 2, + 32, + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1760, + "axes": [ + { + "stride": 1024 + }, + { + "stride": 32 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wv", + "shape": [ + 2, + 32, + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 3808, + "axes": [ + { + "stride": 1024 + }, + { + "stride": 32 + }, + { + "stride": 1 + } + ] + }, + { + "name": "B", + "shape": [ + 2, + 16, + 16 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x403504f3", + "div": "0x3f800000", + "note": "mul = sqrt(8)" + }, + "base": 7936, + "axes": [ + { + "stride": 256 + }, + { + "stride": 16 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wp", + "shape": [ + 32, + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 5856, + "axes": [ + { + "stride": 64 + }, + { + "stride": 1 + } + ] + }, + { + "name": "bp", + "shape": [ + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 7904, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W1", + "shape": [ + 128, + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 8480, + "axes": [ + { + "stride": 32 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b1", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 12576, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W2", + "shape": [ + 32, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 12704, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b2", + "shape": [ + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 16800, + "axes": [ + { + "stride": 1 + } + ] + } + ] + }, + { + "stage": "enc1", + "digest": "89b8d6712d79cc1a023182998636b3918d51e4123c08b116136bed8184201dcb", + "tensors": [ + { + "name": "gamma1", + "shape": [ + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x41000000", + "div": "0x41000000", + "note": "mul = div = sqrt(64)" + }, + "base": 25088, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "gamma2", + "shape": [ + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x41000000", + "div": "0x41000000", + "note": "mul = div = sqrt(64)" + }, + "base": 38016, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "Wqk", + "shape": [ + 2, + 32, + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 25152, + "axes": [ + { + "stride": 2048 + }, + { + "stride": 64 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wv", + "shape": [ + 2, + 32, + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 29248, + "axes": [ + { + "stride": 2048 + }, + { + "stride": 64 + }, + { + "stride": 1 + } + ] + }, + { + "name": "B", + "shape": [ + 2, + 16, + 16 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x403504f3", + "div": "0x3f800000", + "note": "mul = sqrt(8)" + }, + "base": 37504, + "axes": [ + { + "stride": 256 + }, + { + "stride": 16 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wp", + "shape": [ + 64, + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 33344, + "axes": [ + { + "stride": 64 + }, + { + "stride": 1 + } + ] + }, + { + "name": "bp", + "shape": [ + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 37440, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W1", + "shape": [ + 256, + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 38080, + "axes": [ + { + "stride": 64 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b1", + "shape": [ + 256 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 54464, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W2", + "shape": [ + 64, + 256 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 54720, + "axes": [ + { + "stride": 256 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b2", + "shape": [ + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 71104, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "Wm", + "shape": [ + 96, + 256 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 71168, + "axes": [ + { + "stride": 256 + }, + { + "stride": 1 + } + ] + }, + { + "name": "bm", + "shape": [ + 96 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 95744, + "axes": [ + { + "stride": 1 + } + ] + } + ] + }, + { + "stage": "enc2", + "digest": "730e6bb74ab33976caf77c73a47046cd401d49c95ed80ab2565a99d8e6f50c62", + "tensors": [ + { + "name": "gamma1", + "shape": [ + 96 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x411cc471", + "div": "0x411cc471", + "note": "mul = div = sqrt(96)" + }, + "base": 95840, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "gamma2", + "shape": [ + 96 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x411cc471", + "div": "0x411cc471", + "note": "mul = div = sqrt(96)" + }, + "base": 133920, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "Wqk", + "shape": [ + 4, + 32, + 96 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 95936, + "axes": [ + { + "stride": 3072 + }, + { + "stride": 96 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wv", + "shape": [ + 4, + 32, + 96 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 108224, + "axes": [ + { + "stride": 3072 + }, + { + "stride": 96 + }, + { + "stride": 1 + } + ] + }, + { + "name": "B", + "shape": [ + 4, + 16, + 16 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x403504f3", + "div": "0x3f800000", + "note": "mul = sqrt(8)" + }, + "base": 132896, + "axes": [ + { + "stride": 256 + }, + { + "stride": 16 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wp", + "shape": [ + 96, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 120512, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "bp", + "shape": [ + 96 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 132800, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W1", + "shape": [ + 384, + 96 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 134016, + "axes": [ + { + "stride": 96 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b1", + "shape": [ + 384 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 170880, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W2", + "shape": [ + 96, + 384 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 171264, + "axes": [ + { + "stride": 384 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b2", + "shape": [ + 96 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 208128, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "Wm", + "shape": [ + 128, + 384 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 208224, + "axes": [ + { + "stride": 384 + }, + { + "stride": 1 + } + ] + }, + { + "name": "bm", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 257376, + "axes": [ + { + "stride": 1 + } + ] + } + ] + }, + { + "stage": "b0", + "digest": "d3aa55699e1f3364dacf0d6479d7fb0d202c09b17bfe6198eb01f7f6554557c8", + "tensors": [ + { + "name": "gamma1", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x413504f3", + "div": "0x413504f3", + "note": "mul = div = sqrt(128)" + }, + "base": 257504, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "gamma2", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x413504f3", + "div": "0x413504f3", + "note": "mul = div = sqrt(128)" + }, + "base": 307936, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "Wqk", + "shape": [ + 4, + 32, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 257632, + "axes": [ + { + "stride": 4096 + }, + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wv", + "shape": [ + 4, + 32, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 274016, + "axes": [ + { + "stride": 4096 + }, + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "B", + "shape": [ + 4, + 16, + 16 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x403504f3", + "div": "0x3f800000", + "note": "mul = sqrt(8)" + }, + "base": 306912, + "axes": [ + { + "stride": 256 + }, + { + "stride": 16 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wp", + "shape": [ + 128, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 290400, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "bp", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 306784, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W1", + "shape": [ + 512, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 308064, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b1", + "shape": [ + 512 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 373600, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W2", + "shape": [ + 128, + 512 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 374112, + "axes": [ + { + "stride": 512 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b2", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 439648, + "axes": [ + { + "stride": 1 + } + ] + } + ] + }, + { + "stage": "b1", + "digest": "7170c03d22b78f8a594c3fc9da3148d5db46f7290f6e04eb9e41a04208d97d56", + "tensors": [ + { + "name": "gamma1", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x413504f3", + "div": "0x413504f3", + "note": "mul = div = sqrt(128)" + }, + "base": 439776, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "gamma2", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x413504f3", + "div": "0x413504f3", + "note": "mul = div = sqrt(128)" + }, + "base": 490208, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "Wqk", + "shape": [ + 4, + 32, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 439904, + "axes": [ + { + "stride": 4096 + }, + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wv", + "shape": [ + 4, + 32, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 456288, + "axes": [ + { + "stride": 4096 + }, + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "B", + "shape": [ + 4, + 16, + 16 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x403504f3", + "div": "0x3f800000", + "note": "mul = sqrt(8)" + }, + "base": 489184, + "axes": [ + { + "stride": 256 + }, + { + "stride": 16 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wp", + "shape": [ + 128, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 472672, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "bp", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 489056, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W1", + "shape": [ + 512, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 490336, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b1", + "shape": [ + 512 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 555872, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W2", + "shape": [ + 128, + 512 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 556384, + "axes": [ + { + "stride": 512 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b2", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 621920, + "axes": [ + { + "stride": 1 + } + ] + } + ] + }, + { + "stage": "b2", + "digest": "5172f7f0216d82684638da75f04cde85f240c51558b428333021f5aae2d548ef", + "tensors": [ + { + "name": "gamma1", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x413504f3", + "div": "0x413504f3", + "note": "mul = div = sqrt(128)" + }, + "base": 622048, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "gamma2", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x413504f3", + "div": "0x413504f3", + "note": "mul = div = sqrt(128)" + }, + "base": 672480, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "Wqk", + "shape": [ + 4, + 32, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 622176, + "axes": [ + { + "stride": 4096 + }, + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wv", + "shape": [ + 4, + 32, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 638560, + "axes": [ + { + "stride": 4096 + }, + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "B", + "shape": [ + 4, + 16, + 16 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x403504f3", + "div": "0x3f800000", + "note": "mul = sqrt(8)" + }, + "base": 671456, + "axes": [ + { + "stride": 256 + }, + { + "stride": 16 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wp", + "shape": [ + 128, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 654944, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "bp", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 671328, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W1", + "shape": [ + 512, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 672608, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b1", + "shape": [ + 512 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 738144, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W2", + "shape": [ + 128, + 512 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 738656, + "axes": [ + { + "stride": 512 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b2", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 804192, + "axes": [ + { + "stride": 1 + } + ] + } + ] + }, + { + "stage": "b3", + "digest": "6938ba5f59843c8ad669cef988f84aee45920fce92cf3ee46abc8f0a41a34b16", + "tensors": [ + { + "name": "gamma1", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x413504f3", + "div": "0x413504f3", + "note": "mul = div = sqrt(128)" + }, + "base": 804320, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "gamma2", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x413504f3", + "div": "0x413504f3", + "note": "mul = div = sqrt(128)" + }, + "base": 854752, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "Wqk", + "shape": [ + 4, + 32, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 804448, + "axes": [ + { + "stride": 4096 + }, + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wv", + "shape": [ + 4, + 32, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 820832, + "axes": [ + { + "stride": 4096 + }, + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "B", + "shape": [ + 4, + 16, + 16 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x403504f3", + "div": "0x3f800000", + "note": "mul = sqrt(8)" + }, + "base": 853728, + "axes": [ + { + "stride": 256 + }, + { + "stride": 16 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wp", + "shape": [ + 128, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 837216, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "bp", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 853600, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W1", + "shape": [ + 512, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 854880, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b1", + "shape": [ + 512 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 920416, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W2", + "shape": [ + 128, + 512 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 920928, + "axes": [ + { + "stride": 512 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b2", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 986464, + "axes": [ + { + "stride": 1 + } + ] + } + ] + }, + { + "stage": "b4", + "digest": "12a044e5898d41932d70897d0640dbf698dfdfd8bc52d37e975955611d5a4a74", + "tensors": [ + { + "name": "gamma1", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x413504f3", + "div": "0x413504f3", + "note": "mul = div = sqrt(128)" + }, + "base": 986592, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "gamma2", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x413504f3", + "div": "0x413504f3", + "note": "mul = div = sqrt(128)" + }, + "base": 1037024, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "Wqk", + "shape": [ + 4, + 32, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 986720, + "axes": [ + { + "stride": 4096 + }, + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wv", + "shape": [ + 4, + 32, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1003104, + "axes": [ + { + "stride": 4096 + }, + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "B", + "shape": [ + 4, + 16, + 16 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x403504f3", + "div": "0x3f800000", + "note": "mul = sqrt(8)" + }, + "base": 1036000, + "axes": [ + { + "stride": 256 + }, + { + "stride": 16 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wp", + "shape": [ + 128, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1019488, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "bp", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1035872, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W1", + "shape": [ + 512, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1037152, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b1", + "shape": [ + 512 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1102688, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W2", + "shape": [ + 128, + 512 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1103200, + "axes": [ + { + "stride": 512 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b2", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1168736, + "axes": [ + { + "stride": 1 + } + ] + } + ] + }, + { + "stage": "b5", + "digest": "9a08165d4ef7b1eb01e1b8f0b8c55d45cc2601b0e793b937ecb5a6cf86a6f039", + "tensors": [ + { + "name": "gamma1", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x413504f3", + "div": "0x413504f3", + "note": "mul = div = sqrt(128)" + }, + "base": 1168864, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "gamma2", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x413504f3", + "div": "0x413504f3", + "note": "mul = div = sqrt(128)" + }, + "base": 1219296, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "Wqk", + "shape": [ + 4, + 32, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1168992, + "axes": [ + { + "stride": 4096 + }, + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wv", + "shape": [ + 4, + 32, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1185376, + "axes": [ + { + "stride": 4096 + }, + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "B", + "shape": [ + 4, + 16, + 16 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x403504f3", + "div": "0x3f800000", + "note": "mul = sqrt(8)" + }, + "base": 1218272, + "axes": [ + { + "stride": 256 + }, + { + "stride": 16 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wp", + "shape": [ + 128, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1201760, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "bp", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1218144, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W1", + "shape": [ + 512, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1219424, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b1", + "shape": [ + 512 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1284960, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W2", + "shape": [ + 128, + 512 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1285472, + "axes": [ + { + "stride": 512 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b2", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1351008, + "axes": [ + { + "stride": 1 + } + ] + } + ] + }, + { + "stage": "dec2", + "digest": "10656686faed40210bc62586695184f6b98f311eec0f1393b8a274f51b44cafc", + "tensors": [ + { + "name": "gamma1", + "shape": [ + 96 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x411cc471", + "div": "0x411cc471", + "note": "mul = div = sqrt(96)" + }, + "base": 1351136, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "gamma2", + "shape": [ + 96 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x411cc471", + "div": "0x411cc471", + "note": "mul = div = sqrt(96)" + }, + "base": 1389216, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "Wqk", + "shape": [ + 4, + 32, + 96 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1351232, + "axes": [ + { + "stride": 3072 + }, + { + "stride": 96 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wv", + "shape": [ + 4, + 32, + 96 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1363520, + "axes": [ + { + "stride": 3072 + }, + { + "stride": 96 + }, + { + "stride": 1 + } + ] + }, + { + "name": "B", + "shape": [ + 4, + 16, + 16 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x403504f3", + "div": "0x3f800000", + "note": "mul = sqrt(8)" + }, + "base": 1388192, + "axes": [ + { + "stride": 256 + }, + { + "stride": 16 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wp", + "shape": [ + 96, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1375808, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "bp", + "shape": [ + 96 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1388096, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W1", + "shape": [ + 384, + 96 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1389312, + "axes": [ + { + "stride": 96 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b1", + "shape": [ + 384 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1426176, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W2", + "shape": [ + 96, + 384 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1426560, + "axes": [ + { + "stride": 384 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b2", + "shape": [ + 96 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1463424, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "We", + "shape": [ + 384, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1463520, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "be", + "shape": [ + 384 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1512672, + "axes": [ + { + "stride": 1 + } + ] + } + ] + }, + { + "stage": "dec1", + "digest": "fb91beea86a6bb6a6508704767176486eba0871208cf7b196b74d7dfcd9e666f", + "tensors": [ + { + "name": "gamma1", + "shape": [ + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x41000000", + "div": "0x41000000", + "note": "mul = div = sqrt(64)" + }, + "base": 1513056, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "gamma2", + "shape": [ + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x41000000", + "div": "0x41000000", + "note": "mul = div = sqrt(64)" + }, + "base": 1525984, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "Wqk", + "shape": [ + 2, + 32, + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1513120, + "axes": [ + { + "stride": 2048 + }, + { + "stride": 64 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wv", + "shape": [ + 2, + 32, + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1517216, + "axes": [ + { + "stride": 2048 + }, + { + "stride": 64 + }, + { + "stride": 1 + } + ] + }, + { + "name": "B", + "shape": [ + 2, + 16, + 16 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x403504f3", + "div": "0x3f800000", + "note": "mul = sqrt(8)" + }, + "base": 1525472, + "axes": [ + { + "stride": 256 + }, + { + "stride": 16 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wp", + "shape": [ + 64, + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1521312, + "axes": [ + { + "stride": 64 + }, + { + "stride": 1 + } + ] + }, + { + "name": "bp", + "shape": [ + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1525408, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W1", + "shape": [ + 256, + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1526048, + "axes": [ + { + "stride": 64 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b1", + "shape": [ + 256 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1542432, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W2", + "shape": [ + 64, + 256 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1542688, + "axes": [ + { + "stride": 256 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b2", + "shape": [ + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1559072, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "We", + "shape": [ + 256, + 96 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1559136, + "axes": [ + { + "stride": 96 + }, + { + "stride": 1 + } + ] + }, + { + "name": "be", + "shape": [ + 256 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1583712, + "axes": [ + { + "stride": 1 + } + ] + } + ] + }, + { + "stage": "dec0_block", + "digest": "6f43633eb6f9989912ba64e342fbbe4d846ea40208df8f04a07e425c882b1d29", + "tensors": [ + { + "name": "gamma1", + "shape": [ + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x40b504f3", + "div": "0x40b504f3", + "note": "mul = div = sqrt(32)" + }, + "base": 1583968, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "gamma2", + "shape": [ + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x40b504f3", + "div": "0x40b504f3", + "note": "mul = div = sqrt(32)" + }, + "base": 1590688, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "Wqk", + "shape": [ + 2, + 32, + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1584000, + "axes": [ + { + "stride": 1024 + }, + { + "stride": 32 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wv", + "shape": [ + 2, + 32, + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1586048, + "axes": [ + { + "stride": 1024 + }, + { + "stride": 32 + }, + { + "stride": 1 + } + ] + }, + { + "name": "B", + "shape": [ + 2, + 16, + 16 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16_scaled", + "mul": "0x403504f3", + "div": "0x3f800000", + "note": "mul = sqrt(8)" + }, + "base": 1590176, + "axes": [ + { + "stride": 256 + }, + { + "stride": 16 + }, + { + "stride": 1 + } + ] + }, + { + "name": "Wp", + "shape": [ + 32, + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1588096, + "axes": [ + { + "stride": 64 + }, + { + "stride": 1 + } + ] + }, + { + "name": "bp", + "shape": [ + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1590144, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W1", + "shape": [ + 128, + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1590720, + "axes": [ + { + "stride": 32 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b1", + "shape": [ + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1594816, + "axes": [ + { + "stride": 1 + } + ] + }, + { + "name": "W2", + "shape": [ + 32, + 128 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1594944, + "axes": [ + { + "stride": 128 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b2", + "shape": [ + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1599040, + "axes": [ + { + "stride": 1 + } + ] + } + ] + }, + { + "stage": "dec0", + "digest": "6535d493fa7a9e665276b1dd4e34e60d94afb2a47d080203d542bc0145da7075", + "tensors": [ + { + "name": "W", + "shape": [ + 4, + 32, + 64 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "fp8" + }, + "base": 1599072, + "axes": [ + { + "stride": 2048 + }, + { + "stride": 64 + }, + { + "stride": 1 + } + ] + }, + { + "name": "b", + "shape": [ + 4, + 32 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "f16" + }, + "base": 1607264, + "axes": [ + { + "stride": 32 + }, + { + "stride": 1 + } + ] + }, + { + "name": "S", + "shape": [ + 1 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "exp", + "max": "0x41000000" + }, + "base": 1607392, + "axes": [ + { + "stride": 0 + } + ] + }, + { + "name": "T", + "shape": [ + 1 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "exp" + }, + "base": 1607394, + "axes": [ + { + "stride": 0 + } + ] + } + ], + "note": "L uses all 32 projection outputs per sub-pixel (M: 17); the width-32 block (stage dec0_block) runs on them; 17 of the block outputs feed the spec-05 coefficient functions, expected at the positions perm dec0_values gives (to be confirmed by the reference test)." + }, + { + "stage": "post", + "digest": "a04525fadded1470e5a53f72f1c47ee7322f3f656731961be515ec2f366d83ad", + "tensors": [ + { + "name": "s", + "shape": [ + 1 + ], + "dtype": "float32", + "src": "W", + "op": { + "name": "exp" + }, + "base": 1607396, + "axes": [ + { + "stride": 0 + } + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/tools/ci/check_line_endings.py b/tools/ci/check_line_endings.py index 98b53439..e4f9117f 100644 --- a/tools/ci/check_line_endings.py +++ b/tools/ci/check_line_endings.py @@ -12,7 +12,9 @@ import sys from pathlib import Path -CRLF_ALLOWED = set() # repository-relative paths of files that are meant to hold CR LF (none today) +# repository-relative paths of files that are meant to hold CR LF. The preset-L converter map is kept byte for byte as +# the spec side delivered it (CR LF; data/ is spec-side output, never edited by the clean team; .gitattributes: -text). +CRLF_ALLOWED = {"data/preset-L.v1.map.json"} def main():