将时间序列转化为监督学习问题

最新推荐文章于 2022-05-14 17:45:49 发布
最新推荐文章于 2022-05-14 17:45:49 发布
阅读量1.6k 收藏 15
点赞数 3
分类专栏： 时间序列预测 文章标签： 学习 数据挖掘 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39215918/article/details/123410290
版权

这里提供两种不同的数据划分方式，看喜好选择了鸭

第一种数据划分的方式

pandas的shift()函数

import pandas as pd
df = pd.DataFrame()
df["time"] = [x for x in range(10)]
df
time
00
11
22
33
44
55
66
77
88
99
df["time-1"] = df["time"].shift(1)
df
timetime-1
00NaN
110.0
221.0
332.0
443.0
554.0
665.0
776.0
887.0
998.0
df["time+1"] = df["time"].shift(-1)
df
timetime-1time+1
00NaN1.0
110.02.0
221.03.0
332.04.0
443.05.0
554.06.0
665.07.0
776.08.0
887.09.0
998.0NaN
df["time+2"] = df["time"].shift(-2)
df
timetime-1time+1time+2
00NaN1.02.0
110.02.03.0
221.03.04.0
332.04.05.0
443.05.06.0
554.06.07.0
665.07.08.0
776.08.09.0
887.09.0NaN
998.0NaNNaN

在时间序列预测问题中， 当前时间t和未来时间(t+1,t+n)被称为预测时间，过去的观测值(t-1,t-n)是用于预测的

新的数据集被构造为Dataframe，每列根据变量的编号以及该列左移或者右移的步长命名

def series_to_supervisied(data,step_in,step_out,dropnan = True):
    """
    param:data观测序列，类型为列表或者二维的numpy数组
    param:step_in:作为输入滞后观测值数量(x)
    param:step_out:作为输出的观测值为(y)
    param:dropnan:是否删除具有NaN的行，称为bool,默认为True
    
    return:为监督学习重组得到的dataframe序列
    """
    n_vars = 1 if type(data) is list else data.shape[1]
    df = pd.DataFrame(data)
    cols,names = [],[]
    #输入序列(t-n,t-(n+1),t-(n+2)...t-1)
    for i in range(step_in,0,-1):
        cols.append(df.shift(i))
        names+=[("var%d(t-%d)"%(j+1,i)) for j in range(n_vars)]
    
    #预测序列（t+1,t+2...t+n）
    for i in range(0,step_out):
        cols.append(df.shift(-i))
        names+=[("var%d(t+%d)"%(j+1,i)) for j in range(n_vars)]
    
    agg = pd.concat(cols,axis=1)
    agg.columns = names
    if dropnan:
        agg.dropna(inplace=True)
    return  agg

values = [x for x in range(10)]
data = series_to_supervisied(data=values,step_in=1,step_out=1)
data
var1(t-1)var1(t+0)
10.01
21.02
32.03
43.04
54.05
65.06
76.07
87.08
98.09
def series_to_supervisied_(data,step_in,step_out,dropnan = True):
    """
    param:data观测序列，类型为列表或者二维的numpy数组
    param:step_in:作为输入滞后观测值数量(x)
    param:step_out:作为输出的观测值为(y)
    param:dropnan:是否删除具有NaN的行，称为bool,默认为True
    
    return:为监督学习重组得到的dataframe序列
    """
    n_vars = 1 if type(data) is list else data.shape[1]
    df = pd.DataFrame()
    df_time_in =pd.DataFrame() 
    df_time_out = pd.DataFrame()
    df["time"] =data 
    #输入序列(t-n,t-(n+1),t-(n+2)...t-1)
    for i in range(step_in,0,-1):
        name = "step_"+"time-"+str(i)
        print(name)
        df_time_in[name] = df["time"].shift(i)
        print(name)
    
    #预测序列（t+1,t+2...t+n）
    for i in range(1,step_out+1):
        name = "step_"+"time+"+str(i)
        print(name)
        df_time_out[name] = df["time"].shift(-i)
        print(name)
    df_re = pd.concat([df_time_in,df,df_time_out],axis =1)
    del df,df_time_in,df_time_out
    if dropnan:
        df_re.dropna(inplace=True)
    return  df_re

values = [x for x in range(10)]
data = series_to_supervisied_(data=values,step_in=3,step_out=0)
data

