remove redundant codes (f8eff069) · Commits · 钟慕尧 / deepchem

deepchem/models/tf_new_models/graph_models.py

+1 −37

Original line number	Diff line number	Diff line
		@@ -11,7 +11,7 @@ __license__ = "MIT"

		import tensorflow as tf
		from deepchem.nn.layers import GraphGather
		from deepchem.models.tf_new_models.graph_topology import GraphTopology, DTNNGraphTopology, DAGGraphTopology, WeaveGraphTopology, AlternateWeaveGraphTopology, BPSymmetryFunctionGraphTopology
		from deepchem.models.tf_new_models.graph_topology import GraphTopology, DTNNGraphTopology, DAGGraphTopology, WeaveGraphTopology, AlternateWeaveGraphTopology


		class SequentialGraph(object):
		@@ -120,42 +120,6 @@ class SequentialDTNNGraph(SequentialGraph):
		self.layers.append(layer)


		class BPSymmetryFunctionGraph(SequentialGraph):

		def __init__(self, max_atoms):
		self.graph = tf.Graph()
		with self.graph.as_default():
		self.graph_topology = BPSymmetryFunctionGraphTopology(max_atoms)
		self.layers = []

		def add(self, layer):
		"""Adds a new layer to model."""
		with self.graph.as_default():
		if type(layer).__name__ in ['DistanceMatrix']:
		self.d = layer(self.graph_topology.inputs)
		elif type(layer).__name__ in ['DistanceCutoff']:
		self.d_cutoff = layer(
		[self.d, self.graph_topology.atom_flag_placeholder])
		elif type(layer).__name__ in ['RadialSymmetry']:
		self.symmetry1 = layer([self.d_cutoff, self.d])
		elif type(layer).__name__ in ['AngularSymmetry']:
		self.symmetry2 = layer(
		[self.d_cutoff, self.d, self.graph_topology.atom_coordinates])
		elif type(layer).__name__ in ['DTNNEmbedding']:
		self.atom_embedding = layer(self.graph_topology.atom_number_placeholder)
		elif type(layer).__name__ in ['BPFeatureMerge']:
		self.output = layer([
		self.atom_embedding, self.symmetry1, self.symmetry2,
		self.graph_topology.atom_flag_placeholder
		])
		elif type(layer).__name__ in ['BPGather']:
		self.output = layer(
		[self.output, self.graph_topology.atom_flag_placeholder])
		else:
		self.output = layer(self.output)
		self.layers.append(layer)


		class SequentialDAGGraph(SequentialGraph):
		"""SequentialGraph for DAG models
		"""

deepchem/models/tf_new_models/graph_topology.py

+0 −39

Original line number	Diff line number	Diff line
		@@ -260,45 +260,6 @@ class DTNNGraphTopology(GraphTopology):
		return dict_DTNN


		class BPSymmetryFunctionGraphTopology(GraphTopology):

		def __init__(self, max_atoms, name='DTNN_topology'):
		self.name = name
		self.max_atoms = max_atoms

		self.atom_number_placeholder = tf.placeholder(
		dtype='int32',
		shape=(None, self.max_atoms),
		name=self.name + '_atom_number')
		self.atom_flag_placeholder = tf.placeholder(
		dtype='float32',
		shape=(None, self.max_atoms, self.max_atoms),
		name=self.name + '_atom_flag')
		self.atom_coordinates = tf.placeholder(
		dtype='float32',
		shape=(None, self.max_atoms, 3),
		name=self.name + '_coordinates')

		# Define the list of tensors to be used as topology
		self.topology = [self.atom_coordinates, self.atom_flag_placeholder]
		self.inputs = [self.atom_number_placeholder]
		self.inputs += self.topology

		def get_atom_number_placeholder(self):
		return self.atom_number_placeholder

		def batch_to_feed_dict(self, batch):

		feed_dict = dict()
		flags = np.sign(np.array(batch[:, :, 0]))
		feed_dict[self.atom_flag_placeholder] = np.stack([flags]self.max_atoms, axis=2)\
		np.stack([flags]*self.max_atoms, axis=1)
		feed_dict[self.atom_number_placeholder] = np.array(
		batch[:, :, 0], dtype=int)
		feed_dict[self.atom_coordinates] = np.array(batch[:, :, 1:], dtype=float)
		return feed_dict


		class DAGGraphTopology(GraphTopology):
		"""GraphTopology for DAG models
		"""

deepchem/models/tf_new_models/multitask_regressor.py

+3 −0

