Как получить результат латентного слоя в autoencoder?

Я сначала загружаю данные, которые буду использовать для обучения автоенкодера. Соединяю их вместе и использую функцию DataLoader для правильной работы модели.

import numpy as np
import pandas as pd
import torch

idb = pd.read_csv('idb.csv', index_col = 'Unnamed: 0')
rdb = pd.read_csv('rdb.csv', index_col = 'Unnamed: 0')
new_df = pd.concat([idb, rdb])
print(new_df.shape)
dataLoader = torch.utils.data.DataLoader(dataset=new_df,
                                                      batch_size=128,
                                                      shuffle=True)

Впоследствии я создаю класс с encoder и decoder и обучаю модель на своих соединенных данных.

import torch
from torch import nn
from torch.autograd import Variable
import matplotlib.pyplot as plt
import os


class Autoencoder(nn.Module):
    # name, description and manually generated features on data
    def __init__(self, epochs=10, batchSize=128, learningRate=1e-3):
        super(Autoencoder, self).__init__()
        # Encoder Network
        self.encoder = nn.Sequential(nn.Linear(300, 128),
                                     nn.ReLU(True),
                                     nn.Linear(128, 64),
                                     nn.ReLU(True),
                                     nn.Linear(64, 12),
                                     nn.ReLU(True),
                                     nn.Linear(12, 3))
        # Decoder Network
        self.decoder = nn.Sequential(nn.Linear(3, 12),
                                     nn.ReLU(True),
                                     nn.Linear(12, 64),
                                     nn.ReLU(True),
                                     nn.Linear(64, 128),
                                     nn.ReLU(True),
                                     nn.Linear(128, 300),
                                     nn.Tanh())

        self.epochs = epochs
        self.batchSize = batchSize
        self.learningRate = learningRate
        self.data = new_df.values
        self.dataLoader = torch.utils.data.DataLoader(dataset=self.data,
                                                      batch_size=self.batchSize,
                                                      shuffle=True)
        
        #
        self.optimizer = torch.optim.Adam(self.parameters(), lr=self.learningRate, weight_decay=1e-5)
        self.criterion = nn.MSELoss(

        )

    def forward(self, x):
        x = self.encoder(x)
        x = self.decoder(x)
        return x

    def trainModel(self):
        for epoch in range(self.epochs):
            for data in self.dataLoader:
                image  = data
                # Predictions
                output = self(image.float())
                # Calculate Loss
                loss = self.criterion(output, image.float())
                # Backpropagation
                self.optimizer.zero_grad()
                loss.backward()
                self.optimizer.step()

            print('epoch [{}/{}], loss:{:.4f}'
                  .format(epoch + 1, self.epochs, loss.data))

autoencoder = Autoencoder()
autoencoder.trainModel()

В дальнейших моих целях из обученной модели вытащить (обученный) encoder и применить его на тех же самых данных, которые я использовал в обучении только по отдельности. Но препятствие состоит в том, что я не знаю, как получить этот обученный encoder из модели и соответственно latent layer (с помощью которого он получится) для моих данных. Подскажите, пожалуйста, как мне это сделать?