I’m currently trying to reconstruct speech signals that are 3,000 samples long using an autoencoder. I currently have 90,000 examples of these speech signals to train on. Here is a summary of the autoencoder architecture:
Input shape: (8, 1, 3000)
Normalized shape: (8, 1, 3000)
Normalized mean: 6.45319602199379e-08
Normalized variance: 0.9997082948684692
----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv1d-1             [-1, 16, 2998]              64
             PTanh-2             [-1, 16, 2998]               0
            Conv1d-3             [-1, 16, 1499]             528
       BatchNorm1d-4             [-1, 16, 1499]              32
            Conv1d-5             [-1, 32, 1495]           2,592
             PTanh-6             [-1, 32, 1495]               0
            Conv1d-7              [-1, 32, 747]           2,080
       BatchNorm1d-8              [-1, 32, 747]              64
            Conv1d-9              [-1, 64, 741]          14,400
            PTanh-10              [-1, 64, 741]               0
           Conv1d-11              [-1, 64, 370]           8,256
      BatchNorm1d-12              [-1, 64, 370]             128
         Upsample-13              [-1, 64, 740]               0
           Conv1d-14              [-1, 32, 734]          14,368
            PTanh-15              [-1, 32, 734]               0
         Upsample-16             [-1, 32, 1468]               0
           Conv1d-17             [-1, 16, 1464]           2,576
            PTanh-18             [-1, 16, 1464]               0
         Upsample-19             [-1, 16, 3006]               0
            PTanh-20             [-1, 16, 3006]               0
           Conv1d-21              [-1, 1, 3000]             113
================================================================
Total params: 45,201
Trainable params: 45,201
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.01
Forward/backward pass size (MB): 5.47
Params size (MB): 0.17
Estimated Total Size (MB): 5.65
----------------------------------------------------------------

And here is the autoencoder architecture itself:
class PTanh(torch.nn.Module):
    
    # PTanh(x) = a * tanh(b * x)
    
    def __init__(self,in_channels):
        
        super().__init__()
        
        # need this for __repr__ method
        
        self.in_channels = in_channels
        
        # initialize a
        
        a = torch.full((in_channels,1), 1.7159)
        self.a = torch.nn.Parameter(a,requires_grad = True)
        
        # initialize b
        
        b = torch.full((in_channels,1), 2/3)
        self.b = torch.nn.Parameter(b,requires_grad = True)
    
    def __repr__(self):
        return 'PTanh(' + str(self.in_channels) + ')'
    
    def forward(self,x):
        x = torch.multiply(x,self.a)
        x = torch.multiply(torch.nn.Tanh()(x),self.b)
        return x

class Autoencoder(torch.nn.Module):
    
    def __init__(self,batch_norm = False):
        
        super().__init__()
        
        # encoder --------------------------------------------------------
        
        encoder = []
        
        # first layer
        
        layer = [torch.nn.Conv1d(in_channels = 1,
                                 out_channels = 16,
                                 kernel_size = 3,
                                 stride = 1,
                                 bias = True),
                 PTanh(16),
                 torch.nn.Conv1d(in_channels = 16,
                                 out_channels = 16,
                                 kernel_size = 2,
                                 stride = 2,
                                 bias = True)]
        
        encoder.extend(layer)
        
        if batch_norm:
            encoder.append(torch.nn.BatchNorm1d(num_features = 16,
                                                eps = 1e-08,
                                                momentum = 0.1,
                                                affine = True,
                                                track_running_stats = True))
        
        # second layer
        
        layer = [torch.nn.Conv1d(in_channels = 16,
                                 out_channels = 32,
                                 kernel_size = 5,
                                 stride = 1,
                                 bias = True),
                 PTanh(32),
                 torch.nn.Conv1d(in_channels = 32,
                                 out_channels = 32,
                                 kernel_size = 2,
                                 stride = 2,
                                 bias = True)]
        
        encoder.extend(layer)
        
        if batch_norm:
            encoder.append(torch.nn.BatchNorm1d(num_features = 32,
                                                eps = 1e-08,
                                                momentum = 0.1,
                                                affine = True,
                                                track_running_stats = True))
        
        # third layer
        
        layer = [torch.nn.Conv1d(in_channels = 32,
                                 out_channels = 64,
                                 kernel_size = 7,
                                 stride = 1,
                                 bias = True),
                 PTanh(64),
                 torch.nn.Conv1d(in_channels = 64,
                                 out_channels = 64,
                                 kernel_size = 2,
                                 stride = 2,
                                 bias = True)]
        
        encoder.extend(layer)
        
        if batch_norm:
            encoder.append(torch.nn.BatchNorm1d(num_features = 64,
                                                eps = 1e-08,
                                                momentum = 0.1,
                                                affine = True,
                                                track_running_stats = True))
        
        self.encoder = torch.nn.Sequential(*encoder)
        
        # decoder --------------------------------------------------------
        
        decoder = []
        
        # fourth layer
        
        layer = [torch.nn.Upsample(scale_factor = 2,
                                   mode = 'nearest'),
                 torch.nn.Conv1d(in_channels = 64,
                                 out_channels = 32,
                                 kernel_size = 7,
                                 stride = 1,
                                 bias = True),
                 PTanh(32)]
        
        decoder.extend(layer)
        
        if batch_norm:
            encoder.append(torch.nn.BatchNorm1d(num_features = 32,
                                                eps = 1e-08,
                                                momentum = 0.1,
                                                affine = True,
                                                track_running_stats = True))
        
        # fifth layer
        
        layer = [torch.nn.Upsample(scale_factor = 2,
                                   mode = 'nearest'),
                 torch.nn.Conv1d(in_channels = 32,
                                 out_channels = 16,
                                 kernel_size = 5,
                                 stride = 1,
                                 bias = True),
                 PTanh(16)]
        
        decoder.extend(layer)
        
        if batch_norm:
            encoder.append(torch.nn.BatchNorm1d(num_features = 16,
                                                eps = 1e-08,
                                                momentum = 0.1,
                                                affine = True,
                                                track_running_stats = True))
        
        # sixth layer
        
        layer = [torch.nn.Upsample(size = 3006,
                                   mode = 'nearest'),
                 PTanh(16),
                 torch.nn.Conv1d(in_channels = 16,
                                 out_channels = 1,
                                 kernel_size = 7,
                                 stride = 1,
                                 bias = True)]
        
        decoder.extend(layer)
        
        self.decoder = torch.nn.Sequential(*decoder)
        
    def forward(self,x):
        x = self.encoder(x)
        x = self.decoder(x)
        return x

I have trained this autoencoder for 30 epochs using a batch size of 8, the SmoothL1Loss loss function, and the Adam optimizer as follows:
loss_func = torch.nn.SmoothL1Loss(reduction = 'mean',
                                  beta = 1.0)
optimizer = torch.optim.Adam(params = net.parameters(),
                             lr = 0.0003)

However, when I test the autoencoder on new examples, it simply tries to reconstruct the mean. In other words, a low-pass filtered version of the input. For example:
gD9Ml.png1554×787
The original speech signal is at the top and the reconstructed signal is at the bottom. Any suggestions on how I can solve this problem?