深度学习中的线性回归问题并使用正规方程法进行房价预测

线性回归问题

一、前期概念储备

1. （Math）矩阵求导_沤江一流的专栏-CSDN博客

2. 机器学习-线性回归总结_rotation博客-CSDN博客_机器学习线性回归

3. 如何理解最小二乘法？_马同学-CSDN博客_最小二乘法

4. 常用的矩阵求导公式
   

5. 正规方程的公式推导
   

二、应用分析

1. 波士顿房价预测（多特征变量问题）

   13个特征变量，500个数据

   代码实现

   1. 使用sklearn工具包（跳过参数运算部分）

      from sklearn import datasets
      from sklearn.linear_model import LinearRegression#引入线性回归模型
      
      ###引入数据###
      load_data=datasets.load_boston()
      data_X=load_data.data
      data_y=load_data.target
      print(data_X.shape)
      #(506, 13)data_X共13个特征变量
      
      ###训练数据###
      model=LinearRegression()
      model.fit(data_X,data_y)
      model.predict(data_X[:4,:])#预测前4个数据
      
      ###训练好的特征参数w###
      print(model.coef_)
      '''
      [ -1.07170557e-01   4.63952195e-02   2.08602395e-02   2.68856140e+00
        -1.77957587e+01   3.80475246e+00   7.51061703e-04  -1.47575880e+00
         3.05655038e-01  -1.23293463e-02  -9.53463555e-01   9.39251272e-03
        -5.25466633e-01]
      '''
      ###偏差b(回归线的截距)
      print(model.intercept_)
      #36.4911032804
      print(model.get_params())#得到模型的属性
      #{'copy_X': True, 'normalize': False, 'n_jobs': 1, 'fit_intercept': True}
      print(model.score(data_X,data_y))#对训练情况进行打分
      #0.740607742865
      

   2. 数据集+ 正规方程法

      from numpy.core.fromnumeric import shape
      from sklearn import datasets
      from sklearn.linear_model import LinearRegression#引入线性回归模型
      import numpy as np
      import matplotlib.pylab as pyl
      
      ###引入数据###
      load_data=datasets.load_boston()
      data_x=load_data.data
      data_y=load_data.target
      #(506, 13)data_X共13个特征变量
      print("\n数据集的大小：",data_x.shape)
      #在数据集中导入‘变量’x0 = 1，作为最后一列,用于求解偏差b
      b = np.ones(506)
      data_x = np.c_[data_x, b]
      #前500个为训练集，后6个为预测集
      train_x = data_x[:500,:]
      train_y = data_y[:500]
      predict_x = data_x[500:506,:]
      predict_y = data_y[500:506]
      #使用正规方程法求特征参数
      T1 = np.dot(train_x.T, train_x)
      T2 = np.dot(np.linalg.inv(T1), train_x.T)
      w = np.dot(T2, train_y)
      print("\n拟合的特征参数：")
      print(w)
      #评估一下参数的拟合情况(训练集中随机抽取10个数据)
      rand_num = np.random.choice(500, 10)
      test_x = train_x[rand_num]
      test_y = np.dot(test_x, w)
      test_error = train_y[rand_num] - test_y
      test_error = test_error / train_y[rand_num]
      #打印实际值、拟合值和偏差率
      print('\n                                     拟合情况')
      print('\n实际值:',train_y[rand_num])
      print('\n拟合值:',test_y)
      print('\n偏差率:',test_error)
      #展示随机抽取的10个数据的拟合效果
      show_x = np.arange(10)
      pyl.plot(show_x, train_y[rand_num], 'o')
      pyl.plot(show_x, test_y, 'o')
      pyl.ylim([0,70])
      pyl.show()
      #评估一下参数的预测情况(预测最后6个数据)
      P_y = np.dot(predict_x, w)
      Predict_error = predict_y - P_y
      Predict_error = Predict_error / predict_y
      #打印实际值、拟合值和偏差率
      print('\n                                     预测情况')
      print('\n实际值:',predict_y)
      print('\n预测值:',P_y)
      print('\n偏差率:',Predict_error)
      #展示随机抽取的10个数据的拟合效果
      show_x = np.arange(6)
      pyl.plot(show_x, predict_y, 'o')
      pyl.plot(show_x, P_y, 'o')
      pyl.ylim([0,50])
      pyl.show()
      
      
      

      结果：
      
      

