DEVOIR II : TD - TP

Entrainement d’un Modèle

Réseaux de neurones et apprentissage profond

NDOH NDOH Jules Moise Yannick

Master 2 Recherche (Laboratoire SIS)
ENSET EBOLOWA
ndohmoise@gmail.com

16 février 2024
 TD - TP1 Exercice I RNA

February 15, 2024

[1]: #Question 1 : Importation des bibliothèques nécessaires

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

[2]: #Lecture de la base de données

iris = load_iris()

[3]: #Séparation des données en X = entrées et y = sortie

X = iris.data
y = iris.target

[4]: #Question 2 : Le nombre d'exemple du jeu de données est de 150

print(X.shape[0])

150

[5]: #Question 3 : Le nombre de label dans la base est de 4

print(X.shape[1])

[6]: #Question 4 : Le nombre de classe identifié est de 3

print(y)

[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2
2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
2 2]

[7]: #Question 5 : Affichons le nuage de points. Nous avons obtenus 3 classes

plt.scatter(X[:,0], X[:,1], c=y, alpha = 0.8)

[7]: <matplotlib.collections.PathCollection at 0x216ca85a4d0>

1
[8]: #Question 6 : Division des données en données d'entrainement et données de test

[9]: #Question 6 - A : Il permet de diviser les données en 50% de données␣

↪d'entrainement et 50% de données de test

t = 0.5
X_train, X_test, Y_train, Y_test = train_test_split(X,y,test_size=t)
print("Train set : ", X_train.shape)
print("Test set : ", X_test.shape)

Train set : (75, 4)

Test set : (75, 4)

[10]: #Question 6 - B : Il permet de diviser les données en 80% de données␣

↪d'entrainement et 20% des données de test

t = 0.2
X_train, X_test, Y_train, Y_test = train_test_split(X,y,test_size=t)
print("Train set : ", X_train.shape)
print("Test set : ", X_test.shape)

Train set : (120, 4)

Test set : (30, 4)

2
[11]: #Question 6 - C : il permet de déterminer le taux de découpage des données␣
↪d'entrainement et des données de test

[12]: #Question 7 : Visualisation des nuages de points

[13]: #Question 7 - A Visualisation des nuages de points

plt.figure(figsize=(12,4))
plt.subplot(121)
plt.scatter(X_train[:,0], X_train[:,1], c=Y_train, alpha=0.8)
plt.title("Train Set")
plt.subplot(122)
plt.scatter(X_test[:,0], X_test[:,1], c=Y_test, alpha=0.8)
plt.title("Test Set")

[13]: Text(0.5, 1.0, 'Test Set')

[14]: #Question 7-B Les figures obtenus représentent les différents pourcentages de␣
↪données d'entrainement et de données de test

[15]: #Question 8 - A Visualisation du jeu de données d'entrainement et de test avec␣

↪le paramètre random_state

t = 0.2
X_train, X_test, Y_train, Y_test =␣
↪train_test_split(X,y,test_size=t,random_state=5)

plt.figure(figsize=(12,4))
plt.subplot(121)
plt.scatter(X_train[:,0], X_train[:,1], c=Y_train, alpha=0.8)
plt.title("Train Set")
plt.subplot(122)
plt.scatter(X_test[:,0], X_test[:,1], c=Y_test, alpha=0.8)
plt.title("Test Set")

3
[15]: Text(0.5, 1.0, 'Test Set')

[16]: #Question 8 : Après avoir relancer plusieurs fois nous avons constaté une mise␣
↪en place aléatoire des données de test

4
 TD - TP1 Exercice II RNA

February 15, 2024

[1]: #Importation des bibliothèques

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split

[2]: #Séparation des données en X = entrées et y = sortie

iris = load_iris()
X = iris.data
y = iris.target

[3]: t = 0.2
X_train, X_test, Y_train, Y_test = train_test_split(X,y,test_size=t)
print("Train set : ", X_train.shape)
print("Test set : ", X_test.shape)

Train set : (120, 4)

Test set : (30, 4)

[4]: #Question 1 : définition du modèle KNC

model = KNeighborsClassifier(1)

[5]: #Question 2 : Entrainement du modèle aec model.fit

model.fit(X_train, Y_train)

