程序问答   发布时间:2022-05-31  发布网站:大佬教程  code.js-code.com
大佬教程收集整理的这篇文章主要介绍了从 LSTM 自动编码器馈送分类器数据大佬教程大佬觉得挺不错的,现在分享给大家,也给大家做个参考。

如何解决从 LSTM 自动编码器馈送分类器数据?

开发过程中遇到从 LSTM 自动编码器馈送分类器数据的问题如何解决?下面主要结合日常开发的经验,给出你关于从 LSTM 自动编码器馈送分类器数据的解决方法建议,希望对你解决从 LSTM 自动编码器馈送分类器数据有所启发或帮助;

目标:

为了减少特征,我构建了一个 LSTM 自动编码器。我的计划是对一些输入进行编码,并在未来将其提供给分类器。编码器采用 [batch_size,timesteps,features_of_timesteps 形状的数据,但是在编码器部分的输出层中,我只返回 [1,features_of_timesteps] 形式的最后一个隐藏状态。

class Encoder(nn.ModulE):
    def __init__(self,input_size,first_layer,second_layer,n_layers):
        super(Encoder,self).__init__()
        self.n_layers = n_layers
        self.encode = nn.Sequential(nn.LSTM(input_size,batch_first=TruE),getSequence(),nn.ReLU(true),nn.LSTM(first_layer,second_layer),getLast())
        self.decode = nn.Sequential(nn.LSTM(second_layer,input_sizE),getSequence())

    def forWARD(self,X):
        x = x.float()
        x = self.encode(X)
        x = x.repeat(batch_size,1,1)
        x = self.decode(X)
        return x

担心:

我担心模型编码部分中我的第二个 LSTM 层的最后一个隐藏状态正在汇总整个批次并降低特征维度。这感觉不对,因为我试图将单个时间序列减少为一个较小的向量,而不是将整批时间序列减少为一个向量。我的担心正确吗?

解决方法

您的代码中存在多个问题,为简单起见,我只给您一个定义明确的模型,以下代码构建了一个 LSTM 自动编码器,它可以重构形状为 (batch_size,timesteps,number_of_features_at_each_timesteps) 的输入:

import torch
from torch import nn

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

class Encoder(nn.ModulE):
  def __init__(self,seq_len,n_features,embedding_dim=64):
    super(Encoder,self).__init__()

    self.seq_len,self.n_features = seq_len,n_features
    self.embedding_dim,self.hidden_dim = embedding_dim,2 * embedding_dim

    self.rnn1 = nn.LSTM(
      input_size=n_features,hidden_size=self.hidden_dim,num_layers=1,batch_first=True
    )
    self.rnn2 = nn.LSTM(
      input_size=self.hidden_dim,hidden_size=self.embedding_dim,batch_first=True
    )

  def forWARD(self,X):
    x,(_,_) = self.rnn1(X)
    x,(hidden_n,_) = self.rnn2(X)
    return hidden_n

class Decoder(nn.ModulE):
  def __init__(self,input_dim=64,n_features=1):
    super(Decoder,self.input_dim = seq_len,input_dim
    self.hidden_dim,self.n_features = 2 * input_dim,n_features

    self.rnn1 = nn.LSTM(
      input_size=input_dim,hidden_size=input_dim,batch_first=True
    )
    self.rnn2 = nn.LSTM(
      input_size=input_dim,batch_first=True
    )
    self.output_layer = nn.Linear(self.hidden_dim,n_features)

  def forWARD(self,X):
    x = x.repeat(self.seq_len,1,1)
    x = x.permute(1,2)
    x,cell_n) = self.rnn1(X)
    x,cell_n) = self.rnn2(X)
    return self.output_layer(X)

class RecurrentAutoencoder(nn.ModulE):
  def __init__(self,embedding_dim=64):
    super(RecurrentAutoencoder,self).__init__()

    self.encoder = Encoder(seq_len,embedding_dim).to(devicE)
    self.decoder = Decoder(seq_len,embedding_dim,n_features).to(devicE)

  def forWARD(self,X):
    print("Inputs size:",x.size())
    x = self.encoder(X)
    print("Representation size: ",x.size())
    x = self.decoder(X)
    print("Outputs size: ",x.size())
    return x

batch_n = 5
seq_len = 10
n_features = 3
inputs = torch.randn(batch_n,n_features).to(devicE)

model = RecurrentAutoencoder(seq_len,n_features).to(devicE)
y = model(inputs)

输出:

Inputs size: torch.Size([5,10,3])
Representation size:  torch.Size([1,5,64])
Outputs size:  torch.Size([5,3])

注意表示(即编码器的输出)具有形状 (1,batch_size,embedding_dim)

大佬总结

以上是大佬教程为你收集整理的从 LSTM 自动编码器馈送分类器数据全部内容,希望文章能够帮你解决从 LSTM 自动编码器馈送分类器数据所遇到的程序开发问题。

如果觉得大佬教程网站内容还不错,欢迎将大佬教程推荐给程序员好友。

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ:384754419,请注明来意。
标签: