def _extract_box_classifier_features(self, proposal_feature_maps, scope):
    """Extracts second stage box classifier features.

    Args:
      proposal_feature_maps: A 4-D float tensor with shape
        [batch_size * self.max_num_proposals, crop_height, crop_width, depth]
        representing the feature map cropped to each proposal.
      scope: A scope name (unused).

    Returns:
      proposal_classifier_features: A 4-D float tensor with shape
        [batch_size * self.max_num_proposals, height, width, depth]
        representing box classifier features for each proposal.
    """
    with tf.variable_scope(self._architecture, reuse=self._reuse_weights):
      with slim.arg_scope(
          resnet_utils.resnet_arg_scope(
              batch_norm_epsilon=1e-5,
              batch_norm_scale=True,
              weight_decay=self._weight_decay)):
        with slim.arg_scope([slim.batch_norm],
                            is_training=self._train_batch_norm):
          blocks = [
              resnet_utils.Block('block4', resnet_v1.bottleneck, [{
                  'depth': 2048,
                  'depth_bottleneck': 512,
                  'stride': 1
              }] * 3)
          ]
          proposal_classifier_features = resnet_utils.stack_blocks_dense(
              proposal_feature_maps, blocks)
    return proposal_classifier_features
 def _resnet_plain(self, inputs, blocks, output_stride=None, scope=None):
   """A plain ResNet without extra layers before or after the ResNet blocks."""
   with tf.variable_scope(scope, values=[inputs]):
     with slim.arg_scope([slim.conv2d], outputs_collections='end_points'):
       net = resnet_utils.stack_blocks_dense(inputs, blocks, output_stride)
       end_points = slim.utils.convert_collection_to_dict('end_points')
       return net, end_points
    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()):
            with slim.arg_scope([slim.batch_norm], 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.initialize_all_variables())
                            output, expected = sess.run([output, expected])
                            self.assertAllClose(output,
                                                expected,
                                                atol=1e-4,
                                                rtol=1e-4)
Esempio n. 4
0
    def testAtrousValuesBottleneck(self):
        """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.
    """
        block = resnet_v2.resnet_v2_block
        blocks = [
            block('block1', base_depth=1, num_units=2, stride=2),
            block('block2', base_depth=2, num_units=2, stride=2),
            block('block3', base_depth=4, num_units=2, stride=2),
            block('block4', base_depth=8, num_units=2, stride=1),
        ]
        nominal_stride = 8

        # Test both odd and even input dimensions.
        height = 30
        width = 31
        with slim.arg_scope(resnet_utils.resnet_arg_scope()):
            with slim.arg_scope([slim.batch_norm], is_training=False):
                for output_stride in [1, 2, 4, 8, None]:
                    with tf.Graph().as_default():
                        with self.test_session() as sess:
                            tf.compat.v1.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.compat.v1.get_variable_scope().reuse_variables()
                            # Feature extraction at the nominal network rate.
                            expected = self._stack_blocks_nondense(
                                inputs, blocks)
                            sess.run(
                                tf.compat.v1.global_variables_initializer())
                            output, expected = sess.run([output, expected])
                            self.assertAllClose(output,
                                                expected,
                                                atol=1e-4,
                                                rtol=1e-4)
Esempio n. 5
0
def resnet_v1(inputs,
              blocks,
              num_classes=None,
              is_training=True,
              global_pool=True,
              output_stride=None,
              include_root_block=True,
              spatial_squeeze=True,
              store_non_strided_activations=False,
              reuse=None,
              scope=None):
 
  with tf.variable_scope(scope, 'resnet_v1', [inputs], reuse=reuse) as sc:
    end_points_collection = sc.original_name_scope + '_end_points'
    with slim.arg_scope([slim.conv2d, bottleneck,
                         resnet_utils.stack_blocks_dense],
                        outputs_collections=end_points_collection):
      with (slim.arg_scope([slim.batch_norm], is_training=is_training)
            if is_training is not None else NoOpScope()):
        net = inputs
        if include_root_block:
          if output_stride is not None:
            if output_stride % 4 != 0:
              raise ValueError('The output_stride needs to be a multiple of 4.')
            output_stride /= 4
          net = resnet_utils.conv2d_same(net, 64, 7, stride=2, scope='conv1')
          net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool1')
        net = resnet_utils.stack_blocks_dense(net, blocks, output_stride,
                                              store_non_strided_activations)
        # Convert end_points_collection into a dictionary of end_points.
        end_points = slim.utils.convert_collection_to_dict(
            end_points_collection)

        if global_pool:
          # Global average pooling.
          net = tf.reduce_mean(net, [1, 2], name='pool5', keep_dims=True)
          end_points['global_pool'] = net
        if num_classes:
          net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None,
                            normalizer_fn=None, scope='logits')
          end_points[sc.name + '/logits'] = net
          if spatial_squeeze:
            net = tf.squeeze(net, [1, 2], name='SpatialSqueeze')
            end_points[sc.name + '/spatial_squeeze'] = net
          end_points['predictions'] = slim.softmax(net, scope='predictions')
        return net, end_points
  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()):
      with slim.arg_scope([slim.batch_norm], 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)
Esempio n. 7
0
def resnet_v2(inputs,
              blocks,
              num_classes=None,
              is_training=True,
              global_pool=True,
              output_stride=None,
              include_root_block=True,
              spatial_squeeze=True,
              reuse=None,
              scope=None):

    with tf.variable_scope(scope, 'resnet_v2', [inputs], reuse=reuse) as sc:
        end_points_collection = sc.original_name_scope + '_end_points'
        with slim.arg_scope(
            [slim.conv2d, bottleneck, resnet_utils.stack_blocks_dense],
                outputs_collections=end_points_collection):
            with slim.arg_scope([slim.batch_norm], is_training=is_training):
                net = inputs
                if include_root_block:
                    if output_stride is not None:
                        if output_stride % 4 != 0:
                            raise ValueError(
                                'The output_stride needs to be a multiple of 4.'
                            )
                        output_stride /= 4
                    # We do not include batch normalization or activation functions in
                    # conv1 because the first ResNet unit will perform these. Cf.
                    # Appendix of [2].
                    with slim.arg_scope([slim.conv2d],
                                        activation_fn=None,
                                        normalizer_fn=None):
                        net = resnet_utils.conv2d_same(net,
                                                       64,
                                                       7,
                                                       stride=2,
                                                       scope='conv1')
                    net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool1')
                net = resnet_utils.stack_blocks_dense(net, blocks,
                                                      output_stride)
                # This is needed because the pre-activation variant does not have batch
                # normalization or activation functions in the residual unit output. See
                # Appendix of [2].
                net = slim.batch_norm(net,
                                      activation_fn=tf.nn.relu,
                                      scope='postnorm')