step_time-3
step_time-3
step_time-2
step_time-2
step_time-1
step_time-1
step_time-3step_time-2step_time-1time
30.01.02.03
41.02.03.04
52.03.04.05
63.04.05.06
74.05.06.07
85.06.07.08
96.07.08.09

单步单变量预测

用(t-1)作为输入变量预测当前时间的观测值(t),同理，可以指定任意长度的输入

def series_to_supervisied_(data,step_in,step_out,dropnan = True):
    """
    param:data观测序列，类型为列表或者二维的numpy数组
    param:step_in:作为输入滞后观测值数量(x)
    param:step_out:作为输出的观测值为(y)
    param:dropnan:是否删除具有NaN的行，称为bool,默认为True
    
    return:为监督学习重组得到的dataframe序列
    """
    n_vars = 1 if type(data) is list else data.shape[1]
    df = pd.DataFrame()
    df_time_in =pd.DataFrame() 
    df_time_out = pd.DataFrame()
    df["time"] =data 
    #输入序列(t-n,t-(n+1),t-(n+2)...t-1)
    for i in range(step_in,0,-1):
        name = "step_"+"time-"+str(i)
        df_time_in[name] = df["time"].shift(i)
    
    
    #预测序列（t+1,t+2...t+n）
    for i in range(0,step_out):
        name = "step_"+"time+"+str(i)
      
        df_time_out[name] = df["time"].shift(-i)
   
    df_re = pd.concat([df_time_in,df_time_out],axis =1)
    del df,df_time_in,df_time_out
    if dropnan:
        df_re.dropna(inplace=True)
    return  df_re

values = [x for x in range(10)]
data = series_to_supervisied_(data=values,step_in=1,step_out=1)
data
step_time-1step_time+0
10.01
21.02
32.03
43.04
54.05
65.06
76.07
87.08
98.09
def series_to_supervisied_(data,step_in,step_out,dropnan = True):
    """
    param:data观测序列，类型为列表或者二维的numpy数组
    param:step_in:作为输入滞后观测值数量(x)
    param:step_out:作为输出的观测值为(y)
    param:dropnan:是否删除具有NaN的行，称为bool,默认为True
    
    return:为监督学习重组得到的dataframe序列
    """
    n_vars = 1 if type(data) is list else data.shape[1]
    df = pd.DataFrame()
    df_time_in =pd.DataFrame() 
    df_time_out = pd.DataFrame()
    df["time"] =data 
    #输入序列(t-n,t-(n+1),t-(n+2)...t-1)
    for i in range(step_in,0,-1):
        name = "step_"+"time-"+str(i)
        df_time_in[name] = df["time"].shift(i)
    
    
    #预测序列（t+1,t+2...t+n）
    for i in range(0,step_out):
        name = "step_"+"time+"+str(i)
      
        df_time_out[name] = df["time"].shift(-i)
   
    df_re = pd.concat([df_time_in,df_time_out],axis =1)
    del df,df_time_in,df_time_out
    if dropnan:
        df_re.dropna(inplace=True)
    return  df_re

values = [x for x in range(10)]
data = series_to_supervisied_(data=values,step_in=2,step_out=1)
data
step_time-2step_time-1step_time+0
20.01.02
31.02.03
42.03.04
53.04.05
64.05.06
75.06.07
86.07.08
97.08.09

多步预测

def series_to_supervisied_(data,step_in,step_out,dropnan = True):
    """
    param:data观测序列，类型为列表或者二维的numpy数组
    param:step_in:作为输入滞后观测值数量(x)
    param:step_out:作为输出的观测值为(y)
    param:dropnan:是否删除具有NaN的行，称为bool,默认为True
    
    return:为监督学习重组得到的dataframe序列
    """
    n_vars = 1 if type(data) is list else data.shape[1]
    df = pd.DataFrame()
    df_time_in =pd.DataFrame() 
    df_time_out = pd.DataFrame()
    df["time"] =data 
    #输入序列(t-n,t-(n+1),t-(n+2)...t-1)
    for i in range(step_in,0,-1):
        name = "step_"+"time-"+str(i)
        df_time_in[name] = df["time"].shift(i)
    
    
    #预测序列（t+1,t+2...t+n）
    for i in range(0,step_out):
        name = "step_"+"time+"+str(i)
      
        df_time_out[name] = df["time"].shift(-i)
   
    df_re = pd.concat([df_time_in,df_time_out],axis =1)
    del df,df_time_in,df_time_out
    if dropnan:
        df_re.dropna(inplace=True)
    return  df_re

