mussolene/relative-int4-research-prototype

Relative INT4 Research Prototype

Дистилляция общего базиса и остаточных экспертов Qwen частично восстановила качество на validation. На 8192 новых независимых токенах perplexity равна 20,1589 против 17,8091 у Q8_0; допуск качества не пройден. Постоянные веса 4,292 против 4,471 ГБ, снижение примерно на 4,0%. Полное независимое сравнение завершено при тяжелой фоновой нагрузке Mac: наблюдаемые медианы 7,691 и 4,926 с. Ускорение и меньшая полная рабочая память по этой серии не подтверждены. Численная поправка на процент загрузки не применяется.

Продолжение общего базиса: 15 конфигураций с учетом исходных весов и полная Qwen с тремя замененными FFN. Нормализованные остаточные эксперты уменьшают ошибку отдельных блоков, но даже ранг 1536 дает рост perplexity полной модели на 17,7%. Кандидат отклонен по качеству; ускорение полного запроса с сохранением качества не получено. Код, все измерения и отрицательные результаты доступны.

Проверка общего базиса и остаточных экспертов: пилот FFN и качество полной Qwen при замене FFN 0. Первый кандидат ускоряет отдельный блок, но не проходит проверку качества полной модели: верхняя граница отношения perplexity к Q8_0 равна 1,058 при пороге 1,05. Общего ускорения с сохранением качества пока нет.

Продолжение Qwen: профиль CPU backbone, потоковое GDN и музыкальные источники. Качество сохранено, рабочие веса 4,35 против 4,47 ГБ Q8_0. Полный запрос 6,037 против 4,744 с, пик RSS 5,407 против 5,039 ГБ. Требуемого выигрыша нет; обе timing серии без зарегистрированных I/O faults процесса.

Новая оптимизация Qwen: общий packed embedding/head и объединенные проекции. Рабочие веса уменьшены до 4,35 ГБ против 4,47 ГБ Q8_0, качество сохраняется в заданных границах. Независимое сравнение завершено: полный запрос 7,627 против 4,749 с, требуемого ускорения нет. В обеих сериях есть I/O faults, поэтому времена диагностические. Все результаты опубликованы в отчете.

Проверка Qwen3.5-4B на CPU завершена: результаты и ограничения. На 8192 независимых токенах относительный INT8 сохраняет качество, но не дает выигрыша над обычным Q8_0: рабочие веса 5,62 против 4,47 ГБ, медиана полного запроса 7,717 против 4,746 с. Относительный INT4 отклонен по validation качеству. Времена BF16 и относительного INT8 диагностические из-за I/O faults процесса; чистое ускорение относительно BF16 не установлено.

Experimental layer-wise weight transfer using shared feature references, grouped INT4 weight codes, and a small low-rank quantization-error correction.

An additional real SMS classification experiment now includes a compiled native executor and a reloadable application model. See the Russian application section below. Its measured advantage is specific to this task and CPU, not general LLM acceleration or proof that relative coordinates outperform ordinary INT4.

A held-out GPT-2 124M comparison is also included below. Both INT4 variants use fewer working parameters, but the current executor slows full requests; relative INT4 fails the predefined quality tolerance. The LLM gain is not established.

This release is a research package with small trained checkpoints and synthetic tests. It is not a pretrained LLM, a Transformers AutoModel checkpoint, a fast general-purpose inference engine, or a completed low-bit training framework.

What is implemented

For an original linear map y = x W + b, introduce r = (x - c) / s and use W_relative = diag(s) W, b_relative = b + c W. Before quantization this preserves the map, subject to floating-point roundoff. After quantization, W_relative ~= W_INT4 + A B. The small correction is fitted from layer-input calibration activations. Linear dimensions and the surrounding model graph are preserved. No quaternion restriction or width reduction is imposed by transfer.

• Explicitly selected linear matrices, with in_out or out_in layout.
• NPZ and a minimal safetensors reader, including indexed shards and F32/F16/BF16.
• Layer-by-layer conversion, mixed per-layer FP32/INT4 policy, and saved reloadable references/codes/scales/bias/correction factors.
• NumPy reference execution, including arbitrary leading input dimensions.
• Independent layer-output checks and actual trained MLP end-to-end evaluation.
• Synthetic causal Transformer and top2 MoE graph compatibility tests.

