CIFAR-10は60％を超える精度を得ることができない、Tensorflowバックエンドを使用するKeras [終了]

CIFAR-10データセットで15エポック後にトレーニングを行うと、検証損失が減少せず、1.4程度に留まるようになります（60％の検証精度）。トレーニングセットをシャッフルし、255で割って、float32としてインポートしました。Conv2Dレイヤーにドロップアウトがある場合とない場合の両方で、多数のアーキテクチャーを試しましたが、何も機能しないようです。同じアーキテクチャは、MNISTのテストセットで99.7％の精度を達成します。以下のアーキテクチャをご覧ください。

（注：過剰適合を防ぐために、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)

更新：MaxNormを使用した場合と使用しない場合の両方のBatchNormalizationを含むさらなるテスト-

新しいアーキテクチャ：

    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よりもはるかに単純な問題セットであり、完全に接続された（畳み込みではない）NNetから98％をほとんど問題なく取得できることに注意してください。1つまたは2つの畳み込み層のみを持つ非常に単純なCNNも、同じレベルの精度を得ることができます。

NNetアーキテクチャについてはわかりませんが、次のアーキテクチャ（比較的単純で重みが少ない）のCIFAR-10で78％のテスト精度を実現できます。バニラのデフォルトと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!!!')

次の結果が得られます。25番目のエポックまでにほぼ77％に達し、そこからほぼ平坦になります（ただし、ドロップアウトからの正規化は十分に行われているため、少なくともテストされた反復回数にわたって、過剰適合により低下することはありません）。 。

50000サンプルで トレーニング、10000サンプルで検証
Epoch 1/50
50000/50000 [==============================]-19秒390us /ステップ-損失：1.6058-acc：0.4150-val_loss：1.5285-val_acc：0.4669
Epoch
2/50 50000/50000 [======================== =======]-19秒371us /ステップ-損失：1.2563-acc：0.5477-val_loss：1.1447-val_acc：0.5901
Epoch 3/50
50000/50000 [============= =================]-19秒373us /ステップ-損失：1.0784-acc：0.6163-val_loss：1.1577-val_acc：0.6002
...
エポック25/50
50000/50000 [ ==============================]-19秒374us /ステップ-損失：0.3188-acc：0.8857-val_loss：0.7493-val_acc ：0.7680
...
エポック50/50
50000/50000 [==============================]-19秒373us /ステップ-損失：0.1928-acc：0.9329-val_loss ：0.8718-val_acc：0.7751
完了!!!

これは、同じトレーニングレジメン（BatchNormalizationまたはプーリングレイヤーなし）で70％にかなり早く到達できる、さらに単純ではるかに小さいアーキテクチャです。

# 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. 構造、トレーニングアプローチ、ハイパーパラメータを試し、改善の道を見つける

後者についての処方は、構造、トレーニング、またはハイパーパラメーターがどのように相互作用して特定のデータセットのパフォーマンスを生み出すかについての理論的基盤がほとんどないため、実際に入手するのは非常に困難です。ベンチマークデータセットで同様の高レベルのパフォーマンスを実現する公開アーキテクチャで採用されているアプローチが非常に多様であることは、その証拠です。

バッチ正規化は一部のアーキテクチャを大幅に改善することがわかっていますが、他のアーキテクチャはそれなしでも非常にうまく機能します（またはその存在に無関心です）。ここで提供する唯一の実際のガイダンスは、それを試して、それが役立つかどうかを確認することです。

ConvNetを深く理解し、トレーニング中のエポック間の増分パフォーマンスに関して茶葉を読み取る対応する能力を備えた上級開業医でない限り、学習率の微調整は一般に避けてください。カスタマイズされた学習率やその他の特殊なトレーニング計画は、ネットワークが局所的な最小値の周りを移動し、より良い全体的なソリューションを見つけるのに役立つ場合がありますが、ネットワークの収束動作を診断するための多くの時間とノウハウがない限り、これは不可能です開始するには良い場所です。ほとんどの場合、Adamのようなオプティマイザを使用する必要があります。このオプティマイザは、ほとんどの場合、初心者の手作業による学習率での試行よりも優れています。

画像前処理を介してデータの増大は、時々 （一般的には、より多くのより良いモデルは一般れる入力データを変化させ大幅なパフォーマンス向上をもたらすことができる-データの前処理をアウト・オブ・サンプル精度及び向上させることができ、入力空間に変化を追加月を正則化要件を削減できます-仮説的には、無限のトレーニングデータでは正則化はまったく必要ありませんが、画像処理空間ではその漸近線に近づくことはほとんどありません）。これにより、トレーニング時間が大幅に増加し、収束率が遅くなる可能性があります。また、入力画像の並べ替え手法（回転、クロッピング、スケーリング、ノイズなど）に関連するハイパーパラメータのセット全体が導入されます。このパスはトレーニング時間を増加させ、結果を調整するために追加の実験を必要とする可能性があるため、いくつかの一般的なアドバイスは、最初に拡張せずにネットワークで最高の精度を得るために駆動し、次に適度な拡張によって改善が見られるかどうかを確認することです。存在する場合は、さらに実験する必要があります。

