【手搓深度学习算法】用线性回归预测波士顿房价

线性回归

【手搓深度学习算法】用线性回归预测波士顿房价_第1张图片

线性回归是一种监督学习方法,用于建立因变量与一个或多个自变量之间的关系。线性回归的目标是找到一条直线,使得所有数据点到这条直线的距离之和最小。

线性回归的基本形式如下:

y = β 0 + β 1 x 1 + β 2 x 2 + . . . + β n x n + ϵ y = \beta_0 + \beta_1x_1 + \beta_2x_2 + ... + \beta_nx_n + \epsilon y=β0+β1x1+β2x2+...+βnxn+ϵ

其中, y y y 是因变量, x 1 , x 2 , . . . , x n x_1, x_2, ..., x_n x1,x2,...,xn 是自变量, β 0 , β 1 , . . . , β n \beta_0, \beta_1, ..., \beta_n β0,β1,...,βn 是参数, ϵ \epsilon ϵ 是误差项。

线性回归的目标是通过最小化以下的均方误差(Mean Squared Error, MSE)来求解参数 β \beta β

M S E = 1 N ∑ i = 1 N ( y i − ( β 0 + β 1 x i 1 + β 2 x i 2 + . . . + β n x i n ) ) 2 MSE = \frac{1}{N}\sum_{i=1}^{N}(y_i - (\beta_0 + \beta_1x_{i1} + \beta_2x_{i2} + ... + \beta_nx_{in}))^2 MSE=N1i=1N(yi(β0+β1xi1+β2xi2+...+βnxin))2

其中, N N N 是样本数量, y i y_i yi 是第 i i i 个样本的因变量值, x i j x_{ij} xij 是第 i i i 个样本的第 j j j 个自变量值。
这个问题可以转化为一个优化问题,通过梯度下降等方法求解。具体的步骤如下:

  1. 初始化参数 β \beta β
  2. 计算当前参数下的均方误差;
  3. 根据均方误差的梯度,更新参数 β \beta β
  4. 重复步骤2和3,直到收敛。

在这个过程中,参数 β \beta β 的更新规则如下:

β = β − α ∇ M S E \beta = \beta - \alpha\nabla MSE β=βαMSE

其中, α \alpha α 是学习率, ∇ M S E \nabla MSE MSE 是均方误差关于 β \beta β 的梯度。

工具函数

对数据进行标准化

在线性回归中,数据标准化是一个非常重要的步骤,它可以使得不同的特征在模型中具有相同的重要性。数据标准化的一般步骤如下:

  1. 计算每个特征的均值 μ \mu μ 和标准差 σ \sigma σ

μ = 1 N ∑ i = 1 N x i \mu = \frac{1}{N}\sum_{i=1}^{N}x_i μ=N1i=1Nxi

σ = 1 N ∑ i = 1 N ( x i − μ ) 2 \sigma = \sqrt{\frac{1}{N}\sum_{i=1}^{N}(x_i - \mu)^2} σ=N1i=1N(xiμ)2

其中, N N N 是样本数量, x i x_i xi 是第 i i i 个样本的特征值。

  1. 将每个特征的值减去均值并除以标准差,得到标准化后的特征值:

z i = x i − μ σ z_i = \frac{x_i - \mu}{\sigma} zi=σxiμ

其中, z i z_i zi 是第 i i i 个样本的标准化后的特征值。

这样,我们就得到了标准化后的数据,其中每个特征的均值为0,标准差为1。这样可以保证不同的特征在模型中具有相同的重要性,而不会被大的特征值所主导。

def prepare_data(data, normalize_data=True):    
    # 标准化特征矩阵(可选)    
    if normalize_data:    
        features_mean = np.mean(data, axis=0)    #特征的平均值
        features_dev = np.std(data, axis=0)      #特征的标准偏差
        features = (data - features_mean) / features_dev    #标准化数据
    else:    
        features_mean = None    
        features_dev = None    
        
    ...