[5]: KNeighborsClassifier(n_neighbors=1)

[8]: #Question 3-A : Evaluation du modèle sur les donénees d'entrainement

round(model.score(X_train, Y_train), 2)

[8]: 1.0

[9]: #Nous pouvons dire que 100% des données d'entrainement ont été bien utilisé

[10]: round(model.score(X_test, Y_test), 2)

#Nous pouvons dire que 93% des données de test ont donné des bons résultats

[10]: 0.93

1
 TD - TP1 Exercice III RNA

February 15, 2024

[1]: #Importation des bibliothèques

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import validation_curve

[2]: #Séparation des données en X = entrées et y = sortie

cancer = load_breast_cancer()
X = cancer.data
y = cancer.target

[3]: t = 0.2
X_train, X_test, Y_train, Y_test = train_test_split(X,y,test_size=t)
print("Train set : ", X_train.shape)
print("Test set : ", X_test.shape)

Train set : (455, 30)

Test set : (114, 30)

[4]: #Mise en place des différents modèles

model1 = KNeighborsClassifier(1)
model3 = KNeighborsClassifier(3)
model4 = KNeighborsClassifier(4)

[5]: #Entrainement du modèle 1 avec k = 1

model1.fit(X_train, Y_train)

[5]: KNeighborsClassifier(n_neighbors=1)

[6]: #Détermination du score du modèle 1

score1 = round(model1.score(X_test, Y_test), 2)

[7]: #Entrainement du modèle 3 avec k = 3

model3.fit(X_train, Y_train)

1
[7]: KNeighborsClassifier(n_neighbors=3)

[8]: #Détermination du score du modèle 3

score2 = round(model3.score(X_test, Y_test), 2)

[9]: #Entrainement du modèle 4 avec k = 4

model4.fit(X_train, Y_train)

[9]: KNeighborsClassifier(n_neighbors=4)

[10]: #Détermination du score du modèle 4

score3 = round(model4.score(X_test, Y_test), 2)

[11]: #Question 1 : Nous avons utilisé le jeu de données load_breast_cancer avec

# 80% de données d'entrainement et 20% de données de test
compare_score = pd.DataFrame(
{
'Model' : ['Model(k=1)', 'Model(k=3)', 'Model(k=4)'],
'Score' : [score1, score2, score3]
})

[12]: #Question 2 : Evaluation finale en conclusion pour k=4 nous obtenons le␣
↪meilleur score

print(compare_score)

Model Score
0 Model(k=1) 0.92
1 Model(k=3) 0.92
2 Model(k=4) 0.93

[13]: #Modification du découpage du jeu de données 60% de données d'entrainement et␣

↪40% de données de test

t = 0.4
X_train, X_test, Y_train, Y_test = train_test_split(X,y,test_size=t)
print("Train set : ", X_train.shape)
print("Test set : ", X_test.shape)

Train set : (341, 30)

Test set : (228, 30)

[14]: model1 = KNeighborsClassifier(1)

model3 = KNeighborsClassifier(3)
model4 = KNeighborsClassifier(4)

[15]: #paramètre du modèle 1

model1.fit(X_train, Y_train)
score1 = round(model1.score(X_test, Y_test), 2)

2
[16]: #paramètre du modèle 3
model3.fit(X_train, Y_train)
score2 = round(model3.score(X_test, Y_test), 2)

[17]: #paramètre du modèle 4

model4.fit(X_train, Y_train)
score3 = round(model4.score(X_test, Y_test), 2)

[18]: #Question 3 : les nouvelles performances obtenus sont ainsi affichées

compare_score = pd.DataFrame(
{
'Model' : ['Model(k=1)', 'Model(k=3)', 'Model(k=4)'],
'Score' : [score1, score2, score3]
})
print(compare_score)

Model Score
0 Model(k=1) 0.91
1 Model(k=3) 0.92
2 Model(k=4) 0.92

[19]: #Nous constatons que le modèle 3 reste le meilleur

[20]: #Question 4 : Importation des bibliothèques nécessaires

[21]: #Question 4 - B :
cross_val_score(KNeighborsClassifier(), X_train, Y_train, cv = 5, scoring =␣
↪'accuracy')

