Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "premier-closing",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import torch\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "documented-viewer",
   "metadata": {},
   "outputs": [],
   "source": [
    "import drGAT"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "protected-regular",
   "metadata": {},
   "source": [
    "# model evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "869740ff-e2fc-43b8-9a0f-49e637522ec4",
   "metadata": {},
   "outputs": [],
   "source": [
    "test = torch.load(\"test.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "87e09717-6074-4913-a3ea-42e58ab539bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[tensor([[1.0000, 0.9683, 0.9683,  ..., 0.9394, 0.9603, 0.9575],\n",
       "         [0.9683, 1.0000, 0.9932,  ..., 0.9477, 0.9659, 0.9650],\n",
       "         [0.9683, 0.9932, 1.0000,  ..., 0.9514, 0.9697, 0.9688],\n",
       "         ...,\n",
       "         [0.9394, 0.9477, 0.9514,  ..., 1.0000, 0.9472, 0.9500],\n",
       "         [0.9603, 0.9659, 0.9697,  ..., 0.9472, 1.0000, 0.9598],\n",
       "         [0.9575, 0.9650, 0.9688,  ..., 0.9500, 0.9598, 1.0000]]),\n",
       " tensor([[1.0000, 0.0170, 0.0069,  ..., 0.4732, 0.0140, 0.2338],\n",
       "         [0.0170, 1.0000, 0.4351,  ..., 0.0421, 0.4509, 0.0916],\n",
       "         [0.0069, 0.4351, 1.0000,  ..., 0.0196, 0.2926, 0.0337],\n",
       "         ...,\n",
       "         [0.4732, 0.0421, 0.0196,  ..., 1.0000, 0.0267, 0.3622],\n",
       "         [0.0140, 0.4509, 0.2926,  ..., 0.0267, 1.0000, 0.0919],\n",
       "         [0.2338, 0.0916, 0.0337,  ..., 0.3622, 0.0919, 1.0000]]),\n",
       " tensor([[1., 0., 0.,  ..., 0., 0., 0.],\n",
       "         [0., 1., 0.,  ..., 0., 0., 0.],\n",
       "         [0., 0., 1.,  ..., 0., 0., 0.],\n",
       "         ...,\n",
       "         [0., 0., 0.,  ..., 1., 0., 0.],\n",
       "         [0., 0., 0.,  ..., 0., 1., 0.],\n",
       "         [0., 0., 0.,  ..., 0., 0., 1.]]),\n",
       " tensor([[   0,    0,    0,  ..., 3046, 3046, 3046],\n",
       "         [ 279,  281,  282,  ...,  326,  327,  328]]),\n",
       " array([  9,  30, 217, ...,   0, 130, 256]),\n",
       " array([292, 303, 284, ..., 274, 318, 314]),\n",
       " tensor([1., 0., 1.,  ..., 1., 0., 0.])]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "favorite-saturday",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "tmp = !ls | grep pt\n",
    "model = torch.load(\"sample.pt\", map_location=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "subject-allen",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Accuracy</th>\n",
       "      <th>Precision</th>\n",
       "      <th>Recall</th>\n",
       "      <th>F1 Score</th>\n",
       "      <th>True Positive</th>\n",
       "      <th>True Negative</th>\n",
       "      <th>False Positive</th>\n",
       "      <th>False Negative</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.771375</td>\n",
       "      <td>0.740881</td>\n",
       "      <td>0.783245</td>\n",
       "      <td>0.761474</td>\n",
       "      <td>1178</td>\n",
       "      <td>1312</td>\n",
       "      <td>412</td>\n",
       "      <td>326</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Accuracy  Precision    Recall  F1 Score  True Positive  True Negative  \\\n",
       "0  0.771375   0.740881  0.783245  0.761474           1178           1312   \n",
       "\n",
       "   False Positive  False Negative  \n",
       "0             412             326  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predict, res = drGAT.eval(model, test)  # Probability of sensitivity and Metrics\n",
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "korean-recipe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.7653, 0.3292, 0.3037,  ..., 0.9121, 0.4277, 0.2037])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fab9fc36-57a6-4d03-95aa-39592a41371a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f28ddb9e-50b7-40c2-9c81-6b8f0f20d1dd",
   "metadata": {},
   "source": [
    "# For single drug and cell line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6097126f-f158-495b-bb1d-b8131a01ac13",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[tensor([[1.0000, 0.9683, 0.9683,  ..., 0.9394, 0.9603, 0.9575],\n",
       "         [0.9683, 1.0000, 0.9932,  ..., 0.9477, 0.9659, 0.9650],\n",
       "         [0.9683, 0.9932, 1.0000,  ..., 0.9514, 0.9697, 0.9688],\n",
       "         ...,\n",
       "         [0.9394, 0.9477, 0.9514,  ..., 1.0000, 0.9472, 0.9500],\n",
       "         [0.9603, 0.9659, 0.9697,  ..., 0.9472, 1.0000, 0.9598],\n",
       "         [0.9575, 0.9650, 0.9688,  ..., 0.9500, 0.9598, 1.0000]]),\n",
       " tensor([[1.0000, 0.0170, 0.0069,  ..., 0.4732, 0.0140, 0.2338],\n",
       "         [0.0170, 1.0000, 0.4351,  ..., 0.0421, 0.4509, 0.0916],\n",
       "         [0.0069, 0.4351, 1.0000,  ..., 0.0196, 0.2926, 0.0337],\n",
       "         ...,\n",
       "         [0.4732, 0.0421, 0.0196,  ..., 1.0000, 0.0267, 0.3622],\n",
       "         [0.0140, 0.4509, 0.2926,  ..., 0.0267, 1.0000, 0.0919],\n",
       "         [0.2338, 0.0916, 0.0337,  ..., 0.3622, 0.0919, 1.0000]]),\n",
       " tensor([[1., 0., 0.,  ..., 0., 0., 0.],\n",
       "         [0., 1., 0.,  ..., 0., 0., 0.],\n",
       "         [0., 0., 1.,  ..., 0., 0., 0.],\n",
       "         ...,\n",
       "         [0., 0., 0.,  ..., 1., 0., 0.],\n",
       "         [0., 0., 0.,  ..., 0., 1., 0.],\n",
       "         [0., 0., 0.,  ..., 0., 0., 1.]]),\n",
       " tensor([[   0,    0,    0,  ..., 3046, 3046, 3046],\n",
       "         [ 279,  281,  282,  ...,  326,  327,  328]]),\n",
       " array([9]),\n",
       " array([292]),\n",
       " tensor([1])]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test[4] = np.array([9])  # drug index\n",
    "test[5] = np.array([292])  # cell index\n",
    "test[6] = torch.tensor([1])  # label\n",
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "986b0120-115d-4f84-bb87-ca6b3e45b34c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.7653)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Probability of sensitivity.\n",
    "predict, _ = drGAT.eval(model, test)\n",
    "predict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1df199c3-a97d-4a9c-b726-e8324fe1049b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch",
   "language": "python",
   "name": "torch"
  },
  "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.10.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}