CIFAR-10 Không thể có được Độ chính xác trên 60%, Máy ảnh có phụ trợ kéo căng [đóng]

Việc đào tạo sau 15 epoch trên bộ dữ liệu CIFAR-10 dường như làm cho việc mất xác nhận không còn giảm nữa, bám sát khoảng 1.4 (với độ chính xác 60%). Tôi đã xáo trộn bộ huấn luyện, chia cho 255 và nhập dưới dạng float32. Tôi đã thử rất nhiều kiến ​​trúc, cả có và không có trong các lớp Conv2D và dường như không có gì hoạt động. Kiến trúc tương tự đạt được độ chính xác 99,7% trên các bộ thử nghiệm cho MNIST. Xin vui lòng xem kiến ​​trúc dưới đây:

(Lưu ý: Tôi đã thử tăng tỷ lệ bỏ học và tăng / giảm tốc độ học tập của trình tối ưu hóa Adam để ngăn chặn quá mức, tất cả điều này là ngăn chặn quá mức nhưng với cả đào tạo và kiểm tra hiện có độ chính xác thấp tương tự khoảng 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)

Các kết quả:

    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)

Cập nhật: Thử nghiệm thêm bao gồm BatchN normalization cả có và không có MaxNorm -

Kiến trúc mới:

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

Lưu ý rằng MNIST là một vấn đề đơn giản hơn nhiều so với CIFAR-10 và bạn có thể nhận được 98% từ một NNet được kết nối đầy đủ (không tích chập) với rất ít khó khăn. Một CNN rất đơn giản chỉ với một hoặc hai lớp chập có thể có cùng độ chính xác.

Tôi không chắc chắn về kiến ​​trúc NNet của bạn, nhưng tôi có thể giúp bạn đạt độ chính xác kiểm tra 78% trên CIFAR-10 với kiến ​​trúc sau (tương đối đơn giản hơn và có trọng lượng ít hơn). Không yêu cầu khởi tạo hoặc nắm giữ đặc biệt, sử dụng mặc định vanilla và trình tối ưu hóa 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'])

Kiến trúc này khá đơn giản và dựa trên https://arxiv.org/pdf/1412.6806.pdf .

Đào tạo mô hình này như vậy:

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

Đưa ra những điều sau đây, mà bạn có thể thấy đạt gần 77% vào kỷ nguyên thứ 25 và ít nhiều làm phẳng từ đó (nhưng có đủ sự đều đặn từ bỏ học để ngăn chặn nó xuống cấp do quá mức, ít nhất là qua số lần lặp được kiểm tra) .

Đào tạo trên 50000 mẫu, xác thực trên 10000 mẫu
Epoch 1/50
50000/50000 [==============================] - 19s 390us / bước - mất: 1.6058 - acc: 0.4150 - val_loss: 1.5285 - val_acc: 0.4669
Epoch
2/50 50000/50000 [======================= =======] - 19s 371us / bước - mất: 1.2563 - acc: 0.5477 - val_loss: 1.1447 - val_acc: 0.5901
Epoch 3/50
50000/50000 [============= =================] - 19s 373us / bước - mất: 1.0784 - acc: 0.6163 - val_loss: 1.1577 - val_acc: 0.6002
...
Epoch 25/50
50000/50000 [ ==============================] - 19s 374us / bước - mất: 0.3188 - acc: 0.8857 - val_loss: 0.7493 - val_acc : 0,7680
...
Kỷ nguyên 50/50
50000/50000 [==============================] - 19s 373us / bước - mất: 0.1928 - acc: 0.9329 - val_loss : 0.8718 - val_acc: 0.7751
Xong !!!

Đây là một kiến ​​trúc thậm chí đơn giản hơn và nhỏ hơn nhiều, có thể nhanh chóng đạt tới 70% với cùng một chế độ luyện tập (không có lớp BatchN normalization hoặc gộp chung):

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

