python实现mini-batch_Mini-Batch 、Momentum、Adam算法的实现

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 inrange(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