Migrated from GitHub

.gitattributes

@@ -57,3 +57,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/data/QSAR/DRD2/drd2_train.csv filter=lfs diff=lfs merge=lfs -text
+data/data/USPTO/src_train.txt filter=lfs diff=lfs merge=lfs -text
+data/data/USPTO/tgt_train.txt filter=lfs diff=lfs merge=lfs -text

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Sekijima Laboratory, Tokyo Institute of Technology
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Model/GCN/callbacks.py

@@ -0,0 +1,39 @@
+import torch
+import numpy as np
+
+
+class EarlyStopping:
+
+    def __init__(self, patience=5, verbose=False, path='checkpoint_model.pth'):
+
+        self.patience = patience    # stop cpunter
+        self.verbose = verbose 
+        self.counter = 0            # current counter
+        self.best_score = None      # best score
+        self.early_stop = False     # stop flag
+        self.val_loss_min = np.Inf   # to memorize previous best score
+        self.path = path             # path to save the best model
+
+    def __call__(self, val_loss, model):
+
+        score = -val_loss
+
+        if self.best_score is None:  #1Epoch
+            self.best_score = score
+            self.checkpoint(val_loss, model)  # save model and show score
+        elif score < self.best_score:  # if it can not update best score
+            self.counter += 1   # stop counter +1
+            if self.verbose:
+                print(f'EarlyStopping counter: {self.counter} out of {self.patience}')
+            if self.counter >= self.patience:
+                self.early_stop = True
+        else:  # if it update best score
+            self.best_score = score
+            self.checkpoint(val_loss, model) # save model and show score
+            self.counter = 0  # stop counter is reset
+
+    def checkpoint(self, val_loss, model):
+        if self.verbose:
+            print(f'Validation loss decreased ({self.val_loss_min:.6f} --> {val_loss:.6f}).  Saving model ...')
+        torch.save(model.state_dict(), self.path)
+        self.val_loss_min = val_loss

data/Model/GCN/mol2graph.py

@@ -0,0 +1,291 @@
+import numpy as np
+from rdkit import Chem
+import torch
+from torch_geometric.data import Data
+
+
+def one_of_k_encoding(x, allowable_set):
+    """
+    Encodes elements of a provided set as integers.
+    Parameters
+     ----------
+    x: object
+    Must be present in `allowable_set`.
+    allowable_set: list
+    List of allowable quantities.
+    Example
+    -------
+    >>> import deepchem as dc
+    >>> dc.feat.graph_features.one_of_k_encoding("a", ["a", "b", "c"])
+    [True, False, False]
+    Raises
+    ------
+    `ValueError` if `x` is not in `allowable_set`.
+    """
+    if x not in allowable_set:
+        raise Exception(f"input {x} not in allowable set{allowable_set}:")
+    return list(map(lambda s: x == s, allowable_set))
+    # map(適用する関数, 適用するリスト)
+    # allowable_setの中でxが該当する位置にだけ1が入ったone_hotベクトルをreturn
+
+
+def one_of_k_encoding_unk(x, allowable_set):
+    """
+    Maps inputs not in the allowable set to the last element.
+    Unlike `one_of_k_encoding`, if `x` is not in `allowable_set`, this method
+    pretends that `x` is the last element of `allowable_set`.
+    Parameters
+    ----------
+    x: object
+    Must be present in `allowable_set`.
+    allowable_set: list
+    List of allowable quantities.
+    Examples
+    --------
+    >>> dc.feat.graph_features.one_of_k_encoding_unk("s", ["a", "b", "c"])
+    [False, False, True]
+  """
+    if x not in allowable_set:
+        x = allowable_set[-1]
+    return list(map(lambda s: x == s, allowable_set))
+    # one_of_k_encodingする際、allowable_setの最後にunknownを追加して使う
+
+
+def get_intervals(l):
+    """For list of lists, gets the cumulative products of the lengths"""
+    intervals = len(l) * [0] # [0, 0, ... , 0]
+    intervals[0] = 1 # Initalize with 1
+    for k in range(1, len(l)):
+        intervals[k] = (len(l[k]) + 1) * intervals[k - 1]
+    return intervals
+
+
+def safe_index(l, e):
+    """Gets the index of e in l, providing an index of len(l) if not found"""
+    try:
+        return l.index(e)
+    except:
+        return len(l)
+
+
+class GraphConvConstants(object):
+    """This class defines a collection of constants which are useful for graph convolutions on molecules."""
+    possible_atom_list = [
+          'C', 'N', 'O', 'S', 'F', 'P', 'Cl', 'Mg', 'Na', 'Br', 'Fe', 'Ca', 'Cu','Mc', 'Pd', 'Pb', 'K', 'I', 'Al', 'Ni', 'Mn'
+      ]
+    """Allowed Numbers of Hydrogens"""
+    possible_numH_list = [0, 1, 2, 3, 4]
+    """Allowed Valences for Atoms"""
+    possible_valence_list = [0, 1, 2, 3, 4, 5, 6]
+    """Allowed Formal Charges for Atoms"""
+    possible_formal_charge_list = [-3, -2, -1, 0, 1, 2, 3]
+    """This is a placeholder for documentation. These will be replaced with corresponding values of the rdkit HybridizationType"""
+    possible_hybridization_list = ["SP", "SP2", "SP3", "SP3D", "SP3D2"]
+    """Allowed number of radical electrons."""
+    possible_number_radical_e_list = [0, 1, 2]
+    """Allowed types of Chirality"""
+    possible_chirality_list = ['R', 'S']
+    """The set of all values allowed."""
+    reference_lists = [
+          possible_atom_list, possible_numH_list, possible_valence_list,
+          possible_formal_charge_list, possible_number_radical_e_list,
+          possible_hybridization_list, possible_chirality_list
+      ]
+    """The number of different values that can be taken. See `get_intervals()`"""
+    intervals = get_intervals(reference_lists)
+    """Possible stereochemistry. We use E-Z notation for stereochemistry
+    https://en.wikipedia.org/wiki/E%E2%80%93Z_notation"""
+    possible_bond_stereo = ["STEREONONE", "STEREOANY", "STEREOZ", "STEREOE"]
+    """Number of different bond types not counting stereochemistry."""
+    bond_fdim_base = 6
+
+
+def get_feature_list(atom):
+    possible_atom_list = GraphConvConstants.possible_atom_list
+    possible_numH_list = GraphConvConstants.possible_numH_list
+    possible_valence_list = GraphConvConstants.possible_valence_list
+    possible_formal_charge_list = GraphConvConstants.possible_formal_charge_list
+    possible_number_radical_e_list = GraphConvConstants.possible_number_radical_e_list
+    possible_hybridization_list = GraphConvConstants.possible_hybridization_list
+    # Replace the hybridization
+    from rdkit import Chem
+    #global possible_hybridization_list
+    possible_hybridization_list = [
+        Chem.rdchem.HybridizationType.SP, Chem.rdchem.HybridizationType.SP2,
+        Chem.rdchem.HybridizationType.SP3, Chem.rdchem.HybridizationType.SP3D,
+        Chem.rdchem.HybridizationType.SP3D2
+    ]
+    
+    # atom featuresを6種類定義し、feature vectorを作る操作
+    features = 6 * [0]
+    features[0] = safe_index(possible_atom_list, atom.GetSymbol())
+    features[1] = safe_index(possible_numH_list, atom.GetTotalNumHs())
+    features[2] = safe_index(possible_valence_list, atom.GetImplicitValence())
+    features[3] = safe_index(possible_formal_charge_list, atom.GetFormalCharge())
+    features[4] = safe_index(possible_number_radical_e_list,
+                               atom.GetNumRadicalElectrons())
+    features[5] = safe_index(possible_hybridization_list, atom.GetHybridization())
+    return features
+
+
+def features_to_id(features, intervals):
+    """Convert list of features into index using spacings provided in intervals"""
+    id = 0
+    for k in range(len(intervals-1)):
+        id += features[k] * intervals[k]
+    # Allow 0 index to correspond to null molecule 1
+    id = id + 1
+    return id
+
+
+def id_to_features(id, intervals):
+    features = 6 * [0]
+    # Correct for null
+    id -= 1
+    for k in range(0, 6 - 1):
+        # print(6-k-1, id)
+        features[6 - k - 1] = id // intervals[6 - k - 1]
+        id -= features[6 - k - 1] * intervals[6 - k - 1]
+    # Correct for last one
+    features[0] = id
+    return features
+
+
+def atom_to_id(atom):
+    """Return a unique id corresponding to the atom type"""
+    features = get_feature_list(atom)
+    return features_to_id(features, intervals)
+
+
+def atom_features(atom, bool_id_feat=False, explicit_H=False,use_chirality=False):
+    if bool_id_feat:
+        return np.array([atom_to_id(atom)])
+    else:
+        # concatnate all atom features
+        results_ = one_of_k_encoding_unk(
+            atom.GetSymbol(),
+            [
+                'C',
+                'N',
+                'O',
+                'S',
+                'F',
+                'Si',
+                'P',
+                'Cl',
+                'Br',
+                'Mg',
+                'Na',
+                'Ca',
+                'Fe',
+                'As',
+                'Al',
+                'I',
+                'B',
+                'V',
+                'K',
+                'Tl',
+                'Yb',
+                'Sb',
+                'Sn',
+                'Ag',
+                'Pd',
+                'Co',
+                'Se',
+                'Ti',
+                'Zn',
+                'H',
+                'Li',
+                'Ge',
+                'Cu',
+                'Au',
+                'Ni',
+                'Cd',
+                'In',
+                'Mn',
+                'Zr',
+                'Cr',
+                'Pt',
+                'Hg',
+                'Pb',
+                'Unknown'
+            ] # allowable set
+        )
+        results=results_ + \
+        one_of_k_encoding(
+            atom.GetDegree(),
+            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        ) + \
+        one_of_k_encoding_unk(
+            atom.GetImplicitValence(),
+            [0, 1, 2, 3, 4, 5, 6]
+        ) + \
+        [
+            atom.GetFormalCharge(), atom.GetNumRadicalElectrons()
+        ] + \
+        one_of_k_encoding_unk(
+            atom.GetHybridization().name,
+            [
+                Chem.rdchem.HybridizationType.SP.name,
+                Chem.rdchem.HybridizationType.SP2.name,
+                Chem.rdchem.HybridizationType.SP3.name,
+                Chem.rdchem.HybridizationType.SP3D.name,
+                Chem.rdchem.HybridizationType.SP3D2.name
+              ]
+            ) + \
+        [atom.GetIsAromatic()]
+    # In case of explicit hydrogen(QM8, QM9), avoid calling `GetTotalNumHs`
+    if not explicit_H:
+        results = results + one_of_k_encoding_unk(
+            atom.GetTotalNumHs(),
+            [0, 1, 2, 3, 4]
+        )
+    if use_chirality:
+        try:
+            results = results + one_of_k_encoding_unk(
+            atom.GetProp('_CIPCode'),
+            ['R', 'S']) + [atom.HasProp('_ChiralityPossible')]
+        except:
+            results = results + [False, False] + [atom.HasProp('_ChiralityPossible')]
+            
+    return results
+ 
+
+def bond_features(bond, use_chirality=False):
+    from rdkit import Chem
+    bt = bond.GetBondType()
+    bond_feats = [
+        bt == Chem.rdchem.BondType.SINGLE, bt == Chem.rdchem.BondType.DOUBLE,
+        bt == Chem.rdchem.BondType.TRIPLE, bt == Chem.rdchem.BondType.AROMATIC,
+        bond.GetIsConjugated(),
+        bond.IsInRing()
+    ] # if C-C single bond in cyclopropane: [1, 0, 0, 0, 0, 1]
+    if use_chirality:
+        bond_feats = bond_feats + one_of_k_encoding_unk(
+            str(bond.GetStereo()),
+            ["STEREONONE", "STEREOANY", "STEREOZ", "STEREOE"]
+        )
+    return bond_feats
+ 
+def get_bond_pair(mol):
+    bonds = mol.GetBonds()
+    res = [[],[]]
+    for bond in bonds:
+        res[0] += [bond.GetBeginAtomIdx(), bond.GetEndAtomIdx()]
+        res[1] += [bond.GetEndAtomIdx(), bond.GetBeginAtomIdx()]
+    return res
+ 
+def mol2vec(mol):
+    atoms = mol.GetAtoms()
+    bonds = mol.GetBonds()
+    node_f= [atom_features(atom) for atom in atoms]
+    edge_index = get_bond_pair(mol)
+    edge_attr = [bond_features(bond, use_chirality=False) for bond in bonds]
+    for bond in bonds:
+        edge_attr.append(bond_features(bond))
+        data = Data(
+            x=torch.tensor(node_f, dtype=torch.float), # shape [num_nodes, num_node_features] を持つ特徴行列
+            edge_index=torch.tensor(edge_index, dtype=torch.long), #shape [2, num_edges] と型 torch.long を持つ COO フォーマットによるグラフ連結度
+            edge_attr=torch.tensor(edge_attr,dtype=torch.float) # shape [num_edges, num_edge_features] によるエッジ特徴行列
+        )
+    return data

data/Model/GCN/network.py

@@ -0,0 +1,44 @@
+from torch_geometric.nn import GCNConv
+from torch_geometric.nn import global_add_pool
+import torch.nn.functional as F
+from torch.nn import ModuleList, Linear, BatchNorm1d
+import torch
+
+
+class MolecularGCN(torch.nn.Module):
+    def __init__(self, dim, n_conv_hidden, n_mlp_hidden, dropout):
+        super(MolecularGCN, self).__init__()
+        self.n_features = 75 #  This is the mol2graph.py-specific value
+        self.n_conv_hidden = n_conv_hidden
+        self.n_mlp_hidden = n_mlp_hidden
+        self.dim = dim
+        self.dropout = dropout
+        self.graphconv1 = GCNConv(self.n_features, self.dim, cached=False)
+        self.bn1 = BatchNorm1d(self.dim)
+        self.graphconv_hidden = ModuleList(
+            [GCNConv(self.dim, self.dim, cached=False) for _ in range(self.n_conv_hidden)]
+        )
+        self.bn_conv = ModuleList(
+            [BatchNorm1d(self.dim) for _ in range(self.n_conv_hidden)]
+        )
+        self.mlp_hidden =  ModuleList(
+            [Linear(self.dim, self.dim) for _ in range(self.n_mlp_hidden)]
+        )
+        self.bn_mlp = ModuleList(
+            [BatchNorm1d(self.dim) for _ in range(self.n_mlp_hidden)]
+        )
+        self.mlp_out = Linear(self.dim, 1000) # classification of 1000 templates.
+
+    def forward(self, x, edge_index, batch, edge_weight=None):
+        x = F.relu(self.graphconv1(x, edge_index, edge_weight))
+        x = self.bn1(x)
+        for graphconv, bn_conv in zip(self.graphconv_hidden, self.bn_conv):
+            x = graphconv(x, edge_index, edge_weight)
+            x = bn_conv(x)
+        x = global_add_pool(x, batch)
+        for fc_mlp, bn_mlp in zip(self.mlp_hidden, self.bn_mlp):
+            x = F.relu(fc_mlp(x))
+            x = bn_mlp(x)
+            x = F.dropout(x, p=self.dropout, training=self.training)
+        x = F.log_softmax(self.mlp_out(x), dim=-1)
+        return x

data/Model/GCN/utils.py

@@ -0,0 +1,65 @@
+from rdkit import Chem
+from rdkit.Chem import AllChem
+import numpy as np
+import torch
+from Model.GCN import mol2graph
+
+def get_data(data_path):
+    mols, labels = [], []
+    with open(data_path, 'r') as f:
+        smis = f.read().splitlines()
+    for smi in smis:
+        smi = smi.split(' ')
+        labels.append(int(smi[0].strip('[]')))
+        smi = smi[1:]
+        smi = ''.join(smi)
+        mols.append(Chem.MolFromSmiles(smi)) 
+    return np.array(mols), np.array(labels)
+
+"""
+get_neg_sample: select negative sample according to the frequent distribution of library.
+Correct fragments(y) and fragments couldn't be connected to target(y_mask) are masked. """
+@torch.no_grad()
+def get_neg_sample(freq, y):
+    # y: (batch_size, )
+    # freq: (1, ), frequency of templates
+    batch_size = y.size(0)
+    freq = freq.repeat(batch_size, 1)
+    freq.scatter_(1, y.unsqueeze(1), 0)
+    neg_idxs = torch.multinomial(freq, 1, True).view(-1)
+    return neg_idxs
+
+def template_prediction(GCN_model, input_smi, num_sampling, GCN_device=None):
+    mol = Chem.MolFromSmiles(input_smi)
+    data = mol2graph.mol2vec(mol).to(GCN_device)
+    with torch.no_grad():
+        output = GCN_model.forward(data.x, data.edge_index, data.batch).squeeze() # shape(1, 1000) -> (1000,)
+        try:
+            _, indices = torch.topk(output, num_sampling)
+        except:
+            indices = None
+    return indices
+
+def batch_template_prediction(GCN_model, input_smi, num_sampling=5, GCN_device=None):
+    mol = Chem.MolFromSmiles(input_smi)
+    data = mol2graph.mol2vec(mol).to(GCN_device)
+    output = GCN_model.forward(data.x, data.edge_index, data.batch).squeeze() # shape(1, 1000) -> (1000,)
+    _, indices = torch.topk(output, num_sampling)
+    return indices
+    
+def check_templates(indices, input_smi, r_dict):
+    matched_indices = []
+    molecule = Chem.MolFromSmiles(input_smi)
+    for i in indices:
+        idx = str(i.item())
+        rsmi = r_dict[idx]
+        rxn = AllChem.ReactionFromSmarts(rsmi)
+        reactants = rxn.GetReactants()
+        flag = False
+        for reactant in reactants:
+            if molecule.HasSubstructMatch(reactant):
+                flag = True
+        if flag == True:
+            matched_indices.append(f'[{i.item()}]')
+    return matched_indices # list of string, ex) ['[0]', '[123]', ... '[742]']
+

data/Model/QSAR/qsar_AKT1_optimized.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06b15206f5a79076646130dd07bea5bc9111b278a27eb55c978d23f57855c56f
+size 8643648

data/Model/QSAR/qsar_CXCR4_optimized.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:29e8e71fb9791bcdc99a339357ac8e5b2a3660e5f1743c011b55cea61d202e4a
+size 2125387

data/Model/QSAR/qsar_DRD2_optimized.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2db876d2c1d2831594021419fdf8b037c624e68126b3cc240116f99b3c1609aa
+size 49644044

data/Model/Transformer/model.py

@@ -0,0 +1,201 @@
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
+import math
+from typing import Optional, Any, Union, Callable
+
+import torch
+from torch import Tensor
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.optim.lr_scheduler import _LRScheduler
+from torch.nn.init import xavier_uniform_
+import torchtext.vocab.vocab as Vocab
+
+
+
+class PositionalEncoding(nn.Module):
+# P(pos, 2d) = sin(pos/10000**(2d/D)), where d=index of token, D=d_model
+    def __init__(self, d_model: int, pad_idx: int=1, dropout: float = 0.1, max_len: int = 5000):
+        super().__init__()
+        self.dropout = nn.Dropout(p=dropout)
+        self.d_model = d_model
+        self.pad_idx = pad_idx
+
+        position = torch.arange(max_len).unsqueeze(1) # shape: (max_len, 1) の列ベクトル
+        div_term = torch.exp(torch.arange(0, self.d_model, 2) * (-math.log(10000.0) / self.d_model))
+        # torch.arange(start, stop, step) -> shape: (d_model/2,) 1次元ベクトル
+        pe = torch.zeros(max_len, 1, self.d_model) # (seq_length, 1, emb_dim)
+        pe[:, 0, 0::2] = torch.sin(position * div_term)
+        pe[:, 0, 1::2] = torch.cos(position * div_term)
+        self.register_buffer('pe', pe)
+
+    def forward(self, x:torch.tensor, pad_mask=None) -> torch.tensor:
+        """
+        Args:
+            x: Tensor, shape [seq_len, batch_size, embedding_dim]
+        """
+        if pad_mask is not None:
+            mask = pad_mask.permute(1, 0).unsqueeze(-1).repeat(1, 1, self.d_model) # paddingの位置をTrue
+        # make embeddings relatively larger
+        x = x * math.sqrt(self.d_model)
+        x = x + self.pe[:x.size(0)] # max_lenが5000とかでも入力のseq_lenまでを切り取って足してる
+        
+        if pad_mask is not None:
+            x = torch.where(mask == True, 0, x) # mask=Trueの位置を0に置換, それ以外はいじらない
+        return self.dropout(x)
+
+
+# Learning Rate Scheduler
+class TransformerLR(_LRScheduler):
+    """TransformerLR class for adjustment of learning rate.
+
+    The scheduling is based on the method proposed in 'Attention is All You Need'.
+    """
+
+    def __init__(self, optimizer, warmup_epochs=8000, last_epoch=-1, verbose=False):
+        """Initialize class."""
+        self.warmup_epochs = warmup_epochs
+        self.normalize = self.warmup_epochs**0.5
+        super().__init__(optimizer, last_epoch, verbose)
+
+    def get_lr(self):
+        """Return adjusted learning rate."""
+        step = self.last_epoch + 1
+        scale = self.normalize * min(step**-0.5, step * self.warmup_epochs**-1.5)
+        return [base_lr * scale for base_lr in self.base_lrs]
+
+
+# Transformer model
+class Transformer(nn.Module):
+    def __init__(self, d_model: int = 256, nhead: int = 8, num_encoder_layers: int = 4, num_decoder_layers: int =4,
+                 dim_feedforward: int = 2048, dropout: float = 0.1, activation: Union[str, Callable[[Tensor], Tensor]] = F.relu,
+                 vocab: Vocab = None, layer_norm_eps: float = 1e-5, batch_first: bool = False, norm_first: bool = False,
+                 device=None, dtype=None) -> None:
+        factory_kwargs = {'device': device, 'dtype': dtype}
+        super().__init__()
+
+        if vocab == None:
+            raise RuntimeError("set vocab: torch.vocab.vocab")
+        
+        # INFO
+        self.model_type = "Transformer"
+        self.vocab = vocab
+        num_tokens = vocab.__len__()
+        
+        self.positional_encoder = PositionalEncoding(d_model=d_model,
+                                                     pad_idx=self.vocab['<pad>'],
+                                                     dropout=dropout,
+                                                     max_len=5000
+                                                     )
+        self.embedding = nn.Embedding(num_tokens, d_model, padding_idx=self.vocab['<pad>'])
+
+        encoder_layer = nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout,
+                                                activation, layer_norm_eps, batch_first, norm_first,
+                                                **factory_kwargs)
+        encoder_norm = nn.LayerNorm(d_model, eps=layer_norm_eps, **factory_kwargs)
+        self.encoder = nn.TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm)
+
+        decoder_layer = nn.TransformerDecoderLayer(d_model, nhead, dim_feedforward, dropout,
+                                                activation, layer_norm_eps, batch_first, norm_first,
+                                                **factory_kwargs)
+        decoder_norm = nn.LayerNorm(d_model, eps=layer_norm_eps, **factory_kwargs)
+        self.decoder = nn.TransformerDecoder(decoder_layer, num_decoder_layers, decoder_norm)
+        
+        self.out = nn.Linear(d_model, num_tokens)
+        
+        self._reset_parameters()
+        self.d_model = d_model
+        self.nhead = nhead
+        self.batch_first = batch_first
+        
+
+    # Transformer blocks - Out size = (seq_length, batch_size, num_tokens)
+    # input src, tgt must be (seq_length, batch_size)
+    def forward(self, src: Tensor, tgt: Tensor, src_mask: Optional[Tensor] = None,
+                tgt_mask: Optional[Tensor] = None, memory_mask: Optional[Tensor] = None,
+                src_pad_mask: bool = False, tgt_pad_mask: bool = False,
+                memory_pad_mask: bool = False) -> Tensor:
+        
+        if src_pad_mask is True:
+            src_pad_mask = (src == self.vocab['<pad>']).permute(1, 0)
+        else:
+            src_pad_mask = None
+            
+        if tgt_pad_mask is True:
+            tgt_pad_mask = (tgt == self.vocab['<pad>']).permute(1, 0)
+        else:
+            tgt_pad_mask = None
+        
+        if memory_pad_mask is True:
+            memory_pad_mask = (src == self.vocab['<pad>']).permute(1, 0)
+        else:
+            memory_pad_mask = None
+        
+        # Embedding
+        src = self.embedding(src)
+        tgt = self.embedding(tgt)
+        src = self.positional_encoder(src, src_pad_mask)
+        tgt = self.positional_encoder(tgt, tgt_pad_mask)
+        
+        # Transformer layer
+        is_batched = src.dim() == 3
+        if not self.batch_first and src.size(1) != tgt.size(1) and is_batched:
+            raise RuntimeError("the batch number of src and tgt must be equal")
+        elif self.batch_first and src.size(0) != tgt.size(0) and is_batched:
+            raise RuntimeError("the batch number of src and tgt must be equal")
+        if src.size(-1) != self.d_model or tgt.size(-1) != self.d_model:
+            raise RuntimeError("the feature number of src and tgt must be equal to d_model")
+        
+        memory = self.encoder(src=src, mask=src_mask, src_key_padding_mask=src_pad_mask)
+        transformer_out = self.decoder(tgt=tgt, memory=memory, tgt_mask=tgt_mask, memory_mask=memory_mask,
+                              tgt_key_padding_mask=tgt_pad_mask, memory_key_padding_mask=memory_pad_mask)
+        out = self.out(transformer_out)
+        
+        return out
+    
+    def encode(self, src: Tensor, src_mask: Optional[Tensor] = None,
+               src_pad_mask: bool = False) -> Tensor:
+        
+        if src_pad_mask is True:
+            src_pad_mask = (src == self.vocab['<pad>']).permute(1, 0)
+        else:
+            src_pad_mask = None
+        
+        # Embedding + PE
+        src = self.embedding(src)
+        src = self.positional_encoder(src, src_pad_mask)
+
+        # Transformer Encoder
+        memory = self.encoder(src=src, mask=src_mask, src_key_padding_mask=src_pad_mask)
+        
+        return memory, src_pad_mask
+    
+    def decode(self, memory: Tensor, tgt: Tensor, tgt_mask: Optional[Tensor] = None,
+               memory_mask: Optional[Tensor] = None, tgt_pad_mask: bool = False,
+               memory_pad_mask: Optional[Tensor] = None) -> Tensor:
+        
+        if tgt_pad_mask is True:
+            tgt_pad_mask = (tgt == self.vocab['<pad>']).permute(1, 0)
+        else:
+            tgt_pad_mask = None
+            
+        tgt = self.embedding(tgt)
+        tgt = self.positional_encoder(tgt, tgt_pad_mask)
+        transformer_out = self.decoder(tgt=tgt, memory=memory, tgt_mask=tgt_mask, memory_mask=memory_mask,
+                              tgt_key_padding_mask=tgt_pad_mask, memory_key_padding_mask=memory_pad_mask)
+        out = self.out(transformer_out)
+        
+        return out
+    
+    def embed(self, src):
+        src_embed = self.embedding(src)
+        return src_embed
+
+    def _reset_parameters(self):
+        r"""Initiate parameters in the transformer model."""
+
+        for p in self.parameters():
+            if p.dim() > 1:
+                xavier_uniform_(p)

