Merge branch 'master' into maml

      tf.summary.histogram(self.name, self.tb_input, self.collections)

  def _as_graph_element(self):

    if '_as_graph_element' in dir(self.out_tensor):

      return self.out_tensor._as_graph_element()

    else:

      return self.out_tensor

def _convert_layer_to_tensor(value, dtype=None, name=None, as_ref=False):

#!/usr/bin/env bash

envname=`cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 16 | head -n 1`

sed -i -- 's/tensorflow$/tensorflow-gpu/g' scripts/install_deepchem_conda.sh

export python_version=2.7

bash scripts/install_deepchem_conda.sh $envname

source activate $envname

python setup.py install

# Run adme test

cd examples/

nosetests --with-timer tests.py --with-xunit --xunit-file=example_tests.xml|| true

source deactivate

conda remove --name $envname --all

from __future__ import print_function

from __future__ import division

from __future__ import unicode_literals

from builtins import range

import os

import numpy as np

import tensorflow as tf

tf.set_random_seed(123)

import deepchem as dc

from deepchem.models.tensorgraph.models.graph_models import GraphConvTensorGraph

BATCH_SIZE = 128

MAX_EPOCH = 40

# Set to higher values to get better numbers

MAX_EPOCH = 1

LR = 1e-3

LMBDA = 1e-4

  tasks = ['exp']

  if featurizer == 'ECFP':

    featurizer = dc.feat.CircularFingerprint(size=4096)

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

  elif featurizer == 'GraphConv':

    featurizer = dc.feat.ConvMolFeaturizer()

  model = None

  if method == 'GraphConv':

    n_feat = 75

    graph_model = dc.nn.SequentialGraph(n_feat)

    graph_model.add(dc.nn.GraphConv(128, n_feat, activation='relu'))

    graph_model.add(dc.nn.BatchNormalization(epsilon=1e-5, mode=1))

    graph_model.add(dc.nn.GraphPool())

    graph_model.add(dc.nn.GraphConv(128, 128, activation='relu'))

    graph_model.add(dc.nn.BatchNormalization(epsilon=1e-5, mode=1))

    graph_model.add(dc.nn.GraphPool())

    graph_model.add(dc.nn.Dense(256, 128, activation='relu'))

    graph_model.add(dc.nn.BatchNormalization(epsilon=1e-5, mode=1))

    graph_model.add(dc.nn.GraphGather(BATCH_SIZE, activation="tanh"))

    model = dc.models.MultitaskGraphRegressor(

        graph_model,

        len(tasks),

        n_feat,

        batch_size=BATCH_SIZE,

        learning_rate=LR,

        learning_rate_decay_time=1000,

        optimizer_type="adam",

        beta1=.9,

        beta2=.999)

  elif method == 'PDNN':

    model = dc.models.TensorflowMultiTaskRegressor(

        len(tasks),

        train.get_data_shape()[0],

        layer_sizes=[384, 196],

        dropouts=[.25, .25],

        weight_init_stddevs=[.02, .02],

        bias_init_consts=[.1, .1],

        learning_rate=LR,

        penalty=LMBDA,

        penalty_type="l2",

        optimizer="adam",

        batch_size=BATCH_SIZE,

        seed=123,

        verbosity="high")

    model = GraphConvTensorGraph(

        len(tasks), batch_size=BATCH_SIZE, mode="regression")

  elif method == 'RF':

    def model_builder_rf(model_dir):

#======================================================================

# Run Benchmarks {GC-DNN, P-DNN, SVR, RF}

# Run Benchmarks {GC-DNN, SVR, RF}

print("About to retrieve datasets")

retrieve_datasets()

MODEL = 'GraphConv'

SPLIT = 'scaffold'

DATASET = 'az_hppb.csv'

MODEL = "GraphConv"

SPLIT = "scaffold"

DATASET = "az_hppb.csv"

metric = dc.metrics.Metric(dc.metrics.pearson_r2_score, np.mean)

print("About to build model")

model, train, val, test, transformers = experiment(

    DATASET, method=MODEL, split=SPLIT)

if MODEL == 'GraphConv':

  print("running GraphConv search")

  best_val_score = 0.0

  train_score = 0.0

  for l in range(0, MAX_EPOCH):

    print("epoch %d" % l)

    model.fit(train, nb_epoch=1)

    latest_train_score = model.evaluate(train, [metric],

                                        transformers)['mean-pearson_r2_score']

      best_val_score = latest_val_score

      train_score = latest_train_score

  print((MODEL, SPLIT, DATASET, train_score, best_val_score))

elif MODEL == 'PDNN':

  model.fit(train, nb_epoch=25)

  train_score = model.evaluate(train, [metric],

                               transformers)['mean-pearson_r2_score']

  val_score = model.evaluate(val, [metric],

                             transformers)['mean-pearson_r2_score']

  print((MODEL, SPLIT, DATASET, train_score, val_score))

  # we cant re-open the closed session...

else:

  model.fit(train)

  train_score = model.evaluate(train, [metric],

import os

import subprocess

import tempfile

def _example_run(path):

  """Checks that the example at the specified path runs corrently.

  Parameters

  ----------

  path: str

    Path to example file.

  Returns

  -------

  result: int 

    Return code. 0 for success, failure otherwise.

  """

  cmd = ["python", path]

  return subprocess.check_output(cmd)

def test_adme():

  result, output = _example_run("./adme/run_benchmarks.py")

  print(output)

  assert result == 0

if __name__ == "__main__":

  test_adme()