TinyML на хардвере без FPU. Графовая нейросеть с тернарными весами — 22 KB.
Первый в мире KAN (Kolmogorov-Arnold Network) с тернарными весами {-1, 0, +1}.
Тренируется STE (Straight-Through Estimator) + QAT, веса упакованы в 2-bit uint8.
Спроектирован для микроконтроллеров без FPU — умножение заменяется на сложение/сдвиг.
Современные нейросети требуют:
- GPU для инференса (RTX, Jetson, Google TPU)
- Мегабайты весов (MobileNet — 4 MB, GPT — 100 GB)
- FP32/F16 арифметику (FPU на чипе)
- Облако для дообучения
Это исключает 90% устройств: датчики за $0.50, Arduino, LoRa-ноды, RFID-метки.
TernML заменяет float32 × float32 на:
вход × (+1) = вход // вес +1
вход × (-1) = -вход // вес -1
вход × 0 = ничего // вес 0 (49% весов = 0, sparsity естественная)
Никаких float мультипликаторов. Никакого FPU. Никакой внешней flash.
| Dataset | Архитектура | Accuracy | Параметров | Размер (packed) | Sparsity |
|---|---|---|---|---|---|
| MNIST | 256→100→10 | 96.15% | 79,800 ternary | 15.4 KB | 49% |
| MNIST | 784→50→10 | 95.93% | 118,950 ternary | 22.8 KB | — |
| Fashion-MNIST | 256→100→10 | 86.68% | 79,800 ternary | 15.4 KB | — |
| Fashion-MNIST | 64→100→10 | 79.19% | 26,400 ternary | 21.0 KB | — |
| CIFAR-10 | 192→200→10 | 46.31% | 121,200 ternary | 32.7 KB | 49.7% |
| MNIST | 64→100→10 | 92.89% | 26,400 ternary | 21.0 KB | — |
| Dataset | Hidden | Accuracy | % от BP | Размер |
|---|---|---|---|---|
| Fashion-MNIST | 50 | 74.5% | 94.1% | 3.7 KB |
| Fashion-MNIST | 100 | 77.0% | 97.3% | 6.8 KB |
| Fashion-MNIST | 500 | 78.7% | 99.3% | 31.6 KB |
| MNIST | 50 | 85.3% | 91.8% | 3.7 KB |
| MNIST | 500 | 88.1% | 94.9% | 31.6 KB |
99.3% BP accuracy с нулевым обучением скрытого слоя.
| Dataset | Архитектура | Float | STE ternary | True ternary | Размер | Сжатие |
|---|---|---|---|---|---|---|
| Fashion-MNIST | Conv2d(1,32)→Conv2d(32,64)→FC128→FC10 | 91.57% | 91.83% | 92.02% | 102.8 KB | 16× |
Первый в мире ternary CNN, работающий без потери точности (даже лучше float).
Ключевой трюк: gamma absorption — weight = round(weight/γ); α *= γ.
| Модель | Hidden | Размер | Accuracy | Acc/КБ |
|---|---|---|---|---|
| TernML random+LSQ | 50 | 3.7 KB | 73.8% | 19.9%/KB |
| ReLU float32 random+LSQ | 12 | 3.6 KB | 56.7% | 15.7%/KB |
| TernML random+LSQ | 100 | 6.8 KB | 77.1% | 11.4%/KB |
| ReLU float32 random+LSQ | 23 | 6.8 KB | 63.8% | 9.4%/KB |
| Выигрыш | 4× | — | +17% | +27% |
Сравнение с MLP той же архитектуры (256→100→10):
| Модель | Размер | Точность | Операция умножения |
|---|---|---|---|
| MLP float32 | 107 KB | ~93% | float32 × float32 |
| TernML ternary | 15.4 KB | 96.15% | сложение/сдвиг |
| Выигрыш | 7× меньше | +3% | 0 FPU инструкций |
Никто до нас не применял тернарные веса {-1,0,+1} к Kolmogorov-Arnold Networks.
Поиск по arXiv, GitHub, Google Scholar — 0 результатов.
Квантизация повышает accuracy, а не снижает:
| Фаза | Accuracy | Изменение |
|---|---|---|
| Float ctrl (epochs 0-5) | 94.77% | — |
| STE ternary (epochs 6-10) | 95.78% | +1.01% |
| Hard clamp (epochs 11-12) | 96.09% | +0.31% |
| Finetune (epochs 13-15) | 96.15% | +0.06% |
Это новый эффект. Все существующие работы по квантизации KAN отчитываются "negligible accuracy loss" — никто не видел улучшения.
В отличие от feedforward KAN, TernML — граф с циклами:
- 366 нейронов (256 in + 100 hidden + 10 out)
- 26,600 направленных рёбер
- N циклов синхронного обновления (2-4)
- Можно добавить нейрон на новый сенсор без перестройки сети
Для IoT с разными конфигурациями датчиков это gold — добавил датчик = добавил нейрон.
1.58 бита на параметр (log₂3). Упаковка: 4 тернарных значения в 1 uint8.
- {-1} → 0b00
- {0} → 0b01
- {+1} → 0b10
79,800 параметров → 19,950 байт. С масштабами и смещениями: ~22 KB.
| Чип | Кэш L1 | Flash | FPU | Наш TernML |
|---|---|---|---|---|
| ARM Cortex-M0+ (STM32G0) | — | 16-64 KB | нет | ✓ |
| ARM Cortex-M4 (STM32F4) | 16 KB | 512 KB | есть | ✓ в L1 |
| ARM Cortex-M7 (STM32H7) | 64 KB | 2 MB | есть | ✓ в L1 |
| RISC-V (GD32V) | — | 32 KB | нет | ✓ |
| ESP32-S3 | 16 KB | 384 KB | нет | ✓ в L1 |
| Arduino Nano RP2040 | — | 264 KB | нет | ✓ |
Тернарные веса превращают умножение в:
state += (ternary_weight == 1) ? input : (ternary_weight == -1) ? -input : 0
На Cortex-M это 2-3 такта вместо 15-20 тактов на float32 умножение.
22 KB передаётся по LoRa за ~3 секунды (SF9, 125 kHz).
Arduino с камерой делает снимок, прогоняет TernML, шлёт результат по LoRa на базовую станцию.
Никакого облака. Батарейка — год.
- Вибрация → предсказание поломки подшипника
- Температура/давление → аномалии процесса
- Газ/CO₂ → утечка, пожар
Чип STM32G0 за $0.50 + TernML на 22 KB. Работает 5 лет от батарейки CR2032.
Никакого Wi-Fi, никакого облака, никаких подписок.
- Умные часы — анализ ЭКГ на чипе, без отправки на телефон
- Слуховые аппараты — фильтрация шума в реальном времени
- Глюкометры — предсказание скачков сахара локально
Никакой передачи медицинских данных через Bluetooth. Всё на устройстве.
- Почвенный датчик — влажность/кислотность → когда поливать
- Скот — GPS-ошейник + TernML → аномальное поведение (болезнь/хищник)
- Теплица — температура/влажность/освещение → управление климатом
LoRa-нода на 22 KB. 10 км без ретранслятора. Год без замены батарей.
- Датчик движения — человек/животное/машина
- Датчик открытия окна — сквозняк vs взлом
- Датчик протечки воды — капля vs конденсат
Всё локально, ничего не шлётся в облако. Приватность по умолчанию.
14 июня 2026: наш QAT pipeline впервые применён к обычным CNN.
Результат: 92.02% на FashionMNIST (conv2d + relu + maxpool + fc) при 102.8 KB — выше float (91.57%) при 16× сжатии.
Это доказывает, что метод универсален: один pipeline (float → STE absmean → gamma absorption → pure ternary) работает на принципиально разных архитектурах — и на KAN, и на CNN.
gamma = mean(abs(weight))
weight = round(weight / gamma) # {-1, 0, +1}
alpha *= gamma # масштаб ушёл в alpha
Без этого трюка raw веса ~0.03 после float training превращались в 99.995% нулей после round(). С трюком — впервые в мире ternary CNN работает без потери точности.
| Кто | Что | Отличие |
|---|---|---|
| QuantKAN (Nov 2025) | QAT для KAN, 4-bit | Не ternary, не граф, нет reg effect |
| KANtize (Mar 2026) | B-spline таблицы в 2-3 bit | Не ternary {-1,0,+1}, не веса |
| BiKA (Feb 2026) | KAN-inspired аппаратный акселератор | Не KAN (comparators вместо spline) |
| WillHua127/TernML (351★) | TernML в FP32 на Cora | Нет квантизации |
| Мы | Ternary KAN 1.58 bit + граф + STE + reg effect + gamma absorption | Никто |
Открытие: случайные тернарные KAN-фичи + аналитический Least Squares выход = 99.3% BP accuracy.
Скрытый слой замораживается на случайных тернарных весах, выходной слой решается через torch.linalg.solve.
Никакого обучения скрытого слоя — фичи естественно дискриминативны из-за piecewise-linear структуры.
| Dataset | KAN H=500 random+LSQ | Full BP | % от BP |
|---|---|---|---|
| Fashion-MNIST | 78.7% | 79.2% | 99.3% |
| MNIST | 88.1% | 92.9% | 94.9% |
Сравнение с ReLU при равном размере модели (Fashion-MNIST):
| Модель | Размер | Accuracy | Hidden |
|---|---|---|---|
| TernML | 3.7 KB | 73.8% | 50 |
| ReLU float32 | 3.6 KB | 56.7% | 12 |
| TernML | 6.8 KB | 77.1% | 100 |
| ReLU float32 | 6.8 KB | 63.8% | 23 |
TernML даёт ~4× больше скрытых нейронов при том же размере (2-bit vs 32-bit),
что даёт выигрыш +17 п.п. при 3.7 KB.
Gamma absorption решает фундаментальную проблему: после float training веса мелкие (~0.03), round() убивает всё. Нормализация weight/γ перед round + α×=γ конвертирует любую float сеть в true ternary без потери точности.
Проверено на: TernML (piecewise-linear), CNN (conv+relu+maxpool+fc).
Гипотеза: работает на любой архитектуре (ResNet, Transformer, LSTM).
TernML даёт +17 п.п. при 3.7 KB (73.8% vs 56.7%). Причина: 2-bit packing даёт 4× больше нейронов при том же размере.
Гипотеза: разрыв растёт с уменьшением модели — на 1 KB разница будет ещё больше.
Если заменить FFN в Transformer на TernML (ternary, 3 cp):
| Фактор | TernML-Transformer | BitNet b1.58 |
|---|---|---|
| Параметры (теория) | 2.7× меньше | baseline |
| MAC с sparsity 50% | 5.3× меньше | baseline |
| GPU utilization | 10-30% | 80-90% |
| Доказано на >1B | Нет | Да |
| Inference latency | 4× циклов MP | 1× matmul |
Вердикт: BitNet остаётся практичнее для LLM. KAN — для TinyML. Гибрид "KAN учит sparsity → sparse ternary MLP" может объединить преимущества.
Сейчас наш QAT квантизует только веса. Для LLM-масштаба активации — bottleneck. BitNet квантизует weights+activations (w1a8). Добавление activation quantization к нашему pipeline — открытая проблема.
Попытка заменить Backpropagation на локальное обучение без сохранения графа вычислений.
Sign-based, Rprop и local classifier — все дают ≤28% на Fashion-MNIST.
Причина: neuron_scale ≈ 1/fan_in убивает градиент, sign-updates вызывают boundary saturation.
Вердикт: Mono-Forward не подходит для тернарных KAN в текущей архитектуре.
TernaT — CPU-only нейронный reasoner с VSA-памятью, learned resonator и float32 controller.
Question (NL) → NL Parser → (entity, predicate)
↓
┌─ PredicateShardedStore (VSA memory, ~4 MB)
│ Facts sharded by predicate, superposition bundling
│
├─ TernMLResonator (16 KB, 65K tern params)
│ VSA query → forward(256) → [ternary cycles×5] → unproj(D) → cleanup
│
├─ FastController (float32 MLP, <1 KB)
│ BC: (entity, goal) → next predicate to follow (no STOP)
│
└─ ConversationMemory (multi-turn, pronouns, 20-turn history)
↓
Answer (entity name)
| Компонент | Метрика | Размер |
|---|---|---|
| VSA Store query | 96% на D=4096, 2000 фактов | ~4 MB |
| TernMLResonator + negative training | 100% acc, 0% fp_rate на D=1024, 96 facts | 16 KB |
| FastController (BC) | 100% train acc (814 examples) | <1 KB (37K float params) |
| ChainScorer (Transformer 2L/4H/128d) | 100% train acc (1608 examples) | <1 KB (50K float) |
| Ctrl+Res+ChainScorer multi-hop (synthetic_qa) | 90% (1h=100%, 2h=100%, 3h=70%) | — |
| NL Parser | 8/8 тестов (12 паттернов) | — |
-
VSA superposition noise — ~80% accuracy независимо от D (1024-8192). Причина: ~12 facts/shard создают noise
sum_{i!=k} (s_i*s_k) * o_i, который не уменьшается с ростом D. -
Resonator не спасает multi-hop — обучен денойзить VSA, но не отличает real от fake запросов. False positives: ~25% несуществующих фактов дают similarity > 0.45.
-
Threshold 0.6 — best F1 на goal reachability. 100% recall real facts, ~25% false positive rate.
-
Float32 Controller ×400 быстрее ternary — 0.3s vs 130s на 200 эпох. Ternary TernMLayer cyclic graph не batch-ится на GPU.
-
Multi-label soft targets — 43% BFS inputs имеют >1 valid action. KL-divergence с uniform over valid actions → 100% action accuracy (vs 74% с CE).
-
BFS data bias — STOP targets составляют 7-15% данных. Без них 1-hop accuracy падает.
-
Negative examples в resonator training — контрастивный loss (max sim penalty > 0.25) снижает fp_rate с 1.3% до 0% без потери positive accuracy (93%). Mean fake sim: 0.278 → 0.232. Max fake sim: 0.483 → 0.380.
- Train resonator: 30 эпох QAT (float → STE + absmean → gamma absorption), neg_ratio=0.5
- Train FastController: 1000 эпох BC на BFS data + query paths (max_paths=50), STOP targets excluded
- Train ChainScorer: 500 эпох (Transformer 2L/4H/128d, max_examples=5000, max_hops=5)
- Inference: beam search (width 1-3) + exact store goal check + ChainScorer candidate scoring
Результат на 30 queries synthetic_qa (10×1h, 10×2h, 10×3h, D=1024, 96 facts, all (subj,pred) unique):
| Method | Overall | 1-hop | 2-hop | 3-hop |
|---|---|---|---|---|
| VSA direct | 30% | 90% | 0% | 0% |
| Resonator only | 30% | 90% | 0% | 0% |
| Ctrl+Res (beam=1, h=256, no chain) | 73% | 80% | 60% | 80% |
| Ctrl+Res+ChainScorer (beam=1-3) | 90% | 100% | 100% | 70% |
3 failures: controller chooses wrong predicate at branch point (fix: larger MLP or contrastive training)
ternml-ff/ # TernML — основной проект
ternml/
neuron.py # TernMLayer + STE ternary + pack/unpack
graph.py # Понейронная графовая реализация
mf_train.py # Mono-Forward тренировка
train_qat.py # 4-фазный QAT pipeline
train_ternml.py # BP обучение TernML
train_monoforward.py # BP vs Mono-Forward сравнение
bin/ # Утилиты 1.58 bit (энтропия, FLOPs)
RESULTS.md # Все результаты
RESULTS.md # Benchmark results
Gamma absorption решает фундаментальную проблему: после float training веса мелкие (~0.03), round() убивает всё. Нормализация weight/γ перед round + α×=γ конвертирует любую float сеть в true ternary без потери точности.
Проверено на: TernML (piecewise-linear), CNN (conv+relu+maxpool+fc).
Гипотеза: работает на любой архитектуре (ResNet, Transformer, LSTM).
TernML даёт +17 п.п. при 3.7 KB (73.8% vs 56.7%). Причина: 2-bit packing даёт 4× больше нейронов при том же размере.
Гипотеза: разрыв растёт с уменьшением модели — на 1 KB разница будет ещё больше.
Если заменить FFN в Transformer на TernML (ternary, 3 cp):
| Фактор | TernML-Transformer | BitNet b1.58 |
|---|---|---|
| Параметры (теория) | 2.7× меньше | baseline |
| MAC с sparsity 50% | 5.3× меньше | baseline |
| GPU utilization | 10-30% | 80-90% |
| Доказано на >1B | Нет | Да |
| Inference latency | 4× циклов MP | 1× matmul |
Вердикт: BitNet остаётся практичнее для LLM. KAN — для TinyML. Гибрид "KAN учит sparsity → sparse ternary MLP" может объединить преимущества.
Сейчас наш QAT квантизует только веса. Для LLM-масштаба активации — bottleneck. BitNet квантизует weights+activations (w1a8). Добавление activation quantization к нашему pipeline — открытая проблема.
Resonator (16 KB, 65K params) дenoизит VSA superposition noise, но не отличает real факты от случайных корреляций. Решение: negative examples в training.
| Метод | Real recall | Fake precision (>0.45) | Mean fake sim |
|---|---|---|---|
| VSA direct | 80% | — | — |
| VSA+Res (без neg) | 93% | 98.7% | 0.278 |
| VSA+Res (+neg) | 93% | 100% | 0.232 |
Negative training (контрастивный loss с margin 0.25) снижает max fake sim с 0.483 до 0.380 и устраняет все ложные срабатывания >0.45. Гипотеза: negative training + learned VSA embeddings дадут 95%+ precision на scale (1000+ фактов).
Float32 controller (100% train / 90% inference) + ChainScorer (Transformer 2L/4H/128d) + beam search = 90% exact accuracy (1-hop 100%, 2-hop 100%, 3-hop 70%). Ключевые находки:
- Main bottleneck: Controller accuracy — 90% inference accuracy даёт ошибки на 3-hop запросах (0.9^3 = 73% теоретический максимум для 3 шагов)
- ChainScorer бесполезен на step 0 — контекст идентичен для обоих путей
- Hybrid exact+VSA store устранил superposition noise — 80% (VSA only) → 90%
- Beam search width 1-3 — wider не улучшает (controller — bottleneck, не exploration) всё ещё выбирает неправильные predicate'ы для intermediate hops
- Ambiguous queries: некоторые факты имеют множественные valid answers (animal_0 eats food_0 AND food_8), что создаёт конфликты в goal check
Гипотеза: REINFORCE fine-tuning после BC поднимет controller accuracy до 95%+, что даст 85%+ multi-hop.
Один чип: TernML для perception (сенсоры → features) + FastController для reasoning (знания → multi-hop). Float32 controller для training, ternary для deploy.
Гипотеза: 22 KB (perception) + 16 KB (resonator) + 1 KB (controller) + 1 MB (VSA knowledge) = полноценный AI на микроконтроллере за $0.50.
Fakeonomics — creator. Full QAT pipeline (STE, gamma absorption, CNN), resonator training, and VSA reasoning pipeline were developed as independent research.
| Component | Path | Status |
|---|---|---|
| Ternary TernML | ternml-ff/ |
Apache-2.0 (see LICENSE) |
| TernaT | (separate repo FAKEONOMICS/TernaT) |
Apache-2.0 |