Merge pull request #1007 from lilleswing/submodule-tg-disk

from deepchem.models import GraphConvTensorGraph

from deepchem.models import TensorGraph

from deepchem.molnet.load_function.delaney_datasets import load_delaney

from deepchem.models.tensorgraph.layers import ReduceSum, L2Loss

class TestGraphModels(unittest.TestCase):

        dataset, transformers, untransform=True, n_passes=24)

    assert mu.shape == (len(dataset), len(tasks))

    assert sigma.shape == (len(dataset), len(tasks))

  def test_change_loss_function(self):

    tasks, dataset, transformers, metric = self.get_dataset(

        'regression', 'GraphConv', num_tasks=1)

    batch_size = 50

    model = GraphConvTensorGraph(

        len(tasks), batch_size=batch_size, mode='regression')

    model.fit(dataset, nb_epoch=1)

    model.save()

    model2 = TensorGraph.load_from_dir(model.model_dir, restore=False)

    dummy_label = model2.labels[-1]

    dummy_ouput = model2.outputs[-1]

    loss = ReduceSum(L2Loss(in_layers=[dummy_label, dummy_ouput]))

    module = model2.create_submodel(loss=loss)

    model2.restore()

    model2.fit(dataset, nb_epoch=1, submodel=module)

import collections

import os

import pickle

import threading

import time

import collections

import numpy as np

import os

import six

import tensorflow as tf

from tensorflow.python.framework.errors_impl import OutOfRangeError

from tensorflow.python.pywrap_tensorflow_internal import NewCheckpointReader

from deepchem.data import NumpyDataset

from deepchem.metrics import to_one_hot, from_one_hot

from deepchem.models.models import Model

from deepchem.models.tensorgraph.layers import InputFifoQueue, Label, Feature, Weights, Constant

from deepchem.models.tensorgraph.optimizers import Adam

from deepchem.trans import undo_transforms

from deepchem.utils.evaluate import GeneratorEvaluator

from deepchem.feat.graph_features import ConvMolFeaturizer

from deepchem.data.data_loader import featurize_smiles_np

class TensorGraph(Model):

    if checkpoint is None:

      raise ValueError('No checkpoint found')

    with self._get_tf("Graph").as_default():

      saver = tf.train.Saver()

      reader = NewCheckpointReader(checkpoint)

      var_names = set([x for x in reader.get_variable_to_shape_map()])

      var_map = {

          x.op.name: x

          for x in tf.global_variables() if x.op.name in var_names

      }

      saver = tf.train.Saver(var_list=var_map)

      saver.restore(self.session, checkpoint)

  def get_num_tasks(self):

    return self.layers[pre_q_name]

  @staticmethod

  def load_from_dir(model_dir):

  def load_from_dir(model_dir, restore=True):

    pickle_name = os.path.join(model_dir, "model.pickle")

    with open(pickle_name, 'rb') as fout:

      tensorgraph = pickle.load(fout)

      tensorgraph.built = False

      tensorgraph.model_dir = model_dir

      if restore:

        try:

          tensorgraph.restore()

        except ValueError: