for now...

Alexander Rose <alexander.rose@weirdbyte.de>

Aneesh <apappu97@gmail.com>

Aneesh Pappu <apappu97@gmail.com>

Anthony Gitter <agitter@users.noreply.github.com>

Bharath <rbharath@stanford.edu>

Bharath Ramsundar <bharath.ramsundar@gmail.com>

Bharath Ramsundar <rbharath@gpu-15-5.local>

Bharath Ramsundar <rbharath@gpu-19-2.local>

Bharath Ramsundar <rbharath@gpu-9-10.local>

Bharath Ramsundar <rbharath@gpu-9-7.local>

Bharath Ramsundar <rbharath@sherlock-ln01.stanford.edu>

Bharath Ramsundar <rbharath@sherlock-ln02.stanford.edu>

Bharath Ramsundar <rbharath@stanford.edu>

Bharath Ramsundar <rbharath@vsp-compute-38.stanford.edu>

Bowen Liu <bowen@bowenliu.net>

Bowen Liu <bowenliu16@users.noreply.github.com>

Bowen Liu <liubowen@sherlock-ln02.stanford.edu>

CCXD <c.c.lam.2@umail.leidenuniv.nl>

Carlos Hernandez <cxh@stanford.edu>

DorisMai <huanghao@stanford.edu>

Evan N. Feinberg <evan.n.feinberg@gmail.com>

Franklin Lee <flee2@stanford.edu>

Hai Nguyen <hainm.comp@gmail.com>

Hai Nguyen <hainm@users.noreply.github.com>

Han Raut Altae-Tran <hraut@sherlock-ln02.stanford.edu>

Haozhen Wu <hwu84@wisc.edu>

J <sha0lin@alumni.carnegiemellon.edu>

Joe Gomes <jgomes@berkeley.edu>

Joe Gomes <joegomes@sherlock-ln02.stanford.edu>

Joe Gomes <joegomes@stanford.edu>

John Chodera <john.chodera@choderalab.org>

Joseph Gomes <joegomes@stanford.edu>

Joseph Heenan <jheenan@greenkeytech.com>

Juan Eiros <j.eiros-zamora14@imperial.ac.uk>

Karl Leswing <karl.leswing@gmail.com>

Karl Leswing <lilleswing@gmail.com>

Levi Pierce <lpierce@relaytx.com>

Maciej Wójcikowski <mwojcikowski@users.noreply.github.com>

Nate Stanley <dr-nate@users.noreply.github.com>

Patrick Hop <hop.patrick1@gmail.com>

Patrick Hop <patrickhop@ph-dev.local>

Peter Eastman <peter.eastman@gmail.com>

Prasad Kawthekar <prasadkawthekar1@gmail.com>

Steven Kearnes <skearnes@users.noreply.github.com>

Ubuntu <ubuntu@ip-172-31-5-2.us-west-1.compute.internal>

Ubuntu <ubuntu@ip-172-31-55-121.ec2.internal>

Yutong Zhao <proteneer@gmail.com>

ZHENQIN WU <zqwu@gpu-17-35.local>

ZHENQIN WU <zqwu@gpu-9-1.local>

ZHENQIN WU <zqwu@gpu-9-2.local>

ZHENQIN WU <zqwu@sh-5-36.local>

ZHENQIN WU <zqwu@sherlock-ln01.stanford.edu>

ZHENQIN WU <zqwu@sherlock-ln02.stanford.edu>

ZHENQIN WU <zqwu@sherlock-ln03.stanford.edu>

ZHENQIN WU <zqwu@sherlock-ln04.stanford.edu>

Zheng Xu <xuzheng1111@gmail.com>

Zhenqin Wu <zhenqin.wu2@gmail.com>

Zhenqin Wu <zqwu@stanford.edu>

calebgeniesse <calebgeniesse@gmail.com>

cc <c.c.lam.2@umail.leidenuniv.nl>

cfperez <christian.f.perez@gmail.com>

cxh <cxh@liberty.stanford.edu>

dibya <dibyadeep@gmail.com>

dibyadeeppaul <dibyadeep@gmail.com>

evanfeinberg <enf@vsp-compute-01.stanford.edu>

evanfeinberg <evan.n.feinberg@gmail.com>

haozhenWu <hwu84@wisc.edu>

jchodera <john.chodera@choderalab.org>

joegomes <jgomes@berkeley.edu>

ktaneishi <ktaneishi@users.noreply.github.com>

leswing <Karl>

leswing <lilleswing@gmail.com>

miaecle <zqwu@stanford.edu>

patrickhop <hop.patrick1@gmail.com>

peastman <peastman@stanford.edu>

unknown <Zhenqin Wu@DESKTOP-DULN7K0.stanford.edu>

unknown <吴桢钦>

vipulraheja <vipul.raheja@human.x.ai>

from deepchem.models.tensorgraph.graph_layers import WeaveLayer, WeaveGather, \

    Combine_AP, Separate_AP, DTNNEmbedding, DTNNStep, DTNNGather, DAGLayer, DAGGather

from deepchem.models.tensorgraph.layers import Dense, Concat, SoftMax, SoftMaxCrossEntropy, GraphConv, BatchNorm, \

    GraphPool, GraphGather, WeightedError

    GraphPool, GraphGather, WeightedError, Dropout

from deepchem.models.tensorgraph.layers import L2Loss, Label, Weights, Feature

from deepchem.models.tensorgraph.tensor_graph import TensorGraph

from deepchem.trans import undo_transforms

from deepchem.utils.evaluate import GeneratorEvaluator

from deepchem.data import NumpyDataset

class WeaveTensorGraph(TensorGraph):

    batch_norm2 = BatchNorm(in_layers=[gc2])

    gp2 = GraphPool(in_layers=[batch_norm2, self.degree_slice, self.membership]

                    + self.deg_adjs)

    dense = Dense(out_channels=128, activation_fn=None, in_layers=[gp2])

    dense = Dense(out_channels=128, activation_fn=tf.nn.relu, in_layers=[gp2])

    batch_norm3 = BatchNorm(in_layers=[dense])

    gg1 = GraphGather(

    readout = GraphGather(

        batch_size=self.batch_size,

        activation_fn=tf.nn.tanh,

        in_layers=[batch_norm3, self.degree_slice, self.membership] +

        self.deg_adjs)

    readout = Dropout(in_layers=[readout], dropout_prob=0.2)

    costs = []

    self.my_labels = []

    for task in range(self.n_tasks):

      if self.mode == 'classification':

        classification = Dense(

            out_channels=2, activation_fn=None, in_layers=[gg1])

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

        softmax = SoftMax(in_layers=[classification])

        self.add_output(softmax)

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

        costs.append(cost)

      if self.mode == 'regression':

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

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

        self.add_output(regression)

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

              self.layers[k.name].out_tensor: v

              for k, v in six.iteritems(feed_dict)

          }

          feed_dict[self._training_placeholder] = 1.0 ##

          result = np.array(sess.run(out_tensors, feed_dict=feed_dict))

          if len(result.shape) == 3:

            result = np.transpose(result, axes=[1, 0, 2])

        labels=self.my_labels,

        weights=[self.my_task_weights])

  def bayesian_predict(self, dataset, transformers=[], n_passes=4):

    max_index = dataset.shape[0]

    num_batches = max_index // self.batch_size

    mus = []

    sigmas = []

    for i in range(num_batches + 1): # think about edge cases here

      start = i * self.batch_size

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

      batch = dataset[start:end]

      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)

    sigma = np.concatenate(sigmas, axis=0)

    return mu[:max_index], sigma[:max_index]

  def predict_on_smiles(self, smiles, transformers):

    max_index = len(smiles)

    num_batches = max_index // self.batch_size

    featurizer = ConvMolFeaturizer()

    y_ = []

    for i in range(num_batches):

      smiles_batch = smiles[i * self.batch_size:(i + 1) * self.batch_size]

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

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

    smiles_batch = smiles[num_batches * self.batch_size:max_index]

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

    return np.concatenate(y_, axis=1)

    return np.concatenate(y_, axis=1) # wrong axis?

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

    featurizer = ConvMolFeaturizer()

    convmols = featurize_smiles_np(smiles, featurizer)

    n_smiles = convmols.shape[0]

          results.append(result)

        return np.concatenate(results, axis=0)

  def bayesian_predict_on_batch(self, X, sess=None, transformers=[], n_passes=4):

    """

    Returns:

      mu: SHAPE

      sigma: SHAPE

    """

    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)

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

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

    mu = np.mean(y_, axis=2)

    sigma = np.std(y_, axis=2)

    return mu, sigma

  def predict_on_batch(self, X, sess=None, transformers=[]):

    """Generates output predictions for the input samples,

      processing the samples in a batched way.

    # Returns

        A Numpy array of predictions.

    """

    print('inside tensorgraph predict_on_batch')

    dataset = NumpyDataset(X=X, y=None)

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

    return self.predict_on_generator(generator, transformers)

"""

Script that trains graphconv models on delaney dataset.

"""

from __future__ import print_function

from __future__ import division

from __future__ import unicode_literals

import numpy as np

np.random.seed(123)

import tensorflow as tf

tf.set_random_seed(123)

import deepchem as dc

from sklearn.metrics import r2_score

# Load Delaney dataset

delaney_tasks, delaney_datasets, transformers = dc.molnet.load_lipo(

    featurizer='GraphConv', split='scaffold')

train_dataset, valid_dataset, test_dataset = delaney_datasets

# Fit models

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

n_atom_feat = 75

n_pair_feat = 14

# Batch size of models

batch_size = 48

n_feat = 128

model = dc.models.GraphConvTensorGraph(

    len(delaney_tasks),

    batch_size=batch_size,

    learning_rate=1e-3,

    use_queue=False,

    mode='regression')

for i in xrange(0, 50):

  model.fit(train_dataset, nb_epoch=1)

  valid_scores = model.evaluate(valid_dataset, [metric], transformers)

  mu, sigma = model.bayesian_predict(valid_dataset.X, transformers)

  y = valid_dataset.y

  print(r2_score(y, mu))

  tmp = sigma

  amax = np.amax(tmp.reshape(-1, 1))

  amin = np.amin(tmp.reshape(-1, 1))

  print('max uncrt [%.4f] min uncrt [%.4f]' % (amin, amax))

  mu = mu.reshape(-1, 1).tolist()

  if i, estimate in enumerate(mu):

 No newline at end of file