Made initializations consistent with tf.keras naming; test_file_rename (9d016fef) · Commits · 钟慕尧 / deepchem

deepchem/models/layers.py

+93 −74

Original line number	Diff line number	Diff line
		@@ -127,7 +127,8 @@ class GraphConv(tf.keras.layers.Layer):
		atom_features = tf.concat(axis=0, values=new_rel_atoms_collection)

		if self.activation_fn is not None:
		atom_features = self.activation_fn(atom_features)
		activation = activations.get(self.activation_fn)
		atom_features = activation(atom_features)

		return atom_features

		@@ -225,7 +226,8 @@ class GraphGather(tf.keras.layers.Layer):
		mol_features = tf.concat(axis=1, values=[sparse_reps, max_reps])

		if self.activation_fn is not None:
		mol_features = self.activation_fn(mol_features)
		activation = activations.get(self.activation_fn)
		mol_features = activation(mol_features)
		return mol_features


		@@ -241,10 +243,10 @@ class LSTMStep(tf.keras.layers.Layer):
		def __init__(self,
		output_dim,
		input_dim,
		init_fn=initializations.glorot_uniform,
		inner_init_fn=initializations.orthogonal,
		activation_fn=activations.tanh,
		inner_activation_fn=activations.hard_sigmoid,
		init_fn='glorot_uniform',
		inner_init_fn='orthogonal',
		activation_fn='tanh',
		inner_activation_fn='hard_sigmoid',
		**kwargs):
		"""
		Parameters
		@@ -253,13 +255,13 @@ class LSTMStep(tf.keras.layers.Layer):
		Dimensionality of output vectors.
		input_dim: int
		Dimensionality of input vectors.
		init_fn: object
		TensorFlow initialization to use for W.
		inner_init_fn: object
		init_fn: str
		TensorFlow nitialization to use for W.
		inner_init_fn: str
		TensorFlow initialization to use for U.
		activation_fn: object
		activation_fn: str
		TensorFlow activation to use for output.
		inner_activation_fn: object
		inner_activation_fn: str
		TensorFlow activation to use for inner steps.
		"""

		@@ -287,8 +289,8 @@ class LSTMStep(tf.keras.layers.Layer):

		def build(self, input_shape):
		"""Constructs learnable weights for this layer."""
		init = self.init
		inner_init = self.inner_init
		init = initializations.get(self.init)
		inner_init = initializations.get(self.inner_init)
		self.W = init((self.input_dim, 4 * self.output_dim))
		self.U = inner_init((self.output_dim, 4 * self.output_dim))

		@@ -311,8 +313,8 @@ class LSTMStep(tf.keras.layers.Layer):
		list
		Returns h, [h, c]
		"""
		activation = self.activation
		inner_activation = self.inner_activation
		activation = activations.get(self.activation)
		inner_activation = activations.get(self.inner_activation)
		x, h_tm1, c_tm1 = inputs

		# Taken from Keras code [citation needed]
		@@ -1844,9 +1846,9 @@ class Highway(tf.keras.layers.Layer):
		"""

		def __init__(self,
		activation_fn=tf.nn.relu,
		biases_initializer=tf.zeros_initializer,
		weights_initializer=tf.keras.initializers.VarianceScaling,
		activation_fn='relu',
		biases_initializer='zeros',
		weights_initializer=None,
		**kwargs):
		"""
		Parameters
		@@ -1875,20 +1877,22 @@ class Highway(tf.keras.layers.Layer):
		if isinstance(input_shape, collections.Sequence):
		input_shape = input_shape[0]
		out_channels = input_shape[1]
		if self.biases_initializer is None:
		biases_initializer = None

		if self.weights_initializer is None:
		weights_initializer = tf.keras.initializers.VarianceScaling
		else:
		biases_initializer = self.biases_initializer()
		weights_initializer = self.weights_initializer

		self.dense_H = tf.keras.layers.Dense(
		out_channels,
		activation=self.activation_fn,
		bias_initializer=biases_initializer,
		kernel_initializer=self.weights_initializer())
		bias_initializer=self.biases_initializer,
		kernel_initializer=weights_initializer)
		self.dense_T = tf.keras.layers.Dense(
		out_channels,
		activation=tf.nn.sigmoid,
		bias_initializer=tf.constant_initializer(-1),
		kernel_initializer=self.weights_initializer())
		kernel_initializer=weights_initializer)
		self.built = True

		def call(self, inputs):
		@@ -1939,7 +1943,7 @@ class WeaveLayer(tf.keras.layers.Layer):
		"""
		super(WeaveLayer, self).__init__(**kwargs)
		self.init = init # Set weight initialization
		self.activation = activations.get(activation) # Get activations
		self.activation = activation # Get activations
		self.update_pair = update_pair # last weave layer does not need to update
		self.n_hidden_AA = n_hidden_AA
		self.n_hidden_PA = n_hidden_PA
		@@ -2016,31 +2020,33 @@ class WeaveLayer(tf.keras.layers.Layer):
		pair_split = inputs[2]
		atom_to_pair = inputs[3]

		activation = activations.get(self.activation)

		AA = tf.matmul(atom_features, self.W_AA) + self.b_AA
		AA = self.activation(AA)
		AA = activation(AA)
		PA = tf.matmul(pair_features, self.W_PA) + self.b_PA
		PA = self.activation(PA)
		PA = activation(PA)
		PA = tf.segment_sum(PA, pair_split)

		A = tf.matmul(tf.concat([AA, PA], 1), self.W_A) + self.b_A
		A = self.activation(A)
		A = activation(A)

		if self.update_pair:
		AP_ij = tf.matmul(
		tf.reshape(
		tf.gather(atom_features, atom_to_pair),
		[-1, 2 * self.n_atom_input_feat]), self.W_AP) + self.b_AP
		AP_ij = self.activation(AP_ij)
		AP_ij = activation(AP_ij)
		AP_ji = tf.matmul(
		tf.reshape(
		tf.gather(atom_features, tf.reverse(atom_to_pair, [1])),
		[-1, 2 * self.n_atom_input_feat]), self.W_AP) + self.b_AP
		AP_ji = self.activation(AP_ji)
		AP_ji = activation(AP_ji)

		PP = tf.matmul(pair_features, self.W_PP) + self.b_PP
		PP = self.activation(PP)
		PP = activation(PP)
		P = tf.matmul(tf.concat([AP_ij + AP_ji, PP], 1), self.W_P) + self.b_P
		P = self.activation(P)
		P = activation(P)
		else:
		P = pair_features

		@@ -2076,8 +2082,8 @@ class WeaveGather(tf.keras.layers.Layer):
		self.n_input = n_input
		self.batch_size = batch_size
		self.gaussian_expand = gaussian_expand
		self.init = initializations.get(init) # Set weight initialization
		self.activation = activations.get(activation) # Get activations
		self.init = init # Set weight initialization
		self.activation = activation # Get activations
		self.epsilon = epsilon
		self.momentum = momentum

		@@ -2094,13 +2100,15 @@ class WeaveGather(tf.keras.layers.Layer):

		def build(self, input_shape):
		if self.gaussian_expand:
		self.W = self.init([self.n_input * 11, self.n_input])
		init = initializations.get(self.init)
		self.W = init([self.n_input * 11, self.n_input])
		self.b = model_ops.zeros(shape=[self.n_input])
		self.built = True

		def call(self, inputs):
		outputs = inputs[0]
		atom_split = inputs[1]
		activation = activations.get(self.activation)

		if self.gaussian_expand:
		outputs = self.gaussian_histogram(outputs)
		@@ -2109,7 +2117,7 @@ class WeaveGather(tf.keras.layers.Layer):

		if self.gaussian_expand:
		output_molecules = tf.matmul(output_molecules, self.W) + self.b
		output_molecules = self.activation(output_molecules)
		output_molecules = activation(output_molecules)

		return output_molecules

		@@ -2150,7 +2158,7 @@ class DTNNEmbedding(tf.keras.layers.Layer):
		super(DTNNEmbedding, self).__init__(**kwargs)
		self.n_embedding = n_embedding
		self.periodic_table_length = periodic_table_length
		self.init = initializations.get(init) # Set weight initialization
		self.init = init # Set weight initialization

		def get_config(self):
		config = super(DTNNEmbedding, self).get_config()
		@@ -2160,8 +2168,8 @@ class DTNNEmbedding(tf.keras.layers.Layer):
		return config

		def build(self, input_shape):
		self.embedding_list = self.init(
		[self.periodic_table_length, self.n_embedding])
		init = initializations.get(self.init)
		self.embedding_list = init([self.periodic_table_length, self.n_embedding])
		self.built = True

		def call(self, inputs):
		@@ -2199,8 +2207,8 @@ class DTNNStep(tf.keras.layers.Layer):
		self.n_embedding = n_embedding
		self.n_distance = n_distance
		self.n_hidden = n_hidden
		self.init = initializations.get(init) # Set weight initialization
		self.activation = activations.get(activation) # Get activations
		self.init = init # Set weight initialization
		self.activation = activation # Get activations

		def get_config(self):
		config = super(DTNNStep, self).get_config()
		@@ -2212,9 +2220,10 @@ class DTNNStep(tf.keras.layers.Layer):
		return config

		def build(self, input_shape):
		self.W_cf = self.init([self.n_embedding, self.n_hidden])
		self.W_df = self.init([self.n_distance, self.n_hidden])
		self.W_fc = self.init([self.n_hidden, self.n_embedding])
		init = initializations.get(self.init)
		self.W_cf = init([self.n_embedding, self.n_hidden])
		self.W_df = init([self.n_distance, self.n_hidden])
		self.W_fc = init([self.n_hidden, self.n_embedding])
		self.b_cf = model_ops.zeros(shape=[
		self.n_hidden,
		])
		@@ -2231,6 +2240,7 @@ class DTNNStep(tf.keras.layers.Layer):
		distance = inputs[1]
		distance_membership_i = inputs[2]
		distance_membership_j = inputs[3]
		activation = activations.get(self.activation)
		distance_hidden = tf.matmul(distance, self.W_df) + self.b_df
		atom_features_hidden = tf.matmul(atom_features, self.W_cf) + self.b_cf
		outputs = tf.multiply(
		@@ -2239,11 +2249,11 @@ class DTNNStep(tf.keras.layers.Layer):
		# for atom i in a molecule m, this step multiplies together distance info of atom pair(i,j)
		# and embeddings of atom j(both gone through a hidden layer)
		outputs = tf.matmul(outputs, self.W_fc)
		outputs = self.activation(outputs)
		outputs = activation(outputs)

		output_ii = tf.multiply(self.b_df, atom_features_hidden)
		output_ii = tf.matmul(output_ii, self.W_fc)
		output_ii = self.activation(output_ii)
		output_ii = activation(output_ii)

		# for atom i, sum the influence from all other atom j in the molecule
		return tf.segment_sum(outputs,
		@@ -2279,8 +2289,8 @@ class DTNNGather(tf.keras.layers.Layer):
		self.n_outputs = n_outputs
		self.layer_sizes = layer_sizes
		self.output_activation = output_activation
		self.init = initializations.get(init) # Set weight initialization
		self.activation = activations.get(activation) # Get activations
		self.init = init # Set weight initialization
		self.activation = activation # Get activations

		def get_config(self):
		config = super(DTNNGather, self).get_config()
		@@ -2295,14 +2305,15 @@ class DTNNGather(tf.keras.layers.Layer):
		def build(self, input_shape):
		self.W_list = []
		self.b_list = []
		init = initializations.get(self.init)
		prev_layer_size = self.n_embedding
		for i, layer_size in enumerate(self.layer_sizes):
		self.W_list.append(self.init([prev_layer_size, layer_size]))
		self.W_list.append(init([prev_layer_size, layer_size]))
		self.b_list.append(model_ops.zeros(shape=[
		layer_size,
		]))
		prev_layer_size = layer_size
		self.W_list.append(self.init([prev_layer_size, self.n_outputs]))
		self.W_list.append(init([prev_layer_size, self.n_outputs]))
		self.b_list.append(model_ops.zeros(shape=[
		self.n_outputs,
		]))
		@@ -2314,21 +2325,24 @@ class DTNNGather(tf.keras.layers.Layer):
		"""
		output = inputs[0]
		atom_membership = inputs[1]
		activation = activations.get(self.activation)

		for i, W in enumerate(self.W_list[:-1]):
		output = tf.matmul(output, W) + self.b_list[i]
		output = self.activation(output)
		output = activation(output)
		output = tf.matmul(output, self.W_list[-1]) + self.b_list[-1]
		if self.output_activation:
		output = self.activation(output)
		output = activation(output)
		return tf.segment_sum(output, atom_membership)


		def _DAGgraph_step(batch_inputs, W_list, b_list, activation, dropout,
		dropout_switch):
		outputs = batch_inputs
		activation_fn = activations.get(activation)
		for idw, W in enumerate(W_list):
		outputs = tf.nn.xw_plus_b(outputs, W, b_list[idw])
		outputs = activation(outputs)
		outputs = activation_fn(outputs)
		if not dropout is None:
		outputs = tf.nn.dropout(outputs, rate=dropout * dropout_switch)
		return outputs
		@@ -2369,8 +2383,8 @@ class DAGLayer(tf.keras.layers.Layer):
		number of molecules in a batch.
		"""
		super(DAGLayer, self).__init__(**kwargs)
		self.init = initializations.get(init) # Set weight initialization
		self.activation = activations.get(activation) # Get activations
		self.init = init # Set weight initialization
		self.activation = activation # Get activations
		self.layer_sizes = layer_sizes
		self.dropout = dropout
		self.max_atoms = max_atoms
		@@ -2397,14 +2411,15 @@ class DAGLayer(tf.keras.layers.Layer):
		""""Construct internal trainable weights."""
		self.W_list = []
		self.b_list = []
		init = initializations.get(self.init)
		prev_layer_size = self.n_inputs
		for layer_size in self.layer_sizes:
		self.W_list.append(self.init([prev_layer_size, layer_size]))
		self.W_list.append(init([prev_layer_size, layer_size]))
		self.b_list.append(model_ops.zeros(shape=[
		layer_size,
		]))
		prev_layer_size = layer_size
		self.W_list.append(self.init([prev_layer_size, self.n_outputs]))
		self.W_list.append(init([prev_layer_size, self.n_outputs]))
		self.b_list.append(model_ops.zeros(shape=[
		self.n_outputs,
		]))
		@@ -2431,6 +2446,7 @@ class DAGLayer(tf.keras.layers.Layer):
		# another row of zeros is generated for padded dummy atoms
		graph_features = tf.Variable(graph_features_initial, trainable=False)

		activation = activations.get(self.activation)
		for count in range(self.max_atoms):
		# `count`-th step
		# extracting atom features of target atoms: (batch_sizemax_atoms) n_atom_features
		@@ -2462,8 +2478,7 @@ class DAGLayer(tf.keras.layers.Layer):
		# of shape: (batch_sizemax_atoms) n_graph_features
		# representing the graph features of target atoms in each graph
		batch_outputs = _DAGgraph_step(batch_inputs, self.W_list, self.b_list,
		self.activation, self.dropout,
		dropout_switch)
		activation, self.dropout, dropout_switch)

		# index for targe atoms
		target_index = tf.stack([tf.range(n_atoms), parents[:, count, 0]], axis=1)
		@@ -2506,8 +2521,8 @@ class DAGGather(tf.keras.layers.Layer):
		Dropout probability in the hidden layer(s).
		"""
		super(DAGGather, self).__init__(**kwargs)
		self.init = initializations.get(init) # Set weight initialization
		self.activation = activations.get(activation) # Get activations
		self.init = init # Set weight initialization
		self.activation = activation # Get activations
		self.layer_sizes = layer_sizes
		self.dropout = dropout
		self.max_atoms = max_atoms
		@@ -2528,14 +2543,15 @@ class DAGGather(tf.keras.layers.Layer):
		def build(self, input_shape):
		self.W_list = []
		self.b_list = []
		init = initializations.get(self.init)
		prev_layer_size = self.n_graph_feat
		for layer_size in self.layer_sizes:
		self.W_list.append(self.init([prev_layer_size, layer_size]))
		self.W_list.append(init([prev_layer_size, layer_size]))
		self.b_list.append(model_ops.zeros(shape=[
		layer_size,
		]))
		prev_layer_size = layer_size
		self.W_list.append(self.init([prev_layer_size, self.n_outputs]))
		self.W_list.append(init([prev_layer_size, self.n_outputs]))
		self.b_list.append(model_ops.zeros(shape=[
		self.n_outputs,
		]))
		@@ -2629,7 +2645,7 @@ class EdgeNetwork(tf.keras.layers.Layer):
		super(EdgeNetwork, self).__init__(**kwargs)
		self.n_pair_features = n_pair_features
		self.n_hidden = n_hidden
		self.init = initializations.get(init)
		self.init = init

		def get_config(self):
		config = super(EdgeNetwork, self).get_config()
		@@ -2641,7 +2657,8 @@ class EdgeNetwork(tf.keras.layers.Layer):
		def build(self, input_shape):
		n_pair_features = self.n_pair_features
		n_hidden = self.n_hidden
		self.W = self.init([n_pair_features, n_hidden * n_hidden])
		init = initializations.get(self.init)
		self.W = init([n_pair_features, n_hidden * n_hidden])
		self.b = model_ops.zeros(shape=(n_hidden * n_hidden,))
		self.built = True

		@@ -2660,7 +2677,7 @@ class GatedRecurrentUnit(tf.keras.layers.Layer):
		def __init__(self, n_hidden=100, init='glorot_uniform', **kwargs):
		super(GatedRecurrentUnit, self).__init__(**kwargs)
		self.n_hidden = n_hidden
		self.init = initializations.get(init)
		self.init = init

		def get_config(self):
		config = super(GatedRecurrentUnit, self).get_config()
		@@ -2670,12 +2687,13 @@ class GatedRecurrentUnit(tf.keras.layers.Layer):

		def build(self, input_shape):
		n_hidden = self.n_hidden
		self.Wz = self.init([n_hidden, n_hidden])
		self.Wr = self.init([n_hidden, n_hidden])
		self.Wh = self.init([n_hidden, n_hidden])
		self.Uz = self.init([n_hidden, n_hidden])
		self.Ur = self.init([n_hidden, n_hidden])
		self.Uh = self.init([n_hidden, n_hidden])
		init = initializations.get(self.init)
		self.Wz = init([n_hidden, n_hidden])
		self.Wr = init([n_hidden, n_hidden])
		self.Wh = init([n_hidden, n_hidden])
		self.Uz = init([n_hidden, n_hidden])
		self.Ur = init([n_hidden, n_hidden])
		self.Uh = init([n_hidden, n_hidden])
		self.bz = model_ops.zeros(shape=(n_hidden,))
		self.br = model_ops.zeros(shape=(n_hidden,))
		self.bh = model_ops.zeros(shape=(n_hidden,))
		@@ -2711,7 +2729,7 @@ class SetGather(tf.keras.layers.Layer):
		self.M = M
		self.batch_size = batch_size
		self.n_hidden = n_hidden
		self.init = initializations.get(init)
		self.init = init

		def get_config(self):
		config = super(SetGather, self).get_config()
		@@ -2722,7 +2740,8 @@ class SetGather(tf.keras.layers.Layer):
		return config

		def build(self, input_shape):
		self.U = self.init((2 * self.n_hidden, 4 * self.n_hidden))
		init = initializations.get(self.init)
		self.U = init((2 * self.n_hidden, 4 * self.n_hidden))
		self.b = tf.Variable(
		np.concatenate((np.zeros(self.n_hidden), np.ones(self.n_hidden),
		np.zeros(self.n_hidden), np.zeros(self.n_hidden))),

deepchem/models/tensorgraph/initializations.py

+2 −2

Original line number	Diff line number	Diff line
		@@ -106,11 +106,11 @@ def identity(shape, scale=1, name=None):
		scale * np.identity(shape[0]), dtype=tf.float32, name=name)


		def zero(shape, name=None):
		def zeros(shape, name=None):
		return tf.Variable(tf.zeros(shape), dtype=tf.float32, name=name)


		def one(shape, name=None):
		def ones(shape, name=None):
		return tf.Variable(tf.ones(shape), dtype=tf.float32, name=name)

deepchem/models/tensorgraph/tests/test_layers.py

+4 −4

Original line number	Diff line number	Diff line
		@@ -981,7 +981,7 @@ class TestLayers(test_util.TensorFlowTestCase):
		def test_gated_recurrent_unit(self):
		"""Test that Gated Recurrent Unit can be invoked."""
		n_hidden = 2
		init_method = 'one'
		init_method = 'ones'

		messages_np = np.array([[1, -1]])
		inputs_np = np.array([[1, -1]])
		@@ -1002,7 +1002,7 @@ class TestLayers(test_util.TensorFlowTestCase):
		"""Test that Edge Network can be invoked."""
		n_pair_features = 2
		n_hidden = 2
		init_method = 'one'
		init_method = 'ones'

		pair_features_np = np.array([[0.25, 0.25], [0.25, 0.25], [0.25, 0.25]])
		atom_features_np = np.array([[1, 1], [2, 2], [3, 3]])
		@@ -1030,7 +1030,7 @@ class TestLayers(test_util.TensorFlowTestCase):
		n_outputs = 2
		layer_sizes = [2]
		output_activation = False
		init_method = 'one'
		init_method = 'ones'
		activation = 'sigmoid'

		inputs_np = np.array([[1, -1], [1, -1], [1, -1]])
		@@ -1060,7 +1060,7 @@ class TestLayers(test_util.TensorFlowTestCase):
		n_graph_feat = 2
		n_outputs = 2
		layer_sizes = [2]
		init_method = 'one'
		init_method = 'ones'
		activation = 'sigmoid'

		def sigmoid(x):

deepchem/models/tests/test_layers.py→deepchem/models/tests/test_layers_from_config.py

+0 −0

File moved.

View file

Admin message