medt-cxr-with-masks.ipynb

{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":7217573,"sourceType":"datasetVersion","datasetId":4177129}],"dockerImageVersionId":30627,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"%load_ext autoreload\n%autoreload 2","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2023-12-18T13:50:33.002718Z","iopub.execute_input":"2023-12-18T13:50:33.003644Z","iopub.status.idle":"2023-12-18T13:50:33.032210Z","shell.execute_reply.started":"2023-12-18T13:50:33.003607Z","shell.execute_reply":"2023-12-18T13:50:33.031483Z"},"trusted":true},"execution_count":1,"outputs":[]},{"cell_type":"code","source":"import pdb\nimport math\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport matplotlib.pyplot as plt\nimport random\n# use this seed function to make sure the result is reproducible\ndef reset_seed():\n  torch.manual_seed(42)\n  random.seed(42)\n  torch.cuda.manual_seed(42)\nimport torch.nn as nn\nfrom torch.autograd import Variable\nfrom torchvision import transforms\nfrom torch.utils.data.dataset import Dataset\nimport matplotlib.pyplot as plt\nimport pandas as pd\nimport torchvision\nfrom torch.utils.data import DataLoader\nfrom PIL import Image\nimport os\nimport albumentations as A\nfrom albumentations.pytorch import ToTensorV2\nimport numpy as np\nimport cv2\n","metadata":{"execution":{"iopub.status.busy":"2023-12-18T13:50:33.033570Z","iopub.execute_input":"2023-12-18T13:50:33.033822Z","iopub.status.idle":"2023-12-18T13:50:38.065934Z","shell.execute_reply.started":"2023-12-18T13:50:33.033799Z","shell.execute_reply":"2023-12-18T13:50:38.065145Z"},"trusted":true},"execution_count":2,"outputs":[{"name":"stderr","text":"/opt/conda/lib/python3.10/site-packages/scipy/__init__.py:146: UserWarning: A NumPy version >=1.16.5 and <1.23.0 is required for this version of SciPy (detected version 1.24.3\n  warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion}\"\n","output_type":"stream"}]},{"cell_type":"code","source":"import glob\nFIND_FOLDER = '/kaggle/input/chest-x-rays-with-masks/CXR with masks dataset/images' # replace this with your dataset directory\nimages_files = glob.glob(os.path.join(FIND_FOLDER, '*.png'))\nprint(len(images_files), \"Files Found.\")","metadata":{"execution":{"iopub.status.busy":"2023-12-18T13:50:38.066997Z","iopub.execute_input":"2023-12-18T13:50:38.067398Z","iopub.status.idle":"2023-12-18T13:50:38.663602Z","shell.execute_reply.started":"2023-12-18T13:50:38.067371Z","shell.execute_reply":"2023-12-18T13:50:38.662721Z"},"trusted":true},"execution_count":3,"outputs":[{"name":"stdout","text":"21303 Files Found.\n","output_type":"stream"}]},{"cell_type":"code","source":"# transferring data to folders \nimport os\nimport shutil\nimport numpy as np\n\n# Define your directories\nbase_dir = \"/kaggle/input/chest-x-rays-with-masks/CXR with masks dataset\"\nimages_dir = os.path.join(base_dir, 'images')\nmasks_dir = os.path.join(base_dir, 'masks')\n\n# Create new directories if they don't exist\nos.makedirs('trainimages', exist_ok=True)\nos.makedirs('trainmasks', exist_ok=True)\nos.makedirs('valimages', exist_ok=True)\nos.makedirs('valmasks', exist_ok=True)\n\n# Get a list of all image and mask names\nimage_names = os.listdir(images_dir)\nmask_names = os.listdir(masks_dir)\n\n# Shuffle the list of names\nnp.random.shuffle(image_names)\n\n# Split the names into training and validation sets (85-15 split)\ntrain_size = int(0.85 * len(image_names))\ntrain_image_names = image_names[:train_size]\nval_image_names = image_names[train_size:]\n\n# Copy the images and masks into the new directories\nfor name in train_image_names:\n    shutil.copy(os.path.join(images_dir, name), 'trainimages')\n    shutil.copy(os.path.join(masks_dir, name), 'trainmasks')\n\nfor name in val_image_names:\n    shutil.copy(os.path.join(images_dir, name), 'valimages')\n    shutil.copy(os.path.join(masks_dir, name), 'valmasks')","metadata":{"execution":{"iopub.status.busy":"2023-12-18T13:50:38.665653Z","iopub.execute_input":"2023-12-18T13:50:38.665989Z","iopub.status.idle":"2023-12-18T13:55:07.680440Z","shell.execute_reply.started":"2023-12-18T13:50:38.665962Z","shell.execute_reply":"2023-12-18T13:55:07.679593Z"},"trusted":true},"execution_count":4,"outputs":[]},{"cell_type":"code","source":"FIND_FOLDER = '/kaggle/working/trainimages'\nch = glob.glob(os.path.join(FIND_FOLDER, '*.png'))\nprint(len(ch), \"Files Found.\")\n","metadata":{"execution":{"iopub.status.busy":"2023-12-18T13:55:07.681687Z","iopub.execute_input":"2023-12-18T13:55:07.681999Z","iopub.status.idle":"2023-12-18T13:55:07.793550Z","shell.execute_reply.started":"2023-12-18T13:55:07.681972Z","shell.execute_reply":"2023-12-18T13:55:07.792715Z"},"trusted":true},"execution_count":5,"outputs":[{"name":"stdout","text":"18107 Files Found.\n","output_type":"stream"}]},{"cell_type":"code","source":"class QU_Dataset(Dataset):\n  def __init__(self, image_dir, mask_dir, transform=None, state=None):\n    self.image_dir = image_dir\n    self.mask_dir = mask_dir\n    self.transform = transform\n    self.images = os.listdir(image_dir)\n\n  def __len__(self):\n    return len(self.images)\n\n  def __getitem__(self, index):\n    img_path = os.path.join(self.image_dir, self.images[index])\n    mask_path = os.path.join(self.mask_dir, self.images[index]).replace(\".png\",\".png\")\n    image = np.array(Image.open(img_path).convert(\"RGB\"))\n    NEW_IMAGE_HEIGHT = 128\n    NEW_IMAGE_WIDTH = 128\n    image = cv2.resize(image, (NEW_IMAGE_WIDTH, NEW_IMAGE_HEIGHT))\n\n    mask = np.array(Image.open(mask_path))\n    mask=cv2.resize(mask,(NEW_IMAGE_WIDTH, NEW_IMAGE_HEIGHT))\n    mask[mask >= 1] = 1.0\n\n    if self.transform is not None:\n      augmentations = self.transform(image=image, mask=mask)\n      image = augmentations[\"image\"]\n      mask = augmentations[\"mask\"]\n    return image, mask\n\nIMAGE_HEIGHT = 128\nIMAGE_WIDTH = 128\n\ntrain_transform = A.Compose(\n    [\n        A.Resize(height=IMAGE_HEIGHT, width=IMAGE_WIDTH),\n        A.Rotate(limit=35, p=1.0),\n        A.HorizontalFlip(p=0.5),\n        A.VerticalFlip(p=0.1),\n        A.Normalize(\n            mean = [0.0, 0.0, 0.0],\n            std = [1.0, 1.0, 1.0],\n            max_pixel_value = 255.0\n        ),\n        ToTensorV2(),\n    ])\nval_transform = A.Compose(\n    [\n        A.Resize(height=IMAGE_HEIGHT, width=IMAGE_WIDTH),\n        A.Normalize(\n            mean = [0.0, 0.0, 0.0],\n            std = [1.0, 1.0, 1.0],\n            max_pixel_value = 255.0\n        ),\n        ToTensorV2(),\n    ])\n\nTRAIN_DIR = '/kaggle/working/trainimages'\nTRAIN_MASK = '/kaggle/working/trainmasks'\nTEST_DIR = '/kaggle/working/valimages'\nTEST_MASK = '/kaggle/working/valmasks'\n\ntrain_ds1 = QU_Dataset(TRAIN_DIR, TRAIN_MASK, transform=train_transform)\ntrain_ds, val_ds = torch.utils.data.random_split(train_ds1,[17107,1000], generator=torch.Generator().manual_seed(42))\ntest_ds = QU_Dataset(TEST_DIR, TEST_MASK, transform=val_transform)\nreset_seed()\nBATCH_SIZE = 16\nNUM_WORKERS = 2\nIMAGE_HEIGHT = 128\nIMAGE_WIDTH = 128\nPIN_MEMORY = True\ntrain_loader = DataLoader(\n    train_ds1,\n    batch_size = BATCH_SIZE,\n    num_workers = NUM_WORKERS,\n    pin_memory = PIN_MEMORY,\n    shuffle=True,\n)\nval_loader = DataLoader(\n    val_ds,\n    batch_size=BATCH_SIZE,\n    num_workers = NUM_WORKERS,\n    pin_memory = PIN_MEMORY,\n    shuffle=False\n)\ntest_loader = DataLoader(\n    test_ds,\n    batch_size=BATCH_SIZE,\n    num_workers = NUM_WORKERS,\n    pin_memory = PIN_MEMORY,\n    shuffle=False\n)","metadata":{"execution":{"iopub.status.busy":"2023-12-18T13:55:07.794807Z","iopub.execute_input":"2023-12-18T13:55:07.795145Z","iopub.status.idle":"2023-12-18T13:55:07.891263Z","shell.execute_reply.started":"2023-12-18T13:55:07.795111Z","shell.execute_reply":"2023-12-18T13:55:07.890485Z"},"trusted":true},"execution_count":6,"outputs":[]},{"cell_type":"code","source":"for X, y in train_ds:\n  print(X.shape)\n  print(y.shape)\n  break","metadata":{"execution":{"iopub.status.busy":"2023-12-18T13:55:07.892243Z","iopub.execute_input":"2023-12-18T13:55:07.892486Z","iopub.status.idle":"2023-12-18T13:55:07.971795Z","shell.execute_reply.started":"2023-12-18T13:55:07.892464Z","shell.execute_reply":"2023-12-18T13:55:07.970843Z"},"trusted":true},"execution_count":7,"outputs":[{"name":"stdout","text":"torch.Size([3, 128, 128])\ntorch.Size([128, 128])\n","output_type":"stream"}]},{"cell_type":"code","source":"def conv1x1(in_planes, out_planes, stride=1):\n  return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)\n\nclass qkv_transform(nn.Conv1d):\n  \"\"\"Conv1d for qkv_transform\"\"\"\n# define Medical Transformer architecture\nclass AxialAttention(nn.Module):\n\n  def __init__(self,\n               in_planes,\n               out_planes,\n               groups=8,\n               kernel_size=56,\n               stride=1,\n               bias=False,\n               width=False):\n    \"\"\"\n    args :\n      in_planes : d_q\n      out_planes : d_out\n      groups : number heads\n      kernel_size : size of memory block\n    \"\"\"\n    super().__init__()\n    self.in_planes = in_planes\n    self.out_planes = out_planes\n    self.groups = groups\n    self.group_planes = out_planes // groups\n    self.kernel_size = kernel_size\n    self.stride = stride\n    self.bias = bias\n    self.width = width\n\n    # Multi-head self attention\n    # d_q = out_planes // 2, d_out = out_planes (out_planes = 16) => number of\n    self.qkv_transform = qkv_transform(in_planes, out_planes*2, kernel_size=1, stride=1,\n                                       padding=0, bias=False)\n    self.bn_qkv = nn.BatchNorm1d(out_planes * 2) # shape : q,k : (out_planes, d_q)\n    self.bn_similarity = nn.BatchNorm2d(groups * 3)\n    self.bn_output = nn.BatchNorm1d(out_planes * 2)\n\n    # position embedding\n    # (2 * kernel_size - 1) position : -(kernel_size-1),...,0,...,(kernel_size-1)\n    # number of channels = channels of r_q + channels of r_k + channels of r_v\n    # group_planes * 2   =  group_planes//2 * 2 + group_planes (dim value + dim query + dim key)\n    # => dim of embedding position : group_planes * 2 * (kernel_size * 2 - 1)\n    self.relative = nn.Parameter(torch.randn(self.group_planes * 2, kernel_size * 2 - 1), requires_grad=True)\n    query_index = torch.arange(kernel_size).unsqueeze(0)\n    key_index = torch.arange(kernel_size).unsqueeze(1)\n    relative_index = key_index - query_index + kernel_size - 1\n    self.register_buffer('flatten_index', relative_index.view(-1))\n    if stride > 1:\n      self.pooling = nn.AvgPool2d(stride, stride=stride)\n\n    self.reset_paremeters()\n\n  def forward(self, x):\n    # axial attention width-axis\n    if self.width:\n      x = x.permute(0, 2, 1, 3) # N, H, C, W\n    else:\n      x = x.permute(0, 3, 1, 2) # N, W, C, H\n    N, W, C, H = x.shape\n    x = x.contiguous().view(N*W, C, H)\n    # Transformations\n    qkv = self.bn_qkv(self.qkv_transform(x))\n    #print(x.shape)\n    #print(self.qkv_transform(x).shape)\n    q, k, v = torch.split(qkv.reshape(N*W, self.groups, self.group_planes * 2, H),\n                          [self.group_planes // 2, self.group_planes // 2, self.group_planes], dim=2)\n\n    # Calculate position embedding\n    # self.flatten_index : shape (kernel_size * kernel_size)\n    all_embedding = torch.index_select(self.relative, 1, self.flatten_index).view(self.group_planes * 2, self.kernel_size, self.kernel_size)\n    q_embedding, k_embedding, v_embedding = torch.split(all_embedding, [self.group_planes // 2, self.group_planes // 2, self.group_planes], dim=0)\n    qqn = q_embedding[0].detach().cpu().numpy()\n    #plt.imshow(qqn)\n    kqn = k_embedding[0].detach().cpu().numpy()\n    #plt.imshow(kqn)\n    # q : shape (N*W, number heads, self.group_planes // 2 = d_q, H)\n    # k : shape (N*W, number heads, self.group_planes // 2 = d_q, H)\n    # v : shape (N*W, number heads, self.group_planes = 2 * d_q, H)\n    # q_embedding : shape (self.group_planes // 2, kernel_size, kernel_size)\n    # k_embedding : shape (self.group_planes // 2, kernel_size, kernel_size)\n    # v_embedding : shape (self.group_planes, kernel_size, kernel_size)\n    # qr : shape (N*W, number heads, kernel_size, kernel_size)\n    # kr : shape (N*W, number heads, kernel_size, kernel_size)\n    # why transpose(2, 3) -> because index of equal (2) Medical-Transform\n    # qk : shape\n    qr = torch.einsum('bgci,cij->bgij', q, q_embedding)\n    kr = torch.einsum('bgci,cij->bgij', k, k_embedding).transpose(2, 3)\n    qk = torch.einsum('bgci,bgcj->bgij', q, k)\n    # batchnorm each qr, qk, kr before sum\n    stacked_similarity = torch.cat([qk, qr, kr], dim=1)\n    stacked_similarity = self.bn_similarity(stacked_similarity).view(N*W, 3, self.groups, H, H).sum(dim=1)\n    # stacked_similarity = self.bn_qr(qr) + self.bn_kr(kr) + self.bn_qk(qk)\n    # (N*W, groups, H, H)\n    similarity = F.softmax(stacked_similarity, dim=3)\n    sv = torch.einsum('bgij,bgcj->bgci', similarity, v)\n    sve = torch.einsum('bgij,cij->bgci', similarity, v_embedding)\n    stacked_output = torch.cat([sv, sve], dim=-1).view(N*W, self.out_planes*2, H)\n    output = self.bn_output(stacked_output).view(N, W, self.out_planes, 2, H).sum(dim=-2)\n\n    if self.width:\n      output = output.permute(0, 2, 1, 3)\n    else:\n      output = output.permute(0, 2, 3, 1)\n\n    if self.stride > 1:\n      output = self.pooling(output)\n    return output\n\n  def reset_paremeters(self):\n    self.qkv_transform.weight.data.normal_(0, math.sqrt(1. / self.in_planes))\n    nn.init.normal_(self.relative, 0, math.sqrt(1. / self.group_planes))\n# check this code to make sure the output shape is correct\n\"\"\"\nx_test : shape\n\"\"\"\nx_test = torch.randn(1, 256, 9, 9)\ngate = AxialAttention(in_planes=256,out_planes= 256,groups = 8,kernel_size= 9)\nb = gate(x_test)\nprint(x_test.shape)\nprint(b.shape)\nkernel_size = 5\nque_index = torch.arange(5).unsqueeze(0)\nkey_index = torch.arange(5).unsqueeze(1)\na = key_index - que_index + kernel_size - 1\nprint(a)\nb = a.view(-1)\na = torch.randn(4, kernel_size * 2 - 1)\nprint(f'a:{a}')\nprint(a.shape)\nprint(f'b:{b}')\nc = torch.index_select(a, 1, b).reshape(4, kernel_size, kernel_size)\n\"\"\"\nq, k, v = torch.split(c, [1, 1, 2], dim=0)\nprint(q, q.shape)\nprint(k, k.shape)\nprint(v, v.shape)\n\"\"\"\nc.shape","metadata":{"execution":{"iopub.status.busy":"2023-12-18T13:55:07.973097Z","iopub.execute_input":"2023-12-18T13:55:07.973347Z","iopub.status.idle":"2023-12-18T13:55:08.201440Z","shell.execute_reply.started":"2023-12-18T13:55:07.973325Z","shell.execute_reply":"2023-12-18T13:55:08.200503Z"},"trusted":true},"execution_count":8,"outputs":[{"name":"stdout","text":"torch.Size([1, 256, 9, 9])\ntorch.Size([1, 256, 9, 9])\ntensor([[4, 3, 2, 1, 0],\n        [5, 4, 3, 2, 1],\n        [6, 5, 4, 3, 2],\n        [7, 6, 5, 4, 3],\n        [8, 7, 6, 5, 4]])\na:tensor([[-0.3927,  0.2517,  1.4877, -0.4631, -1.0468,  1.8816, -0.1268,  1.9026,\n         -1.2905],\n        [-0.2800,  0.6117,  0.4961, -0.2166, -0.8644,  0.2344, -1.3138,  1.7738,\n          1.1965],\n        [-0.0136,  1.3046, -2.2844,  1.4070, -0.1787,  0.2277, -1.5650,  1.1589,\n          0.0232],\n        [ 0.0426, -0.0195, -0.3383, -1.6627,  0.9750,  0.0910, -0.2920, -0.0769,\n          1.2092]])\ntorch.Size([4, 9])\nb:tensor([4, 3, 2, 1, 0, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 7, 6, 5, 4, 3, 8, 7, 6, 5,\n        4])\n","output_type":"stream"},{"execution_count":8,"output_type":"execute_result","data":{"text/plain":"torch.Size([4, 5, 5])"},"metadata":{}}]},{"cell_type":"code","source":"class AxialAttention_dynamic(nn.Module):\n  def __init__(self,\n               in_planes,\n               out_planes,\n               groups=8,\n               kernel_size=56,\n               stride=1,\n               bias=False,\n               width=False):\n      assert (in_planes % groups == 0) and (out_planes % groups == 0)\n      super(AxialAttention_dynamic, self).__init__()\n      self.in_planes = in_planes\n      self.out_planes = out_planes\n      self.groups = groups\n      self.group_planes = out_planes // groups\n      self.kernel_size = kernel_size\n      self.stride = stride\n      self.bias = bias\n      self.width = width\n\n      # Multi-head self attention\n      self.qkv_transform = qkv_transform(in_planes, out_planes * 2, kernel_size=1, stride=1,\n                                          padding=0, bias=False)\n      self.bn_qkv = nn.BatchNorm1d(out_planes * 2)\n      self.bn_similarity = nn.BatchNorm2d(groups * 3)\n      self.bn_output = nn.BatchNorm1d(out_planes * 2)\n\n      # Priority on encoding\n\n      ## Initial values\n\n      self.f_qr = nn.Parameter(torch.tensor(0.1),  requires_grad=False)\n      self.f_kr = nn.Parameter(torch.tensor(0.1),  requires_grad=False)\n      self.f_sve = nn.Parameter(torch.tensor(0.1),  requires_grad=False)\n      self.f_sv = nn.Parameter(torch.tensor(1.0),  requires_grad=False)\n\n\n      # Position embedding\n      self.relative = nn.Parameter(torch.randn(self.group_planes * 2, kernel_size * 2 - 1), requires_grad=True)\n      query_index = torch.arange(kernel_size).unsqueeze(0)\n      key_index = torch.arange(kernel_size).unsqueeze(1)\n      relative_index = key_index - query_index + kernel_size - 1\n      self.register_buffer('flatten_index', relative_index.view(-1))\n      if stride > 1:\n          self.pooling = nn.AvgPool2d(stride, stride=stride)\n\n      self.reset_parameters()\n      # self.print_para()\n\n  def forward(self, x):\n      if self.width:\n          x = x.permute(0, 2, 1, 3)\n      else:\n          x = x.permute(0, 3, 1, 2)  # N, W, C, H\n      N, W, C, H = x.shape\n      x = x.contiguous().view(N * W, C, H)\n\n      # Transformations\n      qkv = self.bn_qkv(self.qkv_transform(x))\n      q, k, v = torch.split(qkv.reshape(N * W, self.groups, self.group_planes * 2, H), [self.group_planes // 2, self.group_planes // 2, self.group_planes], dim=2)\n\n      # Calculate position embedding\n      all_embeddings = torch.index_select(self.relative, 1, self.flatten_index).view(self.group_planes * 2, self.kernel_size, self.kernel_size)\n      q_embedding, k_embedding, v_embedding = torch.split(all_embeddings, [self.group_planes // 2, self.group_planes // 2, self.group_planes], dim=0)\n      qr = torch.einsum('bgci,cij->bgij', q, q_embedding)\n      kr = torch.einsum('bgci,cij->bgij', k, k_embedding).transpose(2, 3)\n      qk = torch.einsum('bgci, bgcj->bgij', q, k)\n\n\n      # multiply by factors\n      qr = torch.mul(qr, self.f_qr)\n      kr = torch.mul(kr, self.f_kr)\n\n      stacked_similarity = torch.cat([qk, qr, kr], dim=1)\n      stacked_similarity = self.bn_similarity(stacked_similarity).view(N * W, 3, self.groups, H, H).sum(dim=1)\n      #stacked_similarity = self.bn_qr(qr) + self.bn_kr(kr) + self.bn_qk(qk)\n      # (N, groups, H, H, W)\n      similarity = F.softmax(stacked_similarity, dim=3)\n      sv = torch.einsum('bgij,bgcj->bgci', similarity, v)\n      sve = torch.einsum('bgij,cij->bgci', similarity, v_embedding)\n\n      # multiply by factors\n      sv = torch.mul(sv, self.f_sv)\n      sve = torch.mul(sve, self.f_sve)\n\n      stacked_output = torch.cat([sv, sve], dim=-1).view(N * W, self.out_planes * 2, H)\n      output = self.bn_output(stacked_output).view(N, W, self.out_planes, 2, H).sum(dim=-2)\n\n      if self.width:\n          output = output.permute(0, 2, 1, 3)\n      else:\n          output = output.permute(0, 2, 3, 1)\n\n      if self.stride > 1:\n          output = self.pooling(output)\n\n      return output\n  def reset_parameters(self):\n      self.qkv_transform.weight.data.normal_(0, math.sqrt(1. / self.in_planes))\n      #nn.init.uniform_(self.relative, -0.1, 0.1)\n      nn.init.normal_(self.relative, 0., math.sqrt(1. / self.group_planes))\nclass AxialAttention_wopos(nn.Module):\n  def __init__(self, in_planes, out_planes, groups=8, kernel_size=56,\n                stride=1, bias=False, width=False):\n      assert (in_planes % groups == 0) and (out_planes % groups == 0)\n      super(AxialAttention_wopos, self).__init__()\n      self.in_planes = in_planes\n      self.out_planes = out_planes\n      self.groups = groups\n      self.group_planes = out_planes // groups\n      self.kernel_size = kernel_size\n      self.stride = stride\n      self.bias = bias\n      self.width = width\n\n      # Multi-head self attention\n      self.qkv_transform = qkv_transform(in_planes, out_planes * 2, kernel_size=1, stride=1,\n                                          padding=0, bias=False)\n      self.bn_qkv = nn.BatchNorm1d(out_planes * 2)\n      self.bn_similarity = nn.BatchNorm2d(groups )\n\n      self.bn_output = nn.BatchNorm1d(out_planes * 1)\n\n      if stride > 1:\n          self.pooling = nn.AvgPool2d(stride, stride=stride)\n\n      self.reset_parameters()\n\n  def forward(self, x):\n      if self.width:\n          x = x.permute(0, 2, 1, 3)\n      else:\n          x = x.permute(0, 3, 1, 2)  # N, W, C, H\n      N, W, C, H = x.shape\n      x = x.contiguous().view(N * W, C, H)\n\n      # Transformations\n      qkv = self.bn_qkv(self.qkv_transform(x))\n      q, k, v = torch.split(qkv.reshape(N * W, self.groups, self.group_planes * 2, H), [self.group_planes // 2, self.group_planes // 2, self.group_planes], dim=2)\n\n      qk = torch.einsum('bgci, bgcj->bgij', q, k)\n\n      stacked_similarity = self.bn_similarity(qk).reshape(N * W, 1, self.groups, H, H).sum(dim=1).contiguous()\n\n      similarity = F.softmax(stacked_similarity, dim=3)\n      sv = torch.einsum('bgij,bgcj->bgci', similarity, v)\n\n      sv = sv.reshape(N*W,self.out_planes * 1, H).contiguous()\n      output = self.bn_output(sv).reshape(N, W, self.out_planes, 1, H).sum(dim=-2).contiguous()\n\n\n      if self.width:\n          output = output.permute(0, 2, 1, 3)\n      else:\n          output = output.permute(0, 2, 3, 1)\n\n      if self.stride > 1:\n          output = self.pooling(output)\n\n      return output\n\n  def reset_parameters(self):\n      self.qkv_transform.weight.data.normal_(0, math.sqrt(1. / self.in_planes))\n      #nn.init.uniform_(self.relative, -0.1, 0.1)\n      # nn.init.normal_(self.relative, 0., math.sqrt(1. / self.group_planes))\nclass AxialBlock(nn.Module):\n  expansion = 2\n\n  def __init__(self,\n               inplanes,\n               planes,\n               stride=1,\n               downsample=None,\n               groups=1,\n               base_width=64,\n               dilation=1,\n               norm_layer=None,\n               kernel_size=56):\n    super().__init__()\n    if norm_layer is None:\n      norm_layer = nn.BatchNorm2d\n    width = int(planes * (base_width / 64.))\n    # Both self.conv2 and self.downsample layers downsample the input when stride != 1\n    self.groups = groups\n    self.conv_down = conv1x1(inplanes, width)\n    self.bn1 = norm_layer(width)\n    self.hight_block = AxialAttention(width, width, groups=groups, kernel_size=kernel_size)\n    self.width_block = AxialAttention(width, width, groups=groups, kernel_size=kernel_size, width=True)\n    self.conv_up = conv1x1(width, planes*self.expansion)\n    self.bn2 = norm_layer(planes * self.expansion)\n    self.relu = nn.ReLU(inplace=True)\n    self.downsample = downsample\n    self.stride = stride\n\n  def forward(self, x):\n    identity = x\n\n    out = self.conv_down(x)\n    out = self.bn1(out)\n    out = self.relu(out)\n\n    out = self.hight_block(out)\n    out = self.width_block(out)\n    out = self.relu(out)\n\n    out = self.conv_up(out)\n    out = self.bn2(out)\n\n    if self.downsample is not None:\n      identity = self.downsample(x)\n\n    out += identity\n    out = self.relu(out)\n\n    return out\nclass AxialBlock_dynamic(nn.Module):\n  expansion = 2\n\n  def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,\n                base_width=64, dilation=1, norm_layer=None, kernel_size=56):\n      super(AxialBlock_dynamic, self).__init__()\n      if norm_layer is None:\n          norm_layer = nn.BatchNorm2d\n      width = int(planes * (base_width / 64.))\n      # Both self.conv2 and self.downsample layers downsample the input when stride != 1\n      self.conv_down = conv1x1(inplanes, width)\n      self.bn1 = norm_layer(width)\n      self.hight_block = AxialAttention_dynamic(width, width, groups=groups, kernel_size=kernel_size)\n      self.width_block = AxialAttention_dynamic(width, width, groups=groups, kernel_size=kernel_size, stride=stride, width=True)\n      self.conv_up = conv1x1(width, planes * self.expansion)\n      self.bn2 = norm_layer(planes * self.expansion)\n      self.relu = nn.ReLU(inplace=True)\n      self.downsample = downsample\n      self.stride = stride\n\n  def forward(self, x):\n      identity = x\n\n      out = self.conv_down(x)\n      out = self.bn1(out)\n      out = self.relu(out)\n\n      out = self.hight_block(out)\n      out = self.width_block(out)\n      out = self.relu(out)\n\n      out = self.conv_up(out)\n      out = self.bn2(out)\n\n      if self.downsample is not None:\n          identity = self.downsample(x)\n      #print(out.shape)\n      #print(identity.shape)\n      out += identity\n      out = self.relu(out)\n\n      return out\nclass AxialBlock_wopos(nn.Module):\n  expansion = 2\n\n  def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,\n                base_width=64, dilation=1, norm_layer=None, kernel_size=56):\n      super(AxialBlock_wopos, self).__init__()\n      if norm_layer is None:\n          norm_layer = nn.BatchNorm2d\n      # print(kernel_size)\n      width = int(planes * (base_width / 64.))\n      # Both self.conv2 and self.downsample layers downsample the input when stride != 1\n      self.conv_down = conv1x1(inplanes, width)\n      self.conv1 = nn.Conv2d(width, width, kernel_size = 1)\n      self.bn1 = norm_layer(width)\n      self.hight_block = AxialAttention_wopos(width, width, groups=groups, kernel_size=kernel_size)\n      self.width_block = AxialAttention_wopos(width, width, groups=groups, kernel_size=kernel_size, stride=stride, width=True)\n      self.conv_up = conv1x1(width, planes * self.expansion)\n      self.bn2 = norm_layer(planes * self.expansion)\n      self.relu = nn.ReLU(inplace=True)\n      self.downsample = downsample\n      self.stride = stride\n\n  def forward(self, x):\n      identity = x\n\n      # pdb.set_trace()\n\n      out = self.conv_down(x)\n      out = self.bn1(out)\n      out = self.relu(out)\n      # print(out.shape)\n      out = self.hight_block(out)\n      out = self.width_block(out)\n\n      out = self.relu(out)\n\n      out = self.conv_up(out)\n      out = self.bn2(out)\n\n      if self.downsample is not None:\n          identity = self.downsample(x)\n\n      out += identity\n      out = self.relu(out)\n\n      return out\nclass ResAxialAttentionUNet(nn.Module):\n\n  def __init__(self, block, layers, num_classes=2, zero_init_residual=True,\n                groups=8, width_per_group=64, replace_stride_with_dilation=None,\n                norm_layer=None, s=0.125, img_size = 128,imgchan = 3):\n      super(ResAxialAttentionUNet, self).__init__()\n      if norm_layer is None:\n          norm_layer = nn.BatchNorm2d\n      self._norm_layer = norm_layer\n\n      self.inplanes = int(64 * s)\n      self.dilation = 1\n      if replace_stride_with_dilation is None:\n          replace_stride_with_dilation = [False, False, False]\n      if len(replace_stride_with_dilation) != 3:\n          raise ValueError(\"replace_stride_with_dilation should be None \"\n                            \"or a 3-element tuple, got {}\".format(replace_stride_with_dilation))\n      self.groups = groups\n      self.base_width = width_per_group\n      self.conv1 = nn.Conv2d(imgchan, self.inplanes, kernel_size=7, stride=2, padding=3,\n                              bias=False)\n      self.conv2 = nn.Conv2d(self.inplanes, 128, kernel_size=3, stride=1, padding=1, bias=False)\n      self.conv3 = nn.Conv2d(128, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False)\n      self.bn1 = norm_layer(self.inplanes)\n      self.bn2 = norm_layer(128)\n      self.bn3 = norm_layer(self.inplanes)\n      self.relu = nn.ReLU(inplace=True)\n      # self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n      self.layer1 = self._make_layer(block, int(128 * s), layers[0], kernel_size= (img_size//2))\n      self.layer2 = self._make_layer(block, int(256 * s), layers[1], stride=2, kernel_size=(img_size//2),\n                                      dilate=replace_stride_with_dilation[0])\n      self.layer3 = self._make_layer(block, int(512 * s), layers[2], stride=2, kernel_size=(img_size//4),\n                                      dilate=replace_stride_with_dilation[1])\n      self.layer4 = self._make_layer(block, int(1024 * s), layers[3], stride=2, kernel_size=(img_size//8),\n                                      dilate=replace_stride_with_dilation[2])\n\n      # Decoder\n      self.decoder1 = nn.Conv2d(int(1024 *2*s)      ,        int(1024*2*s), kernel_size=3, stride=2, padding=1)\n      self.decoder2 = nn.Conv2d(int(1024  *2*s)     , int(1024*s), kernel_size=3, stride=1, padding=1)\n      self.decoder3 = nn.Conv2d(int(1024*s),  int(512*s), kernel_size=3, stride=1, padding=1)\n      self.decoder4 = nn.Conv2d(int(512*s) ,  int(256*s), kernel_size=3, stride=1, padding=1)\n      self.decoder5 = nn.Conv2d(int(256*s) , int(128*s) , kernel_size=3, stride=1, padding=1)\n      self.adjust   = nn.Conv2d(int(128*s) , num_classes, kernel_size=1, stride=1, padding=0)\n      self.soft     = nn.Softmax(dim=1)\n\n\n  def _make_layer(self, block, planes, blocks, kernel_size=56, stride=1, dilate=False):\n      norm_layer = self._norm_layer\n      downsample = None\n      previous_dilation = self.dilation\n      if dilate:\n          self.dilation *= stride\n          stride = 1\n      if stride != 1 or self.inplanes != planes * block.expansion:\n          downsample = nn.Sequential(\n              conv1x1(self.inplanes, planes * block.expansion, stride),\n              norm_layer(planes * block.expansion),\n          )\n\n      layers = []\n      layers.append(block(self.inplanes, planes, stride, downsample, groups=self.groups,\n                          base_width=self.base_width, dilation=previous_dilation,\n                          norm_layer=norm_layer, kernel_size=kernel_size))\n      self.inplanes = planes * block.expansion\n      if stride != 1:\n          kernel_size = kernel_size // 2\n\n      for _ in range(1, blocks):\n          layers.append(block(self.inplanes, planes, groups=self.groups,\n                              base_width=self.base_width, dilation=self.dilation,\n                              norm_layer=norm_layer, kernel_size=kernel_size))\n\n      return nn.Sequential(*layers)\n\n  def _forward_impl(self, x):\n\n      # AxialAttention Encoder\n      # pdb.set_trace()\n      x = self.conv1(x)\n      x = self.bn1(x)\n      x = self.relu(x)\n      x = self.conv2(x)\n      x = self.bn2(x)\n      x = self.relu(x)\n      x = self.conv3(x)\n      x = self.bn3(x)\n      x = self.relu(x)\n      #print(x.shape)\n      x1 = self.layer1(x)\n      #print(x.shape)\n      x2 = self.layer2(x1)\n      # print(x2.shape)\n      x3 = self.layer3(x2)\n      # print(x3.shape)\n      x4 = self.layer4(x3)\n\n      x = F.relu(F.interpolate(self.decoder1(x4), scale_factor=(2,2), mode ='bilinear'))\n      x = torch.add(x, x4)\n      x = F.relu(F.interpolate(self.decoder2(x) , scale_factor=(2,2), mode ='bilinear'))\n      x = torch.add(x, x3)\n      x = F.relu(F.interpolate(self.decoder3(x) , scale_factor=(2,2), mode ='bilinear'))\n      x = torch.add(x, x2)\n      x = F.relu(F.interpolate(self.decoder4(x) , scale_factor=(2,2), mode ='bilinear'))\n      x = torch.add(x, x1)\n      x = F.relu(F.interpolate(self.decoder5(x) , scale_factor=(2,2), mode ='bilinear'))\n      x = self.adjust(F.relu(x))\n      # pdb.set_trace()\n      return x\n\n  def forward(self, x):\n      return self._forward_impl(x)\nclass medt_net(nn.Module):\n\n  def __init__(self, block, block_2, layers, num_classes=2, zero_init_residual=True,\n              groups=8, width_per_group=64, replace_stride_with_dilation=None,\n              norm_layer=None, s=0.125, img_size = 128,imgchan = 3):\n    super(medt_net, self).__init__()\n    if norm_layer is None:\n        norm_layer = nn.BatchNorm2d\n    self._norm_layer = norm_layer\n\n    self.inplanes = int(64 * s)\n    self.dilation = 1\n    if replace_stride_with_dilation is None:\n        replace_stride_with_dilation = [False, False, False]\n    if len(replace_stride_with_dilation) != 3:\n        raise ValueError(\"replace_stride_with_dilation should be None \"\n                          \"or a 3-element tuple, got {}\".format(replace_stride_with_dilation))\n    self.groups = groups\n    self.base_width = width_per_group\n    self.conv1 = nn.Conv2d(imgchan, self.inplanes, kernel_size=7, stride=2, padding=3,\n                            bias=False)\n    self.conv2 = nn.Conv2d(self.inplanes, 128, kernel_size=3, stride=1, padding=1, bias=False)\n    self.conv3 = nn.Conv2d(128, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False)\n    self.bn1 = norm_layer(self.inplanes)\n    self.bn2 = norm_layer(128)\n    self.bn3 = norm_layer(self.inplanes)\n    # self.conv1 = nn.Conv2d(1, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False)\n    self.bn1 = norm_layer(self.inplanes)\n    self.relu = nn.ReLU(inplace=True)\n    # self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n    self.layer1 = self._make_layer(block, int(128 * s), layers[0], kernel_size= (img_size//2))\n    self.layer2 = self._make_layer(block, int(256 * s), layers[1], stride=2, kernel_size=(img_size//2),\n                                    dilate=replace_stride_with_dilation[0])\n    # self.layer3 = self._make_layer(block, int(512 * s), layers[2], stride=2, kernel_size=(img_size//4),\n    #                                dilate=replace_stride_with_dilation[1])\n    # self.layer4 = self._make_layer(block, int(1024 * s), layers[3], stride=2, kernel_size=(img_size//8),\n    #                                dilate=replace_stride_with_dilation[2])\n\n    # Decoder\n    # self.decoder1 = nn.Conv2d(int(1024 *2*s)      ,        int(1024*2*s), kernel_size=3, stride=2, padding=1)\n    # self.decoder2 = nn.Conv2d(int(1024  *2*s)     , int(1024*s), kernel_size=3, stride=1, padding=1)\n    # self.decoder3 = nn.Conv2d(int(1024*s),  int(512*s), kernel_size=3, stride=1, padding=1)\n    self.decoder4 = nn.Conv2d(int(512*s) ,  int(256*s), kernel_size=3, stride=1, padding=1)\n    self.decoder5 = nn.Conv2d(int(256*s) , int(128*s) , kernel_size=3, stride=1, padding=1)\n    self.adjust   = nn.Conv2d(int(128*s) , num_classes, kernel_size=1, stride=1, padding=0)\n    self.soft     = nn.Softmax(dim=1)\n\n\n    self.conv1_p = nn.Conv2d(imgchan, self.inplanes, kernel_size=7, stride=2, padding=3,\n                            bias=False)\n    self.conv2_p = nn.Conv2d(self.inplanes,128, kernel_size=3, stride=1, padding=1,\n                            bias=False)\n    self.conv3_p = nn.Conv2d(128, self.inplanes, kernel_size=3, stride=1, padding=1,\n                            bias=False)\n    # self.conv1 = nn.Conv2d(1, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False)\n    self.bn1_p = norm_layer(self.inplanes)\n    self.bn2_p = norm_layer(128)\n    self.bn3_p = norm_layer(self.inplanes)\n\n    self.relu_p = nn.ReLU(inplace=True)\n\n    img_size_p = img_size // 4\n\n    self.layer1_p = self._make_layer(block_2, int(128 * s), layers[0], kernel_size= (img_size_p//2))\n    self.layer2_p = self._make_layer(block_2, int(256 * s), layers[1], stride=2, kernel_size=(img_size_p//2),\n                                    dilate=replace_stride_with_dilation[0])\n    self.layer3_p = self._make_layer(block_2, int(512 * s), layers[2], stride=2, kernel_size=(img_size_p//4),\n                                    dilate=replace_stride_with_dilation[1])\n    self.layer4_p = self._make_layer(block_2, int(1024 * s), layers[3], stride=2, kernel_size=(img_size_p//8),\n                                    dilate=replace_stride_with_dilation[2])\n\n    # Decoder\n    self.decoder1_p = nn.Conv2d(int(1024 *2*s)      ,        int(1024*2*s), kernel_size=3, stride=2, padding=1)\n    self.decoder2_p = nn.Conv2d(int(1024  *2*s)     , int(1024*s), kernel_size=3, stride=1, padding=1)\n    self.decoder3_p = nn.Conv2d(int(1024*s),  int(512*s), kernel_size=3, stride=1, padding=1)\n    self.decoder4_p = nn.Conv2d(int(512*s) ,  int(256*s), kernel_size=3, stride=1, padding=1)\n    self.decoder5_p = nn.Conv2d(int(256*s) , int(128*s) , kernel_size=3, stride=1, padding=1)\n\n    self.decoderf = nn.Conv2d(int(128*s) , int(128*s) , kernel_size=3, stride=1, padding=1)\n    self.adjust_p   = nn.Conv2d(int(128*s) , num_classes, kernel_size=1, stride=1, padding=0)\n    self.soft_p     = nn.Softmax(dim=1)\n\n\n  def _make_layer(self, block, planes, blocks, kernel_size=56, stride=1, dilate=False):\n    norm_layer = self._norm_layer\n    downsample = None\n    previous_dilation = self.dilation\n    if dilate:\n        self.dilation *= stride\n        stride = 1\n    if stride != 1 or self.inplanes != planes * block.expansion:\n        downsample = nn.Sequential(\n            conv1x1(self.inplanes, planes * block.expansion, stride),\n            norm_layer(planes * block.expansion),\n        )\n\n    layers = []\n    layers.append(block(self.inplanes, planes, stride, downsample, groups=self.groups,\n                        base_width=self.base_width, dilation=previous_dilation,\n                        norm_layer=norm_layer, kernel_size=kernel_size))\n    self.inplanes = planes * block.expansion\n    if stride != 1:\n        kernel_size = kernel_size // 2\n\n    for _ in range(1, blocks):\n        layers.append(block(self.inplanes, planes, groups=self.groups,\n                            base_width=self.base_width, dilation=self.dilation,\n                            norm_layer=norm_layer, kernel_size=kernel_size))\n\n    return nn.Sequential(*layers)\n\n  def _forward_impl(self, x):\n\n    xin = x.clone()\n    x = self.conv1(x)\n    x = self.bn1(x)\n    x = self.relu(x)\n    x = self.conv2(x)\n    x = self.bn2(x)\n    x = self.relu(x)\n    x = self.conv3(x)\n    x = self.bn3(x)\n    # x = F.max_pool2d(x,2,2)\n    x = self.relu(x)\n\n    # x = self.maxpool(x)\n    # pdb.set_trace()\n    x1 = self.layer1(x)\n    # print(x1.shape)\n    x2 = self.layer2(x1)\n    # print(x2.shape)\n    # x3 = self.layer3(x2)\n    # # print(x3.shape)\n    # x4 = self.layer4(x3)\n    # # print(x4.shape)\n    # x = F.relu(F.interpolate(self.decoder1(x4), scale_factor=(2,2), mode ='bilinear'))\n    # x = torch.add(x, x4)\n    # x = F.relu(F.interpolate(self.decoder2(x4) , scale_factor=(2,2), mode ='bilinear'))\n    # x = torch.add(x, x3)\n    # x = F.relu(F.interpolate(self.decoder3(x3) , scale_factor=(2,2), mode ='bilinear'))\n    # x = torch.add(x, x2)\n    x = F.relu(F.interpolate(self.decoder4(x2) , scale_factor=(2,2), mode ='bilinear'))\n    x = torch.add(x, x1)\n    x = F.relu(F.interpolate(self.decoder5(x) , scale_factor=(2,2), mode ='bilinear'))\n    # print(x.shape)\n\n    # end of full image training\n\n    # y_out = torch.ones((1,2,128,128))\n    x_loc = x.clone()\n    # x = F.relu(F.interpolate(self.decoder5(x) , scale_factor=(2,2), mode ='bilinear'))\n    #start\n    for i in range(0,4):\n        for j in range(0,4):\n\n            x_p = xin[:,:,32*i:32*(i+1),32*j:32*(j+1)]\n            # begin patch wise\n            x_p = self.conv1_p(x_p)\n            x_p = self.bn1_p(x_p)\n            # x = F.max_pool2d(x,2,2)\n            x_p = self.relu(x_p)\n\n            x_p = self.conv2_p(x_p)\n            x_p = self.bn2_p(x_p)\n            # x = F.max_pool2d(x,2,2)\n            x_p = self.relu(x_p)\n            x_p = self.conv3_p(x_p)\n            x_p = self.bn3_p(x_p)\n            # x = F.max_pool2d(x,2,2)\n            x_p = self.relu(x_p)\n\n            # x = self.maxpool(x)\n            # pdb.set_trace()\n            x1_p = self.layer1_p(x_p)\n            # print(x1.shape)\n            x2_p = self.layer2_p(x1_p)\n            # print(x2.shape)\n            x3_p = self.layer3_p(x2_p)\n            # # print(x3.shape)\n            x4_p = self.layer4_p(x3_p)\n\n            x_p = F.relu(F.interpolate(self.decoder1_p(x4_p), scale_factor=(2,2), mode ='bilinear'))\n            x_p = torch.add(x_p, x4_p)\n            x_p = F.relu(F.interpolate(self.decoder2_p(x_p) , scale_factor=(2,2), mode ='bilinear'))\n            x_p = torch.add(x_p, x3_p)\n            x_p = F.relu(F.interpolate(self.decoder3_p(x_p) , scale_factor=(2,2), mode ='bilinear'))\n            x_p = torch.add(x_p, x2_p)\n            x_p = F.relu(F.interpolate(self.decoder4_p(x_p) , scale_factor=(2,2), mode ='bilinear'))\n            x_p = torch.add(x_p, x1_p)\n            x_p = F.relu(F.interpolate(self.decoder5_p(x_p) , scale_factor=(2,2), mode ='bilinear'))\n\n            x_loc[:,:,32*i:32*(i+1),32*j:32*(j+1)] = x_p\n\n    x = torch.add(x,x_loc)\n    x = F.relu(self.decoderf(x))\n\n    x = self.adjust(F.relu(x))\n\n    # pdb.set_trace()\n    return x\n\n  def forward(self, x):\n    return self._forward_impl(x)","metadata":{"execution":{"iopub.status.busy":"2023-12-18T13:55:08.203033Z","iopub.execute_input":"2023-12-18T13:55:08.203289Z","iopub.status.idle":"2023-12-18T13:55:08.353181Z","shell.execute_reply.started":"2023-12-18T13:55:08.203267Z","shell.execute_reply":"2023-12-18T13:55:08.352334Z"},"trusted":true},"execution_count":9,"outputs":[]},{"cell_type":"code","source":"def gated(pretrained=True, **kwargs):\n  model = ResAxialAttentionUNet(AxialBlock_dynamic, [1, 2, 4, 1], s= 0.125, **kwargs)\n  return model\nnet = gated()\nx_test = torch.rand(1, 3, 128, 128)\nnet(x_test);\ndef MedT(pretrained=True, **kwargs):\n    model = medt_net(AxialBlock_dynamic,AxialBlock_wopos, [1, 2, 4, 1], s= 0.125,  **kwargs)\n    return model\n\ndef logo(pretrained=True, **kwargs):\n    model = medt_net(AxialBlock,AxialBlock, [1, 2, 4, 1], s= 0.125, **kwargs)\n    return model","metadata":{"execution":{"iopub.status.busy":"2023-12-18T13:55:08.355861Z","iopub.execute_input":"2023-12-18T13:55:08.356147Z","iopub.status.idle":"2023-12-18T13:55:08.744742Z","shell.execute_reply.started":"2023-12-18T13:55:08.356123Z","shell.execute_reply":"2023-12-18T13:55:08.743904Z"},"trusted":true},"execution_count":10,"outputs":[]},{"cell_type":"code","source":"import torch\nfrom torch.nn.functional import cross_entropy\nfrom torch.nn.modules.loss import _WeightedLoss\nEPSILON = 1e-32\n\nclass LogNLLLoss(_WeightedLoss):\n    __constants__ = ['weight', 'reduction', 'ignore_index']\n\n    def __init__(self, weight=None, size_average=None, reduce=None, reduction=None,\n                 ignore_index=-100):\n        super(LogNLLLoss, self).__init__(weight, size_average, reduce, reduction)\n        self.ignore_index = ignore_index\n\n    def forward(self, y_input, y_target):\n        # y_input = torch.log(y_input + EPSILON)\n        return cross_entropy(y_input, y_target, weight=self.weight,\n                             ignore_index=self.ignore_index)\n\n\ndef classwise_iou(output, gt):\n    \"\"\"\n    Args:\n        output: torch.Tensor of shape (n_batch, n_classes, image.shape)\n        gt: torch.LongTensor of shape (n_batch, image.shape)\n    \"\"\"\n    #dims = (0, *range(2, len(output.shape)))\n    #gt = torch.zeros_like(output).scatter_(1, gt[:, None, :], 1)\n    output = torch.argmax(output, dim=1)\n    intersection = output*gt\n    union = output + gt - intersection\n    #classwise_iou = (intersection.sum(dim=dims).float() + EPSILON) / (union.sum(dim=dims) + EPSILON)\n    classwise_iou = (intersection.sum().float() + EPSILON) / (union.sum() + EPSILON)\n    return classwise_iou\n\n\ndef classwise_f1(output, gt):\n    \"\"\"\n    Args:\n        output: torch.Tensor of shape (n_batch, n_classes, image.shape)\n        gt: torch.LongTensor of shape (n_batch, image.shape)\n    \"\"\"\n\n    epsilon = 1e-20\n    n_classes = output.shape[1]\n\n    output = torch.argmax(output, dim=1)\n    #print(output)\n    true_positives = torch.tensor([((output == i) * (gt == i)).sum() for i in range(n_classes)]).float()\n    true_positives = true_positives[1].item()\n    selected = ((output == 1)).sum().float()\n    relevant = ((gt == 1)).sum().float()\n    #selected = torch.tensor([(output == i).sum() for i in range(n_classes)]).float()\n    #relevant = torch.tensor([(gt == i).sum() for i in range(n_classes)]).float()\n    #print(\"relevant:\",relevant)\n    #print(\"selected:\",selected)\n\n    precision = (true_positives + epsilon) / (selected + epsilon)\n    recall = (true_positives + epsilon) / (relevant + epsilon)\n    #print(precision)\n    #print(recall)\n    classwise_f1 = 2 * (precision * recall) / (precision + recall)\n\n    return classwise_f1\n\n\ndef make_weighted_metric(classwise_metric):\n    \"\"\"\n    Args:\n        classwise_metric: classwise metric like classwise_IOU or classwise_F1\n    \"\"\"\n\n    def weighted_metric(output, gt, weights=None):\n\n        # dimensions to sum over\n        dims = (0, *range(2, len(output.shape)))\n\n        # default weights\n        if weights == None:\n            weights = torch.ones(output.shape[1]) / output.shape[1]\n        else:\n            # creating tensor if needed\n            if len(weights) != output.shape[1]:\n                raise ValueError(\"The number of weights must match with the number of classes\")\n            if not isinstance(weights, torch.Tensor):\n                weights = torch.tensor(weights)\n            # normalizing weights\n            weights /= torch.sum(weights)\n\n        classwise_scores = classwise_metric(output, gt).cpu()\n\n        return classwise_scores\n\n    return weighted_metric","metadata":{"execution":{"iopub.status.busy":"2023-12-18T13:55:08.746049Z","iopub.execute_input":"2023-12-18T13:55:08.746631Z","iopub.status.idle":"2023-12-18T13:55:08.802311Z","shell.execute_reply.started":"2023-12-18T13:55:08.746585Z","shell.execute_reply":"2023-12-18T13:55:08.801428Z"},"trusted":true},"execution_count":11,"outputs":[]},{"cell_type":"code","source":"#output, gt = torch.ones(3, 2, 5, 5), torch.ones(3, 5, 5).long()\ngt = torch.ones(3, 5, 5).long()\noutput = torch.stack([torch.zeros(3,5,5), torch.ones(3,5,5)], dim=1)\nprint(classwise_f1(output, gt))\nclasswise_iou(output, gt)","metadata":{"execution":{"iopub.status.busy":"2023-12-18T13:55:08.803532Z","iopub.execute_input":"2023-12-18T13:55:08.803887Z","iopub.status.idle":"2023-12-18T13:55:08.859320Z","shell.execute_reply.started":"2023-12-18T13:55:08.803854Z","shell.execute_reply":"2023-12-18T13:55:08.858591Z"},"trusted":true},"execution_count":12,"outputs":[{"name":"stdout","text":"tensor(1.)\n","output_type":"stream"},{"execution_count":12,"output_type":"execute_result","data":{"text/plain":"tensor(1.)"},"metadata":{}}]},{"cell_type":"code","source":"from tqdm import tqdm\n# define hyperparameters\nlr = 1e-3\nDEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\nNUM_EPOCHS = 10\nIMG_SIZE = 128\nIMG_CHANEL = 3\nsave_freq = 1\n# code to save checkpoints\ndef save_checkpoint(state, filename=\"medt_weights.pth.tar\"):\n    print(\"=>Saving checkpoint\")\n    torch.save(state, filename)\ndef load_checkpoint(checkpoint, model):\n    print(\"=> Loading checkpoint\")\n    model.load_state_dict(checkpoint[\"state_dict\"])\n# instantiate any architecture from above architectures defined\nmodel = MedT(img_size = IMG_SIZE, imgchan = IMG_CHANEL)\nmodel.cuda()\n#model.cpu()\ncriterion = LogNLLLoss()\noptimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=1e-5)\nscaler = torch.cuda.amp.GradScaler()\nreset_seed()\n# training functions\ndef train_fn(loader, model, optimizer, loss_fn, scaler):\n  train_running_loss = 0\n  counter = 0\n  loop = tqdm(loader)\n  for batch_idx, (data, targets) in enumerate(loop):\n    data = data.to(device=DEVICE)\n    targets = targets.long().to(DEVICE)\n\n    # forward\n\n    with torch.cuda.amp.autocast():\n      prediction = model(data)\n      loss = loss_fn(prediction, targets)\n    \n   \n    # backward\n    optimizer.zero_grad()\n    scaler.scale(loss).backward()\n    scaler.step(optimizer)\n    scaler.update()\n\n    # update tqdm loop\n    loop.set_postfix(loss = loss.item())\n    train_running_loss += loss.item()\n    counter += 1\n  return train_running_loss / counter\n\ndef check_accuracy(loader, model, loss_fn, device=\"cuda\"): # device can be cpu or cuda\n  my_f1 = 0\n  my_iou = 0\n  val_running_loss = 0\n  with torch.no_grad():\n    for X, y in loader:\n      batch_size = X.shape[0]\n      X = X.to(device)\n      y = y.long().to(device)\n      preds = model(X)\n      loss = loss_fn(preds, y)\n      val_running_loss += loss.item()\n      tmp = preds.detach().cpu()\n      tmp[tmp >= 0.5] = 1\n      tmp[tmp < 0.5] = 0\n      tmp2 = y.detach().cpu()\n\n\n      tmp = tmp.to(torch.int32)\n      my_f1 += classwise_f1(tmp, tmp2).item()\n      my_iou += classwise_iou(tmp, tmp2).item()\n  print(f\"IoU score: {my_iou/len(loader)}\")\n  print(f\"F1 score: {my_f1/len(loader)} \")\n  return val_running_loss\n","metadata":{"execution":{"iopub.status.busy":"2023-12-18T13:55:08.860605Z","iopub.execute_input":"2023-12-18T13:55:08.860901Z","iopub.status.idle":"2023-12-18T13:55:11.688851Z","shell.execute_reply.started":"2023-12-18T13:55:08.860878Z","shell.execute_reply":"2023-12-18T13:55:11.688082Z"},"trusted":true},"execution_count":13,"outputs":[]},{"cell_type":"code","source":"for param in model.parameters():\n    param.requires_grad = True","metadata":{"execution":{"iopub.status.busy":"2023-12-18T13:55:11.689964Z","iopub.execute_input":"2023-12-18T13:55:11.690251Z","iopub.status.idle":"2023-12-18T13:55:11.740349Z","shell.execute_reply.started":"2023-12-18T13:55:11.690226Z","shell.execute_reply":"2023-12-18T13:55:11.739483Z"},"trusted":true},"execution_count":14,"outputs":[]},{"cell_type":"code","source":"NUM_EPOCHS=4\n# training code\nloss_history = {\"train\":[], \"val\":[]}\nfor epoch in range(1, NUM_EPOCHS):\n  model.cuda()\n  #model.cpu()\n  print(f\"============Epoch {epoch} ============ \")\n  train_loss = train_fn(train_loader, model, optimizer, criterion, scaler)\n  \"\"\"\n  if epoch == 10:\n    for param in model.parameters():\n      param.requires_grad = True\n  \"\"\"\n  if (epoch % save_freq) == 0:\n    checkpoint = {\n        \"state_dict\": model.state_dict(),\n        \"optimizer\" : optimizer.state_dict(),\n    }\n    save_checkpoint(checkpoint)\n    val_loss = check_accuracy(test_loader, model, criterion, DEVICE)\n    loss_history[\"val\"].append(val_loss)\n    loss_history[\"train\"].append(train_loss)\n","metadata":{"execution":{"iopub.status.busy":"2023-12-18T13:55:11.741333Z","iopub.execute_input":"2023-12-18T13:55:11.741597Z","iopub.status.idle":"2023-12-18T14:42:51.695131Z","shell.execute_reply.started":"2023-12-18T13:55:11.741574Z","shell.execute_reply":"2023-12-18T14:42:51.694114Z"},"trusted":true},"execution_count":15,"outputs":[{"name":"stdout","text":"============Epoch 1 ============ \n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 1132/1132 [14:43<00:00,  1.28it/s, loss=0.166] ","output_type":"stream"},{"name":"stdout","text":"=>Saving checkpoint\n","output_type":"stream"},{"name":"stderr","text":"\n","output_type":"stream"},{"name":"stdout","text":"IoU score: 0.8919419053196908\nF1 score: 0.9427153408527374 \n============Epoch 2 ============ \n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 1132/1132 [14:43<00:00,  1.28it/s, loss=0.0733]\n","output_type":"stream"},{"name":"stdout","text":"=>Saving checkpoint\nIoU score: 0.9093499058485031\nF1 score: 0.9523852175474167 \n============Epoch 3 ============ \n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 1132/1132 [14:37<00:00,  1.29it/s, loss=0.0575]\n","output_type":"stream"},{"name":"stdout","text":"=>Saving checkpoint\nIoU score: 0.9149459275603294\nF1 score: 0.9554727703332901 \n","output_type":"stream"}]},{"cell_type":"code","source":"save_checkpoint(checkpoint)","metadata":{"execution":{"iopub.status.busy":"2023-12-18T14:48:47.416886Z","iopub.execute_input":"2023-12-18T14:48:47.417711Z","iopub.status.idle":"2023-12-18T14:48:47.625040Z","shell.execute_reply.started":"2023-12-18T14:48:47.417656Z","shell.execute_reply":"2023-12-18T14:48:47.624127Z"},"trusted":true},"execution_count":16,"outputs":[{"name":"stdout","text":"=>Saving checkpoint\n","output_type":"stream"}]},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n# Plot training and validation loss\nplt.figure(figsize=(12, 6))\nplt.plot(loss_history['train'], label='Training Loss')\nplt.plot(loss_history['val'], label='Validation Loss')\nplt.title('Loss History')\nplt.xlabel('Epoch')\nplt.ylabel('Loss')\nplt.legend()\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2023-12-18T14:48:50.873498Z","iopub.execute_input":"2023-12-18T14:48:50.874251Z","iopub.status.idle":"2023-12-18T14:48:51.252114Z","shell.execute_reply.started":"2023-12-18T14:48:50.874218Z","shell.execute_reply":"2023-12-18T14:48:51.251244Z"},"trusted":true},"execution_count":17,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 1200x600 with 1 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"code","source":"test_loss = check_accuracy(test_loader, model, criterion, DEVICE)","metadata":{"execution":{"iopub.status.busy":"2023-12-18T14:49:01.197117Z","iopub.execute_input":"2023-12-18T14:49:01.197520Z","iopub.status.idle":"2023-12-18T14:50:12.665849Z","shell.execute_reply.started":"2023-12-18T14:49:01.197486Z","shell.execute_reply":"2023-12-18T14:50:12.664642Z"},"trusted":true},"execution_count":18,"outputs":[{"name":"stdout","text":"IoU score: 0.9149459275603294\nF1 score: 0.9554727703332901 \n","output_type":"stream"}]},{"cell_type":"code","source":"my_index = torch.randint(0, len(test_ds),size=(1,)).item()\nwith torch.no_grad():\n    X_test, y_test = test_ds[my_index]\n    pred_test = model(X_test.unsqueeze(0).cuda())\n    pred_test = torch.argmax(pred_test, dim=1)\n    my_figrue, axarr = plt.subplots(1,3)\n    axarr[0].imshow(X_test.cpu().transpose(0,2).transpose(0,1))\n    axarr[1].imshow(y_test.cpu(),cmap='gray')\n    axarr[2].imshow(pred_test.squeeze(0).cpu(),cmap='gray')","metadata":{"execution":{"iopub.status.busy":"2023-12-18T14:50:47.473540Z","iopub.execute_input":"2023-12-18T14:50:47.474384Z","iopub.status.idle":"2023-12-18T14:50:48.124588Z","shell.execute_reply.started":"2023-12-18T14:50:47.474348Z","shell.execute_reply":"2023-12-18T14:50:48.123738Z"},"trusted":true},"execution_count":22,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 3 Axes>","image/png":"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"},"metadata":{}}]}]}