G2DPredTraining.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4c5923b2-e4ea-4fdd-a648-f5c59a9650d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jovyan/hyunho/anaconda3/envs/g2d_diff/lib/python3.8/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from torch import nn \n",
    "import random\n",
    "import os\n",
    "\n",
    "from src.utils.g2d_diff_genodrug_dataset import *\n",
    "from src.g2d_diff_pred import *\n",
    "from src.scheduler import *\n",
    "\n",
    "\n",
    "def set_seed(seed: int = 42) -> None:\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed(seed)\n",
    "    torch.cuda.manual_seed_all(seed)\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    os.environ[\"PYTHONHASHSEED\"] = str(seed)\n",
    "    print(f\"Random seed set as {seed}\")\n",
    "\n",
    "\n",
    "import sys\n",
    "sys.path.insert(0, './vae_package')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b211c1ec-7af3-4167-893c-25fcdc31d778",
   "metadata": {},
   "source": [
    "## G2D-Pred Training Wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "65ec2b23-d7b5-4b5f-803b-d9b5425ab7f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "import datetime\n",
    "from torch import autograd\n",
    "from torch.autograd import Variable\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "from scipy.stats import pearsonr\n",
    "\n",
    "\n",
    "import numpy\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader\n",
    "from tqdm import tqdm\n",
    "from sklearn.utils import shuffle\n",
    "import copy\n",
    "class G2D_Pred_Trainer(nn.Module):\n",
    "    def __init__(self, num_of_genotypes = 1, num_of_dcls = 5, cond_dim = 128,  drug_dim = 128, device = 'cuda'):\n",
    "        super(G2D_Pred_Trainer, self).__init__()\n",
    "        \n",
    "\n",
    "\n",
    "        self.auc_predictor = NCIPREDICTOR(num_of_genotypes = num_of_genotypes, num_of_dcls = num_of_dcls, \n",
    "                                          cond_dim = cond_dim, drug_dim = drug_dim, device = device) \n",
    "\n",
    "   \n",
    "            \n",
    "        \n",
    "        self.num_of_genotypes = num_of_genotypes\n",
    "        self.num_of_dcls = num_of_dcls\n",
    "        self.condim = cond_dim\n",
    "        self.input_dim = drug_dim\n",
    "        self.device_name = device\n",
    "       \n",
    "        \n",
    "    def validation(self, dataset_obj, collate_fn):     \n",
    "        val_loader = DataLoader(dataset_obj, batch_size=128, shuffle=False, drop_last=False, collate_fn=collate_fn)\n",
    "        pred_list = []\n",
    "        targ_list = []\n",
    "\n",
    "        self.auc_predictor.eval()\n",
    "        for i, batch in tqdm(enumerate(val_loader), total = len(val_loader)):\n",
    "\n",
    "\n",
    "            ## Batch data load to device\n",
    "            for key in batch.keys():\n",
    "                if 'genotype' in key:\n",
    "                    for mut in batch[key].keys():\n",
    "                        batch[key][mut] = batch[key][mut].to(device)\n",
    "                elif key == 'cell_name':\n",
    "                    None\n",
    "                elif key == 'drug_name':\n",
    "                    None\n",
    "                else:\n",
    "                    batch[key] = batch[key].to(device)\n",
    "\n",
    "\n",
    "            pred_auc = self.auc_predictor(batch)\n",
    "            pred_list.append(pred_auc.squeeze().detach().cpu().numpy())\n",
    "            targ_list.append(batch['auc'].detach().cpu().numpy())\n",
    "        pred_list = np.hstack(pred_list)\n",
    "        targ_list = np.hstack(targ_list)\n",
    "        \n",
    "        return np.sqrt(mean_squared_error(targ_list , pred_list)), r2_score(targ_list , pred_list), pearsonr(targ_list, pred_list)[0]\n",
    "    \n",
    "        \n",
    "    def train(self, dataset_obj, collate_fn, train_config: Dict, count, val_dataset_obj, load_model = False, load_path = None, sampler = None):\n",
    "        \n",
    "        \n",
    "        \n",
    "        lr = train_config['lr']\n",
    "        batch_size = train_config['batch_size']\n",
    "        epochs = train_config['epoch']\n",
    "        train_config['current_epoch'] = 0\n",
    "        \n",
    "\n",
    "            \n",
    "        tr_loader = DataLoader(dataset_obj, batch_size=batch_size, drop_last=True, collate_fn=collate_fn, sampler = sampler)\n",
    "\n",
    "        \n",
    "        solver = optim.Adam(self.auc_predictor.parameters(), lr=lr)\n",
    "\n",
    "        lr_scheduler = NoamLR(optimizer = solver, \n",
    "                                 warmup_epochs = [1],\n",
    "                                 total_epochs = [200],\n",
    "                                 steps_per_epoch = len(tr_loader),\n",
    "                                 init_lr = [1e-6],\n",
    "                                 max_lr = [lr],\n",
    "                                 final_lr = [1e-5])\n",
    "        \n",
    "        mse_loss = nn.MSELoss()\n",
    "        fin_losses = []\n",
    "        val_results = []\n",
    "\n",
    "        max_val = 0\n",
    "        patience = 0\n",
    "\n",
    "        for epoch in range(train_config['current_epoch'], epochs):\n",
    "            \n",
    "            int_losses = []\n",
    "\n",
    "            print (\"Epoch: %d\" %epoch)\n",
    "            self.auc_predictor.train()\n",
    "            for i, batch in tqdm(enumerate(tr_loader), total = len(tr_loader)):\n",
    "         \n",
    "\n",
    "                ## Batch data load to device\n",
    "                for key in batch.keys():\n",
    "                    if 'genotype' in key:\n",
    "                        for mut in batch[key].keys():\n",
    "                            batch[key][mut] = batch[key][mut].to(self.device_name)\n",
    "                    elif key == 'cell_name':\n",
    "                        None\n",
    "                    elif key == 'drug_name':\n",
    "                        None\n",
    "                    else:\n",
    "                        batch[key] = batch[key].to(self.device_name)\n",
    "                \n",
    "\n",
    "                \n",
    "   \n",
    "                pred_auc = self.auc_predictor(batch)\n",
    "                pred_loss = mse_loss(pred_auc.squeeze(), batch['auc'])\n",
    "\n",
    "      \n",
    "                int_losses.append(pred_loss.detach().cpu().numpy())\n",
    "\n",
    "                \n",
    "                solver.zero_grad()\n",
    "                pred_loss.backward()\n",
    "                solver.step()\n",
    "                lr_scheduler.step()\n",
    "\n",
    "    \n",
    "    \n",
    "            rmse, r2, pcc = self.validation(val_dataset_obj, collate_fn)\n",
    "            print(rmse, r2, pcc)\n",
    "            val_results.append((rmse, r2, pcc))\n",
    "\n",
    "            t= int(len(np.array(int_losses)) / 1)\n",
    "            x = []\n",
    "            for i in range(int(len(np.array(int_losses)) / t)):\n",
    "                x.append(np.mean(np.array(int_losses)[i*t:(i+1)*t]))\n",
    "            fin_losses += x\n",
    "\n",
    "            \n",
    "            train_config['current_epoch'] = epoch\n",
    "            ckpt_dict = {\n",
    "\n",
    "            'condition_encoder_state_dict': self.condition_encoder.state_dict(),\n",
    "            'response_predictor_state_dict': self.response_predictor.state_dict(),\n",
    "\n",
    "                \n",
    "            'solver_state_dict': solver.state_dict(),\n",
    "         \n",
    "            'losses': fin_losses,\n",
    "           \n",
    "            'val_results': val_results,\n",
    "                \n",
    "            'configs' : train_config\n",
    "            }\n",
    "            ## Use here to save the model\n",
    "            #torch.save(ckpt_dict, \"0104_predictor_%d_%d.pth\"%(count, epoch))\n",
    "        return None\n",
    "    \n",
    "    \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3893c67f-602b-4c38-a9ee-85b40767da47",
   "metadata": {},
   "source": [
    "## Data Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cfebc3f1-040b-452f-8c78-2f09a5bfa72f",
   "metadata": {},
   "outputs": [],
   "source": [
    "PREDIFINED_GENOTYPES = ['mut', 'cna', 'cnd']\n",
    "\n",
    "\n",
    "\n",
    "nci_data = pd.read_csv(\"data/drug_response_data/DC_drug_response.csv\").dropna()\n",
    "\n",
    "\n",
    "mean_auc = nci_data['auc'].mean()\n",
    "std_auc = nci_data['auc'].std()\n",
    "\n",
    "nci_data['z_score'] = nci_data['auc'].map(lambda x: np.abs((x-mean_auc)/(std_auc + 1e-8)))\n",
    "\n",
    "\n",
    "cell2mut = pd.read_csv(\"data/drug_response_data/original_cell2mut.csv\", index_col = 0).rename(columns={'index':'ccle_name'})\n",
    "cell2cna = pd.read_csv(\"data/drug_response_data/original_cell2cna.csv\", index_col = 0).rename(columns={'index':'ccle_name'})\n",
    "cell2cnd = pd.read_csv(\"data/drug_response_data/original_cell2cnd.csv\", index_col = 0).rename(columns={'index':'ccle_name'})\n",
    "drug2smi = pd.read_csv(\"data/drug_response_data/DC_drug2smi.csv\").iloc[:, 0:-1]\n",
    "\n",
    "\n",
    "train_config = {}\n",
    "train_config['lr'] = 1e-4\n",
    "train_config['batch_size'] = 128\n",
    "train_config['epoch'] = 200\n",
    "\n",
    "\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ccf293fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "nci_data_test = nci_data.sample(frac = 0.01, random_state = 0)\n",
    "nci_data_train = pd.concat([nci_data, nci_data_test], axis = 0).drop_duplicates(keep=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4656afd5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: >"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "nci_data_test['auc'].hist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "69475115",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: >"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "nci_data_train['auc'].hist()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "729d53ea-c155-4ef5-9d1b-52c7118c0fab",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "705378d8-7619-4508-a2f5-7bfe0e9bcddd",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "device='cuda:0'\n",
    "for repeat in range(5):\n",
    "    set_seed(repeat)\n",
    "    framework = G2D_Pred_Trainer(num_of_genotypes = 3, num_of_dcls = 5, cond_dim = 128, drug_dim = 128,  device = device)\n",
    "    framework.to(device).to(torch.float)\n",
    "\n",
    "    \n",
    "    valid = nci_data_train.sample(frac = 0.01, random_state = repeat)\n",
    "    train = pd.concat([nci_data_train, valid], axis = 0).drop_duplicates(keep=False)\n",
    "\n",
    "\n",
    "    samples_weight = train['z_score'].values\n",
    "    samples_weight = torch.from_numpy(samples_weight)\n",
    "    sampler = torch.utils.data.WeightedRandomSampler(samples_weight.type('torch.DoubleTensor'), len(samples_weight))\n",
    "\n",
    "    train = train.iloc[:, 0:4]\n",
    "    valid = valid.iloc[:, 0:4]\n",
    "\n",
    "    \n",
    "    train_dataset_obj = GenoDrugDataset(train, cell2mut, drug2smi, cna=cell2cna, cnd=cell2cnd)\n",
    "    val_dataset_obj = GenoDrugDataset(valid, cell2mut, drug2smi, cna=cell2cna, cnd=cell2cnd)\n",
    "    collate_fn = GenoDrugCollator(genotypes=PREDIFINED_GENOTYPES)\n",
    "\n",
    "    _ = framework.train(dataset_obj = train_dataset_obj, collate_fn = collate_fn, \\\n",
    "                                         train_config = train_config, val_dataset_obj = val_dataset_obj, count = repeat, sampler = sampler)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "gen_env",
   "language": "python",
   "name": "gen_env"
  },
  "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.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}