classif_tuning_condensed.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import deepchem\n",
    "import xgboost\n",
    "from rdkit import Chem\n",
    "from rdkit.Chem.EState import Fingerprinter\n",
    "import numpy as np\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from tdc.benchmark_group import admet_group\n",
    "group = admet_group(path = 'data/')\n",
    "rocAucMetric = deepchem.deepchem.metrics.Metric(deepchem.deepchem.metrics.roc_auc_score)\n",
    "ecfpFeat = deepchem.deepchem.feat.CircularFingerprint(radius=4)\n",
    "convMolFeat = deepchem.deepchem.feat.ConvMolFeaturizer()\n",
    "xgb_reg_ecfp = xgboost.XGBClassifier()\n",
    "xgb_reg_estate = xgboost.XGBClassifier()\n",
    "praucMetric = deepchem.deepchem.metrics.prc_auc_score\n",
    "praucMetricWrapped = deepchem.deepchem.metrics.Metric(deepchem.deepchem.metrics.prc_auc_score)\n",
    "params = {'max_depth': [3, 4, 5, 6, 8, 10, 12], 'learning_rate': [0.005, 0.01, 0.03, 0.05, 0.1, 0.15], 'n_estimators': [100, 300, 500, 700, 900, 1100], 'colsample_bytree': [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]}\n",
    "classificationDatasets = ['HIA_Hou', 'Pgp_Broccatelli', 'Bioavailability_Ma', 'BBB_Martins', 'CYP2C9_Veith', 'CYP2D6_Veith', 'CYP3A4_Veith', 'CYP2C9_Substrate_CarbonMangels', 'CYP2D6_Substrate_CarbonMangels', 'CYP3A4_Substrate_CarbonMangels', 'hERG', 'AMES', 'DILI']\n",
    "for dataset in classificationDatasets:\n",
    "    xgbScoring = None\n",
    "    gcnScoring = None\n",
    "    if(dataset in ['CYP2C9_Veith', 'CYP2D6_Veith', 'CYP3A4_Veith', 'CYP2C9_Substrate_CarbonMangels','CYP2D6_Substrate_CarbonMangels']):\n",
    "           xgbScoring = praucMetric\n",
    "           gcnScoring = praucMetricWrapped\n",
    "    else:\n",
    "           xgbScoring = deepchem.deepchem.metrics.roc_auc_score\n",
    "           gcnScoring = rocAucMetric\n",
    "    benchmark = group.get(dataset)\n",
    "    name = benchmark[\"name\"]\n",
    "    train_val, test = benchmark['train_val'], benchmark['test']\n",
    "    train, valid = group.get_train_valid_split(benchmark = name, split_type = 'default', seed = 1)  \n",
    "    results = {}\n",
    "    results[\"name\"] = name\n",
    "    train_valMol = train_val.iloc[:,1].map(lambda x: Chem.MolFromSmiles(x))\n",
    "    testMol = test.iloc[:,1].map(lambda x: Chem.MolFromSmiles(x))\n",
    "    trainValEstateFeat = np.stack(np.array(train_valMol.map(lambda x: Fingerprinter.FingerprintMol(x)[1])))\n",
    "    testEstateFeat = np.stack(np.array(testMol.map(lambda x: Fingerprinter.FingerprintMol(x)[1])))\n",
    "    trainValEcfpFeat = ecfpFeat.featurize(train_val.iloc[:,1].to_list())\n",
    "    testEcfpFeat = ecfpFeat.featurize(test.iloc[:,1].to_list())\n",
    "    trainGcnFeat = convMolFeat.featurize(train.iloc[:,1].to_list())\n",
    "    validGcnFeat = convMolFeat.featurize(valid.iloc[:,1].to_list())\n",
    "    testGcnFeat = convMolFeat.featurize(test.iloc[:,1].to_list())\n",
    "    gcn_train_data = deepchem.deepchem.data.NumpyDataset(X=trainGcnFeat, y=np.array(train.iloc[:,2]), ids=np.array(train.iloc[:,1].to_list()))\n",
    "    gcn_valid_data = deepchem.deepchem.data.NumpyDataset(X=validGcnFeat, y=np.array(valid.iloc[:,2]), ids=np.array(valid.iloc[:,1].to_list()))\n",
    "    clfEstate = GridSearchCV(estimator=xgb_reg_estate, param_grid=params, scoring=xgbScoring, cv=10)\n",
    "    clfEstate.fit(trainValEstateFeat, train_val.iloc[:,2])\n",
    "    results[\"estate\"] = clfEstate.best_params_\n",
    "    clfEcfp = GridSearchCV(estimator=xgb_reg_ecfp, param_grid=params, scoring=xgbScoring, cv=10)\n",
    "    clfEcfp.fit(trainValEcfpFeat, train_val.iloc[:,2])\n",
    "    results[\"ecfp\"] = clfEcfp.best_params_\n",
    "    def model_builder(**model_params):\n",
    "       return deepchem.deepchem.models.GraphConvModel(n_tasks=1, mode=\"classification\", graph_conv_layers=[128, 128, 64])\n",
    "    optimizer = deepchem.deepchem.hyper.GaussianProcessHyperparamOpt(model_builder)\n",
    "    params_dict = {\"dropout\": .01, \"dense_layer_size\": 500}\n",
    "    best_model, best_hyperparams, all_results = optimizer.hyperparam_search(params_dict, gcn_train_data, gcn_valid_data, gcnScoring, search_range=20)\n",
    "    results[\"gcn\"] = best_hyperparams\n",
    "    print(results)\n",
    "    predictions_list = []\n",
    "    for seed in [1, 2, 3, 4, 5]:\n",
    "      predictions = {}\n",
    "      trainBench, validBench = group.get_train_valid_split(benchmark = name, split_type = 'default', seed = seed)\n",
    "      ecfp_benchmark_reg = xgboost.XGBClassifier(max_depth=results[\"ecfp\"][\"max_depth\"], learning_rate=results[\"ecfp\"][\"learning_rate\"], n_estimators=results[\"ecfp\"][\"n_estimators\"], colsample_bytree=results[\"ecfp\"][\"colsample_bytree\"])\n",
    "      estate_benchmark_reg = xgboost.XGBClassifier(max_depth=results[\"estate\"][\"max_depth\"], learning_rate=results[\"estate\"][\"learning_rate\"], n_estimators=results[\"estate\"][\"n_estimators\"], colsample_bytree=results[\"estate\"][\"colsample_bytree\"])\n",
    "      trainGcnFeatBench = convMolFeat.featurize(trainBench.iloc[:,1].to_list())\n",
    "      validGcnFeatBench = convMolFeat.featurize(validBench.iloc[:,1].to_list())\n",
    "      gcn_bench_train_data = deepchem.deepchem.data.NumpyDataset(X=trainGcnFeatBench, y=np.array(trainBench.iloc[:,2]), ids=np.array(trainBench.iloc[:,1].to_list()))\n",
    "      gcn_bench_valid_data = deepchem.deepchem.data.NumpyDataset(X=validGcnFeatBench, y=np.array(validBench.iloc[:,2]), ids=np.array(validBench.iloc[:,1].to_list()))\n",
    "      reg = deepchem.deepchem.models.GraphConvModel(\n",
    "         n_tasks=1, \n",
    "         dropout=results[\"gcn\"][\"dropout\"],\n",
    "         dense_layer_size=results[\"gcn\"][\"dense_layer_size\"],\n",
    "         graph_conv_layers=[128, 128, 64],\n",
    "         mode=\"classification\",)\n",
    "      callback = deepchem.deepchem.models.ValidationCallback(gcn_bench_valid_data, 1000, gcnScoring)\n",
    "      reg.fit(gcn_bench_train_data, nb_epoch=100, callbacks=callback)\n",
    "      estate_benchmark_reg.fit(X=trainValEstateFeat, y=train_val.iloc[:,2], eval_metric=xgbScoring, verbose=True)\n",
    "      ecfp_benchmark_reg.fit(X=trainValEcfpFeat, y=train_val.iloc[:,2], eval_metric=xgbScoring)\n",
    "      pred_estate = estate_benchmark_reg.predict(X=testEstateFeat)\n",
    "      pred_ecfp = ecfp_benchmark_reg.predict(X=testEcfpFeat)\n",
    "      gcn_pred_raw = reg.predict_on_batch(X=np.array(testGcnFeat))\n",
    "      gcn_pred = []\n",
    "      for prediction in gcn_pred_raw:\n",
    "       gcn_pred.append(prediction[0][1])\n",
    "      y_pred_test = np.round(np.mean([ pred_estate, pred_ecfp, gcn_pred ], axis=0))\n",
    "      predictions[name] = y_pred_test\n",
    "      predictions_list.append(predictions)\n",
    "    print(group.evaluate_many(predictions_list))\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "2d9ef161e060c37aa994177a4d833cab797e22621213b4f88b9fe284585c74c2"
  },
  "kernelspec": {
   "display_name": "Python 3.9.10 ('deepchem-test')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}