La Régression Logistique et

l'Algorithme KNN pour la Classification

en AA

1
 Régression Logistique et Algorithmes
de Classification
Objectifs:
• Dans l’apprentissage supervisé, il y a deux type de problèmes :
• Les régressions
• Les classifications
• Dans ce chapitre, vous allez découvrir le modèle de régression Logistique, qui
permet de résoudre des problèmes de classification binaires.
• On va aussi découvrir un des algorithmes les plus populaires et simple : Le K-
Nearest Neighbour.
Objectifs du chapitre :

• Comprendre les deux types de problèmes en apprentissage supervisé : les

régressions et les classifications.

• Découvrir le modèle de régression logistique, utilisé pour résoudre des

problèmes de classification binaires.

• Explorer l'algorithme K-Nearest Neighbors (KNN), l'un des plus populaires et

simples en apprentissage supervisé.
2
 Les problèmes de Classification
• Dans les problèmes de classification binaire, l'objectif est de classer
les données en deux classes distinctes, généralement représentées
par les étiquettes 0 et 1. Par exemple, dans le cas de la
classification d'emails en "spam" ou "non spam", la variable cible
(target) 𝑦 peut prendre deux valeurs : 0 pour indiquer que l'email
n'est pas un spam et 1 pour indiquer que l'email est un spam.
• Le modèle de régression logistique est couramment utilisé pour
résoudre des problèmes de classification binaire. Il ajoute une
frontière de décision qui sépare les deux classes dans l'espace des
caractéristiques (features). Cette frontière de décision permet au
modèle de classer un nouvel email en tant que classe 0 ou classe 1
en fonction de ses caractéristiques.
• L'objectif de l'apprentissage est de trouver les paramètres
optimaux du modèle de régression logistique afin d'optimiser la
frontière de décision et d'effectuer des prédictions précises sur de
3
nouvelles données.
Les problèmes de Classification

4
 Le modèle de Régression logistique

• Pour les problèmes de classification binaire,

un modèle linéaire 𝑭 = 𝑿. 𝜽, comme on l’a
tracé sur la figure précédente, ne convient pas
pour des dataset particuliers, du coup on peut
pas le généraliser.

• Voyez plutôt le résultat que l’on obtient avec

un tel modèle pour le Dataset suivant :

5
Les problèmes de Classification

6
 Les problèmes de Classification
Solution:
• On développe alors une nouvelle fonction
pour les problèmes de classification binaire,
c’est la fonction logistique (aussi appelé
fonction sigmoïde ou tout simplement la
fonction « sigma », 𝝈). Cette fonction a la
particularité d’être toujours comprise en 0 et
1.

7
 Les problèmes de Classification

Pour appliquer la fonction logistique à un jeu de données (X, y), nous

utilisons une approche qui consiste à effectuer un produit matriciel X .
Θ, ce qui aboutit au modèle de régression logistique, également
connu sous le nom de "Logistic Regression".
𝝈(𝑿. 𝜽) =𝟏/(𝟏 + 𝒆− (𝑿.𝜽))
8
 Les problèmes de Classification
• À partir de cette fonction, il est possible de
définir une frontière de décision. En général,
on fixe un seuil à 0.5 de la manière suivante :
• 𝒚 = 𝟎, 𝒔𝒊 𝝈(𝑿. 𝜽) < 𝟎. 𝟓
• 𝒚 = 𝟏, 𝒔𝒊 𝝈(𝑿. 𝜽) ≥ 𝟎. 𝟓

9
Les problèmes de Classification

10
 Fonction Coût associée à la Régression
Logistique
• Pour la régression linéaire, la Fonction Coût:
𝑱(𝜽) = 𝟏/𝟐𝒎*∑(𝑿. 𝜽 − 𝒀)𝟐

Effectivement, la présence d'une courbe non convexe avec un unique

minimum est cruciale pour le bon fonctionnement de l'algorithme de
Gradient Descent. Cependant, dans le cas du modèle logistique, en
raison de sa non-linéarité, la courbe n'est pas convexe, ce qui pose un
défi pour le processus d'optimisation du Gradient Descent.
Concrètement, cela signifie que l'algorithme peut se retrouver piégé
au premier minimum local qu'il rencontre, plutôt que d'atteindre le
minimum global souhaité. Par conséquent, des méthodes spéciales et
des techniques d'optimisation plus sophistiquées peuvent s'avérer
nécessaires pour trouver de manière plus fiable le minimum global
dans de telles situations.

