ML-For-Beginners/translations/pa/7-TimeSeries/3-SVR/README.md

ਸਮੇਂ ਦੀ ਲੜੀ ਦੀ ਭਵਿੱਖਵਾਣੀ Support Vector Regressor ਨਾਲ

ਪਿਛਲੇ ਪਾਠ ਵਿੱਚ, ਤੁਸੀਂ ARIMA ਮਾਡਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਮੇਂ ਦੀ ਲੜੀ ਦੀ ਭਵਿੱਖਵਾਣੀ ਕਰਨ ਦਾ ਤਰੀਕਾ ਸਿੱਖਿਆ। ਹੁਣ ਤੁਸੀਂ Support Vector Regressor ਮਾਡਲ ਦੇਖੋਗੇ, ਜੋ ਕਿ ਇੱਕ ਰਿਗ੍ਰੈਸ਼ਨ ਮਾਡਲ ਹੈ ਜੋ ਲਗਾਤਾਰ ਡਾਟਾ ਦੀ ਭਵਿੱਖਵਾਣੀ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

ਪ੍ਰੀ-ਲੈਕਚਰ ਕਵਿਜ਼

ਜਾਣ ਪਛਾਣ

ਇਸ ਪਾਠ ਵਿੱਚ, ਤੁਸੀਂ ਰਿਗ੍ਰੈਸ਼ਨ ਲਈ SVM: Support Vector Machine ਨਾਲ ਮਾਡਲ ਬਣਾਉਣ ਦਾ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਤਰੀਕਾ ਖੋਜੋਗੇ, ਜਿਸਨੂੰ SVR: Support Vector Regressor ਕਿਹਾ ਜਾਂਦਾ ਹੈ।

ਸਮੇਂ ਦੀ ਲੜੀ ਦੇ ਸੰਦਰਭ ਵਿੱਚ SVR [^1]

ਸਮੇਂ ਦੀ ਲੜੀ ਦੀ ਭਵਿੱਖਵਾਣੀ ਵਿੱਚ SVR ਦੀ ਮਹੱਤਤਾ ਨੂੰ ਸਮਝਣ ਤੋਂ ਪਹਿਲਾਂ, ਕੁਝ ਮਹੱਤਵਪੂਰਨ ਧਾਰਨਾਵਾਂ ਹਨ ਜੋ ਤੁਹਾਨੂੰ ਜਾਣਨ ਦੀ ਲੋੜ ਹੈ:

• ਰਿਗ੍ਰੈਸ਼ਨ: ਇੱਕ ਸੁਪਰਵਾਈਜ਼ਡ ਲਰਨਿੰਗ ਤਕਨੀਕ ਜੋ ਦਿੱਤੇ ਗਏ ਇਨਪੁਟਸ ਤੋਂ ਲਗਾਤਾਰ ਮੁੱਲਾਂ ਦੀ ਭਵਿੱਖਵਾਣੀ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਵਿਚਾਰਧਾਰਾ ਇਹ ਹੈ ਕਿ ਫੀਚਰ ਸਪੇਸ ਵਿੱਚ ਇੱਕ ਵਕਰ (ਜਾਂ ਲਾਈਨ) ਫਿੱਟ ਕੀਤੀ ਜਾਵੇ ਜਿਸ ਵਿੱਚ ਜ਼ਿਆਦਾਤਰ ਡਾਟਾ ਪੌਇੰਟਸ ਹੋਣ। ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ ਇੱਥੇ ਕਲਿਕ ਕਰੋ।
• ਸਪੋਰਟ ਵੈਕਟਰ ਮਸ਼ੀਨ (SVM): ਇੱਕ ਸੁਪਰਵਾਈਜ਼ਡ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਜੋ ਕਲਾਸੀਫਿਕੇਸ਼ਨ, ਰਿਗ੍ਰੈਸ਼ਨ ਅਤੇ ਆਉਟਲਾਇਰ ਡਿਟੈਕਸ਼ਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਮਾਡਲ ਫੀਚਰ ਸਪੇਸ ਵਿੱਚ ਇੱਕ ਹਾਈਪਰਪਲੇਨ ਹੈ, ਜੋ ਕਿ ਕਲਾਸੀਫਿਕੇਸ਼ਨ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਇੱਕ ਬਾਊਂਡਰੀ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਅਤੇ ਰਿਗ੍ਰੈਸ਼ਨ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਬੈਸਟ-ਫਿਟ ਲਾਈਨ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ। SVM ਵਿੱਚ, ਇੱਕ Kernel ਫੰਕਸ਼ਨ ਆਮ ਤੌਰ 'ਤੇ ਡਾਟਾਸੈਟ ਨੂੰ ਵਧੇਰੇ ਡਾਇਮੈਂਸ਼ਨ ਵਾਲੇ ਸਪੇਸ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਜੋ ਉਹ ਆਸਾਨੀ ਨਾਲ ਵੱਖਰੇ ਹੋ ਸਕਣ। SVMs ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ ਇੱਥੇ ਕਲਿਕ ਕਰੋ।
• ਸਪੋਰਟ ਵੈਕਟਰ ਰਿਗ੍ਰੈਸਰ (SVR): SVM ਦੀ ਇੱਕ ਕਿਸਮ, ਜੋ ਬੈਸਟ-ਫਿਟ ਲਾਈਨ (ਜੋ SVM ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਇੱਕ ਹਾਈਪਰਪਲੇਨ ਹੈ) ਲੱਭਣ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਜ਼ਿਆਦਾਤਰ ਡਾਟਾ ਪੌਇੰਟਸ ਹੁੰਦੇ ਹਨ।

