def build(self, input_shape):
self.h_i, self.w_i, self.ch_i, self.n_i = input_shape[1:5]
self.h_j, self.w_j = [conv_utils.conv_output_length(input_shape[i + 1],
self.kernel_size[i],
padding=self.padding,
stride=self.strides[i],
dilation=self.dilation_rate[i]) for i in (0, 1)]
self.ah_j, self.aw_j = [conv_utils.conv_output_length(input_shape[i + 1],
self.kernel_size[i],
padding=self.padding,
stride=1,
dilation=self.dilation_rate[i]) for i in (0, 1)]
self.w_shape = self.kernel_size + (self.ch_i, self.n_i,
self.ch_j, self.n_j)
self.w = self.add_weight(shape=self.w_shape,
initializer=self.kernel_initializer,
name='kernel',
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.built = True
def compute_output_shape(self, input_shape):
if self.data_format == 'channels_last':
space = input_shape[1:-1]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
self.kernel_size[i],
padding=self.padding,
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
out_filters = input_shape[3] * self.depth_multiplier
return (input_shape[0], ) + tuple(new_space) + (out_filters, )
if self.data_format == 'channels_first':
space = input_shape[2:]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
self.kernel_size[i],
padding=self.padding,
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
out_filters = input_shape[1] * self.depth_multiplier
return (input_shape[0], out_filters) + tuple(new_space)
def compute_output_shape(self, input_shape):
if self.data_format == 'channels_last':
space = input_shape[1:-1]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(space[i],
self.kernel_size[i],
padding=self.padding,
stride=self.strides[i])
new_space.append(new_dim)
if (self.output_format == 'image'):
return (input_shape[0], ) + tuple(new_space) + (
self.filters, ) + (1, )
else:
return (input_shape[0], ) + tuple(new_space) + (self.filters, )
if self.data_format == 'channels_first':
raise NotImplementedError(
"Output formate image/signal not handled")
space = input_shape[2:]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(space[i],
self.kernel_size[i],
padding=self.padding,
stride=self.strides[i])
new_space.append(new_dim)
return (input_shape[0], self.filters) + tuple(new_space)
def compute_output_shape(self, input_shape):
if self.data_format == 'channels_first':
depth = input_shape[2]
rows = input_shape[3]
cols = input_shape[4]
out_filters = self.groups * self.depth_multiplier
elif self.data_format == 'channels_last':
depth = input_shape[1]
rows = input_shape[2]
cols = input_shape[3]
out_filters = self.groups * self.depth_multiplier
depth = conv_utils.conv_output_length(depth, self.kernel_size[0],
self.padding, self.strides[0])
rows = conv_utils.conv_output_length(rows, self.kernel_size[1],
self.padding, self.strides[1])
cols = conv_utils.conv_output_length(cols, self.kernel_size[2],
self.padding, self.strides[2])
if self.data_format == 'channels_first':
return (input_shape[0], out_filters, depth, rows, cols)
elif self.data_format == 'channels_last':
return (input_shape[0], depth, rows, cols, out_filters)
def compute_output_shape(self, input_shape):
input_shapes = input_shape
assert (input_shapes[0] == input_shapes[1])
input_shape = input_shapes[0]
if self.data_format == 'channels_last':
space = input_shape[1:-1]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
self.kernel_size[i],
padding=self.padding,
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
single_shape = (input_shape[0], ) + tuple(new_space) + (
self.filters, )
elif self.data_format == 'channels_first':
space = input_shape[2:]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
self.kernel_size[i],
padding=self.padding,
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
single_shape = (input_shape[0], self.filters) + tuple(new_space)
else:
raise ValueError('Invalid data format: ' + self.data_format)
return [single_shape] * 2
def compute_output_shape(self, input_shapes):
if K.image_data_format() == 'channels_first':
space = input_shapes[2:]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
self._kernel_shape[i],
padding=self._padding,
stride=self._strides[i],
dilation=self._rates[i])
new_space.append(new_dim)
if K.image_data_format() == 'channels_last':
space = input_shapes[1:-1]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
self._kernel_shape[i],
padding=self._padding,
stride=self._strides[i],
dilation=self._rates[i])
new_space.append(new_dim)
return ((input_shapes[0], ) + tuple(new_space) +
(np.product(self._kernel_shape) * self._depth, ))
def compute_output_shape(self, input_shape):
if self.data_format == 'channels_last':
space = input_shape[1:-1]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(space[i], self.kernel_size[i],
padding=self.padding,
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
return (input_shape[0],) + tuple(new_space) + (self.filters,)
elif self.data_format == 'channels_first':
space = input_shape[2:]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(space[i], self.kernel_size[i],
padding=self.padding,
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
return (input_shape[0], self.filters) + tuple(new_space)
else:
raise ValueError('Invalid `data_format`. Expected one of: "channels_first", "channels_last".')
def compute_output_shape(self, input_shape):
kernel_size = list(self.kernel_size)
if self.kernel_size[0] % 2:
kernel_size[0] = kernel_size[0] * 2 - 1
else:
kernel_size[0] = kernel_size[0] * 2
kernel_size = tuple(kernel_size)
if self.data_format == 'channels_last':
space = input_shape[1:-1]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
kernel_size[i],
padding=self.padding,
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
return (input_shape[0], ) + tuple(new_space) + (self.filters, )
if self.data_format == 'channels_first':
space = input_shape[2:]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
kernel_size[i],
padding=self.padding,
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
return (input_shape[0], self.filters) + tuple(new_space)
def compute_output_shape(self, input_shape):
sample_space = (-1, ) + tuple(input_shape[1:-3])
if self.data_format == 'channels_last':
space = input_shape[-3:-1]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
self.kernel_size[i],
padding=self.padding,
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
return sample_space + tuple(new_space) + (self.filters, )
if self.data_format == 'channels_first':
space = input_shape[-2:]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
self.kernel_size[i],
padding=self.padding,
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
return sample_space + (self.filters, ) + tuple(new_space)
def compute_output_shape(self, input_shape):
if self.data_format == 'channels_last':
space = input_shape[0][1:-1]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
self.kernel_size[i],
padding='same',
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
new_shape = (input_shape[0][0], ) + tuple(new_space) + (
self.filters, )
return [new_shape, new_shape]
if self.data_format == 'channels_first':
space = input_shape[2:]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
self.kernel_size[i],
padding='same',
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
new_shape = (input_shape[0], self.filters) + tuple(new_space)
return [new_shape, new_shape]
def compute_output_shape(self, input_shape):
if self.data_format == "channels_first":
rows = input_shape[2]
cols = input_shape[3]
out_filters = input_shape[1] * self.depth_multiplier
elif self.data_format == "channels_last":
rows = input_shape[1]
cols = input_shape[2]
out_filters = input_shape[3] * self.depth_multiplier
rows = conv_utils.conv_output_length(
rows,
self.kernel_size[0],
self.padding,
self.strides[0],
self.dilation_rate[0],
)
cols = conv_utils.conv_output_length(
cols,
self.kernel_size[1],
self.padding,
self.strides[1],
self.dilation_rate[1],
)
if self.data_format == "channels_first":
return (input_shape[0], out_filters, rows, cols)
elif self.data_format == "channels_last":
return (input_shape[0], rows, cols, out_filters)
def compute_output_shape(self, input_shape):
if self.data_format == 'channels_last':
space = input_shape[1:-1]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
self.kernel_size[i],
padding=self.padding,
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
return (input_shape[0], ) + tuple(new_space) + (self.filters, )
if self.data_format == 'channels_first':
space = input_shape[2:]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
self.kernel_size[i],
padding=self.padding,
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
return (input_shape[0], self.filters) + tuple(new_space)
else:
raise ValueError(
'The data format should be defined. Found `None`.')
def compute_output_shape(self, input_shape):
input_shape = tf.TensorShape(input_shape).as_list()
if self.data_format == "channels_first":
len_dim1 = input_shape[2]
len_dim2 = input_shape[3]
len_dim3 = input_shape[4]
else:
len_dim1 = input_shape[1]
len_dim2 = input_shape[2]
len_dim3 = input_shape[3]
len_dim1 = conv_utils.conv_output_length(
len_dim1, self.pool_size[0], self.padding, self.strides[0]
)
len_dim2 = conv_utils.conv_output_length(
len_dim2, self.pool_size[1], self.padding, self.strides[1]
)
len_dim3 = conv_utils.conv_output_length(
len_dim3, self.pool_size[2], self.padding, self.strides[2]
)
if self.data_format == "channels_first":
return tf.TensorShape(
[input_shape[0], input_shape[1], len_dim1, len_dim2, len_dim3]
)
else:
return tf.TensorShape(
[input_shape[0], len_dim1, len_dim2, len_dim3, input_shape[4]]
)
def compute_output_shape(self, input_shape):
if self.data_format == 'channels_last':
space = input_shape[1:-1]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
self.kernel_size[i],
padding=self.padding,
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
return (input_shape[0],) + tuple(new_space) + (self.filters,)
if self.data_format == 'channels_first':
space = input_shape[2:]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
self.kernel_size[i],
padding=self.padding,
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
return (input_shape[0], self.filters) + tuple(new_space)
def build(self, input_shape):
# input shape
if self.data_format == 'channels_first':
chn_dim = input_shape[1]
len_dim1 = input_shape[2]
len_dim2 = input_shape[3]
len_dim3 = input_shape[4]
elif self.data_format == 'channels_last':
len_dim1 = input_shape[1]
len_dim2 = input_shape[2]
len_dim3 = input_shape[3]
chn_dim = input_shape[4]
odim = (len_dim1, len_dim2, len_dim3, chn_dim)
# computer the out shape
len_dim1 = conv_utils.conv_output_length(len_dim1, self.pool_size[0],
self.padding, self.strides[0])
len_dim2 = conv_utils.conv_output_length(len_dim2, self.pool_size[1],
self.padding, self.strides[1])
len_dim3 = conv_utils.conv_output_length(len_dim3, self.pool_size[2],
self.padding, self.strides[2])
if self.data_format == 'channels_first':
self.output_dim = (input_shape[0], input_shape[1], len_dim1,
len_dim2, len_dim3)
shape_2d_0 = (chn_dim, odim[0] * odim[1], odim[2])
shape_1d_1 = (chn_dim, odim[0] * len_dim2 * len_dim3)
shape_f = (chn_dim, len_dim1, len_dim2, len_dim3)
elif self.data_format == 'channels_last':
self.output_dim = (input_shape[0], len_dim1, len_dim2, len_dim3,
input_shape[4])
shape_2d_0 = (odim[0] * odim[1], odim[2], chn_dim)
shape_2d_1 = (odim[0], len_dim2 * len_dim3, chn_dim)
shape_f = (len_dim1, len_dim2, len_dim3, chn_dim)
# a list of layers needed for 3D MaxPooling
(p1, p2, p3) = self.pool_size
self.layers = []
self.layers.append(Reshape(shape_2d_0))
self.layers.append(
MaxPooling2D(
pool_size=(p2, p3), #strides=self.strides,
padding=self.padding,
data_format=self.data_format))
self.layers.append(Reshape(shape_2d_1))
self.layers.append(
MaxPooling2D(
pool_size=(p1, 1), #strides=self.strides,
padding=self.padding,
data_format=self.data_format))
self.layers.append(Reshape(shape_f))
super(MaxPooling3D, self).build(input_shape)
def compute_output_shape(self, input_shape):
padding = 'same'
rows = input_shape[1]
cols = input_shape[2]
rows = conv_utils.conv_output_length(rows, self.pool_size[0], padding,
self.strides[0])
cols = conv_utils.conv_output_length(cols, self.pool_size[1], padding,
self.strides[1])
return (input_shape[0], rows, cols, input_shape[3])
def test_output_shape(self):
result = self.model.predict(self.data)
final_x_length = conv_output_length(self.conv_x_length,
self.mask_kernel[0], self.padding,
self.mask_strides[0])
final_y_length = conv_output_length(self.conv_y_length,
self.mask_kernel[1], self.padding,
self.mask_strides[1])
feature_size = self.filters * final_x_length * final_y_length
self.assertEqual(result.shape, (self.batch_size, feature_size))
def _get_output_shape(self, input_shape):
input_row, input_col, _ = self._get_input_shape(input_shape)
output_row = conv_utils.conv_output_length(input_row,
self.kernel_size[0],
self.padding,
self.strides[0])
output_col = conv_utils.conv_output_length(input_col,
self.kernel_size[1],
self.padding,
self.strides[1])
return (input_shape[0], output_row, output_col, self.filters)
def test_conv_input_length():
assert conv_utils.conv_input_length(None, 7, 'same', 1) is None
assert conv_utils.conv_input_length(112, 7, 'same', 1) == 112
assert conv_utils.conv_input_length(112, 7, 'same', 2) == 223
assert conv_utils.conv_input_length(28, 5, 'valid', 1) == 32
assert conv_utils.conv_input_length(14, 5, 'valid', 2) == 31
assert conv_utils.conv_input_length(36, 5, 'full', 1) == 32
assert conv_utils.conv_input_length(18, 5, 'full', 2) == 31
with pytest.raises(AssertionError):
conv_utils.conv_output_length(18, 5, 'diagonal', 2)
def test_output_shape(self):
result = self.model.predict(self.data)
x_window_length = conv_output_length(self.x, self.kernel[0],
self.padding, self.strides[0])
y_window_length = conv_output_length(self.y, self.kernel[1],
self.padding, self.strides[1])
z_window_length = conv_output_length(self.z, self.kernel[2],
self.padding, self.strides[2])
self.assertEqual(result.shape,
(self.batch_size, x_window_length, y_window_length,
z_window_length, self.filters))
def test_conv_input_length():
assert conv_utils.conv_input_length(None, 7, 'same', 1) is None
assert conv_utils.conv_input_length(112, 7, 'same', 1) == 112
assert conv_utils.conv_input_length(112, 7, 'same', 2) == 223
assert conv_utils.conv_input_length(28, 5, 'valid', 1) == 32
assert conv_utils.conv_input_length(14, 5, 'valid', 2) == 31
assert conv_utils.conv_input_length(36, 5, 'full', 1) == 32
assert conv_utils.conv_input_length(18, 5, 'full', 2) == 31
with pytest.raises(AssertionError):
conv_utils.conv_output_length(18, 5, 'diagonal', 2)
def compute_output_shape(self, input_shape):
batch_size = input_shape[0]
h_axis, w_axis = 1, 2
stride_h, stride_w = self.strides
height, width = input_shape[h_axis], input_shape[w_axis]
kernel_h, kernel_w = self.kernelSize
out_height = conv_utils.conv_output_length(height, kernel_h, self.padding, stride_h)
out_width = conv_utils.conv_output_length(width, kernel_w, self.padding, stride_w)
output_shape = (batch_size, out_height, out_width, self.nOutputPlane)
#print(output_shape)
return output_shape
def compute_output_shape(self,input_shape):
rows = input_shape[1]
cols = input_shape[2]
rows = conv_utils.conv_output_length(rows, self.kernel_size[0],
self.padding,
self.strides[0])
cols = conv_utils.conv_output_length(cols, self.kernel_size[1],
self.padding,
self.strides[1])
return (input_shape[0],rows,cols,self.filters)
def compute_output_shape(self, input_shape):
''' in case your layer modifies the shape of its input,
you should specify here the shape transformation logic,
as done in this case'''
assert isinstance(input_shape, list)
'''if self.data_format == 'channels_last':
shape = input_shape[1:-1]
new_shape = [conv_utils.conv_output_length(
space[i],
self.kernel_size[i],
padding='same',
stride=self.strides[i],
dilation=self.dilation_rate[i]) for i in range(len(shape))]
new_shape = (input_shape[0][0],)+tuple(new_shape)+(input_shape[0][-1],)
if self.data_format == 'channels_first':
shape = input_shape[2:]
new_shape = [conv_utils.conv_output_length(
space[i],
self.kernel_size[i],
padding='same',
stride=self.strides[i],
dilation=self.dilation_rate[i]) for i in range(len(shape))]
new_shape = (input_shape[0][0],)+tuple(new_shape)+(input_shape[0][-1],)
return [new_shape,new_shape]'''
if self.data_format == 'channels_last':
space = input_shape[0][1:-1]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
self.kernel_size[i],
padding='same',
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
new_shape = (input_shape[0][0], ) + tuple(new_space) + (
self.filters, )
return [new_shape, new_shape]
if self.data_format == 'channels_first':
space = input_shape[2:]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
self.kernel_size[i],
padding='same',
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
new_shape = (input_shape[0], self.filters) + tuple(new_space)
return [new_shape, new_shape]
def compute_output_shape(self, input_shape):
if self.activation.startswith("avgpool"):
out_shape = (input_shape[0], 1, 1, input_shape[3])
return out_shape
if self.maxpool_params is not None:
mp = self.maxpool_params
rows = conv_utils.conv_output_length(input_shape[1], mp['pool_size'][0], mp['padding'], mp['strides'][0])
cols = conv_utils.conv_output_length(input_shape[2], mp['pool_size'][1], mp['padding'], mp['strides'][1])
return (input_shape[0], rows, cols, input_shape[3])
return input_shape
def compute_output_shape(self, input_shape):
height, width = input_shape[1:3]
convolved_height = conv_output_length(input_length=height,
filter_size=self.filter_size[0],
padding=self.padding,
stride=self.strides[0])
convolved_width = conv_output_length(input_length=width,
filter_size=self.filter_size[1],
padding=self.padding,
stride=self.strides[1])
return (input_shape[0], convolved_height, convolved_width,
self.num_capsule_types, self.num_caps_instantiations)
def compute_output_shape(self, input_shape):
if self.data_format == 'channels_first':
rows = input_shape[2]
cols = input_shape[3]
elif self.data_format == 'channels_last':
rows = input_shape[1]
cols = input_shape[2]
rows = conv_utils.conv_output_length(rows, self.strides, self.padding,
self.strides)
cols = conv_utils.conv_output_length(cols, self.strides, self.padding,
self.strides)
if self.data_format == 'channels_first':
return (input_shape[0], input_shape[1], rows, cols)
elif self.data_format == 'channels_last':
return (input_shape[0], rows, cols, input_shape[3])
def _compute_output_shape(input_shape):
if self.data_format == "channels_first":
rows = input_shape[2]
cols = input_shape[3]
elif self.data_format == "channels_last":
rows = input_shape[1]
cols = input_shape[2]
rows = conv_utils.conv_output_length(rows, self.pool_size[0],
self.padding, self.strides[0])
cols = conv_utils.conv_output_length(cols, self.pool_size[1],
self.padding, self.strides[1])
if self.data_format == "channels_first":
return (input_shape[0], input_shape[1], rows, cols)
elif self.data_format == "channels_last":
return (input_shape[0], rows, cols, input_shape[3])
def compute_output_shape(self, input_shape): if self.data_format == 'channels_first': rows = input_shape[2] cols = input_shape[3] elif self.data_format == 'channels_last': rows = input_shape[1] cols = input_shape[2] rows = conv_utils.conv_output_length(rows, self.pool_size[0], padding='valid', stride=self.strides[0], dilation=self.dilation_rate) cols = conv_utils.conv_output_length(cols, self.pool_size[1], padding='valid', stride=self.strides[1], dilation=self.dilation_rate) if self.data_format == 'channels_first': return (input_shape[0], input_shape[1], rows, cols) elif self.data_format == 'channels_last': return (input_shape[0], rows, cols, input_shape[3])
def get_output_shape(self, input_shape):
if self.dim_ordering == 'tf':
inp_rows = input_shape[0][1]
inp_cols = input_shape[0][2]
else:
raise ValueError('Only support tensorflow.')
rows = conv_output_length(inp_rows, self.kernel_size, self.border_mode,
1)
cols = conv_output_length(inp_cols, self.kernel_size, self.border_mode,
1)
out_r = conv_output_length(inp_rows, self.kernel_size,
self.border_mode, self.subsample[0])
out_c = conv_output_length(inp_cols, self.kernel_size,
self.border_mode, self.subsample[1])
return (input_shape[0][0], rows, cols, out_r * out_c)
def compute_output_shape(self, input_shape):
input_shape = tf.TensorShape(input_shape).as_list()
if self.data_format == "channels_first":
rows = input_shape[2]
cols = input_shape[3]
else:
rows = input_shape[1]
cols = input_shape[2]
rows = conv_utils.conv_output_length(rows, self.pool_size[0],
self.padding, self.strides[0])
cols = conv_utils.conv_output_length(cols, self.pool_size[1],
self.padding, self.strides[1])
if self.data_format == "channels_first":
return tf.TensorShape([input_shape[0], input_shape[1], rows, cols])
else:
return tf.TensorShape([input_shape[0], rows, cols, input_shape[3]])
def compute_output_shape(self, input_shape):
# Both components and input given
if isinstance(input_shape, list) and len(input_shape) > 1:
input_shape, kernel_shape = input_shape
else:
input_shape = input_shape
kernel_shape = self.components.shape
filters = kernel_shape[0] // self.n_replicas
kernel_shape = kernel_shape[1:3]
space = input_shape[1:-1]
new_space = []
for i in range(len(space)):
new_dim = conv_utils.conv_output_length(
space[i],
kernel_shape[i],
padding=self.padding,
stride=self.strides[i],
dilation=self.dilation_rate[i])
new_space.append(new_dim)
if self.n_replicas != 1:
return (input_shape[0],) + tuple(new_space) + \
(filters, self.n_replicas)
else:
return (input_shape[0], ) + tuple(new_space) + (filters, )
def compute_output_shape(self, input_shape):
if self.data_format == 'channels_first':
rows = input_shape[2]
cols = input_shape[3]
elif self.data_format == 'channels_last':
rows = input_shape[1]
cols = input_shape[2]
rows = conv_utils.conv_output_length(rows, self.kernel_size[0],
self.padding, self.strides[0])
cols = conv_utils.conv_output_length(cols, self.kernel_size[1],
self.padding, self.strides[1])
if self.data_format == 'channels_first':
return (input_shape[0], self.filters, rows, cols)
elif self.data_format == 'channels_last':
return (input_shape[0], rows, cols, self.filters)
def compute_output_shape(self, input_shape):
if self.data_format == 'channels_last':
new_dim = conv_utils.conv_output_length(
input_shape[1],
self.kernel_size[0],
padding=self.padding,
stride=self.strides[0],
dilation=self.dilation_rate[0])
return (input_shape[0],) + tuple([new_dim]) + (self.filters,)
if self.data_format == 'channels_first':
return tuple(23)
def build(self, input_shape):
if self.data_format == 'channels_last':
input_row, input_col = input_shape[1:-1]
input_filter = input_shape[3]
else:
input_row, input_col = input_shape[2:]
input_filter = input_shape[1]
if input_row is None or input_col is None:
raise ValueError('The spatial dimensions of the inputs to '
' a LocallyConnected2D layer '
'should be fully-defined, but layer received '
'the inputs shape ' + str(input_shape))
output_row = conv_utils.conv_output_length(input_row, self.kernel_size[0],
self.padding, self.strides[0])
output_col = conv_utils.conv_output_length(input_col, self.kernel_size[1],
self.padding, self.strides[1])
self.output_row = output_row
self.output_col = output_col
self.kernel_shape = (output_row * output_col,
self.kernel_size[0] * self.kernel_size[1] * input_filter,
self.filters)
self.kernel = self.add_weight(shape=self.kernel_shape,
initializer=self.kernel_initializer,
name='kernel',
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
if self.use_bias:
self.bias = self.add_weight(shape=(output_row, output_col, self.filters),
initializer=self.bias_initializer,
name='bias',
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
else:
self.bias = None
if self.data_format == 'channels_first':
self.input_spec = InputSpec(ndim=4, axes={1: input_filter})
else:
self.input_spec = InputSpec(ndim=4, axes={-1: input_filter})
self.built = True
def test_conv_output_length():
assert conv_utils.conv_output_length(None, 7, 'same', 1) is None
assert conv_utils.conv_output_length(224, 7, 'same', 1) == 224
assert conv_utils.conv_output_length(224, 7, 'same', 2) == 112
assert conv_utils.conv_output_length(32, 5, 'valid', 1) == 28
assert conv_utils.conv_output_length(32, 5, 'valid', 2) == 14
assert conv_utils.conv_output_length(32, 5, 'causal', 1) == 32
assert conv_utils.conv_output_length(32, 5, 'causal', 2) == 16
assert conv_utils.conv_output_length(32, 5, 'full', 1) == 36
assert conv_utils.conv_output_length(32, 5, 'full', 2) == 18
with pytest.raises(AssertionError):
conv_utils.conv_output_length(32, 5, 'diagonal', 2)