为数据集增加偏置项特征

在线性回归模型中,我们通常在数据集前面加一列1,这是因为我们需要一个偏置项(也称为截距项)。偏置项是一个常数,它表示当所有特征都等于0时的预期输出。在实际应用中,偏置项通常被添加到模型中,以便模型可以预测当所有特征都等于0时的输出。

在数学表达式中,线性回归模型可以写为:
y ^ = θ 0 + θ 1 x 1 + θ 2 x 2 + . . . + θ n x n \hat{y} = \theta_0 + \theta_1x_1 + \theta_2x_2 + ... + \theta_nx_n y^=θ0+θ1x1+θ2x2+...+θnxn
其中, y ^ \hat{y} y^是预测的目标变量, x 1 , x 2 , . . . , x n x_1, x_2, ..., x_n x1,x2,...,xn是特征变量, θ 0 , θ 1 , . . . , θ n \theta_0, \theta_1, ..., \theta_n θ0,θ1,...,θn是模型的参数。
在这个公式中, θ 0 \theta_0 θ0就是偏置项。当所有的 x i x_i xi都等于0时, y ^ \hat{y} y^就等于 θ 0 \theta_0 θ0
我们通常将数据集的特征矩阵与一个全1的向量进行水平堆叠(horizontal stacking),以此来添加偏置项。例如,如果我们的特征矩阵是 X X X,那么我们可以这样添加偏置项:
这样,我们就得到了一个新的特征矩阵,其中第一列是全1的向量,表示偏置项。

    # 为特征添加偏置项     
    data_processed = np.hstack((np.ones((features.shape[0], 1)), features)).T
    # 返回处理后的数据
    return data_processed, features_mean, features_dev

预测结果评估函数

获取评分和分级以便可视化处理

def get_predict_score(predict_table):
    score_table = []
    pass_count = 0
    for pair in predict_table:
        if (abs(pair[0] - pair[1]) / pair[1] < 0.1):
            score_table.append("good")
            pass_count += 1
        elif (abs(pair[0] - pair[1]) / pair[1] < 0.4):
            score_table.append("around")
            pass_count += 0.8
        else:
            score_table.append("bad")
    accuracy = pass_count / len(predict_table)
    return score_table, accuracy

线性回归类

以下的代码位于名为 LinearRegression的类中

初始化

在初始化中获取处理后的数据,并初始化权重向量

def __init__(self, data,labels, normalize_data = True) -> None:
        (data_proccessed,
         features_mean,
         features_dev) = prepare_data(data, normalize_data)
        self.data = data_proccessed
        self.labels = labels
        self.features_mean = features_mean
        self.features_dev = features_dev
        self.normalize_data = normalize_data
        
        num_features = self.data.shape[0] #特征个数
        self.theta = np.zeros((num_features,1)) #初始化权重向量

训练过程

单步更新权重

首先计算权重和特征的点积,计算预测值
通过最小化以下的均方误差来求解参数 β \beta β

MSE的定义是:

M S E = 1 N ∑ i = 1 N ( y i − ( β 0 + β 1 x i 1 + β 2 x i 2 + . . . + β n x i n ) ) 2 MSE = \frac{1}{N} \sum_{i=1}^{N} (y_i - (\beta_0 + \beta_1x_{i1} + \beta_2x_{i2} + ... + \beta_nx_{in}))^2 MSE=N1i=1N(yi(β0+β1xi1+β2xi2+...+βnxin))2

( β 0 + β 1 x i 1 + β 2 x i 2 + . . . + β n x i n ) (\beta_0 + \beta_1x_{i1} + \beta_2x_{i2} + ... + \beta_nx_{in}) (β0+β1xi1+β2xi2+...+βnxin) 看作一个整体, 对它求偏导,MSE的梯度可以通过以下公式计算:

