zoukankan      html  css  js  c++  java
  • 跟我学算法-吴恩达老师(mini-batchsize,指数加权平均,Momentum 梯度下降法,RMS prop, Adam 优化算法, Learning rate decay)

    1.mini-batch size

        表示每次都只筛选一部分作为训练的样本,进行训练,遍历一次样本的次数为(样本数/单次样本数目) 

        当mini-batch size 的数量通常介于1,m 之间
        当为1时,称为随机梯度下降

        一般我们选择64,128, 256等样本数目

    import numpy as np
    import math
    def random_mini_batch(X, Y, mini_batch = 64, seed=0):
    
        np.random.seed(seed)
        m = X.shape[1]  # 表示X样本的数量
        mini_batches = []
    
        # step 1  shuffle(X, Y)  np.random.permutation(m) 随机排列一个数字
        permutation = list(np.random.permutation(m))
    
        X_shuffle = X[:, permutation]
        Y_shuffle = Y[:, permutation]
        
        num_complete_minibatch = math.floor(m/mini_batch)
        
        for k in range(0, num_complete_minibatch):
            
            mini_batch_x = X_shuffle[:, k*mini_batch:(k+1)*mini_batch]
            mini_batch_y = Y_shuffle[:, k * mini_batch:(k + 1) * mini_batch]
            
            mini_batches.append((mini_batch_x, mini_batch_y))
            
        if m%mini_batch != 0:    
            mini_batch_x = X_shuffle[:, num_complete_minibatch*mini_batch:m]
            mini_batch_y = Y_shuffle[:, num_complete_minibatch*mini_batch:m]
            mini_batches.append((mini_batch_x, mini_batch_y))
            
        
        return mini_batches 

    2. 指数加权平均
       v0 = 0 

       v1 = 0.9 * v0 + 0.1 * θ1   v0表示前一次的数值,θ1表示当前的数值

       v2 = 0.9 * v1 + 0.1 * θ2

       v3 = 0.9 * v2 + 0.1 * θ3

       v4 = 0.9 * v3 + 0.1 * θ4

       vt = β * vt-1 + (1-β) * θt  

       举个例子:

           v100 = 0.1*θ100 + 0.1*0.9*θ99 + 0.1*0.9^2*θ98 ...

       指数加权的偏差修正 

              vt / (1-β^t)   β 通常表示 0.9, t表示时间

              (1-ξ)^(1/ξ) = 1/e 

    3. Momentum 梯度下降法, 加快梯度下降的速度,在横轴方向上进行了加权,因为方向相同,在纵轴上进行了削减,因为方向相反,因此梯度下降前进的方向更快

        动量梯度下降法, 前一次的方向与当前次的方向进行指数加权,得到当前此的方向

         vdw = β * vdw(forward) + (1-β) * dw 

         vdb = β * vdb(forward) + (1-β) * db 

         w: = w - α * vdw 

         b: = b - α * bdw 

        

    def update_parameters_with_Momentum(parameter, grade, v, beta, learning_rate):
    
    
    
        L = len(parameter) // 2
    
        for i in range(L):
    
            v['dW' + str(i+1)] = beta*v['dW' + str(i+1)] + (1-beta) * grade['dW' + str(i+1)]
            v['db' + str(i+1)] = beta*v['db' + str(i+1)] + (1-beta) * grade['db' + str(i+1)]
    
            parameter['dW' + str(i+1)] = parameter['dW' + str(i+1)] - learning_rate * v['dW' + str(i+1)]
            parameter['db' + str(i+1)] = parameter['db' + str(i+1)] - learning_rate * v['db' + str(i+1)]
    
    
        return  parameter, grade, v

    4. RMS prop 

        Sdw = β * sdw(forward) + (1 - β) * dw^2 

        Sdb = β * sdb(forward) + (1 - β) * db^2 

        w: = w -  α * dw/(sqrt(sdw)+ε)

        b: = b - α * db/(sqrt(sdb)+ε)

    5. Adam 优化算法,是将动量梯度下降法与RMS prop 结合

    vdw = 0  

    sdw = 0 

    vab = 0

    sab = 0 

         vdw = β1 * vdw(forward) + (1-β1) * dw 

         vdb = β1 * vdb(forward) + (1-β1) * db 

        Sdw = β2 * sdw(forward) + (1 - β2) * dw^2 

        Sdb = β2 * sdb(forward) + (1 - β2) * db^2

        vdw(correct) = vdw / (1-β1^t) 

        vdb(correct) = vdb / (1-β1^t)

        Sdw(correct) = Sdw / (1-β2^t) 

        Sdb(correct) = Sdb / (1-β2^t)

        w: = w -  α *  vdw(correct)/(sqrt(Sdw(correct))+ε)

        b: = b - α * vdb(correct)/(sqrt( Sdb(correct) )+ε) 

       β1 = 0.9 

       β2 = 0.999 

       ε = 10^-8 

    def update_parameters_with_Adam(parameter, grade, v, s, t, learning_rate, beta1=0.9, beta2=0.999, g=1e-8):
        
        L = len(parameter) // 2 
        
        for i in range(L):
            v['dW' + str(i + 1)] = (beta1 * v['dW' + str(i+1)] + (1 - beta1) * grade['dw' + str(i+1)]) / (1-beta1 ** t)
            v['db' + str(i + 1)] = (beta1 * v['db' + str(i + 1)] + (1 - beta1) * grade['db' + str(i + 1)]) / (1-beta1 ** t)
    
            s['dW' + str(i + 1)] = (beta2 * s['dW' + str(i + 1)] + (1 - beta2) * grade['dw' + str(i + 1)] ** 2) / (1-beta1 ** t)
            s['db' + str(i + 1)] = (beta2 * s['db' + str(i + 1)] + (1 - beta2) * grade['db' + str(i + 1)] ** 2) / (1-beta1 ** t)
            
            parameter['W' + str(i + 1)] = parameter['W' + str(i + 1)] - learning_rate*(v['dW' + str(i + 1)]) 
                                                                        / (s['dW' + str(i + 1)] + g)
            parameter['b' + str(i + 1)] = parameter['b' + str(i + 1)] - learning_rate * (v['db'] + str(i + 1)) 
                                                                        / (s['db' + str(i + 1)] + g)
            
        return v, s, parameter, grade 

    6. Learning rate decay

    根据迭代的次数,加快学习率的降低,使得样本参数更容易发生收敛,但是一般情况下不使用

    3种更新α的公式

    α =  1  / (1 + decay-rate * epoch-num) * α0  α0表示初始学习率, decay-rate 表示衰减层度, epoch-num 表示迭代次数
    α = 0.95^epoch_num * α0 

    α = k / sqrt(epoch_num) * α0 

          

       

  • 相关阅读:
    第一阶段冲刺05
    生成器
    三元表达式 ,列表推导式 , 字典生成式
    装饰器
    闭包函数
    函数的定义和参数
    列表内置方法
    字符串的内置方法
    py_11_ 0731
    py_11_ 0730
  • 原文地址:https://www.cnblogs.com/my-love-is-python/p/9700196.html
Copyright © 2011-2022 走看看