Converted more loaders to new API (82f7b8b8) · Commits · 钟慕尧 / deepchem

deepchem/molnet/init.py

+0 −1

Original line number	Diff line number	Diff line
		@@ -16,7 +16,6 @@ from deepchem.molnet.load_function.pcba_datasets import load_pcba, load_pcba_146
		from deepchem.molnet.load_function.pdbbind_datasets import load_pdbbind_grid, load_pdbbind, load_pdbbind_from_dir
		from deepchem.molnet.load_function.ppb_datasets import load_ppb
		from deepchem.molnet.load_function.qm7_datasets import load_qm7
		from deepchem.molnet.load_function.qm7_datasets import load_qm7_from_mat, load_qm7b_from_mat
		from deepchem.molnet.load_function.qm8_datasets import load_qm8
		from deepchem.molnet.load_function.qm9_datasets import load_qm9
		from deepchem.molnet.load_function.sampl_datasets import load_sampl

deepchem/molnet/load_function/chembl25_datasets.py

+48 −146

Original line number	Diff line number	Diff line
		@@ -2,17 +2,13 @@
		ChEMBL dataset loader, for training ChemNet
		"""
		import os
		import logging
		import deepchem as dc
		from deepchem.molnet.load_function.molnet_loader import TransformerGenerator, _MolnetLoader
		from deepchem.data import Dataset
		from typing import List, Optional, Tuple, Union

		from deepchem.feat import create_char_to_idx, SmilesToSeq, SmilesToImage

		CHEMBL_URL = "https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/chembl_25.csv.gz"
		DEFAULT_DIR = dc.utils.data_utils.get_data_dir()

		logger = logging.getLogger(__name__)

		chembl25_tasks = [
		CHEMBL25_URL = "https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/chembl_25.csv.gz"
		CHEMBL25_TASKS = [
		"MolWt", "HeavyAtomMolWt", "MolLogP", "MolMR", "TPSA", "LabuteASA",
		"HeavyAtomCount", "NHOHCount", "NOCount", "NumHAcceptors", "NumHDonors",
		"NumHeteroatoms", "NumRotatableBonds", "NumRadicalElectrons",
		@@ -37,144 +33,50 @@ chembl25_tasks = [
		]


		def load_chembl25(featurizer="smiles2seq",
		split="random",
		data_dir=None,
		save_dir=None,
		split_seed=None,
		reload=True,
		transformer_type='minmax',
		**kwargs):
		"""Loads the ChEMBL25 dataset, featurizes it, and does a split.
		Parameters
		----------
		featurizer: str, default smiles2seq
		Featurizer to use
		split: str, default None
		Splitter to use
		data_dir: str, default None
		Directory to download data to, or load dataset from. (TODO: If None, make tmp)
		save_dir: str, default None
		Directory to save the featurized dataset to. (TODO: If None, make tmp)
		split_seed: int, default None
		Seed to be used for splitting the dataset
		reload: bool, default True
		Whether to reload saved dataset
		transformer_type: str, default minmax:
		Transformer to use
		"""
		if data_dir is None:
		data_dir = DEFAULT_DIR
		if save_dir is None:
		save_dir = DEFAULT_DIR

		save_folder = os.path.join(save_dir, "chembl_25-featurized", str(featurizer))
		if featurizer == "smiles2img":
		img_spec = kwargs.get("img_spec", "std")
		save_folder = os.path.join(save_folder, img_spec)

		if reload:
		if not os.path.exists(save_folder):
		logger.warning(
		"{} does not exist. Reconstructing dataset.".format(save_folder))
		else:
		logger.info("{} exists. Restoring dataset.".format(save_folder))
		loaded, dataset, transformers = dc.utils.data_utils.load_dataset_from_disk(
		save_folder)
		if loaded:
		return chembl25_tasks, dataset, transformers

		dataset_file = os.path.join(data_dir, "chembl_25.csv.gz")
		class _Chembl25Loader(_MolnetLoader):

		def create_dataset(self) -> Dataset:
		dataset_file = os.path.join(self.data_dir, "chembl_25.csv.gz")
		if not os.path.exists(dataset_file):
		logger.warning("File {} not found. Downloading dataset. (~555 MB)".format(
		dataset_file))
		dc.utils.data_utils.download_url(url=CHEMBL_URL, dest_dir=data_dir)

		if featurizer == 'ECFP':
		featurizer = deepchem.feat.CircularFingerprint(size=1024)
		elif featurizer == 'GraphConv':
		featurizer = deepchem.feat.ConvMolFeaturizer()
		elif featurizer == 'Weave':
		featurizer = deepchem.feat.WeaveFeaturizer()
		elif featurizer == 'Raw':
		featurizer = deepchem.feat.RawFeaturizer()
		elif featurizer == "smiles2seq":
		max_len = kwargs.get('max_len', 250)
		pad_len = kwargs.get('pad_len', 10)
		char_to_idx = create_char_to_idx(
		dataset_file, max_len=max_len, smiles_field="smiles")
		featurizer = SmilesToSeq(
		char_to_idx=char_to_idx, max_len=max_len, pad_len=pad_len)
		elif featurizer == "smiles2img":
		img_size = kwargs.get("img_size", 80)
		img_spec = kwargs.get("img_spec", "engd")
		res = kwargs.get("res", 0.5)
		featurizer = SmilesToImage(img_size=img_size, img_spec=img_spec, res=res)

		else:
		raise ValueError(
		"Featurizer of type {} is not supported".format(featurizer))

		dc.utils.data_utils.download_url(url=CHEMBL25_URL, dest_dir=self.data_dir)
		loader = dc.data.CSVLoader(
		tasks=chembl25_tasks, smiles_field='smiles', featurizer=featurizer)
		dataset = loader.featurize(
		input_files=[dataset_file], shard_size=10000, data_dir=save_folder)

		if split is None:
		if transformer_type == "minmax":
		transformers = [
		dc.trans.MinMaxTransformer(
		transform_X=False, transform_y=True, dataset=dataset)
		]
		else:
		transformers = [
		dc.trans.NormalizationTransformer(
		transform_X=False, transform_y=True, dataset=dataset)
		]

		logger.info("Split is None, about to transform dataset.")
		for transformer in transformers:
		dataset = transformer.transform(dataset)
		return chembl25_tasks, (dataset, None, None), transformers

		splitters = {
		'index': dc.splits.IndexSplitter(),
		'random': dc.splits.RandomSplitter(),
		'scaffold': dc.splits.ScaffoldSplitter(),
		}

		logger.info("About to split data with {} splitter.".format(split))
		splitter = splitters[split]

		frac_train = kwargs.get('frac_train', 4 / 6)
		frac_valid = kwargs.get('frac_valid', 1 / 6)
		frac_test = kwargs.get('frac_test', 1 / 6)

		train, valid, test = splitter.train_valid_test_split(
		dataset,
		seed=split_seed,
		frac_train=frac_train,
		frac_test=frac_test,
		frac_valid=frac_valid)
		if transformer_type == "minmax":
		transformers = [
		dc.trans.MinMaxTransformer(
		transform_X=False, transform_y=True, dataset=train)
		]
		else:
		transformers = [
		dc.trans.NormalizationTransformer(
		transform_X=False, transform_y=True, dataset=train)
		]

		for transformer in transformers:
		train = transformer.transform(train)
		valid = transformer.transform(valid)
		test = transformer.transform(test)

		if reload:
		dc.utils.data_utils.save_dataset_to_disk(save_folder, train, valid, test,
		transformers)
		tasks=self.tasks, feature_field="smiles", featurizer=self.featurizer)
		return loader.create_dataset(dataset_file, shard_size=8192)


		def load_chembl25(
		featurizer: Union[dc.feat.Featurizer, str] = 'ECFP',
		splitter: Union[dc.splits.Splitter, str, None] = 'scaffold',
		transformers: List[Union[TransformerGenerator, str]] = ['normalization'],
		reload: bool = True,
		data_dir: Optional[str] = None,
		save_dir: Optional[str] = None,
		**kwargs
		) -> Tuple[List[str], Tuple[Dataset, ...], List[dc.trans.Transformer]]:
		"""Loads the ChEMBL25 dataset, featurizes it, and does a split.

		return chembl25_tasks, (train, valid, test), transformers
		Parameters
		----------
		featurizer: Featurizer or str
		the featurizer to use for processing the data. Alternatively you can pass
		one of the names from dc.molnet.featurizers as a shortcut.
		splitter: Splitter or str
		the splitter to use for splitting the data into training, validation, and
		test sets. Alternatively you can pass one of the names from
		dc.molnet.splitters as a shortcut. If this is None, all the data
		will be included in a single dataset.
		transformers: list of TransformerGenerators or strings
		the Transformers to apply to the data. Each one is specified by a
		TransformerGenerator or, as a shortcut, one of the names from
		dc.molnet.transformers.
		reload: bool
		if True, the first call for a particular featurizer and splitter will cache
		the datasets to disk, and subsequent calls will reload the cached datasets.
		data_dir: str
		a directory to save the raw data in
		save_dir: str
		a directory to save the dataset in
		"""
		loader = _Chembl25Loader(featurizer, splitter, transformers, CHEMBL25_TASKS,
		data_dir, save_dir, **kwargs)
		return loader.load_dataset('chembl25', reload)

deepchem/molnet/load_function/chembl_datasets.py

+79 −152

Original line number	Diff line number	Diff line
		@@ -2,157 +2,84 @@
		ChEMBL dataset loader.
		"""
		import os
		import logging
		import deepchem
		import deepchem as dc
		from deepchem.molnet.load_function.molnet_loader import TransformerGenerator, _MolnetLoader
		from deepchem.data import Dataset
		from deepchem.molnet.load_function.chembl_tasks import chembl_tasks

		logger = logging.getLogger(__name__)

		DEFAULT_DIR = deepchem.utils.data_utils.get_data_dir()


		def load_chembl(shard_size=2000,
		featurizer="ECFP",
		set="5thresh",
		split="random",
		reload=True,
		data_dir=None,
		save_dir=None,
		**kwargs):

		if data_dir is None:
		data_dir = DEFAULT_DIR
		if save_dir is None:
		save_dir = DEFAULT_DIR

		logger.info("About to load ChEMBL dataset.")

		if reload:
		save_folder = os.path.join(save_dir, "chembl-featurized", featurizer)
		if featurizer == "smiles2img":
		img_spec = kwargs.get("img_spec", "std")
		save_folder = os.path.join(save_folder, img_spec)
		save_folder = os.path.join(save_folder, str(split))

		loaded, all_dataset, transformers = deepchem.utils.data_utils.load_dataset_from_disk(
		save_folder)
		if loaded:
		return chembl_tasks, all_dataset, transformers

		dataset_path = os.path.join(data_dir, "chembl_%s.csv.gz" % set)
		if not os.path.exists(dataset_path):
		deepchem.utils.data_utils.download_url(
		url=
		"https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/chembl_5thresh.csv.gz",
		dest_dir=data_dir)
		deepchem.utils.data_utils.download_url(
		url=
		"https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/chembl_sparse.csv.gz",
		dest_dir=data_dir)
		deepchem.utils.data_utils.download_url(
		url=
		"https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/chembl_year_sets/chembl_5thresh_ts_test.csv.gz",
		dest_dir=data_dir)
		deepchem.utils.data_utils.download_url(
		url=
		"https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/chembl_year_sets/chembl_5thresh_ts_train.csv.gz",
		dest_dir=data_dir)
		deepchem.utils.data_utils.download_url(
		url=
		"https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/chembl_year_sets/chembl_5thresh_ts_valid.csv.gz",
		dest_dir=data_dir)
		deepchem.utils.data_utils.download_url(
		url=
		"https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/chembl_year_sets/chembl_sparse_ts_test.csv.gz",
		dest_dir=data_dir)
		deepchem.utils.data_utils.download_url(
		url=
		"https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/chembl_year_sets/chembl_sparse_ts_train.csv.gz",
		dest_dir=data_dir)
		deepchem.utils.data_utils.download_url(
		url=
		"https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/chembl_year_sets/chembl_sparse_ts_valid.csv.gz",
		dest_dir=data_dir)

		if split == "year":
		train_files = os.path.join(
		data_dir, "./chembl_year_sets/chembl_%s_ts_train.csv.gz" % set)
		valid_files = os.path.join(
		data_dir, "./chembl_year_sets/chembl_%s_ts_valid.csv.gz" % set)
		test_files = os.path.join(
		data_dir, "./chembl_year_sets/chembl_%s_ts_test.csv.gz" % set)

		# Featurize ChEMBL dataset
		logger.info("About to featurize ChEMBL dataset.")
		if featurizer == 'ECFP':
		featurizer = deepchem.feat.CircularFingerprint(size=1024)
		elif featurizer == 'GraphConv':
		featurizer = deepchem.feat.ConvMolFeaturizer()
		elif featurizer == 'Weave':
		featurizer = deepchem.feat.WeaveFeaturizer()
		elif featurizer == 'Raw':
		featurizer = deepchem.feat.RawFeaturizer()
		elif featurizer == "smiles2img":
		img_spec = kwargs.get("img_spec", "std")
		img_size = kwargs.get("img_size", 80)
		featurizer = deepchem.feat.SmilesToImage(
		img_size=img_size, img_spec=img_spec)

		loader = deepchem.data.CSVLoader(
		tasks=chembl_tasks, smiles_field="smiles", featurizer=featurizer)

		if split == "year":
		logger.info("Featurizing train datasets")
		train = loader.featurize(train_files, shard_size=shard_size)
		logger.info("Featurizing valid datasets")
		valid = loader.featurize(valid_files, shard_size=shard_size)
		logger.info("Featurizing test datasets")
		test = loader.featurize(test_files, shard_size=shard_size)
		else:
		dataset = loader.featurize(dataset_path, shard_size=shard_size)

		if split is None:
		transformers = [
		deepchem.trans.NormalizationTransformer(
		transform_y=True, dataset=dataset)
		]

		logger.info("Split is None, about to transform data.")
		for transformer in transformers:
		dataset = transformer.transform(dataset)

		return chembl_tasks, (dataset, None, None), transformers

		if split != "year":
		splitters = {
		'index': deepchem.splits.IndexSplitter(),
		'random': deepchem.splits.RandomSplitter(),
		'scaffold': deepchem.splits.ScaffoldSplitter(),
		}

		splitter = splitters[split]
		logger.info("Performing new split.")
		frac_train = kwargs.get("frac_train", 0.8)
		frac_valid = kwargs.get('frac_valid', 0.1)
		frac_test = kwargs.get('frac_test', 0.1)

		train, valid, test = splitter.train_valid_test_split(
		dataset,
		frac_train=frac_train,
		frac_valid=frac_valid,
		frac_test=frac_test)

		transformers = [
		deepchem.trans.NormalizationTransformer(transform_y=True, dataset=train)
		]

		logger.info("About to transform data.")
		for transformer in transformers:
		train = transformer.transform(train)
		valid = transformer.transform(valid)
		test = transformer.transform(test)

		if reload:
		deepchem.utils.data_utils.save_dataset_to_disk(save_folder, train, valid,
		test, transformers)
		return chembl_tasks, (train, valid, test), transformers
		from typing import List, Optional, Tuple, Union

		CHEMBL_URL = "https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/chembl_%s.csv.gz"


		class _ChemblLoader(_MolnetLoader):

		def __init__(self, args, set: str, *kwargs):
		super(_ChemblLoader, self).__init__(args, *kwargs)
		self.set = set

		def create_dataset(self) -> Dataset:
		dataset_file = os.path.join(self.data_dir, "chembl_%s.csv.gz" % self.set)
		if not os.path.exists(dataset_file):
		dc.utils.data_utils.download_url(
		url=CHEMBL_URL % self.set, dest_dir=self.data_dir)
		loader = dc.data.CSVLoader(
		tasks=self.tasks, feature_field="smiles", featurizer=self.featurizer)
		return loader.create_dataset(dataset_file, shard_size=8192)


		def load_chembl(
		featurizer: Union[dc.feat.Featurizer, str] = 'ECFP',
		splitter: Union[dc.splits.Splitter, str, None] = 'scaffold',
		transformers: List[Union[TransformerGenerator, str]] = ['normalization'],
		set: bool = "5thresh",
		reload: bool = True,
		data_dir: Optional[str] = None,
		save_dir: Optional[str] = None,
		**kwargs
		) -> Tuple[List[str], Tuple[Dataset, ...], List[dc.trans.Transformer]]:
		"""Load the ChEMBL dataset.

		This dataset is based on release 22.1 of the data from https://www.ebi.ac.uk/chembl/.
		Two subsets of the data are available, depending on the "set" argument. "sparse"
		is a large dataset with 244,245 compounds. As the name suggests, the data is
		extremely sparse, with most compounds having activity data for only one target.
		"5thresh" is a much smaller set (23,871 compounds) that includes only compounds
		with activity data for at least five targets.

		Parameters
		----------
		featurizer: Featurizer or str
		the featurizer to use for processing the data. Alternatively you can pass
		one of the names from dc.molnet.featurizers as a shortcut.
		splitter: Splitter or str
		the splitter to use for splitting the data into training, validation, and
		test sets. Alternatively you can pass one of the names from
		dc.molnet.splitters as a shortcut. If this is None, all the data
		will be included in a single dataset.
		transformers: list of TransformerGenerators or strings
		the Transformers to apply to the data. Each one is specified by a
		TransformerGenerator or, as a shortcut, one of the names from
		dc.molnet.transformers.
		set: str
		the subset to load, either "sparse" or "5thresh"
		reload: bool
		if True, the first call for a particular featurizer and splitter will cache
		the datasets to disk, and subsequent calls will reload the cached datasets.
		data_dir: str
		a directory to save the raw data in
		save_dir: str
		a directory to save the dataset in
		"""
		if set not in ("5thresh", "sparse"):
		raise ValueError("set must be either '5thresh' or 'sparse'")
		loader = _ChemblLoader(
		featurizer,
		splitter,
		transformers,
		chembl_tasks,
		data_dir,
		save_dir,
		set=set,
		**kwargs)
		return loader.load_dataset('chembl-%s' % set, reload)

