CIFAR-10 60% से अधिक नहीं मिल सकता है सटीकता, टेन्सरफ़्लो बैकएंड के साथ केरस [बंद]

बन्द है। यह सवाल ऑफ टॉपिक है । यह वर्तमान में उत्तर स्वीकार नहीं कर रहा है।

इस प्रश्न को सुधारना चाहते हैं? प्रश्न को अपडेट करें ताकि यह क्रॉस मान्य के लिए विषय पर हो ।

पिछले साल बंद हुआ ।

CIFAR-10 डेटासेट पर 15 युगों के बाद प्रशिक्षण को लगता है कि अब सत्यापन में कोई कमी नहीं होगी, जो लगभग 1.4 (60% सत्यापन सटीकता के साथ) चिपका है। मैंने प्रशिक्षण सेट में फेरबदल किया है, इसे 255 से विभाजित किया है, और फ्लोट 32 के रूप में आयात किया है। मैंने कई आर्किटेक्चर की कोशिश की है, दोनों के साथ और कन्वर्जन 2 लेयर में ड्रॉपआउट के बिना और कुछ भी काम नहीं करता है। एक ही आर्किटेक्चर MNIST के लिए परीक्षण सेट पर 99.7% सटीकता प्राप्त करता है। कृपया नीचे आर्किटेक्चर देखें:

(ध्यान दें: मैंने ओवरफिटिंग को रोकने के लिए एडम ऑप्टिमाइज़र के ड्रॉपआउट और बढ़ती / घटती सीखने की दर को बढ़ाने की कोशिश की है, यह सब ओवरफिटिंग को रोकता है लेकिन प्रशिक्षण और परीक्षण दोनों के साथ अब 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)

अपडेट: मैक्समोर के साथ और बिना दोनों के बैचनलाइज़ेशन सहित आगे का परीक्षण -

नई वास्तुकला:

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

neural-networks conv-neural-network keras

— user4779
स्रोत

जवाबों:

ध्यान दें कि MNIST CIFAR-10 की तुलना में बहुत सरल समस्या है, और आप बहुत कम कठिनाई के साथ पूरी तरह से जुड़े (गैर-दृढ़) NNet से 98% प्राप्त कर सकते हैं। केवल एक या दो संकेंद्रित परतों के साथ एक बहुत ही सरल सीएनएन उसी तरह की सटीकता के स्तर तक पहुंच सकता है।

मैं आपके एननेट आर्किटेक्चर के बारे में निश्चित नहीं हूं, लेकिन मैं आपको निम्नलिखित आर्किटेक्चर (जो तुलनात्मक रूप से सरल है और कम वजन है) के साथ CIFAR-10 पर 78% परीक्षण सटीकता प्राप्त कर सकता है। वेनिला चूक और एडम ऑप्टिमाइज़र का उपयोग करते हुए कोई विशेष आरंभीकरण या हैंडहोल्डिंग की आवश्यकता नहीं थी:

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 [================================] - 19 s 390us / चरण - हानि: 1.6058 - एसीसी: 0.4150 - val_loss: 1.5285 - val_acc: 0.4669
युग
2/50 50000/50000 [======================= =======] - 19s 371us / चरण - हानि: 1.2563 - एसीसी: 0.5477 - val_loss: 1.1447 - val_acc: 0.5901
युग 3/50
50000/50000 [===============] ===================] - 19s 373us / चरण - हानि: 1.0784 - एसीसी: 0.6163 - val_loss: 1.1577 - val_acc: 0.6002
...
युग 25/50
50000-50000 [ ==============================] - 19s 374us / चरण - हानि: 0.3188 - acc: 0.8857 - val_loss: 0.7493 - val_acc : 0.7680
...
युग 50/50
50000/50000 [==============================] - 19s 373us / चरण - हानि: 0.1928 - acc: 0.9329 - val_loss : 0.8718 - val_acc: 0.7751 हो
गया !!!

यहां एक और भी सरल और बहुत छोटी वास्तुकला है जो एक ही प्रशिक्षण आहार (कोई बैचनलाइज़ेशन या पूलिंग परतों) के साथ 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 का उपयोग करने में, मैं निम्नलिखित सलाह देता हूं:

