Commit 5cbb4d8b authored by miaecle's avatar miaecle
Browse files

textcnn merge

parent 79df7c75

deepchem/models/tensorgraph/models/graph_models.py

+1 −1
Original line number Diff line number Diff line
@@ -193,7 +193,7 @@ class DTNNTensorGraph(TensorGraph): 
               distance_min=-1,

               distance_max=18,

               output_activation=True,

               mode="classification",

               mode="regression",

               **kwargs):

    """

            Parameters

deepchem/models/tensorgraph/models/text_cnn.py

+3 −1
Original line number Diff line number Diff line
@@ -104,6 +104,8 @@ class TextCNNTensorGraph(TensorGraph): 
      Properties of filters used in the conv net

    num_filters: list of int, optional

      Properties of filters used in the conv net

    dropout: float, optional

      Dropout rate

    mode: str

      Either "classification" or "regression" for type of model.

    """
@@ -211,7 +213,7 @@ class TextCNNTensorGraph(TensorGraph): 
        cost = L2Loss(in_layers=[label, regression])

        costs.append(cost)

    if self.mode == "classification":

      all_cost = Concat(in_layers=costs, axis=1)

      all_cost = Stack(in_layers=costs, axis=1)

    elif self.mode == "regression":

      all_cost = Stack(in_layers=costs, axis=1)

    self.weights = Weights(shape=(None, self.n_tasks))

deepchem/molnet/check_availability.py

+16 −1
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@ CheckFeaturizer = { 
    ('bace_c', 'graphconv'): ['GraphConv', 75],

    ('bace_c', 'dag'): ['GraphConv', 75],

    ('bace_c', 'weave'): ['Weave', 75],

    ('bace_c', 'textcnn'): ['Raw', None],

    ('bbbp', 'logreg'): ['ECFP', 1024],

    ('bbbp', 'tf'): ['ECFP', 1024],

    ('bbbp', 'tf_robust'): ['ECFP', 1024],
@@ -19,6 +20,7 @@ CheckFeaturizer = { 
    ('bbbp', 'graphconv'): ['GraphConv', 75],

    ('bbbp', 'dag'): ['GraphConv', 75],

    ('bbbp', 'weave'): ['Weave', 75],

    ('bbbp', 'textcnn'): ['Raw', None],

    ('clintox', 'logreg'): ['ECFP', 1024],

    ('clintox', 'tf'): ['ECFP', 1024],

    ('clintox', 'tf_robust'): ['ECFP', 1024],
@@ -29,6 +31,7 @@ CheckFeaturizer = { 
    ('clintox', 'graphconv'): ['GraphConv', 75],

    ('clintox', 'dag'): ['GraphConv', 75],

    ('clintox', 'weave'): ['Weave', 75],

    ('clintox', 'textcnn'): ['Raw', None],

    ('hiv', 'logreg'): ['ECFP', 1024],

    ('hiv', 'tf'): ['ECFP', 1024],

    ('hiv', 'tf_robust'): ['ECFP', 1024],
@@ -39,6 +42,7 @@ CheckFeaturizer = { 
    ('hiv', 'graphconv'): ['GraphConv', 75],

    ('hiv', 'dag'): ['GraphConv', 75],

    ('hiv', 'weave'): ['Weave', 75],

    ('hiv', 'textcnn'): ['Raw', None],

    ('muv', 'logreg'): ['ECFP', 1024],

    ('muv', 'tf'): ['ECFP', 1024],

    ('muv', 'tf_robust'): ['ECFP', 1024],
@@ -51,6 +55,7 @@ CheckFeaturizer = { 
    ('muv', 'attn'): ['GraphConv', 75],

    ('muv', 'res'): ['GraphConv', 75],

    ('muv', 'weave'): ['Weave', 75],

    ('muv', 'textcnn'): ['Raw', None],

    ('pcba', 'logreg'): ['ECFP', 1024],

    ('pcba', 'tf'): ['ECFP', 1024],

    ('pcba', 'tf_robust'): ['ECFP', 1024],
@@ -58,6 +63,7 @@ CheckFeaturizer = { 
    ('pcba', 'xgb'): ['ECFP', 1024],

    ('pcba', 'graphconv'): ['GraphConv', 75],

    ('pcba', 'weave'): ['Weave', 75],

    ('pcba', 'textcnn'): ['Raw', None],

    ('pcba_146', 'logreg'): ['ECFP', 1024],

    ('pcba_146', 'tf'): ['ECFP', 1024],

    ('pcba_146', 'tf_robust'): ['ECFP', 1024],
@@ -85,6 +91,7 @@ CheckFeaturizer = { 
    ('sider', 'siamese'): ['GraphConv', 75],

    ('sider', 'attn'): ['GraphConv', 75],

    ('sider', 'res'): ['GraphConv', 75],

    ('sider', 'textcnn'): ['Raw', None],

    ('tox21', 'logreg'): ['ECFP', 1024],

    ('tox21', 'tf'): ['ECFP', 1024],

    ('tox21', 'tf_robust'): ['ECFP', 1024],
@@ -98,6 +105,7 @@ CheckFeaturizer = { 
    ('tox21', 'siamese'): ['GraphConv', 75],

    ('tox21', 'attn'): ['GraphConv', 75],

    ('tox21', 'res'): ['GraphConv', 75],

    ('tox21', 'textcnn'): ['Raw', None],

    ('toxcast', 'logreg'): ['ECFP', 1024],

    ('toxcast', 'tf'): ['ECFP', 1024],

    ('toxcast', 'tf_robust'): ['ECFP', 1024],
@@ -107,6 +115,7 @@ CheckFeaturizer = { 
    ('toxcast', 'xgb'): ['ECFP', 1024],

    ('toxcast', 'graphconv'): ['GraphConv', 75],

    ('toxcast', 'weave'): ['Weave', 75],

    ('toxcast', 'textcnn'): ['Raw', None],

    ('bace_r', 'tf_regression'): ['ECFP', 1024],

    ('bace_r', 'rf_regression'): ['ECFP', 1024],

    ('bace_r', 'krr'): ['ECFP', 1024],
@@ -114,6 +123,7 @@ CheckFeaturizer = { 
    ('bace_r', 'graphconvreg'): ['GraphConv', 75],

    ('bace_r', 'dag_regression'): ['GraphConv', 75],

    ('bace_r', 'weave_regression'): ['Weave', 75],

    ('bace_r', 'textcnn_regression'): ['Raw', None],

    ('chembl', 'tf_regression'): ['ECFP', 1024],

    ('chembl', 'rf_regression'): ['ECFP', 1024],

    ('chembl', 'krr'): ['ECFP', 1024],
@@ -135,6 +145,7 @@ CheckFeaturizer = { 
    ('delaney', 'dag_regression'): ['GraphConv', 75],

    ('delaney', 'weave_regression'): ['Weave', 75],

    ('delaney', 'mpnn'): ['Weave', [75, 14]],

    ('delaney', 'textcnn_regression'): ['Raw', None],

    ('hopv', 'tf_regression'): ['ECFP', 1024],

    ('hopv', 'rf_regression'): ['ECFP', 1024],

    ('hopv', 'krr'): ['ECFP', 1024],
@@ -150,6 +161,7 @@ CheckFeaturizer = { 
    ('lipo', 'dag_regression'): ['GraphConv', 75],

    ('lipo', 'weave_regression'): ['Weave', 75],

    ('lipo', 'mpnn'): ['Weave', [75, 14]],

    ('lipo', 'textcnn_regression'): ['Raw', None],

    ('nci', 'tf_regression'): ['ECFP', 1024],

    ('nci', 'rf_regression'): ['ECFP', 1024],

    ('nci', 'krr'): ['ECFP', 1024],
@@ -171,6 +183,7 @@ CheckFeaturizer = { 
    ('sampl', 'dag_regression'): ['GraphConv', 75],

    ('sampl', 'weave_regression'): ['Weave', 75],

    ('sampl', 'mpnn'): ['Weave', [75, 14]],

    ('sampl', 'textcnn_regression'): ['Raw', None],

    ('kaggle', 'tf_regression'): [None, 14293],

    ('kaggle', 'rf_regression'): [None, 14293],

    ('kaggle', 'krr'): [None, 14293],
@@ -198,6 +211,7 @@ CheckFeaturizer = { 
    ('qm8', 'dtnn'): ['CoulombMatrix', [26, 26]],

    ('qm8', 'ani'): ['BPSymmetryFunction', [26, 4]],

    ('qm8', 'mpnn'): ['MP', [70, 8]],

    ('qm8', 'textcnn_regression'): ['Raw', None],

    ('qm9', 'tf_regression'): ['ECFP', 1024],

    ('qm9', 'rf_regression'): ['ECFP', 1024],

    ('qm9', 'krr'): ['ECFP', 1024],
@@ -206,7 +220,8 @@ CheckFeaturizer = { 
    ('qm9', 'krr_ft'): ['CoulombMatrix', 1024],

    ('qm9', 'dtnn'): ['CoulombMatrix', [29, 29]],

    ('qm9', 'ani'): ['BPSymmetryFunction', [29, 4]],

    ('qm9', 'mpnn'): ['MP', [70, 8]]

    ('qm9', 'mpnn'): ['MP', [70, 8]],

    ('qm9', 'textcnn_regression'): ['Raw', None]

}



CheckSplit = {

deepchem/molnet/preset_hyper_parameters.py

+21 −3
Original line number Diff line number Diff line
@@ -52,7 +52,7 @@ hps['irv'] = { 
}

hps['graphconv'] = {

    'batch_size': 50,

    'nb_epoch': 15,

    'nb_epoch': 50,

    'learning_rate': 0.0005,

    'n_filters': 64,

    'n_fully_connected_nodes': 128,
@@ -68,12 +68,21 @@ hps['dag'] = { 
}

hps['weave'] = {

    'batch_size': 64,

    'nb_epoch': 40,

    'nb_epoch': 50,

    'learning_rate': 0.001,

    'n_graph_feat': 128,

    'n_pair_feat': 14,

    'seed': 123

}

hps['textcnn'] = {

    'batch_size': 64,

    'nb_epoch': 50,

    'learning_rate': 0.001,

    'n_embedding': 75,

    'filter_sizes': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20],

    'num_filters': [100, 200, 200, 200, 200, 100, 100, 100, 100, 100, 160, 160],

    'seed': 123

}

hps['rf'] = {'n_estimators': 500}

hps['kernelsvm'] = {'C': 1.0, 'gamma': 0.05}

hps['xgb'] = {
@@ -122,7 +131,7 @@ hps['krr'] = {'alpha': 1e-3} 
hps['krr_ft'] = {'alpha': 1e-3}

hps['graphconvreg'] = {

    'batch_size': 128,

    'nb_epoch': 20,

    'nb_epoch': 50,

    'learning_rate': 0.0005,

    'n_filters': 128,

    'n_fully_connected_nodes': 256,
@@ -152,6 +161,15 @@ hps['weave_regression'] = { 
    'n_pair_feat': 14,

    'seed': 123

}

hps['textcnn_regression'] = {

    'batch_size': 64,

    'nb_epoch': 50,

    'learning_rate': 0.001,

    'n_embedding': 75,

    'filter_sizes': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20],

    'num_filters': [100, 200, 200, 200, 200, 100, 100, 100, 100, 100, 160, 160],

    'seed': 123

}

hps['ani'] = {

    'batch_size': 32,

    'nb_epoch': 100,

deepchem/molnet/run_benchmark_models.py

+116 −188
Original line number Diff line number Diff line
@@ -49,10 +49,11 @@ def benchmark_classification(train_dataset, 
      number of features, or length of binary fingerprints

  metric: list of dc.metrics.Metric objects

      metrics used for evaluation

  model: string,  optional (default='tf')

      choice of which model to use, should be: rf, tf, tf_robust, logreg,

      irv, graphconv, dag, xgb, weave

  test: boolean

  model: string,  optional

      choice of model

      'rf', 'tf', 'tf_robust', 'logreg', 'irv', 'graphconv', 'dag', 'xgb',

      'weave', 'kernelsvm', 'textcnn'

  test: boolean, optional

      whether to calculate test_set performance

  hyper_parameters: dict, optional (default=None)

      hyper parameters for designated model, None = use preset values
@@ -75,14 +76,13 @@ def benchmark_classification(train_dataset, 


  assert model in [

      'rf', 'tf', 'tf_robust', 'logreg', 'irv', 'graphconv', 'dag', 'xgb',

      'weave', 'kernelsvm'

      'weave', 'kernelsvm', 'textcnn'

  ]

  if hyper_parameters is None:

    hyper_parameters = hps[model]

  model_name = model



  if model_name == 'tf':

    # Loading hyper parameters

    layer_sizes = hyper_parameters['layer_sizes']

    weight_init_stddevs = hyper_parameters['weight_init_stddevs']

    bias_init_consts = hyper_parameters['bias_init_consts']
@@ -108,7 +108,6 @@ def benchmark_classification(train_dataset, 
        seed=seed)



  elif model_name == 'tf_robust':

    # Loading hyper parameters

    layer_sizes = hyper_parameters['layer_sizes']

    weight_init_stddevs = hyper_parameters['weight_init_stddevs']

    bias_init_consts = hyper_parameters['bias_init_consts']
@@ -144,7 +143,6 @@ def benchmark_classification(train_dataset, 
        seed=seed)



  elif model_name == 'logreg':

    # Loading hyper parameters

    penalty = hyper_parameters['penalty']

    penalty_type = hyper_parameters['penalty_type']

    batch_size = hyper_parameters['batch_size']
@@ -162,7 +160,6 @@ def benchmark_classification(train_dataset, 
        seed=seed)



  elif model_name == 'irv':

    # Loading hyper parameters

    penalty = hyper_parameters['penalty']

    penalty_type = hyper_parameters['penalty_type']

    batch_size = hyper_parameters['batch_size']
@@ -188,42 +185,22 @@ def benchmark_classification(train_dataset, 
        seed=seed)



  elif model_name == 'graphconv':

    # Loading hyper parameters

    batch_size = hyper_parameters['batch_size']

    nb_epoch = hyper_parameters['nb_epoch']

    learning_rate = hyper_parameters['learning_rate']

    n_filters = hyper_parameters['n_filters']

    n_fully_connected_nodes = hyper_parameters['n_fully_connected_nodes']



    tf.set_random_seed(seed)

    graph_model = deepchem.nn.SequentialGraph(n_features)

    graph_model.add(

        deepchem.nn.GraphConv(int(n_filters), n_features, activation='relu'))

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

    graph_model.add(deepchem.nn.GraphPool())

    graph_model.add(

        deepchem.nn.GraphConv(

            int(n_filters), int(n_filters), activation='relu'))

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

    graph_model.add(deepchem.nn.GraphPool())

    # Gather Projection

    graph_model.add(

        deepchem.nn.Dense(

            int(n_fully_connected_nodes), int(n_filters), activation='relu'))

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

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

    model = deepchem.models.MultitaskGraphClassifier(

        graph_model,

    model = deepchem.models.GraphConvTensorGraph(

        len(tasks),

        n_features,

        graph_conv_layers=[n_filters]*2,

        dense_layer_size=n_fully_connected_nodes,

        batch_size=batch_size,

        learning_rate=learning_rate,

        optimizer_type="adam",

        beta1=.9,

        beta2=.999)

        random_seed=seed,

        mode='classification')



  elif model_name == 'dag':

    # Loading hyper parameters

    batch_size = hyper_parameters['batch_size']

    nb_epoch = hyper_parameters['nb_epoch']

    learning_rate = hyper_parameters['learning_rate']
@@ -246,26 +223,17 @@ def benchmark_classification(train_dataset, 
      test_dataset.reshard(reshard_size)

      test_dataset = transformer.transform(test_dataset)

    

    tf.set_random_seed(seed)

    graph_model = deepchem.nn.SequentialDAGGraph(

        n_features, max_atoms=max_atoms)

    graph_model.add(

        deepchem.nn.DAGLayer(

            n_graph_feat,

            n_features,

            max_atoms=max_atoms,

            batch_size=batch_size))

    graph_model.add(deepchem.nn.DAGGather(n_graph_feat, max_atoms=max_atoms))



    model = deepchem.models.MultitaskGraphClassifier(

        graph_model,

    model = deepchem.models.DAGTensorGraph(

        len(tasks),

        n_features,

        max_atoms=max_atoms,

        n_atom_feat=n_features,

        n_graph_feat=n_graph_feat,

        n_outputs=30,

        batch_size=batch_size,

        learning_rate=learning_rate,

        optimizer_type="adam",

        beta1=.9,

        beta2=.999)

        random_seed=seed,

        use_queue=False,

        mode='classification')



  elif model_name == 'weave':

    batch_size = hyper_parameters['batch_size']
@@ -274,39 +242,42 @@ def benchmark_classification(train_dataset, 
    n_graph_feat = hyper_parameters['n_graph_feat']

    n_pair_feat = hyper_parameters['n_pair_feat']



    max_atoms_train = max([mol.get_num_atoms() for mol in train_dataset.X])

    max_atoms_valid = max([mol.get_num_atoms() for mol in valid_dataset.X])

    max_atoms_test = max([mol.get_num_atoms() for mol in test_dataset.X])

    max_atoms = max([max_atoms_train, max_atoms_valid, max_atoms_test])



    tf.set_random_seed(seed)

    graph_model = deepchem.nn.AlternateSequentialWeaveGraph(

        batch_size,

        max_atoms=max_atoms,

        n_atom_feat=n_features,

        n_pair_feat=n_pair_feat)

    graph_model.add(deepchem.nn.AlternateWeaveLayer(max_atoms, 75, 14))

    graph_model.add(

        deepchem.nn.AlternateWeaveLayer(max_atoms, 50, 50, update_pair=False))

    graph_model.add(deepchem.nn.Dense(n_graph_feat, 50, activation='tanh'))

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

    graph_model.add(

        deepchem.nn.AlternateWeaveGather(

            batch_size, n_input=n_graph_feat, gaussian_expand=True))



    model = deepchem.models.MultitaskGraphClassifier(

        graph_model,

    model = deepchem.models.WeaveTensorGraph(

        len(tasks),

        n_features,

        n_atom_feat=n_features,

        n_pair_feat=n_pair_feat,

        n_hidden=50,

        n_graph_feat=n_graph_feat,

        batch_size=batch_size,

        learning_rate=learning_rate,

        learning_rate_decay_time=1000,

        optimizer_type="adam",

        beta1=.9,

        beta2=.999)

        use_queue=False,

        random_seed=seed,

        mode='classification')



  elif model_name == 'textcnn':

    batch_size = hyper_parameters['batch_size']

    nb_epoch = hyper_parameters['nb_epoch']

    learning_rate = hyper_parameters['learning_rate']

    n_embedding = hyper_parameters['n_embedding']

    filter_sizes = hyper_parameters['filter_sizes']

    num_filters = hyper_parameters['num_filters']



    char_dict, length = deepchem.models.TextCNNTensorGraph.build_char_dict(train_dataset)

    

    model = deepchem.models.TextCNNTensorGraph(

        len(tasks),

        char_dict,

        seq_length=length,

        n_embedding=n_embedding,

        filter_sizes=filter_sizes,

        num_filters=num_filters,

        learning_rate=learning_rate,

        batch_size=batch_size,

        use_queue=False,

        random_seed=seed,

        mode='classification')

    

  elif model_name == 'rf':

    # Loading hyper parameters

    n_estimators = hyper_parameters['n_estimators']

    nb_epoch = None
@@ -321,7 +292,6 @@ def benchmark_classification(train_dataset, 
        tasks, model_builder)



  elif model_name == 'kernelsvm':

    # Loading hyper parameters

    C = hyper_parameters['C']

    gamma = hyper_parameters['gamma']

    nb_epoch = None
@@ -336,7 +306,6 @@ def benchmark_classification(train_dataset, 
        tasks, model_builder)



  elif model_name == 'xgb':

    # Loading hyper parameters

    max_depth = hyper_parameters['max_depth']

    learning_rate = hyper_parameters['learning_rate']

    n_estimators = hyper_parameters['n_estimators']
@@ -423,11 +392,12 @@ def benchmark_regression(train_dataset, 
      number of features, or length of binary fingerprints

  metric: list of dc.metrics.Metric objects

      metrics used for evaluation

  model: string,  optional (default='tf_regression')

      choice of which model to use, should be: tf_regression, tf_regression_ft,

      graphconvreg, rf_regression, dtnn, dag_regression, xgb_regression,

      weave_regression, krr, ani, krr_ft, mpnn

  test: boolean

  model: string, optional

      choice of model

      'tf_regression', 'tf_regression_ft', 'rf_regression', 'graphconvreg',

      'dtnn', 'dag_regression', 'xgb_regression', 'weave_regression', 

      'textcnn_regression', 'krr', 'ani', 'krr_ft', 'mpnn'      

  test: boolean, optional

      whether to calculate test_set performance

  hyper_parameters: dict, optional (default=None)

      hyper parameters for designated model, None = use preset values
@@ -436,11 +406,11 @@ def benchmark_regression(train_dataset, 
  Returns

  -------

  train_scores : dict

	predicting results(AUC) on training set

	predicting results(R2) on training set

  valid_scores : dict

	predicting results(AUC) on valid set

	predicting results(R2) on valid set

  test_scores : dict

	predicting results(AUC) on test set

	predicting results(R2) on test set



  """

  train_scores = {}
@@ -449,8 +419,8 @@ def benchmark_regression(train_dataset, 


  assert model in [

      'tf_regression', 'tf_regression_ft', 'rf_regression', 'graphconvreg',

      'dtnn', 'dag_regression', 'xgb_regression', 'weave_regression', 'krr',

      'ani', 'krr_ft', 'mpnn'

      'dtnn', 'dag_regression', 'xgb_regression', 'weave_regression', 

      'textcnn_regression', 'krr', 'ani', 'krr_ft', 'mpnn'

  ]

  import xgboost

  if hyper_parameters is None:
@@ -458,7 +428,6 @@ def benchmark_regression(train_dataset, 
  model_name = model



  if model_name == 'tf_regression':

    # Loading hyper parameters

    layer_sizes = hyper_parameters['layer_sizes']

    weight_init_stddevs = hyper_parameters['weight_init_stddevs']

    bias_init_consts = hyper_parameters['bias_init_consts']
@@ -482,9 +451,7 @@ def benchmark_regression(train_dataset, 
        learning_rate=learning_rate,

        seed=seed)



    # Building tensorflow MultiTaskDNN model

  elif model_name == 'tf_regression_ft':

    # Loading hyper parameters

    layer_sizes = hyper_parameters['layer_sizes']

    weight_init_stddevs = hyper_parameters['weight_init_stddevs']

    bias_init_consts = hyper_parameters['bias_init_consts']
@@ -512,44 +479,23 @@ def benchmark_regression(train_dataset, 
        seed=seed)



  elif model_name == 'graphconvreg':

    # Initialize model folder



    # Loading hyper parameters

    batch_size = hyper_parameters['batch_size']

    nb_epoch = hyper_parameters['nb_epoch']

    learning_rate = hyper_parameters['learning_rate']

    n_filters = hyper_parameters['n_filters']

    n_fully_connected_nodes = hyper_parameters['n_fully_connected_nodes']



    tf.set_random_seed(seed)

    graph_model = deepchem.nn.SequentialGraph(n_features)

    graph_model.add(

        deepchem.nn.GraphConv(int(n_filters), n_features, activation='relu'))

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

    graph_model.add(deepchem.nn.GraphPool())

    graph_model.add(

        deepchem.nn.GraphConv(

            int(n_filters), int(n_filters), activation='relu'))

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

    graph_model.add(deepchem.nn.GraphPool())

    # Gather Projection

    graph_model.add(

        deepchem.nn.Dense(

            int(n_fully_connected_nodes), int(n_filters), activation='relu'))

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

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

    model = deepchem.models.MultitaskGraphRegressor(

        graph_model,



    model = deepchem.models.GraphConvTensorGraph(

        len(tasks),

        n_features,

        graph_conv_layers=[n_filters]*2,

        dense_layer_size=n_fully_connected_nodes,

        batch_size=batch_size,

        learning_rate=learning_rate,

        optimizer_type="adam",

        beta1=.9,

        beta2=.999)

        random_seed=seed,

        mode='regression')



  elif model_name == 'dtnn':

    # Loading hyper parameters

    batch_size = hyper_parameters['batch_size']

    nb_epoch = hyper_parameters['nb_epoch']

    learning_rate = hyper_parameters['learning_rate']
@@ -557,26 +503,17 @@ def benchmark_regression(train_dataset, 
    n_distance = hyper_parameters['n_distance']

    assert len(n_features) == 2, 'DTNN is only applicable to qm datasets'



    tf.set_random_seed(seed)

    graph_model = deepchem.nn.SequentialDTNNGraph(n_distance=n_distance)

    graph_model.add(deepchem.nn.DTNNEmbedding(n_embedding=n_embedding))

    graph_model.add(

        deepchem.nn.DTNNStep(n_embedding=n_embedding, n_distance=n_distance))

    graph_model.add(

        deepchem.nn.DTNNStep(n_embedding=n_embedding, n_distance=n_distance))

    graph_model.add(deepchem.nn.DTNNGather(n_embedding=n_embedding))

    model = deepchem.models.MultitaskGraphRegressor(

        graph_model,

    model = deepchem.models.DTNNTensorGraph(

        len(tasks),

        n_embedding,

        n_embedding=n_embedding,

        n_distance=n_distance,

        batch_size=batch_size,

        learning_rate=learning_rate,

        optimizer_type="adam",

        beta1=.9,

        beta2=.999)

        random_seed=seed,

        mode='regression')

    



  elif model_name == 'dag_regression':

    # Loading hyper parameters

    batch_size = hyper_parameters['batch_size']

    nb_epoch = hyper_parameters['nb_epoch']

    learning_rate = hyper_parameters['learning_rate']
@@ -589,7 +526,7 @@ def benchmark_regression(train_dataset, 
    max_atoms = max([max_atoms_train, max_atoms_valid, max_atoms_test])

    max_atoms = min([max_atoms, default_max_atoms])

    print('Maximum number of atoms: %i' % max_atoms)

    reshard_size = 512

    reshard_size = 256

    transformer = deepchem.trans.DAGTransformer(max_atoms=max_atoms)

    train_dataset.reshard(reshard_size)

    train_dataset = transformer.transform(train_dataset)
@@ -599,26 +536,17 @@ def benchmark_regression(train_dataset, 
      test_dataset.reshard(reshard_size)

      test_dataset = transformer.transform(test_dataset)

    

    tf.set_random_seed(seed)

    graph_model = deepchem.nn.SequentialDAGGraph(

        n_features, max_atoms=max_atoms)

    graph_model.add(

        deepchem.nn.DAGLayer(

            n_graph_feat,

            n_features,

            max_atoms=max_atoms,

            batch_size=batch_size))

    graph_model.add(deepchem.nn.DAGGather(n_graph_feat, max_atoms=max_atoms))



    model = deepchem.models.MultitaskGraphRegressor(

        graph_model,

    model = deepchem.models.DAGTensorGraph(

        len(tasks),

        n_features,

        max_atoms=max_atoms,

        n_atom_feat=n_features,

        n_graph_feat=n_graph_feat,

        n_outputs=30,

        batch_size=batch_size,

        learning_rate=learning_rate,

        optimizer_type="adam",

        beta1=.9,

        beta2=.999)

        random_seed=seed,

        use_queue=False,

        mode='regression')



  elif model_name == 'weave_regression':

    batch_size = hyper_parameters['batch_size']
@@ -627,36 +555,40 @@ def benchmark_regression(train_dataset, 
    n_graph_feat = hyper_parameters['n_graph_feat']

    n_pair_feat = hyper_parameters['n_pair_feat']



    max_atoms_train = max([mol.get_num_atoms() for mol in train_dataset.X])

    max_atoms_valid = max([mol.get_num_atoms() for mol in valid_dataset.X])

    max_atoms_test = max([mol.get_num_atoms() for mol in test_dataset.X])

    max_atoms = max([max_atoms_train, max_atoms_valid, max_atoms_test])



    tf.set_random_seed(seed)

    graph_model = deepchem.nn.AlternateSequentialWeaveGraph(

        batch_size,

        max_atoms=max_atoms,

        n_atom_feat=n_features,

        n_pair_feat=n_pair_feat)

    graph_model.add(deepchem.nn.AlternateWeaveLayer(max_atoms, 75, 14))

    graph_model.add(

        deepchem.nn.AlternateWeaveLayer(max_atoms, 50, 50, update_pair=False))

    graph_model.add(deepchem.nn.Dense(n_graph_feat, 50, activation='tanh'))

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

    graph_model.add(

        deepchem.nn.AlternateWeaveGather(

            batch_size, n_input=n_graph_feat, gaussian_expand=True))



    model = deepchem.models.MultitaskGraphRegressor(

        graph_model,

    model = deepchem.models.WeaveTensorGraph(

        len(tasks),

        n_features,

        n_atom_feat=n_features,

        n_pair_feat=n_pair_feat,

        n_hidden=50,

        n_graph_feat=n_graph_feat,

        batch_size=batch_size,

        learning_rate=learning_rate,

        learning_rate_decay_time=1000,

        optimizer_type="adam",

        beta1=.9,

        beta2=.999)

        use_queue=False,

        random_seed=seed,

        mode='regression')



  elif model_name == 'textcnn_regression':

    batch_size = hyper_parameters['batch_size']

    nb_epoch = hyper_parameters['nb_epoch']

    learning_rate = hyper_parameters['learning_rate']

    n_embedding = hyper_parameters['n_embedding']

    filter_sizes = hyper_parameters['filter_sizes']

    num_filters = hyper_parameters['num_filters']



    char_dict, length = deepchem.models.TextCNNTensorGraph.build_char_dict(train_dataset)

    

    model = deepchem.models.TextCNNTensorGraph(

        len(tasks),

        char_dict,

        seq_length=length,

        n_embedding=n_embedding,

        filter_sizes=filter_sizes,

        num_filters=num_filters,

        learning_rate=learning_rate,

        batch_size=batch_size,

        use_queue=False,

        random_seed=seed,

        mode='regression')

    

  elif model_name == 'ani':

    batch_size = hyper_parameters['batch_size']
@@ -718,7 +650,6 @@ def benchmark_regression(train_dataset, 
        mode="regression")



  elif model_name == 'rf_regression':

    # Loading hyper parameters

    n_estimators = hyper_parameters['n_estimators']

    nb_epoch = None
@@ -733,7 +664,6 @@ def benchmark_regression(train_dataset, 
        tasks, model_builder)



  elif model_name == 'krr':

    # Loading hyper parameters

    alpha = hyper_parameters['alpha']

    nb_epoch = None
@@ -746,7 +676,6 @@ def benchmark_regression(train_dataset, 
        tasks, model_builder)



  elif model_name == 'krr_ft':

    # Loading hyper parameters

    alpha = hyper_parameters['alpha']

    nb_epoch = None
@@ -764,7 +693,6 @@ def benchmark_regression(train_dataset, 
        tasks, model_builder)



  elif model_name == 'xgb_regression':

    # Loading hyper parameters

    max_depth = hyper_parameters['max_depth']

    learning_rate = hyper_parameters['learning_rate']

    n_estimators = hyper_parameters['n_estimators']
@@ -784,7 +712,7 @@ def benchmark_regression(train_dataset, 


    esr = {'early_stopping_rounds': early_stopping_rounds}



    # Building xgboost classification model

    # Building xgboost regression model

    def model_builder(model_dir_xgb):

      xgboost_model = xgboost.XGBRegressor(

          max_depth=max_depth,

CRA Git | Maintained and supported by SUSTech CRA and CCSE