25 KiB

Raw Permalink Blame History

सपोर्ट वेक्टर रेग्रेसर के साथ टाइम सीरीज़ फोरकास्टिंग

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

प्री-लेक्चर क्विज़

परिचय

इस पाठ में, आप SVM: Support Vector Machine का उपयोग करके रेग्रेशन के लिए मॉडल बनाने का एक विशेष तरीका जानेंगे, जिसे SVR: Support Vector Regressor कहा जाता है।

टाइम सीरीज़ के संदर्भ में SVR ¹

टाइम सीरीज़ प्रेडिक्शन में SVR के महत्व को समझने से पहले, यहां कुछ महत्वपूर्ण अवधारणाएं हैं जिन्हें आपको जानना चाहिए:

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

SVR क्यों? ¹

पिछले पाठ में आपने ARIMA के बारे में सीखा, जो टाइम सीरीज़ डेटा की भविष्यवाणी के लिए एक बहुत ही सफल सांख्यिकीय रैखिक विधि है। हालांकि, कई मामलों में, टाइम सीरीज़ डेटा में गैर-रैखिकता होती है, जिसे रैखिक मॉडल द्वारा मैप नहीं किया जा सकता। ऐसे मामलों में, रेग्रेशन कार्यों के लिए डेटा में गैर-रैखिकता को ध्यान में रखने की SVM की क्षमता SVR को टाइम सीरीज़ फोरकास्टिंग में सफल बनाती है।

अभ्यास - SVR मॉडल बनाएं

डेटा तैयार करने के पहले कुछ चरण पिछले पाठ ARIMA के समान हैं।

इस पाठ में /working फ़ोल्डर खोलें और notebook.ipynb फ़ाइल ढूंढें।²

नोटबुक चलाएं और आवश्यक लाइब्रेरी आयात करें: ²

import sys
sys.path.append('../../')

import os
import warnings
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import datetime as dt
import math

from sklearn.svm import SVR
from sklearn.preprocessing import MinMaxScaler
from common.utils import load_data, mape

/data/energy.csv फ़ाइल से डेटा को एक Pandas डेटा फ्रेम में लोड करें और इसे देखें: ²
```
energy = load_data('../../data')[['load']]
```
जनवरी 2012 से दिसंबर 2014 तक उपलब्ध सभी ऊर्जा डेटा को प्लॉट करें: ²
```
energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
plt.xlabel('timestamp', fontsize=12)
plt.ylabel('load', fontsize=12)
plt.show()
```
अब, चलिए अपना SVR मॉडल बनाते हैं।

प्रशिक्षण और परीक्षण डेटा सेट बनाएं

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

1 सितंबर से 31 अक्टूबर, 2014 तक की दो महीने की अवधि को ट्रेनिंग सेट में आवंटित करें। टेस्ट सेट में 1 नवंबर से 31 दिसंबर, 2014 तक की दो महीने की अवधि शामिल होगी: ²
```
train_start_dt = '2014-11-01 00:00:00'
test_start_dt = '2014-12-30 00:00:00'
```

अंतर को विज़ुअलाइज़ करें: ²

energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)][['load']].rename(columns={'load':'train'}) \
    .join(energy[test_start_dt:][['load']].rename(columns={'load':'test'}), how='outer') \
    .plot(y=['train', 'test'], figsize=(15, 8), fontsize=12)
plt.xlabel('timestamp', fontsize=12)
plt.ylabel('load', fontsize=12)
plt.show()

प्रशिक्षण के लिए डेटा तैयार करें

अब, आपको अपने डेटा को प्रशिक्षण के लिए तैयार करने की आवश्यकता है, जिसमें डेटा को फ़िल्टर करना और स्केल करना शामिल है। अपने डेटा सेट को केवल आवश्यक समय अवधि और कॉलम तक सीमित करें, और डेटा को 0,1 के अंतराल में प्रोजेक्ट करने के लिए स्केल करें।

