多元线性回归及梯度下降

曾经终败给现在 2022-07-16 01:08 240阅读 0赞

**一、线性回归定义**

方法：线性回归属于监督学习，因此方法和监督学习应该是一样的，先给定一个训练集，根据这个训练集学习出一个线性函数，然后测试这个函数训练的好不好（即此函数是否足够拟合训练集数据），挑选出最好的函数（cost function最小）即可。

线性方程应如下表示：

![gif.latex_7B_5Ccolor_7BMagenta_7D_20h_7B0_7D_28x_29_3D_5Ctheta_20_7B0_7D_plus_5Ctheta_20_7B1_7Dx_7B1_7D_plus_5Ctheta_20_7B2_7Dx_7B2_7D_plus_..._20_7D][]

因此，线性方程可以如下表示：

![gif.latex_7B_5Ccolor_7BMagenta_7D_20h_28x_29_3D_5Csum_7Bi_3D1_7D_5E_7Bn_7D_5Ctheta_20_7Bi_7Dx_7Bi_7D_3D_5Ctheta_20_5E_7BT_7DX_7D][]

因上式中![gif.latex_x_7B0_7D_3D1][]，而求线性方程则演变成了求方程的参数ΘT。

线性回归假设特征和结果满足线性关系。其实线性关系的表达能力非常强大，每个特征对结果的影响强弱可以有前面的参数体现，而且每个特征变量可以首先映射到一个函数，然后再参与线性计算，这样就可以表达特征与结果之间的非线性关系。

**二、梯度下降算法**

为了得到目标线性方程，我们只需确定上式中的ΘT，同时为了确定所选定的的ΘT效果好坏，通常情况下，我们使用一个损失函数(loss function)或者说是错误函数(error function)来评估h(x)函数的好坏。该错误函数如下所示。

![gif.latex_7B_5Ccolor_7BMagenta_7DJ_28_5Ctheta_20_29_3D_5Cfrac_7B1_7D_7B2m_7D_5Csum_7Bi_3D1_7D_5E_7Bm_7D_28h_7B_5Ctheta_20_7D_28x_5E_7Bi_7D_29-y_5E_7Bi_7D_29_5E_7B2_7D_7D][]

如何调整ΘT以使得J(Θ)取得最小值有很多方法，其中有完全用数学描述的最小二乘法(min square)和梯度下降法。

由之前所述，求ΘT的问题演变成了求J(Θ)的极小值问题，这里使用梯度下降法。而梯度下降法中的梯度方向由J(Θ)对Θ的偏导数确定，由于求的是极小值，因此梯度方向是偏导数的反方向。

![gif.latex_7B_5Ccolor_7BMagenta_7D_5Ctheta_20_7Bj_7D_3A_3D_5Ctheta_20_7Bj_7D-_5Calpha_20_5Cfrac_7B_5Cpartial_20_7D_7B_5Cpartial_20_5Ctheta_20_7Bj_7D_7DJ_28_5Ctheta_20_29_7D][]

公式中α为学习速率，当α过大时，有可能越过最小值，而α当过小时，容易造成迭代次数较多，收敛速度较慢。

可以由一下变形：

![gif.latex_7B_5Ccolor_7BMagenta_7D_5Cfrac_7B_5Cpartial_20_7D_7B_5Cpartial_20_5Ctheta_20_7Bj_7D_7DJ_28_5Ctheta_20_29_3D_5Cfrac_7B1_7D_7B2m_7D_5Cfrac_7B_5Cpartial_20_7D_7B_5Cpartial_20_5Ctheta_20_7Bj_7D_7D_5Csum_7Bi_3D1_7D_5E_7Bm_7D_28h_7B_5Ctheta_20_7D_28x_5E_7Bi_7D_29-y_5E_7Bi_7D_29_5E_7B2_7D_7D][]

![gif.latex_7B_5Ccolor_7BMagenta_7D_5Cfrac_7B_5Cpartial_20_7D_7B_5Cpartial_20_5Ctheta_20_7Bj_7D_7DJ_28_5Ctheta_20_29_3D_5Cfrac_7B1_7D_7Bm_7D_5Csum_7Bi_3D1_7D_5E_7Bm_7D_5B_28h_7B_5Ctheta_20_7D_28x_5E_7Bi_7D_29-y_5E_7Bi_7D_29_5Cfrac_7B_5Cpartial_20_7D_7B_5Cpartial_20_5Ctheta_20_7Bj_7D_7D_28h_7B_5Ctheta_20_7D_28x_5E_7Bi_7D_29-y_5E_7Bi_7D_29_5D_7D][]