d M S E d θ = 1 N ∑ i = 1 N − 2 ( y i − ( β 0 + β 1 x i 1 + β 2 x i 2 + . . . + β n x i n ) ) x i j \frac{dMSE}{d\theta} = \frac{1}{N} \sum_{i=1}^{N} -2 (y_i - (\beta_0 + \beta_1x_{i1} + \beta_2x_{i2} + ... + \beta_nx_{in})) x_{ij} dθdMSE=N1i=1N2(yi(β0+β1xi1+β2xi2+...+βnxin))xij
其中, x i j x_{ij} xij是第 i i i个样本的第 j j j个特征的值。
这个公式的意思是,对于每一个样本,我们首先计算预测值和真实值之间的差距,然后乘以这个差距的符号(也就是 − 2 ( y i − ( β 0 + β 1 x i 1 + β 2 x i 2 + . . . + β n x i n ) ) -2(y_i - (\beta_0 + \beta_1x_{i1} + \beta_2x_{i2} + ... + \beta_nx_{in})) 2(yi(β0+β1xi1+β2xi2+...+βnxin))),再乘以这个特征的值 x i j x_{ij} xij。这样,我们就得到了每个特征对MSE的贡献。

然后,我们可以使用这个梯度来更新参数theta。在这个函数中,首先计算了预测值和真实值之间的偏差向量delta,然后根据这个偏差向量来更新权重参数theta

具体来说,这个更新过程是通过以下公式完成的:

θ − = l r ⋅ 1 n u m _ e x a m p l e s ⋅ ( n p . d o t ( d e l t a . T , s e l f . d a t a . T ) ) . T \theta -= lr \cdot \frac{1}{num\_examples} \cdot (np.dot(delta.T, self.data.T)).T θ=lrnum_examples1(np.dot(delta.T,self.data.T)).T

其中,lr是学习率, n u m _ e x a m p l e s num\_examples num_examples是样本数量,delta是偏差向量,self.data是特征矩阵。这个公式表示,我们把权重参数theta减去学习率乘以偏差向量和特征矩阵的点积的结果,从而实现参数的更新。

def gradient_step(self,lr):
        '''
        梯度下降参数更新,使用矩阵运算
        '''
        num_examples = self.data.shape[1] # 多少行
        prediction = LinearRegression.predict(self.data, self.theta) #每次计算所有样本的预测值,使用矩阵乘法
        delta = prediction - self.labels # 偏差向量
        theta = self.theta
        theta -= lr*(1/num_examples)*(np.dot(delta.T, self.data.T)).T #更新权重
        self.theta = theta #记录当前权重参数

损失函数

首先计算权重和特征的点积,计算预测值
通过最小化以下的均方误差来求解参数 β \beta β

M S E = 1 N ∑ i = 1 N ( y i − ( β 0 + β 1 x i 1 + β 2 x i 2 + . . . + β n x i n ) ) 2 MSE = \frac{1}{N}\sum_{i=1}^{N}(y_i - (\beta_0 + \beta_1x_{i1} + \beta_2x_{i2} + ... + \beta_nx_{in}))^2 MSE=N1i=1N(yi(β0+β1xi1+β2xi2+...+βnxin))2
通过添加表示偏置项的值为1的列得到
M S E = 1 N ∑ i = 0 N ( y i − ( β ^ x i ^ ) ) 2 MSE = \frac{1}{N}\sum_{i=0}^{N}(y_i - (\hat{\beta} \hat{x_i}))^2 MSE=N1i=0N(yi(β^xi^))2
其中 ( β ^ x i ^ ) ) (\hat{\beta} \hat{x_i})) (β^xi^)) 即是如下代码中的 ‘delta’( δ ^ \hat{\delta} δ^),因为涉及向量的平方所以
( δ ^ ) 2 = ( n p . d o t ( d e l t a . T , d e l t a ) ) (\hat{\delta})^2 = (np.dot(delta.T, delta)) (δ^)2=(np.dot(delta.T,delta))

