CIFAR-10 не может быть выше 60% точности, керас с бэкэндом Tensorflow [закрыто]

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

(Примечание: я пытался увеличить отсев и увеличивать / уменьшать скорость обучения оптимизатора Adam, чтобы предотвратить переоснащение, все, что он делает, это предотвращает переоснащение, но и тренировочные, и тестовые наборы теперь имеют одинаковую низкую точность около 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 с помощью следующей архитектуры (которая сравнительно проще и имеет меньший вес). Никакой специальной инициализации или ручной фиксации не требовалось с использованием стандартных настроек по умолчанию и оптимизатора 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'])

Эта архитектура довольно проста и основана на 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!!!')

Дает следующее, которое, как вы можете видеть, достигает почти 77% к 25-й эпохе и более или менее выравнивается оттуда (но имеет достаточную регуляризацию от выпадения, чтобы предотвратить его деградацию из-за переоснащения, по крайней мере, в течение проверенного количества итераций) ,

Поезд на 50000 образцов, проверка на 10000 образцов.
Эпоха 1/50
50000/50000 [=============================] - 19 с 390 долл. / Шаг - потеря: 1,6058 - в соответствии с 0,4150 - потеря_расхода: 1,5285 - val_acc: 0,4669
эпоха 2/50
50000/50000 [======================= =======] - 19 с 371 долл. / Шаг - потеря: 1,2563 - в соответствии с: 0,5477 - вэл. Потеря: 1,1447 - валь_акк: 0,5901
Эпоха 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 [ ==============================] - 19 с 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 над сложными проблемами, такими как классификация изображений: достижение «довольно хорошего» результата на основе методов, которые, как известно, хорошо работают, не сложно, но постепенное улучшение становится все более дорогостоящим. Достижение наилучших опубликованных результатов с помощью экспериментов будет за пределами возможностей или доступности многих времени (хотя возможно, при достаточном времени и усилиях, следовать рецептам поваренной книги опубликованных подходов, чтобы воспроизвести их результаты - но даже это никоим образом значит тривиально). Достижение постепенного улучшения из «довольно хорошей» начальной точки может быть очень трудоемким процессом проб и ошибок, и многие эксперименты не дадут существенного улучшения.

Это не означает отговорить кого-либо от попыток учиться, но только для того, чтобы ясно дать понять, что для освоения (постоянно расширяющегося) набора инструментов в пакете хитростей NNet требуются значительные инвестиции, а для продвижения по пути проб и ошибок может потребоваться десятки (или сотни) экспериментов за несколько дней или недель тренировок на GPU.

Время, навыки и ресурсы (выделенный графический процессор), необходимые для обучения сетей очень высокому уровню производительности, частично объясняют популярность предварительно обученных сетей.

Глядя на ваши значения потерь и точности в выборке и вне выборки, ваша модель в настоящее время недостаточно приспособлена, но она монотонно улучшается. Другими словами, кажется, что выполнение этого для большего количества эпох приведет к более высокой предсказательной производительности / меньшей потере энтропии.

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

Вещи, которые вы можете попытаться ускорить обучение:

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

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

III. увеличить размер пакета: я не уверен, какой у вас размер пакета и есть ли у вас графический процессор. Если у вас есть графический процессор, вы, вероятно, должны попытаться увеличить размер пакета в мультипликативных 32.

Наконец, чтобы гарантировать, что ваши данные «обучаемы» / не повреждены (например, вы неохотно применили преобразование, чтобы деформировать их), я бы отбросил всю регуляризацию в вашей архитектуре, запустил обучение и убедился, что вы можете соответствовать учебному набору. , Если вы можете успешно выучить данные тренировок, остальное - обобщающее упражнение. Если вы не можете приспособиться к обучающим данным даже без регуляризации, скорее всего, ваша модель нуждается в большей емкости (более глубокая и широкая архитектура).

Я сделал это сегодня и смог точно достичь 75-80% точности теста.

• Общее количество используемых параметров было: 183,242

• Вы можете сделать лучше, добавив еще несколько слоев, но вам не нужно быть чрезмерным. Более сложные сети не всегда приводят к лучшим результатам.

Предложения

Я предлагаю вам сохранить простоту своей архитектуры. Следуйте за Бритвой Оккама , просто лучше.

• Масштабируйте ваши данные

• Не используйте случайное семя

• Используйте соответствующий оптимизатор; Я использовал Adadelta как есть от Keras.

• CNN не должны быть замысловатыми; будь проще

• Глубокие более тонкие сети иногда работают лучше, чем более широкие

• Используйте регуляризацию (например, Dropout)

Ниже мой код (с использованием 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