Зачем нужны дифференцируемые в нуле функции?

Зачем нужны дифференцируемые в нуле функции?

Дифференцируемость в нуле — это ключевое свойство активационных функций в нейронных сетях и функций потерь. Давайте разберём, почему это критически важно.

Контекст: Обучение нейронных сетей

Для обучения нейронной сети используется gradient descent — алгоритм, который движется по градиенту функции потерь. Градиент — это производная функции потерь по параметрам модели.

Δw = -learning_rate * ∂L/∂w

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

Проблема: Недифференцируемые функции

Пример 1: ReLU (Rectified Linear Unit) в нуле

import numpy as np
import matplotlib.pyplot as plt

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

def relu_derivative(x):
    return np.where(x > 0, 1, 0)  # Проблема в x=0!

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

• При x > 0: производная ReLU = 1
• При x < 0: производная ReLU = 0
• При x = 0: производная НЕ определена (разрыв!)

Это называется угловой точкой или кинк (kink).

Почему это важно?

Если функция не дифференцируема в точке, градиент там не определён, и оптимизатор не знает, в какую сторону двигаться.

Решение: ReLU на практике

ReLU работает, несмотря на недифференцируемость в нуле, потому что:

1. Вероятность попасть точно в ноль ничтожна при случайной инициализации
2. Оптимизатор использует субградиент — обобщение производной для недифференцируемых функций

Дифференцируемые альтернативы

Если нужна полная дифференцируемость везде:

1. Sigmoid

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

def sigmoid_derivative(x):
    s = sigmoid(x)
    return s * (1 - s)  # Дифференцируема везде!

2. Tanh

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

def tanh_derivative(x):
    return 1 - np.tanh(x)**2  # Дифференцируема везде!

3. ELU (Exponential Linear Unit)

ELU дифференцируема везде, включая x=0, и переходит плавно.

4. Swish (современный стандарт)

def swish(x):
    return x * sigmoid(x)  # Дифференцируема везде

Практическое сравнение

import tensorflow as tf
from tensorflow.keras.layers import Dense
from tensorflow.keras.models import Sequential
import numpy as np

X_train = np.random.randn(1000, 10)
y_train = np.random.randint(0, 2, (1000,))

# Модель с ReLU (недифференцируема в нуле, но работает)
model_relu = Sequential([
    Dense(64, activation='relu'),
    Dense(32, activation='relu'),
    Dense(1, activation='sigmoid')
])
model_relu.compile(optimizer='adam', loss='binary_crossentropy')
model_relu.fit(X_train, y_train, epochs=5, verbose=0)

# Модель с Sigmoid (везде дифференцируема)
model_sigmoid = Sequential([
    Dense(64, activation='sigmoid'),
    Dense(32, activation='sigmoid'),
    Dense(1, activation='sigmoid')
])
model_sigmoid.compile(optimizer='adam', loss='binary_crossentropy')
model_sigmoid.fit(X_train, y_train, epochs=5, verbose=0)

Зачем нужна дифференцируемость в нуле конкретно?

1. Для функций потерь

Функции потерь должны быть дифференцируемы везде:

def mse(y_true, y_pred):
    return np.mean((y_true - y_pred) ** 2)

def mse_derivative(y_true, y_pred):
    return 2 * (y_pred - y_true)  # Определена везде

2. Для активационных функций в скрытых слоях

Они должны быть гладкими, чтобы градиент мог распространяться через сеть (backpropagation).

3. Для оптимизаторов

Адам, SGD и другие оптимизаторы полагаются на первые и вторые производные.

Практический вывод

Модерный стандарт: ReLU работает, несмотря на недифференцируемость, потому что:

• Вероятность попадания в точку разрыва минимальна
• Оптимизаторы используют субградиенты
• Производная везде рядом с нулём определена

Вывод

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

1. ReLU работает, несмотря на недифференцируемость в нуле
2. Sigmoid везде дифференцируема, но обучается медленнее
3. Современные функции (Swish, ELU) объединяют лучшее: дифференцируемость + быстрое обучение

Для оптимизации градиентными методами нужна гладкость функции, но небольшие недифференцируемости на практике не критичны.