11
Fonction Coût associée à la Régression
Logistique

12
Fonction Coût associée à la Régression
Logistique
• Solution:
Pour rendre la fonction de coût convexe et résoudre le problème de
non-convexité, la "Log Loss" (ou "Cross-Entropy Loss") est utilisée
dans le modèle de régression logistique. Cette fonction de coût
utilise le logarithme pour différencier les cas où y = 1 et y = 0, ce qui
permet de pénaliser les erreurs différemment pour chaque classe.
Cette approche contribue à obtenir un unique minimum global pour
la fonction de coût, ce qui est essentiel pour l'optimisation par des
méthodes comme le Gradient Descent. En fin de compte, la "Log
Loss" est un choix judicieux pour la régression logistique en raison
de sa capacité à résoudre le problème de non-convexité tout en
adaptant la pénalité en fonction des erreurs de classification pour
chaque classe.
Cela améliore la convergence de l'algorithme de Gradient Descent et
assure de meilleures performances pour le modèle logistique en
classification binaire.

13
Fonction Coût associée à la Régression
Logistique
Log(0)=-inf
Log(+inf)=+inf
Log(1)=0

14
Fonction Coût associée à la Régression
Logistique
• Fonction Coût dans les cas où 𝑦 = 1
• Voici la Fonction Coût que l’on utilise dans les cas où 𝑦 =
1:
• 𝑱(𝜽) = − 𝐥𝐨𝐠 (𝝈(𝑿. 𝜽)) = − 𝐥𝐨𝐠 (𝝈)
• Explications :
• Si notre modèle prédit 𝜎 = 0 , alors que 𝑦 = 1, on doit
pénaliser la machine par une grande erreur (un grand
coût 𝑱(0)=− 𝐥𝐨𝐠 (0)=+inf).
• La fonction logarithme permet de tracer cette courbe
avec une propriété convexe, ce qui poussera le Gradient
Descent à trouver les paramètres 𝜽 pour un coût qui
tend vers 0, (𝜎 = 1) (𝑱(1)= -𝐥𝐨𝐠 (1) = 0)
15
Fonction Coût associée à la Régression
Logistique

16
Fonction Coût associée à la Régression
Logistique
• Fonction Coût dans les cas où 𝑦 = 0
• Cette fois la Fonction Coût devient :
• 𝑱(𝜽) = − 𝐥𝐨𝐠 (𝟏 − 𝝈(𝑿. 𝜽)), ou bien 𝑱 = − 𝐥𝐨𝐠 (𝟏 − 𝝈)
• Explications :
• Si notre modèle prédit 𝜎(𝑥) = 1 alors que 𝑦 = 0, on doit
pénaliser la machine par une grande erreur (un grand
coût 𝑱 = − 𝐥𝐨𝐠 (𝟏 − 𝝈)). (𝑱(1)= -𝐥𝐨𝐠 (1-1) =+ inf)
• Cette fois 𝑱(0)=− 𝐥𝐨𝐠 (1-0)=0  donne la même
courbe, inversée sur l’axe vertical.

17
Fonction Coût associée à la Régression
Logistique

18
 Fonction Coût complète

• pour écrire la fonction de coût en une seule équation, en

séparant les cas y = 0 et y = 1 tout en évitant une division par
zéro, on peut utiliser l'astuce suivante :

• 𝑱(𝜽) =(− 𝟏/𝒎)*∑ 𝒚 × 𝐥𝐨𝐠( 𝝈(𝑿. 𝜽)) + (𝟏 − 𝒚) × 𝐥𝐨𝐠(𝟏 − 𝝈(𝑿. 𝜽))

• Dans le cas où 𝑦 = 0, il nous reste :
• 𝐽(𝜃) =− 1/𝑚∑ 0 × log(𝜎(𝑋. 𝜃)) + 𝟏 × 𝐥𝐨𝐠(𝟏 − 𝝈(𝑿. 𝜽))

• Et dans le cas où 𝑦 = 1
• 𝐽(𝜃) = (− 1/m) * ∑ 𝟏 × 𝐥𝐨𝐠(𝝈(𝑿. 𝜽))+ 0 × log(1 − 𝜎(𝑋. 𝜃))

19
 Gradient Descent pour la Régression
