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 call(self, x): inp = x kernel = K.random_uniform_variable(shape=(self.kernel_size[0], self.kernel_size[1], self.out_shape[-1], int(x.get_shape()[-1])), low=0, high=1) deconv = K.conv2d_transpose(x, kernel=kernel, strides=self.strides, output_shape=self.out_shape, padding='same') biases = K.zeros(shape=(self.out_shape[-1])) deconv = K.reshape(K.bias_add(deconv, biases), deconv.get_shape()) deconv = LeakyReLU()(deconv) g = K.conv2d_transpose(inp, kernel, output_shape=self.out_shape, strides=self.strides, padding='same') biases2 = K.zeros(shape=(self.out_shape[-1])) g = K.reshape(K.bias_add(g, biases2), deconv.get_shape()) g = K.sigmoid(g) deconv = tf.multiply(deconv, g) outputs = [deconv, g] output_shapes = self.compute_output_shape(x.shape) for output, shape in zip(outputs, output_shapes): output._keras_shape = shape return [deconv, g]
def gconv2d(x, kernel, gconv_indices, gconv_shape_info, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1), transpose=False, output_shape=None): """2D group equivariant convolution. # Arguments x: Tensor or variable. kernel: kernel tensor. strides: strides tuple. padding: string, `"same"` or `"valid"`. data_format: string, `"channels_last"` or `"channels_first"`. Whether to use Theano or TensorFlow data format for inputs/kernels/ouputs. dilation_rate: tuple of 2 integers. # Returns A tensor, result of 2D convolution. # Raises ValueError: if `data_format` is neither `channels_last` or `channels_first`. """ # Transform the filters transformed_filter = transform_filter_2d_nhwc(w=kernel, flat_indices=gconv_indices, shape_info=gconv_shape_info) if transpose: output_shape = (K.shape(x)[0], output_shape[1], output_shape[2], output_shape[3]) transformed_filter = transform_filter_2d_nhwc(w=kernel, flat_indices=gconv_indices, shape_info=gconv_shape_info) transformed_filter = K.permute_dimensions(transformed_filter, [0, 1, 3, 2]) return K.conv2d_transpose(x=x, kernel=transformed_filter, output_shape=output_shape, strides=strides, padding=padding, data_format=data_format) return K.conv2d(x=x, kernel=transformed_filter, strides=strides, padding=padding, data_format=data_format, dilation_rate=dilation_rate)
def call(self, inputs): h = self.h tmp, otmp = tf.split(inputs, num_or_size_splits=2, axis=-1) for k in range(self.unroll_length): y_f_tmp = K.conv2d(otmp, self.kernel, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if self.use_bias: y_f_tmp = K.bias_add(y_f_tmp, self.bias, data_format=self.data_format) x_f_tmp = -K.conv2d_transpose(x=tmp, kernel=self.kernel, strides=self.strides, output_shape=K.shape(tmp), padding=self.padding, data_format=self.data_format) if self.use_bias: x_f_tmp = K.bias_add(x_f_tmp, self.bias2, data_format=self.data_format) if self.activation is not None: tmp = tmp + h * self.activation(y_f_tmp) otmp = otmp + h * self.activation(x_f_tmp) out = K.concatenate([tmp, otmp], axis=-1) return out
def call(self, inputs): input_shape = K.shape(inputs) batch_size = input_shape[0] if self.data_format == 'channels_first': h_axis, w_axis = 2, 3 c_axis = 1 else: h_axis, w_axis = 1, 2 c_axis = 3 ##BTEK kernel = self.U() in_channels = input_shape[c_axis] height, width = input_shape[h_axis], input_shape[w_axis] kernel_h, kernel_w = self.kernel_size stride_h, stride_w = self.strides if self.output_padding is None: out_pad_h = out_pad_w = None else: out_pad_h, out_pad_w = self.output_padding # Infer the dynamic output shape: out_height = conv_utils.deconv_length(height, stride_h, kernel_h, self.padding, out_pad_h, self.dilation_rate[0]) out_width = conv_utils.deconv_length(width, stride_w, kernel_w, self.padding, out_pad_w, self.dilation_rate[1]) if self.data_format == 'channels_first': output_shape = (batch_size, self.filters, out_height, out_width) else: output_shape = (batch_size, out_height, out_width, self.filters) ##BTEK kernel = self.U() print("kernel shape in output:", kernel.shape) print("channel axis") kernel = K.repeat_elements(kernel, self.input_channels, axis=c_axis) print("kernel reshaped :", kernel.shape) outputs = K.conv2d_transpose(inputs, kernel, output_shape, self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if self.use_bias: outputs = K.bias_add(outputs, self.bias, data_format=self.data_format) if self.activation is not None: return self.activation(outputs) return outputs
def call(self, x): shape = self.compute_output_shape(x.shape.as_list()) batch_size = K.shape(x)[0] output_shape = (batch_size, *shape) return K.conv2d_transpose(x, self._W, output_shape=output_shape, strides=tuple(self._upscaling_factors), padding="same")
def call(self, inputs): if self.transpose_output_shape is None: input_shape = K.shape(inputs) input_shape_list = inputs.get_shape().as_list() batch_size = input_shape[0] if self.data_format == 'channels_first': h_axis, w_axis = 2, 3 else: h_axis, w_axis = 1, 2 height, width = input_shape_list[h_axis], input_shape_list[w_axis] kernel_h, kernel_w = self.kernel_size stride_h, stride_w = self.strides # Infer the dynamic output shape: out_height = conv_utils.deconv_length(height, stride_h, kernel_h, self.padding) out_width = conv_utils.deconv_length(width, stride_w, kernel_w, self.padding) if self.data_format == 'channels_first': self.transpose_output_shape = (batch_size, self.filters, out_height, out_width) else: self.transpose_output_shape = (batch_size, out_height, out_width, self.filters) shape = self.transpose_output_shape else: shape = self.transpose_output_shape if self.data_format == 'channels_first': shape = (shape[0], shape[2], shape[3], shape[1]) if shape[0] is None: shape = (tf.shape(inputs)[0], ) + tuple(shape[1:]) shape = tf.stack(list(shape)) outputs = K.conv2d_transpose(x=inputs, kernel=self.kernel, output_shape=shape, strides=self.strides, padding=self.padding, data_format=self.data_format) outputs = tf.reshape(outputs, shape) # if self.bias: # outputs = K.bias_add( # outputs, # self.bias, # data_format=self.data_format) if self.activation is not None: return self.activation(outputs) return outputs
def call(self, inputs): input_shape = K.shape(inputs) batch_size = input_shape[0] if self.data_format == 'channels_first': h_axis, w_axis = 2, 3 else: h_axis, w_axis = 1, 2 height, width = input_shape[h_axis], input_shape[w_axis] kernel_h, kernel_w = self.kernel_size stride_h, stride_w = self.strides if self.output_padding is None: out_pad_h = out_pad_w = None else: out_pad_h, out_pad_w = self.output_padding # Infer the dynamic output shape: out_height = conv_utils.deconv_length(height, stride_h, kernel_h, self.padding, out_pad_h, self.dilation_rate[0]) out_width = conv_utils.deconv_length(width, stride_w, kernel_w, self.padding, out_pad_w, self.dilation_rate[1]) if self.data_format == 'channels_first': output_shape = (batch_size, self.filters, out_height, out_width) else: output_shape = (batch_size, out_height, out_width, self.filters) outputs = inputs if self.use_bias: outputs = K.bias_add( outputs, -self.bias, data_format=self.data_format) outputs = K.conv2d_transpose( outputs, self.kernel, output_shape, self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if self.activation is not None: return self.activation(outputs) return outputs
def call(self, inputs): shape = K.shape(inputs) if self.keep_dims: y = K.conv2d(inputs, self.dct_kernel) else: y = K.conv2d_transpose(inputs, self.dct_kernel, output_shape=(shape[0], shape[1] + 7, shape[2] + 7, 1)) y = y * self.scale_kernel return y
def branch(self, z, kernel, bias): out = K.conv2d(z, kernel=kernel, padding='same', strides=(1, 1)) out = K.bias_add(out, bias) out = K.relu(out) z_shape = K.shape(z) tr_shape = (z_shape[0], z_shape[1], z_shape[2], self.filters / 2) out = K.conv2d_transpose(out, output_shape=tr_shape, kernel=kernel, padding='same', strides=(1, 1)) return self.h * out
def max_singular_val_for_convolution(w, u, fully_differentiable=False, ip=1, padding='same', strides=(1, 1), data_format='channels_last'): assert ip >= 1 if not fully_differentiable: w_ = K.stop_gradient(w) else: w_ = w u_bar = u for _ in range(ip): v_bar = K.conv2d(u_bar, w_, strides=strides, data_format=data_format, padding=padding) v_bar = K.l2_normalize(v_bar) u_bar_raw = K.conv2d_transpose(v_bar, w_, output_shape=K.int_shape(u), strides=strides, data_format=data_format, padding=padding) u_bar = K.l2_normalize(u_bar_raw) u_bar_raw_diff = K.conv2d_transpose(v_bar, w, output_shape=K.int_shape(u), strides=strides, data_format=data_format, padding=padding) sigma = K.sum(u_bar * u_bar_raw_diff) return sigma, u_bar
def call(self, input_tensor, training=None): input_transposed = tf.transpose(input_tensor, [3, 0, 1, 2, 4]) input_shape = K.shape(input_transposed) input_tensor_reshaped = K.reshape(input_transposed, [ input_shape[1] * input_shape[0], self.input_height, self.input_width, self.input_num_atoms]) input_tensor_reshaped.set_shape((None, self.input_height, self.input_width, self.input_num_atoms)) if self.upsamp_type == 'resize': upsamp = K.resize_images(input_tensor_reshaped, self.scaling, self.scaling, 'channels_last') outputs = K.conv2d(upsamp, kernel=self.W, strides=(1, 1), padding=self.padding, data_format='channels_last') elif self.upsamp_type == 'subpix': conv = K.conv2d(input_tensor_reshaped, kernel=self.W, strides=(1, 1), padding='same', data_format='channels_last') outputs = tf.depth_to_space(conv, self.scaling) else: batch_size = input_shape[1] * input_shape[0] # Infer the dynamic output shape: out_height = deconv_length(self.input_height, self.scaling, self.kernel_size, self.padding, None) out_width = deconv_length(self.input_width, self.scaling, self.kernel_size, self.padding, None) output_shape = (batch_size, out_height, out_width, self.num_capsule * self.num_atoms) outputs = K.conv2d_transpose(input_tensor_reshaped, self.W, output_shape, (self.scaling, self.scaling), padding=self.padding, data_format='channels_last') votes_shape = K.shape(outputs) _, conv_height, conv_width, _ = outputs.get_shape() votes = K.reshape(outputs, [input_shape[1], input_shape[0], votes_shape[1], votes_shape[2], self.num_capsule, self.num_atoms]) votes.set_shape((None, self.input_num_capsule, conv_height.value, conv_width.value, self.num_capsule, self.num_atoms)) logit_shape = K.stack([ input_shape[1], input_shape[0], votes_shape[1], votes_shape[2], self.num_capsule]) biases_replicated = K.tile(self.b, [votes_shape[1], votes_shape[2], 1, 1]) activations = update_routing( votes=votes, biases=biases_replicated, logit_shape=logit_shape, num_dims=6, input_dim=self.input_num_capsule, output_dim=self.num_capsule, num_routing=self.routings) return activations
def call(self, inputs): input_shape = K.shape(inputs) batch_size = input_shape[0] #if self.data_format == 'channels_first': # s_axis = 2 #else: s_axis = 1 steps = input_shape[s_axis] kernel_w, = self.kernel_size stride, = self.strides if self.output_padding is None: out_pad_w = None else: out_pad_w, = self.output_padding # Infer the dynamic output shape: out_width = conv_utils.deconv_length(steps, stride, kernel_w, self.padding, out_pad_w, self.dilation_rate[0]) #if self.data_format == 'channels_first': # output_shape = (batch_size, self.filters, 1, out_width) # inputs = K.expand_dims(inputs, axis=2) #else: output_shape = (batch_size, 1, out_width, self.filters) inputs = K.expand_dims(inputs, axis=1) outputs = K.conv2d_transpose(inputs, K.expand_dims(self.kernel, axis=0), output_shape, (1, self.strides[0]), padding=self.padding, data_format=self.data_format, dilation_rate=(1, self.dilation_rate[0])) #if self.data_format == 'channels_first': # outputs = K.squeeze(outputs, axis=2) #else: outputs = K.squeeze(outputs, axis=1) if self.use_bias: outputs = K.bias_add(outputs, self.bias, data_format=self.data_format) if self.activation is not None: return self.activation(outputs) return outputs
def _deconv_module(feature_layer, deconv_layer, name, feature_size=512): # deconv1 = Conv2DTranspose(feature_size, kernel_size=(2,2), # strides=(2, 2), name=name+'Transpose1', padding='same')(deconv_layer) # # deconv1 = UpSampling2D(size=(2, 2), name=name+'upsampled')(deconv_layer) # filter_shape = K.stack([1, 2,2, deconv_layer.shape[3]]) deconv_filter = Lambda(lambda args: K.variable( K.random_normal(K.stack([2, 2, feature_size, args.shape[3]])), name=name + 'kernel'))(deconv_layer) # output_shape = K.stack([K.shape(feature_layer)[0], feature_layer.shape[1], feature_layer.shape[2], feature_size]) deconv1 = Lambda(lambda args: K.conv2d_transpose( args[0], args[2], K.stack([ K.shape(args[1])[0], args[1].shape[1], args[1].shape[2], feature_size ]), (2, 2), 'valid'))([deconv_layer, feature_layer, deconv_filter]) conv1 = Conv2D(feature_size, kernel_size=(3, 3), strides=1, padding='same', name=name + 'Conv1')(deconv1) bn1 = BatchNormalization(name='bn_1' + name)(conv1) conv2 = Conv2D(feature_size, kernel_size=(3, 3), strides=1, padding='same', name=name + 'Conv2')(feature_layer) bn2 = BatchNormalization(name='bn_2' + name)(conv2) relu1 = Activation('relu', name=name + 'Relu2')(bn2) conv3 = Conv2D(feature_size, kernel_size=(3, 3), strides=1, padding='same', name=name + 'Conv3')(relu1) bn3 = BatchNormalization(name='bn_3' + name)(conv3) product = Multiply(name='mul_' + name)([bn1, bn3]) return Activation('relu', name=name)(product)
def call(self, inputs): input_shape = K.shape(inputs) batch_size = input_shape[0] if self.data_format == 'channels_first': h_axis, w_axis = 2, 3 else: h_axis, w_axis = 1, 2 height, width = input_shape[h_axis], input_shape[w_axis] kernel_h, kernel_w = self.kernel_size stride_h, stride_w = self.strides # Infer the dynamic output shape: if self._output_shape is None: out_height = deconv_length(height, stride_h, kernel_h, self.padding) out_width = deconv_length(width, stride_w, kernel_w, self.padding) if self.data_format == 'channels_first': output_shape = ( batch_size, self.filters, out_height, out_width ) else: output_shape = ( batch_size, out_height, out_width, self.filters ) else: output_shape = (batch_size,) + self._output_shape outputs = K.conv2d_transpose( inputs, self.kernel, output_shape, self.strides, padding=self.padding, data_format=self.data_format ) if self.bias: outputs = K.bias_add( outputs, self.bias, data_format=self.data_format ) if self.activation is not None: return self.activation(outputs) return outputs
def call(self, inputs): revcomp_kernel =\ K.concatenate([self.kernel, self.kernel[::-1,::-1,::-1]],axis=-2) if (self.use_bias): revcomp_bias = K.concatenate([self.bias, self.bias[::-1]], axis=-1) input_shape = K.shape(inputs) batch_size = input_shape[0] s_axis = 1 steps = input_shape[s_axis] kernel_w, = self.kernel_size stride, = self.strides if self.output_padding is None: out_pad_w = None else: out_pad_w, = self.output_padding # Infer the dynamic output shape: out_width = conv_utils.deconv_length(steps, stride, kernel_w, self.padding, out_pad_w, self.dilation_rate[0]) output_shape = (batch_size, 1, out_width, 2 * self.filters) inputs = K.expand_dims(inputs, axis=1) outputs = K.conv2d_transpose(inputs, K.expand_dims(revcomp_kernel, axis=0), output_shape, (1, self.strides[0]), padding=self.padding, data_format=self.data_format, dilation_rate=(1, self.dilation_rate[0])) outputs = K.squeeze(outputs, axis=1) if self.use_bias: outputs = K.bias_add(outputs, revcomp_bias, data_format=self.data_format) if self.activation is not None: return self.activation(outputs) return outputs
def call(self, inputs): inputs_shape = array_ops.shape(inputs) batch_size = inputs_shape[0] if self.data_format == 'channels_first': h_axis, w_axis = 2, 3 else: h_axis, w_axis = 1, 2 height, width = inputs_shape[h_axis], inputs_shape[w_axis] kernel_h, kernel_w = self.kernel_size stride_h, stride_w = self.strides if self.output_padding is None: out_pad_h = out_pad_w = None else: out_pad_h, out_pad_w = self.output_padding # Hard-code the output shape because Keras screws this up: # this only works for padding='same' stride_h, stride_w = self.strides out_height = inputs_shape[h_axis] * stride_h out_width = inputs_shape[w_axis] * stride_w if self.data_format == 'channels_first': output_shape = (batch_size, self.filters, out_height, out_width) else: output_shape = (batch_size, out_height, out_width, self.filters) outputs = K.conv2d_transpose(inputs, self.kernel, output_shape, self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if self.use_bias: outputs = K.bias_add(outputs, self.bias, data_format=self.data_format) if self.activation is not None: return self.activation(outputs) return outputs
def conv2d_transpose( inputs, filter, # pylint: disable=redefined-builtin kernel_size=None, filters=None, strides=(1, 1), padding='same', output_padding=None, data_format='channels_last'): """Compatibility layer for K.conv2d_transpose Take a filter defined for forward convolution and adjusts it for a transposed convolution.""" input_shape = K.shape(inputs) batch_size = input_shape[0] if data_format == 'channels_first': h_axis, w_axis = 2, 3 else: h_axis, w_axis = 1, 2 height, width = input_shape[h_axis], input_shape[w_axis] kernel_h, kernel_w = kernel_size stride_h, stride_w = strides # Infer the dynamic output shape: out_height = conv_utils.deconv_length(height, stride_h, kernel_h, padding, output_padding) out_width = conv_utils.deconv_length(width, stride_w, kernel_w, padding, output_padding) if data_format == 'channels_first': output_shape = (batch_size, filters, out_height, out_width) else: output_shape = (batch_size, out_height, out_width, filters) filter = K.permute_dimensions(filter, (0, 1, 3, 2)) return K.conv2d_transpose(inputs, filter, output_shape, strides, padding=padding, data_format=data_format)
def __call__(self, w): norm = self.max_k if len(w.shape) == 4: x = K.random_normal_variable(shape=(1,) + self.in_shape[1:3] + (self.in_shape[0],), mean=0, scale=1) for i in range(0, self.iterations): x_p = K.conv2d(x, w, strides=self.stride, padding=self.padding) x = K.conv2d_transpose(x_p, w, x.shape, strides=self.stride, padding=self.padding) Wx = K.conv2d(x, w, strides=self.stride, padding=self.padding) norm = K.sqrt(K.sum(K.pow(Wx, 2.0)) / K.sum(K.pow(x, 2.0))) else: x = K.random_normal_variable(shape=(int(w.shape[1]), 1), mean=0, scale=1) for i in range(0, self.iterations): x_p = K.dot(w, x) x = K.dot(K.transpose(w), x_p) norm = K.sqrt(K.sum(K.pow(K.dot(w, x), 2.0)) / K.sum(K.pow(x, 2.0))) return w * (1.0 / K.maximum(1.0, norm / self.max_k))
def call(self, inputs): input_shape = K.shape(inputs) batch_size = input_shape[0] if self.data_format == 'channels_first': h_axis, w_axis = 2, 3 else: h_axis, w_axis = 1, 2 height, width = input_shape[h_axis], input_shape[w_axis] kernel_h, kernel_w = self.kernel_size stride_h, stride_w = self.strides if self.output_padding is None: out_pad_h = out_pad_w = None else: out_pad_h, out_pad_w = self.output_padding # Infer the dynamic output shape: out_height = conv_utils.deconv_length(height, stride_h, kernel_h, self.padding, out_pad_h) out_width = conv_utils.deconv_length(width, stride_w, kernel_w, self.padding, out_pad_w) if self.data_format == 'channels_first': output_shape = (batch_size, self.filters, out_height, out_width) else: output_shape = (batch_size, out_height, out_width, self.filters) #Spectral Normalization def _l2normalize(v, eps=1e-12): return v / (K.sum(v**2)**0.5 + eps) def power_iteration(W, u): #Accroding the paper, we only need to do power iteration one time. _u = u _v = _l2normalize(K.dot(_u, K.transpose(W))) _u = _l2normalize(K.dot(_v, W)) return _u, _v W_shape = self.kernel.shape.as_list() #Flatten the Tensor W_reshaped = K.reshape(self.kernel, [-1, W_shape[-1]]) _u, _v = power_iteration(W_reshaped, self.u) #Calculate Sigma sigma = K.dot(_v, W_reshaped) sigma = K.dot(sigma, K.transpose(_u)) #normalize it W_bar = W_reshaped / sigma #reshape weight tensor if training in {0, False}: W_bar = K.reshape(W_bar, W_shape) else: with tf.control_dependencies([self.u.assign(_u)]): W_bar = K.reshape(W_bar, W_shape) self.kernel = W_bar outputs = K.conv2d_transpose(inputs, self.kernel, output_shape, self.strides, padding=self.padding, data_format=self.data_format) if self.use_bias: outputs = K.bias_add(outputs, self.bias, data_format=self.data_format) if self.activation is not None: return self.activation(outputs) return outputs
def call(self, inputs, training=None): input_shape = K.shape(inputs) batch_size = input_shape[0] if self.data_format == 'channels_first': h_axis, w_axis = 2, 3 else: h_axis, w_axis = 1, 2 height, width = input_shape[h_axis], input_shape[w_axis] kernel_h, kernel_w = self.kernel_size stride_h, stride_w = self.strides if self.output_padding is None: out_pad_h = out_pad_w = None else: out_pad_h, out_pad_w = self.output_padding # Infer the dynamic output shape: out_height = conv_utils.deconv_length(height, stride_h, kernel_h, self.padding, out_pad_h) out_width = conv_utils.deconv_length(width, stride_w, kernel_w, self.padding, out_pad_w) if self.data_format == 'channels_first': output_shape = (batch_size, self.filters, out_height, out_width) else: output_shape = (batch_size, out_height, out_width, self.filters) w_shape = self.kernel.shape.as_list() # Flatten the Tensor w_reshaped = K.reshape(self.kernel, [-1, w_shape[-1]]) _u, _v = power_iteration(w_reshaped, self.u) # Calculate Sigma sigma = K.dot(_v, w_reshaped) sigma = K.dot(sigma, K.transpose(_u)) # normalize it w_bar = w_reshaped / sigma # reshape weight tensor if not training: w_bar = K.reshape(w_bar, w_shape) else: with tf.control_dependencies([self.u.assign(_u)]): w_bar = K.reshape(w_bar, w_shape) outputs = K.conv2d_transpose( inputs, w_bar, output_shape, self.strides, padding=self.padding, data_format=self.data_format) if self.use_bias: outputs = K.bias_add( outputs, self.bias, data_format=self.data_format) if self.activation is not None: return self.activation(outputs) return outputs
def call(self, x): shape = self.compute_output_shape(x.shape.as_list()) batch_size = K.shape(x)[0] output_shape = (batch_size, *shape) return K.conv2d_transpose(x, self._W, output_shape=output_shape, strides=tuple(self._upscaling_factors), padding="same")
def call(self, inputs): inputs_shape = tf.shape(inputs) batch_size = inputs_shape[0] if self.data_format == 'channels_first': h_axis, w_axis = 2, 3 else: h_axis, w_axis = 1, 2 # Use the constant height and weight when possible. # TODO(scottzhu): Extract this into a utility function that can be applied # to all convolutional layers, which currently lost the static shape # information due to tf.shape(). height, width = None, None if inputs.shape.rank is not None: dims = inputs.shape.as_list() height = dims[h_axis] width = dims[w_axis] height = height if height is not None else inputs_shape[h_axis] width = width if width is not None else inputs_shape[w_axis] kernel_h, kernel_w = self.kernel_size stride_h, stride_w = self.strides if self.output_padding is None: out_pad_h = out_pad_w = None else: out_pad_h, out_pad_w = self.output_padding # Infer the dynamic output shape: out_height = conv_utils.deconv_output_length( height, kernel_h, padding=self.padding, output_padding=out_pad_h, stride=stride_h, dilation=self.dilation_rate[0]) out_width = conv_utils.deconv_output_length( width, kernel_w, padding=self.padding, output_padding=out_pad_w, stride=stride_w, dilation=self.dilation_rate[1]) if self.data_format == 'channels_first': output_shape = (batch_size, self.filters, out_height, out_width) else: output_shape = (batch_size, out_height, out_width, self.filters) output_shape_tensor = tf.stack(output_shape) outputs = backend.conv2d_transpose(inputs, self.kernel, output_shape_tensor, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if not tf.executing_eagerly(): # Infer the static output shape: out_shape = self.compute_output_shape(inputs.shape) outputs.set_shape(out_shape) if self.use_bias: outputs = tf.nn.bias_add( outputs, self.bias, data_format=conv_utils.convert_data_format(self.data_format, ndim=4)) if self.activation is not None: return self.activation(outputs) return outputs