人工智能—优化算法，mini-batch,指数加权平均，mini-batch梯度下降

几个专业术语
1.mini-batch梯度下降：用子训练集进行梯度下降。
2.batch梯度下降:用整个训练集进行梯度下降
3.随机梯度下降：用一个样本进行梯度下降
4.epoch：对整个训练集进行一次梯度下降

训练神经网络的目的就是找到一组参数使成本函数最小，下图代表了成本函数，中间点为最小。蓝色的代表batch梯度下降，紫色的代表随机梯度下降，绿色的代表mini-batch梯度下降。有人会觉得直接使用batch梯度下降不是很好吗，但如果输入的数据集过大的话，电脑的cpu不能承受，并且学习周期太过漫长，如果数据集不是很大，就另当别论了。

指数加权平均
要用很短的篇幅来详细讲解几乎是不可能的，所以这里只是简单的介绍一下。
公式：Vt=k*Vt-1+(1-k)*Wt

在编程中实现加权平均：
v=0
for i in 100:
v=k*v+(1-k)*w

求子训练集的代码实现

#获取子训练集
def random_mini_batches(X,Y,mini_batch_size=64,seed=0):
    #设置随机数种子
    np.random.seed(seed)
    #获取样本数量
    m=X.shape[1]
    #存储分割后的训练集
    mini_batches=[]
    #对训练集进行洗牌
    #这行代码会产生m范围内的随机整数,且里面的数是0到m-1
    permutation=list(np.random.permutation(m))
    #这行代码会将每一列按permutation列表中的随机索引进行洗牌，每一列代表一个训练数据
    shuffled_X=X[:,permutation]
    shuffled_Y=Y[:,permutation].reshape((1,m))
    
    #获取子训练集的个数，不包括不满mini_batch_size的训练集
    num_complete_minibatches=math.floor(m/mini_batch_size)
    #分割洗牌后的训练集
    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]
        mini_batch=(mini_batch_X,mini_batch_Y)
        mini_batches.append(mini_batch)
    #将不满mini_batch_size的训练集也添加进来
    if m%mini_batch_size!=0:
        mini_batch_X=shuffled_X[:,num_complete_minibatches*mini_batch_size:]
        mini_batch_Y=shuffled_Y[:,num_complete_minibatches*mini_batch_size:]
        mini_batch=(mini_batch_X,mini_batch_Y)
        mini_batches.append(mini_batch)
        
    return mini_batches

更新参数W和b

def update_parameters_with_gd(parameters, grads, learning_rate):
 
    L = len(parameters) // 2 

    for l in range(L):
        parameters["W" + str(l + 1)] = parameters["W" + str(l + 1)] - learning_rate * grads["dW" + str(l + 1)]
        parameters["b" + str(l + 1)] = parameters["b" + str(l + 1)] - learning_rate * grads["db" +str(l+1)]        
    return parameters

mini_batch神经网络训练模型

def model(X, Y, layers_dims,learning_rate=0.0007, mini_batch_size=64,num_epochs=10000, print_cost=True):
    
    L = len(layers_dims)            
    costs = []                                                 
    seed = 10                      
    
    parameters = initialize_parameters(layers_dims)
    # 一个epoch就是遍历整个数据集一遍，一个epoch里面可以有多个minibatch
    for i in range(num_epochs):
        # 下面的seed进行了加1处理，是为了让每个epoch中的洗牌后数据集都不同。这样一来，每次的minibatch都包含了不同的训练样本。
        seed = seed + 1
        minibatches = random_mini_batches(X, Y, mini_batch_size, seed)
        # 遍历每个minibatch
        for minibatch in minibatches:

            # 分出x和y
            (minibatch_X, minibatch_Y) = minibatch

            a3, caches = forward_propagation(minibatch_X, parameters)

            cost = compute_cost(a3, minibatch_Y)

            grads = backward_propagation(minibatch_X, minibatch_Y, caches)

            parameters = update_parameters_with_gd(parameters, grads, learning_rate)
       
        
        if print_cost and i % 1000 == 0:
            print("Cost after epoch %i: %f" % (i, cost))
        if print_cost and i % 100 == 0:
            costs.append(cost)
    #将成本函数以图象的形式显示出来            
    plt.plot(costs)
    plt.ylabel('cost')
    plt.xlabel('epochs (per 100)')
    plt.title("Learning rate = " + str(learning_rate))
    plt.show()
    return parameters

ps:大家如果真的想学习人工智能方面的知识，请点击下方链接：人工智能社区，讲的非常通俗易懂，适用于各个阶段的学习者。