Deep Learning TensorFlow

Нейронні мережі: вступ до Deep Learning

18 лютого 2026 | 35 хв читання

У 1943 році нейрофізіолог Уоррен Маккаллок та математик Уолтер Піттс опублікували статтю "A Logical Calculus of Ideas Immanent in Nervous Activity", де вперше описали математичну модель нейрона. 80 років потому ці ідеї лежать в основі ChatGPT, Midjourney та автопілотів Tesla. Нейронні мережі — це не магія, це математика. У цій статті ми розберемо, як вони працюють насправді.

Біологічна інспірація: як працює мозок

Людський мозок містить приблизно 86 мільярдів нейронів, кожен з яких пов'язаний з тисячами інших через синапси. Коли нейрон отримує достатньо сигналів від сусідів, він "активується" і передає сигнал далі.

Функції активації: нелінійність — ключ до всього

Без функції активації нейронна мережа була б просто лінійним перетворенням. Нелінійність дозволяє апроксимувати будь-яку функцію.

Архітектура: від перцептрона до Transformer

1. Perceptron (Персептрон)

Найпростіша нейронна мережа — один нейрон. Може вирішувати тільки лінійно роздільні задачі.

import numpy as np

class Perceptron:
    def __init__(self, learning_rate=0.1, n_iterations=100):
        self.lr = learning_rate
        self.n_iter = n_iterations
        self.weights = None
        self.bias = None

    def fit(self, X, y):
        n_samples, n_features = X.shape
        self.weights = np.zeros(n_features)
        self.bias = 0

        for _ in range(self.n_iter):
            for idx, x_i in enumerate(X):
                linear_output = np.dot(x_i, self.weights) + self.bias
                y_pred = self._activation(linear_output)

                # Perceptron learning rule
                update = self.lr * (y[idx] - y_pred)
                self.weights += update * x_i
                self.bias += update

    def _activation(self, x):
        return np.where(x >= 0, 1, 0)

    def predict(self, X):
        linear_output = np.dot(X, self.weights) + self.bias
        return self._activation(linear_output)

2. Multi-Layer Perceptron (MLP)

Кілька шарів нейронів дозволяють вирішувати нелінійні задачі. Це "класична" нейронна мережа.

import tensorflow as tf
from tensorflow.keras import layers, models

# Створення MLP для класифікації
model = models.Sequential([
    layers.Input(shape=(784,)),           # Вхід: 28x28 = 784 пікселі
    layers.Dense(256, activation='relu'), # Прихований шар 1
    layers.Dropout(0.3),                  # Регуляризація
    layers.Dense(128, activation='relu'), # Прихований шар 2
    layers.Dropout(0.3),
    layers.Dense(10, activation='softmax') # Вихід: 10 класів
])

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

model.summary()

3. Convolutional Neural Networks (CNN)

Спеціалізовані для обробки зображень. Використовують згорткові фільтри для виявлення патернів.

