"Aprendizaje automático" de Andrew Ng: implementación de código de regresión lineal

Los conjuntos de datos y los archivos fuente se pueden obtener en el proyecto Github.

Dirección: https://github.com/Raymond-Yang-2001/AndrewNg-Machine-Learing-Homework

1. Regresión lineal univariada

La regresión lineal univariada encuentra una ecuación unidimensional y se ajusta a una línea recta.

Fórmula de regresión lineal univariante

$$h_{w,}\left(X\right)=b+wx$$
$w$ y$b$ es un parámetro. Para facilitar el cálculo, puede dar$x$ más un$X_{}=1$
$$h_{w,}\left(X\right)=b{x}_{}+ancho{x}_{}$$

función de pérdida

$$J(w,b)=\frac{}{2m\_\_}\sum _{yo=1}\left(h_{w,}\right(X^{\left(i\right)})-y^{\left(i\right)}{)}^2$$
Para evitar pérdidas excesivas o pequeñas causadas por rangos de datos inadecuados (por ejemplo, si el valor de los datos es demasiado grande, la pérdida puede ser$10^5$ o$10^6$ , este orden de magnitud no es adecuado para un análisis intuitivo) Al evaluar la pérdida, puede hw$h_{w,}\left(X^{\left(yo\right)}\right)$sumy$y^{\left(i\right)}$ Primero estandarizar para que el valor de la pérdida esté dentro de un rango evaluable. Pero esto no se hace cuando se hace un descenso de gradiente.

Algoritmo de optimización: descenso de gradiente por lotes (BGD)

$$w_{}=w_{}-a\frac{}{\partial w_{}}J(w,b)=w_{}-a\frac{}{metro}\sum _{yo=1}\left(h_{w,}\right(X^{\left(i\right)})-y^{\left(yo\right)})x^{\left(i\right)}$$
$$b_{}=b_{}-a\frac{}{\partial {segundo}_{}}J(w,b)=w_{}-a\frac{}{metro}\sum _{yo=1}\left(h_{w,}\right(X^{\left(i\right)})-y^{\left(i\right)})$$
Aquí, podemos usar$\theta$ parámetros de identificación unificados, incluido$w$ y$b$ .

Es decir, $j$ parámetros$i_{}$Determine lo siguiente:
$$i_{}=i_{}-a\frac{}{\partial w_{}}J(\theta ;X)=w_{}-a\frac{}{metro}\sum _{yo=1}\left(h_{}\right(X^{\left(i\right)})-y^{\left(yo\right)})x^{\left(i\right)}$$
donde$\alpha$ es la tasa de aprendizaje.

2. Regresión lineal multivariable

La regresión lineal multivariable intenta encontrar la relación entre múltiples variables y los valores predichos. Por ejemplo, la relación entre el tamaño de la casa, el número de dormitorios de una casa y los precios de la vivienda.

Escalado de características (normalización)

Cuando las diferencias numéricas entre las diferentes características de la muestra son demasiado grandes, los métodos de optimización basados ​​​​en gradientes tendrán algunos problemas. Por ejemplo, existe la siguiente ecuación de regresión:
$$h_{}\left(X\right)=i_{}+i_{}{X}_{}+i_{}{X}_{}$$
Supongamos $X_{}$El rango es $0\sim 1$ ,$X_{}$El rango es $10^3\sim 10^4$ . Optimizamos simultáneamente$i_{}\sim i_{}$, de modo que todas cambien en el mismo tamaño, entonces obviamente cuando las muestras de entrada son iguales, $i_{}$El cambio será mayor que $i_{}$cambios que conduzcan a una mayor producción. Esto también puede entenderse como el par de modelos $i_{}$Más sensible. Como se muestra en el siguiente diagrama de isolíneas de pérdida, $i_{}$Pequeños cambios pueden traer cambios drásticos en las pérdidas. En este caso, la optimización de los parámetros será más difícil.

Una forma de resolver este problema es el escalado de funciones, que escala dos funciones al mismo rango. Por ejemplo, se puede realizar la normalización del puntaje z:
$$X_{nuevo\_}=\frac{X-}{pag}$$
Entre ellos, $\mu$ es la media del conjunto de datos,$\sigma$ es la desviación estándar y la distribución de datos nuevos es una distribución con media 0 y desviación estándar 1.
El diagrama de pérdida de parámetros después de la normalización de datos es el siguiente:

Escalado inverso de parámetros.

