Skip to content

Run frontier MoE models on hardware you already own — pure C, zero deps, experts streamed from disk. Tiny engine, immense model. 🐦

C

feat(glm53): stream the routed experts from disk

JustVugg21bcf68df884
diff --git a/c/glm53.c b/c/glm53.c
index bf9d4be4..a09eca36 100644
--- a/c/glm53.c
+++ b/c/glm53.c
@@ -619,6 +619,13 @@ typedef struct {
Mat head;
GLayer *layer;
char prefix[64];
+ /* esperti: o residenti (checkpoint f32) o in streaming (container int4) */
+ int streaming;
+ struct ERef *eref;
+ struct LCache *ecache;
+ int64_t e_len[6], e_at[6], e_slot;
+ uint64_t clock, ebytes;
+ long hits, miss;
/* torre vision: presente solo se il checkpoint la porta */
int has_vision;
ColiVisionTower vision;
@@ -927,8 +934,176 @@ static void mla_layer(const Cfg *c, const GLayer *l, const float *x, int tokens,
}
/* ---------- FFN: denso oppure MoE ---------- */
-static void ffn_layer(const Cfg *c, const GLayer *l, int index, const float *x,
+/* ================= streaming degli esperti =================
+ *
+ * 288 esperti per 42 layer sparsi, 14,2 MB l'uno in int4 gs64: 171 GB, che
+ * stanno su disco e non in RAM. Per ogni token se ne toccano 8 per layer, e la
+ * stessa manciata torna spesso, quindi ogni layer tiene una cache LRU di slot
+ * e il resto arriva con una lettura quando serve.
+ *
+ * Uno slot e' un blocco unico che contiene i sei pezzi dell'esperto nell'ordine
+ * in cui li vuole il calcolo. Le Mat che ne escono puntano dentro allo slot,
+ * cosi' il codice del MoE non sa da dove arrivi il peso e resta quello di
+ * prima. */
+#define GLM53_EXPERT_PIECES 6
+
+typedef struct ERef {
+ int fd[GLM53_EXPERT_PIECES];
+ int64_t off[GLM53_EXPERT_PIECES];
+ int contig; /* i sei pezzi sono consecutivi in un file */
+} ERef;
+
+typedef struct { int eid; uint8_t *base; uint64_t used; } Slot;
+typedef struct LCache { Slot *s; int n, cap; } LCache;
+
+/* Lunghezze e posizioni dei sei pezzi dentro allo slot. Gate e up sono
+ * [moe_inter, hidden], down e' [hidden, moe_inter]: stessi byte, forme
+ * scambiate. */
+static void expert_geometry(GModel *m) {
+ const int64_t hidden = m->c.hidden, inter = m->c.moe_inter;
+ const int64_t packed = inter * hidden / 2;
+ const int64_t scales = inter * hidden / 64 * (int64_t)sizeof(float);
+ const int64_t length[GLM53_EXPERT_PIECES] = { packed, scales, packed, scales, packed, scales };
+ int64_t at = 0;
+ for (int p = 0; p < GLM53_EXPERT_PIECES; p++) {
+ m->e_len[p] = length[p];
+ m->e_at[p] = at;
+ at += length[p];
+ }
+ m->e_slot = at;
+}
+
+/* Indirizzi su disco di ogni esperto. Le lunghezze dichiarate dal file devono
+ * combaciare con la geometria: un checkpoint che dice altro non e' questo
+ * modello, e leggerlo lo stesso vorrebbe dire calcolare su byte a caso. */
+static void expert_table_init(GModel *m) {
+ const Cfg *c = &m->c;
+ static const char *piece[GLM53_EXPERT_PIECES] = {
+ "gate_proj.weight", "gate_proj.weight.qs",
+ "up_proj.weight", "up_proj.weight.qs",
+ "down_proj.weight", "down_proj.weight.qs",
+ };
+ m->eref = calloc((size_t)c->n_layers * c->n_experts, sizeof(*m->eref));
+ if (!m->eref) { fprintf(stderr, "OOM sulla tabella degli esperti\n"); exit(1); }
+
+ for (int i = c->first_dense; i < c->n_layers; i++) {
+ for (int e = 0; e < c->n_experts; e++) {
+ ERef *ref = &m->eref[(size_t)i * c->n_experts + e];
+ for (int p = 0; p < GLM53_EXPERT_PIECES; p++) {
+ char name[512];
+ snprintf(name, sizeof(name), "%slayers.%d.mlp.experts.%d.%s",
+ m->prefix, i, e, piece[p]);
+ st_tensor *t = st_find(&m->S, name);
+ if (!t) { fprintf(stderr, "manca %s\n", name); exit(1); }
+ if (t->nbytes != m->e_len[p]) {
+ fprintf(stderr, "%s: %lld byte, attesi %lld\n", name,
+ (long long)t->nbytes, (long long)m->e_len[p]);
+ exit(1);
+ }
+ ref->fd[p] = t->fd;
+ ref->off[p] = t->off;
+ }
+ /* Sei letture per esperto costano sei code invece di una. Vale la
+ * pena accorgersi quando il file le ha gia' messe in fila. */
+ ref->contig = 1;
+ for (int p = 1; p < GLM53_EXPERT_PIECES; p++)
+ if (ref->fd[p] != ref->fd[0] ||
+ ref->off[p] != ref->off[p - 1] + m->e_len[p - 1]) { ref->contig = 0; break; }
+ }
+ }
+}
+
+/* Quanti slot per layer: il budget diviso i layer sparsi. Il pavimento e' 1 e
+ * non topk, perche' un pavimento a topk impegnerebbe topk*layer slot comunque,
+ * cioe' molti GB, a dispetto del budget chiesto. */
+static void expert_cache_init(GModel *m) {
+ const Cfg *c = &m->c;
+ const char *setting = getenv("GLM53_EXPERT_GB");
+ double budget = setting ? atof(setting) : 8.0;
+ const int sparse = c->n_layers - c->first_dense;
+ int cap = (int)((budget * 1e9) / ((double)m->e_slot * (sparse > 0 ? sparse : 1)));
+ if (cap < 1) cap = 1;
+ if (cap > c->n_experts) cap = c->n_experts;
+
+ m->ecache = calloc((size_t)c->n_layers, sizeof(*m->ecache));
+ if (!m->ecache) { fprintf(stderr, "OOM sulla cache degli esperti\n"); exit(1); }
+ for (int i = c->first_dense; i < c->n_layers; i++) {
+ LCache *cache = &m->ecache[i];
+ cache->cap = cap;
+ cache->s = calloc((size_t)cap, sizeof(*cache->s));
+ if (!cache->s) { fprintf(stderr, "OOM sugli slot del layer %d\n", i); exit(1); }
+ for (int j = 0; j < cap; j++) cache->s[j].eid = -1;
+ }
+ if (getenv("GLM53_VERBOSE"))
+ fprintf(stderr, "esperti: slot da %.1f MB, %d per layer su %d layer sparsi "
+ "(%.1f GB residenti)\n",
+ m->e_slot / 1e6, cap, sparse, (double)cap * sparse * m->e_slot / 1e9);
+}
+
+static Slot *slot_find(GModel *m, int layer, int eid) {
+ LCache *cache = &m->ecache[layer];
+ for (int j = 0; j < cache->n; j++)
+ if (cache->s[j].eid == eid) {
+ cache->s[j].used = ++m->clock;
+ m->hits++;
+ return &cache->s[j];
+ }
+ return NULL;
+}
+
+static void expert_read(GModel *m, int layer, int eid, Slot *slot) {
+ const ERef *ref = &m->eref[(size_t)layer * m->c.n_experts + eid];
+ if (!slot->base) {
+ slot->base = malloc((size_t)m->e_slot);
+ if (!slot->base) { fprintf(stderr, "OOM su uno slot esperto\n"); exit(1); }
+ }
+ if (ref->contig) {
+ st_pread_full(ref->fd[0], slot->base, m->e_slot, ref->off[0], "expert");
+ } else {
+ for (int p = 0; p < GLM53_EXPERT_PIECES; p++)
+ st_pread_full(ref->fd[p], slot->base + m->e_at[p], m->e_len[p],
+ ref->off[p], "expert piece");
+ }
+ slot->eid = eid;
+ m->miss++;
+ m->ebytes += (uint64_t)m->e_slot;
+}
+
+/* Lo slot dell'esperto chiesto, letto se non c'e'. La vittima e' quella usata
+ * meno di recente. */
+static Slot *expert_slot(GModel *m, int layer, int eid) {
+ Slot *slot = slot_find(m, layer, eid);
+ if (slot) return slot;
+ LCache *cache = &m->ecache[layer];
+ if (cache->n < cache->cap) slot = &cache->s[cache->n++];
+ else {
+ int lru = 0;
+ for (int j = 1; j < cache->n; j++)
+ if (cache->s[j].used < cache->s[lru].used) lru = j;
+ slot = &cache->s[lru];
+ }
+ expert_read(m, layer, eid, slot);
+ slot->used = ++m->clock;
+ return slot;
+}
+
+/* Le tre matrici di un esperto, che puntano dentro al suo slot. */
+static void expert_mats(const GModel *m, const Slot *slot, Mat *gate, Mat *up, Mat *down) {
+ const int hidden = m->c.hidden, inter = m->c.moe_inter;
+ const Mat shape[3] = {
+ { 4, NULL, NULL, slot->base + m->e_at[0], (const float *)(slot->base + m->e_at[1]),
+ inter, hidden, 64 },
+ { 4, NULL, NULL, slot->base + m->e_at[2], (const float *)(slot->base + m->e_at[3]),
+ inter, hidden, 64 },
+ { 4, NULL, NULL, slot->base + m->e_at[4], (const float *)(slot->base + m->e_at[5]),
+ hidden, inter, 64 },
+ };
+ *gate = shape[0]; *up = shape[1]; *down = shape[2];
+}
+
+static void ffn_layer(GModel *m, const GLayer *l, int index, const float *x,
int tokens, float *out) {
+ const Cfg *c = &m->c;
const int inter = index < c->first_dense ? c->dense_inter : c->moe_inter;
float *sg = malloc((size_t)(c->dense_inter > c->moe_inter ? c->dense_inter : c->moe_inter)
* sizeof(float));
@@ -971,8 +1146,14 @@ static void ffn_layer(const Cfg *c, const GLayer *l, int index, const float *x,
}
for (int k = 0; k < c->topk; k++) {
float scale = weight[k] / (total + 1e-20f) * c->routed_scale;
- mlp3(tmp, row, &l->eg[chosen[k]], &l->eu[chosen[k]], &l->ed[chosen[k]],
- c->swiglu_limit, sg, su);
+ Mat gate, up, down;
+ if (m->streaming) {
+ Slot *slot = expert_slot(m, index, chosen[k]);
+ expert_mats(m, slot, &gate, &up, &down);
+ } else {
+ gate = l->eg[chosen[k]]; up = l->eu[chosen[k]]; down = l->ed[chosen[k]];
+ }
+ mlp3(tmp, row, &gate, &up, &down, c->swiglu_limit, sg, su);
for (int d = 0; d < c->hidden; d++) dst[d] += scale * tmp[d];
}
}
@@ -981,6 +1162,9 @@ static void ffn_layer(const Cfg *c, const GLayer *l, int index, const float *x,
/* ---------- caricamento ---------- */
static void vision_load(GModel *m);
+static void expert_geometry(GModel *m);
+static void expert_table_init(GModel *m);
+static void expert_cache_init(GModel *m);
static void model_load(GModel *m, const char *dir) {
load_cfg(&m->c, dir);
@@ -1010,6 +1194,22 @@ static void model_load(GModel *m, const char *dir) {
}
m->layer = calloc((size_t)m->c.n_layers, sizeof(*m->layer));
+ /* Streaming o residenti: lo decide il contenitore, non una variabile
+ * d'ambiente. Si guarda il primo esperto del primo layer sparso. */
+ if (m->c.first_dense < m->c.n_layers) {
+ char first[512];
+ snprintf(first, sizeof(first), "%slayers.%d.mlp.experts.0.gate_proj.weight",
+ P, m->c.first_dense);
+ st_tensor *probe_expert = st_find(&m->S, first);
+ if (!probe_expert) { fprintf(stderr, "manca %s\n", first); exit(1); }
+ m->streaming = probe_expert->dtype == 3;
+ }
+ if (m->streaming) {
+ expert_geometry(m);
+ expert_table_init(m);
+ expert_cache_init(m);
+ }
+
for (int i = 0; i < m->c.n_layers; i++) {
GLayer *l = &m->layer[i];
l->in_ln = load_f32(m, "%slayers.%d.input_layernorm.weight", P, i);
@@ -1077,13 +1277,18 @@ static void model_load(GModel *m, const char *dir) {
l->rg = load_mat(m, "%slayers.%d.mlp.shared_experts.gate_proj.weight", P, i);
l->ru = load_mat(m, "%slayers.%d.mlp.shared_experts.up_proj.weight", P, i);
l->rd = load_mat(m, "%slayers.%d.mlp.shared_experts.down_proj.weight", P, i);
- l->eg = malloc((size_t)m->c.n_experts * sizeof(Mat));
- l->eu = malloc((size_t)m->c.n_experts * sizeof(Mat));
- l->ed = malloc((size_t)m->c.n_experts * sizeof(Mat));
- for (int e = 0; e < m->c.n_experts; e++) {
- l->eg[e] = load_mat(m, "%slayers.%d.mlp.experts.%d.gate_proj.weight", P, i, e);
- l->eu[e] = load_mat(m, "%slayers.%d.mlp.experts.%d.up_proj.weight", P, i, e);
- l->ed[e] = load_mat(m, "%slayers.%d.mlp.experts.%d.down_proj.weight", P, i, e);
+ /* Gli esperti quantizzati restano su disco: sono il 97% dei byte
+ * e nessuna macchina li tiene in RAM. Un checkpoint f32, come le
+ * fixture degli oracoli, e' piccolo e si carica tutto. */
+ if (!m->streaming) {
+ l->eg = malloc((size_t)m->c.n_experts * sizeof(Mat));
+ l->eu = malloc((size_t)m->c.n_experts * sizeof(Mat));
+ l->ed = malloc((size_t)m->c.n_experts * sizeof(Mat));
+ for (int e = 0; e < m->c.n_experts; e++) {
+ l->eg[e] = load_mat(m, "%slayers.%d.mlp.experts.%d.gate_proj.weight", P, i, e);
+ l->eu[e] = load_mat(m, "%slayers.%d.mlp.experts.%d.up_proj.weight", P, i, e);
+ l->ed[e] = load_mat(m, "%slayers.%d.mlp.experts.%d.down_proj.weight", P, i, e);
+ }
}
}
}
@@ -1257,7 +1462,7 @@ static float *forward(GModel *m, const int *tokens, int n,
kda_layer(c, l, normed, n, branch, state, window, scratch);
}
} else {
- ffn_layer(c, l, i, normed, n, branch);
+ ffn_layer(m, l, i, normed, n, branch);
}
for (int t = 0; t < n; t++)
coli_hc_post(next + (size_t)t * H * D, branch + (size_t)t * D,
@@ -1332,6 +1537,7 @@ int main(int argc, char **argv) {
if (!count) { fprintf(stderr, "nessun id nel prompt\n"); return 2; }
GModel model;
+ memset(&model, 0, sizeof(model)); /* contatori e puntatori opzionali */
model_load(&model, dir);
if (getenv("GLM53_VERBOSE")) cfg_report(&model.c);
@@ -1391,6 +1597,11 @@ int main(int argc, char **argv) {
printf("\n");
free(sequence);
}
+ /* Contatori della cache esperti: servono a un test per accorgersi se lo
+ * streaming e' stato aggirato invece che esercitato. */
+ if (model.streaming)
+ printf("experts hits %ld miss %ld bytes %llu\n",
+ model.hits, model.miss, (unsigned long long)model.ebytes);
free(logits);
free(vision);
free(tokens);
diff --git a/c/tests/test_glm53_streaming.py b/c/tests/test_glm53_streaming.py
new file mode 100644
index 00000000..5473903c
--- /dev/null
+++ b/c/tests/test_glm53_streaming.py
@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""Lo streaming degli esperti legge davvero i byte giusti.
+
+Sul modello vero gli esperti sono 171 GB e non entrano in RAM: il motore tiene
+una tabella dei loro indirizzi, una cache LRU per layer, e costruisce le
+matrici puntando dentro allo slot appena letto. Un offset sbagliato, una forma
+scambiata fra gate e down, una vittima scelta male: nessuna di queste cose
+fa cadere il programma. Calcola su altri byte e risponde lo stesso.
+
+Il confronto e' fra due fixture con gli stessi identici numeri, uno col
+contenitore int4 che il motore legge in streaming e uno con quegli stessi
+valori gia' dequantizzati, che il motore carica residenti. La quantizzazione e'
+avvenuta in entrambi, quindi l'unica differenza rimasta e' da dove arrivano i
+byte, e le risposte devono coincidere.
+
+Si esegue due volte sul contenitore int4: con un budget largo, dove ogni
+esperto si legge una volta sola, e con un budget da uno slot, dove la cache
+sbatte e gli stessi esperti vengono riletti in continuazione. Se il secondo
+giro rispondesse diverso, sarebbe l'eviction a sbagliare.
+
+Il conteggio dei miss viene controllato perche' sia diverso da zero: un motore
+che avesse silenziosamente caricato tutto in RAM passerebbe ogni altro
+controllo di questo test.
+"""
+import argparse
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def run(binary, fixture, patches, grid, budget=None):
+ environment = {**os.environ, "GLM53_BITS": "32"}
+ if budget is not None:
+ environment["GLM53_EXPERT_GB"] = budget
+ command = [binary, "--model", str(fixture), "--ids", patches["ids"]]
+ if patches["file"]:
+ command += ["--patches", patches["file"], "--grid", grid]
+ command += ["--greedy", "3"]
+ result = subprocess.run(command, capture_output=True, text=True, check=True,
+ env=environment)
+ parsed = {}
+ for line in result.stdout.splitlines():
+ if line.strip():
+ parsed[line.split()[0]] = line.split()[1:]
+ return parsed
+
+
+def main() -> int:
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("--binary", required=True)
+ parser.add_argument("--quantized", type=Path, required=True,
+ help="fixture con gli esperti nel contenitore int4")
+ parser.add_argument("--dequantized", type=Path, required=True,
+ help="fixture con quegli stessi valori in f32")
+ arguments = parser.parse_args()
+
+ reference = json.loads((arguments.quantized / "ref.json").read_text())
+ grid_h, grid_w = reference.get("grid", (0, 0))
+ image = arguments.quantized / "patches.f32"
+ patches = {"ids": ",".join(str(t) for t in reference["prompt"]),
+ "file": str(image) if image.exists() else None}
+ grid = f"{grid_h}x{grid_w}"
+
+ resident = run(arguments.binary, arguments.dequantized, patches, grid)
+ wide = run(arguments.binary, arguments.quantized, patches, grid, budget="8")
+ narrow = run(arguments.binary, arguments.quantized, patches, grid, budget="0.000001")
+
+ if "experts" not in wide or "experts" not in narrow:
+ print("FAIL: il motore non ha usato lo streaming sul contenitore int4")
+ return 1
+ misses = {"largo": int(wide["experts"][3]), "stretto": int(narrow["experts"][3])}
+ if misses["largo"] < 1:
+ print("FAIL: nessuna lettura da disco, gli esperti non sono stati streammati")
+ return 1
+ if misses["stretto"] <= misses["largo"]:
+ print(f"FAIL: con un solo slot i miss non aumentano "
+ f"({misses['stretto']} contro {misses['largo']}): la cache non sfratta")
+ return 1
+
+ for label, run_output in (("budget largo", wide), ("budget stretto", narrow)):
+ for field in ("teacher_forcing", "greedy"):
+ if run_output[field] != resident[field]:
+ print(f"FAIL {field} con {label}\n"
+ f" streaming: {run_output[field]}\n"
+ f" residente: {resident[field]}")
+ return 1
+
+ print(f"PASS GLM-5.3 streaming: stessi token dei pesi residenti, "
+ f"{misses['largo']} letture col budget largo e {misses['stretto']} "
+ f"con un solo slot per layer")
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/c/tools/make_glm53_streaming_pair.py b/c/tools/make_glm53_streaming_pair.py
new file mode 100644
index 00000000..1e2905ce
--- /dev/null
+++ b/c/tools/make_glm53_streaming_pair.py
@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Da un fixture GLM-5.3 f32, la coppia che prova lo streaming degli esperti.
+
+Il motore ha due strade per gli esperti. Con un checkpoint f32 li carica tutti
+in RAM; col contenitore int4 li lascia su disco e ne legge uno slot per volta,
+con tabella degli indirizzi, cache LRU per layer e matrici che puntano dentro
+allo slot. La seconda strada e' quella che serve sul modello vero, ed e' anche
+quella dove si sbaglia un offset, una forma o una vittima della cache senza che
+il programma se ne accorga: legge byte diversi e continua a rispondere.
+
+Qui si scrivono due fixture con gli stessi identici numeri:
+
+ <out>-i4 gli esperti nel contenitore int4 gs64 (`nome` U8 + `nome.qs` F32)
+ <out>-deq gli stessi esperti in f32, dequantizzati da quel contenitore
+
+Il resto dei pesi non viene toccato. Il motore deve rispondere allo stesso modo
+sui due: la differenza fra le due esecuzioni non e' la quantizzazione, che e'
+gia' avvenuta in entrambe, ma solo da dove arrivano i byte.
+
+USO:
+ python3 tools/make_glm53_streaming_pair.py --fixture ~/glm53_mm_tiny \\
+ --output ~/glm53_stream
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+from pathlib import Path
+
+EXPERT_MARK = ".mlp.experts."
+GROUP = 64
+
+
+def quantize(weight, numpy):
+ """int4 con una scala ogni 64 colonne, la stessa di convert_glm53.py."""
+ rows, columns = weight.shape
+ groups = (columns + GROUP - 1) // GROUP
+ padded = numpy.zeros((rows, groups * GROUP), numpy.float32)
+ padded[:, :columns] = weight
+ blocks = padded.reshape(rows, groups, GROUP)
+ amax = numpy.abs(blocks).max(axis=2, keepdims=True)
+ step = numpy.maximum(amax / 7.0, 1e-8)
+ level = numpy.clip(numpy.rint(blocks / step), -8, 7).astype(numpy.int32)
+ level = level.reshape(rows, groups * GROUP)[:, :columns]
+
+ packed = numpy.zeros((rows, (columns + 1) // 2), numpy.uint8)
+ low = (level[:, 0::2] + 8).astype(numpy.uint8)
+ packed[:, :low.shape[1]] = low
+ if columns > 1:
+ high = (level[:, 1::2] + 8).astype(numpy.uint8)
+ packed[:, :high.shape[1]] |= (high << 4)
+ dequantized = (level * step.reshape(rows, groups).repeat(GROUP, axis=1)[:, :columns])
+ return packed.reshape(-1), step[:, :, 0].astype(numpy.float32).reshape(-1), \
+ dequantized.astype(numpy.float32)
+
+
+def build(fixture: Path, output: Path) -> int:
+ import numpy
+ import torch
+ from safetensors import safe_open
+ from safetensors.torch import save_file
+
+ quantized_dir = Path(str(output) + "-i4")
+ dequantized_dir = Path(str(output) + "-deq")
+ for directory in (quantized_dir, dequantized_dir):
+ directory.mkdir(parents=True, exist_ok=True)
+
+ quantized, dequantized = {}, {}
+ experts = 0
+ with safe_open(str(fixture / "model.safetensors"), "pt") as handle:
+ for name in handle.keys():
+ tensor = handle.get_tensor(name)
+ if EXPERT_MARK not in name or not name.endswith(".weight") or tensor.dim() != 2:
+ quantized[name] = tensor
+ dequantized[name] = tensor
+ continue
+ packed, step, plain = quantize(tensor.float().numpy(), numpy)
+ quantized[name] = torch.from_numpy(packed)
+ quantized[name + ".qs"] = torch.from_numpy(step)
+ dequantized[name] = torch.from_numpy(plain)
+ experts += 1
+
+ if not experts:
+ print(f"{fixture}: nessun esperto da convertire")
+ return 2
+
+ save_file(quantized, str(quantized_dir / "model.safetensors"), metadata={"format": "pt"})
+ save_file(dequantized, str(dequantized_dir / "model.safetensors"), metadata={"format": "pt"})
+ for directory in (quantized_dir, dequantized_dir):
+ for extra in ("config.json", "ref.json", "patches.f32"):
+ source = fixture / extra
+ if source.exists():
+ shutil.copy(source, directory / extra)
+
+ print(f"scritti {quantized_dir.name} e {dequantized_dir.name} "
+ f"({experts} matrici di esperti)")
+ return 0
+
+
+def main() -> int:
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("--fixture", type=Path, required=True)
+ parser.add_argument("--output", type=Path, required=True)
+ arguments = parser.parse_args()
+ return build(arguments.fixture, arguments.output)
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())