Hi! I am a beginner in deep learning. I have implemented the following model. The problem I am facing now is that the weights and bias are not being updated. When I plot the losses, the losses are periodic(looks the same every epoch). Can anyone please help me see what is causing this? Thank you!

class MyModel(torch.nn.Module):

```
def __init__(self):
"""
In the constructor we instantiate two nn.Linear modules and assign them as
member variables.
"""
super(MyModel, self).__init__()
# Pooling layer
self.pool = torch.nn.MaxPool1d(20, stride=2)
self.pool_avg = torch.nn.AvgPool1d(127)
# Time(left) convolution
self.time1 = torch.nn.Conv1d(in_channels=1, out_channels=64, kernel_size=16, stride=1, padding=17)
self.time2 = torch.nn.Conv1d(in_channels=64, out_channels=128, kernel_size=16, stride=1, padding=17)
self.time3 = torch.nn.Conv1d(in_channels=128, out_channels=256, kernel_size=16, stride=1, padding=17)
# Frequency(right) convolution
self.freq1 = torch.nn.Conv1d(in_channels=1, out_channels=64, kernel_size=16, stride=1, padding=17)
self.freq2 = torch.nn.Conv1d(in_channels=64, out_channels=128, kernel_size=16, stride=1, padding=17)
self.freq3 = torch.nn.Conv1d(in_channels=128, out_channels=256, kernel_size=16, stride=1, padding=17)
# Fully conencted layer
self.linear1 = torch.nn.Linear(512, 256)
self.linear2 = torch.nn.Linear(256, 128)
self.linear3 = torch.nn.Linear(128, 64)
# Fianl layer
self.final = torch.nn.Softmax(dim=1)
def forward(self, time_domian, freq_domain, clean_result):
"""
In the forward function we accept a Tensor of input data and we must return
a Tensor of output data. We can use Modules defined in the constructor as
well as arbitrary operators on Tensors.
"""
# input dimension
time_domian = time_domian.unsqueeze(1)
freq_domain = freq_domain.unsqueeze(1)
# Time(left) convolution
# print(f"len time domain: {time_domian.shape}")
time1_out = self.time1(time_domian)
time1_out = self.pool(time1_out)
# print(f"len time1_out: {time1_out.shape}")
time2_out = self.time2(time1_out)
time2_out = self.pool(time2_out)
# print(f"len time2_out: {time2_out.shape}")
time3_out = self.time3(time2_out)
time3_out = self.pool(time3_out)
# print(f"len time3_out: {time3_out.shape}")
# Frequency(right) convolution
freq1_out = self.freq1(freq_domain)
freq1_out = self.pool(freq1_out)
freq2_out = self.freq2(freq1_out)
freq2_out = self.pool(freq2_out)
freq3_out = self.freq3(freq2_out)
freq3_out = self.pool(freq3_out)
# print(f"len freq3_out: {freq3_out.shape}")
# Connection
conv_out = torch.cat((time3_out, freq3_out), dim=1)
conv_out_ave = torch.squeeze(self.pool_avg(conv_out))
# print(f"len conv_out: {conv_out.shape}")
# print(f"len conv_out_ave: {conv_out_ave.shape}")
# Fully conencted layer
fc1_out = self.linear1(conv_out_ave).clamp(min=0) # relu
# print(f"len fc1_out: {fc1_out.shape}")
fc2_out = self.linear2(fc1_out).clamp(min=0) # relu
# print(f"len fc2_out: {fc2_out.shape}")
fc3_out = self.linear3(fc2_out).clamp(min=0) # relu
#print(f"len fc3_out: {fc3_out.shape}")
# print(fc3_out)
# Final layer
final_out = torch.max(self.final(fc3_out), dim=1)[0]
# print(f"len final_out: {final_out.shape}")
# print(final_out)
return final_out
```