values = [x for x in range(10)]
data = series_to_supervisied_(data=values,step_in=2,step_out=2)
data
step_time-2step_time-1step_time+0step_time+1
20.01.023.0
31.02.034.0
42.03.045.0
53.04.056.0
64.05.067.0
75.06.078.0
86.07.089.0

多变量预测

def series_to_superivsed(data,step_in =1,step_out=1,dropnan = True):
    """
    param:data观测序列，类型为列表或者二维的numpy数组
    param:step_in:作为输入滞后观测值数量(x)
    param:step_out:作为输出的观测值为(y)
    param:dropnan:是否删除具有NaN的行，称为bool,默认为True
    
    return:为监督学习重组得到的dataframe序列
    """
    n_vars = 1 if type(data) is list else data.shape[1]
    df = pd.DataFrame(data)
    cols = []
    names = []
    #输入序列：[(t-n),(t-n+1).....(t-1)]
    for i in range(step_in,0,-1):
        cols.append(df.shift(i))
        names+=[("var%d(t-%d)"%(j+1,i)) for j in range(n_vars)]
    #预测序列[t,(t+1),(t+2)....(t+n)]
    for i in range(0,step_out):
        cols.append(df.shift(-i))
        if i ==0:
            names += [('var%d(t)' % (j+1)) for j in range(n_vars)]
        else:
            names+=[("var%d(t+%d)"%(j+1,i)) for j in range(n_vars)]
            
    df_re = pd.concat(cols,axis=1)
    df_re.columns = names
    if dropnan:
        df_re.dropna(inplace =True)
    return df_re
raw = pd.DataFrame()

raw['ob1'] = [x for x in range(10)]
raw['ob2'] = [x for x in range(50, 60)]
values = raw.values
data = series_to_superivsed(values)
data
var1(t-1)var2(t-1)var1(t)var2(t)
10.050.0151
21.051.0252
32.052.0353
43.053.0454
54.054.0555
65.055.0656
76.056.0757
87.057.0858
98.058.0959
raw['ob1'] = [x for x in range(10)]
raw['ob2'] = [x for x in range(50, 60)]
values = raw.values
data = series_to_superivsed(values,1,2)
data
var1(t-1)var2(t-1)var1(t)var2(t)var1(t+1)var2(t+1)
10.050.01512.052.0
21.051.02523.053.0
32.052.03534.054.0
43.053.04545.055.0
54.054.05556.056.0
65.055.06567.057.0
76.056.07578.058.0
87.057.08589.059.0

第二种数据划分的方式

索引数据
010
120
230
340
450
560
670
780
890
9100
10110

假如time_step（3）个步长预测一个样本 ,得到如下表

索引xy
010,20,3040
120,30,4050
230,40,5060
340,50,6070
450,60,7080
560,70,8090
670,80,90100
780,90,100110
890,100,110?
9100,110,???
10110,?,?????
import numpy as np 
def split_sequence(sequence,n_steps):
    x,y = [],[]
    for i in range(len(sequence)):
        #找到步长的最后一个值
        end_idx = i+n_steps
        if end_idx>len(sequence)-1:
            break
        input_x,input_y = sequence[i:end_idx],sequence[end_idx]
        x.append(input_x)
        y.append(input_y)
    return np.array(x),np.array(y)
raw_seq = [10,20,30,40,50,60,70,80,90]
n_steps = 3
x,y = split_sequence(raw_seq,n_steps)
for i in range(len(x)):
    print(x[i],y[i])

[10 20 30] 40
[20 30 40] 50
[30 40 50] 60
[40 50 60] 70
[50 60 70] 80
[60 70 80] 90

多变量时间序列是指每个时间步长有一个观测值的数据

多个输入的系列·

索引x1,x2y
010,1525
120,2545
230,3565
340,4585
450,55105
560,65125
670,75145
780,85165
890,95185
in_seq1 =np. array([10, 20, 30, 40, 50, 60, 70, 80, 90])
in_seq2 = np.array([15, 25, 35, 45, 55, 65, 75, 85, 95])
out_seq = np.array([in_seq1[i]+in_seq2[i] for i in range(len(in_seq1))])



