Hello,your models is pretty,but i find there something wierd at

mel_train = []
print("Calculatin mel spectrograms for train set")
for i in range(X_train.shape[0]):
    mel_spectrogram = getMELspectrogram(X_train[0,:], sample_rate=SAMPLE_RATE)
    mel_train.append(mel_spectrogram)
    print("\r Processed {}/{} files".format(i,X_train.shape[0]),end='')
print('')
del X_train

mel_val = []
print("Calculatin mel spectrograms for val set")
for i in range(X_val.shape[0]):
    mel_spectrogram = getMELspectrogram(X_val[0,:], sample_rate=SAMPLE_RATE)
    mel_val.append(mel_spectrogram)
    print("\r Processed {}/{} files".format(i,X_val.shape[0]),end='')
print('')
del X_val

mel_test = []
print("Calculatin mel spectrograms for test set")
for i in range(X_test.shape[0]):
    mel_spectrogram = getMELspectrogram(X_test[0,:], sample_rate=SAMPLE_RATE)
    mel_test.append(mel_spectrogram)
    print("\r Processed {}/{} files".format(i,X_test.shape[0]),end='')
print('')
del X_test

It always load the first data,I think it may be the index i

Hi,
I have tried to train Stacked Time Distributed 2D CNN-LSTM model on RAVDESS database by using default hyperparameters.
But I can't reproduce the result(acc=94%) reported by you. Could you give me some cues to setup the best hyperparameters for the model?
Thanks a lot!

Thank you for sharing your very impressive performance and model.
I have one question for you.

I want to reproduce the same performance as you showed below, but how do I set the hyperparameter?

1. Stacked Time Distributed 2D CNN - LSTM (94.02%)
2. Stacked Time Distributed 2D CNN - Bidirectional LSTM with attention (96.55%)
3. Parallel 2D CNN - Bidirectional LSTM with attention (95.40%)
4. Parallel 2D CNN - Transformer Encoder (96.78%)

Hi sir,
As suggested by you I have used Pytorch Dataloaders due to cuda memory issues. Now plz guide me with code How to train test and validate the model to replicate your output.
I have tried the code below.

train_set = Dataset(X=X_train, y=Y_train,mode="train")
tr_loader = DL(train_set, batch_size=8, num_workers=0,shuffle=True)

test_set  = Dataset(X=X_test, y=Y_test,mode="train")
ts_loader = DL(test_set, batch_size=8,num_workers=0,shuffle=False)
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print('Selected device is {}'.format(device))
model = HybridModel(num_emotions=len(EMOTIONS)).to(device)
print('Number of trainable params: ',sum(p.numel() for p in model.parameters()) )
criterion=nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(),lr=0.01, weight_decay=1e-3, momentum=0.8)
#%%
train_step = make_train_step(model, loss_fnc, optimizer=optimizer)
validate = make_validate_fnc(model,loss_fnc)

#%%
verbose=True
Losses = []
Accuracies = []
epochs=50
DLS = {"train": tr_loader, "valid": ts_loader}

start_time = time.time()
for e in range(epochs):
    epochLoss = {"train": 0, "valid": 0}
    epochAccs = {"train": 0, "valid": 0}

    for phase in ["train", "valid"]:
        if phase == "train":
            model.train()
        else:
            model.eval()

        lossPerPass = []
        accuracy = []

        for X, y in DLS[phase]:
            X, y = X.to(device), y.to(device).view(-1)

            optimizer.zero_grad()
            alpha=1.0
            beta=1.0
            with torch.set_grad_enabled(phase == "train"):
              
                pred_emo, output_softmax= model(X)
                emotion_loss = criterion(pred_emo,y)
              
                total_loss = alpha*emotion_loss
                if phase == "train":
                    total_loss.backward()
                    optimizer.step()
            lossPerPass.append(total_loss.item())
            accuracy.append(accuracy_score(torch.argmax(torch.exp(output_softmax.detach().cpu()), dim=1), y.cpu()))
            torch.save(model.state_dict(),"E................................/Epoch_{}.pt".format(e+1))  
        epochLoss[phase] = np.mean(np.array(lossPerPass))
        epochAccs[phase] = np.mean(np.array(accuracy))
        # Epoch Checkpoint // All or Best
    Losses.append(epochLoss)
    Accuracies.append(epochAccs)

    

    if verbose:
        print("Epoch : {} | Train Loss : {:.5f} | Valid Loss : {:.5f} \
| Train Accuracy : {:.5f} | Valid Accuracy : {:.5f}".format(e + 1, epochLoss["train"], epochLoss["valid"],
                                                        epochAccs["train"], epochAccs["valid"]))

Is it okay. I am using a batch size of 8. But the model is performing very poor in this training , for 50 epochs the accuracy is fluctuating between 25 to 30%. I mean for how much epochs you run it?

Hi there, Just started reusing your first model, stacked _cnn , all work fine until training.
Even for batch_size=1
its throwing an error: cuda out of memory.

is there any other solution for this? I think you have not used any dataloaders here probably that's the reason , plz explain and guide what to do?

Hi Kosta,

Can I check if the repo support any Inference for Individual/Custom Audio Sample?

When training the model, the issue below happens:

`Selected device is cuda

RuntimeError Traceback (most recent call last)
in
4 device = 'cuda' if torch.cuda.is_available() else 'cpu'
5 print('Selected device is {}'.format(device))
----> 6 model = HybridModel(num_emotions=len(EMOTIONS)).to(device)
7 print('Number of trainable params: ',sum(p.numel() for p in model.parameters()))
8 OPTIMIZER = torch.optim.SGD(model.parameters(),lr=0.01, weight_decay=1e-3, momentum=0.8)

~\anaconda3\lib\site-packages\torch\nn\modules\module.py in to(self, *args, **kwargs)
671 return t.to(device, dtype if t.is_floating_point() or t.is_complex() else None, non_blocking)
672
--> 673 return self._apply(convert)
674
675 def register_backward_hook(

~\anaconda3\lib\site-packages\torch\nn\modules\module.py in _apply(self, fn)
385 def _apply(self, fn):
386 for module in self.children():
--> 387 module._apply(fn)
388
389 def compute_should_use_set_data(tensor, tensor_applied):

~\anaconda3\lib\site-packages\torch\nn\modules\rnn.py in _apply(self, fn)
177
178 def _apply(self, fn):
--> 179 ret = super(RNNBase, self)._apply(fn)
180
181 # Resets _flat_weights

~\anaconda3\lib\site-packages\torch\nn\modules\module.py in _apply(self, fn)
407 # with torch.no_grad():
408 with torch.no_grad():
--> 409 param_applied = fn(param)
410 should_use_set_data = compute_should_use_set_data(param, param_applied)
411 if should_use_set_data:

~\anaconda3\lib\site-packages\torch\nn\modules\module.py in convert(t)
669 return t.to(device, dtype if t.is_floating_point() or t.is_complex() else None,
670 non_blocking, memory_format=convert_to_format)
--> 671 return t.to(device, dtype if t.is_floating_point() or t.is_complex() else None, non_blocking)
672
673 return self._apply(convert)

RuntimeError: CUDA out of memory. Tried to allocate 2.00 MiB (GPU 0; 2.00 GiB total capacity; 1.08 GiB already allocated; 1.44 MiB free; 1.11 GiB reserved in total by PyTorch)`

Decreasing the batch size doesn't help.