Converts a value to a one-hot vector based on options in lst

Add a list of new graphs Parameters ---------- gs : list of tg.data.Data Molecular graphs

Converts an RDKit molecule to an attributed undirected graph

Produce N identical layers.

Maps inputs not in the allowable set to the last element.

Takes a step forward according to the action. Args: action: Chem.RWMol. The action is actually the target of the modification. Returns

Gets the valid actions for the state. In this design, we do not further modify a aromatic ring. For example, we do not change a benzene to a

Print string if verbose.

Maps inputs to one hot vectors.

Sets the termination criterion for molecule Generation. A child class can define this function to terminate the MDP before max_steps is reach

Generate feature vector for each bond: [bond type, if conjugated, if in ring, (chirality)] Parameters ---------- bond : r

Get length of bond features

Resets the MDP to its initial state.

Converts an RDKit molecule to a graph Parameters ---------- rdmol : rdkit.Chem.rdchem.Mol rdkit molecule class explicit_H : bool, opti

Computes valid actions that involve adding atoms to the graph. Actions: * Add atom (with a bond connecting it to the existing graph) Each ad

Computes valid actions that involve adding bonds to the graph. Actions (where allowed): * None->{single,double,triple} * single->{double,tr

Computes valid actions that involve removing bonds from the graph. Actions (where allowed): * triple->{double,single,None} * double->{singl

Gets the reward for the state. A child class can redefine the reward function if reward other than zero is desired. Returns: Float

Returns a numpy array of attributes for an RDKit atom From ECFP defaults: <IdentifierConfiguration> <Property Name="AtomicNumber" Value="1"

Compute 'Scaled Dot Product Attention

Returns a numpy array of attributes for an RDKit bond From Neural FP defaults: The bond features were a concatenation of whether the bond type wa

Calculate graph distance between atom a1 with the remaining atoms using BFS

Transorms label vector from one-hot encoding. y: np.ndarray A vector of shape [n_samples, num_classes]

Fetch the idx-th graph from cache Parameters ---------- idx : int indice Returns ------- tg.data.Data

Generate adjacency list for molecule

Generate feature vector for each atom: [atom type, degree (number of neighbors), valence, hybridization state, formal charg

Get length of atom features

Calculates the largest ring size in the molecule. Refactored from https://github.com/wengong-jin/icml18-jtnn/blob/master/bo/run_bo.py Args:

Molecular attributes calculated as: [Crippen contribution to logp, Crippen contribution to mr, TPSA contribution, Labute ASA con

Generate feature vector for each atom-atom pair: [bond features, if in the same ring, graph distance/catesian distance] Parameters

Get training op for applying gradients to variables. Subclasses that need to do anything fancy with gradients should override this method.

Computes the set of valid actions for a given state. Args: state: String SMILES; the current state. If None or the empty string, we assum

Helper: Construct a model from hyperparameters.

Uses self to make predictions on provided Dataset object. Returns: y_pred: numpy ndarray of shape (n_samples,)

Dispatcher function for saving. Each subclass is responsible for overriding this method.

Add a batch of graphs into cache Parameters ---------- file_path : str File path of the cached data batch.

Triggered when you call dataset[i]

Initializes the parameters for the MDP. Internal state will be stored as SMILES strings. Args: atom_types: The set of elements the mol

Initializes the class. Args: discount_factor: Float. The discount factor. We only care about the molecule at the end of modificatio

Molecule dataset Parameters ---------- mol_graphs : list of tg.data.Data, optional Molecular graphs data_batch_size : int,

@param data_list: list of MolDatum

Constructs the computational graph. This function constructs the computational graph for the model. It relies subclassed methods (build/co

Take in model size and number of heads.

Constructs the computational graph. This function constructs the computational graph for the model. It relies subclassed methods (build/cost)