def cost_function(self,data,labels):
        num_examples = data.shape[0]
        delta = LinearRegression.predict(self.data, self.theta) - labels #偏差
        cost = (1/2)*np.dot(delta.T, delta) #最小二乘法计算损失
        #print(cost.shape)
        return cost[0][0]

迭代执行梯度下降更新参数

这一部分没什么好说的,还是对迭代次数和学习率两个超参数做一下说明

在线性回归中,学习率(learning rate)和迭代次数(number of iterations)是两个非常重要的超参数,它们直接影响到模型的训练效果。

  1. 学习率(Learning Rate):学习率决定了每一步梯度下降的步长。如果学习率太大,那么在搜索最优解的过程中可能会“跳过”最优解;如果学习率太小,那么训练过程可能会非常慢,甚至可能陷入局部最优解。因此,选择合适的学习率是非常重要的。

  2. 迭代次数(Number of Iterations):迭代次数决定了梯度下降的迭代次数。如果迭代次数太少,那么模型可能还没有收敛到最优解;如果迭代次数太多,那么可能会导致过拟合,模型在训练集上的表现很好,但在测试集上的表现很差。因此,选择合适的迭代次数也是非常重要的。

def gradient_desent(self, lr, num_iter):
        cost_history = []
        for _ in range(num_iter): # 在规定的迭代次数里执行训练
            self.gradient_step(lr)
            cost_history.append(self.cost_function(self.data, self.labels)) # 记录损失值,以便可视化展示
        return cost_history

预测

线性回归模型的预测即是将权重向量和特征向量进行点积,有人可能会问偏置项去了哪里,其实偏置项就藏在权重向量的第一个元素里,因为我们在前面处理数据集的时候已经向数据集的开头添加了一列“1”,所以在进行点积的时候,自动就变成了 y i = b i a s ∗ 1 + x i 1 w i 1 + x i 2 w i 2 + . . . + x i n w i n y_i = bias*1 + x_{i1}w_{i1} + x_{i2}w_{i2} +... + x_{in}w_{in} yi=bias1+xi1wi1+xi2wi2+...+xinwin

def predict_test(self, data):
        data_proccessed = prepare_data(data, self.normalize_data)[0]
        prediction = LinearRegression.predict(data_proccessed, self.theta)
        return prediction
    @staticmethod
    def predict(data, theta):
        prediction = np.dot(data.T, theta) #特征值和权重参数做点积,计算预测值
        return prediction

训练,预测和可视化展示部分

没什么好说的,主要就是处理数据集和可视化展示

import pandas as pd
import matplotlib.pyplot as plt
def main():        
    data_file = "J:\\MachineLearning\\数据集\\housing.data"
    data = pd.read_csv(data_file, sep="\s+").sample(frac=1).reset_index(drop=True)
    train_data = data.sample(frac=0.8)
    test_data = data.drop(train_data.index)
    input_param_index = 'NOX'
    output_param_index = 'MEDV'
    x_train = train_data[input_param_index].values
    y_train = train_data[output_param_index].values
    x_test = test_data[input_param_index].values
    y_test = test_data[output_param_index].values
    
    x_train = train_data.iloc[:, :13].values
    y_train = train_data[output_param_index].values.reshape(len(x_train),1)
    x_test = test_data.iloc[:, :13].values
    y_test = test_data[output_param_index].values.reshape(len(test_data),1)
    print(x_train.shape)
    print(y_train.shape)
    
    linearReg = LinearRegression(x_train, y_train)
    train_theta, loss_history = linearReg.train(0.0001, 50000)
    fomula = 'Y = '
    index = 0
    for w in np.round(train_theta, 2)[1:]:
        fomula += "{}{}X{}".format(" + " if w >=0 else " - " if index != 0 else "", float(abs(w[0])), index)
        index += 1
    fomula += "{}{}".format(" + " if train_theta[0] >= 0 else "-", round(float(abs(train_theta[0][0])), 2))
    print(fomula)
    print(train_theta.shape)
    plt.plot(loss_history)
    plt.show()
    
    predic_result = np.round(linearReg.predict_test(x_test), 2)
    predict_table = np.column_stack((predic_result, y_test))
    score, accuracy = get_predict_score(predict_table)
    print("Accuracy is {}".format(accuracy))
    color_table = {"good": "green", "around":"yellow", "bad": "red"}
    #print(predic_result)
    fig, ax = plt.subplots()
    table = ax.table(cellText = predict_table, loc = 'center')
    for i, cell in enumerate(table._cells.values()):
        color_index = int(i / 2)
        cell.set_facecolor(color_table[score[color_index]])
    ax.axis("off")
    plt.show()

