Loading deepchem/models/__init__.py +0 −5 Original line number Diff line number Diff line Loading @@ -10,14 +10,9 @@ from deepchem.models.sklearn_models import SklearnModel from deepchem.models.xgboost_models import XGBoostModel from deepchem.models.multitask import SingletaskToMultitask from deepchem.models.tensorflow_models.fcnet import TensorflowMultiTaskRegressor from deepchem.models.tensorflow_models.fcnet import TensorflowMultiTaskClassifier from deepchem.models.tensorflow_models.fcnet import TensorflowMultiTaskFitTransformRegressor from deepchem.models.tensorflow_models.fcnet import MultiTaskRegressor from deepchem.models.tensorflow_models.fcnet import MultiTaskClassifier from deepchem.models.tensorflow_models.fcnet import MultiTaskFitTransformRegressor from deepchem.models.tensorflow_models.robust_multitask import RobustMultitaskRegressor from deepchem.models.tensorflow_models.robust_multitask import RobustMultitaskClassifier from deepchem.models.tensorflow_models.lr import TensorflowLogisticRegression from deepchem.models.tensorflow_models.progressive_multitask import ProgressiveMultitaskRegressor from deepchem.models.tensorflow_models.progressive_joint import ProgressiveJointRegressor Loading deepchem/models/tensorflow_models/robust_multitask.py +0 −320 Original line number Diff line number Diff line Loading @@ -8,323 +8,3 @@ import tensorflow as tf from deepchem.nn import model_ops from deepchem.models.tensorflow_models import TensorflowGraph from deepchem.models.tensorflow_models.fcnet import TensorflowMultiTaskClassifier from deepchem.models.tensorflow_models.fcnet import TensorflowMultiTaskRegressor class RobustMultitaskClassifier(TensorflowMultiTaskClassifier): """Implements a neural network for robust multitasking. Key idea is to have bypass layers that feed directly from features to task output. Hopefully will allow tasks to route around bad multitasking. """ def __init__(self, n_tasks, n_features, logdir=None, bypass_layer_sizes=[100], bypass_weight_init_stddevs=[.02], bypass_bias_init_consts=[1.], bypass_dropouts=[.5], **kwargs): warnings.warn("RobustMultiTaskClassifier is deprecated. " "Will be removed in DeepChem 1.4.", DeprecationWarning) self.bypass_layer_sizes = bypass_layer_sizes self.bypass_weight_init_stddevs = bypass_weight_init_stddevs self.bypass_bias_init_consts = bypass_bias_init_consts self.bypass_dropouts = bypass_dropouts super(RobustMultitaskClassifier, self).__init__(n_tasks, n_features, logdir, **kwargs) def build(self, graph, name_scopes, training): """Constructs the graph architecture as specified in its config. This method creates the following Placeholders: mol_features: Molecule descriptor (e.g. fingerprint) tensor with shape batch_size x num_features. """ num_features = self.n_features placeholder_scope = TensorflowGraph.get_placeholder_scope( graph, name_scopes) with graph.as_default(): with placeholder_scope: mol_features = tf.placeholder( tf.float32, shape=[None, num_features], name='mol_features') layer_sizes = self.layer_sizes weight_init_stddevs = self.weight_init_stddevs bias_init_consts = self.bias_init_consts dropouts = self.dropouts bypass_layer_sizes = self.bypass_layer_sizes bypass_weight_init_stddevs = self.bypass_weight_init_stddevs bypass_bias_init_consts = self.bypass_bias_init_consts bypass_dropouts = self.bypass_dropouts lengths_set = { len(layer_sizes), len(weight_init_stddevs), len(bias_init_consts), len(dropouts), } assert len(lengths_set) == 1, "All layer params must have same length." num_layers = lengths_set.pop() assert num_layers > 0, "Must have some layers defined." bypass_lengths_set = { len(bypass_layer_sizes), len(bypass_weight_init_stddevs), len(bypass_bias_init_consts), len(bypass_dropouts), } assert len(bypass_lengths_set) == 1, ( "All bypass_layer params" + " must have same length.") num_bypass_layers = bypass_lengths_set.pop() label_placeholders = self.add_label_placeholders(graph, name_scopes) weight_placeholders = self.add_example_weight_placeholders( graph, name_scopes) if training: graph.queue = tf.FIFOQueue( capacity=5, dtypes=[tf.float32] * (len(label_placeholders) + len(weight_placeholders) + 1)) graph.enqueue = graph.queue.enqueue([mol_features] + label_placeholders + weight_placeholders) queue_outputs = graph.queue.dequeue() labels = queue_outputs[1:len(label_placeholders) + 1] weights = queue_outputs[len(label_placeholders) + 1:] prev_layer = queue_outputs[0] else: labels = label_placeholders weights = weight_placeholders prev_layer = mol_features top_layer = prev_layer prev_layer_size = num_features for i in range(num_layers): # layer has shape [None, layer_sizes[i]] print("Adding weights of shape %s" % str( [prev_layer_size, layer_sizes[i]])) layer = tf.nn.relu( model_ops.fully_connected_layer( tensor=prev_layer, size=layer_sizes[i], weight_init=tf.truncated_normal( shape=[prev_layer_size, layer_sizes[i]], stddev=weight_init_stddevs[i]), bias_init=tf.constant( value=bias_init_consts[i], shape=[layer_sizes[i]]))) layer = model_ops.dropout(layer, dropouts[i], training) prev_layer = layer prev_layer_size = layer_sizes[i] output = [] # top_multitask_layer has shape [None, layer_sizes[-1]] top_multitask_layer = prev_layer for task in range(self.n_tasks): # TODO(rbharath): Might want to make it feasible to have multiple # bypass layers. # Construct task bypass layer prev_bypass_layer = top_layer prev_bypass_layer_size = num_features for i in range(num_bypass_layers): # bypass_layer has shape [None, bypass_layer_sizes[i]] print("Adding bypass weights of shape %s" % str( [prev_bypass_layer_size, bypass_layer_sizes[i]])) bypass_layer = tf.nn.relu( model_ops.fully_connected_layer( tensor=prev_bypass_layer, size=bypass_layer_sizes[i], weight_init=tf.truncated_normal( shape=[prev_bypass_layer_size, bypass_layer_sizes[i]], stddev=bypass_weight_init_stddevs[i]), bias_init=tf.constant( value=bypass_bias_init_consts[i], shape=[bypass_layer_sizes[i]]))) bypass_layer = model_ops.dropout(bypass_layer, bypass_dropouts[i], training) prev_bypass_layer = bypass_layer prev_bypass_layer_size = bypass_layer_sizes[i] top_bypass_layer = prev_bypass_layer if num_bypass_layers > 0: # task_layer has shape [None, layer_sizes[-1] + bypass_layer_sizes[-1]] task_layer = tf.concat( axis=1, values=[top_multitask_layer, top_bypass_layer]) task_layer_size = layer_sizes[-1] + bypass_layer_sizes[-1] else: task_layer = top_multitask_layer task_layer_size = layer_sizes[-1] print("Adding output weights of shape %s" % str([task_layer_size, 1])) output.append( model_ops.logits( task_layer, num_classes=2, weight_init=tf.truncated_normal( shape=[task_layer_size, 2], stddev=weight_init_stddevs[-1]), bias_init=tf.constant(value=bias_init_consts[-1], shape=[2]))) return (output, labels, weights) class RobustMultitaskRegressor(TensorflowMultiTaskRegressor): """Implements a neural network for robust multitasking. Key idea is to have bypass layers that feed directly from features to task output. Hopefully will allow tasks to route around bad multitasking. """ def __init__(self, n_tasks, n_features, logdir=None, bypass_layer_sizes=[100], bypass_weight_init_stddevs=[.02], bypass_bias_init_consts=[1.], bypass_dropouts=[.5], **kwargs): warnings.warn("RobustMultiTaskRegressor is deprecated. " "Will be removed in DeepChem 1.4.", DeprecationWarning) self.bypass_layer_sizes = bypass_layer_sizes self.bypass_weight_init_stddevs = bypass_weight_init_stddevs self.bypass_bias_init_consts = bypass_bias_init_consts self.bypass_dropouts = bypass_dropouts super(RobustMultitaskRegressor, self).__init__(n_tasks, n_features, logdir, **kwargs) def build(self, graph, name_scopes, training): """Constructs the graph architecture as specified in its config. This method creates the following Placeholders: mol_features: Molecule descriptor (e.g. fingerprint) tensor with shape batch_size x num_features. """ num_features = self.n_features placeholder_scope = TensorflowGraph.get_placeholder_scope( graph, name_scopes) with graph.as_default(): with placeholder_scope: mol_features = tf.placeholder( tf.float32, shape=[None, num_features], name='mol_features') layer_sizes = self.layer_sizes weight_init_stddevs = self.weight_init_stddevs bias_init_consts = self.bias_init_consts dropouts = self.dropouts bypass_layer_sizes = self.bypass_layer_sizes bypass_weight_init_stddevs = self.bypass_weight_init_stddevs bypass_bias_init_consts = self.bypass_bias_init_consts bypass_dropouts = self.bypass_dropouts lengths_set = { len(layer_sizes), len(weight_init_stddevs), len(bias_init_consts), len(dropouts), } assert len(lengths_set) == 1, "All layer params must have same length." num_layers = lengths_set.pop() assert num_layers > 0, "Must have some layers defined." bypass_lengths_set = { len(bypass_layer_sizes), len(bypass_weight_init_stddevs), len(bypass_bias_init_consts), len(bypass_dropouts), } assert len(bypass_lengths_set) == 1, ( "All bypass_layer params" + " must have same length.") num_bypass_layers = bypass_lengths_set.pop() label_placeholders = self.add_label_placeholders(graph, name_scopes) weight_placeholders = self.add_example_weight_placeholders( graph, name_scopes) if training: graph.queue = tf.FIFOQueue( capacity=5, dtypes=[tf.float32] * (len(label_placeholders) + len(weight_placeholders) + 1)) graph.enqueue = graph.queue.enqueue([mol_features] + label_placeholders + weight_placeholders) queue_outputs = graph.queue.dequeue() labels = queue_outputs[1:len(label_placeholders) + 1] weights = queue_outputs[len(label_placeholders) + 1:] prev_layer = queue_outputs[0] else: labels = label_placeholders weights = weight_placeholders prev_layer = mol_features top_layer = prev_layer prev_layer_size = num_features for i in range(num_layers): # layer has shape [None, layer_sizes[i]] print("Adding weights of shape %s" % str( [prev_layer_size, layer_sizes[i]])) layer = tf.nn.relu( model_ops.fully_connected_layer( tensor=prev_layer, size=layer_sizes[i], weight_init=tf.truncated_normal( shape=[prev_layer_size, layer_sizes[i]], stddev=weight_init_stddevs[i]), bias_init=tf.constant( value=bias_init_consts[i], shape=[layer_sizes[i]]))) layer = model_ops.dropout(layer, dropouts[i], training) prev_layer = layer prev_layer_size = layer_sizes[i] output = [] # top_multitask_layer has shape [None, layer_sizes[-1]] top_multitask_layer = prev_layer for task in range(self.n_tasks): # TODO(rbharath): Might want to make it feasible to have multiple # bypass layers. # Construct task bypass layer prev_bypass_layer = top_layer prev_bypass_layer_size = num_features for i in range(num_bypass_layers): # bypass_layer has shape [None, bypass_layer_sizes[i]] print("Adding bypass weights of shape %s" % str( [prev_bypass_layer_size, bypass_layer_sizes[i]])) bypass_layer = tf.nn.relu( model_ops.fully_connected_layer( tensor=prev_bypass_layer, size=bypass_layer_sizes[i], weight_init=tf.truncated_normal( shape=[prev_bypass_layer_size, bypass_layer_sizes[i]], stddev=bypass_weight_init_stddevs[i]), bias_init=tf.constant( value=bypass_bias_init_consts[i], shape=[bypass_layer_sizes[i]]))) bypass_layer = model_ops.dropout(bypass_layer, bypass_dropouts[i], training) prev_bypass_layer = bypass_layer prev_bypass_layer_size = bypass_layer_sizes[i] top_bypass_layer = prev_bypass_layer if num_bypass_layers > 0: # task_layer has shape [None, layer_sizes[-1] + bypass_layer_sizes[-1]] task_layer = tf.concat( axis=1, values=[top_multitask_layer, top_bypass_layer]) task_layer_size = layer_sizes[-1] + bypass_layer_sizes[-1] else: task_layer = top_multitask_layer task_layer_size = layer_sizes[-1] print("Adding output weights of shape %s" % str([task_layer_size, 1])) output.append( tf.squeeze( model_ops.fully_connected_layer( tensor=task_layer, size=1, weight_init=tf.truncated_normal( shape=[task_layer_size, 1], stddev=weight_init_stddevs[-1]), bias_init=tf.constant( value=bias_init_consts[-1], shape=[1])), axis=1)) return (output, labels, weights) deepchem/models/tests/test_api.py +0 −42 Original line number Diff line number Diff line Loading @@ -141,48 +141,6 @@ class TestAPI(unittest.TestCase): _ = model.evaluate(train_dataset, regression_metrics, transformers) _ = model.evaluate(test_dataset, regression_metrics, transformers) def test_singletask_tf_mlp_ECFP_classification_API(self): """Test of Tensorflow singletask deepchem classification API.""" n_features = 1024 featurizer = dc.feat.CircularFingerprint(size=n_features) tasks = ["outcome"] current_dir = os.path.dirname(os.path.abspath(__file__)) input_file = os.path.join(current_dir, "example_classification.csv") loader = dc.data.CSVLoader( tasks=tasks, smiles_field="smiles", featurizer=featurizer) dataset = loader.featurize(input_file) splitter = dc.splits.ScaffoldSplitter() train_dataset, test_dataset = splitter.train_test_split(dataset) transformers = [ dc.trans.NormalizationTransformer( transform_y=True, dataset=train_dataset) ] for dataset in [train_dataset, test_dataset]: for transformer in transformers: dataset = transformer.transform(dataset) classification_metrics = [ dc.metrics.Metric(dc.metrics.roc_auc_score), dc.metrics.Metric(dc.metrics.matthews_corrcoef), dc.metrics.Metric(dc.metrics.recall_score), dc.metrics.Metric(dc.metrics.accuracy_score) ] model = dc.models.TensorflowMultiTaskClassifier(len(tasks), n_features) # Fit trained model model.fit(train_dataset) model.save() # Eval model on train/test _ = model.evaluate(train_dataset, classification_metrics, transformers) _ = model.evaluate(test_dataset, classification_metrics, transformers) def test_singletask_tg_mlp_ECFP_classification_API(self): """Test of TensorGraph singletask deepchem classification API.""" n_features = 1024 Loading deepchem/models/tests/test_overfit.py +0 −245 File changed.Preview size limit exceeded, changes collapsed. Show changes deepchem/models/tests/test_reload.py +0 −38 Original line number Diff line number Diff line Loading @@ -50,41 +50,3 @@ class TestReload(unittest.TestCase): # Eval model on train scores = reloaded_model.evaluate(dataset, [classification_metric]) assert scores[classification_metric.name] > .9 def test_tf_reload(self): """Test that tensorflow models can overfit simple classification datasets.""" n_samples = 10 n_features = 3 n_tasks = 1 n_classes = 2 # Generate dummy dataset np.random.seed(123) ids = np.arange(n_samples) X = np.random.rand(n_samples, n_features) y = np.random.randint(n_classes, size=(n_samples, n_tasks)) w = np.ones((n_samples, n_tasks)) dataset = dc.data.NumpyDataset(X, y, w, ids) classification_metric = dc.metrics.Metric(dc.metrics.accuracy_score) model_dir = tempfile.mkdtemp() model = dc.models.TensorflowMultiTaskClassifier( n_tasks, n_features, model_dir, dropouts=[0.]) # Fit trained model model.fit(dataset) scores_preload = model.evaluate(dataset, [classification_metric])['accuracy_score'] model.save() # Load trained model reloaded_model = dc.models.TensorflowMultiTaskClassifier( n_tasks, n_features, model_dir, dropouts=[0.]) reloaded_model.reload() # Eval model on train scores_reload = reloaded_model.evaluate( dataset, [classification_metric])['accuracy_score'] assert np.isclose(scores_preload, scores_reload, 0.01) Loading
deepchem/models/__init__.py +0 −5 Original line number Diff line number Diff line Loading @@ -10,14 +10,9 @@ from deepchem.models.sklearn_models import SklearnModel from deepchem.models.xgboost_models import XGBoostModel from deepchem.models.multitask import SingletaskToMultitask from deepchem.models.tensorflow_models.fcnet import TensorflowMultiTaskRegressor from deepchem.models.tensorflow_models.fcnet import TensorflowMultiTaskClassifier from deepchem.models.tensorflow_models.fcnet import TensorflowMultiTaskFitTransformRegressor from deepchem.models.tensorflow_models.fcnet import MultiTaskRegressor from deepchem.models.tensorflow_models.fcnet import MultiTaskClassifier from deepchem.models.tensorflow_models.fcnet import MultiTaskFitTransformRegressor from deepchem.models.tensorflow_models.robust_multitask import RobustMultitaskRegressor from deepchem.models.tensorflow_models.robust_multitask import RobustMultitaskClassifier from deepchem.models.tensorflow_models.lr import TensorflowLogisticRegression from deepchem.models.tensorflow_models.progressive_multitask import ProgressiveMultitaskRegressor from deepchem.models.tensorflow_models.progressive_joint import ProgressiveJointRegressor Loading
deepchem/models/tensorflow_models/robust_multitask.py +0 −320 Original line number Diff line number Diff line Loading @@ -8,323 +8,3 @@ import tensorflow as tf from deepchem.nn import model_ops from deepchem.models.tensorflow_models import TensorflowGraph from deepchem.models.tensorflow_models.fcnet import TensorflowMultiTaskClassifier from deepchem.models.tensorflow_models.fcnet import TensorflowMultiTaskRegressor class RobustMultitaskClassifier(TensorflowMultiTaskClassifier): """Implements a neural network for robust multitasking. Key idea is to have bypass layers that feed directly from features to task output. Hopefully will allow tasks to route around bad multitasking. """ def __init__(self, n_tasks, n_features, logdir=None, bypass_layer_sizes=[100], bypass_weight_init_stddevs=[.02], bypass_bias_init_consts=[1.], bypass_dropouts=[.5], **kwargs): warnings.warn("RobustMultiTaskClassifier is deprecated. " "Will be removed in DeepChem 1.4.", DeprecationWarning) self.bypass_layer_sizes = bypass_layer_sizes self.bypass_weight_init_stddevs = bypass_weight_init_stddevs self.bypass_bias_init_consts = bypass_bias_init_consts self.bypass_dropouts = bypass_dropouts super(RobustMultitaskClassifier, self).__init__(n_tasks, n_features, logdir, **kwargs) def build(self, graph, name_scopes, training): """Constructs the graph architecture as specified in its config. This method creates the following Placeholders: mol_features: Molecule descriptor (e.g. fingerprint) tensor with shape batch_size x num_features. """ num_features = self.n_features placeholder_scope = TensorflowGraph.get_placeholder_scope( graph, name_scopes) with graph.as_default(): with placeholder_scope: mol_features = tf.placeholder( tf.float32, shape=[None, num_features], name='mol_features') layer_sizes = self.layer_sizes weight_init_stddevs = self.weight_init_stddevs bias_init_consts = self.bias_init_consts dropouts = self.dropouts bypass_layer_sizes = self.bypass_layer_sizes bypass_weight_init_stddevs = self.bypass_weight_init_stddevs bypass_bias_init_consts = self.bypass_bias_init_consts bypass_dropouts = self.bypass_dropouts lengths_set = { len(layer_sizes), len(weight_init_stddevs), len(bias_init_consts), len(dropouts), } assert len(lengths_set) == 1, "All layer params must have same length." num_layers = lengths_set.pop() assert num_layers > 0, "Must have some layers defined." bypass_lengths_set = { len(bypass_layer_sizes), len(bypass_weight_init_stddevs), len(bypass_bias_init_consts), len(bypass_dropouts), } assert len(bypass_lengths_set) == 1, ( "All bypass_layer params" + " must have same length.") num_bypass_layers = bypass_lengths_set.pop() label_placeholders = self.add_label_placeholders(graph, name_scopes) weight_placeholders = self.add_example_weight_placeholders( graph, name_scopes) if training: graph.queue = tf.FIFOQueue( capacity=5, dtypes=[tf.float32] * (len(label_placeholders) + len(weight_placeholders) + 1)) graph.enqueue = graph.queue.enqueue([mol_features] + label_placeholders + weight_placeholders) queue_outputs = graph.queue.dequeue() labels = queue_outputs[1:len(label_placeholders) + 1] weights = queue_outputs[len(label_placeholders) + 1:] prev_layer = queue_outputs[0] else: labels = label_placeholders weights = weight_placeholders prev_layer = mol_features top_layer = prev_layer prev_layer_size = num_features for i in range(num_layers): # layer has shape [None, layer_sizes[i]] print("Adding weights of shape %s" % str( [prev_layer_size, layer_sizes[i]])) layer = tf.nn.relu( model_ops.fully_connected_layer( tensor=prev_layer, size=layer_sizes[i], weight_init=tf.truncated_normal( shape=[prev_layer_size, layer_sizes[i]], stddev=weight_init_stddevs[i]), bias_init=tf.constant( value=bias_init_consts[i], shape=[layer_sizes[i]]))) layer = model_ops.dropout(layer, dropouts[i], training) prev_layer = layer prev_layer_size = layer_sizes[i] output = [] # top_multitask_layer has shape [None, layer_sizes[-1]] top_multitask_layer = prev_layer for task in range(self.n_tasks): # TODO(rbharath): Might want to make it feasible to have multiple # bypass layers. # Construct task bypass layer prev_bypass_layer = top_layer prev_bypass_layer_size = num_features for i in range(num_bypass_layers): # bypass_layer has shape [None, bypass_layer_sizes[i]] print("Adding bypass weights of shape %s" % str( [prev_bypass_layer_size, bypass_layer_sizes[i]])) bypass_layer = tf.nn.relu( model_ops.fully_connected_layer( tensor=prev_bypass_layer, size=bypass_layer_sizes[i], weight_init=tf.truncated_normal( shape=[prev_bypass_layer_size, bypass_layer_sizes[i]], stddev=bypass_weight_init_stddevs[i]), bias_init=tf.constant( value=bypass_bias_init_consts[i], shape=[bypass_layer_sizes[i]]))) bypass_layer = model_ops.dropout(bypass_layer, bypass_dropouts[i], training) prev_bypass_layer = bypass_layer prev_bypass_layer_size = bypass_layer_sizes[i] top_bypass_layer = prev_bypass_layer if num_bypass_layers > 0: # task_layer has shape [None, layer_sizes[-1] + bypass_layer_sizes[-1]] task_layer = tf.concat( axis=1, values=[top_multitask_layer, top_bypass_layer]) task_layer_size = layer_sizes[-1] + bypass_layer_sizes[-1] else: task_layer = top_multitask_layer task_layer_size = layer_sizes[-1] print("Adding output weights of shape %s" % str([task_layer_size, 1])) output.append( model_ops.logits( task_layer, num_classes=2, weight_init=tf.truncated_normal( shape=[task_layer_size, 2], stddev=weight_init_stddevs[-1]), bias_init=tf.constant(value=bias_init_consts[-1], shape=[2]))) return (output, labels, weights) class RobustMultitaskRegressor(TensorflowMultiTaskRegressor): """Implements a neural network for robust multitasking. Key idea is to have bypass layers that feed directly from features to task output. Hopefully will allow tasks to route around bad multitasking. """ def __init__(self, n_tasks, n_features, logdir=None, bypass_layer_sizes=[100], bypass_weight_init_stddevs=[.02], bypass_bias_init_consts=[1.], bypass_dropouts=[.5], **kwargs): warnings.warn("RobustMultiTaskRegressor is deprecated. " "Will be removed in DeepChem 1.4.", DeprecationWarning) self.bypass_layer_sizes = bypass_layer_sizes self.bypass_weight_init_stddevs = bypass_weight_init_stddevs self.bypass_bias_init_consts = bypass_bias_init_consts self.bypass_dropouts = bypass_dropouts super(RobustMultitaskRegressor, self).__init__(n_tasks, n_features, logdir, **kwargs) def build(self, graph, name_scopes, training): """Constructs the graph architecture as specified in its config. This method creates the following Placeholders: mol_features: Molecule descriptor (e.g. fingerprint) tensor with shape batch_size x num_features. """ num_features = self.n_features placeholder_scope = TensorflowGraph.get_placeholder_scope( graph, name_scopes) with graph.as_default(): with placeholder_scope: mol_features = tf.placeholder( tf.float32, shape=[None, num_features], name='mol_features') layer_sizes = self.layer_sizes weight_init_stddevs = self.weight_init_stddevs bias_init_consts = self.bias_init_consts dropouts = self.dropouts bypass_layer_sizes = self.bypass_layer_sizes bypass_weight_init_stddevs = self.bypass_weight_init_stddevs bypass_bias_init_consts = self.bypass_bias_init_consts bypass_dropouts = self.bypass_dropouts lengths_set = { len(layer_sizes), len(weight_init_stddevs), len(bias_init_consts), len(dropouts), } assert len(lengths_set) == 1, "All layer params must have same length." num_layers = lengths_set.pop() assert num_layers > 0, "Must have some layers defined." bypass_lengths_set = { len(bypass_layer_sizes), len(bypass_weight_init_stddevs), len(bypass_bias_init_consts), len(bypass_dropouts), } assert len(bypass_lengths_set) == 1, ( "All bypass_layer params" + " must have same length.") num_bypass_layers = bypass_lengths_set.pop() label_placeholders = self.add_label_placeholders(graph, name_scopes) weight_placeholders = self.add_example_weight_placeholders( graph, name_scopes) if training: graph.queue = tf.FIFOQueue( capacity=5, dtypes=[tf.float32] * (len(label_placeholders) + len(weight_placeholders) + 1)) graph.enqueue = graph.queue.enqueue([mol_features] + label_placeholders + weight_placeholders) queue_outputs = graph.queue.dequeue() labels = queue_outputs[1:len(label_placeholders) + 1] weights = queue_outputs[len(label_placeholders) + 1:] prev_layer = queue_outputs[0] else: labels = label_placeholders weights = weight_placeholders prev_layer = mol_features top_layer = prev_layer prev_layer_size = num_features for i in range(num_layers): # layer has shape [None, layer_sizes[i]] print("Adding weights of shape %s" % str( [prev_layer_size, layer_sizes[i]])) layer = tf.nn.relu( model_ops.fully_connected_layer( tensor=prev_layer, size=layer_sizes[i], weight_init=tf.truncated_normal( shape=[prev_layer_size, layer_sizes[i]], stddev=weight_init_stddevs[i]), bias_init=tf.constant( value=bias_init_consts[i], shape=[layer_sizes[i]]))) layer = model_ops.dropout(layer, dropouts[i], training) prev_layer = layer prev_layer_size = layer_sizes[i] output = [] # top_multitask_layer has shape [None, layer_sizes[-1]] top_multitask_layer = prev_layer for task in range(self.n_tasks): # TODO(rbharath): Might want to make it feasible to have multiple # bypass layers. # Construct task bypass layer prev_bypass_layer = top_layer prev_bypass_layer_size = num_features for i in range(num_bypass_layers): # bypass_layer has shape [None, bypass_layer_sizes[i]] print("Adding bypass weights of shape %s" % str( [prev_bypass_layer_size, bypass_layer_sizes[i]])) bypass_layer = tf.nn.relu( model_ops.fully_connected_layer( tensor=prev_bypass_layer, size=bypass_layer_sizes[i], weight_init=tf.truncated_normal( shape=[prev_bypass_layer_size, bypass_layer_sizes[i]], stddev=bypass_weight_init_stddevs[i]), bias_init=tf.constant( value=bypass_bias_init_consts[i], shape=[bypass_layer_sizes[i]]))) bypass_layer = model_ops.dropout(bypass_layer, bypass_dropouts[i], training) prev_bypass_layer = bypass_layer prev_bypass_layer_size = bypass_layer_sizes[i] top_bypass_layer = prev_bypass_layer if num_bypass_layers > 0: # task_layer has shape [None, layer_sizes[-1] + bypass_layer_sizes[-1]] task_layer = tf.concat( axis=1, values=[top_multitask_layer, top_bypass_layer]) task_layer_size = layer_sizes[-1] + bypass_layer_sizes[-1] else: task_layer = top_multitask_layer task_layer_size = layer_sizes[-1] print("Adding output weights of shape %s" % str([task_layer_size, 1])) output.append( tf.squeeze( model_ops.fully_connected_layer( tensor=task_layer, size=1, weight_init=tf.truncated_normal( shape=[task_layer_size, 1], stddev=weight_init_stddevs[-1]), bias_init=tf.constant( value=bias_init_consts[-1], shape=[1])), axis=1)) return (output, labels, weights)
deepchem/models/tests/test_api.py +0 −42 Original line number Diff line number Diff line Loading @@ -141,48 +141,6 @@ class TestAPI(unittest.TestCase): _ = model.evaluate(train_dataset, regression_metrics, transformers) _ = model.evaluate(test_dataset, regression_metrics, transformers) def test_singletask_tf_mlp_ECFP_classification_API(self): """Test of Tensorflow singletask deepchem classification API.""" n_features = 1024 featurizer = dc.feat.CircularFingerprint(size=n_features) tasks = ["outcome"] current_dir = os.path.dirname(os.path.abspath(__file__)) input_file = os.path.join(current_dir, "example_classification.csv") loader = dc.data.CSVLoader( tasks=tasks, smiles_field="smiles", featurizer=featurizer) dataset = loader.featurize(input_file) splitter = dc.splits.ScaffoldSplitter() train_dataset, test_dataset = splitter.train_test_split(dataset) transformers = [ dc.trans.NormalizationTransformer( transform_y=True, dataset=train_dataset) ] for dataset in [train_dataset, test_dataset]: for transformer in transformers: dataset = transformer.transform(dataset) classification_metrics = [ dc.metrics.Metric(dc.metrics.roc_auc_score), dc.metrics.Metric(dc.metrics.matthews_corrcoef), dc.metrics.Metric(dc.metrics.recall_score), dc.metrics.Metric(dc.metrics.accuracy_score) ] model = dc.models.TensorflowMultiTaskClassifier(len(tasks), n_features) # Fit trained model model.fit(train_dataset) model.save() # Eval model on train/test _ = model.evaluate(train_dataset, classification_metrics, transformers) _ = model.evaluate(test_dataset, classification_metrics, transformers) def test_singletask_tg_mlp_ECFP_classification_API(self): """Test of TensorGraph singletask deepchem classification API.""" n_features = 1024 Loading
deepchem/models/tests/test_overfit.py +0 −245 File changed.Preview size limit exceeded, changes collapsed. Show changes
deepchem/models/tests/test_reload.py +0 −38 Original line number Diff line number Diff line Loading @@ -50,41 +50,3 @@ class TestReload(unittest.TestCase): # Eval model on train scores = reloaded_model.evaluate(dataset, [classification_metric]) assert scores[classification_metric.name] > .9 def test_tf_reload(self): """Test that tensorflow models can overfit simple classification datasets.""" n_samples = 10 n_features = 3 n_tasks = 1 n_classes = 2 # Generate dummy dataset np.random.seed(123) ids = np.arange(n_samples) X = np.random.rand(n_samples, n_features) y = np.random.randint(n_classes, size=(n_samples, n_tasks)) w = np.ones((n_samples, n_tasks)) dataset = dc.data.NumpyDataset(X, y, w, ids) classification_metric = dc.metrics.Metric(dc.metrics.accuracy_score) model_dir = tempfile.mkdtemp() model = dc.models.TensorflowMultiTaskClassifier( n_tasks, n_features, model_dir, dropouts=[0.]) # Fit trained model model.fit(dataset) scores_preload = model.evaluate(dataset, [classification_metric])['accuracy_score'] model.save() # Load trained model reloaded_model = dc.models.TensorflowMultiTaskClassifier( n_tasks, n_features, model_dir, dropouts=[0.]) reloaded_model.reload() # Eval model on train scores_reload = reloaded_model.evaluate( dataset, [classification_metric])['accuracy_score'] assert np.isclose(scores_preload, scores_reload, 0.01)