# CNN для класифікації зображень
cnn_model = models.Sequential([
    # Convolutional блок 1
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    layers.MaxPooling2D((2, 2)),

    # Convolutional блок 2
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),

    # Convolutional блок 3
    layers.Conv2D(64, (3, 3), activation='relu'),

    # Класифікатор
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# Параметри
print(f"Total parameters: {cnn_model.count_params():,}")

4. Recurrent Neural Networks (RNN)

Для послідовних даних: текст, часові ряди, аудіо. Мають "пам'ять" про попередні входи.

# LSTM для аналізу тексту
from tensorflow.keras.layers import Embedding, LSTM, Bidirectional

text_model = models.Sequential([
    Embedding(input_dim=10000, output_dim=128, input_length=500),
    Bidirectional(LSTM(64, return_sequences=True)),
    Bidirectional(LSTM(32)),
    layers.Dense(64, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(1, activation='sigmoid')  # Бінарна класифікація
])

text_model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

5. Transformers

Революційна архітектура 2017 року. Основа GPT, BERT, та всіх сучасних LLM. Використовує механізм attention замість рекурентності.

Backpropagation: як мережа навчається

Backpropagation (зворотне поширення помилки) — алгоритм, який обчислює градієнти функції втрат відносно кожної ваги в мережі.

1. Forward pass: Вхід проходить через мережу, обчислюється вихід
2. Loss calculation: Порівнюється вихід з правильною відповіддю
3. Backward pass: Градієнт помилки поширюється назад через шари
4. Weight update: Ваги оновлюються в напрямку, що зменшує помилку

# Спрощений backpropagation (для розуміння)
def train_step(X, y, model, learning_rate):
    # Forward pass
    predictions = model(X)

    # Compute loss
    loss = compute_loss(predictions, y)

    # Backward pass (автоматично в TensorFlow)
    with tf.GradientTape() as tape:
        predictions = model(X)
        loss = compute_loss(predictions, y)

    # Compute gradients
    gradients = tape.gradient(loss, model.trainable_variables)

    # Update weights
    for var, grad in zip(model.trainable_variables, gradients):
        var.assign_sub(learning_rate * grad)

    return loss

Практичний проект: класифікація зображень CIFAR-10

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import cifar10
import matplotlib.pyplot as plt

# Завантаження даних
(X_train, y_train), (X_test, y_test) = cifar10.load_data()

# Нормалізація
X_train = X_train.astype('float32') / 255.0
X_test = X_test.astype('float32') / 255.0

# Назви класів
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
               'dog', 'frog', 'horse', 'ship', 'truck']

# Побудова CNN
model = models.Sequential([
    # Block 1
    layers.Conv2D(32, (3, 3), padding='same', activation='relu',
                  input_shape=(32, 32, 3)),
    layers.BatchNormalization(),
    layers.Conv2D(32, (3, 3), padding='same', activation='relu'),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.25),

    # Block 2
    layers.Conv2D(64, (3, 3), padding='same', activation='relu'),
    layers.BatchNormalization(),
    layers.Conv2D(64, (3, 3), padding='same', activation='relu'),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.25),

    # Block 3
    layers.Conv2D(128, (3, 3), padding='same', activation='relu'),
    layers.BatchNormalization(),
    layers.Conv2D(128, (3, 3), padding='same', activation='relu'),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.25),

    # Classifier
    layers.Flatten(),
    layers.Dense(512, activation='relu'),
    layers.BatchNormalization(),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax')
])

# Компіляція
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Data Augmentation
data_augmentation = tf.keras.Sequential([
    layers.RandomFlip("horizontal"),
    layers.RandomRotation(0.1),
    layers.RandomZoom(0.1),
])

# Callbacks
callbacks = [
    tf.keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True),
    tf.keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=5)
]

# Навчання
history = model.fit(
    X_train, y_train,
    epochs=100,
    batch_size=64,
    validation_split=0.1,
    callbacks=callbacks
)

# Оцінка
test_loss, test_acc = model.evaluate(X_test, y_test)
print(f"Test accuracy: {test_acc:.2%}")

Проблеми та їх вирішення

Transfer Learning: не винаходьте колесо

У 2026 році рідко хто тренує мережі з нуля. Transfer Learning — це використання моделі, натренованої на великому датасеті, для вашої задачі.

# Transfer Learning з ResNet50
from tensorflow.keras.applications import ResNet50
from tensorflow.keras.layers import GlobalAveragePooling2D

# Завантаження pretrained моделі (без верхніх шарів)
base_model = ResNet50(
    weights='imagenet',
    include_top=False,
    input_shape=(224, 224, 3)
)

# Заморожуємо базову модель
base_model.trainable = False

# Додаємо свої шари
model = models.Sequential([
    base_model,
    GlobalAveragePooling2D(),
    layers.Dense(256, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(num_classes, activation='softmax')
])

# Компіляція та тренування
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Fine-tuning (опціонально)
base_model.trainable = True
for layer in base_model.layers[:-20]:
    layer.trainable = False

model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-5),
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

Рекомендовані ресурси

• 3Blue1Brown Neural Networks
  Найкраща візуалізація концепцій
  YouTube
• Deep Learning Specialization (Andrew Ng)
  Повний курс на Coursera
  Курс
• TensorFlow Documentation
  tensorflow.org/tutorials
  Docs
• Papers With Code
  Найновіші дослідження з кодом
  Research