Original line number	Diff line number	Diff line
		@@ -109,6 +109,9 @@ class MultitaskGraphRegressor(Model):
		beta1=self.optimizer_beta1,
		beta2=self.optimizer_beta2,
		epsilon=self.epsilon)
		elif self.optimizer_type == "SGD":
		self.optimizer = tf.train.GradientDescentOptimizer(
		self.learning_rate)
		else:
		raise ValueError("Optimizer type not recognized.")

deepchem/nn/init.py

+0 −9

Original line number	Diff line number	Diff line
		@@ -26,13 +26,6 @@ from deepchem.nn.weave_layers import WeaveConcat
		from deepchem.nn.weave_layers import WeaveGather
		from deepchem.nn.weave_layers import AlternateWeaveGather

		from deepchem.nn.symmetry_functions import DistanceMatrix
		from deepchem.nn.symmetry_functions import DistanceCutoff
		from deepchem.nn.symmetry_functions import RadialSymmetry
		from deepchem.nn.symmetry_functions import AngularSymmetry
		from deepchem.nn.symmetry_functions import BPFeatureMerge
		from deepchem.nn.symmetry_functions import BPGather

		from deepchem.nn.model_ops import weight_decay
		from deepchem.nn.model_ops import optimizer
		from deepchem.nn.model_ops import add_bias
		@@ -46,11 +39,9 @@ from deepchem.models.tf_new_models.graph_topology import DTNNGraphTopology
		from deepchem.models.tf_new_models.graph_topology import DAGGraphTopology
		from deepchem.models.tf_new_models.graph_topology import WeaveGraphTopology
		from deepchem.models.tf_new_models.graph_topology import AlternateWeaveGraphTopology
		from deepchem.models.tf_new_models.graph_topology import BPSymmetryFunctionGraphTopology
		from deepchem.models.tf_new_models.graph_models import SequentialGraph
		from deepchem.models.tf_new_models.graph_models import SequentialDTNNGraph
		from deepchem.models.tf_new_models.graph_models import SequentialDAGGraph
		from deepchem.models.tf_new_models.graph_models import SequentialWeaveGraph
		from deepchem.models.tf_new_models.graph_models import AlternateSequentialWeaveGraph
		from deepchem.models.tf_new_models.graph_models import SequentialSupportGraph
		from deepchem.models.tf_new_models.graph_models import BPSymmetryFunctionGraph

deepchem/nn/symmetry_functions.py

deleted100644 → 0

+0 −172

