{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.14","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":71549,"databundleVersionId":8561470,"sourceType":"competition"},{"sourceId":124135,"sourceType":"modelInstanceVersion","modelInstanceId":104483,"modelId":128684},{"sourceId":124863,"sourceType":"modelInstanceVersion","isSourceIdPinned":true,"modelInstanceId":105097,"modelId":129321},{"sourceId":124874,"sourceType":"modelInstanceVersion","isSourceIdPinned":true,"modelInstanceId":105107,"modelId":129333}],"dockerImageVersionId":30775,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import os\nimport glob\nimport pandas as pd\nimport numpy as np\n\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom torchvision import models \nimport torchvision.transforms as T\nfrom torch.utils.data import Dataset, DataLoader\nimport torch.nn.functional as F\nfrom torch.cuda.amp import autocast\n\nimport pydicom\nfrom PIL import Image,ImageOps\nimport random\nfrom sklearn.preprocessing import LabelEncoder, label_binarize\nimport matplotlib.pyplot as plt\nfrom skimage.measure import regionprops, label\nimport seaborn as sns\nimport cv2\nimport time\n\nimport gc\n\nimport warnings\nwarnings.filterwarnings('ignore')","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-10-04T11:28:09.423182Z","iopub.execute_input":"2024-10-04T11:28:09.423544Z","iopub.status.idle":"2024-10-04T11:29:56.920951Z","shell.execute_reply.started":"2024-10-04T11:28:09.423503Z","shell.execute_reply":"2024-10-04T11:29:56.919852Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"################### for test only ####################","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:56.922953Z","iopub.execute_input":"2024-10-04T11:29:56.923621Z","iopub.status.idle":"2024-10-04T11:29:56.929373Z","shell.execute_reply.started":"2024-10-04T11:29:56.923546Z","shell.execute_reply":"2024-10-04T11:29:56.928323Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"series = ['Sagittal T2/STIR', 'Sagittal T1', 'Axial T2']\nconditions = ['spinal_canal_stenosis', 'neural_foraminal_narrowing', 'subarticular_stenosis']\n\n############################## SPINAL #############################################\nspinal_lo=['x_level_l1_l2', 'y_level_l1_l2', 'x_level_l2_l3', 'y_level_l2_l3',\n           'x_level_l3_l4', 'y_level_l3_l4', 'x_level_l4_l5', 'y_level_l4_l5',\n           'x_level_l5_s1', 'y_level_l5_s1'] #model_location\nspinal_level=['l1_l2','l2_l3', 'l3_l4','l4_l5', 'l5_s1'] #process for crop dataframe purpose\nspinal_condition=['spinal_canal_stenosis'] #process for crop dataframe purpose\n#example for neural list_name= 'spinal_canal_stenosis_l4_l5'\n\n############################## NEURAL #############################################\nneural_lo = ['x_level_l1_l2','y_level_l1_l2', 'x_level_l2_l3', \n             'y_level_l2_l3', 'x_level_l3_l4','y_level_l3_l4', \n             'x_level_l4_l5', 'y_level_l4_l5', 'x_level_l5_s1',\n             'y_level_l5_s1'] #model_location\nneural_leftright = ['left_right'] #model_location\nneural_level = ['l1_l2','l2_l3', 'l3_l4','l4_l5', 'l5_s1']#process for crop dataframe purpose\nneural_condition=['neural_foraminal_narrowin'] #process for crop dataframe purpose\n#example for neural list_name= 'right_neural_foraminal_narrowing_l5_s1'\n\n############################## SUBARTICULAR #############################################\nsubarticular_lo = ['x_level_Right', 'y_level_Right','x_level_Left', 'y_level_Left'] #model_location\nsubarticular_level = ['l1_l2','l2_l3', 'l3_l4','l4_l5', 'l5_s1']#model_location  + process for crop dataframe purpose\nsubarticular_leftright = ['left_right'] #process for crop dataframe purpose \"left\" or \"right\"\nsubarticular_condition=['neural_foraminal_narrowin'] #process for crop dataframe purpose\n#example for subarticular list_name= 'right_subarticular_stenosis_l2_l3'","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:56.930500Z","iopub.execute_input":"2024-10-04T11:29:56.930840Z","iopub.status.idle":"2024-10-04T11:29:56.944444Z","shell.execute_reply.started":"2024-10-04T11:29:56.930808Z","shell.execute_reply":"2024-10-04T11:29:56.943565Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"'''\nall table for test data have: 'study_id', 'series_id', 'instance_number'\n'''","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:56.946777Z","iopub.execute_input":"2024-10-04T11:29:56.947108Z","iopub.status.idle":"2024-10-04T11:29:56.962025Z","shell.execute_reply.started":"2024-10-04T11:29:56.947064Z","shell.execute_reply":"2024-10-04T11:29:56.961151Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"spinal = ['spinal_canal_stenosis_l1_l2', 'spinal_canal_stenosis_l2_l3', \n          'spinal_canal_stenosis_l3_l4', 'spinal_canal_stenosis_l4_l5', \n          'spinal_canal_stenosis_l5_s1']\n\nneural = ['left_neural_foraminal_narrowing_l1_l2', 'left_neural_foraminal_narrowing_l2_l3', \n          'left_neural_foraminal_narrowing_l3_l4', 'left_neural_foraminal_narrowing_l4_l5', \n          'left_neural_foraminal_narrowing_l5_s1', 'right_neural_foraminal_narrowing_l1_l2', \n          'right_neural_foraminal_narrowing_l2_l3', 'right_neural_foraminal_narrowing_l3_l4', \n          'right_neural_foraminal_narrowing_l4_l5', 'right_neural_foraminal_narrowing_l5_s1']\n\nsubarticular = ['left_subarticular_stenosis_l1_l2', 'left_subarticular_stenosis_l2_l3',\n                'left_subarticular_stenosis_l3_l4', 'left_subarticular_stenosis_l4_l5',\n                'left_subarticular_stenosis_l5_s1', 'right_subarticular_stenosis_l1_l2',\n                'right_subarticular_stenosis_l2_l3', 'right_subarticular_stenosis_l3_l4',\n                'right_subarticular_stenosis_l4_l5', 'right_subarticular_stenosis_l5_s1']","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:56.963133Z","iopub.execute_input":"2024-10-04T11:29:56.963427Z","iopub.status.idle":"2024-10-04T11:29:56.971394Z","shell.execute_reply.started":"2024-10-04T11:29:56.963395Z","shell.execute_reply":"2024-10-04T11:29:56.970521Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def test_dataPreprocess(test_series,img_test_path):\n    series = ['Sagittal T2/STIR', 'Sagittal T1', 'Axial T2']\n    conditions = ['spinal_canal_stenosis', 'neural_foraminal_narrowing', 'subarticular_stenosis']\n    df_name=[pd.DataFrame(),pd.DataFrame(),pd.DataFrame()]\n\n    df_guide=pd.read_csv(test_series)\n    for i, (se,cond) in enumerate(zip(series,conditions)):\n        df_se=df_guide[df_guide['series_description']==se]\n\n        study_id,series_id,instance_number,conditions,img_ids,level_id=[],[],[],[],[],[]\n        for _,row in df_se.iterrows():\n            #print(row['study_id'])\n            pattern=f\"{img_test_path}/{str(row['study_id'])}/{str(row['series_id'])}/*.dcm\"\n            dcm_filesss=glob.glob(pattern)\n            \n            # Function to extract instance number before \".dcm\"\n            def extract_instance_number(dcm_filesss):\n                # Split the file path and extract the instance number\n                instance_id = os.path.splitext(os.path.basename(dcm_filesss))[0]\n                return int(instance_id)  # Ensure it's an integer for proper sorting\n\n            # Sort the dcm_files list by the instance number\n            dcm_files= sorted(dcm_filesss, key=extract_instance_number)\n            \n            get_files = []\n            if se == 'Sagittal T2/STIR':\n                half_dcm = len(dcm_files) // 2  # Use integer division\n                get_files = dcm_files[half_dcm-2:half_dcm+2]\n                #print(len(get_files))\n                level_id.extend([0] * len(get_files)) \n\n            elif se == 'Sagittal T1':\n                half_dcm = len(dcm_files) // 2  # Use integer division\n                get_files = dcm_files[half_dcm-4:half_dcm-1]\n                n1=len(get_files)\n                #print(n1)\n                level_id.extend([1] * n1)  # Corrected syntax for extending level_id\n                get_files.extend(dcm_files[half_dcm+1:half_dcm+4])\n                #print(len(get_files)-n1)\n                level_id.extend([0] * (len(get_files)-n1))  # Corrected syntax for extending level_id\n\n            elif se == 'Axial T2':\n                five_dcm = len(dcm_files) // 5  # Use integer division\n                half_five = five_dcm // 2  # Use integer division\n\n                # Ensure file_dcm is defined before this\n                l1_l2_dcm = dcm_files[half_five - 1:half_five + 2]\n                l2_l3_dcm = dcm_files[1 * five_dcm + half_five - 1: 1 * five_dcm + half_five + 2]\n                l3_l4_dcm = dcm_files[2 * five_dcm + half_five - 1: 2 * five_dcm + half_five + 2]\n                l4_l5_dcm = dcm_files[3 * five_dcm + half_five - 1: 3 * five_dcm + half_five + 2]\n                l5_s1_dcm = dcm_files[4 * five_dcm + half_five - 1: 4 * five_dcm + half_five + 2]\n\n                get_files = l1_l2_dcm + l2_l3_dcm + l3_l4_dcm + l4_l5_dcm + l5_s1_dcm  # Flatten the list\n                level_id.extend(['0'] * len(l1_l2_dcm) + ['1'] * len(l2_l3_dcm) + ['2'] * len(l3_l4_dcm) + \n                                ['3'] * len(l4_l5_dcm) + ['4'] * len(l5_s1_dcm))  # Corrected syntax for extending level_id\n                \n            for file in get_files:\n                path_split=file.split('/')\n                instance_id = os.path.splitext(path_split[-1])[0]\n                image_id=f\"{row['study_id']}_{row['series_id']}_{instance_id}\"\n                #print(instance_id)\n                study_id.append(row['study_id'])\n                series_id.append(row['series_id'])\n                instance_number.append(instance_id)\n                conditions.append(cond)\n                img_ids.append(image_id)\n        #print(len(study_id))\n        #print(len(instance_number))\n        #print(len(level_id))\n\n        df=pd.DataFrame({\n            'study_id': study_id,\n            'series_id': series_id,\n            'instance_number':instance_number,\n            'condition':conditions,\n            'image_id':img_ids,\n            'level_index': level_id\n        })\n        df_name[i]=df\n\n    return df_name[0],df_name[1],df_name[2]\n\ndef construct_rowIDdf(test_series_path,spinal,neural,subarticular):\n    df_series=pd.read_csv(test_series_path)\n    \n    row_id = []  # To collect the new row IDs\n    for index, row in df_series.iterrows():\n        id_condition = []  # Initialize for each row\n         # Based on the series_description, assign the correct list\n        if row['series_description'] == 'Sagittal T1':  # neural\n            id_condition = [f\"{row['study_id']}_{desc}\" for desc in neural]\n        elif row['series_description'] == 'Sagittal T2/STIR':  # spinal\n            id_condition = [f\"{row['study_id']}_{desc}\" for desc in spinal]\n        else:  # subarticular\n            id_condition = [f\"{row['study_id']}_{desc}\" for desc in subarticular]\n        row_id.extend(id_condition)\n        \n    row_id_df =pd.DataFrame({'row_id': row_id})\n    row_id_df=row_id_df.drop_duplicates()\n    return row_id_df","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:56.972586Z","iopub.execute_input":"2024-10-04T11:29:56.972903Z","iopub.status.idle":"2024-10-04T11:29:56.996704Z","shell.execute_reply.started":"2024-10-04T11:29:56.972858Z","shell.execute_reply":"2024-10-04T11:29:56.995901Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class locationDataset(Dataset):\n    def __init__(self, df, image_dir,input_size=128,transform=None):\n        self.df = df\n        self.img_dir = image_dir\n        self.input_size= input_size\n        self.transform = transform\n\n        # Default transform if none provided\n        if self.transform is None:\n            self.transform = T.Compose([\n                T.Resize((self.input_size, self.input_size)),\n                T.ToTensor()\n            ])\n\n    def __len__(self):\n        return len(self.df)\n\n    def __getitem__(self, idx):\n        # Get the image and mask for the given index\n        image, image_id = self.get_images(idx)\n\n        # Apply transformations to the image (if any)\n        image = self.transform(image)\n\n        # Ensure image and mask are of type float32 for model compatibility\n        image = torch.tensor(image, dtype=torch.float32)\n        \n        \n        return image, image_id\n\n    def get_images(self, idx):\n        # Fetch the row for the given index\n        row = self.df.iloc[idx]\n\n        # Load DICOM image\n        dicom_path = os.path.join(self.img_dir, str(row['study_id']), str(row['series_id']), f\"{str(row['instance_number'])}.dcm\")\n        dicom = pydicom.dcmread(dicom_path)\n        image = dicom.pixel_array\n\n        # Normalize the image to the range 0-255 and convert it to RGB\n        image_normalized = np.interp(image, (0, 1810), (0, 255)).astype(np.uint8)  #(n,n)\n        rgb_image_pil = Image.fromarray(image_normalized)\n        \n        # Image_id\n        image_id = row['image_id']\n\n        return rgb_image_pil, image_id","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:56.997833Z","iopub.execute_input":"2024-10-04T11:29:56.998160Z","iopub.status.idle":"2024-10-04T11:29:57.013680Z","shell.execute_reply.started":"2024-10-04T11:29:56.998120Z","shell.execute_reply":"2024-10-04T11:29:57.012908Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def show_random_dataset(val2_dataset):\n    num_images = len(val2_dataset)\n    #half_num_images = num_images // frac  # Get half the dataset\n    #selected_indices = random.sample(range(num_images), half_num_images)  # Randomly select half\n\n    cols = 8  # Define the number of columns\n    rows = (num_images // cols) + (1 if num_images % cols != 0 else 0)  # Calculate number of rows\n\n    fig, axes = plt.subplots(rows, cols, figsize=(15, rows * 2))\n\n    # Flatten axes array for easy iteration\n    axes = axes.flatten()\n    for i, idx in enumerate(range(num_images)):\n        img, img_id = val2_dataset[idx]\n        img_insnum = img_id.split('_')[-1]\n        # Convert tensor image to NumPy array if necessary\n        if isinstance(img, torch.Tensor):\n            img = img.permute(1, 2, 0).numpy()  # Adjust shape from (C, H, W) to (H, W, C)\n\n        # Show image on the subplot\n        axes[i].imshow(img)\n        axes[i].set_title(f'{i+1}:{img_insnum}')\n        axes[i].axis('off')\n        \n    # Turn off remaining empty subplots\n    for j in range(i + 1, len(axes)):\n        axes[j].axis('off')\n\n    plt.tight_layout()\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:57.014975Z","iopub.execute_input":"2024-10-04T11:29:57.015405Z","iopub.status.idle":"2024-10-04T11:29:57.027509Z","shell.execute_reply.started":"2024-10-04T11:29:57.015359Z","shell.execute_reply":"2024-10-04T11:29:57.026735Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"################################################### PREDICTION ###############################################\n\ndef model_loc_spinal(model, data_loader):\n    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n    model.to(device)\n    print(f\"Device: {device}\")\n    \n    coor_outputs = []\n    time_start=time.time()\n    model.eval()\n    with torch.no_grad():\n        for images, _ in data_loader:\n            images = images.to(device)\n            with autocast(): #torch.amp.autocast('cuda'):\n                output = model(images)\n                _, preds = torch.max(output, 1)\n                coor_outputs.extend(preds.cpu().detach())\n                \n    print('Done!')\n    time_end=time.time()\n    print(f'time used: {time_end-time_start}')\n\n    torch.cuda.empty_cache()\n    \n    return coor_outputs #coor_outputs\n\n\ndef model_loc_neural_sub(model_mask,model_rl, data_loader):\n    device_mask = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n    device_rl = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n    model_mask.to(device_mask)\n    model_rl.to(device_rl)\n    print(f'model unet in {device_mask}, mdoel left right in {device_rl}')\n    \n    coor_outputs, levels = [],[]\n    \n    time_start =time.time()\n    model_mask.eval()\n    model_rl.eval()\n    i=0\n    with torch.no_grad():\n        for images, image_id in data_loader:\n            i+=1\n            time_half_start=time.time()\n            with torch.amp.autocast('cuda'):\n                inputs_mask,input_leris = images.to(device_mask), images.to(device_rl)\n                output_mask = model_mask(inputs_mask)\n                output_leris = model_rl(input_leris)\n            \n                _, preds_mask = torch.max(output_mask, 1)\n                _, preds_leris = torch.max(output_leris, 1)\n                \n                coor_outputs.extend(torch.cat([coor_outputs, preds_mask.cpu().detach().numpy()], dim=0) if 'all_preds' in locals() else preds_mask.cpu().detach())\n                levels.extend(preds_leris.cpu().detach().numpy())\n    print('Done!')\n    \n    time_end=time.time()\n    print(f'time used: {time_end-time_start}')\n    torch.cuda.empty_cache()\n    \n    return coor_outputs, levels","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:57.029063Z","iopub.execute_input":"2024-10-04T11:29:57.029416Z","iopub.status.idle":"2024-10-04T11:29:57.044867Z","shell.execute_reply.started":"2024-10-04T11:29:57.029374Z","shell.execute_reply":"2024-10-04T11:29:57.043983Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"####################################### process data after location retrieve#######################################\n\n#SPINAL\ndef data_process_spinal(df_ori,outputs_df):\n    \n    df = pd.merge(df_ori, outputs_df, on='image_id', how='left')\n    \n    spinal_level=['l1_l2','l2_l3', 'l3_l4','l4_l5', 'l5_s1']\n    # Repeat each row 5 times and create a new DataFrame\n    df_final = pd.DataFrame(np.repeat(df.values, 5, axis=0), columns=df.columns)\n    df_final['level'] = spinal_level * len(df)\n    \n    # Map the \"level\" column to create \"level_id\"\n    mask_mapping = {\n    'l1_l2': 1,\n    'l2_l3': 2,\n    'l3_l4': 3,\n    'l4_l5': 4,\n    'l5_s1': 5\n    }\n    df_final['mask_id'] = df_final['level'].map(mask_mapping)\n    \n    df_final = df_final.sort_values(by=['study_id', 'series_id', 'instance_number'])\n    return df_final\n\n#NEURAL\ndef data_process_neural(df_ori,outputs_df):\n    df = pd.merge(df_ori, outputs_df, on='image_id', how='left')\n\n    left_right_mapping = {0:'right', 1:'left'}\n    df['level_index'] = df['level_index'].astype(int)\n    df['left_right'] = df['level_index'].map(left_right_mapping)\n    \n    neural_level = ['l1_l2','l2_l3', 'l3_l4','l4_l5', 'l5_s1']\n    df_final = pd.DataFrame(np.repeat(df.values, 5, axis=0), columns=df.columns)\n    df_final['level'] = neural_level * len(df)\n\n    # Map the \"level\" column to create \"level_id\"\n    mask_mapping = {\n    'l1_l2': 1,\n    'l2_l3': 2,\n    'l3_l4': 3,\n    'l4_l5': 4,\n    'l5_s1': 5\n    }\n    \n    df_final['mask_id'] = df_final['level'].map(mask_mapping)\n    df_final = df_final.sort_values(by=['study_id', 'series_id', 'instance_number'])\n    \n    return df_final\n\n#Subarticular\ndef data_process_subarticular(df_ori, outputs_df): \n    df = pd.merge(df_ori, outputs_df, on='image_id', how='left')\n    level_mapping = {0:'l1_l2', 1:'l2_l3', 2:'l3_l4', 3:'l4_l5', 4:'l5_s1'}\n    df['level_index'] = df['level_index'].astype(int)\n    df['level'] = df['level_index'].map(level_mapping)\n    \n    subarticular_leftright = ['left','right']\n    # Repeat each row 5 times and create a new DataFrame\n    df_final = pd.DataFrame(np.repeat(df.values, 2, axis=0), columns=df.columns)\n    df_final['left_right'] = subarticular_leftright * len(df)\n\n    # Map the \"level\" column to create \"level_id\"\n    mask_mapping = {\n    'right': 1,\n    'left': 2,\n    }\n    df_final['mask_id'] = df_final['left_right'].map(mask_mapping)\n    \n    df_final = df_final.sort_values(by=['study_id', 'series_id', 'instance_number'])\n    return df_final","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:57.048776Z","iopub.execute_input":"2024-10-04T11:29:57.049424Z","iopub.status.idle":"2024-10-04T11:29:57.065695Z","shell.execute_reply.started":"2024-10-04T11:29:57.049365Z","shell.execute_reply":"2024-10-04T11:29:57.064743Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class Conv2dReLU(nn.Module):\n    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1, use_batchnorm=True):\n        super().__init__()\n        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, bias=not use_batchnorm)\n        self.bn = nn.BatchNorm2d(out_channels) if use_batchnorm else nn.Identity()\n        self.relu = nn.ReLU(inplace=True)\n\n    def forward(self, x):\n        x = self.conv(x)\n        x = self.bn(x)\n        x = self.relu(x)\n        return x\n\n#class Conv2Conv\n\nclass DecoderBlock(nn.Module):\n    def __init__(self, in_channels, out_channels):\n        super(DecoderBlock, self).__init__()\n        self.conv1 = Conv2dReLU(in_channels, out_channels)\n        self.conv2 = Conv2dReLU(out_channels, out_channels)\n        \n    def forward(self, x, skip):\n        x = torch.cat([x, skip], dim=1)  # Skip connection\n        x = self.conv1(x)\n        x = self.conv2(x)\n        return x\n\nclass MobileNetV2Encoder(nn.Module):\n    def __init__(self, in_channels=1, pretrained=True):\n        super(MobileNetV2Encoder, self).__init__()\n        mobilenet_v2 = models.mobilenet_v2(pretrained=pretrained)\n        mobilenet_v2.features[0][0] = nn.Conv2d(in_channels, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n\n        # Extract layers from the pretrained MobileNetV2\n        self.enc0 = mobilenet_v2.features[0:2]  # 32 channels    [1, 16, 128, 128]\n        self.enc1 = mobilenet_v2.features[2:4]  # 24 channels    [1, 24, 64, 64]\n        self.enc2 = mobilenet_v2.features[4:7]  # 32 channels    [1, 32, 32, 32]\n        self.enc3 = mobilenet_v2.features[7:14]  # 96 channels   [1, 96, 16, 16]\n        self.enc4 = mobilenet_v2.features[14:18]  # 320 channels  [1, 320, 8, 8]\n        self.bottleneck = mobilenet_v2.features[18:] # 1280 channels  [1, 1280, 8, 8]\n        \n\n    def forward(self, x):\n        features = []\n        x = self.enc0(x)  # Downsample 1\n        features.append(x)\n        \n        x = self.enc1(x)  # Downsample 2\n        features.append(x)\n        \n        x = self.enc2(x)  # Downsample 3\n        features.append(x)\n        \n        x = self.enc3(x)  # Downsample 4\n        features.append(x)\n        \n        x = self.enc4(x)\n        features.append(x)\n        \n        x=self.bottleneck(x)\n        return x, features\n\nclass UNetMobileNetV2(nn.Module):\n    def __init__(self, in_channels=1, out_channels=6, pretrained=True):\n        super(UNetMobileNetV2, self).__init__()\n        self.encoder = MobileNetV2Encoder(in_channels=in_channels,pretrained=pretrained)\n\n        # Bottleneck output is 1280 from MobileNetV2\n        self.bottleneck = Conv2dReLU(320, 1280)\n        \n        # Upsampling layers\n        self.upconv4 = nn.ConvTranspose2d(1280, 320, kernel_size=2, stride=2)  # Upsample to 512\n        self.upconv3 = nn.ConvTranspose2d(208, 96, kernel_size=2, stride=2)   # Upsample to 256\n        self.upconv2 = nn.ConvTranspose2d(96, 96, kernel_size=2, stride=2)   # Upsample to 128\n        self.upconv1 = nn.ConvTranspose2d(64, 64, kernel_size=2, stride=2)     # Upsample to 64\n        self.upconv0 = nn.ConvTranspose2d(32, 32, kernel_size=2, stride=2)\n\n        # Decoder\n        self.dec4 = DecoderBlock(320+96, 208)  # Decoder for bottleneck and enc3\n        self.dec3 = DecoderBlock(96+32, 96)   # Decoder for dec4 and enc2\n        self.dec2 = DecoderBlock(96+24, 64)   # Decoder for dec3 and enc1\n        self.dec1 = DecoderBlock(64+16, 32)   # Decoder for dec2 and enc0\n\n        # Final segmentation head\n        self.segmentation_head = nn.Conv2d(32, out_channels, kernel_size=1)\n\n    def forward(self, x):\n        # Encoder\n        bottleneck, features = self.encoder(x)\n       \n        x = self.upconv4(bottleneck) \n        x = self.dec4(x, features[3])  \n        \n        x = self.upconv3(x)\n        x = self.dec3(x, features[2])  \n        \n        x = self.upconv2(x)\n        x = self.dec2(x, features[1])  \n       \n        x = self.upconv1(x)\n        x = self.dec1(x, features[0]) \n        #print(f'dec4 {x.shape}')\n       \n        # Final segmentation head\n        x = self.upconv0(x) \n        x = self.segmentation_head(x)\n        return x","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:57.067291Z","iopub.execute_input":"2024-10-04T11:29:57.067725Z","iopub.status.idle":"2024-10-04T11:29:57.090258Z","shell.execute_reply.started":"2024-10-04T11:29:57.067681Z","shell.execute_reply":"2024-10-04T11:29:57.089278Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"###################### model left right and model levels ########################\n\nclass resnet_lr_level(nn.Module):\n    def __init__(self, num_classes=2):\n        super(resnet_lr_level, self).__init__()\n        self.resnet = models.resnet50(pretrained=False)\n        \n        # Modify the first convolutional layer to accept 1 channel instead of 3\n        self.resnet.conv1 = nn.Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n        \n        # Modify the fully connected layer for 2-class output\n        num_ftrs = self.resnet.fc.in_features\n        self.resnet.fc = nn.Linear(num_ftrs, num_classes)\n        \n    def forward(self, x):\n        return self.resnet(x)","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:57.091537Z","iopub.execute_input":"2024-10-04T11:29:57.091946Z","iopub.status.idle":"2024-10-04T11:29:57.104403Z","shell.execute_reply.started":"2024-10-04T11:29:57.091903Z","shell.execute_reply":"2024-10-04T11:29:57.103526Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#############################################################################","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:57.105746Z","iopub.execute_input":"2024-10-04T11:29:57.106148Z","iopub.status.idle":"2024-10-04T11:29:57.116009Z","shell.execute_reply.started":"2024-10-04T11:29:57.106102Z","shell.execute_reply":"2024-10-04T11:29:57.115202Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#file path\nbase_path = '/kaggle/input/rsna-2024-lumbar-spine-degenerative-classification'\n\n#train path\ntrain_label = os.path.join(base_path,'train_label_coordinates.csv')\ntrain_series = os.path.join(base_path,'train_series_descriptions.csv')\ntrain_ = os.path.join(base_path,'train.csv')\nimg_train_path = os.path.join(base_path,'train_images')\n\n#test path\ntest_series=os.path.join(base_path,'test_series_descriptions.csv')\nimg_test_path = os.path.join(base_path,'test_images')","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:57.117151Z","iopub.execute_input":"2024-10-04T11:29:57.117453Z","iopub.status.idle":"2024-10-04T11:29:57.126696Z","shell.execute_reply.started":"2024-10-04T11:29:57.117420Z","shell.execute_reply":"2024-10-04T11:29:57.125748Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"row_id_df = construct_rowIDdf(test_series,spinal,neural,subarticular)\nspinal_df,neural_df,subarticular_df = test_dataPreprocess(test_series,img_test_path)\n\n#row_id_df = construct_rowIDdf(test_series,spinal,neural,subarticular)\n#spinal_df,neural_df,subarticular_df = test_dataPreprocess(test_series,img_train_path)","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:57.127881Z","iopub.execute_input":"2024-10-04T11:29:57.128235Z","iopub.status.idle":"2024-10-04T11:29:57.187042Z","shell.execute_reply.started":"2024-10-04T11:29:57.128193Z","shell.execute_reply":"2024-10-04T11:29:57.186264Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\nspinal_dataset = locationDataset(spinal_df,img_test_path,input_size=128,transform=None)\nneural_dataset = locationDataset(neural_df,img_test_path,input_size=128,transform=None)\nsub_dataset = locationDataset(subarticular_df,img_test_path,input_size=128,transform=None )\n\nspinal_loader = DataLoader(spinal_dataset,batch_size=16,shuffle=False,num_workers=4,pin_memory= True )\nneural_loader = DataLoader(neural_dataset,batch_size=16,shuffle=False,num_workers=4,pin_memory=True )\nsub_loader = DataLoader(sub_dataset,batch_size=16,shuffle=False,num_workers=4,pin_memory=True )\n\n'''\nspinal_dataset = locationDataset(spinal_df,img_train_path,input_size=128,transform=None)\nneural_dataset = locationDataset(neural_df,img_train_path,input_size=128,transform=None)\nsub_dataset = locationDataset(subarticular_df,img_train_path,input_size=128,transform=None )\n\nspinal_loader = DataLoader(spinal_dataset,batch_size=16,shuffle=False,num_workers=4,pin_memory= True )\nneural_loader = DataLoader(neural_dataset,batch_size=16,shuffle=False,num_workers=4,pin_memory=True )\nsub_loader = DataLoader(sub_dataset,batch_size=16,shuffle=False,num_workers=4,pin_memory=True )\n'''","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:57.188394Z","iopub.execute_input":"2024-10-04T11:29:57.188783Z","iopub.status.idle":"2024-10-04T11:29:57.199305Z","shell.execute_reply.started":"2024-10-04T11:29:57.188735Z","shell.execute_reply":"2024-10-04T11:29:57.198412Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"'''\nfig,axes=plt.subplots(1,3,figsize=(8,5))\n\nimg1,_= spinal_dataset[1] #\nimg1 = img1.permute(1, 2, 0)\naxes[0].imshow(img1)\n\nimg2,_= neural_dataset[1] #\nimg2 = img2.permute(1, 2, 0)\naxes[1].imshow(img2)\n\nimg3,_= sub_dataset[1] #\nimg3 = img3.permute(1, 2, 0)\naxes[2].imshow(img3)\n\nplt.tight_layout()\nplt.show()\n'''","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:57.200553Z","iopub.execute_input":"2024-10-04T11:29:57.200845Z","iopub.status.idle":"2024-10-04T11:29:57.213030Z","shell.execute_reply.started":"2024-10-04T11:29:57.200813Z","shell.execute_reply":"2024-10-04T11:29:57.212185Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Unet model\nspinal_Unet = UNetMobileNetV2(in_channels=1, out_channels=6, pretrained=False) \nneural_Unet = UNetMobileNetV2(in_channels=1, out_channels=6, pretrained=False)\nsubarticular_Unet = UNetMobileNetV2(in_channels=1, out_channels=3, pretrained=False)\n\npath_unet_spinal='/kaggle/input/mobile_unet_128/pytorch/default/1/lo_last_spinal_Unet_128.pth'\npath_unet_neural='/kaggle/input/mobile_unet_128/pytorch/default/1/lo_last_neural_Unet_128.pth'\npath_unet_sub='/kaggle/input/mobile_unet_128/pytorch/default/1/lo_last_sub_Unet_128.pth'\n\nspinal_Unet.load_state_dict(torch.load(path_unet_spinal))\nneural_Unet.load_state_dict(torch.load(path_unet_neural))\nsubarticular_Unet.load_state_dict(torch.load(path_unet_sub))","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:57.214403Z","iopub.execute_input":"2024-10-04T11:29:57.214734Z","iopub.status.idle":"2024-10-04T11:29:59.327071Z","shell.execute_reply.started":"2024-10-04T11:29:57.214683Z","shell.execute_reply":"2024-10-04T11:29:59.326135Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#left right and level model\npath_model_lo_neural='/kaggle/input/lr_level_model_128/pytorch/default/1/last_neural_rl_128.pth'\npath_model_lo_sub='/kaggle/input/lr_level_model_128/pytorch/default/1/best_sub_lv_128.pth'\n\nmodel_lo_neural=resnet_lr_level(num_classes=2)\nmodel_lo_neural.load_state_dict(torch.load(path_model_lo_neural))\n\nmodel_lo_sub=resnet_lr_level(num_classes=5)\nmodel_lo_sub.load_state_dict(torch.load(path_model_lo_sub))","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:29:59.328401Z","iopub.execute_input":"2024-10-04T11:29:59.328883Z","iopub.status.idle":"2024-10-04T11:30:02.158476Z","shell.execute_reply.started":"2024-10-04T11:29:59.328835Z","shell.execute_reply":"2024-10-04T11:30:02.157466Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"coor_outputs_spinal = model_loc_spinal(spinal_Unet,spinal_loader)\n\ncoor_outputs_spinalll = [output.cpu().detach().numpy() for output in coor_outputs_spinal]\noutputs_spinal_df = pd.DataFrame({\n    'image_id' : spinal_df['image_id'],\n    'mask' : coor_outputs_spinalll\n})\ndf_spinal_lo=data_process_spinal(spinal_df,outputs_spinal_df)","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:02.160068Z","iopub.execute_input":"2024-10-04T11:30:02.160381Z","iopub.status.idle":"2024-10-04T11:30:03.278972Z","shell.execute_reply.started":"2024-10-04T11:30:02.160346Z","shell.execute_reply":"2024-10-04T11:30:03.277706Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#neural_mask, neural_lr = model_loc_neural_sub(neural_Unet,model_lo_neural,neural_loader)\nneural_mask = model_loc_spinal(neural_Unet,neural_loader)\n\nneural_maskkk = [output.cpu().detach().numpy() for output in neural_mask]\noutputs_neural_df = pd.DataFrame({\n    'image_id' : neural_df['image_id'],\n    'mask' : neural_maskkk,\n})\n\ndf_neural_lo=data_process_neural(neural_df,outputs_neural_df)","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:03.280798Z","iopub.execute_input":"2024-10-04T11:30:03.281158Z","iopub.status.idle":"2024-10-04T11:30:03.722031Z","shell.execute_reply.started":"2024-10-04T11:30:03.281117Z","shell.execute_reply":"2024-10-04T11:30:03.720934Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#sub_mask, sub_levels = model_loc_neural_sub(subarticular_Unet,model_lo_sub,sub_loader)\nsub_mask = model_loc_spinal(subarticular_Unet,sub_loader)\n\nsub_maskkk = [output.cpu().detach().numpy() for output in sub_mask]\noutputs_subarticular_df = pd.DataFrame({\n    'image_id' : subarticular_df['image_id'],\n    'mask' : sub_maskkk,\n})\n\ndf_subarticular_lo=data_process_subarticular(subarticular_df,outputs_subarticular_df)","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:03.723772Z","iopub.execute_input":"2024-10-04T11:30:03.724162Z","iopub.status.idle":"2024-10-04T11:30:04.087784Z","shell.execute_reply.started":"2024-10-04T11:30:03.724122Z","shell.execute_reply":"2024-10-04T11:30:04.086669Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def model_plot(test_dataset, output):\n    f, ax = plt.subplots(1, 2, figsize=(13,8 ))\n    \n    img, _= test_dataset\n    image = img.permute(1, 2, 0)\n    #height, weight = image.shape[:2]\n\n    # Original image with label scatter plot\n    ax[0].imshow(image)#, cmap='gray')\n    #ax[0].imshow(mask, cmap='jet', alpha=0.5)\n        \n    # Model prediction\n    ax[1].imshow(image)#, cmap='gray')\n    ax[1].imshow(output,cmap='jet',alpha=0.5)\n\n    plt.tight_layout()\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:04.089283Z","iopub.execute_input":"2024-10-04T11:30:04.089682Z","iopub.status.idle":"2024-10-04T11:30:04.096697Z","shell.execute_reply.started":"2024-10-04T11:30:04.089625Z","shell.execute_reply":"2024-10-04T11:30:04.095677Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#model_plot(neural_dataset[1], neural_maskkk[1])","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:04.098187Z","iopub.execute_input":"2024-10-04T11:30:04.098858Z","iopub.status.idle":"2024-10-04T11:30:04.109011Z","shell.execute_reply.started":"2024-10-04T11:30:04.098812Z","shell.execute_reply":"2024-10-04T11:30:04.108034Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#model_plot(sub_dataset[3], sub_maskkk[3])","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:04.110147Z","iopub.execute_input":"2024-10-04T11:30:04.110476Z","iopub.status.idle":"2024-10-04T11:30:04.119547Z","shell.execute_reply.started":"2024-10-04T11:30:04.110441Z","shell.execute_reply":"2024-10-04T11:30:04.118673Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"######################################### Severity Model######################################","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:04.120729Z","iopub.execute_input":"2024-10-04T11:30:04.121063Z","iopub.status.idle":"2024-10-04T11:30:04.129916Z","shell.execute_reply.started":"2024-10-04T11:30:04.121029Z","shell.execute_reply":"2024-10-04T11:30:04.129004Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class SeverityDataset(Dataset):\n    def __init__(self, df, image_dir, transform=None,input_size=64,crop_size=32):\n        self.df = df\n        self.img_dir = image_dir\n        self.transform = transform\n        self.input_size = input_size\n        self.crop_size = crop_size\n        \n        # Initialize transformation if not provided\n        if self.transform is None:\n            self.transform = T.Compose([\n                T.Resize((self.input_size, self.input_size)),  # Ensure the final size is handled correctly\n                T.ToTensor(),\n                # T.Normalize(norm_mean, norm_std)  # Uncomment if normalization is needed\n            ])\n    \n    def __len__(self):\n        return len(self.df)\n    \n    def __getitem__(self, idx):\n        # Get the image and label for the given index\n        image = self.get_image_label(idx)\n        \n        # Apply transformations\n        image = self.transform(image)\n        \n        image = torch.tensor(image, dtype=torch.float32)\n        \n        return image\n    \n    def get_image_label(self, idx):\n        row = self.df.iloc[idx]\n        dicom_path = os.path.join(self.img_dir, str(row['study_id']), str(row['series_id']), f\"{str(row['instance_number'])}.dcm\")\n        dicom = pydicom.dcmread(dicom_path)\n        image = dicom.pixel_array\n        \n        # Normalize the image\n        image_normalized = np.interp(image, (0, 1810), (0, 255)).astype(np.uint8)\n        \n        # Convert to PIL Image\n        rgb_image_pil = Image.fromarray(image_normalized)\n        \n        # Resize the image using PIL\n        rgb_image_pil = rgb_image_pil.resize((128, 128), Image.BILINEAR)\n        # Get cropped image\n        cropped_image = self.crop_mask(row, rgb_image_pil)\n        \n        return cropped_image\n\n    def crop_mask(self, row, ori_image_pil):\n        level = row['mask_id']\n        mask_np = row['mask']\n        labeled_mask = (mask_np == level).astype(int)\n        regions = regionprops(labeled_mask)\n\n        # Initialize cropped image with zeros (placeholder)\n        cropped_img = np.zeros((self.crop_size, self.crop_size), dtype=np.uint8)\n\n        # Crop the image using the bounding boxes from the mask regions\n        for region in regions:\n            minr, minc, maxr, maxc = region.bbox  # Get the bounding box of the region\n            cropped_pil_img = ori_image_pil.crop((minc, minr, maxc, maxr))  # Crop using the bounding box\n            cropped_img = np.array(cropped_pil_img)  # Convert cropped image to NumPy array\n            break\n\n        # Ensure the cropped image is returned as a PIL Image\n        return Image.fromarray(cropped_img)\n\n","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:04.131295Z","iopub.execute_input":"2024-10-04T11:30:04.131566Z","iopub.status.idle":"2024-10-04T11:30:04.146203Z","shell.execute_reply.started":"2024-10-04T11:30:04.131536Z","shell.execute_reply":"2024-10-04T11:30:04.145165Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def model_severity(model, test_loader):\n    device= torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n    model.to(device)\n    print(device)\n    \n    all_test_outputs = []\n    model.eval()\n    with torch.no_grad():\n        for inputs in test_loader:\n            with torch.amp.autocast(device.type):  # 'cuda' or 'cpu' depending on availability\n                inputs = inputs.to(device)\n                outputs = model(inputs)\n                preds = F.softmax(outputs, dim=1)\n                all_test_outputs.extend(preds.detach().cpu().numpy())\n    \n    #delete model and data_loader\n    torch.cuda.empty_cache()\n    \n    return all_test_outputs","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:04.152346Z","iopub.execute_input":"2024-10-04T11:30:04.152731Z","iopub.status.idle":"2024-10-04T11:30:04.160697Z","shell.execute_reply.started":"2024-10-04T11:30:04.152693Z","shell.execute_reply":"2024-10-04T11:30:04.159900Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def condition_severity(df, severity_outputs, left_right = True):\n    severity_col=['Normal/Mild','Moderate','Severe']\n    df[severity_col]= severity_outputs\n    \n    if left_right:\n        df['row_id'] = df['study_id'].astype(str) + '_' + df['left_right'].astype(str) + '_' + df['condition'].astype(str) + '_' + df['level'].astype(str)\n    else:\n        df['row_id'] = df['study_id'].astype(str) + '_' + df['condition'].astype(str) + '_' + df['level'].astype(str)\n    \n    df_final= pd.DataFrame({\n        'row_id': df['row_id'],\n        'normal_mild': df['Normal/Mild'] ,\n        'moderate': df['Moderate'],\n        'severe': df['Severe']\n    })\n    \n    df_final=df_final.groupby('row_id').mean().reset_index()\n    df_final['normal_mild'] = df_final['normal_mild']/df_final[['normal_mild', 'moderate', 'severe']].sum(axis=1)\n    df_final['moderate'] = df_final['moderate']/df_final[['normal_mild', 'moderate', 'severe']].sum(axis=1)\n    df_final['severe'] = df_final['severe']/df_final[['normal_mild', 'moderate', 'severe']].sum(axis=1)\n    \n    return df_final","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:04.162247Z","iopub.execute_input":"2024-10-04T11:30:04.162634Z","iopub.status.idle":"2024-10-04T11:30:04.177039Z","shell.execute_reply.started":"2024-10-04T11:30:04.162572Z","shell.execute_reply":"2024-10-04T11:30:04.176009Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class mobile_severe(nn.Module):\n    def __init__(self, num_classes=3):\n        super(mobile_severe, self).__init__()\n        # Load the pretrained MobileNetV2 model\n        self.mobilenet_v2 = models.mobilenet_v2()\n        \n        # Modify the first convolutional layer to accept 1 channel instead of 3\n        in_channels = self.mobilenet_v2.features[0][0].in_channels\n        out_channels = self.mobilenet_v2.features[0][0].out_channels\n        kernel_size = self.mobilenet_v2.features[0][0].kernel_size\n        stride = self.mobilenet_v2.features[0][0].stride\n        padding = self.mobilenet_v2.features[0][0].padding\n        \n        self.pool = nn.AdaptiveAvgPool2d(1)\n        \n        # Replace the first conv layer\n        self.mobilenet_v2.features[0][0] = nn.Conv2d(1, out_channels, kernel_size, stride, padding, bias=False)\n        \n        # Reinitialize the weights for the new conv layer\n        nn.init.kaiming_normal_(self.mobilenet_v2.features[0][0].weight, mode='fan_out', nonlinearity='relu')\n        \n        # Adjust the fully connected layer according to your specific needs\n        self.mobilenet_v2.classifier[1] = nn.Linear(self.mobilenet_v2.classifier[1].in_features, num_classes)\n    \n    def forward(self, x):\n        x = self.mobilenet_v2.features(x)\n        x = self.pool(x)\n        x = torch.flatten(x, 1)\n        x = self.mobilenet_v2.classifier(x)\n        return x","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:04.178408Z","iopub.execute_input":"2024-10-04T11:30:04.179277Z","iopub.status.idle":"2024-10-04T11:30:04.188891Z","shell.execute_reply.started":"2024-10-04T11:30:04.179228Z","shell.execute_reply":"2024-10-04T11:30:04.188093Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"spinal_severity_dataset = SeverityDataset(df_spinal_lo,img_test_path,transform=None,input_size=64,crop_size=64)\nneural_severity_dataset = SeverityDataset(df_neural_lo,img_test_path,transform=None,input_size=64,crop_size=64)\nsub_severity_dataset = SeverityDataset(df_subarticular_lo,img_test_path,transform=None,input_size=64,crop_size=32)\n\n#spinal_severity_dataset = SeverityDataset(df_spinal_lo,img_train_path,transform=None,input_size=64,crop_size=64)\n#neural_severity_dataset = SeverityDataset(df_neural_lo,img_train_path,transform=None,input_size=64,crop_size=64)\n#sub_severity_dataset = SeverityDataset(df_subarticular_lo,img_train_path,transform=None,input_size=64,crop_size=32)\n\nspinal_severity_loader = DataLoader(spinal_severity_dataset,batch_size=16,shuffle=False,num_workers=4,pin_memory= True )\nneural_severity_loader = DataLoader(neural_severity_dataset,batch_size=16,shuffle=False,num_workers=4,pin_memory= True )\nsub_severity_loader = DataLoader(sub_severity_dataset,batch_size=16,shuffle=False,num_workers=4,pin_memory= True )","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:04.190128Z","iopub.execute_input":"2024-10-04T11:30:04.190503Z","iopub.status.idle":"2024-10-04T11:30:04.205615Z","shell.execute_reply.started":"2024-10-04T11:30:04.190467Z","shell.execute_reply":"2024-10-04T11:30:04.204741Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"fig,axes=plt.subplots(1,3,figsize=(8,5))\n\nimg1= spinal_severity_dataset[18] #\n#img1 = np.transpose(img1, (1, 2, 0))\nimg1 = img1.permute(1, 2, 0)\naxes[0].imshow(img1)\n\nimg2= neural_severity_dataset[20] #\n#img2 = np.transpose(img2, (1, 2, 0))\nimg2 = img2.permute(1, 2, 0)\naxes[1].imshow(img2)\n\nimg3= sub_severity_dataset[3] #\n#img3 = np.transpose(img3, (1, 2, 0))\nimg3 = img3.permute(1, 2, 0)\naxes[2].imshow(img3)\n\nplt.tight_layout()\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:04.206889Z","iopub.execute_input":"2024-10-04T11:30:04.207722Z","iopub.status.idle":"2024-10-04T11:30:04.907622Z","shell.execute_reply.started":"2024-10-04T11:30:04.207674Z","shell.execute_reply":"2024-10-04T11:30:04.906636Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def show_random_dataset(val2_dataset):\n    num_images = len(val2_dataset)\n    #half_num_images = num_images // frac  # Get half the dataset\n    #selected_indices = random.sample(range(num_images), half_num_images)  # Randomly select half\n\n    cols = 8  # Define the number of columns\n    rows = (num_images // cols) + (1 if num_images % cols != 0 else 0)  # Calculate number of rows\n\n    fig, axes = plt.subplots(rows, cols, figsize=(15, rows * 2))\n\n    # Flatten axes array for easy iteration\n    axes = axes.flatten()\n    for i, idx in enumerate(range(num_images)):\n        img, img_id = val2_dataset[idx]\n        img_insnum = img_id.split('_')[-1]\n        # Convert tensor image to NumPy array if necessary\n        if isinstance(img, torch.Tensor):\n            img = img.permute(1, 2, 0).numpy()  # Adjust shape from (C, H, W) to (H, W, C)\n\n        # Show image on the subplot\n        axes[i].imshow(img)\n        axes[i].set_title(f'{i+1}:{img_insnum}')\n        axes[i].axis('off')\n        \n    # Turn off remaining empty subplots\n    for j in range(i + 1, len(axes)):\n        axes[j].axis('off')\n\n    plt.tight_layout()\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:04.908851Z","iopub.execute_input":"2024-10-04T11:30:04.909145Z","iopub.status.idle":"2024-10-04T11:30:04.919207Z","shell.execute_reply.started":"2024-10-04T11:30:04.909112Z","shell.execute_reply":"2024-10-04T11:30:04.918123Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"path_model_lo_spinal='/kaggle/input/severity_mobile/pytorch/default/1/best_movile_spinal (1).pth'\npath_model_lo_neural='/kaggle/input/severity_mobile/pytorch/default/1/last_mobile_neur2.pth'\npath_model_lo_sub='/kaggle/input/severity_mobile/pytorch/default/1/last_mobile_sub2.pth'\n\nmodel_se_spinal=mobile_severe(num_classes=3)\nmodel_se_spinal.load_state_dict(torch.load(path_model_lo_spinal))\n\nmodel_se_neural=mobile_severe(num_classes=3)\nmodel_se_neural.load_state_dict(torch.load(path_model_lo_neural))\n\nmodel_se_subarticular=mobile_severe(num_classes=3)\nmodel_se_subarticular.load_state_dict(torch.load(path_model_lo_sub))","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:04.920725Z","iopub.execute_input":"2024-10-04T11:30:04.921063Z","iopub.status.idle":"2024-10-04T11:30:05.630648Z","shell.execute_reply.started":"2024-10-04T11:30:04.921017Z","shell.execute_reply":"2024-10-04T11:30:05.629650Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"severity_spinal =model_severity(model_se_spinal, spinal_severity_loader)\nseverity_neural =model_severity(model_se_neural, neural_severity_loader)\nseverity_subarticular =model_severity(model_se_subarticular, sub_severity_loader)","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:05.631940Z","iopub.execute_input":"2024-10-04T11:30:05.632305Z","iopub.status.idle":"2024-10-04T11:30:07.540088Z","shell.execute_reply.started":"2024-10-04T11:30:05.632270Z","shell.execute_reply":"2024-10-04T11:30:07.538192Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df_final_spinal = condition_severity(df_spinal_lo, severity_spinal, left_right = False)\ndf_final_neural = condition_severity(df_neural_lo, severity_neural, left_right = True)\ndf_final_subarticular = condition_severity(df_subarticular_lo, severity_subarticular, left_right = True)\ncombine_cond_df= pd.concat([df_final_neural, df_final_subarticular,df_final_spinal],axis=0)\nsubmission_df = pd.merge(row_id_df, combine_cond_df, on='row_id', how='left')\nsubmission_df=submission_df.sort_values(by='row_id').reset_index(drop= True)","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:07.542518Z","iopub.execute_input":"2024-10-04T11:30:07.547001Z","iopub.status.idle":"2024-10-04T11:30:07.596848Z","shell.execute_reply.started":"2024-10-04T11:30:07.546957Z","shell.execute_reply":"2024-10-04T11:30:07.595854Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"submission_df=submission_df.fillna(0.333333)","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:07.598014Z","iopub.execute_input":"2024-10-04T11:30:07.598318Z","iopub.status.idle":"2024-10-04T11:30:07.603338Z","shell.execute_reply.started":"2024-10-04T11:30:07.598285Z","shell.execute_reply":"2024-10-04T11:30:07.602245Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"submission_df","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:07.604465Z","iopub.execute_input":"2024-10-04T11:30:07.604841Z","iopub.status.idle":"2024-10-04T11:30:07.630431Z","shell.execute_reply.started":"2024-10-04T11:30:07.604781Z","shell.execute_reply":"2024-10-04T11:30:07.629478Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"submission_df.to_csv('submission.csv',index=False)","metadata":{"execution":{"iopub.status.busy":"2024-10-04T11:30:07.631476Z","iopub.execute_input":"2024-10-04T11:30:07.631777Z","iopub.status.idle":"2024-10-04T11:30:07.638930Z","shell.execute_reply.started":"2024-10-04T11:30:07.631745Z","shell.execute_reply":"2024-10-04T11:30:07.638091Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}