Neural-Computing

commit 6da2320be16e909147c13628ff60f64029b1f0d4
parent 8581a82569730d721b8f9e04b5297b94789fb4ef
Author: William Lindholm <85635561+LindholmLabs@users.noreply.github.com>
Date:   Thu, 17 Oct 2024 15:27:05 +0100

Skapades med Colab
Diffstat:
A
CS4287_Prj1_24293059_24273759_id3.ipynb
 | 
852
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

1 file changed, 852 insertions(+), 0 deletions(-)
diff --git a/CS4287_Prj1_24293059_24273759_id3.ipynb b/CS4287_Prj1_24293059_24273759_id3.ipynb
@@ -0,0 +1,851 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/LindholmLabs/Neural-Computing/blob/main/CS4287_Prj1_24293059_24273759_id3.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "gNbyHNt__G-S"
+      },
+      "source": [
+        "Lars Jacobs (24293059)\n",
+        "William Lindholm (24273759)\n",
+        "Patrick Vorreiter (24284335)\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ZLO-lC_K8YiA"
+      },
+      "source": [
+        "# Project 1 notes\n",
+        "-----------------\n",
+        "\n",
+        "## Data Set\n",
+        "\n",
+        "Skin cancer dataset. This dataset contains 1800 pictures of benign cell pictures and 1500 pictures of malignant cell pictures\n",
+        "\n",
+        "## Pre-processing\n",
+        "\n",
+        "This will be resizing and flipping the pictures randomly to improve the models generalization. Maybe grayscaling and exposure settings that can also be changed\n",
+        "\n",
+        "## Network and hyperparameters\n",
+        "\n",
+        "Probably this will be most work. Figuring out which network setup works best and makes most sense. Lots of research needed here to know what kind of layers and how big / how much of them to use.\n",
+        "\n",
+        "## Loss Function\n",
+        "\n",
+        "Try different loss functions and try to explain why some work better than others:\n",
+        "- MSE\n",
+        "- Cross entropy\n",
+        "- DICE\n",
+        "\n",
+        "\n",
+        "## Optimiser\n",
+        "\n",
+        "Try different optimisers and try to explain why some work better than others:\n",
+        "- SGD\n",
+        "- ADAM\n",
+        "\n",
+        "\n",
+        "## Cross Fold Validation\n",
+        "\n",
+        "Basically just use it, maybe 5 or 10 fold if needed\n",
+        "\n",
+        "## Results\n",
+        "\n",
+        "Display different kinds of metrics. For classification of our dataset we can use terms like FPR, TPR, precision, recall, accuracy, etc. Make a confusion matrix, stuff like that\n",
+        "\n",
+        "## Evaluation\n",
+        "\n",
+        "Try to see if we overfitted or underfitted the data. Not sure how to do this yet but we can figure it out.\n",
+        "\n",
+        "## Experiments\n",
+        "\n",
+        "Experiments with number of layers and what kind of layers for example. It will be crucial here to keep our notebook clean and make use of the code blocks in the notebook so we dont have to rerun all the code for different experiments."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "D30oqzQgCkdt"
+      },
+      "source": [
+        "**Loading the dataset**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 804
+        },
+        "collapsed": true,
+        "id": "Lv9XC-tFCocp",
+        "outputId": "4032fa98-8a76-4d7d-d5ef-896f0885b9ac"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Requirement already satisfied: kaggle in /usr/local/lib/python3.10/dist-packages (1.6.17)\n",
+            "Requirement already satisfied: six>=1.10 in /usr/local/lib/python3.10/dist-packages (from kaggle) (1.16.0)\n",
+            "Requirement already satisfied: certifi>=2023.7.22 in /usr/local/lib/python3.10/dist-packages (from kaggle) (2024.8.30)\n",
+            "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.8.2)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.32.3)\n",
+            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from kaggle) (4.66.5)\n",
+            "Requirement already satisfied: python-slugify in /usr/local/lib/python3.10/dist-packages (from kaggle) (8.0.4)\n",
+            "Requirement already satisfied: urllib3 in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.2.3)\n",
+            "Requirement already satisfied: bleach in /usr/local/lib/python3.10/dist-packages (from kaggle) (6.1.0)\n",
+            "Requirement already satisfied: webencodings in /usr/local/lib/python3.10/dist-packages (from bleach->kaggle) (0.5.1)\n",
+            "Requirement already satisfied: text-unidecode>=1.3 in /usr/local/lib/python3.10/dist-packages (from python-slugify->kaggle) (1.3)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (3.4.0)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (3.10)\n"
+          ]
+        },
+        {
+          "data": {
+            "text/html": [
+              "\n",
+              "     <input type=\"file\" id=\"files-cb8033cc-7638-4970-8d31-2425abc863fc\" name=\"files[]\" multiple disabled\n",
+              "        style=\"border:none\" />\n",
+              "     <output id=\"result-cb8033cc-7638-4970-8d31-2425abc863fc\">\n",
+              "      Upload widget is only available when the cell has been executed in the\n",
+              "      current browser session. Please rerun this cell to enable.\n",
+              "      </output>\n",
+              "      <script>// Copyright 2017 Google LLC\n",
+              "//\n",
+              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+              "// you may not use this file except in compliance with the License.\n",
+              "// You may obtain a copy of the License at\n",
+              "//\n",
+              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
+              "//\n",
+              "// Unless required by applicable law or agreed to in writing, software\n",
+              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+              "// See the License for the specific language governing permissions and\n",
+              "// limitations under the License.\n",
+              "\n",
+              "/**\n",
+              " * @fileoverview Helpers for google.colab Python module.\n",
+              " */\n",
+              "(function(scope) {\n",
+              "function span(text, styleAttributes = {}) {\n",
+              "  const element = document.createElement('span');\n",
+              "  element.textContent = text;\n",
+              "  for (const key of Object.keys(styleAttributes)) {\n",
+              "    element.style[key] = styleAttributes[key];\n",
+              "  }\n",
+              "  return element;\n",
+              "}\n",
+              "\n",
+              "// Max number of bytes which will be uploaded at a time.\n",
+              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
+              "\n",
+              "function _uploadFiles(inputId, outputId) {\n",
+              "  const steps = uploadFilesStep(inputId, outputId);\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  // Cache steps on the outputElement to make it available for the next call\n",
+              "  // to uploadFilesContinue from Python.\n",
+              "  outputElement.steps = steps;\n",
+              "\n",
+              "  return _uploadFilesContinue(outputId);\n",
+              "}\n",
+              "\n",
+              "// This is roughly an async generator (not supported in the browser yet),\n",
+              "// where there are multiple asynchronous steps and the Python side is going\n",
+              "// to poll for completion of each step.\n",
+              "// This uses a Promise to block the python side on completion of each step,\n",
+              "// then passes the result of the previous step as the input to the next step.\n",
+              "function _uploadFilesContinue(outputId) {\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  const steps = outputElement.steps;\n",
+              "\n",
+              "  const next = steps.next(outputElement.lastPromiseValue);\n",
+              "  return Promise.resolve(next.value.promise).then((value) => {\n",
+              "    // Cache the last promise value to make it available to the next\n",
+              "    // step of the generator.\n",
+              "    outputElement.lastPromiseValue = value;\n",
+              "    return next.value.response;\n",
+              "  });\n",
+              "}\n",
+              "\n",
+              "/**\n",
+              " * Generator function which is called between each async step of the upload\n",
+              " * process.\n",
+              " * @param {string} inputId Element ID of the input file picker element.\n",
+              " * @param {string} outputId Element ID of the output display.\n",
+              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
+              " */\n",
+              "function* uploadFilesStep(inputId, outputId) {\n",
+              "  const inputElement = document.getElementById(inputId);\n",
+              "  inputElement.disabled = false;\n",
+              "\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  outputElement.innerHTML = '';\n",
+              "\n",
+              "  const pickedPromise = new Promise((resolve) => {\n",
+              "    inputElement.addEventListener('change', (e) => {\n",
+              "      resolve(e.target.files);\n",
+              "    });\n",
+              "  });\n",
+              "\n",
+              "  const cancel = document.createElement('button');\n",
+              "  inputElement.parentElement.appendChild(cancel);\n",
+              "  cancel.textContent = 'Cancel upload';\n",
+              "  const cancelPromise = new Promise((resolve) => {\n",
+              "    cancel.onclick = () => {\n",
+              "      resolve(null);\n",
+              "    };\n",
+              "  });\n",
+              "\n",
+              "  // Wait for the user to pick the files.\n",
+              "  const files = yield {\n",
+              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
+              "    response: {\n",
+              "      action: 'starting',\n",
+              "    }\n",
+              "  };\n",
+              "\n",
+              "  cancel.remove();\n",
+              "\n",
+              "  // Disable the input element since further picks are not allowed.\n",
+              "  inputElement.disabled = true;\n",
+              "\n",
+              "  if (!files) {\n",
+              "    return {\n",
+              "      response: {\n",
+              "        action: 'complete',\n",
+              "      }\n",
+              "    };\n",
+              "  }\n",
+              "\n",
+              "  for (const file of files) {\n",
+              "    const li = document.createElement('li');\n",
+              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
+              "    li.append(span(\n",
+              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
+              "        `last modified: ${\n",
+              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
+              "                                    'n/a'} - `));\n",
+              "    const percent = span('0% done');\n",
+              "    li.appendChild(percent);\n",
+              "\n",
+              "    outputElement.appendChild(li);\n",
+              "\n",
+              "    const fileDataPromise = new Promise((resolve) => {\n",
+              "      const reader = new FileReader();\n",
+              "      reader.onload = (e) => {\n",
+              "        resolve(e.target.result);\n",
+              "      };\n",
+              "      reader.readAsArrayBuffer(file);\n",
+              "    });\n",
+              "    // Wait for the data to be ready.\n",
+              "    let fileData = yield {\n",
+              "      promise: fileDataPromise,\n",
+              "      response: {\n",
+              "        action: 'continue',\n",
+              "      }\n",
+              "    };\n",
+              "\n",
+              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
+              "    let position = 0;\n",
+              "    do {\n",
+              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
+              "      const chunk = new Uint8Array(fileData, position, length);\n",
+              "      position += length;\n",
+              "\n",
+              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
+              "      yield {\n",
+              "        response: {\n",
+              "          action: 'append',\n",
+              "          file: file.name,\n",
+              "          data: base64,\n",
+              "        },\n",
+              "      };\n",
+              "\n",
+              "      let percentDone = fileData.byteLength === 0 ?\n",
+              "          100 :\n",
+              "          Math.round((position / fileData.byteLength) * 100);\n",
+              "      percent.textContent = `${percentDone}% done`;\n",
+              "\n",
+              "    } while (position < fileData.byteLength);\n",
+              "  }\n",
+              "\n",
+              "  // All done.\n",
+              "  yield {\n",
+              "    response: {\n",
+              "      action: 'complete',\n",
+              "    }\n",
+              "  };\n",
+              "}\n",
+              "\n",
+              "scope.google = scope.google || {};\n",
+              "scope.google.colab = scope.google.colab || {};\n",
+              "scope.google.colab._files = {\n",
+              "  _uploadFiles,\n",
+              "  _uploadFilesContinue,\n",
+              "};\n",
+              "})(self);\n",
+              "</script> "
+            ],
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Saving kaggle.json to kaggle (1).json\n",
+            "mkdir: cannot create directory ‘/root/.kaggle’: File exists\n",
+            "ref                                                           title                                               size  lastUpdated          downloadCount  voteCount  usabilityRating  \n",
+            "------------------------------------------------------------  -------------------------------------------------  -----  -------------------  -------------  ---------  ---------------  \n",
+            "lainguyn123/student-performance-factors                       Student Performance Factors                         94KB  2024-09-02 10:53:57          34096        605  1.0              \n",
+            "valakhorasani/mobile-device-usage-and-user-behavior-dataset   Mobile Device Usage and User Behavior Dataset       11KB  2024-09-28 20:21:12           6314        115  1.0              \n",
+            "abdulszz/spotify-most-streamed-songs                          Spotify Most Streamed Songs                         60KB  2024-09-07 18:23:14          13506        174  1.0              \n",
+            "valakhorasani/gym-members-exercise-dataset                    Gym Members Exercise Dataset                        22KB  2024-10-06 11:27:38           2996         65  1.0              \n",
+            "ankulsharma150/marketing-analytics-project                    Marketing Analytics Project                         38KB  2024-10-01 09:27:22           1571         27  1.0              \n",
+            "prajwaldongre/top-100-healthiest-food-in-the-world            100 Healthiest Foods:Nutrition and Origin dataset    3KB  2024-10-11 09:40:41           1270         32  1.0              \n",
+            "ka66ledata/gym-membership-dataset                             Gym Membership Dataset                              24KB  2024-10-14 06:48:29           1495         25  1.0              \n",
+            "saisiddartha69/customer-churn-classification                  Customer Churn Classification                      553KB  2024-10-15 02:32:01            848         25  0.9411765        \n",
+            "umerhaddii/walmart-stock-data-2024                            Walmart Stock Data 2024                            304KB  2024-10-15 07:25:18            413         34  1.0              \n",
+            "mafzal19/electric-vehicle-sales-by-state-in-india             Electric Vehicle Sales by State in India           453KB  2024-10-11 18:59:45           1370         27  1.0              \n",
+            "waqi786/remote-work-and-mental-health                         Remote Work & Mental Health 🌍🧠                      93KB  2024-09-22 11:44:29           5926         87  1.0              \n",
+            "waqi786/youth-smoking-and-drug-dataset                        Youth Smoking and Drug Dataset 🚭💊                  152KB  2024-10-08 15:22:23           1807         33  1.0              \n",
+            "zafarali27/house-price-prediction-dataset                     House Price Prediction Dataset                      29KB  2024-09-21 19:19:08           1868         32  1.0              \n",
+            "valakhorasani/electric-vehicle-charging-patterns              Electric Vehicle Charging Patterns                 130KB  2024-10-02 10:52:27           2136         58  1.0              \n",
+            "alexandrakim2201/spotify-dataset                              Spotify User Reviews                                 3MB  2024-10-03 10:36:36           1235         30  1.0              \n",
+            "zafarali27/car-price-prediction                               Car Price Prediction                                45KB  2024-09-21 20:30:22           2314         31  1.0              \n",
+            "syedfaizanalii/predict-students-dropout-and-academic-success  Predict Students Dropout and Academic Success      105KB  2024-09-28 09:41:55           2315         58  1.0              \n",
+            "owm4096/laptop-prices                                         Laptop Prices                                       25KB  2024-09-09 12:43:01           9623        134  1.0              \n",
+            "willianoliveiragibin/marvel-vs-dc                             Marvel vs DC                                       107KB  2024-09-26 22:51:04           2122         32  1.0              \n",
+            "ankulsharma150/food-order-cost-and-profit-analysis            Food Order Cost and Profit Analysis                 28KB  2024-09-30 13:38:30           1360         26  1.0              \n",
+            "Dataset URL: https://www.kaggle.com/datasets/rm1000/skin-cancer-isic-images\n",
+            "License(s): CC0-1.0\n",
+            "skin-cancer-isic-images.zip: Skipping, found more recently modified local copy (use --force to force download)\n",
+            "Archive:  skin-cancer-isic-images.zip\n",
+            "replace benign/0000.jpg? [y]es, [n]o, [A]ll, [N]one, [r]ename: "
+          ]
+        }
+      ],
+      "source": [
+        "# Needed libraries\n",
+        "!pip install kaggle;\n",
+        "\n",
+        "from google.colab import files\n",
+        "\n",
+        "files.upload()\n",
+        "\n",
+        "! mkdir ~/.kaggle;\n",
+        "! cp kaggle.json ~/.kaggle/;\n",
+        "! chmod 600 ~/.kaggle/kaggle.json;\n",
+        "! kaggle datasets list\n",
+        "!kaggle datasets download -d rm1000/skin-cancer-isic-images;\n",
+        "!unzip skin-cancer-isic-images.zip;\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "1jpf8RG8FbPf"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import matplotlib.pyplot as plt\n",
+        "from PIL import Image\n",
+        "\n",
+        "# Set the path for your dataset\n",
+        "benign_path = './benign'\n",
+        "malignant_path = './malignant'\n",
+        "\n",
+        "# Function to load images from a folder\n",
+        "def load_images_from_folder(folder):\n",
+        "    images = []\n",
+        "    for filename in os.listdir(folder):\n",
+        "        img_path = os.path.join(folder, filename)\n",
+        "        img = Image.open(img_path)\n",
+        "        images.append(img)\n",
+        "    return images\n",
+        "\n",
+        "# Load benign and malignant images\n",
+        "benign_images = load_images_from_folder(benign_path)\n",
+        "malignant_images = load_images_from_folder(malignant_path)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "r-9GxnJHk_IH"
+      },
+      "source": [
+        "# Our model class"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "hzkED5MihiXy"
+      },
+      "outputs": [],
+      "source": [
+        "import tensorflow as tf\n",
+        "from tensorflow.keras import layers, models\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "from sklearn.metrics import confusion_matrix\n",
+        "import seaborn as sns\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "class ImageClassificationModel:\n",
+        "    def __init__(self, optimizer='adam', loss_function='binary_crossentropy', activation_function='relu', output_activation_function='sigmoid', batch_size=64, epochs=20, data_augmentation=None):\n",
+        "        # Fixed parameters\n",
+        "        self.img_size = (228, 228)\n",
+        "        self.num_classes = 2\n",
+        "        self.test_size = 0.2\n",
+        "        self.val_size = 0.1\n",
+        "\n",
+        "        # Customizable parameters\n",
+        "        self.optimizer = optimizer\n",
+        "        self.loss_function = loss_function\n",
+        "        self.activation_function = activation_function\n",
+        "        self.batch_size = batch_size\n",
+        "        self.epochs = epochs\n",
+        "        self.output_activation_function = output_activation_function\n",
+        "        self.data_augmentation = data_augmentation\n",
+        "        self.model_summary = False\n",
+        "        self.training_progress = 0\n",
+        "\n",
+        "    def show_model_summary(self):\n",
+        "        self.model_summary = True\n",
+        "\n",
+        "    def show_training_progress(self):\n",
+        "        self.training_progress = 1\n",
+        "\n",
+        "    # Function to resize and normalize images\n",
+        "    def preprocess_images(self, images):\n",
+        "        images_resized = np.array([tf.image.resize(img, self.img_size).numpy() for img in images])\n",
+        "        images_resized = images_resized.astype('float32') / 255.0\n",
+        "        return images_resized\n",
+        "\n",
+        "    # Function to load data, preprocess, and split into train, validation, and test sets\n",
+        "    def load_data(self, benign_images, malignant_images):\n",
+        "        benign_images_array = self.preprocess_images(benign_images)\n",
+        "        malignant_images_array = self.preprocess_images(malignant_images)\n",
+        "\n",
+        "        benign_labels = np.zeros(len(benign_images_array))\n",
+        "        malignant_labels = np.ones(len(malignant_images_array))\n",
+        "\n",
+        "        X_data = np.concatenate((benign_images_array, malignant_images_array), axis=0)\n",
+        "        y_data = np.concatenate((benign_labels, malignant_labels), axis=0)\n",
+        "\n",
+        "        indices = np.arange(X_data.shape[0])\n",
+        "        np.random.shuffle(indices)\n",
+        "        X_data = X_data[indices]\n",
+        "        y_data = y_data[indices]\n",
+        "\n",
+        "        X_train, X_test, y_train, y_test = train_test_split(X_data, y_data, test_size=self.test_size, random_state=42)\n",
+        "        X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=self.val_size, random_state=42)\n",
+        "\n",
+        "        y_train = tf.keras.utils.to_categorical(y_train, self.num_classes)\n",
+        "        y_val = tf.keras.utils.to_categorical(y_val, self.num_classes)\n",
+        "        y_test = tf.keras.utils.to_categorical(y_test, self.num_classes)\n",
+        "\n",
+        "        return X_train, y_train, X_val, y_val, X_test, y_test\n",
+        "\n",
+        "    # Function to build the model with customizable activation function\n",
+        "    def build_model(self, input_shape):\n",
+        "        model = models.Sequential()\n",
+        "\n",
+        "        # 1st block\n",
+        "        model.add(layers.Conv2D(32, (3, 3), padding='same', input_shape=input_shape, activation=self.activation_function))\n",
+        "        model.add(layers.BatchNormalization())\n",
+        "        model.add(layers.Conv2D(32, (3, 3), padding='same', activation=self.activation_function))\n",
+        "        model.add(layers.BatchNormalization())\n",
+        "        model.add(layers.MaxPooling2D(pool_size=(2, 2)))\n",
+        "        model.add(layers.Dropout(0.2))\n",
+        "\n",
+        "        # 2nd block\n",
+        "        model.add(layers.Conv2D(64, (3, 3), padding='same', activation=self.activation_function))\n",
+        "        model.add(layers.BatchNormalization())\n",
+        "        model.add(layers.Conv2D(64, (3, 3), padding='same', activation=self.activation_function))\n",
+        "        model.add(layers.BatchNormalization())\n",
+        "        model.add(layers.MaxPooling2D(pool_size=(2, 2)))\n",
+        "        model.add(layers.Dropout(0.3))\n",
+        "\n",
+        "        # 3rd block\n",
+        "        model.add(layers.Conv2D(128, (3, 3), padding='same', activation=self.activation_function))\n",
+        "        model.add(layers.BatchNormalization())\n",
+        "        model.add(layers.Conv2D(128, (3, 3), padding='same', activation=self.activation_function))\n",
+        "        model.add(layers.BatchNormalization())\n",
+        "        model.add(layers.MaxPooling2D(pool_size=(2, 2)))\n",
+        "        model.add(layers.Dropout(0.4))\n",
+        "\n",
+        "        # Dense layer\n",
+        "        model.add(layers.Flatten())\n",
+        "        model.add(layers.Dense(128, activation=self.activation_function))\n",
+        "        model.add(layers.Dropout(0.5))\n",
+        "        model.add(layers.Dense(self.num_classes, activation=self.output_activation_function))\n",
+        "\n",
+        "        return model\n",
+        "\n",
+        "    # Function to compile and train the model using the preset parameters\n",
+        "    def train_model(self, X_train, y_train, X_val, y_val):\n",
+        "        model = self.build_model(X_train.shape[1:])\n",
+        "\n",
+        "        model.compile(optimizer=self.optimizer, loss=self.loss_function, metrics=['accuracy'])\n",
+        "\n",
+        "        if self.model_summary:\n",
+        "          model.summary()\n",
+        "\n",
+        "        if self.data_augmentation:\n",
+        "          history = model.fit(self.data_augmentation.flow(X_train, y_train, batch_size=self.batch_size), epochs=self.epochs, validation_data=(X_val, y_val), verbose=self.training_progress)\n",
+        "        else:\n",
+        "          history = model.fit(X_train, y_train, batch_size=self.batch_size, epochs=self.epochs, validation_data=(X_val, y_val), verbose=self.training_progress)\n",
+        "\n",
+        "        return model, history\n",
+        "\n",
+        "    # Function to evaluate the model on test data\n",
+        "    def evaluate_model(self, model, X_test, y_test):\n",
+        "        score = model.evaluate(X_test, y_test, verbose=0)\n",
+        "        print(f\"\\nTest loss: {score[0]}\")\n",
+        "        print(f\"Test accuracy: {score[1]}\")\n",
+        "        return score\n",
+        "\n",
+        "    def run(self, evaluate_model=True, plot_history=True):\n",
+        "      X_train, y_train, X_val, y_val, X_test, y_test = self.load_data(benign_images, malignant_images)\n",
+        "\n",
+        "      # Train the model\n",
+        "      model, history = self.train_model(X_train, y_train, X_val, y_val)\n",
+        "\n",
+        "      if evaluate_model:\n",
+        "        # Evaluate the model on the test data\n",
+        "        self.evaluate_model(model, X_test, y_test)\n",
+        "\n",
+        "      if plot_history:\n",
+        "        # Plot the training history\n",
+        "        self.plot_history(history)\n",
+        "\n",
+        "\n",
+        "    # Function to plot training and validation accuracy and loss\n",
+        "    def plot_history(self, history):\n",
+        "        acc = history.history['accuracy']\n",
+        "        val_acc = history.history['val_accuracy']\n",
+        "        loss = history.history['loss']\n",
+        "        val_loss = history.history['val_loss']\n",
+        "\n",
+        "        epochs_range = range(len(acc))\n",
+        "\n",
+        "        plt.figure(figsize=(12, 6))\n",
+        "        plt.subplot(1, 2, 1)\n",
+        "        plt.plot(epochs_range, acc, label='Training Accuracy')\n",
+        "        plt.plot(epochs_range, val_acc, label='Validation Accuracy')\n",
+        "        plt.legend(loc='lower right')\n",
+        "        plt.title('Training and Validation Accuracy')\n",
+        "\n",
+        "        plt.subplot(1, 2, 2)\n",
+        "        plt.plot(epochs_range, loss, label='Training Loss')\n",
+        "        plt.plot(epochs_range, val_loss, label='Validation Loss')\n",
+        "        plt.legend(loc='upper right')\n",
+        "        plt.title('Training and Validation Loss')\n",
+        "        plt.show()\n",
+        "\n",
+        "        y_pred_prob = model.predict(X_test)\n",
+        "        y_pred = np.argmax(y_pred_prob, axis=1)\n",
+        "        y_true = np.argmax(y_test, axis=1)\n",
+        "\n",
+        "        conf_matrix = confusion_matrix(y_true, y_pred)\n",
+        "\n",
+        "        plt.figure(figsize=(8, 6))\n",
+        "        sns.heatmap(conf_matrix, annot=True, fmt=\"d\", cmap=\"Blues\",\n",
+        "                    xticklabels=['Benign', 'Malignant'],\n",
+        "                    yticklabels=['Benign', 'Malignant'])\n",
+        "        plt.xlabel(\"Predicted\")\n",
+        "        plt.ylabel(\"Actual\")\n",
+        "        plt.title(\"Confusion Matrix\")\n",
+        "        plt.show()\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ORjee3Qd8f7S"
+      },
+      "source": [
+        "Here is the default configuration that we got from the lab."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "zegpbfKC8fTH",
+        "outputId": "aead70d5-b111-4ed7-d390-ba2f43a13352"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/usr/local/lib/python3.10/dist-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
+            "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "Test loss: 0.7393055558204651\n",
+            "Test accuracy: 0.7757575511932373\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1200x600 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\u001b[1m21/21\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 800x600 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "hello\n"
+          ]
+        }
+      ],
+      "source": [
+        "model_obj = ImageClassificationModel(optimizer='RMSprop', loss_function='categorical_crossentropy', activation_function='relu', output_activation_function='softmax', batch_size=32, epochs=10)\n",
+        "\n",
+        "model_obj.run()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "wFn3ptG7pqI6"
+      },
+      "source": [
+        "# Results\n",
+        "\n",
+        "# Results\n",
+        "\n",
+        "## 1\n",
+        "- 10 epochs\n",
+        "- loss: categorical_crossentropy\n",
+        "- Batch size: 64\n",
+        "- optimizer: RMSprop\n",
+        "- activation: relu (for all layers except output)\n",
+        "\n",
+        "<br>\n",
+        "Test score: 2.2877860069274902<br>\n",
+        "Test accuracy: 0.7651515007019043\n",
+        "\n",
+        "## 2\n",
+        "- 20 epochs\n",
+        "- loss: categorical_crossentropy\n",
+        "- Batch size: 64\n",
+        "- optimizer: RMSprop\n",
+        "- activation: relu (for all layers except output)\n",
+        "\n",
+        "<br>\n",
+        "Test loss: 0.45444709062576294 <br>\n",
+        "Test accuracy: 0.831818163394928\n",
+        "\n",
+        "## 3\n",
+        "- 30 epochs\n",
+        "- loss: categorical_crossentropy\n",
+        "- Batch size: 128\n",
+        "- optimizer: RMSprop\n",
+        "- activation: relu (for all layers except output)\n",
+        "\n",
+        "<br>\n",
+        "Test loss: 1.4917829036712646 <br>\n",
+        "Test accuracy: 0.4848484992980957\n",
+        "\n",
+        "\n",
+        "\n",
+        "**Introduced separate test and validation set after this point**\n",
+        "\n",
+        "## 4\n",
+        "- 30 epochs\n",
+        "- loss: categorical_crossentropy\n",
+        "- Batch size: 128\n",
+        "- optimizer: RMSprop\n",
+        "- activation: relu (for all layers except output)\n",
+        "\n",
+        "<br>\n",
+        "Test loss: 1.4917829036712646 <br>\n",
+        "Test accuracy: 0.4848484992980957\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "GZP80_YWyEsn"
+      },
+      "source": [
+        "**Pre Processing Testing**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "background_save": true,
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "mS3XmLaux4A7",
+        "outputId": "9e118661-a00e-45f8-8508-96dd200ea721"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/usr/local/lib/python3.10/dist-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
+            "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n",
+            "/usr/local/lib/python3.10/dist-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
+            "  self._warn_if_super_not_called()\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "Test loss: 0.6276654005050659\n",
+            "Test accuracy: 0.4636363685131073\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1200x600 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\u001b[1m21/21\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 800x600 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "hello\n"
+          ]
+        }
+      ],
+      "source": [
+        "datagen = ImageDataGenerator(\n",
+        "    rotation_range=30,\n",
+        "    horizontal_flip=True,\n",
+        "    vertical_flip=True,\n",
+        "    zoom_range=0.2\n",
+        ")\n",
+        "\n",
+        "model_obj = ImageClassificationModel(\n",
+        "    optimizer='adam',\n",
+        "    loss_function='binary_crossentropy',\n",
+        "    activation_function='relu',\n",
+        "    output_activation_function='sigmoid',\n",
+        "    batch_size=32, epochs=10,\n",
+        "    data_augmentation=datagen)\n",
+        "\n",
+        "model_obj.run()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Okv5mQkN-4gY"
+      },
+      "source": [
+        "#"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "A100",
+      "machine_shape": "hm",
+      "provenance": [],
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
+\ No newline at end of file