[21]: array([0.94202899, 0.94117647, 0.95588235, 0.91176471, 0.88235294])

[22]: #Question 4 - C : Enregistrement des données

val_score = []
for k in range(1,50):
score = cross_val_score(KNeighborsClassifier(k), X_train, Y_train, cv = 5,␣
↪scoring = 'accuracy').mean()

val_score.append(score)

print(val_score)

[0.9090366581415175, 0.9002557544757034, 0.9207587382779199, 0.9208013640238704,

0.9266410912190963, 0.9236999147485081, 0.9384057971014494, 0.9384057971014494,
0.9295822676896845, 0.9325234441602728, 0.935464620630861, 0.929624893435635,
0.9325234441602728, 0.9325234441602728, 0.9295822676896845, 0.9266837169650468,
0.9295822676896845, 0.9237425404944586, 0.9208013640238704, 0.920843989769821,
0.915004262574595, 0.9091219096334185, 0.9179028132992327, 0.9179028132992327,
0.9120630861040068, 0.9120630861040068, 0.9091219096334185, 0.9062233589087809,
0.9061807331628303, 0.9032395566922421, 0.9061381074168798, 0.9002557544757034,
0.9031969309462916, 0.9031969309462916, 0.9032395566922421, 0.9032395566922421,

3
 0.9003410059676045, 0.9003410059676045, 0.9003410059676045, 0.9003410059676045,
0.9032821824381927, 0.8973998294970162, 0.8973998294970162, 0.8973998294970162,
0.8973998294970162, 0.9003410059676045, 0.9032821824381927, 0.9003410059676045,
0.9003410059676045]

[23]: #Question 4 - D : Traçons les différents scores obtenus

plt.grid(True)
plt.plot(val_score, marker="+")
plt.xlabel('Les valeurs des k-voisins')
plt.ylabel('Les valeurs des différentes moyennes des scores')

[23]: Text(0, 0.5, 'Les valeurs des différentes moyennes des scores')

[34]: #Le modèle obtenu est le modèle k = 7 et k = 8 nous avons les mêmes valeurs
#car ils ont obtenu score = 0.9384057971014494

[25]: #Question E : Vérification des dimensions de train_score et de val_score

model = KNeighborsClassifier()
k = np.arange(1,50)
train_score, val_score = validation_curve(model, X_train, Y_train, param_name =␣
↪'n_neighbors', param_range=k, cv=5)

4
[26]: #Affichons la dimension de train_score
print(train_score.shape)

(49, 5)

[27]: #Affichons la dimension de val_score

print(val_score.shape)

(49, 5)

[28]: #Question F : visualisons les différents scores moyens en fonction du nombre de␣
↪voisin

plt.grid(True)
plt.plot(k, val_score.mean(axis=1), label='validation', marker='+')
plt.ylabel('score')
plt.xlabel('n_neighbors')

[28]: Text(0.5, 0, 'n_neighbors')

[29]: #Question G : Affichons la moyenne des données obtenus sur le jeu␣

↪d'entrainement

plt.grid(True)

5
 plt.plot(k, train_score.mean(axis=1), color="r", label='validation', marker='+')
plt.ylabel('train')
plt.xlabel('n_neighbors')

[29]: Text(0.5, 0, 'n_neighbors')

[30]: #Nous remarquons que plus le nombre de voisins augmentent le score des données␣
↪entrainés diminue au fur et à mesure

[31]: #Pour afficher les

model1 = KNeighborsClassifier()
k = np.arange(1,50)
test_score, val_score1 = validation_curve(model1, X_test, Y_test, param_name =␣
↪'n_neighbors', param_range=k, cv=5)

[32]: #Question H : Affichons les données obtenus sur le jeu de test

plt.grid(True)
plt.plot(k, test_score.mean(axis=1), color="g", label='test', marker='+')
plt.ylabel('test')
plt.xlabel('n_neighbors')

6
[32]: Text(0.5, 0, 'n_neighbors')

[33]: #Nous remarquons que plus le nombre de voisins augmentent le score des données␣
↪de test diminue au fur et à mesure

7
 TD - TP1 Exercice IV RNA

February 16, 2024

[1]: #Importation des bibliothèques

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import confusion_matrix
import warnings
warnings.filterwarnings("ignore")

