Как предотвратить переобучение и недообучение ваших моделей

«Регуляризация — это мощный инструмент, который может помочь вам повысить производительность ваших моделей машинного обучения». — Ян Гудфеллоу

Введение

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

Регуляризация — это метод, который можно использовать для повышения эффективности обобщения моделей машинного обучения. Регуляризация работает, добавляя штраф к функции стоимости, что препятствует тому, чтобы модель становилась слишком сложной. Это может помочь предотвратить переоснащение, которое возникает, когда модель слишком хорошо изучает обучающие данные и не может обобщать новые данные.

Оптимальный уровень регуляризации зависит от конкретной модели машинного обучения и набора данных, на котором она обучается. Перекрестная проверка может быть использована для поиска оптимального уровня регуляризации. Перекрестная проверка включает в себя разделение набора данных на обучающий набор и тестовый набор. Модель обучается на обучающем наборе, а затем оценивается на тестовом наборе. Этот процесс повторяется для разных значений гиперпараметра регуляризации. Значение гиперпараметра регуляризации, обеспечивающее наилучшую производительность на тестовом наборе, является оптимальным значением для использования.

Зачем нужна регуляризация?

Регуляризация — это подход машинного обучения, используемый для уменьшения переобучения и улучшения способности модели к обобщению. Переобучение происходит, когда модель обучается на обучающих данных настолько успешно, что запоминает данные, а не понимает лежащие в их основе закономерности и взаимосвязи. В результате модель плохо работает со свежими, ранее невиданными данными. Регуляризация предотвращает переоснащение, вводя штрафной член в функцию потерь, который не позволяет модели подгонять шум в данных.

Регуляризация для переобучения

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

«Регуляризация — это способ предотвратить переоснащение вашей модели обучающими данными». — Йошуа Бенжио

Функция стоимости и переобучение

Прежде чем мы углубимся в регуляризацию, давайте сначала определим функцию стоимости. Функция стоимости измеряет, насколько хорошо модель соответствует обучающим данным. Например, в линейной регрессии функция стоимости представляет собой среднеквадратичную ошибку между прогнозируемыми значениями и фактическими значениями.

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

Регуляризация добавляет штрафной член к функции стоимости, которая контролирует сложность модели. Штрафной срок наказывает сложные модели и поощряет более простые модели, которые с большей вероятностью хорошо обобщают невидимые данные.

Типы регуляризации

Регуляризация L1

Регуляризация L1, также известная как регуляризация Лассо, добавляет штрафной член к функции потерь, который пропорционален абсолютному значению весов. Это приводит к уменьшению некоторых весов до нуля, эффективно удаляя некоторые функции из модели. Регуляризация L1 может быть полезна при работе с многомерными наборами данных, где есть много нерелевантных или избыточных функций.

Функция стоимости для модели линейной регрессии с регуляризацией L1 определяется следующим образом:

J(θ) = 1/m * Σ(y(i) - hθ(x(i)))^2 + λ * Σ|θ|

где:

  • m — количество обучающих примеров
  • y(i) — это метка истинности для ith обучающего примера.
  • hθ(x(i)) — прогноз модели для ith обучающего примера.
  • θ - параметры модели
  • λ — гиперпараметр регуляризации

Первый член функции стоимости представляет собой обычную функцию потерь квадрата ошибки. Второй термин - это срок штрафа за регуляризацию. Этот термин штрафует за большие значения параметров модели. В результате параметры модели вынуждены быть малыми, что снижает сложность модели.

Чтобы увидеть, как регуляризация L1 влияет на параметры модели, давайте рассмотрим пример на Python:

from sklearn.linear_model import Lasso

# Load data
X, y = load_data()

# Create Lasso model
lasso = Lasso(alpha=0.1)

# Train model
lasso.fit(X, y)

# Print model coefficients
print(lasso.coef_)

В этом примере мы загружаем некоторые данные и создаем модель Lasso с альфа-параметром 0,1. Затем мы обучаем модель данным и печатаем коэффициенты модели. Модель Лассо устанавливает некоторые коэффициенты равными нулю, что приводит к разреженному решению.

«Регуляризация похожа на использование смирительной рубашки, чтобы ваша модель не стала слишком сложной». — Эндрю Нг

Регуляризация L2

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

Функция стоимости для модели линейной регрессии с регуляризацией L2 определяется следующим образом:

J(θ) = 1/m * Σ(y(i) - hθ(x(i)))^2 + λ * Σ(θ^2)

где:

  • m — количество обучающих примеров
  • y(i) — метка истинности для ith обучающего примера.
  • hθ(x(i)) — прогноз модели для ith обучающего примера.
  • θ - параметры модели
  • λ — гиперпараметр регуляризации

