yapf and bugfixes (343cb214) · Commits · 钟慕尧 / deepchem

deepchem/models/sequential.py

+110 −113

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@ from deepchem.nn import model_ops
		from deepchem.nn.copy import Layer
		from deepchem.nn.copy import InputLayer


		class Sequential(Model):
		"""Linear stack of layers.

		@@ -40,6 +41,7 @@ class Sequential(Model):

		Example
		-------
		>>> import deepchem as dc
		>>> model = dc.models.Sequential()
		>>> # Add features
		>>> model.add_features(dc.nn.Input(shape=(50,)))
		@@ -93,7 +95,8 @@ class Sequential(Model):
		def add_features(self, layer):
		"""Adds an input layer."""
		if self.layers:
		raise ValueError("add_features() has to be called before layers are added.")
		raise ValueError(
		"add_features() has to be called before layers are added.")
		if not isinstance(layer, InputLayer):
		raise ValueError("First layer in sequential model must be InputLayer")
		with self.graph.as_default():
		@@ -101,7 +104,6 @@ class Sequential(Model):
		self.outputs = [self.features]
		self.layers = [layer]


		def add_labels(self, layer):
		"""Adds a layer for labels"""
		with self.graph.as_default():
		@@ -125,8 +127,13 @@ class Sequential(Model):
		def uses_learning_phase(self):
		return self.uses_learning_phase

		def fit(self, dataset, nb_epoch=10, max_checkpoints_to_keep=5,
		log_every_N_batches=50, learning_rate=.001, batch_size=50):
		def fit(self,
		dataset,
		nb_epoch=10,
		max_checkpoints_to_keep=5,
		log_every_N_batches=50,
		learning_rate=.001,
		batch_size=50):
		"""Trains the model for a fixed number of epochs.

		TODO(rbharath0: This is mostly copied from TensorflowGraphModel. Should
		@@ -154,40 +161,26 @@ class Sequential(Model):
		train_op = opt.minimize(self.loss, name='train')
		with self.session as sess:
		sess.run(tf.global_variables_initializer())
		############################################################ DEBUG
		#print("after global variable initialization")
		#print("[var.name for var in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)]")
		#print([var.name for var in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)])
		############################################################ DEBUG
		saver = tf.train.Saver(max_to_keep=max_checkpoints_to_keep)
		# Save an initial checkpoint.
		saver.save(sess, self._save_path, global_step=0)
		for epoch in range(nb_epoch):
		avg_loss, n_batches = 0., 0
		# TODO(rbharath): Don't support example weighting yet.
		for ind, (X_b, y_b, w_b, ids_b) in enumerate(
		dataset.iterbatches(batch_size)):
		for ind, (X_b, y_b, w_b,
		ids_b) in enumerate(dataset.iterbatches(batch_size)):
		if ind % log_every_N_batches == 0:
		print("On batch %d" % ind)
		feed_dict = {self.features: X_b,
		self.labels: y_b}
		feed_dict = {self.features: X_b, self.labels: y_b}
		fetches = self.outputs + [train_op, self.loss]
		fetched_values = sess.run(fetches, feed_dict=feed_dict)
		output = fetched_values[:len(self.outputs)]
		######################################### DEBUG
		print("fetched_values")
		print(fetched_values)
		######################################### DEBUG
		loss = fetched_values[-1]
		avg_loss += loss
		y_pred = np.squeeze(np.array(output))
		y_b = y_b.flatten()
		n_batches += 1
		saver.save(sess, self._save_path, global_step=epoch)
		######################################### DEBUG
		print("avg_loss")
		print(avg_loss)
		######################################### DEBUG
		avg_loss = float(avg_loss) / n_batches
		print('Ending epoch %d: Average loss %g' % (epoch, avg_loss))
		# Always save a final checkpoint when complete.
		@@ -197,11 +190,17 @@ class Sequential(Model):
		print("TIMING: model fitting took %0.3f s" % (time2 - time1))
		############################################################## TIMING

		def evaluate(self, x, y, batch_size=32, verbose=1,
		sample_weight=None, **kwargs):
		def evaluate(self,
		x,
		y,
		batch_size=32,
		verbose=1,
		sample_weight=None,
		**kwargs):
		"""Computes the loss on some input data, batch by batch.

		# Arguments
		Parameters
		----------
		x: input data, as a Numpy array or list of Numpy arrays
		(if the model has multiple inputs).
		y: labels, as a Numpy array.
		@@ -209,15 +208,15 @@ class Sequential(Model):
		verbose: verbosity mode, 0 or 1.
		sample_weight: sample weights, as a Numpy array.

		# Returns
		Returns
		-------
		Scalar test loss (if the model has no metrics)
		or list of scalars (if the model computes other metrics).
		The attribute `model.metrics_names` will give you
		the display labels for the scalar outputs.
		"""
		if self.model is None:
		raise RuntimeError('The model needs to be compiled '
		'before being used.')
		raise RuntimeError('The model needs to be compiled ' 'before being used.')
		if 'show_accuracy' in kwargs:
		kwargs.pop('show_accuracy')
		warnings.warn('The "show_accuracy" argument is deprecated, '
		@@ -226,9 +225,10 @@ class Sequential(Model):
		'`model.compile(optimizer, loss, '
		'metrics=["accuracy"])`')
		if kwargs:
		raise TypeError('Received unknown keyword arguments: ' +
		str(kwargs))
		return self.model.evaluate(x, y,
		raise TypeError('Received unknown keyword arguments: ' + str(kwargs))
		return self.model.evaluate(
		x,
		y,
		batch_size=batch_size,
		verbose=verbose,
		sample_weight=sample_weight)
		@@ -256,8 +256,12 @@ class Sequential(Model):
		self.build()
		return self.model.predict_on_batch(x)

		def train_on_batch(self, x, y, class_weight=None,
		sample_weight=None, **kwargs):
		def train_on_batch(self,
		x,
		y,
		class_weight=None,
		sample_weight=None,
		**kwargs):
		"""Single gradient update over one batch of samples.

		# Arguments
		@@ -275,8 +279,7 @@ class Sequential(Model):
		the display labels for the scalar outputs.
		"""
		if self.model is None:
		raise RuntimeError('The model needs to be compiled '
		'before being used.')
		raise RuntimeError('The model needs to be compiled ' 'before being used.')
		if 'accuracy' in kwargs:
		kwargs.pop('accuracy')
		warnings.warn('The "accuracy" argument is deprecated, '
		@@ -285,14 +288,11 @@ class Sequential(Model):
		'`model.compile(optimizer, loss, '
		'metrics=["accuracy"])`')
		if kwargs:
		raise TypeError('Received unknown keyword arguments: ' +
		str(kwargs))
		return self.model.train_on_batch(x, y,
		sample_weight=sample_weight,
		class_weight=class_weight)

		def test_on_batch(self, x, y,
		sample_weight=None, **kwargs):
		raise TypeError('Received unknown keyword arguments: ' + str(kwargs))
		return self.model.train_on_batch(
		x, y, sample_weight=sample_weight, class_weight=class_weight)

		def test_on_batch(self, x, y, sample_weight=None, **kwargs):
		"""Evaluates the model over a single batch of samples.

		# Arguments
		@@ -308,8 +308,7 @@ class Sequential(Model):
		the display labels for the scalar outputs.
		"""
		if self.model is None:
		raise RuntimeError('The model needs to be compiled '
		'before being used.')
		raise RuntimeError('The model needs to be compiled ' 'before being used.')
		if 'accuracy' in kwargs:
		kwargs.pop('accuracy')
		warnings.warn('The "accuracy" argument is deprecated, '
		@@ -318,10 +317,8 @@ class Sequential(Model):
		'`model.compile(optimizer, loss, '
		'metrics=["accuracy"])`')
		if kwargs:
		raise TypeError('Received unknown keyword arguments: ' +
		str(kwargs))
		return self.model.test_on_batch(x, y,
		sample_weight=sample_weight)
		raise TypeError('Received unknown keyword arguments: ' + str(kwargs))
		return self.model.test_on_batch(x, y, sample_weight=sample_weight)

		def predict_proba(self, x, batch_size=32, verbose=1):
		"""Generates class probability predictions for the input samples

deepchem/models/tests/misc_test.py

0 → 100644

+16 −0

Original line number	Diff line number	Diff line
		import sklearn
		import sklearn.datasets
		import numpy as np
		#import openbabel as ob
		from sklearn.linear_model import LogisticRegression

		print("sklearn.__version__")
		print(sklearn.__version__)
		print("np.__version__")
		print(np.__version__)

		dataset = sklearn.datasets.load_digits(n_class=2)
		X, y = dataset.data, dataset.target

		sklearn_model = LogisticRegression()
		sklearn_model.fit(X, y)

deepchem/models/tests/test_overfit.py

+312 −243

File changed.

Preview size limit exceeded, changes collapsed.

deepchem/models/tests/test_sequential.py

+1 −0

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@ import tensorflow as tf
		import numpy as np
		import deepchem as dc


		class TestSequential(unittest.TestCase):
		"""
		Test API for sequential models

deepchem/models/tf_new_models/graph_models.py

+53 −43

Original line number	Diff line number	Diff line
		@@ -13,6 +13,7 @@ import tensorflow as tf
		from deepchem.nn.layers import GraphGather
		from deepchem.models.tf_new_models.graph_topology import GraphTopology


		class SequentialGraph(object):
		"""An analog of Keras Sequential class for Graph data.

		@@ -20,6 +21,7 @@ class SequentialGraph(object):
		placeholders from GraphTopology to each graph layer (from layers) added
		to the network. Non graph layers don't get the extra placeholders.
		"""

		def __init__(self, n_feat):
		"""
		Parameters
		@@ -28,8 +30,6 @@ class SequentialGraph(object):
		Number of features per atom.
		"""
		self.graph = tf.Graph()
		config = tf.ConfigProto(allow_soft_placement=True)
		self.session = tf.Session(graph=self.graph, config=config)
		with self.graph.as_default():
		self.graph_topology = GraphTopology(n_feat)
		self.output = self.graph_topology.get_atom_features_placeholder()
		@@ -45,8 +45,8 @@ class SequentialGraph(object):
		assert self.layers[-1].__name__ != "GraphGather", \
		'Cannot use GraphConv or GraphGather layers after a GraphGather'

		self.output = layer(
		[self.output] + self.graph_topology.get_topology_placeholders())
		self.output = layer([self.output] +
		self.graph_topology.get_topology_placeholders())
		else:
		self.output = layer(self.output)

		@@ -69,8 +69,10 @@ class SequentialGraph(object):
		def get_layer(self, layer_id):
		return self.layers[layer_id]


		class SequentialSupportGraph(object):
		"""An analog of Keras Sequential model for test/support models."""

		def __init__(self, n_feat):
		"""
		Parameters
		@@ -78,6 +80,8 @@ class SequentialSupportGraph(object):
		n_feat: int
		Number of atomic features.
		"""
		self.graph = tf.Graph()
		with self.graph.as_default():
		# Create graph topology and x
		self.test_graph_topology = GraphTopology(n_feat, name='test')
		self.support_graph_topology = GraphTopology(n_feat, name='support')
		@@ -95,6 +99,7 @@ class SequentialSupportGraph(object):
		Note that the layer transformation is performed independently on the
		test/support tensors.
		"""
		with self.graph.as_default():
		self.layers.append(layer)

		# Update new value of x
		@@ -102,7 +107,8 @@ class SequentialSupportGraph(object):
		assert self.bool_pre_gather, "Cannot apply graphical layers after gather."

		self.test = layer([self.test] + self.test_graph_topology.topology)
		self.support = layer([self.support] + self.support_graph_topology.topology)
		self.support = layer([self.support] +
		self.support_graph_topology.topology)
		else:
		self.test = layer(self.test)
		self.support = layer(self.support)
		@@ -112,6 +118,7 @@ class SequentialSupportGraph(object):

		def add_test(self, layer):
		"""Adds a layer to test."""
		with self.graph.as_default():
		self.layers.append(layer)

		# Update new value of x
		@@ -122,16 +129,19 @@ class SequentialSupportGraph(object):

		def add_support(self, layer):
		"""Adds a layer to support."""
		with self.graph.as_default():
		self.layers.append(layer)

		# Update new value of x
		if type(layer).__name__ in ['GraphConv', 'GraphPool', 'GraphGather']:
		self.support = layer([self.support] + self.support_graph_topology.topology)
		self.support = layer([self.support] +
		self.support_graph_topology.topology)
		else:
		self.support = layer(self.support)

		def join(self, layer):
		"""Joins test and support to a two input two output layer"""
		with self.graph.as_default():
		self.layers.append(layer)
		self.test, self.support = layer([self.test, self.support])

		@@ -145,5 +155,5 @@ class SequentialSupportGraph(object):
		return [self.test] + [self.support]

		def return_inputs(self):
		return (self.test_graph_topology.get_inputs()
		+ self.support_graph_topology.get_inputs())
		return (self.test_graph_topology.get_inputs() +
		self.support_graph_topology.get_inputs())

Admin message