Điều đáng chú ý là các kiến ​​trúc có độ chính xác được công bố tốt nhất trên CIFAR-10 (hiện nằm trong khoảng 90-96%) thường phức tạp hơn và mất nhiều giờ để đào tạo về phần cứng GPU. Nhưng tôi đã có thể đạt đến phạm vi 70-80% với các kiến ​​trúc khá đơn giản, đào tạo trong vài phút, đó là những gì tôi khuyên dùng trước khi có kết quả được công bố tốt nhất thường đòi hỏi kiến ​​trúc phức tạp hơn, thời gian đào tạo dài hơn, đôi khi chế độ chăm sóc / huấn luyện đặc biệt hoặc tăng cường dữ liệu và thời gian đào tạo.

CẬP NHẬT:

Dựa trên các ô được cập nhật trong câu hỏi, vấn đề rõ ràng nhất được thể hiện là quá mức. Điều này được chứng minh bằng sự phân kỳ của dữ liệu thử nghiệm tàu ​​sau khoảng kỷ nguyên thứ 15 thể hiện sự không đủ chính quy cho kiến ​​trúc này, đối với tập dữ liệu này. Bạn sẽ khó có thể có được sự cải thiện từ việc điều chỉnh bất kỳ siêu đường kính nào khác (chiến lược bình thường hóa, tỷ lệ học tập, v.v.) trừ khi giải quyết quá mức.

Khi sử dụng NNets, tôi khuyên bạn nên như sau:

1. Bắt đầu từ các kiến ​​trúc bắt chước hoặc sao chép những cái đã biết để tạo ra kết quả tốt
2. Xác minh hiệu suất trên tập dữ liệu của bạn, với một con mắt cụ thể để phù hợp quá mức trong mạng (được chứng minh bằng sự khác biệt đáng kể của các lỗi kiểm tra tàu)
3. Thêm chính quy hóa bổ sung (tăng tỷ lệ bỏ học) khi quan sát quá mức (bạn đang tìm kiếm "vừa đủ" để ngăn chặn quá mức - quá nhiều sẽ dẫn đến tình trạng không phù hợp)
4. Thử nghiệm với cấu trúc, phương pháp đào tạo và siêu tham số để tìm ra con đường cải thiện

Các đơn thuốc liên quan đến cái sau thực sự khá khó để ra đời, bởi vì có rất ít nền tảng lý thuyết về cách cấu trúc, đào tạo hoặc siêu tham số tương tác để mang lại hiệu suất trên bất kỳ tập dữ liệu nào. Các phương pháp được sử dụng bởi các kiến ​​trúc được công bố đạt được mức hiệu suất cao tương tự trên các tập dữ liệu điểm chuẩn khác nhau rất nhiều là bằng chứng về điều này.

Batchn normalization đã được tìm thấy để cải thiện đáng kể một số kiến ​​trúc, nhưng những người khác có thể làm khá tốt mà không cần nó (hoặc không quan tâm đến sự hiện diện của nó). Hướng dẫn thực sự duy nhất để cung cấp ở đây là thử nó và xem nếu nó giúp.

Nói chung, nên tránh tốc độ học tập tinh chỉnh trừ khi bạn là một học viên tiên tiến có hiểu biết sâu sắc về ConvNets và khả năng đọc lá trà tương ứng liên quan đến hiệu suất tăng dần giữa các kỷ nguyên trong quá trình đào tạo. Tỷ lệ học tập tùy chỉnh và chế độ đào tạo chuyên ngành khác trong một số trường hợp có thể giúp các mạng điều hướng xung quanh cực tiểu địa phương và tìm giải pháp tổng thể tốt hơn, nhưng trừ khi bạn có nhiều thời gian và bí quyết để chẩn đoán hành vi hội tụ của mạng, điều này không phải là Một nơi tốt để bắt đầu. Hầu hết chúng ta nên sử dụng một trình tối ưu hóa như Adam, nó sẽ vượt trội hơn so với những nỗ lực mới làm quen với tốc độ học tập được điều chỉnh bằng tay trong phần lớn các trường hợp.

