Merge branch 'master' into k-fold (744e8856) · Commits · 钟慕尧 / deepchem

contrib/rl/tictactoe.py

+2 −2

Original line number	Diff line number	Diff line
		@@ -9,6 +9,7 @@ import deepchem as dc
		import deepchem.rl.envs.tictactoe
		from deepchem.models.tensorgraph.layers import Flatten, Dense, SoftMax, \
		BatchNorm, Squeeze
		from deepchem.models.tensorgraph.optimizers import Adam


		class TicTacToePolicy(dc.rl.Policy):
		@@ -66,8 +67,7 @@ def eval_tic_tac_toe(value_weight,
		entropy_weight=0.01,
		value_weight=value_weight,
		model_dir=model_dir,
		optimizer=dc.models.tensorgraph.TFWrapper(
		tf.train.AdamOptimizer, learning_rate=0.001))
		optimizer=Adam(learning_rate=0.001))
		try:
		a3c.restore()
		except:

deepchem/models/tensorgraph/layers.py

+15 −1

Original line number	Diff line number	Diff line
		@@ -573,6 +573,20 @@ class Concat(Layer):
		return out_tensor


		class Stack(Layer):

		def __init__(self, axis=1, **kwargs):
		self.axis = axis
		super(Stack, self).__init__(**kwargs)

		def create_tensor(self, in_layers=None, set_tensors=True, **kwargs):
		inputs = self._get_input_tensors(in_layers)
		out_tensor = tf.stack(inputs, axis=self.axis)
		if set_tensors:
		self.out_tensor = out_tensor
		return out_tensor


		class Constant(Layer):
		"""Output a constant value."""

		@@ -1091,7 +1105,7 @@ class GraphGather(Layer):

		# Perform the mol gather

		assert (self.batch_size > 1, "graph_gather requires batches larger than 1")
		assert self.batch_size > 1, "graph_gather requires batches larger than 1"

		# Obtain the partitions for each of the molecules
		activated_par = tf.dynamic_partition(atom_features, membership,

deepchem/models/tensorgraph/models/graph_models.py

+82 −30

Original line number	Diff line number	Diff line
		@@ -7,11 +7,14 @@ from deepchem.metrics import to_one_hot, from_one_hot
		from deepchem.models.tensorgraph.graph_layers import WeaveLayer, WeaveGather, \
		Combine_AP, Separate_AP, DTNNEmbedding, DTNNStep, DTNNGather, DAGLayer, DAGGather, DTNNExtract
		from deepchem.models.tensorgraph.layers import Dense, Concat, SoftMax, SoftMaxCrossEntropy, GraphConv, BatchNorm, \
		GraphPool, GraphGather, WeightedError, BatchNormalization
		GraphPool, GraphGather, WeightedError, Dropout, BatchNormalization, Stack
		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
		from deepchem.data.data_loader import featurize_smiles_np
		from deepchem.feat.graph_features import ConvMolFeaturizer


		class WeaveTensorGraph(TensorGraph):
		@@ -103,7 +106,10 @@ class WeaveTensorGraph(TensorGraph):
		self.labels_fd.append(label)
		cost = L2Loss(in_layers=[label, regression])
		costs.append(cost)
		if self.mode == "classification":
		all_cost = Concat(in_layers=costs, axis=1)
		elif self.mode == "regression":
		all_cost = Stack(in_layers=costs, axis=1)
		self.weights = Weights(shape=(None, self.n_tasks))
		loss = WeightedError(in_layers=[all_cost, self.weights])
		self.set_loss(loss)
		@@ -256,7 +262,7 @@ class DTNNTensorGraph(TensorGraph):
		cost = L2Loss(in_layers=[label, regression])
		costs.append(cost)

		all_cost = Concat(in_layers=costs, axis=1)
		all_cost = Stack(in_layers=costs, axis=1)
		self.weights = Weights(shape=(None, self.n_tasks))
		loss = WeightedError(in_layers=[all_cost, self.weights])
		self.set_loss(loss)
		@@ -401,8 +407,10 @@ class DAGTensorGraph(TensorGraph):
		self.labels_fd.append(label)
		cost = L2Loss(in_layers=[label, regression])
		costs.append(cost)

		if self.mode == "classification":
		all_cost = Concat(in_layers=costs, axis=1)
		elif self.mode == "regression":
		all_cost = Stack(in_layers=costs, axis=1)
		self.weights = Weights(shape=(None, self.n_tasks))
		loss = WeightedError(in_layers=[all_cost, self.weights])
		self.set_loss(loss)
		@@ -476,6 +484,7 @@ class GraphConvTensorGraph(TensorGraph):

		"""
		self.n_tasks = n_tasks
		self.error_bars = True if 'error_bars' in kwargs and kwargs['error_bars'] else False
		kwargs['use_queue'] = False
		super(GraphConvTensorGraph, self).__init__(**kwargs)
		self.build_graph()
		@@ -507,20 +516,23 @@ class GraphConvTensorGraph(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)

		if self.error_bars == True:
		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)
		@@ -530,15 +542,18 @@ class GraphConvTensorGraph(TensorGraph):
		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.my_labels.append(label)
		cost = L2Loss(in_layers=[label, regression])
		costs.append(cost)

		if self.mode == "classification":
		entropy = Concat(in_layers=costs, axis=-1)
		elif self.mode == "regression":
		entropy = Stack(in_layers=costs, axis=1)
		self.my_task_weights = Weights(shape=(None, self.n_tasks))
		loss = WeightedError(in_layers=[entropy, self.my_task_weights])
		self.set_loss(loss)
		@@ -583,6 +598,7 @@ class GraphConvTensorGraph(TensorGraph):
		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])
		@@ -595,33 +611,69 @@ class GraphConvTensorGraph(TensorGraph):
		if not self.built:
		self.build()
		return self.evaluate_generator(
		self.default_generator(dataset),
		self.default_generator(dataset, predict=True),
		metrics,
		labels=self.my_labels,
		weights=[self.my_task_weights])

		def predict_on_smiles(self, smiles, transformers):
		max_index = len(smiles)
		num_batches = max_index // self.batch_size
		def bayesian_predict(self,
		dataset,
		transformers=[],
		n_passes=4,
		untransform=False):
		"""Generates predictions and confidences on a dataset object
		https://arxiv.org/pdf/1506.02142.pdf

		# Returns:
		mu: numpy ndarray of shape (n_samples, n_tasks)
		sigma: numpy ndarray of shape (n_samples, n_tasks)
		"""
		X = dataset.X
		max_index = X.shape[0] - 1
		num_batches = (max_index // self.batch_size) + 1

		y_ = []
		mus = []
		sigmas = []
		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))
		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)

		def predict_on_smiles_batch(self, smiles, transformers=[]):
		featurizer = ConvMolFeaturizer()
		convmols = featurize_smiles_np(smiles, featurizer)

		n_smiles = convmols.shape[0]
		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)
		mus.append(mu)
		sigmas.append(sigma)
		mu = np.concatenate(mus, axis=0)
		sigma = np.concatenate(sigmas, axis=0) + 0.55

		if untransform:
		mu = undo_transforms(mu, transformers)
		for i in range(sigma.shape[1]):
		sigma[:, i] = sigma[:, i] * transformers[0].y_stds[i]

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

		def predict_on_smiles(self, smiles, transformers=[], untransform=False):
		"""Generates predictions on a numpy array of smile strings

		# Returns:
		y_: numpy ndarray of shape (n_samples, n_tasks)
		"""
		max_index = len(smiles) - 1
		n_tasks = len(self.outputs)
		num_batches = (max_index // self.batch_size) + 1
		featurizer = ConvMolFeaturizer()

		dataset = NumpyDataset(X=convmols, y=None, n_tasks=n_tasks)
		generator = self.default_generator(dataset, predict=True, pad_batches=False)
		y_ = self.predict_on_generator(generator, transformers)

		return y_.reshape(-1, n_tasks)[:n_smiles]
		y_ = []
		for i in range(num_batches):
		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_ = np.concatenate(y_, axis=0)[:max_index + 1]
		y_ = y_.reshape(-1, n_tasks)

		if untransform:
		y_ = undo_transforms(y_, transformers)

		return y_

deepchem/models/tensorgraph/models/symmetry_function_regression.py

+3 −3

Original line number	Diff line number	Diff line
		@@ -8,7 +8,7 @@ Created on Thu Jul 6 20:31:47 2017
		import numpy as np
		import tensorflow as tf

		from deepchem.models.tensorgraph.layers import Dense, Concat, WeightedError
		from deepchem.models.tensorgraph.layers import Dense, Concat, WeightedError, Stack
		from deepchem.models.tensorgraph.layers import L2Loss, Label, Weights, Feature
		from deepchem.models.tensorgraph.tensor_graph import TensorGraph
		from deepchem.models.tensorgraph.graph_layers import DTNNEmbedding
		@@ -69,7 +69,7 @@ class BPSymmetryFunctionRegression(TensorGraph):
		cost = L2Loss(in_layers=[label, output])
		costs.append(cost)

		all_cost = Concat(in_layers=costs, axis=0)
		all_cost = Stack(in_layers=costs, axis=1)
		self.weights = Weights(shape=(None, self.n_tasks))
		loss = WeightedError(in_layers=[all_cost, self.weights])
		self.set_loss(loss)
		@@ -158,7 +158,7 @@ class ANIRegression(TensorGraph):
		cost = L2Loss(in_layers=[label, output])
		costs.append(cost)

		all_cost = Concat(in_layers=costs, axis=0)
		all_cost = Stack(in_layers=costs, axis=1)
		self.weights = Weights(shape=(None, self.n_tasks))
		loss = WeightedError(in_layers=[all_cost, self.weights])
		self.set_loss(loss)

deepchem/models/tensorgraph/optimizers.py

0 → 100644

+170 −0

Original line number	Diff line number	Diff line
		"""Optimizers and related classes for use with TensorGraph."""

		import tensorflow as tf


		class Optimizer(object):
		"""An algorithm for optimizing a TensorGraph based model.

		This is an abstract class. Subclasses represent specific optimization algorithms.
		"""

		def _create_optimizer(self, global_step):
		"""Construct the TensorFlow optimizer.

		Parameters
		----------
		global_step: tensor
		a tensor containing the global step index during optimization, used for learning rate decay

		Returns
		-------
		a new TensorFlow optimizer implementing the algorithm
		"""
		raise NotImplemented("Subclasses must implement this")


		class LearningRateSchedule(object):
		"""A schedule for changing the learning rate over the course of optimization.

		This is an abstract class. Subclasses represent specific schedules.
		"""

		def _create_tensor(self, global_step):
		"""Construct a tensor that equals the learning rate.

		Parameters
		----------
		global_step: tensor
		a tensor containing the global step index during optimization

		Returns
		-------
		a tensor that equals the learning rate
		"""
		raise NotImplemented("Subclasses must implement this")


		class Adam(Optimizer):
		"""The Adam optimization algorithm."""

		def __init__(self, learning_rate=0.001, beta1=0.9, beta2=0.999,
		epsilon=1e-08):
		"""Construct an Adam optimizer.

		Parameters
		----------
		learning_rate: float or LearningRateSchedule
		the learning rate to use for optimization
		beta1: float
		a parameter of the Adam algorithm
		beta2: float
		a parameter of the Adam algorithm
		epsilon: float
		a parameter of the Adam algorithm
		"""
		self.learning_rate = learning_rate
		self.beta1 = beta1
		self.beta2 = beta2
		self.epsilon = epsilon

		def _create_optimizer(self, global_step):
		if isinstance(self.learning_rate, LearningRateSchedule):
		learning_rate = self.learning_rate._create_tensor(global_step)
		else:
		learning_rate = self.learning_rate
		return tf.train.AdamOptimizer(
		learning_rate=learning_rate,
		beta1=self.beta1,
		beta2=self.beta2,
		epsilon=self.epsilon)


		class GradientDescent(Optimizer):
		"""The gradient descent optimization algorithm."""

		def __init__(self, learning_rate=0.001):
		"""Construct a gradient descent optimizer.

		Parameters
		----------
		learning_rate: float or LearningRateSchedule
		the learning rate to use for optimization
		"""
		self.learning_rate = learning_rate

		def _create_optimizer(self, global_step):
		if isinstance(self.learning_rate, LearningRateSchedule):
		learning_rate = self.learning_rate._create_tensor(global_step)
		else:
		learning_rate = self.learning_rate
		return tf.train.GradientDescentOptimizer(learning_rate=learning_rate)


		class ExponentialDecay(LearningRateSchedule):
		"""A learning rate that decreases exponentially with the number of training steps."""

		def __init__(self, initial_rate, decay_rate, decay_steps, staircase=True):
		"""Create an exponentially decaying learning rate.

		The learning rate starts as initial_rate. Every decay_steps training steps, it is multiplied by decay_rate.

		Parameters
		----------
		initial_rate: float
		the initial learning rate
		decay_rate: float
		the base of the exponential
		decay_steps: int
		the number of training steps over which the rate decreases by decay_rate
		staircase: bool
		if True, the learning rate decreases by discrete jumps every decay_steps.
		if False, the learning rate decreases smoothly every step
		"""
		self.initial_rate = initial_rate
		self.decay_rate = decay_rate
		self.decay_steps = decay_steps
		self.staircase = staircase

		def _create_tensor(self, global_step):
		return tf.train.exponential_decay(
		learning_rate=self.initial_rate,
		global_step=global_step,
		decay_rate=self.decay_rate,
		decay_steps=self.decay_steps,
		staircase=self.staircase)


		class PolynomialDecay(LearningRateSchedule):
		"""A learning rate that decreases from an initial value to a final value over a fixed number of training steps."""

		def __init__(self, initial_rate, final_rate, decay_steps, power=1.0):
		"""Create a smoothly decaying learning rate.

		The learning rate starts as initial_rate. It smoothly decreases to final_rate over decay_steps training steps.
		It decays as a function of (1-step/decay_steps)**power. Once the final rate is reached, it remains there for
		the rest of optimization.

		Parameters
		----------
		initial_rate: float
		the initial learning rate
		final_rate: float
		the final learning rate
		decay_steps: int
		the number of training steps over which the rate decreases from initial_rate to final_rate
		power: float
		the exponent controlling the shape of the decay
		"""
		self.initial_rate = initial_rate
		self.final_rate = final_rate
		self.decay_steps = decay_steps
		self.power = power

		def _create_tensor(self, global_step):
		return tf.train.polynomial_decay(
		learning_rate=self.initial_rate,
		end_learning_rate=self.final_rate,
		global_step=global_step,
		decay_steps=self.decay_steps,
		power=self.power)

Admin message