CIFAR-10 Не може перевищити 60% точності, Керас із Tensorflow backkend [закрито]

Навчання після 15 епох на наборі даних CIFAR-10, схоже, втрати валідації більше не зменшуються, припадаючи на 1,4 (з 60% точністю перевірки). Я перемістив навчальний набір, поділив його на 255 і імпортував як float32. Я випробував численні архітектури, як із відсівом, так і без шарів Conv2D, і, здається, нічого не працює. Ця ж архітектура досягає 99,7% точності на тестових наборах для MNIST. Перегляньте архітектуру нижче:

(Примітка. Я намагався збільшити кількість випадаючих та збільшити / зменшити рівень навчання оптимізатора Адама для запобігання перенапруження. Це все - це запобігання переналагодженню, але з навчанням та тестовим набором тепер мають схожу низьку точність приблизно 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)

Результати:

    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)

Оновлення: подальше тестування, включаючи BatchNormalization як з MaxNorm, так і без нього -

Нова архітектура:

    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 - це набагато простіша проблема, ніж CIFAR-10, і ви можете отримати 98% від повністю підключеної (неконволюційної) NNet з дуже невеликими труднощами. Дуже простий CNN з лише одним або двома згортковими шарами може також досягти однакового рівня точності.

Я не впевнений у вашій архітектурі NNet, але я можу отримати 78% точність тестування на CIFAR-10 із такою архітектурою (яка порівняно простіша і має меншу вагу). Ніякої спеціальної ініціалізації та тримання в руках не потрібно, використовуючи параметри ванілі та оптимізатор Адама:

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

Ця архітектура досить проста і основана на https://arxiv.org/pdf/1412.6806.pdf .

Навчіть цю модель таким чином:

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-ї епохи досягає майже 77% і більш-менш вирівнюється звідти (але має достатню регуляризацію від випадання, щоб запобігти її деградації через переозброєння, принаймні за тестовану кількість ітерацій) .

Поїзд на 50000 зразків, валідація на 10000 зразків
Епоха 1/50
50000/50000 [===============================] - 19s 390us / крок - втрата: 1.6058 - acc: 0.4150 - val_loss: 1.5285 - val_acc: 0.4669
Epoch 2/50
50000/50000 [======================= =======] - 19s 371us / step - втрата: 1,2563 - acc: 0,5477 - val_loss: 1,1447 - val_acc: 0,5901
Epoch 3/50
50000/50000 [============= =================] - 19s 373us / step - втрата: 1.0784 - acc: 0.6163 - val_loss: 1.1577 - val_acc: 0.6002
...
Epoch 25/50
50000/50000 [ ==============================] - 19s 374us / крок - втрата: 0.3188 - соотв .: 0.8857 - val_loss: 0.7493 - val_acc : 0.7680
...
Епоха 50/50
50000/50000 [===============================] - 19s 373us / step - втрата: 0.1928 - acc: 0.9329 - val_loss : 0.8718 - val_acc: 0.7751
Готово !!!