Dado que los datos están escalados, los parámetros finales también se escalarán en consecuencia. La relación específica es la siguiente:
$$i_{}+i_{1\sim d+}\frac{X_{1\sim d+}-{metro}_{}}{{pag}_{}}=\frac{y-{metro}_{}}{{pag}_{}}$$
Aquí estamos hablando de $y$ también se ha estandarizado,de hecho, no es necesario hacer esto y no habrá ningún impacto en el rendimiento. Pero la normalización de y hace que los parámetros sean más pequeños y la convergencia se puede lograr más rápido para los parámetros inicializados en 0.

En $En$ este caso, la fórmula de escala inversa de los parámetros es:
$$i_{1\sim re+1}^{nuevo\_}=\frac{i_{1\sim d+}}{{pag}_{}}{pag}_{}$$
Fórmula:
$$i_{}{pag}_{}+i_{1\sim re+1}^{nuevo\_}(X_{1\sim d+}-{metro}_{})=y-{metro}_{}$$

$$i_0^{nuevo\_}=i_{}{pag}_{}+{metro}_{}-i_{1\sim re+1}^{nuevo\_}{metro}_{}$$
Entre ellos, durante la operación de vectorización, $i_{1\sim re+1}^{nuevo\_}$和${metro}_{}$Todos son vectores de (1,d), y la multiplicación debe utilizar el producto interno del vector.

3. Implementación del código del algoritmo de regresión lineal

implementación de vectores

Sea el dato $Las\; dimensiones\; de\; x$ son$(norte,d)$ , donde n es el número de muestras y d es la dimensión de las características de la muestra. Para facilitar el cálculo, agregamos una dimensión de característica adicional con todos los valores 1 a la muestra, de modo que su dimensión se convierta en$(norte,d+1)$

1. Predicción
   Sea el parámetro $La\; dimensión\; de\; \theta$ es (1, d+1), entonces$x\theta {\_}^{\top }$或$(\theta x^{\top }{)}^{\top La}$ dimensión se puede obtener como$(norte,1)$ Resultado de la predicción$h_{}\left(X\right)$ .
