24 KiB

Raw Permalink Blame History

การพยากรณ์ข้อมูลอนุกรมเวลาด้วย Support Vector Regressor

ในบทเรียนก่อนหน้านี้ คุณได้เรียนรู้วิธีใช้โมเดล ARIMA เพื่อทำการพยากรณ์ข้อมูลอนุกรมเวลา ในบทนี้ คุณจะได้เรียนรู้เกี่ยวกับโมเดล Support Vector Regressor ซึ่งเป็นโมเดลสำหรับการพยากรณ์ข้อมูลแบบต่อเนื่อง

แบบทดสอบก่อนเรียน

บทนำ

ในบทเรียนนี้ คุณจะได้ค้นพบวิธีการสร้างโมเดลด้วย SVM: Support Vector Machine สำหรับการพยากรณ์ หรือที่เรียกว่า SVR: Support Vector Regressor

SVR ในบริบทของข้อมูลอนุกรมเวลา ¹

ก่อนที่จะเข้าใจความสำคัญของ SVR ในการพยากรณ์ข้อมูลอนุกรมเวลา ต่อไปนี้คือแนวคิดสำคัญที่คุณควรรู้:

Regression: เทคนิคการเรียนรู้แบบมีผู้สอนที่ใช้ในการพยากรณ์ค่าต่อเนื่องจากชุดข้อมูลที่กำหนด แนวคิดคือการหาค่าที่เหมาะสมที่สุดในพื้นที่ฟีเจอร์ที่มีจุดข้อมูลมากที่สุด คลิกที่นี่ เพื่อดูข้อมูลเพิ่มเติม
Support Vector Machine (SVM): โมเดลการเรียนรู้แบบมีผู้สอนที่ใช้สำหรับการจัดประเภท การพยากรณ์ และการตรวจจับค่าผิดปกติ โมเดลนี้จะสร้างไฮเปอร์เพลนในพื้นที่ฟีเจอร์ ซึ่งในกรณีของการจัดประเภทจะทำหน้าที่เป็นเส้นแบ่ง และในกรณีของการพยากรณ์จะทำหน้าที่เป็นเส้นที่เหมาะสมที่สุด โดยทั่วไป SVM จะใช้ฟังก์ชัน Kernel เพื่อแปลงชุดข้อมูลไปยังพื้นที่ที่มีมิติสูงขึ้นเพื่อให้สามารถแยกได้ง่ายขึ้น คลิกที่นี่ เพื่อดูข้อมูลเพิ่มเติมเกี่ยวกับ SVM
Support Vector Regressor (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 dataframe และดูข้อมูล: ²
```
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 คุณจะฝึกโมเดลของคุณบนชุดฝึก หลังจากที่โมเดลฝึกเสร็จแล้ว คุณจะประเมินความแม่นยำของมันบนชุดฝึก ชุดทดสอบ และชุดข้อมูลทั้งหมดเพื่อดูประสิทธิภาพโดยรวม คุณต้องมั่นใจว่าชุดทดสอบครอบคลุมช่วงเวลาที่เกิดขึ้นหลังจากชุดฝึกเพื่อให้แน่ใจว่าโมเดลไม่ได้รับข้อมูลจากช่วงเวลาในอนาคต ² (สถานการณ์นี้เรียกว่า Overfitting)

กำหนดช่วงเวลาสองเดือนตั้งแต่วันที่ 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 tensor โดยใช้ nested list comprehension:

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 tensor:

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))

ตรวจสอบประสิทธิภาพโมเดลบนข้อมูลชุดฝึกและชุดทดสอบ ¹

เราจะดึง timestamps จากชุดข้อมูลเพื่อแสดงในแกน x ของกราฟ โปรดทราบว่าเราใช้ timesteps-1 ค่าแรกเป็นอินพุตสำหรับเอาต์พุตแรก ดังนั้น timestamps สำหรับเอาต์พุตจะเริ่มหลังจากนั้น

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) ขณะสร้างโมเดลและประเมินผลบนข้อมูลเพื่อดูว่าชุดไฮเปอร์พารามิเตอร์ใดให้ผลลัพธ์ที่ดีที่สุดบนข้อมูลชุดทดสอบ หากต้องการทราบข้อมูลเพิ่มเติมเกี่ยวกับไฮเปอร์พารามิเตอร์เหล่านี้ คุณสามารถดูเอกสาร ที่นี่
ลองใช้ฟังก์ชัน kernel แบบต่างๆ สำหรับโมเดลและวิเคราะห์ประสิทธิภาพของพวกมันบนชุดข้อมูล เอกสารที่เป็นประโยชน์สามารถดูได้ ที่นี่
ลองใช้ค่าที่แตกต่างกันสำหรับ timesteps เพื่อให้โมเดลย้อนกลับไปดูข้อมูลเพื่อทำการพยากรณ์

แบบทดสอบหลังเรียน

ทบทวนและศึกษาด้วยตนเอง

บทเรียนนี้เป็นการแนะนำการใช้ SVR สำหรับการพยากรณ์ข้อมูลอนุกรมเวลา หากต้องการอ่านเพิ่มเติมเกี่ยวกับ SVR คุณสามารถดูได้ที่ บล็อกนี้ เอกสารนี้ scikit-learn documentation ให้คำอธิบายที่ครอบคลุมมากขึ้นเกี่ยวกับ SVM โดยทั่วไป SVRs และรายละเอียดการใช้งานอื่นๆ เช่น ฟังก์ชัน kernel ที่สามารถใช้ได้และพารามิเตอร์ของพวกมัน

งานที่ได้รับมอบหมาย

โมเดล SVR ใหม่

เครดิต

ข้อจำกัดความรับผิดชอบ:
เอกสารนี้ได้รับการแปลโดยใช้บริการแปลภาษา AI Co-op Translator แม้ว่าเราจะพยายามให้การแปลมีความถูกต้อง แต่โปรดทราบว่าการแปลอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่แม่นยำ เอกสารต้นฉบับในภาษาต้นทางควรถือเป็นแหล่งข้อมูลที่เชื่อถือได้ สำหรับข้อมูลที่สำคัญ ขอแนะนำให้ใช้บริการแปลภาษาจากผู้เชี่ยวชาญ เราไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความที่ผิดพลาดซึ่งเกิดจากการใช้การแปลนี้

ข้อความ โค้ด และผลลัพธ์ในส่วนนี้ได้รับการสนับสนุนโดย @AnirbanMukherjeeXD ↩︎
ข้อความ โค้ด และผลลัพธ์ในส่วนนี้นำมาจาก ARIMA ↩︎

24 KiB Raw Permalink Blame History