Термодинамический мозг: альтернатива backpropagation для обучения нейросетей на Arduino

Backpropagation на Arduino? Это шутка

Представь: пытаешься запустить градиентный спуск на микроконтроллере с 2 КБ оперативки. Backpropagation жрет память, требует матричных операций и оверхеда, который просто не влезает в железо стоимостью как чашка кофе. Стандартный подход - это попытка впихнуть слона в спичечный коробок. И все это ради того, чтобы нейросеть на краю сети (edge AI) могла хоть чему-то научиться без облака.

Термодинамический мозг - физика вместо математики

Забудь про градиенты. Забудь про цепочки правил. Термодинамический мозг - это не алгоритм, а физический процесс. Сеть организуется как газ или жидкость, стремясь к состоянию с минимальной "энергией". Нейроны - это частицы, связи - это силы притяжения и отталкивания. Обучение происходит не через обратное распространение ошибки, а через локальные взаимодействия между соседями в графе.

Почему это работает на Arduino? Потому что каждое правило локально. Нейрон смотрит только на своих непосредственных соседей. Ему не нужно знать всю сеть. Это значит - нет глобальных вычислений, нет хранения градиентов для всех слоев. Память O(1). Да, константная.

Самоорганизующийся граф - как он устроен

Представь паутину, которая меняет свою прочность в зависимости от того, как часто по ней ходят. Сильные связи усиливаются, слабые - ослабевают и рвутся. Новые связи образуются между активными нейронами. Это и есть наш граф.

• Нейроны - узлы с состоянием (активность от 0 до 255, целочисленно)
• Связи - ребра с весом (также 0-255) и "температурой" стабильности
• Правило Гиббса: вероятность усиления связи = exp(-ΔE / T), где ΔE - изменение "энергии" системы, T - "температура" обучения
• Локальное обновление: каждый нейрон пересчитывает только связи с непосредственными соседями

Это радикально отличается от backpropagation, где ошибка должна пройти через всю сеть. Здесь все происходит в окрестности одного-двух шагов. Если ты смотрел нашу статью про архитектуру «Обратного Хэша», то понимаешь - на микроконтроллерах нужно избегать умножений. В термодинамическом мозге умножения заменяются на сравнения и битовые сдвиги.

Фаза сна и митоз - где нейросеть действительно "живет"

Самое интересное начинается, когда сеть не обрабатывает данные. В фазе сна (это не метафора, а отдельный режим работы) граф перестраивается:

1. Консолидация знаний: слабые связи удаляются, сильные - укрепляются
2. Митоз нейронов: если нейрон постоянно активируется в разных контекстах, он "делится" - создает копию себя с похожими связями
3. Терморегуляция: "температура" системы снижается, делая сеть более стабильной

Это похоже на то, как работает человеческий мозг во сне. И да, это можно реализовать на Arduino. Просто переводишь контроллер в режим пониженного энергопотребления, а сеть в фоновом режиме перестраивает связи. Просыпается - уже умнее.

1 Подготовка железа и среды

Берем Arduino Nano ESP32 (актуально на 2026) - у него есть Wi-Fi, Bluetooth LE и достаточно памяти. Установи последнюю версию Arduino IDE 3.0+ или PlatformIO. Важно: отключи все лишние библиотеки, они съедают память.

// platformio.ini
[env:nano_esp32]
platform = espressif32
board = nano_esp32
framework = arduino
monitor_speed = 115200
lib_deps = 

Да, список библиотек пустой. Мы напишем все с нуля.

2 Структура нейрона и графа

Используем минимальные структуры данных. Каждый байт на счету.

struct Neuron {
  uint8_t activity;      // текущая активность 0-255
  uint8_t potential;     // потенциал для митоза 0-255
  uint8_t connections[6]; // индексы связанных нейронов (максимум 6)
  uint8_t weights[6];    // вес каждой связи 0-255
  uint8_t temp;          // "температура" нейрона
};

#define MAX_NEURONS 64
Neuron brain[MAX_NEURONS];
uint8_t neuron_count = 10; // начинаем с 10 нейронов

Почему 6 связей? Эмпирически - больше не влезает в память, а меньше - слишком мало для самоорганизации. Это компромисс.

3 Правило обучения без умножений

Вместо точных вычислений exp() используем lookup-таблицу и битовые операции. На Arduino нет FPU.

// Таблица "вероятностей" для правила Гиббса
// exp(-delta/16) * 255, предвычислено
const uint8_t gibbs_table[32] = {
  255, 240, 226, 213, 200, 188, 177, 166,
  156, 147, 138, 130, 122, 115, 108, 101,
  95, 89, 84, 79, 74, 70, 66, 62,
  58, 55, 51, 48, 45, 42, 40, 37
};

void update_connection(uint8_t neuron_idx, uint8_t conn_idx) {
  Neuron& n = brain[neuron_idx];
  Neuron& other = brain[n.connections[conn_idx]];
  
  // "Энергия" связи - разница активностей
  int16_t delta = abs(n.activity - other.activity);
  delta = min(delta, 31); // ограничиваем для таблицы
  
  // Вероятность усиления связи
  uint8_t prob = gibbs_table[delta];
  
  // Случайное решение (псевдослучайное, но для Arduino сойдет)
  if (random(256) < prob) {
    // Усиливаем связь
    if (n.weights[conn_idx] < 250) n.weights[conn_idx] += 6;
  } else {
    // Ослабляем
    if (n.weights[conn_idx] > 5) n.weights[conn_idx] -= 5;
  }
}

Обрати внимание: нет ни одного умножения с плавающей точкой. Только целочисленные операции. Это критично для скорости.

