CIFAR-10 Tidak bisa mendapatkan Akurasi di atas 60%, Keras dengan backend Tensorflow [ditutup]

Pelatihan setelah 15 zaman pada dataset CIFAR-10 tampaknya membuat kehilangan validasi tidak lagi menurun, bertahan sekitar 1,4 (dengan akurasi validasi 60%). Saya telah mengocok set pelatihan, membaginya dengan 255, dan diimpor sebagai float32. Saya sudah mencoba banyak arsitektur, baik dengan maupun tanpa putus di lapisan Conv2D dan sepertinya tidak ada yang berhasil. Arsitektur yang sama mencapai akurasi 99,7% pada set tes untuk MNIST. Silakan lihat arsitektur di bawah ini:

(Catatan: Saya telah mencoba meningkatkan angka putus sekolah dan meningkatkan / mengurangi tingkat pembelajaran pengoptimal Adam untuk mencegah overfitting, semua ini dilakukan untuk mencegah overfitting tetapi dengan pelatihan dan set tes sekarang memiliki akurasi rendah yang sama sekitar 60%).

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)

Hasil:

    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)

Pembaruan: Pengujian lebih lanjut termasuk BatchNormalization baik dengan dan tanpa MaxNorm -

Arsitektur baru:

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

Perhatikan bahwa MNIST adalah set masalah yang jauh lebih sederhana daripada CIFAR-10, dan Anda bisa mendapatkan 98% dari NNet yang sepenuhnya terhubung (non-convolutional) dengan kesulitan yang sangat kecil. CNN yang sangat sederhana dengan hanya satu atau dua lapisan konvolusional juga dapat mencapai tingkat akurasi yang sama.

Saya tidak yakin tentang arsitektur NNet Anda, tetapi saya dapat membuat Anda mencapai 78% akurasi pengujian pada CIFAR-10 dengan arsitektur berikut (yang relatif lebih sederhana dan memiliki bobot lebih sedikit). Tidak diperlukan inisialisasi atau pegangan khusus, menggunakan standar vanilla dan pengoptimal Adam:

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

Arsitektur ini cukup sederhana, dan didasarkan pada https://arxiv.org/pdf/1412.6806.pdf .

Latih model ini dengan demikian:

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

Memberikan yang berikut, yang dapat Anda lihat mencapai hampir 77% pada zaman ke-25 dan lebih atau kurang rata keluar dari sana (tetapi memiliki cukup regularisasi dari dropout untuk mencegahnya dari degradasi karena overfitting, setidaknya atas jumlah iterasi yang diuji) .

Berlatihlah pada 50.000 sampel, validasi pada 10.000 sampel
Epoch 1/50
50000/50000 [==============================] - 19s 390us / step - loss: 1.6058 - acc: 0.4150 - val_loss: 1.5285 - val_acc: 0.4669
Epoch
2/50 50000/50000 [========================= =======] - 19s 371us / step - loss: 1.2563 - acc: 0.5477 - val_loss: 1.1447 - val_acc: 0.5901
Epoch
3/50 50000/50000 [============= =================] - 19s 373us / step - loss: 1.0784 - acc: 0.6163 - val_loss: 1.1577 - val_acc: 0.6002
...
Epoch 25/50
50000/50000 [ ==============================] - 19s 374us / step - loss: 0.3188 - acc: 0.8857 - val_loss: 0.7493 - val_acc : 0.7680
...
Epoch 50/50
50000/50000 [============================] - 19s 373us / step - loss: 0.1928 - acc: 0.9329 - val_loss : 0.8718 - val_acc: 0.7751
Selesai !!!

Berikut ini adalah arsitektur yang lebih sederhana dan jauh lebih kecil yang dapat mencapai 70% cukup cepat dengan rejimen pelatihan yang sama (tanpa lapisan BatchNormalisasi atau pooling):

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

Perlu dicatat bahwa arsitektur yang mendapatkan akurasi terbitan terbaik pada CIFAR-10 (saat ini dalam kisaran 90-96%) umumnya lebih rumit dan membutuhkan waktu berjam-jam untuk melatih perangkat keras GPU. Tapi saya sudah bisa mencapai kisaran 70-80% dengan arsitektur yang cukup sederhana yang melatih dalam hitungan menit, yang adalah apa yang saya sarankan sebelum pergi untuk hasil yang dipublikasikan terbaik yang biasanya membutuhkan arsitektur yang lebih rumit, periode pelatihan yang lebih lama, kadang-kadang regimen pegangan / pelatihan khusus atau penambahan data, dan jam waktu kereta.

MEMPERBARUI:

Berdasarkan plot diperbarui dalam pertanyaan, masalah yang paling jelas yang ditunjukkan adalah overfitting. Ini dibuktikan dengan divergensi data uji kereta setelah sekitar abad ke-15 yang menunjukkan kurangnya regularisasi untuk arsitektur ini, untuk kumpulan data ini. Anda tidak akan mendapatkan peningkatan dari menyetel hiperparameter lainnya (strategi normalisasi, tingkat pembelajaran, dll.) Kecuali overfitting ditangani.

