TP2 : apprentissage automatique,

Ndeye Fatou NGOM (2021-2022)

Exercice 1 Selection de modèles

On considère le jeu de données suivant
# importation des modules
import numpy as np
import matplotlib . pyplot as plt
# generation des données
x = np . array ([1 , 2 , 3 , 4 , 5])
y = np . array ([4 , 2 , 1 , 3 , 7])
plt . scatter (x , y );

1. Tester et interpréter le script qui suit

from sklearn . linear_model import LinearRegression
X = x [: , np . newaxis ]
model = LinearRegression (). fit (X , y )
yfit = model . predict ( X )
plt . scatter (x , y )
plt . plot (x , yfit );

2. Afin d’améliorer le résultat, un modèle polynomial de degré 3 est utilisé.

# Modèle polynomial
from sklearn . preprocessing import Pol yn om ial Fe at ure s
poly = Po ly nom ia lF ea tur es ( degree =2 , include_bias = False )
X2 = poly . fit_transform ( X )
print ( X2 )

model = LinearRegression (). fit ( X2 , y )

yfit = model . predict ( X2 )
plt . scatter (x , y )
plt . plot (x , yfit );

(a) Dans le script qui suit, que représente X2 ?

(b) Est ce que le modèle polynomial est meilleur que le modèle linéaire
de la question précédente ?
(c) Comparez les résultats obtenus lorsque l’on utilise un polynome de
degré 2, 3, 4, 5.
3. Maintenant nous souhaitons sélectionner le meilleur modèle polyno-
mial. Pour cela nous avons besoin d’un pipeline de transformation.
(a) Interpréter le segment de code qui suit
from sklearn . preprocessing import Pol yn om ial Fe at ure s
from sklearn . linear_model import LinearRegression
from sklearn . pipeline import make_pipeline
 DIC-2022-GIT-ML- NFN

def P o l y n o m i a l R eg r e s s i o n ( degree =2 , ** kwargs ):

return make_pipeline ( P ol yn omi al Fe atu re s ( degree ) ,
LinearRegression (** kwargs ))

(b) Pour la suite, nous considérons le jeu de données générées par la

fonction qui suit
import numpy as np

def make_data (N , err =1.0 , rseed =1):

# randomly sample the data
rng = np . random . RandomState ( rseed )
X = rng . rand (N , 1) ** 2
y = 10 - 1. / ( X . ravel () + 0.1)
if err > 0:
y += err * rng . randn ( N )
return X , y

X , y = make_data (40)
plt . figure ()
plt . scatter (X , y )

(c) Comparez les modèles polynomiales (degree 1, 3, 5) en vous ins-

pirant du script qui suit
import matplotlib . pyplot as plt
import seaborn ; seaborn . set ()

X_test = np . linspace ( -0.1 , 1.1 , 500)[: , None ]

plt . figure ()
plt . scatter ( X . ravel () , y , color = ’ black ’)
axis = plt . axis ()
for degree in [1 , 3 , 5]:
y_test = P o l y n o m i a l R e g r e s s i o n ( degree ). fit (X , y ). predict ( X_test )
plt . plot ( X_test . ravel () , y_test ,
label = ’ degree ={0} ’. format ( degree ))
plt . xlim ( -0.1 , 1.0)
plt . ylim ( -2 , 12)
plt . legend ( loc = ’ best ’ );

(d) A l’aide des courbes de validation, étudier les degree en fonction

du score.

from sklearn . learning_curve import validation_curve

degree = np . arange (0 , 21)
train_score , val_score = validation_curve (
P o l y n o m i a l R eg r e s s i o n () , X , y ,
’ p o l y n o m i a l f e a t u r e s _ _ d e g r e e ’ , degree , cv =7)
plt . figure ()
plt . plot ( degree , np . median ( train_score , 1) , color = ’ blue ’ ,
 DIC-2022-GIT-ML- NFN

label = ’ training score ’)

plt . plot ( degree , np . median ( val_score , 1) , color = ’ red ’ ,
label = ’ validation score ’)
plt . legend ( loc = ’ best ’)
plt . ylim (0 , 1)
plt . xlabel ( ’ degree ’)
plt . ylabel ( ’ score ’ );

(e) Afficher les résultats obtenus sur des données réelles

plt . figure ()
plt . scatter ( X . ravel () , y )
lim = plt . axis ()
y_test = P o l y n o m i a l R e g r e s s i o n (3). fit (X , y ). predict ( X_test )
plt . plot ( X_test . ravel () , y_test );
plt . axis ( lim );

(f ) SkitLearn offre des fonctions permettant de calculer des courbes

d’apprentissage qui permettent d’étudier le comportement du mo-
dèle en fonction du score. Testez et interprétez le script qui suit
from sklearn . learning_curve import learning_curve
plt . figure ()
fig , ax = plt . subplots (1 , 2 , figsize =(16 , 6))
fig . subplots_adjust ( left =0.0625 , right =0.95 , wspace =0.1)

for i , degree in enumerate ([2 , 9]):

N , train_lc , val_lc = learning_curve (
P o l y n o m i a l R eg r e s s i o n ( degree ) ,
X , y , cv =7 ,
train_sizes = np . linspace (0.3 , 1 , 25))

