{"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_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\nimport os\ndf = pd.read_csv(\"../input/results-vinbin/results/tmp_debug/submission.csv\")\ndf2 = pd.read_csv(\"../input/241solution/submission.csv\")\ndf2","metadata":{"_uuid":"76e4cf87-fe6a-4362-b388-13e0ecd2731c","_cell_guid":"a544f4e6-ca00-4ddf-b17d-062c373219d1","execution":{"iopub.status.busy":"2022-01-10T10:23:09.144069Z","iopub.execute_input":"2022-01-10T10:23:09.144503Z","iopub.status.idle":"2022-01-10T10:23:09.366221Z","shell.execute_reply.started":"2022-01-10T10:23:09.144473Z","shell.execute_reply":"2022-01-10T10:23:09.365197Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# ConvXray","metadata":{}},{"cell_type":"code","source":"########################################################################################################################\n#                                                      IMPORTS                                                         #\n########################################################################################################################\n\nimport os\nfrom PIL import Image\nimport pandas as pd\nfrom tqdm.auto import tqdm\nfrom collections import Counter\nfrom typing import Any, Dict\nimport cv2\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport seaborn as sns\nimport torch\nimport pydicom\nfrom pydicom.pixel_data_handlers.util import apply_voi_lut\n\n\n########################################################################################################################\n#                                                Class definition                                                      #\n########################################################################################################################\n\n\n# ------------------------------------#\n#         USEFUL FUNCTIONS            #\n# ------------------------------------#\n\ndef read_xray(path, voi_lut=True, fix_monochrome=True):\n    # Original from: https://www.kaggle.com/raddar/convert-dicom-to-np-array-the-correct-way\n    dicom = pydicom.read_file(path)\n    # VOI LUT (if available by DICOM device) is used to transform raw DICOM data to \"human-friendly\" view\n    if voi_lut:\n        data = apply_voi_lut(dicom.pixel_array, dicom)\n    else:\n        data = dicom.pixel_array\n    # depending on this value, X-ray may look inverted - fix that:\n    if fix_monochrome and dicom.PhotometricInterpretation == \"MONOCHROME1\":\n        data = np.amax(data) - data\n    data = data - np.min(data)\n    data = data / np.max(data)\n    data = (data * 255).astype(np.uint8)\n    return data\n\n\ndef resize(array, size, keep_ratio=False, resample=Image.LANCZOS):\n    # Original from: https://www.kaggle.com/xhlulu/vinbigdata-process-and-resize-to-image\n    im = Image.fromarray(array)\n    if keep_ratio:\n        im.thumbnail((size, size), resample)\n    else:\n        im = im.resize((size, size), resample)\n    return im\n\n\n# DRAW BOUNDING-BOXES #\ndef draw_bboxes(img, tl, br, rgb, score, label=\"\", label_location=\"tl\", opacity=0.1, line_thickness=0, font_scale=0.2,\n                font_thickness=1):\n    \"\"\" Draw bounding boxes in an image\"\"\"\n    box = np.uint8(np.ones((br[1] - tl[1], br[0] - tl[0], 3)) * rgb)\n    sub_combo = cv2.addWeighted(img[tl[1]:br[1], tl[0]:br[0], :], 1 - opacity, box, opacity, 1.0)\n    img[tl[1]:br[1], tl[0]:br[0], :] = sub_combo\n    if line_thickness > 0:\n        img = cv2.rectangle(img, tuple(tl), tuple(br), rgb, line_thickness)\n    if label:\n        font = cv2.FONT_HERSHEY_SIMPLEX\n        font_line_type = cv2.LINE_AA\n        label = label.upper()\n        text_width, text_height = cv2.getTextSize(label, font, font_scale, font_thickness)[0]\n        label_origin = {\"tl\": tl, \"br\": br, \"tr\": (br[0], tl[1]), \"bl\": (tl[0], br[1])}[label_location]\n        label_offset = {\n            \"tl\": np.array([0, -10]), \"br\": np.array([-text_width, text_height + 10]),\n            \"tr\": np.array([-text_width, -10]), \"bl\": np.array([0, text_height + 10])\n        }[label_location]\n        img = cv2.putText(img, label + \"(\" + str(round(score, 2)) + \")\", tuple(label_origin + label_offset), font,\n                          font_scale, rgb, font_thickness, font_line_type)\n    return img\n\n\ndef show_xray(*img, title: list or str = \"\", axis: bool = False, size: tuple = (20, 13)):\n    \"\"\" Show with mathlab plot as many X-rays than passed as argument\"\"\"\n    plt.figure(figsize=size)\n    for n in range(len(img)):\n        plt.subplot(len(img), 2, n + 1)\n        plt.axis(axis)\n        plt.imshow(img[n], cmap=\"gray\")\n        if len(title) == n and type(title) == \"array\" :\n            titre = title[n]\n        elif type(title) == str:\n            titre = title\n        else:\n            raise ValueError(\"number of titles don't match with the number of Xray\")\n        plt.title(titre)\n    plt.show()\n\n\ndef predict_bbox(image_to_predict, predictor, resized_width=256, resized_height=256):\n    \"\"\" Return predictions with labels, scores and bboxes\"\"\"\n    with torch.no_grad():  # https://github.com/sphinx-doc/sphinx/issues/4258\n        inputs_list = []\n        img = image_to_predict.copy()\n        if predictor.input_format == \"RGB\":\n            img = img[:, :, ::-1]\n        height, width = img.shape[:2]\n        inputs = {\"image\": image, \"height\": height, \"width\": width}\n        inputs_list.append(inputs)\n        predictions = predictor.model(inputs_list)\n    instances = predictions[0][\"instances\"]\n    if len(instances) == 0:\n        pred_classes = 14\n        pred_boxes = [0, 0, 1, 1]\n        pred_scores = 1.0\n    else:\n        fields: Dict[str, Any] = instances.get_fields()\n        pred_classes, pred_scores, pred_boxes = fields[\"pred_classes\"], fields[\"scores\"], fields[\"pred_boxes\"].tensor\n        h_ratio, w_ratio = height / resized_height, width / resized_width\n        pred_boxes[:, [0, 2]] *= w_ratio\n        pred_boxes[:, [1, 3]] *= h_ratio\n        pred_classes, pred_boxes, pred_scores = pred_classes.cpu().numpy(), pred_boxes.cpu().numpy(), pred_scores.cpu().numpy()\n    return pred_classes, pred_boxes, pred_scores\n\n\n\n\n# ------------------------------------#\n#             XRAY CLASS              #\n# ------------------------------------#\n\nclass Xray:\n\n    def __init__(self, path: str = \"\", folder: str = \"\", name: str = \"\", extension: str = \"\",\n                 th: float = 0.25, palette: str = \"icefire\", predictor=False):\n        if extension == \"\":\n            self.extension = path\n        else:\n            self.extension = extension\n        if name == \"\":\n            self.name = path\n        else:\n            self.name = name\n        if folder == \"\":\n            self.folder = path\n        else:\n            self.folder = folder\n        self.path = path\n        self.image = self.extension\n        self.shape = self.image.shape\n        self.height, self.width = self.shape[0], self.shape[1]\n        self.th = th\n        self.palette = [tuple([int(x) for x in np.array(c) * (255, 255, 255)]) for c in sns.color_palette(palette, 15)]\n        self.predictor = predictor\n    \n    @property\n    def image(self):\n        return self._image\n    \n    @image.setter\n    def image(self,ext):\n        if ext == 'png':\n            self._image = cv2.imread(self.path)\n        elif ext == \"dicom\":\n            self._image = read_xray(self.path)\n        else :\n            raise ValueError(\"extention is not possible\")\n            \n    @property\n    def path(self):\n        return self._path\n\n    @path.setter\n    def path(self, value):\n        if value == \"\":\n            if self.folder != \"\" and self.name != \"\" and self.extension != \"\":\n                self._path = self.folder + \"/\" + self.name + \".\" + self.extension\n            else:\n                raise ValueError(\"Please provide a complete path or name, folder and extension values\")\n        else:\n            self._path = value\n\n    @property\n    def extension(self):\n        return self._extension\n\n    @extension.setter\n    def extension(self, value):\n        possible_extensions = [\"png\", \"dicom\",\"jpg\"]\n        possible_extensions_txt = 'png, dicom, jpg'\n        ext = value.split(\".\")\n        if len(ext) > 1:\n            ext = ext[-1]\n        if ext in possible_extensions:\n            self._extension = ext\n        else:\n            raise ValueError(\"Please enter a valid extension (possible extensions : \" + possible_extensions_txt)\n\n    @property\n    def name(self):\n        return self._name\n\n    @name.setter\n    def name(self, value):\n        split_value = value.split(\".\")\n        if len(split_value) > 1:\n            name = split_value[-2]\n            self._name = name.split(\"/\")[-1]\n        else:\n            self._name = split_value\n\n    @property\n    def folder(self):\n        return self._folder\n\n    @folder.setter\n    def folder(self, value):\n        split = value.split(\".\")\n        split = \"\".join(split[:(len(split) - 1)])  # getting rid of the extension\n        split = split.split(\"/\")\n        fold = \"/\".join(split[:(len(split) - 1)])  # getting rid of the name\n        self._folder = fold\n\n    @property\n    def predictor(self):\n        return self._predictor\n\n    @predictor.setter\n    def predictor(self, value):\n        self._predictor = value\n        return self._predictor\n\n    def show(self):\n        show_xray(self.image, title=self.name)\n\n    def predict_bbox(self, resized_width: int = 256, resized_height: int = 256):\n        if not self.predictor:\n            raise ValueError('Predictor is missing. Please provide one using Xray.predictor = predictor')\n        return predict_bbox(self.image, self.predictor, resized_width, resized_height)\n\n    def process_prediction(self, th=False):\n        if not th:\n            th = self.th\n        labels, boxes, scores = self.predict_bbox()\n        processed_scores, processed_labels, processed_boxes = [], [], []\n        if len(labels) > 1:\n            count_dict = Counter(labels.tolist())\n        for score, box, label in zip(scores, boxes, labels):\n            score_i = score\n            # aortic enlargement\n            if int(label) == 0 and count_dict[label] != 1:\n                best_score = np.max(scores[np.where(labels == label)])  # best score for aortic enlargement\n                if score < best_score:\n                    score_i = 0\n            # cardiomegaly\n            if int(label) == 3:\n                score_i = score / 2\n                if np.any(labels == 10):  # cardiomegaly + pleuresie => pas de cardiomégalie\n                    score_i = 0\n            if int(label) == 9:  # other lesion\n                score_i = score / 1.3\n            print(label + \" : \" + str(score) + ' ( ' + str(score_i) + ' ) ')\n            processed_scores.append(score_i)\n            processed_labels.append(label)\n            processed_boxes.append(box)\n        return processed_labels, processed_boxes, processed_scores\n\n        def predicted_image(self, labels, boxes, scores):\n            predicted_img = self.image.copy()\n            nb_box = 0\n            for label, box, score in labels, boxes, scores:\n                if score_i > self.th:\n                    predicted_img = draw_bboxes(predicted_img, (int(box[0]), int(box[1])), (int(box[2]), int(box[3])),\n                                                self.palette[label], score, label=self.mapping[label],\n                                                label_location=\"tr\",\n                                                opacity=0.2, line_thickness=1)\n                nb_box += 1\n                if nb_box == 0:\n                    predicted_img = draw_bboxes(predicted_img, (40, self.height - 40), (self.width - 40, self.height),\n                                                self.palette[14],\n                                                1 - scores[0], label=\"NORMAL\", label_location=\"tl\", opacity=0.2,\n                                                line_thickness=1)\n\n        return predicted_img\n\n\n    \nclass Xray_dataset:\n    \n    def __init__(self,files):\n        self.files = [Xray(file) for file in files]\n\n        \n    \n    \n    \n    \n    \n    \n    \n    \n    \nfrom typing import Any\nimport yaml\n\ndef save_yaml(filepath: str, content: Any, width: int = 120):\n    with open(filepath, \"w\") as f:\n        yaml.dump(content, f, width=width)\n    \n    \n    \n    \n    \nfrom dataclasses import dataclass, field\nfrom typing import Dict, Any, Tuple, Union, List\n\n\n@dataclass\nclass Flags:\n    # General\n    debug: bool = True\n    outdir: str = \"results/det\"\n    device: str = \"cuda:0\"\n\n    # Data config\n    imgdir_name: str = \"vinbigdata-chest-xray-resized-png-256x256\"\n    # split_mode: str = \"all_train\"  # all_train or valid20\n    seed: int = 111\n    target_fold: int = 0  # 0~4\n    label_smoothing: float = 0.0\n    # Model config\n    model_name: str = \"resnet18\"\n    model_mode: str = \"normal\"  # normal, cnn_fixed supported\n    # Training config\n    epoch: int = 20\n    batchsize: int = 8\n    valid_batchsize: int = 16\n    num_workers: int = 4\n    snapshot_freq: int = 5\n    ema_decay: float = 0.999  # negative value is to inactivate ema.\n    scheduler_type: str = \"\"\n    scheduler_kwargs: Dict[str, Any] = field(default_factory=lambda: {})\n    scheduler_trigger: List[Union[int, str]] = field(default_factory=lambda: [1, \"iteration\"])\n    aug_kwargs: Dict[str, Dict[str, Any]] = field(default_factory=lambda: {})\n    mixup_prob: float = -1.0  # Apply mixup augmentation when positive value is set.\n\n    def update(self, param_dict: Dict) -> \"Flags\":\n        # Overwrite by `param_dict`\n        for key, value in param_dict.items():\n            if not hasattr(self, key):\n                raise ValueError(f\"[ERROR] Unexpected key for flag = {key}\")\n            setattr(self, key, value)\n        return self\n    \n    \n    \n#####################################################\n#  TESTS\n\n\nif __name__ == \"__main__\":\n    print('tests went good')","metadata":{"execution":{"iopub.status.busy":"2022-01-10T10:23:09.368653Z","iopub.execute_input":"2022-01-10T10:23:09.369343Z","iopub.status.idle":"2022-01-10T10:23:10.87819Z","shell.execute_reply.started":"2022-01-10T10:23:09.369298Z","shell.execute_reply":"2022-01-10T10:23:10.877292Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"n=15\nname=df2.loc[n,\"image_id\"]\npred = df2.loc[n,\"PredictionString\"]\nxray = Xray(\"../input/vinbigdata-chest-xray-abnormalities-detection/test/\"+name+\".dicom\")\nxray.show()\n\nsplited = pred.split(\" \")\nresult = {\"label\" : [],\"score\" : [],'xmin' : [],\"ymin\" : [],\"xmax\" : [], \"ymax\" : []}\n\nfor n in range(len(splited)//6):\n    result[\"label\"].append(splited[n*6])\n    result[\"score\"].append(splited[n*6+1])\n    result[\"xmin\"].append(splited[n*6+2])\n    result[\"ymin\"].append(splited[n*6+3])\n    result[\"xmax\"].append(splited[n*6+4])\n    result[\"ymax\"].append(splited[n*6+5])\n    \n\nresult_df = pd.DataFrame(result)\nresult_df\nn=1","metadata":{"execution":{"iopub.status.busy":"2022-01-10T10:23:10.879654Z","iopub.execute_input":"2022-01-10T10:23:10.880054Z","iopub.status.idle":"2022-01-10T10:23:15.260411Z","shell.execute_reply.started":"2022-01-10T10:23:10.880024Z","shell.execute_reply":"2022-01-10T10:23:15.25941Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\nfrom collections import namedtuple\n\n\nRectangle = namedtuple('Rectangle', 'xmin ymin xmax ymax')\n\nra = Rectangle(3., 3., 5., 5.)\nrb = Rectangle(1., 1., 4., 3.5)\n# intersection here is (3, 3, 4, 3.5), or an area of 1*.5=.5\n\ndef intersection(a, b,normalisation=1):\n    dx = min(a.xmax, b.xmax) - max(a.xmin, b.xmin)\n    dy = min(a.ymax, b.ymax) - max(a.ymin, b.ymin)\n    if (dx>=0) and (dy>=0):\n        return dx*dy/normalisation\n    else :\n        return 0\n    \n\nprint(intersection(ra, rb))","metadata":{"execution":{"iopub.status.busy":"2022-01-10T10:23:15.26211Z","iopub.execute_input":"2022-01-10T10:23:15.262542Z","iopub.status.idle":"2022-01-10T10:23:15.273427Z","shell.execute_reply.started":"2022-01-10T10:23:15.262506Z","shell.execute_reply":"2022-01-10T10:23:15.271935Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"k = 90","metadata":{"execution":{"iopub.status.busy":"2022-01-10T10:43:45.650039Z","iopub.execute_input":"2022-01-10T10:43:45.650412Z","iopub.status.idle":"2022-01-10T10:43:45.654549Z","shell.execute_reply.started":"2022-01-10T10:43:45.650383Z","shell.execute_reply":"2022-01-10T10:43:45.653669Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import seaborn as sns\n\nmode = 'compet'\nnormale = True\n\nwhile normale:\n    normale = False\n    k +=1\n    print(k)\n    name=df2.loc[k,\"image_id\"]\n    pred = df2.loc[k,\"PredictionString\"]\n    xray = Xray(\"../input/vinbigdata-chest-xray-abnormalities-detection/test/\"+name+\".dicom\")\n\n    palette = \"icefire\"\n    palette = [tuple([int(x) for x in np.array(c) * (255, 255, 255)]) for c in sns.color_palette(palette, 15)]\n    predicted = xray.image\n    predicted = cv2.cvtColor(predicted,cv2.COLOR_GRAY2RGB)\n    \n    mapping = {0: 'Elargissement aortique', 1: 'Atelectasie', 2: 'Calcification', 3: 'Cardiomegalie',\n               4: 'Sd alveolaire', 5: 'Sd Interstitiel',6: 'Infiltration', 7: 'Opacite', 8: 'Nodule/Masse',\n               9: 'Autre', 10: 'Pleuresie', 11: 'Epaississement pleural',12: 'Pneumothorax',\n               13: 'Fibrose', 14: 'normal'}\n    decision = {(0,0) : 'fusion',(0,1):'possibleifBig&Right',(0,2):'possible',(0,3):'specificCMG',(0,4):\"?\",(0,5):'?',(0,6):'?',(0,7):'?',(0,8):\"?\",(0,9):\"possible\",(0,10):\"impossible\",(0,11):\"?\",(0,12):\"possible\",(0,13):\"possible\",\n               (1,0):'-',(1,2):\"?\",(1,3):'possibleifBig&Side'}\n\n    splited = pred.split(\" \")\n    \n    result = {\"label\" : [],\"score\" : [],'xmin' : [],\"ymin\" : [],\"xmax\" : [], \"ymax\" : []}\n    for n in range(len(splited)//6):\n        result[\"label\"].append(splited[n*6])\n        result[\"score\"].append(splited[n*6+1])\n        result[\"xmin\"].append(splited[n*6+2])\n        result[\"ymin\"].append(splited[n*6+3])\n        result[\"xmax\"].append(splited[n*6+4])\n        result[\"ymax\"].append(splited[n*6+5])\n\n    result_df = pd.DataFrame(result)\n\n    ####################\n\n    TH = 0.3\n    nb = 0\n    result_df_th = result_df[result_df[\"score\"].astype(\"float\") >= 0.4]\n    result_df_th=result_df_th.reset_index()\n    del result_df_th['index']\n    result_df_th[\"label\"] = result_df_th[\"label\"].astype(\"int\")\n    result_df_th[\"xmin\"] = result_df_th[\"xmin\"].astype(\"int\")\n    result_df_th[\"ymin\"] = result_df_th[\"ymin\"].astype(\"int\")\n    result_df_th[\"xmax\"] = result_df_th[\"xmax\"].astype(\"int\")\n    result_df_th[\"ymax\"] = result_df_th[\"ymax\"].astype(\"int\")\n\n    if len(result_df_th[result_df_th['label'] == 14]) > 1:\n        if len(result_df_th[result_df_th['label'] != 14]) < 1:\n            pd.DataFrame.drop(pd.index(result_df_th[result_df_th['label'].astype('int') == 14][result_df_th['score'].astype('float') != 1]),axis=0, inplace=True)\n        \n    if len(result_df_th[result_df_th['label'] == 14]) == 1 or len(result_df_th[result_df_th['label'] != 14]) > 10 or len(result_df_th[result_df_th['label'] != 0]) < 2:\n        print('NORMAL, next Xray')\n        normale = True\n        \n        \n\n        \n        \nif len(result_df_th) >= 1:\n    for n in range(len(result_df_th)):\n    ################################################################################################################\n    \n        for j in range(len(result_df_th)):\n            if j != n : \n                inter = intersection(Rectangle(result_df_th.loc[j,\"xmin\"],result_df_th.loc[j,\"ymin\"],result_df_th.loc[j,\"xmax\"],result_df_th.loc[j,\"ymax\"]),\n                                     Rectangle(result_df_th.loc[n,\"xmin\"],result_df_th.loc[n,\"ymin\"],result_df_th.loc[n,\"xmax\"],result_df_th.loc[n,\"ymax\"]),\n                                    (result_df_th.loc[j,\"xmax\"] - result_df_th.loc[j,\"xmin\"])*(result_df_th.loc[j,\"ymax\"] - result_df_th.loc[j,\"ymin\"]) ) \n                if inter != 0:\n                    print(f'intersection of {inter} between {mapping[result_df_th.loc[n,\"label\"]]} ({result_df_th.loc[n,\"score\"]}) and {mapping[result_df_th.loc[j,\"label\"]]} ({result_df_th.loc[j,\"score\"]})')\n                    \n                    # Si intersection avec other et autre probable, delete other\n                    if inter > 0.6:\n                        \n                        # Si intersection avec other et autre probable, delete other\n                        if result_df_th.loc[n,\"label\"] == 9 and result_df_th.loc[j,\"score\"] > 0.5 and result_df_th.loc[j,\"score\"] > 2*result_df_th.loc[n,\"score\"] :\n                            print('this {mapping[result_df_th.loc[n,\"label\"]]} is deleted')\n                            pd.DataFrame.drop(result_df_th.iloc[n], inplace=True)\n                            \n                    # Si pleural effusion\n                    if inter > 0.8:\n                        if result_df_th.loc[n,\"label\"] == 10:\n                            result_df_th.loc[n,\"xmin\"] = min(result_df_th.loc[n,\"xmin\"],result_df_th.loc[j,\"xmin\"])\n                            result_df_th.loc[n,\"ymin\"] = min(result_df_th.loc[n,\"ymin\"],result_df_th.loc[j,\"ymin\"])\n                            result_df_th.loc[n,\"xmax\"] = max(result_df_th.loc[n,\"xmax\"],result_df_th.loc[j,\"xmax\"])\n                            result_df_th.loc[n,\"ymax\"] = max(result_df_th.loc[n,\"ymax\"],result_df_th.loc[j,\"ymax\"])\n                            pd.DataFrame.drop(result_df_th.index[j], inplace=True)\n                         \n\n    \n    \n    ################################################################################################################\n        predicted = draw_bboxes(predicted,\n                            tl=(int(result_df_th.loc[n,\"xmin\"]),int(result_df_th.loc[n,\"ymin\"])),\n                            br=(int(result_df_th.loc[n,\"xmax\"]),int(result_df_th.loc[n,\"ymax\"])),\n                            rgb=palette[int(result_df_th.loc[n,\"label\"])],\n                            score=float(result_df_th.loc[n,\"score\"]),\n                            label=mapping[int(result_df_th.loc[n,\"label\"])],\n                            label_location=\"tl\",\n                            opacity=0.5,\n                            line_thickness=0,\n                            font_scale=2,\n                            font_thickness=5)\nelse:\n    print('NORMAL')\n    \n\nshow_xray(xray.image,predicted,size=(30,30))\nresult_df_th","metadata":{"execution":{"iopub.status.busy":"2022-01-10T11:04:31.768729Z","iopub.execute_input":"2022-01-10T11:04:31.769087Z","iopub.status.idle":"2022-01-10T11:05:03.424256Z","shell.execute_reply.started":"2022-01-10T11:04:31.769052Z","shell.execute_reply":"2022-01-10T11:05:03.423485Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# New prediction","metadata":{}},{"cell_type":"code","source":"from collections import Counter\nfrom tqdm import tqdm\nTH = 0.05\n\nmapping = {0: 'Aortic enlargement', 1: 'Atelectasis', 2: 'Calcification', 3: 'Cardiomegaly', 4: 'Consolidation', 5: 'ILD',6: 'Infiltration', 7: 'Lung Opacity', 8: 'Nodule/Mass', 9: 'Other lesion', 10: 'Pleural effusion', 11: 'Pleural thickening',12: 'Pneumothorax', 13: 'Pulmonary fibrosis'}\n\nfor i in tqdm(range(len(df2))):\n    name=df2.loc[i,\"image_id\"]\n    pred = df2.loc[i,\"PredictionString\"]\n    #xray = Xray(\"../input/vinbigdata-chest-xray-abnormalities-detection/test/\"+name+\".dicom\")\n    #xray.show()\n    splited = pred.split(\" \")\n    result = {\"label\" : [],\"score\" : [],'xmin' : [],\"ymin\" : [],\"xmax\" : [], \"ymax\" : []}\n    for n in range(len(splited)//6):\n        result[\"label\"].append(splited[n*6])\n        result[\"score\"].append(splited[n*6+1])\n        result[\"xmin\"].append(splited[n*6+2])\n        result[\"ymin\"].append(splited[n*6+3])\n        result[\"xmax\"].append(splited[n*6+4])\n        result[\"ymax\"].append(splited[n*6+5])\n        \n    result_df = pd.DataFrame(result)\n    resultSTR = \"\"\n    \n    labels = result[\"label\"]\n    scores = result[\"score\"]\n    \n    cls_ids = np.unique(labels).tolist()\n    count_dict = Counter(labels)\n\n    \n    for k in range(len(result_df)):        \n        \n        result_df[\"score\"] =result_df[\"score\"].astype(\"float\")\n        label = result_df.loc[k,\"label\"]\n        score_i = result_df.loc[k,\"score\"]\n        score = result_df.loc[k,\"score\"]\n        \n        if int(label) == 0 and count_dict[label] != 1:\n            best_score = result_df[result_df[\"label\"] == label][\"score\"].max() #meilleure score pour aortic enlargment\n            if score < best_score :\n                score_i = 0\n                \n        if int(label) == 3 : # cardiomegaly\n            if np.any(labels == 10) : # cardiomegaly + pleuresie => pas de cardiomégalie\n                score_i = 0\n            else:\n                best_score = result_df[result_df[\"label\"] == label][\"score\"].max() #meilleure score pour cardiomegaly\n            if score < best_score :\n                score_i = 0\n            else:\n                score_i = float(score_i) / 2\n                score_i = str(score_i)\n        \n        if int(label) == 9:\n            score_i = float(score_i)/4\n            score_i = str(score_i)\n        \n        \n        if int(label) == 14 and count_dict[label] != 1:\n            best_score = result_df[result_df[\"label\"] == label][\"score\"].max() #meilleure score pour aortic enlargment\n            if score < best_score :\n                score_i = 0\n        \n        result_df.loc[k,\"score\"] = score_i\n        # TH\n        if float(result_df.loc[k,\"score\"]) > TH:\n            resultSTR = resultSTR + ' ' + result_df.loc[k,\"label\"] + ' ' + str(result_df.loc[k,\"score\"]) + ' ' + result_df.loc[k,\"xmin\"] + ' ' + result_df.loc[k,\"ymin\"] + ' ' + result_df.loc[k,\"xmax\"] + ' ' + result_df.loc[k,\"ymax\"]\n    \n    \n    resultSTR = resultSTR.strip()\n    df2.loc[i,\"PredictionString\"] = resultSTR\n    \n","metadata":{"execution":{"iopub.status.busy":"2022-01-10T10:23:17.90961Z","iopub.execute_input":"2022-01-10T10:23:17.910044Z","iopub.status.idle":"2022-01-10T10:23:42.231283Z","shell.execute_reply.started":"2022-01-10T10:23:17.910005Z","shell.execute_reply":"2022-01-10T10:23:42.230326Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df2 \n\ndf2.to_csv(\"./submission.csv\",index=False)","metadata":{"execution":{"iopub.status.busy":"2022-01-10T10:23:42.232724Z","iopub.execute_input":"2022-01-10T10:23:42.233097Z","iopub.status.idle":"2022-01-10T10:23:42.26014Z","shell.execute_reply.started":"2022-01-10T10:23:42.233066Z","shell.execute_reply":"2022-01-10T10:23:42.259119Z"},"trusted":true},"execution_count":null,"outputs":[]}]}