def process_step(self):
graph = self.graph
adj_matrix = self.adj_transform(graph.adj_matrix)
attr_matrix = self.attr_transform(graph.attr_matrix)
feature_inputs, structure_inputs = T.astensors(attr_matrix,
adj_matrix,
device=self.device)
if self.kind == "T":
# To avoid this tensorflow error in large dataset:
# InvalidArgumentError: Cannot use GPU when output.shape[1] * nnz(a) > 2^31 [Op:SparseTensorDenseMatMul]
if self.graph.n_attrs * adj_matrix.nnz > 2**31:
device = "CPU"
else:
device = self.device
with tf.device(device):
feature_inputs = tfSGConvolution(order=self.order)(
[feature_inputs, structure_inputs])
with tf.device(self.device):
self.feature_inputs, self.structure_inputs = feature_inputs, structure_inputs
else:
feature_inputs = pySGConvolution(order=self.order)(
[feature_inputs, structure_inputs])
self.feature_inputs, self.structure_inputs = feature_inputs, structure_inputs
def process_step(self):
graph = self.graph
adj_matrix = self.adj_transform(graph.adj_matrix)
attr_matrix = self.attr_transform(graph.attr_matrix)
self.feature_inputs, self.structure_inputs = T.astensors(
attr_matrix, adj_matrix, device=self.device)
def process_step(self):
graph = self.graph
adj_matrix = self.adj_transform(graph.adj_matrix)
attr_matrix = self.attr_transform(graph.attr_matrix)
edge_index, edge_weight = T.sparse_adj_to_sparse_edges(adj_matrix)
self.feature_inputs, self.structure_inputs = T.astensors(
attr_matrix, (edge_index.T, edge_weight), device=self.device)
def process_step(self):
graph = self.graph
attr_matrix = self.attr_transform(graph.attr_matrix)
batch_adj, batch_x, self.cluster_member = T.graph_partition(
graph.adj_matrix, attr_matrix, n_clusters=self.n_clusters)
batch_adj = self.adj_transform(*batch_adj)
(self.batch_adj, self.batch_x) = T.astensors(batch_adj,
batch_x,
device=self.device)
def process_step(self):
graph = self.graph
# Dense matrix, shape [n_nodes, max_degree]
adj_matrix = self.adj_transform(graph.adj_matrix)
attr_matrix = self.attr_transform(graph.attr_matrix)
# pad with a dummy zero vector
attr_matrix = np.vstack(
[attr_matrix, np.zeros(attr_matrix.shape[1], dtype=self.floatx)])
self.feature_inputs, self.structure_inputs = T.astensors(
attr_matrix, device=self.device), adj_matrix
def predict(self, index):
mask = T.indices2mask(index, self.graph.n_nodes)
orders_dict = {idx: order for order, idx in enumerate(index)}
batch_idx, orders = [], []
batch_x, batch_adj = [], []
for cluster in range(self.n_clusters):
nodes = self.cluster_member[cluster]
mini_mask = mask[nodes]
batch_nodes = np.asarray(nodes)[mini_mask]
if batch_nodes.size == 0:
continue
batch_x.append(self.batch_x[cluster])
batch_adj.append(self.batch_adj[cluster])
batch_idx.append(np.where(mini_mask)[0])
orders.append([orders_dict[n] for n in batch_nodes])
batch_data = tuple(zip(batch_x, batch_adj, batch_idx))
logit = np.zeros((index.size, self.graph.n_classes), dtype=self.floatx)
batch_data = T.astensors(batch_data, device=self.device)
model = self.model
if self.kind == "P":
model.eval()
with torch.no_grad():
for order, inputs in zip(orders, batch_data):
output = model(inputs).detach().cpu().numpy()
logit[order] = output
else:
with tf.device(self.device):
for order, inputs in zip(orders, batch_data):
output = model.predict_on_batch(inputs)
logit[order] = output
return logit
def train(self,
idx_train,
idx_val=None,
pre_train_epochs=100,
epochs=100,
early_stopping=None,
verbose=None,
save_best=True,
weight_path=None,
as_model=False,
monitor='val_acc',
early_stop_metric='val_loss'):
histories = []
index_all = tf.range(self.graph.n_nodes, dtype=self.intx)
# pre train model_q
self.model = self.model_q
history = super().train(idx_train,
idx_val,
epochs=pre_train_epochs,
early_stopping=early_stopping,
verbose=verbose,
save_best=save_best,
weight_path=weight_path,
as_model=True,
monitor=monitor,
early_stop_metric=early_stop_metric)
histories.append(history)
label_predict = self.predict(index_all).argmax(1)
label_predict[idx_train] = self.graph.labels[idx_train]
label_predict = tf.one_hot(label_predict, depth=self.graph.n_classes)
# train model_p fitst
train_sequence = FullBatchNodeSequence(
[label_predict, self.structure_inputs, index_all],
label_predict,
device=self.device)
if idx_val is not None:
val_sequence = FullBatchNodeSequence(
[label_predict, self.structure_inputs, idx_val],
self.labels_onehot[idx_val],
device=self.device)
else:
val_sequence = None
self.model = self.model_p
history = super().train(train_sequence,
val_sequence,
epochs=epochs,
early_stopping=early_stopping,
verbose=verbose,
save_best=save_best,
weight_path=weight_path,
as_model=as_model,
monitor=monitor,
early_stop_metric=early_stop_metric)
histories.append(history)
# then train model_q again
label_predict = self.model.predict_on_batch(
T.astensors(label_predict,
self.structure_inputs,
index_all,
device=self.device))
label_predict = softmax(label_predict)
if tf.is_tensor(label_predict):
label_predict = label_predict.numpy()
label_predict[idx_train] = self.labels_onehot[idx_train]
self.model = self.model_q
train_sequence = FullBatchNodeSequence(
[self.feature_inputs, self.structure_inputs, index_all],
label_predict,
device=self.device)
history = super().train(train_sequence,
idx_val,
epochs=epochs,
early_stopping=early_stopping,
verbose=verbose,
save_best=save_best,
weight_path=weight_path,
as_model=as_model,
monitor=monitor,
early_stop_metric=early_stop_metric)
histories.append(history)
return histories
