多元线性回归

阅读数: 10000次

多元线性回归

引入

​ 学习一元线性回归之后，我们便开始学习多元线性回归。

​ 我们之前学习的一元线性回归具有单一的特征x，就拿房子的面积与其房子价格的关系来说，在一元线性回归中我们仅有theta0和theta1

假设函数：
$$
h_θ=θ_0+θ_1k
$$
​ 但是在现实生活中，不可能仅仅依靠房子价格由房子的面积来决定，因为影响房价的因素肯定不仅仅是面积比如，有几个卧室，有几个卫生间，房龄多久了等等。

​ 我们也许在生活中见到过房子面积大的比房子面积小的价格更低，说明还有其他因素在影响着价格。那么我们如何更好的来预测房子的价格呢，我们需要把更多的特征纳入假设函数中，这样才能使我们的预测结果更加准确。

分析

假设函数：

$$
(θ_0,θ_1,θ_2,θ_3,……θ_n)θ代表一系列需要学习的参数
$$

$$
(1,X^i_1,X^i_2,X^i_3,……,X^i_n )代表了特征的参数
$$

所以多元线性回归的假设函数可以写为：
$$
h_θ(x)=θ_0+θ_1X^i_1+θ_2X^i_2+θ_3X^i_3+……+θ_nX^i_n
$$

$$
若令θ_0X^i_0=1
$$

$$
则h_θ(x)=θ_0X^i_0+θ_1X^i_1+θ_2X^i_2+θ_3X^i_3+……+θ_nX^i_n
$$

一元线性回归损失函数

$$
J(θ_0,θ_1)=\frac{1}{2m}\sum ^n_i(y^i-y)^2
$$

求导后的公式为

$$
对\theta_0进行求导后的导函数：\frac{\partial}{\theta_0}=\frac{1}{m}\sum ^n_i(y^i-y)
$$

$$
对\theta_1进行求导后的导函数：\frac{\partial}{\theta_1}=\frac{1}{m}\sum ^n_i(y^i-y)x^i
$$

一元迭代函数

$$
对\theta_0进行迭代更新：\theta_0=\alpha\frac{\partial}{\theta_0}=\theta_0-\alpha\frac{1}{m}\sum ^n_i(y^i-y)
$$

$$
对\theta_1进行迭代更新：\theta_1=\alpha\frac{\partial}{\theta_1}=\theta_1-\alpha\frac{1}{m}\sum ^n_i(y^i-y)x^i
$$

多元线性回归

多元线性回归算法描述

(1).初始化权值

(2).对每一个训练样本：

​ 计算权值和输入特征向量之间的值作为预测值

​ 计算实际值与预测值之间的误差

​ 定义一种误差的衡量标准，想办法让误差降到最低

​ 用误差指导权值的更新

(3).设置算法停止的终止条件，当达到终止条件时，算法就不再继续运行

由于我们希望尽可能的减小误差，所以我们在这里采用的方法就是梯度下降法，那么首先要构造损失函数

多元损失函数
$$
J(θ_0,θ_1,\theta_2,\theta_3,…,\theta_n)=\frac{1}{2m}\sum ^n_i(y^i-y)^2
$$

对于多元的损失函数进行求导，其实是和一元的差不多的

代码实现

例子：X，Y为数据
$$
X=\begin{bmatrix}
1&2&5&4\
2&5&1&2\
\end{bmatrix}
$$

$$
Y=\begin{bmatrix}
19\
26\
19\
20\
\end{bmatrix}
$$

批梯度下降：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import numpy as np
import matplotlib.pyplot as plt
import random
import datetime
def bgd(samples, y, step_size=0.01, max_iteration_count=10000):
    """
    批梯度下降法Batch Gradient Descent
    :param samples: 样本
    :param y: 结果
    :param step_size: 每一接迭代的步长
    :param max_iteration_count: 最大的迭代次数
    :return:
    """
    sample_num, dimension = samples.shape
    #sample_num=矩阵的行数，dimision=矩阵的列数
    w = np.ones((dimension,1), dtype=np.float32)# numpy.ones（）函数返回给定形状和数据类型的新数组，其中元素的值设置为1
    #w为一个行数为dimension列数为1的矩阵
    loss_collection = []#生成一个数组
    loss = 1
    iteration_count = 0#用于记录迭代次数
    #  当loss大于阈值并且迭代次数小于最大迭代次数时进行迭代
    while loss > 0.001 and iteration_count < max_iteration_count:
        loss = 0
        gradient = np.zeros((dimension,1), dtype=np.float32)#dtype用于指定数组的数据类型
        #w为一个行数为dimension列数为1的矩阵
        #  计算（批）梯度
        for i in range(sample_num):
            predict_y = np.dot(w.T, samples[i])#dot是矩阵乘法，得到的是预测值
            for j in range(dimension):
                gradient[j] += (predict_y - y[i]) * samples[i][j]
        #对参数进行求值，就是导数相加的和，用于迭代
        #  更新权重
        for j in range(dimension):
            w[j] -= step_size * gradient[j]
        #  计算当前loss值
        for i in range(sample_num):
            predict_y = np.dot(w.T, samples[i])
            loss += np.power((predict_y - y[i]), 2)
        #  将loss存储到链表里，以便后续画图
        loss_collection.append(loss)
        iteration_count += 1
    return w,loss_collection
