मैं एक प्रतिगमन समस्या पर काम कर रहा हूं, जहां मेरे पास 12 सेंसर डेटा (स्वतंत्र) कॉलम और 1 आउटपुट कॉलम है, सभी को 48KHz पर नमूना लिया गया है। मेरे पास कुल 420 सेकंड का ट्रेन डेटा है। परीक्षण डेटासेट में, मेरे पास 12 सेंसर डेटा कॉलम हैं और आउटपुट की भविष्यवाणी करने की आवश्यकता है।

अब तक, मैंने समय की विशेषता पर विचार किए बिना शास्त्रीय मशीन लर्निंग एल्गोरिदम की कोशिश की है। मैं समय श्रृंखला के लिए नया हूं और निश्चित नहीं हूं कि यह वास्तव में एक समय श्रृंखला पूर्वानुमान समस्या है।

मुझे यकीन नहीं है कि क्या मैं इसे एक बहुभिन्नरूपी समय श्रृंखला समस्या के रूप में मान सकता हूं और LSTM/RNN का प्रयास कर सकता हूं। मैं https://machinelearningmastery.com/multivariate का अनुसरण कर रहा हूं -समय-श्रृंखला-पूर्वानुमान-lstms-keras/#comment-442845 लेकिन यह समझने में सक्षम नहीं है कि मैं परीक्षण डेटा पर कैसे भविष्यवाणी कर सकता हूं।

क्या मुझे परीक्षण डेटा को (लंबाई, 12) से (लंबाई, 13) में बदलने के लिए एक नया कॉलम जोड़ने की आवश्यकता है और फिर एक-एक करके भविष्यवाणी करें और अगले पुनरावृत्ति के लिए आउटपुट का उपयोग करें?

साथ ही, इस तरह की समस्या को हल करने के लिए एक सही दृष्टिकोण से ऊपर है या क्या मुझे कुछ और सोचना है?

अपडेट करें नीचे दी गई टिप्पणियों पर मेरा प्रश्न अपडेट कर रहा है। मान लें कि मेरा ट्रेन डेटा नीचे जैसा दिखता है (बेहतर व्याख्या करने के लिए अद्यतन शीर्षक)। मैं LSTM नेटवर्क को उसी तरह प्रशिक्षित कर रहा हूं जैसा कि ऊपर दिए गए लिंक में बताया गया है। मैंने वाई (टी), वाई (टी -1), एक्स 1 (टी -1), एक्स 2 (टी -1), एक्स 3 (टी -1), एक्स 4 (टी -1), एक्स 5 (टी -1) बनाया है। x6(t-1) series_to_supervised फ़ंक्शन का उपयोग करके।

                           Y     x1   x2    x3         x4      x5      x6
date                                                                          
2010-01-02 00:00:00      129.0  -16  -4.0  1020.0      SE     1.79     0     
2010-01-02 01:00:00      148.0  -15  -4.0  1020.0      SE     2.68     0     
2010-01-02 02:00:00      159.0  -11  -5.0  1021.0      SE     3.57     0     
2010-01-02 03:00:00      181.0   -7  -5.0  1022.0      SE     5.36     1     
2010-01-02 04:00:00      138.0   -7  -5.0  1022.0      SE     6.25     2     

अब, मेरे पास वाई कॉलम के बिना परीक्षण डेटा है। उदाहरण के तौर पे,

                          x1   x2    x3         x4      x5      x6
date                                                                          
2010-01-02 00:00:00      -11  -6.0  1020.0      SE     1.79     0     
2010-01-02 01:00:00      -12  -1.0  1020.0      SE     2.68     0     
2010-01-02 02:00:00      -10  -4.0  1021.0      SE     3.57     0     
2010-01-02 03:00:00      -7   -2.0  1022.0      SE     5.36     1     
2010-01-02 04:00:00      -7   -5.0  1022.0      SE     6.25     2     

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

सांकेतिक टुकड़ा

#test_pd is panda frame of size Nx6
#train_pd is panda frame of size Nx5

