【问题标题】:Calculating Fscore for each epoch using keras (not batch-wise)使用 keras 计算每个时期的 Fscore(不是批量)
【发布时间】:2020-05-08 16:41:15
【问题描述】:

这个问题的本质:

我想找到一种合适的方法来计算每个 epoch 之后的验证和训练数据的 Fscore(不是批量)

对于二元分类任务,我想使用简单的keras 模型在每个时期之后计算Fscore。但如何计算Fscore 似乎颇受讨论。

我知道keras 分批工作,计算每个批次fscore 的一种方法https://stackoverflow.com/a/45305384/10053244(Fscore-calculation:f1)。

批量计算可能会很混乱,我更喜欢在每个 epoch 之后计算 Fscore。所以只是调用history.history['f1']history.history['val_f1'] 做的伎俩,因为它显示了batch-wise fscores。

我想出一种方法是使用 from keras.callbacks import ModelCheckpoint 函数保存每个模型:

  1. 在每个 epoch 后保存每个模型的权重
  2. 重新加载模型并使用model.evaluate model.predict

编辑:

使用 tensorflow 后端,我决定跟踪 TruePositivesFalsePositivesFalseNegatives(按照 umbreon29 的建议)。 但现在有趣的部分来了:重新加载模型时的结果对于训练数据是不同的(TP、FP、FN 是不同的)但对于验证集却不是!

因此,存储权重以重建每个模型并重新计算 TP、FN、TP(最后是 Fscore)的简单模型如下所示:

from keras.metrics import TruePositives, TrueNegatives, FalseNegatives, FalsePositives

## simple keras model
sequence_input = Input(shape=(input_dim,), dtype='float32')
preds = Dense(1, activation='sigmoid',name='output')(sequence_input)
model = Model(sequence_input, preds)

model.compile(loss='binary_crossentropy',
              optimizer='adam',
              metrics=[TruePositives(name='true_positives'),
                       TrueNegatives(name='true_negatives'),
                       FalseNegatives(name='false_negatives'),
                       FalsePositives(name='false_positives'),
                       f1])

# model checkpoints
filepath="weights-improvement-{epoch:02d}-{val_f1:.2f}.hdf5"
checkpoint = ModelCheckpoint(os.path.join(savemodel,filepath), monitor='val_f1', verbose=1, save_best_only=False, save_weights_only=True, mode='auto')
callbacks_list = [checkpoint]

history = model.fit(x_train, y_train, validation_data=(x_val, y_val), epochs=epoch, batch_size=batch,
                    callbacks=[callbacks_list])

## Saving TP, FN, FP to calculate Fscore
tp.append(history.history['true_positives'])
fp.append(history.history['false_positives'])
fn.append(history.history['false_negatives'])

arr_train = np.stack((tp, fp, fn), axis=1)

## doing the same for tp_val, fp_val, fn_val 
[...]
arr_val = np.stack((tp_val, fp_val, fn_val), axis=1)

## following method just showes batch-wise fscores and shouldnt be used:
## f1_sc.append(history.history['f1'])  

在每个 epoch 后重新加载模型以计算 Fscores(使用 sklearn fscore 指标from sklearn.metrics import f1_scorepredict 方法等效于从 TP、FP、FN 计算 fscore 指标):

Fscore_val = []
fscorepredict_val_sklearn = []
Fscore_train = []
fscorepredict_train = []

## model_loads contains list of model-paths
for i in model_loads:
    ## rebuilding the model each time since only weights are stored
    sequence_input = Input(shape=(input_dim,), dtype='float32')
    preds = Dense(1, activation='sigmoid',name='output')(sequence_input)
    model = Model(sequence_input, preds)
    model.load_weights(i)

    # Compile model (required to make predictions)
    model.compile(loss='binary_crossentropy',
                  optimizer='adam',
                  metrics=[TruePositives(name='true_positives'),
                           TrueNegatives(name='true_negatives'),
                           FalseNegatives(name='false_negatives'),
                           FalsePositives(name='false_positives'),
                           f1
                           ])    

    ### For Validation data
    ## using evaluate
    y_pred =  model.evaluate(x_val, y_val, verbose=0)
    Fscore_val.append(y_pred)  ## contains (loss,tp,fp,fn, f1-batchwise)

    ## using predict
    y_pred = model.predict(x_val)
    val_preds = [1 if x > 0.5 else 0 for x in y_pred]
    cm = f1_score(y_val, val_preds)
    fscorepredict_val_sklearn.append(cm)  ## equivalent to Fscore calculated from Fscore_vals tp,fp, fn


    ### For the training data
    y_pred =  model.evaluate(x_train, y_train, verbose=0) 
    Fscore_train.append(y_pred) ## also contains (loss,tp,fp,fn, f1-batchwise)

    y_pred =  model.predict(x_train, verbose=0)  # gives probabilities
    train_preds = [1 if x > 0.5 else 0 for x in y_pred]
    cm = f1_score(y_train, train_preds)
    fscorepredict_train.append(cm)

