Fracture-own_model2.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "jwZ32SflMoll"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from keras import Sequential\n",
        "from keras import layers\n",
        "from keras.layers import Dense,Conv2D,MaxPooling2D,Flatten,BatchNormalization,Dropout,AveragePooling2D\n",
        "from keras.layers import Activation, Dropout, Flatten, Dense, GaussianNoise, GlobalMaxPooling2D\n",
        "import tensorflow as tf\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import cv2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_eyE3rRc0EMF",
        "outputId": "fec610f0-7ebd-4561-8155-a4f1a18b0b8c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Found 8863 images belonging to 2 classes.\n",
            "Found 600 images belonging to 2 classes.\n"
          ]
        }
      ],
      "source": [
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "# Define data generators for train and test sets\n",
        "train_datagen = ImageDataGenerator(rescale=1./255)\n",
        "test_datagen = ImageDataGenerator(rescale=1./255)\n",
        "\n",
        "# Flow images from directory in batches\n",
        "Xtrain= train_datagen.flow_from_directory(\n",
        "    directory='/Users/sukanya/Downloads/dataset_fracture/train',\n",
        "    target_size=(256, 256),\n",
        "    batch_size=100,\n",
        "    class_mode='binary'\n",
        ")\n",
        "\n",
        "Xtest = test_datagen.flow_from_directory(\n",
        "    directory='/Users/sukanya/Downloads/dataset_fracture/val',\n",
        "    target_size=(256, 256),\n",
        "    batch_size=100,\n",
        "    class_mode='binary'\n",
        ")\n",
        "\n",
        "# Optionally, if you want to convert class labels to integers\n",
        "class_indices = Xtrain.class_indices\n",
        "train_dataset = (Xtrain, class_indices)\n",
        "test_dataset = (Xtest, class_indices)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "gxMa58Y-0PwT"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "\n",
        "# Define a function to normalize images\n",
        "def process(image, label):\n",
        "    image = tf.cast(image / 255., tf.float32)\n",
        "    return image, label\n",
        "\n",
        "# Convert DirectoryIterator objects to tf.data.Dataset objects\n",
        "train_dataset = tf.data.Dataset.from_generator(\n",
        "    lambda: Xtrain,\n",
        "    output_signature=(\n",
        "        tf.TensorSpec(shape=(None, 256, 256, 3), dtype=tf.float32),\n",
        "        tf.TensorSpec(shape=(None,), dtype=tf.int32)\n",
        "    )\n",
        ")\n",
        "\n",
        "test_dataset = tf.data.Dataset.from_generator(\n",
        "    lambda: Xtest,\n",
        "    output_signature=(\n",
        "        tf.TensorSpec(shape=(None, 256, 256, 3), dtype=tf.float32),\n",
        "        tf.TensorSpec(shape=(None,), dtype=tf.int32)\n",
        "    )\n",
        ")\n",
        "\n",
        "# Apply normalization using the map function\n",
        "x_train = train_dataset.map(process)\n",
        "x_test = test_dataset.map(process)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "EYo4lIl2M6aO"
      },
      "outputs": [],
      "source": [
        "input_shape = (256, 256, 3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "_VC8ejjSDS7_"
      },
      "outputs": [],
      "source": [
        "#model\n",
        "model = Sequential()\n",
        "model.add(Conv2D(32, (3, 3), padding='same', activation='relu', input_shape=input_shape))\n",
        "model.add(GaussianNoise(0.1))\n",
        "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "model.add(Dropout(0.25))\n",
        "\n",
        "model.add(Conv2D(64, (3, 3), padding='same', activation='relu'))\n",
        "model.add(AveragePooling2D(pool_size=(2, 2)))\n",
        "model.add(Dropout(0.25))\n",
        "\n",
        "model.add(Conv2D(128, (3, 3), padding='same', activation='relu'))\n",
        "model.add(GaussianNoise(0.1))\n",
        "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "model.add(Dropout(0.25))\n",
        "\n",
        "model.add(Conv2D(256, (3, 3), padding='same', activation='relu'))\n",
        "model.add(GaussianNoise(0.1))\n",
        "model.add(AveragePooling2D(pool_size=(2, 2)))\n",
        "model.add(Dropout(0.25))\n",
        "\n",
        "model.add(Conv2D(512, (3, 3), padding='same', activation='relu'))\n",
        "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "model.add(Dropout(0.25))\n",
        "\n",
        "model.add(Flatten())\n",
        "model.add(Dense(512, activation='relu'))\n",
        "model.add(Dense(1, activation='sigmoid'))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ElJNhexgB1v5",
        "outputId": "b99a92dc-8ea5-4ef4-f43c-27d993f8c92b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 256, 256, 32)      896       \n",
            "                                                                 \n",
            " gaussian_noise (GaussianNo  (None, 256, 256, 32)      0         \n",
            " ise)                                                            \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2  (None, 128, 128, 32)      0         \n",
            " D)                                                              \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 128, 128, 32)      0         \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 128, 128, 64)      18496     \n",
            "                                                                 \n",
            " average_pooling2d (Average  (None, 64, 64, 64)        0         \n",
            " Pooling2D)                                                      \n",
            "                                                                 \n",
            " dropout_1 (Dropout)         (None, 64, 64, 64)        0         \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 64, 64, 128)       73856     \n",
            "                                                                 \n",
            " gaussian_noise_1 (Gaussian  (None, 64, 64, 128)       0         \n",
            " Noise)                                                          \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPoolin  (None, 32, 32, 128)       0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " dropout_2 (Dropout)         (None, 32, 32, 128)       0         \n",
            "                                                                 \n",
            " conv2d_3 (Conv2D)           (None, 32, 32, 256)       295168    \n",
            "                                                                 \n",
            " gaussian_noise_2 (Gaussian  (None, 32, 32, 256)       0         \n",
            " Noise)                                                          \n",
            "                                                                 \n",
            " average_pooling2d_1 (Avera  (None, 16, 16, 256)       0         \n",
            " gePooling2D)                                                    \n",
            "                                                                 \n",
            " dropout_3 (Dropout)         (None, 16, 16, 256)       0         \n",
            "                                                                 \n",
            " conv2d_4 (Conv2D)           (None, 16, 16, 512)       1180160   \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPoolin  (None, 8, 8, 512)         0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " dropout_4 (Dropout)         (None, 8, 8, 512)         0         \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 32768)             0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 512)               16777728  \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 1)                 513       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 18346817 (69.99 MB)\n",
            "Trainable params: 18346817 (69.99 MB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "r2RfYW9a0ih2"
      },
      "outputs": [],
      "source": [
        "model.compile(optimizer=\"adam\", loss=\"binary_crossentropy\", metrics=[\"accuracy\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HHBFNFHCtzLu",
        "outputId": "51bcc58f-2f99-4f20-a3b9-d04a639903de"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n",
            "89/89 [==============================] - 227s 3s/step - loss: 0.9029 - accuracy: 0.4996 - val_loss: 0.6924 - val_accuracy: 0.6000\n",
            "Epoch 2/10\n",
            "89/89 [==============================] - 223s 3s/step - loss: 0.6931 - accuracy: 0.5055 - val_loss: 0.6916 - val_accuracy: 0.6000\n",
            "Epoch 3/10\n",
            "89/89 [==============================] - 228s 3s/step - loss: 0.6931 - accuracy: 0.5055 - val_loss: 0.6916 - val_accuracy: 0.6000\n",
            "Epoch 4/10\n",
            "89/89 [==============================] - 233s 3s/step - loss: 0.6931 - accuracy: 0.5055 - val_loss: 0.6916 - val_accuracy: 0.6000\n",
            "Epoch 5/10\n",
            "89/89 [==============================] - 240s 3s/step - loss: 0.6931 - accuracy: 0.5055 - val_loss: 0.6910 - val_accuracy: 0.6000\n",
            "Epoch 6/10\n",
            "89/89 [==============================] - 232s 3s/step - loss: 0.6933 - accuracy: 0.5001 - val_loss: 0.6910 - val_accuracy: 0.6000\n",
            "Epoch 7/10\n",
            "89/89 [==============================] - 227s 3s/step - loss: 0.6937 - accuracy: 0.5039 - val_loss: 0.6928 - val_accuracy: 0.6000\n",
            "Epoch 8/10\n",
            "89/89 [==============================] - 221s 2s/step - loss: 0.6939 - accuracy: 0.5003 - val_loss: 0.6924 - val_accuracy: 0.6000\n",
            "Epoch 9/10\n",
            "89/89 [==============================] - 221s 2s/step - loss: 0.6935 - accuracy: 0.5064 - val_loss: 0.6922 - val_accuracy: 0.6000\n",
            "Epoch 10/10\n",
            "89/89 [==============================] - 222s 2s/step - loss: 0.6932 - accuracy: 0.5032 - val_loss: 0.6925 - val_accuracy: 0.6000\n"
          ]
        }
      ],
      "source": [
        "batch_size = min(100, len(Xtrain))\n",
        "history = model.fit(Xtrain, epochs=10, batch_size=batch_size, validation_data=Xtest)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {},
      "outputs": [],
      "source": [
        "y_test = Xtest.classes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "6/6 [==============================] - 3s 556ms/step\n",
            "Accuracy: 0.6\n",
            "Precision: 0.0\n",
            "Recall: 0.0\n",
            "F1-score: 0.0\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/opt/homebrew/lib/python3.11/site-packages/sklearn/metrics/_classification.py:1497: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
          ]
        }
      ],
      "source": [
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n",
        "\n",
        "# Assuming you have model predictions and true labels\n",
        "predictions = model.predict(Xtest)\n",
        "predicted_labels = (predictions > 0.5).astype(int)\n",
        "true_labels = y_test\n",
        "\n",
        "# Calculate metrics\n",
        "accuracy = accuracy_score(true_labels, predicted_labels)\n",
        "precision = precision_score(true_labels, predicted_labels)\n",
        "recall = recall_score(true_labels, predicted_labels)\n",
        "f1 = f1_score(true_labels, predicted_labels)\n",
        "\n",
        "# Print metrics\n",
        "print(\"Accuracy:\", accuracy)\n",
        "print(\"Precision:\", precision)\n",
        "print(\"Recall:\", recall)\n",
        "print(\"F1-score:\", f1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Plot training and validation accuracy\n",
        "plt.plot(history.history['accuracy'], label='Training Accuracy')\n",
        "plt.plot(history.history['val_accuracy'], label='Validation Accuracy')\n",
        "plt.title('Training and Validation Accuracy')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "# Plot training and validation loss\n",
        "plt.plot(history.history['loss'], label='Training Loss')\n",
        "plt.plot(history.history['val_loss'], label='Validation Loss')\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "6/6 [==============================] - 4s 570ms/step\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x600 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "import seaborn as sns\n",
        "import numpy as np\n",
        "\n",
        "# Get model predictions for the test dataset\n",
        "y_pred = model.predict(Xtest)\n",
        "y_pred_classes = np.argmax(y_pred, axis=1)\n",
        "\n",
        "# Compute confusion matrix\n",
        "conf_matrix = confusion_matrix(y_test, y_pred_classes)\n",
        "\n",
        "# Plot confusion matrix\n",
        "plt.figure(figsize=(8, 6))\n",
        "sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', \n",
        "            xticklabels=['Fracture', 'Non-Fracture'], \n",
        "            yticklabels=['Fracture', 'Non-Fracture'])\n",
        "plt.title('Confusion Matrix')\n",
        "plt.xlabel('Predicted Label')\n",
        "plt.ylabel('True Label')\n",
        "plt.show()"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.7"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}