• Search by Module
• Search by Words
• Search Projects

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

• morph-net-master
  • morph_net
    • BUILD
    • framework
      • BUILD
      • op_regularizer_manager_test.py
      • batch_norm_source_op_handler_test.py
      • op_handler.py
      • matmul_source_op_handler_test.py
      • op_handler_util.py
      • group_lasso_base_op_handler.py
      • grouping_op_handler.py
      • conv2d_transpose_source_op_handler.py
      • op_handlers_test.py
      • concat_and_slice_regularizers.py
      • matmul_source_op_handler.py
      • batch_norm_source_op_handler.py
      • grouping_op_handler_test.py
      • conv_source_op_handler.py
      • leaf_op_handler_test.py
      • depth_to_space_op_handler_test.py
      • output_non_passthrough_op_handler_test.py
      • tpu_util.py
      • concat_and_slice_regularizers_test.py
      • op_handler_util_test.py
      • grouping_regularizers_test.py
      • generic_regularizers.py
      • conv_source_op_handler_test.py
      • tpu_util_test.py
      • op_regularizer_manager.py
      • grouping_regularizers.py
      • __init__.py
      • op_handler_decorator_test.py
      • constant_op_regularizer.py
      • output_non_passthrough_op_handler.py
      • depth_to_space_op_handler.py
      • depthwise_convolution_op_handler_test.py
      • op_handler_decorator.py
      • depthwise_convolution_op_handler.py
      • concat_op_handler.py
      • leaf_op_handler.py
      • op_handlers.py
      • concat_op_handler_test.py
    • network_regularizers
      • model_size_regularizer.py
      • BUILD
      • cost_calculator_test.py
      • flop_regularizer_test.py
      • cost_calculator.py
      • latency_regularizer_test.py
      • latency_regularizer.py
      • resource_function.py
      • flop_regularizer.py
      • __init__.py
      • resource_function_test.py
      • model_size_regularizer_test.py
      • activation_regularizer_test.py
      • activation_regularizer.py
    • __init__.py
    • tools
      • BUILD
      • structure_exporter.py
      • structure_exporter_test.py
      • configurable_ops.py
      • configurable_ops_test.py
      • __init__.py
    • testing
      • grouping_concat_model_stub.py
      • BUILD
      • op_regularizer_stub.py
      • dummy_decorator.py
      • ladder_model_stub.py
      • add_concat_model_stub.py
    • op_regularizers
      • BUILD
      • gamma_l1_regularizer.py
      • group_lasso_regularizer.py
      • group_lasso_regularizer_test.py
      • __init__.py
  • g3doc
  • examples
    • slim
      • BUILD
      • datasets
        • download_and_convert_imagenet.sh
        • dataset_utils.py
        • cifar10.py
        • preprocess_imagenet_validation_data.py
        • mnist.py
        • visualwakewords.py
        • build_visualwakewords_data.py
        • download_and_convert_cifar10.py
        • flowers.py
        • __init__.py
        • build_visualwakewords_data_lib.py
        • download_and_convert_mnist.py
        • download_imagenet.sh
        • imagenet_lsvrc_2015_synsets.txt
        • download_and_convert_flowers.py
        • build_imagenet_data.py
        • imagenet.py
        • dataset_factory.py
        • process_bounding_boxes.py
        • download_mscoco.sh
      • download_and_convert_data.py
      • train_image_classifier.py
      • export_inference_graph.py
      • deployment
        • __init__.py
        • model_deploy_test.py
        • model_deploy.py
      • slim_walkthrough.ipynb
      • setup.py
      • nets
        • resnet_v1.py
        • nets_factory.py
        • resnet_v1_test.py
        • nets_factory_test.py
        • resnet_utils.py
        • __init__.py
        • resnet_v2_test.py
        • resnet_v2.py
      • __init__.py
      • README.md
      • eval_image_classifier.py
      • preprocessing
        • vgg_preprocessing.py
        • __init__.py
        • preprocessing_factory.py
      • export_inference_graph_test.py
    • keras
      • model.py
      • main.py
      • README.md
      • utils.py
      • Dockerfile
      • test_configs.py
    • .gitignore
  • LICENSE
  • CONTRIBUTING.md
  • setup.py
  • setup.cfg
  • README.md

