Statistics.py

import tensorflow as tf
from keras import backend as K
import numpy as np

def TP(y_true, y_pred):
    y_true_f = K.flatten(y_true)
    y_pred_f = K.flatten(y_pred)
    true_positives = K.sum(K.round(K.clip(y_true_f * y_pred_f, 0, 1)))
    return true_positives


def FP(y_true, y_pred):
    y_true_f = K.flatten(y_true)
    y_pred_f = K.flatten(y_pred)
    y_pred_f01 = K.round(K.clip(y_pred_f, 0, 1))
    tp_f01 = K.round(K.clip(y_true_f * y_pred_f, 0, 1))
    false_positives = K.sum(K.round(K.clip(y_pred_f01 - tp_f01, 0, 1)))
    return false_positives


def TN(y_true, y_pred):
    y_true_f = K.flatten(y_true)
    y_pred_f = K.flatten(y_pred)
    y_pred_f01 = K.round(K.clip(y_pred_f, 0, 1))
    all_one = K.ones_like(y_pred_f01)
    y_pred_f_1 = -1 * (y_pred_f01 - all_one)
    y_true_f_1 = -1 * (y_true_f - all_one)
    true_negatives = K.sum(K.round(K.clip(y_true_f_1 + y_pred_f_1, 0, 1)))
    return true_negatives


def FN(y_true, y_pred):
    y_true_f = K.flatten(y_true)
    y_pred_f = K.flatten(y_pred)
    # y_pred_f01 = keras.round(keras.clip(y_pred_f, 0, 1))
    tp_f01 = K.round(K.clip(y_true_f * y_pred_f, 0, 1))
    false_negatives = K.sum(K.round(K.clip(y_true_f - tp_f01, 0, 1)))
    return false_negatives


def recall(y_true, y_pred):
    tp = TP(y_true, y_pred)
    fn = FN(y_true, y_pred)
    return tp / (tp + fn)


def precision(y_true, y_pred):
    tp = TP(y_true, y_pred)
    fp = FP(y_true, y_pred)
    return tp / (tp + fp)


def patch_whole_dice(truth, predict):
    dice = []
    count_dice = 0
    for i in range(len(truth)):
        true_positive = truth[i] > 0
        predict_positive = predict[i] > 0
        match = np.equal(true_positive, predict_positive)
        match_count = np.count_nonzero(match)

        P1 = np.count_nonzero(predict[i])
        T1 = np.count_nonzero(truth[i])

        full_back = np.zeros(truth[i].shape)
        non_back = np.invert(np.equal(truth[i], full_back))
        TP = np.logical_and(match, non_back)
        TP_count = np.count_nonzero(TP)
        # print("m:", match_count, " P:", P1, " T:", T1, " TP:", TP_count)

        if (P1 + T1) == 0:
            dice.append(0)
        else:
            dice.append(2 * TP_count / (P1 + T1))
        if P1 != 0 or T1 != 0:
            count_dice += 1
    if count_dice == 0:
        count_dice = 1e6
    return dice  # , count_dice
    # return dice

def patch_whole_dice2(truth, predict):
    y_true_f = np.reshape(truth, (1, -1))
    y_pred_f = np.reshape(predict, (1, -1))
    intersection = np.sum(y_true_f * y_pred_f)
    return (2. * intersection + 1) / (np.sum(y_true_f * y_true_f) + np.sum(y_pred_f * y_pred_f) + 1)

def dice_coef(y_true, y_pred):
    smooth = 1.
    y_true_f = K.flatten(y_true)
    y_pred_f = K.flatten(y_pred)
    intersection = K.sum(y_true_f * y_pred_f)
    return (2. * intersection + smooth) / (K.sum(y_true_f * y_true_f) + K.sum(y_pred_f * y_pred_f) + smooth)

def EML(y_true, y_pred):
    gamma = 1.1
    alpha = 0.48
    smooth = 1.
    y_true = K.flatten(y_true)
    y_pred = K.flatten(y_pred)
    intersection = K.sum(y_true*y_pred)
    dice_loss = (2.*intersection + smooth)/(K.sum(y_true*y_true)+K.sum(y_pred * y_pred)+smooth)
    y_pred = K.clip(y_pred, K.epsilon(),max_value=None)
    pt_1 = tf.where(tf.equal(y_true, 1),y_pred,tf.ones_like(y_pred))
    pt_0 = tf.where(tf.equal(y_true, 0),y_pred,tf.zeros_like(y_pred))
    focal_loss = -K.mean(alpha*K.pow(1. -pt_1, gamma)*K.log(pt_1),axis=-1)\
                   -K.mean((1-alpha)*K.pow(pt_0,gamma)*K.log(1. -pt_0),axis=-1)
    return focal_loss - K.log(dice_loss)