Вступ до нейронних мереж — від персептрона до багатошарових мереж

Від одного нейрона до мереж — чому лінійності недостатньо

Уявіть, що ви програміст у 1950-х роках і отримуєте завдання: навчити комп'ютер розпізнавати рукописні цифри. У вас немає готових бібліотек, лише базові математичні операції. З чого почати?

Інтуїція підказує: кожен піксель зображення — це число (яскравість). Якщо помножити кожен піксель на свою «вагу важливості» та просумувати, отримаємо «оцінку схожості» на певну цифру. Саме так народилася ідея персептрона — першої нейронної мережі.

Але швидко з'ясувалося: одного персептрона недостатньо. Він може розв'язати лише найпростіші задачі — ті, де класи можна розділити прямою лінією. Більшість реальних задач — складніші. Потрібна мережа персептронів, де виходи одних стають входами для інших. Так з'явилися багатошарові нейронні мережі.

Архітектура персептрона — перший штучний нейрон

Персептрон — це математична модель біологічного нейрона, запропонована Френком Розенблаттом у 1957 році. Його структура надзвичайно проста, але концептуально революційна для свого часу.

Структура персептрона

Персептрон складається з чотирьох компонентів:

Візуалізація персептрона

@startuml
skinparam style plain
skinparam backgroundColor #FFFFFF
skinparam defaultFontName "SF Pro Display, Arial"

!define INPUT_COLOR DBEAFE
!define NEURON_COLOR FEF3C7
!define OUTPUT_COLOR DCFCE7

rectangle "Вхідні ознаки" as input {
  (x₁) #INPUT_COLOR
  (x₂) #INPUT_COLOR
  (x₃) #INPUT_COLOR
  (x₄) #INPUT_COLOR
}

rectangle "Нейрон (Персептрон)" as neuron #NEURON_COLOR {
  card "z = Σ wᵢxᵢ + b" as sum
  card "σ(z)" as activation
  sum -down-> activation : активація
}

rectangle "Вихід" as output {
  (ŷ) #OUTPUT_COLOR
}

(x₁) -right-> sum : w₁
(x₂) -right-> sum : w₂
(x₃) -right-> sum : w₃
(x₄) -right-> sum : w₄

activation -right-> (ŷ) : клас 0 або 1

note right of sum
  Зважена сума:
  **z = w₁·x₁ + w₂·x₂ + w₃·x₃ + w₄·x₄ + b**
end note

note right of activation
  Функція кроку:
  **σ(z) = 1 якщо z ≥ 0, інакше 0**
end note

@enduml

Приклад: персептрон для логічного АБО (OR)

Розглянемо найпростішу задачу: навчити персептрон логічній операції OR.

Таблиця істинності OR:

Питання: чи можна знайти такі ваги Завантаження..., щоб персептрон правильно класифікував всі 4 приклади?

Відповідь: так! Наприклад, Завантаження....

Перевірка:

import numpy as np

def step_function(z):
    """Функція кроку: 1 якщо z >= 0, інакше 0"""
    return 1 if z >= 0 else 0

# Ваги персептрона для OR
w1, w2, b = 1.0, 1.0, -0.5

# Перевірка всіх комбінацій
inputs = [(0, 0), (0, 1), (1, 0), (1, 1)]

print("x₁  x₂  | z = w₁·x₁ + w₂·x₂ + b | σ(z) | Очікується")
print("-" * 55)

for x1, x2 in inputs:
    z = w1 * x1 + w2 * x2 + b
    output = step_function(z)
    expected = int(x1 or x2)
    status = "✓" if output == expected else "✗"
    print(f"{x1}   {x2}   |  {z:6.2f}               | {output}    | {expected}        {status}")

@startuml
skinparam style plain
skinparam backgroundColor #FFFFFF
skinparam defaultFontName "SF Pro Display, Arial"

!define INPUT_COLOR DBEAFE
!define GATE_COLOR FEF3C7
!define OUTPUT_COLOR DCFCE7

rectangle "Логічний вентиль OR (АБО)" as or_gate #GATE_COLOR {
  card "w₁ = 1.0, w₂ = 1.0\nb = -0.5" as or_weights
  card "Межа розділення:\nx₁ + x₂ - 0.5 = 0" as or_line
}

rectangle "Логічний вентиль AND (І)" as and_gate #GATE_COLOR {
  card "w₁ = 1.0, w₂ = 1.0\nb = -1.5" as and_weights
  card "Межа розділення:\nx₁ + x₂ - 1.5 = 0" as and_line
}

node "(0,0) → 0\n(0,1) → 1\n(1,0) → 1\n(1,1) → 1" as or_truth #INPUT_COLOR
node "(0,0) → 0\n(0,1) → 0\n(1,0) → 0\n(1,1) → 1" as and_truth #INPUT_COLOR

or_truth -down-> or_gate : лінійно роздільні
and_truth -down-> and_gate : лінійно роздільні

card "Висновок: обидві задачі успішно розв'язуються\nоднією прямою гіперплощиною" as conclusion #OUTPUT_COLOR
or_gate -down-> conclusion
and_gate -down-> conclusion

@enduml

Проблема XOR — межа лінійної роздільності