The reference runtime uses FP32 activations and dequantizes groups for NumPy matmul. It is W4A32 storage, not an integer compute kernel. BF16 retained tensors are promoted to FP32. This minimal safetensors reader is not a replacement for the official library's full production validation.

Results: transferred trained models

Five trained 64 -> 64 -> 10 MLP checkpoints, sklearn digits, 359 calibration and 360 test examples, no fine-tuning after conversion. Original NPZ weights are FP64; the computational reference explicitly casts them to FP32.

Variant	Mean accuracy	Agreement with original predictions	Relative logit error
Original FP32 reference	97.1111%	100%	0
Relative FP32 transfer	97.1111%	100%	1.81e-7
Absolute INT4	97.0000%	99.2222%	0.07005
Relative INT4	97.0556%	99.3333%	0.04671
Relative INT4 + rank4 correction	97.1111%	99.7778%	0.02124

Relative error means norm(output_converted - output_reference) / norm(output_reference). Matching mean accuracy does not imply identical predictions or statistically established equivalence. The test split was used in earlier research; five initializations are not five independent test sets.

Scale and negative results

• 4096 x 4096 synthetic projection: 16,777,216 random weights. FP32 W+b payload: 67,125,248 bytes. Relative INT4 + rank4 files, including metadata: 9,553,240 bytes, approximately 7.03x smaller. FP32 rebase output error: 5.36e-7; INT4+rank4 output error: 0.09857. Rank4 barely helps on random full-rank error. Relative INT4 alone is slightly worse than absolute INT4.
• Reference-runtime latency on that projection: batch1 INT4+rank4 ~16.81ms versus FP32 BLAS ~1.62ms; batch16 ~33.99ms versus ~17.69ms. The current converter/runtime does not establish an inference speed advantage.
• Untrained synthetic Transformer: two causal blocks, 13 transferred linear layers. FP32 transfer preserves all tested top1 predictions and greedy generation. INT4+rank4 top1 agreement is 68.75%, with substantial accumulated logit error. This is not a language-quality evaluation.

MoE compatibility

An additional synthetic one-block test uses four experts, top2 routing, d32, hidden64. Each expert is calibrated only on the inputs routed to it. The FP32 router is retained unchanged. There are 512 calibration and 256 test inputs.

Variant	Relative block-output error	Test routes preserved
Relative FP32	1.12e-7	Yes
Relative INT4	0.05972	Yes
Relative INT4 + rank4	0.04907	Yes

The same input and unchanged router guarantee identical routing at this one block. Quantization of earlier blocks can change inputs to downstream routers. This result does not validate a trained MoE LLM, sparse-expert coverage, expert parallelism, communication costs, training speed or quality.

Proposed next steps: retain sensitive routers in higher precision, fit references and corrections per expert using routed inputs, keep rarely calibrated experts in higher precision, and evaluate the entire network. Shared expert bases are an additional hypothesis, not implemented here.

Separate native QAT study

native_qat_study.zip contains the earlier C++ W4A8 QAT study and its raw results. On a small digits MLP, a relative INT4 model with hidden width32 versus the original FP32 width64 obtained ~1.45x shorter training, ~2.07x lower warmed single-example inference latency, and a 9.25x smaller saved model. Training gains came from reduced width. At equal width QAT was slower to train than FP32 BLAS; compact ordinary FP32 trained faster than compact QAT. Backward, master weights and Adam states remained FP32. These results must not be attributed to the different NumPy transfer runtime or extrapolated to LLMs.

Reproduce

Python + NumPy; the full suite currently uses Linux sched_setaffinity. The native study additionally requires its documented compiler/CPU/BLAS setup.

python -m pip install -r requirements.txt
OPENBLAS_NUM_THREADS=1 python check_relative_transfer.py --output fresh_transfer_run
OPENBLAS_NUM_THREADS=1 python check_moe_transfer.py --output fresh_moe_run

Existing output folders are intentionally not overwritten. The large synthetic source and other large codec variants are regenerated deterministically. Only the final large INT4+rank4 layer is bundled. Raw results are in transfer_verified_experiment/results.json and moe_transfer_experiment/results.json.

import numpy as np
from relative_weight_transfer import RelativeLinear

