如何使用 Tensorboard 绘制损失和准确度

如何解决如何使用 Tensorboard 绘制损失和准确度

我有三个数据集（训练、测试和验证）。我结合训练数据集和测试数据集来做 k 折交叉验证。我没有使用验证数据集。我是上一个问题的张量板的新手，我能够在每个时期的训练期间进行绘图损失准确性。我如何绘制损失和准确性的图，以便在每个时期进行测试。因为我想看看每个时期的表现。我应该为 set 使用验证集吗？如果是，如何使用？

# Prepare dataset by concatenating Train/Test part; we split later.
training_set = CustomDataset('one_hot_train_data.txt','train_3states_target.txt') #training_set = CustomDataset_3('one_hot_train_data.txt','train_5_target.txt')
training_generator = torch.utils.data.DataLoader(training_set,**params)
val_set = CustomDataset('one_hot_val_data.txt','val_3states_target.txt')
test_set = CustomDataset('one_hot_test_data.txt','test_3states_target.txt')
testloader_ = torch.utils.data.DataLoader(test_set,**params)
dataset = ConcatDataset([training_set,test_set])
kfold = KFold(n_splits=k_folds,shuffle=True)

# Start print
print('--------------------------------')

# K-fold Cross Validation model evaluation
for fold,(train_ids,test_ids) in enumerate(kfold.split(dataset)):
    # Print
    print(f'FOLD {fold}')
    print('--------------------------------')

    # Sample elements randomly from a given list of ids,no replacement.
    train_subsampler = torch.utils.data.SubsetRandomSampler(train_ids)
    test_subsampler = torch.utils.data.SubsetRandomSampler(test_ids)

    # Define data loaders for training and testing data in this fold
    trainloader = torch.utils.data.DataLoader(
        dataset,**params,sampler=train_subsampler)
    testloader = torch.utils.data.DataLoader(
       dataset,sampler=test_subsampler)
    # Init the neural network
    model = PPS()
    model.to(device)
    # Initialize optimizer
    optimizer = optim.SGD(model.parameters(),lr=LEARNING_RATE)
    # Run the training loop for defined number of epochs
    for epoch in range(0,N_EPOCHES):
        # Print epoch
        print(f'Starting epoch {epoch + 1}')
        # Set current loss value
        running_loss = 0.0
        epoch_loss = 0.0
        a = []
        # Iterate over the DataLoader for training data
        for i,data in enumerate(trainloader,0):
            inputs,targets = data
            inputs = inputs.unsqueeze(-1)
            #inputs = inputs.to(device)
            targets = targets.to(device)
            inputs = inputs.to(device)
            # print(inputs.shape,targets.shape)
            # Zero the gradients
            optimizer.zero_grad()
            # Perform forward pass
            loss,outputs = model(inputs,targets)
            outputs = outputs.to(device)

            # Perform backward pass
            loss.backward()
            # Perform optimization
            optimizer.step()
            # print statistics
            running_loss += loss.item()
            epoch_loss += loss
            a.append(torch.sum(outputs == targets))
            # print(outputs.shape,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",torch.sum(outputs == targets) / float(outputs.shape[0]))
                running_loss = 0.0
            # sum_acc += (outputs == stat_batch.argmax(1)).float().sum()
        print("epoch",epoch + 1,sum(a) / len(train_subsampler),"loss",epoch_loss / len(trainloader))
        accuracy = 100 * sum(a) / len(training_set)
        avg_loss = sum(a) / len(training_set)
        writer.add_scalar('train/loss',avg_loss.item(),epoch)
        writer.add_scalar('accuracy/loss',accuracy,epoch)
    state = {'epoch': epoch + 1,'state_dict': model.state_dict(),'optimizer': optimizer.state_dict() }
    torch.save(state,path + name_file + "model_epoch_i_" + str(epoch) + str(fold)+".cnn")
    #torch.save(model.state_dict(),path + name_file + "model_epoch_i_" + str(epoch) + ".cnn")
    # Print about testing
    print('Starting testing')

# Evaluation for this fold
    correct,total = 0,0
    with torch.no_grad():
    # Iterate over the test data and generate predictions
     for i,data in enumerate(testloader,0):
        # Get inputs
        inputs,targets = data
        #targets = targets.to(device)
        inputs = inputs.unsqueeze(-1)
        inputs = inputs.to(device)
        # Generate outputs
        loss,targets)
        outputs.to(device)
        print("out",outputs.shape)
        print("target",targets.shape)
        print("targetsize",targets.size(0))
        print("sum",(outputs == targets).sum().item())
        #print("sum",torch.sum(outputs == targets))

        # Set total and correct
       # _,predicted = torch.max(outputs.data,1)
        total += targets.size(0)
        correct += (outputs == targets).sum().item()
        #correct += torch.sum(outputs == targets)

    # Print accuracy
    print('Accuracy for fold %d: %d %%' % (fold,float( 100.0 * float(correct / total))))
    print('--------------------------------')
    results[fold] = 100.0 * float(correct / total)

# Print fold results
print(f'K-FOLD CROSS VALIDATION RESULTS FOR {k_folds} FOLDS')
print('--------------------------------')
sum = 0.0
for key,value in results.items():
    print(f'Fold {key}: {value} %')
    sum += value
print(f'Average: {float(sum / len(results.items()))} %')