Esempio n. 8
0
 def _extract_camera_features(self, rpn_bottleneck, scope):
     with tf.variable_scope(self._architecture, reuse=self._reuse_weights):
         with slim.arg_scope(
                 resnet_utils.resnet_arg_scope(
                     batch_norm_epsilon=1e-5,
                     batch_norm_scale=True,
                     weight_decay=self._weight_decay)):
             with slim.arg_scope([slim.batch_norm], is_training=False):
                 blocks = [
                     resnet_v1_block('block4',
                                     base_depth=512,
                                     num_units=3,
                                     stride=2),
                     resnet_v1_block('block5',
                                     base_depth=512,
                                     num_units=2,
                                     stride=2),
                     #resnet_v1_block('block6', base_depth=512, num_units=2, stride=2)
                 ]
                 camera_features = resnet_utils.stack_blocks_dense(
                     rpn_bottleneck, blocks)
     return camera_features
def resnet_v1(inputs,
              blocks,
              num_classes=None,
              is_training=True,
              global_pool=True,
              output_stride=None,
              include_root_block=True,
              spatial_squeeze=True,
              store_non_strided_activations=False,
              reuse=None,
              scope=None):
    """Generator for v1 ResNet models.

  This function generates a family of ResNet v1 models. See the resnet_v1_*()
  methods for specific model instantiations, obtained by selecting different
  block instantiations that produce ResNets of various depths.

  Training for image classification on Imagenet is usually done with [224, 224]
  inputs, resulting in [7, 7] feature maps at the output of the last ResNet
  block for the ResNets defined in [1] that have nominal stride equal to 32.
  However, for dense prediction tasks we advise that one uses inputs with
  spatial dimensions that are multiples of 32 plus 1, e.g., [321, 321]. In
  this case the feature maps at the ResNet output will have spatial shape
  [(height - 1) / output_stride + 1, (width - 1) / output_stride + 1]
  and corners exactly aligned with the input image corners, which greatly
  facilitates alignment of the features to the image. Using as input [225, 225]
  images results in [8, 8] feature maps at the output of the last ResNet block.

  For dense prediction tasks, the ResNet needs to run in fully-convolutional
  (FCN) mode and global_pool needs to be set to False. The ResNets in [1, 2] all
  have nominal stride equal to 32 and a good choice in FCN mode is to use
  output_stride=16 in order to increase the density of the computed features at
  small computational and memory overhead, cf. http://arxiv.org/abs/1606.00915.

  Args:
    inputs: A tensor of size [batch, height_in, width_in, channels].
    blocks: A list of length equal to the number of ResNet blocks. Each element
      is a resnet_utils.Block object describing the units in the block.
    num_classes: Number of predicted classes for classification tasks.
      If 0 or None, we return the features before the logit layer.
    is_training: whether batch_norm layers are in training mode. If this is set
      to None, the callers can specify slim.batch_norm's is_training parameter
      from an outer slim.arg_scope.
    global_pool: If True, we perform global average pooling before computing the
      logits. Set to True for image classification, False for dense prediction.
    output_stride: If None, then the output will be computed at the nominal
      network stride. If output_stride is not None, it specifies the requested
      ratio of input to output spatial resolution.
    include_root_block: If True, include the initial convolution followed by
      max-pooling, if False excludes it.
    spatial_squeeze: if True, logits is of shape [B, C], if false logits is
        of shape [B, 1, 1, C], where B is batch_size and C is number of classes.
        To use this parameter, the input images must be smaller than 300x300
        pixels, in which case the output logit layer does not contain spatial
        information and can be removed.
    store_non_strided_activations: If True, we compute non-strided (undecimated)
      activations at the last unit of each block and store them in the
      `outputs_collections` before subsampling them. This gives us access to
      higher resolution intermediate activations which are useful in some
      dense prediction problems but increases 4x the computation and memory cost
      at the last unit of each block.
    reuse: whether or not the network and its variables should be reused. To be
      able to reuse 'scope' must be given.
    scope: Optional variable_scope.

  Returns:
    net: A rank-4 tensor of size [batch, height_out, width_out, channels_out].
      If global_pool is False, then height_out and width_out are reduced by a
      factor of output_stride compared to the respective height_in and width_in,
      else both height_out and width_out equal one. If num_classes is 0 or None,
      then net is the output of the last ResNet block, potentially after global
      average pooling. If num_classes a non-zero integer, net contains the
      pre-softmax activations.
    end_points: A dictionary from components of the network to the corresponding
      activation.

  Raises:
    ValueError: If the target output_stride is not valid.
  """
    with tf.variable_scope(scope, 'resnet_v1', [inputs], reuse=reuse) as sc:
        end_points_collection = sc.original_name_scope + '_end_points'
        with slim.arg_scope(
            [slim.conv2d, bottleneck, resnet_utils.stack_blocks_dense],
                outputs_collections=end_points_collection):
            with (slim.arg_scope([slim.batch_norm], is_training=is_training)
                  if is_training is not None else NoOpScope()):
                net = inputs
                if include_root_block:
                    if output_stride is not None:
                        if output_stride % 4 != 0:
                            raise ValueError(
                                'The output_stride needs to be a multiple of 4.'
                            )
                        output_stride /= 4
                    net = resnet_utils.conv2d_same(net,
                                                   64,
                                                   7,
                                                   stride=2,
                                                   scope='conv1')
                    net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool1')
                net = resnet_utils.stack_blocks_dense(
                    net, blocks, output_stride, store_non_strided_activations)

                # Convert end_points_collection into a dictionary of end_points.
                end_points = slim.utils.convert_collection_to_dict(
                    end_points_collection)

                return net, end_points
