Dettagli:

GPU : GTX 1080

Formazione : ~ 1,1 milioni di immagini appartenenti a 10 classi

Convalida : ~ 150 mila immagini appartenenti a 10 classi

Tempo per epoca : ~ 10 ore

Ho installato CUDA, cuDNN e Tensorflow (anche GPU Tensorflow).

Non credo che il mio modello sia così complicato che richiede 10 ore per epoca. Ho anche controllato se la mia GPU era il problema ma non lo era.

Il tempo di allenamento è dovuto agli strati completamente collegati?

Il mio modello:

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

Perché ci sono molti dati che ho usato 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"
)

Questo è previsto. Se dividi il numero di secondi per il numero di immagini che hai elaborato, otterrai 33 millisecondi per immagine, il che sembra giusto per una rete così piccola. Le reti più grandi di solito occupano il campo da baseball da 50 a 200 millisecondi per immagine.

Sì, è probabile che un grosso strato denso danneggi le tue prestazioni, dal momento che si tratta di una matrice enorme (256 per 4096) e di una grande moltiplicazione della matrice da accompagnare ogni volta che esegui la rete.

Come ha detto Shimao, è quello che ti aspetteresti. Pur non avendo molti livelli, una dimensione di input di 512x512 è un'immagine di grandi dimensioni su cui deviare. L'ampio tempo di calcolo è probabilmente maggiore a causa del convolgere 64 filtri sull'immagine grande, anziché i livelli completamente collegati.

Tuttavia, la rete che hai creato presenta un collo di bottiglia di informazioni divertenti. Si inizia con 64 filtri sull'immagine di dimensioni originali, diminuendo solo quando si riducono le dimensioni dell'immagine. Man mano che l'immagine passa attraverso la tua rete, le funzionalità che stai imparando diventano sempre più astratte e complesse. Il tuo livello Conv2D (32, (3, 3)) limita essenzialmente la rete all'apprendimento di una mappa 128x128 di 32 funzioni.

La maggior parte delle architetture di rete raddoppia il numero di funzionalità ogni volta che mette in comune, e le più recenti architetture imagenet in realtà abbandonano i livelli completamente collegati a favore di un pool medio rispetto alla mappa delle caratteristiche finale e sostanzialmente eseguono la regressione logistica sull'output di quel pool.

Prova a iniziare con un minor numero di filtri, ad esempio 16 nel tuo primo livello di convoluzione, raddoppiando ogni volta che avanzi o fai un balzo. Fatelo un po 'più di voi, per aumentare il campo ricettivo e ridurre le dimensioni della mappa delle caratteristiche. Fai questo fino a 64x64 o 32x32, che sarebbe 128 o 256 filtri. Puoi utilizzare il pool Global o Max di Keras per eliminare anche i layer completamente connessi. Ciò dovrebbe circa il doppio della velocità della rete e mi aspetterei un aumento della precisione allo stesso tempo.