I Have implemented an Autoencoder that takes in a Tweet and the Target, concatenates the final hidden state after passing them through encoder, and reconstructs as well as classifies them into 3 classes.

But the loss is not changing at all and is constant at 17.226, pls help?

EDIT : so the loss is changing but it’s fluctuating betwen 17.223 - 17.235 and that too very, slowly. what can i do to solve/find the problem?

src1 = trg1 = tweet

src2 = trg2 = target

```
class Seq2Seq(nn.Module):
def __init__(self,encoder,decoder, device):
super().__init__()
self.decoder = decoder
self.encoder = encoder
self.device = device
hid_dim1 = encoder.hid_dim
hid_dim2 = decoder.hid_dim
self.linear = nn.Linear(hid_dim1*2, hid_dim2)
self.out = nn.Linear(hid_dim2,3)
def forward(self,src1,trg1,src2,trg2,teacher_forcing_ratio = 0.5):
batch_size = trg1.shape[1]
max_len = trg1.shape[0]
target_voc_size = self.decoder.output_dim
outputs = torch.zeros(max_len, batch_size, target_voc_size).to(self.device)
context1 = self.encoder(src1)
hidden1 = context1
input = trg1[0,:]
max_len2 = trg2.shape[0]
outputs2 = torch.zeros(max_len2,batch_size,target_voc_size).to(self.device)
context2 = self.encoder(src2)
hidden2 = context2
temp = torch.cat((hidden1,hidden2), dim = 2)
hidden = self.linear(temp)
context = hidden
for t in range(1,max_len):
#print(t)
output, hidden = self.decoder(input, hidden, context)
outputs[t] = output
teacher_force = random.random() < teacher_forcing_ratio
top1 = output.max(1)[1]
input = (trg1[t] if teacher_force else top1)
input2 = trg2[0,:]
for t in range(1, max_len2):
output, hidden = self.decoder(input2, hidden, context)
outputs2[t] = output
teacher_force = random.random() < teacher_forcing_ratio
input2 = output.max(1)[1]
out = F.relu(self.out(context))
return outputs, outputs2, out
```

and i am implementing the criterion as

```
criterion = nn.CrossEntropyLoss(ignore_index=pad_idx)
criterion2 = nn.BCEWithLogitsLoss()
```

while I am implementing the loss as follows -

```
lossA = criterion(output1[1:].view(-1, output1.shape[2]), trg[1:].view(-1))
lossB = criterion(output2[1:].view(-1, output2.shape[2]), trg2[1:].view(-1))
lossC = criterion2(y,output3)
loss = lossA + lossB + lossC
loss.backward()
```

Where could be the problem?