def testEndPointsV2(self):
     """Test the end points of a tiny v2 bottleneck network."""
     bottleneck = resnet_v2.bottleneck
     blocks = [
         resnet_utils.Block("block1", bottleneck, [(4, 1, 1), (4, 1, 2)]),
         resnet_utils.Block("block2", bottleneck, [(8, 2, 1), (8, 2, 1)]),
     ]
     inputs = create_test_input(2, 32, 16, 3)
     with slim.arg_scope(resnet_utils.resnet_arg_scope()):
         _, end_points = self._resnet_plain(inputs, blocks, scope="tiny")
     expected = [
         "tiny/block1/unit_1/bottleneck_v2/shortcut",
         "tiny/block1/unit_1/bottleneck_v2/conv1",
         "tiny/block1/unit_1/bottleneck_v2/conv2",
         "tiny/block1/unit_1/bottleneck_v2/conv3",
         "tiny/block1/unit_2/bottleneck_v2/conv1",
         "tiny/block1/unit_2/bottleneck_v2/conv2",
         "tiny/block1/unit_2/bottleneck_v2/conv3",
         "tiny/block2/unit_1/bottleneck_v2/shortcut",
         "tiny/block2/unit_1/bottleneck_v2/conv1",
         "tiny/block2/unit_1/bottleneck_v2/conv2",
         "tiny/block2/unit_1/bottleneck_v2/conv3",
         "tiny/block2/unit_2/bottleneck_v2/conv1",
         "tiny/block2/unit_2/bottleneck_v2/conv2",
         "tiny/block2/unit_2/bottleneck_v2/conv3",
     ]
     self.assertItemsEqual(expected, end_points)

 def testAtrousFullyConvolutionalValues(self):
   """Verify dense feature extraction with atrous convolution."""
   nominal_stride = 32
   for output_stride in [4, 8, 16, 32, None]:
     with slim.arg_scope(resnet_utils.resnet_arg_scope()):
       with tf.Graph().as_default():
         with self.test_session() as sess:
           tf.set_random_seed(0)
           inputs = create_test_input(2, 81, 81, 3)
           # Dense feature extraction followed by subsampling.
           output, _ = self._resnet_small(inputs,
                                          None,
                                          is_training=False,
                                          global_pool=False,
                                          output_stride=output_stride)
           if output_stride is None:
             factor = 1
           else:
             factor = nominal_stride // output_stride
           output = resnet_utils.subsample(output, factor)
           # Make the two networks use the same weights.
           tf.get_variable_scope().reuse_variables()
           # Feature extraction at the nominal network rate.
           expected, _ = self._resnet_small(inputs,
                                            None,
                                            is_training=False,
                                            global_pool=False)
           sess.run(tf.global_variables_initializer())
           self.assertAllClose(output.eval(), expected.eval(),
                               atol=1e-4, rtol=1e-4)

 def testEndPointsV1(self):
   """Test the end points of a tiny v1 bottleneck network."""
   bottleneck = resnet_v1.bottleneck
   blocks = [resnet_utils.Block('block1', bottleneck, [(4, 1, 1), (4, 1, 2)]),
             resnet_utils.Block('block2', bottleneck, [(8, 2, 1), (8, 2, 1)])]
   inputs = create_test_input(2, 32, 16, 3)
   with slim.arg_scope(resnet_utils.resnet_arg_scope()):
     _, end_points = self._resnet_plain(inputs, blocks, scope='tiny')
   expected = [
       'tiny/block1/unit_1/bottleneck_v1/shortcut',
       'tiny/block1/unit_1/bottleneck_v1/shortcut/BatchNorm',
       'tiny/block1/unit_1/bottleneck_v1/conv1',
       'tiny/block1/unit_1/bottleneck_v1/conv2',
       'tiny/block1/unit_1/bottleneck_v1/conv3',
       'tiny/block1/unit_1/bottleneck_v1/conv3/BatchNorm',
       'tiny/block1/unit_2/bottleneck_v1/conv1',
       'tiny/block1/unit_2/bottleneck_v1/conv2',
       'tiny/block1/unit_2/bottleneck_v1/conv3',
       'tiny/block1/unit_2/bottleneck_v1/conv3/BatchNorm',
       'tiny/block2/unit_1/bottleneck_v1/shortcut',
       'tiny/block2/unit_1/bottleneck_v1/shortcut/BatchNorm',
       'tiny/block2/unit_1/bottleneck_v1/conv1',
       'tiny/block2/unit_1/bottleneck_v1/conv2',
       'tiny/block2/unit_1/bottleneck_v1/conv3',
       'tiny/block2/unit_1/bottleneck_v1/conv3/BatchNorm',
       'tiny/block2/unit_2/bottleneck_v1/conv1',
       'tiny/block2/unit_2/bottleneck_v1/conv2',
       'tiny/block2/unit_2/bottleneck_v1/conv3',
       'tiny/block2/unit_2/bottleneck_v1/conv3/BatchNorm']
   self.assertItemsEqual(expected, end_points)

 def testClassificationEndPoints(self):
     global_pool = True
     num_classes = 10
     inputs = create_test_input(2, 224, 224, 3)
     with slim.arg_scope(resnet_utils.resnet_arg_scope()):
         logits, end_points = self._resnet_small(inputs, num_classes, global_pool, scope="resnet")
     self.assertTrue(logits.op.name.startswith("resnet/logits"))
     self.assertListEqual(logits.get_shape().as_list(), [2, 1, 1, num_classes])
     self.assertTrue("predictions" in end_points)
     self.assertListEqual(end_points["predictions"].get_shape().as_list(), [2, 1, 1, num_classes])

 def testFullyConvolutionalUnknownHeightWidth(self):
     batch = 2
     height, width = 65, 65
     global_pool = False
     inputs = create_test_input(batch, None, None, 3)
     with slim.arg_scope(resnet_utils.resnet_arg_scope()):
         output, _ = self._resnet_small(inputs, None, global_pool)
     self.assertListEqual(output.get_shape().as_list(), [batch, None, None, 32])
     images = create_test_input(batch, height, width, 3)
     with self.test_session() as sess:
         sess.run(tf.initialize_all_variables())
         output = sess.run(output, {inputs: images.eval()})
         self.assertEqual(output.shape, (batch, 3, 3, 32))

 def testFullyConvolutionalEndpointShapes(self):
   global_pool = False
   num_classes = 10
   inputs = create_test_input(2, 321, 321, 3)
   with slim.arg_scope(resnet_utils.resnet_arg_scope()):
     _, end_points = self._resnet_small(inputs, num_classes, global_pool,
                                        scope='resnet')
     endpoint_to_shape = {
         'resnet/block1': [2, 41, 41, 4],
         'resnet/block2': [2, 21, 21, 8],
         'resnet/block3': [2, 11, 11, 16],
         'resnet/block4': [2, 11, 11, 32]}
     for endpoint in endpoint_to_shape:
       shape = endpoint_to_shape[endpoint]
       self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)

 def testClassificationShapes(self):
   global_pool = True
   num_classes = 10
   inputs = create_test_input(2, 224, 224, 3)
   with slim.arg_scope(resnet_utils.resnet_arg_scope()):
     _, end_points = self._resnet_small(inputs, num_classes, global_pool,
                                        scope='resnet')
     endpoint_to_shape = {
         'resnet/block1': [2, 28, 28, 4],
         'resnet/block2': [2, 14, 14, 8],
         'resnet/block3': [2, 7, 7, 16],
         'resnet/block4': [2, 7, 7, 32]}
     for endpoint in endpoint_to_shape:
       shape = endpoint_to_shape[endpoint]
       self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)

 def testUnknownBatchSize(self):
     batch = 2
     height, width = 65, 65
     global_pool = True
     num_classes = 10
     inputs = create_test_input(None, height, width, 3)
     with slim.arg_scope(resnet_utils.resnet_arg_scope()):
         logits, _ = self._resnet_small(inputs, num_classes, global_pool, scope="resnet")
     self.assertTrue(logits.op.name.startswith("resnet/logits"))
     self.assertListEqual(logits.get_shape().as_list(), [None, 1, 1, num_classes])
     images = create_test_input(batch, height, width, 3)
     with self.test_session() as sess:
         sess.run(tf.initialize_all_variables())
         output = sess.run(logits, {inputs: images.eval()})
         self.assertEqual(output.shape, (batch, 1, 1, num_classes))

  def testClassificationEndPointsWithMultigrid(self):
    global_pool = True
    num_classes = 10
    inputs = create_test_input(2, 224, 224, 3)
    multi_grid = [1, 2, 4]
    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
      logits, end_points = self._resnet_small(inputs,
                                              num_classes,
                                              global_pool=global_pool,
                                              multi_grid=multi_grid,
                                              scope='resnet')

    self.assertTrue(logits.op.name.startswith('resnet/logits'))
    self.assertListEqual(logits.get_shape().as_list(), [2, 1, 1, num_classes])
    self.assertTrue('predictions' in end_points)
    self.assertListEqual(end_points['predictions'].get_shape().as_list(),
                         [2, 1, 1, num_classes])

 def testRootlessFullyConvolutionalEndpointShapes(self):
     global_pool = False
     num_classes = 10
     inputs = create_test_input(2, 128, 128, 3)
     with slim.arg_scope(resnet_utils.resnet_arg_scope()):
         _, end_points = self._resnet_small(
             inputs, num_classes, global_pool, include_root_block=False, scope="resnet"
         )
         endpoint_to_shape = {
             "resnet/block1": [2, 64, 64, 4],
             "resnet/block2": [2, 32, 32, 8],
             "resnet/block3": [2, 16, 16, 16],
             "resnet/block4": [2, 16, 16, 32],
         }
         for endpoint in endpoint_to_shape:
             shape = endpoint_to_shape[endpoint]
             self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)

 def testAtrousFullyConvolutionalEndpointShapes(self):
     global_pool = False
     num_classes = 10
     output_stride = 8
     inputs = create_test_input(2, 321, 321, 3)
     with slim.arg_scope(resnet_utils.resnet_arg_scope()):
         _, end_points = self._resnet_small(
             inputs, num_classes, global_pool, output_stride=output_stride, scope="resnet"
         )
         endpoint_to_shape = {
             "resnet/block1": [2, 41, 41, 4],
             "resnet/block2": [2, 41, 41, 8],
             "resnet/block3": [2, 41, 41, 16],
             "resnet/block4": [2, 41, 41, 32],
         }
         for endpoint in endpoint_to_shape:
             shape = endpoint_to_shape[endpoint]
             self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)

  def _atrousValues(self, bottleneck):
    """Verify the values of dense feature extraction by atrous convolution.

    Make sure that dense feature extraction by stack_blocks_dense() followed by
    subsampling gives identical results to feature extraction at the nominal
    network output stride using the simple self._stack_blocks_nondense() above.

    Args:
      bottleneck: The bottleneck function.
    """
    blocks = [
        resnet_utils.Block('block1', bottleneck, [(4, 1, 1), (4, 1, 2)]),
        resnet_utils.Block('block2', bottleneck, [(8, 2, 1), (8, 2, 2)]),
        resnet_utils.Block('block3', bottleneck, [(16, 4, 1), (16, 4, 2)]),
        resnet_utils.Block('block4', bottleneck, [(32, 8, 1), (32, 8, 1)])
    ]
    nominal_stride = 8

    # Test both odd and even input dimensions.
    height = 30
    width = 31
    with slim.arg_scope(resnet_utils.resnet_arg_scope(is_training=False)):
      for output_stride in [1, 2, 4, 8, None]:
        with tf.Graph().as_default():
          with self.test_session() as sess:
            tf.set_random_seed(0)
            inputs = create_test_input(1, height, width, 3)
            # Dense feature extraction followed by subsampling.
            output = resnet_utils.stack_blocks_dense(inputs,
                                                     blocks,
                                                     output_stride)
            if output_stride is None:
              factor = 1
            else:
              factor = nominal_stride // output_stride

            output = resnet_utils.subsample(output, factor)
            # Make the two networks use the same weights.
            tf.get_variable_scope().reuse_variables()
            # Feature extraction at the nominal network rate.
            expected = self._stack_blocks_nondense(inputs, blocks)
            sess.run(tf.global_variables_initializer())
            output, expected = sess.run([output, expected])
            self.assertAllClose(output, expected, atol=1e-4, rtol=1e-4)

 def testAtrousFullyConvolutionalEndpointShapes(self):
   global_pool = False
   num_classes = 10
   output_stride = 8
   inputs = create_test_input(2, 321, 321, 3)
   with slim.arg_scope(resnet_utils.resnet_arg_scope()):
     _, end_points = self._resnet_small(inputs,
                                        num_classes,
                                        global_pool=global_pool,
                                        output_stride=output_stride,
                                        scope='resnet')
     endpoint_to_shape = {
         'resnet/conv1_1': [2, 161, 161, 64],
         'resnet/conv1_2': [2, 161, 161, 64],
         'resnet/conv1_3': [2, 161, 161, 128],
         'resnet/block1': [2, 41, 41, 4],
         'resnet/block2': [2, 41, 41, 8],
         'resnet/block3': [2, 41, 41, 16],
         'resnet/block4': [2, 41, 41, 32]}
     for endpoint, shape in endpoint_to_shape.iteritems():
       self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)