def IOU_calc(y_true, y_pred):
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 + iou_smooth) / (K.sum(y_true_f) +
K.sum(y_pred_f) + iou_smooth)
def dice_coef(y_true, y_pred):
smooth = 1e-7
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 * 0.01) / (K.sum(y_true_f) +
K.sum(y_pred_f) + smooth)
def dice_coeff(y_true, y_pred):
smooth = 0.001
y_true = K.flatten(y_true)
y_pred = K.flatten(y_pred)
intersection = K.sum(y_true * y_pred)
return (2. * intersection + smooth) / (K.sum(y_true) + K.sum(y_pred) +
smooth)
def dice_coef(y_true, y_pred, smooth=1e-3):
y_true_f = K.flatten(y_true)
y_pred_f = K.flatten(y_pred)
intersection = K.sum(y_true_f * y_pred_f)
return K.mean(
(2.0 * intersection + smooth)
/ (K.sum(y_true_f) + K.sum(y_pred_f) + smooth)
)
def __metrics_base(self, y_true, y_pred):
""" Base for all the metrics defined below """
y_true, y_pred = K.flatten(tf.math.argmax(y_true, axis=-1)), K.flatten(
tf.math.argmax(y_pred, axis=-1))
con_mat = K.cast(tf.math.confusion_matrix(y_true, y_pred), K.floatx())
correct = tf.linalg.diag_part(con_mat)
total = K.sum(con_mat, axis=-1)
return correct, total, con_mat
def dice_coef(y_true, y_pred):
#y_true_f = K.flatten(y_true.astype('float32'))
#y_pred_f = K.flatten(y_pred.astype('float32'))
y_true_f = K.flatten(y_true) # K.flatten(y_true.astype('float32'))
y_pred_f = K.flatten(y_pred) # K.flatten(y_pred.astype('float32'))
print (y_true_f)
print ("******************")
print (y_pred_f)
intersection = K.sum(y_true_f * y_pred_f)
return (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth)
def dice_axon(y_true, y_pred, smooth=1e-3):
"""
Computes the pixel-wise dice myelin coefficient from the prediction tensor outputted by the network.
:param y_pred: Tensor, the prediction outputed by the network. Shape (N,H,W,C).
:param y_true: Tensor, the gold standard we work with. Shape (N,H,W,C).
:return: dice axon coefficient for the current batch.
"""
y_true_f = K.flatten(y_true[..., 2])
y_pred_f = K.flatten(y_pred[..., 2])
intersection = K.sum(y_true_f * y_pred_f)
return K.mean((2. * intersection + smooth) /
(K.sum(y_true_f) + K.sum(y_pred_f) + smooth))
def yolo_head(graph, feats, anchors, num_classes):
with graph.as_default():
num_anchors = len(anchors)
anchors_tensor = K.reshape(K.variable(anchors),
[1, 1, 1, num_anchors, 2])
conv_dims = K.shape(feats)[1:3]
conv_height_index = K.arange(0, stop=conv_dims[0])
conv_width_index = K.arange(0, stop=conv_dims[1])
conv_height_index = K.tile(conv_height_index, [conv_dims[1]])
conv_width_index = K.tile(K.expand_dims(conv_width_index, 0),
[conv_dims[0], 1])
conv_width_index = K.flatten(K.transpose(conv_width_index))
conv_index = K.transpose(K.stack([conv_height_index,
conv_width_index]))
conv_index = K.reshape(conv_index,
[1, conv_dims[0], conv_dims[1], 1, 2])
conv_index = K.cast(conv_index, K.dtype(feats))
feats = K.reshape(
feats,
[-1, conv_dims[0], conv_dims[1], num_anchors, num_classes + 5])
conv_dims = K.cast(K.reshape(conv_dims, [1, 1, 1, 1, 2]),
K.dtype(feats))
box_xy = K.sigmoid(feats[..., :2])
box_wh = K.exp(feats[..., 2:4])
box_confidence = K.sigmoid(feats[..., 4:5])
box_class_probs = K.softmax(feats[..., 5:])
box_xy = (box_xy + conv_index) / conv_dims
box_wh = box_wh * anchors_tensor / conv_dims
return box_xy, box_wh, box_confidence, box_class_probs
def K_sparse_categorical_crossentropy(target,
output,
from_logits=False,
axis=-1):
output_dimensions = list(range(len(output.get_shape())))
if axis != -1 and axis not in output_dimensions:
raise ValueError('{}{}{}'.format(
'Unexpected channels axis {}. '.format(axis),
'Expected to be -1 or one of the axes of `output`, ',
'which has {} dimensions.'.format(len(output.get_shape()))))
# If the channels are not in the last axis, move them to be there:
if axis != -1 and axis != output_dimensions[-1]:
permutation = output_dimensions[:axis] + output_dimensions[axis + 1:]
permutation += [axis]
output = tf.transpose(output, perm=permutation)
# Note: tf.nn.sparse_softmax_cross_entropy_with_logits
# expects logits, Keras expects probabilities.
if not from_logits:
_epsilon = _to_tensor(epsilon(), output.dtype.base_dtype)
output = tf.clip_by_value(output, _epsilon, 1 - _epsilon)
output = tf.log(output)
output_shape = output.get_shape()
targets = cast(flatten(target), 'int64')
logits = tf.reshape(output, [-1, tf.shape(output)[-1]])
res = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=targets,
logits=logits)
if len(output_shape) >= 3:
# if our output includes timestep dimension
# or spatial dimensions we need to reshape
return tf.reshape(res, tf.shape(output)[:-1])
else:
return res
def dice_coef(self, y_true, y_pred):
y_true_f = ktf.flatten(y_true)
y_pred_f = ktf.flatten(y_pred)
intersection = ktf.sum(y_true_f * y_pred_f)
return (2. * intersection + self.smooth) / (ktf.sum(y_true_f) + ktf.sum(y_pred_f) + self.smooth)