あらゆるチューニング実験では、過剰適合と過小適合の動作の変化に注意する必要があります。ネットワークアーキテクチャ、トレーニングレジメン、またはハイパーパラメーターを変更するには、ドロップアウトの正規化をさらに調整する必要がある場合があります。トレーニング/テストのパフォーマンスから過大および過小の動作を簡単に確認する機能は、おそらくNNetを操作する上で最も重要なベースラインスキルであり、これは経験によってより直感的になります。

これはあなたのすべての努力が導かれるろうそくです。ろうそくは道をほのかに照らすことができますが、それがなければ暗闇の中でつまずくでしょう。ネットワークの適合性が過剰または不足している場合は、ネットワーク構造またはハイパーパラメーターのランダムな置換を試みる前に対処する必要があります。

この回答に含まれているバニラトレーニングレジメンを含む比較的単純なアーキテクチャは、画像分類などの難しい問題でNNETアーキテクチャを使用する現実を示しています。うまく機能することがわかっているアプローチに基づいて「かなり良い」結果を得るのは難しいことではありませんが、漸進的な改善ますますコストがかかります。実験を通じて最良の公開結果を達成することは、多くの能力や時間の利用可能性を超えてしまいます（十分な時間と労力で、公開されたアプローチのクックブックレシピに従って結果を複製することは可能ですが、これでも不可能ですささいな意味）。「かなり良い」開始点から段階的に改善することは、試行錯誤の非常に時間のかかるプロセスになる可能性があり、多くの実験では、大きな改善は得られません。

これは、誰もが学習しようとするのを思いとどまらせることを意味するのではなく、トリックのNNetバッグの（常に拡大する）ツールセットを習得するために必要な多大な投資があり、試行錯誤による改善の推進には数十または数百の実験を数日または数週間の専用GPUトレーニングで行う。

ネットワークを非常に高いレベルのパフォーマンスにトレーニングするために必要な時間、スキル、およびリソース（専用GPU）は、トレーニング済みネットワークの人気の一部を説明しています。

サンプル内およびサンプル外の損失と精度の値を見ると、モデルは現在不十分ですが、単調に改善しています。つまり、これをより多くのエポックで実行すると、予測パフォーマンスが高くなり、エントロピー損失が少なくなるようです。

高度に正規化された（ドロップアウトレイヤー）アーキテクチャを使用していますが、これは悪くありません。ただし、トレーニングが正規化なしの場合よりもはるかに長くかかることも当然のことです。ドロップアウトレイヤーがあるため、（実質的に）オーバーフィットすることはほとんどありません。

学習を加速するためにできること：

私。学習率を微調整します。たとえば、小さいものから始めて、中央で引き上げ、最後に向かってもう一度下げます。

ii。バッチ正規化を追加：上記のアーキテクチャでは、畳み込みブロックと高密度レイヤーの両方にバッチノルムを含めることができます。通常、バッチノルムレイヤーは、非線形アクティブ化の後、ドロップアウトの前に追加されます。バッチノルムがmaxnormでどれだけうまく機能するかわかりません。あなたの密な層のために、私はmaxnormの有無にかかわらずbatch-norm + dropuoutを試します。バッチ正規化を適用する場合、maxnormは必要ないと感じています。

iii。バッチサイズを増やす：あなたのバッチサイズが何であるか、そしてあなたがGPUを所有しているかどうかはわかりません。GPUを使用している場合は、おそらく32の乗法でバッチサイズを最大化する必要があります。

最後に、データが「学習可能」/破損していないことを確認するために（たとえば、不本意に変換を適用して変形させていない）、アーキテクチャからすべての正則化を破棄し、トレーニングを実行して、トレーニングセットにオーバーフィットできることを確認します。トレーニングデータを正常に学習できたら、残りは一般化の練習です。正規化を行わなくてもトレーニングデータにオーバーフィットできない場合は、モデルにさらに多くの容量が必要です（より深く、より広いアーキテクチャ）。

今日はこれを試してみましたが、テストの精度は常に75〜80％近くにありました。

• 使用されたパラメーターの総数は次のとおりです。 183,242

• いくつかのレイヤーを追加することでより良い結果を得ることができますが、過度である必要はありません。より複雑なネットワークが常により良い結果をもたらすとは限りません。

提案

あなたへの私の提案は、あなたのアーキテクチャをシンプルに保つことです。OccamのRazorに従ってください。シンプルな方が良いです。

• データをスケーリングする

• ランダムシードを使用しない

• 適切なオプティマイザを使用してください。KerasのAdadeltaをそのまま使用しました。

• 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