From 7518feb7840fba1c5fa8e6aea1810baf7c44d5a8 Mon Sep 17 00:00:00 2001 From: Balgopal Moharana <99070111+lucifer4073@users.noreply.github.com> Date: Wed, 26 Feb 2025 18:14:12 +0530 Subject: [PATCH] [ENH] Test coverage for TimeCNNNetwork Improved (#2534) * Test coverage improved for cnn network * assertion changed for test_cnn * coverage improved along with naming --- aeon/networks/tests/test_cnn.py | 22 --- aeon/networks/tests/test_time_cnn.py | 274 +++++++++++++++++++++++++++ 2 files changed, 274 insertions(+), 22 deletions(-) delete mode 100644 aeon/networks/tests/test_cnn.py create mode 100644 aeon/networks/tests/test_time_cnn.py diff --git a/aeon/networks/tests/test_cnn.py b/aeon/networks/tests/test_cnn.py deleted file mode 100644 index c859397b34..0000000000 --- a/aeon/networks/tests/test_cnn.py +++ /dev/null @@ -1,22 +0,0 @@ -"""Tests for the CNN Model.""" - -import pytest - -from aeon.networks import TimeCNNNetwork -from aeon.utils.validation._dependencies import _check_soft_dependencies - -__maintainer__ = [] - - -@pytest.mark.skipif( - not _check_soft_dependencies(["tensorflow"], severity="none"), - reason="Tensorflow soft dependency unavailable.", -) -def test_cnn_input_shape_padding(): - """Test of CNN network with input_shape < 60.""" - input_shape = (40, 2) - network = TimeCNNNetwork() - input_layer, output_layer = network.build_network(input_shape=input_shape) - - assert input_layer is not None - assert output_layer is not None diff --git a/aeon/networks/tests/test_time_cnn.py b/aeon/networks/tests/test_time_cnn.py new file mode 100644 index 0000000000..3f31f1db10 --- /dev/null +++ b/aeon/networks/tests/test_time_cnn.py @@ -0,0 +1,274 @@ +"""Tests for the TimeCNNNetwork Model.""" + +import pytest + +from aeon.networks import TimeCNNNetwork +from aeon.utils.validation._dependencies import _check_soft_dependencies + + +@pytest.mark.skipif( + not _check_soft_dependencies(["tensorflow"], severity="none"), + reason="Tensorflow soft dependency unavailable.", +) +def test_time_cnn_input_shape_padding(): + """Test of CNN network with input_shape < 60.""" + input_shape = (40, 2) + network = TimeCNNNetwork() + input_layer, output_layer = network.build_network(input_shape=input_shape) + + assert hasattr(input_layer, "shape") + assert hasattr(output_layer, "shape") + + +@pytest.mark.skipif( + not _check_soft_dependencies(["tensorflow"], severity="none"), + reason="Tensorflow soft dependency unavailable.", +) +@pytest.mark.parametrize( + "activation, n_layers, should_raise", + [ + ("relu", 2, False), + ("sigmoid", 2, False), + ("tanh", 2, False), + (["relu", "sigmoid", "tanh"], 2, True), + (["relu"], 2, True), + ], +) +def test_time_cnn_activation(activation, n_layers, should_raise): + """Test activation configuration handling.""" + input_shape = (100, 5) + if should_raise: + with pytest.raises(ValueError): + network = TimeCNNNetwork(activation=activation, n_layers=n_layers) + network.build_network(input_shape=input_shape) + else: + network = TimeCNNNetwork(activation=activation, n_layers=n_layers) + input_layer, output_layer = network.build_network(input_shape=input_shape) + + assert hasattr(input_layer, "shape") + assert hasattr(output_layer, "shape") + + +@pytest.mark.skipif( + not _check_soft_dependencies(["tensorflow"], severity="none"), + reason="Tensorflow soft dependency unavailable.", +) +@pytest.mark.parametrize( + "kernel_size, n_layers, should_raise", + [ + (7, 2, False), + ([5, 3], 2, False), + ([5, 3, 2], 2, True), + ([5], 2, True), + ], +) +def test_time_cnn_kernel_size(kernel_size, n_layers, should_raise): + """Test kernel size configuration with different layer counts.""" + input_shape = (100, 5) + if should_raise: + with pytest.raises(ValueError): + network = TimeCNNNetwork(n_layers=n_layers, kernel_size=kernel_size) + network.build_network(input_shape=input_shape) + else: + network = TimeCNNNetwork(n_layers=n_layers, kernel_size=kernel_size) + input_layer, output_layer = network.build_network(input_shape=input_shape) + + assert hasattr(input_layer, "shape") + assert hasattr(output_layer, "shape") + + +@pytest.mark.skipif( + not _check_soft_dependencies(["tensorflow"], severity="none"), + reason="Tensorflow soft dependency unavailable.", +) +@pytest.mark.parametrize( + "n_layers,n_filters,should_raise", + [ + (2, [8, 16], False), + (1, [12, 10, 4], True), + (2, 8, False), + (3, [8], True), + ], +) +def test_time_cnn_n_filters(n_layers, n_filters, should_raise): + """Test filter configuration handling.""" + input_shape = (100, 5) + if should_raise: + with pytest.raises(ValueError): + network = TimeCNNNetwork(n_layers=n_layers, n_filters=n_filters) + network.build_network(input_shape=input_shape) + else: + network = TimeCNNNetwork(n_layers=n_layers, n_filters=n_filters) + input_layer, output_layer = network.build_network(input_shape=input_shape) + + assert hasattr(input_layer, "shape") + assert hasattr(output_layer, "shape") + + +@pytest.mark.skipif( + not _check_soft_dependencies(["tensorflow"], severity="none"), + reason="Tensorflow soft dependency unavailable.", +) +@pytest.mark.parametrize( + "avg_pool_size, n_layers, should_raise", + [ + (3, 2, False), + ([2, 3], 2, False), + ([2, 3, 4], 2, True), + ([2], 2, True), + ], +) +def test_time_cnn_avg_pool_size(avg_pool_size, n_layers, should_raise): + """Test average pool size configuration.""" + input_shape = (100, 5) + if should_raise: + with pytest.raises(ValueError): + network = TimeCNNNetwork(avg_pool_size=avg_pool_size, n_layers=n_layers) + network.build_network(input_shape=input_shape) + else: + network = TimeCNNNetwork(avg_pool_size=avg_pool_size, n_layers=n_layers) + input_layer, output_layer = network.build_network(input_shape=input_shape) + + assert hasattr(input_layer, "shape") + assert hasattr(output_layer, "shape") + + +@pytest.mark.skipif( + not _check_soft_dependencies(["tensorflow"], severity="none"), + reason="Tensorflow soft dependency unavailable.", +) +@pytest.mark.parametrize( + "strides_pooling, n_layers, should_raise", + [ + (None, 2, False), + (2, 2, False), + ([2, 3], 2, False), + ([2, 3, 4], 2, True), + ([2], 2, True), + ], +) +def test_time_cnn_strides_pooling(strides_pooling, n_layers, should_raise): + """Test strides pooling configuration.""" + input_shape = (100, 5) + if should_raise: + with pytest.raises(ValueError): + network = TimeCNNNetwork(strides_pooling=strides_pooling, n_layers=n_layers) + network.build_network(input_shape=input_shape) + else: + network = TimeCNNNetwork(strides_pooling=strides_pooling, n_layers=n_layers) + input_layer, output_layer = network.build_network(input_shape=input_shape) + + assert hasattr(input_layer, "shape") + assert hasattr(output_layer, "shape") + + +@pytest.mark.skipif( + not _check_soft_dependencies(["tensorflow"], severity="none"), + reason="Tensorflow soft dependency unavailable.", +) +@pytest.mark.parametrize( + "padding, n_layers, should_raise", + [ + ("valid", 2, False), + ("same", 2, False), + (["same", "valid"], 2, False), + (["same", "valid", "same"], 2, True), + (["same"], 2, True), + ], +) +def test_time_cnn_padding(padding, n_layers, should_raise): + """Test padding override behavior for different inputs.""" + input_shape = (100, 5) + if should_raise: + with pytest.raises(ValueError): + network = TimeCNNNetwork(padding=padding, n_layers=n_layers) + network.build_network(input_shape=input_shape) + else: + network = TimeCNNNetwork(padding=padding, n_layers=n_layers) + input_layer, output_layer = network.build_network(input_shape=input_shape) + assert hasattr(input_layer, "shape") + assert hasattr(output_layer, "shape") + + +@pytest.mark.skipif( + not _check_soft_dependencies(["tensorflow"], severity="none"), + reason="Tensorflow soft dependency unavailable.", +) +@pytest.mark.parametrize( + "dilation, n_layers, should_raise", + [ + (2, 2, False), + ([1, 2], 2, False), + ([1, 2, 3], 2, True), + ([1], 2, True), + ], +) +def test_time_cnn_dilation_rate(dilation, n_layers, should_raise): + """Test dilation rate configuration.""" + input_shape = (100, 5) + if should_raise: + with pytest.raises(ValueError): + network = TimeCNNNetwork(dilation_rate=dilation, n_layers=n_layers) + network.build_network(input_shape=input_shape) + else: + network = TimeCNNNetwork(dilation_rate=dilation, n_layers=n_layers) + input_layer, output_layer = network.build_network(input_shape=input_shape) + + assert hasattr(input_layer, "shape") + assert hasattr(output_layer, "shape") + + +@pytest.mark.skipif( + not _check_soft_dependencies(["tensorflow"], severity="none"), + reason="Tensorflow soft dependency unavailable.", +) +@pytest.mark.parametrize( + "strides, n_layers, should_raise", + [ + (1, 2, False), + ([1, 2], 2, False), + ([1, 2, 3], 2, True), + ([1], 2, True), + ], +) +def test_time_cnn_strides(strides, n_layers, should_raise): + """Test strides configuration.""" + input_shape = (100, 5) + if should_raise: + with pytest.raises(ValueError): + network = TimeCNNNetwork(strides=strides, n_layers=n_layers) + network.build_network(input_shape=input_shape) + else: + network = TimeCNNNetwork(strides=strides, n_layers=n_layers) + input_layer, output_layer = network.build_network(input_shape=input_shape) + + assert hasattr(input_layer, "shape") + assert hasattr(output_layer, "shape") + + +@pytest.mark.skipif( + not _check_soft_dependencies(["tensorflow"], severity="none"), + reason="Tensorflow soft dependency unavailable.", +) +@pytest.mark.parametrize( + "use_bias, n_layers, should_raise", + [ + (True, 2, False), + ([True, False], 2, False), + ([True, False, True], 2, True), + ([True], 2, True), + ], +) +def test_time_cnn_use_bias(use_bias, n_layers, should_raise): + """Test bias usage configuration.""" + input_shape = (100, 5) + if should_raise: + with pytest.raises(ValueError): + network = TimeCNNNetwork(use_bias=use_bias, n_layers=n_layers) + network.build_network(input_shape=input_shape) + else: + network = TimeCNNNetwork(use_bias=use_bias, n_layers=n_layers) + input_layer, output_layer = network.build_network(input_shape=input_shape) + + assert hasattr(input_layer, "shape") + assert hasattr(output_layer, "shape")