num_classes=1000,

num_blocks=[3, 4, 6, 3], # defaults to 50-layer network

use_bias=False, # defaults to using batch norm

bottleneck=True):

c = Config()

c['bottleneck'] = bottleneck

c['is_training'] = tf.convert_to_tensor(is_training,

dtype='bool',

name='is_training')

c['ksize'] = 3

c['stride'] = 1

c['use_bias'] = use_bias

c['fc_units_out'] = num_classes

c['num_blocks'] = num_blocks

c['stack_stride'] = 2

with tf.variable_scope('scale1'):

c['conv_filters_out'] = 64

c['ksize'] = 7

c['stride'] = 2

x = conv(x, c)

x = bn(x, c)

x = activation(x)

with tf.variable_scope('scale2'):

x = _max_pool(x, ksize=3, stride=2)

c['num_blocks'] = num_blocks[0]

c['stack_stride'] = 1

c['block_filters_internal'] = 64

x = stack(x, c)

with tf.variable_scope('scale3'):

c['num_blocks'] = num_blocks[1]

c['block_filters_internal'] = 128

assert c['stack_stride'] == 2

x = stack(x, c)

with tf.variable_scope('scale4'):

c['num_blocks'] = num_blocks[2]

c['block_filters_internal'] = 256

x = stack(x, c)

with tf.variable_scope('scale5'):

c['num_blocks'] = num_blocks[3]

c['block_filters_internal'] = 512

x = stack(x, c)

# post-net

x = tf.reduce_mean(x, reduction_indices=[1, 2], name="avg_pool")

if num_classes != None:

with tf.variable_scope('fc'):

x = fc(x, c)

is_training,

num_blocks=3, # 6n+2 total weight layers will be used.

use_bias=False, # defaults to using batch norm

num_classes=10):

c = Config()

c['is_training'] = tf.convert_to_tensor(is_training,

dtype='bool',

name='is_training')

c['use_bias'] = use_bias

c['fc_units_out'] = num_classes

c['num_blocks'] = num_blocks

c['num_classes'] = num_classes

c['bottleneck'] = False

c['ksize'] = 3

c['stride'] = 1

with tf.variable_scope('scale1'):

c['conv_filters_out'] = 16

c['block_filters_internal'] = 16

c['stack_stride'] = 1

x = conv(x, c)

x = bn(x, c)

x = activation(x)

x = stack(x, c)

with tf.variable_scope('scale2'):

c['block_filters_internal'] = 32

c['stack_stride'] = 2

x = stack(x, c)

with tf.variable_scope('scale3'):

c['block_filters_internal'] = 64

c['stack_stride'] = 2

x = stack(x, c)

# post-net

x = tf.reduce_mean(x, reduction_indices=[1, 2], name="avg_pool")

if c['num_classes'] != None:

with tf.variable_scope('fc'):

x = fc(x, c)

"""Changes RGB [0,1] valued image to BGR [0,255] with mean subtracted."""

red, green, blue = tf.split(3, 3, rgb * 255.0)

bgr = tf.concat(3, [blue, green, red])

bgr -= IMAGENET_MEAN_BGR

cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits, labels)

cross_entropy_mean = tf.reduce_mean(cross_entropy)

regularization_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)

loss_ = tf.add_n([cross_entropy_mean] + regularization_losses)

tf.scalar_summary('loss', loss_)

for n in range(c['num_blocks']):

s = c['stack_stride'] if n == 0 else 1

c['block_stride'] = s

with tf.variable_scope('block%d' % (n + 1)):

x = block(x, c)

filters_in = x.get_shape()[-1]

# Note: filters_out isn't how many filters are outputed.

# That is the case when bottleneck=False but when bottleneck is

# True, filters_internal*4 filters are outputted. filters_internal is how many filters

# the 3x3 convs output internally.

m = 4 if c['bottleneck'] else 1

filters_out = m * c['block_filters_internal']

shortcut = x # branch 1

c['conv_filters_out'] = c['block_filters_internal']

if c['bottleneck']:

with tf.variable_scope('a'):

c['ksize'] = 1

