Mini-Batch
1. 把訓練集打亂，但是X和Y依舊是一一對應的
import numpy as np a = np.random.randn(3,3) print(a) b = list(np.random.permutation(3)) #生成無序的數字0-2之間 print(b) a_shuffled = a[b] #通過索引迭代生成打亂的a print(a_shuffled)
2.創建迷你分支數據集
def random_mini_batches(X,Y,mini_batch_size=64,seed=0): """ 從（X，Y）中創建一個隨機的mini-batch列表 參數： X - 輸入數據，維度為(輸入節點數量，樣本的數量) Y - 對應的是X的標簽，【1 | 0】（藍|紅），維度為(1,樣本的數量) mini_batch_size - 每個mini-batch的樣本數量 返回： mini-bacthes - 一個同步列表，維度為（mini_batch_X,mini_batch_Y） """ np.random.seed(seed) #指定隨機種子 m = X.shape[1] mini_batches = [] #第一步：打亂順序 permutation = list(np.random.permutation(m)) #它會返回一個長度為m的隨機數組，且里面的數是0到m-1 shuffled_X = X[:,permutation] #將每一列的數據按permutation的順序來重新排列。 shuffled_Y = Y[:,permutation].reshape((1,m)) """ #博主注： #如果你不好理解的話請看一下下面的偽代碼，看看X和Y是如何根據permutation來打亂順序的。 x = np.array([[1,2,3,4,5,6,7,8,9], [9,8,7,6,5,4,3,2,1]]) y = np.array([[1,0,1,0,1,0,1,0,1]]) random_mini_batches(x,y) permutation= [7, 2, 1, 4, 8, 6, 3, 0, 5] shuffled_X= [[8 3 2 5 9 7 4 1 6] [2 7 8 5 1 3 6 9 4]] shuffled_Y= [[0 1 0 1 1 1 0 1 0]] """ #第二步，分割 num_complete_minibatches = math.floor(m / mini_batch_size) #把你的訓練集分割成多少份,請注意，如果值是99.99，那么返回值是99，剩下的0.99會被舍棄 for k in range(0,num_complete_minibatches): mini_batch_X = shuffled_X[:,k * mini_batch_size:(k+1)*mini_batch_size] mini_batch_Y = shuffled_Y[:,k * mini_batch_size:(k+1)*mini_batch_size] """ #博主注： #如果你不好理解的話請單獨執行下面的代碼，它可以幫你理解一些。 a = np.array([[1,2,3,4,5,6,7,8,9], [9,8,7,6,5,4,3,2,1], [1,2,3,4,5,6,7,8,9]]) k=1 mini_batch_size=3 print(a[:,1*3:(1+1)*3]) #從第4列到第6列 ''' [[4 5 6] [6 5 4] [4 5 6]] ''' k=2 print(a[:,2*3:(2+1)*3]) #從第7列到第9列 ''' [[7 8 9] [3 2 1] [7 8 9]] ''' #看一下每一列的數據你可能就會好理解一些 """ mini_batch = (mini_batch_X,mini_batch_Y) mini_batches.append(mini_batch) #如果訓練集的大小剛好是mini_batch_size的整數倍，那么這里已經處理完了 #如果訓練集的大小不是mini_batch_size的整數倍，那么最后肯定會剩下一些，我們要把它處理了 if m % mini_batch_size != 0: #獲取最后剩余的部分 mini_batch_X = shuffled_X[:,mini_batch_size * num_complete_minibatches:] mini_batch_Y = shuffled_Y[:,mini_batch_size * num_complete_minibatches:] mini_batch = (mini_batch_X,mini_batch_Y) mini_batches.append(mini_batch) return mini_batches
Momentum
1初始化
def initialize_velocity(parameters): """ 初始化速度，velocity是一個字典： - keys: "dW1", "db1", ..., "dWL", "dbL" - values:與相應的梯度/參數維度相同的值為零的矩陣。 參數： parameters - 一個字典，包含了以下參數： parameters["W" + str(l)] = Wl parameters["b" + str(l)] = bl 返回: v - 一個字典變量，包含了以下參數： v["dW" + str(l)] = dWl的速度 v["db" + str(l)] = dbl的速度 """ L = len(parameters) // 2 #神經網絡的層數 v = {} for l in range(L): v["dW" + str(l + 1)] = np.zeros_like(parameters["W" + str(l + 1)]) v["db" + str(l + 1)] = np.zeros_like(parameters["b" + str(l + 1)]) return v
2動量更新參數
def update_parameters_with_momentun(parameters,grads,v,beta,learning_rate): """ 使用動量更新參數 參數： parameters - 一個字典類型的變量，包含了以下字段： parameters["W" + str(l)] = Wl parameters["b" + str(l)] = bl grads - 一個包含梯度值的字典變量，具有以下字段： grads["dW" + str(l)] = dWl grads["db" + str(l)] = dbl v - 包含當前速度的字典變量，具有以下字段： v["dW" + str(l)] = ... v["db" + str(l)] = ... beta - 超參數，動量，實數 learning_rate - 學習率，實數 返回： parameters - 更新后的參數字典 v - 包含了更新后的速度變量 """ L = len(parameters) // 2 for l in range(L): #計算速度 v["dW" + str(l + 1)] = beta * v["dW" + str(l + 1)] + (1 - beta) * grads["dW" + str(l + 1)] v["db" + str(l + 1)] = beta * v["db" + str(l + 1)] + (1 - beta) * grads["db" + str(l + 1)] #更新參數 parameters["W" + str(l + 1)] = parameters["W" + str(l + 1)] - learning_rate * v["dW" + str(l + 1)] parameters["b" + str(l + 1)] = parameters["b" + str(l + 1)] - learning_rate * v["db" + str(l + 1)] return parameters,v
Adam
Adam算法是訓練神經網絡中最有效的算法之一，它是RMSProp算法與Momentum算法的結合體。
1.初始化參數
def initialize_adam(parameters): """ 初始化v和s，它們都是字典類型的變量，都包含了以下字段： - keys: "dW1", "db1", ..., "dWL", "dbL" - values：與對應的梯度/參數相同維度的值為零的numpy矩陣 參數： parameters - 包含了以下參數的字典變量： parameters["W" + str(l)] = Wl parameters["b" + str(l)] = bl 返回： v - 包含梯度的指數加權平均值，字段如下： v["dW" + str(l)] = ... v["db" + str(l)] = ... s - 包含平方梯度的指數加權平均值，字段如下： s["dW" + str(l)] = ... s["db" + str(l)] = ... """ L = len(parameters) // 2 v = {} s = {} for l in range(L): v["dW" + str(l + 1)] = np.zeros_like(parameters["W" + str(l + 1)]) v["db" + str(l + 1)] = np.zeros_like(parameters["b" + str(l + 1)]) s["dW" + str(l + 1)] = np.zeros_like(parameters["W" + str(l + 1)]) s["db" + str(l + 1)] = np.zeros_like(parameters["b" + str(l + 1)]) return (v,s)
2.Adam算法實現
def update_parameters_with_adam(parameters,grads,v,s,t,learning_rate=0.01,beta1=0.9,beta2=0.999,epsilon=1e-8): """ 使用Adam更新參數 參數： parameters - 包含了以下字段的字典： parameters['W' + str(l)] = Wl parameters['b' + str(l)] = bl grads - 包含了梯度值的字典，有以下key值： grads['dW' + str(l)] = dWl grads['db' + str(l)] = dbl v - Adam的變量，第一個梯度的移動平均值，是一個字典類型的變量 s - Adam的變量，平方梯度的移動平均值，是一個字典類型的變量 t - 當前迭代的次數 learning_rate - 學習率 beta1 - 動量，超參數,用於第一階段，使得曲線的Y值不從0開始（參見天氣數據的那個圖） beta2 - RMSprop的一個參數，超參數 epsilon - 防止除零操作（分母為0） 返回： parameters - 更新后的參數 v - 第一個梯度的移動平均值，是一個字典類型的變量 s - 平方梯度的移動平均值，是一個字典類型的變量 """ L = len(parameters) // 2 v_corrected = {} #偏差修正后的值 s_corrected = {} #偏差修正后的值 for l in range(L): #梯度的移動平均值,輸入："v , grads , beta1",輸出：" v " v["dW" + str(l + 1)] = beta1 * v["dW" + str(l + 1)] + (1 - beta1) * grads["dW" + str(l + 1)] v["db" + str(l + 1)] = beta1 * v["db" + str(l + 1)] + (1 - beta1) * grads["db" + str(l + 1)] #計算第一階段的偏差修正后的估計值，輸入"v , beta1 , t" , 輸出："v_corrected" v_corrected["dW" + str(l + 1)] = v["dW" + str(l + 1)] / (1 - np.power(beta1,t)) v_corrected["db" + str(l + 1)] = v["db" + str(l + 1)] / (1 - np.power(beta1,t)) #計算平方梯度的移動平均值，輸入："s, grads , beta2"，輸出："s" s["dW" + str(l + 1)] = beta2 * s["dW" + str(l + 1)] + (1 - beta2) * np.square(grads["dW" + str(l + 1)]) s["db" + str(l + 1)] = beta2 * s["db" + str(l + 1)] + (1 - beta2) * np.square(grads["db" + str(l + 1)]) #計算第二階段的偏差修正后的估計值，輸入："s , beta2 , t"，輸出："s_corrected" s_corrected["dW" + str(l + 1)] = s["dW" + str(l + 1)] / (1 - np.power(beta2,t)) s_corrected["db" + str(l + 1)] = s["db" + str(l + 1)] / (1 - np.power(beta2,t)) #更新參數，輸入: "parameters, learning_rate, v_corrected, s_corrected, epsilon". 輸出: "parameters". parameters["W" + str(l + 1)] = parameters["W" + str(l + 1)] - learning_rate * (v_corrected["dW" + str(l + 1)] / np.sqrt(s_corrected["dW" + str(l + 1)] + epsilon)) parameters["b" + str(l + 1)] = parameters["b" + str(l + 1)] - learning_rate * (v_corrected["db" + str(l + 1)] / np.sqrt(s_corrected["db" + str(l + 1)] + epsilon)) return (parameters,v,s)
def update_parameters_with_momentun(parameters,grads,v,beta,learning_rate):""" 使用動量更新參數 參數： parameters - 一個字典類型的變量，包含了以下字段： parameters["W" + str(l)] = Wl parameters["b" + str(l)] = bl grads - 一個包含梯度值的字典變量，具有以下字段： grads["dW" + str(l)] = dWl grads["db" + str(l)] = dbl v - 包含當前速度的字典變量，具有以下字段： v["dW" + str(l)] = ... v["db" + str(l)] = ... beta - 超參數，動量，實數 learning_rate - 學習率，實數 返回： parameters - 更新后的參數字典 v - 包含了更新后的速度變量 """ L = len(parameters) // 2for l in range(L): #計算速度 v["dW" + str(l + 1)] = beta * v["dW" + str(l + 1)] + (1 - beta) * grads["dW" + str(l + 1)] v["db" + str(l + 1)] = beta * v["db" + str(l + 1)] + (1 - beta) * grads["db" + str(l + 1)] #更新參數 parameters["W" + str(l + 1)] = parameters["W" + str(l + 1)] - learning_rate * v["dW" + str(l + 1)] parameters["b" + str(l + 1)] = parameters["b" + str(l + 1)] - learning_rate * v["db" + str(l + 1)] return parameters,v