运行结果

损失值变化
【手搓深度学习算法】用线性回归预测波士顿房价_第2张图片

得到的展开式
Y = 0.59 X 0 + 0.48 X 1 − 0.55 X 2 + 0.89 X 3 − 1.18 X 4 + 3.23 X 5 + 0.0 X 6 − 2.2 X 7 + 1.0 X 8 − 0.45 X 9 − 1.82 X 1 0 + 0.82 X 1 1 − 3.66 X 1 2 + 22.67 Y = 0.59X_0 + 0.48X_1 - 0.55X_2 + 0.89X_3 - 1.18X_4 + 3.23X_5 + 0.0X_6 - 2.2X_7 + 1.0X_8 - 0.45X_9 - 1.82X_10 + 0.82X_11 - 3.66X_12 + 22.67 Y=0.59X0+0.48X10.55X2+0.89X31.18X4+3.23X5+0.0X62.2X7+1.0X80.45X91.82X10+0.82X113.66X12+22.67

得分展示
【手搓深度学习算法】用线性回归预测波士顿房价_第3张图片

完整代码(数据集在绑定资源里,也可以自己去下载)

import numpy as np    
    
def prepare_data(data, normalize_data=True):    
    # 标准化特征矩阵(可选)    
    if normalize_data:    
        features_mean = np.mean(data, axis=0)    #特征的平均值
        features_dev = np.std(data, axis=0)      #特征的标准偏差
        features = (data - features_mean) / features_dev    #标准化数据
    else:    
        features_mean = None    
        features_dev = None    
        
    # 为特征添加偏置项     
    data_processed = np.hstack((np.ones((features.shape[0], 1)), features)).T
    # 返回处理后的数据
    return data_processed, features_mean, features_dev

def get_predict_score(predict_table):
    score_table = []
    pass_count = 0
    for pair in predict_table:
        if (abs(pair[0] - pair[1]) / pair[1] < 0.1):
            score_table.append("good")
            pass_count += 1
        elif (abs(pair[0] - pair[1]) / pair[1] < 0.4):
            score_table.append("around")
            pass_count += 0.8
        else:
            score_table.append("bad")
    accuracy = pass_count / len(predict_table)
    return score_table, accuracy
        