Esempio n. 10
0
def resnet_v1(inputs,
              blocks,
              num_classes=None,
              is_training=True,
              global_pool=True,
              output_stride=None,
              include_root_block=True,
              spatial_squeeze=False,
              reuse=None,
              scope=None):
  """Generator for v1 ResNet models.

  This function generates a family of ResNet v1 models. See the resnet_v1_*()
  methods for specific model instantiations, obtained by selecting different
  block instantiations that produce ResNets of various depths.

  Training for image classification on Imagenet is usually done with [224, 224]
  inputs, resulting in [7, 7] feature maps at the output of the last ResNet
  block for the ResNets defined in [1] that have nominal stride equal to 32.
  However, for dense prediction tasks we advise that one uses inputs with
  spatial dimensions that are multiples of 32 plus 1, e.g., [321, 321]. In
  this case the feature maps at the ResNet output will have spatial shape
  [(height - 1) / output_stride + 1, (width - 1) / output_stride + 1]
  and corners exactly aligned with the input image corners, which greatly
  facilitates alignment of the features to the image. Using as input [225, 225]
  images results in [8, 8] feature maps at the output of the last ResNet block.

  For dense prediction tasks, the ResNet needs to run in fully-convolutional
  (FCN) mode and global_pool needs to be set to False. The ResNets in [1, 2] all
  have nominal stride equal to 32 and a good choice in FCN mode is to use
  output_stride=16 in order to increase the density of the computed features at
  small computational and memory overhead, cf. http://arxiv.org/abs/1606.00915.

  Args:
    inputs: A tensor of size [batch, height_in, width_in, channels].
    blocks: A list of length equal to the number of ResNet blocks. Each element
      is a resnet_utils.Block object describing the units in the block.
    num_classes: Number of predicted classes for classification tasks. If None
      we return the features before the logit layer.
    is_training: whether is training or not.
    global_pool: If True, we perform global average pooling before computing the
      logits. Set to True for image classification, False for dense prediction.
    output_stride: If None, then the output will be computed at the nominal
      network stride. If output_stride is not None, it specifies the requested
      ratio of input to output spatial resolution.
    include_root_block: If True, include the initial convolution followed by
      max-pooling, if False excludes it.
    spatial_squeeze: if True, logits is of shape [B, C], if false logits is
        of shape [B, 1, 1, C], where B is batch_size and C is number of classes.
    reuse: whether or not the network and its variables should be reused. To be
      able to reuse 'scope' must be given.
    scope: Optional variable_scope.

  Returns:
    net: A rank-4 tensor of size [batch, height_out, width_out, channels_out].
      If global_pool is False, then height_out and width_out are reduced by a
      factor of output_stride compared to the respective height_in and width_in,
      else both height_out and width_out equal one. If num_classes is None, then
      net is the output of the last ResNet block, potentially after global
      average pooling. If num_classes is not None, net contains the pre-softmax
      activations.
    end_points: A dictionary from components of the network to the corresponding
      activation.

  Raises:
    ValueError: If the target output_stride is not valid.
  """
  with tf.variable_scope(scope, 'resnet_v1', [inputs], reuse=reuse) as sc:
    end_points_collection = sc.name + '_end_points'
    with slim.arg_scope([slim.conv2d, bottleneck,
                         resnet_utils.stack_blocks_dense],
                        outputs_collections=end_points_collection):
      with slim.arg_scope([slim.batch_norm], is_training=is_training):
        net = inputs
        if include_root_block:
          if output_stride is not None:
            if output_stride % 4 != 0:
              raise ValueError('The output_stride needs to be a multiple of 4.')
            output_stride /= 4
          net = resnet_utils.conv2d_same(net, 64, 7, stride=2, scope='conv1')
          net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool1')
        net = resnet_utils.stack_blocks_dense(net, blocks, output_stride)
        if global_pool:
          # Global average pooling.
          net = tf.reduce_mean(net, [1, 2], name='pool5', keep_dims=True)
        if num_classes is not None:
          net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None,
                            normalizer_fn=None, scope='logits')
        if spatial_squeeze:
          logits = tf.squeeze(net, [1, 2], name='SpatialSqueeze')
        else:
          logits = net
        # Convert end_points_collection into a dictionary of end_points.
        end_points = slim.utils.convert_collection_to_dict(
            end_points_collection)
        if num_classes is not None:
          end_points['predictions'] = slim.softmax(logits, scope='predictions')
        return logits, end_points