Первый член функции стоимости представляет собой обычную функцию потерь квадрата ошибки. Второй термин - это срок штрафа за регуляризацию. Этот термин штрафует большие значения параметров модели в квадрате. В результате параметры модели вынуждены быть близкими к нулю, что снижает сложность модели.

Чтобы увидеть, как регуляризация L2 влияет на параметры модели, давайте рассмотрим пример на Python:

from sklearn.linear_model import Ridge

# Load data
X, y = load_data()

# Create Ridge model
ridge = Ridge(alpha=0.1)

# Train model
ridge.fit(X, y)

# Print model coefficients
print(ridge.coef_)

В этом примере мы загружаем некоторые данные и создаем модель Ridge с альфа-параметром 0,1. Затем мы обучаем модель данным и печатаем коэффициенты модели. Модель Риджа поощряет меньшие значения коэффициентов, что приводит к более простой модели с меньшей вероятностью переобучения.

Регуляризация эластичной сети

Эластичная сетевая регуляризация — это метод регуляризации, сочетающий регуляризацию L1 и L2. Это может помочь улучшить производительность модели за счет уменьшения переобучения и улучшения интерпретируемости модели.

Математическое выражение для регуляризации эластичной сети выглядит следующим образом:

loss = (y - h)^2 + λ * (α * |w| + (1 - α) * w^2)

где:

  • α — параметр смешивания, который управляет относительным весом регуляризации L1 и L2.
from sklearn.linear_model import ElasticNet

# Create a model with Elastic Net regularization.
model = ElasticNet(alpha=0.5, l1_ratio=0.5)

# Train the model.
model.fit(x_train, y_train)

# Make predictions.
y_pred = model.predict(x_test)

Этот код будет обучать модель с регуляризацией Elastic Net. Параметр alpha управляет количеством регуляризации, а параметр l1_ratio управляет отношением регуляризации L1 к L2.

Регуляризация эластичной сети представляет собой комбинацию регуляризации L1 и L2. Регуляризация L1, также известная как Лассо, штрафует сумму абсолютных значений коэффициентов. Регуляризация L2, также известная как Ridge, штрафует сумму квадратов коэффициентов.

Регуляризация эластичной сети может использоваться для предотвращения переобучения в моделях линейной регрессии. Переобучение происходит, когда модель слишком хорошо изучает обучающие данные и не может обобщать новые данные. Регуляризация эластичной сети помогает предотвратить переоснащение, добавляя штраф к функции потерь, который наказывает модель за большие коэффициенты.

Параметры alpha и l1_ratio можно настроить, чтобы найти наилучшее сочетание регуляризации и точности. Хорошей отправной точкой является использование альфа 0,5 и l1_ratio 0,5. Если модель все еще переоснащается, вы можете увеличить альфа-параметр. Если модель недостаточно хорошо обучается, вы можете уменьшить альфа-параметр.

Вы также можете использовать перекрестную проверку, чтобы найти наилучшее сочетание параметров alpha и l1_ratio. Перекрестная проверка — это метод оценки производительности модели на данных, которые она раньше не видела.

Вот пример того, как использовать перекрестную проверку, чтобы найти наилучшую комбинацию параметров alpha и l1_ratio:

from sklearn.model_selection import cross_val_score

# Create a list of alpha values to try.
alphas = [0.1, 0.5, 1.0]

# Create a list of l1_ratio values to try.
l1_ratios = [0.1, 0.5, 1.0]

# Create a list to store the cross-validation scores.
scores = []

# Loop over the alpha values.
for alpha in alphas:

    # Loop over the l1_ratio values.
    for l1_ratio in l1_ratios:

        # Create a model with the current alpha and l1_ratio values.
        model = ElasticNet(alpha=alpha, l1_ratio=l1_ratio)

        # Calculate the cross-validation score.
        score = cross_val_score(model, x_train, y_train, cv=5)

        # Store the cross-validation score.
        scores.append(score)

# Find the best alpha and l1_ratio values.
best_alpha = alphas[scores.index(max(scores))]
best_l1_ratio = l1_ratios[scores.index(max(scores))]

# Create a model with the best alpha and l1_ratio values.
model = ElasticNet(alpha=best_alpha, l1_ratio=best_l1_ratio)

# Train the model.
model.fit(x_train, y_train)

# Make predictions.
y_pred = model.predict(x_test)

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

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

Выбывать

Dropout — это метод регуляризации, который случайным образом выбрасывает (или «отключает») некоторые нейроны в нейронной сети во время обучения. Это означает, что выход этих нейронов равен нулю, и они не участвуют в прямом или обратном проходе сети.

Идея отсева заключается в том, что он заставляет сеть изучать более надежные функции, не позволяя одному нейрону слишком сильно полагаться на любой другой нейрон. Это может помочь предотвратить переоснащение и повысить эффективность обобщения сети.