"""Tests for depth_to_space_op_handler."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import mock

from morph_net.framework import depth_to_space_op_handler
from morph_net.framework import op_regularizer_manager as orm
import tensorflow.compat.v1 as tf


class DepthToSpaceOpHandlerTest(tf.test.TestCase):

  def setUp(self):
    super(DepthToSpaceOpHandlerTest, self).setUp()
    # Test a Identity -> DepthToSpace -> Identity chain of ops.
    inputs = tf.zeros([2, 4, 4, 4])
    id1 = tf.identity(inputs)
    dts = tf.depth_to_space(id1, 2)
    tf.identity(dts)

    g = tf.get_default_graph()

    # Declare OpSlice and OpGroup for ops of interest.
    self.id1_op = g.get_operation_by_name('Identity')
    self.id1_op_slice = orm.OpSlice(self.id1_op, orm.Slice(0, 4))
    self.id1_op_group = orm.OpGroup(self.id1_op_slice,
                                    omit_source_op_slices=[self.id1_op_slice])
    self.id1_op_slice0 = orm.OpSlice(self.id1_op, orm.Slice(0, 1))
    self.id1_op_slice1 = orm.OpSlice(self.id1_op, orm.Slice(1, 1))
    self.id1_op_slice2 = orm.OpSlice(self.id1_op, orm.Slice(2, 1))
    self.id1_op_slice3 = orm.OpSlice(self.id1_op, orm.Slice(3, 1))

    self.dts_op = g.get_operation_by_name('DepthToSpace')
    self.dts_op_slice = orm.OpSlice(self.dts_op, orm.Slice(0, 1))
    self.dts_op_group = orm.OpGroup(self.dts_op_slice,
                                    omit_source_op_slices=[self.dts_op_slice])

    self.id2_op = g.get_operation_by_name('Identity_1')
    self.id2_op_slice = orm.OpSlice(self.id2_op, orm.Slice(0, 1))
    self.id2_op_group = orm.OpGroup(self.id2_op_slice,
                                    omit_source_op_slices=[self.id2_op_slice])

    # Create mock OpRegularizerManager with custom mapping of OpSlice and
    # OpGroup.
    self.mock_op_reg_manager = mock.create_autospec(orm.OpRegularizerManager)

    self.op_slice_dict = {
        self.id1_op: [self.id1_op_slice],
        self.dts_op: [self.dts_op_slice],
        self.id2_op: [self.id2_op_slice],
    }
    def get_op_slices(op):
      return self.op_slice_dict.get(op)

    def get_op_group(op_slice):
      return self.op_group_dict.get(op_slice)

    self.mock_op_reg_manager.get_op_slices.side_effect = get_op_slices
    self.mock_op_reg_manager.get_op_group.side_effect = get_op_group
    self.mock_op_reg_manager.is_source_op.return_value = False
    self.mock_op_reg_manager.ops = [self.id1_op, self.dts_op, self.id2_op]

  def test_assign_grouping_no_neighbor_groups(self):
    # No ops have groups.
    self.op_group_dict = {}

    # Call handler to assign grouping.
    handler = depth_to_space_op_handler.DepthToSpaceOpHandler()
    handler.assign_grouping(self.dts_op, self.mock_op_reg_manager)

    # Verify manager looks up OpSlice for ops of interest.
    self.mock_op_reg_manager.get_op_slices.assert_has_calls(
        [mock.call(self.id1_op),
         mock.call(self.id2_op)])

    # Verify manager does not group.
    self.mock_op_reg_manager.group_op_slices.assert_not_called()

    # Verify manager processes grouping for identity ops.
    self.mock_op_reg_manager.process_ops.assert_called_once_with(
        [self.id1_op])

  def test_assign_grouping_all_inputs_grouped(self):
    # Map ops to slices.
    self.op_slice_dict[self.id1_op] = [
        self.id1_op_slice0,
        self.id1_op_slice1,
        self.id1_op_slice2,
        self.id1_op_slice3]

    # All inputs have groups.
    self.op_group_dict = {
        self.id1_op_slice0: self.id1_op_group,
        self.id1_op_slice1: self.id1_op_group,
        self.id1_op_slice2: self.id1_op_group,
        self.id1_op_slice3: self.id1_op_group,
    }

    # Call handler to assign grouping.
    handler = depth_to_space_op_handler.DepthToSpaceOpHandler()
    handler.assign_grouping(self.dts_op, self.mock_op_reg_manager)

    # Verify manager looks up OpSlice for ops of interest.
    self.mock_op_reg_manager.get_op_slices.assert_has_calls(
        # Checking for ops to process.
        [mock.call(self.id1_op),
         mock.call(self.id2_op),
         # Reslicing.
         mock.call(self.id1_op),
         mock.call(self.dts_op),
         mock.call(self.id2_op),
         # Refreshing slice data.
         mock.call(self.dts_op),
         mock.call(self.id1_op)])

    # Verify manager groups DepthToSpace channel with individual input channels.
    self.mock_op_reg_manager.group_op_slices.assert_called_once_with(
        [self.id1_op_slice0, self.id1_op_slice1, self.id1_op_slice2,
         self.id1_op_slice3, self.dts_op_slice])

    # Verify manager processes grouping for identity ops.
    self.mock_op_reg_manager.process_ops.assert_called_once_with([self.id2_op])

  def test_assign_grouping_all_outputs_grouped(self):
    # All outputs have groups.
    self.op_group_dict = {
        self.id2_op_slice: self.id2_op_group,
    }

    # Call handler to assign grouping.
    handler = depth_to_space_op_handler.DepthToSpaceOpHandler()
    handler.assign_grouping(self.dts_op, self.mock_op_reg_manager)

    # Verify manager looks up OpSlice for ops of interest.
    self.mock_op_reg_manager.get_op_slices.assert_has_calls(
        # Checking for ops to process.
        [mock.call(self.id1_op),
         mock.call(self.id2_op)])

    # Verify manager does not group.
    self.mock_op_reg_manager.group_op_slices.assert_not_called()

    # Verify manager processes grouping for identity ops.
    self.mock_op_reg_manager.process_ops.assert_called_once_with(
        [self.id1_op])

  def test_assign_grouping_all_neighbors_grouped(self):
    # Map ops to slices.
    self.op_slice_dict[self.id1_op] = [
        self.id1_op_slice0,
        self.id1_op_slice1,
        self.id1_op_slice2,
        self.id1_op_slice3]

    # All neighbors have groups.
    self.op_group_dict = {
        self.id1_op_slice0: self.id1_op_group,
        self.id1_op_slice1: self.id1_op_group,
        self.id1_op_slice2: self.id1_op_group,
        self.id1_op_slice3: self.id1_op_group,
        self.id2_op_slice: self.id2_op_group,
    }

    # Call handler to assign grouping.
    handler = depth_to_space_op_handler.DepthToSpaceOpHandler()
    handler.assign_grouping(self.dts_op, self.mock_op_reg_manager)

    # Verify manager looks up OpSlice for ops of interest.
    self.mock_op_reg_manager.get_op_slices.assert_has_calls(
        # Checking for ops to process.
        [mock.call(self.id1_op),
         mock.call(self.id2_op),
         # Reslicing.
         mock.call(self.id1_op),
         mock.call(self.dts_op),
         mock.call(self.id2_op),
         # Refreshing slice data.
         mock.call(self.dts_op),
         mock.call(self.id1_op)])

    # Verify manager groups DepthToSpace channel with individual input channels.
    self.mock_op_reg_manager.group_op_slices.assert_called_once_with(
        [self.id1_op_slice0, self.id1_op_slice1, self.id1_op_slice2,
         self.id1_op_slice3, self.dts_op_slice])

    # Verify manager processes grouping for identity ops.
    self.mock_op_reg_manager.process_ops.assert_not_called()

  def test_assign_grouping_all_neighbors_grouped_same_group(self):
    # Map ops to slices.
    self.op_slice_dict[self.id1_op] = [
        self.id1_op_slice0,
        self.id1_op_slice1,
        self.id1_op_slice2,
        self.id1_op_slice3]

    # All neighbors have the same group.
    self.op_group_dict = {
        self.id1_op_slice0: self.id1_op_group,
        self.id1_op_slice1: self.id1_op_group,
        self.id1_op_slice2: self.id1_op_group,
        self.id1_op_slice3: self.id1_op_group,
        self.id2_op_slice: self.id1_op_group,
    }

    # Call handler to assign grouping.
    handler = depth_to_space_op_handler.DepthToSpaceOpHandler()
    handler.assign_grouping(self.dts_op, self.mock_op_reg_manager)

    # Verify manager looks up OpSlice for ops of interest.
    self.mock_op_reg_manager.get_op_slices.assert_has_calls(
        # Checking for ops to process.
        [mock.call(self.id1_op),
         mock.call(self.id2_op),
         # Reslicing.
         mock.call(self.id1_op),
         mock.call(self.dts_op),
         mock.call(self.id2_op),
         # Refreshing slice data.
         mock.call(self.dts_op),
         mock.call(self.id1_op)])

    # Verify manager groups DepthToSpace channel with individual input channels.
    self.mock_op_reg_manager.group_op_slices.assert_called_once_with(
        [self.id1_op_slice0, self.id1_op_slice1, self.id1_op_slice2,
         self.id1_op_slice3, self.dts_op_slice])

    # Verify manager processes grouping for identity ops.
    self.mock_op_reg_manager.process_ops.assert_not_called()


if __name__ == '__main__':
  tf.test.main()