def test_single_scale_loss_other():
"""
Test value error raised if non supported
string passed to the single scale loss function.
"""
tensor_eye = tf.convert_to_tensor(np.zeros((3, 3, 3, 3)), dtype=tf.float32)
tensor_pred = tf.convert_to_tensor(np.zeros((3, 3, 3, 3)),
dtype=tf.float32)
with pytest.raises(ValueError):
label.single_scale_loss(tensor_eye, tensor_pred, "random")
def test_multi_scale_loss_kernel():
"""
Test multi-scale loss kernel returns the appropriate
loss tensor for same inputs and jaccard cal.
"""
loss_values = np.asarray([1, 2, 3])
array_eye = np.identity((3))
tensor_pred = np.zeros((3, 3, 3, 3))
tensor_eye = np.zeros((3, 3, 3, 3))
tensor_eye[:, :, 0:3, 0:3] = array_eye
tensor_pred[:, :, 0, 0] = array_eye
tensor_eye = tf.convert_to_tensor(tensor_eye, dtype=tf.double)
tensor_pred = tf.convert_to_tensor(tensor_pred, dtype=tf.double)
list_losses = np.array([
label.single_scale_loss(
y_true=label.separable_filter3d(tensor_eye,
label.gauss_kernel1d(s)),
y_pred=label.separable_filter3d(tensor_pred,
label.gauss_kernel1d(s)),
loss_type="jaccard",
) for s in loss_values
])
expect = np.mean(list_losses, axis=0)
get = label.multi_scale_loss(tensor_eye, tensor_pred, "jaccard",
loss_values)
assert assertTensorsEqual(get, expect)
def test_single_scale_loss_mean_sq():
"""
Test single scale loss function returns
known mean sq value tensor when passed with
mean squared arg,
"""
tensor_mask = np.zeros((3, 3, 3, 3))
tensor_mask[0, 0, 0, 0] = 1
tensor_pred = np.ones((3, 3, 3, 3))
expect = np.array([26 / 27, 1.0, 1.0])
get = label.single_scale_loss(tensor_mask, tensor_pred, "mean-squared")
assert assertTensorsEqual(get, expect)
def test_single_scale_loss_mean_sq():
"""
Test single scale loss function returns
known mean sq value tensor when passed with
mean squared arg,
"""
tensor_mask = np.zeros((3, 3, 3, 3))
tensor_mask[0, 0, 0, 0] = 1
tensor_mask = tf.convert_to_tensor(tensor_mask, dtype=tf.float32)
tensor_pred = tf.convert_to_tensor(np.ones((3, 3, 3, 3)), dtype=tf.float32)
expect = tf.convert_to_tensor(np.array([26 / 27, 1.0, 1.0]),
dtype=tf.float32)
get = label.single_scale_loss(tensor_mask, tensor_pred, "mean-squared")
assert is_equal_tf(get, expect)
def test_single_scale_loss_bce():
"""
Testing bce single scale loss entry
returns known loss tensor for given inputs.
"""
array_eye = np.identity((3))
tensor_eye = np.zeros((3, 3, 3, 3))
tensor_eye[:, :, 0:3, 0:3] = array_eye
tensor_pred = np.zeros((3, 3, 3, 3))
tensor_pred[:, 0:2, :, :] = array_eye
expect = [1.535057, 1.535057, 1.535057]
get = label.single_scale_loss(tensor_eye, tensor_pred, "cross-entropy")
assert assertTensorsEqual(get, expect)
def test_single_scale_loss_jacc():
"""
Testing single scale loss returns known loss
tensor when called with jaccard argment.
"""
array_eye = np.identity((3))
tensor_eye = np.zeros((3, 3, 3, 3))
tensor_eye[:, :, 0:3, 0:3] = array_eye
tensor_pred = np.zeros((3, 3, 3, 3))
tensor_pred[:, 0:2, :, :] = array_eye
num = np.array([6, 6, 6])
denom = np.array([9, 9, 9]) + np.array([6, 6, 6]) - num
expect = 1 - (num / denom)
get = label.single_scale_loss(tensor_eye, tensor_pred, "jaccard")
assert assertTensorsEqual(get, expect)
def test_single_scale_loss_bce():
"""
Testing bce single scale loss entry
returns known loss tensor for given inputs.
"""
array_eye = np.identity(3, dtype=np.float32)
tensor_eye = np.zeros((3, 3, 3, 3), dtype=np.float32)
tensor_eye[:, :, 0:3, 0:3] = array_eye
tensor_eye = tf.convert_to_tensor(tensor_eye, dtype=tf.float32)
tensor_pred = np.zeros((3, 3, 3, 3), dtype=np.float32)
tensor_pred[:, 0:2, :, :] = array_eye
tensor_pred = tf.convert_to_tensor(tensor_pred, dtype=tf.float32)
expect = [1.535057, 1.535057, 1.535057]
get = label.single_scale_loss(tensor_eye, tensor_pred, "cross-entropy")
assert is_equal_tf(get, expect)
def test_single_scale_loss_dice():
"""
Testing single sclare loss returns
precomputed, known dice loss for given
inputs.
"""
array_eye = np.identity((3))
tensor_eye = np.zeros((3, 3, 3, 3))
tensor_eye[:, :, 0:3, 0:3] = array_eye
tensor_pred = np.zeros((3, 3, 3, 3))
tensor_pred[:, 0:2, :, :] = array_eye
num = 2 * np.array([6, 6, 6])
denom = np.array([9, 9, 9]) + np.array([6, 6, 6])
expect = 1 - (num / denom)
get = label.single_scale_loss(tensor_eye, tensor_pred, "dice")
assert assertTensorsEqual(get, expect)
def test_single_scale_loss_jacc():
"""
Testing single scale loss returns known loss
tensor when called with jaccard argment.
"""
array_eye = np.identity(3, dtype=np.float32)
tensor_eye = np.zeros((3, 3, 3, 3), dtype=np.float32)
tensor_eye[:, :, 0:3, 0:3] = array_eye
tensor_eye = tf.convert_to_tensor(tensor_eye, dtype=tf.float32)
tensor_pred = np.zeros((3, 3, 3, 3), dtype=np.float32)
tensor_pred[:, 0:2, :, :] = array_eye
tensor_pred = tf.convert_to_tensor(tensor_pred, dtype=tf.float32)
num = np.array([6, 6, 6])
denom = np.array([9, 9, 9]) + np.array([6, 6, 6]) - num
expect = 1 - (num / denom)
get = label.single_scale_loss(tensor_eye, tensor_pred, "jaccard")
assert is_equal_tf(get, expect)
def test_single_scale_loss_dice():
"""
Testing single sclare loss returns
precomputed, known dice loss for given
inputs.
"""
array_eye = np.identity(3, dtype=np.float32)
tensor_eye = np.zeros((3, 3, 3, 3), dtype=np.float32)
tensor_eye[:, :, 0:3, 0:3] = array_eye
tensor_eye = tf.convert_to_tensor(tensor_eye, dtype=tf.float32)
tensor_pred = np.zeros((3, 3, 3, 3), dtype=np.float32)
tensor_pred[:, 0:2, :, :] = array_eye
tensor_pred = tf.convert_to_tensor(tensor_pred, dtype=tf.float32)
num = 2 * np.array([6, 6, 6])
denom = np.array([9, 9, 9]) + np.array([6, 6, 6])
expect = 1 - (num / denom)
get = label.single_scale_loss(tensor_eye, tensor_pred, "dice")
assert is_equal_tf(get, expect)
def test_single_scale_loss_dg():
"""
Testing generalised dice loss single
scale loss function returns known loss
tensor for given inputs.
"""
array_eye = 0.6 * np.identity((3))
tensor_eye = np.zeros((3, 3, 3, 3))
tensor_eye[:, :, 0:3, 0:3] = array_eye
tensor_pred = np.zeros((3, 3, 3, 3))
tensor_pred[:, 0:2, :, :] = array_eye
y_prod = np.sum(tensor_eye * tensor_pred, axis=(1, 2, 3))
y_sum = np.sum(tensor_eye, axis=(1, 2, 3)) + np.sum(tensor_pred,
axis=(1, 2, 3))
num = 2 * y_prod
den = y_sum
expect = 1 - num / den
get = label.single_scale_loss(tensor_eye, tensor_pred, "dice_generalized")
assert assertTensorsEqual(get, expect)
