def call(self, inputs):
if self._horch_impl:
inputs = inputs[:, ::2, ::2, :]
outputs = backend.depthwise_conv2d(inputs,
self.depthwise_kernel,
strides=(1, 1),
padding='valid',
dilation_rate=(1, 1),
data_format=self.data_format)
else:
outputs = backend.depthwise_conv2d(
inputs,
self.depthwise_kernel,
strides=self.strides,
padding=self.padding,
dilation_rate=self.dilation_rate,
data_format=self.data_format)
if self.use_bias:
outputs = backend.bias_add(outputs,
self.bias,
data_format=self.data_format)
if self.activation is not None:
return self.activation(outputs)
return outputs
def call(self, x):
x = K.depthwise_conv2d(x,
self.blur_kernel,
padding='same',
strides=(self.pool_size, self.pool_size))
return x
def call(self, input_tensor):
"""
Calls the tensor for forward pass operation.
:param input_tensor: The input dataset of 2D images with shape of `(batch_shape, rows, cols, channels)`.
:return: 4D tensor with shape: `(batch_shape, rows, cols, input_image_channels * 4)` for 'concat' merge mode.
4D tensor with shape: `(batch_shape, rows, cols, output_conv_filter)` for 'convolution' merge mode.
"""
input_tensor = K.cast(tf.identity(input_tensor), tf.float32)
result_tensors_list_img = []
for direction, kernel in self.kernel_dic.items():
res_sum = tf.identity(input_tensor)
tensor = tf.identity(input_tensor)
for i in range(self.seq_length):
conv = K.depthwise_conv2d(x=tensor,
depthwise_kernel=kernel *
self.kernel_switch_dic[direction],
padding='same')
tensor = self.activation(conv)
res_sum += tensor
result_tensors_list_img.append(res_sum)
result_tensors_list_img = K.concatenate(result_tensors_list_img,
axis=-1)
if self.merge_mode == 'convolution':
result_tensors_list_img = K.conv2d(x=result_tensors_list_img,
kernel=self.conv_kernel,
padding='same')
result_tensors_list_img = self.activation(result_tensors_list_img)
return result_tensors_list_img
def call(self, x):
x = tf.nn.pool(x, (self.pool_size, self.pool_size),
strides=(1, 1), padding='SAME', pooling_type='MAX', data_format='NHWC')
x = K.depthwise_conv2d(x, self.blur_kernel, padding='same', strides=(self.pool_size, self.pool_size))
return x
def call(self, inputs):
x, kernel = inputs
# kernel = kernel[:, 4:-4, 4:-4]
n, xh, xw, c = x.shape
x = tf.transpose(x, (1, 2, 0, 3))
x = K.reshape(x, (1, xh, xw, -1))
n, kh, kw, c = kernel.shape
# kernel = K.reshape(kernel, (-1, kh * kw * c))
# kernel = K.softmax(kernel)
# print('softmax.kernel.shape:', kernel.shape)
# kernel = K.reshape(kernel, (-1, kh, kw, c))
print('kernel.shape:', kernel.shape)
kernel = tf.transpose(kernel, (1, 2, 0, 3))
kernel = K.reshape(kernel, (kh, kw, -1, 1))
print('kernel.shape:', kernel.shape)
print('x.shape:', x.shape)
# https://www.tensorflow.org/api_docs/python/tf/nn/depthwise_conv2d
out = K.depthwise_conv2d(x, kernel)
print('out.shape:', out.shape)
_, oh, ow, _ = out.shape
out = K.reshape(out, (oh, ow, -1, c))
out = tf.transpose(out, (2, 0, 1, 3))
return out
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 gaussian_kernel_layer(inputs, sigma=1):
kfilter = get_kernel_filter(inputs.shape[-1], sigma)
kernel = tf.Variable(
initial_value=kfilter,
trainable=False, dtype=tf.float64)
out = K.depthwise_conv2d(tf.cast(inputs, tf.float64), kfilter, padding='same')
return out
def scharr_edges(image, magnitude):
""" Returns a tensor holding modified Scharr edge maps.
Parameters
----------
image: tensor
Image tensor with shape [batch_size, h, w, d] and type float32. The image(s) must be 2x2
or larger.
magnitude: bool
Boolean to determine if the edge magnitude or edge direction is returned
Returns
-------
tensor
Tensor holding edge maps for each channel. Returns a tensor with shape `[batch_size, h, w,
d, 2]` where the last two dimensions hold `[[dy[0], dx[0]], [dy[1], dx[1]], ..., [dy[d-1],
dx[d-1]]]` calculated using the Scharr filter.
"""
# Define vertical and horizontal Scharr filters.
static_image_shape = image.shape.dims if get_backend(
) == "amd" else image.get_shape()
image_shape = K.shape(image)
# 5x5 modified Scharr kernel ( reshape to (5,5,1,2) )
matrix = np.array([[[[0.00070, 0.00070]], [[0.00520, 0.00370]],
[[0.03700, 0.00000]], [[0.00520, -0.0037]],
[[0.00070, -0.0007]]],
[[[0.00370, 0.00520]], [[0.11870, 0.11870]],
[[0.25890, 0.00000]], [[0.11870, -0.1187]],
[[0.00370, -0.0052]]],
[[[0.00000, 0.03700]], [[0.00000, 0.25890]],
[[0.00000, 0.00000]], [[0.00000, -0.2589]],
[[0.00000, -0.0370]]],
[[[-0.0037, 0.00520]], [[-0.1187, 0.11870]],
[[-0.2589, 0.00000]], [[-0.1187, -0.1187]],
[[-0.0037, -0.0052]]],
[[[-0.0007, 0.00070]], [[-0.0052, 0.00370]],
[[-0.0370, 0.00000]], [[-0.0052, -0.0037]],
[[-0.0007, -0.0007]]]])
num_kernels = [2]
kernels = K.constant(matrix, dtype='float32')
kernels = K.tile(kernels, [1, 1, image_shape[-1], 1])
# Use depth-wise convolution to calculate edge maps per channel.
# Output tensor has shape [batch_size, h, w, d * num_kernels].
pad_sizes = [[0, 0], [2, 2], [2, 2], [0, 0]]
padded = pad(image, pad_sizes, mode='REFLECT')
output = K.depthwise_conv2d(padded, kernels)
if not magnitude: # direction of edges
# Reshape to [batch_size, h, w, d, num_kernels].
shape = K.concatenate([image_shape, num_kernels], axis=0)
output = K.reshape(output, shape=shape)
output.set_shape(static_image_shape.concatenate(num_kernels))
output = tf.atan(
K.squeeze(output[:, :, :, :, 0] / output[:, :, :, :, 1],
axis=None))
# magnitude of edges -- unified x & y edges don't work well with Neural Networks
return output
def call(self, x):
x = K.expand_dims(x, axis=-2)
x = K.depthwise_conv2d(x,
self.blur_kernel,
padding='same',
strides=(self.pool_size, self.pool_size))
x = K.squeeze(x, axis=-2)
return x
def gaussian_kernel_layer(inputs, sigma=1):
# print(sigma)
kfilter = get_kernel_filter(inputs.shape[-1], sigma)
kfilter = tf.convert_to_tensor(np.float32(kfilter))
kernel = tf.Variable(
initial_value=kfilter,
trainable=False)
# out = K.depthwise_conv2d(tf.cast(inputs, tf.float64), kfilter, padding='same')
out = K.depthwise_conv2d(inputs, kfilter, padding='same')
# out = tf.cast(out, tf.float32)
return out
def sobel_func(batch ):
batch=tf.image.rgb_to_grayscale(batch)
filt=expandedSobel(batch)
#calculate the sobel filters for yTrue and yPred
#this generates twice the number of input channels
#a X and Y channel for each input channel
batch = K.depthwise_conv2d(batch,filt)
resize = tf.keras.Sequential([layers.experimental.preprocessing.Resizing(height=IMG_SIZE,width=IMG_SIZE)])
batch=resize(batch)
batch=batch[:,:,:,0]
batch=tf.expand_dims(batch,axis=3)
return batch
def laplacian_func(batch,filt=laplacianFilter):
#get the sobel filter repeated for each input channel
#filt = expandedLaplacian(batch)
batch=tf.image.rgb_to_grayscale(batch)
#calculate the sobel filters for yTrue and yPred
#this generates twice the number of input channels
#a X and Y channel for each input channel
laplacian = K.depthwise_conv2d(batch,filt)
resize = tf.keras.Sequential([layers.experimental.preprocessing.Resizing(height=IMG_SIZE,width=IMG_SIZE)])
batch=resize(batch)
return batch
#now you just apply the mse:
return laplacian
def call(self, x):
x = tf.nn.pool(x, (self.pool_size, ),
strides=(1, ),
padding='SAME',
pooling_type='AVG',
data_format='NWC')
x = K.expand_dims(x, axis=-2)
x = K.depthwise_conv2d(x,
self.blur_kernel,
padding='same',
strides=(self.pool_size, self.pool_size))
x = K.squeeze(x, axis=-2)
return x
def _depthwise_conv2d(cls, image: tf.Tensor, kernel: tf.Tensor) -> tf.Tensor:
""" Perform a standardized depthwise convolution.
Parameters
----------
image: :class:`tf.Tensor`
Batch of images, channels last, to perform depthwise convolution
kernel: :class:`tf.Tensor`
convolution kernel
Returns
-------
:class:`tf.Tensor`
The output from the convolution
"""
return K.depthwise_conv2d(image, kernel, strides=(1, 1), padding="valid")
def training_phase():
# Depthwise-Conv mit Soft-Relu
dconvs = K.depthwise_conv2d(inputs,
self.depthwise_kernel,
strides=self.strides,
padding=self.padding,
data_format='channels_last')
# dconvs = tf.where(dconvs<=2**(-self.L_A[1]-1), tf.zeros_like(dconvs), dconvs)
# factor2 = 0.9*self.max_activity
# dconvs = K.minimum(dconvs, 0.1*dconvs+factor2)
factor2 = 0.9 * self.max_activity_signed
dconvs = K.minimum(dconvs, 0.1 * dconvs + factor2)
dconvs = K.maximum(dconvs, 0.1 * dconvs - factor2)
# Pointwise-Conv
convs = K.conv2d(dconvs,
self.kernel,
strides=(1, 1),
padding=self.padding,
data_format='channels_last',
dilation_rate=self.dilation_rate)
convs = K.bias_add(convs, self.bias, data_format='channels_last')
# Skalierung
scale1 = K.abs(self.max_activity_x /
(K.max(K.abs(convs), axis=(0, 1, 2)) + 1e-6))
indizes = K.greater(scale1, self.max_scale)
scale1 = self.w_scale * tf.to_float(indizes) + tf.to_float(
~indizes) * scale1
scale2 = self.max_weight / (K.maximum(
tf.abs(self.bias),
tf.reduce_max(tf.abs(self.kernel), axis=(0, 1, 2))) + 1e-6)
scale = K.minimum(scale1, scale2)
self.add_update(
K.moving_average_update(self.w_scale, scale, self.momentum),
inputs)
# Softclipped-linear
outputs = convs * self.w_scale
# outputs = K.clip(outputs, min_value=-self.max_activity_signed, max_value=self.max_activity_signed)
outputs = tf.where(outputs <= 2**(-self.L_A[1] - 1),
tf.zeros_like(outputs), outputs)
outputs = K.minimum(outputs, 0.1 * outputs + factor2)
return outputs
def call(self, inputs, training=None):
outputs = K.depthwise_conv2d(
inputs,
self.depthwise_kernel,
strides=self.strides,
padding=self.padding,
dilation_rate=self.dilation_rate,
data_format=self.data_format)
if self.bias:
outputs = K.bias_add(
outputs, self.bias, data_format=self.data_format)
if self.activation is not None:
return self.activation(outputs)
return outputs
def call(self, inputs, training=None):
if self.quant_mode not in [None, 'extrinsic', 'hybrid', 'intrinsic']:
raise ValueError(
'Invalid quantization mode. The \'quant_mode\' argument must be one of \'extrinsic\' , \'intrinsic\' , \'hybrid\' or None.'
)
# set quantizer
if isinstance(self.quantizer, list) and len(self.quantizer) == 3:
quantizer_input = self.quantizer[0]
quantizer_weight = self.quantizer[1]
quantizer_output = self.quantizer[2]
else:
quantizer_input = self.quantizer
quantizer_weight = self.quantizer
quantizer_output = self.quantizer
# quantize kernel
if self.quant_mode in ['hybrid', 'intrinsic']:
inputs = quantizer_input.quantize(inputs)
# quantize input
if self.quant_mode in ['hybrid', 'intrinsic']:
quantized_depthwise_kernel = quantizer_weight.quantize(
self.depthwise_kernel)
# depthwise convolution 2D layer call
if self.quant_mode == 'intrinsic':
strides = (1, self.strides[0], self.strides[1], 1)
dilation_rate = (1, self.dilation_rate[0], self.dilation_rate[1],
1)
outputs = QuantizedDepthwiseConv2DCore(
inputs, quantized_depthwise_kernel, strides, dilation_rate,
self.padding, self.data_format, quantizer_output)
elif self.quant_mode == 'hybrid':
outputs = K.depthwise_conv2d(inputs,
quantized_depthwise_kernel,
strides=self.strides,
padding=self.padding,
dilation_rate=self.dilation_rate,
data_format=self.data_format)
outputs = quantizer_output.quantize(outputs)
elif self.quant_mode in ['extrinsic', None]:
outputs = K.depthwise_conv2d(inputs,
self.depthwise_kernel,
strides=self.strides,
padding=self.padding,
dilation_rate=self.dilation_rate,
data_format=self.data_format)
# add bias
if self.use_bias:
if self.quant_mode in ['hybrid', 'intrinsic']:
quantized_bias = quantizer_weight.quantize(self.bias)
outputs = K.bias_add(outputs,
quantized_bias,
data_format=self.data_format)
outputs = quantizer_output.quantize(outputs)
elif self.quant_mode in ['extrinsic', None]:
outputs = K.bias_add(outputs,
self.bias,
data_format=self.data_format)
# activation function
if self.activation is not None:
outputs = self.activation(outputs)
# quantize output
if self.quant_mode in ['extrinsic', 'hybrid', 'intrinsic']:
outputs = quantizer_output.quantize(outputs)
return outputs
def gaussian_kernel_layer(inputs, kfilter):
kernel = tf.Variable(
initial_value=kfilter,
trainable=False, dtype=tf.float64)
out = K.depthwise_conv2d(tf.cast(inputs, tf.float64), kfilter, padding='same')
return out"""
