def resnet(inputs,
blocks,
num_classes = None,
is_training = True,
global_pool = True,
include_root_block = True,
conv1_depth = 64,
reuse=None,
scope=None):
"""Generator for ResNet models.
Args:
inputs: A `Tensor` of size `[batch, height_in, width_in, channels_in]`.
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: The number of predicted classes for classification tasks.
is_training: Whether batch norm layers are in training mode.
global_pool: If True, performs global average pooling before computing the
logits.
include_root_block: If True, includes the initial convolution, otherwise
excludes it.
conv1_depth: The number of filters of the first convolutional layer.
reuse: Whether 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]`.
end_points: A dictionary from components of the network to the corresponding
activation.
"""
with tf.variable_scope(scope, 'resnet', [inputs], reuse=reuse) as sc:
end_points_collection = sc.original_name_scope + 'end_points'
# noinspection PyCallingNonCallable
with slim.arg_scope(
[conv2d, basic_block, bottleneck, resnet_utils.stack_blocks_dense],
outputs_collections=end_points_collection):
# noinspection PyCallingNonCallable
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 _use_small_root_block(inputs):
net = resnet_utils.conv2d_same(
net, conv1_depth, kernel_size=3, stride=1, scope='conv1')
else:
net = resnet_utils.conv2d_same(
net, conv1_depth, kernel_size=7, stride=2, scope='conv1')
if not _skip_first_max_pooling(inputs):
net = slim.max_pool2d(
net, kernel_size=3, stride=2, padding='SAME', scope='pool1')
net = resnet_utils.stack_blocks_dense(net, blocks)
end_points = utils.convert_collection_to_dict(
end_points_collection, clear_collection=True)
if global_pool:
# Global average pooling.
net = tf.reduce_mean(net, axis=[1, 2], name='pool5', keepdims=True)
end_points['global_pool'] = net
if num_classes:
net = conv2d(
net,
num_classes,
kernel_size=1,
activation_fn=None,
normalizer_fn=None,
scope='logits')
end_points[sc.name + '/logits'] = net
end_points['predictions'] = slim.softmax(net, scope='predictions')
return net, end_points
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.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
with slim.arg_scope([slim.conv2d],
activation_fn=None,
normalizer_fn=None):
net = resnet_utils.conv2d_same(net,
64,
6,
stride=1,
scope='conv1')
net = slim.max_pool2d(net, [2, 2], stride=2, scope='pool1')
net = resnet_utils.stack_blocks_dense(net, blocks,
output_stride)
net = slim.batch_norm(net,
activation_fn=tf.nn.relu,
scope='postnorm')
output0 = net
if global_pool:
net = tf.reduce_mean(net, [1, 2],
name='pool5',
keep_dims=True)
output1 = 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:
logits = 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(
logits, scope='predictions')
return logits, end_points, output0, output1
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,
root_initializers=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.
root_initializers: Initializers for root block conv and batchnorm layers.
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',
**root_initializers)
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(input_tensor=net,
axis=[1, 2],
name='pool5',
keepdims=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 vgg_16(inputs, reuse=False, pooling='avg', final_endpoint='fc8'):
"""VGG-16 implementation intended for test-time use.
It takes inputs with values in [0, 1] and preprocesses them (scaling,
mean-centering) before feeding them to the VGG-16 network.
Args:
inputs: A 4-D tensor of shape [batch_size, image_size, image_size, 3]
and dtype float32, with values in [0, 1].
reuse: bool. Whether to reuse model parameters. Defaults to False.
pooling: str in {'avg', 'max'}, which pooling operation to use. Defaults
to 'avg'.
final_endpoint: str, specifies the endpoint to construct the network up to.
Defaults to 'fc8'.
Returns:
A dict mapping end-point names to their corresponding Tensor.
Raises:
ValueError: the final_endpoint argument is not recognized.
"""
inputs *= 255.0
inputs -= tf.constant([123.68, 116.779, 103.939], dtype=tf.float32)
pooling_fns = {'avg': slim.avg_pool2d, 'max': slim.max_pool2d}
pooling_fn = pooling_fns[pooling]
with tf.variable_scope('vgg_16', [inputs], reuse=reuse) as sc:
end_points = {}
def add_and_check_is_final(layer_name, net):
end_points['%s/%s' % (sc.name, layer_name)] = net
return layer_name == final_endpoint
with slim.arg_scope([slim.conv2d], trainable=False):
net = slim.repeat(inputs,
2,
slim.conv2d,
64, [3, 3],
scope='conv1')
if add_and_check_is_final('conv1', net): return end_points
net = pooling_fn(net, [2, 2], scope='pool1')
if add_and_check_is_final('pool1', net): return end_points
net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], scope='conv2')
if add_and_check_is_final('conv2', net): return end_points
net = pooling_fn(net, [2, 2], scope='pool2')
if add_and_check_is_final('pool2', net): return end_points
net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], scope='conv3')
if add_and_check_is_final('conv3', net): return end_points
net = pooling_fn(net, [2, 2], scope='pool3')
if add_and_check_is_final('pool3', net): return end_points
net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv4')
if add_and_check_is_final('conv4', net): return end_points
net = pooling_fn(net, [2, 2], scope='pool4')
if add_and_check_is_final('pool4', net): return end_points
net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv5')
if add_and_check_is_final('conv5', net): return end_points
net = pooling_fn(net, [2, 2], scope='pool5')
if add_and_check_is_final('pool5', net): return end_points
# Use conv2d instead of fully_connected layers.
net = slim.conv2d(net, 4096, [7, 7], padding='VALID', scope='fc6')
if add_and_check_is_final('fc6', net): return end_points
net = slim.dropout(net, 0.5, is_training=False, scope='dropout6')
net = slim.conv2d(net, 4096, [1, 1], scope='fc7')
if add_and_check_is_final('fc7', net): return end_points
net = slim.dropout(net, 0.5, is_training=False, scope='dropout7')
net = slim.conv2d(net,
1000, [1, 1],
activation_fn=None,
scope='fc8')
end_points[sc.name + '/predictions'] = slim.softmax(net)
if add_and_check_is_final('fc8', net): return end_points
raise ValueError('final_endpoint (%s) not recognized' % final_endpoint)