DL.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Approximating electromagnetic shielding using deep learning\n",
    "\n",
    "Here we are digging in the __deep learning part__ of the automated learning. We wish to see by ourselves to which extends this is applicable to our case and if it gives better results than standard machine learning.\n",
    "\n",
    "When designing algorithms, we always have to wonder what are the requirements in terms of __time / performance trade-offs__. In our case, the __performance__ is the most important, we should have precise predictions. Computation time should of course stay reasonable but considering the time taken to construct the matrix on which we predict, as long as our algorithms don't take several minutes to run they will not take the major part of the overall time.\n",
    "\n",
    "Note that deep-learning algorithms rely a lot on data. The more you have, the better your predictions will be. Hence __we highly recommand that whenever more data are available to rerun the algorithms__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "# Clean up the memory\n",
    "%reset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "import gc\n",
    "\n",
    "import src.crowd as crowd\n",
    "import src.experts as experts\n",
    "import src.supercrowd as sc\n",
    "import src.collaborative_crowd as cc\n",
    "\n",
    "import numpy as np\n",
    "import math\n",
    "from PIL import Image\n",
    "import timeit\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras.constraints import MaxNorm\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_FOLDER = \"data/DL/\"\n",
    "SESSION_FOLDER = \"session/\"\n",
    "\n",
    "TRAIN_SET_PERC = 0.75"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rmse(pred, real, loop = True):\n",
    "    '''\n",
    "    Computes RMSE between predictions and real values\n",
    "    :param : float[]\n",
    "    :param : float[]\n",
    "    :return : float\n",
    "    '''\n",
    "    if len(pred) != len(real):\n",
    "        print(\"RMSE Error : Predictions and real values arrays do not have the same length, aborting.\")\n",
    "        return None\n",
    "    \n",
    "    if loop:\n",
    "        mse = 0\n",
    "        for i in range(len(pred)):\n",
    "            mse += (pred[i] - real[i])**2\n",
    "        return math.sqrt(mse/len(pred))\n",
    "    else:\n",
    "        # The creation of the array may produce memory error\n",
    "        err = pred - real\n",
    "        mse = err.T @ err\n",
    "        return math.sqrt(2 * mse / len(pred))\n",
    "    \n",
    "    \n",
    "def basic_error(pred, real):\n",
    "    '''\n",
    "    Compute basic error. Used to notify bias.\n",
    "    :param : float[]\n",
    "    :param : float[]\n",
    "    :return : float\n",
    "    '''\n",
    "    err = 0\n",
    "    for i in range(len(pred)):\n",
    "        err += (pred[i][0][0] - real[i])\n",
    "    return err\n",
    "\n",
    "\n",
    "def garbage_collection():\n",
    "    '''\n",
    "    Calls garbage collection to clean unused memory\n",
    "    '''\n",
    "    gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_history(history):\n",
    "    '''\n",
    "    Plots the history of the training error\n",
    "    '''\n",
    "    plt.figure()\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('Mean Abs Error')\n",
    "    plt.plot(history.epoch, np.array(history.history['mean_absolute_error']),\n",
    "           label='Train Loss')\n",
    "    plt.plot(history.epoch, np.array(history.history['val_mean_absolute_error']),\n",
    "           label = 'Val loss')\n",
    "    plt.legend()\n",
    "    plt.ylim([0, 5])\n",
    "    \n",
    "    \n",
    "def plot_crowd_dist_4(crowd, s1, s2, s3, s4):\n",
    "    nb_bins = 8\n",
    "    fig = plt.gcf()\n",
    "    fig.set_size_inches(18.5, 10.5)\n",
    "    plt.subplot(221)\n",
    "    crowd.plot_error_dist_on_sample(s1[0], s1[1], basic_error, show = False, bins = nb_bins)\n",
    "    plt.subplot(222)\n",
    "    crowd.plot_error_dist_on_sample(s2[0], s2[1], basic_error, show = False, bins = nb_bins)\n",
    "    plt.subplot(223)\n",
    "    crowd.plot_error_dist_on_sample(s3[0], s3[1], basic_error, show = False, bins = nb_bins)\n",
    "    plt.subplot(224)\n",
    "    crowd.plot_error_dist_on_sample(s4[0], s4[1], basic_error, show = False, bins = nb_bins)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparing the data\n",
    "\n",
    "First, we need to prepare the data in a train / test split. The test part is required to have good approximation of the error on unseen data. The lab asked for a __$75$ / $25$ train / test split__, we select the samples at random to avoid training only on a subset of the data (note that this is overkill since the lab revealed us that the samples were already randomized).\n",
    "\n",
    "The matrix we used has been generated in the __preprocessing__ part of the project. It contains around 3k features instead of 15k in the original matrix.\n",
    "\n",
    "And the last, but not the least, detail : we add a random seed in our random selection to ensure __reproducibility__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_red: (30049, 3004)\n",
      "y: (30049,)\n"
     ]
    }
   ],
   "source": [
    "X_red = np.load(DATA_FOLDER + \"feature_mat_radial_compression_normalized_red.npy\")\n",
    "y = np.load(DATA_FOLDER + \"CSD500-r_train-H_total.npy\")\n",
    "\n",
    "train_set_size = int(len(X_red) * TRAIN_SET_PERC)\n",
    "# Select random rows of the matrix for train / test set\n",
    "# Random seed for reproducibility \n",
    "np.random.seed(100)\n",
    "train_idx = np.random.choice(len(X_red), size=train_set_size, replace = False)\n",
    "test_idx = [i for i in range(len(X_red)) if i not in train_idx]\n",
    "X_train_red = X_red[train_idx, :]\n",
    "X_test_red = X_red[test_idx, :]\n",
    "y_train = y[train_idx]\n",
    "y_test = y[test_idx]\n",
    "print(\"X_red: \" + str(X_red.shape))\n",
    "print(\"y: \" + str(y.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Single neural network model approach \n",
    "\n",
    "First, we want to see how well a __single neural network__ can perform on the data we have at our disposal. Highly influenced by tensorflow's tutorials and Standford University CS231n Convolutional Neural Networks for Visual Recognition lecture (http://cs231n.github.io/), we build our first neural network.\n",
    "\n",
    "We also execute __cross-validations__ on the relevant parameters to get the best RMSE out of the network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_and_pred(nb_layers, nb_neurons, regularizer_fac, optimizer_fac):\n",
    "    # Prepare model \n",
    "    model = tf.keras.Sequential()\n",
    "    for i in range(nb_layers):\n",
    "        model.add(layers.Dense(nb_neurons, activation='relu', \\\n",
    "                               kernel_regularizer=tf.keras.regularizers.l2(regularizer_fac)))\n",
    "    # Last layer represent the electromagnetic shielding, our prediction\n",
    "    model.add(layers.Dense(1, activation='relu'))\n",
    "\n",
    "    model.compile(optimizer=tf.train.AdamOptimizer(optimizer_fac),\n",
    "                  loss='mse',\n",
    "                  # Note that the accuracy metric is useless but it doesn't compile when trying to use RMSE.\n",
    "                  metrics=['mae'])\n",
    "    EPOCHS = 200\n",
    "    BATCH_SIZE = 32\n",
    "    VALIDATION_SPLIT = 0.1\n",
    "    early_stop = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=20)\n",
    "\n",
    "    history = model.fit(X_train_red, y_train, epochs=EPOCHS, batch_size=BATCH_SIZE, validation_split = VALIDATION_SPLIT, \\\n",
    "              callbacks=[early_stop])\n",
    "    plot_history(history)\n",
    "    \n",
    "    result = model.predict(X_test_red, batch_size=32)\n",
    "    error = rmse(result, y_test)\n",
    "    print(\"Error : {}\".format(error))\n",
    "    return error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "errors = [0.7416394267991249, 0.6443409956831526, 0.4930030937745785, \\\n",
    "         0.453638706377575, 0.41453323956187177, 0.4311010863788413, 0.4254569121978898]\n",
    "\n",
    "x = np.logspace(-1, -9, 7)\n",
    "\n",
    "plt.semilogx(x, errors)\n",
    "plt.title(\"RMSE versus Regularization factor\")\n",
    "plt.xlabel(\"Regularizer factor\")\n",
    "plt.ylabel(\"RMSE\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will train the neural network and print its error on the test set.\n",
    "# Since tensorflow is very talkative when training a network, we remove the output for the comfort of the reader.\n",
    "error = train_and_pred(8, 156, 1e-6, 0.001)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results of cross validation over regularization factor\n",
    "\n",
    "For the sake of sanity, we only display the results we obtained to avoid recomputing them. The previous graph shows evolution of the __RMSE for a single neural network versus the L2 regularization factor__.\n",
    "\n",
    "The number of layers and neurons by layers was chosen such that the model is __powerful enough__ to capture most of the complexity of the model, __overfitting being taken care with the L2-regularization__. \n",
    "\n",
    "As for the __optimizer factor__, it will not influence the accuracy of our predictions but rather the convergence time. Hence we chose a factor that allowed us to __converge while keeping a decent amount of epochs__.\n",
    "\n",
    "## Final optimized structure :\n",
    "\n",
    "- __Train / test split__ : $75$ / $25$.\n",
    "- __Number of hidden layers__ : $8$.\n",
    "- __Number of neuron / layers__ : $156$.\n",
    "- __Activations__ : Rectified Linear Unit (relu).\n",
    "- __Regularizer__ : L2 regularizer with factor $10^{-6}$.\n",
    "- __Optimizer__ : Adam Optimizer with factor $10^{-3}$.\n",
    "- __Single network error__ : 0.43."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Crowd of Neural Networks Approach\n",
    "\n",
    "Now we try a new approach based on the *Wisdom Of Crowds* principle which states that the __average of the predictions of a crowd is almost always better than the prediction of a single expert__.\n",
    "\n",
    "Hence we will create a Crowd composed of a __multitude of networks__, train them all on the same training set and then ask them all to predict the test data. We will then __average__ their predictions to give the final answer of the crowd, counting on the randomness of the neural network algorithm to give different answers for each individual, needed assumption for the above principle to hold.\n",
    "\n",
    "Note that most of the code for this part is located in the __Crowd class__, itself defined in the file _crowd.py_.\n",
    "\n",
    "The structure of each networks we use is the optimized one we found in the previous part. Note also that the crowds are pretty long to train, to have good approximations, the more networks they have, the better. However this training should be done only once and __each network is saved__ in the directory of its crowd in the folder _session/_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recovered 16 entities from session/Crowd_opt_2_8_156_relu_1e-06_0.001_mse/16\n"
     ]
    }
   ],
   "source": [
    "crowd_opt2 = crowd.Crowd(X_train_red, y_train, \"Crowd_opt_2\", nb_layers = 8, \\\n",
    "                      nb_neurons=156, regularization_factor=1e-6, validation_split = 0)\n",
    "# Recover the crowd from file.\n",
    "# The file should be located in the 'session' folder\n",
    "crowd_opt2.restore()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will add new networks to the crowd. Note that this is a long operation (up to 2 hours for 8 entities).\n",
    "crowd_opt2.train_new_entities(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prediction time for 7513 samples : 185.83958538400475 seconds\n",
      "RMSE : 0.35298389679256353 \n"
     ]
    }
   ],
   "source": [
    "# Predict on the test set and compute RMSE\n",
    "start = timeit.default_timer()\n",
    "pred = crowd_opt2.predict(X_test_red)\n",
    "stop = timeit.default_timer()\n",
    "error_rmse = rmse(pred, y_test)\n",
    "print('Prediction time for {} samples : {} seconds\\nRMSE : {} '.format(len(X_test_red), stop - start, error_rmse))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the crowd error vs the number of networks used for prediction\n",
    "crowd_opt2.plot_crowd_error(X_test_red, y_test, rmse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the prediction time vs the number of networks used\n",
    "crowd_opt2.plot_crowd_pred_time(X_test_red)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1332x756 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the distribution of the error of the different networks over a single sample\n",
    "plot_crowd_dist_4(crowd_opt2, (X_test_red[0], y_test[0]), (X_test_red[1], y_test[1]), \\\n",
    "                  (X_test_red[2], y_test[2]), (X_test_red[3], y_test[3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A wild idea : use a neural network stacked above the crowd for the prediction\n",
    "\n",
    "This idea is not detailed in the report because it doesn't bring better results than the ones we already have. And because we are limited to 4 pages for the report we had to make choices.\n",
    "\n",
    "This type of predictions __adds a neural network on top of the crowd to make the prediction__. This network will train on the whole training matrix but also on all the predictions of the other networks of the crowd. Doing so should learn it how the other networks did and it may ameliorate its predictions with this knowledge."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a prediction using a stacker at the end of the crowd\n",
    "# Again output is removed because of tensorflow verbosity.\n",
    "print(\"RMSE using stacker : {}\".format(rmse(crowd_opt2.predict_stacked(X_test_red), y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "Looking at the error versus the number of networks used for prediction, the results is undeniable : __the crowd definetely reduce our error in an impressive way__.\n",
    "\n",
    "We can clearly see that the error follows an __exponential decay__ when compared to the number of networks used for a __linear increase of the computation time__. From the plot of the distribution of the error over a single sample, we can see that it is more or less gaussianly distributed. However we observe that this gaussian distribution is __not centered around 0__ which means that adding more and more networks will not necessarly brought us to a RMSE of $0$. \n",
    "\n",
    "Consequently, we have to find better ways of decreasing the error.\n",
    "\n",
    "As a side note, please consider the error obtained with the stacked_prediction. Although it is not as good as the average of the predictions of the crowd (around $0.35$) it is better than the single network error (around $0.43$). Keep this in mind since it will be the starting point of our __collaborative crowds__ later.\n",
    "\n",
    "## Final structure :\n",
    "\n",
    "- Each network composing the crowd is an instance of the optimized version found in the first part.\n",
    "- 16 entities (more will bring better results but also increase the prediction time).\n",
    "- Crowd error : $0.353$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mixture of experts\n",
    "\n",
    "Finally we want to test a last method : instead of assigning the same weight to the prediction of each individual of the Crowd, __we try to assign different weights__ based on ressemblance between the sample to predict and the samples on which the individual performed best. \n",
    "\n",
    "If the data is categorizable, this method may give very good results. The core code is located in the file _experts.py_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recovered 8 entities from session/Experts_opt1_8_156_relu_1e-06_0.001_mse/8\n"
     ]
    }
   ],
   "source": [
    "experts01 = experts.Experts(X_train_red, y_train, \"Experts_opt1\", nb_layers = 8, \\\n",
    "                      nb_neurons=156, regularization_factor=1e-6, validation_split = 0)\n",
    "experts01.restore()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "experts01.train_new_entities(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prediction using gating network\n",
    "\n",
    "Here we want to train a gating network on a matrix $[(S, b)]$ where $S$ is the training samples and $b$ is the neural network that performed best on that sample. Then at prediction time, we ask to this gating network to assign to each neural network composing the crowd a probability that it should be selected. We then compute our final prediction :\n",
    "$$\\hat{y} = \\sum_{i=1}^k p_i \\hat{y}_i$$\n",
    "Where $\\hat{y}$ is the final prediction, $\\hat{y}_i$ is the prediction of network $i$ and $p_i$ is the probability that network $i$ should be selected to make the prediction according to the gating network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Triggers the construction of the gating network (actual predictions will be computed in next cell for clarity)\n",
    "# Again output is removed because of the verbose of sklearn\n",
    "experts01.predict(X_test_red)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.374657711965834, 0.039667213888995106)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rmse(experts01.predict(X_test_red), y_test), \\\n",
    "rmse(experts01.predict(X_train_red), y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prediction using k-means clustering\n",
    "\n",
    "The previous predictions being unsuccessful, we try another approach. We will cluster the data thanks to a __k-means__ algorithm (from the library _sklearn_) and then assign to each cluster the networks that have the smallest average RMSE over the cluster. At prediction time we assign the new sample to the closest cluster and use the related networks for prediction. This may work if data belonging to a given cluster are equally well predicted by a given set of networks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "experts01.predict_kmeans(X_test_red, rmse, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.3765282421913312, 0.07056080187493417)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rmse(experts01.predict_kmeans(X_test_red, rmse, 8), y_test), \\\n",
    "rmse(experts01.predict_kmeans(X_train_red, rmse, 8), y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion on mixture of experts\n",
    "\n",
    "None of the two algorithms described above are successful. We get good results, but nothing better than the prediction of the crowd. Hence we didn't push this idea any further. Moreover, this system is assumed to work well when the data can be categorized in subsets where some networks may perform better than others. It doesn't seem to be our case.\n",
    "\n",
    "### Best results :\n",
    "- Using deep learning categorizer : $0.375$\n",
    "- Using clustering : $0.377$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Collaborative crowd\n",
    "\n",
    "Let's recall the __wild idea__ we had when using the crowd of neural networks. The idea was to stack a neural network on top of the crowd and train it on the training data where we appended the predictions of the other networks of the crowd.\n",
    "\n",
    "We push this idea further and __allow each network of the crowd to access the predictions of the other networks__ previously added. This will allow the newcomer to known what the others predicted, how wrong they were and to __adjust its predictions based on this knownledge__.\n",
    "\n",
    "The core code for this part is located in _collaborative_crowd.py_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recovered 16 entities from session/CollabCrowd_2_8_156_relu_1e-06_0.001_mse/16\n"
     ]
    }
   ],
   "source": [
    "cc1 = cc.CollaborativeCrowd(X_train_red, y_train, \"CollabCrowd_2\", nb_layers = 8, \\\n",
    "                      nb_neurons=156, regularization_factor=1e-6, validation_split = 0)\n",
    "cc1.restore()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cc1.train_new_entities(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last entity RMSE : 0.3812139181354184\n",
      "Last 5 entities RMSE : 0.3586411031403149\n",
      "Average RMSE : 0.3489545411525422\n"
     ]
    }
   ],
   "source": [
    "last, avg, last5 = cc1.predict(X_test_red, True)\n",
    "print(\"Last entity RMSE : {}\".format(rmse(last, y_test)))\n",
    "print(\"Last 5 entities RMSE : {}\".format(rmse(last5, y_test)))\n",
    "print(\"Average RMSE : {}\".format(rmse(avg, y_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cc1.plot_crowd_error(X_test_red, y_test, rmse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cc1.plot_crowd_pred_time(X_test_red)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1332x756 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_crowd_dist_4(cc1, (X_test_red[0], y_test[0]), (X_test_red[1], y_test[1]), \\\n",
    "                  (X_test_red[2], y_test[2]), (X_test_red[3], y_test[3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results of collaborative crowd\n",
    "\n",
    "The collaborative crowd brought better results, we can observe that the __newcomers indeed have an error way smaller than the first networks__ appended to the crowd.\n",
    "\n",
    "Above you can see that the last network performed with a RMSE of $0.38$ over the test set. The new average error has dropped by around $0.004$ compared to the standard crowd which represents $1\\%$ of the error, which is a quite tiny improvement.\n",
    "\n",
    "We also remark that the __distribution of the predictions for one samples has changed__. Some samples are very well predicted (average close to 1) while some others are very far from the truth. __Further investigation on this phenomena could be conducted__, however considering the time given for this project we will not be able to dig in this area.\n",
    "\n",
    "## Final structure :\n",
    "\n",
    "- Each network composing the crowd is an instance of the optimized version found in the first part and has been trained on both the training data and the predictions of the other networks composing the crowd.\n",
    "- 16 entities (more will bring better results but also increase the prediction time).\n",
    "- Collaborative crowd error : $0.349$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SuperCrowd\n",
    "\n",
    "The super crowd has been made with the idea that different estimators may be __combined to offer even better estimations__. The idea behind this is to __vary the sources of biases__. Two systems may have the same bias, however it will not be distributed the same way on all the samples. Consequently some biases may balance each others on some samples and reduce the error.\n",
    "\n",
    "If we combine two models with similar RMSE, __the output of the supercrowd prediction will perform at least as well as them and there's high chances that it performs better__.\n",
    "\n",
    "The class is following the __Composite__ design pattern. Each element composing the SuperCrowd should have a predict(matix) method in order for the algorithm to work. The SuperCrowd itself may be appended to another instance of SuperCrowd.\n",
    "\n",
    "The core code of this class is located in _supercrowd.py_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recovered 16 entities from session/CollabCrowd_2_8_156_relu_1e-06_0.001_mse/16\n",
      "Recovered 16 entities from session/Crowd_opt_2_8_156_relu_1e-06_0.001_mse/16\n"
     ]
    }
   ],
   "source": [
    "supercrowd = sc.SuperCrowd()\n",
    "\n",
    "cc1 = cc.CollaborativeCrowd(X_train_red, y_train, \"CollabCrowd_2\", nb_layers = 8, \\\n",
    "                      nb_neurons=156, regularization_factor=1e-6, validation_split = 0)\n",
    "cc1.restore()\n",
    "\n",
    "crowd_opt2 = crowd.Crowd(X_train_red, y_train, \"Crowd_opt_2\", nb_layers = 8, \\\n",
    "                      nb_neurons=156, regularization_factor=1e-6, validation_split = 0)\n",
    "crowd_opt2.restore()\n",
    "\n",
    "supercrowd.append_crowd(cc1)\n",
    "supercrowd.append_crowd(crowd_opt2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3419144346517784"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rmse(supercrowd.predict(X_test_red), y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results\n",
    "The accuracy of the prediction has been increased. However, note that the computation time is now the sum of all the computation times of all the crowds composing the supercrowd. However we remark that we reduced our RMSE of $0.008$ which is still a __good amelioration__.\n",
    "\n",
    "### Best result\n",
    "- Combinaison of the optimal crowd and the collaborative crowd described above.\n",
    "- Super Crowd error : $0.342$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dropout & max-norm constraint\n",
    "\n",
    "Dropout layers combined with max-norm constraints are referenced in the litterature as a good way to avoid overfitting (N. Srebro and A. Shraibman _Rank, trace-norm and max-norm_). Since we remarked some overfit during the training of our neural network (a training error less that $0.1$ while the test error is around $0.4$ ) we wanted to see if those techniques were worth bringing in the equation. \n",
    "\n",
    "We hence execute a bunch of cross-validations on the input dropout percentage, the inter-layer dropout percentage and the max-norm value to see if we can have better results using them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cv_dropout_maxnorm(df_in, df_hidden, max_norm):\n",
    "    model = tf.keras.Sequential()\n",
    "    model.add(layers.Dropout(df_in))\n",
    "    for i in range(8):\n",
    "        model.add(layers.Dense(156, activation='relu', \\\n",
    "                               kernel_regularizer=tf.keras.regularizers.l2(1e-6), \\\n",
    "                               kernel_constraint=MaxNorm(max_norm)))\n",
    "        model.add(layers.Dropout(df_hidden))\n",
    "    # Last layer represent the electromagnetic shielding, our prediction\n",
    "    model.add(layers.Dense(1, activation='relu'))\n",
    "\n",
    "    model.compile(optimizer=tf.train.AdamOptimizer(0.001),\n",
    "                  loss='mse',\n",
    "                  # Note that the accuracy metric is useless but it doesn't compile when trying to use RMSE.\n",
    "                  metrics=['mae'])\n",
    "    EPOCHS = 200\n",
    "    BATCH_SIZE = 32\n",
    "    VALIDATION_SPLIT = 0.1\n",
    "    early_stop = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=20)\n",
    "\n",
    "    history = model.fit(X_train_red, y_train, epochs=EPOCHS, batch_size=BATCH_SIZE, validation_split = VALIDATION_SPLIT, \\\n",
    "              callbacks=[early_stop])\n",
    "    plot_history(history)\n",
    "\n",
    "    result = model.predict(X_test_red, batch_size=32)\n",
    "    error = rmse(result, y_test)\n",
    "    print(\"Error : {}\".format(error))\n",
    "    return error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cross validation on the dropout percentage on the input, the one between the layers and the max-norm.\n",
    "# Again we don't display the run for clarity purposes\n",
    "errors = []\n",
    "for df_in in [0.2, 0.3]:\n",
    "    print(\"df_in = \" + str(df_in))\n",
    "    for df_hidden in [0.4, 0.5]:\n",
    "        print(\"    df_hidden = \" + str(df_hidden))\n",
    "        for max_norm in [3, 4]:\n",
    "            print(\"        max_norm = \" + str(max_norm))\n",
    "            errors.append(cv_dropout_maxnorm(df_in, df_hidden, max_norm))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusion on dropout & max-norm\n",
    "\n",
    "Those techniques don't bring better results than what we already have. Even after trying with several different combinaisons, we couldn't do better than $0.45$ for a single network RMSE. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Collaborative Crowd on jittered matrix\n",
    "\n",
    "Another good way to increase performances of a neural network is to artificially add samples to the matrix we already have."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((22761, 3004), (22761,), (7513, 3004), (7513,))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train_red = np.load(DATA_FOLDER + \"x_pca_train.npy\")\n",
    "y_train = np.load(DATA_FOLDER + \"y_pca_train.npy\")\n",
    "X_test_red = np.load(DATA_FOLDER + \"x_pca_test.npy\")\n",
    "y_test = np.load(DATA_FOLDER + \"y_pca_test.npy\")\n",
    "X_train_red.shape, y_train.shape, X_test_red.shape, y_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No directory with name session/CollabCrowd_jitter_8_156_relu_1e-06_0.001_mse\n"
     ]
    }
   ],
   "source": [
    "cc_jitt = cc.CollaborativeCrowd(X_train_red, y_train, \"CollabCrowd_jitter\", nb_layers = 8, \\\n",
    "                      nb_neurons=156, regularization_factor=1e-6, validation_split = 0)\n",
    "cc_jitt.restore()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cc_jitt.train_new_entities(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.117733862088689"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avg = cc_jitt.predict(X_test_red)\n",
    "rmse(avg, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results\n",
    "\n",
    "Here the results are a disaster. Maybe the jittering is to strong or maybe this type of jittering is not ideal for big deep learning neural networks that are able to fit the data very well. Also the jittering has been added without changing the prediction, no garantees are given that the data created this way is valid."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusion on Deep Learning\n",
    "\n",
    "The results we have for different architecture we implemented propose a significant increase in accuracy compared to standard Machine Learning techniques. The results suggest to continue digging in the area of Deep Learning to decrease the errors even further as it seems to suit their problem better."
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}