Персептрон успішно вирішує логічні операції AND, OR, NOT. Але існує одна проста операція, яка повністю розбиває одношаровий персептрон: XOR (виключне АБО).

Таблиця істинності XOR:

Питання: чи можна знайти ваги Завантаження... для персептрона, щоб правильно класифікувати XOR?

Відповідь: НІ! Це математично неможливо.

Чому персептрон не може розв'язати XOR?

Персептрон — це лінійний класифікатор. Він може провести лише одну пряму лінію для розділення класів. Подивимося на візуалізацію XOR:

xor_visualization.ipynb (Autosaved)

Trusted

Python 3.11 (ipykernel)

Cell

Run

Code

In [2]:

0.31s

import matplotlib.pyplot as plt
import numpy as np

# Дані XOR
x_coords = [0, 0, 1, 1]
y_coords = [0, 1, 0, 1]
colors = ['red', 'blue', 'blue', 'red']  # клас 0 — червоний, клас 1 — синій
labels = [0, 1, 1, 0]

plt.figure(figsize=(8, 6))
plt.scatter(x_coords, y_coords, c=colors, s=300, edgecolors='black', linewidths=2, alpha=0.7)

# Додаємо підписи точок
for i, (x, y, label) in enumerate(zip(x_coords, y_coords, labels)):
    plt.text(x, y, f'  ({x}, {y})\n  y={label}', fontsize=12, ha='left')

# Спроба провести лінію розділення (завжди помилиться)
plt.axline((0.5, 0), slope=1, color='gray', linestyle='--', linewidth=2, alpha=0.5, label='Неможлива лінія розділення')

plt.xlim(-0.3, 1.5)
plt.ylim(-0.3, 1.5)
plt.xlabel('x₁', fontsize=14)
plt.ylabel('x₂', fontsize=14)
plt.title('Проблема XOR: класи не є лінійно роздільними', fontsize=16, fontweight='bold')
plt.legend(fontsize=12)
plt.grid(alpha=0.3)
plt.tight_layout()
plt.show()

Out[2]:

@startuml
skinparam style plain
skinparam backgroundColor #FFFFFF
skinparam defaultFontName "SF Pro Display, Arial"

!define CLASS0_COLOR FEE2E2
!define CLASS1_COLOR DBEAFE
!define LIMIT_COLOR FEF3C7

package "Простір входів XOR (x₁, x₂)" {
  node "(0, 0)\ny = 0" as p00 #CLASS0_COLOR
  node "(1, 1)\ny = 0" as p11 #CLASS0_COLOR
  node "(0, 1)\ny = 1" as p01 #CLASS1_COLOR
  node "(1, 0)\ny = 1" as p10 #CLASS1_COLOR
}

package "Обмеження одношарового персептрона" as limit #LIMIT_COLOR {
  card "Лінійна модель: w₁·x₁ + w₂·x₂ + b = 0" as model
  card "Пряма лінія може розділити лише сусідні точки,\nале точки однакових класів розташовані діагонально!" as conflict
}

p00 ..> conflict : діагональ 1
p11 ..> conflict : діагональ 1
p01 ..> conflict : діагональ 2
p10 ..> conflict : діагональ 2

card "Рішення: Багатошаровий персептрон (MLP)\nіз нелінійною активацією" as solution #DCFCE7
conflict -down-> solution : подолання обмеження
@enduml

Історичний контекст: «зима AI» через XOR

У 1969 році математики Марвін Мінський та Сеймур Паперт опублікували книгу «Персептрони», де математично довели, що одношаровий персептрон принципово не може розв'язати XOR.

Це викликало першу «зиму штучного інтелекту» (1970–1980-ті роки) — різке скорочення фінансування досліджень AI, бо вважалося, що нейронні мережі — тупиковий шлях.

Аналогія з будівництвом:

Уявіть, що ви маєте лише прямокутні цеглини. З них можна збудувати стіни, але неможливо створити арку чи купол — потрібні цеглини інших форм. Одношаровий персептрон — це «прямокутні цеглини». Для складних форм (нелінійних задач) потрібні багатошарові мережі — цеглини різних форм і розмірів.

Рішення проблеми: додати приховані шари нейронів між входом і виходом. Так з'являються багатошарові нейронні мережі (Multi-Layer Perceptron, MLP).

Багатошаровий персептрон (MLP) — прорив у нелінійності

Якщо один персептрон — це одна пряма лінія, то кілька персептронів, з'єднаних у мережу, можуть створювати складні нелінійні межі розділення.

Архітектура MLP

Multi-Layer Perceptron (MLP) — це нейронна мережа, що складається з:

1. Вхідного шару (Input Layer): приймає ознаки об'єкта (не виконує обчислень, лише передає дані далі)
2. Прихованих шарів (Hidden Layers): один або кілька шарів нейронів, що виконують нелінійні перетворення
3. Вихідного шару (Output Layer): повертає передбачення (одне число для регресії, ймовірності класів для класифікації)

Приклад: MLP для розв'язання XOR

Найпростіша архітектура для XOR:

