def global_mi(self, y_true, y_pred):
warnings.warn(
'This loss will be deprecated. Consider switching to ne.metrics.MutualInformation.'
)
if self.crop_background:
# does not support variable batch size
thresh = 0.0001
padding_size = 20
filt = tf.ones([padding_size, padding_size, padding_size, 1, 1])
smooth = tf.nn.conv3d(y_true, filt, [1, 1, 1, 1, 1], "SAME")
mask = smooth > thresh
# mask = K.any(K.stack([y_true > thresh, y_pred > thresh], axis=0), axis=0)
y_pred = tf.boolean_mask(y_pred, mask)
y_true = tf.boolean_mask(y_true, mask)
y_pred = K.expand_dims(K.expand_dims(y_pred, 0), 2)
y_true = K.expand_dims(K.expand_dims(y_true, 0), 2)
else:
# reshape: flatten images into shape (batch_size, heightxwidthxdepthxchan, 1)
y_true = K.reshape(y_true, (-1, K.prod(K.shape(y_true)[1:])))
y_true = K.expand_dims(y_true, 2)
y_pred = K.reshape(y_pred, (-1, K.prod(K.shape(y_pred)[1:])))
y_pred = K.expand_dims(y_pred, 2)
nb_voxels = tf.cast(K.shape(y_pred)[1], tf.float32)
# reshape bin centers to be (1, 1, B)
o = [1, 1, np.prod(self.vol_bin_centers.get_shape().as_list())]
vbc = K.reshape(self.vol_bin_centers, o)
# compute image terms
I_a = K.exp(-self.preterm * K.square(y_true - vbc))
I_a /= K.sum(I_a, -1, keepdims=True)
I_b = K.exp(-self.preterm * K.square(y_pred - vbc))
I_b /= K.sum(I_b, -1, keepdims=True)
# compute probabilities
I_a_permute = K.permute_dimensions(I_a, (0, 2, 1))
pab = K.batch_dot(
I_a_permute,
I_b) # should be the right size now, nb_labels x nb_bins
pab /= nb_voxels
pa = tf.reduce_mean(I_a, 1, keepdims=True)
pb = tf.reduce_mean(I_b, 1, keepdims=True)
papb = K.batch_dot(K.permute_dimensions(pa,
(0, 2, 1)), pb) + K.epsilon()
return K.sum(K.sum(pab * K.log(pab / papb + K.epsilon()), 1), 1)
def class_tversky(y_true, y_pred):
smooth = 1
y_true = K.permute_dimensions(y_true, (3, 1, 2, 0))
y_pred = K.permute_dimensions(y_pred, (3, 1, 2, 0))
y_true_pos = K.batch_flatten(y_true)
y_pred_pos = K.batch_flatten(y_pred)
true_pos = K.sum(y_true_pos * y_pred_pos, 1)
false_neg = K.sum(y_true_pos * (1 - y_pred_pos), 1)
false_pos = K.sum((1 - y_true_pos) * y_pred_pos, 1)
alpha = 0.7
return (true_pos + smooth) / (true_pos + alpha * false_neg +
(1 - alpha) * false_pos + smooth)
def predict(self, X, y, epoch=None):
y_probs = self.model.call(X, training=False)
if self.is_full:
agnostic_predictions = get_last_channel(
y_probs[0]) > self.hparams.predict_frame_threshold
multi_stack_predictions = convert_multi_instrument_probs_to_predictions(
y_probs[0], self.hparams.predict_frame_threshold,
self.hparams.multiple_instruments_threshold)[0]
permuted_stack_predictions = K.permute_dimensions(
multi_stack_predictions,
(tf.rank(multi_stack_predictions) - 1,
*K.arange(tf.rank(multi_stack_predictions) - 1)))
permuted_predictions = K.concatenate(
[permuted_stack_predictions, agnostic_predictions], axis=0)
else:
timbre_probs = y_probs[0]
top_probs = K.cast(
tf.one_hot(K.argmax(timbre_probs),
K.int_shape(timbre_probs)[-1]), 'bool')
frame_predictions = tf.logical_or(
timbre_probs > self.hparams.multiple_instruments_threshold,
tf.logical_and(top_probs, timbre_probs > 0.5))
permuted_predictions = K.permute_dimensions(
frame_predictions, (tf.rank(frame_predictions) - 1,
*K.arange(tf.rank(frame_predictions) - 1)))
y_relevant = y[0][0]
permuted_true = K.permute_dimensions(
y_relevant,
(tf.rank(y_relevant) - 1, *K.arange(tf.rank(y_relevant) - 1)))
instrument_metrics = dict()
for i in range(self.num_classes):
instrument_metric = calculate_frame_metrics(
permuted_true[i], permuted_predictions[i])
instrument_metrics[
constants.FAMILY_IDX_STRINGS[i]] = instrument_metric
if self.is_full:
if not os.path.exists(self.save_dir):
os.makedirs(self.save_dir)
# Save agnostic midi.
self.save_midi([get_last_channel(p) for p in y_probs],
[get_last_channel(t) for t in y], epoch)
self.save_stack_midi([get_last_channel(p) for p in y_probs],
[get_last_channel(t) for t in y], epoch)
del y_probs
return instrument_metrics
def dropped_inputs():
outputs = inputs
if self.data_format == 'channels_first':
outputs = K.permute_dimensions(outputs, [0, 2, 3, 1])
shape = K.shape(outputs)
if self.sync_channels:
mask = self._compute_drop_mask(
[shape[0], shape[1], shape[2], 1])
else:
mask = self._compute_drop_mask(shape)
outputs = outputs * mask *\
(K.cast(K.prod(shape), dtype=K.floatx()) / K.sum(mask))
if self.data_format == 'channels_first':
outputs = K.permute_dimensions(outputs, [0, 3, 1, 2])
return outputs
def multilabel_dice_coefficient_fixed(y_true, y_pred):
y_dims = K.int_shape(y_pred)
number_of_labels = y_dims[len(y_dims) - 1]
if dimensionality == 2:
# 2-D image
y_true_permuted = K.permute_dimensions(y_true,
pattern=(3, 0, 1, 2))
y_pred_permuted = K.permute_dimensions(y_pred,
pattern=(3, 0, 1, 2))
elif dimensionality == 3:
# 3-D image
y_true_permuted = K.permute_dimensions(y_true,
pattern=(4, 0, 1, 2, 3))
y_pred_permuted = K.permute_dimensions(y_pred,
pattern=(4, 0, 1, 2, 3))
else:
raise ValueError("Specified dimensionality not implemented.")
y_true_label = K.gather(y_true_permuted, indices=(1))
y_pred_label = K.gather(y_pred_permuted, indices=(1))
y_true_label_f = K.flatten(y_true_label)
y_pred_label_f = K.flatten(y_pred_label)
intersection = y_true_label_f * y_pred_label_f
union = y_true_label_f + y_pred_label_f - intersection
numerator = K.sum(intersection)
denominator = K.sum(union)
if number_of_labels > 2:
for j in range(2, number_of_labels):
y_true_label = K.gather(y_true_permuted, indices=(j))
y_pred_label = K.gather(y_pred_permuted, indices=(j))
y_true_label_f = K.flatten(y_true_label)
y_pred_label_f = K.flatten(y_pred_label)
intersection = y_true_label_f * y_pred_label_f
union = y_true_label_f + y_pred_label_f - intersection
numerator = numerator + K.sum(intersection)
denominator = denominator + K.sum(union)
unionOverlap = numerator / denominator
return (-1.0 * (2.0 * unionOverlap + smoothing_factor) /
(1.0 + unionOverlap + smoothing_factor))
def call(self, inputs, **kwargs):
"""This is where the layer's logic lives.
Parameters
----------
inputs: tensor
Input tensor, or list/tuple of input tensors
kwargs: dict
Additional keyword arguments
Returns
-------
tensor
A tensor or list/tuple of tensors
"""
input_shape = K.int_shape(inputs)
if len(input_shape) != 4:
raise ValueError(
'Inputs should have rank ' + str(4) +
'; Received input shape:', str(input_shape))
if self.data_format == 'channels_first':
batch_size, channels, height, width = input_shape
if batch_size is None:
batch_size = -1
r_height, r_width = self.size
o_height, o_width = height * r_height, width * r_width
o_channels = channels // (r_height * r_width)
out = K.reshape(
inputs,
(batch_size, r_height, r_width, o_channels, height, width))
out = K.permute_dimensions(out, (0, 3, 4, 1, 5, 2))
out = K.reshape(out, (batch_size, o_channels, o_height, o_width))
elif self.data_format == 'channels_last':
batch_size, height, width, channels = input_shape
if batch_size is None:
batch_size = -1
r_height, r_width = self.size
o_height, o_width = height * r_height, width * r_width
o_channels = channels // (r_height * r_width)
out = K.reshape(
inputs,
(batch_size, height, width, r_height, r_width, o_channels))
out = K.permute_dimensions(out, (0, 1, 3, 2, 4, 5))
out = K.reshape(out, (batch_size, o_height, o_width, o_channels))
return out
def call(self, x):
x_orig = x
# x reshape
this_bs_int = K.shape(x)[0]
this_bs = tf.cast(this_bs_int, 'float32') # this batch size
prev_count = self.count
x = K.batch_flatten(x) # B x N
# update mean
new_mean, new_count = _mean_update(self.mean, self.count, x, self.cap)
# new C update. Should be B x N x N
x = K.expand_dims(x, -1)
C_delta = K.batch_dot(x, K.permute_dimensions(x, [0, 2, 1]))
# update cov
prev_cap = K.minimum(prev_count, self.cap)
C = self.cov * (prev_cap - 1) + K.sum(C_delta, 0)
new_cov = C / (prev_cap + this_bs - 1)
# updates
updates = [(self.count, new_count), (self.mean, new_mean), (self.cov, new_cov)]
self.add_update(updates, x_orig)
# prep for broadcasting :(
p = tf.concat((K.reshape(this_bs_int, (1,)), K.shape(self.cov)), 0)
z = K.ones(p)
return K.minimum(1., new_count/self.cap) * (z * K.expand_dims(new_cov, 0))
def call(self, u_vecs):
if self.share_weights:
u_hat_vecs = K.conv1d(u_vecs, self.W)
else:
u_hat_vecs = K.local_conv1d(u_vecs, self.W, [1], [1])
batch_size = K.shape(u_vecs)[0]
input_num_capsule = K.shape(u_vecs)[1]
u_hat_vecs = K.reshape(u_hat_vecs, (batch_size, input_num_capsule,
self.num_capsule, self.dim_capsule))
u_hat_vecs = K.permute_dimensions(u_hat_vecs, (0, 2, 1, 3))
#final u_hat_vecs.shape = [None, num_capsule, input_num_capsule, dim_capsule]
b = K.zeros_like(u_hat_vecs[:,:,:,0]) #shape = [None, num_capsule, input_num_capsule]
for i in range(self.routings):
c = softmax(b, 1)
# o = K.batch_dot(c, u_hat_vecs, [2, 2])
o = tf.einsum('bin,binj->bij', c, u_hat_vecs)
if K.backend() == 'theano':
o = K.sum(o, axis=1)
if i < self.routings - 1:
o = K.l2_normalize(o, -1)
# b = K.batch_dot(o, u_hat_vecs, [2, 3])
b = tf.einsum('bij,binj->bin', o, u_hat_vecs)
if K.backend() == 'theano':
b = K.sum(b, axis=1)
return self.activation(o)
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 _space_to_depth(self, input_tensor):
""" Space to depth implementation.
PlaidML does not have a space to depth operation, so calculate if backend is amd
otherwise returns the :func:`tensorflow.space_to_depth` operation.
Parameters
----------
input_tensor: tensor
The tensor to be manipulated
Returns
-------
tensor
The manipulated input tensor
"""
if get_backend() == "amd":
batch, height, width, depth = input_tensor.shape.dims
new_height = height // self.scale
new_width = width // self.scale
reshaped = K.reshape(input_tensor,
(batch, new_height, self.scale, new_width, self.scale, depth))
retval = K.reshape(K.permute_dimensions(reshaped, [0, 1, 3, 2, 4, 5]),
(batch, new_height, new_width, -1))
else:
retval = tf.space_to_depth(input_tensor, block_size=self.scale, data_format="NHWC")
logger.debug("Input Tensor: %s, Output Tensor: %s", input_tensor, retval)
return retval
def gramMatrix(x):
if K.image_data_format() == "channels_first":
features = K.flatten(x)
else:
features = K.batch_flatten(K.permute_dimensions(x, (2, 0, 1)))
gram = K.dot(features, K.transpose(features))
return gram
def call(self, inputs, training=None):
input_shape = K.int_shape(inputs)
reduction_axes = list(range(0, len(input_shape)))
if self.axis is not None:
del reduction_axes[self.axis]
del reduction_axes[0]
# Put axis last
inputs = K.permute_dimensions(
inputs, tuple([0] + reduction_axes + [self.axis]))
# Collapse all other dims into dim 1
cinp = K.reshape(inputs,
(K.shape(inputs)[0], -1, input_shape[self.axis]))
n_reduced = K.shape(cinp)[1]
# Calculate dot product
pure_gram = K.batch_dot(cinp, cinp, 1)
scaled_gram = pure_gram / K.cast(
2 * n_reduced * input_shape[self.axis], 'float32')
return scaled_gram
#return K.sqrt(scaled_gram)
# Calculate covariance
means = K.mean(cinp, [1], keepdims=True)
mean_mat = K.batch_dot(means, means, 1)
cov = scaled_gram - mean_mat
return cov
def call(self, inputs):
"""Following the routing algorithm from Hinton's paper,
but replace b = b + <u,v> with b = <u,v>.
This change can improve the feature representation of Capsule.
However, you can replace
b = K.batch_dot(outputs, hat_inputs, [2, 3])
with
b += K.batch_dot(outputs, hat_inputs, [2, 3])
to realize a standard routing.
"""
if self.share_weights:
hat_inputs = K.conv1d(inputs, self.kernel)
else:
hat_inputs = K.local_conv1d(inputs, self.kernel, [1], [1])
batch_size = K.shape(inputs)[0]
input_num_capsule = K.shape(inputs)[1]
hat_inputs = K.reshape(hat_inputs,
(batch_size, input_num_capsule,
self.num_capsule, self.dim_capsule))
hat_inputs = K.permute_dimensions(hat_inputs, (0, 2, 1, 3))
b = K.zeros_like(hat_inputs[:, :, :, 0])
for i in range(self.routings):
c = softmax(b, 1)
o = self.activation(caps_batch_dot(c, hat_inputs))
if i < self.routings - 1:
b = caps_batch_dot(o, hat_inputs)
if K.backend() == 'theano':
o = K.sum(o, axis=1)
return o
def call(self, x, mask=None):
assert(len(x) == 2)
img = x[0]
rois = x[1]
outputs = []
for roi_idx in range(self.num_rois):
x = rois[0, roi_idx, 0]
y = rois[0, roi_idx, 1]
w = rois[0, roi_idx, 2]
h = rois[0, roi_idx, 3]
x = K.cast(x, 'int32')
y = K.cast(y, 'int32')
w = K.cast(w, 'int32')
h = K.cast(h, 'int32')
rs = tf.image.resize_images(img[:, y:y+h, x:x+w, :], (self.pool_size, self.pool_size))
outputs.append(rs)
final_output = K.concatenate(outputs, axis=0)
final_output = K.reshape(final_output, (1, self.num_rois, self.pool_size, self.pool_size, self.nb_channels))
final_output = K.permute_dimensions(final_output, (0, 1, 2, 3, 4))
return final_output
def split_heads(r: int, x: KTensor) -> KTensor:
r"""
Split sequential data along the last dimension (entries/embeddings)
into a set of subspaces and flatten the result:
Given $r \in \mathbb{N}$ and a tensor $X$ of shape $b \times l \times d$,
where $b$ – batch size, $l$ – the number of entries in a sequences, $d$ is
entry length (embedding dimensions) such that $d \bmod r = 0$:
1. Calculate subspace size $d_r = d \bmod r$;
2. Add a new dimension along the entry (embedding) dimension such that
each entry (embedding) vector is replaced by an $r \times ${d}_{r}$
matrix: the resulting tensor will have shape [b, l, r, d_r]. Permute
dimensions from $[b, l, r, d_r]$ to $[r, b, l, d_r]$. In other
words, we end up with $r$ consecutive views (entry/embedding splits) of the
original batch. Each view retains the structure of the original
batch.
4. Flatten the output along the 0-axis. The output will be
$[r \times b, l, d_r]$
:param r: the number of heads
:param x: a tensor of shape
"""
b, l, d = K.int_shape(x)
d_r = d // r
# split each entry of shape d into r splits of shape d_r
splits = K.reshape(x, [-1, l, r, d_r])
# permute to [r, b, l, d_r]
head_batches = K.permute_dimensions(splits, [2, 0, 1, 3])
# drop the r-dimension: [r, b, l, d_r] -> [r*b, l, d_r]
return K.reshape(head_batches, [-1, l, d_r])
def call(self, x): assert(len(x)==2) #feature map img = x[0] #锚框坐标 rois = x[1] outputs = [] for roi_idx in range(self.num_rois): x = rois[0, roi_idx, 0] y = rois[0, roi_idx, 1] w = rois[0, roi_idx, 2] h = rois[0, roi_idx, 3] x = K.cast(x, 'int32') y = K.cast(y, 'int32') w = K.cast(w, 'int32') h = K.cast(h, 'int32') #在feature map中，取出roi, 并缩放到14*14 rs = tf.compat.v1.image.resize_images(img[:,y:y+h,x:x+w,:], (self.pool_size, self.pool_size)) outputs.append(rs) #类似，tf.concat()，这里转化为tensor final_output = K.concatenate(outputs, axis=0) final_output = K.reshape(final_output, (1, self.num_rois, self.pool_size, self.pool_size, self.nb_channels)) #permute:置换、dimensions：尺寸 final_output = K.permute_dimensions(final_output, (0,1,2,3,4)) return final_output
def extract_image_patches(self,
x,
ksizes,
ssizes,
padding='same',
data_format='channels_last'):
"""
Extract the patches from an image
# Parameters
x : The input image
ksizes : 2-d tuple with the kernel size
ssizes : 2-d tuple with the strides size
padding : 'same' or 'valid'
data_format : 'channels_last' or 'channels_first'
# Returns
The (k_w, k_h) patches extracted
TF ==> (batch_size, w, h, k_w, k_h, c)
TH ==> (batch_size, w, h, c, k_w, k_h)
"""
kernel = [1, ksizes[0], ksizes[1], 1]
strides = [1, ssizes[0], ssizes[1], 1]
padding = self._preprocess_padding(padding)
if data_format == 'channels_first':
x = K.permute_dimensions(x, (0, 2, 3, 1))
patches = extract_image_patches(x, kernel, strides, [1, 1, 1, 1],
padding)
return patches
def _multiplicative_similarity(self, source, query):
qp = K.dot(query, self._weights["w_a"])
similarity = K.batch_dot(K.permute_dimensions(qp, [0, 2, 1]),
source,
axes=[1, 2])
return similarity
def _reshape_from_batches(x, head_num):
input_shape = K.shape(x)
batch_size, seq_len, feature_dim = input_shape[0], input_shape[1], input_shape[2]
x = K.reshape(x, (batch_size // head_num,
head_num, seq_len, feature_dim))
x = K.permute_dimensions(x, [0, 2, 1, 3])
return K.reshape(x, (batch_size // head_num, seq_len, feature_dim * head_num))
def split_heads(x, n_heads: int, k: bool = False):
x_shape = shape_list(x)
m = x_shape[-1]
new_x_shape = x_shape[:-1] + [n_heads, m // n_heads]
new_x = K.reshape(x, new_x_shape)
return K.permute_dimensions(new_x,
[0, 2, 3, 1] if k else [0, 2, 1, 3])
def call(self, inputs):
activation = Kb.dot(inputs, self._weights) # (batch, in_dim) x (nb_ker, in_dim, ker_dim) = (batch, nb_ker, ker_dim)
diffs = (Kb.expand_dims(activation, 3) # (batch, nb_ker, ker_dim, 1)
- Kb.expand_dims(Kb.permute_dimensions(activation, [1, 2, 0]), 0)) # (1, nb_ker, ker_dim, batch)
abs_diffs = Kb.sum(Kb.abs(diffs), axis=2) # (batch, nb_ker, batch) Sum over rows to get L1
minibatch_features = Kb.sum(Kb.exp(-abs_diffs), axis=2) # (batch, nb_ker)
return minibatch_features # (batch, in_dim+nb_ker)
def call(self, input):
point_cloud = input
point_cloud_transpose = K.permute_dimensions(point_cloud, [0, 2, 1])
# Compute distances.
point_cloud_inner = tf.matmul(point_cloud, point_cloud_transpose)
point_cloud_inner = -2 * point_cloud_inner
point_cloud_square = tf.reduce_sum(tf.square(point_cloud),
axis=-1,
keepdims=True)
point_cloud_square_tranpose = tf.transpose(point_cloud_square,
perm=[0, 2, 1])
adj_matrix = point_cloud_square + point_cloud_inner + point_cloud_square_tranpose
# Compute indices.
neg_adj = -adj_matrix
_, nn_idx = tf.nn.top_k(neg_adj, k=self.k)
# Compute the neighbors.
batch_size = tf.shape(point_cloud)[
0] # Note: Treat batch-size differently.
num_points = point_cloud.get_shape()[1]
num_dims = point_cloud.get_shape()[2]
idx_ = tf.range(batch_size) * num_points
idx_ = tf.reshape(idx_, [-1, 1, 1])
point_cloud_flat = tf.reshape(point_cloud, [-1, num_dims])
point_cloud_neighbors = tf.gather(point_cloud_flat, nn_idx + idx_)
return point_cloud_neighbors
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 call(self, inputs):
if self.share_weights:
hat_inputs = K.conv1d(inputs, self.kernel)
else:
hat_inputs = K.local_conv1d(inputs, self.kernel, [1], [1])
batch_size = K.shape(inputs)[0]
input_num_capsule = K.shape(inputs)[1]
hat_inputs = K.reshape(hat_inputs,
(batch_size, input_num_capsule,
self.num_capsule, self.dim_capsule))
hat_inputs = K.permute_dimensions(hat_inputs, (0, 2, 1, 3))
b = K.zeros_like(hat_inputs[:, :, :, 0])
for i in range(self.routings):
c = softmax(b, 1)
o = self.activation(keras.backend.batch_dot(c, hat_inputs, [2, 2]))
if i < self.routings - 1:
b = keras.backend.batch_dot(o, hat_inputs, [2, 3])
if K.backend() == 'theano':
o = K.sum(o, axis=1)
return o
def boxes_from_deltas(pred_box_delta, config):
"""
Converts prediction deltas to bounding boxes
Arguments:
pred_box_delta {[type]} -- tensor of deltas
config {[type]} -- hyperparameter dict
Returns:
[type] -- tensor of bounding boxes
"""
# Keras backend allows no unstacking
delta_x = pred_box_delta[:, :, 0]
delta_y = pred_box_delta[:, :, 1]
delta_w = pred_box_delta[:, :, 2]
delta_h = pred_box_delta[:, :, 3]
# get the coordinates and sizes of the anchor boxes from config
anchor_x = config.ANCHOR_BOX[:, 0]
anchor_y = config.ANCHOR_BOX[:, 1]
anchor_w = config.ANCHOR_BOX[:, 2]
anchor_h = config.ANCHOR_BOX[:, 3]
# as we only predict the deltas, we need to transform the anchor box values before computing the loss
box_center_x = tf.identity(
anchor_x + delta_x * anchor_w)
box_center_y = tf.identity(
anchor_y + delta_y * anchor_h)
box_width = tf.identity(
anchor_w * safe_exp(delta_w, config.EXP_THRESH))
box_height = tf.identity(
anchor_h * safe_exp(delta_h, config.EXP_THRESH))
# tranform into a real box with four coordinates
xmins, ymins, xmaxs, ymaxs = bbox_transform([box_center_x, box_center_y, box_width, box_height])
# trim boxes if predicted outside
xmins = K.minimum(
K.maximum(0.0, xmins), config.IMAGE_WIDTH - 1.0)
ymins = K.minimum(
K.maximum(0.0, ymins), config.IMAGE_HEIGHT - 1.0)
xmaxs = K.maximum(
K.minimum(config.IMAGE_WIDTH - 1.0, xmaxs), 0.0)
ymaxs = K.maximum(
K.minimum(config.IMAGE_HEIGHT - 1.0, ymaxs), 0.0)
det_boxes = K.permute_dimensions(
K.stack(bbox_transform_inv([xmins, ymins, xmaxs, ymaxs])),
(1, 2, 0)
)
return (det_boxes)
def compute_p_c_z(self, z):
assert z.shape[1:] == (
self.latent_dim, ), 'z.shape[1:] {} != {}'.format(
z.shape[1:], (self.latent_dim, ))
Z = K.permute_dimensions(K.repeat(z, self.n_clusters), [0, 2, 1])
assert Z.shape[1:] == (self.latent_dim,
self.n_clusters), 'Z.shape[1:] {} != {}'.format(
Z.shape[1:],
(self.latent_dim, self.n_clusters))
u_tensor3 = self.compute_u_tensor3()
lambda_tensor3 = self.compute_lambda_tensor3()
assert self.theta_p.shape == (
self.n_clusters, ), 'self.theta_p.shape {} != {}'.format(
self.theta_p.shape, (self.n_clusters, ))
theta_tensor3 = K.expand_dims(
K.expand_dims(self.theta_p, axis=0), axis=0) * K.ones(
(self.batch_size, self.latent_dim, self.n_clusters))
assert theta_tensor3.shape == (
self.batch_size, self.latent_dim,
self.n_clusters), 'theta_tensor3.shape {} != {}'.format(
theta_tensor3.shape,
(self.batch_size, self.latent_dim, self.n_clusters))
p_c_z=K.exp(K.sum((K.log(theta_tensor3)-0.5*K.log(2*math.pi*lambda_tensor3)-\
K.square(Z-u_tensor3)/(2*lambda_tensor3)),axis=1))+1e-10
assert p_c_z.shape[1:] == (
self.n_clusters, ), 'p_c_z.shape[1:] {} != {}'.format(
p_c_z.shape[1:], (self.n_clusters, ))
return p_c_z / K.sum(p_c_z, axis=-1, keepdims=True)
def _call_multiplicative_emission(self, inputs):
# e_{t, t'} = x_t^T W_a x_{t'} + b_a
e = K.batch_dot(K.dot(inputs, self.Wa),
K.permute_dimensions(inputs, (0, 2, 1)))
if self.use_attention_bias:
e = e + self.ba
return e
def channel_shuffle(x):
height, width, channels = x.shape.as_list()[1:]
channels_per_split = channels // 2
x = K.reshape(x, [-1, height, width, 2, channels_per_split])
x = K.permute_dimensions(x, (0,1,2,4,3))
x = K.reshape(x, [-1, height, width, channels])
return x
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 channel_shuffle(x, groups):
"""
Parameters
----------
x:
Input tensor of with `channels_last` data format
groups: int
number of groups per channel
Returns
-------
channel shuffled output tensor
Examples
--------
Example for a 1D Array with 3 groups
>>> d = np.array([0,1,2,3,4,5,6,7,8])
>>> x = np.reshape(d, (3,3))
>>> x = np.transpose(x, [1,0])
>>> x = np.reshape(x, (9,))
'[0 1 2 3 4 5 6 7 8] --> [0 3 6 1 4 7 2 5 8]'
"""
height, width, in_channels = x.shape.as_list()[1:]
#handle dynamic image shape case
if height is None:
height = K.shape(x)[1]
if width is None:
width = K.shape(x)[2]
channels_per_group = in_channels // groups
x = K.reshape(x, [-1, height, width, groups, channels_per_group])
x = K.permute_dimensions(x, (0, 1, 2, 4, 3)) # transpose
x = K.reshape(x, [-1, height, width, in_channels])
return x