""" import warnings warnings.filterwarnings('ignore') import deepchem as dc #from deepchem.models.tensorgraph.models.graph_models import MPNNTensorGraph from deepchem.models.tensorgraph.models.graph_models import GraphConvModel #from deepchem.feat import WeaveFeaturizer from deepchem.feat.graph_features import ConvMolFeaturizer from deepchem.feat.graph_features import WeaveFeaturizer from deepchem.data.data_loader import CSVLoader import pandas as pd import numpy as np featurizer = ConvMolFeaturizer() #featurizer = WeaveFeaturizer(graph_distance=True, explicit_H=False) train_loader = CSVLoader(tasks=['LogD7.4'], smiles_field='smiles', featurizer=featurizer) test_loader = CSVLoader(tasks=['LogD7.4'], smiles_field='smiles', featurizer=featurizer) X_train = train_loader.featurize('../demo_data/reg/training_set.csv') X_test = test_loader.featurize('../demo_data/reg/testing_set.csv') model = GraphConvModel(n_tasks=1, mode='regression') model.fit(X_train) print(model.predict(X_test))
# Compute accuracies task_scores = {task: [] for task in range(len(test_dataset.get_task_names()))} for trial_num, (task, support) in enumerate(support_generator): print("Starting trial %d" % trial_num) # Number of features on conv-mols n_feat = 75 # Batch size of models batch_size = 50 #graph_model = dc.nn.SequentialGraph(n_feat) model = GraphConvModel( 1, graph_conv_layers=[64, 128, 64], batch_size=batch_size) # Fit trained model model.fit(support, nb_epoch=10) # Test model task_dataset = dc.data.get_task_dataset_minus_support(test_dataset, support, task) y_pred = model.predict(task_dataset) score = metric.compute_metric(task_dataset.y, y_pred, task_dataset.w) print("Score on task %s is %s" % (str(task), str(score))) task_scores[task].append(score) # Join information for all tasks. mean_task_scores = {} std_task_scores = {} for task in range(len(test_dataset.get_task_names())): mean_task_scores[task] = np.mean(np.array(task_scores[task])) std_task_scores[task] = np.std(np.array(task_scores[task]))
# Load Tox21 dataset tox21_tasks, tox21_datasets, transformers = load_tox21(featurizer='GraphConv') train_dataset, valid_dataset, test_dataset = tox21_datasets print(train_dataset.data_dir) print(valid_dataset.data_dir) # Fit models metric = dc.metrics.Metric(dc.metrics.roc_auc_score, np.mean, mode="classification") # Batch size of models batch_size = 50 model = GraphConvModel(len(tox21_tasks), batch_size=batch_size, mode='classification') model.fit(train_dataset, nb_epoch=10) print("Evaluating model") train_scores = model.evaluate(train_dataset, [metric], transformers) valid_scores = model.evaluate(valid_dataset, [metric], transformers) print("Train scores") print(train_scores) print("Validation scores") print(valid_scores)
task_scores = {task: [] for task in range(len(test_dataset.get_task_names()))} for trial_num, (task, support) in enumerate(support_generator): print("Starting trial %d" % trial_num) # Number of features on conv-mols n_feat = 75 # Batch size of models batch_size = 50 #graph_model = dc.nn.SequentialGraph(n_feat) model = GraphConvModel(1, graph_conv_layers=[64, 128, 64], batch_size=batch_size) # Fit trained model model.fit(support, nb_epoch=10) # Test model task_dataset = dc.data.get_task_dataset_minus_support( test_dataset, support, task) y_pred = model.predict(task_dataset) score = metric.compute_metric(task_dataset.y, y_pred, task_dataset.w) print("Score on task %s is %s" % (str(task), str(score))) task_scores[task].append(score) # Join information for all tasks. mean_task_scores = {} std_task_scores = {} for task in range(len(test_dataset.get_task_names())): mean_task_scores[task] = np.mean(np.array(task_scores[task])) std_task_scores[task] = np.std(np.array(task_scores[task]))
def graph_conv_training(): graph_featurizer = dc.feat.graph_features.ConvMolFeaturizer() loader = dc.data.data_loader.CSVLoader(tasks=[t_task.get()], smiles_field=t_smiles.get(), id_field=t_id.get(), featurizer=graph_featurizer) dataset = loader.featurize(t_csv.get()) splitter = dc.splits.splitters.RandomSplitter() trainset, testset = splitter.train_test_split(dataset) hp = dc.molnet.preset_hyper_parameters param = hp.hps['graphconvreg'] print(param) batch_size = 48 from deepchem.models.tensorgraph.models.graph_models import GraphConvModel model = GraphConvModel(n_tasks=1, batch_size=64, uncertainty=False, mode='regression') model = dc.models.GraphConvTensorGraph(1, batch_size=batch_size, learning_rate=1e-3, use_queue=False, mode='regression', model_dir=t_savename.get()) np.random.seed(1) random.seed(1) model.fit(dataset, nb_epoch=max(1, int(t_epochs.get()))) #model.fit(trainset, nb_epoch=max(1, int(t_epochs.get()))) metric = dc.metrics.Metric(dc.metrics.r2_score) print('epoch: ', t_epochs.get()) print("Evaluating model") train_score = model.evaluate(trainset, [metric]) test_score = model.evaluate(testset, [metric]) model.save() pred_train = model.predict(trainset) pred_test = model.predict(testset) y_train = np.array(trainset.y, dtype=np.float32) y_test = np.array(testset.y, dtype=np.float32) import matplotlib.pyplot as plt plt.figure() plt.figure(figsize=(5, 5)) plt.scatter(y_train, pred_train, label='Train', c='blue') plt.title('Graph Convolution') plt.xlabel('Measured value') plt.ylabel('Predicted value') plt.scatter(y_test, pred_test, c='lightgreen', label='Test', alpha=0.8) plt.legend(loc=4) #plt.show() plt.savefig('score-tmp.png') from PIL import Image img = Image.open('score-tmp.png') img_resize = img.resize((400, 400), Image.LANCZOS) img_resize.save('score-tmp.png') global image_score image_score_open = Image.open('score-tmp.png') image_score = ImageTk.PhotoImage(image_score_open, master=frame1) canvas.create_image(200, 200, image=image_score) #Calculate R2 score print("Train score") print(train_score) t_train_r2.set(train_score) print("Test scores") print(test_score) t_test_r2.set(test_score) #Calculate RMSE train_rmse = 1 test_rmse = 1 ''' print("Train RMSE") print(train_rmse) t_train_rmse.set(train_rmse) print("Test RMSE") print(test_rmse) t_test_rmse.set(test_rmse) ''' df_save = pd.DataFrame({'pred_train': pred_train, 'meas_train': y_train}) df_save.to_csv('pred_and_meas_train.csv') print('finish!')
# splitter = dc.splits.RandomSplitter() # train_dataset, valid_dataset, test_dataset = splitter.train_valid_test_split(dataset, seed=42) transformers = [ dc.trans.NormalizationTransformer(transform_y=True, dataset=train_dataset) ] for dataset in [train_dataset, valid_dataset, test_dataset]: for transformer in transformers: dataset = transformer.transform(dataset) model = GraphConvModel(n_tasks=1, mode='regression', tensorboard=True, model_dir='models/', dropout=0.5, graph_conv_layers=[64, 64]) # Need to use the following hackish code to track the validation loss # while fitting with DeepChem, this is how I track overfitting. valid_loss = 10000000 while valid_loss > 50: # Fit trained model model.fit(train_dataset, nb_epoch=1) # checkpoint_interval causes the model not to save a checkpoint. valid_loss = model.fit(valid_dataset, checkpoint_interval=0) print("valid loss: ", valid_loss) # This will restore the model to the fit from the train dataset model.restore() model.save()
splitter = dc.splits.splitters.RandomSplitter() trainset, testset = splitter.train_test_split(dataset) X_oversampled, y_oversampled = ros.fit_resample( np.atleast_2d(X_embeddings[0]).T, labels) test_classifier = GraphConvModel(1, graph_conv_layers=[64, 64], dense_layer_size=128, dropout=0.5, model_dir='models', mode='classification', number_atom_features=75, n_classes=2, uncertainty=False, use_queue=False, tensorboard=True) test_classifier.fit(trainset, nb_epoch=10) dnn_preds = test_classifier.predict(testset) break # hp = dc.molnet.preset_hyper_parameters # param = hp.hps[ 'graphconvreg' ] # print(param['batch_size']) # g = tf.Graph() # graph_model = dc.nn.SequentialGraph( 75 ) # graph_model.add( dc.nn.GraphConv( int(param['n_filters']), 75, activation='relu' )) # graph_model.add( dc.nn.BatchNormalization( epsilon=1e-5, mode=1 )) # graph_model.add( dc.nn.GraphPool() ) # graph_model.add( dc.nn.GraphConv( int(param['n_filters']), int(param['n_filters']), activation='relu' )) # graph_model.add( dc.nn.BatchNormalization( epsilon=1e-5, mode=1 )) # graph_model.add( dc.nn.GraphPool() ) # graph_model.add( dc.nn.Dense( int(param['n_fully_connected_nodes']), int(param['n_filters']), activation='relu' )) # graph_model.add( dc.nn.BatchNormalization( epsilon=1e-5, mode=1 ))
smiles_field="smiles", featurizer=graph_featurizer) dataset_train = loader_train.featurize('./train.csv') # In[3]: loader_test = dc.data.data_loader.CSVLoader(tasks=['ACTIVITY'], smiles_field="smiles", featurizer=graph_featurizer) dataset_test = loader_test.featurize('./test.csv') # In[9]: model = GraphConvModel(n_tasks=1, mode='regression', dropout=0.2) model.fit(dataset_train, nb_epoch=1000) # In[10]: metric = dc.metrics.Metric(dc.metrics.pearson_r2_score) print(model.evaluate(dataset_train, [metric])) print(model.evaluate(dataset_test, [metric])) # In[11]: test_preds = model.predict(dataset_test) # In[12]: