Download annotations/annotation_42/HTML/transfer_learning/chem/splitters.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 15.3 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_42/HTML/transfer_learning/chem/splitters.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_42/HTML/transfer_learning/chem/splitters.py
-
curl -L -o splitters.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_42/HTML/transfer_learning/chem/splitters.py
15.3 kB
| import torch | |
| import random | |
| import numpy as np | |
| from itertools import compress | |
| from rdkit.Chem.Scaffolds import MurckoScaffold | |
| from collections import defaultdict | |
| from sklearn.model_selection import StratifiedKFold | |
| # splitter function | |
| def generate_scaffold(smiles, include_chirality=False): | |
| """ | |
| Obtain Bemis-Murcko scaffold from smiles | |
| :param smiles: | |
| :param include_chirality: | |
| :return: smiles of scaffold | |
| """ | |
| scaffold = MurckoScaffold.MurckoScaffoldSmiles( | |
| smiles=smiles, includeChirality=include_chirality) | |
| return scaffold | |
| # # test generate_scaffold | |
| # s = 'Cc1cc(Oc2nccc(CCC)c2)ccc1' | |
| # scaffold = generate_scaffold(s) | |
| # assert scaffold == 'c1ccc(Oc2ccccn2)cc1' | |
| def scaffold_split(dataset, smiles_list, task_idx=None, null_value=0, | |
| frac_train=0.8, frac_valid=0.1, frac_test=0.1, | |
| return_smiles=False): | |
| """ | |
| Adapted from https://github.com/deepchem/deepchem/blob/master/deepchem/splits/splitters.py | |
| Split dataset by Bemis-Murcko scaffolds | |
| This function can also ignore examples containing null values for a | |
| selected task when splitting. Deterministic split | |
| :param dataset: pytorch geometric dataset obj | |
| :param smiles_list: list of smiles corresponding to the dataset obj | |
| :param task_idx: column idx of the data.y tensor. Will filter out | |
| examples with null value in specified task column of the data.y tensor | |
| prior to splitting. If None, then no filtering | |
| :param null_value: float that specifies null value in data.y to filter if | |
| task_idx is provided | |
| :param frac_train: | |
| :param frac_valid: | |
| :param frac_test: | |
| :param return_smiles: | |
| :return: train, valid, test slices of the input dataset obj. If | |
| return_smiles = True, also returns ([train_smiles_list], | |
| [valid_smiles_list], [test_smiles_list]) | |
| """ | |
| np.testing.assert_almost_equal(frac_train + frac_valid + frac_test, 1.0) | |
| if task_idx != None: | |
| # filter based on null values in task_idx | |
| # get task array | |
| y_task = np.array([data.y[task_idx].item() for data in dataset]) | |
| # boolean array that correspond to non null values | |
| non_null = y_task != null_value | |
| smiles_list = list(compress(enumerate(smiles_list), non_null)) | |
| else: | |
| non_null = np.ones(len(dataset)) == 1 | |
| smiles_list = list(compress(enumerate(smiles_list), non_null)) | |
| # create dict of the form {scaffold_i: [idx1, idx....]} | |
| all_scaffolds = {} | |
| for i, smiles in smiles_list: | |
| scaffold = generate_scaffold(smiles, include_chirality=True) | |
| if scaffold not in all_scaffolds: | |
| all_scaffolds[scaffold] = [i] | |
| else: | |
| all_scaffolds[scaffold].append(i) | |
| # sort from largest to smallest sets | |
| all_scaffolds = {key: sorted(value) for key, value in all_scaffolds.items()} | |
| all_scaffold_sets = [ | |
| scaffold_set for (scaffold, scaffold_set) in sorted( | |
| all_scaffolds.items(), key=lambda x: (len(x[1]), x[1][0]), reverse=True) | |
| ] | |
| # get train, valid test indices | |
| train_cutoff = frac_train * len(smiles_list) | |
| valid_cutoff = (frac_train + frac_valid) * len(smiles_list) | |
| train_idx, valid_idx, test_idx = [], [], [] | |
| for scaffold_set in all_scaffold_sets: | |
| if len(train_idx) + len(scaffold_set) > train_cutoff: | |
| if len(train_idx) + len(valid_idx) + len(scaffold_set) > valid_cutoff: | |
| test_idx.extend(scaffold_set) | |
| else: | |
| valid_idx.extend(scaffold_set) | |
| else: | |
| train_idx.extend(scaffold_set) | |
| assert len(set(train_idx).intersection(set(valid_idx))) == 0 | |
| assert len(set(test_idx).intersection(set(valid_idx))) == 0 | |
| train_dataset = dataset[torch.tensor(train_idx)] | |
| valid_dataset = dataset[torch.tensor(valid_idx)] | |
| test_dataset = dataset[torch.tensor(test_idx)] | |
| if not return_smiles: | |
| return train_dataset, valid_dataset, test_dataset | |
| else: | |
| train_smiles = [smiles_list[i][1] for i in train_idx] | |
| valid_smiles = [smiles_list[i][1] for i in valid_idx] | |
| test_smiles = [smiles_list[i][1] for i in test_idx] | |
| return train_dataset, valid_dataset, test_dataset, (train_smiles, | |
| valid_smiles, | |
| test_smiles) | |
| def random_scaffold_split(dataset, smiles_list, task_idx=None, null_value=0, | |
| frac_train=0.8, frac_valid=0.1, frac_test=0.1, seed=0): | |
| """ | |
| Adapted from https://github.com/pfnet-research/chainer-chemistry/blob/master/chainer_chemistry/dataset/splitters/scaffold_splitter.py | |
| Split dataset by Bemis-Murcko scaffolds | |
| This function can also ignore examples containing null values for a | |
| selected task when splitting. Deterministic split | |
| :param dataset: pytorch geometric dataset obj | |
| :param smiles_list: list of smiles corresponding to the dataset obj | |
| :param task_idx: column idx of the data.y tensor. Will filter out | |
| examples with null value in specified task column of the data.y tensor | |
| prior to splitting. If None, then no filtering | |
| :param null_value: float that specifies null value in data.y to filter if | |
| task_idx is provided | |
| :param frac_train: | |
| :param frac_valid: | |
| :param frac_test: | |
| :param seed; | |
| :return: train, valid, test slices of the input dataset obj | |
| """ | |
| np.testing.assert_almost_equal(frac_train + frac_valid + frac_test, 1.0) | |
| if task_idx != None: | |
| # filter based on null values in task_idx | |
| # get task array | |
| y_task = np.array([data.y[task_idx].item() for data in dataset]) | |
| # boolean array that correspond to non null values | |
| non_null = y_task != null_value | |
| smiles_list = list(compress(enumerate(smiles_list), non_null)) | |
| else: | |
| non_null = np.ones(len(dataset)) == 1 | |
| smiles_list = list(compress(enumerate(smiles_list), non_null)) | |
| rng = np.random.RandomState(seed) | |
| scaffolds = defaultdict(list) | |
| for ind, smiles in smiles_list: | |
| scaffold = generate_scaffold(smiles, include_chirality=True) | |
| scaffolds[scaffold].append(ind) | |
| scaffold_sets = rng.permutation(list(scaffolds.values())) | |
| n_total_valid = int(np.floor(frac_valid * len(dataset))) | |
| n_total_test = int(np.floor(frac_test * len(dataset))) | |
| train_idx = [] | |
| valid_idx = [] | |
| test_idx = [] | |
| for scaffold_set in scaffold_sets: | |
| if len(valid_idx) + len(scaffold_set) <= n_total_valid: | |
| valid_idx.extend(scaffold_set) | |
| elif len(test_idx) + len(scaffold_set) <= n_total_test: | |
| test_idx.extend(scaffold_set) | |
| else: | |
| train_idx.extend(scaffold_set) | |
| train_dataset = dataset[torch.tensor(train_idx)] | |
| valid_dataset = dataset[torch.tensor(valid_idx)] | |
| test_dataset = dataset[torch.tensor(test_idx)] | |
| return train_dataset, valid_dataset, test_dataset | |
| def random_split(dataset, task_idx=None, null_value=0, | |
| frac_train=0.8, frac_valid=0.1, frac_test=0.1, seed=0, | |
| smiles_list=None): | |
| """ | |
| :param dataset: | |
| :param task_idx: | |
| :param null_value: | |
| :param frac_train: | |
| :param frac_valid: | |
| :param frac_test: | |
| :param seed: | |
| :param smiles_list: list of smiles corresponding to the dataset obj, or None | |
| :return: train, valid, test slices of the input dataset obj. If | |
| smiles_list != None, also returns ([train_smiles_list], | |
| [valid_smiles_list], [test_smiles_list]) | |
| """ | |
| np.testing.assert_almost_equal(frac_train + frac_valid + frac_test, 1.0) | |
| if task_idx != None: | |
| # filter based on null values in task_idx | |
| # get task array | |
| y_task = np.array([data.y[task_idx].item() for data in dataset]) | |
| non_null = y_task != null_value # boolean array that correspond to non null values | |
| idx_array = np.where(non_null)[0] | |
| dataset = dataset[torch.tensor(idx_array)] # examples containing non | |
| # null labels in the specified task_idx | |
| else: | |
| pass | |
| num_mols = len(dataset) | |
| random.seed(seed) | |
| all_idx = list(range(num_mols)) | |
| random.shuffle(all_idx) | |
| train_idx = all_idx[:int(frac_train * num_mols)] | |
| valid_idx = all_idx[int(frac_train * num_mols):int(frac_valid * num_mols) | |
| + int(frac_train * num_mols)] | |
| test_idx = all_idx[int(frac_valid * num_mols) + int(frac_train * num_mols):] | |
| assert len(set(train_idx).intersection(set(valid_idx))) == 0 | |
| assert len(set(valid_idx).intersection(set(test_idx))) == 0 | |
| assert len(train_idx) + len(valid_idx) + len(test_idx) == num_mols | |
| train_dataset = dataset[torch.tensor(train_idx)] | |
| valid_dataset = dataset[torch.tensor(valid_idx)] | |
| test_dataset = dataset[torch.tensor(test_idx)] | |
| if not smiles_list: | |
| return train_dataset, valid_dataset, test_dataset | |
| else: | |
| train_smiles = [smiles_list[i] for i in train_idx] | |
| valid_smiles = [smiles_list[i] for i in valid_idx] | |
| test_smiles = [smiles_list[i] for i in test_idx] | |
| return train_dataset, valid_dataset, test_dataset, (train_smiles, | |
| valid_smiles, | |
| test_smiles) | |
| def cv_random_split(dataset, fold_idx = 0, | |
| frac_train=0.9, frac_valid=0.1, seed=0, | |
| smiles_list=None): | |
| """ | |
| :param dataset: | |
| :param task_idx: | |
| :param null_value: | |
| :param frac_train: | |
| :param frac_valid: | |
| :param frac_test: | |
| :param seed: | |
| :param smiles_list: list of smiles corresponding to the dataset obj, or None | |
| :return: train, valid, test slices of the input dataset obj. If | |
| smiles_list != None, also returns ([train_smiles_list], | |
| [valid_smiles_list], [test_smiles_list]) | |
| """ | |
| np.testing.assert_almost_equal(frac_train + frac_valid, 1.0) | |
| skf = StratifiedKFold(n_splits=10, shuffle = True, random_state = seed) | |
| labels = [data.y.item() for data in dataset] | |
| idx_list = [] | |
| for idx in skf.split(np.zeros(len(labels)), labels): | |
| idx_list.append(idx) | |
| train_idx, val_idx = idx_list[fold_idx] | |
| train_dataset = dataset[torch.tensor(train_idx)] | |
| valid_dataset = dataset[torch.tensor(val_idx)] | |
| return train_dataset, valid_dataset | |
| if __name__ == "__main__": | |
| from loader import MoleculeDataset | |
| from rdkit import Chem | |
| import pandas as pd | |
| # # test scaffold_split | |
| dataset = MoleculeDataset('dataset/tox21', dataset='tox21') | |
| smiles_list = pd.read_csv('dataset/tox21/processed/smiles.csv', header=None)[0].tolist() | |
| train_dataset, valid_dataset, test_dataset = scaffold_split(dataset, smiles_list, task_idx=None, null_value=0, frac_train=0.8,frac_valid=0.1, frac_test=0.1) | |
| # train_dataset, valid_dataset, test_dataset = random_scaffold_split(dataset, smiles_list, task_idx=None, null_value=0, frac_train=0.8,frac_valid=0.1, frac_test=0.1, seed = 0) | |
| unique_ids = set(train_dataset.data.id.tolist() + | |
| valid_dataset.data.id.tolist() + | |
| test_dataset.data.id.tolist()) | |
| assert len(unique_ids) == len(dataset) # check that we did not have any | |
| # missing or overlapping examples | |
| # test scaffold_split with smiles returned | |
| dataset = MoleculeDataset('dataset/bbbp', dataset='bbbp') | |
| smiles_list = pd.read_csv('dataset/bbbp/processed/smiles.csv', header=None)[ | |
| 0].tolist() | |
| train_dataset, valid_dataset, test_dataset, (train_smiles, valid_smiles, | |
| test_smiles) = \ | |
| scaffold_split(dataset, smiles_list, task_idx=None, null_value=0, | |
| frac_train=0.8,frac_valid=0.1, frac_test=0.1, | |
| return_smiles=True) | |
| assert len(train_dataset) == len(train_smiles) | |
| for i in range(len(train_dataset)): | |
| data_obj_n_atoms = train_dataset[i].x.size()[0] | |
| smiles_n_atoms = len(list(Chem.MolFromSmiles(train_smiles[ | |
| i]).GetAtoms())) | |
| assert data_obj_n_atoms == smiles_n_atoms | |
| assert len(valid_dataset) == len(valid_smiles) | |
| for i in range(len(valid_dataset)): | |
| data_obj_n_atoms = valid_dataset[i].x.size()[0] | |
| smiles_n_atoms = len(list(Chem.MolFromSmiles(valid_smiles[ | |
| i]).GetAtoms())) | |
| assert data_obj_n_atoms == smiles_n_atoms | |
| assert len(test_dataset) == len(test_smiles) | |
| for i in range(len(test_dataset)): | |
| data_obj_n_atoms = test_dataset[i].x.size()[0] | |
| smiles_n_atoms = len(list(Chem.MolFromSmiles(test_smiles[ | |
| i]).GetAtoms())) | |
| assert data_obj_n_atoms == smiles_n_atoms | |
| # test random_split | |
| from loader import MoleculeDataset | |
| dataset = MoleculeDataset('dataset/tox21', dataset='tox21') | |
| train_dataset, valid_dataset, test_dataset = random_split(dataset, task_idx=None, null_value=0, frac_train=0.8,frac_valid=0.1, frac_test=0.1) | |
| unique_ids = set(train_dataset.data.id.tolist() + | |
| valid_dataset.data.id.tolist() + | |
| test_dataset.data.id.tolist()) | |
| assert len(unique_ids) == len(dataset) # check that we did not have any | |
| # missing or overlapping examples | |
| # test random_split with smiles returned | |
| dataset = MoleculeDataset('dataset/bbbp', dataset='bbbp') | |
| smiles_list = pd.read_csv('dataset/bbbp/processed/smiles.csv', header=None)[ | |
| 0].tolist() | |
| train_dataset, valid_dataset, test_dataset, (train_smiles, valid_smiles, | |
| test_smiles) = \ | |
| random_split(dataset, task_idx=None, null_value=0, | |
| frac_train=0.8, frac_valid=0.1, frac_test=0.1, seed=42, | |
| smiles_list=smiles_list) | |
| assert len(train_dataset) == len(train_smiles) | |
| for i in range(len(train_dataset)): | |
| data_obj_n_atoms = train_dataset[i].x.size()[0] | |
| smiles_n_atoms = len(list(Chem.MolFromSmiles(train_smiles[ | |
| i]).GetAtoms())) | |
| assert data_obj_n_atoms == smiles_n_atoms | |
| assert len(valid_dataset) == len(valid_smiles) | |
| for i in range(len(valid_dataset)): | |
| data_obj_n_atoms = valid_dataset[i].x.size()[0] | |
| smiles_n_atoms = len(list(Chem.MolFromSmiles(valid_smiles[ | |
| i]).GetAtoms())) | |
| assert data_obj_n_atoms == smiles_n_atoms | |
| assert len(test_dataset) == len(test_smiles) | |
| for i in range(len(test_dataset)): | |
| data_obj_n_atoms = test_dataset[i].x.size()[0] | |
| smiles_n_atoms = len(list(Chem.MolFromSmiles(test_smiles[ | |
| i]).GetAtoms())) | |
| assert data_obj_n_atoms == smiles_n_atoms | |