在Keras中拟合模型时，批处理大小和纪元数应为多少？

Question 1

我正在训练970个样本，并验证243个样本。

在Keras中拟合模型以优化val_acc时，批处理大小和纪元数应为多少？是否有基于数据输入大小的经验法则？

Question 2

由于您的数据集非常小（约有1000个样本），因此使用32的批量大小（这很标准）可能会很安全。除非您正在接受数十万或数百万个观测值的训练，否则不会对您的问题产生太大的影响。

要回答有关批量大小和纪元的问题：

一般而言：批量越大，训练进度越快，但不一定总是收敛得那么快。小批量训练速度较慢，但能收敛速度更快。这绝对取决于问题。

总的来说，模型会随着更多的训练时间而改善。随着它们的融合，它们的准确性将开始达到平稳状态。尝试使用类似50的值，并绘制历元数（x轴）与精度（y轴）的关系。您会看到它变平的地方。

数据的类型和/或形状是什么？这些是图像还是表格数据？这是一个重要的细节。

Question 3

上面的好答案。每个人都提供了很好的意见。

理想情况下，这是应该使用的批量大小的顺序：

{1, 2, 4, 8, 16} - slow 

{ [32, 64],[ 128, 256] }- Good starters

[32, 64] - CPU

[128, 256] - GPU for more boost

Question 4

我使用Keras对语音数据执行非线性回归。我的每个语音文件都为我提供了文本文件中25000行的功能，每行包含257个实数值。我使用批处理大小为100，纪元为50的方法Sequential在Keras中使用1个隐藏层来训练模型。经过50个星期的训练，它收敛得很好val_loss。

Question 5

我使用Keras对市场组合建模进行了非线性回归。在Keras中使用3个隐藏层训练序列模型时，批处理大小为32，历时= 100，我得到了最佳结果。通常，批处理大小为32或25是好的，除非您有大型数据集，否则时期= 100。如果是大型数据集，则可以批量处理10个，历时b / w为50到100。上述数据对我来说也很好。

Question 6

Epochs完全可以满足您的要求，具体取决于验证损失何时停止进一步改善。这个应该是批量大小：


# To define function to find batch size for training the model
# use this function to find out the batch size

    def FindBatchSize(model):
        """#model: model architecture, that is yet to be trained"""
        import os, sys, psutil, gc, tensorflow, keras
        import numpy as np
        from keras import backend as K
        BatchFound= 16

        try:
            total_params= int(model.count_params());    GCPU= "CPU"
            #find whether gpu is available
            try:
                if K.tensorflow_backend._get_available_gpus()== []:
                    GCPU= "CPU";    #CPU and Cuda9GPU
                else:
                    GCPU= "GPU"
            except:
                from tensorflow.python.client import device_lib;    #Cuda8GPU
                def get_available_gpus():
                    local_device_protos= device_lib.list_local_devices()
                    return [x.name for x in local_device_protos if x.device_type == 'GPU']
                if "gpu" not in str(get_available_gpus()).lower():
                    GCPU= "CPU"
                else:
                    GCPU= "GPU"

            #decide batch size on the basis of GPU availability and model complexity
            if (GCPU== "GPU") and (os.cpu_count() >15) and (total_params <1000000):
                BatchFound= 64    
            if (os.cpu_count() <16) and (total_params <500000):
                BatchFound= 64  
            if (GCPU== "GPU") and (os.cpu_count() >15) and (total_params <2000000) and (total_params >=1000000):
                BatchFound= 32      
            if (GCPU== "GPU") and (os.cpu_count() >15) and (total_params >=2000000) and (total_params <10000000):
                BatchFound= 16  
            if (GCPU== "GPU") and (os.cpu_count() >15) and (total_params >=10000000):
                BatchFound= 8       
            if (os.cpu_count() <16) and (total_params >5000000):
                BatchFound= 8    
            if total_params >100000000:
                BatchFound= 1

        except:
            pass
        try:

            #find percentage of memory used
            memoryused= psutil.virtual_memory()
            memoryused= float(str(memoryused).replace(" ", "").split("percent=")[1].split(",")[0])
            if memoryused >75.0:
                BatchFound= 8
            if memoryused >85.0:
                BatchFound= 4
            if memoryused >90.0:
                BatchFound= 2
            if total_params >100000000:
                BatchFound= 1
            print("Batch Size:  "+ str(BatchFound));    gc.collect()
        except:
            pass

        memoryused= [];    total_params= [];    GCPU= "";
        del memoryused, total_params, GCPU;    gc.collect()
        return BatchFound