ax [ i ]. plot (N , np . mean ( train_lc , 1) , color = ’ blue ’ ,

label = ’ training score ’)
ax [ i ]. plot (N , np . mean ( val_lc , 1) , color = ’ red ’ ,
label = ’ validation score ’)
ax [ i ]. hlines ( np . mean ([ train_lc [ -1] , val_lc [ -1]]) , N [0] , N [ -1] ,
color = ’ gray ’ , linestyle = ’ dashed ’)

ax [ i ]. set_ylim (0 , 1)
ax [ i ]. set_xlim ( N [0] , N [ -1])
ax [ i ]. set_xlabel ( ’ training size ’)
ax [ i ]. set_ylabel ( ’ score ’)
ax [ i ]. set_title ( ’ degree = {0} ’. format ( degree ) , size =14)
ax [ i ]. legend ( loc = ’ best ’)

Exercice 2 Classement : régression logistique

La régression logistique permet de classer des données ou de fournir une
probabilité d’appartenance d’une données à une classe. Si la probabilité esti-
mée est supérieure à 50%, alors le modèle prédit que l’observation appartient
 DIC-2022-GIT-ML- NFN

à cette classe (appelée classe positive, d’étiquette 1), sinon il prédit qu’elle
apprtient à l’autre classe (la classe négative d’étiquette 0). La logisstique du
résultat ou probabilité estimé par le modèle de régression logistique est donnée
par
p̂ = hθ (x) = σ θT .x

où la fonction logistique σ ou logit est une fonction sigmoide qui renvoie des
valeurs entre 0 et 1.
1
σ (t) =
1 + exp(−t)
La prédiction du modèle se fait de la manière suivante
(
0 si p̂ ≺ 0.5
ŷ =
1

Comme σ (t) ≺ 0.5 lorsque t ≺ 0 et σ (t) ≥ 0.5 lorsque t ≥ 0.5, alors un

modèle de régression logistique prédit 1 si θT .x est positif et 0 sinon. La
fonction coût (perte logistique) est donnée par
m
1 X i
y log p̂i + 1 − y i log 1 − p̂i




J (θ) = −
m
i=1

J (θ) est convexe (le min sur θ peut être trouvé par descente de gradient) et
m
∂ 1 X
σ θT .xi − y i xij



J (θ) =
∂θ m
i=1

Pour tester la régression logistique, nous considérons le jeu de données iris

qui comporte la longueur et la largeur des sépales et des pétales de 150 fleurs
d’iris de trois espèces différentes : Iris sesotat, Iris versicolor et Iris viginica.
L’objectif est de construire un classificateur pour détecter les iris de type
virginica en se basant uniquement sur la largeur du pétale.
1. Charger le jeu de données,
2. Entrainer le modèle de régression logistic,
3. Ensuite générer les probabilités estimés par le modèle pour les fleurs
ayant des tailles de pétales comprises entre 0 et 3cm.
4. Dans une même figure les courbes d’évolutions correspondante.
5. Interpéter les garphes et discuter sur la frontière de décision.
6. Calculer la précision du modèle.
7. Une généralisation de la régression logistique, pour prendre en compte
plusieurs classes directement, est donnée par la régression softmax ou
régression logsitique multinomiale. Etant donné une observation x, le
modèle de régression softmax calcule d’abord un score sk (x) pour chaque
 DIC-2022-GIT-ML- NFN

classe k, puis estime la probabilité p̂k de chaque classe en appliquant

aux scores la fonction sofmax (exponentielle normalisée). La probabilité
estimée que l’observation x appartienne à la classe k compte tenu des
cores de chaque classe pour cette observation est
exp (sk (x))
p̂k = σ (s (x))k = PK
j=1 exp (sj (x))

T
sk (x) = θk .x est score sk (x) softmax pour la classe k, K le nombre
de classes, s (x) un vecteur contenant les scores de chaque classe pour
l’observation x.
(a) A l’aide de la calsse LogisticRegression de Scikit-Learn et de l’hy-
perparamètre multi_class, utiliser la régression softmax pour ré-
partir les fleur d’iris en trois classes.
(b) Interpréter les résultats obtenus en vous basant sur les probabilités
estimées et la frontière de décision.
(c) Impélenter une descente de gradient ordinaire avec arrêt précoce
avec une régression softmax sans utiliser Scikit-Learn.

Exercice 3 Classfification

1. Jeu de donnée MNIST

(a) Concevez un classificateur pour le jeu de données MNIST.
(b) Ecrivez une fonction qui peut décaler une image MNIST d’un pixel
dans une direction quelconque.
(c) Puis, pour chaque image du jeu d’entraînement, créez quatre co-
pies décalées et ajoutez les au jeu d’entraînement.
(d) Ensuite entraînez votre meilleur modèle sur ce jeu d’entraînement
étendu et mesurez son excatitude sur le jeu de test.
(e) Construire un classificateur de spam.
i. Récupérez les exemples de spam et de ham dans les jeu de
données publics Spam Assassin d’Apache.
ii. Dézippez ces jeux de données et familiarisez-vous avec leur
format.
iii. Partagez ces données entre jeu d’entraînement et jeu de test.
iv. Ecrivez un pipeline de préparation de données pour convertir
chaque e-mail en un vecteur de caractéristiques.
v. Essayez ensuite différents classificateurs et en deduire un bon
classifieur de spam, ayant à la fois un rappel et une précision
élevée.