线性回归-梯度下降法

梯度下降法求解最小二乘

梯度下降（GD）是最小化风险函数、损失函数的一种常用方法，随机梯度下降和批量梯度下降是两种迭代求解思路，下面从公式和实现的角度对两者进行分析
下面的h(x)是要拟合的函数，J(theta)是损失函数，theta是参数，要迭代求解的值，theta求解出来了那最终要拟合的函数h(theta)就出来了。其中n是训练集的样本数量，j是参数的个数。

1、批量梯度下降法

（1）构造损失函数

---

（2）求梯度
对J(theta)关于theta求偏导，得到损失函数关于每个theta对应的的梯度

（3）设置参数
1.学习率：
学习率不能设置过大，否则每次theta改变的太快，可能会跳过全局最优解。而陷入局部最优解，但是也不能设置的过小，否则要经过很多次迭代才能收敛到全局最优解
2.最大迭代次数：
即梯度下降法迭代的最大次数
3.误差阈值：
和迭代次数一样是用来控制迭代的结束条件的，当误差小于某个阈值或者迭代次数大于最大迭代次数时就结束迭代

（4）迭代更新theta
梯度是函数增长最快的方向，因此最小化损失函数，要沿着梯度的反方向进行寻优，来更新每个theta

从上面公式可以注意到，每迭代一步，都要用到训练集所有的数据，如果样本数量n很大，那么批量梯度下降的迭代速度会很慢！所以，这就引入了另外一种方法，随机梯度下降。

（5）python的实现

#coding=UTF-8

import numpy as np
import matplotlib.pyplot as plt
class linear_regression_gradient_descent:

    def __init__(self,x,y,eps,alpha,max_iter_times):
        '''
        initalize feature、dependent variable 、learning rate、iteration times
        :param x:
        :param y:
        :param alpha:
        :param max_iter_times:
        '''
        self.x=x
        self.y=y
        self.n = len(self.x)
        self.w=np.zeros((x.shape[1],1))
        self.alpha=alpha
        self.iteration=max_iter_times
        self.eps=eps
        self.cost_review=np.zeros((0,0))

    def error_function(self):
        '''
        compute error of training data in every iteration
        :return:a vector of error
        '''
        # step1 compute cost function
        n = len(self.x)
        y_pred = np.dot(self.x, self.w)
        error = y_pred - self.y
        return error

    def partial_devative(self):
        '''
        compute the partial derivatives of cost functions on theta in every turn
        :return:
        '''
        n = len(self.x)
        error = self.error_function()
        delta_w = np.dot(self.x.T, error) / n
        return delta_w

    def batch_gradient_descent(self):
        '''
        gradient descent to solve the parameter of linear regression
        :return:
        '''
        n = len(self.x)
        itera = 0
        error = self.error_function()
        cost = np.sum(error ** 2) / 2 * n
        while (itera < self.iteration or cost > self.eps):
            #step1 compute the partial derivatives of cost functions on theta
            delta_w = self.partial_devative()
            #step2 update theta
            self.w = self.w - self.alpha * delta_w
            #step3 compute cost function
            error = self.error_function()
            cost = np.sum(error ** 2) / 2 * n
           # print cost
            self.cost_review=np.append(self.cost_review, cost)
            itera += 1
        return self.w