# Find the layer folder in its model's manifest.json.
layer = RelativeLinear("path/to/model/layer-folder")
output = layer(np.zeros((2, layer.shape[0]), dtype=np.float32))

To convert selected matrices from another checkpoint:

python relative_weight_transfer.py checkpoint.safetensors spec.json new_checkpoint

Adapt transfer_spec_example.json to real tensor names and prepare a calibration NPZ containing representative inputs for every selected layer. It does not automatically collect activation hooks or replace Transformers modules.

Comparison with existing work and further development

This package has not been benchmarked against AWQ, GPTQ, QLoRA or LQER on the same trained LLM, hardware and evaluation corpus. It does not establish novelty or superiority over those methods. Group scales, affine rebasing and low-rank error repair are established techniques. Our contribution at this stage is a working, inspectable composition and ablations of these ideas.

Trainable corrections on a frozen quantized base are a proposed development path, with conceptual overlap with QLoRA. They are not implemented as an autograd training adapter in this release. Full QAT, learned quantization steps, fast fused kernels and Transformers integration remain future work.

No trained LLM/MoE checkpoint, GPU benchmark, perplexity evaluation, measured energy advantage or low-bit optimizer result is included. The next decision point is a real small LLM or MoE with untouched evaluation data and matched ordinary INT4 baselines, measuring quality, prefill/decode, throughput and memory.

Attribution and references

Code and research artifacts: MIT. Digits dataset: separate CC BY 4.0 terms and attribution in NOTICE.txt. Original work: E. Alpaydin and C. Kaynak (1998), Optical Recognition of Handwritten Digits, UCI, DOI 10.24432/C50P49. Data changes: pixel normalization by16 and our fixed train/calibration/test split.

• LQER: quantization-error reconstruction.
• LSQ: learned quantization steps.
• QLoRA: fine-tuning adapters on frozen quantized weights.
• QMoE: compression of MoE weights with dedicated execution kernels.

Кратко по-русски

Работающий исследовательский перенос весов в относительное INT4-представление с небольшой поправкой ошибки. Выигрыш в хранении подтверждён. Для маленьких обученных моделей удалось восстановить среднюю точность без дообучения. Универсальный NumPy-runtime пока медленнее FP32. Настоящие LLM и MoE ещё не проверены. MoE совместим на уровне экспертов; текущая проверка синтетическая. Преимущество над существующими методами и новизна не установлены.

Прикладной результат: фильтрация SMS

Добавлен воспроизводимый эксперимент на SMS Spam Collection UCI. Исходный архив содержит 5574 реальных сообщений. После удаления повторов относительно типизированного текста осталось 5145: 3087 для обучения, 1029 для выбора модели и порога, 1029 для оценки. Словарь TF-IDF, IDF и веса обучаются только на обучающей части. Совпадающие нормализованные сообщения не пересекают части. Исследовательские запуски уже использовали этот корпус; это не новый независимый внешний тест и не проверка современной SMS-атаки.

Сравниваются одинаковые веса в FP32, обычном INT4 и относительном INT4. Группа квантования равна 32, поправка rank4 в этом опыте не используется. Порог классификации выбирается отдельно на проверочной части для каждого варианта. Допуски относительно обоих FP32-контролей: accuracy не ниже на 0,5 процентного пункта, macro F1 не ниже на 1 пункт, recall спама не ниже на 2 пункта. Это допуски измеренного качества, не доказанная эквивалентность на всей генеральной совокупности.

Вариант	Accuracy	Macro F1	Recall спама	Рабочие параметры, байт	Умножения с накоплением
FP32 MLP, 4096 → 64 → 1	98,74%	0,96945	91,2%	1 049 284	262 208
Полная линейная FP32, 4096 → 1	99,13%	0,97915	94,4%	16 484	4096
Компактная модель, обычный INT4	99,03%	0,97675	93,6%	420	512
Компактная модель, относительный INT4	99,03%	0,97675	93,6%	420 после той же компиляции	512

Проверочная часть выбрала 512 входных связей. Их индексы используются компилятором текстовых признаков, поэтому исполняемый слой имеет размер 512 × 1 и не хранит индексы связей. Полные результаты сравнений до этой компиляции сохранены в sms_verified_experiment/results.json. Относительный вариант не показал отдельного преимущества над обычным INT4.

