Методы регуляризации для моделей машинного обучения

Введение

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

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

Взяв этот график, чтобы лучше визуализировать утверждение:

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

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

Чтобы продолжить, давайте сначала разберемся в этом методе — «регуляризации».

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

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

Методы регуляризации:

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

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

Приведенная ниже функция вычисляет ошибку/потери без функции регуляризации.

функция, которая может вычислять ошибку с функцией регуляризации L1,

функция, которая может вычислять ошибку сфункцией регуляризации L2,

Зная формулы этих двух подметодов (L1 и L2), мы узнаем, что регуляризация L1 дает выходные данные в двоичных весах от 0 до 1 для признаков модели и используется для уменьшения количества признаков в огромных размерностях. наборы данных. Регуляризация второго уровня распределяет погрешности по всем весам, что приводит к более точным настраиваемым окончательным моделям.

Реализация кода L2:

В этом примере мы рассчитаем градиентный спуск с регуляризацией L2.

давайте рассмотрим этот файл l2_reg_gradient_descent.py

#!/usr/bin/env python3
"""
Gradient Descent with L2 Regularization
"""
import numpy as np
def tanh(Z):
    """
    Method:
        Computes the Hyperbolic Tagent of Z elemnet-wise.
    Parameters:
        @Z (array): output of affine transformation.
    Returns:
        A (array): post activation output.
    """
   A = np.tanh(Z)
   return A
def l2_reg_gradient_descent(Y, weights, cache, alpha, lambtha, L):
    """
    Method:
        updates the weights and biases of a neural network using gradient descent with L2 regularization.
    Parameters:
       @Y: a one-hot that contains the correct labels for the data.
       @weights: a dictionary of the weights and biases.
        @cache: a dictionary of the outputs of each layer of the neural network
        @alpha: the learning rate
        @lambtha: the L2 regularization parameter
        @L: the number of layers of the network
    """
    # Number of trainings
    m = Y.shape[1]
    # Initialization for backpropagation algorithm
    dZ = cache['A' + str(L)] - Y
    for i in range(L, 0, -1):
     # dW is the Derivative of the cost function w.r.t W of the current layer
    dW = (np.matmul(dZ, cache['A' + str(i - 1)].T)) / m
    # db is the Derivative of the cost function w.r.t b of the current layer
    db = (np.sum(dZ, axis=1, keepdims=True)) / m
    # dA is the Derivative of the cost function w.r.t A (cache) of the current layer
    dA = 1 - np.square(cache['A' + str(i - 1)])
    # dZ is the Derivative of the cost function w.r.t Z of the current layer
    dZ = np.multiply(np.matmul(weights['W' + str(i)].T, dZ), dA)
    # Updating weight matrix and the bias vector for each layer
    reg_term = 1 - ((alpha * lambtha) / m)
    weights['W' + str(i)] = reg_term * weights['W' + str(i)] - alpha * dW
    weights['b' + str(i)] = weights['b' + str(i)] - alpha * db

файл main.py

#!/usr/bin/env python3
import numpy as np
l2_reg_gradient_descent = __import__('1-l2_reg_gradient_descent').l2_reg_gradient_descent
def one_hot(Y, classes):
    """convert an array to a one-hot matrix"""
    m = Y.shape[0]
    one_hot = np.zeros((classes, m))
    one_hot[Y, np.arange(m)] = 1
    return one_hot
if __name__ == '__main__':
    lib= np.load('../data/MNIST.npz')
    X_train_3D = lib['X_train']
    print(X_train_3D.shape)
    Y_train = lib['Y_train']
    X_train = X_train_3D.reshape((X_train_3D.shape[0], -1)).T
    Y_train_oh = one_hot(Y_train, 10)
    np.random.seed(0)
    
    weights = {}
    weights['W1'] = np.random.randn(256, 784)
    print(weights['W1'].shape)
    weights['b1'] = np.zeros((256, 1))
    weights['W2'] = np.random.randn(128, 256)
    weights['b2'] = np.zeros((128, 1))
    weights['W3'] = np.random.randn(10, 128)
    weights['b3'] = np.zeros((10, 1))
    cache = {}
    cache['A0'] = X_train
    cache['A1'] = np.tanh(np.matmul(weights['W1'], cache['A0']) +     weights['b1'])
    cache['A2'] = np.tanh(np.matmul(weights['W2'], cache['A1']) +    weights['b2'])
    Z3 = np.matmul(weights['W3'], cache['A2']) + weights['b3']
   cache['A3'] = np.exp(Z3) / np.sum(np.exp(Z3), axis=0)
   print(weights['W1'])
    l2_reg_gradient_descent(Y_train_oh, weights, cache, 0.1, 0.1, 3)
    print(weights['W1'])

• Выбывать

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

Другими словами, он основан на стохастическом выпадении нейронов во время обучения.

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

Формула расчета сети без Dropout:

Используя формулу расчета сети Dropout:

• Увеличение данных

Этот метод отличается от предыдущих тем, что он не добавляет термины и не применяет какую-либо вероятность к слоям, а вместо этого добавляет больше данных в обучающие наборы для повышения производительности модели!

• Ранняя остановка

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

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

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

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

Чтобы узнать больше о кодировании, загляните в мой каталог GitHub, чтобы узнать о Регуляризация, Ссылка на GitHub.