if __name__=="__main__":
        x = np.array([[1, 2, 2, 0, 1], [3, 4, 2, 0, 1], [2, 5, 1, 0, 2], [2, 3, 5, 1, 3], [1, 4, 2, 3, 1], [3, 4, 2, 2, 1]])
        x_theta0 = np.ones(x.shape[0])
        # insert a full-1 col in the first col of X matrix to get the design matrix
        design_matrix = np.insert(x, 0, values=x_theta0, axis=1)
        y = np.array([1.2, 0.4, 0.6, 2.1, 0.9, 0.3]).reshape((len(design_matrix), 1))
        lr = linear_regression_gradient_descent(design_matrix,y,0.15,0.01,100)
        w=lr.batch_gradient_descent()
        print "parameter of linear regression:"+str(w)
        print "iteration times are:"+str(len(lr.cost_review))
    #show the curve of cost function
    fig=plt.figure(1)
    plt.plot(lr.cost_review,color='r')
    plt.ylim(ymin=np.min(lr.cost_review),ymax=np.max(lr.cost_review))
    plt.xlim(xmin=0,xmax=len(lr.cost_review)+1)
    plt.ylabel("cost function")
    plt.xlabel("id of iteration")
    plt.title("cost function of linear regression")
    plt.grid()
    plt.show()

cost_function.png

可以看出：虽然迭代次数设置了100次，但是因为误差一直没有达到设置的阈值0.15以内，因为一直在迭代，大约迭代了将近1000次才结束，在迭代的过程中，可以看到误差一直在不断减小，直至达到阈值要求

2、随机梯度下降法
（1）构造损失函数
上面批量梯度下降对应的是所有的训练样本，可以写成如下这种形式：

损失函数

此时的损失函数对应的是训练集中每个样本的损失函数，是样本粒度的

（2）求梯度
对每个样本的损失函数关于theta求偏导得到梯度

梯度

（3）设置参数
参照批量梯度下降法

（4）迭代更新theta

迭代更新公式

3.SGD与BGD的比较
相同点：都是全局寻优的：
BGD是最小化所有训练样本的损失函数，使得最终求解的是全局的最优解，即求解的参数是使得风险函数最小；
SGD是最小化每条样本的损失函数，SGD伴随的一个问题是噪音较BGD要多，使得SGD并不是每次迭代都向着整体最优化方向。但是大的整体的方向是向全局最优化的，最终的结果往往是在全局最优解附近。
总之，SGD和BGD都是在整个参数区间上进行搜索，学习率越大，每次参数的变动越大，那么可能容易陷入局部最小值，但是整体思想是全局寻优的
不同点：
(1)效率上：
随机梯度下降（SGD）是通过每个样本来迭代更新一次，如果样本量很大的情况（例如几十万），那么可能只用其中几万条或者几千条的样本，就已经将theta迭代到最优解了；
对比上面的批量梯度下降，迭代一次需要用到十几万训练样本，一次迭代不可能最优，如果迭代10次的话就需要遍历训练样本10次。因此SGD在计算的效率上要高于BGD
(2)局部最小值问题
因为SGD是通过每次对部分样本进行迭代，是对BGD的一个随机近似，那么当目标函数有多个局部极小值时，SGD比BGD反而更可能避免进入局部极小值中。
(3)学习率η的选择
对于步长 η的取值，一般BGD的η比SGD的大。因为GD的是使用准确的梯度，理直气壮地走，SGD使用的是近似的梯度，就得小心翼翼地走，怕一不小心误入歧途南辕北辙了。

4.梯度下降法和最小二乘法求解线性回归的比较
(1)梯度下降法是迭代算法，通过每一次迭代不断沿着函数减小最快的方向来改变代价函数的自变量theta，进而减小代价函数值，这一过程我们可以看出：梯度下降法是全局寻优的过程，只要theta设置合理，就不会陷入局部最小值，我们会逐渐收敛到全局最优值；
(2)最小二乘法是对代价函数直接求偏导令其为0，因此是局部寻优，实践表明在属性或者样本数目比较多时，梯度下降法效果更好，且在参数设置合理的情况下，会收敛到全局最优解

5、梯度下降用来求最优解，哪些问题可以求得全局最优？哪些问题可能局部最优解？
对于linear regression问题，如果最优化问题对theta的分布是****unimodal，即从图形上面看只有一个peak，所以梯度下降最终求得的是全局最优解。然而对于multimodal的问题，因为存在多个peak值，很有可能梯度下降的最终结果是局部最优

转载请注明出处：