c['stride'] = c['block_stride']

x = conv(x, c)

x = bn(x, c)

x = activation(x)

with tf.variable_scope('b'):

x = conv(x, c)

x = bn(x, c)

x = activation(x)

with tf.variable_scope('c'):

c['conv_filters_out'] = filters_out

c['ksize'] = 1

assert c['stride'] == 1

x = conv(x, c)

x = bn(x, c)

else:

with tf.variable_scope('A'):

c['stride'] = c['block_stride']

assert c['ksize'] == 3

x = conv(x, c)

x = bn(x, c)

x = activation(x)

with tf.variable_scope('B'):

c['conv_filters_out'] = filters_out

assert c['ksize'] == 3

assert c['stride'] == 1

x = conv(x, c)

x = bn(x, c)

with tf.variable_scope('shortcut'):

if filters_out != filters_in or c['block_stride'] != 1:

c['ksize'] = 1

c['stride'] = c['block_stride']

c['conv_filters_out'] = filters_out

shortcut = conv(shortcut, c)

shortcut = bn(shortcut, c)

x_shape = x.get_shape()

params_shape = x_shape[-1:]

if c['use_bias']:

bias = _get_variable('bias', params_shape,

initializer=tf.zeros_initializer)

return x + bias

axis = list(range(len(x_shape) - 1))

beta = _get_variable('beta',

params_shape,

initializer=tf.zeros_initializer)

gamma = _get_variable('gamma',

params_shape,

initializer=tf.ones_initializer)

moving_mean = _get_variable('moving_mean',

params_shape,

initializer=tf.zeros_initializer,

trainable=False)

moving_variance = _get_variable('moving_variance',

params_shape,

initializer=tf.ones_initializer,

trainable=False)

# These ops will only be preformed when training.

mean, variance = tf.nn.moments(x, axis)

update_moving_mean = moving_averages.assign_moving_average(moving_mean,

mean, BN_DECAY)

update_moving_variance = moving_averages.assign_moving_average(

moving_variance, variance, BN_DECAY)

tf.add_to_collection(UPDATE_OPS_COLLECTION, update_moving_mean)

tf.add_to_collection(UPDATE_OPS_COLLECTION, update_moving_variance)

mean, variance = control_flow_ops.cond(

c['is_training'], lambda: (mean, variance),

lambda: (moving_mean, moving_variance))

x = tf.nn.batch_normalization(x, mean, variance, beta, gamma, BN_EPSILON)

#x.set_shape(inputs.get_shape()) ??

num_units_in = x.get_shape()[1]

num_units_out = c['fc_units_out']

weights_initializer = tf.truncated_normal_initializer(

stddev=FC_WEIGHT_STDDEV)

weights = _get_variable('weights',

shape=[num_units_in, num_units_out],

initializer=weights_initializer,

weight_decay=FC_WEIGHT_STDDEV)

biases = _get_variable('biases',

shape=[num_units_out],

initializer=tf.zeros_initializer)

x = tf.nn.xw_plus_b(x, weights, biases)

shape,

initializer,

weight_decay=0.0,

dtype='float',

trainable=True):

"A little wrapper around tf.get_variable to do weight decay and add to"

"resnet collection"

if weight_decay > 0:

regularizer = tf.contrib.layers.l2_regularizer(weight_decay)

else:

regularizer = None

collections = [tf.GraphKeys.VARIABLES, RESNET_VARIABLES]

return tf.get_variable(name,

shape=shape,

initializer=initializer,

dtype=dtype,

regularizer=regularizer,

collections=collections,

ksize = c['ksize']

stride = c['stride']

filters_out = c['conv_filters_out']

filters_in = x.get_shape()[-1]

shape = [ksize, ksize, filters_in, filters_out]

initializer = tf.truncated_normal_initializer(stddev=CONV_WEIGHT_STDDEV)

weights = _get_variable('weights',

shape=shape,

dtype='float',

initializer=initializer,

weight_decay=CONV_WEIGHT_DECAY)

return tf.nn.max_pool(x,

ksize=[1, ksize, ksize, 1],

strides=[1, stride, stride, 1],