test.unit.test_loss_util

Complexity

Total Complexity

10

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Importance

Changes

0

7 Functions

Rating	Name	Duplication	Size	Complexity
A	test_separable_filter()	0	18	1
A	test_negative_loss_mixin()	0	16	1
A	test_gaussian_kernel1d_sigma()	0	7	1
A	test_triangular_kernel1d()	0	10	2
A	test_cauchy_kernel1d()	0	7	1
A	test_gaussian_kernel1d_size()	0	10	1
A	test_rectangular_kernel1d()	0	5	1

# coding=utf-8

"""
Tests for deepreg/model/loss/label.py in
pytest style
"""

from test.unit.util import is_equal_tf

import numpy as np
import pytest
import tensorflow as tf

from deepreg.loss.util import (
    NegativeLossMixin,
    cauchy_kernel1d,
    gaussian_kernel1d_sigma,
    gaussian_kernel1d_size,
    rectangular_kernel1d,
    separable_filter,
    triangular_kernel1d,
)


@pytest.mark.parametrize("sigma", [1, 3, 2.2])
def test_gaussian_kernel1d_sigma(sigma):

Missing function or method docstring

    tail = int(sigma * 3)
    expected = [np.exp(-0.5 * x ** 2 / sigma ** 2) for x in range(-tail, tail + 1)]
    expected = expected / np.sum(expected)
    got = gaussian_kernel1d_sigma(sigma)
    assert is_equal_tf(got, expected)


@pytest.mark.parametrize("sigma", [1, 3, 2.2])
def test_cauchy_kernel1d(sigma):

Missing function or method docstring

    tail = int(sigma * 5)
    expected = [1 / ((x / sigma) ** 2 + 1) for x in range(-tail, tail + 1)]
    expected = expected / np.sum(expected)
    got = cauchy_kernel1d(sigma)
    assert is_equal_tf(got, expected)


@pytest.mark.parametrize("kernel_size", [3, 7, 11])
def test_gaussian_kernel1d_size(kernel_size):

Missing function or method docstring

    mean = (kernel_size - 1) / 2.0
    sigma = kernel_size / 3

    grid = tf.range(0, kernel_size, dtype=tf.float32)
    expected = tf.exp(-tf.square(grid - mean) / (2 * sigma ** 2))

bad operand type for unary -: object

    got = gaussian_kernel1d_size(kernel_size)
    assert is_equal_tf(got, expected)


@pytest.mark.parametrize("kernel_size", [3, 7, 11])
def test_rectangular_kernel1d(kernel_size):

Missing function or method docstring

    expected = tf.ones(shape=(kernel_size,), dtype=tf.float32)
    got = rectangular_kernel1d(kernel_size)
    assert is_equal_tf(got, expected)


@pytest.mark.parametrize("kernel_size", [3, 7, 11])
def test_triangular_kernel1d(kernel_size):

Missing function or method docstring

    expected = np.zeros(shape=(kernel_size,), dtype=np.float32)
    expected[kernel_size // 2] = kernel_size // 2 + 1
    for it_k in range(kernel_size // 2):
        expected[it_k] = it_k + 1
        expected[-it_k - 1] = it_k + 1

    got = triangular_kernel1d(kernel_size)
    assert is_equal_tf(got, expected)


def test_separable_filter():
    """
    Testing separable filter case where non
    zero length tensor is passed to the
    function.
    """
    k = np.ones((3, 3, 3, 3, 1), dtype=np.float32)
    array_eye = np.identity(3, dtype=np.float32)
    tensor_pred = np.zeros((3, 3, 3, 3, 1), dtype=np.float32)
    tensor_pred[:, :, 0, 0, 0] = array_eye
    tensor_pred = tf.convert_to_tensor(tensor_pred, dtype=tf.float32)
    k = tf.convert_to_tensor(k, dtype=tf.float32)

    expect = np.ones((3, 3, 3, 3, 1), dtype=np.float32)
    expect = tf.convert_to_tensor(expect, dtype=tf.float32)

    get = separable_filter(tensor_pred, k)
    assert is_equal_tf(get, expect)


class MinusClass(tf.keras.losses.Loss):

Missing class docstring

    def __init__(self):
        super().__init__()
        self.name = "MinusClass"

    def call(self, y_true, y_pred):
        return y_true - y_pred


class MinusClassLoss(NegativeLossMixin, MinusClass):

Missing class docstring

    pass


@pytest.mark.parametrize("y_true,y_pred,expected", [(1, 2, 1), (2, 1, -1), (0, 0, 0)])
def test_negative_loss_mixin(y_true, y_pred, expected):

"expected, y_pred, y_true" missing in parameter documentation

"expected, y_pred, y_true" missing in parameter type documentation

    """
    Testing NegativeLossMixin class that
    inverts the sign of any value
    returned by a function
    """

    y_true = tf.constant(y_true, dtype=tf.float32)
    y_pred = tf.constant(y_pred, dtype=tf.float32)

    got = MinusClassLoss().call(
        y_true,
        y_pred,
    )
    assert is_equal_tf(got, expected)