From 507e239e3e78ebaa7a66ac4f5538c08baedcdd64 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Tue, 21 Feb 2023 12:11:30 +0530 Subject: [PATCH 01/34] adding sanity check experiments for small horizon len and layernorm actor --- sac.py | 9 ++++++--- scripts/cedar/1.sh | 2 +- scripts/cedar/2.sh | 2 +- scripts/cedar/3.sh | 2 +- 4 files changed, 9 insertions(+), 6 deletions(-) diff --git a/sac.py b/sac.py index 6256cec..f882c43 100644 --- a/sac.py +++ b/sac.py @@ -20,9 +20,12 @@ def forward(self, x): class Actor(nn.Module): def __init__(self, input_dims, hidden_dims, output_dims, dist='categorical'): super(Actor, self).__init__() - self.fc1 = nn.Linear(input_dims, hidden_dims) - self.fc2 = nn.Linear(hidden_dims, hidden_dims) - self.fc3 = nn.Linear(hidden_dims, output_dims) + + self.action_dist = nn.Sequential( + nn.Linear(input_dims, hidden_dims), + nn.ReLU(), nn.Linear(hidden_dims, hidden_dims), nn.LayerNorm(hidden_dims), + nn.ReLU(), nn.Linear(hidden_dims, output_dims), + ) self.dist = dist def forward(self, x): diff --git a/scripts/cedar/1.sh b/scripts/cedar/1.sh index 1a60480..6165a06 100644 --- a/scripts/cedar/1.sh +++ b/scripts/cedar/1.sh @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem &&\ -python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=23 wandb_log=True wandb_run_name=max_len_23 seed=1 num_sub_proc=20" \ No newline at end of file +python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=22 wandb_log=True wandb_run_name=ln_max_len_22 seed=1 num_sub_proc=20" \ No newline at end of file diff --git a/scripts/cedar/2.sh b/scripts/cedar/2.sh index 1a60480..048d33f 100644 --- a/scripts/cedar/2.sh +++ b/scripts/cedar/2.sh @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem &&\ -python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=23 wandb_log=True wandb_run_name=max_len_23 seed=1 num_sub_proc=20" \ No newline at end of file +python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=22 wandb_log=True wandb_run_name=ln_max_len_22 seed=2 num_sub_proc=20" \ No newline at end of file diff --git a/scripts/cedar/3.sh b/scripts/cedar/3.sh index 1a60480..bf59e4e 100644 --- a/scripts/cedar/3.sh +++ b/scripts/cedar/3.sh @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem &&\ -python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=23 wandb_log=True wandb_run_name=max_len_23 seed=1 num_sub_proc=20" \ No newline at end of file +python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=22 wandb_log=True wandb_run_name=ln_max_len_22 seed=3 num_sub_proc=20" \ No newline at end of file From faaee492d2597e2ec778494792fc3fc32be3d06a Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Tue, 21 Feb 2023 12:19:44 +0530 Subject: [PATCH 02/34] adding sanity check experiments for small horizon len and layernorm actor --- sac.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/sac.py b/sac.py index f882c43..ed1c8b0 100644 --- a/sac.py +++ b/sac.py @@ -21,7 +21,7 @@ class Actor(nn.Module): def __init__(self, input_dims, hidden_dims, output_dims, dist='categorical'): super(Actor, self).__init__() - self.action_dist = nn.Sequential( + self.actor = nn.Sequential( nn.Linear(input_dims, hidden_dims), nn.ReLU(), nn.Linear(hidden_dims, hidden_dims), nn.LayerNorm(hidden_dims), nn.ReLU(), nn.Linear(hidden_dims, output_dims), @@ -29,9 +29,7 @@ def __init__(self, input_dims, hidden_dims, output_dims, dist='categorical'): self.dist = dist def forward(self, x): - x = F.relu(self.fc1(x)) - x = F.relu(self.fc2(x)) - logits = self.fc3(x) + logits = self.actor(x) if self.dist == 'categorical': dist = td.Categorical(logits=logits) elif self.dist == 'one_hot_categorical': From d75ae8b49d1a4f2dcb0842343d34e3ccc58e02fc Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Tue, 21 Feb 2023 12:26:24 +0530 Subject: [PATCH 03/34] adding 25 len experiments as well --- scripts/cedar/4.sh | 12 +++++++----- scripts/cedar/5.sh | 16 ++++++++++++++++ scripts/cedar/6.sh | 16 ++++++++++++++++ 3 files changed, 39 insertions(+), 5 deletions(-) create mode 100644 scripts/cedar/5.sh create mode 100644 scripts/cedar/6.sh diff --git a/scripts/cedar/4.sh b/scripts/cedar/4.sh index de81bd5..f5c39af 100644 --- a/scripts/cedar/4.sh +++ b/scripts/cedar/4.sh @@ -1,14 +1,16 @@ #!/bin/bash #SBATCH --account=rrg-gberseth -#SBATCH --time=5:00:00 -#SBATCH --cpus-per-task=4 +#SBATCH --time=02:00:00 +#SBATCH --cpus-per-task=24 #SBATCH --mem=4G #SBATCH --gres=gpu:v100l:1 #SBATCH --array=1-3 -rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem +array=(-1 "fa7" "parp1" "5ht1b") -cd $SLURM_TMPDIR/RL4Chem +rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem +echo "moved code to slurm tmpdir" -python train.py max_selfie_length=20 entropy_coefficient=0.1 wandb_log=True seed=$SLURM_ARRAY_TASK_ID wandb_run_name=max_len20_ent0.1_seed$SLURM_ARRAY_TASK_ID \ No newline at end of file +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem &&\ +python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=25 wandb_log=True wandb_run_name=ln_max_len_25 seed=1 num_sub_proc=24" \ No newline at end of file diff --git a/scripts/cedar/5.sh b/scripts/cedar/5.sh new file mode 100644 index 0000000..995a541 --- /dev/null +++ b/scripts/cedar/5.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +#SBATCH --account=rrg-gberseth +#SBATCH --time=02:00:00 +#SBATCH --cpus-per-task=24 +#SBATCH --mem=4G +#SBATCH --gres=gpu:v100l:1 +#SBATCH --array=1-3 + +array=(-1 "fa7" "parp1" "5ht1b") + +rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem +echo "moved code to slurm tmpdir" + +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem &&\ +python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=25 wandb_log=True wandb_run_name=ln_max_len_25 seed=2 num_sub_proc=24" \ No newline at end of file diff --git a/scripts/cedar/6.sh b/scripts/cedar/6.sh new file mode 100644 index 0000000..c307e3f --- /dev/null +++ b/scripts/cedar/6.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +#SBATCH --account=rrg-gberseth +#SBATCH --time=02:00:00 +#SBATCH --cpus-per-task=24 +#SBATCH --mem=4G +#SBATCH --gres=gpu:v100l:1 +#SBATCH --array=1-3 + +array=(-1 "fa7" "parp1" "5ht1b") + +rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem +echo "moved code to slurm tmpdir" + +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem &&\ +python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=25 wandb_log=True wandb_run_name=ln_max_len_25 seed=3 num_sub_proc=24" \ No newline at end of file From f4f6099f7780ea04250f4fb452a9c080233d74aa Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Tue, 21 Feb 2023 12:36:34 +0530 Subject: [PATCH 04/34] does rl produce unique strings? --- train.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/train.py b/train.py index b4c1e17..96a1221 100644 --- a/train.py +++ b/train.py @@ -51,6 +51,7 @@ def __init__(self, cfg): self.device = torch.device(cfg.device) self.train_env, self.eval_env = make_env(self.cfg) self.agent, self.env_buffer, self.fresh_env_buffer = make_agent(self.train_env, self.device, self.cfg) + self.unique_molecules = set() self.current_reward_batch = np.zeros((cfg.parallel_molecules,), dtype=np.float32) self.current_reward_info = dict() self._train_step = 0 @@ -88,6 +89,7 @@ def _explore(self): self.fresh_env_buffer.reset() print('Total strings = ', len(self.current_reward_info['selfies']), 'Unique strings = ', len(set(self.current_reward_info['selfies'])), ' Evaluation time = ', reward_eval_time) print(np.sort(self.current_reward_batch)) + self.unique_molecules.update(self.current_reward_info['smiles']) def train(self): self._eval() @@ -135,13 +137,15 @@ def train(self): unique_strings = len(set(self.current_reward_info['selfies'])) print('Total strings = ', len(self.current_reward_info['selfies']), 'Unique strings = ', unique_strings, ' Evaluation time = ', reward_eval_time) + self.unique_molecules.update(self.current_reward_info['smiles']) print(np.sort(self.current_reward_batch)) best_idx = np.argmax(self.current_reward_batch) print(self.current_reward_info['smiles'][best_idx]) if self.cfg.wandb_log: wandb.log({'reward_eval_time' : reward_eval_time, - 'unique strings': unique_strings}, step = self._train_step) + 'unique strings': unique_strings, + 'cummulative unique strings' : len(self.unique_molecules)}, step = self._train_step) parallel_counter = 0 def _eval(self): From 49186dc9f31caddfd3c65051a9ae5aacdbc4185f Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Tue, 21 Feb 2023 12:38:39 +0530 Subject: [PATCH 05/34] does rl produce unique strings? --- train.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/train.py b/train.py index 96a1221..ae55643 100644 --- a/train.py +++ b/train.py @@ -136,7 +136,7 @@ def train(self): self.fresh_env_buffer.reset() unique_strings = len(set(self.current_reward_info['selfies'])) - print('Total strings = ', len(self.current_reward_info['selfies']), 'Unique strings = ', unique_strings, ' Evaluation time = ', reward_eval_time) + print('Total strings = ', len(self.current_reward_info['selfies']), 'Unique strings = ', unique_strings, 'Cummulative unique strings = ', len(self.unique_molecules), ' Evaluation time = ', reward_eval_time) self.unique_molecules.update(self.current_reward_info['smiles']) print(np.sort(self.current_reward_batch)) best_idx = np.argmax(self.current_reward_batch) From 0ea6ec319fbc046f041b49ec4648883e6c84869e Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Wed, 22 Feb 2023 16:54:28 +0530 Subject: [PATCH 06/34] adding regression eval --- .gitignore | 1 + regression/models.py | 29 ++++++ regression/regression.py | 198 +++++++++++++++++++++++++++++++++++++++ requirements.txt | 1 + 4 files changed, 229 insertions(+) create mode 100644 regression/models.py create mode 100644 regression/regression.py diff --git a/.gitignore b/.gitignore index 373ee1c..97e4948 100644 --- a/.gitignore +++ b/.gitignore @@ -24,6 +24,7 @@ datasets/ filtered_data/ docked_data/ raw_data/ +data/ #package dependencies dockstring/ diff --git a/regression/models.py b/regression/models.py new file mode 100644 index 0000000..e3e25eb --- /dev/null +++ b/regression/models.py @@ -0,0 +1,29 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.nn.utils.rnn as rnn_utils + +class CharRNN(nn.Module): + def __init__(self, vocabulary, device): + super(CharRNN, self).__init__() + + self.vocabulary = vocabulary + self.hidden_size = 256 + self.num_layers = 3 + self.dropout = 0.2 + self.device = device + self.vocab_size = self.input_size = len(vocabulary) + + self.embedding_layer = nn.Embedding(self.vocab_size, 32, + padding_idx=vocabulary.pad).to(self.device) + self.lstm_layer = nn.LSTM(32, self.hidden_size, + self.num_layers, dropout=0.2, + batch_first=True).to(self.device) + self.linear_layer = nn.Linear(self.hidden_size, 1).to(self.device) + + def forward(self, x, lengths, hiddens=None): + x = self.embedding_layer(x) + x = rnn_utils.pack_padded_sequence(x, lengths, batch_first=True, enforce_sorted=False) + _, (h_last, _) = self.lstm_layer(x, hiddens) + preds = self.linear_layer(h_last[-1]).squeeze(-1) + return preds \ No newline at end of file diff --git a/regression/regression.py b/regression/regression.py new file mode 100644 index 0000000..693f114 --- /dev/null +++ b/regression/regression.py @@ -0,0 +1,198 @@ +import re +import torch +import torch.nn as nn +import torch.optim as optim +import torch.nn.functional as F +from torch.utils.data import DataLoader +import numpy as np +import pandas as pd +import selfies as sf +from pathlib import Path +from models import CharRNN + +def get_dataset(data_path='data/filtered_dockstring-dataset.tsv', splits_path='data/filtered_cluster_split.tsv', target='ESR2', string_rep='SMILES'): + assert target in ['ESR2', 'F2', 'KIT', 'PARP1', 'PGR'] + dockstring_df = pd.read_csv(data_path) + dockstring_splits = pd.read_csv(splits_path) + + bond_constraints = sf.get_semantic_constraints() + bond_constraints['I'] = 5 + sf.set_semantic_constraints(bond_constraints) + + assert np.all(dockstring_splits.smiles == dockstring_df.smiles) + assert sf.get_semantic_constraints()['I'] == 5 + + df_train = dockstring_df[dockstring_splits["split"] == "train"].dropna(subset=[target]) + df_test = dockstring_df[dockstring_splits["split"] == "test"].dropna(subset=[target]) + + y_train = df_train[target].values + y_test = df_test[target].values + + y_train = np.minimum(y_train, 5.0) + y_test = np.minimum(y_test, 5.0) + + if string_rep == 'SMILES': + x_train = list(df_train['canon_smiles']) + x_test = list(df_test['canon_smiles']) + elif string_rep == 'SELFIES': + assert sf == 1 + x_train = list(df_train['selfies']) + x_test = list(df_test['selifes']) + else: + raise NotImplementedError + + return x_train, y_train, x_test, y_test + +def replace_halogen(string): + """Regex to replace Br and Cl with single letters""" + br = re.compile('Br') + cl = re.compile('Cl') + string = br.sub('R', string) + string = cl.sub('L', string) + + return string + +class smiles_vocabulary(object): + def __init__(self, vocab_path='data/dockstring_smiles_vocabulary.txt'): + + self.alphabet = set() + with open(vocab_path, 'r') as f: + chars = f.read().split() + for char in chars: + self.alphabet.add(char) + + self.special_tokens = ['BOS', 'EOS', 'PAD', 'UNK'] + + self.alphabet_list = list(self.alphabet) + self.alphabet_list.sort() + self.alphabet_list = self.alphabet_list + self.special_tokens + self.alphabet_length = len(self.alphabet_list) + + self.alphabet_to_idx = {s: i for i, s in enumerate(self.alphabet_list)} + self.idx_to_alphabet = {s: i for i, s in self.alphabet_to_idx.items()} + + def tokenize(self, smiles, add_bos=False, add_eos=False): + """Takes a SMILES and return a list of characters/tokens""" + regex = '(\[[^\[\]]{1,6}\])' + smiles = replace_halogen(smiles) + char_list = re.split(regex, smiles) + tokenized = [] + for char in char_list: + if char.startswith('['): + tokenized.append(char) + else: + chars = [unit for unit in char] + [tokenized.append(unit) for unit in chars] + if add_bos: + tokenized.insert(0, "BOS") + if add_eos: + tokenized.append('EOS') + return tokenized + + def encode(self, smiles, add_bos=False, add_eos=False): + """Takes a list of SMILES and encodes to array of indices""" + char_list = self.tokenize(smiles, add_bos, add_eos) + encoded_smiles = np.zeros(len(char_list), dtype=np.uint8) + for i, char in enumerate(char_list): + encoded_smiles[i] = self.alphabet_to_idx[char] + return encoded_smiles + + def decode(self, encoded_smiles, rem_bos=True, rem_eos=True): + """Takes an array of indices and returns the corresponding SMILES""" + if rem_bos and encoded_smiles[0] == self.bos: + encoded_smiles = encoded_smiles[1:] + if rem_eos and encoded_smiles[-1] == self.eos: + encoded_smiles = encoded_smiles[:-1] + + chars = [] + for i in encoded_smiles: + chars.append(self.idx_to_alphabet[i]) + smiles = "".join(chars) + smiles = smiles.replace("L", "Cl").replace("R", "Br") + return smiles + + def __len__(self): + return len(self.alphabet_to_idx) + + @property + def bos(self): + return self.alphabet_to_idx['BOS'] + + @property + def eos(self): + return self.alphabet_to_idx['EOS'] + + @property + def pad(self): + return self.alphabet_to_idx['PAD'] + + @property + def unk(self): + return self.alphabet_to_idx['UNK'] + +class StringDataset: + def __init__(self, vocab, data, target, device, add_bos=False, add_eos=False): + """ + Arguments: + vocab: CharVocab instance for tokenization + data (list): SMILES/SELFIES strings for the datasety + target (arra): Array of target values + target (list): + """ + self.data = data + self.target = target + self.vocab = vocab + self.device = device + self.encoded_data = [vocab.encode(s, add_bos, add_eos) for s in data] + + def __len__(self): + """ + Computes a number of objects in the dataset + """ + return len(self.data) + + def __getitem__(self, index): + return torch.tensor(self.encoded_data[index], dtype=torch.long), self.target[index] + + def default_collate(self, batch): + x, y = list(zip(*batch)) + lens = [len(s) for s in x] + x = torch.nn.utils.rnn.pad_sequence(x, batch_first=True, padding_value=self.vocab.pad).to(self.device) + y = torch.tensor(y, dtype=torch.float32, device=self.device) + return x, y, lens + +vocab = smiles_vocabulary() +x_train, y_train, x_test, y_test = get_dataset() +train_dataset = StringDataset(vocab, x_train, y_train, device='cuda') +train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, drop_last=False, collate_fn=train_dataset.default_collate) + +val_dataset = StringDataset(vocab, x_test, y_test, device='cuda') +val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False, drop_last=False, collate_fn=train_dataset.default_collate) + + +model = CharRNN(vocab, device='cuda') +model.train() +def get_params(): + return (p for p in model.parameters() if p.requires_grad) +optimizer = optim.Adam(get_params(), lr=1e-3) +scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.5) + +model.eval() +with torch.no_grad(): + for step, (x, y, lens) in enumerate(val_loader): + preds = model(x, lens) + loss = F.mse_loss(preds, y) + print('val loss = ', loss) + +model.train() +for step, (x, y, lens) in enumerate(train_loader): + preds = model(x, lens) + loss = F.mse_loss(preds, y) + optimizer.zero_grad() + loss.backward() + optimizer.step() + print('train loss = ', loss) + + + +scheduler.step() diff --git a/requirements.txt b/requirements.txt index c1e16ec..03b1cb4 100644 --- a/requirements.txt +++ b/requirements.txt @@ -12,6 +12,7 @@ importlib-resources==5.10.2 numpy==1.24.1 omegaconf==2.3.0 packaging==23.0 +pandas==1.5.3 pathtools==0.1.2 Pillow==9.4.0 protobuf==4.21.12 From ecb8136282d025eff8ba094c6adb8d53d5df6ea6 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Wed, 22 Feb 2023 22:07:28 +0530 Subject: [PATCH 07/34] adding regression --- regression/cfgs/config.yaml | 43 ++++++ regression/data.py | 175 +++++++++++++++++++++++ regression/models.py | 24 ++-- regression/regression.py | 278 ++++++++++++------------------------ 4 files changed, 324 insertions(+), 196 deletions(-) create mode 100644 regression/cfgs/config.yaml create mode 100644 regression/data.py diff --git a/regression/cfgs/config.yaml b/regression/cfgs/config.yaml new file mode 100644 index 0000000..f90ce1f --- /dev/null +++ b/regression/cfgs/config.yaml @@ -0,0 +1,43 @@ +#common +target: 'ESR2' +string_rep: 'smiles' +data_path: 'data/filtered_dockstring-dataset.tsv' +splits_path: 'data/filtered_cluster_split.tsv' +vocab_path: 'data/dockstring_smiles_vocabulary.txt' + +#learning +lr: 1e-3 +seed: 1 +device: 'cuda' +num_epochs: 10 +batch_size: 64 + +model_name: 'char_rnn' +vocab_size: +pad_idx: + +#CharRNN +charrnn: + _target_: models.CharRNN + vocab_size: ${vocab_size} + pad_idx: ${pad_idx} + device: ${device} + num_layers: 3 + hidden_size: 256 + embedding_size: 32 + dropout: 0.2 + +#eval +eval_interval: 100 + +#logging +wandb_log: False +wandb_entity: 'raj19' +wandb_run_name: 'docking-regression' +log_interval: 100 + +hydra: + run: + dir: ./local_exp/${now:%Y.%m.%d}/${now:%H.%M.%S}_${seed} + job: + chdir: False \ No newline at end of file diff --git a/regression/data.py b/regression/data.py new file mode 100644 index 0000000..11dcd67 --- /dev/null +++ b/regression/data.py @@ -0,0 +1,175 @@ +import re +import torch +import numpy as np +import pandas as pd +import selfies as sf + +from torch.utils.data import DataLoader + +def replace_halogen(string): + """Regex to replace Br and Cl with single letters""" + br = re.compile('Br') + cl = re.compile('Cl') + string = br.sub('R', string) + string = cl.sub('L', string) + + return string + +class smiles_vocabulary(object): + def __init__(self, vocab_path='data/dockstring_smiles_vocabulary.txt'): + + self.alphabet = set() + with open(vocab_path, 'r') as f: + chars = f.read().split() + for char in chars: + self.alphabet.add(char) + + self.special_tokens = ['BOS', 'EOS', 'PAD', 'UNK'] + + self.alphabet_list = list(self.alphabet) + self.alphabet_list.sort() + self.alphabet_list = self.alphabet_list + self.special_tokens + self.alphabet_length = len(self.alphabet_list) + + self.alphabet_to_idx = {s: i for i, s in enumerate(self.alphabet_list)} + self.idx_to_alphabet = {s: i for i, s in self.alphabet_to_idx.items()} + + def tokenize(self, smiles, add_bos=False, add_eos=False): + """Takes a SMILES and return a list of characters/tokens""" + regex = '(\[[^\[\]]{1,6}\])' + smiles = replace_halogen(smiles) + char_list = re.split(regex, smiles) + tokenized = [] + for char in char_list: + if char.startswith('['): + tokenized.append(char) + else: + chars = [unit for unit in char] + [tokenized.append(unit) for unit in chars] + if add_bos: + tokenized.insert(0, "BOS") + if add_eos: + tokenized.append('EOS') + return tokenized + + def encode(self, smiles, add_bos=False, add_eos=False): + """Takes a list of SMILES and encodes to array of indices""" + char_list = self.tokenize(smiles, add_bos, add_eos) + encoded_smiles = np.zeros(len(char_list), dtype=np.uint8) + for i, char in enumerate(char_list): + encoded_smiles[i] = self.alphabet_to_idx[char] + return encoded_smiles + + def decode(self, encoded_smiles, rem_bos=True, rem_eos=True): + """Takes an array of indices and returns the corresponding SMILES""" + if rem_bos and encoded_smiles[0] == self.bos: + encoded_smiles = encoded_smiles[1:] + if rem_eos and encoded_smiles[-1] == self.eos: + encoded_smiles = encoded_smiles[:-1] + + chars = [] + for i in encoded_smiles: + chars.append(self.idx_to_alphabet[i]) + smiles = "".join(chars) + smiles = smiles.replace("L", "Cl").replace("R", "Br") + return smiles + + def __len__(self): + return len(self.alphabet_to_idx) + + @property + def bos(self): + return self.alphabet_to_idx['BOS'] + + @property + def eos(self): + return self.alphabet_to_idx['EOS'] + + @property + def pad(self): + return self.alphabet_to_idx['PAD'] + + @property + def unk(self): + return self.alphabet_to_idx['UNK'] + +class StringDataset: + def __init__(self, vocab, data, target, device, add_bos=False, add_eos=False): + """ + Arguments: + vocab: CharVocab instance for tokenization + data (list): SMILES/SELFIES strings for the datasety + target (arra): Array of target values + target (list): + """ + self.data = data + self.target = target + self.vocab = vocab + self.device = device + self.encoded_data = [vocab.encode(s, add_bos, add_eos) for s in data] + + def __len__(self): + """ + Computes a number of objects in the dataset + """ + return len(self.data) + + def __getitem__(self, index): + return torch.tensor(self.encoded_data[index], dtype=torch.long), self.target[index] + + def get_collate_fn(self, model_name): + if model_name == 'char_rnn': + def collate_fn(batch): + x, y = list(zip(*batch)) + lens = [len(s) for s in x] + x = torch.nn.utils.rnn.pad_sequence(x, batch_first=True, padding_value=self.vocab.pad).to(self.device) + y = torch.tensor(y, dtype=torch.float32, device=self.device) + return x, y, lens + return collate_fn + else: + raise NotImplementedError + +def get_data(cfg): + data_path=cfg.data_path + splits_path=cfg.splits_path + target=cfg.target + string_rep=cfg.string_rep + batch_size=cfg.batch_size + + assert target in ['ESR2', 'F2', 'KIT', 'PARP1', 'PGR'] + dockstring_df = pd.read_csv(data_path) + dockstring_splits = pd.read_csv(splits_path) + + bond_constraints = sf.get_semantic_constraints() + bond_constraints['I'] = 5 + sf.set_semantic_constraints(bond_constraints) + + assert np.all(dockstring_splits.smiles == dockstring_df.smiles) + assert sf.get_semantic_constraints()['I'] == 5 + + df_train = dockstring_df[dockstring_splits["split"] == "train"].dropna(subset=[target]) + df_test = dockstring_df[dockstring_splits["split"] == "test"].dropna(subset=[target]) + + y_train = df_train[target].values + y_test = df_test[target].values + + y_train = np.minimum(y_train, 5.0) + y_test = np.minimum(y_test, 5.0) + + if string_rep == 'smiles': + x_train = list(df_train['canon_smiles']) + x_test = list(df_test['canon_smiles']) + vocab = smiles_vocabulary(cfg.vocab_path) + elif string_rep == 'selfies': + assert sf == 1 + x_train = list(df_train['selfies']) + x_test = list(df_test['selifes']) + else: + raise NotImplementedError + + train_dataset = StringDataset(vocab, x_train, y_train, device='cuda') + train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, drop_last=False, collate_fn=train_dataset.get_collate_fn(cfg.model_name)) + val_dataset = StringDataset(vocab, x_test, y_test, device='cuda') + val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, drop_last=False, collate_fn=train_dataset.get_collate_fn(cfg.model_name)) + + return train_loader, val_loader, vocab \ No newline at end of file diff --git a/regression/models.py b/regression/models.py index e3e25eb..1790930 100644 --- a/regression/models.py +++ b/regression/models.py @@ -3,23 +3,27 @@ import torch.nn.functional as F import torch.nn.utils.rnn as rnn_utils -class CharRNN(nn.Module): - def __init__(self, vocabulary, device): - super(CharRNN, self).__init__() +def count_parameters(model): + return sum(p.numel() for p in model.parameters() if p.requires_grad) +class CharMLP(nn.Module): + def __init__(self, vocabulary, device): + super(CharMLP, self).__init__() self.vocabulary = vocabulary - self.hidden_size = 256 + self.hidden_size = 786 self.num_layers = 3 self.dropout = 0.2 self.device = device self.vocab_size = self.input_size = len(vocabulary) - self.embedding_layer = nn.Embedding(self.vocab_size, 32, - padding_idx=vocabulary.pad).to(self.device) - self.lstm_layer = nn.LSTM(32, self.hidden_size, - self.num_layers, dropout=0.2, - batch_first=True).to(self.device) - self.linear_layer = nn.Linear(self.hidden_size, 1).to(self.device) +class CharRNN(nn.Module): + def __init__(self, vocab_size, pad_idx, embedding_size, num_layers, hidden_size, dropout, device): + super(CharRNN, self).__init__() + + self.device = device + self.embedding_layer = nn.Embedding(vocab_size, embedding_size, padding_idx=pad_idx).to(self.device) + self.lstm_layer = nn.LSTM(embedding_size, hidden_size, num_layers, dropout=dropout, batch_first=True).to(self.device) + self.linear_layer = nn.Linear(hidden_size, 1).to(self.device) def forward(self, x, lengths, hiddens=None): x = self.embedding_layer(x) diff --git a/regression/regression.py b/regression/regression.py index 693f114..41868bc 100644 --- a/regression/regression.py +++ b/regression/regression.py @@ -1,198 +1,104 @@ -import re +import hydra +import wandb import torch -import torch.nn as nn import torch.optim as optim import torch.nn.functional as F -from torch.utils.data import DataLoader -import numpy as np -import pandas as pd -import selfies as sf -from pathlib import Path -from models import CharRNN +import sklearn.metrics +from omegaconf import DictConfig +from data import get_data -def get_dataset(data_path='data/filtered_dockstring-dataset.tsv', splits_path='data/filtered_cluster_split.tsv', target='ESR2', string_rep='SMILES'): - assert target in ['ESR2', 'F2', 'KIT', 'PARP1', 'PGR'] - dockstring_df = pd.read_csv(data_path) - dockstring_splits = pd.read_csv(splits_path) +class Averager(): + def __init__(self): + self.n = 0 + self.v = 0 - bond_constraints = sf.get_semantic_constraints() - bond_constraints['I'] = 5 - sf.set_semantic_constraints(bond_constraints) + def add(self, x): + self.v = (self.v * self.n + x) / (self.n + 1) + self.n += 1 - assert np.all(dockstring_splits.smiles == dockstring_df.smiles) - assert sf.get_semantic_constraints()['I'] == 5 + def item(self): + return self.v - df_train = dockstring_df[dockstring_splits["split"] == "train"].dropna(subset=[target]) - df_test = dockstring_df[dockstring_splits["split"] == "test"].dropna(subset=[target]) - - y_train = df_train[target].values - y_test = df_test[target].values - - y_train = np.minimum(y_train, 5.0) - y_test = np.minimum(y_test, 5.0) - - if string_rep == 'SMILES': - x_train = list(df_train['canon_smiles']) - x_test = list(df_test['canon_smiles']) - elif string_rep == 'SELFIES': - assert sf == 1 - x_train = list(df_train['selfies']) - x_test = list(df_test['selifes']) - else: - raise NotImplementedError +def count_parameters(model): + return sum(p.numel() for p in model.parameters() if p.requires_grad) - return x_train, y_train, x_test, y_test - -def replace_halogen(string): - """Regex to replace Br and Cl with single letters""" - br = re.compile('Br') - cl = re.compile('Cl') - string = br.sub('R', string) - string = cl.sub('L', string) - - return string - -class smiles_vocabulary(object): - def __init__(self, vocab_path='data/dockstring_smiles_vocabulary.txt'): - - self.alphabet = set() - with open(vocab_path, 'r') as f: - chars = f.read().split() - for char in chars: - self.alphabet.add(char) - - self.special_tokens = ['BOS', 'EOS', 'PAD', 'UNK'] - - self.alphabet_list = list(self.alphabet) - self.alphabet_list.sort() - self.alphabet_list = self.alphabet_list + self.special_tokens - self.alphabet_length = len(self.alphabet_list) - - self.alphabet_to_idx = {s: i for i, s in enumerate(self.alphabet_list)} - self.idx_to_alphabet = {s: i for i, s in self.alphabet_to_idx.items()} - - def tokenize(self, smiles, add_bos=False, add_eos=False): - """Takes a SMILES and return a list of characters/tokens""" - regex = '(\[[^\[\]]{1,6}\])' - smiles = replace_halogen(smiles) - char_list = re.split(regex, smiles) - tokenized = [] - for char in char_list: - if char.startswith('['): - tokenized.append(char) - else: - chars = [unit for unit in char] - [tokenized.append(unit) for unit in chars] - if add_bos: - tokenized.insert(0, "BOS") - if add_eos: - tokenized.append('EOS') - return tokenized - - def encode(self, smiles, add_bos=False, add_eos=False): - """Takes a list of SMILES and encodes to array of indices""" - char_list = self.tokenize(smiles, add_bos, add_eos) - encoded_smiles = np.zeros(len(char_list), dtype=np.uint8) - for i, char in enumerate(char_list): - encoded_smiles[i] = self.alphabet_to_idx[char] - return encoded_smiles - - def decode(self, encoded_smiles, rem_bos=True, rem_eos=True): - """Takes an array of indices and returns the corresponding SMILES""" - if rem_bos and encoded_smiles[0] == self.bos: - encoded_smiles = encoded_smiles[1:] - if rem_eos and encoded_smiles[-1] == self.eos: - encoded_smiles = encoded_smiles[:-1] - - chars = [] - for i in encoded_smiles: - chars.append(self.idx_to_alphabet[i]) - smiles = "".join(chars) - smiles = smiles.replace("L", "Cl").replace("R", "Br") - return smiles - - def __len__(self): - return len(self.alphabet_to_idx) - - @property - def bos(self): - return self.alphabet_to_idx['BOS'] - - @property - def eos(self): - return self.alphabet_to_idx['EOS'] - - @property - def pad(self): - return self.alphabet_to_idx['PAD'] - - @property - def unk(self): - return self.alphabet_to_idx['UNK'] - -class StringDataset: - def __init__(self, vocab, data, target, device, add_bos=False, add_eos=False): - """ - Arguments: - vocab: CharVocab instance for tokenization - data (list): SMILES/SELFIES strings for the datasety - target (arra): Array of target values - target (list): - """ - self.data = data - self.target = target - self.vocab = vocab - self.device = device - self.encoded_data = [vocab.encode(s, add_bos, add_eos) for s in data] - - def __len__(self): - """ - Computes a number of objects in the dataset - """ - return len(self.data) - - def __getitem__(self, index): - return torch.tensor(self.encoded_data[index], dtype=torch.long), self.target[index] - - def default_collate(self, batch): - x, y = list(zip(*batch)) - lens = [len(s) for s in x] - x = torch.nn.utils.rnn.pad_sequence(x, batch_first=True, padding_value=self.vocab.pad).to(self.device) - y = torch.tensor(y, dtype=torch.float32, device=self.device) - return x, y, lens - -vocab = smiles_vocabulary() -x_train, y_train, x_test, y_test = get_dataset() -train_dataset = StringDataset(vocab, x_train, y_train, device='cuda') -train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, drop_last=False, collate_fn=train_dataset.default_collate) - -val_dataset = StringDataset(vocab, x_test, y_test, device='cuda') -val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False, drop_last=False, collate_fn=train_dataset.default_collate) - - -model = CharRNN(vocab, device='cuda') -model.train() -def get_params(): +def get_params(model): return (p for p in model.parameters() if p.requires_grad) -optimizer = optim.Adam(get_params(), lr=1e-3) -scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.5) - -model.eval() -with torch.no_grad(): - for step, (x, y, lens) in enumerate(val_loader): - preds = model(x, lens) - loss = F.mse_loss(preds, y) - print('val loss = ', loss) -model.train() -for step, (x, y, lens) in enumerate(train_loader): - preds = model(x, lens) - loss = F.mse_loss(preds, y) - optimizer.zero_grad() - loss.backward() - optimizer.step() - print('train loss = ', loss) +def train(cfg): + #get trainloader + train_loader, val_loader, vocab = get_data(cfg) + #get model + cfg.vocab_size = len(vocab) + cfg.pad_idx = vocab.pad + if cfg.model_name == 'char_rnn': + model = hydra.utils.instantiate(cfg.charrnn) + else: + raise NotImplementedError - -scheduler.step() + #set optimizer + optimizer = optim.Adam(get_params(model), lr=cfg.lr) + scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=cfg.num_epochs, eta_min=0.0) + + num_params = count_parameters(model) + print('The model has ', num_params, ' number of trainable parameters.') + + avg_train_loss = Averager() + for epoch in range(cfg.num_epochs): + metrics = dict() + for step, (x, y, lens) in enumerate(train_loader): + preds = model(x, lens) + loss = F.mse_loss(preds, y) + optimizer.zero_grad() + loss.backward() + optimizer.step() + avg_train_loss.add(loss.item()) + + if step % cfg.eval_interval == 0: + metrics.update( + eval(model, val_loader)) + print('Epoch = ', epoch, 'Step = ', step, ' r2_score time = ', metrics['r2 score']) + model.train() + + if cfg.wandb_log and step % cfg.log_interval==0: + metrics['train loss'] = avg_train_loss.item() + metrics['lr'] = scheduler.get_last_lr()[0] + metrics['epoch'] = epoch + avg_train_loss = Averager() + wandb.log(metrics) + scheduler.step() + +def eval(model, val_loader): + metrics = dict() + preds_list = [] + targets_list = [] + avg_loss = Averager() + model.eval() + with torch.no_grad(): + for step, (x, y, lens) in enumerate(val_loader): + preds = model(x, lens) + preds_list.append(preds) + targets_list.append(y) + loss = F.mse_loss(preds, y) + avg_loss.add(loss.item()) + + preds_list = torch.cat(preds_list).tolist() + targets_list = torch.cat(targets_list).tolist() + r2_score = sklearn.metrics.r2_score(y_true = targets_list, y_pred = preds_list) + metrics['r2 score'] = r2_score + metrics['val loss'] = avg_loss.item() + return metrics + +@hydra.main(config_path='cfgs', config_name='config', version_base=None) +def main(cfg: DictConfig): + hydra_cfg = hydra.core.hydra_config.HydraConfig.get() + from regression import train + if cfg.wandb_log: + project_name = 'docking-regression-' + cfg.target + wandb.init(project=project_name, entity=cfg.wandb_entity, config=dict(cfg), dir=hydra_cfg['runtime']['output_dir']) + wandb.run.name = cfg.wandb_run_name + train(cfg) + +if __name__ == '__main__': + main() \ No newline at end of file From a569eb878ae1e836ddb5c3b84891d793f9cfc786 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Thu, 23 Feb 2023 00:24:23 +0530 Subject: [PATCH 08/34] adding regression --- regression/regression.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/regression/regression.py b/regression/regression.py index 41868bc..ed4ecc6 100644 --- a/regression/regression.py +++ b/regression/regression.py @@ -38,7 +38,8 @@ def train(cfg): raise NotImplementedError #set optimizer - optimizer = optim.Adam(get_params(model), lr=cfg.lr) + # optimizer = optim.Adam(get_params(model), lr=cfg.lr) + optimizer = optim.SGD(get_params(model), cfg.lr, momentum=0.9, weight_decay=5e-4) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=cfg.num_epochs, eta_min=0.0) num_params = count_parameters(model) @@ -68,6 +69,10 @@ def train(cfg): avg_train_loss = Averager() wandb.log(metrics) scheduler.step() + + metrics.update( + eval(model, val_loader)) + print('Epoch = ', epoch, 'Step = ', step, ' r2_score time = ', metrics['r2 score']) def eval(model, val_loader): metrics = dict() From 2eed3e9fdb6f07c44031a9fc4351e2568afa3ff6 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Thu, 23 Feb 2023 10:17:57 +0530 Subject: [PATCH 09/34] adding mila script --- regression/regression.py | 3 +-- regression/requirements_extra.txt | 1 + regression/scripts/mila/1.sh | 23 +++++++++++++++++++++++ 3 files changed, 25 insertions(+), 2 deletions(-) create mode 100644 regression/requirements_extra.txt create mode 100644 regression/scripts/mila/1.sh diff --git a/regression/regression.py b/regression/regression.py index ed4ecc6..99c507c 100644 --- a/regression/regression.py +++ b/regression/regression.py @@ -38,8 +38,7 @@ def train(cfg): raise NotImplementedError #set optimizer - # optimizer = optim.Adam(get_params(model), lr=cfg.lr) - optimizer = optim.SGD(get_params(model), cfg.lr, momentum=0.9, weight_decay=5e-4) + optimizer = optim.Adam(get_params(model), lr=cfg.lr, eps=1e-4) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=cfg.num_epochs, eta_min=0.0) num_params = count_parameters(model) diff --git a/regression/requirements_extra.txt b/regression/requirements_extra.txt new file mode 100644 index 0000000..66d3106 --- /dev/null +++ b/regression/requirements_extra.txt @@ -0,0 +1 @@ +scikit-learn==1.0.2 \ No newline at end of file diff --git a/regression/scripts/mila/1.sh b/regression/scripts/mila/1.sh new file mode 100644 index 0000000..2b3ad17 --- /dev/null +++ b/regression/scripts/mila/1.sh @@ -0,0 +1,23 @@ +#!/bin/bash + +#SBATCH -t 30:00 +#SBATCH -c 4 +#SBATCH --partition=lab-real +#SBATCH --mem=4G +#SBATCH --gres=gpu:1 +#SBATCH --array=1-3 + +array=(-1 "ESR2", "F2", "KIT", "PARP1", "PGR") + +module --quiet load anaconda/3 +conda activate rl4chem +echo "activated conda environment" + +rsync -a $HOME/RL4Chem/ $SLURM_TMPDIR/RL4Chem +echo "moved code to slurm tmpdir" + +cd $SLURM_TMPDIR/RL4Chem/regression + +python regression.py target=${array[SLURM_ARRAY_TASK_ID]} seed=1 wandb_log=True wandb_run_name=adam_charnn_1 & +python regression.py target=${array[SLURM_ARRAY_TASK_ID]} seed=2 wandb_log=True wandb_run_name=adam_charnn_2 & +python regression.py target=${array[SLURM_ARRAY_TASK_ID]} seed=3 wandb_log=True wandb_run_name=adam_charnn_3 & \ No newline at end of file From f31a5b794614a9e7713581185d129ecbdc67ce11 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Thu, 23 Feb 2023 11:22:29 +0530 Subject: [PATCH 10/34] adding cedar scripts --- regression/cfgs/config.yaml | 1 + regression/regression.py | 5 +++++ regression/scripts/cedar/1.sh | 16 ++++++++++++++++ regression/scripts/mila/1.sh | 14 +++++++------- 4 files changed, 29 insertions(+), 7 deletions(-) create mode 100644 regression/scripts/cedar/1.sh diff --git a/regression/cfgs/config.yaml b/regression/cfgs/config.yaml index f90ce1f..95ed7e8 100644 --- a/regression/cfgs/config.yaml +++ b/regression/cfgs/config.yaml @@ -11,6 +11,7 @@ seed: 1 device: 'cuda' num_epochs: 10 batch_size: 64 +max_grad_norm: 0.5 model_name: 'char_rnn' vocab_size: diff --git a/regression/regression.py b/regression/regression.py index 99c507c..4853a17 100644 --- a/regression/regression.py +++ b/regression/regression.py @@ -1,6 +1,7 @@ import hydra import wandb import torch +import torch.nn as nn import torch.optim as optim import torch.nn.functional as F import sklearn.metrics @@ -45,6 +46,7 @@ def train(cfg): print('The model has ', num_params, ' number of trainable parameters.') avg_train_loss = Averager() + avg_grad_norm = Averager() for epoch in range(cfg.num_epochs): metrics = dict() for step, (x, y, lens) in enumerate(train_loader): @@ -52,8 +54,10 @@ def train(cfg): loss = F.mse_loss(preds, y) optimizer.zero_grad() loss.backward() + grad_norm = nn.utils.clip_grad_norm_(model.parameters(), cfg.max_grad_norm) optimizer.step() avg_train_loss.add(loss.item()) + avg_grad_norm.add(grad_norm.item()) if step % cfg.eval_interval == 0: metrics.update( @@ -63,6 +67,7 @@ def train(cfg): if cfg.wandb_log and step % cfg.log_interval==0: metrics['train loss'] = avg_train_loss.item() + metrics['average grad norm'] = avg_grad_norm.item() metrics['lr'] = scheduler.get_last_lr()[0] metrics['epoch'] = epoch avg_train_loss = Averager() diff --git a/regression/scripts/cedar/1.sh b/regression/scripts/cedar/1.sh new file mode 100644 index 0000000..68a4bac --- /dev/null +++ b/regression/scripts/cedar/1.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +#SBATCH --account=rrg-gberseth +#SBATCH --time=00:30:00 +#SBATCH --cpus-per-task=4 +#SBATCH --mem=4G +#SBATCH --gres=gpu:v100l:1 +#SBATCH --array=1-3 + +array=(-1 "0.5" "10" "100") + +rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem +echo "moved code to slurm tmpdir" + +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem && pip install scikit-learn==1.0.2 &&\ +python regression.py max_grad_norm=${array[SLURM_ARRAY_TASK_ID]} seed=1 wandb_log=True wandb_run_name=${array[SLURM_ARRAY_TASK_ID]}_charnn_1" \ No newline at end of file diff --git a/regression/scripts/mila/1.sh b/regression/scripts/mila/1.sh index 2b3ad17..a0e267b 100644 --- a/regression/scripts/mila/1.sh +++ b/regression/scripts/mila/1.sh @@ -1,13 +1,13 @@ #!/bin/bash -#SBATCH -t 30:00 +#SBATCH -t 00:30:00 #SBATCH -c 4 -#SBATCH --partition=lab-real +#SBATCH --partition=unkillable #SBATCH --mem=4G #SBATCH --gres=gpu:1 #SBATCH --array=1-3 -array=(-1 "ESR2", "F2", "KIT", "PARP1", "PGR") +array=(-1 "ESR2" "F2" "KIT" "PARP1" "PGR") module --quiet load anaconda/3 conda activate rl4chem @@ -16,8 +16,8 @@ echo "activated conda environment" rsync -a $HOME/RL4Chem/ $SLURM_TMPDIR/RL4Chem echo "moved code to slurm tmpdir" -cd $SLURM_TMPDIR/RL4Chem/regression -python regression.py target=${array[SLURM_ARRAY_TASK_ID]} seed=1 wandb_log=True wandb_run_name=adam_charnn_1 & -python regression.py target=${array[SLURM_ARRAY_TASK_ID]} seed=2 wandb_log=True wandb_run_name=adam_charnn_2 & -python regression.py target=${array[SLURM_ARRAY_TASK_ID]} seed=3 wandb_log=True wandb_run_name=adam_charnn_3 & \ No newline at end of file +cd $SLURM_TMPDIR/RL4Chem/regression +python regression.py target=${array[SLURM_ARRAY_TASK_ID]} seed=1 wandb_log=True wandb_run_name=adam_charnn_1& +python regression.py target=${array[SLURM_ARRAY_TASK_ID]} seed=2 wandb_log=True wandb_run_name=adam_charnn_2& +python regression.py target=${array[SLURM_ARRAY_TASK_ID]} seed=3 wandb_log=True wandb_run_name=adam_charnn_3 \ No newline at end of file From 3eefc6fde9da769be01f3e9958b1f9cebbd7a49b Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Thu, 23 Feb 2023 11:40:20 +0530 Subject: [PATCH 11/34] adding mila scripts --- regression/scripts/mila/1.sh | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/regression/scripts/mila/1.sh b/regression/scripts/mila/1.sh index a0e267b..d35b13b 100644 --- a/regression/scripts/mila/1.sh +++ b/regression/scripts/mila/1.sh @@ -2,12 +2,12 @@ #SBATCH -t 00:30:00 #SBATCH -c 4 -#SBATCH --partition=unkillable +#SBATCH --partition=main #SBATCH --mem=4G #SBATCH --gres=gpu:1 #SBATCH --array=1-3 -array=(-1 "ESR2" "F2" "KIT" "PARP1" "PGR") +array=(-1 "0.5" "10" "100") module --quiet load anaconda/3 conda activate rl4chem @@ -16,8 +16,5 @@ echo "activated conda environment" rsync -a $HOME/RL4Chem/ $SLURM_TMPDIR/RL4Chem echo "moved code to slurm tmpdir" - cd $SLURM_TMPDIR/RL4Chem/regression -python regression.py target=${array[SLURM_ARRAY_TASK_ID]} seed=1 wandb_log=True wandb_run_name=adam_charnn_1& -python regression.py target=${array[SLURM_ARRAY_TASK_ID]} seed=2 wandb_log=True wandb_run_name=adam_charnn_2& -python regression.py target=${array[SLURM_ARRAY_TASK_ID]} seed=3 wandb_log=True wandb_run_name=adam_charnn_3 \ No newline at end of file +python regression.py max_grad_norm=${array[SLURM_ARRAY_TASK_ID]} seed=1 wandb_log=True wandb_run_name=${array[SLURM_ARRAY_TASK_ID]}_charnn_1 \ No newline at end of file From 323f2d58245d98ba10edffd5bd770ba0f5e4d619 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Thu, 23 Feb 2023 12:13:25 +0530 Subject: [PATCH 12/34] adding cedar scripts --- regression/scripts/cedar/1.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/regression/scripts/cedar/1.sh b/regression/scripts/cedar/1.sh index 68a4bac..b9fd5e4 100644 --- a/regression/scripts/cedar/1.sh +++ b/regression/scripts/cedar/1.sh @@ -12,5 +12,5 @@ array=(-1 "0.5" "10" "100") rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem echo "moved code to slurm tmpdir" -singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem && pip install scikit-learn==1.0.2 &&\ -python regression.py max_grad_norm=${array[SLURM_ARRAY_TASK_ID]} seed=1 wandb_log=True wandb_run_name=${array[SLURM_ARRAY_TASK_ID]}_charnn_1" \ No newline at end of file +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem && pip install scikit-learn &&\ +python regression.py max_grad_norm=0.5 seed=1 wandb_log=True wandb_run_name=0.5_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file From 9dd774975edbf5320d0f31d7add1b7e53a405d13 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Thu, 23 Feb 2023 12:21:54 +0530 Subject: [PATCH 13/34] adding cedar scripts --- regression/scripts/cedar/1.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/regression/scripts/cedar/1.sh b/regression/scripts/cedar/1.sh index b9fd5e4..100127e 100644 --- a/regression/scripts/cedar/1.sh +++ b/regression/scripts/cedar/1.sh @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem && pip install scikit-learn &&\ -python regression.py max_grad_norm=0.5 seed=1 wandb_log=True wandb_run_name=0.5_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python regression.py max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0.5_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file From bf6e7dbc913b66cb129561c587789d043685e31a Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Thu, 23 Feb 2023 12:31:18 +0530 Subject: [PATCH 14/34] add scripts --- regression/cfgs/config.yaml | 3 +- regression/data.py | 93 +++++++++++++++++++++++++++++++---- regression/scripts/cedar/1.sh | 2 +- regression/scripts/cedar/2.sh | 16 ++++++ regression/scripts/mila/1.sh | 2 +- 5 files changed, 102 insertions(+), 14 deletions(-) create mode 100644 regression/scripts/cedar/2.sh diff --git a/regression/cfgs/config.yaml b/regression/cfgs/config.yaml index 95ed7e8..ad1704f 100644 --- a/regression/cfgs/config.yaml +++ b/regression/cfgs/config.yaml @@ -1,9 +1,8 @@ #common target: 'ESR2' -string_rep: 'smiles' +string_rep: 'selfies' data_path: 'data/filtered_dockstring-dataset.tsv' splits_path: 'data/filtered_cluster_split.tsv' -vocab_path: 'data/dockstring_smiles_vocabulary.txt' #learning lr: 1e-3 diff --git a/regression/data.py b/regression/data.py index 11dcd67..dd70fb5 100644 --- a/regression/data.py +++ b/regression/data.py @@ -15,6 +15,77 @@ def replace_halogen(string): return string +class selfies_vocabulary(object): + def __init__(self, vocab_path='data/dockstring_selfies_vocabulary.txt', robust_alphabet=False): + + if robust_alphabet: + self.alphabet = sf.get_semantic_robust_alphabet() + else: + self.alphabet = set() + with open(vocab_path, 'r') as f: + chars = f.read().split() + for char in chars: + self.alphabet.add(char) + + self.special_tokens = ['BOS', 'EOS', 'PAD', 'UNK'] + + self.alphabet_list = list(self.alphabet) + self.alphabet_list.sort() + self.alphabet_list = self.alphabet_list + self.special_tokens + self.alphabet_length = len(self.alphabet_list) + + self.alphabet_to_idx = {s: i for i, s in enumerate(self.alphabet_list)} + self.idx_to_alphabet = {s: i for i, s in self.alphabet_to_idx.items()} + + def tokenize(self, selfies, add_bos=False, add_eos=False): + """Takes a SELFIES and return a list of characters/tokens""" + tokenized = list(sf.split_selfies(selfies)) + if add_bos: + tokenized.insert(0, "BOS") + if add_eos: + tokenized.append('EOS') + return tokenized + + def encode(self, selfies, add_bos=False, add_eos=False): + """Takes a list of SELFIES and encodes to array of indices""" + char_list = self.tokenize(selfies, add_bos, add_eos) + encoded_selfies = np.zeros(len(char_list), dtype=np.uint8) + for i, char in enumerate(char_list): + encoded_selfies[i] = self.alphabet_to_idx[char] + return encoded_selfies + + def decode(self, encoded_seflies, rem_bos=True, rem_eos=True): + """Takes an array of indices and returns the corresponding SELFIES""" + if rem_bos and encoded_seflies[0] == self.bos: + encoded_seflies = encoded_seflies[1:] + if rem_eos and encoded_seflies[-1] == self.eos: + encoded_seflies = encoded_seflies[:-1] + + chars = [] + for i in encoded_seflies: + chars.append(self.idx_to_alphabet[i]) + selfies = "".join(chars) + return selfies + + def __len__(self): + return len(self.alphabet_to_idx) + + @property + def bos(self): + return self.alphabet_to_idx['BOS'] + + @property + def eos(self): + return self.alphabet_to_idx['EOS'] + + @property + def pad(self): + return self.alphabet_to_idx['PAD'] + + @property + def unk(self): + return self.alphabet_to_idx['UNK'] + class smiles_vocabulary(object): def __init__(self, vocab_path='data/dockstring_smiles_vocabulary.txt'): @@ -140,13 +211,8 @@ def get_data(cfg): dockstring_df = pd.read_csv(data_path) dockstring_splits = pd.read_csv(splits_path) - bond_constraints = sf.get_semantic_constraints() - bond_constraints['I'] = 5 - sf.set_semantic_constraints(bond_constraints) - assert np.all(dockstring_splits.smiles == dockstring_df.smiles) - assert sf.get_semantic_constraints()['I'] == 5 - + df_train = dockstring_df[dockstring_splits["split"] == "train"].dropna(subset=[target]) df_test = dockstring_df[dockstring_splits["split"] == "test"].dropna(subset=[target]) @@ -159,11 +225,18 @@ def get_data(cfg): if string_rep == 'smiles': x_train = list(df_train['canon_smiles']) x_test = list(df_test['canon_smiles']) - vocab = smiles_vocabulary(cfg.vocab_path) + vocab = smiles_vocabulary() + elif string_rep == 'selfies': - assert sf == 1 - x_train = list(df_train['selfies']) - x_test = list(df_test['selifes']) + assert sf.__version__ == '2.1.0' + bond_constraints = sf.get_semantic_constraints() + bond_constraints['I'] = 5 + sf.set_semantic_constraints(bond_constraints) + assert sf.get_semantic_constraints()['I'] == 5 + + x_train = list(df_train['selfies_'+sf.__version__]) + x_test = list(df_test['selfies_'+sf.__version__]) + vocab = selfies_vocabulary() else: raise NotImplementedError diff --git a/regression/scripts/cedar/1.sh b/regression/scripts/cedar/1.sh index 100127e..56da831 100644 --- a/regression/scripts/cedar/1.sh +++ b/regression/scripts/cedar/1.sh @@ -12,5 +12,5 @@ array=(-1 "0.5" "10" "100") rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem echo "moved code to slurm tmpdir" -singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem && pip install scikit-learn &&\ +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install scikit-learn &&\ python regression.py max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0.5_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/2.sh b/regression/scripts/cedar/2.sh new file mode 100644 index 0000000..26be8c9 --- /dev/null +++ b/regression/scripts/cedar/2.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +#SBATCH --account=rrg-gberseth +#SBATCH --time=00:30:00 +#SBATCH --cpus-per-task=4 +#SBATCH --mem=4G +#SBATCH --gres=gpu:v100l:1 +#SBATCH --array=1-3 + +array=(-1 "0.5" "10" "100") + +rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem +echo "moved code to slurm tmpdir" + +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install scikit-learn &&\ +python regression.py max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/mila/1.sh b/regression/scripts/mila/1.sh index d35b13b..f98c662 100644 --- a/regression/scripts/mila/1.sh +++ b/regression/scripts/mila/1.sh @@ -17,4 +17,4 @@ rsync -a $HOME/RL4Chem/ $SLURM_TMPDIR/RL4Chem echo "moved code to slurm tmpdir" cd $SLURM_TMPDIR/RL4Chem/regression -python regression.py max_grad_norm=${array[SLURM_ARRAY_TASK_ID]} seed=1 wandb_log=True wandb_run_name=${array[SLURM_ARRAY_TASK_ID]}_charnn_1 \ No newline at end of file +python regression.py seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name="selfies_charnn_"$SLURM_ARRAY_TASK_ID \ No newline at end of file From b416e092e41da7c871406b70f5d09f0341db91e1 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Thu, 23 Feb 2023 12:37:09 +0530 Subject: [PATCH 15/34] install pandas --- regression/scripts/cedar/1.sh | 4 ++-- regression/scripts/cedar/2.sh | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/regression/scripts/cedar/1.sh b/regression/scripts/cedar/1.sh index 56da831..5096ef7 100644 --- a/regression/scripts/cedar/1.sh +++ b/regression/scripts/cedar/1.sh @@ -12,5 +12,5 @@ array=(-1 "0.5" "10" "100") rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem echo "moved code to slurm tmpdir" -singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install scikit-learn &&\ -python regression.py max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0.5_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ +python regression.py max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/2.sh b/regression/scripts/cedar/2.sh index 26be8c9..dc45ce2 100644 --- a/regression/scripts/cedar/2.sh +++ b/regression/scripts/cedar/2.sh @@ -12,5 +12,5 @@ array=(-1 "0.5" "10" "100") rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem echo "moved code to slurm tmpdir" -singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install scikit-learn &&\ +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ python regression.py max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file From 8f6ba52931992f8e56fa8ab174b636efd2912d1f Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Thu, 23 Feb 2023 14:02:10 +0530 Subject: [PATCH 16/34] adding fc mlp --- regression/cfgs/config.yaml | 14 ++- regression/char_mlp.py | 108 ++++++++++++++++++++++ regression/{regression.py => char_rnn.py} | 8 +- regression/data.py | 20 +++- regression/models.py | 21 +++-- regression/scripts/cedar/1.sh | 4 +- regression/scripts/cedar/2.sh | 4 +- regression/scripts/cedar/3.sh | 16 ++++ regression/scripts/cedar/4.sh | 16 ++++ 9 files changed, 190 insertions(+), 21 deletions(-) create mode 100644 regression/char_mlp.py rename regression/{regression.py => char_rnn.py} (95%) create mode 100644 regression/scripts/cedar/3.sh create mode 100644 regression/scripts/cedar/4.sh diff --git a/regression/cfgs/config.yaml b/regression/cfgs/config.yaml index ad1704f..dca95bd 100644 --- a/regression/cfgs/config.yaml +++ b/regression/cfgs/config.yaml @@ -11,10 +11,10 @@ device: 'cuda' num_epochs: 10 batch_size: 64 max_grad_norm: 0.5 - -model_name: 'char_rnn' +model_name: vocab_size: pad_idx: +input_size: #CharRNN charrnn: @@ -27,6 +27,16 @@ charrnn: embedding_size: 32 dropout: 0.2 +#CharMLP +charmlp: + _target_: models.CharMLP + vocab_size: ${vocab_size} + pad_idx: ${pad_idx} + device: ${device} + hidden_size: 256 + embedding_size: 32 + input_size: ${input_size} + #eval eval_interval: 100 diff --git a/regression/char_mlp.py b/regression/char_mlp.py new file mode 100644 index 0000000..b85a89b --- /dev/null +++ b/regression/char_mlp.py @@ -0,0 +1,108 @@ +import hydra +import wandb +import torch +import torch.nn as nn +import torch.optim as optim +import torch.nn.functional as F +import sklearn.metrics +from omegaconf import DictConfig +from data import get_data + +class Averager(): + def __init__(self): + self.n = 0 + self.v = 0 + + def add(self, x): + self.v = (self.v * self.n + x) / (self.n + 1) + self.n += 1 + + def item(self): + return self.v + +def count_parameters(model): + return sum(p.numel() for p in model.parameters() if p.requires_grad) + +def get_params(model): + return (p for p in model.parameters() if p.requires_grad) + +def train(cfg): + #get trainloader + train_loader, val_loader, vocab, input_size = get_data(cfg, get_max_len=True) + + #get model + cfg.vocab_size = len(vocab) + cfg.pad_idx = vocab.pad + cfg.input_size = int(input_size) + model = hydra.utils.instantiate(cfg.charmlp) + + #set optimizer + optimizer = optim.Adam(get_params(model), lr=cfg.lr, eps=1e-4) + scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=cfg.num_epochs, eta_min=0.0) + + num_params = count_parameters(model) + print('The model has ', num_params, ' number of trainable parameters.') + + avg_train_loss = Averager() + avg_grad_norm = Averager() + for epoch in range(cfg.num_epochs): + metrics = dict() + for step, (x, y) in enumerate(train_loader): + preds = model(x) + loss = F.mse_loss(preds, y) + optimizer.zero_grad() + loss.backward() + grad_norm = nn.utils.clip_grad_norm_(model.parameters(), cfg.max_grad_norm) + optimizer.step() + avg_train_loss.add(loss.item()) + avg_grad_norm.add(grad_norm.item()) + + if step % cfg.eval_interval == 0: + metrics.update( + eval(model, val_loader)) + print('Epoch = ', epoch, 'Step = ', step, ' r2_score time = ', metrics['r2 score']) + model.train() + + if cfg.wandb_log and step % cfg.log_interval==0: + metrics['train loss'] = avg_train_loss.item() + metrics['average grad norm'] = avg_grad_norm.item() + metrics['lr'] = scheduler.get_last_lr()[0] + metrics['epoch'] = epoch + avg_train_loss = Averager() + wandb.log(metrics) + scheduler.step() + +def eval(model, val_loader): + metrics = dict() + preds_list = [] + targets_list = [] + avg_loss = Averager() + model.eval() + with torch.no_grad(): + for step, (x, y) in enumerate(val_loader): + preds = model(x) + preds_list.append(preds) + targets_list.append(y) + loss = F.mse_loss(preds, y) + avg_loss.add(loss.item()) + + preds_list = torch.cat(preds_list).tolist() + targets_list = torch.cat(targets_list).tolist() + r2_score = sklearn.metrics.r2_score(y_true = targets_list, y_pred = preds_list) + metrics['r2 score'] = r2_score + metrics['val loss'] = avg_loss.item() + return metrics + +@hydra.main(config_path='cfgs', config_name='config', version_base=None) +def main(cfg: DictConfig): + hydra_cfg = hydra.core.hydra_config.HydraConfig.get() + from char_mlp import train + cfg.model_name = 'char_mlp' + if cfg.wandb_log: + project_name = 'docking-regression-' + cfg.target + wandb.init(project=project_name, entity=cfg.wandb_entity, config=dict(cfg), dir=hydra_cfg['runtime']['output_dir']) + wandb.run.name = cfg.wandb_run_name + train(cfg) + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/regression/regression.py b/regression/char_rnn.py similarity index 95% rename from regression/regression.py rename to regression/char_rnn.py index 4853a17..acc2f27 100644 --- a/regression/regression.py +++ b/regression/char_rnn.py @@ -33,10 +33,7 @@ def train(cfg): #get model cfg.vocab_size = len(vocab) cfg.pad_idx = vocab.pad - if cfg.model_name == 'char_rnn': - model = hydra.utils.instantiate(cfg.charrnn) - else: - raise NotImplementedError + model = hydra.utils.instantiate(cfg.charrnn) #set optimizer optimizer = optim.Adam(get_params(model), lr=cfg.lr, eps=1e-4) @@ -102,7 +99,8 @@ def eval(model, val_loader): @hydra.main(config_path='cfgs', config_name='config', version_base=None) def main(cfg: DictConfig): hydra_cfg = hydra.core.hydra_config.HydraConfig.get() - from regression import train + from char_rnn import train + cfg.model_name = 'char_rnn' if cfg.wandb_log: project_name = 'docking-regression-' + cfg.target wandb.init(project=project_name, entity=cfg.wandb_entity, config=dict(cfg), dir=hydra_cfg['runtime']['output_dir']) diff --git a/regression/data.py b/regression/data.py index dd70fb5..52c3685 100644 --- a/regression/data.py +++ b/regression/data.py @@ -178,6 +178,8 @@ def __init__(self, vocab, data, target, device, add_bos=False, add_eos=False): self.vocab = vocab self.device = device self.encoded_data = [vocab.encode(s, add_bos, add_eos) for s in data] + self.len = [len(s) for s in self.encoded_data] + self.max_len = np.max(self.len) def __len__(self): """ @@ -196,11 +198,20 @@ def collate_fn(batch): x = torch.nn.utils.rnn.pad_sequence(x, batch_first=True, padding_value=self.vocab.pad).to(self.device) y = torch.tensor(y, dtype=torch.float32, device=self.device) return x, y, lens - return collate_fn + elif model_name == 'char_mlp': + def collate_fn(batch): + x, y = list(zip(*batch)) + x = list(x) + x[0] = torch.nn.ConstantPad1d((0, self.max_len - x[0].shape[0]), self.vocab.pad)(x[0]) + x = torch.nn.utils.rnn.pad_sequence(x, batch_first=True, padding_value=self.vocab.pad).to(self.device) + y = torch.tensor(y, dtype=torch.float32, device=self.device) + return x, y else: raise NotImplementedError + + return collate_fn -def get_data(cfg): +def get_data(cfg, get_max_len=False): data_path=cfg.data_path splits_path=cfg.splits_path target=cfg.target @@ -245,4 +256,7 @@ def get_data(cfg): val_dataset = StringDataset(vocab, x_test, y_test, device='cuda') val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, drop_last=False, collate_fn=train_dataset.get_collate_fn(cfg.model_name)) - return train_loader, val_loader, vocab \ No newline at end of file + if get_max_len: + return train_loader, val_loader, vocab, max(train_dataset.max_len, val_dataset.max_len) + else: + return train_loader, val_loader, vocab \ No newline at end of file diff --git a/regression/models.py b/regression/models.py index 1790930..adb28d5 100644 --- a/regression/models.py +++ b/regression/models.py @@ -7,19 +7,26 @@ def count_parameters(model): return sum(p.numel() for p in model.parameters() if p.requires_grad) class CharMLP(nn.Module): - def __init__(self, vocabulary, device): + def __init__(self, vocab_size, pad_idx, embedding_size, input_size, hidden_size, dropout, device): super(CharMLP, self).__init__() - self.vocabulary = vocabulary - self.hidden_size = 786 - self.num_layers = 3 - self.dropout = 0.2 self.device = device - self.vocab_size = self.input_size = len(vocabulary) + self.input_size = input_size + self.embedding_size = embedding_size + self.embedding_layer = nn.Embedding(vocab_size, embedding_size, padding_idx=pad_idx).to(self.device) + self.fc_layer = nn.Sequential( + nn.Linear(input_size * embedding_size, hidden_size), + nn.ReLU(), nn.Dropout(dropout), nn.Linear(hidden_size, hidden_size), + nn.ReLU(), nn.Dropout(dropout), nn.Linear(hidden_size, 1), + ).to(self.device) + def forward(self, x): + x = self.embedding_layer(x).view(-1, self.input_size * self.embedding_size) + preds = self.fc_layer(x).squeeze(-1) + return preds + class CharRNN(nn.Module): def __init__(self, vocab_size, pad_idx, embedding_size, num_layers, hidden_size, dropout, device): super(CharRNN, self).__init__() - self.device = device self.embedding_layer = nn.Embedding(vocab_size, embedding_size, padding_idx=pad_idx).to(self.device) self.lstm_layer = nn.LSTM(embedding_size, hidden_size, num_layers, dropout=dropout, batch_first=True).to(self.device) diff --git a/regression/scripts/cedar/1.sh b/regression/scripts/cedar/1.sh index 5096ef7..43731b9 100644 --- a/regression/scripts/cedar/1.sh +++ b/regression/scripts/cedar/1.sh @@ -1,7 +1,7 @@ #!/bin/bash #SBATCH --account=rrg-gberseth -#SBATCH --time=00:30:00 +#SBATCH --time=00:45:00 #SBATCH --cpus-per-task=4 #SBATCH --mem=4G #SBATCH --gres=gpu:v100l:1 @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python regression.py max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_rnn.py max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=crnn_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/2.sh b/regression/scripts/cedar/2.sh index dc45ce2..8b3ea8f 100644 --- a/regression/scripts/cedar/2.sh +++ b/regression/scripts/cedar/2.sh @@ -1,7 +1,7 @@ #!/bin/bash #SBATCH --account=rrg-gberseth -#SBATCH --time=00:30:00 +#SBATCH --time=00:45:00 #SBATCH --cpus-per-task=4 #SBATCH --mem=4G #SBATCH --gres=gpu:v100l:1 @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python regression.py max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_rnn.py max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=crnn_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/3.sh b/regression/scripts/cedar/3.sh new file mode 100644 index 0000000..2688e29 --- /dev/null +++ b/regression/scripts/cedar/3.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +#SBATCH --account=rrg-gberseth +#SBATCH --time=00:30:00 +#SBATCH --cpus-per-task=4 +#SBATCH --mem=4G +#SBATCH --gres=gpu:v100l:1 +#SBATCH --array=1-3 + +array=(-1 "0.5" "10" "100") + +rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem +echo "moved code to slurm tmpdir" + +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ +python char_mlp.py max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=cmlp_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/4.sh b/regression/scripts/cedar/4.sh new file mode 100644 index 0000000..d407d1b --- /dev/null +++ b/regression/scripts/cedar/4.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +#SBATCH --account=rrg-gberseth +#SBATCH --time=00:30:00 +#SBATCH --cpus-per-task=4 +#SBATCH --mem=4G +#SBATCH --gres=gpu:v100l:1 +#SBATCH --array=1-3 + +array=(-1 "0.5" "10" "100") + +rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem +echo "moved code to slurm tmpdir" + +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ +python char_rnn.py max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=cmlp_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file From e6f62bd78bff904b32e08b0c7f3f3818af477d42 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Thu, 23 Feb 2023 14:04:22 +0530 Subject: [PATCH 17/34] adding fc mlp --- regression/cfgs/config.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/regression/cfgs/config.yaml b/regression/cfgs/config.yaml index dca95bd..5d0f61f 100644 --- a/regression/cfgs/config.yaml +++ b/regression/cfgs/config.yaml @@ -36,6 +36,7 @@ charmlp: hidden_size: 256 embedding_size: 32 input_size: ${input_size} + dropout: 0.2 #eval eval_interval: 100 From 5c2360bf999bd6d9775981317c467d022fdacaf2 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Thu, 23 Feb 2023 14:08:57 +0530 Subject: [PATCH 18/34] minor edits --- regression/char_mlp.py | 14 +++++++++----- regression/char_rnn.py | 4 ++-- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/regression/char_mlp.py b/regression/char_mlp.py index b85a89b..9b7460a 100644 --- a/regression/char_mlp.py +++ b/regression/char_mlp.py @@ -44,7 +44,7 @@ def train(cfg): print('The model has ', num_params, ' number of trainable parameters.') avg_train_loss = Averager() - avg_grad_norm = Averager() + # avg_grad_norm = Averager() for epoch in range(cfg.num_epochs): metrics = dict() for step, (x, y) in enumerate(train_loader): @@ -52,26 +52,30 @@ def train(cfg): loss = F.mse_loss(preds, y) optimizer.zero_grad() loss.backward() - grad_norm = nn.utils.clip_grad_norm_(model.parameters(), cfg.max_grad_norm) + # grad_norm = nn.utils.clip_grad_norm_(model.parameters(), cfg.max_grad_norm) optimizer.step() avg_train_loss.add(loss.item()) - avg_grad_norm.add(grad_norm.item()) + # avg_grad_norm.add(grad_norm.item()) if step % cfg.eval_interval == 0: metrics.update( eval(model, val_loader)) - print('Epoch = ', epoch, 'Step = ', step, ' r2_score time = ', metrics['r2 score']) + print('Epoch = ', epoch, 'Step = ', step, ' r2_score = ', metrics['r2 score']) model.train() if cfg.wandb_log and step % cfg.log_interval==0: metrics['train loss'] = avg_train_loss.item() - metrics['average grad norm'] = avg_grad_norm.item() + # metrics['average grad norm'] = avg_grad_norm.item() metrics['lr'] = scheduler.get_last_lr()[0] metrics['epoch'] = epoch avg_train_loss = Averager() wandb.log(metrics) scheduler.step() + metrics.update( + eval(model, val_loader)) + print('Epoch = ', epoch, 'Step = ', step, ' r2_score = ', metrics['r2 score']) + def eval(model, val_loader): metrics = dict() preds_list = [] diff --git a/regression/char_rnn.py b/regression/char_rnn.py index acc2f27..d479c0c 100644 --- a/regression/char_rnn.py +++ b/regression/char_rnn.py @@ -59,7 +59,7 @@ def train(cfg): if step % cfg.eval_interval == 0: metrics.update( eval(model, val_loader)) - print('Epoch = ', epoch, 'Step = ', step, ' r2_score time = ', metrics['r2 score']) + print('Epoch = ', epoch, 'Step = ', step, ' r2_score = ', metrics['r2 score']) model.train() if cfg.wandb_log and step % cfg.log_interval==0: @@ -73,7 +73,7 @@ def train(cfg): metrics.update( eval(model, val_loader)) - print('Epoch = ', epoch, 'Step = ', step, ' r2_score time = ', metrics['r2 score']) + print('Epoch = ', epoch, 'Step = ', step, ' r2_score = ', metrics['r2 score']) def eval(model, val_loader): metrics = dict() From e40a5b4ced4809c412d724b15946fd54e4eca15d Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Thu, 23 Feb 2023 14:41:19 +0530 Subject: [PATCH 19/34] addin scripts for other targets --- regression/scripts/cedar/1.sh | 2 +- regression/scripts/cedar/2.sh | 2 +- regression/scripts/cedar/3.sh | 4 ++-- regression/scripts/cedar/4.sh | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/regression/scripts/cedar/1.sh b/regression/scripts/cedar/1.sh index 43731b9..4920594 100644 --- a/regression/scripts/cedar/1.sh +++ b/regression/scripts/cedar/1.sh @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=crnn_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_rnn.py target=F2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=crnn_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/2.sh b/regression/scripts/cedar/2.sh index 8b3ea8f..d3cd8c4 100644 --- a/regression/scripts/cedar/2.sh +++ b/regression/scripts/cedar/2.sh @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=crnn_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_rnn.py target=F2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=crnn_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/3.sh b/regression/scripts/cedar/3.sh index 2688e29..7ebd600 100644 --- a/regression/scripts/cedar/3.sh +++ b/regression/scripts/cedar/3.sh @@ -1,7 +1,7 @@ #!/bin/bash #SBATCH --account=rrg-gberseth -#SBATCH --time=00:30:00 +#SBATCH --time=00:45:00 #SBATCH --cpus-per-task=4 #SBATCH --mem=4G #SBATCH --gres=gpu:v100l:1 @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_mlp.py max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=cmlp_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_rnn.py target=KIT max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=crnn_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/4.sh b/regression/scripts/cedar/4.sh index d407d1b..7903b92 100644 --- a/regression/scripts/cedar/4.sh +++ b/regression/scripts/cedar/4.sh @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=cmlp_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_rnn.py target=KIT max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=cmlp_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file From 0d941752022dc89f51b89cc5002bed4f235240aa Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Thu, 23 Feb 2023 15:19:15 +0530 Subject: [PATCH 20/34] addin scripts for other targets --- regression/scripts/cedar/5.sh | 16 ++++++++++++++++ regression/scripts/cedar/6.sh | 16 ++++++++++++++++ regression/scripts/cedar/7.sh | 16 ++++++++++++++++ regression/scripts/cedar/8.sh | 16 ++++++++++++++++ 4 files changed, 64 insertions(+) create mode 100644 regression/scripts/cedar/5.sh create mode 100644 regression/scripts/cedar/6.sh create mode 100644 regression/scripts/cedar/7.sh create mode 100644 regression/scripts/cedar/8.sh diff --git a/regression/scripts/cedar/5.sh b/regression/scripts/cedar/5.sh new file mode 100644 index 0000000..9018950 --- /dev/null +++ b/regression/scripts/cedar/5.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +#SBATCH --account=rrg-gberseth +#SBATCH --time=00:45:00 +#SBATCH --cpus-per-task=4 +#SBATCH --mem=4G +#SBATCH --gres=gpu:v100l:1 +#SBATCH --array=1-3 + +array=(-1 "0.5" "10" "100") + +rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem +echo "moved code to slurm tmpdir" + +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ +python char_rnn.py target=PARP1 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=crnn_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/6.sh b/regression/scripts/cedar/6.sh new file mode 100644 index 0000000..2b22d3f --- /dev/null +++ b/regression/scripts/cedar/6.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +#SBATCH --account=rrg-gberseth +#SBATCH --time=00:45:00 +#SBATCH --cpus-per-task=4 +#SBATCH --mem=4G +#SBATCH --gres=gpu:v100l:1 +#SBATCH --array=1-3 + +array=(-1 "0.5" "10" "100") + +rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem +echo "moved code to slurm tmpdir" + +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ +python char_rnn.py target=PARP1 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=crnn_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/7.sh b/regression/scripts/cedar/7.sh new file mode 100644 index 0000000..7aef8ef --- /dev/null +++ b/regression/scripts/cedar/7.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +#SBATCH --account=rrg-gberseth +#SBATCH --time=00:45:00 +#SBATCH --cpus-per-task=4 +#SBATCH --mem=4G +#SBATCH --gres=gpu:v100l:1 +#SBATCH --array=1-3 + +array=(-1 "0.5" "10" "100") + +rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem +echo "moved code to slurm tmpdir" + +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ +python char_rnn.py target=PGR max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=crnn_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/8.sh b/regression/scripts/cedar/8.sh new file mode 100644 index 0000000..6ae2975 --- /dev/null +++ b/regression/scripts/cedar/8.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +#SBATCH --account=rrg-gberseth +#SBATCH --time=00:45:00 +#SBATCH --cpus-per-task=4 +#SBATCH --mem=4G +#SBATCH --gres=gpu:v100l:1 +#SBATCH --array=1-3 + +array=(-1 "0.5" "10" "100") + +rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem +echo "moved code to slurm tmpdir" + +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ +python char_rnn.py target=PGR max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=crnn_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file From fe4f30bc13fb032cfbb243d3dbf41540c96f0473 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Thu, 23 Feb 2023 18:19:41 +0530 Subject: [PATCH 21/34] adding scripts with horizon 50 --- regression/scripts/cedar/1.sh | 2 -- regression/scripts/cedar/10.sh | 14 ++++++++++++++ regression/scripts/cedar/2.sh | 2 -- regression/scripts/cedar/3.sh | 2 -- regression/scripts/cedar/4.sh | 2 -- regression/scripts/cedar/5.sh | 2 -- regression/scripts/cedar/6.sh | 2 -- regression/scripts/cedar/7.sh | 2 -- regression/scripts/cedar/8.sh | 2 -- regression/scripts/cedar/9.sh | 14 ++++++++++++++ scripts/cedar/1.sh | 2 +- scripts/cedar/2.sh | 2 +- scripts/cedar/3.sh | 2 +- 13 files changed, 31 insertions(+), 19 deletions(-) create mode 100644 regression/scripts/cedar/10.sh create mode 100644 regression/scripts/cedar/9.sh diff --git a/regression/scripts/cedar/1.sh b/regression/scripts/cedar/1.sh index 4920594..7514ab7 100644 --- a/regression/scripts/cedar/1.sh +++ b/regression/scripts/cedar/1.sh @@ -7,8 +7,6 @@ #SBATCH --gres=gpu:v100l:1 #SBATCH --array=1-3 -array=(-1 "0.5" "10" "100") - rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem echo "moved code to slurm tmpdir" diff --git a/regression/scripts/cedar/10.sh b/regression/scripts/cedar/10.sh new file mode 100644 index 0000000..5c6ed60 --- /dev/null +++ b/regression/scripts/cedar/10.sh @@ -0,0 +1,14 @@ +#!/bin/bash + +#SBATCH --account=rrg-gberseth +#SBATCH --time=00:45:00 +#SBATCH --cpus-per-task=4 +#SBATCH --mem=4G +#SBATCH --gres=gpu:v100l:1 +#SBATCH --array=1-3 + +rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem +echo "moved code to slurm tmpdir" + +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ +python char_rnn.py target=ESR2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=crnn_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/2.sh b/regression/scripts/cedar/2.sh index d3cd8c4..56706e5 100644 --- a/regression/scripts/cedar/2.sh +++ b/regression/scripts/cedar/2.sh @@ -7,8 +7,6 @@ #SBATCH --gres=gpu:v100l:1 #SBATCH --array=1-3 -array=(-1 "0.5" "10" "100") - rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem echo "moved code to slurm tmpdir" diff --git a/regression/scripts/cedar/3.sh b/regression/scripts/cedar/3.sh index 7ebd600..625bca2 100644 --- a/regression/scripts/cedar/3.sh +++ b/regression/scripts/cedar/3.sh @@ -7,8 +7,6 @@ #SBATCH --gres=gpu:v100l:1 #SBATCH --array=1-3 -array=(-1 "0.5" "10" "100") - rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem echo "moved code to slurm tmpdir" diff --git a/regression/scripts/cedar/4.sh b/regression/scripts/cedar/4.sh index 7903b92..537b188 100644 --- a/regression/scripts/cedar/4.sh +++ b/regression/scripts/cedar/4.sh @@ -7,8 +7,6 @@ #SBATCH --gres=gpu:v100l:1 #SBATCH --array=1-3 -array=(-1 "0.5" "10" "100") - rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem echo "moved code to slurm tmpdir" diff --git a/regression/scripts/cedar/5.sh b/regression/scripts/cedar/5.sh index 9018950..653ca30 100644 --- a/regression/scripts/cedar/5.sh +++ b/regression/scripts/cedar/5.sh @@ -7,8 +7,6 @@ #SBATCH --gres=gpu:v100l:1 #SBATCH --array=1-3 -array=(-1 "0.5" "10" "100") - rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem echo "moved code to slurm tmpdir" diff --git a/regression/scripts/cedar/6.sh b/regression/scripts/cedar/6.sh index 2b22d3f..9b17a5e 100644 --- a/regression/scripts/cedar/6.sh +++ b/regression/scripts/cedar/6.sh @@ -7,8 +7,6 @@ #SBATCH --gres=gpu:v100l:1 #SBATCH --array=1-3 -array=(-1 "0.5" "10" "100") - rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem echo "moved code to slurm tmpdir" diff --git a/regression/scripts/cedar/7.sh b/regression/scripts/cedar/7.sh index 7aef8ef..c322d06 100644 --- a/regression/scripts/cedar/7.sh +++ b/regression/scripts/cedar/7.sh @@ -7,8 +7,6 @@ #SBATCH --gres=gpu:v100l:1 #SBATCH --array=1-3 -array=(-1 "0.5" "10" "100") - rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem echo "moved code to slurm tmpdir" diff --git a/regression/scripts/cedar/8.sh b/regression/scripts/cedar/8.sh index 6ae2975..34a6d10 100644 --- a/regression/scripts/cedar/8.sh +++ b/regression/scripts/cedar/8.sh @@ -7,8 +7,6 @@ #SBATCH --gres=gpu:v100l:1 #SBATCH --array=1-3 -array=(-1 "0.5" "10" "100") - rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem echo "moved code to slurm tmpdir" diff --git a/regression/scripts/cedar/9.sh b/regression/scripts/cedar/9.sh new file mode 100644 index 0000000..a9ac9df --- /dev/null +++ b/regression/scripts/cedar/9.sh @@ -0,0 +1,14 @@ +#!/bin/bash + +#SBATCH --account=rrg-gberseth +#SBATCH --time=00:45:00 +#SBATCH --cpus-per-task=4 +#SBATCH --mem=4G +#SBATCH --gres=gpu:v100l:1 +#SBATCH --array=1-3 + +rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem +echo "moved code to slurm tmpdir" + +singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ +python char_rnn.py target=ESR2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=crnn_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/scripts/cedar/1.sh b/scripts/cedar/1.sh index 6165a06..546279b 100644 --- a/scripts/cedar/1.sh +++ b/scripts/cedar/1.sh @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem &&\ -python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=22 wandb_log=True wandb_run_name=ln_max_len_22 seed=1 num_sub_proc=20" \ No newline at end of file +python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=50 wandb_log=True wandb_run_name=ln_max_len_50 seed=1 num_sub_proc=20" \ No newline at end of file diff --git a/scripts/cedar/2.sh b/scripts/cedar/2.sh index 048d33f..2824cda 100644 --- a/scripts/cedar/2.sh +++ b/scripts/cedar/2.sh @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem &&\ -python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=22 wandb_log=True wandb_run_name=ln_max_len_22 seed=2 num_sub_proc=20" \ No newline at end of file +python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=50 wandb_log=True wandb_run_name=ln_max_len_50 seed=2 num_sub_proc=20" \ No newline at end of file diff --git a/scripts/cedar/3.sh b/scripts/cedar/3.sh index bf59e4e..be0595c 100644 --- a/scripts/cedar/3.sh +++ b/scripts/cedar/3.sh @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem &&\ -python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=22 wandb_log=True wandb_run_name=ln_max_len_22 seed=3 num_sub_proc=20" \ No newline at end of file +python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=50 wandb_log=True wandb_run_name=ln_max_len_50 seed=3 num_sub_proc=20" \ No newline at end of file From e50ee598e0bcdeb369f8c7255e0fedd98949f4fb Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Fri, 24 Feb 2023 15:51:26 +0530 Subject: [PATCH 22/34] adding new code --- cfgs/config.yaml | 3 +- env.py | 37 ++---- sac.py | 18 ++- train.py | 291 +++++++++++++++++++++++------------------------ utils.py | 82 +++++++------ 5 files changed, 206 insertions(+), 225 deletions(-) diff --git a/cfgs/config.yaml b/cfgs/config.yaml index 898f74c..8fb4276 100644 --- a/cfgs/config.yaml +++ b/cfgs/config.yaml @@ -8,7 +8,7 @@ seed: 1 #environment specific target: 'fa7' selfies_enc_type: 'one_hot' -max_selfie_length: 25 +max_selfie_length: 15 vina_program: 'qvina2' temp_dir: 'tmp' exhaustiveness: 1 @@ -22,6 +22,7 @@ timeout_dock: 100 num_train_steps: 1000000 env_buffer_size: 100000 +explore_molecules: 250 parallel_molecules: 250 batch_size: 256 obs_dtype: diff --git a/env.py b/env.py index f1f58ee..f3eeb1f 100644 --- a/env.py +++ b/env.py @@ -122,17 +122,19 @@ def step(self, action): if done: molecule_smiles = sf.decoder(self.molecule_selfie) - pretty_selfies = sf.encoder(molecule_smiles) - - self.smiles_batch.append(molecule_smiles) - self.selfies_batch.append(pretty_selfies) - self.len_selfies_batch.append(sf.len_selfies(pretty_selfies)) + # pretty_selfies = sf.encoder(molecule_smiles) + # self.selfies_batch.append(pretty_selfies) + # self.len_selfies_batch.append(sf.len_selfies(pretty_selfies)) info["episode"]["l"] = self.t + info["episode"]["smiles"] = molecule_smiles reward = -1000 else: reward = 0 return self.enc_selifes_fn(self.molecule_selfie), reward, done, info + def _add_smiles_to_batch(self, molecule_smiles): + self.smiles_batch.append(molecule_smiles) + def _reset_store_batch(self): # Intitialising smiles batch for parallel evaluation self.smiles_batch = [] @@ -168,31 +170,6 @@ class args(): timeout_dock= 100 env = docking_env(args) - state = env.reset() - done = False - next_state, reward, done, info = env.step(15) - print(env.action_space[15]) - print(next_state) - print(env.molecule_selfie) - # print(state) - # while not done: - # action = np.random.randint(env.num_actions) - # next_state, reward, done, info = env.step(action) - # print(action) - # print(env.alphabet_to_idx[env.action_space[action]]) - # print(next_state) - # print('\n') - - # possible_states = [] - # for a1 in range(env.num_actions): - # for a2 in range(env.num_actions): - # env.reset() - # env.step(a1) - # env.step(a2) - - # reward_batch, reward_info = env.get_reward_batch() - # print(np.argmax(reward_batch), np.max(reward_batch)) - # print(reward_info['smiles'][np.argmax(reward_batch)]) ''' ENV stats diff --git a/sac.py b/sac.py index ed1c8b0..7a31f66 100644 --- a/sac.py +++ b/sac.py @@ -74,7 +74,6 @@ def __init__(self, device, obs_dims, num_actions, self.policy_update_interval = policy_update_interval self.target_update_interval = target_update_interval self.batch_size = batch_size - self.aug = NoiseAug() #exploration self.entropy_coefficient = entropy_coefficient @@ -87,7 +86,7 @@ def __init__(self, device, obs_dims, num_actions, self._init_networks(obs_dims, num_actions, hidden_dims) self._init_optims(lr) - def get_action(self, obs, step, eval=False): + def get_action(self, obs, eval=False): with torch.no_grad(): obs = torch.FloatTensor(obs).to(self.device) action_dist = self.actor(obs) @@ -104,15 +103,12 @@ def update(self, buffer, step): else: log = False - state_batch, action_batch, reward_batch, next_state_batch, done_batch = buffer.sample(self.batch_size) - - # state_batch = self.aug(torch.FloatTensor(state_batch).to(self.device)) - # next_state_batch = self.aug(torch.FloatTensor(next_state_batch).to(self.device)) - state_batch = torch.FloatTensor(state_batch).to(self.device) - next_state_batch = torch.FloatTensor(next_state_batch).to(self.device) - action_batch = torch.FloatTensor(action_batch).to(self.device) - reward_batch = torch.FloatTensor(reward_batch).to(self.device) - done_batch = torch.FloatTensor(done_batch).to(self.device) + state_batch, action_batch, reward_batch, next_state_batch, done_batch, time_batch = buffer.sample(self.batch_size) + state_batch = torch.tensor(state_batch, dtype=torch.float32, device=self.device) + next_state_batch = torch.tensor(next_state_batch, dtype=torch.float32, device=self.device) + action_batch = torch.tensor(action_batch, dtype=torch.float32, device=self.device) + reward_batch = torch.tensor(reward_batch, dtype=torch.float32, device=self.device) + done_batch = torch.tensor(done_batch, dtype=torch.float32, device=self.device) discount_batch = self.gamma*(1-done_batch) self.update_critic(state_batch, action_batch, reward_batch, next_state_batch, discount_batch, log, metrics) diff --git a/train.py b/train.py index ae55643..de82ab7 100644 --- a/train.py +++ b/train.py @@ -10,6 +10,19 @@ from pathlib import Path from omegaconf import DictConfig +from collections import defaultdict + +class Topk(): + def __init__(self): + self.top25 = [] + + def add(self, scores): + scores = np.sort(np.concatenate([self.top25, scores])) + self.top25 = scores[-25:] + + def top(self, k): + assert k <= 25 + return self.top25[-k] def make_agent(env, device, cfg): obs_dims = np.prod(env.observation_shape) @@ -21,6 +34,7 @@ def make_agent(env, device, cfg): env_buffer = utils.ReplayMemory(env_buffer_size, obs_dims, obs_dtype, action_dtype) fresh_env_buffer = utils.FreshReplayMemory(cfg.parallel_molecules, env.episode_length, obs_dims, obs_dtype, action_dtype) + docking_buffer = defaultdict(lambda: None) if cfg.agent == 'sac': from sac import SacAgent @@ -29,7 +43,7 @@ def make_agent(env, device, cfg): cfg.hidden_dims, cfg.wandb_log, cfg.agent_log_interval) else: raise NotImplementedError - return agent, env_buffer, fresh_env_buffer + return agent, env_buffer, fresh_env_buffer, docking_buffer def make_env(cfg): print(cfg.id) @@ -39,164 +53,145 @@ def make_env(cfg): else: raise NotImplementedError -class Workspace: - def __init__(self, cfg): - self.work_dir = Path.cwd() - self.cfg = cfg - if self.cfg.save_snapshot: - self.checkpoint_path = self.work_dir / 'checkpoints' - self.checkpoint_path.mkdir(exist_ok=True) - - self.set_seed() - self.device = torch.device(cfg.device) - self.train_env, self.eval_env = make_env(self.cfg) - self.agent, self.env_buffer, self.fresh_env_buffer = make_agent(self.train_env, self.device, self.cfg) - self.unique_molecules = set() - self.current_reward_batch = np.zeros((cfg.parallel_molecules,), dtype=np.float32) - self.current_reward_info = dict() - self._train_step = 0 - self._train_episode = 0 - self._best_eval_returns = -np.inf - self._best_train_returns = -np.inf - - def set_seed(self): - random.seed(self.cfg.seed) - np.random.seed(self.cfg.seed) - torch.manual_seed(self.cfg.seed) - torch.cuda.manual_seed_all(self.cfg.seed) - - def _explore(self): - print('random exploration of ', self.cfg.parallel_molecules, ' number of molecules begins') - explore_steps = self.cfg.parallel_molecules * self.train_env.episode_length - - state, done = self.train_env.reset(), False - for _ in range(explore_steps): - action = np.random.randint(self.train_env.num_actions) - next_state, reward, done, info = self.train_env.step(action) +def set_seed(seed): + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + +def collect_molecule(env, agent, fresh_env_buffer): + state, done, t = env.reset(), False, 0 + while not done: + action = agent.get_action(state) + next_state, reward, done, info = env.step(action) + fresh_env_buffer.push((state, action, reward, next_state, done, t)) + t += 1 + state = next_state + return info['episode'] + +def collect_random_molecule(env, fresh_env_buffer): + state, done, t = env.reset(), False, 0 + while not done: + action = np.random.randint(env.num_actions) + next_state, reward, done, info = env.step(action) + fresh_env_buffer.push((state, action, reward, next_state, done, t)) + t += 1 + state = next_state + return info['episode'] + +def explore(cfg, train_env, env_buffer, fresh_env_buffer, docking_buffer): + explore_mols = 0 + while explore_mols < cfg.explore_molecules: + episode_info = collect_random_molecule(train_env, fresh_env_buffer) + + if docking_buffer[episode_info['smiles']] is not None: + fresh_env_buffer.remove_last_episode(episode_info['l']) + else: + docking_buffer[episode_info['smiles']] = 0 + train_env._add_smiles_to_batch(episode_info['smiles']) + explore_mols += 1 + + reward_start_time = time.time() + parallel_reward_batch, parallel_reward_info = train_env.get_reward_batch() + reward_eval_time = time.time() - reward_start_time + + #Update main buffer and docking_buffer and reset fresh buffer + fresh_env_buffer.update_final_rewards(parallel_reward_batch) + env_buffer.push_fresh_buffer(fresh_env_buffer) + fresh_env_buffer.reset() + + # Uncomment this when you want to save all molecules with their docking score in a text + # for i, smiles_string in enumerate(parallel_reward_info['smiles']): + # docking_buffer[smiles_string] = parallel_reward_info['docking_scores'][i] + + print('Total strings explored = ', cfg.explore_molecules, ' Reward evaluation time = ', reward_eval_time) + print(np.sort(parallel_reward_batch)) + + return parallel_reward_batch + +def train(cfg): + set_seed(cfg.seed) + device = torch.device(cfg.device) + + #get train and eval envs + train_env, eval_env = make_env(cfg) + + #get agent and memory + agent, env_buffer, fresh_env_buffer, docking_buffer = make_agent(train_env, device, cfg) + topk = Topk() + + #explore + cummulative_unique_molecules = cfg.explore_molecules + docking_scores = explore(cfg, train_env, env_buffer, fresh_env_buffer, docking_buffer) + topk.add(docking_scores) + + #eval + #To-do + + #train + train_step = 0 + train_unique_counter = 0 + train_parallel_counter = 0 + while train_step < cfg.num_train_steps: + + episode_info = collect_molecule(train_env, agent, fresh_env_buffer) + train_parallel_counter += 1 + + if docking_buffer[episode_info['smiles']] is not None: + fresh_env_buffer.remove_last_episode(episode_info['l']) + train_step += episode_info['l'] + else: + docking_buffer[episode_info['smiles']] = 0 + train_env._add_smiles_to_batch(episode_info['smiles']) + train_unique_counter += 1 + + for _ in range(episode_info['l']): + agent.update(env_buffer, train_step) + train_step += 1 - self.fresh_env_buffer.push((state, action, reward, next_state, done)) + if train_parallel_counter == cfg.parallel_molecules: - if done: - state, done = self.train_env.reset(), False - else: - state = next_state - - reward_start_time = time.time() - self.current_reward_batch, self.current_reward_info = self.train_env.get_reward_batch() - reward_eval_time = time.time() - reward_start_time - self.fresh_env_buffer.update_final_rewards(self.current_reward_batch) - self.env_buffer.push_fresh_buffer(self.fresh_env_buffer) - self.fresh_env_buffer.reset() - print('Total strings = ', len(self.current_reward_info['selfies']), 'Unique strings = ', len(set(self.current_reward_info['selfies'])), ' Evaluation time = ', reward_eval_time) - print(np.sort(self.current_reward_batch)) - self.unique_molecules.update(self.current_reward_info['smiles']) - - def train(self): - self._eval() - self._explore() - - parallel_counter = 0 - state, done, episode_start_time, episode_metrics = self.train_env.reset(), False, time.time(), dict() - - for _ in range(1, self.cfg.num_train_steps): - action = self.agent.get_action(state, self._train_step) - next_state, reward, done, info = self.train_env.step(action) - self.fresh_env_buffer.push((state, action, reward, next_state, done)) - self._train_step += 1 + reward_start_time = time.time() + parallel_reward_batch, parallel_reward_info = train_env.get_reward_batch() + reward_eval_time = time.time() - reward_start_time - if done: - self._train_episode += 1 - print("Episode: {}, total numsteps: {}".format(self._train_episode, self._train_step)) - state, done, episode_start_time = self.train_env.reset(), False, time.time() - if self.cfg.wandb_log: - episode_metrics['episodic_length'] = info["episode"]["l"] - episode_metrics['steps_per_second'] = info["episode"]["l"]/(time.time() - episode_start_time) - episode_metrics['env_buffer_length'] = len(self.env_buffer) - episode_metrics['episodic_reward'] = self.current_reward_batch[parallel_counter] - episode_metrics['episodic_selfies_len'] = self.current_reward_info['len_selfies'][parallel_counter] - wandb.log(episode_metrics, step=self._train_step) - parallel_counter += 1 - else: - state = next_state - - self.agent.update(self.env_buffer, self._train_step) - - if self._train_step % self.cfg.eval_episode_interval == 0: - self._eval() - - if self.cfg.save_snapshot and self._train_step % self.cfg.save_snapshot_interval == 0: - self.save_snapshot() - - if parallel_counter == self.cfg.parallel_molecules: - reward_start_time = time.time() - self.current_reward_batch, self.current_reward_info = self.train_env.get_reward_batch() - reward_eval_time = time.time() - reward_start_time - self.fresh_env_buffer.update_final_rewards(self.current_reward_batch) - self.env_buffer.push_fresh_buffer(self.fresh_env_buffer) - self.fresh_env_buffer.reset() - - unique_strings = len(set(self.current_reward_info['selfies'])) - print('Total strings = ', len(self.current_reward_info['selfies']), 'Unique strings = ', unique_strings, 'Cummulative unique strings = ', len(self.unique_molecules), ' Evaluation time = ', reward_eval_time) - self.unique_molecules.update(self.current_reward_info['smiles']) - print(np.sort(self.current_reward_batch)) - best_idx = np.argmax(self.current_reward_batch) - print(self.current_reward_info['smiles'][best_idx]) - - if self.cfg.wandb_log: - wandb.log({'reward_eval_time' : reward_eval_time, - 'unique strings': unique_strings, - 'cummulative unique strings' : len(self.unique_molecules)}, step = self._train_step) - parallel_counter = 0 - - def _eval(self): - steps = 0 - for _ in range(self.cfg.num_eval_episodes): - done = False - state = self.eval_env.reset() - while not done: - action = self.agent.get_action(state, self._train_step, True) - next_state, _, done ,info = self.eval_env.step(action) - state = next_state - - steps += info["episode"]["l"] - - final_rewards, _ = self.eval_env.get_reward_batch() - eval_metrics = dict() - eval_metrics['eval_episodic_return'] = sum(final_rewards)/self.cfg.num_eval_episodes - eval_metrics['eval_episodic_length'] = steps/self.cfg.num_eval_episodes - - print("Episode: {}, total numsteps: {}, average Evaluation return: {}".format(self._train_episode, self._train_step, round(eval_metrics['eval_episodic_return'], 2))) - - if self.cfg.save_snapshot and sum(final_rewards)/self.cfg.num_eval_episodes >= self._best_eval_returns: - self.save_snapshot(best=True) - self._best_eval_returns = sum(final_rewards)/self.cfg.num_eval_episodes - - if self.cfg.wandb_log: - wandb.log(eval_metrics, step = self._train_step) - - def save_snapshot(self, best=False): - if best: - snapshot = Path(self.checkpoint_path) / 'best.pt' - else: - snapshot = Path(self.checkpoint_path) / Path(str(self._train_step)+'.pt') - save_dict = self.agent.get_save_dict() - torch.save(save_dict, snapshot) + topk.add(parallel_reward_batch) + + #Update main buffer and reset fresh buffer + fresh_env_buffer.update_final_rewards(parallel_reward_batch) + env_buffer.push_fresh_buffer(fresh_env_buffer) + fresh_env_buffer.reset() + + cummulative_unique_molecules += train_unique_counter + + print('Total strings = ', train_parallel_counter, 'Unique strings = ', train_unique_counter, ' Evaluation time = ', reward_eval_time) + print(np.sort(parallel_reward_batch)) + + if cfg.wandb_log: + metrics = dict() + metrics['reward_eval_time'] = reward_eval_time + metrics['cummulative_unique_strings'] = cummulative_unique_molecules + metrics['unique_strings'] = train_unique_counter + metrics['top1'] = topk.top(1) + metrics['top5'] = topk.top(5) + metrics['top25'] = topk.top(25) + wandb.log(metrics, step=train_step) + + train_unique_counter = 0 + train_parallel_counter = 0 @hydra.main(config_path='cfgs', config_name='config', version_base=None) def main(cfg: DictConfig): - from train import Workspace as W + from train import train hydra_cfg = hydra.core.hydra_config.HydraConfig.get() if cfg.wandb_log: project_name = 'rl4chem_' + cfg.target - with wandb.init(project=project_name, entity=cfg.wandb_entity, config=dict(cfg), dir=hydra_cfg['runtime']['output_dir']): - wandb.run.name = cfg.wandb_run_name - workspace = W(cfg) - workspace.train() - else: - workspace = W(cfg) - workspace.train() + wandb.init(project=project_name, entity=cfg.wandb_entity, config=dict(cfg), dir=hydra_cfg['runtime']['output_dir']) + wandb.run.name = cfg.wandb_run_name + + train(cfg) if __name__ == '__main__': main() \ No newline at end of file diff --git a/utils.py b/utils.py index 8ad5f0c..94bd23b 100644 --- a/utils.py +++ b/utils.py @@ -15,87 +15,99 @@ def __init__(self, buffer_limit, obs_dims, obs_dtype, action_dtype): self.action = np.empty((buffer_limit, 1), dtype=action_dtype) self.reward = np.empty((buffer_limit,), dtype=np.float32) self.terminal = np.empty((buffer_limit,), dtype=bool) + self.time_step = np.empty((buffer_limit,), dtype=np.uint8) self.idx = 0 self.full = False def push(self, transition): - state, action, reward, next_state, done = transition + state, action, reward, next_state, done, time_step = transition self.observation[self.idx] = state self.next_observation[self.idx] = next_state self.action[self.idx] = action self.reward[self.idx] = reward self.terminal[self.idx] = done + self.time_step[self.idx] = time_step self.idx = (self.idx + 1) % self.buffer_limit self.full = self.full or self.idx == 0 def push_batch(self, transitions, N): - states, actions, rewards, next_states, dones = transitions + states, actions, rewards, next_states, dones, time_steps = transitions idxs = np.arange(self.idx, self.idx + N) % self.buffer_limit self.observation[idxs] = states self.next_observation[idxs] = next_states self.action[idxs] = actions self.reward[idxs] = rewards self.terminal[idxs] = dones + self.time_step[idxs] = time_steps self.full = self.full or (self.idx + N >= self.buffer_limit) self.idx = (idxs[-1] + 1) % self.buffer_limit def push_fresh_buffer(self, fresh_buffer): - N = fresh_buffer.num_episodes * fresh_buffer.max_episode_len + N = fresh_buffer.buffer_limit if fresh_buffer.full else fresh_buffer.step_idx idxs = np.arange(self.idx, self.idx + N) % self.buffer_limit - self.observation[idxs] = fresh_buffer.observation.reshape((-1, self.obs_dims)) - self.next_observation[idxs] = fresh_buffer.next_observation.reshape((-1, self.obs_dims)) - self.action[idxs] = fresh_buffer.action.reshape((-1, 1)) - self.reward[idxs] = fresh_buffer.reward.reshape((-1,)) - self.terminal[idxs] = fresh_buffer.terminal.reshape((-1,)) - + self.observation[idxs] = fresh_buffer.observation[:N] + self.next_observation[idxs] = fresh_buffer.next_observation[:N] + self.action[idxs] = fresh_buffer.action[:N] + self.reward[idxs] = fresh_buffer.reward[:N] + self.terminal[idxs] = fresh_buffer.terminal[:N] + self.time_step[idxs] = fresh_buffer.time_step[:N] self.full = self.full or (self.idx + N >= self.buffer_limit) self.idx = (idxs[-1] + 1) % self.buffer_limit def sample(self, n): - idxes = np.random.randint(0, self.buffer_limit if self.full else self.idx, size=n) - - return self.observation[idxes], self.action[idxes], self.reward[idxes], self.next_observation[idxes], self.terminal[idxes] + idxes = np.random.randint(0, self.buffer_limit if self.full else self.idx, size=n) + return self.observation[idxes], self.action[idxes], self.reward[idxes], self.next_observation[idxes], self.terminal[idxes], self.time_step[idxes] def __len__(self): return self.buffer_limit if self.full else self.idx+1 - + class FreshReplayMemory(): def __init__(self, num_episodes, max_episode_len, obs_dims, obs_dtype, action_dtype): - self.obs_dtype = obs_dtype self.obs_dims = obs_dims self.action_dtype = action_dtype - self.num_episodes = num_episodes - self.max_episode_len = max_episode_len + self.buffer_limit = num_episodes * max_episode_len self.reset() def reset(self): - self.observation = np.empty((self.num_episodes, self.max_episode_len, self.obs_dims), dtype=self.obs_dtype) - self.next_observation = np.empty((self.num_episodes, self.max_episode_len, self.obs_dims), dtype=self.obs_dtype) - self.action = np.empty((self.num_episodes, self.max_episode_len, 1), dtype=self.action_dtype) - self.reward = np.empty((self.num_episodes, self.max_episode_len), dtype=np.float32) - self.terminal = np.empty((self.num_episodes, self.max_episode_len), dtype=bool) - + self.observation = np.empty((self.buffer_limit, self.obs_dims), dtype=self.obs_dtype) + self.next_observation = np.empty((self.buffer_limit, self.obs_dims), dtype=self.obs_dtype) + self.action = np.empty((self.buffer_limit, 1), dtype=self.action_dtype) + self.reward = np.empty((self.buffer_limit,), dtype=np.float32) + self.terminal = np.empty((self.buffer_limit,), dtype=bool) + self.time_step = np.empty((self.buffer_limit,), dtype=np.uint8) + self.reward_indices = [] self.full = False self.step_idx = 0 - self.episode_idx = 0 def push(self, transition): - state, action, reward, next_state, done = transition - self.observation[self.episode_idx, self.step_idx] = state - self.next_observation[self.episode_idx, self.step_idx] = next_state - self.action[self.episode_idx, self.step_idx] = action - self.reward[self.episode_idx, self.step_idx] = reward - self.terminal[self.episode_idx, self.step_idx] = done + state, action, reward, next_state, done, time_step = transition + self.observation[self.step_idx] = state + self.next_observation[self.step_idx] = next_state + self.action[self.step_idx] = action + self.reward[self.step_idx] = reward + self.terminal[self.step_idx] = done + self.time_step[self.step_idx] = time_step + + if done: + self.reward_indices.append(self.step_idx) + + self.step_idx = (self.step_idx + 1) % self.buffer_limit + self.full = self.full or self.step_idx == 0 + + def remove_last_episode(self, episode_len): + last_episode_start_id = self.step_idx - episode_len + if self.full : assert self.step_idx == 0 + if last_episode_start_id < 0 : assert self.full + if last_episode_start_id < 0 : assert self.step_idx == 0 + self.reward_indices.pop() + self.step_idx = last_episode_start_id % self.buffer_limit + if self.full : self.full = not last_episode_start_id < 0 - self.step_idx = (self.step_idx + 1) % self.max_episode_len - self.episode_idx = self.episode_idx + 1 * (self.step_idx == 0) - self.full = self.full or self.episode_idx == self.num_episodes - def update_final_rewards(self, reward_batch): - self.reward[:, -1] = reward_batch - + self.reward[self.reward_indices] = reward_batch + # NN weight utils def weight_init(m): From 4d9d62845ddfb60a66b9e54eaf4c2c842bee2607 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Sat, 25 Feb 2023 13:12:42 +0530 Subject: [PATCH 23/34] add --- cfgs/config.yaml | 2 +- env.py | 12 ++----- sac.py | 10 +++--- train.py | 86 +++++++++++++++++++++++++----------------------- utils.py | 4 +++ 5 files changed, 56 insertions(+), 58 deletions(-) diff --git a/cfgs/config.yaml b/cfgs/config.yaml index 8fb4276..82074da 100644 --- a/cfgs/config.yaml +++ b/cfgs/config.yaml @@ -8,7 +8,7 @@ seed: 1 #environment specific target: 'fa7' selfies_enc_type: 'one_hot' -max_selfie_length: 15 +max_selfie_length: 22 vina_program: 'qvina2' temp_dir: 'tmp' exhaustiveness: 1 diff --git a/env.py b/env.py index f3eeb1f..94b37ae 100644 --- a/env.py +++ b/env.py @@ -86,8 +86,6 @@ def __init__(self, cfg): # Intitialising smiles batch for parallel evaluation self.smiles_batch = [] - self.selfies_batch = [] - self.len_selfies_batch = [] # Initialize Step self.t = 0 @@ -122,11 +120,11 @@ def step(self, action): if done: molecule_smiles = sf.decoder(self.molecule_selfie) - # pretty_selfies = sf.encoder(molecule_smiles) - # self.selfies_batch.append(pretty_selfies) - # self.len_selfies_batch.append(sf.len_selfies(pretty_selfies)) + pretty_selfies = sf.encoder(molecule_smiles) info["episode"]["l"] = self.t info["episode"]["smiles"] = molecule_smiles + info["episode"]["seflies"] = pretty_selfies + info["episode"]["selfies_len"] = sf.len_selfies(pretty_selfies) reward = -1000 else: reward = 0 @@ -138,16 +136,12 @@ def _add_smiles_to_batch(self, molecule_smiles): def _reset_store_batch(self): # Intitialising smiles batch for parallel evaluation self.smiles_batch = [] - self.selfies_batch = [] - self.len_selfies_batch = [] def get_reward_batch(self): info = defaultdict(dict) docking_scores = self.predictor.predict(self.smiles_batch) reward_batch = np.clip(-np.array(docking_scores), a_min=0.0, a_max=None) info['smiles'] = self.smiles_batch - info['selfies'] = self.selfies_batch - info['len_selfies'] = self.len_selfies_batch info['docking_scores'] = docking_scores self._reset_store_batch() return reward_batch, info diff --git a/sac.py b/sac.py index 7a31f66..a260f45 100644 --- a/sac.py +++ b/sac.py @@ -112,12 +112,8 @@ def update(self, buffer, step): discount_batch = self.gamma*(1-done_batch) self.update_critic(state_batch, action_batch, reward_batch, next_state_batch, discount_batch, log, metrics) - actor_log = False - if step % self.policy_update_interval == 0: - for _ in range(self.policy_update_interval): - actor_log = not actor_log if log else actor_log - self.update_actor(state_batch, actor_log, metrics) - + self.update_actor(state_batch, log, metrics) + if step%self.target_update_interval==0: utils.soft_update(self.critic_target, self.critic, self.tau) @@ -146,6 +142,8 @@ def update_critic(self, state_batch, action_batch, reward_batch, next_state_batc if log: metrics['mean_q_target'] = torch.mean(target_Q).item() + metrics['max_reward'] = torch.max(reward_batch).item() + metrics['min_reward'] = torch.min(reward_batch).item() metrics['variance_q_target'] = torch.var(target_Q).item() metrics['min_q_target'] = torch.min(target_Q).item() metrics['max_q_target'] = torch.max(target_Q).item() diff --git a/train.py b/train.py index de82ab7..472f41e 100644 --- a/train.py +++ b/train.py @@ -59,16 +59,6 @@ def set_seed(seed): torch.manual_seed(seed) torch.cuda.manual_seed_all(seed) -def collect_molecule(env, agent, fresh_env_buffer): - state, done, t = env.reset(), False, 0 - while not done: - action = agent.get_action(state) - next_state, reward, done, info = env.step(action) - fresh_env_buffer.push((state, action, reward, next_state, done, t)) - t += 1 - state = next_state - return info['episode'] - def collect_random_molecule(env, fresh_env_buffer): state, done, t = env.reset(), False, 0 while not done: @@ -99,16 +89,24 @@ def explore(cfg, train_env, env_buffer, fresh_env_buffer, docking_buffer): fresh_env_buffer.update_final_rewards(parallel_reward_batch) env_buffer.push_fresh_buffer(fresh_env_buffer) fresh_env_buffer.reset() - - # Uncomment this when you want to save all molecules with their docking score in a text - # for i, smiles_string in enumerate(parallel_reward_info['smiles']): - # docking_buffer[smiles_string] = parallel_reward_info['docking_scores'][i] + for i, smiles_string in enumerate(parallel_reward_info['smiles']): + docking_buffer[smiles_string] = parallel_reward_batch[i] print('Total strings explored = ', cfg.explore_molecules, ' Reward evaluation time = ', reward_eval_time) print(np.sort(parallel_reward_batch)) return parallel_reward_batch +def collect_molecule(env, agent, fresh_env_buffer): + state, done, t = env.reset(), False, 0 + while not done: + action = agent.get_action(state) + next_state, reward, done, info = env.step(action) + fresh_env_buffer.push((state, action, reward, next_state, done, t)) + t += 1 + state = next_state + return info['episode'] + def train(cfg): set_seed(cfg.seed) device = torch.device(cfg.device) @@ -121,64 +119,63 @@ def train(cfg): topk = Topk() #explore - cummulative_unique_molecules = cfg.explore_molecules docking_scores = explore(cfg, train_env, env_buffer, fresh_env_buffer, docking_buffer) topk.add(docking_scores) - #eval - #To-do - #train train_step = 0 - train_unique_counter = 0 - train_parallel_counter = 0 + molecule_counter = 0 + unique_molecule_counter = 0 while train_step < cfg.num_train_steps: + episode_info = collect_molecule(train_env, agent, fresh_env_buffer) - train_parallel_counter += 1 - + molecule_counter += 1 if docking_buffer[episode_info['smiles']] is not None: - fresh_env_buffer.remove_last_episode(episode_info['l']) - train_step += episode_info['l'] + fresh_env_buffer.update_last_episode_reward(docking_buffer[episode_info['smiles']]) else: docking_buffer[episode_info['smiles']] = 0 train_env._add_smiles_to_batch(episode_info['smiles']) - train_unique_counter += 1 + unique_molecule_counter += 1 + + for _ in range(episode_info['l']): + agent.update(env_buffer, train_step) + train_step += 1 + + print('Total strings = ', molecule_counter, 'Unique strings = ', unique_molecule_counter) + + if molecule_counter % cfg.parallel_molecules == 0 and unique_molecule_counter != 0: - for _ in range(episode_info['l']): - agent.update(env_buffer, train_step) - train_step += 1 - - if train_parallel_counter == cfg.parallel_molecules: - reward_start_time = time.time() parallel_reward_batch, parallel_reward_info = train_env.get_reward_batch() reward_eval_time = time.time() - reward_start_time topk.add(parallel_reward_batch) - #Update main buffer and reset fresh buffer + #Update main buffer and docking_buffer and reset fresh buffer fresh_env_buffer.update_final_rewards(parallel_reward_batch) env_buffer.push_fresh_buffer(fresh_env_buffer) fresh_env_buffer.reset() + for i, smiles_string in enumerate(parallel_reward_info['smiles']): + docking_buffer[smiles_string] = parallel_reward_batch[i] - cummulative_unique_molecules += train_unique_counter - - print('Total strings = ', train_parallel_counter, 'Unique strings = ', train_unique_counter, ' Evaluation time = ', reward_eval_time) + print('Evaluation time = ', reward_eval_time) print(np.sort(parallel_reward_batch)) if cfg.wandb_log: metrics = dict() metrics['reward_eval_time'] = reward_eval_time - metrics['cummulative_unique_strings'] = cummulative_unique_molecules - metrics['unique_strings'] = train_unique_counter + metrics['total_strings'] = molecule_counter + metrics['unique_strings'] = unique_molecule_counter + metrics['env_buffer_size'] = len(env_buffer) metrics['top1'] = topk.top(1) metrics['top5'] = topk.top(5) metrics['top25'] = topk.top(25) wandb.log(metrics, step=train_step) - - train_unique_counter = 0 - train_parallel_counter = 0 + + return docking_buffer + #eval + #To-do @hydra.main(config_path='cfgs', config_name='config', version_base=None) def main(cfg: DictConfig): @@ -191,7 +188,12 @@ def main(cfg: DictConfig): wandb.init(project=project_name, entity=cfg.wandb_entity, config=dict(cfg), dir=hydra_cfg['runtime']['output_dir']) wandb.run.name = cfg.wandb_run_name - train(cfg) - + docking_buffer = train(cfg) + sorted_docking_buffer = sorted(docking_buffer.items(), key=lambda x:x[1]) + + with open(str(hydra_cfg['runtime']['output_dir']) + '/molecules.txt', 'w') as f: + for (smiles, score) in reversed(sorted_docking_buffer): + f.write(str(score) + ' || ' + smiles + "\n") + if __name__ == '__main__': main() \ No newline at end of file diff --git a/utils.py b/utils.py index 94bd23b..395e46c 100644 --- a/utils.py +++ b/utils.py @@ -105,6 +105,10 @@ def remove_last_episode(self, episode_len): self.step_idx = last_episode_start_id % self.buffer_limit if self.full : self.full = not last_episode_start_id < 0 + def update_last_episode_reward(self, reward): + self.reward[self.reward_indices[-1]] = reward + self.reward_indices.pop() + def update_final_rewards(self, reward_batch): self.reward[self.reward_indices] = reward_batch From 59e365c6f46097042fbd820c8b0479d4175817fa Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Sat, 25 Feb 2023 13:18:24 +0530 Subject: [PATCH 24/34] addinf sanity check cedar scripts --- scripts/cedar/1.sh | 2 +- scripts/cedar/2.sh | 2 +- scripts/cedar/3.sh | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/scripts/cedar/1.sh b/scripts/cedar/1.sh index 546279b..85c43df 100644 --- a/scripts/cedar/1.sh +++ b/scripts/cedar/1.sh @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem &&\ -python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=50 wandb_log=True wandb_run_name=ln_max_len_50 seed=1 num_sub_proc=20" \ No newline at end of file +python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=25 wandb_log=True wandb_run_name=ln_max_len_25 seed=1 num_sub_proc=20" \ No newline at end of file diff --git a/scripts/cedar/2.sh b/scripts/cedar/2.sh index 2824cda..7230791 100644 --- a/scripts/cedar/2.sh +++ b/scripts/cedar/2.sh @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem &&\ -python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=50 wandb_log=True wandb_run_name=ln_max_len_50 seed=2 num_sub_proc=20" \ No newline at end of file +python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=25 wandb_log=True wandb_run_name=ln_max_len_25 seed=2 num_sub_proc=20" \ No newline at end of file diff --git a/scripts/cedar/3.sh b/scripts/cedar/3.sh index be0595c..fa85ef2 100644 --- a/scripts/cedar/3.sh +++ b/scripts/cedar/3.sh @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem &&\ -python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=50 wandb_log=True wandb_run_name=ln_max_len_50 seed=3 num_sub_proc=20" \ No newline at end of file +python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=25 wandb_log=True wandb_run_name=ln_max_len_25 seed=3 num_sub_proc=20" \ No newline at end of file From 9cd7efde5a4a239f391c4ac27c0abb064a28745f Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Sat, 25 Feb 2023 16:24:20 +0530 Subject: [PATCH 25/34] len 22 sanity --- scripts/cedar/1.sh | 2 +- scripts/cedar/2.sh | 2 +- scripts/cedar/3.sh | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/scripts/cedar/1.sh b/scripts/cedar/1.sh index 85c43df..6165a06 100644 --- a/scripts/cedar/1.sh +++ b/scripts/cedar/1.sh @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem &&\ -python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=25 wandb_log=True wandb_run_name=ln_max_len_25 seed=1 num_sub_proc=20" \ No newline at end of file +python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=22 wandb_log=True wandb_run_name=ln_max_len_22 seed=1 num_sub_proc=20" \ No newline at end of file diff --git a/scripts/cedar/2.sh b/scripts/cedar/2.sh index 7230791..048d33f 100644 --- a/scripts/cedar/2.sh +++ b/scripts/cedar/2.sh @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem &&\ -python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=25 wandb_log=True wandb_run_name=ln_max_len_25 seed=2 num_sub_proc=20" \ No newline at end of file +python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=22 wandb_log=True wandb_run_name=ln_max_len_22 seed=2 num_sub_proc=20" \ No newline at end of file diff --git a/scripts/cedar/3.sh b/scripts/cedar/3.sh index fa85ef2..bf59e4e 100644 --- a/scripts/cedar/3.sh +++ b/scripts/cedar/3.sh @@ -13,4 +13,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem &&\ -python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=25 wandb_log=True wandb_run_name=ln_max_len_25 seed=3 num_sub_proc=20" \ No newline at end of file +python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=22 wandb_log=True wandb_run_name=ln_max_len_22 seed=3 num_sub_proc=20" \ No newline at end of file From d7e4eeabe7b9e4b60d0ff985163a2762a0f089c5 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Mon, 27 Feb 2023 13:04:06 +0530 Subject: [PATCH 26/34] adding 0 dropout experiments --- regression/cfgs/config.yaml | 15 ++++- regression/char_conv.py | 112 +++++++++++++++++++++++++++++++++ regression/char_mlp.py | 12 ++-- regression/data.py | 2 +- regression/models.py | 21 +++++++ regression/scripts/cedar/1.sh | 2 +- regression/scripts/cedar/10.sh | 2 +- regression/scripts/cedar/2.sh | 2 +- regression/scripts/cedar/3.sh | 2 +- regression/scripts/cedar/4.sh | 2 +- regression/scripts/cedar/5.sh | 2 +- regression/scripts/cedar/6.sh | 2 +- regression/scripts/cedar/7.sh | 2 +- regression/scripts/cedar/8.sh | 2 +- regression/scripts/cedar/9.sh | 2 +- 15 files changed, 163 insertions(+), 19 deletions(-) create mode 100644 regression/char_conv.py diff --git a/regression/cfgs/config.yaml b/regression/cfgs/config.yaml index 5d0f61f..0ceb49b 100644 --- a/regression/cfgs/config.yaml +++ b/regression/cfgs/config.yaml @@ -25,7 +25,7 @@ charrnn: num_layers: 3 hidden_size: 256 embedding_size: 32 - dropout: 0.2 + dropout: 0.0 #CharMLP charmlp: @@ -36,7 +36,18 @@ charmlp: hidden_size: 256 embedding_size: 32 input_size: ${input_size} - dropout: 0.2 + dropout: 0.0 + +#CharConv +charconv: + _target_: models.CharConv + vocab_size: ${vocab_size} + pad_idx: ${pad_idx} + device: ${device} + hidden_size: 256 + embedding_size: 32 + input_size: ${input_size} + dropout: 0.0 #eval eval_interval: 100 diff --git a/regression/char_conv.py b/regression/char_conv.py new file mode 100644 index 0000000..0b136cf --- /dev/null +++ b/regression/char_conv.py @@ -0,0 +1,112 @@ +import hydra +import wandb +import torch +import torch.nn as nn +import torch.optim as optim +import torch.nn.functional as F +import sklearn.metrics +from omegaconf import DictConfig +from data import get_data + +class Averager(): + def __init__(self): + self.n = 0 + self.v = 0 + + def add(self, x): + self.v = (self.v * self.n + x) / (self.n + 1) + self.n += 1 + + def item(self): + return self.v + +def count_parameters(model): + return sum(p.numel() for p in model.parameters() if p.requires_grad) + +def get_params(model): + return (p for p in model.parameters() if p.requires_grad) + +def train(cfg): + #get trainloader + train_loader, val_loader, vocab, input_size = get_data(cfg, get_max_len=True) + + #get model + cfg.vocab_size = len(vocab) + cfg.pad_idx = vocab.pad + cfg.input_size = int(input_size) + model = hydra.utils.instantiate(cfg.charconv) + + #set optimizer + optimizer = optim.Adam(get_params(model), lr=cfg.lr) + scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=cfg.num_epochs, eta_min=0.0) + + num_params = count_parameters(model) + print('The model has ', num_params, ' number of trainable parameters.') + + avg_train_loss = Averager() + avg_grad_norm = Averager() + for epoch in range(cfg.num_epochs): + metrics = dict() + for step, (x, y) in enumerate(train_loader): + preds = model(x) + loss = F.mse_loss(preds, y) + optimizer.zero_grad() + loss.backward() + grad_norm = nn.utils.clip_grad_norm_(model.parameters(), cfg.max_grad_norm) + optimizer.step() + avg_train_loss.add(loss.item()) + avg_grad_norm.add(grad_norm.item()) + + if step % cfg.eval_interval == 0: + metrics.update( + eval(model, val_loader)) + print('Epoch = ', epoch, 'Step = ', step, ' r2_score = ', metrics['r2 score']) + model.train() + + if cfg.wandb_log and step % cfg.log_interval==0: + metrics['train loss'] = avg_train_loss.item() + metrics['average grad norm'] = avg_grad_norm.item() + metrics['lr'] = scheduler.get_last_lr()[0] + metrics['epoch'] = epoch + avg_train_loss = Averager() + wandb.log(metrics) + scheduler.step() + + metrics.update( + eval(model, val_loader)) + print('Epoch = ', epoch, 'Step = ', step, ' r2_score = ', metrics['r2 score']) + +def eval(model, val_loader): + metrics = dict() + preds_list = [] + targets_list = [] + avg_loss = Averager() + model.eval() + with torch.no_grad(): + for step, (x, y) in enumerate(val_loader): + preds = model(x) + preds_list.append(preds) + targets_list.append(y) + loss = F.mse_loss(preds, y) + avg_loss.add(loss.item()) + + preds_list = torch.cat(preds_list).tolist() + targets_list = torch.cat(targets_list).tolist() + r2_score = sklearn.metrics.r2_score(y_true = targets_list, y_pred = preds_list) + metrics['r2 score'] = r2_score + metrics['val loss'] = avg_loss.item() + return metrics + +@hydra.main(config_path='cfgs', config_name='config', version_base=None) +def main(cfg: DictConfig): + hydra_cfg = hydra.core.hydra_config.HydraConfig.get() + from char_conv import train + cfg.model_name = 'char_conv' + if cfg.wandb_log: + project_name = 'docking-regression-' + cfg.target + wandb.init(project=project_name, entity=cfg.wandb_entity, config=dict(cfg), dir=hydra_cfg['runtime']['output_dir']) + wandb.run.name = cfg.wandb_run_name + train(cfg) + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/regression/char_mlp.py b/regression/char_mlp.py index 9b7460a..743ecef 100644 --- a/regression/char_mlp.py +++ b/regression/char_mlp.py @@ -33,18 +33,18 @@ def train(cfg): #get model cfg.vocab_size = len(vocab) cfg.pad_idx = vocab.pad - cfg.input_size = int(input_size) + cfg.input_size = int(input_size) #length of the maximum sequence in the dataset model = hydra.utils.instantiate(cfg.charmlp) #set optimizer - optimizer = optim.Adam(get_params(model), lr=cfg.lr, eps=1e-4) + optimizer = optim.Adam(get_params(model), lr=cfg.lr) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=cfg.num_epochs, eta_min=0.0) num_params = count_parameters(model) print('The model has ', num_params, ' number of trainable parameters.') avg_train_loss = Averager() - # avg_grad_norm = Averager() + avg_grad_norm = Averager() for epoch in range(cfg.num_epochs): metrics = dict() for step, (x, y) in enumerate(train_loader): @@ -52,10 +52,10 @@ def train(cfg): loss = F.mse_loss(preds, y) optimizer.zero_grad() loss.backward() - # grad_norm = nn.utils.clip_grad_norm_(model.parameters(), cfg.max_grad_norm) + grad_norm = nn.utils.clip_grad_norm_(model.parameters(), cfg.max_grad_norm) optimizer.step() avg_train_loss.add(loss.item()) - # avg_grad_norm.add(grad_norm.item()) + avg_grad_norm.add(grad_norm.item()) if step % cfg.eval_interval == 0: metrics.update( @@ -65,7 +65,7 @@ def train(cfg): if cfg.wandb_log and step % cfg.log_interval==0: metrics['train loss'] = avg_train_loss.item() - # metrics['average grad norm'] = avg_grad_norm.item() + metrics['average grad norm'] = avg_grad_norm.item() metrics['lr'] = scheduler.get_last_lr()[0] metrics['epoch'] = epoch avg_train_loss = Averager() diff --git a/regression/data.py b/regression/data.py index 52c3685..7fef3ec 100644 --- a/regression/data.py +++ b/regression/data.py @@ -198,7 +198,7 @@ def collate_fn(batch): x = torch.nn.utils.rnn.pad_sequence(x, batch_first=True, padding_value=self.vocab.pad).to(self.device) y = torch.tensor(y, dtype=torch.float32, device=self.device) return x, y, lens - elif model_name == 'char_mlp': + elif model_name in ['char_mlp', 'char_conv']: def collate_fn(batch): x, y = list(zip(*batch)) x = list(x) diff --git a/regression/models.py b/regression/models.py index adb28d5..a270a3a 100644 --- a/regression/models.py +++ b/regression/models.py @@ -24,6 +24,27 @@ def forward(self, x): preds = self.fc_layer(x).squeeze(-1) return preds +class CharConv(nn.Module): + def __init__(self, vocab_size, pad_idx, embedding_size, input_size, hidden_size, dropout, device): + super(CharConv, self).__init__() + self.device = device + self.input_size = input_size + self.embedding_size = embedding_size + self.embedding_layer = nn.Embedding(vocab_size, embedding_size, padding_idx=pad_idx).to(self.device) + self.convnet = nn.Sequential(nn.Conv1d(embedding_size, 16, kernel_size=9), + nn.ReLU(), nn.Conv1d(16, 8, kernel_size=9), + nn.ReLU(), nn.Conv1d(8, 4, kernel_size=9), + nn.ReLU(), nn.Conv1d(4, 2, kernel_size=9), + nn.ReLU()).to(self.device) + self.linear_layer = nn.Linear(198, 1).to(self.device) + + def forward(self, x): + x = self.embedding_layer(x).view(-1, self.input_size * self.embedding_size).view(-1, self.embedding_size, self.input_size) + x = self.convnet(x) + x = x.view(x.shape[0], -1) + preds = self.linear_layer(x).squeeze(-1) + return preds + class CharRNN(nn.Module): def __init__(self, vocab_size, pad_idx, embedding_size, num_layers, hidden_size, dropout, device): super(CharRNN, self).__init__() diff --git a/regression/scripts/cedar/1.sh b/regression/scripts/cedar/1.sh index 7514ab7..7f61b3d 100644 --- a/regression/scripts/cedar/1.sh +++ b/regression/scripts/cedar/1.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=F2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=crnn_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_rnn.py target=F2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/10.sh b/regression/scripts/cedar/10.sh index 5c6ed60..b41fb3e 100644 --- a/regression/scripts/cedar/10.sh +++ b/regression/scripts/cedar/10.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=ESR2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=crnn_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_rnn.py target=ESR2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/2.sh b/regression/scripts/cedar/2.sh index 56706e5..016a840 100644 --- a/regression/scripts/cedar/2.sh +++ b/regression/scripts/cedar/2.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=F2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=crnn_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_rnn.py target=F2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/3.sh b/regression/scripts/cedar/3.sh index 625bca2..cf596b6 100644 --- a/regression/scripts/cedar/3.sh +++ b/regression/scripts/cedar/3.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=KIT max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=crnn_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_rnn.py target=KIT max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/4.sh b/regression/scripts/cedar/4.sh index 537b188..bba0bfe 100644 --- a/regression/scripts/cedar/4.sh +++ b/regression/scripts/cedar/4.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=KIT max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=cmlp_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_rnn.py target=KIT max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/5.sh b/regression/scripts/cedar/5.sh index 653ca30..0c91b61 100644 --- a/regression/scripts/cedar/5.sh +++ b/regression/scripts/cedar/5.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=PARP1 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=crnn_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_rnn.py target=PARP1 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/6.sh b/regression/scripts/cedar/6.sh index 9b17a5e..e83bd37 100644 --- a/regression/scripts/cedar/6.sh +++ b/regression/scripts/cedar/6.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=PARP1 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=crnn_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_rnn.py target=PARP1 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/7.sh b/regression/scripts/cedar/7.sh index c322d06..2452662 100644 --- a/regression/scripts/cedar/7.sh +++ b/regression/scripts/cedar/7.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=PGR max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=crnn_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_rnn.py target=PGR max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/8.sh b/regression/scripts/cedar/8.sh index 34a6d10..59f5bed 100644 --- a/regression/scripts/cedar/8.sh +++ b/regression/scripts/cedar/8.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=PGR max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=crnn_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_rnn.py target=PGR max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/9.sh b/regression/scripts/cedar/9.sh index a9ac9df..9ab0af6 100644 --- a/regression/scripts/cedar/9.sh +++ b/regression/scripts/cedar/9.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=ESR2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=crnn_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_rnn.py target=ESR2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file From d9729ebe5a7fe89328a95a3e3dd516e0a9547aa6 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Mon, 27 Feb 2023 19:06:55 +0530 Subject: [PATCH 27/34] adding conv1d experiments --- regression/cfgs/config.yaml | 5 +---- regression/models.py | 29 ++++++++++++++--------------- regression/scripts/cedar/1.sh | 2 +- regression/scripts/cedar/10.sh | 2 +- regression/scripts/cedar/2.sh | 2 +- regression/scripts/cedar/3.sh | 2 +- regression/scripts/cedar/4.sh | 2 +- regression/scripts/cedar/5.sh | 2 +- regression/scripts/cedar/6.sh | 2 +- regression/scripts/cedar/7.sh | 2 +- regression/scripts/cedar/8.sh | 2 +- regression/scripts/cedar/9.sh | 2 +- 12 files changed, 25 insertions(+), 29 deletions(-) diff --git a/regression/cfgs/config.yaml b/regression/cfgs/config.yaml index 0ceb49b..50d6e4d 100644 --- a/regression/cfgs/config.yaml +++ b/regression/cfgs/config.yaml @@ -25,7 +25,6 @@ charrnn: num_layers: 3 hidden_size: 256 embedding_size: 32 - dropout: 0.0 #CharMLP charmlp: @@ -36,7 +35,6 @@ charmlp: hidden_size: 256 embedding_size: 32 input_size: ${input_size} - dropout: 0.0 #CharConv charconv: @@ -45,9 +43,8 @@ charconv: pad_idx: ${pad_idx} device: ${device} hidden_size: 256 - embedding_size: 32 + embedding_size: 256 input_size: ${input_size} - dropout: 0.0 #eval eval_interval: 100 diff --git a/regression/models.py b/regression/models.py index a270a3a..f243bc6 100644 --- a/regression/models.py +++ b/regression/models.py @@ -7,7 +7,7 @@ def count_parameters(model): return sum(p.numel() for p in model.parameters() if p.requires_grad) class CharMLP(nn.Module): - def __init__(self, vocab_size, pad_idx, embedding_size, input_size, hidden_size, dropout, device): + def __init__(self, vocab_size, pad_idx, embedding_size, input_size, hidden_size, device): super(CharMLP, self).__init__() self.device = device self.input_size = input_size @@ -15,8 +15,8 @@ def __init__(self, vocab_size, pad_idx, embedding_size, input_size, hidden_size, self.embedding_layer = nn.Embedding(vocab_size, embedding_size, padding_idx=pad_idx).to(self.device) self.fc_layer = nn.Sequential( nn.Linear(input_size * embedding_size, hidden_size), - nn.ReLU(), nn.Dropout(dropout), nn.Linear(hidden_size, hidden_size), - nn.ReLU(), nn.Dropout(dropout), nn.Linear(hidden_size, 1), + nn.ReLU(), nn.Linear(hidden_size, hidden_size), + nn.ReLU(), nn.Linear(hidden_size, 1), ).to(self.device) def forward(self, x): @@ -25,32 +25,31 @@ def forward(self, x): return preds class CharConv(nn.Module): - def __init__(self, vocab_size, pad_idx, embedding_size, input_size, hidden_size, dropout, device): + def __init__(self, vocab_size, pad_idx, embedding_size, input_size, hidden_size, device): super(CharConv, self).__init__() self.device = device self.input_size = input_size self.embedding_size = embedding_size - self.embedding_layer = nn.Embedding(vocab_size, embedding_size, padding_idx=pad_idx).to(self.device) - self.convnet = nn.Sequential(nn.Conv1d(embedding_size, 16, kernel_size=9), - nn.ReLU(), nn.Conv1d(16, 8, kernel_size=9), - nn.ReLU(), nn.Conv1d(8, 4, kernel_size=9), - nn.ReLU(), nn.Conv1d(4, 2, kernel_size=9), - nn.ReLU()).to(self.device) - self.linear_layer = nn.Linear(198, 1).to(self.device) + self.embedding_layer = nn.Embedding(vocab_size, embedding_size, padding_idx=pad_idx).to(self.device).to(self.device) + self.convnet = nn.Conv1d(in_channels=self.embedding_size, out_channels=self.embedding_size, kernel_size=10).to(self.device) + self.temp = (self.input_size - 10 + 1) * self.embedding_size + self.linear_layer_1 = nn.Linear(self.temp, hidden_size).to(self.device) + self.linear_layer_2 = nn.Linear(hidden_size, 1).to(self.device) def forward(self, x): x = self.embedding_layer(x).view(-1, self.input_size * self.embedding_size).view(-1, self.embedding_size, self.input_size) - x = self.convnet(x) + x = F.relu(self.convnet(x)) x = x.view(x.shape[0], -1) - preds = self.linear_layer(x).squeeze(-1) + x = F.relu(self.linear_layer_1(x)) + preds = self.linear_layer_2(x).squeeze(-1) return preds class CharRNN(nn.Module): - def __init__(self, vocab_size, pad_idx, embedding_size, num_layers, hidden_size, dropout, device): + def __init__(self, vocab_size, pad_idx, embedding_size, num_layers, hidden_size, device): super(CharRNN, self).__init__() self.device = device self.embedding_layer = nn.Embedding(vocab_size, embedding_size, padding_idx=pad_idx).to(self.device) - self.lstm_layer = nn.LSTM(embedding_size, hidden_size, num_layers, dropout=dropout, batch_first=True).to(self.device) + self.lstm_layer = nn.LSTM(embedding_size, hidden_size, num_layers, batch_first=True).to(self.device) self.linear_layer = nn.Linear(hidden_size, 1).to(self.device) def forward(self, x, lengths, hiddens=None): diff --git a/regression/scripts/cedar/1.sh b/regression/scripts/cedar/1.sh index 7f61b3d..03dd748 100644 --- a/regression/scripts/cedar/1.sh +++ b/regression/scripts/cedar/1.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=F2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=F2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/10.sh b/regression/scripts/cedar/10.sh index b41fb3e..5719fd4 100644 --- a/regression/scripts/cedar/10.sh +++ b/regression/scripts/cedar/10.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=ESR2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=ESR2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/2.sh b/regression/scripts/cedar/2.sh index 016a840..18a2686 100644 --- a/regression/scripts/cedar/2.sh +++ b/regression/scripts/cedar/2.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=F2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=F2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/3.sh b/regression/scripts/cedar/3.sh index cf596b6..a193f71 100644 --- a/regression/scripts/cedar/3.sh +++ b/regression/scripts/cedar/3.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=KIT max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=KIT max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/4.sh b/regression/scripts/cedar/4.sh index bba0bfe..40cb6bc 100644 --- a/regression/scripts/cedar/4.sh +++ b/regression/scripts/cedar/4.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=KIT max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=KIT max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/5.sh b/regression/scripts/cedar/5.sh index 0c91b61..2fa52e8 100644 --- a/regression/scripts/cedar/5.sh +++ b/regression/scripts/cedar/5.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=PARP1 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=PARP1 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/6.sh b/regression/scripts/cedar/6.sh index e83bd37..3db565d 100644 --- a/regression/scripts/cedar/6.sh +++ b/regression/scripts/cedar/6.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=PARP1 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=PARP1 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/7.sh b/regression/scripts/cedar/7.sh index 2452662..0126222 100644 --- a/regression/scripts/cedar/7.sh +++ b/regression/scripts/cedar/7.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=PGR max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=PGR max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/8.sh b/regression/scripts/cedar/8.sh index 59f5bed..954612d 100644 --- a/regression/scripts/cedar/8.sh +++ b/regression/scripts/cedar/8.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=PGR max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=PGR max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/9.sh b/regression/scripts/cedar/9.sh index 9ab0af6..4e70941 100644 --- a/regression/scripts/cedar/9.sh +++ b/regression/scripts/cedar/9.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_rnn.py target=ESR2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_charnn_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=ESR2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file From 726434dad5e5c8b12b9fa9186e1c72533da12351 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Tue, 28 Feb 2023 14:01:05 +0530 Subject: [PATCH 28/34] adding char conv exps --- regression/cfgs/config.yaml | 2 +- regression/char_conv.py | 10 +++++----- regression/data.py | 5 ++++- regression/models.py | 2 +- regression/scripts/cedar/1.sh | 2 +- regression/scripts/cedar/10.sh | 2 +- regression/scripts/cedar/2.sh | 2 +- regression/scripts/cedar/3.sh | 2 +- regression/scripts/cedar/4.sh | 2 +- regression/scripts/cedar/5.sh | 2 +- regression/scripts/cedar/6.sh | 2 +- regression/scripts/cedar/7.sh | 2 +- regression/scripts/cedar/8.sh | 2 +- regression/scripts/cedar/9.sh | 2 +- 14 files changed, 21 insertions(+), 18 deletions(-) diff --git a/regression/cfgs/config.yaml b/regression/cfgs/config.yaml index 50d6e4d..8f1afc7 100644 --- a/regression/cfgs/config.yaml +++ b/regression/cfgs/config.yaml @@ -43,7 +43,7 @@ charconv: pad_idx: ${pad_idx} device: ${device} hidden_size: 256 - embedding_size: 256 + embedding_size: 32 input_size: ${input_size} #eval diff --git a/regression/char_conv.py b/regression/char_conv.py index 0b136cf..4fad2d7 100644 --- a/regression/char_conv.py +++ b/regression/char_conv.py @@ -35,7 +35,7 @@ def train(cfg): cfg.pad_idx = vocab.pad cfg.input_size = int(input_size) model = hydra.utils.instantiate(cfg.charconv) - + #set optimizer optimizer = optim.Adam(get_params(model), lr=cfg.lr) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=cfg.num_epochs, eta_min=0.0) @@ -44,7 +44,7 @@ def train(cfg): print('The model has ', num_params, ' number of trainable parameters.') avg_train_loss = Averager() - avg_grad_norm = Averager() + # avg_grad_norm = Averager() for epoch in range(cfg.num_epochs): metrics = dict() for step, (x, y) in enumerate(train_loader): @@ -52,10 +52,10 @@ def train(cfg): loss = F.mse_loss(preds, y) optimizer.zero_grad() loss.backward() - grad_norm = nn.utils.clip_grad_norm_(model.parameters(), cfg.max_grad_norm) + # grad_norm = nn.utils.clip_grad_norm_(model.parameters(), cfg.max_grad_norm) optimizer.step() avg_train_loss.add(loss.item()) - avg_grad_norm.add(grad_norm.item()) + # avg_grad_norm.add(grad_norm.item()) if step % cfg.eval_interval == 0: metrics.update( @@ -65,7 +65,7 @@ def train(cfg): if cfg.wandb_log and step % cfg.log_interval==0: metrics['train loss'] = avg_train_loss.item() - metrics['average grad norm'] = avg_grad_norm.item() + # metrics['average grad norm'] = avg_grad_norm.item() metrics['lr'] = scheduler.get_last_lr()[0] metrics['epoch'] = epoch avg_train_loss = Averager() diff --git a/regression/data.py b/regression/data.py index 7fef3ec..871520d 100644 --- a/regression/data.py +++ b/regression/data.py @@ -257,6 +257,9 @@ def get_data(cfg, get_max_len=False): val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, drop_last=False, collate_fn=train_dataset.get_collate_fn(cfg.model_name)) if get_max_len: - return train_loader, val_loader, vocab, max(train_dataset.max_len, val_dataset.max_len) + max_len = max(train_dataset.max_len, val_dataset.max_len) + train_dataset.max_len = max_len + val_dataset.max_len = max_len + return train_loader, val_loader, vocab, max_len else: return train_loader, val_loader, vocab \ No newline at end of file diff --git a/regression/models.py b/regression/models.py index f243bc6..de00956 100644 --- a/regression/models.py +++ b/regression/models.py @@ -37,7 +37,7 @@ def __init__(self, vocab_size, pad_idx, embedding_size, input_size, hidden_size, self.linear_layer_2 = nn.Linear(hidden_size, 1).to(self.device) def forward(self, x): - x = self.embedding_layer(x).view(-1, self.input_size * self.embedding_size).view(-1, self.embedding_size, self.input_size) + x = torch.transpose(self.embedding_layer(x), 1, 2) x = F.relu(self.convnet(x)) x = x.view(x.shape[0], -1) x = F.relu(self.linear_layer_1(x)) diff --git a/regression/scripts/cedar/1.sh b/regression/scripts/cedar/1.sh index 03dd748..916df4a 100644 --- a/regression/scripts/cedar/1.sh +++ b/regression/scripts/cedar/1.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=F2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=F2 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/10.sh b/regression/scripts/cedar/10.sh index 5719fd4..179c7b0 100644 --- a/regression/scripts/cedar/10.sh +++ b/regression/scripts/cedar/10.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=ESR2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=ESR2 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/2.sh b/regression/scripts/cedar/2.sh index 18a2686..0f45bed 100644 --- a/regression/scripts/cedar/2.sh +++ b/regression/scripts/cedar/2.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=F2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=F2 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/3.sh b/regression/scripts/cedar/3.sh index a193f71..fe75e82 100644 --- a/regression/scripts/cedar/3.sh +++ b/regression/scripts/cedar/3.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=KIT max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=KIT seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/4.sh b/regression/scripts/cedar/4.sh index 40cb6bc..2261ba2 100644 --- a/regression/scripts/cedar/4.sh +++ b/regression/scripts/cedar/4.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=KIT max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=KIT seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/5.sh b/regression/scripts/cedar/5.sh index 2fa52e8..820b4f6 100644 --- a/regression/scripts/cedar/5.sh +++ b/regression/scripts/cedar/5.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=PARP1 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=PARP1 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/6.sh b/regression/scripts/cedar/6.sh index 3db565d..42625bd 100644 --- a/regression/scripts/cedar/6.sh +++ b/regression/scripts/cedar/6.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=PARP1 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=PARP1 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/7.sh b/regression/scripts/cedar/7.sh index 0126222..35e03fe 100644 --- a/regression/scripts/cedar/7.sh +++ b/regression/scripts/cedar/7.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=PGR max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=PGR seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/8.sh b/regression/scripts/cedar/8.sh index 954612d..be93a38 100644 --- a/regression/scripts/cedar/8.sh +++ b/regression/scripts/cedar/8.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=PGR max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=PGR seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/9.sh b/regression/scripts/cedar/9.sh index 4e70941..f8384e0 100644 --- a/regression/scripts/cedar/9.sh +++ b/regression/scripts/cedar/9.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=ESR2 max_grad_norm=0.5 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=ESR2 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file From 61081fe510ed7296fcff63f013797bb7f14157b6 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Thu, 2 Mar 2023 13:06:27 +0530 Subject: [PATCH 29/34] adding conv regression experiments based on chem VAE --- regression/cfgs/config.yaml | 2 +- regression/models.py | 19 ++++++++++++------- regression/scripts/cedar/1.sh | 2 +- regression/scripts/cedar/10.sh | 2 +- regression/scripts/cedar/2.sh | 2 +- regression/scripts/cedar/3.sh | 2 +- regression/scripts/cedar/4.sh | 4 ++-- regression/scripts/cedar/5.sh | 2 +- regression/scripts/cedar/6.sh | 2 +- regression/scripts/cedar/7.sh | 2 +- regression/scripts/cedar/8.sh | 2 +- regression/scripts/cedar/9.sh | 2 +- 12 files changed, 24 insertions(+), 19 deletions(-) diff --git a/regression/cfgs/config.yaml b/regression/cfgs/config.yaml index 8f1afc7..606f282 100644 --- a/regression/cfgs/config.yaml +++ b/regression/cfgs/config.yaml @@ -8,7 +8,7 @@ splits_path: 'data/filtered_cluster_split.tsv' lr: 1e-3 seed: 1 device: 'cuda' -num_epochs: 10 +num_epochs: 20 batch_size: 64 max_grad_norm: 0.5 model_name: diff --git a/regression/models.py b/regression/models.py index de00956..3eb680d 100644 --- a/regression/models.py +++ b/regression/models.py @@ -30,17 +30,22 @@ def __init__(self, vocab_size, pad_idx, embedding_size, input_size, hidden_size, self.device = device self.input_size = input_size self.embedding_size = embedding_size - self.embedding_layer = nn.Embedding(vocab_size, embedding_size, padding_idx=pad_idx).to(self.device).to(self.device) - self.convnet = nn.Conv1d(in_channels=self.embedding_size, out_channels=self.embedding_size, kernel_size=10).to(self.device) - self.temp = (self.input_size - 10 + 1) * self.embedding_size - self.linear_layer_1 = nn.Linear(self.temp, hidden_size).to(self.device) - self.linear_layer_2 = nn.Linear(hidden_size, 1).to(self.device) + self.embedding_layer = nn.Embedding(vocab_size, embedding_size, padding_idx=pad_idx).to(self.device) + self.conv1d1 = nn.Conv1d(in_channels=self.embedding_size, out_channels=9, kernel_size=9).to(self.device) + self.conv1d2 = nn.Conv1d(9, 9, kernel_size=9).to(self.device) + self.conv1d3 = nn.Conv1d(9, 10, kernel_size=11).to(self.device) + + self.temp = (self.input_size - 26) * 10 + self.linear_layer_1 = nn.Linear(self.temp, 256).to(self.device) + self.linear_layer_2 = nn.Linear(256, 1).to(self.device) def forward(self, x): x = torch.transpose(self.embedding_layer(x), 1, 2) - x = F.relu(self.convnet(x)) + x = F.relu(self.conv1d1(x)) + x = F.relu(self.conv1d2(x)) + x = F.relu(self.conv1d3(x)) x = x.view(x.shape[0], -1) - x = F.relu(self.linear_layer_1(x)) + x = F.selu(self.linear_layer_1(x)) preds = self.linear_layer_2(x).squeeze(-1) return preds diff --git a/regression/scripts/cedar/1.sh b/regression/scripts/cedar/1.sh index 916df4a..d1ee5a6 100644 --- a/regression/scripts/cedar/1.sh +++ b/regression/scripts/cedar/1.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=F2 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=F2 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/10.sh b/regression/scripts/cedar/10.sh index 179c7b0..edb89f8 100644 --- a/regression/scripts/cedar/10.sh +++ b/regression/scripts/cedar/10.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=ESR2 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=ESR2 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/2.sh b/regression/scripts/cedar/2.sh index 0f45bed..7d6d854 100644 --- a/regression/scripts/cedar/2.sh +++ b/regression/scripts/cedar/2.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=F2 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=F2 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/3.sh b/regression/scripts/cedar/3.sh index fe75e82..aa305de 100644 --- a/regression/scripts/cedar/3.sh +++ b/regression/scripts/cedar/3.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=KIT seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=KIT seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/4.sh b/regression/scripts/cedar/4.sh index 2261ba2..44cee88 100644 --- a/regression/scripts/cedar/4.sh +++ b/regression/scripts/cedar/4.sh @@ -1,7 +1,7 @@ #!/bin/bash #SBATCH --account=rrg-gberseth -#SBATCH --time=00:30:00 +#SBATCH --time=00:45:00 #SBATCH --cpus-per-task=4 #SBATCH --mem=4G #SBATCH --gres=gpu:v100l:1 @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=KIT seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=KIT seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/5.sh b/regression/scripts/cedar/5.sh index 820b4f6..f5a2775 100644 --- a/regression/scripts/cedar/5.sh +++ b/regression/scripts/cedar/5.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=PARP1 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=PARP1 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/6.sh b/regression/scripts/cedar/6.sh index 42625bd..8b989f5 100644 --- a/regression/scripts/cedar/6.sh +++ b/regression/scripts/cedar/6.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=PARP1 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=PARP1 seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/7.sh b/regression/scripts/cedar/7.sh index 35e03fe..28bd070 100644 --- a/regression/scripts/cedar/7.sh +++ b/regression/scripts/cedar/7.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=PGR seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=PGR seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/8.sh b/regression/scripts/cedar/8.sh index be93a38..f584fae 100644 --- a/regression/scripts/cedar/8.sh +++ b/regression/scripts/cedar/8.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=PGR seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=0drop_selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=PGR seed=$SLURM_ARRAY_TASK_ID wandb_log=True wandb_run_name=selfies_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file diff --git a/regression/scripts/cedar/9.sh b/regression/scripts/cedar/9.sh index f8384e0..3c9df35 100644 --- a/regression/scripts/cedar/9.sh +++ b/regression/scripts/cedar/9.sh @@ -11,4 +11,4 @@ rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --excl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem_old.sif bash -c "source activate rl4chem && cd RL4Chem/regression && pip install pandas && pip install scikit-learn &&\ -python char_conv.py target=ESR2 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=0drop_smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file +python char_conv.py target=ESR2 seed=$SLURM_ARRAY_TASK_ID wandb_log=True string_rep=smiles wandb_run_name=smiles_chaconv_$SLURM_ARRAY_TASK_ID" \ No newline at end of file From e51c92a98a4a57ee365d831d0a1ea88d61360786 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Thu, 2 Mar 2023 13:59:19 +0530 Subject: [PATCH 30/34] adding partial development --- cfgs/mbac.yaml | 73 ++++++++++++++++++++++++++++++++++ env.py | 71 +++++++++++++++++++++++++++++++++ mbac.py | 105 +++++++++++++++++++++++++++++++++++++++++++++++++ utils.py | 20 ++++++++++ 4 files changed, 269 insertions(+) create mode 100644 cfgs/mbac.yaml create mode 100644 mbac.py diff --git a/cfgs/mbac.yaml b/cfgs/mbac.yaml new file mode 100644 index 0000000..21b5ec3 --- /dev/null +++ b/cfgs/mbac.yaml @@ -0,0 +1,73 @@ +#common +id: 'docking' +device: 'cuda' +seed: 1 + +#environment specific +target: 'fa7' +selfies_enc_type: 'index' +max_selfie_length: 22 +vina_program: 'qvina2' +temp_dir: 'tmp' +exhaustiveness: 1 +num_sub_proc: 12 +num_cpu_dock: 1 +num_modes: 10 +timeout_gen3d: 30 +timeout_dock: 100 + +#data +num_train_steps: 100000 +env_buffer_size: 100000 +explore_molecules: 250 +parallel_molecules: 250 +batch_size: 256 +obs_dtype: +action_dtype: + +#learning +lr: {'actor':1e-4, 'reward':1e-4, 'alpha':1e-3} +max_grad_norm: 0.5 +vocab_size: +pad_idx: + +#Actor +actor: + _target_: mbac.Actor + vocab_size: ${vocab_size} + pad_idx: ${pad_idx} + device: ${device} + output_size: ${vocab_size} + num_layers: 3 + hidden_size: 256 + embedding_size: 32 + +#Reward +reward: + _target_: mbac.Reward + vocab_size: ${vocab_size} + pad_idx: ${pad_idx} + device: ${device} + num_layers: 3 + hidden_size: 256 + embedding_size: 32 + +#evaluation +eval_episode_interval: 10000 +num_eval_episodes: 5 + +#logging +wandb_log: False +wandb_entity: 'raj19' +wandb_run_name: 'mbac-disc' +agent_log_interval: 100 + +#saving +save_snapshot: False +save_snapshot_interval: 100000 + +hydra: + run: + dir: ./local_exp/${now:%Y.%m.%d}/${now:%H.%M.%S}_${seed} + job: + chdir: False \ No newline at end of file diff --git a/env.py b/env.py index 94b37ae..25e1b3e 100644 --- a/env.py +++ b/env.py @@ -6,6 +6,77 @@ from docking import DockingVina from collections import defaultdict +class selfies_vocabulary(object): + def __init__(self, vocab_path=None): + + if vocab_path is None: + self.alphabet = sf.get_semantic_robust_alphabet() + else: + self.alphabet = set() + with open(vocab_path, 'r') as f: + chars = f.read().split() + for char in chars: + self.alphabet.add(char) + + self.special_tokens = ['BOS', 'EOS', 'PAD', 'UNK'] + + self.alphabet_list = list(self.alphabet) + self.alphabet_list.sort() + self.alphabet_list = self.alphabet_list + self.special_tokens + self.alphabet_length = len(self.alphabet_list) + + self.alphabet_to_idx = {s: i for i, s in enumerate(self.alphabet_list)} + self.idx_to_alphabet = {s: i for i, s in self.alphabet_to_idx.items()} + + def tokenize(self, selfies, add_bos=False, add_eos=False): + """Takes a SELFIES and return a list of characters/tokens""" + tokenized = list(sf.split_selfies(selfies)) + if add_bos: + tokenized.insert(0, "BOS") + if add_eos: + tokenized.append('EOS') + return tokenized + + def encode(self, selfies, add_bos=False, add_eos=False): + """Takes a list of SELFIES and encodes to array of indices""" + char_list = self.tokenize(selfies, add_bos, add_eos) + encoded_selfies = np.zeros(len(char_list), dtype=np.uint8) + for i, char in enumerate(char_list): + encoded_selfies[i] = self.alphabet_to_idx[char] + return encoded_selfies + + def decode(self, encoded_seflies, rem_bos=True, rem_eos=True): + """Takes an array of indices and returns the corresponding SELFIES""" + if rem_bos and encoded_seflies[0] == self.bos: + encoded_seflies = encoded_seflies[1:] + if rem_eos and encoded_seflies[-1] == self.eos: + encoded_seflies = encoded_seflies[:-1] + + chars = [] + for i in encoded_seflies: + chars.append(self.idx_to_alphabet[i]) + selfies = "".join(chars) + return selfies + + def __len__(self): + return len(self.alphabet_to_idx) + + @property + def bos(self): + return self.alphabet_to_idx['BOS'] + + @property + def eos(self): + return self.alphabet_to_idx['EOS'] + + @property + def pad(self): + return self.alphabet_to_idx['PAD'] + + @property + def unk(self): + return self.alphabet_to_idx['UNK'] + class docking_env(object): '''This environment is build assuming selfies version 2.1.1 To-do diff --git a/mbac.py b/mbac.py new file mode 100644 index 0000000..9e71ee1 --- /dev/null +++ b/mbac.py @@ -0,0 +1,105 @@ +import time +import hydra +import random +import numpy as np + +import torch +import torch.nn as nn +import torch.optim as optim +import torch.nn.functional as F +import torch.distributions as td +import torch.nn.utils.rnn as rnn_utils + +from omegaconf import DictConfig +from collections import defaultdict + +import utils + +class Actor(nn.Module): + def __init__(self, vocab_size, pad_idx, embedding_size, num_layers, hidden_size, output_size, device, dist='categorical'): + super(Actor, self).__init__() + self.device = device + self.embedding_layer = nn.Embedding(vocab_size, embedding_size, padding_idx=pad_idx).to(self.device) + self.lstm_layer = nn.LSTM(embedding_size, hidden_size, num_layers, batch_first=True).to(self.device) + self.linear_layer = nn.Linear(hidden_size, output_size).to(self.device) + + def forward(self, x, lengths, hiddens=None): + x = self.embedding_layer(x) + x = rnn_utils.pack_padded_sequence(x, lengths, batch_first=True, enforce_sorted=False) + x, hiddens = self.lstm_layer(x, hiddens) + x, _ = rnn_utils.pad_packed_sequence(x, batch_first=True) + logits = self.linear_layer(x) + print(logits.shape) + exit() + return logits + +class Reward(nn.Module): + def __init__(self, vocab_size, pad_idx, embedding_size, num_layers, hidden_size, dropout, device): + super(Reward, self).__init__() + self.device = device + self.embedding_layer = nn.Embedding(vocab_size, embedding_size, padding_idx=pad_idx).to(self.device) + self.lstm_layer = nn.LSTM(embedding_size, hidden_size, num_layers, batch_first=True).to(self.device) + self.linear_layer = nn.Linear(hidden_size, 1).to(self.device) + + def forward(self, x, lengths, hiddens=None): + x = self.embedding_layer(x) + x = rnn_utils.pack_padded_sequence(x, lengths, batch_first=True, enforce_sorted=False) + _, (h_last, _) = self.lstm_layer(x, hiddens) + preds = self.linear_layer(h_last[-1]).squeeze(-1) + return preds + +def get_params(model): + return (p for p in model.parameters() if p.requires_grad) + +@hydra.main(config_path='cfgs', config_name='mbac', version_base=None) +def main(cfg: DictConfig): + hydra_cfg = hydra.core.hydra_config.HydraConfig.get() + + if cfg.wandb_log: + import wandb + project_name = 'rl4chem_' + cfg.target + wandb.init(project=project_name, entity=cfg.wandb_entity, config=dict(cfg), dir=hydra_cfg['runtime']['output_dir']) + wandb.run.name = cfg.wandb_run_name + + device = torch.device("cuda" if torch.cuda.is_available() and cfg.device == 'cuda' else "cpu") + + #set seed + random.seed(cfg.seed) + np.random.seed(cfg.seed) + torch.manual_seed(cfg.seed) + torch.cuda.manual_seed_all(cfg.seed) + + #get vocab + from env import selfies_vocabulary + vocab = selfies_vocabulary() + + #get replay buffer + rb = utils.ReplayBuffer(cfg.env_buffer_size) + + #get model + cfg.vocab_size = len(vocab) + cfg.pad_idx = vocab.pad + actor_model = hydra.utils.instantiate(cfg.actor) + reward_model = hydra.utils.instantiate(cfg.reward) + + #set optimizer + actor_optimizer = torch.optim.Adam(get_params(actor_model), lr=cfg.lr['actor']) + reward_optimizer = optim.Adam(get_params(reward_model), lr=cfg.lr['reward']) + + max_length = 100 + train_step = 0 + while train_step < cfg.num_train_steps: + with torch.no_grad(): + starts = torch.full((cfg.parallel_molecules, 1), fill_value=vocab.bos, dtype=torch.long, device=device) + + new_smiles_list = [ + torch.tensor(vocab.pad, dtype=torch.long, + device=device).repeat(max_length + 2) + for _ in range(cfg.parallel_molecules)] + + print(new_smiles_list) + exit() + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/utils.py b/utils.py index 395e46c..472360e 100644 --- a/utils.py +++ b/utils.py @@ -1,9 +1,29 @@ +import random import numpy as np import torch.nn as nn from typing import Iterable +from collections import namedtuple, deque # Replay memory +Transition = namedtuple('Transition', + ('action', 'next_state', 'reward', 'length')) + +class ReplayBuffer(object): + + def __init__(self, capacity): + self.memory = deque([], maxlen=capacity) + + def push(self, *args): + """Save a transition""" + self.memory.append(Transition(*args)) + + def sample(self, batch_size): + return random.sample(self.memory, batch_size) + + def __len__(self): + return len(self.memory) + class ReplayMemory(): def __init__(self, buffer_limit, obs_dims, obs_dtype, action_dtype): self.buffer_limit = buffer_limit From 9f2ccde59f998feb7c45a61d394f20f7c15ae3fd Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Fri, 10 Mar 2023 19:38:12 +0530 Subject: [PATCH 31/34] adding dqn as agent --- .gitignore | 3 +- cfgs/config.yaml | 13 +++--- cfgs/mbac.yaml | 73 -------------------------------- dqn.py | 108 +++++++++++++++++++++++++++++++++++++++++++++++ train.py | 22 +++++++--- 5 files changed, 132 insertions(+), 87 deletions(-) delete mode 100644 cfgs/mbac.yaml create mode 100644 dqn.py diff --git a/.gitignore b/.gitignore index 97e4948..cbeaa88 100644 --- a/.gitignore +++ b/.gitignore @@ -13,7 +13,7 @@ MUJOCO_LOG.TXT saved/ #virtual env -env_rl4chem/ +env_* #notebooks .ipynb_checkpoints/ @@ -29,6 +29,7 @@ data/ #package dependencies dockstring/ openbabel.git +oracle/ #local experiments store_room/ diff --git a/cfgs/config.yaml b/cfgs/config.yaml index 82074da..71c9766 100644 --- a/cfgs/config.yaml +++ b/cfgs/config.yaml @@ -1,4 +1,4 @@ -agent: 'sac' +agent: 'dqn' #common id: 'docking' @@ -30,13 +30,10 @@ action_dtype: #learning gamma: 0.99 -tau: 0.01 -target_update_interval: 1 -policy_update_interval: 2 -lr: {'actor':3e-4, 'critic':1e-3, 'alpha':1e-3} - -#exploration -entropy_coefficient: 0.1 +tau: 1.0 +update_interval: 10 +target_update_interval: 500 +lr: {'q':2.5e-4} #hidden_dims and layers hidden_dims: 256 diff --git a/cfgs/mbac.yaml b/cfgs/mbac.yaml deleted file mode 100644 index 21b5ec3..0000000 --- a/cfgs/mbac.yaml +++ /dev/null @@ -1,73 +0,0 @@ -#common -id: 'docking' -device: 'cuda' -seed: 1 - -#environment specific -target: 'fa7' -selfies_enc_type: 'index' -max_selfie_length: 22 -vina_program: 'qvina2' -temp_dir: 'tmp' -exhaustiveness: 1 -num_sub_proc: 12 -num_cpu_dock: 1 -num_modes: 10 -timeout_gen3d: 30 -timeout_dock: 100 - -#data -num_train_steps: 100000 -env_buffer_size: 100000 -explore_molecules: 250 -parallel_molecules: 250 -batch_size: 256 -obs_dtype: -action_dtype: - -#learning -lr: {'actor':1e-4, 'reward':1e-4, 'alpha':1e-3} -max_grad_norm: 0.5 -vocab_size: -pad_idx: - -#Actor -actor: - _target_: mbac.Actor - vocab_size: ${vocab_size} - pad_idx: ${pad_idx} - device: ${device} - output_size: ${vocab_size} - num_layers: 3 - hidden_size: 256 - embedding_size: 32 - -#Reward -reward: - _target_: mbac.Reward - vocab_size: ${vocab_size} - pad_idx: ${pad_idx} - device: ${device} - num_layers: 3 - hidden_size: 256 - embedding_size: 32 - -#evaluation -eval_episode_interval: 10000 -num_eval_episodes: 5 - -#logging -wandb_log: False -wandb_entity: 'raj19' -wandb_run_name: 'mbac-disc' -agent_log_interval: 100 - -#saving -save_snapshot: False -save_snapshot_interval: 100000 - -hydra: - run: - dir: ./local_exp/${now:%Y.%m.%d}/${now:%H.%M.%S}_${seed} - job: - chdir: False \ No newline at end of file diff --git a/dqn.py b/dqn.py new file mode 100644 index 0000000..6b980ec --- /dev/null +++ b/dqn.py @@ -0,0 +1,108 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.distributions as td +import numpy as np +import random +import wandb + +import utils + +class QNetwork(nn.Module): + def __init__(self, input_dims, hidden_dims, output_dims): + super().__init__() + self.network = nn.Sequential( + nn.Linear(input_dims, hidden_dims), + nn.ReLU(), nn.Linear(hidden_dims, hidden_dims), nn.LayerNorm(hidden_dims), + nn.ReLU(), nn.Linear(hidden_dims, output_dims)) + + def forward(self, x): + return self.network(x) + +class DQNAgent: + def __init__(self, device, obs_dims, num_actions, + gamma, tau, update_interval, target_update_interval, lr, batch_size, + hidden_dims, wandb_log, log_interval): + + self.device = device + + #learning + self.gamma = gamma + self.tau = tau + self.update_interval = update_interval + self.target_update_interval = target_update_interval + self.batch_size = batch_size + + #logging + self.wandb_log = wandb_log + self.log_interval = log_interval + + self._init_networks(obs_dims, num_actions, hidden_dims) + self._init_optims(lr) + + def get_action(self, obs, eval=False): + with torch.no_grad(): + obs = torch.tensor(obs, dtype=torch.float32, device=self.device) + q_values = self.q(obs) + action = torch.argmax(q_values) + return action.cpu().numpy() + + def _init_networks(self, obs_dims, num_actions, hidden_dims): + self.q = QNetwork(obs_dims, hidden_dims, num_actions).to(self.device) + self.q_target = QNetwork(obs_dims, hidden_dims, num_actions).to(self.device) + utils.hard_update(self.q_target, self.q) + + def _init_optims(self, lr): + self.q_opt = torch.optim.Adam(self.q.parameters(), lr=lr["q"]) + + def get_save_dict(self): + return { + "q": self.q.state_dict(), + "q_target":self.q_target.state_dict(), + } + + def load_save_dict(self, saved_dict): + self.q.load_state_dict(saved_dict["q"]) + self.q_target.load_state_dict(saved_dict["q_target"]) + + def update(self, buffer, step): + metrics = dict() + if step % self.log_interval == 0 and self.wandb_log: + log = True + else: + log = False + + if step % self.update_interval == 0: + state_batch, action_batch, reward_batch, next_state_batch, done_batch, time_batch = buffer.sample(self.batch_size) + state_batch = torch.tensor(state_batch, dtype=torch.float32, device=self.device) + next_state_batch = torch.tensor(next_state_batch, dtype=torch.float32, device=self.device) + action_batch = torch.tensor(action_batch, dtype=torch.long, device=self.device) + reward_batch = torch.tensor(reward_batch, dtype=torch.float32, device=self.device) + done_batch = torch.tensor(done_batch, dtype=torch.float32, device=self.device) + discount_batch = self.gamma*(1-done_batch) + + with torch.no_grad(): + target_max, _ = self.q_target(next_state_batch).max(dim=1) + td_target = reward_batch + self.gamma * target_max * discount_batch + + old_val = self.q(state_batch).gather(1, action_batch).squeeze() + + loss = F.mse_loss(td_target, old_val) + self.q_opt.zero_grad() + loss.backward() + self.q_opt.step() + + if log: + metrics['mean_q_target'] = torch.mean(td_target).item() + metrics['max_reward'] = torch.max(reward_batch).item() + metrics['min_reward'] = torch.min(reward_batch).item() + metrics['variance_q_target'] = torch.var(td_target).item() + metrics['min_q_target'] = torch.min(td_target).item() + metrics['max_q_target'] = torch.max(td_target).item() + metrics['critic_loss'] = loss.item() + + if step % self.target_update_interval == 0: + utils.soft_update(self.q_target, self.q, self.tau) + + if log: + wandb.log(metrics, step=step) \ No newline at end of file diff --git a/train.py b/train.py index 472f41e..2c7d8d8 100644 --- a/train.py +++ b/train.py @@ -41,6 +41,13 @@ def make_agent(env, device, cfg): agent = SacAgent(device, obs_dims, num_actions, cfg.gamma, cfg.tau, cfg.policy_update_interval, cfg.target_update_interval, cfg.lr, cfg.batch_size, cfg.entropy_coefficient, cfg.hidden_dims, cfg.wandb_log, cfg.agent_log_interval) + + elif cfg.agent == 'dqn': + from dqn import DQNAgent + agent = DQNAgent(device, obs_dims, num_actions, cfg.gamma, cfg.tau, + cfg.update_interval, cfg.target_update_interval, cfg.lr, cfg.batch_size, + cfg.hidden_dims, cfg.wandb_log, cfg.agent_log_interval) + else: raise NotImplementedError return agent, env_buffer, fresh_env_buffer, docking_buffer @@ -97,14 +104,20 @@ def explore(cfg, train_env, env_buffer, fresh_env_buffer, docking_buffer): return parallel_reward_batch -def collect_molecule(env, agent, fresh_env_buffer): +def collect_molecule(env, agent, fresh_env_buffer, train_step, num_train_steps): state, done, t = env.reset(), False, 0 while not done: - action = agent.get_action(state) + epsilon = utils.linear_schedule(1, 0.05, 0.5 * num_train_steps, train_step+t) + if random.random() < epsilon: + action = np.random.randint(env.num_actions) + else: + action = agent.get_action(state) next_state, reward, done, info = env.step(action) fresh_env_buffer.push((state, action, reward, next_state, done, t)) t += 1 state = next_state + + info['episode']['last epsilon'] = epsilon return info['episode'] def train(cfg): @@ -128,8 +141,7 @@ def train(cfg): unique_molecule_counter = 0 while train_step < cfg.num_train_steps: - - episode_info = collect_molecule(train_env, agent, fresh_env_buffer) + episode_info = collect_molecule(train_env, agent, fresh_env_buffer, train_step, cfg.num_train_steps) molecule_counter += 1 if docking_buffer[episode_info['smiles']] is not None: fresh_env_buffer.update_last_episode_reward(docking_buffer[episode_info['smiles']]) @@ -137,7 +149,7 @@ def train(cfg): docking_buffer[episode_info['smiles']] = 0 train_env._add_smiles_to_batch(episode_info['smiles']) unique_molecule_counter += 1 - + for _ in range(episode_info['l']): agent.update(env_buffer, train_step) train_step += 1 From 040387d0b284e57828d35934b7e5b2231da00453 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Fri, 10 Mar 2023 20:25:03 +0530 Subject: [PATCH 32/34] adding fast dqn to cedar --- cfgs/config.yaml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/cfgs/config.yaml b/cfgs/config.yaml index 71c9766..dc86750 100644 --- a/cfgs/config.yaml +++ b/cfgs/config.yaml @@ -24,15 +24,15 @@ env_buffer_size: 100000 explore_molecules: 250 parallel_molecules: 250 -batch_size: 256 +batch_size: 128 obs_dtype: action_dtype: #learning gamma: 0.99 -tau: 1.0 -update_interval: 10 -target_update_interval: 500 +tau: 0.01 +update_interval: 1 +target_update_interval: 1 lr: {'q':2.5e-4} #hidden_dims and layers @@ -45,7 +45,7 @@ num_eval_episodes: 5 #logging wandb_log: False wandb_entity: 'raj19' -wandb_run_name: 'sac-disc' +wandb_run_name: 'dqn-disc' agent_log_interval: 100 #saving From 57d449c94f0f92a6d620a5d2785e6263d2761da5 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Fri, 10 Mar 2023 21:24:52 +0530 Subject: [PATCH 33/34] bring back sac --- cfgs/config.yaml | 13 +++--- mbac.py | 105 --------------------------------------------- scripts/cedar/1.sh | 4 +- train.py | 22 +++------- 4 files changed, 15 insertions(+), 129 deletions(-) delete mode 100644 mbac.py diff --git a/cfgs/config.yaml b/cfgs/config.yaml index dc86750..82074da 100644 --- a/cfgs/config.yaml +++ b/cfgs/config.yaml @@ -1,4 +1,4 @@ -agent: 'dqn' +agent: 'sac' #common id: 'docking' @@ -24,16 +24,19 @@ env_buffer_size: 100000 explore_molecules: 250 parallel_molecules: 250 -batch_size: 128 +batch_size: 256 obs_dtype: action_dtype: #learning gamma: 0.99 tau: 0.01 -update_interval: 1 target_update_interval: 1 -lr: {'q':2.5e-4} +policy_update_interval: 2 +lr: {'actor':3e-4, 'critic':1e-3, 'alpha':1e-3} + +#exploration +entropy_coefficient: 0.1 #hidden_dims and layers hidden_dims: 256 @@ -45,7 +48,7 @@ num_eval_episodes: 5 #logging wandb_log: False wandb_entity: 'raj19' -wandb_run_name: 'dqn-disc' +wandb_run_name: 'sac-disc' agent_log_interval: 100 #saving diff --git a/mbac.py b/mbac.py deleted file mode 100644 index 9e71ee1..0000000 --- a/mbac.py +++ /dev/null @@ -1,105 +0,0 @@ -import time -import hydra -import random -import numpy as np - -import torch -import torch.nn as nn -import torch.optim as optim -import torch.nn.functional as F -import torch.distributions as td -import torch.nn.utils.rnn as rnn_utils - -from omegaconf import DictConfig -from collections import defaultdict - -import utils - -class Actor(nn.Module): - def __init__(self, vocab_size, pad_idx, embedding_size, num_layers, hidden_size, output_size, device, dist='categorical'): - super(Actor, self).__init__() - self.device = device - self.embedding_layer = nn.Embedding(vocab_size, embedding_size, padding_idx=pad_idx).to(self.device) - self.lstm_layer = nn.LSTM(embedding_size, hidden_size, num_layers, batch_first=True).to(self.device) - self.linear_layer = nn.Linear(hidden_size, output_size).to(self.device) - - def forward(self, x, lengths, hiddens=None): - x = self.embedding_layer(x) - x = rnn_utils.pack_padded_sequence(x, lengths, batch_first=True, enforce_sorted=False) - x, hiddens = self.lstm_layer(x, hiddens) - x, _ = rnn_utils.pad_packed_sequence(x, batch_first=True) - logits = self.linear_layer(x) - print(logits.shape) - exit() - return logits - -class Reward(nn.Module): - def __init__(self, vocab_size, pad_idx, embedding_size, num_layers, hidden_size, dropout, device): - super(Reward, self).__init__() - self.device = device - self.embedding_layer = nn.Embedding(vocab_size, embedding_size, padding_idx=pad_idx).to(self.device) - self.lstm_layer = nn.LSTM(embedding_size, hidden_size, num_layers, batch_first=True).to(self.device) - self.linear_layer = nn.Linear(hidden_size, 1).to(self.device) - - def forward(self, x, lengths, hiddens=None): - x = self.embedding_layer(x) - x = rnn_utils.pack_padded_sequence(x, lengths, batch_first=True, enforce_sorted=False) - _, (h_last, _) = self.lstm_layer(x, hiddens) - preds = self.linear_layer(h_last[-1]).squeeze(-1) - return preds - -def get_params(model): - return (p for p in model.parameters() if p.requires_grad) - -@hydra.main(config_path='cfgs', config_name='mbac', version_base=None) -def main(cfg: DictConfig): - hydra_cfg = hydra.core.hydra_config.HydraConfig.get() - - if cfg.wandb_log: - import wandb - project_name = 'rl4chem_' + cfg.target - wandb.init(project=project_name, entity=cfg.wandb_entity, config=dict(cfg), dir=hydra_cfg['runtime']['output_dir']) - wandb.run.name = cfg.wandb_run_name - - device = torch.device("cuda" if torch.cuda.is_available() and cfg.device == 'cuda' else "cpu") - - #set seed - random.seed(cfg.seed) - np.random.seed(cfg.seed) - torch.manual_seed(cfg.seed) - torch.cuda.manual_seed_all(cfg.seed) - - #get vocab - from env import selfies_vocabulary - vocab = selfies_vocabulary() - - #get replay buffer - rb = utils.ReplayBuffer(cfg.env_buffer_size) - - #get model - cfg.vocab_size = len(vocab) - cfg.pad_idx = vocab.pad - actor_model = hydra.utils.instantiate(cfg.actor) - reward_model = hydra.utils.instantiate(cfg.reward) - - #set optimizer - actor_optimizer = torch.optim.Adam(get_params(actor_model), lr=cfg.lr['actor']) - reward_optimizer = optim.Adam(get_params(reward_model), lr=cfg.lr['reward']) - - max_length = 100 - train_step = 0 - while train_step < cfg.num_train_steps: - with torch.no_grad(): - starts = torch.full((cfg.parallel_molecules, 1), fill_value=vocab.bos, dtype=torch.long, device=device) - - new_smiles_list = [ - torch.tensor(vocab.pad, dtype=torch.long, - device=device).repeat(max_length + 2) - for _ in range(cfg.parallel_molecules)] - - print(new_smiles_list) - exit() - - -if __name__ == "__main__": - main() \ No newline at end of file diff --git a/scripts/cedar/1.sh b/scripts/cedar/1.sh index 6165a06..5345f7c 100644 --- a/scripts/cedar/1.sh +++ b/scripts/cedar/1.sh @@ -9,8 +9,8 @@ array=(-1 "fa7" "parp1" "5ht1b") -rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_rl4chem +rsync -a $HOME/projects/def-gberseth/$USER/RL4Chem/ $SLURM_TMPDIR/RL4Chem --exclude=env_crl echo "moved code to slurm tmpdir" singularity exec --nv --home $SLURM_TMPDIR --env WANDB_API_KEY="7da29c1c6b185d3ab2d67e399f738f0f0831abfc",REQUESTS_CA_BUNDLE="/usr/local/envs/rl4chem/lib/python3.11/site-packages/certifi/cacert.pem",HYDRA_FULL_ERROR=1 $SCRATCH/rl4chem.sif bash -c "source activate rl4chem && cd RL4Chem &&\ -python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=22 wandb_log=True wandb_run_name=ln_max_len_22 seed=1 num_sub_proc=20" \ No newline at end of file +python train.py target=${array[SLURM_ARRAY_TASK_ID]} max_selfie_length=22 wandb_log=True wandb_run_name=dqn_ln_max_len_22 seed=1 num_sub_proc=20" \ No newline at end of file diff --git a/train.py b/train.py index 2c7d8d8..472f41e 100644 --- a/train.py +++ b/train.py @@ -41,13 +41,6 @@ def make_agent(env, device, cfg): agent = SacAgent(device, obs_dims, num_actions, cfg.gamma, cfg.tau, cfg.policy_update_interval, cfg.target_update_interval, cfg.lr, cfg.batch_size, cfg.entropy_coefficient, cfg.hidden_dims, cfg.wandb_log, cfg.agent_log_interval) - - elif cfg.agent == 'dqn': - from dqn import DQNAgent - agent = DQNAgent(device, obs_dims, num_actions, cfg.gamma, cfg.tau, - cfg.update_interval, cfg.target_update_interval, cfg.lr, cfg.batch_size, - cfg.hidden_dims, cfg.wandb_log, cfg.agent_log_interval) - else: raise NotImplementedError return agent, env_buffer, fresh_env_buffer, docking_buffer @@ -104,20 +97,14 @@ def explore(cfg, train_env, env_buffer, fresh_env_buffer, docking_buffer): return parallel_reward_batch -def collect_molecule(env, agent, fresh_env_buffer, train_step, num_train_steps): +def collect_molecule(env, agent, fresh_env_buffer): state, done, t = env.reset(), False, 0 while not done: - epsilon = utils.linear_schedule(1, 0.05, 0.5 * num_train_steps, train_step+t) - if random.random() < epsilon: - action = np.random.randint(env.num_actions) - else: - action = agent.get_action(state) + action = agent.get_action(state) next_state, reward, done, info = env.step(action) fresh_env_buffer.push((state, action, reward, next_state, done, t)) t += 1 state = next_state - - info['episode']['last epsilon'] = epsilon return info['episode'] def train(cfg): @@ -141,7 +128,8 @@ def train(cfg): unique_molecule_counter = 0 while train_step < cfg.num_train_steps: - episode_info = collect_molecule(train_env, agent, fresh_env_buffer, train_step, cfg.num_train_steps) + + episode_info = collect_molecule(train_env, agent, fresh_env_buffer) molecule_counter += 1 if docking_buffer[episode_info['smiles']] is not None: fresh_env_buffer.update_last_episode_reward(docking_buffer[episode_info['smiles']]) @@ -149,7 +137,7 @@ def train(cfg): docking_buffer[episode_info['smiles']] = 0 train_env._add_smiles_to_batch(episode_info['smiles']) unique_molecule_counter += 1 - + for _ in range(episode_info['l']): agent.update(env_buffer, train_step) train_step += 1 From e104ff52fae218fdb75ddb01729d78f4086d1545 Mon Sep 17 00:00:00 2001 From: RajGhugare19 Date: Sat, 11 Mar 2023 11:03:34 +0530 Subject: [PATCH 34/34] removing mback utils --- utils.py | 21 +-------------------- 1 file changed, 1 insertion(+), 20 deletions(-) diff --git a/utils.py b/utils.py index 472360e..bb5a294 100644 --- a/utils.py +++ b/utils.py @@ -5,25 +5,6 @@ from collections import namedtuple, deque # Replay memory - -Transition = namedtuple('Transition', - ('action', 'next_state', 'reward', 'length')) - -class ReplayBuffer(object): - - def __init__(self, capacity): - self.memory = deque([], maxlen=capacity) - - def push(self, *args): - """Save a transition""" - self.memory.append(Transition(*args)) - - def sample(self, batch_size): - return random.sample(self.memory, batch_size) - - def __len__(self): - return len(self.memory) - class ReplayMemory(): def __init__(self, buffer_limit, obs_dims, obs_dtype, action_dtype): self.buffer_limit = buffer_limit @@ -81,7 +62,7 @@ def sample(self, n): def __len__(self): return self.buffer_limit if self.full else self.idx+1 - + class FreshReplayMemory(): def __init__(self, num_episodes, max_episode_len, obs_dims, obs_dtype, action_dtype): self.obs_dtype = obs_dtype