$course$/QCM de NSI/Première/k plus proches voisins (k-NN) Algorithme des k plus proches voisins (k-NN) : exemple
d'algorithme d'apprentissage supervisé. Distance entre
points, vote majoritaire, choix de k, applications,
forces et limites.

]]> k plus proches voisins (k-NN) — Q01 : k-NN : qu'est-ce que c'est ? Que fait l'algorithme des k plus proches voisins
(k-NN, k-Nearest Neighbors) ?

]]> Apprentissage supervisé : on dispose d'exemples
étiquetés (avec leur classe connue), on
apprend à prédire la classe pour de nouveaux
exemples.

]]> 1.0 0.0 0 true true abc Prédire la classe d'un point selon ses voisins

]]> Bonne réponse : c'est un algorithme
d'apprentissage supervisé par
mémorisation. On classe un nouveau point
selon ses voisins.

]]> Cherche un élément dans une liste triée

]]> Erreur : c'est la recherche dichotomique.

]]> Trie une liste par ordre croissant

]]> Erreur : aucun rapport avec le tri.

]]> Mesure la complexité d'un programme

]]> Erreur : la mesure de
complexité algorithmique
n'a aucun rapport avec
l'algorithme des k plus
proches voisins.

]]> k plus proches voisins (k-NN) — Q02 : Des mesures lues dans un fichier CSV Pour préparer un k-NN, on lit le fichier fruits.csv avec
csv.reader. Sa première ligne contient 102,7,pomme et devient
la liste ligne. Quel est le type de ligne[0] ?

]]> Une table importée depuis un fichier CSV ne contient que du texte.
Avant d'appliquer k-NN, on convertit les colonnes numériques avec
float pour pouvoir calculer les distances.

]]> 1.0 0.0 0 true true abc Un entier, car la valeur 102 n'a pas de partie décimale

]]> Erreur : csv.reader ne convertit aucune valeur, quelle que soit
son écriture. ligne[0] est la chaîne '102', qu'il faut
convertir avec int ou float avant de calculer.

]]> Un p-uplet de trois caractères, un par chiffre de 102

]]> Erreur : la ligne est découpée aux virgules, pas chiffre par
chiffre. ligne[0] est la chaîne entière '102'.

]]> Un flottant, car le module csv convertit les nombres qu'il lit

]]> Erreur : le module csv ne devine pas le type des valeurs, il
renvoie toujours des chaînes. ligne[0] vaut '102', pas
102.0.

]]> Une chaîne, à convertir avant de calculer une distance

]]> Bonne réponse : csv.reader découpe chaque ligne en chaînes de
caractères, sans rien convertir : ligne[0] vaut '102'. Pour
calculer une distance, il faut écrire float(ligne[0]) ; sinon la
soustraction avec un nombre provoque TypeError.

]]> k plus proches voisins (k-NN) — Q03 : Distance euclidienne Comment calcule-t-on la distance euclidienne
entre deux points A=(x_A, y_A) et B=(x_B, y_B) du plan ?

]]> Cette formule se généralise en dimension n :
d = \\sqrt{\\sum_{i=1}^{n}(b_i - a_i)^2}.
Pour comparer des distances, on peut omettre
la racine carrée.

]]> 1.0 0.0 0 true true abc d = √(x_B - x_A) + (y_B - y_A)

]]> Erreur : sans les carrés, les écarts
négatifs se compensent et l'expression
sous la racine peut être négative.

]]> d = (x_B - x_A)² + (y_B - y_A)²

]]> Erreur : c'est le carré de la distance,
il manque la racine carrée. Comparer des
carrés de distances reste possible pour
k-NN, mais ce n'est pas la distance.

]]> d = |x_B - x_A| + |y_B - y_A|

]]> Erreur : c'est la distance de Manhattan
(somme des écarts absolus), une autre
distance possible, mais pas l'euclidienne.

]]> d = √(x_B - x_A)² + (y_B - y_A)²

]]> Bonne réponse : formule de Pythagore.
C'est la distance « à vol d'oiseau »
entre les deux points.

]]> k plus proches voisins (k-NN) — Q04 : Vote majoritaire Une fois les k plus proches voisins
identifiés, comment k-NN détermine-t-il la
classe à attribuer ?

]]> Variante : vote pondéré par la distance
(les voisins plus proches comptent plus).
Permet de gérer les ex æquo.

]]> 1.0 0.0 0 true true abc Par vote majoritaire parmi les k voisins

]]> Bonne réponse : si parmi les 5 voisins
les plus proches, 3 sont de la classe A et
2 de la classe B, on prédit A.

]]> En choisissant la classe du voisin le plus proche

]]> C'est k-NN avec k = 1, cas particulier. En
général on utilise plusieurs voisins pour
plus de robustesse.

]]> En faisant la moyenne des classes

]]> Erreur : on ne fait pas la moyenne d'une
classe (c'est une catégorie, pas un
nombre).

]]> Au hasard

]]> Erreur : k-NN est déterministe.

]]> k plus proches voisins (k-NN) — Q05 : Choix de k Pourquoi prend-on souvent k impair quand
on classe en deux classes ?

]]> Pour trois classes ou plus, un
k impair n'évite pas
forcément les ex æquo : trois
classes peuvent par exemple
obtenir chacune k/3 voix.
On peut alors recourir à la
classe du voisin le plus
proche, ou à un vote pondéré
par la distance.

]]> 1.0 0.0 0 true true abc Parce que les nombres impairs sont plus rapides à calculer

]]> Aucun lien n'existe entre la
parité d'un nombre et la
rapidité de calcul.

]]> Parce que k pair ne fonctionne pas

]]> Erreur : ça fonctionne, mais on doit gérer
les ex æquo.

]]> Pour éviter les égalités lors du vote

]]> Bonne réponse : avec k pair (par exemple
k = 4), on peut avoir 2 votes pour chaque
classe → indécision. Avec k impair (k = 5),
impossible.

]]> Aucune raison particulière

]]> Cette parité répond au
contraire à un besoin
technique précis : éviter
les égalités lors du
vote, comme expliqué dans
la bonne réponse.

]]> k plus proches voisins (k-NN) — Q06 : Exemple typique Lequel de ces problèmes est un bon candidat
pour l'algorithme k-NN ?

]]> Autres exemples : reconnaissance de
chiffres manuscrits, classification de
fleurs (jeu de données Iris), recommandation
de films.

]]> 1.0 0.0 0 true true abc Calculer la racine carrée exacte d'un nombre

]]> Erreur : pas un problème d'apprentissage.

]]> Trier une liste de nombres

]]> Erreur : ce n'est pas un problème de
classification.

]]> Compresser un fichier pour gagner de la place

]]> La compression de fichiers
est une tâche très
différente, sans rapport
avec la classification.

]]> Reconnaître un spam à partir d'exemples

]]> Bonne réponse : tâche de classification
binaire (spam / non spam). On peut
comparer le mail aux exemples connus
selon des caractéristiques (mots-clés,
longueur, etc.).

]]> k plus proches voisins (k-NN) — Q07 : Pas d'entraînement explicite Quelle particularité de k-NN le distingue
d'autres algorithmes d'apprentissage ?

]]> Conséquence : prédiction lente quand le jeu
d'entraînement est gros (il faut calculer la
distance à tous les exemples). Compromis :
stockage important, calcul à la prédiction.

]]> 1.0 0.0 0 true true abc Il invente de nouveaux exemples au cours de la prédiction

]]> Aucun exemple n'est
inventé. L'algorithme se
contente de comparer le
point à classer aux
exemples déjà connus.

]]> Il fonctionne sans aucune donnée d'entraînement

]]> Au contraire, l'algorithme
a besoin d'exemples
étiquetés pour pouvoir
comparer le nouveau
point.

]]> Presque aucun entraînement, calcul à la prédiction

]]> Bonne réponse : k-NN est un algorithme
dit « paresseux ». Pas de modèle interne ;
tout le travail est fait à la prédiction.

]]> Il a une phase d'entraînement très longue

]]> Erreur : c'est l'inverse. La phase
d'entraînement consiste juste à
mémoriser les exemples.

]]> k plus proches voisins (k-NN) — Q08 : Squelette de l'algorithme Quelle est la structure générale de
l'algorithme k-NN pour classer un nouveau
point p ?

]]> En Python, les trois premières étapes s'écrivent
par exemple :
``python
def cle(couple):
return couple[0]

