{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":11848,"databundleVersionId":862157,"sourceType":"competition"},{"sourceId":7675811,"sourceType":"datasetVersion","datasetId":4477523}],"dockerImageVersionId":30646,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Histopathologic Cancer Detection\n\nThis project is a part of an older Kaggle Competition that can be found [here](https://www.kaggle.com/competitions/histopathologic-cancer-detection).","metadata":{}},{"cell_type":"markdown","source":"# Step One: Objective\n\nThe objective of this project is to create a model that can reliable classify if an image either has or does not have cancerous tissue present. We are provided two directories of imagery, one to train with and another that we will use to run the final validation on for submission in this competition.","metadata":{}},{"cell_type":"markdown","source":"# Step Two: Exploratory Data Analysis & Preprocessing\n\nBefore we get to builing a model, I will use this section to explore the data we have to work with and then prepare the data to be pre-processed and loaded by the model. \n","metadata":{}},{"cell_type":"markdown","source":"## Loading Kaggle Data","metadata":{}},{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\n# If we run the given code below this stalls the run. \n# for dirname, _, filenames in os.walk('/kaggle/input'):\n#     for filename in filenames:\n#         print(os.path.join(dirname, filename))\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-02-22T19:09:09.846879Z","iopub.execute_input":"2024-02-22T19:09:09.847665Z","iopub.status.idle":"2024-02-22T19:09:10.190690Z","shell.execute_reply.started":"2024-02-22T19:09:09.847621Z","shell.execute_reply":"2024-02-22T19:09:10.189720Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_labels = pd.read_csv('/kaggle/input/histopathologic-cancer-detection/train_labels.csv')\nsample_submission = pd.read_csv('/kaggle/input/histopathologic-cancer-detection/sample_submission.csv')\nprint(\"Loaded...\")","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:09:10.239872Z","iopub.execute_input":"2024-02-22T19:09:10.240247Z","iopub.status.idle":"2024-02-22T19:09:10.671885Z","shell.execute_reply.started":"2024-02-22T19:09:10.240222Z","shell.execute_reply":"2024-02-22T19:09:10.670876Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Exploratory Data Analysis\n\nIn the cells below I explore some basics about the dataset we're provided via `train_labels.csv`. This csv contains two attributes: Id and Label. The provided id corresponds to a tiff filename in the training data directory. The label is a binary classification indicating if the image associated with the id has cancerous tissue present. The label will show 0 if no cancerous tissue is detected, and will show 1 if cancerous tissue is detected. We also see that there are over 220,000 images available to train with. ","metadata":{}},{"cell_type":"code","source":"print(f\"Entries: {train_labels.shape[0]}\\nAttributes: {list(train_labels.columns)}\")\ntrain_labels.head()","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:09:10.929069Z","iopub.execute_input":"2024-02-22T19:09:10.929410Z","iopub.status.idle":"2024-02-22T19:09:10.945186Z","shell.execute_reply.started":"2024-02-22T19:09:10.929385Z","shell.execute_reply":"2024-02-22T19:09:10.944350Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_labels.info()","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:09:11.228800Z","iopub.execute_input":"2024-02-22T19:09:11.229660Z","iopub.status.idle":"2024-02-22T19:09:11.274957Z","shell.execute_reply.started":"2024-02-22T19:09:11.229628Z","shell.execute_reply":"2024-02-22T19:09:11.274039Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"labels = train_labels['label'].unique()\nprint(labels)","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:09:11.393713Z","iopub.execute_input":"2024-02-22T19:09:11.394025Z","iopub.status.idle":"2024-02-22T19:09:11.401128Z","shell.execute_reply.started":"2024-02-22T19:09:11.394000Z","shell.execute_reply":"2024-02-22T19:09:11.400124Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Now that we know a bit about the data frame provided, let's take a look at the acutal imagery.","metadata":{}},{"cell_type":"code","source":"import matplotlib.pyplot as plt\nfrom PIL import Image\ndef get_image(tif_id: str):\n    filename = f'/kaggle/input/histopathologic-cancer-detection/train/{tif_id}.tif'\n    return Image.open(filename)\n\ndef show_image(image_data, label: int = None, ax=None): \n    if ax is None:\n        plt.imshow(image_data)\n        if label != None:\n            plt.title(f\"Classification: {label}\")\n        plt.axis('off')\n        plt.show()\n    else:\n        ax.imshow(image_data)\n        if label != None:\n            ax.set_title(f\"Classification: {label}\")\n        shape = np.array(image_data).shape\n        ax.text(0, 20, f\"Min: {np.min(image_data)} Max: {np.max(image_data)}\\nHxW:{shape[0]}x{shape[1]}\\nChannels: {shape[2]}\", fontsize=10, color='white', bbox=dict(facecolor='black', alpha=0.5))\n        ax.axis('off')\n\n\ndef show_images(data: pd.DataFrame, images_per_row:int = 5, rows: int =1) -> None:\n    n = images_per_row * rows\n    fig, axs = plt.subplots(rows, images_per_row, figsize=(images_per_row*4, rows*4))\n    if rows == 1:\n        axs = axs.reshape(1, -1)\n    for i in range(n):\n        tif_id = data['id'][i]\n        label = data['label'][i]\n        image = get_image(tif_id = tif_id)\n        \n        row = i // images_per_row\n        col = i % images_per_row\n        show_image(image, label, ax=axs[row, col])\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:09:12.049413Z","iopub.execute_input":"2024-02-22T19:09:12.049729Z","iopub.status.idle":"2024-02-22T19:09:12.061605Z","shell.execute_reply.started":"2024-02-22T19:09:12.049706Z","shell.execute_reply":"2024-02-22T19:09:12.060568Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"negative = train_labels[(train_labels['label'] == 0)].reset_index(drop=True)\nshow_images(data = negative)","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:09:12.288990Z","iopub.execute_input":"2024-02-22T19:09:12.289551Z","iopub.status.idle":"2024-02-22T19:09:12.998767Z","shell.execute_reply.started":"2024-02-22T19:09:12.289523Z","shell.execute_reply":"2024-02-22T19:09:12.997816Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"positive = train_labels[(train_labels['label'] == 1)].reset_index(drop=True)\nshow_images(data = positive)","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:09:13.000264Z","iopub.execute_input":"2024-02-22T19:09:13.000546Z","iopub.status.idle":"2024-02-22T19:09:13.632325Z","shell.execute_reply.started":"2024-02-22T19:09:13.000521Z","shell.execute_reply":"2024-02-22T19:09:13.631394Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Above we see that these images are represented by arrays of size 96x96 and have 3 RGB color channels. The values range from 0-255, which makes these images good candidates for normalization as a part of the pre-processing, which will scale it down to values between 0-1.\n\nNext, since we have over 200,000 images to work with we'll need to sample the data we're working with so that we can efficiently train the model on a subset of the data. In order to do this, we'll need to make sure our subset is representative of the original dataset, so below I've plotted the distribution of negative and positive classifications. There appears to be about a 60/40 split so we'll want to confirm the subset we work with has a similar distribution to avoid any biasing the model.","metadata":{}},{"cell_type":"code","source":"sums = [(train_labels['label'] == l).sum() for l in labels]\n\nplt.bar(labels, sums)\nplt.xlabel(\"Classification\")\nplt.ylabel('Count')\nplt.xticks(labels)\nfor i, value in enumerate(sums):\n    plt.text(i, value + 0.1, f\"{value} = {value/train_labels.shape[0]*100:.2f}%\", ha='center', va='bottom')\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:09:13.633975Z","iopub.execute_input":"2024-02-22T19:09:13.634369Z","iopub.status.idle":"2024-02-22T19:09:13.767783Z","shell.execute_reply.started":"2024-02-22T19:09:13.634338Z","shell.execute_reply":"2024-02-22T19:09:13.766872Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Data Preparation \n\nNow that we know some about the data we're working with we can prepare it to be used by the model. Since we're working with images, and not data just stored in memory, we'll need to make use of the Keras object `ImageDataGenerator`. In order to use this, and to prepare the images there are a few things we'll need to do next: \n\n1. Update `id` column to include .tif file extension so `ImageDataGenerator` can find the data in the directory\n2. Update `label` column to be a string so it can be used by the `ImageDataGenerator`\n3. Get a representative subset of the data from the training \n4. Build the `ImageDataGenerator` objects for both training and validation - should include normalization ","metadata":{}},{"cell_type":"code","source":"# Set seed for reproducible results\nimport tensorflow as tf\nimport numpy as np\nimport random\nseed = 55\n\n# Set seed for numpy\nnp.random.seed(seed)\nrandom.seed(seed)\ntf.random.set_seed(seed)\n","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:49:10.850244Z","iopub.execute_input":"2024-02-22T19:49:10.850946Z","iopub.status.idle":"2024-02-22T19:49:10.856396Z","shell.execute_reply.started":"2024-02-22T19:49:10.850904Z","shell.execute_reply":"2024-02-22T19:49:10.855415Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"img_height, img_width = 96, 96","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:09:14.149675Z","iopub.execute_input":"2024-02-22T19:09:14.150008Z","iopub.status.idle":"2024-02-22T19:09:14.154211Z","shell.execute_reply.started":"2024-02-22T19:09:14.149983Z","shell.execute_reply":"2024-02-22T19:09:14.153181Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# To use ImageDataGenerator we need to provide filename not just id\ntrain_labels['id'] = train_labels['id'] + \".tif\"\n\n# To use ImageDataGenerator binary mode we need labes to be strings:\ntrain_labels['label'] = train_labels['label'].astype(str)\n\ntrain_labels.head()","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:09:14.668685Z","iopub.execute_input":"2024-02-22T19:09:14.669246Z","iopub.status.idle":"2024-02-22T19:09:14.798103Z","shell.execute_reply.started":"2024-02-22T19:09:14.669213Z","shell.execute_reply":"2024-02-22T19:09:14.797160Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Get subset of samples to work with for training + \n# We have over 200k samples to work with - can limit the number of samples as we're building first model\nsample_size = 10000\ntrain_reduced = train_labels.iloc[:sample_size]","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:09:15.214068Z","iopub.execute_input":"2024-02-22T19:09:15.214645Z","iopub.status.idle":"2024-02-22T19:09:15.219389Z","shell.execute_reply.started":"2024-02-22T19:09:15.214609Z","shell.execute_reply":"2024-02-22T19:09:15.218451Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Confirm distribution is representative of original set (60% zeroes, 40% ones)\nsums = [(train_reduced['label'] == str(l)).sum() for l in labels]\n\nplt.bar(labels, sums)\nplt.xlabel(\"Classification\")\nplt.ylabel('Count')\nplt.xticks(labels)\nfor i, value in enumerate(sums):\n    plt.text(i, value + 0.1, f\"{value} = {value/train_reduced.shape[0]*100:.2f}%\", ha='center', va='bottom')\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:09:15.334375Z","iopub.execute_input":"2024-02-22T19:09:15.335180Z","iopub.status.idle":"2024-02-22T19:09:15.474031Z","shell.execute_reply.started":"2024-02-22T19:09:15.335126Z","shell.execute_reply":"2024-02-22T19:09:15.473099Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from tensorflow.keras.preprocessing.image import ImageDataGenerator\nimport time\nimg_height, img_width = 96, 96\n\n# Normalize pixel values 0:1 + enable us to split sampled data to train/validation sets wo work with\ntrain_datagen = ImageDataGenerator(rescale=1./255, validation_split=0.2) \n\nstart_time = time.time()\n\nprint(\"Train Generator...\")\ntrain_generator = train_datagen.flow_from_dataframe(\n    dataframe=train_reduced,\n    directory='/kaggle/input/histopathologic-cancer-detection/train/',\n    x_col='id',\n    y_col='label',\n    target_size=(img_width, img_height),\n    batch_size=64,\n    class_mode='binary',\n    subset='training', \n    color_mode=\"rgb\",\n    seed=55\n)\n\nend_time = time.time()\n\nelapsed_time = end_time - start_time\nprint(f\"Elapsed time: {elapsed_time} seconds\")","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:09:15.755122Z","iopub.execute_input":"2024-02-22T19:09:15.755927Z","iopub.status.idle":"2024-02-22T19:09:45.313922Z","shell.execute_reply.started":"2024-02-22T19:09:15.755897Z","shell.execute_reply":"2024-02-22T19:09:45.313014Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(\"Test Generator...\")\nstart_time = time.time()\n\ntest_generator = train_datagen.flow_from_dataframe(\n    dataframe=train_reduced,\n    directory='/kaggle/input/histopathologic-cancer-detection/train/',\n    x_col='id',\n    y_col='label',\n    target_size=(img_width, img_height),\n    batch_size=32,\n    class_mode='binary',\n    subset='validation', \n    color_mode=\"rgb\",\n    seed=55,\n    shuffle=False\n)\n\nend_time = time.time()\nelapsed_time = end_time - start_time\nprint(f\"Elapsed time: {elapsed_time} seconds\")\n","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:09:45.315419Z","iopub.execute_input":"2024-02-22T19:09:45.315974Z","iopub.status.idle":"2024-02-22T19:09:50.333204Z","shell.execute_reply.started":"2024-02-22T19:09:45.315948Z","shell.execute_reply":"2024-02-22T19:09:50.332338Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Step Three: Model Architecture\n\nFor setting up the model architecture, I've decided to explore the Conv-Conv-MaxPool structure, because it has been commonly used in CNNs for image classification. This basically just means we have an architecture with n iterations of 2 layers of convolution followed by max-pooling. Once I've got the base model built out I plan to adjust some parameters to see what produces better results - including changing the number of Conv-Conv-MaxPool iterations, number of dense layers, output activation function, and include things like normalization.","metadata":{}},{"cell_type":"code","source":"from tensorflow.keras.models import Sequential\nfrom tensorflow.keras.layers import Input, Conv2D, AvgPool2D, MaxPooling2D, Flatten, Dense, BatchNormalization\n\n\ndef build_model(convolution_layers: int, fully_connected_layers: int, pooling: str, output_activation:str, two_layers: bool, batch_normalization: bool):\n    # Define the model config/layers\n    model_config = [Input(shape=(img_width, img_height, 3))]\n    filter_size = (3,3)\n\n    for layer in range(convolution_layers):\n        units = (2)**(layer+5)\n        model_config.append(Conv2D(units, kernel_size=filter_size, activation = 'relu'))\n        if two_layers:\n            model_config.append(Conv2D(units, kernel_size=filter_size, activation = 'relu'))\n        if pooling == 'max':\n            model_config.append(MaxPooling2D(pool_size=2))    \n        elif pooling == 'avg':\n            model_config.append(AvgPool2D(pool_size=2, padding='same'))\n        if batch_normalization:\n            model_config.append(BatchNormalization())\n\n    model_config.append(Flatten())\n    layer_start = fully_connected_layers+4\n    for i in range(layer_start, 4, -1):\n        units = (2)**(i)\n#         print(i, units)\n        model_config.append(Dense(units, activation='relu'))\n\n    # Output Layer\n    model_config.append(Dense(1, activation=output_activation))\n    return Sequential(model_config)\n\n\ndef build_and_fit_model(\n    convolution_layers: int, \n    fully_connected_layers: int,\n    pooling: str, output_activation:str,\n    two_layers: bool, \n    batch_normalization: bool,\n    epochs: int,\n    optimizer,\n):\n    model =  build_model(\n        convolution_layers=convolution_layers, \n        fully_connected_layers=fully_connected_layers,\n        pooling = pooling, \n        output_activation=output_activation,\n        two_layers=two_layers,\n        batch_normalization = batch_normalization\n    )\n    \n    print(model.summary())\n    \n    # Compile the model\n    model.compile(\n        optimizer=optimizer,\n        loss='binary_crossentropy',\n        metrics=['accuracy']\n    )\n\n    # Train the model\n    history = model.fit(\n        train_generator,\n        steps_per_epoch=train_generator.samples // train_generator.batch_size,\n        epochs=epochs,\n        validation_data=test_generator,\n        validation_steps=test_generator.samples // test_generator.batch_size\n    )\n    loss, accuracy = model.evaluate(test_generator)\n\n    print(f\"Loss: {loss}\")\n    print(f\"Accuracy: {accuracy}\")\n    return (model, accuracy, history)\n","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:10:05.054716Z","iopub.execute_input":"2024-02-22T19:10:05.055085Z","iopub.status.idle":"2024-02-22T19:10:05.073545Z","shell.execute_reply.started":"2024-02-22T19:10:05.055061Z","shell.execute_reply":"2024-02-22T19:10:05.072596Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Handles model run + saving results\n\nresults = pd.DataFrame(columns=['convolution_layers', 'fully_connected_layers', 'pooling', 'output_activation', 'two_layers', 'batch_normalization', 'optimizer', 'accuracy'])\nmodels = []\nhistories = []\n\ndef test_model(model_args) -> None:\n    (model, accuracy, history) = build_and_fit_model(**model_args)\n    results.loc[len(results)] = {**model_args, 'accuracy': accuracy,}\n    models.append(model)\n    histories.append(history)\n    ","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:10:05.769502Z","iopub.execute_input":"2024-02-22T19:10:05.770179Z","iopub.status.idle":"2024-02-22T19:10:05.777501Z","shell.execute_reply.started":"2024-02-22T19:10:05.770145Z","shell.execute_reply":"2024-02-22T19:10:05.776524Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def plot_history(history):\n    plt.plot(history.history['accuracy'])\n    plt.plot(history.history['val_accuracy'])\n    plt.title('Model accuracy')\n    plt.ylabel('Accuracy')\n    plt.xlabel('Epoch')\n    plt.legend(['Train', 'Test'], loc='upper left')\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:12:28.389407Z","iopub.execute_input":"2024-02-22T19:12:28.390066Z","iopub.status.idle":"2024-02-22T19:12:28.395336Z","shell.execute_reply.started":"2024-02-22T19:12:28.390033Z","shell.execute_reply":"2024-02-22T19:12:28.394476Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Base Model \n","metadata":{}},{"cell_type":"code","source":"model_one_params = {\n    'convolution_layers':1, \n    'fully_connected_layers': 1, \n    'pooling': 'max', \n    'output_activation': 'sigmoid',\n    'epochs': 5,\n    'optimizer':'adam',\n    'two_layers': True,\n    'batch_normalization': False,\n}\n\ntest_model(model_one_params)","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:10:06.309126Z","iopub.execute_input":"2024-02-22T19:10:06.309984Z","iopub.status.idle":"2024-02-22T19:12:10.870580Z","shell.execute_reply.started":"2024-02-22T19:10:06.309950Z","shell.execute_reply":"2024-02-22T19:12:10.869504Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plot_history(histories[0])","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:32:10.431542Z","iopub.execute_input":"2024-02-22T19:32:10.432502Z","iopub.status.idle":"2024-02-22T19:32:10.693850Z","shell.execute_reply.started":"2024-02-22T19:32:10.432467Z","shell.execute_reply":"2024-02-22T19:32:10.692868Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"In this base model our accuracy is in the mid-70s. Lets move on to tuning the model a bit to see if we can find an optimal structure and set of parameters to increase accuracy. \n\n# Step Four: Results + Analysis\n\n## Iterating Over Parameters\n\nIn the next section I tried some different permutations of inputs to see if I could get and idea of which structures worked best. I commented ou the code because it took a long time to run, but have included a summary of the results below. As we can see the sigmoid activation function does appear to produce the best results, so we'll stick with that. In terms of optimizing structure it seems we perform best when we've got 3 iterations of Conv-Conv-MaxPool and 3 Dense layers before outputting so we'll continue with those as well. \n","metadata":{}},{"cell_type":"code","source":"# model_args = {\n#     'convolution_layers':[2,3], \n#     'fully_connected_layers': [2,3,5], \n#     'pooling': 'max', \n#     'output_activation': ['sigmoid', 'tanh', 'softmax'],\n#     'epochs': 5,\n#     'optimizer':'adam',\n# }\n# all_args = [dict(zip(model_args.keys(), values)) for values in itertools.product(*model_args.values())]\n            \n# for arg in all_args:\n#     test_model(arg)\n            \n# results.sort_values(by='accuracy', ascending=False)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"![Screen Shot 2024-02-21 at 8.48.31 PM.png](attachment:9c504fc4-87d7-4ddb-a091-fff2241e5d13.png)","metadata":{},"attachments":{"9c504fc4-87d7-4ddb-a091-fff2241e5d13.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"## Changing Optimizer\n\nPreviously we've been using the `adam` optimizer, next I'll try a few different ones.","metadata":{}},{"cell_type":"code","source":"import itertools\nmodel_args = {\n    'convolution_layers': [3], \n    'fully_connected_layers': [3], \n    'pooling': ['max'], \n    'output_activation': ['sigmoid'],\n    'epochs': [5],\n    'optimizer':['sgd', 'rmsprop', 'adam'],\n    'two_layers': [True],\n    'batch_normalization': [False],\n}\n\nall_args = [dict(zip(model_args.keys(), values)) for values in itertools.product(*model_args.values())]\nprint(f\"Testing {len(all_args)}\")            \nfor arg in all_args:\n    test_model(arg)\n            \nresults.sort_values(by='accuracy', ascending=False)","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:24:35.989459Z","iopub.execute_input":"2024-02-22T19:24:35.989840Z","iopub.status.idle":"2024-02-22T19:29:04.423250Z","shell.execute_reply.started":"2024-02-22T19:24:35.989810Z","shell.execute_reply":"2024-02-22T19:29:04.422101Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Though it seems the results are pretty close, the `adam` optimizer does appear to still have the best performance.","metadata":{}},{"cell_type":"markdown","source":"## Enabling Batch Normalization\n\nLet's enable Batch Noramlization.","metadata":{}},{"cell_type":"code","source":"model_args = {\n    'convolution_layers': 3, \n    'fully_connected_layers': 3, \n    'pooling': 'max', \n    'output_activation': 'sigmoid',\n    'epochs': 5,\n    'optimizer': 'adam',\n    'two_layers': True,\n    'batch_normalization': True,\n}\n\ntest_model(model_args)","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:32:28.530316Z","iopub.execute_input":"2024-02-22T19:32:28.530662Z","iopub.status.idle":"2024-02-22T19:33:54.737742Z","shell.execute_reply.started":"2024-02-22T19:32:28.530637Z","shell.execute_reply":"2024-02-22T19:33:54.736749Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plot_history(histories[-1])","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:34:07.969719Z","iopub.execute_input":"2024-02-22T19:34:07.970597Z","iopub.status.idle":"2024-02-22T19:34:08.215630Z","shell.execute_reply.started":"2024-02-22T19:34:07.970562Z","shell.execute_reply":"2024-02-22T19:34:08.214397Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Switch to Conv-Max Pool \n\nNext, I'll try adjusting the model structure to only have one Conv Layer instead of two.","metadata":{}},{"cell_type":"code","source":"model_args = {\n    'convolution_layers': 3, \n    'fully_connected_layers': 3, \n    'pooling': 'max', \n    'output_activation': 'sigmoid',\n    'epochs': 5,\n    'optimizer': 'adam',\n    'two_layers': False,\n    'batch_normalization': False,\n}\n\ntest_model(model_args)","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:34:29.589916Z","iopub.execute_input":"2024-02-22T19:34:29.590315Z","iopub.status.idle":"2024-02-22T19:35:54.101255Z","shell.execute_reply.started":"2024-02-22T19:34:29.590285Z","shell.execute_reply":"2024-02-22T19:35:54.100213Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plot_history(histories[-1])","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:36:20.330186Z","iopub.execute_input":"2024-02-22T19:36:20.330555Z","iopub.status.idle":"2024-02-22T19:36:20.592428Z","shell.execute_reply.started":"2024-02-22T19:36:20.330527Z","shell.execute_reply":"2024-02-22T19:36:20.591437Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Summary of Results\n\nThe table below summarizes the results (not including the initial parameter permutations shown earlier). ","metadata":{}},{"cell_type":"code","source":"results.sort_values(by='accuracy', ascending=False)","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:41:35.410517Z","iopub.execute_input":"2024-02-22T19:41:35.410882Z","iopub.status.idle":"2024-02-22T19:41:35.427108Z","shell.execute_reply.started":"2024-02-22T19:41:35.410855Z","shell.execute_reply":"2024-02-22T19:41:35.426068Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Step Five: Conclusions\n\nIn all, I was only able to get accuracy here to about 80%. I found best results when there was a good balance of convolution layers and dense layers. If you add too many of either the performance does start to degrade. As shown above the optimal results were for 3 iterations of Conv-Conv-MaxPool and 3 Dense layers. In general sigmoid activation and using the adam optimizer seemed to perform the best. Overall the results were still not as high as I'd prefer. Time allowing, next steps would be to tune the optimizer and possible run on higher volumes of data and ran more epochs to see if that helps.","metadata":{}},{"cell_type":"code","source":"# Best results\nmax_accuracy_index = results['accuracy'].idxmax()\nprint(results.loc[max_accuracy_index])\nplot_history(histories[max_accuracy_index])","metadata":{"execution":{"iopub.status.busy":"2024-02-22T19:46:36.551023Z","iopub.execute_input":"2024-02-22T19:46:36.551676Z","iopub.status.idle":"2024-02-22T19:46:36.773037Z","shell.execute_reply.started":"2024-02-22T19:46:36.551645Z","shell.execute_reply":"2024-02-22T19:46:36.772007Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Predictions for Submission:","metadata":{}},{"cell_type":"code","source":"def get_validation_files():\n    test_dir = \"/kaggle/input/histopathologic-cancer-detection/test\"\n    validation_imgs = os.listdir(test_dir)\n    print(\"Number of test images: {}\".format(len(validation_imgs)))\n    return validation_imgs\n\ndef get_validation_generator(validation_df: pd.DataFrame):\n    print(\"Building Validation Generator...\")\n    start_time = time.time()\n    validation_datagen = ImageDataGenerator(rescale=1./255)\n    validation_generator = validation_datagen.flow_from_dataframe(\n        dataframe=validation_df,\n        directory=\"/kaggle/input/histopathologic-cancer-detection/test/\",\n        x_col='id',\n        target_size=(img_width, img_height),\n        batch_size=1, # has to be one for predictions\n        class_mode=None,\n        color_mode=\"rgb\",\n\n    )\n    end_time = time.time()\n    elapsed_time = end_time - start_time\n    print(f\"Elapsed time: {elapsed_time} seconds\")\n    return validation_generator\n\ndef generate_submission_file(validation_df):\n    if 'predictions' in validation_df.columns:\n        validation_df['label'] = (validation_df['predictions'] > 0.5).astype(int)\n    else:\n        print(\"No predictions found, using mock predictions.\")\n        validation_df['label'] = 0\n    submission = validation_df[['id', 'label']]\n    submission.loc[:, 'id'] = submission['id'].str.replace('.tif', '')\n    submission_filename = 'submission.csv'\n    submission.to_csv(submission_filename, index=False)\n    print(f\"Submission saved as {submission_filename}.\")\n    \ndef generate_submission_predictions(final_model, generate_predictions:bool = False) -> None:\n    validation_df = pd.DataFrame({'id': get_validation_files()})\n    validation_generator = get_validation_generator(validation_df)\n    # Running predictions can take a while...\n    if generate_predictions: \n        print(\"Making predictions...\")\n        validation_df['predictions'] = model_one.predict(validation_generator)\n    generate_submission_file(validation_df)\n\ngenerate_submission = False\nif generate_submission: \n    generate_submission_predictions(final_model = models[max_accuracy_index], generate_predictions = False)","metadata":{"execution":{"iopub.status.busy":"2024-02-22T20:19:40.510289Z","iopub.execute_input":"2024-02-22T20:19:40.510683Z","iopub.status.idle":"2024-02-22T20:19:40.524468Z","shell.execute_reply.started":"2024-02-22T20:19:40.510656Z","shell.execute_reply":"2024-02-22T20:19:40.523258Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}