import torch import copy import random import networkx as nx import numpy as np from torch_geometric.utils import convert from loader import graph_data_obj_to_nx_simple, nx_to_graph_data_obj_simple from rdkit import Chem from rdkit.Chem import AllChem from loader import mol_to_graph_data_obj_simple, \ graph_data_obj_to_mol_simple from loader import MoleculeDataset def check_same_molecules(s1, s2): mol1 = AllChem.MolFromSmiles(s1) mol2 = AllChem.MolFromSmiles(s2) return AllChem.MolToInchi(mol1) == AllChem.MolToInchi(mol2) class NegativeEdge: def __init__(self): """ Randomly sample negative edges """ pass def __call__(self, data): num_nodes = data.num_nodes num_edges = data.num_edges edge_set = set([str(data.edge_index[0, i].cpu().item()) + "," + str( data.edge_index[1, i].cpu().item()) for i in range(data.edge_index.shape[1])]) redandunt_sample = torch.randint(0, num_nodes, (2, 5 * num_edges)) sampled_ind = [] sampled_edge_set = set([]) for i in range(5 * num_edges): node1 = redandunt_sample[0, i].cpu().item() node2 = redandunt_sample[1, i].cpu().item() edge_str = str(node1) + "," + str(node2) if not edge_str in edge_set and not edge_str in sampled_edge_set and not node1 == node2: sampled_edge_set.add(edge_str) sampled_ind.append(i) if len(sampled_ind) == num_edges / 2: break data.negative_edge_index = redandunt_sample[:, sampled_ind] return data class ExtractSubstructureContextPair: def __init__(self, k, l1, l2): """ Randomly selects a node from the data object, and adds attributes that contain the substructure that corresponds to k hop neighbours rooted at the node, and the context substructures that corresponds to the subgraph that is between l1 and l2 hops away from the root node. :param k: :param l1: :param l2: """ self.k = k self.l1 = l1 self.l2 = l2 # for the special case of 0, addresses the quirk with # single_source_shortest_path_length if self.k == 0: self.k = -1 if self.l1 == 0: self.l1 = -1 if self.l2 == 0: self.l2 = -1 def __call__(self, data, root_idx=None): """ :param data: pytorch geometric data object :param root_idx: If None, then randomly samples an atom idx. Otherwise sets atom idx of root (for debugging only) :return: None. Creates new attributes in original data object: data.center_substruct_idx data.x_substruct data.edge_attr_substruct data.edge_index_substruct data.x_context data.edge_attr_context data.edge_index_context data.overlap_context_substruct_idx """ num_atoms = data.x.size()[0] if root_idx == None: root_idx = random.sample(range(num_atoms), 1)[0] G = graph_data_obj_to_nx_simple(data) # same ordering as input data obj # Get k-hop subgraph rooted at specified atom idx substruct_node_idxes = nx.single_source_shortest_path_length(G, root_idx, self.k).keys() if len(substruct_node_idxes) > 0: substruct_G = G.subgraph(substruct_node_idxes) substruct_G, substruct_node_map = reset_idxes(substruct_G) # need # to reset node idx to 0 -> num_nodes - 1, otherwise data obj does not # make sense, since the node indices in data obj must start at 0 substruct_data = nx_to_graph_data_obj_simple(substruct_G) data.x_substruct = substruct_data.x data.edge_attr_substruct = substruct_data.edge_attr data.edge_index_substruct = substruct_data.edge_index data.center_substruct_idx = torch.tensor([substruct_node_map[ root_idx]]) # need # to convert center idx from original graph node ordering to the # new substruct node ordering # Get subgraphs that is between l1 and l2 hops away from the root node l1_node_idxes = nx.single_source_shortest_path_length(G, root_idx, self.l1).keys() l2_node_idxes = nx.single_source_shortest_path_length(G, root_idx, self.l2).keys() context_node_idxes = set(l1_node_idxes).symmetric_difference( set(l2_node_idxes)) if len(context_node_idxes) > 0: context_G = G.subgraph(context_node_idxes) context_G, context_node_map = reset_idxes(context_G) # need to # reset node idx to 0 -> num_nodes - 1, otherwise data obj does not # make sense, since the node indices in data obj must start at 0 context_data = nx_to_graph_data_obj_simple(context_G) data.x_context = context_data.x data.edge_attr_context = context_data.edge_attr data.edge_index_context = context_data.edge_index # Get indices of overlapping nodes between substruct and context, # WRT context ordering context_substruct_overlap_idxes = list(set( context_node_idxes).intersection(set(substruct_node_idxes))) if len(context_substruct_overlap_idxes) > 0: context_substruct_overlap_idxes_reorder = [context_node_map[old_idx] for old_idx in context_substruct_overlap_idxes] # need to convert the overlap node idxes, which is from the # original graph node ordering to the new context node ordering data.overlap_context_substruct_idx = \ torch.tensor(context_substruct_overlap_idxes_reorder) return data # ### For debugging ### # if len(substruct_node_idxes) > 0: # substruct_mol = graph_data_obj_to_mol_simple(data.x_substruct, # data.edge_index_substruct, # data.edge_attr_substruct) # print(AllChem.MolToSmiles(substruct_mol)) # if len(context_node_idxes) > 0: # context_mol = graph_data_obj_to_mol_simple(data.x_context, # data.edge_index_context, # data.edge_attr_context) # print(AllChem.MolToSmiles(context_mol)) # # print(list(context_node_idxes)) # print(list(substruct_node_idxes)) # print(context_substruct_overlap_idxes) # ### End debugging ### def __repr__(self): return '{}(k={},l1={}, l2={})'.format(self.__class__.__name__, self.k, self.l1, self.l2) def reset_idxes(G): """ Resets node indices such that they are numbered from 0 to num_nodes - 1 :param G: :return: copy of G with relabelled node indices, mapping """ mapping = {} for new_idx, old_idx in enumerate(G.nodes()): mapping[old_idx] = new_idx new_G = nx.relabel_nodes(G, mapping, copy=True) return new_G, mapping # TODO(Bowen): more unittests class MaskAtom: def __init__(self, num_atom_type, num_edge_type, mask_rate, mask_edge=True): """ Randomly masks an atom, and optionally masks edges connecting to it. The mask atom type index is num_possible_atom_type The mask edge type index in num_possible_edge_type :param num_atom_type: :param num_edge_type: :param mask_rate: % of atoms to be masked :param mask_edge: If True, also mask the edges that connect to the masked atoms """ self.num_atom_type = num_atom_type self.num_edge_type = num_edge_type self.mask_rate = mask_rate self.mask_edge = mask_edge def __call__(self, data, masked_atom_indices=None): """ :param data: pytorch geometric data object. Assume that the edge ordering is the default pytorch geometric ordering, where the two directions of a single edge occur in pairs. Eg. data.edge_index = tensor([[0, 1, 1, 2, 2, 3], [1, 0, 2, 1, 3, 2]]) :param masked_atom_indices: If None, then randomly samples num_atoms * mask rate number of atom indices Otherwise a list of atom idx that sets the atoms to be masked (for debugging only) :return: None, Creates new attributes in original data object: data.mask_node_idx data.mask_node_label data.mask_edge_idx data.mask_edge_label """ if masked_atom_indices == None: # sample x distinct atoms to be masked, based on mask rate. But # will sample at least 1 atom num_atoms = data.x.size()[0] sample_size = int(num_atoms * self.mask_rate + 1) masked_atom_indices = random.sample(range(num_atoms), sample_size) # create mask node label by copying atom feature of mask atom mask_node_labels_list = [] for atom_idx in masked_atom_indices: mask_node_labels_list.append(data.x[atom_idx].view(1, -1)) data.mask_node_label = torch.cat(mask_node_labels_list, dim=0) data.masked_atom_indices = torch.tensor(masked_atom_indices) # modify the original node feature of the masked node for atom_idx in masked_atom_indices: data.x[atom_idx] = torch.tensor([self.num_atom_type, 0]) if self.mask_edge: # create mask edge labels by copying edge features of edges that are bonded to # mask atoms connected_edge_indices = [] for bond_idx, (u, v) in enumerate(data.edge_index.cpu().numpy().T): for atom_idx in masked_atom_indices: if atom_idx in set((u, v)) and \ bond_idx not in connected_edge_indices: connected_edge_indices.append(bond_idx) if len(connected_edge_indices) > 0: # create mask edge labels by copying bond features of the bonds connected to # the mask atoms mask_edge_labels_list = [] for bond_idx in connected_edge_indices[::2]: # because the # edge ordering is such that two directions of a single # edge occur in pairs, so to get the unique undirected # edge indices, we take every 2nd edge index from list mask_edge_labels_list.append( data.edge_attr[bond_idx].view(1, -1)) data.mask_edge_label = torch.cat(mask_edge_labels_list, dim=0) # modify the original bond features of the bonds connected to the mask atoms for bond_idx in connected_edge_indices: data.edge_attr[bond_idx] = torch.tensor( [self.num_edge_type, 0]) data.connected_edge_indices = torch.tensor( connected_edge_indices[::2]) else: data.mask_edge_label = torch.empty((0, 2)).to(torch.int64) data.connected_edge_indices = torch.tensor( connected_edge_indices).to(torch.int64) return data def __repr__(self): return '{}(num_atom_type={}, num_edge_type={}, mask_rate={}, mask_edge={})'.format( self.__class__.__name__, self.num_atom_type, self.num_edge_type, self.mask_rate, self.mask_edge) if __name__ == "__main__": transform = NegativeEdge() dataset = MoleculeDataset("dataset/tox21", dataset="tox21") transform(dataset[0]) """ # TODO(Bowen): more unit tests # test ExtractSubstructureContextPair smiles = 'C#Cc1c(O)c(Cl)cc(/C=C/N)c1S' m = AllChem.MolFromSmiles(smiles) data = mol_to_graph_data_obj_simple(m) root_idx = 13 # 0 hops: no substructure or context. We just test the absence of x attr transform = ExtractSubstructureContextPair(0, 0, 0) transform(data, root_idx) assert not hasattr(data, 'x_substruct') assert not hasattr(data, 'x_context') # k > n_nodes, l1 = 0 and l2 > n_nodes: substructure and context same as # molecule data = mol_to_graph_data_obj_simple(m) transform = ExtractSubstructureContextPair(100000, 0, 100000) transform(data, root_idx) substruct_mol = graph_data_obj_to_mol_simple(data.x_substruct, data.edge_index_substruct, data.edge_attr_substruct) context_mol = graph_data_obj_to_mol_simple(data.x_context, data.edge_index_context, data.edge_attr_context) assert check_same_molecules(AllChem.MolToSmiles(substruct_mol), AllChem.MolToSmiles(context_mol)) transform = ExtractSubstructureContextPair(1, 1, 10000) transform(data, root_idx) # increase k from 0, and increase l1 from 1 while keeping l2 > n_nodes: the # total number of atoms should be n_atoms for i in range(len(m.GetAtoms())): data = mol_to_graph_data_obj_simple(m) print('i: {}'.format(i)) transform = ExtractSubstructureContextPair(i, i, 100000) transform(data, root_idx) if hasattr(data, 'x_substruct'): n_substruct_atoms = data.x_substruct.size()[0] else: n_substruct_atoms = 0 print('n_substruct_atoms: {}'.format(n_substruct_atoms)) if hasattr(data, 'x_context'): n_context_atoms = data.x_context.size()[0] else: n_context_atoms = 0 print('n_context_atoms: {}'.format(n_context_atoms)) assert n_substruct_atoms + n_context_atoms == len(m.GetAtoms()) # l1 < k and l2 >= k, so an overlap exists between context and substruct data = mol_to_graph_data_obj_simple(m) transform = ExtractSubstructureContextPair(2, 1, 3) transform(data, root_idx) assert hasattr(data, 'center_substruct_idx') # check correct overlap atoms between context and substruct # m = AllChem.MolFromSmiles('COC1=CC2=C(NC(=N2)[S@@](=O)CC2=NC=C(C)C(OC)=C2C)C=C1') # data = mol_to_graph_data_obj_simple(m) # root_idx = 9 # k = 1 # l1 = 1 # l2 = 2 # transform = ExtractSubstructureContextPaidata = mol_to_graph_data_obj_simple(m)r(k, l1, l2) # transform(data, root_idx) pass # TODO(Bowen): more unit tests # test MaskAtom from loader import mol_to_graph_data_obj_simple, \ graph_data_obj_to_mol_simple smiles = 'C#Cc1c(O)c(Cl)cc(/C=C/N)c1S' m = AllChem.MolFromSmiles(smiles) original_data = mol_to_graph_data_obj_simple(m) num_atom_type = 118 num_edge_type = 5 # manually specify masked atom indices, don't mask edge masked_atom_indices = [13, 12] data = mol_to_graph_data_obj_simple(m) transform = MaskAtom(num_atom_type, num_edge_type, 0.1, mask_edge=False) transform(data, masked_atom_indices) assert data.mask_node_label.size() == torch.Size( (len(masked_atom_indices), 2)) assert not hasattr(data, 'mask_edge_label') # check that the correct rows in x have been modified to be mask atom type assert (data.x[masked_atom_indices] == torch.tensor(([num_atom_type, 0]))).all() assert (data.mask_node_label == original_data.x[masked_atom_indices]).all() # manually specify masked atom indices, mask edge masked_atom_indices = [13, 12] data = mol_to_graph_data_obj_simple(m) transform = MaskAtom(num_atom_type, num_edge_type, 0.1, mask_edge=True) transform(data, masked_atom_indices) assert data.mask_node_label.size() == torch.Size( (len(masked_atom_indices), 2)) # check that the correct rows in x have been modified to be mask atom type assert (data.x[masked_atom_indices] == torch.tensor(([num_atom_type, 0]))).all() assert (data.mask_node_label == original_data.x[masked_atom_indices]).all() # check that the correct rows in edge_attr have been modified to be mask edge # type, and the mask_edge_label are correct rdkit_bonds = [] for atom_idx in masked_atom_indices: bond_indices = list(AllChem.FindAtomEnvironmentOfRadiusN(m, radius=1, rootedAtAtom=atom_idx)) for bond_idx in bond_indices: rdkit_bonds.append( (m.GetBonds()[bond_idx].GetBeginAtomIdx(), m.GetBonds()[ bond_idx].GetEndAtomIdx())) rdkit_bonds.append( (m.GetBonds()[bond_idx].GetEndAtomIdx(), m.GetBonds()[ bond_idx].GetBeginAtomIdx())) rdkit_bonds = set(rdkit_bonds) connected_edge_indices = [] for i in range(data.edge_index.size()[1]): if tuple(data.edge_index.numpy().T[i].tolist()) in rdkit_bonds: connected_edge_indices.append(i) assert (data.edge_attr[connected_edge_indices] == torch.tensor(([num_edge_type, 0]))).all() assert (data.mask_edge_label == original_data.edge_attr[ connected_edge_indices[::2]]).all() # data.mask_edge_label contains # the unique edges (ignoring direction). The data obj has edge ordering # such that two directions of a single edge occur in pairs, so to get the # unique undirected edge indices, we take every 2nd edge index from list """