Esempio n. 11
0
def resnet_distributions_v1(inputs,
                            blocks,
                            num_classes=None,
                            is_training=True,
                            output_stride=None,
                            include_root_block=True,
                            reuse=None,
                            scope=None,
                            sample_number=1):
    """Generator for v1 ResNet models.

  This function generates a family of ResNet v1 models. See the resnet_v1_*()
  methods for specific model instantiations, obtained by selecting different
  block instantiations that produce ResNets of various depths.

  Training for image classification on Imagenet is usually done with [224, 224]
  inputs, resulting in [7, 7] feature maps at the output of the last ResNet
  block for the ResNets defined in [1] that have nominal stride equal to 32.
  However, for dense prediction tasks we advise that one uses inputs with
  spatial dimensions that are multiples of 32 plus 1, e.g., [321, 321]. In
  this case the feature maps at the ResNet output will have spatial shape
  [(height - 1) / output_stride + 1, (width - 1) / output_stride + 1]
  and corners exactly aligned with the input image corners, which greatly
  facilitates alignment of the features to the image. Using as input [225, 225]
  images results in [8, 8] feature maps at the output of the last ResNet block.

  For dense prediction tasks, the ResNet needs to run in fully-convolutional
  (FCN) mode and global_pool needs to be set to False. The ResNets in [1, 2] all
  have nominal stride equal to 32 and a good choice in FCN mode is to use
  output_stride=16 in order to increase the density of the computed features at
  small computational and memory overhead, cf. http://arxiv.org/abs/1606.00915.

  Args:
    inputs: A tensor of size [batch, height_in, width_in, channels].
    blocks: A list of length equal to the number of ResNet blocks. Each element
      is a resnet_utils.Block object describing the units in the block.
    num_classes: Number of predicted classes for classification tasks. If None
      we return the features before the logit layer.
    is_training: whether is training or not.
    global_pool: If True, we perform global average pooling before computing the
      logits. Set to True for image classification, False for dense prediction.
    output_stride: If None, then the output will be computed at the nominal
      network stride. If output_stride is not None, it specifies the requested
      ratio of input to output spatial resolution.
    include_root_block: If True, include the initial convolution followed by
      max-pooling, if False excludes it.
    spatial_squeeze: if True, logits is of shape [B, C], if false logits is
        of shape [B, 1, 1, C], where B is batch_size and C is number of classes.
    reuse: whether or not the network and its variables should be reused. To be
      able to reuse 'scope' must be given.
    scope: Optional variable_scope.
    avr_cc: 0, default, average; 1, concatenate

  Returns:
    net: A rank-4 tensor of size [batch, height_out, width_out, channels_out].
      If global_pool is False, then height_out and width_out are reduced by a
      factor of output_stride compared to the respective height_in and width_in,
      else both height_out and width_out equal one. If num_classes is None, then
      net is the output of the last ResNet block, potentially after global
      average pooling. If num_classes is not None, net contains the pre-softmax
      activations.
    end_points: A dictionary from components of the network to the corresponding
      activation.

  Raises:
    ValueError: If the target output_stride is not valid.
  """
    with tf.variable_scope(scope, 'resnet_v1', [inputs], reuse=reuse) as sc:
        end_points_collection = sc.name + '_end_points'
        with slim.arg_scope([
                slim.conv2d, bottleneck, resnet_utils.stack_blocks_dense,
                resnet_utils.extra_fc, resnet_utils.projecting_feats
        ],
                            outputs_collections=end_points_collection):
            with slim.arg_scope(
                [resnet_utils.extra_fc],
                    loss_collection=tf.GraphKeys.REGULARIZATION_LOSSES):
                with slim.arg_scope([slim.batch_norm],
                                    is_training=is_training):
                    net = inputs
                    if include_root_block:
                        if output_stride is not None:
                            if output_stride % 4 != 0:
                                raise ValueError(
                                    'The output_stride needs to be a multiple of 4.'
                                )
                            output_stride /= 4
                        net = resnet_utils.conv2d_same(net,
                                                       64,
                                                       7,
                                                       stride=2,
                                                       scope='conv1')
                        net = slim.max_pool2d(net, [3, 3],
                                              stride=2,
                                              scope='pool1')
                    net = resnet_utils.stack_blocks_dense(
                        net, blocks, output_stride)
                    end_points = slim.utils.convert_collection_to_dict(
                        end_points_collection)
                    with tf.variable_scope('Distributions'):
                        mu = tf.reduce_mean(net, [1, 2],
                                            name='pool5',
                                            keep_dims=True)
                        end_points['global_pool'] = mu

                        sig = slim.conv2d(
                            net,
                            net.shape[-1], [net.shape[1], net.shape[2]],
                            activation_fn=None,
                            normalizer_fn=None,
                            biases_initializer=tf.zeros_initializer(),
                            scope='sig',
                            padding='VALID')

                        sig += 1e-10

                        mu = slim.dropout(mu,
                                          scope='Dropout',
                                          is_training=is_training)
                        end_points['PreLogits_mean'] = tf.squeeze(
                            mu, [1, 2], name='PreLogits_mean')
                        end_points['PreLogits_sig'] = tf.squeeze(
                            sig, [1, 2], name='PreLogits_sig')

                        tfd = tf.contrib.distributions
                        #MultivariateNormalDiagWithSoftplusScale
                        sample_dist = tfd.MultivariateNormalDiagWithSoftplusScale(
                            loc=end_points['PreLogits_mean'],
                            scale_diag=end_points['PreLogits_sig'])

                        end_points['sample_dist'] = sample_dist
                        end_points['sample_dist_samples'] = sample_dist.sample(
                            100)
                        end_points[
                            'sample_dist_covariance'] = sample_dist.stddev()

                        if not num_classes:
                            return mu, end_points

                    logits = slim.conv2d(
                        mu,
                        num_classes, [1, 1],
                        activation_fn=None,
                        normalizer_fn=None,
                        biases_initializer=tf.zeros_initializer(),
                        scope='logits')

                    logits = tf.squeeze(logits, [1, 2])

                    #with tf.variable_scope('Distributions'):
                    logits2 = []
                    for iii in range(sample_number):
                        z = sample_dist.sample(1)
                        z = tf.reshape(z, [-1, int(mu.shape[-1])])

                        #import pdb
                        #pdb.set_trace()
                        z = tf.expand_dims(z, 1)
                        z = tf.expand_dims(z, 1)
                        logits_tmp = slim.conv2d(
                            z,
                            num_classes, [1, 1],
                            activation_fn=None,
                            normalizer_fn=None,
                            biases_initializer=tf.zeros_initializer(),
                            scope='logits',
                            reuse=True)
                        logits2.append(tf.squeeze(logits_tmp, [1, 2]))

                    logits = tf.identity(logits, name='output')
                    end_points['Logits'] = logits
                    end_points['Logits2'] = logits2

                    if sample_number == 1:
                        end_points['predictions'] = slim.softmax(
                            logits + 0.1 * logits2[0], scope='predictions')
                    else:
                        end_points['predictions'] = slim.softmax(
                            logits, scope='predictions')

        return logits, logits2, end_points
