CIFAR-10% 60'ın üzerinde Doğruluk, Tensorflow arka uçlu Keras [kapalı]

CIFAR-10 veri setinde 15 dönemden sonra yapılan eğitim, geçerlilik kaybının artık azalmamasına ve 1.4'e (% 60 doğrulama doğruluğu ile) bağlı kalmayacağı görülüyor. Eğitim setini karıştırdım, 255'e böldüm ve float32 olarak içe aktardım. Conv2D katmanlarında hem bırakarak hem de bırakmadan çok sayıda mimariyi denedim ve hiçbir şey işe yaramıyor. Aynı mimari MNIST için test setlerinde% 99,7 doğruluk elde eder. Lütfen aşağıdaki mimariye bakın:

(Not: Adam sığdırmayı önlemek için artan Adam düşürücüyü ve artan / azalan öğrenme oranını denedim, tüm bunlar aşırı sığmayı önlemek, ancak hem eğitim hem de test setinin şimdi% 60 civarında benzer düşük doğruluğa sahip olması).

with tf.device('/gpu:0'):
    tf.placeholder(tf.float32, shape=(None, 20, 64))
    #placeholder initialized (pick /cpu:0 or /gpu:0)
    seed = 6
    np.random.seed(seed)
    modelnn = Sequential()
    neurons = x_train_reduced.shape[1:]

    modelnn.add(Convolution2D(32, 3, 3, input_shape=neurons, activation='relu', border_mode='same'))
    modelnn.add(Convolution2D(32, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(MaxPooling2D(pool_size=(2, 2)))
    modelnn.add(Dropout(0.2))
    modelnn.add(Convolution2D(64, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(Convolution2D(64, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(MaxPooling2D(pool_size=(2, 2)))
    modelnn.add(Dropout(0.2))
    modelnn.add(Convolution2D(128, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(Convolution2D(128, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(MaxPooling2D(pool_size=(2, 2)))
    modelnn.add(Dropout(0.2))
    #modelnn.add(Convolution2D(256, 3, 3, activation='relu', border_mode='same'))
    #modelnn.add(Convolution2D(256, 3, 3, activation='relu', border_mode='same'))
    #modelnn.add(MaxPooling2D(pool_size=(2, 2)))
    modelnn.add(Flatten())
    #modelnn.add(Dropout(0.5))
    modelnn.add(Dense(1024, activation='relu', W_constraint=maxnorm(3)))
    modelnn.add(Dropout(0.5))
    modelnn.add(Dense(512, activation='relu', W_constraint=maxnorm(3)))
    modelnn.add(Dropout(0.5))
    modelnn.add(Dense(10, activation='softmax'))
    modelnn.compile(loss='categorical_crossentropy', optimizer=optimizer_input, metrics=['accuracy'])
    y_train = to_categorical(y_train)
    modelnn.fit(x_train_reduced, y_train, nb_epoch=nb_epoch_count, shuffle=True, batch_size=bsize,
                           validation_split=0.1)

Sonuçlar:

    44100/44100 [==============================] - 22s - loss: 2.1453 - acc: 0.2010 - val_loss: 1.9812 - val_acc: 0.2959
    Epoch 2/50
    44100/44100 [==============================] - 24s - loss: 1.9486 - acc: 0.3089 - val_loss: 1.8685 - val_acc: 0.3567
    Epoch 3/50
    44100/44100 [==============================] - 18s - loss: 1.8599 - acc: 0.3575 - val_loss: 1.7822 - val_acc: 0.3982
    Epoch 4/50
    44100/44100 [==============================] - 18s - loss: 1.7925 - acc: 0.3933 - val_loss: 1.7272 - val_acc: 0.4229
    Epoch 5/50
    44100/44100 [==============================] - 18s - loss: 1.7425 - acc: 0.4195 - val_loss: 1.6806 - val_acc: 0.4459
    Epoch 6/50
    44100/44100 [==============================] - 18s - loss: 1.6998 - acc: 0.4440 - val_loss: 1.6436 - val_acc: 0.4682
    Epoch 7/50
    44100/44100 [==============================] - 18s - loss: 1.6636 - acc: 0.4603 - val_loss: 1.6156 - val_acc: 0.4837
    Epoch 8/50
    44100/44100 [==============================] - 18s - loss: 1.6333 - acc: 0.4781 - val_loss: 1.6351 - val_acc: 0.4776
    Epoch 9/50
    44100/44100 [==============================] - 18s - loss: 1.6086 - acc: 0.4898 - val_loss: 1.5732 - val_acc: 0.5063
    Epoch 10/50
    44100/44100 [==============================] - 18s - loss: 1.5776 - acc: 0.5065 - val_loss: 1.5411 - val_acc: 0.5227
    Epoch 11/50
    44100/44100 [==============================] - 18s - loss: 1.5585 - acc: 0.5145 - val_loss: 1.5485 - val_acc: 0.5212
    Epoch 12/50
    44100/44100 [==============================] - 18s - loss: 1.5321 - acc: 0.5288 - val_loss: 1.5354 - val_acc: 0.5316
    Epoch 13/50
    44100/44100 [==============================] - 18s - loss: 1.5082 - acc: 0.5402 - val_loss: 1.5022 - val_acc: 0.5427
    Epoch 14/50
    44100/44100 [==============================] - 18s - loss: 1.4945 - acc: 0.5438 - val_loss: 1.4916 - val_acc: 0.5490
    Epoch 15/50
    44100/44100 [==============================] - 192s - loss: 1.4762 - acc: 0.5535 - val_loss: 1.5159 - val_acc: 0.5394
    Epoch 16/50
    44100/44100 [==============================] - 18s - loss: 1.4577 - acc: 0.5620 - val_loss: 1.5389 - val_acc: 0.5257
    Epoch 17/50
    44100/44100 [==============================] - 18s - loss: 1.4425 - acc: 0.5671 - val_loss: 1.4590 - val_acc: 0.5667
    Epoch 18/50
    44100/44100 [==============================] - 18s - loss: 1.4258 - acc: 0.5766 - val_loss: 1.4552 - val_acc: 0.5763
    Epoch 19/50
    44100/44100 [==============================] - 18s - loss: 1.4113 - acc: 0.5805 - val_loss: 1.4439 - val_acc: 0.5767
    Epoch 20/50
    44100/44100 [==============================] - 18s - loss: 1.3971 - acc: 0.5879 - val_loss: 1.4473 - val_acc: 0.5769
    Epoch 21/50
    44100/44100 [==============================] - 18s - loss: 1.3850 - acc: 0.5919 - val_loss: 1.4251 - val_acc: 0.5871
    Epoch 22/50
    44100/44100 [==============================] - 18s - loss: 1.3668 - acc: 0.6006 - val_loss: 1.4203 - val_acc: 0.5910
    Epoch 23/50
    44100/44100 [==============================] - 18s - loss: 1.3549 - acc: 0.6051 - val_loss: 1.4207 - val_acc: 0.5939
    Epoch 24/50
    44100/44100 [==============================] - 18s - loss: 1.3373 - acc: 0.6111 - val_loss: 1.4516 - val_acc: 0.5784
    Epoch 25/50
    44100/44100 [==============================] - 18s - loss: 1.3285 - acc: 0.6149 - val_loss: 1.4146 - val_acc: 0.5922
    Epoch 26/50
    44100/44100 [==============================] - 18s - loss: 1.3134 - acc: 0.6205 - val_loss: 1.4090 - val_acc: 0.6024
    Epoch 27/50
    44100/44100 [==============================] - 18s - loss: 1.3043 - acc: 0.6239 - val_loss: 1.4307 - val_acc: 0.5959
    Epoch 28/50
    44100/44100 [==============================] - 18s - loss: 1.2862 - acc: 0.6297 - val_loss: 1.4241 - val_acc: 0.5978
    Epoch 29/50
    44100/44100 [==============================] - 18s - loss: 1.2706 - acc: 0.6340 - val_loss: 1.4046 - val_acc: 0.6067
    Epoch 30/50
    44100/44100 [==============================] - 18s - loss: 1.2634 - acc: 0.6405 - val_loss: 1.4120 - val_acc: 0.6037
    Epoch 31/50
    44100/44100 [==============================] - 18s - loss: 1.2473 - acc: 0.6446 - val_loss: 1.4067 - val_acc: 0.6045
    Epoch 32/50
    44100/44100 [==============================] - 18s - loss: 1.2411 - acc: 0.6471 - val_loss: 1.4083 - val_acc: 0.6098
    Epoch 33/50
    44100/44100 [==============================] - 18s - loss: 1.2241 - acc: 0.6498 - val_loss: 1.4091 - val_acc: 0.6076
    Epoch 34/50
    44100/44100 [==============================] - 18s - loss: 1.2121 - acc: 0.6541 - val_loss: 1.4209 - val_acc: 0.6127
    Epoch 35/50
    44100/44100 [==============================] - 18s - loss: 1.1995 - acc: 0.6582 - val_loss: 1.4230 - val_acc: 0.6131
    Epoch 36/50
    44100/44100 [==============================] - 18s - loss: 1.1884 - acc: 0.6622 - val_loss: 1.4024 - val_acc: 0.6124
    Epoch 37/50
    44100/44100 [==============================] - 18s - loss: 1.1778 - acc: 0.6657 - val_loss: 1.4328 - val_acc: 0.6080
    Epoch 38/50
    44100/44100 [==============================] - 18s - loss: 1.1612 - acc: 0.6683 - val_loss: 1.4246 - val_acc: 0.6159
    Epoch 39/50
    44100/44100 [==============================] - 18s - loss: 1.1466 - acc: 0.6735 - val_loss: 1.4282 - val_acc: 0.6122
    Epoch 40/50
    44100/44100 [==============================] - 18s - loss: 1.1325 - acc: 0.6783 - val_loss: 1.4311 - val_acc: 0.6157
    Epoch 41/50
    44100/44100 [==============================] - 18s - loss: 1.1213 - acc: 0.6806 - val_loss: 1.4647 - val_acc: 0.6047
    Epoch 42/50
    44100/44100 [==============================] - 18s - loss: 1.1064 - acc: 0.6842 - val_loss: 1.4631 - val_acc: 0.6047
    Epoch 43/50
    44100/44100 [==============================] - 18s - loss: 1.0967 - acc: 0.6870 - val_loss: 1.4535 - val_acc: 0.6106
    Epoch 44/50
    44100/44100 [==============================] - 18s - loss: 1.0822 - acc: 0.6893 - val_loss: 1.4532 - val_acc: 0.6149
    Epoch 45/50
    44100/44100 [==============================] - 18s - loss: 1.0659 - acc: 0.6941 - val_loss: 1.4691 - val_acc: 0.6108
    Epoch 46/50
    44100/44100 [==============================] - 18s - loss: 1.0610 - acc: 0.6956 - val_loss: 1.4751 - val_acc: 0.6106
    Epoch 47/50
    44100/44100 [==============================] - 18s - loss: 1.0397 - acc: 0.6981 - val_loss: 1.4857 - val_acc: 0.6041
    Epoch 48/50
    44100/44100 [==============================] - 18s - loss: 1.0208 - acc: 0.7039 - val_loss: 1.4901 - val_acc: 0.6106
    Epoch 49/50
    44100/44100 [==============================] - 18s - loss: 1.0187 - acc: 0.7036 - val_loss: 1.4994 - val_acc: 0.6106
    Epoch 50/50
    44100/44100 [==============================] - 18s - loss: 1.0024 - acc: 0.7070 - val_loss: 1.5078 - val_acc: 0.6039
    Time: 1109.7512991428375
    Neural Network now trained from dimensions (49000, 3, 32, 32)

Güncelleme: MaxNorm ile veya MaxNorm olmadan BatchNormalization dahil olmak üzere daha fazla test -

Yeni mimari:

    modelnn.add(Convolution2D(32, 3, 3, input_shape=neurons, activation='relu', border_mode='same'))
    modelnn.add(Convolution2D(32, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(MaxPooling2D(pool_size=(2, 2)))
    modelnn.add(BatchNormalization())
    modelnn.add(Dropout(0.2))
    modelnn.add(Convolution2D(64, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(Convolution2D(64, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(MaxPooling2D(pool_size=(2, 2)))
    modelnn.add(BatchNormalization())
    modelnn.add(Dropout(0.2))
    modelnn.add(Convolution2D(128, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(Convolution2D(128, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(BatchNormalization())
    modelnn.add(MaxPooling2D(pool_size=(2, 2)))
    modelnn.add(Dropout(0.2))
    # modelnn.add(Convolution2D(256, 3, 3, activation='relu', border_mode='same'))
    # modelnn.add(Convolution2D(256, 3, 3, activation='relu', border_mode='same'))
    # modelnn.add(MaxPooling2D(pool_size=(2, 2)))
    modelnn.add(Flatten())
    modelnn.add(Dense(1024, activation='relu', W_constraint=maxnorm(3)))
    modelnn.add(BatchNormalization())
    modelnn.add(Dropout(0.5))
    modelnn.add(Dense(512, activation='relu', W_constraint=maxnorm(3)))
    modelnn.add(BatchNormalization())
    modelnn.add(Dropout(0.5))
    modelnn.add(Dense(10, activation='softmax'))

MNIST'in CIFAR-10'dan çok daha basit bir sorun olduğunu ve çok az zorluk ile tam bağlı (evrişimsel olmayan) bir NNet'ten% 98 alabileceğinizi unutmayın. Sadece bir veya iki kıvrımlı katmanı olan çok basit bir CNN de aynı doğruluk seviyesine ulaşabilir.

NNet mimarinizden emin değilim, ancak aşağıdaki mimariyle (nispeten daha basit ve daha az ağırlığa sahip) CIFAR-10'da% 78 test doğruluğuna ulaşabilirim. Vanilya varsayılanları ve Adam optimizer kullanılarak özel bir başlatma veya tutma gerekmez:

model = Sequential()
model.add(Conv2D(input_shape=trainX[0,:,:,:].shape, filters=96, kernel_size=(3,3)))
model.add(Activation('relu'))
model.add(Conv2D(filters=96, kernel_size=(3,3), strides=2))
model.add(Activation('relu'))
model.add(Dropout(0.2))
model.add(Conv2D(filters=192, kernel_size=(3,3)))
model.add(Activation('relu'))
model.add(Conv2D(filters=192, kernel_size=(3,3), strides=2))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Flatten())
model.add(BatchNormalization())
model.add(Dense(256))
model.add(Activation('relu'))
model.add(Dense(n_classes, activation="softmax"))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

Bu mimari oldukça basittir ve gevşek bir şekilde https://arxiv.org/pdf/1412.6806.pdf adresine dayanmaktadır .

Bu modeli bu şekilde eğitmek:

n_epochs = 25
batch_size = 256
callbacks_list = None
H = model.fit(trainX, trainY, validation_data=(testX, testY), 
              epochs=n_epochs, batch_size=batch_size, callbacks=callbacks_list)
print('Done!!!')

25. çağda neredeyse% 77'ye ulaştığını ve oradan daha fazla veya daha az düzleştiğini görebileceğiniz aşağıdakileri verir (ancak en azından test edilen yineleme sayısının üzerinde aşırı takılmadan dolayı bozulmasını önlemek için bırakma işleminden yeterince düzenli hale gelir) .

50000 numune üzerinde eğitim, 10000 numune üzerinde doğrulama
Epoch 1/50
50000/50000 [=============================== 19s 390us / adım - kayıp: 1.6058 - acc: 0.4150 - val_loss: 1.5285 - val_acc: 0.4669
Dönem
2/50 50000/50000 [======================= =======] - 19s 371us / adım - kayıp: 1.2563 - acc: 0.5477 - val_loss: 1.1447 - val_acc: 0.5901
Dönem 3/50
50000/50000 [============= =================] - 19s 373us / adım - kayıp: 1.0784 - acc: 0.6163 - val_loss: 1.1577 - val_acc: 0.6002
...
Dönem 25/50
50000/50000 [ ==============================] - 19s 374us / adım - kayıp: 0.3188 - acc: 0.8857 - val_loss: 0.7493 - val_acc : 0,7680
...
Dönem 50/50
50000/50000 [==============================] - 19s 373us / adım - kayıp: 0.1928 - acc: 0.9329 - val_loss : 0.8718 - val_acc: 0.7751
Yapıldı !!!

İşte aynı eğitim rejimi ile% 70'e kadar oldukça hızlı bir şekilde ulaşabilen daha basit ve çok daha küçük bir mimari: (BatchNormalization veya havuzlama katmanları yok):

# CNN architecture with Keras
model = Sequential()
model.add(Conv2D(input_shape=trainX[0,:,:,:].shape, filters=32, 
                 use_bias=True, kernel_size=(3,3)))
model.add(Activation('relu'))
model.add(Dropout(0.1))
model.add(Conv2D(filters=64, use_bias=False, kernel_size=(5,5), strides=2))
model.add(Activation('relu'))
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(128))
model.add(Activation('relu'))
model.add(Dropout(0.3))
model.add(Dense(n_classes, activation="softmax"))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=    ['accuracy'])

Olsun mimariler belirterek It değerinde cifar-10 üzerinde en çok yayınlanan doğruluk (şu anda 90-96% aralığında) genellikle daha karmaşık olan ve GPU donanım üzerinde eğitmek için saatler sürebilir. Ancak dakikalar içinde eğitim veren oldukça basit mimarilerle% 70-80 aralığına ulaşabildim, bu genellikle daha karmaşık mimariler, daha uzun eğitim periyotları gerektiren en iyi yayınlanan sonuçlar için gitmeden önce tavsiye ederim. bazen özel tutma / eğitim rejimleri veya veri artırımı ve saatlerce eğitim süresi.

GÜNCELLEME:

Sorudaki güncellenmiş grafiklere dayanarak, ortaya çıkan en belirgin sorun aşırı uydurmadır. Bu, 15. veri çağından sonra, bu veri seti için bu mimari için yetersiz düzenlenme gösteren tren testi verilerinin farklılığı ile kanıtlanmıştır. Aşırı sığdırma ele alınmadıkça, diğer hiperparametreleri (normalleştirme stratejileri, öğrenme oranları, vb.) Ayarlayarak iyileşme elde etme olasılığınız düşük olacaktır.

NNets kullanırken aşağıdakileri öneririm:

1. İyi sonuçlar verdiği bilinenleri taklit eden veya taklit eden mimarilerden başlayın
2. Ağınıza aşırı uymaya özel bir gözle veri kümenizdeki performansı doğrulayın (tren testi hatalarının önemli ölçüde farklılaşmasıyla kanıtlanmıştır)
3. Aşırı sığdırma gözlemlendiğinde ek düzenlileştirme ekleyin (bırakma oranlarını artırın) (fazla takmayı önlemek için "yeterli" arıyorsunuz - çok fazla eksiklik ile sonuçlanacaktır)
4. İyileştirme yollarını bulmak için yapı, eğitim yaklaşımları ve hiper parametrelerle denemeler yapın

İkincisi ile ilgili reçetelerin gelmesi oldukça zordur, çünkü yapı, eğitim veya hiper parametrelerin herhangi bir veri setinde performans vermek için nasıl etkileşime girdiğine dair çok az teorik temel vardır. Karşılaştırmalı veri setlerinde benzer şekilde yüksek performans elde eden yayınlanmış mimarlar tarafından kullanılan yaklaşımların çok farklı olması bunun kanıtıdır.

Toplu normalleştirmenin bazı mimarileri önemli ölçüde iyileştirdiği bulunmuştur, ancak diğerleri onsuz oldukça iyi yapabilir (veya varlığına kayıtsızdır). Burada sağlanacak tek gerçek rehber, denemek ve yardımcı olup olmadığını görmek.

ConvNets hakkında derin bir anlayışa ve eğitim sırasında dönemler arası artımlı performansa göre çay yapraklarını okuma yeteneğine sahip gelişmiş bir uygulayıcı değilseniz, ince ayar öğrenme oranlarından genellikle kaçınılmalıdır. Özelleştirilmiş öğrenme oranları ve diğer özel eğitim rejimleri bazı durumlarda ağların yerel minima etrafında gezinmesine ve daha iyi genel çözümler bulmasına yardımcı olabilir, ancak çok fazla zamanınız ve ağın yakınsama davranışını teşhis etmek için know-howınız yoksa, bu değildir. Başlamak için iyi bir yer. Birçoğumuz, Adam gibi, vakaların büyük çoğunluğunda elle ayarlanmış öğrenme oranlarındaki acemi girişimlerinden daha iyi olacak bir optimize edici kullanmalıyız.

Görüntü önişleme ile veri büyütme bazen önemli performans iyileştirmeleri sağlayabilir (genel olarak, girdi verileri ne kadar değişken olursa model genelleme o kadar iyi olur - veri önişleme, girdi alanına örnek dışı doğruluğu artırabilecek ve olabilirDüzenleme gereksinimlerinde azalma sağlamak - varsayımsal olarak, sonsuz eğitim verileri ile herhangi bir düzenlemeye ihtiyacımız olmayacaktı, ancak görüntü işleme alanında bu asimptota yaklaşma olasılığı düşüktür). Bu, eğitim süresini ve yavaş yakınsama oranlarını önemli ölçüde artırabilir ve girdi görüntü permütasyon teknikleri (rotasyon, kırpma, ölçekleme, gürültü, vb.) İle ilgili başka bir dizi hiperparametre seti sunar. Bu yol, eğitim sürelerini artırabildiğinden ve sonuçları ayarlamak için ek deneyler gerektirdiğinden, bazı genel öneriler, öncelikle büyütme olmadan ağınızda en iyi doğruluğu sağlamak, ardından bazı mütevazı artırmanın iyileştirme sağlayıp sağlamadığını görmek olacaktır. Eğer öyleyse, daha fazla deney yapılmasını gerektirebilir.

Herhangi bir ve tüm ayarlama deneyleri için, aşırı ve yetersiz uyum davranışındaki değişikliklere dikkat etmelisiniz. Ağ mimarisini, eğitim rejimlerini veya hiperparametreleri değiştirmek, bırakma düzeninin ek olarak ayarlanmasını gerektirebilir. Tren / test performansından aşırı ve uygun olmayan davranışı kolayca belirleme yeteneği, NNets ile çalışmadaki tartışmasız en önemli temel beceridir ve bu deneyim ile daha sezgisel hale gelir.

Bu, tüm çabalarınızın yönlendirileceği mum. Mum sadece loş bir şekilde aydınlatabilir, ancak onsuz karanlıkta tökezlersiniz. Ağınız çok fazla veya yetersizse, ağ yapısının veya hiperparametrelerin rasgele permütasyonlarını denemeden önce bu sorun çözülmelidir.

Bu cevaba dahil edilen vanilya eğitim rejimleriyle nispeten basit mimariler, görüntü sınıflandırması gibi zor problemler üzerinde NNET mimarileri ile çalışma gerçeğini göstermektedir: iyi çalıştığı bilinen yaklaşımlara dayalı "oldukça iyi" bir sonuca ulaşmak zor değil, artımlı bir gelişme giderek daha maliyetli hale geliyor. Deneme yoluyla en iyi yayınlanan sonuçları elde etmek, birçoğunun yeteneklerinin veya zaman uygunluğunun ötesine geçecektir (yeterli zaman ve çaba ile, sonuçlarını çoğaltmak için yayınlanmış yaklaşımların yemek kitabı tariflerini takip etmek mümkündür - ancak bu bile hayır önemsiz anlamına gelir). "Oldukça iyi" bir başlangıç ​​noktasından artımlı iyileşme elde etmek, deneme-yanılma için çok zaman alıcı bir süreç olabilir ve birçok deney önemli bir gelişme sağlamaz.

Bu, kimsenin öğrenmeye teşebbüs etmekten vazgeçmesi değil, sadece NNet hileler çantasındaki (sürekli genişleyen) araç setinde ustalaşmak için önemli bir yatırımın olduğunu ve deneme-yanılma yoluyla iyileştirmeleri gerektirebileceğini açıkça belirtmek içindir. Özel GPU eğitimi günler veya haftalar boyunca düzinelerce (veya yüzlerce) deney.

Ağları çok yüksek performans seviyelerinde eğitmek için gereken zaman, beceri ve kaynaklar (özel GPU), kısmen önceden eğitilmiş ağların popülerliğini açıklar.

Numune içi ve numune dışı kayıp ve doğruluk değerlerinize baktığınızda, modeliniz şu anda yetersiz durumdadır, ancak monoton olarak gelişmektedir. Başka bir deyişle, bunu daha fazla dönem için çalıştırmak, daha yüksek tahmin performansına / daha az entropi kaybına yol açacaktır.

Son derece düzenli (bırakma katmanları) bir mimari kullanıyorsunuz, ki bu fena değil. Bununla birlikte, eğitimin herhangi bir düzenleme olmadan çok daha uzun sürmesi şaşırtıcı değildir. Bırakma katmanları nedeniyle, (büyük ölçüde) fazla takmanız olası değildir.

Öğrenmeyi hızlandırmak için deneyebileceğiniz şeyler:

ben. öğrenme hızını değiştirin: örneğin küçük biriyle başlayın, ortada yükseltin ve sonuna doğru tekrar indirin.

ii. batchnormalisation ekleyin : yukarıdaki mimaride, hem konvolüsyon bloklarınıza hem de yoğun katmanlarınıza batch-norm ekleyebilirsiniz. Genellikle, parti-norm katmanı, doğrusal olmayan aktivasyondan sonra, ancak bırakmadan önce eklenir. Toplu normun maxnorm ile ne kadar iyi oynadığından emin değilim. Yoğun katmanlarınız için, batch-norm + dropout'u maxnorm ile / maxnorm olmadan deneyeceğim. Parti normalizasyonu uygularsanız, maksimuma ihtiyacınız olmadığına dair bir his var.

iii. toplu boyutu artırın: Toplu boyutunuzun ne olduğundan ve GPU'nuzun olup olmadığından emin değilim. GPU'nuz varsa, büyük olasılıkla toplu iş boyutunuzu 32 çarpımla artırmaya çalışmalısınız.

Son olarak, verilerinizin 'öğrenilebilir' olduğundan / bozulmadığından emin olmak için (örneğin, istemeden çözüme dönüştürmek için bir dönüşüm uygulamadıysanız), mimarinizden tüm düzenlileştirmeleri atar, eğitimi çalıştırır ve eğitim setine daha fazla uyum sağlayabileceğinizi görürüm . Egzersiz verilerini başarıyla öğrenebilirseniz, geri kalanı bir genelleme alıştırmasıdır. Düzenleme yapılmadan bile eğitim verilerine fazla uyum sağlayamıyorsanız, büyük olasılıkla modelinizin daha fazla kapasiteye (daha derin ve daha geniş mimari) ihtiyacı vardır.

Bunu bugün denedim ve test doğruluğunda sürekli olarak% 75-80'e vurabildim.

• Kullanılan toplam parametre sayısı: 183,242

• Birkaç katman daha ekleyerek daha iyisini yapabilirsiniz, ancak aşırı olması gerekmez. Daha karmaşık ağlar her zaman daha iyi sonuçlarla sonuçlanmaz.

Öneriler

Size önerim mimarinizi basit tutmanızdır. Occam'ın ustura izleyin , basit daha iyidir.

• Verilerinizi ölçeklendirin

• Rastgele bir tohum kullanma

• Uygun bir optimize edici kullanın; Adadelta'yı Keras'tan kullandım.

• CNN'lerin kıvrılması gerekmez; basit tut

• Daha derin ağlar bazen daha geniş ağlardan daha iyi çalışır

• Düzenlemeyi kullanın (örn. Bırakma)

Kodum aşağıdadır (Keras kullanarak)

# Define the model
model = Sequential()
model.add(Convolution2D(64, (4, 4), padding='same', input_shape=(3, 32, 32)))
model.add(MaxPooling2D(pool_size=(2, 2), strides=2))
model.add(Activation('relu'))
model.add(Dropout(0.25))
model.add(Convolution2D(64, (2, 2), padding='same'))
model.add(Activation('relu'))
model.add(Dropout(0.25))
model.add(Convolution2D(32, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Dropout(0.25))
model.add(Convolution2D(32, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=2))
model.add(Dropout(0.15))
model.add(Flatten())
model.add(Dense(64))
model.add(Activation('relu'))
model.add(Dropout(0.25))
model.add(Dense(64))
model.add(Activation('tanh'))
model.add(Dropout(0.25))
model.add(Dense(num_classes, activation='softmax'))
# Compile the model