def build(self, input_shape): super(Conv2d_transpose, self).build(input_shape) self.kernel = self.add_weight(name='kernel', shape=self.kernel_size + [self.num_outputs, input_shape[-1]], initializer=self.kernel_initializer, trainable=self.trainable) if self.use_biases: self.biases = self.add_weight(name="biases", shape=[1, 1, 1, self.num_outputs], initializer=self.biases_initializer, trainable=self.trainable) self.spatial_shape = input_shape[1:3] self.output_shape_ = [ deconv_output_length(input_shape[1], self.kernel_size[0], padding=self.padding.lower(), stride=self.strides, dilation=self.dilations), deconv_output_length(input_shape[2], self.kernel_size[1], padding=self.padding.lower(), stride=self.strides, dilation=self.dilations), self.num_outputs ]
def get_output_spec(self, input_spec): height = deconv_output_length(input_length=input_spec['shape'][0], filter_size=self.window[0], padding=self.padding, stride=self.stride[1], dilation=self.dilation[1]) width = deconv_output_length(input_length=input_spec['shape'][1], filter_size=self.window[1], padding=self.padding, stride=self.stride[2], dilation=self.dilation[2]) if self.output_shape is None: self.output_shape = (1, height, width, self.size) shape = (height, width) if self.squeeze: input_spec['shape'] = shape else: input_spec['shape'] = shape + (self.size, ) input_spec.pop('min_value', None) input_spec.pop('max_value', None) return input_spec
def compute_output_shape(self, input_shape): input_shape = tensor_shape.TensorShape(input_shape).as_list() output_shape = list(input_shape) if self.data_format == 'channels_first': c_axis, h_axis, w_axis = 1, 2, 3 else: c_axis, h_axis, w_axis = 3, 1, 2 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 output_shape[c_axis] = self.filters output_shape[h_axis] = conv_utils.deconv_output_length( output_shape[h_axis], kernel_h, padding=self.padding, output_padding=out_pad_h, stride=stride_h, dilation=self.dilation_rate[0]) output_shape[w_axis] = conv_utils.deconv_output_length( output_shape[w_axis], kernel_w, padding=self.padding, output_padding=out_pad_w, stride=stride_w, dilation=self.dilation_rate[1]) return tensor_shape.TensorShape(output_shape)
def call(self, inputs, training=True): # 抄自系统的源码 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 # 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 = array_ops.stack(output_shape) outputs = backend.conv2d_transpose( inputs, self.compute_spectral_normal(training=training), # self.kernel, output_shape_tensor, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if not context.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 = 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
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_output_length(height , kernel_h , 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 , 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) scaled_kernel = self.kernel * self.runtime_coeff kernel = Ke.transpose(scaled_kernel,[0, 1, 3, 2]) #? kernel = Ke.pad(kernel , [[1,1], [1,1], [0,0], [0,0]]) fused_kernel = Ke.add_n([kernel[1:, 1:] , kernel[:-1, 1:] , kernel[1:, :-1] , kernel[:-1, :-1]]) #? outputs = K.conv2d_transpose(inputs , fused_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 compute_output_shape(self, input_shape): output_shape = list(input_shape) output_shape[1] = deconv_output_length(input_length=output_shape[1], stride=self.scaling, filter_size=self.kernel_size, padding=self.padding) output_shape[2] = deconv_output_length(input_length=output_shape[2], stride=self.scaling, filter_size=self.kernel_size, padding=self.padding) output_shape[3] = self.num_capsule output_shape[4] = self.num_atoms return tuple(output_shape)
def compute_output_shape(self, input_shape): input_shape = tf.TensorShape(input_shape).as_list() output_shape = list(input_shape) if self.data_format == 'channels_first': c_axis, h_axis = 1, 2 else: c_axis, h_axis = 2, 1 kernel_w = self.kernel_size[0] stride_w = self.strides[0] if self.output_padding is None: out_pad_w = None else: out_pad_w = self.output_padding[0] output_shape[c_axis] = self.filters output_shape[h_axis] = conv_utils.deconv_output_length( output_shape[h_axis], kernel_w, padding=self.padding, output_padding=out_pad_w, stride=stride_w, dilation=self.dilation_rate[0]) return tf.TensorShape(output_shape)
def get_spatial_out(self, spatial_in: List = None, filter_shape: List = None, strides: List = None, padding: str = None, dilations: List = None) -> List: if spatial_in is None: spatial_in = self.image_shape if filter_shape is None: filter_shape = self.patch_shape else: assert len(filter_shape) == 2 if strides is None: strides = self.strides if padding is None: padding = self.padding if dilations is None: dilations = self.dilations return [deconv_output_length(input_length=spatial_in[i], filter_size=filter_shape[i], stride=strides[i], padding=padding.lower(), dilation=dilations[i]) for i in range(2)]
def call(self, inputs): inputs_shape = array_ops.shape(inputs) batch_size = inputs_shape[0] if self.data_format == 'channels_first': w_axis = 2 else: w_axis = 1 width = inputs_shape[w_axis] kernel_w, = self.kernel_size stride_w, = 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_output_length( width, kernel_w, padding=self.padding, output_padding=out_pad_w, stride=stride_w, dilation=self.dilation_rate[0], ) if self.data_format == 'channels_first': output_shape = (batch_size, self.filters, out_width) else: output_shape = (batch_size, out_width, self.filters) output_shape_tensor = array_ops.stack(output_shape) outputs = conv1d_transpose( inputs, self.kernel, output_shape_tensor, stride=stride_w, padding=self.padding.upper(), data_format=conv_utils.convert_data_format(self.data_format, ndim=3), ) if not context.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 = 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
def get_new_space(space): new_space = [] for i in range(len(space)): new_dim = conv_utils.deconv_output_length( space[i], self.kernel_size[i], padding="same", stride=self.strides[i], output_padding=None) new_space.append(new_dim) return tuple(new_space)
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 out_pad_h = out_pad_w = None # Infer the dynamic output shape: out_height = conv_utils.deconv_output_length( height, kernel_h, self.padding, stride=stride_h) out_width = conv_utils.deconv_output_length( width, kernel_w, self.padding, stride=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.compute_spectral_normal(training=training), 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): if training is None: training = K.learning_phase() # Get the output space inputSpace = K.shape(inputs) batchSize = inputSpace[0] height, width = inputSpace[1], inputSpace[2] kHeight, kWidth = self.kernel_size sHeight, sWidth = self.strides if self.output_padding is None: opHeight = opWidth = None else: opHeight, opWidth = self.output_padding outHeight = conv_utils.deconv_output_length(height, kHeight, self.padding, opHeight, sHeight) outWidth = conv_utils.deconv_output_length(width, kWidth, self.padding, opWidth, sWidth) outputSpace = (batchSize, outHeight, outWidth, self.filters) self.kernel.assign(self._computeWeights(training)) output = K.conv2d_transpose(inputs, self.kernel, outputSpace, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if self.use_bias: output = K.bias_add(output, self.bias, data_format=self.data_format) if self.activation is not None: output = self.activation(output) return output
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 = inputs.shape 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_output_length(input_length=height, filter_size=kernel_h, padding=padding, output_padding=output_padding, stride=stride_h) out_width = conv_utils.deconv_output_length(input_length=width, filter_size=kernel_w, padding=padding, output_padding=output_padding, stride=stride_w) 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 output_spec(self): output_spec = super().output_spec() height = deconv_output_length( input_length=output_spec.shape[0], filter_size=self.window[0], padding=self.padding, stride=self.stride[1], dilation=self.dilation[1] ) width = deconv_output_length( input_length=output_spec.shape[1], filter_size=self.window[1], padding=self.padding, stride=self.stride[2], dilation=self.dilation[2] ) if self.output_shape is None: self.output_shape = (height, width, self.size) if self.squeeze: output_spec.shape = self.output_shape[: 2] else: output_spec.shape = self.output_shape output_spec.min_value = None output_spec.max_value = None return output_spec
def conv_transpose_output_length( input_length, filter_size, padding, stride, dilation=1, output_padding=None): """Rearrange arguments for compatibility with conv_output_length.""" if dilation != 1: msg = f"Dilation must be 1 for transposed convolution. " msg += f"Got dilation = {dilation}" raise ValueError(msg) # return conv_utils.deconv_length( # input_length, # dim_size # stride, # stride_size # filter_size, # kernel_size # padding, # padding # output_padding, # output_padding # ) return conv_utils.deconv_output_length(input_length, filter_size, padding, output_padding=output_padding, stride=stride, dilation=dilation)
def output_spec(self): output_spec = super().output_spec() width = deconv_output_length( input_length=output_spec.shape[0], filter_size=self.window, padding=self.padding, stride=self.stride, dilation=self.dilation ) if self.output_shape is None: self.output_shape = (width, self.size) if self.squeeze: output_spec.shape = self.output_shape[:1] else: output_spec.shape = self.output_shape output_spec.min_value = None output_spec.max_value = None return output_spec
def get_output_spec(self, input_spec): length = deconv_output_length(input_length=input_spec['shape'][0], filter_size=self.window, padding=self.padding, stride=self.stride, dilation=self.dilation) if self.output_width is None: self.output_width = length shape = (length, ) if self.squeeze: input_spec['shape'] = shape else: input_spec['shape'] = shape + (self.size, ) input_spec.pop('min_value', None) input_spec.pop('max_value', None) return input_spec
def compute_output_shape(self, input_shape): input_shape = tensor_shape.TensorShape(input_shape).as_list() output_shape = list(input_shape) if self.data_format == 'channels_first': c_axis, w_axis = 1, 2 else: c_axis, w_axis = 2, 1 # 3 con 2 kernel_w = self.kernel_size[0] #[0] stride_w = self.strides[0] #[0] if self.output_padding is None: out_pad_w = None else: out_pad_w = self.output_padding output_shape[c_axis] = self.filters output_shape[w_axis] = conv_utils.deconv_output_length( output_shape[w_axis], kernel_w, padding=self.padding, output_padding=out_pad_w, stride=stride_w) return tensor_shape.TensorShape(output_shape)
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 # 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) if self.kernel_quantizer: quantized_kernel = self.kernel_quantizer_internal(self.kernel) else: quantized_kernel = self.kernel output_shape_tensor = array_ops.stack(output_shape) outputs = tf.keras.backend.conv2d_transpose( inputs, quantized_kernel, output_shape_tensor, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if not context.executing_eagerly(): # Infer the static output shape: out_shape = self.compute_output_shape(inputs.shape) outputs.set_shape(out_shape) if self.use_bias: if self.bias_quantizer: quantized_bias = self.bias_quantizer_internal(self.bias) else: quantized_bias = self.bias outputs = tf.keras.backend.bias_add( outputs, quantized_bias, data_format=self.data_format) if self.activation is not None: return self.activation(outputs) return outputs
def call(self, inputs): W_shape = self.kernel.shape.as_list() W_reshaped = tf.reshape(self.kernel, (-1, W_shape[-1])) new_kernel = self.compute_spectral_norm(W_reshaped, self.u, W_shape) 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 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 = array_ops.stack(output_shape) outputs = K.conv2d_transpose( inputs, new_kernel, output_shape_tensor, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if not context.executing_eagerly(): 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
def call(self, inputs): inputs_shape = array_ops.shape(inputs) batch_size = inputs_shape[0] if self.data_format == 'channels_first': c_axis, h_axis, w_axis = 1, 2, 3 else: c_axis, h_axis, w_axis = 3, 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 # 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) self.output_shape_tensor = array_ops.stack(output_shape) outputs = self._apply_variational_kernel(inputs) if not context.executing_eagerly(): # Infer the static output shape: out_shape = self.compute_output_shape(inputs.shape) outputs.set_shape(out_shape) outputs = self._apply_variational_bias(outputs) if self.activation is not None: outputs = self.activation(outputs) if not self._built_kernel_divergence: self._apply_divergence(self.kernel_divergence_fn, self.kernel_posterior, self.kernel_prior, self.kernel_posterior_tensor, name='divergence_kernel') self._built_kernel_divergence = True if not self._built_bias_divergence: self._apply_divergence(self.bias_divergence_fn, self.bias_posterior, self.bias_prior, self.bias_posterior_tensor, name='divergence_bias') self._built_bias_divergence = True return outputs
def call(self, inputs, training=None): input_shape = 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[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_output_length(height, kernel_h, self.padding, out_pad_h, stride_h) # out_height = conv_utils.deconv_length(height, # stride_h, kernel_h, # self.padding, # out_pad_h) out_width = conv_utils.deconv_output_length(width, kernel_w, self.padding, out_pad_w, stride_w) # 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 trainig_val = tf_utils.constant_value(training) if trainig_val == 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, 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_output_length(input_length=self.input_height, stride=self.scaling, filter_size=self.kernel_size, padding=self.padding) out_width = deconv_output_length(input_length=self.input_width, stride=self.scaling, filter_size=self.kernel_size, padding=self.padding) 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 test_deconv_output_length(self): self.assertEqual( 4, conv_utils.deconv_output_length(4, 2, 'same', stride=1)) self.assertEqual( 8, conv_utils.deconv_output_length(4, 2, 'same', stride=2)) self.assertEqual( 5, conv_utils.deconv_output_length(4, 2, 'valid', stride=1)) self.assertEqual( 8, conv_utils.deconv_output_length(4, 2, 'valid', stride=2)) self.assertEqual( 3, conv_utils.deconv_output_length(4, 2, 'full', stride=1)) self.assertEqual( 6, conv_utils.deconv_output_length(4, 2, 'full', stride=2)) self.assertEqual( 5, conv_utils.deconv_output_length(4, 2, 'same', output_padding=2, stride=1)) self.assertEqual( 7, conv_utils.deconv_output_length(4, 2, 'same', output_padding=1, stride=2)) self.assertEqual( 7, conv_utils.deconv_output_length(4, 2, 'valid', output_padding=2, stride=1)) self.assertEqual( 9, conv_utils.deconv_output_length(4, 2, 'valid', output_padding=1, stride=2)) self.assertEqual( 5, conv_utils.deconv_output_length(4, 2, 'full', output_padding=2, stride=1)) self.assertEqual( 7, conv_utils.deconv_output_length(4, 2, 'full', output_padding=1, stride=2)) self.assertEqual( 5, conv_utils.deconv_output_length(4, 2, 'same', output_padding=1, stride=1, dilation=2)) self.assertEqual( 12, conv_utils.deconv_output_length(4, 2, 'valid', output_padding=2, stride=2, dilation=3)) self.assertEqual( 6, conv_utils.deconv_output_length(4, 2, 'full', output_padding=2, stride=2, dilation=3))
def test_deconv_output_length(self): self.assertEqual(4, conv_utils.deconv_output_length(4, 2, 'same', stride=1)) self.assertEqual(8, conv_utils.deconv_output_length(4, 2, 'same', stride=2)) self.assertEqual(5, conv_utils.deconv_output_length( 4, 2, 'valid', stride=1)) self.assertEqual(8, conv_utils.deconv_output_length( 4, 2, 'valid', stride=2)) self.assertEqual(3, conv_utils.deconv_output_length(4, 2, 'full', stride=1)) self.assertEqual(6, conv_utils.deconv_output_length(4, 2, 'full', stride=2)) self.assertEqual( 5, conv_utils.deconv_output_length( 4, 2, 'same', output_padding=2, stride=1)) self.assertEqual( 7, conv_utils.deconv_output_length( 4, 2, 'same', output_padding=1, stride=2)) self.assertEqual( 7, conv_utils.deconv_output_length( 4, 2, 'valid', output_padding=2, stride=1)) self.assertEqual( 9, conv_utils.deconv_output_length( 4, 2, 'valid', output_padding=1, stride=2)) self.assertEqual( 5, conv_utils.deconv_output_length( 4, 2, 'full', output_padding=2, stride=1)) self.assertEqual( 7, conv_utils.deconv_output_length( 4, 2, 'full', output_padding=1, stride=2)) self.assertEqual( 5, conv_utils.deconv_output_length( 4, 2, 'same', output_padding=1, stride=1, dilation=2)) self.assertEqual( 12, conv_utils.deconv_output_length( 4, 2, 'valid', output_padding=2, stride=2, dilation=3)) self.assertEqual( 6, conv_utils.deconv_output_length( 4, 2, 'full', output_padding=2, stride=2, dilation=3))
def call(self, inputs): inputs_shape = tf.shape(inputs) batch_size = inputs_shape[0] if self.data_format == 'channels_first': h_axis = 2 else: h_axis = 1 height = inputs_shape[h_axis] kernel_w = self.kernel_size[0] stride_w = self.strides[0] if self.output_padding is None: out_pad_w = None else: out_pad_w = self.output_padding[0] # Infer the dynamic output shape: out_width = conv_utils.deconv_output_length( height, kernel_w, padding=self.padding, output_padding=out_pad_w, stride=stride_w, dilation=self.dilation_rate[0]) if self.data_format == 'channels_first': output_shape = (batch_size, self.filters, out_width) data_format = 'NCW' strides = [1, 1, self.strides[0]] dilations = [1, 1, self.dilation_rate[0]] else: output_shape = (batch_size, out_width, self.filters) data_format = 'NWC' strides = [1, self.strides[0], 1] dilations = [1, self.dilation_rate[0], 1] assert self.dilation_rate[0] == 1, "No support for dilation_rate > 1" output_shape_tensor = tf.stack(output_shape) # TODO: support dilations > 1 (atrous_conv2d_transpose) outputs = tf.nn.conv1d_transpose(inputs, self.kernel, output_shape_tensor, strides=strides, padding=self.padding.upper(), data_format=data_format, dilations=dilations) 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=3)) if self.activation is not None: return self.activation(outputs) return outputs
def call(self, inputs, init_scale=0.1): 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 # 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 = array_ops.stack(output_shape) # --------------------------------------------------------------------- # Check if the convolution has been initialized. If it has not, # perform "batch norm" and initialize the kernel scale and the bias # --------------------------------------------------------------------- if not self._initialized: # Do not use the kernel log scale for the initialization round # Remember that the filter axis for deconvolutions is the 3rd one not the 4th # Note: the original IAF implementation is consciously using a bugged implementation, where # the norm is taken over the axes [0, 1, 2], but apparently this causes training instability # https://github.com/openai/iaf/issues/7 # https://github.com/openai/iaf/blob/ad33fe4872bf6e4b4f387e709a625376bb8b0d9d/tf_utils/layers.py#L93 kernel = self._get_kernel(norm_axes=[0, 1, 3], initializing=True) outputs = backend.conv2d_transpose(inputs, kernel, output_shape_tensor, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) out_mean, out_var = tf.nn.moments(outputs, axes=[0, 1, 2], keepdims=True) init_scale = init_scale / tf.sqrt(out_var + 1e-10) # Batch norm normed_outputs = (outputs - out_mean) * init_scale # Initialize the kernel scale and the bias self.kernel_log_scale.assign(tf.transpose(tf.math.log(init_scale) / 3.0, perm=[0, 1, 3, 2])) if self.use_bias: self.bias.assign(tf.reshape(-out_mean * init_scale, [self.filters])) self._initialized.assign(True) return normed_outputs else: 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 the convolution has not been initialized yet, we shouldn't add on the bias if self.use_bias: outputs = 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
def call(self, inputs, **kwargs): inputs_shape = tf.shape(inputs) # align_shape = tf.shape(inputs[1]) batch_size = inputs_shape[0] if self.data_format == 'channels_first': c_axis, h_axis, w_axis = 1, 2, 3 else: c_axis, h_axis, w_axis = 3, 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 # Infer the dynamic output shape: if type(self.align_shape) == type(None): out_height = conv_utils.deconv_output_length(height, kernel_h, self.padding, stride_h) out_width = conv_utils.deconv_output_length(width, kernel_w, self.padding, stride_w) else: out_height = self.align_shape[0] out_width = self.align_shape[1] # out_height = tf.where(tf.equal(out_height % 2, 0), out_height, out_height+1) # out_width = tf.where(tf.equal(out_width % 2, 0), out_width, out_width+1) # out_height = align_shape[1] # out_width = align_shape[2] if self.data_format == 'channels_first': output_shape = (batch_size, self.filters, out_height, out_width) strides = (1, 1, stride_h, stride_w) else: output_shape = (batch_size, out_height, out_width, self.filters) strides = (1, stride_h, stride_w, 1) output_shape_tensor = tf.stack(output_shape) outputs = tf.nn.conv2d_transpose( inputs, self.kernel, output_shape_tensor, strides, padding=self.padding.upper(), data_format=conv_utils.convert_data_format(self.data_format, ndim=4)) if not context.executing_eagerly(): # Infer the static output shape: out_shape = inputs.get_shape().as_list() out_shape[c_axis] = self.filters out_shape[h_axis] = conv_utils.deconv_output_length(out_shape[h_axis], kernel_h, self.padding, stride_h) out_shape[w_axis] = conv_utils.deconv_output_length(out_shape[w_axis], kernel_w, self.padding, stride_w) 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