Перцептрон: учим нейрон логике AND и OR

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

Перцептрон — это нейрон с пороговой активацией и простым правилом обучения: если ответ неверный, веса чуть сдвигаются в сторону правильного ответа.

Пороговая активация

В перцептроне активация — это ступенька (step): если взвешенная сумма больше либо равна нулю, выход = 1, иначе 0. Это удобно для задач, где ответ — «да/нет». В отличие от прошлого урока, веса мы не зададим вручную — нейрон найдёт их сам.

Правило обучения перцептрона

Идея гениально простая. Для каждого примера сеть делает предсказание и сравнивает с правильным ответом. Ошибка err = target - pred принимает значения -1, 0 или 1. Веса обновляются так:

w_i = w_i + lr * err * x_i, а смещение b = b + lr * err.

Здесь lr (learning rate, скорость обучения) — небольшое число, задающее размер шага. Если ответ верный, err = 0 и веса не меняются. Если нейрон ошибся — веса сдвигаются в сторону, которая уменьшает ошибку именно на этом примере.

Обучаем логике AND

Логическое И: результат равен 1, только если оба входа равны 1. Прогоним обучение и посмотрим, как число ошибок за эпоху падает до нуля.

def step(x):
    return 1 if x >= 0 else 0

def train_perceptron(data, epochs=6, lr=0.1):
    w = [0.0, 0.0]
    b = 0.0
    for epoch in range(epochs):
        errors = 0
        for inputs, target in data:
            s = w[0]*inputs[0] + w[1]*inputs[1] + b
            pred = step(s)
            err = target - pred
            if err != 0:
                errors += 1
                w[0] += lr * err * inputs[0]
                w[1] += lr * err * inputs[1]
                b    += lr * err
        print("Эпоха", epoch+1, "ошибок:", errors)
    return w, b

AND = [((0,0),0), ((0,1),0), ((1,0),0), ((1,1),1)]
w, b = train_perceptron(AND)
print("Веса:", [round(x,2) for x in w], "смещение:", round(b,2))
for inputs, _ in AND:
    s = w[0]*inputs[0] + w[1]*inputs[1] + b
    print(inputs, "->", step(s))

Вывод:

Эпоха 1 ошибок: 2
Эпоха 2 ошибок: 3
Эпоха 3 ошибок: 3
Эпоха 4 ошибок: 0
Эпоха 5 ошибок: 0
Эпоха 6 ошибок: 0
Веса: [0.2, 0.1] смещение: -0.2
(0, 0) -> 0
(0, 1) -> 0
(1, 0) -> 0
(1, 1) -> 1

К четвёртой эпохе ошибок не осталось — перцептрон выучил AND. Обратите внимание: ошибки сначала даже выросли, прежде чем упасть. Обучение редко идёт строго вниз с первого шага.

То же самое для OR

Логическое ИЛИ: результат равен 1, если хотя бы один вход равен 1. Меняется только обучающая таблица — алгоритм тот же.

def step(x):
    return 1 if x >= 0 else 0

def train_perceptron(data, epochs=6, lr=0.1):
    w = [0.0, 0.0]
    b = 0.0
    for epoch in range(epochs):
        errors = 0
        for inputs, target in data:
            s = w[0]*inputs[0] + w[1]*inputs[1] + b
            pred = step(s)
            err = target - pred
            if err != 0:
                errors += 1
                w[0] += lr * err * inputs[0]
                w[1] += lr * err * inputs[1]
                b    += lr * err
        print("Эпоха", epoch+1, "ошибок:", errors)
    return w, b

OR = [((0,0),0), ((0,1),1), ((1,0),1), ((1,1),1)]
w, b = train_perceptron(OR)
print("Веса:", [round(x,2) for x in w], "смещение:", round(b,2))
for inputs, _ in OR:
    s = w[0]*inputs[0] + w[1]*inputs[1] + b
    print(inputs, "->", step(s))

Вывод:

Эпоха 1 ошибок: 2
Эпоха 2 ошибок: 2
Эпоха 3 ошибок: 1
Эпоха 4 ошибок: 0
Эпоха 5 ошибок: 0
Эпоха 6 ошибок: 0
Веса: [0.1, 0.1] смещение: -0.1
(0, 0) -> 0
(0, 1) -> 1
(1, 0) -> 1
(1, 1) -> 1

Что важно понять

Перцептрон — это исторический первый кирпич нейросетей (1958 год). Его правило обучения наглядно показывает главную идею: учить — значит постепенно сдвигать веса так, чтобы ошибок становилось меньше. Дальше мы заменим грубое правило перцептрона на более мощный и универсальный механизм — градиентный спуск с обратным распространением.

Итог

Перцептрон обновляет веса по правилу w += lr * err * x.
Линейно разделимые функции (AND, OR) он выучивает за несколько эпох.
Число ошибок за эпоху — простой индикатор прогресса обучения.