{"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":"markdown","source":"## Breast Cancer Detection\n### Project Lifecycle:\n#### 1) Environment Setup & Data Loading\n#### 2) Data Exploration\n#### 3) Creating a custom dataset\n#### 4) Building the classification model\n#### 5) Defining the loss function\n#### 6) Defining the optimizer\n#### 7) Training and evaluation of the model\n#### 8) Deploying the model\n#### 9) Model inference on test data\n","metadata":{}},{"cell_type":"code","source":"!python -m venv /kaggle/working/breast_cancer_detection\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:22.339846Z","iopub.execute_input":"2023-07-25T09:01:22.340658Z","iopub.status.idle":"2023-07-25T09:01:27.985555Z","shell.execute_reply.started":"2023-07-25T09:01:22.34063Z","shell.execute_reply":"2023-07-25T09:01:27.984144Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"!source /kaggle/working/breast_cancer_detection/bin/activate\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:27.988543Z","iopub.execute_input":"2023-07-25T09:01:27.99199Z","iopub.status.idle":"2023-07-25T09:01:29.065793Z","shell.execute_reply.started":"2023-07-25T09:01:27.991947Z","shell.execute_reply":"2023-07-25T09:01:29.06434Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport cv2","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:29.070007Z","iopub.execute_input":"2023-07-25T09:01:29.070323Z","iopub.status.idle":"2023-07-25T09:01:29.465666Z","shell.execute_reply.started":"2023-07-25T09:01:29.070293Z","shell.execute_reply":"2023-07-25T09:01:29.464657Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Data Loading","metadata":{}},{"cell_type":"code","source":"train_df = pd.read_csv('/kaggle/input/rsna-breast-cancer-detection/train.csv')","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:29.471999Z","iopub.execute_input":"2023-07-25T09:01:29.47444Z","iopub.status.idle":"2023-07-25T09:01:29.619896Z","shell.execute_reply.started":"2023-07-25T09:01:29.474405Z","shell.execute_reply":"2023-07-25T09:01:29.618858Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_images_path= '/kaggle/input/breat-cancer-png-train-images'\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:29.624886Z","iopub.execute_input":"2023-07-25T09:01:29.62532Z","iopub.status.idle":"2023-07-25T09:01:29.63157Z","shell.execute_reply.started":"2023-07-25T09:01:29.625278Z","shell.execute_reply":"2023-07-25T09:01:29.629854Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### EDA","metadata":{}},{"cell_type":"code","source":"train_df.head()","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:29.632742Z","iopub.execute_input":"2023-07-25T09:01:29.633159Z","iopub.status.idle":"2023-07-25T09:01:29.67Z","shell.execute_reply.started":"2023-07-25T09:01:29.633112Z","shell.execute_reply":"2023-07-25T09:01:29.669141Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(train_df['cancer'].value_counts())","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:29.673034Z","iopub.execute_input":"2023-07-25T09:01:29.673325Z","iopub.status.idle":"2023-07-25T09:01:29.686776Z","shell.execute_reply.started":"2023-07-25T09:01:29.673301Z","shell.execute_reply":"2023-07-25T09:01:29.685839Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df.info()","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:29.688124Z","iopub.execute_input":"2023-07-25T09:01:29.689006Z","iopub.status.idle":"2023-07-25T09:01:29.813312Z","shell.execute_reply.started":"2023-07-25T09:01:29.688974Z","shell.execute_reply":"2023-07-25T09:01:29.81048Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df['view']","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:29.819038Z","iopub.execute_input":"2023-07-25T09:01:29.81948Z","iopub.status.idle":"2023-07-25T09:01:29.837553Z","shell.execute_reply.started":"2023-07-25T09:01:29.819423Z","shell.execute_reply":"2023-07-25T09:01:29.835976Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df.isnull().sum()","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:29.843445Z","iopub.execute_input":"2023-07-25T09:01:29.844392Z","iopub.status.idle":"2023-07-25T09:01:29.901065Z","shell.execute_reply.started":"2023-07-25T09:01:29.844357Z","shell.execute_reply":"2023-07-25T09:01:29.899711Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Count the frequency of each category\ncategory_counts = train_df['cancer'].value_counts()\ncategory_counts","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:29.902345Z","iopub.execute_input":"2023-07-25T09:01:29.903375Z","iopub.status.idle":"2023-07-25T09:01:29.913534Z","shell.execute_reply.started":"2023-07-25T09:01:29.903342Z","shell.execute_reply":"2023-07-25T09:01:29.912627Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\nimport matplotlib.pyplot as plt\n\n# Count the frequency of each category\ncategory_counts = train_df['cancer'].value_counts()\n\n# Define colors for each category\ncolors = [ 'green', 'red',]\n\n# Create a bar chart with specified colors\nplt.bar(category_counts.index, category_counts.values, color=colors)\n\n# Customize the chart\nplt.xlabel('Cancer')\nplt.ylabel('Count')\nplt.title('Cancer-Negative Vs Positive')\nplt.xticks(category_counts.index)\n\n# Display the chart\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:29.915678Z","iopub.execute_input":"2023-07-25T09:01:29.916123Z","iopub.status.idle":"2023-07-25T09:01:30.353647Z","shell.execute_reply.started":"2023-07-25T09:01:29.91608Z","shell.execute_reply":"2023-07-25T09:01:30.352746Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\n# Count the frequency of each category\ncategory_counts = train_df['invasive'].value_counts()\n\n# Define colors for each category\ncolors = [ 'green', 'red',]\n\n# Create a bar chart with specified colors\nplt.bar(category_counts.index, category_counts.values, color=colors)\n\n# Customize the chart\nplt.xlabel('invasive')\nplt.ylabel('Count')\nplt.title('Invasive Cancer-Negative Vs Positive')\nplt.xticks( category_counts.index)\n\n# Display the chart\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:30.355132Z","iopub.execute_input":"2023-07-25T09:01:30.356429Z","iopub.status.idle":"2023-07-25T09:01:30.587676Z","shell.execute_reply.started":"2023-07-25T09:01:30.356394Z","shell.execute_reply":"2023-07-25T09:01:30.586831Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Count the frequency of each category\ncategory_counts = train_df['BIRADS'].value_counts()\n\n# Define colors for each category\ncolors = [ 'green', 'red','orange']\n\n# Create a bar chart with specified colors\nplt.bar(category_counts.index, category_counts.values, color=colors)\n\n# Customize the chart\nplt.xlabel('BIRADS')\nplt.ylabel('Count')\nplt.title('BIRADS-Follow up required,negative, normal')\nplt.xticks( category_counts.index)\n\n\n# Display the chart\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:30.589684Z","iopub.execute_input":"2023-07-25T09:01:30.590299Z","iopub.status.idle":"2023-07-25T09:01:30.886325Z","shell.execute_reply.started":"2023-07-25T09:01:30.590264Z","shell.execute_reply":"2023-07-25T09:01:30.885257Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\n\n# Count the frequency of each category\ncategory_counts = train_df['biopsy'].value_counts()\n\n# Define colors for each category\ncolors = [ 'green', 'red',]\n\n# Create a bar chart with specified colors\nplt.bar(category_counts.index, category_counts.values, color=colors)\n\n# Customize the chart\nplt.xlabel('Biopsy')\nplt.ylabel('Count')\nplt.title('Follow-up Biospy- No Vs Yes')\nplt.xticks( category_counts.index)\n\n\n# Display the chart\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:30.889492Z","iopub.execute_input":"2023-07-25T09:01:30.890302Z","iopub.status.idle":"2023-07-25T09:01:31.122412Z","shell.execute_reply.started":"2023-07-25T09:01:30.890264Z","shell.execute_reply":"2023-07-25T09:01:31.121462Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\n# Group the data by \"cancer\" and \"biopsy\" columns and calculate the count\ngrouped_data = train_df.groupby(['cancer', 'biopsy']).size().unstack()\n\n# Get unique categories from the \"cancer\" column\ncategories = grouped_data.index\n\n# Set the bar width\nbar_width = 0.35\n\n# Set the positions of the bars on the x-axis\nr = range(len(categories))\n\n# Create the stacked bar chart\nfor i, col in enumerate(grouped_data.columns):\n    plt.bar(r, grouped_data[col], bottom=grouped_data.iloc[:, :i].sum(axis=1), width=bar_width, label=col)\n\n# Customize the chart\nplt.xlabel('Cancer')\nplt.ylabel('Count')\nplt.title('Stacked Bar Chart: Cancer and Biopsy')\nplt.xticks(r, categories)\nplt.legend(title='Biopsy')\n\n# Display the chart\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:31.126247Z","iopub.execute_input":"2023-07-25T09:01:31.126532Z","iopub.status.idle":"2023-07-25T09:01:31.404726Z","shell.execute_reply.started":"2023-07-25T09:01:31.126506Z","shell.execute_reply":"2023-07-25T09:01:31.403864Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Filter the DataFrame for positive diagnosed cases\npositive_cases = train_df[train_df[\"cancer\"]==1]","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:31.406569Z","iopub.execute_input":"2023-07-25T09:01:31.407331Z","iopub.status.idle":"2023-07-25T09:01:31.414531Z","shell.execute_reply.started":"2023-07-25T09:01:31.407296Z","shell.execute_reply":"2023-07-25T09:01:31.41359Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Count the frequency of each density category within positive cases\ndensity_counts= positive_cases[\"density\"].value_counts()\n\n# Create a pie chart\nplt.pie(density_counts.values, labels= density_counts.index, autopct='%1.1f%%')\n\n# Customize the chart\nplt.title('Distribution of Density in Positive Diagnosed Cases')\n\n# Display the chart\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:31.416175Z","iopub.execute_input":"2023-07-25T09:01:31.416506Z","iopub.status.idle":"2023-07-25T09:01:31.633232Z","shell.execute_reply.started":"2023-07-25T09:01:31.416473Z","shell.execute_reply":"2023-07-25T09:01:31.631969Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Density represents how dense the breast tissue is, with A being the least dense and D being the most dense, Extremely dense tissue can make diagnosis more difficult.","metadata":{}},{"cell_type":"code","source":"# Create the box plot\nplt.boxplot(positive_cases['age'])\n\n# Customize the chart\nplt.xlabel('Cancer')\nplt.ylabel('Age')\nplt.title('Box Plot: Age for Positive Diagnosed Cases')\n\n# Display the chart\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:31.634948Z","iopub.execute_input":"2023-07-25T09:01:31.635305Z","iopub.status.idle":"2023-07-25T09:01:31.964648Z","shell.execute_reply.started":"2023-07-25T09:01:31.635271Z","shell.execute_reply":"2023-07-25T09:01:31.96375Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Group the data by \"cancer\" and \"biopsy\" columns and calculate the count\ngrouped_data = train_df.groupby(['cancer', 'implant']).size().unstack()\n\n# Get unique categories from the \"cancer\" column\ncategories = grouped_data.index\n\n# Set the bar width\nbar_width = 0.35\n\n# Set the positions of the bars on the x-axis\nr = range(len(categories))\n\n# Create the stacked bar chart\nfor i, col in enumerate(grouped_data.columns):\n    plt.bar(r, grouped_data[col], bottom=grouped_data.iloc[:, :i].sum(axis=1), width=bar_width, label=col)\n\n# Customize the chart\nplt.xlabel('Cancer')\nplt.ylabel('Count')\nplt.title('Stacked Bar Chart: Cancer and Implants')\nplt.xticks(r, categories)\nplt.legend(title='implants')\n\n# Display the chart\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:31.966282Z","iopub.execute_input":"2023-07-25T09:01:31.966932Z","iopub.status.idle":"2023-07-25T09:01:32.220399Z","shell.execute_reply.started":"2023-07-25T09:01:31.966895Z","shell.execute_reply":"2023-07-25T09:01:32.219516Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Displaying some sample images\n","metadata":{}},{"cell_type":"code","source":"\n\n# List the contents of the /kaggle/input/ directory\ninput_dir = '/kaggle/input/'\ndataset_list = os.listdir(input_dir)\n\n# Find your dataset directory\nfor dataset_name in dataset_list:\n    if dataset_name != '__notebook_source__.ipynb':  # Exclude the notebook itself\n        dataset_path = os.path.join(input_dir, dataset_name)\n        if os.path.isdir(dataset_path):\n            print(\"Dataset directory:\", dataset_name)\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:32.22412Z","iopub.execute_input":"2023-07-25T09:01:32.224656Z","iopub.status.idle":"2023-07-25T09:01:32.234548Z","shell.execute_reply.started":"2023-07-25T09:01:32.224622Z","shell.execute_reply":"2023-07-25T09:01:32.232925Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_images_path= '/kaggle/input/breat-cancer-png-train-images'","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:32.236601Z","iopub.execute_input":"2023-07-25T09:01:32.236898Z","iopub.status.idle":"2023-07-25T09:01:32.247701Z","shell.execute_reply.started":"2023-07-25T09:01:32.236874Z","shell.execute_reply":"2023-07-25T09:01:32.24672Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Create the path to each image.\nfor i in range(len(train_df)):\n    train_df.loc[i, 'path'] = os.path.join(train_images_path + '/' + str(train_df.loc[i, 'patient_id']) + '_' + str(train_df.loc[i, 'image_id']) + '.png')\ntrain_df.head()","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:32.249058Z","iopub.execute_input":"2023-07-25T09:01:32.249375Z","iopub.status.idle":"2023-07-25T09:01:41.855872Z","shell.execute_reply.started":"2023-07-25T09:01:32.249348Z","shell.execute_reply":"2023-07-25T09:01:41.854285Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# a sample path\ntrain_df.loc[0, 'path']","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:41.857667Z","iopub.execute_input":"2023-07-25T09:01:41.858699Z","iopub.status.idle":"2023-07-25T09:01:41.875067Z","shell.execute_reply.started":"2023-07-25T09:01:41.858609Z","shell.execute_reply":"2023-07-25T09:01:41.873474Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# a sample image\nimg = cv2.imread(train_df.loc[0, 'path'])\nplt.imshow(img, cmap = 'gray')","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:41.876654Z","iopub.execute_input":"2023-07-25T09:01:41.877099Z","iopub.status.idle":"2023-07-25T09:01:42.229631Z","shell.execute_reply.started":"2023-07-25T09:01:41.877062Z","shell.execute_reply":"2023-07-25T09:01:42.228729Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"img","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:42.231022Z","iopub.execute_input":"2023-07-25T09:01:42.231617Z","iopub.status.idle":"2023-07-25T09:01:42.239447Z","shell.execute_reply.started":"2023-07-25T09:01:42.231582Z","shell.execute_reply":"2023-07-25T09:01:42.238422Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"img.shape","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:42.241036Z","iopub.execute_input":"2023-07-25T09:01:42.241652Z","iopub.status.idle":"2023-07-25T09:01:42.253404Z","shell.execute_reply.started":"2023-07-25T09:01:42.241619Z","shell.execute_reply":"2023-07-25T09:01:42.252394Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"malignant_cancer= train_df[train_df['cancer']==1].reset_index(drop=True)\nmalignant_cancer","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:42.263254Z","iopub.execute_input":"2023-07-25T09:01:42.263983Z","iopub.status.idle":"2023-07-25T09:01:42.292355Z","shell.execute_reply.started":"2023-07-25T09:01:42.263952Z","shell.execute_reply":"2023-07-25T09:01:42.291506Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Display some sample images with cancer","metadata":{}},{"cell_type":"code","source":"# Number of images to display\nnum_images_to_display = 10\n\n# Calculate the number of columns based on the desired number of images per row\nnum_cols = 5\n\n# Calculate the number of rows needed to display the images\nnum_rows = (num_images_to_display + num_cols - 1) // num_cols\n\n# Display the images in a grid layout\nfig, axs = plt.subplots(num_rows, num_cols, figsize=(15,10))\n\n# Flatten the axs array if necessary\nif num_rows > 1:\n    axs = axs.flatten()\n\n\n# Iterate over the images\nfor i in range(num_images_to_display):\n    img = cv2.imread(malignant_cancer.loc[i, 'path'])\n    axs[i].imshow(img)\n    axs[i].set_title('Cancer')\n    axs[i].axis('off')\n\n# Adjust the layout\nplt.tight_layout()\n\n# Show the plot\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:42.293609Z","iopub.execute_input":"2023-07-25T09:01:42.294021Z","iopub.status.idle":"2023-07-25T09:01:43.751343Z","shell.execute_reply.started":"2023-07-25T09:01:42.293989Z","shell.execute_reply":"2023-07-25T09:01:43.7505Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Display some sample images without cancer","metadata":{}},{"cell_type":"code","source":"benign_cancer= train_df[train_df['cancer']==0].reset_index(drop=True)\nbenign_cancer","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:43.752359Z","iopub.execute_input":"2023-07-25T09:01:43.75268Z","iopub.status.idle":"2023-07-25T09:01:43.792709Z","shell.execute_reply.started":"2023-07-25T09:01:43.752651Z","shell.execute_reply":"2023-07-25T09:01:43.791641Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Number of images to display\nnum_images_to_display = 10\n\n# Calculate the number of columns based on the desired number of images per row\nnum_cols = 5\n\n# Calculate the number of rows needed to display the images\nnum_rows = (num_images_to_display + num_cols - 1) // num_cols\n\n# Display the images in a grid layout\nfig, axs = plt.subplots(num_rows, num_cols, figsize=(15,10))\n\n# Flatten the axs array if necessary\nif num_rows > 1:\n    axs = axs.flatten()\n\n\n# Iterate over the images\nfor i in range(num_images_to_display):\n    img = cv2.imread(benign_cancer.loc[i, 'path'])\n    axs[i].imshow(img)\n    axs[i].set_title('Normal')\n    axs[i].axis('off')\n\n# Adjust the layout\nplt.tight_layout()\n\n# Show the plot\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:43.794327Z","iopub.execute_input":"2023-07-25T09:01:43.794707Z","iopub.status.idle":"2023-07-25T09:01:45.162526Z","shell.execute_reply.started":"2023-07-25T09:01:43.794671Z","shell.execute_reply":"2023-07-25T09:01:45.161711Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"##### As we can see that just by viewing the images, we can't know if a patient has cancer or not.","metadata":{}},{"cell_type":"markdown","source":"### Creating a custom dataset","metadata":{}},{"cell_type":"code","source":"from PIL import Image\nimport torch\nfrom torch.utils.data import Dataset\nimport torchvision.transforms as transforms\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:45.164006Z","iopub.execute_input":"2023-07-25T09:01:45.16459Z","iopub.status.idle":"2023-07-25T09:01:50.946881Z","shell.execute_reply.started":"2023-07-25T09:01:45.164557Z","shell.execute_reply":"2023-07-25T09:01:50.945917Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#fix randm seed for reproductibilty\ntorch.manual_seed(0)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:50.948543Z","iopub.execute_input":"2023-07-25T09:01:50.949215Z","iopub.status.idle":"2023-07-25T09:01:50.965088Z","shell.execute_reply.started":"2023-07-25T09:01:50.949178Z","shell.execute_reply":"2023-07-25T09:01:50.964092Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class breastcancerdataset(Dataset):\n    def __init__(self,train_df,transform):\n        self.train_df = train_df\n        #path to images\n        self.image_path= train_df['path']\n        #obtain labels from data frame\n        self.labels= [img for img in train_df['cancer']]\n        self.transform = transform\n        \n    def __len__(self):\n        #return the size dataset\n        return len(self.train_df)\n    \n    def __getitem__(self,idx):\n        #open image, apply transforms and return with label\n        image = Image.open(self.image_path[idx]) #PIL image\n        image = self.transform(image)\n        return image, self.labels[idx]","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:50.966412Z","iopub.execute_input":"2023-07-25T09:01:50.96696Z","iopub.status.idle":"2023-07-25T09:01:50.974612Z","shell.execute_reply.started":"2023-07-25T09:01:50.966926Z","shell.execute_reply":"2023-07-25T09:01:50.973689Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import torchvision.transforms as transform\ndata_transformer = transforms.Compose([transforms.ToTensor()])","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:50.976004Z","iopub.execute_input":"2023-07-25T09:01:50.976417Z","iopub.status.idle":"2023-07-25T09:01:50.990861Z","shell.execute_reply.started":"2023-07-25T09:01:50.976382Z","shell.execute_reply":"2023-07-25T09:01:50.989956Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"cancer_dataset = breastcancerdataset(train_df,data_transformer)    ","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:50.992288Z","iopub.execute_input":"2023-07-25T09:01:50.992624Z","iopub.status.idle":"2023-07-25T09:01:51.00993Z","shell.execute_reply.started":"2023-07-25T09:01:50.992592Z","shell.execute_reply":"2023-07-25T09:01:51.00895Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(len(cancer_dataset))","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:51.011046Z","iopub.execute_input":"2023-07-25T09:01:51.011383Z","iopub.status.idle":"2023-07-25T09:01:51.022336Z","shell.execute_reply.started":"2023-07-25T09:01:51.011345Z","shell.execute_reply":"2023-07-25T09:01:51.02132Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#load an image\nimg,label = cancer_dataset[9]\nprint(img.shape,torch.min(img), torch.max(img))\n\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:51.023437Z","iopub.execute_input":"2023-07-25T09:01:51.024149Z","iopub.status.idle":"2023-07-25T09:01:51.224734Z","shell.execute_reply.started":"2023-07-25T09:01:51.024072Z","shell.execute_reply":"2023-07-25T09:01:51.223706Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"we can see that the dataset returns images in the (Channels, Height, Width) format\nand pixel values are normalized to the range [0.0, 1.0]. This is the result of transforms.\nToTensor() converts a PIL image into the range [0, 255] to torch.FloatTensor of\nshape (C x H x W) in the range [0.0, 1.0]. It is common to use this formatting when working\nwith images in PyTorch.","metadata":{}},{"cell_type":"markdown","source":"### Splitting the dataset","metadata":{}},{"cell_type":"code","source":"from torch.utils.data import random_split\n\nlen_cancer= len(cancer_dataset)\nlen_train=int(0.8*len_cancer)\nlen_val = len_cancer- len_train\ntrain_ds,val_ds = random_split(cancer_dataset,[len_train,len_val])\n\nprint(\"train dataset length:\", len(train_ds))\nprint(\"validation dataset length:\",len(val_ds))\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:51.22579Z","iopub.execute_input":"2023-07-25T09:01:51.226073Z","iopub.status.idle":"2023-07-25T09:01:51.243076Z","shell.execute_reply.started":"2023-07-25T09:01:51.22605Z","shell.execute_reply":"2023-07-25T09:01:51.242131Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"for x,y in train_ds:\n    print(x.shape,y)\n    break\n ","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:51.244529Z","iopub.execute_input":"2023-07-25T09:01:51.245179Z","iopub.status.idle":"2023-07-25T09:01:51.262242Z","shell.execute_reply.started":"2023-07-25T09:01:51.245146Z","shell.execute_reply":"2023-07-25T09:01:51.261359Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"for x, y in val_ds:\n    print(x.shape,y)\n    break\n    ","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:51.263612Z","iopub.execute_input":"2023-07-25T09:01:51.263968Z","iopub.status.idle":"2023-07-25T09:01:51.280241Z","shell.execute_reply.started":"2023-07-25T09:01:51.263937Z","shell.execute_reply":"2023-07-25T09:01:51.279321Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from torchvision import utils\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\nnp.random.seed(0)\n\n#Define a helper function to show an image\ndef show(img,y,color=False):\n    #convert tensor to numpy array\n    npimg= img.numpy()\n    \n    #convert to H*W*C shape\n    npimg_tr= np.transpose(npimg,(1,2,0))\n    if color== False:\n        npimg_tr = npimg_tr[:,:,0]\n        plt.imshow(npimg_tr, interpolation = 'nearest', cmap= \"gray\")\n    else:\n        #display images\n        plt.imshow(npimg_tr,interpolation ='nearest')\n    plt.title(\"label:\" +str(y))\n\ngrid_size=4\nrnd_inds = np.random.randint(0,len(train_ds), grid_size)\nprint(\"image indices:\", rnd_inds)\n\nx_grid_train = [train_ds[i][0] for i in rnd_inds]\ny_grid_train = [train_ds[i][1] for i in rnd_inds]\n\nx_grid_train = utils.make_grid(x_grid_train, nrow=4, padding= 2)\nprint(x_grid_train.shape)\n\nplt.rcParams['figure.figsize'] = (10.0,5)\nshow(x_grid_train,y_grid_train)\n\n    \n\n        \n    \n    ","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:51.281425Z","iopub.execute_input":"2023-07-25T09:01:51.281841Z","iopub.status.idle":"2023-07-25T09:01:51.729634Z","shell.execute_reply.started":"2023-07-25T09:01:51.281796Z","shell.execute_reply":"2023-07-25T09:01:51.728712Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"grid_size=4\nrnd_inds=np.random.randint(0,len(val_ds),grid_size)\nprint(\"image indices:\",rnd_inds)\nx_grid_val=[val_ds[i][0] for i in range(grid_size)]\ny_grid_val=[val_ds[i][1] for i in range(grid_size)]\nx_grid_val=utils.make_grid(x_grid_val, nrow=4, padding=2)\nprint(x_grid_val.shape)\nshow(x_grid_val,y_grid_val)\n\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:51.731115Z","iopub.execute_input":"2023-07-25T09:01:51.731744Z","iopub.status.idle":"2023-07-25T09:01:52.156587Z","shell.execute_reply.started":"2023-07-25T09:01:51.73171Z","shell.execute_reply":"2023-07-25T09:01:52.155719Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Data Transformation\n\n**Image transformation and image augmentation** are necessary for training deep learningmodels. By using image transformations, we can expand our dataset or resize andnormalize it to achieve better model performance. Typical transformations include **horizontal and vertical flipping, rotation, and resizing.**\n\n**RandomHorizontalFlip and RandomVerticalFlip** will flip the imagehorizontally and vertically with a probability of 0.5, respectively.\nThe **RandomRotation function** rotates images in the range of [-45,45] degrees.\nAlso, **RandomSizedCrop** crops a square image randomly in the range of [72, 512] and then resizes it to the original size of 512x512.\nWe used **transforms.ToTensor** to normalize the images in the range [0, 1] andconvert them into tensors. ","metadata":{}},{"cell_type":"code","source":"train_transformer = transforms.Compose([\n    transforms.RandomHorizontalFlip(p=0.5),\n    transforms.RandomVerticalFlip(p=0.5),\n    transforms.RandomRotation(45),\ntransforms.RandomResizedCrop(512,scale=(0.8,1,0),\n    ratio=(1.0,1.0)), transforms.ToTensor()])","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:52.158108Z","iopub.execute_input":"2023-07-25T09:01:52.158822Z","iopub.status.idle":"2023-07-25T09:01:52.165143Z","shell.execute_reply.started":"2023-07-25T09:01:52.158769Z","shell.execute_reply":"2023-07-25T09:01:52.163943Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":" For the validation dataset, we don't need any augmentation. So, we only convert the images into tensors, normalized to the range [0, 1] in the transforms function:","metadata":{}},{"cell_type":"code","source":"val_transformer = transforms.Compose([transforms.ToTensor()])","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:52.166852Z","iopub.execute_input":"2023-07-25T09:01:52.167248Z","iopub.status.idle":"2023-07-25T09:01:52.175121Z","shell.execute_reply.started":"2023-07-25T09:01:52.167215Z","shell.execute_reply":"2023-07-25T09:01:52.17427Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Overwrite the transform functions of train_ds and val_ds:","metadata":{}},{"cell_type":"code","source":"train_ds.transform = train_transformer\nval_ds.transform = val_transformer","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:52.176454Z","iopub.execute_input":"2023-07-25T09:01:52.176972Z","iopub.status.idle":"2023-07-25T09:01:52.18557Z","shell.execute_reply.started":"2023-07-25T09:01:52.176938Z","shell.execute_reply":"2023-07-25T09:01:52.184722Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Creating Data Loaders\n\nWe will be using a PyTorch dataloaders to extract data batches from the dataset. ","metadata":{}},{"cell_type":"code","source":"from torch.utils.data import DataLoader\ntrain_dl = DataLoader(train_ds,batch_size=32,shuffle=True)\nval_dl = DataLoader(val_ds, batch_size=64, shuffle=False)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:52.187111Z","iopub.execute_input":"2023-07-25T09:01:52.187501Z","iopub.status.idle":"2023-07-25T09:01:52.196868Z","shell.execute_reply.started":"2023-07-25T09:01:52.18747Z","shell.execute_reply":"2023-07-25T09:01:52.195748Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#extract a batch from training data\nfor x,y in train_dl:\n    print(x.shape)\n    print(y.shape)\n    break\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:52.199761Z","iopub.execute_input":"2023-07-25T09:01:52.200076Z","iopub.status.idle":"2023-07-25T09:01:52.510731Z","shell.execute_reply.started":"2023-07-25T09:01:52.200052Z","shell.execute_reply":"2023-07-25T09:01:52.509813Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#extract a batch from validation data\n\nfor x,y in val_dl:\n    print(x.shape)\n    print(y.shape)\n    break","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:52.512291Z","iopub.execute_input":"2023-07-25T09:01:52.512916Z","iopub.status.idle":"2023-07-25T09:01:53.096981Z","shell.execute_reply.started":"2023-07-25T09:01:52.51288Z","shell.execute_reply":"2023-07-25T09:01:53.096019Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#extract a batch from training data\nfor x,y in train_dl:\n    print(x.shape)\n    print(y.shape)\n    break\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Building the classification model\n[![image.png](attachment:7acbb055-6106-4fdf-acdc-9c67ec56189f.png)](http://)","metadata":{},"attachments":{"7acbb055-6106-4fdf-acdc-9c67ec56189f.png":{"image/png":"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"}}},{"cell_type":"code","source":"#get labels for validation dataset\ny_val= [y for _,y in val_ds]","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:01:53.09849Z","iopub.execute_input":"2023-07-25T09:01:53.098846Z","iopub.status.idle":"2023-07-25T09:03:29.279996Z","shell.execute_reply.started":"2023-07-25T09:01:53.098796Z","shell.execute_reply":"2023-07-25T09:03:29.279014Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def accuracy(labels,out):\n    return np.sum(out==labels)/float(len(labels))","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:29.283426Z","iopub.execute_input":"2023-07-25T09:03:29.283725Z","iopub.status.idle":"2023-07-25T09:03:29.288906Z","shell.execute_reply.started":"2023-07-25T09:03:29.283698Z","shell.execute_reply":"2023-07-25T09:03:29.287703Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"np.zeros_like(y_val)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:29.290087Z","iopub.execute_input":"2023-07-25T09:03:29.290844Z","iopub.status.idle":"2023-07-25T09:03:29.30668Z","shell.execute_reply.started":"2023-07-25T09:03:29.290794Z","shell.execute_reply":"2023-07-25T09:03:29.305559Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#calculationg a dumb baseline for all-zero predictions:\n#accuracy all zero predictions\nacc_all_zeros= accuracy(y_val,np.zeros_like(y_val))\nprint(\"accuracy all zero prediction : %.2f\" %acc_all_zeros)\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:29.308012Z","iopub.execute_input":"2023-07-25T09:03:29.308521Z","iopub.status.idle":"2023-07-25T09:03:29.320707Z","shell.execute_reply.started":"2023-07-25T09:03:29.308488Z","shell.execute_reply":"2023-07-25T09:03:29.319865Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#calculationg a dumb baseline for all-one predictions:\n#accuracy all one predictions\nacc_all_ones= accuracy(y_val,np.ones_like(y_val))\nprint(\"accuracy all one prediction: %.2f\" %acc_all_ones)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:29.322291Z","iopub.execute_input":"2023-07-25T09:03:29.322624Z","iopub.status.idle":"2023-07-25T09:03:29.337927Z","shell.execute_reply.started":"2023-07-25T09:03:29.322593Z","shell.execute_reply":"2023-07-25T09:03:29.336833Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#accuracy random predictions\nacc_random = accuracy(y_val,np.random.randint(2,size=len(y_val)))\nprint(\"accuracy all one prediction: %.2f\" %acc_random)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:29.339632Z","iopub.execute_input":"2023-07-25T09:03:29.340018Z","iopub.status.idle":"2023-07-25T09:03:29.351875Z","shell.execute_reply.started":"2023-07-25T09:03:29.339987Z","shell.execute_reply":"2023-07-25T09:03:29.350985Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### helper function to calculate the output size of a CNN layer","metadata":{}},{"cell_type":"code","source":"import torch.nn as nn\nimport numpy as np\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:29.353171Z","iopub.execute_input":"2023-07-25T09:03:29.353709Z","iopub.status.idle":"2023-07-25T09:03:29.365135Z","shell.execute_reply.started":"2023-07-25T09:03:29.353677Z","shell.execute_reply":"2023-07-25T09:03:29.36418Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def findConv2dOutShape(H_in,W_in,conv,pool=2):\n    #get conv arguments\n    kernel_size=conv.kernel_size\n    stride= conv.stride\n    padding = conv.padding\n    dilation = conv.dilation\n    H_out= np.floor((H_in+2*padding[0]-dilation[0]*(kernel_size[0]-1)-1)/stride[0]+1)\n    W_out= np.floor((W_in+2*padding[1]-dilation[1]*(kernel_size[1]-1)-1)/stride[1]+1)\n    if pool:\n        H_out/=pool\n        W_out/=pool\n    return int(H_out),int(W_out)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:29.36645Z","iopub.execute_input":"2023-07-25T09:03:29.366895Z","iopub.status.idle":"2023-07-25T09:03:29.379514Z","shell.execute_reply.started":"2023-07-25T09:03:29.366863Z","shell.execute_reply":"2023-07-25T09:03:29.37868Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import torch.nn as nn\nimport torch.nn.functional as F","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:29.380983Z","iopub.execute_input":"2023-07-25T09:03:29.381532Z","iopub.status.idle":"2023-07-25T09:03:29.391567Z","shell.execute_reply.started":"2023-07-25T09:03:29.381497Z","shell.execute_reply":"2023-07-25T09:03:29.390593Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#example\n#The layer takes an input with 1 channels and produces an output with 8 channels, using a kernel size of 3.\nconv1 = nn.Conv2d(1,8,kernel_size= 3)\nh,w = findConv2dOutShape(512,512,conv1)\nprint(h,w)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:29.394367Z","iopub.execute_input":"2023-07-25T09:03:29.394698Z","iopub.status.idle":"2023-07-25T09:03:29.409571Z","shell.execute_reply.started":"2023-07-25T09:03:29.394673Z","shell.execute_reply":"2023-07-25T09:03:29.408576Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class Net(nn.Module):\n    def __init__(self,params):\n        super(Net,self).__init__()\n        C_in,H_in,W_in= params[\"input_shape\"]\n        init_f= params[\"initial_filters\"]\n        num_fc1=params[\"num_fc1\"]\n        num_classes= params[\"num_classes\"]\n        self.dropout_rate = params[\"dropout_rate\"]\n        \n        self.conv1 = nn.Conv2d(C_in,init_f, kernel_size=3)\n        h,w= findConv2dOutShape(H_in,W_in,self.conv1)\n        self.conv2 = nn.Conv2d(init_f,2*init_f,kernel_size=3)\n        h,w= findConv2dOutShape(h,w,self.conv2)\n        self.conv3= nn.Conv2d(2*init_f,4*init_f,kernel_size=3)\n        h,w= findConv2dOutShape(h,w,self.conv3)\n        self.conv4= nn.Conv2d(4*init_f,8*init_f,kernel_size=3)\n        h,w= findConv2dOutShape(h,w, self.conv4)\n        #compute the flatten size\n        self.num_flatten=h*w*8*init_f\n        self.fc1= nn.Linear(self.num_flatten, num_fc1)\n        self.fc2= nn.Linear(num_fc1,num_classes)\n        \n    def forward(self,x):\n        x= F.relu(self.conv1(x))\n        x= F.max_pool2d(x,2,2)\n        x= F.relu(self.conv2(x))\n        x= F.max_pool2d(x,2,2)\n        x= F.relu(self.conv3(x))\n        x= F.max_pool2d(x,2,2)\n        x= F.relu(self.conv4(x))\n        x= F.max_pool2d(x,2,2)\n        x= x.view(-1,self.num_flatten)\n        x= F.relu(self.fc1(x))\n        x=F.dropout(x,self.dropout_rate, training= self.training)\n        x= self.fc2(x)\n        return F.log_softmax(x,dim=1)\n        ","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:29.411379Z","iopub.execute_input":"2023-07-25T09:03:29.411773Z","iopub.status.idle":"2023-07-25T09:03:29.425722Z","shell.execute_reply.started":"2023-07-25T09:03:29.411676Z","shell.execute_reply":"2023-07-25T09:03:29.424822Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#dict to define model parameters\nparams_model= {\"input_shape\": (1,512,512),\"initial_filters\":8,\n              \"num_fc1\":100,\"dropout_rate\":0.25, \"num_classes\":2}","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:38:59.612173Z","iopub.execute_input":"2023-07-25T09:38:59.612542Z","iopub.status.idle":"2023-07-25T09:38:59.617242Z","shell.execute_reply.started":"2023-07-25T09:38:59.61251Z","shell.execute_reply":"2023-07-25T09:38:59.616347Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#create model\ncnn_model = Net(params_model)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:29.444584Z","iopub.execute_input":"2023-07-25T09:03:29.444927Z","iopub.status.idle":"2023-07-25T09:03:29.490078Z","shell.execute_reply.started":"2023-07-25T09:03:29.444897Z","shell.execute_reply":"2023-07-25T09:03:29.489249Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#move model to cuda/gpu device\nif torch.cuda.is_available():\n    device= torch.device(\"cuda\")\n    cnn_model = cnn_model.to(device)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:29.491459Z","iopub.execute_input":"2023-07-25T09:03:29.491782Z","iopub.status.idle":"2023-07-25T09:03:33.964093Z","shell.execute_reply.started":"2023-07-25T09:03:29.491752Z","shell.execute_reply":"2023-07-25T09:03:33.963141Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#print the model\nprint(cnn_model)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:33.965426Z","iopub.execute_input":"2023-07-25T09:03:33.965903Z","iopub.status.idle":"2023-07-25T09:03:33.971524Z","shell.execute_reply.started":"2023-07-25T09:03:33.965866Z","shell.execute_reply":"2023-07-25T09:03:33.970501Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(next(cnn_model.parameters()).device)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:33.973409Z","iopub.execute_input":"2023-07-25T09:03:33.973746Z","iopub.status.idle":"2023-07-25T09:03:33.985052Z","shell.execute_reply.started":"2023-07-25T09:03:33.973713Z","shell.execute_reply":"2023-07-25T09:03:33.984179Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"!pip install torchsummary","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:33.986343Z","iopub.execute_input":"2023-07-25T09:03:33.987198Z","iopub.status.idle":"2023-07-25T09:03:48.045265Z","shell.execute_reply.started":"2023-07-25T09:03:33.987165Z","shell.execute_reply":"2023-07-25T09:03:48.04416Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from torchsummary import summary\nsummary(cnn_model,input_size=(1,512,512),device= device.type)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:48.047139Z","iopub.execute_input":"2023-07-25T09:03:48.047498Z","iopub.status.idle":"2023-07-25T09:03:57.054211Z","shell.execute_reply.started":"2023-07-25T09:03:48.047468Z","shell.execute_reply":"2023-07-25T09:03:57.052816Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Some key points\nBy providing the number of output channels of the previous layer as the number of input channels to the next layer, we can define each layer. However, this becomes tricky when it comes to nn.Linear layers.The linear layer accepts a 2D tensor. That is why we need the view method in the forward function to reshape the 4D tensor into a 2D tensor.\n##### flatten/reshape\nx = x.view(-1, self.num_flatten\nwe get self.num_flatten=h*w*8*init_f\n \nDropout layer before the output layer to reduce the overfitting problem in deep learning models. Notice that we set the training = self.training argument in\nthe F.dropout function. The self.training parameter is automatically set to True during training and False at evaluation. This will bypass the dropout layer at the\ndeployment time.","metadata":{}},{"cell_type":"markdown","source":"### Defining the loss function\nThe loss function depends on the output activation that we are using, and the number of final outputs. For binary classification, we can either choose 1 or 2 outputs, for which log_softmax activation is suitable, since it expands well for the multi-class classification.\n**Log Softmax Activation Function**- PyTorch combines the log and softmax operations into one function due to numerical stability and speed. The \"softmax\" part of the function ensures that all the values in the resulting distribution are positive and sum up to 1, resembling a valid probability distribution.\n![image.png](attachment:58594ab6-386d-4a35-87cd-b73c43f25260.png)\n*Parameters:*\ndim (int) – A dimension along which LogSoftmax will be computed.\n*Returns:*\na Tensor of the same dimension and shape as the input with values in the range [-inf, 0)\n\n**Negative log likelihood loss** tells us how well the model's predicted probabilities match the true labels. It penalizes the model more if it makes confident and incorrect predictions, while rewarding it for making confident and correct predictions.\n","metadata":{},"attachments":{"58594ab6-386d-4a35-87cd-b73c43f25260.png":{"image/png":"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"}}},{"cell_type":"code","source":"# define the loss function\nloss_funct = nn.NLLLoss(reduction= \"sum\")\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:57.058021Z","iopub.execute_input":"2023-07-25T09:03:57.058305Z","iopub.status.idle":"2023-07-25T09:03:57.066654Z","shell.execute_reply.started":"2023-07-25T09:03:57.05828Z","shell.execute_reply":"2023-07-25T09:03:57.06513Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# fix random seed\ntorch.manual_seed(0)\nn,c=8,2\ny = torch.randn(n, c, requires_grad=True)\nls_F = nn.LogSoftmax(dim=1)\ny_out=ls_F(y)\nprint(y_out.shape)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:57.0713Z","iopub.execute_input":"2023-07-25T09:03:57.073026Z","iopub.status.idle":"2023-07-25T09:03:57.092511Z","shell.execute_reply.started":"2023-07-25T09:03:57.072991Z","shell.execute_reply":"2023-07-25T09:03:57.09142Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"target = torch.randint(c,size=(n,))\nprint(target.shape)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:57.096862Z","iopub.execute_input":"2023-07-25T09:03:57.097621Z","iopub.status.idle":"2023-07-25T09:03:57.10554Z","shell.execute_reply.started":"2023-07-25T09:03:57.097578Z","shell.execute_reply":"2023-07-25T09:03:57.104582Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"loss = loss_funct(y_out, target)\nprint(loss.item())","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:57.107168Z","iopub.execute_input":"2023-07-25T09:03:57.107985Z","iopub.status.idle":"2023-07-25T09:03:57.125706Z","shell.execute_reply.started":"2023-07-25T09:03:57.107952Z","shell.execute_reply":"2023-07-25T09:03:57.12463Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#we will compute the gradients of the loss with respect to y\nloss.backward()\nprint (y.data)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:57.126568Z","iopub.execute_input":"2023-07-25T09:03:57.126887Z","iopub.status.idle":"2023-07-25T09:03:57.14501Z","shell.execute_reply.started":"2023-07-25T09:03:57.126858Z","shell.execute_reply":"2023-07-25T09:03:57.144218Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Defining the optimizer","metadata":{}},{"cell_type":"code","source":"from torch import optim \nopt= optim.Adam(cnn_model.parameters(),lr=3e-4)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:57.146355Z","iopub.execute_input":"2023-07-25T09:03:57.146653Z","iopub.status.idle":"2023-07-25T09:03:57.151633Z","shell.execute_reply.started":"2023-07-25T09:03:57.146625Z","shell.execute_reply":"2023-07-25T09:03:57.15056Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#get learning rate\ndef get_lr(opt):\n    for param_group in opt.param_groups:\n        return param_group['lr']\ncurrent_lr = get_lr(opt)\nprint('current lr={}'.format(current_lr))\n","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:57.153368Z","iopub.execute_input":"2023-07-25T09:03:57.154099Z","iopub.status.idle":"2023-07-25T09:03:57.161651Z","shell.execute_reply.started":"2023-07-25T09:03:57.154068Z","shell.execute_reply":"2023-07-25T09:03:57.160653Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#define a learning scheduler using the ReduceLROnPlateau\n\nfrom torch.optim.lr_scheduler import ReduceLROnPlateau\n\nlr_scheduler = ReduceLROnPlateau(opt,mode=\"min\",factor=0.5,patience=20,verbose=1)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:57.163509Z","iopub.execute_input":"2023-07-25T09:03:57.164305Z","iopub.status.idle":"2023-07-25T09:03:57.170609Z","shell.execute_reply.started":"2023-07-25T09:03:57.164273Z","shell.execute_reply":"2023-07-25T09:03:57.169594Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"for i in range(100):\n    lr_scheduler.step(1)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:57.172254Z","iopub.execute_input":"2023-07-25T09:03:57.172929Z","iopub.status.idle":"2023-07-25T09:03:57.181134Z","shell.execute_reply.started":"2023-07-25T09:03:57.172897Z","shell.execute_reply":"2023-07-25T09:03:57.180283Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Training and Evaluation of the model","metadata":{}},{"cell_type":"code","source":"#a helper function to count the number of correct predictions/ data batch\ndef metrics_batch(output, target):\n # get output class\n pred = output.argmax(dim=1, keepdim=True)\n # compare output class with target class\n corrects=pred.eq(target.view_as(pred)).sum().item()\n return corrects\n    ","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:57.182703Z","iopub.execute_input":"2023-07-25T09:03:57.183527Z","iopub.status.idle":"2023-07-25T09:03:57.194354Z","shell.execute_reply.started":"2023-07-25T09:03:57.183493Z","shell.execute_reply":"2023-07-25T09:03:57.193306Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#helper function to compute the loss value per batch of data\ndef loss_batch(loss_func,output,target,opt=None):\n    \n    loss= loss_func(output,target)\n    \n    with torch.no_grad():\n        metric_b = metrics_batch(output,target)\n    if opt is not None:\n        opt.zero_grad()\n        loss.backward()\n        opt.step()\n    return loss.item(), metric_b","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:57.196238Z","iopub.execute_input":"2023-07-25T09:03:57.196946Z","iopub.status.idle":"2023-07-25T09:03:57.21126Z","shell.execute_reply.started":"2023-07-25T09:03:57.196913Z","shell.execute_reply":"2023-07-25T09:03:57.210222Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# helper function to compute the loss value and the performance metric for the epoch\n#Define the loss_epoch function:\n\ndef loss_epoch(model,loss_funct,dataset_dl,sanity_check=False,opt=None):\n    running_loss= 0.0\n    running_metric=0.0\n    len_data=len(dataset_dl.dataset)\n    \n    for xb,yb in dataset_dl:\n        #move batch to device\n        xb= xb.to(device)\n        yb= yb.to(device)\n        \n        #get model output\n        output = model(xb)\n        \n        #get loss per batch\n        loss_b, metric_b = loss_batch(loss_func,output,yb,opt)\n        \n        #update running loss\n        running_loss+= loss_b\n        \n        #update running metric\n        if metric_b is not None:\n            running_metric+= metric_b\n            \n        #break the loop in case of sanity check\n        if sanity_check is True:\n            break\n    \n    #average loss value\n    loss = running_loss/float(len_data)\n    \n    #average metric value\n    metric= running_metric/float(len_data)\n    \n    return loss, metric\n        ","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:57.212205Z","iopub.execute_input":"2023-07-25T09:03:57.212689Z","iopub.status.idle":"2023-07-25T09:03:57.229038Z","shell.execute_reply.started":"2023-07-25T09:03:57.212657Z","shell.execute_reply":"2023-07-25T09:03:57.227966Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def train_val(model,params):\n    #extract model parameters\n    num_epochs = params[\"num_epochs\"]\n    loss_func = params[\"loss_func\"]\n    opt= params[\"optimizer\"]\n    train_dl= params[\"train_dl\"]\n    val_dl= params[\"val_dl\"]\n    sanity_check = params[\"sanity_check\"]\n    lr_scheduler= params[\"lr_scheduler\"]\n    path2weights= params[\"path2weights\"]\n    \n    os.makedirs(os.path.dirname(path2weights), exist_ok=True)  # Create the parent directory\n    \n    # history of loss values in each epoch\n    loss_history= { \n        \"train\":[], \n        \"val\": [],\n    }\n    #history of metric values in each epoch\n    metric_history = {\n        \"train\": [],\n        \"val\": [],\n    }\n    # a deep copy of weights for the best performing model\n    best_model_wts = copy.deepcopy(model.state_dict())\n    \n    #initialize best loss to a large value\n    best_loss= float(\"inf\")\n    \n    #training loss over an epoch\n    for epoch in range(num_epochs):\n        \n        #get current learning rate\n        current_lr= get_lr(opt)\n        print('Epoch {}/{}, current lr = {}'.format(epoch,num_epochs-1,current_lr))\n        \n        #train model on training dataset\n        model.train()\n        train_loss,train_metric= loss_epoch(model, loss_func,train_dl,sanity_check,opt)\n        \n        #collect loss and metric for training dataset\n        loss_history[\"train\"].append(train_loss)\n        metric_history[\"train\"].append(train_metric)\n        \n        # evaluate model on validation dataset\n        model.eval()\n        with torch.no_grad():\n            val_loss,val_metric = loss_epoch(model,loss_func,val_dl,sanity_check)\n            \n            \n        #store best model\n        if val_loss < best_loss:\n            best_loss= val_loss\n            best_model_wts = copy.deepcopy(model.state_dict())\n                \n            #store weights into a local file\n            torch.save(model.state_dict(),path2weights)\n            print(\"copied best model weights!\")\n         \n        #collect loss and metric for validation dataset\n        loss_history[\"val\"].append(val_loss)\n        metric_history[\"val\"].append(val_metric)\n       \n        #learning rate schedule\n        lr_scheduler.step(val_loss)\n        if current_lr != get_lr(opt):\n            print(\"Loading best model weights!\")\n            model.load_state_dict(best_model_wts)\n        \n        print(\"train loss: %.6f, dev loss: %.6f,accuracy: %.2f\"\n                %(train_loss,val_loss,100*val_metric))\n        print(\"-\"*10)\n            \n    #load best model weights\n    model.load_state_dict(best_model_wts)\n    torch.save(model.state_dict(), path2weights)\n    print(\"Saved final model weights!\")\n   \n    return model, loss_history,metric_history\n        ","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:57.23075Z","iopub.execute_input":"2023-07-25T09:03:57.2314Z","iopub.status.idle":"2023-07-25T09:03:57.261857Z","shell.execute_reply.started":"2023-07-25T09:03:57.231366Z","shell.execute_reply":"2023-07-25T09:03:57.260863Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import copy \n\nloss_func = nn.NLLLoss(reduction=\"sum\")\nopt= optim.Adam(cnn_model.parameters(), lr= 3e-4)\nlr_scheduler = ReduceLROnPlateau(opt, mode= \"min\",factor=0.5,patience= 20,verbose=1)\nparams_train={\n \"num_epochs\": 100,\n \"optimizer\": opt,\n \"loss_func\": loss_func,\n \"train_dl\": train_dl,\n \"val_dl\": val_dl,\n \"sanity_check\": True,\n \"lr_scheduler\": lr_scheduler,\n \"path2weights\": \"/kaggle/working/models/weights/pt\",\n}\n\n# train and validate the model\ncnn_model,loss_hist,metric_hist=train_val(cnn_model,params_train)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:03:57.266612Z","iopub.execute_input":"2023-07-25T09:03:57.26907Z","iopub.status.idle":"2023-07-25T09:05:11.707929Z","shell.execute_reply.started":"2023-07-25T09:03:57.269037Z","shell.execute_reply":"2023-07-25T09:05:11.706687Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Train-Validation Progress\nnum_epochs=params_train[\"num_epochs\"]\n\n# plot loss progress\nplt.title(\" Dense_Net Train-Val Loss\")\nplt.plot(range(1,num_epochs+1),loss_hist[\"train\"],label=\"train\")\nplt.plot(range(1,num_epochs+1),loss_hist[\"val\"],label=\"val\")\nplt.ylabel(\"Loss\")\nplt.xlabel(\"Training Epochs\")\nplt.legend()\nplt.show()\n\n# plot accuracy progress\nplt.title(\"Dense_Net Train-Val Accuracy\")\nplt.plot(range(1,num_epochs+1),metric_hist[\"train\"],label=\"train\")\nplt.plot(range(1,num_epochs+1),metric_hist[\"val\"],label=\"val\")\nplt.ylabel(\"Accuracy\")\nplt.xlabel(\"Training Epochs\")\nplt.legend()\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:05:32.032857Z","iopub.execute_input":"2023-07-25T09:05:32.033214Z","iopub.status.idle":"2023-07-25T09:05:32.639958Z","shell.execute_reply.started":"2023-07-25T09:05:32.033185Z","shell.execute_reply":"2023-07-25T09:05:32.639014Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## DenseNet121 Model","metadata":{}},{"cell_type":"code","source":"import torchvision.models as models\ndensenet121_model = models.densenet121(pretrained=True)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:05:12.540925Z","iopub.execute_input":"2023-07-25T09:05:12.543178Z","iopub.status.idle":"2023-07-25T09:05:13.321232Z","shell.execute_reply.started":"2023-07-25T09:05:12.543136Z","shell.execute_reply":"2023-07-25T09:05:13.320287Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Train and validate the model\ndensenet121_model, loss_hist, metric_hist = train_val(densenet121_model, params_train)","metadata":{"execution":{"iopub.status.busy":"2023-07-25T09:38:13.50234Z","iopub.execute_input":"2023-07-25T09:38:13.502863Z","iopub.status.idle":"2023-07-25T09:38:14.170485Z","shell.execute_reply.started":"2023-07-25T09:38:13.50278Z","shell.execute_reply":"2023-07-25T09:38:14.168728Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}