Andrew Ngs „Machine Learning“ – Implementierung des linearen Regressionscodes

Datensätze und Quelldateien können im Github-Projekt bezogen werden

Adresse: https://github.com/Raymond-Yang-2001/AndrewNg-Machine-Learing-Homework

1. Univariate lineare Regression

Die univariate lineare Regression findet eine eindimensionale Gleichung und passt eine gerade Linie an.

Univariate lineare Regressionsformel

$$H_{w,}\left(X\right)=B+Bx$$
$w$ und$b$ ist ein Parameter. Um die Berechnung zu erleichtern, können Sie$x$ plus ein$X_{}=1$
$$H_{w,}\left(X\right)=b{x}_{}+B{x}_{}$$

verlustfunktion

$$J(w,B)=\frac{}{2m\_}\sum _{ich=1}\left(H_{w,}\right(X^{\left(ich\right)})-j^{\left(ich\right)}{)}^2$$
Um übermäßige oder kleine Verluste zu vermeiden, die durch ungeeignete Datenbereiche verursacht werden (z. B. wenn der Datenwert zu groß ist, kann der Verlust$10^5$ oder$10^6$ , diese Größenordnung ist für eine intuitive Analyse nicht geeignet) Bei der Bewertung des Verlusts können Sie hw$H_{w,}\left(X^{\left(i\right)}\right)$sumy$j^{\left(i\right)}$ Standardisieren Sie zunächst so, dass der Verlustwert innerhalb eines auswertbaren Bereichs liegt. Beim Gradientenabstieg ist dies jedoch nicht der Fall

Optimierungsalgorithmus – Batch Gradient Descent (BGD)

$$w_{}=w_{}-A\frac{}{\partial w_{}}J(w,B)=w_{}-A\frac{}{M}\sum _{ich=1}\left(H_{w,}\right(X^{\left(ich\right)})-j^{\left(i\right)})x^{\left(i\right)}$$
$$B_{}=B_{}-A\frac{}{\partial b_{}}J(w,B)=w_{}-A\frac{}{M}\sum _{ich=1}\left(H_{w,}\right(X^{\left(ich\right)})-j^{\left(i\right)})$$
Hier können wir$\theta$ einheitliche Identifikationsparameter, einschließlich$w$ und$B$ .

Das heißt, $j$ Parameter${ich}_{}$Bestimmen Sie Folgendes:
$${ich}_{}={ich}_{}-A\frac{}{\partial w_{}}J(\theta ;X)=w_{}-A\frac{}{M}\sum _{ich=1}\left(H_{}\right(X^{\left(ich\right)})-j^{\left(i\right)})x^{\left(i\right)}$$
wobei$\alpha$ ist die Lernrate.

2. Multivariable lineare Regression

Bei der multivariablen linearen Regression wird versucht, die Beziehung zwischen mehreren Variablen und vorhergesagten Werten zu ermitteln. Zum Beispiel die Beziehung zwischen Hausgröße, Anzahl der Schlafzimmer in einem Haus und Hauspreisen.

Feature-Skalierung (Normalisierung)

Wenn die numerischen Unterschiede zwischen verschiedenen Merkmalen der Stichprobe zu groß sind, treten bei der Optimierung auf Gradientenbasis einige Probleme auf. Beispielsweise gibt es die folgende Regressionsgleichung:
$$H_{}\left(X\right)={ich}_{}+{ich}_{}{X}_{}+{ich}_{}{X}_{}$$
Angenommen $X_{}$Der Bereich ist $0\sim 1$，$X_{}$Der Bereich ist $10^3\sim 10^4$ . Wir optimieren gleichzeitig${ich}_{}\sim {ich}_{}$, so dass sie sich alle um die gleiche Größe ändern, dann ist es offensichtlich, dass θ 1 \theta_1 , wenn die Eingabeproben gleich sind${ich}_{}$Die Änderung wird größer sein als ${ich}_{}$Änderungen, die zu einer höheren Leistung führen. Dies kann auch als Modellpaar ${ich}_{}$Empfindlichere. Wie im folgenden Verlustisoliniendiagramm gezeigt, ${ich}_{}$Kleine Änderungen können drastische Veränderungen bei den Verlusten mit sich bringen. In diesem Fall wird die Parameteroptimierung schwieriger.

Eine Möglichkeit, dieses Problem zu lösen, ist die Feature-Skalierung, die zwei Features auf den gleichen Bereich skaliert. Beispielsweise kann eine Z-Score-Normalisierung durchgeführt werden:
$$X_{neu\_}=\frac{X-}{P}$$
Darunter $\mu$ ist der Mittelwert des Datensatzes,$\sigma$ ist die Standardabweichung und die Verteilung neuer Daten ist eine Verteilung mit Mittelwert 0 und Standardabweichung 1.
Das Parameterverlustdiagramm nach der Datennormalisierung sieht wie folgt aus:

Inverse Skalierung von Parametern

