Models on RAF-DB.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0b10191a",
   "metadata": {},
   "source": [
    "## Second dataset: RAF-DB"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82d2a809",
   "metadata": {},
   "source": [
    "### Import packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "85535967",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Sequential, model_from_json, Model\n",
    "from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dense, Dropout, Flatten, BatchNormalization, Activation, Input, GlobalAveragePooling2D, ReLU, Multiply, Reshape\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from tensorflow.keras.optimizers.schedules import ExponentialDecay\n",
    "\n",
    "import cv2\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import os\n",
    "import shutil\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from keras.utils import to_categorical\n",
    "\n",
    "from tensorflow.keras.regularizers import l2\n",
    "\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2ca3a48",
   "metadata": {},
   "source": [
    "### Artificially create an unlabeled subset of dataset for semi-supervised learning using pseudo-labeling\n",
    "\n",
    "Note that this cell will error if run more than once since we've then already split the original training set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a32a02e0",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "With n_samples=0, test_size=0.2 and train_size=None, the resulting train set will be empty. Adjust any of the aforementioned parameters.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_4110/774937739.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     26\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     27\u001b[0m     \u001b[0;31m# Split images into labeled and \"unlabeled\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 28\u001b[0;31m     \u001b[0mlabeled_imgs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0munlabeled_imgs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrain_test_split\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimages\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msplit_ratio\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrandom_state\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m42\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     29\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     30\u001b[0m     \u001b[0;31m# Move images to their new directories\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.9/site-packages/sklearn/model_selection/_split.py\u001b[0m in \u001b[0;36mtrain_test_split\u001b[0;34m(test_size, train_size, random_state, shuffle, stratify, *arrays)\u001b[0m\n\u001b[1;32m   2173\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2174\u001b[0m     \u001b[0mn_samples\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_num_samples\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marrays\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\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-> 2175\u001b[0;31m     n_train, n_test = _validate_shuffle_split(n_samples, test_size, train_size,\n\u001b[0m\u001b[1;32m   2176\u001b[0m                                               default_test_size=0.25)\n\u001b[1;32m   2177\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.9/site-packages/sklearn/model_selection/_split.py\u001b[0m in \u001b[0;36m_validate_shuffle_split\u001b[0;34m(n_samples, test_size, train_size, default_test_size)\u001b[0m\n\u001b[1;32m   1855\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1856\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mn_train\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1857\u001b[0;31m         raise ValueError(\n\u001b[0m\u001b[1;32m   1858\u001b[0m             \u001b[0;34m'With n_samples={}, test_size={} and train_size={}, the '\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1859\u001b[0m             \u001b[0;34m'resulting train set will be empty. Adjust any of the '\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: With n_samples=0, test_size=0.2 and train_size=None, the resulting train set will be empty. Adjust any of the aforementioned parameters."
     ]
    }
   ],
   "source": [
    "# Adjust the base directory to point to training data\n",
    "base_dir = 'datasets/RAF-DB/DATASET/train'  \n",
    "\n",
    "# Directories for labeled and \"unlabeled\" training data\n",
    "labeled_dir = os.path.join(base_dir, '../labeled_train')\n",
    "unlabeled_dir = os.path.join(base_dir, '../unlabeled_train')\n",
    "\n",
    "# Ensure the output directories exist\n",
    "os.makedirs(labeled_dir, exist_ok=True)\n",
    "os.makedirs(unlabeled_dir, exist_ok=True)\n",
    "\n",
    "# Split ratio\n",
    "split_ratio = 0.2  # 20% of training data is treated as \"unlabeled\"\n",
    "\n",
    "# List classes/categories\n",
    "classes = [dir for dir in os.listdir(base_dir) if os.path.isdir(os.path.join(base_dir, dir))]\n",
    "classes = sorted(classes)\n",
    "\n",
    "for class_name in classes:\n",
    "    # Create target directories for both labeled and unlabeled data\n",
    "    os.makedirs(os.path.join(labeled_dir, class_name), exist_ok=True)\n",
    "    os.makedirs(os.path.join(unlabeled_dir, class_name), exist_ok=True)\n",
    "    \n",
    "    class_dir = os.path.join(base_dir, class_name)\n",
    "    images = [img for img in os.listdir(class_dir) if img.lower().endswith(('png', 'jpg', 'jpeg'))]\n",
    "    \n",
    "    # Split images into labeled and \"unlabeled\"\n",
    "    labeled_imgs, unlabeled_imgs = train_test_split(images, test_size=split_ratio, random_state=42)\n",
    "    \n",
    "    # Move images to their new directories\n",
    "    for img in labeled_imgs:\n",
    "        shutil.move(os.path.join(class_dir, img), os.path.join(labeled_dir, class_name, img))\n",
    "    \n",
    "    for img in unlabeled_imgs:\n",
    "        shutil.move(os.path.join(class_dir, img), os.path.join(unlabeled_dir, class_name, img))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94269020",
   "metadata": {},
   "source": [
    "### Preprocess images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2c3dbcb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 8789 images belonging to 7 classes.\n",
      "Found 2195 images belonging to 7 classes.\n",
      "Found 2457 images belonging to 7 classes.\n",
      "Found 3068 images belonging to 7 classes.\n"
     ]
    }
   ],
   "source": [
    "# Initialize the data generators\n",
    "train_data_gen = ImageDataGenerator(\n",
    "    rescale=1./255, \n",
    "    validation_split=0.2  # Using 20% of the labeled data for validation\n",
    ")\n",
    "\n",
    "# Load the labeled training data and split it into training and validation sets\n",
    "train_generator = train_data_gen.flow_from_directory(\n",
    "    'datasets/RAF-DB/DATASET/labeled_train',  \n",
    "    target_size=(48, 48),\n",
    "    batch_size=64,\n",
    "    color_mode=\"grayscale\",\n",
    "    class_mode='categorical',\n",
    "    subset='training'  \n",
    ")\n",
    "\n",
    "validation_generator = train_data_gen.flow_from_directory(\n",
    "    'datasets/RAF-DB/DATASET/labeled_train',  \n",
    "    target_size=(48, 48),\n",
    "    batch_size=64,\n",
    "    color_mode=\"grayscale\",\n",
    "    class_mode='categorical',\n",
    "    subset='validation' \n",
    ")\n",
    "\n",
    "# Initialize unlabeled data generator\n",
    "unlabeled_data_gen = ImageDataGenerator(rescale=1./255)\n",
    "\n",
    "unlabeled_generator = unlabeled_data_gen.flow_from_directory(\n",
    "    'datasets/RAF-DB/DATASET/unlabeled_train',  \n",
    "    target_size=(48, 48),  \n",
    "    batch_size=64, \n",
    "    color_mode=\"grayscale\", \n",
    "    class_mode=None,  # must set to None for unlabeled data\n",
    "    shuffle=False  \n",
    ")\n",
    "\n",
    "# Initialize the test data generator\n",
    "test_data_gen = ImageDataGenerator(rescale=1./255)\n",
    "\n",
    "# Load the test data\n",
    "test_generator = test_data_gen.flow_from_directory(\n",
    "    'datasets/RAF-DB/DATASET/test',  \n",
    "    target_size=(48, 48),\n",
    "    batch_size=64,\n",
    "    color_mode=\"grayscale\",\n",
    "    class_mode='categorical'  \n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27cb826e",
   "metadata": {},
   "source": [
    "### Set up example model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3d3ccc62",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-03-22 02:25:57.536962: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1639] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 10398 MB memory:  -> device: 0, name: NVIDIA GeForce GTX 1080 Ti, pci bus id: 0000:04:00.0, compute capability: 6.1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d (Conv2D)             (None, 46, 46, 32)        320       \n",
      "                                                                 \n",
      " batch_normalization (Batch  (None, 46, 46, 32)        128       \n",
      " Normalization)                                                  \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 44, 44, 64)        18496     \n",
      "                                                                 \n",
      " batch_normalization_1 (Bat  (None, 44, 44, 64)        256       \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2  (None, 22, 22, 64)        0         \n",
      " D)                                                              \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 22, 22, 64)        0         \n",
      "                                                                 \n",
      " conv2d_2 (Conv2D)           (None, 20, 20, 128)       73856     \n",
      "                                                                 \n",
      " batch_normalization_2 (Bat  (None, 20, 20, 128)       512       \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPoolin  (None, 10, 10, 128)       0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " conv2d_3 (Conv2D)           (None, 8, 8, 128)         147584    \n",
      "                                                                 \n",
      " batch_normalization_3 (Bat  (None, 8, 8, 128)         512       \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " max_pooling2d_2 (MaxPoolin  (None, 4, 4, 128)         0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " dropout_1 (Dropout)         (None, 4, 4, 128)         0         \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 2048)              0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 1024)              2098176   \n",
      "                                                                 \n",
      " batch_normalization_4 (Bat  (None, 1024)              4096      \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " dropout_2 (Dropout)         (None, 1024)              0         \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 7)                 7175      \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 2351111 (8.97 MB)\n",
      "Trainable params: 2348359 (8.96 MB)\n",
      "Non-trainable params: 2752 (10.75 KB)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = Sequential() # initialize Sequential model\n",
    "\n",
    "# add 2 conv layers\n",
    "model.add(Conv2D(32, kernel_size=(3, 3), input_shape=(48, 48, 1), activation='relu'))\n",
    "model.add(BatchNormalization())  \n",
    "model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))\n",
    "model.add(BatchNormalization()) \n",
    "# add max pooling layer\n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "# add 25% dropout \n",
    "model.add(Dropout(0.25))\n",
    "\n",
    "# add 2 more conv layers, 2 more max pooling layers, and dropout again\n",
    "model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))\n",
    "model.add(BatchNormalization())  \n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))\n",
    "model.add(BatchNormalization())  \n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "model.add(Dropout(0.25))\n",
    "\n",
    "# flatten into 1D vector\n",
    "model.add(Flatten())\n",
    "# fully-connected layer \n",
    "model.add(Dense(1024, activation='relu'))\n",
    "model.add(BatchNormalization())\n",
    "model.add(Dropout(0.5))\n",
    "# softmax to turn into class probabilities\n",
    "model.add(Dense(7, activation='softmax'))\n",
    "\n",
    "model.summary()\n",
    "\n",
    "# disable OpenCL\n",
    "cv2.ocl.setUseOpenCL(False)\n",
    "\n",
    "# set up learning rate scheduler, starting at 0.0001\n",
    "initial_learning_rate = 0.0001\n",
    "lr_schedule = ExponentialDecay(initial_learning_rate, decay_steps=100000, decay_rate=0.96)\n",
    "\n",
    "# use Adam optimizer\n",
    "optimizer = Adam(learning_rate=lr_schedule)\n",
    "\n",
    "# compile model\n",
    "model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c3b1088",
   "metadata": {},
   "source": [
    "### Train the model on labeled data first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "86e7a296",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/25\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-03-22 02:26:03.527973: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:954] layout failed: INVALID_ARGUMENT: Size of values 0 does not match size of permutation 4 @ fanin shape insequential/dropout/dropout/SelectV2-2-TransposeNHWCToNCHW-LayoutOptimizer\n",
      "2024-03-22 02:26:04.439644: I tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:432] Loaded cuDNN version 8600\n",
      "2024-03-22 02:26:05.438334: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x7f359800c070 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
      "2024-03-22 02:26:05.438413: I tensorflow/compiler/xla/service/service.cc:176]   StreamExecutor device (0): NVIDIA GeForce GTX 1080 Ti, Compute Capability 6.1\n",
      "2024-03-22 02:26:05.451984: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:255] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
      "2024-03-22 02:26:05.657880: I ./tensorflow/compiler/jit/device_compiler.h:186] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "122/122 [==============================] - 18s 90ms/step - loss: 2.3493 - accuracy: 0.3253 - val_loss: 1.8850 - val_accuracy: 0.4104\n",
      "Epoch 2/25\n",
      "122/122 [==============================] - 7s 60ms/step - loss: 1.8285 - accuracy: 0.4641 - val_loss: 1.7710 - val_accuracy: 0.4151\n",
      "Epoch 3/25\n",
      "122/122 [==============================] - 6s 52ms/step - loss: 1.5603 - accuracy: 0.5279 - val_loss: 1.5410 - val_accuracy: 0.5156\n",
      "Epoch 4/25\n",
      "122/122 [==============================] - 5s 44ms/step - loss: 1.4195 - accuracy: 0.5659 - val_loss: 1.2442 - val_accuracy: 0.5786\n",
      "Epoch 5/25\n",
      "122/122 [==============================] - 6s 52ms/step - loss: 1.3219 - accuracy: 0.5984 - val_loss: 0.9651 - val_accuracy: 0.6635\n",
      "Epoch 6/25\n",
      "122/122 [==============================] - 6s 52ms/step - loss: 1.2226 - accuracy: 0.6236 - val_loss: 0.8771 - val_accuracy: 0.7047\n",
      "Epoch 7/25\n",
      "122/122 [==============================] - 6s 51ms/step - loss: 1.1437 - accuracy: 0.6457 - val_loss: 0.8441 - val_accuracy: 0.7141\n",
      "Epoch 8/25\n",
      "122/122 [==============================] - 6s 45ms/step - loss: 1.0849 - accuracy: 0.6571 - val_loss: 0.8024 - val_accuracy: 0.7312\n",
      "Epoch 9/25\n",
      "122/122 [==============================] - 6s 53ms/step - loss: 1.0147 - accuracy: 0.6720 - val_loss: 0.7766 - val_accuracy: 0.7328\n",
      "Epoch 10/25\n",
      "122/122 [==============================] - 7s 53ms/step - loss: 0.9410 - accuracy: 0.6998 - val_loss: 0.7928 - val_accuracy: 0.7292\n",
      "Epoch 11/25\n",
      "122/122 [==============================] - 6s 52ms/step - loss: 0.9382 - accuracy: 0.6930 - val_loss: 0.7673 - val_accuracy: 0.7370\n",
      "Epoch 12/25\n",
      "122/122 [==============================] - 7s 54ms/step - loss: 0.9043 - accuracy: 0.7028 - val_loss: 0.7587 - val_accuracy: 0.7464\n",
      "Epoch 13/25\n",
      "122/122 [==============================] - 6s 49ms/step - loss: 0.8497 - accuracy: 0.7209 - val_loss: 0.7247 - val_accuracy: 0.7667\n",
      "Epoch 14/25\n",
      "122/122 [==============================] - 6s 47ms/step - loss: 0.8133 - accuracy: 0.7306 - val_loss: 0.7323 - val_accuracy: 0.7604\n",
      "Epoch 15/25\n",
      "122/122 [==============================] - 6s 51ms/step - loss: 0.7594 - accuracy: 0.7442 - val_loss: 0.7035 - val_accuracy: 0.7729\n",
      "Epoch 16/25\n",
      "122/122 [==============================] - 6s 51ms/step - loss: 0.7279 - accuracy: 0.7531 - val_loss: 0.7435 - val_accuracy: 0.7547\n",
      "Epoch 17/25\n",
      "122/122 [==============================] - 6s 51ms/step - loss: 0.7164 - accuracy: 0.7603 - val_loss: 0.7260 - val_accuracy: 0.7667\n",
      "Epoch 18/25\n",
      "122/122 [==============================] - 6s 50ms/step - loss: 0.6988 - accuracy: 0.7593 - val_loss: 0.7117 - val_accuracy: 0.7719\n",
      "Epoch 19/25\n",
      "122/122 [==============================] - 6s 52ms/step - loss: 0.6786 - accuracy: 0.7715 - val_loss: 0.7236 - val_accuracy: 0.7651\n",
      "Epoch 20/25\n",
      "122/122 [==============================] - 7s 53ms/step - loss: 0.6531 - accuracy: 0.7751 - val_loss: 0.7169 - val_accuracy: 0.7682\n",
      "Epoch 21/25\n",
      "122/122 [==============================] - 6s 50ms/step - loss: 0.6206 - accuracy: 0.7842 - val_loss: 0.7251 - val_accuracy: 0.7677\n",
      "Epoch 22/25\n",
      "122/122 [==============================] - 6s 53ms/step - loss: 0.5954 - accuracy: 0.7907 - val_loss: 0.6679 - val_accuracy: 0.7896\n",
      "Epoch 23/25\n",
      "122/122 [==============================] - 6s 50ms/step - loss: 0.5939 - accuracy: 0.7914 - val_loss: 0.7196 - val_accuracy: 0.7630\n",
      "Epoch 24/25\n",
      "122/122 [==============================] - 6s 53ms/step - loss: 0.5766 - accuracy: 0.7958 - val_loss: 0.6820 - val_accuracy: 0.7760\n",
      "Epoch 25/25\n",
      "122/122 [==============================] - 6s 52ms/step - loss: 0.5221 - accuracy: 0.8147 - val_loss: 0.6655 - val_accuracy: 0.7896\n"
     ]
    }
   ],
   "source": [
    "# Initial training with labeled data\n",
    "model_info = model.fit(\n",
    "    train_generator,\n",
    "    steps_per_epoch=7855 // 64,  \n",
    "    epochs=25,  \n",
    "    validation_data=validation_generator,\n",
    "    validation_steps=1959 // 64  \n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab4d593c",
   "metadata": {},
   "source": [
    "### Visualizations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "05c6c0aa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "accuracy = model_info.history['accuracy']\n",
    "val_accuracy = model_info.history['val_accuracy']\n",
    "loss = model_info.history['loss']\n",
    "val_loss = model_info.history['val_loss']\n",
    "\n",
    "# accuracy graph\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(accuracy, label='accuracy')\n",
    "plt.plot(val_accuracy, label='val accuracy')\n",
    "plt.title('Accuracy Graph')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "\n",
    "# loss graph\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(loss, label='loss')\n",
    "plt.plot(val_loss, label='val loss')\n",
    "plt.title('Loss Graph')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9d3a861",
   "metadata": {},
   "source": [
    "### Now, train on unlabeled data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6c6f878f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39/39 [==============================] - 3s 65ms/step\n"
     ]
    }
   ],
   "source": [
    "# Step 1: Predict class probabilities for the unlabeled data\n",
    "predicted_probabilities = model.predict(unlabeled_generator)\n",
    "\n",
    "# Step 2: Generate pseudo-labels from these predictions\n",
    "pseudo_labels = np.argmax(predicted_probabilities, axis=1)\n",
    "\n",
    "# Define a confidence threshold\n",
    "confidence_threshold = 0.9\n",
    "\n",
    "# Step 3: Create a mask for predictions that exceed the confidence threshold\n",
    "high_confidence_mask = np.max(predicted_probabilities, axis=1) > confidence_threshold\n",
    "\n",
    "# Apply the mask to filter out the filenames and predictions\n",
    "high_confidence_filenames = np.array(unlabeled_generator.filenames)[high_confidence_mask]\n",
    "high_confidence_predictions = pseudo_labels[high_confidence_mask]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "44b18d23",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(pseudo_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a586718b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Organize images\n",
    "for filename, pseudo_label in zip(high_confidence_filenames, high_confidence_predictions):\n",
    "#     # Ensure the pseudo_label is an integer or a valid class name\n",
    "#     assert isinstance(pseudo_label, int), \"Pseudo-label must be an integer\"\n",
    "    \n",
    "    # Define the source path for the pseudo-labeled image\n",
    "    source_path = os.path.join(unlabeled_dir, filename)\n",
    "    \n",
    "    # Define the destination directory based on the pseudo-label\n",
    "    destination_dir = os.path.join(labeled_dir, str(pseudo_label + 1))\n",
    "    if not os.path.exists(destination_dir):\n",
    "        os.makedirs(destination_dir, exist_ok=True)\n",
    "    \n",
    "    # Define the destination path for the pseudo-labeled image\n",
    "    destination_path = os.path.join(destination_dir, os.path.basename(filename))\n",
    "    \n",
    "    # Copy the pseudo-labeled image to the destination\n",
    "    shutil.copy(source_path, destination_path)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "52d30255",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'datasets/RAF-DB/DATASET/train/../labeled_train'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labeled_dir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c29666a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "checkpoints_path = os.path.join(labeled_dir, '.ipynb_checkpoints')\n",
    "if os.path.exists(checkpoints_path):\n",
    "    shutil.rmtree(checkpoints_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8d14b2e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 8989 images belonging to 7 classes.\n"
     ]
    }
   ],
   "source": [
    "# Initialize the data generator for the combined labeled and pseudo-labeled data\n",
    "train_data_gen_combined = ImageDataGenerator(\n",
    "    rescale=1./255,\n",
    "    validation_split=0.2  \n",
    ")\n",
    "\n",
    "# Load the combined training data\n",
    "train_generator_combined = train_data_gen_combined.flow_from_directory(\n",
    "    labeled_dir,  # both labeled and unlabeled images\n",
    "    target_size=(48, 48),\n",
    "    batch_size=64,\n",
    "    color_mode=\"grayscale\",\n",
    "    class_mode='categorical',\n",
    "    subset='training'\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4e8e4279",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'1': 0, '2': 1, '3': 2, '4': 3, '5': 4, '6': 5, '7': 6}\n",
      "{'1': 0, '2': 1, '3': 2, '4': 3, '5': 4, '6': 5, '7': 6}\n"
     ]
    }
   ],
   "source": [
    "print(train_generator_combined.class_indices)\n",
    "print(validation_generator.class_indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "bb20b477",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "140/140 [==============================] - 8s 56ms/step - loss: 0.4946 - accuracy: 0.8261 - val_loss: 0.6840 - val_accuracy: 0.7909\n",
      "Epoch 2/10\n",
      "140/140 [==============================] - 7s 51ms/step - loss: 0.4597 - accuracy: 0.8375 - val_loss: 0.6738 - val_accuracy: 0.7932\n",
      "Epoch 3/10\n",
      "140/140 [==============================] - 7s 50ms/step - loss: 0.4715 - accuracy: 0.8342 - val_loss: 0.6865 - val_accuracy: 0.7872\n",
      "Epoch 4/10\n",
      "140/140 [==============================] - 7s 48ms/step - loss: 0.4376 - accuracy: 0.8425 - val_loss: 0.6759 - val_accuracy: 0.7918\n",
      "Epoch 5/10\n",
      "140/140 [==============================] - 7s 51ms/step - loss: 0.4228 - accuracy: 0.8458 - val_loss: 0.6567 - val_accuracy: 0.7992\n",
      "Epoch 6/10\n",
      "140/140 [==============================] - 7s 49ms/step - loss: 0.4083 - accuracy: 0.8545 - val_loss: 0.6865 - val_accuracy: 0.7923\n",
      "Epoch 7/10\n",
      "140/140 [==============================] - 7s 50ms/step - loss: 0.3966 - accuracy: 0.8561 - val_loss: 0.6804 - val_accuracy: 0.7900\n",
      "Epoch 8/10\n",
      "140/140 [==============================] - 7s 53ms/step - loss: 0.3734 - accuracy: 0.8711 - val_loss: 0.6794 - val_accuracy: 0.7946\n",
      "Epoch 9/10\n",
      "140/140 [==============================] - 8s 58ms/step - loss: 0.3563 - accuracy: 0.8711 - val_loss: 0.6609 - val_accuracy: 0.8028\n",
      "Epoch 10/10\n",
      "140/140 [==============================] - 7s 48ms/step - loss: 0.3375 - accuracy: 0.8757 - val_loss: 0.6655 - val_accuracy: 0.7950\n"
     ]
    }
   ],
   "source": [
    "# Retrain the model on the combined dataset\n",
    "steps_per_epoch = train_generator_combined.samples // train_generator_combined.batch_size\n",
    "validation_steps = validation_generator.samples // validation_generator.batch_size\n",
    "\n",
    "model_info = model.fit(\n",
    "    train_generator_combined,\n",
    "    steps_per_epoch=steps_per_epoch,\n",
    "    epochs=10,  \n",
    "    validation_data=validation_generator,\n",
    "    validation_steps=validation_steps\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bae447cd",
   "metadata": {},
   "source": [
    "## Now, do this again but with our actual model (with attention)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2834e710",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                Output Shape                 Param #   Connected to                  \n",
      "==================================================================================================\n",
      " input_2 (InputLayer)        [(None, 48, 48, 1)]          0         []                            \n",
      "                                                                                                  \n",
      " conv2d_5 (Conv2D)           (None, 48, 48, 32)           320       ['input_2[0][0]']             \n",
      "                                                                                                  \n",
      " re_lu_1 (ReLU)              (None, 48, 48, 32)           0         ['conv2d_5[0][0]']            \n",
      "                                                                                                  \n",
      " batch_normalization_6 (Bat  (None, 48, 48, 32)           128       ['re_lu_1[0][0]']             \n",
      " chNormalization)                                                                                 \n",
      "                                                                                                  \n",
      " global_average_pooling2d_1  (None, 32)                   0         ['batch_normalization_6[0][0]'\n",
      "  (GlobalAveragePooling2D)                                          ]                             \n",
      "                                                                                                  \n",
      " dense_4 (Dense)             (None, 2)                    64        ['global_average_pooling2d_1[0\n",
      "                                                                    ][0]']                        \n",
      "                                                                                                  \n",
      " dense_5 (Dense)             (None, 32)                   64        ['dense_4[0][0]']             \n",
      "                                                                                                  \n",
      " reshape_1 (Reshape)         (None, 1, 1, 32)             0         ['dense_5[0][0]']             \n",
      "                                                                                                  \n",
      " multiply (Multiply)         (None, 48, 48, 32)           0         ['batch_normalization_6[0][0]'\n",
      "                                                                    , 'reshape_1[0][0]']          \n",
      "                                                                                                  \n",
      " conv2d_6 (Conv2D)           (None, 48, 48, 64)           18496     ['multiply[0][0]']            \n",
      "                                                                                                  \n",
      " re_lu_2 (ReLU)              (None, 48, 48, 64)           0         ['conv2d_6[0][0]']            \n",
      "                                                                                                  \n",
      " batch_normalization_7 (Bat  (None, 48, 48, 64)           256       ['re_lu_2[0][0]']             \n",
      " chNormalization)                                                                                 \n",
      "                                                                                                  \n",
      " global_average_pooling2d_2  (None, 64)                   0         ['batch_normalization_7[0][0]'\n",
      "  (GlobalAveragePooling2D)                                          ]                             \n",
      "                                                                                                  \n",
      " dense_6 (Dense)             (None, 4)                    256       ['global_average_pooling2d_2[0\n",
      "                                                                    ][0]']                        \n",
      "                                                                                                  \n",
      " dense_7 (Dense)             (None, 64)                   256       ['dense_6[0][0]']             \n",
      "                                                                                                  \n",
      " reshape_2 (Reshape)         (None, 1, 1, 64)             0         ['dense_7[0][0]']             \n",
      "                                                                                                  \n",
      " multiply_1 (Multiply)       (None, 48, 48, 64)           0         ['batch_normalization_7[0][0]'\n",
      "                                                                    , 'reshape_2[0][0]']          \n",
      "                                                                                                  \n",
      " max_pooling2d_3 (MaxPoolin  (None, 24, 24, 64)           0         ['multiply_1[0][0]']          \n",
      " g2D)                                                                                             \n",
      "                                                                                                  \n",
      " dropout_3 (Dropout)         (None, 24, 24, 64)           0         ['max_pooling2d_3[0][0]']     \n",
      "                                                                                                  \n",
      " conv2d_7 (Conv2D)           (None, 24, 24, 128)          73856     ['dropout_3[0][0]']           \n",
      "                                                                                                  \n",
      " re_lu_3 (ReLU)              (None, 24, 24, 128)          0         ['conv2d_7[0][0]']            \n",
      "                                                                                                  \n",
      " batch_normalization_8 (Bat  (None, 24, 24, 128)          512       ['re_lu_3[0][0]']             \n",
      " chNormalization)                                                                                 \n",
      "                                                                                                  \n",
      " global_average_pooling2d_3  (None, 128)                  0         ['batch_normalization_8[0][0]'\n",
      "  (GlobalAveragePooling2D)                                          ]                             \n",
      "                                                                                                  \n",
      " dense_8 (Dense)             (None, 8)                    1024      ['global_average_pooling2d_3[0\n",
      "                                                                    ][0]']                        \n",
      "                                                                                                  \n",
      " dense_9 (Dense)             (None, 128)                  1024      ['dense_8[0][0]']             \n",
      "                                                                                                  \n",
      " reshape_3 (Reshape)         (None, 1, 1, 128)            0         ['dense_9[0][0]']             \n",
      "                                                                                                  \n",
      " multiply_2 (Multiply)       (None, 24, 24, 128)          0         ['batch_normalization_8[0][0]'\n",
      "                                                                    , 'reshape_3[0][0]']          \n",
      "                                                                                                  \n",
      " max_pooling2d_4 (MaxPoolin  (None, 12, 12, 128)          0         ['multiply_2[0][0]']          \n",
      " g2D)                                                                                             \n",
      "                                                                                                  \n",
      " conv2d_8 (Conv2D)           (None, 12, 12, 128)          147584    ['max_pooling2d_4[0][0]']     \n",
      "                                                                                                  \n",
      " re_lu_4 (ReLU)              (None, 12, 12, 128)          0         ['conv2d_8[0][0]']            \n",
      "                                                                                                  \n",
      " batch_normalization_9 (Bat  (None, 12, 12, 128)          512       ['re_lu_4[0][0]']             \n",
      " chNormalization)                                                                                 \n",
      "                                                                                                  \n",
      " global_average_pooling2d_4  (None, 128)                  0         ['batch_normalization_9[0][0]'\n",
      "  (GlobalAveragePooling2D)                                          ]                             \n",
      "                                                                                                  \n",
      " dense_10 (Dense)            (None, 8)                    1024      ['global_average_pooling2d_4[0\n",
      "                                                                    ][0]']                        \n",
      "                                                                                                  \n",
      " dense_11 (Dense)            (None, 128)                  1024      ['dense_10[0][0]']            \n",
      "                                                                                                  \n",
      " reshape_4 (Reshape)         (None, 1, 1, 128)            0         ['dense_11[0][0]']            \n",
      "                                                                                                  \n",
      " multiply_3 (Multiply)       (None, 12, 12, 128)          0         ['batch_normalization_9[0][0]'\n",
      "                                                                    , 'reshape_4[0][0]']          \n",
      "                                                                                                  \n",
      " max_pooling2d_5 (MaxPoolin  (None, 6, 6, 128)            0         ['multiply_3[0][0]']          \n",
      " g2D)                                                                                             \n",
      "                                                                                                  \n",
      " dropout_4 (Dropout)         (None, 6, 6, 128)            0         ['max_pooling2d_5[0][0]']     \n",
      "                                                                                                  \n",
      " flatten_1 (Flatten)         (None, 4608)                 0         ['dropout_4[0][0]']           \n",
      "                                                                                                  \n",
      " dense_12 (Dense)            (None, 1024)                 4719616   ['flatten_1[0][0]']           \n",
      "                                                                                                  \n",
      " batch_normalization_10 (Ba  (None, 1024)                 4096      ['dense_12[0][0]']            \n",
      " tchNormalization)                                                                                \n",
      "                                                                                                  \n",
      " dropout_5 (Dropout)         (None, 1024)                 0         ['batch_normalization_10[0][0]\n",
      "                                                                    ']                            \n",
      "                                                                                                  \n",
      " dense_13 (Dense)            (None, 256)                  262400    ['dropout_5[0][0]']           \n",
      "                                                                                                  \n",
      " batch_normalization_11 (Ba  (None, 256)                  1024      ['dense_13[0][0]']            \n",
      " tchNormalization)                                                                                \n",
      "                                                                                                  \n",
      " dropout_6 (Dropout)         (None, 256)                  0         ['batch_normalization_11[0][0]\n",
      "                                                                    ']                            \n",
      "                                                                                                  \n",
      " dense_14 (Dense)            (None, 7)                    1799      ['dropout_6[0][0]']           \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 5235335 (19.97 MB)\n",
      "Trainable params: 5232071 (19.96 MB)\n",
      "Non-trainable params: 3264 (12.75 KB)\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "def squeeze_excite_block(input_tensor, ratio=16):\n",
    "    init = input_tensor\n",
    "    channel_axis = -1  \n",
    "    filters = init.shape[channel_axis]\n",
    "    \n",
    "    se = GlobalAveragePooling2D()(init)\n",
    "    se = Dense(filters // ratio, activation='relu', use_bias=False)(se)\n",
    "    se = Dense(filters, activation='sigmoid', use_bias=False)(se)\n",
    "    se = Reshape((1, 1, filters))(se)\n",
    "    x = Multiply()([init, se])\n",
    "    return x\n",
    "\n",
    "# Model definition, use Functional API instead of Sequential\n",
    "input_img = Input(shape=(48, 48, 1))\n",
    "\n",
    "# 1st conv block\n",
    "x = Conv2D(32, kernel_size=(3, 3), padding='same')(input_img)\n",
    "x = ReLU()(x)\n",
    "x = BatchNormalization()(x)\n",
    "x = squeeze_excite_block(x)  \n",
    "\n",
    "# 2nd conv block\n",
    "x = Conv2D(64, kernel_size=(3, 3), padding='same')(x)\n",
    "x = ReLU()(x)\n",
    "x = BatchNormalization()(x)\n",
    "x = squeeze_excite_block(x)  \n",
    "x = MaxPooling2D(pool_size=(2, 2))(x)\n",
    "x = Dropout(0.25)(x)\n",
    "\n",
    "# 3rd conv block\n",
    "x = Conv2D(128, kernel_size=(3, 3), padding='same')(x)\n",
    "x = ReLU()(x)\n",
    "x = BatchNormalization()(x)\n",
    "x = squeeze_excite_block(x)  \n",
    "x = MaxPooling2D(pool_size=(2, 2))(x)\n",
    "\n",
    "# 4th conv block\n",
    "x = Conv2D(128, kernel_size=(3, 3), padding='same')(x)\n",
    "x = ReLU()(x)\n",
    "x = BatchNormalization()(x)\n",
    "x = squeeze_excite_block(x)\n",
    "x = MaxPooling2D(pool_size=(2, 2))(x)\n",
    "x = Dropout(0.25)(x)\n",
    "\n",
    "# Flatten and Dense Layers\n",
    "x = Flatten()(x)\n",
    "x = Dense(1024, activation='relu')(x)\n",
    "x = BatchNormalization()(x)\n",
    "x = Dropout(0.5)(x)\n",
    "\n",
    "# Additional Dense layer to increase complexity\n",
    "x = Dense(256, activation='relu')(x)\n",
    "x = BatchNormalization()(x)\n",
    "x = Dropout(0.5)(x)\n",
    "\n",
    "# Output layer\n",
    "output = Dense(7, activation='softmax')(x)\n",
    "\n",
    "model_with_se = Model(inputs=input_img, outputs=output)\n",
    "\n",
    "\n",
    "# Set up the learning rate schedule and compile the model\n",
    "initial_learning_rate = 0.0001\n",
    "lr_schedule = ExponentialDecay(\n",
    "    initial_learning_rate,\n",
    "    decay_steps=100000,\n",
    "    decay_rate=0.96,\n",
    "    staircase=True)\n",
    "\n",
    "optimizer = Adam(learning_rate=lr_schedule)\n",
    "\n",
    "model_with_se.compile(optimizer=optimizer,\n",
    "              loss='categorical_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "model_with_se.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "66e6a41a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/25\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-03-22 02:32:33.773432: E tensorflow/core/grappler/optimizers/meta_optimizer.cc:954] layout failed: INVALID_ARGUMENT: Size of values 0 does not match size of permutation 4 @ fanin shape inmodel/dropout_3/dropout/SelectV2-2-TransposeNHWCToNCHW-LayoutOptimizer\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "122/122 [==============================] - 14s 55ms/step - loss: 2.5864 - accuracy: 0.2760 - val_loss: 2.0166 - val_accuracy: 0.2000\n",
      "Epoch 2/25\n",
      "122/122 [==============================] - 6s 52ms/step - loss: 2.0088 - accuracy: 0.4046 - val_loss: 3.3455 - val_accuracy: 0.1937\n",
      "Epoch 3/25\n",
      "122/122 [==============================] - 7s 54ms/step - loss: 1.7706 - accuracy: 0.4769 - val_loss: 3.7401 - val_accuracy: 0.1948\n",
      "Epoch 4/25\n",
      "122/122 [==============================] - 7s 53ms/step - loss: 1.6047 - accuracy: 0.5159 - val_loss: 2.3032 - val_accuracy: 0.3057\n",
      "Epoch 5/25\n",
      "122/122 [==============================] - 6s 52ms/step - loss: 1.4876 - accuracy: 0.5420 - val_loss: 1.3036 - val_accuracy: 0.5625\n",
      "Epoch 6/25\n",
      "122/122 [==============================] - 6s 51ms/step - loss: 1.3872 - accuracy: 0.5663 - val_loss: 1.0353 - val_accuracy: 0.6391\n",
      "Epoch 7/25\n",
      "122/122 [==============================] - 6s 49ms/step - loss: 1.3117 - accuracy: 0.5867 - val_loss: 0.9363 - val_accuracy: 0.6766\n",
      "Epoch 8/25\n",
      "122/122 [==============================] - 6s 48ms/step - loss: 1.2113 - accuracy: 0.6201 - val_loss: 0.8870 - val_accuracy: 0.6974\n",
      "Epoch 9/25\n",
      "122/122 [==============================] - 6s 48ms/step - loss: 1.1725 - accuracy: 0.6274 - val_loss: 0.8858 - val_accuracy: 0.6927\n",
      "Epoch 10/25\n",
      "122/122 [==============================] - 6s 48ms/step - loss: 1.0921 - accuracy: 0.6502 - val_loss: 0.8618 - val_accuracy: 0.7052\n",
      "Epoch 11/25\n",
      "122/122 [==============================] - 6s 48ms/step - loss: 1.0539 - accuracy: 0.6592 - val_loss: 0.8369 - val_accuracy: 0.7047\n",
      "Epoch 12/25\n",
      "122/122 [==============================] - 6s 45ms/step - loss: 1.0093 - accuracy: 0.6714 - val_loss: 0.7769 - val_accuracy: 0.7401\n",
      "Epoch 13/25\n",
      "122/122 [==============================] - 6s 48ms/step - loss: 0.9599 - accuracy: 0.6774 - val_loss: 0.7943 - val_accuracy: 0.7333\n",
      "Epoch 14/25\n",
      "122/122 [==============================] - 6s 47ms/step - loss: 0.9161 - accuracy: 0.6945 - val_loss: 0.7556 - val_accuracy: 0.7437\n",
      "Epoch 15/25\n",
      "122/122 [==============================] - 6s 45ms/step - loss: 0.8691 - accuracy: 0.7127 - val_loss: 0.7512 - val_accuracy: 0.7453\n",
      "Epoch 16/25\n",
      "122/122 [==============================] - 6s 50ms/step - loss: 0.8561 - accuracy: 0.7104 - val_loss: 0.7635 - val_accuracy: 0.7453\n",
      "Epoch 17/25\n",
      "122/122 [==============================] - 6s 51ms/step - loss: 0.8070 - accuracy: 0.7249 - val_loss: 0.7385 - val_accuracy: 0.7453\n",
      "Epoch 18/25\n",
      "122/122 [==============================] - 6s 52ms/step - loss: 0.7885 - accuracy: 0.7330 - val_loss: 0.7032 - val_accuracy: 0.7630\n",
      "Epoch 19/25\n",
      "122/122 [==============================] - 6s 51ms/step - loss: 0.7506 - accuracy: 0.7411 - val_loss: 0.6998 - val_accuracy: 0.7667\n",
      "Epoch 20/25\n",
      "122/122 [==============================] - 6s 51ms/step - loss: 0.7593 - accuracy: 0.7419 - val_loss: 0.6970 - val_accuracy: 0.7651\n",
      "Epoch 21/25\n",
      "122/122 [==============================] - 6s 51ms/step - loss: 0.7101 - accuracy: 0.7569 - val_loss: 0.7219 - val_accuracy: 0.7599\n",
      "Epoch 22/25\n",
      "122/122 [==============================] - 6s 51ms/step - loss: 0.6939 - accuracy: 0.7569 - val_loss: 0.7108 - val_accuracy: 0.7714\n",
      "Epoch 23/25\n",
      "122/122 [==============================] - 6s 48ms/step - loss: 0.6594 - accuracy: 0.7672 - val_loss: 0.6961 - val_accuracy: 0.7677\n",
      "Epoch 24/25\n",
      "122/122 [==============================] - 6s 48ms/step - loss: 0.6539 - accuracy: 0.7719 - val_loss: 0.6651 - val_accuracy: 0.7823\n",
      "Epoch 25/25\n",
      "122/122 [==============================] - 6s 52ms/step - loss: 0.6146 - accuracy: 0.7804 - val_loss: 0.7134 - val_accuracy: 0.7719\n"
     ]
    }
   ],
   "source": [
    "#initial training on just labeled\n",
    "model_with_se_info = model_with_se.fit(\n",
    "    train_generator,\n",
    "    steps_per_epoch=7855 // 64,  \n",
    "    epochs=25,  \n",
    "    validation_data=validation_generator,\n",
    "    validation_steps=1959 // 64  \n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "9283b2ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "140/140 [==============================] - 7s 52ms/step - loss: 0.6063 - accuracy: 0.7855 - val_loss: 0.7080 - val_accuracy: 0.7753\n",
      "Epoch 2/10\n",
      "140/140 [==============================] - 7s 47ms/step - loss: 0.5693 - accuracy: 0.8000 - val_loss: 0.6702 - val_accuracy: 0.7790\n",
      "Epoch 3/10\n",
      "140/140 [==============================] - 7s 49ms/step - loss: 0.5536 - accuracy: 0.8009 - val_loss: 0.6735 - val_accuracy: 0.7767\n",
      "Epoch 4/10\n",
      "140/140 [==============================] - 7s 48ms/step - loss: 0.5357 - accuracy: 0.8113 - val_loss: 0.6797 - val_accuracy: 0.7826\n",
      "Epoch 5/10\n",
      "140/140 [==============================] - 7s 49ms/step - loss: 0.5115 - accuracy: 0.8208 - val_loss: 0.6798 - val_accuracy: 0.7803\n",
      "Epoch 6/10\n",
      "140/140 [==============================] - 7s 48ms/step - loss: 0.5087 - accuracy: 0.8208 - val_loss: 0.6878 - val_accuracy: 0.7757\n",
      "Epoch 7/10\n",
      "140/140 [==============================] - 8s 54ms/step - loss: 0.4916 - accuracy: 0.8262 - val_loss: 0.6835 - val_accuracy: 0.7721\n",
      "Epoch 8/10\n",
      "140/140 [==============================] - 7s 49ms/step - loss: 0.4516 - accuracy: 0.8415 - val_loss: 0.6830 - val_accuracy: 0.7835\n",
      "Epoch 9/10\n",
      "140/140 [==============================] - 7s 46ms/step - loss: 0.4427 - accuracy: 0.8432 - val_loss: 0.6489 - val_accuracy: 0.7950\n",
      "Epoch 10/10\n",
      "140/140 [==============================] - 7s 52ms/step - loss: 0.4320 - accuracy: 0.8474 - val_loss: 0.6782 - val_accuracy: 0.7955\n"
     ]
    }
   ],
   "source": [
    "#retrain on combined\n",
    "steps_per_epoch = train_generator_combined.samples // train_generator_combined.batch_size\n",
    "validation_steps = validation_generator.samples // validation_generator.batch_size\n",
    "\n",
    "model_with_se_info = model_with_se.fit(\n",
    "    train_generator_combined,\n",
    "    steps_per_epoch=steps_per_epoch,\n",
    "    epochs=10,  \n",
    "    validation_data=validation_generator,\n",
    "    validation_steps=validation_steps\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c82fa6f8",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize\n",
    "\n",
    "accuracy = model_with_se_info.history['accuracy']\n",
    "val_accuracy = model_with_se_info.history['val_accuracy']\n",
    "loss = model_with_se_info.history['loss']\n",
    "val_loss = model_with_se_info.history['val_loss']\n",
    "\n",
    "plt.figure(figsize=(12, 5))\n",
    "\n",
    "# accuracy graph\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(accuracy, label='accuracy')\n",
    "plt.plot(val_accuracy, label='val accuracy')\n",
    "plt.title('Accuracy for Improved SE Model on RAF-DB')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "\n",
    "# loss graph\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(loss, label='loss')\n",
    "plt.plot(val_loss, label='val loss')\n",
    "plt.title('Loss for Improved SE Model on RAF-DB')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "458da3c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48/48 [==============================] - 5s 97ms/step - loss: 0.7565 - accuracy: 0.7643\n",
      "Test loss: 0.7564506530761719\n",
      "Test accuracy: 0.7643415927886963\n"
     ]
    }
   ],
   "source": [
    "results = model_with_se.evaluate(test_generator, steps=len(test_generator))\n",
    "\n",
    "# Test results\n",
    "print(\"Test loss:\", results[0])\n",
    "print(\"Test accuracy:\", results[1])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (clean)",
   "language": "python",
   "name": "python3_clean"
  },
  "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.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}