net_mape_nb_features.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Goal : Plot MAPE*nb_features\n",
    "\n",
    "Conditions :\n",
    "\n",
    "- feature_importance from random forest\n",
    "- 90% training, 10% test\n",
    "- best hyper-parameters\n",
    "\n",
    "--"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tuxml\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "from sklearn.model_selection import train_test_split\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "features = tuxml.load_dataset()\n",
    "\n",
    "# normalization of the nb yes/no/module counters\n",
    "col = features.columns\n",
    "# I assumed 12611 was (around) the number of real options we can change to compile the linux kernel => cf option_columns.json\n",
    "nb_features = 12611\n",
    "to_normalize = ['nbyes', 'nbno', 'nbmodule', 'nbyesmodule']\n",
    "for feat in to_normalize:\n",
    "    if feat in col:\n",
    "        features[feat] = features[feat]/nb_features\n",
    "\n",
    "df_selection = pd.read_csv('feature_importanceRF.csv', names = ['features', 'imp'], skiprows = 0)\n",
    "selection = df_selection['features']\n",
    "imp = df_selection['imp']\n",
    "sorted_imp = sorted(imp, reverse = True)\n",
    "\n",
    "def choose_features(nb_features):\n",
    "    \n",
    "    threshold_imp = sorted_imp[nb_features-1]\n",
    "\n",
    "    final = selection[imp>threshold_imp]\n",
    "    final[len(final)] = 'vmlinux'\n",
    "    print(len(final))\n",
    "    # selection\n",
    "    features2 = features[final]\n",
    "    \n",
    "    return features2.replace([2,-1],0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Test_functions\n",
    "\n",
    "\n",
    "### Compute_features(p) gives the couple (MAPE train, MAPE test) returned  by the neural network fed with the p most important features (random forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_standard(features):\n",
    "    n = 65000\n",
    "    sizes = np.array(features[0:n]['vmlinux'])\n",
    "    x_train, x_test, y_train, y_test = train_test_split(features.drop('vmlinux', axis=1)[0:n], sizes, test_size = 0.1)\n",
    "\n",
    "    nbCol = len(features.columns)\n",
    "\n",
    "    x_train = np.array(x_train, dtype = np.float32)\n",
    "    x_test =  np.array(x_test, dtype = np.float32)\n",
    "\n",
    "    y_train = np.array(y_train, dtype = np.float32)\n",
    "    y_test = np.array(y_test, dtype = np.float32)\n",
    "\n",
    "    nb_features = x_train.shape[1]\n",
    "    batch_size = 50\n",
    "    nb_epochs = 30\n",
    "    nb_batch_train = int(len(x_train)/batch_size)-1\n",
    "    nb_batch_test = int(len(x_test)/batch_size)\n",
    "    nb_node_layer1 = 200\n",
    "    nb_node_layer2 = 300\n",
    "\n",
    "    # slice the datasets => feed_dict was very slow, so I choose an iterator solution\n",
    "    dataset_train = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(batch_size)\n",
    "    iterator_train = tf.compat.v1.data.make_initializable_iterator(dataset_train)\n",
    "    xtr, ytr = iterator_train.get_next()\n",
    "\n",
    "    dataset_test = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(batch_size)\n",
    "    iterator_test = tf.compat.v1.data.make_initializable_iterator(dataset_test)\n",
    "    xte, yte = iterator_test.get_next()\n",
    "\n",
    "    with tf.device(\"/gpu:0\"):\n",
    "        # Layers training\n",
    "        w_h1_tr = tf.Variable(tf.glorot_uniform_initializer()((nb_features, nb_node_layer1)), name = \"w_h1_tr\")\n",
    "        mat_h1_tr = tf.matmul(xtr, w_h1_tr)\n",
    "        b_h1_tr = tf.Variable(tf.zeros(nb_node_layer1), name=\"b_h1_tr\")\n",
    "        out_h1_tr = tf.nn.relu(tf.add(mat_h1_tr, b_h1_tr))\n",
    "\n",
    "        w_h2_tr = tf.Variable(tf.glorot_uniform_initializer()((nb_node_layer1, nb_node_layer2)), name = \"w_h2_tr\")\n",
    "        mat_h2_tr = tf.matmul(out_h1_tr, w_h2_tr)\n",
    "        b_h2_tr = tf.Variable(tf.zeros(nb_node_layer2), name=\"b_h2_tr\")\n",
    "        out_h2_tr = tf.nn.relu(tf.add(mat_h2_tr, b_h2_tr))\n",
    "\n",
    "        w_final_tr = tf.Variable(tf.glorot_uniform_initializer()((nb_node_layer2, 1)), name = \"w_final_tr\")\n",
    "        outputs_tr =  tf.reshape(tf.matmul(out_h2_tr, w_final_tr), shape=[batch_size])\n",
    "        ytr = tf.reshape(ytr, [batch_size])\n",
    "\n",
    "        # Layers test\n",
    "        mat_h1_te = tf.matmul(xte, w_h1_tr)\n",
    "        out_h1_te = tf.nn.relu(tf.add(mat_h1_te, b_h1_tr))\n",
    "\n",
    "        mat_h2_te = tf.matmul(out_h1_te, w_h2_tr)\n",
    "        out_h2_te = tf.nn.relu(tf.add(mat_h2_te, b_h2_tr))\n",
    "\n",
    "        outputs_te =  tf.reshape(tf.matmul(out_h2_te, w_final_tr), shape=[batch_size])\n",
    "        yte = tf.reshape(yte, [batch_size])\n",
    "\n",
    "        # Cost => MAPE\n",
    "        train_cost = tf.keras.losses.MAPE(ytr, outputs_tr)\n",
    "        test_cost = tf.keras.losses.MAPE(yte, outputs_te)\n",
    "\n",
    "        # Convergence function => AdamOptimizer\n",
    "        train_step = tf.train.AdamOptimizer(learning_rate=0.5).minimize(train_cost)\n",
    "\n",
    "        # train step with a lower learning rate => gain few % at the end\n",
    "        tiny_train_step = tf.train.AdamOptimizer(learning_rate=0.025).minimize(train_cost)\n",
    "\n",
    "        # allocate memory for tensors\n",
    "        init = tf.global_variables_initializer()\n",
    "\n",
    "    with tf.Session() as sess:\n",
    "        sess.run(init)\n",
    "        for j in range(nb_epochs):\n",
    "            if j < 20:\n",
    "                sess.run(iterator_train.initializer)\n",
    "                for i in range(nb_batch_train):\n",
    "                    val = sess.run(train_step)\n",
    "                #print(\"Cout entrainement epoch n°\", j+1, \":\",  sess.run(train_cost))\n",
    "            else:\n",
    "                sess.run(iterator_train.initializer)\n",
    "                for i in range(nb_batch_train):\n",
    "                    val = sess.run(tiny_train_step)\n",
    "                #print(\"Cout entrainement epoch n°\", j+1, \":\",  sess.run(train_cost))\n",
    "        sess.run(iterator_train.initializer)\n",
    "        mape = 0\n",
    "        for i in range(nb_batch_train):\n",
    "            mape+=sess.run(train_cost)\n",
    "        mape_train = mape/nb_batch_train\n",
    "        sess.run(iterator_test.initializer)\n",
    "        mape = 0\n",
    "        for i in range(nb_batch_test):\n",
    "            mape+=sess.run(test_cost)\n",
    "        mape_test = mape/nb_batch_test\n",
    "        return (mape_train, mape_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### All the features are not supported (it creates a tensor bigger than 2 Gigabytes, and crashes the kernel), but by reducing the number of the first layer to 200 nodes, we can compute until 8000 features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9239"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df_selection)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "WARNING:tensorflow:From C:\\Users\\llesoil\\Documents\\Anaconda3\\envs\\tensor_gpu\\lib\\site-packages\\tensorflow\\python\\data\\ops\\dataset_ops.py:1419: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From C:\\Users\\llesoil\\Documents\\Anaconda3\\envs\\tensor_gpu\\lib\\site-packages\\tensorflow\\python\\ops\\math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n",
      "50 (7.479199070926402, 7.966091020290668)\n",
      "100\n",
      "100 (6.362605203003635, 7.531402166073139)\n",
      "250\n",
      "250 (4.500358184246654, 6.166484997822688)\n",
      "500\n",
      "500 (3.87748114567113, 5.995050588020912)\n",
      "750\n",
      "750 (3.820579105610517, 6.031110539803138)\n",
      "1000\n",
      "1000 (3.723123487394217, 6.413761857839731)\n",
      "1200\n",
      "1200 (3.736771368592901, 6.631464187915508)\n",
      "1500\n",
      "1500 (4.0686002548583255, 7.396629575582651)\n",
      "2000\n",
      "2000 (4.167195938712415, 7.861370420455932)\n",
      "2500\n",
      "2500 (4.216191209208976, 7.952859753828783)\n",
      "3000\n",
      "3000 (4.419150530527146, 8.46539215674767)\n",
      "4000\n",
      "4000 (4.32036808150971, 8.760453568972075)\n",
      "5000\n",
      "5000 (4.253250440641588, 9.530968284606933)\n",
      "6000\n",
      "6000 (4.929930310457358, 9.787896585464477)\n",
      "7000\n",
      "7000 (4.68738895282468, 9.974623096906221)\n",
      "8000\n",
      "8000 (5.0598881624008065, 10.888339453477126)\n",
      "8389\n",
      "9239 (5.126091190848828, 10.496802975581243)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{50: (7.479199070926402, 7.966091020290668),\n",
       " 100: (6.362605203003635, 7.531402166073139),\n",
       " 250: (4.500358184246654, 6.166484997822688),\n",
       " 500: (3.87748114567113, 5.995050588020912),\n",
       " 750: (3.820579105610517, 6.031110539803138),\n",
       " 1000: (3.723123487394217, 6.413761857839731),\n",
       " 1200: (3.736771368592901, 6.631464187915508),\n",
       " 1500: (4.0686002548583255, 7.396629575582651),\n",
       " 2000: (4.167195938712415, 7.861370420455932),\n",
       " 2500: (4.216191209208976, 7.952859753828783),\n",
       " 3000: (4.419150530527146, 8.46539215674767),\n",
       " 4000: (4.32036808150971, 8.760453568972075),\n",
       " 5000: (4.253250440641588, 9.530968284606933),\n",
       " 6000: (4.929930310457358, 9.787896585464477),\n",
       " 7000: (4.68738895282468, 9.974623096906221),\n",
       " 8000: (5.0598881624008065, 10.888339453477126),\n",
       " 9239: (5.126091190848828, 10.496802975581243)}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nb_features = [50,100,250,500,750,1000,1200,1500,2000,2500,3000,4000,5000,6000,7000,8000, len(df_selection)]\n",
    "\n",
    "res = dict()\n",
    "\n",
    "for nb_f in nb_features:\n",
    "    res[nb_f] = compute_standard(choose_features(nb_f))\n",
    "    print(nb_f, res[nb_f])\n",
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{50: (7.479199070926402, 7.966091020290668),\n",
       " 100: (6.362605203003635, 7.531402166073139),\n",
       " 250: (4.500358184246654, 6.166484997822688),\n",
       " 500: (3.87748114567113, 5.995050588020912),\n",
       " 750: (3.820579105610517, 6.031110539803138),\n",
       " 1000: (3.723123487394217, 6.413761857839731),\n",
       " 1200: (3.736771368592901, 6.631464187915508),\n",
       " 1500: (4.0686002548583255, 7.396629575582651),\n",
       " 2000: (4.167195938712415, 7.861370420455932),\n",
       " 2500: (4.216191209208976, 7.952859753828783),\n",
       " 3000: (4.419150530527146, 8.46539215674767),\n",
       " 4000: (4.32036808150971, 8.760453568972075),\n",
       " 5000: (4.253250440641588, 9.530968284606933),\n",
       " 6000: (4.929930310457358, 9.787896585464477),\n",
       " 7000: (4.68738895282468, 9.974623096906221),\n",
       " 8000: (5.0598881624008065, 10.888339453477126),\n",
       " 9239: (5.126091190848828, 10.496802975581243)}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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>MAPE train</th>\n",
       "      <th>MAPE test</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>50</th>\n",
       "      <td>7.479199</td>\n",
       "      <td>7.966091</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>100</th>\n",
       "      <td>6.362605</td>\n",
       "      <td>7.531402</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>250</th>\n",
       "      <td>4.500358</td>\n",
       "      <td>6.166485</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>500</th>\n",
       "      <td>3.877481</td>\n",
       "      <td>5.995051</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>750</th>\n",
       "      <td>3.820579</td>\n",
       "      <td>6.031111</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1000</th>\n",
       "      <td>3.723123</td>\n",
       "      <td>6.413762</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1200</th>\n",
       "      <td>3.736771</td>\n",
       "      <td>6.631464</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1500</th>\n",
       "      <td>4.068600</td>\n",
       "      <td>7.396630</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2000</th>\n",
       "      <td>4.167196</td>\n",
       "      <td>7.861370</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2500</th>\n",
       "      <td>4.216191</td>\n",
       "      <td>7.952860</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3000</th>\n",
       "      <td>4.419151</td>\n",
       "      <td>8.465392</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4000</th>\n",
       "      <td>4.320368</td>\n",
       "      <td>8.760454</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5000</th>\n",
       "      <td>4.253250</td>\n",
       "      <td>9.530968</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6000</th>\n",
       "      <td>4.929930</td>\n",
       "      <td>9.787897</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7000</th>\n",
       "      <td>4.687389</td>\n",
       "      <td>9.974623</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8000</th>\n",
       "      <td>5.059888</td>\n",
       "      <td>10.888339</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8389</th>\n",
       "      <td>5.126091</td>\n",
       "      <td>10.496803</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      MAPE train  MAPE test\n",
       "50      7.479199   7.966091\n",
       "100     6.362605   7.531402\n",
       "250     4.500358   6.166485\n",
       "500     3.877481   5.995051\n",
       "750     3.820579   6.031111\n",
       "1000    3.723123   6.413762\n",
       "1200    3.736771   6.631464\n",
       "1500    4.068600   7.396630\n",
       "2000    4.167196   7.861370\n",
       "2500    4.216191   7.952860\n",
       "3000    4.419151   8.465392\n",
       "4000    4.320368   8.760454\n",
       "5000    4.253250   9.530968\n",
       "6000    4.929930   9.787897\n",
       "7000    4.687389   9.974623\n",
       "8000    5.059888  10.888339\n",
       "8389    5.126091  10.496803"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(np.transpose(pd.DataFrame(res)))\n",
    "df.columns =[\"MAPE train\", \"MAPE test\"]\n",
    "ind_df = np.array(df.index)\n",
    "# 8389 was the real number of features for the last launch\n",
    "ind_df[len(ind_df)-1] = 8389\n",
    "df.index = ind_df\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize =(15,10))\n",
    "plt.scatter(ind_df, df[\"MAPE train\"], color =\"blue\", marker = \"s\")\n",
    "plt.plot(ind_df, df[\"MAPE train\"], color =\"blue\")\n",
    "plt.scatter(ind_df, df[\"MAPE test\"], color =\"red\", marker = \"s\")\n",
    "plt.plot(ind_df, df[\"MAPE test\"], color =\"red\")\n",
    "plt.xlabel(\"Number of features in input\")\n",
    "plt.ylabel(\"MAPE (Mean Average Percentage Error)\")\n",
    "plt.savefig(\"net_mape_nb_features.png\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "train = blue,\n",
    "test = red"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}