array([ 25,  45,  65,  85, 105, 125, 145, 165, 185])

in_seq1 = in_seq1.reshape((len(in_seq1), 1))
in_seq2 = in_seq2.reshape((len(in_seq2), 1))
out_seq = out_seq.reshape((len(out_seq), 1))

data = np.hstack((in_seq1,in_seq2,out_seq))
data

array([[ 10,  15,  25],
       [ 20,  25,  45],
       [ 30,  35,  65],
       [ 40,  45,  85],
       [ 50,  55, 105],
       [ 60,  65, 125],
       [ 70,  75, 145],
       [ 80,  85, 165],
       [ 90,  95, 185]])
索引x1,x2y
010,15
120,25
230,3565
320,25
430,35
540,4585
6……
def split_sequence(sequence,n_steps):
    x,y = [],[]
    for i in range(len(sequence)):
        end_idx = i+n_steps
        if end_idx>len(sequence):
            break
        input_x,input_y = sequence[i:end_idx,:-1],sequence[end_idx-1,-1]
        x.append(input_x)
        y.append(input_y)
    return np.array(x),np.array(y)

n_steps = 3
x,y = split_sequence(data,n_steps)
for i in range(len(x)):
    print(x[i], y[i])
    print("="*15)


[[10 15]
 [20 25]
 [30 35]] 65
===============
[[20 25]
 [30 35]
 [40 45]] 85
===============
[[30 35]
 [40 45]
 [50 55]] 105
===============
[[40 45]
 [50 55]
 [60 65]] 125
===============
[[50 55]
 [60 65]
 [70 75]] 145
===============
[[60 65]
 [70 75]
 [80 85]] 165
===============
[[70 75]
 [80 85]
 [90 95]] 185
===============

多个序列输出

索引x1,x2y
010,1525
120,2545
230,3565
340,4585
450,55105
560,65125
670,75145
780,85165
890,95185
索引x1,x2y
010,1525
120,2545
230,3565
输出
340,4585
def split_sequence(sequences,n_step):
    x,y = [],[]
    for i in range(len(sequences)):
        end_idx = i+n_step
        if end_idx>len(sequences)-1:
            break
        input_x,input_y = sequences[i:end_idx,:],sequences[end_idx,:]
        x.append(input_x)
        y.append(input_y)
    return np.array(x),np.array(y)

in_seq1 = np.array([10, 20, 30, 40, 50, 60, 70, 80, 90])
in_seq2 = np.array([15, 25, 35, 45, 55, 65, 75, 85, 95])
out_seq = np.array([in_seq1[i]+in_seq2[i] for i in range(len(in_seq1))])

in_seq1 = in_seq1.reshape((len(in_seq1), 1))
in_seq2 = in_seq2.reshape((len(in_seq2), 1))
out_seq = out_seq.reshape((len(out_seq), 1))

data =np. hstack((in_seq1, in_seq2, out_seq))
n_steps = 3
x,y = split_sequence(data,n_steps)
for i in range(len(x)):
    print(x[i], y[i])
    print("="*20)

[[10 15 25]
 [20 25 45]
 [30 35 65]] [40 45 85]
====================
[[20 25 45]
 [30 35 65]
 [40 45 85]] [ 50  55 105]
====================
[[ 30  35  65]
 [ 40  45  85]
 [ 50  55 105]] [ 60  65 125]
====================
[[ 40  45  85]
 [ 50  55 105]
 [ 60  65 125]] [ 70  75 145]
====================
[[ 50  55 105]
 [ 60  65 125]
 [ 70  75 145]] [ 80  85 165]
====================
[[ 60  65 125]
 [ 70  75 145]
 [ 80  85 165]] [ 90  95 185]
====================

多个输入，多个输出

索引数据
010
120
230
340
450
560
670
780
890
9100
10110
索引数据
010
120
230
输出
340
450
560
def split_sequence(sequence,n_steps_in,n_steps_out):
    x,y =[],[]
    for i in range(len(sequence)):
        end_idx = i+n_steps_in
        out_end_idx = end_idx + n_steps_out
        
        if out_end_idx>len(sequence):
            break
        
        input_x,input_y = sequence[i:end_idx],sequence[end_idx:out_end_idx]
        x.append(input_x)
        y.append(input_y)
    return np.array(x),np.array(y)



raw_seq = [10, 20, 30, 40, 50, 60, 70, 80, 90]

n_steps_in, n_steps_out = 3, 2
x, y = split_sequence(raw_seq, n_steps_in, n_steps_out)
for i in range(len(x)):
    print(x[i], y[i])
    print("="*20)

[10 20 30] [40 50]
====================
[20 30 40] [50 60]
====================
[30 40 50] [60 70]
====================
[40 50 60] [70 80]
====================
[50 60 70] [80 90]
====================

多个维度的输入输出

索引x1,x2y
010,1525
120,2545
230,3565
340,4585
450,55105
560,65125
670,75145
780,85165
890,95185
索引x1,x2y
010,15
120,25
230,35
输出
365
485
def split_sequence(sequences,n_steps_in,n_steps_out):
    x,y = [],[]
    for i in range(len(sequences)):
        end_idx = i+n_steps_in
        out_end_idx = end_idx+n_steps_out-1
        if out_end_idx>len(sequences):
            break
        input_x,input_y = sequences[i:end_idx,:-1],sequences[end_idx-1:out_end_idx,-1]
        x.append(input_x)
        y.append(input_y)
    return np.array(x),np.array(y)


in_seq1 = np.array([10, 20, 30, 40, 50, 60, 70, 80, 90])
in_seq2 = np.array([15, 25, 35, 45, 55, 65, 75, 85, 95])
out_seq = np.array([in_seq1[i]+in_seq2[i] for i in range(len(in_seq1))])
# convert to [rows, columns] structure
in_seq1 = in_seq1.reshape((len(in_seq1), 1))
in_seq2 = in_seq2.reshape((len(in_seq2), 1))
out_seq = out_seq.reshape((len(out_seq), 1))
data = np.hstack((in_seq1, in_seq2, out_seq))
n_steps_in, n_steps_out = 3, 2
x, y = split_sequence(data, n_steps_in, n_steps_out)
for i in range(len(x)):
    print(x[i], y[i])
    print("="*30)

[[10 15]
 [20 25]
 [30 35]] [65 85]
==============================
[[20 25]
 [30 35]
 [40 45]] [ 85 105]
==============================
[[30 35]
 [40 45]
 [50 55]] [105 125]
==============================
[[40 45]
 [50 55]
 [60 65]] [125 145]
==============================
[[50 55]
 [60 65]
 [70 75]] [145 165]
==============================
[[60 65]
 [70 75]
 [80 85]] [165 185]
==============================
索引x1,x2y
010,1525
120,2545
230,3565
340,4585
450,55105
560,65125
670,75145
780,85165
890,95185
索引x1,x2y
010,1525
120,2545
230,3565
340,4585
输出
450,55105
560,65125
def split_sequences(sequences,n_steps_in,n_steps_out):
    x,y = [],[]
    for i in range(len(sequences)):
        end_idx = i+n_steps_in
        out_end_idx = end_idx+n_steps_out
        
        if out_end_idx>len(sequences):
            break
        input_x,input_y = sequences[i:end_idx,:],sequences[end_idx:out_end_idx,:]
        x.append(input_x)
        y.append(input_y)
    return np.array(x),np.array(y)

in_seq1 = np.array([10, 20, 30, 40, 50, 60, 70, 80, 90])
in_seq2 = np.array([15, 25, 35, 45, 55, 65, 75, 85, 95])
out_seq = np.array([in_seq1[i]+in_seq2[i] for i in range(len(in_seq1))])

in_seq1 = in_seq1.reshape((len(in_seq1), 1))
in_seq2 = in_seq2.reshape((len(in_seq2), 1))
out_seq = out_seq.reshape((len(out_seq), 1))

dataset = np.hstack((in_seq1, in_seq2, out_seq))
n_steps_in, n_steps_out = 3, 2
X, y = split_sequences(dataset, n_steps_in, n_steps_out)
for i in range(len(X)):
    print(X[i], y[i])
    print("="*30)

[[10 15 25]
 [20 25 45]
 [30 35 65]] [[ 40  45  85]
 [ 50  55 105]]
==============================
[[20 25 45]
 [30 35 65]
 [40 45 85]] [[ 50  55 105]
 [ 60  65 125]]
==============================
[[ 30  35  65]
 [ 40  45  85]
 [ 50  55 105]] [[ 60  65 125]
 [ 70  75 145]]
