title: how to build a multidimensional autoencoder with pytorch
body: <p>I followed this great answer for sequence autoencoder, </p>
  
  <p><a href="https://stackoverflow.com/questions/54411662/lstm-autoencoder-always-returns-the-average-of-the-input-sequence">LSTM autoencoder always returns the average of the input sequence</a>.</p>
  
  <p>but I met some problem when I try to change the code:</p>
  
  <ol>
  <li><strong>question one:</strong>
  Your explanation is so professional, but the problem is a little bit different from mine, I attached some code I changed from your example. My input features are 2 dimensional, and my output is same with the input. 
  for example:</li>
  </ol>
  
  <pre><code>input_x = torch.Tensor([[0.0,0.0], [0.1,0.1], [0.2,0.2], [0.3,0.3], [0.4,0.4]])
  output_y = torch.Tensor([[0.0,0.0], [0.1,0.1], [0.2,0.2], [0.3,0.3], [0.4,0.4]])
  the input_x and output_y are same, 5-timesteps, 2-dimensional feature.
  
          import torch
          import torch.nn as nn
          import torch.optim as optim
  
          class LSTM(nn.Module):
              def __init__(self, input_dim, latent_dim, num_layers):
                  super(LSTM, self).__init__()
                 self.input_dim = input_dim
                  self.latent_dim = latent_dim
                  self.num_layers = num_layers
                  self.encoder = nn.LSTM(self.input_dim, self.latent_dim, self.num_layers)
  
                  # I changed here, to 40 dimesion, I think there is some problem 
                  # self.decoder = nn.LSTM(self.latent_dim, self.input_dim, self.num_layers)
                  self.decoder = nn.LSTM(40, self.input_dim, self.num_layers)
  
              def forward(self, input):
                  # Encode
                  _, (last_hidden, _) = self.encoder(input)
                  # It is way more general that way
                  encoded = last_hidden.repeat(input.shape)
                  # Decode
                  y, _ = self.decoder(encoded)
                 return torch.squeeze(y)
  
          model = LSTM(input_dim=2, latent_dim=20, num_layers=1)
          loss_function = nn.MSELoss()
          optimizer = optim.Adam(model.parameters())
          y = torch.Tensor([[0.0,0.0], [0.1,0.1], [0.2,0.2], [0.3,0.3], [0.4,0.4]])
          x = y.view(len(y), -1, 2)   # I changed here 
  
          while True:
              y_pred = model(x)
              optimizer.zero_grad()
              loss = loss_function(y_pred, y)
              loss.backward()
              optimizer.step()
              print(y_pred)
  </code></pre>
  
  <p>The above code can learn very well, can you help review the code and give some instructions.</p>
  
  <p>When I input 2 examples as the input to the model, the model cannot work:</p>
  
  <p>for example, change the code:</p>
  
  <pre><code>y = torch.Tensor([[0.0,0.0], [0.1,0.1], [0.2,0.2], [0.3,0.3], [0.4,0.4]])
  </code></pre>
  
  <p>to:</p>
  
  <pre><code>y = torch.Tensor([[[0.0,0.0],[0.5,0.5]], [[0.1,0.1], [0.6,0.6]], [[0.2,0.2],[0.7,0.7]], [[0.3,0.3],[0.8,0.8]], [[0.4,0.4],[0.9,0.9]]])
  </code></pre>
  
  <p>When I compute the loss function, it complain some errors? can anyone help have a look</p>
  
  <ol start="2">
  <li><strong>question two:</strong>
  my training samples are with different length:
  for example:</li>
  </ol>
  
  <pre><code>x1 = [[0.0,0.0], [0.1,0.1], [0.2,0.2], [0.3,0.3], [0.4,0.4]]   #with 5 timesteps
  x2 = [[0.5,0.5], [0.6,0.6], [0.7,0.7]] #with only 3 timesteps
  </code></pre>
  
  <p>How can I input these two training sample into the model at the same time for a batch training.</p>