def call(self, inputs, **kwargs):
input_shape = K.int_shape(inputs)
# Prepare broadcasting shape.
ndim = len(input_shape)
reduction_axes = list(range(len(input_shape)))
del reduction_axes[self.axis]
broadcast_shape = [1] * len(input_shape)
broadcast_shape[self.axis] = input_shape[self.axis]
reshape_group_shape = list(input_shape)
reshape_group_shape[self.axis] = input_shape[self.axis] // self.groups
group_shape = [tf.shape(inputs)[0], self.groups]
group_shape.extend(reshape_group_shape[1:])
group_shape = [n if n is not None else -1 for n in group_shape]
group_reduction_axes = list(range(len(group_shape)))
# Determines whether broadcasting is needed.
needs_broadcasting = sorted(reduction_axes) != list(range(ndim))[:-1]
inputs = K.reshape(inputs, group_shape)
mean = K.mean(inputs, axis=group_reduction_axes[2:], keepdims=True)
variance = K.var(inputs, axis=group_reduction_axes[2:], keepdims=True)
inputs = (inputs - mean) / (K.sqrt(variance + self.epsilon))
original_shape = [tf.shape(inputs)[0]] + list(input_shape[1:])
original_shape = [n if n is not None else -1 for n in original_shape]
inputs = K.reshape(inputs, original_shape)
if needs_broadcasting:
outputs = inputs
# In this case we must explicitly broadcast all parameters.
if self.scale:
broadcast_gamma = K.reshape(self.gamma, broadcast_shape)
outputs = outputs * broadcast_gamma
if self.center:
broadcast_beta = K.reshape(self.beta, broadcast_shape)
outputs = outputs + broadcast_beta
else:
outputs = inputs
if self.scale:
outputs = outputs * self.gamma
if self.center:
outputs = outputs + self.beta
return outputs
def call(self, inputs, **kwargs):
input_shape = K.int_shape(inputs)
tensor_input_shape = K.shape(inputs)
# Prepare broadcasting shape.
reduction_axes = list(range(len(input_shape)))
del reduction_axes[self.axis]
broadcast_shape = [1] * len(input_shape)
broadcast_shape[self.axis] = input_shape[self.axis] // self.groups
broadcast_shape.insert(1, self.groups)
reshape_group_shape = K.shape(inputs)
group_axes = [reshape_group_shape[i] for i in range(len(input_shape))]
group_axes[self.axis] = input_shape[self.axis] // self.groups
group_axes.insert(1, self.groups)
# reshape inputs to new group shape
group_shape = [group_axes[0], self.groups] + group_axes[2:]
group_shape = K.stack(group_shape)
inputs = K.reshape(inputs, group_shape)
group_reduction_axes = list(range(len(group_axes)))
group_reduction_axes = group_reduction_axes[2:]
mean = K.mean(inputs, axis=group_reduction_axes, keepdims=True)
variance = K.var(inputs, axis=group_reduction_axes, keepdims=True)
inputs = (inputs - mean) / (K.sqrt(variance + self.epsilon))
# prepare broadcast shape
inputs = K.reshape(inputs, group_shape)
outputs = inputs
# In this case we must explicitly broadcast all parameters.
if self.scale:
broadcast_gamma = K.reshape(self.gamma, broadcast_shape)
outputs = outputs * broadcast_gamma
if self.center:
broadcast_beta = K.reshape(self.beta, broadcast_shape)
outputs = outputs + broadcast_beta
outputs = K.reshape(outputs, tensor_input_shape)
return outputs
def apply_local_cmvn(feats, epsilon=1e-9):
''' feats: (NHWC) '''
mean = tf.expand_dims(keras_backend.mean(feats, axis=1), axis=1)
var = tf.expand_dims(keras_backend.var(feats, axis=1), axis=1)
feats = (feats - mean) * tf.rsqrt(var + epsilon)
return feats
def metric_var_y(_y_true_unused, _y_pred_unused):
return K.mean(K.var(representation_layer_yx))
def call(self, x, mask=None):
"""Execute this layer on input tensors.
This layer is meant to be executed on a Graph. So x is expected to
be a list of placeholders, with the first placeholder the list of
atom_features (learned or input) at this level, the second the deg_slice,
the third the membership, and the remaining the deg_adj_lists.
Visually
x = [atom_features, deg_slice, membership, deg_adj_list placeholders...]
Parameters
----------
x: list
list of Tensors of form described above.
mask: bool, optional
Ignored. Present only to shadow superclass call() method.
Returns
-------
atom_features: tf.Tensor
Of shape (n_atoms, nb_filter)
"""
# Add trainable weights
# self.build()
# Extract atom_features
atom_features_ori = x[0]
# Extract graph topology
deg_slice, membership, deg_adj_lists = x[1], x[2], x[3:]
training = x[-2]
# Perform the mol conv
atom_features, gather_feature = graph_conv(
atom_features_ori, deg_adj_lists, deg_slice, self.max_deg,
self.min_deg, self.W_list, self.b_list, self.gather_W_list,
self.gather_b_list, membership, self.batch_size)
atom_features = self.activation(atom_features)
gather_feature = self.activation(gather_feature)
xx = atom_features
yy = gather_feature
if not isinstance(xx, list):
input_shape = model_ops.int_shape(xx)
else:
xx = xx[0]
input_shape = model_ops.int_shape(xx)
m = model_ops.mean(xx, axis=-1, keepdims=True)
std = model_ops.sqrt(
model_ops.var(xx, axis=-1, keepdims=True) + self.epsilon)
x_normed = (xx - m) / (std + self.epsilon)
x_normed = self.gamma * x_normed + self.beta
m_1 = model_ops.mean(yy, axis=-1, keepdims=True)
std_1 = model_ops.sqrt(
model_ops.var(yy, axis=-1, keepdims=True) + self.epsilon)
y_normed = (yy - m_1) / (std_1 + self.epsilon)
y_normed = self.gamma * y_normed + self.beta
atom_features = x_normed
gather_norm = gather_node(x_normed, membership, self.batch_size)
gather = tf.convert_to_tensor(gather_norm, dtype=tf.float32)
if self.dropout is not None:
atom_features = training * tf.nn.dropout(
atom_features,
1 - self.dropout) + (1 - training) * atom_features
gather = training * tf.nn.dropout(
gather_feature,
1 - self.dropout) + (1 - training) * gather_feature
return [atom_features, y_normed, gather]
def call(self, inputs, training=None):
input_shape = K.int_shape(inputs)
# Prepare broadcasting shape.
reduction_axes = list(range(len(input_shape)))
del reduction_axes[self.axis]
if self.axis != 0:
del reduction_axes[0]
broadcast_shape = [1] * len(input_shape)
broadcast_shape[self.axis] = input_shape[self.axis]
mean_instance = K.mean(inputs, reduction_axes, keepdims=True)
variance_instance = K.var(inputs, reduction_axes, keepdims=True)
mean_layer = K.mean(mean_instance, self.axis, keepdims=True)
temp = variance_instance + K.square(mean_instance)
variance_layer = K.mean(temp, self.axis,
keepdims=True) - K.square(mean_layer)
def training_phase():
mean_batch = K.mean(mean_instance, axis=0, keepdims=True)
variance_batch = K.mean(temp, axis=0,
keepdims=True) - K.square(mean_batch)
mean_batch_reshaped = K.flatten(mean_batch)
variance_batch_reshaped = K.flatten(variance_batch)
if K.backend() != 'cntk':
sample_size = K.prod(
[K.shape(inputs)[axis] for axis in reduction_axes])
sample_size = K.cast(sample_size, dtype=K.dtype(inputs))
# sample variance - unbiased estimator of population variance
variance_batch_reshaped *= sample_size / (sample_size -
(1.0 + self.epsilon))
self.add_update([
K.moving_average_update(self.moving_mean, mean_batch_reshaped,
self.momentum),
K.moving_average_update(self.moving_variance,
variance_batch_reshaped, self.momentum)
], inputs)
return normalize_func(mean_batch, variance_batch)
def inference_phase():
mean_batch = self.moving_mean
variance_batch = self.moving_variance
return normalize_func(mean_batch, variance_batch)
def normalize_func(mean_batch, variance_batch):
mean_batch = K.reshape(mean_batch, broadcast_shape)
variance_batch = K.reshape(variance_batch, broadcast_shape)
mean_weights = K.softmax(self.mean_weights, axis=0)
variance_weights = K.softmax(self.variance_weights, axis=0)
mean = (mean_weights[0] * mean_instance +
mean_weights[1] * mean_layer +
mean_weights[2] * mean_batch)
variance = (variance_weights[0] * variance_instance +
variance_weights[1] * variance_layer +
variance_weights[2] * variance_batch)
outputs = (inputs - mean) / (K.sqrt(variance + self.epsilon))
if self.scale:
broadcast_gamma = K.reshape(self.gamma, broadcast_shape)
outputs = outputs * broadcast_gamma
if self.center:
broadcast_beta = K.reshape(self.beta, broadcast_shape)
outputs = outputs + broadcast_beta
return outputs
if training in {0, False}:
return inference_phase()
return K.in_train_phase(training_phase,
inference_phase,
training=training)