def fit(self, model: SupervisedHomogeneousNodeClassificationModel,
dataset):
self.optimizer = torch.optim.Adam(model.parameters(),
lr=self.args.lr,
weight_decay=self.args.weight_decay)
device = self.args.device_id[0] if not self.args.cpu else "cpu"
data = dataset[0]
data.apply(lambda x: x.to(device))
self.max_epoch = self.args.max_epoch
row, col = data.edge_index
row, col = row.cpu().numpy(), col.cpu().numpy()
num_edge = row.shape[0]
num_node = data.x.to("cpu").shape[0]
self.graph.add_nodes(num_node)
for i in range(num_edge):
src, dst = row[i], col[i]
self.graph.add_edge(src, dst)
self.graph = self.graph.to(device)
model.set_graph(self.graph)
self.data = data
self.model = model.to(device)
epoch_iter = tqdm(range(self.max_epoch))
best_score = 0
best_loss = np.inf
max_score = 0
min_loss = np.inf
for epoch in epoch_iter:
self._train_step()
train_acc, _ = self._test_step(split="train")
val_acc, val_loss = self._test_step(split="val")
epoch_iter.set_description(
f"Epoch: {epoch:03d}, Train: {train_acc:.4f}, Val: {val_acc:.4f}"
)
if val_loss <= min_loss or val_acc >= max_score:
if val_loss <= best_loss: # and val_acc >= best_score:
best_loss = val_loss
best_score = val_acc
min_loss = np.min((min_loss, val_loss))
max_score = np.max((max_score, val_acc))
print(f"Best accurracy = {best_score}")
test_acc, _ = self._test_step(split="test")
print(f"Test accuracy = {test_acc}")
return dict(Acc=test_acc)
def fit(self, model: SupervisedHomogeneousNodeClassificationModel, dataset: Dataset):
# self.resplit_data(dataset.data)
self.data = dataset.data
self.original_data = dataset.data
self.data.apply(lambda x: x.to(self.device))
self.original_data.apply(lambda x: x.to(self.device))
if self.auxiliary_task == "edgemask":
self.agent = EdgeMask(self.data.edge_index, self.data.x, self.hidden_size, self.device)
elif self.auxiliary_task == "pairwise-distance":
self.agent = PairwiseDistance(self.data.edge_index, self.data.x, self.hidden_size, 3, self.device)
elif self.auxiliary_task == "distance2clusters":
self.agent = Distance2Clusters(self.data.edge_index, self.data.x, self.hidden_size, 30, self.device)
elif self.auxiliary_task == "pairwise-attr-sim":
self.agent = PairwiseAttrSim(self.data.edge_index, self.data.x, self.hidden_size, 5, self.device)
elif self.auxiliary_task == "distance2clusters++":
self.agent = Distance2ClustersPP(
self.data.edge_index, self.data.x, self.data.y, self.hidden_size, 5, 1, self.device
)
else:
raise Exception(
"auxiliary task must be edgemask, pairwise-distance, distance2clusters, distance2clusters++ or pairwise-attr-sim"
)
self.model = model
self.optimizer = torch.optim.Adam(
list(model.parameters()) + list(self.agent.linear.parameters()), lr=self.lr, weight_decay=self.weight_decay
)
self.model.to(self.device)
epoch_iter = tqdm(range(self.max_epoch))
best_score = 0
best_loss = np.inf
max_score = 0
min_loss = np.inf
for epoch in epoch_iter:
if self.auxiliary_task == "distance2clusters++" and epoch % 40 == 0:
self.agent.update_cluster()
self._train_step()
train_acc, _ = self._test_step(split="train")
val_acc, val_loss = self._test_step(split="val")
epoch_iter.set_description(f"Epoch: {epoch:03d}, Train: {train_acc:.4f}, Val: {val_acc:.4f}")
if val_loss <= min_loss or val_acc >= max_score:
if val_loss <= best_loss: # and val_acc >= best_score:
best_loss = val_loss
best_score = val_acc
best_model = copy.deepcopy(self.model)
min_loss = np.min((min_loss, val_loss))
max_score = np.max((max_score, val_acc))
print(f"Valid accurracy = {best_score}")
return best_model
def fit(self, model: SupervisedHomogeneousNodeClassificationModel, dataset: Dataset):
self.data = dataset.data
self.data.add_remaining_self_loops()
self.set_agent()
self.original_data = dataset.data
self.original_data.add_remaining_self_loops()
self.model = model
self.set_loss_eval(dataset)
self.optimizer = torch.optim.Adam(
list(model.parameters()) + list(self.agent.linear.parameters()), lr=self.lr, weight_decay=self.weight_decay
)
self.model.to(self.device)
self.best_model = None
self.pretrain()
return self.finetune()
def fit(self, model: SupervisedHomogeneousNodeClassificationModel,
dataset: Dataset):
# self.resplit_data(dataset.data)
self.data = dataset.data
self.original_data = dataset.data
self.data.to(self.device)
self.set_agent()
self.data = self.agent.transform_data()
self.original_data.apply(lambda x: x.to(self.device))
self.model = model
self.set_loss_eval(dataset)
self.optimizer = torch.optim.Adam(list(model.parameters()) +
list(self.agent.linear.parameters()),
lr=self.lr,
weight_decay=self.weight_decay)
self.model.to(self.device)
epoch_iter = tqdm(range(self.max_epoch))
best_score = 0
best_loss = np.inf
max_score = 0
min_loss = np.inf
for epoch in epoch_iter:
if self.auxiliary_task == "distance2clusters++" and epoch % 40 == 0:
self.agent.update_cluster()
aux_loss = self._train_step()
train_acc, _ = self._test_step(split="train")
val_acc, val_loss = self._test_step(split="val")
test_acc, test_loss = self._test_step(split="test")
epoch_iter.set_description(
f"Epoch: {epoch:03d}, Train: {train_acc:.4f}, Val: {val_acc:.4f}, Test: {test_acc:.4f}, Aux loss: {aux_loss:.4f}"
)
if val_loss <= min_loss or val_acc >= max_score:
if val_loss <= best_loss: # and val_acc >= best_score:
best_loss = val_loss
best_score = val_acc
best_model = copy.deepcopy(self.model)
min_loss = np.min((min_loss, val_loss.cpu()))
max_score = np.max((max_score, val_acc))
print(f"Valid accurracy = {best_score}")
return best_model