损失函数python实现
这是从GitHub上下载的loss函数；
适合二分类，多分类得自己从新修改。
交叉熵素损失函数
def pixel_wise_softmax(output_map):
exponential_map = tf.exp(output_map)
sum_exp = tf.reduce_sum(exponential_map, 3, keep_dims=True)
return tf.div(exponential_map, sum_exp)
def xentropy_loss(mask, prediction, n_class):
mask = tf.reshape(mask, [-1, n_class])
mask = tf.cast(mask, tf.float32)
pred = tf.reshape(pixel_wise_softmax(prediction), [-1, n_class])
pred = tf.cast(pred,tf.float32)
loss_temp = mask * tf.log(tf.clip_by_value(pred, 1e-10, 1.0))
return -tf.reduce_mean(loss_temp)
l2正则化
def l2_regular():
total_vars = tf.trainable_variables()
weights_name_list = [var for var in total_vars if "kernel" in var.name]
loss_holder = []
for w in range(len(weights_name_list)):
l2_loss = tf.nn.l2_loss(weights_name_list[w])
loss_holder.append(l2_loss)
regular_loss = tf.reduce_mean(loss_holder) * 0.001
return regular_loss
dice损失函数
def dice_loss_3d(Y_gt, Y_pred):
Z, H, W, C = Y_gt.get_shape().as_list()[1:]
smooth = 1e-5
pred_flat = tf.reshape(Y_pred, [-1, H * W * C * Z])
true_flat = tf.reshape(Y_gt, [-1, H * W * C * Z])
intersection = 2 * tf.reduce_sum(pred_flat * true_flat, axis=1) + smooth
denominator = tf.reduce_sum(pred_flat, axis=1) + tf.reduce_sum(true_flat, axis=1) + smooth
loss = 1 - tf.reduce_mean(intersection / denominator)
return loss
def dice_loss_2d(Y_gt, Y_pred):
H, W, C = Y_gt.get_shape().as_list()[1:]
smooth = 1e-5
pred_flat = tf.reshape(Y_pred, [-1, H * W * C])
true_flat = tf.reshape(Y_gt, [-1, H * W * C])
intersection = 2 * tf.reduce_sum(pred_flat * true_flat, axis=1) + smooth
denominator = tf.reduce_sum(pred_flat, axis=1) + tf.reduce_sum(true_flat, axis=1) + smooth
loss = 1 - tf.reduce_mean(intersection / denominator)
return loss
tversky loss
def tversky_loss_3d(Y_gt, Y_pred, alpha=0.7):
Z, H, W, C = Y_gt.get_shape().as_list()[1:]
smooth = 1e-5
y_pred_pos = tf.reshape(Y_pred, [-1, H * W * C * Z])
y_true_pos = tf.reshape(Y_gt, [-1, H * W * C * Z])
true_pos = tf.reduce_sum(y_true_pos * y_pred_pos, axis=1)
false_neg = tf.reduce_sum(y_true_pos * (1 - y_pred_pos), axis=1)
false_pos = tf.reduce_sum((1 - y_true_pos) * y_pred_pos, axis=1)
tversky = (true_pos + smooth) / (true_pos + alpha * false_neg + (1 - alpha) * false_pos + smooth)
loss = 1 - tf.reduce_mean(tversky)
return loss
def tversky_loss_2d(Y_gt, Y_pred, alpha=0.7):
H, W, C = Y_gt.get_shape().as_list()[1:]
smooth = 1e-5
y_pred_pos = tf.reshape(Y_pred, [-1, H * W * C])
y_true_pos = tf.reshape(Y_gt, [-1, H * W * C])
true_pos = tf.reduce_sum(y_true_pos * y_pred_pos, axis=1)
false_neg = tf.reduce_sum(y_true_pos * (1 - y_pred_pos), axis=1)
false_pos = tf.reduce_sum((1 - y_true_pos) * y_pred_pos, axis=1)
tversky = (true_pos + smooth) / (true_pos + alpha * false_neg + (1 - alpha) * false_pos + smooth)
loss = 1 - tf.reduce_mean(tversky)
return loss
focal loss
def focal_tversky_3d(Y_gt, Y_pred, alpha=0.7, gamma=0.75):
Z, H, W, C = Y_gt.get_shape().as_list()[1:]
smooth = 1e-5
y_pred_pos = tf.reshape(Y_pred, [-1, H * W * C * Z])
y_true_pos = tf.reshape(Y_gt, [-1, H * W * C * Z])
true_pos = tf.reduce_sum(y_true_pos * y_pred_pos, axis=1)
false_neg = tf.reduce_sum(y_true_pos * (1 - y_pred_pos), axis=1)
false_pos = tf.reduce_sum((1 - y_true_pos) * y_pred_pos, axis=1)
tversky = (true_pos + smooth) / (true_pos + alpha * false_neg + (1 - alpha) * false_pos + smooth)
loss = 1 - tf.reduce_mean(tversky)
loss = tf.pow(loss, gamma)
return loss
def focal_tversky_2d(Y_gt, Y_pred, alpha=0.7, gamma=0.75):
H, W, C = Y_gt.get_shape().as_list()[1:]
smooth = 1e-5
y_pred_pos = tf.reshape(Y_pred, [-1, H * W * C])
y_true_pos = tf.reshape(Y_gt, [-1, H * W * C])
true_pos = tf.reduce_sum(y_true_pos * y_pred_pos, axis=1)
false_neg = tf.reduce_sum(y_true_pos * (1 - y_pred_pos), axis=1)
false_pos = tf.reduce_sum((1 - y_true_pos) * y_pred_pos, axis=1)
tversky = (true_pos + smooth) / (true_pos + alpha * false_neg + (1 - alpha) * false_pos + smooth)
loss = 1 - tf.reduce_mean(tversky)
loss = tf.pow(loss, gamma)
return loss
def generalised_dice_loss_3d(Y_gt, Y_pred):
smooth = 1e-5
w = tf.reduce_sum(Y_gt, axis=[1, 2, 3])
w = 1 / (w ** 2 + smooth)
numerator = Y_gt * Y_pred
numerator = w * tf.reduce_sum(numerator, axis=[1, 2, 3])
numerator = tf.reduce_sum(numerator, axis=1)
denominator = Y_pred + Y_gt
denominator = w * tf.reduce_sum(denominator, axis=[1, 2, 3])
denominator = tf.reduce_sum(denominator, axis=1)
gen_dice_coef = 2 * numerator / (denominator + smooth)
loss = tf.reduce_mean(1 - gen_dice_coef)
return loss
def generalised_dice_loss_2d_ein(Y_gt, Y_pred):
Y_gt = tf.cast(Y_gt, 'float32')
Y_pred = tf.cast(Y_pred, 'float32')
w = tf.einsum("bwhc->bc", Y_gt)
w = 1 / ((w + 1e-10) ** 2)
intersection = w * tf.einsum("bwhc,bwhc->bc", Y_pred, Y_gt)
union = w * (tf.einsum("bwhc->bc", Y_pred) + tf.einsum("bwhc->bc", Y_gt))
divided = 1 - 2 * (tf.einsum("bc->b", intersection) + 1e-10) / (tf.einsum("bc->b", union) + 1e-10)
loss = tf.reduce_mean(divided)
return loss
def generalised_dice_loss_2d(Y_gt, Y_pred):
smooth = 1e-5
w = tf.reduce_sum(Y_gt, axis=[1, 2])
w = 1 / (w ** 2 + smooth)
numerator = Y_gt * Y_pred
numerator = w * tf.reduce_sum(numerator, axis=[1, 2])
numerator = tf.reduce_sum(numerator, axis=1)
denominator = Y_pred + Y_gt
denominator = w * tf.reduce_sum(denominator, axis=[1, 2])
denominator = tf.reduce_sum(denominator, axis=1)
gen_dice_coef = 2 * numerator / (denominator + smooth)
loss = tf.reduce_mean(1 - gen_dice_coef)
return loss
def surface_loss_3d(Y_gt, Y_pred):
multipled = tf.reduce_sum(Y_gt * Y_pred, axis=[0,1, 2, 3, 4])
loss = tf.reduce_mean(multipled)
return loss
def surface_loss_2d(Y_gt, Y_pred):
multipled = tf.reduce_sum(Y_gt * Y_pred, axis=[0,1, 2, 3])
loss = tf.reduce_mean(multipled)
return loss