Tăng cường dữ liệu thông qua quá trình tiền xử lý hình ảnh đôi khi có thể mang lại những cải tiến hiệu suất đáng kể (nói chung, dữ liệu đầu vào càng đa dạng thì mô hình sẽ càng khái quát hóa - tiền xử lý dữ liệu thêm biến thể vào không gian đầu vào có thể cải thiện độ chính xác ngoài mẫu và có thểđủ khả năng giảm các yêu cầu chính quy hóa - theo giả thuyết, với dữ liệu đào tạo vô hạn, chúng tôi sẽ không cần bất kỳ sự chính quy hóa nào, nhưng trong không gian xử lý hình ảnh, chúng tôi khó có thể tiếp cận với tiệm cận đó). Điều này có thể làm tăng đáng kể thời gian đào tạo và tốc độ hội tụ chậm, và giới thiệu một loạt các siêu đường kính khác liên quan đến các kỹ thuật hoán vị hình ảnh đầu vào (xoay, cắt, chia tỷ lệ, nhiễu, v.v.). Vì đường dẫn này có thể tăng thời gian đào tạo và yêu cầu thử nghiệm bổ sung để điều chỉnh kết quả, một số lời khuyên chung sẽ là lái xe để có độ chính xác tốt nhất trong mạng của bạn mà không cần tăng cường trước, sau đó xem liệu một số gia tăng khiêm tốn có cải thiện không. Nếu có, nó có thể đảm bảo thử nghiệm thêm.

Đối với bất kỳ và tất cả các thử nghiệm điều chỉnh, bạn sẽ cần để mắt đến những thay đổi trong hành vi quá mức và không phù hợp. Thay đổi kiến ​​trúc mạng, chế độ đào tạo hoặc siêu âm có thể yêu cầu điều chỉnh bổ sung quy trình bỏ học. Khả năng dễ dàng xác định hành vi phù hợp và quá mức từ hiệu suất đào tạo / kiểm tra được cho là kỹ năng cơ bản quan trọng nhất khi làm việc với NNets, và điều này trở nên trực quan hơn với kinh nghiệm.

Đây là ngọn nến mà tất cả những nỗ lực của bạn sẽ được hướng dẫn. Cây nến chỉ có thể chiếu sáng con đường một cách mờ nhạt, nhưng không có nó, bạn sẽ bị loạng choạng trong bóng tối. Nếu mạng của bạn quá kém hoặc không phù hợp, điều đó cần được giải quyết trước khi thử hoán vị ngẫu nhiên cấu trúc mạng hoặc siêu đường kính.

Các kiến ​​trúc tương đối đơn giản với các chế độ đào tạo vanilla có trong câu trả lời này cho thấy thực tế khi làm việc với các kiến ​​trúc NNET về các vấn đề khó khăn như phân loại hình ảnh: đạt được kết quả "khá tốt" dựa trên các phương pháp được biết là hoạt động tốt không khó, nhưng cải thiện gia tăng ngày càng tốn kém. Đạt được kết quả được công bố tốt nhất thông qua thử nghiệm sẽ vượt quá khả năng hoặc thời gian có sẵn của nhiều người (mặc dù có thể, với đủ thời gian và nỗ lực, để làm theo các công thức nấu ăn của các phương pháp tiếp cận được công bố để sao chép kết quả của họ - nhưng ngay cả điều này là không nghĩa là tầm thường). Đạt được sự cải thiện gia tăng từ điểm xuất phát "khá tốt" có thể là một quá trình thử và sai rất tốn thời gian, và nhiều thử nghiệm sẽ không mang lại bất kỳ cải thiện đáng kể nào.

Điều này không có nghĩa là ngăn cản bất cứ ai cố gắng học, mà chỉ để làm rõ rằng cần có một khoản đầu tư đáng kể để làm chủ bộ công cụ (bao giờ mở rộng) trong túi thủ thuật NNet và có thể yêu cầu cải tiến thông qua thử và sai hàng chục (hoặc hàng trăm) thử nghiệm trong nhiều ngày hoặc vài tuần đào tạo GPU chuyên dụng.

