Merge pull request #324 from miaecle/graphconvreg

|Dataset    |Model               |Splitting   |Train score/R2|Valid score/R2|

|-----------|--------------------|------------|--------------|--------------|

|delaney    |MT-NN regression    |Index       |0.773         |0.574         |

|           |graphconv regression|Index       |0.964         |0.829         |

|           |MT-NN regression    |Random      |0.769         |0.591         |

|           |graphconv regression|Random      |0.959         |0.821         |

|           |MT-NN regression    |Scaffold    |0.782         |0.426         |

|           |graphconv regression|Scaffold    |0.976         |0.581         |

|kaggle     |MT-NN regression    |User-defined|0.748         |0.452         |

* General features

from deepchem.models.models import Model

from deepchem.models.sklearn_models import SklearnModel

from deepchem.models.tf_keras_models.multitask_classifier import MultitaskGraphClassifier

from deepchem.models.tf_keras_models.multitask_regressor import MultitaskGraphRegressor

from deepchem.models.tf_keras_models.support_classifier import SupportGraphClassifier

from deepchem.models.multitask import SingletaskToMultitask

Compound ID,outcome,smiles

Amigdalin,2.826,OCC3OC(OCC2OC(OC(C#N)c1ccccc1)C(O)C(O)C2O)C(O)C(O)C3O 

Fenfuram,0.915,Cc1occc1C(=O)Nc2ccccc2

citral,1.221,CC(C)=CCCC(C)=CC(=O)

Picene,-2.818,c1ccc2c(c1)ccc3c2ccc4c5ccccc5ccc43

Thiophene,1.568,c1ccsc1

benzothiazole,1.067,c2ccc1scnc1c2 

"2,2,4,6,6'-PCB",-2.745,Clc1cc(Cl)c(c(Cl)c1)c2c(Cl)cccc2Cl

Estradiol,-0.338,CC12CCC3C(CCc4cc(O)ccc34)C2CCC1O

Dieldrin,-0.733,ClC4=C(Cl)C5(Cl)C3C1CC(C2OC12)C3C4(Cl)C5(Cl)Cl

Rotenone,-1.446,COc5cc4OCC3Oc2c1CC(Oc1ccc2C(=O)C3c4cc5OC)C(C)=C 

      assert scores[classification_metric.name] > .75

  def test_graph_conv_singletask_regression_overfit(self):

    """Test graph-conv multitask overfits tiny data."""

    np.random.seed(123)

    tf.set_random_seed(123)

    g = tf.Graph()

    sess = tf.Session(graph=g)

    K.set_session(sess)

    with g.as_default():

      n_tasks = 1

      n_samples = 10

      n_features = 3

      n_classes = 2

      # Load mini log-solubility dataset.

      featurizer = dc.feat.ConvMolFeaturizer()

      tasks = ["outcome"]

      input_file = os.path.join(self.current_dir, "example_regression.csv")

      loader = dc.data.CSVLoader(

          tasks=tasks, smiles_field="smiles", featurizer=featurizer)

      dataset = loader.featurize(input_file)

      classification_metric = dc.metrics.Metric(

          dc.metrics.mean_squared_error,

          task_averager=np.mean)

      n_feat = 71

      batch_size = 10

      graph_model = dc.nn.SequentialGraph(n_feat)

      graph_model.add(dc.nn.GraphConv(64, activation='relu'))

      graph_model.add(dc.nn.BatchNormalization(epsilon=1e-5, mode=1))

      graph_model.add(dc.nn.GraphPool())

      # Gather Projection

      graph_model.add(dc.nn.Dense(128, activation='relu'))

      graph_model.add(dc.nn.BatchNormalization(epsilon=1e-5, mode=1))

      graph_model.add(dc.nn.GraphGather(batch_size, activation="tanh"))

      with self.test_session() as sess:

        model = dc.models.MultitaskGraphRegressor(

          sess, graph_model, n_tasks, batch_size=batch_size,

          learning_rate=1e-2, learning_rate_decay_time=1000,

          optimizer_type="adam", beta1=.9, beta2=.999)

        # Fit trained model

        model.fit(dataset, nb_epoch=40)

        model.save()

        # Eval model on train

        scores = model.evaluate(dataset, [classification_metric])

      assert scores[classification_metric.name] < .2

  def test_siamese_singletask_classification_overfit(self):

    """Test siamese singletask model overfits tiny data."""

    np.random.seed(123)

    def loss_fn(x, t):

      diff = tf.sub(x, t)

      return tf.reduce_sum(tf.square(diff), 0)

  elif final_loss=='weighted_L2':

    def loss_fn(x, t, w):

      diff = tf.sub(x, t)

      weighted_diff = tf.mul(diff,w)

      return tf.reduce_sum(tf.square(weighted_diff), 0)

  elif final_loss=='L1':

    def loss_fn(x, t):

      diff = tf.sub(x, t)