4 Митоз нейронов - как сеть растет

Когда нейрон слишком часто активируется, он "перегревается" и делится. Это аналог создания новых признаков в глубоком обучении.

void maybe_mitosis(uint8_t neuron_idx) {
  Neuron& n = brain[neuron_idx];
  
  // Накопленный потенциал
  n.potential += (n.activity > 200) ? 3 : 0;
  
  if (n.potential > 250 && neuron_count < MAX_NEURONS) {
    // Делимся!
    Neuron& new_neuron = brain[neuron_count];
    new_neuron.activity = n.activity;
    new_neuron.potential = 0;
    new_neuron.temp = n.temp;
    
    // Копируем часть связей
    for (uint8_t i = 0; i < 3; i++) {
      new_neuron.connections[i] = n.connections[i];
      new_neuron.weights[i] = n.weights[i] / 2;
      n.weights[i] = n.weights[i] / 2; // оригинал тоже ослабляется
    }
    
    // Связываем новый нейрон с оригиналом
    new_neuron.connections[3] = neuron_idx;
    new_neuron.weights[3] = 128; // средняя связь
    
    neuron_count++;
    n.potential = 0;
  }
}

Митоз - это то, чего нет в backpropagation. Сеть буквально растет, когда ей нужно больше вычислительных ресурсов для задачи. После прочтения статьи про Continual Learning на микронейросетях, ты понимаешь - без роста нейронов continual learning невозможен.

5 Фаза сна - консолидация знаний

Когда Arduino не обрабатывает данные (ждущий режим между измерениями датчиков), запускаем фазу сна.

void sleep_phase() {
  // Понижаем "температуру" - сеть становится более стабильной
  for (uint8_t i = 0; i < neuron_count; i++) {
    if (brain[i].temp > 1) brain[i].temp--;
  }
  
  // Удаляем слабые связи (вес < 10)
  for (uint8_t i = 0; i < neuron_count; i++) {
    for (uint8_t j = 0; j < 6; j++) {
      if (brain[i].weights[j] < 10) {
        brain[i].weights[j] = 0;
        brain[i].connections[j] = 255; // нет связи
      }
    }
  }
  
  // Консолидация: сильные связи становятся еще сильнее
  for (uint8_t i = 0; i < neuron_count; i++) {
    for (uint8_t j = 0; j < 6; j++) {
      if (brain[i].weights[j] > 200) {
        brain[i].weights[j] = 255; // максимальный вес
      }
    }
  }
}

Этот код можно запускать в прерывании таймера или в loop(), когда нет новых данных. Сеть "спит" и становится умнее без дополнительных входных данных.

Где это взорвется: подводные камни и ошибки

Я видел, как люди пытаются внедрить термодинамический мозг и терпят неудачу. Вот почему:

Самая частая ошибка - пытаться скопировать формулы из научных статей один в один. На Arduino нет экспоненты. Нет нормального генератора случайных чисел. Нужно адаптировать. Как в статье про нейро-алгебраическое ядро - все упрощаем до битовых операций.

Практический пример: классификация простых жестов с акселерометра

Допустим, у тебя есть MPU6050 на Arduino. Нужно различать "взмах вверх", "взмах вниз", "покой". Backpropagation потребовал бы тысячи примеров и минут обучения. Термодинамический мозг справляется за десятки итераций.

// Упрощенный процесс
void setup() {
  // Инициализация датчика
  // Создание начального графа с 10 нейронами
}

void loop() {
  // Чтение акселерометра
  int x = read_accel_x();
  
  // Активация входных нейронов (первые 3)
  brain[0].activity = map(abs(x), 0, 16384, 0, 255);
  
  // Распространение активности
  propagate_activity();
  
  // Обновление связей (обучение)
  for (uint8_t i = 0; i < neuron_count; i++) {
    for (uint8_t j = 0; j < 6; j++) {
      if (brain[i].connections[j] != 255) {
        update_connection(i, j);
      }
    }
  }
  
  // Чтение выходных нейронов (последние 3)
  uint8_t gesture_up = brain[neuron_count-3].activity;
  uint8_t gesture_down = brain[neuron_count-2].activity;
  uint8_t gesture_rest = brain[neuron_count-1].activity;
  
  // Каждые 100 итераций - фаза сна
  static uint16_t iter = 0;
  if (iter++ % 100 == 0) sleep_phase();
  
  delay(10); // 100 Гц частота обновления
}

Через минуту работы сеть начнет различать жесты. Без обратного распространения ошибки. Без labeled датасета. Просто через самоорганизацию. Это ближе к тому, как учатся животные, а не как учатся алгоритмы.

Почему это не заменит GPT-7, но изменит edge AI

Термодинамический мозг на Arduino не напишет поэзию. Не решит дифференциальные уравнения. Его предел - простые классификации, аномальное обнаружение, базовое управление. Но именно это нужно на краю сети.

Пока крупные модели в облаке потребляют мегаватты, твой Arduino с термодинамическим мозгом будет годами работать от батарейки AAA. И обучаться прямо на устройстве. Без облака. Без обратной связи. Это как edge-прогноз погоды, но еще более минималистичный.

Если ты экспериментировал с альтернативами backpropagation, то термодинамический мозг - следующий логичный шаг. Еще более радикальный. Еще более эффективный по ресурсам.

Последний совет: начни с малого. 10 нейронов. Простая задача. Пойми, как граф самоорганизуется. Потом увеличивай масштаб. И не бойся, когда сеть начнет вести себя нестабильно - это часть процесса. Иногда нужно дать ей "поспать".

Подписаться на канал