I’m training an LSTM model to recognize patterns from different voices and classify them into two categories: Male and Female. I applied a Mel-frequency cepstrum transformation and captured 1/10 of a second long signal which equals an array of 512. I have about 30 million sequences for training. But I’m using a small percentage to experiment before training on the entire data.

I’m using an LSTM to classify the sequence to male or female, each time I run the model I get the same prediction with the same probability. I can’t figure out what’s wrong.

```
class AudioLSTM(nn.Module):
def __init__(
self,
batch_size = 256,
input_size = 512,
hidden_size: 126,
dropout: 0.3,
num_layer: 126,
output_size: 2,
batch: bool = True,
bidirectional: bool = True
) -> None:
super(AudioLSTM, self).__init__()
self.input_size = input_size
self.hidden_size = hidden_size
self.num_layer = num_layer
self.dropout = dropout
self.output_size = output_size
self.batch_size = batch_size
self.RNN_TYPE = nn.LSTM(
input_size=input_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout,
batch_first=batch,
bidirectional=bidirectional,
)
self.dropout = nn.Dropout(dropout)
self.out = nn.Sigmoid()
def forward(self, mfcc, hidden):
seq_length = mfcc.shape[1] # seq_length = 512 #mfcc = torch.Size([256, 512, 1])
mfcc_reshape = mfcc.float().view(1, -1, seq_length) # mfcc_reshape = torch.Size([1, 256, 512])
lstm_out, hidden = self.RNN_TYPE(mfcc_reshape, hidden) # lstm_out, = torch.Size([1, 256, 252])
lstm_out = self.dropout(lstm_out)
final_layer = lstm_out.view(self.batch_size, -1, self.output_size)[:, -1] # torch.Size([256, 2])
layer_prob = torch.sigmoid(final_layer) # layer_prob = torch.Size([256, 2])
return layer_prob, hidden
def init_hidden(self, batch_size: int):
weight = next(self.parameters()).data
if torch.cuda.is_available():
hidden = (
weight.new(self.num_layer * self.output_size, batch_size, self.hidden_size).zero_().cuda(),
weight.new(self.num_layer * self.output_size, batch_size, self.hidden_size).zero_().cuda(),
)
else:
hidden = (
weight.new(self.num_layer * self.output_size, batch_size, self.hidden_size).zero_(),
weight.new(self.num_layer * self.output_size, batch_size, self.hidden_size).zero_(),
)
return hidden
```

The latest run was for using a small percentage: see below for results.

```
Epoch: 1/1... Step: 20... Training Loss: 0.692648... Validation Loss: 0.692760 Train Accuracy: 0.531250 Test Accuracy: 0.519531
Epoch: 1/1... Step: 30... Training Loss: 0.692848... Validation Loss: 0.693522 Train Accuracy: 0.523438 Test Accuracy: 0.476562
Epoch: 1/1... Step: 40... Training Loss: 0.691812... Validation Loss: 0.693789 Train Accuracy: 0.546875 Test Accuracy: 0.472656
```