Dalam menggunakan NNets, saya merekomendasikan yang berikut ini:

1. Mulai dari arsitektur yang meniru atau meniru yang dikenal untuk menghasilkan hasil yang baik
2. Verifikasi kinerja pada kumpulan data Anda, dengan perhatian khusus pada pemasangan berlebihan di jaringan (dibuktikan dengan perbedaan signifikan dari kesalahan tes kereta)
3. Tambahkan regularisasi tambahan (tingkat dropout meningkat) ketika overfitting diamati (Anda sedang mencari "cukup" untuk mencegah overfitting - terlalu banyak akan mengakibatkan kurang pas)
4. Eksperimen dengan struktur, pendekatan pelatihan, dan hiper-parameter untuk menemukan jalan perbaikan

Resep mengenai yang terakhir ini sebenarnya cukup sulit didapat, karena ada sedikit landasan teori untuk bagaimana struktur, pelatihan, atau hiper-parameter berinteraksi untuk menghasilkan kinerja pada set data yang diberikan. Bahwa pendekatan yang digunakan oleh arsitektur yang diterbitkan mencapai tingkat kinerja yang sama-tinggi pada set data benchmark sangat berbeda adalah buktinya.

Batchnormalisasi telah terbukti secara signifikan meningkatkan beberapa arsitektur, tetapi yang lain dapat melakukannya dengan cukup baik tanpa itu (atau acuh tak acuh terhadap kehadirannya). Satu-satunya pedoman nyata untuk menyediakan di sini adalah untuk mencobanya dan melihat apakah itu membantu.

Tingkat pembelajaran fine-tuning umumnya harus dihindari kecuali jika Anda adalah seorang praktisi tingkat lanjut dengan pemahaman yang mendalam tentang ConvNets dan kemampuan yang sesuai untuk membaca daun teh sehubungan dengan peningkatan kinerja antar-zaman selama pelatihan. Tingkat pembelajaran khusus dan rejimen pelatihan khusus lainnya dalam beberapa kasus dapat membantu jaringan bernavigasi di sekitar minimum minimum lokal dan menemukan solusi keseluruhan yang lebih baik, tetapi kecuali Anda memiliki banyak waktu dan cara untuk mendiagnosis perilaku konvergensi jaringan, ini bukan tempat yang bagus untuk memulai. Sebagian besar dari kita harus menggunakan pengoptimal seperti Adam yang akan mengungguli upaya pemula pada tingkat pembelajaran yang disesuaikan dengan tangan di sebagian besar kasus.

Augmentasi data melalui preprocessing gambar kadang-kadang dapat menghasilkan peningkatan kinerja yang signifikan (secara umum, semakin bervariasi data input semakin baik model akan digeneralisasi - preprocessing data menambah variasi ruang input yang dapat meningkatkan akurasi out-of-sampel dan mungkinmampu mengurangi persyaratan regularisasi - secara hipotetis, dengan data pelatihan tak terbatas kita tidak akan memerlukan regularisasi sama sekali, tetapi dalam ruang pemrosesan gambar kita tidak mungkin mendekati asimtot itu). Ini secara signifikan dapat meningkatkan waktu pelatihan dan memperlambat laju konvergensi, dan memperkenalkan serangkaian hiperparameter lain yang berkaitan dengan teknik permutasi input gambar (rotasi, tanam, penskalaan, penskalaan, noise, dll.). Karena jalur ini dapat meningkatkan waktu pelatihan dan memerlukan percobaan tambahan untuk menyesuaikan hasil, beberapa saran umum akan mengarahkan untuk akurasi terbaik di jaringan Anda tanpa augmentasi terlebih dahulu, kemudian lihat apakah beberapa augmentasi sederhana menghasilkan peningkatan. Jika ya, mungkin diperlukan eksperimen lebih lanjut.

Untuk setiap dan semua percobaan penyetelan, Anda perlu mengawasi perubahan perilaku over-dan under-fitting. Mengubah arsitektur jaringan, rejimen pelatihan, atau hiperparameter mungkin memerlukan penyetelan tambahan regularisasi putus sekolah. Kemampuan untuk memastikan perilaku over-dan under-fitting dari kinerja kereta / tes bisa dibilang keterampilan dasar yang paling penting dalam bekerja dengan NNets, dan ini menjadi lebih intuitif dengan pengalaman.

Ini adalah lilin yang dengannya semua upaya Anda akan dibimbing. Lilin hanya bisa secara samar menerangi jalan, tetapi tanpanya Anda akan tersandung dalam kegelapan. Jika jaringan Anda terlalu banyak atau kurang pas, itu harus diatasi sebelum mencoba permutasi acak struktur jaringan atau hiperparameter.

