def fn(x): #conv_even = K.conv2d(K.conv2d(x, even_kernel_3d), #K.permute_dimensions(even_kernel_3d, (1, 0, 2, 3))) #conv_odd = K.conv2d(K.conv2d(x, odd_kernel_3d), #K.permute_dimensions(odd_kernel_3d, (1, 0, 2, 3))) input_shape = K.shape(x) dim1 = conv_utils.conv_input_length(input_shape[1], 5, padding=padding_mode, stride=2) dim2 = conv_utils.conv_input_length(input_shape[2], 5, padding=padding_mode, stride=2) output_shape_a = (input_shape[0], dim1, input_shape[2], input_shape[3]) output_shape_b = (input_shape[0], dim1, dim2, input_shape[3]) upconvolved = K.conv2d_transpose(x, kernel_3d, output_shape_a, strides=(2, 1), padding=padding_mode) upconvolved = K.conv2d_transpose(upconvolved, K.permute_dimensions( kernel_3d, (1, 0, 2, 3)), output_shape_b, strides=(1, 2), padding=padding_mode) return 4 * upconvolved
def test_deconvolution_3d(): num_samples = 6 num_filter = 4 stack_size = 2 kernel_dim1 = 12 kernel_dim2 = 10 kernel_dim3 = 8 for batch_size in [None, num_samples]: for border_mode in _convolution_border_modes: for subsample in [(1, 1, 1), (2, 2, 2)]: if border_mode == 'same' and subsample != (1, 1, 1): continue dim1 = conv_input_length(kernel_dim1, 7, border_mode, subsample[0]) dim2 = conv_input_length(kernel_dim2, 5, border_mode, subsample[1]) dim3 = conv_input_length(kernel_dim3, 3, border_mode, subsample[2]) layer_test(convolutional.Deconvolution3D, kwargs={'filters': num_filter, 'kernel_size': (7, 5, 3), 'output_shape': (batch_size, num_filter, dim1, dim2, dim3), 'padding': border_mode, 'strides': subsample, 'data_format': 'channels_first'}, input_shape=(num_samples, stack_size, kernel_dim1, kernel_dim2, kernel_dim3), fixed_batch_size=True, tolerance=None) layer_test(convolutional.Deconvolution3D, kwargs={'filters': num_filter, 'kernel_size': (7, 5, 3), 'output_shape': (batch_size, num_filter, dim1, dim2, dim3), 'padding': border_mode, 'strides': subsample, 'data_format': 'channels_first', 'kernel_regularizer': 'l2', 'bias_regularizer': 'l2', 'activity_regularizer': 'l2'}, input_shape=(num_samples, stack_size, kernel_dim1, kernel_dim2, kernel_dim3), fixed_batch_size=True, tolerance=None) layer_test(convolutional.Deconvolution3D, kwargs={'filters': num_filter, 'kernel_size': (7, 5, 3), 'output_shape': (num_filter, dim1, dim2, dim3), 'padding': border_mode, 'strides': subsample, 'data_format': 'channels_first', 'kernel_regularizer': 'l2', 'bias_regularizer': 'l2', 'activity_regularizer': 'l2'}, input_shape=(num_samples, stack_size, kernel_dim1, kernel_dim2, kernel_dim3), tolerance=None)
def get_output_shape_for_helper(self, input_shape, nb_filter, dim_ordering, nb_row, nb_col, border_mode, subsample): if dim_ordering == 'th': rows = input_shape[2] cols = input_shape[3] elif dim_ordering == 'tf': rows = input_shape[1] cols = input_shape[2] else: raise Exception('Invalid dim_ordering: ' + dim_ordering) rows = conv_input_length(rows, nb_row, border_mode, subsample[0]) cols = conv_input_length(cols, nb_col, border_mode, subsample[1]) if dim_ordering == 'th': return (input_shape[0], nb_filter, rows, cols) elif dim_ordering == 'tf': return (input_shape[0], rows, cols, nb_filter)
def get_output_shape_for(self, input_shape): if self.dim_ordering == 'th': rows = input_shape[2] cols = input_shape[3] elif self.dim_ordering == 'tf': rows = input_shape[1] cols = input_shape[2] else: raise Exception('Invalid dim_ordering: ' + self.dim_ordering) rows = conv_input_length(rows, self.nb_row, self.border_mode, self.subsample[0]) cols = conv_input_length(cols, self.nb_col, self.border_mode, self.subsample[1]) if self.dim_ordering == 'th': return (input_shape[0], self.nb_filter, rows, cols) elif self.dim_ordering == 'tf': return (input_shape[0], rows, cols, self.nb_filter) else: raise Exception('Invalid dim_ordering: ' + self.dim_ordering)
def test_conv_input_length(self): self.assertEqual(3, conv_utils.conv_input_length(4, 2, 'same', 1)) self.assertEqual(2, conv_utils.conv_input_length(2, 2, 'same', 2)) self.assertEqual(4, conv_utils.conv_input_length(3, 2, 'valid', 1)) self.assertEqual(4, conv_utils.conv_input_length(2, 2, 'valid', 2)) self.assertEqual(3, conv_utils.conv_input_length(4, 2, 'full', 1)) self.assertEqual(4, conv_utils.conv_input_length(3, 2, 'full', 2))
def test_conv_input_length(self): self.assertEqual(3, conv_utils.conv_input_length(4, 2, "same", 1)) self.assertEqual(2, conv_utils.conv_input_length(2, 2, "same", 2)) self.assertEqual(4, conv_utils.conv_input_length(3, 2, "valid", 1)) self.assertEqual(4, conv_utils.conv_input_length(2, 2, "valid", 2)) self.assertEqual(3, conv_utils.conv_input_length(4, 2, "full", 1)) self.assertEqual(4, conv_utils.conv_input_length(3, 2, "full", 2))
def deconv2d(x, kernel, output_shape, strides=(1, 1), border_mode='valid', dim_ordering='th', image_shape=None, filter_shape=None): '''2D deconvolution (transposed convolution). # Arguments kernel: kernel tensor. output_shape: desired dimensions of output. strides: strides tuple. border_mode: string, "same" or "valid". dim_ordering: "tf" or "th". Whether to use Theano or TensorFlow dimension ordering in inputs/kernels/ouputs. ''' flip_filters = False if dim_ordering not in {'th', 'tf'}: raise Exception('Unknown dim_ordering ' + str(dim_ordering)) x = _preprocess_conv2d_input(x, dim_ordering) kernel = _preprocess_conv2d_kernel(kernel, dim_ordering) kernel = kernel.dimshuffle((1, 0, 2, 3)) th_border_mode = _preprocess_border_mode(border_mode) np_kernel = kernel.eval() filter_shape = _preprocess_conv2d_filter_shape(dim_ordering, filter_shape) filter_shape = tuple(filter_shape[i] for i in (1, 0, 2, 3)) op = T.nnet.abstract_conv.AbstractConv2d_gradInputs( imshp=output_shape, kshp=filter_shape, subsample=strides, border_mode=th_border_mode, filter_flip=not flip_filters) # Set output size as [None, None] output_size = [None] * 2 # Check if the width and heigth dimensions are None for i in [-2, -1]: if output_shape[i] is None: output_size[i] = conv_input_length(x.shape[i], filter_shape[i], border_mode, strides[i]) else: output_size[i] = output_shape[i] conv_out = op(kernel, x, output_size) conv_out = _postprocess_conv2d_output(conv_out, x, border_mode, np_kernel, strides, dim_ordering) return conv_out
def test_conv_input_length(): assert conv_utils.conv_input_length(None, 7, 'same', 1) is None assert conv_utils.conv_input_length(112, 7, 'same', 1) == 112 assert conv_utils.conv_input_length(112, 7, 'same', 2) == 223 assert conv_utils.conv_input_length(28, 5, 'valid', 1) == 32 assert conv_utils.conv_input_length(14, 5, 'valid', 2) == 31 assert conv_utils.conv_input_length(36, 5, 'full', 1) == 32 assert conv_utils.conv_input_length(18, 5, 'full', 2) == 31 with pytest.raises(AssertionError): conv_utils.conv_output_length(18, 5, 'diagonal', 2)
def deconv2d(x, kernel, output_shape, strides=(1, 1), border_mode='valid', dim_ordering='default', image_shape=None, filter_shape=None): """2D deconvolution (i.e. transposed convolution). # Arguments x: input tensor. kernel: kernel tensor. output_shape: 1D int tensor for the output shape. strides: strides tuple. border_mode: string, `"same"` or `"valid"`. dim_ordering: `"tf"` or `"th"`. Whether to use Theano or TensorFlow dimension ordering for inputs/kernels/ouputs. # Returns A tensor, result of transposed 2D convolution. # Raises ValueError: if `dim_ordering` is neither `tf` or `th`. """ if dim_ordering == 'default': dim_ordering = K.image_dim_ordering() if dim_ordering not in {'th', 'tf'}: raise ValueError('Unknown dim_ordering ' + str(dim_ordering)) x = _preprocess_conv2d_input(x, dim_ordering) strides = (1, ) + strides + (1, ) # Get output shape shape_b = tf.shape(x)[0] shape_h = output_shape[1] shape_w = output_shape[2] shape_c = output_shape[3] # print('Output Shape: ' + str(output_shape)) # print('Input Shape: ' + str(x.get_shape())) # Compute output height if none if shape_h is None: shape_h = conv_input_length( tf.shape(x)[1], filter_shape[0], border_mode, strides[1]) # Compute output width if none if shape_w is None: shape_w = conv_input_length( tf.shape(x)[2], filter_shape[1], border_mode, strides[2]) # Compose output shape without nones try: # Uses tf.pack, previous to tensorflow 1.0.0 output_shape = tf.pack([shape_b, shape_h, shape_w, shape_c]) except AttributeError: # Uses tf.stack in favor of tf.pack, which is deprecated from tensorflow v1.0.0 onwards output_shape = tf.stack([shape_b, shape_h, shape_w, shape_c]) output_shape = _preprocess_deconv_output_shape(x, output_shape, dim_ordering) kernel = _preprocess_conv2d_kernel(kernel, dim_ordering) kernel = tf.transpose(kernel, (0, 1, 3, 2)) padding = _preprocess_border_mode(border_mode) x = tf.nn.conv2d_transpose(x, kernel, output_shape, strides, padding=padding) return _postprocess_conv2d_output(x, dim_ordering)