• Вхідний шар: 2 нейрони (Завантаження...)
• Прихований шар: 2 нейрони (дозволяють створити дві лінії розділення)
• Вихідний шар: 1 нейрон (передбачення 0 або 1)

@startuml
skinparam style plain
skinparam backgroundColor #FFFFFF
skinparam defaultFontName "SF Pro Display, Arial"

!define INPUT_COLOR DBEAFE
!define HIDDEN_COLOR FEF3C7
!define OUTPUT_COLOR DCFCE7

left to right direction

package "Вхідний шар\n(Input Layer)" as input #INPUT_COLOR {
  circle x1 as "x₁"
  circle x2 as "x₂"
}

package "Прихований шар\n(Hidden Layer)" as hidden #HIDDEN_COLOR {
  circle h1 as "h₁"
  circle h2 as "h₂"
}

package "Вихідний шар\n(Output Layer)" as output #OUTPUT_COLOR {
  circle y as "ŷ"
}

x1 -right-> h1
x1 -right-> h2
x2 -right-> h1
x2 -right-> h2

h1 -right-> y
h2 -right-> y

note bottom of hidden
  Кожен нейрон обчислює:
  **hᵢ = σ(w·x + b)**
  де σ — функція активації
end note

@enduml

Як MLP розв'язує XOR: покрокове пояснення

Розберемо, як працює MLP з 2 входами → 2 прихованих нейронів → 1 вихід для задачі XOR.

import numpy as np

def sigmoid(z):
    """Сигмоїда: σ(z) = 1 / (1 + e^(-z))"""
    return 1 / (1 + np.exp(-z))

# Ваги для прихованого шару (підібрані вручну для демонстрації)
W1 = np.array([
    [1.0, 1.0],   # h1: реагує на OR (x1 + x2)
    [1.0, 1.0]    # h2: реагує на AND (x1 * x2 при правильному bias)
])
b1 = np.array([-0.5, -1.5])  # Порогові значення

# Ваги для вихідного шару
W2 = np.array([1.0, -2.0])   # y = h1 - 2*h2
b2 = np.array([0.0])

# Вхідні дані XOR
X = np.array([
    [0, 0],
    [0, 1],
    [1, 0],
    [1, 1]
])

print("Обчислення MLP для XOR:\n")
print("x₁  x₂  | h₁ (OR-подібний) | h₂ (AND-подібний) | z_out      | ŷ (σ(z)) | Очікується")
print("-" * 90)

for x in X:
    # Прихований шар
    z_hidden = W1 @ x + b1
    h = sigmoid(z_hidden)

    # Вихідний шар
    z_out = W2 @ h + b2
    y_pred = sigmoid(z_out)

    expected = int(x[0] != x[1])  # XOR: 1 якщо входи різні
    status = "✓" if round(y_pred[0]) == expected else "✗"

    print(f"{x[0]}   {x[1]}   |      {h[0]:.3f}       |      {h[1]:.3f}        | {z_out[0]:7.3f}   | {y_pred[0]:7.3f}  | {expected}        {status}")

@startuml
skinparam style plain
skinparam backgroundColor #FFFFFF
skinparam defaultFontName "SF Pro Display, Arial"

!define INPUT_COLOR DBEAFE
!define HIDDEN_COLOR FEF3C7
!define OUTPUT_COLOR DCFCE7

rectangle "1. Вхідний простір (x₁, x₂)" as input_space #INPUT_COLOR {
  card "Точки нелінійні:\n(0,0)=0, (1,1)=0\n(0,1)=1, (1,0)=1" as raw_pts
  card "Потрібні дві лінії розділення:\n• h₁: x₁ + x₂ = 0.5 (OR)\n• h₂: x₁ + x₂ = 1.5 (AND)" as lines
}

rectangle "2. Нелінійна активація σ(z)" as activation #HIDDEN_COLOR {
  card "Прихований шар деформує простір:\nточки (0,1) та (1,0) зближуються,\nа (0,0) та (1,1) розсуваються" as transform
}

rectangle "3. Прихований простір (h₁, h₂)" as hidden_space #OUTPUT_COLOR {
  card "Точки стають лінійно роздільними!" as sep_pts
  card "Вихідний нейрон проводить пряму:\nh₁ - 2·h₂ = 0" as final_line
}

input_space -right-> activation : W₁, b₁
activation -right-> hidden_space : W₂, b₂
@enduml

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

Ми вже бачили функцію кроку та сигмоїду. Але чому взагалі потрібна будь-яка функція активації? Що станеться, якщо її не буде?

Чому без активації мережа колапсує до лінійної моделі

Уявімо MLP без функцій активації (тобто кожен нейрон просто обчислює зважену суму):

Розкриємо дужки:

Позначимо Завантаження... та Завантаження...:

Результат: отримали просту лінійну модель! Неважливо, скільки шарів ви додасте — без нелінійної активації вся мережа редукується до однієї лінійної функції.

Огляд популярних функцій активації

Розглянемо найважливіші функції активації, їхні переваги та недоліки.

1. Сигмоїда (Sigmoid)

Формула:

Діапазон виходу: Завантаження...

Властивості:

• Плавна S-подібна крива
• Інтерпретується як ймовірність
• Виходи завжди додатні

