Skip to content
Snippets Groups Projects
Select Git revision
  • 24df7f38d2541128d29a37eaea33e71f6c789089
  • main default protected
2 results

start_interactive_gpu_job.sh

Blame
  • test_model_class.py 11.42 KiB
    import keras
    import pytest
    
    from mlair.model_modules.model_class import AbstractModelClass
    from mlair.model_modules.model_class import MyPaperModel
    
    
    class Paddings:
        allowed_paddings = {"pad1": 34, "another_pad": True}
    
    
    class AbstractModelSubClass(AbstractModelClass):
    
        def __init__(self):
            super().__init__(input_shape=(12, 1, 2), output_shape=3)
            self.test_attr = "testAttr"
    
    
    class TestAbstractModelClass:
    
        @pytest.fixture
        def amc(self):
            return AbstractModelClass(input_shape=(14, 1, 2), output_shape=(3,))
    
        @pytest.fixture
        def amsc(self):
            return AbstractModelSubClass()
    
        def test_init(self, amc):
            assert amc.model is None
            # assert amc.loss is None
            assert amc.model_name == "AbstractModelClass"
            assert amc.custom_objects == {}
            assert amc._input_shape == (14, 1, 2)
            assert amc._output_shape == 3
    
        def test_model_property(self, amc):
            amc.model = keras.Model()
            assert isinstance(amc.model, keras.Model) is True
    
        # def test_loss_property(self, amc):
        #     amc.loss = keras.losses.mean_absolute_error
        #     assert amc.loss == keras.losses.mean_absolute_error
    
        def test_compile_options_setter_all_empty(self, amc):
            amc.compile_options = None
            assert amc.compile_options == {'optimizer': None,
                                           'loss': None,
                                           'metrics': None,
                                           'loss_weights': None,
                                           'sample_weight_mode': None,
                                           'weighted_metrics': None,
                                           'target_tensors': None
                                           }
    
        def test_compile_options_setter_as_dict(self, amc):
            amc.compile_options = {"optimizer": keras.optimizers.SGD(),
                                   "loss": keras.losses.mean_absolute_error,
                                   "metrics": ["mse", "mae"]}
            assert isinstance(amc.compile_options["optimizer"], keras.optimizers.SGD)
            assert amc.compile_options["loss"] == keras.losses.mean_absolute_error
            assert amc.compile_options["metrics"] == ["mse", "mae"]
            assert amc.compile_options["loss_weights"] is None
            assert amc.compile_options["sample_weight_mode"] is None
            assert amc.compile_options["target_tensors"] is None
            assert amc.compile_options["weighted_metrics"] is None
    
        def test_compile_options_setter_as_attr(self, amc):
            amc.optimizer = keras.optimizers.SGD()
            amc.loss = keras.losses.mean_absolute_error
            amc.compile_options = None  # This line has to be called!
            # optimizer check
            assert isinstance(amc.optimizer, keras.optimizers.SGD)
            assert isinstance(amc.compile_options["optimizer"], keras.optimizers.SGD)
            # loss check
            assert amc.loss == keras.losses.mean_absolute_error
            assert amc.compile_options["loss"] == keras.losses.mean_absolute_error
            # check rest (all None as not set)
            assert amc.compile_options["metrics"] is None
            assert amc.compile_options["loss_weights"] is None
            assert amc.compile_options["sample_weight_mode"] is None
            assert amc.compile_options["target_tensors"] is None
            assert amc.compile_options["weighted_metrics"] is None
    
        def test_compile_options_setter_as_mix_attr_dict_no_duplicates(self, amc):
            amc.optimizer = keras.optimizers.SGD()
            amc.compile_options = {"loss": keras.losses.mean_absolute_error,
                                   "loss_weights": [0.2, 0.8]}
            # check setting by attribute
            assert isinstance(amc.optimizer, keras.optimizers.SGD)
            assert isinstance(amc.compile_options["optimizer"], keras.optimizers.SGD)
            # check setting by dict
            assert amc.compile_options["loss"] == keras.losses.mean_absolute_error
            assert amc.compile_options["loss_weights"] == [0.2, 0.8]
            # check rest (all None as not set)
            assert amc.compile_options["metrics"] is None
            assert amc.compile_options["sample_weight_mode"] is None
            assert amc.compile_options["target_tensors"] is None
            assert amc.compile_options["weighted_metrics"] is None
    
        def test_compile_options_setter_as_mix_attr_dict_valid_duplicates_optimizer(self, amc):
            amc.optimizer = keras.optimizers.SGD()
            amc.metrics = ['mse']
            amc.compile_options = {"optimizer": keras.optimizers.SGD(),
                                   "loss": keras.losses.mean_absolute_error}
            # check duplicate (attr and dic)
            assert isinstance(amc.optimizer, keras.optimizers.SGD)
            assert isinstance(amc.compile_options["optimizer"], keras.optimizers.SGD)
            # check setting by dict
            assert amc.compile_options["loss"] == keras.losses.mean_absolute_error
            # check setting by attr
            assert amc.metrics == ['mse']
            assert amc.compile_options["metrics"] == ['mse']
            # check rest (all None as not set)
            assert amc.compile_options["loss_weights"] is None
            assert amc.compile_options["sample_weight_mode"] is None
            assert amc.compile_options["target_tensors"] is None
            assert amc.compile_options["weighted_metrics"] is None
    
        def test_compile_options_setter_as_mix_attr_dict_valid_duplicates_none_optimizer(self, amc):
            amc.optimizer = keras.optimizers.SGD()
            amc.metrics = ['mse']
            amc.compile_options = {"metrics": ['mse'],
                                   "loss": keras.losses.mean_absolute_error}
            # check duplicate (attr and dic)
            assert amc.metrics == ['mse']
            assert amc.compile_options["metrics"] == ['mse']
            # check setting by dict
            assert amc.compile_options["loss"] == keras.losses.mean_absolute_error
            # check setting by attr
            assert isinstance(amc.optimizer, keras.optimizers.SGD)
            assert isinstance(amc.compile_options["optimizer"], keras.optimizers.SGD)
            # check rest (all None as not set)
            assert amc.compile_options["loss_weights"] is None
            assert amc.compile_options["sample_weight_mode"] is None
            assert amc.compile_options["target_tensors"] is None
            assert amc.compile_options["weighted_metrics"] is None
    
        def test_compile_options_property_type_error(self, amc):
            with pytest.raises(TypeError) as einfo:
                amc.compile_options = 'hello world'
            assert "`compile_options' must be `dict' or `None', but is <class 'str'>." in str(einfo.value)
    
        def test_compile_options_setter_as_mix_attr_dict_invalid_duplicates_other_optimizer(self, amc):
            amc.optimizer = keras.optimizers.SGD()
            with pytest.raises(ValueError) as einfo:
                amc.compile_options = {"optimizer": keras.optimizers.Adam()}
            assert "Got different values or arguments for same argument: self.optimizer=<class" \
                   " 'keras.optimizers.SGD'> and 'optimizer': <class 'keras.optimizers.Adam'>" in str(einfo.value)
    
        def test_compile_options_setter_as_mix_attr_dict_invalid_duplicates_same_optimizer_other_args(self, amc):
            amc.optimizer = keras.optimizers.SGD(lr=0.1)
            with pytest.raises(ValueError) as einfo:
                amc.compile_options = {"optimizer": keras.optimizers.SGD(lr=0.001)}
            assert "Got different values or arguments for same argument: self.optimizer=<class" \
                   " 'keras.optimizers.SGD'> and 'optimizer': <class 'keras.optimizers.SGD'>" in str(einfo.value)
    
        def test_compile_options_setter_as_dict_invalid_keys(self, amc):
            with pytest.raises(ValueError) as einfo:
                amc.compile_options = {"optimizer": keras.optimizers.SGD(), "InvalidKeyword": [1, 2, 3]}
            assert "Got invalid key for compile_options. dict_keys(['optimizer', 'InvalidKeyword'])" in str(einfo.value)
    
        def test_compare_keras_optimizers_equal(self, amc):
            assert amc._AbstractModelClass__compare_keras_optimizers(keras.optimizers.SGD(), keras.optimizers.SGD()) is True
    
        def test_compare_keras_optimizers_no_optimizer(self, amc):
            assert amc._AbstractModelClass__compare_keras_optimizers('NoOptimizer', keras.optimizers.SGD()) is False
    
        def test_compare_keras_optimizers_other_parameters_run_sess(self, amc):
            assert amc._AbstractModelClass__compare_keras_optimizers(keras.optimizers.SGD(lr=0.1),
                                                                     keras.optimizers.SGD(lr=0.01)) is False
    
        def test_compare_keras_optimizers_other_parameters_none_sess(self, amc):
            assert amc._AbstractModelClass__compare_keras_optimizers(keras.optimizers.SGD(decay=1),
                                                                     keras.optimizers.SGD(decay=0.01)) is False
    
        def test_getattr(self, amc):
            amc.model = keras.Model()
            assert hasattr(amc, "compile") is True
            assert hasattr(amc.model, "compile") is True
            assert amc.compile == amc.model.compile
    
        def test_get_settings(self, amc, amsc):
            assert amc.get_settings() == {"model_name": "AbstractModelClass", "_input_shape": (14, 1, 2),
                                          "_output_shape": 3}
            assert amsc.get_settings() == {"test_attr": "testAttr", "model_name": "AbstractModelSubClass",
                                           "_input_shape": (12, 1, 2), "_output_shape": 3}
    
        def test_custom_objects(self, amc):
            amc.custom_objects = {"Test": 123}
            assert amc.custom_objects == {"Test": 123}
    
        def test_set_custom_objects(self, amc):
            amc.set_custom_objects(Test=22, minor_param="minor")
            assert amc.custom_objects == {"Test": 22, "minor_param": "minor"}
            amc.set_custom_objects(Test=2, minor_param1="minor1")
            assert amc.custom_objects == {"Test": 2, "minor_param1": "minor1"}
            paddings = Paddings()
            amc.set_custom_objects(Test=1, Padding2D=paddings)
            assert amc.custom_objects == {"Test": 1, "Padding2D": paddings, "pad1": 34, "another_pad": True}
    
    
    class TestMyPaperModel:
    
        @pytest.fixture
        def mpm(self):
            return MyPaperModel(input_shape=[(7, 1, 9)], output_shape=[(4,)])
    
        def test_init(self, mpm):
            # check if loss number of loss functions fit to model outputs
            #       same loss fkts. for all tails               or different fkts. per tail
            if isinstance(mpm.model.output_shape, list):
                assert (callable(mpm.compile_options["loss"]) or (len(mpm.compile_options["loss"]) == 1)) or (
                            len(mpm.compile_options["loss"]) == len(mpm.model.output_shape))
            elif isinstance(mpm.model.output_shape, tuple):
                assert callable(mpm.compile_options["loss"]) or (len(mpm.compile_options["loss"]) == 1)
    
        def test_set_model(self, mpm):
            assert isinstance(mpm.model, keras.Model)
            assert mpm.model.layers[0].output_shape == (None, 7, 1, 9)
            # check output dimensions
            if isinstance(mpm.model.output_shape, tuple):
                assert mpm.model.output_shape == (None, 4)
            elif isinstance(mpm.model.output_shape, list):
                for tail_shape in mpm.model.output_shape:
                    assert tail_shape == (None, 4)
            else:
                raise TypeError(f"Type of model.output_shape as to be a tuple (one tail)"
                                f" or a list of tuples (multiple tails). Received: {type(mpm.model.output_shape)}")
    
        # def test_set_loss(self, mpm):
        #     assert callable(mpm.loss) or (len(mpm.loss) > 0)
    
        def test_set_compile_options(self, mpm):
            assert callable(mpm.compile_options["loss"]) or (len(mpm.compile_options["loss"]) > 0)