def get_inv_sqrt(ff):
with ktf.device('/cpu:0'):
S, U, _ = ktf.svd(ff + ktf.eye(c) * self.epsilon,
full_matrices=True)
D = ktf.diag(ktf.pow(S, -0.5))
inv_sqrt = ktf.matmul(D, U, transpose_b=True)
D = ktf.diag(ktf.pow(S, 0.5))
sqrt = ktf.matmul(D, U, transpose_b=True)
return sqrt, inv_sqrt
def upsampling_from_mask(inputs):
X_, A_, I_, M_ = inputs
S_ = tf.eye(tf.shape(M_)[0])
S_ = tf.boolean_mask(S_, M_)
S_t_ = tf.transpose(S_)
X_out_ = K.dot(S_t_, X_)
A_out_ = K.dot(K.transpose(K.dot(A_, S_)), S_)
I_out_ = K.dot(S_t_, K.cast(I_[:, None], tf.float32))[:, 0]
I_out_ = K.cast(I_out_, tf.int32)
return [X_out_, A_out_, I_out_]
def train():
ff_apr = ktf.matmul(f, f, transpose_b=True) / (
ktf.cast(bs * w * h, ktf.float32) - 1.)
if self.decomposition in ['pca-cor', 'zca-cor']:
dinv = ktf.diag(ktf.sqrt(ktf.diag_part(ff_apr)))
ff_apr = ktf.matmul(ktf.matmul(dinv, ff_apr),
ktf.matrix_inverse(dinv),
transpose_b=True)
self.add_update([
K.moving_average_update(self.moving_mean, m, self.momentum),
K.moving_average_update(self.moving_cov, ff_apr, self.momentum)
], inputs)
ff_apr_shrinked = (
1 - self.epsilon) * ff_apr + ktf.eye(c) * self.epsilon
if self.renorm:
l, l_inv = get_inv_sqrt(ff_apr_shrinked)
ff_mov = (1 - self.epsilon
) * self.moving_cov + ktf.eye(c) * self.epsilon
_, l_mov_inverse = get_inv_sqrt(ff_mov)
l_ndiff = K.stop_gradient(l)
return ktf.matmul(ktf.matmul(l_mov_inverse, l_ndiff), l_inv)
return get_inv_sqrt(ff_apr_shrinked)[1]
def test():
ff_mov = (
1 - self.epsilon) * self.moving_cov + ktf.eye(c) * self.epsilon
return get_inv_sqrt(ff_mov)[1]
def get_inv_sqrt(ff):
sqrt = ktf.cholesky(ff)
inv_sqrt = ktf.matrix_triangular_solve(sqrt, ktf.eye(c))
return sqrt, inv_sqrt
def call(self, inputs):
# Note that I is useless, because thee layer cannot be used in graph
# batch mode.
if len(inputs) == 3:
X, A, I = inputs
else:
X, A = inputs
I = None
N = K.shape(A)[-1]
# Check if the layer is operating in batch mode (X and A have rank 3)
batch_mode = K.ndim(A) == 3
# Get normalized adjacency
if K.is_sparse(A):
I_ = tf.sparse.eye(N, dtype=A.dtype)
A_ = tf.sparse.add(A, I_)
else:
I_ = tf.eye(N, dtype=A.dtype)
A_ = A + I_
fltr = ops.normalize_A(A_)
# Node embeddings
Z = K.dot(X, self.kernel_emb)
Z = ops.filter_dot(fltr, Z)
if self.activation is not None:
Z = self.activation(Z)
# Compute cluster assignment matrix
S = K.dot(X, self.kernel_pool)
S = ops.filter_dot(fltr, S)
S = activations.softmax(S, axis=-1) # softmax applied row-wise
# Link prediction loss
S_gram = ops.matmul_A_BT(S, S)
if K.is_sparse(A):
LP_loss = tf.sparse.add(
A, -S_gram) # A/tf.norm(A) - S_gram/tf.norm(S_gram)
else:
LP_loss = A - S_gram
LP_loss = tf.norm(LP_loss, axis=(-1, -2))
if batch_mode:
LP_loss = K.mean(LP_loss)
self.add_loss(LP_loss)
# Entropy loss
entr = tf.negative(
tf.reduce_sum(tf.multiply(S, K.log(S + K.epsilon())), axis=-1))
entr_loss = K.mean(entr, axis=-1)
if batch_mode:
entr_loss = K.mean(entr_loss)
self.add_loss(entr_loss)
# Pooling
X_pooled = ops.matmul_AT_B(S, Z)
A_pooled = ops.matmul_AT_B_A(S, A)
output = [X_pooled, A_pooled]
if I is not None:
I_mean = tf.segment_mean(I, I)
I_pooled = ops.tf_repeat_1d(I_mean, tf.ones_like(I_mean) * self.k)
output.append(I_pooled)
if self.return_mask:
output.append(S)
return output
def call(self, inputs):
# Note that I is useless, because thee layer cannot be used in graph
# batch mode.
if len(inputs) == 3:
X, A, I = inputs
else:
X, A = inputs
I = None
# Check if the layer is operating in batch mode (X and A have rank 3)
batch_mode = K.ndim(A) == 3
# Optionally compute hidden layer
if self.h is None:
Hid = X
else:
Hid = K.dot(X, self.kernel_in)
if self.use_bias:
Hid = K.bias_add(Hid, self.bias_in)
if self.activation is not None:
Hid = self.activation(Hid)
# Compute cluster assignment matrix
S = K.dot(Hid, self.kernel_out)
if self.use_bias:
S = K.bias_add(S, self.bias_out)
S = activations.softmax(
S, axis=-1) # Apply softmax to get cluster assignments
# MinCut regularization
A_pooled = ops.matmul_AT_B_A(S, A)
num = tf.trace(A_pooled)
D = ops.degree_matrix(A)
den = tf.trace(ops.matmul_AT_B_A(S, D))
cut_loss = -(num / den)
if batch_mode:
cut_loss = K.mean(cut_loss)
self.add_loss(cut_loss)
# Orthogonality regularization
SS = ops.matmul_AT_B(S, S)
I_S = tf.eye(self.k)
ortho_loss = tf.norm(SS / tf.norm(SS, axis=(-1, -2)) -
I_S / tf.norm(I_S),
axis=(-1, -2))
if batch_mode:
ortho_loss = K.mean(cut_loss)
self.add_loss(ortho_loss)
# Pooling
X_pooled = ops.matmul_AT_B(S, X)
A_pooled = tf.linalg.set_diag(A_pooled, tf.zeros(
K.shape(A_pooled)[:-1])) # Remove diagonal
A_pooled = ops.normalize_A(A_pooled)
output = [X_pooled, A_pooled]
if I is not None:
I_mean = tf.segment_mean(I, I)
I_pooled = ops.tf_repeat_1d(I_mean, tf.ones_like(I_mean) * self.k)
output.append(I_pooled)
if self.return_mask:
output.append(S)
return output