Введение в нейронные сети на Python: линейный слой (Dense)

Обновлено в 2026 году.

Нейронные сети на Python проще всего собрать на Keras: пара строк — и модель учится. Минимальный полносвязный (Dense), он же линейный, слой выглядит так:

from tensorflow.keras.layers import Dense Dense(128, activation='relu') # 128 нейронов, каждый связан со всеми входами

Dense-слой считает output = activation(dot(input, kernel) + bias): умножает входы на матрицу весов, добавляет смещение и прогоняет результат через функцию активации. На этой операции держится большинство базовых моделей.

• Нейрон — это взвешенная сумма входов плюс смещение, пропущенная через нелинейность.
• Линейный (Dense) слой соединяет каждый вход с каждым выходом: формула y = Wx + b.
• Функция активации (ReLU, sigmoid, softmax) добавляет нелинейность — без неё сеть остаётся линейной регрессией.
• Обучение — это подбор весов W и b градиентным спуском так, чтобы уменьшить ошибку (loss).
• Собрать рабочую сеть на Keras или PyTorch можно за 10–15 строк — примеры ниже.

Что такое нейронные сети на Python простыми словами

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

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

На Python всю эту математику не пишут руками — её берут на себя библиотеки TensorFlow/Keras и PyTorch. Разработчик описывает архитектуру слоёв, а перемножение матриц, подсчёт градиентов и обновление весов происходят под капотом.

Коротко: нейрон — это взвешенная сумма плюс активация, а сеть — это стопка таких нейронов, собранных в слои.

ОНЛАЙН-ПРАКТИКУМ

ЗАПУСК нейросети DEEPSEEK R1 ЛОКАЛЬНО НА СВОЕМ КОМПЬЮТЕРЕ

ЧТО БУДЕТ НА ОБУЧЕНИИ?

• ПОКАЖЕМ, КАК РАЗВЕРНУТЬ МОДЕЛЬ нейросети DEEPSEEK R1 ПРЯМО НА СВОЁМ КОМПЬЮТЕРЕ
• Где и как применять? Потестируем модель после установки на разных задачах
• Как дообучить модель под себя?

Участвовать бесплатно

Линейный (Dense) слой: формула и как он устроен

Линейный слой, он же полносвязный или Dense layer, — базовый строительный блок нейронных сетей на Python. «Полносвязный» значит, что каждый нейрон слоя связан со всеми выходами предыдущего слоя. Математически слой выполняет линейное преобразование:

y = W · x + b x — вектор входов W — матрица весов (обучаемая) b — вектор смещений (обучаемый) y — выход до активации

В документации Keras та же операция записана как output = activation(dot(input, kernel) + bias), где kernel — это матрица весов W, а bias — вектор b. В PyTorch слой nn.Linear применяет преобразование y = xA^T + b — это та же формула, записанная под построчное умножение.

Размерность слоя задаёт один параметр — число нейронов (units в Keras, out_features в PyTorch). Запись Dense(128) означает 128 выходов; если на входе 784 числа, слой создаёт матрицу весов 784×128 и вектор из 128 смещений — итого 100 480 обучаемых параметров.

Мини-вывод: Dense-слой — это умножение на матрицу весов плюс смещение. Всё «обучение» сводится к подбору чисел в W и b.

Функции активации: зачем ReLU, sigmoid и softmax

Если сложить несколько линейных слоёв подряд, их произведение снова остаётся линейным — такая сеть не мощнее одной прямой. Нелинейность добавляет функция активации: она гнёт выход нейрона, и это позволяет сети аппроксимировать сложные зависимости.

Три функции покрывают почти все базовые задачи:

Практическое правило для старта: ReLU на скрытых слоях, softmax на выходе для многоклассовой классификации, sigmoid — для «да/нет».

Мини-вывод: активация — это то, что превращает стопку линейных слоёв в настоящую нейросеть.

Как собрать нейронные сети на Python: Keras и PyTorch

Для входа в тему хватает двух библиотек. Keras (внутри TensorFlow) даёт высокоуровневый интерфейс — модель описывается декларативно. PyTorch популярнее в исследованиях и даёт больше контроля. Ниже — одна и та же классификация рукописных цифр MNIST на обеих.

Вариант на Keras

Установка одной командой:

pip install tensorflow

import tensorflow as tf from tensorflow.keras.layers import Dense, Flatten from tensorflow.keras.models import Sequential # Данные: 70 000 изображений цифр 28x28 mnist = tf.keras.datasets.mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train, x_test = x_train / 255.0, x_test / 255.0 # нормализация в [0, 1] # Модель: два полносвязных слоя model = Sequential([ Flatten(input_shape=(28, 28)), # 28x28 -> вектор 784 Dense(128, activation='relu'), # скрытый слой Dense(10, activation='softmax') # 10 классов (цифры 0-9) ]) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) model.fit(x_train, y_train, epochs=5) model.evaluate(x_test, y_test)

Разбор ключевых элементов:

