Сколько слоев в многослойном перцептроне с линейной функцией активации нужно, чтобы апроксимировать полином третьей степени?

Сколько слоёв нужно для аппроксимации полинома третьей степени

Это классический вопрос о выразительной способности нейронных сетей и их связи с полиномиальными функциями. Ответ зависит от того, какую функцию активации мы используем.

Ключевой инсайт: Линейная активация

Линейная функция активации — это просто f(x) = ax + b. Это решающий момент!

Математический факт: Композиция линейных функций всегда даёт линейную функцию:

# Слой 1: y1 = a1*x + b1
# Слой 2: y2 = a2*y1 + b2 = a2*(a1*x + b1) + b2 = (a2*a1)*x + (a2*b1 + b2)

# Результат: линейная функция!
# Независимо от количества слоёв

Математически:

Сложение линейных функций = линейная функция
Умножение линейных функций = линейная функция

Парадоксальный ответ

Ответ: НЕВОЗМОЖНО

Многослойный перцептрон с ТОЛЬКО линейными функциями активации может выразить только линейные функции, независимо от количества слоёв и нейронов.

import numpy as np
import matplotlib.pyplot as plt

# Попытаемся аппроксимировать полином 3-й степени: y = x^3
x = np.linspace(-2, 2, 100)
y_true = x**3  # Полином третьей степени

# МЛП с только линейной активацией
def mlp_linear(x, weights_1, bias_1, weights_2, bias_2, weights_3, bias_3):
    # Слой 1
    h1 = weights_1 @ x + bias_1
    # Слой 2
    h2 = weights_2 @ h1 + bias_2
    # Слой 3 (выход)
    y = weights_3 @ h2 + bias_3
    return y

# При любых весах это сводится к: y = a*x + b (линейная!)
# Никогда не получим y = x^3

Почему это так

Теория: Теорема Колмогорова–Арнольда и результаты о выразительной способности нейронных сетей показывают:

1. Без скрытых нейронов: вход → выход (однослойный = линейный)
2. Со скрытыми слоями, но только линейная активация: всё равно линейный
3. Нужна нелинейная активация: ReLU, Sigmoid, Tanh и т.п.

Правильный подход: Нелинейная активация

Чтобы аппроксимировать полином третьей степени, НЕОБХОДИМО использовать нелинейные функции активации.

С ReLU или Sigmoid:

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

# Сеть с нелинейной активацией
model = Sequential([
    layers.Dense(64, activation='relu', input_shape=(1,)),  # Нелинейность!
    layers.Dense(32, activation='relu'),                    # Нелинейность!
    layers.Dense(1)  # Линейный выход
])

model.compile(optimizer='adam', loss='mse')
model.fit(x, y_true, epochs=100)

# Результат: модель успешно аппроксимирует x^3

Минимальное количество слоёв для полинома n-й степени

Теоретический результат:

1. Полином степени 1 (линейный): 1 слой (без скрытых)
   y = ax + b

2. Полином степени 2 (квадратичный): 2-3 слоя
   y = ax^2 + bx + c
   (1 скрытый слой с нелинейностью)

3. Полином степени 3 (кубический): 3-4 слоя
   y = ax^3 + bx^2 + cx + d
   (2 скрытых слоя с нелинейностью)

4. Полином степени n: примерно n слоёв

Практический пример для полинома третьей степени:

import numpy as np
from tensorflow.keras import Sequential, layers

# Данные
x_train = np.linspace(-10, 10, 1000).reshape(-1, 1)
y_train = x_train**3 + 2*x_train**2 - 5*x_train + 3

# Минимальная архитектура для полинома 3-й степени
model = Sequential([
    layers.Dense(10, activation='relu', input_shape=(1,)),     # Слой 1
    layers.Dense(10, activation='relu'),                       # Слой 2
    layers.Dense(1)                                            # Выход (линейный)
])

model.compile(optimizer='adam', loss='mse')
history = model.fit(x_train, y_train, epochs=200, verbose=0)

# Проверка на тестовых данных
x_test = np.array([[-5], [0], [5], [7]])
y_pred = model.predict(x_test, verbose=0)
y_true_test = x_test**3 + 2*x_test**2 - 5*x_test + 3

print("Истинные значения:")
print(y_true_test.flatten())
print("\nПредсказанные значения:")
print(y_pred.flatten())

Универсальная аппроксимация

Теорема универсальной аппроксимации (Universal Approximation Theorem):

Сеть с одним скрытым слоем и нелинейной активацией (ReLU, Sigmoid, Tanh) может аппроксимировать любую непрерывную функцию с произвольной точностью при достаточном количестве нейронов.

# Теоретически достаточно одного скрытого слоя
model = Sequential([
    layers.Dense(1000, activation='relu'),  # Достаточно нейронов
    layers.Dense(1)                         # Выход
])

Однако в практике:

• Глубокие сети (много слоёв) часто эффективнее
• Они требуют меньше нейронов для такой же точности
• Легче обучаются (благодаря иерархическим представлениям)

Сравнение архитектур для полинома y = x³

# Архитектура 1: Один скрытый слой (теория)
model_1 = Sequential([
    layers.Dense(100, activation='relu', input_shape=(1,)),
    layers.Dense(1)
])  # 100 нейронов в скрытом слое

# Архитектура 2: Два скрытых слоя (практика)
model_2 = Sequential([
    layers.Dense(10, activation='relu', input_shape=(1,)),
    layers.Dense(10, activation='relu'),
    layers.Dense(1)
])  # Всего 20 нейронов, но эффективнее!

# Архитектура 3: Три скрытых слоя (глубокая сеть)
model_3 = Sequential([
    layers.Dense(8, activation='relu', input_shape=(1,)),
    layers.Dense(8, activation='relu'),
    layers.Dense(8, activation='relu'),
    layers.Dense(1)
])  # Всего 24 нейрона, очень эффективно

Резюме: Ответ на вопрос

Главный вывод: На вопрос "с линейной активацией" ответ — это невозможно по математическим причинам. Композиция линейных функций всегда линейна. Нужна нелинейная активация (ReLU, Sigmoid, Tanh).