python - एक प्रशिक्षित केरस मॉडल लोड करें और प्रशिक्षण जारी रखें




tensorflow neural-network (4)

मैं सोच रहा था कि क्या यह संभव है कि एक आंशिक रूप से प्रशिक्षित केरस मॉडल को बचाया जाए और फिर से मॉडल को लोड करने के बाद प्रशिक्षण जारी रखा जाए।

इसका कारण यह है कि मेरे पास भविष्य में अधिक प्रशिक्षण डेटा होगा और मैं पूरे मॉडल को फिर से नहीं लेना चाहता।

मैं जिन कार्यों का उपयोग कर रहा हूं वे हैं:

#Partly train model
model.fit(first_training, first_classes, batch_size=32, nb_epoch=20)

#Save partly trained model
model.save('partly_trained.h5')

#Load partly trained model
from keras.models import load_model
model = load_model('partly_trained.h5')

#Continue training
model.fit(second_training, second_classes, batch_size=32, nb_epoch=20)

संपादित 1: पूरी तरह से काम कर रहे उदाहरण को जोड़ा

10 युगों के बाद पहले डेटासेट के साथ अंतिम युग का नुकसान 0.0748 और सटीकता 0.9863 होगी।

मॉडल को सहेजने, हटाने और पुन: लोड करने के बाद दूसरे डेटासेट पर प्रशिक्षित मॉडल की हानि और सटीकता क्रमशः 0.1711 और 0.950 होगी।

क्या यह नए प्रशिक्षण डेटा या पूरी तरह से प्रशिक्षित मॉडल के कारण है?

"""
Model by: http://machinelearningmastery.com/
"""
# load (downloaded if needed) the MNIST dataset
import numpy
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense
from keras.utils import np_utils
from keras.models import load_model
numpy.random.seed(7)

def baseline_model():
    model = Sequential()
    model.add(Dense(num_pixels, input_dim=num_pixels, init='normal', activation='relu'))
    model.add(Dense(num_classes, init='normal', activation='softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    return model

if __name__ == '__main__':
    # load data
    (X_train, y_train), (X_test, y_test) = mnist.load_data()

    # flatten 28*28 images to a 784 vector for each image
    num_pixels = X_train.shape[1] * X_train.shape[2]
    X_train = X_train.reshape(X_train.shape[0], num_pixels).astype('float32')
    X_test = X_test.reshape(X_test.shape[0], num_pixels).astype('float32')
    # normalize inputs from 0-255 to 0-1
    X_train = X_train / 255
    X_test = X_test / 255
    # one hot encode outputs
    y_train = np_utils.to_categorical(y_train)
    y_test = np_utils.to_categorical(y_test)
    num_classes = y_test.shape[1]

    # build the model
    model = baseline_model()

    #Partly train model
    dataset1_x = X_train[:3000]
    dataset1_y = y_train[:3000]
    model.fit(dataset1_x, dataset1_y, nb_epoch=10, batch_size=200, verbose=2)

    # Final evaluation of the model
    scores = model.evaluate(X_test, y_test, verbose=0)
    print("Baseline Error: %.2f%%" % (100-scores[1]*100))

    #Save partly trained model
    model.save('partly_trained.h5')
    del model

    #Reload model
    model = load_model('partly_trained.h5')

    #Continue training
    dataset2_x = X_train[3000:]
    dataset2_y = y_train[3000:]
    model.fit(dataset2_x, dataset2_y, nb_epoch=10, batch_size=200, verbose=2)
    scores = model.evaluate(X_test, y_test, verbose=0)
    print("Baseline Error: %.2f%%" % (100-scores[1]*100))

आप कॉन्सेप्ट ड्रिफ्ट को भी मार सकते हैं, देखिए कि क्या आप एक मॉडल को रिटेन कर सकते हैं जब नई टिप्पणियां उपलब्ध हैं । वहाँ भी भयावह भूल की अवधारणा है जिस पर अकादमिक पत्रों का एक समूह चर्चा करता है। यहाँ भयावह भूल के MNIST अनुभवजन्य जांच के साथ एक है


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

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


वास्तव में - model.save आपके मामले में प्रशिक्षण को फिर से शुरू करने के लिए सभी जानकारी की आवश्यकता को बचाता है। केवल एक चीज जो मॉडल को फिर से लोड करने से खराब हो सकती है वह है आपका आशावादी राज्य। यह जांचने के लिए - मॉडल को save और पुनः लोड करने का प्रयास करें और इसे प्रशिक्षण डेटा पर प्रशिक्षित करें।


समस्या यह हो सकती है कि आप अपने ऑप्टिमाइज़र के लिए एक अलग ऑप्टिमाइज़र - या अलग-अलग तर्क का उपयोग करें। मैं सिर्फ एक कस्टम pretrained मॉडल के साथ एक ही मुद्दा था, का उपयोग कर

reduce_lr = ReduceLROnPlateau(monitor='loss', factor=lr_reduction_factor,
                              patience=patience, min_lr=min_lr, verbose=1)

प्रीट्रेन मॉडल के लिए, जिसमें मूल सीखने की दर 0.0003 से शुरू होती है और पूर्व-प्रशिक्षण के दौरान इसे घटाकर min_learning दर कर दिया जाता है, जो 0.000003 है

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