{"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":"nvidiaTeslaT4","dataSources":[{"sourceId":8089,"databundleVersionId":44321,"sourceType":"competition"},{"sourceId":10297111,"sourceType":"datasetVersion","datasetId":6373373}],"dockerImageVersionId":30823,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"pip install -U albumentations\n","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true,"execution":{"iopub.status.busy":"2024-12-25T15:52:01.180202Z","iopub.execute_input":"2024-12-25T15:52:01.180540Z","iopub.status.idle":"2024-12-25T15:52:08.812866Z","shell.execute_reply.started":"2024-12-25T15:52:01.180510Z","shell.execute_reply":"2024-12-25T15:52:08.811880Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import os\nimport time\nimport copy\nfrom collections import defaultdict\nimport torch\nimport shutil\nimport pandas as pd\nfrom skimage import io, transform\nimport numpy as np\nfrom PIL import Image\nimport matplotlib.pyplot as plt\nfrom torch.utils.data import Dataset, DataLoader, random_split\nfrom torchvision import transforms, utils\nfrom torch import nn\nfrom albumentations import (HorizontalFlip, ShiftScaleRotate, Normalize, Resize, Compose, GaussNoise)\nimport cv2\n# from albumentations.pytorch import ToTensor, ToTensorV2\nfrom torch.autograd import Variable\nfrom torch.nn import Linear, ReLU, CrossEntropyLoss, Sequential, Conv2d, MaxPool2d, Module, Softmax, BatchNorm2d, Dropout\nfrom torch.optim import Adam, SGD\nimport torch.nn.functional as F\nfrom PIL import Image\nfrom torch import nn\nimport zipfile\nimport tqdm\nimport random\nfrom albumentations.pytorch import ToTensorV2\n\n# device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n\ndef reset_seed():\n  torch.manual_seed(42)\n  random.seed(42)\n  torch.manual_seed(42)\nreset_seed()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:59:41.693882Z","iopub.execute_input":"2024-12-25T16:59:41.694216Z","iopub.status.idle":"2024-12-25T16:59:41.702845Z","shell.execute_reply.started":"2024-12-25T16:59:41.694187Z","shell.execute_reply":"2024-12-25T16:59:41.701808Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"mkdir /kaggle/working/pretrain_pth/pvt","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:28:29.202902Z","iopub.execute_input":"2024-12-25T16:28:29.203229Z","iopub.status.idle":"2024-12-25T16:28:29.358100Z","shell.execute_reply.started":"2024-12-25T16:28:29.203201Z","shell.execute_reply":"2024-12-25T16:28:29.357149Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import os\nimport shutil\n\n# Đường dẫn tệp nguồn và đích\nsrc_path = \"/kaggle/input/okokoko/pvt_v2_b2.pth\"\ndst_dir = \"/kaggle/working/pretrain_pth/pvt\"\n\n# Tạo thư mục đích nếu chưa tồn tại\nos.makedirs(dst_dir, exist_ok=True)\n\n# Sao chép tệp\ndst_path = os.path.join(dst_dir, \"pvt_v2_b2.pth\")  # Đường dẫn đến tệp đích\nshutil.copy(src_path, dst_path)\n\nprint(f\"File copied from {src_path} to {dst_path}\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:29:55.917438Z","iopub.execute_input":"2024-12-25T16:29:55.917827Z","iopub.status.idle":"2024-12-25T16:29:57.293865Z","shell.execute_reply.started":"2024-12-25T16:29:55.917795Z","shell.execute_reply":"2024-12-25T16:29:57.293061Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"!mkdir /kaggle/working/data_2/","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T15:52:50.450993Z","iopub.execute_input":"2024-12-25T15:52:50.451280Z","iopub.status.idle":"2024-12-25T15:52:50.579989Z","shell.execute_reply.started":"2024-12-25T15:52:50.451257Z","shell.execute_reply":"2024-12-25T15:52:50.578920Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"!mkdir /kaggle/working/data_2/val","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T15:52:52.436485Z","iopub.execute_input":"2024-12-25T15:52:52.436811Z","iopub.status.idle":"2024-12-25T15:52:52.565358Z","shell.execute_reply.started":"2024-12-25T15:52:52.436782Z","shell.execute_reply":"2024-12-25T15:52:52.564578Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"!mkdir /kaggle/working/data_2/train","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T15:52:53.115280Z","iopub.execute_input":"2024-12-25T15:52:53.115616Z","iopub.status.idle":"2024-12-25T15:52:53.244582Z","shell.execute_reply.started":"2024-12-25T15:52:53.115590Z","shell.execute_reply":"2024-12-25T15:52:53.243556Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\n\n!unzip -q /kaggle/input/data-science-bowl-2018/stage1_train.zip -d /kaggle/working/data_2/train\n!unzip -q /kaggle/input/data-science-bowl-2018/stage1_test.zip -d /kaggle/working/data_2/val","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T15:53:50.853495Z","iopub.execute_input":"2024-12-25T15:53:50.853804Z","iopub.status.idle":"2024-12-25T15:53:53.982484Z","shell.execute_reply.started":"2024-12-25T15:53:50.853779Z","shell.execute_reply":"2024-12-25T15:53:53.981293Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Data Path\nTRAIN_PATH = '/kaggle/working/data_2/train/'\nTEST_PATH = '/kaggle/working/data_2/val/'","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T15:54:03.833497Z","iopub.execute_input":"2024-12-25T15:54:03.833839Z","iopub.status.idle":"2024-12-25T15:54:03.837875Z","shell.execute_reply.started":"2024-12-25T15:54:03.833809Z","shell.execute_reply":"2024-12-25T15:54:03.837163Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import os\nimport random\nimport sys\nimport warnings\nimport numpy as np\nimport pandas as pd\nfrom itertools import chain\nfrom skimage.io import imread, imshow, imread_collection, concatenate_images\nfrom skimage.transform import resize\nfrom skimage.morphology import label\nfrom keras.utils import Progbar","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T15:54:09.869187Z","iopub.execute_input":"2024-12-25T15:54:09.869516Z","iopub.status.idle":"2024-12-25T15:54:18.740578Z","shell.execute_reply.started":"2024-12-25T15:54:09.869489Z","shell.execute_reply":"2024-12-25T15:54:18.739846Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"mkdir /kaggle/working/data_3","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T15:54:57.621497Z","iopub.execute_input":"2024-12-25T15:54:57.621800Z","iopub.status.idle":"2024-12-25T15:54:57.756672Z","shell.execute_reply.started":"2024-12-25T15:54:57.621775Z","shell.execute_reply":"2024-12-25T15:54:57.755649Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"mkdir /kaggle/working/data_3/train","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T15:54:59.889741Z","iopub.execute_input":"2024-12-25T15:54:59.890048Z","iopub.status.idle":"2024-12-25T15:55:00.025882Z","shell.execute_reply.started":"2024-12-25T15:54:59.890022Z","shell.execute_reply":"2024-12-25T15:55:00.024446Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"mkdir /kaggle/working/data_3/val","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T15:55:02.772494Z","iopub.execute_input":"2024-12-25T15:55:02.772808Z","iopub.status.idle":"2024-12-25T15:55:02.907532Z","shell.execute_reply.started":"2024-12-25T15:55:02.772781Z","shell.execute_reply":"2024-12-25T15:55:02.906424Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def read_train_data(IMG_WIDTH=256,IMG_HEIGHT=256,IMG_CHANNELS=3):\n    X_train = np.zeros((len(train_ids), IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS), dtype=np.uint8)\n    Y_train = np.zeros((len(train_ids), IMG_HEIGHT, IMG_WIDTH, 1), dtype=bool)\n\n    print('Getting and resizing train images and masks ... ')\n    sys.stdout.flush()\n    if os.path.isfile(\"train_img.npy\") and os.path.isfile(\"train_mask.npy\"):\n        print(\"Train file loaded from memory\")\n        X_train = np.load(\"/kaggle/working/data_3/train/train_img.npy\")\n        Y_train = np.load(\"/kaggle/working/data_3/train/train_mask.npy\")\n        return X_train,Y_train\n    a = Progbar(len(train_ids))\n    for n, id_ in enumerate(train_ids):\n        path = TRAIN_PATH + id_\n        img = imread(path + '/images/' + id_ + '.png')[:,:,:IMG_CHANNELS]\n        img = resize(img, (IMG_HEIGHT, IMG_WIDTH), mode='constant', preserve_range=True)\n        X_train[n] = img\n        \n        mask = np.zeros((IMG_HEIGHT, IMG_WIDTH, 1), dtype=bool)\n        for mask_file in next(os.walk(path + '/masks/'))[2]:\n            mask_ = imread(path + '/masks/' + mask_file)\n            mask_ = np.expand_dims(resize(mask_, (IMG_HEIGHT, IMG_WIDTH), mode='constant', \n                                        preserve_range=True), axis=-1)\n            mask = np.maximum(mask, mask_)\n        Y_train[n] = mask\n        a.update(n)\n    np.save(\"train_img\",X_train)\n    np.save(\"train_mask\",Y_train)\n    return X_train,Y_train","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T15:55:10.570241Z","iopub.execute_input":"2024-12-25T15:55:10.570626Z","iopub.status.idle":"2024-12-25T15:55:10.579572Z","shell.execute_reply.started":"2024-12-25T15:55:10.570592Z","shell.execute_reply":"2024-12-25T15:55:10.578475Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def read_test_data(IMG_WIDTH=256,IMG_HEIGHT=256,IMG_CHANNELS=3):\n    X_test = np.zeros((len(test_ids), IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS), dtype=np.uint8)\n    sizes_test = []\n    print('\\nGetting and resizing test images ... ')\n    sys.stdout.flush()\n    if os.path.isfile(\"test_img.npy\") and os.path.isfile(\"test_size.npy\"):\n        print(\"Test file loaded from memory\")\n        X_test = np.load(\"/kaggle/working/data_3/val/test_img.npy\")\n        sizes_test = np.load(\"/kaggle/working/data_3/val/test_size.npy\")\n        return X_test,sizes_test\n    b = Progbar(len(test_ids))\n    for n, id_ in enumerate(test_ids):\n        path = TEST_PATH + id_\n        img = imread(path + '/images/' + id_ + '.png')[:,:,:IMG_CHANNELS]\n        sizes_test.append([img.shape[0], img.shape[1]])\n        img = resize(img, (IMG_HEIGHT, IMG_WIDTH), mode='constant', preserve_range=True)\n        X_test[n] = img\n        b.update(n)\n    np.save(\"test_img\",X_test)\n    np.save(\"test_size\",sizes_test)\n    return X_test,sizes_test","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T15:55:25.909522Z","iopub.execute_input":"2024-12-25T15:55:25.909799Z","iopub.status.idle":"2024-12-25T15:55:25.916275Z","shell.execute_reply.started":"2024-12-25T15:55:25.909777Z","shell.execute_reply":"2024-12-25T15:55:25.915206Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"class Nuclie_data(Dataset):\n        def __init__(self,image, mask, transform):\n            self.image = image\n            self.mask = mask\n            self.transforms = transform\n        \n        def __len__(self):\n            return len(self.image)\n              \n        \n        def __getitem__(self,idx):\n            img = self.image[idx].astype('float32')\n            \n            mask = self.mask[idx].astype('float32')\n            \n            augmented = self.transforms(image=img, mask=mask)\n            img = augmented['image']\n            mask = augmented['mask']\n            mask = mask.permute(2, 0, 1)\n            mask = torch.from_numpy(np.where(mask > 0.5, 1, 0))\n            return (img,mask)\n            ","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T15:55:50.653226Z","iopub.execute_input":"2024-12-25T15:55:50.653548Z","iopub.status.idle":"2024-12-25T15:55:50.659253Z","shell.execute_reply.started":"2024-12-25T15:55:50.653524Z","shell.execute_reply":"2024-12-25T15:55:50.658257Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import albumentations as A\ntrain_transform = A.Compose(\n    [\n        #A.Resize(height=IMAGE_HEIGHT, width=IMAGE_WIDTH),\n        A.Rotate(limit=20, p=1.0),\n        A.HorizontalFlip(p=0.5),\n        A.VerticalFlip(p=0.1),\n        A.Normalize(\n            #mean = (0.485, 0.456, 0.406),\n            #std = (0.229, 0.224, 0.225),\n            mean = (0., 0., 0.),\n            std = (1., 1., 1.),\n            max_pixel_value = 255.0\n        ),\n        ToTensorV2(),\n    ])\nval_transform = A.Compose(\n    [\n        #A.RandomCrop(height=IMAGE_HEIGHT, width=IMAGE_WIDTH),\n        #A.Resize(height=IMAGE_HEIGHT, width=IMAGE_WIDTH),\n        A.Normalize(\n            mean = (0., 0., 0.),\n            std = (1., 1., 1.),\n            max_pixel_value = 255.0\n        ),\n        ToTensorV2(),\n    ])","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T15:55:58.831561Z","iopub.execute_input":"2024-12-25T15:55:58.831848Z","iopub.status.idle":"2024-12-25T15:55:58.843515Z","shell.execute_reply.started":"2024-12-25T15:55:58.831826Z","shell.execute_reply":"2024-12-25T15:55:58.842808Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_ids = next(os.walk(TRAIN_PATH))[1]\ntest_ids = next(os.walk(TEST_PATH))[1]","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T15:57:21.360739Z","iopub.execute_input":"2024-12-25T15:57:21.361018Z","iopub.status.idle":"2024-12-25T15:57:21.366184Z","shell.execute_reply.started":"2024-12-25T15:57:21.360997Z","shell.execute_reply":"2024-12-25T15:57:21.365496Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_img_1,train_mask_1 = read_train_data()\n\n# get test_data\ntest_img_1,test_img_sizes_1 = read_test_data()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T15:57:23.385620Z","iopub.execute_input":"2024-12-25T15:57:23.386009Z","iopub.status.idle":"2024-12-25T16:01:10.075867Z","shell.execute_reply.started":"2024-12-25T15:57:23.385974Z","shell.execute_reply":"2024-12-25T16:01:10.074718Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"X_train_1 = np.load(\"/kaggle/working/train_img.npy\")\nY_train_1 = np.load(\"/kaggle/working/train_mask.npy\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:02:06.969384Z","iopub.execute_input":"2024-12-25T16:02:06.969729Z","iopub.status.idle":"2024-12-25T16:02:07.044098Z","shell.execute_reply.started":"2024-12-25T16:02:06.969701Z","shell.execute_reply":"2024-12-25T16:02:07.043398Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_ds = Nuclie_data(X_train_1, Y_train_1, transform=train_transform)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:02:08.619037Z","iopub.execute_input":"2024-12-25T16:02:08.619375Z","iopub.status.idle":"2024-12-25T16:02:08.623500Z","shell.execute_reply.started":"2024-12-25T16:02:08.619327Z","shell.execute_reply":"2024-12-25T16:02:08.622366Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"num_train = int(len(train_ds)*0.9)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:02:09.671004Z","iopub.execute_input":"2024-12-25T16:02:09.671337Z","iopub.status.idle":"2024-12-25T16:02:09.675261Z","shell.execute_reply.started":"2024-12-25T16:02:09.671307Z","shell.execute_reply":"2024-12-25T16:02:09.674275Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"train_ds, val_ds = torch.utils.data.random_split(train_ds,[num_train, len(train_ds)-num_train])","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:02:10.578988Z","iopub.execute_input":"2024-12-25T16:02:10.579309Z","iopub.status.idle":"2024-12-25T16:02:10.584047Z","shell.execute_reply.started":"2024-12-25T16:02:10.579284Z","shell.execute_reply":"2024-12-25T16:02:10.582991Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import numpy as np\nNumSamples = 5\n\nk = np.random.randint(len(train_ds)*0.8,size = NumSamples)\nfg , ax = plt.subplots(2,NumSamples,figsize = (20,8))\nfg.suptitle(\"Data visualization\")\n\nfor i,j in enumerate(k):\n\n    X, y = train_ds[j]\n    ax[0,i].imshow(X.transpose(0,2).transpose(0,1), cmap='gray')\n    ax[0,i].set_xlabel('image {}'.format(j))\n    ax[1,i].imshow(y[0], cmap='gray')\n    ax[1,i].set_xlabel('mask {}'.format(j))","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:02:13.028742Z","iopub.execute_input":"2024-12-25T16:02:13.029027Z","iopub.status.idle":"2024-12-25T16:02:14.538520Z","shell.execute_reply.started":"2024-12-25T16:02:13.029005Z","shell.execute_reply":"2024-12-25T16:02:14.537539Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"for X, y in train_ds:\n  print(X.shape)\n  print(y.shape)\n  break","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:02:20.866925Z","iopub.execute_input":"2024-12-25T16:02:20.867228Z","iopub.status.idle":"2024-12-25T16:02:20.877454Z","shell.execute_reply.started":"2024-12-25T16:02:20.867205Z","shell.execute_reply":"2024-12-25T16:02:20.876582Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"batch_size=16\ntrain_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True)\nval_loader = DataLoader(val_ds, batch_size=batch_size, shuffle=True)\n# test_loader = DataLoader(test_ds, batch_size=10)\nNuclie_data","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:02:21.851893Z","iopub.execute_input":"2024-12-25T16:02:21.852215Z","iopub.status.idle":"2024-12-25T16:02:21.857818Z","shell.execute_reply.started":"2024-12-25T16:02:21.852188Z","shell.execute_reply":"2024-12-25T16:02:21.856745Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"for image, mask in train_loader:\n    print(f\"Image shape: {image.shape}, Mask shape: {mask.shape}\")\n    break  # Lấy phần tử đầu tiên để kiểm tra\n\nfor image, mask in val_loader:\n    print(f\"Image shape: {image.shape}, Mask shape: {mask.shape}\")\n    break  # Lấy phần tử đầu tiên để kiểm tra","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:02:23.874200Z","iopub.execute_input":"2024-12-25T16:02:23.874549Z","iopub.status.idle":"2024-12-25T16:02:24.013343Z","shell.execute_reply.started":"2024-12-25T16:02:23.874520Z","shell.execute_reply":"2024-12-25T16:02:24.012441Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"!git clone https://github.com/SLDGroup/EMCAD.git","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:02:25.694011Z","iopub.execute_input":"2024-12-25T16:02:25.694298Z","iopub.status.idle":"2024-12-25T16:02:25.841442Z","shell.execute_reply.started":"2024-12-25T16:02:25.694276Z","shell.execute_reply":"2024-12-25T16:02:25.840382Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import os\nimport shutil\nimport logging\nimport sys\nimport torch\nimport torch.optim as optim\nfrom torch.utils.data import DataLoader, random_split\nfrom tensorboardX import SummaryWriter\n# from utils.dataset_nuclei import NucleiData\n# from utils.utils import powerset, one_hot_encoder, DiceLoss, val_single_volume\n# from EMCAD.lib.networks import EMCADNet\nfrom tqdm.notebook import tqdm","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:40:56.098822Z","iopub.execute_input":"2024-12-25T16:40:56.099149Z","iopub.status.idle":"2024-12-25T16:40:56.103507Z","shell.execute_reply.started":"2024-12-25T16:40:56.099119Z","shell.execute_reply":"2024-12-25T16:40:56.102460Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"batch_size=16\ntrain_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True)\nval_loader = DataLoader(val_ds, batch_size=batch_size, shuffle=True)\n# test_loader = DataLoader(test_ds, batch_size=10)\n# Nuclie_data","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:36:23.737644Z","iopub.execute_input":"2024-12-25T16:36:23.738026Z","iopub.status.idle":"2024-12-25T16:36:23.743695Z","shell.execute_reply.started":"2024-12-25T16:36:23.737996Z","shell.execute_reply":"2024-12-25T16:36:23.742689Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"!pip install tensorboardX\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:16:46.442106Z","iopub.execute_input":"2024-12-25T16:16:46.442462Z","iopub.status.idle":"2024-12-25T16:16:49.871258Z","shell.execute_reply.started":"2024-12-25T16:16:46.442431Z","shell.execute_reply":"2024-12-25T16:16:49.869945Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"cd EMCAD","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:17:14.308578Z","iopub.execute_input":"2024-12-25T16:17:14.308906Z","iopub.status.idle":"2024-12-25T16:17:14.314455Z","shell.execute_reply.started":"2024-12-25T16:17:14.308876Z","shell.execute_reply":"2024-12-25T16:17:14.313748Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import argparse\nimport logging\nimport os\nimport random\nimport sys\nimport time\nimport numpy as np\nfrom tqdm import tqdm\n\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom tensorboardX import SummaryWriter\nfrom torch.nn.modules.loss import CrossEntropyLoss\nfrom torch.utils.data import DataLoader\nfrom torchvision import transforms\nfrom torch.amp import GradScaler, autocast\nfrom tensorboardX import SummaryWriter\n\nfrom utils.dataset_synapse import Synapse_dataset, RandomGenerator\nfrom utils.utils import powerset, one_hot_encoder, DiceLoss, val_single_volume\n            \n# def inference(args, model, best_performance, testloader, val_ds):\n#     # db_test = Nuclei(base_dir=args.volume_path, split=\"test_vol\", list_dir=args.list_dir, nclass=args.num_classes)\n    \n#     # testloader = DataLoader(db_test, batch_size=1, shuffle=False, num_workers=1)\n#     logging.info(\"{} test iterations per epoch\".format(len(testloader)))\n#     model.eval()\n#     metric_list = 0.0\n#     # for i_batch, sampled_batch in tqdm(enumerate(val_loader)):\n#     #     # Kiểm tra cấu trúc của sampled_batch\n#     #     print(type(sampled_batch), sampled_batch)\n        \n#     #     # Nếu sampled_batch là một list, kiểm tra cách bạn truy cập các phần tử\n#     #     if isinstance(sampled_batch, list):\n#     #         print(f\"First element type: {type(sampled_batch[0])}\")\n        \n#     #     # Tiến hành lấy kích thước ảnh nếu là dict hoặc kiểu hợp lệ\n#     #     if isinstance(sampled_batch, dict):\n#     #         _, _, h, w = sampled_batch[\"image\"].size()  # 4 chiều: (batch_size, channels, height, width)\n#     #         image, label = sampled_batch[\"image\"], sampled_batch[\"label\"]\n#     #         metric_i = val_single_volume(image, label, model, classes=args.num_classes, patch_size=[args.img_size, args.img_size],\n#     #                                      z_spacing=args.z_spacing)\n#     #         metric_list += np.array(metric_i)\n\n\n\n# #     batch_size=1\n# # train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True)\n# # val_loader = DataLoader(val_ds, batch_size=batch_size, shuffle=True)\n# #     # test_loader = DataLoader(test_ds, batch_size=10)\n#     for i_batch, sampled_batch in tqdm(enumerate(val_loader)):\n#         # In ra kiểu dữ liệu của sampled_batch\n#         # print(f\"Batch {i_batch} type: {type(sampled_batch)}\")\n        \n#         # Kiểm tra xem sampled_batch có phải là list không\n#         if isinstance(sampled_batch, list):\n#             # In ra kiểu của phần tử đầu tiên\n#             # print(f\"First element type in list: {type(sampled_batch[0])}\")\n#             # print(f\"First element in batch: {sampled_batch[0]}\")\n            \n#             # Kiểm tra phần tử đầu tiên có phải là tensor không\n#             if isinstance(sampled_batch[0], torch.Tensor):\n#                 # Lấy ảnh và nhãn từ các phần tử của list\n#                 image = sampled_batch[0]  # Tensor ảnh\n#                 label = sampled_batch[1]  # Tensor nhãn (giả sử nhãn là phần tử thứ 2)\n                \n#                 # print(f\"Image size: {image.size()}\")\n#                 # print(f\"Label size: {label.size()}\")\n                \n#                 _, _, h, w = image.size()  # 4 chiều: (batch_size, channels, height, width)\n#                 # print(f\"Height: {h}, Width: {w}\")\n                \n#                 # Tính toán các metric\n#                 metric_i = val_single_volume(image, label, model, classes=2, patch_size=[256, 256],z_spacing=1)\n#                 # print(f\"Metric for batch {i_batch}: {metric_i}\")\n                \n#                 # Cập nhật metric_list\n#                 if metric_i:  # Kiểm tra nếu metric_i có giá trị hợp lệ\n#                     metric_list += np.array(metric_i)\n#                 else:\n#                     print(f\"Warning: Empty metric for batch {i_batch}\")\n#             else:\n#                 print(\"Warning: First element is not a tensor\")\n#         else:\n    #         print(f\"Warning: sampled_batch is neither a list nor a dictionary\")\n        \n    #     # In metric_list sau khi cập nhật\n    #     # print(f\"Updated metric_list after batch {i_batch}: {metric_list}\")\n\n    \n\n    \n    # # for i_batch, sampled_batch in tqdm(enumerate(testloader)):\n    # #     h, w = sampled_batch[\"image\"].size()[2:]\n    # #     image, label = sampled_batch[\"image\"], sampled_batch[\"label\"]\n    # #     metric_i = val_single_volume(image, label, model, classes=args.num_classes, patch_size=[args.img_size, args.img_size],\n    # #                                    z_spacing=args.z_spacing)\n    # #     metric_list += np.array(metric_i)\n    # metric_list = metric_list / len(val_ds)\n    # performance = np.mean(metric_list, axis=0)\n    # logging.info('Testing performance in val model: mean_dice : %f, best_dice : %f' % (performance, best_performance))\n    # return performance\n\ndef trainer_synapse(args, model, snapshot_path, trainloader, testloader, val_ds):\n    # logging.basicConfig(filename=snapshot_path + \"/log.txt\", level=logging.INFO,\n    #                     format='[%(asctime)s.%(msecs)03d] %(message)s', datefmt='%H:%M:%S')\n    # logging.getLogger().addHandler(logging.StreamHandler(sys.stdout))\n    # logging.info(str(args))\n    base_lr = args['base_lr']\n    num_classes = args['num_classes']\n    batch_size = args['batch_size'] * 1\n    \n    # db_train = Synapse_dataset(base_dir=args.root_path, list_dir=args.list_dir, split=\"train\", nclass=args.num_classes,\n    #                            transform=transforms.Compose(\n    #                                [RandomGenerator(output_size=[args.img_size, args.img_size])]))\n    \n    # print(\"The length of train set is: {}\".format(len(db_train)))\n\n    def worker_init_fn(worker_id):\n        random.seed(args['seed'] + worker_id)\n\n    # trainloader = DataLoader(db_train, batch_size=batch_size, shuffle=True, num_workers=8, pin_memory=True,\n    #                          worker_init_fn=worker_init_fn)\n    \n    # device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n    # if torch.device_count() > 1 and args['n_gpu'] > 1:\n    #     print(\"Let's use\", torch.device_count(), \"GPUs!\")\n    #     model = nn.DataParallel(model)\n    model.to('cpu')\n\n    model.train()\n    ce_loss = CrossEntropyLoss()\n    dice_loss = DiceLoss(num_classes)\n\n    #optimizer = optim.SGD(model.parameters(), lr=base_lr, momentum=0.9, weight_decay=0.0001)\n    optimizer = optim.AdamW(model.parameters(), lr=base_lr, weight_decay=0.0001)\n    writer = SummaryWriter(snapshot_path + '/log')\n    iter_num = 0\n    max_epoch = args['max_epochs']\n    max_iterations = args['max_epochs'] * len(trainloader)\n    logging.info(\"{} iterations per epoch. {} max iterations \".format(len(trainloader), max_iterations))\n    best_performance = 0.0\n    iterator = tqdm(range(max_epoch), ncols=70)\n    \n    for epoch_num in iterator:\n\n        for i_batch, sampled_batch in enumerate(train_loader):\n            # Debug kiểu dữ liệu\n            # print(f\"Batch {i_batch}: {type(sampled_batch)}\")\n            # print(sampled_batch)\n        \n            # Kiểm tra và sửa cú pháp\n            if isinstance(sampled_batch, dict):\n                image_batch, label_batch = sampled_batch['image'], sampled_batch['label']\n            elif isinstance(sampled_batch, (list, tuple)):\n                image_batch, label_batch = sampled_batch[0], sampled_batch[1]\n            else:\n                raise TypeError(\"Unsupported batch data type.\")\n            \n            image_batch, label_batch = image_batch, label_batch.squeeze(1)\n\n        \n        # for i_batch, sampled_batch in enumerate(trainloader):\n        #     image_batch, label_batch = sampled_batch['image'], sampled_batch['label']\n        #     image_batch, label_batch = image_batch.cuda(), label_batch.squeeze(1).cuda()\n            \n            P = model(image_batch, mode='train')\n\n            if  not isinstance(P, list):\n                P = [P]\n            if epoch_num == 0 and i_batch == 0:\n                n_outs = len(P)\n                out_idxs = list(np.arange(n_outs)) #[0, 1, 2, 3]#, 4, 5, 6, 7]\n\n                if 'supervision' in args and args['supervision'] == 'mutation':\n                # if args.supervision == 'mutation':\n                    ss = [x for x in powerset(out_idxs)]\n                elif args.supervision == 'deep_supervision':\n                    ss = [[x] for x in out_idxs]\n                else:\n                    ss = [[-1]]\n                print(ss)\n            \n            loss = 0.0\n            w_ce, w_dice = 0.3, 0.7\n          \n            for s in ss:\n                iout = 0.0\n                if(s==[]):\n                    continue\n                for idx in range(len(s)):\n                    iout += P[s[idx]]\n                loss_ce = ce_loss(iout, label_batch[:].long())\n                loss_dice = dice_loss(iout, label_batch, softmax=True)\n                loss += (w_ce * loss_ce + w_dice * loss_dice)\n            \n            optimizer.zero_grad()\n            loss.backward()\n            optimizer.step()\n            #lr_ = base_lr * (1.0 - iter_num / max_iterations) ** 0.9 # we did not use this\n            lr_ = base_lr\n            for param_group in optimizer.param_groups:\n                param_group['lr'] = lr_\n\n            iter_num = iter_num + 1\n            writer.add_scalar('info/lr', lr_, iter_num)\n            writer.add_scalar('info/total_loss', loss, iter_num)\n            \n\n            if iter_num % 50 == 0:\n                logging.info('iteration %d, epoch %d : loss : %f, lr: %f' % (iter_num, epoch_num, loss.item(), lr_))\n                \n        logging.info('iteration %d, epoch %d : loss : %f, lr: %f' % (iter_num, epoch_num, loss.item(), lr_))\n        \n        save_mode_path = os.path.join(snapshot_path, 'last.pth')\n        torch.save(model.state_dict(), save_mode_path)\n        \n        performance = inference(args, model, best_performance,testloader,val_ds)\n        \n        save_interval = 50\n\n        if(best_performance <= performance):\n            best_performance = performance\n            save_mode_path = os.path.join(snapshot_path, 'best.pth')\n            torch.save(model.state_dict(), save_mode_path)\n            logging.info(\"save model to {}\".format(save_mode_path))\n            \n        if (epoch_num + 1) % save_interval == 0:\n            save_mode_path = os.path.join(snapshot_path, 'epoch_' + str(epoch_num) + '.pth')\n            torch.save(model.state_dict(), save_mode_path)\n            logging.info(\"save model to {}\".format(save_mode_path))\n\n        if epoch_num >= max_epoch - 1:\n            save_mode_path = os.path.join(snapshot_path, 'epoch_' + str(epoch_num) + '.pth')\n            torch.save(model.state_dict(), save_mode_path)\n            logging.info(\"save model to {}\".format(save_mode_path))\n            iterator.close()\n            break\n\n    writer.close()\n    return \"Training Finished!\"","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T20:07:30.991563Z","iopub.execute_input":"2024-12-25T20:07:30.991863Z","iopub.status.idle":"2024-12-25T20:07:31.007734Z","shell.execute_reply.started":"2024-12-25T20:07:30.991841Z","shell.execute_reply":"2024-12-25T20:07:31.006732Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def inference(args, model, best_performance, val_loader, val_ds):\n    \"\"\"\n   \n    \"\"\"\n    model.eval()  # Chuyển mô hình sang chế độ đánh giá (evaluation mode)\n    model.to(\"cpu\")  # Di chuyển mô hình sang CPU (nếu chưa)\n\n    total_samples = 0\n    metric_sum = 0.0\n    device = torch.device(\"cpu\")\n    \n    # Disable gradient computation during inference\n    with torch.no_grad():\n        for i_batch, sampled_batch in tqdm(enumerate(val_loader)):\n            # Validate batch format\n            if not isinstance(sampled_batch, list):\n                print(f\"Warning: sampled_batch at batch {i_batch} is not a list\")\n                continue\n                \n            if not isinstance(sampled_batch[0], torch.Tensor):\n                print(f\"Warning: First element at batch {i_batch} is not a tensor\")\n                continue\n            \n            # Extract data\n            image = sampled_batch[0].cpu()  # Image tensor\n            label = sampled_batch[1].cpu() # Label tensor\n            \n            # Move data to appropriate device if needed\n            # device = next(model.parameters()).cpu()\n            image = image.to(device)\n            label = label.to(device)\n            \n            # Get current batch size\n            batch_size = image.size(0)\n            \n            # Calculate metrics for current batch\n            metric_i = val_single_volume(\n                image=image,\n                label=label,\n                net=model,\n                classes=2,\n                patch_size=[256, 256],\n                z_spacing=1\n            )\n            \n            # Update metrics with batch weighting\n            if metric_i is not None:\n                metric_sum += np.array(metric_i) * batch_size\n                total_samples += batch_size\n            else:\n                print(f\"Warning: Empty metric for batch {i_batch}\")\n    \n    # Calculate final weighted average\n    if total_samples > 0:\n        metric_list = metric_sum / total_samples\n        performance = np.mean(metric_list, axis=0)\n        \n        logging.info(\n            'Testing performance in val model: mean_dice: %f, best_dice: %f', \n            performance, \n            best_performance\n        )\n        \n        return performance\n    else:\n        logging.error('No valid samples processed during inference')\n        return None","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T21:11:45.735482Z","iopub.execute_input":"2024-12-25T21:11:45.735825Z","iopub.status.idle":"2024-12-25T21:11:45.744788Z","shell.execute_reply.started":"2024-12-25T21:11:45.735794Z","shell.execute_reply":"2024-12-25T21:11:45.743751Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# batch_size=1\n# train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True)\n# val_loader = DataLoader(val_ds, batch_size=batch_size, shuffle=True)\n#     # test_loader = DataLoader(test_ds, batch_size=10)\n# for i_batch, sampled_batch in tqdm(enumerate(val_loader)):\n#     # In ra kiểu dữ liệu của sampled_batch\n#     # print(f\"Batch {i_batch} type: {type(sampled_batch)}\")\n    \n#     # Kiểm tra xem sampled_batch có phải là list không\n#     if isinstance(sampled_batch, list):\n#         # In ra kiểu của phần tử đầu tiên\n#         # print(f\"First element type in list: {type(sampled_batch[0])}\")\n#         # print(f\"First element in batch: {sampled_batch[0]}\")\n        \n#         # Kiểm tra phần tử đầu tiên có phải là tensor không\n#         if isinstance(sampled_batch[0], torch.Tensor):\n#             # Lấy ảnh và nhãn từ các phần tử của list\n#             image = sampled_batch[0]  # Tensor ảnh\n#             label = sampled_batch[1]  # Tensor nhãn (giả sử nhãn là phần tử thứ 2)\n            \n#             # print(f\"Image size: {image.size()}\")\n#             # print(f\"Label size: {label.size()}\")\n            \n#             _, _, h, w = image.size()  # 4 chiều: (batch_size, channels, height, width)\n#             # print(f\"Height: {h}, Width: {w}\")\n            \n#             # Tính toán các metric\n#             metric_i = val_single_volume(image, label, model, classes=2, patch_size=[256, 256],z_spacing=1)\n#             # print(f\"Metric for batch {i_batch}: {metric_i}\")\n            \n#             # Cập nhật metric_list\n#             if metric_i:  # Kiểm tra nếu metric_i có giá trị hợp lệ\n#                 metric_list += np.array(metric_i)\n#             else:\n#                 print(f\"Warning: Empty metric for batch {i_batch}\")\n#         else:\n#             print(\"Warning: First element is not a tensor\")\n#     else:\n#         print(f\"Warning: sampled_batch is neither a list nor a dictionary\")\n    \n#     # In metric_list sau khi cập nhật\n#     # print(f\"Updated metric_list after batch {i_batch}: {metric_list}\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T21:09:43.642974Z","iopub.execute_input":"2024-12-25T21:09:43.643272Z","iopub.status.idle":"2024-12-25T21:09:47.892504Z","shell.execute_reply.started":"2024-12-25T21:09:43.643249Z","shell.execute_reply":"2024-12-25T21:09:47.891180Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import torch\nimport numpy as np\nfrom scipy.ndimage import zoom\n\ndef val_single_volume(image, label, net, classes, patch_size=[256, 256], test_save_path=None, case=None, z_spacing=1):\n    # Chuyển đổi image và label sang numpy và đảm bảo trên CPU\n    image, label = image.squeeze(0).cpu().detach().numpy(), label.squeeze(0).cpu().detach().numpy()\n\n    # Kiểm tra xem image có phải là ảnh 3D hay không (nhiều slice)\n    if len(image.shape) == 3:\n        # Tạo mảng prediction với kích thước đúng (theo chiều slice của image)\n        prediction = np.zeros((image.shape[0], patch_size[0], patch_size[1]))  # Kích thước tương ứng với số lượng slice\n        for ind in range(image.shape[0]):\n            slice = image[ind, :, :]\n            x, y = slice.shape[0], slice.shape[1]\n            # print(f\"Slice size: {slice.shape}\")\n\n            # Thay đổi kích thước của slice nếu không đúng với kích thước patch_size\n            if x != patch_size[0] or y != patch_size[1]:\n                slice = zoom(slice, (patch_size[0] / x, patch_size[1] / y), order=3)  # Thay đổi kích thước\n            # print(f\"Input size: torch.Size({slice.shape})\")\n\n            # Chuyển đổi slice thành tensor và đưa về CPU\n            input = torch.from_numpy(slice).unsqueeze(0).unsqueeze(0).float().cpu()\n\n            # Đặt mô hình vào chế độ đánh giá (evaluation)\n            net.eval()\n            with torch.no_grad():\n                # Dự đoán với mô hình\n                P = net(input)\n                outputs = P[-1]\n                # Lấy class có xác suất cao nhất\n                out = torch.argmax(torch.softmax(outputs, dim=1), dim=1).squeeze(0)\n                out = out.cpu().detach().numpy()\n\n                # Nếu cần, thay đổi kích thước của kết quả dự đoán để phù hợp với kích thước ban đầu\n                if x != patch_size[0] or y != patch_size[1]:\n                    pred = zoom(out, (x / patch_size[0], y / patch_size[1]), order=0)\n                else:\n                    pred = out\n\n                # Lưu kết quả dự đoán vào mảng prediction\n                prediction[ind] = pred\n            print(f\"Prediction size: {prediction[ind].shape}\")\n\n    else:\n        # Xử lý trường hợp image là 2D (không có nhiều slice)\n        input = torch.from_numpy(image).unsqueeze(0).unsqueeze(0).float().cpu()\n        net.eval()\n        with torch.no_grad():\n            P = net(input)\n            outputs = P[-1]\n            out = torch.argmax(torch.softmax(outputs, dim=1), dim=1).squeeze(0)\n            prediction = out.cpu().detach().numpy()\n\n    # Tính các metric (ví dụ: Dice coefficient) cho mỗi lớp\n    batch_metrics = []\n    \n    for i in range(1, classes):\n        metric_i = calculate_dice_percase(prediction == i, label == i)\n        print(f\"Dice coefficient for class {i}: {metric_i}\")\n        # Chỉ thêm vào nếu metric hợp lệ\n        if 0 <= metric_i <= 1:\n            batch_metrics.append(metric_i)\n    \n    # # In thông tin cho batch hiện tại\n    # print(f\"Batch Dice coefficients: {batch_metrics}\")\n    # print(f\"Average Dice coefficient: {np.mean(batch_metrics) if batch_metrics else 0.0}\")\n    \n    # Trả về metrics của batch hiện tại, không tích lũy\n    return batch_metrics","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T21:31:02.293611Z","iopub.execute_input":"2024-12-25T21:31:02.293938Z","iopub.status.idle":"2024-12-25T21:31:02.304186Z","shell.execute_reply.started":"2024-12-25T21:31:02.293913Z","shell.execute_reply":"2024-12-25T21:31:02.303251Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# def val_single_volume(image, label, net, classes, patch_size=[256, 256], test_save_path=None, case=None, z_spacing=1):\n#     image, label = image.squeeze(0).cpu().detach().numpy(), label.squeeze(0).cpu().detach().numpy()\n\n#     if len(image.shape) == 3:\n#         prediction = np.zeros_like(label)\n#         for ind in range(image.shape[0]):\n#             slice = image[ind, :, :]\n#             x, y = slice.shape[0], slice.shape[1]\n#             if x != patch_size[0] or y != patch_size[1]:\n#                 slice = zoom(slice, (patch_size[0] / x, patch_size[1] / y), order=3)  # previous using 0\n#             input = torch.from_numpy(slice).unsqueeze(0).unsqueeze(0).float().cpu()\n#             net.eval()\n#             with torch.no_grad():\n#                 P = net(input)\n#                 outputs = 0.0\n#                 outputs = P[-1]\n#                 out = torch.argmax(torch.softmax(outputs, dim=1), dim=1).squeeze(0)\n#                 out = out.cpu().detach().numpy()\n#                 if x != patch_size[0] or y != patch_size[1]:\n#                     pred = zoom(out, (x / patch_size[0], y / patch_size[1]), order=0)\n#                 else:\n#                     pred = out\n#                 prediction[ind] = pred\n#     else:\n#         input = torch.from_numpy(image).unsqueeze(\n#             0).unsqueeze(0).float()\n#         net.eval()\n#         with torch.no_grad():\n#             P = net(input)\n#             outputs = P[-1]\n#             out = torch.argmax(torch.softmax(outputs, dim=1), dim=1).squeeze(0)\n#             prediction = out.cpu().detach().numpy()\n#     metric_list = []\n#     for i in range(1, classes):\n#         metric_list.append(calculate_dice_percase(prediction == i, label == i))\n#     return metric_list","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T21:31:03.528857Z","iopub.execute_input":"2024-12-25T21:31:03.529133Z","iopub.status.idle":"2024-12-25T21:31:03.533002Z","shell.execute_reply.started":"2024-12-25T21:31:03.529111Z","shell.execute_reply":"2024-12-25T21:31:03.532074Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"!pip install medpy\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T21:10:16.159871Z","iopub.execute_input":"2024-12-25T21:10:16.160121Z","iopub.status.idle":"2024-12-25T21:10:19.442653Z","shell.execute_reply.started":"2024-12-25T21:10:16.160100Z","shell.execute_reply":"2024-12-25T21:10:19.441685Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"!pip install torch torchvision\n!pip install numpy\n!pip install medpy\n!pip install scipy\n!pip install seaborn\n!pip install pillow\n!pip install matplotlib\n!pip install segmentation-mask-overlay\n!pip install SimpleITK\n!pip install pandas\n!pip install thop\n!pip install ptflops\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T21:10:19.444153Z","iopub.execute_input":"2024-12-25T21:10:19.444412Z","iopub.status.idle":"2024-12-25T21:10:58.828508Z","shell.execute_reply.started":"2024-12-25T21:10:19.444388Z","shell.execute_reply":"2024-12-25T21:10:58.827483Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\nimport torch\nimport torch.nn as nn\nimport numpy as np\nfrom medpy import metric\nfrom scipy.ndimage import zoom\nimport seaborn as sns\nfrom PIL import Image\nimport matplotlib.pyplot as plt\nfrom segmentation_mask_overlay import overlay_masks\nimport matplotlib.colors as mcolors\n\nimport SimpleITK as sitk\nimport pandas as pd\n\nfrom thop import profile\nfrom thop import clever_format\nfrom ptflops import get_model_complexity_info\n\ndef powerset(seq):\n    \"\"\"\n    Returns all the subsets of this set. This is a generator.\n    \"\"\"\n    if len(seq) <= 1:\n        yield seq\n        yield []\n    else:\n        for item in powerset(seq[1:]):\n            yield [seq[0]]+item\n            yield item\n\ndef clip_gradient(optimizer, grad_clip):\n    \"\"\"\n    For calibrating misalignment gradient via cliping gradient technique\n    :param optimizer:\n    :param grad_clip:\n    :return:\n    \"\"\"\n    for group in optimizer.param_groups:\n        for param in group['params']:\n            if param.grad is not None:\n                param.grad.data.clamp_(-grad_clip, grad_clip)\n\ndef adjust_lr(optimizer, init_lr, epoch, decay_rate=0.1, decay_epoch=30):\n    decay = decay_rate ** (epoch // decay_epoch)\n    for param_group in optimizer.param_groups:\n        param_group['lr'] *= decay\n\nclass AvgMeter(object):\n    def __init__(self, num=40):\n        self.num = num\n        self.reset()\n\n    def reset(self):\n        self.val = 0\n        self.avg = 0\n        self.sum = 0\n        self.count = 0\n        self.losses = []\n\n    def update(self, val, n=1):\n        self.val = val\n        self.sum += val * n\n        self.count += n\n        self.avg = self.sum / self.count\n        self.losses.append(val)\n\n    def show(self):\n        return torch.mean(torch.stack(self.losses[np.maximum(len(self.losses)-self.num, 0):]))\n\ndef CalParams(model, input_tensor):\n    \"\"\"\n    Usage:\n        Calculate Params and FLOPs via [THOP](https://github.com/Lyken17/pytorch-OpCounter)\n    Necessarity:\n        from thop import profile\n        from thop import clever_format\n    :param model:\n    :param input_tensor:\n    :return:\n    \"\"\"\n    flops, params = profile(model, inputs=(input_tensor,))\n    flops, params = clever_format([flops, params], \"%.3f\")\n    print('[Statistics Information]\\nFLOPs: {}\\nParams: {}'.format(flops, params))\n\ndef one_hot_encoder(input_tensor,dataset,n_classes = None):\n    tensor_list = []\n    if dataset == 'MMWHS':\n        dict = [0,205,420,500,550,600,820,850]\n        for i in dict:\n            temp_prob = input_tensor == i\n            tensor_list.append(temp_prob.unsqueeze(1))\n        output_tensor = torch.cat(tensor_list, dim=1)\n        return output_tensor.float()\n    else:\n        for i in range(n_classes):\n            temp_prob = input_tensor == i\n            tensor_list.append(temp_prob.unsqueeze(1))\n        output_tensor = torch.cat(tensor_list, dim=1)\n        return output_tensor.float()\n\nclass DiceLoss(nn.Module):\n    def __init__(self, n_classes):\n        super(DiceLoss, self).__init__()\n        self.n_classes = n_classes\n\n    def _one_hot_encoder(self, input_tensor):\n        tensor_list = []\n        for i in range(self.n_classes):\n            temp_prob = input_tensor == i  # * torch.ones_like(input_tensor)\n            tensor_list.append(temp_prob.unsqueeze(1))\n        output_tensor = torch.cat(tensor_list, dim=1)\n        return output_tensor.float()\n\n    def _dice_loss(self, score, target):\n        target = target.float()\n        smooth = 1e-5\n        intersect = torch.sum(score * target)\n        y_sum = torch.sum(target * target)\n        z_sum = torch.sum(score * score)\n        loss = (2 * intersect + smooth) / (z_sum + y_sum + smooth)\n        loss = 1 - loss\n        return loss\n\n    def forward(self, inputs, target, weight=None, softmax=False):\n        if softmax:\n            inputs = torch.softmax(inputs, dim=1)\n        target = self._one_hot_encoder(target)\n        if weight is None:\n            weight = [1] * self.n_classes\n        assert inputs.size() == target.size(), 'predict {} & target {} shape do not match'.format(inputs.size(), target.size())\n        class_wise_dice = []\n        loss = 0.0\n        for i in range(0, self.n_classes):\n            dice = self._dice_loss(inputs[:, i], target[:, i])\n            class_wise_dice.append(1.0 - dice.item())\n            loss += dice * weight[i]\n        return loss / self.n_classes\n\ndef calculate_metric_percase(pred, gt):\n    pred[pred > 0] = 1\n    gt[gt > 0] = 1\n    if pred.sum() > 0 and gt.sum()>0:\n        dice = metric.binary.dc(pred, gt)\n        hd95 = metric.binary.hd95(pred, gt)\n        jaccard = metric.binary.jc(pred, gt)\n        asd = metric.binary.assd(pred, gt)\n        return dice, hd95, jaccard, asd\n    elif pred.sum() > 0 and gt.sum()==0:\n        return 1, 0, 1, 0\n    else:\n        return 0, 0, 0, 0\n\ndef calculate_dice_percase(pred, gt):\n    # Chuyển về binary\n    pred = (pred > 0).astype(np.float32)\n    gt = (gt > 0).astype(np.float32)\n    \n    # Tính intersection và union\n    intersection = np.sum(pred * gt)\n    union = np.sum(pred) + np.sum(gt)\n    \n    # Tính Dice coefficient\n    if union > 0:\n        dice = (2.0 * intersection) / union\n        return np.clip(dice, 0.0, 1.0)  # Đảm bảo kết quả trong khoảng [0,1]\n    elif np.sum(pred) == 0 and np.sum(gt) == 0:\n        return 1.0  # Cả hai đều rỗng -> hoàn hảo match\n    else:\n        return 0.0  # Một trong hai rỗng -> không match\n\n\ndef test_single_volume(image, label, net, classes, patch_size=[256, 256], test_save_path=None, case=None, z_spacing=1, class_names=None):\n    image, label = image.squeeze(0).cpu().detach().numpy(), label.squeeze(0).cpu().detach().numpy()\n    if class_names==None:\n        mask_labels = np.arange(1,classes)\n    else:\n        mask_labels = class_names\n    cmaps = mcolors.CSS4_COLORS\n    my_colors=['red','darkorange','yellow','forestgreen','blue','purple','magenta','cyan','deeppink', 'chocolate', 'olive','deepskyblue','darkviolet']\n    cmap = {k: cmaps[k] for k in sorted(cmaps.keys()) if k in my_colors[:classes-1]}\n    if len(image.shape) == 3:\n        prediction = np.zeros_like(label)\n        for ind in range(image.shape[0]):\n            slice = image[ind, :, :]\n            x, y = slice.shape[0], slice.shape[1]\n            if x != patch_size[0] or y != patch_size[1]:\n                slice = zoom(slice, (patch_size[0] / x, patch_size[1] / y), order=3)  # previous using 0\n            input = torch.from_numpy(slice).unsqueeze(0).unsqueeze(0).float()\n            net.eval()\n            with torch.no_grad():\n                P = net(input)\n                outputs = P[-1]\n                out = torch.argmax(torch.softmax(outputs, dim=1), dim=1).squeeze(0)\n                out = out.cpu().detach().numpy()\n                if x != patch_size[0] or y != patch_size[1]:\n                    pred = zoom(out, (x / patch_size[0], y / patch_size[1]), order=0)\n                else:\n                    pred = out\n                prediction[ind] = pred\n                # saving the final output as a PNG file\n                #print(test_save_path + '/'+case + '' +str(ind))\n                #Image.fromarray((pred/8 * 255).astype(np.uint8)).save(test_save_path + '/'+case + '' +str(ind)+'_pred.png')\n                #Image.fromarray((image[ind, :, :] * 255).astype(np.uint8)).save(test_save_path + '/'+case + '' +str(ind)+'_img.png')\n                #Image.fromarray((label[ind, :, :]/8 * 255).astype(np.uint8)).save(test_save_path + '/'+case + '' +str(ind)+'_gt.png')\n                #cmap = plt.cm.tab20(np.arange(len(mask_labels)))\n\n                lbl = label[ind, :, :]\n                masks = []\n                for i in range(1, classes):\n                    masks.append(lbl==i)\n                preds_o = []\n                for i in range(1, classes):\n                    preds_o.append(pred==i)\n\n                fig_gt = overlay_masks(image[ind, :, :], masks, labels=mask_labels, colors=cmap, mask_alpha=0.5)\n                fig_pred = overlay_masks(image[ind, :, :], preds_o, labels=mask_labels, colors=cmap, mask_alpha=0.5)\n                # Do with that image whatever you want to do.\n                fig_gt.savefig(test_save_path + '/' + case + '_' +str(ind) + '_gt.png', bbox_inches=\"tight\", dpi=300)\n                fig_pred.savefig(test_save_path + '/' + case + '_' +str(ind) + '_pred.png', bbox_inches=\"tight\", dpi=300)\n\n    else:\n        input = torch.from_numpy(image).unsqueeze(\n            0).unsqueeze(0).float().cuda()\n        net.eval()\n        with torch.no_grad():\n            P = net(input)\n            outputs = P[-1]\n            out = torch.argmax(torch.softmax(outputs, dim=1), dim=1).squeeze(0)\n            prediction = out.cpu().detach().numpy()\n    metric_list = []\n    for i in range(1, classes):\n        metric_list.append(calculate_metric_percase(prediction == i, label == i))\n\n    if test_save_path is not None:\n        img_itk = sitk.GetImageFromArray(image.astype(np.float32))\n        prd_itk = sitk.GetImageFromArray(prediction.astype(np.float32))\n        lab_itk = sitk.GetImageFromArray(label.astype(np.float32))\n        img_itk.SetSpacing((1, 1, z_spacing))\n        prd_itk.SetSpacing((1, 1, z_spacing))\n        lab_itk.SetSpacing((1, 1, z_spacing))\n        sitk.WriteImage(prd_itk, test_save_path + '/'+case + \"_pred.nii.gz\")\n        sitk.WriteImage(img_itk, test_save_path + '/'+ case + \"_img.nii.gz\")\n        sitk.WriteImage(lab_itk, test_save_path + '/'+ case + \"_gt.nii.gz\")\n    return metric_list\n# def val_single_volume(image, label, net, classes, patch_size=[256, 256], test_save_path=None, case=None):\n#     \"\"\"\n#     Validate a single volume (image and label).\n#     \"\"\"\n#     # In kích thước của image và label ngay từ đầu\n#     print(f\"Original image shape: {image.shape}\")\n#     print(f\"Original label shape: {label.shape}\")\n\n#     image = image.squeeze(0).cpu().detach().numpy()\n#     label = label.squeeze(0).cpu().detach().numpy()\n\n#     print(f\"After squeezing: image shape: {image.shape}\")\n#     print(f\"After squeezing: label shape: {label.shape}\")\n\n#     batch_size = image.shape[0] if len(image.shape) > 3 else 1\n#     metric_list = []\n\n#     # Lặp qua từng ảnh trong batch\n#     for i in range(batch_size):\n#         single_image = image[i] if batch_size > 1 else image\n#         single_label = label[i] if batch_size > 1 else label\n\n#         # In kích thước của mỗi ảnh sau khi lấy ra\n#         print(f\"Processing image {i} with shape: {single_image.shape}\")\n#         print(f\"Processing label {i} with shape: {single_label.shape}\")\n\n#         # Nếu ảnh là 3D, lặp qua từng slice\n#         if len(single_image.shape) == 3:\n#             prediction = np.zeros_like(single_label)\n#             for ind in range(single_image.shape[0]):  # Lặp qua từng slice\n#                 slice_ = single_image[ind, :, :]\n#                 print(f\"Slice {ind} shape: {slice_.shape}\")\n\n#                 x, y = slice_.shape\n\n#                 if x != patch_size[0] or y != patch_size[1]:\n#                     slice_ = zoom(slice_, (patch_size[0] / x, patch_size[1] / y), order=3)\n\n#                 input_tensor = torch.from_numpy(slice_).unsqueeze(0).float().cuda()\n#                 print(f\"Input tensor shape for slice {ind}: {input_tensor.shape}\")\n\n#                 net.eval()\n#                 with torch.no_grad():\n#                     P = net(input_tensor)\n#                     outputs = P[-1] if isinstance(P, list) else P\n#                     out = torch.argmax(torch.softmax(outputs, dim=1), dim=1).squeeze(0)\n#                     out = out.cpu().detach().numpy()\n\n#                     if x != patch_size[0] or y != patch_size[1]:\n#                         pred = zoom(out, (x / patch_size[0], y / patch_size[1]), order=0)\n#                     else:\n#                         pred = out\n#                     prediction[ind] = pred\n#         else:\n#             # Ảnh 2D\n#             input_tensor = torch.from_numpy(single_image).unsqueeze(0).float().cuda()\n#             print(f\"Input tensor shape (2D): {input_tensor.shape}\")\n\n#             net.eval()\n#             with torch.no_grad():\n#                 P = net(input_tensor)\n#                 outputs = P[-1] if isinstance(P, list) else P\n#                 out = torch.argmax(torch.softmax(outputs, dim=1), dim=1).squeeze(0)\n#                 prediction = out.cpu().detach().numpy()\n\n#         # Tính các metrics cho từng class\n#         for i in range(1, classes):\n#             dice_score = calculate_dice_percase(prediction == i, single_label == i)\n#             metric_list.append(dice_score)\n\n#     return metric_list\n# def val_single_volume(image, label, net, classes, patch_size=[128, 128], test_save_path=None, case=None):\n#     \"\"\"\n#     Validate a single volume (image and label).\n#     \"\"\"\n#     # print(f\"Original image shape: {image.shape}\")\n#     # print(f\"Original label shape: {label.shape}\")\n\n#     # Chuyển sang numpy\n#     image = image.cpu().detach().numpy()\n#     label = label.cpu().detach().numpy()\n\n#     # print(f\"After converting to numpy: image shape: {image.shape}\")\n#     # print(f\"After converting to numpy: label shape: {label.shape}\")\n\n#     batch_size = image.shape[0]\n#     metric_list = []\n\n#     # Lặp qua từng ảnh trong batch\n#     for idx in range(batch_size):\n#         single_image = image[idx]  # Shape: (3, H, W) for RGB images\n#         single_label = label[idx]  # Shape: (1, H, W)\n\n#         # print(f\"Processing image {idx} with shape: {single_image.shape}\")\n#         # print(f\"Processing label {idx} with shape: {single_label.shape}\")\n\n#         # Kiểm tra và resize nếu cần\n#         if single_image.shape[1:] != tuple(patch_size):\n#             # Resize từng channel\n#             resized_image = np.zeros((single_image.shape[0], patch_size[0], patch_size[1]))\n#             for c in range(single_image.shape[0]):\n#                 resized_image[c] = zoom(single_image[c], (patch_size[0] / single_image.shape[1],\n#                                                         patch_size[1] / single_image.shape[2]), order=3)\n#             single_image = resized_image\n\n#         # Chuẩn bị input tensor\n#         input_tensor = torch.from_numpy(single_image).unsqueeze(0).float().cuda()\n#         print(f\"Input tensor shape: {input_tensor.shape}\")\n\n    #     # Inference\n    #     net.eval()\n    #     with torch.no_grad():\n    #         outputs = net(input_tensor)\n    #         if isinstance(outputs, list):\n    #             outputs = outputs[-1]\n    #         out = torch.argmax(torch.softmax(outputs, dim=1), dim=1).squeeze(0)\n    #         prediction = out.cpu().detach().numpy()\n\n    #         # Resize prediction về kích thước gốc nếu cần\n    #         if prediction.shape != single_label.shape[1:]:\n    #             prediction = zoom(prediction, (single_label.shape[1] / prediction.shape[0],\n    #                                         single_label.shape[2] / prediction.shape[1]), order=0)\n\n    #     # Tính metrics cho từng class\n    #     for class_idx in range(1, classes):\n    #         dice_score = calculate_dice_percase(prediction == class_idx,\n    #                                           single_label[0] == class_idx)\n    #         print(f\"Dice score for class {i}: {dice_score}\")\n    #         metric_list.append(dice_score)\n\n    # return metric_list\n\n# def val_single_volume(image, label, net, classes, patch_size=[256, 256], test_save_path=None, case=None, z_spacing=1):\n#     image, label = image.squeeze(0).cpu().detach().numpy(), label.squeeze(0).cpu().detach().numpy()\n\n#     if len(image.shape) == 3:\n#         prediction = np.zeros_like(label)\n#         for ind in range(image.shape[0]):\n#             slice = image[ind, :, :]\n#             x, y = slice.shape[0], slice.shape[1]\n#             if x != patch_size[0] or y != patch_size[1]:\n#                 slice = zoom(slice, (patch_size[0] / x, patch_size[1] / y), order=3)  # previous using 0\n#             input = torch.from_numpy(slice).unsqueeze(0).unsqueeze(0).float().cpu()\n#             net.eval()\n#             with torch.no_grad():\n#                 P = net(input)\n#                 outputs = 0.0\n#                 outputs = P[-1]\n#                 out = torch.argmax(torch.softmax(outputs, dim=1), dim=1).squeeze(0)\n#                 out = out.cpu().detach().numpy()\n#                 if x != patch_size[0] or y != patch_size[1]:\n#                     pred = zoom(out, (x / patch_size[0], y / patch_size[1]), order=0)\n#                 else:\n#                     pred = out\n#                 prediction[ind] = pred\n#     else:\n#         input = torch.from_numpy(image).unsqueeze(\n#             0).unsqueeze(0).float()\n#         net.eval()\n#         with torch.no_grad():\n#             P = net(input)\n#             outputs = P[-1]\n#             out = torch.argmax(torch.softmax(outputs, dim=1), dim=1).squeeze(0)\n#             prediction = out.cpu().detach().numpy()\n#     metric_list = []\n#     for i in range(1, classes):\n#         metric_list.append(calculate_dice_percase(prediction == i, label == i))\n#     return metric_list\ndef horizontal_flip(image):\n    image = image[:, ::-1, :]\n    return image\n\ndef vertical_flip(image):\n    image = image[::-1, :, :]\n    return image\n\ndef tta_model(model, image):\n    n_image = image\n    h_image = horizontal_flip(image)\n    v_image = vertical_flip(image)\n\n    n_mask = model.predict(np.expand_dims(n_image, axis=0))[0]\n    h_mask = model.predict(np.expand_dims(h_image, axis=0))[0]\n    v_mask = model.predict(np.expand_dims(v_image, axis=0))[0]\n\n    n_mask = n_mask\n    h_mask = horizontal_flip(h_mask)\n    v_mask = vertical_flip(v_mask)\n\n    mean_mask = (n_mask + h_mask + v_mask) / 3.0\n    return mean_mask\n\ndef cal_params_flops(model, size, logger):\n    input = torch.randn(1, 3, size, size)\n    flops, params = profile(model, inputs=(input,))\n    print('flops',flops/1e9)\t\t\t## 打印计算量\n    print('params',params/1e6)\t\t\t## 打印参数量\n\n    total = sum(p.numel() for p in model.parameters())\n    print(\"Total params: %.2fM\" % (total/1e6))\n    logger.info(f'flops: {flops/1e9}, params: {params/1e6}, Total params: : {total/1e6:.4f}')\n\n# Example function to calculate and print GMACs and parameter count for a given model\ndef print_model_stats(model, input_size=(3, 224, 224)):\n    # Print model parameter count\n    total_params = sum(p.numel() for p in model.parameters())\n    print(f'Model created, param count: {total_params}')\n\n    # Calculate GMACs using ptflops\n    macs, params = get_model_complexity_info(model, input_size, as_strings=True, print_per_layer_stat=True)\n\n    # Display GMACs and params\n    print(f'Model: {macs} GMACs, {params} parameters')","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T19:09:03.292427Z","iopub.execute_input":"2024-12-25T19:09:03.292741Z","iopub.status.idle":"2024-12-25T19:09:03.329978Z","shell.execute_reply.started":"2024-12-25T19:09:03.292720Z","shell.execute_reply":"2024-12-25T19:09:03.329089Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import logging\nimport os\nimport random\nimport numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.backends.cudnn as cudnn\n\n# from lib.networks import EMCADNet\n# from trainer import trainer_synapse\n\n# Cấu hình tham số trực tiếp\nargs = {\n    'root_path': './data/synapse/train_npz',\n    'volume_path': './data/synapse/test_vol_h5',\n    'dataset': 'Synapse',\n    'list_dir': './lists/lists_Synapse',\n    'num_classes': 2,\n    'encoder': 'pvt_v2_b2',\n    'expansion_factor': 2,\n    'kernel_sizes': [1, 3, 5],\n    'lgag_ks': 3,\n    'activation_mscb': 'relu6',\n    'no_dw_parallel': False,\n    'concatenation': False,\n    'no_pretrain': False,\n    'supervision': 'mutation',\n    'max_iterations': 50000,\n    'max_epochs': 300,\n    'batch_size': 6,\n    'base_lr': 0.0001,\n    'img_size': 224,\n    'n_gpu': 1,\n    'deterministic': 1,\n    'seed': 2222\n}\n\nif __name__ == \"__main__\":\n    if not args['deterministic']:\n        cudnn.benchmark = True\n        cudnn.deterministic = False\n    else:\n        cudnn.benchmark = False\n        cudnn.deterministic = True\n\n    random.seed(args['seed'])\n    np.random.seed(args['seed'])\n    torch.manual_seed(args['seed'])\n    torch.manual_seed(args['seed'])\n\n    dataset_name = args['dataset']\n    dataset_config = {\n        'Synapse': {\n            'root_path': args['root_path'],\n            'volume_path': args['volume_path'],\n            'list_dir': args['list_dir'],\n            'num_classes': args['num_classes'],\n            'z_spacing': 1,\n        },\n    }\n    args['num_classes'] = dataset_config[dataset_name]['num_classes']\n    args['root_path'] = dataset_config[dataset_name]['root_path']\n    args['volume_path'] = dataset_config[dataset_name]['volume_path']\n    args['z_spacing'] = dataset_config[dataset_name]['z_spacing']\n    args['list_dir'] = dataset_config[dataset_name]['list_dir']\n\n    aggregation = 'concat' if args['concatenation'] else 'add'\n    dw_mode = 'series' if args['no_dw_parallel'] else 'parallel'\n\n    run = 1\n    args['exp'] = (\n        f\"{args['encoder']}_EMCAD_kernel_sizes_{args['kernel_sizes']}_dw_{dw_mode}_{aggregation}_\"\n        f\"lgag_ks_{args['lgag_ks']}_ef{args['expansion_factor']}_act_mscb_{args['activation_mscb']}_\"\n        f\"loss_{args['supervision']}_output_final_layer_Run{run}_{dataset_name}{args['img_size']}\"\n    )\n    snapshot_path = f\"model_pth/{args['exp']}/{args['encoder']}_EMCAD_kernel_sizes_{args['kernel_sizes']}_dw_{dw_mode}_{aggregation}_lgag_ks_{args['lgag_ks']}_ef{args['expansion_factor']}_act_mscb_{args['activation_mscb']}_loss_{args['supervision']}_output_final_layer_Run{run}\"\n    snapshot_path = snapshot_path.replace('[', '').replace(']', '').replace(', ', '_')\n\n    if not args['no_pretrain']:\n        snapshot_path += '_pretrain'\n    if args['max_iterations'] != 50000:\n        snapshot_path += f\"_{str(args['max_iterations'])[0:2]}k\"\n    if args['max_epochs'] != 300:\n        snapshot_path += f\"_epo{args['max_epochs']}\"\n    snapshot_path += f\"_bs{args['batch_size']}\"\n    if args['base_lr'] != 0.0001:\n        snapshot_path += f\"_lr{args['base_lr']}\"\n    snapshot_path += f\"_{args['img_size']}\"\n    if args['seed'] != 1234:\n        snapshot_path += f\"_s{args['seed']}\"\n\n    if not os.path.exists(snapshot_path):\n        os.makedirs(snapshot_path)\n# def trainer_synapse(args, model, snapshot_path, trainloader):\n\n    model = EMCADNet(\n        num_classes=args['num_classes'],\n        kernel_sizes=args['kernel_sizes'],\n        expansion_factor=args['expansion_factor'],\n        dw_parallel=not args['no_dw_parallel'],\n        add=not args['concatenation'],\n        lgag_ks=args['lgag_ks'],\n        activation=args['activation_mscb'],\n        encoder=args['encoder'],\n        pretrain=not args['no_pretrain']\n    )\n    batch_size=1\n    train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True)\n    val_loader = DataLoader(val_ds, batch_size=batch_size, shuffle=True)\n    # test_loader = DataLoader(test_ds, batch_size=10)\n    # Nuclie_data\n    model\n\n    print('Model successfully created.')\n\n    trainer = {'Synapse': trainer_synapse}\n    trainer[dataset_name](args, model, snapshot_path, train_loader, val_loader, val_ds)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T21:31:14.416851Z","iopub.execute_input":"2024-12-25T21:31:14.417130Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import torch\ntorch.cuda.empty_cache()\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:55:25.789251Z","iopub.execute_input":"2024-12-25T16:55:25.789636Z","iopub.status.idle":"2024-12-25T16:55:25.793485Z","shell.execute_reply.started":"2024-12-25T16:55:25.789612Z","shell.execute_reply":"2024-12-25T16:55:25.792641Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# for i_batch, sampled_batch in enumerate(train_loader):\n\n#     # Debug kiểu dữ liệu\n#     print(f\"Batch {i_batch}: {type(sampled_batch)}\")\n#     print(sampled_batch)\n\n#     # Kiểm tra và sửa cú pháp\n#     if isinstance(sampled_batch, dict):\n#         image_batch, label_batch = sampled_batch['image'], sampled_batch['label']\n#     elif isinstance(sampled_batch, (list, tuple)):\n#         image_batch, label_batch = sampled_batch[0], sampled_batch[1]\n#     else:\n#         raise TypeError(\"Unsupported batch data type.\")\n    \n#     image_batch, label_batch = image_batch.cuda(), label_batch.squeeze(1).cuda()\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T18:13:44.059324Z","iopub.execute_input":"2024-12-25T18:13:44.059754Z","iopub.status.idle":"2024-12-25T18:13:44.064164Z","shell.execute_reply.started":"2024-12-25T18:13:44.059722Z","shell.execute_reply":"2024-12-25T18:13:44.063005Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom lib.pvtv2 import pvt_v2_b0, pvt_v2_b1, pvt_v2_b2, pvt_v2_b3, pvt_v2_b4, pvt_v2_b5\nfrom lib.resnet import resnet18, resnet34, resnet50, resnet101, resnet152\nfrom lib.decoders import EMCAD\n\n\nclass EMCADNet(nn.Module):\n    def __init__(self, num_classes=1, kernel_sizes=[1,3,5], expansion_factor=2, dw_parallel=True, add=True, lgag_ks=3, activation='relu', encoder='pvt_v2_b2', pretrain=True):\n        super(EMCADNet, self).__init__()\n\n        # conv block to convert single channel to 3 channels\n        self.conv = nn.Sequential(\n            nn.Conv2d(1, 3, kernel_size=1),\n            nn.BatchNorm2d(3),\n            nn.ReLU(inplace=True)\n        )\n\n        # backbone network initialization with pretrained weight\n        if encoder == 'pvt_v2_b0':\n            self.backbone = pvt_v2_b0()\n            path = '/content/EMCAD/pretrained_pth/pvt/pvt_v2_b2.pth'\n            channels=[256, 160, 64, 32]\n        elif encoder == 'pvt_v2_b1':\n            self.backbone = pvt_v2_b1()\n            path = '/content/EMCAD/pretrained_pth/pvt/pvt_v2_b2.pth'\n            channels=[512, 320, 128, 64]\n        elif encoder == 'pvt_v2_b2':\n            self.backbone = pvt_v2_b2()\n            path = '/kaggle/working/pretrain_pth/pvt/pvt_v2_b2.pth'\n            channels=[512, 320, 128, 64]\n        elif encoder == 'pvt_v2_b3':\n            self.backbone = pvt_v2_b3()\n            path = '/content/EMCAD/pretrained_pth/pvt/pvt_v2_b2.pth'\n            channels=[512, 320, 128, 64]\n        elif encoder == 'pvt_v2_b4':\n            self.backbone = pvt_v2_b4()\n            path = '/content/EMCAD/pretrained_pth/pvt/pvt_v2_b2.pth'\n            channels=[512, 320, 128, 64]\n        elif encoder == 'pvt_v2_b5':\n            self.backbone = pvt_v2_b5()\n            path = '/content/EMCAD/pretrained_pth/pvt/pvt_v2_b2.pth'\n            channels=[512, 320, 128, 64]\n        elif encoder == 'resnet18':\n            self.backbone = resnet18(pretrained=pretrain)\n            channels=[512, 256, 128, 64]\n        elif encoder == 'resnet34':\n            self.backbone = resnet34(pretrained=pretrain)\n            channels=[512, 256, 128, 64]\n        elif encoder == 'resnet50':\n            self.backbone = resnet50(pretrained=pretrain)\n            channels=[2048, 1024, 512, 256]\n        elif encoder == 'resnet101':\n            self.backbone = resnet101(pretrained=pretrain)\n            channels=[2048, 1024, 512, 256]\n        elif encoder == 'resnet152':\n            self.backbone = resnet152(pretrained=pretrain)\n            channels=[2048, 1024, 512, 256]\n        else:\n            print('Encoder not implemented! Continuing with default encoder pvt_v2_b2.')\n            self.backbone = pvt_v2_b2()\n            path = '/kaggle/working/pretrain_pth/pvt/pvt_v2_b2.pth'\n            channels=[512, 320, 128, 64]\n\n        if pretrain==True and 'pvt_v2' in encoder:\n            save_model = torch.load(path)\n            model_dict = self.backbone.state_dict()\n            state_dict = {k: v for k, v in save_model.items() if k in model_dict.keys()}\n            model_dict.update(state_dict)\n            self.backbone.load_state_dict(model_dict)\n\n        print('Model %s created, param count: %d' %\n                     (encoder+' backbone: ', sum([m.numel() for m in self.backbone.parameters()])))\n\n        #   decoder initialization\n        self.decoder = EMCAD(channels=channels, kernel_sizes=kernel_sizes, expansion_factor=expansion_factor, dw_parallel=dw_parallel, add=add, lgag_ks=lgag_ks, activation=activation)\n\n        print('Model %s created, param count: %d' %\n                     ('EMCAD decoder: ', sum([m.numel() for m in self.decoder.parameters()])))\n\n        self.out_head4 = nn.Conv2d(channels[0], num_classes, 1)\n        self.out_head3 = nn.Conv2d(channels[1], num_classes, 1)\n        self.out_head2 = nn.Conv2d(channels[2], num_classes, 1)\n        self.out_head1 = nn.Conv2d(channels[3], num_classes, 1)\n\n    def forward(self, x, mode='test'):\n\n        # if grayscale input, convert to 3 channels\n        if x.size()[1] == 1:\n            x = self.conv(x)\n\n        # encoder\n        x1, x2, x3, x4 = self.backbone(x)\n        #print(x1.shape, x2.shape, x3.shape, x4.shape)\n\n        # decoder\n        dec_outs = self.decoder(x4, [x3, x2, x1])\n\n        # prediction heads\n        p4 = self.out_head4(dec_outs[0])\n        p3 = self.out_head3(dec_outs[1])\n        p2 = self.out_head2(dec_outs[2])\n        p1 = self.out_head1(dec_outs[3])\n\n        p4 = F.interpolate(p4, scale_factor=32, mode='bilinear')\n        p3 = F.interpolate(p3, scale_factor=16, mode='bilinear')\n        p2 = F.interpolate(p2, scale_factor=8, mode='bilinear')\n        p1 = F.interpolate(p1, scale_factor=4, mode='bilinear')\n\n        if mode == 'test':\n            return [p4, p3, p2, p1]\n\n        return [p4, p3, p2, p1]\n\n\n\n\n\nif __name__ == '__main__':\n    model = EMCADNet()\n    input_tensor = torch.randn(1, 3, 352, 352)\n    \n\n    P = model(input_tensor)\n    print(P[0].size(), P[1].size(), P[2].size(), P[3].size())\n\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-12-25T16:41:05.477169Z","iopub.execute_input":"2024-12-25T16:41:05.477527Z","iopub.status.idle":"2024-12-25T16:41:06.375119Z","shell.execute_reply.started":"2024-12-25T16:41:05.477497Z","shell.execute_reply":"2024-12-25T16:41:06.374259Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null}]}