Merge pull request #1264 from peastman/submodel

    self.rnn_zero_states = []

    self.session = None

    out_tensors = []

    submodel_ops = []

    if self.built:

      must_restore = True

      for layer in self.topsort():

        out_tensors.append(layer.none_tensors())

      for submodel in self.submodels:

        submodel_ops.append(submodel._train_op)

        submodel._train_op = None

      training_placeholder = self._training_placeholder

      self._training_placeholder = None

      self.built = False

    if must_restore:

      for index, layer in enumerate(self.topsort()):

        layer.set_tensors(out_tensors[index])

      for submodel, op in zip(self.submodels, submodel_ops):

        submodel._train_op = op

      self._training_placeholder = training_placeholder

      self.built = True

    self.tensor_objects = tensor_objects

import deepchem as dc

from deepchem.data import NumpyDataset

from deepchem.data.datasets import Databag

from deepchem.models.tensorgraph.layers import Dense, SoftMaxCrossEntropy, ReduceMean, SoftMax, Constant, Variable

from deepchem.models.tensorgraph.layers import Dense, SoftMaxCrossEntropy, ReduceMean, ReduceSum, SoftMax, Constant, Variable

from deepchem.models.tensorgraph.layers import Feature, Label

from deepchem.models.tensorgraph.layers import ReduceSquareDifference, Add, GRU

from deepchem.models.tensorgraph.tensor_graph import TensorGraph

from deepchem.models.tensorgraph.optimizers import GradientDescent, ExponentialDecay

from deepchem.models.tensorgraph.optimizers import GradientDescent, ExponentialDecay, Adam

import tensorflow.contrib.eager as tfe

from tensorflow.python.eager import context

    tg = dc.models.TensorGraph(learning_rate=0.01)

    tg.add_output(output)

    tg.set_loss(loss)

    submodel_loss = ReduceSum(in_layers=smce)

    submodel_opt = Adam(learning_rate=0.002)

    submodel = tg.create_submodel(

        layers=[dense], loss=submodel_loss, optimizer=submodel_opt)

    tg.fit(dataset, nb_epoch=1)

    prediction = np.squeeze(tg.predict_on_batch(X))

    tg.save()