Hi
My problem is this:
I have data X and Y and I know its latent representation T. T is between [-1,1]. So, I am trying to create two parallel auto-encoders (Q1, P1) and (Q2, P2) [#both have a single hidden layer] with the following objectives
(1) Q1, Q2 = encoder
(2) P1, P2 = decoder
(3) My objective is to minimize the latent representation w.r.t T and also the reconstructed data w.r.t to X and Y
(4) I would also like to minimize the difference between the first hidden layer outputs using m.s.e.
Few snippets of code are given below (for defining Q1,P1). Q2,P2 are also defined similarly.

class Q1(nn.Module):  


  def __init__(self):
    super(Q1, self).__init__()
    # separate layers
    self.headX = nn.Linear(D_in1, H)                
    self.tailX = nn.Linear(H, D_out)

  def forward(self, x):        
    x = self.headX(x)        
    x1 =F.relu(x)                
    return F.tanh(self.tailX(x1)), x1

class P1(nn.Module):  
  def __init__(self):
    super(P_1, self).__init__()
    self.headX = nn.Linear(D_out, H)                
    self.tailX = nn.Linear(H, D_in1)
    
  def forward(self, x):        
    x = self.headX(x)        
    x1 = F.relu(x)                
    return F.tanh(self.tailX(x1)), x1    


Now when I am trying to compute the loss for objective (3) I am doing this (which is working fine)

for batch_idx, (data1, y_act1, data2, y_act2) in enumerate(train_loader):
    
    data1, y_act1 = Variable(data1), Variable(y_act1)
    data2, y_act2 = Variable(data2), Variable(y_act2)
    
    y_pred1, tx1 =  Q1(data1)
    y_pred2, ty1 =  Q2(data2)
    
    x_pred1, tx2 =  P1(y_pred1)
    x_pred2, ty2 =  P2(y_pred2)
    
    # Compute and print loss.
    
    # embedding loss
    loss_em1 = Loss_embed1(y_pred1, y_act1)        
    loss_em2 = Loss_embed2(y_pred2, y_act2)
    
    # reconstruction loss
    loss_re1 = Loss_recons1(x_pred1, data1)
    loss_re2 = Loss_recons2(x_pred2, data2)
    
    #compute loss for output of common layers but employed on intermediate outputs   
    # in the encoding side
    q1 = torch.mean(torch.norm(tx1 - ty1, 2, 1))      
            
    # in the decoding side
    q2 = torch.mean(torch.norm(tx2 - ty2, 2, 1))
    
    # Total loss
    loss_a = loss_re1 + loss_re2
    loss_b = loss_em1 + loss_em2
    loss = loss_a + loss_b + q1 + q2
    
    print('Epoch {:d}: {:d} reconst Loss {:.6f} embed Loss {:.6f} enc Loss {:.6f} dec Loss {:.6f}\n'.format(
        epoch, batch_idx, loss_a.data[0], loss_b.data[0], q1.data[0], q2.data[0]))
    
    # set the gradients to zero
    P_decoder1.zero_grad()
    Q_encoder1.zero_grad()
    P_decoder2.zero_grad()
    Q_encoder2.zero_grad()
    
    # compute by backpropagation
    loss.backward()
    
    # update the weights
    P_decoder1.step()
    Q_encoder1.step()
    P_decoder2.step()
    Q_encoder2.step()


Is this the most appropriate way to do it? Any information on this will be helpful. Thanks.