Ecole nationale d'Electronique et des Télécommunications de Sfax

IA et Machine
Learning
Travaux pratiques

Elaboré par

Dr. Amina BEN HAJ KHALED

Responsable du module : Dr. Ali KHALFALLAH

Année universitaire 2021-2022

 TP 2 : Machine Learning
1. Introduction
Dans la dernière séance de travaux pratique, on s’est familiarisé avec l’environnement python
en utilisant l’application ANACONDA. Cette application est une distribution des langages de
programmation Python et elle est très utilisée en Machine Learning.
Le navigateur ANACONDA permet aux utilisateurs de choisir leurs applications, leurs
librairies, et leurs environnements. Dans notre TP, on a lancé l’application Spyder et on peut
aussi travailler avec l’application Jupiter. Ce qui diffère, dans ces deux applications, c’est
l’interface graphique.

Figure 1. L'application Spyder.

Figure 2. L'application Jupyter.

2. Objectif
L’objectif de cette deuxième séance de travaux pratique est de :
1
 • Utiliser la librairie Scikit-Learn pour ML.
• Faire un exemple d’apprentissage supervisé.
• Faire un exemple d’apprentissage non supervisé.
3. Le Machine Learning
La librairie Scikit-learn est la librairie la plus utilisée dans le ML.
La librairie Scikit-learn
Scikit-learn est une bibliothèque libre Python qui a été créée par David Cournapeau. Elle est
spécifique à l'apprentissage automatique. Elle comprend notamment des fonctions pour estimer
des (RT) forêts aléatoires, des régressions logistiques, des algorithmes de classification, et
les machines à vecteurs de support (SVM). Le lien de la librairie : https://scikit-learn.org/stable/

Figure 3. La carte des algorithmes de Scikit learn.

Les bases de Scikit learn sont simples.

1. Choisir un modèle en important la classe appropriée de Scikit-Learn.

2. Paramétrer le modèle.

3. Entraîner le modèle à l’aide de la méthode fit.

4. Tester le modèle sur de nouvelles données à l’aide de la méthode predict.

2
Ces 4 étapes sont en général communes à l’utilisation d’un grand nombre de modèles
disponibles dans la librairie ce qui permet de pouvoir très facilement utiliser d’autres modèles.

3.1. Apprentissage supervisé

Exercice1 : Régression
On souhaite faire une régression linéaire pour prédire la valeur de X en fonction de y. pour
cela on donne :
X=np.linspace(0, 10, m).reshape(m, 1)
y=X +np.random.randn(m, 1) # c’est une fonction linéaire.
avec m=100 (nombre d’exemple)
1. Importer la librairie Scikit learn
import sklearn
2. Importer le modèle de régression linéaire.
from sklearn.linear_model import LinearRegression
3. Importer les librairies nécessaires pour créer un tableau et un graphique.
import numpy as np
import matplotlib.pyplot as plt
4. entrer les lignes suivantes:
np.random.seed(0)
m=100
X=np.linspace(0, 10, m).reshape(m, 1)
y=X +np.random.randn(m, 1)
plt.scatter(X,y)
5. choisir le modèle de régression linéaire
model=LinearRegression()
6. Entrainer le modèle en utilisant la fonction « fit ».
model.fit(X ,y)
7. Evaluer le modèle en utilisant la fonction « score » pour calculer le moindre carré.
model.score(X ,y)
8. prédire la valeur de X en fonction de y en utilisant la fonction « predict ».
model.predict(X)
plt.plot(X, p, c='r')
9. Modifier le code pour que y=X**2 +np.random.randn(m, 1). Que remarquez-
vous ?
10. Modifier le code en appliquant une classification «Machine à vecteurs de support ». Que
remarquez-vous ?
Exercice2 : Classification
On désire prédire si on était parmi les voyageurs du bateau Titanic, quels sont nos chances de
survivre.

3
Pour cela, on va utiliser une base de données appelée « seaborn » qui contient les données
des voyageurs qui ont été présents (sexe, âge, classe, survivant….). Cette base n’est pas
complète et elle contient des données manquantes (on n’a pas des informations sur tous les
voyageurs).

1. Importer les librairies et la base de données nécessaire pour réaliser cet exercice.

import sklearn
import numpy as np
import pandas as pd
import seaborn as sns

2. Charger la base de données Titanic et expliquer les nouvelles fonctions.

titanic=sns.load_dataset('titanic')
titanic.shape
titanic.head()

3. Afficher la base de données. Quel est le type de cette base de données.

4. On souhaite sélectionner que certaines colonnes du tableau de Titanic : ‘survived’, ‘pclass’,
‘sex’ et ‘age’.
titanic= titanic[['survived', 'pclass', 'sex', 'age' ]]
titanic.dropna(axis=0, inplace=True)
titanic['sex'].replace(['male', 'female'],[0,1], inplace=True)
titanic.head()

5. charger le modèle de classification KNN (K-nearest neighbors).

from sklearn.neighbors import KNeighborsClassifier
model=KNeighborsClassifier()
y=titanic['survived']
X=titanic.drop('survived', axis=1)
print(y)
print(X)

6. Entrainer le modèle en utilisant la fonction « fit ».

model.fit(X, y)

4
7. Évaluer le modèle.
model.score(X, y)

8. Prédire la survécu. Que remarquez-vous ?

pp=model.predict(X)
print(pp)

9. créer la fonction suivante :

def survie(model, pclass=3, sex=1, age=35):
x=np.array([pclass, sex, age]).reshape(1, 3)
print(model.predict(x))
print(model.predict_proba(x))
am=survie(model)
print(am)

3.2. Apprentissage non supervisé

Exercice3 : Détection d’anomalie (Isolation forest)
1. Entrer le modèle suivant :

from sklearn.datasets import make_blobs

X, y = make_blobs(n_samples=50, centers=1, cluster_std=0.025)
X[-1,:] =np.array([2.25 ,5])
plt.scatter(X[: ,0], X[: ,1])

2. En suivant le même principe des exercices précédents, utiliser la classification Isolation forest
en utilisant les fonctions « IsolationForest ». Que remarquez-vous ?

Exercice 4 : PCA (Analyse en composantes principales)

1. taper le code suivant :
import numpy as np
import matplotlib.pyplot as plt
import sklearn
from sklearn.decomposition import PCA
from sklearn.datasets import load_digits
digits = load_digits()
images = digits.images

5
X = digits.data
y = digits.target
print(X.shape)
model = PCA(n_components=2)
X_reduced= model.fit_transform(X)
plt.scatter(X_reduced[:,0], X_reduced[:,1], c=y)
plt.colorbar()
model1 = PCA(n_components=64)
X_reduced1= model1.fit_transform(X)
rat=np.cumsum(model1.explained_variance_ratio_) #on va de 14%
à 100%
#print(rat)
#plt.plot(rat)
valeur=np.argmax(np.cumsum(model1.explained_variance_ratio_))
print(valeur) #a partir de la valeur de 60 on atteint 99%
model2 = PCA(n_components=60)
X_reduced2= model2.fit_transform(X)
X_recovred=model2.inverse_transform(X_reduced2)
plt.imshow(X_recovred[0].reshape(8, 8))