25 KiB

Raw Permalink Blame History

सपोर्ट व्हेक्टर रेग्रेसरसह टाइम सिरीज अंदाज

मागील धड्यात, तुम्ही ARIMA मॉडेल वापरून टाइम सिरीज अंदाज कसा करायचा ते शिकले. आता तुम्ही सपोर्ट व्हेक्टर रेग्रेसर मॉडेलकडे पाहणार आहात, जे सतत डेटा अंदाज करण्यासाठी वापरले जाते.

पूर्व-व्याख्यान प्रश्नमंजुषा

परिचय

या धड्यात, तुम्ही SVM: Support Vector Machine वापरून रेग्रेशनसाठी मॉडेल तयार करण्याचा एक विशिष्ट मार्ग शोधाल, ज्याला SVR: Support Vector Regressor म्हणतात.

टाइम सिरीजच्या संदर्भात SVR ¹

टाइम सिरीज अंदाजामध्ये SVR चे महत्त्व समजण्यापूर्वी, तुम्हाला खालील महत्त्वाच्या संकल्पना माहित असणे आवश्यक आहे:

रेग्रेशन: दिलेल्या इनपुट्सच्या संचातून सतत मूल्ये अंदाज करण्यासाठी सुपरवाइज्ड लर्निंग तंत्र. कल्पना अशी आहे की फीचर स्पेसमध्ये जास्तीत जास्त डेटा पॉइंट्स असलेली वक्र (किंवा रेषा) फिट करणे. अधिक माहितीसाठी येथे क्लिक करा.
सपोर्ट व्हेक्टर मशीन (SVM): वर्गीकरण, रेग्रेशन आणि आउटलाईयर डिटेक्शनसाठी वापरले जाणारे सुपरवाइज्ड मशीन लर्निंग मॉडेलचा प्रकार. मॉडेल फीचर स्पेसमधील हायपरप्लेन आहे, जे वर्गीकरणाच्या बाबतीत सीमा म्हणून कार्य करते आणि रेग्रेशनच्या बाबतीत सर्वोत्तम फिट रेषा म्हणून कार्य करते. SVM मध्ये, डेटासेटला उच्च परिमाणांच्या जागेत रूपांतरित करण्यासाठी सामान्यतः कर्नल फंक्शन वापरले जाते, जेणेकरून ते सहजपणे विभक्त होऊ शकतील. SVM बद्दल अधिक माहितीसाठी येथे क्लिक करा.
सपोर्ट व्हेक्टर रेग्रेसर (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 अंतरामध्ये प्रोजेक्ट करण्यासाठी स्केलिंग करा.

मूळ डेटासेट फिल्टर करा, ज्यामध्ये फक्त वरील कालावधी आणि 'load' स्तंभ आणि तारीख समाविष्ट असेल: ²

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 kernel वापरतो आणि हायपरपॅरामीटर्स 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