04_Classify.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ff7c736c",
   "metadata": {},
   "source": [
    "# Classify\n",
    "\n",
    "In this notebook, I will use 3D images and textures to classify the objects in the data set.\n",
    "\n",
    "I will proceed as follows:\n",
    "* Compute a \"most-common\" baseline for the filtered data\n",
    "* Train and evaluate an ensemble of 4 classifiers (fig. 1), one for each 3D view and one for textures\n",
    "* Combine the results using either k-NN or logistic regression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ced3c3a",
   "metadata": {},
   "source": [
    "## Load feature data\n",
    "Load the feature data extracted from the 3D-views and textures in notebook 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2339d6cc",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The train dataset has 677 objects, the validation dataset 192, the test dataset 99\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "PROD_DIR = 'production' # interim production files\n",
    "\n",
    "metadata_textures = {}\n",
    "# Reload texture metadata and extracted features from train dataset\n",
    "with np.load(os.path.join(PROD_DIR, 'features_textures_train.npz'), allow_pickle=True) as data:\n",
    "    data_dict = dict(data.items())\n",
    "    metadata_textures['train'] = data_dict['metadata']\n",
    "    textures_train = data_dict['textures_features']\n",
    "    \n",
    "# Reload texture metadata and extracted features from validation dataset\n",
    "with np.load(os.path.join(PROD_DIR, 'features_textures_validate.npz'), allow_pickle=True) as data:\n",
    "    data_dict = dict(data.items())\n",
    "    metadata_textures['valid'] = data_dict['metadata']\n",
    "    textures_valid = data_dict['textures_features']\n",
    "\n",
    "# Reload texture metadata and extracted features from test dataset\n",
    "with np.load(os.path.join(PROD_DIR, 'features_textures_test.npz'), allow_pickle=True) as data:\n",
    "    data_dict = dict(data.items())\n",
    "    metadata_textures['test'] = data_dict['metadata']\n",
    "    textures_test = data_dict['textures_features']\n",
    "\n",
    "# Reload extracted 3D features from train dataset\n",
    "with np.load(os.path.join(PROD_DIR, 'features_point_clouds_train.npz'), allow_pickle=True) as data:\n",
    "    data_dict = dict(data.items())\n",
    "    metadata_train = data_dict['metadata']\n",
    "    elevation_features_train = data_dict['elevation_features']\n",
    "    plan_features_train = data_dict['plan_features']\n",
    "    section_features_train = data_dict['section_features']\n",
    "    \n",
    "# encode labels as ints\n",
    "labels_train = LabelEncoder().fit_transform(metadata_train[:, 3])\n",
    "\n",
    "# Reload extracted features from validate dataset\n",
    "with np.load(os.path.join(PROD_DIR, 'features_point_clouds_validate.npz'), allow_pickle=True) as data:\n",
    "    data_dict = dict(data.items())\n",
    "    metadata_valid = data_dict['metadata']\n",
    "    elevation_features_valid = data_dict['elevation_features']\n",
    "    plan_features_valid = data_dict['plan_features']\n",
    "    section_features_valid = data_dict['section_features']\n",
    "\n",
    "# encode labels as ints\n",
    "labels_valid = LabelEncoder().fit_transform(metadata_valid[:, 3])\n",
    "\n",
    "# Reload extracted features from test dataset\n",
    "with np.load(os.path.join(PROD_DIR, 'features_point_clouds_test.npz'), allow_pickle=True) as data:\n",
    "    data_dict = dict(data.items())\n",
    "    metadata_test = data_dict['metadata']\n",
    "    elevation_features_test = data_dict['elevation_features']\n",
    "    plan_features_test = data_dict['plan_features']\n",
    "    section_features_test = data_dict['section_features']\n",
    "\n",
    "# encode labels as ints\n",
    "labels_test = LabelEncoder().fit_transform(metadata_test[:, 3])\n",
    "\n",
    "print('The train dataset has {} objects, the validation dataset {}, the test dataset {}'.format(\n",
    "    len(labels_train), len(labels_valid), len(labels_test)\n",
    "))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "453f86a1",
   "metadata": {},
   "source": [
    "## Baseline\n",
    "Compute the \"most frequent\" baseline based on validation and the test datasets (as the distribution is the same, these are equal)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "655bb178",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The accuracy of the most frequent baseline for the validation dataset is 0.34, for the test dataset 0.34.\n"
     ]
    }
   ],
   "source": [
    "from sklearn.dummy import DummyClassifier\n",
    "\n",
    "dummy = DummyClassifier(strategy='most_frequent')\n",
    "dummy.fit(elevation_features_train, labels_train)\n",
    "baseline_score_valid = dummy.score(elevation_features_valid, labels_valid)\n",
    "baseline_score_test = dummy.score(elevation_features_test, labels_test)\n",
    "print('The accuracy of the most frequent baseline for the validation dataset is {:.2f}, for the test dataset {:.2f}.'.format(baseline_score_valid, baseline_score_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec7d40db",
   "metadata": {},
   "source": [
    "## Define dense networks\n",
    "\n",
    "For each of the 3D-views and the texture image, I implemented a separate dense network, so there are 4 separate models to fit. Each network has 1 input and 1 output tensor, there are no branching or merging layers, so the architecture is sequential and similar for each of the 4 models:\n",
    "\n",
    "* The input data for the network are 2048 high-level features extracted from each of the 3d-views and from the textures in the previous notebook.\n",
    "* The data is not linearly separable (notebook 3), therefore this network needs at least one hidden layer. After some experimenting, I added two hidden layers. Choosing the number of nodes in the hidden layer is a problem for which [some heuristics](http://www.faqs.org/faqs/ai-faq/neural-nets/part3/section-10.html) exist, but no definitive answer, therefore I optimize the number of nodes in the hidden layers using grid search. In this network, the second hidden layer has half the nodes of the first hidden layer.\n",
    "* I added dropout layers to prevent overfitting.\n",
    "* The images are in 6 classes ('Bronze Age', 'Iron Age', etc.), therefore the network requires 6 outputs.\n",
    "\n",
    "I chose to implement the network using Keras."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "87f84d46",
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
    "import tensorflow as tf\n",
    "import tensorflow.keras as keras\n",
    "from tensorflow.keras import Sequential\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow.keras import activations\n",
    "from tensorflow.keras import initializers\n",
    "\n",
    "def define_network(outputs, hidden_nodes, rate):\n",
    "    \"\"\"\n",
    "    Defines a multi-layer dense network with a hidden and a dropout layer.\n",
    "    @param outputs: int, number of outputs\n",
    "    @param hidden_nodes: int, number of nodes in the hidden layer\n",
    "    @param rate: float, rate of the dropout layer\n",
    "    \"\"\"\n",
    "    network = Sequential()\n",
    "    # hidden layer 1\n",
    "    network.add(\n",
    "        Dense(\n",
    "            hidden_nodes, \n",
    "            activation='relu', \n",
    "            kernel_initializer=initializers.VarianceScaling(scale=2.0, seed=0)\n",
    "        )\n",
    "    )\n",
    "    # dropout layer\n",
    "    network.add(\n",
    "        keras.layers.Dropout(rate, seed=0)\n",
    "    )\n",
    "    # hidden layer 2\n",
    "    network.add(\n",
    "        Dense(\n",
    "            np.floor(hidden_nodes/2), # the second hidden layer has half the nodes of the first one\n",
    "            activation='relu', \n",
    "            kernel_initializer=initializers.VarianceScaling(scale=2.0, seed=0)\n",
    "        )\n",
    "    )\n",
    "    # dropout layer 2\n",
    "    network.add(\n",
    "        keras.layers.Dropout(rate, seed=0)\n",
    "    )\n",
    "    # output layer\n",
    "    network.add(\n",
    "        Dense(\n",
    "            outputs, # number of image classes\n",
    "            activation='softmax', # 'softmax' since output layer for classification network\n",
    "            kernel_initializer=initializers.VarianceScaling(scale=1.0, seed=0)\n",
    "        )\n",
    "    )\n",
    "    return network"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bf3c693",
   "metadata": {},
   "source": [
    "### Grid search\n",
    "The networks are trained independently from each other. There are 4 networks, one for each 3D view and one for the textures. I used grid search to optimize the accuracy of the model by tuning:\n",
    "* the number of nodes in the hidden layers\n",
    "* the dropout rate \n",
    "* the optimizer used for compiling the model \n",
    "\n",
    "Alternatively, I could have used cross validation for a better estimate of the parameters. However, this would be very computationally demanding, as fitting the model is itself costly, and the grid has many parameter combinations. As the data set is large enough, I did a simple grid search. Additionally, I used early stopping to reduce the computation time (this would not be compatible with cross validation). \n",
    "\n",
    "In order to get a better estimate nonetheless, \n",
    "* the train and validation data as split in notebook 1 is stratified\n",
    "* the parameter class_weight is set to a dictionary of class labels per sample\n",
    "* I used a batch size larger than the default\n",
    "\n",
    "Optimizing the parameters for all 4 classifiers required about 3/4 hour on my machine, using 3 processor threads."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e9f67c2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import ParameterGrid\n",
    "from sklearn.utils import class_weight\n",
    "\n",
    "# create a grid of tunable parameters\n",
    "# the same grid is used for all networks\n",
    "grid = ParameterGrid({\n",
    "    'nw__num_nodes': [2**i for i in range(8, 12)], # between 256 and 2048\n",
    "    'nw__dropout_rate': [0.5, 0.55, 0.6, 0.65],\n",
    "    'nw__optimizer': ['sgd', 'adam'] # try 2 optimizers: stochastic gradient descent and Adam\n",
    "})\n",
    "\n",
    "# callback for early stopping\n",
    "early_stopping = keras.callbacks.EarlyStopping(monitor='val_loss', patience=6)\n",
    "\n",
    "def fit_network(num_nodes, optimizer, dropout_rate, X_train, y_train, X_valid, y_valid):\n",
    "    \"\"\"\n",
    "    Fit a network as defined in define_network().\n",
    "    @param num_nodes int, number of nodes in the hidden layer\n",
    "    @param optimizer string name of a tf.keras.optimizers.*\n",
    "    @params X_train, y_train, X_valid, y_valid numpy ndarrays\n",
    "    @return fitted tensorflow network ('Sequential' object), tensorflow fit history ('History' object)\n",
    "    \"\"\"\n",
    "    # define and compile the model with given number of nodes, dropout rate and optimizer\n",
    "    outputs = 6\n",
    "    network = define_network(outputs, num_nodes, dropout_rate) \n",
    "    network.compile(optimizer=optimizer, loss='sparse_categorical_crossentropy', metrics=['acc']) # expecting 1 category as output, so use sparse_... as loss function\n",
    "    # compute class weights, as dataset is imbalanced\n",
    "    class_weights = class_weight.compute_class_weight('balanced', np.unique(y_train), y_train)\n",
    "    # fit network on training set, compute accuracy on validation set (from notebook 3)\n",
    "    history = network.fit(\n",
    "        x=X_train,\n",
    "        y=y_train,\n",
    "        class_weight=class_weights,\n",
    "        validation_data=(X_valid, y_valid), # using pre-processed validation data\n",
    "        batch_size=256, # using larger than default batch size for better estimate\n",
    "        epochs=1000, # combine many epochs with early stopping\n",
    "        callbacks=[early_stopping],\n",
    "        shuffle=False, # don't shuffle before each epoch, for repeatability\n",
    "        verbose=0,\n",
    "        workers=3 # multi-threading\n",
    "    )\n",
    "    return network, history\n",
    "\n",
    "def optimize_params(X_train, y_train, X_valid, y_valid):\n",
    "    \"\"\"\n",
    "    Tune the number of nodes in the hidden layer and the dropout rate of the network defined in define_network().\n",
    "    @params X_train, y_train, X_valid, y_valid numpy ndarrays\n",
    "    @return best_num_nodes int, best_rate float, accuracy Pandas DataFrame\n",
    "    \"\"\"\n",
    "    test_scores = []\n",
    "    for params_dict in grid:\n",
    "        network, history = fit_network(\n",
    "            params_dict['nw__num_nodes'], # keras API is not compatible with ParameterGrid, so read grid parameters by hand \n",
    "            params_dict ['nw__optimizer'],\n",
    "            params_dict['nw__dropout_rate'],\n",
    "            X_train, y_train, X_valid, y_valid)\n",
    "        params_dict['accuracy'] = history.history['val_acc'][-1] # the validation accuracy of the model, last epoch\n",
    "        test_scores.append(params_dict)\n",
    "\n",
    "    accuracy_df = pd.DataFrame(test_scores)\n",
    "    accuracy_df.sort_values(by='accuracy', ascending=False, inplace=True)\n",
    "    best_dropout_rate = accuracy_df.loc[accuracy_df['accuracy'].idxmax(), 'nw__dropout_rate']\n",
    "    best_num_nodes = accuracy_df.loc[accuracy_df['accuracy'].idxmax(), 'nw__num_nodes']\n",
    "    best_optimizer = accuracy_df.loc[accuracy_df['accuracy'].idxmax(), 'nw__optimizer']\n",
    "    return best_dropout_rate, best_num_nodes, best_optimizer, accuracy_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c0aec7f",
   "metadata": {},
   "source": [
    "#### Optimizing parameters for elevation view"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0c49e919",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    accuracy  nw__dropout_rate  nw__num_nodes nw__optimizer\n",
      "2   0.713542              0.50            512           sgd\n",
      "18  0.713542              0.60            512           sgd\n",
      "26  0.713542              0.65            512           sgd\n",
      "10  0.713542              0.55            512           sgd\n",
      "11  0.703125              0.55            512          adam\n",
      "3   0.703125              0.50            512          adam\n",
      "27  0.703125              0.65            512          adam\n",
      "13  0.697917              0.55           1024          adam\n",
      "21  0.697917              0.60           1024          adam\n",
      "19  0.697917              0.60            512          adam \n",
      "\n",
      "Best parameters for elevation view: dropout rate 0.5, nodes in hidden layer 512, optimizer \"sgd\"\n",
      "\n"
     ]
    }
   ],
   "source": [
    "best_dropout_rate_elevation, best_num_nodes_elevation, best_optimizer_elevation, elevation_accuracy = optimize_params(elevation_features_train, labels_train, elevation_features_valid, labels_valid)\n",
    "print(elevation_accuracy.head(10), '\\n')\n",
    "print('Best parameters for elevation view: dropout rate {}, nodes in hidden layer {}, optimizer \"{}\"\\n'.format(best_dropout_rate_elevation, best_num_nodes_elevation, best_optimizer_elevation))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "977c2207",
   "metadata": {},
   "source": [
    "#### Optimizing parameters for plan view"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a8bbe3fd",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    accuracy  nw__dropout_rate  nw__num_nodes nw__optimizer\n",
      "26  0.682292              0.65            512           sgd\n",
      "2   0.682292              0.50            512           sgd\n",
      "18  0.682292              0.60            512           sgd\n",
      "10  0.682292              0.55            512           sgd\n",
      "25  0.677083              0.65            256          adam\n",
      "17  0.677083              0.60            256          adam\n",
      "1   0.677083              0.50            256          adam\n",
      "3   0.671875              0.50            512          adam\n",
      "27  0.671875              0.65            512          adam\n",
      "19  0.671875              0.60            512          adam \n",
      "\n",
      "Best parameters for plan view: dropout rate 0.65, nodes in hidden layer 512, optimizer \"sgd\"\n",
      "\n"
     ]
    }
   ],
   "source": [
    "best_dropout_rate_plan, best_num_nodes_plan, best_optimizer_plan, plan_accuracy = optimize_params(plan_features_train, labels_train, plan_features_valid, labels_valid)\n",
    "print(plan_accuracy.head(10), '\\n')\n",
    "print('Best parameters for plan view: dropout rate {}, nodes in hidden layer {}, optimizer \"{}\"\\n'.format(best_dropout_rate_plan, best_num_nodes_plan, best_optimizer_plan))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2af11b6e",
   "metadata": {},
   "source": [
    "#### Optimizing parameters for section view"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "88f2f847",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    accuracy  nw__dropout_rate  nw__num_nodes nw__optimizer\n",
      "11  0.750000              0.55            512          adam\n",
      "3   0.750000              0.50            512          adam\n",
      "27  0.750000              0.65            512          adam\n",
      "19  0.750000              0.60            512          adam\n",
      "5   0.744792              0.50           1024          adam\n",
      "21  0.744792              0.60           1024          adam\n",
      "29  0.744792              0.65           1024          adam\n",
      "13  0.744792              0.55           1024          adam\n",
      "9   0.729167              0.55            256          adam\n",
      "1   0.729167              0.50            256          adam \n",
      "\n",
      "Best parameters for section view: dropout rate 0.55, nodes in hidden layer 512, optimizer \"adam\"\n",
      "\n"
     ]
    }
   ],
   "source": [
    "best_dropout_rate_section, best_num_nodes_section, best_optimizer_section, section_accuracy = optimize_params(section_features_train, labels_train, section_features_valid, labels_valid)\n",
    "print(section_accuracy.head(10), '\\n')\n",
    "print('Best parameters for section view: dropout rate {}, nodes in hidden layer {}, optimizer \"{}\"\\n'.format(best_dropout_rate_section, best_num_nodes_section, best_optimizer_section))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fe7fdb5",
   "metadata": {},
   "source": [
    "#### Optimizing parameters for textures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0c953bb4",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    accuracy  nw__dropout_rate  nw__num_nodes nw__optimizer\n",
      "3   0.807292              0.50            512          adam\n",
      "27  0.807292              0.65            512          adam\n",
      "19  0.807292              0.60            512          adam\n",
      "11  0.807292              0.55            512          adam\n",
      "14  0.802083              0.55           2048           sgd\n",
      "30  0.802083              0.65           2048           sgd\n",
      "6   0.802083              0.50           2048           sgd\n",
      "7   0.802083              0.50           2048          adam\n",
      "22  0.802083              0.60           2048           sgd\n",
      "15  0.802083              0.55           2048          adam \n",
      "\n",
      "Best parameters for textures: dropout rate 0.5, nodes in hidden layer 512, optimizer \"adam\"\n",
      "\n"
     ]
    }
   ],
   "source": [
    "best_dropout_rate_textures, best_num_nodes_textures, best_optimizer_textures, textures_accuracy = optimize_params(textures_train, labels_train, textures_valid, labels_valid)\n",
    "print(textures_accuracy.head(10), '\\n')\n",
    "print('Best parameters for textures: dropout rate {}, nodes in hidden layer {}, optimizer \"{}\"\\n'.format(best_dropout_rate_textures, best_num_nodes_textures, best_optimizer_textures))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9aae04b8",
   "metadata": {},
   "source": [
    "### Define and fit each network\n",
    "For each 3D-view, define a network with the optimal number of nodes in the hidden layer as determined in the previous step, fit the network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4e67541a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define and fit a network for each 3D-view and textures\n",
    "elevation_network, elevation_history = fit_network(best_num_nodes_elevation, best_optimizer_elevation, best_dropout_rate_elevation, elevation_features_train, labels_train, elevation_features_valid, labels_valid)\n",
    "plan_network, plan_history = fit_network(best_num_nodes_plan, best_optimizer_plan, best_dropout_rate_plan, plan_features_train, labels_train, plan_features_valid, labels_valid)\n",
    "section_network, section_history = fit_network(best_num_nodes_section, best_optimizer_section, best_dropout_rate_section, section_features_train, labels_train, section_features_valid, labels_valid)\n",
    "textures_network, textures_history = fit_network(best_num_nodes_textures, best_optimizer_textures, best_dropout_rate_textures, textures_train, labels_train, textures_valid, labels_valid)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d51ce1d",
   "metadata": {},
   "source": [
    "### Examine the networks' accuracy and loss\n",
    "I plotted the accuracy and loss curves of each network (separately for each network) to determine if the network is overfitting. \n",
    "* __Accuracy__: The validation curves reach a plateau as the number of epochs increases, so the networks' accuracy is not increasing any more. \n",
    "* __Loss__: The validation curves don't show an increased loss as the number of epochs increases, so the models are not overfitting. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "fb54d507",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x864 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "def plot_accuracy(ax, history, title):\n",
    "    ax.plot(history.history['acc'], label='train')\n",
    "    ax.plot(history.history['val_acc'], label='validation')\n",
    "    ax.set_xlabel('epoch')\n",
    "    ax.set_ylabel('accuracy')\n",
    "    ax.set_title(title)\n",
    "\n",
    "def plot_loss(ax, history, title):\n",
    "    ax.plot(history.history['loss'], label='train')\n",
    "    ax.plot(history.history['val_loss'], label='validation')\n",
    "    ax.set_xlabel('epoch')\n",
    "    ax.set_ylabel('accuracy')\n",
    "    ax.set_title(title)\n",
    "\n",
    "fig, ax = plt.subplots(2, 4, figsize=(20, 12))\n",
    "plot_accuracy(ax[0, 0], elevation_history, 'Elevation accuracy')\n",
    "plot_accuracy(ax[0, 1], plan_history, 'Plan accuracy')\n",
    "plot_accuracy(ax[0, 2], section_history, 'Section accuracy')\n",
    "plot_accuracy(ax[0, 3], textures_history, 'Textures accuracy')\n",
    "plot_loss(ax[1, 0], elevation_history, 'Elevation loss')\n",
    "plot_loss(ax[1, 1], plan_history, 'Plan loss')\n",
    "plot_loss(ax[1, 2], section_history, 'Section loss')\n",
    "plot_loss(ax[1, 3], textures_history, 'Textures loss')\n",
    "plt.legend(loc='upper right', bbox_to_anchor=(1.4, 1))\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b16a220",
   "metadata": {},
   "source": [
    "### Accuracy on the test set for each network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "dd926349",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The accuracy for the network trained on the elevation views on the test set is 0.81\n",
      "The accuracy for the network trained on the plan views on the test set is 0.68\n",
      "The accuracy for the network trained on the section views on the test set is 0.77\n",
      "The accuracy for the network trained on the textures on the test set is 0.83\n"
     ]
    }
   ],
   "source": [
    "elevation_score = elevation_network.evaluate(elevation_features_test, labels_test, verbose=0)[1]\n",
    "print('The accuracy for the network trained on the elevation views on the test set is {:.2f}'.format(elevation_score))\n",
    "plan_score = plan_network.evaluate(plan_features_test, labels_test, verbose=0)[1]\n",
    "print('The accuracy for the network trained on the plan views on the test set is {:.2f}'.format(plan_score))\n",
    "section_score = section_network.evaluate(section_features_test, labels_test, verbose=0)[1]\n",
    "print('The accuracy for the network trained on the section views on the test set is {:.2f}'.format(section_score))\n",
    "textures_score = textures_network.evaluate(textures_test, labels_test, verbose=0)[1]\n",
    "print('The accuracy for the network trained on the textures on the test set is {:.2f}'.format(textures_score))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e6201ca",
   "metadata": {},
   "source": [
    "## Combine results\n",
    "The results of the individual classifiers have to be combined into one final result for the ensemble. I tried out 2 methods to achieve this: k-NN and logistic regression.\n",
    "\n",
    "The output of the 3d-views and texture classifiers are numpy arrays of __probabilities__. Each array element contains the probabilities associated with an element in the data set. These probabilities are an array of 6 entries, one for each class.\n",
    "\n",
    "* The input of the final classifier is therefore an array of 24 elements\n",
    "* The output is an array of 6 elements, one for each class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "90f45bd6",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# predictions for train set\n",
    "pred_elevation_train = elevation_network.predict(elevation_features_train)\n",
    "pred_plan_train = plan_network.predict(plan_features_train)\n",
    "pred_section_train = section_network.predict(section_features_train)\n",
    "pred_textures_train = textures_network.predict(textures_train)\n",
    "pred_train = [np.concatenate([pred_elevation_train[i], pred_plan_train[i], pred_section_train[i], pred_textures_train[i]]) for i,_ in enumerate(labels_train)]\n",
    "\n",
    "# predictions for validation set\n",
    "pred_elevation_valid = elevation_network.predict(elevation_features_valid)\n",
    "pred_plan_valid = plan_network.predict(plan_features_valid)\n",
    "pred_section_valid = section_network.predict(section_features_valid)\n",
    "pred_textures_valid = textures_network.predict(textures_valid)\n",
    "pred_valid = [np.concatenate([pred_elevation_valid[i], pred_plan_valid[i], pred_section_valid[i], pred_textures_valid[i]]) for i,_ in enumerate(labels_valid)]\n",
    "\n",
    "# predictions for test set\n",
    "pred_elevation_test = elevation_network.predict(elevation_features_test)\n",
    "pred_plan_test = plan_network.predict(plan_features_test)\n",
    "pred_section_test = section_network.predict(section_features_test)\n",
    "pred_textures_test = textures_network.predict(textures_test)\n",
    "pred_test = [np.concatenate([pred_elevation_test[i], pred_plan_test[i], pred_section_test[i], pred_textures_test[i]]) for i,_ in enumerate(labels_test)]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c83ca30",
   "metadata": {},
   "source": [
    "### Combine using k-NN\n",
    "\n",
    "I used grid search to tune the parameters for the k-NN final classifier. Several parameters can be tuned in the scikit-learn implementation of k-NN. According to the [documentation](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html), these are:\n",
    "* n_neighbors: the number of neighbors\n",
    "* algorithm: the algorithm used to compute the nearest neighbors\n",
    "* metric: the distance metric\n",
    "* p: only used when algorithm is 'minkowski'\n",
    "* weight: the weight of the neighbors according to the distance (not to be confused with class weight)\n",
    "\n",
    "The best parameter values found are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0ac9a8dc",
   "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>algorithm</th>\n",
       "      <th>metric</th>\n",
       "      <th>n_neighbors</th>\n",
       "      <th>p</th>\n",
       "      <th>score</th>\n",
       "      <th>weights</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>227</th>\n",
       "      <td>kd_tree</td>\n",
       "      <td>minkowski</td>\n",
       "      <td>8</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.90625</td>\n",
       "      <td>distance</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>33</th>\n",
       "      <td>ball_tree</td>\n",
       "      <td>manhattan</td>\n",
       "      <td>8</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.90625</td>\n",
       "      <td>distance</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>141</th>\n",
       "      <td>brute</td>\n",
       "      <td>manhattan</td>\n",
       "      <td>8</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.90625</td>\n",
       "      <td>distance</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>87</th>\n",
       "      <td>kd_tree</td>\n",
       "      <td>manhattan</td>\n",
       "      <td>8</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.90625</td>\n",
       "      <td>distance</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>263</th>\n",
       "      <td>brute</td>\n",
       "      <td>minkowski</td>\n",
       "      <td>8</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.90625</td>\n",
       "      <td>distance</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     algorithm     metric  n_neighbors    p    score   weights\n",
       "227    kd_tree  minkowski            8  1.0  0.90625  distance\n",
       "33   ball_tree  manhattan            8  NaN  0.90625  distance\n",
       "141      brute  manhattan            8  NaN  0.90625  distance\n",
       "87     kd_tree  manhattan            8  NaN  0.90625  distance\n",
       "263      brute  minkowski            8  1.0  0.90625  distance"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import ParameterGrid\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "# create a grid of tunable parameters\n",
    "grid_knn = ParameterGrid([\n",
    "    {\n",
    "        'n_neighbors': range(1, 10),\n",
    "        'weights': ['uniform', 'distance'],\n",
    "        'algorithm': ['ball_tree', 'kd_tree', 'brute'],\n",
    "        'metric': ['euclidean', 'manhattan', 'chebyshev']\n",
    "    },\n",
    "    {\n",
    "        'n_neighbors': range(1, 10),\n",
    "        'weights': ['uniform', 'distance'],\n",
    "        'algorithm': ['ball_tree', 'kd_tree', 'brute'],\n",
    "        'p': [1, 2], # L1 or L2\n",
    "        'metric': ['minkowski']\n",
    "    }\n",
    "])\n",
    "\n",
    "gs_results_knn = []\n",
    "for params_dict in grid_knn:\n",
    "    knn = KNeighborsClassifier().set_params(**params_dict) # sklearn API can set parameters directly from grid object\n",
    "    knn.fit(pred_train, labels_train)\n",
    "    params_dict['score'] = knn.score(pred_valid, labels_valid)\n",
    "    gs_results_knn.append(params_dict)\n",
    "    \n",
    "gs_results_knn = pd.DataFrame(gs_results_knn)\n",
    "gs_results_knn.sort_values(by='score', ascending=False).head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fc3e253",
   "metadata": {},
   "source": [
    "#### Accuracy on the test set of the complete ensemble using k-NN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ff3d762f",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The score for the ensemble using k-NN: 0.88\n"
     ]
    }
   ],
   "source": [
    "best_params = grid_knn[gs_results_knn['score'].idxmax()]\n",
    "knn = KNeighborsClassifier().set_params(**best_params).fit(pred_train, labels_train)\n",
    "ensemble_score_knn = knn.score(pred_test, labels_test)\n",
    "print('The score for the ensemble using k-NN: {:.2f}'.format(ensemble_score_knn))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c1d09c3",
   "metadata": {},
   "source": [
    "### Combine using logistic regression\n",
    "Inputs and outputs are the same as for k-NN, [tunable parameters](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html) are \n",
    "* the inverse regularization C\n",
    "* the solver algorithm. I did not use solvers saga and sag, as these were throwing too many convergence warnings\n",
    "* the penalty, depending on the algorithm used\n",
    "\n",
    "Max iterations is set to a high value, to avoid convergence warnings.\n",
    "\n",
    "The class weight is set to 'balanced', which should adjust weights according to the class frequencies in the input data.\n",
    "\n",
    "The best parameter values found are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0bea01cc",
   "metadata": {
    "jupyter": {
     "source_hidden": 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>C</th>\n",
       "      <th>class_weight</th>\n",
       "      <th>max_iter</th>\n",
       "      <th>penalty</th>\n",
       "      <th>score</th>\n",
       "      <th>solver</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>79</th>\n",
       "      <td>10.000000</td>\n",
       "      <td>balanced</td>\n",
       "      <td>2000</td>\n",
       "      <td>l2</td>\n",
       "      <td>0.895833</td>\n",
       "      <td>liblinear</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>77</th>\n",
       "      <td>7.847600</td>\n",
       "      <td>balanced</td>\n",
       "      <td>2000</td>\n",
       "      <td>l2</td>\n",
       "      <td>0.895833</td>\n",
       "      <td>liblinear</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>34</th>\n",
       "      <td>6.158482</td>\n",
       "      <td>balanced</td>\n",
       "      <td>2000</td>\n",
       "      <td>l2</td>\n",
       "      <td>0.895833</td>\n",
       "      <td>newton-cg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>6.158482</td>\n",
       "      <td>balanced</td>\n",
       "      <td>2000</td>\n",
       "      <td>l2</td>\n",
       "      <td>0.895833</td>\n",
       "      <td>lbfgs</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>7.847600</td>\n",
       "      <td>balanced</td>\n",
       "      <td>2000</td>\n",
       "      <td>l2</td>\n",
       "      <td>0.895833</td>\n",
       "      <td>newton-cg</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            C class_weight  max_iter penalty     score     solver\n",
       "79  10.000000     balanced      2000      l2  0.895833  liblinear\n",
       "77   7.847600     balanced      2000      l2  0.895833  liblinear\n",
       "34   6.158482     balanced      2000      l2  0.895833  newton-cg\n",
       "35   6.158482     balanced      2000      l2  0.895833      lbfgs\n",
       "36   7.847600     balanced      2000      l2  0.895833  newton-cg"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "# create a grid of tunable parameters\n",
    "grid_logreg = ParameterGrid([\n",
    "    {\n",
    "        'C': np.logspace(-1, 1, num=20), # inverse regularization\n",
    "        'solver': ['newton-cg', 'lbfgs'],\n",
    "        'penalty': ['l2'], # these solvers no l1\n",
    "        'max_iter': [2000], # avoid 'coefficient did not converge' warnings\n",
    "        'class_weight': ['balanced'] # adjust weights inversely proportional to class frequencies \n",
    "    },\n",
    "    {\n",
    "        'C': np.logspace(-1, 1, num=20), # inverse regularization\n",
    "        'solver': ['liblinear'],\n",
    "        'penalty': ['l1', 'l2'],\n",
    "        'max_iter': [2000], # avoid 'coefficient did not converge' warnings\n",
    "        'class_weight': ['balanced'] # adjust weights inversely proportional to class frequencies \n",
    "    },\n",
    "])\n",
    "\n",
    "gs_results_logreg = []\n",
    "for params_dict in grid_logreg:\n",
    "    logreg = LogisticRegression().set_params(**params_dict) # sklearn API can set parameters directly from grid object\n",
    "    logreg.fit(pred_train, labels_train)\n",
    "    params_dict['score'] = logreg.score(pred_valid, labels_valid)\n",
    "    gs_results_logreg.append(params_dict)\n",
    "    \n",
    "gs_results_logreg = pd.DataFrame(gs_results_logreg)\n",
    "gs_results_logreg.sort_values(by='score', ascending=False).head()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e64ebf2",
   "metadata": {},
   "source": [
    "#### Accuracy on the test set of the complete ensemble using logistic regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b5358bc5",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The score for the ensemble using logistic regression: 0.85\n"
     ]
    }
   ],
   "source": [
    "best_params = grid_logreg[gs_results_logreg['score'].idxmax()]\n",
    "logreg = LogisticRegression().set_params(**best_params).fit(pred_train, labels_train)\n",
    "ensemble_score_logreg = logreg.score(pred_test, labels_test)\n",
    "print('The score for the ensemble using logistic regression: {:.2f}'.format(ensemble_score_logreg))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccf2179f",
   "metadata": {},
   "source": [
    "## Score comparisons\n",
    "\n",
    "The scores of the individual classifiers were all above the most-common baseline. The scores of the ensemble, whether combined through k-NN or logistic regression, where higher than the scores of the individual classifiers. In the final notebook, I will analyze the predictions of the classifiers in this notebook in depth."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6c5afc0e",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "acc_df = pd.DataFrame({\n",
    "    'classifier': ['Baseline', 'Elevation only', 'Plan only', 'Section only', 'Textures only', 'Ensemble k-NN', 'Ensemble logreg'],\n",
    "    'accuracy': [baseline_score_test, elevation_score, plan_score, section_score, textures_score, ensemble_score_knn, ensemble_score_logreg]\n",
    "}).sort_values(by='accuracy')\n",
    "plt.barh(acc_df['classifier'], acc_df['accuracy'])\n",
    "plt.xlabel('Accuracy')\n",
    "plt.ylabel('')\n",
    "plt.title('Classification accuracy')\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84cbc70d",
   "metadata": {},
   "source": [
    "Save the predictions (on the test set) for later analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "fe4485a2",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# save predictions for test set\n",
    "pred_knn = knn.predict(pred_test)\n",
    "pred_logreg = logreg.predict(pred_test)\n",
    "\n",
    "np.savez_compressed(os.path.join('production', 'predictions.npz'),\n",
    "    pred_knn = pred_knn,\n",
    "    pred_logreg = pred_logreg\n",
    ")"
   ]
  }
 ],
 "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.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}