आर्किटेक्चर से शुरू करें जो अच्छे परिणाम उत्पन्न करने के लिए ज्ञात लोगों की नकल करते हैं या नकल करते हैं
नेटवर्क में ओवर-फिटिंग के लिए एक विशेष आंख के साथ अपने डेटा सेट पर प्रदर्शन को सत्यापित करें (ट्रेन-परीक्षण त्रुटियों के महत्वपूर्ण विचलन द्वारा सबूत)
जब ओवरफिटिंग देखी जाती है तो अतिरिक्त नियमितिकरण (ड्रॉपआउट दरें बढ़ाएं) जोड़ें (आप ओवरफिटिंग को रोकने के लिए "बस पर्याप्त" की तलाश में हैं - बहुत अधिक परिणाम अंडर-फिटिंग में होगा)
सुधार के रास्ते खोजने के लिए संरचना, प्रशिक्षण दृष्टिकोण और हाइपर-मापदंडों के साथ प्रयोग

उत्तरार्द्ध के बारे में दिए गए नुस्खे वास्तव में काफी कठिन हैं, क्योंकि संरचना, प्रशिक्षण या हाइपर-पैरामीटर किसी भी दिए गए डेटा सेट पर प्रदर्शन करने के लिए बातचीत करते हैं, इसके लिए थोड़ा सैद्धांतिक आधार है। बेंचमार्क डेटा सेटों पर प्रदर्शन के समान-उच्च स्तर को प्राप्त करने वाले प्रकाशित आर्किटेक्चर द्वारा नियोजित दृष्टिकोण अलग-अलग होते हैं इसलिए इसका प्रमाण बहुत है।

कुछ आर्किटेक्चर में काफी सुधार करने के लिए बैचेनीकरण पाया गया है, लेकिन अन्य इसके बिना काफी अच्छा कर सकते हैं (या इसकी उपस्थिति के प्रति उदासीन हैं)। यहाँ प्रदान करने के लिए एकमात्र वास्तविक मार्गदर्शन यह कोशिश करना है और देखें कि क्या यह मदद करता है।

ललित-ट्यूनिंग सीखने की दरों को आमतौर पर तब तक टाला जाना चाहिए जब तक कि आप एक उन्नत अभ्यासी न हों, क्योंकि कन्वेंशन की गहरी समझ और प्रशिक्षण के दौरान अंतर-युगीन वृद्धिशील प्रदर्शन के संबंध में चाय की पत्तियों को पढ़ने की संगत क्षमता। अनुकूलित सीखने की दर और अन्य विशेष प्रशिक्षण regimens कुछ मामलों में नेटवर्क को स्थानीय मिनीमा के चारों ओर नेविगेट करने और बेहतर समग्र समाधान खोजने में मदद कर सकते हैं, लेकिन जब तक आपके पास बहुत समय नहीं होता और नेटवर्क के अभिसरण व्यवहार का पता नहीं चलता, यह नहीं है। शुरू करने की अच्छी जगह। हम में से अधिकांश को एडम जैसे एक आशावादी का उपयोग करना चाहिए जो अधिकांश मामलों में हाथ से सीखने की दर पर नौसिखिया प्रयासों को बेहतर बना देगा।

छवि प्रीप्रोसेसिंग के माध्यम से डेटा वृद्धि कभी-कभी महत्वपूर्ण प्रदर्शन में सुधार ला सकती है (सामान्य तौर पर, इनपुट डेटा को जितना अधिक विविध किया जाएगा उतना ही मॉडल सामान्य होगा - डेटा प्रीप्रोसेसिंग इनपुट स्पेस में भिन्नता जोड़ता है जो आउट-ऑफ-सैंपल सटीकता में सुधार कर सकता है और हो सकता हैनियमितीकरण आवश्यकताओं में कमी को वहन करना - काल्पनिक रूप से, अनंत प्रशिक्षण डेटा के साथ हमें किसी भी नियमितीकरण की आवश्यकता नहीं होगी, लेकिन इमेज प्रोसेसिंग स्पेस में हम उस असममित दृष्टिकोण की संभावना नहीं रखते हैं)। यह हालांकि, प्रशिक्षण समय और धीमी गति से अभिसरण दर को बढ़ा सकता है, और इनपुट छवि क्रमपरिवर्तन तकनीकों (रोटेशन, फसल, स्केलिंग, शोर, आदि) से संबंधित हाइपरपैरमीटर के एक पूरे अन्य सेट का परिचय देता है। क्योंकि यह पथ प्रशिक्षण के समय को बढ़ा सकता है और परिणामों को ट्यून करने के लिए अतिरिक्त प्रयोगों की आवश्यकता होती है, इसलिए कुछ सामान्य सलाह आपके नेटवर्क में सबसे अच्छी सटीकता के लिए पहले वृद्धि के बिना ड्राइव करना होगा, फिर देखें कि क्या कुछ मामूली वृद्धि पैदावार में सुधार करती है। यदि ऐसा होता है, तो यह आगे के प्रयोग का वारंट कर सकता है।

