समय श्रृंखला - LSTM मॉडल

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

LSTM आवर्तक तंत्रिका नेटवर्क का एक वर्ग है। तो इससे पहले कि हम LSTM पर जा सकें, तंत्रिका नेटवर्क और आवर्तक तंत्रिका नेटवर्क को समझना आवश्यक है।

तंत्रिका जाल

एक कृत्रिम तंत्रिका नेटवर्क जुड़ा न्यूरॉन्स की एक स्तरित संरचना है, जो जैविक तंत्रिका नेटवर्क से प्रेरित है। यह एक एल्गोरिथ्म नहीं है, लेकिन विभिन्न एल्गोरिदम का संयोजन है जो हमें डेटा पर जटिल संचालन करने की अनुमति देता है।

आवर्तक तंत्रिका नेटवर्क

यह तंत्रिका नेटवर्क का एक वर्ग है जो अस्थायी डेटा से निपटने के लिए अनुरूप है। आरएनएन के न्यूरॉन्स में एक सेल राज्य / मेमोरी होती है, और इनपुट को इस आंतरिक स्थिति के अनुसार संसाधित किया जाता है, जिसे तंत्रिका नेटवर्क में छोरों की मदद से प्राप्त किया जाता है। RNN में 'tanh' परतों के आवर्ती मॉड्यूल (ओं) हैं जो उन्हें जानकारी बनाए रखने की अनुमति देते हैं। हालांकि, लंबे समय तक नहीं, यही वजह है कि हमें LSTM मॉडल की आवश्यकता है।

LSTM

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

ऊपर की तस्वीर पीले बक्से में चार तंत्रिका नेटवर्क परतों को दर्शाती है, हरे रंग के हलकों में बिंदु वार ऑपरेटरों, पीले हलकों में इनपुट और नीले घेरे में सेल राज्य। एक LSTM मॉड्यूल में एक सेल राज्य और तीन द्वार होते हैं जो उन्हें चुनिंदा इकाइयों में से प्रत्येक के बारे में जानकारी जानने, अनजान या बनाए रखने की शक्ति प्रदान करते हैं। LSTM में कोशिका स्थिति केवल कुछ रैखिक अंतःक्रियाओं की अनुमति के बिना सूचनाओं को इकाइयों के माध्यम से प्रवाहित करने में मदद करती है। प्रत्येक इकाई में एक इनपुट, आउटपुट और एक भूल गेट है जो सेल राज्य में जानकारी जोड़ या हटा सकता है। भूल गेट यह तय करता है कि पिछली सेल स्थिति से कौन सी जानकारी को भूल जाना चाहिए जिसके लिए वह सिग्माइड फ़ंक्शन का उपयोग करता है। इनपुट गेट क्रमशः state सिग्मॉइड ’और the टैन्ह’ के एक बिंदु-वार गुणन ऑपरेशन का उपयोग करके वर्तमान सेल स्थिति में सूचना प्रवाह को नियंत्रित करता है। अंत में, आउटपुट गेट तय करता है कि कौन सी जानकारी अगले छिपे हुए राज्य में पारित की जानी चाहिए

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

पहले हमें एक सीधी रेखा को दर्शाते हुए डेटासेट बनाते हैं।

[402] में:

x = numpy.arange (1,500,1)
y = 0.4 * x + 30
plt.plot(x,y)

आउट [402]:

[<matplotlib.lines.Line2D at 0x1eab9d3ee10>]

[403] में:

trainx, testx = x[0:int(0.8*(len(x)))], x[int(0.8*(len(x))):]
trainy, testy = y[0:int(0.8*(len(y)))], y[int(0.8*(len(y))):]
train = numpy.array(list(zip(trainx,trainy)))
test = numpy.array(list(zip(trainx,trainy)))

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

तो एक समय श्रृंखला इस तरह से -

time variable_x
t1  x1
t2  x2
 :   :
 :   :
T   xT

जब लुक-बैक पीरियड 1 होता है, तो इसे -

x1   x2
x2   x3
 :    :
 :    :
xT-1 xT

[४०४] में:

def create_dataset(n_X, look_back):
   dataX, dataY = [], []
   for i in range(len(n_X)-look_back):
      a = n_X[i:(i+look_back), ]
      dataX.append(a)
      dataY.append(n_X[i + look_back, ])
   return numpy.array(dataX), numpy.array(dataY)

[405] में:

look_back = 1
trainx,trainy = create_dataset(train, look_back)
testx,testy = create_dataset(test, look_back)

trainx = numpy.reshape(trainx, (trainx.shape[0], 1, 2))
testx = numpy.reshape(testx, (testx.shape[0], 1, 2))

अब हम अपने मॉडल को प्रशिक्षित करेंगे।

प्रशिक्षण डेटा के छोटे बैचों को नेटवर्क में दिखाया जाता है, जब संपूर्ण प्रशिक्षण डेटा को बैचों में मॉडल को दिखाया जाता है और त्रुटि की गणना की जाती है तो एक रन को युग कहा जाता है। जिस समय त्रुटि कम हो रही है, उस युग को चलाया जाना चाहिए।

[] में:

from keras.models import Sequential
from keras.layers import LSTM, Dense

model = Sequential()
model.add(LSTM(256, return_sequences = True, input_shape = (trainx.shape[1], 2)))
model.add(LSTM(128,input_shape = (trainx.shape[1], 2)))
model.add(Dense(2))
model.compile(loss = 'mean_squared_error', optimizer = 'adam')
model.fit(trainx, trainy, epochs = 2000, batch_size = 10, verbose = 2, shuffle = False)
model.save_weights('LSTMBasic1.h5')

[407] में:

model.load_weights('LSTMBasic1.h5')
predict = model.predict(testx)

अब देखते हैं कि हमारी भविष्यवाणियां क्या दिखती हैं।

[408] में:

plt.plot(testx.reshape(398,2)[:,0:1], testx.reshape(398,2)[:,1:2])
plt.plot(predict[:,0:1], predict[:,1:2])

आउट [408]:

[<matplotlib.lines.Line2D at 0x1eac792f048>]

अब, हमें एक समान शैली में साइन या कोसाइन लहर का प्रयास करना चाहिए। आप नीचे दिए गए कोड को चला सकते हैं और परिणाम देखने के लिए मॉडल मापदंडों के साथ खेल सकते हैं।

[409] में:

x = numpy.arange (1,500,1)
y = numpy.sin(x)
plt.plot(x,y)

आउट [409]:

[<matplotlib.lines.Line2D at 0x1eac7a0b3c8>]

[410] में:

trainx, testx = x[0:int(0.8*(len(x)))], x[int(0.8*(len(x))):]
trainy, testy = y[0:int(0.8*(len(y)))], y[int(0.8*(len(y))):]
train = numpy.array(list(zip(trainx,trainy)))
test = numpy.array(list(zip(trainx,trainy)))

[411] में:

look_back = 1
trainx,trainy = create_dataset(train, look_back)
testx,testy = create_dataset(test, look_back)
trainx = numpy.reshape(trainx, (trainx.shape[0], 1, 2))
testx = numpy.reshape(testx, (testx.shape[0], 1, 2))

[] में:

model = Sequential()
model.add(LSTM(512, return_sequences = True, input_shape = (trainx.shape[1], 2)))
model.add(LSTM(256,input_shape = (trainx.shape[1], 2)))
model.add(Dense(2))
model.compile(loss = 'mean_squared_error', optimizer = 'adam')
model.fit(trainx, trainy, epochs = 2000, batch_size = 10, verbose = 2, shuffle = False)
model.save_weights('LSTMBasic2.h5')

[413] में:

model.load_weights('LSTMBasic2.h5')
predict = model.predict(testx)

[४१५] में:

plt.plot(trainx.reshape(398,2)[:,0:1], trainx.reshape(398,2)[:,1:2])
plt.plot(predict[:,0:1], predict[:,1:2])

बाहर [415]:

[<matplotlib.lines.Line2D at 0x1eac7a1f550>]

अब आप किसी भी डेटासेट पर जाने के लिए तैयार हैं।