Merge pull request #133 from rbharath/MUV_debug (ee06065d) · Commits · 钟慕尧 / deepchem

deepchem/featurizers/featurize.py

+0 −3

Original line number	Diff line number	Diff line
		@@ -442,9 +442,6 @@ class FeaturizedSamples(object):
		raise ValueError("improper splittype.")
		train_samples, valid_samples, test_samples = None, None, None
		dataset_files = self.dataset_files
		print("FeaturizedSamples.train_valid_test_split")
		print("dataset_files")
		print(dataset_files)
		if train_dir is not None:
		train_samples = FeaturizedSamples(samples_dir=train_dir,
		dataset_files=dataset_files,

deepchem/hyperparameters/init.py

+10 −2

Original line number	Diff line number	Diff line
		@@ -50,11 +50,16 @@ class HyperparamOpt(object):
		for hyperparam, hyperparam_val in zip(hyperparams, hyperparameter_tuple):
		model_params[hyperparam] = hyperparam_val

		if logdir is not None:
		model_dir = logdir
		else:
		model_dir = tempfile.mkdtemp()
		if logdir is not None:
		model = self.model_class(self.task_types, model_params, logdir=logdir)
		model = self.model_class(self.task_types, model_params, model_dir,
		verbosity=self.verbosity)
		else:
		model = self.model_class(self.task_types, model_params)
		model = self.model_class(self.task_types, model_params,
		verbosity=self.verbosity)
		model.fit(train_dataset)
		model.save(model_dir)

		@@ -84,6 +89,9 @@ class HyperparamOpt(object):
		log("\tbest_validation_score so far: %f" % best_validation_score,
		self.verbosity)

		if best_model is None:
		log("No models trained correctly.", self.verbosity)
		return best_model, best_hyperparams, all_scores
		train_csv_out = tempfile.NamedTemporaryFile()
		train_stats_out = tempfile.NamedTemporaryFile()
		train_evaluator = Evaluator(best_model, train_dataset, output_transformers)

deepchem/hyperparameters/tests/test_hyperparam_opt.py

+1 −1

Original line number	Diff line number	Diff line
		@@ -22,7 +22,7 @@ from deepchem import metrics
		from deepchem.metrics import Metric
		from sklearn.ensemble import RandomForestRegressor

		def rf_model_builder(task_types, params_dict, logdir=None):
		def rf_model_builder(task_types, params_dict, logdir=None, verbosity=None):
		"""Builds random forests given hyperparameters.

		Last two arguments only for tensorflow models and ignored.

deepchem/hyperparameters/tests/test_tf_hyperparam_opt.py

0 → 100644

+76 −0

Original line number	Diff line number	Diff line
		"""
		Integration tests for hyperparam optimization.
		"""
		from __future__ import print_function
		from __future__ import division
		from __future__ import unicode_literals

		__author__ = "Bharath Ramsundar"
		__copyright__ = "Copyright 2016, Stanford University"
		__license__ = "LGPL"


		import os
		from deepchem.featurizers.fingerprints import CircularFingerprint
		from deepchem.models.test import TestAPI
		from deepchem.metrics import Metric
		from deepchem import metrics
		import numpy as np
		from deepchem.models.tensorflow_models import TensorflowModel
		from deepchem.models.tensorflow_models.fcnet import TensorflowMultiTaskClassifier

		class TestTFHyperparamOptAPI(TestAPI):
		"""
		Test hyperparameter optimization API.
		"""
		def test_multitask_keras_mlp_ECFP_classification_hyperparam_opt(self):
		"""Straightforward test of Tensorflow multitask deepchem classification API."""
		splittype = "scaffold"
		output_transformers = []
		input_transformers = []
		task_type = "classification"

		input_file = os.path.join(self.current_dir, "multitask_example.csv")
		tasks = ["task0", "task1", "task2", "task3", "task4", "task5", "task6",
		"task7", "task8", "task9", "task10", "task11", "task12",
		"task13", "task14", "task15", "task16"]
		task_types = {task: task_type for task in tasks}

		compound_featurizers = [CircularFingerprint(size=1024)]
		complex_featurizers = []

		train_dataset, valid_dataset, _, transformers = self._featurize_train_test_split(
		splittype, compound_featurizers,
		complex_featurizers, input_transformers,
		output_transformers, input_file, task_types.keys())
		metric = Metric(metrics.matthews_corrcoef, np.mean)
		params_dict = {"activation": ["relu"],
		"momentum": [.9],
		"batch_size": [50],
		"init": ["glorot_uniform"],
		"data_shape": [train_dataset.get_data_shape()],
		"learning_rate": [1e-3],
		"decay": [1e-6],
		"nb_hidden": [1000],
		"nb_epoch": [1],
		"nesterov": [False],
		"dropouts": [(.5,)],
		"nb_layers": [1],
		"batchnorm": [False],
		"layer_sizes": [(1000,)],
		"weight_init_stddevs": [(.1,)],
		"bias_init_consts": [(1.,)],
		"num_classes": [2],
		"penalty": [0.],
		"optimizer": ["sgd"],
		"num_classification_tasks": [len(task_types)]
		}

		def model_builder(task_types, params_dict, logdir, verbosity=None):
		return TensorflowModel(
		task_types, params_dict, logdir,
		tf_class=TensorflowMultiTaskClassifier,
		verbosity=verbosity)
		self._hyperparam_opt(model_builder, params_dict, train_dataset,
		valid_dataset, output_transformers, task_types,
		metric, logdir=self.model_dir)

deepchem/models/tensorflow_models/init.py

+20 −20

Original line number	Diff line number	Diff line
		@@ -41,6 +41,7 @@ import deepchem.metrics as met
		from deepchem.utils.evaluate import from_one_hot
		from deepchem.models.tensorflow_models import model_ops
		from deepchem.models.tensorflow_models import utils as tf_utils
		from deepchem.utils.save import log

		class TensorflowGraph(object):
		"""Thin wrapper holding a tensorflow graph and a few vars.
		@@ -82,7 +83,8 @@ class TensorflowGraph(object):
		logdir: Directory for output files.
		"""

		def __init__(self, model_params, logdir, task_types, train=True):
		def __init__(self, model_params, logdir, task_types, train=True,
		verbosity=None):
		"""Constructs the computational graph.

		Args:
		@@ -98,6 +100,7 @@ class TensorflowGraph(object):
		self.logdir = logdir
		self.task_types = task_types
		self.num_tasks = len(task_types)
		self.verbosity = verbosity

		# Lazily created by _get_shared_session().
		self._shared_session = None
		@@ -217,24 +220,24 @@ class TensorflowGraph(object):

		def fit(self,
		dataset,
		max_steps=None,
		summaries=False,
		save_model_secs=60,
		max_checkpoints_to_keep=5):
		"""Fit the model.

		Args:
		dataset: Dataset object that represents data on disk.
		max_steps: Maximum number of training steps. If not provided, will
		train indefinitely.
		summaries: If True, add summaries for model parameters.
		save_model_secs: Integer. Saves a checkpoint at this interval in seconds.
		max_checkpoints_to_keep: Integer. Maximum number of checkpoints to keep;
		older checkpoints will be deleted.

		Raises:
		AssertionError: If model is not in training mode.
		"""
		num_datapoints = len(dataset)
		batch_size = self.model_params["batch_size"]
		step_per_epoch = np.ceil(float(num_datapoints)/batch_size)
		nb_epoch = self.model_params["nb_epoch"]
		log("Training for %d epochs" % nb_epoch, self.verbosity)
		with self.graph.as_default():
		assert model_ops.is_training()
		self.require_attributes(['loss', 'global_step', 'updates'])
		@@ -242,27 +245,21 @@ class TensorflowGraph(object):
		no_op = tf.no_op()
		tf.train.write_graph(
		tf.get_default_graph().as_graph_def(), self.logdir, 'train.pbtxt')
		last_checkpoint_time = time.time()
		with self._get_shared_session() as sess:
		sess.run(tf.initialize_all_variables())
		saver = tf.train.Saver(max_to_keep=max_checkpoints_to_keep)
		# Save an initial checkpoint.
		saver.save(sess, self._save_path, global_step=self.global_step)
		for (X_b, y_b, w_b, ids_b) in dataset.iterbatches(self.model_params["batch_size"]):
		for epoch in range(nb_epoch):
		for (X_b, y_b, w_b, ids_b) in dataset.iterbatches(batch_size):
		# Run training op and compute summaries.
		feed_dict = self.construct_feed_dict(X_b, y_b, w_b, ids_b)
		step, loss, _ = sess.run(
		[train_op.values()[0], self.loss, self.updates],
		feed_dict=feed_dict)
		# Save model checkpoints.
		secs_since_checkpoint = time.time() - last_checkpoint_time
		if secs_since_checkpoint > save_model_secs:
		logging.info('step %d: %g', step, loss)
		# Save model checkpoints at end of epoch
		saver.save(sess, self._save_path, global_step=self.global_step)
		last_checkpoint_time = time.time()
		# Quit when we reach max_steps.
		if max_steps is not None and step >= max_steps:
		break
		log('Ending epoch %d: loss %g' % (epoch, loss), self.verbosity)
		# Always save a final checkpoint when complete.
		saver.save(sess, self._save_path, global_step=self.global_step)

		@@ -333,7 +330,8 @@ class TensorflowGraph(object):

		logging.info('Eval batch took %g seconds', time.time() - start)

		labels = np.array(from_one_hot(np.squeeze(np.concatenate(labels))))
		labels = np.array(from_one_hot(
		np.squeeze(np.concatenate(labels)), axis=-1))

		return np.copy(labels)

		@@ -712,8 +710,10 @@ class TensorflowModel(Model):
		tf_class = TensorflowGraph
		self.model_params = model_params
		self.task_types = task_types
		self.train_model = tf_class(model_params, logdir, task_types, train=True)
		self.eval_model = tf_class(model_params, logdir, task_types, train=False)
		self.train_model = tf_class(model_params, logdir, task_types, train=True,
		verbosity=verbosity)
		self.eval_model = tf_class(model_params, logdir, task_types, train=False,
		verbosity=verbosity)
		self.num_tasks = len(task_types)

		def fit(self, dataset):
		@@ -734,7 +734,7 @@ class TensorflowModel(Model):
		"""
		if logdir != self.train_model.logdir:
		raise ValueError("Cannot save to directory "
		"that was not specifed during initialization")
		"that was not specified during initialization")

		def load(self, model_dir):
		"""

Admin message