三、知识积累

1. Numpy进行矩阵运算（逆矩阵，行列式，转置矩阵、特征值等）

   • 创建矩阵对象：Python列表，numpy.array（），numpy.matrix()
   • 获取和更改（分配）矩阵元素
   • 转置矩阵：.T属性
   • 矩阵总和与差：+运算符，-运算符
   • 标量乘法和按元素乘积：运算符，numpy.multiply（）
   • *矩阵乘积：numpy.dot（），numpy.matmul（），@运算符，*运算符
   • 求幂**运算符
   • **矢量点积：numpy.inner（）
   • **逆矩阵：numpy.linalg.inv（）**或者.I属性
   • 行列式：numpy.linalg.det（）
   • 特征值和特征向量：numpy.linalg.eig（）

2. Numpy创建空矩阵

   >>> a = numpy.zeros(shape=(5,2))
   
   >>> a
   
   array([[ 0., 0.],
   
   [ 0., 0.],
   
   [ 0., 0.],
   
   [ 0., 0.],
   
   [ 0., 0.]])
   

3. 给numpy矩阵添加一列

   使用 np.c_[] 和 np.r_[] 分别添加行和列

   import numpy as np
   a = np.array([[1,2,3],[4,5,6],[7,8,9]])
   b = np.ones(3)
   #[ 1.  1.  1.]
   np.c_[a,b]
   #array([[ 1.,  2.,  3.,  1.],
   #	[ 4.,  5.,  6.,  1.],
   #	[ 7.,  8.,  9.,  1.]])
   np.c_[a,a]
   #array([[1, 2, 3, 1, 2, 3],
   #	[4, 5, 6, 4, 5, 6],
   #	[7, 8, 9, 7, 8, 9]])
   np.c_[b,a]
   #array([[ 1.,  1.,  2.,  3.],
   #	[ 1.,  4.,  5.,  6.],
   #	[ 1.,  7.,  8.,  9.]])
   
   

4. Numpy 中的矩阵求逆

   1. 矩阵求逆

      import numpy as np
      
      a  = np.array([[1, 2], [3, 4]])  # 初始化一个非奇异矩阵(数组)
      print(np.linalg.inv(a))  # 对应于MATLAB中 inv() 函数
      
      # 矩阵对象可以通过 .I 更方便的求逆
      A = np.matrix(a)
      print(A.I)
      
      

   2. 矩阵求伪逆

      import numpy as np
      
      # 定义一个奇异阵 A
      A = np.zeros((4, 4))
      A[0, -1] = 1
      A[-1, 0] = -1
      A = np.matrix(A)
      print(A)
      # print(A.I)  将报错，矩阵 A 为奇异矩阵，不可逆
      print(np.linalg.pinv(a))   # 求矩阵 A 的伪逆（广义逆矩阵），对应于MATLAB中 pinv() 函数
      

   3. Numpy随机抽取二维矩阵中的多行或多列

      法一：

      1. 行随机抽取

      row_rand_array = np.arange(array.shape[0])
      np.random.shuffle(row_rand_array)
      row_rand = array[row_rand_array[0:2]]
      

      2. 列随机抽取

      col_rand_array = np.arange(array.shape[1])
      np.random.shuffle(col_rand_array)
      col_rand = array[col_rand_array[0:2]]
      

      法二：

      1. 随机选数，再根据随机数去挑选

      rand_num = np.random.choice(506, 10)
      test_x = data_X[rand_num]
      #data_X.shape = (506, 14)
      #test_x.shape = (10, 14)