NSI1_25b_knn_Conclusion.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"width:100%;border-collapse:separate;border:solid 2px;border-radius:14px;\">\n",
    "    <div style=\"display:flex;\">\n",
    "        <div style=\"display:inline;width:5%;\"></div>\n",
    "        <div style=\"display:inline;width:15%;\">NSI1</div>\n",
    "        <div style=\"display:inline;width:15%;\">25b</div>\n",
    "        <div style=\"display:inline;width:70%;text-align:right;\"><b>Algorithmique</b></div>\n",
    "        <div style=\"display:inline;width:5%;\"></div>\n",
    "    </div>\n",
    "    <div  style=\"display: flex;background-color:#EEE\">\n",
    "        <p style=\"width:100%;text-align:center;\">Algorithme des k plus proches voisins</p>\n",
    "    </div>\n",
    "    <div  style=\"display: flex;\">\n",
    "        <p style=\"width:100%;text-align:center;\">Développement, exemples d'application et conclusion</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = \"alert alert-success\">\n",
    "    \n",
    "**Objectifs de la séquence:**  \n",
    "Initiation à un algorithme d'apprentissage: Une approche de l'intelligence artificelle.    \n",
    "Prédire la classe d’un élément.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = \"alert alert-info\">\n",
    "    \n",
    "**Sommaire :**\n",
    "\n",
    "- <a href=#Resume>Résumé de l'épisode précédent</a> \n",
    "- <a href=#Distance_euclidienne>Calcul de distance euclidienne</a> \n",
    "- <a href=#Ordre_et_choix>Mettre de l'ordre et faire un choix</a> \n",
    "- <a href=#Frontieres_decision>Frontières de décision</a> \n",
    "- <a href=#Exemple_applications>Exemples d'applications</a>  \n",
    "- <a href=#Conclusion>Conclusion</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "![Starting block](https://github.com/ebuonocore/NSI1_25_knn/blob/master/images/NSI1_25b_1nn_Vornoi.jpg?raw=true)\n",
    "<span style=\"font-family:Comic Sans MS; color:gray; font-size: x-small;float:right \">Source: \n",
    "<a href =\"https://kevinzakka.github.io/2016/07/13/k-nearest-neighbor/\">kevinzakka.github.io</a></span> \n",
    "\n",
    "<div id=\"Resume\"></div>\n",
    "\n",
    "# Résumé de l'épisode précédent\n",
    "\n",
    "<div class = \"alert alert-success\">\n",
    "\n",
    "Afin d'estimer la classe d'un **candidat** , nous avons vu qu'il faut:\n",
    "- calculer les distances entre le candidat et les autres objets\n",
    "- conserver la liste des k objets les plus proches\n",
    "- parmi ces k objets, recenser la classe la plus présente</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Distance_euclidienne\"></div>\n",
    "\n",
    "# Calcul de distance euclidienne\n",
    "\n",
    "La fonction `distance()` prend 2 couples de flottants en paramètres:  \n",
    "A = ( xa, ya) et B = (xb   , yb)  \n",
    "Elle renvoie la disance euclidienne entre ces deux points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "def distance (A,B):\n",
    "    \"\"\" tuple * tuple -> float\n",
    "    Préconditions: A et B sont des couples de flottants représentants les coordonnées des points\n",
    "    Renvoie la distance entre A et B\n",
    "    \"\"\"\n",
    "    xa = A [0] # xa et ya prennent les valeurs de l'abscisse et de l'ordonnée de A\n",
    "    ya = A [1] \n",
    "    xb = B [0] # xb et yb prennent les valeurs de l'abscisse et de l'ordonnée de B\n",
    "    yb = B [1]\n",
    "    return sqrt((xb-xa)**2+(yb-ya)**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q1:** Utilisez cette fonction pour calculer la distance entre les points de coordonées (-1,0) et (0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "distance( ... )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On note `E` la liste des individus de la population existante (C'est à dire, les coquelicots et les bleuets déjà éclos)  \n",
    "Chaque élément de la liste est un p-uplet: Les deux premiers paramètres représentent les coordonnées dans le repère et le troisième la classe de l'objet:  \n",
    "`'C'` correspond à un coquelicot  \n",
    "`'B'` à un bleuet\n",
    "\n",
    "Exemple: un_element_de_la_population = ( abscisse, ordonnée, classe )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "E = [] # Initialisation de la liste des individus\n",
    "E.append( (2.200, 1.200 , 'B') ) # Ajout des différents individus\n",
    "E.append( (1.370, 0.721 , 'C') ) # Chaque individu est représenté par un 3-uplet(float, float, int) \n",
    "E.append( (1.555, 0.649 , 'C') )\n",
    "E.append( (2.160, 0.567 , 'B') )\n",
    "E.append( (2.506, 0.587 , 'C') )\n",
    "E.append( (2.432, 3.134 , 'B') )\n",
    "E.append( (1.500, 2.175 , 'C') )\n",
    "E.append( (3.493, 1.432 , 'B') )\n",
    "E.append( (3.913, 1.000 , 'B') )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q2:** Quelle est l'instruction qui permet de récupérer le deuxième **élément** de la liste: `(1.370, 0.721 , 'C')`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q3:** Quelle est l'instruction qui permet de récupérer la **classe** du deuxième élément de la liste: `'C'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q4:** Dans la fonction suivante, complétez le code de couleur manquant "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\"\"\" Le programme suivant dessine les points de l'ensemble E et le candidat dans le plan\n",
    "    L'instruction plt.scatter() qui dessine ce graphique, prend en paramètres les listes\n",
    "    abscisses, ordonnées et couleurs construites à partir des paramètres des points à représenter \n",
    "\"\"\"\n",
    "fleur_mystere = (1.9,1.6)\n",
    "abscisses = [fleur_mystere[0]]  # Initialisation des listes 'abscisses', 'ordonnées' et 'couleurs',\n",
    "ordonnées = [fleur_mystere[1]] # avec les paramètres de la fleur mystère (le candidat)\n",
    "couleurs = ['#ffff00'] # Couleur Jaune = Rouge + Vert (pas de Bleu)\n",
    "for individu in E: # Pour chaque élément de l'ensemble E (les coquelicots et le bleuets éclos)\n",
    "    abscisses.append(individu[0]) # On ajoute les paramètres aux listes 'abscisses', 'ordonnées' et 'couleurs'\n",
    "    ordonnées.append(individu[1])\n",
    "    if individu[2] == 'C': \n",
    "        couleurs.append( '#ff0000') # Couleur Rouge\n",
    "    elif individu[2] == 'B':\n",
    "        couleurs.append( '#0000ff') # Couleur Bleue\n",
    "    elif individu[2] == 'V':\n",
    "        couleurs.append( '...') # Couleur Verte\n",
    "    else:\n",
    "        couleurs.append( '#444444') # Sinon, couleur Grise\n",
    "# On affiche chaque point mémorisé avec ses coordonnées et la couleur propre à sa classe.        \n",
    "plt.scatter(abscisses, ordonnées, c = couleurs,edgecolor = '#000000', alpha = 1, s = 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le schéma ci-dessous donne une représentation de la succession des traitements des données que nous allons réaliser:\n",
    "- `liste_distances()` prend en paramètres l'ensemble des objets connus et la position du candidat. Elle génère la liste des couples (distance par rapport au candidat, classe)\n",
    "- `k_plus_proches()` prend en paramètres la liste des couples et l'entier k. Elle  renvoie les k plus proches éléments.\n",
    "- `classe_predite()` désigne la classe majoritairement représentée dans la liste prise en paramètre."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Liste des fonctions](https://github.com/ebuonocore/NSI1_25_knn/blob/master/images/fonctions_knn2.png?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Ordre_et_choix\"></div>\n",
    "\n",
    "# Mettre de l'ordre et faire un choix\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Connaissant une **population** d'individus (liste E) et la position du **candidat**, nous souhaitons construire la fonction qui renvoie une **liste de couples** où chaque élément de E est représenté par sa distance par rapport au candidat et sa classe.  \n",
    "**Q5:** Complétez la fonction `liste_distances()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def liste_distances(population, candidat):\n",
    "    \"\"\" list * int * 2-uplet -> list\n",
    "        renvoie la liste des couples (distance, classe) pour chaque individu\n",
    "        population est une liste d'individus. Liste de 3-uplets (float, float, classe)\n",
    "        candidat est un 2-uplet de flottants (coordonnées du candidat)\n",
    "    \"\"\"\n",
    "    liste_retour = [] # Initialisation de la liste à construire\n",
    "    xa = candidat[0] # Coordonnées du candidat (xa,ya)\n",
    "    ya = candidat[1]\n",
    "    for individu in population: # Pour chaque individu de l'ensemble E\n",
    "        xi = individu[0] # Abscisse de l'individu\n",
    "        yi = ... # Ordonnée de l'individu\n",
    "        classe = individu[2] # Classe de l'individu\n",
    "        eloignement = distance ((xa,ya) , (xi,yi)) # Calcul de la distance en utilisant la fonction précédente\n",
    "        liste_retour.append( (eloignement, classe) ) # Ajout du couple (distance, classe) dans la liste\n",
    "    return liste_retour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fleur_mystere = (1.9,1.6)\n",
    "liste_distances(E, fleur_mystere)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant, nous disposons, pour chaque élément de sa distance par rapport au candidat et de sa classe.  \n",
    "Nous allons trier cette liste dans l'ordre des distances croissantes et ne conserver que les k plus proches éléments.  \n",
    "**Q6:** Complétez la liste en compréhension de la fonction suivante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def k_plus_proches(couples_distances_classes, k):\n",
    "    \"\"\" Classe les couples de la liste liste_distances dans l'ordre des distances croissantes\n",
    "        Renvoie la liste des k couples les plus petites\n",
    "        couples_distances_classes est une liste de couples: (distance, classe) \n",
    "        k est un entier\n",
    "    \"\"\"\n",
    "    liste_triee = sorted(couples_distances_classes) # Par défaut les couples sont triés selon le premier paramètre (la distance)\n",
    "    liste_retour = [liste_triee[i] for i in range(...)] # liste_retour ne conserve que les k premiers éléments\n",
    "    return liste_retour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fleur_mystere = (1.9,1.6) # Définition du candidat\n",
    "couples_distances_classes = liste_distances(E, fleur_mystere) # Construction des couples (distance,classe)\n",
    "k_plus_proches(couples_distances_classes, 8) # Liste des k plus proches voisins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q7:** Exécutez à nouveau la cellule ci-dessus en paramétrant l'appel de la fonction `k_plus_proches()` pour ne faire apparaitre que les 5 plus proches. Cela vous permettra de vérifier aussi si votre fonction est bien programmée.\n",
    "\n",
    "Connaissant la liste des k plus proches voisins, il ne reste plus qu'à renvoyer la classe majoritaire.  \n",
    "Complétez la fonction suivante:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def  classe_predite(plus_proches):\n",
    "    dictionnaire_classe = {} # Initialisation du dictionnaire. Clef = Classe, Valeur = nombre d'occurences\n",
    "    maximum = 0 # Initialisation du maximum\n",
    "    for individu in plus_proches: # On parcourt les k plus proches couples (distance, classe)\n",
    "        classe_individu = individu[1] # On récupère la classe de cet individu\n",
    "        if classe_individu in dictionnaire_classe.keys(): # Si cette occurence exite déjà dans le dictionnaire\n",
    "            dictionnaire_classe[classe_individu] += 1  # Incrémente la valeur de cette clef\n",
    "        else :\n",
    "            dictionnaire_classe[classe_individu] = 1 # Sinon, créé cette nouvelle clef avec valeur=1\n",
    "        if dictionnaire_classe[classe_individu] > maximum: # Si on bat le record de représentation,\n",
    "            maximum = dictionnaire_classe[classe_individu] # on mémorise le score,\n",
    "            classe_majoritaire = classe_individu # et le nom de cette classe majoritaire jusque là\n",
    "    #print(\"La classe majoritaire\",classe_majoritaire,\"est représentée\",maximum,\"fois\")\n",
    "    return classe_majoritaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fleur_mystere = (1.9,1.6) # Définition du candidat\n",
    "couples_distances_classes = liste_distances(E, fleur_mystere) # Construction des couples (distance,classe)\n",
    "plus_proches = k_plus_proches(couples_distances_classes, 4) # Liste des k plus proches voisins\n",
    "classe_predite(plus_proches) # Désigne la classe majritaire parmi les k plus proches voisins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Au final, nous avons tous les outils en main:\n",
    "Soit `E`, la population d'individus connus,  \n",
    "- `distance (A,B)` permet de calculer la distance entre 2 points \n",
    "- `liste_distances(population, candidat)` renvoie une liste de couples (distance par rapport au candidat, classe de l'individu)\n",
    "- `k_plus_proches(couples_distances_classes, k)` trie cette liste et renvoie les k éléments plus proches\n",
    "- `classe_predite(plus_proches)` renvoie la classe majoritaire parmi la liste `plus_proches`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour synthétiser tout cela, on définie la fonction `k_nn` qui prend en paramètre la population `E`, la position du `candidat`, l'entier `k` et renvoie une prédiction pour la classe du **candidat**.  \n",
    "**Q8:** Complétez les paramètres des fonctions. (Les définitions de fonctions plus haut peuvent aider à répondre)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def k_nn(population, candidat, k):\n",
    "    \"\"\" Renvoie une prédiction de la calsse de l'individu candidat\n",
    "        population est une liste d'individus. Liste de 3-uplets (float, float, classe)\n",
    "        candidat est un couple de flottants (abscisse, ordonnée)\n",
    "        k est un entier\n",
    "    \"\"\"\n",
    "    couples_distances_classes = liste_distances(...)\n",
    "    plus_proches = k_plus_proches(...)\n",
    "    prediction = classe_predite(...)\n",
    "    return prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exécutez les lignes suivantes pour différentes valeurs de `k`: de 1 à 9 \n",
    "Que remarquez-vous?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fleur_mystere = (1.9,1.6)\n",
    "k_nn (E,fleur_mystere, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q9:** Ecrivez vos observations dans cette cellule :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pourquoi dans cet exemple, le choix de 2 ou 6 comme valeur de `k` n'est pas judicieux? Le résultat est-il valable?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q10:** Ecrivez votre commentaire dans cette cellule :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Frontieres_decision\"></div>\n",
    "\n",
    "# Frontières de décision"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour une valeur de `k` donnée, on peut interroger l'algorithme pour chaque point du plan.  \n",
    "Si l'on représente graphiquement ces réponses, on voit se dessiner des zones distinctes d'appaition prévue de bleuets ou de coquelicots et des frontières entre ces zones.  \n",
    "Ci-dessous, pour 4 différentes valeurs de `k`, on voit comment évolue le tracé de ces **frontières de décision**. On rertouve aussi la position de notre fleur candidate (en jaune) qui est au centre du disque qui contient les k plus proches voisins.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Frontieres_de_decision_Npetit](https://github.com/ebuonocore/NSI1_25_knn/blob/master/images/frontieres_decision_3.jpg?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avec `k=1` chaque zone inclue les individus de sa classe: Tous les individus bleus sont dans des zones bleues. Et tous les individus rouges sont dans les zones rouges.  \n",
    "Lorsque `k` grandit, Les contours des zones de décision ont tendance à s'adoucir. Des individus d'une couleur peuvent se retrouver dans une zone d'une autre couleur. Ils sont comme des exceptions de la règle générale qui se dégage de l'algorithme.  \n",
    "Mais notre ensemble de départ n'est peut être pas assez complet. Généralement, il va falloir l'alimenter par une sélection d'individus plus large. Dans ce cas, nous serions sans doute dans une situation de **sous-apprentissage**.\n",
    "\n",
    "Voilà à quoi cela ressemble avec davantage \"d'expériences\" pour alimenter l'algorithme."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Frontieres_de_decision_N_grand](https://github.com/ebuonocore/NSI1_25_knn/blob/master/images/frontieres_decision_4.jpg?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A l'inverse, il existe un autre écueil: Le **sur-apprentissage** (overfitting en anglais): Avec un trop grand nombre d'expériences, votre algorithme ne fera que \"coller\" au **jeu d'entraînement** sans permettre de dégager une tendance générale pertinente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Exemple_applications\"></div>\n",
    "\n",
    "# Exemples d'applications\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'algorithme des **k plus proches voisins** ne sert a priori pas à deviner la nature des fleurs qui poussent.  \n",
    "Il est très utilisé dans des domaines divers comme:\n",
    "- La génétique (prédiction de la fonction   de gènes)\n",
    "- l'agriculture (mais pas que des fleurs)\n",
    "- les transports (prédiction de trafic)\n",
    "- la sécurité\n",
    "\n",
    "Imaginons un jeu de stratégie:  \n",
    "A un moment donné, l'ordinateur qui joue un des opposant doit faire le choix d'adopter un comportement **agressif**, **défensif** ou de **développement** en créant des bâtiments par exemple.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "![Orcs_vs_humans](https://github.com/ebuonocore/NSI1_25_knn/blob/master/images/Orcs_vs_humans2.jpg?raw=true)\n",
    "<span style=\"font-family:Comic Sans MS; color:gray; font-size: x-small;float:right \">Source: D'après \n",
    "<a href =\"https://www.freepng.fr/\">freepng.fr</a> et <a href =\"https://pixabay.com/\">pixabay.com/</a></span> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour faire son choix, il dispose de deux informations:  \n",
    "- un paramètre reflétant le potentiel offensif de ces unités : noté **'Attaque'**\n",
    "- un paramètre reflétant le potentiel défensif de ces bâtiments: noté **'Défense'**  \n",
    "\n",
    "On fait tourner le jeu sur un grand nombre de parties, et on note quel choix a été fait arbitrairement au bout de 10 minutes de jeu.  \n",
    "On représente sur un graphique les parties qui ont abouties à une **victoire**.  \n",
    "- En abscisse, la valeur d'**Attaque**.  \n",
    "- En ordonnée, la valeur de **Défense**.  \n",
    "- La classe du point correspond au choix qui a conduit à la victoire."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voila à quoi ressemble l'analyse de ces parties avec l'algorithme des **k plus proches voisins** pour un `k=7`\n",
    "![Orcs_vs_humans_knn](https://github.com/ebuonocore/NSI1_25_knn/blob/master/images/Orcs_vs_humans_knn.jpg?raw=true)\n",
    "**Q11:** D'après ce graphique, quels choix devra faire l'ordinateur s'il se trouve dans les situations suivantes:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Partie A: Attaque = 50, Défense = 25\n",
    "-> Choix stratégique:\n",
    "\n",
    "Partie B: Attaque = 150, Défense =150\n",
    "-> Choix stratégique:\n",
    "\n",
    "Partie C: Attaque = 75, Défense =100\n",
    "-> Choix stratégique:\n",
    "\n",
    "Partie D: Attaque = 100, Défense =100 (Point jaune)\n",
    "-> Choix stratégique:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Conclusion\"></div>\n",
    "\n",
    "# Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous avons vu comment réaliser l'algorithme des **k plus proches voisins**, mais la grosse difficulté résidera souvent dans le réglage de la taille du jeux d'entraînement et de la valeur de `k` afin d'obtenir des prédictions et un taux d'erreurs satisfaisant."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "N'oublions pas que ces prédictions sont statistiques: certaines seront fausses.  \n",
    "Par définition, un phénomène soumis à l'aléa ne peut pas être complétement prévisible.  \n",
    "Vous en avez fait l'expérience pendant le sondage.\n",
    "\n",
    "Et si le choix repose sur plus de deux paramètres, il est tout à fait possible d'utiliser cet algorithme mais les représentations graphiques sont moins lisibles: 3 critères débouchent sur 3 axes et une représentation 3D."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Fruits en 3D](https://github.com/ebuonocore/NSI1_25_knn/blob/master/images/knn_fruits.jpg?raw=true)\n",
    "<span style=\"font-family:Comic Sans MS; color:gray; font-size: x-small;float:right \">Source: D'après \n",
    "<a href =\"http://www.pianshen.com/article/2839170053/\">pianshen.com</a></span> \n",
    "\n",
    "Ci dessus un modèle permettant de reconnaître des fruits en fonction des critères:\n",
    "- largeur\n",
    "- hauteur\n",
    "- indice de couleur"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<p style=\"font-family:Comic Sans MS; text-align: center; color:gray; font-size: x-small; \">- Eric Buonocore. Mai 2020 -</p>\n",
    "\n",
    "![Licence CC BY NC SA](https://licensebuttons.net/l/by-nc-sa/3.0/88x31.png)"
   ]
  }
 ],
 "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": 1
}