{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9f61bdd9-8d14-475b-b53b-e7e9132a1884",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import Libraries\n",
    "import os\n",
    "import shutil\n",
    "import random\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout\n",
    "from tensorflow.keras.optimizers import Adam\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "2bb9d6f0-2132-4190-8a35-3e864f0a4343",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Define paths\n",
    "original_dataset_dir = r\"C:\\Users\\X1 YOGA\\Downloads\\Animal_Image_Dataset\\dogs_vs_cats\\All_Data\\cats\"\n",
    "base_dir = r\"C:\\Users\\X1 YOGA\\Downloads\\Animal_dataset_spilt\"\n",
    "classes = ['Cat', 'Dog']\n",
    "split_ratios = {'train': 0.7, 'val': 0.15, 'test': 0.15}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ca1894a8-0858-4eb1-81d3-2657d192c8bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset splitting complete.\n"
     ]
    }
   ],
   "source": [
    "#Create split folders\n",
    "for split in split_ratios:\n",
    "    for class_name in classes:\n",
    "        os.makedirs(os.path.join(base_dir, split, class_name), exist_ok=True)\n",
    "\n",
    "#Split and move files\n",
    "cat_images = [f for f in os.listdir(original_dataset_dir) if f.startswith('cat')]\n",
    "dog_images = [f for f in os.listdir(original_dataset_dir) if f.startswith('dog')]\n",
    "random.shuffle(cat_images)\n",
    "random.shuffle(dog_images)\n",
    "\n",
    "def split_and_copy(images, class_name):\n",
    "    total = len(images)\n",
    "    train_end = int(split_ratios['train'] * total)\n",
    "    val_end = train_end + int(split_ratios['val'] * total)\n",
    "\n",
    "    split_data = {\n",
    "        'train': images[:train_end],\n",
    "        'val': images[train_end:val_end],\n",
    "        'test': images[val_end:]\n",
    "    }\n",
    "\n",
    "    for split, image_list in split_data.items():\n",
    "        for img in image_list:\n",
    "            src = os.path.join(original_dataset_dir, img)\n",
    "            dst = os.path.join(base_dir, split, class_name, img)\n",
    "            shutil.copyfile(src, dst)\n",
    "\n",
    "split_and_copy(cat_images, 'Cat')\n",
    "split_and_copy(dog_images, 'Dog')\n",
    "\n",
    "print(\"Dataset splitting complete.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "85e23e54-701b-401f-a9f4-c05073f4e99d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 7197 images belonging to 2 classes.\n",
      "Found 1500 images belonging to 2 classes.\n",
      "Found 1500 images belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "#Apply data augmentation & generators\n",
    "img_size = (150, 150)\n",
    "batch_size = 32\n",
    "\n",
    "train_datagen = ImageDataGenerator(\n",
    "    rescale=1./255,\n",
    "    rotation_range=20,\n",
    "    zoom_range=0.2,\n",
    "    horizontal_flip=True\n",
    ")\n",
    "\n",
    "val_test_datagen = ImageDataGenerator(rescale=1./255)\n",
    "\n",
    "train_gen = train_datagen.flow_from_directory(\n",
    "    os.path.join(base_dir, 'train'),\n",
    "    target_size=img_size,\n",
    "    batch_size=batch_size,\n",
    "    class_mode='binary'\n",
    ")\n",
    "\n",
    "val_gen = val_test_datagen.flow_from_directory(\n",
    "    os.path.join(base_dir, 'val'),\n",
    "    target_size=img_size,\n",
    "    batch_size=batch_size,\n",
    "    class_mode='binary'\n",
    ")\n",
    "\n",
    "test_gen = val_test_datagen.flow_from_directory(\n",
    "    os.path.join(base_dir, 'test'),\n",
    "    target_size=img_size,\n",
    "    batch_size=batch_size,\n",
    "    class_mode='binary')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9c41f831-b0a1-4ce7-b8ef-d81d21cffd9b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\X1 YOGA\\anaconda3\\envs\\Drive_Guard\\Lib\\site-packages\\keras\\src\\layers\\convolutional\\base_conv.py:113: 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"
     ]
    }
   ],
   "source": [
    "#Build CNN model\n",
    "model = Sequential([\n",
    "    Conv2D(32, (3,3), activation='relu', input_shape=(150,150,3)),\n",
    "    MaxPooling2D(2,2),\n",
    "    Conv2D(64, (3,3), activation='relu'),\n",
    "    MaxPooling2D(2,2),\n",
    "    Flatten(),\n",
    "    Dense(64, activation='relu'),\n",
    "    Dropout(0.5),\n",
    "    Dense(1, activation='sigmoid')  # Binary classification\n",
    "])\n",
    "\n",
    "model.compile(optimizer=Adam(), loss='binary_crossentropy', metrics=['accuracy'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "0508989b-0cba-4c58-acb8-19eadd06e150",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\X1 YOGA\\anaconda3\\envs\\Drive_Guard\\Lib\\site-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": [
      "Epoch 1/10\n",
      "\u001b[1m225/225\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m185s\u001b[0m 817ms/step - accuracy: 0.9934 - loss: 0.0169 - val_accuracy: 1.0000 - val_loss: 0.0000e+00\n",
      "Epoch 2/10\n",
      "\u001b[1m225/225\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m71s\u001b[0m 315ms/step - accuracy: 1.0000 - loss: 2.8460e-28 - val_accuracy: 1.0000 - val_loss: 0.0000e+00\n",
      "Epoch 3/10\n",
      "\u001b[1m225/225\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m72s\u001b[0m 318ms/step - accuracy: 1.0000 - loss: 1.9676e-33 - val_accuracy: 1.0000 - val_loss: 0.0000e+00\n",
      "Epoch 4/10\n",
      "\u001b[1m225/225\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m110s\u001b[0m 489ms/step - accuracy: 1.0000 - loss: 7.7376e-31 - val_accuracy: 1.0000 - val_loss: 0.0000e+00\n",
      "Epoch 5/10\n",
      "\u001b[1m225/225\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m96s\u001b[0m 424ms/step - accuracy: 1.0000 - loss: 1.1312e-26 - val_accuracy: 1.0000 - val_loss: 0.0000e+00\n",
      "Epoch 6/10\n",
      "\u001b[1m225/225\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m118s\u001b[0m 523ms/step - accuracy: 1.0000 - loss: 1.0607e-21 - val_accuracy: 1.0000 - val_loss: 0.0000e+00\n",
      "Epoch 7/10\n",
      "\u001b[1m225/225\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m99s\u001b[0m 439ms/step - accuracy: 1.0000 - loss: 9.0084e-25 - val_accuracy: 1.0000 - val_loss: 0.0000e+00\n",
      "Epoch 8/10\n",
      "\u001b[1m225/225\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m99s\u001b[0m 439ms/step - accuracy: 1.0000 - loss: 6.3839e-34 - val_accuracy: 1.0000 - val_loss: 0.0000e+00\n",
      "Epoch 9/10\n",
      "\u001b[1m225/225\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m103s\u001b[0m 456ms/step - accuracy: 1.0000 - loss: 0.0000e+00 - val_accuracy: 1.0000 - val_loss: 0.0000e+00\n",
      "Epoch 10/10\n",
      "\u001b[1m225/225\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m114s\u001b[0m 506ms/step - accuracy: 1.0000 - loss: 4.1140e-31 - val_accuracy: 1.0000 - val_loss: 0.0000e+00\n"
     ]
    }
   ],
   "source": [
    "#Train the model\n",
    "history = model.fit(\n",
    "    train_gen,\n",
    "    epochs=10,\n",
    "    validation_data=val_gen\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6035fe22-6e16-4155-9906-6c4114b946c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. \n"
     ]
    }
   ],
   "source": [
    "#save mode\n",
    "model.save(\"cat_dog_model.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "aebe6a2b-6e81-4557-9a9a-b639c09550a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m47/47\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 432ms/step - accuracy: 1.0000 - loss: 0.0000e+00\n",
      "Test Accuracy: 1.00\n"
     ]
    }
   ],
   "source": [
    "#Evaluate model\n",
    "loss, accuracy = model.evaluate(test_gen)\n",
    "print(f\"Test Accuracy: {accuracy:.2f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "58b59595-961b-4af5-ba06-0a65d30ccb92",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot accuracy\n",
    "plt.plot(history.history['accuracy'], label='train acc')\n",
    "plt.plot(history.history['val_accuracy'], label='val acc')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "54b046e2-f030-453b-b091-9c013ead4fb1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 243ms/step\n",
      " Predicted label: Cat\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.preprocessing import image\n",
    "import numpy as np\n",
    "import os\n",
    "\n",
    "#Image test path\n",
    "img_path = r\"C:\\Users\\X1 YOGA\\Downloads\\cat_image_test.jpeg\"\n",
    "img = image.load_img(img_path, target_size=(150, 150))\n",
    "img_array = image.img_to_array(img) / 255.0\n",
    "img_array = np.expand_dims(img_array, axis=0)\n",
    "\n",
    "# Pridect\n",
    "prediction = model.predict(img_array)\n",
    "label = \"Dog\" if prediction[0][0] > 0.5 else \"Cat\"\n",
    "print(f\" Predicted label: {label}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b9b1327-a71a-47c0-b184-d3008c20294f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}