test_pd['Y'] = 0
train_out_mean = train_pd[0].mean()
test_pd[0][0] = train_out_mean
test_pd = test_pd.values.reshape((test_pd.shape[0],1,test_pd.shape[1]))
out_list = list()
out_list.append(train_out_mean)
for i in range(test_pd.shape[0]):

    y = loaded_model.predict(test_pd[i].reshape(1,test_pd.shape[1],test_pd.shape[2]))
    y = y[0]
    out_list.append(y)
    if (i+1>=test_pd.shape[0]):
        break
    test_pd[i+1][0][0] = y

मेरे पास दो अनुवर्ती प्रश्न हैं।

  1. क्या उपरोक्त दृष्टिकोण समस्या को हल करने के लिए सैद्धांतिक रूप से सही है?

  2. यदि हाँ, तो क्या परीक्षण डेटासेट पर भविष्यवाणी करने का कोई बेहतर तरीका है?

0
Sailorman 3 अक्टूबर 2019, 05:22

1 उत्तर

मैं LSTM जैसे अधिक जटिल एल्गोरिदम के लिए जाने से पहले एक सरल दृष्टिकोण से शुरू करने पर विचार करूंगा।

यहां स्टैक ओवरफ्लो में आपको निष्पक्ष रूप से कोड के बारे में कुछ संदेह पूछना चाहिए। इसलिए यदि आप अपना कुछ कोड यहां साझा करते हैं, तो हम आपकी सहायता करने का प्रयास कर सकते हैं।

यह देखते हुए कि आपके पास एक समय श्रृंखला है (उदाहरण आपके लिंक में):

                     pollution  dew  temp   press wnd_dir  wnd_spd  snow  rain
date                                                                          
2010-01-02 00:00:00      129.0  -16  -4.0  1020.0      SE     1.79     0     0
2010-01-02 01:00:00      148.0  -15  -4.0  1020.0      SE     2.68     0     0
2010-01-02 02:00:00      159.0  -11  -5.0  1021.0      SE     3.57     0     0
2010-01-02 03:00:00      181.0   -7  -5.0  1022.0      SE     5.36     1     0
2010-01-02 04:00:00      138.0   -7  -5.0  1022.0      SE     6.25     2     0

सरल तरीका: एमएलपी रजिस्ट्रार

एक आसान तरीके से, यह मानकर कि आप प्रदूषण की भविष्यवाणी करना चाहते हैं, आप एक MLP Regressor, इसलिए प्रशिक्षण चरण के दौरान, आपको प्रदूषण की भविष्यवाणी करने के लिए डेटा को 7 विशेषताओं (ओस, तापमान, प्रेस, wnd_dir, wnd_spd, स्नो, रेन) में अलग करना चाहिए। यहाँ एक उदाहरण:

from sklearn.neural_network import MLPRegressor
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, MinMaxScaler
from sklearn import metrics

data = dataset.values

# integer encode WIND direction
encoder = LabelEncoder()
data[:,4] = encoder.fit_transform(data[:,4])

scaler = MinMaxScaler(feature_range=(0, 1))
scaled = scaler.fit_transform(data)

y, X = np.split(data,[1],axis=1) 

mlp = MLPRegressor(learning_rate_init=0.001)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

print (X_train.shape, y_train.shape)
print (X_test.shape, y_test.shape)

mlp.fit(X_train,y_train)

y_prediction = mlp.predict(X_test)

print("R2 score:", metrics.r2_score(y_test, y_prediction))

आउटपुट:

R2 score: 0.30376681842945985

LSTM में (आपको चाहिए: 3D [नमूने, समय-चरण, सुविधाएँ])

अब, मान लीजिए कि इस समय ** t-1 **, ** t-2 ** (1 घंटा, 2 घंटे) की किसी विशेषता (हवा, वायुदाब, आदि) का कुछ प्रभाव है इस समय ** टी **। तो अब आप कुछ समय के लिए हवा की गति (उदाहरण के लिए) के कुछ विकास को कैप्चर करके समय श्रृंखला के रूप में अपनी समस्या को हल करने का इरादा रखते हैं। तो अब LSTM का उपयोग करना समझ में आता है।

तो, फ़ंक्शन series_to_supervised (आपके लिंक का उदाहरण) आपको नई सुविधाएं बनाने में मदद करेगा...