ਕਿਉਂ SVR? [^1]

ਪਿਛਲੇ ਪਾਠ ਵਿੱਚ ਤੁਸੀਂ ARIMA ਬਾਰੇ ਸਿੱਖਿਆ, ਜੋ ਕਿ ਸਮੇਂ ਦੀ ਲੜੀ ਦੇ ਡਾਟਾ ਦੀ ਭਵਿੱਖਵਾਣੀ ਕਰਨ ਲਈ ਇੱਕ ਬਹੁਤ ਹੀ ਸਫਲ ਸਾਂਖਿਕ ਰੇਖੀ ਮੈਥਡ ਹੈ। ਹਾਲਾਂਕਿ, ਕਈ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਸਮੇਂ ਦੀ ਲੜੀ ਦੇ ਡਾਟਾ ਵਿੱਚ ਗੈਰ-ਰੇਖੀਤਾ ਹੁੰਦੀ ਹੈ, ਜਿਸਨੂੰ ਰੇਖੀ ਮਾਡਲਾਂ ਦੁਆਰਾ ਮੈਪ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ। ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਰਿਗ੍ਰੈਸ਼ਨ ਟਾਸਕ ਲਈ ਡਾਟਾ ਵਿੱਚ ਗੈਰ-ਰੇਖੀਤਾ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣ ਦੀ SVM ਦੀ ਸਮਰੱਥਾ SVR ਨੂੰ ਸਮੇਂ ਦੀ ਲੜੀ ਦੀ ਭਵਿੱਖਵਾਣੀ ਵਿੱਚ ਸਫਲ ਬਣਾਉਂਦੀ ਹੈ।

ਅਭਿਆਸ - SVR ਮਾਡਲ ਬਣਾਉਣਾ

ਡਾਟਾ ਤਿਆਰ ਕਰਨ ਦੇ ਪਹਿਲੇ ਕੁਝ ਕਦਮ ਪਿਛਲੇ ਪਾਠ ARIMA ਦੇ ਸਮਾਨ ਹਨ।

ਇਸ ਪਾਠ ਵਿੱਚ /working ਫੋਲਡਰ ਖੋਲ੍ਹੋ ਅਤੇ notebook.ipynb ਫਾਈਲ ਲੱਭੋ।[^2]

1. ਨੋਟਬੁੱਕ ਚਲਾਓ ਅਤੇ ਜ਼ਰੂਰੀ ਲਾਇਬ੍ਰੇਰੀਜ਼ ਇੰਪੋਰਟ ਕਰੋ: [^2]

   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
   

2. /data/energy.csv ਫਾਈਲ ਤੋਂ ਡਾਟਾ Pandas ਡਾਟਾਫ੍ਰੇਮ ਵਿੱਚ ਲੋਡ ਕਰੋ ਅਤੇ ਡਾਟਾ ਵੇਖੋ: [^2]

   energy = load_data('../../data')[['load']]
   

3. ਜਨਵਰੀ 2012 ਤੋਂ ਦਸੰਬਰ 2014 ਤੱਕ ਉਪਲਬਧ ਸਾਰੀ energy ਡਾਟਾ ਪਲਾਟ ਕਰੋ: [^2]

   energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
   plt.xlabel('timestamp', fontsize=12)
   plt.ylabel('load', fontsize=12)
   plt.show()
   

   

   ਹੁਣ, ਆਓ ਆਪਣਾ SVR ਮਾਡਲ ਬਣਾਈਏ।