Arsitektur yang relatif sederhana dengan rejimen pelatihan vanila yang termasuk dalam jawaban ini menunjukkan kenyataan bekerja dengan arsitektur NNET pada masalah-masalah sulit seperti klasifikasi gambar: mendapatkan hasil "cukup bagus" berdasarkan pendekatan yang dikenal bekerja dengan baik tidaklah sulit, tetapi peningkatan tambahan semakin mahal. Mencapai hasil yang diterbitkan terbaik melalui eksperimen akan melampaui kemampuan atau ketersediaan waktu banyak orang (walaupun mungkin, dengan waktu dan usaha yang cukup, untuk mengikuti resep buku resep dari pendekatan yang diterbitkan untuk mereplikasi hasil mereka - tetapi bahkan ini tidak sama sekali. berarti sepele). Mencapai peningkatan bertahap dari titik awal yang "cukup bagus" bisa menjadi proses trial-and-error yang sangat memakan waktu, dan banyak percobaan tidak akan menghasilkan peningkatan yang signifikan.

Ini tidak dimaksudkan untuk menghalangi siapa pun dari upaya untuk belajar, tetapi hanya untuk memperjelas bahwa ada investasi yang signifikan diperlukan untuk menguasai (terus berkembang) toolset dalam kantong trik NNet, dan mendorong peningkatan melalui uji coba-dan-kesalahan dapat memerlukan puluhan (atau ratusan) percobaan selama beberapa hari atau minggu pelatihan khusus GPU.

Waktu, keterampilan, dan sumber daya (GPU khusus) yang diperlukan untuk melatih jaringan ke tingkat kinerja yang sangat tinggi menjelaskan sebagian popularitas jaringan pra-terlatih.

Melihat nilai kehilangan dan keakuratan sampel dan out-of-sample Anda, model Anda saat ini kekurangan, tetapi secara monoton membaik. Dengan kata lain, sepertinya menjalankan ini untuk lebih banyak zaman akan menghasilkan kinerja prediksi yang lebih tinggi / lebih sedikit kerugian entropi.

Anda menggunakan arsitektur (lapisan drop-out) yang sangat teratur, yang tidak buruk. Namun, tidak mengherankan bahwa pelatihan ini memakan waktu lebih lama daripada tanpa pengaturan. Karena lapisan drop-out, Anda tidak akan (secara substansial) akan berpakaian berlebihan.

Hal-hal yang dapat Anda coba untuk mempercepat pembelajaran:

saya. menyesuaikan tingkat belajar: misalnya mulai dengan yang kecil, naikkan itu di tengah, dan menjelang akhir turunkan lagi.

ii. tambahkan batchnormalisation : dalam arsitektur di atas, Anda dapat memasukkan norma batch baik di blok convolutional Anda dan lapisan padat. Biasanya, lapisan norma batch ditambahkan setelah aktivasi nonlinear tetapi sebelum putus. Saya tidak yakin seberapa baik batch-norm bermain dengan maxnorm. Untuk lapisan padat Anda, saya akan mencoba batch-norm + dropuout dengan / tanpa maxnorm. Saya merasa Anda tidak perlu maxnorm jika Anda menerapkan normalisasi batch.

aku aku aku. meningkatkan ukuran batch: Saya tidak yakin apa ukuran batch Anda dan apakah Anda memiliki GPU. Jika Anda memiliki GPU, Anda mungkin harus mencoba untuk memaksimalkan ukuran batch Anda dalam multiplicative of 32.

Akhirnya, untuk memastikan bahwa data Anda 'dapat dipelajari' / tidak korup (mis. Anda belum mau menerapkan transformasi untuk membelokkannya), saya akan membuang semua regularisasi dari arsitektur Anda, menjalankan pelatihan dan memastikan bahwa Anda dapat menyesuaikan dengan set pelatihan. . Jika Anda berhasil mempelajari data pelatihan, sisanya adalah latihan generalisasi. Jika Anda tidak dapat menyesuaikan untuk melatih data bahkan tanpa regularisasi, kemungkinan besar model Anda membutuhkan lebih banyak kapasitas (arsitektur yang lebih dalam dan lebih luas).

Saya mencoba ini hari ini dan secara konsisten dapat mencapai hampir 75-80% dalam akurasi pengujian.

• Jumlah parameter yang digunakan adalah: 183,242

• Anda dapat melakukannya dengan lebih baik dengan menambahkan mungkin beberapa layer lagi, tetapi Anda tidak perlu berlebihan. Jaringan yang lebih kompleks tidak selalu menghasilkan hasil yang lebih baik.

Saran

Saran saya kepada Anda adalah agar arsitektur Anda tetap sederhana. Ikuti Occam's Razor , sederhana itu lebih baik.

• Skala data Anda

• Jangan gunakan benih acak

• Gunakan pengoptimal yang sesuai; Saya menggunakan Adadelta seperti dari Keras.

• CNN tidak perlu berbelit-belit; tetap sederhana

• Jaringan yang lebih kurus dan kadang-kadang bekerja lebih baik daripada yang lebih luas

• Gunakan regularisasi (mis. Dropout)

Di bawah ini adalah kode saya (menggunakan Keras)

# 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