На macOS ARM64 время вызова модели с Python составляет около 8 мкс, против 16 мкс у MLP и 11 мкс у полной линейной модели. Рабочих параметров примерно в 39 раз меньше, чем у полной линейной FP32, а умножений в 8 раз меньше. Параметры включают коды, FP32-масштабы, bias и структуру интерфейса. Словарь, IDF, библиотека, Python, входы и временные буферы сюда не входят. Это не измерение полного RSS или энергии.

Полная обработка текста, включая ContextIR и получение признаков, занимает около 45 мкс, против 166 мкс у исходной MLP с sklearn TF-IDF. При одинаковом ускоренном компиляторе признаков полная линейная FP32 занимает около 50 мкс, а MLP около 55 мкс. Поэтому выигрыш относительно более сильного прикладного контроля составляет около 1,12 раза; относительно исходной MLP около 3,7 раза. Средние и все раунды таймеров сохранены рядом с медианами; время зависит от компьютера и нагрузки.

Из ContextIR напрямую используется PrivacyScrubber: номера телефонов и другие распознанные чувствительные фрагменты заменяются типизированными обозначениями. Отрицания и остальной текст сохраняются; семантическое сокращение SMS не выполняется. Контроль без этого маскирования дал accuracy 98,83% и macro F1 0,97170, с ним 99,13% и 0,97915 у полной линейной модели. Это результат одного корпуса, а не универсальная гарантия обнаружения PII.

Из hedgehog использован принцип ограниченных связей на узел. Здесь он реализован как выбор признаков и маскированное дообучение, с контролями 32, 64, 128, 256 и 512 связей на скрытый узел. Исходники, состояния и осцилляторная динамика hedgehog не копируются. Разреженная MLP не стала победителем. Компактный линейный классификатор оказался полезнее на этой задаче.

native_relative_linear.cpp использует packed INT4, SIMD на ARM64 и Accelerate BLAS для FP32-контроля. Полная FP32-матрица квантованного слоя не хранится между вызовами. При одинаковом масштабе входных координат относительное преобразование переносится в scales и bias до выполнения. С произвольными масштабами оно вычисляется явно. Это W4A32, не полностью целочисленное обучение. Плотный INT4 здесь остается медленнее FP32; экономия вычислений возникает благодаря компактной структуре.

Сборка на macOS требует Command Line Tools. На Linux нужен компилятор C++ и CBLAS; Linux-вариант нового ядра в этой работе не проверен.

python -m pip install -r requirements-sms.txt
curl --fail --location --output sms.zip 'https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip'
python -B check_sms_transfer.py --data-zip sms.zip --output fresh_sms_run
python -B check_native_relative.py -q

Для работы из соседнего локального исходника ContextIR вместо установки пакета передайте эксперименту и классификатору --contextir-root /path/to/sir-translater. Версия зависимости закреплена в requirements-sms.txt; контрольная сумма архива и разбиения указаны в результатах. Каталог результатов не перезаписывается.

Для готовой модели соберите библиотеку из текущего исходника:

clang++ -O3 -std=c++17 -dynamiclib native_relative_linear.cpp -framework Accelerate -o /tmp/librelative.dylib
python -B sms_classifier.py --model sms_verified_experiment --library /tmp/librelative.dylib --text 'Free prize! Call now to claim your reward.'

classifier.json хранит словарь, IDF, выбранные признаки и порог без pickle. Ненужные модельные признаки не материализуются, но их вклад в исходную норму TF-IDF учитывается. Совпадение с sklearn проверено на тестовой части. Первая разведочная серия не прошла качество и скорость; ее компактные результаты сохранены в sms_verified_experiment/exploratory_results.json.

Проверка на обученной GPT-2

Полного выигрыша на LLM не получено. На GPT-2 124M обычный INT4 с низкоранговой коррекцией уменьшает рабочие параметры в 2,06 раза, но замедляет полный запрос в 1,60 раза. Относительный INT4 дополнительно ухудшает качество. Результат SMS нельзя переносить на Transformer без проверки.

Вариант	Perplexity	Точность следующего токена	Рабочие параметры, МБ	Полный запрос, мс
FP32, нативный BLAS	52,7676	31,6162%	497,965	309,598
Обычный INT4, group 32, rank 8	55,4053	30,8838%	241,785	494,994
Относительный INT4, group 16, rank 0	66,9163	28,7598%	251,398	571,525