J(θ) = E[(1 - p)L(θ, x, y)]

где:

  • J(θ) - функция потерь
  • θ — параметры модели
  • p — процент отсева
  • L(θ, x, y) — функция потерь для одной точки данных.

Член регуляризации отсева (1 — p) наказывает функцию потерь за чрезмерное использование любого отдельного нейрона. Это заставляет модель учиться использовать все нейроны вместе, что делает ее более устойчивой к переоснащению.

Показатель отсева — это гиперпараметр, который должен выбирать пользователь. Хорошей отправной точкой является использование коэффициента отсева 0,5. Если модель все еще переоснащается, вы можете увеличить процент отсева. Если модель недостаточно хорошо обучается, вы можете уменьшить процент отсева.

Давайте посмотрим на математическое доказательство отсева. Во время обучения мы случайным образом отбрасываем часть нейронов с вероятностью p. Это означает, что выход каждого нейрона умножается на бинарную матрицу маски m, где каждый элемент матрицы равен либо 0, либо 1 с вероятностью p и 1-p соответственно. Ожидаемое значение m равно 1-p.

Во время тестирования мы не отбрасываем ни одного нейрона и используем полную сеть для предсказания.

import keras

class DropoutRegularization(keras.layers.Layer):

    def __init__(self, rate):
        super(DropoutRegularization, self).__init__()
        self.rate = rate

    def call(self, inputs):
        # Randomly drop out neurons with probability `rate`.
        dropout_mask = keras.backend.random_uniform(
            shape=inputs.shape,
            dtype=inputs.dtype,
            minval=0.0,
            maxval=1.0
        ) < self.rate

        # Set the dropped out neurons to zero.
        inputs *= dropout_mask

        return inputs

Функция стоимости для нейронной сети с отсевом:

J(w) = (1/m) * (sum(L(y_i, f(x_i, w, m))) + lambda * sum(w^2))

где:

  • w — вектор параметров модели
  • f(x, w, m) - это выход сети с входом x
  • m — бинарная матрица маски
  • L(y, y_hat) - функция потерь
  • lambda — параметр регуляризации.

Первый член функции стоимости — это средняя потеря по всем обучающим примерам, а второй член — член регуляризации L2. Член регуляризации поощряет меньшие значения параметров модели, добавляя штраф, пропорциональный квадрату каждого параметра. Параметр лямбда контролирует силу регуляризации.

Чтобы увидеть, как отсев влияет на производительность нейронной сети, давайте рассмотрим пример на Python:

import tensorflow as tf

# Define a neural network with dropout
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(10)
])

# Compile the model with a loss function and optimizer
model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              optimizer=tf.keras.optimizers.Adam(),
              metrics=['accuracy'])

# Train the model with dropout
history = model.fit(train_images, train_labels, epochs=10,
                    validation_data=(test_images, test_labels))

В этом примере мы определяем нейронную сеть с выпадающим слоем, который выбрасывает 50% нейронов. Затем мы компилируем модель с функцией потерь и оптимизатором и обучаем ее набору данных. Слой отсева помогает предотвратить переобучение и улучшить производительность сети при обобщении.

Регуляризация недообучения

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

Регуляризацию также можно использовать для предотвращения недообучения, добавляя штрафной член к функции потерь, который побуждает модель изучать более сложные функции. Срок штрафа наказывает простые модели и поощряет более сложные модели, которые лучше подходят для данных.

Вы также можете создать функцию, которую можно использовать для предотвращения недообучения:

def regularized_linear_regression(x, y, λ):
  """
  Performs regularized linear regression.

  Args:
    x: The training data.
    y: The target data.
    λ: The regularization hyperparameter.

  Returns:
    The model's parameters.
  """

  # Initialize the model's parameters.
  θ = np.zeros(x.shape[1])

  # Calculate the loss function.
  J = 1 / len(x) * np.sum((y - θ.T @ x)**2) + λ * np.sum(θ**2)

  # Calculate the gradient of the loss function.
  ∇J = -1 / len(x) * np.sum(x * (y - θ.T @ x)) + 2λθ

  # Update the model's parameters using gradient descent.
  θ = θ - η * ∇J

  # Return the model's parameters.
  return θ

Математическое доказательство того, как регуляризация помогает предотвратить недообучение, выглядит следующим образом:

Рассмотрим модель линейной регрессии со следующей функцией потерь:

J(θ) = 1/n * Σ(y - θ^T x)^2

где:

  • θ — параметры модели
  • x - данные обучения
  • y — это целевые данные.

Градиент этой функции потерь по θ равен:

∇J(θ) = -1/n * Σ(x(y - θ^T x))

