Ready For PR (c09ca92e) · Commits · 钟慕尧 / deepchem

deepchem/data/datasets.py

+49 −27

Original line number	Diff line number	Diff line
		@@ -8,6 +8,7 @@ import os
		import numpy as np
		import pandas as pd
		import random
		import six
		from functools import partial
		from deepchem.utils.save import save_to_disk
		from deepchem.utils.save import load_from_disk
		@@ -1031,3 +1032,24 @@ class DiskDataset(Dataset):
		def get_label_stds(self):
		"""Return pandas series of label stds."""
		return self.metadata_df["y_stds"]


		class Databag(object):
		def __init__(self):
		self.datasets = dict()

		def add_dataset(self, key, dataset):
		self.datasets[key] = dataset

		def iterbatches(self, **kwargs):
		key_order = [x for x in self.datasets.keys()]
		if "epochs" in kwargs:
		epochs = kwargs['epochs']
		del kwargs['epochs']
		else:
		epochs = 1
		for epoch in range(epochs):
		iterators = [self.datasets[x].iterbatches(deterministic=True, **kwargs) for x in key_order]
		for tup in six.moves.zip(*iterators):
		m_d = {key_order[i]: tup[i][0] for i in range(len(key_order))}
		yield m_d

deepchem/metrics/init.py

+1 −1

Original line number	Diff line number	Diff line
		@@ -192,7 +192,7 @@ class Metric(object):
		else:
		y_pred = np.reshape(y_pred, (n_samples, n_tasks))
		y_true = np.reshape(y_true, (n_samples, n_tasks))
		if w is None:
		if w is None or len(w) == 0:
		w = np.ones_like(y_true)
		assert y_true.shape[0] == y_pred.shape[0] == w.shape[0]
		computed_metrics = []

deepchem/models/tensorgraph/layers.py

+180 −152

