Keras 自建各种loss及评价函数

最新推荐文章于 2024-04-08 15:27:40 发布

原创最新推荐文章于 2024-04-08 15:27:40 发布 · 1.5k 阅读

6 ·

本内容遵循CC 4.0 BY-SA版权协议

AI 专栏收录该内容

145 篇文章

订阅专栏

本文介绍了如何在Keras中创建自定义的损失和评价函数，特别是针对图像分割任务。重点讨论了二分类Dice损失、IOU损失、Tversky系数，并提到了可以利用sklearn库的评价指标，如混淆矩阵、F1分数、精度和召回率以及ROC AUC得分。

Keras 自带的loss及评价函数许多情况下无法满足需求，尤其对于图像分割，需要导入自定义函数，本文主要介绍一些常用的损失及评价函数。评价函数和损失函数相似，只不过评价函数的结果不会用于训练过程中。
1.二分类Dice损失及评价函数：
公式如下：
类似与IOU

def dice_coef(y_true, y_pred, smooth=1):
    intersection = K.sum(y_true * y_pred, axis=[1,2,3])
    union = K.sum(y_true, axis=[1,2,3]) + K.sum(y_pred, axis=[1,2,3])
    return K.mean( (2. * intersection + smooth) / (union + smooth), axis=0)
    
def dice_coef_loss(y_true, y_pred):
    return 1 - dice_coef(y_true, y_pred, smooth=1)

2.IOU损失及评价函数：交集除以并集
真正的IOU

def IoU(y_true, y_pred, eps=1e-6):
    if np.max(y_true) == 0.0:
        return IoU(1-y_true, 1-y_pred) ## empty image; calc IoU of zeros
    intersection = K.sum(y_true * y_pred, axis=[1,2,3])
    union = K.sum(y_true, axis=[1,2,3]) + K.sum(y_pred, axis=[1,2,3]) - intersection
    return K.mean( (intersection + eps) / (union + eps), axis=0)

def iou_loss(y_true, y_pred):
    return - IoU(y_true, y_pred)

3.Tversky 系数，Tversky系数是Dice系数和 Jaccard 系数的一种广义系数。
在这里插入图片描述

def tversky(y_true, y_pred,smooth=1):
    y_true_pos = K.flatten(y_true)
    y_pred_pos = K.flatten(y_pred)
    true_pos = K.sum(y_true_pos * y_pred_pos)
    false_neg = K.sum(y_true_pos * (1-y_pred_pos))
    false_pos = K.sum((1-y_true_pos)*y_pred_pos)
    alpha = 0.7
    return (true_pos + smooth)/(true_pos + alpha*false_neg + (1-alpha)*false_pos + smooth)

def tversky_loss(y_true, y_pred):
    return 1 - tversky(y_true,y_pred)

4.利用sklearn自建评价函数，sklearn自带许多评价函数。
confusion_matrix, f1_score, precision_score, recall_score，roc_auc_score

from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score
from keras.callbacks import Callback

class RocAucEvaluation(Callback):
    def __init__(self, validation_data=(), interval=1):
        super(Callback, self).__init__()
        self.interval = interval
        self.x_val,self.y_val = validation_data
    def on_epoch_end(self, epoch, log={}):
        if epoch % self.interval == 0:
            y_pred = self.model.predict(self.x_val, verbose=0)
            score = roc_auc_score(self.y_val, y_pred)
            print('\n ROC_AUC - epoch:%d - score:%.6f \n' % (epoch+1, score))

x_train,y_train,x_label,y_label = train_test_split(train_feature, train_label, train_size=0.95, random_state=233)
RocAuc = RocAucEvaluation(validation_data=(y_train,y_label), interval=1)


hist = model.fit(x_train, x_label, batch_size=batch_size, epochs=epochs, validation_data=(y_train, y_label), callbacks=[RocAuc], verbose=2)

import numpy as np
from keras.callbacks import Callback
from sklearn.metrics import confusion_matrix, f1_score, precision_score, recall_score
class Metrics(Callback):
  def on_train_begin(self, logs={}):
    self.val_f1s = []
    self.val_recalls = []
    self.val_precisions = []

  def on_epoch_end(self, epoch, logs={}):
    val_predict=(np.asarray(self.model.predict(self.model.validation_data[0]))).round()
    val_targ = self.model.validation_data[1]
    _val_f1 = f1_score(val_targ, val_predict)
    _val_recall = recall_score(val_targ, val_predict)
    _val_precision = precision_score(va_targ, val)
    self.val_f1s.append(_val_f1)
    self.val_recalls.append(_val_recall)
    self.val_precisions.append(_val_precision)
    print('-val_f1: %.4f --val_precision: %.4f --val_recall: %.4f'%(_val_f1, _val_precision, _val_recall))
    return

metrics = Metrics()

model.fit(training_data, training_target, 
          validation_data=(validation_data, validation_target),
          np_epoch=10, batch_size=64, callbacks =[metrics])