मूल डेटा सेट को केवल उपर्युक्त समय अवधि और केवल आवश्यक कॉलम 'लोड' और तारीख तक सीमित करें: ²

train = energy.copy()[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']]
test = energy.copy()[energy.index >= test_start_dt][['load']]

print('Training data shape: ', train.shape)
print('Test data shape: ', test.shape)

Training data shape:  (1416, 1)
Test data shape:  (48, 1)

ट्रेनिंग डेटा को (0, 1) की रेंज में स्केल करें: ²
```
scaler = MinMaxScaler()
train['load'] = scaler.fit_transform(train)
```
अब, टेस्टिंग डेटा को स्केल करें: ²
```
test['load'] = scaler.transform(test)
```

टाइम-स्टेप्स के साथ डेटा बनाएं ¹

SVR के लिए, आप इनपुट डेटा को [batch, timesteps] के रूप में ट्रांसफॉर्म करते हैं। इसलिए, आप मौजूदा train_data और test_data को इस प्रकार पुनः आकार देंगे कि एक नया आयाम हो, जो टाइमस्टेप्स को संदर्भित करता है।

# Converting to numpy arrays
train_data = train.values
test_data = test.values

इस उदाहरण के लिए, हम timesteps = 5 लेते हैं। तो, मॉडल के इनपुट पहले 4 टाइमस्टेप्स के डेटा होंगे, और आउटपुट 5वें टाइमस्टेप का डेटा होगा।

timesteps=5

नेस्टेड लिस्ट कॉम्प्रिहेंशन का उपयोग करके ट्रेनिंग डेटा को 2D टेंसर में बदलना:

train_data_timesteps=np.array([[j for j in train_data[i:i+timesteps]] for i in range(0,len(train_data)-timesteps+1)])[:,:,0]
train_data_timesteps.shape

(1412, 5)

टेस्टिंग डेटा को 2D टेंसर में बदलना:

test_data_timesteps=np.array([[j for j in test_data[i:i+timesteps]] for i in range(0,len(test_data)-timesteps+1)])[:,:,0]
test_data_timesteps.shape

(44, 5)

ट्रेनिंग और टेस्टिंग डेटा से इनपुट और आउटपुट का चयन:

x_train, y_train = train_data_timesteps[:,:timesteps-1],train_data_timesteps[:,[timesteps-1]]
x_test, y_test = test_data_timesteps[:,:timesteps-1],test_data_timesteps[:,[timesteps-1]]

print(x_train.shape, y_train.shape)
print(x_test.shape, y_test.shape)

(1412, 4) (1412, 1)
(44, 4) (44, 1)

SVR लागू करें ¹

अब, SVR को लागू करने का समय है। इस कार्यान्वयन के बारे में अधिक पढ़ने के लिए, आप इस दस्तावेज़ का संदर्भ ले सकते हैं। हमारे कार्यान्वयन के लिए, हम निम्नलिखित चरणों का पालन करते हैं:

SVR() को कॉल करके और मॉडल हाइपरपैरामीटर्स: kernel, gamma, c और epsilon पास करके मॉडल को परिभाषित करें।
fit() फ़ंक्शन को कॉल करके मॉडल को ट्रेनिंग डेटा के लिए तैयार करें।
predict() फ़ंक्शन को कॉल करके भविष्यवाणियां करें।

अब हम एक SVR मॉडल बनाते हैं। यहां हम RBF कर्नेल का उपयोग करते हैं, और हाइपरपैरामीटर्स gamma, C और epsilon को क्रमशः 0.5, 10 और 0.05 पर सेट करते हैं।

model = SVR(kernel='rbf',gamma=0.5, C=10, epsilon = 0.05)

ट्रेनिंग डेटा पर मॉडल फिट करें ¹

model.fit(x_train, y_train[:,0])

SVR(C=10, cache_size=200, coef0=0.0, degree=3, epsilon=0.05, gamma=0.5,
    kernel='rbf', max_iter=-1, shrinking=True, tol=0.001, verbose=False)

मॉडल की भविष्यवाणियां करें ¹

y_train_pred = model.predict(x_train).reshape(-1,1)
y_test_pred = model.predict(x_test).reshape(-1,1)

print(y_train_pred.shape, y_test_pred.shape)

(1412, 1) (44, 1)

आपने अपना SVR बना लिया है! अब हमें इसका मूल्यांकन करना होगा।

अपने मॉडल का मूल्यांकन करें ¹

मूल्यांकन के लिए, पहले हम डेटा को हमारे मूल स्केल में वापस स्केल करेंगे। फिर, प्रदर्शन की जांच करने के लिए, हम मूल और भविष्यवाणी किए गए टाइम सीरीज़ प्लॉट को प्लॉट करेंगे, और MAPE परिणाम भी प्रिंट करेंगे।

भविष्यवाणी और मूल आउटपुट को स्केल करें:

# Scaling the predictions
y_train_pred = scaler.inverse_transform(y_train_pred)
y_test_pred = scaler.inverse_transform(y_test_pred)

print(len(y_train_pred), len(y_test_pred))

# Scaling the original values
y_train = scaler.inverse_transform(y_train)
y_test = scaler.inverse_transform(y_test)

print(len(y_train), len(y_test))

ट्रेनिंग और टेस्टिंग डेटा पर मॉडल प्रदर्शन की जांच करें ¹

हम x-अक्ष पर दिखाने के लिए डेटा सेट से टाइमस्टैम्प निकालते हैं। ध्यान दें कि हम पहले timesteps-1 मानों का उपयोग पहले आउटपुट के लिए इनपुट के रूप में कर रहे हैं, इसलिए आउटपुट के लिए टाइमस्टैम्प उसके बाद शुरू होंगे।

train_timestamps = energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)].index[timesteps-1:]
test_timestamps = energy[test_start_dt:].index[timesteps-1:]

