graph_convolutional_networks_for_tox21_on_colab.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "graph_convolutional_networks_for_tox21_on_colab.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "[View in Colaboratory](https://colab.research.google.com/github/christianmerkwirth/colabs/blob/master/graph_convolutional_networks_for_tox21_on_colab.ipynb)"
      ]
    },
    {
      "metadata": {
        "id": "R9PuATRRqO7T",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Graph Convolutions For Tox21 on Google Colaboratory\n",
        "In this Colab notebook, we first show how to install DeepChem on a Colab with Py27 or Py36 runtime. We then explore the use of TensorGraph to create graph convolutional models with DeepChem on the Tox21 dataset.\n",
        "\n",
        "Let's start with installing [DeepChem](https://deepchem.io)."
      ]
    },
    {
      "metadata": {
        "id": "LGu5G1SY9hzv",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "%%bash\n",
        "PYV=`python -c \"import sys;t='{v[0]}.{v[1]}'.format(v=list(sys.version_info[:2]));sys.stdout.write(t)\";`\n",
        "echo \"Python version $PYV detected\"\n",
        "if [ $PYV == \"2.7\" ]\n",
        "then\n",
        "  # Installing DeepChem for Python 2.7.\n",
        "  apt-get install -y libxrender-dev\n",
        "  apt-get install python-rdkit librdkit1 rdkit-data       # Install RDkit\n",
        "\n",
        "  pip install joblib simdna\n",
        "\n",
        "  git clone https://github.com/deepchem/deepchem.git      # Clone deepchem source code from GitHub\n",
        "  cd deepchem && python setup.py install  \n",
        "\n",
        "  ls -la /usr/local/lib/python2.7/dist-packages/deepchem/\n",
        "else\n",
        "  # Installing DeepChem for Python 3.6 using MiniConda.\n",
        "  wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -O anaconda.sh;\n",
        "  chmod +x anaconda.sh\n",
        "  bash ./anaconda.sh -b -f -p /usr/local\n",
        "  conda install -y --prefix /usr/local -c conda-forge rdkit joblib simdna\n",
        "\n",
        "  git clone https://github.com/deepchem/deepchem.git      # Clone deepchem source code from GitHub\n",
        "  cd deepchem && python setup.py install\n",
        "  ls -la /usr/local/lib/python3.6/site-packages/deepchem\n",
        "fi"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "U3cX2OcRKhfC",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Last step of installing DeepChem under Python 3.6\n",
        "\n",
        "import sys\n",
        "if sys.version_info[0] >= 3:\n",
        "    sys.path.append('/usr/local/lib/python3.6/site-packages/')\n",
        "sys.path"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "OBVCwtHnsblw",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Let's start with some basic imports to see if the install was successful. \n",
        "\n",
        "Note: Sometimes it is necessary to restart the runtime once after the initial install. After restarting, continue from the cell below."
      ]
    },
    {
      "metadata": {
        "id": "UnqurdY1qO7V",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from __future__ import division\n",
        "from __future__ import print_function\n",
        "from __future__ import unicode_literals\n",
        "\n",
        "import numpy as np \n",
        "import tensorflow as tf\n",
        "import deepchem as dc\n",
        "from deepchem.models.tensorgraph.models.graph_models import GraphConvModel"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "D0JDwx5XqO7Z",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Now, let's use MoleculeNet to load the Tox21 dataset. We need to make sure to process the data in a way that graph convolutional networks can use For that, we make sure to set the featurizer option to 'GraphConv'. The MoleculeNet call will return a training set, an validation set, and a test set for us to use. The call also returns `transformers`, a list of data transformations that were applied to preprocess the dataset. (Most deep networks are quite finicky and require a set of data transformations to ensure that training proceeds stably.)"
      ]
    },
    {
      "metadata": {
        "id": "i3knXlDcqO7a",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# Load Tox21 dataset\n",
        "tox21_tasks, tox21_datasets, transformers = dc.molnet.load_tox21(featurizer='GraphConv')\n",
        "train_dataset, valid_dataset, test_dataset = tox21_datasets"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "5VBRQBRxqO7f",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Let's now train a graph convolutional network on this dataset. DeepChem has the class `GraphConvModel` that wraps a standard graph convolutional architecture underneath the hood for user convenience. Let's instantiate an object of this class and train it on our dataset."
      ]
    },
    {
      "metadata": {
        "id": "c8H4WKvEqO7g",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "model = GraphConvModel(\n",
        "    len(tox21_tasks), batch_size=50, mode='classification')\n",
        "# Set nb_epoch=10 for better results.\n",
        "model.fit(train_dataset, nb_epoch=1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "NdACV2-bqO7j",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Let's try to evaluate the performance of the model we've trained. For this, we need to define a metric, a measure of model performance. `dc.metrics` holds a collection of metrics already. For this dataset, it is standard to use the ROC-AUC score, the area under the receiver operating characteristic curve (which measures the tradeoff between precision and recall). Luckily, the ROC-AUC score is already available in DeepChem. \n",
        "\n",
        "To measure the performance of the model under this metric, we can use the convenience function `model.evaluate()`."
      ]
    },
    {
      "metadata": {
        "id": "5pAqT5b9qO7k",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "metric = dc.metrics.Metric(\n",
        "    dc.metrics.roc_auc_score, np.mean, mode=\"classification\")\n",
        "\n",
        "print(\"Evaluating model\")\n",
        "train_scores = model.evaluate(train_dataset, [metric], transformers)\n",
        "print(\"Training ROC-AUC Score: %f\" % train_scores[\"mean-roc_auc_score\"])\n",
        "valid_scores = model.evaluate(valid_dataset, [metric], transformers)\n",
        "print(\"Validation ROC-AUC Score: %f\" % valid_scores[\"mean-roc_auc_score\"])"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}