GAN_Enhanced_CNN_Experiments.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eVP7aTLTTtA4",
        "outputId": "81d92efa-571c-4daf-a455-cc1587c14acb"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading fracture-multi-region-x-ray-data, 504652653 bytes compressed\n",
            "[==================================================] 504652653 bytes downloaded\n",
            "Downloaded and uncompressed: fracture-multi-region-x-ray-data\n",
            "Data source import complete.\n"
          ]
        }
      ],
      "source": [
        "\n",
        "# IMPORTANT: RUN THIS CELL IN ORDER TO IMPORT YOUR KAGGLE DATA SOURCES\n",
        "# TO THE CORRECT LOCATION (/kaggle/input) IN YOUR NOTEBOOK,\n",
        "# THEN FEEL FREE TO DELETE THIS CELL.\n",
        "# NOTE: THIS NOTEBOOK ENVIRONMENT DIFFERS FROM KAGGLE'S PYTHON\n",
        "# ENVIRONMENT SO THERE MAY BE MISSING LIBRARIES USED BY YOUR\n",
        "# NOTEBOOK.\n",
        "\n",
        "import os\n",
        "import sys\n",
        "from tempfile import NamedTemporaryFile\n",
        "from urllib.request import urlopen\n",
        "from urllib.parse import unquote, urlparse\n",
        "from urllib.error import HTTPError\n",
        "from zipfile import ZipFile\n",
        "import tarfile\n",
        "import shutil\n",
        "\n",
        "CHUNK_SIZE = 40960\n",
        "DATA_SOURCE_MAPPING = 'fracture-multi-region-x-ray-data:https%3A%2F%2Fstorage.googleapis.com%2Fkaggle-data-sets%2F4854718%2F8201044%2Fbundle%2Farchive.zip%3FX-Goog-Algorithm%3DGOOG4-RSA-SHA256%26X-Goog-Credential%3Dgcp-kaggle-com%2540kaggle-161607.iam.gserviceaccount.com%252F20240611%252Fauto%252Fstorage%252Fgoog4_request%26X-Goog-Date%3D20240611T024621Z%26X-Goog-Expires%3D259200%26X-Goog-SignedHeaders%3Dhost%26X-Goog-Signature%3Dace93751985c31eeb71a12eb72450f18a95e61a129b7b7c8caa8806e3c7e13ce446788e9aec22091d7ca6282202cd09c585dad5da7e15faa33f32cf8256ef353ac211bcc3edec23460e7662427b44e054327eb6b4fc00a93a17e4ff48c5a474f1be62e82979d745a007e9a8aae0ad572372c4cf745334318eafbb2c1a1621acb0c1bbee6444e2380ec0449b85b3438a7bbb1e58ead48212db7c878b07ea3bac030698e9753400ecffcb927f68fba68ef9c7b1834bf976abbec8f856a19ffa859982726c2d18b77b580ba88e3c1f5438797476d742ad49403cb7728da3e543b31c29d964d0123268fe25e94968d681baa97c1c2ff697a6c5b1d6dd11065cef3a0'\n",
        "\n",
        "KAGGLE_INPUT_PATH='/kaggle/input'\n",
        "KAGGLE_WORKING_PATH='/kaggle/working'\n",
        "KAGGLE_SYMLINK='kaggle'\n",
        "\n",
        "!umount /kaggle/input/ 2> /dev/null\n",
        "shutil.rmtree('/kaggle/input', ignore_errors=True)\n",
        "os.makedirs(KAGGLE_INPUT_PATH, 0o777, exist_ok=True)\n",
        "os.makedirs(KAGGLE_WORKING_PATH, 0o777, exist_ok=True)\n",
        "\n",
        "try:\n",
        "  os.symlink(KAGGLE_INPUT_PATH, os.path.join(\"..\", 'input'), target_is_directory=True)\n",
        "except FileExistsError:\n",
        "  pass\n",
        "try:\n",
        "  os.symlink(KAGGLE_WORKING_PATH, os.path.join(\"..\", 'working'), target_is_directory=True)\n",
        "except FileExistsError:\n",
        "  pass\n",
        "\n",
        "for data_source_mapping in DATA_SOURCE_MAPPING.split(','):\n",
        "    directory, download_url_encoded = data_source_mapping.split(':')\n",
        "    download_url = unquote(download_url_encoded)\n",
        "    filename = urlparse(download_url).path\n",
        "    destination_path = os.path.join(KAGGLE_INPUT_PATH, directory)\n",
        "    try:\n",
        "        with urlopen(download_url) as fileres, NamedTemporaryFile() as tfile:\n",
        "            total_length = fileres.headers['content-length']\n",
        "            print(f'Downloading {directory}, {total_length} bytes compressed')\n",
        "            dl = 0\n",
        "            data = fileres.read(CHUNK_SIZE)\n",
        "            while len(data) > 0:\n",
        "                dl += len(data)\n",
        "                tfile.write(data)\n",
        "                done = int(50 * dl / int(total_length))\n",
        "                sys.stdout.write(f\"\\r[{'=' * done}{' ' * (50-done)}] {dl} bytes downloaded\")\n",
        "                sys.stdout.flush()\n",
        "                data = fileres.read(CHUNK_SIZE)\n",
        "            if filename.endswith('.zip'):\n",
        "              with ZipFile(tfile) as zfile:\n",
        "                zfile.extractall(destination_path)\n",
        "            else:\n",
        "              with tarfile.open(tfile.name) as tarfile:\n",
        "                tarfile.extractall(destination_path)\n",
        "            print(f'\\nDownloaded and uncompressed: {directory}')\n",
        "    except HTTPError as e:\n",
        "        print(f'Failed to load (likely expired) {download_url} to path {destination_path}')\n",
        "        continue\n",
        "    except OSError as e:\n",
        "        print(f'Failed to load {download_url} to path {destination_path}')\n",
        "        continue\n",
        "\n",
        "print('Data source import complete.')\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import numpy as np\n",
        "from PIL.Image import Resampling\n",
        "from keras.utils import load_img, img_to_array\n",
        "\n",
        "\n",
        "def load_data(data_dir):\n",
        "    # Initialize empty lists for images and labels\n",
        "    X = []\n",
        "    y = []\n",
        "\n",
        "    # Define image dimensions (adjust as needed)\n",
        "    img_width, img_height = 64, 64\n",
        "\n",
        "    for class_dir in os.listdir(data_dir):\n",
        "        if class_dir in [\"fractured\", \"not fractured\"]:\n",
        "            class_path = os.path.join(data_dir, class_dir)\n",
        "\n",
        "            # Loop through images in the current subdirectory\n",
        "            for img_name in os.listdir(class_path):\n",
        "                img_path = os.path.join(class_path, img_name)\n",
        "\n",
        "                # Load the image\n",
        "                try:\n",
        "                    img = load_img(img_path, color_mode=\"grayscale\")\n",
        "                except OSError as e:\n",
        "                    if \"truncated\" in str(e):\n",
        "                        #print(f\"Error: Image {img_path} is truncated. Skipping it.\")\n",
        "                        continue\n",
        "                    else:\n",
        "                        raise  # Raise the exception for other errors\n",
        "\n",
        "                # Resize the image\n",
        "                img = img.resize((img_width, img_height), resample=Resampling.BICUBIC)\n",
        "\n",
        "                # Convert to NumPy array\n",
        "                img_array = img_to_array(img)\n",
        "\n",
        "                # Reshape for model input (1 channel for grayscale)\n",
        "                img_array = img_array.reshape(img_width, img_height, 1).astype('float32')\n",
        "\n",
        "                # Assign labels (0 for \"not fractured\", 1 for \"fractured\")\n",
        "                label = 0 if class_dir == \"not fractured\" else 1\n",
        "                X.append(img_array)\n",
        "                y.append(label)\n",
        "\n",
        "    return np.array(X), np.array(y)"
      ],
      "metadata": {
        "id": "X0XfeEUaY6ZJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_dir = \"/kaggle/input/fracture-multi-region-x-ray-data/Bone_Fracture_Binary_Classification/Bone_Fracture_Binary_Classification/train\"\n",
        "valid_dir = \"/kaggle/input/fracture-multi-region-x-ray-data/Bone_Fracture_Binary_Classification/Bone_Fracture_Binary_Classification/val\"\n",
        "test_dir = \"/kaggle/input/fracture-multi-region-x-ray-data/Bone_Fracture_Binary_Classification/Bone_Fracture_Binary_Classification/test\"\n",
        "\n",
        "(X_train, y_train) = load_data(train_dir)\n",
        "(X_valid, y_valid) = load_data(valid_dir)\n",
        "(X_test, y_test) = load_data(test_dir)\n",
        "\n",
        "X_train /= 255\n",
        "X_valid /= 255\n",
        "X_test /= 255"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4mnnZ8cpU0d2",
        "outputId": "cc0fd30e-874a-42f5-b218-972a0ef0f9b2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/PIL/Image.py:996: UserWarning: Palette images with Transparency expressed in bytes should be converted to RGBA images\n",
            "  warnings.warn(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "def augment_data(X_train, y_train, batch_size=32, img_width=64, img_height=64):\n",
        "    # Create an ImageDataGenerator instance for data augmentation\n",
        "    datagen = ImageDataGenerator(\n",
        "        # rotation_range=10,      # Rotate images randomly by up to 20 degrees\n",
        "        # width_shift_range=0.1,  # Shift images horizontally by up to 10% of the width\n",
        "        # height_shift_range=0.1, # Shift images vertically by up to 10% of the height\n",
        "        # shear_range=0.2,        # Apply shear transformation\n",
        "        # zoom_range=0.1,         # Zoom in/out on images by up to 20%\n",
        "        horizontal_flip=True,  # Flip images horizontally\n",
        "        # vertical_flip=True,    # Flip images vertically\n",
        "        # fill_mode='nearest'     # Fill missing pixels using the nearest value\n",
        "    )\n",
        "\n",
        "    # Fit the ImageDataGenerator on the training data\n",
        "    datagen.fit(X_train)\n",
        "\n",
        "    # Create a generator to yield augmented data batches\n",
        "    aug_generator = datagen.flow(X_train, y_train, batch_size=batch_size)\n",
        "\n",
        "    # Return the augmented data generator\n",
        "    return aug_generator\n"
      ],
      "metadata": {
        "id": "3G1bKPuceoGu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.models import Sequential\n",
        "from keras.layers import Dense, Dropout, BatchNormalization\n",
        "from keras.layers import Flatten, Conv2D, MaxPooling2D\n",
        "from keras.initializers import Zeros, GlorotNormal\n",
        "\n",
        "def CNN():\n",
        "  model = Sequential()\n",
        "\n",
        "  model.add(Conv2D(32, kernel_size=(3, 3), strides=(3, 3), activation='relu', input_shape=(64, 64, 1),\n",
        "                  kernel_initializer=GlorotNormal(), bias_initializer=Zeros()))\n",
        "  model.add(BatchNormalization())\n",
        "\n",
        "  model.add(Conv2D(16, kernel_size=(3, 3), strides=(3, 3), activation='relu',\n",
        "                  kernel_initializer=GlorotNormal(), bias_initializer=Zeros()))\n",
        "  model.add(MaxPooling2D(pool_size=(3, 3)))\n",
        "  model.add(BatchNormalization())\n",
        "  model.add(Dropout(0.25))\n",
        "\n",
        "  model.add(Flatten())\n",
        "\n",
        "  model.add(Dense(128, activation='relu', kernel_initializer=GlorotNormal(), bias_initializer=Zeros()))\n",
        "  model.add(Dropout(0.5))\n",
        "\n",
        "  model.add(Dense(1, activation='sigmoid', kernel_initializer=GlorotNormal(), bias_initializer=Zeros()))\n",
        "\n",
        "  model.summary()\n",
        "  model.compile(loss='binary_crossentropy', optimizer='nadam', metrics=['accuracy'])\n",
        "\n",
        "  return model"
      ],
      "metadata": {
        "id": "-epPzSJFZ2UC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "def plot_accuracy(history):\n",
        "    plt.plot(history.history['accuracy'])\n",
        "    plt.plot(history.history['val_accuracy'])\n",
        "    plt.title('Model Accuracy')\n",
        "    plt.xlabel('Epoch')\n",
        "    plt.ylabel('Accuracy')\n",
        "    plt.legend(['Train', 'Validation'], loc='upper left')\n",
        "    plt.show()\n",
        "\n",
        "def plot_loss(history):\n",
        "    plt.plot(history.history['loss'])\n",
        "    plt.plot(history.history['val_loss'])\n",
        "    plt.title('Model Loss')\n",
        "    plt.xlabel('Epoch')\n",
        "    plt.ylabel('Loss')\n",
        "    plt.legend(['Train', 'Validation'], loc='upper left')\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "Qqf8ddcJdlcg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "BATCH_SIZE = 32\n",
        "EPOCHS = 20"
      ],
      "metadata": {
        "id": "M24XdwyPcBqQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = CNN()\n",
        "history = model.fit(X_train, y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=1, validation_data=(X_valid, y_valid))\n",
        "print(model.evaluate(X_test, y_test))\n",
        "plot_accuracy(history)\n",
        "plot_loss(history)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "K5IubO8_Zy_q",
        "outputId": "2f0cdf15-dc96-49be-c60f-30e1a4f451ab"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_7\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d_14 (Conv2D)          (None, 21, 21, 32)        320       \n",
            "                                                                 \n",
            " batch_normalization_14 (Ba  (None, 21, 21, 32)        128       \n",
            " tchNormalization)                                               \n",
            "                                                                 \n",
            " conv2d_15 (Conv2D)          (None, 7, 7, 16)          4624      \n",
            "                                                                 \n",
            " max_pooling2d_7 (MaxPoolin  (None, 2, 2, 16)          0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " batch_normalization_15 (Ba  (None, 2, 2, 16)          64        \n",
            " tchNormalization)                                               \n",
            "                                                                 \n",
            " dropout_14 (Dropout)        (None, 2, 2, 16)          0         \n",
            "                                                                 \n",
            " flatten_7 (Flatten)         (None, 64)                0         \n",
            "                                                                 \n",
            " dense_14 (Dense)            (None, 128)               8320      \n",
            "                                                                 \n",
            " dropout_15 (Dropout)        (None, 128)               0         \n",
            "                                                                 \n",
            " dense_15 (Dense)            (None, 1)                 129       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 13585 (53.07 KB)\n",
            "Trainable params: 13489 (52.69 KB)\n",
            "Non-trainable params: 96 (384.00 Byte)\n",
            "_________________________________________________________________\n",
            "Epoch 1/20\n",
            "289/289 [==============================] - 13s 34ms/step - loss: 0.6210 - accuracy: 0.6672 - val_loss: 0.6272 - val_accuracy: 0.6087\n",
            "Epoch 2/20\n",
            "289/289 [==============================] - 8s 27ms/step - loss: 0.4749 - accuracy: 0.7774 - val_loss: 0.5169 - val_accuracy: 0.7096\n",
            "Epoch 3/20\n",
            "289/289 [==============================] - 6s 19ms/step - loss: 0.3963 - accuracy: 0.8237 - val_loss: 0.5207 - val_accuracy: 0.7922\n",
            "Epoch 4/20\n",
            "289/289 [==============================] - 5s 16ms/step - loss: 0.3494 - accuracy: 0.8545 - val_loss: 0.4143 - val_accuracy: 0.8505\n",
            "Epoch 5/20\n",
            "289/289 [==============================] - 6s 22ms/step - loss: 0.3046 - accuracy: 0.8771 - val_loss: 0.3842 - val_accuracy: 0.8445\n",
            "Epoch 6/20\n",
            "289/289 [==============================] - 6s 20ms/step - loss: 0.2745 - accuracy: 0.8904 - val_loss: 0.4400 - val_accuracy: 0.8408\n",
            "Epoch 7/20\n",
            "289/289 [==============================] - 6s 21ms/step - loss: 0.2495 - accuracy: 0.9000 - val_loss: 0.4219 - val_accuracy: 0.8663\n",
            "Epoch 8/20\n",
            "289/289 [==============================] - 5s 18ms/step - loss: 0.2391 - accuracy: 0.9079 - val_loss: 0.3298 - val_accuracy: 0.8858\n",
            "Epoch 9/20\n",
            "289/289 [==============================] - 5s 17ms/step - loss: 0.2172 - accuracy: 0.9129 - val_loss: 0.3178 - val_accuracy: 0.8894\n",
            "Epoch 10/20\n",
            "289/289 [==============================] - 6s 22ms/step - loss: 0.2090 - accuracy: 0.9166 - val_loss: 0.3109 - val_accuracy: 0.8882\n",
            "Epoch 11/20\n",
            "289/289 [==============================] - 5s 16ms/step - loss: 0.2011 - accuracy: 0.9218 - val_loss: 0.2879 - val_accuracy: 0.9028\n",
            "Epoch 12/20\n",
            "289/289 [==============================] - 5s 17ms/step - loss: 0.1882 - accuracy: 0.9297 - val_loss: 0.2708 - val_accuracy: 0.8858\n",
            "Epoch 13/20\n",
            "289/289 [==============================] - 6s 21ms/step - loss: 0.1810 - accuracy: 0.9310 - val_loss: 0.2951 - val_accuracy: 0.9016\n",
            "Epoch 14/20\n",
            "289/289 [==============================] - 5s 16ms/step - loss: 0.1739 - accuracy: 0.9370 - val_loss: 0.2345 - val_accuracy: 0.9113\n",
            "Epoch 15/20\n",
            "289/289 [==============================] - 6s 21ms/step - loss: 0.1634 - accuracy: 0.9415 - val_loss: 0.4384 - val_accuracy: 0.8092\n",
            "Epoch 16/20\n",
            "289/289 [==============================] - 5s 16ms/step - loss: 0.1564 - accuracy: 0.9425 - val_loss: 0.2512 - val_accuracy: 0.9077\n",
            "Epoch 17/20\n",
            "289/289 [==============================] - 5s 16ms/step - loss: 0.1552 - accuracy: 0.9425 - val_loss: 0.2961 - val_accuracy: 0.8943\n",
            "Epoch 18/20\n",
            "289/289 [==============================] - 7s 25ms/step - loss: 0.1524 - accuracy: 0.9450 - val_loss: 0.3160 - val_accuracy: 0.8906\n",
            "Epoch 19/20\n",
            "289/289 [==============================] - 5s 16ms/step - loss: 0.1366 - accuracy: 0.9502 - val_loss: 0.2349 - val_accuracy: 0.9125\n",
            "Epoch 20/20\n",
            "289/289 [==============================] - 5s 18ms/step - loss: 0.1435 - accuracy: 0.9496 - val_loss: 0.2205 - val_accuracy: 0.9210\n",
            "16/16 [==============================] - 0s 6ms/step - loss: 0.1968 - accuracy: 0.9280\n",
            "[0.19679298996925354, 0.9279999732971191]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "augmented_generator = augment_data(X_train, y_train)\n",
        "\n",
        "model = CNN()\n",
        "history = model.fit(augmented_generator, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=1, validation_data=(X_valid, y_valid))\n",
        "print(model.evaluate(X_test, y_test))\n",
        "plot_accuracy(history)\n",
        "plot_loss(history)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "kLRW2Li9cNad",
        "outputId": "1da5f251-0869-4e34-e9a2-2f3839d300e8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_14\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d_28 (Conv2D)          (None, 21, 21, 32)        320       \n",
            "                                                                 \n",
            " batch_normalization_28 (Ba  (None, 21, 21, 32)        128       \n",
            " tchNormalization)                                               \n",
            "                                                                 \n",
            " conv2d_29 (Conv2D)          (None, 7, 7, 16)          4624      \n",
            "                                                                 \n",
            " max_pooling2d_14 (MaxPooli  (None, 2, 2, 16)          0         \n",
            " ng2D)                                                           \n",
            "                                                                 \n",
            " batch_normalization_29 (Ba  (None, 2, 2, 16)          64        \n",
            " tchNormalization)                                               \n",
            "                                                                 \n",
            " dropout_28 (Dropout)        (None, 2, 2, 16)          0         \n",
            "                                                                 \n",
            " flatten_14 (Flatten)        (None, 64)                0         \n",
            "                                                                 \n",
            " dense_28 (Dense)            (None, 128)               8320      \n",
            "                                                                 \n",
            " dropout_29 (Dropout)        (None, 128)               0         \n",
            "                                                                 \n",
            " dense_29 (Dense)            (None, 1)                 129       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 13585 (53.07 KB)\n",
            "Trainable params: 13489 (52.69 KB)\n",
            "Non-trainable params: 96 (384.00 Byte)\n",
            "_________________________________________________________________\n",
            "Epoch 1/20\n",
            "289/289 [==============================] - 9s 23ms/step - loss: 0.6340 - accuracy: 0.6562 - val_loss: 0.6363 - val_accuracy: 0.6075\n",
            "Epoch 2/20\n",
            "289/289 [==============================] - 5s 17ms/step - loss: 0.5423 - accuracy: 0.7329 - val_loss: 0.5040 - val_accuracy: 0.7801\n",
            "Epoch 3/20\n",
            "289/289 [==============================] - 7s 23ms/step - loss: 0.4974 - accuracy: 0.7683 - val_loss: 0.4493 - val_accuracy: 0.8080\n",
            "Epoch 4/20\n",
            "289/289 [==============================] - 5s 17ms/step - loss: 0.4667 - accuracy: 0.7869 - val_loss: 0.4301 - val_accuracy: 0.8165\n",
            "Epoch 5/20\n",
            "289/289 [==============================] - 7s 23ms/step - loss: 0.4321 - accuracy: 0.8050 - val_loss: 0.4237 - val_accuracy: 0.8408\n",
            "Epoch 6/20\n",
            "289/289 [==============================] - 5s 18ms/step - loss: 0.4118 - accuracy: 0.8176 - val_loss: 0.4172 - val_accuracy: 0.8202\n",
            "Epoch 7/20\n",
            "289/289 [==============================] - 5s 18ms/step - loss: 0.3922 - accuracy: 0.8272 - val_loss: 0.4127 - val_accuracy: 0.8250\n",
            "Epoch 8/20\n",
            "289/289 [==============================] - 7s 23ms/step - loss: 0.3715 - accuracy: 0.8386 - val_loss: 0.4246 - val_accuracy: 0.8372\n",
            "Epoch 9/20\n",
            "289/289 [==============================] - 5s 17ms/step - loss: 0.3464 - accuracy: 0.8502 - val_loss: 0.4046 - val_accuracy: 0.8384\n",
            "Epoch 10/20\n",
            "289/289 [==============================] - 6s 19ms/step - loss: 0.3363 - accuracy: 0.8578 - val_loss: 0.3959 - val_accuracy: 0.8275\n",
            "Epoch 11/20\n",
            "289/289 [==============================] - 5s 18ms/step - loss: 0.3286 - accuracy: 0.8614 - val_loss: 0.4085 - val_accuracy: 0.8457\n",
            "Epoch 12/20\n",
            "289/289 [==============================] - 7s 23ms/step - loss: 0.3223 - accuracy: 0.8693 - val_loss: 0.4199 - val_accuracy: 0.8408\n",
            "Epoch 13/20\n",
            "289/289 [==============================] - 5s 18ms/step - loss: 0.3050 - accuracy: 0.8715 - val_loss: 0.3645 - val_accuracy: 0.8542\n",
            "Epoch 14/20\n",
            "289/289 [==============================] - 6s 21ms/step - loss: 0.2913 - accuracy: 0.8789 - val_loss: 0.3197 - val_accuracy: 0.8724\n",
            "Epoch 15/20\n",
            "289/289 [==============================] - 7s 24ms/step - loss: 0.2880 - accuracy: 0.8805 - val_loss: 0.3406 - val_accuracy: 0.8785\n",
            "Epoch 16/20\n",
            "289/289 [==============================] - 5s 19ms/step - loss: 0.2783 - accuracy: 0.8853 - val_loss: 0.3347 - val_accuracy: 0.8639\n",
            "Epoch 17/20\n",
            "289/289 [==============================] - 6s 22ms/step - loss: 0.2638 - accuracy: 0.8908 - val_loss: 0.3418 - val_accuracy: 0.8688\n",
            "Epoch 18/20\n",
            "289/289 [==============================] - 5s 17ms/step - loss: 0.2555 - accuracy: 0.8960 - val_loss: 0.3604 - val_accuracy: 0.8566\n",
            "Epoch 19/20\n",
            "289/289 [==============================] - 7s 23ms/step - loss: 0.2628 - accuracy: 0.8952 - val_loss: 0.3035 - val_accuracy: 0.8797\n",
            "Epoch 20/20\n",
            "289/289 [==============================] - 5s 18ms/step - loss: 0.2414 - accuracy: 0.9050 - val_loss: 0.3464 - val_accuracy: 0.8797\n",
            "16/16 [==============================] - 0s 6ms/step - loss: 0.3620 - accuracy: 0.8680\n",
            "[0.36200207471847534, 0.8679999709129333]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "import os\n",
        "\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2jt3j8I-91Uf",
        "outputId": "a35186e7-eec1-4a5a-8632-e39aa58999bd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from tqdm import tqdm\n",
        "\n",
        "\n",
        "def shuffle_data(x_train, y_train):\n",
        "    # Generate random permutation of indices\n",
        "    num_samples = x_train.shape[0]\n",
        "    permutation = np.random.permutation(num_samples)\n",
        "\n",
        "    # Shuffle both x_train and y_train using the same permutation\n",
        "    shuffled_x_train = x_train[permutation]\n",
        "    shuffled_y_train = y_train[permutation]\n",
        "\n",
        "    return shuffled_x_train, shuffled_y_train\n",
        "\n",
        "\n",
        "def add_synthetic_data(data_dir, x_train, y_train, label):\n",
        "  synthetic_x_train = []\n",
        "  synthetic_y_train = []\n",
        "  for img_name in tqdm(os.listdir(data_dir)):\n",
        "      img_path = os.path.join(data_dir, img_name)\n",
        "\n",
        "      # Load the image\n",
        "      try:\n",
        "          img = load_img(img_path, color_mode=\"grayscale\")\n",
        "      except OSError as e:\n",
        "          if \"truncated\" in str(e):\n",
        "              #print(f\"Error: Image {img_path} is truncated. Skipping it.\")\n",
        "              continue\n",
        "          else:\n",
        "              raise  # Raise the exception for other errors\n",
        "\n",
        "      # Convert to NumPy array\n",
        "      img_array = img_to_array(img)\n",
        "\n",
        "      # Reshape for model input (1 channel for grayscale)\n",
        "      img_array = img_array.reshape(64, 64, 1).astype('float32')\n",
        "\n",
        "      synthetic_x_train.append(img_array)\n",
        "      synthetic_y_train.append(label)\n",
        "\n",
        "  # Convert lists to Numpy arrays\n",
        "  synthetic_x_train = np.array(synthetic_x_train)\n",
        "  synthetic_y_train = np.array(synthetic_y_train)\n",
        "\n",
        "  # Concatenate with existing data\n",
        "  if x_train is not None:\n",
        "    synthetic_x_train = np.concatenate((x_train, synthetic_x_train), axis=0)\n",
        "  if y_train is not None:\n",
        "    synthetic_y_train = np.concatenate((y_train, synthetic_y_train), axis=0)\n",
        "\n",
        "  # shuffle the data\n",
        "  synthetic_x_train, synthetic_y_train = shuffle_data(synthetic_x_train, synthetic_y_train)\n",
        "\n",
        "  return synthetic_x_train, synthetic_y_train\n",
        "\n"
      ],
      "metadata": {
        "id": "x33GWce69hvy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "UNFRACTURED_SYNTHETIC_DATA_DIR = '/content/drive/MyDrive/unfrac_generated_images/'\n",
        "FRACTURED_SYNTHETIC_DATA_DIR = '/content/drive/MyDrive/generated_fractured_images/'\n",
        "\n",
        "X_train_synthetic = X_train.copy()\n",
        "y_train_synthetic = y_train.copy()\n",
        "print(X_train_synthetic.shape, y_train_synthetic.shape)\n",
        "\n",
        "X_train_synthetic, y_train_synthetic = add_synthetic_data(UNFRACTURED_SYNTHETIC_DATA_DIR, X_train_synthetic, y_train_synthetic, 0)\n",
        "print(X_train_synthetic.shape, y_train_synthetic.shape)\n",
        "\n",
        "X_train_synthetic, y_train_synthetic = add_synthetic_data(FRACTURED_SYNTHETIC_DATA_DIR, X_train_synthetic, y_train_synthetic, 1)\n",
        "print(X_train_synthetic.shape, y_train_synthetic.shape)\n",
        "\n",
        "model = CNN()\n",
        "history = model.fit(X_train_synthetic, y_train_synthetic, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=1, validation_data=(X_valid, y_valid))\n",
        "print(model.evaluate(X_test, y_test))\n",
        "plot_accuracy(history)\n",
        "plot_loss(history)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 412
        },
        "id": "ap2UCRhY1aUU",
        "outputId": "bb6f44dd-3ef3-4178-ac43-48ce36a48f8c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(9240, 64, 64, 1) (9240,)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  0%|          | 0/4830 [00:00<?, ?it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 64, 64, 1) (1,)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-29-633ab3dced1b>\u001b[0m in \u001b[0;36m<cell line: 11>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train_synthetic\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train_synthetic\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mX_train_synthetic\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train_synthetic\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0madd_synthetic_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFRACTURED_SYNTHETIC_DATA_DIR\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX_train_synthetic\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train_synthetic\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train_synthetic\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train_synthetic\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-28-6f99900fde4a>\u001b[0m in \u001b[0;36madd_synthetic_data\u001b[0;34m(data_dir, x_train, y_train, label)\u001b[0m\n\u001b[1;32m     17\u001b[0m   \u001b[0msynthetic_x_train\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m   \u001b[0msynthetic_y_train\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 19\u001b[0;31m   \u001b[0;32mfor\u001b[0m \u001b[0mimg_name\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtqdm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlistdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_dir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     20\u001b[0m       \u001b[0mimg_path\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimg_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     21\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X_train_synthetic, y_train_synthetic = add_synthetic_data(UNFRACTURED_SYNTHETIC_DATA_DIR, None, None, 0)\n",
        "print(X_train_synthetic.shape, y_train_synthetic.shape)\n",
        "\n",
        "X_train_synthetic, y_train_synthetic = add_synthetic_data(FRACTURED_SYNTHETIC_DATA_DIR, X_train_synthetic, y_train_synthetic, 1)\n",
        "print(X_train_synthetic.shape, y_train_synthetic.shape)\n",
        "\n",
        "model = CNN()\n",
        "\n",
        "# warm start model on synthetic data\n",
        "history = model.fit(X_train_synthetic, y_train_synthetic, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=1, validation_data=(X_valid, y_valid))\n",
        "\n",
        "# train model on real data\n",
        "history = model.fit(X_train, y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=1, validation_data=(X_valid, y_valid))\n",
        "\n",
        "print(model.evaluate(X_test, y_test))\n",
        "plot_accuracy(history)\n",
        "plot_loss(history)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KV7uXGVsBgu3",
        "outputId": "8f80f396-e348-4524-ed92-34b885f3b531"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 4830/4830 [02:22<00:00, 33.79it/s] \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(4830, 64, 64, 1) (4830,)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  1%|          | 116/10500 [00:47<2:01:07,  1.43it/s]"
          ]
        }
      ]
    }
  ]
}