{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":11848,"databundleVersionId":862157,"sourceType":"competition"}],"dockerImageVersionId":30626,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Problem description\nIn this project we are trying to identify metastatic cancer in digital pathology scans using Convolutional Neural Networks (CNN) to classify the images as having cancer or not.\n\nThe dataset has 220,025 square images 96px in size for training. There are 57,458 test images of the same size.  ","metadata":{}},{"cell_type":"code","source":"# Import packages\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport os\nimport seaborn as sns\nfrom PIL import Image\nfrom tensorflow.keras.models import Sequential\nfrom tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout, BatchNormalization, LeakyReLU\nfrom tensorflow.keras.metrics import Recall\nfrom tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau\nfrom tensorflow.keras.preprocessing.image import ImageDataGenerator\nfrom keras.regularizers import l2\nimport tensorflow as tf\n\n# Set train and test directories, and set \ntrain_dir = '/kaggle/input/histopathologic-cancer-detection/train'\ntest_dir = '/kaggle/input/histopathologic-cancer-detection/test'\nsample_submission = pd.read_csv('/kaggle/input/histopathologic-cancer-detection/sample_submission.csv')\ntrain_labels = pd.read_csv('/kaggle/input/histopathologic-cancer-detection/train_labels.csv')","metadata":{"execution":{"iopub.status.busy":"2024-06-11T14:19:51.356305Z","iopub.execute_input":"2024-06-11T14:19:51.356784Z","iopub.status.idle":"2024-06-11T14:20:06.264622Z","shell.execute_reply.started":"2024-06-11T14:19:51.356752Z","shell.execute_reply":"2024-06-11T14:20:06.263487Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(train_labels.info())\n\nprint(train_labels.head())\n\nprint(sample_submission.info())","metadata":{"execution":{"iopub.status.busy":"2024-06-11T14:20:06.266809Z","iopub.execute_input":"2024-06-11T14:20:06.267171Z","iopub.status.idle":"2024-06-11T14:20:06.330066Z","shell.execute_reply.started":"2024-06-11T14:20:06.267140Z","shell.execute_reply":"2024-06-11T14:20:06.328923Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"There are 220,025 samples for the training data. The labels match up to a file in the train directory. The testing data has 57,478 samples. Those labels are found in the testing directory.","metadata":{}},{"cell_type":"markdown","source":"# Exploratory Data Analysis","metadata":{}},{"cell_type":"code","source":"# Visualize some of the images\ndef show_images(ids, labels, path, title):\n    plt.figure(figsize=(15, 5))\n    for i, (img_id, label) in enumerate(zip(ids, labels)):\n        img_path = os.path.join(path, img_id + '.tif')\n        img = Image.open(img_path)\n        plt.subplot(1, len(ids), i+1)\n        plt.imshow(img)\n        plt.title(f\"Label: {label}\")\n        plt.axis('off')\n    plt.suptitle(title)\n    plt.show()\n\n# Showing 5 examples of images without cancer\nshow_images(train_labels[train_labels['label'] == 0]['id'][:5], [0]*5, train_dir, \"Examples Without Cancer\")\n\n# Showing 5 examples of images with cancer\nshow_images(train_labels[train_labels['label'] == 1]['id'][:5], [1]*5, train_dir, \"Examples With Cancer\")","metadata":{"execution":{"iopub.status.busy":"2024-06-11T14:20:06.331749Z","iopub.execute_input":"2024-06-11T14:20:06.332163Z","iopub.status.idle":"2024-06-11T14:20:07.639606Z","shell.execute_reply.started":"2024-06-11T14:20:06.332123Z","shell.execute_reply":"2024-06-11T14:20:07.638494Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Print the length of the train and test dirs\nnum_train_images = len(os.listdir(train_dir))\nnum_test_images = len(os.listdir(test_dir))\ntotal_len_of_dataset = num_train_images + num_test_images\nprint(f\"Number of training images: \" + str(round(num_train_images / total_len_of_dataset, 2)))\nprint(f\"Number of test images: \" + str(round(num_test_images / total_len_of_dataset, 2)))","metadata":{"execution":{"iopub.status.busy":"2024-06-11T14:20:07.641004Z","iopub.execute_input":"2024-06-11T14:20:07.641335Z","iopub.status.idle":"2024-06-11T14:20:13.578486Z","shell.execute_reply.started":"2024-06-11T14:20:07.641305Z","shell.execute_reply":"2024-06-11T14:20:13.577296Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Print the size of the images and the color channels\nsample_image_path = os.path.join(train_dir, os.listdir(train_dir)[0])\nsample_image = Image.open(sample_image_path)\nprint(f\"Sample image dimensions: {sample_image.size}\")\nprint(f\"Number of channels in the sample image: {sample_image.mode}\\n\\n\")\n\n# Print the number of positive and negative samples in the training set\nplt.figure(figsize=(6, 4))\nsns.countplot(x='label', data=train_labels)\nplt.title('Distribution of Labels in Training Set')\nplt.xlabel('Label')\nplt.ylabel('Count')\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-06-11T14:20:13.581236Z","iopub.execute_input":"2024-06-11T14:20:13.581597Z","iopub.status.idle":"2024-06-11T14:20:14.005458Z","shell.execute_reply.started":"2024-06-11T14:20:13.581566Z","shell.execute_reply":"2024-06-11T14:20:14.004476Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"This analysis shows that the dataset has an 80/20 split for the testing and training data. The images are 96x96 pixels in size and have RGB channels. Images need to be downscaled to allow for quicker training, and the channels will be normalized from 0-255 to 0-1.\n\nThe dataset is decently balanced with a bias towards non-cancerous samples, but the metric for analyzing the performance should not be accuracy due to the imbalance. Recall will be crucial as measuring false negatives is the most important metric.\n\nThe training data will need to be formatted properly as it currently has image id's.","metadata":{}},{"cell_type":"markdown","source":"The images must be preprocessed to allow for timely training in Kaggle and for the models to be able to train on them.\n\nThe following is done to get the images ready for training:\n* Normalize color values from 0-255 to 0-1\n* Downscale images from 96x96 to 60x60\n* Append .tif to the id column so they match the file name in the Kaggle directory\n* Modify 'label' column from int64 to string to work with the flow_from_dataframe function\n* Will use 25% of the training data for validation to measure overfitting","metadata":{}},{"cell_type":"code","source":"# Image preprocessing\ntarget_size = (60, 60) # Downscaling\nbatch_size = 256\n\ntrain_datagen = ImageDataGenerator(rescale=1./255, # Normalize from 0-255 to 0-1\n                                   validation_split=.25\n                                  )\n\n# The label must be converted from int64 to string to work with the flow_from_dataframe function\ntrain_labels['label'] = train_labels['label'].astype(str)\n\n# The file id's must have the .tif extension added to work with the flow_from_dataframe function\ntrain_labels['id'] = train_labels['id'].apply(lambda x: x + '.tif')\n\ntrain_data_generator = train_datagen.flow_from_dataframe(dataframe=train_labels,\n                                                    directory=train_dir,\n                                                    x_col='id',\n                                                    y_col='label',\n                                                    target_size=target_size,\n                                                    batch_size=batch_size,\n                                                    class_mode='binary',\n                                                    workers=4,\n                                                    use_multiprocessing=True,\n                                                    subset='training',\n                                                    shuffle=True)\n\nvalidation_data_generator = train_datagen.flow_from_dataframe(dataframe=train_labels,\n                                                    directory=train_dir,\n                                                    x_col='id',\n                                                    y_col='label',\n                                                    target_size=target_size,\n                                                    batch_size=batch_size,\n                                                    class_mode='binary',\n                                                    workers=4,\n                                                    use_multiprocessing=True,\n                                                    subset='validation',\n                                                    shuffle=True)","metadata":{"execution":{"iopub.status.busy":"2024-06-11T14:20:14.007156Z","iopub.execute_input":"2024-06-11T14:20:14.007517Z","iopub.status.idle":"2024-06-11T14:28:45.332564Z","shell.execute_reply.started":"2024-06-11T14:20:14.007487Z","shell.execute_reply":"2024-06-11T14:28:45.331408Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Model Architecture","metadata":{}},{"cell_type":"markdown","source":"Two models will be tested and compared. \n\nThe first model will have the architecture of:\n* 2 16 filter layers\n* 2x2 pooling\n* 2 32 filter layers\n* 2x2 pooling\n* 2 64 filter layers\n* 2x2 pooling\n* Flattening layer\n* Dense layer with 512 units\n* Dropout of .5 to help with overfitting\n* Dense layer with sigmoid activation\n\nThe second model will have the architecture of:\n* 2 32 filter layer with l2 regularization\n* BatchNormalization\n* 2x2 pooling\n* Dropout of .3 to help with overfitting\n* 2 64 filter layer with l2 regularization\n* BatchNormalization\n* 2x2 pooling\n* Dropout of .3 to help with overfitting\n* 2 128 filter layer with l2 regularization\n* BatchNormalization\n* 2x2 pooling\n* Dropout of .3 to help with overfitting\n* Flattening layer\n* Dense layer with 256 units with l2 regularization\n* Dropout of .5 to help with overfitting\n* Dense layer with sigmoid activation with l2 regularization\n\nThe first model has more convolution layers that are smaller with less regularization/normalization overall. The second model has larger convolution layers and there is a lot more regularization/normalization with batch normalization and dropout layers to help prevent overfitting.\n\nBoth models have early stopping enabled if the model doesn't improve. The second model also implements learning rate reduction when the validation loss plateaus.","metadata":{}},{"cell_type":"markdown","source":"# Results and Analysis","metadata":{}},{"cell_type":"code","source":"# First model architecture\nmodel = Sequential([\n    # Convolutional layer with 16 filters, kernel size of 3x3, activation function ReLU\n    Conv2D(16, (3, 3), activation='relu', input_shape=(target_size[0], target_size[1], 3)),\n    MaxPooling2D(2, 2),\n    # Second convolutional layer with 32 filters\n    Conv2D(32, (3, 3), activation='relu'),\n    MaxPooling2D(2, 2),\n    # Third convolutional layer with 64 filters\n    Conv2D(64, (3, 3), activation='relu'),\n    MaxPooling2D(2, 2),\n    Flatten(),\n    # Dense layer with dropout for regularization\n    Dense(256, activation='relu'),\n    Dropout(0.15),\n    # Output layer with a single neuron and sigmoid activation function for binary classification\n    Dense(1, activation='sigmoid')\n])\n\nmodel.compile(optimizer='adam',\n              loss='binary_crossentropy',\n              metrics=['accuracy', Recall(name='recall')])\n\nmodel.summary()\n\nsteps_per_epoch = train_data_generator.samples // train_data_generator.batch_size\nvalidation_steps = validation_data_generator.samples // validation_data_generator.batch_size\n\nearly_stopping = EarlyStopping(monitor='val_loss', patience=3, restore_best_weights=True)\n\n# Training the model\nhistory = model.fit(train_data_generator,\n                    steps_per_epoch=steps_per_epoch,\n                    epochs=10,\n                    validation_data=validation_data_generator,\n                    validation_steps=validation_steps,\n                    callbacks=[early_stopping])","metadata":{"execution":{"iopub.status.busy":"2024-06-11T19:42:13.991885Z","iopub.execute_input":"2024-06-11T19:42:13.992749Z","iopub.status.idle":"2024-06-11T20:53:00.180009Z","shell.execute_reply.started":"2024-06-11T19:42:13.992710Z","shell.execute_reply":"2024-06-11T20:53:00.177710Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def plot_metric(history, metric_name):\n    plt.plot(history.history[metric_name])\n    plt.plot(history.history['val_' + metric_name])\n    plt.title('Model ' + metric_name)\n    plt.xlabel('Epoch')\n    plt.ylabel(metric_name)\n    plt.legend(['Train', 'Validation'], loc='upper left')\n    plt.show()\n\nplt.figure(figsize=(12, 4))\n\nplot_metric(history, 'accuracy')\nplot_metric(history, 'loss')\nplot_metric(history, 'recall')","metadata":{"execution":{"iopub.status.busy":"2024-06-11T20:53:00.184177Z","iopub.execute_input":"2024-06-11T20:53:00.184615Z","iopub.status.idle":"2024-06-11T20:53:00.902103Z","shell.execute_reply.started":"2024-06-11T20:53:00.184566Z","shell.execute_reply":"2024-06-11T20:53:00.900942Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=3, min_lr=0.0001)\n\n# Second model architecture\nsecond_model = Sequential([\n    Conv2D(32, (3, 3), activation='relu', input_shape=(target_size[0], target_size[1], 3), kernel_regularizer=l2(.0015)),\n    Conv2D(32, (3, 3), activation='relu', kernel_regularizer=l2(.0015)),\n    BatchNormalization(),\n    MaxPooling2D(2, 2),\n    Conv2D(64, (3, 3), activation='relu', kernel_regularizer=l2(.0015)),\n    Conv2D(64, (3, 3), activation='relu', kernel_regularizer=l2(.0015)),\n    BatchNormalization(),\n    MaxPooling2D(2, 2),\n    Conv2D(128, (3, 3), activation='relu', kernel_regularizer=l2(.0015)),\n    Conv2D(128, (3, 3), activation='relu', kernel_regularizer=l2(.0015)),\n    BatchNormalization(),\n    MaxPooling2D(2, 2),\n    Flatten(),\n    Dense(256, activation='relu', kernel_regularizer=l2(.0015)),\n    Dropout(0.4),\n    Dense(1, activation='sigmoid')\n])\n\nsecond_model.compile(optimizer='adam',\n              loss='binary_crossentropy',\n              metrics=['accuracy', Recall(name='recall')])\n\nsecond_model.summary()\n\nsteps_per_epoch = train_data_generator.samples // train_data_generator.batch_size\nvalidation_steps = validation_data_generator.samples // validation_data_generator.batch_size\n\n# Training the model\nhistory = second_model.fit(train_data_generator,\n                    steps_per_epoch=steps_per_epoch,\n                    epochs=10,\n                    validation_data=validation_data_generator,\n                    validation_steps=validation_steps,\n                    callbacks=[early_stopping, reduce_lr])","metadata":{"execution":{"iopub.status.busy":"2024-06-11T16:39:09.191382Z","iopub.execute_input":"2024-06-11T16:39:09.191820Z","iopub.status.idle":"2024-06-11T19:24:57.795568Z","shell.execute_reply.started":"2024-06-11T16:39:09.191782Z","shell.execute_reply":"2024-06-11T19:24:57.792586Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(figsize=(12, 4))\n\nplot_metric(history, 'accuracy')\nplot_metric(history, 'loss')\nplot_metric(history, 'recall')","metadata":{"execution":{"iopub.status.busy":"2024-06-11T19:24:57.799381Z","iopub.execute_input":"2024-06-11T19:24:57.799961Z","iopub.status.idle":"2024-06-11T19:24:58.549574Z","shell.execute_reply.started":"2024-06-11T19:24:57.799897Z","shell.execute_reply":"2024-06-11T19:24:58.548510Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# First model architecture\nthird_model = Sequential([\n    # Convolutional layer with 16 filters, kernel size of 3x3, activation function ReLU\n    Conv2D(16, (3, 3), activation='relu', input_shape=(target_size[0], target_size[1], 3)),\n    Conv2D(16, (3, 3), activation='relu'),\n    MaxPooling2D(2, 2),\n    # Second convolutional layer with 32 filters\n    Conv2D(32, (3, 3), activation='relu'),\n    Conv2D(32, (3, 3), activation='relu'),\n    MaxPooling2D(2, 2),\n    # Third convolutional layer with 64 filters\n    Conv2D(64, (3, 3), activation='relu'),\n    Conv2D(64, (3, 3), activation='relu'),\n    MaxPooling2D(2, 2),\n    Flatten(),\n    # Dense layer with dropout for regularization\n    Dense(256, activation='relu'),\n    Dropout(0.25),\n    # Output layer with a single neuron and sigmoid activation function for binary classification\n    Dense(1, activation='sigmoid')\n])\n\nthird_model.compile(optimizer='adam',\n              loss='binary_crossentropy',\n              metrics=['accuracy', Recall(name='recall')])\n\nthird_model.summary()\n\nsteps_per_epoch = train_data_generator.samples // train_data_generator.batch_size\nvalidation_steps = validation_data_generator.samples // validation_data_generator.batch_size\n\nearly_stopping = EarlyStopping(monitor='val_loss', patience=3, restore_best_weights=True)\n\n# Training the model\nhistory = third_model.fit(train_data_generator,\n                    steps_per_epoch=steps_per_epoch,\n                    epochs=10,\n                    validation_data=validation_data_generator,\n                    validation_steps=validation_steps,\n                    callbacks=[early_stopping])","metadata":{"execution":{"iopub.status.busy":"2024-06-11T14:28:45.334121Z","iopub.execute_input":"2024-06-11T14:28:45.334511Z","iopub.status.idle":"2024-06-11T16:39:08.317686Z","shell.execute_reply.started":"2024-06-11T14:28:45.334479Z","shell.execute_reply":"2024-06-11T16:39:08.313739Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(figsize=(12, 4))\n\nplot_metric(history, 'accuracy')\nplot_metric(history, 'loss')\nplot_metric(history, 'recall')","metadata":{"execution":{"iopub.status.busy":"2024-06-11T16:39:08.324811Z","iopub.execute_input":"2024-06-11T16:39:08.325298Z","iopub.status.idle":"2024-06-11T16:39:09.189657Z","shell.execute_reply.started":"2024-06-11T16:39:08.325239Z","shell.execute_reply":"2024-06-11T16:39:09.188488Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Model Results\n\n### Model 1 Results\nModel 1 finished training with the following metrics:\nloss: 0.2612 - accuracy: 0.8938 - recall: 0.8500 - val_loss: 0.2797 - val_accuracy: 0.8860 - val_recall: 0.8549\n\nThe training data resulted in a loss of 26.12%, an accuracy of 89.38%, and recall of 85%. The validation data (25% of the dataset) has a loss of 27.97%, an accuracy of 88.6%, and a recall of 85.49%. These are quite good results and the metrics are close for both the training and validation data, suggesting that the model didn't start to overfit. An accuracy of 88-89% is quite good for what is supposed to be the more basic model.\n\n### Model 2 Results\nModel 2 finished training with the following metrics:\nloss: 0.2166 - accuracy: 0.9205 - recall: 0.8922 - val_loss: 0.3104 - val_accuracy: 0.8817 - val_recall: 0.8081\n\nThe training data resulted in a loss of 21.66%, an accuracy of 92.05%, and recall of 89.22%. The validation data (25% of the dataset) has a loss of 31.04%, an accuracy of 88.17%, and a recall of 80.81%. Surprisingly even though there are a lot of measures to normalize and regularize the validation data performs worse than it did in the first model. However, the model did better learning the training data. What I suspect is that as the model improves above the 90% accuracy it will reach a plateau of results on the validation dataset. In other words, improvements of the model will require a tradeoff in overfitting.","metadata":{}},{"cell_type":"code","source":"test_datagen = ImageDataGenerator(rescale=1./255, # Normalize from 0-255 to 0-1\n                                  )\n\ntest_files = os.listdir(test_dir)\ntest_dataframe = pd.DataFrame(test_files, columns=['id'])\ntest_data_generator = test_datagen.flow_from_dataframe(dataframe=test_dataframe,\n                                                    directory=test_dir,\n                                                    x_col='id',\n                                                    y_col=None,\n                                                    target_size=target_size,\n                                                    class_mode=None,\n                                                    workers=4,\n                                                    use_multiprocessing=True)","metadata":{"execution":{"iopub.status.busy":"2024-06-11T20:56:31.985265Z","iopub.execute_input":"2024-06-11T20:56:31.986306Z","iopub.status.idle":"2024-06-11T20:57:42.097534Z","shell.execute_reply.started":"2024-06-11T20:56:31.986266Z","shell.execute_reply":"2024-06-11T20:57:42.096489Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"predictions = third_model.predict(test_data_generator)\npredictions = np.transpose(predictions)[0]\nprint(f\"Number of predictions: {len(predictions)}\")\nprint(f\"Number of test samples: {len(test_dataframe)}\")\nbinary_predictions = (predictions >= 0.5).astype(int).flatten() # convert the sigmoid 0-1 to either 0 or 1\nprint(len(binary_predictions))\nsubmission_dataframe = pd.DataFrame()\nsubmission_dataframe['id'] = test_dataframe['id'].apply(lambda x: x.split('.')[0]) # remove .tif from the id\nsubmission_dataframe['label'] = binary_predictions\nsubmission_dataframe.to_csv('submission.csv', index=False)","metadata":{"execution":{"iopub.status.busy":"2024-06-11T20:57:42.099357Z","iopub.execute_input":"2024-06-11T20:57:42.099716Z","iopub.status.idle":"2024-06-11T21:00:38.349110Z","shell.execute_reply.started":"2024-06-11T20:57:42.099687Z","shell.execute_reply":"2024-06-11T21:00:38.347973Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Submission Score\n![image.png](attachment:e24a7644-350a-4f5b-9355-bacf3aa5c9d7.png)","metadata":{},"attachments":{"e24a7644-350a-4f5b-9355-bacf3aa5c9d7.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"markdown","source":"# Conclusion","metadata":{}},{"cell_type":"markdown","source":"","metadata":{}}]}