使用Fscore_val 的 tp,fn,fp 从 tp、fn 和 fp 计算 Fscore 并将其与fscorepredict_val_sklearn 进行比较与从 arr_val 计算它是等效且相同的。

然而,比较Fscore_trainarr_train时tp、fn和fp的数量是不同的。因此,我也得出了不同的 Fscores。 tp,fn,fp 的数量应该是相同的,但它们不是。这是一个错误吗?

我应该信任哪一个? fscorepredict_train 实际上似乎更值得信赖,因为它们从“总是猜测类 1”-Fscore 开始(当召回 = 1 时)。 (fscorepredict_train[0]=0.6784 vs f_hist[0]=0.5736 vs always-guessing-class-1-fscore = 0.6751)

[注意: Fscore_train[0] = [0.6853608025386962, 2220.0, 250.0, 111.0, 1993.0, 0.6730511784553528] (loss,tp,tn,fp,fn) 导致 fscore= 0.6784 ,所以 Fscore 来自 Fscore_train = fscorepredict_train ]

【问题讨论】:

  • 我可以建议的解决方法是在每批累积测试集中的误报、真阳性和假阴性示例之后。 epoch 完成后,您可以计算整个集合中的 f1-score。我可以给你一个使用火炬的完整可重复的例子

标签: python tensorflow keras


【解决方案1】:

我提供了一个自定义回调,用于计算 epoch 结束时所有数据的分数(在你的情况下是来自 sklearn 的 F1)(用于训练和可选的验证)

class F1History(tf.keras.callbacks.Callback):

    def __init__(self, train, validation=None):
        super(F1History, self).__init__()
        self.validation = validation
        self.train = train

    def on_epoch_end(self, epoch, logs={}):

        logs['F1_score_train'] = float('-inf')
        X_train, y_train = self.train[0], self.train[1]
        y_pred = (self.model.predict(X_train).ravel()>0.5)+0
        score = f1_score(y_train, y_pred)       

        if (self.validation):
            logs['F1_score_val'] = float('-inf')
            X_valid, y_valid = self.validation[0], self.validation[1]
            y_val_pred = (self.model.predict(X_valid).ravel()>0.5)+0
            val_score = f1_score(y_valid, y_val_pred)
            logs['F1_score_train'] = np.round(score, 5)
            logs['F1_score_val'] = np.round(val_score, 5)
        else:
            logs['F1_score_train'] = np.round(score, 5)

这里是一个虚拟的例子:

x_train = np.random.uniform(0,1, (30,10))
y_train = np.random.randint(0,2, (30))

x_val = np.random.uniform(0,1, (20,10))
y_val = np.random.randint(0,2, (20))

sequence_input = Input(shape=(10,), dtype='float32')
preds = Dense(1, activation='sigmoid',name='output')(sequence_input)
model = Model(sequence_input, preds)

es = EarlyStopping(patience=3, verbose=1, min_delta=0.001, monitor='F1_score_val', mode='max', restore_best_weights=True)
model.compile(loss='binary_crossentropy', optimizer='adam')
model.fit(x_train,y_train, epochs=10, 
          callbacks=[F1History(train=(x_train,y_train),validation=(x_val,y_val)),es])

输出打印:

Epoch 1/10
1/1 [==============================] - 0s 78ms/step - loss: 0.7453 - F1_score_train: 0.3478 - F1_score_val: 0.4762
Epoch 2/10
1/1 [==============================] - 0s 57ms/step - loss: 0.7448 - F1_score_train: 0.3478 - F1_score_val: 0.4762
Epoch 3/10
1/1 [==============================] - 0s 58ms/step - loss: 0.7444 - F1_score_train: 0.3478 - F1_score_val: 0.4762
Epoch 4/10
1/1 [==============================] - ETA: 0s - loss: 0.7439Restoring model weights from the end of the best epoch.
1/1 [==============================] - 0s 70ms/step - loss: 0.7439 - F1_score_train: 0.3478 - F1_score_val: 0.4762

我有 TF 2.2 并且可以正常工作,希望对您有所帮助

【讨论】:

  • 您的方法确实有效。我会接受你的回答,但我很好奇为什么使用arr_train 的 Fscore 计算不起作用(见编辑)。应用你的方法让我相信fscorepredict_train(或Fscore_train中包含的tp、fp、fn)确实是正确的训练Fscore,因为它与你的计算相符
猜你喜欢
  • 2019-02-09
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2018-08-07
  • 2018-06-05
  • 2020-06-13
  • 2019-02-05
  • 1970-01-01
相关资源
最近更新 更多