Da die Daten skaliert sind, werden auch die endgültigen Parameter entsprechend skaliert. Die spezifische Beziehung ist wie folgt:
$${ich}_{}+{ich}_{1\sim d+}\frac{X_{1\sim d+}-M_{}}{P_{}}=\frac{j-M_{}}{P_{}}$$
Hier reden wir über $y$ wurde ebenfalls standardisiert.Tatsächlich ist dies nicht erforderlich und es wird keine Auswirkungen auf die Leistung haben. Durch die Normalisierung von y werden die Parameter jedoch kleiner und die Konvergenz kann für auf 0 initialisierte Parameter schneller erreicht werden.

In $In$ diesem Fall lautet die inverse Skalierungsformel der Parameter:
$${ich}_{1\sim d+1}^{neu\_}=\frac{{ich}_{1\sim d+}}{P_{}}{P}_{}$$
Formel:
$${ich}_{}{P}_{}+{ich}_{1\sim d+1}^{neu\_}(X_{1\sim d+}-M_{})=j-M_{}$$

$${ich}_0^{neu\_}={ich}_{}{P}_{}+M_{}-{ich}_{1\sim d+1}^{neu\_}{M}_{}$$
Darunter gilt während des Vektorisierungsvorgangs ${ich}_{1\sim d+1}^{neu\_}$和$M_{}$Sie sind alle Vektoren von (1,d), und die Multiplikation sollte das innere Vektorprodukt verwenden.

3. Implementierung des Codes für den linearen Regressionsalgorithmus

Vektorimplementierung

Seien die Daten $Die\; Dimensionen\; von\; x$ sind$(N,d)$ , wobei n die Anzahl der Stichproben und d die Dimension der Stichprobenmerkmale ist. Zur Vereinfachung der Berechnung fügen wir der Stichprobe eine zusätzliche Merkmalsdimension mit allen Werten 1 hinzu, sodass ihre Dimension$(N,D+1)$

1. Vorhersage
   Sei der Parameter $Die\; Dimension\; von\; \theta$ ist (1, d+1), dann ist$x{\theta }^{\top }$或$(\theta x^{\top }{)}^{\top Die}$ Dimension kann erhalten werden als$(N,1)$ Vorhersageergebnis$H_{}\left(X\right)$ .
2. Teilen wir die
   Größe j durch die Größe:
   $${ich}_{}={ich}_{}-A\frac{}{\partial w_{}}J(\theta ;X)=w_{}-A\frac{}{M}\sum _{ich=1}\left(H_{}\right(X^{\left(ich\right)})-j^{\left(i\right)})x^{\left(i\right)}$$
   Tatsächlich setzen wir hier${ich}_{}$Als Voreingenommenheit sollte sein Gradient sein:
   $$\frac{}{\partial w_{}}J(\theta ;X)=w_{}-A\frac{}{M}\sum _{ich=1}\left(H_{}\right(X^{\left(ich\right)})-j^{\left(i\right)})$$, da wir die Daten mit Merkmalsdimensionen$X_{}$, sodass er wie andere Parameter mit der obigen Formel berechnet werden kann.
   Lassen Sie $Fehlermatrix$ β$\beta$为$H_{}\left(X\right)-x$ , mit Abmessungen$(N,1)$ , dann$X^{\top }\beta /n$ist die Dimension$(D+1,x\; \top \; \beta \; =\; [\; x\; (\; 1\; )\; x\; (\; 2\; )\; \cdots \; ]\; \times \; [\; h\; (\; x\; (\; 1\; )\; )\; -\; y\; (\; 1)$ h ( x (
   $$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)-j^{\left(1\right)}\\ h\left(x^{\left(2\right)}\right)-j^{\left(2\right)}\\ ⋮\end{array}\right]=\left[\begin{array}{c}{\sum }_{ich=1}^{}\left(h\right(x^{\left(ich\right)})-j^{\left(i\right)})x_0^{(1}\\ {\sum }_{ich=1}^{}\left(h\right(x^{\left(ich\right)})-j^{\left(i\right)})x_1^{(1}\\ ⋮\end{array}\right]$$
   $X^{}$Jedes Element in${}^{\top }$$\beta$$/$$n$

Python-Code

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. Experimentelle Ergebnisse

Univariate Regression

Aufteilung des Trainingssatzes zur Datensatzvisualisierung und des Testsatzes

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

Visualisierung des Trainingsprozesses

und Prognosekurve für den Sk-Learn-Vergleich

multivariable Regression

Datenvisualisierungs- und Trainingsset und Validierungsset

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（采用归一化后数据计算损失）

Visualisierung des Trainingsprozesses

Vorhersageebene (im Vergleich zu sk-learn),
wobei Blau die Vorhersageebene dieses Algorithmus und Grau die Vorhersageebene von sk-learn ist

Zusammenfassung des Experiments

Um bei der Implementierung des linearen Regressionsalgorithmus eine bessere Leistung zu erzielen, können Sie versuchen, die Lernrate oder die Anzahl der Iterationen anzupassen, um eine bessere Leistung zu erzielen. Da Matrixoperationen anstelle von Schleifen verwendet werden, wird die Trainingszeit erheblich verkürzt, sie hat jedoch noch nicht das Niveau der Sk-Learn-Bibliotheksfunktion erreicht.