Нейрон: шаг в будущее

Шаг в будущее: немного истории

Идея «искусственного нейрона» почти так же стара, как сами компьютеры.

• 1943 — Уоррен Мак-Каллок и Уолтер Питтс описали математическую модель нейрона: он суммирует сигналы и «срабатывает», если сумма выше порога. Они показали, что из таких элементов можно собрать любую логическую схему.
• 1958 — Фрэнк Розенблатт построил перцептрон — нейрон, который учится на примерах, подстраивая веса. Пресса писала, что скоро машины будут ходить, говорить и осознавать себя.
• 1969 — Марвин Минский и Сеймур Пейперт доказали, что один перцептрон не может выучить даже простую функцию XOR. Интерес и финансирование надолго иссякли — началась первая «зима ИИ».
• 1986 — Румельхарт, Хинтон и Уильямс популяризировали обратное распространение ошибки: сети из нескольких слоёв нейронов можно обучать градиентным спуском, и XOR им по силам.
• 2012 — свёрточная сеть AlexNet с большим отрывом выиграла конкурс распознавания изображений ImageNet, обучившись на видеокартах. Началась эпоха глубокого обучения, которая привела к сегодняшним языковым моделям.

Всё это построено из одного элемента, который мы сейчас разберём.

Как устроен нейрон

Биологический нейрон получает сигналы от других нейронов через дендриты, «взвешивает» их (одни синапсы усиливают сигнал, другие ослабляют) и, если суммарное возбуждение превышает порог, посылает импульс дальше по аксону. Искусственный нейрон — сильно упрощённая математическая версия:

• x — входы (признаки или выходы других нейронов);
• w — веса: насколько важен каждый вход и с каким знаком;
• b — сдвиг (bias): порог срабатывания;
• f — функция активации: ступенька, сигмоида, ReLU…

import numpy as np

def neuron(x, w, b):
    z = w @ x + b
    return 1 / (1 + np.exp(-z))          # сигмоида

# «нейрон, который любит солнце и не любит ветер»: признаки (солнце, ветер, температура)
w = np.array([2.0, -3.0, 0.1])
b = -1.0
for day in ([1, 0, 20], [1, 1, 25], [0, 0, 15], [0, 1, 5]):
    print(day, f"→ желание гулять {neuron(np.array(day, float), w, b):.2f}")

Геометрия: нейрон проводит прямую

Нейрон с двумя входами и ступенькой (или сигмоидой с порогом 0.5) делит плоскость на две части прямой

С одной стороны z > 0 (класс 1), с другой z < 0 (класс 0). Вектор весов w перпендикулярен прямой и указывает в сторону класса 1, а сдвиг b двигает прямую. В n измерениях это гиперплоскость. Модели с такой границей называют линейными классификаторами.

Попробуйте подобрать веса для логических функций. Точки — 4 комбинации входов, цвет — нужный ответ. Обведённые красным — ошибки.

• И (AND): w_1 = w_2 = 1, b = -1.5 — прямая отсекает только угол (1, 1).
• ИЛИ (OR): w_1 = w_2 = 1, b = -0.5.
• XOR — попробуйте… и убедитесь, что ни одна прямая не отделяет (0, 1) и (1, 0) от (0, 0) и (1, 1).

Обучение перцептрона

Розенблатт предложил простое правило: показываем примеры по одному; если нейрон ошибся, сдвигаем веса в сторону правильного ответа:

Если нейрон сказал 0, а надо 1, к весам прибавляется вход — в следующий раз w \cdot x на этом примере будет больше. Если сказал 1, а надо 0, — вычитается. Для линейно разделимых данных доказано, что перцептрон за конечное число шагов найдёт разделяющую прямую.

import numpy as np
import vis

X = np.array([[0.0, 0], [0, 1], [1, 0], [1, 1]])
for name, y in [("И", [0, 0, 0, 1]), ("ИЛИ", [0, 1, 1, 1]), ("XOR", [0, 1, 1, 0])]:
    w, b = np.zeros(2), 0.0
    for epoch in range(20):
        errors = 0
        for x, t in zip(X, y):
            p = 1 if w @ x + b > 0 else 0
            if p != t:
                w += (t - p) * x
                b += t - p
                errors += 1
    print(f"{name:4}: w = {w}, b = {b:+.0f}, ошибок в последней эпохе: {errors}")
    vis.scatter(X, labels=y, lines=[(w[0], w[1], b)], title=f"Перцептрон: {name}", equal=True)

На XOR перцептрон так и не сходится: правильной прямой просто нет.

Нейрон с градиентным спуском

Ступенька плоха для градиентного спуска: её производная везде 0. Если заменить её сигмоидой, а правило перцептрона — минимизацией бинарной кросс-энтропии, получится логистическая регрессия — нейрон, выдающий вероятность. Обучим его в nanotorch:

import numpy as np
import nanotorch as nt
import vis

X, y = nt.make_blobs(200, centers=((-1.5, -1), (1.5, 1)), std=1.0, seed=2)

nt.manual_seed(0)
neuron = nt.Linear(2, 1)                    # w·x + b; сигмоида встроена в функцию потерь
opt = nt.SGD(neuron.parameters(), lr=0.5)
for step in range(200):
    logits = neuron(nt.Tensor(X))
    loss = nt.binary_cross_entropy(logits, y)
    opt.zero_grad()
    loss.backward()
    opt.step()

w, b = neuron.W.data.ravel(), neuron.b.data[0]
acc = ((X @ w + b > 0) == (y == 1)).mean()
print(f"w = {w.round(2)}, b = {b:.2f}, loss = {loss.item():.3f}, точность = {acc:.1%}")
vis.boundary(lambda P: 1 / (1 + np.exp(-(P @ w + b))), X, y, title="Нейрон: вероятность класса 1 и граница p = 0.5")

Цвет фона — вероятность, которую выдаёт нейрон: у границы она около 0.5, вдали от неё — уверенные 0 или 1.

Что дальше

Один нейрон — линейный классификатор: он умеет только провести прямую. Чтобы решать XOR, спирали и распознавать цифры, нейроны объединяют:

1. в слой — много нейронов, смотрящих на одни и те же входы (следующий урок);
2. в сеть — слои один за другим, с нелинейностью между ними.

Итог

• Нейрон: y = f(w \cdot x + b) — взвешенная сумма входов, сдвиг и функция активации.
• Геометрически — гиперплоскость w \cdot x + b = 0, делящая пространство на два класса.
• Один нейрон реализует И, ИЛИ, НЕ, но не XOR: классы XOR линейно неразделимы.
• Правило перцептрона: w \mathrel{+}= (y - \hat y)x; с сигмоидой и кросс-энтропией нейрон обучается градиентным спуском (логистическая регрессия).