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