deepchem/molnet/load_function/sweetlead_datasets.py

+61 −91

Original line number	Diff line number	Diff line
		@@ -2,100 +2,70 @@
		SWEET dataset loader.
		"""
		import os
		import numpy as np
		import shutil
		import logging
		import deepchem as dc
		from deepchem.molnet.load_function.molnet_loader import TransformerGenerator, _MolnetLoader
		from deepchem.data import Dataset
		from typing import List, Optional, Tuple, Union

		logger = logging.getLogger(__name__)

		DEFAULT_DIR = dc.utils.data_utils.get_data_dir()
		SWEETLEAD_URL = "https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/sweet.csv.gz"
		SWEETLEAD_TASKS = ["task"]


		def load_sweet(featurizer='ECFP',
		split='index',
		reload=True,
		frac_train=.8,
		data_dir=None,
		save_dir=None,
		**kwargs):
		"""Load sweet datasets.

		Sweetlead is a dataset of chemical structures for approved drugs, chemical isolates from traditional medicinal herbs, and regulated chemicals. Resulting structures are filtered for the active pharmaceutical ingredient, standardized, and differing formulations of the same drug were combined in the final database.

		Novick, Paul A., et al. "SWEETLEAD: an in silico database of approved drugs, regulated chemicals, and herbal isolates for computer-aided drug discovery." PLoS One 8.11 (2013).
		"""
		# Load Sweetlead dataset
		logger.info("About to load Sweetlead dataset.")
		SWEET_tasks = ["task"]

		if data_dir is None:
		data_dir = DEFAULT_DIR
		if save_dir is None:
		save_dir = DEFAULT_DIR

		if reload:
		save_folder = os.path.join(save_dir, "sweet-featurized", featurizer)
		if featurizer == "smiles2img":
		img_spec = kwargs.get("img_spec", "std")
		save_folder = os.path.join(save_folder, img_spec)
		save_folder = os.path.join(save_folder, str(split))

		loaded, all_dataset, transformers = dc.utils.data_utils.load_dataset_from_disk(
		save_folder)
		if loaded:
		return SWEET_tasks, all_dataset, transformers
		class _SweetLoader(_MolnetLoader):

		# Featurize SWEET dataset
		logger.info("About to featurize SWEET dataset.")
		if featurizer == 'ECFP':
		featurizer = dc.feat.CircularFingerprint(size=1024)
		elif featurizer == "smiles2img":
		img_spec = kwargs.get("img_spec", "std")
		img_size = kwargs.get("img_size", 80)
		featurizer = deepchem.feat.SmilesToImage(
		img_size=img_size, img_spec=img_spec)
		else:
		raise ValueError("Other featurizations not supported")

		dataset_file = os.path.join(data_dir, "sweet.csv.gz")
		def create_dataset(self) -> Dataset:
		dataset_file = os.path.join(self.data_dir, "sweet.csv.gz")
		if not os.path.exists(dataset_file):
		dc.utils.download_url(SWEETLEAD_URL)
		dc.utils.data_utils.download_url(
		url=SWEETLEAD_URL, dest_dir=self.data_dir)
		loader = dc.data.CSVLoader(
		tasks=SWEET_tasks, smiles_field="smiles", featurizer=featurizer)
		dataset = loader.featurize(dataset_file)

		# Initialize transformers
		transformers = [dc.trans.BalancingTransformer(dataset=dataset)]
		logger.info("About to transform data")
		for transformer in transformers:
		dataset = transformer.transform(dataset)

		if split == None:
		return SWEET_tasks, (dataset, None, None), transformers

		splitters = {
		'index': dc.splits.IndexSplitter(),
		'random': dc.splits.RandomSplitter(),
		'scaffold': dc.splits.ScaffoldSplitter(),
		'task': dc.splits.TaskSplitter(),
		'stratified': dc.splits.RandomStratifiedSplitter()
		}
		splitter = splitters[split]
		frac_train = kwargs.get("frac_train", 0.8)
		frac_valid = kwargs.get('frac_valid', 0.1)
		frac_test = kwargs.get('frac_test', 0.1)

		train, valid, test = splitter.train_valid_test_split(
		dataset,
		frac_train=frac_train,
		frac_valid=frac_valid,
		frac_test=frac_test)

		if reload:
		dc.utils.data_utils.save_dataset_to_disk(save_folder, train, valid, test,
		transformers)
		all_dataset = (train, valid, test)
		tasks=self.tasks, feature_field="smiles", featurizer=self.featurizer)
		return loader.create_dataset(dataset_file, shard_size=8192)


		def load_sweet(
		featurizer: Union[dc.feat.Featurizer, str] = 'ECFP',
		splitter: Union[dc.splits.Splitter, str, None] = 'scaffold',
		transformers: List[Union[TransformerGenerator, str]] = ['balancing'],
		reload: bool = True,
		data_dir: Optional[str] = None,
		save_dir: Optional[str] = None,
		**kwargs
		) -> Tuple[List[str], Tuple[Dataset, ...], List[dc.trans.Transformer]]:
		"""Load sweet datasets.

		return SWEET_tasks, (train, valid, test), transformers
		Sweetlead is a dataset of chemical structures for approved drugs, chemical isolates
		from traditional medicinal herbs, and regulated chemicals. Resulting structures are
		filtered for the active pharmaceutical ingredient, standardized, and differing
		formulations of the same drug were combined in the final database.

		Parameters
		----------
		featurizer: Featurizer or str
		the featurizer to use for processing the data. Alternatively you can pass
		one of the names from dc.molnet.featurizers as a shortcut.
		splitter: Splitter or str
		the splitter to use for splitting the data into training, validation, and
		test sets. Alternatively you can pass one of the names from
		dc.molnet.splitters as a shortcut. If this is None, all the data
		will be included in a single dataset.
		transformers: list of TransformerGenerators or strings
		the Transformers to apply to the data. Each one is specified by a
		TransformerGenerator or, as a shortcut, one of the names from
		dc.molnet.transformers.
		reload: bool
		if True, the first call for a particular featurizer and splitter will cache
		the datasets to disk, and subsequent calls will reload the cached datasets.
		data_dir: str
		a directory to save the raw data in
		save_dir: str
		a directory to save the dataset in

		References
		----------
		Novick, Paul A., et al. "SWEETLEAD: an in silico database of approved drugs, regulated
		chemicals, and herbal isolates for computer-aided drug discovery." PLoS One 8.11 (2013).
		"""
		loader = _SweetLoader(featurizer, splitter, transformers, SWEETLEAD_TASKS,
		data_dir, save_dir, **kwargs)
		return loader.load_dataset('sweet', reload)

deepchem/molnet/load_function/thermosol_datasets.py

+54 −121

File changed.

Preview size limit exceeded, changes collapsed.

Admin message