Дата: 2026-11-13. Стенд: Windows 11, RTX 4060, torch 2.14.1+cu126 (CPU: 10 потоков), Python 3.13.17, Rust 1.100 (release, LTO). Модель: SmolLM2-135M (реальная, 134.5M параметров, bf16 safetensors из HF-кэша) + MiniLlama (синтетическая, 4 слоя).
Методика: одинаковые входы для обеих версий (одни и те же веса, одни и те же 50 EAMIT-фактов,
одинаковые LCG input ids, один YAML-план, один TOON-payload). Прогрев + 3–20 итераций,
замер wall-time. Дополнительно — проверки точности (§3): контрольные суммы логитов/градиентов,
побитовое сравнение экспортов, кросс-декод TOON. Rust — wx-bench.exe
(rust/crates/wx-cli/src/bin/wx-bench.rs), Python — docs/benchmarks/bench_py.py
(сырые данные: docs/benchmarks/*.jsonl).
| Операция | Rust (CPU, 1 поток) | torch CPU (10 потоков) | torch CUDA (RTX 4060) | Кто быстрее |
|---|---|---|---|---|
| Forward, seq=64 | 748 мс | 224 мс | 66 мс | torch CPU ×3.3, CUDA ×11 |
| Forward, seq=128 | 1039 мс | 406 мс | 68 мс | torch CPU ×2.6, CUDA ×15 |
| Forward+backward (все градиенты), seq=64 | 2307 мс | 999 мс | 253 мс | torch CPU ×2.3, CUDA ×9 |
| EAMIT (align + ridge), 50 фактов × 4 слоя (1536×576) | 23 490 мс (мин. 18 356) | 7 698 мс (мин. 7 235) | — (numpy/CPU) | Python ×3.05 |
| L2-профиль (13 метрик × 30 слоёв, seq=32) | 26.7 с | 25.6 с | 26.3 с | паритет |
| EAMIT на MiniLlama (50 × 3, 172×64) | 10.2 мс (мин. 9.6) | 684 мс (мин. 646) | — | Rust ×67 |
Пояснения:
- Rust-ядро — чистый
ndarrayf32 без BLAS и без многопоточности; torch CPU использует MKL/oneDNN на 10 потоках. Разрыв 2.3–3.3× на CPU — следствие этого, а не «Rust медленный язык». - EAMIT на реальных размерах: Python выигрывает за счёт LAPACK (
np.linalg.inv1536×1536) и векторизованного Adam-выравнивания эмбеддинговKL(P_r || P_k) + top-M MSE; Rust использует собственный f64 Gauss-Jordan +ndarray-циклы. На малых матрицах (MiniLlama) наоборот — Rust быстрее, т.к. у numpy/Python высоки накладные расходы на вызов и мелкие тензоры в цикле оптимизации выравнивания. - L2-профиль у обеих версий упирается в SVD больших матриц — одинаково.
| Операция | Rust | Python | Кто быстрее |
|---|---|---|---|
Старт CLI (wx --help, холодный процесс) |
212 мс (мин. 58) | 2947 мс | Rust ×14 |
| Загрузка модели из HF-кэша (холодный процесс) | 0.59–0.79 с | 5.2–6.5 с (с первым импортом transformers) | Rust ×8 |
| Загрузка модели в прогретом процессе | ~0.6–0.8 с | 0.60 с | паритет |
| E2E демо: полный WSP-цикл (L1→L2→план→EAMIT→Vespasian) | 204 мс | 5573 мс | Rust ×27 |
| TOON encode (таблица тензоров, 21.4 КБ) | 0.74 мс | 2.78 мс | Rust ×3.8 |
| TOON decode | 0.67 мс | 1.94 мс | Rust ×2.9 |
| Исполнение YAML-плана (5 шагов, workspace SmolLM2) | 13.7 мс | 33.1 мс | Rust ×2.4 |
| Загрузка safetensors 269 МБ + построение workspace | 273 мс | 212 мс | Python ×1.3 |
| Экспорт safetensors (все 272 тензора) | 1474 мс | 342 мс | Python ×4.3 |
| describe_tensor (статистика + top-k, 884K параметров) | 245 мс | 216 мс | паритет (Python ×1.14) |
| Sandbox round-trip (запуск python-кода над тензором) | 229 мс | 186 мс | паритет (обе стороны спавнят Python) |
Одни и те же веса (bf16 safetensors), одни и те же LCG input ids, одни и те же 50 фактов. Контрольные суммы считаются в f64 по выходам f32.
| Проверка | Rust | Python (torch CPU) | Относительное расхождение |
|---|---|---|---|
| Forward seq=64, сумма логитов | 54 381 916.274 | 54 381 931.961 | 2.9e-7 |
| Forward seq=128, сумма логитов | 118 600 013.214 | 118 600 023.328 | 8.5e-8 |
| Градиенты seq=64, Σ‖g‖² (272 тензора) | 796.117025 | 796.149652 | 4.1e-5 |
| EAMIT SmolLM2: pre-edit MSE | 0.21095170850493764 | 0.21095170850493694 | 3e-15 |
| EAMIT SmolLM2: post-edit MSE | 0.00018898723343218244 | 0.0001889872334322112 | 1.5e-13 |
| EAMIT SmolLM2: alignment KL (pre → post) | 0.09712446145047543 → 0.06173833727440217 | 0.09712446145047551 → 0.06173833727440214 | <1e-15 |
| Экспорт safetensors (272 тензора, f32) | — | — | 0.0, побитово 272/272 |
| YAML-план (5 шагов) | success | success | идентичный результат |
| TOON cross-decode (Rust↔Python) | OK | OK | 0 расхождений (после фикса, см. ниже) |
Вывод: численный паритет подтверждён. Расхождения 1e-7…4e-5 на логитах/градиентах — нормальный эффект разного порядка накопления f32 при bf16-весах (torch CUDA даёт тот же порядок расхождений между собой). EAMIT на реальной модели совпадает до 13-го знака (и KL до 15-го). Экспорты весов побитово идентичны — Rust-порт не портит веса.
Нюансы:
- MiniLlama (синтетическая демо-модель): pre-MSE 0.088187 (Rust) vs 0.088052 (Python),
расхождение 0.15%. Причина: обе версии строят демо-веса своим ГСЧ с seed=2026
(Rust: ChaCha8Rng, Python: torch/np Mersenne Twister) — веса разные, это не баг.
Поведение редактирования эквивалентно: MSE падает в ~77–78 раз (98.7%,
0.088 -> 0.0011), аalignment_klснижается с ~1.15–1.21 до ~0.64–0.67 в обеих версиях; на SmolLM2 (1536×576) MSE снижается в ~1116 раз (99.91%). - TOON: до фикса Rust-энкодер терял точность float (
%.6g: 181.0093→181.009) и не квотил число-подобные строки ("576"→576), из-за чего Python декодировал Rust-TOON со 151 расхождением. Python использует reference-библиотекуtoon_format1.2.0, а Rust-порт повторял fallback-энкодер. Исправлено вtoon.rs(shortest-roundtrip float + квотирование число-подобных строк), добавлен регрессионный тест; после фикса кросс-декод в обе стороны — 0 расхождений, размер выхода идентичен (21 400 символов). Замеры TOON в таблице §2 — после фикса (до фикса было 0.52/0.44 мс, но несовместимо).
| Компонент | Вердикт | Обоснование |
|---|---|---|
| CLI / оркестрация / старт | Оставить Rust | ×14 старт, ×8 холодная загрузка, ×11 E2E |
| TOON | Оставить Rust | ×3–4, паритет подтверждён |
| YAML-планы (plan engine) | Оставить Rust | ×2.4, идентичный результат |
| Workspace I/O (загрузка) | Оставить Rust | паритет (Python ×1.3 — в пределах шума) |
| Workspace I/O (экспорт) | Python быстрее ×4.3 | 1474 vs 342 мс; чинится буферизацией, но пока факт |
| describe / sandbox / L2-профиль | Паритет | обе стороны упираются в одно и то же (SVD / спавн Python) |
| EAMIT на малых матрицах | Оставить Rust | ×67 (MiniLlama: 10.2 vs 684 мс) |
| Forward / backward на реальных моделях | PyTorch лучше | CPU ×2.3–3.3, CUDA ×9–15 |
| EAMIT на реальных размерах (1536×576) | PyTorch/NumPy лучше ×3.05 | LAPACK + векторизованный Adam vs pure Rust |
Главный честный вывод: переносить ВСЁ на Rust смысла нет. Числовое ядро на реальных моделях у PyTorch быстрее в 2.3–15 раз, потому что Rust-ядро — чистый ndarray f32 без BLAS, без многопоточности и без GPU, а torch использует MKL/oneDNN (10 потоков) и CUDA. Это разрыв реализаций, а не языков: с BLAS+rayon Rust мог бы догнать torch CPU, но CUDA-разрыв (×9–15) без GPU-бэкенда не закрыть в принципе. Все остальные компоненты Rust выигрывает или держит паритет — там перенос оправдан.
- TOON-энкодер: потеря точности и типов — найдено кросс-тестом, исправлено
(
rust/crates/weightx-core/src/toon.rs), регрессионный тест добавлен, все 23 Rust-теста зелёные. - Экспорт safetensors в Rust ×4.3 медленнее — частично исправлено в гибридной итерации (×1.9, zero-copy, см. §7 «Попутно исправлено»); остаток — сериализация и запись, чинится потоковой записью.
- Числовое ядро без BLAS/потоков/GPU — корневая причина проигрыша torch (см. §4).
- MiniLlama: разные ГСЧ — демо-веса Rust и Python не совпадают (0.15% MSE). Некритично; при желании выравнивается общим фикстуром весов.
- 26 предупреждений компилятора (snake_case и т.п.) — косметика, на работу не влияет.
- A. Гибрид — ВЫБРАН И РЕАЛИЗОВАН (см. §7). Rust остаётся для CLI, оркестрации, TOON, планов, I/O (везде выигрыш ×2–27). Тяжёлая численность (forward/backward, EAMIT на реальных моделях) — через PyTorch-sidecar. Ничего не теряем.
- B. Улучшать Rust-ядро. Подключить BLAS (ndarray-linalg/OpenBLAS) + rayon для матмулов, LAPACK для EAMIT. Реалистично догнать torch CPU (×2–3 разрыв закрыть), но GPU не появится — CUDA останется быстрее в разы. Объём работы: большой.
- C. Полный откат на Python. Потеряем выигрыши ×2–14 в CLI/E2E/TOON/планах. Не рекомендую: остальной порт себя оправдал.
Rust orchestration + PyTorch numerics. Выбор варианта A из §6.
rust/crates/weightx-core/src/torch_backend.rs—TorchArch, обёртка над нативнойModelArch:forward,weight_grads,mlp_keys_gradsи полный EAMIT делегируются персистентному Python-sidecar'у;config,weight_names,lens_logits(дешёвая проекция головы) остаются в Rust.rust/crates/weightx-core/src/torch_worker.py— JSONL-worker (вкомпилирован в бинарник черезinclude_str!), переиспользует эталонный Python-пакетweightx: forward/backward через PyTorch (MKL/oneDNN + CUDA), EAMIT черезweightx.l3_weights.eamit(numpy/LAPACK + key-residual embedding alignment).- Обмен: веса синхронизируются инкрементально по счётчику ревизий workspace
(
WeightWorkspace::revision), большие массивы (логиты/градиенты/ключи) — через.safetensorsво временном каталоге. Таймаут запроса —WEIGHTX_TORCH_TIMEOUT(по умолчанию 900 с), при сбое sidecar перезапускается. - EAMIT: sidecar оптимизирует выравнивание остатков к ключам (
KL + top-M MSE) и решает систему с LAPACK, Fisher-регуляризация передаётся из Rust-.guard'а, применение весов и метрики — через Rustset_tensor(семантика защиты сохраняется). - Авто-выбор (
WEIGHTX_BACKEND=auto, по умолчанию): модели ≥ 5M параметров оборачиваются в torch-sidecar, малые/демо-модели (MiniLlama) остаются на чистом Rust. Если Python+torch недоступны — тихий откат на Rust.
wx --backend rust|torch|auto <команда>или переменнаяWEIGHTX_BACKEND.WEIGHTX_TORCH_DEVICE=cpu|cuda|auto(по умолчанию auto: CUDA при наличии).WEIGHTX_PYTHON— интерпретатор (по умолчанию.venvрепозитория, затем PATH);WEIGHTX_HOME— корень репозитория;WEIGHTX_SIDECAR_LOG=1— тайминги операций.
| Операция | Чистый Rust | Гибрид CPU | Гибрид CUDA | Чистый torch (из §1) |
|---|---|---|---|---|
| Forward seq=64 | 748 мс | 253 мс (×3.0) | 89–97 мс (×7.7–8.4) | 224 / 66 мс |
| Forward seq=128 | 1039 мс | — | 118 мс (×8.8) | 406 / 68 мс |
| Forward+backward seq=64 | 2307 мс | 1674 мс (×1.4) | 1185 мс (×1.9) | 999 / 253 мс |
| EAMIT 50×4 (steady-state, min) | 23 490 мс (мин. 18 356) | 7 970 мс (×2.95) | — (numpy/CPU) | 7 698 мс |
| EAMIT MiniLlama (auto → Rust) | 10.2 мс | 12.5 мс (мин. 10.7) | — | 684 мс |
| YAML-план (auto → Rust) | 13.7 мс | 14.9 мс | — | 33.1 мс |
| L2-профиль seq=32 | 71.7 с* | 71.6 с | паритет | — |
* Контрольный замер чистого Rust в тот же день: 71.7 с вместо 26.7 с из §1 — машина была в другом состоянии (троттлинг/фон). L2 упирается в SVD на стороне Rust, выбор бэкенда на него почти не влияет; разовый вызов дополнительно платит ~11 с за старт sidecar'а (импорт torch + построение модели), в длинной сессии это амортизируется.
Накладные расходы гибрида: IPC + обмен файлами (~20–30 мс на forward, ~0.6–0.9 с на полный градиентный обмен 538 МБ). Первый вызов EAMIT включает инициализацию sidecar'а (~12 с), далее — паритет с чистым Python.
| Проверка | Гибрид | Эталон Python (§3) | Расхождение |
|---|---|---|---|
| Forward seq=64 CPU, Σ логитов | 54 381 931.96127349 | 54 381 931.961 | 0 (побитово) |
| Градиенты seq=64 CPU, Σ‖g‖² | 796.1496520606638 | 796.149652 | 0 (побитово) |
| EAMIT pre/post MSE & align KL | 0.21095 / 0.00018898723343221195 (KL 0.09712→0.06174) |
те же (0.0001889872334322112) |
<4e-15 |
| Forward CUDA, Σ логитов | 54 381 923.77 | 54 381 931.96 (CPU) | 1.5e-7 (норма для CUDA) |
Гибрид на CPU даёт тот же самый torch, поэтому совпадение побитовое; EAMIT совпадает с эталонным numpy/LAPACK до 15-го знака.
cargo test --workspace — 27 тестов зелёные, включая 3 parity-теста
гибрида (torch_backend::tests: forward/grads/eamit против нативного Rust на
одинаковых весах; пропускаются, если Python+torch недоступны).
- Экспорт safetensors ускорен ×1.9 (1474 → ~774 мс на 538 МБ): zero-copy
reinterpret f32→байты на little-endian + отказ от лишних копий
(
tensor.rs). До Python (342 мс) остаётся разрыв ~2.3× — упирается в сериализацию и запись файла; дальнейшее улучшение — потоковая запись. - Загрузка f32 safetensors — один memcpy вместо поэлементной конвертации.
- Разовые CLI-вызовы на больших моделях платят старт sidecar'а (~5–12 с:
импорт torch + построение модели). Для
wx --help, каталога, TOON, планов и малых моделей sidecar не запускается вовсе. - Градиентный обмен (538 МБ на вызов) делает гибридные grads медленнее чистого torch в ~2–4 раза, но всё равно быстрее чистого Rust. Рычаг улучшения — передавать только нужные тензоры / считать нормы на стороне Python.
- L2-профиль остаётся SVD-bound на Rust; гибрид здесь ничего не ускоряет.
WEIGHTX_BACKEND=torchна модели без HF-конфига строит конфиг из полейModelConfig; для MiniLlama (RoPE выключен) torch-путь не эквивалентен — поэтому auto-режим никогда не оборачивает малые модели.
Сырые данные и скрипты: docs/benchmarks/ (results_*.jsonl, bench_py.py,
run_*.ps1, parity_check.py, toon_cross.py, общие фикстуры facts_*.json,
payload.json). Rust-бенч: rust/crates/wx-cli/src/bin/wx-bench.rs
(cargo build --release --bin wx-bench). Гибридные замеры:
docs/benchmarks/run_hybrid.ps1 → results_hybrid.jsonl
(WEIGHTX_BACKEND=auto, WEIGHTX_TORCH_DEVICE=cpu|cuda). Большие экспорты
safetensors (538 МБ) в репозиторий не включены — генерируются командами wsio.