किसी भी और सभी ट्यूनिंग प्रयोगों के लिए, आपको ओवर- और अंडर-फिटिंग व्यवहार में बदलाव के लिए नज़र रखने की आवश्यकता होगी। नेटवर्क आर्किटेक्चर को बदलना, प्रशिक्षण प्राप्त करना, या हाइपरपरमेटर्स को ड्रॉपआउट नियमितीकरण की अतिरिक्त ट्यूनिंग की आवश्यकता हो सकती है। ट्रेन / परीक्षण प्रदर्शन से आसानी से और अंडर-फिटिंग व्यवहार की आसानी से पता लगाने की क्षमता NNets के साथ काम करने में सबसे महत्वपूर्ण आधारभूत कौशल है, और यह अनुभव के साथ अधिक सहज हो जाता है।

यह वह मोमबत्ती है जिसके द्वारा आपके सभी प्रयासों का मार्गदर्शन किया जाएगा। मोमबत्ती केवल पथ को रोशन कर सकती है, लेकिन इसके बिना आप अंधेरे में चारों ओर ठोकर खाएंगे। यदि आपका नेटवर्क बुरी तरह से खत्म हो गया है या अंडर-फिटिंग है, जिसे नेटवर्क संरचना या हाइपरपरमेटर्स के यादृच्छिक क्रमांकन का प्रयास करने से पहले संबोधित किया जाना चाहिए।

इस जवाब में शामिल वेनिला प्रशिक्षण के साथ तुलनात्मक रूप से सरल आर्किटेक्चर छवि वर्गीकरण जैसी कठिन समस्याओं पर NNET आर्किटेक्चर के साथ काम करने की वास्तविकता को प्रदर्शित करते हैं: दृष्टिकोण के आधार पर एक "बहुत अच्छा" परिणाम प्राप्त करना जो अच्छी तरह से काम करने के लिए जाना जाता है, लेकिन मुश्किल नहीं है, लेकिन वृद्धिशील सुधार तेजी से महंगा है। प्रयोग के माध्यम से सर्वोत्तम प्रकाशित परिणामों को प्राप्त करना कई लोगों की क्षमताओं या समय की उपलब्धता से परे होने वाला है (हालांकि यह संभव है, पर्याप्त समय और प्रयास के साथ, अपने परिणामों को दोहराने के लिए प्रकाशित दृष्टिकोणों के कुकबुक व्यंजनों का पालन करने के लिए - लेकिन यह भी नहीं है मतलब तुच्छ)। "बहुत अच्छा" शुरुआती बिंदु से वृद्धिशील सुधार को बनाए रखना परीक्षण-और-त्रुटि की एक बहुत समय लेने वाली प्रक्रिया हो सकती है, और कई प्रयोगों से कोई महत्वपूर्ण सुधार नहीं होगा।

इसका अर्थ किसी को सीखने के प्रयास से वंचित करना नहीं है, बल्कि केवल यह स्पष्ट करना है कि ट्रिक्स के एननेट बैग में मास्टर (कभी विस्तार करने वाले) टूलसेट में महत्वपूर्ण निवेश की आवश्यकता है, और परीक्षण और त्रुटि के माध्यम से ड्राइविंग सुधार की आवश्यकता हो सकती है। समर्पित-जीपीयू प्रशिक्षण के दिनों या हफ्तों में प्रयोगों के दर्जनों (या सैकड़ों)।

समय, कौशल और संसाधनों (समर्पित GPU) को प्रदर्शन के बहुत उच्च स्तर तक नेटवर्क को प्रशिक्षित करने की आवश्यकता होती है, जो पूर्व-प्रशिक्षित नेटवर्क की लोकप्रियता का हिस्सा है।

— T3am5hark
स्रोत

आप तंत्रिका नेटवर्क आर्किटेक्चर में कोई पूलिंग परत नहीं रखते हैं? कि मापदंडों की असहनीय संख्या पैदा नहीं करता है?

— स्पांडी

पूलिंग - pfft! अहंकारी। यह एक सर्वांगीण दृष्टिकोण का उपयोग करता है जो पूलिंग के बजाय डिकमीशन के लिए स्ट्राइडिंग का उपयोग करता है - विवरण के लिए लिंक किए गए दस्तावेज़ देखें। संवेदी स्ट्राइडिंग को अलग-अलग साधनों द्वारा पूलिंग के समान "फ़नलिंग" प्रभाव मिल सकता है। यह कि वे दोनों ही काम करते हैं, यह दर्शाता है कि इस सामान के काम करने के संबंध में कोई ठोस सैद्धांतिक आधार नहीं है।