class LinearRegression:
    '''
    1. 对数据进行预处理操作
    2. 先得到所有的特征个数
    3. 初始化参数矩阵
    '''
    def __init__(self, data,labels, normalize_data = True) -> None:
        (data_proccessed,
         features_mean,
         features_dev) = prepare_data(data, normalize_data)
        self.data = data_proccessed
        self.labels = labels
        self.features_mean = features_mean
        self.features_dev = features_dev
        self.normalize_data = normalize_data
        
        num_features = self.data.shape[0] #特征个数
        self.theta = np.zeros((num_features,1)) #初始化权重向量
        
    def train(self, lr, num_iter = 500):
        #训练模块
        cost_history = self.gradient_desent(lr, num_iter) #梯度下降过程
        return self.theta,cost_history
        
    def gradient_step(self,lr):
        '''
        梯度下降参数更新,使用矩阵运算
        '''
        num_examples = self.data.shape[1] # 多少行
        prediction = LinearRegression.predict(self.data, self.theta) #每次计算所有样本的预测值,使用矩阵乘法
        delta = prediction - self.labels # 偏差向量
        theta = self.theta
        theta -= lr*(1/num_examples)*(np.dot(delta.T, self.data.T)).T #更新权重
        self.theta = theta #记录当前权重参数
    
    def gradient_desent(self, lr, num_iter):
        cost_history = []
        for _ in range(num_iter): # 在规定的迭代次数里执行训练
            self.gradient_step(lr)
            cost_history.append(self.cost_function(self.data, self.labels)) # 记录损失值,以便可视化展示
        return cost_history
    
    def cost_function(self,data,labels):
        num_examples = data.shape[0]
        delta = LinearRegression.predict(self.data, self.theta) - labels #偏差
        cost = (1/2)*np.dot(delta.T, delta) #最小二乘法计算损失
        #print(cost.shape)
        return cost[0][0]
    
    #针对测试集
    def get_cost(self, data, labels):
        data_proccessed = prepare_data(data, self.normalize_data)[0]
        return self.cost_function(data_proccessed, labels)
    
    def predict_test(self, data):
        data_proccessed = prepare_data(data, self.normalize_data)[0]
        prediction = LinearRegression.predict(data_proccessed, self.theta)
        return prediction
    @staticmethod
    def predict(data, theta):
        prediction = np.dot(data.T, theta) #特征值和权重参数做点积,计算预测值
        return prediction
        
import pandas as pd
import matplotlib.pyplot as plt
def main():        
    data_file = "J:\\MachineLearning\\数据集\\housing.data"
    data = pd.read_csv(data_file, sep="\s+").sample(frac=1).reset_index(drop=True)
    train_data = data.sample(frac=0.8)
    test_data = data.drop(train_data.index)
    input_param_index = 'NOX'
    output_param_index = 'MEDV'
    x_train = train_data[input_param_index].values
    y_train = train_data[output_param_index].values
    x_test = test_data[input_param_index].values
    y_test = test_data[output_param_index].values
    
    x_train = train_data.iloc[:, :13].values
    y_train = train_data[output_param_index].values.reshape(len(x_train),1)
    x_test = test_data.iloc[:, :13].values
    y_test = test_data[output_param_index].values.reshape(len(test_data),1)
    print(x_train.shape)
    print(y_train.shape)
    
    linearReg = LinearRegression(x_train, y_train)
    train_theta, loss_history = linearReg.train(0.0001, 50000)
    fomula = 'Y = '
    index = 0
    for w in np.round(train_theta, 2)[1:]:
        fomula += "{}{}X{}".format(" + " if w >=0 else " - " if index != 0 else "", float(abs(w[0])), index)
        index += 1
    fomula += "{}{}".format(" + " if train_theta[0] >= 0 else "-", round(float(abs(train_theta[0][0])), 2))
    print(fomula)
    print(train_theta.shape)
    plt.plot(loss_history)
    plt.show()
    
    predic_result = np.round(linearReg.predict_test(x_test), 2)
    predict_table = np.column_stack((predic_result, y_test))
    score, accuracy = get_predict_score(predict_table)
    print("Accuracy is {}".format(accuracy))
    color_table = {"good": "green", "around":"yellow", "bad": "red"}
    #print(predic_result)
    fig, ax = plt.subplots()
    table = ax.table(cellText = predict_table, loc = 'center')
    for i, cell in enumerate(table._cells.values()):
        color_index = int(i / 2)
        cell.set_facecolor(color_table[score[color_index]])
    ax.axis("off")
    plt.show()
    
    
 
if (__name__ == "__main__"):
    main()

你可能感兴趣的:(天网计划,算法,深度学习,线性回归)