Logistique
L'algorithme de Gradient Descent peut être appliqué de la même
manière pour la régression logistique que pour la régression linéaire.
De plus, la dérivée de la fonction de coût utilisée dans la régression
logistique est la même que celle utilisée dans la régression linéaire.
Cela facilite l'optimisation des paramètres du modèle à l'aide de
l'algorithme de Gradient Descent, car les étapes mathématiques sont
similaires et consistent à ajuster les paramètres pour minimiser la
fonction de coût (Log Loss dans le cas de la régression logistique) et
atteindre une solution optimale.
• 𝐺𝑟𝑎𝑑𝑖𝑒𝑛𝑡:
• 𝝏 𝑱(𝜽)/𝝏 𝜽=(𝟏/𝒎)∑( 𝝈(𝑿. 𝜽) − 𝒚) *𝑿
• 𝐺𝑟𝑎𝑑𝑖𝑒𝑛𝑡 𝐷𝑒𝑠𝑐𝑒𝑛𝑡:
• 𝜽 = 𝜽 − 𝑎 × *(𝝏 𝑱(𝜽)/ 𝝏 𝜽)

20
Résumé de la Régression Logistique

21
 Développer un programme de
classification binaire dans Jupyter
il faut tout d'abord importer les modules
nécessaires et générer des données aléatoires à
des fins d'apprentissage et d'exploration en
utilisant la fonction make_classification de la
bibliothèque scikit-learn en Python. Voici
comment vous pouvez procéder avec les
importations et la génération de données
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
22
 Développer un programme de
classification binaire dans Jupyter
• import numpy as np
• import matplotlib.pyplot as plt
• from sklearn.datasets import make_classification
• from sklearn.linear_model import SGDClassifier
• # create features and target# Génération de données aléatoires: 100 exemples, 2 classes, 2
features x0 et x1
• x, y = make_classification(n_samples=100,
• n_features=2,
• n_informative=2,
• n_redundant=0,
• n_classes=2,
• weights=[0.3, 0.7],
• random_state=42)
• # Visualisation des données
• plt.figure(num=None, figsize=(8, 6))
• plt.scatter(x[:,0], x[:, 1], marker = 'o', c=y, edgecolors='k')
• plt.xlabel('X0')
• plt.ylabel('X1')
• x.shape

23
 Développer un programme de
classification binaire dans Jupyter

24
 Développer un programme de
classification binaire dans Jupyter
• Ensuite, nous devons créer un modèle en utilisant
SGDClassifier.
• # Génération d'un modele en utilisant la fonction cout
'log' pour Logistic Regression.
• model = SGDClassifier(max_iter=1000, eta0=0.001,
loss='log').
• model.fit(X, y)
• print('score:', model.score(x, y))
• Une fois le modèle entraîné, on peut afficher sa
frontière de décision avec le code suivant…un peu
compliqué je vous l’accorde, mais un simple
copier/coller fera l’affaire.
25
 Développer un programme de
classification binaire dans Jupyter
• # Visualisation des données
• h = .02
• colors = "bry"
• x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
• y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
• xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
• np.arange(y_min, y_max, h))
• Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
• Z = Z.reshape(xx.shape)
• cs = plt.contourf(xx, yy, Z, cmap=plt.cm.Paired)
• plt.axis('tight')
• for i, color in zip(model.classes_, colors):
idx = np.where(y == i)
• plt.scatter(X[idx, 0], X[idx, 1], c=color, cmap=plt.cm.Paired, edgecolor='black', s
• =20)

26
 Développer un programme de
classification binaire dans Jupyter

27
 Développer un programme de
classification binaire dans Jupyter
• Pour résumer de manière concise : l'apprentissage
automatique, bien que basé sur des concepts
mathématiques complexes, peut être extrêmement
amusant et gratifiant lorsqu'il est appliqué à des
problèmes du monde réel.
• Vous pouvez l'utiliser pour résoudre une variété de
défis, tels que la détection de spam, la classification de
tumeurs, la recommandation de produits, la prédiction
de la demande, et bien d'autres encore.
L'apprentissage automatique vous offre l'opportunité
de trouver des solutions créatives à des questions
diverses et passionnantes.

28
 L’Algorithme de Nearest Neighbour

• L'algorithme des k plus proches voisins (KNN)

est l'un des algorithmes les plus simples en
apprentissage automatique. Il fonctionne en
attribuant à un nouvel exemple la classe
majoritaire parmi ses k voisins les plus proches
dans l'ensemble d'entraînement. KNN est
efficace pour des données bien regroupées ou
des frontières de décision simples.

29
 Vulgarisation du Pb: Promenade en