Original line number	Diff line number	Diff line
		#!/usr/bin/env python2
		# -- coding: utf-8 --
		"""
		Created on Sun Jul 9 22:57:45 2017

		@author: zqwu
		"""

		from __future__ import print_function
		from __future__ import division
		from __future__ import unicode_literals

		import numpy as np
		import tensorflow as tf
		from deepchem.nn import activations
		from deepchem.nn import initializations
		from deepchem.nn import model_ops
		from deepchem.nn.copy import Layer


		class DistanceMatrix(Layer):

		def __init__(self, max_atoms, **kwargs):
		"""
		Parameters
		----------
		max_atoms: int
		Maximum number of atoms in the dataset
		"""
		self.max_atoms = max_atoms
		super(DistanceMatrix, self).__init__(**kwargs)

		def call(self, x, mask=None):
		max_atoms = self.max_atoms
		atom_coordinates = x[1]
		atom_flags = x[2]
		tensor1 = tf.tile(
		tf.expand_dims(atom_coordinates, axis=2), (1, 1, max_atoms, 1))
		tensor2 = tf.tile(
		tf.expand_dims(atom_coordinates, axis=1), (1, max_atoms, 1, 1))
		# Calculate pairwise distance
		d = tf.sqrt(tf.reduce_sum(tf.square(tensor1 - tensor2), axis=3))
		# Masking for valid atom index
		return d * tf.to_float(atom_flags)


		class DistanceCutoff(Layer):

		def __init__(self, max_atoms, cutoff=6 / 0.52917721092, **kwargs):
		"""
		Parameters
		----------
		cutoff: float, optional
		cutoff threshold for distance, in Bohr(0.53Angstrom)
		"""
		self.max_atoms = max_atoms
		self.cutoff = cutoff

		super(DistanceCutoff, self).__init__(**kwargs)

		def build(self):
		self.Rc = tf.Variable(tf.constant(self.cutoff))

		def call(self, x, mask=None):
		""" Generate distance matrix for BPSymmetryFunction with trainable cutoff """

		self.build()
		d = x[0]
		d_flag = x[1]
		# Cutoff with threshold Rc
		d_flag = d_flag * tf.nn.relu(tf.sign(self.Rc - d))
		d = 0.5 * (tf.cos(np.pi * d / self.Rc) + 1)
		out_tensor = d * d_flag
		out_tensor = out_tensor * tf.expand_dims((1 - tf.eye(self.max_atoms)), 0)
		return out_tensor


		class RadialSymmetry(Layer):
		""" Radial Symmetry Function """

		def __init__(self, max_atoms, ita=1., **kwargs):
		self.max_atoms = max_atoms
		self.ita = ita
		super(RadialSymmetry, self).__init__(**kwargs)

		def build(self):
		""" Parameters for the Gaussian """
		self.Rs = tf.Variable(tf.constant(0.))

		def call(self, x, mask=None):
		""" Generate Radial Symmetry Function """
		self.build()
		d_cutoff = x[0]
		d = x[1]
		out_tensor = tf.exp(-self.ita * tf.square(d - self.Rs)) * d_cutoff
		return tf.reduce_sum(out_tensor, axis=2)


		class AngularSymmetry(Layer):
		""" Angular Symmetry Function """

		def __init__(self, max_atoms, lambd=1., ita=1., zeta=0.8, **kwargs):
		self.max_atoms = max_atoms
		self.lambd = lambd
		self.ita = ita
		self.zeta = zeta
		super(AngularSymmetry, self).__init__(**kwargs)

		def call(self, x, mask=None):
		""" Generate Angular Symmetry Function """
		max_atoms = self.max_atoms
		d_cutoff = x[0]
		d = x[1]
		atom_coordinates = x[2]
		vector_distances = tf.tile(tf.expand_dims(atom_coordinates, axis=2), (1,1,max_atoms,1)) - \
		tf.tile(tf.expand_dims(atom_coordinates, axis=1), (1,max_atoms,1,1))
		R_ij = tf.tile(tf.expand_dims(d, axis=3), (1, 1, 1, max_atoms))
		R_ik = tf.tile(tf.expand_dims(d, axis=2), (1, 1, max_atoms, 1))
		R_jk = tf.tile(tf.expand_dims(d, axis=1), (1, max_atoms, 1, 1))
		f_R_ij = tf.tile(tf.expand_dims(d_cutoff, axis=3), (1, 1, 1, max_atoms))
		f_R_ik = tf.tile(tf.expand_dims(d_cutoff, axis=2), (1, 1, max_atoms, 1))
		f_R_jk = tf.tile(tf.expand_dims(d_cutoff, axis=1), (1, max_atoms, 1, 1))

		# Define angle theta = R_ij(Vector) dot R_ik(Vector)/R_ij(distance)/R_ik(distance)
		theta = tf.reduce_sum(tf.tile(tf.expand_dims(vector_distances, axis=3), (1,1,1,max_atoms,1)) * \
		tf.tile(tf.expand_dims(vector_distances, axis=2), (1,1,max_atoms,1,1)), axis=4)

		theta = tf.div(theta, R_ij * R_ik + 1e-5)

		out_tensor = tf.pow(1+self.lambdtf.cos(theta), self.zeta) \
		tf.exp(-self.ita(tf.square(R_ij)+tf.square(R_ik)+tf.square(R_jk))) \
		f_R_ij * f_R_ik * f_R_jk
		return tf.reduce_sum(out_tensor, axis=[2, 3]) * \
		tf.pow(tf.constant(2.), 1-self.zeta)


		class BPFeatureMerge(Layer):

		def __init__(self, max_atoms, **kwargs):
		self.max_atoms = max_atoms
		super(BPFeatureMerge, self).__init__(**kwargs)

		def call(self, x, mask=None):
		""" Merge features together """

		atom_embedding = x[0]
		radial_symmetry = x[1]
		angular_symmetry = x[2]
		atom_flags = x[3]

		out_tensor = tf.concat(
		[
		atom_embedding, tf.expand_dims(radial_symmetry, 2),
		tf.expand_dims(angular_symmetry, 2)
		],
		axis=2)
		out_tensor = out_tensor * atom_flags[:, :, 0:1]
		return out_tensor * atom_flags[:, :, 0:1]


		class BPGather(Layer):

		def __init__(self, max_atoms, **kwargs):
		self.max_atoms = max_atoms
		super(BPGather, self).__init__(**kwargs)

		def call(self, x, mask=None):
		""" Merge features together """
		out_tensor = x[0]
		flags = x[1]
		out_tensor = tf.reduce_sum(out_tensor * flags[:, :, 0:1], axis=1)
		return out_tensor

Admin message