Esempio n. 12
0
def resnet_twostream_inter(inputs_depth,
                           blocks_depth,
                           inputs_rgb,
                           blocks_rgb,
                           nr_frames,
                           num_classes=None,
                           is_training=True,
                           global_pool=True,
                           output_stride=None,
                           include_root_block=True,
                           spatial_squeeze=True,
                           reuse=None,
                           scope_depth=None,
                           scope_rgb=None,
                           depth_training=True):
    # depth / hallucination injects signal into rgb
    # depth stream
    with tf.device('/gpu:0'):
        inputs = inputs_depth
        scope = scope_depth
        bottleneck = bottleneck_normal
        blocks = blocks_depth
        with tf.variable_scope(scope, 'resnet_v1', [inputs],
                               reuse=reuse) as sc:
            end_points_collection = sc.name + '_end_points'
            with slim.arg_scope(
                [slim.conv2d, bottleneck, resnet_utils.stack_blocks_dense],
                    outputs_collections=end_points_collection):
                with slim.arg_scope([slim.batch_norm],
                                    is_training=depth_training):
                    net = inputs
                    if include_root_block:
                        if output_stride is not None:
                            if output_stride % 4 != 0:
                                raise ValueError(
                                    'The output_stride needs to be a multiple of 4.'
                                )
                            output_stride /= 4
                        net = resnet_utils.conv2d_same(net,
                                                       64,
                                                       7,
                                                       stride=2,
                                                       scope='conv1')
                        net = slim.max_pool2d(net, [3, 3],
                                              stride=2,
                                              scope='pool1')
                    net = resnet_utils.stack_blocks_dense(
                        net, blocks, nr_frames, output_stride)
                    if global_pool:
                        net = tf.reduce_mean(net, [1, 2],
                                             name='pool5',
                                             keep_dims=True)
                    if num_classes is not None:
                        net = slim.conv2d(net,
                                          num_classes, [1, 1],
                                          activation_fn=None,
                                          normalizer_fn=None,
                                          scope='logits')
                        if spatial_squeeze:
                            net = tf.squeeze(net, [1, 2],
                                             name='SpatialSqueeze')
                    end_points = slim.utils.convert_collection_to_dict(
                        end_points_collection)
                    if num_classes is not None:
                        end_points['predictions'] = slim.softmax(
                            net, scope='predictions')
                    net_depth = net
                    end_points_depth = end_points

    end_points_to_pass = {}
    end_points_to_pass[scope_depth +
                       '/block1/unit_1/bottleneck_v1'] = end_points_depth[
                           scope_depth + '/block1/unit_1/bottleneck_v1']
    end_points_to_pass[scope_depth +
                       '/block2/unit_1/bottleneck_v1'] = end_points_depth[
                           scope_depth + '/block2/unit_1/bottleneck_v1']
    end_points_to_pass[scope_depth +
                       '/block3/unit_1/bottleneck_v1'] = end_points_depth[
                           scope_depth + '/block3/unit_1/bottleneck_v1']
    end_points_to_pass[scope_depth +
                       '/block4/unit_1/bottleneck_v1'] = end_points_depth[
                           scope_depth + '/block4/unit_1/bottleneck_v1']

    # rgb stream
    with tf.device('/gpu:1'):
        inputs = inputs_rgb
        scope = scope_rgb
        bottleneck = bottleneck_injected
        blocks = blocks_rgb
        with tf.variable_scope(scope, 'resnet_v1', [inputs],
                               reuse=reuse) as sc:
            end_points_collection = sc.name + '_end_points'
            with slim.arg_scope([
                    slim.conv2d, bottleneck,
                    resnet_utils.stack_blocks_dense_injected
            ],
                                outputs_collections=end_points_collection):
                with slim.arg_scope([slim.batch_norm],
                                    is_training=is_training):
                    net = inputs
                    if include_root_block:
                        if output_stride is not None:
                            if output_stride % 4 != 0:
                                raise ValueError(
                                    'The output_stride needs to be a multiple of 4.'
                                )
                            output_stride /= 4
                        net = resnet_utils.conv2d_same(net,
                                                       64,
                                                       7,
                                                       stride=2,
                                                       scope='conv1')
                        net = slim.max_pool2d(net, [3, 3],
                                              stride=2,
                                              scope='pool1')
                    net = resnet_utils.stack_blocks_dense_injected(
                        net, blocks, nr_frames, end_points_to_pass,
                        'resnet_v1_50_depth/', output_stride)
                    if global_pool:
                        net = tf.reduce_mean(net, [1, 2],
                                             name='pool5',
                                             keep_dims=True)
                    if num_classes is not None:
                        net = slim.conv2d(net,
                                          num_classes, [1, 1],
                                          activation_fn=None,
                                          normalizer_fn=None,
                                          scope='logits')
                        if spatial_squeeze:
                            net = tf.squeeze(net, [1, 2],
                                             name='SpatialSqueeze')
                    end_points = slim.utils.convert_collection_to_dict(
                        end_points_collection)
                    if num_classes is not None:
                        end_points['predictions'] = slim.softmax(
                            net, scope='predictions')
                    net_rgb = net
                    end_points_rgb = end_points

    return net_depth, end_points_depth, net_rgb, end_points_rgb
Esempio n. 13
0
def resnet_one_stream(inputs,
                      blocks,
                      nr_frames,
                      num_classes=None,
                      is_training=True,
                      global_pool=True,
                      output_stride=None,
                      include_root_block=True,
                      spatial_squeeze=True,
                      reuse=None,
                      scope=None,
                      gpu_id='/gpu:0'):
    bottleneck = bottleneck_normal
    with tf.device(gpu_id):
        with tf.variable_scope(scope, 'resnet_v1', [inputs],
                               reuse=reuse) as sc:
            end_points_collection = sc.name + '_end_points'
            with slim.arg_scope(
                [slim.conv2d, bottleneck, resnet_utils.stack_blocks_dense],
                    outputs_collections=end_points_collection):
                with slim.arg_scope([slim.batch_norm],
                                    is_training=is_training):
                    net = inputs
                    if include_root_block:
                        if output_stride is not None:
                            if output_stride % 4 != 0:
                                raise ValueError(
                                    'The output_stride needs to be a multiple of 4.'
                                )
                            output_stride /= 4
                        net = resnet_utils.conv2d_same(net,
                                                       64,
                                                       7,
                                                       stride=2,
                                                       scope='conv1')
                        net = slim.max_pool2d(net, [3, 3],
                                              stride=2,
                                              scope='pool1')
                    net = resnet_utils.stack_blocks_dense(
                        net, blocks, nr_frames, output_stride)
                    if global_pool:
                        net = tf.reduce_mean(net, [1, 2],
                                             name='pool5',
                                             keep_dims=True)
                    last_pool = net
                    if num_classes is not None:
                        net = slim.conv2d(net,
                                          num_classes, [1, 1],
                                          activation_fn=None,
                                          normalizer_fn=None,
                                          scope='logits')
                        if spatial_squeeze:
                            net = tf.squeeze(net, [1, 2],
                                             name='SpatialSqueeze')
                    end_points = slim.utils.convert_collection_to_dict(
                        end_points_collection)
                    if num_classes is not None:
                        end_points['predictions'] = slim.softmax(
                            net, scope='predictions')
                    end_points['last_pool'] = last_pool
    return net, end_points
