NLP neural.net 验证准确性在交叉验证中的折叠之间增加太多（？）

Question

我正在使用 BERT 训练 model 以使用两个标签进行分类。 我想使用交叉验证，因为我想对数据集中的每个观察结果进行样本外预测，以便稍后在线性回归中使用。 我有 5 个 EPOCHS。

第一次折叠的行为符合预期：验证准确度在 EPOCHS 中增加，并收敛到我在使用通常的 80-10-10 分割和整个样本（约 .86）运行 neural.net 时获得的准确度。

奇怪的是，对于随后的折叠（2 到 5），验证准确度不断增加——达到 .90、.95、.98 和 1.0。

我相信代码是正确的，因为我每次折叠都从头开始重新运行所有 model。 我也手动检查过，拆分似乎没问题。 每个折叠的验证集都是随机的、唯一的，并且不与其相应的训练数据集重叠一个可能的解释是权重在折叠之间没有重新初始化？ 这将导致之前使用新折叠的新观察来计算权重。 但这对我来说很奇怪。

我复制我的代码。 任何帮助或想法将不胜感激。 谢谢！

%%time



# Create K train/test folds
n_folds = 5
kf = KFold(n_splits=n_folds, random_state=RANDOM_SEED, shuffle=True)

# Initialize matrix to store results across folds
train_acc_mat = [[0 for _ in range(EPOCHS)] for _ in range(n_folds)]
train_loss_mat = [[0 for _ in range(EPOCHS)] for _ in range(n_folds)]
val_acc_mat = [[0 for _ in range(EPOCHS)] for _ in range(n_folds)]
val_loss_mat = [[0 for _ in range(EPOCHS)] for _ in range(n_folds)]

# Create fold index to store results in matrix
fold_index = 1

# Loop across folds
for train_index, val_index in kf.split(df):
  df_train = df.iloc[train_index]
  df_val = df.iloc[val_index]
  
  # Run Data Loader function for each training data set - fold
  train_data_loader = create_data_loader(df_train, tokenizer, MAX_LEN, BATCH_SIZE)
  # Run Data Loader function for each validation data set - fold
  val_data_loader = create_data_loader(df_val, tokenizer, MAX_LEN, BATCH_SIZE)

  # Train data loader
  data = next(iter(train_data_loader))

  # Create input_ids and attention_mask
  input_ids = data['input_ids'].to(device)
  attention_mask = data['attention_mask'].to(device)

  # Set last layer classification function, other config
  F.sigmoid(model(input_ids, attention_mask))
  optimizer = AdamW(model.parameters(), lr=2e-5, correct_bias=False)
  total_steps = len(train_data_loader) * EPOCHS

  scheduler = get_linear_schedule_with_warmup(
    optimizer,
    num_warmup_steps=0,
    num_training_steps=total_steps
  )

  loss_fn = nn.CrossEntropyLoss().to(device)


  ###### TRAIN MODEL

  # Set accuracy to 0 to store fold best model results
  best_accuracy = 0

  # Create epoch index to store results in matrix
  EPOCH_index = 1

  # Iterate over EPOCHS, TRAIN MODEL
  for epoch in range(EPOCHS):

    print(f'Epoch {epoch + 1}/{EPOCHS}')
    print('-' * 10)

    train_acc, train_loss = train_epoch(
      model,
      train_data_loader,    
      loss_fn, 
      optimizer, 
      device, 
      scheduler, 
      len(df_train)
    )

    print(f'Train loss {train_loss} accuracy {train_acc}')

    val_acc, val_loss = eval_model(
      model,
      val_data_loader,
      loss_fn, 
      device, 
      len(df_val)
    )

    print(f'Val   loss {val_loss} accuracy {val_acc}')
    print()

    # For fold_index, store results from EPOCH_index iteration
    train_acc_mat[fold_index-1][EPOCH_index-1] = train_acc.item()
    train_loss_mat[fold_index-1][EPOCH_index-1] = train_loss.item()
    val_acc_mat[fold_index-1][EPOCH_index-1] = val_acc.item()
    val_loss_mat[fold_index-1][EPOCH_index-1] = val_loss.item()

    # Save fold_index best model
    if val_acc > best_accuracy:
      torch.save(model.state_dict(), 'best_model_state_%s.bin' % fold_index)
      best_accuracy = val_acc
    
    # Update index for next EPOCH iteration
    EPOCH_index = EPOCH_index + 1

  # Store fold results
  globals()['train_fold_%s' % fold_index] = np.asmatrix(train_index)  
    
  y_review_texts, y_pred, y_pred_probs, y_test = get_predictions(
  model,
  val_data_loader
  )

  globals()['results_fold_%s' % fold_index] = np.asmatrix(val_index)
  globals()['results_fold_%s' % fold_index] = np.vstack([globals()['results_fold_%s' % fold_index], y_review_texts])
  globals()['results_fold_%s' % fold_index] = np.vstack([globals()['results_fold_%s' % fold_index], y_pred.detach().numpy()])
  globals()['results_fold_%s' % fold_index] = np.vstack([globals()['results_fold_%s' % fold_index], y_test.detach().numpy()])
  globals()['results_fold_%s' % fold_index] = np.vstack([globals()['results_fold_%s' % fold_index], y_pred_probs.detach().numpy().T[1]])

  # Update index for next FOLD iteration
  fold_index = fold_index + 1

Answer 1

您正在重置优化器，但没有重置 model。使用 K 折，您应该有 K 个模型。

假设你有 5 条数据[1, 2, 3, 4, 5]

在第一次折叠中，您训练[1, 2, 3, 4]并测试[5] 。
第二折你在[1]上训练[2, 3, 4, 5]测试
第三次训练[3, 4, 5, 1]测试[2]
第四次训练[4, 5, 1, 2] [3]测试
第五次训练 [ [4]上的[5, 1, 2, 3]测试。

由于您没有重置 model，所以当您到达第五折时，它已经在 4 个训练集中看到了4个，因此它会在上面表现得非常好。

这也是为什么你的准确率在每次折叠后都会持续增加的原因。 在每次折叠时，您都会通过测试已经看到的折叠将数据泄漏到 model。 K 折交叉验证的目的是查看 model 如何处理未见过的数据。