activation_functions.ipynb (Autosaved)

Trusted

Python 3.11 (ipykernel)

Cell

Run

Code

In [4]:

0.28s

import numpy as np
import matplotlib.pyplot as plt

# Визначення функцій активації
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

def tanh(z):
    return np.tanh(z)

def relu(z):
    return np.maximum(0, z)

def leaky_relu(z, alpha=0.01):
    return np.where(z > 0, z, alpha * z)

# Діапазон значень
z = np.linspace(-5, 5, 200)

# Візуалізація
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Сигмоїда
axes[0, 0].plot(z, sigmoid(z), color='#3b82f6', linewidth=3)
axes[0, 0].axhline(0, color='gray', linestyle='--', alpha=0.3)
axes[0, 0].axvline(0, color='gray', linestyle='--', alpha=0.3)
axes[0, 0].grid(alpha=0.3)
axes[0, 0].set_title('Сигмоїда: σ(z) = 1/(1+e⁻ᶻ)', fontsize=14, fontweight='bold')
axes[0, 0].set_ylabel('σ(z)', fontsize=12)
axes[0, 0].set_ylim(-0.2, 1.2)

# Tanh
axes[0, 1].plot(z, tanh(z), color='#8b5cf6', linewidth=3)
axes[0, 1].axhline(0, color='gray', linestyle='--', alpha=0.3)
axes[0, 1].axvline(0, color='gray', linestyle='--', alpha=0.3)
axes[0, 1].grid(alpha=0.3)
axes[0, 1].set_title('Tanh: tanh(z)', fontsize=14, fontweight='bold')
axes[0, 1].set_ylabel('tanh(z)', fontsize=12)

# ReLU
axes[1, 0].plot(z, relu(z), color='#10b981', linewidth=3)
axes[1, 0].axhline(0, color='gray', linestyle='--', alpha=0.3)
axes[1, 0].axvline(0, color='gray', linestyle='--', alpha=0.3)
axes[1, 0].grid(alpha=0.3)
axes[1, 0].set_title('ReLU: max(0, z)', fontsize=14, fontweight='bold')
axes[1, 0].set_xlabel('z', fontsize=12)
axes[1, 0].set_ylabel('ReLU(z)', fontsize=12)

# Leaky ReLU
axes[1, 1].plot(z, leaky_relu(z), color='#f59e0b', linewidth=3)
axes[1, 1].axhline(0, color='gray', linestyle='--', alpha=0.3)
axes[1, 1].axvline(0, color='gray', linestyle='--', alpha=0.3)
axes[1, 1].grid(alpha=0.3)
axes[1, 1].set_title('Leaky ReLU: max(0.01z, z)', fontsize=14, fontweight='bold')
axes[1, 1].set_xlabel('z', fontsize=12)
axes[1, 1].set_ylabel('Leaky ReLU(z)', fontsize=12)

plt.tight_layout()
plt.show()

Out[4]:

@startuml
skinparam style plain
skinparam backgroundColor #FFFFFF
skinparam defaultFontName "SF Pro Display, Arial"

!define SIG_COLOR #DBEAFE
!define TANH_COLOR #FEF3C7
!define RELU_COLOR #DCFCE7
!define LEAKY_COLOR #F1F5F9

package "Функції активації (Activation Functions)" {
  class "Sigmoid: σ(z) = 1/(1+e⁻ᶻ)" as sig #SIG_COLOR {
    + Діапазон: (0, 1)
    + Похідна: max 0.25 (зникаючий градієнт)
    + Роль: вихід бінарної класифікації
  }
  class "Tanh: (eᶻ - e⁻ᶻ)/(eᶻ + e⁻ᶻ)" as tanh #TANH_COLOR {
    + Діапазон: (-1, 1)
    + Центрована навколо нуля
    + Роль: приховані шари RNN / NLP
  }
  class "ReLU: max(0, z)" as relu #RELU_COLOR {
    + Діапазон: [0, +∞)
    + Похідна: 1 при z > 0
    + Роль: дефолтний стандарт глибоких мереж
  }
  class "Leaky ReLU: max(αz, z)" as leaky #LEAKY_COLOR {
    + Діапазон: (-∞, +∞)
    + Похідна: α = 0.01 при z < 0
    + Роль: запобігання "мертвим нейронам"
  }
}
@enduml

Проблеми сигмоїди:

Коли використовувати: лише для вихідного шару в бінарній класифікації (інтерпретація як ймовірність класу 1).

2. Гіперболічний тангенс (Tanh)

Формула:

Діапазон виходу: Завантаження...

Переваги над сигмоїдою:

• Центрована навколо нуля: виходи симетричні відносно нуля, що прискорює збіжність
• Більший діапазон градієнтів

Недоліки:

• Також страждає від проблеми зникаючих градієнтів (хоча меншою мірою, ніж сигмоїда)

Коли використовувати: для прихованих шарів у рекурентних нейронних мережах (RNN, LSTM).

Аналогія:

Сигмоїда — як термометр, що показує від 0°C до 100°C. Tanh — як термометр із шкалою від -50°C до +50°C (центрований навколо нормальної температури). Другий термометр точніше реагує на невеликі зміни навколо середнього значення.

