時系列データに対しLSTMを用いたEncoderDecoderを実装し、特徴量抽出をしたい

前提・実現したいこと

気温の変化のような一つの時系列データに対して図の**pre-trainingような**LSTMを用いたEncoderDecoderを実施し、特徴量抽出をしたい。
inferenceの部分は関係ありません。
元の論文：https://arxiv.org/pdf/1709.01907.pdf

今回の実装において
図の中のT,Fはそれぞれ48,12
Encoderの隠れ層は128
Decoderの隠れ層は32
とします。

発生している問題・エラーメッセージ

RuntimeError: input.size(-1) must be equal to input_size. Expected 1, got 95

該当のソースコード

まずこちらを作業ディレクトリに入れてください。
データ読み込み用です。
https://github.com/aybchan/uber-time-series/blob/master/data.py
※もちろん任意の1次元時系列データを用いても大丈夫です。

python
1
2
3from data import *
4import numpy as np
5import torch.optim as optim
6from torch.utils.data import DataLoader
7from tqdm import tqdm
8
9#データの読み込み
10df = pipeline()
11time_steps = 48
12y_time_steps = 12
13datasets = samples(df, time_steps, y_time_steps)
14
15#モデルの実装
16class Encoder(nn.Module):
17    def __init__(self):
18        super(Encoder, self).__init__()
19        
20        self.l1 = nn.RNN(1,128, 
21                         nonlinearity = 'tanh',
22                         batch_first = True)
23        
24        nn.init.xavier_normal_(self.l1.weight_ih_l0) #tanhよりXavierの初期化
25        nn.init.orthogonal_(self.l1.weight_ih_l0) #直行座標を用いた初期化
26        
27
28
29    def forward(self, x):
30        _,states = self.l1(x)
31        return states
32
33
34class Decoder(nn.Module):
35    def __init__(self):
36        super(Decoder, self).__init__()
37        
38        self.l1 = nn.RNN(1,32, 
39                         nonlinearity = 'tanh',
40                         batch_first = True)
41        
42        nn.init.xavier_normal_(self.l1.weight_ih_l0) #tanhよりXavierの初期化
43        nn.init.orthogonal_(self.l1.weight_ih_l0) #直行座標を用いた初期化
44        
45
46
47    def forward(self, x, states):
48        #型を変える作業?
49        h, _ = self.l1(x,states)
50        
51        return h
52
53class Autoencoder(nn.Module):
54    def __init__(self):
55        super(Autoencoder, self).__init__()
56        self.encoder = Encoder()
57        self.decoder = Decoder()
58        self.f1 = nn.Linear(32,12)
59
60    def forward(self, x):
61        states = self.encoder(x)
62        h = self.decoder(x[-12:],self)
63        out = self.f1(h)
64
65        return out
66
67
68##これ以降は他のモデルでは動いため、問題ないと思われます。
69
70#モデル学習
71batch_size = 256
72learning_rate = 0.001
73
74model = Autoencoder(output_dim =y_time_steps)
75train_dataloader = DataLoader(TrafficDataset(datasets,set_='train'), #データのバッチ処理とテンソル化
76                              batch_size=batch_size,
77                              shuffle=True)
78optimiser = optim.Adam(lr=learning_rate,
79                       params=model.parameters())
80
81num_epochs = 100
82pbar = tqdm(range(num_epochs)) #進行状況を可視化してくれる
83
84for epoch in pbar:
85    for i, (x,y) in enumerate(train_dataloader):
86        x_hat = model(x)
87        
88        ##勾配更新
89        optimiser.zero_grad()
90        loss = F.mse_loss(y, x_hat)
91        loss.backward()
92        optimiser.step()
93        ##
94        
95        step = (epoch * len(train_dataloader.dataset) + #??
96                i * batch_size + len(x))
97        
98        losses.append([step, loss.item()])
99        pbar.set_description("Epoch={0} | [{1:>5}|{2}]\t loss={3:.4f}"
100                             .format(epoch,
101                                     i * batch_size + len(x),
102                                     len(train_dataloader.dataset),
103                                     loss.item()))
104

試したこと

大まかな流れは間違っていないと思うのですが、入力データの次元等があやしいです、、

どこが問題が自分でもはっきりしておらず、漠然とした質問になってしまいましたが、何か少しでもお分かりになることがあれば教えていただけると大変助かります。

行動規範の内容に同意します

回答1件

自己解決

python
1
2class Encoder(nn.Module):
3    def __init__(self, input_dim):
4        super(Encoder, self).__init__()
5        
6        self.l1 = nn.LSTM(input_dim,128, 
7                         #nonlinearity = 'tanh',
8                         batch_first = True) #(batch, seq_len, input_size)
9        
10        self.l2 = nn.LSTM(128,32,
11                        #nonlinearity = 'tanh',
12                        batch_first = True)
13        
14        nn.init.xavier_normal_(self.l1.weight_ih_l0) #tanhよりXavierの初期化
15        nn.init.orthogonal_(self.l1.weight_ih_l0) #直行座標を用いた初期化
16        
17        nn.init.xavier_normal_(self.l2.weight_ih_l0) #tanhよりXavierの初期化
18        nn.init.orthogonal_(self.l2.weight_ih_l0) #直行座標を用いた初期化
19        
20
21
22    def forward(self, x):
23        h,states128 = self.l1(x)
24        _,states32 = self.l2(h)
25        return states128, states32
26
27
28class Decoder(nn.Module):
29    def __init__(self, input_dim):
30        super(Decoder, self).__init__()
31        
32        self.l1 = nn.LSTM(input_dim,128,
33                         #nonlinearity = 'tanh',
34                         batch_first = True)
35        
36        self.l2 = nn.LSTM(128,32,
37                         #nonlinearity = 'tanh',
38                         batch_first = True)
39        
40        nn.init.xavier_normal_(self.l1.weight_ih_l0) #tanhよりXavierの初期化
41        nn.init.orthogonal_(self.l1.weight_ih_l0) #直行座標を用いた初期化
42        
43        nn.init.xavier_normal_(self.l2.weight_ih_l0) #tanhよりXavierの初期化
44        nn.init.orthogonal_(self.l2.weight_ih_l0) #直行座標を用いた初期化
45        
46
47
48    def forward(self, x, states128,states32):
49        h, _ = self.l1(x,states128)
50        h, _ = self.l2(h,states32)
51        
52        return h
53
54class Autoencoder(nn.Module):
55    def __init__(self,input_dim,y_time_steps):
56        super(Autoencoder, self).__init__()
57        self.y_time_steps = y_time_steps
58        self.encoder = Encoder(input_dim)
59        self.decoder = Decoder(input_dim)
60        self.f1 = nn.Linear(32,1)
61
62    def forward(self, x):
63        states128, states32 = self.encoder(x)
64        h = self.decoder(x[:,-(self.y_time_steps):,:],states128, states32)
65        out = self.f1(h)
66
67        return out
68