Delete .virtual_documents

.virtual_documents/DataInspect.ipynb

@@ -1,237 +0,0 @@
-import os
-import time
-from rdkit import Chem
-from rdkit import RDLogger;
-from torch.utils.data import Dataset
-import torch.nn.functional as F
-from tqdm import tqdm
-RDLogger.DisableLog('rdApp.*')
-import torch
-import torch.nn as nn
-import torch.optim as optim
-import pickle
-import numpy as np
-import matplotlib.pyplot as plt
-import math
-import dgl
-import networkx as nx
-
-
-atom_number_index_dict ={
-    1:0, # H
-    6:1, # C
-    7:2, # N
-    8:3, # O
-    9:4  # F
-} 
-# device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-atom_index_number_dict = {v: k for k, v in atom_number_index_dict.items()}
-max_atom_number = max(atom_number_index_dict.keys())
-atom_number2index_tensor = torch.full((max_atom_number + 1,), -1)
-for k, v in atom_number_index_dict.items():
-    atom_number2index_tensor[k] = v
-
-atom_index2number_tensor = torch.tensor([atom_index_number_dict[i] for i in range(len(atom_index_number_dict))])
-def atom_number2index(atom_numbers):
-    return atom_number2index_tensor[atom_numbers]
-def atom_index2number(atom_indexes):
-    return atom_index2number_tensor[atom_indexes]
-
-
-from dgl.data import QM9Dataset
-from torch.utils.data import SubsetRandomSampler
-from dgl.dataloading import GraphDataLoader
-from multiprocessing import Pool
-
-dataset = QM9Dataset(label_keys=['mu', 'gap'], cutoff=5.0)
-dataset_length = len(dataset)
-train_idx = torch.arange(dataset_length)
-# def preprocess_graph(data):
-#     g, label = data
-#     g.ndata["Z_index"] = atom_number2index(g.ndata["Z"])
-#     return g, label
-
-# def preprocess_dataset(dataset):
-#     with Pool(processes=4) as pool:  # 设置进程数
-#         with tqdm(total=len(dataset)) as pbar:  # 初始化进度条
-#             results = []
-#             for result in pool.imap(preprocess_graph, dataset):  # 使用 imap 逐步处理
-#                 results.append(result)
-#                 pbar.update(1)  # 更新进度条
-#     return results
-
-# # 使用多进程预处理数据集
-# dataset = preprocess_dataset(dataset)
-
-# def collate_fn(batch):
-#     # print(batch)
-#     graphs, labels = map(list, zip(*batch))
-#     for g in graphs:
-#         pass
-#         # g.ndata["Z_index"] = atom_number2index(g.ndata["Z"])
-#         # g.ndata["R"]->the coordinates of each atom[num_nodes,3], g.ndata["Z"]->the atomic number(H:1,C:6) [num_nodes]
-#         # g.ndata["Z_index"] = torch.tensor([atom_number2index(z.item()) for z in g.ndata["Z"]])
-#     batched_graph = dgl.batch(graphs)
-#     return batched_graph, torch.stack(labels)
-myGLoader = GraphDataLoader(dataset,batch_size=32,pin_memory=True,num_workers=8)
-
-
-# for batch in tqdm(myGLoader):
-#     pass
-#     # print(batch)
-    
-
-
-from functools import partial
-import sys
-sys.path.append("lib")
-from lib.metrics import sce_loss
-
-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
-    
-
-
-import dgl.nn as dglnn
-import torch.nn as nn
-import torch.nn.functional as F
-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
-
-
-sage_enc = SimpleGNN(in_feats=7,hid_feats=4,out_feats=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)
-epoches = 20
-optimizer = optim.Adam(gmae.parameters(), lr=1e-3)
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-
-
-print(f"epoch {0} started!")
-gmae.train()
-gmae.encoder.train()
-gmae.decoder.train()
-gmae.to(device)
-loss_epoch = 0
-import os
-os.environ["CUDA_LAUNCH_BLOCKING"]="1"
-for batch in tqdm(myGLoader):
-    optimizer.zero_grad()
-    batch_g, _ = batch
-    R = batch_g.ndata["R"].to(device)
-    Z_index = batch_g.ndata["Z"].to(device)
-    Z_emb = gmae.encode_atom_index(Z_index)
-    # feat = torch.cat([R,Z_emb],dim=1)
-    # batch_g = batch_g.to(device)
-    # loss = gmae.mask_attr_prediction(batch_g, feat)
-    # loss.backward()
-    # optimizer.step()
-    # loss_epoch+=loss.item()
-
-
-
-from datetime import datetime
-
-current_time = datetime.now().strftime("%m-%d@%H_%M")
-best_loss = 10000
-for epoch in range(epoches):
-    print(f"epoch {epoch} started!")
-    gmae.train()
-    gmae.encoder.train()
-    gmae.decoder.train()
-    gmae.to(device)
-    loss_epoch = 0
-    for batch in myGLoader:
-        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 = gmae.encode_atom_index(Z_index)
-        feat = torch.cat([R,Z_emb],dim=1)
-        batch_g = batch_g.to(device)
-        loss = gmae.mask_attr_prediction(batch_g, feat)
-        loss.backward()
-        optimizer.step()
-        loss_epoch+=loss.item()
-    if loss_epoch < best_loss:
-        formatted_loss_epoch = f"{loss_epoch:.3f}"
-        save_path = f"./experiments/consumption/gmae/{current_time}/gmae_epoch-{epoch}-{formatted_loss_epoch}.pt"
-        save_dir = os.path.dirname(save_path)
-        if not os.path.exists(save_dir):
-            os.makedirs(save_dir,exist_ok=True)
-        torch.save(gmae.state_dict(), save_path)
-        best_loss = loss_epoch
-        print(f"best model saved-loss:{formatted_loss_epoch}-save_path:{save_path}")
-    print(f"epoch {epoch}: loss {loss_epoch}")