distances = [(dist(p, e), c) for (e, c) in exemples]
distances = sorted(distances, key=cle)
voisins = [distances[i] for i in range(k)]
``

]]> 1.0 0.0 0 true true abc 1. Calculer la distance de p à chaque exemple connu.
2. Trier les exemples par distance croissante.
3. Garder les k premiers.
4. Retourner la classe majoritaire parmi ces k voisins.

]]> Bonne réponse : algorithme en quatre
étapes claires. Les étapes 1 et 2
dominent le coût.

]]> 1. Calculer la distance de p à chaque exemple connu.
2. Trier les exemples par distance croissante.
3. Garder les k premiers.
4. Retourner la classe du plus proche d'entre eux.

]]> Erreur : retourner la classe du seul plus
proche voisin revient à prendre k = 1 ; le
vote majoritaire parmi les k voisins est
justement ce qui rend k-NN robuste au
bruit.

]]> 1. Calculer la moyenne des exemples de chaque classe.
2. Calculer la distance de p à chacune de ces moyennes.
3. Garder la moyenne la plus proche.
4. Retourner sa classe.

]]> Erreur : c'est un autre algorithme (le
plus proche centre). k-NN ne calcule
aucune moyenne : il compare p aux
exemples eux-mêmes.

]]> 1. Calculer la distance de p à chaque exemple connu.
2. Trier les exemples par distance décroissante.
3. Garder les k premiers.
4. Retourner la classe majoritaire parmi ces k voisins.

]]> Erreur : trié par distance décroissante,
les k premiers sont les k exemples les
plus éloignés de p, l'inverse de ce
que l'on veut.

]]> k plus proches voisins (k-NN) — Q09 : Paramètre k Que se passe-t-il si l'on prend k = 1 ?

]]> Choix de k : compromis. k trop petit →
sensibilité au bruit. k trop grand → frontières
lissées, perte de précision locale. On choisit
souvent k empiriquement.

]]> 1.0 0.0 0 true true abc La classe du seul voisin, très sensible au bruit

]]> Bonne réponse : un seul exemple aberrant
peut fausser la prédiction. Augmenter k
rend la décision plus robuste.

]]> L'algorithme ne fonctionne pas avec k = 1

]]> Le choix k = 1 est tout
à fait valide d'un point
de vue algorithmique. Il
est simplement peu
robuste face au bruit
des données.

]]> La prédiction est plus stable

]]> Erreur : c'est l'inverse. k = 1 est très
sensible au bruit.

]]> La complexité du calcul devient alors logarithmique

]]> Le coût d'un calcul de
prédiction ne dépend pas
du choix de k : il
reste linéaire en
N (nombre d'exemples).

]]> k plus proches voisins (k-NN) — Q10 : Trace simple Avec k = 3, on classe un nouveau point P. Ses
3 plus proches voisins ont les classes : A, B,
A. Quelle classe prédit k-NN pour P ?

]]> Le vote se programme simplement : un dictionnaire compte les
occurrences de chaque classe parmi les voisins, puis on retient
la classe qui a le plus grand compte.

]]> 1.0 0.0 0 true true abc B (le plus proche)

]]> Erreur : ce serait k = 1. Avec k = 3, on
fait un vote majoritaire.

]]> Les deux à la fois

]]> Erreur : k-NN renvoie une seule classe.

]]> A (deux votes contre un pour B)

]]> Bonne réponse : vote majoritaire. A
obtient 2 votes, B obtient 1. La classe
prédite est A.

]]> Aucune des deux (égalité)

]]> Erreur : il n'y a pas d'égalité (2 vs 1).

]]> k plus proches voisins (k-NN) — Q11 : Code distance Quel code calcule correctement la distance euclidienne entre deux points 2D représentés
comme tuples a = (xa, ya) et b = (xb, yb) ?

]]> Astuce : pour comparer des distances, on
peut omettre la racine carrée (la fonction
racine est croissante). Plus rapide.

]]> 1.0 0.0 0 true true abc ((a[0] - b[0]) 2 + (a[1] - b[1]) 2) ** 1/2

]]> Erreur de priorité : est prioritaire
sur /, donc l'expression vaut
(...) 1 / 2, la moitié du carré de la
distance. Il faut 0.5 ou (1/2).

]]> abs(a[0] - b[0]) + abs(a[1] - b[1])

]]> Erreur : c'est la distance de Manhattan
(|Δx| + |Δy|), pas l'euclidienne.

]]> a[0] b[0] + a[1] b[1]

]]> Erreur : c'est le produit scalaire.

]]> ((a[0] - b[0]) 2 + (a[1] - b[1]) 2) ** 0.5

]]> Bonne réponse : Pythagore en Python.
** 0.5 calcule la racine carrée. Variante :
math.sqrt(...).

]]> k plus proches voisins (k-NN) — Q12 : Sélection des voisins Pour trouver les k plus proches voisins d'un
point P parmi N exemples, quelle approche est
la plus simple ?

]]> Des méthodes plus rapides existent pour de très grands jeux de
données, mais l'approche directe suffit pour comprendre
l'algorithme.

]]> 1.0 0.0 0 true true abc Calculer la moyenne des exemples

]]> Erreur : ce n'est pas le rôle.

]]> Aucune solution simple n'existe vraiment pour ce problème

]]> Plusieurs solutions
existent au contraire ;
la plus simple est
précisément celle qu'on
vient de décrire.

]]> Calculer les distances, trier, garder les k premiers

]]> Bonne réponse : simple à implémenter. On calcule les N distances,
on les trie par ordre croissant et on garde les k premières.

]]> Choisir k exemples au hasard

]]> Erreur : pas k-NN.

]]> k plus proches voisins (k-NN) — Q13 : Le plus proche en une seule passe Avec k = 1, il suffit de trouver le plus proche voisin. On propose
(la fonction dist(a, b) renvoie la distance entre deux points) :