3. ReLU (Rectified Linear Unit)

Формула:

Діапазон виходу: Завантаження...

Чому ReLU стала революцією (2010-ті роки):

Проблема: "мертві нейрони" (Dying ReLU)

Якщо нейрон отримує лише від'ємні входи, ReLU завжди повертає 0, градієнт також 0, і нейрон назавжди перестає навчатися. Це відбувається при:

• Дуже високому learning rate (ваги «перестрибують» в область, де вхід завжди від'ємний)
• Поганій ініціалізації ваг

Коли використовувати: для прихованих шарів у більшості завдань — стандартний вибір за замовчуванням.

4. Leaky ReLU

Формула:

Відмінність від ReLU: замість нуля для від'ємних значень використовується невеликий нахил Завантаження... (зазвичай 0.01).

Переваги:

• Немає "мертвих нейронів": навіть для Завантаження... градієнт Завантаження..., тому нейрон продовжує навчатися
• Всі переваги ReLU зберігаються

Коли використовувати: якщо ReLU призводить до великої кількості мертвих нейронів (експериментальна альтернатива).

5. Softmax (для багатокласової класифікації)

Формула (для вектора Завантаження...):

Властивості:

• Перетворює довільний вектор у розподіл ймовірностей: всі виходи в діапазоні Завантаження..., їхня сума дорівнює 1
• Клас з найбільшим Завантаження... отримує найвищу ймовірність

Коли використовувати: виключно для вихідного шару в задачах багатокласової класифікації (наприклад, розпізнавання 10 цифр MNIST).

import numpy as np

def softmax(z):
    """Обчислює softmax для вектора z"""
    exp_z = np.exp(z - np.max(z))  # Віднімаємо max для числової стабільності
    return exp_z / np.sum(exp_z)

# Приклад: мережа передбачає бали для 3 класів (кішка, собака, птах)
logits = np.array([2.0, 1.0, 0.1])  # Сирі виходи мережі (до softmax)

probabilities = softmax(logits)

print("Клас         | Логіт (z) | Ймовірність (softmax)")
print("-" * 55)
classes = ["Кішка", "Собака", "Птах"]
for cls, z, prob in zip(classes, logits, probabilities):
    print(f"{cls:12} |   {z:5.2f}   |   {prob:6.4f}  ({prob*100:5.2f}%)")

print(f"\nСума ймовірностей: {probabilities.sum():.6f}")
print(f"Передбачений клас: {classes[np.argmax(probabilities)]}")

Порівняльна таблиця функцій активації

Прямий прохід (Forward Propagation) — від входу до виходу

Тепер, коли ми розуміємо архітектуру MLP та функції активації, розберемо покроково, як мережа обчислює своє передбачення.

Forward Propagation — це процес послідовного обчислення виходів кожного шару, починаючи від вхідного та закінчуючи вихідним.

Загальна формула для одного шару

Для шару Завантаження... з Завантаження... нейронами:

Де:

• Завантаження... — активації попереднього шару (для першого шару це вхідні дані Завантаження...)
• Завантаження... — матриця ваг шару Завантаження... (розмір: Завантаження...)
• Завантаження... — вектор зсувів (bias) шару Завантаження...
• Завантаження... — функція активації шару Завантаження...

Приклад: прямий прохід для мережі 3 → 4 → 2 → 1

Розглянемо конкретну архітектуру:

• Вхід: 3 ознаки (Завантаження...)
• Прихований шар 1: 4 нейрони з ReLU
• Прихований шар 2: 2 нейрони з ReLU
• Вихід: 1 нейрон з sigmoid (бінарна класифікація)

@startuml
skinparam style plain
skinparam backgroundColor #FFFFFF
skinparam defaultFontName "SF Pro Display, Arial"

!define INPUT_COLOR DBEAFE
!define HIDDEN1_COLOR FEF3C7
!define HIDDEN2_COLOR FECACA
!define OUTPUT_COLOR DCFCE7

left to right direction

package "Вхід\n(3 ознаки)" as input #INPUT_COLOR {
  circle "x₁" as x1
  circle "x₂" as x2
  circle "x₃" as x3
}

package "Прихований 1\n(4 нейрони, ReLU)" as h1 #HIDDEN1_COLOR {
  circle "h₁⁽¹⁾" as h11
  circle "h₂⁽¹⁾" as h12
  circle "h₃⁽¹⁾" as h13
  circle "h₄⁽¹⁾" as h14
}

package "Прихований 2\n(2 нейрони, ReLU)" as h2 #HIDDEN2_COLOR {
  circle "h₁⁽²⁾" as h21
  circle "h₂⁽²⁾" as h22
}

package "Вихід\n(1 нейрон, Sigmoid)" as output #OUTPUT_COLOR {
  circle "ŷ" as y
}

x1 --> h11
x1 --> h12
x1 --> h13
x1 --> h14

x2 --> h11
x2 --> h12
x2 --> h13
x2 --> h14

x3 --> h11
x3 --> h12
x3 --> h13
x3 --> h14

h11 --> h21
h11 --> h22
h12 --> h21
h12 --> h22
h13 --> h21
h13 --> h22
h14 --> h21
h14 --> h22

h21 --> y
h22 --> y

note bottom of input
  **Крок 1:** Отримуємо вхідні дані
  **x** = [x₁, x₂, x₃]ᵀ
end note

note bottom of h1
  **Крок 2:** Обчислюємо шар 1
  **z⁽¹⁾** = W⁽¹⁾·x + b⁽¹⁾
  **a⁽¹⁾** = ReLU(z⁽¹⁾)
end note

note bottom of h2
  **Крок 3:** Обчислюємо шар 2
  **z⁽²⁾** = W⁽²⁾·a⁽¹⁾ + b⁽²⁾
  **a⁽²⁾** = ReLU(z⁽²⁾)
end note

note bottom of output
  **Крок 4:** Вихідний шар
  **z** = W⁽³⁾·a⁽²⁾ + b⁽³⁾
  **ŷ** = σ(z)
end note

@enduml

Реалізація прямого проходу на NumPy

import numpy as np

def relu(z):
    """ReLU: max(0, z)"""
    return np.maximum(0, z)

def sigmoid(z):
    """Sigmoid: 1 / (1 + exp(-z))"""
    return 1 / (1 + np.exp(-z))

# Ініціалізація ваг (випадкові значення для демонстрації)
np.random.seed(42)

# Розміри шарів: 3 → 4 → 2 → 1
W1 = np.random.randn(4, 3) * 0.1  # Шар 1: 4 нейрони, кожен приймає 3 входи
b1 = np.zeros((4, 1))

W2 = np.random.randn(2, 4) * 0.1  # Шар 2: 2 нейрони, кожен приймає 4 входи
b2 = np.zeros((2, 1))

W3 = np.random.randn(1, 2) * 0.1  # Вихід: 1 нейрон, приймає 2 входи
b3 = np.zeros((1, 1))

# Вхідні дані: один приклад з 3 ознаками
x = np.array([[0.5], [0.3], [0.8]])  # Вектор-стовпець (3, 1)

print("ПРЯМИЙ ПРОХІД (Forward Propagation)\n")
print("=" * 60)

# Шар 1
z1 = W1 @ x + b1
a1 = relu(z1)
print(f"Шар 1 (Прихований):")
print(f"  z⁽¹⁾ = W⁽¹⁾·x + b⁽¹⁾ → shape: {z1.shape}")
print(f"  Зважені суми z⁽¹⁾: {z1.flatten()}")
print(f"  a⁽¹⁾ = ReLU(z⁽¹⁾): {a1.flatten()}\n")

# Шар 2
z2 = W2 @ a1 + b2
a2 = relu(z2)
print(f"Шар 2 (Прихований):")
print(f"  z⁽²⁾ = W⁽²⁾·a⁽¹⁾ + b⁽²⁾ → shape: {z2.shape}")
print(f"  Зважені суми z⁽²⁾: {z2.flatten()}")
print(f"  a⁽²⁾ = ReLU(z⁽²⁾): {a2.flatten()}\n")

# Вихідний шар
z3 = W3 @ a2 + b3
y_pred = sigmoid(z3)
print(f"Вихідний шар:")
print(f"  z = W⁽³⁾·a⁽²⁾ + b⁽³⁾: {z3.flatten()}")
print(f"  ŷ = σ(z): {y_pred.flatten()[0]:.4f}")
print(f"\n{'='*60}")
print(f"ПЕРЕДБАЧЕННЯ: ймовірність класу 1 = {y_pred[0, 0]:.2%}")

Зворотний прохід (Backpropagation) — як мережа навчається

Ми отримали передбачення Завантаження.... Тепер потрібно порівняти його з правильною відповіддю Завантаження..., обчислити помилку та оновити ваги, щоб наступного разу помилка була меншою.

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

Інтуїтивне пояснення

Аналогія з виробничим конвеєром:

Уявіть фабрику з 3 етапами виробництва печива:

1. Етап А: Замішування тіста (робітник Андрій)
2. Етап Б: Формування печива (робітник Богдан)
3. Етап В: Випікання (робітник Віктор)

Печиво вийшло несмачним (висока функція втрат). Директор починає розслідування у зворотному порядку:

• Перевіряє Віктора (вихідний шар): температура печі занадто висока → коригує налаштування
• Перевіряє Богдана (прихований шар 2): печиво занадто товсте → коригує товщину
• Перевіряє Андрія (прихований шар 1): недостатньо борошна → коригує рецепт

Кожен етап отримує «частку провини» пропорційно свому впливу на кінцевий результат. Саме це робить backpropagation.

Ланцюгове правило (Chain Rule) — математична основа

Припустимо, функція втрат залежить від виходу останнього шару, який залежить від ваг:

Щоб знайти, як зміна ваги Завантаження... впливає на втрати Завантаження..., застосовуємо ланцюгове правило:

Інтерпретація:

• Завантаження... — наскільки втрати чутливі до зміни передбачення
• Завантаження... — наскільки передбачення чутливе до зміни зваженої суми (похідна функції активації)
• Завантаження... — наскільки зважена сума чутлива до зміни ваги (це просто Завантаження...)

@startuml
skinparam style plain
skinparam backgroundColor #FFFFFF
skinparam defaultFontName "SF Pro Display, Arial"

!define FWD_COLOR DBEAFE
!define BWD_COLOR FEE2E2
!define NODE_COLOR F1F5F9

rectangle "Прямий прохід (Forward Pass: обчислення втрат)" #FWD_COLOR {
  card "x, w" as in_val
  card "z = w·x + b" as sum_val
  card "ŷ = σ(z)" as act_val
  card "Loss L(ŷ, y)" as loss_val
  in_val -right-> sum_val : лінійна сума
  sum_val -right-> act_val : активація
  act_val -right-> loss_val : функція втрат
}

rectangle "Зворотний прохід (Backpropagation: ланцюгове правило)" #BWD_COLOR {
  card "∂L/∂w = ∂L/∂z · x" as grad_w
  card "∂L/∂z = ∂L/∂ŷ · σ'(z)" as grad_z
  card "∂L/∂ŷ" as grad_y
  loss_val ..> grad_y : 1. помилка на виході
  grad_y -left-> grad_z : 2. через активацію
  grad_z -left-> grad_w : 3. на ваги
}

card "Оновлення ваг: w := w - α · (∂L/∂w)" as update #DCFCE7
grad_w -down-> update : градієнтний спуск

@enduml

Алгоритм backpropagation покроково

Для мережі з Завантаження... шарами:

Похідні функцій активації

Для backpropagation потрібні похідні функцій активації:

Спрощений приклад backpropagation на папері

Розглянемо мінімальну мережу: 1 вхід → 1 нейрон з sigmoid → 1 вихід.

Дано:

• Вхід: Завантаження...
• Вага: Завантаження...
• Bias: Завантаження...
• Правильна відповідь: Завантаження...

Forward pass:

import numpy as np

# Параметри
x = 0.5
w = 0.8
b = 0.2
y = 1.0
learning_rate = 0.5

# Forward pass
z = w * x + b
y_pred = 1 / (1 + np.exp(-z))  # sigmoid

# Loss (Binary Cross-Entropy)
loss = -(y * np.log(y_pred) + (1 - y) * np.log(1 - y_pred))

print("FORWARD PASS:")
print(f"z = w·x + b = {w}·{x} + {b} = {z:.4f}")
print(f"ŷ = σ(z) = {y_pred:.4f}")
print(f"Loss = -{y}·log({y_pred:.4f}) = {loss:.4f}\n")

# Backward pass
dL_dy_pred = -(y / y_pred) + (1 - y) / (1 - y_pred)  # Градієнт по виходу
dy_pred_dz = y_pred * (1 - y_pred)  # Похідна sigmoid
dL_dz = dL_dy_pred * dy_pred_dz  # Ланцюгове правило

# Для sigmoid з BCE це спрощується до:
dL_dz_simplified = y_pred - y

dz_dw = x  # Похідна z по w
dz_db = 1  # Похідна z по b

dL_dw = dL_dz_simplified * dz_dw
dL_db = dL_dz_simplified * dz_db

print("BACKWARD PASS:")
print(f"∂L/∂ŷ = {dL_dy_pred:.4f}")
print(f"∂ŷ/∂z = {dy_pred_dz:.4f}  (похідна sigmoid)")
print(f"∂L/∂z = {dL_dz:.4f}  або спрощено: {dL_dz_simplified:.4f}")
print(f"∂L/∂w = ∂L/∂z · ∂z/∂w = {dL_dz_simplified:.4f} · {x} = {dL_dw:.4f}")
print(f"∂L/∂b = ∂L/∂z · ∂z/∂b = {dL_dz_simplified:.4f} · 1 = {dL_db:.4f}\n")

# Оновлення параметрів
w_new = w - learning_rate * dL_dw
b_new = b - learning_rate * dL_db

print("ОНОВЛЕННЯ ПАРАМЕТРІВ:")
print(f"w := w - α·∂L/∂w = {w} - {learning_rate}·{dL_dw:.4f} = {w_new:.4f}")
print(f"b := b - α·∂L/∂b = {b} - {learning_rate}·{dL_db:.4f} = {b_new:.4f}\n")

# Перевірка: forward pass з новими вагами
z_new = w_new * x + b_new
y_pred_new = 1 / (1 + np.exp(-z_new))
loss_new = -(y * np.log(y_pred_new) + (1 - y) * np.log(1 - y_pred_new))

print("ПЕРЕВІРКА (після оновлення):")
print(f"ŷ_new = {y_pred_new:.4f}  (було {y_pred:.4f})")
print(f"Loss_new = {loss_new:.4f}  (було {loss:.4f})")
print(f"Покращення: {loss - loss_new:.4f} ✓" if loss_new < loss else "Погіршення ✗")

Оптимізатори — еволюція градієнтного спуску

Базовий градієнтний спуск має суттєві обмеження при навчанні нейронних мереж. Розглянемо еволюцію алгоритмів оптимізації від найпростішого до сучасних.

1. Vanilla Gradient Descent (Batch GD)

Формула оновлення:

Принцип: обчислюємо градієнт по всьому датасету, потім робимо один крок.

Проблеми:

2. Stochastic Gradient Descent (SGD)

Ідея: замість всього датасету використовуємо один випадковий приклад для обчислення градієнта.

Формула:

Переваги:

• ✅ Швидкі оновлення ваг (після кожного прикладу)
• ✅ Може «вистрибнути» з локальних мінімумів завдяки шуму градієнта

Проблеми:

• ⚠️ Дуже шумний градієнт — траєкторія навчання хаотична
• ⚠️ Може не досягти точного мінімуму (буде коливатися навколо нього)

3. Mini-Batch Gradient Descent

Ідея: обчислюємо градієнт по невеликій підмножині (batch) прикладів, зазвичай 32, 64, 128 або 256.

Формула:

Де Завантаження... — розмір батча.

Переваги:

• ✅ Баланс між швидкістю та стабільністю
• ✅ Ефективне використання GPU (паралельна обробка батча)
• ✅ Менш шумний градієнт, ніж у SGD

Зауваження: У сучасній літературі термін «SGD» часто означає саме Mini-Batch GD, а не справжній стохастичний (по одному прикладу).

4. SGD з Momentum

Проблема vanilla SGD: у регіонах з різною кривизною функції втрат (наприклад, вузькі «яри») градієнт коливається між стінками, уповільнюючи рух до мінімуму.

Ідея Momentum: додати «інерцію» — враховувати попередній напрямок руху.

Формули:

Де Завантаження... — швидкість (velocity), Завантаження... — коефіцієнт momentum (зазвичай 0.9).

Аналогія:

Уявіть м'яч, що котиться вниз по схилу. Без momentum він зупиняється при кожній малій нерівності. З momentum він набирає швидкість і пролітає крізь невеликі перешкоди, прямуючи до найнижчої точки.

Переваги:

• ✅ Швидша збіжність у напрямках зі слабкою кривизною
• ✅ Зменшує коливання у напрямках із сильною кривизною
• ✅ Може «перестрибнути» дрібні локальні мінімуми

5. Adam (Adaptive Moment Estimation)

Adam — це найпопулярніший оптимізатор у сучасному глибокому навчанні. Він поєднує ідеї Momentum та адаптивного learning rate для кожного параметра окремо.

Ідея:

• Для кожної ваги зберігаємо експоненційно згладжений градієнт (перший момент)
• Для кожної ваги зберігаємо експоненційно згладжений квадрат градієнта (другий момент)
• Автоматично адаптуємо learning rate: великий для параметрів із малими градієнтами, малий для параметрів із великими градієнтами

Формули:

Корекція зміщення (bias correction):

Оновлення параметрів:

Типові гіперпараметри:

• Завантаження... (learning rate)
• Завантаження... (експоненційне згасання для першого моменту)
• Завантаження... (експоненційне згасання для другого моменту)
• Завантаження... (для числової стабільності)

Переваги:

• ✅ Адаптивний learning rate для кожного параметра
• ✅ Добре працює «з коробки» без тонкого налаштування гіперпараметрів
• ✅ Ефективний для розріджених градієнтів (NLP, рекомендаційні системи)
• ✅ Швидка збіжність

Коли використовувати: за замовчуванням для більшості задач — якщо не маєте особливих причин, обирайте Adam.

Порівняльна таблиця оптимізаторів

Практичні завдання

import numpy as np

def relu(z):
    return np.maximum(0, z)

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

def forward_pass(x, layers, activations):
    """
    Прямий прохід по нейронній мережі

    Parameters:
    - x: вхідний вектор (shape: n_features)
    - layers: список (W, b) для кожного шару
    - activations: список функцій активації для кожного шару

    Returns:
    - Вихід мережі (shape: n_output)
    """
    a = x.reshape(-1, 1)  # Перетворюємо на вектор-стовпець

    for (W, b), activation in zip(layers, activations):
        z = W @ a + b
        a = activation(z)

    return a.flatten()  # Повертаємо як 1D масив

# Приклад використання
np.random.seed(42)

# Архітектура: 3 → 4 (ReLU) → 2 (ReLU) → 1 (Sigmoid)
layers = [
    (np.random.randn(4, 3) * 0.1, np.zeros((4, 1))),  # Шар 1
    (np.random.randn(2, 4) * 0.1, np.zeros((2, 1))),  # Шар 2
    (np.random.randn(1, 2) * 0.1, np.zeros((1, 1)))   # Вихідний шар
]

activations = [relu, relu, sigmoid]

# Вхід
x = np.array([0.5, 0.3, 0.8])

# Прямий прохід
output = forward_pass(x, layers, activations)

print(f"Вхід: {x}")
print(f"Вихід мережі: {output[0]:.4f}")
print(f"Інтерпретація: ймовірність класу 1 = {output[0]:.2%}")

Резюме модуля

Ключові терміни та визначення

Що далі?

У наступній статті ми познайомимося з бібліотекою PyTorch — найпопулярнішим фреймворком для побудови нейронних мереж. Ви навчитеся:

• Працювати з тензорами та графами обчислень
• Визначати моделі за допомогою nn.Module
• Використовувати вбудовані оптимізатори та функції втрат
• Навчати свою першу нейронну мережу на реальному датасеті