def resnet_v1(inputs,
              blocks,
              num_classes=None,
              is_training=True,
              global_pool=True,
              output_stride=None,
              include_root_block=True,
              spatial_squeeze=True,
              store_non_strided_activations=False,
              reuse=None,
              scope=None):

    with tf.variable_scope(scope, 'resnet_v1', [inputs], reuse=reuse) as sc:
        end_points_collection = sc.original_name_scope + '_end_points'
        with slim.arg_scope(
            [slim.conv2d, bottleneck, resnet_utils.stack_blocks_dense],
                outputs_collections=end_points_collection):
            with (slim.arg_scope([slim.batch_norm],
                                 decay=0.99,
                                 zero_debias_moving_mean=True,
                                 is_training=is_training)
                  if is_training is not None else NoOpScope()):
                net = inputs
                if include_root_block:
                    if output_stride is not None:
                        if output_stride % 4 != 0:
                            raise ValueError(
                                'The output_stride needs to be a multiple of 4.'
                            )
                        output_stride /= 4
                    net = slim.batch_norm(net,
                                          decay=0.99,
                                          zero_debias_moving_mean=True,
                                          scale=True)
                    net = slim.conv2d(net,
                                      64,
                                      7,
                                      stride=2,
                                      padding='SAME',
                                      normalizer_fn=slim.batch_norm,
                                      normalizer_params={
                                          'decay': 0.99,
                                          'zero_debias_moving_mean': True
                                      },
                                      activation_fn=tf.nn.relu,
                                      scope='conv1')
                    net = slim.max_pool2d(net, [3, 3],
                                          stride=2,
                                          padding='SAME',
                                          scope='pool1')
                net = resnet_utils.stack_blocks_dense(net, blocks,
                                                      output_stride)
                # Convert end_points_collection into a dictionary of end_points.
                end_points = slim.utils.convert_collection_to_dict(
                    end_points_collection)

                num_types = 4
                num_color = 3
                types = slim.conv2d(
                    net,
                    num_types, [1, 1],
                    activation_fn=tf.nn.relu,
                    weights_initializer=tf.truncated_normal_initializer(
                        mean=0, stddev=0.01),
                    normalizer_fn=None,
                    scope='logits_type')
                end_points[sc.name + '/logits_type'] = net

                if global_pool:
                    types = tf.reduce_mean(types, [1, 2],
                                           name='pool5',
                                           keepdims=True)
                    end_points['global_pool_types'] = types

                if spatial_squeeze:
                    types = tf.squeeze(types, [1, 2], name='type')
                    end_points[sc.name + '/type'] = types
                end_points['predictions_types'] = types

                color = slim.conv2d(
                    net,
                    num_color, [1, 1],
                    activation_fn=tf.nn.relu,
                    weights_initializer=tf.truncated_normal_initializer(
                        mean=0, stddev=0.01),
                    normalizer_fn=None,
                    scope='logits')
                end_points[sc.name + '/logits'] = color

                if global_pool:
                    color = tf.reduce_mean(color, [1, 2],
                                           name='pool6',
                                           keepdims=True)
                    end_points['global_pool_color'] = color

                if spatial_squeeze:
                    color = tf.squeeze(color, [1, 2], name='color')
                    end_points[sc.name + '/color'] = color
                end_points['predictions_color'] = color

                return net, end_points
Esempio n. 15
0
  def testStridingLastUnitVsSubsampleBlockEnd(self):
    """Compares subsampling at the block's last unit or block's end.

    Makes sure that the final output is the same when we use a stride at the
    last unit of a block vs. we subsample activations at the end of a block.
    """
    block = resnet_v1.resnet_v1_block

    blocks = [
        block('block1', base_depth=1, num_units=2, stride=2),
        block('block2', base_depth=2, num_units=2, stride=2),
        block('block3', base_depth=4, num_units=2, stride=2),
        block('block4', base_depth=8, num_units=2, stride=1),
    ]

    # Test both odd and even input dimensions.
    height = 30
    width = 31
    with slim.arg_scope(resnet_utils.resnet_arg_scope()):
      with slim.arg_scope([slim.batch_norm], 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)

              # Subsampling at the last unit of the block.
              output = resnet_utils.stack_blocks_dense(
                  inputs, blocks, output_stride,
                  store_non_strided_activations=False,
                  outputs_collections='output')
              output_end_points = slim.utils.convert_collection_to_dict(
                  'output')

              # Make the two networks use the same weights.
              tf.get_variable_scope().reuse_variables()

              # Subsample activations at the end of the blocks.
              expected = resnet_utils.stack_blocks_dense(
                  inputs, blocks, output_stride,
                  store_non_strided_activations=True,
                  outputs_collections='expected')
              expected_end_points = slim.utils.convert_collection_to_dict(
                  'expected')

              sess.run(tf.global_variables_initializer())

              # Make sure that the final output is the same.
              output, expected = sess.run([output, expected])
              self.assertAllClose(output, expected, atol=1e-4, rtol=1e-4)

              # Make sure that intermediate block activations in
              # output_end_points are subsampled versions of the corresponding
              # ones in expected_end_points.
              for i, block in enumerate(blocks[:-1:]):
                output = output_end_points[block.scope]
                expected = expected_end_points[block.scope]
                atrous_activated = (output_stride is not None and
                                    2 ** i >= output_stride)
                if not atrous_activated:
                  expected = resnet_utils.subsample(expected, 2)
                output, expected = sess.run([output, expected])
                self.assertAllClose(output, expected, atol=1e-4, rtol=1e-4)
Esempio n. 16
0
    def testStridingLastUnitVsSubsampleBlockEnd(self):
        """Compares subsampling at the block's last unit or block's end.

    Makes sure that the final output is the same when we use a stride at the
    last unit of a block vs. we subsample activations at the end of a block.
    """
        block = resnet_v1.resnet_v1_block

        blocks = [
            block('block1', base_depth=1, num_units=2, stride=2),
            block('block2', base_depth=2, num_units=2, stride=2),
            block('block3', base_depth=4, num_units=2, stride=2),
            block('block4', base_depth=8, num_units=2, stride=1),
        ]

        # Test both odd and even input dimensions.
        height = 30
        width = 31
        with slim.arg_scope(resnet_utils.resnet_arg_scope()):
            with slim.arg_scope([slim.batch_norm], 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)

                            # Subsampling at the last unit of the block.
                            output = resnet_utils.stack_blocks_dense(
                                inputs,
                                blocks,
                                output_stride,
                                store_non_strided_activations=False,
                                outputs_collections='output')
                            output_end_points = slim.utils.convert_collection_to_dict(
                                'output')

                            # Make the two networks use the same weights.
                            tf.get_variable_scope().reuse_variables()

                            # Subsample activations at the end of the blocks.
                            expected = resnet_utils.stack_blocks_dense(
                                inputs,
                                blocks,
                                output_stride,
                                store_non_strided_activations=True,
                                outputs_collections='expected')
                            expected_end_points = slim.utils.convert_collection_to_dict(
                                'expected')

                            sess.run(tf.global_variables_initializer())

                            # Make sure that the final output is the same.
                            output, expected = sess.run([output, expected])
                            self.assertAllClose(output,
                                                expected,
                                                atol=1e-4,
                                                rtol=1e-4)

                            # Make sure that intermediate block activations in
                            # output_end_points are subsampled versions of the corresponding
                            # ones in expected_end_points.
                            for i, block in enumerate(blocks[:-1:]):
                                output = output_end_points[block.scope]
                                expected = expected_end_points[block.scope]
                                atrous_activated = (output_stride is not None
                                                    and 2**i >= output_stride)
                                if not atrous_activated:
                                    expected = resnet_utils.subsample(
                                        expected, 2)
                                output, expected = sess.run([output, expected])
                                self.assertAllClose(output,
                                                    expected,
                                                    atol=1e-4,
                                                    rtol=1e-4)
