added ipyparallel parallelization

    self.verbose = verbose

    self.log_every_n = log_every_n

  def featurize(self, input_file, feature_dir, samples_dir, shard_size=128):

  def featurize(self, input_file, feature_dir, samples_dir, shard_size=128, worker_pool=None):

    """Featurize provided file and write to specified location."""

    input_type = _get_input_type(input_file)

      for compound_featurizer in self.compound_featurizers:

        log("Currently feauturizing feature_type: %s"

            % compound_featurizer.__class__.__name__, self.verbose)

        self._featurize_compounds(df, compound_featurizer)

        self._featurize_compounds(df, compound_featurizer, worker_pool=worker_pool)

      for complex_featurizer in self.complex_featurizers:

        log("Currently feauturizing feature_type: %s"

            % complex_featurizer.__class__.__name__, self.verbose)

        self._featurize_complexes(df, complex_featurizer)

        self._featurize_complexes(df, complex_featurizer, worker_pool=worker_pool)

      shard_out = os.path.join(feature_dir, "features_shard%d.joblib" % j)

      save_to_disk(df, shard_out)

    return df

  def _featurize_complexes(self, df, featurizer, parallel=True):

  def _featurize_complexes(self, df, featurizer, parallel=True,

                           worker_pool=None):

    """Generates circular fingerprints for dataset."""

    protein_pdbs = list(df["protein_pdb"])

    ligand_pdbs = list(df["ligand_pdb"])

      molecule_features = featurizer.featurize_complexes([ligand_pdb], [protein_pdb])

      return molecule_features

    features = ProcessingPool(mp.cpu_count()).map(featurize_wrapper, 

    if not parallel:

      features = []

      for ligand_protein_pdb_tuple in zip(ligand_pdbs, protein_pdbs):

        features.append(featurize_wrapper(ligand_protein_pdb_tuple))

    else:

      if worker_pool is None:

        worker_pool = ProcessingPool(mp.cpu_count())

        features = worker_pool.map(featurize_wrapper, 

                                   zip(ligand_pdbs, protein_pdbs))

      else:

        features = worker_pool.map_sync(featurize_wrapper, 

                                        zip(ligand_pdbs, protein_pdbs))

      #features = featurize_wrapper(zip(ligand_pdbs, protein_pdbs))

    df[featurizer.__class__.__name__] = list(features)

  def _featurize_compounds(self, df, featurizer, parallel=True):    

  def _featurize_compounds(self, df, featurizer, parallel=True,

                           worker_pool=None):    

    """Featurize individual compounds.

       Given a featurizer that operates on individual chemical compounds 

        mol = Chem.MolFromSmiles(smiles)

        return featurizer.featurize([mol])

      features = ProcessingPool(mp.cpu_count()).map(featurize_wrapper, 

      if worker_pool is None:

        worker_pool = ProcessingPool(mp.cpu_count())

        features = worker_pool.map(featurize_wrapper, 

                                   sample_smiles)

      else:

        features = worker_pool.map_sync(featurize_wrapper, 

                                        sample_smiles)

    df[featurizer.__class__.__name__] = features

import numpy as np

from keras.models import Graph

from keras.models import model_from_json

from keras.layers.core import Dense, Dropout

from keras.layers.core import Dense, Dropout, Activation

from keras.layers.normalization import BatchNormalization 

from keras.optimizers import SGD

from deepchem.models import Model

      (n_inputs,) = model_params["data_shape"]

      model = Graph()

      model.add_input(name="input", input_shape=(n_inputs,))

      prev_layer = "input"

      for ind, layer in enumerate(range(model_params["nb_layers"])):

        dense_layer_name = "dense%d" % ind

        activation_layer_name = "activation%d" % ind

        batchnorm_layer_name = "batchnorm%d" % ind

        dropout_layer_name = "dropout%d" % ind

        model.add_node(

          Dense(model_params["nb_hidden"], init=model_params["init"],

                activation=model_params["activation"]),

          name="dense", input="input")

            Dense(model_params["nb_hidden"], init=model_params["init"]),

            name=dense_layer_name, input=prev_layer)

        prev_layer = dense_layer_name 

        if model_params["batchnorm"]:

          model.add_node(

            BatchNormalization(), input=prev_layer, name=batchnorm_layer_name)

          prev_layer = batchnorm_layer_name

        model.add_node(Activation(model_params["activation"]),

                       name=activation_layer_name, input=prev_layer)

        prev_layer = activation_layer_name

        if model_params["dropout"] > 0:

          model.add_node(Dropout(model_params["dropout"]),

                     name="dropout",

                     input="dense")

      top_layer = "dropout"

                         name=dropout_layer_name,

                         input=prev_layer)

          prev_layer = dropout_layer_name

      for ind, task in enumerate(sorted_tasks):

        task_type = task_types[task]

        if task_type == "classification":

          model.add_node(

              Dense(2, init=model_params["init"], activation="softmax"),

              name="dense_head%d" % ind, input=top_layer)

              name="dense_head%d" % ind, input=prev_layer)

        elif task_type == "regression":

          model.add_node(

              Dense(1, init=model_params["init"]),

              name="dense_head%d" % ind, input=top_layer)

              name="dense_head%d" % ind, input=prev_layer)

        model.add_output(name="task%d" % ind, input="dense_head%d" % ind)

      loss_dict = {}