print(len(train_timestamps), len(test_timestamps))

1412 44

ट्रेनिंग डेटा के लिए भविष्यवाणियों को प्लॉट करें:

plt.figure(figsize=(25,6))
plt.plot(train_timestamps, y_train, color = 'red', linewidth=2.0, alpha = 0.6)
plt.plot(train_timestamps, y_train_pred, color = 'blue', linewidth=0.8)
plt.legend(['Actual','Predicted'])
plt.xlabel('Timestamp')
plt.title("Training data prediction")
plt.show()

ट्रेनिंग डेटा के लिए MAPE प्रिंट करें:

print('MAPE for training data: ', mape(y_train_pred, y_train)*100, '%')

MAPE for training data: 1.7195710200875551 %

टेस्टिंग डेटा के लिए भविष्यवाणियों को प्लॉट करें:

plt.figure(figsize=(10,3))
plt.plot(test_timestamps, y_test, color = 'red', linewidth=2.0, alpha = 0.6)
plt.plot(test_timestamps, y_test_pred, color = 'blue', linewidth=0.8)
plt.legend(['Actual','Predicted'])
plt.xlabel('Timestamp')
plt.show()

टेस्टिंग डेटा के लिए MAPE प्रिंट करें:

print('MAPE for testing data: ', mape(y_test_pred, y_test)*100, '%')

MAPE for testing data:  1.2623790187854018 %

🏆 आपके पास टेस्टिंग डेटा सेट पर बहुत अच्छा परिणाम है!

पूरे डेटा सेट पर मॉडल प्रदर्शन की जांच करें ¹

# Extracting load values as numpy array
data = energy.copy().values

# Scaling
data = scaler.transform(data)

# Transforming to 2D tensor as per model input requirement
data_timesteps=np.array([[j for j in data[i:i+timesteps]] for i in range(0,len(data)-timesteps+1)])[:,:,0]
print("Tensor shape: ", data_timesteps.shape)