`python def plus_proche(p, exemples): # exemples : liste non vide de couples (point, classe) d_min = 0 classe = exemples[0][1] for (x, c) in exemples: if dist(p, x) < d_min: d_min = dist(p, x) classe = c return classe`

Que renvoie cette fonction ?

]]> Pour chercher un minimum, on initialise avec une valeur réellement
atteinte, par exemple la distance au premier exemple, puis on
parcourt la liste en ne gardant que les valeurs strictement plus
petites. Ce parcours séquentiel a un coût linéaire.

]]> 1.0 0.0 0 true true abc La classe du premier exemple, quel que soit p

]]> Bonne réponse : une distance n'est jamais strictement inférieure
à 0, donc le test dist(p, x) < d_min est toujours faux. classe
garde sa valeur initiale, la classe du premier exemple. Il
fallait initialiser d_min avec la distance au premier exemple.

]]> La classe du plus proche voisin de p

]]> Erreur : c'est l'intention, mais d_min part de 0. Aucune
distance n'étant strictement inférieure à 0, la condition n'est
jamais vraie et la variable classe n'est jamais mise à jour.

]]> La classe de l'exemple le plus éloigné de p

]]> Erreur : le test < ne retient jamais un exemple plus éloigné.
En fait il ne retient aucun exemple, car aucune distance n'est
strictement inférieure à la valeur initiale 0.

]]> La classe du dernier exemple de la liste examinée

]]> Erreur : classe n'est modifiée que si la condition est vraie,
ce qui n'arrive jamais ici. Elle garde donc la classe du premier
exemple, pas celle du dernier.

]]> k plus proches voisins (k-NN) — Q14 : Compromis sur k Quel risque y a-t-il à choisir un k trop grand (par exemple k = nombre total
d'exemples) ?

]]> Un k petit rend la prédiction sensible au bruit, par exemple à un
exemple mal étiqueté ; un k grand lisse les résultats mais efface
les différences locales. On choisit k selon la taille du jeu de
données.

]]> 1.0 0.0 0 true true abc Aucun risque ; un grand k est toujours préférable

]]> Au contraire, un k trop
grand pose un problème
spécifique, comme expliqué
dans la bonne réponse.

]]> Le coût d'un calcul explose en n³

]]> Le coût d'un calcul de
prédiction reste linéaire
en N : il ne dépend pas
du choix de k.

]]> La prédiction tend vers la classe majoritaire globale

]]> Bonne réponse : si k = N, tous les
exemples votent. Le résultat est toujours
la classe la plus représentée dans tout
le jeu de données, indépendamment de la
position de P. Plus rien d'utile.

]]> L'algorithme cesse alors complètement de fonctionner

]]> L'algorithme continue de
fonctionner, mais le
résultat qu'il produit
n'est plus pertinent.

]]> k plus proches voisins (k-NN) — Q15 : Rôle des données d'entraînement Que sont les données d'entraînement
(training set) pour k-NN ?

]]> En pratique, on divise un jeu étiqueté en
train (entraînement) + test
(évaluation) pour mesurer la performance
sans tricher.

]]> 1.0 0.0 0 true true abc Les exemples étiquetés servant de comparaison

]]> Bonne réponse : plus le jeu
d'entraînement est riche et représentatif,
meilleures sont les prédictions.

]]> Une formule mathématique

]]> Les données d'entraînement
ne sont pas une formule,
mais un ensemble
d'exemples concrets,
chacun étiqueté avec sa
classe.

]]> Le code source de l'algorithme

]]> Le code source est une
notion distincte des
données d'entraînement,
qui sont les exemples
utilisés.

]]> Les nouvelles données que l'on cherche à classer

]]> Erreur : ce sont les données de test
(à classer).

]]> k plus proches voisins (k-NN) — Q16 : Code k-NN simple Quel code en Python implémente correctement
k-NN pour classer un point p ?
`

python

# exemples = [(point, classe), ...]

# k entier, dist(a, b) renvoie la distance

# majoritaire(liste) renvoie la classe la plus

# fréquente de la liste

def premier(paire):

    return paire[0]

]]> Implémentation simple et lisible. La fonction majoritaire se
programme avec un dictionnaire qui compte les occurrences de
chaque classe.

]]> 1.0 0.0 0 true true abc `

