{"cells":[{"metadata":{"trusted":true},"cell_type":"code","source":"!pip install cython\n!pip install -U 'git+https://github.com/cocodataset/cocoapi.git#subdirectory=PythonAPI'","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"!git clone https://github.com/pytorch/vision.git\n!cd vision\n!git checkout v0.3.0\n!ls -l","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"!cp ./vision/references/detection/utils.py .\n!cp ./vision/references/detection/transforms.py .\n!cp ./vision/references/detection/coco_eval.py .\n!cp ./vision/references/detection/engine.py .\n!cp ./vision/references/detection/coco_utils.py .","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"!ls ./vision/references/detection/coco_utils.py","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"!ls ./engine.py","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"from engine import train_one_epoch, evaluate\nimport utils\nimport transforms as T","execution_count":null,"outputs":[]},{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"from __future__ import print_function\nfrom collections import defaultdict, deque\nimport datetime\nimport pickle\nimport time\nimport torch.distributed as dist\nimport errno\nfrom shapely.geometry import Polygon\nimport collections\nimport os\nimport numpy as np\nimport torch\nimport torch.utils.data\nfrom PIL import Image, ImageFile\nimport pandas as pd\nfrom tqdm import tqdm\nfrom torchvision import transforms\nimport torchvision\nfrom torchvision.models.detection.faster_rcnn import FastRCNNPredictor\nfrom torchvision.models.detection.mask_rcnn import MaskRCNNPredictor\nimport pandas as pd\nimport pydicom\nimport matplotlib.pyplot as plt\nimport glob\nfrom skimage.transform import resize\nfrom matplotlib.patches import Rectangle\nimport torchvision.transforms as T\nfrom sklearn.model_selection import train_test_split\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nfrom skimage import io, transform\nfrom torchvision.models.detection.faster_rcnn import FastRCNNPredictor\nfrom torchvision.models.detection import FasterRCNN\nfrom torchvision.models.detection.rpn import AnchorGenerator\nfrom PIL import Image\nimport psutil\n\nimport warnings\nwarnings.filterwarnings('ignore')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"input_path = '/kaggle/input/vinbigdata-chest-xray-abnormalities-detection/train/'","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"input_file = os.listdir(input_path)\ninput_files = list(dict.fromkeys(input_file))\nprint(len(input_files))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"df1 = pd.read_csv('../input/vinbigdata-chest-xray-abnormalities-detection/train.csv')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#classes = list(df1['class_name'].values)\n#classes = list(dict.fromkeys(classes))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"df = df1[df1['class_name']!= 'No finding']","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def plot_maskimage(mask):\n    color = ['r','b','g','y','w','c','m','w','c','m','r','b','g','y','w','c','m','w','c','m']\n    #plt.imshow(img,cmap='gray')\n    #for ii in range(size):\n    #    plt.gca().add_patch(Rectangle((xmin[ii], ymin[ii]), (xmax[ii]-xmin[ii]), (ymax[ii]-ymin[ii]),linewidth=1,edgecolor=color[i],facecolor='none'))\n    #plt.show()\n    for mas in mask:\n        plt.imshow(mas,cmap='gray')\n        plt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"num_classes = 15","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def masks_generation(img,dff,res):\n    m = img.shape[0]\n    n = img.shape[1]\n    #all_classids = list(np.arange(0,15))\n    class_ids = list(dff['class_id'].values)\n    mask = np.zeros((num_classes,m,n))\n    print(class_ids)\n    #for s in all_classids:\n    #print(s)\n    res = res\n    for dd in dff.values:\n        #print('dd',dd)\n        s = dd[2]+1\n        print('s',s)\n        xmin = dd[4]/res\n        print(dd[4],xmin)\n        xmax = dd[5]/res\n        ymin = dd[6]/res\n        ymax = dd[7]/res\n        ax = int(xmin)\n        ax1 =int(xmax)\n        ay = int(ymin)\n        ay1 = int(ymax)\n        mask[s,ay:ay1,ax:ax1] = 1\n        print(mask.shape)\n    #print(xmin,xmax,ymin,ymax)\n        print(ax,ax1,ay,ay1)\n    plot_maskimage(img,mask,num_classes)\n    return mask","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"class traindataset(torch.utils.data.Dataset):\n\n    def __init__(self, df, transform):\n        super().__init__()\n        \n        self.input_files = list(set(df['image_id'].values))\n        self.df = df\n        self.transform = transform\n    \n    def __len__(self) :\n        return len(self.input_files)\n\n    def __getitem__(self, idx):\n        \n        input_files = self.input_files\n        #print(idx)\n        img_id = input_files[idx]\n        df = self.df\n        \n        fdf = df[df['image_id'] == img_id]\n        m,n = 1024,1024\n        dff = fdf.sort_values(by=['x_min'])\n        class_id = [m+1 for m in list(dff['class_id'].values)]\n        N = len(class_id)\n        \n        image_path  = '../input/vinbigdata-chest-xray-abnormalities-detection/train/'+img_id+'.dicom'\n        img_pxl = pydicom.read_file(image_path).pixel_array\n        res = (img_pxl.shape[0]*img_pxl.shape[1])/(m*n) \n        img = resize(img_pxl,(1024,1024),anti_aliasing=True)\n        img_np = img.astype(np.float32())\n        img_tr = torch.from_numpy(img_np).unsqueeze(0)\n\n        xmin_res = [x/res for x in list(dff['x_min'].values)]\n        xmax_res = [xm/res for xm in list(dff['x_max'].values)]\n        ymax_res = [y/res for y in list(dff['y_max'].values)]\n        ymin_res = [ym/res for ym in list(dff['y_min'].values)]\n        b = 0\n        area = []\n        bbox = []\n        mask = np.zeros((N,m,n))\n        for b in range(N):\n            x1,x2,y1,y2 = int(xmin_res[b]),int(xmax_res[b]),int(ymin_res[b]),int(ymax_res[b])\n            ax1,ax2,ay1,ay2 = xmin_res[b],xmax_res[b],ymin_res[b],ymax_res[b]\n            mask[b,y1:y2,x1:x2] = 1\n            box = [ax1,ay1,ax2,ay2]\n            a = (ax2-ax1)*(ay2-ay1)\n            area.append(a)\n            bbox.append(box)\n\n        boxes = torch.as_tensor(bbox, dtype=torch.int64)\n        labels = torch.as_tensor(class_id, dtype=torch.int64)\n        masks = torch.as_tensor(mask, dtype=torch.uint8)\n        image_id = torch.tensor([idx])\n        \n        target = {}\n        target[\"boxes\"] = boxes\n        target[\"labels\"] = labels\n        target[\"masks\"] = masks\n        target[\"image_id\"] = image_id\n        \n        return img_tr, target\n    \ntraindata = traindataset(df,transform = None)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"len(traindata)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"data_loader = torch.utils.data.DataLoader(traindata, batch_size=2, shuffle=True, num_workers=2,collate_fn=lambda x: tuple(zip(*x)))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"data_frame = df[df['class_name'] == 'Pleural effusion']","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"class validdataset(torch.utils.data.Dataset):\n\n    def __init__(self, data_frame, transform):\n        super().__init__()\n        \n        self.input_files = list(set(data_frame['image_id'].values))\n        self.data_frame = data_frame\n        self.transform = transform\n    \n    def __len__(self) :\n        return len(self.input_files)\n\n    def __getitem__(self, idx):\n        \n        input_files = self.input_files\n        #print(idx)\n        img_id = input_files[10]\n        df = self.data_frame\n        \n        fdf = df[df['image_id'] == img_id]\n        m,n = 1024,1024\n        dff = fdf.sort_values(by=['x_min'])\n        class_id = [m+1 for m in list(dff['class_id'].values)]\n        N = len(class_id)\n        \n        image_path  = '../input/vinbigdata-chest-xray-abnormalities-detection/train/'+img_id+'.dicom'\n        img_pxl = pydicom.read_file(image_path).pixel_array\n        res = (img_pxl.shape[0]*img_pxl.shape[1])/(m*n) \n        img = resize(img_pxl,(1024,1024),anti_aliasing=True)\n        img_np = img.astype(np.float32())\n        img_tr = torch.from_numpy(img_np).unsqueeze(0)\n\n        xmin_res = [x/res for x in list(dff['x_min'].values)]\n        xmax_res = [xm/res for xm in list(dff['x_max'].values)]\n        ymax_res = [y/res for y in list(dff['y_max'].values)]\n        ymin_res = [ym/res for ym in list(dff['y_min'].values)]\n        b = 0\n        bbox = []\n        for b in range(N):\n            ax1,ax2,ay1,ay2 = xmin_res[b],xmax_res[b],ymin_res[b],ymax_res[b]\n            box = [ax1,ay1,ax2,ay2]\n            bbox.append(box)\n        return img, img_tr, bbox\n    \nvaliddata = validdataset(data_frame,transform = None)\nvaliddata_loader = torch.utils.data.DataLoader(validdata, batch_size=1, shuffle=True, num_workers=1)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test_files = os.listdir('../input/vinbigdata-chest-xray-abnormalities-detection/test/')\nclass testdataset(torch.utils.data.Dataset):\n\n    def __init__(self, test_files, transform):\n        super().__init__()\n\n        self.test_files = test_files\n        self.transform = transform\n        \n    def __len__(self) -> int:\n        return len(test_files)\n\n    def __getitem__(self, index: int):\n        img_id = self.test_files[index]\n        image_path  = '../input/vinbigdata-chest-xray-abnormalities-detection/test/'+img_id\n        dicom_data = pydicom.read_file(image_path)\n        img_pixel = dicom_data.pixel_array \n        image = resize(img_pixel,(1024,1024),anti_aliasing=True)\n        img_numpy = image.astype(np.float32())\n        img_tensor = torch.from_numpy(img_numpy).unsqueeze(0)\n\n        return img_tensor.unsqueeze(0)\ntestdata = testdataset(test_files,transform = None)\ntest_loader = torch.utils.data.DataLoader(testdata, batch_size=1, shuffle=True, num_workers=1,collate_fn=lambda x: tuple(zip(*x)))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"import torchvision\nfrom torchvision.models.detection.faster_rcnn import FastRCNNPredictor\nfrom torchvision.models.detection.mask_rcnn import MaskRCNNPredictor\n\n\ndef get_model_instance_segmentation(num_classes):\n    # load an instance segmentation model pre-trained pre-trained on COCO\n    model = torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=True)\n\n    # get number of input features for the classifier\n    in_features = model.roi_heads.box_predictor.cls_score.in_features\n    # replace the pre-trained head with a new one\n    model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)\n\n    # now get the number of input features for the mask classifier\n    in_features_mask = model.roi_heads.mask_predictor.conv5_mask.in_channels\n    hidden_layer = 256\n    # and replace the mask predictor with a new one\n    model.roi_heads.mask_predictor = MaskRCNNPredictor(in_features_mask,\n                                                       hidden_layer,\n                                                       num_classes)\n\n    return model","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model = get_model_instance_segmentation(num_classes)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"device = torch.device('cuda:0')\nmodel.to(device)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model.load_state_dict(torch.load('../input/mask-rcnn-fop/mask_rcnn_sd1 (1).pth'))\nparams = [p for p in model.parameters() if p.requires_grad]\noptimizer = torch.optim.SGD(params, lr=0.005,\n                            momentum=0.9, weight_decay=0.0005)\nlr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer,\n                                               step_size=3,\n                                               gamma=0.1)\nnum_epochs = 5\nloss_values = []\nfor epoch in range(num_epochs):\n    metric_logger = train_one_epoch(model, optimizer, data_loader, device, epoch, print_freq=2197)\n    loss_values.append(metric_logger.meters['loss'].median)\n    torch.save(model.state_dict(),'./mask_rcnn_sd'+str(epoch)+'.pth')\n    torch.save(model,'./mask_rcnn'+str(epoch)+'.pth')\n    # update the learning rate\n    lr_scheduler.step()\n    # evaluate on the test dataset\n    #evaluate(model, test, device=device)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"loss_valueso = [0.8922919034957886, 1.0178143978118896, 1.0720345973968506, 0.9409962892532349, 1.1191381216049194]","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(metric_logger)\nprint(metric_logger.meters['loss'].median)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model.load_state_dict(torch.load('./mask_rcnn_sd4.pth'))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def plot_image(img,bboxes):\n    img_resize = img\n    bbox = bboxes\n    color = ['r','b','g','y','w','c','m','w','c','m','r','b','g','y','w','c','m','w','c','m','r','b','g','y','w','c','m','w','c','m','r','b','g','y','w','c','m','w','c','m']\n    plt.imshow(img_resize,cmap='gray')\n    for m,p in enumerate(bbox):\n        plt.gca().add_patch(Rectangle((p[0], p[1]), (p[2]-p[0]), (p[3]-p[1]),linewidth=1,edgecolor=color[m],facecolor='none'))\n    plt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model.eval()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"for pred in validdata:\n    img_o = pred[0]\n    image_tst = pred[1]\n    output = model(pred[1].unsqueeze(0).to(device))\n    pred_boxes = output[0]['boxes'].cpu().detach().numpy()\n    pred_scores = list(output[0]['scores'].cpu().detach().numpy())\n    #print(pred_scores)\n    predictions = [pred_scores.index(p) for p in pred_scores if p > 0.7]\n    print(predictions)\n    bboxes = []\n    predscores = []\n    for val in predictions:\n        bboxes.append(pred_boxes[val])\n        predscores.append(pred_scores[val])\n    o_box = pred[2]\n    plot_image(img_o,o_box)\n    plot_image(img_o,bboxes)\n    break","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"dfff = df.iloc[15]\nimg_tst = pydicom.read_file('../input/vinbigdata-chest-xray-abnormalities-detection/train/'+dfff['image_id']+'.dicom').pixel_array","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"image_tst = resize(img_tst,(1024,1024),anti_aliasing=True)\nimg_numpy_tst = image_tst.astype(np.float32())\nimg_tensor_tst = torch.from_numpy(img_numpy_tst).unsqueeze(0)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model.eval()\noutput = model(img_tensor_tst.unsqueeze(0).to(device))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"output","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def plot_image(img,bboxes):\n    img_resize = img\n    bbox = bboxes\n    color = ['r','b','g','y','w','c','m','w','c','m']\n    plt.imshow(img_resize,cmap='gray')\n    for m,p in enumerate(bbox):\n        plt.gca().add_patch(Rectangle((p[0], p[1]), (p[2]-p[0]), (p[3]-p[1]),linewidth=1,edgecolor=color[m],facecolor='none'))\n    plt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def plot_o_image(img,dd):\n    img_resize = img\n    dd = dd\n    xmin_o = list(dd['x_min'].values)\n    ymin_o = list(dd['y_min'].values)\n    xmax_o = list(dd['x_max'].values)\n    ymax_o = list(dd['y_max'].values)\n    bbox = bboxes\n    color = ['r','b','g','y','w','c','m','w','c','m','r','b','g','y','w','c','m','w','c','m','r','b','g','y','w','c','m','w','c','m','r','b','g','y','w','c','m','w','c','m']\n    plt.imshow(img_resize,cmap='gray')\n    print(xmin_o)\n    for i in range(len(xmin_o)):\n        plt.gca().add_patch(Rectangle((xmin_o[i], ymin_o[i]), (xmax_o[i]-xmin_o[i]), (ymax_o[i]-ymin_o[i]),linewidth=1,edgecolor=color[i],facecolor='none'))\n    plt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"output","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"pred_boxes = output[0]['boxes'].cpu().detach().numpy()\npred_scores = list(output[0]['scores'].cpu().detach().numpy())\nprint(pred_scores)\npredictions = [pred_scores.index(p) for p in pred_scores if p > 0.4]\nprint(predictions)\nbboxes = []\npredscores = []\nfor val in predictions:\n    bboxes.append(pred_boxes[val])\n    predscores.append(pred_scores[val])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"dd = df[df['image_id'] == dfff['image_id']]\ndd = dd.sort_values(by=['x_min'])\nprint(dd)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(bboxes,predscores)\nplot_o_image(img_tst,dd)\nplot_image(image_tst,bboxes)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"pred_boxes","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#!pip install pycocotools","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"class SmoothedValue(object):\n    \"\"\"Track a series of values and provide access to smoothed values over a\n    window or the global series average.\n    \"\"\"\n\n    def __init__(self, window_size=20, fmt=None):\n        if fmt is None:\n            fmt = \"{median:.4f} ({global_avg:.4f})\"\n        self.deque = deque(maxlen=window_size)\n        self.total = 0.0\n        self.count = 0\n        self.fmt = fmt\n\n    def update(self, value, n=1):\n        self.deque.append(value)\n        self.count += n\n        self.total += value * n\n\n    def synchronize_between_processes(self):\n        \"\"\"\n        Warning: does not synchronize the deque!\n        \"\"\"\n        if not is_dist_avail_and_initialized():\n            return\n        t = torch.tensor([self.count, self.total], dtype=torch.float64, device='cuda')\n        dist.barrier()\n        dist.all_reduce(t)\n        t = t.tolist()\n        self.count = int(t[0])\n        self.total = t[1]\n\n    @property\n    def median(self):\n        d = torch.tensor(list(self.deque))\n        return d.median().item()\n\n    @property\n    def avg(self):\n        d = torch.tensor(list(self.deque), dtype=torch.float32)\n        return d.mean().item()\n\n    @property\n    def global_avg(self):\n        return self.total / self.count\n\n    @property\n    def max(self):\n        return max(self.deque)\n\n    @property\n    def value(self):\n        return self.deque[-1]\n\n    def __str__(self):\n        return self.fmt.format(\n            median=self.median,\n            avg=self.avg,\n            global_avg=self.global_avg,\n            max=self.max,\n            value=self.value)\n\n\ndef all_gather(data):\n    \"\"\"\n    Run all_gather on arbitrary picklable data (not necessarily tensors)\n    Args:\n        data: any picklable object\n    Returns:\n        list[data]: list of data gathered from each rank\n    \"\"\"\n    world_size = get_world_size()\n    if world_size == 1:\n        return [data]\n\n    # serialized to a Tensor\n    buffer = pickle.dumps(data)\n    storage = torch.ByteStorage.from_buffer(buffer)\n    tensor = torch.ByteTensor(storage).to(\"cuda\")\n\n    # obtain Tensor size of each rank\n    local_size = torch.tensor([tensor.numel()], device=\"cuda\")\n    size_list = [torch.tensor([0], device=\"cuda\") for _ in range(world_size)]\n    dist.all_gather(size_list, local_size)\n    size_list = [int(size.item()) for size in size_list]\n    max_size = max(size_list)\n\n    # receiving Tensor from all ranks\n    # we pad the tensor because torch all_gather does not support\n    # gathering tensors of different shapes\n    tensor_list = []\n    for _ in size_list:\n        tensor_list.append(torch.empty((max_size,), dtype=torch.uint8, device=\"cuda\"))\n    if local_size != max_size:\n        padding = torch.empty(size=(max_size - local_size,), dtype=torch.uint8, device=\"cuda\")\n        tensor = torch.cat((tensor, padding), dim=0)\n    dist.all_gather(tensor_list, tensor)\n\n    data_list = []\n    for size, tensor in zip(size_list, tensor_list):\n        buffer = tensor.cpu().numpy().tobytes()[:size]\n        data_list.append(pickle.loads(buffer))\n\n    return data_list\n\n\ndef reduce_dict(input_dict, average=True):\n    \"\"\"\n    Args:\n        input_dict (dict): all the values will be reduced\n        average (bool): whether to do average or sum\n    Reduce the values in the dictionary from all processes so that all processes\n    have the averaged results. Returns a dict with the same fields as\n    input_dict, after reduction.\n    \"\"\"\n    world_size = get_world_size()\n    if world_size < 2:\n        return input_dict\n    with torch.no_grad():\n        names = []\n        values = []\n        # sort the keys so that they are consistent across processes\n        for k in sorted(input_dict.keys()):\n            names.append(k)\n            values.append(input_dict[k])\n        values = torch.stack(values, dim=0)\n        dist.all_reduce(values)\n        if average:\n            values /= world_size\n        reduced_dict = {k: v for k, v in zip(names, values)}\n    return reduced_dict\n\n\nclass MetricLogger(object):\n    def __init__(self, delimiter=\"\\t\"):\n        self.meters = defaultdict(SmoothedValue)\n        self.delimiter = delimiter\n\n    def update(self, **kwargs):\n        for k, v in kwargs.items():\n            if isinstance(v, torch.Tensor):\n                v = v.item()\n            assert isinstance(v, (float, int))\n            self.meters[k].update(v)\n\n    def __getattr__(self, attr):\n        if attr in self.meters:\n            return self.meters[attr]\n        if attr in self.__dict__:\n            return self.__dict__[attr]\n        raise AttributeError(\"'{}' object has no attribute '{}'\".format(\n            type(self).__name__, attr))\n\n    def __str__(self):\n        loss_str = []\n        for name, meter in self.meters.items():\n            loss_str.append(\n                \"{}: {}\".format(name, str(meter))\n            )\n        return self.delimiter.join(loss_str)\n\n    def synchronize_between_processes(self):\n        for meter in self.meters.values():\n            meter.synchronize_between_processes()\n\n    def add_meter(self, name, meter):\n        self.meters[name] = meter\n\n    def log_every(self, iterable, print_freq, header=None):\n        i = 0\n        if not header:\n            header = ''\n        start_time = time.time()\n        end = time.time()\n        iter_time = SmoothedValue(fmt='{avg:.4f}')\n        data_time = SmoothedValue(fmt='{avg:.4f}')\n        space_fmt = ':' + str(len(str(len(iterable)))) + 'd'\n        log_msg = self.delimiter.join([\n            header,\n            '[{0' + space_fmt + '}/{1}]',\n            'eta: {eta}',\n            '{meters}',\n            'time: {time}',\n            'data: {data}',\n            'max mem: {memory:.0f}'\n        ])\n        MB = 1024.0 * 1024.0\n        for obj in iterable:\n            data_time.update(time.time() - end)\n            yield obj\n            iter_time.update(time.time() - end)\n            if i % print_freq == 0 or i == len(iterable) - 1:\n                eta_seconds = iter_time.global_avg * (len(iterable) - i)\n                eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))\n                print(log_msg.format(\n                    i, len(iterable), eta=eta_string,\n                    meters=str(self),\n                    time=str(iter_time), data=str(data_time),\n                    memory=torch.cuda.max_memory_allocated() / MB))\n            i += 1\n            end = time.time()\n        total_time = time.time() - start_time\n        total_time_str = str(datetime.timedelta(seconds=int(total_time)))\n        print('{} Total time: {} ({:.4f} s / it)'.format(\n            header, total_time_str, total_time / len(iterable)))\n\n\ndef collate_fn(batch):\n    return tuple(zip(*batch))\n\n\ndef warmup_lr_scheduler(optimizer, warmup_iters, warmup_factor):\n\n    def f(x):\n        if x >= warmup_iters:\n            return 1\n        alpha = float(x) / warmup_iters\n        return warmup_factor * (1 - alpha) + alpha\n\n    return torch.optim.lr_scheduler.LambdaLR(optimizer, f)\n\n\ndef mkdir(path):\n    try:\n        os.makedirs(path)\n    except OSError as e:\n        if e.errno != errno.EEXIST:\n            raise\n\n\ndef setup_for_distributed(is_master):\n    \"\"\"\n    This function disables printing when not in master process\n    \"\"\"\n    import builtins as __builtin__\n    builtin_print = __builtin__.print\n\n    def print(*args, **kwargs):\n        force = kwargs.pop('force', False)\n        if is_master or force:\n            builtin_print(*args, **kwargs)\n\n    __builtin__.print = print\n\n\ndef is_dist_avail_and_initialized():\n    if not dist.is_available():\n        return False\n    if not dist.is_initialized():\n        return False\n    return True\n\n\ndef get_world_size():\n    if not is_dist_avail_and_initialized():\n        return 1\n    return dist.get_world_size()\n\n\ndef get_rank():\n    if not is_dist_avail_and_initialized():\n        return 0\n    return dist.get_rank()\n\n\ndef is_main_process():\n    return get_rank() == 0\n\n\ndef save_on_master(*args, **kwargs):\n    if is_main_process():\n        torch.save(*args, **kwargs)\n\n\ndef init_distributed_mode(args):\n    if 'RANK' in os.environ and 'WORLD_SIZE' in os.environ:\n        args.rank = int(os.environ[\"RANK\"])\n        args.world_size = int(os.environ['WORLD_SIZE'])\n        args.gpu = int(os.environ['LOCAL_RANK'])\n    elif 'SLURM_PROCID' in os.environ:\n        args.rank = int(os.environ['SLURM_PROCID'])\n        args.gpu = args.rank % torch.cuda.device_count()\n    else:\n        print('Not using distributed mode')\n        args.distributed = False\n        return\n\n    args.distributed = True\n\n    torch.cuda.set_device(args.gpu)\n    args.dist_backend = 'nccl'\n    print('| distributed init (rank {}): {}'.format(\n        args.rank, args.dist_url), flush=True)\n    torch.distributed.init_process_group(backend=args.dist_backend, init_method=args.dist_url,\n                                         world_size=args.world_size, rank=args.rank)\n    torch.distributed.barrier()\n    setup_for_distributed(args.rank == 0)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"import warnings\nwarnings.filterwarnings('ignore')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def train_one_epoch(model, optimizer, data_loader, device, epoch, print_freq):\n    model.train()\n    metric_logger = MetricLogger(delimiter=\"  \")\n    metric_logger.add_meter('lr', SmoothedValue(window_size=1, fmt='{value:.6f}'))\n    header = 'Epoch: [{}]'.format(epoch)\n\n    lr_scheduler = None\n    if epoch == 0:\n        warmup_factor = 1. / 1000\n        warmup_iters = min(1000, len(data_loader) - 1)\n\n        lr_scheduler = warmup_lr_scheduler(optimizer, warmup_iters, warmup_factor)\n\n    for images, targets in metric_logger.log_every(data_loader, print_freq, header):\n        images = list(image.to(device) for image in images)\n        targets = [{k: v.to(device) for k, v in t.items()} for t in targets]\n        #print('image_id',targets[0]['image_id'])\n        #print('image--',images[0].shape)\n        #print('targets--',targets[0]['boxes'].shape,targets[0]['labels'],targets[0]['masks'].shape)\n        loss_dict = model(images, targets)\n        #print('loss_dict-----',loss_dict)\n        #print('epoch')\n        losses = sum(loss for loss in loss_dict.values())/len(loss_dict.values())\n        #print('losses-----',losses)\n        # reduce losses over all GPUs for logging purposes\n        loss_dict_reduced = reduce_dict(loss_dict)\n        losses_reduced = sum(loss for loss in loss_dict_reduced.values())\n        #print('losses_reduced-----',losses_reduced)\n        optimizer.zero_grad()\n        #print('zero grad over')\n        losses.backward()\n        #print('losses backward over')\n        optimizer.step()\n        #print('optimizer step over')\n        if lr_scheduler is not None:\n            #print('lr_scheduler',lr_scheduler)\n            lr_scheduler.step()\n            #print('lr_scheduler')\n        metric_logger.update(loss=losses_reduced, **loss_dict_reduced)\n        metric_logger.update(lr=optimizer.param_groups[0][\"lr\"])\n        print('before del',psutil.Process(os.getpid()).memory_info().rss / 1024 ** 2)\n        del losses_reduced,loss_dict_reduced,images,targets\n        print('after del',psutil.Process(os.getpid()).memory_info().rss / 1024 ** 2)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"device = torch.device('cuda:0')\n#device = torch.device('cpu')\n\n#model_ft = torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=True)\n#in_features = model_ft.roi_heads.box_predictor.cls_score.in_features\n#print('infeatures',in_features)\n#model_ft.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)\n#in_features_mask = model_ft.roi_heads.mask_predictor.conv5_mask.in_channels\n#hidden_layer = 256\n#model_ft.roi_heads.mask_predictor = MaskRCNNPredictor(in_features_mask, hidden_layer, num_classes)\nmodel_ft = model\nmodel_ft.to(device)\n\nfor param in model_ft.parameters():\n    param.requires_grad = True","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"params = [p for p in model_ft.parameters() if p.requires_grad]\noptimizer = torch.optim.SGD(params, lr=0.001, momentum=0.9, weight_decay=0.0005)\nlr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer,\n                                               step_size=5,\n                                               gamma=0.1)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"next(model_ft.parameters()).is_cuda","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#model_ft.load_state_dict(torch.load('../input/maskrcnn-op-1/previous_model_sd (1).pth'))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"optimizer = optim.Adam(model_ft.parameters())\ntrain_losses = []\nepochs = 4\nfor epoch in range(epochs):\n    model_ft.train()\n    running_loss = 0\n    size = 0\n    print('epoch',epoch)\n    for a,i in enumerate(data_loader):\n        #print('iter number'+str(a)+' for epoch '+str(epoch))\n        images = list(image.to(device) for image in i[0])\n        targets = [{k: v.to(device) for k, v in t.items()} for t in i[1]]\n        \n        #model_ft.eval()\n        #print('targets',targets[0]['boxes'])\n        #output = model_ft(images)\n        #print('outputs',output[0]['boxes'])\n        \n        model_ft.train()\n        optimizer.zero_grad()\n        loss_dict = model_ft(images,targets)\n        losses = sum(loss for loss in loss_dict.values())/len(loss_dict.values())\n        print('loss for batch_no '+str(a),losses)\n        running_loss += losses.item()\n        losses.backward()\n        torch.nn.utils.clip_grad_norm_(model_ft.parameters(), 1000000)\n        optimizer.step()\n        #print('targets',targets[0]['boxes'])\n        del images,targets,loss_dict\n    train_losses.append(float(running_loss)/len(data_loader))\n    torch.save(model_ft.state_dict(),'./previous_model_sd.pth')\n    torch.save(model_ft,'./'+str(epoch)+'mask_rcnn.pth')\n    print(epoch,'epoch completed')\n    print('train_looses',train_losses)\n    #print('space',psutil.Process(os.getpid()).memory_info().rss / 1024 ** 2)\ntorch.save(model_ft.state_dict(),'./final_mask_rcnn_sd.pth')\ntorch.save(model_ft,'./final_mask_rcnn.pth')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#!cat /opt/conda/lib/python3.7/site-packages/torchvision/models/detection/roi_heads.py","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#!cat /opt/conda/lib/python3.7/site-packages/torchvision/models/detection/roi_heads.py","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#model_ft.eval()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#for b,val in enumerate(data_loader):\n#    image = list(img.to(device) for img in val[0])\n#    targets = [{k: v.to(device) for k, v in t.items()} for t in val[1]]\n#    outputs = model_ft(image)\n#    outputs = [{k: v for k, v in t.items()} for t in outputs]\n    #if len(outputs[0]['boxes']) >= 1:\n#    print('target',targets[0]['boxes'])\n#    print('output',outputs[0]['boxes'])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"images = glob.glob('../input/vinbigdata-chest-xray-abnormalities-detection/train/*.dicom')"},{"metadata":{},"cell_type":"markdown","source":"for i in images:\n    j = pydicom.read_file(i).pixel_array\n    mask = np.ones(j.shape)\n    mask[50:100,150:250] = 0\n    plt.imshow(j*mask)\n    plt.show()\n    print(j)\n    break"},{"metadata":{"trusted":true},"cell_type":"markdown","source":"print(psutil.Process(os.getpid()).memory_info().rss / 1024 ** 2)"}],"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat":4,"nbformat_minor":4}