Montage
Vous partez en randonnée en montagne avec un
ami. Avant le départ, la température est de 30 °C, et
votre ami indique qu'il a chaud. Une fois en
montagne, la température chute à 10 °C, et votre
ami dit qu'il a froid. Maintenant, en redescendant
dans la vallée, la température est de 15 °C.
Pensez-vous que votre ami aura froid ou chaud ? En
considérant que 15 °C se rapproche davantage de
10 °C (froid) que de 30 °C (chaud)
 il semble légitime de prédire que votre ami aura
froid.

30
Vulgarisation du Pb: Promenade en
Montage

31
 K-Nearest Neighbour (K-NN)

• L'algorithme des k plus proches voisins (KNN) est

une méthode simple et intuitive en apprentissage
automatique. Lorsque vous devez faire une
nouvelle prédiction, vous trouvez simplement
l'exemple le plus proche dans votre ensemble de
données en fonction des caractéristiques ou des
conditions en question. C'est un excellent
exemple de la simplicité de certains algorithmes
d'apprentissage automatique, qui peuvent être
très puissants tout en étant faciles à comprendre
et à utiliser.

32
 K-Nearest Neighbour (K-NN)

• La variété et la quantité de données dans votre ensemble de

données sont cruciales en apprentissage automatique. Un ensemble
de données limité ou non représentatif peut conduire à des
conclusions erronées. Dans votre exemple, avec seulement deux
points de données (-20 °C et 20 °C), il serait très trompeur de
conclure que 1 °C est une température chaude, car ces deux points
ne couvrent pas la plage complète des températures possibles.
• Avoir un ensemble de données diversifié et suffisamment
volumineux permet à un algorithme comme KNN de généraliser
correctement et de prendre des décisions plus précises. Plus il y a de
données, mieux l'algorithme peut apprendre et s'adapter à
différentes situations. Il est donc essentiel de collecter et de disposer
de données de qualité pour obtenir des résultats fiables en
apprentissage automatique.

33
 K-Nearest Neighbour (K-NN)
La distance la plus courte

• le voisin le plus proche du point vert est un voisin de la

classe rouge. L'algorithme de Nearest Neighbour (KNN)
fonctionne en calculant la distance entre le point vert et
tous les autres points du jeu de données, puis en
associant le point vert à la classe dont il est le plus
proche en termes de distance. Dans ce cas précis, le
point vert est plus proche des points rouges que des
points bleus, ce qui le fait classer dans la classe rouge en
utilisant la méthode KNN pour la classification. 34
 K-Nearest Neighbour (K-NN)
La distance la plus courte
• En effet, en utilisant généralement la distance euclidienne, qui mesure la
distance directe entre deux points comme la ligne droite, est courante
dans l'algorithme KNN. Cependant, d'autres métriques de distance telles
que la distance de Manhattan (aussi connue sous le nom de distance de la
ville) ou la distance cosinus peuvent être plus appropriées selon la nature
de vos données et de votre problème.

• La distance de Manhattan est utile lorsque les caractéristiques ont des

unités différentes ou que les déplacements ne se font pas nécessairement
en ligne droite, tandis que la distance cosinus est particulièrement utile
lorsque vous travaillez avec des vecteurs ou des données textuelles.

• Heureusement, des bibliothèques telles que scikit-learn simplifient la mise

en œuvre de différentes métriques de distance, ce qui vous permet de
choisir la métrique la plus adaptée à votre problème sans avoir à coder les
équations vous-même.

35
 K-Nearest Neighbour (K-NN)
Le nombre de voisin K
• En choisissant de trouver les K voisins les plus
proches au lieu d'un seul voisin dans l'algorithme
KNN, vous réduisez la sensibilité aux bruits et aux
cas particuliers, ce qui améliore la qualité du
modèle et sa capacité à généraliser correctement.
• Cela permet au modèle de mieux saisir la
structure globale des données au lieu de se
concentrer sur des points individuels, réduisant
ainsi le risque de surajustement(overfitting).
Cependant, le choix de la valeur optimale de K est
important pour obtenir de bons résultats.

36
37
Vision par ordinateur avec K-NN dans
Jupyter
• Pour créer un programme capable de
reconnaître des chiffres écrits à la main, nous
allons utiliser un modèle d'apprentissage
automatique.
• Voici les chiffres que la machine saura
reconnaitre dans quelques minutes.

38
Vision par ordinateur avec K-NN dans
Jupyter

39
Vision par ordinateur avec K-NN dans
Jupyter
• Vous pouvez charger ces données depuis Sklearn
(la librairie contient des Datasets de base).
• Commençons par importer les libraires
habituelles :
• import numpy as np
• import matplotlib.pyplot as plt
• from sklearn.datasets import load_digits
• from sklearn.neighbors import
KNeighborsClassifier

