Skip to content

Latest commit

 

History

History
231 lines (191 loc) · 19.7 KB

benchmark_rust_vs_python.md

File metadata and controls

231 lines (191 loc) · 19.7 KB

Бенчмарк: Rust-порт WeightX vs Python/PyTorch

Дата: 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).

1. Числовое ядро (SmolLM2-135M, batch=1)

Операция 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-ядро — чистый ndarray f32 без BLAS и без многопоточности; torch CPU использует MKL/oneDNN на 10 потоках. Разрыв 2.3–3.3× на CPU — следствие этого, а не «Rust медленный язык».
  • EAMIT на реальных размерах: Python выигрывает за счёт LAPACK (np.linalg.inv 1536×1536) и векторизованного Adam-выравнивания эмбеддингов KL(P_r || P_k) + top-M MSE; Rust использует собственный f64 Gauss-Jordan + ndarray-циклы. На малых матрицах (MiniLlama) наоборот — Rust быстрее, т.к. у numpy/Python высоки накладные расходы на вызов и мелкие тензоры в цикле оптимизации выравнивания.
  • L2-профиль у обеих версий упирается в SVD больших матриц — одинаково.

2. Остальные компоненты

Операция 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)

3. Точность (parity): совпадают ли результаты?

Одни и те же веса (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_format 1.2.0, а Rust-порт повторял fallback-энкодер. Исправлено в toon.rs (shortest-roundtrip float + квотирование число-подобных строк), добавлен регрессионный тест; после фикса кросс-декод в обе стороны — 0 расхождений, размер выхода идентичен (21 400 символов). Замеры TOON в таблице §2 — после фикса (до фикса было 0.52/0.44 мс, но несовместимо).

4. Вердикты по компонентам

Компонент Вердикт Обоснование
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 выигрывает или держит паритет — там перенос оправдан.

5. Найденные проблемы

  1. TOON-энкодер: потеря точности и типов — найдено кросс-тестом, исправлено (rust/crates/weightx-core/src/toon.rs), регрессионный тест добавлен, все 23 Rust-теста зелёные.
  2. Экспорт safetensors в Rust ×4.3 медленнее — частично исправлено в гибридной итерации (×1.9, zero-copy, см. §7 «Попутно исправлено»); остаток — сериализация и запись, чинится потоковой записью.
  3. Числовое ядро без BLAS/потоков/GPU — корневая причина проигрыша torch (см. §4).
  4. MiniLlama: разные ГСЧ — демо-веса Rust и Python не совпадают (0.15% MSE). Некритично; при желании выравнивается общим фикстуром весов.
  5. 26 предупреждений компилятора (snake_case и т.п.) — косметика, на работу не влияет.

6. Варианты решения (на выбор)

  • 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/планах. Не рекомендую: остальной порт себя оправдал.

7. Гибридная архитектура (реализована 2026-11-13)

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'а, применение весов и метрики — через Rust set_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 — тайминги операций.

Замеры гибрида (SmolLM2-135M, тот же стенд; машина шумит, min устойчивее mean)

Операция Чистый 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.

Точность гибрида (parity)

Проверка Гибрид Эталон 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 вместо поэлементной конвертации.

Ограничения (честно)

  1. Разовые CLI-вызовы на больших моделях платят старт sidecar'а (~5–12 с: импорт torch + построение модели). Для wx --help, каталога, TOON, планов и малых моделей sidecar не запускается вовсе.
  2. Градиентный обмен (538 МБ на вызов) делает гибридные grads медленнее чистого torch в ~2–4 раза, но всё равно быстрее чистого Rust. Рычаг улучшения — передавать только нужные тензоры / считать нормы на стороне Python.
  3. L2-профиль остаётся SVD-bound на Rust; гибрид здесь ничего не ускоряет.
  4. 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.