• Search by Module
• Search by Words
• Search Projects

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• delira-master
  • .github
    • ISSUE_TEMPLATE
      • question.md
      • feature_request.md
      • bug_report.md
  • LICENSE
  • .readthedocs.yml
  • CONTRIBUTING.md
  • versioneer.py
  • .gitattributes
  • paper
    • paper.md
    • paper.bib
  • notebooks
    • tutorial_delira.ipynb
    • segmentation_2d_pytorch.ipynb
    • segmentation_3d_pytorch.ipynb
    • classification_examples
      • pytorch.ipynb
      • sklearn.ipynb
      • torchscript.ipynb
      • tf_eager.ipynb
      • chainer.ipynb
      • tf_graph.ipynb
    • custom_backend.ipynb
    • gan_pytorch.ipynb
  • setup.py
  • docker
    • Dockerfile
  • AUTHORS.rst
  • setup.cfg
  • .travis.yml
  • README.md
  • delira
    • utils
      • decorators.py
      • config.py
      • path.py
      • codecs.py
      • messenger.py
      • __init__.py
      • context_managers.py
      • dict_reductions.py
      • time.py
    • training
      • predictor.py
      • callbacks
        • pytorch_schedulers.py
        • logging_callback.py
        • abstract_callback.py
        • __init__.py
        • early_stopping.py
      • backends
        • tf_eager
          • experiment.py
          • __init__.py
          • utils.py
          • trainer.py
        • torchscript
          • experiment.py
          • __init__.py
          • trainer.py
        • sklearn
          • experiment.py
          • __init__.py
          • utils.py
          • trainer.py
        • torch
          • experiment.py
          • __init__.py
          • utils.py
          • trainer.py
        • __init__.py
        • chainer
          • experiment.py
          • __init__.py
          • utils.py
          • trainer.py
        • tf_graph
          • experiment.py
          • __init__.py
          • utils.py
          • trainer.py
      • metrics.py
      • losses.py
      • base_trainer.py
      • base_experiment.py
      • __init__.py
      • utils.py
    • models
      • backends
        • tf_eager
          • data_parallel.py
          • __init__.py
          • abstract_network.py
        • torchscript
          • __init__.py
          • abstract_network.py
        • sklearn
          • __init__.py
          • abstract_network.py
        • torch
          • data_parallel.py
          • __init__.py
          • utils.py
          • abstract_network.py
        • __init__.py
        • chainer
          • data_parallel.py
          • __init__.py
          • abstract_network.py
        • tf_graph
          • __init__.py
          • abstract_network.py
      • __init__.py
      • abstract_network.py
    • io
      • torch.py
      • chainer.py
      • __init__.py
      • sklearn.py
      • tf.py
    • __init__.py
    • data_loading
      • data_loader.py
      • augmenter.py
      • __init__.py
      • sampler
        • sequential.py
        • weighted.py
        • random.py
        • batch.py
        • __init__.py
        • abstract.py
      • data_manager.py
      • numba_transform.py
      • dataset.py
      • load_utils.py
    • _version.py
    • _debug_mode.py
    • logging
      • writer_backend.py
      • base_backend.py
      • logging_context.py
      • visdom_backend.py
      • registry.py
      • __init__.py
      • base_logger.py
      • tensorboard_backend.py
    • _backends.py
  • tests
    • utils
      • test_codecs.py
      • test_messenger.py
      • test_config.py
      • __init__.py
      • dict_reductions.py
    • training
      • test_losses_torch.py
      • backends
        • test_chainer.py
        • test_sklearn.py
        • test_torch.py
        • test_tf_graph.py
        • __init__.py
        • utils.py
        • test_tf_eager.py
        • test_torchscript.py
      • __init__.py
      • test_metrics.py
    • models
      • data_parallel
        • test_chainer.py
        • test_torch.py
        • __init__.py
      • test_abstract_models.py
      • __init__.py
    • io
      • test_chainer.py
      • test_sklearn.py
      • test_tf.py
      • test_torch.py
      • __init__.py
    • __init__.py
    • data_loading
      • test_augmenters.py
      • test_dataset.py
      • test_numba_transforms.py
      • test_data_loader.py
      • __init__.py
      • utils.py
      • test_sampler.py
      • test_data_manager.py
    • logging
      • test_single_threaded_logging.py
      • test_logging_outside_trainer.py
      • __init__.py
      • test_logging_frequency.py
  • pytest.ini
  • scripts
    • ci
      • install_before_docs.sh
      • run_tests.sh
      • install_before_tests.sh
      • install_before_style_check.sh
      • build_docs.sh
      • run_style_checks.sh
  • CODEOWNERS
  • .codecov.yml
  • .gitignore
  • docs
    • _api
      • _build
        • delira
          • delira.utils.rst
          • training
            • predictor.rst
            • callbacks.rst
            • backends
              • torchscript.rst
              • backends.rst
              • chainer.rst
              • sklearn.rst
              • tfgraph.rst
              • tfeager.rst
              • torch.rst
            • metrics.rst
            • training.rst
            • losses.rst
            • experiment.rst
            • utils.rst
            • trainer.rst
            • parameters.rst
          • delira.io.rst
          • backend_resolution.rst
          • models
            • torchscript.rst
            • chainer.rst
            • sklearn.rst
            • tfgraph.rst
            • tfeager.rst
            • models.rst
            • torch.rst
          • debug_mode.rst
          • data_loading
            • dataloader.rst
            • sampler.rst
            • data_loading.rst
            • nii.rst
            • arbitrary_data.rst
            • utils.rst
            • dataset.rst
            • datamanager.rst
          • class_hierarchy.rst
          • delira.rst
          • logging
            • base_logger.rst
            • writer_backend.py
            • logging.rst
            • logging_context.py
            • logging_context.rst
            • backends.rst
            • handlers.rst
            • visdom_backend.py
            • registry.py
            • registry.rst
            • tensorboard_backend.py
        • modules.rst
    • Makefile
    • segmentation_2d_pytorch.rst
    • classification_pytorch.rst
    • getting_started.rst
    • custom_backend.rst
    • tutorial_delira.rst
    • requirements.txt
    • index.rst
    • conf.py
    • _static
      • logo
        • delira.svg
    • segmentation_3d_pytorch.rst
    • gan_pytorch.rst
    • conda.yml
  • requirements
    • base.txt
    • tensorflow.txt
    • chainer.txt
    • torch.txt
  • MANIFEST.in

import unittest

from ..utils import check_for_tf_eager_backend, check_for_tf_graph_backend


class IoTfTest(unittest.TestCase):

    def setUp(self) -> None:
        import tensorflow as tf
        tf.reset_default_graph()
        if "_eager" in self._testMethodName:
            tf.enable_eager_execution()
        else:
            tf.disable_eager_execution()

    @unittest.skipUnless(check_for_tf_graph_backend(),
                         "Test should be only executed if tensorflow backend "
                         "is installed and specified")
    def test_load_save(self):
        import tensorflow as tf
        tf.disable_eager_execution()
        from delira.io.tf import load_checkpoint, save_checkpoint
        from delira.models import AbstractTfGraphNetwork
        from delira.training.backends import initialize_uninitialized

        import numpy as np

        class DummyNetwork(AbstractTfGraphNetwork):
            def __init__(self, in_channels, n_outputs):
                super().__init__(in_channels=in_channels, n_outputs=n_outputs)
                self.net = self._build_model(in_channels, n_outputs)

            @staticmethod
            def _build_model(in_channels, n_outputs):
                return tf.keras.models.Sequential(
                    layers=[
                        tf.keras.layers.Dense(
                            64,
                            input_shape=in_channels,
                            bias_initializer='glorot_uniform'),
                        tf.keras.layers.ReLU(),
                        tf.keras.layers.Dense(
                            n_outputs,
                            bias_initializer='glorot_uniform')])

        net = DummyNetwork((32,), 1)
        initialize_uninitialized(net._sess)

        vars_1 = net._sess.run(tf.global_variables())

        save_checkpoint("./model", model=net)

        net._sess.run(tf.initializers.global_variables())

        vars_2 = net._sess.run(tf.global_variables())

        load_checkpoint("./model", model=net)

        vars_3 = net._sess.run(tf.global_variables())

        for var_1, var_2 in zip(vars_1, vars_2):
            with self.subTest(var_1=var_1, var2=var_2):
                self.assertTrue(np.all(var_1 != var_2))

        for var_1, var_3 in zip(vars_1, vars_3):
            with self.subTest(var_1=var_1, var_3=var_3):
                self.assertTrue(np.all(var_1 == var_3))

    @unittest.skipUnless(check_for_tf_eager_backend(),
                         "Test should be only executed if tensorflow backend "
                         "is installed and specified")
    def test_load_save_eager(self):
        import tensorflow as tf
        tf.enable_eager_execution()
        from delira.io.tf import load_checkpoint_eager, save_checkpoint_eager
        from delira.models import AbstractTfEagerNetwork

        import numpy as np

        class DummyNetwork(AbstractTfEagerNetwork):
            def __init__(self, in_channels, n_outputs):
                super().__init__(in_channels=in_channels, n_outputs=n_outputs)
                with tf.init_scope():
                    self.net = self._build_model(in_channels, n_outputs)

            @staticmethod
            def _build_model(in_channels, n_outputs):
                return tf.keras.models.Sequential(
                    layers=[
                        tf.keras.layers.Dense(
                            64,
                            input_shape=in_channels,
                            bias_initializer='glorot_uniform'),
                        tf.keras.layers.ReLU(),
                        tf.keras.layers.Dense(
                            n_outputs,
                            bias_initializer='glorot_uniform')])

            def call(self, inputs):
                return self.net(inputs)

        net = DummyNetwork((32,), 1)
        input_tensor = tf.constant(np.random.rand(1, 32).astype(np.float32))
        result_pre_save = net(input_tensor)
        save_checkpoint_eager("./model_eager", model=net)

        loaded_state = load_checkpoint_eager("./model_eager", model=net)
        loaded_net = loaded_state["model"]

        result_post_save = loaded_net(input_tensor)

        self.assertTrue(np.array_equal(result_post_save, result_pre_save))

    def tearDown(self) -> None:
        import gc
        import sys

        try:
            del sys.modules["tf"]
        except KeyError:
            pass
        try:
            del tf
        except (UnboundLocalError, NameError):
            pass
        try:
            del sys.modules["tensorflow"]
        except KeyError:
            pass
        try:
            del tensorflow
        except (UnboundLocalError, NameError):
            pass

        gc.collect()


if __name__ == '__main__':
    unittest.main()