Original line number	Diff line number	Diff line
		@@ -7,8 +7,7 @@ from deepchem.nn import model_ops, initializations


		class Layer(object):

		def __init__(self, **kwargs):
		def __init__(self, in_layers=None, **kwargs):
		if "name" not in kwargs:
		self.name = "%s%s" % (self.__class__.__name__, self._random_name())
		else:
		@@ -17,6 +16,9 @@ class Layer(object):
		self.tensorboard = False
		else:
		self.tensorboard = kwargs['tensorboard']
		if in_layers is None:
		in_layers = list()
		self.in_layers = in_layers

		def _random_name(self):
		return ''.join(
		@@ -30,19 +32,34 @@ class Layer(object):
		def set_tensors(self, tensor):
		self.out_tensor = tensor

		def _create_tensor(self):
		raise ValueError("Subclasses must implement for themselves")

		def __key(self):
		return self.name

		def __eq__(x, y):
		if x is None or y is None:
		return False
		if type(x) != type(y):
		return False
		return x.__key() == y.__key()

		def __hash__(self):
		return hash(self.__key())

		class Conv1DLayer(Layer):

		class Conv1DLayer(Layer):
		def __init__(self, width, out_channels, **kwargs):
		self.width = width
		self.out_channels = out_channels
		self.out_tensor = None
		super().__init__(**kwargs)
		super(Conv1DLayer, self).__init__(**kwargs)

		def __call__(self, *parents):
		if len(parents) != 1:
		def _create_tensor(self):
		if len(self.in_layers) != 1:
		raise ValueError("Only One Parent to conv1D over")
		parent = parents[0]
		parent = self.in_layers[0]
		if len(parent.out_tensor.get_shape()) != 3:
		raise ValueError("Parent tensor must be (batch, width, channel)")
		parent_shape = parent.out_tensor.get_shape()
		@@ -57,19 +74,23 @@ class Conv1DLayer(Layer):


		class Dense(Layer):

		def __init__(self, out_channels, activation_fn=None, **kwargs):
		self.out_channels = out_channels
		self.out_tensor = None
		self.activation_fn = activation_fn
		super().__init__(**kwargs)
		super(Dense, self).__init__(**kwargs)

		def __call__(self, *parents):
		if len(parents) != 1:
		raise ValueError("Only One Parent to Dense over")
		parent = parents[0]
		def _create_tensor(self):
		if len(self.in_layers) != 1:
		raise ValueError("Only One Parent to Dense over %s" % self.in_layers)
		parent = self.in_layers[0]
		if len(parent.out_tensor.get_shape()) != 2:
		raise ValueError("Parent tensor must be (batch, width)")
		in_channels = parent.out_tensor.get_shape()[-1].value
		# w = initializations.glorot_uniform([in_channels, self.out_channels])
		# w = model_ops.zeros(shape=[in_channels, self.out_channels])
		# b = tf.Variable([0.0, 0.0])
		# self.out_tensor = tf.matmul(parent.out_tensor, w) + b
		self.out_tensor = tf.contrib.layers.fully_connected(
		parent.out_tensor,
		num_outputs=self.out_channels,
		@@ -80,14 +101,13 @@ class Dense(Layer):


		class Flatten(Layer):

		def __init__(self, **kwargs):
		super().__init__(**kwargs)
		super(Flatten, self).__init__(**kwargs)

		def __call__(self, *parents):
		if len(parents) != 1:
		def _create_tensor(self):
		if len(self.in_layers) != 1:
		raise ValueError("Only One Parent to conv1D over")
		parent = parents[0]
		parent = self.in_layers[0]
		parent_shape = parent.out_tensor.get_shape()
		vector_size = 1
		for i in range(1, len(parent_shape)):
		@@ -98,25 +118,23 @@ class Flatten(Layer):


		class Reshape(Layer):

		def __init__(self, shape, **kwargs):
		self.shape = shape
		super().__init__(**kwargs)
		super(Reshape, self).__init__(**kwargs)

		def __call__(self, *parents):
		parent_tensor = parents[0].out_tensor
		def _create_tensor(self):
		parent_tensor = self.in_layers[0].out_tensor
		self.out_tensor = tf.reshape(parent_tensor, self.shape)


		class CombineMeanStd(Layer):

		def __init__(self, **kwargs):
		super().__init__(**kwargs)
		super(CombineMeanStd, self).__init__(**kwargs)

		def __call__(self, *parents):
		if len(parents) != 2:
		raise ValueError("Must have two parents")
		mean_parent, std_parent = parents[0], parents[1]
		def _create_tensor(self):
		if len(self.in_layers) != 2:
		raise ValueError("Must have two self.in_layers")
		mean_parent, std_parent = self.in_layers[0], self.in_layers[1]
		mean_parent_tensor, std_parent_tensor = mean_parent.out_tensor, std_parent.out_tensor
		sample_noise = tf.random_normal(
		mean_parent_tensor.get_shape(), 0, 1, dtype=tf.float32)
		@@ -124,32 +142,30 @@ class CombineMeanStd(Layer):


		class Repeat(Layer):

		def __init__(self, n_times, **kwargs):
		self.n_times = n_times
		super().__init__(**kwargs)
		super(Repeat, self).__init__(**kwargs)

		def __call__(self, *parents):
		if len(parents) != 1:
		def _create_tensor(self):
		if len(self.in_layers) != 1:
		raise ValueError("Must have one parent")
		parent_tensor = parents[0].out_tensor
		parent_tensor = self.in_layers[0].out_tensor
		t = tf.expand_dims(parent_tensor, 1)
		pattern = tf.stack([1, self.n_times, 1])
		self.out_tensor = tf.tile(t, pattern)


		class GRU(Layer):

		def __init__(self, n_hidden, out_channels, batch_size, **kwargs):
		self.n_hidden = n_hidden
		self.out_channels = out_channels
		self.batch_size = batch_size
		super().__init__(**kwargs)
		super(GRU, self).__init__(**kwargs)

		def __call__(self, *parents):
		if len(parents) != 1:
		def _create_tensor(self):
		if len(self.in_layers) != 1:
		raise ValueError("Must have one parent")
		parent_tensor = parents[0].out_tensor
		parent_tensor = self.in_layers[0].out_tensor
		gru_cell = tf.nn.rnn_cell.GRUCell(self.n_hidden)
		initial_gru_state = gru_cell.zero_state(self.batch_size, tf.float32)
		rnn_outputs, rnn_states = tf.nn.dynamic_rnn(
		@@ -162,31 +178,28 @@ class GRU(Layer):


		class TimeSeriesDense(Layer):

		def __init__(self, out_channels, **kwargs):
		self.out_channels = out_channels
		super().__init__(**kwargs)
		super(TimeSeriesDense, self).__init__(**kwargs)

		def __call__(self, *parents):
		if len(parents) != 1:
		def _create_tensor(self):
		if len(self.in_layers) != 1:
		raise ValueError("Must have one parent")
		parent_tensor = parents[0].out_tensor
		parent_tensor = self.in_layers[0].out_tensor
		dense_fn = lambda x: tf.contrib.layers.fully_connected(x, num_outputs=self.out_channels,
		activation_fn=tf.nn.sigmoid)
		self.out_tensor = tf.map_fn(dense_fn, parent_tensor)


		class Input(Layer):

		def __init__(self, shape, dtype=tf.float32, pre_queue=False, **kwargs):
		def __init__(self, shape, dtype=tf.float32, **kwargs):
		self.shape = shape
		self.pre_queue = pre_queue
		self.dtype = dtype
		super().__init__(**kwargs)
		super(Input, self).__init__(**kwargs)

		def __call__(self, *parents):
		if not self.pre_queue:
		queue = parents[0]
		def _create_tensor(self):
		if len(self.in_layers) > 0:
		queue = self.in_layers[0]
		placeholder = queue.out_tensors[self.get_pre_q_name()]
		self.out_tensor = tf.placeholder_with_default(placeholder, self.shape)
		return self.out_tensor
		@@ -194,70 +207,76 @@ class Input(Layer):
		return self.out_tensor

		def create_pre_q(self, batch_size):
		if self.pre_queue:
		raise ValueError("Input is already pre_q")
		q_shape = (batch_size,) + self.shape[1:]
		return Input(
		shape=q_shape,
		name="%s_pre_q" % self.name,
		dtype=self.dtype,
		pre_queue=True)
		dtype=self.dtype)

		def get_pre_q_name(self):
		if self.pre_queue:
		raise ValueError("You are already pre_q")
		return "%s_pre_q" % self.name


		class LossLayer(Layer):
		class Feature(Input):
		def __init__(self, **kwargs):
		super(Feature, self).__init__(**kwargs)


		class Label(Input):
		def __init__(self, **kwargs):
		super(Label, self).__init__(**kwargs)


		class Weights(Input):
		def __init__(self, **kwargs):
		super().__init__(**kwargs)
		super(Weights, self).__init__(**kwargs)

		def __call__(self, *parents):
		guess, label = parents[0], parents[1]

		class LossLayer(Layer):
		def __init__(self, **kwargs):
		super(LossLayer, self).__init__(**kwargs)

		def _create_tensor(self):
		guess, label = self.in_layers[0], self.in_layers[1]
		self.out_tensor = tf.reduce_mean(
		tf.square(guess.out_tensor - label.out_tensor))
		return self.out_tensor


		class SoftMax(Layer):

		def __init__(self, **kwargs):
		super().__init__(**kwargs)
		super(SoftMax, self).__init__(**kwargs)

		def __call__(self, *parents):
		if len(parents) != 1:
		def _create_tensor(self):
		if len(self.in_layers) != 1:
		raise ValueError("Must only Softmax single parent")
		parent = parents[0]
		parent = self.in_layers[0]
		self.out_tensor = tf.contrib.layers.softmax(parent.out_tensor)
		return self.out_tensor


		class Concat(Layer):

		def __init__(self, **kwargs):
		super().__init__(**kwargs)
		super(Concat, self).__init__(**kwargs)

		def __call__(self, *parents):
		if len(parents) == 1:
		self.out_tensor = parents[0].out_tensor
		def _create_tensor(self):
		if len(self.in_layers) == 1:
		self.out_tensor = self.in_layers[0].out_tensor
		return self.out_tensor
		out_tensors = [x.out_tensor for x in parents]
		out_tensors = [x.out_tensor for x in self.in_layers]

		self.out_tensor = tf.concat(out_tensors, 1)
		return self.out_tensor


		class SoftMaxCrossEntropy(Layer):

		def __init__(self, **kwargs):
		super().__init__(**kwargs)
		super(SoftMaxCrossEntropy, self).__init__(**kwargs)

		def __call__(self, *parents):
		if len(parents) != 2:
		def _create_tensor(self):
		if len(self.in_layers) != 2:
		raise ValueError()
		labels, logits = parents[0].out_tensor, parents[1].out_tensor
		labels, logits = self.in_layers[0].out_tensor, self.in_layers[1].out_tensor
		self.out_tensor = tf.nn.softmax_cross_entropy_with_logits(
		logits=logits, labels=labels)
		self.out_tensor = tf.reshape(self.out_tensor, [-1, 1])
		@@ -265,22 +284,36 @@ class SoftMaxCrossEntropy(Layer):


		class ReduceMean(Layer):
		def _create_tensor(self):
		if len(self.in_layers) > 1:
		out_tensors = [x.out_tensor for x in self.in_layers]
		self.out_tensor = tf.stack(out_tensors)
		else:
		self.out_tensor = self.in_layers[0].out_tensor

		def __call__(self, *parents):
		parent_tensor = parents[0].out_tensor
		self.out_tensor = tf.reduce_mean(parent_tensor)
		self.out_tensor = tf.reduce_mean(self.out_tensor)
		return self.out_tensor


		class Conv2d(Layer):
		class ReduceSquareDifference(Layer):
		def __init__(self, **kwargs):
		super(ReduceSquareDifference, self).__init__(**kwargs)

		def _create_tensor(self):
		a = self.in_layers[0].out_tensor
		b = self.in_layers[1].out_tensor
		self.out_tensor = tf.reduce_mean(tf.squared_difference(a, b))
		return self.out_tensor


		class Conv2d(Layer):
		def __init__(self, num_outputs, kernel_size=5, **kwargs):
		self.num_outputs = num_outputs
		self.kernel_size = kernel_size
		super().__init__(**kwargs)
		super(Conv2d, self).__init__(**kwargs)

		def __call__(self, *parents):
		parent_tensor = parents[0].out_tensor
		def _create_tensor(self):
		parent_tensor = self.in_layers[0].out_tensor
		out_tensor = tf.contrib.layers.conv2d(
		parent_tensor,
		num_outputs=self.num_outputs,
		@@ -292,7 +325,6 @@ class Conv2d(Layer):


		class MaxPool(Layer):

		def __init__(self,
		ksize=[1, 2, 2, 1],
		strides=[1, 2, 2, 1],
		@@ -301,10 +333,10 @@ class MaxPool(Layer):
		self.ksize = ksize
		self.strides = strides
		self.padding = padding
		super().__init__(**kwargs)
		super(MaxPool, self).__init__(**kwargs)

		def __call__(self, *parents):
		in_tensor = parents[0].out_tensor
		def _create_tensor(self):
		in_tensor = self.in_layers[0].out_tensor
		self.out_tensor = tf.nn.max_pool(
		in_tensor, ksize=self.ksize, strides=self.strides, padding=self.padding)
		return self.out_tensor
		@@ -321,31 +353,31 @@ class InputFifoQueue(Layer):
		self.names = names
		self.capacity = capacity
		self.dtypes = dtypes
		super().__init__(**kwargs)
		super(InputFifoQueue, self).__init__(**kwargs)

		def __call__(self, *parents):
		def _create_tensor(self):
		if self.dtypes is None:
		self.dtypes = [tf.float32] * len(self.shapes)
		self.queue = tf.FIFOQueue(
		self.capacity, self.dtypes, shapes=self.shapes, names=self.names)
		feed_dict = {x.name: x.out_tensor for x in parents}
		feed_dict = {x.name: x.out_tensor for x in self.in_layers}
		self.out_tensor = self.queue.enqueue(feed_dict)
		self.close_op = self.queue.close()
		self.out_tensors = self.queue.dequeue()

		def none_tensors(self):
		queue, out_tensors, out_tensor = self.queue, self.out_tensor, self.out_tensor
		self.queue, self.out_tensor, self.out_tensors = None, None, None
		return queue, out_tensors, out_tensor
		queue, out_tensors, out_tensor, close_op = self.queue, self.out_tensor, self.out_tensor, self.close_op
		self.queue, self.out_tensor, self.out_tensors, self.close_op = None, None, None, None
		return queue, out_tensors, out_tensor, close_op

		def set_tensors(self, tensors):
		self.queue, self.out_tensor, self.out_tensors = tensors
		self.queue, self.out_tensor, self.out_tensors, self.close_op = tensors

		def close(self):
		self.queue.close()


		class GraphConvLayer(Layer):

		def __init__(self,
		out_channel,
		min_deg=0,
		@@ -357,11 +389,11 @@ class GraphConvLayer(Layer):
		self.max_degree = max_deg
		self.num_deg = 2 * max_deg + (1 - min_deg)
		self.activation_fn = activation_fn
		super().__init__(**kwargs)
		super(GraphConvLayer, self).__init__(**kwargs)

		def __call__(self, *parents):
		# parents = [atom_features, deg_slice, membership, deg_adj_list placeholders...]
		in_channels = parents[0].out_tensor.get_shape()[-1].value
		def _create_tensor(self):
		# self.in_layers = [atom_features, deg_slice, membership, deg_adj_list placeholders...]
		in_channels = self.in_layers[0].out_tensor.get_shape()[-1].value

		# Generate the nb_affine weights and biases
		self.W_list = [
		@@ -375,11 +407,11 @@ class GraphConvLayer(Layer):
		]

		# Extract atom_features
		atom_features = parents[0].out_tensor
		atom_features = self.in_layers[0].out_tensor

		# Extract graph topology
		deg_slice = parents[1].out_tensor
		deg_adj_lists = [x.out_tensor for x in parents[3:]]
		deg_slice = self.in_layers[1].out_tensor
		deg_adj_lists = [x.out_tensor for x in self.in_layers[3:]]

		# Perform the mol conv
		# atom_features = graph_conv(atom_features, deg_adj_lists, deg_slice,
		@@ -456,16 +488,15 @@ class GraphConvLayer(Layer):


		class GraphPoolLayer(Layer):

		def __init__(self, min_degree=0, max_degree=10, **kwargs):
		self.min_degree = min_degree
		self.max_degree = max_degree
		super().__init__(**kwargs)
		super(GraphPoolLayer, self).__init__(**kwargs)

		def __call__(self, *parents):
		atom_features = parents[0].out_tensor
		deg_slice = parents[1].out_tensor
		deg_adj_lists = [x.out_tensor for x in parents[3:]]
		def _create_tensor(self):
		atom_features = self.in_layers[0].out_tensor
		deg_slice = self.in_layers[1].out_tensor
		deg_adj_lists = [x.out_tensor for x in self.in_layers[3:]]

		# Perform the mol gather
		# atom_features = graph_pool(atom_features, deg_adj_lists, deg_slice,
		@@ -502,18 +533,17 @@ class GraphPoolLayer(Layer):


		class GraphGather(Layer):

		def __init__(self, batch_size, activation_fn=None, **kwargs):
		self.batch_size = batch_size
		self.activation_fn = activation_fn
		super().__init__(**kwargs)
		super(GraphGather, self).__init__(**kwargs)

		def __call__(self, *parents):
		def _create_tensor(self):
		# x = [atom_features, deg_slice, membership, deg_adj_list placeholders...]
		atom_features = parents[0].out_tensor
		atom_features = self.in_layers[0].out_tensor

		# Extract graph topology
		membership = parents[2].out_tensor
		membership = self.in_layers[2].out_tensor

		# Perform the mol gather

		@@ -525,7 +555,7 @@ class GraphGather(Layer):

		# Sum over atoms for each molecule
		sparse_reps = [
		tf.reduce_sum(activated, 0, keep_dims=True)
		tf.reduce_mean(activated, 0, keep_dims=True)
		for activated in activated_par
		]
		max_reps = [
		@@ -545,16 +575,14 @@ class GraphGather(Layer):


		class BatchNormLayer(Layer):

		def __call__(self, *parents):
		parent_tensor = parents[0].out_tensor
		def _create_tensor(self):
		parent_tensor = self.in_layers[0].out_tensor
		self.out_tensor = tf.layers.batch_normalization(parent_tensor)
		return self.out_tensor


		class WeightedError(Layer):

		def __call__(self, *parents):
		entropy, weights = parents[0], parents[1]
		def _create_tensor(self):
		entropy, weights = self.in_layers[0], self.in_layers[1]
		self.out_tensor = tf.reduce_sum(entropy.out_tensor * weights.out_tensor)
		return self.out_tensor

deepchem/models/tensorgraph/tensor_graph.py

+180 −155

File changed.

Preview size limit exceeded, changes collapsed.

deepchem/models/tensorgraph/tests/test_tensor_graph.py

+239 −39

File changed.

Preview size limit exceeded, changes collapsed.

Admin message