python

paires = [(dist(p, x), c) for (x, c) in exemples]

paires = sorted(paires, key=premier)

return paires[0][1]

]]> Erreur : on renvoie la classe du seul plus
proche voisin, comme si k valait toujours 1.
Le paramètre k est ignoré et le vote
majoritaire disparaît.

]]> `

python

voisins = [exemples[i][1] for i in range(k)]

return majoritaire(voisins)

]]> Erreur : on fait voter les k premiers
exemples dans l'ordre du tableau, sans
calculer aucune distance. Le vote ne porte
donc pas sur les voisins de p.

]]> `

python

paires = [(dist(p, x), c) for (x, c) in exemples]

paires = sorted(paires, key=premier)

voisins = [paires[i][1] for i in range(k)]

return majoritaire(voisins)

]]> Bonne réponse : on calcule les distances, on trie par distance
croissante grâce à la fonction clé premier, on garde les k plus
proches, et majoritaire réalise le vote.

]]> `

python

paires = [(dist(p, x), c) for (x, c) in exemples]

paires = sorted(paires, key=premier, reverse=True)

voisins = [paires[i][1] for i in range(k)]

return majoritaire(voisins)

]]> Erreur : le tri décroissant fait voter
les k exemples les plus éloignés de p.
Il faut trier par distance croissante pour
retenir les plus proches voisins.

]]> k plus proches voisins (k-NN) — Q17 : Des exemples rangés en dictionnaires Chaque fruit est rangé dans un dictionnaire, par exemple
e = {"masse": 152, "diametre": 5, "fruit": "pomme"}, et le
fruit à classer est p = {"masse": 150, "diametre": 7}. Quelle
expression donne le carré de la distance euclidienne entre e et
p ?

]]> Représenter un exemple par un dictionnaire rend le code lisible : on
écrit e["masse"] plutôt qu'un indice. Le calcul de distance reste
le même : somme des carrés des écarts, attribut par attribut.

]]> 1.0 0.0 0 true true abc (e["masse"] - p["masse"]) 2 + (e["diametre"] - p["diametre"]) 2

]]> Bonne réponse : on accède à chaque attribut par sa clé et on
additionne les carrés des écarts, attribut par attribut :
2² + 2² = 8 pour cet exemple. Le champ "fruit" n'entre pas
dans le calcul.

]]> (e["masse"] - e["diametre"]) 2 + (p["masse"] - p["diametre"]) 2

]]> Erreur : cette expression soustrait le diamètre à la masse d'un
même fruit, ce qui n'a pas de sens. Il faut comparer la masse de
e à celle de p, puis le diamètre de e à celui de p ; ici on
obtiendrait 42 058 au lieu de 8.

]]> (e[0] - p[0]) 2 + (e[1] - p[1]) 2

]]> Erreur : un dictionnaire ne s'indexe pas par position mais par
clé. e[0] provoque KeyError, car 0 n'est pas une clé du
dictionnaire.

]]> e["masse"] - p["masse"] + e["diametre"] - p["diametre"]

]]> Erreur : les écarts ne sont ni mis au carré ni pris en valeur
absolue, si bien qu'ils peuvent se compenser. Ici
2 + (-2) = 0, comme si les deux fruits étaient identiques.

]]> k plus proches voisins (k-NN) — Q18 : Coût de la prédiction Si l'on a N exemples d'entraînement, quel est
le coût d'une prédiction k-NN naïve ?

]]> Conséquence : la prédiction est lente sur de gros jeux
d'entraînement, car chaque nouveau point est comparé à tous les
exemples.

]]> 1.0 0.0 0 true true abc Constant, indépendant de N

]]> Erreur : il faut bien comparer le
nouveau point à chaque exemple.

]]> Linéaire en N (nombre d'exemples)

]]> Bonne réponse : on calcule une distance par exemple, soit N
distances, comme dans un parcours séquentiel. Pour retenir les k
plus proches, on peut chercher k fois le minimum, ce qui reste
linéaire en N pour k fixé.

]]> Quadratique en N (double boucle)

]]> Erreur : on ne fait pas de double boucle.

]]> Logarithmique en N

]]> Erreur : il faut bien examiner tous les
exemples.

]]> k plus proches voisins (k-NN) — Q19 : Forces et limites Quelle est une limite importante de k-NN ?

]]> Forces : simple, intuitif, sans phase d'entraînement. Limites :
lent à la prédiction, car chaque nouveau point est comparé à tous
les exemples, et sensible aux échelles des attributs.

]]> 1.0 0.0 0 true true abc Il invente de nouveaux exemples au cours de la prédiction

]]> L'algorithme se contente
de comparer le nouveau
point aux exemples déjà
fournis. Il n'en invente
aucun.

]]> Il ne fonctionne qu'en dimension 2

]]> Erreur : k-NN se généralise à toute
dimension.

]]> Il ne peut pas faire de classification

]]> Erreur : c'est précisément son rôle.

]]> Lent à la prédiction et sensible aux échelles

]]> Bonne réponse : tous les calculs ont lieu à la prédiction. Pour un
million d'exemples décrits par de nombreux attributs, k-NN peut
devenir impraticable.

]]> k plus proches voisins (k-NN) — Q20 : Vote pondéré Une variante de k-NN consiste à pondérer le vote des voisins. Pourquoi ?

]]> Vote uniforme = chaque voisin compte 1.
Vote pondéré = poids dépendant de la
distance. Variante classique du k-NN.

]]> 1.0 0.0 0 true true abc Pour économiser la mémoire

]]> La pondération n'a aucun
effet sur la consommation
mémoire.

]]> Pour donner plus de poids aux voisins proches

]]> Bonne réponse : un voisin très proche
devrait peser plus qu'un voisin éloigné.
Améliore souvent la qualité des
prédictions et résout les égalités.

]]> Pour rendre l'algorithme aléatoire

]]> Cette pondération reste
parfaitement déterministe.
Elle ne fait pas
intervenir le hasard.

]]> Pour ralentir intentionnellement tout le programme

]]> Aucun procédé de
pondération n'a pour but
de ralentir le
programme.

]]> k plus proches voisins (k-NN) — Q21 : Trace détaillée Avec k = 3, on classe un point P. Les 5
exemples les plus proches sont (par distance
croissante) : (1.0, classe A), (1.5, B), (2.0,
A), (3.0, A), (4.0, B). Quelle classe prédit
k-NN ?

]]> Méthode : trier par distance, garder les k
premiers, voter à la majorité. Les exemples
au-delà de k (4ᵉ et 5ᵉ ici) ne comptent pas.

]]> 1.0 0.0 0 true true abc Indéterminé

]]> Erreur : k-NN est déterministe.

]]> B

]]> Erreur : B n'a qu'un seul vote.

]]> Égalité

]]> Erreur : pas d'égalité.

]]> A

]]> Bonne réponse : on garde les k = 3 plus
proches : (1.0, A), (1.5, B), (2.0, A).
Vote : A = 2, B = 1 → A gagne.

]]> k plus proches voisins (k-NN) — Q22 : Un test réussi qui ne prouve rien La fonction suivante doit prédire la classe de p par vote
majoritaire de ses k plus proches voisins (dist(a, b) renvoie la
distance euclidienne) :

``python
def premier(couple):
return couple[0]

def predire(p, exemples, k):
couples = [(dist(p, x), c) for (x, c) in exemples]
couples = sorted(couples, key=premier)
return couples[0][1]
`