К этой функции потерь можно добавить регуляризацию, добавив штрафной член к сумме квадратов параметров модели:

J(θ) = 1/n * Σ(y - θ^T x)^2 + λ * Σθ^2

где λ — гиперпараметр регуляризации. Градиент этой функции потерь по θ равен:

∇J(θ) = -1/n * Σ(x(y - θ^T x)) + 2λθ

Член регуляризации побуждает параметры модели быть меньше, что может помочь предотвратить переоснащение. Однако, если срок регуляризации слишком велик, это также может привести к недообучению. Оптимальное значение гиперпараметра регуляризации λ необходимо настроить на обучающих данных.

В приведенной выше функции Python гиперпараметр регуляризации λ используется для управления степенью регуляризации, применяемой к модели. Чем больше значение λ, тем больше применяется регуляризация и тем больше вероятность того, что модель будет неадекватной. Чем меньше значение λ, тем меньше применяется регуляризация и тем больше вероятность переобучения модели.

Оптимальное значение λ необходимо настроить на обучающих данных. Это можно сделать с помощью метода перекрестной проверки, такой как перекрестная проверка в k-кратном порядке. K-кратная перекрестная проверка включает в себя разделение обучающих данных на k кратностей. Затем модель обучается на k-1 сгибах и оценивается на оставшемся сгибе. Этот процесс повторяется k раз, и средняя производительность модели используется для выбора оптимального значения λ.

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

Функция стоимости для линейной регрессии с регуляризацией L2:

J(w) = (1/2m) * (sum((h(x_i) - y_i)^2)) + (lambda/2m) * (sum(w_j^2))

где:

  • w — вектор параметров модели
  • h(x) - прогнозируемое значение для ввода x
  • y - фактическое выходное значение
  • m количество обучающих примеров
  • lambda — параметр регуляризации.

Первый член функции стоимости представляет собой среднеквадратичную ошибку между прогнозируемыми и фактическими значениями, а второй член представляет собой штрафной член L2. Член штрафа L2 поощряет меньшие значения параметров модели, добавляя штраф, пропорциональный квадрату каждого параметра. Параметр лямбда контролирует силу регуляризации.

Чтобы увидеть, как регуляризация L2 влияет на параметры модели, давайте рассмотрим пример на Python:

import numpy as np

# Generate some sample data
np.random.seed(0)
X = np.random.rand(100, 1)
y = 5 * X + np.random.randn(100, 1)

# Add polynomial features
from sklearn.preprocessing import PolynomialFeatures
poly = PolynomialFeatures(degree=3, include_bias=False)
X_poly = poly.fit_transform(X)

# Train a linear regression model with L2 regularization
from sklearn.linear_model import Ridge
ridge = Ridge(alpha=1.0)
ridge.fit(X_poly, y)

# Plot the results
import matplotlib.pyplot as plt
plt.scatter(X, y, color='blue')
plt.plot(X, ridge.predict(X_poly), color='red')
plt.show()

В этом примере мы генерируем некоторые образцы данных и добавляем к входным данным полиномиальные функции. Затем мы обучаем модель линейной регрессии с регуляризацией L2, используя класс Ridge из scikit-learn. Параметр альфа управляет силой регуляризации. Наконец, мы наносим результаты на график, чтобы увидеть, как регуляризация влияет на модель.

Заключение

«Регуляризация — это метод, о котором стоит узнать, если вы серьезно относитесь к машинному обучению». — Орельен Жерон

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

Методы регуляризации, такие как регуляризация L1 и L2, а также отсев, доказали свою эффективность в предотвращении переобучения и недообучения. Эти методы добавляют к функции стоимости штрафной член, который побуждает модель изучать более надежные функции и избегать чрезмерной зависимости от какой-либо отдельной функции.

Регуляризация — важный инструмент в вашем наборе инструментов машинного обучения, независимо от того, работаете ли вы с распознаванием изображений, обработкой естественного языка или прогнозной аналитикой. Это может помочь вам построить более точные и обобщающие модели, которые могут делать более точные прогнозы и улучшать бизнес-результаты.

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

Спасибо, что прочитали мою запись в блоге Регуляризация: ключ к созданию лучших моделей машинного обучения. Надеюсь, вы нашли ее информативной и полезной. Если у вас есть какие-либо вопросы или отзывы, пожалуйста, не стесняйтесь оставлять комментарии ниже.

Я также рекомендую вам ознакомиться с моим портфолио и GitHub. Вы можете найти ссылки на оба в описании ниже.

Я всегда работаю над новыми и интересными проектами, поэтому не забудьте подписаться на мой блог, чтобы ничего не пропустить!

Еще раз спасибо за чтение, и я надеюсь увидеть вас в следующий раз!

[Ссылка на портфолио] [Ссылка на Github]