*Unedescription de votre implémentation de l’algorithme k-NN :classe implémentant l’algorithme, méthode(s) de cette classe implémentant le calcul de la distance, traitement de la normalisation, méthode(s) de cette classe implémentant la classification, méthode(s) évaluant la robustesse. N’hésitez
pas à mettre en avant l’efficacité de ces méthodes (approprié pour un grand volume de données, normalisation
efficace des distances).*
Nous avons implémenté l'algorithme K-NN dans une classe MethodKNN. Nous avons choisis d'utiliser des methodes statiques pour faciliter l'utilisation de cette algorithme.
Cette classe contient 5 methodes permettant d'implementer l'algorithme K-NN et ses differentes fonctionnalités.
Cette premiere methode permet de mettre a jour les données de l'algorithme. Ainsi il faut passer en parametre les données sur lesquelles ont souhaite travailler.
Cette methode va calculer les valeurs max et min ainsi que l'amplitude de chaque attribue des données passé en parametre.
Cette methode necessite 2 parcours, 1 sur les données, puis un sur les min et les max de chaque attribue pour calculer l'amplitude. Il est donc conseillé de n'utiliser cette methode qu'une fois par jeu de données (toute facon le resultat serait le meme)
C'est pour cela que cette methode n'est pas directement appelé dans les methodes ci-dessous mais qu'elle doit explicitement être appelé aupparavant.
> public static List<LoadableData> kVoisins(List<LoadableData> datas, LoadableData data, int k, Distance distance)
Cette methode a pour objectif de recupéré les k voisins les plus proches d'un donnée parmis un jeu de données et selon une distance.
Elle prends donc en parametre le jeu de données, la données pour laquelle on souhaite obtenir les voisins, le nombre de voisins souhaités ainsi que la distance avec laquelle les calculs doivent etres effectués.
Cette methode n'effectue qu'un seul parcours de boucle et calcul pour chacune des données sa distance avec la donnée passée en parametre. Les calculs de distance sont definis dans l'objet implémentant l'interface Distance passé en parametre.
Si il s'agit d'une distance normalisée la normalisation s'effectue au moment de la recherche des voisins.
Cette methode a pour objectif d'évaluer la robustesse de l'algorithme sur un jeu de donné avec un K donné et une distance donnée. Elle prends en parametre le jeu de données sur lequel effectué l'evalutation,
le k a tester, la distance a utiliser ainsi que un pourcentage correspondant a la partie des données qui sera utilisé afin de tester les données. Ex avec testPart=0.2, 80% des données serviront de données de reférence et 20% seront utilisé pour tester la
validité de l'algorithme. Cette effectue une validation croisée (Voir #Validation Croisée)
> public static int bestK(List<LoadableData> datas, Distance distance)
Cette methode a pour objectif de rechercher le meilleur K possible pour un jeu de données et une distance données.
Elle va tester la totalité des K impair compris entre 1 et racine caré du nombre de données. Cette valeur max permet d'eviter que le K choisit soit trop grand et
fausse les résultats. Elle test donc la robustesse de chaque K et renvoie le K ayant la meilleure robustesse. Cette methode parcours le jeu de donnée Kmax*(1/testPart) fois, ou testPart correspond au pourcentage des données utilisé comme valeurs de test.
---
## Validation croisée
#### Rappel de la methode de validation croisée
La validation croisée est une méthode d'évaluation utilisée pour mesurer la performance d'un modèle en le testant sur des données qu'il n'a pas utilisées pour l'entraînement. Dans ce cas précis :
Les données sont divisées en plusieurs parties égales (appelées folds ou partitions).
À chaque itération, une des partitions est utilisée comme jeu de test, tandis que les autres servent pour l'entraînement.
Les résultats des tests sont cumulés pour calculer un score global.
Cette méthode permet de minimiser le biais d'évaluation en utilisant toutes les données tour à tour pour l'entraînement et le test.
#### Implémentation de la validation croisée
La méthode effectue une validation croisée en divisant les données en plusieurs partitions. À chaque itération :
Une partie des données sert de jeu de test.
Le reste des données sert de jeu d'entraînement.
Voici les étapes principales :
- Calcul du nombre d'itérations :
Le nombre d'itérations est déterminé par
1/testPart. Par exemple, si testPart = 0.1, la méthode effectue 10 itérations, si testPart = 0.2, la méthode effectue 5 iterations, etc.
- Division des données :
Pour chaque itération i, une sous-liste correspondant au pourcentage testPart (par exemple, 10 % des données) est extraite et utilisée comme jeu de test (testData).
Le reste des données sert de jeu d'entraînement (trainingData).
- Estimation des classes :
Chaque élément du jeu de test est classé à l’aide de la fonction MethodKNN.estimateClass(trainingData, l, k, distance) où trainingData correspond au reste des données.
Si la classe prédite correspond à la classe réelle (retournée par l.getClassification()), un compteur (totalFind) est incrémenté.
- Calcul du taux de réussite :
Après chaque itération, le taux de réussite est calculé totalFind/totalTry et ajouté à la variable taux.
- Renvoie du taux total moyen de reussite: Enfin, on divise la variable taux par le nombre d'itération afin d'obtenir un taux de reussite moyen.
---
## Choix du meilleur K
Pour obtenir le meilleur K, on appel la methode bestK(List<LoadableData> datas, Distance distance) decrite plus haut. On obtient un K optimal, puis on appel la methode robustesse(...) avec le k trouvé plutot comme parametre.
En appliquant cette methode voici les resultats que nous avons obtenue avec:
##### Iris
| Distance \ K | 1 | 3 | 5 | 7 | 9 | 11 | K choisit |
On obtient donc un taux de reussiste plutôt élevé. A chaque fois l'algorithme choisit le K avec le plus haut taux de reussite. En cas d'égalité, il choisit le plus petit K parmis les égalités.
Comme expliqué pour chaque methode dans la partie Implementation de l'algorithme, nous avons chercher a minimiser le nombre de parcours du fichier de données et plus generalement le nombre de boucle.
L'algorithme necessite une List qui sera donnée en parametre, il est donc libre a la personne qui l'utilise de fournir l'implementation de List qu'il souhaite. De plus, pour le calcul des parametres du jeu de données (
amplitude,valeur minimale, valeur maximal) nous avons utiliser un tableau de double afin de limiter les performances