Question

我正在使用深层的CNN + LSTM网络对1D信号的数据集进行分类。我正在使用keras 2.2.4支持的tensorflow 1.12.0。由于我的数据集很大且资源有限，因此我在训练阶段使用了生成器将数据加载到内存中。首先，我尝试了这个生成器：

def data_generator(batch_size, preproc, type, x, y):
    num_examples = len(x)
    examples = zip(x, y)
    examples = sorted(examples, key = lambda x: x[0].shape[0])
    end = num_examples - batch_size + 1
    batches = [examples[i:i + batch_size] for i in range(0, end, batch_size)]

    random.shuffle(batches)
    while True:
        for batch in batches:
            x, y = zip(*batch)
            yield preproc.process(x, y)

使用上述方法，我可以一次以最多30个样本的小批量启动训练。但是，这种方法不能保证网络每个时期每个样本仅训练一次。考虑到Keras网站上的评论：

Sequence是进行多处理的更安全方法。这种结构保证网络在每个样本上仅训练一次生成器不是这样的时代。

我尝试了使用以下类加载数据的另一种方式：

class Data_Gen(Sequence):

def __init__(self, batch_size, preproc, type, x_set, y_set):
    self.x, self.y = np.array(x_set), np.array(y_set)
    self.batch_size = batch_size
    self.indices = np.arange(self.x.shape[0])
    np.random.shuffle(self.indices)
    self.type = type
    self.preproc = preproc

def __len__(self):
    # print(self.type + ' - len : ' + str(int(np.ceil(self.x.shape[0] / self.batch_size))))
    return int(np.ceil(self.x.shape[0] / self.batch_size))

def __getitem__(self, idx):
    inds = self.indices[idx * self.batch_size:(idx + 1) * self.batch_size]
    batch_x = self.x[inds]
    batch_y = self.y[inds]
    return self.preproc.process(batch_x, batch_y)

def on_epoch_end(self):
    np.random.shuffle(self.indices)

我可以确认使用这种方法，网络在每个时期对每个样本进行一次训练，但是这次，当我在微型批次中放入7个以上样本时，出现内存不足错误：

OP_REQUIRES在random_op.cc处失败：202：资源耗尽：OOM时用形状分配张量......

我可以确认我使用相同的模型架构，配置和机器来进行此测试。我想知道为什么这两种加载数据的方式会有区别？

请随时询问更多详细信息。

先谢谢了。

已编辑：

这是我用来拟合模型的代码：

reduce_lr = keras.callbacks.ReduceLROnPlateau(
            factor=0.1,
            patience=2,
            min_lr=params["learning_rate"])

        checkpointer = keras.callbacks.ModelCheckpoint(
            filepath=str(get_filename_for_saving(save_dir)),
            save_best_only=False)

        batch_size = params.get("batch_size", 32)

        path = './logs/run-{0}'.format(datetime.now().strftime("%b %d %Y %H:%M:%S"))
        tensorboard = keras.callbacks.TensorBoard(log_dir=path, histogram_freq=0,
                                                  write_graph=True, write_images=False)
        if index == 0:
            print(model.summary())
            print("Model memory needed for batchsize {0} : {1} Gb".format(batch_size, get_model_memory_usage(batch_size, model)))

        if params.get("generator", False):
            train_gen = load.data_generator(batch_size, preproc, 'Train', *train)
            dev_gen = load.data_generator(batch_size, preproc, 'Dev', *dev)
            valid_metrics = Metrics(dev_gen, len(dev[0]) // batch_size, batch_size)
            model.fit_generator(
                train_gen,
                steps_per_epoch=len(train[0]) / batch_size + 1 if len(train[0]) % batch_size != 0 else len(train[0]) // batch_size,
                epochs=MAX_EPOCHS,
                validation_data=dev_gen,
                validation_steps=len(dev[0]) / batch_size + 1  if len(dev[0]) % batch_size != 0 else len(dev[0]) // batch_size,
                callbacks=[valid_metrics, MyCallback(), checkpointer, reduce_lr, tensorboard])

            # train_gen = load.Data_Gen(batch_size, preproc, 'Train', *train)
            # dev_gen = load.Data_Gen(batch_size, preproc, 'Dev', *dev)
            # model.fit_generator(
        #     train_gen,
        #     epochs=MAX_EPOCHS,
        #     validation_data=dev_gen,
        #     callbacks=[valid_metrics, MyCallback(), checkpointer, reduce_lr, tensorboard])

Answer 1

这些方法大致相同。子类化是正确的 Sequence当您的数据集不适合内存时。但是你不应该在任何类的方法中运行任何预处理，因为那样会每次重复执行一次，浪费大量计算资源。

洗牌而不是洗牌更容易索引。像这样：

来自随机导入的随机播放

class DataGen(Sequence):
    def __init__(self, batch_size, preproc, type, x_set, y_set):
        self.samples = list(zip(x, y))
        self.batch_size = batch_size
        shuffle(self.samples)
        self.type = type
        self.preproc = preproc

    def __len__(self):
        return int(np.ceil(len(self.samples) / self.batch_size))

    def __getitem__(self, i):
        batch = self.samples[i * self.batch_size:(i + 1) * self.batch_size]
        return self.preproc.process(*zip(batch))

    def on_epoch_end(self):
        shuffle(self.samples)

我认为无法说出为什么没有内存就会耗尽进一步了解您的数据。我的猜测是您的preproc 函数做错了什么。您可以通过运行以下命令对其进行调试：

for e in DataGen(batch_size, preproc, *train):
    print(e)
for e in DataGen(batch_size, preproc, *dev):
    print(e)

您很可能会用完内存。

Answer 2

您需要减小批量大小。一般而言，对于图片而言，32似乎是很大的-尝试将其缩小为16。

然后增加小批量的大小。

生成器和序列之间的Keras差异

2 个答案: