RNN (पुनरावर्ती तंत्रिका नेटवर्क) ट्यूटोरियल: TensorFlow उदाहरण

हमें पुनरावर्ती तंत्रिका नेटवर्क (आरएनएन) की आवश्यकता क्यों है?

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

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

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

सौभाग्य से, त्रुटि पहले से कम है, फिर भी बहुत छोटी नहीं है। अनुकूलन चरण तब तक दोहराया जाता है जब तक कि त्रुटि न्यूनतम न हो जाए, यानी, कोई और जानकारी नहीं निकाली जा सकती।

इस प्रकार के मॉडल के साथ समस्या यह है कि इसमें कोई मेमोरी नहीं होती। इसका मतलब है कि इनपुट और आउटपुट स्वतंत्र हैं। दूसरे शब्दों में, मॉडल को इस बात की परवाह नहीं है कि पहले क्या हुआ था। जब आपको समय श्रृंखला या वाक्यों की भविष्यवाणी करने की आवश्यकता होती है तो यह कुछ सवाल उठाता है क्योंकि नेटवर्क को ऐतिहासिक डेटा या पिछले शब्दों के बारे में जानकारी की आवश्यकता होती है।

इस समस्या से निपटने के लिए, एक नए प्रकार की वास्तुकला विकसित की गई है: आवर्तक तंत्रिका नेटवर्क (आरएनएन)

आवर्तक तंत्रिका नेटवर्क (आरएनएन) क्या है?

A आवर्तक तंत्रिका नेटवर्क (RNN) का एक वर्ग है कृत्रिम तंत्रिका नेटवर्क जिसमें विभिन्न नोड्स के बीच कनेक्शन एक निर्देशित ग्राफ बनाता है जो एक अस्थायी गतिशील व्यवहार देता है। यह फीडफॉरवर्ड नेटवर्क से प्राप्त अनुक्रमिक डेटा को मॉडल करने में मदद करता है। यह पूर्वानुमानित परिणाम देने के लिए मानव मस्तिष्क के समान काम करता है।

आवर्ती तंत्रिका नेटवर्क पारंपरिक तंत्रिका नेटवर्क के समान ही दिखता है, सिवाय इसके कि इसमें न्यूरॉन्स में एक मेमोरी-स्टेट जोड़ दी जाती है। मेमोरी को शामिल करने की गणना सरल है।

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

उदाहरण के लिए, नीचे दी गई तस्वीर में, आप देख सकते हैं कि नेटवर्क एक न्यूरॉन से बना है। नेटवर्क इनपुट और वज़न के बीच मैट्रिसेस गुणन की गणना करता है और सक्रियण फ़ंक्शन के साथ गैर-रैखिकता जोड़ता है। यह t-1 पर आउटपुट बन जाता है। यह आउटपुट दूसरे मैट्रिक्स गुणन का इनपुट है।

नीचे, हम चरण और आउटपुट के आकार को समझने के लिए TensorFlow में एक सरल RNN को कोड करते हैं।

नेटवर्क निम्नलिखित से बना है:

चार इनपुट
छह न्यूरॉन्स
2-समय चरण

नेटवर्क नीचे दिए गए चित्र के अनुसार आगे बढ़ेगा।

नेटवर्क को 'पुनरावर्ती' कहा जाता है क्योंकि यह प्रत्येक सक्रिय वर्ग में एक ही ऑपरेशन करता है। नेटवर्क ने सक्रियण फ़ंक्शन का उपयोग करने से पहले इनपुट और पिछले आउटपुट के भार की गणना की।

import numpy as np
import tensorflow as tf
n_inputs = 4
n_neurons = 6
n_timesteps = 2
The data is a sequence of a number from 0 to 9 and divided into three batches of data.
## Data 
X_batch = np.array([
        [[0, 1, 2, 5], [9, 8, 7, 4]], # Batch 1
        [[3, 4, 5, 2], [0, 0, 0, 0]], # Batch 2
        [[6, 7, 8, 5], [6, 5, 4, 2]], # Batch 3
    ])

हम डेटा, पुनरावर्ती चरण और आउटपुट के लिए प्लेसहोल्डर के साथ नेटवर्क का निर्माण कर सकते हैं।

डेटा के लिए प्लेसहोल्डर परिभाषित करें

X = tf.placeholder(tf.float32, [None, n_timesteps, n_inputs])

यहाँ:

कोई नहीं: अज्ञात और बैच का आकार लेगा
n_timesteps: नेटवर्क द्वारा न्यूरॉन को आउटपुट वापस भेजने की संख्या
n_inputs: प्रति बैच इनपुट की संख्या

आवर्तक नेटवर्क को परिभाषित करें

जैसा कि ऊपर चित्र में बताया गया है, नेटवर्क 6 न्यूरॉन्स से बना है। नेटवर्क दो डॉट उत्पाद की गणना करेगा:

भार के पहले सेट के साथ इनपुट डेटा (अर्थात, 6: न्यूरॉन्स की संख्या के बराबर)
भार के दूसरे सेट के साथ पिछला आउटपुट (अर्थात, 6: आउटपुट की संख्या के अनुरूप)

ध्यान दें कि, पहले फीडफॉरवर्ड के दौरान, पिछले आउटपुट के मान शून्य के बराबर होते हैं क्योंकि हमारे पास कोई मान उपलब्ध नहीं होता है।

RNN बनाने के लिए ऑब्जेक्ट tf.contrib.rnn.BasicRNNCell है, जिसमें इनपुट की संख्या निर्धारित करने के लिए तर्क num_units है

basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons)

अब जब नेटवर्क परिभाषित हो गया है, तो आप आउटपुट और स्थिति की गणना कर सकते हैं

outputs, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)

यह ऑब्जेक्ट मैट्रिसेस को उचित संख्या में गुणा करने के लिए आंतरिक लूप का उपयोग करता है।

ध्यान दें कि आवर्ती न्यूरॉन पिछले समय चरणों के सभी इनपुट का एक फ़ंक्शन है। इस तरह से नेटवर्क अपनी मेमोरी बनाता है। पिछले समय की जानकारी भविष्य के समय में फैल सकती है। यह आवर्ती तंत्रिका नेटवर्क का जादू है

## Define the shape of the tensor
X = tf.placeholder(tf.float32, [None, n_timesteps, n_inputs])
## Define the network
basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons)
outputs, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)
init = tf.global_variables_initializer()
init = tf.global_variables_initializer()
with tf.Session() as sess:
    init.run()
    outputs_val = outputs.eval(feed_dict={X: X_batch})
print(states.eval(feed_dict={X: X_batch}))
[[ 0.38941205 -0.9980438   0.99750966  0.7892596   0.9978241   0.9999997 ]
 [ 0.61096436  0.7255889   0.82977575 -0.88226104  0.29261455 -0.15597084]
 [ 0.62091285 -0.87023467  0.99729395 -0.58261937  0.9811445   0.99969864]]

स्पष्टीकरण के लिए, आप पिछली स्थिति के मान प्रिंट करते हैं। ऊपर प्रिंट किया गया आउटपुट पिछली स्थिति से आउटपुट दिखाता है। अब सभी आउटपुट प्रिंट करें, आप देख सकते हैं कि स्थितियाँ प्रत्येक बैच का पिछला आउटपुट हैं। यानी, पिछले आउटपुट में पूरे अनुक्रम के बारे में जानकारी होती है।

print(outputs_val)    
print(outputs_val.shape)    
[[[-0.75934666 -0.99537754  0.9735819  -0.9722234  -0.14234993
   -0.9984044 ]
  [ 0.99975264 -0.9983206   0.9999993  -1.         -0.9997506
   -1.        ]]

 [[ 0.97486496 -0.98773265  0.9969686  -0.99950117 -0.7092863
   -0.99998885]
  [ 0.9326837   0.2673438   0.2808514  -0.7535883  -0.43337247
    0.5700631 ]]

 [[ 0.99628735 -0.9998728   0.99999213 -0.99999976 -0.9884324
   -1.        ]
  [ 0.99962527 -0.9467421   0.9997403  -0.99999714 -0.99929446
   -0.9999795 ]]]
(3, 2, 6)

आउटपुट का आकार (3, 2, 6) है:

3: बैचों की संख्या
2: टाइमस्टेप की संख्या
6: न्यूरॉन की संख्या

आवर्ती तंत्रिका नेटवर्क का अनुकूलन पारंपरिक तंत्रिका नेटवर्क के समान है। आप इस आवर्ती तंत्रिका नेटवर्क ट्यूटोरियल के अगले भाग में कोड अनुकूलन के बारे में अधिक विस्तार से देखेंगे।

आरएनएन के अनुप्रयोग

RNN के कई उपयोग हैं, खासकर जब भविष्य की भविष्यवाणी करने की बात आती है। वित्तीय उद्योग में, RNN स्टॉक की कीमतों या स्टॉक मार्केट की दिशा (यानी, सकारात्मक या नकारात्मक) के संकेत की भविष्यवाणी करने में मददगार हो सकता है।

आरएनएन स्वचालित कार के लिए उपयोगी है, क्योंकि यह वाहन के प्रक्षेप पथ का पूर्वानुमान लगाकर कार दुर्घटना से बच सकता है।

RNN का व्यापक रूप से टेक्स्ट विश्लेषण, छवि कैप्शनिंग, भावना विश्लेषण और मशीन अनुवाद में उपयोग किया जाता है। उदाहरण के लिए, कोई व्यक्ति मूवी देखने के बाद दर्शक द्वारा महसूस की गई भावना को समझने के लिए मूवी समीक्षा का उपयोग कर सकता है। इस कार्य को स्वचालित करना बहुत उपयोगी है जब मूवी कंपनी के पास समीक्षाओं की समीक्षा, लेबलिंग, समेकन और विश्लेषण करने के लिए पर्याप्त समय नहीं होता है। मशीन उच्च स्तर की सटीकता के साथ काम कर सकती है।

आरएनएन की सीमाएँ

सिद्धांत रूप में, RNN को समय तक जानकारी ले जाना चाहिए। हालाँकि, जब समय चरण बहुत लंबा होता है, तो यह सारी जानकारी प्रसारित करना काफी चुनौतीपूर्ण होता है। जब किसी नेटवर्क में बहुत अधिक गहरी परतें होती हैं, तो यह अप्रशिक्षित हो जाता है। इस समस्या को कहा जाता है: लुप्त होती क्रमिक समस्यायदि आपको याद हो, तो न्यूरल नेटवर्क ग्रेडिएंट डिसेंट एल्गोरिदम का उपयोग करके वज़न को अपडेट करता है। जब नेटवर्क निचली परतों तक आगे बढ़ता है तो ग्रेडिएंट छोटे होते जाते हैं।

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

सुधार एलएसटीएम

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

LSTM आर्किटेक्चर TensorFlow, tf.contrib.rnn.LSTMCell में उपलब्ध है। LSTM ट्यूटोरियल के दायरे से बाहर है। आप आधिकारिक वेबसाइट देख सकते हैं दस्तावेज़ीकरण अधिक जानकारी के लिए

समय श्रृंखला में आरएनएन

इस TensorFlow RNN ट्यूटोरियल में, आप टाइम सीरीज़ डेटा के साथ RNN का उपयोग करेंगे। टाइम सीरीज़ पिछले समय पर निर्भर होती हैं, जिसका अर्थ है कि पिछले मूल्यों में प्रासंगिक जानकारी शामिल होती है जिससे नेटवर्क सीख सकता है। टाइम सीरीज़ भविष्यवाणी के पीछे का विचार किसी सीरीज़ के भविष्य के मूल्य का अनुमान लगाना है, मान लीजिए, स्टॉक मूल्य, तापमान, जीडीपी इत्यादि।

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

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

# To plot pretty figures
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
import pandas as pd
def create_ts(start = '2001', n = 201, freq = 'M'):
    rng = pd.date_range(start=start, periods=n, freq=freq)
    ts = pd.Series(np.random.uniform(-18, 18, size=len(rng)), rng).cumsum()
    return ts
ts= create_ts(start = '2001', n = 192, freq = 'M')
ts.tail(5)

उत्पादन

2016-08-31    -93.459631
2016-09-30    -95.264791
2016-10-31    -95.551935
2016-11-30   -105.879611
2016-12-31   -123.729319
Freq: M, dtype: float64

ts = create_ts(start = '2001', n = 222)

# Left
plt.figure(figsize=(11,4))
plt.subplot(121)
plt.plot(ts.index, ts)
plt.plot(ts.index[90:100], ts[90:100], "b-", linewidth=3, label="A training instance")
plt.title("A time series (generated)", fontsize=14)

# Right
plt.subplot(122)
plt.title("A training instance", fontsize=14)
plt.plot(ts.index[90:100], ts[90:100], "b-", markersize=8, label="instance")
plt.plot(ts.index[91:101], ts[91:101], "bo", markersize=10, label="target", markerfacecolor='red')
plt.legend(loc="upper left")
plt.xlabel("Time")

plt.show()

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

दोनों सदिशों की लंबाई समान है। आप इसे ऊपर दिए गए ग्राफ के दाहिने हिस्से में देख सकते हैं। रेखा X इनपुट के दस मानों को दर्शाती है, जबकि लाल बिंदु लेबल Y के दस मान हैं। ध्यान दें कि, लेबल X से एक अवधि आगे शुरू होता है और एक अवधि बाद खत्म होता है।

TensorFlow में समय श्रृंखला की भविष्यवाणी करने के लिए RNN बनाएँ

अब इस RNN प्रशिक्षण में, ऊपर दी गई श्रृंखला की भविष्यवाणी करने के लिए अपना पहला RNN बनाने का समय आ गया है। आपको मॉडल के लिए कुछ हाइपरपैरामीटर (मॉडल के पैरामीटर, यानी न्यूरॉन्स की संख्या, आदि) निर्दिष्ट करने की आवश्यकता है:

इनपुट की संख्या: 1
समय चरण (समय श्रृंखला में विंडो): 10
न्यूरॉन्स की संख्या: 120
आउटपुट की संख्या: 1

आपका नेटवर्क 10 दिनों के अनुक्रम से सीखेगा और इसमें 120 पुनरावर्ती न्यूरॉन्स होंगे। आप मॉडल को एक इनपुट, यानी एक दिन के साथ फीड करते हैं। मॉडल में सुधार हुआ है या नहीं यह देखने के लिए मूल्यों को बदलने में संकोच न करें।

मॉडल बनाने से पहले, आपको डेटासेट को ट्रेन सेट और टेस्ट सेट में विभाजित करना होगा। पूरे डेटासेट में 222 डेटा पॉइंट हैं; आप मॉडल को प्रशिक्षित करने के लिए पहले 201 पॉइंट का उपयोग करेंगे और अपने मॉडल का परीक्षण करने के लिए अंतिम 21 पॉइंट का उपयोग करेंगे।

ट्रेन और टेस्ट सेट को परिभाषित करने के बाद, आपको बैचों वाले ऑब्जेक्ट को बनाने की आवश्यकता है। इस बैच में, आपके पास X मान और Y मान हैं। याद रखें कि X मान एक अवधि से पिछड़े हुए हैं। इसलिए, आप पहले 200 अवलोकनों का उपयोग करते हैं और समय चरण 10 के बराबर होता है। X_batches ऑब्जेक्ट में 20*10 आकार के 1 बैच होने चाहिए। y_batches का आकार X_batches ऑब्जेक्ट के समान है, लेकिन एक अवधि आगे है।

चरण 1) ट्रेन बनाएं और परीक्षण करें

सबसे पहले, आप श्रृंखला को एक में परिवर्तित करते हैं numpy array; फिर आप विंडोज़ (यानी, नेटवर्क द्वारा सीखे जाने वाले समय की संख्या), इनपुट, आउटपुट की संख्या और ट्रेन सेट के आकार को परिभाषित करते हैं जैसा कि नीचे TensorFlow RNN उदाहरण में दिखाया गया है।

series = np.array(ts)
n_windows = 20   
n_input =  1
n_output = 1
size_train = 201

इसके बाद, आप सारणी को दो डेटासेट में विभाजित कर सकते हैं।

## Split data
train = series[:size_train]
test = series[size_train:]
print(train.shape, test.shape)
(201,) (21,)

चरण 2) X_batches और y_batches लौटाने के लिए फ़ंक्शन बनाएँ

इसे आसान बनाने के लिए, आप एक फ़ंक्शन बना सकते हैं जो दो अलग-अलग सरणियाँ लौटाता है, एक X_batches के लिए और एक y_batches के लिए।

आइए बैचों के निर्माण के लिए एक RNN TensorFlow फ़ंक्शन लिखें।

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

मुश्किल हिस्सा डेटा बिंदुओं को सही ढंग से चुनना है। X डेटा बिंदुओं के लिए, आप t = 1 से t = 200 तक के अवलोकन चुनते हैं, जबकि Y डेटा बिंदु के लिए, आप t = 2 से 201 तक के अवलोकन लौटाते हैं। एक बार जब आपके पास सही डेटा बिंदु होते हैं, तो श्रृंखला को फिर से आकार देना सीधा होता है।

बैच के साथ ऑब्जेक्ट बनाने के लिए, आपको डेटासेट को बराबर लंबाई के दस बैचों (यानी, 20) में विभाजित करना होगा। आप रीशेप विधि का उपयोग कर सकते हैं और -1 पास कर सकते हैं ताकि श्रृंखला बैच आकार के समान हो। मान 20 प्रति बैच अवलोकनों की संख्या है और 1 इनपुट की संख्या है।

आपको यही चरण दोहराना होगा, लेकिन लेबल के लिए।

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

x_data = train[:size_train-1]: Select all the training instance minus one day
X_batches = x_data.reshape(-1, windows, input): create the right shape for the batch e.g (10, 20, 1)
def create_batches(df, windows, input, output):
    ## Create X         
        x_data = train[:size_train-1] # Select the data
        X_batches = x_data.reshape(-1, windows, input)  # Reshape the data 
    ## Create y
        y_data = train[n_output:size_train]
        y_batches = y_data.reshape(-1, windows, output)
        return X_batches, y_batches

अब चूंकि फ़ंक्शन परिभाषित हो गया है, तो आप बैच बनाने के लिए इसे कॉल कर सकते हैं जैसा कि नीचे दिए गए RNN उदाहरण में दिखाया गया है।

X_batches, y_batches = create_batches(df = train,
                                      windows = n_windows,
                                      input = n_input,
                                      output = n_output)

आप यह सुनिश्चित करने के लिए आकृति को प्रिंट कर सकते हैं कि आयाम सही हैं।

print(X_batches.shape, y_batches.shape)
(10, 20, 1) (10, 20, 1)

आपको केवल एक बैच डेटा और 20 अवलोकनों के साथ परीक्षण सेट बनाना होगा।

ध्यान दें कि, आप दिनों-दिन पूर्वानुमान लगाते हैं, इसका मतलब है कि दूसरा अनुमानित मूल्य परीक्षण डेटासेट के पहले दिन (t+1) के वास्तविक मूल्य पर आधारित होगा। वास्तव में, वास्तविक मूल्य ज्ञात होगा।

यदि आप t+2 (यानी, दो दिन आगे) का पूर्वानुमान लगाना चाहते हैं, तो आपको पूर्वानुमानित मान t+1 का उपयोग करना होगा; यदि आप t+3 (तीन दिन आगे) का पूर्वानुमान लगाना चाहते हैं, तो आपको पूर्वानुमानित मान t+1 और t+2 का उपयोग करना होगा। यह समझ में आता है कि, t+n दिन आगे का सटीक पूर्वानुमान लगाना मुश्किल है।

X_test, y_test = create_batches(df = test, windows = 20,input = 1, output = 1)
print(X_test.shape, y_test.shape)
(10, 20, 1) (10, 20, 1)

ठीक है, आपका बैच आकार तैयार है, आप RNN आर्किटेक्चर बना सकते हैं। याद रखें, आपके पास 120 आवर्तक न्यूरॉन्स हैं।

चरण 3) मॉडल बनाएं

मॉडल बनाने के लिए आपको तीन भाग परिभाषित करने होंगे:

टेंसर वाला चर
आरएनएन
हानि और अनुकूलन

चरण 3.1) चर

आपको X और y चर को उचित आकार के साथ निर्दिष्ट करने की आवश्यकता है। यह चरण तुच्छ है। टेंसर का आयाम ऑब्जेक्ट X_batches और y_batches के समान है।

उदाहरण के लिए, टेंसर X एक प्लेसहोल्डर है (परिचय पर ट्यूटोरियल देखें) टेन्सलफ्लो चर घोषणा के बारे में अपने दिमाग को ताज़ा करने के लिए) के तीन आयाम हैं:

नोट: बैच का आकार
n_windows: खिड़कियों की लंबाई। यानी, मॉडल द्वारा पीछे की ओर देखने की संख्या
n_input: इनपुट की संख्या

परिणाम है:

tf.placeholder(tf.float32, [None, n_windows, n_input])

## 1. Construct the tensors
X = tf.placeholder(tf.float32, [None, n_windows, n_input])   
y = tf.placeholder(tf.float32, [None, n_windows, n_output])

चरण 3.2) RNN बनाएं

इस RNN TensorFlow उदाहरण के दूसरे भाग में, आपको नेटवर्क की वास्तुकला को परिभाषित करने की आवश्यकता है। पहले की तरह, आप TensorFlow अनुमानक से ऑब्जेक्ट BasicRNNCell और dynamic_rnn का उपयोग करते हैं।

## 2. create the model
basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu)   
rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)

अगला भाग थोड़ा मुश्किल है लेकिन इससे गणना तेज़ हो जाती है। आपको रन आउटपुट को सघन परत में बदलना होगा और फिर उसे इनपुट के समान आयाम में बदलना होगा।

stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron])          
stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output)       
outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output])

चरण 3.3) हानि और अनुकूलन बनाएँ

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

यह अंतर महत्वपूर्ण है क्योंकि यह अनुकूलन समस्या को बदल देगा। निरंतर चर के लिए अनुकूलन समस्या औसत वर्ग त्रुटि को न्यूनतम करना है। TF में इन मेट्रिक्स का निर्माण करने के लिए, आप इसका उपयोग कर सकते हैं:

tf.reduce_sum(tf.square(आउटपुट – y))

RNN कोड का शेष भाग पहले जैसा ही है; हानि (अर्थात MSE) को कम करने के लिए आप एडम ऑप्टिमाइज़र का उपयोग करते हैं:

tf.train.AdamOptimizer(सीखने_दर=सीखने_दर)
अनुकूलक.न्यूनतम(नुकसान)

बस, आप सब कुछ एक साथ पैक कर सकते हैं, और आपका मॉडल प्रशिक्षण के लिए तैयार है।

tf.reset_default_graph()
r_neuron = 120    

## 1. Construct the tensors
X = tf.placeholder(tf.float32, [None, n_windows, n_input])   
y = tf.placeholder(tf.float32, [None, n_windows, n_output])

## 2. create the model
basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu)   
rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)              

stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron])          
stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output)       
outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output])   

## 3. Loss + optimization
learning_rate = 0.001  
 
loss = tf.reduce_sum(tf.square(outputs - y))    
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)         
training_op = optimizer.minimize(loss)                                          

init = tf.global_variables_initializer()

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

iteration = 1500 

with tf.Session() as sess:
    init.run()
    for iters in range(iteration):
        sess.run(training_op, feed_dict={X: X_batches, y: y_batches})
        if iters % 150 == 0:
            mse = loss.eval(feed_dict={X: X_batches, y: y_batches})
            print(iters, "\tMSE:", mse)
    
    y_pred = sess.run(outputs, feed_dict={X: X_test})
0 	MSE: 502893.34
150 	MSE: 13839.129
300 	MSE: 3964.835
450 	MSE: 2619.885
600 	MSE: 2418.772
750 	MSE: 2110.5923
900 	MSE: 1887.9644
1050 	MSE: 1747.1377
1200 	MSE: 1556.3398
1350 	MSE: 1384.6113

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

जैसा कि आप देख सकते हैं, मॉडल में सुधार की गुंजाइश है। विंडोज़, आवर्ती न्यूरॉन्स की संख्या के बैच आकार जैसे हाइपरपैरामीटर को बदलना आपके ऊपर है।

plt.title("Forecast vs Actual", fontsize=14)
plt.plot(pd.Series(np.ravel(y_test)), "bo", markersize=8, label="Actual", color='green')
plt.plot(pd.Series(np.ravel(y_pred)), "r.", markersize=8, label="Forecast", color='red')
plt.legend(loc="lower left")
plt.xlabel("Time")

plt.show()

सारांश

आवर्ती तंत्रिका नेटवर्क समय श्रृंखला या पाठ विश्लेषण से निपटने के लिए एक मजबूत वास्तुकला है। पिछली स्थिति का आउटपुट समय या शब्दों के अनुक्रम के साथ नेटवर्क की स्मृति को संरक्षित करने के लिए फीडबैक है।

TensorFlow में, आप समय श्रृंखला के लिए TensorFlow आवर्तक तंत्रिका नेटवर्क को प्रशिक्षित करने के लिए निम्नलिखित कोड का उपयोग कर सकते हैं:

मॉडल के पैरामीटर

n_windows = 20   
n_input =  1
n_output = 1
size_train = 201

मॉडल को परिभाषित कीजिए

X = tf.placeholder(tf.float32, [None, n_windows, n_input])   
y = tf.placeholder(tf.float32, [None, n_windows, n_output])

basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu)   
rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)              

stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron])          
stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output)       
outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output])

अनुकूलन का निर्माण करें

learning_rate = 0.001  
 
loss = tf.reduce_sum(tf.square(outputs - y))    
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)         
training_op = optimizer.minimize(loss)

मॉडल को प्रशिक्षित करें

init = tf.global_variables_initializer() 
iteration = 1500 

with tf.Session() as sess:
    init.run()
    for iters in range(iteration):
        sess.run(training_op, feed_dict={X: X_batches, y: y_batches})
        if iters % 150 == 0:
            mse = loss.eval(feed_dict={X: X_batches, y: y_batches})
            print(iters, "\tMSE:", mse)
    
    y_pred = sess.run(outputs, feed_dict={X: X_test})