def forward(self, x): with tf.variable_scope(self.Gscope): h = self.downSampling1(x) with tf.variable_scope("downSampling1_norm") as self.Gscope: h = instance_norm(h, scale=False, epsilon=1e-5) h = tf.nn.relu(h) h = self.downSampling2(h) with tf.variable_scope("downSampling2_norm") as self.Gscope: h = instance_norm(h, scale=False, epsilon=1e-5) h = tf.nn.relu(h) h = self.downSampling3(h) with tf.variable_scope("downSampling3_norm") as self.Gscope: h = instance_norm(h, scale=False, epsilon=1e-5) h = tf.nn.relu(h) h = self.residualBlock1.forward(h) h = self.residualBlock2.forward(h) h = self.residualBlock3.forward(h) h = self.residualBlock4.forward(h) h = self.residualBlock5.forward(h) h = self.residualBlock6.forward(h) h = self.Y_upSampling1(h) with tf.variable_scope("Y_upSampling1_norm") as self.Gscope: h = instance_norm(h, scale=True, epsilon=1e-5) h = tf.nn.relu(h) h = self.Y_upSampling2(h) with tf.variable_scope("Y_upSampling2_norm") as self.Gscope: h = instance_norm(h, scale=True, epsilon=1e-5) h = tf.nn.relu(h) return self.fakeGeneration(h)
def testCreateVariables(self): height, width = 3, 3 images = random_ops.random_uniform((5, height, width, 3), seed=1) normalization.instance_norm(images, center=True, scale=True) beta = contrib_variables.get_variables_by_name('beta')[0] gamma = contrib_variables.get_variables_by_name('gamma')[0] self.assertEqual('InstanceNorm/beta', beta.op.name) self.assertEqual('InstanceNorm/gamma', gamma.op.name)
def testReuseVariables(self): height, width = 3, 3 images = random_ops.random_uniform((5, height, width, 3), seed=1) normalization.instance_norm(images, scale=True, scope='IN') normalization.instance_norm(images, scale=True, scope='IN', reuse=True) beta = contrib_variables.get_variables_by_name('beta') gamma = contrib_variables.get_variables_by_name('gamma') self.assertEqual(1, len(beta)) self.assertEqual(1, len(gamma))
def forward(self, x): h = self.Y1(x) with tf.variable_scope("Generator/ResBlock" + str(self.num) + "1"): h = instance_norm(h, scale=False, epsilon=1e-5) h = tf.nn.relu(h) h = self.Y2(h) with tf.variable_scope("Generator/ResBlock" + str(self.num) + "2"): h = instance_norm(h, scale=False, epsilon=1e-5) return x + h
def testValueCorrectWithReuseVars(self): height, width = 3, 3 image_shape = (10, height, width, 3) images = random_ops.random_uniform(image_shape, seed=1) output_train = normalization.instance_norm(images, scope='IN') output_eval = normalization.instance_norm(images, scope='IN', reuse=True) with self.test_session() as sess: sess.run(variables.global_variables_initializer()) # output_train and output_eval should be the same. train_np, eval_np = sess.run([output_train, output_eval]) self.assertAllClose(train_np, eval_np)
def doOutputTest(self, input_shape, data_format, tol=1e-3): axis = -1 if data_format == 'NHWC' else 1 for mu in (0.0, 1e2): for sigma in (1.0, 0.1): # Determine shape of Tensor after normalization. reduced_shape = (input_shape[0], input_shape[axis]) expected_mean = np.zeros(reduced_shape) expected_var = np.ones(reduced_shape) # Determine axes that will be normalized. reduced_axes = list(range(len(input_shape))) del reduced_axes[axis] del reduced_axes[0] reduced_axes = tuple(reduced_axes) inputs = random_ops.random_uniform(input_shape, seed=0) * sigma + mu output_op = normalization.instance_norm( inputs, center=False, scale=False, data_format=data_format) with self.test_session() as sess: sess.run(variables.global_variables_initializer()) outputs = sess.run(output_op) # Make sure that there are no NaNs self.assertFalse(np.isnan(outputs).any()) mean = np.mean(outputs, axis=reduced_axes) var = np.var(outputs, axis=reduced_axes) # The mean and variance of each example should be close to 0 and 1 # respectively. self.assertAllClose(expected_mean, mean, rtol=tol, atol=tol) self.assertAllClose(expected_var, var, rtol=tol, atol=tol)
def testCreateOp(self): height, width = 3, 3 images = random_ops.random_uniform((5, height, width, 3), seed=1) output = normalization.instance_norm(images) print('name: ', output.op.name) self.assertStartsWith(output.op.name, 'InstanceNorm/instancenorm') self.assertListEqual([5, height, width, 3], output.shape.as_list())
def testCreateOpFloat64(self): height, width = 3, 3 images = random_ops.random_uniform( (5, height, width, 3), dtype=dtypes.float64, seed=1) output = normalization.instance_norm(images) self.assertStartsWith( output.op.name, 'InstanceNorm/instancenorm') self.assertListEqual([5, height, width, 3], output.shape.as_list())
def testCreateOpNoScaleCenter(self): height, width = 3, 3 images = random_ops.random_uniform( (5, height, width, 3), dtype=dtypes.float64, seed=1) output = normalization.instance_norm(images, center=False, scale=False) self.assertStartsWith( output.op.name, 'InstanceNorm/instancenorm') self.assertListEqual([5, height, width, 3], output.shape.as_list()) self.assertEqual(0, len(contrib_variables.get_variables_by_name('beta'))) self.assertEqual(0, len(contrib_variables.get_variables_by_name('gamma')))
def testParamsShapeNotFullyDefinedNHWC(self): inputs = array_ops.placeholder(dtypes.float32, shape=(3, 4, None)) with self.assertRaisesRegexp(ValueError, 'undefined channels dimension'): normalization.instance_norm(inputs, data_format='NHWC')
def testBadDataFormat(self): inputs = array_ops.placeholder(dtypes.float32, shape=(2, 5, 5)) with self.assertRaisesRegexp(ValueError, 'data_format has to be either NCHW or NHWC.'): normalization.instance_norm(inputs, data_format='NHCW')
def testUnknownShape(self): inputs = array_ops.placeholder(dtypes.float32) with self.assertRaisesRegexp(ValueError, 'undefined rank'): normalization.instance_norm(inputs)
def residual_block_with_IN(incoming, nb_blocks, out_channels, downsample=False, downsample_strides=2, activation='relu', batch_norm=True, bias=True, weights_init='variance_scaling', bias_init='zeros', regularizer='L2', weight_decay=0.0001, trainable=True, restore=True, reuse=False, scope=None, name="ResidualBlock", is_training=True): """ Residual Block. A residual block as described in MSRA's Deep Residual Network paper. Full pre-activation architecture is used here. Input: 4-D Tensor [batch, height, width, in_channels]. Output: 4-D Tensor [batch, new height, new width, nb_filter]. Arguments: incoming: `Tensor`. Incoming 4-D Layer. nb_blocks: `int`. Number of layer blocks. out_channels: `int`. The number of convolutional filters of the convolution layers. downsample: `bool`. If True, apply downsampling using 'downsample_strides' for strides. downsample_strides: `int`. The strides to use when downsampling. activation: `str` (name) or `function` (returning a `Tensor`). Activation applied to this layer (see tflearn.activations). Default: 'linear'. batch_norm: `bool`. If True, apply batch normalization. bias: `bool`. If True, a bias is used. weights_init: `str` (name) or `Tensor`. Weights initialization. (see tflearn.initializations) Default: 'uniform_scaling'. bias_init: `str` (name) or `tf.Tensor`. Bias initialization. (see tflearn.initializations) Default: 'zeros'. regularizer: `str` (name) or `Tensor`. Add a regularizer to this layer weights (see tflearn.regularizers). Default: None. weight_decay: `float`. Regularizer decay parameter. Default: 0.001. trainable: `bool`. If True, weights will be trainable. restore: `bool`. If True, this layer weights will be restored when loading a model. reuse: `bool`. If True and 'scope' is provided, this layer variables will be reused (shared). scope: `str`. Define this layer scope (optional). A scope can be used to share variables between layers. Note that scope will override name. name: A name for this layer (optional). Default: 'ShallowBottleneck'. is_training: True for training mode and False for val or test mode. References: - Deep Residual Learning for Image Recognition. Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun. 2015. - Identity Mappings in Deep Residual Networks. Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun. 2015. Links: - [http://arxiv.org/pdf/1512.03385v1.pdf] (http://arxiv.org/pdf/1512.03385v1.pdf) - [Identity Mappings in Deep Residual Networks] (https://arxiv.org/pdf/1603.05027v2.pdf) """ resnet = incoming in_channels = incoming.get_shape().as_list()[-1] with tf.variable_scope(values=[incoming], name_or_scope=scope, default_name=name, reuse=reuse) as scope: name = scope.name # TODO for i in range(nb_blocks): identity = resnet if not downsample: downsample_strides = 1 if batch_norm: resnet = normalization.instance_norm(resnet, scope=name + '_bn_' + str(i) + '_1') resnet = tflearn.activation(resnet, activation) resnet = tflearn.conv_2d(resnet, out_channels, 3, downsample_strides, 'same', 'linear', bias, weights_init, bias_init, regularizer, weight_decay, trainable, restore) if batch_norm: resnet = normalization.instance_norm(resnet, scope=name + '_bn_' + str(i) + '_2') resnet = tflearn.activation(resnet, activation) resnet = tflearn.conv_2d(resnet, out_channels, 3, downsample_strides, 'same', 'linear', bias, weights_init, bias_init, regularizer, weight_decay, trainable, restore) # Downsampling if downsample_strides > 1: identity = tflearn.avg_pool_2d(identity, 1, downsample_strides) # Projection to new dimension ''' if in_channels != out_channels: ch = (out_channels - in_channels)//2 identity = tf.pad(identity, [[0, 0], [0, 0], [0, 0], [ch, ch]]) in_channels = out_channels ''' resnet = resnet + identity return resnet