Membrain Permiability

  Handles loading of SDF files.

  """

  def __init__(self, clean_mols=False, **kwargs):

    super(SDFLoader, self).__init__(**kwargs)

    self.clean_mols = clean_mols

    self.smiles_field = "smiles"

    self.mol_field = "mol"

    self.id_field = "mol_id"

  def get_shards(self, input_files, shard_size):

    """Defines a generator which returns data for each shard"""

    return load_sdf_files(input_files)

    return load_sdf_files(input_files, self.clean_mols)

  def featurize_shard(self, shard):

    """Featurizes a shard of an input dataframe."""

      yield load_pickle_from_disk(input_file)

def load_sdf_files(input_files):

def load_sdf_files(input_files, clean_mols):

  """Load SDF file into dataframe."""

  dataframes = []

  for input_file in input_files:

    raw_df = next(load_csv_files([input_file + ".csv"], shard_size=None))

    # Structures are stored in .sdf file

    print("Reading structures from %s." % input_file)

    suppl = Chem.SDMolSupplier(str(input_file), False, False, False)

    suppl = Chem.SDMolSupplier(str(input_file), clean_mols, False, False)

    df_rows = []

    for ind, mol in enumerate(suppl):

      if mol is not None:

"""

MUV dataset loader.

"""

from __future__ import print_function

from __future__ import division

from __future__ import unicode_literals

import os

import numpy as np

import shutil

import deepchem as dc

def load_permeability(featurizer='ECFP', split='index'):

  """Load membrain permeability datasets. Does not do train/test split"""

  print("About to load membrain permeability dataset.")

  current_dir = os.path.dirname(os.path.realpath(__file__))

  dataset_file = os.path.join(

    current_dir, "../../datasets/membrane_permeability.sdf")

  # Featurize permeability dataset

  print("About to featurize membrain permeability dataset.")

  if featurizer == 'ECFP':

    featurizer_func = dc.feat.CircularFingerprint(size=1024)

  elif featurizer == 'GraphConv':

    featurizer_func = dc.feat.ConvMolFeaturizer()

  permeability_tasks = sorted(['LogP(RRCK)'])

  loader = dc.data.SDFLoader(

    tasks=permeability_tasks, clean_mols=True, featurizer=featurizer_func)

  dataset = loader.featurize(dataset_file)

  splitters = {'index': dc.splits.IndexSplitter(),

               'random': dc.splits.RandomSplitter(),

               'scaffold': dc.splits.ScaffoldSplitter()}

  splitter = splitters[split]

  train, valid, test = splitter.train_valid_test_split(dataset)

  return permeability_tasks, (train, valid, test), []