def call(self, inputs):
# Input = [X^H, X^L]
assert len(inputs) == 2
high_input, low_input = inputs
# High -> High conv
high_to_high = K.conv2d(high_input, self.high_to_high_kernel,
strides=self.strides, padding=self.padding,
data_format="channels_last")
# High -> Low conv
high_to_low = K.pool2d(high_input, (2,2), strides=(2,2), pool_mode="avg")
high_to_low = K.conv2d(high_to_low, self.high_to_low_kernel,
strides=self.strides, padding=self.padding,
data_format="channels_last")
# Low -> High conv
low_to_high = K.conv2d(low_input, self.low_to_high_kernel,
strides=self.strides, padding=self.padding,
data_format="channels_last")
# print('low_to_high',low_to_high)
# low_to_high = K.repeat_elements(low_to_high, 2, axis=1) # Nearest Neighbor Upsampling
# print('low_to_high', low_to_high)
# low_to_high = K.repeat_elements(low_to_high, 2, axis=2)
# print('low_to_high', low_to_high)
low_to_high = tf.keras.layers.UpSampling2D(size=(2, 2), data_format='channels_last')(low_to_high)
# Low -> Low conv
low_to_low = K.conv2d(low_input, self.low_to_low_kernel,
strides=self.strides, padding=self.padding,
data_format="channels_last")
# Cross Add
high_add = high_to_high + low_to_high
low_add = high_to_low + low_to_low
return [high_add, low_add]
def call(self, x, **kwargs):
def hw_flatten(x):
return K.reshape(x,
shape=[
K.shape(x)[0],
K.shape(x)[1] * K.shape(x)[2],
K.shape(x)[-1]
])
f = K.conv2d(x, kernel=self.kernel_f, strides=(1, 1),
padding='same') # [bs, h, w, c']
f = K.bias_add(f, self.bias_f)
g = K.conv2d(x, kernel=self.kernel_g, strides=(1, 1),
padding='same') # [bs, h, w, c']
g = K.bias_add(g, self.bias_g)
h = K.conv2d(x, kernel=self.kernel_h, strides=(1, 1),
padding='same') # [bs, h, w, c]
h = K.bias_add(h, self.bias_h)
s = tf.matmul(hw_flatten(g), hw_flatten(f),
transpose_b=True) # # [bs, N, N]
beta = K.softmax(s, axis=-1) # attention map
self.beta = beta
o = K.batch_dot(beta, hw_flatten(h)) # [bs, N, C]
o = K.reshape(o, shape=K.shape(x)) # [bs, h, w, C]
x = self.gamma * o + x
return x
def var_yhat(y_true, y_pred):
n = 5
sk = K.constant(value=np.ones((n,n,1,1), dtype=np.float32), dtype='float32')
Var = K.mean((K.conv2d(K.square(y_pred), sk) - K.square(K.conv2d(y_pred, sk)/n**2))/n**2, axis=-1)
return Var
def call(self, x):
f = K.conv2d(x, kernel=self.kernel_f, strides=(1, 1),
padding='same') # [bs, h, w, c']
g = K.conv2d(x, kernel=self.kernel_g, strides=(1, 1),
padding='same') # [bs, h, w, c']
h = K.conv2d(x, kernel=self.kernel_h, strides=(1, 1),
padding='same') # [bs, h, w, c']
f_ = K.permute_dimensions(self._hw_flatten(f),
(0, 2, 1)) # [bs, 3c', N]
s = K.batch_dot(self._hw_flatten(g), f_) # [bs, N, N]
beta = K.softmax(s, axis=-1) # attention map
double_attn = K.batch_dot(f_, self._hw_flatten(x)) # [bs, 3c', 3c]
double_attn = K.softmax(double_attn, axis=1)
h_tmp, shape_tmp = self._hw_flatten(h,
return_shape=True) # [bs, N, 3c']
o_tmp = K.batch_dot(beta, h_tmp) # [bs, N, 3c']
o = K.batch_dot(o_tmp, double_attn) # [bs, N, 3c]
o = self._hw_recover(o, shape_tmp) # [bs, h, w, C]
x = self.gamma * o + x
return x
def call(self, inputs):
# Input = [X^H, X^L]
assert len(inputs) == 2
high_input, low_input = inputs
# Convolution: High Channels -> High Channels
high_to_high = K.conv2d(high_input, self.high_to_high_kernel,
strides=self.strides, padding=self.padding,
data_format="channels_last")
# Convolution: High Channels -> Low Channels
high_to_low = K.pool2d(high_input, (2, 2), strides=(2, 2), pool_mode="avg")
high_to_low = K.conv2d(high_to_low, self.high_to_low_kernel,
strides=self.strides, padding=self.padding,
data_format="channels_last")
# Convolution: Low Channels -> High Channels
low_to_high = K.conv2d(low_input, self.low_to_high_kernel,
strides=self.strides, padding=self.padding,
data_format="channels_last")
low_to_high = K.repeat_elements(low_to_high, 2, axis=1) # Nearest Neighbor Upsampling
low_to_high = K.repeat_elements(low_to_high, 2, axis=2)
# Convolution: Low Channels -> Low Channels
low_to_low = K.conv2d(low_input, self.low_to_low_kernel,
strides=self.strides, padding=self.padding,
data_format="channels_last")
# Cross Add
high_add = high_to_high + low_to_high
low_add = high_to_low + low_to_low
return [high_add, low_add]
def call(self, x):
def hw_flatten(x):
return K.reshape(x,
shape=[
K.shape(x)[0],
K.shape(x)[1] * K.shape(x)[2],
K.shape(x)[3]
])
f = K.conv2d(x, kernel=self.kernel_f, strides=(1, 1),
padding='same') # [bs, h, w, c']
g = K.conv2d(x, kernel=self.kernel_g, strides=(1, 1),
padding='same') # [bs, h, w, c']
h = K.conv2d(x, kernel=self.kernel_h, strides=(1, 1),
padding='same') # [bs, h, w, c]
s = K.batch_dot(hw_flatten(g),
K.permute_dimensions(hw_flatten(f),
(0, 2, 1))) # # [bs, N, N]
beta = K.softmax(s, axis=-1) # attention map
o = K.batch_dot(beta, hw_flatten(h)) # [bs, N, C]
o = K.reshape(o, shape=K.shape(x)) # [bs, h, w, C]
x = self.gamma * o + x
return x
def call(self, inputs, mask=None):
'''
We will be using the Keras conv2d method, and essentially we have
to do here is multiply the mask with the input X, before we apply the
convolutions. For the mask itself, we apply convolutions with all weights
set to 1.
Subsequently, we clip mask values to between 0 and 1
'''
# Both image and mask must be supplied
if type(inputs) is not list or len(inputs) != 2:
raise Exception(
'PartialConvolution2D must be called on a list of two tensors [img, mask]. Instead got: ' + str(inputs))
# Padding done explicitly so that padding becomes part of the masked partial convolution
images = K.spatial_2d_padding(inputs[0], self.pconv_padding, self.data_format)
masks = K.spatial_2d_padding(inputs[1], self.pconv_padding, self.data_format)
# Apply convolutions to mask
mask_output = K.conv2d(
masks, self.kernel_mask,
strides=self.strides,
padding='valid',
data_format=self.data_format,
dilation_rate=self.dilation_rate
)
# Apply convolutions to image
img_output = K.conv2d(
(images * masks), self.kernel,
strides=self.strides,
padding='valid',
data_format=self.data_format,
dilation_rate=self.dilation_rate
)
# Calculate the mask ratio on each pixel in the output mask
mask_ratio = self.window_size / (mask_output + 1e-8)
# Clip output to be between 0 and 1
mask_output = K.clip(mask_output, 0, 1)
# Remove ratio values where there are holes
mask_ratio = mask_ratio * mask_output
# Normalize iamge output
img_output = img_output * mask_ratio
# Apply bias only to the image (if chosen to do so)
if self.use_bias:
img_output = K.bias_add(
img_output,
self.bias,
data_format=self.data_format)
# Apply activations on the image
if self.activation is not None:
img_output = self.activation(img_output)
return [img_output, mask_output]
def call(self, inputs):
print(self.kernel)
outputs_plus = K.conv2d(
inputs,
self.kernel,
strides=self.strides,
padding=self.padding,
data_format=self.data_format,
dilation_rate=self.dilation_rate)
outputs_minus = K.conv2d(
inputs,
K.reverse(self.kernel,0),
strides=self.strides,
padding=self.padding,
data_format=self.data_format,
dilation_rate=self.dilation_rate)
if self.use_bias:
outputs_plus = K.bias_add(
outputs_plus,
self.bias,
data_format=self.data_format)
outputs_minus = K.bias_add(
outputs_minus,
self.bias,
data_format=self.data_format)
if self.activation is not None:
return [self.activation(outputs_plus),self.activation(outputs_minus)]
return [outputs_plus,outputs_minus]
def _spectrogram_mono(self, x):
'''x.shape : (None, 1, len_src),
returns 2D batch of a mono power-spectrogram'''
x = K.permute_dimensions(x, [0, 2, 1])
x = K.expand_dims(x, 3) # add a dummy dimension (channel axis)
subsample = (self.n_hop, 1)
output_real = K.conv2d(
x,
self.dft_real_kernels,
strides=subsample,
padding=self.padding,
data_format='channels_last',
)
output_imag = K.conv2d(
x,
self.dft_imag_kernels,
strides=subsample,
padding=self.padding,
data_format='channels_last',
)
output = output_real**2 + output_imag**2
# now shape is (batch_sample, n_frame, 1, freq)
if self.image_data_format == 'channels_last':
output = K.permute_dimensions(output, [0, 3, 1, 2])
else:
output = K.permute_dimensions(output, [0, 2, 3, 1])
return output
def call(self, inputs, mask=None):
def flatten(x):
input_shape = K.shape(x)
output_shape = (input_shape[0], input_shape[1] * input_shape[2],
input_shape[3])
x_flat = K.reshape(x, shape=output_shape)
return (x_flat)
f = K.conv2d(inputs,
kernel=self.kernel_f,
strides=(1, 1),
padding='same')
f = K.bias_add(f, self.bias_f)
g = K.conv2d(inputs,
kernel=self.kernel_g,
strides=(1, 1),
padding='same')
g = K.bias_add(g, self.bias_g)
h = K.conv2d(inputs,
kernel=self.kernel_h,
strides=(1, 1),
padding='same')
h = K.bias_add(h, self.bias_h)
f_flat = flatten(f)
g_flat = flatten(g)
h_flat = flatten(h)
s = tf.matmul(g_flat, f_flat, transpose_b=True)
beta = K.softmax(s, axis=-1)
o = K.reshape(K.batch_dot(beta, h_flat), shape=K.shape(inputs))
x = self.gamma * o + inputs
return (x)
def call(self, inputs):
# Input=[x^H, x^L]
assert len(inputs) == 2
high_input, low_input = inputs
# High -> High conv
high_to_high = K.conv2d(high_input, self.high_to_high_kernel,
strides=self.strides, padding=self.padding,
data_format="channels_last")
# High -> low conv
high_to_low = K.pool2d(high_input, (2, 2), strides=(2, 2), pool_mode="avg")
high_to_low = K.conv2d(high_to_low, self.high_to_low_kernel, strides=self.strides,
padding=self.padding, data_format="channels_last")
# Low -> high conv
low_to_high = K.conv2d(low_input, self.low_to_high_kernel,
strides=self.strides, padding=self.padding,
data_format="channels_last")
low_to_high = K.repeat_elements(low_to_high, 2, axis=1)
low_to_high = K.repeat_elements(low_to_high, 2, axis=2)
# Low -> low conv
low_to_low = K.conv2d(low_input, self.low_to_low_kernel,
strides=self.strides, padding=self.padding,
data_format="channels_last")
# cross add
high_add = high_to_high + low_to_high
low_add = low_to_low + high_to_low
return [high_add, low_add]
def conv_loss(y_true, y_pred):
n = 5
mk = K.constant(value=np.ones((n,n,1,1), dtype=np.float32) / n**2, dtype='float32')
sk = K.constant(value=np.ones((n,n,1,1), dtype=np.float32), dtype='float32')
Bias = K.mean(K.abs(K.conv2d(y_true, mk)-K.conv2d(y_pred, mk)), axis=-1)
Var = K.mean(K.abs((K.conv2d(K.square(y_true), sk) - K.square(K.conv2d(y_true, sk)/n**2))/n**2 - (K.conv2d(K.square(y_pred), sk) - K.square(K.conv2d(y_pred, sk)/n**2))/n**2), axis=-1)
return Var + 4*Bias
def call(self, x):
y = K.conv2d(x, self.conv2d_w1, padding="same")
y = K.bias_add(y, self.conv2d_b1)
y = K.relu(y)
y = K.conv2d(y, self.conv2d_w2, padding="same")
y = K.bias_add(y, self.conv2d_b2)
y = K.relu(y)
y = y + x
return y
def ode_func(self, x, t):
y = self.concat_t(x, t)
y = K.conv2d(y, self.conv2d_w1, padding="same")
y = K.bias_add(y, self.conv2d_b1)
y = K.relu(y)
y = self.concat_t(y, t)
y = K.conv2d(y, self.conv2d_w2, padding="same")
y = K.bias_add(y, self.conv2d_b2)
y = K.relu(y)
return y
def call(self, x):
f = K.conv2d(x, kernel=self.kernel_f, strides=(1, 1), padding='same')
f = K.bias_add(f, self.bias_f)
g = K.conv2d(x, kernel=self.kernel_g, strides=(1, 1), padding='same')
g = K.bias_add(g, self.bias_g)
h = K.conv2d(x, kernel=self.kernel_h, strides=(1, 1), padding='same')
h = K.bias_add(h, self.bias_h)
s = tf.matmul(hw_flatten(g), hw_flatten(f), transpose_b=True)
beta = K.softmax(s, axis=-1) # attention map
o = K.batch_dot(beta, hw_flatten(h)) # [bs, N, C]
o = K.reshape(o, shape=K.int_shape(x)) # [bs, h, w, C]
return self.gamma * o + x
def Active_Contour_Loss(y_true, y_pred):
coef = 1
sober_y_len = K.sum(K.relu(K.conv2d(y_pred, sobel_operator_y, padding='same')))
sober_x_len = K.sum(K.relu(K.conv2d(y_pred, sobel_operator_x, padding='same')))
sober_len = sober_y_len + sober_x_len
area = K.sum(y_pred) + K.epsilon()
shape_metric = sober_len/ area
# shape_metric = tensorflow.keras.backend.print_tensor(shape_metric)
binary_cross_loss = tf.keras.losses.binary_crossentropy(y_pred, y_true)
return binary_cross_loss + coef*shape_metric
def loss(y_true, y_pred):
mse_pointwise = K.mean(mse(y_true, y_pred), axis=(1, 2))
true_vol = K.conv2d(y_pred,
kernel,
strides=(scale, scale),
padding='same')
pred_vol = K.conv2d(y_pred,
kernel,
strides=(scale, scale),
padding='same')
mse_spatial = K.mean(mse(true_vol - input_lr, pred_vol - input_lr),
axis=(1, 2))
return beta * mse_pointwise + (1. - beta) * mse_spatial
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,
output_padding=None)
out_width = deconv_length(self.input_width, self.scaling, self.kernel_size, self.padding,
output_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, conv_width,
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, x, h2_prev, timestep, rand_seed=None):
# NOTE: expected input shape: (batch, height, width, channel)
# init h2 and w
if timestep == 0:
# dirty workaround as glorot_normal won't take None as batch dim
if x.shape[0] == None:
h2_prev = K.random_normal(K.shape(x))
else:
h2_prev = keras.initializers.glorot_normal(seed=rand_seed)(x.shape)
if self.batchnorm: # ReLU with recurrent batchnorm
# calculate gain G(1)[t]
g1 = K.sigmoid(self.bn[timestep*4](K.conv2d(h2_prev, self.u1) + self.b1))
# horizontal inhibition C(1)[t]
if self.channel_sym:
conv_inh = channel_sym_conv2d((g1 * h2_prev), self.w_inh)
else:
conv_inh = K.conv2d((g1 * h2_prev), self.w_inh, padding='same')
c1 = self.bn[timestep*4+1](conv_inh)
# apply gain gate and inhibition to get H(1)[t]
h1 = K.relu(x - K.relu(c1 * (self.alpha * h2_prev + self.mu)))
# mix gate G(2)[t]
g2 = K.sigmoid(self.bn[timestep*4+2](K.conv2d(h1, self.u2) + self.b2))
# horizontal excitation C(2)[t]
if self.channel_sym:
conv_exc = channel_sym_conv2d(h1, self.w_exc)
else:
conv_exc = K.conv2d(h1, self.w_exc , padding='same')
c2 = self.bn[timestep*4+3](conv_exc)
# output candidate H_tilda(2)[t] via excitation
h2_tilda = K.relu(self.kappa * h1 + self.beta * c2 + self.omega * h1 * c2)
# apply mix gate to get H(2)[t]
h2_t = g2 * h2_tilda + (1 - g2) * h2_prev
else: # tanh with timestep weights, no batchnorm except at g2
g1 = K.sigmoid(K.conv2d(h2_prev, self.u1) + self.b1)
if self.channel_sym:
c1 = channel_sym_conv2d((g1 * h2_prev), self.w_inh)
else:
c1 = K.conv2d((g1 * h2_prev), self.w_inh, padding='same')
h1 = K.tanh(x - c1 * (self.alpha * h2_prev + self.mu))
g2 = K.sigmoid(self.bn[timestep*4+2](K.conv2d(h1, self.u2) + self.b2))
if self.channel_sym:
c2 = channel_sym_conv2d(h1, self.w_exc)
else:
c2 = K.conv2d(h1, self.w_exc , padding='same')
h2_tilda = K.tanh(self.kappa * h1 + self.beta * c2 + self.omega * h1 * c2)
h2_t = self.eta[timestep] * (g2 * h2_tilda + (1 - g2) * h2_prev)
return h2_t
def call(self, x):
# soft-assignment.
s = K.conv2d(x, self.kernel, padding='same') + self.bias
print('s.shape=', s.shape)
a = K.softmax(s)
self.amap = K.argmax(a, -1)
# print 'amap.shape', self.amap.shape
# Dims used hereafter: batch, H, W, desc_coeff, cluster
a = K.expand_dims(a, -2)
# print 'a.shape=',a.shape
# Core
v = K.expand_dims(x, -1) + self.C
# print 'v.shape', v.shape
v = a * v
# print 'v.shape', v.shape
v = K.sum(v, axis=[1, 2])
# print 'v.shape', v.shape
v = K.permute_dimensions(v, pattern=[0, 2, 1])
# print 'v.shape', v.shape
#v.shape = None x K x D
# Normalize v (Intra Normalization)
v = K.l2_normalize(v, axis=-1)
v = K.batch_flatten(v)
v = K.l2_normalize(v, axis=-1)
# return [v, self.amap]
return v
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[0] * input_shape[1], 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))
conv = K.conv2d(input_tensor_reshaped, self.W, (self.strides, self.strides),
padding=self.padding, data_format='channels_last')
votes_shape = K.shape(conv)
_, conv_height, conv_width, _ = conv.get_shape()
votes = K.reshape(conv, [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, conv_width,
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, [conv_height, conv_width, 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 conv2d(x,
kernel,
strides=(1, 1),
padding='valid',
data_format='channels_first',
image_shape=None,
filter_shape=None):
"""2D convolution.
# Arguments
x: Input tensor
kernel: kernel tensor.
strides: strides tuple.
padding: string, "same" or "valid".
data_format: 'channels_first' or 'channels_last'.
Whether to use Theano or TensorFlow dimension
ordering in inputs/kernels/ouputs.
image_shape: Optional, the input tensor shape
filter_shape: Optional, the kernel shape.
# Returns
x convolved with the kernel.
# Raises
Exception: In case of invalid border mode or data format.
"""
return K.conv2d(x, kernel, strides, padding, data_format)
def call(self, inputs, training=None):
"""
Calls the layer on some input. If training,
updates the `u` parameter with revised estimates
of the right singular vector.
"""
W_bar = spectrally_normalize_weight(
weight=self.kernel,
right_singular_vector=self.u,
training=training,
epsilon=self.epsilon,
)
outputs = K.conv2d(
inputs,
W_bar,
strides=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 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 _conv_gaussian(self, inputs: tf.Tensor) -> tf.Tensor:
""" Perform Gaussian convolution on a batch of images.
Parameters
----------
inputs: :class:`tf.Tensor`
The input batch of images to perform Gaussian convolution on.
Returns
-------
:class:`tf.Tensor`
The convolved images
"""
channels = K.int_shape(inputs)[-1]
gauss = K.tile(self._gaussian_kernel, (1, 1, 1, channels))
# TF doesn't implement replication padding like pytorch. This is an inefficient way to
# implement it for a square guassian kernel
size = self._gaussian_kernel.shape[1] // 2
padded_inputs = inputs
for _ in range(size):
padded_inputs = tf.pad(
padded_inputs, # noqa,pylint:disable=no-value-for-parameter,unexpected-keyword-arg
([0, 0], [1, 1], [1, 1], [0, 0]),
mode="SYMMETRIC")
retval = K.conv2d(padded_inputs, gauss, strides=1, padding="valid")
return retval
def normalize_inference():
dconvs = K.depthwise_conv2d(inputs,
self.depthwise_kernel,
strides=self.strides,
padding=self.padding,
data_format='channels_last')
# dconvs = K.clip(dconvs, min_value=0, max_value=self.max_activity)
dconvs = K.clip(dconvs,
min_value=-self.max_activity_signed,
max_value=self.max_activity_signed)
convs = K.conv2d(dconvs,
self.kernel * self.w_scale,
strides=(1, 1),
padding=self.padding,
data_format='channels_last',
dilation_rate=self.dilation_rate)
convs = K.bias_add(convs,
self.bias * self.w_scale,
data_format='channels_last')
# outputs = convs
# outputs = K.clip(convs, min_value=-self.max_activity_signed, max_value=self.max_activity_signed)
outputs = K.clip(convs, min_value=0, max_value=self.max_activity)
return K.round(outputs * 2**
self.L_A[1]) * 2**-self.L_A[1] # naechster Nachbar
def call(self, x):
# Calculate the pairwise distances between the codewords and the feature vectors
x_square = K.sum(x ** 2, axis=3, keepdims=True)
y_square = K.sum(self.V ** 2, axis=2, keepdims=True)
dists = x_square + y_square - 2 * K.conv2d(x, self.V, strides=(1, 1), padding='valid')
dists = K.maximum(dists, 0)
# Quantize the feature vectors
quantized_features = K.softmax(- dists / (self.sigmas ** 2))
# Compile the histogram
if self.spatial_level == 0:
histogram = K.mean(quantized_features, [1, 2])
elif self.spatial_level == 1:
shape = K.shape(quantized_features)
mid_1 = K.cast(shape[1] / 2, 'int32')
mid_2 = K.cast(shape[2] / 2, 'int32')
histogram1 = K.mean(quantized_features[:, :mid_1, :mid_2, :], [1, 2])
histogram2 = K.mean(quantized_features[:, mid_1:, :mid_2, :], [1, 2])
histogram3 = K.mean(quantized_features[:, :mid_1, mid_2:, :], [1, 2])
histogram4 = K.mean(quantized_features[:, mid_1:, mid_2:, :], [1, 2])
histogram = K.stack([histogram1, histogram2, histogram3, histogram4], 1)
histogram = K.reshape(histogram, (-1, 4 * self.N_k))
else:
# No other spatial level is currently supported (it is trivial to extend the code)
assert False
# Simple trick to avoid rescaling issues
return histogram * self.N_k
def call(self, x, training=None):
W_shape = self.kernel.shape
if training:
W_bar, _u, sigma = spectral_normalization(
self.kernel, self.u, niter=self.niter_spectral)
self.sig.assign(sigma)
self.u.assign(_u)
else:
W_reshaped = K.reshape(self.kernel, [-1, W_shape[-1]])
W_bar = W_reshaped / self.sig
W_bar = bjorck_normalization(W_bar, niter=self.niter_bjorck)
W_bar = W_bar * self._get_coef()
W_bar = K.reshape(W_bar, W_shape)
outputs = K.conv2d(
x,
W_bar,
strides=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,input):
y = K.conv2d(input, self.kernel, strides=(1, 1), padding='same', data_format="channels_last",
dilation_rate=(1, 1))
y = K.relu(y)
y = tf.depth_to_space(y, self.scale)
y = K.pool2d(y, pool_size=(self.scale,self.scale), strides=(1, 1), padding='same', data_format="channels_last", pool_mode='avg')
return y
def mean_yhat(y_true, y_pred):
n = 5
mk = K.constant(value=np.ones((n,n,1,1), dtype=np.float32) / n**2, dtype='float32')
Mean = K.mean(K.conv2d(y_pred, mk), axis=-1)
return Mean
