Когда мы говорим «нейроинтерфейс», большинство сразу представляет себе что-то вроде Neuralink или фантастические сцены из «Джонни Мнемоника». Но на деле между идеей и практикой — не пропасть, а куча микроконтроллеров, кода, биопотенциалов и кофе. В этой статье я покажу, как можно построить рабочий прототип интерфейса «мозг → ИИ-приложение» — начиная от электродов и аналоговых фильтров, заканчивая API, которое передаёт сигналы в модель машинного обучения.

Откуда растут электроды

Если отбросить маркетинг, нейроинтерфейс — это просто способ измерить электрическую активность мозга (обычно через ЭЭГ) и как-то использовать эти данные. И первое, что понимаешь, когда начинаешь собирать BCI своими руками — мозг не любит, когда ты к нему лезешь с проводами.

Я начал с OpenBCI Cyton, потому что у него открытые схемы и нормальная документация. Он снимает сигналы с восьми каналов ЭЭГ с частотой 250 Гц. Можно подключить сухие электроды или «мокрые» (через гель), но последние дают чище сигнал.

Кстати, если вы хотите собрать что-то бюджетное — подойдёт и Arduino с внешним усилителем типа ADS1299. Главное — не пытайтесь цепляться напрямую к коже, без экранирования: вы просто поймаете помехи от сети, а не мысли.

Пример подключения:

[электроды] → [усилитель ADS1299] → [Arduino Nano] → [Serial USB] → [Python]

Питание лучше делать от батареи, а не от USB, чтобы не создавать петлю заземления.
А если вы решите протестировать сигнал — достаточно подмигнуть: вы увидите резкий всплеск альфа-активности в диапазоне 8–13 Гц. В этот момент вы, кстати, тоже увидите, насколько «шумный» мир.

Фильтруем хаос

Когда данные начинают поступать, вы осознаёте: мозг не умеет посылать чистые сигналы. Вся поверхность головы — это как огромная антенна, которая ловит всё подряд.

Для обработки я использую Python + NumPy + SciPy. Вот минимальный фрагмент кода, который фильтрует сигнал и выделяет альфа-ритм:

import numpy as np
from scipy.signal import butter, lfilter

def bandpass_filter(data, lowcut, highcut, fs, order=4):
    nyq = 0.5 * fs
    low = lowcut / nyq
    high = highcut / nyq
    b, a = butter(order, [low, high], btype='band')
    return lfilter(b, a, data)

# Пример: фильтр альфа-диапазона 8–13 Гц
fs = 250  # частота дискретизации
raw_signal = np.loadtxt('eeg_raw_data.txt')
alpha_signal = bandpass_filter(raw_signal, 8, 13, fs)

Если посмотреть на спектр после фильтрации — вы увидите знакомые волны, будто тихий пульс вашего мозга.

Чтобы отличить «намерение» от просто биошума, нужно анализировать изменение мощности в разных диапазонах. Например, концентрация вызывает рост бета-активности (13–30 Гц), а расслабление — альфа.

Обучаем ИИ понимать мозг

И вот у нас поток цифр — тысячи отсчётов в секунду. Как заставить ИИ их понимать?
Для начала стоит собрать небольшой датасет. Например, вы записываете, как человек выполняет разные ментальные действия: «поднять руку», «расслабиться», «представить движение». Потом помечаете эти отрезки метками.

Минимальный пример на PyTorch, как обучить простую нейросеть различать два состояния:

import torch
import torch.nn as nn
import torch.optim as optim

class EEGNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(250, 64)
        self.fc2 = nn.Linear(64, 2)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.relu(self.fc1(x))
        return self.fc2(x)

model = EEGNet()
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()

for epoch in range(100):
    for X, y in dataloader:
        optimizer.zero_grad()
        out = model(X)
        loss = criterion(out, y)
        loss.backward()
        optimizer.step()

После обучения модель начинает угадывать, что вы хотите сделать, с точностью примерно 70–80 %. Звучит не как «чтение мыслей», но для управления простыми действиями (например, выбрать пункт меню или включить свет) — вполне достаточно.

А теперь представьте: вы моргнули, модель поняла, что вы хотите запустить сценарий, и через API вызвала функцию в ИИ-приложении. Красота.

Строим API-мост между мозгом и кодом

Чтобы интегрировать мозг с приложением, нужен слой API, который будет получать данные от модели и вызывать нужные действия.
Я сделал прототип на FastAPI — потому что быстро и удобно:

from fastapi import FastAPI
import json
from model import predict_state

app = FastAPI()

@app.post("/neuro")
async def process_signal(payload: dict):
    signal = payload["data"]
    state = predict_state(signal)
    if state == "focus":
        do_action("run_ai_model")
    return {"state": state}

def do_action(action):
    if action == "run_ai_model":
        print("? Запускаем анализ в приложении...")

# Запуск: uvicorn main:app --reload

Теперь можно подключить всё, что угодно — от голосового помощника до GPT-модели. Представьте: вы просто думаете о задаче — и ИИ начинает выполнять запрос.

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

Реальность, усталость и немного философии

После недели тестов я понял, что мозг — не очень надёжный интерфейс. Но сама идея «мышления как API» даёт что-то большее.
Нейроинтерфейс — это не про контроль. Это про понимание себя через сигнал, который мы наконец-то научились измерять.

Да, пока мы далеко от шлемов, которые читают мысли. Но собрать свой работающий BCI можно уже сейчас, если не бояться пайки и Python.

А вы бы хотели, чтобы ваше приложение реагировало на ваше состояние? Чтобы оно чувствовало, что вы устали, и подсказывало: «эй, сделай перерыв»?