==============================
[[ 40  45  85]
 [ 50  55 105]
 [ 60  65 125]] [[ 70  75 145]
 [ 80  85 165]]
==============================
[[ 50  55 105]
 [ 60  65 125]
 [ 70  75 145]] [[ 80  85 165]
 [ 90  95 185]]
==============================
我也要做小太阳
关注
专栏目录
将时间序列转换为监督学习数据
段智华的博客
11-25 1905
将时间序列转换为监督学习数据： https://machinelearningmastery.com/convert-time-series-supervised-learning-problem-python/ 其中的一个例子： from pandas import DataFrame from pandas import concat def series_to_supervis...
如何将时间序列转化为监督学习
To be a better man
03-12 352
参考资料： 如何将时间序列转化为监督学习 - 知乎 🍞正在为您运送作品详情
如何把时间序列问题转化为监督学习问题？通俗易懂的 Python 教程
weixin_34236497的博客
08-02 902
Jason Brownlee 机器学习方法，比如深度学习，是可以用来解决时间序列预测问题的。 但在使用机器学习之前，时间序列问题需要被转化为监督学习问题。从仅仅是一个序列，变成成对的输入、输出序列。 这篇教程里，你将学到如何把单变量、多变量时间序列问题转为机器学习算法能解决的监督学习问题。本教程包含： 如何创建把时间序列数据集转为监督学习数据集...
如何将时间序列预测转换为监督学习问题
weixin_45694013的博客
12-07 4459
时间序列转化为监督学习时间序列与监督学习利用Pandas的shift()函数series_to_supervised（） 功能单变量时间序列多变量时间序列总结 时间序列预测可以被认为是监督学习问题。只需要对数据进行转换，重新构建时间序列数据，使其转变为监督学习即可。 时间序列与监督学习 时间序列是按时间索引排序的数字序列，可视为有序值的列表或列。比如下面这个例子： 0 1 2 3 4 5 6 7 8 9 #时间序列 监督学习是具有输入变量（X）和输出变量（Y）的的问题，并且可以使用算法来学习x到y的映
时间序列预测01：如何将时间序列预测转化为监督学习问题
stay hungry, stay foolish
04-06 1万+
时间序列预测可以被构造为一个监督学习问题。通过对时间序列数据的重构，可以针对不同问题使用相关的机器学习算法。本文介绍了如何将时间序列问题重新构造为机器学习中的监督学习问题。
时间序列预测作为监督学习
缘分天空，美丽的梦的博客
05-03 2940
本文翻译杰森布朗利博士的博文，如想查看原文请点击链接时间序列预测可以被定义为监督学习问题。对时间序列数据进行重新组可以让你访问针对您问题的标准线性和非线性机器学习算法。在这篇文章中，您将发现如何将你的时间序列问题重新组织为机器学习的监督学习问题。阅读这篇文章后你将会知道：什么是监督式学习，以及它是如何成为所有预测性建模机器学习算法的基础用于构建时间序列数据集的滑动窗口方法以及如何使用它。如何使用滑...
使用SageMaker+XGBoost，将时间序列转换为监督学习，完成预测性维护的实践.zip
最新发布
10-29
本文将详细介绍如何利用Amazon SageMaker和XGBoost将时间序列数据转换为监督学习问题，从而实现预测性维护的实践过程。 首先，Amazon SageMaker是亚马逊云服务（AWS）提供的一款全托管的机器学习服务，它简化了模型...
如何将时间序列数据转换为监督学习问题
03-29
将时间序列数据转换为监督学习问题的方法是将其转换为一个有监督的学习问题，其中目标变量是未来的时间步骤中的值。 具体步骤如下： 1. 确定时间步长：将时间序列数据分为多个时间步长，每个时间步长包含一组输入...
将时间序列转换为监督学习有什么用
04-02
而监督学习算法需要的是输入和输出之间的关系，因此需要将时间序列数据转换为监督学习问题。 这种转换方式可以将时间序列数据转换为一个有监督学习问题，例如将前一天的天气数据作为输入，预测当天的天气情况。这种...
时间序列的无监督特征学习
03-06
谱分析是另一种技术，它可以将时间序列数据从时间域转换到频率域，帮助提取时间序列中的周期性和趋势性信息。正则化最小二乘法是一种为了防止模型过拟合而设计的优化方法，它通过在目标函数中加入正则化项来限制模型...
机器学习中时间序列数据的训练集、验证集、测试集处理问题
GlaDOS.AI的博客
12-19 2万+
机器学习中对于时间序列的数据进行train、val、test划分时需要注意的问题是，不要将val中的数据出现在train中，准确的说，是选取的val数据的时间节点不能与train中数据时间节点有任何交集。否则，你会发现训练时，val的loss会与train的loss几乎一样，即失去其作用。因为，对于时间序列预测这种任务，如果你的验证集中与训练集中时间上出现重叠，模型会在训练时记忆你训练集中出现的重...
时间序列预测基础教程系列(2)_用构建监督学习型数据进行时间序列预测
AI量化交易实验室
12-14 2211
时间序列预测可以被视为监督学习问题。 通过重新构建时间序列数据，您可以访问针对您的问题的标准线性和非线性机器学习算法套件。 在这篇文章中，您将了解如何重新构建时间序列问题，作为机器学习的监督学习问题。阅读这篇文章后，你会知道： 什么是监督学习，以及它是如何成为所有预测建模机器学习算法的基础。 用于构建时间序列数据集的滑动窗口方法以及如何使用它。 如何使用滑动窗口进行多变量数据和多步预测。...
时间序列预测——LSTM模型（附代码实现）
热门推荐
JJJAY
05-14 8万+
长短时记忆网络（ Long short-term memory，LSTM ）是一种循环神经网络 (Recurrent neural network, RNN)的特殊变体。
如何将时间序列问题转化为监督学习问题
落尘
03-13 1万+
如何将时间序列问题转化为监督学习问题 如何将时间序列问题转化为监督学习问题 1.学习目标: 2.时间序列 vs 监督学习 3.pandas shift() 函数 4.series_to_supervised() 函数 5.单步单变量预测(One-Step Univariate Forecasting) 6.多步或序列预测(Multi-Step or Sequence Forecasting)...
如何将时间序列预测问题转换为python中的监督学习问题
菜鸟很菜的专栏
11-05 5327
原文：《How to Convert a Time Series to a Supervised Learning Problem in Python》 一、前言 像深度学习这样的机器学习方法可以用于时间序列预测。 在可以使用机器学习之前，时间序列预测问题必须重新构建成监督学习问题，从一个单纯的序列变成一对序列输入和输出。 在本教程中，您将了解如何将单变量和多变量时间序列预测问题转换为
如何将时间序列转换为Python中的监督学习问题（1）
真梦行路的博客
07-10 3316
  深度学习等机器学习方法可用于时间序列预测。 在可以使用机器学习之前，必须将时间序列预测问题重新定义为监督学习问题。从序列到输入和输出序列对。 在本教程中，您将了解如何将单变量和多变量时间序列预测问题转换为监督学习问题，以便与机器学习算法一起使用。 完成本教程后，您将了解： 如何开发将时间序列数据集转换为监督学习数据集的函数。 如何转换用于机器学习的单变量时间序列数据。 如何转换多...