data/Utils/reward.py

@@ -0,0 +1,112 @@
+import numpy as np
+import pandas as pd
+import pickle
+import hydra
+
+import warnings
+warnings.filterwarnings('ignore')
+
+import rdkit.Chem as Chem
+from rdkit import RDLogger
+RDLogger.DisableLog('rdApp.*')
+from rdkit.Chem import AllChem, QED
+
+def getReward(name,
+              receptor_path=None,
+              pdbqt_path=None,
+              VinaGPU_path=None,
+              VinaGPU_config=None):
+    if name == "QED":
+        return QEDReward()
+    elif name == 'DRD2':
+        with open(hydra.utils.get_original_cwd() + '/Model/QSAR/drd2_qsar_optimized.pkl', mode='rb') as f:
+            qsar_model = pickle.load(f)
+        return QSAR_Reward(qsar_model)
+    elif name == 'AKT1':
+        with open(hydra.utils.get_original_cwd() + '/Model/QSAR/akt1_qsar_optimized.pkl', mode='rb') as f:
+            qsar_model = pickle.load(f)
+        return QSAR_Reward(qsar_model)
+
+
+class Reward:
+    def __init__(self):
+        self.vmin = -100
+        self.max_r = -10000
+        return
+
+    def reward(self):
+        raise NotImplementedError()
+
+class QSAR_Reward(Reward):
+    def __init__(self, qsar_model, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.qsar_model = qsar_model
+
+    def reward(self, score_que:list = None):
+        max_smi = None
+        scores = []
+        mols = [Chem.MolFromSmiles(smi) for smi in score_que]
+        ecfps = []
+        None_indices = []
+        for i, mol in enumerate(mols):
+            if mol is not None:
+                ecfps.append(AllChem.GetMorganFingerprintAsBitVect(mol, 3, nBits=2048))
+            else:
+                None_indices.append(i)
+                ecfps.append([0]*2048)
+        if len(ecfps) == 0:
+            return [], None, None
+        ecfp6_array = np.array(ecfps)
+        X = pd.DataFrame(ecfp6_array, columns=[f'bit_{i}' for i in range(2048)])
+        y_pred = self.qsar_model.predict_proba(X)[:, 1]
+        for None_idx in None_indices:
+            y_pred[None_idx] = np.nan
+        max_score = np.nanmax(y_pred)
+        for smi, score in zip(score_que, y_pred):
+            if score == np.nan:
+                pass
+            elif score == max_score:
+                max_smi = smi
+            scores.append((smi, score))
+        return scores, max_smi, max_score
+    
+    def reward_remove_nan(self, score_que:list = None):
+        max_smi = None
+        scores = []
+        # convert smiles to mol if mol is not none.
+        valid_smiles = []
+        mols = []
+        for smi in score_que:
+            mol = Chem.MolFromSmiles(smi)
+            if mol is not None:
+                valid_smiles.append(smi)
+                mols.append(mol)
+        ecfps = []
+        for i, mol in enumerate(mols):
+            if mol is not None:
+                ecfps.append(AllChem.GetMorganFingerprintAsBitVect(mol, 3, nBits=2048))
+        if len(ecfps) == 0:
+            return [], None, None
+        ecfp6_array = np.array(ecfps)
+        X = pd.DataFrame(ecfp6_array, columns=[f'bit_{i}' for i in range(2048)])
+        y_pred = self.qsar_model.predict_proba(X)[:, 1]
+        max_score = np.nanmax(y_pred)
+        for smi, score in zip(valid_smiles, y_pred):
+            if score == max_score:
+                max_smi = smi
+            scores.append((smi, score))
+        return scores, max_smi, max_score
+
+class QEDReward(Reward):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.vmin = 0
+
+    def reward(self, smi):
+        mol = Chem.MolFromSmiles(smi)
+        try:
+            score = QED.qed(mol)
+        except:
+            score = None
+
+        return score

data/Utils/utils.py

@@ -0,0 +1,297 @@
+import numpy as np
+import math
+from tqdm import tqdm
+from copy import deepcopy
+import random
+import numpy as np
+import warnings
+warnings.filterwarnings('ignore')
+
+from rdkit import RDLogger
+RDLogger.DisableLog('rdApp.*')
+from rdkit.Chem import Descriptors
+
+import torch
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+def smi_tokenizer(smi):
+    '''
+    Tokenize a SMILES molecule or reaction
+    '''
+    import re
+    pattern =  '(\[[^\]]+]|Br?|Cl?|N|O|S|P|F|I|b|c|n|o|s|p|\(|\)|\.|=|#|-|\+|\\\\|\/|:|~|@|\?|>|\*|\$|\%[0-9]{2}|[0-9])'
+    regex = re.compile(pattern)
+    tokens = [token for token in regex.findall(smi)]
+    assert smi == ''.join(tokens)
+    return ' '.join(tokens)
+
+class Node:
+    def __init__(self):
+        self.parent = None
+        self.template = None
+        self.path = []
+        self.depth = -100
+        self.visit = 1
+        self.children = []
+        self.imm_score = 0
+        self.cum_score = 0
+        self.c = 1
+        self.id = -1
+        self.rollout_result = ('None', -1000)
+
+    def add_Node(self, c):
+        c.parent = self
+        c.depth = self.depth + 1
+        self.children.append(c)
+
+    def calc_UCB(self):
+        if self.visit == 0:
+            ucb = 1e+6
+        else:
+            ucb = self.cum_score/self.visit + self.c*math.sqrt(2*math.log(self.parent.visit)/self.visit)
+        return ucb
+
+    def select_children(self):
+        children_ucb = []
+        for cn in self.children:
+            children_ucb.append(cn.calc_UCB())
+        max_ind = np.random.choice(np.where(np.array(children_ucb) == max(children_ucb))[0])
+        return self.children[max_ind]
+
+    def select_children_rand(self):
+        indices = list(range(0, len(self.children)))
+        ind = np.random.choice(indices)
+        return self.children[ind]
+
+
+class RootNode(Node):
+    def __init__(self, c=1/np.sqrt(2)):
+        super().__init__()
+        self.smi = '&&'
+        self.depth = 0
+
+        self.c = c
+
+class NormalNode(Node):
+    def __init__(self, smi, c=1/np.sqrt(2)):
+        super().__init__()
+        self.smi = smi
+        self.c = c
+        self.template = None
+
+    def remove_Node(self):
+        self.parent.children.remove(self)
+
+def read_smilesset(path):
+    smiles_list = []
+    with open(path) as f:
+        for smiles in f:
+            smiles_list.append(smiles.rstrip())
+
+    return smiles_list
+
+# caluculate the number of parameters
+def tally_parameters(model):
+    n_params = sum([p.nelement() for p in model.parameters()])
+    enc = 0
+    dec = 0
+    for name, param in model.named_parameters():
+        if 'encoder' in name:
+            enc += param.nelement()
+        elif 'decoder' or 'generator' in name:
+            dec += param.nelement()
+    return n_params, enc, dec
+
+
+class EarlyStopping:
+    def __init__(self, patience=10, ckpt_dir=None):
+        '''引数: 最小値の非更新数カウンタ、表示設定、モデル格納path'''
+
+        self.patience = patience    #設定ストップカウンタ
+        self.counter = 0            #現在のカウンタ値
+        self.best_score = None      #ベストスコア
+        self.early_stop = False     #ストップフラグ
+        self.val_loss_min = np.Inf   #前回のベストスコア記憶用
+        self.path = ckpt_dir         #ベストモデル格納path
+
+    def __call__(self, val_loss, step, optimizer, cur_loss, model):
+        '''
+        特殊(call)メソッド
+        実際に学習ループ内で最小lossを更新したか否かを計算させる部分
+        '''
+        score = -val_loss
+
+        if self.best_score is None:  #1Epoch目の処理
+            self.best_score = score   #1Epoch目はそのままベストスコアとして記録する
+            self.checkpoint(val_loss, step, optimizer, cur_loss, model)  #記録後にモデルを保存してスコア表示する
+        elif score < self.best_score:  # ベストスコアを更新できなかった場合
+            self.counter += 1   #ストップカウンタを+1
+            print(f'Validation loss increased ({self.val_loss_min:.6f} --> {val_loss:.6f}).')
+            self.checkpoint(val_loss, step, optimizer, cur_loss, model)
+            print(f'EarlyStopping counter: {self.counter} out of {self.patience}')  #現在のカウンタを表示する 
+            if self.counter >= self.patience:  #設定カウントを上回ったらストップフラグをTrueに変更
+                self.early_stop = True
+        else:  #ベストスコアを更新した場合
+            self.best_score = score  #ベストスコアを上書き
+            print(f'Validation loss decreased! ({self.val_loss_min:.6f} --> {val_loss:.6f}) Saving model ...')
+            self.checkpoint(val_loss, step, optimizer, cur_loss, model)  #モデルを保存してスコア表示
+            self.counter = 0  #ストップカウンタリセット
+
+    def checkpoint(self, val_loss, step, optimizer, cur_loss, model):
+        torch.save({'step': step,
+                    'model_state_dict': model.state_dict(),
+                    'optimizer_state_dict': optimizer.state_dict(),
+                    'loss': cur_loss,}, f'{self.path}/ckpt_{step+1}.pth')
+        self.val_loss_min = val_loss  #その時のlossを記録する
+
+class AverageMeter(object):
+    '''Computes and stores the average and current value'''
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.value = 0 # latest value
+        self.avg = 0
+        self.sum = 0
+        self.count = 0
+
+    def update(self, value, n=1):
+        self.value = value
+        self.sum += value * n
+        self.count += n
+        self.avg = self.sum / self.count
+
+# def accuracy(output, target, batch_size, v=None):
+#     '''
+#     Computes the accuracy of top1 prediction
+    
+#     output: (seq_length*batch_size, num_tokens)
+#     target: (seq_length*batch_size)
+#     '''
+    
+#     pad_mask = (target != v['<pad>']) # padはFalse, それ以外はTrue
+#     true_pos = torch.nonzero(pad_mask).squeeze().tolist()
+#     out_extracted = output[true_pos]
+#     t_extracted = target[true_pos]
+#     _, pred = out_extracted.topk(1, 1, True, True) # arg of topk: (k, dim=1, largest=True, sorted=True)
+#     pred = pred.t() # (seq*batch, maxk) -> (maxk, seq*batch)
+#     correct = pred.eq(t_extracted.reshape(1, -1).expand_as(pred)) # target:(seq*batch, 1) -> (1, seq*batch) -> (maxk, seq*batch)
+#     # Tensor.eq: compute element-wise equality, correct: bool matrix
+#     correct_rate = (correct[0].float().sum(0, keepdim=True)) / len(t_extracted)
+    
+#     # compute accuracy per whole molecule
+#     target = target.reshape(-1, batch_size)
+#     output = output.reshape(-1, batch_size, v.__len__())
+#     _, pred = output.topk(10, 2, True, True)
+#     top1, top5, top10 = pred[:, :, 0], pred[:, :, 0:4], pred[:, :, 0:9]
+#     pred_list = [top1, top5, top10]
+#     perfect_acc_list = []
+#     EOS_token = v['<eos>']
+#     for pred in pred_list:
+#         correct_cum = 0
+#         for i in range(batch_size):
+#             t = target[:, i].tolist()
+#             eos_idx = t.index(EOS_token)
+#             t = t[0:eos_idx]
+#             p = pred[:, i].tolist()
+#             p = p[0:len(t)]
+#             if t == p:
+#                 correct_cum += 1
+#         perfect_acc_list.append(correct_cum / batch_size)
+#     return correct_rate.item(), perfect_acc_list
+
+def accuracy(output, target, batch_size, v=None):
+    '''
+    Computes the accuracy of top1 prediction
+    
+    output: (seq_length*batch_size, num_tokens)
+    target: (seq_length*batch_size)
+    '''
+    
+    pad_mask = (target != v['<pad>']) # padはFalse, それ以外はTrue
+    true_pos = torch.nonzero(pad_mask).squeeze().tolist()
+    out_extracted = output[true_pos]
+    t_extracted = target[true_pos]
+    _, pred = out_extracted.topk(1, 1, True, True) # arg of topk: (k, dim=1, largest=True, sorted=True)
+    pred = pred.t() # (seq*batch, maxk) -> (maxk, seq*batch)
+    correct = pred.eq(t_extracted.reshape(1, -1).expand_as(pred)) # target:(seq*batch, 1) -> (1, seq*batch) -> (maxk, seq*batch)
+    # Tensor.eq: compute element-wise equality, correct: bool matrix
+    correct_rate = (correct[0].float().sum(0, keepdim=True)) / len(t_extracted)
+    
+    # compute accuracy per whole molecule
+    target = target.reshape(-1, batch_size)
+    output = output.reshape(-1, batch_size, v.__len__())
+    _, pred = output.topk(1, 2, True, True)
+    pred = pred.squeeze() # (seq, batch) -> (batch, seq)
+    correct_cum = 0
+    EOS_token = v['<eos>']
+    for i in range(batch_size):
+        t = target[:, i].tolist()
+        eos_idx = t.index(EOS_token)
+        t = t[0:eos_idx]
+        p = pred[:, i].tolist()
+        p = p[0:len(t)]
+        if t == p:
+            correct_cum += 1
+    perfect_acc = correct_cum / batch_size
+    return correct_rate.item(), perfect_acc
+
+def calc_topk_perfect_acc(x, target, batch_size, EOS):
+    '''
+    x: predicted tensor of shape (seq, batch, k)
+    target: (seq, batch)
+    '''
+    correct_cum = 0
+    if x.dim() < 3:
+        x = x.unsqueeze(-1)
+    for i in range(batch_size):
+        t = target[:, i].tolist()
+        eos_idx = t.index(EOS)
+        t = t[0:eos_idx]
+        for j in range(x.size(2)):
+            p = x[:, i, j].tolist()
+            p = p[0:len(t)]
+            if t == p:
+                correct_cum += 1
+                break
+    return correct_cum / batch_size
+    
+
+def MW_checker(mol, threshold:int = 500):
+    MW = Descriptors.ExactMolWt(mol)
+    if MW > threshold:
+        return False
+    else:
+        return True
+
+def is_empty(li):
+    return all(not sublist for sublist in li)
+
+def torch_fix_seed(seed=42):
+    # Python random
+    random.seed(seed)
+    # Numpy
+    np.random.seed(seed)
+    # Pytorch
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.use_deterministic_algorithms = True
+    
+
+# 例えばimport utils とした場合、そのutils.__name__ にはモジュール名（ファイル名）が格納される
+# このファイルをimportで呼び出した場合、print(utils.__name__) の出力結果は'utils'
+# ただし、importではなくコマンドラインで直接実行された場合は__name__ に __main__ が格納される
+# よって、以下はimportされたときには実行されず、コマンドラインで実行されたときにだけ動く
+if __name__ == '__main__':
+    smiles_list = read_smilesset('Data/input/250k_rndm_zinc_drugs_clean.smi')
+    vocab = []
+    for smiles in tqdm(smiles_list):
+        p = parse_smiles(smiles)
+        vocab.extend(p)
+
+    vocab = list(set(vocab))
+    vocab.sort()
+    print(vocab)
+    

data/ckpts/GCN/GCN.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c6b85821672caa8cf4b35d11c1241e76fe0109ee635a9a5fe1549e3fd10b92a
+size 2188609

data/config/config.py

@@ -0,0 +1,104 @@
+import math
+
+from hydra.core.config_store import ConfigStore
+from dataclasses import dataclass
+
+@dataclass
+class PreProcess:
+    augm_size: int = 1
+    src_train: str = '/data/USPTO/src_train.txt'
+    tgt_train: str = '/data/USPTO/tgt_train.txt'
+    src_valid: str = '/data/USPTO/src_valid.txt'
+    tgt_valid: str = '/data/USPTO/tgt_valid.txt'
+    batch_size: int = 256
+    
+@dataclass
+class ModelConfig:
+    dim_model: int = 512
+    num_encoder_layers: int = 6
+    num_decoder_layers: int = 6
+    nhead: int = 8
+    dropout: float = 0.1
+    dim_ff: int = 2048
+    ckpt:str = '/ckpts/Transformer/ckpt_conditional.pth'
+
+@dataclass
+class TrainConfig:
+    src_train: str = '/data/USPTO/src_train.txt'
+    tgt_train: str = '/data/USPTO/tgt_train.txt'
+    src_valid: str = '/data/USPTO/src_valid.txt'
+    tgt_valid: str = '/data/USPTO/tgt_valid.txt'
+    batch_size: int = 128
+    label_smoothing: float = 0.0
+    lr: float = 0.001
+    betas: tuple = (0.9, 0.998)
+    step_num: int = 500000 # set training steps
+    patience: int = 10
+    log_interval : int = 100
+    val_interval: int = 1000
+    save_interval: int = 10000
+
+@dataclass
+class TranslateConfig:
+    src_train: str = '/data/USPTO/src_train.txt'
+    tgt_train: str = '/data/USPTO/tgt_train.txt'
+    src_valid: str = '/data/USPTO/src_valid.txt'
+    tgt_valid: str = '/data/USPTO/tgt_valid.txt'
+    GCN_ckpt: str = '/ckpts/GCN/GCN.pth'
+    out_dir: str = '/translation'
+    src_test_path: str = '/data/input/test.txt'
+    annotated_templates: str = '/data/beamsearch_template_list.txt'
+    filename: str = 'test'
+    GCN_num_sampling: int = 10
+    inf_max_len: int = 256
+    nbest: int = 10
+    beam_size: int = 10
+
+@dataclass
+class GCN_TrainConfig:
+    train: str = '/data/USPTO/src_train.txt'
+    valid: str = '/data/USPTO/src_valid.txt'
+    test: str = '/data/USPTO/src_test.txt'
+    batch_size: int = 256
+    dim: int = 256
+    n_conv_hidden: int = 1
+    n_mlp_hidden: int = 3
+    dropout: float = 0.1
+    lr: float =  0.0004
+    epochs: int = 100
+    patience: int = 5
+    save_path: str = '/ckpts/GCN'
+    
+
+
+@dataclass
+class MCTSConfig:
+    src_train: str = '/data/USPTO/src_train.txt'
+    tgt_train: str = '/data/USPTO/tgt_train.txt'
+    src_valid: str = '/data/USPTO/src_valid.txt'
+    tgt_valid: str = '/data/USPTO/tgt_valid.txt'
+    n_step: int = 200
+    max_depth: int = 10
+    in_smiles_file: str = '/data/input/init_smiles_drd2.txt'
+    out_dir: str = '/mcts_out'
+    ucb_c: float = 1/math.sqrt(2)
+    reward_name: str = 'DRD2'  # 'DRD2' or 'QED'
+    ckpt_Transformer: str = '/ckpts/Transformer/ckpt_conditional.pth'
+    ckpt_GCN: str = '/ckpts/GCN/GCN.pth'
+    beam_width:int = 10
+    nbest:int = 10
+    exp_num_sampling:int = 10
+    rollout_depth:int = 2
+    roll_num_sampling:int = 5
+
+@dataclass
+class Config:
+    prep: PreProcess = PreProcess()
+    model: ModelConfig = ModelConfig()
+    train: TrainConfig = TrainConfig()
+    translate: TranslateConfig = TranslateConfig()
+    GCN_train: GCN_TrainConfig = GCN_TrainConfig()
+    mcts: MCTSConfig = MCTSConfig()
+
+cs = ConfigStore.instance()
+cs.store(name="config", node=Config)

data/data/QSAR/CXCR4/cxcr4_test.csv

@@ -0,0 +1,428 @@
+canonical,activity
+CCCCCCNC(=NC1CCCCC1)SCC1=CSC2=NCCN12,1
+c1ccc(CNCc2ccc(CN(Cc3nc4ccccc4[nH]3)C3CCCc4cccnc43)cc2)nc1,1
+C1=C(CSC(=NC2CCCCC2)NC23CC4CC(CC(C4)C2)C3)N2CCN=C2S1,1
+CC1C(=O)NC(CCCN=C(N)N)C(=O)NC(Cc2ccc3ccccc3c2)C(=O)NCC(=O)NC(Cc2ccc(O)cc2)C(=O)N1C,1
+CC(=O)NCCCC1C(=O)NC(CCCNC(N)=O)C(=O)NC(Cc2ccc3ccccc3c2)C(=O)NCC(=O)NC(Cc2ccc(O)cc2)C(=O)N1C,1
+CN1C(=O)C(Cc2ccc3ccccc3c2)NC(=O)CNC(=O)C(Cc2ccc(O)cc2)NC(=O)C(CCCNC(=N)N)NC(=O)C1CCCNC(=N)N,1
+CC(C)CC(NC(=N)N)C(=O)Nc1ccc2c(c1)cc(C(=O)NCCc1c[nH]c3ccccc13)n2CCCNC(=N)N,1
+COC(=O)C1C(O)CCC2CN(C#N)C(c3[nH]c4ccccc4c3CCn3cc(-c4cccc(Cl)c4)nn3)CC21,1
+N=C(N)NCCCC1NC(=O)C(Cc2ccc(O)cc2)NC(=O)CCC(Cc2ccc3ccccc3c2)NC(=O)C(CCCN=C(N)N)NC1=O,1
+N=C(N)NCCCC1NC(=O)C(NC(=O)CCNC(=N)N)CSSCC(C(N)=O)NC(=O)C(Cc2ccc3ccccc3c2)NC1=O,1
+Cc1cc(NC2CCN(C(=O)CCNCC(=O)O)CC2)nc(NCc2cn(CCCNCCCNC3CCCCC3)nn2)n1,1
+N=C(N)NCCCn1c(C(=O)NCCc2c[nH]c3ccccc23)cc2cc(NC(=O)C(Cc3ccccc3)NC(=N)N)ccc21,1
+Oc1cccc(CN(CCN2CCCCC2)CC2CCCN(C3CCCC3)C2)c1,1
+c1ccc(CNCc2ccc(CN(Cc3nc4ccccc4[nH]3)C3CCCc4cccnc43)cc2)nc1,1
+CN1C(=O)C(CCCNC(=N)N)NC(=O)C(Cc2ccc3ccccc3c2)NC(=O)CNC(=O)C(Cc2ccc(O)cc2)NC(=O)C1CCCNC(=N)N,1
+N=C(N)NCCCn1c(C(=O)NCCc2c[nH]c3ccccc23)cc2cc(NC(=O)CNC(=N)N)ccc21,1
+N=C(N)NCCCC1NC(=O)C(NC(=O)CCNC(=N)N)CC=CCC(C(N)=O)NC(=O)C(Cc2ccc3ccccc3c2)NC1=O,1
+N=C(N)NCCC(=O)NC1CC=CCCC(C(N)=O)NC(=O)C(Cc2ccc3ccccc3c2)NC(=O)C(CCCN=C(N)N)NC1=O,1
+CCCCCCNC(=NC1CCCCC1)SCC1=CSC2=NCCN12,1
+CCCCCCNC(=NC1CCCCC1)SCC1=CSC2=NCCN12,1
+Cc1cc(N(C)C2CCN(C(=O)CCNCC(=O)O)CC2)nc(NCc2cn(CCCNCCCNC3CCCCC3)nn2)n1,1
+CCc1cc(NC2CCN(C(=O)CCNCC(=O)O)CC2)nc(NCc2cn(CCCNCCCNC3CCCCC3)nn2)n1,1
+c1ccc(CNCc2ccc(CN(Cc3nc4ccccc4[nH]3)C3CCCc4cccnc43)cc2)nc1,1
+C1=C(CSC(=NC2CCCCC2)NC23CC4CC(CC(C4)C2)C3)N2CCN=C2S1,1
+Cc1cc(NC2CCN(C(=O)CCNCCC(=O)O)CC2)nc(NCc2cn(CCCNCCCNC3CCCCC3)nn2)n1,1
+Cc1cc(NC2CCN(CCCCC(=O)O)CC2)nc(NCc2cn(CCCNCCCNC3CCCCC3)nn2)n1,1
+N=C(N)NCCC(=O)NC1CCC=CCCC(C(N)=O)NC(=O)C(Cc2ccc3ccccc3c2)NC(=O)C(CCCN=C(N)N)NC1=O,1
+N=C(N)NCCCn1c(C(=O)NCCc2c[nH]c3ccccc23)cc2cc(NC(=O)C(Cc3ccccc3)NC(=N)N)ccc21,1
+N=C(N)NCCc1cc2cc(NC(=O)CCc3ccc(O)cc3)ccc2n1CCc1ccc2ccccc2c1,1
+Cc1cc(NC2CCN(C(=O)CCCNCC(=O)O)CC2)nc(NCc2cn(CCCNCCCNC3CCCCC3)nn2)n1,1
+N=C(N)NCCCn1c(C(=O)Nc2cccc3ccccc23)cc2cc(NC(=O)Cc3ccc(O)cc3)ccc21,1
+CN1C(=O)C(Cc2ccc(O)cc2)NC(=O)CNC(=O)C(Cc2ccc3ccccc3c2)NC(=O)C(CCCNC(=N)N)NC(=O)C1CCCNC(=N)N,1
+CC(=O)NCCCC1C(=O)NC(CCCNC(=N)N)C(=O)NC(Cc2ccc3ccccc3c2)C(=O)NCC(=O)NC(Cc2ccc(O)cc2)C(=O)N1C,1
+N=C(N)NCCCC1NC(=O)C(Cc2ccc(O)cc2)NC(=O)CNC(=O)C(Cc2ccc3ccccc3c2)NC(=O)C(CCCNC(=N)N)NC1=N,1
+CN1C(=O)C(Cc2ccc(O)cc2)NC(=O)CNC(=O)C(Cc2ccc3ccccc3c2)NC(=O)C(CCCNC(=N)N)NC(=O)C1CCCNC(=N)N,1
+N=C(N)NCCCn1c(C(=O)NCCc2c[nH]c3ccccc23)cc2cc(NC(=O)C3CCN(C(=N)N)CC3)ccc21,1
+Cc1cc(NC2CCN(CCC(=O)O)CC2)nc(NCc2cn(CCCNCCCNC3CCCCC3)nn2)n1,1
+Cc1cc(NC2CCN(CCC(N)=O)CC2)nc(NCc2cn(CCCNCCCNC3CCCCC3)nn2)n1,1
+CCCN1CCC(Nc2cc(C)nc(NCc3cn(CCCNCCCNC4CCCCC4)nn3)n2)CC1,1
+N=C(N)NCCCC1NC(=O)C2CC(N=C(N)N)CN2C(=O)C(Cc2ccc(O)cc2)NC(=O)CNC(=O)C(Cc2ccc3ccccc3c2)NC1=O,1
+N=C(N)NCCCC1NC(=O)C(Cc2ccc3ccccc3c2)NC(=O)CCNC(=O)C(Cc2ccc(O)cc2)NC(=O)C(CCCNC(=N)N)NC1=O,1
+N=C(N)NCCCC1NC(=O)C(Cc2ccc3ccccc3c2)NC(=O)CCNC(=O)C(Cc2ccc(O)cc2)NC(=O)C(CCCNC(=N)N)NC1=O,1
+NCCCCC1NC(=O)C(Cc2ccc(O)cc2)NC(=O)CNC(=O)C(Cc2ccc3ccccc3c2)NC(=O)C(CCCN=C(N)N)NC1=O,1
+CN1C(=O)C(Cc2ccc(O)cc2)NC(=O)CNC(=O)C(Cc2ccc3ccccc3c2)NC(=O)C(CCCNC(=N)N)NC(=O)C1CCCNC(=N)N,1
+CN1C(=O)C(Cc2ccc(O)cc2)NC(=O)CNC(=O)C(Cc2ccc3ccccc3c2)NC(=O)C(CCCNC(=N)N)NC(=O)C1CCCNC(=N)N,1
+CC(C)CC(NC(=N)N)C(=O)Nc1ccc2c(c1)cc(C(=O)NCCc1c[nH]c3ccccc13)n2CCCNC(=N)N,1
+O=C(O)CNCCC(=O)N1CCC(Nc2ccnc(NCc3cn(CCCNCCCNC4CCCCC4)nn3)n2)CC1,1
+Cc1cc(NC2CCN(CCC#N)CC2)nc(NCc2cn(CCCNCCCNC3CCCCC3)nn2)n1,1
+Cc1cc(NC2CCN(C(=O)CCCC(=O)O)CC2)nc(NCc2cn(CCCNCCCNC3CCCCC3)nn2)n1,1
+CCc1cc(NC2CCN(C(=O)CCNCCP(=O)(O)O)CC2)nc(NCc2cn(CCCNCCCNC3CCCCC3)nn2)n1,1
+N=C(N)NCCCC1NC(=O)C(CCCNC(=N)N)NC(=O)C(Cc2ccc(O)cc2)NC(=O)CNC(=O)C(Cc2ccc3ccccc3c2)NC1=N,1
+Cc1cc(NC2CCN(C(=O)CCC(N)C(=O)O)CC2)nc(NCc2cn(CCCNCCCNC3CCCCC3)nn2)n1,1
+Cc1cc(NC2CCN(CCCCCC(=O)O)CC2)nc(NCc2cn(CCCNCCCNC3CCCCC3)nn2)n1,1
+N=C(N)NCCCC1NC(=O)C2CC(N=C(N)N)CN2C(=O)C(Cc2ccc(O)cc2)NC(=O)CNC(=O)C(Cc2ccc3ccccc3c2)NC1=O,1
+NC(=O)CCC1NC(=O)C(Cc2ccc(O)cc2)NC(=O)CNC(=O)C(Cc2ccc3ccccc3c2)NC(=O)C(CCCN=C(N)N)NC1=O,1
+CN1C(=O)C(Cc2ccc(O)cc2)NC(=O)CNC(=O)C(Cc2ccc3ccccc3c2)NC(=O)C(CCCNC(=N)N)NC(=O)C1CCCN,1
+N=C(N)NCCCNC1CSSCC(C(N)=O)NC(=O)C(Cc2ccc3ccccc3c2)NC(=O)C(CCCN=C(N)N)NC1=O,1
+N=C(N)NCCCC1NC(=O)C(Cc2ccc(O)cc2)NC(=O)CCNC(=O)C(Cc2ccc3ccccc3c2)NC(=O)C(CCCNC(=N)N)NC1=O,1
+CN1C(=O)C(Cc2ccc3ccccc3c2)NC(=O)CNC(=O)C(Cc2ccc(O)cc2)NC(=O)C(CCCNC(=N)N)NC(=O)C1CCCNC(=N)N,1
+CC1C(=O)NC(CCCN=C(N)N)C(=O)NC(Cc2ccc3ccccc3c2)C(=O)NCC(=O)NC(Cc2ccc(O)cc2)C(=O)N1C,1
+CN1C(=O)C(CCCNC(=N)N)NC(=O)C(Cc2ccc3ccccc3c2)NC(=O)CNC(=O)C(Cc2ccc(O)cc2)NC(=O)C1CCCNC(=N)N,1
+NCCC1NC(=O)C(Cc2ccc(O)cc2)NC(=O)CNC(=O)C(Cc2ccc3ccccc3c2)NC(=O)C(CCCN=C(N)N)NC1=O,1
+NC(=O)CC1NC(=O)C(Cc2ccc(O)cc2)NC(=O)CNC(=O)C(Cc2ccc3ccccc3c2)NC(=O)C(CCCN=C(N)N)NC1=O,1
+Cc1cc(NC2CCN(C(=O)CNCCC(=O)O)CC2)nc(NCc2cn(CCCNCCCNC3CCCCC3)nn2)n1,1
+C1=C(CSC(=NC2CCCCC2)NC23CC4CC(CC(C4)C2)C3)N2CCN=C2S1,1
+CCCCN(c1nc2ccccc2o1)C(CC)c1ccc(-c2ccccc2-c2nnn[nH]2)cc1,1
+CCCCN(c1nc2ccccc2o1)C(C)c1ccc(-c2ccccc2-c2nnn[nH]2)cc1,1
+Cc1cc(NC2CCN(C(=O)CCNCP(=O)(O)O)CC2)nc(NCc2cn(CCCNCCCNC3CCCCC3)nn2)n1,1
+CCCCN(c1nc2ccccc2o1)C(C)c1ccc(-c2ccccc2-c2nnn[nH]2)cc1,1
+CCCCN(c1nc2ccccc2o1)C(C)c1ccc(-c2ccccc2-c2nnn[nH]2)cc1,1
+CCN(CC)CCCC(C)Nc1cc(C=Cc2ccc([N+](=O)[O-])cc2)nc2cc(OC)ccc12,1
+Oc1cccc(CN(CCN2CCCCC2)CC2CCCN(C3CCCC3)C2)c1,1
+CCC(C)N1C(=O)C2C(Cc3c[nH]c4ccccc34)[NH2+]C3(C(=O)Nc4ccc(C)cc43)C2C1=O,0
+COc1cccc(NC(=O)c2sc3[nH+]c(N4CCCC4)c4c(c3c2N)CC(C)(C)OC4)c1,0
+CC[NH+]1CCN(C(c2cccs2)C(C)NC(=O)C(=O)NCCc2c[nH]c3ccccc23)CC1,0
+CSC1=CC2CC3COP(=O)(c4ccccc4O)N[NH+]3CC2C=C1c1ccccc1O,0
+CC(C)S(=O)(=O)C1=CC2CC3COP(=O)(c4ccccc4O)N[NH+]3CC2C=C1c1ccccc1O,0
+COc1ccc2[nH]cc(CCNC(=O)C3CN(C(=O)c4ccccc4C)CC34CC[NH2+]CC4)c2c1,0
+COc1ccc2[nH]cc(CCNC(=O)C3CN(C(=O)c4cc(Cl)cc(Cl)c4)CC34CC[NH2+]CC4)c2c1,0
+COc1ccc2[nH]cc(CCNC(=O)C3CN(C(=O)c4cccc(Cl)c4F)CC34CC[NH2+]CC4)c2c1,0
+COc1ccc2[nH]cc(CCNC(=O)C3CN(C(=O)C4CC=CCC4)CC34CC[NH2+]CC4)c2c1,0
+CC(CCCC(C)(C)O)NC(=O)C1CN(C(=O)c2c(F)cccc2F)CC12CC[NH2+]CC2,0
+CC(CCCC(C)(C)O)NC(=O)C1CN(C(=O)c2cc(Cl)cc(Cl)c2)CC12CC[NH2+]CC2,0
+CC(CCCC(C)(C)O)NC(=O)C1CN(C(=O)c2ccc(Br)cc2)CC12CC[NH2+]CC2,0
+COc1c(Cl)cc(C(=O)N2CC(C(=O)NC(C)CCCC(C)(C)O)C3(CC[NH2+]CC3)C2)cc1Cl,0
+CCCCC(C)C(=O)N1CC(C(=O)NCCc2c[nH]c3ccc(Cl)cc23)C2(CC[NH2+]CC2)C1,0
+Cc1cccc2c(CCNC(=O)C3CN(C(=O)C(Oc4ccccc4)C(C)C)CC34CC[NH2+]CC4)c[nH]c12,0
+CCc1cccc2c1=[NH+]CC=2C(=O)CSC1NNC(c2ccc(F)cc2)[NH+]1CCC(=O)[O-],0
+Cc1n[nH]c(C)c1C(C)NC(=O)C1CN(C(=O)c2ccc(C(F)(F)F)cc2)CC12CC[NH2+]CC2,0
+Cc1n[nH]c(C)c1C(C)NC(=O)C1CN(C(=O)c2cc(Cl)ccc2F)CC12CC[NH2+]CC2,0
+Cc1cc(C)c2c(N)c(C(=O)OCC(=O)Nc3sc4c(c3C#N)CCCCC4)sc2[nH+]1,0
+CCC(Sc1nc2n[nH]c(C)c2c(N)[n+]1-c1ccc(C)c(Cl)c1)C(=O)NCc1ccco1,0
+Cc1ccc(C2CC(C(F)(F)F)N3NC=C(C(=O)Nc4cc5c(cc4C(C)O)OCO5)C3=[NH+]2)cc1,0
+CC(O)c1cc2c(cc1NC(=O)C1=CNN3C1=[NH+]C(c1ccco1)CC3C(F)(F)F)OCO2,0
+COc1cc(-c2cc(=[NH+]C(Cc3c[nH]c[nH+]3)C(=O)[O-])c3cc(Cl)c(C)cc3o2)ccc1O,0
+O=C(NCCC1=c2cc(Cl)ccc2=[NH+]C1)C1C=C2NC(=C3CC3)C=C(C(F)(F)F)N2N1,0
+O=C(NCCC1=c2cc(Cl)ccc2=[NH+]C1)C1C=C2NC(=C3CC3)C=C(C(F)(F)F)N2N1,0
+CCOCCC1NNC(NC(=O)C2CC(=O)N(CCC3=c4cc(F)ccc4=[NH+]C3)C2)S1,0
+[H]N=C(Nc1nc(C)cc(C)n1)N(CCC1=c2ccccc2=[NH+]C1)C(=S)Nc1ccc(F)cc1,0
+COc1ccc(NC(=O)CSC2NC(=CC(=O)NCCC3=c4ccccc4=[NH+]C3)CS2)cc1,0
+O=C(C=C1CSC(SCC(=O)Nc2ccc(Cl)cc2)N1)NCCC1=c2ccccc2=[NH+]C1,0
+CNS(=O)(=O)c1ccc(NC(=O)C(CC2=c3ccccc3=[NH+]C2)NC(=O)c2cccs2)cc1,0
+COC12CCC3(CC1C(C)(O)C(C)(C)C)C1C(O)c4ccc(O)c5c4C3(CC[NH+]1CC1CC1)C2O5,0
+[NH3+]C(CO)C(=O)NC(Cc1ccc(O)cc1)C(=O)[NH+]=c1ccc2c(C(F)(F)F)cc(O)oc-2c1,0
+CC1=CC(C(=O)N2CC(C(=O)NCCC3=c4cc(C#N)ccc4=[NH+]C3C)C3(CC[NH2+]CC3)C2)NN1C,0
+CC1=CC(C(=O)N2CC(C(=O)NCCC3=c4cc(C#N)ccc4=[NH+]C3C)C3(CC[NH2+]CC3)C2)NN1C,0
+Cc1n[nH]c2ncc(-c3cc(OCC([NH3+])CC4=c5ccccc5=[NH+]C4)cnc3-c3ccoc3)cc12,0
+Cc1n[nH]c2ccc(-c3cc(OCC([NH3+])CC4=c5ccccc5=[NH+]C4)cnc3-c3ccoc3)nc12,0
+Cc1n[nH]c2ccc(-c3cc(OCC([NH3+])CC4=c5cccnc5=[NH+]C4)cnc3-c3ccoc3)cc12,0
+Cc1occc1-c1nc(N)c(OCC([NH3+])CC2=c3ccccc3=[NH+]C2)cc1-c1cc2c(C)n[nH]c2cn1,0
+CC(C)(CC1=CN=CC1)C1C(=O)Nc2ccc(-c3cncc(OCC([NH3+])CC4=c5ccccc5=[NH+]C4)c3)cc21,0
+Cc1ccc2c(c1)=[NH+]C(SC(C(=O)Nc1ccc(S(N)(=O)=O)cc1)c1ccccc1)[NH+]=2,0
+Cc1ccc2c(c1)=[NH+]C(SC(C(=O)Nc1ccc(S(N)(=O)=O)cc1)c1ccccc1)[NH+]=2,0
+Cc1ccc2c(c1)=[NH+]C(CNC(=O)C1[NH+]=C(Cn3nc(-c4ccc(F)cc4)ccc3=O)NO1)[NH+]=2,0
+Cc1ccc2c(c1)=[NH+]C(CNC(=O)C1[NH+]=C(Cn3nc(-c4ccc(F)cc4)ccc3=O)NO1)[NH+]=2,0
+Cn1c(SCC(=O)NCCC2[NH+]=c3ccccc3=[NH+]2)nnc1C1[NH+]=C(c2ccc(F)cc2)NO1,0
+Cc1ccc(C2=[NH+]C(c3nnc(SCC(=O)NCCC4[NH+]=c5ccccc5=[NH+]4)n3C)ON2)cc1,0
+COc1cc(C2CC(=NNC3[NH+]=c4ccccc4=[NH+]3)c3ccc(C)cc3O2)ccc1O,0
+CCN1NC(C)=C(NC(=O)CSC2[NH+]=c3cc(C)cc(C)c3=[NH+]2)C1C,0
+COc1ccc2c(c1)=CC(C[NH2+]CC1CN(c3cccc(F)c3)NC1c1ccc(C)o1)[NH+]=2,0
+O=C1CCC(CC[NH2+]CCOc2ccc(F)cc2)N1CC1([NH+]2CCOCC2)CCCCC1,0
+COC(=O)C1[NH+]=c2ccc(Cl)cc2=C1NC(=O)C(C)[NH+]1CCN(c2cccc(OC)c2)C(C)C1,0
+COc1ccc(C2=CN=[NH+]C2c2ccc(OCC[NH+]3CCN(c4ccc(F)cc4)CC3)cc2O)cc1,0
+CCOC(=O)c1cccc(NC2[NH+]=c3ccccc3=[NH+]C2=NS(=O)(=O)c2ccc(F)cc2)c1,0
+O=C(Nc1ccc(N2CCC([NH2+]C(CCn3cc[nH+]c3)c3ccccc3)CC2)cc1)c1ccccc1F,0
+COc1ccc2c(c1)=C(CCNC(=O)C1C=C3[NH+]=C(c4ccco4)C=C(C(F)(F)F)N3N1)C[NH+]=2,0
+CCC(C)Nc1c[nH+]c2c(c1)C(NC(C)=O)C(C(=O)OC)N2CCC1=c2ccccc2=[NH+]C1,0
+COc1cccc(Cn2nc(C(=O)NC3CC3)c3c2CCN(CC2[NH+]=c4ccccc4=[NH+]2)C3)c1,0
+COC(=O)C1C(NC(C)=O)c2cc(NC(C)CC(C)C)c[nH+]c2N1CCC1=c2ccccc2=[NH+]C1,0
+COc1cc(CC2CC(C[NH2+]CCCC3=c4ccccc4=[NH+]C3C)=NO2)c(OC)c2c1OCO2,0
+CCc1ccccc1NC(=O)CSC1N=NC(C([NH3+])CC2=c3ccccc3=[NH+]C2)O1,0
+C#CCN(C)C(=O)CC1CC[NH2+]CC1Cc1cc(-c2ccc(F)cc2)on1,0
+CCCNC(=O)C1CCCN(Cc2coc(-c3ccc(C)cc3)[nH+]2)C1,0
+CCCCNC(=O)C1CCC(C)[NH+](Cc2c(C)nn(C)c2Cl)C1,0
+C[NH2+]C(C)C(=O)NC1C=C(C(=O)NC(Cc2ccc(OC)cc2)C(N)=O)CC(O)C1O,0
+COc1cccc2c1C(=O)c1c(O)c3c(c(O)c1C2=O)CC(O)(C(C)=O)CC3OC(=O)CC[NH3+],0
+COC(=O)C(Cc1c[nH]c2ccc(F)cc12)NC(=O)C([NH3+])Cc1c[nH]c2ccccc12,0
+Cc1ccc(Nc2nc(N)nc(C[NH2+]CC(O)c3ccc([N+](=O)[O-])cc3)n2)cc1,0
+C=C1c2cccc(O)c2C(=O)C2=C(O)C3(O)C(=O)C(C(N)=O)=C(O)C([NH+](C)C)C3C(O)C12,0
+CC(=O)C1(O)Cc2c(O)c3c(c(O)c2C(OC2CC([NH3+])C(O)C(C)O2)C1)C(=O)c1c(O)cccc1C3=O,0
+CN1Cc2c(N3CCOCC3)[nH+]c3sc(C(=O)NN)c(N)c3c2CC1(C)C,0
+CC(=O)C1([NH3+])Cc2c(O)c3c(c(O)c2C(OC2CC(O)C(O)CO2)C1)C(=O)c1ccccc1C3=O,0
+CCCC1CC(C(=O)NC(C(C)O)C2OC(SC)C(O)C(O)C2O)[NH+](C)C1,0
+Cc1cc(O)oc2cc(=[NH+]C(=O)C(CCCNC(N)=[NH2+])NC(=O)c3ccccc3)ccc1-2,0
+CCCC1CC(C(=O)NC(C(C)O)C2OC(SC)C(O)C(O)C2O)[NH+](C)C1,0
+CC(=O)C1([NH3+])Cc2c(O)c3c(c(O)c2C(OC2CC(O)C(O)CO2)C1)C(=O)c1ccccc1C3=O,0
+COc1ccc(-c2nc3n(c(=[NH2+])c2C#N)NC(=[NH2+])C3=NNc2ccc3c(c2)OCO3)cc1,0
+Cc1cc(C)c2c(N)c(C(=O)OCC(=O)Nc3sc4c(c3C(N)=O)CCC4)sc2[nH+]1,0
+O=C1[NH+]=c2ccccc2=[NH+]C1C(=NNc1ccc([N+](=O)[O-])cc1)C(O)C(O)CO,0
+CC1(O)c2c(Cl)ccc(O)c2C(=O)C2C1CC1C([NH3+])C(O)C(C(N)=O)C(=O)C1(O)C2O,0
+CC(O)C1([NH3+])Cc2c(O)c3c(c(O)c2C(OC2CC(O)C(O)CO2)C1)C(=O)c1ccccc1C3=O,0
+CCCC1CC(C(=O)NC(C(C)O)C2OC(SC)C(O)C(O)C2O)[NH+](C)C1,0
+CC(=O)C1([NH3+])Cc2c(O)c3c(c(O)c2C(OC2CC(O)C(O)CO2)C1)C(=O)c1ccccc1C3=O,0
+Cc1cc(O)oc2cc(=[NH+]C(=O)C(CCC[NH+]=C(N)N)NC(=O)C[NH3+])ccc1-2,0
+CC([NH3+])C(=O)NC(CCCNC(N)=[NH2+])C(=O)[NH+]=c1ccc2c(C(F)(F)F)cc(O)oc-2c1,0
+CC(NC(=O)C([NH3+])CCCC[NH3+])C(=O)[NH+]=c1ccc2c(C(F)(F)F)cc(O)oc-2c1,0
+[NH3+]C(COc1cncc(-c2ccc3[nH]nc(Cl)c3c2)c1)CC1=c2ccccc2=[NH+]C1,0
+CCN1NC(C)=C(NC(=O)CSC2[NH+]=c3cc(C)cc(C)c3=[NH+]2)C1C,0
+Cc1cccc(NC(=O)CSC2N=NC(C([NH3+])CC3=c4ccccc4=[NH+]C3)O2)c1C,0
+Cc1cccc(NC(=O)CSC2N=NC(C([NH3+])CC3=c4ccccc4=[NH+]C3)O2)c1C,0
+Cc1ccc2c(c1)=[NH+]C(CNC(=O)c1ccccc1C1NC(c3ccc(F)cc3)=NO1)[NH+]=2,0
+Cc1ccc2c(c1)=[NH+]C(CNC(=O)c1ccccc1C1NC(c3ccc(F)cc3)=NO1)[NH+]=2,0
+CC1[NH+]=c2ccc(C#N)cc2=C1CCNC(=O)CC1C(=O)NCC[NH+]1C(C)C,0
+Cc1ccn2cc(CNC(=O)C3CN(C(=O)C4CC=CCC4)CC34CC[NH2+]CC4)[nH+]c2c1,0
+Cc1ccc2[nH+]c(CNC(=O)C3CN(C(=O)C4CC=CCC4)CC34CC[NH2+]CC4)cn2c1,0
+Cc1ccc(C(=O)N2CC(C(=O)NCCC3=c4cc(C#N)ccc4=[NH+]C3C)C3(CC[NH2+]CC3)C2)cc1,0
+CC1[NH+]=c2ccc(C#N)cc2=C1CCNC(=O)C1CN(C(=O)C2CC=CCC2)CC12CC[NH2+]CC2,0
+Cc1cccc(C2=c3cc(S(N)(=O)=O)ccc3=[NH+]C2C(=O)N[n+]2c(C)cc(C)cc2C)c1,0
+COc1ccc(N2CC(=O)C(C3[NH+]=c4ccc(C)cc4=[NH+]3)=C2N)cc1Cl,0
+COCC(=O)N1CC2C[NH2+]CC2(C(=O)NC(C)(C)C[NH+]2CCCC2)C1,0
+COc1ccc2c(c1)=[NH+]C(C(C#N)=Cc1cc(C)n(C3SC4CCCCC4=C3C#N)c1C)[NH+]=2,0
+COc1ccc(C(=O)C2CC2C[NH+]2CC=C(C3=c4c(Br)cccc4=[NH+]C3)CC2)cc1,0
+Cc1ccc(OC2N=C3C=CC=CN3C(=O)C2C=C(C#N)C2[NH+]=c3ccccc3=[NH+]2)cc1,0
+N#CC(=CC1C(=O)N2C=CC=CC2=NC1Oc1ccc(Cl)cc1)C1[NH+]=c2ccccc2=[NH+]1,0
+Cc1cc(OC2N=C3C=CC=CN3C(=O)C2C=C(C#N)C2[NH+]=c3ccccc3=[NH+]2)ccc1Cl,0
+Cc1cc(C)cc(OC2N=C3C=CC=CN3C(=O)C2C=C(C#N)C2[NH+]=c3ccccc3=[NH+]2)c1,0
+COCCN1C(=O)c2ccccc2C(C(=O)N=C2[NH+]=c3ccccc3=[NH+]2)C12CCCCC2,0
+O=C(C1CCCC1)N(CC[NH+]1CCCCC1)CC1CCC[NH+](C2CCCC2)C1,0
+COc1ccc(-c2nn(-c3ccccc3)cc2C[NH+]2CCC3(CC[NH+](C)C3)C2)c(F)c1,0
+CC1=C(C#N)C(n2c(C)cc(C=C(C#N)C3[NH+]=c4ccccc4=[NH+]3)c2C)OC1C,0
+CC1=C(C#N)C(n2c(C)cc(C=C(C#N)C3[NH+]=c4ccccc4=[NH+]3)c2C)OC1C,0
+CC1C2CCC3C4CC=C5CC([NH+](C)C)CCC5(C)C4CCC32C[NH+]1C,0
+COc1c2c(cc3c1C(C#CC[NH+](C)C)[NH+](C)CC3)OCO2,0
+C[NH+](CC#N)C1CCC2C3CCC4CC(OC(=O)C[N+](C)(C)C)CCC4(C)C3CCC21C,0
+CC1C2CCC3C4CC=C5CC([NH+](C)C)CCC5(C)C4CCC32C[NH+]1C,0
+Fc1ccc(C=[NH+]C2=CC(c3ccc(Br)cc3)[NH+]=N2)cc1Oc1ccccc1,0
+CCCC[NH+]1CCCCC1CNC(=O)NC(C)Cn1cc[nH+]c1,0
+CCCC[NH+]1CCCCC1CNC(=O)NC(C)Cn1cc[nH+]c1,0
+C[NH+]1CCN(C2N=C3C=CC=CN3C(=O)C2C=C(C#N)C2[NH+]=c3ccccc3=[NH+]2)CC1,0
+C[NH+](CC1=CN=[NH+]C1c1ccc2c(c1)OCO2)CC1C=c2cc(F)ccc2=[NH+]1,0
+CC([NH2+]CC1C=c2ccccc2=[NH+]1)C1C=NN(c2cccc(F)c2)C1C,0
+O=C(C1CCCC1)N(CC[NH+]1CCCCC1)CC1CCC[NH+](C2CCCC2)C1,0
+CCCC[NH+](CC(=O)N1CCSC1c1ccc(F)cc1)Cc1ccccc1F,0
+Cc1cccc(C(=O)N2CC(C[NH+]3CCCC3)C(c3cccc(C(F)(F)F)c3)C2)c1,0
+N#Cc1cccc(C[NH+](Cc2cccn2Cc2cccc(C(F)(F)F)c2)C2CC2)c1,0
+O=C(c1ccco1)N1CC(C[NH+]2CCCC2)C(c2cccc(C(F)(F)F)c2)C1,0
+COc1ccc(C2c3cccn3CCC[NH+]2Cc2cccc(Cl)c2)cc1OC,0
+COc1cc(C[NH+]2CCCn3cccc3C2c2cc(C)ccc2C)cc(OC)c1,0
+CN(C(=O)CCC1=c2ccccc2=[NH+]C1c1ccc(F)cc1)c1cccc(C#N)c1,0
+COc1cccc(C(CNC(=O)CCc2[nH+]cc(-c3ccc(F)cc3)o2)[NH+](C)C)c1,0
+CCCCc1[nH]cc(C[NH2+]CCC2C(C)=Nc3ccc(OC)cc32)[nH+]1,0
+O=S(=O)(c1ccccc1)N1CC[NH+](CC[NH+]=c2cc(O)oc3ccccc23)CC1,0
+COC(=O)C1[NH+]=c2ccccc2=C1NC(=O)C(C)[NH+]1CCN(c2ccccc2)CC1,0
+COC(=O)C1[NH+]=c2ccc(Cl)cc2=C1NC(=O)C(C)[NH+]1CCN(c2ccccc2)CC1,0
+CCOC(=O)C1[NH+]=c2ccc(Br)cc2=C1NC(=O)CC[NH+]1CCCC(C)(C)C1,0
+CCOc1ccc2c(c1)=CC(C1N=C3C=CC=CN3C1[NH2+]Cc1ccco1)C(=O)[NH+]=2,0
+CCOc1ccc2c(c1)=CC(C1N=C3C=CC=CN3C1[NH2+]Cc1ccco1)C(=O)[NH+]=2,0
+CCOc1ccc2c(c1)=CC(c1[nH+]c3cc(C)ccn3c1NCCOC)C(=O)[NH+]=2,0
+COc1ccc(C2CC(C(=O)NCCC3=c4ccccc4=[NH+]C3)N=[NH+]2)c(OC)c1,0
+COc1ccc(C2CC(C(=O)NCCC3=c4ccccc4=[NH+]C3)N=[NH+]2)c(OC)c1,0
+CCCSc1ccc2c(c1)=[NH+]C(NC(=O)CSc1nc(C)cc(C)n1)[NH+]=2,0
+O=C(Cc1ccc(Cl)cc1)Nc1nnc(SCC2[NH+]=c3ccccc3=[NH+]C2=O)s1,0
+Cc1cc2c(cc1C)=[NH+]C(CSc1nnc(NC(=O)C(C)(C)C)s1)C(=O)[NH+]=2,0
+CCCC(=O)Nc1nnc(SCC2[NH+]=c3cc(C)c(C)cc3=[NH+]C2=O)s1,0
+CCn1nc(C(=O)N2CCOCC2)c2c1CCC([NH2+]CCC1=c3ccccc3=[NH+]C1)C2,0
+Cc1ccc2c(c1)=[NH+]C(SCc1noc(CCC(=O)Nc3c(F)cccc3F)n1)[NH+]=2,0
+Cc1ccc2c(c1)=[NH+]C(SCc1noc(CCC(=O)Nc3ccc(F)cc3F)n1)[NH+]=2,0
+COc1ccc(C(=O)CC2(O)C(=O)N(C[NH+]3CCCCCC3)c3ccccc32)cc1,0
+Cc1ccsc1C[NH+](C)CC(=O)Nc1c(C#N)c(C)c(C)n1CC1CCCO1,0
+COc1ccc(N2CC[NH+](CCNS(=O)(=O)c3ccc(Cl)s3)CC2)cc1,0
+CCOc1cc2c(cc1C[NH+]1CCC(NC(C)=O)(c3ccccc3F)CC1)OCO2,0
+Cc1ccc(Cn2cnc3sc4c(c3c2=O)CCC([NH2+]CCCn2ccnc2)C4)cc1,0
+CC(C)Cn1nc(C(=O)N2CCOCC2)c2c1CCC([NH2+]CCc1ccccc1F)C2,0
+CCOC(=O)N1CCC([NH2+]Cc2cc3ccc(F)cc3n(CC(C)C)c2=O)CC1,0
+Cc1ccc(NC(=O)COc2coc(C[NH+]3CCc4ccccc4C3)cc2=O)c(C)c1,0
+O=C(Cn1c(=O)oc2ccccc21)NCC(c1ccsc1)[NH+]1CCCCCC1,0
+Cc1ccc(N2CC(C(=O)NCC(c3cccn3C)[NH+]3CCCCCC3)CC2=O)cc1C,0
+COc1ccc(-n2c(C)cc(C=C(C#N)C(=O)NCC[NH+]3CCCCC3)c2C)cc1,0
+COc1ccc2c(c1)OC(=O)C(CCC(=O)NCCC1=c3cc(F)ccc3=[NH+]C1)C2C,0
+CCOc1ccccc1NC(=O)C1CC(=O)N(CCC2=c3cc(F)ccc3=[NH+]C2)C1,0
+CN(CC1C=c2cc(F)ccc2=[NH+]1)C(=O)C1C=C(COc2c(F)cccc2F)ON1,0
+O=C(C1CC1)N(CC[NH+]1CCCCC1)CC1CCC[NH+](C2CCCC2)C1,0
+Cc1cc(C=C(C#N)C2[NH+]=c3ccccc3=[NH+]2)c(C)n1C1SC2CCCCC2=C1C#N,0
+CC12CCC3C(CCC4(O)CC(O)CCC34C=[NH+]Cc3ccncc3)C1(O)CCC2C1=CC(=O)OC1,0
+CCOC(=O)c1ccc(N2C(=O)C3C(CC(N)=O)[NH2+]C4(C(=O)Nc5ccc(Cl)cc54)C3C2=O)cc1,0
+COc1ccc2c3c1OC1C4(OC)C=CC5(c6c(O)cc(SCCO)c(O)c64)C(C2)[NH+](C)CCC315,0
+COC(C[NH+]=CC12CCC(O)CC1(O)CCC1C2CCC2(C)C(C3=CC(=O)OC3)CCC12O)OC,0
+O=C(CSc1nnc(-c2ccc(F)cc2)n1CC[NH+]1CCOCC1)Nc1ccc2[nH]c(=O)[nH]c2c1,0
+O=C(CCC1CNC(=O)C2CC(NC(=O)c3ccc(F)c(Cl)c3)C[NH+]12)NCc1ccc(F)cc1,0
+CCOc1ccc(C=NNC(=O)c2ccc(N)cc2)cc1C[NH+]1CC2CC(C1)c1cccc(=O)n1C2,0
+Cc1nn(C(C)C)c(C)c1C=NNc1nc(SCC(=O)NC2CC(C)(C)[NH2+]C(C)(C)C2)n[nH]1,0
+CC(c1ccc(S(N)(=O)=O)cc1)[NH+](C)CC(=O)Nc1cc(C(F)(F)F)ccc1-n1cncn1,0
+COc1cccc(C=[NH+]CCNC(=O)c2cc3n(n2)C(C(F)(F)C(F)(F)F)CC(C)N3)c1O,0
+COc1ccc2[nH]cc(CCNC(=O)C3CN(C(=O)c4ccccc4OC(C)=O)CC34CC[NH2+]CC4)c2c1,0
+COc1ccc2[nH]cc(CCNC(=O)C3CN(C(=O)c4c(Cl)cccc4Cl)CC34CC[NH2+]CC4)c2c1,0
+COc1ccc2[nH]cc(CCNC(=O)C3CN(C(=O)C(C)Oc4ccccc4)CC34CC[NH2+]CC4)c2c1,0
+CC(CCCC(C)(C)O)NC(=O)C1CN(C(=O)c2ccccc2C(F)(F)F)CC12CC[NH2+]CC2,0
+Cc1cc(C(=O)N2CC(C(=O)NC(C)CCCC(C)(C)O)C3(CC[NH2+]CC3)C2)ccc1Br,0
+Cc1cc(-c2onc(C)c2C(=O)N2CC(C(=O)NC(C)CCCC(C)(C)O)C3(CC[NH2+]CC3)C2)no1,0
+Cc1nn(C)c2ncc(C(=O)N3CC(C(=O)NC(C)CCCC(C)(C)O)C4(CC[NH2+]CC4)C3)c(Cl)c12,0
+Cc1ccc2[nH]cc(CCNC(=O)C3CN(C(=O)c4ccc(N5CCOCC5)nc4)CC34CC[NH2+]CC4)c2c1,0
+CC1=C(C(=O)N2CC(C(=O)NCCc3c[nH]c4ccc(C)cc34)C3(CC[NH2+]CC3)C2)C(c2ccccc2)NO1,0
+CC1[NH+]=c2ccc(C#N)cc2=C1CCNC(=O)C1CN(C(=O)C2(C)CCCCC2)CC12CC[NH2+]CC2,0
+CC(=O)N1CCC(C(=O)N2CC(C(=O)NCCc3c[nH]c4ccc(Cl)cc34)C3(CC[NH2+]CC3)C2)CC1,0
+Cc1ccc(F)cc1C(=O)N1CC(C(=O)NCCc2c[nH]c3ccc(Cl)cc23)C2(CC[NH2+]CC2)C1,0
+CC1=CC(C(=O)N2CC(C(=O)NCCc3c[nH]c4ccc(Cl)cc34)C3(CC[NH2+]CC3)C2)NN1C,0
+CC(C)(C)OC(=O)NCCNC(=O)C1CN(C(=O)C2CCCN2C(=O)C(F)(F)F)CC12CC[NH2+]CC2,0
+CC(C)(C)OC(=O)NCCNC(=O)C1CN(C(=O)c2cc(Cl)ccc2F)CC12CC[NH2+]CC2,0
+Cc1n[nH]c(C)c1C(C)NC(=O)C1CN(C(=O)c2cc(F)cc(C(F)(F)F)c2)CC12CC[NH2+]CC2,0
+COc1ccc(C(=O)N2CC(C(=O)NC(C)c3c(C)n[nH]c3C)C3(CC[NH2+]CC3)C2)cc1C(F)(F)F,0
+Cc1ccc2nc(C(C)NC(=O)C3CN(C(=O)c4ccc(C)c(F)c4F)CC34CC[NH2+]CC4)[nH]c2c1,0
+COc1ccc(OC)c(C(=O)N2CC(C(=O)NC(C)c3nc4ccc(C)cc4[nH]3)C3(CC[NH2+]CC3)C2)c1,0
+Cc1ccc(N2C(=O)C3C(c4ccccc4O)[NH2+]C(CC4=c5ccccc5=[NH+]C4)(C(=O)[O-])C3C2=O)cc1C,0
+COc1ccc2c(c1)=C(CCN1CC(C(=O)NC3NNC(Cc4ccccc4)S3)CC1=O)C[NH+]=2,0
+CNS(=O)(=O)c1ccc(NC(=O)C(CC2=c3ccccc3=[NH+]C2)NC(=O)c2cccs2)cc1,0
+CCC(Sc1nc2n[nH]c(C)c2c(N)[n+]1-c1ccc(Br)cc1)C(=O)NCc1ccco1,0
+COc1ccc2c(c1)OC1(CC[NH+](CC(O)c3c[nH]c4cc(C)ccc34)CC1)CC2O,0
+Cc1ccc(F)cc1CC([NH3+])COc1cncc(-c2ccc3[nH]nc(C)c3c2)c1,0
+CCC(=O)Nc1ccc(C(C)[NH2+]C(C)C(=O)Nc2cccc(Cl)c2C)cc1,0
+CCC(=O)Nc1ccc(C(C)[NH2+]C(C)C(=O)Nc2cccc(Cl)c2C)cc1,0
+CCC(C)C(=O)N1CC(C(=O)NCCc2c[nH]c3ccc(C)cc23)C2(CC[NH2+]CC2)C1,0
+Cc1n[nH]c2cnc(-c3cncc(OCC([NH3+])Cc4ccc(F)c(F)c4F)c3)cc12,0
+O=C(NC1Nc2ccc(NC(=O)C3C=c4ccccc4=[NH+]3)cc2S1)c1ccccc1,0
+CC[NH+]1CCN(c2c(Cl)cccc2NC(=S)NC(=O)c2ccc(OC)c(Br)c2)CC1,0
+CC(C)c1ccc(NC(=O)C(=O)NCC(c2ccc3c(c2)CCN3C)N2CC[NH+](C)CC2)cc1,0
+FC(F)(F)c1ccc2c(NC3CCC([NH2+]Cc4cccnc4)CC3)ncc(-c3ccsc3)c2n1,0
+COc1ccc(C[NH+](C)Cc2nc3sc(C(=O)Nc4ccc(C)cc4C)c(C)c3c(=O)[nH]2)cc1F,0
+Cc1ccccc1-c1csc2nc(C[NH+](CC(O)COc3ccccc3)C(C)C)[nH]c(=O)c12,0
+CC(C)OCC(O)C[NH+](Cc1ccccc1)Cc1nc2sc3c(c2c(=O)[nH]1)CCCCC3,0
+CCOc1ccc(C2CC(c3ccc(C)cc3C)=NN2C(=O)C[NH+]2CCC(C(N)=O)CC2)cc1,0
+CC(=O)C1CCC2C3CCC4=CC(=NOCC(=O)NCCc5c[nH]c[nH+]5)CCC4(C)C3CCC12C,0
+CC[NH+]1CCN(c2c(Cl)cccc2NC(=S)NC(=O)c2cc(Br)ccc2OC)CC1,0
+Cc1ccc(C(=O)NC(=CC2CN(C)c3ccccc32)C(=O)NCCC2=c3ccccc3=[NH+]C2)cc1,0
+COc1ccc2cc(C(=O)N3CCC(CC(=O)NCCC4=c5cc(C)ccc5=[NH+]C4)CC3)[nH]c2c1,0
+COc1cccc(CNC2=[NH+]CCNC23CCN(S(=O)(=O)c2ccc(C(C)C)cc2)CC3)c1,0
+CCC([NH2+]CCc1c[nH]c2cc(F)ccc12)C(=O)Nc1cc(C)on1,0
+CCC([NH2+]CCc1c[nH]c2cc(F)ccc12)C(=O)Nc1cc(C)on1,0
+COc1cccc(NC(=O)N(Cc2ccsc2)Cc2ccco2)c1,0
+COc1ccc(CC(NC(=O)C2=CC(NC(=O)C([NH3+])C(C)C)C(O)C(O)C2)C(N)=O)cc1,0
+CCCC1CC(C(=O)NC(C(C)O)C2OC(SC)C(O)C(O)C2O)[NH+](C)C1,0
+OCC1OC(CO)(Oc2cc3c(O)cc(O)cc3[o+]c2-c2cc(O)c(O)c(O)c2)C(O)C1O,0
+COc1cccc2c1C(=O)c1c(O)c3c(c(O)c1C2=O)CC(O)(C(C)=O)CC3SCC[NH3+],0
+COC(=O)C(Cc1c[nH]c2ccc(F)cc12)NC(=O)C([NH3+])Cc1c[nH]c2ccccc12,0
+CC=C(C)C(=O)OC1CCC2(C)C3CCC4C5(O)CC(O)C6(O)C(C[NH+]7CC(C)CCC7C6(C)O)C5(O)CC42OC13O,0
+N#CC(=CNc1ccc(S(=O)(=O)NC(N)=[NH2+])cc1)c1nc(-c2cccc(Br)c2)cs1,0
+C[NH+](C)C1C(O)=C(C(N)=O)C(=O)C2(O)C(O)=C3C(=O)c4c(O)cccc4C(C)(O)C3C(O)C12,0
+C[NH+](C)C1C(O)=C(C(N)=O)C(=O)C2(O)C(O)=C3C(=O)c4c(O)cccc4C(C)(O)C3C(O)C12,0
+Cc1cc(NC(=O)NC(=O)c2ccccc2NC(=O)C(C)[NH3+])ccc1Oc1ncc(Br)cn1,0
+CCOc1cc(C=NNc2nc(SCC(=O)NC3CC(C)(C)[NH2+]C(C)(C)C3)n[nH]2)ccc1O,0
+CC(=O)C1([NH3+])Cc2c(O)c3c(c(O)c2C(OC2CC(O)C(O)CO2)C1)C(=O)c1ccccc1C3=O,0
+CC1(O)c2c(Cl)ccc(O)c2C(=O)C2C1CC1C([NH3+])C(O)C(C(N)=O)C(=O)C1(O)C2O,0
+CCCC1CC(C(=O)NC(C(C)O)C2OC(SC)C(O)C(O)C2O)[NH+](C)C1,0
+CCC1CC[NH2+]C(C(=O)NC(C(C)Cl)C2OC(SC)C(O)C(O)C2O)C1,0
+CC1(O)c2c(Cl)ccc(O)c2C(=O)C2C1CC1C([NH3+])C(O)C(C(N)=O)C(=O)C1(O)C2O,0
+CCCC1CC(C(=O)NC(C(C)O)C2OC(SC)C(O)C(O)C2O)[NH+](C)C1,0
+CCCC1CC(C(=O)NC(C(C)O)C2OC(SC)C(O)C(O)C2O)[NH+](C)C1,0
+O=C1[NH+]=c2ccccc2=[NH+]C1C(=NNc1ccc([N+](=O)[O-])cc1)C(O)C(O)CO,0
+CCCC1CC(C(=O)NC(C(C)O)C2OC(SC)C(O)C(O)C2O)[NH+](C)C1,0
+CCC1CC[NH2+]C(C(=O)NC(C(C)Cl)C2OC(SC)C(O)C(O)C2O)C1,0
+CC(C)(C)OC(=O)NC(CC1=c2ccccc2=[NH+]C1)C(=O)OCC1OC(O)C(O)C(O)C1O,0
+O=C(CSC1NC(c2ccco2)Nc2cc(=O)[nH]n21)NCC1[NH+]=c2ccccc2=[NH+]1,0
+O=C(CSC1NC(c2ccco2)Nc2cc(=O)[nH]n21)NCCC1[NH+]=c2ccccc2=[NH+]1,0
+CC(C)(C)OC(=O)NC(CC1=c2ccccc2=[NH+]C1)C(=O)OCC1OC(O)C(O)C(O)C1O,0
+Cc1ccccc1-[n+]1c(SCC(=O)NCCc2ccc(S(N)(=O)=O)cc2)nc2[nH]nc(C)c2c1N,0
+CCC(=O)Nc1cc(C(O)C[NH+]2CCc3[nH]c4c(C)cccc4c3C2)ccc1OC,0
+NC(=O)CN1CCCC([NH2+]Cc2ccc(-c3cccc(Cl)c3Cl)o2)C1,0
+CCOC(=O)c1c[nH+]c2c(C)cc(Cl)cc2c1NCCC[NH+]1CCOCC1,0
+COc1ccc(C[NH+]2CCN(Cc3[nH+]ccn3-c3cccc(C)c3)CC2CCO)c(F)c1,0
+C[NH+]1CCC[NH+](CC(=O)N2CC(c3ccc(Cl)cc3)C(c3csnn3)C2)CC1,0
+CCC(C)c1ccccc1NC(=O)C(C)SC1=[NH+]c2ccccc2C(=O)[N+]1=c1cc(C)cc[nH]1,0
+C=C1CCCC2(C)CC3OC(=O)C(C[NH2+]CCC4=c5cc(O)ccc5=[NH+]C4)C3CC12,0
+CCOC(=O)C1[NH+]=c2ccc(Br)cc2=C1NC(=O)CC[NH+]1CCC(C)CC1,0
+Cc1ccc2c(c1C)=[NH+]C(=O)C(CCNC(=O)C(=O)C1=c3ccccc3=[NH+]C1C)C=2,0
+CC1CCCC[NH+]1CCCNC(=O)C1CN(C(=O)C2CCC2)CC12CC[NH2+]CC2,0
+CCC(CC)C(=O)N1CC(C(=O)NCCC[NH+]2CCCCC2C)C2(CC[NH2+]CC2)C1,0
+CSCCC(=O)N1CC(C(=O)NCCC[NH+]2CCCCC2C)C2(CC[NH2+]CC2)C1,0
+C[NH+](C)C(CNC(=O)CCc1[nH+]cc(-c2ccc(F)cc2)o1)c1ccsc1,0
+N#Cc1cccc2c1=[NH+]CC=2C1=CC[NH+](CCC2OCCc3cc(C(N)=O)ccc32)CC1,0
+Cc1ccc2cc(CNCCC[NH+]3CC4C=CC3C4)c(N3CCC(O)CC3)[nH+]c2c1,0
+O=C(NCC1CCC[NH+](Cc2cccc3c2OCO3)C1)C1C=c2ccccc2=[NH+]1,0
+CNc1cc(C(=O)N2CCC3(CCC[NH+](Cc4cc(OC)ccc4F)C3)C2)cc[nH+]1,0
+Cc1ccc2c(c1C)=[NH+]C(=O)C(CCNC(=O)C(=O)C1=c3ccccc3=[NH+]C1C)C=2,0
+CCC[NH+]1CCC(N2CC([NH2+]Cc3ccc(F)cc3F)CC2C(=O)NCC)CC1,0
+C[NH+](C)CCCn1c(=O)[nH]c2sc3c(c2c1=[NH2+])CC(C)(C)OC3,0
+COc1ccc2c(c1)=CC(CNC(=O)C(C)n1cc[nH+]c1C(C)C)[NH+]=2,0
+Cc1ccc(Cn2nc(C)c(C[NH2+]CC(C)Cn3cc[nH+]c3)c2C)cc1,0
+CC1CC(C)C[NH+](CCCNC(=O)C2C=C3C(=O)[NH+]=c4ccccc4=C3N2C)C1,0
+CCc1ccccc1N1C(=O)CC([NH2+]CCC2=c3cc(OC)ccc3=[NH+]C2)C1=O,0
+O=C(NCC1CCC[NH+](Cc2cccc3c2OCO3)C1)C1C=c2ccccc2=[NH+]1,0
+CC1(C2CC[NH+](CC3C=c4ccccc4=[NH+]3)CC2)NC(=O)N(Cc2ccsc2)C1=O,0
+O=C(C[NH+]1CCCC1C(=O)Nc1ccccc1)C1=c2ccccc2=[NH+]C1,0
+Cn1cnnc1CC1CC[NH+](CC2C=c3ccc(F)cc3=[NH+]C2=O)CC1,0
+CC[NH+]1CCN(C(=O)c2ccc(N3CCC([NH+]4CCc5sccc5C4)CC3)cc2)CC1,0
+CC1CCCC[NH+]1CCC[n+]1c(-c2ccccc2)csc1Nc1cc(F)ccc1F,0
+OC1C[NH+](CC=Cc2ccco2)CCC1N1CCN(c2cccc[nH+]2)CC1,0
+Cc1ccc2c(c1)=C1SC(C(=O)NCCC[NH+]3CCC(C)CC3)C=C1C(=O)[NH+]=2,0
+Cc1ccc2c(c1)=C1SC(C(=O)NCCC[NH+]3C(C)CCCC3C)C=C1C(=O)[NH+]=2,0
+O=C(CC1=c2ccccc2=[NH+]C1)N1CCCC(C2[NH+]=C(c3ccc(Cl)cc3)NO2)C1,0
+O=C1CC([NH2+]CCC2=c3ccccc3=[NH+]C2)C(=O)N1c1cccc(C(F)(F)F)c1,0
+Cc1[nH+]ccn1CC1CC[NH+](Cc2c(-c3ccc(F)cc3)nc3sccn23)CC1,0
+Cc1cccc(C(=O)N2CC[NH+](CC[NH+]=c3cc(O)oc4ccccc34)CC2)c1,0
+COCCNc1c(C2C=c3cc(C)ccc3=[NH+]C2=O)[nH+]c2cc(C)ccn12,0
+Cc1cc(=O)oc2c3c(c(Cl)cc12)OC[NH+](CCCn1cc[nH+]c1)C3,0
+Cc1ccc(Cn2nc(C)c(C[NH2+]CC(C)Cn3cc[nH+]c3)c2Cl)cc1,0
+COc1ccc(F)c(C[NH+]2CCCC3(CCN(C(=O)C4C=c5ccccc5=[NH+]4)C3)C2)c1,0
+CCC1C(C(=O)N2CCC3=c4ccccc4=[NH+]C3C2)C(=O)C=C(C)N1CC1CCC[NH+]1CC,0
+CC(=O)Oc1c(C)cc(C[NH2+]CC2C=c3ccc(F)cc3=[NH+]C2=O)cc1C,0
+Cc1ccccc1-n1nc(C)c(C[NH+](C)Cc2cn3ccccc3[nH+]2)c1C,0
+O=c1c(-c2ccccc2C[NH+]2CCOCC2)ccc2n1CC1CC2C[NH+](CC2CCCCC2)C1,0
+Cc1ccc(OCCN(C)C(=O)C2CC23CC[NH+](CC2C=c4ccccc4=[NH+]C2=O)CC3)cc1,0
+CCc1cccc2c1=[NH+]CC=2C(=O)CSC1N=NC(C(C)[NH+](C)C)N1c1ccc(F)cc1,0
+CC1=CN2C(=NC(C3C=c4cc(C)cc(C)c4=[NH+]C3=O)C2[NH2+]Cc2ccco2)C=C1,0
+COc1ccc2c(c1)=[NH+]C(=O)C(C1N=C3C=CC(C)=CN3C1[NH2+]Cc1ccccc1)C=2,0
+Cc1c(Cc2ccccc2)c(=O)oc2c3c(c(Cl)cc12)OC[NH+](CCCn1cc[nH+]c1)C3,0
+CCOc1cc(C[NH2+]CC2C=c3ccc(F)cc3=[NH+]C2=O)cc(Cl)c1OCC,0
+O=C(CC[NH+]1Cc2ccccc2OC(c2ccccc2)C1)NCCC1=c2ccccc2=[NH+]C1,0
+Cc1[nH+]ccn1CCC(=O)N1CCC2=c3ccccc3=[NH+]C2C1C1CCCCC1,0
+CCOC(=O)C1[NH+]=c2ccc(OC)cc2=C1NC(=O)C(C)[NH+]1CCC(C(N)=O)CC1,0
+CCOC(=O)C1[NH+]=c2ccc(OC)cc2=C1NC(=O)C(C)[NH+]1CCC(C(N)=O)CC1,0
+Cc1cccc2c1=[NH+]C(CN(C)C(=O)CN1N[NH2+]NC1C[NH+](C)C(C)C)[NH+]=2,0
+O=c1c(-c2ccccc2C[NH+]2CCOCC2)ccc2n1CC1CC2C[NH+](C2CCOCC2)C1,0
+COc1cc(C[NH+]2CCC3(CCC[NH+](CC4CCC4)C3)C2)cc2c1OCO2,0
+Cc1ccc2c(c1)C[NH+](CC(=O)N1CCC([NH+]3CCOCC3)CC1)CC(c1ccsc1)O2,0
+C[NH+]1CCC2(CCN(C(=O)c3ccc(OC4CC[NH+](CCc5ccccc5)CC4)cc3)C2)C1,0
+CCOC(=O)C1[NH+]=c2ccc(F)cc2=C1NC(=O)C(C)[NH+]1CCCCC1,0
+O=C(CCC1=c2ccccc2=[NH+]C1)NCc1ccc(N2CCOCC2)[nH+]c1,0
+Cc1ccc2c(c1)=C1SC(C(=O)NCCC[NH+](C)Cc3ccccc3)C=C1C(=O)[NH+]=2,0
+COc1ccc2c(c1)=C(CC[NH2+]C1CC(=O)N(c3cccc4ccccc34)C1=O)C[NH+]=2,0
+O=C(NCC1CCC[NH+](C2CSCCSC2)C1)C1C=c2ccccc2=[NH+]1,0
+Cc1ccc2occ(C[NH+]3CCCC(c4ccnc(SCC[NH+]5CCCC5)n4)C3)c(=O)c2c1,0
+COc1ccc(-c2nn(-c3ccccc3C)cc2C[NH2+]CCC2CCC[NH+]2C)cc1F,0
+CCC[NH+]1CCC(N2CCC3(CCC[NH+](Cc4cccc(F)c4F)C3)C2)CC1,0
+O=C(c1ccc(Cl)cc1)N1CC[NH+](CC[NH+]=c2cc(O)oc3ccccc23)CC1,0
+O=c1cc(C[NH+]2CCN(c3ccc(O)cc3)CC2)[nH+]c2scc(-c3ccccc3)n12,0
+O=C(CSC1N[NH+]=C(N2CCCCC2)N1c1ccccc1)C1=c2ccccc2=[NH+]C1,0
+CC([NH2+]CC(C1=c2ccccc2=[NH+]C1)C1CC=CS1)C(=O)N1CCc2ccccc21,0
+O=C(CC1=c2ccccc2=[NH+]C1)NCC[NH+]1Cc2ccccc2OC(c2ccccc2)C1,0
+Cc1[nH+]ccn1CCC(=O)N1CCC2=c3ccccc3=[NH+]C2C1C1CCCCC1,0
+O=C1C2C3=C(CC([NH2+]CCC4=c5ccccc5=[NH+]C4)CC3)SC2N=CN1Cc1cccc(F)c1,0
+COc1ccc2c(c1)=[NH+]C(CN1CCN(C(=O)C3(c4cccs4)CCCC3)CC1)[NH+]=2,0
+CCC1CCCCN1C(=O)C(C)[NH2+]CC(C1=c2ccccc2=[NH+]C1)C1CC=CS1,0
+COc1ccc(-c2nn(-c3ccccc3)cc2C[NH+]2CCN(c3cc[nH+]cc3)CC2)c(F)c1,0
+O=C(NCCCN1CCC([NH+]2CCCCC2)CC1)C1CCCN(c2[nH+]ccc3sccc23)C1,0
+Nc1c2c(-c3ccccc3)c(-c3ccccc3)n(Cc3ccccc3)c2nc[n+]1CCCn1cc[nH+]c1,0
+Cc1ccc2c(c1)=C1SC(C(=O)NCCC[NH+]3CC(C)CC(C)C3)C=C1C(=O)[NH+]=2,0
+CC1(C2CC[NH+](CC3C=c4ccccc4=[NH+]3)CC2)NC(=O)N(Cc2ccsc2)C1=O,0
+O=C(Nc1cccc(C2C=c3ccccc3=[NH+]2)c1)C1CCC[NH+](Cc2ccc(CO)o2)C1,0
+Cc1c(C[NH+]2CCCC(C(=O)Nc3cccc(C4C=c5ccccc5=[NH+]4)c3)C2)cnn1C,0
+COc1ccc(C[NH+]2Cc3cc(C)ccc3OC(c3ccsc3)C2)c(OC)c1OC,0
+COc1ccccc1-c1nn(C[NH+](Cc2c(F)cccc2Cl)C2CC2)c(=S)n1C,0
+CC(C)c1ccccc1-n1c(-c2cccnc2)nn(C[NH+]2CCc3sccc3C2)c1=S,0
+CC1(C)CC(C[NH+]2CCC(Oc3cc(Cl)ccc3C(=O)N3CCCCC3)CC2)CCO1,0
+COc1ccc(C[NH+]2CCCn3cccc3C2c2cccc(Cl)c2)c(OC)c1OC,0
+CC(c1cccs1)[NH+](C)C1CCC(=O)N(Cc2cc3c(cc2Cl)OCO3)CC1,0
+COc1cc2c(cc1OC)C(c1cccs1)N(Cc1[nH+]cc(C)c(OC)c1C)CC2,0
+CCOC(=O)C1CCCN(C(=O)CC2=c3ccccc3=[NH+]C2Sc2ccccc2)C1,0
+C[NH+](C)CCN1C(=O)c2oc3ccc(Cl)cc3c(=O)c2C1c1cccs1,0
+N#Cc1cccc(C[NH+]2CC3CC(C2)c2c(-c4ccco4)ccc(=O)n2C3)c1,0
+C[NH+](C)CCN1C(=O)c2oc3ccc(Cl)cc3c(=O)c2C1c1cccc(F)c1,0
+O=C(C=Cc1ccco1)N1CCCC([NH+]2CCN(c3ccccc3F)CC2)C1,0
+COc1cc(-c2nc(C[NH+]3CCCCC3c3nccs3)c(C)o2)ccc1F,0
+COC(=O)C(c1ccc(Cl)cc1)[NH+]1CCN(C(=O)c2sccc2C)CC1,0
+Cn1c[nH+]cc1CN1CCC2=NN=C(C3(c4ccc(Cl)cc4)CCCC3)C2C1,0
+CCOc1ccc(C2C3N=C4C=CC=CC4C3CC[NH+]2CC2C=CN=N2)cc1,0
+Cn1cc(C[NH+]2CC3(C)CC2CC(C)(C)C3)c(-c2ccc3c(c2)OCCO3)n1,0
+C=C1CCCC2(C)CC3OC(=O)C(C[NH+]4CCC(C(=O)OCC)CC4)C3CC12,0
+Cn1c(-c2ccco2)nn(C[NH+]2CCCC2Cc2cccc(F)c2)c1=S,0
+Cc1ccc(C)c(OC2CC[NH+](C(C)c3nnc(-c4cccs4)o3)CC2)c1,0
+Cc1c(CCC(C)C)c(NCCC[NH+]2CCOCC2)[n+]2c([nH]c3ccccc32)c1C#N,0
+COc1cc(C(=O)NCCC2CCC[NH+]2C)ccc1OC1CC[NH+](C2CCCC2)CC1,0
+CCOC(=O)C1[NH+]=c2ccc(Br)cc2=C1NC(=O)CC[NH+](C)C,0
+CC[NH+](CC)CCCNC(=O)C1C=C2C(=O)[NH+]=c3ccccc3=C2N1C,0
+CN1C2=c3ccccc3=[NH+]C(=O)C2=CC1C(=O)NCCC[NH+]1CCCC1,0
+O=C1CC(C(F)F)=NC(c2ccccc2C[NH+]2CCC(Cn3cc[nH+]c3)CC2)=N1,0
+C[NH+](C)CCN1CC(C(=O)NCC2C=c3cc(F)ccc3=[NH+]2)CCC1=O,0
+O=C(C[NH+]1CCCC1C(=O)Nc1ccccc1)C1=c2ccccc2=[NH+]C1,0
+Cn1cnnc1CC1CC[NH+](CC2C=c3ccc(F)cc3=[NH+]C2=O)CC1,0

data/data/QSAR/DRD2/drd2_train.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:47c9146a2736905da6cb08178d330ac7167f53989459b28ad5581fc1f7cb040b
+size 12970112

data/data/USPTO/src_train.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3984cf01980610f69e07336dfcc32de8268e075c678c5b46a1fda6c01b66349d
+size 28402794

data/data/USPTO/tgt_train.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1ebb47dc821e1f27079c97b8aab778ab2de874badee069a248cd7f45be809f14
+size 30955321

data/data/beamsearch_template_list.txt

@@ -0,0 +1,575 @@
+9
+10
+11
+15
+16
+17
+18
+26
+31
+33
+34
+35
+36
+37
+38
+39
+42
+43
+44
+45
+49
+50
+51
+52
+54
+55
+57
+60
+61
+62
+63
+64
+67
+68
+70
+73
+74
+75
+76
+77
+78
+79
+83
+85
+94
+95
+99
+101
+102
+104
+105
+107
+108
+110
+111
+113
+115
+119
+120
+123
+124
+125
+126
+127
+129
+130
+131
+132
+133
+134
+135
+137
+138
+144
+145
+146
+147
+148
+149
+153
+154
+156
+159
+160
+161
+162
+165
+166
+167
+169
+170
+174
+176
+184
+185
+187
+194
+196
+197
+198
+201
+206
+208
+209
+210
+211
+213
+214
+216
+219
+220
+221
+227
+230
+232
+233
+235
+236
+238
+240
+241
+244
+248
+250
+252
+256
+257
+258
+261
+267
+270
+271
+272
+273
+275
+276
+277
+279
+280
+284
+285
+289
+294
+295
+296
+297
+298
+299
+302
+304
+305
+308
+309
+310
+314
+315
+321
+323
+326
+327
+329
+330
+331
+332
+333
+334
+336
+338
+340
+342
+346
+347
+349
+351
+352
+353
+354
+355
+359
+364
+365
+367
+368
+371
+375
+379
+380
+382
+385
+389
+392
+393
+398
+399
+405
+406
+407
+411
+413
+414
+416
+422
+425
+426
+427
+429
+433
+434
+435
+437
+438
+439
+440
+441
+442
+443
+446
+450
+454
+455
+458
+459
+460
+461
+462
+463
+464
+467
+468
+469
+470
+473
+474
+478
+479
+482
+483
+484
+485
+487
+488
+493
+494
+495
+496
+498
+499
+501
+502
+503
+505
+508
+509
+510
+511
+512
+513
+514
+515
+516
+517
+519
+521
+523
+524
+525
+526
+527
+528
+530
+534
+536
+539
+540
+541
+542
+544
+547
+548
+549
+550
+551
+553
+554
+556
+557
+558
+559
+563
+564
+565
+566
+567
+572
+577
+578
+579
+580
+583
+584
+585
+586
+587
+589
+592
+593
+596
+597
+598
+599
+600
+601
+603
+604
+605
+606
+607
+608
+609
+611
+612
+613
+614
+616
+621
+623
+627
+629
+633
+635
+636
+637
+640
+644
+645
+646
+647
+648
+649
+651
+652
+653
+656
+657
+658
+659
+662
+663
+664
+666
+667
+668
+669
+673
+674
+675
+676
+678
+679
+681
+683
+685
+688
+690
+691
+692
+693
+696
+697
+699
+700
+701
+702
+709
+710
+712
+714
+715
+716
+718
+719
+721
+722
+723
+724
+725
+727
+728
+729
+733
+734
+736
+737
+738
+739
+741
+744
+747
+749
+751
+753
+756
+757
+759
+760
+763
+764
+765
+766
+767
+769
+770
+773
+774
+775
+776
+777
+778
+780
+785
+787
+788
+790
+791
+792
+794
+795
+797
+798
+799
+801
+802
+804
+808
+809
+810
+811
+814
+816
+817
+818
+819
+821
+822
+823
+824
+828
+829
+833
+835
+836
+837
+842
+844
+845
+846
+851
+853
+855
+857
+858
+859
+860
+861
+862
+863
+864
+865
+866
+868
+869
+870
+871
+872
+873
+874
+875
+876
+878
+879
+880
+882
+883
+884
+886
+888
+889
+890
+891
+892
+893
+894
+895
+899
+900
+901
+902
+903
+904
+905
+906
+907
+908
+909
+910
+911
+912
+913
+914
+916
+917
+918
+919
+920
+921
+922
+924
+925
+926
+927
+928
+929
+931
+932
+933
+936
+937
+938
+939
+941
+944
+946
+947
+948
+950
+951
+952
+953
+954
+955
+957
+958
+960
+961
+962
+963
+965
+967
+968
+969
+970
+971
+972
+973
+974
+975
+976
+977
+980
+982
+984
+985
+986
+987
+989
+990
+991
+992
+993
+994
+995
+996
+997
+998
+999

data/data/input/init_smiles_akt1.txt

@@ -0,0 +1,5 @@
+CC1CCCN1C1CCNC1
+N#Cc1ncc(C(F)(F)F)cc1N
+N#Cc1cnc2c(c1)CCC2=O
+Nc1ccc(Oc2cccnc2)cc1
+N#Cc1ccc(-c2cnco2)cc1

data/data/input/init_smiles_cxcr4.txt

@@ -0,0 +1,5 @@
+NCC(O)c1ccccc1
+Cc1cn(C)c(CSCCN)n1
+NCc1ccc2ccccc2c1
+NNc1cccc2ncccc12
+NCCc1ccccn1

data/data/input/init_smiles_drd2.txt

@@ -0,0 +1,5 @@
+OC1CCc2cc(F)ccc21
+c1ccc2c(c1)CC1CNCCN21
+NC1CCN(CCc2ccccc2)C1
+Oc1ccc2c(c1)CNCC2
+N#Cc1cccc(N2CCNCC2)c1

data/data/input/test.txt

@@ -0,0 +1 @@
+C c 1 c c c 2 [nH] c3 c ( c 2 c 1 ) C N ( C ) C C 3

data/data/input/unseen_ZINC_AKT1.txt

@@ -0,0 +1 @@
+Brc1ccccn1

data/data/input/unseen_ZINC_CXCR4.txt

@@ -0,0 +1 @@
+O=C1N=C(O)C(Br)N1

data/data/input/unseen_ZINC_DRD2.txt

@@ -0,0 +1 @@
+Brc1ccccn1

data/env.yml

@@ -0,0 +1,24 @@
+name: tracer
+channels:
+  - pyg
+  - pytorch
+  - nvidia
+  - conda-forge
+  - defaults
+dependencies:
+  - mkl==2024.0
+  - numpy=1.23.5
+  - pandas=1.5.3
+  - pip=23.0.1
+  - pyg=2.3.0=py310_torch_2.0.0_cu118
+  - python=3.10.10
+  - pytorch=2.0.1=py3.10_cuda11.8_cudnn8.7.0_0
+  - pytorch-cuda=11.8
+  - rdkit=2022.03.2
+  - torchtext=0.15.2
+  - tqdm=4.65.0
+  - pip:
+      - hydra-core==1.3.2
+      - json5==0.9.14
+      - omegaconf==2.3.0
+      - scikit-learn==1.2.2

data/scripts/beam_search.py

@@ -0,0 +1,300 @@
+import os
+import operator
+import itertools
+import re
+import json
+import hydra
+from tqdm.auto import tqdm
+from config.config import cs
+from omegaconf import DictConfig
+
+import rdkit.Chem as Chem
+from rdkit.Chem import AllChem
+
+import torch
+import torchtext.vocab.vocab as Vocab
+import torch.nn.functional as F
+
+from Model.Transformer.model import Transformer
+from scripts.preprocess import make_counter ,make_transforms
+from Utils.utils import smi_tokenizer
+from Model.GCN import network
+from Model.GCN.utils import template_prediction, check_templates
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+with open('./data/label_template.json') as f:
+    r_dict = json.load(f)
+
+class BeamSearchNode(object):
+    def __init__(self, previousNode, decoder_input, logProb, length):
+        self.prevNode = previousNode
+        self.dec_in = decoder_input
+        self.logp = logProb
+        self.leng = length
+
+    def eval(self, alpha=0.6):
+        return self.logp / (((5 + self.leng) / (5 + 1)) ** alpha)
+    
+def check_templates(indices, input_smi):
+    matched_indices = []
+    input_smi = input_smi.replace(' ','')
+    molecule = Chem.MolFromSmiles(input_smi)
+    for i in indices:
+        idx = str(i.item())
+        rsmi = r_dict[idx]
+        rxn = AllChem.ReactionFromSmarts(rsmi)
+        reactants = rxn.GetReactants()
+        flag = False
+        for reactant in reactants:
+            if molecule.HasSubstructMatch(reactant):
+                flag = True
+        if flag == True:
+            matched_indices.append(f'[{i.item()}]')
+    return matched_indices # ['[0]', '[123]', ... '[742]']
+
+def beam_decode(v:Vocab, model=None, input_tokens=None, template_idx=None,
+                device=None, inf_max_len=None, beam_width=10, nbest=5, Temp=None,
+                beam_templates:list=None):
+    
+    SOS_token = v['<bos>']
+    EOS_token = v['<eos>']
+    if template_idx is not None:
+        template_idx = re.sub(r'\D', '', template_idx)
+        if template_idx not in beam_templates:
+            beam_width = 5
+            nbest = 1
+    
+    # A batch of one input for Encoder
+    encoder_input = input_tokens
+
+    # Generate encoded features
+    with torch.no_grad():
+        encoder_input = encoder_input.unsqueeze(-1) # (seq, 1), batch_size=1
+        encoder_output, memory_pad_mask = model.encode(encoder_input, src_pad_mask=True) # encoder_output.shape: (seq, 1, d_model)
+
+    # Start with the start of the sentence token
+    decoder_input = torch.tensor([[SOS_token]]) # (1,1)
+
+    # Starting node
+    counter = itertools.count()
+    
+    node = BeamSearchNode(previousNode=None,
+                          decoder_input=decoder_input,
+                          logProb=0, length=0)
+    
+    with torch.no_grad():
+        tgt_mask = torch.nn.Transformer.generate_square_subsequent_mask(decoder_input.size(1)).to(device)
+        logits = model.decode(memory=encoder_output, tgt=decoder_input.permute(1, 0).to(device), tgt_mask=tgt_mask, memory_pad_mask=memory_pad_mask)
+        logits = logits.permute(1, 0, 2) # logits: (seq, 1, vocab) -> (1, seq, vocab), batch=1
+        decoder_output = torch.log_softmax(logits[:, -1, :]/Temp, dim=1).to('cpu') # (1, vocab)
+    
+    tmp_beam_width = min(beam_width, decoder_output.size(1))
+    log_prob, indices = torch.topk(decoder_output, tmp_beam_width) # (tmp_beam_with,)
+    nextnodes = []
+    for new_k in range(tmp_beam_width):
+        decoded_t = indices[0][new_k].view(1, -1)
+        log_p = log_prob[0][new_k].item()
+        next_decoder_input = torch.cat([node.dec_in, decoded_t],dim=1) # dec_in:(1, seq)
+        nn = BeamSearchNode(previousNode=node,
+                                decoder_input=next_decoder_input,
+                                logProb=node.logp + log_p,
+                                length=node.leng + 1)
+        score = -nn.eval()
+        count = next(counter)
+        nextnodes.append((score, count, nn))
+    
+    # start beam search
+    for i in range(inf_max_len - 1):
+        # fetch the best node
+        if i == 0:
+            current_nodes = sorted(nextnodes)[:tmp_beam_width]
+        else:
+            current_nodes = sorted(nextnodes)[:beam_width]
+            
+        nextnodes=[]
+        # current_nodes = [(score, count, node), (score, count, node)...], shape:(beam_width,)
+        scores, counts, nodes, decoder_inputs = [], [], [], []
+        
+        for score, count, node in current_nodes:
+            if node.dec_in[0][-1].item() == EOS_token:
+                nextnodes.append((score, count, node))
+            else:
+                scores.append(score)
+                counts.append(count)
+                nodes.append(node)
+                decoder_inputs.append(node.dec_in)
+        if not bool(decoder_inputs):
+            break
+        
+        decoder_inputs = torch.vstack(decoder_inputs) # (batch=beam, seq)
+
+        # adjust batch_size
+        enc_out = encoder_output.repeat(1, decoder_inputs.size(0), 1)
+        mask = memory_pad_mask.repeat(decoder_inputs.size(0), 1)
+        
+        with torch.no_grad():
+            tgt_mask = torch.nn.Transformer.generate_square_subsequent_mask(decoder_inputs.size(1)).to(device)
+            logits = model.decode(memory=enc_out, tgt=decoder_inputs.permute(1, 0).to(device), tgt_mask=tgt_mask, memory_pad_mask=mask)
+            logits = logits.permute(1, 0, 2) # logits: (seq, batch, vocab) -> (batch, seq, vocab)
+            decoder_output = torch.log_softmax(logits[:, -1, :]/Temp, dim=1).to('cpu') # extract log_softmax of last token
+            # decoder_output.shape = (batch, vocab)
+        
+        for beam, score in enumerate(scores):
+            for token in range(EOS_token, decoder_output.size(-1)): # remove unk, pad, bosは最初から捨てる
+                decoded_t = torch.tensor([[token]])
+                log_p = decoder_output[beam, token].item()
+                next_decoder_input = torch.cat([nodes[beam].dec_in, decoded_t],dim=1)
+                node = BeamSearchNode(previousNode=nodes[beam],
+                                    decoder_input=next_decoder_input,
+                                    logProb=nodes[beam].logp + log_p,
+                                    length=nodes[beam].leng + 1)
+                score = -node.eval()
+                count = next(counter)
+                nextnodes.append((score, count, node))
+            
+    outputs = []
+    for score, _, n in sorted(nextnodes, key=operator.itemgetter(0))[:nbest]:
+        # endnodes = [(score, node), (score, node)...] 
+        output = n.dec_in.squeeze(0).tolist()[1:-1] # remove bos and eos
+        output = v.lookup_tokens(output)
+        output = ''.join(output)
+        outputs.append(output)
+    return outputs
+
+def greedy_translate(v:Vocab, model=None, input_tokens=None, device=None, inf_max_len=None):
+    '''
+    in:
+    input_tokens: (seq, batch)
+    
+    out:
+    outputs: list of SMILES(str).
+    '''
+    
+    SOS_token = v['<bos>']
+    EOS_token = v['<eos>']
+
+    # A batch of one input for Encoder
+    encoder_input = input_tokens.permute(1, 0) # (batch,seq) -> (seq, batch)
+
+    # Generate encoded features
+    with torch.no_grad():
+        enc_out, memory_pad_mask = model.encode(encoder_input, src_pad_mask=True) # encoder_output.shape: (seq, 1, d_model)
+
+        # Start with the SOS token
+        dec_inp = torch.tensor([[SOS_token]]).expand(1, encoder_input.size(1)).to(device) # (1, batch)
+        EOS_dic = {i:False for i in range(encoder_input.size(1))}
+
+        for i in range(inf_max_len - 1):
+            tgt_mask = torch.nn.Transformer.generate_square_subsequent_mask(dec_inp.size(0)).to(device)
+            logits = model.decode(memory=enc_out, tgt=dec_inp, tgt_mask=tgt_mask, memory_pad_mask=memory_pad_mask)
+            dec_out = F.softmax(logits[-1, :, :], dim=1) # extract softmax of last token, (batch, vocab)
+            next_items = dec_out.topk(1)[1].permute(1, 0) # (seq, batch) -> (batch, seq)
+            EOS_indices = (next_items == EOS_token)
+            # update EOS_dic
+            for j, EOS in enumerate(EOS_indices[0]):
+                if EOS:
+                    EOS_dic[j] = True
+            
+            dec_inp = torch.cat([dec_inp, next_items], dim=0)
+            if sum(list(EOS_dic.values())) == encoder_input.size(1):
+                break
+        out = dec_inp.permute(1, 0).to('cpu') # (seq, batch) -> (batch, seq)
+        outputs = []
+        for i in range(out.size(0)):
+            out_tokens = v.lookup_tokens(out[i].tolist())
+            try:
+                eos_idx = out_tokens.index('<eos>')
+                out_tokens = out_tokens[1:eos_idx]
+                outputs.append(''.join(out_tokens))
+            except ValueError:
+                continue
+        
+    return outputs
+
+def translate(cfg:DictConfig):
+    print('Loading...')
+    # make transforms and vocabulary
+    src_train_path = hydra.utils.get_original_cwd()+cfg['translate']['src_train']
+    tgt_train_path = hydra.utils.get_original_cwd()+cfg['translate']['tgt_train']
+    src_valid_path = hydra.utils.get_original_cwd()+cfg['translate']['src_valid']
+    tgt_valid_path = hydra.utils.get_original_cwd()+cfg['translate']['tgt_valid']
+    data_dict = make_counter(src_train_path=src_train_path,
+                             tgt_train_path=tgt_train_path,
+                             src_valid_path=src_valid_path,
+                             tgt_valid_path=tgt_valid_path
+                             )
+    src_transforms, _, v = make_transforms(data_dict=data_dict, make_vocab=True, vocab_load_path=None)
+    
+    # load model
+    d_model = cfg['model']['dim_model']
+    num_encoder_layers = cfg['model']['num_encoder_layers']
+    num_decoder_layers = cfg['model']['num_decoder_layers']
+    nhead = cfg['model']['nhead']
+    dropout = cfg['model']['dropout']
+    dim_ff = cfg['model']['dim_ff'] 
+    model = Transformer(d_model=d_model, nhead=nhead, num_encoder_layers=num_encoder_layers, num_decoder_layers=num_decoder_layers,
+                        dim_feedforward=dim_ff,vocab=v, dropout=dropout, device=device).to(device)
+    ckpt = torch.load(hydra.utils.get_original_cwd() + cfg['model']['ckpt'], map_location=device)
+    model.load_state_dict(ckpt['model_state_dict'])
+    model.eval()
+    
+    # make dataset
+    src = []
+    src_test_path = hydra.utils.get_original_cwd() + cfg['translate']['src_test_path']
+    with open(src_test_path,'r') as f:
+        for line in f:
+            src.append(line.rstrip())
+    
+    dim_GCN = cfg['GCN_train']['dim']
+    n_conv_hidden = cfg['GCN_train']['n_conv_hidden']
+    n_mlp_hidden = cfg['GCN_train']['n_mlp_hidden']
+    GCN_model = network.MolecularGCN(dim = dim_GCN,
+                                 n_conv_hidden = n_conv_hidden,
+                                 n_mlp_hidden = n_mlp_hidden,
+                                 dropout = dropout).to(device)
+    GCN_ckpt = hydra.utils.get_original_cwd() + cfg['translate']['GCN_ckpt']
+    GCN_model.load_state_dict(torch.load(GCN_ckpt))
+    GCN_model.eval()
+    
+    out_dir = cfg['translate']['out_dir']
+    beam_width = cfg['translate']['beam_size']
+    nbest = cfg['translate']['nbest']
+    inf_max_len = cfg['translate']['inf_max_len']
+    GCN_num_sampling = cfg['translate']['GCN_num_sampling']
+    with open(hydra.utils.get_original_cwd() + cfg['translate']['annotated_templates'], 'r') as f:
+        beam_templates = f.read().splitlines()
+        f.close()
+    print(f'The number of sampling for GCN: {GCN_num_sampling}')
+    print('Start translation...')
+    rsmis =[]
+    for input_smi in tqdm(src):
+        input_smi = input_smi.replace(' ', '')
+        indices = template_prediction(GCN_model=GCN_model, input_smi=input_smi,
+                                      num_sampling=GCN_num_sampling, GCN_device=device)
+        matched_indices = check_templates(indices, input_smi)
+        print(f"{len(matched_indices)} reaction templates are matched for '{input_smi}'.")
+        with torch.no_grad():
+            for i in matched_indices:
+                input_conditional = smi_tokenizer(i + input_smi).split(' ')
+                input_tokens = src_transforms(input_conditional).to(device)
+                outputs = beam_decode(v=v, model=model, input_tokens=input_tokens, template_idx=i,
+                                    device=device, inf_max_len=inf_max_len, beam_width=beam_width, nbest=nbest,
+                                    Temp=1, beam_templates=beam_templates)
+                for output in outputs:
+                    output = smi_tokenizer(output)
+                    rsmis.append(i + ' ' + smi_tokenizer(input_smi) + ' >> ' + output)
+
+# set output file name
+    os.makedirs(hydra.utils.get_original_cwd() + out_dir, exist_ok=True)
+    with open(hydra.utils.get_original_cwd() + f'{out_dir}/out_beam{beam_width}_best{nbest}2.txt','w') as f:
+        for rsmi in rsmis:
+            f.write(rsmi + '\n')
+        f.close()
+
+@hydra.main(config_path=None, config_name='config', version_base=None)
+def main(cfg: DictConfig):
+    translate(cfg)
+
+if __name__ == '__main__':
+    main()

data/scripts/gcn_train.py

@@ -0,0 +1,161 @@
+import os
+import torch
+from torch_geometric.data import DataLoader
+import torch.nn.functional as F
+
+from Model.GCN import mol2graph
+from Model.GCN.callbacks import EarlyStopping
+from Model.GCN.network import MolecularGCN
+from Model.GCN.utils import get_data
+
+import hydra
+import datetime
+from config.config import cs
+from omegaconf import DictConfig, OmegaConf
+from tqdm.auto import tqdm
+
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+date = datetime.datetime.now().strftime('%Y%m%d')
+
+def train(model, optimizer, loader):
+    model.train()
+    loss_all = 0
+    for data in loader:
+        optimizer.zero_grad()
+        data = data.to(device)
+        output = model.forward(data.x, data.edge_index, data.batch).squeeze(1)
+        loss =  F.cross_entropy(output, data.y)
+        loss.backward()
+        loss_all += loss.item() * data.num_graphs
+        optimizer.step()
+        
+    return loss_all / len(loader)
+
+
+def eval(model, loader, ks=None):
+    model.eval()
+    score_list = []
+    with torch.no_grad():
+        loss_all = 0
+        for data in loader:
+            data = data.to(device)
+            output = model.forward(data.x, data.edge_index, data.batch) # output.shape = (batch_size, vocab_size)
+            loss = F.cross_entropy(output, data.y)
+            loss_all += loss.item() * data.num_graphs
+            if ks is not None:
+                for k in ks:
+                    score_list.append(topk_accuracy(data, output, k))
+    return  loss_all/len(loader), score_list
+
+def topk_accuracy(data, output, k: int):
+    _, pred = output.topk(k, 1, True, True) # (k, dim=1, largest=True, sorted=True)
+    pred = pred.t() # (batch, maxk) -> (maxk, batch)
+    correct = pred.eq(data.y.unsqueeze(0).expand_as(pred)) # target:(batch,) -> (1, batch) -> (maxk, batch)
+    # Tensor.eq: compute element-wise equality, correct: bool matrix
+    score = correct.float().sum() / len(data)
+    score = score.detach().item()
+    return score
+
+
+@hydra.main(config_path=None, config_name='config', version_base=None)
+def main(cfg: DictConfig):
+    print('Loading data...')
+    train_path = cfg['GCN_train']['train']
+    valid_path = cfg['GCN_train']['valid']
+    test_path = cfg['GCN_train']['test']
+    batch_size = cfg['GCN_train']['batch_size']
+    dim = cfg['GCN_train']['dim']
+    n_conv_hidden = cfg['GCN_train']['n_conv_hidden']
+    n_mlp_hidden = cfg['GCN_train']['n_mlp_hidden']
+    dropout = cfg['GCN_train']['dropout']
+    lr = cfg['GCN_train']['lr']
+    epochs = cfg['GCN_train']['epochs']
+    patience = cfg['GCN_train']['patience']
+    save_path = cfg['GCN_train']['save_path']
+    ks = [1, 3, 5, 10]
+    
+    mols_train, y_train = get_data(hydra.utils.get_original_cwd() + train_path)
+    mols_valid, y_valid = get_data(hydra.utils.get_original_cwd() + valid_path)
+    
+    print('-'*100)
+    print('Training: ', mols_train.shape)
+    print('Validation: ', mols_valid.shape)
+    print('-'*100)
+
+    labels = y_train.tolist() + y_valid.tolist()
+    
+    # Mol to Graph
+    print('Converting mol to graph...')
+    X_train = [mol2graph.mol2vec(m) for m in tqdm(mols_train.tolist())]
+    for i, data in enumerate(X_train):
+        data.y = torch.LongTensor([y_train[i]]).to(device)
+    X_valid = [mol2graph.mol2vec(m) for m in tqdm(mols_valid.tolist())]
+    for i, data in enumerate(X_valid):
+        data.y = torch.LongTensor([y_valid[i]]).to(device)
+    train_loader = DataLoader(X_train, batch_size=batch_size, shuffle=True, drop_last=True)
+    valid_loader = DataLoader(X_valid, batch_size=batch_size, shuffle=True, drop_last=True)
+    print('completed.')
+    print('-'*100)
+    
+    num = 1
+    while True:
+        ckpt_dir = hydra.utils.get_original_cwd()+f'{save_path}/checkpoints_{date}_{num}'
+        try:
+            if any(os.scandir(ckpt_dir)):
+                num +=1
+                continue
+            else:
+                break
+        except:
+            os.makedirs(ckpt_dir, exist_ok=True)
+        break
+    train_path = cfg['GCN_train']['train']
+    valid_path = cfg['GCN_train']['valid']
+    test_path = cfg['GCN_train']['test']
+    batch_size = cfg['GCN_train']['batch_size']
+    dim = cfg['GCN_train']['dim']
+    n_conv_hidden = cfg['GCN_train']['n_conv_hidden']
+    n_mlp_hidden = cfg['GCN_train']['n_mlp_hidden']
+    dropout = cfg['GCN_train']['dropout']
+    lr = cfg['GCN_train']['lr']
+    epochs = cfg['GCN_train']['epochs']
+    patience = cfg['GCN_train']['patience']
+
+    # Model instance construction
+    print('Model instance construction')
+    model = MolecularGCN(
+        dim = dim,
+        n_conv_hidden = n_conv_hidden,
+        n_mlp_hidden = n_mlp_hidden,
+        dropout = dropout
+        ).to(device)
+    print(model)
+    print('-'*100)
+
+    # Training
+    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+    earlystopping = EarlyStopping(patience=patience, path=ckpt_dir + '/ckpt.pth', verbose=True)
+    for epoch in range(1, epochs+1):
+        # training
+        train_loss = train(model, optimizer, train_loader)
+
+        # performance evaluation
+        loss_train, _ = eval(model, train_loader)
+        loss_valid, score_list = eval(model, valid_loader, ks=ks)
+        top1acc = score_list[0]
+        top3acc = score_list[1]
+        top5acc = score_list[2]
+        top10acc = score_list[3]
+        
+        print(f'Epoch: {epoch}/{epochs}, loss_train: {loss_train:.5}, loss_valid: {loss_valid:.5}')
+        print(f'top k accuracy: top1={top1acc:.2}, top3={top3acc:.2}, top5={top5acc:.2}, top10={top10acc:.2}')
+        # early stopping detection
+        earlystopping(loss_valid, model)
+        if earlystopping.early_stop:
+            print('Early Stopping!')
+            print('-'*100)
+            break
+
+if __name__ == '__main__':
+    main()

data/scripts/mcts.py

@@ -0,0 +1,395 @@
+import os
+import numpy as np
+import pandas as pd
+import json
+import pickle
+import datetime
+
+import hydra
+from config.config import cs
+from omegaconf import DictConfig
+
+import torch
+import torch.nn.functional as F
+
+import time
+
+import warnings
+warnings.filterwarnings('ignore')
+
+import rdkit.Chem as Chem
+from rdkit import RDLogger
+from rdkit.Chem import Descriptors
+RDLogger.DisableLog('rdApp.*')
+
+from Model.Transformer.model import Transformer
+from scripts.preprocess import make_counter ,make_transforms
+from Model.GCN import network
+from Model.GCN.utils import template_prediction, check_templates
+from scripts.beam_search import beam_decode, greedy_translate
+
+from Utils.utils import read_smilesset, RootNode, NormalNode, smi_tokenizer, MW_checker, is_empty
+from Utils.reward import getReward
+
+class MCTS():
+    def __init__(self, init_smiles, model, GCN_model, vocab, Reward, max_depth=10, c=1, step=0, n_valid=0,
+                 n_invalid=0, max_r=-1000, r_dict=None, src_transforms=None, beam_width=10, nbest=5,
+                 inf_max_len=256, beam_templates:list=None, rollout_depth=None, device=None, GCN_device=None,
+                 exp_num_sampling=None, roll_num_sampling=None):        
+        self.init_smiles = init_smiles
+        self.model = model
+        self.GCN_model = GCN_model
+        self.vocab = vocab
+        self.Reward = Reward
+        self.max_depth = max_depth
+        self.valid_smiles = {}
+        self.terminate_smiles = {}
+        self.c = c
+        self.count = 0
+        self.max_score = max_r
+        self.step = step
+        self.n_valid = n_valid
+        self.n_invalid = n_invalid
+        self.total_nodes = 0
+        self.expand_max = 0
+        self.r_dict = r_dict
+        self.transforms = src_transforms
+        self.beam_width = beam_width
+        self.nbest = nbest
+        self.inf_max_len = inf_max_len
+        self.beam_templates = beam_templates
+        self.rollout_depth = rollout_depth
+        self.device = device
+        self.GCN_device = GCN_device
+        self.gen_templates = []
+        self.num_sampling = exp_num_sampling
+        self.roll_num_sampling = roll_num_sampling
+        self.no_template = False
+        self.smi_to_template = {}
+        self.accum_time = 0
+
+    def select(self):
+        raise NotImplementedError()
+
+    def expand(self):
+        raise NotImplementedError()
+
+    def simulate(self):
+        raise NotImplementedError()
+
+    def backprop(self):
+        raise NotImplementedError()
+
+    def search(self, n_step):
+        raise NotImplementedError()
+
+class ParseSelectMCTS(MCTS):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.root = RootNode()
+        self.current_node = None
+        self.next_smiles = {}
+        self.rollout_result = {}
+        scores, _, _ = self.Reward.reward([self.init_smiles])
+        _, self.init_score = scores[0]
+
+    def select(self):
+        '''
+        search for the node with no child nodes and maximum UCB score
+        '''
+        self.current_node = self.root
+        while len(self.current_node.children) != 0:
+            self.current_node = self.current_node.select_children()
+            if self.current_node.depth+1 > self.max_depth:
+                tmp = self.current_node
+                # update
+                while self.current_node is not None:
+                    self.current_node.cum_score += -1
+                    self.current_node.visit += 1
+                    self.current_node = self.current_node.parent
+                tmp.remove_Node()
+                self.current_node = self.root
+
+    def expand(self):
+        '''
+        self.no_template: If the output of template_prediction for selected node is empty, self.no_template = True
+        self.next_smiles: key=smiles, value=reward score
+        
+        '''
+        
+        self.next_smiles = {}
+        self.smi_to_template = {}
+        self.expand_max = 0
+        
+        ''' prediction of reaction templates '''
+        matched_indices = []
+        input_smi = self.current_node.smi
+        self.no_template = False
+        indices = template_prediction(GCN_model=self.GCN_model, input_smi=input_smi,
+                                      num_sampling=self.num_sampling, GCN_device=self.GCN_device)
+        matched_indices = check_templates(indices, input_smi, self.r_dict)
+        if len(matched_indices) != 0:
+            self.gen_templates.extend(matched_indices)
+            ''' prediction of products '''
+            with torch.no_grad():
+                for i in matched_indices:
+                    input_conditional = smi_tokenizer(i + input_smi).split(' ')
+                    input_tokens = self.transforms(input_conditional).to(self.device)
+                    outputs = beam_decode(v=self.vocab, model=self.model, input_tokens=input_tokens, template_idx=i,
+                                    device=self.device, inf_max_len=self.inf_max_len, beam_width=self.beam_width,
+                                    nbest=self.nbest, Temp=1, beam_templates=self.beam_templates)
+                    for output in outputs:
+                        self.next_smiles[output] = 0
+                        self.smi_to_template[output] = i
+            self.check()
+        else:
+            self.no_template = True
+            while (len(self.current_node.children) == 0) or (min([cn.visit for cn in self.current_node.children]) >= 10000):
+                self.current_node.cum_score = -10000
+                self.current_node.visit = 10000
+                self.current_node = self.current_node.parent
+            
+    def check(self):
+        valid_list = []
+        invalid_list = []
+        score_que = []
+        score = None
+        reaction_path = []
+        tmp = self.current_node
+        
+        if len(self.next_smiles) == 0:
+            self.current_node.cum_score = -100000
+            self.current_node.visit = 100000
+            self.current_node.remove_Node()
+            print('0 molecules are expanded.')
+        
+        else:
+            # make reaction path
+            while self.current_node.depth > 0:
+                reaction_path.insert(0, f'{self.current_node.template}.{self.current_node.smi}')
+                self.current_node = self.current_node.parent
+            self.current_node = tmp
+            
+            # scoring
+            for smi in self.next_smiles.keys():
+                mol = Chem.MolFromSmiles(smi)
+                if mol is None:
+                    self.n_invalid += 1
+                    invalid_list.append(smi)
+                elif (mol is not None) and (MW_checker(mol, 600) == True):
+                    score_que.append(smi)
+                    self.n_valid += 1
+                else:
+                    invalid_list.append(smi)
+
+            scores, _, _ = self.Reward.reward(score_que)
+            if len(scores) != 0:
+                valid_scores = []
+                for smi, score in scores:
+                    template = self.smi_to_template[smi]
+                    path = reaction_path.copy()
+                    path.append(f'{template}.{smi}')
+                    path = '.'.join(path)
+                    if score is not None:
+                        self.valid_smiles[self.step, smi, path] = score
+                        valid_list.append((score, smi))
+                        valid_scores.append(score)
+                        self.max_score = max(self.max_score, score)
+                        self.expand_max = max(self.expand_max, score)                        
+                for smi in invalid_list:
+                    self.next_smiles.pop(smi)
+                print(f'{len(self.next_smiles)} molecules are expanded.')
+            else:
+                self.no_template = True
+                while (len(self.current_node.children) == 0) or (min([cn.visit for cn in self.current_node.children]) >= 100000):
+                    self.current_node.cum_score = -100000
+                    self.current_node.visit = 100000
+                    self.current_node = self.current_node.parent
+
+    def simulate(self):
+        '''rollout'''
+        self.rollout_result = {}  # key:next_tokennext_smi, value:(smi, avg_score)
+        for orig_smi in self.next_smiles:
+            depth = 0
+            smi_que = [orig_smi]
+            max_smi = None
+            max_score = -10000
+            while depth < self.rollout_depth:
+                input_conditional = []
+                for next_smi in smi_que:
+                    if Chem.MolFromSmiles(next_smi) is not None:
+                        indices = template_prediction(self.GCN_model, next_smi, num_sampling=self.roll_num_sampling, GCN_device=self.GCN_device)
+                        matched_indices = check_templates(indices, next_smi, self.r_dict)
+                        for t in matched_indices:
+                            input_conditional.append(smi_tokenizer(t + next_smi).split(' '))
+                if is_empty(input_conditional) == False:
+                    with torch.no_grad():
+                        input_tokens = self.transforms(input_conditional).to(self.device)
+                        output = greedy_translate(v=self.vocab, model=self.model, input_tokens=input_tokens,
+                                                  inf_max_len=self.inf_max_len, device=self.device) # output: list of SMILES
+                    scores, max_smi_tmp, max_score_tmp = self.Reward.reward_remove_nan(output)
+                    if max_score_tmp is None:
+                        max_score_tmp = -10000
+                    elif max_score < max_score_tmp:
+                        max_score = max_score_tmp
+                        max_smi = max_smi_tmp
+                else:
+                    break
+                depth += 1
+                smi_que = output
+            if max_score > 0:
+                self.next_smiles[orig_smi] = max_score
+                self.rollout_result[orig_smi] = (max_smi, max_score)
+            else:
+                self.next_smiles[orig_smi] = 0
+            
+    def backprop(self):
+        for key, value in self.next_smiles.items():
+            child = NormalNode(smi=key, c=self.c)
+            child.template = self.smi_to_template[key]
+            child.cum_score += value
+            child.imm_score = value
+            child.id = self.total_nodes
+            self.total_nodes += 1
+            try:
+                child.rollout_result = self.rollout_result[key]
+            except KeyError:
+                child.rollout_result = ('Termination', -10000)
+            self.current_node.add_Node(child)
+        max_reward = max(self.next_smiles.values())
+        self.max_score = max(self.max_score, max_reward)
+        while self.current_node is not None:
+            self.current_node.visit += 1
+            self.current_node.cum_score += max_reward
+            self.current_node.imm_score = max(self.current_node.imm_score, max_reward)
+            self.current_node = self.current_node.parent
+
+    def search(self, n_step):
+        n = NormalNode(self.init_smiles)
+        self.root.add_Node(n)
+        while self.step < n_step:
+            self.step += 1
+            if self.n_valid+self.n_invalid == 0:
+                valid_rate = 0
+            else:
+                valid_rate = self.n_valid/(self.n_valid+self.n_invalid)
+            print(f'step:{self.step}, INIT_SCORE:{self.init_score}, MAX_SCORE:{self.max_score}, VALIDITY:{valid_rate}')
+            self.select()
+            print(f'selected_score:{self.current_node.imm_score}')
+            self.expand()
+            expand_max = self.expand_max if self.expand_max != 0 else None            
+            if self.no_template == True:
+                print('no template')
+                continue
+            if len(self.next_smiles) != 0:
+                self.simulate()
+                self.backprop()
+
+@hydra.main(config_path=None, config_name='config', version_base=None)
+def main(cfg: DictConfig):
+    date = datetime.datetime.now().strftime('%Y%m%d')
+    num = 1
+    while True:
+        out_dir = hydra.utils.get_original_cwd()+f"{cfg['mcts']['out_dir']}/{date}_{num}"
+        if os.path.isdir(out_dir):
+            num += 1
+            continue
+        else:
+            os.makedirs(out_dir, exist_ok=True)
+            break
+    print(f'{out_dir} was created.')
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    
+    ''' preprocess '''
+    src_train_path = hydra.utils.get_original_cwd()+cfg['mcts']['src_train']
+    tgt_train_path = hydra.utils.get_original_cwd()+cfg['mcts']['tgt_train']
+    src_valid_path = hydra.utils.get_original_cwd()+cfg['mcts']['src_valid']
+    tgt_valid_path = hydra.utils.get_original_cwd()+cfg['mcts']['tgt_valid']
+    data_dict = make_counter(src_train_path=src_train_path,
+                             tgt_train_path=tgt_train_path,
+                             src_valid_path=src_valid_path,
+                             tgt_valid_path=tgt_valid_path
+                             )
+    src_transforms, _, v = make_transforms(data_dict=data_dict, make_vocab=True)
+
+    '''input smiles set'''
+    init_smiles = read_smilesset(hydra.utils.get_original_cwd() + cfg['mcts']['in_smiles_file'])
+    n_valid = 0
+    n_invalid = 0
+    mcts = None
+
+    ''' load model '''
+    d_model = cfg['model']['dim_model']
+    num_encoder_layers = cfg['model']['num_encoder_layers']
+    num_decoder_layers = cfg['model']['num_decoder_layers']
+    nhead = cfg['model']['nhead']
+    dropout = cfg['model']['dropout']
+    dim_ff = cfg['model']['dim_ff']
+    ckpt = cfg['mcts']['ckpt_Transformer']
+    model = Transformer(d_model=d_model, nhead=nhead, num_encoder_layers=num_encoder_layers, num_decoder_layers=num_decoder_layers,
+                        dim_feedforward=dim_ff,vocab=v, dropout=dropout, device=device).to(device)
+    ckpt = torch.load(hydra.utils.get_original_cwd() + cfg['model']['ckpt'])
+    model.load_state_dict(ckpt['model_state_dict'])
+    model.eval()
+    
+    ''' load GCN model'''
+    dim_GCN = cfg['GCN_train']['dim']
+    n_conv_hidden = cfg['GCN_train']['n_conv_hidden']
+    n_mlp_hidden = cfg['GCN_train']['n_mlp_hidden']
+    ckpt_GCN = cfg['mcts']['ckpt_GCN']
+    GCN_model = network.MolecularGCN(dim = dim_GCN,
+                                n_conv_hidden = n_conv_hidden,
+                                n_mlp_hidden = n_mlp_hidden,
+                                dropout = dropout).to(device)
+    GCN_model.load_state_dict(torch.load(hydra.utils.get_original_cwd() + ckpt_GCN))
+    GCN_model.eval()
+    
+    '''MCTS'''
+    reward = getReward(name=cfg['mcts']['reward_name'])
+    print('REWARD:',cfg['mcts']['reward_name'])
+    with open(hydra.utils.get_original_cwd() + '/data/label_template.json') as f:
+        r_dict = json.load(f)
+        f.close()
+    with open(hydra.utils.get_original_cwd()+'/data/beamsearch_template_list.txt', 'r') as f:
+        beam_templates = f.read().splitlines()
+        f.close()
+    for start_smiles in init_smiles:
+        input_smiles = start_smiles
+        start = time.time()
+        mcts = ParseSelectMCTS(input_smiles, model=model, GCN_model=GCN_model, vocab=v, Reward=reward, 
+                                max_depth=cfg['mcts']['max_depth'], step=0, n_valid=n_valid, n_invalid=n_invalid,
+                                c=cfg['mcts']['ucb_c'], max_r=reward.max_r, r_dict=r_dict, src_transforms=src_transforms,
+                                beam_width=cfg['mcts']['beam_width'], nbest=cfg['mcts']['nbest'],
+                                beam_templates=beam_templates, rollout_depth=cfg['mcts']['rollout_depth'],
+                                roll_num_sampling=cfg['mcts']['roll_num_sampling'], device=device,
+                                GCN_device=device, exp_num_sampling=cfg['mcts']['exp_num_sampling'])
+        mcts.search(n_step=cfg['mcts']['n_step'])
+        reward.max_r = mcts.max_score
+        n_valid += mcts.n_valid
+        n_invalid += mcts.n_invalid
+        end = time.time()
+        print('Elapsed Time: %f' % (end-start))
+
+        generated_smiles = pd.DataFrame(columns=['SMILES', 'Reward', 'Imp', 'MW', 'step', 'reaction_path'])
+        scores, _, _ = reward.reward([start_smiles])
+        start_reward = scores[0][1]
+        for kv in mcts.valid_smiles.items():
+            step, smi, path = kv[0]
+            step = int(step)
+            try:
+                w = Descriptors.MolWt(Chem.MolFromSmiles(smi))
+            except:
+                w = 0           
+            if (kv[1] is None) or (start_reward is None):
+                Imp = None
+            else:
+                Imp = kv[1] - start_reward
+            row = {'SMILES': smi, 'Reward': kv[1], 'Imp': Imp, 
+                        'MW': w, 'step': step, 'reaction_path': path}
+            generated_smiles = generated_smiles.append(row, ignore_index=True)
+        generated_smiles = generated_smiles.sort_values('Reward', ascending=False)
+        generated_smiles.to_csv(out_dir + f'/{start_smiles}.csv', index=False)
+
+if __name__ == '__main__':
+    main()
+    

data/scripts/preprocess.py

@@ -0,0 +1,148 @@
+import warnings
+import hydra
+import os
+from config.config import cs
+from omegaconf import DictConfig
+warnings.filterwarnings('ignore')
+from collections import Counter
+
+import torch
+from torch.utils.data import Dataset
+from torch.utils.data import DataLoader
+from torchtext.vocab import vocab
+import torchtext.transforms as T
+
+class smi_Dataset(Dataset):
+    def __init__(self, src, tgt):
+        super().__init__()
+        self.src = src
+        self.tgt = tgt
+        
+    def __getitem__(self, i):
+        src = self.src[i]
+        tgt = self.tgt[i]
+        return src, tgt
+    
+    def __len__(self):
+        return len(self.src)
+
+def make_smi_list(path, counter):
+    smi_list = []
+    max_length = 0
+    with open(path,'r') as f:
+        for line in f:
+            smi_list.append(line.rstrip().split(' '))
+        for i in smi_list:
+            counter.update(i)
+            if len(i) > max_length:
+                max_length = len(i)
+    return smi_list, max_length
+    
+
+def make_counter(src_train_path, tgt_train_path, src_valid_path, tgt_valid_path) -> dict:
+    src_counter = Counter()
+    tgt_counter = Counter()
+    src_train, max_src_train = make_smi_list(src_train_path, src_counter)
+    tgt_train, max_tgt_train = make_smi_list(tgt_train_path, tgt_counter)
+    src_valid, max_src_valid = make_smi_list(src_valid_path, src_counter)
+    tgt_valid, max_tgt_valid = make_smi_list(tgt_valid_path, tgt_counter)
+    
+    src_max_length = max([max_src_train, max_src_valid])
+    tgt_max_length = max([max_tgt_train, max_tgt_valid])
+    tgt_max_length = tgt_max_length+2 # bosとeosの分を加算
+    
+    datasets = []
+    datasets.append(src_train)
+    datasets.append(tgt_train)
+    datasets.append(src_valid)
+    datasets.append(tgt_valid)
+    
+    return {'src_counter': src_counter, 'tgt_counter': tgt_counter,
+            'src_max_len': src_max_length, 'tgt_max_len': tgt_max_length, 'datasets': datasets}
+
+def make_transforms(data_dict, make_vocab: bool = False, vocab_load_path=None):
+    if make_vocab == False and vocab_load_path is None:
+        raise ValueError('The make_transforms function is not being passed the vocab_load_path.')
+    if make_vocab:
+        counter = data_dict['src_counter'] + data_dict['tgt_counter']
+        v = vocab(counter, min_freq=5, specials=(['<unk>', '<pad>', '<bos>', '<eos>']))
+        v.set_default_index(v['<unk>'])
+    else:
+        v = torch.load(vocab_load_path)
+    
+    src_transforms = T.Sequential(
+        T.VocabTransform(v),
+        T.ToTensor(padding_value=v['<pad>']),
+        T.PadTransform(max_length=data_dict['src_max_len'], pad_value=v['<pad>']) # srcはbosとeosが不要
+        )
+    
+    tgt_transforms = T.Sequential(
+        T.VocabTransform(v),
+        T.AddToken(token=v['<bos>'], begin=True),
+        T.AddToken(token=v['<eos>'], begin=False),
+        T.ToTensor(padding_value=v['<pad>']),
+        T.PadTransform(max_length=data_dict['tgt_max_len'],pad_value=v['<pad>'])
+        )
+    
+    return src_transforms, tgt_transforms, v
+    
+
+def make_dataloader(datasets, src_transforms, tgt_transforms, batch_size):
+    '''
+    datasets: output of make_counter()
+    transforms: output of make_vocab()
+    '''
+    
+    src_train = datasets[0]
+    tgt_train = datasets[1]
+    src_valid = datasets[2]
+    tgt_valid = datasets[3]
+    
+    src_train, src_valid = src_transforms(src_train), src_transforms(src_valid)
+    tgt_train, tgt_valid = tgt_transforms(tgt_train), tgt_transforms(tgt_valid)
+    
+    train_dataset = smi_Dataset(src=src_train, tgt=tgt_train)
+    valid_dataset = smi_Dataset(src=src_valid, tgt=tgt_valid)
+
+    train_dataloader = DataLoader(dataset=train_dataset,
+                                  batch_size=batch_size,
+                                  drop_last=True,
+                                  shuffle=True,
+                                  num_workers=2,
+                                  pin_memory=True
+                                  )
+    valid_dataloader = DataLoader(dataset=valid_dataset,
+                                  batch_size=batch_size,
+                                  drop_last=False,
+                                  shuffle=False,
+                                  num_workers=2,
+                                  pin_memory=True
+                                  )
+
+    return train_dataloader, valid_dataloader
+    
+
+@hydra.main(config_path=None, config_name='config', version_base=None)
+def main(cfg: DictConfig):
+    # Loading data
+    print('Saving vocabulary...')
+    src_train_path = hydra.utils.get_original_cwd()+cfg['prep']['src_train']
+    tgt_train_path = hydra.utils.get_original_cwd()+cfg['prep']['tgt_train']
+    src_valid_path = hydra.utils.get_original_cwd()+cfg['prep']['src_valid']
+    tgt_valid_path = hydra.utils.get_original_cwd()+cfg['prep']['tgt_valid']
+    
+    data_dict= make_counter(src_train_path=src_valid_path,
+                            tgt_train_path=tgt_train_path,
+                            src_valid_path=src_train_path,
+                            tgt_valid_path=tgt_valid_path)
+    
+    _, _, v = make_transforms(data_dict=data_dict, make_vocab=True, vocab_load_path=None)
+    torch.save(v, hydra.utils.get_original_cwd()+'/vocab.pth')
+    print('done.')
+
+if __name__ == '__main__':
+    main()
+
+
+
+

data/scripts/transformer_train.py

@@ -0,0 +1,167 @@
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
+
+import time
+import math
+import hydra
+from config.config import cs
+from omegaconf import DictConfig, OmegaConf
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torch.backends.cudnn as cudnn
+import torch.distributed as dist
+import torch.multiprocessing as mp
+
+from Model.Transformer.model import TransformerLR, Transformer
+from scripts.preprocess import make_counter, make_transforms, make_dataloader
+from Utils.utils import tally_parameters, EarlyStopping, AverageMeter, accuracy, torch_fix_seed
+
+import datetime
+date = datetime.datetime.now().strftime('%Y%m%d')
+
+torch_fix_seed()
+
+def train(cfg):
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    num = 1
+    while True:
+        ckpt_dir = hydra.utils.get_original_cwd()+f'/ckpts/checkpoints_{date}_{num}'
+        if os.path.isdir(ckpt_dir):
+            num += 1
+            continue
+        else:
+            os.makedirs(ckpt_dir, exist_ok=True)
+            break
+    print(f'{ckpt_dir} was created.')
+    
+    data_dict = make_counter(src_train_path=hydra.utils.get_original_cwd()+cfg['train']['src_train'],
+                             tgt_train_path=hydra.utils.get_original_cwd()+cfg['train']['tgt_train'],
+                             src_valid_path=hydra.utils.get_original_cwd()+cfg['train']['src_valid'],
+                             tgt_valid_path=hydra.utils.get_original_cwd()+cfg['train']['tgt_valid']
+                             )
+    print('making dataloader...')
+    src_transforms, tgt_transforms, v = make_transforms(data_dict=data_dict, make_vocab=True, vocab_load_path=None)
+    train_dataloader, valid_dataloader = make_dataloader(datasets=data_dict['datasets'], src_transforms=src_transforms,
+                                                         tgt_transforms=tgt_transforms,batch_size=cfg['train']['batch_size'])
+    print('max length of src sentence:', data_dict['src_max_len'])
+    d_model = cfg['model']['dim_model']
+    nhead = cfg['model']['nhead']
+    dropout = cfg['model']['dropout']
+    dim_ff = cfg['model']['dim_ff']
+    num_encoder_layers = cfg['model']['num_encoder_layers']
+    num_decoder_layers = cfg['model']['num_decoder_layers']
+    model = Transformer(d_model=d_model, nhead=nhead, num_encoder_layers=num_encoder_layers, num_decoder_layers=num_decoder_layers,
+                        dim_feedforward=dim_ff,vocab=v, dropout=dropout, device=device).to(device)
+    cudnn.benchmark = True
+    if device == 'cuda':
+        model = torch.nn.DataParallel(model) # make parallel
+        torch.backends.cudnn.benchmark = True
+    
+    # count the number of parameters.
+    n_params, enc, dec = tally_parameters(model)
+    print('encoder: %d' % enc)
+    print('decoder: %d' % dec)
+    print('* number of parameters: %d' % n_params)
+    
+    lr = cfg['train']['lr']
+    betas = cfg['train']['betas']
+    patience = cfg['train']['patience']
+    optimizer = optim.Adam(model.parameters(), lr=lr, betas=betas)
+    scheduler = TransformerLR(optimizer, warmup_epochs=8000)
+    label_smoothing = cfg['train']['label_smoothing']
+    criterion = nn.CrossEntropyLoss(label_smoothing=label_smoothing,
+                                    reduction='none',
+                                    ignore_index=v['<pad>']
+                                    )
+    earlystopping = EarlyStopping(patience=patience, ckpt_dir=ckpt_dir)
+    
+    step_num = cfg['train']['step_num']
+    log_interval_step = cfg['train']['log_interval']
+    valid_interval_steps = cfg['train']['val_interval']
+    save_interval_steps = cfg['train']['save_interval']
+    accum_count = 1
+    
+    valid_len = 0
+    for _, d in enumerate(valid_dataloader):
+        valid_len += len(d[0])
+    
+    step = 0
+    tgt_mask = nn.Transformer.generate_square_subsequent_mask(data_dict['tgt_max_len']-1).to(device)
+    scaler = torch.cuda.amp.GradScaler()
+    total_loss = 0
+    accum_loss = 0
+    model.train()
+    start_time = time.time()
+    print('start training...')
+    while step < step_num:
+        for i, data in enumerate(train_dataloader):
+            src, tgt = data[0].to(device).permute(1, 0), data[1].to(device).permute(1, 0)
+            tgt_input = tgt[:-1, :] # (seq, batch)
+            tgt_output = tgt[1:, :] # shifted right
+            with torch.amp.autocast('cuda'):
+                outputs = model(src=src, tgt=tgt_input, tgt_mask=tgt_mask,
+                                src_pad_mask=True, tgt_pad_mask=True, memory_pad_mask=True) # out: (seq_length, batch_size, vocab_size)
+                loss = (criterion(outputs.reshape(-1, v.__len__()), tgt_output.reshape(-1)).sum() / len(data[0])) / accum_count
+            scaler.scale(loss).backward()
+            accum_loss += loss.detach().item()
+            if ((i + 1) % accum_count == 0) or ((i + 1) == len(train_dataloader)):
+                scaler.unscale_(optimizer)
+                torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)
+                scaler.step(optimizer)
+                scaler.update()
+                scheduler.step()
+                optimizer.zero_grad()
+                step += 1
+                total_loss += accum_loss
+                accum_loss = 0
+            
+            if (step + 1) % log_interval_step == 0:
+                lr = scheduler.get_last_lr()[0]
+                cur_loss = total_loss / log_interval_step
+                ppl = math.exp(cur_loss)
+                end_time = time.time()
+                print(f'| step {step+1} | lr {lr:03.5f} | loss {cur_loss:5.5f} | ppl {ppl:8.5f} | time per {log_interval_step} step {end_time - start_time:3.1f}|')
+                total_loss = 0
+                start_time = time.time()
+            
+            # validation step
+            if (step + 1) % valid_interval_steps == 0:
+                model.eval()
+                top1 = AverageMeter()
+                perfect_acc_top1 = AverageMeter()
+                eval_total_loss = 0.
+                with torch.no_grad():
+                    for val_i, val_data in enumerate(valid_dataloader):
+                        src, tgt = val_data[0].to(device).permute(1, 0), val_data[1].to(device).permute(1, 0)
+                        tgt_input = tgt[:-1, :]
+                        tgt_output = tgt[1:, :]
+                        outputs = model(src=src, tgt=tgt_input, tgt_mask=tgt_mask,
+                                        src_pad_mask=True, tgt_pad_mask=True, memory_pad_mask=True)
+                        tmp_eval_loss = criterion(outputs.reshape(-1, v.__len__()), tgt_output.reshape(-1)).sum() / len(val_data[0])
+                        eval_total_loss += tmp_eval_loss.detach().item()
+                        partial_top1, perfect_acc = accuracy(outputs.reshape(-1, v.__len__()), tgt_output.reshape(-1), batch_size=tgt_output.size(1), v=v)
+                        top1.update(partial_top1, src.size(1))
+                        perfect_acc_top1.update(perfect_acc, src.size(1))
+                    eval_loss = eval_total_loss / (val_i + 1)
+                    print(f'validation step {step+1} | validation loss {eval_loss:5.5f} | partial top1 accuracy {top1.avg:.3f} | perfect top1 accuracy {perfect_acc_top1.avg:.3f}')
+                    if (step + 1) % save_interval_steps == 0:
+                        earlystopping(val_loss=eval_loss, step=step, optimizer=optimizer, cur_loss=cur_loss, model=model)
+                model.train()
+                start_time = time.time()
+            if earlystopping.early_stop:
+                print('Early Stopping!')
+                break
+        if earlystopping.early_stop:
+            break
+            
+@hydra.main(config_path=None, config_name='config', version_base=None)
+def main(cfg: DictConfig):
+    train(cfg)
+
+
+if __name__ == '__main__':
+    main()

data/scripts/translate.py

@@ -0,0 +1,193 @@
+import operator
+import torch
+import torchtext.vocab.vocab as Vocab
+import rdkit.Chem as Chem
+import hydra
+from config.config import cs
+from omegaconf import DictConfig
+
+from Model.Transformer.model import Transformer
+from scripts.preprocess import make_counter ,make_transforms
+
+import itertools
+import os
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+class BeamSearchNode(object):
+    def __init__(self, previousNode, decoder_input, logProb, length):
+        self.prevNode = previousNode
+        self.dec_in = decoder_input.to('cpu')
+        self.logp = logProb
+        self.leng = length
+
+    def eval(self, alpha=0.6):
+        return self.logp / (((5 + self.leng) / (5 + 1)) ** alpha)
+
+
+def beam_decode(cfg: DictConfig, v:Vocab, model=None, input_tokens=None, Temp=1):
+    global beam_width, nbest
+    SOS_token = v['<bos>']
+    EOS_token = v['<eos>']
+    beam_width = cfg['translate']['beam_size']
+    nbest = cfg['translate']['nbest']
+    inf_max_len = cfg['translate']['inf_max_len']
+    
+    # A batch of one input for Encoder
+    encoder_input = input_tokens
+
+    # Generate encoded features
+    with torch.no_grad():
+        encoder_input = encoder_input.unsqueeze(-1) # (seq, 1), batch_size=1
+        encoder_output, memory_pad_mask = model.encode(encoder_input, src_pad_mask=True) # encoder_output.shape: (seq, 1, d_model)
+
+    # Start with the start of the sentence token
+    decoder_input = torch.tensor([[SOS_token]]).to(device) # (1,1)
+
+    # Starting node
+    counter = itertools.count()
+    
+    node = BeamSearchNode(previousNode=None,
+                          decoder_input=decoder_input,
+                          logProb=0, length=0)
+    
+    with torch.no_grad():
+        tgt_mask = torch.nn.Transformer.generate_square_subsequent_mask(decoder_input.size(1)).to(device)
+        logits = model.decode(memory=encoder_output, tgt=decoder_input.permute(1, 0), tgt_mask=tgt_mask, memory_pad_mask=memory_pad_mask)
+        logits = logits.permute(1, 0, 2) # logits: (seq, 1, vocab) -> (1, seq, vocab), batch=1になってる
+        decoder_output = torch.log_softmax(logits[:, -1, :]/Temp, dim=1) # 最後のseqだけ取り出してlog_softmax, (1, vocab)
+    
+    
+    tmp_beam_width = min(beam_width, decoder_output.size(1))
+    log_prob, indexes = torch.topk(decoder_output, tmp_beam_width) # (tmp_beam_with,)
+    nextnodes = []
+    for new_k in range(tmp_beam_width):
+        decoded_t = indexes[0][new_k].view(1, -1).to('cpu') # indexを取得, shape: (1,1)
+        log_p = log_prob[0][new_k].item() # logpを取得
+        next_decoder_input = torch.cat([node.dec_in, decoded_t],dim=1) # dec_in:(1, seq)
+        nn = BeamSearchNode(previousNode=node,
+                                decoder_input=next_decoder_input,
+                                logProb=node.logp + log_p,
+                                length=node.leng + 1)
+        score = -nn.eval()
+        count = next(counter)
+        nextnodes.append((score, count, nn))
+    
+    # start beam search
+    for i in range(inf_max_len - 1):
+        # fetch the best node
+        if i == 0:
+            current_nodes = sorted(nextnodes)[:tmp_beam_width]
+        else:
+            current_nodes = sorted(nextnodes)[:beam_width]
+        
+        nextnodes=[]
+        # current_nodes = [(score, count, node), (score, count, node)...], shape:(beam_width,)
+        scores, counts, nodes, decoder_inputs = [], [], [], []
+        for score, count, node in current_nodes:
+            if node.dec_in[0][-1].item() == EOS_token:
+                nextnodes.append((score, count, node))
+            else:
+                scores.append(score)
+                counts.append(count)
+                nodes.append(node)
+                decoder_inputs.append(node.dec_in)
+        if not bool(decoder_inputs):
+            break
+        
+        decoder_inputs = torch.vstack(decoder_inputs) # (batch=beam, seq)
+
+        # adjust batch_size
+        enc_out = encoder_output.repeat(1, decoder_inputs.size(0), 1)
+        mask = memory_pad_mask.repeat(decoder_inputs.size(0), 1)
+        
+        with torch.no_grad():
+            tgt_mask = torch.nn.Transformer.generate_square_subsequent_mask(decoder_inputs.size(1)).to(device)
+            logits = model.decode(memory=enc_out, tgt=decoder_inputs.permute(1, 0).to(device), tgt_mask=tgt_mask, memory_pad_mask=mask)
+            logits = logits.permute(1, 0, 2) # logits: (seq, batch, vocab) -> (batch, seq, vocab)
+            decoder_output = torch.log_softmax(logits[:, -1, :]/Temp, dim=1) # extract log_softmax of last token
+            # decoder_output.shape = (batch, vocab)
+            
+        for beam, score in enumerate(scores):
+            for token in range(EOS_token, decoder_output.size(-1)): # indexを取得, unk, pad, bosは最初から捨てる
+                decoded_t = torch.tensor([[token]])
+                log_p = decoder_output[beam, token].item()
+                next_decoder_input = torch.cat([nodes[beam].dec_in, decoded_t],dim=1)
+                node = BeamSearchNode(previousNode=nodes[beam],
+                                    decoder_input=next_decoder_input,
+                                    logProb=nodes[beam].logp + log_p,
+                                    length=nodes[beam].leng + 1)
+                score = -node.eval()
+                count = next(counter)
+                nextnodes.append((score, count, node))
+
+    outputs = []
+    for score, _, n in sorted(nextnodes, key=operator.itemgetter(0))[:nbest]:
+        # endnodes = [(score, node), (score, node)...] なのでitemgetter(0)でscoreをkeyに指定している
+        output = n.dec_in.squeeze(0).tolist()[1:-1] # bosとeos削除
+        output = v.lookup_tokens(output)
+        output = ' '.join(output)
+        outputs.append(output)
+
+    return outputs
+
+
+def translation(cfg:DictConfig):
+    # make transforms and vocabulary
+    src_train_path = hydra.utils.get_original_cwd()+cfg['translate']['src_train']
+    tgt_train_path = hydra.utils.get_original_cwd()+cfg['translate']['tgt_train']
+    src_valid_path = hydra.utils.get_original_cwd()+cfg['translate']['src_valid']
+    tgt_valid_path = hydra.utils.get_original_cwd()+cfg['translate']['tgt_valid']
+    data_dict = make_counter(src_train_path=src_train_path,
+                             tgt_train_path=tgt_train_path,
+                             src_valid_path=src_valid_path,
+                             tgt_valid_path=tgt_valid_path
+                             )
+    src_transforms, _, v = make_transforms(data_dict=data_dict, make_vocab=True, vocab_load_path=None)
+    
+    # load model
+    d_model = cfg['model']['dim_model']
+    num_encoder_layers = cfg['model']['num_encoder_layers']
+    num_decoder_layers = cfg['model']['num_decoder_layers']
+    nhead = cfg['model']['nhead']
+    dropout = cfg['model']['dropout']
+    dim_ff = cfg['model']['dim_ff']
+    model = Transformer(d_model=d_model, nhead=nhead, num_encoder_layers=num_encoder_layers, num_decoder_layers=num_decoder_layers,
+                        dim_feedforward=dim_ff,vocab=v, dropout=dropout, device=device).to(device)
+    ckpt = torch.load(hydra.utils.get_original_cwd() + cfg['model']['ckpt'], map_location=device)
+    model.load_state_dict(ckpt['model_state_dict'])
+    
+    # make dataset
+    src = []
+    src_test_path = hydra.utils.get_original_cwd() + cfg['translate']['src_test_path']
+    with open(src_test_path,'r') as f:
+        for line in f:
+            src.append(line.rstrip().split(' '))
+    src = src_transforms(src).to(device)
+
+    rsmis =[]
+    for i, input_tokens in enumerate(src):
+        outputs = beam_decode(cfg=cfg, v=v, model=model, input_tokens=input_tokens)
+        input_tokens = input_tokens.tolist()
+        input_smi = input_tokens[0:input_tokens.index(v['<pad>'])]
+        input_smi = v.lookup_tokens(input_smi)
+        input_smi = ' '.join(input_smi)
+        for output in outputs:
+            rsmis.append(input_smi + ' >> ' + output)
+        
+    out_dir = cfg['translate']['out_dir']
+    filename = cfg['translate']['filename']
+    
+# set output file name
+    os.makedirs(hydra.utils.get_original_cwd() + out_dir, exist_ok=True)
+    with open(hydra.utils.get_original_cwd() + f'{out_dir}/out_beam{beam_width}_best{nbest}_file_{filename}.txt','w') as f:
+        for rsmi in rsmis:
+            f.write(rsmi + '\n')
+        f.close()
+
+@hydra.main(config_path=None, config_name='config', version_base=None)
+def main(cfg: DictConfig):
+    translation(cfg)
+
+if __name__ == '__main__':
+    main()

data/set_up.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+# You should source this script to get the correct additions to Python path
+
+# Directory of script
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+# Set up the python paths
+export PYTHONPATH=${PYTHONPATH}:${DIR}/
+export PYTHONPATH=${PYTHONPATH}:${DIR}/Model/

data/translation/out_beam10_best10.txt

@@ -0,0 +1,91 @@
+[749] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C ( C ) ( O ) c 2 c c n c c 2 ) C C N ( C ) C 1
+[749] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C ( C ) ( O ) c 2 c c c n c 2 ) C C N ( C ) C 1
+[749] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C ( C ) ( O ) c 2 c c n c n 2 ) C C N ( C ) C 1
+[749] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C ( O ) c 2 c c n c c 2 ) C C N ( C ) C 1
+[749] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C ( C ) ( O ) c 2 c n c n c 2 ) C C N ( C ) C 1
+[749] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C ( C ) ( O ) c 2 c n c c n 2 ) C C N ( C ) C 1
+[749] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C O c 1 c c c ( C ( O ) C n 2 c 3 c ( c 4 c c ( C ) c c c 4 2 ) C N ( C ) C C 3 ) c n 1
+[749] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C ( C ) ( O ) c 2 c n n ( C ) c 2 ) C C N ( C ) C 1
+[749] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C ( C ) ( O ) c 2 c c c ( C ) n c 2 ) C C N ( C ) C 1
+[749] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C ( C ) ( O ) c 2 c c c c n 2 ) C C N ( C ) C 1
+[987] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C C ( = C n 1 c 2 c ( c 3 c c ( C ) c c c 3 1 ) C N ( C ) C C 2 ) c 1 c c c ( F ) c ( F ) c 1
+[987] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C C ( = C n 1 c 2 c ( c 3 c c ( C ) c c c 3 1 ) C N ( C ) C C 2 ) c 1 c c c ( F ) c c 1
+[987] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C C ( = C n 1 c 2 c ( c 3 c c ( C ) c c c 3 1 ) C N ( C ) C C 2 ) c 1 c c c ( C ) n c 1
+[987] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C O c 1 c c c ( C ( C ) = C n 2 c 3 c ( c 4 c c ( C ) c c c 4 2 ) C N ( C ) C C 3 ) c c 1
+[987] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C C ( = C n 1 c 2 c ( c 3 c c ( C ) c c c 3 1 ) C N ( C ) C C 2 ) c 1 c c c ( Cl ) c ( Cl ) c 1
+[987] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C C ( = C n 1 c 2 c ( c 3 c c ( C ) c c c 3 1 ) C N ( C ) C C 2 ) c 1 c c c c ( F ) c 1
+[987] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C C ( = C n 1 c 2 c ( c 3 c c ( C ) c c c 3 1 ) C N ( C ) C C 2 ) c 1 c c n c c 1
+[987] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C C ( = C n 1 c 2 c ( c 3 c c ( C ) c c c 3 1 ) C N ( C ) C C 2 ) c 1 c c c ( F ) c c 1 F
+[987] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C C ( = C n 1 c 2 c ( c 3 c c ( C ) c c c 3 1 ) C N ( C ) C C 2 ) c 1 c c c c c 1 F
+[987] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C C ( = C n 1 c 2 c ( c 3 c c ( C ) c c c 3 1 ) C N ( C ) C C 2 ) c 1 c c c ( Cl ) c c 1
+[986] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C c 2 c c c ( C ( F ) ( F ) F ) n c 2 ) C C N ( C ) C 1
+[986] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C c 2 c c c ( C ) n c 2 ) C C N ( C ) C 1
+[986] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C c 2 c n c 3 c c c c c 3 c 2 ) C C N ( C ) C 1
+[986] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C c 2 c n c c ( F ) c 2 ) C C N ( C ) C 1
+[986] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C C c 1 c c c ( C C n 2 c 3 c ( c 4 c c ( C ) c c c 4 2 ) C N ( C ) C C 3 ) c n 1
+[986] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C c 2 c c c ( N ( C ) C ) n c 2 ) C C N ( C ) C 1
+[986] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C c 2 c n c c c 2 C ( F ) ( F ) F ) C C N ( C ) C 1
+[986] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C c 2 c n c ( C ) c c 2 C ( F ) ( F ) F ) C C N ( C ) C 1
+[986] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C c 2 c n c c ( Br ) c 2 ) C C N ( C ) C 1
+[986] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C c 2 c c c ( = O ) [nH] c 2 ) C C N ( C ) C 1
+[349] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 - c 2 c c c 3 n c c c c 3 c 2 ) C C N ( C ) C 1
+[349] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 - c 2 c c c 3 c c n c c 3 c 2 ) C C N ( C ) C 1
+[349] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 - c 2 c c c c c 2 ) C C N ( C ) C 1
+[349] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 - c 2 c c c c ( Br ) c 2 ) C C N ( C ) C 1
+[349] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c ( - n 2 c 3 c ( c 4 c c ( C ) c c c 4 2 ) C N ( C ) C C 3 ) c c 1
+[349] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 - c 2 c c c 3 [nH] c c c 3 c 2 ) C C N ( C ) C 1
+[349] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 - c 2 c c c 3 c n c c c 3 c 2 ) C C N ( C ) C 1
+[349] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 - c 2 c c c 3 n c n c c 3 c 2 ) C C N ( C ) C 1
+[349] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 - c 2 c c c 3 c n n c c 3 c 2 ) C C N ( C ) C 1
+[349] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C O c 1 c c c ( - n 2 c 3 c ( c 4 c c ( C ) c c c 4 2 ) C N ( C ) C C 3 ) c c 1
+[556] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c c c 2 ) C C N ( C ) C 1
+[556] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c c c 2 Cl ) C C N ( C ) C 1
+[556] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c ( Cl ) c c 2 ) C C N ( C ) C 1
+[556] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c n c c 2 ) C C N ( C ) C 1
+[556] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C O c 1 c c c ( C n 2 c 3 c ( c 4 c c ( C ) c c c 4 2 ) C N ( C ) C C 3 ) c c 1
+[556] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c ( F ) c c 2 ) C C N ( C ) C 1
+[556] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c c c 2 C ( F ) ( F ) F ) C C N ( C ) C 1
+[556] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c c c 2 F ) C C N ( C ) C 1
+[556] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c c ( Cl ) c 2 ) C C N ( C ) C 1
+[556] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c ( F ) c c c c 2 F ) C C N ( C ) C 1
+[648] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 S ( = O ) ( = O ) c 2 c c c c c 2 ) C C N ( C ) C 1
+[648] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 S ( = O ) ( = O ) c 2 c c c ( Cl ) c c 2 ) C C N ( C ) C 1
+[648] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 S ( = O ) ( = O ) c 2 c c c c ( Cl ) c 2 ) C C N ( C ) C 1
+[648] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 S ( = O ) ( = O ) c 2 c c c ( F ) c c 2 ) C C N ( C ) C 1
+[648] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 S ( = O ) ( = O ) c 2 c c c ( C ) c c 2 ) C C N ( C ) C 1
+[648] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 S ( = O ) ( = O ) c 2 c c c c c 2 Cl ) C C N ( C ) C 1
+[648] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 S ( = O ) ( = O ) c 2 c c c c 3 c c c c c 2 3 ) C C N ( C ) C 1
+[648] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 S ( = O ) ( = O ) c 2 c c c c c 2 F ) C C N ( C ) C 1
+[648] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C O c 1 c c c ( S ( = O ) ( = O ) n 2 c 3 c ( c 4 c c ( C ) c c c 4 2 ) C N ( C ) C C 3 ) c c 1
+[648] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 S ( = O ) ( = O ) c 2 c c c 3 c c n c c 3 c 2 ) C C N ( C ) C 1
+[302] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C C n 1 c 2 c ( c 3 c c ( C ) c c c 3 1 ) C N ( C ) C C 2
+[302] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C C C n 1 c 2 c ( c 3 c c ( C ) c c c 3 1 ) C N ( C ) C C 2
+[302] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C ( C ) C ) C C N ( C ) C 1
+[302] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C C C C n 1 c 2 c ( c 3 c c ( C ) c c c 3 1 ) C N ( C ) C C 2
+[302] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C C ( F ) ( F ) F ) C C N ( C ) C 1
+[302] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C ( C ) ( C ) C ) C C N ( C ) C 1
+[302] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C c 2 c c c c c 2 ) C C N ( C ) C 1
+[302] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C C C ( C ) C ) C C N ( C ) C 1
+[302] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C C C C C n 1 c 2 c ( c 3 c c ( C ) c c c 3 1 ) C N ( C ) C C 2
+[302] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C O C C n 1 c 2 c ( c 3 c c ( C ) c c c 3 1 ) C N ( C ) C C 2
+[191] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C ) C C N ( C ) C 1
+[232] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C ( = O ) c 2 c c c c c 2 ) C C N ( C ) C 1
+[232] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C ( = O ) c 2 c c c ( Cl ) c c 2 ) C C N ( C ) C 1
+[232] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C ( = O ) c 2 c c c ( F ) c c 2 ) C C N ( C ) C 1
+[232] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c ( C ( = O ) n 2 c 3 c ( c 4 c c ( C ) c c c 4 2 ) C N ( C ) C C 3 ) c c 1
+[232] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C ( = O ) c 2 c ( Cl ) c c c c 2 Cl ) C C N ( C ) C 1
+[232] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C ( = O ) c 2 c c n c c 2 ) C C N ( C ) C 1
+[232] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C ( = O ) c 2 c c ( Cl ) c c ( Cl ) c 2 ) C C N ( C ) C 1
+[232] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C ( = O ) c 2 c c c ( C ) c c 2 ) C C N ( C ) C 1
+[232] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C ( = O ) c 2 c c c ( Br ) c c 2 ) C C N ( C ) C 1
+[232] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C ( = O ) c 2 c c c c c 2 Cl ) C C N ( C ) C 1
+[528] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c c c 2 ) C C N ( C ) C 1
+[528] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c c ( Br ) c 2 ) C C N ( C ) C 1
+[528] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c ( F ) c c 2 ) C C N ( C ) C 1
+[528] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c c c 2 C # N ) C C N ( C ) C 1
+[528] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c c c 2 Cl ) C C N ( C ) C 1
+[528] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c c c 2 F ) C C N ( C ) C 1
+[528] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c c ( F ) c 2 ) C C N ( C ) C 1
+[528] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c ( Br ) c c 2 ) C C N ( C ) C 1
+[528] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c c c 2 Br ) C C N ( C ) C 1
+[528] C c 1 c c c 2 [nH] c 3 c ( c 2 c 1 ) C N ( C ) C C 3 >> C c 1 c c c 2 c ( c 1 ) c 1 c ( n 2 C c 2 c c c ( Cl ) c c 2 ) C C N ( C ) C 1