python - केर एलएसटीएम को समझना




deep-learning keras (2)

जब आपके पास RNN की अंतिम परत में रिटर्न_ परिणाम हैं तो आप TimeDistributed का उपयोग करने के बजाय एक साधारण घने परत का उपयोग नहीं कर सकते हैं।

यहां कोड का एक उदाहरण है जो दूसरों की मदद कर सकता है।

शब्द = keras.layers.Input (batch_shape = (कोई नहीं, self.maxSequenceLength), नाम = "इनपुट")

    # Build a matrix of size vocabularySize x EmbeddingDimension 
    # where each row corresponds to a "word embedding" vector.
    # This layer will convert replace each word-id with a word-vector of size Embedding Dimension.
    embeddings = keras.layers.embeddings.Embedding(self.vocabularySize, self.EmbeddingDimension,
        name = "embeddings")(words)
    # Pass the word-vectors to the LSTM layer.
    # We are setting the hidden-state size to 512.
    # The output will be batchSize x maxSequenceLength x hiddenStateSize
    hiddenStates = keras.layers.GRU(512, return_sequences = True, 
                                        input_shape=(self.maxSequenceLength,
                                        self.EmbeddingDimension),
                                        name = "rnn")(embeddings)
    hiddenStates2 = keras.layers.GRU(128, return_sequences = True, 
                                        input_shape=(self.maxSequenceLength, self.EmbeddingDimension),
                                        name = "rnn2")(hiddenStates)

    denseOutput = TimeDistributed(keras.layers.Dense(self.vocabularySize), 
        name = "linear")(hiddenStates2)
    predictions = TimeDistributed(keras.layers.Activation("softmax"), 
        name = "softmax")(denseOutput)  

    # Build the computational graph by specifying the input, and output of the network.
    model = keras.models.Model(input = words, output = predictions)
    # model.compile(loss='kullback_leibler_divergence', \
    model.compile(loss='sparse_categorical_crossentropy', \
        optimizer = keras.optimizers.Adam(lr=0.009, \
            beta_1=0.9,\
            beta_2=0.999, \
            epsilon=None, \
            decay=0.01, \
            amsgrad=False))

मैं LSTM के बारे में अपनी समझ को समेटने की कोशिश कर रहा हूं और यहां इस पोस्ट में बताया कि क्रिस्टोफर ओलाह ने केरस में लागू किया। मैं केरस ट्यूटोरियल के लिए जेसन ब्राउनली द्वारा लिखे गए ब्लॉग का अनुसरण कर रहा हूं। मैं मुख्य रूप से उलझन में हूँ,

  1. [samples, time steps, features] और
  2. स्टेटफुल LSTMs

नीचे दिए गए कोड के संदर्भ में उपरोक्त दो प्रश्नों पर ध्यान केंद्रित करें:

# reshape into X=t and Y=t+1
look_back = 3
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)

# reshape input to be [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], look_back, 1))
testX = numpy.reshape(testX, (testX.shape[0], look_back, 1))
########################
# The IMPORTANT BIT
##########################
# create and fit the LSTM network
batch_size = 1
model = Sequential()
model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
for i in range(100):
    model.fit(trainX, trainY, nb_epoch=1, batch_size=batch_size, verbose=2, shuffle=False)
    model.reset_states()

नोट: create_dataset लंबाई N का अनुक्रम लेता है और एक N-look_back सरणी देता है, जिसमें से प्रत्येक तत्व एक look_back लंबाई अनुक्रम है।

टाइम स्टेप्स और फीचर्स क्या है?

जैसा कि देखा जा सकता है कि TrainX एक 3-D सरणी है जिसमें Time_steps और फ़ीचर क्रमशः दो अंतिम आयाम हैं (इस विशेष कोड में 3 और 1)। नीचे की छवि के संबंध में, क्या इसका मतलब है कि हम many to one मामले पर विचार कर रहे हैं, जहां गुलाबी बक्से की संख्या 3 है? या इसका शाब्दिक अर्थ है कि चेन की लंबाई 3 है (यानी केवल 3 ग्रीन बॉक्स माना जाता है)।

जब हम मल्टीवेरेट श्रृंखला पर विचार करते हैं तो क्या विशेषताएं तर्क प्रासंगिक हो जाती हैं? उदाहरण के लिए दो वित्तीय शेयरों को एक साथ मॉडलिंग करना?

