CIFAR-10 Tensorflow 백엔드가있는 Keras가 60 % 이상의 정확도를 달성 할 수 없음

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 %를 얻을 수 있습니다. 하나 또는 두 개의 컨볼 루션 레이어가있는 매우 간단한 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 [==============================]-19s 390us / step-손실 : 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 / step-손실 : 0.3188-acc : 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
완료 !!!

다음은 동일한 교육 계획으로 BatchNormalization 또는 Pooling 레이어가없는 상태에서 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 번째 시대 이후의 열차 테스트 데이터의 발산에 의해 입증됩니다. 과적 합이 해결되지 않으면 다른 하이퍼 파라미터 (정규화 전략, 학습 속도 등)를 조정하여 개선 할 가능성이 거의 없습니다.

NNet을 사용할 때 다음을 권장합니다.

1. 좋은 결과를내는 것으로 알려진 아키텍처를 모방 또는 복제하는 아키텍처에서 시작
2. 네트워크에서 과적 합을 특히 염두에두고 데이터 세트의 성능을 검증하십시오 (열차 테스트 오류의 현저한 차이로 나타남)
3. 과적 합이 관찰 될 때 추가 정규화 (드롭 아웃 비율 증가)를 추가하십시오 (과적 합을 방지하기 위해 "충분히"찾고 있습니다-너무 많으면 과적 합을 초래할 수 있습니다)
4. 구조, 훈련 방법 및 하이퍼 파라미터를 실험하여 개선의 길을 찾으십시오.

후자에 관한 처방은 구조, 훈련 또는 하이퍼 매개 변수가 주어진 데이터 세트에서 성능을 산출하기 위해 상호 작용하는 방법에 대한 이론적 근거가 거의 없기 때문에 실제로 얻기가 매우 어렵습니다. 벤치 마크 데이터 세트에서 유사하게 높은 수준의 성능을 달성하는 게시 된 아키텍처에서 사용 된 접근 방식이 매우 다양하다는 사실이 그 증거입니다.

배치 정규화는 일부 아키텍처를 크게 향상시키는 것으로 밝혀졌지만 다른 아키텍처는 아키텍처 없이도 잘 수행 할 수 있습니다 (또는 존재에 무관심). 여기에 제공하는 유일한 실제 지침은 그것을 시도하고 도움이되는지 확인하는 것입니다.

ConvNets에 대한 깊은 이해와 훈련 중 획기적인 인터 포크 성능과 관련하여 찻잎을 읽는 능력이있는 고급 실무자가 아닌 한, 미세 조정 학습 속도는 일반적으로 피해야합니다. 맞춤형 학습률 및 기타 전문 교육 기관은 경우에 따라 네트워크가 로컬 최소 점을 탐색하고 더 나은 전체 솔루션을 찾는 데 도움이 될 수 있지만 네트워크의 수렴 동작을 진단하는 데 많은 시간과 노하우가없는 한 그렇지 않습니다. 시작하기 좋은 곳. 우리 대부분은 Adam과 같은 옵티 마이저를 사용해야합니다. 대부분의 경우 수동 학습 속도에서 초보자 시도보다 성능이 뛰어납니다.

이미지 전처리를 통해 데이터 보강 때때로 (상당한 성능 개선을 수득 일반 수는 더 나은 모델 일반화 될 입력 데이터를 변경 - 데이터 전처리 - 샘플 아웃 정확도 개선 할 수있는 입력 공간에 변화 추가 월정규화 요구 사항 감소-가상 훈련 데이터를 사용하면 정규화가 전혀 필요하지 않지만 이미지 처리 공간에서는 해당 점근선에 접근 할 가능성이 거의 없습니다). 이것은 훈련 시간을 크게 늘리고 수렴 속도를 느리게 할 수 있으며 입력 이미지 순열 기술 (회전, 자르기, 스케일링, 노이즈 등)과 관련된 다른 모든 하이퍼 파라미터 세트를 도입합니다. 이 경로는 학습 시간을 늘리고 결과를 조정하기 위해 추가 실험이 필요할 수 있으므로, 먼저 보강하지 않고 네트워크에서 최고의 정확성을 추구 한 다음, 약간의 보강이 개선되는지 확인하십시오. 그렇다면 추가 실험이 필요할 수 있습니다.

모든 튜닝 실험의 경우 과적 합 및 과적 합 행동의 변화에주의를 기울여야합니다. 네트워크 아키텍처, 훈련 요법 또는 하이퍼 파라미터를 변경하면 드롭 아웃 정규화를 추가로 조정해야 할 수도 있습니다. 훈련 / 테스트 성능에서 과적 및 과적 합 행동을 쉽게 확인할 수있는 능력은 NNet과의 작업에서 가장 중요한 기본 기술이며, 이는 경험에 따라 더욱 직관적입니다.

