def testAtrousFullyConvolutionalValues(self): """Verify dense feature extraction with atrous convolution.""" nominal_stride = 32 for output_stride in [4, 8, 16, 32, None]: with arg_scope(resnet_utils.resnet_arg_scope()): with ops.Graph().as_default(): with self.cached_session() as sess: random_seed.set_random_seed(0) inputs = create_test_input(2, 81, 81, 3) # Dense feature extraction followed by subsampling. output, _ = self._resnet_small( inputs, None, is_training=False, global_pool=False, output_stride=output_stride) if output_stride is None: factor = 1 else: factor = nominal_stride // output_stride output = resnet_utils.subsample(output, factor) # Make the two networks use the same weights. variable_scope.get_variable_scope().reuse_variables() # Feature extraction at the nominal network rate. expected, _ = self._resnet_small(inputs, None, is_training=False, global_pool=False) sess.run(variables.global_variables_initializer()) self.assertAllClose(output.eval(), expected.eval(), atol=2e-4, rtol=1e-4)
def testEndPointsV1(self): """Test the end points of a tiny v1 bottleneck network.""" blocks = [ resnet_v1.resnet_v1_block('block1', base_depth=1, num_units=2, stride=2), resnet_v1.resnet_v1_block('block2', base_depth=2, num_units=2, stride=1), ] inputs = create_test_input(2, 32, 16, 3) with arg_scope(resnet_utils.resnet_arg_scope()): _, end_points = self._resnet_plain(inputs, blocks, scope='tiny') expected = [ 'tiny/block1/unit_1/bottleneck_v1/shortcut', 'tiny/block1/unit_1/bottleneck_v1/conv1', 'tiny/block1/unit_1/bottleneck_v1/conv2', 'tiny/block1/unit_1/bottleneck_v1/conv3', 'tiny/block1/unit_2/bottleneck_v1/conv1', 'tiny/block1/unit_2/bottleneck_v1/conv2', 'tiny/block1/unit_2/bottleneck_v1/conv3', 'tiny/block2/unit_1/bottleneck_v1/shortcut', 'tiny/block2/unit_1/bottleneck_v1/conv1', 'tiny/block2/unit_1/bottleneck_v1/conv2', 'tiny/block2/unit_1/bottleneck_v1/conv3', 'tiny/block2/unit_2/bottleneck_v1/conv1', 'tiny/block2/unit_2/bottleneck_v1/conv2', 'tiny/block2/unit_2/bottleneck_v1/conv3' ] self.assertItemsEqual(expected, end_points)
def resnet_inference(inputs, is_train=True): x = tf.reshape(inputs, [FLAGS.batch_size, 64, 64, 1]) with slim.arg_scope(resnet_arg_scope(is_training=(MODE == "train"))): net, enpoints = resnet_v2.resnet_v2_50( x, num_classes=FLAGS.label_size) net = tf.reshape(net, [FLAGS.batch_size, FLAGS.label_size]) return net
def PSPNet(inputs , num_classes, is_training): '''A TensorFlow implementation of PSPNet model based on https://github.com/hszhao/PSPNet/tree/master/evaluation/prototxt Args: inputs: A 4-D tensor with dimensions [batch_size, height, width, channels] num_classes: Integer, the total number of categories in the dataset is_training : Bool, whether to updates the running means and variances during the training. Returns: A score map with dimensions [batch_size, 1/8*height, 1/8*width, num_classes] ''' with slim.arg_scope(resnet_utils.resnet_arg_scope()): net, end_points = resnet_v2.resnet_v2_101(inputs, num_classes=None, is_training=is_training, global_pool=False, output_stride=8, reuse=None, scope='resnet_v2_101') with tf.variable_scope("PSPNet") as sc: shape = tf.shape(net)[1:3] net = PyramidPoolingModule(net, shape = shape) net = slim.conv2d(net, 512, [3, 3], activation_fn=None, scope='conv5') net = slim.batch_norm(net, fused=True, scope='conv5_bn') net = tf.nn.relu(net, name='conv5_bn_relu') logits = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, scope='logits') return logits
def testEndPointsV1(self): """Test the end points of a tiny v1 bottleneck network.""" bottleneck = resnet_v1.bottleneck blocks = [ resnet_utils.Block('block1', bottleneck, [(4, 1, 1), (4, 1, 2)]), resnet_utils.Block('block2', bottleneck, [(8, 2, 1), (8, 2, 1)]) ] inputs = create_test_input(2, 32, 16, 3) with arg_scope(resnet_utils.resnet_arg_scope()): _, end_points = self._resnet_plain(inputs, blocks, scope='tiny') expected = [ 'tiny/block1/unit_1/bottleneck_v1/shortcut', 'tiny/block1/unit_1/bottleneck_v1/shortcut/BatchNorm', 'tiny/block1/unit_1/bottleneck_v1/conv1', 'tiny/block1/unit_1/bottleneck_v1/conv2', 'tiny/block1/unit_1/bottleneck_v1/conv3', 'tiny/block1/unit_1/bottleneck_v1/conv3/BatchNorm', 'tiny/block1/unit_2/bottleneck_v1/conv1', 'tiny/block1/unit_2/bottleneck_v1/conv2', 'tiny/block1/unit_2/bottleneck_v1/conv3', 'tiny/block1/unit_2/bottleneck_v1/conv3/BatchNorm', 'tiny/block2/unit_1/bottleneck_v1/shortcut', 'tiny/block2/unit_1/bottleneck_v1/shortcut/BatchNorm', 'tiny/block2/unit_1/bottleneck_v1/conv1', 'tiny/block2/unit_1/bottleneck_v1/conv2', 'tiny/block2/unit_1/bottleneck_v1/conv3', 'tiny/block2/unit_1/bottleneck_v1/conv3/BatchNorm', 'tiny/block2/unit_2/bottleneck_v1/conv1', 'tiny/block2/unit_2/bottleneck_v1/conv2', 'tiny/block2/unit_2/bottleneck_v1/conv3', 'tiny/block2/unit_2/bottleneck_v1/conv3/BatchNorm' ] self.assertItemsEqual(expected, end_points)
def extract_features(inputs, contexts, is_training): # TODO - Add skip connections between conv-deconv layers with slim.arg_scope(resnet_utils.resnet_arg_scope(is_training=is_training)): conv1 = tf.layers.conv2d(inputs, filters=128, kernel_size=3, strides=1, padding='same') context_layer = expand_context(contexts, height, width) contexted_batch = tf.concat([conv1, context_layer], axis=3) net, end_points = resnet_v2.resnet_v2_101(contexted_batch, None, global_pool=False, output_stride=16) deconv1 = deconv_block(net,num_inputs=2048, num_outputs=1024, is_training=is_training, scope='deconv1') deconv2 = deconv_block(deconv1, num_inputs=1024, num_outputs=512, stride=2, is_training=is_training, scope='deconv2') deconv3 = deconv_block(deconv2, num_inputs=512, num_outputs=256, stride=2, is_training=is_training, scope='deconv3') deconv4 = deconv_block(deconv3, num_inputs=256,num_outputs=128, stride=2, is_training=is_training, scope='deconv4') deconv5 = deconv_block(deconv4, num_inputs=128,num_outputs=64, stride=2, is_training=is_training, scope='deconv5') return deconv5, net
def testEndPointsV2(self): """Test the end points of a tiny v2 bottleneck network.""" blocks = [ resnet_v2.resnet_v2_block( 'block1', base_depth=1, num_units=2, stride=2), resnet_v2.resnet_v2_block( 'block2', base_depth=2, num_units=2, stride=1), ] inputs = create_test_input(2, 32, 16, 3) with arg_scope(resnet_utils.resnet_arg_scope()): _, end_points = self._resnet_plain(inputs, blocks, scope='tiny') expected = [ 'tiny/block1/unit_1/bottleneck_v2/shortcut', 'tiny/block1/unit_1/bottleneck_v2/conv1', 'tiny/block1/unit_1/bottleneck_v2/conv2', 'tiny/block1/unit_1/bottleneck_v2/conv3', 'tiny/block1/unit_2/bottleneck_v2/conv1', 'tiny/block1/unit_2/bottleneck_v2/conv2', 'tiny/block1/unit_2/bottleneck_v2/conv3', 'tiny/block2/unit_1/bottleneck_v2/shortcut', 'tiny/block2/unit_1/bottleneck_v2/conv1', 'tiny/block2/unit_1/bottleneck_v2/conv2', 'tiny/block2/unit_1/bottleneck_v2/conv3', 'tiny/block2/unit_2/bottleneck_v2/conv1', 'tiny/block2/unit_2/bottleneck_v2/conv2', 'tiny/block2/unit_2/bottleneck_v2/conv3' ] self.assertItemsEqual(expected, end_points)
def _encoder(self, input_images, scope_name = "encoder", trainable = True, scope_reuse = False): with arg_scope(resnet_utils.resnet_arg_scope()): output, end_points = resnet_v2.resnet_v2_50(input_images, output_stride=8, global_pool=False,reuse=scope_reuse)#(256, 256, 2048)==>(32, 32, 2048) hidden_state = decoder_layer(output, out_channels = self.lstm_channel, stride = 1, scope_name = 'encoder_layer1', trainable = trainable)#(32, 32, 2048)==>(32, 32, 512) print hidden_state.get_shape() tf.summary.histogram(hidden_state.op.name + "/activation", hidden_state) return hidden_state
def testAtrousFullyConvolutionalValues(self): """Verify dense feature extraction with atrous convolution.""" nominal_stride = 32 for output_stride in [4, 8, 16, 32, None]: with arg_scope(resnet_utils.resnet_arg_scope()): with ops.Graph().as_default(): with self.test_session() as sess: random_seed.set_random_seed(0) inputs = create_test_input(2, 81, 81, 3) # Dense feature extraction followed by subsampling. output, _ = self._resnet_small( inputs, None, is_training=False, global_pool=False, output_stride=output_stride) if output_stride is None: factor = 1 else: factor = nominal_stride // output_stride output = resnet_utils.subsample(output, factor) # Make the two networks use the same weights. variable_scope.get_variable_scope().reuse_variables() # Feature extraction at the nominal network rate. expected, _ = self._resnet_small( inputs, None, is_training=False, global_pool=False) sess.run(variables.global_variables_initializer()) self.assertAllClose( output.eval(), expected.eval(), atol=1e-4, rtol=1e-4)
def Deeplab_v2(inputs , num_classes, is_training): '''A TensorFlow implementation of Deeplab_v2 model based on http://liangchiehchen.com/projects/DeepLabv2_resnet.html Args: inputs: A 4-D tensor with dimensions [batch_size, height, width, channels] num_classes: Integer, the total number of categories in the dataset is_training : Bool, whether to updates the running means and variances during the training. Returns: A score map with dimensions [batch_size, 1/8*height, 1/8*width, num_classes] ''' with slim.arg_scope(resnet_utils.resnet_arg_scope()) as sc: net, _ = resnet_v2.resnet_v2_101(inputs, num_classes=None, is_training=is_training, global_pool=False, output_stride=8, reuse=None, scope='resnet_v2_101') # ASPP module without BN layers with tf.variable_scope('Deeplab_v2'): pool6 = slim.conv2d(net, num_classes, [3,3], rate=6, activation_fn=None, scope='pool6') pool12 = slim.conv2d(net, num_classes, [3,3], rate=12, activation_fn=None, scope='pool12') pool18 = slim.conv2d(net, num_classes, [3,3], rate=18, activation_fn=None, scope='pool18') pool24 = slim.conv2d(net, num_classes, [3,3], rate=24, activation_fn=None, scope='pool24') logits = tf.add_n([pool6, pool12, pool18, pool24], name='logits') return logits
def testEndPointsV2(self): """Test the end points of a tiny v2 bottleneck network.""" bottleneck = resnet_v2.bottleneck blocks = [ resnet_utils.Block('block1', bottleneck, [(4, 1, 1), (4, 1, 2)]), resnet_utils.Block('block2', bottleneck, [(8, 2, 1), (8, 2, 1)]) ] inputs = create_test_input(2, 32, 16, 3) with arg_scope(resnet_utils.resnet_arg_scope()): _, end_points = self._resnet_plain(inputs, blocks, scope='tiny') expected = [ 'tiny/block1/unit_1/bottleneck_v2/shortcut', 'tiny/block1/unit_1/bottleneck_v2/conv1', 'tiny/block1/unit_1/bottleneck_v2/conv2', 'tiny/block1/unit_1/bottleneck_v2/conv3', 'tiny/block1/unit_2/bottleneck_v2/conv1', 'tiny/block1/unit_2/bottleneck_v2/conv2', 'tiny/block1/unit_2/bottleneck_v2/conv3', 'tiny/block2/unit_1/bottleneck_v2/shortcut', 'tiny/block2/unit_1/bottleneck_v2/conv1', 'tiny/block2/unit_1/bottleneck_v2/conv2', 'tiny/block2/unit_1/bottleneck_v2/conv3', 'tiny/block2/unit_2/bottleneck_v2/conv1', 'tiny/block2/unit_2/bottleneck_v2/conv2', 'tiny/block2/unit_2/bottleneck_v2/conv3' ] self.assertItemsEqual(expected, end_points)
def testClassificationEndPoints(self): global_pool = True num_classes = 10 inputs = create_test_input(2, 224, 224, 3) with arg_scope(resnet_utils.resnet_arg_scope()): logits, end_points = self._resnet_small( inputs, num_classes, global_pool, scope='resnet') self.assertTrue(logits.op.name.startswith('resnet/logits')) self.assertListEqual(logits.get_shape().as_list(), [2, 1, 1, num_classes]) self.assertTrue('predictions' in end_points) self.assertListEqual(end_points['predictions'].get_shape().as_list(), [2, 1, 1, num_classes])
def testClassificationEndPoints(self): global_pool = True num_classes = 10 inputs = create_test_input(2, 224, 224, 3) with arg_scope(resnet_utils.resnet_arg_scope()): logits, end_points = self._resnet_small( inputs, num_classes, global_pool=global_pool, scope='resnet') self.assertTrue(logits.op.name.startswith('resnet/logits')) self.assertListEqual(logits.get_shape().as_list(), [2, 1, 1, num_classes]) self.assertTrue('predictions' in end_points) self.assertListEqual(end_points['predictions'].get_shape().as_list(), [2, 1, 1, num_classes])
def testFullyConvolutionalUnknownHeightWidth(self): batch = 2 height, width = 65, 65 global_pool = False inputs = create_test_input(batch, None, None, 3) with arg_scope(resnet_utils.resnet_arg_scope()): output, _ = self._resnet_small(inputs, None, global_pool) self.assertListEqual(output.get_shape().as_list(), [batch, None, None, 32]) images = create_test_input(batch, height, width, 3) with self.test_session() as sess: sess.run(variables.global_variables_initializer()) output = sess.run(output, {inputs: images.eval()}) self.assertEqual(output.shape, (batch, 3, 3, 32))
def testFullyConvolutionalUnknownHeightWidth(self): batch = 2 height, width = 65, 65 global_pool = False inputs = create_test_input(batch, None, None, 3) with arg_scope(resnet_utils.resnet_arg_scope()): output, _ = self._resnet_small(inputs, None, global_pool=global_pool) self.assertListEqual(output.get_shape().as_list(), [batch, None, None, 32]) images = create_test_input(batch, height, width, 3) with self.test_session() as sess: sess.run(variables.global_variables_initializer()) output = sess.run(output, {inputs: images.eval()}) self.assertEqual(output.shape, (batch, 3, 3, 32))
def create_resnet(image_input, is_training, scope="", resnet_out="block4", resnet_version=50, cbn=None): """ Create a resnet by overidding the classic batchnorm with conditional batchnorm :param image_input: placeholder with image :param is_training: are you using the resnet at training_time or test_time :param scope: tensorflow scope :param resnet_version: 50/101/152 :param cbn: the cbn factory :return: the resnet output """ if cbn is None: # assert False, "\n" \ # "There is a bug with classic batchnorm with slim networks (https://github.com/tensorflow/tensorflow/issues/4887). \n" \ # "Please use the following config -> 'cbn': {'use_cbn':true, 'excluded_scope_names': ['*']}" arg_sc = slim_utils.resnet_arg_scope(is_training=is_training) else: arg_sc = get_resnet_arg_scope(cbn.apply) # Pick the correct version of the resnet if resnet_version == 50: current_resnet = resnet_v1.resnet_v1_50 elif resnet_version == 101: current_resnet = resnet_v1.resnet_v1_101 elif resnet_version == 152: current_resnet = resnet_v1.resnet_v1_152 else: raise ValueError("Unsupported resnet version") resnet_scope = os.path.join('resnet_v1_{}/'.format(resnet_version), resnet_out) with slim.arg_scope(arg_sc): net, end_points = current_resnet( image_input, 1000) # 1000 is the number of softmax class if len(scope) > 0 and not scope.endswith("/"): scope += "/" print("Use: {}".format(resnet_scope)) out = end_points[scope + resnet_scope] return out
def testFullyConvolutionalEndpointShapes(self): global_pool = False num_classes = 10 inputs = create_test_input(2, 321, 321, 3) with arg_scope(resnet_utils.resnet_arg_scope()): _, end_points = self._resnet_small( inputs, num_classes, global_pool=global_pool, scope='resnet') endpoint_to_shape = { 'resnet/block1': [2, 41, 41, 4], 'resnet/block2': [2, 21, 21, 8], 'resnet/block3': [2, 11, 11, 16], 'resnet/block4': [2, 11, 11, 32] } for endpoint in endpoint_to_shape: shape = endpoint_to_shape[endpoint] self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)
def testClassificationShapes(self): global_pool = True num_classes = 10 inputs = create_test_input(2, 224, 224, 3) with arg_scope(resnet_utils.resnet_arg_scope()): _, end_points = self._resnet_small( inputs, num_classes, global_pool=global_pool, scope='resnet') endpoint_to_shape = { 'resnet/block1': [2, 28, 28, 4], 'resnet/block2': [2, 14, 14, 8], 'resnet/block3': [2, 7, 7, 16], 'resnet/block4': [2, 7, 7, 32] } for endpoint in endpoint_to_shape: shape = endpoint_to_shape[endpoint] self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)
def testFullyConvolutionalEndpointShapes(self): global_pool = False num_classes = 10 inputs = create_test_input(2, 321, 321, 3) with arg_scope(resnet_utils.resnet_arg_scope()): _, end_points = self._resnet_small( inputs, num_classes, global_pool, scope='resnet') endpoint_to_shape = { 'resnet/block1': [2, 41, 41, 4], 'resnet/block2': [2, 21, 21, 8], 'resnet/block3': [2, 11, 11, 16], 'resnet/block4': [2, 11, 11, 32] } for endpoint in endpoint_to_shape: shape = endpoint_to_shape[endpoint] self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)
def testClassificationShapes(self): global_pool = True num_classes = 10 inputs = create_test_input(2, 224, 224, 3) with arg_scope(resnet_utils.resnet_arg_scope()): _, end_points = self._resnet_small( inputs, num_classes, global_pool, scope='resnet') endpoint_to_shape = { 'resnet/block1': [2, 28, 28, 4], 'resnet/block2': [2, 14, 14, 8], 'resnet/block3': [2, 7, 7, 16], 'resnet/block4': [2, 7, 7, 32] } for endpoint in endpoint_to_shape: shape = endpoint_to_shape[endpoint] self.assertListEqual(end_points[endpoint].get_shape().as_list(), shape)
def 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_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), ] nominal_stride = 8 # Test both odd and even input dimensions. height = 30 width = 31 with arg_scope(resnet_utils.resnet_arg_scope()): with arg_scope([layers.batch_norm], is_training=False): for output_stride in [1, 2, 4, 8, None]: with ops.Graph().as_default(): with self.cached_session() as sess: random_seed.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. variable_scope.get_variable_scope( ).reuse_variables() # Feature extraction at the nominal network rate. expected = self._stack_blocks_nondense( inputs, blocks) sess.run(variables.global_variables_initializer()) output, expected = sess.run([output, expected]) self.assertAllClose(output, expected, atol=1e-4, rtol=1e-4)
def create_resnet(image_input, is_training, scope="", resnet_out="block4", resnet_version=50, cbn=None): """ Create a resnet by overidding the classic batchnorm with conditional batchnorm :param image_input: placeholder with image :param is_training: are you using the resnet at training_time or test_time :param scope: tensorflow scope :param resnet_version: 50/101/152 :param cbn: the cbn factory :return: the resnet output """ if cbn is None: arg_sc = slim_utils.resnet_arg_scope() else: arg_sc = get_resnet_arg_scope(cbn.apply) # Pick the correct version of the resnet if resnet_version == 50: current_resnet = resnet_v1.resnet_v1_50 elif resnet_version == 101: current_resnet = resnet_v1.resnet_v1_101 elif resnet_version == 152: current_resnet = resnet_v1.resnet_v1_152 else: raise ValueError("Unsupported resnet version") resnet_scope = os.path.join('resnet_v1_{}/'.format(resnet_version), resnet_out) with slim.arg_scope(arg_sc): net, end_points = current_resnet( image_input, 1000, is_training=is_training) # 1000 is the number of softmax class if len(scope) > 0 and not scope.endswith("/"): scope += "/" print("Use: {}".format(resnet_scope)) out = end_points[scope + resnet_scope] return out
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 arg_scope(resnet_utils.resnet_arg_scope(is_training=False)): for output_stride in [1, 2, 4, 8, None]: with ops.Graph().as_default(): with self.test_session() as sess: random_seed.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. variable_scope.get_variable_scope().reuse_variables() # Feature extraction at the nominal network rate. expected = self._stack_blocks_nondense(inputs, blocks) sess.run(variables.global_variables_initializer()) output, expected = sess.run([output, expected]) self.assertAllClose(output, expected, atol=1e-4, rtol=1e-4)
def testUnknownBatchSize(self): batch = 2 height, width = 65, 65 global_pool = True num_classes = 10 inputs = create_test_input(None, height, width, 3) with arg_scope(resnet_utils.resnet_arg_scope()): logits, _ = self._resnet_small( inputs, num_classes, global_pool, scope='resnet') self.assertTrue(logits.op.name.startswith('resnet/logits')) self.assertListEqual(logits.get_shape().as_list(), [None, 1, 1, num_classes]) images = create_test_input(batch, height, width, 3) with self.test_session() as sess: sess.run(variables.global_variables_initializer()) output = sess.run(logits, {inputs: images.eval()}) self.assertEqual(output.shape, (batch, 1, 1, num_classes))
def slim_resnet_v2_50(net_in, num_classes=1000, weight_decay=0.0001, is_training=False, reuse=None): net_in = tl.layers.InputLayer(net_in, name='input_layer') with slim.arg_scope( resnet_arg_scope(is_training=is_training, weight_decay=weight_decay)): network = tl.layers.SlimNetsLayer( layer=net_in, slim_layer=resnet_v2_50, slim_args={ 'num_classes': num_classes, }, name='resnet_v2_50') # same with the ckpt mode return network
def testUnknownBatchSize(self): batch = 2 height, width = 65, 65 global_pool = True num_classes = 10 inputs = create_test_input(None, height, width, 3) with arg_scope(resnet_utils.resnet_arg_scope()): logits, _ = self._resnet_small( inputs, num_classes, global_pool=global_pool, scope='resnet') self.assertTrue(logits.op.name.startswith('resnet/logits')) self.assertListEqual(logits.get_shape().as_list(), [None, 1, 1, num_classes]) images = create_test_input(batch, height, width, 3) with self.test_session() as sess: sess.run(variables.global_variables_initializer()) output = sess.run(logits, {inputs: images.eval()}) self.assertEqual(output.shape, (batch, 1, 1, num_classes))
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 arg_scope(resnet_utils.resnet_arg_scope(is_training=False)): for output_stride in [1, 2, 4, 8, None]: with ops.Graph().as_default(): with self.test_session() as sess: random_seed.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. variable_scope.get_variable_scope().reuse_variables() # Feature extraction at the nominal network rate. expected = self._stack_blocks_nondense(inputs, blocks) sess.run(variables.global_variables_initializer()) output, expected = sess.run([output, expected]) self.assertAllClose(output, expected, atol=1e-4, rtol=1e-4)
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 arg_scope(resnet_utils.resnet_arg_scope()): with arg_scope([layers.batch_norm], is_training=False): for output_stride in [1, 2, 4, 8, None]: with ops.Graph().as_default(): with self.test_session() as sess: random_seed.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. variable_scope.get_variable_scope().reuse_variables() # Feature extraction at the nominal network rate. expected = self._stack_blocks_nondense(inputs, blocks) sess.run(variables.global_variables_initializer()) output, expected = sess.run([output, expected]) self.assertAllClose(output, expected, atol=1e-4, rtol=1e-4)
assert False, "Invalid mode: {}".format(args.mode) # Define the output folder out_file = "gw_{mode}_{network}_{feature_name}_{size}".format( mode=args.mode, network=args.network, feature_name=args.feature_name, size=args.img_size) print("Create networks...") if args.network == "resnet": ft_output = resnet.create_resnet(images, resnet_out=args.feature_name, resnet_version=args.resnet_version, is_training=False) # create network with slim.arg_scope(slim_utils.resnet_arg_scope(is_training=False)): _, end_points = resnet_v1.resnet_v1_152(images, 1000) # 1000 is the number of softmax class elif args.network == "vgg": _, end_points = vgg.vgg_16(images, is_training=False, dropout_keep_prob=1.0) ft_name = os.path.join("vgg_16", args.feature_name) ft_output = end_points[ft_name] else: assert False, "Incorrect Network" extract_features( img_input = images, ft_output = ft_output, dataset_cstor = dataset_cstor,
def GCN(inputs, num_classes, is_training): '''A TensorFlow implementation of GCN model based on "Large Kernel Matters -- Improve Semantic Segmentation by Global Convolutional Network" Args: inputs: A 4-D tensor with dimensions [batch_size, height, width, channels] num_classes: Integer, the total number of categories in the dataset is_training : Bool, whether to updates the running means and variances during the training. Returns: A score map with dimensions [batch_size, height, width, num_classes] ''' with slim.arg_scope(resnet_utils.resnet_arg_scope()): net, end_points = resnet_v2.resnet_v2_101(inputs, num_classes=None, is_training=is_training, global_pool=False, output_stride=None, reuse=None, scope='resnet_v2_101') block1 = end_points[ "resnet_v2_101/block1/unit_2/bottleneck_v2"] # (56, 56, 256) block2 = end_points[ "resnet_v2_101/block2/unit_3/bottleneck_v2"] # (28, 28, 512) block3 = end_points[ "resnet_v2_101/block3/unit_22/bottleneck_v2"] # (14, 14, 1024) block4 = net # (7, 7, 2048) with tf.variable_scope("gcn") as sc: down5 = GlobalConvBlock(block4, num_classes=num_classes) down5 = BoundaryRefinementBlock(down5, num_classes=num_classes, kernel_size=[3, 3]) down5 = slim.conv2d_transpose(down5, num_classes, kernel_size=[4, 4], stride=2, activation_fn=None) # (14, 14, 21) down4 = GlobalConvBlock(block3, num_classes=num_classes) down4 = BoundaryRefinementBlock(down4, num_classes=num_classes, kernel_size=[3, 3]) down4 = tf.add(down4, down5) down4 = BoundaryRefinementBlock(down4, num_classes=num_classes, kernel_size=[3, 3]) down4 = slim.conv2d_transpose(down4, num_classes, kernel_size=[4, 4], stride=2, activation_fn=None) # (28, 28, 21) down3 = GlobalConvBlock(block2, num_classes=num_classes) down3 = BoundaryRefinementBlock(down3, num_classes=num_classes, kernel_size=[3, 3]) down3 = tf.add(down3, down4) down3 = BoundaryRefinementBlock(down3, num_classes=num_classes, kernel_size=[3, 3]) down3 = slim.conv2d_transpose(down3, num_classes, kernel_size=[4, 4], stride=2, activation_fn=None) # (56, 56, 21) down2 = GlobalConvBlock(block1, num_classes=num_classes) down2 = BoundaryRefinementBlock(down2, num_classes=num_classes, kernel_size=[3, 3]) down2 = tf.add(down2, down3) down2 = BoundaryRefinementBlock(down2, num_classes=num_classes, kernel_size=[3, 3]) down2 = slim.conv2d_transpose(down2, num_classes, kernel_size=[4, 4], stride=2, activation_fn=None) # (112, 112, 21) output = BoundaryRefinementBlock(down2, num_classes=num_classes, kernel_size=[3, 3]) output = slim.conv2d_transpose(output, num_classes, kernel_size=[4, 4], stride=2, activation_fn=None) # (224, 224, 21) output = BoundaryRefinementBlock(output, num_classes=num_classes, kernel_size=[3, 3]) return output
def create_resnet(image_input, is_training, scope="", scope_feature="", resnet_out="logits", resnet_version=50, cbn=None): """ Create a resnet by overidding the classic batchnorm with conditional batchnorm :param image_input: placeholder with image :param is_training: are you using the resnet at training_time or test_time :param scope: tensorflow scope :param resnet_version: 50/101/152 :param cbn: the cbn factory :return: the resnet output """ # print("resnet_out = {}".format(resnet_out)) if cbn is None: # assert False, "\n" \ # "There is a bug with classic batchnorm with slim networks (https://github.com/tensorflow/tensorflow/issues/4887). \n" \ # "Please use the following config -> 'cbn': {'use_cbn':true, 'excluded_scope_names': ['*']}" # arg_sc = slim_utils.resnet_arg_scope(is_training=is_training) arg_sc = slim_utils.resnet_arg_scope() # print("arg_sc = {}".format(arg_sc)) else: arg_sc = get_resnet_arg_scope(cbn.apply) # Pick the correct version of the resnet if resnet_version == 50: print("------ 50") current_resnet = resnet_v1.resnet_v1_50 elif resnet_version == 101: print("------ 101") current_resnet = resnet_v1.resnet_v1_101 elif resnet_version == 152: print("------ 152") current_resnet = resnet_v1.resnet_v1_152 else: raise ValueError("Unsupported resnet version") resnet_scope = os.path.join('resnet_v1_{}/'.format(resnet_version), resnet_out) # print(" resnet_out = {} , resnet_scope = {}".format(resnet_out,resnet_scope)) # exit() # print("current_resnet = {}".format(current_resnet)) # exit() with slim.arg_scope(arg_sc): net, end_points = current_resnet( image_input, 1000, scope="resnet_v1_50") # 1000 is the number of softmax class print("net = {}, end_points = {}".format(net, end_points)) # print(" resnet | endpoint=",end_points) if len(scope) > 0 and not scope.endswith("/"): scope += "/" out = end_points[ scope + resnet_scope] # Tensor("oracle/resnet_v1_50/block4/unit_3/bottleneck_v1/Relu:0", shape=(32, 7, 7, 2048), dtype=float32) # print("------------------------- out Use: {},output = {}".format(resnet_scope,out)) # out = tf.reshape( # out, # [-1,out.shape[3]], # ) # print("-- net = {}, end_points={},out={} ".format(net,end_points,out)) # exit() return out, end_points
def arg_scope(self, weight_decay=0.0005, is_training=None): return resnet_utils.resnet_arg_scope(weight_decay=weight_decay, is_training=None)
def _testDeprecatingIsTraining(self, network_fn): batch_norm_fn = layers.batch_norm @add_arg_scope def batch_norm_expect_is_training(*args, **kwargs): assert kwargs['is_training'] return batch_norm_fn(*args, **kwargs) @add_arg_scope def batch_norm_expect_is_not_training(*args, **kwargs): assert not kwargs['is_training'] return batch_norm_fn(*args, **kwargs) global_pool = True num_classes = 10 inputs = create_test_input(2, 224, 224, 3) # Default argument for resnet_arg_scope layers.batch_norm = batch_norm_expect_is_training with arg_scope(resnet_utils.resnet_arg_scope()): network_fn(inputs, num_classes, global_pool=global_pool, scope='resnet1') layers.batch_norm = batch_norm_expect_is_training with arg_scope(resnet_utils.resnet_arg_scope()): network_fn(inputs, num_classes, is_training=True, global_pool=global_pool, scope='resnet2') layers.batch_norm = batch_norm_expect_is_not_training with arg_scope(resnet_utils.resnet_arg_scope()): network_fn(inputs, num_classes, is_training=False, global_pool=global_pool, scope='resnet3') # resnet_arg_scope with is_training set to True (deprecated) layers.batch_norm = batch_norm_expect_is_training with arg_scope(resnet_utils.resnet_arg_scope(is_training=True)): network_fn(inputs, num_classes, global_pool=global_pool, scope='resnet4') layers.batch_norm = batch_norm_expect_is_training with arg_scope(resnet_utils.resnet_arg_scope(is_training=True)): network_fn(inputs, num_classes, is_training=True, global_pool=global_pool, scope='resnet5') layers.batch_norm = batch_norm_expect_is_not_training with arg_scope(resnet_utils.resnet_arg_scope(is_training=True)): network_fn(inputs, num_classes, is_training=False, global_pool=global_pool, scope='resnet6') # resnet_arg_scope with is_training set to False (deprecated) layers.batch_norm = batch_norm_expect_is_not_training with arg_scope(resnet_utils.resnet_arg_scope(is_training=False)): network_fn(inputs, num_classes, global_pool=global_pool, scope='resnet7') layers.batch_norm = batch_norm_expect_is_training with arg_scope(resnet_utils.resnet_arg_scope(is_training=False)): network_fn(inputs, num_classes, is_training=True, global_pool=global_pool, scope='resnet8') layers.batch_norm = batch_norm_expect_is_not_training with arg_scope(resnet_utils.resnet_arg_scope(is_training=False)): network_fn(inputs, num_classes, is_training=False, global_pool=global_pool, scope='resnet9') layers.batch_norm = batch_norm_fn
def _testDeprecatingIsTraining(self, network_fn): batch_norm_fn = layers.batch_norm @add_arg_scope def batch_norm_expect_is_training(*args, **kwargs): assert kwargs['is_training'] return batch_norm_fn(*args, **kwargs) @add_arg_scope def batch_norm_expect_is_not_training(*args, **kwargs): assert not kwargs['is_training'] return batch_norm_fn(*args, **kwargs) global_pool = True num_classes = 10 inputs = create_test_input(2, 224, 224, 3) # Default argument for resnet_arg_scope layers.batch_norm = batch_norm_expect_is_training with arg_scope(resnet_utils.resnet_arg_scope()): network_fn(inputs, num_classes, global_pool=global_pool, scope='resnet1') layers.batch_norm = batch_norm_expect_is_training with arg_scope(resnet_utils.resnet_arg_scope()): network_fn( inputs, num_classes, is_training=True, global_pool=global_pool, scope='resnet2') layers.batch_norm = batch_norm_expect_is_not_training with arg_scope(resnet_utils.resnet_arg_scope()): network_fn( inputs, num_classes, is_training=False, global_pool=global_pool, scope='resnet3') # resnet_arg_scope with is_training set to True (deprecated) layers.batch_norm = batch_norm_expect_is_training with arg_scope(resnet_utils.resnet_arg_scope(is_training=True)): network_fn(inputs, num_classes, global_pool=global_pool, scope='resnet4') layers.batch_norm = batch_norm_expect_is_training with arg_scope(resnet_utils.resnet_arg_scope(is_training=True)): network_fn( inputs, num_classes, is_training=True, global_pool=global_pool, scope='resnet5') layers.batch_norm = batch_norm_expect_is_not_training with arg_scope(resnet_utils.resnet_arg_scope(is_training=True)): network_fn( inputs, num_classes, is_training=False, global_pool=global_pool, scope='resnet6') # resnet_arg_scope with is_training set to False (deprecated) layers.batch_norm = batch_norm_expect_is_not_training with arg_scope(resnet_utils.resnet_arg_scope(is_training=False)): network_fn(inputs, num_classes, global_pool=global_pool, scope='resnet7') layers.batch_norm = batch_norm_expect_is_training with arg_scope(resnet_utils.resnet_arg_scope(is_training=False)): network_fn( inputs, num_classes, is_training=True, global_pool=global_pool, scope='resnet8') layers.batch_norm = batch_norm_expect_is_not_training with arg_scope(resnet_utils.resnet_arg_scope(is_training=False)): network_fn( inputs, num_classes, is_training=False, global_pool=global_pool, scope='resnet9') layers.batch_norm = batch_norm_fn
x = tf.placeholder(tf.float32, shape=[batch_size, height, width, 6]) y_ = tf.placeholder(tf.float32, shape=[batch_size, height, width, 1]) network = tl.layers.InputLayer(x, name='input') network = tl.layers.Conv2d(network, 16, (3, 3), (1, 1), act=tf.nn.relu, padding='VALID', name='conv1') network = tl.layers.Conv2d(network, 16, (3, 3), (1, 1), act=tf.nn.relu, padding='VALID', name='conv2') network = tl.layers.Conv2d(network, 32, (3, 3), (1, 1), act=tf.nn.relu, padding='VALID', name='conv3') network = tl.layers.MaxPool2d(network, (2, 2), (2, 2), padding='VALID', name='pool1') network = tl.layers.Conv2d(network, 32, (3, 3), (1, 1), act=tf.nn.relu, padding='VALID', name='conv4') network = tl.layers.Conv2d(network, 32, (3, 3), (1, 1), act=tf.nn.relu, padding='VALID', name='conv5') network = tl.layers.Conv2dLayer(network, shape = [1, 1, 32, 3], act=tf.nn.relu, name='conv6', padding='VALID') network = tl.layers.MaxPool2d(network, (2, 2), (2, 2), padding='VALID', name='pool2') with slim.arg_scope(resnet_arg_scope()): network = tl.layers.SlimNetsLayer(layer=network, slim_layer=resnet_v2_50, slim_args={'num_classes':None, 'is_training':True, 'global_pool':False, 'output_stride':16, # 'inputs' : [batch_size, 299, 299, 3], }, name='resnet_v2_50' # <-- the name should be the same with the ckpt model ) # network = tl.layers.MaxPool2d(network, (1, 1), (1, 1), padding='SAME', name='pool3') network.print_layers() network = tf.layers.