Esempio n. 17
0
    """
    with tf.variable_scope(self._architecture, reuse=self._reuse_weights):
      with slim.arg_scope(
          resnet_utils.resnet_arg_scope(
              batch_norm_epsilon=1e-5,
              batch_norm_scale=True,
              weight_decay=self._weight_decay)):
        with slim.arg_scope([slim.batch_norm], is_training=False):
          blocks = [
              resnet_utils.Block('block4', resnet_v1.bottleneck, [{
                  'depth': 2048,
                  'depth_bottleneck': 512,
                  'stride': 1
              }] * 3)
          ]
          proposal_classifier_features = resnet_utils.stack_blocks_dense(
              proposal_feature_maps, blocks)
    return proposal_classifier_features


class FasterRCNNResnet50FeatureExtractor(FasterRCNNResnetV1FeatureExtractor):    //基础上述基类,RCNN 50 特征提取器
  """Faster R-CNN Resnet 50 feature extractor implementation."""

  def __init__(self,
               is_training,
               first_stage_features_stride,
               reuse_weights=None,
               weight_decay=0.0):
    """Constructor.

    Args:
      is_training: See base class.
Esempio n. 18
0
def resnet_v2(inputs,
              blocks,
              num_classes=None,
              is_training=True,
              global_pool=True,
              output_stride=None,
              include_root_block=True,
              spatial_squeeze=False,
              reuse=None,
              scope=None):
    """Generator for v2 (preactivation) ResNet models.

  This function generates a family of ResNet v2 models. See the resnet_v2_*()
  methods for specific model instantiations, obtained by selecting different
  block instantiations that produce ResNets of various depths.

  Training for image classification on Imagenet is usually done with [224, 224]
  inputs, resulting in [7, 7] feature maps at the output of the last ResNet
  block for the ResNets defined in [1] that have nominal stride equal to 32.
  However, for dense prediction tasks we advise that one uses inputs with
  spatial dimensions that are multiples of 32 plus 1, e.g., [321, 321]. In
  this case the feature maps at the ResNet output will have spatial shape
  [(height - 1) / output_stride + 1, (width - 1) / output_stride + 1]
  and corners exactly aligned with the input image corners, which greatly
  facilitates alignment of the features to the image. Using as input [225, 225]
  images results in [8, 8] feature maps at the output of the last ResNet block.

  For dense prediction tasks, the ResNet needs to run in fully-convolutional
  (FCN) mode and global_pool needs to be set to False. The ResNets in [1, 2] all
  have nominal stride equal to 32 and a good choice in FCN mode is to use
  output_stride=16 in order to increase the density of the computed features at
  small computational and memory overhead, cf. http://arxiv.org/abs/1606.00915.

  Args:
    inputs: A tensor of size [batch, height_in, width_in, channels].
    blocks: A list of length equal to the number of ResNet blocks. Each element
      is a resnet_utils.Block object describing the units in the block.
    num_classes: Number of predicted classes for classification tasks. If None
      we return the features before the logit layer.
    is_training: whether is training or not.
    global_pool: If True, we perform global average pooling before computing the
      logits. Set to True for image classification, False for dense prediction.
    output_stride: If None, then the output will be computed at the nominal
      network stride. If output_stride is not None, it specifies the requested
      ratio of input to output spatial resolution.
    include_root_block: If True, include the initial convolution followed by
      max-pooling, if False excludes it. If excluded, `inputs` should be the
      results of an activation-less convolution.
    spatial_squeeze: if True, logits is of shape [B, C], if false logits is
        of shape [B, 1, 1, C], where B is batch_size and C is number of classes.
        To use this parameter, the input images must be smaller than 300x300
        pixels, in which case the output logit layer does not contain spatial
        information and can be removed.
    reuse: whether or not the network and its variables should be reused. To be
      able to reuse 'scope' must be given.
    scope: Optional variable_scope.


  Returns:
    net: A rank-4 tensor of size [batch, height_out, width_out, channels_out].
      If global_pool is False, then height_out and width_out are reduced by a
      factor of output_stride compared to the respective height_in and width_in,
      else both height_out and width_out equal one. If num_classes is None, then
      net is the output of the last ResNet block, potentially after global
      average pooling. If num_classes is not None, net contains the pre-softmax
      activations.
    end_points: A dictionary from components of the network to the corresponding
      activation.

  Raises:
    ValueError: If the target output_stride is not valid.
  """
    with tf.variable_scope(scope, 'resnet_v2', [inputs], reuse=reuse) as sc:
        end_points_collection = sc.name + '_end_points'
        with slim.arg_scope(
            [slim.conv2d, bottleneck, resnet_utils.stack_blocks_dense],
                outputs_collections=end_points_collection):
            with slim.arg_scope([slim.batch_norm], is_training=is_training):
                net = inputs
                if include_root_block:
                    if output_stride is not None:
                        if output_stride % 4 != 0:
                            raise ValueError(
                                'The output_stride needs to be a multiple of 4.'
                            )
                        output_stride /= 4
                    # We do not include batch normalization or activation functions in
                    # conv1 because the first ResNet unit will perform these. Cf.
                    # Appendix of [2].
                    with slim.arg_scope([slim.conv2d],
                                        activation_fn=None,
                                        normalizer_fn=None):
                        net = resnet_utils.conv2d_same(net,
                                                       64,
                                                       7,
                                                       stride=2,
                                                       scope='conv1')
                    net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool1')
                net = resnet_utils.stack_blocks_dense(net, blocks,
                                                      output_stride)
                # This is needed because the pre-activation variant does not have batch
                # normalization or activation functions in the residual unit output. See
                # Appendix of [2].
                net = slim.batch_norm(net,
                                      activation_fn=tf.nn.relu,
                                      scope='postnorm')
                if global_pool:
                    # Global average pooling.
                    net = tf.reduce_mean(net, [1, 2],
                                         name='pool5',
                                         keep_dims=True)
                if num_classes is not None:
                    net = slim.conv2d(net,
                                      num_classes, [1, 1],
                                      activation_fn=None,
                                      normalizer_fn=None,
                                      scope='logits')
                    if spatial_squeeze:
                        net = tf.squeeze(net, [1, 2], name='SpatialSqueeze')
                # Convert end_points_collection into a dictionary of end_points.
                end_points = slim.utils.convert_collection_to_dict(
                    end_points_collection)
                if num_classes is not None:
                    end_points['predictions'] = slim.softmax(
                        net, scope='predictions')
                return net, end_points