2. Dividamos la
   cantidad j entre la cantidad:
   $$i_{}=i_{}-a\frac{}{\partial w_{}}J(\theta ;X)=w_{}-a\frac{}{metro}\sum _{yo=1}\left(h_{}\right(X^{\left(i\right)})-y^{\left(yo\right)})x^{\left(i\right)}$$
   De hecho, aquí ponemos$i_{}$Como sesgo, su gradiente debería ser:
   $$\frac{}{\partial w_{}}J(\theta ;X)=w_{}-a\frac{}{metro}\sum _{yo=1}\left(h_{}\right(X^{\left(i\right)})-y^{\left(i\right)})$$, ya que complementamos los datos con dimensiones de características$X_{}$, por lo que se puede calcular utilizando la fórmula anterior al igual que otros parámetros.
   dejar error errormatriz$de\; error$$\beta$为$h_{}\left(X\right)-x$ , con dimensiones$(norte,1)$ , entonces$X^{\top }\beta /n$es la dimensión$(d+1,1)$的梯度矩阵。
   $$X^{\top \beta }\_=\left[\begin{array}{ccc}{X}^{(1}& X^{(2}& \end{array}\right]\times \left[\begin{array}{c}h\left(x^{\left(1\right)}\right)-y^{\left(1\right)}\\ h\left(x^{\left(2\right)}\right)-y^{\left(2\right)}\\ ⋮\end{array}\right]=\left[\begin{array}{c}{\sum }_{yo=1}^{}\left(h\right(x^{\left(i\right)})-y^{\left(yo\right)})x_0^{(1}\\ {\sum }_{yo=1}^{}\left(h\right(x^{\left(i\right)})-y^{\left(yo\right)})x_1^{(1}\\ ⋮\end{array}\right]$$
   $X^{}$Cada elemento en${}^{\top }$$\beta$$/$$n$

código pitón

import numpy as np


def square_loss(pred, target):
    """
    计算平方误差
    :param pred: 预测
    :param target: ground truth
    :return: 损失序列
    """
    return np.sum(np.power((pred - target), 2))


def compute_loss(pred, target):
    """
    计算归一化平均损失
    :param pred: 预测
    :param target: ground truth
    :return: 损失
    """
    pred = (pred - pred.mean(axis=0)) / pred.std(axis=0)
    target = (pred - target.mean(axis=0)) / target.std(axis=0)
    loss = square_loss(pred, target)
    return np.sum(loss) / (2 * pred.shape[0])


class LinearRegression:
    """
    线性回归类
    """

    def __init__(self, x, y, val_x, val_y, epoch=100, lr=0.1):
        """
        初始化
        :param x: 样本, (sample_number, dimension)
        :param y: 标签, (sample_numer, 1)
        :param epoch: 训练迭代次数
        :param lr: 学习率
        """
        self.theta = None
        self.loss = []
        self.val_loss = []
        self.n = x.shape[0]
        self.d = x.shape[1]

        self.epoch = epoch
        self.lr = lr

        t = np.ones(shape=(self.n, 1))

        self.x_std = x.std(axis=0)
        self.x_mean = x.mean(axis=0)
        self.y_mean = y.mean(axis=0)
        self.y_std = y.std(axis=0)

        x_norm = (x - self.x_mean) / self.x_std
        y_norm = (y - self.y_mean) / self.y_std

        self.y = y_norm
        self.x = np.concatenate((t, x_norm), axis=1)

        self.val_x = val_x
        self.val_y = val_y

    def init_theta(self):
        """
        初始化参数
        :return: theta (1, d+1)
        """
        self.theta = np.zeros(shape=(1, self.d + 1))

    def validation(self, x, y):
        x = (x - x.mean(axis=0)) / x.std(axis=0)
        y = (y - y.mean(axis=0)) / y.std(axis=0)
        outputs = self.predict(x)
        curr_loss = square_loss(outputs, y) / (2 * y.shape[0])
        return curr_loss

    def gradient_decent(self, pred):
        """
        实现梯度下降求解
        """
        # error (n,1)
        error = pred - self.y
        # gradient (d+1, 1)
        gradient = np.matmul(self.x.T, error)
        # gradient (1,d+1)
        gradient = gradient.T / pred.shape[0]
        # update parameters
        self.theta = self.theta - (self.lr / self.n) * gradient

    def train(self):
        """
        训练线性回归
        :return: 参数矩阵theta (1,d+1); 损失序列 loss
        """
        self.init_theta()

        for i in range(self.epoch):
            # pred (1,n); theta (1,d+1); self.x.T (d+1, n)
            pred = np.matmul(self.theta, self.x.T)
            # pred (n,1)
            pred = pred.T
            curr_loss = square_loss(pred, self.y) / (2 * self.n)
            val_loss = self.validation(self.val_x, self.val_y)
            self.gradient_decent(pred)
            
            self.val_loss.append(val_loss)
            self.loss.append(curr_loss)
            print("Epoch: {}/{}\tTrain Loss: {:.4f}\tVal loss: {:.4f}".format(i + 1, self.epoch, curr_loss, val_loss))

        # un_scaling parameters
        self.theta[0, 1:] = self.theta[0, 1:] / self.x_std.T * self.y_std[0]
        self.theta[0, 0] = self.theta[0, 0] * self.y_std[0] + self.y_mean[0] - np.dot(self.theta[0, 1:], self.x_mean)
        return self.theta, self.loss, self.val_loss

    def predict(self, x):
        """
        回归预测
        :param x: 输入样本 (n,d)
        :return: 预测结果 (n,1)
        """
        # (d,1)
        t = np.ones(shape=(x.shape[0], 1))
        x = np.concatenate((t, x), axis=1)
        pred = np.matmul(self.theta, x.T)
        return pred.T

4. Resultados experimentales

Regresión univariada

Conjunto de entrenamiento de visualización de conjuntos de datos

y división del conjunto de pruebas

from LinearRegression import LinearRegression

epochs = 200
alpha = 1
linear_reg = LinearRegression(x=train_x_ex,y=train_y_ex,val_x=val_x_ex, val_y=val_y_ex, lr=alpha,epoch=epochs)
start_time = time.time()
theta,loss, val_loss = linear_reg.train()
end_time = time.time()

Train Time: 0.0309s
Val Loss: 6.7951

Visualización del proceso de entrenamiento

y curva de predicción de comparación de sk-learn.

regresión multivariable

Conjunto de visualización y entrenamiento de datos y conjunto de validación.

from LinearRegression import LinearRegression

alpha = 0.1
epochs = 1000
multi_lr = LinearRegression(train_x,train_y_ex,val_x=val_x,val_y=val_y_ex, epoch=epochs,lr=alpha)
start_time = time.time()
theta, loss, val_loss = multi_lr.train()
end_time = time.time()

Train Time: 0.1209s
Val Loss: 4.187（采用归一化后数据计算损失）

Visualización del proceso de formación.

Plano de predicción (en comparación con sk-learn),
donde el azul es el plano de predicción de este algoritmo y el gris es el plano de predicción de sk-learn.

Resumen del experimento

Para que la implementación del algoritmo de regresión lineal logre un mejor rendimiento, puede intentar ajustar la tasa de aprendizaje o el número de iteraciones para obtener un mejor rendimiento. Dado que se utilizan operaciones matriciales en lugar de bucles, el tiempo de entrenamiento se reduce considerablemente, pero aún no ha alcanzado el nivel de la función de la biblioteca sk-learn.