• Sequential — контейнер, где слои идут строго друг за другом, выход одного = вход следующего.
• Flatten — растягивает картинку 28×28 в вектор из 784 чисел, чтобы подать в Dense.
• Dense(128, activation='relu') — скрытый полносвязный слой из 128 нейронов.
• Dense(10, activation='softmax') — выходной слой: 10 вероятностей, по одной на цифру.

Тот же пример на PyTorch

import torch import torch.nn as nn class Net(nn.Module): def __init__(self): super().__init__() self.flatten = nn.Flatten() self.fc1 = nn.Linear(784, 128) # линейный слой 784 -> 128 self.fc2 = nn.Linear(128, 10) # линейный слой 128 -> 10 def forward(self, x): x = self.flatten(x) x = torch.relu(self.fc1(x)) # активация ReLU return self.fc2(x) # логиты; softmax внутри loss model = Net() loss_fn = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

Логика одна: два линейных слоя и ReLU между ними. Разница в стиле — Keras прячет цикл обучения, PyTorch показывает его явно (прямой проход, расчёт loss, loss.backward(), шаг оптимизатора).

Мини-вывод: архитектура из двух Dense-слоёв достаточна, чтобы распознавать цифры с точностью около 97–98% после нескольких эпох.

Как обучаются нейронные сети на Python

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

1. Прямой проход. Данные проходят через слои, сеть выдаёт предсказание.
2. Расчёт ошибки (loss). Функция потерь измеряет, насколько предсказание далеко от правильного ответа. Для многоклассовой классификации берут кросс-энтропию.
3. Обратное распространение. Алгоритм считает, как каждый вес повлиял на ошибку — это градиент.
4. Шаг оптимизатора. Веса сдвигаются в сторону, уменьшающую ошибку. Размер шага задаёт скорость обучения (learning rate); сам метод — градиентный спуск, а его практичная версия Adam используется в примерах выше.

Одна эпоха — это один полный проход по всем обучающим данным. Данные подают мини-пакетами (batch), чтобы не держать весь датасет в памяти и чаще обновлять веса. Число эпох, размер пакета и скорость обучения — это гиперпараметры: их задают до обучения, и они управляют тем, как быстро и качественно сходится модель.

Мини-вывод: сеть не «понимает» задачу — она много раз ошибается и каждый раз чуть-чуть правит веса в сторону меньшей ошибки.

Пример задачи: классификация цифр

Разобранный выше MNIST — классическая задача классификации: на входе картинка, на выходе один из 10 классов. Тот же каркас (Flatten → Dense+ReLU → Dense+softmax) переносится на другие табличные и векторные задачи почти без изменений — меняются размер входа и число выходных нейронов.

Мини-вывод: тип задачи определяет три вещи — размер выходного слоя, активацию на нём и функцию потерь. Скрытые слои остаются Dense+ReLU.

Частые ошибки новичков в нейронных сетях на Python

Несколько граблей, на которые наступают почти все на старте:

• Забыли нормализацию. Пиксели 0–255 или сырые признаки с разным масштабом мешают сходимости. Делите на 255 или приводите к среднему 0 — как в примере выше.
• Softmax не на том слое. Softmax нужен только на выходном слое классификации, а не на скрытых. На скрытых — ReLU.
• Число выходных нейронов не совпадает с числом классов. Для 10 цифр выход — ровно Dense(10), не 1 и не 128.
• Слишком большая скорость обучения. Если loss скачет или уходит в NaN — уменьшите learning rate (например, с 0.01 до 0.001).
• Переобучение. Если точность на обучении высокая, а на тесте падает — сеть запомнила данные. Помогают меньше нейронов, больше данных или Dropout-слой.

Мини-вывод: большинство «сеть не учится» на старте — это не архитектура, а нормализация данных и скорость обучения.

Что запомнить о линейном слое

• Dense (линейный, полносвязный) слой считает y = Wx + b — это ядро большинства базовых нейросетей.
• Число нейронов слоя задаёт размер выхода; веса и смещения — то, что сеть выучивает.
• Активация даёт нелинейность: ReLU в скрытых слоях, softmax/sigmoid на выходе.
• Keras быстрее для старта, PyTorch показывает цикл обучения явно — начинать можно с любого.
• Обучение = подбор весов градиентным спуском для минимизации loss.

Частые вопросы

Чем линейный слой отличается от Dense?

Это одно и то же. «Линейный слой», «полносвязный слой» и «Dense layer» — синонимы. В Keras он называется Dense, в PyTorch — nn.Linear. Оба выполняют преобразование y = Wx + b.

Что такое веса и смещения простыми словами?

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

Зачем нужна функция активации?

Без неё несколько линейных слоёв схлопываются в один и сеть не может выучить сложные зависимости. Активация (ReLU, sigmoid, softmax) добавляет нелинейность.

Keras или PyTorch выбрать новичку?

Для первого знакомства проще Keras: меньше кода, скрытый цикл обучения. PyTorch стоит освоить следующим — он даёт полный контроль и доминирует в исследованиях. Синтаксис слоёв в обеих библиотеках близок.

Сколько слоёв нужно для начала?

Для простой классификации хватает одного-двух скрытых Dense-слоёв. Начинать стоит с малого: добавлять нейроны и слои имеет смысл только если модель недообучается.