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()