text: import tensorflow as tf
  from tensorflow.contrib import slim
  import models.resnet_utils as resnet_utils
  
  resnet_arg_scope = resnet_utils.resnet_arg_scope
  
  @slim.add_arg_scope
  def bottleneck(inputs, depth, depth_bottleneck, stride, rate=1,
                 outputs_collections=None, scope=None):
      """Bottleneck residual unit variant with BN after convolutions.
      This is the original residual unit proposed in [1]. See Fig. 1(a) of [2] for
      its definition. Note that we use here the bottleneck variant which has an
      extra bottleneck layer.
      When putting together two consecutive ResNet blocks that use this unit, one
      should use stride = 2 in the last unit of the first block.
      Args:
        inputs: A tensor of size [batch, height, width, channels].
        depth: The depth of the ResNet unit output.
        depth_bottleneck: The depth of the bottleneck layers.
        stride: The ResNet unit's stride. Determines the amount of downsampling of
          the units output compared to its input.
        rate: An integer, rate for atrous convolution.
        outputs_collections: Collection to add the ResNet unit output.
        scope: Optional variable_scope.
      Returns:
        The ResNet unit's output.
      """
      with tf.variable_scope(scope, 'bottleneck_v1', [inputs]) as sc:
          depth_in = slim.utils.last_dimension(inputs.get_shape(), min_rank=4)
          if depth == depth_in:
              shortcut = resnet_utils.subsample(inputs, stride, 'shortcut')
          else:
              shortcut = slim.conv2d(inputs, depth, [1, 1], stride=stride,
                                     activation_fn=None, scope='shortcut')
          residual = slim.conv2d(inputs, depth_bottleneck, [1, 1], stride=1,
                                 scope='conv1')
          residual = resnet_utils.conv2d_same(residual, depth_bottleneck, 3, stride,
                                              rate=rate, scope='conv2')
          residual = slim.conv2d(residual, depth, [1, 1], stride=1,
                                 activation_fn=None, scope='conv3')
  
          output = tf.nn.relu(shortcut + residual)
  
          return slim.utils.collect_named_outputs(outputs_collections,
                                                  sc.original_name_scope,
                                                  output)
  
  
  def resnet_v1(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):
      """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 = slim.utils.collect_named_outputs(end_points_collection, 'pool2', net)
  
                  net = resnet_utils.stack_blocks_dense(net, blocks, output_stride)
                  end_points = slim.utils.convert_collection_to_dict(end_points_collection)
  
                  end_points['pool3'] = end_points[scope + '/block1']
                  end_points['pool4'] = end_points[scope + '/block2']
                  end_points['pool5'] = net
                  return net, end_points
  
  
  resnet_v1.default_image_size = 224
  
  def resnet_v1_50(inputs,
                   num_classes=None,
                   is_training=True,
                   global_pool=True,
                   output_stride=None,
                   spatial_squeeze=True,
                   reuse=None,
                   scope='resnet_v1_50'):
      """ResNet-50 model of [1]. See resnet_v1() for arg and return description."""
      blocks = [
          resnet_utils.Block(
              'block1', bottleneck, [(256, 64, 1)] * 2 + [(256, 64, 2)]),
          resnet_utils.Block(
              'block2', bottleneck, [(512, 128, 1)] * 3 + [(512, 128, 2)]),
          resnet_utils.Block(
              'block3', bottleneck, [(1024, 256, 1)] * 5 + [(1024, 256, 2)]),
          resnet_utils.Block(
              'block4', bottleneck, [(2048, 512, 1)] * 3)
      ]
      return resnet_v1(inputs, blocks, num_classes, is_training,
                       global_pool=global_pool, output_stride=output_stride,
                       include_root_block=True, spatial_squeeze=spatial_squeeze,
                       reuse=reuse, scope=scope)
  
  
  resnet_v1_50.default_image_size = resnet_v1.default_image_size
  
  
  def resnet_v1_101(inputs,
                    num_classes=None,
                    is_training=True,
                    global_pool=True,
                    output_stride=None,
                    spatial_squeeze=True,
                    reuse=None,
                    scope='resnet_v1_101'):
      """ResNet-101 model of [1]. See resnet_v1() for arg and return description."""
      blocks = [
          resnet_utils.Block(
              'block1', bottleneck, [(256, 64, 1)] * 2 + [(256, 64, 2)]),
          resnet_utils.Block(
              'block2', bottleneck, [(512, 128, 1)] * 3 + [(512, 128, 2)]),
          resnet_utils.Block(
              'block3', bottleneck, [(1024, 256, 1)] * 22 + [(1024, 256, 2)]),
          resnet_utils.Block(
              'block4', bottleneck, [(2048, 512, 1)] * 3)
      ]
      return resnet_v1(inputs, blocks, num_classes, is_training,
                       global_pool=global_pool, output_stride=output_stride,
                       include_root_block=True, spatial_squeeze=spatial_squeeze,
                       reuse=reuse, scope=scope)
  
  
  resnet_v1_101.default_image_size = resnet_v1.default_image_size
  
  
  def resnet_v1_152(inputs,
                    num_classes=None,
                    is_training=True,
                    global_pool=True,
                    output_stride=None,
                    spatial_squeeze=True,
                    reuse=None,
                    scope='resnet_v1_152'):
      """ResNet-152 model of [1]. See resnet_v1() for arg and return description."""
      blocks = [
          resnet_utils.Block(
              'block1', bottleneck, [(256, 64, 1)] * 2 + [(256, 64, 2)]),
          resnet_utils.Block(
              'block2', bottleneck, [(512, 128, 1)] * 7 + [(512, 128, 2)]),
          resnet_utils.Block(
              'block3', bottleneck, [(1024, 256, 1)] * 35 + [(1024, 256, 2)]),
          resnet_utils.Block(
              'block4', bottleneck, [(2048, 512, 1)] * 3)]
      return resnet_v1(inputs, blocks, num_classes, is_training,
                       global_pool=global_pool, output_stride=output_stride,
                       include_root_block=True, spatial_squeeze=spatial_squeeze,
                       reuse=reuse, scope=scope)
  
  
  resnet_v1_152.default_image_size = resnet_v1.default_image_size
  
  
  def resnet_v1_200(inputs,
                    num_classes=None,
                    is_training=True,
                    global_pool=True,
                    output_stride=None,
                    spatial_squeeze=True,
                    reuse=None,
                    scope='resnet_v1_200'):
      """ResNet-200 model of [2]. See resnet_v1() for arg and return description."""
      blocks = [
          resnet_utils.Block(
              'block1', bottleneck, [(256, 64, 1)] * 2 + [(256, 64, 2)]),
          resnet_utils.Block(
              'block2', bottleneck, [(512, 128, 1)] * 23 + [(512, 128, 2)]),
          resnet_utils.Block(
              'block3', bottleneck, [(1024, 256, 1)] * 35 + [(1024, 256, 2)]),
          resnet_utils.Block(
              'block4', bottleneck, [(2048, 512, 1)] * 3)]
      return resnet_v1(inputs, blocks, num_classes, is_training,
                       global_pool=global_pool, output_stride=output_stride,
                       include_root_block=True, spatial_squeeze=spatial_squeeze,
                       reuse=reuse, scope=scope)
  
  
  resnet_v1_200.default_image_size = resnet_v1.default_image_size
  
  
  if __name__ == '__main__':
      input = tf.placeholder(tf.float32, shape=(None, 224, 224, 3), name='input')
      with slim.arg_scope(resnet_arg_scope()) as sc:
          logits = resnet_v1_50(input)