Einzelheiten:

GPU : GTX 1080

Training : ~ 1,1 Millionen Bilder aus 10 Klassen

Validierung : ~ 150 Tausend Bilder aus 10 Klassen

Zeit pro Epoche : ~ 10 Stunden

Ich habe CUDA, cuDNN und Tensorflow eingerichtet (auch Tensorflow-GPU).

Ich denke nicht, dass mein Modell so kompliziert ist, dass es 10 Stunden pro Epoche dauert. Ich habe sogar überprüft, ob meine GPU das Problem war, aber es war nicht so.

Liegt die Trainingszeit an den vollständig verbundenen Schichten?

Mein Modell:

model = Sequential()
model.add()
model.add(Conv2D(64, (3, 3), padding="same", strides=2))
model.add(Activation('relu'))
model.add(Dropout(0.25))
model.add(Conv2D(64, (3, 3), padding="same", strides=2))
model.add(Activation('relu'))
model.add(Dropout(0.25))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(3, 3), strides=2))
model.add(Flatten())
model.add(Dense(256))
model.add(Activation('relu'))
model.add(Dense(4096))
model.add(Activation('relu'))
model.add(Dense(10))
model.add(Activation('softmax'))

model.summary()

opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)

model.compile(loss='categorical_crossentropy',
          optimizer=opt,
          metrics=['accuracy']
          )

Da es viele Daten gibt, habe ich den ImageDataGenerator verwendet.

gen = ImageDataGenerator(
 horizontal_flip=True
)

train_gen = gen.flow_from_directory(
        'train/',
        target_size=(512, 512),
        batch_size=5,
        class_mode="categorical"
)

valid_gen = gen.flow_from_directory(
        'validation/',
        target_size=(512, 512),
        batch_size=5,
        class_mode="categorical"
)

Das ist ungefähr zu erwarten. Wenn Sie die Anzahl der Sekunden durch die Anzahl der von Ihnen verarbeiteten Bilder dividieren, erhalten Sie 33 Millisekunden pro Bild, was für ein so kleines Netzwerk ungefähr richtig erscheint. Größere Netzwerke benötigen normalerweise 50 bis 200 Millisekunden pro Bild.

Ja, eine große, dichte Schicht kann Ihre Leistung beeinträchtigen, da dies eine riesige Matrix (256 x 4096) und eine große Matrixmultiplikation ist, die jedes Mal, wenn Sie das Netzwerk ausführen, dazugehört.

Wie Shimao sagte, ist das ungefähr das, was Sie erwarten würden. Obwohl nicht viele Ebenen vorhanden sind, ist eine Eingabegröße von 512 x 512 ein großes Bild, über das gefaltet werden soll. Die große Rechenzeit ist wahrscheinlich eher darauf zurückzuführen, dass 64 Filter über das große Bild anstatt über die vollständig verbundenen Schichten gefaltet werden.

Das Netzwerk, das Sie zusammengestellt haben, weist jedoch einen lustigen Informationsengpass auf. Sie beginnen mit 64 Filtern für das Bild in Originalgröße, die nur mit abnehmender Bildgröße abnehmen. Während das Bild Ihr Netzwerk durchläuft, werden die Funktionen, die Sie lernen, immer abstrakter und komplexer. Ihre Conv2D-Schicht (32, (3, 3)) beschränkt das Netzwerk im Wesentlichen auf das Erlernen einer 128 x 128-Karte mit 32 Funktionen.

Die meisten Netzwerkarchitekturen verdoppeln die Anzahl der Features bei jedem Pooling, und die neuesten Imagenet-Architekturen lassen die vollständig verbundenen Layer zugunsten eines durchschnittlichen Pools gegenüber der endgültigen Feature-Map fallen und führen im Grunde genommen eine logistische Regression für die Ausgabe dieses Pools durch.

Beginnen Sie mit weniger Filtern, z. B. 16 in Ihrer ersten Faltungsschicht, und verdoppeln Sie sich bei jedem Schritt oder Pool. Tun Sie dies einige Male öfter als Sie, um das Empfangsfeld zu vergrößern und die Größe der Feature-Map zu verringern. Tun Sie dies bis zu 64x64 oder 32x32, was 128 oder 256 Filtern entspricht. Sie können das globale Durchschnitts- oder Max-Pooling von Keras verwenden, um auch vollständig verbundene Ebenen zu entfernen. Das sollte die Geschwindigkeit des Netzwerks ungefähr verdoppeln, und ich würde gleichzeitig eine Erhöhung der Genauigkeit erwarten.