[ST]cycle_wider_BNGN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T22:06:32.726614Z",
     "iopub.status.busy": "2022-09-18T22:06:32.726036Z",
     "iopub.status.idle": "2022-09-18T22:06:32.733077Z",
     "shell.execute_reply": "2022-09-18T22:06:32.732575Z",
     "shell.execute_reply.started": "2022-09-18T22:06:32.726555Z"
    },
    "id": "cfVwVROsx3N2"
   },
   "outputs": [],
   "source": [
    "test_id = 'ST_wider_cycle_BNGN_FINAL'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dOtzaj1xehms"
   },
   "source": [
    "# wandb setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2022-09-18T22:06:33.379832Z",
     "iopub.status.busy": "2022-09-18T22:06:33.379058Z",
     "iopub.status.idle": "2022-09-18T22:06:38.500114Z",
     "shell.execute_reply": "2022-09-18T22:06:38.499302Z",
     "shell.execute_reply.started": "2022-09-18T22:06:33.379790Z"
    },
    "id": "2VS8a9greZmr",
    "outputId": "17fdadb4-403b-4984-bbbc-cdd8b710c53c"
   },
   "outputs": [],
   "source": [
    "!pip install wandb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wandb Key 입력\n",
    "\n",
    "사용자 wandb api key를 입력"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2022-09-18T22:06:38.501669Z",
     "iopub.status.busy": "2022-09-18T22:06:38.501464Z",
     "iopub.status.idle": "2022-09-18T22:06:40.258728Z",
     "shell.execute_reply": "2022-09-18T22:06:40.258138Z",
     "shell.execute_reply.started": "2022-09-18T22:06:38.501651Z"
    },
    "id": "GYTNVC_-ejaJ",
    "outputId": "8b694225-555f-4d59-e0f6-08efabcc361c"
   },
   "outputs": [],
   "source": [
    "import wandb\n",
    "\n",
    "wandb.login(key='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wandb 프로젝트 생성\n",
    "\n",
    "wandb.init(project=\"project-name\", entity=\"user-name\")\n",
    "\n",
    "project 이름과 user name 입력"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 126
    },
    "execution": {
     "iopub.execute_input": "2022-09-18T22:06:40.260308Z",
     "iopub.status.busy": "2022-09-18T22:06:40.259948Z",
     "iopub.status.idle": "2022-09-18T22:06:41.229002Z",
     "shell.execute_reply": "2022-09-18T22:06:41.228530Z",
     "shell.execute_reply.started": "2022-09-18T22:06:40.260288Z"
    },
    "id": "QZkP0JKFe9k3",
    "outputId": "4180c1ff-08b0-4218-b25b-a80271ffd49f"
   },
   "outputs": [],
   "source": [
    "wandb.init(project=\"SaumsungSEM\", entity=\"\")\n",
    "wandb.run.name = test_id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YYsy3tkktiK2"
   },
   "source": [
    "# Basic Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T22:06:41.231006Z",
     "iopub.status.busy": "2022-09-18T22:06:41.230213Z",
     "iopub.status.idle": "2022-09-18T22:06:43.464980Z",
     "shell.execute_reply": "2022-09-18T22:06:43.464472Z",
     "shell.execute_reply.started": "2022-09-18T22:06:41.230984Z"
    },
    "id": "aTA1KQlzrfJg"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "import glob\n",
    "import cv2\n",
    "import zipfile\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "import torchvision\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import itertools\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "from tqdm import tqdm\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.model_selection import train_test_split\n",
    "from datetime import datetime\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(action='ignore') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T22:06:44.162713Z",
     "iopub.status.busy": "2022-09-18T22:06:44.162269Z",
     "iopub.status.idle": "2022-09-18T22:06:44.171931Z",
     "shell.execute_reply": "2022-09-18T22:06:44.171129Z",
     "shell.execute_reply.started": "2022-09-18T22:06:44.162695Z"
    },
    "id": "Kc9WYHE1tkPG"
   },
   "outputs": [],
   "source": [
    "CFG = {\n",
    "    #################################################\n",
    "    'DEBUG': False,\n",
    "    'OPEN_ZIP_PATH': './open.zip',\n",
    "    'PROJECT_DIR': './cycle',\n",
    "    #################################################\n",
    "\n",
    "\n",
    "    #기본 설정\n",
    "    'RUN_TYPE': 'ST',                 #ST / TD / Clf\n",
    "    'TRAIN_CASE': 1,                  #1 / 2 / 3 / 4\n",
    "    'SAVE_EPOCH_TERM': 2,\n",
    "\n",
    "    #모델 설정\n",
    "    'STG_RES_NUM': 2,\n",
    "    'STG_DIM': 64,\n",
    "    'STG_PATHS':[],\n",
    "    'STD_DIM': 64,\n",
    "    'STD_PATHS':[],\n",
    "    'STD_DROPOUT': 0.3,\n",
    "\n",
    "    #학습 parameter 설정\n",
    "    'EPOCHS': 300,\n",
    "    'BATCH_SIZE': 128,\n",
    "    'LAMBDA_IDT': 0.5,\n",
    "    'LAMBDA_CYCLE': 10,\n",
    "    'GAN_LR': 0.0002,\n",
    "\n",
    "    #기타\n",
    "    'PERCENTILES': [0, 0.01, 0.03, 0.05, 0.07 ,0.1, 0.15, 0.2, 0.2, 0.3, 0.35, 0.38, 0.4, 0.42, 0.44, 0.46, 0.48, 0.5, 0.6, 0.7, 0.8],\n",
    "    'SEED': 42,\n",
    "}\n",
    "CFG['IMG_dir'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/images/{CFG[\"TRAIN_CASE\"]}'\n",
    "CFG['STG_dir'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STG/{CFG[\"TRAIN_CASE\"]}'\n",
    "CFG['STD_dir'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STD/{CFG[\"TRAIN_CASE\"]}'\n",
    "\n",
    "os.makedirs(CFG['IMG_dir'], exist_ok=True)\n",
    "os.makedirs(CFG['STG_dir'], exist_ok=True)\n",
    "os.makedirs(CFG['STD_dir'], exist_ok=True)\n",
    "\n",
    "wandb.config.update(CFG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T22:06:44.738729Z",
     "iopub.status.busy": "2022-09-18T22:06:44.738204Z",
     "iopub.status.idle": "2022-09-18T22:06:44.745444Z",
     "shell.execute_reply": "2022-09-18T22:06:44.744907Z",
     "shell.execute_reply.started": "2022-09-18T22:06:44.738707Z"
    },
    "id": "LnxjQGvor3u_"
   },
   "outputs": [],
   "source": [
    "def seed_everything(seed):\n",
    "    random.seed(seed)\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed)\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed(seed)\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = True\n",
    "\n",
    "seed_everything(CFG['SEED']) # Seed 고정"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T22:06:45.650264Z",
     "iopub.status.busy": "2022-09-18T22:06:45.649493Z",
     "iopub.status.idle": "2022-09-18T22:06:45.654450Z",
     "shell.execute_reply": "2022-09-18T22:06:45.653974Z",
     "shell.execute_reply.started": "2022-09-18T22:06:45.650264Z"
    },
    "id": "S6oSAdDVr4-X"
   },
   "outputs": [],
   "source": [
    "device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8-6KHoBfqDHo"
   },
   "source": [
    "# Prepare Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T22:06:52.567326Z",
     "iopub.status.busy": "2022-09-18T22:06:52.566564Z",
     "iopub.status.idle": "2022-09-18T22:06:52.570791Z",
     "shell.execute_reply": "2022-09-18T22:06:52.570237Z",
     "shell.execute_reply.started": "2022-09-18T22:06:52.567325Z"
    },
    "id": "5bPPP4OfpUr8"
   },
   "outputs": [],
   "source": [
    "if CFG['OPEN_ZIP_PATH'] is not None:\n",
    "  with zipfile.ZipFile(CFG['OPEN_ZIP_PATH']) as z:\n",
    "    z.extractall()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T11:02:48.112837Z",
     "iopub.status.busy": "2022-09-18T11:02:48.112503Z",
     "iopub.status.idle": "2022-09-18T11:02:54.833944Z",
     "shell.execute_reply": "2022-09-18T11:02:54.833130Z",
     "shell.execute_reply.started": "2022-09-18T11:02:48.112814Z"
    },
    "id": "PJvaZFUMpdou"
   },
   "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>iter0</th>\n",
       "      <th>iter1</th>\n",
       "      <th>depth</th>\n",
       "      <th>case</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>./simulation_data/SEM\\Case_1\\80\\20201001_20294...</td>\n",
       "      <td>./simulation_data/SEM\\Case_1\\80\\20201001_20294...</td>\n",
       "      <td>./simulation_data/Depth\\Case_1\\80\\20201001_202...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>./simulation_data/SEM\\Case_1\\80\\20201001_20294...</td>\n",
       "      <td>./simulation_data/SEM\\Case_1\\80\\20201001_20294...</td>\n",
       "      <td>./simulation_data/Depth\\Case_1\\80\\20201001_202...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>./simulation_data/SEM\\Case_1\\80\\20201001_20294...</td>\n",
       "      <td>./simulation_data/SEM\\Case_1\\80\\20201001_20294...</td>\n",
       "      <td>./simulation_data/Depth\\Case_1\\80\\20201001_202...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>./simulation_data/SEM\\Case_1\\80\\20201001_20294...</td>\n",
       "      <td>./simulation_data/SEM\\Case_1\\80\\20201001_20294...</td>\n",
       "      <td>./simulation_data/Depth\\Case_1\\80\\20201001_202...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>./simulation_data/SEM\\Case_1\\80\\20201001_20294...</td>\n",
       "      <td>./simulation_data/SEM\\Case_1\\80\\20201001_20294...</td>\n",
       "      <td>./simulation_data/Depth\\Case_1\\80\\20201001_202...</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                               iter0  \\\n",
       "0  ./simulation_data/SEM\\Case_1\\80\\20201001_20294...   \n",
       "1  ./simulation_data/SEM\\Case_1\\80\\20201001_20294...   \n",
       "2  ./simulation_data/SEM\\Case_1\\80\\20201001_20294...   \n",
       "3  ./simulation_data/SEM\\Case_1\\80\\20201001_20294...   \n",
       "4  ./simulation_data/SEM\\Case_1\\80\\20201001_20294...   \n",
       "\n",
       "                                               iter1  \\\n",
       "0  ./simulation_data/SEM\\Case_1\\80\\20201001_20294...   \n",
       "1  ./simulation_data/SEM\\Case_1\\80\\20201001_20294...   \n",
       "2  ./simulation_data/SEM\\Case_1\\80\\20201001_20294...   \n",
       "3  ./simulation_data/SEM\\Case_1\\80\\20201001_20294...   \n",
       "4  ./simulation_data/SEM\\Case_1\\80\\20201001_20294...   \n",
       "\n",
       "                                               depth  case  \n",
       "0  ./simulation_data/Depth\\Case_1\\80\\20201001_202...     1  \n",
       "1  ./simulation_data/Depth\\Case_1\\80\\20201001_202...     1  \n",
       "2  ./simulation_data/Depth\\Case_1\\80\\20201001_202...     1  \n",
       "3  ./simulation_data/Depth\\Case_1\\80\\20201001_202...     1  \n",
       "4  ./simulation_data/Depth\\Case_1\\80\\20201001_202...     1  "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simulation_sem_path = sorted(glob.glob('./simulation_data/SEM/*/*/*.png'))\n",
    "simulation_depth_paths = sorted(glob.glob('./simulation_data/Depth/*/*/*.png'))\n",
    "simulation_sem_paths = np.array(simulation_sem_path).reshape(-1,2)\n",
    "\n",
    "df_simul = pd.DataFrame({'iter0':simulation_sem_paths[:,0], 'iter1':simulation_sem_paths[:,1], 'depth':simulation_depth_paths})\n",
    "df_simul['case'] = df_simul['iter0'].apply(lambda x: int(x[27]))\n",
    "df_simul.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T11:02:54.835330Z",
     "iopub.status.busy": "2022-09-18T11:02:54.835107Z",
     "iopub.status.idle": "2022-09-18T11:02:54.840410Z",
     "shell.execute_reply": "2022-09-18T11:02:54.839700Z",
     "shell.execute_reply.started": "2022-09-18T11:02:54.835310Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "86652"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df_simul)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:06.627106Z",
     "iopub.status.busy": "2022-09-18T10:55:06.626877Z",
     "iopub.status.idle": "2022-09-18T10:55:10.270412Z",
     "shell.execute_reply": "2022-09-18T10:55:10.269815Z",
     "shell.execute_reply.started": "2022-09-18T10:55:06.627086Z"
    },
    "id": "erTyeF7QqI61"
   },
   "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>path</th>\n",
       "      <th>case</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>./train/SEM\\Depth_110\\site_00000\\SEM_043510.png</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>./train/SEM\\Depth_110\\site_00000\\SEM_043987.png</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>./train/SEM\\Depth_110\\site_00000\\SEM_045397.png</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>./train/SEM\\Depth_110\\site_00000\\SEM_046894.png</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>./train/SEM\\Depth_110\\site_00000\\SEM_049394.png</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                              path  case\n",
       "0  ./train/SEM\\Depth_110\\site_00000\\SEM_043510.png     1\n",
       "1  ./train/SEM\\Depth_110\\site_00000\\SEM_043987.png     1\n",
       "2  ./train/SEM\\Depth_110\\site_00000\\SEM_045397.png     1\n",
       "3  ./train/SEM\\Depth_110\\site_00000\\SEM_046894.png     1\n",
       "4  ./train/SEM\\Depth_110\\site_00000\\SEM_049394.png     1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data_path = glob.glob('./train/SEM/*/*/*.png')\n",
    "\n",
    "df_train = pd.DataFrame({'path':train_data_path})\n",
    "df_train['case'] = df_train['path'].apply(lambda x: int(x[18:21])//10%10)\n",
    "df_train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BM-RQfCsdlSn"
   },
   "source": [
    "# ST_Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:10.272176Z",
     "iopub.status.busy": "2022-09-18T10:55:10.271325Z",
     "iopub.status.idle": "2022-09-18T10:55:10.278393Z",
     "shell.execute_reply": "2022-09-18T10:55:10.277871Z",
     "shell.execute_reply.started": "2022-09-18T10:55:10.272148Z"
    },
    "id": "uujHhy8Ur_uS"
   },
   "outputs": [],
   "source": [
    "class ST_Simul_Dataset(Dataset):  \n",
    "  def __init__(self, df):\n",
    "    self.df = df\n",
    "  def __len__(self):\n",
    "    return len(self.df)\n",
    "  def __getitem__(self, idx):\n",
    "    sem1 = torch.Tensor(cv2.imread(self.df.iloc[idx,0], cv2.IMREAD_GRAYSCALE))[None, :]\n",
    "    sem2 = torch.Tensor(cv2.imread(self.df.iloc[idx,1], cv2.IMREAD_GRAYSCALE))[None, :]\n",
    "    sem = (sem1 + sem2) / 212 - 1    \n",
    "\n",
    "    return sem \n",
    "\n",
    "class ST_Train_Dataset(Dataset):\n",
    "  def __init__(self, df):\n",
    "    self.df = df\n",
    "  def __len__(self):\n",
    "    return len(self.df)\n",
    "  def __getitem__(self, idx):\n",
    "    train = torch.Tensor(cv2.imread(self.df.iloc[idx,0], cv2.IMREAD_GRAYSCALE))[None,:]\n",
    "\n",
    "    return train / 212 * 2 - 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "je3jeZP3Mr5X"
   },
   "source": [
    "# Extra Class & Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:10.280588Z",
     "iopub.status.busy": "2022-09-18T10:55:10.279952Z",
     "iopub.status.idle": "2022-09-18T10:55:10.285228Z",
     "shell.execute_reply": "2022-09-18T10:55:10.284726Z",
     "shell.execute_reply.started": "2022-09-18T10:55:10.280561Z"
    },
    "id": "-YadUU74iruq"
   },
   "outputs": [],
   "source": [
    "def weights_init_normal(m):\n",
    "    classname = m.__class__.__name__\n",
    "    if classname.find(\"Conv2d\") != -1:\n",
    "        torch.nn.init.normal_(m.weight.data, 0.0, 0.02)\n",
    "    elif classname.find(\"BatchNorm2d\") != -1:\n",
    "        torch.nn.init.normal_(m.weight.data, 1.0, 0.02)\n",
    "        torch.nn.init.constant_(m.bias.data, 0.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dHMpofy1U1JM"
   },
   "source": [
    "# WGAN\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:10.286721Z",
     "iopub.status.busy": "2022-09-18T10:55:10.286024Z",
     "iopub.status.idle": "2022-09-18T10:55:10.294908Z",
     "shell.execute_reply": "2022-09-18T10:55:10.294401Z",
     "shell.execute_reply.started": "2022-09-18T10:55:10.286696Z"
    },
    "id": "A99A0EOoK6Vv"
   },
   "outputs": [],
   "source": [
    "class Resblock(nn.Module):\n",
    "  def __init__(self, dim):\n",
    "    super(Resblock, self).__init__()\n",
    "    self.main = nn.Sequential(\n",
    "      nn.Conv2d(dim, dim, 3, 1, 1, padding_mode='replicate'),\n",
    "      nn.BatchNorm2d(dim),\n",
    "      nn.ReLU(),\n",
    "\n",
    "      nn.Conv2d(dim, dim, 3, 1, 1, padding_mode='replicate'),\n",
    "      nn.BatchNorm2d(dim),\n",
    "    )\n",
    "  \n",
    "  def forward(self, img):\n",
    "    return img + self.main(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:10.296545Z",
     "iopub.status.busy": "2022-09-18T10:55:10.296169Z",
     "iopub.status.idle": "2022-09-18T10:55:10.309697Z",
     "shell.execute_reply": "2022-09-18T10:55:10.309199Z",
     "shell.execute_reply.started": "2022-09-18T10:55:10.296521Z"
    },
    "id": "eamPULL_U2Rm"
   },
   "outputs": [],
   "source": [
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "from torch.autograd import Variable\n",
    "from torch.autograd import grad as torch_grad\n",
    "\n",
    "class Generator(nn.Module):\n",
    "    def __init__(self, dim):\n",
    "        super(Generator, self).__init__() \n",
    "        self.encoder = nn.Sequential(\n",
    "            nn.Conv2d(1, dim, 7, 1, padding='same', padding_mode='replicate'),\n",
    "            nn.BatchNorm2d(dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(dim, 2*dim, 4, 2, 1, padding_mode='replicate'),\n",
    "            nn.BatchNorm2d(2*dim),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        resblocks = [Resblock(2*dim) for _ in range(CFG['STG_RES_NUM'])]\n",
    "        self.middle_layer = nn.Sequential(*resblocks)\n",
    "\n",
    "        self.decoder = nn.Sequential(\n",
    "            nn.ConvTranspose2d(2 * dim, dim, 4, 2, 1),\n",
    "            nn.BatchNorm2d(dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(dim, 1, 7, 1, padding='same', padding_mode='replicate'),\n",
    "            nn.Tanh()\n",
    "        )\n",
    "\n",
    "    def forward(self, simul_sem):\n",
    "        weights = self.encoder(simul_sem)\n",
    "        weights = self.middle_layer(weights)\n",
    "        weights = self.decoder(weights)\n",
    "        return weights\n",
    "\n",
    "\n",
    "class Discriminator(nn.Module):\n",
    "    def __init__(self, dim):\n",
    "        super(Discriminator, self).__init__()\n",
    "        self.main = nn.Sequential(\n",
    "            nn.Conv2d(1, dim, 7, 1, padding='same', padding_mode='replicate'),\n",
    "            nn.LeakyReLU(0.2),\n",
    "\n",
    "            nn.Conv2d(dim, dim, 4, 2, 1),           #(Batch, dim, 36, 24)\n",
    "            nn.GroupNorm(4, dim),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            nn.Dropout(p=CFG['STD_DROPOUT']),\n",
    "\n",
    "            nn.Conv2d(dim, dim, 3, 1, 1),   \n",
    "            nn.GroupNorm(4, dim),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            nn.Dropout(p=CFG['STD_DROPOUT']),\n",
    "\n",
    "            nn.Conv2d(dim, 2 * dim, 4, 2, 1),     #(Batch, 2*dim, 18, 12)\n",
    "            nn.GroupNorm(4, 2*dim),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            nn.Dropout(p=CFG['STD_DROPOUT']),\n",
    "\n",
    "            nn.Conv2d(2*dim, 2*dim, 3, 1, 1),\n",
    "            nn.GroupNorm(4, 2*dim),\n",
    "            nn.LeakyReLU(2*dim),\n",
    "            nn.Dropout(p=CFG['STD_DROPOUT']),\n",
    "\n",
    "            nn.Conv2d(2 * dim, 4 * dim, 4, 2, 1), #(Batch, 4*dim, 9, 6)\n",
    "            nn.GroupNorm(4, 4*dim),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            nn.Dropout(p=CFG['STD_DROPOUT']),\n",
    "\n",
    "            nn.Conv2d(4*dim, 4*dim, 3, 1, 1),\n",
    "            nn.GroupNorm(4, 4*dim),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            nn.Dropout(p=CFG['STD_DROPOUT']),\n",
    "\n",
    "            nn.Conv2d(4*dim, 1, (9,6), 1, 1)\n",
    "        )\n",
    "\n",
    "    def forward(self, trasnfered_SEM):\n",
    "        x = self.main(trasnfered_SEM)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "D3_cv6dAacmm"
   },
   "source": [
    "# Trainer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:10.311281Z",
     "iopub.status.busy": "2022-09-18T10:55:10.310919Z",
     "iopub.status.idle": "2022-09-18T10:55:10.366480Z",
     "shell.execute_reply": "2022-09-18T10:55:10.365776Z",
     "shell.execute_reply.started": "2022-09-18T10:55:10.311259Z"
    },
    "id": "NKgwuqdKadWV"
   },
   "outputs": [],
   "source": [
    "class Trainer():\n",
    "  def __init__(self, generator, discriminator, device=device, model_checkpoint=None,\n",
    "               lambda_idt=CFG['LAMBDA_IDT'], lambda_cycle=CFG['LAMBDA_CYCLE'], lambda_GP=10, critic_iterations=5):\n",
    "      self.G_ST = generator(dim=CFG['STG_DIM']).to(device)\n",
    "      self.G_TS = generator(dim=CFG['STG_DIM']).to(device)\n",
    "      self.G_opt = torch.optim.Adam(itertools.chain(self.G_ST.parameters(), self.G_TS.parameters()),lr=CFG['GAN_LR'], betas=(0.5,0.999))\n",
    "\n",
    "      self.D_T = discriminator(dim=CFG['STG_DIM']).to(device)\n",
    "      self.D_S = discriminator(dim=CFG['STG_DIM']).to(device)\n",
    "      self.D_T_opt = torch.optim.Adam(params=self.D_T.parameters(), lr=CFG['GAN_LR'], betas=(0.5,0.999))\n",
    "      self.D_S_opt = torch.optim.Adam(params=self.D_S.parameters(), lr=CFG['GAN_LR'], betas=(0.5,0.999))\n",
    "        \n",
    "      self.scheduler_D_T = optim.lr_scheduler.MultiStepLR(self.D_T_opt, milestones=[100, 200, 300], gamma=0.5, verbose=True)\n",
    "      self.scheduler_D_S = optim.lr_scheduler.MultiStepLR(self.D_S_opt, milestones=[100, 200, 300], gamma=0.5, verbose=True)\n",
    "      self.scheduler_G = optim.lr_scheduler.MultiStepLR(self.G_opt, milestones=[100, 200, 300], gamma=0.5, verbose=True)\n",
    "        \n",
    "    \n",
    "      if model_checkpoint is None:\n",
    "          weights_init_normal(self.G_ST)\n",
    "          weights_init_normal(self.G_TS)\n",
    "          weights_init_normal(self.D_T)\n",
    "          weights_init_normal(self.D_S)\n",
    "          self.last_epoch = 0\n",
    "      \n",
    "      else:\n",
    "          self.last_epoch = model_checkpoint['last_epoch']\n",
    "          self.G_ST.load_state_dict(torch.load(model_checkpoint['G_ST']))\n",
    "          self.G_TS.load_state_dict(torch.load(model_checkpoint['G_TS']))            \n",
    "          self.D_T.load_state_dict(torch.load(model_checkpoint['D_T']))\n",
    "          self.D_S.load_state_dict(torch.load(model_checkpoint['D_S']))\n",
    "\n",
    "          try:\n",
    "            self.G_opt.load_state_dict(torch.load(model_checkpoint['G_opt']))\n",
    "            self.scheduler_G.load_state_dict(torch.load(model_checkpoint['scheduler_G']))\n",
    "            self.D_T_opt.load_state_dict(torch.load(model_checkpoint['D_T_opt']))\n",
    "            self.D_S_opt.load_state_dict(torch.load(model_checkpoint['D_S_opt']))\n",
    "            self.scheduler_D_T.load_state_dict(torch.load(model_checkpoint['scheduler_D_T']))\n",
    "            self.scheduler_D_S.load_state_dict(torch.load(model_checkpoint['scheduler_D_S']))\n",
    "          except KeyError:\n",
    "            print('load model only')\n",
    "          print('train checkpoint loaded')\n",
    "\n",
    "      wandb.watch(self.G_ST)\n",
    "      wandb.watch(self.G_TS)\n",
    "      wandb.watch(self.D_T)\n",
    "      wandb.watch(self.D_S)\n",
    "  \n",
    "      self.criterion_idt = nn.L1Loss()\n",
    "      self.criterion_cycle = nn.L1Loss()\n",
    "\n",
    "      self.log = {'G':[], 'D_S': [], 'D_T': [], 'GP': [], 'gradient_norm': [],\n",
    "                     'cycle_ST': [], 'cycle_TS': [],  'IDT_TS':[], 'IDT_ST':[],\n",
    "                     'D_S': [], 'D_T': [],'D_S_fake':[], 'D_S_real':[], 'D_T_fake':[], 'D_T_real':[]}\n",
    "      self.num_steps = 0\n",
    "\n",
    "      self.lambda_idt = lambda_idt\n",
    "      self.lambda_GP = lambda_GP\n",
    "      self.lambda_cycle = lambda_cycle\n",
    "      self.critic_iterations = critic_iterations\n",
    "\n",
    "      self.device = device\n",
    "  def _critic_train_iteration(self, simul_SEM, train_SEM):\n",
    "      #Generate Image S\n",
    "      fake_ST = self.G_ST(simul_SEM)\n",
    "      #Generate Image T\n",
    "      fake_TS = self.G_TS(train_SEM)\n",
    "\n",
    "      #Discriminator S\n",
    "      d_S_real = self.D_S(simul_SEM)\n",
    "      d_S_fake = self.D_S(fake_TS)\n",
    "\n",
    "      #Discriminator T\n",
    "      d_T_real = self.D_T(train_SEM)\n",
    "      d_T_fake = self.D_T(fake_ST)\n",
    "\n",
    "      # Get gradient penalty for S\n",
    "      gradient_penalty_S = self._gradient_penalty(self.D_S, simul_SEM, fake_TS)\n",
    "      self.log['GP'].append(gradient_penalty_S.item())\n",
    "\n",
    "      # Get gradient penalty for T\n",
    "      gradient_penalty_T = self._gradient_penalty(self.D_T, train_SEM, fake_ST)\n",
    "      self.log['GP'].append(gradient_penalty_T.item())\n",
    "   \n",
    "      # weight update S\n",
    "      self.D_S_opt.zero_grad()\n",
    "      d_S_loss = d_S_fake.mean() - d_S_real.mean() + gradient_penalty_S\n",
    "      d_S_loss.backward()\n",
    "      self.D_S_opt.step()\n",
    "\n",
    "      # weight update T\n",
    "      self.D_T_opt.zero_grad()\n",
    "      d_T_loss = d_T_fake.mean() - d_T_real.mean() + gradient_penalty_T\n",
    "      d_T_loss.backward()\n",
    "      self.D_T_opt.step()\n",
    "\n",
    "      # Record loss\n",
    "      self.log['D_S'].append(d_S_loss.item())\n",
    "      self.log['D_T'].append(d_T_loss.item())\n",
    "      self.log['D_S_fake'].append(d_S_fake.mean().item())\n",
    "      self.log['D_S_real'].append(d_S_real.mean().item())\n",
    "      self.log['D_T_fake'].append(d_T_fake.mean().item())\n",
    "      self.log['D_T_real'].append(d_T_real.mean().item())\n",
    "\n",
    "  def _generator_train_iteration(self, simul_SEM, train_SEM, epoch):\n",
    "      #Generate Image ST\n",
    "      fake_ST = self.G_ST(simul_SEM)\n",
    "      #Generate Iamge TS\n",
    "      fake_TS = self.G_TS(train_SEM)\n",
    "      self.G_opt.zero_grad()\n",
    "\n",
    "      # Calculate loss and optimize\n",
    "  \n",
    "      #IDT Loss ST\n",
    "      ST_idt_loss = self.criterion_idt(simul_SEM, fake_ST) * self.lambda_idt\n",
    "      #IDT Loss TS\n",
    "      TS_idt_loss = self.criterion_idt(train_SEM, fake_TS) * self.lambda_idt\n",
    "\n",
    "      #GAN_Loss ST\n",
    "      d_T_fake = self.D_T(fake_ST)\n",
    "      #GAN_Loss TS\n",
    "      d_S_fake = self.D_S(fake_TS)\n",
    "\n",
    "      #get cycle_loss ST\n",
    "      rec_S = self.G_TS(fake_ST)\n",
    "      loss_cycle_S = self.criterion_cycle(rec_S, simul_SEM) * self.lambda_cycle\n",
    "      #get cycle_loss TS\n",
    "      rec_T = self.G_ST(fake_TS)\n",
    "      loss_cycle_T = self.criterion_cycle(rec_T, train_SEM) * self.lambda_cycle\n",
    "\n",
    "      loss_G = -d_T_fake.mean() - d_S_fake.mean() + ST_idt_loss + TS_idt_loss + loss_cycle_S + loss_cycle_T\n",
    "      loss_G.backward()\n",
    "      self.G_opt.step()\n",
    "\n",
    "      if self.num_steps % 500 == 0:\n",
    "        img_sample = torch.cat((simul_SEM.data[0], fake_ST.data[0], rec_S.data[0], train_SEM.data[0], fake_TS.data[0], rec_T.data[0]), -2)\n",
    "        img_sample = (img_sample + 1) * 212 / 2\n",
    "        img_sample = img_sample.view(1,-1,48).cpu().numpy().transpose(1,2,0)\n",
    "        cv2.imwrite(f'{CFG[\"IMG_dir\"]}/{str(epoch).zfill(4)}.png', img_sample)\n",
    "      # Record loss\n",
    "      self.log['G'].append(loss_G.item())\n",
    "      self.log['IDT_ST'].append(ST_idt_loss.item())\n",
    "      self.log['IDT_TS'].append(TS_idt_loss.item())\n",
    "      self.log['cycle_ST'].append(loss_cycle_S.item())\n",
    "      self.log['cycle_TS'].append(loss_cycle_T.item())\n",
    "\n",
    "  def _gradient_penalty(self, netD, SEM, fake_SEM):\n",
    "    b_size = SEM.size()[0]\n",
    "\n",
    "    # Calculate interpolation\n",
    "    alpha = torch.rand(b_size, 1, 1, 1)\n",
    "    alpha = alpha.expand_as(SEM)\n",
    "    alpha = alpha.cuda()\n",
    "\n",
    "    interpolated = alpha * SEM.data + (1 - alpha) * fake_SEM.data\n",
    "    interpolated = Variable(interpolated, requires_grad=True)\n",
    "    interpolated = interpolated.cuda()\n",
    "\n",
    "    # Calculate probability of interpolated examples\n",
    "    prob_interpolated = netD(interpolated)\n",
    "\n",
    "    # Calculate gradients of probabilities with respect to examples\n",
    "    gradients = torch_grad(outputs=prob_interpolated, inputs=interpolated,\n",
    "                          grad_outputs=torch.ones(prob_interpolated.size()).cuda(),\n",
    "                          create_graph=True, retain_graph=True)[0]\n",
    "\n",
    "    # Gradients have shape (batch_size, num_channels, img_width, img_height),\n",
    "    # so flatten to easily take norm per example in batch\n",
    "    gradients = gradients.view(b_size, -1)\n",
    "    self.log['gradient_norm'].append(gradients.norm(2, dim=1).mean().item())\n",
    "    # Derivatives of the gradient close to 0 can cause problems because of\n",
    "    # the square root, so manually calculate norm and add epsilon\n",
    "    gradients_norm = torch.sqrt(torch.sum(gradients ** 2, dim=1) + 1e-12)\n",
    "\n",
    "    # Return gradient penalty\n",
    "    return self.lambda_GP * ((gradients_norm - 1) ** 2).mean()\n",
    "\n",
    "  def _train_epoch(self, simul_loader, train_loader, epoch):\n",
    "      for i, simul_SEM in enumerate(tqdm(simul_loader)):\n",
    "        try:\n",
    "          train_SEM = next(self.train_iter)\n",
    "          assert train_SEM.shape[0] == simul_SEM.shape[0]\n",
    "        except (AssertionError, StopIteration):\n",
    "          if train_SEM.shape[0] > simul_SEM.shape[0]:\n",
    "            train_SEM = train_SEM[:simul_SEM.shape[0]]\n",
    "          else:\n",
    "            self.train_iter = iter(train_loader)\n",
    "            train_SEM = next(self.train_iter)[:simul_SEM.shape[0]]\n",
    "        simul_SEM = simul_SEM.to(self.device)\n",
    "        train_SEM = train_SEM.to(self.device)\n",
    "\n",
    "        self.num_steps += 1\n",
    "        self._critic_train_iteration(simul_SEM, train_SEM)\n",
    "        # Only update generator every |critic_iterations| iterations\n",
    "        if self.num_steps % self.critic_iterations == 0:\n",
    "            self._generator_train_iteration(simul_SEM, train_SEM, epoch)\n",
    "        \n",
    "  def train(self, simul_loader, train_loader, epochs, save_every):\n",
    "      df_train = self.get_df(None, train_loader)\n",
    "      df_simul = self.get_df(None, simul_loader)\n",
    "      self.train_iter = iter(train_loader)\n",
    "      for epoch in range(self.last_epoch, epochs):\n",
    "          print(\"\\nEpoch {}\\n\".format(epoch + 1))\n",
    "          self._train_epoch(simul_loader, train_loader, epoch)\n",
    "          log = self.get_log(epoch)\n",
    "          if (epoch > CFG['EPOCHS']-10 and epoch % save_every == 0) or (epoch % 20 == 0):\n",
    "            self.model_save(epoch)\n",
    "            print('################Model Saved################')\n",
    "\n",
    "            self.G_ST.eval()\n",
    "            self.G_TS.eval()\n",
    "            with torch.no_grad():\n",
    "              print('Generating plot for wandb...')\n",
    "              df_simul_for_plot = self.get_df(self.G_ST, simul_loader)\n",
    "              log = self.get_plot(df_train, df_simul_for_plot,Gtype='ST', log=log)\n",
    "              df_train_for_plot = self.get_df(self.G_TS, train_loader)\n",
    "              log = self.get_plot(df_simul, df_train_for_plot,Gtype='TS', log=log)\n",
    "              print('Pushing plot Finished')\n",
    "\n",
    "          self.G_ST.train()\n",
    "          self.G_TS.train()\n",
    "          wandb.log(log)\n",
    "          if self.scheduler_G is not None:\n",
    "            self.scheduler_G.step()\n",
    "          if self.scheduler_D_S is not None:\n",
    "            self.scheduler_D_S.step()\n",
    "          if self.scheduler_D_T is not None:\n",
    "            self.scheduler_D_T.step()\n",
    "\n",
    "  def model_save(self, epoch):\n",
    "    torch.save(self.G_opt.state_dict(), f'{CFG[\"STG_dir\"]}/optG_{str(epoch+1).zfill(3)}.pth')\n",
    "    torch.save(self.G_ST.state_dict(), f'{CFG[\"STG_dir\"]}/G_ST_{str(epoch+1).zfill(3)}.pth')\n",
    "    torch.save(self.G_TS.state_dict(), f'{CFG[\"STG_dir\"]}/G_TS_{str(epoch+1).zfill(3)}.pth')\n",
    "    torch.save(self.scheduler_G.state_dict(), f'{CFG[\"STG_dir\"]}/schedlerG_{str(epoch+1).zfill(3)}.pth')\n",
    "\n",
    "    torch.save(self.D_S_opt.state_dict(), f'{CFG[\"STD_dir\"]}/optD_S{str(epoch+1).zfill(3)}.pth')\n",
    "    torch.save(self.D_S.state_dict(), f'{CFG[\"STD_dir\"]}/STD_S{str(epoch+1).zfill(3)}.pth')\n",
    "    torch.save(self.scheduler_D_S.state_dict(), f'{CFG[\"STD_dir\"]}/schedlerD_S{str(epoch+1).zfill(3)}.pth')\n",
    "\n",
    "    torch.save(self.D_T_opt.state_dict(), f'{CFG[\"STD_dir\"]}/optD_T{str(epoch+1).zfill(3)}.pth')\n",
    "    torch.save(self.D_T.state_dict(), f'{CFG[\"STD_dir\"]}/STD_T{str(epoch+1).zfill(3)}.pth')\n",
    "    torch.save(self.scheduler_D_T.state_dict(), f'{CFG[\"STD_dir\"]}/schedlerD_T{str(epoch+1).zfill(3)}.pth')\n",
    "\n",
    "  def get_log(self, epoch):\n",
    "    G_losses = np.mean(self.log['G'])\n",
    "    IDT_ST_losses = np.mean(self.log['IDT_ST'])\n",
    "    IDT_TS_losses = np.mean(self.log['IDT_TS'])\n",
    "    D_S_losses = np.mean(self.log['D_S'])\n",
    "    D_T_losses = np.mean(self.log['D_T'])\n",
    "    GP_losses = np.mean(self.log['GP'])\n",
    "    gradient_norm = np.mean(self.log['gradient_norm'])\n",
    "    D_S_fake = np.mean(self.log['D_S_fake'])\n",
    "    D_S_real = np.mean(self.log['D_S_real'])\n",
    "    D_T_fake = np.mean(self.log['D_T_fake'])\n",
    "    D_T_real = np.mean(self.log['D_T_real'])\n",
    "    cycle_ST = np.mean(self.log['cycle_ST'])\n",
    "    cycle_TS = np.mean(self.log['cycle_TS'])\n",
    "\n",
    "    log = {'epoch': epoch,\n",
    "            f'G_loss_{CFG[\"TRAIN_CASE\"]}': G_losses,\n",
    "            f'IDT_ST_losses{CFG[\"TRAIN_CASE\"]}': IDT_ST_losses,\n",
    "            f'IDT_TS_losses{CFG[\"TRAIN_CASE\"]}': IDT_TS_losses,\n",
    "            f'D_S_losses_{CFG[\"TRAIN_CASE\"]}': D_S_losses,\n",
    "            f'D_T_losses_{CFG[\"TRAIN_CASE\"]}': D_T_losses,\n",
    "            f'GP_losses_{CFG[\"TRAIN_CASE\"]}': GP_losses,\n",
    "            f'gradient_norm_{CFG[\"TRAIN_CASE\"]}': gradient_norm,\n",
    "            f'D_S_fake_{CFG[\"TRAIN_CASE\"]}' : D_S_fake,\n",
    "            f'D_S_real_{CFG[\"TRAIN_CASE\"]}' : D_S_real,\n",
    "            f'D_T_fake_{CFG[\"TRAIN_CASE\"]}' : D_T_fake,\n",
    "            f'D_T_real_{CFG[\"TRAIN_CASE\"]}' : D_T_real,\n",
    "            f'cycle_ST_{CFG[\"TRAIN_CASE\"]}' : cycle_ST,\n",
    "            f'cycle_TS_{CFG[\"TRAIN_CASE\"]}' : cycle_TS,\n",
    "            }\n",
    "    self.log = {'G':[], 'D_S': [], 'D_T': [], 'GP': [], 'gradient_norm': [],\n",
    "                'cycle_ST': [], 'cycle_TS': [],  'IDT_TS':[], 'IDT_ST':[],\n",
    "                'D_S': [], 'D_T': [],'D_S_fake':[], 'D_S_real':[], 'D_T_fake':[], 'D_T_real':[]}\n",
    "    return log\n",
    "\n",
    "  def get_df(self, model, loader):\n",
    "    avg = torch.Tensor([]).to(self.device)\n",
    "    std = torch.Tensor([]).to(self.device)\n",
    "    percentiles = torch.Tensor(CFG['PERCENTILES']).to(self.device)\n",
    "    p = torch.zeros(1, len(percentiles)).to(self.device)\n",
    "    #EDA 파일과 같은 방식으로 각 데이터 수집\n",
    "    for img in tqdm(loader):\n",
    "      img = img.to(self.device)\n",
    "      if model is not None:\n",
    "        img = model(img)\n",
    "\n",
    "      img = img.view(-1,3456).detach()\n",
    "      avg = torch.cat((avg, torch.mean(img, dim=1)))\n",
    "      std = torch.cat((std, torch.std(img, dim=1, unbiased=False)))\n",
    "      temp = torch.quantile(img, percentiles, dim=1, interpolation='nearest')\n",
    "      temp = torch.transpose(temp, 1, 0)\n",
    "      p = torch.cat((p, temp.detach()))\n",
    "\n",
    "    avg = avg.cpu()\n",
    "    std = std.cpu()\n",
    "    p = p[1:].cpu()\n",
    "    percentiles = percentiles.cpu().numpy()\n",
    "    df = pd.DataFrame({'avg': avg, 'std': std})\n",
    "    for i in range(len(percentiles)):\n",
    "      df[str(percentiles[i])[1:]+'%'] = p[:,i]\n",
    "    return df\n",
    "\n",
    "  #wandb 전송할 plot 생성\n",
    "  def get_plot(self, df1, df2, Gtype, log):\n",
    "    case=CFG['TRAIN_CASE']\n",
    "    percentiles = CFG['PERCENTILES']\n",
    "    fig, axes = plt.subplots(nrows=(len(percentiles)+2)//2, ncols=2)\n",
    "    fig.set_size_inches(30, 4 *len(axes))\n",
    "\n",
    "    key = iter(df1.keys())\n",
    "    for rows in axes:\n",
    "      for ax in rows:\n",
    "        try:\n",
    "          target = next(key)\n",
    "          ax1 = ax.twinx()\n",
    "          sns.histplot(data=df1, x=target, kde=False, ax=ax, palette='bright')\n",
    "          sns.kdeplot(data=df2, x=target, ax=ax1, palette='bright')\n",
    "\n",
    "        except StopIteration:\n",
    "          break \n",
    "    log[f'Analysis_{Gtype}_{CFG[\"TRAIN_CASE\"]}'] = wandb.Image(fig)\n",
    "    plt.cla()\n",
    "    plt.clf()\n",
    "    plt.close('all')\n",
    "    return log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4AQbtwMcJolt"
   },
   "source": [
    "# Train 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:10.368282Z",
     "iopub.status.busy": "2022-09-18T10:55:10.367472Z",
     "iopub.status.idle": "2022-09-18T10:55:10.373925Z",
     "shell.execute_reply": "2022-09-18T10:55:10.373251Z",
     "shell.execute_reply.started": "2022-09-18T10:55:10.368256Z"
    },
    "id": "vVk6d8dNYMcI"
   },
   "outputs": [],
   "source": [
    "CFG['TRAIN_CASE'] = 1\n",
    "CFG['IMG_dir'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/images/{CFG[\"TRAIN_CASE\"]}'\n",
    "CFG['STG_dir'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STG/{CFG[\"TRAIN_CASE\"]}'\n",
    "CFG['STD_dir'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STD/{CFG[\"TRAIN_CASE\"]}'\n",
    "\n",
    "os.makedirs(CFG['IMG_dir'], exist_ok=True)\n",
    "os.makedirs(CFG['STG_dir'], exist_ok=True)\n",
    "os.makedirs(CFG['STD_dir'], exist_ok=True)\n",
    "\n",
    "model_checkpoint = None\n",
    "wandb.config.update(CFG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:10.375246Z",
     "iopub.status.busy": "2022-09-18T10:55:10.374664Z",
     "iopub.status.idle": "2022-09-18T10:55:13.605207Z",
     "shell.execute_reply": "2022-09-18T10:55:13.603908Z",
     "shell.execute_reply.started": "2022-09-18T10:55:10.375221Z"
    },
    "id": "sgMWBPrKYMcI",
    "outputId": "97b9ac04-5b30-4596-ca54-4243cbe87087"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adjusting learning rate of group 0 to 2.0000e-04.\n",
      "Adjusting learning rate of group 0 to 2.0000e-04.\n",
      "Adjusting learning rate of group 0 to 2.0000e-04.\n"
     ]
    }
   ],
   "source": [
    "#dataset 준비\n",
    "seed_everything(CFG['SEED']) # Seed 고정\n",
    "\n",
    "temp_simul = df_simul[df_simul['case'] == CFG['TRAIN_CASE']]\n",
    "temp_train = df_train[df_train['case']==CFG['TRAIN_CASE']]\n",
    "if CFG['DEBUG'] == True:\n",
    "  temp_simul = temp_simul.iloc[:1000]\n",
    "  temp_train = temp_train.iloc[:800]\n",
    "\n",
    "ST_simul = ST_Simul_Dataset(temp_simul)\n",
    "ST_train = ST_Train_Dataset(temp_train)\n",
    "\n",
    "\n",
    "ST_simul_loader = DataLoader(ST_simul, batch_size=CFG['BATCH_SIZE'], shuffle=True)\n",
    "ST_train_loader = DataLoader(ST_train, batch_size=CFG['BATCH_SIZE'], shuffle=True)\n",
    "\n",
    "wgan_trainer = Trainer(Generator, Discriminator, device, model_checkpoint = model_checkpoint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:13.607569Z",
     "iopub.status.busy": "2022-09-18T10:55:13.607325Z",
     "iopub.status.idle": "2022-09-18T11:02:05.786202Z",
     "shell.execute_reply": "2022-09-18T11:02:05.784957Z",
     "shell.execute_reply.started": "2022-09-18T10:55:13.607547Z"
    },
    "id": "ZVpvzue0YMcI",
    "outputId": "c8aef82b-46bd-44a4-f8ce-77d032d0efdb"
   },
   "outputs": [],
   "source": [
    "wgan_trainer.train(ST_simul_loader, ST_train_loader, CFG['EPOCHS'], 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4AQbtwMcJolt"
   },
   "source": [
    "# Train 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:10.368282Z",
     "iopub.status.busy": "2022-09-18T10:55:10.367472Z",
     "iopub.status.idle": "2022-09-18T10:55:10.373925Z",
     "shell.execute_reply": "2022-09-18T10:55:10.373251Z",
     "shell.execute_reply.started": "2022-09-18T10:55:10.368256Z"
    },
    "id": "vVk6d8dNYMcI"
   },
   "outputs": [],
   "source": [
    "CFG['TRAIN_CASE'] = 2\n",
    "CFG['IMG_dir'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/images/{CFG[\"TRAIN_CASE\"]}'\n",
    "CFG['STG_dir'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STG/{CFG[\"TRAIN_CASE\"]}'\n",
    "CFG['STD_dir'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STD/{CFG[\"TRAIN_CASE\"]}'\n",
    "\n",
    "os.makedirs(CFG['IMG_dir'], exist_ok=True)\n",
    "os.makedirs(CFG['STG_dir'], exist_ok=True)\n",
    "os.makedirs(CFG['STD_dir'], exist_ok=True)\n",
    "\n",
    "model_checkpoint = {}\n",
    "model_checkpoint['last_epoch'] = 0\n",
    "model_checkpoint['G_ST'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STG/1/G_ST_299.pth'\n",
    "model_checkpoint['G_TS'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STG/1/G_TS_299.pth'       \n",
    "model_checkpoint['D_T'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STD/1/STD_T299.pth' \n",
    "model_checkpoint['D_S'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STD/1/STD_S299.pth' \n",
    "CFG['EPOCHS'] = 100\n",
    "\n",
    "wandb.config.update(CFG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:10.375246Z",
     "iopub.status.busy": "2022-09-18T10:55:10.374664Z",
     "iopub.status.idle": "2022-09-18T10:55:13.605207Z",
     "shell.execute_reply": "2022-09-18T10:55:13.603908Z",
     "shell.execute_reply.started": "2022-09-18T10:55:10.375221Z"
    },
    "id": "sgMWBPrKYMcI",
    "outputId": "97b9ac04-5b30-4596-ca54-4243cbe87087"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adjusting learning rate of group 0 to 2.0000e-04.\n",
      "Adjusting learning rate of group 0 to 2.0000e-04.\n",
      "Adjusting learning rate of group 0 to 2.0000e-04.\n",
      "load model only\n",
      "train checkpoint loaded\n"
     ]
    }
   ],
   "source": [
    "#dataset 준비\n",
    "seed_everything(CFG['SEED']) # Seed 고정\n",
    "\n",
    "temp_simul = df_simul[df_simul['case'] == CFG['TRAIN_CASE']]\n",
    "temp_train = df_train[df_train['case']==CFG['TRAIN_CASE']]\n",
    "if CFG['DEBUG'] == True:\n",
    "  temp_simul = temp_simul.iloc[:1000]\n",
    "  temp_train = temp_train.iloc[:800]\n",
    "\n",
    "ST_simul = ST_Simul_Dataset(temp_simul)\n",
    "ST_train = ST_Train_Dataset(temp_train)\n",
    "\n",
    "\n",
    "ST_simul_loader = DataLoader(ST_simul, batch_size=CFG['BATCH_SIZE'], shuffle=True)\n",
    "ST_train_loader = DataLoader(ST_train, batch_size=CFG['BATCH_SIZE'], shuffle=True)\n",
    "\n",
    "wgan_trainer = Trainer(Generator, Discriminator, device, model_checkpoint = model_checkpoint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:13.607569Z",
     "iopub.status.busy": "2022-09-18T10:55:13.607325Z",
     "iopub.status.idle": "2022-09-18T11:02:05.786202Z",
     "shell.execute_reply": "2022-09-18T11:02:05.784957Z",
     "shell.execute_reply.started": "2022-09-18T10:55:13.607547Z"
    },
    "id": "ZVpvzue0YMcI",
    "outputId": "c8aef82b-46bd-44a4-f8ce-77d032d0efdb",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "wgan_trainer.train(ST_simul_loader, ST_train_loader, CFG['EPOCHS'], 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4AQbtwMcJolt"
   },
   "source": [
    "# Train 3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:10.368282Z",
     "iopub.status.busy": "2022-09-18T10:55:10.367472Z",
     "iopub.status.idle": "2022-09-18T10:55:10.373925Z",
     "shell.execute_reply": "2022-09-18T10:55:10.373251Z",
     "shell.execute_reply.started": "2022-09-18T10:55:10.368256Z"
    },
    "id": "vVk6d8dNYMcI"
   },
   "outputs": [],
   "source": [
    "CFG['TRAIN_CASE'] = 3\n",
    "CFG['IMG_dir'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/images/{CFG[\"TRAIN_CASE\"]}'\n",
    "CFG['STG_dir'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STG/{CFG[\"TRAIN_CASE\"]}'\n",
    "CFG['STD_dir'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STD/{CFG[\"TRAIN_CASE\"]}'\n",
    "\n",
    "os.makedirs(CFG['IMG_dir'], exist_ok=True)\n",
    "os.makedirs(CFG['STG_dir'], exist_ok=True)\n",
    "os.makedirs(CFG['STD_dir'], exist_ok=True)\n",
    "\n",
    "model_checkpoint = {}\n",
    "model_checkpoint['last_epoch'] = 0\n",
    "model_checkpoint['G_ST'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STG/1/G_ST_299.pth'\n",
    "model_checkpoint['G_TS'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STG/1/G_TS_299.pth'       \n",
    "model_checkpoint['D_T'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STD/1/STD_T299.pth' \n",
    "model_checkpoint['D_S'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STD/1/STD_S299.pth'\n",
    "CFG['EPOCHS'] = 100\n",
    "\n",
    "wandb.config.update(CFG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:10.375246Z",
     "iopub.status.busy": "2022-09-18T10:55:10.374664Z",
     "iopub.status.idle": "2022-09-18T10:55:13.605207Z",
     "shell.execute_reply": "2022-09-18T10:55:13.603908Z",
     "shell.execute_reply.started": "2022-09-18T10:55:10.375221Z"
    },
    "id": "sgMWBPrKYMcI",
    "outputId": "97b9ac04-5b30-4596-ca54-4243cbe87087"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adjusting learning rate of group 0 to 2.0000e-04.\n",
      "Adjusting learning rate of group 0 to 2.0000e-04.\n",
      "Adjusting learning rate of group 0 to 2.0000e-04.\n",
      "load model only\n",
      "train checkpoint loaded\n"
     ]
    }
   ],
   "source": [
    "#dataset 준비\n",
    "seed_everything(CFG['SEED']) # Seed 고정\n",
    "\n",
    "temp_simul = df_simul[df_simul['case'] == CFG['TRAIN_CASE']]\n",
    "temp_train = df_train[df_train['case']==CFG['TRAIN_CASE']]\n",
    "if CFG['DEBUG'] == True:\n",
    "  temp_simul = temp_simul.iloc[:1000]\n",
    "  temp_train = temp_train.iloc[:800]\n",
    "\n",
    "ST_simul = ST_Simul_Dataset(temp_simul)\n",
    "ST_train = ST_Train_Dataset(temp_train)\n",
    "\n",
    "\n",
    "ST_simul_loader = DataLoader(ST_simul, batch_size=CFG['BATCH_SIZE'], shuffle=True)\n",
    "ST_train_loader = DataLoader(ST_train, batch_size=CFG['BATCH_SIZE'], shuffle=True)\n",
    "\n",
    "wgan_trainer = Trainer(Generator, Discriminator, device, model_checkpoint = model_checkpoint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:13.607569Z",
     "iopub.status.busy": "2022-09-18T10:55:13.607325Z",
     "iopub.status.idle": "2022-09-18T11:02:05.786202Z",
     "shell.execute_reply": "2022-09-18T11:02:05.784957Z",
     "shell.execute_reply.started": "2022-09-18T10:55:13.607547Z"
    },
    "id": "ZVpvzue0YMcI",
    "outputId": "c8aef82b-46bd-44a4-f8ce-77d032d0efdb"
   },
   "outputs": [],
   "source": [
    "wgan_trainer.train(ST_simul_loader, ST_train_loader, CFG['EPOCHS'], 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4AQbtwMcJolt"
   },
   "source": [
    "# Train 4\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:10.368282Z",
     "iopub.status.busy": "2022-09-18T10:55:10.367472Z",
     "iopub.status.idle": "2022-09-18T10:55:10.373925Z",
     "shell.execute_reply": "2022-09-18T10:55:10.373251Z",
     "shell.execute_reply.started": "2022-09-18T10:55:10.368256Z"
    },
    "id": "vVk6d8dNYMcI"
   },
   "outputs": [],
   "source": [
    "CFG['TRAIN_CASE'] = 4\n",
    "CFG['IMG_dir'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/images/{CFG[\"TRAIN_CASE\"]}'\n",
    "CFG['STG_dir'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STG/{CFG[\"TRAIN_CASE\"]}'\n",
    "CFG['STD_dir'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STD/{CFG[\"TRAIN_CASE\"]}'\n",
    "\n",
    "os.makedirs(CFG['IMG_dir'], exist_ok=True)\n",
    "os.makedirs(CFG['STG_dir'], exist_ok=True)\n",
    "os.makedirs(CFG['STD_dir'], exist_ok=True)\n",
    "\n",
    "model_checkpoint = {}\n",
    "model_checkpoint['last_epoch'] = 0\n",
    "model_checkpoint['G_ST'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STG/1/G_ST_299.pth'\n",
    "model_checkpoint['G_TS'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STG/1/G_TS_299.pth'       \n",
    "model_checkpoint['D_T'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STD/1/STD_T299.pth' \n",
    "model_checkpoint['D_S'] = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STD/1/STD_S299.pth' \n",
    "CFG['EPOCHS'] = 100\n",
    "\n",
    "wandb.config.update(CFG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:10.375246Z",
     "iopub.status.busy": "2022-09-18T10:55:10.374664Z",
     "iopub.status.idle": "2022-09-18T10:55:13.605207Z",
     "shell.execute_reply": "2022-09-18T10:55:13.603908Z",
     "shell.execute_reply.started": "2022-09-18T10:55:10.375221Z"
    },
    "id": "sgMWBPrKYMcI",
    "outputId": "97b9ac04-5b30-4596-ca54-4243cbe87087"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adjusting learning rate of group 0 to 2.0000e-04.\n",
      "Adjusting learning rate of group 0 to 2.0000e-04.\n",
      "Adjusting learning rate of group 0 to 2.0000e-04.\n",
      "load model only\n",
      "train checkpoint loaded\n"
     ]
    }
   ],
   "source": [
    "#dataset 준비\n",
    "seed_everything(CFG['SEED']) # Seed 고정\n",
    "\n",
    "temp_simul = df_simul[df_simul['case'] == CFG['TRAIN_CASE']]\n",
    "temp_train = df_train[df_train['case']==CFG['TRAIN_CASE']]\n",
    "if CFG['DEBUG'] == True:\n",
    "  temp_simul = temp_simul.iloc[:1000]\n",
    "  temp_train = temp_train.iloc[:800]\n",
    "\n",
    "ST_simul = ST_Simul_Dataset(temp_simul)\n",
    "ST_train = ST_Train_Dataset(temp_train)\n",
    "\n",
    "\n",
    "ST_simul_loader = DataLoader(ST_simul, batch_size=CFG['BATCH_SIZE'], shuffle=True)\n",
    "ST_train_loader = DataLoader(ST_train, batch_size=CFG['BATCH_SIZE'], shuffle=True)\n",
    "\n",
    "wgan_trainer = Trainer(Generator, Discriminator, device, model_checkpoint = model_checkpoint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2022-09-18T10:55:13.607569Z",
     "iopub.status.busy": "2022-09-18T10:55:13.607325Z",
     "iopub.status.idle": "2022-09-18T11:02:05.786202Z",
     "shell.execute_reply": "2022-09-18T11:02:05.784957Z",
     "shell.execute_reply.started": "2022-09-18T10:55:13.607547Z"
    },
    "id": "ZVpvzue0YMcI",
    "outputId": "c8aef82b-46bd-44a4-f8ce-77d032d0efdb"
   },
   "outputs": [],
   "source": [
    "wgan_trainer.train(ST_simul_loader, ST_train_loader, CFG['EPOCHS'], 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simulation -> Train domain transfer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ST_Simul_Dataset_Save(Dataset):  \n",
    "  def __init__(self, df):\n",
    "    self.df = df\n",
    "    \n",
    "  def __len__(self):\n",
    "    return len(self.df)\n",
    "\n",
    "  def __getitem__(self, idx):\n",
    "    sem1 = torch.Tensor(cv2.imread(self.df.iloc[idx,0], cv2.IMREAD_GRAYSCALE))[None, :]\n",
    "    sem2 = torch.Tensor(cv2.imread(self.df.iloc[idx,1], cv2.IMREAD_GRAYSCALE))[None, :]\n",
    "    sem = (sem1 + sem2) / 212 - 1    \n",
    "    \n",
    "    depth = cv2.imread(df_simul.iloc[idx,2], cv2.IMREAD_GRAYSCALE) # get depth img\n",
    "    \n",
    "    case = df_simul.iloc[idx, 3]\n",
    "\n",
    "    return sem, depth, case, idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "model1_path = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STG/1/G_ST_299.pth'\n",
    "model2_path = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STG/2/G_ST_099.pth'\n",
    "model3_path = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STG/3/G_ST_099.pth'\n",
    "model4_path = f'{CFG[\"PROJECT_DIR\"]}/{test_id}/STG/4/G_ST_099.pth'\n",
    "\n",
    "models = []\n",
    "models.append(0)\n",
    "\n",
    "models.append(Generator(dim=CFG['STG_DIM']))\n",
    "models.append(Generator(dim=CFG['STG_DIM']))\n",
    "models.append(Generator(dim=CFG['STG_DIM']))\n",
    "models.append(Generator(dim=CFG['STG_DIM']))\n",
    "\n",
    "models[1].load_state_dict(torch.load(model1_path))\n",
    "models[2].load_state_dict(torch.load(model2_path))\n",
    "models[3].load_state_dict(torch.load(model3_path))\n",
    "models[4].load_state_dict(torch.load(model4_path))\n",
    "\n",
    "for model in models:\n",
    "    if model:\n",
    "        model.to(device)\n",
    "        model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|                                                                                        | 0/86652 [00:00<?, ?it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1008x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ST_set_save = ST_Simul_Dataset_Save(df_simul)\n",
    "ST_loader_save = DataLoader(ST_set_save, batch_size=1)\n",
    "\n",
    "with torch.no_grad():\n",
    "  for sem, depth, case, idx in tqdm(iter(ST_loader_save)):\n",
    "    sem = sem.to(device)\n",
    "    idx = int(idx)\n",
    "    case = int(case)\n",
    "    \n",
    "    fake_ST = models[case](sem)\n",
    "\n",
    "    model_pred = (fake_ST + 1) * 212 / 2\n",
    "    model_pred = model_pred.cpu().numpy()[0][0]\n",
    "    \n",
    "    sem = (sem + 1)*212\n",
    "    sem = sem.cpu().numpy()[0][0]\n",
    "    \n",
    "    depth = depth.cpu().numpy()[0]\n",
    "    \n",
    "    imgname = ['sim1_st', 'sim1_orig', 'sim1_depth']\n",
    "    imgs = [model_pred, sem, depth]\n",
    "    plt.figure(figsize=(14, 5))\n",
    "    for i, img in enumerate(imgs) :\n",
    "        plt.subplot(1,len(imgs),i+1)\n",
    "        plt.title(imgname[i])\n",
    "        plt.axis('off') \n",
    "        plt.imshow(img[:,:], cmap='gray')\n",
    "    \n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████| 86652/86652 [12:20<00:00, 117.05it/s]\n"
     ]
    }
   ],
   "source": [
    "from os.path import join as opj\n",
    "\n",
    "Depth_dir = f'./processed_data/simulation/Depth'\n",
    "Simul_dir = f'./processed_data/simulation/SEM'\n",
    "\n",
    "os.makedirs(Depth_dir, exist_ok=True)\n",
    "os.makedirs(Simul_dir, exist_ok=True)\n",
    "\n",
    "ST_set_save = ST_Simul_Dataset_Save(df_simul)\n",
    "ST_loader_save = DataLoader(ST_set_save, batch_size=1)\n",
    "\n",
    "with torch.no_grad():\n",
    "  for sem, depth, case, idx in tqdm(iter(ST_loader_save)):\n",
    "    sem = sem.to(device)\n",
    "    idx = int(idx)\n",
    "    case = int(case)\n",
    "    \n",
    "    fake_ST = models[case](sem)\n",
    "\n",
    "    model_pred = (fake_ST + 1) * 212 / 2\n",
    "    model_pred = model_pred.cpu().numpy()[0][0]\n",
    "    \n",
    "    depth = depth.cpu().numpy()[0]\n",
    "    \n",
    "    simulation_save_path = opj(Simul_dir, f'SEM_{case}_{str(idx).zfill(5)}.png')\n",
    "    depth_save_path = opj(Depth_dir, f'Depth_{case}_{str(idx).zfill(5)}.png')\n",
    "    \n",
    "    cv2.imwrite(simulation_save_path, model_pred)\n",
    "    cv2.imwrite(depth_save_path, depth)"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "provenance": []
  },
  "gpuClass": "standard",
  "kernelspec": {
   "display_name": "Python 3.9.12 ('base')",
   "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.12"
  },
  "vscode": {
   "interpreter": {
    "hash": "24f4f8817329ddfaf02b54d63eb7c3e45c779aba8b44a116056b96860c8e6725"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}