Нейроморфные вычисления имитируют работу мозга — с использованием спайков (импульсов) вместо чисел. Мы создадим сеть из 8 нейронов, соединенных через синапсы с изменяемым весом.

Реализация спайковой нейронной сети:

cpp

#include <avr/io.h>
#include <avr/interrupt.h>

#define NEURON_COUNT 8
#define SYNAPSE_DELAY 5  // Задержка распространения спайка

// Нейрон
struct Neuron {
    int16_t potential;       // Мембранный потенциал
    uint8_t threshold;       // Порог возбуждения (обычно 100)
    uint8_t refractory;      // Рефрактерный период (счетчик)
    uint8_t fired;           // Флаг срабатывания
};

// Синапс
struct Synapse {
    uint8_t source;          // Нейрон-источник
    uint8_t target;          // Нейрон-цель
    int8_t weight;           // Вес (-128..127)
};

Neuron neurons[NEURON_COUNT];
Synapse synapses[NEURON_COUNT * NEURON_COUNT];
uint8_t synapseCount = 0;

// Инициализация нейронной сети
void initNetwork() {
    for (uint8_t i = 0; i < NEURON_COUNT; i++) {
        neurons[i].potential = 0;
        neurons[i].threshold = 100;
        neurons[i].refractory = 0;
        neurons[i].fired = 0;
    }
}

// Добавление синапса
void addSynapse(uint8_t source, uint8_t target, int8_t weight) {
    synapses[synapseCount].source = source;
    synapses[synapseCount].target = target;
    synapses[synapseCount].weight = weight;
    synapseCount++;
}

// Спайк-зависимая пластичность (STDP)
void stdpLearning(uint8_t source, uint8_t target, uint32_t timeDiff) {
    // Находим синапс
    for (uint8_t i = 0; i < synapseCount; i++) {
        if (synapses[i].source == source && synapses[i].target == target) {
            // Если спайк пришел до возбуждения - усиливаем
            if (timeDiff < 1000) {
                if (synapses[i].weight < 127) synapses[i].weight++;
            } else {
                // Если после - ослабляем
                if (synapses[i].weight > -128) synapses[i].weight--;
            }
            break;
        }
    }
}

// Обработка спайка
void processSpike(uint8_t neuronIdx, uint32_t currentTime) {
    // Отправляем спайк всем связанным нейронам
    for (uint8_t i = 0; i < synapseCount; i++) {
        if (synapses[i].source == neuronIdx) {
            uint8_t target = synapses[i].target;
            
            // Добавляем к потенциалу целевого нейрона (с учетом веса)
            neurons[target].potential += synapses[i].weight;
            
            // STDP обучение (если нейрон сработал)
            if (neurons[target].fired) {
                stdpLearning(neuronIdx, target, currentTime - lastSpikeTime[target]);
            }
        }
    }
}

// Основной цикл обработки (вызывается каждые 1 мс)
uint32_t time = 0;
uint32_t lastSpikeTime[NEURON_COUNT];

void processNetwork() {
    time++;
    
    for (uint8_t i = 0; i < NEURON_COUNT; i++) {
        // Проверяем рефрактерность
        if (neurons[i].refractory > 0) {
            neurons[i].refractory--;
            continue;
        }
        
        // Проверяем порог
        if (neurons[i].potential >= neurons[i].threshold) {
            // Спайк!
            neurons[i].fired = 1;
            neurons[i].potential = 0;
            neurons[i].refractory = 5;  // 5 мс рефрактерности
            lastSpikeTime[i] = time;
            
            processSpike(i, time);
        } else {
            neurons[i].fired = 0;
            // Постепенное угасание потенциала
            neurons[i].potential = (neurons[i].potential * 15) / 16;
        }
    }
}

// Входной стимул (от датчиков)
void stimulateNetwork(uint8_t* input) {
    for (uint8_t i = 0; i < NEURON_COUNT; i++) {
        if (input[i]) {
            neurons[i].potential += 20;  // Добавляем стимул
        }
    }
}

// Чтение выхода (сработавшие нейроны)
void readOutput(uint8_t* output) {
    for (uint8_t i = 0; i < NEURON_COUNT; i++) {
        output[i] = neurons[i].fired;
    }
}

// Пример: распознавание паттернов
void setup() {
    Serial.begin(115200);
    initNetwork();
    
    // Создаем случайные связи (50% вероятность)
    for (uint8_t i = 0; i < NEURON_COUNT; i++) {
        for (uint8_t j = 0; j < NEURON_COUNT; j++) {
            if (i != j && (rand() % 2)) {
                addSynapse(i, j, rand() % 20 - 10);
            }
        }
    }
    
    // Обучаем сеть на паттерне (00110011)
    uint8_t pattern[] = {0, 0, 1, 1, 0, 0, 1, 1};
    for (uint8_t epoch = 0; epoch < 100; epoch++) {
        stimulateNetwork(pattern);
        for (uint8_t i = 0; i < 100; i++) {
            processNetwork();
        }
    }
}

void loop() {
    // Тестируем сеть
    uint8_t testInput[] = {0, 1, 1, 0, 0, 0, 1, 1};
    uint8_t output[NEURON_COUNT];
    
    stimulateNetwork(testInput);
    for (uint8_t i = 0; i < 100; i++) {
        processNetwork();
    }
    readOutput(output);
    
    Serial.print("Распознанный паттерн: ");
    for (uint8_t i = 0; i < NEURON_COUNT; i++) {
        Serial.print(output[i]);
    }
    Serial.println();
    
    delay(1000);
}