def train_step(self, sequence):
with tf.device(self.device):
self.train_metric.reset_states()
for inputs, labels in sequence:
x, adj, index, adv_mask = inputs
with tf.GradientTape() as tape:
logit = self.forward(x, adj)
output = tf.gather(logit, index)
loss = self.loss_fn(labels, output)
entropy_loss = entropy_y_x(logit)
vat_loss = self.virtual_adversarial_loss(x,
adj,
logit=logit,
adv_mask=adv_mask)
loss += self.p1 * vat_loss + self.p2 * entropy_loss
self.train_metric.update_state(labels, output)
trainable_variables = self.model.trainable_variables
gradients = tape.gradient(loss, trainable_variables)
self.optimizer.apply_gradients(
zip(gradients, trainable_variables))
return loss, self.train_metric.result()
def train_step(self, sequence):
model = self.model
metric = model.metrics[0]
loss_fn = model.loss
optimizer = model.optimizer
with tf.device(self.device):
metric.reset_states()
for inputs, labels in sequence:
x, adj, index, adv_mask = inputs
with tf.GradientTape() as tape:
logit = model([x, adj, self.index_all], training=True)
output = tf.gather(logit, index)
loss = loss_fn(labels, output)
entropy_loss = entropy_y_x(logit)
vat_loss = self.virtual_adversarial_loss(x,
adj,
logit=logit,
adv_mask=adv_mask)
loss += self.p1 * vat_loss + self.p2 * entropy_loss
metric.update_state(labels, output)
trainable_variables = model.trainable_variables
gradients = tape.gradient(loss, trainable_variables)
optimizer.apply_gradients(zip(gradients, trainable_variables))
return {"loss": loss, "accuracy": metric.result()}
def build(self,
hiddens=[16],
activations=['relu'],
dropout=0.5,
weight_decay=5e-4,
use_bias=False,
lr=0.01,
p1=1.4,
p2=0.7):
if self.backend == "torch":
raise RuntimeError(
f"Currently {self.name} only supports for tensorflow backend.")
with tf.device(self.device):
x = Input(batch_shape=[None, self.graph.num_node_attrs],
dtype=self.floatx,
name='node_attr')
adj = Input(batch_shape=[None, None],
dtype=self.floatx,
sparse=True,
name='adj_matrix')
index = Input(batch_shape=[None],
dtype=self.intx,
name='node_index')
GCN_layers = []
for hidden, activation in zip(hiddens, activations):
GCN_layers.append(
GraphConvolution(
hidden,
activation=activation,
use_bias=use_bias,
kernel_regularizer=regularizers.l2(weight_decay)))
GCN_layers.append(
GraphConvolution(self.graph.num_node_classes,
use_bias=use_bias))
self.GCN_layers = GCN_layers
self.dropout = Dropout(rate=dropout)
logit = self.forward(x, adj)
output = Gather()([logit, index])
model = TFKeras(inputs=[x, adj, index], outputs=output)
model.compile(loss=SparseCategoricalCrossentropy(from_logits=True),
optimizer=Adam(lr=lr),
metrics=['accuracy'])
self.r_vadv = tf.Variable(TruncatedNormal(stddev=0.01)(
shape=[self.graph.num_nodes, self.graph.num_node_attrs]),
name="r_vadv")
entropy_loss = entropy_y_x(logit)
vat_loss = self.virtual_adversarial_loss(x, adj, logit)
model.add_loss(p1 * vat_loss + p2 * entropy_loss)
self.model = model
self.adv_optimizer = Adam(lr=lr / 10)
def build(self,
hiddens=[16],
activations=['relu'],
dropout=0.5,
l2_norm=5e-4,
use_bias=False,
lr=0.01,
p1=1.4,
p2=0.7):
with tf.device(self.device):
x = Input(batch_shape=[None, self.graph.n_attrs],
dtype=self.floatx,
name='attr_matrix')
adj = Input(batch_shape=[None, None],
dtype=self.floatx,
sparse=True,
name='adj_matrix')
index = Input(batch_shape=[None],
dtype=self.intx,
name='node_index')
GCN_layers = []
dropout_layers = []
for hidden, activation in zip(hiddens, activations):
GCN_layers.append(
GraphConvolution(
hidden,
activation=activation,
use_bias=use_bias,
kernel_regularizer=regularizers.l2(l2_norm)))
dropout_layers.append(Dropout(rate=dropout))
GCN_layers.append(
GraphConvolution(self.graph.n_classes, use_bias=use_bias))
self.GCN_layers = GCN_layers
self.dropout_layers = dropout_layers
logit = self.forward(x, adj)
output = Gather()([logit, index])
model = Model(inputs=[x, adj, index], outputs=output)
model.compile(loss=SparseCategoricalCrossentropy(from_logits=True),
optimizer=Adam(lr=lr),
metrics=['accuracy'])
self.r_vadv = tf.Variable(TruncatedNormal(stddev=0.01)(
shape=[self.graph.n_nodes, self.graph.n_attrs]),
name="r_vadv")
entropy_loss = entropy_y_x(logit)
vat_loss = self.virtual_adversarial_loss(x, adj, logit)
model.add_loss(p1 * vat_loss + p2 * entropy_loss)
self.model = model
self.adv_optimizer = Adam(lr=lr / 10)
def build(self,
hiddens=[16],
activations=['relu'],
dropout=0.,
lr=0.01,
weight_decay=5e-4,
p1=1.4,
p2=0.7,
use_bias=False,
epsilon=0.01):
with tf.device(self.device):
x = Input(batch_shape=[None, self.graph.num_node_attrs],
dtype=self.floatx,
name='node_attr')
adj = Input(batch_shape=[None, None],
dtype=self.floatx,
sparse=True,
name='adj_matrix')
index = Input(batch_shape=[None],
dtype=self.intx,
name='node_index')
GCN_layers = []
for hidden, activation in zip(hiddens, activations):
GCN_layers.append(
GraphConvolution(
hidden,
activation=activation,
use_bias=use_bias,
kernel_regularizer=regularizers.l2(weight_decay)))
GCN_layers.append(
GraphConvolution(self.graph.num_node_classes,
use_bias=use_bias))
self.GCN_layers = GCN_layers
self.dropout = Dropout(rate=dropout)
logit = self.forward(x, adj)
output = Gather()([logit, index])
model = TFKeras(inputs=[x, adj, index], outputs=output)
model.compile(loss=SparseCategoricalCrossentropy(from_logits=True),
optimizer=Adam(lr=lr),
metrics=['accuracy'])
entropy_loss = entropy_y_x(logit)
vat_loss = self.virtual_adversarial_loss(x, adj, logit, epsilon)
model.add_loss(p1 * vat_loss + p2 * entropy_loss)
self.model = model