What is the purpose of testing and recording accuracy every 100 rounds during training? Isn't the pre-training process an unsupervised process? According to the DGI paper and code implementation, DGI only has a gradient descent in the training process until the loss stops getting smaller (early stopping) and then the training ends.

I don't think the value of infonce loss is necessarily inversely proportional to the result of linear evaluation, but controlling the training of graph contrastive learning according to the result of linear evaluation is fitting the dataset. So, when should the training of graph contrastive learning end? And how to compare the different graph contrastive learning methods fairly?

Also the final accuracy calculation in the code implementation only calculates the accuracy of one random split of the dataset, and does not calculate the accuracy of multiple splits (or multiple run of logistic regression like DGI) and calculate the final average acc.

Hi, thanks for reading this!

When I reproduce the results of WikiCS by the provided hyperparameters and code (nothing changed), I cannot reproduce the results shown in the paper, i.e., 78%+. I only can achieve 32%+ accuracy.

Do you have any hints on it? Is that caused by hyperparameter setting?

Thanks!

drop weightis is computed according to the folllowing codes in pGRACE/functional.py :

`def pr_drop_weights(edge_index, aggr: str = 'sink', k: int = 10): pv = compute_pr(edge_index, k=k) pv_row = pv[edge_index[0]].to(torch.float32) pv_col = pv[edge_index[1]].to(torch.float32) s_row = torch.log(pv_row) s_col = torch.log(pv_col) if aggr == 'sink': s = s_col elif aggr == 'source': s = s_row elif aggr == 'mean': s = (s_col + s_row) * 0.5 else: s = s_col weights = (s.max() - s) / (s.max() - s.mean())

return `

However, in debugging codes, I found that some elements in array pv could be 0 (while using WikiCS for training). After executed torch.log(), min value of s_row and s_col will be -inf, resulted in all of weights became 0. At that time, the weights was meaningless.

Sorry to bother you, I am confused that why edge_weights divided by edge_weights.mean()？

def drop_edge_weighted(edge_index, edge_weights, p: float, threshold: float = 1.): edge_weights = edge_weights / edge_weights.mean() * p edge_weights = edge_weights.where(edge_weights < threshold, torch.ones_like(edge_weights) * threshold) sel_mask = torch.bernoulli(1. - edge_weights).to(torch.bool) return edge_index[:, sel_mask]