Add files using upload-large-folder tool

Graph/GraphMAE_MQ9/README.md

@@ -0,0 +1,43 @@
+# Graph Mask AutoEncoder(GraphMAE) on QM9 Dataset
+## Overview
+We run the **Graph Mask AutoEncoder** on **QM9 Dataset** for pretraining. We use the atom position of each atom and the embedding of their element type as the input feature (dim=7) and predict the input feature by using the GraphSage with 4-dim hidden representation.
+
+**Total Epochs: 10**
+## How to run
+### If you do not want to re-train the model again
+- **Unzip the model.zip** to get the model weight & embedded graph in each epoch
+### If you want to try out the training process
+- step1. **Preprocess the dataset** (we have provided the preprocessed as well)
+
+```bash
+python prepare_QM9_dataset.py --label_keys "mu" "gap"
+```
+- step2. **Train the Graph Mask AutoEncoder on the preprocessed dataset**
+```bash
+python run.py [--dataset_path] [--batch_size] [--epochs] [--device] [--save_dir]
+```
+
+## Model Description
+### Overview
+Ref:**[GraphMAE](https://arxiv.org/abs/2205.10803)**
+>Self-supervised learning (SSL) has been extensively explored in recent years. Particularly, generative SSL has seen emerging success in natural language processing and other AI fields, such as the wide adoption of BERT and GPT. Despite this, contrastive learning-which heavily relies on structural data augmentation and complicated training strategies-has been the dominant approach in graph SSL, while the progress of generative SSL on graphs, especially graph autoencoders (GAEs), has thus far not reached the potential as promised in other fields. In this paper, we identify and examine the issues that negatively impact the development of GAEs, including their reconstruction objective, training robustness, and error metric. We present a masked graph autoencoder GraphMAE that mitigates these issues for generative self-supervised graph pretraining. Instead of reconstructing graph structures, we propose to focus on feature reconstruction with both a masking strategy and scaled cosine error that benefit the robust training of GraphMAE. We conduct extensive experiments on 21 public datasets for three different graph learning tasks. The results manifest that GraphMAE-a simple graph autoencoder with careful designs-can consistently generate outperformance over both contrastive and generative state-of-the-art baselines. This study provides an understanding of graph autoencoders and demonstrates the potential of generative self-supervised pre-training on graphs.
+
+### Detail
+Encoder & Decoder: Two layer [GraphSage](https://docs.dgl.ai/generated/dgl.nn.pytorch.conv.SAGEConv.html)
+
+Readout Method: Mean
+
+HiddenDims: 4 (Default)
+
+MaskRate: 0.3 (Default)
+
+Training on RTX 4060
+
+## Dataset Description
+### Overview
+Ref: **[QM9](https://docs.dgl.ai/generated/dgl.data.QM9Dataset.html)**
+> Type: Molecule property prediction 
+> 
+> Sample_num: 130831
+> 
+> Total Elements: H,C,N,O,F

Graph/GraphMAE_MQ9/code/QM9_dataset_class.py

@@ -0,0 +1,51 @@
+import os
+
+from tqdm import tqdm
+import networkx as nx
+import torch
+from torch.utils.data import Dataset
+
+atom_number_index_dict = {
+    1: 0,  # H
+    6: 1,  # C
+    7: 2,  # N
+    8: 3,  # O
+    9: 4  # F
+}
+atom_index_number_dict = {v: k for k, v in atom_number_index_dict.items()}
+max_atom_number = max(atom_number_index_dict.keys())
+
+
+def atom_number2index(atom_number):
+    return atom_number_index_dict[atom_number]
+
+
+def atom_index2number(atom_index):
+    return atom_index_number_dict[atom_index]
+
+
+class PreprocessedQM9Dataset(Dataset):
+    def __init__(self, dataset):
+        self.dataset = dataset
+        self.processed_data = []
+        if dataset is not None:
+            self._preprocess()
+    def _preprocess(self):
+        i = 0
+        for g, label in tqdm(self.dataset):
+            g.ndata["Z_index"] = torch.tensor([atom_number2index(z.item()) for z in g.ndata["Z"]])
+            g.ndata["sample_idx"] = i
+            self.processed_data.append((g, label))
+
+    def __len__(self):
+        return len(self.processed_data)
+
+    def __getitem__(self, idx):
+        return self.processed_data[idx]
+
+    def save_dataset(self, save_dir):
+        if not os.path.exists(save_dir):
+            os.makedirs(save_dir)
+        torch.save(self.processed_data, os.path.join(save_dir,"QM9_dataset_processed.pt"))
+    def load_dataset(self, dataset_path):
+        self.processed_data = torch.load(dataset_path)

Graph/GraphMAE_MQ9/code/lib/metrics.py

@@ -0,0 +1,95 @@
+# -*- coding:utf-8 -*-
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+
+def masked_mape_np(y_true, y_pred, null_val=np.nan):
+    with np.errstate(divide='ignore', invalid='ignore'):
+        if np.isnan(null_val):
+            mask = ~np.isnan(y_true)
+        else:
+            mask = np.not_equal(y_true, null_val)
+        mask = mask.astype('float32')
+        mask /= np.mean(mask)
+        mape = np.abs(np.divide(np.subtract(y_pred, y_true).astype('float32'),
+                                y_true))
+        mape = np.nan_to_num(mask * mape)
+        return np.mean(mape)
+
+
+def masked_mse(preds, labels, null_val=np.nan):
+    if np.isnan(null_val):
+        mask = ~torch.isnan(labels)
+    else:
+        mask = (labels != null_val)
+    mask = mask.float()
+    # print(mask.sum())
+    # print(mask.shape[0]*mask.shape[1]*mask.shape[2])
+    mask /= torch.mean((mask))
+    mask = torch.where(torch.isnan(mask), torch.zeros_like(mask), mask)
+    loss = (preds - labels) ** 2
+    loss = loss * mask
+    loss = torch.where(torch.isnan(loss), torch.zeros_like(loss), loss)
+    return torch.mean(loss)
+
+
+def masked_rmse(preds, labels, null_val=np.nan):
+    return torch.sqrt(masked_mse(preds=preds, labels=labels,
+                                 null_val=null_val))
+
+
+def masked_mae(preds, labels, null_val=np.nan):
+    if np.isnan(null_val):
+        mask = ~torch.isnan(labels)
+    else:
+        mask = (labels != null_val)
+    mask = mask.float()
+    mask /= torch.mean((mask))
+    mask = torch.where(torch.isnan(mask), torch.zeros_like(mask), mask)
+    loss = torch.abs(preds - labels)
+    loss = loss * mask
+    loss = torch.where(torch.isnan(loss), torch.zeros_like(loss), loss)
+    return torch.mean(loss)
+
+
+def masked_mae_test(y_true, y_pred, null_val=np.nan):
+    with np.errstate(divide='ignore', invalid='ignore'):
+        if np.isnan(null_val):
+            mask = ~np.isnan(y_true)
+        else:
+            mask = np.not_equal(y_true, null_val)
+        mask = mask.astype('float32')
+        mask /= np.mean(mask)
+        mae = np.abs(np.subtract(y_pred, y_true).astype('float32'),
+                     )
+        mae = np.nan_to_num(mask * mae)
+        return np.mean(mae)
+
+
+def masked_rmse_test(y_true, y_pred, null_val=np.nan):
+    with np.errstate(divide='ignore', invalid='ignore'):
+        if np.isnan(null_val):
+            mask = ~np.isnan(y_true)
+        else:
+            # null_val=null_val
+            mask = np.not_equal(y_true, null_val)
+        mask = mask.astype('float32')
+        mask /= np.mean(mask)
+        mse = ((y_pred - y_true) ** 2)
+        mse = np.nan_to_num(mask * mse)
+        return np.sqrt(np.mean(mse))
+
+
+def sce_loss(x, y, alpha=3):
+    x = F.normalize(x, p=2, dim=-1)
+    y = F.normalize(y, p=2, dim=-1)
+
+    # loss =  - (x * y).sum(dim=-1)
+    # loss = (x_h - y_h).norm(dim=1).pow(alpha)
+
+    loss = (1 - (x * y).sum(dim=-1)).pow_(alpha)
+
+    loss = loss.mean()
+    return loss

Graph/GraphMAE_MQ9/code/lib/utils.py

@@ -0,0 +1,397 @@
+import os
+import numpy as np
+import torch
+import torch.utils.data
+from sklearn.metrics import mean_absolute_error
+from sklearn.metrics import mean_squared_error
+import sys
+project_path = "/content/gdrive//My Drive/CS5248_project"
+sys.path.append(project_path + '/lib')
+from metrics import masked_mape_np
+from scipy.sparse.linalg import eigs
+from metrics import masked_mape_np,  masked_mae,masked_mse,masked_rmse,masked_mae_test,masked_rmse_test
+
+
+def re_normalization(x, mean, std):
+    x = x * std + mean
+    return x
+
+
+def max_min_normalization(x, _max, _min):
+    x = 1. * (x - _min)/(_max - _min)
+    x = x * 2. - 1.
+    return x
+
+
+def re_max_min_normalization(x, _max, _min):
+    x = (x + 1.) / 2.
+    x = 1. * x * (_max - _min) + _min
+    return x
+
+
+def get_adjacency_matrix(distance_df_filename, num_of_vertices, id_filename=None):
+    '''
+    Parameters
+    ----------
+    distance_df_filename: str, path of the csv file contains edges information
+
+    num_of_vertices: int, the number of vertices
+
+    Returns
+    ----------
+    A: np.ndarray, adjacency matrix
+
+    '''
+    if 'npy' in distance_df_filename:
+
+        adj_mx = np.load(distance_df_filename)
+
+        return adj_mx, None
+
+    else:
+
+        import csv
+
+        A = np.zeros((int(num_of_vertices), int(num_of_vertices)),
+                     dtype=np.float32)
+
+        distaneA = np.zeros((int(num_of_vertices), int(num_of_vertices)),
+                            dtype=np.float32)
+
+        if id_filename:
+
+            with open(id_filename, 'r') as f:
+                id_dict = {int(i): idx for idx, i in enumerate(f.read().strip().split('\n'))}  # 把节点id（idx）映射成从0开始的索引
+
+            with open(distance_df_filename, 'r') as f:
+                f.readline()
+                reader = csv.reader(f)
+                for row in reader:
+                    if len(row) != 3:
+                        continue
+                    i, j, distance = int(row[0]), int(row[1]), float(row[2])
+                    A[id_dict[i], id_dict[j]] = 1
+                    distaneA[id_dict[i], id_dict[j]] = distance
+            return A, distaneA
+
+        else:
+
+            with open(distance_df_filename, 'r') as f:
+                f.readline()
+                reader = csv.reader(f)
+                for row in reader:
+                    if len(row) != 3:
+                        continue
+                    i, j, distance = int(row[0]), int(row[1]), float(row[2])
+                    A[i, j] = 1
+                    distaneA[i, j] = distance
+            return A, distaneA
+
+
+def scaled_Laplacian(W):
+    '''
+    compute \tilde{L}
+
+    Parameters
+    ----------
+    W: np.ndarray, shape is (N, N), N is the num of vertices
+
+    Returns
+    ----------
+    scaled_Laplacian: np.ndarray, shape (N, N)
+
+    '''
+
+    assert W.shape[0] == W.shape[1]
+
+    D = np.diag(np.sum(W, axis=1))
+
+    L = D - W
+
+    lambda_max = eigs(L, k=1, which='LR')[0].real
+
+    return (2 * L) / lambda_max - np.identity(W.shape[0])
+
+
+def cheb_polynomial(L_tilde, K):
+    '''
+    compute a list of chebyshev polynomials from T_0 to T_{K-1}
+
+    Parameters
+    ----------
+    L_tilde: scaled Laplacian, np.ndarray, shape (N, N)
+
+    K: the maximum order of chebyshev polynomials
+
+    Returns
+    ----------
+    cheb_polynomials: list(np.ndarray), length: K, from T_0 to T_{K-1}
+
+    '''
+
+    N = L_tilde.shape[0]
+
+    cheb_polynomials = [np.identity(N), L_tilde.copy()]
+
+    for i in range(2, K):
+        cheb_polynomials.append(2 * L_tilde * cheb_polynomials[i - 1] - cheb_polynomials[i - 2])
+
+    return cheb_polynomials
+
+
+def load_graphdata_channel1(graph_signal_matrix_filename, num_of_indices, DEVICE, batch_size, shuffle=True):
+    '''
+    这个是为PEMS的数据准备的函数
+    将x,y都处理成归一化到[-1,1]之前的数据;
+    每个样本同时包含所有监测点的数据，所以本函数构造的数据输入时空序列预测模型；
+    该函数会把hour, day, week的时间串起来；
+    注： 从文件读入的数据，x是最大最小归一化的，但是y是真实值
+    这个函数转为mstgcn，astgcn设计，返回的数据x都是通过减均值除方差进行归一化的，y都是真实值
+    :param graph_signal_matrix_filename: str
+    :param num_of_hours: int
+    :param num_of_days: int
+    :param num_of_weeks: int
+    :param DEVICE:
+    :param batch_size: int
+    :return:
+    three DataLoaders, each dataloader contains:
+    test_x_tensor: (B, N_nodes, in_feature, T_input)
+    test_decoder_input_tensor: (B, N_nodes, T_output)
+    test_target_tensor: (B, N_nodes, T_output)
+
+    '''
+
+    file = os.path.basename(graph_signal_matrix_filename).split('.')[0]
+
+    dirpath = os.path.dirname(graph_signal_matrix_filename)
+
+    filename = os.path.join(dirpath,
+                            file) +'_astcgn'
+
+    print('load file:', filename)
+
+    file_data = np.load(filename + '.npz')
+    train_x = file_data['train_x']  # (10181, 307, 3, 12)
+    train_x = train_x[:, :, 0:5, :]
+    train_target = file_data['train_target']  # (10181, 307, 12)
+
+    val_x = file_data['val_x']
+    val_x = val_x[:, :, 0:5, :]
+    val_target = file_data['val_target']
+
+    test_x = file_data['test_x']
+    test_x = test_x[:, :, 0:5, :]
+    test_target = file_data['test_target']
+
+    mean = file_data['mean'][:, :, 0:5, :]  # (1, 1, 3, 1)
+    std = file_data['std'][:, :, 0:5, :]  # (1, 1, 3, 1)
+
+    # ------- train_loader -------
+    train_x_tensor = torch.from_numpy(train_x).type(torch.FloatTensor).to(DEVICE)  # (B, N, F, T)
+    train_target_tensor = torch.from_numpy(train_target).type(torch.FloatTensor).to(DEVICE)  # (B, N, T)
+
+    train_dataset = torch.utils.data.TensorDataset(train_x_tensor, train_target_tensor)
+
+    train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle)
+
+    # ------- val_loader -------
+    val_x_tensor = torch.from_numpy(val_x).type(torch.FloatTensor).to(DEVICE)  # (B, N, F, T)
+    val_target_tensor = torch.from_numpy(val_target).type(torch.FloatTensor).to(DEVICE)  # (B, N, T)
+
+    val_dataset = torch.utils.data.TensorDataset(val_x_tensor, val_target_tensor)
+
+    val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
+
+    # ------- test_loader -------
+    test_x_tensor = torch.from_numpy(test_x).type(torch.FloatTensor).to(DEVICE)  # (B, N, F, T)
+    test_target_tensor = torch.from_numpy(test_target).type(torch.FloatTensor).to(DEVICE)  # (B, N, T)
+
+    test_dataset = torch.utils.data.TensorDataset(test_x_tensor, test_target_tensor)
+
+    test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
+
+    # print
+    print('train:', train_x_tensor.size(), train_target_tensor.size())
+    print('val:', val_x_tensor.size(), val_target_tensor.size())
+    print('test:', test_x_tensor.size(), test_target_tensor.size())
+
+    return train_loader, train_target_tensor, val_loader, val_target_tensor, test_loader, test_target_tensor, mean, std
+
+
+def compute_val_loss_mstgcn(net, val_loader, criterion,  masked_flag,missing_value,sw, epoch, limit=None):
+    '''
+    for rnn, compute mean loss on validation set
+    :param net: model
+    :param val_loader: torch.utils.data.utils.DataLoader
+    :param criterion: torch.nn.MSELoss
+    :param sw: tensorboardX.SummaryWriter
+    :param global_step: int, current global_step
+    :param limit: int,
+    :return: val_loss
+    '''
+
+    net.train(False)  # ensure dropout layers are in evaluation mode
+
+    with torch.no_grad():
+
+        val_loader_length = len(val_loader)  # nb of batch
+
+        tmp = []  # 记录了所有batch的loss
+
+        for batch_index, batch_data in enumerate(val_loader):
+            encoder_inputs, labels = batch_data
+            outputs = net(encoder_inputs)
+            if masked_flag:
+                loss = criterion(outputs, labels, missing_value)
+            else:
+                loss = criterion(outputs, labels)
+
+            tmp.append(loss.item())
+            if batch_index % 100 == 0:
+                print('validation batch %s / %s, loss: %.2f' % (batch_index + 1, val_loader_length, loss.item()))
+            if (limit is not None) and batch_index >= limit:
+                break
+
+        validation_loss = sum(tmp) / len(tmp)
+        sw.add_scalar('validation_loss', validation_loss, epoch)
+    return validation_loss
+
+
+# def evaluate_on_test_mstgcn(net, test_loader, test_target_tensor, sw, epoch, _mean, _std):
+#     '''
+#     for rnn, compute MAE, RMSE, MAPE scores of the prediction for every time step on testing set.
+#
+#     :param net: model
+#     :param test_loader: torch.utils.data.utils.DataLoader
+#     :param test_target_tensor: torch.tensor (B, N_nodes, T_output, out_feature)=(B, N_nodes, T_output, 1)
+#     :param sw:
+#     :param epoch: int, current epoch
+#     :param _mean: (1, 1, 3(features), 1)
+#     :param _std: (1, 1, 3(features), 1)
+#     '''
+#
+#     net.train(False)  # ensure dropout layers are in test mode
+#
+#     with torch.no_grad():
+#
+#         test_loader_length = len(test_loader)
+#
+#         test_target_tensor = test_target_tensor.cpu().numpy()
+#
+#         prediction = []  # 存储所有batch的output
+#
+#         for batch_index, batch_data in enumerate(test_loader):
+#
+#             encoder_inputs, labels = batch_data
+#
+#             outputs = net(encoder_inputs)
+#
+#             prediction.append(outputs.detach().cpu().numpy())
+#
+#             if batch_index % 100 == 0:
+#                 print('predicting testing set batch %s / %s' % (batch_index + 1, test_loader_length))
+#
+#         prediction = np.concatenate(prediction, 0)  # (batch, T', 1)
+#         prediction_length = prediction.shape[2]
+#
+#         for i in range(prediction_length):
+#             assert test_target_tensor.shape[0] == prediction.shape[0]
+#             print('current epoch: %s, predict %s points' % (epoch, i))
+#             mae = mean_absolute_error(test_target_tensor[:, :, i], prediction[:, :, i])
+#             rmse = mean_squared_error(test_target_tensor[:, :, i], prediction[:, :, i]) ** 0.5
+#             mape = masked_mape_np(test_target_tensor[:, :, i], prediction[:, :, i], 0)
+#             print('MAE: %.2f' % (mae))
+#             print('RMSE: %.2f' % (rmse))
+#             print('MAPE: %.2f' % (mape))
+#             print()
+#             if sw:
+#                 sw.add_scalar('MAE_%s_points' % (i), mae, epoch)
+#                 sw.add_scalar('RMSE_%s_points' % (i), rmse, epoch)
+#                 sw.add_scalar('MAPE_%s_points' % (i), mape, epoch)
+
+
+def predict_and_save_results_mstgcn(net, data_loader, data_target_tensor, global_step, metric_method,_mean, _std, params_path, type):
+    '''
+
+    :param net: nn.Module
+    :param data_loader: torch.utils.data.utils.DataLoader
+    :param data_target_tensor: tensor
+    :param epoch: int
+    :param _mean: (1, 1, 3, 1)
+    :param _std: (1, 1, 3, 1)
+    :param params_path: the path for saving the results
+    :return:
+    '''
+    net.train(False)  # ensure dropout layers are in test mode
+
+    with torch.no_grad():
+
+        data_target_tensor = data_target_tensor.cpu().numpy()
+
+        loader_length = len(data_loader)  # nb of batch
+
+        prediction = []  # 存储所有batch的output
+
+        input = []  # 存储所有batch的input
+
+        for batch_index, batch_data in enumerate(data_loader):
+
+            encoder_inputs, labels = batch_data
+
+            input.append(encoder_inputs[:, :, 0:1].cpu().numpy())  # (batch, T', 1)
+
+            outputs = net(encoder_inputs)
+
+            prediction.append(outputs.detach().cpu().numpy())
+
+            if batch_index % 100 == 0:
+                print('predicting data set batch %s / %s' % (batch_index + 1, loader_length))
+
+        input = np.concatenate(input, 0)
+
+        input = re_normalization(input, _mean, _std)
+
+        prediction = np.concatenate(prediction, 0)  # (batch, T', 1)
+
+        print('input:', input.shape)
+        print('prediction:', prediction.shape)
+        print('data_target_tensor:', data_target_tensor.shape)
+        output_filename = os.path.join(params_path, 'output_epoch_%s_%s' % (global_step, type))
+        np.savez(output_filename, input=input, prediction=prediction, data_target_tensor=data_target_tensor)
+
+        # 计算误差
+        excel_list = []
+        prediction_length = prediction.shape[2]
+
+        for i in range(prediction_length):
+            assert data_target_tensor.shape[0] == prediction.shape[0]
+            print('current epoch: %s, predict %s points' % (global_step, i))
+            if metric_method == 'mask':
+                mae = masked_mae_test(data_target_tensor[:, :, i], prediction[:, :, i],0.0)
+                rmse = masked_rmse_test(data_target_tensor[:, :, i], prediction[:, :, i],0.0)
+                mape = masked_mape_np(data_target_tensor[:, :, i], prediction[:, :, i], 0)
+            else :
+                mae = mean_absolute_error(data_target_tensor[:, :, i], prediction[:, :, i])
+                rmse = mean_squared_error(data_target_tensor[:, :, i], prediction[:, :, i]) ** 0.5
+                mape = masked_mape_np(data_target_tensor[:, :, i], prediction[:, :, i], 0)
+            print('MAE: %.2f' % (mae))
+            print('RMSE: %.2f' % (rmse))
+            print('MAPE: %.2f' % (mape))
+            excel_list.extend([mae, rmse, mape])
+
+        # print overall results
+        if metric_method == 'mask':
+            mae = masked_mae_test(data_target_tensor.reshape(-1, 1), prediction.reshape(-1, 1), 0.0)
+            rmse = masked_rmse_test(data_target_tensor.reshape(-1, 1), prediction.reshape(-1, 1), 0.0)
+            mape = masked_mape_np(data_target_tensor.reshape(-1, 1), prediction.reshape(-1, 1), 0)
+        else :
+            mae = mean_absolute_error(data_target_tensor.reshape(-1, 1), prediction.reshape(-1, 1))
+            rmse = mean_squared_error(data_target_tensor.reshape(-1, 1), prediction.reshape(-1, 1)) ** 0.5
+            mape = masked_mape_np(data_target_tensor.reshape(-1, 1), prediction.reshape(-1, 1), 0)
+        print('all MAE: %.2f' % (mae))
+        print('all RMSE: %.2f' % (rmse))
+        print('all MAPE: %.2f' % (mape))
+        excel_list.extend([mae, rmse, mape])
+        print(excel_list)
+
+

Graph/GraphMAE_MQ9/code/model.py

@@ -0,0 +1,90 @@
+from functools import partial
+import sys
+
+sys.path.append("lib")
+from lib.metrics import sce_loss
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import dgl.nn as dglnn
+
+
+class GMae(nn.Module):
+    def __init__(self, encoder, decoder,
+                 in_dim, hidden_dim, out_dim, mask_rate=0.3, replace_rate=0.1, alpha_l=2,
+                 embedding_layer_classes=5, embedding_layer_dim=4):
+        super(GMae, self).__init__()
+        self.Z_embedding = nn.Embedding(embedding_layer_classes, embedding_layer_dim)
+        self.encoder = encoder
+        self.decoder = decoder
+        self.mask_rate = mask_rate
+        self.replace_rate = replace_rate
+        self.alpha_l = alpha_l
+        self.in_dim = in_dim
+        self.hidden_dim = hidden_dim
+        self.out_dim = out_dim
+        self.embedding_layer_classes = embedding_layer_classes
+        self.embedding_layer_dim = embedding_layer_dim
+        self.enc_mask_token = nn.Parameter(torch.zeros(1, in_dim))
+        self.criterion = partial(sce_loss, alpha=alpha_l)
+        self.encoder_to_decoder = nn.Linear(hidden_dim, hidden_dim, bias=False)
+
+    def encode_atom_index(self, Z_index):
+        return self.Z_embedding(Z_index)
+
+    def encoding_mask_noise(self, g, x, mask_rate=0.3):
+        num_nodes = g.num_nodes()
+        perm = torch.randperm(num_nodes, device=x.device)
+        # random masking
+        num_mask_nodes = int(mask_rate * num_nodes)
+        mask_nodes = perm[: num_mask_nodes]
+        keep_nodes = perm[num_mask_nodes:]
+
+        if self.replace_rate > 0:
+            num_noise_nodes = int(self.replace_rate * num_mask_nodes)
+            perm_mask = torch.randperm(num_mask_nodes, device=x.device)
+            token_nodes = mask_nodes[perm_mask[: int((1 - self.replace_rate) * num_mask_nodes)]]
+            noise_nodes = mask_nodes[perm_mask[-int(self.replace_rate * num_mask_nodes):]]
+            noise_to_be_chosen = torch.randperm(num_nodes, device=x.device)[:num_noise_nodes]
+            out_x = x.clone()
+            out_x[token_nodes] = 0.0
+            out_x[noise_nodes] = x[noise_to_be_chosen]
+        else:
+            out_x = x.clone()
+            token_nodes = mask_nodes
+            out_x[mask_nodes] = 0.0
+
+        out_x[token_nodes] += self.enc_mask_token
+        use_g = g.clone()
+
+        return use_g, out_x, (mask_nodes, keep_nodes)
+
+    def mask_attr_prediction(self, g, x):
+        use_g, use_x, (mask_nodes, keep_nodes) = self.encoding_mask_noise(g, x, self.mask_rate)
+        enc_rep = self.encoder(use_g, use_x)
+        # ---- attribute reconstruction ----
+        rep = self.encoder_to_decoder(enc_rep)
+        recon = self.decoder(use_g, rep)
+        x_init = x[mask_nodes]
+        x_rec = recon[mask_nodes]
+        loss = self.criterion(x_rec, x_init)
+        return loss
+
+    def embed(self, g, x):
+        rep = self.encoder(g, x)
+        return rep
+
+
+class SimpleGnn(nn.Module):
+    def __init__(self, in_feats, hid_feats, out_feats):
+        super().__init__()
+        self.conv1 = dglnn.SAGEConv(
+            in_feats=in_feats, out_feats=hid_feats, aggregator_type="mean")
+        self.conv2 = dglnn.SAGEConv(
+            in_feats=hid_feats, out_feats=out_feats, aggregator_type="mean")
+
+    def forward(self, graph, inputs):
+        h = self.conv1(graph, inputs)
+        h = F.relu(h)
+        h = self.conv2(graph, h)
+        return h

Graph/GraphMAE_MQ9/code/prepare_QM9_dataset.py

@@ -0,0 +1,48 @@
+import argparse
+import os
+import time
+
+from dgl.data import QM9Dataset
+from dgl.dataloading import GraphDataLoader
+from rdkit import Chem
+from rdkit import RDLogger;
+from torch.utils.data import Dataset
+import torch.nn.functional as F
+from tqdm import tqdm
+import ast
+
+from QM9_dataset_class import PreprocessedQM9Dataset
+
+RDLogger.DisableLog('rdApp.*')
+import torch
+import torch.nn as nn
+import torch.optim as optim
+
+
+QM9_label_keys = ['mu','alpha','homo','lumo','gap','r2','zpve','U0','U','H','G','Cv']
+
+
+
+def prepare_main(label_keys=None, cutoff=5.0,save_path="dataset"):
+    assert save_path !="","save_path shouldn't be empty"
+    if label_keys is None:
+        raise ValueError('label_keys cannot be None')
+    for label_key in label_keys:
+        if label_key not in QM9_label_keys:
+            raise ValueError('label_key must be in QM9_label_keys,refer:https://docs.dgl.ai/en/0.8.x/generated/dgl.data.QM9Dataset.html')
+    dataset = QM9Dataset(label_keys=label_keys, cutoff=5.0)
+    dataset_processed = PreprocessedQM9Dataset(dataset)
+    print("Store processed QM9 dataset:",save_path)
+    dataset_processed.save_dataset("dataset")
+    return dataset_processed
+
+def main():
+    parser = argparse.ArgumentParser(description="Prepare QM9 dataset")
+    parser.add_argument('--label_keys', nargs='+', help="label keys in QM9 dataset,like 'mu' 'gap'....")
+    parser.add_argument('--cutoff', type=float, default=5.0, help="cutoff for atom number")
+    parser.add_argument('--save_path', type=str, default="dataset", help="processed_dataset save path")
+    args = parser.parse_args()
+    prepare_main(label_keys=args.label_keys, cutoff=args.cutoff)
+
+if __name__ == '__main__':
+    main()

Graph/GraphMAE_MQ9/code/run.py

@@ -0,0 +1,94 @@
+import argparse
+import os
+
+import dgl
+import torch.utils.data
+from dgl.dataloading import GraphDataLoader
+from torch import optim
+from tqdm import tqdm
+from QM9_dataset_class import PreprocessedQM9Dataset
+from model import SimpleGnn, GMae
+import torch.nn as nn
+
+def train_epoch(epoch, graphLoader: torch.utils.data.DataLoader,
+                model: nn.Module,device, optimizer:torch.optim.Optimizer,
+                save_dir:str
+                ):
+    print(f"epoch {epoch} started!")
+    model.train()
+    model.encoder.train()
+    model.decoder.train()
+    model.to(device)
+    loss_epoch = 0
+    for batch in tqdm(graphLoader):
+        optimizer.zero_grad()
+        batch_g, _ = batch
+        R = batch_g.ndata["R"].to(device)
+        # Z_index = batch_g.ndata["Z_index"].to(device)
+        Z_index = batch_g.ndata["Z_index"].to(device)
+        Z_emb = model.encode_atom_index(Z_index)
+        feat = torch.cat([R, Z_emb], dim=1)
+        batch_g = batch_g.to(device)
+        loss = model.mask_attr_prediction(batch_g, feat)
+        loss.backward()
+        optimizer.step()
+        loss_epoch += loss.item()
+    return loss_epoch
+
+
+def train_loop(dataset_path, epochs, batch_size,device,save_dir):
+    device = torch.device(device)
+    dataset = PreprocessedQM9Dataset(None)
+    dataset.load_dataset(dataset_path)
+    print("Dataset loaded:", dataset_path, "Total samples:", len(dataset))
+    print("Initializing dataloader")
+    myGLoader = GraphDataLoader(dataset, batch_size=batch_size, pin_memory=True,shuffle=False)
+    sage_enc = SimpleGnn(in_feats=7, hid_feats=4, out_feats=4) # 7 = R_dim(3)+Z_embedding_dim(4)
+    sage_dec = SimpleGnn(in_feats=4, hid_feats=4, out_feats=7)
+    gmae = GMae(sage_enc, sage_dec, 7, 4, 7, replace_rate=0)
+    optimizer = optim.Adam(gmae.parameters(), lr=1e-3)
+    print("Start training", "epochs:", epochs, "batch_size:", batch_size)
+    for epoch in range(epochs):
+        loss_epoch = train_epoch(epoch, myGLoader,gmae,device,optimizer,save_dir)
+        formatted_loss_epoch = f"{loss_epoch:.3f}"
+        save_path = os.path.join(save_dir,f"epoch_{epoch}",f"gmae_{formatted_loss_epoch}.pt")
+        save_subdir = os.path.dirname(save_path)
+        if not os.path.exists(save_subdir):
+            os.makedirs(save_subdir, exist_ok=True)
+        torch.save(gmae.state_dict(), save_path)
+        print(f"Epoch:{epoch},loss:{loss_epoch},Model saved:{save_path}")
+        with torch.no_grad():
+            embedded_graphs = []
+            print(f"Epoch:{epoch},start embedding")
+            gmae.eval()
+            gmae.encoder.eval()
+            for batch in tqdm(myGLoader):
+                batch_g, _ = batch
+                R = batch_g.ndata["R"].to(device)
+                Z_index = batch_g.ndata["Z_index"].to(device)
+                Z_emb = gmae.encode_atom_index(Z_index)
+                feat = torch.cat([R, Z_emb], dim=1)
+                batch_g = batch_g.to(device)
+                batch_g.ndata["embedding"] = gmae.embed(batch_g,feat)
+                unbatched_graphs = dgl.unbatch(batch_g)
+                embedded_graphs.extend(unbatched_graphs)
+            for idx,embedded_graph in enumerate(embedded_graphs):
+                embeddings_save_path = os.path.join(save_dir, f"epoch_{epoch}", f"embedding_{idx}.dgl")
+                dgl.save_graphs(embeddings_save_path, [embedded_graph])
+            print(f"epoch:{epoch},embedding saved:{embeddings_save_path},total_graphs:{len(embedded_graphs)}")
+
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Prepare QM9 dataset")
+    parser.add_argument('--dataset_path', type=str, default='dataset/QM9_dataset_processed.pt')
+    parser.add_argument('--batch_size', type=int, default=4)
+    parser.add_argument('--epochs', type=int, default=10, help='number of epochs')
+    parser.add_argument("--device", type=str, default='cuda:0')
+    parser.add_argument("--save_dir", type=str, default='./model')
+    args = parser.parse_args()
+    train_loop(args.dataset_path, args.epochs, args.batch_size,args.device,args.save_dir)
+
+
+if __name__ == '__main__':
+    main()