if __name__ == '__main__':
    samples = np.array([[1,2,5,4],
                        [2,5,1,2]]).T#转置，变成4*2的矩阵
    #print(samples[1])
    y = np.array([19,26,19,20]).reshape((4,1))#得到原有矩阵的转置矩阵
    #print(y)
    D,loss=bgd(samples,y)
    for i in range(2):
        print("第",i+1,"个参数的值：",D[i])

运行的结果为：

1
2
第 1 个参数的值： [2.8636856]
第 2 个参数的值： [4.570819]

随机梯度下降:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import numpy as np
import matplotlib.pyplot as plt
import random
import datetime
def sgd(samples, y, step_size=0.001, max_iteration_count=10000):
    # step_size为步长，max_iteration_count为限制条件次数
    """
    随机梯度下降法Stochastic Gradient Descent
    :param samples: 样本
    :param y: 结果
    :param step_size: 每一接迭代的步长
    :param max_iteration_count: 最大的迭代次数
    :return:
    """
    sample_num, dimension = samples.shape           #sample_num=4(行数),dimension=2(列数)
    w = np.ones((dimension,1), dtype=np.float32)    #2行1列的矩阵
    loss_collection = []                            #新列表
    loss = 1
    iteration_count = 0                             #记录循环次数
    while loss > 0.001 and iteration_count < max_iteration_count:     #当循环能进行时
        loss = 0
        gradient = np.zeros((dimension,1), dtype=np.float32)
        #  不同于BGD的是，这里随机取一个样本进行权重更新
        sample_index = random.randint(0, sample_num-1)
        predict_y = np.dot(w.T, samples[sample_index])
        for j in range(dimension):
            gradient[j] += (predict_y - y[sample_index]) * samples[sample_index][j]
            w[j] -= step_size * gradient[j]                   #不断更新权重
        for i in range(sample_num):
            predict_y = np.dot(w.T, samples[i])
            loss += np.power((predict_y - y[i]), 2)
        loss_collection.append(loss)
        iteration_count += 1
    return w,loss_collection
if __name__ == '__main__':
    samples = np.array([[1,2,5,4],
                        [2,5,1,2]]).T#转置后变成4行2列的矩阵
    y = np.array([19,26,19,20]).reshape((4,1))
    D,loss=sgd(samples,y)
    for i in range(2):
        print("第",i+1,"个参数的值：",D[i])

运行结果：

1
2
第 1 个参数的值： [2.8565211]
第 2 个参数的值： [4.6394463]

波斯顿房价预测

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.utils import shuffle
df = pd.read_csv("E\人工智能资料\boston.csv")
df = np.array(df.values,ndmin=2)
x_data = df[:,:12]
#归一化
for i in range(12):
    x_data[:,i] = (x_data[:,i]-x_data[:,i].min())/(x_data[:,i].max()-x_data[:,i].min())
y_data = df[:,12]
#将后10个作为测试集，不参加训练
test_x = x_data[-10:]
test_y = y_data[-10:]
#初始化参数
w = np.random.normal(0.0,1.0,(1,12))#初始化权值
b = 0.0
#设置训练轮次
train_epochs = 200
learing_rate = 0.001#学习率
loss_=[]#初始化一个列表
for count in range(train_epochs):
    loss=[]
    for i in range(len(x_data)):
        re = w.dot(x_data[i])+b#预测值
        err = y_data[i]-re#真实值与预测值的差
        w +=learing_rate*err*x_data[i]#用于更新权值
        b +=learing_rate*err#常数不断更新
        #记录误差
        loss.append(abs(err))
    loss_.append(sum(loss)/len(loss))
    #print(sum(loss)/len(loss))
    #随机打乱训练集中的样本，防止模型出现结果和输入的位置有关的情况
    x_data,y_data = shuffle(x_data,y_data)
#打印误差的变化情况
plt.plot(loss_)
#简单的评估，看看实际值和预测值之间的误差
for i in range(10):
    print("true:\t{}".format(test_y[i]),end="\t")
    pre = np.dot(w,test_x[i])+b
    print("guess:\t{}".format(pre))
plt.show()

数据集下载地址：https://pan.baidu.com/s/1mfC1lqQoUKH3fflao_hxwA

提取码：15p5

参考https://blog.csdn.net/program_developer/article/details/78637711

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

生活不止眼前的苟且,还有诗和远方的田野. WeChat：gyh2219608739 就读学校：河南理工