Thời gian, kỹ năng và tài nguyên (GPU chuyên dụng) cần thiết để đào tạo các mạng đến mức hiệu suất rất cao giải thích phần nào sự phổ biến của các mạng được đào tạo trước.

Nhìn vào các giá trị độ mất và độ chính xác trong mẫu và ngoài mẫu của bạn, mô hình của bạn hiện đang bị thiếu, nhưng nó đang được cải thiện một cách đơn điệu. Nói cách khác, có vẻ như chạy cái này trong nhiều kỷ nguyên hơn sẽ dẫn đến hiệu suất dự đoán cao hơn / mất entropy ít hơn.

Bạn đang sử dụng một kiến ​​trúc (các lớp thả ra) được chuẩn hóa cao, điều này không tệ. Tuy nhiên, cũng không có gì đáng ngạc nhiên khi việc đào tạo mất nhiều thời gian hơn mà không có bất kỳ sự chính quy nào. Do các lớp thả ra, không chắc là bạn sẽ (về cơ bản) quá phù hợp.

Những điều bạn có thể cố gắng để tăng tốc học tập:

Tôi. điều chỉnh tốc độ học tập: ví dụ: bắt đầu với một cái nhỏ, tăng nó lên ở giữa và về phía cuối hạ nó xuống một lần nữa.

ii. thêm hàng loạt : trong kiến ​​trúc ở trên, bạn có thể bao gồm định mức hàng loạt cả trong các khối chập và các lớp dày đặc của bạn. Thông thường, lớp định mức hàng loạt được thêm vào sau khi kích hoạt phi tuyến nhưng trước khi bỏ học. Tôi không chắc chắn mức độ chơi theo tiêu chuẩn hàng loạt với maxnorm. Đối với các lớp dày đặc của bạn, tôi sẽ thử lô-Norm + dropuout có / không có maxnorm. Tôi có cảm giác bạn không cần maxnorm nếu bạn áp dụng chuẩn hóa hàng loạt.

iii. tăng kích thước lô: Tôi không chắc kích thước lô của bạn là bao nhiêu và bạn có sở hữu GPU hay không. Nếu bạn có GPU, có lẽ bạn nên cố gắng tối đa hóa kích thước lô của mình theo bội số của 32.

Cuối cùng, để đảm bảo rằng dữ liệu của bạn 'có thể học được' / không bị hỏng (ví dụ: bạn không sẵn sàng áp dụng một biến đổi để làm cong nó), tôi sẽ vứt bỏ tất cả các quy tắc từ kiến ​​trúc của bạn, chạy đào tạo và thấy rằng bạn có thể phù hợp với tập huấn luyện . Nếu bạn có thể học dữ liệu đào tạo thành công, phần còn lại là một bài tập khái quát. Nếu bạn không thể phù hợp với dữ liệu đào tạo ngay cả khi không có sự chính quy, rất có thể mô hình của bạn cần nhiều dung lượng hơn (kiến trúc sâu hơn và rộng hơn).

Tôi đã cho nó một phát bắn ngày hôm nay và liên tục có thể đạt gần 75-80% độ chính xác kiểm tra.

• Tổng số tham số được sử dụng là: 183,242

• Bạn có thể làm tốt hơn bằng cách thêm có thể thêm một vài lớp nữa, nhưng bạn không cần quá nhiều. Các mạng phức tạp hơn không phải lúc nào cũng dẫn đến kết quả tốt hơn.

Gợi ý

Đề nghị của tôi cho bạn là bạn giữ cho kiến ​​trúc của bạn đơn giản. Theo Occam's Razor , đơn giản là tốt hơn.

• Chia tỷ lệ dữ liệu của bạn

• Đừng sử dụng hạt giống ngẫu nhiên

• Sử dụng một trình tối ưu hóa thích hợp; Tôi đã sử dụng Adadelta như là từ Keras.

• CNN không cần phải bị chia rẽ; giữ cho nó đơn giản

• Mạng lưới da sâu hơn đôi khi hoạt động tốt hơn so với mạng rộng hơn

• Sử dụng chính quy (ví dụ: Bỏ học)

Dưới đây là mã của tôi (sử dụng 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