Le test suivant passe sans erreur :

python assert predire((0, 0), [((1, 0), "A"), ((5, 5), "B"), ((0, 2), "A")], 3) == "A"`

Que peut-on en conclure ?

]]> Un bon jeu de tests contient des cas qui distinguent une fonction
correcte d'une fonction fausse. Pour k-NN, il faut au moins un cas
où la classe du plus proche voisin est minoritaire parmi les k
voisins.

]]> 1.0 0.0 0 true true abc Rien sur le vote : ce test donne A qu'on fasse voter 1 ou 3 voisins

]]> Bonne réponse : la fonction renvoie la classe du seul plus proche
voisin et ignore k. Ce test ne le révèle pas, car le plus proche
voisin (1, 0) et la majorité des trois voisins désignent tous
deux A. Le test
predire((0, 0), [((1, 0), "A"), ((0, 2), "B"), ((2, 0), "B")], 3),
qui doit donner B, ferait apparaître l'erreur : la fonction
renvoie A.

]]> Le paramètre k est bien utilisé, le résultat correspondant au vote des 3 voisins

]]> Erreur : le résultat coïncide avec le vote des trois voisins
(A, A, B), mais la fonction ne fait aucun vote : elle renvoie
couples[0][1], la classe du plus proche. Le paramètre k
n'apparaît nulle part dans le corps.

]]> Le test est mal écrit : avec k = 3, la prédiction attendue serait B

]]> Erreur : les trois voisins sont (1, 0) de classe A à distance 1,
(0, 2) de classe A à distance 2 et (5, 5) de classe B, plus
loin. Le vote donne A deux voix contre une, et le test attend bien
A.

]]> La fonction est correcte, puisque l'assertion ne déclenche pas d'erreur

]]> Erreur : le succès d'un test ne garantit pas la correction d'un
programme. Ici la fonction ignore k et renvoie la classe du seul
plus proche voisin ; ce test tombe simplement sur un cas où cela
donne le bon résultat.

]]> k plus proches voisins (k-NN) — Q23 : Toujours le même voisin Pour éviter de trier toute la liste, on cherche k fois le plus
proche voisin dans une liste de couples (distance, classe) :

``python
def k_plus_proches(distances, k):
retenus = []
for etape in range(k):
i_min = 0
for i in range(len(distances)):
if distances[i][0] < distances[i_min][0]:
i_min = i
retenus.append(distances[i_min])
return retenus

print(k_plus_proches([(3, "A"), (1, "B"), (2, "A"), (5, "B")], 3))
``

Qu'affiche ce programme ?

]]> Chercher k fois un minimum est une bonne idée, à condition de ne pas
retrouver toujours le même élément : il faut exclure à chaque étape
les couples déjà retenus. L'erreur passe facilement inaperçue, car
les k « voisins » ont alors tous la même classe et le vote semble
fonctionner.

]]> 1.0 0.0 0 true true abc [(1, 'B'), (2, 'A'), (3, 'A')]

]]> Erreur : c'est le résultat voulu par l'auteur, mais la liste
distances n'est jamais modifiée. Les trois recherches de minimum
portent sur les mêmes couples et trouvent toutes (1, 'B').

]]> [(1, 'B')]

]]> Erreur : la boucle externe fait k = 3 tours et chacun ajoute un
couple à retenus. La liste finale contient donc trois couples,
tous égaux à (1, 'B').

]]> [(3, 'A'), (1, 'B'), (2, 'A')]

]]> Erreur : la fonction ne recopie pas les trois premiers couples de
la liste, elle cherche à chaque étape celui de plus petite
distance, qui est toujours (1, 'B').

]]> [(1, 'B'), (1, 'B'), (1, 'B')]

]]> Bonne réponse : à chaque étape, la recherche du minimum parcourt
la même liste, qui n'a pas changé, et retrouve le couple
(1, 'B'). Il est donc ajouté trois fois. Il faudrait écarter les
couples déjà retenus, par exemple en mémorisant leurs indices.

]]> k plus proches voisins (k-NN) — Q24 : k-NN pour la régression Peut-on adapter k-NN pour prédire un nombre
(régression) au lieu d'une classe ?

]]> Algorithme k-NN régresseur : très utilisé
en pratique pour des prédictions de prix,
durées, scores. Même principe que la
classification.

]]> 1.0 0.0 0 true true abc Non, l'algorithme est strictement limité à la classification

]]> L'algorithme s'adapte au
contraire très naturellement
au cas de la régression,
comme expliqué dans la
bonne réponse.

]]> Oui, en remplaçant le vote par la moyenne des k voisins

]]> Bonne réponse : si la cible est
numérique (prix d'une maison, note
attendue), la classe « majoritaire » est
remplacée par la moyenne des cibles des
k voisins. Idée générale identique.

]]> Oui, mais à condition de doubler la valeur de k

]]> Le passage à la régression
n'a aucun rapport avec un
doublement de k. C'est
la nature de l'agrégation
finale (vote majoritaire
ou moyenne) qui change.

]]> Non, il faut nécessairement un autre algorithme

]]> L'algorithme des k plus
proches voisins s'étend
naturellement à la
régression, sans qu'il
soit nécessaire de le
remplacer.

]]> k plus proches voisins (k-NN) — Q25 : Synthèse Parmi les affirmations suivantes sur k-NN,
laquelle est fausse ?

]]> Mnémonique : k petit = local, sensible au
bruit ; k grand = global, lissé. Choisir k
empiriquement par validation.

]]> 1.0 0.0 0 true true abc Plus k est grand, plus l'algorithme est sensible au bruit local.

]]> Faux (donc bonne réponse) : c'est
l'inverse. Avec k grand, le vote
intègre beaucoup de voisins, ce qui
lisse la décision et la rend
moins sensible aux exemples isolés
(bruit). Avec k petit (k = 1), un seul
exemple aberrant change la prédiction.

]]> La distance euclidienne est un choix courant pour la mesure de proximité.

]]> Vrai : c'est la mesure standard, mais
d'autres existent (Manhattan, cosinus).

]]> La phase d'entraînement se résume essentiellement à mémoriser les exemples.

]]> Vrai : algorithme paresseux.

]]> k-NN est un algorithme d'apprentissage supervisé.

]]> Vrai : il apprend depuis des exemples
étiquetés.

]]> k plus proches voisins (k-NN) — Q26 : Choix de la distance Outre la distance euclidienne, on rencontre
souvent la distance de Manhattan
(|Δx| + |Δy|). Quel critère permet de choisir
entre ces deux distances ?

]]> Repère pratique : essayer plusieurs distances, mesurer la qualité
des prédictions sur des exemples dont on connaît la classe, et
retenir la meilleure.

]]> 1.0 0.0 0 true true abc La distance de Manhattan est plus rapide à calculer

]]> Erreur : la différence est négligeable en pratique, les deux
distances demandant un calcul par coordonnée. La rapidité n'est
pas le critère qui motive le choix.

]]> Aucun critère, on choisit au hasard

]]> Erreur : le choix de la distance influence
fortement les résultats de l'algorithme. Il
faut le justifier en fonction du problème,
pas le tirer au hasard.

]]> La distance euclidienne est toujours préférable car elle est plus précise

]]> Erreur : ces deux distances sont des choix
valides selon le contexte. Aucune n'est
universellement meilleure. Le choix dépend
de la nature des données et de la
structure de la proximité que l'on veut
modéliser.

]]> Cela dépend du problème (espace continu ou grille)

]]> Bonne réponse : la distance de Manhattan est moins sensible aux
valeurs aberrantes dans les coordonnées, car elle n'élève pas les
écarts au carré. Elle est aussi plus naturelle quand on se déplace
sur une grille, comme dans les rues d'une ville. La distance
euclidienne, qui mesure la ligne droite, convient bien aux espaces
géométriques classiques.

]]> k plus proches voisins (k-NN) — Q27 : Classes déséquilibrées On veut détecter une maladie rare avec k-NN.
Le jeu d'entraînement contient 95 % d'exemples
« sain » et 5 % d'exemples « malade ». Avec
k = 7, que va prédire l'algorithme pour
presque tous les nouveaux patients ?

]]> Quand une classe est très rare, le vote majoritaire la prédit
rarement. Mesurer uniquement le taux global de bonnes prédictions
est trompeur : il faut aussi vérifier combien d'exemples de la
classe rare sont bien reconnus.

]]> 1.0 0.0 0 true true abc « sain » presque toujours, les voisins étant surtout sains

]]> Bonne réponse : c'est le piège classique des classes déséquilibrées.
Parmi les 7 voisins, les exemples « malade » sont presque toujours
minoritaires, et le vote donne « sain » même pour un patient malade.
Le taux global de bonnes prédictions peut sembler élevé (95 %) alors
que presque aucun malade n'est détecté.

]]> « malade » à 5 % des nouveaux patients, par symétrie

]]> Erreur : ce serait le comportement attendu
d'une distribution aléatoire. Or k-NN ne
tire rien au hasard ; il prédit en
fonction des voisins, et ceux-ci sont
principalement « sain ».

]]> « malade » dans la majorité des cas, par sécurité

]]> Erreur : k-NN n'a aucune logique de prudence sanitaire. Il vote
simplement à la majorité des voisins, et ceux-ci sont presque
toujours « sain ».

]]> Une classe choisie au hasard, l'algorithme étant non déterministe

]]> Erreur : k-NN est strictement
déterministe. Pour une même entrée et un
même jeu d'entraînement, il prédit
toujours la même classe.

]]> k plus proches voisins (k-NN) — Q28 : Calcul concret On classe le point P = (3, 4) avec k = 3 et
la distance euclidienne. Les exemples
étiquetés sont :
(0, 0, A), (6, 8, A), (2, 1, B),
(5, 4, B), (3, 0, A). Quelle classe
prédit k-NN ?

]]> Méthode systématique : (1) calculer la
distance de P à chaque exemple ; (2) trier par
distance croissante ; (3) garder les k
premiers ; (4) voter à la majorité. Sur les
petits jeux, refaire le calcul à la main est
le meilleur exercice de compréhension.

]]> 1.0 0.0 0 true true abc B

]]> Bonne réponse. Distances calculées :
(0, 0) → 5 ; (6, 8) → 5 ; (2, 1) →
√10 ≈ 3,16 ; (5, 4) → 2 ; (3, 0) → 4.
Les 3 plus proches sont (5, 4, B),
(2, 1, B), (3, 0, A). Vote : B = 2,
A = 1 → B gagne.

]]> Indéterminé sans plus d'informations

]]> Erreur : toutes les informations
nécessaires sont fournies (point, k,
distance, exemples étiquetés). Le résultat
est parfaitement calculable.

]]> Égalité entre A et B

]]> Erreur : avec k = 3 (impair) et deux
classes, il ne peut pas y avoir égalité.
Le calcul donne B = 2 voix, A = 1 voix.

]]> A

]]> Erreur : ce serait correct si A obtenait
la majorité parmi les 3 plus proches.
Refaire le calcul des distances : (0, 0)
→ 5 ; (6, 8) → 5 ; (2, 1) → √10 ≈ 3,16 ;
(5, 4) → 2 ; (3, 0) → 4. Les 3 plus
proches sont (5, 4, B) (2), (2, 1, B)
(3,16) et (3, 0, A) (4).

]]> k plus proches voisins (k-NN) — Q29 : La distance de Manhattan Quelle est la distance de Manhattan, somme des écarts en valeur
absolue sur chaque coordonnée, entre les points (1, 2) et
(4, 6) ?

]]> La distance de Manhattan compte les déplacements le long des axes,
comme dans une ville quadrillée ; elle se calcule sans racine
carrée.

]]> 1.0 0.0 0 true true abc 3

]]> Erreur : 3 n'est que l'écart sur la première coordonnée.

]]> 12

]]> Erreur : les écarts s'additionnent, ils ne se multiplient pas.

]]> 5

]]> Erreur : 5 est la distance euclidienne, à vol d'oiseau ; la
distance de Manhattan additionne les écarts.

]]> 7

]]> Bonne réponse : |1 - 4| + |2 - 6| = 3 + 4 = 7.

]]> k plus proches voisins (k-NN) — Q30 : Comparer des distances sans racine carrée Pour trouver les plus proches voisins de (0, 0), un programme
compare les carrés des distances euclidiennes au lieu des
distances. Quelle valeur calcule-t-il pour le point (3, 4),
et pourquoi ce choix ?

]]> Pour classer des distances, le carré suffit : si d₁ < d₂, alors
d₁² < d₂². On économise une racine carrée par exemple.

]]> 1.0 0.0 0 true true abc 25, mais ce choix fausse l'ordre des voisins

]]> Erreur : la valeur est juste, mais l'ordre est préservé, puisque
la racine carrée est croissante.

]]> 5, la distance elle-même, seule valeur exacte

]]> Erreur : 5 est la distance, mais le programme s'en passe ;
son carré 25 suffit pour comparer.

]]> 7, la somme des coordonnées, plus rapide

]]> Erreur : la somme des coordonnées n'est pas une distance.

]]> 25, la racine ne changeant pas l'ordre

]]> Bonne réponse : 3² + 4² = 25. Comparer les carrés donne
le même classement que comparer les distances, en évitant un
calcul coûteux.

]]> k plus proches voisins (k-NN) — Q31 : Des attributs d'échelles différentes Pour prédire si un client achète, on utilise son âge, entre 18 et
80, et son revenu annuel, entre 10 000 et 100 000. Quel
problème pose la distance euclidienne sur ces deux attributs tels
quels ?

]]> Avant un k-NN, on normalise souvent chaque attribut, par exemple
entre 0 et 1, pour qu'aucun ne domine la distance.

]]> 1.0 0.0 0 true true abc La distance ne peut pas se calculer avec deux attributs

]]> Erreur : la distance euclidienne se calcule avec autant
d'attributs que l'on veut.

]]> L'âge domine la distance, étant le premier attribut

]]> Erreur : l'ordre des attributs n'intervient pas ; c'est
l'ampleur des écarts qui compte.

]]> Le revenu domine, l'âge n'ayant presque plus d'influence

]]> Bonne réponse : un écart de 10 000 sur le revenu écrase un
écart de 20 sur l'âge. Il faut ramener les attributs à une
même échelle avant de calculer les distances.

]]> Aucun, les deux attributs étant des nombres positifs

]]> Erreur : être des nombres ne suffit pas, les échelles doivent
être comparables.

]]> k plus proches voisins (k-NN) — Q32 : Le cas k égal à un Avec k = 1, quelle classe l'algorithme des k plus proches voisins
attribue-t-il à un nouveau point ?

]]> Le plus proche voisin est l'algorithme le plus simple de la
famille : efficace sur des données propres, fragile sur des
données bruitées.

]]> 1.0 0.0 0 true true abc La classe la plus fréquente dans tout le jeu de données

]]> Erreur : ce serait le cas où k vaut le nombre total
d'exemples.

]]> La classe de l'exemple le plus éloigné

]]> Erreur : seuls les voisins proches votent.

]]> Une classe tirée au hasard

]]> Erreur : l'algorithme est déterministe, hors cas d'égalité des
distances.

]]> La classe de l'exemple le plus proche

]]> Bonne réponse : avec un seul voisin, le vote se réduit à sa
classe. C'est le cas le plus simple, et le plus sensible aux
exemples mal étiquetés.

]]> k plus proches voisins (k-NN) — Q33 : Un vote sans majorité Avec k = 4, les quatre plus proches voisins d'un point ont pour
classes A, A, B et B. Que se passe-t-il, et comment l'éviter ?

]]> Choisir k impair est une règle pratique pour deux classes ; avec
davantage de classes, une règle de départage reste nécessaire.

]]> 1.0 0.0 0 true true abc Le vote est indécis ; un k impair évite cette égalité

]]> Bonne réponse : deux voix contre deux ne désignent rien. Avec
deux classes, un k impair garantit une majorité.

]]> Le point est rejeté du jeu de données faute de majorité

]]> Erreur : le point doit recevoir une classe ; c'est le paramètre
k qu'il faut ajuster.

]]> La classe A l'emporte, étant la première rencontrée

]]> Erreur : l'ordre d'apparition n'a aucune valeur ; il faut une
règle explicite.

]]> L'algorithme recommence avec k = 8, le double

]]> Erreur : doubler k garde un nombre pair et le risque
d'égalité.

]]> k plus proches voisins (k-NN) — Q34 : Quand k vaut le nombre d'exemples Le jeu de données compte 100 exemples, 70 de classe A et 30 de
classe B. Que prédit l'algorithme pour tout nouveau point si k
vaut 100 ?

]]> Un k trop petit suit le bruit, un k trop grand ignore la
position : le bon k se trouve entre les deux, par essais.

]]> 1.0 0.0 0 true true abc La classe du point le plus proche

]]> Erreur : ce serait k = 1.

]]> Toujours B, la classe la plus rare du jeu

]]> Erreur : le vote donne la majorité, A.

]]> Une erreur, k devant être inférieur à 10

]]> Erreur : aucune règle n'impose cette borne, mais un k trop
grand noie les voisins proches.

]]> Toujours A, la classe majoritaire du jeu entier

]]> Bonne réponse : tous les exemples votent, quelle que soit la
position du point. Le résultat ne dépend plus du point, ce qui
rend l'algorithme inutile.

]]> k plus proches voisins (k-NN) — Q35 : Un exemple mal étiqueté Dans le jeu de données, un exemple de classe A a été étiqueté B
par erreur. Quels nouveaux points cette erreur affecte-t-elle le
plus, et pour quelle valeur de k ?

]]> Augmenter k lisse les erreurs d'étiquetage, au prix d'une
frontière entre classes moins précise.

]]> 1.0 0.0 0 true true abc Les points proches de cet exemple, surtout avec k petit

]]> Bonne réponse : avec k = 1, l'exemple fautif impose sa classe à
tout son voisinage ; avec un k plus grand, les autres voisins
corrigent son vote.

]]> Tous les points du jeu, quel que soit k

]]> Erreur : l'exemple ne vote que pour les points dont il est
voisin.

]]> Les points les plus éloignés de cet exemple

]]> Erreur : les points éloignés ne le comptent pas parmi leurs
voisins.

]]> Aucun point, une erreur isolée étant toujours ignorée

]]> Erreur : avec k = 1, elle n'est pas ignorée du tout.

]]> k plus proches voisins (k-NN) — Q36 : Mesurer la qualité des prédictions Pour savoir si son k-NN prédit bien, Théo l'évalue sur les
exemples qui ont servi à construire le jeu de données et obtient
100 % de bonnes réponses. Pourquoi ce chiffre ne prouve-t-il
rien ?

]]> Séparer les données en un jeu pour prédire et un jeu pour évaluer
est la règle pour mesurer honnêtement un algorithme
d'apprentissage.

]]> 1.0 0.0 0 true true abc Le pourcentage est mal calculé, les erreurs étant oubliées

]]> Erreur : le calcul est juste, c'est le protocole qui est
biaisé.

]]> Chaque exemple est son propre voisin, à distance nulle

]]> Bonne réponse : l'algorithme retrouve la classe de l'exemple
lui-même. Il faut évaluer sur des exemples mis de côté, qui
n'ont pas servi à prédire.

]]> Le k-NN ne s'évalue pas, faute de phase d'entraînement

]]> Erreur : il s'évalue très bien, sur des données séparées.

]]> 100 % est impossible pour un algorithme d'apprentissage

]]> Erreur : rien n'interdit un score parfait sur des données
faciles ; ici il est seulement trompeur.

]]>