转载

批量梯度下降, 随机梯度下降,小批量梯度下降

批量梯度下降, 随机梯度下降,小批量梯度下降

  • 批量梯度下降

    计算梯度时,使用全部的样本,换句话说就是,每一次参数更新,使用所有的样本

    缺点:当样本很多时,训练过程非常慢

  • 随机梯度下降

    计算梯度的时,仅仅使用一个样本,换句话说就是,每一次参数更新,使用一个样本。

    换句话说,可以是个增量更新的过程。

    缺点:每一次更新,计算出来的‘‘梯度’’并不是真正的梯度,也就是说每一次更新,

    并不是朝着整体最优的方向进行的。

  • 小批量梯度下降

    计算梯度时,使用一部分样本。换句话说就是,每一次参数更新,使用样本中的一小部分

    优点:是上面两种算法的一个平衡

  • python代码

    批量梯度下降算法

    from numpy import *
    
    #input x input y
    X = [[1, 1, 1], [2, 2, 2], [1, 1, 0], [5, 1, 0], [3, 2 , 1], \
        [1, 0, 1], [7, 0, 2], [8, 1, 0], [5, 6, 5], [0, 0, 0]] 
    Y = [6, 11, 4, 12, 11, 5, 19, 18, 27, 1]
    
    X, Y = mat(X), mat(Y)
    X = insert(X, 0, ones(shape(X)[0]), axis=1)
    m, n = shape(X)
    
    #阈值 步长(步长较大,疯狂震荡), 最大迭代次数
    threshold, step, iterator =  0.00001, 0.001, 10000
     
    #初始化参数 计算初始误差
    theta = ones((n, 1))
    preError = sum(0.5 * power(X * theta - Y.transpose(), 2)) / m
    
    times = 0
    while times < iterator:
        times += 1
        theta = theta - step * X.transpose() * (X * theta - Y.transpose())
        #计算新参数的误差
        error = sum(0.5 * power(X * theta - Y.transpose(), 2)) / m
        if abs(preError - error) < threshold:
            break
        else:
            preError = error
    print ('ParValue: ', theta)
    

    随机梯度下降算法

    from numpy import *
    
    #input x input y
    X = [[1, 1, 1], [2, 2, 2], [1, 1, 0], [5, 1, 0], [3, 2 , 1], \
        [1, 0, 1], [7, 0, 2], [8, 1, 0], [5, 6, 5], [0, 0, 0]] 
    Y = [6, 11, 4, 12, 11, 5, 19, 18, 27, 1]
    
    X, Y = mat(X), mat(Y)
    X = insert(X, 0, ones(shape(X)[0]), axis=1)
    m, n = shape(X)
    
    #阈值 步长(步长较大,疯狂震荡), 最大迭代次数
    threshold, step, iterator =  0.00001, 0.001, 10000
     
    #初始化参数 计算初始误差
    theta = ones((n, 1))
    preError = sum(0.5 * power(X * theta - Y.transpose(), 2)) / m
    
    times = 0
    while times < iterator:
        times += 1
        for index in range(m):
            #修改这一行
            theta = theta - step * X[index].transpose() * (X[index] * theta - Y.transpose()[index])
            #计算新参数的误差
            error = sum(0.5 * power(X * theta - Y.transpose(), 2)) / m
            if abs(preError - error) < threshold:
                times = iterator
                break
            else:
                preError = error
    print ('ParValue: ', theta)
    

    小批量梯度下降

    from numpy import *
    
    #input x input y
    X = [[1, 1, 1], [2, 2, 2], [1, 1, 0], [5, 1, 0], [3, 2 , 1], \
        [1, 0, 1], [7, 0, 2], [8, 1, 0], [5, 6, 5], [0, 0, 0]] 
    Y = [6, 11, 4, 12, 11, 5, 19, 18, 27, 1]
    
    X, Y = mat(X), mat(Y)
    X = insert(X, 0, ones(shape(X)[0]), axis=1)
    m, n = shape(X)
    
    #阈值 步长(步长较大,疯狂震荡), 最大迭代次数
    threshold, step, iterator =  0.00001, 0.001, 10000
     
    #初始化参数 计算初始误差
    theta = ones((n, 1))
    preError = sum(0.5 * power(X * theta - Y.transpose(), 2)) / m
    
    #一次选三个小样本
    b = 3; times = 0
    
    while times < iterator:
        times += 1; start = 0
        while start < m:
            tempX = X[start:start+b]
            tempY = Y.transpose()[start:start+b];
            #修改这一行
            theta = theta - step * tempX.transpose() * (tempX * theta - tempY)
            #计算新参数的误差
            error = sum(0.5 * power(X * theta - Y.transpose(), 2)) / m
            if abs(preError - error) < threshold:
                time = iterator
                break
            else:
                preError = error
            start += b
    
    print ('ParValue: ', theta)
    
正文到此结束
本文目录