Это рабочие массивы модели, включая embeddings, нормы, FP32-масштабы, коррекцию и структуры нативного интерфейса, а не размер сжатых файлов. В FP32 входные embeddings и выходная матрица используют общую память. В INT4 embeddings остаются FP32, выходная матрица квантуется отдельно. Активации, KV-кэш, токенизатор, временные буферы и общая RSS процесса в этот столбец не входят. Число MAC от INT4 не уменьшается; низкоранговая коррекция добавляет операции.

Заранее заданный допуск: рост perplexity до 5% и снижение точности до 1 процентного пункта. Обычный INT4 проходит его по точечным оценкам, но сохранение качества статистически не подтверждено: парный 95% интервал отношения perplexity равен [1,04175; 1,05845], а разности точности [-1,1597; -0,3052] процентного пункта. Оба интервала пересекают границу допуска. У относительного INT4 perplexity выросла на 26,81%, точность упала на 2,86 процентного пункта. Ни один относительный вариант не прошел validation, поэтому показан лучший по validation NLL неудачный вариант.

Модель: openai-community/gpt2, revision 607a30d783dfa663caf39e06633721c8d4cfcd7e. Данные: WikiText-2 raw, revision b08601e04326c79dfdd32d625aee71d232d685c3. Калибровка: 1024 токена train; выбор параметров: 2048 токенов validation; итог: 8192 токена test из 64 отдельных блоков. Контекст сбрасывается между блоками по 128 предсказываемых токенов, поэтому это не стандартная perplexity WikiText с длинным скользящим контекстом. Проверены точные хеши блоков, разделение частей и предсказания всех тестовых токенов. Отсутствие пересечения с исходным WebText гарантировать нельзя.

Первая серия с rank 0 провалила качество. После нее использованные 64 блока test исключены из подтверждающего запуска. Затем настройки (group, rank) = (32,0), (16,0), (32,8), (32,16) выбраны только по validation; test открыт после сохранения выбора. Отрицательная серия и исключенные блоки сохранены. Коррекция использует существующий формат A/B и детерминированную randomized SVD по калибровочным активациям.

Полный запрос: токенизация 32 входных токенов, prefill, greedy-генерация 16 токенов с KV-кэшем и декодирование текста. Замеры на Apple M1 Pro, macOS ARM64, один поток CPU, 8 запросов, 5 повторов на вариант, случайное чередование после прогрева. Повторная серия подтвердила замедление: ускорение обычного INT4 относительно FP32 0,625 раза, 95% интервал [0,6225; 0,6278]. Transformers FP32 с SDPA занял 451,323 мс, то есть обычный INT4 медленнее и этого контроля. Исходный INT4 был еще медленнее; прямые SIMD-загрузки улучшили ядро, но не изменили итог.

FP32 logits совпадают с Transformers с максимальной ошибкой 0,000168; KV-кэш и greedy-токены совпадают. INT4 сохраняется упакованным между вызовами. Prefill декодирует временную плитку не более 32 входных каналов и вызывает GEMM; decode использует NEON и GEMV для коррекции. Измерения показывают, что текущие расходы декодирования INT4 и prefill перекрывают экономию памяти. Это отрицательный результат текущего W4A32-исполнителя на этом устройстве, а не доказательство невозможности эффективного INT4 на другом ядре или железе.

Результаты находятся в llm_verified_experiment: протокол, выбранные настройки, ошибки по токенам, исходные замеры, два повторных замера с Transformers и независимая финальная проверка. Внешние обученные веса и исходные тексты не включены в репозиторий.

Воспроизведение на macOS, с двумя отдельными окружениями:

python3.14 -m venv /tmp/gpt2-quality-env
/tmp/gpt2-quality-env/bin/pip install -r requirements-llm.txt
/tmp/gpt2-quality-env/bin/hf download openai-community/gpt2 config.json tokenizer.json tokenizer_config.json model.safetensors --revision 607a30d783dfa663caf39e06633721c8d4cfcd7e --local-dir /tmp/gpt2-source
/tmp/gpt2-quality-env/bin/hf download Salesforce/wikitext wikitext-2-raw-v1/train-00000-of-00001.parquet wikitext-2-raw-v1/validation-00000-of-00001.parquet wikitext-2-raw-v1/test-00000-of-00001.parquet --type dataset --revision b08601e04326c79dfdd32d625aee71d232d685c3 --local-dir /tmp/wikitext-source
clang++ -O3 -std=c++17 -dynamiclib native_relative_linear.cpp -framework Accelerate -o /tmp/librelative-gpt2.dylib
VECLIB_MAXIMUM_THREADS=1 OPENBLAS_NUM_THREADS=1 /tmp/gpt2-quality-env/bin/python -B check_gpt2_transfer.py --source /tmp/gpt2-source --dataset /tmp/wikitext-source --work /tmp/gpt2-work --library /tmp/librelative-gpt2.dylib --output /tmp/gpt2-results --exclude-test-blocks llm_verified_experiment/excluded_exploratory_test_blocks.json
python3.13 -m venv /tmp/gpt2-reference-env
/tmp/gpt2-reference-env/bin/pip install -r requirements-llm-reference.txt
VECLIB_MAXIMUM_THREADS=1 OPENBLAS_NUM_THREADS=1 /tmp/gpt2-reference-env/bin/python -B check_gpt2_transfer.py --source /tmp/gpt2-source --dataset /tmp/wikitext-source --work /tmp/gpt2-work --library /tmp/librelative-gpt2.dylib --output /tmp/gpt2-results --latency-only
VECLIB_MAXIMUM_THREADS=1 /tmp/gpt2-reference-env/bin/python -B check_gpt2_reference.py --source /tmp/gpt2-source --model /tmp/gpt2-work/fp32 --library /tmp/librelative-gpt2.dylib --output /tmp/gpt2-reference.json

Каталоги результатов должны быть новыми. Для нового исследования используйте пустой рабочий каталог, чтобы не переиспользовать чужие преобразованные модели. Версии обоих измеренных окружений записаны в результатах. На Linux и GPU этот LLM-путь не проверялся. Ни один вариант не прошел одновременно проверку качества, уменьшения рабочих весов и ускорения полного запроса.

Новое исполнение GPT-2: подтвержденный выигрыш W8A8

Повторная серия выявила проблему сильного масштабирования по std и расходов W4A32. Отказ от центра почти не помог качеству. Более мягкие относительные единицы, INT8 и пакетное ARM dotprod ядро дали реальный выигрыш без обучения:

Вариант	Perplexity	Рабочие веса, МБ	Полный запрос, мс
FP32	50,4113	497,965	307,619
Обычный INT4, rank 16	52,6058	170,942	485,703
Относительный INT4, rank 16, W4A8	56,4005	171,464	329,201
Относительный INT8, group 128, W8A8	50,3952	208,946	164,454

Выбранный INT8 уменьшил рабочие веса в 2,38 раза и ускорил полный запрос в 1,87 раза, 95% интервал [1,8555; 1,8767]. Сохранение качества прошло допуск: 95% интервал отношения perplexity [0,997867; 1,001607], разности точности [-0,1831; 0,2014] процентного пункта. Это 16384 новых тестовых токена; все 128 ранее использованных блоков исключены. Настройки выбраны до test. Измерение: Apple M1 Pro, один поток CPU, 32 входных и 16 новых токенов, 8 запросов, по 5 повторов, случайное чередование после прогрева.

Число линейных MAC не уменьшилось. Экономятся байты рабочих весов и время исполнения благодаря INT8 и повторному использованию загрузок. Выигрыш получен преимущественно в decode; ускорение длинного prefill и холодного чтения с диска не подтверждено. Текущая серия не заявляет новую архитектуру или возможность без обучения превратить dense GPT-2 в эффективную MoE.

Конвертер поддерживает mode: int8, reference_center: false и reference_power: 0.5. NativeNetwork принимает activation_int8=True для W4A8; INT8 всегда исполняется как W8A8. GPT-2 CLI имеет --activation-int8. Сборка без ARM dotprod явно отклоняет эти режимы. Старые опубликованные результаты сохранены; новый эксперимент находится в gpt2_decomposition_experiment. Там приведены диагностика, ограничения, исследования LoRA/MoE/соседних проектов, проверка низкоранговой замены FFN и команды воспроизведения.