Самый маленький мозг, который ты можешь написать: перцептрон на Python

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

Давай разберёмся, почему эта штука заслуживает твоего времени.

Что такое перцептрон

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

Это и есть перцептрон. Простейший элемент нейросети — минимальная единица, которая умеет принимать бинарное решение (два варианта, «да» или «нет»). Не путать с полноценной нейросетью — там десятки слоёв и миллионы параметров. Здесь всё скромнее.

        ВХОДЫ          ВЕСА         СУММА      ПОРОГ     ВЫХОД
    ┌──────────┐
    │ x₁ = 0.8 │───w₁ = 0.5──┐
    └──────────┘              │        ┌───────────┐
    ┌──────────┐              ├───────▶│ Σ + bias  │───▶ (1 или 0)
    │ x₂ = 0.3 │───w₂ = 0.2──┤        └───────────┘
    └──────────┘              │             │
    ┌──────────┐              │        порог: 0.5
    │ x₃ = 0.6 │───w₃ = 0.1──┘
    └──────────┘

Как он считает

Математика здесь элементарная. Каждый вход умножается на свой вес, всё складывается, добавляется смещение (bias) — и результат сравнивается с порогом.

Формула: выход = 1, если w₁x₁ + w₂x₂ + w₃x₃ + b > 0, иначе 0

Вес (weight) — число, определяющее важность каждого входа. Можешь думать о нём как о громкости рупора: чем больше вес, тем сильнее сигнал.

Смещение (bias) — дополнительное число, которое сдвигает порог принятия решения. Это как настройка чувствительности: сделаешь больше — перцептрон станет «ленивее», меньше — чувствительнее.

Взвешенная сумма — каждый вход умножается на свой вес и всё складывается. Результат говорит, насколько суммарный сигнал превышает порог.

Как работает обучение

Вот где начинается магия. Перцептрон учится на ошибках — и это поразительно простой процесс.

Правило обновления весов: если перцептрон ошибся, мы подправляем веса. Предсказал «1», а нужно «0»? Уменьшаем веса. Наоборот? Увеличиваем. Величина корректировки зависит от ошибки и learning rate (шаг обучения) — скорости, с которой мы меняем веса.

Шаг обучения обычно берут маленький: 0.01, 0.1, максимум 0.5. Больше — рискуешь «перепрыгнуть» правильный ответ.

# Псевдокод обучения
for each mistake:
    w = w + learning_rate * (expected - predicted) * x

И так по кругу, пока ошибки не станут редкостью.

Реализация на Python

Хватит теории. Код:

import numpy as np

class Perceptron:
    def __init__(self, num_inputs, learning_rate=0.01):
        self.weights = np.zeros(num_inputs)
        self.bias = 0
        self.lr = learning_rate

    def predict(self, inputs):
        summation = np.dot(inputs, self.weights) + self.bias
        return 1 if summation > 0 else 0

    def train(self, X, y, epochs=100):
        for _ in range(epochs):
            for inputs, label in zip(X, y):
                prediction = self.predict(inputs)
                error = label - prediction
                # Обновляем веса
                self.weights += self.lr * error * inputs
                self.bias += self.lr * error

Структура простая: конструктор задаёт веса и смещение, predict считает результат, train крутит цикл обучения. Весь перцептрон умещается в сорок строк.

Проверка на данных

Возьмём классический пример — логическое «И». Таблица истинности:

Запускаем:

X = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([0, 0, 0, 1])

p = Perceptron(2, learning_rate=0.1)
p.train(X, y, epochs=10)

for inputs in X:
    print(f"Вход: {inputs} → Предсказание: {p.predict(inputs)}")

Перцептрон сходится за считанные эпохи. Красиво, правда?

Границы возможного

А теперь болезненная правда: перцептрон — малыш с серьёзными ограничениями.

Он решает только линейно разделимые задачи. Если данные нельзя разделить прямой линией — перцептрон сдастся. Классический пример: операция XOR (исключающее ИЛИ). Попробуй провести прямую так, чтобы 0⊕0 и 1⊕1 были по одну сторону, а 0⊕1 и 1⊕0 — по другую. Не выйдет.

Именно это ограничение в 1969 году доказал Минский, и после этого нейросетевая зима продлилась почти двадцать лет. Пока не придумали многослойные сети — но это уже совсем другая история.

        XOR: не разделяется прямой
────────────────────────────────────
    ┌───────────┐      ┌───────────┐
    │ 0,0 → 0   │      │ 0,1 → 1   │
    └───────────┘      └───────────┘
    ┌───────────┐      ┌───────────┐
    │ 1,0 → 1   │      │ 1,1 → 0   │
    └───────────┘      └───────────┘
          ────────▶ прямая не помогает

Итого

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

Да, он линейно ограничен. Да, для серьёзных задач нужны слои. Но если ты хочешь почувствовать, как машина учится принимать решения — начни с него. Потрать вечер, напиши код, поиграйся с данными. Остальное приложится.

Ссылки

• The Smallest Brain You Can Build: A Perceptron in Python — статья с разбором перцептрона и практической реализацией