diff --git "a/part_2.ipynb" "b/part_2.ipynb" new file mode 100644--- /dev/null +++ "b/part_2.ipynb" @@ -0,0 +1,1035 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_Q4gIvePGw85", + "outputId": "ebac1a5d-9f43-416c-d900-82cc6587b6d1" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n", + "/content\n", + "'Colab Notebooks'\n" + ] + } + ], + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')\n", + "\n", + "import os\n", + "print(os.getcwd())\n", + "\n", + "!ls /content/drive/MyDrive/" + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "files.upload()\n", + "\n", + "!pip install kaggle\n", + "\n", + "!mkdir -p ~/.kaggle\n", + "!cp kaggle.json ~/.kaggle/\n", + "!chmod 600 ~/.kaggle/kaggle.json\n", + "\n", + "!kaggle datasets download -d dagnelies/deepfake-faces\n", + "!unzip -q deepfake-faces.zip -d deepfake_faces\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 440 + }, + "id": "7Emqe4aNG7Ak", + "outputId": "f8f9fe9f-6710-4dd7-cbd0-936b0066ac1b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \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", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving kaggle.json to kaggle.json\n", + "Requirement already satisfied: kaggle in /usr/local/lib/python3.11/dist-packages (1.7.4.5)\n", + "Requirement already satisfied: bleach in /usr/local/lib/python3.11/dist-packages (from kaggle) (6.2.0)\n", + "Requirement already satisfied: certifi>=14.05.14 in /usr/local/lib/python3.11/dist-packages (from kaggle) (2025.8.3)\n", + "Requirement already satisfied: charset-normalizer in /usr/local/lib/python3.11/dist-packages (from kaggle) (3.4.3)\n", + "Requirement already satisfied: idna in /usr/local/lib/python3.11/dist-packages (from kaggle) (3.10)\n", + "Requirement already satisfied: protobuf in /usr/local/lib/python3.11/dist-packages (from kaggle) (5.29.5)\n", + "Requirement already satisfied: python-dateutil>=2.5.3 in /usr/local/lib/python3.11/dist-packages (from kaggle) (2.9.0.post0)\n", + "Requirement already satisfied: python-slugify in /usr/local/lib/python3.11/dist-packages (from kaggle) (8.0.4)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.11/dist-packages (from kaggle) (2.32.3)\n", + "Requirement already satisfied: setuptools>=21.0.0 in /usr/local/lib/python3.11/dist-packages (from kaggle) (75.2.0)\n", + "Requirement already satisfied: six>=1.10 in /usr/local/lib/python3.11/dist-packages (from kaggle) (1.17.0)\n", + "Requirement already satisfied: text-unidecode in /usr/local/lib/python3.11/dist-packages (from kaggle) (1.3)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.11/dist-packages (from kaggle) (4.67.1)\n", + "Requirement already satisfied: urllib3>=1.15.1 in /usr/local/lib/python3.11/dist-packages (from kaggle) (2.5.0)\n", + "Requirement already satisfied: webencodings in /usr/local/lib/python3.11/dist-packages (from kaggle) (0.5.1)\n", + "Dataset URL: https://www.kaggle.com/datasets/dagnelies/deepfake-faces\n", + "License(s): other\n", + "Downloading deepfake-faces.zip to /content\n", + " 94% 405M/433M [00:05<00:00, 68.0MB/s]\n", + "100% 433M/433M [00:05<00:00, 78.5MB/s]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import plotly.graph_objects as go\n", + "from plotly.offline import iplot\n", + "import tensorflow as tf\n", + "from sklearn.model_selection import train_test_split\n", + "import cv2" + ], + "metadata": { + "id": "sgQ6ibXHHCAd" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "meta = pd.read_csv('/content/deepfake_faces/metadata.csv')\n", + "print(meta.head())" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HRchwl81HEiU", + "outputId": "33d76344-43d8-4e16-b14a-805482766d57" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " videoname original_width original_height label original\n", + "0 aznyksihgl.mp4 129 129 FAKE xnojggkrxt.mp4\n", + "1 gkwmalrvcj.mp4 129 129 FAKE hqqmtxvbjj.mp4\n", + "2 lxnqzocgaq.mp4 223 217 FAKE xjzkfqddyk.mp4\n", + "3 itsbtrrelv.mp4 186 186 FAKE kqvepwqxfe.mp4\n", + "4 ddvgrczjno.mp4 155 155 FAKE pluadmqqta.mp4\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "def summary(df):\n", + " summary_df = pd.DataFrame(df.dtypes, columns=['dtypes'])\n", + " summary_df['count'] = df.count().values\n", + " summary_df['unique'] = df.nunique().values\n", + " summary_df['missing#'] = df.isna().sum()\n", + " summary_df['missing%'] = df.isna().sum() / len(df)\n", + " return summary_df" + ], + "metadata": { + "id": "8da4BT5CHGVz" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(summary(meta).style.background_gradient('Purples'))\n", + "\n", + "print('Fake Images:', len(meta[meta.label=='FAKE']))\n", + "print('Real Images:', len(meta[meta.label=='REAL']))\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "SaZKTtqFHKQM", + "outputId": "3ffd6956-e191-4253-a42e-01fe7bb188a8" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Fake Images: 79341\n", + "Real Images: 16293\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Sample balanced dataset\n", + "real_df = meta[meta['label'] == 'REAL']\n", + "fake_df = meta[meta['label'] == 'FAKE']\n", + "sample_size = 16000\n", + "\n", + "real_df = real_df.sample(sample_size, random_state=42)\n", + "fake_df = fake_df.sample(sample_size, random_state=42)\n", + "\n", + "sample_meta = pd.concat([real_df, fake_df])" + ], + "metadata": { + "id": "9m8dhK0ZHP8c" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "sample_meta['filepath'] = '/content/deepfake_faces/faces_224/' + sample_meta['videoname'].str[:-4] + '.jpg'\n", + "\n", + "# Split the data\n", + "Train_set, temp_df = train_test_split(sample_meta, test_size=0.2, random_state=42, stratify=sample_meta['label'])\n", + "Val_set, Test_set = train_test_split(temp_df, test_size=0.5, random_state=42, stratify=temp_df['label'])\n", + "\n", + "print(f'Train Set: {Train_set.shape}')\n", + "print(f'Validation Set: {Val_set.shape}')\n", + "print(f'Test Set: {Test_set.shape}')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bL62yOEcHWqE", + "outputId": "12cdf0b0-4508-4587-813c-ebc47c5ee81d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train Set: (25600, 6)\n", + "Validation Set: (3200, 6)\n", + "Test Set: (3200, 6)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "data_augmentation = tf.keras.Sequential([\n", + " tf.keras.layers.RandomFlip(\"horizontal\"),\n", + " tf.keras.layers.RandomRotation(0.1),\n", + " tf.keras.layers.RandomZoom(0.1),\n", + "])" + ], + "metadata": { + "id": "e4xmsSeGIDe8" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "label_map = {'REAL': 0, 'FAKE': 1}\n" + ], + "metadata": { + "id": "2ba3DFLDIFWs" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def preprocess_image(filepath, label):\n", + " image = tf.io.read_file(filepath)\n", + " image = tf.image.decode_jpeg(image, channels=3)\n", + " image = tf.image.resize(image, [224, 224])\n", + " image = tf.cast(image, tf.float32)\n", + " # EfficientNet expects values in [0, 255] for its preprocess function\n", + " return image, label\n", + "\n", + "# Create TensorFlow datasets\n", + "batch_size = 32\n", + "\n", + "train_ds = tf.data.Dataset.from_tensor_slices((\n", + " Train_set['filepath'].values,\n", + " Train_set['label'].map(label_map).values\n", + "))\n", + "train_ds = (train_ds\n", + " .map(preprocess_image, num_parallel_calls=tf.data.AUTOTUNE)\n", + " .shuffle(1000, seed=42)\n", + " .batch(batch_size)\n", + " .prefetch(tf.data.AUTOTUNE))\n", + "\n", + "val_ds = tf.data.Dataset.from_tensor_slices((\n", + " Val_set['filepath'].values,\n", + " Val_set['label'].map(label_map).values\n", + "))\n", + "val_ds = (val_ds\n", + " .map(preprocess_image, num_parallel_calls=tf.data.AUTOTUNE)\n", + " .batch(batch_size)\n", + " .prefetch(tf.data.AUTOTUNE))\n", + "\n", + "test_ds = tf.data.Dataset.from_tensor_slices((\n", + " Test_set['filepath'].values,\n", + " Test_set['label'].map(label_map).values\n", + "))\n", + "test_ds = (test_ds\n", + " .map(preprocess_image, num_parallel_calls=tf.data.AUTOTUNE)\n", + " .batch(batch_size)\n", + " .prefetch(tf.data.AUTOTUNE))" + ], + "metadata": { + "id": "OendSPcjIF99" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def plot_class_counts(train_set, val_set, test_set):\n", + " sets = ['Train Set', 'Validation Set', 'Test Set']\n", + " colors = ['#52A666', '#C15B4E']\n", + "\n", + " y = {\n", + " 'REAL': [np.sum(train_set == 'REAL'), np.sum(val_set == 'REAL'), np.sum(test_set == 'REAL')],\n", + " 'FAKE': [np.sum(train_set == 'FAKE'), np.sum(val_set == 'FAKE'), np.sum(test_set == 'FAKE')]\n", + " }\n", + "\n", + " trace0 = go.Bar(x=sets, y=y['REAL'], name='REAL', marker={'color': colors[0]}, opacity=0.7)\n", + " trace1 = go.Bar(x=sets, y=y['FAKE'], name='FAKE', marker={'color': colors[1]}, opacity=0.7)\n", + "\n", + " data = [trace0, trace1]\n", + " layout = go.Layout(title='Count of Classes in each set:', xaxis={'title': 'Set'}, yaxis={'title': 'Count'})\n", + "\n", + " fig = go.Figure(data, layout)\n", + " iplot(fig)\n", + "\n", + "plot_class_counts(np.array(Train_set['label']), np.array(Val_set['label']), np.array(Test_set['label']))\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 542 + }, + "id": "BUtvuXUPIL3E", + "outputId": "eaae2e22-669a-4e1e-f59b-8d9021dffba0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "
\n", + "
\n", + "\n", + "" + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "from tensorflow.keras.models import load_model\n", + "\n", + "model = load_model(\n", + " \"/content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_21.keras\")\n" + ], + "metadata": { + "id": "jlIxMc3IxDpy" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Compile model\n", + "optimizer = tf.keras.optimizers.Adam(learning_rate=0.001) # Using Adam for better convergence\n", + "model.compile(\n", + " optimizer=optimizer,\n", + " loss=\"binary_crossentropy\",\n", + " metrics=[\"accuracy\"]\n", + ")\n", + "\n", + "model.summary()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 357 + }, + "id": "0IpweVPuIY38", + "outputId": "6a857f2d-b4f7-4473-9fd0-f16e974c9d62" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1mModel: \"functional_1\"\u001b[0m\n" + ], + "text/html": [ + "
Model: \"functional_1\"\n",
+              "
\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ input_layer_1 (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m224\u001b[0m, \u001b[38;5;34m224\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ sequential (\u001b[38;5;33mSequential\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m224\u001b[0m, \u001b[38;5;34m224\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ efficientnetb4 (\u001b[38;5;33mFunctional\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m7\u001b[0m, \u001b[38;5;34m7\u001b[0m, \u001b[38;5;34m1792\u001b[0m) │ \u001b[38;5;34m17,673,823\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ global_average_pooling2d │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1792\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "│ (\u001b[38;5;33mGlobalAveragePooling2D\u001b[0m) │ │ │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dropout (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1792\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m1,793\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ], + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+              "┃ Layer (type)                     Output Shape                  Param # ┃\n",
+              "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+              "│ input_layer_1 (InputLayer)      │ (None, 224, 224, 3)    │             0 │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ sequential (Sequential)         │ (None, 224, 224, 3)    │             0 │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ efficientnetb4 (Functional)     │ (None, 7, 7, 1792)     │    17,673,823 │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ global_average_pooling2d        │ (None, 1792)           │             0 │\n",
+              "│ (GlobalAveragePooling2D)        │                        │               │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ dropout (Dropout)               │ (None, 1792)           │             0 │\n",
+              "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+              "│ dense (Dense)                   │ (None, 1)              │         1,793 │\n",
+              "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+              "
\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m17,675,616\u001b[0m (67.43 MB)\n" + ], + "text/html": [ + "
 Total params: 17,675,616 (67.43 MB)\n",
+              "
\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m17,550,409\u001b[0m (66.95 MB)\n" + ], + "text/html": [ + "
 Trainable params: 17,550,409 (66.95 MB)\n",
+              "
\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m125,207\u001b[0m (489.09 KB)\n" + ], + "text/html": [ + "
 Non-trainable params: 125,207 (489.09 KB)\n",
+              "
\n" + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "!ls '/content/drive/MyDrive/Colab Notebooks/NTI-PRJCT'" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sn926v3myB0q", + "outputId": "4b8bbee9-08b7-4895-8fdd-5e1c70ebc84f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "model_epoch_21.keras\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "SfedgNNnyBnL" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Setup callbacks\n", + "from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau\n", + "\n", + "\n", + "\n", + "# Model checkpoint\n", + "checkpoint_path = \"/content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_{epoch:02d}.keras\"\n", + "checkpoint_callback = ModelCheckpoint(\n", + " filepath=checkpoint_path,\n", + " monitor='val_accuracy',\n", + " save_best_only=False,\n", + " save_weights_only=False,\n", + " verbose=1\n", + ")\n", + "\n", + "# Early stopping with proper patience\n", + "early_stopping = EarlyStopping(\n", + " monitor='val_loss',\n", + " patience=8,\n", + " restore_best_weights=True,\n", + " verbose=1\n", + ")\n", + "best_checkpoint_callback = ModelCheckpoint(\n", + " filepath=\"/content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_{epoch:02d}.keras\",\n", + " monitor='val_accuracy',\n", + " save_best_only=True,\n", + " verbose=1\n", + ")" + ], + "metadata": { + "id": "TUVta5W5IcTM" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "lr_reducer = ReduceLROnPlateau(\n", + " monitor='val_loss',\n", + " factor=0.2,\n", + " patience=5,\n", + " min_lr=1e-7,\n", + " verbose=1\n", + ")\n", + "\n", + "# Training\n", + "history = model.fit(\n", + " train_ds,\n", + " validation_data=val_ds,\n", + " epochs=50,\n", + " initial_epoch = 21,\n", + " callbacks=[early_stopping, checkpoint_callback,best_checkpoint_callback, lr_reducer],\n", + " verbose=1\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3jaEVVMHInmc", + "outputId": "bc5ebf26-63ea-433a-bb1a-840fcf51fa67" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 22/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 823ms/step - accuracy: 0.9621 - loss: 0.0993\n", + "Epoch 22: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_22.keras\n", + "\n", + "Epoch 22: val_accuracy improved from -inf to 0.87531, saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_22.keras\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m774s\u001b[0m 860ms/step - accuracy: 0.9621 - loss: 0.0993 - val_accuracy: 0.8753 - val_loss: 0.3583 - learning_rate: 0.0010\n", + "Epoch 23/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 825ms/step - accuracy: 0.9521 - loss: 0.1238\n", + "Epoch 23: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_23.keras\n", + "\n", + "Epoch 23: val_accuracy did not improve from 0.87531\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m731s\u001b[0m 855ms/step - accuracy: 0.9521 - loss: 0.1238 - val_accuracy: 0.8712 - val_loss: 0.3874 - learning_rate: 0.0010\n", + "Epoch 24/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 825ms/step - accuracy: 0.9532 - loss: 0.1239\n", + "Epoch 24: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_24.keras\n", + "\n", + "Epoch 24: val_accuracy improved from 0.87531 to 0.87750, saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_24.keras\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m687s\u001b[0m 858ms/step - accuracy: 0.9532 - loss: 0.1239 - val_accuracy: 0.8775 - val_loss: 0.3489 - learning_rate: 0.0010\n", + "Epoch 25/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 825ms/step - accuracy: 0.9514 - loss: 0.1232\n", + "Epoch 25: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_25.keras\n", + "\n", + "Epoch 25: val_accuracy improved from 0.87750 to 0.88937, saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_25.keras\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m685s\u001b[0m 855ms/step - accuracy: 0.9514 - loss: 0.1232 - val_accuracy: 0.8894 - val_loss: 0.3205 - learning_rate: 0.0010\n", + "Epoch 26/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 828ms/step - accuracy: 0.9575 - loss: 0.1086\n", + "Epoch 26: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_26.keras\n", + "\n", + "Epoch 26: val_accuracy improved from 0.88937 to 0.89469, saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_26.keras\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m686s\u001b[0m 858ms/step - accuracy: 0.9575 - loss: 0.1086 - val_accuracy: 0.8947 - val_loss: 0.3064 - learning_rate: 0.0010\n", + "Epoch 27/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 830ms/step - accuracy: 0.9573 - loss: 0.1082\n", + "Epoch 27: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_27.keras\n", + "\n", + "Epoch 27: val_accuracy did not improve from 0.89469\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m685s\u001b[0m 856ms/step - accuracy: 0.9573 - loss: 0.1082 - val_accuracy: 0.8853 - val_loss: 0.2887 - learning_rate: 0.0010\n", + "Epoch 28/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 826ms/step - accuracy: 0.9594 - loss: 0.1042\n", + "Epoch 28: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_28.keras\n", + "\n", + "Epoch 28: val_accuracy did not improve from 0.89469\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m681s\u001b[0m 851ms/step - accuracy: 0.9594 - loss: 0.1042 - val_accuracy: 0.8925 - val_loss: 0.3436 - learning_rate: 0.0010\n", + "Epoch 29/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 828ms/step - accuracy: 0.9601 - loss: 0.1019\n", + "Epoch 29: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_29.keras\n", + "\n", + "Epoch 29: val_accuracy did not improve from 0.89469\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m683s\u001b[0m 853ms/step - accuracy: 0.9601 - loss: 0.1019 - val_accuracy: 0.8909 - val_loss: 0.3259 - learning_rate: 0.0010\n", + "Epoch 30/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 829ms/step - accuracy: 0.9585 - loss: 0.1001\n", + "Epoch 30: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_30.keras\n", + "\n", + "Epoch 30: val_accuracy did not improve from 0.89469\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m686s\u001b[0m 857ms/step - accuracy: 0.9585 - loss: 0.1001 - val_accuracy: 0.8809 - val_loss: 0.3333 - learning_rate: 0.0010\n", + "Epoch 31/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 825ms/step - accuracy: 0.9652 - loss: 0.0908\n", + "Epoch 31: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_31.keras\n", + "\n", + "Epoch 31: val_accuracy improved from 0.89469 to 0.90688, saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_31.keras\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m690s\u001b[0m 861ms/step - accuracy: 0.9652 - loss: 0.0908 - val_accuracy: 0.9069 - val_loss: 0.2768 - learning_rate: 0.0010\n", + "Epoch 32/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 826ms/step - accuracy: 0.9685 - loss: 0.0823\n", + "Epoch 32: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_32.keras\n", + "\n", + "Epoch 32: val_accuracy improved from 0.90688 to 0.91125, saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_32.keras\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m689s\u001b[0m 861ms/step - accuracy: 0.9685 - loss: 0.0823 - val_accuracy: 0.9112 - val_loss: 0.2527 - learning_rate: 0.0010\n", + "Epoch 33/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 826ms/step - accuracy: 0.9693 - loss: 0.0876\n", + "Epoch 33: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_33.keras\n", + "\n", + "Epoch 33: val_accuracy did not improve from 0.91125\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m687s\u001b[0m 859ms/step - accuracy: 0.9693 - loss: 0.0876 - val_accuracy: 0.8938 - val_loss: 0.3748 - learning_rate: 0.0010\n", + "Epoch 34/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 826ms/step - accuracy: 0.9697 - loss: 0.0808\n", + "Epoch 34: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_34.keras\n", + "\n", + "Epoch 34: val_accuracy did not improve from 0.91125\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m684s\u001b[0m 854ms/step - accuracy: 0.9697 - loss: 0.0808 - val_accuracy: 0.8838 - val_loss: 0.3397 - learning_rate: 0.0010\n", + "Epoch 35/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 826ms/step - accuracy: 0.9706 - loss: 0.0787\n", + "Epoch 35: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_35.keras\n", + "\n", + "Epoch 35: val_accuracy did not improve from 0.91125\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m685s\u001b[0m 856ms/step - accuracy: 0.9706 - loss: 0.0787 - val_accuracy: 0.8378 - val_loss: 0.4757 - learning_rate: 0.0010\n", + "Epoch 36/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 826ms/step - accuracy: 0.9708 - loss: 0.0789\n", + "Epoch 36: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_36.keras\n", + "\n", + "Epoch 36: val_accuracy did not improve from 0.91125\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m741s\u001b[0m 855ms/step - accuracy: 0.9708 - loss: 0.0789 - val_accuracy: 0.9009 - val_loss: 0.3198 - learning_rate: 0.0010\n", + "Epoch 37/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 828ms/step - accuracy: 0.9735 - loss: 0.0717\n", + "Epoch 37: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_37.keras\n", + "\n", + "Epoch 37: val_accuracy did not improve from 0.91125\n", + "\n", + "Epoch 37: ReduceLROnPlateau reducing learning rate to 0.00020000000949949026.\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m692s\u001b[0m 864ms/step - accuracy: 0.9735 - loss: 0.0717 - val_accuracy: 0.8950 - val_loss: 0.3753 - learning_rate: 0.0010\n", + "Epoch 38/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 826ms/step - accuracy: 0.9797 - loss: 0.0511\n", + "Epoch 38: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_38.keras\n", + "\n", + "Epoch 38: val_accuracy improved from 0.91125 to 0.91562, saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_38.keras\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m694s\u001b[0m 866ms/step - accuracy: 0.9797 - loss: 0.0511 - val_accuracy: 0.9156 - val_loss: 0.3122 - learning_rate: 2.0000e-04\n", + "Epoch 39/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 825ms/step - accuracy: 0.9900 - loss: 0.0287\n", + "Epoch 39: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_39.keras\n", + "\n", + "Epoch 39: val_accuracy improved from 0.91562 to 0.92062, saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_39.keras\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m741s\u001b[0m 865ms/step - accuracy: 0.9900 - loss: 0.0287 - val_accuracy: 0.9206 - val_loss: 0.3256 - learning_rate: 2.0000e-04\n", + "Epoch 40/50\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 826ms/step - accuracy: 0.9918 - loss: 0.0226\n", + "Epoch 40: saving model to /content/drive/MyDrive/Colab Notebooks/NTI-PRJCT/model_epoch_40.keras\n", + "\n", + "Epoch 40: val_accuracy did not improve from 0.92062\n", + "\u001b[1m800/800\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m689s\u001b[0m 860ms/step - accuracy: 0.9918 - loss: 0.0226 - val_accuracy: 0.9206 - val_loss: 0.3713 - learning_rate: 2.0000e-04\n", + "Epoch 40: early stopping\n", + "Restoring model weights from the end of the best epoch: 32.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "KFBcgWXf3kLt" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 340 + }, + "id": "3e3e5ae5", + "outputId": "9cdf65bc-90bc-41e2-b759-e737f43992e7" + }, + "source": [ + "# Plot training and validation accuracy and loss\n", + "plt.figure(figsize=(12, 4))\n", + "\n", + "plt.subplot(1, 2, 1)\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('Epoch')\n", + "plt.ylabel('Accuracy')\n", + "plt.legend()\n", + "\n", + "plt.subplot(1, 2, 2)\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('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "\n", + "plt.show()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "a58cf2f0", + "outputId": "8231d24f-b4ab-4eda-baea-a51024f03f73" + }, + "source": [ + "loss, accuracy = model.evaluate(test_ds)\n", + "\n", + "print(f\"Test Loss: {loss:.4f}\")\n", + "print(f\"Test Accuracy: {accuracy:.4f}\")" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[1m100/100\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 170ms/step - accuracy: 0.9013 - loss: 0.2446\n", + "Test Loss: 0.2296\n", + "Test Accuracy: 0.9075\n" + ] + } + ] + } + ] +} \ No newline at end of file