ਟ੍ਰੇਨਿੰਗ ਅਤੇ ਟੈਸਟਿੰਗ ਡਾਟਾਸੈਟ ਬਣਾਉਣਾ

ਹੁਣ ਤੁਹਾਡਾ ਡਾਟਾ ਲੋਡ ਹੋ ਗਿਆ ਹੈ, ਇਸ ਨੂੰ ਟ੍ਰੇਨ ਅਤੇ ਟੈਸਟ ਸੈਟ ਵਿੱਚ ਵੱਖਰਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਫਿਰ ਤੁਸੀਂ ਡਾਟਾ ਨੂੰ ਰੀਸ਼ੇਪ ਕਰਕੇ ਇੱਕ time-step ਅਧਾਰਿਤ ਡਾਟਾਸੈਟ ਬਣਾਉਗੇ, ਜੋ SVR ਲਈ ਲੋੜੀਂਦਾ ਹੋਵੇਗਾ। ਤੁਸੀਂ ਆਪਣੇ ਮਾਡਲ ਨੂੰ ਟ੍ਰੇਨ ਸੈਟ 'ਤੇ ਟ੍ਰੇਨ ਕਰੋਗੇ। ਮਾਡਲ ਟ੍ਰੇਨਿੰਗ ਪੂਰੀ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਇਸਦੀ ਸਹੀਤਾ ਨੂੰ ਟ੍ਰੇਨਿੰਗ ਸੈਟ, ਟੈਸਟਿੰਗ ਸੈਟ ਅਤੇ ਫਿਰ ਪੂਰੇ ਡਾਟਾਸੈਟ 'ਤੇ ਮਾਪੋਗੇ ਤਾਂ ਜੋ ਕੁੱਲ ਪ੍ਰਦਰਸ਼ਨ ਦੇਖਿਆ ਜਾ ਸਕੇ। ਤੁਹਾਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਹੋਵੇਗਾ ਕਿ ਟੈਸਟ ਸੈਟ ਟ੍ਰੇਨਿੰਗ ਸੈਟ ਤੋਂ ਬਾਅਦ ਦੇ ਸਮੇਂ ਦੀ ਮਿਆਦ ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ ਮਾਡਲ ਭਵਿੱਖ ਦੇ ਸਮੇਂ ਦੀ ਮਿਆਦ ਤੋਂ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਨਾ ਕਰੇ [^2] (ਇਸ ਸਥਿਤੀ ਨੂੰ Overfitting ਕਿਹਾ ਜਾਂਦਾ ਹੈ)।

1. 1 ਸਤੰਬਰ ਤੋਂ 31 ਅਕਤੂਬਰ 2014 ਤੱਕ ਦੀ ਦੋ ਮਹੀਨੇ ਦੀ ਮਿਆਦ ਨੂੰ ਟ੍ਰੇਨਿੰਗ ਸੈਟ ਲਈ ਅਲਾਟ ਕਰੋ। ਟੈਸਟ ਸੈਟ ਵਿੱਚ 1 ਨਵੰਬਰ ਤੋਂ 31 ਦਸੰਬਰ 2014 ਤੱਕ ਦੀ ਦੋ ਮਹੀਨੇ ਦੀ ਮਿਆਦ ਸ਼ਾਮਲ ਹੋਵੇਗੀ: [^2]

   train_start_dt = '2014-11-01 00:00:00'
   test_start_dt = '2014-12-30 00:00:00'
   

2. ਅੰਤਰਾਂ ਨੂੰ ਵਿਜੁਅਲਾਈਜ਼ ਕਰੋ: [^2]

   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 ਦੇ ਇੰਟਰਵਾਲ ਵਿੱਚ ਪ੍ਰੋਜੈਕਟ ਕਰਨ ਲਈ ਸਕੇਲਿੰਗ ਕਰੋ।

1. ਮੂਲ ਡਾਟਾਸੈਟ ਨੂੰ ਸਿਰਫ਼ ਉਪਰੋਕਤ ਸਮੇਂ ਦੀ ਮਿਆਦ ਅਤੇ ਸਿਰਫ਼ ਲੋੜੀਂਦਾ ਕਾਲਮ 'load' ਅਤੇ ਤਾਰੀਖ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਫਿਲਟਰ ਕਰੋ: [^2]

   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)
   

2. ਟ੍ਰੇਨਿੰਗ ਡਾਟਾ ਨੂੰ (0, 1) ਦੀ ਰੇਂਜ ਵਿੱਚ ਸਕੇਲ ਕਰੋ: [^2]

   scaler = MinMaxScaler()
   train['load'] = scaler.fit_transform(train)
   

3. ਹੁਣ, ਟੈਸਟਿੰਗ ਡਾਟਾ ਨੂੰ ਸਕੇਲ ਕਰੋ: [^2]

   test['load'] = scaler.transform(test)
   

ਟਾਈਮ-ਸਟੈਪਸ ਨਾਲ ਡਾਟਾ ਬਣਾਉਣਾ [^1]

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

Nested list comprehension ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਟ੍ਰੇਨਿੰਗ ਡਾਟਾ ਨੂੰ 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 ਲਾਗੂ ਕਰੋ [^1]

ਹੁਣ, SVR ਲਾਗੂ ਕਰਨ ਦਾ ਸਮਾਂ ਹੈ। ਇਸ ਲਾਗੂ ਕਰਨ ਬਾਰੇ ਹੋਰ ਪੜ੍ਹਨ ਲਈ, ਤੁਸੀਂ ਇਹ ਡੌਕੂਮੈਂਟੇਸ਼ਨ ਨੂੰ ਰਿਫਰ ਕਰ ਸਕਦੇ ਹੋ। ਸਾਡੇ ਲਾਗੂ ਕਰਨ ਲਈ, ਅਸੀਂ ਇਹ ਕਦਮ ਅਨੁਸਰਣ ਕਰਦੇ ਹਾਂ:

1. ਮਾਡਲ ਨੂੰ SVR() ਕਾਲ ਕਰਕੇ ਅਤੇ ਮਾਡਲ ਹਾਈਪਰਪੈਰਾਮੀਟਰਜ਼: kernel, gamma, c ਅਤੇ epsilon ਪਾਸ ਕਰਕੇ ਡਿਫਾਈਨ ਕਰੋ।
2. fit() ਫੰਕਸ਼ਨ ਕਾਲ ਕਰਕੇ ਟ੍ਰੇਨਿੰਗ ਡਾਟਾ ਲਈ ਮਾਡਲ ਤਿਆਰ ਕਰੋ।
3. predict() ਫੰਕਸ਼ਨ ਕਾਲ ਕਰਕੇ ਭਵਿੱਖਵਾਣੀ ਕਰੋ।

ਹੁਣ ਅਸੀਂ SVR ਮਾਡਲ ਬਣਾਉਂਦੇ ਹਾਂ। ਇੱਥੇ ਅਸੀਂ RBF kernel ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਅਤੇ gamma, C ਅਤੇ epsilon ਨੂੰ 0.5, 10 ਅਤੇ 0.05 ਵਜੋਂ ਸੈਟ ਕਰਦੇ ਹਾਂ।

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

ਟ੍ਰੇਨਿੰਗ ਡਾਟਾ 'ਤੇ ਮਾਡਲ ਫਿਟ ਕਰੋ [^1]

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)

ਮਾਡਲ ਦੀ ਭਵਿੱਖਵਾਣੀ ਕਰੋ [^1]

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 ਬਣ ਗਿਆ ਹੈ! ਹੁਣ ਅਸੀਂ ਇਸਦੀ ਮੁਲਾਂਕਣ ਕਰਦੇ ਹਾਂ।

ਆਪਣੇ ਮਾਡਲ ਦਾ ਮੁਲਾਂਕਣ ਕਰੋ [^1]

ਮੁਲਾਂਕਣ ਲਈ, ਪਹਿਲਾਂ ਅਸੀਂ ਡਾਟਾ ਨੂੰ ਆਪਣੇ ਮੂਲ ਸਕੇਲ ਵਿੱਚ ਵਾਪਸ ਸਕੇਲ ਕਰਦੇ ਹਾਂ। ਫਿਰ, ਪ੍ਰਦਰਸ਼ਨ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ, ਅਸੀਂ ਮੂਲ ਅਤੇ ਭਵਿੱਖਵਾਣੀ ਸਮੇਂ ਦੀ ਲੜੀ ਦਾ ਪਲਾਟ ਬਣਾਉਂਦੇ ਹਾਂ, ਅਤੇ 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))

ਟ੍ਰੇਨਿੰਗ ਅਤੇ ਟੈਸਟਿੰਗ ਡਾਟਾ 'ਤੇ ਮਾਡਲ ਪ੍ਰਦਰਸ਼ਨ ਦੀ ਜਾਂਚ ਕਰੋ [^1]