所以：

![gif.latex_7B_5Ccolor_7BMagenta_7D_5Ctheta_7Bj_7D_3A_3D_5Ctheta_7Bj_7D-_5Cfrac_7B_5Calpha_20_7D_7Bm_7D_5Csum_7Bi_3D1_7D_5E_7Bm_7D_28h_7B_5Ctheta_20_7D_28x_5E_7Bi_7D_29-y_5E_7Bi_7D_29x_7Bi_2Cj_7D_7D][]

初始时ΘT可全设为1，然后迭代使用上式计算ΘT中的每个参数，直至收敛为止。由于每次迭代计算ΘT时，都使用了整个样本集，因此我们称该梯度下降算法为批量梯度下降算法(batch gradient descent)。

**三、代码实现**

package linearRegression;
    
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileReader;
    import java.io.IOException;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * Created by hui on 2016/9/25.
     */
    public class LinearRegression {
        /**
         * 训练数据示例：
         *   x0        x1        x2        y
            1.0       1.0       2.0       7.2
            1.0       2.0       1.0       4.9
            1.0       3.0       0.0       2.6
            1.0       4.0       1.0       6.3
            1.0       5.0      -1.0       1.0
            1.0       6.0       0.0       4.7
            1.0       7.0      -2.0      -0.6
            注意！！！！x1，x2，y三列是用户实际输入的数据，x0是为了推导出来的公式统一，特地补上的一列。
            x0,x1,x2是“特征”，y是结果
    
            h(x) = theta0 * x0 + theta1* x1 + theta2 * x2
    
            theta0,theta1,theta2 是想要训练出来的参数
    
            此程序采用“梯度下降法”
    
         *
         */
    
        private double [][] trainData;     //训练数据，一行一个记录，每行最后一个数据为y
    
        private int row;                   //训练数据，行数
    
        private int column;                //训练数据  列数
    
        private double[] theta;            //参数
    
        private double alpha;              //训练步长
    
        private int iteration;             //迭代次数
    
        private double error;              //训练误差
    
        public LinearRegression(String fileName){
    
            this(fileName, 0.001, 100);               //默认设置：步长为0.001；迭代次数为100；
        }
    
        public LinearRegression(String fileName, double alpha, int iteration){
    
            getRowAndColumnNumber(fileName);             //初始化矩阵行数、列数
    
            trainData = new double[row][column];         //声明训练矩阵大小
    
            this.alpha = alpha;                          //初始化训练步长
    
            this.iteration = iteration;                  //初始化迭代次数
    
            this.error = 0.0001;                          //最小训练误差
    
            theta = new double[column-1];                //声明参数数组大小
    
            loadTrainData(fileName);                     //加载并初始化训练数据
    
            init_theta();                                //初始化训练参数
        }
    
        /**
         * 根据输入的文件获得文件的行数和列数
         * @param fileName
         */
        public void getRowAndColumnNumber(String fileName){
            int rowCount = 1;                            //设为1的原因，因为在获得列数的时候已经加载了一行
            int columnCount = 0;
            File file = new File(fileName);
            BufferedReader reader = null;
            try{
                //获得列数
                reader = new BufferedReader(new FileReader(file));
                String temp = reader.readLine();
                if(temp != null){
                    columnCount = temp.split(" ").length;
                }
    
                //获得行数
                while(reader != null && reader.readLine() != null){
                    rowCount++;
                }
    
                this.column = columnCount+1;          //注意，为什么要+1？？？ 因为为了使得公式整齐，我们加了一个特征x0，x0恒等于1
                this.row = rowCount;
                System.out.println(this.column);
                System.out.println(this.row);
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                if(reader != null)
                    try{
                        reader.close();
                    }catch (IOException e){
    
                    }
            }
        }
    
        /**
         * 加载训练数据
         * @param fileName 文件名
         */
        public void loadTrainData(String fileName){
            //trainData的第一列全部置于1.0
            for(int i = 0; i < this.row; i++)
                trainData[i][0] = 1.0;
    
            File file = new File(fileName);
            BufferedReader reader = null;
            try{
                reader = new BufferedReader(new FileReader(file));
                String tempString = null;
                int rowCount = 0;
                while(rowCount < this.row && (tempString = reader.readLine())!=null){
                    String [] tempData = tempString.split(" ");
                    for(int i = 1; i < this.column; i++)
                        trainData[rowCount][i] = Double.parseDouble(tempData[i-1]);
                    rowCount++;
                }
                reader.close();
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                if(reader != null)
                    try{
                        reader.close();
                    }catch (IOException e){
    
                    }
            }
        }
    
        /**
         *初始化训练参数
         */
        public void init_theta(){
            for(int i = 0; i<column-1; i++)
                theta[i] = 1.0;
        }
    
        /**
         * 利用梯度下降算法计算模型的训练参数
         */
        public void train_theta(){
          for(int i = 0; i < iteration; i++){
    
              //对每个训练参数，计算偏导数
              double [] partial_derivative = compute_partial_derivative();
    
              //计算新一轮的训练参数
              for(int j = 0; j < column-1; j++){
                  theta[j] = theta[j] - alpha * partial_derivative[j];
              }
    
              for(int j = 0; j< column-1; j++)
                  System.out.print(theta[j]+" ");
              System.out.println();
    
              //判断损失函数是否达到要求的最小值，达到要求则退出迭代
              double error = compute_error();
              if(error < this.error) {
                  System.out.println("The number of iteration: " + (i+1));
                  return;
              }
          }
        }
    
        /**
         * 计算所以训练参数的偏导数
         * @return
         */
        public double[] compute_partial_derivative(){
            double []partial_derivative = new double[column-1];
            for(int i = 0; i < column-1; i++){
                partial_derivative[i] = compute_every_partial_derivative(i);
            }
            return partial_derivative;
        }
    
        /**
         * 计算每个参数的偏导数
         * @param j    第几个需要计算的参数
         * @return
         */
        public double compute_every_partial_derivative(int j){
            double sum = 0;
            for(int i = 0; i < row; i++){
                sum += compute_row_error(i) * trainData[i][j];
            }
            return sum/row;
        }
    
        /**
         * 计算损失函数的大小，用来决定是否继续迭代
         * @return
         */
        public double compute_error(){
            double sum = 0;
            for(int i = 0; i < row; i++){
                double temp = compute_row_error(i);
                sum += temp * temp;
            }
            return sum/(2*row);
        }
    
        /**
         * 计算第row行预测值和真实值之差，可能为负数
         * @param row
         * @return
         */
        public double compute_row_error(int row){
            double error = 0;
            for(int i = 0; i < column-1; i++){
                error += theta[i] * trainData[row][i];
            }
            error = error - trainData[row][column-1];
            return error;
        }
    
        public void main(){
            train_theta();
            printData();
            printTheta();
        }
        /**
         * 打印训练数据
         */
        public void printData(){
            System.out.println("Train Data:");
            for(int i =0;i<column-1;i++)
                System.out.printf("%10s", "x"+i+" ");
            System.out.printf("%10s", "y" + "\n");
    
            for(int i = 0; i < row; i++){
                for(int j = 0; j < column; j++)
                    System.out.printf("%10s", trainData[i][j] + " ");
                System.out.println();
            }
        }
    
        /**
         * 打印模型的训练参数
         */
        public void printTheta(){
            for(int i = 0; i < column-1; i++)
                System.out.print(theta[i]+"  ");
            System.out.println();
        }
    
        /**
         * 测试给定的样例
         * @param num
         */
        public void test(double []num){
            System.out.println("core:");
            double []str = this.theta;
            double sum=0.0;
            for(int i=0;i<num.length;i++) {
                sum = sum + str[i] * num[i];
            }
            System.out.println(sum);
        }
    }

