STAGE_D.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "98581fcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2d1a7765",
   "metadata": {},
   "outputs": [],
   "source": [
    "train = pd.read_csv(\"C:/Users/godso/Desktop/jupyter/kaggle/train_v2.csv/train_v2.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0f7266cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>image_name</th>\n",
       "      <th>tags</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>train_0</td>\n",
       "      <td>haze primary</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>train_1</td>\n",
       "      <td>agriculture clear primary water</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>train_2</td>\n",
       "      <td>clear primary</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>train_3</td>\n",
       "      <td>clear primary</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>train_4</td>\n",
       "      <td>agriculture clear habitation primary road</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40474</th>\n",
       "      <td>train_40474</td>\n",
       "      <td>clear primary</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40475</th>\n",
       "      <td>train_40475</td>\n",
       "      <td>cloudy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40476</th>\n",
       "      <td>train_40476</td>\n",
       "      <td>agriculture clear primary</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40477</th>\n",
       "      <td>train_40477</td>\n",
       "      <td>agriculture clear primary road</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40478</th>\n",
       "      <td>train_40478</td>\n",
       "      <td>agriculture cultivation partly_cloudy primary</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>40479 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "        image_name                                           tags\n",
       "0          train_0                                   haze primary\n",
       "1          train_1                agriculture clear primary water\n",
       "2          train_2                                  clear primary\n",
       "3          train_3                                  clear primary\n",
       "4          train_4      agriculture clear habitation primary road\n",
       "...            ...                                            ...\n",
       "40474  train_40474                                  clear primary\n",
       "40475  train_40475                                         cloudy\n",
       "40476  train_40476                      agriculture clear primary\n",
       "40477  train_40477                 agriculture clear primary road\n",
       "40478  train_40478  agriculture cultivation partly_cloudy primary\n",
       "\n",
       "[40479 rows x 2 columns]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c5d03cfa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['bare_ground', 'selective_logging', 'blow_down', 'cultivation', 'haze', 'artisinal_mine', 'water', 'clear', 'road', 'blooming', 'cloudy', 'habitation', 'conventional_mine', 'agriculture', 'partly_cloudy', 'primary', 'slash_burn']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "labels = set()\n",
    "def splitting_tags(tags):\n",
    "    for tag in tags.split():\n",
    "        labels.add(tag)\n",
    "#we redefine the train_classes by creating a copy of it so as not to overwrite the existing one. \n",
    "#so a copy of the train classes is stored in the variable train_classes1, we convert labels which is a set to a list.\n",
    "train_classes = train.copy()\n",
    "train_classes['tags'].apply(splitting_tags)\n",
    "labels = list(labels)\n",
    "print(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0c2e794f",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert len(train_classes['image_name'].unique()) == train_classes.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ba306745",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>image_name</th>\n",
       "      <th>tags</th>\n",
       "      <th>bare_ground</th>\n",
       "      <th>selective_logging</th>\n",
       "      <th>blow_down</th>\n",
       "      <th>cultivation</th>\n",
       "      <th>haze</th>\n",
       "      <th>artisinal_mine</th>\n",
       "      <th>water</th>\n",
       "      <th>clear</th>\n",
       "      <th>road</th>\n",
       "      <th>blooming</th>\n",
       "      <th>cloudy</th>\n",
       "      <th>habitation</th>\n",
       "      <th>conventional_mine</th>\n",
       "      <th>agriculture</th>\n",
       "      <th>partly_cloudy</th>\n",
       "      <th>primary</th>\n",
       "      <th>slash_burn</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>train_0.jpg</td>\n",
       "      <td>haze primary</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>train_1.jpg</td>\n",
       "      <td>agriculture clear primary water</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>train_2.jpg</td>\n",
       "      <td>clear primary</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>train_3.jpg</td>\n",
       "      <td>clear primary</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>train_4.jpg</td>\n",
       "      <td>agriculture clear habitation primary road</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    image_name                                       tags  bare_ground  \\\n",
       "0  train_0.jpg                               haze primary            0   \n",
       "1  train_1.jpg            agriculture clear primary water            0   \n",
       "2  train_2.jpg                              clear primary            0   \n",
       "3  train_3.jpg                              clear primary            0   \n",
       "4  train_4.jpg  agriculture clear habitation primary road            0   \n",
       "\n",
       "   selective_logging  blow_down  cultivation  haze  artisinal_mine  water  \\\n",
       "0                  0          0            0     1               0      0   \n",
       "1                  0          0            0     0               0      1   \n",
       "2                  0          0            0     0               0      0   \n",
       "3                  0          0            0     0               0      0   \n",
       "4                  0          0            0     0               0      0   \n",
       "\n",
       "   clear  road  blooming  cloudy  habitation  conventional_mine  agriculture  \\\n",
       "0      0     0         0       0           0                  0            0   \n",
       "1      1     0         0       0           0                  0            1   \n",
       "2      1     0         0       0           0                  0            0   \n",
       "3      1     0         0       0           0                  0            0   \n",
       "4      1     1         0       0           1                  0            1   \n",
       "\n",
       "   partly_cloudy  primary  slash_burn  \n",
       "0              0        1           0  \n",
       "1              0        1           0  \n",
       "2              0        1           0  \n",
       "3              0        1           0  \n",
       "4              0        1           0  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##One hot encoding is performed on the labels in train classes\n",
    "for tag in labels:\n",
    "    train_classes[tag] = train_classes['tags'].apply(lambda x: 1 if tag in x.split() else 0)\n",
    "    \n",
    "## adding .jpg extension to the column image_name so as to have same name format as the image files\n",
    "train_classes['image_name'] = train_classes['image_name'].apply(lambda x: '{}.jpg'.format(x))\n",
    "train_classes.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "86c01a12",
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing tensorflow libraries for training the dataset\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, BatchNormalization, Conv2D, MaxPooling2D\n",
    "from tensorflow.keras.layers import Dropout, Flatten\n",
    "from tensorflow.keras.optimizers import Adam, SGD\n",
    "from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, TensorBoard\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "894a209a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#defining the columns, that is the labels that were newly added to the train_classes via hot encoding.\n",
    "columns = list(train_classes.columns[2:]) #from index 2 to the end defines the columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7b923c83",
   "metadata": {},
   "outputs": [],
   "source": [
    "#define a function for fbeta scoring\n",
    "def fbeta(y_true, y_pred, beta = 2, epsilon = 1e-4):\n",
    "    \n",
    "    beta_squared = beta**2\n",
    "    \n",
    "    y_true = tf.cast(y_true, tf.float32)\n",
    "    y_pred = tf.cast(tf.greater(tf.cast(y_pred, tf.float32), tf.constant(0.5)), tf.float32)\n",
    "    \n",
    "    tp = tf.reduce_sum(y_true * y_pred, axis = 1)\n",
    "    fp = tf.reduce_sum(y_pred, axis = 1) - tp\n",
    "    fn = tf.reduce_sum(y_true, axis = 1) - tp\n",
    "    \n",
    "    precision = tp/(tp+fp+epsilon)\n",
    "    recall = tp/(tp+fn+epsilon)\n",
    "    \n",
    "    fb = (1+beta_squared)*precision*recall / (beta_squared*precision+recall+epsilon)\n",
    "    return fb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2724f8b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#define a function for accuracy for multi_label classification\n",
    "def multi_label_acc(y_true, y_pred, epsilon = 1e-4):\n",
    "    \n",
    "    y_true = tf.cast(y_true, tf.float32)\n",
    "    y_pred = tf.cast(tf.greater(tf.cast(y_pred, tf.float32), tf.constant(0.5)), tf.float32)\n",
    "    \n",
    "    tp = tf.reduce_sum(y_true * y_pred, axis = 1)\n",
    "    fp = tf.reduce_sum(y_pred, axis = 1) - tp\n",
    "    fn = tf.reduce_sum(y_true, axis = 1) - tp\n",
    "    \n",
    "    y_true = tf.cast(y_true, tf.bool)\n",
    "    y_pred = tf.cast(y_pred, tf.bool)\n",
    "        \n",
    "    tn = tf.reduce_sum(tf.cast(tf.logical_not(y_true), tf.float32) * tf.cast(tf.logical_not(y_pred), tf.float32), \n",
    "                       axis = 1)\n",
    "    return (tp+tn)/(tp+tn+fp+fn+epsilon)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4cc0d9bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "#defining our model using a function build_model()\n",
    "def build_model():\n",
    "    model = Sequential()\n",
    "    model.add(BatchNormalization(input_shape=(128, 128, 3)))\n",
    "    model.add(Conv2D(32, kernel_size=(3, 3), padding='same', activation='relu'))\n",
    "    model.add(Conv2D(32, kernel_size=(3, 3), activation='relu'))\n",
    "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "    model.add(Dropout(0.2))\n",
    "\n",
    "    model.add(Conv2D(64, kernel_size=(3, 3), padding='same', activation='relu'))\n",
    "    model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))\n",
    "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "    model.add(Dropout(0.2))\n",
    "\n",
    "    model.add(Conv2D(128, kernel_size=(3, 3), padding='same', activation='relu'))\n",
    "    model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))\n",
    "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "    model.add(Dropout(0.2))\n",
    "\n",
    "    model.add(Conv2D(256, kernel_size=(3, 3), padding='same', activation='relu'))\n",
    "    model.add(Conv2D(256, kernel_size=(3, 3), activation='relu'))\n",
    "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "    model.add(Dropout(0.2))\n",
    "\n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(512, activation='relu'))\n",
    "    model.add(Dropout(0.5))\n",
    "    model.add(Dense(17, activation='sigmoid'))\n",
    "\n",
    "    opt = Adam(lr=1e-4)\n",
    "\n",
    "    model.compile(loss='binary_crossentropy',\n",
    "              # We NEED binary here, since categorical_crossentropy l1 norms the output before calculating loss.\n",
    "              optimizer=opt,\n",
    "              metrics=[multi_label_acc, fbeta])\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0bd11c18",
   "metadata": {},
   "outputs": [],
   "source": [
    "#modelcheckpoint is set to monitor the model using validation fbeta score and save the best only\n",
    "save_best_check_point = ModelCheckpoint(filepath = 'best_model.hdf5', monitor = 'val_fbeta', mode = 'max',\n",
    "                                       save_best_only = True, save_weights_only = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "fe1a757f",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 32384 validated image filenames.\n",
      "Found 8095 validated image filenames.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#initializing imagedatagenerator with a validation split of 0.2\n",
    "train_image_gen = ImageDataGenerator(rescale = 1/255, validation_split = 0.2)\n",
    "\n",
    "#generating train data generator which is 80% of the train dataset\n",
    "#note that a generator contains both features and target of the data\n",
    "train_generator = train_image_gen.flow_from_dataframe(dataframe=train_classes,\n",
    "                                                directory =\"C:/Users/godso/Desktop/jupyter/kaggle/train-jpg\",  \n",
    "                                                x_col=\"image_name\", y_col=columns, subset=\"training\", \n",
    "                                                batch_size=16,seed=2021, shuffle=True, \n",
    "                                                class_mode=\"raw\", target_size=(128,128))\n",
    "\n",
    "#generating validation data which is expected to be 20% of the train dataset since validation split is 0.2\n",
    "val_generator = train_image_gen.flow_from_dataframe(dataframe=train_classes,\n",
    "                                                directory =\"C:/Users/godso/Desktop/jupyter/kaggle/train-jpg\",  \n",
    "                                                x_col=\"image_name\", y_col=columns, subset=\"validation\", \n",
    "                                                batch_size=16,seed=2021, shuffle=True, \n",
    "                                                class_mode=\"raw\", target_size=(128,128))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "eec4417c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#setting up step size for training and validation image data\n",
    "step_train_size = int(np.ceil(train_generator.samples / train_generator.batch_size))\n",
    "step_val_size = int(np.ceil(val_generator.samples / val_generator.batch_size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "02b26e97",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\godso\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\keras\\optimizers\\optimizer_v2\\adam.py:114: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
      "  super().__init__(name, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "#initializing the model\n",
    "model1 = build_model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9bb3591d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#this shows the summary of the model, simply put as the model architecture\n",
    "model1.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7331b52",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/25\n",
      "2024/2024 [==============================] - 1205s 595ms/step - loss: 0.2158 - multi_label_acc: 0.9180 - fbeta: 0.7050 - val_loss: 0.1634 - val_multi_label_acc: 0.9364 - val_fbeta: 0.7828\n",
      "Epoch 2/25\n",
      "2024/2024 [==============================] - 1148s 567ms/step - loss: 0.1632 - multi_label_acc: 0.9354 - fbeta: 0.7856 - val_loss: 0.1434 - val_multi_label_acc: 0.9441 - val_fbeta: 0.8039\n",
      "Epoch 3/25\n",
      "2024/2024 [==============================] - 1149s 568ms/step - loss: 0.1480 - multi_label_acc: 0.9410 - fbeta: 0.8068 - val_loss: 0.1355 - val_multi_label_acc: 0.9467 - val_fbeta: 0.8172\n",
      "Epoch 4/25\n",
      "2024/2024 [==============================] - 1157s 572ms/step - loss: 0.1402 - multi_label_acc: 0.9446 - fbeta: 0.8202 - val_loss: 0.1268 - val_multi_label_acc: 0.9499 - val_fbeta: 0.8327\n",
      "Epoch 5/25\n",
      "2024/2024 [==============================] - 1181s 584ms/step - loss: 0.1328 - multi_label_acc: 0.9474 - fbeta: 0.8315 - val_loss: 0.1251 - val_multi_label_acc: 0.9497 - val_fbeta: 0.8335\n",
      "Epoch 6/25\n",
      "2024/2024 [==============================] - 1257s 621ms/step - loss: 0.1273 - multi_label_acc: 0.9492 - fbeta: 0.8395 - val_loss: 0.1166 - val_multi_label_acc: 0.9544 - val_fbeta: 0.8565\n",
      "Epoch 7/25\n",
      "2024/2024 [==============================] - 1280s 633ms/step - loss: 0.1219 - multi_label_acc: 0.9517 - fbeta: 0.8500 - val_loss: 0.1163 - val_multi_label_acc: 0.9545 - val_fbeta: 0.8573\n",
      "Epoch 8/25\n",
      "2024/2024 [==============================] - 1576s 779ms/step - loss: 0.1175 - multi_label_acc: 0.9537 - fbeta: 0.8576 - val_loss: 0.1120 - val_multi_label_acc: 0.9562 - val_fbeta: 0.8700\n",
      "Epoch 9/25\n",
      "2024/2024 [==============================] - 3037s 2s/step - loss: 0.1139 - multi_label_acc: 0.9553 - fbeta: 0.8626 - val_loss: 0.1117 - val_multi_label_acc: 0.9564 - val_fbeta: 0.8642\n",
      "Epoch 10/25\n",
      "2024/2024 [==============================] - 2730s 1s/step - loss: 0.1108 - multi_label_acc: 0.9564 - fbeta: 0.8666 - val_loss: 0.1097 - val_multi_label_acc: 0.9581 - val_fbeta: 0.8674\n",
      "Epoch 11/25\n",
      "2024/2024 [==============================] - 1170s 578ms/step - loss: 0.1072 - multi_label_acc: 0.9576 - fbeta: 0.8710 - val_loss: 0.1086 - val_multi_label_acc: 0.9584 - val_fbeta: 0.8759\n",
      "Epoch 12/25\n",
      "2024/2024 [==============================] - 1169s 578ms/step - loss: 0.1040 - multi_label_acc: 0.9591 - fbeta: 0.8773 - val_loss: 0.1064 - val_multi_label_acc: 0.9591 - val_fbeta: 0.8785\n",
      "Epoch 13/25\n",
      "2024/2024 [==============================] - 1153s 570ms/step - loss: 0.1006 - multi_label_acc: 0.9603 - fbeta: 0.8805 - val_loss: 0.1106 - val_multi_label_acc: 0.9574 - val_fbeta: 0.8702\n",
      "Epoch 14/25\n",
      "2024/2024 [==============================] - 1159s 573ms/step - loss: 0.0983 - multi_label_acc: 0.9610 - fbeta: 0.8827 - val_loss: 0.1099 - val_multi_label_acc: 0.9581 - val_fbeta: 0.8737\n",
      "Epoch 15/25\n",
      "2024/2024 [==============================] - 1153s 570ms/step - loss: 0.0953 - multi_label_acc: 0.9622 - fbeta: 0.8864 - val_loss: 0.1102 - val_multi_label_acc: 0.9598 - val_fbeta: 0.8769\n",
      "Epoch 16/25\n",
      "2024/2024 [==============================] - 1151s 569ms/step - loss: 0.0919 - multi_label_acc: 0.9634 - fbeta: 0.8913 - val_loss: 0.1065 - val_multi_label_acc: 0.9593 - val_fbeta: 0.8827\n",
      "Epoch 17/25\n",
      "2024/2024 [==============================] - 1149s 568ms/step - loss: 0.0892 - multi_label_acc: 0.9644 - fbeta: 0.8933 - val_loss: 0.1081 - val_multi_label_acc: 0.9591 - val_fbeta: 0.8821\n",
      "Epoch 18/25\n",
      "1300/2024 [==================>...........] - ETA: 6:32 - loss: 0.0849 - multi_label_acc: 0.9660 - fbeta: 0.8985"
     ]
    }
   ],
   "source": [
    "#fitting our model using the parameters already defined \n",
    "model1.fit(x = train_generator, steps_per_epoch = step_train_size, validation_data = val_generator, \n",
    "           validation_steps = step_val_size,epochs = 25, \n",
    "           callbacks = [save_best_check_point])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9dfe6124",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\godso\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\keras\\optimizers\\optimizer_v2\\adam.py:114: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
      "  super().__init__(name, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "#initializing a second model so we can make predictions\n",
    "model2 = build_model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d493a9d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>image_name</th>\n",
       "      <th>tags</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>test_0.jpg</td>\n",
       "      <td>primary clear agriculture road water</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>test_1.jpg</td>\n",
       "      <td>primary clear agriculture road water</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>test_2.jpg</td>\n",
       "      <td>primary clear agriculture road water</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>test_3.jpg</td>\n",
       "      <td>primary clear agriculture road water</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>test_4.jpg</td>\n",
       "      <td>primary clear agriculture road water</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   image_name                                  tags\n",
       "0  test_0.jpg  primary clear agriculture road water\n",
       "1  test_1.jpg  primary clear agriculture road water\n",
       "2  test_2.jpg  primary clear agriculture road water\n",
       "3  test_3.jpg  primary clear agriculture road water\n",
       "4  test_4.jpg  primary clear agriculture road water"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##adding .jpg extension to image name in the sample submission file\n",
    "sample_submission = pd.read_csv(\"C:/Users/godso/Desktop/jupyter/sample_submission_v2.csv\")\n",
    "sample_submission1 = sample_submission.copy()\n",
    "sample_submission1['image_name'] = sample_submission1['image_name'].apply(lambda x: '{}.jpg'.format(x))\n",
    "sample_submission1.head()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27ece4be",
   "metadata": {},
   "outputs": [],
   "source": [
    "#loading in the weights of the trained model so we can make predictions with it\n",
    "model2.load_weights('best_model.hdf5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ca5fd04",
   "metadata": {},
   "outputs": [],
   "source": [
    "#we divide the sample submission file into two splits, first test1_df which contains the first 40669 images \n",
    "test1_df = sample_submission1.iloc[:40669]['image_name'].reset_index().drop('index', axis =1)\n",
    "test1_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26d9cdc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_image_gen = ImageDataGenerator(rescale = 1/255)\n",
    "\n",
    "\n",
    "#creating a generator for the images found in the first test image files\n",
    "test_generator1 = test_image_gen.flow_from_dataframe(dataframe=test1_df, \n",
    "                                                directory=\"C:/Users/godso/Desktop/jupyter/kaggle/test-jpg\", \n",
    "                                                x_col=\"image_name\", y_col=None, batch_size=16, \n",
    "                                                shuffle=False, class_mode=None, target_size=(128,128))\n",
    "\n",
    "step_test_size1 = int(np.ceil(test_generator1.samples/test_generator1.batch_size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92eb0a71",
   "metadata": {},
   "outputs": [],
   "source": [
    "#first, we reset the test generator to avoid shuffling of index as we want it to be orderly\n",
    "test_generator1.reset()\n",
    "pred1 = model2.predict(test_generator1, steps = step_test_size1, verbose = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6afd7726",
   "metadata": {},
   "outputs": [],
   "source": [
    "#this is to get the filenames in the generator using the attribute .filenames\n",
    "file_names1 = test_generator1.filenames\n",
    "\n",
    "#convert the predicted values to a dataframe and join two labels together if the probability of occurrance \n",
    "#of the label is greater than 0.5 \n",
    "pred_tags1 = pd.DataFrame(pred1)\n",
    "pred_tags1 = pred_tags1.apply(lambda x: ' '.join(np.array(labels)[x>0.5]), axis = 1)\n",
    "\n",
    "#then the result should look like this \n",
    "result1 = pd.DataFrame({'image_name': file_names1, 'tags': pred_tags1})\n",
    "result1.head()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c618371",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#second batch of the test dataset\n",
    "test2_df = sample_submission1.iloc[40669:]['image_name'].reset_index().drop('index', axis =1)\n",
    "test2_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "135d2579",
   "metadata": {},
   "outputs": [],
   "source": [
    "#creating a generator for the second batch of test image files\n",
    "test_generator2 = test_image_gen.flow_from_dataframe(dataframe=test2_df, \n",
    "                                                directory=\"C:/Users/godso/Desktop/jupyter/kaggle/test-jpg-additional/test\", \n",
    "                                                x_col=\"image_name\", y_col=None, batch_size=16, \n",
    "                                                shuffle=False, class_mode=None, target_size=(128,128))\n",
    "\n",
    "step_test_size2 = int(np.ceil(test_generator2.samples/test_generator2.batch_size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8dedf78a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#we reset the generator to avoid shuffling, then make prediction on the generator\n",
    "test_generator2.reset()\n",
    "pred2 = model2.predict(test_generator2, steps = step_test_size2, verbose = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e47b3266",
   "metadata": {},
   "outputs": [],
   "source": [
    "#this is to get the filenames in the generator using the attribute .filenames\n",
    "file_names2 = test_generator2.filenames\n",
    "\n",
    "#convert the predicted values to a dataframe and join two labels together if the probability of occurrance \n",
    "#of the label is greater than 0.5\n",
    "pred_tags2 = pd.DataFrame(pred2)\n",
    "pred_tags2 = pred_tags2.apply(lambda x: ''.join(np.array(labels)[x>0.5]), axis = 1)\n",
    "\n",
    "#then the result should look like this\n",
    "result2 = pd.DataFrame({'image_name': file_names2, 'tags': pred_tags2})\n",
    "result2.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1142732a",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#for the final result of the predicted tags for the test images, we need to concat the first and second results in \n",
    "#that order to avoid shuffling the index\n",
    "last_result = pd.concat([result1, result2])\n",
    "\n",
    "last_result = last_result.reset_index().drop('index', axis =1)\n",
    "\n",
    "print(last_result.shape)\n",
    "#print the final result\n",
    "last_result.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a08557b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "#we need to remove the .jpg extension from the image_name of the last_result because from the sample submission the \n",
    "#extension was not there, we added it for easy manipulation of the data.\n",
    "last_result['image_name'] = last_result['image_name'].apply(lambda x: x[:-4])\n",
    "last_result.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3af010af",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Finally, we save the result to a csv file using the .to_csv() method and setting the index to false.\n",
    "last_result.to_csv('substage.csv', index = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8853a8bc",
   "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.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}