ਅਸੀਂ ਡਾਟਾਸੈਟ ਤੋਂ ਟਾਈਮਸਟੈਂਪਸ ਨੂੰ ਕੱਢਦੇ ਹਾਂ ਤਾਂ ਜੋ ਆਪਣੇ ਪਲਾਟ ਦੇ x-axis ਵਿੱਚ ਦਿਖਾ ਸਕੀਏ। ਧਿਆਨ ਦਿਓ ਕਿ ਅਸੀਂ ਪਹਿਲੇ 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 %

🏆 ਤੁਹਾਡੇ ਕੋਲ ਟੈਸਟਿੰਗ ਡਾਟਾਸੈਟ 'ਤੇ ਬਹੁਤ ਵਧੀਆ ਨਤੀਜਾ ਹੈ!

ਪੂਰੇ ਡਾਟਾਸੈਟ 'ਤੇ ਮਾਡਲ ਪ੍ਰਦਰਸ਼ਨ ਦੀ ਜਾਂਚ ਕਰੋ [^1]

# 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) ਨੂੰ ਬਦਲਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਅਤੇ ਡਾਟਾ 'ਤੇ ਮੁਲਾਂਕਣ ਕਰੋ ਤਾਂ ਜੋ ਪਤਾ ਲੱਗੇ ਕਿ ਕਿਹੜੇ ਹਾਈਪਰਪੈਰਾਮੀਟਰਜ਼ ਦਾ ਸੈੱਟ ਟੈਸਟਿੰਗ ਡਾਟਾ 'ਤੇ ਸਭ ਤੋਂ ਵਧੀਆ ਨਤੀਜੇ ਦਿੰਦਾ ਹੈ। ਇਨ੍ਹਾਂ ਹਾਈਪਰਪੈਰਾਮੀਟਰਜ਼ ਬਾਰੇ ਹੋਰ ਜਾਣਨ ਲਈ, ਤੁਸੀਂ ਇਹ ਡੌਕੂਮੈਂਟ ਨੂੰ ਰਿਫਰ ਕਰ ਸਕਦੇ ਹੋ।
• ਮਾਡਲ ਲਈ ਵੱਖ-ਵੱਖ kernel functions ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਅਤੇ ਡਾਟਾਸੈਟ 'ਤੇ ਉਨ੍ਹਾਂ ਦੇ ਪ੍ਰਦਰਸ਼ਨ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੋ। ਇੱਕ ਮਦਦਗਾਰ ਡੌਕੂਮੈਂਟ ਇੱਥੇ ਮਿਲ ਸਕਦਾ ਹੈ।
• ਮਾਡਲ ਨੂੰ ਭਵਿੱਖਵਾਣੀ ਕਰਨ ਲਈ ਵੱਖ-ਵੱਖ timesteps ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ।

ਪੋਸਟ-ਲੈਕਚਰ ਕਵਿਜ਼

ਸਮੀਖਿਆ ਅਤੇ ਸਵੈ-ਅਧਿਐਨ

ਇਹ ਪਾਠ ਸਮੇਂ ਦੀ ਲੜੀ ਦੀ ਭਵਿੱਖਵਾਣੀ ਲਈ SVR ਦੀ ਅਰਜ਼ੀ ਨੂੰ ਪੇਸ਼ ਕਰਨ ਲਈ ਸੀ। SVR ਬਾਰੇ ਹੋਰ ਪੜ੍ਹਨ ਲਈ, ਤੁਸੀਂ ਇਹ ਬਲੌਗ ਨੂੰ ਰਿਫਰ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ scikit-learn ਡੌਕੂਮੈਂਟੇਸ਼ਨ SVMs ਦੇ ਬਾਰੇ ਵਿੱਚ ਇੱਕ ਵਧੇਰੇ ਵਿਸਤ੍ਰਿਤ ਵਿਆਖਿਆ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, SVRs ਅਤੇ ਹੋਰ ਲਾਗੂ ਕਰਨ ਦੇ ਵੇਰਵੇ ਜਿਵੇਂ ਕਿ ਵੱਖ-ਵੱਖ kernel functions ਜੋ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ, ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਪੈਰਾਮੀਟਰਜ਼।

---

ਅਸਵੀਕਤੀ:
ਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ Co-op Translator ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀਤਾ ਲਈ ਯਤਨਸ਼ੀਲ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸੁਚਨਾਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਇਸਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਅਧਿਕਾਰਤ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਅਸੀਂ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।