假设共有m个样本：当 Mini-batch = 1 时，为随机梯度下降; 当 Mini-batch = m 时，为 batch 梯度下降; 当 1 < Mini-batch < m 时，为 Mini-batch 梯度下降。通常情况下 mini-batch 取 $2^n$ （如：64， 128 等）。
在这里插入图片描述该图来自吴恩达深度学习视频教程。从中可以看出 Mini-batch 收敛速度快、波动小等优点。数据集来源：链接: https://pan.baidu.com/s/1_GY48DuWrzBnDfuGTv7Bbg 提取码: 2ksj

在进行 mini_batch 之前使用 np.random.permutation() 函数数据集打乱，如下图所示。下图中上层是原始数据集的顺序，下层是shuffle操作后的乱序。采用的函数是：
在这里插入图片描述然后利用 shuffle 操作，按照 mini_batch_size 分割整个数据集，代码形式：

first_mini_batch_X = shuffled_X[:, 0 : mini_batch_size]
second_mini_batch_X = shuffled_X[:, mini_batch_size : 2 * mini_batch_size]
...
...

在这里插入图片描述
数据集mini_batch的具体算法实现（python）：

import numpy as np
import h5py
import math


# 定义数据集，，，读者下载好数据集后  需要将 此处的 train_dataset 和 test_dataset 改为自己的数据地址文件夹
def load_dataset():
    train_dataset = h5py.File('/home/zwb/Logistic_Regression/train_catvnoncat.h5', "r")
    train_set_x_orig = np.array(train_dataset["train_set_x"][:]) # your train set features
    train_set_y_orig = np.array(train_dataset["train_set_y"][:]) # your train set labels

    test_dataset = h5py.File('/home/zwb/Logistic_Regression/test_catvnoncat.h5', "r")
    test_set_x_orig = np.array(test_dataset["test_set_x"][:]) # your test set features
    test_set_y_orig = np.array(test_dataset["test_set_y"][:]) # your test set labels

    classes = np.array(test_dataset["list_classes"][:]) # the list of classes
    
    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))
    
    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes

# 定义mini_batch函数
def random_mini_batches(X, Y, mini_batch_size=64, seed=0):
    np.random.seed(seed)
    m = X.shape[1]
    mini_batches = []
    
    # 利用 np.random.permutation()函数将整个数据集打乱
    permutation = list(np.random.permutation(m))
    shuffled_X = X[:, permutation]
    shuffled_Y = Y[:, permutation].reshape((1, m))
    num_complete_minibatches = math.floor(m/mini_batch_size) #计算有多少个mini_batch
    
    # 构建每个 mini_batch, 并将每一组的mini_batch 存放到 mini_batches 中
    for k in range(0, num_complete_minibatches):  #完整的 mini_batch
        mini_batch_X = shuffled_X[:, k*mini_batch_size:(1+k)*mini_batch_size]
        mini_batch_Y = shuffled_Y[:, k*mini_batch_size:(1+k)*mini_batch_size]
        mini_batch = (mini_batch_X, mini_batch_Y)
        mini_batches.append(mini_batch)
        
    if m % mini_batch_size != 0:  #剩余不足64的数据
        mini_batch_X = shuffled_X[:, num_complete_minibatches*mini_batch_size:m]
        mini_batch_Y = shuffled_Y[:, num_complete_minibatches*mini_batch_size:m]
        mini_batch = (mini_batch_X, mini_batch_Y)
        mini_batches.append(mini_batch)
        
    return mini_batches

train_x, train_y, test_x, test_y, classes = load_dataset()
train_x = train_x.reshape(train_x.shape[0], -1).T  #将每个数据学成列的形式
mini_batches = random_mini_batches(train_x, train_y, mini_batch_size=64, seed=0)

for i in range(len(mini_batches)):
    print ("Shape of the {} mini_batch_X: {}" .format(i, mini_batches[i][0].shape))
    print ("Shape of the {} mini_batch_Y: {}" .format(i, mini_batches[i][1].shape))

结果：
Shape of the 0 mini_batch_X: (12288, 64)
Shape of the 0 mini_batch_Y: (1, 64)
Shape of the 1 mini_batch_X: (12288, 64)
Shape of the 1 mini_batch_Y: (1, 64)
Shape of the 2 mini_batch_X: (12288, 64)
Shape of the 2 mini_batch_Y: (1, 64)
Shape of the 3 mini_batch_X: (12288, 17)
Shape of the 3 mini_batch_Y: (1, 17)