class_docstr: This is an implementation of Automatic Chemical Design Using a Continuous Representation of Molecules
  http://pubs.acs.org/doi/full/10.1021/acscentsci.7b00572
  
  Abstract
  --------
  We report a method to convert discrete representations of molecules to and
  from a multidimensional continuous representation. This model allows us to
  generate new molecules for efficient exploration and optimization through
  open-ended spaces of chemical compounds. A deep neural network was trained on
  hundreds of thousands of existing chemical structures to construct three
  coupled functions: an encoder, a decoder, and a predictor. The encoder
  converts the discrete representation of a molecule into a real-valued
  continuous vector, and the decoder converts these continuous vectors back to
  discrete molecular representations. The predictor estimates chemical
  properties from the latent continuous vector representation of the molecule.
  Continuous representations of molecules allow us to automatically generate
  novel chemical structures by performing simple operations in the latent space,
  such as decoding random vectors, perturbing known chemical structures, or
  interpolating between molecules. Continuous representations also allow the use
  of powerful gradient-based optimization to efficiently guide the search for
  optimized functional compounds. We demonstrate our method in the domain of
  drug-like molecules and also in a set of molecules with fewer that nine heavy
  atoms.
  
  Notes
  -------
  This is currently an imperfect reproduction of the paper.  One difference is
  that teacher forcing in the decoder is not implemented.  The paper also
  discusses co-learning molecular properties at the same time as training the
  encoder/decoder.  This is not done here.  The hyperparameters chosen are from
  ZINC dataset.
  
  This network also currently suffers from exploding gradients.  Care has to be taken when training.
  
  NOTE(LESWING): Will need to play around with annealing schedule to not have exploding gradients
  TODO(LESWING): Teacher Forcing
  TODO(LESWING): Sigmoid variational loss annealing schedule
  The output GRU layer had one
  additional input, corresponding to the character sampled from the softmax output of the
  previous time step and was trained using teacher forcing. 48 This increased the accuracy
  of generated SMILES strings, which resulted in higher fractions of valid SMILES strings
  for latent points outside the training data, but also made training more difficult, since the
  decoder showed a tendency to ignore the (variational) encoding and rely solely on the input
  sequence. The variational loss was annealed according to sigmoid schedule after 29 epochs,
  running for a total 120 epochs
  
  I also added a BatchNorm before the mean and std embedding layers.  This has empiracally
  made training more stable, and is discussed in Ladder Variational Autoencoders.
  https://arxiv.org/pdf/1602.02282.pdf
  Maybe if Teacher Forcing and Sigmoid variational loss annealing schedule are used the
  BatchNorm will no longer be neccessary.
code: def _create_input_array(self, sequences):
      return self._create_output_array(sequences)
  
imports: from deepchem.models import KerasModel, layers
  from heapq import heappush, heappushpop
  import numpy
  import tensorflow
  from tensorflow.keras.layers import Input, Layer, Dense, Dropout, GRU, Lambda, Conv1D, Flatten, BatchNormalization
label_desc: Use image node_id 5 for calling the AspuruGuzikAutoEncoder obj's underlying member method code with example usage: obj._create_input_array(sequences) and returns: self