diff --git a/graph/Graph_Attribution_Prior.ipynb b/graph/Graph_Attribution_Prior.ipynb new file mode 100644 index 0000000..5ad2724 --- /dev/null +++ b/graph/Graph_Attribution_Prior.ipynb @@ -0,0 +1,676 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Graph Attribution Prior" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A simple illustrative example of how to train a feed-forward network to have feature attributions that are smooth over an arbitrary graph. We use AML _ex vivo_ drug response data (from [Tyner et. al. 2018](https://www.nature.com/articles/s41586-018-0623-z)), where our input data ($X$) are a matrix of drug features and gene expression data, and our labels ($y$) are a vector of drug response values (as measured by $\\textrm{IC}_{50}$, the concentration of a drug required to kill half of the cells). We first train for several epochs of standard training, then regularize the network to be smooth over a graph of [protein-protein interactions](https://hb.flatironinstitute.org/)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from attributionpriors.ops import AttributionPriorExplainer\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import scipy.sparse as sp\n", + "\n", + "import pickle\n", + "import random\n", + "\n", + "from sklearn.metrics import mean_squared_error \n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "import tensorflow as tf\n", + "import sys\n", + "import os\n", + "\n", + "from tqdm import *\n", + "\n", + "import sys\n", + "sys.path.insert(0, '../')\n", + "\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"2\"\n", + "\n", + "np.random.seed(1017)\n", + "random.seed(1017)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### graph-handling functions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def convert_csr_to_sparse_tensor_inputs(X):\n", + " coo = sp.coo_matrix(X)\n", + " indices = np.mat([coo.row, coo.col]).transpose()\n", + " return indices, coo.data, coo.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def graph_mult(values, indices, shape, y):\n", + " # sparse tensor multiplication function\n", + " x_tensor = tf.SparseTensor(indices, values, shape) \n", + " out_layer = tf.sparse_tensor_dense_matmul(x_tensor, y)\n", + " return out_layer" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def adj_to_lap(x):\n", + " # calculate graph laplacian from adjacency matrix\n", + " rowsum = np.array(x.sum(1))\n", + " D = sp.diags(rowsum)\n", + " return D - x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### load data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# load training/test data and labels\n", + "\n", + "X_train,y_train,X_test,y_test = pickle.load(open('../data/fully_preprocessed_data.p','rb'))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# load graph\n", + "\n", + "adj_frame = pd.read_pickle('../data/hematopoietic_stem_cell_top_adj.p')\n", + "adj = adj_frame.values\n", + "adj = adj.astype(np.float32)\n", + "adj = adj_to_lap(adj)\n", + "adj_indices, adj_values, adj_shape = convert_csr_to_sparse_tensor_inputs(adj)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# create dataset\n", + "\n", + "batch_size = 32\n", + "references_per_batch = 10\n", + "n_batches = X_train.shape[0] // batch_size\n", + "n_batches_val = X_test.shape[0] // batch_size\n", + "\n", + "x_hold, y_hold = tf.placeholder(tf.float32, shape=[None,X_train.shape[1]]), tf.placeholder(tf.float32, shape=[None,1])\n", + "\n", + "foreground_set = tf.data.Dataset.from_tensor_slices((x_hold, y_hold)).shuffle(buffer_size=1000).batch(batch_size).repeat()\n", + "\n", + "b_hold = tf.placeholder(tf.float32, shape=[None,X_train.shape[1]])\n", + "b_batch_num = batch_size * references_per_batch\n", + "reference_dataset = tf.data.Dataset.from_tensor_slices(b_hold)\n", + "reference_dataset = reference_dataset.shuffle(1000)\n", + "reference_dataset = reference_dataset.apply(tf.contrib.data.batch_and_drop_remainder(b_batch_num))\n", + "reference_dataset = reference_dataset.repeat()\n", + "\n", + "foreground_iter = foreground_set.make_initializable_iterator()\n", + "background_iter = reference_dataset.make_initializable_iterator()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### build model" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# define hyperparameters\n", + "\n", + "layers = [512,256,1]\n", + "l1_penalty = 0.001\n", + "eta = 1e-5\n", + "graph_penalty = 1e2\n", + "training_epochs = 10 ## choose small number of epochs, just for illustration purposes\n", + "fine_tuning_epochs = 2 ## a few fine-tuning epochs, again for illustration" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "features, labels = foreground_iter.get_next()\n", + "background = background_iter.get_next()\n", + "background = tf.reshape(background, [-1, references_per_batch, X_train.shape[1]])\n", + "\n", + "# explainer API\n", + "explainer = AttributionPriorExplainer()\n", + "cond_input_op, train_eg = explainer.input_to_samples_delta(features, background)\n", + "\n", + "# build model\n", + "dense1 = tf.layers.dense(cond_input_op, layers[0], activation=tf.nn.relu,kernel_initializer=\"he_normal\")\n", + "dense2 = tf.layers.dense(dense1, layers[1], activation=tf.nn.relu,kernel_initializer=\"he_normal\")\n", + "prediction = tf.layers.dense(dense2, 1,kernel_initializer=\"he_normal\")\n", + "prediction = tf.reshape(prediction,[-1])\n", + "labels = tf.reshape(labels,[-1])\n", + "\n", + "#DEFINES expected gradients tensor of size --> [batch_size, d]\n", + "expected_gradients_op = explainer.shap_value_op(prediction, cond_input_op)\n", + "\n", + "# define penalty vector based on mean absolute expected gradients\n", + "ma_eg = tf.reduce_mean(tf.abs(expected_gradients_op),axis=0)\n", + "ma_eg = ma_eg[:,tf.newaxis]\n", + "\n", + "# define regularization\n", + "weights = tf.trainable_variables()\n", + "l1_regularizer = tf.contrib.layers.l1_regularizer(scale=l1_penalty, scope=None)\n", + "regularization_penalty = tf.contrib.layers.apply_regularization(l1_regularizer, weights)\n", + "graph_reg = tf.matmul(tf.transpose(graph_mult(adj_values, adj_indices, adj_shape, ma_eg[145:,:])),ma_eg[145:,:])\n", + "\n", + "# define loss, error, training ops\n", + "loss = tf.losses.mean_squared_error(prediction, labels) + regularization_penalty\n", + "eg_loss = tf.multiply(graph_penalty,graph_reg)\n", + "eg_loss = tf.reshape(eg_loss,[-1])\n", + "mse_op = tf.losses.mean_squared_error(prediction, labels)\n", + "\n", + "train_op = tf.train.AdamOptimizer(learning_rate=eta).minimize(loss)\n", + "train_eg_op = tf.train.AdamOptimizer(learning_rate=eta).minimize(eg_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### train model" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 770/770 [00:36<00:00, 30.38it/s]\n", + "100%|██████████| 192/192 [00:02<00:00, 66.77it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 0, Tr Loss: 68.8915, Val Loss: 1.1492\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 770/770 [00:26<00:00, 29.29it/s]\n", + "100%|██████████| 192/192 [00:02<00:00, 73.11it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 1, Tr Loss: 62.8776, Val Loss: 1.0834\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 770/770 [00:26<00:00, 29.40it/s]\n", + "100%|██████████| 192/192 [00:02<00:00, 74.81it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 2, Tr Loss: 56.6563, Val Loss: 1.0432\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 770/770 [00:26<00:00, 29.26it/s]\n", + "100%|██████████| 192/192 [00:02<00:00, 74.02it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 3, Tr Loss: 50.5023, Val Loss: 0.8645\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 770/770 [00:26<00:00, 29.41it/s]\n", + "100%|██████████| 192/192 [00:02<00:00, 74.18it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 4, Tr Loss: 44.5950, Val Loss: 0.8701\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 770/770 [00:26<00:00, 29.30it/s]\n", + "100%|██████████| 192/192 [00:02<00:00, 75.06it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 5, Tr Loss: 39.0724, Val Loss: 0.8217\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 770/770 [00:26<00:00, 29.39it/s]\n", + "100%|██████████| 192/192 [00:02<00:00, 73.73it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 6, Tr Loss: 34.0604, Val Loss: 0.7932\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 770/770 [00:26<00:00, 30.08it/s]\n", + "100%|██████████| 192/192 [00:02<00:00, 73.99it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 7, Tr Loss: 29.5252, Val Loss: 0.8174\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 770/770 [00:26<00:00, 29.33it/s]\n", + "100%|██████████| 192/192 [00:02<00:00, 72.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 8, Tr Loss: 25.5438, Val Loss: 0.7443\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 770/770 [00:26<00:00, 29.16it/s]\n", + "100%|██████████| 192/192 [00:02<00:00, 73.90it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 9, Tr Loss: 22.0930, Val Loss: 0.7506\n", + "Fine-tuning...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 770/770 [00:46<00:00, 16.67it/s] \n", + "100%|██████████| 192/192 [00:02<00:00, 75.29it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 10, Tr Loss: 76.6142, Val Loss: 0.6753\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 770/770 [00:28<00:00, 26.61it/s]\n", + "100%|██████████| 192/192 [00:02<00:00, 74.33it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter: 11, Tr Loss: 35.7239, Val Loss: 0.6839\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "stopped = False\n", + "with tf.Session() as sess:\n", + " \n", + " sess.run(tf.global_variables_initializer())\n", + " i = 0\n", + "\n", + " train_mse = []\n", + " test_mse = []\n", + " eg_cost_per_epoch = []\n", + " l1_cost_per_epoch = []\n", + " graph_smoothness = []\n", + " \n", + " ###\n", + " ### REGULAR TRAINING\n", + " ###\n", + " print('Training...')\n", + " while i < training_epochs:\n", + "\n", + " tot_loss = 0.\n", + " tot_train_loss = 0.\n", + " eg_cost = 0.\n", + " l1_cost = 0.\n", + " tgs = 0.\n", + "\n", + " sess.run(foreground_iter.initializer, feed_dict={ x_hold: X_train, y_hold: y_train})\n", + " sess.run(background_iter.initializer, feed_dict={ b_hold: X_train})\n", + "\n", + " for _ in tqdm(range(n_batches)):\n", + " _, loss_value, tl = sess.run([train_op, loss, mse_op],feed_dict={train_eg: False})\n", + " gs = sess.run([graph_reg],feed_dict={train_eg: True})\n", + " tot_train_loss += tl\n", + " tot_loss += loss_value\n", + " l1_cost += loss_value\n", + " tgs += gs[0]\n", + "\n", + " tvl = 0.\n", + " sess.run(foreground_iter.initializer, feed_dict={ x_hold: X_test, y_hold: y_test})\n", + " for _ in tqdm(range(n_batches_val)):\n", + " vl = sess.run(mse_op)\n", + " tvl += vl\n", + "\n", + " print(\"Iter: {}, Tr Loss: {:.4f}, Val Loss: {:.4f}\".format(i, tot_loss / n_batches, tvl / n_batches_val))\n", + " \n", + " train_mse.append(tot_train_loss / n_batches)\n", + " eg_cost_per_epoch.append(0.0)\n", + " l1_cost_per_epoch.append(l1_cost / n_batches)\n", + " test_mse.append(tvl / n_batches_val)\n", + " graph_smoothness.append(tgs[0][0]/n_batches)\n", + "\n", + "\n", + " i += 1\n", + " \n", + " \n", + " ###\n", + " ### FINE-TUNING GRAPH OBJECTIVE\n", + " ###\n", + " print('Fine-tuning...')\n", + " while i < (training_epochs + fine_tuning_epochs):\n", + "\n", + " tot_loss = 0.\n", + " tot_train_loss = 0.\n", + " eg_cost = 0.\n", + " l1_cost = 0.\n", + " tgs = 0.\n", + "\n", + " sess.run(foreground_iter.initializer, feed_dict={ x_hold: X_train, y_hold: y_train})\n", + " sess.run(background_iter.initializer, feed_dict={ b_hold: X_train})\n", + "\n", + " for bn in tqdm(range(n_batches)):\n", + " _, loss_value, tl = sess.run([train_op, loss, mse_op],feed_dict={train_eg: False})\n", + " tot_train_loss += tl\n", + " gs, _, eg_loss_value = sess.run([graph_reg, train_eg_op, eg_loss],feed_dict={train_eg: True})\n", + " tot_loss += eg_loss_value\n", + " eg_cost += eg_loss_value\n", + " tot_loss += loss_value\n", + " l1_cost += loss_value\n", + " tgs += gs\n", + "\n", + " graph_smoothness.append(tgs[0][0]/n_batches)\n", + " tvl = 0.\n", + " sess.run(foreground_iter.initializer, feed_dict={ x_hold: X_test, y_hold: y_test})\n", + " for _ in tqdm(range(n_batches_val)):\n", + " vl = sess.run(mse_op)\n", + " tvl += vl\n", + "\n", + " print(\"Iter: {}, Tr Loss: {:.4f}, Val Loss: {:.4f}\".format(i, tot_loss[0] / n_batches, tvl / n_batches_val))\n", + " train_mse.append(tot_train_loss / n_batches)\n", + " eg_cost_per_epoch.append(eg_cost / n_batches)\n", + " l1_cost_per_epoch.append(l1_cost / n_batches)\n", + " test_mse.append(tvl / n_batches_val)\n", + " \n", + " i += 1" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGoCAYAAABL+58oAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIhJ1/h+arYrz6C29VwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax1 = plt.subplots()\n", + "fig.set_figwidth(8)\n", + "fig.set_figheight(6)\n", + "\n", + "color = 'tab:red'\n", + "ax1.set_xlabel('epochs')\n", + "ax1.set_ylabel('mse', color=color)\n", + "ax1.plot(np.arange(len(test_mse)), test_mse, color=color)\n", + "ax1.plot([training_epochs-1,training_epochs-1],[0,2],color='black',linestyle='dashed')\n", + "ax1.tick_params(axis='y', labelcolor=color)\n", + "ax1.set_ylim([np.amin(test_mse)-0.1,np.amax(test_mse)+0.1])\n", + "\n", + "ax2 = ax1.twinx()\n", + "\n", + "color = 'tab:blue'\n", + "ax2.set_ylabel('graph variation', color=color) \n", + "ax2.plot(np.arange(len(test_mse)), graph_smoothness, color=color)\n", + "ax2.tick_params(axis='y', labelcolor=color)\n", + "ax2.set_title('Fine Tuning with Attribution Prior Smoothes Over Graph and Decreases Error')\n", + "\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEICAYAAACuxNj9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\niGj0/wEqVXHDVMJJKAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "color = 'tab:red'\n", + "fig, axes = plt.subplots(1, 1)\n", + "ind_1 = training_epochs-1\n", + "ind_2 = training_epochs+fine_tuning_epochs-1\n", + "axes.bar([0,1],[test_mse[ind_1],test_mse[ind_2]],color=color)\n", + "axes.set_ylim([test_mse[ind_2]-0.1,test_mse[ind_1]+0.1])\n", + "xticks = [0,1]\n", + "axes.set_xticks(xticks)\n", + "axes.set_xticklabels(['Without AP','With AP'])\n", + "axes.set_ylabel('Mean squared error')\n", + "axes.set_title('Attribution Prior Decreases Error')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYEAAAEICAYAAAC55kg0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nCZiZ1ZiTgJlZjf1/NnZITpIMnHEAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "color = 'tab:blue'\n", + "fig, axes = plt.subplots(1, 1)\n", + "ind_1 = training_epochs-1\n", + "ind_2 = training_epochs+fine_tuning_epochs-1\n", + "axes.bar([0,1],[graph_smoothness[ind_1],graph_smoothness[ind_2]],color=color)\n", + "axes.set_ylim([0,graph_smoothness[ind_1]+0.25])\n", + "xticks = [0,1]\n", + "axes.set_xticks(xticks)\n", + "axes.set_xticklabels(['Without AP','With AP']);\n", + "axes.set_ylabel('$\\phi^T L_G \\phi$ (Graph Variation)')\n", + "axes.set_title('Attribution Prior Decreases Variation Over Graph')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}