- Python 86.6%
- Shell 6.2%
- Metal 3.4%
- Jupyter Notebook 2.4%
- Rust 0.6%
- Other 0.8%
| Filename | Latest commit message | Latest commit date |
|---|---|---|
| assets | ||
| data | ||
| docs | ||
| out | ||
| scripts | ||
| tests | ||
| .gitattributes | ||
| .gitignore | ||
| .lane-daemon.log | ||
| .lane-daemon.pid | ||
| .lane-state.json | ||
| ayeos_export.py | ||
| ayeos_i2s_g64_gemv.metal | ||
| ayeos_q4_g64_lmhead.metal | ||
| bench-watch.out | ||
| bench-watch.sh | ||
| bench.sh | ||
| box.env | ||
| build_corpus.py | ||
| CATALOG.md | ||
| CHANGELOG.md | ||
| classroom_v2.py | ||
| colab_e2e_qwen.ipynb | ||
| colab_sprint.sh | ||
| comet.sh | ||
| dashboard.nu | ||
| dashboard.sh | ||
| deepsiper_enthea_gate.py | ||
| distill_consensus.py | ||
| e2e.sh | ||
| elder_cache_gen.py | ||
| engram_headroom.py | ||
| eval.sh | ||
| feed_dogfood.py | ||
| flake.nix | ||
| generate_benchmark_report.py | ||
| install.sh | ||
| lane.py | ||
| ledger.py | ||
| LICENSE | ||
| make_colab_e2e.py | ||
| make_sim_model.py | ||
| mem8_condition.py | ||
| mem8_moe.py | ||
| mem8_wave_loss.py | ||
| mirror-big.sh | ||
| mirror_peetpedro_hf.py | ||
| mlx.sh | ||
| mlx_mem8_wave_loss.py | ||
| model_card_template.md | ||
| MODELS.md | ||
| pack_out.py | ||
| PLAN.md | ||
| polars_corpus.py | ||
| pops.contract.json | ||
| pops.py | ||
| pq_randomx_pouw.py | ||
| quantize.sh | ||
| quantize_b158.py | ||
| quantize_pqm.py | ||
| README.md | ||
| run_finetune.py | ||
| save_to_hf.sh | ||
| secrets.env.example | ||
| setup_box.sh | ||
| sprint.sh | ||
| sprint_boot.py | ||
| sprint_download.sh | ||
| sprint_harvest.sh | ||
| sprint_probe.py | ||
| sprint_watch.sh | ||
| sprint_zip.py | ||
| stages.py | ||
| train.py | ||
| train.sh | ||
| train_deepseek_pqm.py | ||
| v41.sh | ||
| v41_knobs.py | ||
| VERSION | ||
| viewer.py | ||
| watch-alt.sh | ||
the training pipeline — the obliterated lane, on the big box
beast-box · quick setup (the 140 TB lake, one afternoon)
git clone https://github.com/8b-is/training-pipeline && cd training-pipeline
sudo ./setup_box.sh # the U.2 lake mounted, llama.cpp native AVX-512 (CUDA-89)
source box.env # CPU/GPU/RAM/disk — the box's truth in the env
./lane setup && ./lane train && ./lane quantize && ./lane eval && ./lane view
- the hardware: Xeon Gold 5412U (Sapphire Rapids, AVX-512) · RTX 6000 Ada 48 GB · ~700 GB DDR5 ECC · ~140 TB SSD (2× U.2 NVMe)
- the lane binary abstracts every stage to one verb;
lane viewopens the live watchroom at localhost:4242 - the mirror rides the U.2 lake (LRU cap 1 TB — the 140 TB is the lane's)
v0.3.0 — changelog · the whole corridor: ./e2e.sh (20 green) · install · the private lane of the 8b-is org.
The constellation's fine-tune corridor, optimized for the RTX 6000 Ada (48 GB VRAM) · 760 GB RAM · ~140 TB storage workstation: unsloth QLoRA → merged fp16 → MLX (the battle-Macs) + GGUF (imatrix quantized on the full corpus) → verdict eval → the box's mirror (no 10 GB leash — the 140 TB is the leash).
MEMNET·MEM8 as the MoE-cognitive router
The lane's finished adapters are the EXPERTS; the mem8 quad's bilinear
phase-interpolation + boolean gates ROUTE each prompt to an expert —
the memory picks the mind, observer-relative, mutating none of them
(mem8_moe.py, the Rust/Zig twin's math, portable fixture pinned). The
NEXT training experiment is memory-addressed from birth: every
instruction carries its [mem8::<gated>&<delta>] token
(mem8_condition.py), so the model learns the routing it rides.
the format: polars (the election)
The pipeline's data is polars-shaped (arrow/parquet), not loose
json: data/corpus.parquet (source · kind · chars · sha256 · text —
the peetPedro sweep + the top-5 sails), data/world.parquet (the
doctrine pairs), and data/runs.parquet (the lane's ledger — one row
per train+eval). The jsonl the trainers eat is a derived
materialization, never the truth. The mem8 sketch's flow — observer
delta → quadrant → interpolation → quantized sink — is the shape the
data rides: one schema, continuous, no spills.
uv run polars_corpus.py # world.parquet + corpus.parquet (+ the jsonls)
uv run polars_corpus.py --corpus # with the full PeetPedro + top-5 sweep
uv run ledger.py record --model OBLITERATUS/... [--ppl ...]
uv run ledger.py show
uv run ledger.py show
uv run feed_dogfood.py --model OBLITERATUS/... --steps <done> --target 200
./dashboard.sh # the pure-ASCII live view (watch -n 180)
the full corpus
The world's ground for the fine-tune AND the imatrix calibration:
all of PeetPedro/'s Hugging Face datasets + the top-5 most-downloaded
mixed text datasets, composed by build_corpus.py (probe mode lists
the picks without downloading; the box raises MAX_CHARS).
uv run build_corpus.py --probe # the peetPedro sweep + the top-5, live
uv run build_corpus.py # stream everything into corpus/corpus.txt
the hardware profile
| resource | the box | what it buys |
|---|---|---|
| 48 GB VRAM | RTX 6000 Ada | QLoRA 4-bit of the 27B (~20 GB) at batch 16; the 9B at batch 32 |
| 760 GB RAM | the workstation | imatrix calibration on the FULL corpus; fp16 merges resident; many models at once |
| ~140 TB | the shelf | every quant of every pick, checkpoints, the mirror unlimited |
the lane binary + the viewer
./lane abstracts the whole corridor to one command (setup · profile ·
train · quantize · eval · bench · status · list · stream), and
lane view opens the live training dashboard at localhost:4242 —
the box's watchroom, auto-refreshing (box, live log, the polars ledger,
the models). Full plan: PLAN.md. The whole lane, drawn:
pipeline-viz.html — the ternary wave canvas,
the qSpace mem8-quad, the corridor diagram.
runs
# the four picks (env-driven)
MODEL=OBLITERATUS/Ornith-1.5-9B-OBLITERATED STEPS=240 ./train.sh
MODEL=OBLITERATUS/gemma-4-E4B-it-OBLITERATED ./train.sh
MODEL=OBLITERATUS/Gemma-4-12B-OBLITERATED STEPS=300 ./train.sh
MODEL=OBLITERATUS/Qwen3.8-27B-OBLITERATED STEPS=200 ./train.sh # the far room finally fits
./quantize.sh # GGUF: imatrix on the corpus → Q4_K_M · Q5_K_M · Q6_K · Q8_0
./mlx.sh # MLX 4-bit, group 64, for the Macs
./eval.sh # perplexity + refusal-spot battery + the verdict table
./mirror-big.sh # seat everything into the box's mirror (cap override)
Defaults are tuned for the 48 GB box; every knob is an env var
(BATCH, SEQ, GBYTES, STEPS, LR, MIRROR_MAX).
the lane's chain
train (world + instruct mix) → merged fp16 → GGUF imatrix (the calibration IS the corpus) + MLX → eval verdict (perplexity · the abliteration survival · the dream penetration) → mirror seat.
the constellation · 0 + 1 · fine touch from within · vaked.dev
the record layer (POP)
Every lane event is a record: id · kind · parent · payload_hash · payload_ref · timestamp · actor · protocol_version · attestation,
hash-linked and monotonic (pops.py — the protocol kernel, +
pops.contract.json + the treaty).
The Go city (bonobo@Memex, flyxion/spherepop-core) and this kernel are
bit-exact on event ids — sha256(source | payload_hash)[:16],
proven on live samples. V(L) re-derives the warrant: schema ∧ transition
∧ references ∧ hash-chain ∧ monotonicity ∧ no-branching. Refusals are
records, not erasures.
the constellation's surfaces
- the models registry: MODELS.md — every HF seat names its GitHub source, both ways
- the E2E notebook: colab_e2e_qwen.ipynb — one run, qwen-obliterated
- the oven's eye:
./sprint_watch.sh— the live training tail - the persistent memory:
POST https://8s.is/api/v1/recall— the constellation's recall surface
the constellation · 0 + 1 · fine touch from within · vaked.dev