Esempio n. 19
0
def resnet_v1(inputs,
              blocks,
              num_classes=None,
              is_training=True,
              extra_fc_type=-1,
              extra_fc_out_dim=0,
              extra_fc_W_decay=0.0,
              f_decorr_fr=-1.,
              f_decorr_decay=0.0,
              global_pool=True,
              output_stride=None,
              include_root_block=True,
              spatial_squeeze=True,
              avr_cc=0,
              feat_proj_type=-1,
              proj_dim=1024,
              feat_prop_down=False,
              reuse=None,
              scope=None):
    """Generator for v1 ResNet models.

  This function generates a family of ResNet v1 models. See the resnet_v1_*()
  methods for specific model instantiations, obtained by selecting different
  block instantiations that produce ResNets of various depths.

  Training for image classification on Imagenet is usually done with [224, 224]
  inputs, resulting in [7, 7] feature maps at the output of the last ResNet
  block for the ResNets defined in [1] that have nominal stride equal to 32.
  However, for dense prediction tasks we advise that one uses inputs with
  spatial dimensions that are multiples of 32 plus 1, e.g., [321, 321]. In
  this case the feature maps at the ResNet output will have spatial shape
  [(height - 1) / output_stride + 1, (width - 1) / output_stride + 1]
  and corners exactly aligned with the input image corners, which greatly
  facilitates alignment of the features to the image. Using as input [225, 225]
  images results in [8, 8] feature maps at the output of the last ResNet block.

  For dense prediction tasks, the ResNet needs to run in fully-convolutional
  (FCN) mode and global_pool needs to be set to False. The ResNets in [1, 2] all
  have nominal stride equal to 32 and a good choice in FCN mode is to use
  output_stride=16 in order to increase the density of the computed features at
  small computational and memory overhead, cf. http://arxiv.org/abs/1606.00915.

  Args:
    inputs: A tensor of size [batch, height_in, width_in, channels].
    blocks: A list of length equal to the number of ResNet blocks. Each element
      is a resnet_utils.Block object describing the units in the block.
    num_classes: Number of predicted classes for classification tasks. If None
      we return the features before the logit layer.
    is_training: whether is training or not.
    global_pool: If True, we perform global average pooling before computing the
      logits. Set to True for image classification, False for dense prediction.
    output_stride: If None, then the output will be computed at the nominal
      network stride. If output_stride is not None, it specifies the requested
      ratio of input to output spatial resolution.
    include_root_block: If True, include the initial convolution followed by
      max-pooling, if False excludes it.
    spatial_squeeze: if True, logits is of shape [B, C], if false logits is
        of shape [B, 1, 1, C], where B is batch_size and C is number of classes.
    reuse: whether or not the network and its variables should be reused. To be
      able to reuse 'scope' must be given.
    scope: Optional variable_scope.
    avr_cc: 0, default, average; 1, concatenate

  Returns:
    net: A rank-4 tensor of size [batch, height_out, width_out, channels_out].
      If global_pool is False, then height_out and width_out are reduced by a
      factor of output_stride compared to the respective height_in and width_in,
      else both height_out and width_out equal one. If num_classes is None, then
      net is the output of the last ResNet block, potentially after global
      average pooling. If num_classes is not None, net contains the pre-softmax
      activations.
    end_points: A dictionary from components of the network to the corresponding
      activation.

  Raises:
    ValueError: If the target output_stride is not valid.
  """
    with tf.variable_scope(scope, 'resnet_v1', [inputs], reuse=reuse) as sc:
        end_points_collection = sc.name + '_end_points'
        with slim.arg_scope([
                slim.conv2d, bottleneck, resnet_utils.stack_blocks_dense,
                resnet_utils.extra_fc, resnet_utils.projecting_feats
        ],
                            outputs_collections=end_points_collection):
            with slim.arg_scope(
                [resnet_utils.extra_fc],
                    loss_collection=tf.GraphKeys.REGULARIZATION_LOSSES):
                with slim.arg_scope([slim.batch_norm],
                                    is_training=is_training):
                    net = inputs
                    if include_root_block:
                        if output_stride is not None:
                            if output_stride % 4 != 0:
                                raise ValueError(
                                    'The output_stride needs to be a multiple of 4.'
                                )
                            output_stride /= 4
                        net = resnet_utils.conv2d_same(net,
                                                       64,
                                                       7,
                                                       stride=2,
                                                       scope='conv1')
                        net = slim.max_pool2d(net, [3, 3],
                                              stride=2,
                                              scope='pool1')
                    net = resnet_utils.stack_blocks_dense(
                        net, blocks, output_stride)
                    if extra_fc_type >= 0:
                        # extra fc layer; keep its dimension as 4?
                        net, pre_pool5 = resnet_utils.extra_fc(
                            net, extra_fc_out_dim, extra_fc_W_decay,
                            extra_fc_type, f_decorr_fr, f_decorr_decay)
                    elif global_pool:
                        # Global average pooling.
                        net = tf.reduce_mean(net, [1, 2],
                                             name='pool5',
                                             keep_dims=True)
                        deep_branch_feat = net
                        # if (gate_proj_type != -1) and (gate_aug_type != -1):
                        #     raise ValueError('Either gate_proj_type or gate_aug_type can be activated at a time.')
                        #
                        # if not gate_aug_type == -1:
                        #     # Augmenting pool5 features with gates
                        #     net = MoEL_utils.augmenting_gates(net, gate_aug_type, gate_prop_down, is_training,
                        #                                       concat_gate_reg=concat_gate_reg,
                        #                                       concat_gate_reg_type=concat_gate_reg_type)

                        if not feat_proj_type == -1:
                            # projecting hidden feats and/or deep fc features to the same dimension and fuse them up
                            net = resnet_utils.projecting_feats(net,
                                                                feat_proj_type,
                                                                proj_dim,
                                                                feat_prop_down,
                                                                is_training,
                                                                avr_cc=avr_cc)

                    if num_classes is not None:
                        net = slim.conv2d(net,
                                          num_classes, [1, 1],
                                          activation_fn=None,
                                          normalizer_fn=None,
                                          scope='logits')
                    if spatial_squeeze:
                        logits = tf.squeeze(net, [1, 2], name='SpatialSqueeze')
                    # Convert end_points_collection into a dictionary of end_points.
                    end_points = slim.utils.convert_collection_to_dict(
                        end_points_collection)

                    if num_classes is not None:
                        end_points['predictions'] = slim.softmax(
                            net, scope='predictions')
                    if extra_fc_type >= 0:
                        end_points['pre_pool5'] = pre_pool5
                    elif global_pool:
                        end_points['deep_branch_feat'] = deep_branch_feat
                        end_points['PreLogits'] = tf.squeeze(deep_branch_feat,
                                                             [1, 2],
                                                             name='PreLogits')
                    end_points['Logits'] = logits
                    return logits, end_points