数据挖掘 - 使用 Tensorflow 进行深度学习：使用大数据集进行训练 - 吾爱随笔录

目标
我正在尝试构建一个能够识别给定图像中的多个标签的神经网络。我从一个由 1800 张图像组成的数据库开始（每个图像都是一个形状数组（204,204,3）。我训练了我的模型并得出结论，使用的数据不足以构建一个好的模型（关于所选指标） . 所以我决定应用数据增强技术来获得更多的图像。我设法获得了 25396 张图像（它们都是形状 (204,204,3)）。我将它们全部存储在数组中。我获得了 (X,Y ) 其中 X 是训练示例（是形状数组 (25396,204,204,3)），Y 是标签（形状数组 (25396,39) ：数字 39 是指给定图像中的可能标签） .
问题
我的数据 (X,Y) 权重约为 26 GB。我成功地使用了它们。但是，当我尝试进行操作（如排列）时，我在 python 中遇到了内存错误。 示例1.我启动了jupyter并成功导入了我的数据（X，Y ）

x=np.load('x.npy')
y=np.load('y.npy')

output: x is an np.array of shape (25396,204,204,3) and y is an np.array of shape (25396,39).

2.我使用内置函数train_test_split的sklearn将我的数据集划分为训练和测试

X_train, X_valid, Y_train, Y_valid= `train_test_split(x_train,y_train_augmented,test_size=0.3, random_state=42)`

output
-------------testing size of different elements et toplogie: 
-------------x size: (25396, 204, 204, 3)
-------------y size: (25396, 39) 
-------------X_train size:  (17777, 204, 204, 3)
-------------X_valid size:  (7619, 204, 204, 3)
-------------Y_train size:  (17777, 39)
-------------Y_valid size:  (7619, 39)

3.我正在创建一个由从 (X,Y) 中提取的随机批次组成的列表，然后迭代批次以完成给定时期的学习过程：'此操作在训练部分的每个时期中完成。这是用于创建随机批次列表的函数：

def random_mini_batches(X, Y, mini_batch_size = 64, seed = 0):
    """
    Creates a list of random minibatches from (X, Y)

    Arguments:
    X -- input data, of shape (input size, number of examples)
    Y -- true "label" vector (1 for blue dot / 0 for red dot), of shape (1, number of examples)
    mini_batch_size -- size of the mini-batches, integer

    Returns:
    mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y)
    """


    np.random.seed(seed)            
    m = X.shape[0]                  
    mini_batches = []
    # Step 1: Shuffle (X, Y)
    permutation = list(np.random.permutation(m))



    shuffled_X = X[permutation,:]
    shuffled_Y = Y[permutation,:]


    # Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.
    num_complete_minibatches = floor(m/mini_batch_size) # number of mini batches of size mini_batch_size in your partitionning
    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_batches.append((X[permutation,:][k * mini_batch_size : (k + 1) * mini_batch_size, :], Y[permutation,:][k * mini_batch_size : (k + 1) * mini_batch_size, :]))
        '''
    # Handling the end case (last mini-batch < mini_batch_size)
    if m % mini_batch_size != 0:
        ### START CODE HERE ### (approx. 2 lines)
        mini_batch_X = shuffled_X[ num_complete_minibatches * mini_batch_size:, :]
        mini_batch_Y = shuffled_Y[ num_complete_minibatches * mini_batch_size:, :]
        ### END CODE HERE ###
        mini_batch = (mini_batch_X, mini_batch_Y)
        mini_batches.append(mini_batch)
        '''
        mini_batches.append((X[permutation,:][ num_complete_minibatches * mini_batch_size:, :], Y[permutation,:][ num_complete_minibatches * mini_batch_size:, :]))
        '''
    shuffled_X=None
    shuffled_Y=None
    return mini_batches

4. 我正在创建一个循环（4 次迭代），并在每次迭代中测试 random_mini_batch 函数。在每次迭代结束时，我将 None 值分配给 mini_batches 列表，以释放内存并在下一次迭代中重做 random_mini_batch_function 。所以这些代码行工作正常，我没有内存问题：

minibatch_size=32
seed=2
for i in range(4):
    seed=seed+1
    minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)

    minibatches=None 
    minibatches_valid=create_mini_batches(X_valid, Y_valid, minibatch_size)
    print(i)
minibatches_valid=None

5. 如果我在不同批次上添加迭代！然后我遇到了内存问题。换句话说，如果运行此代码，我会收到错误：

minibatch_size=32
seed=2
for i in range(4):
    seed=seed+1
    minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)
    #added code: iteration over mini_batches
    for minibatch in minibatches:
                print('batch training number ')
    #end of added code        
    minibatches=None 
    minibatches_valid=create_mini_batches(X_valid, Y_valid, minibatch_size)
    print(i)
    minibatches_valid=None

MemoryError                               Traceback (most recent call last)
<ipython-input-13-9c1942cdf0bc> in <module>()
      3 for i in range(4):
      4     seed=seed+1
----> 5     minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)
      6     
      7     for minibatch in minibatches:

<ipython-input-3-2056fee14def> in random_mini_batches(X, Y, mini_batch_size, seed)

     23 
---> 24     shuffled_X = X[permutation,:]
     25     shuffled_Y = Y[permutation,:]
     26 

MemoryError:

有谁知道 np.arrays 有什么问题？以及为什么添加循环（迭代批次列表）的简单事实会导致内存错误。

问题

1.加载整个数据集然后继续训练是个好主意吗？（我需要在每个时期创建随机批次，所以如果数据没有预加载，我不知道该怎么做？你从预加载的数据中获取随机的小批量，对吧？） 2. 有没有可能的解决方案伙计们？