स्टेटफुल LSTMs

क्या स्टेटफुल LSTM का मतलब है कि हम बैच के रनों के बीच सेल मेमोरी वैल्यू को बचाते हैं? यदि यह मामला है, तो batch_size एक है, और प्रशिक्षण के चलने के बीच मेमोरी रीसेट हो जाती है, तो यह कहने का क्या मतलब था कि यह स्टेटफुल था। मैं अनुमान लगा रहा हूं कि यह इस तथ्य से संबंधित है कि प्रशिक्षण डेटा में फेरबदल नहीं किया जाता है, लेकिन मुझे यकीन नहीं है कि कैसे।

कोई विचार? छवि संदर्भ: http://karpathy.github.io/2015/05/21/rnn-effectiveness/

1 संपादित करें:

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

2 संपादित करें:

उन लोगों के लिए, जिन्होंने उडेसिटी के गहन शिक्षण पाठ्यक्रम को किया है और अभी भी time_step तर्क के बारे में उलझन में हैं, निम्न चर्चा देखें: https://discussions.udacity.com/t/rnn-lstm-use-implementation/163169

अपडेट करें:

यह model.add(TimeDistributed(Dense(vocab_len))) से पता चलता है कि मैं क्या देख रहा था। यहाँ एक उदाहरण है: https://github.com/sachinruk/ShakespeareBot

Update2:

मैंने यहाँ LSTM की अपनी अधिकांश समझ को संक्षेप में दिया है: https://www.youtube.com/watch?v=ywinX5wgdEU


सबसे पहले, आप शुरू करने के लिए महान ट्यूटोरियल ( 1 , http://karpathy.github.io/2015/05/21/rnn-effectiveness/ ) चुनते हैं।

टाइम-स्टेप का क्या अर्थ है : Time-steps==3 में X.shape (डेटा आकृति का वर्णन) का अर्थ है कि तीन गुलाबी बक्से हैं। चूंकि केरस में प्रत्येक चरण में एक इनपुट की आवश्यकता होती है, इसलिए हरे बॉक्स की संख्या आमतौर पर लाल बॉक्स की संख्या के बराबर होनी चाहिए। जब तक आप संरचना को हैक नहीं करते।

कई बनाम एक से कई : केरस में, जब आपका प्रारंभिक LSTM या GRU या SimpleRNN होता है, तो एक return_sequences पैरामीटर होता है। जब return_sequences False (डिफ़ॉल्ट रूप से), तो यह तस्वीर में दिखाए गए अनुसार कई है । इसका रिटर्न शेप है (batch_size, hidden_unit_length) , जो अंतिम अवस्था का प्रतिनिधित्व करता है। जब return_sequences True , तो यह कई से कई है । इसका रिटर्न शेप है (batch_size, time_step, hidden_unit_length)

क्या सुविधाएँ तर्क प्रासंगिक हो जाती हैं : फ़ीचर तर्क का अर्थ है "आपका लाल बॉक्स कितना बड़ा है" या प्रत्येक चरण में इनपुट आयाम क्या है। यदि आप 8 प्रकार की बाज़ार जानकारी से कहना चाहते हैं, तो आप अपने डेटा को feature==8 साथ उत्पन्न कर सकते हैं।

स्टेटफुल : आप सोर्स कोड देख सकते हैं। राज्य को प्रारंभ करते समय, यदि राज्य stateful==True , तो अंतिम प्रशिक्षण से राज्य को प्रारंभिक राज्य के रूप में उपयोग किया जाएगा, अन्यथा यह एक नया राज्य उत्पन्न करेगा। मैंने अभी तक stateful चालू नहीं किया है। हालाँकि, मैं इससे असहमत हूं कि batch_size केवल 1 हो सकता है जब stateful==True

वर्तमान में, आप एकत्रित डेटा के साथ अपना डेटा जनरेट करते हैं। छवि आपकी स्टॉक जानकारी स्ट्रीम के रूप में आ रही है, सभी अनुक्रमिक एकत्र करने के लिए एक दिन की प्रतीक्षा करने के बजाय, आप नेटवर्क के साथ प्रशिक्षण / भविष्यवाणी करते समय ऑनलाइन इनपुट डेटा उत्पन्न करना चाहेंगे। यदि आपके पास समान नेटवर्क साझा करने वाले 400 स्टॉक हैं, तो आप batch_size==400 सेट कर सकते हैं।





lstm