@ptrblck this is what i understood , apologies if i am still missing please guide me i really want to learn this stuff
I asked to track loss of classification header in network , here is Autoencoder no change as you suggested
class Autoencoder(nn.Module):
    def __init__(self):
        super().__init__()

        self.encoder = nn.Sequential(
            nn.Linear(112,480),
            nn.ReLU(),
            nn.BatchNorm1d(480),
            
            nn.Linear(480,100),
            nn.BatchNorm1d(100),
            nn.ReLU()
        )
        self.decoder = nn.Sequential(
            nn.Linear(100,480),
            nn.ReLU())
            
        self.decoder_recon = nn.Linear(480,112)
        self.decoder_classifier = nn.Linear(480,112)
    
    def forward(self,x):
        x = self.encoder(x)
        x = self.decoder(x)
        reconstruction = self.decoder_recon(x)
        logits = self.decoder_classifier(x)
        return reconstruction,logits
    
    def get_encoder_state(self,x):
        encoded = self.encoder(x)
        return encoded

Here i am just updating gradient of additional defined classification header loss
self.decoder_classifier = nn.Linear(480,112)
I removed   self.decoder_recon = nn.Linear(480,112) loss updating in the following code
criterion = nn.MSELoss()
seed = 4
torch.manual_seed(seed)
num_epochs = 100
outputs = []
running_loss = 0.0

for epoch in range(num_epochs):
    for data in data_loader:
        inputs, targets = data['x'].to(device), data['y'].to(device)
        recon,logits = autoencoder(inputs)
        loss_recon  = criterion(recon,targets) # calculate loss
        loss_classifier     = criterion(logits,inputs)
        loss = loss_recon + loss_classifier

        optimizer.zero_grad()
        loss_classifier.backward()  # gradients = backward pass
        optimizer.step() # update weights 
        if not  scheduler.__class__ ==  torch.optim.lr_scheduler.ReduceLROnPlateau:
            scheduler.step(loss)
        running_loss += loss.item()
    if (epoch+1) % 2 ==0:
        print(f'Epoch: {epoch+1}, Loss:{loss_classifier}, Running Loss:{running_loss}')

Epoch: 2, Loss:0.19022159278392792, Running Loss:506.3911786079407
Epoch: 4, Loss:0.15673978626728058, Running Loss:1002.0990172624588
.
.
Epoch: 98, Loss:0.062328677624464035, Running Loss:20757.95539867878
Epoch: 100, Loss:0.06230540573596954, Running Loss:21154.803141355515

Updating combined loss self.decoder_classifier = nn.Linear(480,112) and
self.decoder_recon = nn.Linear(480,112) in the following code
criterion = nn.MSELoss()
seed = 4
torch.manual_seed(seed)

num_epochs = 100
outputs = []
running_loss = 0.0

for epoch in range(num_epochs):
    for data in data_loader:
        inputs, targets = data['x'].to(device), data['y'].to(device)
        recon,logits = autoencoder(inputs)
        loss_recon  = criterion(recon,targets) # calculate loss
        loss_classifier     = criterion(logits,inputs)
        loss = loss_recon + loss_classifier

        optimizer.zero_grad()
        loss.backward()  # gradients = backward pass
        optimizer.step() # update weights 
        if not  scheduler.__class__ ==  torch.optim.lr_scheduler.ReduceLROnPlateau:
            scheduler.step(loss)
        running_loss += loss.item()
    if (epoch+1) % 2 ==0:
        print(f'Epoch: {epoch+1}, Loss:{loss.item():.4f}, Running Loss:{running_loss}')

Epoch: 2, Loss:0.7351, Running Loss:216.49947154521942
Epoch: 4, Loss:0.7167, Running Loss:424.1127555966377
Epoch: 6, Loss:0.7047, Running Loss:627.1306979060173
Epoch: 8, Loss:0.7052, Running Loss:828.52132833004
.
.
Epoch:100, Loss:0.4444, Running Loss:3412.2449165582657

In both cases down stream model LGBM using latent space 100 as an input for model training , and downstream LGBM model is giving more or less same score in each fold
Updating loss with respect to classification header latent space performance of LGBM model

0.8072682510834308
0.8065939798651113
0.8057722965731224
0.8059680518666961
0.8057054368050915
Fold Mean: 0.80626, Standard Deviation: 0.00059

Updating combined loss w.r.t recon and classification header latent space performance of LGBM model

0.8065435663650142
0.8059007970122725
0.8055537970177743
0.8060057710128392
0.8054112326987021
Fold Mean: 0.80588, Standard Deviation: 0.00040

There is only slight improvement from fold 0.80588 to 0.80626
If still i am doing wrong please correct me