00_Utils.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6cc8e5b5-92e4-4740-b12a-f23121d483d1",
   "metadata": {},
   "source": [
    "<font size=5>**Define functions used on several other notebooks**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bdcff70-1efd-4ca6-8a5b-a9dc98c5d66e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import random\n",
    "import datetime\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import csv\n",
    "\n",
    "import torch.multiprocessing as mp\n",
    "\n",
    "from torch.optim import Adam, AdamW\n",
    "from torch.utils.data import Dataset, DataLoader, BatchSampler, RandomSampler,random_split, SequentialSampler\n",
    "from torch.multiprocessing import Pool, Process, set_start_method\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from scipy import stats\n",
    "\n",
    "import os.path\n",
    "from sklearn.metrics import r2_score, mean_squared_error\n",
    "\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f96f07d3-c0c4-4b33-a8ad-86f8e413e9e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def MinMaxNormalization(x):\n",
    "    x_min=np.min(x)\n",
    "    x_max=np.max(x)\n",
    "    return (x-x_min)/(x_max-x_min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8efd68be-c328-421a-afeb-08af94cdd8d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def estimate_density(data,precision=2):\n",
    "    density = scipy.stats.gaussian_kde(data)\n",
    "    precision=2\n",
    "\n",
    "    viability_around_list=np.around(np.arange(0,1.501,10**(-1*precision)),precision)\n",
    "    density_list=[density(x)[0] for x in viability_around_list]\n",
    "    density_list_minmax=MinMaxNormalization(density_list)\n",
    "    density_dic={viability_around_list[i]: density_list_minmax[i] for i in range(len(viability_around_list))}\n",
    "    \n",
    "    return density_dic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "27d46906-63d9-4781-a947-36eeaeb276a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_weight(torch_tensor,gamma,density_dic,precision=2):\n",
    "    label_range=[x[0] for x in np.around(np.float64(torch_tensor.cpu().numpy()),precision)]\n",
    "    density=np.array([density_dic[x] for x in label_range])\n",
    "    weight_for_loss=1-gamma*density\n",
    "\n",
    "    return torch.Tensor(weight_for_loss).to(torch.device(device))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6081a5ff-7f68-4de2-83a7-110938c841ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "def PCC(y_pred, y_true):\n",
    "    x=y_pred.clone()\n",
    "    y=y_true.clone()\n",
    "    vx=x-torch.mean(x)\n",
    "    vy=y-torch.mean(y)\n",
    "    cov=torch.sum(vx*vy)\n",
    "    corr=cov/(torch.sqrt(torch.sum(vx**2))*torch.sqrt(torch.sum(vy**2)))\n",
    "    return corr\n",
    "\n",
    "def MSE(y_pred, y_true):\n",
    "    return torch.mean((y_pred-y_true)**2)\n",
    "\n",
    "def RMSE(y_pred, y_true):\n",
    "    return torch.sqrt(torch.mean((y_pred-y_true)**2))\n",
    "    \n",
    "def WeightedMSE(y_pred, y_true,density_dic,gamma=0.75):\n",
    "    weight=get_weight(torch_tensor=y_true,gamma=gamma,density_dic=density_dic)\n",
    "    loss=torch.mean(weight*((y_pred-y_true)**2))\n",
    "    return loss\n",
    "\n",
    "class CustomLoss(nn.Module):\n",
    "    def __init__(self,density_dic,alpha=1,beta=0.5,gamma=0.75):\n",
    "        self.alpha=alpha\n",
    "        self.beta=beta\n",
    "        self.gamma=gamma\n",
    "        self.density_dic=density_dic\n",
    "        super(CustomLoss, self).__init__()\n",
    "        \n",
    "    def forward(self, y_pred, y_true):\n",
    "        weighted_mse=WeightedMSE(y_pred=y_pred,y_true=y_true,gamma=self.gamma,density_dic=self.density_dic)\n",
    "        mse=MSE(y_pred,y_true)\n",
    "        corr=PCC(y_pred,y_true)\n",
    "        loss=self.alpha*weighted_mse+self.beta*(1-corr)\n",
    "        return loss,mse,corr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "112ae063-d943-4d1d-b30d-a07573ae7e1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def batch_dot(tensor1,tensor2,batch_size=1024):\n",
    "    return (tensor1[None]*tensor2).sum(dim=-1).view(-1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b7fc0122-0620-4b0e-995b-c074a60500fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_tensor_value(tensor):\n",
    "    return tensor.cpu().detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "24b215f0-f272-4ede-a3e5-4e5b39b65c61",
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "def timestamp2datetime(timestamp):\n",
    "    return datetime.datetime.fromtimestamp(timestamp).strftime('%c')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bbe36031-9154-4d1a-be32-19b928c85313",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Hook():\n",
    "    def __init__(self, module):\n",
    "        self.hook = module.register_forward_hook(self.hook_fn)\n",
    "    def hook_fn(self, module, i, o):\n",
    "        self.i=i\n",
    "        self.o=o\n",
    "    def close(self):\n",
    "        self.hook.remove()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0daa96e3-b20c-49da-a5a1-b512ba432fe1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_intermediate_output(dataloader, model, target_layer):\n",
    "    model.eval()\n",
    "    hook=Hook(model._modules[target_layer])\n",
    "\n",
    "    num_batches = len(dataloader)\n",
    "    intermediate_output_list=[]\n",
    "    final_output_list=[]\n",
    "    with torch.no_grad():\n",
    "        for sample in dataloader:\n",
    "            X,y=MonotherapyDataset2device(sample,device)\n",
    "            pred = model(X)\n",
    "            final_output_list.append(pred)\n",
    "            intermediate_output_list.append(hook.o)\n",
    "    intermediate_output=torch.cat(intermediate_output_list)\n",
    "    final_output=torch.cat(final_output_list)\n",
    "\n",
    "    return intermediate_output, final_output"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}