Now initializes

except:

  from collections import Sequence as SequenceCollection

class RNN(KerasModel):

  """A recurrent neural network for either regression or classification.

               n_features,

               n_dims,

               layer_input_dims=(256, 128, 64),

               bidirectional=True,

               bidirectional=False,

               weight_init_stddevs=0.02,

               bias_init_consts=1.0,

               weight_decay_penalty=0.0,

    all the keyword arguments from TensorGraph.

    """

    if dims not in (1, 2, 3):

    if n_dims not in (1, 2, 3):

      raise ValueError("n_dims must be 1, 2, or 3 at this time.")

    if mode not in ['classification', 'regression']:

      raise ValueError("mode must be either 'classification' or 'regression'")

    self.n_tasks = n_tasks

    self.n_features = n_features

    self.dims = n_dims

    self.n_classes = n_classes

    self.uncertainty = uncertainty

    n_layers = len(layer_input_dims)

    if not isinstance(kernel_size, list):

      kernel_size = [kernel_size] * n_layers

    if not isinstance(weight_init_stddevs, SequenceCollection):

      weight_init_stddevs = [weight_init_stddevs] * (n_layers + 1)

    if not isinstance(bias_init_consts, SequenceCollection):

    # Add the input features.

    features = Input(shape=(None,) * dims + (n_features,))

    features = Input(shape=(None,) * n_dims + (n_features,))

    dropout_switch = Input(shape=tuple())

    prev_layer = features

    next_activation = None

    prev_layer = layers.Embedding(input_dim=encoder_vocab, output_dim=layer_input_dims[0])(

        features

    )

    # Pick type of RNN

    if layerType == 'LSTM':

      RecurrentLayer = layers.LSTM

    elif layerType == 'GRU':

    else:

      raise ValueError('layerType must be "LSTM," "GRU," or "SimpleRNN."')

    # Bidirectional

    if bidirectional == True:

      RecurrentLayer = layers.Bidirectional(RecurrentLayer)

      RecurrentLayer = layers.Bidirectional(RecurrentLayer(10)) # TODO remove magic number

    for dim, size, weight_stddev, bias_const, dropout, activation_fn in zip( 

        layer_input_dims, kernel_size, weight_init_stddevs, bias_init_consts, 

    for dim, weight_stddev, bias_const, dropout, activation_fn in zip( 

        layer_input_dims, weight_init_stddevs, bias_init_consts, 

        dropouts, activation_fns):

      layer = prev_layer

      if next_activation is not None:

        layer = Activation(next_activation)(layer)

      output, state_h, state_c = recurrentLayer(

      output, state_h, state_c = RecurrentLayer(

                                     dim,

                                     return_state=True,

                                     return_sequences=True,

                                         stddev=weight_stddev),

                                     bias_initializer=tf.constant_initializer(

                                         value=bias_const),

                                     kernel_regularizer=regularizer)(layer)

                                 )

                                     kernel_regularizer=regularizer)(layer) # Var layer is problematic.

      state = [state_h, state_c]

      if dropout > 0.0:

        layer = SwitchedDropout(rate=dropout)([layer, dropout_switch])

  n_tasks = len(tasks)

  model = RNN(

      mode='regression',

      n_dims=3,

      n_features=30,

      n_dims=1,

      n_features=3,

      n_tasks=len(tasks),

      batch_size=10,

      learning_rate=0.003)

  # overfit test

  print("dataset", dataset);

  model.fit(dataset, nb_epoch=300)

  scores = model.evaluate(dataset, [metric], transformers)

  assert scores['mean_absolute_error'] < 0.5

  # test on a small MoleculeNet dataset

  from deepchem.molnet import load_delaney

  tasks, all_dataset, transformers = load_delaney(featurizer=featurizer)

  train_set, _, _ = all_dataset

  model = dc.models.RNN(n_tasks=len(tasks))

  model.fit(train_set, nb_epoch=1)

"""

@unittest.skipIf(not has_dependencies,

                 'Please make sure tensorflow and collections are installed.')