2. Método de optimización: descenso de gradiente (BGD, SGD, Min_BGD)

Uno, función de pérdida

La función de pérdida se usa generalmente para estimar el valor predicho del modelo f (x) f (x)El grado de inconsistencia entre$f$$($$x$$)$ y el valor verdadero Y. Es una función de valor real no negativo, donde$L(Y,f(x\left)\right)$ significa. Cuanto menor sea el valor de la pérdida, mejor será la solidez del modelo.

La función de pérdida es la parte central de la función de riesgo empírico y una parte importante de la función de riesgo estructural.

La función de riesgo resultante del modelo incluye términos de riesgo empíricos y términos regulares, que generalmente se expresan de la siguiente manera:

1.1 Función de pérdida cuadrática media

Usando el método de mínimos cuadrados, el principio básico es que la curva de mejor ajuste debe minimizar la distancia desde todos los puntos a la línea de regresión. La distancia euclidiana se usa generalmente para medir la distancia. La función de pérdida de la pérdida cuadrática media es la siguiente:
$$L(Y|f\left(X\right))=\sum (Y-f\left(X\right){)}^2$$

1.2 función de pérdida de registro de registro

La función de pérdida de regresión logística es la función de pérdida logarítmica.

$$L(Y|f\left(X\right))=-logP(Y|X)$$

1.3 Función de pérdida exponencial

AdaBoost es la función de pérdida exponencial. Su forma estándar es la siguiente:
$$L(Y|f\left(X\right))=exp[-yf\left(x\right)]$$

Dos, método de optimización

El problema de optimización se refiere a la función objetivo dada $L(Y|f\left(X\right))$ , necesitamos encontrar un conjunto de parámetros X tal que$El\; valor\; de\; L(Y|f\left(X\right))$ es el más pequeño. En el entorno del aprendizaje automático, hay tres formas de descenso de gradiente, a saber: descenso de gradiente por lotes (BGD), descenso de gradiente estocástico (SGD) y descenso de gradiente por mini lotes (Min_BGD).

2.1 Descenso de gradiente por lotes (BGD)

La idea básica: la forma más primitiva del método de descenso de gradiente, su idea específica es que al actualizar cada parámetro, todas las muestras se utilizan para actualizar.

Ventajas: solución óptima global, fácil de implementar en paralelo;

Desventajas: cuando el número de muestras es grande, el proceso de formación será muy lento.

Asunto: El tamaño de la muestra es relativamente pequeño.

import numpy as np
import matplotlib.pyplot as plt

def BGD(x_vals, y_vals):

    alpha = 0.001  # 步长
    loop_max = 100     # 迭代次数
    theta = np.random.randn(2)  # 存储 权重、偏移量
    m = len(x_vals)
    b = np.full(m, 1.0)
    x_vals = np.vstack([b, x_vals]).T
    error = np.zeros(2)
    for i in range(loop_max):
        sum_m = np.zeros(2)
        for j in range(m):
            dif = (np.matmul(theta, x_vals[j]) - y_vals[j]) * x_vals[j]
            sum_m = sum_m + dif
        theta = theta - alpha * sum_m
        if np.linalg.norm(theta - error) < 0.001:
            break
        else:
            error = theta
        print('loop count = %d' % i, '\t theta:',theta)
    return theta

if __name__ == '__main__':
    np.random.seed(0)
    # iris = datasets.load_iris()
    # x_vals = np.array([x[3] for x in iris.data])
    # y_vals = np.array([y[0] for y in iris.data])
    x_vals = np.arange(0., 10., 0.2)
    y_vals = 2 * x_vals + 5 + np.random.randn(len(x_vals))
    theta = BGD(x_vals, y_vals)

    #  画图
    plt.plot(x_vals, y_vals, 'g*')
    plt.plot(x_vals, theta[1] * x_vals + theta[0], 'r')
    plt.show()

2.2 Descenso de gradiente estocástico (SGD)

La idea básica: en cada iteración, se actualiza una muestra.

Ventajas: velocidad de entrenamiento rápida;

Desventajas: Precisión reducida, no óptima global; no es fácil de implementar en paralelo.

Objeto: el número de muestras es demasiado grande o es un algoritmo en línea.

import numpy as np
import matplotlib.pyplot as plt

def SGD(x_vals, y_vals):

    alpha = 0.01  # 步长
    loop_max = 100     # 迭代次数
    theta = np.random.randn(2)  # 存储 权重、偏移量
    m = len(x_vals)
    b = np.full(m, 1.0)
    x_vals = np.vstack([b, x_vals]).T
    error = np.zeros(2)
    np.random.seed(0)
    for i in range(loop_max):

        for j in range(m):
            dif = np.matmul(theta, x_vals[j]) - y_vals[j]
            theta = theta - alpha * dif * x_vals[j]

        if np.linalg.norm(theta - error) < 0.001:
            break
        else:
            error = theta

        print('loop count = %d' % i, '\t theta:',theta)
    return theta

if __name__ == '__main__':

    x_vals = np.arange(0., 10., 0.2)
    y_vals = 2 * x_vals + 5 + np.random.randn(len(x_vals))

    theta = SGD(x_vals, y_vals)

    #  画图
    plt.plot(x_vals, y_vals, 'g*')
    plt.plot(x_vals, theta[1] * x_vals + theta[0], 'r')
    plt.show()

2.3 Descenso de gradiente de lotes pequeños (Min_BGD)

Idea básica: combinando las ideas de BGD y SGD, use una parte de los datos para la operación BGD en cada iteración.

Ventajas: para superar las deficiencias de los dos métodos anteriores, teniendo en cuenta las ventajas de ambos métodos;

Objeto: . En la situación general actual.

import numpy as np
import matplotlib.pyplot as plt

def min_batch(x_vals, y_vals):

    alpha = 0.01  # 步长
    loop_max = 100     # 迭代次数
    batch_size=5
    theta = np.random.randn(2)  # 存储 w、b
    m = len(x_vals)

    b = np.full(m, 1.0)
    x_vals = np.vstack([b, x_vals]).T

    error = np.zeros(2)
    np.random.seed(0)
    for j in range(loop_max):
        for i in range(1,m,batch_size):
            sum_m = np.zeros(2)
            for k in range(i-1,i+batch_size-1,1):
                dif = (np.dot(theta, x_vals[k]) - y_vals[k]) *x_vals[k]
                sum_m = sum_m + dif
            theta = theta- alpha * (1.0/batch_size) * sum_m

        if np.linalg.norm(theta - error) < 0.001:
            break
        else:
            error = theta

        print('loop count = %d' % j, '\t theta:',theta)
    return theta

if __name__ == '__main__':

    x_vals = np.arange(0., 10., 0.2)
    y_vals = 2 * x_vals + 5 + np.random.randn(len(x_vals))

    theta = min_batch(x_vals, y_vals)

    #  画图
    plt.plot(x_vals, y_vals, 'g*')
    plt.plot(x_vals, theta[1] * x_vals + theta[0], 'r')
    plt.show()