이것은 당신의 모든 노력이 인도 될 초입니다. 촛불은 길을 희미하게 비출 수 있지만 어둠이 없으면 어둠 속에서 걸려 넘어 질 것입니다. 네트워크가 과도하거나 과도하게 적합하지 않은 경우 네트워크 구조 또는 하이퍼 파라미터의 임의 순열을 시도하기 전에 해결해야합니다.

이 답변에 포함 된 바닐라 교육 요법을 사용하는 비교적 간단한 아키텍처는 이미지 분류와 같은 어려운 문제에 대해 NNET 아키텍처로 작업하는 현실을 보여줍니다. 제대로 작동하는 것으로 알려진 접근 방식을 기반으로 "꽤 좋은"결과를 얻는 것은 어렵지 않지만 점진적으로 개선됩니다. 점점 비용이 많이 듭니다. 실험을 통해 가장 많이 게시 된 결과를 달성하는 것은 많은 사람들의 능력이나 시간 가용성을 넘어 설 것입니다. (충분한 시간과 노력으로 결과를 복제하기 위해 게시 된 접근 방식의 요리 책 레시피를 따르는 것이 가능합니다.) 사소한 의미). "꽤 좋은"출발점에서 점진적인 개선을 얻는 것은 많은 시간이 걸리는 시행 착오의 과정이 될 수 있으며, 많은 실험에서 크게 개선되지는 않을 것입니다.

이것은 누군가가 배우려고 시도하는 것을 설득하기위한 것이 아니라, NNet 기술 요령에서 도구 집합을 익히는 데 필요한 상당한 투자가 있으며 시행 착오를 통해 개선을 이끌어내는 데 필요한 상당한 투자가 있음을 분명히하기위한 것입니다. 며칠 또는 몇 주 동안의 전용 GPU 교육에 대한 수십 또는 수백 건의 실험.

네트워크를 매우 높은 수준의 성능으로 훈련시키는 데 필요한 시간, 기술 및 리소스 (전용 GPU)는 부분적으로 사전 훈련 된 네트워크의 인기를 설명합니다.

샘플 내 및 샘플 외 손실 및 정확도 값을 보면 현재 모델이 적합하지 않지만 단조롭게 개선되고 있습니다. 다시 말해, 더 많은 에포크에 대해이를 실행하면 예측 성능이 높아지고 엔트로피 손실이 줄어 듭니다.

고도로 정규화 된 (드롭 아웃 레이어) 아키텍처를 사용하고 있으며 이는 나쁘지 않습니다. 그러나 정규화가없는 것보다 훈련 시간이 훨씬 오래 걸린다는 것도 놀라운 일이 아닙니다. 드롭 아웃 레이어로 인해 (실질적으로) 과도하게 적합하지 않을 수 있습니다.

학습 속도를 높일 수있는 것들 :

나는. 학습 속도를 조정하십시오. 예를 들어 작은 것을 시작으로 가운데에서 하이킹을하고 끝을 향해 다시 내려갑니다.

ii. 배치 정규화 추가 : 위의 아키텍처에서 컨벌루션 블록과 짙은 레이어에 배치 규범을 포함시킬 수 있습니다. 일반적으로 배치 표준 레이어는 비선형 활성화 후 드롭 아웃 전에 추가됩니다. 배치 노름이 maxnorm과 얼마나 잘 작동하는지 잘 모르겠습니다. 밀도가 높은 레이어의 경우 maxnorm을 사용하거나 사용하지 않고 batch-norm + dropuout을 시도합니다. 배치 정규화를 적용하면 maxnorm이 필요하지 않은 느낌이 있습니다.

iii. 배치 크기 증가 : 배치 크기가 무엇인지, GPU를 소유하고 있는지 확실하지 않습니다. GPU가 있다면 32 배의 곱셈에서 배치 크기를 최대화해야 할 것입니다.

마지막으로, 데이터가 '학습 가능'/ 손상되지 않도록하기 위해 (예를 들어 변형을 의도적으로 적용하지 않은 경우) 아키텍처에서 모든 정규화를 버리고 교육을 실행하고 교육 세트에 과적 합할 수 있음을 알 수 있습니다 . 훈련 데이터를 성공적으로 배울 수 있다면 나머지는 일반화 운동입니다. 정규화가 없어도 교육 데이터에 과적 합할 수없는 경우 모델에 더 많은 용량 (깊고 넓은 아키텍처)이 필요합니다.

나는 오늘이 기회를 주었고 지속적으로 테스트 정확도에서 거의 75-80 %를 칠 수 있었다.

• 사용 된 총 매개 변수 수는 다음과 같습니다. 183,242

• 레이어를 몇 개 더 추가하여 더 잘 수행 할 수 있지만 과도 할 필요는 없습니다. 더 복잡한 네트워크가 항상 더 나은 결과를 낳지는 않습니다.

제안

내 제안은 아키텍처를 단순하게 유지하는 것입니다. Occam의 면도기를 따르십시오 . 간단합니다.

• 데이터 확장

• 임의의 씨앗을 사용하지 마십시오

• 적절한 최적화 프로그램을 사용하십시오. 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