# Selecting inputs and outputs from data
X, Y = data_timesteps[:,:timesteps-1],data_timesteps[:,[timesteps-1]]
print("X shape: ", X.shape,"\nY shape: ", Y.shape)

Tensor shape:  (26300, 5)
X shape:  (26300, 4) 
Y shape:  (26300, 1)

# Make model predictions
Y_pred = model.predict(X).reshape(-1,1)

# Inverse scale and reshape
Y_pred = scaler.inverse_transform(Y_pred)
Y = scaler.inverse_transform(Y)

plt.figure(figsize=(30,8))
plt.plot(Y, color = 'red', linewidth=2.0, alpha = 0.6)
plt.plot(Y_pred, color = 'blue', linewidth=0.8)
plt.legend(['Actual','Predicted'])
plt.xlabel('Timestamp')
plt.show()

print('MAPE: ', mape(Y_pred, Y)*100, '%')

MAPE:  2.0572089029888656 %

🏆 बहुत अच्छे प्लॉट्स, जो एक अच्छे सटीकता वाले मॉडल को दिखाते हैं। बहुत बढ़िया!

🚀चुनौती

मॉडल बनाते समय हाइपरपैरामीटर्स (gamma, C, epsilon) को बदलने का प्रयास करें और डेटा पर मूल्यांकन करें ताकि यह देखा जा सके कि कौन सा हाइपरपैरामीटर सेट टेस्टिंग डेटा पर सबसे अच्छे परिणाम देता है। इन हाइपरपैरामीटर्स के बारे में अधिक जानने के लिए, आप यहां दस्तावेज़ देख सकते हैं।
मॉडल के लिए विभिन्न कर्नेल फंक्शंस का उपयोग करने का प्रयास करें और उनके प्रदर्शन का विश्लेषण करें। एक सहायक दस्तावेज़ यहां पाया जा सकता है।
मॉडल के लिए भविष्यवाणी करने के लिए timesteps के विभिन्न मानों का उपयोग करने का प्रयास करें।

पोस्ट-लेक्चर क्विज़

समीक्षा और स्व-अध्ययन

यह पाठ टाइम सीरीज़ फोरकास्टिंग के लिए SVR के अनुप्रयोग को पेश करने के लिए था। SVR के बारे में अधिक पढ़ने के लिए, आप इस ब्लॉग का संदर्भ ले सकते हैं। scikit-learn पर यह दस्तावेज़ SVMs के बारे में अधिक व्यापक व्याख्या प्रदान करता है, SVRs और अन्य कार्यान्वयन विवरण जैसे कि विभिन्न कर्नेल फंक्शंस जो उपयोग किए जा सकते हैं, और उनके पैरामीटर्स।

असाइनमेंट

एक नया SVR मॉडल

क्रेडिट्स

अस्वीकरण:
यह दस्तावेज़ AI अनुवाद सेवा Co-op Translator का उपयोग करके अनुवादित किया गया है। जबकि हम सटीकता के लिए प्रयास करते हैं, कृपया ध्यान दें कि स्वचालित अनुवाद में त्रुटियां या अशुद्धियां हो सकती हैं। मूल भाषा में उपलब्ध मूल दस्तावेज़ को आधिकारिक स्रोत माना जाना चाहिए। महत्वपूर्ण जानकारी के लिए, पेशेवर मानव अनुवाद की सिफारिश की जाती है। इस अनुवाद के उपयोग से उत्पन्न किसी भी गलतफहमी या गलत व्याख्या के लिए हम उत्तरदायी नहीं हैं।

इस खंड में पाठ, कोड और आउटपुट @AnirbanMukherjeeXD द्वारा योगदान किया गया था। ↩︎
इस खंड में पाठ, कोड और आउटपुट ARIMA से लिया गया था। ↩︎

25 KiB Raw Permalink Blame History