Wie groß sollten Stapelgröße und Anzahl der Epochen sein, wenn ein Modell in Keras eingebaut wird?

Ich trainiere an 970 Proben und validiere an 243 Proben.

Wie groß sollten Stapelgröße und Anzahl der Epochen sein, wenn ein Modell in Keras angepasst wird, um val_acc zu optimieren? Gibt es eine Faustregel, die auf der Größe der Dateneingabe basiert?

Da Sie einen ziemlich kleinen Datensatz (~ 1000 Proben) haben, wären Sie wahrscheinlich sicher, wenn Sie eine Stapelgröße von 32 verwenden, was ziemlich Standard ist. Es wird keinen großen Unterschied für Ihr Problem machen, wenn Sie nicht an Hunderttausenden oder Millionen von Beobachtungen trainieren.

So beantworten Sie Ihre Fragen zu Chargengröße und Epochen:

Im Allgemeinen : Größere Chargen führen zu schnelleren Trainingsfortschritten, konvergieren jedoch nicht immer so schnell. Kleinere Losgrößen trainieren langsamer, aber kann schneller konvergieren. Es ist definitiv problemabhängig.

Im Allgemeinen verbessern sich die Modelle mit mehr Trainingsepochen bis zu einem gewissen Punkt. Sie werden anfangen, an Genauigkeit zu gewinnen, wenn sie konvergieren. Versuchen Sie etwas wie 50 und zeichnen Sie die Anzahl der Epochen (x-Achse) gegen die Genauigkeit (y-Achse). Sie werden sehen, wo es sich abflacht.

Was ist die Art und / oder Form Ihrer Daten? Handelt es sich um Bilder oder nur um Tabellendaten? Dies ist ein wichtiges Detail.

Tolle Antworten oben. Alle gaben gute Beiträge.

Im Idealfall ist dies die Reihenfolge der Chargengrößen, die verwendet werden sollen:

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

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

[32, 64] - CPU

[128, 256] - GPU for more boost

Ich benutze Keras, um eine nichtlineare Regression für Sprachdaten durchzuführen. Jede meiner Sprachdateien enthält Funktionen mit 25000 Zeilen in einer Textdatei, wobei jede Zeile 257 reelle Zahlen enthält. Ich verwende eine Stapelgröße von 100, Epoche 50, um das SequentialModell in Keras mit 1 versteckten Ebene zu trainieren . Nach 50 Trainingsepochen konvergiert es recht gut auf ein Tief val_loss.

Ich habe Keras verwendet, um eine nichtlineare Regression für die Marktmixmodellierung durchzuführen. Ich habe die besten Ergebnisse mit einer Stapelgröße von 32 und Epochen = 100 erzielt, als ich ein sequentielles Modell in Keras mit 3 versteckten Ebenen trainiert habe. Im Allgemeinen ist eine Stapelgröße von 32 oder 25 gut, mit Epochen = 100, es sei denn, Sie haben einen großen Datensatz. Bei großen Datenmengen können Sie mit einer Chargengröße von 10 mit Epochen s / w 50 bis 100 arbeiten. Auch hier haben die oben genannten Zahlen für mich gut funktioniert.

Epochen entsprechen Ihrem Wunsch, je nachdem, wann sich der Validierungsverlust nicht mehr weiter verbessert. So viel sollte Chargengröße sein:

# 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