将含时间序列字段的数据集转换为一般的监督学习问题（python）
abc200941410128的博客
12-28 711
一、前言： 时间序列算法的局限性 一是，可用的算法较少，一般机器学习算法都不适用。无论是单一字段的时间序列还是多元时间序列，在现实场景中可用的算法都比较固定，一般都是（单一ARIMA,多元VARMAX）2种算法的延伸或者变种。 二是，应用场景不多，往往都伴随着其他非时间序列的影响因素（如，性别，地区等数值或非数值类型）。 二、方法介绍 1、时间上的因素拉平 标题可能起的不太好，意思很简单，就是将前1天~前n天的数都作为影响因素/字段（需要后几天的同理）。代码如下： ###序列特征转监督学习 def seri
时间序列（单变量/多变量+多个步预测）
kylin_learn的博客
12-20 1万+
''' 用之前时间预测往后不止是一步，而是多步 ''' from numpy import array # split a univariate sequence into samples def split_sequence(sequence, n_steps_in, n_steps_out): X, y = list(), list() for i in range(len(seq...
基于LSTM及其变种网络的时序数据建模实战教程
Python中文社区
02-08 1149
♚作者：沂水寒城，CSDN博客专家，个人研究方向：机器学习、深度学习、NLP、CVBlog:http://yishuihancheng.blog.csdn.net本文翻译自大神Jaso...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值