[2]: #Séparation des données en X = entrées et y = sortie

cancer = load_breast_cancer()
X = cancer.data
y = cancer.target

[3]: #Division des données en entrainement et test

t = 0.2
X_train, X_test, Y_train, Y_test = train_test_split(X,y,test_size=t)
print("Train set : ", X_train.shape)
print("Test set : ", X_test.shape)

Train set : (455, 30)

Test set : (114, 30)

[4]: #création du model

model = KNeighborsClassifier()

[5]: #Question I : création du dictionnaire qui contient les hyperparamètres

param_grid = {'n_neighbors': np.arange(1,50), 'metric': ["euclidian",␣
↪"manhattan"]}

[6]: #Question II : Construction de la grille avec plusieurs estimateurs à l'aide de␣

↪GridSearchCV

Grid = GridSearchCV(model, param_grid, cv=5)

1
[7]: #Question III : Entrainons le modèle avec les différentes combinaisons
Grid.fit(X_train, Y_train)

[7]: GridSearchCV(cv=5, estimator=KNeighborsClassifier(),

param_grid={'metric': ['euclidian', 'manhattan'],
'n_neighbors': array([ 1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49])})

[8]: #Question 4 : Affichons le meilleur paramètre du modèle

Grid.best_params_

[8]: {'metric': 'manhattan', 'n_neighbors': 7}

[9]: #Affichons le meilleur score

Grid.best_score_

[9]: 0.9494505494505494

[10]: #Question 5 : sauvegarde du modèle

model_save = Grid.best_estimator_

[11]: #Question 6 : Evaluons les performances du model

round(model_save.score(X_test, Y_test), 2)

[11]: 0.92

[12]: #Question 7 : Mesurons la performance avec la matrice de confusion

confusion_matrix(Y_test, model_save.predict(X_test))

[12]: array([[35, 7],

[ 2, 70]], dtype=int64)

[14]: #Interprétation des résultats

#nous avons constaté que sur les 114 données de test nous avons
# True Positive = 35 des cas testés non-malade sont effectivement prédits␣
↪non-malade

# True Negatif = 7 des cas sont testés non-malades sont prédits malades
# False Positif = 2 des cas sont testés malades sont prédits non malades
# False Negatif = 70 des cas sont testés malades sont effectivement prédits␣
↪malades

2
 TD - TP1 Exercice V RNA

February 15, 2024

[5]: #Importation des bibliothèques

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import learning_curve

[6]: #Séparation des données en X = entrées et y = sortie

cancer = load_breast_cancer()
X = cancer.data
y = cancer.target

[7]: #Division des données en entrainement et test

t = 0.2
X_train, X_test, Y_train, Y_test = train_test_split(X,y,test_size=t)
print("Train set : ", X_train.shape)
print("Test set : ", X_test.shape)

Train set : (455, 30)

Test set : (114, 30)

[8]: #création du model

model = KNeighborsClassifier()

[9]: debut = 0.1

fin = 1
lots = 10
N, train_score, val_score = learning_curve(model, X_train, Y_train, train_sizes␣
↪= np.linspace(debut, fin, lots), cv = 5)

[11]: #Question 1 : C'est un vecteur qui contient le nombre d'exemples d'entrainement␣

↪qui ont été utlisés pour générer la courbe d'apprentissage

print(N)

[ 36 72 109 145 182 218 254 291 327 364]

1
[12]: #Question 2 : Visualisons la courbe des scores moyens
plt.grid(True)
plt.plot(N, val_score.mean(axis=1), color = "r", marker = "+",␣
↪label="validation")

plt.ylabel('Score')
plt.xlabel('Train Sizes')

[12]: Text(0.5, 0, 'Train Sizes')

[29]: #Question 3 : Visualisons les données d'apprentissage et d'entrainement

plt.grid(True)
plt.plot(N, val_score.mean(axis=1), color = "r", marker = "+",␣
↪label="Validation")

plt.plot(N, train_score.mean(axis=1), color = "b", marker = "+",␣

↪label="Entrainement")

plt.legend()
plt.show()

2
[24]: #Nous pouvons dire qu'il n'est plus nécessaire de collecter les données car à␣
↪partir de 300 les scores semblent se stabiliser