{"cells":[{"metadata":{},"cell_type":"markdown","source":"# Pulmonary fibrosis\n\nPulmonary fibrosis is a chronic and progressive lung disease where the air sacs in the lungs, called the alveoli, become scarred and stiff, making it difficult to breathe and get enough oxygen into the bloodstream.\n\nGood read and reference - [here](https://pulmonaryfibrosisnews.com/2019/08/16/twelve-facts-about-pulmonary-fibrosis-prognosis-and-life-expectancy/)\n\nFirstly please upvote if you my work, this will keep me motivated.\n\n## Causes:\n\n1. without known cause (this is called idiopathic pulmonary fibrosis)\n2. by exposure to environmental hazards (such as asbestos, coal, silica)\n3. by exposure to autoimmune diseases (such as rheumatoid arthritis)\n4. caused by medications (such as chemotherapy)\n5. In other rare cases, genetics may predispose some patients to develop the disorder.\n\nOur dataset does not help is determining which of the above can be a cause. :(\n\n## Interesting points\n\n1. Older age generally means a worse prognosis\n2. Women usually have a better prognosis than men\n3. Each year as the disease progresses, pulmonary fibrosis patients will lose an average of between 150 mL and 200 mL of lung capacity, which can be monitored by spirometry\n\nWe will see if we can use this information during our experiments. Nice.\n\nLet us also watch a quick video.","execution_count":null},{"metadata":{"_kg_hide-input":true,"trusted":true},"cell_type":"code","source":"from IPython.display import HTML\nHTML('<center><iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/cnzOZ1KveMY\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe></center>')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Import libraries ","execution_count":null},{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"import os\nimport pydicom as dcm\nimport glob\nimport numpy as np\nimport pandas as pd\nimport math\nimport matplotlib.pyplot as plt\nplt.style.use('ggplot')\nimport seaborn as sns\nimport torch\nfrom sklearn.linear_model import Ridge\nimport random\nfrom tqdm.notebook import tqdm\nfrom sklearn.model_selection import StratifiedKFold, GroupKFold, KFold\nfrom sklearn.metrics import mean_squared_error\nimport category_encoders as ce\nfrom PIL import Image\nimport cv2\n#import pydicom\nimport lightgbm as lgb\nimport warnings\nwarnings.filterwarnings(\"ignore\")\n\nimport seaborn as sns\np = sns.color_palette()\nimport plotly.express as px","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Load CSV files","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"train = pd.read_csv('../input/osic-pulmonary-fibrosis-progression/train.csv')\ntrain['ID'] = train['Patient'].astype(str) + '_' + train['Weeks'].astype(str)\nprint(train.shape)\ntrain.head()\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test = pd.read_csv('../input/osic-pulmonary-fibrosis-progression/test.csv')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Examine DICOM count","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"patient_sizes = [len(os.listdir('../input/osic-pulmonary-fibrosis-progression/train/' + d)) for d in os.listdir('../input/osic-pulmonary-fibrosis-progression/train/')]\nplt.hist(patient_sizes, color=p[2])\nplt.ylabel('Number of patients')\nplt.xlabel('DICOM files')\nplt.title('Histogram of DICOM count per patient');\n\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We have very less patients with more than 200 DICOM files, let us examine if further.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"patient_sizes_arr = np.array(patient_sizes) \nfor x in [200,300,400,500,600,800,1000]:\n    print(\"We have \",sum(patient_sizes_arr > x),\"patients with more than\",x,\"DICOM files\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"During our experiments - we might have to exclude these 7 patients with huge DICOM files or probably use them differently.","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"# Explore Training Data","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"print(\"Total entries\",len(train['Patient']))\nprint(\"Total patients\",len(np.unique(train['Patient'])))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train.info()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train.isnull().sum()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"No Missing values in train.csv","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"## Examining records of one patient","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"train[train['Patient'] == 'ID00007637202177411956430']","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Examining patient data","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"train_patient_data = train[['Patient','Age','Sex','SmokingStatus']].drop_duplicates().reset_index(drop=True)\ntrain_patient_data.head()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(\"Different smoking status:\",np.unique(train_patient_data.SmokingStatus))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Smoking Status - EDA","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"plt.hist(train_patient_data.SmokingStatus)\nplt.ylabel('Number of patients')\nplt.xlabel('SmokingStatus')\nplt.title('Histogram of SmokingStatus of patients');\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"labels = 'Ex-smoker', 'Never smoked', 'Currently smokes'\nvalues = [np.sum(train_patient_data.SmokingStatus.eq(\"Ex-smoker\")), np.sum(train_patient_data.SmokingStatus.eq(\"Never smoked\")), np.sum(train_patient_data.SmokingStatus.eq(\"Currently smokes\"))]\nfig1, ax1 = plt.subplots()\nax1.pie(values,  labels=labels, autopct='%1.1f%%',\n        shadow=True, startangle=90)\nax1.axis('equal')\nplt.title('Distribution of patients by SmokingStatus')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Age - EDA","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"plt.figure(figsize=(30,15))\nplt.hist(train_patient_data.Age,bins=50)\nplt.ylabel('Number of patients')\nplt.xlabel('Age')\nplt.title('Histogram of Age of patients');\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"plt.figure(figsize=(16, 6))\nsns.kdeplot(train_patient_data.loc[train_patient_data['Sex'] == 'Male', 'Age'], label = 'Male',shade=True)\nsns.kdeplot(train_patient_data.loc[train_patient_data['Sex'] == 'Female', 'Age'], label = 'Female',shade=True)\nplt.xlabel('Age (years)'); plt.ylabel('Density'); plt.title('Distribution of Ages over gender');","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"plt.figure(figsize=(16, 6))\nsns.kdeplot(train_patient_data.loc[train_patient_data['SmokingStatus'] == 'Ex-smoker', 'Age'], label = 'Ex-smoker',shade=True)\nsns.kdeplot(train_patient_data.loc[train_patient_data['SmokingStatus'] == 'Never smoked', 'Age'], label = 'Never smoked',shade=True)\nsns.kdeplot(train_patient_data.loc[train_patient_data['SmokingStatus'] == 'Currently smokes', 'Age'], label = 'Currently smokes', shade=True)\n\n# Labeling of plot\nplt.xlabel('Age (years)');\nplt.ylabel('Density');\nplt.title('Distribution of Ages over SmokingStatus');","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"There do not seem to be any patients with age more than 82 who currently smoke.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"plt.figure(figsize=(16, 6))\nax = sns.violinplot(x = train_patient_data['SmokingStatus'], y = train_patient_data['Age'], palette = 'Reds')\nax.set_xlabel(xlabel = 'Smoking habit', fontsize = 15)\nax.set_ylabel(ylabel = 'Age', fontsize = 15)\nax.set_title(label = 'Distribution of Smokers over Age', fontsize = 20)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Sex - EDA","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"plt.hist(train_patient_data.Sex)\nplt.ylabel('Number of patients')\nplt.xlabel('Sex')\nplt.title('Histogram of Sex of patients');\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"labels = 'Male', 'Female'\nvalues = [np.sum(train_patient_data.Sex.eq(\"Male\")), np.sum(train_patient_data.Sex.eq(\"Female\"))]\nfig1, ax1 = plt.subplots()\nax1.pie(values,  labels=labels, autopct='%1.1f%%',\n        shadow=True, startangle=90)\nax1.axis('equal')\nplt.title('Distribution of patients by Gender')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"* Data is highly skewed towards Ex-Smoker, it might be due to the fact that as the patients noticed symptoms they gave up smoking.\n* Data is highly skewed for people in Age 65-72.\n* Data is highly skewed in Male population.","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"#### Easy code for stacked barchart","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"cond1_colname = 'Sex'\ncond1_vales = np.unique(train_patient_data[[cond1_colname]])\n\ncond2_colname = 'SmokingStatus'\ncond2_vales = np.unique(train_patient_data[[cond2_colname]])\ncount_list = []\nfor x in cond1_vales:\n    tmp = []\n    for y in cond2_vales:\n        tmp.append(np.sum((train_patient_data[cond1_colname] == x) & (train_patient_data[cond2_colname] == y)))\n    count_list.append(tmp)\ncount_list = pd.DataFrame(count_list,columns=cond2_vales,index=cond1_vales)\n\ncount_list.plot(kind='bar',stacked = True, figsize=(10,6))\nplt.legend(bbox_to_anchor=(1,1), title = cond2_colname)\nplt.title(cond2_colname+' by '+cond1_colname)\nplt.xlabel(cond1_colname)\nplt.ylabel(cond2_colname)\nwarnings.filterwarnings('ignore')\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Though the Female contribution is less the number of \"Never Smoked\" patients in Male and Female are similar. This is interesting. Let us explore more.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"#labels = cond2_vales\n#values = [np.sum(train_patient_data.Sex.eq(\"Male\")), np.sum(train_patient_data.Sex.eq(\"Female\"))]\nfor x in cond1_vales:\n    fig1, ax1 = plt.subplots()\n    ax1.pie(count_list.loc[x,:],  labels=cond2_vales, autopct='%1.1f%%',\n            shadow=True, startangle=90)\n    ax1.axis('equal')\n    plt.title('Distribution of SmokingStatus in '+x)\n    plt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"So the percentage of NeverSmoked in Female is more. We will consider this information during our Experiments.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"train_patient_data.boxplot(column='Age', by='Sex')\n#plt.title(\"ddddd\")\nplt.title(\"Boxplot of Age by Sex\")\nplt.ylabel(\"Age\")\n# get rid of the automatic 'Boxplot grouped by group_by_column_name' title\nplt.suptitle(\"\")\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Further examination of training data","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"train['Patient'].value_counts().max()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"There are multiple rows for one patient","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"### Weeks - EDA","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"plt.figure(figsize=(30,15))\nplt.hist(train.Weeks,bins=150)\nplt.ylabel('Number of Weeks')\nplt.xlabel('Week')\nplt.title('Distribution of Weeks');","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We have very few negative values i.e. very few information before the baseline CT.\n\nWe have less information after 60 weeks.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"week_arr = np.array(train.Weeks)\nprint(\"We have\",sum(week_arr < 0),\"records before the baseline CT\")\nfor x in [60,70,80,90,100,110,120]:\n    print(\"We have\",sum(week_arr > x),\"records after\",x,\"weeks\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Some more considerations for our experiments.\n* How best to use the 11 records before the baseline CT\n* Should we use 10 records after 100 weeks or consider them as outliers","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"### FVC - EDA","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"plt.scatter(x=list(train['FVC'].value_counts().keys()),y=list(train['FVC'].value_counts().values))\nplt.ylabel('Count of FVC')\nplt.xlabel('FVC')\nplt.title('Distribution of FVC')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"plt.figure(figsize=(30,15))\nplt.hist(train['FVC'],bins=250)\nplt.ylabel('Count of FVC')\nplt.xlabel('FVC')\nplt.title('Distribution of FVC')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(\"so FVC values range from\",min(train['FVC']),\"to\",max(train['FVC']),\"and do not seem to be repeating often\")","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"fig = px.scatter(train, x=\"FVC\", y=\"Percent\", color='Age')\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Some observations from the plot:\n* There seems be a linear correlation between FVC and Percent\n* People with age > 85 do not seem to have a high FVC i.e. > 2500\n* Only people with Age 71 have FVC > 5100, most probably all the records belong to one person. Let us examine that","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"np.unique(train[train['FVC'] > 5100].Patient)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Let us also check if there are any records of this patient having FVC < 5100","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"sum(train[train['Patient'] == 'ID00219637202258203123958'].FVC < 5100)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Yes only one patient i.e. ID00219637202258203123958 has FVC > 5100 so we can remove this as an outlier.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"fig = px.scatter(train, x=\"Weeks\", y=\"Age\", color='Sex')\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Very few patient records exist after 110 weeks.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"fig = px.scatter(train, x=\"FVC\", y=\"Age\", color='Sex')\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Some observations:\n* Overall Male have a high FVC compared to Female\n* Only a few Female have a high FVC i.e. around 3000, let us examine this further ","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"high_FVC_female_patients = np.unique(train[(train['FVC'] > 2800) & (train['Sex']=='Female')].Patient)\nhigh_FVC_female_patients","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"There seems be 5 female patients with FVC > 2800.\n\nLet us examine if these patients ever had FVC < 2800","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"sum(train['Patient'].isin(high_FVC_female_patients) & (train['FVC'] < 2800))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"There seems to be 4 records of these patients with FVC < 2800. Let us see who are those patients","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"tmp_patients = np.unique(train[train['Patient'].isin(high_FVC_female_patients) & (train['FVC'] < 2800)].Patient)\ntmp_patients","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"set(high_FVC_female_patients) - set(tmp_patients)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"These 3 Female patients have FVC > 2800 with no record of FVC < 2800","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"fig = px.scatter(train, x=\"FVC\", y=\"Weeks\", color='SmokingStatus')\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"In general Person who do not smoke have less FVC","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"### Percent - EDA","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"plt.figure(figsize=(30,15))\nplt.hist(train['Percent'],bins=25)\nplt.ylabel('Count of Percent')\nplt.xlabel('Percent')\nplt.title('Distribution of Percent')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Some observations:\n* Very less records with percentages less than 40 and mote than 120\n* High number of records have percentages between 60 and 80","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"fig = px.violin(train, y='Percent', x='SmokingStatus', box=True, color='Sex', points=\"all\",\n          hover_data=train.columns)\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"plt.figure(figsize=(16, 6))\nax = sns.violinplot(x = train['SmokingStatus'], y = train['Percent'], palette = 'Reds')\nax.set_xlabel(xlabel = 'Smoking Habit', fontsize = 15)\nax.set_ylabel(ylabel = 'Percent', fontsize = 15)\nax.set_title(label = 'Distribution of Smoking Status Over Percentage', fontsize = 20)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"fig = px.scatter(train, x=\"Age\", y=\"Percent\", color='SmokingStatus')\nfig.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# DICOM files - Read","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"DICOM(Digital Imaging and COmmunications in Medicine) is the de-facto standard that establishes rules that allow medical images(X-Ray, MRI, CT) and associated information to be exchanged between imaging equipment from different vendors, computers, and hospitals. The DICOM format provides a suitable means that meets health information exchange (HIE) standards for transmission of health related data among facilities and HL7 standards which is the messaging standard that enables clinical applications to exchange data.\n\n![image.png](data:image/png;base64,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)\n\nReference - [https://towardsdatascience.com/understanding-dicoms-835cd2e57d0b](https://towardsdatascience.com/understanding-dicoms-835cd2e57d0b)","attachments":{},"execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"files = folders = 0\n\npath = \"/kaggle/input/osic-pulmonary-fibrosis-progression/train\"\n\nfor _, dirnames, filenames in os.walk(path):\n    files += len(filenames)\n    folders += len(dirnames)\nprint(files,\"files/images\\n\",folders,'folders/patients')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Examining few DICOM files","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"files = glob.glob('../input/osic-pulmonary-fibrosis-progression/train/*/*.dcm')\ndef dicom_to_image(filename):\n    im = dcm.dcmread(filename)\n    img = im.pixel_array\n    img[img == -2000] = 0\n    return img\nf, plots = plt.subplots(4, 5, sharex='col', sharey='row', figsize=(10, 8))\nfor i in range(20):\n    plots[i // 5, i % 5].axis('off')\n    plots[i // 5, i % 5].imshow(dicom_to_image(files[i]), cmap=plt.cm.bone)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Most of them are similar, let us look randomly again to be sure.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"f, plots = plt.subplots(4, 5, sharex='col', sharey='row', figsize=(10, 8))\nfor i in range(20):\n    plots[i // 5, i % 5].axis('off')\n    plots[i // 5, i % 5].imshow(dicom_to_image(np.random.choice(files)), cmap=plt.cm.bone)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"So some images are not uniform, again something we will consider during our experiments.","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"## Dark Images\n\nThanks to this [discussion](https://www.kaggle.com/c/osic-pulmonary-fibrosis-progression/discussion/170861) we are aware the some scans are dark for instance as below.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"files_darkimages = glob.glob('../input/osic-pulmonary-fibrosis-progression/train/ID00105637202208831864134/*.dcm')\nprint(\"Patiend files :\",len(files_darkimages))\nf, plots = plt.subplots(4, 5, sharex='col', sharey='row', figsize=(10, 8))\nfor i in range(20):\n    plots[i // 5, i % 5].axis('off')\n    plots[i // 5, i % 5].imshow(dicom_to_image(files_darkimages[i]), cmap=plt.cm.bone)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Dark images - fixed\n\nThere seems two ways to fix this as mentioned [here](http://uwmsk.org/jupyter/Jupyter_DICOM_toolbox.html)\n\n1. `equalize_hist`\n2. `equalize_adapthist`\n\nLet us try both of these","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"from skimage import exposure\ndef dicom_to_image2(filename):\n    im = dcm.dcmread(filename)\n    img = im.pixel_array\n    img = exposure.equalize_hist(img)\n    return img\n\ndef dicom_to_image3(filename):\n    im = dcm.dcmread(filename)\n    img = im.pixel_array\n    img = exposure.equalize_adapthist(img)\n    return img","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"f, plots = plt.subplots(4, 5, sharex='col', sharey='row', figsize=(10, 8))\nfor i in range(20):\n    plots[i // 5, i % 5].axis('off')\n    plots[i // 5, i % 5].imshow(dicom_to_image2(files_darkimages[i]), cmap=plt.cm.bone)\nplt.title(\"Dark images fixed using equalize_hist\")","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"f, plots = plt.subplots(4, 5, sharex='col', sharey='row', figsize=(10, 8))\nfor i in range(20):\n    plots[i // 5, i % 5].axis('off')\n    plots[i // 5, i % 5].imshow(dicom_to_image3(files_darkimages[i]), cmap=plt.cm.bone)\nplt.title(\"Dark images fixed using equalize_adapthist\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"While the images with equalise_hist are more clear, it is not recommended over the other. Hence let us leave both these options for our experiments during training.","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"Let us view the initial images again with the new methods.","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"f, plots = plt.subplots(4, 5, sharex='col', sharey='row', figsize=(10, 8))\nfor i in range(20):\n    plots[i // 5, i % 5].axis('off')\n    plots[i // 5, i % 5].imshow(dicom_to_image2(files[i]), cmap=plt.cm.bone)\nplt.title(\"Dark images fixed using equalize_hist\")","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"f, plots = plt.subplots(4, 5, sharex='col', sharey='row', figsize=(10, 8))\nfor i in range(20):\n    plots[i // 5, i % 5].axis('off')\n    plots[i // 5, i % 5].imshow(dicom_to_image3(files[i]), cmap=plt.cm.bone)\nplt.title(\"Dark images fixed using equalize_adapthist\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Pytorch Neural Network\n\nThis code has been built upon https://www.kaggle.com/carlossouza/quantile-regression-pytorch-tabular-data-only\n\nWe are only using Tabular Data at the moment.","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"## Additional libraries for Training","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"import copy\nfrom datetime import datetime, timedelta\nimport matplotlib.pyplot as plt\nfrom pathlib import Path\nfrom sklearn.model_selection import GroupKFold\nfrom torch.utils.data import Dataset\nfrom tqdm import tqdm\nimport torch\nfrom torch.utils.data import DataLoader, Subset\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.optim import Adam\nfrom torch.optim.lr_scheduler import StepLR\nfrom torch.utils.tensorboard import SummaryWriter\nfrom tqdm.notebook import trange\nfrom time import time","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Inputs for Neural Network","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"root_dir = Path('/kaggle/input/osic-pulmonary-fibrosis-progression')\nmodel_dir = '/kaggle/working/model_states'\nnum_kfolds = 5\nbatch_size = 32\nlearning_rate = 3e-3\nnum_epochs = 1000\nes_patience = 8\nquantiles = (0.2, 0.5, 0.8)\nmodel_name ='descartes'\ntensorboard_dir = Path('/kaggle/working/runs')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Dataset Initialization","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"class ClinicalDataset(Dataset):\n    def __init__(self, root_dir, mode, transform=None):\n        self.transform = transform\n        self.mode = mode\n\n        tr = pd.read_csv(Path(root_dir)/\"train.csv\")\n        tr.drop_duplicates(keep=False, inplace=True, subset=['Patient', 'Weeks'])\n        chunk = pd.read_csv(Path(root_dir)/\"test.csv\")\n\n        sub = pd.read_csv(Path(root_dir)/\"sample_submission.csv\")\n        sub['Patient'] = sub['Patient_Week'].apply(lambda x: x.split('_')[0])\n        sub['Weeks'] = sub['Patient_Week'].apply(lambda x: int(x.split('_')[-1]))\n        sub = sub[['Patient', 'Weeks', 'Confidence', 'Patient_Week']]\n        sub = sub.merge(chunk.drop('Weeks', axis=1), on=\"Patient\")\n\n        tr['WHERE'] = 'train'\n        chunk['WHERE'] = 'val'\n        sub['WHERE'] = 'test'\n        data = tr.append([chunk, sub])\n\n        data['min_week'] = data['Weeks']\n        data.loc[data.WHERE == 'test', 'min_week'] = np.nan\n        data['min_week'] = data.groupby('Patient')['min_week'].transform('min')\n\n        base = data.loc[data.Weeks == data.min_week]\n        base = base[['Patient', 'FVC']].copy()\n        base.columns = ['Patient', 'min_FVC']\n        base['nb'] = 1\n        base['nb'] = base.groupby('Patient')['nb'].transform('cumsum')\n        base = base[base.nb == 1]\n        base.drop('nb', axis=1, inplace=True)\n\n        data = data.merge(base, on='Patient', how='left')\n        data['base_week'] = data['Weeks'] - data['min_week']\n        del base\n\n        COLS = ['Sex', 'SmokingStatus']\n        self.FE = []\n        for col in COLS:\n            for mod in data[col].unique():\n                self.FE.append(mod)\n                data[mod] = (data[col] == mod).astype(int)\n\n        data['age'] = (data['Age'] - data['Age'].min()) / \\\n                      (data['Age'].max() - data['Age'].min())\n        data['BASE'] = (data['min_FVC'] - data['min_FVC'].min()) / \\\n                       (data['min_FVC'].max() - data['min_FVC'].min())\n        data['week'] = (data['base_week'] - data['base_week'].min()) / \\\n                       (data['base_week'].max() - data['base_week'].min())\n        data['percent'] = (data['Percent'] - data['Percent'].min()) / \\\n                          (data['Percent'].max() - data['Percent'].min())\n        self.FE += ['age', 'percent', 'week', 'BASE']\n\n        self.raw = data.loc[data.WHERE == mode].reset_index()\n        del data\n\n    def __len__(self):\n        return len(self.raw)\n\n    def __getitem__(self, idx):\n        if torch.is_tensor(idx):\n            idx = idx.tolist()\n\n        sample = {\n            'patient_id': self.raw['Patient'].iloc[idx],\n            'features': self.raw[self.FE].iloc[idx].values,\n            'target': self.raw['FVC'].iloc[idx]\n        }\n        if self.transform:\n            sample = self.transform(sample)\n\n        return sample\n\n    def group_kfold(self, n_splits):\n        gkf = GroupKFold(n_splits=n_splits)\n        groups = self.raw['Patient']\n        for train_idx, val_idx in gkf.split(self.raw, self.raw, groups):\n            train = Subset(self, train_idx)\n            val = Subset(self, val_idx)\n            yield train, val\n\n    def group_split(self, test_size=0.2):\n        \"\"\"To test no-kfold\n        \"\"\"\n        gss = GroupShuffleSplit(n_splits=1, test_size=test_size)\n        groups = self.raw['Patient']\n        idx = list(gss.split(self.raw, self.raw, groups))\n        train = Subset(self, idx[0][0])\n        val = Subset(self, idx[0][1])\n        return train, val","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Neural Network","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"class QuantModel(nn.Module):\n    def __init__(self, in_tabular_features=9, out_quantiles=3):\n        super(QuantModel, self).__init__()\n        self.fc1 = nn.Linear(in_tabular_features, 100)\n        #self.bn1 = nn.BatchNorm1d(num_features=100)\n        self.fc2 = nn.Linear(100, 100)\n        self.fc3 = nn.Linear(100, out_quantiles)\n\n    def forward(self, x):\n        x = F.leaky_relu(self.fc1(x))\n        #x = self.bn1(x)\n        x = F.leaky_relu(self.fc2(x))\n        x = self.fc3(x)\n        return x\n\n\ndef quantile_loss(preds, target, quantiles):\n    #assert not target.requires_grad\n    assert len(preds) == len(target)\n    losses = []\n    for i, q in enumerate(quantiles):\n        errors = target - preds[:, i]\n        losses.append(torch.max((q - 1) * errors, q * errors).unsqueeze(1))\n    loss = torch.mean(torch.sum(torch.cat(losses, dim=1), dim=1))\n    return loss\n\ndef metric_loss(pred_fvc,true_fvc):\n        #Implementation of the metric in pytorch\n    sigma = pred_fvc[:, 2] - pred_fvc[:, 0]\n    true_fvc=torch.reshape(true_fvc,pred_fvc[:,1].shape)\n    sigma_clipped=torch.clamp(sigma,min=70)\n    delta=torch.clamp(torch.abs(pred_fvc[:,1]-true_fvc),max=1000)\n    metric=torch.div(-torch.sqrt(torch.tensor([2.0]).to(device))*delta,sigma_clipped)-torch.log(torch.sqrt(torch.tensor([2.0]).to(device))*sigma_clipped)\n    return metric\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Training\n\nWe are using EarlyStopping. I implement this almost everywhere as it is very easy to implement i.e. hold a copy of weights when validation LLL (or accuracy or f1) increases and at the end of the training use the best weights. A easy powerful way to prevent overfitting.\n\n![image.png](data:image/png;base64,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)","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"\nmodels = []\n\ntrain_loss = []\nval_lll = []\n# Load the data\ndata = ClinicalDataset(root_dir=root_dir, mode='train')\nfolds = data.group_kfold(num_kfolds)\n#t0 = time()\n#if len(testfiles) == 5:\n    #f= open(\"/kaggle/working/training.log\",\"w+\") \nfor fold, (trainset, valset) in enumerate(folds):\n    best_val = None\n    patience = es_patience\n    model = QuantModel().to(device)\n    params = [p for p in model.parameters() if p.requires_grad]\n    optimizer = Adam(params, lr=learning_rate)\n# lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=3, gamma=0.1)\n    lr_scheduler = StepLR(optimizer, step_size=20, gamma=0.5)\n\n\n    print(\"==\"*20+\"Fold \"+str(fold+1)+\"==\"*20)\n    Path(model_dir).mkdir(parents=True, exist_ok=True)\n    model_path = model_dir+f'/fold_{fold}.pth'\n    now = datetime.now()\n    dataset_sizes = {'train': len(trainset), 'val': len(valset)}\n    dataloaders = {\n            'train': DataLoader(trainset, batch_size=batch_size,\n                                shuffle=True, num_workers=2),\n            'val': DataLoader(valset, batch_size=batch_size,\n                              shuffle=False, num_workers=2)\n    }\n    train_loss_epoch = []\n    val_lll_epoch = []\n    for epoch in range(num_epochs):\n        start_time = time()\n        itr = 1\n        model.train()\n        train_losses =[]\n        for batch in dataloaders['train']:\n            inputs = batch['features'].float().to(device)\n            targets = batch['target'].to(device)\n            optimizer.zero_grad()\n            with torch.set_grad_enabled(True):\n                preds = model(inputs)\n                loss = quantile_loss(preds, targets, quantiles)\n                train_losses.append(loss.tolist())\n                loss.backward()\n                optimizer.step()\n           \n            if itr % 50 == 0:\n                print(f\"Epoch #{epoch+1} Iteration #{itr} loss: {loss}\")\n            itr += 1\n            \n        model.eval()\n        all_preds = []\n        all_targets = []\n        for batch in dataloaders['val']:\n            inputs = batch['features'].float().to(device)\n            targets = batch['target']\n            optimizer.zero_grad()\n            with torch.set_grad_enabled(False):\n                preds = model(inputs)\n                all_preds.extend(preds.detach().cpu().numpy().tolist())\n                all_targets.extend(targets.numpy().tolist()) # np.append(an_array, row_to_append, 0)\n        all_preds =torch.FloatTensor(all_preds)\n        all_targets =torch.FloatTensor(all_targets)\n        val_metric_loss = metric_loss(all_preds, all_targets)\n        val_metric_loss = torch.mean(val_metric_loss).tolist()\n\n        lr_scheduler.step()\n        print(f\"Epoch #{epoch+1}\",\"Training loss : {0:.4f}\".format(np.mean(train_losses)),\"Validation LLL : {0:.4f}\".format(val_metric_loss),\"Time taken :\",str(timedelta(seconds=time() - start_time))[:7])\n        train_loss_epoch.append(np.mean(train_losses))\n        val_lll_epoch.append(val_metric_loss)\n        if not best_val:\n            best_val = val_metric_loss  # So any validation roc_auc we have is the best one for now\n            print(\"Info : Saving model\")\n            torch.save(copy.deepcopy(model.state_dict()), model_path)  # Saving the model\n        if val_metric_loss > best_val:\n            print(\"Info : Saving model as Laplace Log Likelihood is increased from {0:.4f}\".format(best_val),\"to {0:.4f}\".format(val_metric_loss))\n            best_val = val_metric_loss\n            patience = es_patience  # Resetting patience since we have new best validation accuracy\n            torch.save(copy.deepcopy(model.state_dict()), model_path)  # Saving current best model torch.save(model.state_dict(), 'fasterrcnn_resnet50_fpn.pth')\n        else:\n            patience -= 1\n            if patience == 0:\n                print('Early stopping. Best Validation Laplace Log Likelihood: {:.3f}'.format(best_val))\n                break\n    model.load_state_dict(torch.load(model_path))\n    models.append(model)\n    train_loss.append(train_loss_epoch)\n    val_lll.append(val_lll_epoch)\nprint('Finished Training of BiLSTM Model')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Training visualisations","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"plt.figure(figsize=(15,4))\nfor i in range(len(train_loss)):\n    plt.plot(train_loss[i],label=\"Fold \"+str(i+1))\n#plt.plot(val_loss,label=\"Validation loss\",color=\"blue\")\nplt.xlabel(\"Epoch\")\nplt.ylabel(\"Training Loss\")\nplt.title(\"Epoch vs Training Loss\")\nplt.legend()\nplt.grid()\nplt.show()\n\n\nplt.figure(figsize=(15,4))\nfor i in range(len(val_lll)):\n    plt.plot(val_lll[i],label=\"Fold \"+str(i+1))\nplt.xlabel(\"Epoch\")\nplt.ylabel(\"Validation Log Laplacian Likelihood\")\nplt.title(\"Epoch vs Validation Log Laplacian Likelihood\")\nplt.legend()\nplt.grid()\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"These graphs say that a maximum of 20 epochs for every fold is good enough.","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"## Test predicition","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"data = ClinicalDataset(root_dir, mode='test')\navg_preds = np.zeros((len(data), len(quantiles)))\n\nfor model in models:\n    dataloader = DataLoader(data, batch_size=batch_size,\n                            shuffle=False, num_workers=2)\n    preds = []\n    for batch in dataloader:\n        inputs = batch['features'].float()\n        with torch.no_grad():\n            x = model(inputs)\n            preds.append(x)\n\n    preds = torch.cat(preds, dim=0).numpy()\n    avg_preds += preds\n\navg_preds /= len(models)\ndf = pd.DataFrame(data=avg_preds, columns=list(quantiles))\ndf['Patient_Week'] = data.raw['Patient_Week']\ndf['FVC'] = df[quantiles[1]]\ndf['Confidence'] = df[quantiles[2]] - df[quantiles[0]]\ndf = df.drop(columns=list(quantiles))\ndf.to_csv('submission.csv', index=False)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"df.head()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"I will continue to work on it to the best of my ability.","execution_count":null}],"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}