yapfed lots of stuff

from deepchem.data.data_loader import featurize_smiles_np

from deepchem.feat.graph_features import ConvMolFeaturizer

class WeaveTensorGraph(TensorGraph):

  def __init__(self,

        cost = SoftMaxCrossEntropy(in_layers=[label, classification])

        costs.append(cost)

      if self.mode == 'regression':

        regression = Dense(out_channels=1, activation_fn=None, in_layers=[readout])

        regression = Dense(

            out_channels=1, activation_fn=None, in_layers=[readout])

        self.add_output(regression)

        label = Label(shape=(None, 1))

      start = i * self.batch_size

      end = min((i + 1) * self.batch_size, max_index + 1)

      batch = X[start:end]

      mu, sigma = self.bayesian_predict_on_batch(batch, transformers=[], n_passes=n_passes)

      mu, sigma = self.bayesian_predict_on_batch(

          batch, transformers=[], n_passes=n_passes)

      mus.append(mu)

      sigmas.append(sigma)

    mu = np.concatenate(mus, axis=0)

      start = i * self.batch_size

      end = min((i + 1) * self.batch_size, max_index + 1)

      smiles_batch = smiles[start:end]

      y_.append(self.predict_on_smiles_batch(smiles_batch, featurizer, transformers))

      y_.append(

          self.predict_on_smiles_batch(smiles_batch, featurizer, transformers))

    y_ = np.concatenate(y_, axis=0)[:max_index + 1]

    y_ = y_.reshape(-1, n_tasks)

from deepchem.feat.graph_features import ConvMolFeaturizer

from deepchem.data.data_loader import featurize_smiles_np

class TensorGraph(Model):

  def __init__(self,

    dataset = NumpyDataset(X=X, y=None, n_tasks=len(self.outputs))

    y_ = []

    for i in range(n_passes):

      generator = self.default_generator(dataset, predict=True, pad_batches=True)

      generator = self.default_generator(

          dataset, predict=True, pad_batches=True)

      y_.append(self.predict_on_generator(generator, transformers))

    y_ = np.concatenate(y_, axis=2)

    return mu, sigma

  def predict_on_smiles_batch(self, smiles, featurizer, n_tasks, transformers=[]):

  def predict_on_smiles_batch(self,

                              smiles,

                              featurizer,

                              n_tasks,

                              transformers=[]):

    convmols = featurize_smiles_np(smiles, featurizer)

    dataset = NumpyDataset(X=convmols, y=None, n_tasks=len(self.outputs))

import tempfile

import deepchem as dc

def load_bace(mode="regression", transform=True, split="20-80"):

  """Load BACE-1 dataset as regression/classification problem."""

  assert split in ["20-80", "80-20"]

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

  if split == "20-80":

    dataset_file = os.path.join(

        current_dir, "../../datasets/desc_canvas_aug30.csv")

    dataset_file = os.path.join(current_dir,

                                "../../datasets/desc_canvas_aug30.csv")

  elif split == "80-20":

    dataset_file = os.path.join(

        current_dir, "../../datasets/rev8020split_desc.csv")

    dataset_file = os.path.join(current_dir,

                                "../../datasets/rev8020split_desc.csv")

  crystal_dataset_file = os.path.join(

      current_dir, "../../datasets/crystal_desc_canvas_aug30.csv")

    bace_tasks = ["Class"]

  featurizer = dc.feat.UserDefinedFeaturizer(user_specified_features)

  loader = dc.data.UserCSVLoader(

      tasks=bace_tasks, smiles_field="mol", id_field="CID",

      tasks=bace_tasks,

      smiles_field="mol",

      id_field="CID",

      featurizer=featurizer)

  dataset = loader.featurize(dataset_file)

  crystal_dataset = loader.featurize(crystal_dataset_file)

  transformers = [

      NormalizationTransformer(transform_X=True, dataset=train_dataset),

      ClippingTransformer(transform_X=True, dataset=train_dataset)]

      ClippingTransformer(transform_X=True, dataset=train_dataset)

  ]

  if mode == "regression":

    transformers += [

      NormalizationTransformer(transform_y=True, dataset=train_dataset)]

        NormalizationTransformer(transform_y=True, dataset=train_dataset)

    ]

  for dataset in [train_dataset, valid_dataset, test_dataset, crystal_dataset]:

    for transformer in transformers:

def bace_dnn_model(mode="classification", verbosity="high", split="20-80"):

  """Train fully-connected DNNs on BACE dataset."""

  (bace_tasks, train_dataset, valid_dataset, test_dataset, crystal_dataset,

   transformers) = load_bace(mode=mode, transform=True, split=split)

   transformers) = load_bace(

       mode=mode, transform=True, split=split)

  if mode == "regression":

    r2_metric = Metric(metrics.r2_score, verbosity=verbosity)

  else:

    raise ValueError("Invalid mode %s" % mode)

  params_dict = {"learning_rate": np.power(10., np.random.uniform(-5, -3, size=5)),

  params_dict = {

      "learning_rate": np.power(10., np.random.uniform(-5, -3, size=5)),

      "decay": np.power(10, np.random.uniform(-6, -4, size=5)),

                 "nb_epoch": [40] }

      "nb_epoch": [40]

  }

  n_features = train_dataset.get_data_shape()[0]

  def model_builder(model_params, model_dir):

    keras_model = MultiTaskDNN(

        len(bace_tasks), n_features, "classification", dropout=.5,

        len(bace_tasks),

        n_features,

        "classification",

        dropout=.5,

        **model_params)

    return KerasModel(keras_model, model_dir)

  optimizer = HyperparamOpt(model_builder, verbosity="low")

  best_dnn, best_hyperparams, all_results = optimizer.hyperparam_search(

      params_dict, train_dataset, valid_dataset, transformers,

      metric=metric)

      params_dict, train_dataset, valid_dataset, transformers, metric=metric)

  if len(train_dataset) > 0:

    dnn_train_evaluator = Evaluator(best_dnn, train_dataset, transformers)

        all_metrics, csv_out=csv_out, stats_out=stats_out)

    print("DNN Crystal set %s: %s" % (metric.name, str(dnn_crystal_score)))

if __name__ == "__main__":

  print("Classifier DNN 20-80:")

  print("--------------------------------")