Detalles:

GPU : GTX 1080

Entrenamiento : ~ 1.1 millones de imágenes pertenecientes a 10 clases

Validación : ~ 150 mil imágenes pertenecientes a 10 clases

Tiempo por época : ~ 10 horas

He configurado CUDA, cuDNN y Tensorflow (GPU Tensorflow también).

No creo que mi modelo sea tan complicado que lleva 10 horas por época. Incluso verifiqué si mi GPU era el problema, pero no fue así.

¿El tiempo de entrenamiento se debe a las capas totalmente conectadas?

Mi modelo:

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']
          )

Debido a que hay muchos datos, utilicé ImageDataGenerator.

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"
)

Eso es lo esperado. Si divide el número de segundos entre el número de imágenes que procesó, obtendrá 33 milisegundos por imagen, lo que parece ser adecuado para una red tan pequeña. Las redes más grandes usualmente toman el estadio de 50 a 200 milisegundos por imagen.

Sí, es probable que una gran capa densa perjudique su rendimiento, ya que es una matriz enorme (256 por 4096) y una gran matriz de multiplicación para acompañarla cada vez que ejecuta la red.

Como dijo shimao, eso es lo que esperarías. A pesar de no tener muchas capas, un tamaño de entrada de 512x512 es una imagen grande sobre la que se puede involucrar. El gran tiempo de cálculo probablemente se deba más a la convolución de 64 filtros sobre la imagen grande, en lugar de las capas completamente conectadas.

Sin embargo, la red que ha creado tiene un cuello de botella de información divertido. Comienza con 64 filtros en la imagen de tamaño original, que solo disminuye a medida que se reduce el tamaño de la imagen. A medida que la imagen pasa a través de su red, las características que está aprendiendo se vuelven cada vez más abstractas y complejas. Su capa Conv2D (32, (3, 3)) esencialmente limita la red a aprender un mapa de 128x128 de 32 características.

La mayoría de las arquitecturas de red duplican el número de características cada vez que se agrupan, y las arquitecturas de redes de imagen más recientes abandonan las capas completamente conectadas a favor de un grupo promedio sobre el mapa de características final, y básicamente realizan una regresión logística en la salida de ese grupo.

Intente comenzar con menos filtros, digamos 16 en su primera capa de convolución, duplicando cada vez que camina o agrupa. Haga esto unas pocas veces más de lo que es, para aumentar el campo receptivo y disminuir el tamaño del mapa de características. Haga esto a 64x64 o 32x32, que serían 128 o 256 filtros. También puede usar la agrupación Global Avg o Max de Keras para eliminar capas completamente conectadas. Eso debería duplicar la velocidad de la red, y esperaría un aumento en la precisión al mismo tiempo.