Ось ще простіша та набагато менша архітектура, яка може швидко досягати 70% за допомогою того ж режиму навчання (без BatchNormalization або об'єднання шарів):

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

Варто зауважити, що архітектури, які досягають найкращої публікації на CIFAR-10 (на даний момент у діапазоні 90-96%), як правило, складніші та займають багато годин для навчання обладнання апаратних засобів GPU. Але мені вдалося дістатись до 70-80% діапазону за допомогою досить простих архітектур, які тренуються за лічені хвилини. Це, що я рекомендував би, перш ніж перейти до найкращо опублікованих результатів, які, як правило, вимагають складніших архітектур, більш тривалих періодів навчання, іноді спеціальні схеми тримання / навчання або збільшення даних та години поїздів.

ОНОВЛЕННЯ:

На підставі оновлених сюжетів у питанні найбільш очевидною проблемою, яка демонструється, є надмірне розміщення. Про це свідчить розбіжність даних випробувань поїздів приблизно після 15-ї епохи, що демонструє недостатню регуляризацію для цієї архітектури для цього набору даних. Ви навряд чи зможете покращити налаштування будь-яких інших гіперпараметрів (стратегії нормалізації, темпи навчання тощо), якщо не буде вирішено питання про перевищення рівня.

Використовуючи NNets, я рекомендую наступне:

1. Почніть з архітектури, яка імітує або копіює ті, які, як відомо, дають хороші результати
2. Перевірте працездатність у своєму наборі даних з особливим поглядом на переналагодження в мережі (про що свідчать значні розбіжності помилок тестування поїздів)
3. Додайте додаткову регуляризацію (збільшуйте коефіцієнт відсіву), коли спостерігається перевитрата (ви шукаєте "достатньо", щоб запобігти перенавантаженню - занадто багато призведе до недостатнього розміру)
4. Експериментуйте зі структурою, підходами до тренувань та гіпер-параметрами, щоб знайти шляхи вдосконалення

Написання щодо останнього насправді досить важко підійти, тому що існує мало теоретичного підґрунтя для взаємодії структури, тренувань або гіперпараметрів для отримання ефективності для будь-якого даного набору даних. Це свідчить про те, що підходи, опубліковані архітектурою, що досягають однаково високого рівня продуктивності на наборах даних бенчмарків, настільки сильно відрізняються, свідчить про це.

Виявлено, що батхнормалізація значно покращила деякі архітектури, але інші можуть зробити без цього непогані (або байдужі до її присутності). Єдине справжнє керівництво, яке тут можна надати, - це спробувати його і побачити, чи допомагає він.

Як правило, слід уникати точних налаштувань навчання, якщо ви не передовий практик з глибоким розумінням ConvNets і відповідною здатністю читати чайні листки з урахуванням підвищення ефективності між епохами під час тренувань. Індивідуальні курси навчання та інші спеціалізовані режими навчання можуть у деяких випадках допомогти мережам орієнтуватися на місцевих мінімумах та знаходити кращі загальні рішення, але, якщо у вас є багато часу та ноу-хау для діагностики поведінки конвергенції мережі, це не так гарне місце для початку. Більшість із нас повинні використовувати оптимізатор, як Адам, який у переважній більшості випадків перевершить спроби початківців у налаштованому на практиці рівні навчання.

Розширення даних за допомогою попередньої обробки зображень іноді може призвести до значних поліпшень продуктивності (загалом, чим різноманітніші вхідні дані, тим краще буде узагальнюватися модель - попередня обробка даних додає варіації у вхідний простір, що може покращити точність поза вибіркою та можедозвольте зменшити вимоги до регуляризації - гіпотетично, з нескінченними даними про навчання нам взагалі не знадобиться жодна регуляризація, але в просторі обробки зображень ми навряд чи підійдемо до цього асимптоту). Це може значно збільшити час навчання та повільні темпи конвергенції, і вводить цілий інший набір гіперпараметрів, що стосуються методів перестановки вхідних зображень (обертання, обрізання, масштабування, шум тощо) тощо. Оскільки цей шлях може збільшити терміни навчання та вимагати додаткових експериментів для налаштування результатів, деякі загальні поради полягають у тому, щоб досягти найкращої точності у вашій мережі без розширення спочатку, а потім побачити, чи покращиться прискорене збільшення. Якщо це станеться, це може бути підставою для подальших експериментів.

Для будь-яких експериментів з налаштуванням вам потрібно буде стежити за змінами в поведінці надмірно та недостатньо. Зміна мережевої архітектури, режимів навчання або гіперпараметрів може зажадати додаткової настройки регуляризації випаду. Здатність легко визначати надмірну та невідкладну поведінку від виконання поїзних / випробувальних робіт, мабуть, є найважливішим базовим вмінням роботи з NNets, і це стає більш інтуїтивно зрозумілим із досвідом.

Це свічка, якою будуть керуватися всі ваші зусилля. Свічка може лише тьмяно освітлити стежку, але без неї ви будете спотикатися навколо в темряві. Якщо ваша мережа погано переоцінена або недостатньо підходить, це слід вирішити перед спробою випадкових перестановок структури мережі або гіперпараметрів.

Порівняно прості архітектури із схемами навчання ванілі, включеними у цю відповідь, демонструють реальність роботи з архітектурами NNET над важкими проблемами, такими як класифікація зображень: досягти «досить хорошого» результату на основі підходів, які, як відомо, добре працюють, але не складно, але додаткове вдосконалення все більше коштує. Досягнення найкращих опублікованих результатів шляхом експериментування виходить за межі можливостей чи доступності часу багатьох (хоча можна, маючи достатньо часу та зусиль, дотримуватися рецептів кулінарної книги опублікованих підходів, щоб повторити їх результати - але навіть це не так означає тривіальне). Досягнення поступового вдосконалення з «досить хорошої» вихідної точки може бути дуже трудомістким процесом проб і помилок, і багато експериментів не принесуть значного покращення.

Це не призначене для того, щоб відмовити когось від спроб вчитися, а лише уточнити, що для освоєння (постійно зростаючого) набору інструментів у пакеті хитрощів хитрощів потрібні значні інвестиції, а вдосконалення водіння за допомогою проб і помилок можуть зажадати. десятки (або сотні) експериментів протягом днів або тижнів спеціальної підготовки GPU.

Час, навички та ресурси (виділений GPU), необхідний для підготовки мереж до дуже високого рівня продуктивності, частково пояснюють популярність попередньо підготовлених мереж.

Дивлячись на ваші показники втрат та точності вибірок та вибіркових зразків, ваша модель наразі є недостатнім, але монотонно вдосконалюється. Іншими словами, схоже на те, що використання цього в більші епохи призведе до більш високої прогнозованої ефективності / меншої втрати ентропії.

Ви використовуєте сильно регульовану (випадаючі шари) архітектуру, що непогано. Однак також не дивно, що навчання займає набагато більше часу, ніж без будь-якої регуляризації. Через шари, що випадають, навряд чи ви (істотно) переобладнаєте.

Що ви можете спробувати прискорити навчання:

i. налаштуйте рівень навчання: наприклад, починайте з невеликого, підніміть його в середині, а до кінця знову опустіть його.

ii. додайте пакетну нормалізацію : у вищевказаній архітектурі ви можете включати пакетну норму як у ваші згорнуті блоки, так і в щільні шари. Зазвичай шар партії норми додається після нелінійної активації, але перед випаданням. Я не впевнений, наскільки добре пакетна норма грає з maxnorm. Для ваших щільних шарів я б спробував batch-norm + dropuout з / без maxnorm. У мене є відчуття, що вам не потрібно maxnorm, якщо ви застосовуєте пакетну нормалізацію.

iii. збільшити розмір партії: я не впевнений, який ваш пакетний розмір і чи є у вас GPU. Якщо у вас є графічний процесор, вам, мабуть, слід спробувати збільшити розмір партії в мультиплікаціях 32.

Нарешті, щоб переконатися, що ваші дані "засвоєні" / не пошкоджені (наприклад, ви не бажаєте застосувати трансформацію, щоб викривити її), я б відкинув все регуляризацію з вашої архітектури, запустив навчання і побачив, що ви можете наблизити до навчального набору . Якщо ви можете успішно засвоїти дані тренувань, решта - це узагальнення. Якщо ви не можете перенаправити дані навчання навіть без регуляризації, швидше за все, ваша модель потребує більшої спроможності (більш глибока та широка архітектура).

Сьогодні я зробив це зйомки і постійно міг вдарити близько 75-80% у точності тесту.

• Загальна кількість використаних параметрів: 183,242

• Можна зробити краще, додавши, можливо, ще кілька шарів, але не потрібно зайвим. Більш складні мережі не завжди призводять до кращих результатів.

Пропозиції

Моя вам пропозиція полягає в тому, щоб ви зберігали просту архітектуру. Слідуйте за бритвами Оккама , простіше - краще.

• Масштабуйте свої дані

• Не використовуйте випадкове насіння

• Використовуйте відповідний оптимізатор; Я використовував Ададельту як від Кераса.

• CNN не потрібно згортати; не ускладнювати

• Глибинні скінні мережі іноді працюють краще, ніж ширші

• Використовуйте регуляризацію (наприклад, випадання)

Нижче мій код (за допомогою 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