— T3am5hark

आपके इन-सैंपल और आउट-ऑफ-सैंपल लॉस और सटीकता मूल्यों को देखते हुए, आपका मॉडल वर्तमान में कमतर है, लेकिन यह एकतरफा सुधार कर रहा है। दूसरे शब्दों में, ऐसा लगता है कि अधिक युगों के लिए इसे चलाने से उच्च भविष्य कहनेवाला प्रदर्शन / कम एन्ट्रापी नुकसान होगा।

आप अत्यधिक नियमित (ड्रॉप-आउट लेयर्स) आर्किटेक्चर का उपयोग कर रहे हैं, जो खराब नहीं है। हालांकि, यह भी आश्चर्यजनक नहीं है कि प्रशिक्षण बिना किसी नियमितीकरण की तुलना में अधिक समय लेता है। ड्रॉप-आउट परतों के कारण, यह संभावना नहीं है कि आप (काफी) ओवरफिट करेंगे।

चीजें जो आप सीखने में तेजी लाने की कोशिश कर सकते हैं:

मैं। सीखने की दर को ट्विक करें: जैसे कि एक छोटे से शुरू करें, इसे बीच में बढ़ाएं, और अंत में इसे फिर से कम करें।

ii। बैटक्नोर्मालीज़ेशन जोड़ें : ऊपर दिए गए आर्किटेक्चर में, आप अपने दृढ़ ब्लॉक और घनी परतों में बैच- नॉरमल दोनों को शामिल कर सकते हैं। आमतौर पर, बैच-नॉर्मल लेयर को नॉनलाइनियर एक्टिवेशन के बाद जोड़ा जाता है लेकिन ड्रॉपआउट से पहले। मुझे यकीन नहीं है कि अधिकतम मानदंड कितनी अच्छी तरह से निभाते हैं। आपकी घनी परतों के लिए, मैं अधिकतम मानदंड के साथ / बिना बैच-मान + छोड़ने की कोशिश करूंगा। यदि आप बैच सामान्यीकरण लागू करते हैं, तो मुझे लगता है कि आपको मैक्समोर्म की आवश्यकता नहीं है।

iii। बैच-साइज़ बढ़ाएँ: मुझे यकीन नहीं है कि आपका बैच-साइज़ क्या है और क्या आपके पास GPU है। यदि आपके पास एक GPU है, तो आपको संभवतः अपने बैच-आकार को 32 के गुणकों में अधिकतम करने का प्रयास करना चाहिए।

अंत में, यह सुनिश्चित करने के लिए कि आपका डेटा 'सीखने योग्य' है / भ्रष्ट नहीं है (जैसे कि आपने अनिच्छा से इसे बदलने के लिए कोई परिवर्तन लागू नहीं किया है), मैं आपकी वास्तुकला से सभी नियमितीकरण को फेंक दूंगा, प्रशिक्षण चलाऊंगा और देखूंगा कि आप प्रशिक्षण सेट पर ओवरफिट कर सकते हैं । यदि आप प्रशिक्षण डेटा को सफलतापूर्वक सीख सकते हैं, तो बाकी एक सामान्यीकरण अभ्यास है। यदि आप बिना किसी नियमितीकरण के भी प्रशिक्षण डेटा से अधिक नहीं कर सकते हैं, तो सबसे अधिक संभावना है कि आपके मॉडल को अधिक क्षमता (गहरी और व्यापक वास्तुकला) की आवश्यकता है।

— Zhubarb
स्रोत

सलाह के लिए धन्यवाद! आप MaxNorm के बारे में थोड़ा हस्तक्षेप कर रहे थे। फिर भी, बैचनलाइज़ेशन लेयर्स (कृपया अपडेट देखें) और मैक्सनॉर्म सहित दोनों को हटाने / जोड़ने के बाद भी, सटीकता अभी भी कम है। कोई वृद्धि नहीं हो रही है। मेरे पास एक GPU है, और 64,128,256 और 512 बैचों में प्रशिक्षण की कोशिश की है, लेकिन बहुत कम अंतर देखा गया है। सीखने की दर के बारे में, मैं एडम ऑप्टिमाइज़र का उपयोग कर रहा हूं और सोचा कि इसे कम या ज्यादा छोड़ देना चाहिए? कभी-कभी मैंने 0.05, 0.001, 0.0005 पर LR की कोशिश की और देखा कि डिफ़ॉल्ट 0.001 अभी भी सबसे अच्छा लगता है। कोई विचार?

