Exemplo n.º 1
0
    def __init__(self, smiles):
        DGLGraph.__init__(self)
        self.nodes_dict = {}

        if smiles is None:
            return

        self.smiles = smiles
        self.mol = get_mol(smiles)

        # Stereo Generation
        mol = Chem.MolFromSmiles(smiles)
        self.smiles3D = Chem.MolToSmiles(mol, isomericSmiles=True)
        self.smiles2D = Chem.MolToSmiles(mol)
        self.stereo_cands = decode_stereo(self.smiles2D)

        # cliques: a list of list of atom indices
        cliques, edges = tree_decomp(self.mol)
        root = 0
        for i, c in enumerate(cliques):
            cmol = get_clique_mol(self.mol, c)
            csmiles = get_smiles(cmol)
            self.nodes_dict[i] = dict(
                smiles=csmiles,
                mol=get_mol(csmiles),
                clique=c,
            )
            if min(c) == 0:
                root = i
        self.add_nodes(len(cliques))

        # The clique with atom ID 0 becomes root
        if root > 0:
            for attr in self.nodes_dict[0]:
                self.nodes_dict[0][attr], self.nodes_dict[root][attr] = \
                    self.nodes_dict[root][attr], self.nodes_dict[0][attr]

        src = np.zeros((len(edges) * 2, ), dtype='int')
        dst = np.zeros((len(edges) * 2, ), dtype='int')
        for i, (_x, _y) in enumerate(edges):
            x = 0 if _x == root else root if _x == 0 else _x
            y = 0 if _y == root else root if _y == 0 else _y
            src[2 * i] = x
            dst[2 * i] = y
            src[2 * i + 1] = y
            dst[2 * i + 1] = x
        self.add_edges(src, dst)

        for i in self.nodes_dict:
            self.nodes_dict[i]['nid'] = i + 1
            if self.out_degree(i) > 1:  # Leaf node mol is not marked
                set_atommap(self.nodes_dict[i]['mol'],
                            self.nodes_dict[i]['nid'])
            self.nodes_dict[i]['is_leaf'] = (self.out_degree(i) == 1)
Exemplo n.º 2
0
    def __init__(self, smiles):
        DGLGraph.__init__(self)
        self.nodes_dict = {}

        if smiles is None:
            return
        self.smiles = smiles
        self.mol = get_mol(smiles)
        """Stereo Generation."""
        mol = Chem.MolFromSmiles(smiles)

        self.smiles2D = Chem.MolToSmiles(mol)
        self.smiles3D = Chem.MolToSmiles(mol, isomericSmiles=True)
        self.stereo_cands = decode_stereo(self.smiles2D)
        """Cliques: [[Neighbor Indices] for Atom in Atoms]"""
        cliques, edges = tree_decomp(self.mol)
        root = 0

        for i, clique in enumerate(cliques):
            cmol = get_clique_mol(self.mol, clique)
            csmiles = get_smiles(cmol)
            self.nodes_dict[i] = dict(smiles=csmiles,
                                      mol=get_mol(csmiles),
                                      clique=clique)
            if min(clique) == 0:
                root = i

        self.add_nodes(len(cliques))

        if root > 0:
            for attr in self.nodes_dict[0]:
                self.nodes_dict[0][attr] = self.nodes_dict[root][attr]
                self.nodes_dict[root][attr] = self.nodes_dict[0][attr]
        """Generate Edges."""
        src = np.zeros((len(edges) * 2, ), dtype='int')
        dst = np.zeros((len(edges) * 2, ), dtype='int')
        for i, (_x, _y) in enumerate(edges):
            x = 0 if _x == root else root if _x == 0 else _x
            y = 0 if _y == root else root if _y == 0 else _y
            src[2 * i], dst[2 * i] = x, y
            src[2 * i + 1], dst[2 * i + 1] = y, x

        self.add_edges(src, dst)

        for i in self.nodes_dict:
            self.nodes_dict[i]['nid'] = i + 1
            if self.out_degree(i) > 1:
                set_atommap(self.nodes_dict[i]['mol'],
                            self.nodes_dict[i]['nid'])
            self.nodes_dict[i]['is_leaf'] = (self.out_degree(i) == 1)
Exemplo n.º 3
0
    def __init__(self, num_nodes: int, num_relations: int,
                 triplets: np.ndarray):
        Object.__init__(self)
        DGLGraph.__init__(self)

        assert triplets.shape[0] == 3
        src, rel, dst = triplets

        self.add_nodes(num_nodes)
        self.add_edges(src, dst)

        self.set_n_initializer(zero_initializer)
        self.set_e_initializer(zero_initializer)

        self.logger.info(
            f"Constructed graph with {num_nodes} nodes and {num_relations} relation types."
        )
Exemplo n.º 4
0
    def __init__(self, smiles):
        DGLGraph.__init__(self)
        self.smiles = smiles
        self.mol = get_mol(smiles)

        # Stereo Generation
        mol = Chem.MolFromSmiles(smiles)
        self.smiles3D = Chem.MolToSmiles(mol, isomericSmiles=True)
        self.smiles2D = Chem.MolToSmiles(mol)
        self.stereo_cands = decode_stereo(self.smiles2D)

        # cliques: a list of list of atom indices
        cliques, edges = tree_decomp(self.mol)
        root = 0
        for i, c in enumerate(cliques):
            cmol = get_clique_mol(self.mol, c)
            csmiles = get_smiles(cmol)
            self.add_node(
                i,
                smiles=csmiles,
                mol=get_mol(csmiles),
                clique=c,
            )
            if min(c) == 0:
                root = i

        # The clique with atom ID 0 becomes root
        if root > 0:
            for attr in self.nodes[0]:
                self.nodes[0][attr], self.nodes[root][attr] = \
                        self.nodes[root][attr], self.nodes[0][attr]

        for _x, _y in edges:
            x = 0 if _x == root else root if _x == 0 else _x
            y = 0 if _y == root else root if _y == 0 else _y
            self.add_edge(x, y)
            self.add_edge(y, x)

        for i in self.nodes:
            self.nodes[i]['nid'] = i + 1
            if len(self[i]) > 1:  # Leaf node mol is not marked
                set_atommap(self.nodes[i]['mol'], self.nodes[i]['nid'])
            self.nodes[i]['is_leaf'] = (len(self[i]) == 1)