10 fold cross validation evaluation

Question

I have the following model for classification. I have train set and test set. I trained it on train set,the Input is 3400 vector and output it is a class between 3 classes (0,1,2). I saved the model as the following code. Now I want to apply 10 fold cross validation to evaluate the saved model on test set. Could you please tell how i can do it since I never used 10 cross validation before.

training_set = Dataset("train_data.txt","train_target.txt")
training_generator = torch.utils.data.DataLoader(training_set, **params)
testing_set = Dataset("test_data.txt","testtarget.txt")
testing_generator = torch.utils.data.DataLoader(testing_set, **params)
    for i, (seq_batch, stat_batch) in enumerate(training_generator):
        seq_batch, stat_batch = seq_batch.to(device), stat_batch.to(device)
        optimizer.zero_grad()
        #print(seq_batch.shape,stat_batch.shape)
        # Model computation
        seq_batch = seq_batch.unsqueeze(-1)
        outputs = model(seq_batch)
        if CUDA:
            loss = criterion(outputs, stat_batch)
        loss.backward()
        optimizer.step()
        # print statistics
        running_loss += loss.item()
        epoch_loss += loss.item()*outputs.shape[0]
        if i % 2000 == 1999:  # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000),"acc",(outputs.argmax(1) == stat_batch).float().mean())
            running_loss = 0.0
        sum_acc += (outputs.argmax(1) == stat_batch).float().sum()

    print("epoch" , epoch+1, "acc", sum_acc/len(training_set),"loss", epoch_loss/len(training_set))
    loss_values.append(epoch_loss/len(training_set))
    if epoch % 20 == 0:
        torch.save(model.state_dict(), path + name_file + "model_epoch_i_" + str(epoch) + ".cnn")

Answer 1

This topic can be useful for you. One of the answers contain custom CV function: k-fold cross validation using DataLoaders in PyTorch

# define a cross validation function
def crossvalid(model=None,criterion=None,optimizer=None,dataset=None,k_fold=10):
    
    train_score = pd.Series()
    val_score = pd.Series()
    
    total_size = len(dataset)
    fraction = 1/k_fold
    seg = int(total_size * fraction)
    # tr:train,val:valid; r:right,l:left;  eg: trrr: right index of right side train subset 
    # index: [trll,trlr],[vall,valr],[trrl,trrr]
    for i in range(k_fold):
        trll = 0
        trlr = i * seg
        vall = trlr
        valr = i * seg + seg
        trrl = valr
        trrr = total_size
        # msg
#         print("train indices: [%d,%d),[%d,%d), test indices: [%d,%d)" 
#               % (trll,trlr,trrl,trrr,vall,valr))
        
        train_left_indices = list(range(trll,trlr))
        train_right_indices = list(range(trrl,trrr))
        
        train_indices = train_left_indices + train_right_indices
        val_indices = list(range(vall,valr))
        
        train_set = torch.utils.data.dataset.Subset(dataset,train_indices)
        val_set = torch.utils.data.dataset.Subset(dataset,val_indices)
        
#         print(len(train_set),len(val_set))
#         print()
        
        train_loader = torch.utils.data.DataLoader(train_set, batch_size=50,
                                          shuffle=True, num_workers=4)
        val_loader = torch.utils.data.DataLoader(val_set, batch_size=50,
                                          shuffle=True, num_workers=4)
        train_acc = train(res_model,criterion,optimizer,train_loader,epoch=1)
        train_score.at[i] = train_acc
        val_acc = valid(res_model,criterion,optimizer,val_loader)
        val_score.at[i] = val_acc
    
    return train_score,val_score
        

train_score,val_score = crossvalid(res_model,criterion,optimizer,dataset=tiny_dataset)