फ़ंक्शन series_to_supervised में 4 तर्क हैं:

  • डेटा: एक सूची या 2D NumPy सरणी के रूप में अवलोकनों का क्रम।
  • n_in: इनपुट (X) के रूप में अंतराल अवलोकनों की संख्या। मान [1..len(data)] के बीच हो सकते हैं
  • n_out: आउटपुट (y) के रूप में अवलोकनों की संख्या। मान [0..len(data)-1] के बीच हो सकते हैं।
  • dropnan: बूलियन NaN मानों वाली पंक्तियों को छोड़ना है या नहीं

तो, मान लीजिए कि इस श्रृंखला में केवल एक विशेषता X और लेबल y है:

                        X   y
2018-01-01 00:00:00     1   2
2018-01-01 01:00:00     2   3
2018-01-01 02:00:00     3   4
2018-01-01 03:00:00     4   5
2018-01-01 04:00:00     5   6
2018-01-01 05:00:00     6   7
2018-01-01 06:00:00     7   8
2018-01-01 07:00:00     8   9
2018-01-01 08:00:00     9   10
2018-01-01 09:00:00     10  11

इस फ़ंक्शन का उपयोग करना series_to_supervised(df.values,n_in=2, n_out=1, dropnan=False) आपके पास कुछ ऐसा होगा (मैंने समझने के लिए कुछ सुधार किए हैं):

                        X(t-2)   y(t-2)   X(t-1)   y(t-1)   X(t)   y(t)
2018-01-01 00:00:00       NaN     NaN     NaN        NaN     1      2
2018-01-01 01:00:00       NaN     NaN     1.0        2.0     2      3
2018-01-01 02:00:00       1.0     2.0     2.0        3.0     3      4
2018-01-01 03:00:00       2.0     3.0     3.0        4.0     4      5
2018-01-01 04:00:00       3.0     4.0     4.0        5.0     5      6
2018-01-01 05:00:00       4.0     5.0     5.0        6.0     6      7
2018-01-01 06:00:00       5.0     6.0     6.0        7.0     7      8
2018-01-01 07:00:00       6.0     7.0     7.0        8.0     8      9
2018-01-01 08:00:00       7.0     8.0     8.0        9.0     9      10
2018-01-01 09:00:00       8.0     9.0     9.0        10.0    10     11

इसलिए, इस दृष्टिकोण में हम इस बात पर विचार कर रहे हैं कि भविष्यवाणी करने के लिए, हम y(t), भविष्य की भविष्यवाणी करने के लिए कम से कम दो रिकॉर्ड X(t-2, t-1) और y(t-2, t-1) करेंगे।

आपको ऐसा करने की आवश्यकता क्यों है? अब मुझे लगता है कि मैं आपके प्रश्न का उत्तर देना शुरू करूंगा। LSTM में आपको अपने डेटा को 2D में 3D स्पेस में बदलना होगा।

इसलिए, उसके बाद आपको LSTM का उपयोग करने से पहले इनपुट को 3D [नमूने, समय-चरण, सुविधाएँ] में बदलने की आवश्यकता है। तो, रूपांतरित करें (इस फ़ंक्शन का उपयोग करके) आपका डेटा केवल एक तैयारी है।

आपके प्रश्न का उत्तर दे रहे हैं। आपको केवल एक कॉलम जोड़ने की आवश्यकता नहीं है। आपको t-n, t-3, t-2, t-1 में कुछ विशेषता की भविष्यवाणी करने के लिए t-n, t-3, t-2, t-1 में नई सुविधाएं प्राप्त करने के लिए अपने डेटा को रूपांतरित करने की आवश्यकता है।

मैं अनुशंसा करता हूं कि आप अपने मामले में अनुकूलन करने से पहले, इस ब्लॉग पर प्रदूषण के मामले (आपके द्वारा उद्धृत) के चरणों का पालन करें।

2
Andre Araujo 3 अक्टूबर 2019, 08:18
आपकी विस्तृत व्याख्या के लिए धन्यवाद। मैंने आपकी टिप्पणियों को पढ़ने के बाद अपना प्रश्न अपडेट कर लिया है।
 – 
Sailorman
9 अक्टूबर 2019, 05:13