weave model first draft (52a85775) · Commits · 钟慕尧 / deepchem

deepchem/models/tf_new_models/graph_models.py

+8 −8

Original line number	Diff line number	Diff line
		@@ -162,7 +162,7 @@ class SequentialDAGGraph(SequentialGraph):
		self.layers.append(layer)

		class SequentialWeaveGraph(SequentialGraph):
		"""SequentialGraph for DAG models
		"""SequentialGraph for Weave models
		"""

		def __init__(self, max_atoms=50, n_atom_feat=75, n_pair_feat=14):
		@@ -174,7 +174,7 @@ class SequentialWeaveGraph(SequentialGraph):
		self.graph_topology = WeaveGraphTopology(self.max_atoms,
		self.n_atom_feat,
		self.n_pair_feat)
		self.output_A = self.graph_topology.get_atom_features_placeholder()
		self.output = self.graph_topology.get_atom_features_placeholder()
		self.output_P = self.graph_topology.get_pair_features_placeholder()
		self.layers = []

		@@ -182,16 +182,16 @@ class SequentialWeaveGraph(SequentialGraph):
		"""Adds a new layer to model."""
		with self.graph.as_default():
		if type(layer).__name__ in ['WeaveLayer']:
		self.output_A, self.output_P = layer([self.output_A, self.output_P] +
		self.output, self.output_P = layer([self.output, self.output_P] +
		self.graph_topology.get_topology_placeholders())
		elif type(layer).__name__ in ['WeaveConcat']:
		self.output_A = layer(
		[self.output_A, self.graph_topology.atom_mask_placeholder])
		self.output = layer(
		[self.output, self.graph_topology.atom_mask_placeholder])
		elif type(layer).__name__ in ['WeaveGather']:
		self.output_A = layer(
		[self.output_A, self.graph_topology.membership_placeholder])
		self.output = layer(
		[self.output, self.graph_topology.membership_placeholder])
		else:
		self.output_A = layer(self.output_A)
		self.output = layer(self.output)
		self.layers.append(layer)

		class SequentialSupportGraph(object):

deepchem/models/tf_new_models/graph_topology.py

+6 −9

Original line number	Diff line number	Diff line
		@@ -396,19 +396,16 @@ class DAGGraphTopology(GraphTopology):
		class WeaveGraphTopology(GraphTopology):
		"""Manages placeholders associated with batch of graphs and their topology"""

		def __init__(self, max_atoms, n_atom_feat, n_pair_feat, name='DTNN_topology'):
		def __init__(self, max_atoms, n_atom_feat, n_pair_feat, name='Weave_topology'):
		"""
		Parameters
		----------
		max_n_atoms: int
		max_atoms: int
		maximum number of atoms in a molecule
		n_distance: int, optional
		granularity of distance matrix
		step size will be (distance_max-distance_min)/n_distance
		distance_min: float, optional
		minimum distance of atom pairs, default = -1 Angstorm
		distance_max: float, optional
		maximum distance of atom pairs, default = 18 Angstorm
		n_atom_feat: int
		number of basic features of each atom
		n_pair_feat: int
		number of basic features of each pair
		"""

		#self.n_atoms = n_atoms

deepchem/nn/weave_layers.py

+11 −13

Original line number	Diff line number	Diff line
		@@ -173,10 +173,12 @@ class WeaveConcat(Layer):
		def call(self, x, mask=None):
		"""Execute this layer on input tensors.

		x = [atom_features, atom_mask]

		Parameters
		----------
		x: list
		Tensors: atom_features, atom_masks
		Tensors as listed above
		mask: bool, optional
		Ignored. Present only to shadow superclass call() method.

		@@ -189,7 +191,7 @@ class WeaveConcat(Layer):
		atom_features = x[0]
		atom_masks = x[1]
		A = tf.split(atom_features, self.batch_size, axis=0)
		A_mask = tf.unstack(tf.cast(atom_masks, dtype=tf.bool), self.batch_size, axis=0)
		A_mask = tf.split(tf.cast(atom_masks, dtype=tf.bool), self.batch_size, axis=0)
		outputs = tf.concat([tf.boolean_mask(A[i], A_mask[i]) for i in range(len(A))], axis=0)
		return outputs

		@@ -202,7 +204,7 @@ class WeaveGather(Layer):
		def __init__(self,
		batch_size,
		n_atom_input_feat=50,
		n_hidden=128,
		n_output=128,
		init='glorot_uniform',
		activation='tanh',
		gaussian_expand=True,
		@@ -238,22 +240,18 @@ class WeaveGather(Layer):
		self.batch_size = batch_size
		self.init = initializations.get(init) # Set weight initialization
		self.activation = activations.get(activation) # Get activations
		self.n_hidden = n_hidden
		self.n_output = n_output
		self.n_atom_input_feat = n_atom_input_feat
		self.gaussian_expand = gaussian_expand
		if gaussian_expand:
		self.n_outputs = self.n_hidden * 11
		else:
		self.n_outputs = self.n_hidden
		self.epsilon = epsilon
		self.momentum = momentum

		def build(self, shape):
		def build(self):
		""""Construct internal trainable weights.
		"""

		self.W = self.init([self.n_atom_input_feat, self.n_hidden])
		self.b = model_ops.zeros(shape=[self.n_hidden,])
		self.W = self.init([self.n_atom_input_feat, self.n_output])
		self.b = model_ops.zeros(shape=[self.n_output,])

		self.trainable_weights = self.W + self.b

		@@ -285,7 +283,7 @@ class WeaveGather(Layer):
		output_molecules = [tf.reduce_sum(molecule, 0) for molecule in outputs]

		output_molecules = tf.stack(output_molecules)
		return outputs
		return output_molecules

		def gaussian_histogram(x):
		return x

examples/delaney/delaney_weave.py

+6 −5

Original line number	Diff line number	Diff line
		@@ -13,7 +13,7 @@ import deepchem as dc

		# Load Delaney dataset
		delaney_tasks, delaney_datasets, transformers = dc.molnet.load_delaney(
		featurizer='Weave', split='random')
		featurizer='Weave', split='scaffold')
		train_dataset, valid_dataset, test_dataset = delaney_datasets

		# Fit models
		@@ -30,27 +30,28 @@ n_pair_feat = 14
		max_atoms = 55
		# Batch size of models
		batch_size = 64
		n_output = 128
		graph = dc.nn.SequentialWeaveGraph(max_atoms=max_atoms,
		n_atom_feat=n_atom_feat,
		n_pair_feat=n_pair_feat)

		graph.add(dc.nn.WeaveLayer())
		graph.add(dc.nn.WeaveConcat(batch_size))
		graph.add(dc.nn.WeaveGather(batch_size))
		graph.add(dc.nn.WeaveGather(batch_size, gaussian_expand=False, n_output=n_output))

		model = dc.models.MultitaskGraphRegressor(
		graph,
		len(delaney_tasks),
		n_feat,
		128,
		batch_size=batch_size,
		learning_rate=1e-3,
		learning_rate=1e-4,
		learning_rate_decay_time=1000,
		optimizer_type="adam",
		beta1=.9,
		beta2=.999)

		# Fit trained model
		model.fit(train_dataset, nb_epoch=20, log_every_N_batches=5)
		model.fit(train_dataset, nb_epoch=100, log_every_N_batches=50)
		print("Evaluating model")
		train_scores = model.evaluate(train_dataset, [metric], transformers)
		valid_scores = model.evaluate(valid_dataset, [metric], transformers)

Admin message