40
Vision par ordinateur avec K-NN dans
Jupyter
• Le code ci-dessous présente un exemple d'image de chiffre inclus
dans le jeu de données. Plus précisément, il s'agit d'un exemple du
chiffre 0. Il est important de noter que le jeu de données contient
un total de 1797 exemples, ce qui équivaut à 1797 images, et
chaque exemple comprend 64 caractéristiques.

• Les 64 caractéristiques correspondent aux valeurs des 64 pixels

constituant les images. Lorsque nous soumettons un nouveau
chiffre manuscrit à la machine, l'algorithme K-NN recherche
l'exemple du jeu de données qui présente la ressemblance la plus
proche avec notre chiffre. Cette ressemblance est calculée en
examinant la proximité des valeurs de chaque pixel, permettant
ainsi de trouver le voisin le plus proche qui correspond le mieux au
chiffre soumis.

41
Vision par ordinateur avec K-NN dans
Jupyter
• # importons une base de données de chiffre
• digits = load_digits()
• X = digits.data
• y = digits.target
• print('dimension de X:', X.shape)

42
Vision par ordinateur avec K-NN dans
Jupyter
• En effet, obtenir un score de 99% en précision de classification est
une performance impressionnante, et cela démontre que le modèle
K-NN que vous avez entraîné est capable de reconnaître les chiffres
manuscrits avec une grande précision. C'est une étape significative
dans l'apprentissage automatique, et cela montre que vous
maîtrisez les concepts fondamentaux du Machine Learning.

• Cependant, il est important de noter que la performance d'un

modèle peut varier en fonction de la qualité des données, de la
taille de l'ensemble d'entraînement, du choix des hyperparamètres,
etc. Il y a encore beaucoup à explorer et à apprendre dans le
domaine de l'apprentissage automatique, mais obtenir un score
élevé comme celui-ci est certainement un signe encourageant de
compétence en matière de Machine Learning !!

43
Vision par ordinateur avec K-NN dans
Jupyter
• # visualisons un de ces chiffres
• plt.imshow(digits['images'][0], cmap =
'Greys_r')
• # Entraînement du modele
• model = KNeighborsClassifier()
• model.fit(X, y)
• model.score(X, y)

44
Vision par ordinateur avec K-NN dans
Jupyter

45
Vision par ordinateur avec K-NN dans
Jupyter
• C'est une excellente idée de tester le modèle avec une
image aléatoire pour voir s'il est capable de la reconnaître
correctement. Le fait que la machine ait réussi à identifier
le chiffre 4 dans la 100e image du jeu de données est une
démonstration convaincante de son efficacité et de sa
capacité à généraliser à partir des exemples
d'entraînement.

• Cela montre que le modèle K-NN que vous avez entraîné

est capable de prendre en compte les caractéristiques des
images et de les utiliser pour faire des prédictions précises.
C'est une réalisation impressionnante en matière
d'apprentissage automatique et un excellent moyen de
conclure votre exploration de ce modèle de classification !
46
Vision par ordinateur avec K-NN dans
Jupyter
• #Test du modele
• test = digits['images'][100].reshape(1, -1)
• plt.imshow(digits['images'][100], cmap =
'Greys_r')
• model.predict(test)

47
Vision par ordinateur avec K-NN dans
Jupyter

Bravo pour avoir su développer votre premier vrai programme

de vision par ordinateur !

48
 Bilan de ce chapitre

• Dans ce chapitre, Vous avez exploré deux algorithmes populaires pour la

classification : la Régression Logistique avec Gradient Descent et le K-
Nearest Neighbors (KNN). La Régression Logistique est une technique
fondamentale en apprentissage automatique, souvent utilisée pour la
classification binaire et multiclasse. Elle joue également un rôle clé dans
les réseaux de neurones, qui seront abordés dans le prochain chapitre.

• Le KNN, quant à lui, est un algorithme simple mais puissant qui se base sur
la proximité pour effectuer des prédictions de classification. Ces deux
algorithmes constituent un excellent point de départ pour comprendre les
concepts de base de l'apprentissage automatique.

• Dans le prochain chapitre sur les réseaux de neurones, vous plongerez

dans un domaine passionnant et puissant de l'apprentissage automatique,
où les concepts de la régression logistique et du KNN continueront d'avoir
leur importance, notamment au sein des couches de neurones.

49