Delete code

code/QM9_dataset_class.py

@@ -1,51 +0,0 @@
-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)

code/lib/metrics.py

@@ -1,95 +0,0 @@
-# -*- 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

code/lib/utils.py

@@ -1,397 +0,0 @@
-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)
-
-

code/model.py

@@ -1,90 +0,0 @@
-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

code/prepare_QM9_dataset.py

@@ -1,48 +0,0 @@
-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()

code/run.py

@@ -1,94 +0,0 @@
-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()