{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1587aa08",
   "metadata": {},
   "source": [
    "# Lesson 28: TensorFlow/Keras classification activity\n",
    "\n",
    "## Notebook set up\n",
    "\n",
    "### Vocareum compatibility\n",
    "\n",
    "Check the notebook path to determine if we are running in Vocareum, if so, install TensorFlow 2.17 and Keras 3.2.0 via pip."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "96b7c4f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "# Get the parts of the current directory path as a tuple\n",
    "path_parts = Path.cwd().parts\n",
    "\n",
    "# Check if 'voc' is the first directory level\n",
    "is_voc_root = len(path_parts) > 1 and path_parts[1] == \"voc\"\n",
    "\n",
    "# If we are in a Vocareum instance, upgrade TensorFlow and Keras\n",
    "if is_voc_root:\n",
    "    print(\"Running in Vocareum environment\")\n",
    "\n",
    "    get_ipython().run_line_magic(\n",
    "        \"pip\", \"install -qq --no-warn-script-location tensorflow==2.17.0 keras==3.2.0\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "790c0e7d",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "39b9bf45",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Suppress noisy TensorFlow logs before importing\n",
    "import os\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'\n",
    "\n",
    "# Standard library imports\n",
    "import itertools\n",
    "\n",
    "from pathlib import Path\n",
    "from shutil import rmtree\n",
    "from typing import Tuple, Optional\n",
    "\n",
    "# Third party imports\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import accuracy_score, ConfusionMatrixDisplay\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.utils.class_weight import compute_class_weight\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras.callbacks import EarlyStopping, TensorBoard"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a6707ac",
   "metadata": {},
   "source": [
    "### GPU configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8982d6f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using GPU: NVIDIA GeForce GTX 1070, compute capability 6.1\n",
      "Memory growth enabled\n"
     ]
    }
   ],
   "source": [
    "# Configure GPU settings\n",
    "gpus = tf.config.list_physical_devices('GPU')\n",
    "\n",
    "if gpus:\n",
    "    try:\n",
    "        # Use only GPU 0\n",
    "        tf.config.set_visible_devices(gpus[0], 'GPU')\n",
    "\n",
    "        # Enable memory growth\n",
    "        tf.config.experimental.set_memory_growth(gpus[0], True)\n",
    "\n",
    "        # Get GPU\n",
    "        details = tf.config.experimental.get_device_details(gpus[0])\n",
    "        cc = details.get('compute_capability', (0, 0))\n",
    "        device = details.get('device_name', '')\n",
    "\n",
    "        print(f'Using GPU: {device}, compute capability {cc[0]}.{cc[1]}')\n",
    "        print('Memory growth enabled')\n",
    "\n",
    "    except RuntimeError as e:\n",
    "        print(e)\n",
    "\n",
    "else:\n",
    "    print('No GPU found')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13ba26d9",
   "metadata": {},
   "source": [
    "### Global TensorFlow training configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "73b5ddcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove and recreate logs directory to clear any old TensorBoard logs\n",
    "log_dir = ('../logs')\n",
    "rmtree(log_dir, ignore_errors=True)\n",
    "Path(log_dir).mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "# Set verbosity for wherever it's accepted\n",
    "verbose = 0\n",
    "\n",
    "# Fix TensorFlow random state for reproducibility\n",
    "tf.random.set_seed(315)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98f5eab8",
   "metadata": {},
   "source": [
    "## 1. Data preparation\n",
    "\n",
    "### 1.1. Load occupancy data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e94bf1e5",
   "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>date</th>\n",
       "      <th>Temperature</th>\n",
       "      <th>Humidity</th>\n",
       "      <th>Light</th>\n",
       "      <th>CO2</th>\n",
       "      <th>HumidityRatio</th>\n",
       "      <th>Occupancy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2015-02-04 17:51:00</td>\n",
       "      <td>23.18</td>\n",
       "      <td>27.2720</td>\n",
       "      <td>426.0</td>\n",
       "      <td>721.25</td>\n",
       "      <td>0.004793</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2015-02-04 17:51:59</td>\n",
       "      <td>23.15</td>\n",
       "      <td>27.2675</td>\n",
       "      <td>429.5</td>\n",
       "      <td>714.00</td>\n",
       "      <td>0.004783</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2015-02-04 17:53:00</td>\n",
       "      <td>23.15</td>\n",
       "      <td>27.2450</td>\n",
       "      <td>426.0</td>\n",
       "      <td>713.50</td>\n",
       "      <td>0.004779</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2015-02-04 17:54:00</td>\n",
       "      <td>23.15</td>\n",
       "      <td>27.2000</td>\n",
       "      <td>426.0</td>\n",
       "      <td>708.25</td>\n",
       "      <td>0.004772</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2015-02-04 17:55:00</td>\n",
       "      <td>23.10</td>\n",
       "      <td>27.2000</td>\n",
       "      <td>426.0</td>\n",
       "      <td>704.50</td>\n",
       "      <td>0.004757</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  date  Temperature  Humidity  Light     CO2  HumidityRatio  \\\n",
       "0  2015-02-04 17:51:00        23.18   27.2720  426.0  721.25       0.004793   \n",
       "1  2015-02-04 17:51:59        23.15   27.2675  429.5  714.00       0.004783   \n",
       "2  2015-02-04 17:53:00        23.15   27.2450  426.0  713.50       0.004779   \n",
       "3  2015-02-04 17:54:00        23.15   27.2000  426.0  708.25       0.004772   \n",
       "4  2015-02-04 17:55:00        23.10   27.2000  426.0  704.50       0.004757   \n",
       "\n",
       "   Occupancy  \n",
       "0          1  \n",
       "1          1  \n",
       "2          1  \n",
       "3          1  \n",
       "4          1  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "occupancy_df = pd.read_csv('https://gperdrizet.github.io/FSA_devops/assets/data/unit4/occupancy_data.csv')\n",
    "occupancy_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0561763f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 20560 entries, 0 to 20559\n",
      "Data columns (total 7 columns):\n",
      " #   Column         Non-Null Count  Dtype  \n",
      "---  ------         --------------  -----  \n",
      " 0   date           20560 non-null  object \n",
      " 1   Temperature    20560 non-null  float64\n",
      " 2   Humidity       20560 non-null  float64\n",
      " 3   Light          20560 non-null  float64\n",
      " 4   CO2            20560 non-null  float64\n",
      " 5   HumidityRatio  20560 non-null  float64\n",
      " 6   Occupancy      20560 non-null  int64  \n",
      "dtypes: float64(5), int64(1), object(1)\n",
      "memory usage: 1.1+ MB\n"
     ]
    }
   ],
   "source": [
    "occupancy_df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d5716bd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "label = 'Occupancy'\n",
    "features = ['Temperature','Humidity','Light','CO2','HumidityRatio']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdce7333",
   "metadata": {},
   "source": [
    "### 1.2. Train test split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "43267e58",
   "metadata": {},
   "outputs": [],
   "source": [
    "training_df, testing_df = train_test_split(occupancy_df, random_state=315)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cea0e509",
   "metadata": {},
   "source": [
    "### 1.3. Standard scale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "63115680",
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_scaler = StandardScaler()\n",
    "feature_scaler.fit(training_df[features])\n",
    "\n",
    "training_df[features] = feature_scaler.transform(training_df[features])\n",
    "testing_df[features] = feature_scaler.transform(testing_df[features])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bccff99",
   "metadata": {},
   "source": [
    "## 2. Logistic regression baseline\n",
    "\n",
    "### 2.1. Fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d8e85966",
   "metadata": {},
   "outputs": [],
   "source": [
    "logistic_model = LogisticRegression(n_jobs=-1, random_state=315)\n",
    "fit_result = logistic_model.fit(training_df[features], training_df[label])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31d5c9c2",
   "metadata": {},
   "source": [
    "### 2.2. Test set evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b9eea129",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic regression accuracy on test set: 0.9907\n"
     ]
    }
   ],
   "source": [
    "logistic_predictions = logistic_model.predict(testing_df[features])\n",
    "logistic_accuracy = accuracy_score(testing_df[label], logistic_predictions)\n",
    "print(f'Logistic regression accuracy on test set: {logistic_accuracy:.4f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01f45893",
   "metadata": {},
   "source": [
    "## 3. DNN model\n",
    "\n",
    "### 3.1. Compute class weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b4d0bdae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class weights: {0: 0.6505231184610193, 1: 2.1608744394618835}\n"
     ]
    }
   ],
   "source": [
    "# Compute class weights to handle class imbalance\n",
    "class_weights = compute_class_weight(\n",
    "    class_weight='balanced',\n",
    "    classes=np.unique(training_df[label]),\n",
    "    y=training_df[label]\n",
    ")\n",
    "\n",
    "class_weight_dict = dict(enumerate(class_weights))\n",
    "print(f'Class weights: {class_weight_dict}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb98d209",
   "metadata": {},
   "source": [
    "### 3.2. Callback constructor function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ef3c4b13",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_callbacks(\n",
    "    learning_rate: float,\n",
    "    batch_size: int,\n",
    "    patience: int = 10,\n",
    ") -> Tuple[keras.callbacks.EarlyStopping, keras.callbacks.TensorBoard]:\n",
    "    '''Create EarlyStopping and TensorBoard callbacks.'''\n",
    "\n",
    "    early_stopping = keras.callbacks.EarlyStopping(\n",
    "        monitor='val_loss',\n",
    "        patience=patience,\n",
    "        verbose=verbose\n",
    "    )\n",
    "\n",
    "    run_log_dir = f'{log_dir}/lr_{learning_rate}_bs_{batch_size}'\n",
    "\n",
    "    Path(run_log_dir).mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "    tensorboard_callback = keras.callbacks.TensorBoard(\n",
    "        log_dir=run_log_dir,\n",
    "        histogram_freq=1,\n",
    "        write_graph=False\n",
    "    )\n",
    "\n",
    "    return early_stopping, tensorboard_callback"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2260c98f",
   "metadata": {},
   "source": [
    "### 3.3. Model constructor function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7026c659",
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_model(learning_rate: float=0.01) -> keras.Sequential:\n",
    "    '''Builds and compiles the Keras Sequential model.'''\n",
    "\n",
    "    model = keras.Sequential([\n",
    "        layers.Input(shape=(5,)),\n",
    "        layers.Dense(16, activation='relu'),\n",
    "        layers.Dense(32, activation='relu'),\n",
    "        layers.Dense(16, activation='relu'),\n",
    "        layers.Dense(1, activation='sigmoid')\n",
    "    ])\n",
    "\n",
    "    model.compile(\n",
    "        optimizer=keras.optimizers.Adam(learning_rate=learning_rate),\n",
    "        loss='binary_crossentropy',\n",
    "        metrics=['accuracy']\n",
    "    )\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04aa4af3",
   "metadata": {},
   "source": [
    "### 3.4. Model training function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "5178fc7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(\n",
    "    model: keras.Sequential,\n",
    "    epochs: int=200,\n",
    "    batch_size: int=128,\n",
    "    validation_split: Optional[float]=0.2,\n",
    "    callbacks: Tuple[keras.callbacks.EarlyStopping, keras.callbacks.TensorBoard]=None\n",
    ") -> Tuple[keras.Sequential, keras.callbacks.History]:\n",
    "    '''Trains the Keras Sequential model. Returns the training history.'''\n",
    "\n",
    "    history = model.fit(\n",
    "        training_df[features],\n",
    "        training_df[label],\n",
    "        epochs=epochs,\n",
    "        batch_size=batch_size,\n",
    "        validation_split=validation_split,\n",
    "        class_weight=class_weight_dict,\n",
    "        callbacks=callbacks,\n",
    "        verbose=verbose\n",
    "    )\n",
    "\n",
    "    return model, history"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ce92b2b",
   "metadata": {},
   "source": [
    "### 3.5. Optimize batch size and learning rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "62e31840",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 256, learning rate: 1e-06...\t"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
      "I0000 00:00:1787776631.029638 1389532 service.cc:145] XLA service 0x7b9e2d4892c0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
      "I0000 00:00:1787776631.029688 1389532 service.cc:153]   StreamExecutor device (0): NVIDIA GeForce GTX 1070, Compute Capability 6.1\n",
      "I0000 00:00:1787776631.150019 1389532 device_compiler.h:188] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final val loss: 0.6840,  final val accuracy: 54.28%\n",
      "Batch size: 256, learning rate: 1e-05...\tfinal val loss: 0.0953,  final val accuracy: 97.24%\n",
      "Batch size: 256, learning rate: 0.0001...\tfinal val loss: 0.0428,  final val accuracy: 98.93%\n",
      "Batch size: 512, learning rate: 1e-06...\tfinal val loss: 0.6599,  final val accuracy: 58.27%\n",
      "Batch size: 512, learning rate: 1e-05...\tfinal val loss: 0.2965,  final val accuracy: 88.75%\n",
      "Batch size: 512, learning rate: 0.0001...\tfinal val loss: 0.0452,  final val accuracy: 98.74%\n",
      "Batch size: 1024, learning rate: 1e-06...\tfinal val loss: 0.6976,  final val accuracy: 43.26%\n",
      "Batch size: 1024, learning rate: 1e-05...\tfinal val loss: 0.5777,  final val accuracy: 84.79%\n",
      "Batch size: 1024, learning rate: 0.0001...\tfinal val loss: 0.0456,  final val accuracy: 98.80%\n",
      "\n",
      "CPU times: user 10min 8s, sys: 36.6 s, total: 10min 45s\n",
      "Wall time: 8min 31s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "batch_sizes = [256, 512, 1024]\n",
    "learning_rates = [1e-6, 1e-5, 1e-4]\n",
    "\n",
    "for batch_size, learning_rate in itertools.product(batch_sizes, learning_rates):\n",
    "\n",
    "    print(f'Batch size: {batch_size}, learning rate: {learning_rate}...', end='\\t')\n",
    "\n",
    "    # Set-up callback for this run\n",
    "    callbacks = make_callbacks(learning_rate=learning_rate, batch_size=batch_size)\n",
    "\n",
    "    # Build and train the model\n",
    "    model = build_model(learning_rate=learning_rate)\n",
    "    model, history = train_model(model, batch_size=batch_size, callbacks=callbacks)\n",
    "\n",
    "    print(f\"final val loss: {history.history['val_loss'][-1]:.4f}, \", end=' ') \n",
    "    print(f\"final val accuracy: {history.history['val_accuracy'][-1]*100:.2f}%\")\n",
    "\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbcb39fb",
   "metadata": {},
   "source": [
    "Based on the final loss & accuracy and the TensorBoard learning curves the best settings are:\n",
    "\n",
    "- Batch size: 256\n",
    "- Learning rate: 0.0001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "23813338",
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 256\n",
    "learning_rate = 0.0001"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4ac5759",
   "metadata": {},
   "source": [
    "### 3.6. Re-train with optimized hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ff678452",
   "metadata": {},
   "outputs": [],
   "source": [
    "callbacks = make_callbacks(learning_rate=learning_rate, batch_size=batch_size)\n",
    "model = build_model(learning_rate=learning_rate)\n",
    "model, history = train_model(model, batch_size=batch_size, callbacks=callbacks)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d74f3b7e",
   "metadata": {},
   "source": [
    "### 3.7. Learning curves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e0f48c27",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(1, 2, figsize=(9, 4))\n",
    "\n",
    "axes[0].set_title('Optimized DNN: loss')\n",
    "axes[0].plot(history.history['loss'], label='Training')\n",
    "axes[0].plot(history.history['val_loss'], label='Validation')\n",
    "axes[0].set_xlabel('Epoch')\n",
    "axes[0].set_ylabel('Loss (binary crossentropy)')\n",
    "axes[0].legend(loc='best')\n",
    "\n",
    "axes[1].set_title('Optimized DNN: accuracy')\n",
    "axes[1].plot(history.history['accuracy'], label='Training')\n",
    "axes[1].plot(history.history['val_accuracy'], label='Validation')\n",
    "axes[1].set_xlabel('Epoch')\n",
    "axes[1].set_ylabel('Accuracy')\n",
    "axes[1].legend(loc='best')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9f32761",
   "metadata": {},
   "source": [
    "### 3.8. Test set evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "fa2e6fa3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimized DNN model accuracy on test set: 0.9907\n"
     ]
    }
   ],
   "source": [
    "sequential_probs = model.predict(testing_df[features], verbose=0).flatten()\n",
    "sequential_predictions = (sequential_probs >= 0.5).astype(int)\n",
    "sequential_accuracy = accuracy_score(testing_df[label], sequential_predictions)\n",
    "\n",
    "print(f'Optimized DNN model accuracy on test set: {sequential_accuracy:.4f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a8be77f",
   "metadata": {},
   "source": [
    "### 3.9. Performance analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "97451643",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(4, 4))\n",
    "\n",
    "ax.set_title(f'Optimized DNN test set performance\\n(accuracy: {sequential_accuracy:.2%})')\n",
    "\n",
    "disp = ConfusionMatrixDisplay.from_predictions(\n",
    "    testing_df[label],\n",
    "    sequential_predictions,\n",
    "    normalize='true',\n",
    "    ax=ax,\n",
    "    colorbar=False\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "717d75c2",
   "metadata": {},
   "source": [
    "## 4. Model comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "905307f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic regression accuracy on test set: 0.9907\n",
      "Optimized DNN model accuracy on test set: 0.9907\n"
     ]
    }
   ],
   "source": [
    "print(f'Logistic regression accuracy on test set: {logistic_accuracy:.4f}')\n",
    "print(f'Optimized DNN model accuracy on test set: {sequential_accuracy:.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "74cc4e6d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x450 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compare confusion matrices for logistic regression and DNN\n",
    "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(7, 4.5))\n",
    "\n",
    "fig.suptitle('Test set performance comparison')\n",
    "fig.supxlabel('Predicted label')\n",
    "fig.supylabel('True label')\n",
    "\n",
    "# Confusion matrix for logistic regression\n",
    "axes[0].set_title(f'Logistic regression\\n(accuracy: {logistic_accuracy:.2%})')\n",
    "\n",
    "disp_logistic = ConfusionMatrixDisplay.from_predictions(\n",
    "    testing_df[label],\n",
    "    logistic_predictions,\n",
    "    normalize='true',\n",
    "    ax=axes[0],\n",
    "    colorbar=False\n",
    ")\n",
    "\n",
    "axes[0].set_xlabel('')\n",
    "axes[0].set_ylabel('')\n",
    "\n",
    "# Confusion matrix for DNN model\n",
    "axes[1].set_title(f'DNN\\n(accuracy: {sequential_accuracy:.2%})')\n",
    "\n",
    "disp_sequential = ConfusionMatrixDisplay.from_predictions(\n",
    "    testing_df[label],\n",
    "    sequential_predictions,\n",
    "    normalize='true',\n",
    "    ax=axes[1],\n",
    "    colorbar=False\n",
    ")\n",
    "\n",
    "axes[1].set_xlabel('')\n",
    "axes[1].set_ylabel('')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbfc7d39",
   "metadata": {},
   "source": [
    "## 5. Final training run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "e4d1ca2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final training accuracy: 98.89%\n",
      "Final training loss: 0.0368\n"
     ]
    }
   ],
   "source": [
    "# Combine training and testing datasets for final training\n",
    "combined_df = pd.concat([training_df, testing_df], ignore_index=True)\n",
    "\n",
    "# Build final model with optimized hyperparameters\n",
    "final_model = build_model(learning_rate=learning_rate)\n",
    "\n",
    "# Train on combined dataset (no validation split for final run)\n",
    "final_history = final_model.fit(\n",
    "    combined_df[features],\n",
    "    combined_df[label],\n",
    "    epochs=200,\n",
    "    batch_size=batch_size,\n",
    "    class_weight=class_weight_dict,\n",
    "    verbose=verbose\n",
    ")\n",
    "\n",
    "print(f\"Final training accuracy: {final_history.history['accuracy'][-1]*100:.2f}%\")\n",
    "print(f\"Final training loss: {final_history.history['loss'][-1]:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "aa40c199",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save the final model\n",
    "Path('../models').mkdir(parents=True, exist_ok=True)\n",
    "final_model.save('../models/optimized_occupancy_dnn_model.keras')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}