— user4779

इसके अलावा मैं ठीक ओवरफिट करने में सक्षम हूं। मैंने उन पत्रों में वास्तुकला को कॉपी करने की पूरी कोशिश की जो MNIST10 के साथ 80% ++ सटीकता प्राप्त करने में सक्षम प्रतीत होते हैं। जब मैं लंबी अवधि के लिए मॉडल प्रशिक्षण छोड़ता हूं तो लगता है कि नुकसान अब बढ़ जाता है (20 से अधिक युग या तो)।

— user4779

संशोधित टिप्पणी - मॉडल में बदलावों के बाद, ग्राफ़ अब संकेत देते हैं कि यह डेटा को ओवरफ़िट करने में महत्वपूर्ण है (~ 15 युगों के बाद सत्यापन त्रुटि के विचलन के आधार पर)

— T3am5hark

मैं वास्तव में यहां की पेशकश पर सलाह की उपयोगिता का विवाद करता हूं, खासकर नए चिकित्सकों के लिए। ये सभी चीजें हैं जो आप कर सकते हैं, निश्चित रूप से, लेकिन उन लोगों के लिए जो सीएनएन के लिए नए हैं और इन चीजों के बारे में कोई अंतर्ज्ञान या समझ नहीं है कि यह कैसे काम करता है, यह बहुत अधिक knobs और लीवर है जो बिना किसी प्रिस्क्रिप्शनल गाइडेंस के अंधा परीक्षण के अलावा। और त्रुटि, सकारात्मक परिणाम प्राप्त करने की संभावना नहीं है। बेहतर यह होगा कि पहले सरल आर्किटेक्चर के साथ शुरुआत की जाए जो कि न्यूनतम ट्विडलिंग के साथ अच्छा (सर्वोत्तम-प्रकाशित नहीं) प्रदर्शन करने में सक्षम हों, फिर वहां से सुधार के रास्ते तलाशने होंगे। मेरे दो सेंट।

— T3am5hark

आगे विस्तृत करने के लिए - सीखने की दरों के साथ मत खेलो, एडम का उपयोग करें। यह समय के 99.99% सीखने की दर को हाथ से हरा देता है। इसके अलावा - यह कथन कि "यह संभावना नहीं है कि आप कभी भी ओवरफिट करेंगे" सिर्फ सादा गलत है (जैसा कि अनुवर्ती ग्राफिक्स द्वारा संकेत दिया गया है जो अब महत्वपूर्ण ओवर-फिटिंग प्रदर्शित करता है), और पोस्टर के लिए यह मानने का कोई अच्छा कारण नहीं है कि ... किसी दिए गए आर्किटेक्चर के लिए आपको एक प्राथमिकता बताने के लिए कुछ भी नहीं है, क्या किसी दिए गए ड्रॉपआउट दर को ओवर-फिटिंग को रोकने के लिए पर्याप्त रूप से नियमित किया जाएगा।

— T3am5hark

मैंने आज इसे एक शॉट दिया और लगातार 75-80% सटीकता के साथ हिट करने में सक्षम था।

उपयोग किए गए मापदंडों की कुल संख्या थी: 183,242
आप शायद कुछ और परतों को जोड़कर बेहतर कर सकते हैं, लेकिन आपको ज़रूरत से ज़्यादा नहीं होना चाहिए। अधिक जटिल नेटवर्क हमेशा बेहतर परिणाम नहीं देते हैं।

सुझाव

मेरा सुझाव है कि आप अपनी वास्तुकला को सरल रखें। ओप्पम के रेजर का पालन करें , सरल बेहतर है।

अपने डेटा को स्केल करें
एक यादृच्छिक बीज का उपयोग न करें
एक उपयुक्त अनुकूलक का उपयोग करें; मैं आदिलता का इस्तेमाल करता था जैसा कि केरस से है।
CNN को दृढ़ होने की आवश्यकता नहीं है; इसे सरल रखें
डीपर स्किनियर नेटवर्क कभी-कभी व्यापक लोगों की तुलना में बेहतर काम करते हैं
नियमितीकरण का उपयोग करें (जैसे ड्रॉपआउट)

नीचे मेरा कोड है (केर का उपयोग करके)

# 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

— जॉन
स्रोत