import linearRegression.LinearRegression;
    
    /**
     * Created by hui on 2016/9/25.
     */
    public class linearRTest {
        public static void main(String []args){
            String fileName = "C:\\Users\\John\\Desktop\\train.txt";
            LinearRegression linearRegression = new LinearRegression(fileName,0.001,100000);
            linearRegression.main();
    
            double []num = new double[3];
            num[0]=1.0;
            num[1]=4.0;
            num[2]=1.0;
            linearRegression.test(num);
            System.exit(0);               //中断程序
        }
    
    }

[gif.latex_7B_5Ccolor_7BMagenta_7D_20h_7B0_7D_28x_29_3D_5Ctheta_20_7B0_7D_plus_5Ctheta_20_7B1_7Dx_7B1_7D_plus_5Ctheta_20_7B2_7Dx_7B2_7D_plus_..._20_7D]: /images/20220716/d8d597d57da04d29b56f3b3efce5b708.png
[gif.latex_7B_5Ccolor_7BMagenta_7D_20h_28x_29_3D_5Csum_7Bi_3D1_7D_5E_7Bn_7D_5Ctheta_20_7Bi_7Dx_7Bi_7D_3D_5Ctheta_20_5E_7BT_7DX_7D]: /images/20220716/4380e22057f94025a8d4ad68e40af305.png
[gif.latex_x_7B0_7D_3D1]: /images/20220716/c337715bee594ea4b3220a4cbee2c0d5.png
[gif.latex_7B_5Ccolor_7BMagenta_7DJ_28_5Ctheta_20_29_3D_5Cfrac_7B1_7D_7B2m_7D_5Csum_7Bi_3D1_7D_5E_7Bm_7D_28h_7B_5Ctheta_20_7D_28x_5E_7Bi_7D_29-y_5E_7Bi_7D_29_5E_7B2_7D_7D]: /images/20220716/383d0c4ab90e4ff0a26b215be4113a83.png
[gif.latex_7B_5Ccolor_7BMagenta_7D_5Ctheta_20_7Bj_7D_3A_3D_5Ctheta_20_7Bj_7D-_5Calpha_20_5Cfrac_7B_5Cpartial_20_7D_7B_5Cpartial_20_5Ctheta_20_7Bj_7D_7DJ_28_5Ctheta_20_29_7D]: /images/20220716/df1e167438f1423cbcc58a96da732760.png
[gif.latex_7B_5Ccolor_7BMagenta_7D_5Cfrac_7B_5Cpartial_20_7D_7B_5Cpartial_20_5Ctheta_20_7Bj_7D_7DJ_28_5Ctheta_20_29_3D_5Cfrac_7B1_7D_7B2m_7D_5Cfrac_7B_5Cpartial_20_7D_7B_5Cpartial_20_5Ctheta_20_7Bj_7D_7D_5Csum_7Bi_3D1_7D_5E_7Bm_7D_28h_7B_5Ctheta_20_7D_28x_5E_7Bi_7D_29-y_5E_7Bi_7D_29_5E_7B2_7D_7D]: /images/20220716/7a6718ca4c434cc19847857e6561b4c4.png
[gif.latex_7B_5Ccolor_7BMagenta_7D_5Cfrac_7B_5Cpartial_20_7D_7B_5Cpartial_20_5Ctheta_20_7Bj_7D_7DJ_28_5Ctheta_20_29_3D_5Cfrac_7B1_7D_7Bm_7D_5Csum_7Bi_3D1_7D_5E_7Bm_7D_5B_28h_7B_5Ctheta_20_7D_28x_5E_7Bi_7D_29-y_5E_7Bi_7D_29_5Cfrac_7B_5Cpartial_20_7D_7B_5Cpartial_20_5Ctheta_20_7Bj_7D_7D_28h_7B_5Ctheta_20_7D_28x_5E_7Bi_7D_29-y_5E_7Bi_7D_29_5D_7D]: /images/20220716/cb75fb4135ae48ab86eff7446123a57e.png
[gif.latex_7B_5Ccolor_7BMagenta_7D_5Cfrac_7B_5Cpartial_20_7D_7B_5Cpartial_20_5Ctheta_20_7Bj_7D_7DJ_28_5Ctheta_20_29_3D_5Cfrac_7B1_7D_7Bm_7D_5Csum_7Bi_3D1_7D_5E_7Bm_7D_28h_7B_5Ctheta_20_7D_28x_5E_7Bi_7D_29-y_5E_7Bi_7D_29x_7Bi_2Cj_7D_7D]: /images/20220716/9b0bf3d0ae514c6ba9b575db4af5ab64.png
[gif.latex_7B_5Ccolor_7BMagenta_7D_5Ctheta_7Bj_7D_3A_3D_5Ctheta_7Bj_7D-_5Cfrac_7B_5Calpha_20_7D_7Bm_7D_5Csum_7Bi_3D1_7D_5E_7Bm_7D_28h_7B_5Ctheta_20_7D_28x_5E_7Bi_7D_29-y_5E_7Bi_7D_29x_7Bi_2Cj_7D_7D]: /images/20220716/79d59b82f9cb4f6fa5b56f844f183a72.png