ift7025-projet/Code/Rapport-Partiel.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "## Définitions\n",
    "\n",
    "La **matrice de confusion** est un tableau où on décompte les valeurs réelle O et prédites S pour chaque observation du jeu de données dans un problème de classification. Par sa conception, on peut valider rapidement le nombre d'observations où la prédiction est égale à la valeur réelle sur la diagonale de la matrice. Par convention, on place les valeurs prédites à la verticale et les valeurs observées à l'horizontale. Lorsque le nombre de modalités de la variable prédite est de deux, on a un problème de classification binaire et on obtient alors le décompte des vrais positifs, faux positifs, faux négatifs et vrais négatifs.\n",
    "\n",
    "La **précision** correspont à la proportion d'observations où la prédiction et la valeur réelle est dans une même classe par rapport au nombre d'observations où la prédiction est dans cette classe\n",
    "\n",
    "$$ \\text{Précision}_c =  \\frac{\\sum_{i=1}^N 1_{s_i=c}1_{o_i=c}}{\\sum_{i=1}^N 1_{s_i=c}}$$\n",
    "\n",
    "Le **rappel** correspond à la proportions d'observations où la prédiction est dans une classe par rapport au nombre d'observations où la valeur réelle est dans cette classe.\n",
    "\n",
    "$$ \\text{Rappel}_c =  \\frac{\\sum_{i=1}^N 1_{s_i=c}}{\\sum_{i=1}^N 1_{o_i=c}}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Librairies utilisées\n",
    "\n",
    "Le project actuel est programmé dans le langage Python 3, et ce rapport est produit à l'aide de Jupyter Notebook. Seule les librairie standard `numpy` et `math` est utilisée, les autres ont été développées dans le cadre de ce projet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Librairies standard\n",
    "import numpy as np\n",
    "import math\n",
    "# Librairies développées par l'étudiant\n",
    "import load_datasets as ld\n",
    "import metrics\n",
    "import BayesNaif\n",
    "import Knn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jeux de données\n",
    "\n",
    "Ce projet utilise 3 jeux de données: [Iris](https://archive.ics.uci.edu/ml/datasets/Iris), [MONKS](https://archive.ics.uci.edu/ml/datasets/MONK's+Problems) et [Congressional Voting Records Dataset](https://archive.ics.uci.edu/ml/datasets/Congressional+Voting+Records). Pour les jeux qui ne sont pas déjà divisés en entrainement et test, on utilisera un ratio de 70% pour l'entrainement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train1, train_labels1, test1, test_labels1 = ld.load_iris_dataset(train_ratio = 0.7)\n",
    "train2, train_labels2, test2, test_labels2 = ld.load_monks_dataset(1)\n",
    "train3, train_labels3, test3, test_labels3 = ld.load_monks_dataset(2)\n",
    "train4, train_labels4, test4, test_labels4 = ld.load_monks_dataset(3)\n",
    "train5, train_labels5, test5, test_labels5 = ld.load_congressional_dataset(0.7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "# Algorithme des k plus proches voisins (kNN)\n",
    "\n",
    "Dans cette section, on présente les résultats obtenus pour l'algorithme des k plus proches voisins. Ce n'est pas un algorithme d'apprentissage à proprement parler, car il n'y a aucun modèle d'entrainé. On prédit la classe d'un nouvel élément en recherchant les $k$ plus proches voisins selon une métrique choisie. Dans notre cas, nous utiliserons la distance de Minkowski, qui est une généralisation de la distance euclidienne et de la distance de Manhattan à l'aide d'un paramètre $p$. Pour nos besoins, on le fixe à $p=2$, soit la distance euclidienne.\n",
    "\n",
    "$${\\displaystyle D\\left(X,Y\\right)=\\left(\\sum _{i=1}^{N}|o_{i}-s_{i}|^{p}\\right)^{1/p}}$$\n",
    "\n",
    "On peut ainsi itérer sur différentes valeurs de ce paramètre pour trouver la mesure la plus adaptée au problème, tout en réutilisant la même fonction. Cette métrique s'utilise aurant pour des domaines de valeurs continus que discrets.\n",
    "\n",
    "## Pseudocode\n",
    "\n",
    "- Initialisation\n",
    "\n",
    "```\n",
    "k = 5\n",
    "minkowski_p = 2\n",
    "```\n",
    "\n",
    "- Entrainement\n",
    "\n",
    "```\n",
    "Copier le jeu d'entrainement et les étiquettes d'entrainement dans la mémoire du modèle\n",
    "```\n",
    "\n",
    "- Prédiction\n",
    "```\n",
    "Pour une observation x_i:\n",
    "    Entrainement <- Vrai si on fait le premier entrainement\n",
    "    T = copie jeu d'entrainement\n",
    "    L = copie des étiquettes d'entrainement\n",
    "    K = tableau de paires (point, distance) de longueur k\n",
    "    Si Entrainement:\n",
    "        Enlever x de T et l'étiquette de x_i de L\n",
    "    Pour chaque observation t_j, j=[1,k]) de T:\n",
    "        d(x_i,t_i) = distance de Minkowski entre x_i et t_j\n",
    "        K[j] <- (t_i,d(x_i,t_j)) \n",
    "    Pour chaque observation t_j, j=[k+1,N-1] de T:\n",
    "        d(x,t_i) = distance de Minkowski entre x_i et t_j\n",
    "        d_max <- distance maximum dans K\n",
    "        pos_d_max <- position de d_max dans K\n",
    "        Si d(x_i,t_j) < d_max\n",
    "            Remplacer le point K[pos_d_max] par (t_j,d(x,t_j))\n",
    "    s <- mode des valeurs des étiquettes des points dans K\n",
    "    retourner s\n",
    "```\n",
    "\n",
    "- Test\n",
    "\n",
    "```\n",
    "Pour chaque observation x_i, i=1,N:\n",
    "    S_i <- Prédiction(x_i)\n",
    "M <- matrice de confusion avec les étiquettes d'entrainement et les étiquettes S\n",
    "Calculer les métriques depuis M\n",
    "```\n",
    "\n",
    "- Validation croisée\n",
    "\n",
    "```\n",
    "K <- Valeurs à tester pour le nombre de voisins\n",
    "Pour un jeu d'entrainement x\n",
    "Permuter aléatoirement les nombre de 1 à N\n",
    "Diviser la permutation en L groupes approximativement égaux\n",
    "Pour l dans L:\n",
    "    \n",
    "\n",
    "Pour k dans K:\n",
    "    Pour l dans L:\n",
    "        Effectuer l'entrainement avec k voisins, x[sans l] comme jeu d'entrainement \n",
    "        Effectuer le test avec x[l] comme jeu de validation\n",
    "        Calculer l'exactitude\n",
    "    Prendre la moyenne des exactitudes\n",
    "Prendre le k avec la meilleur exactitude moyenne\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iris Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On utilise 70% des données pour le jeu d'entrainement et 30% des données pour le jeu de test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On crée un premier modèle afin d'identifier la meilleure valeur de k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "findbest_Knn = Knn.Knn()\n",
    "meilleur_k = findbest_Knn.set_best_k(train1, train_labels1, nb_split=5, k_potentiel=range(2,12))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On crée maintenant un nouveau modèle où on initialise la valeur de K avec celle trouvée précédemment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myKnn = Knn.Knn(meilleur_k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On effectue l'entrainement du modèle (la copie du jeu d'entrainement et des étiquettes en mémoire) et on obtient les mesures de validation pour ce jeu d'entraînement. Les valeurs des métriques de précision et de rappel sont calculées pour chacune des étiquettes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_iris_knn = myKnn.train(train1, train_labels1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On effectue maintenant le test avec l'échantillon de test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_iris_knn = myKnn.test(test1, test_labels1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Monks Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "### Premier sous-ensemble"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On identifie la meilleure valeur de k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "findbest_Knn = Knn.Knn()\n",
    "meilleur_k = findbest_Knn.set_best_k(train2, train_labels2, nb_split=5, k_potentiel=range(2,12))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myKnn2 = Knn.Knn(meilleur_k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On effectue l'entrainement du modèle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_monks1_knn = myKnn2.train(train2, train_labels2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On effectue maintenant le test avec l'échantillon de test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_monks1_knn = myKnn2.test(test2, test_labels2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Second sous-ensemble"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On identifie la meilleure valeur de k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "findbest_Knn = Knn.Knn()\n",
    "meilleur_k = findbest_Knn.set_best_k(train3, train_labels3, nb_split=5, k_potentiel=range(2,12))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myKnn3 = Knn.Knn(meilleur_k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On effectue l'entrainement du modèle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_monks2_knn = myKnn3.train(train3, train_labels3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On effectue maintenant le test avec l'échantillon de test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_monks2_knn = myKnn3.test(test3, test_labels3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Troisième sous-ensemble"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On identifie la meilleure valeur de k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "findbest_Knn = Knn.Knn()\n",
    "meilleur_k = findbest_Knn.set_best_k(train4, train_labels4, nb_split=5, k_potentiel=range(2,12))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myKnn4 = Knn.Knn(meilleur_k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On effectue l'entrainement du modèle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_monks3_knn = myKnn4.train(train4, train_labels4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On effectue maintenant le test avec l'échantillon de test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_monks3_knn = myKnn4.test(test4, test_labels4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Congressional Voting Records Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On identifie la meilleure valeur de k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "findbest_Knn = Knn.Knn()\n",
    "meilleur_k = findbest_Knn.set_best_k(train5, train_labels5, nb_split=5, k_potentiel=range(2,12))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myKnn5 = Knn.Knn(meilleur_k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On effectue l'entrainement du modèle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_congres_knn = myKnn5.train(train5, train_labels5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On effectue maintenant le test avec l'échantillon de test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_congres_knn = myKnn5.test(test5, test_labels5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Algorithme Bayes Naïf\n",
    "\n",
    "Cet algorithme est basé sur la règle de Bayes:\n",
    "\n",
    "$$\n",
    "P(C|X) = \\frac{P(X|C)P(C)}{P(X)}\n",
    "$$\n",
    "\n",
    "Dans notre cas, le dénominateur est une constante et ne nous intéresse pas. Nous le représentons par la lettre $\\alpha$\n",
    "\n",
    "En posant l'hypothèse de l'indépendance conditionnelle entre les caractéristiques $X_1,\\ldots,X_m$, on peut réécrire la règle comme suit:\n",
    "\n",
    "$$\n",
    "P(C|X) = \\alpha P(X) \\prod_{f=1}^m P(X_f|C)\n",
    "$$\n",
    "\n",
    "Dans le cas de variables descriptives continues, la probabilité $P(X_f|C)$ prend plutôt la forme d'une distribution de probabilités. On utilisera alors la fonction de densité de probabilités de la loi gaussienne, avec la moyenne et l'écart-type estimés à partir des données.\n",
    "\n",
    "## Pseudocode\n",
    "\n",
    "### Initialisation\n",
    "\n",
    "Il n'y a aucun paramètre à initialiser\n",
    "\n",
    "### Entrainement\n",
    "\n",
    "L'entrainement se fait en deux parties. On calcule d'abord les probabilités à priori des classes de l'étiquette $\\mathbf{P}(C)$\n",
    "\n",
    "```\n",
    "T = copie jeu d'entrainement\n",
    "L = copie des étiquettes d'entrainement\n",
    "Pour c dans unique(L):\n",
    "    Compteur=0\n",
    "    Pour l dans L:\n",
    "        Si l=c:\n",
    "            Compteur+=1\n",
    "    P(C=c) = Compteur/N\n",
    "```\n",
    "\n",
    "On calcule ensuite les probabilités conditionnelles des caractéristiques sachant la classe de l'étiquette $\\mathbf{P}(F_1,\\ldots,F_m|C)$\n",
    "\n",
    "```\n",
    "F <- Liste des caractéristiques\n",
    "Pour c dans unique(L):\n",
    "    TS <- filtrer(T si L=c)\n",
    "    NS <- taille(TS)\n",
    "    Pour f dans F:\n",
    "        Si Gaussien:\n",
    "            Parametres(C=c,F=f) = (moyenne(TS[f]), écart-type(TS[f]))\n",
    "        Sinon:\n",
    "            Pour v dans unique(TS[f]):\n",
    "                Compteur = 0\n",
    "                Pour l dans TS[f]:\n",
    "                Si l=v:\n",
    "                    Compteur+=1\n",
    "            P(C=c,F=f,V=v) = Compteur/NS\n",
    "```\n",
    "\n",
    "Pour la prédiction, on ne calcule pas le facteur de régularisation $\\alpha$ pour amener les probabilité à 1, car ce qui nous intéresse, c'est une relation d'ordre et celle-ci est inchangée si on la divise par un nombre positif.\n",
    "\n",
    "### Prédiction\n",
    "\n",
    "```\n",
    "Pour c dans unique(L):\n",
    "    Produit=0\n",
    "    Pour f dans F:\n",
    "        Pour l dans TS[f]:\n",
    "        Si Gaussien:\n",
    "            Si Parametres(C=c,F=f) existe:\n",
    "                Produit *= Densité_Gaussien(l,Parametres(C=c,F=f))\n",
    "        Sinon\n",
    "            Si P(C=c,F=f,V=l) existe:\n",
    "                Produit *= P(C=c,F=f,V=l)\n",
    "    P(X|c) = Produit\n",
    "Retourner c où P(X|c) = Max(P(X|C))\n",
    "```\n",
    "\n",
    "### Test\n",
    "\n",
    "```\n",
    "Pour chaque observation x_i, i=1,N:\n",
    "    S_i <- Prédiction(x_i)\n",
    "M <- matrice de confusion avec les étiquettes d'entrainement et les étiquettes S\n",
    "Calculer les métriques depuis M\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iris Dataset\n",
    "\n",
    "Comme ce jeu de données présente des caractéristiques continues, on utilisera la variante gaussienne du Bayes Naif"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "BN = BayesNaif.BayesNaif(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mesures de performance sur l'échantillon d'entrainement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_iris_nb = BN.train(train1, train_labels1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mesures de performance sur l'échantillon de test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_iris_nb = BN.test(test1,test_labels1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Monks Dataset\n",
    "\n",
    "Comme ce jeu de données présente des caractéristiques discrètes, on n'utilise pas la variante gaussienne du Bayes Naif"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Premier sous-ensemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "BN2 = BayesNaif.BayesNaif(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_monks1_nb = BN2.train(train2, train_labels2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mesures de performance sur l'échantillon de test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_monks1_nb = BN2.test(test2,test_labels2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Second sous-ensemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "BN3 = BayesNaif.BayesNaif(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_monks2_nb = BN3.train(train3, train_labels3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mesures de performance sur l'échantillon de test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_monks2_nb = BN3.test(test3,test_labels3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Troisième sous-ensemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "BN4 = BayesNaif.BayesNaif(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_monks3_nb = BN4.train(train4, train_labels4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mesures de performance sur l'échantillon de test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_monks3_nb = BN4.test(test4,test_labels4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Congressional Voting Records Dataset\n",
    "\n",
    "Comme ce jeu de données présente des caractéristiques discrètes, on n'utilise pas la variante gaussienne du Bayes Naif"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "BN5 = BayesNaif.BayesNaif(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_congres_nb = BN5.train(train5, train_labels5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mesures de performance sur l'échantillon de test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_congres_nb = BN5.test(test5, test_labels5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tableau sommaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tous_resultats = [[\"Iris\",test_iris_knn,test_iris_nb],\n",
    "                  [\"MONKS1\",test_monks1_knn,test_monks1_nb],\n",
    "                  [\"MONKS2\",test_monks2_knn,test_monks2_nb],\n",
    "                  [\"MONKS3\",test_monks3_knn,test_monks3_nb],\n",
    "                  [\"Votes\",test_congres_knn,test_congres_nb]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exactitude\n",
    "\n",
    "Le tableau ci-dessous présente l'exactitude pour les modèles KNN et NB ainsi que le meilleur modèle dans ce cas. On remarque que pour le jeu de données Iris, le résultat obtenu est le même pour les deux modèles. Pour les jeux MONKS, dans deux des trois cas, le modèle KNN est meilleur, mais les deux résultats sont faibles. Dans le troisième cas, le modèle NB est largement plus exact, une situation similaire se reproduit pour les données sur les votes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.array([(i[0],\n",
    "           i[1][1],\n",
    "           i[2][1],\n",
    "           \"KNN\" if i[1][1]>i[2][1] else \"NB\") for i in tous_resultats]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Précision\n",
    "\n",
    "On obtient les mêmes constats que précédemment au niveau de la précision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.array([(i[0],\n",
    "           i[1][2],\n",
    "           i[2][2],\n",
    "           \"KNN\" if i[1][2]>i[2][2] else \"NB\") for i in tous_resultats]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rappel\n",
    "\n",
    "Pour le rappel, on obtient des résultats différents. Pour une même exactitude, le modele KNN a un meilleur rappel pour la seconde classe. Pour le jeu de données MONKS1, l'ordre des valeurs du rappel est inversé. Ceci nous montre qu'il est important de sélectionner la mesure la plus importante pour le problème que nous voulons résoudre, car il est possible d'obtenir un conclusion erronée en utilisant une autre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.array([(i[0],\n",
    "           i[1][3],\n",
    "           i[2][3],\n",
    "           \"KNN\" if i[1][3]>i[2][3] else \"NB\") for i in tous_resultats]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Temps d'exécution\n",
    "\n",
    "Dans tous les cas, le temps de calcul du Naive Bayes est signicativement plus court."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.array([(i[0],\n",
    "           i[1][4],\n",
    "           i[2][4],\n",
    "           \"KNN\" if i[1][4]<i[2][4] else \"NB\") for i in tous_resultats]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Difficultés rencontrées"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algorithme kNN\n",
    "\n",
    "Une des difficultés rencontrées a été d'avoir effectivement le bon nombre de voisins dans l'entraînement, car le jeu d'entrainement contient toujours l'exemple et a une distance de 0. J'ai donc du modifier l'ensemble d'entrainement pour enlever l'exemple actif lors du calcul des métriques. Ceci était nécessaire pour pouvoir calculer la meilleure valeur de $k$.\n",
    "\n",
    "### Algorithme Bayes Naïf\n",
    "\n",
    "Comme il est possible de rencontrer une classe jamais rencontrée lors de l'entraînement, j'ai du modifier le produite des probabilités conditionnelles indépendantes pour enlever les probabilités qui ne sont pas évaluées durant l'entraînement. J'aurais pu modifier le tableau de probabilités, mais le plus simple a été de leur donner une valeur de 1, ce qui est équivalent à les ignorer dans le produit."
   ]
  },
  {
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}