Université Batna2,

Module Deep Learning TP1 (Master 2 SDS) 2020/2021

TP N°1
L’objectif du premier TP est de réviser le 4 notions clefs de machine Learning et leur implémentation
avec python.

Donc premièrement installé Anaconda puis utiliser le Notebook.

Rappel Python
Anaconda contient tous les outils et librairies dont vous avez besoin pour faire du Machine Learning :
Numpy, Matplotlib, Sklearn, etc. Commencez par télécharger puis installer Anaconda depuis le site
officiel : https://www.anaconda.com/products/individual#download-section

Les librairies à maîtriser pour le Machine Learning : Pour importer une librairie dans Python sont
numpy, matplotlib, sklearn et pandas et pour le Deep Learning il y a tensorflow. Il suffit d’écrire le nom
de la librairie précédé de « import » en tête de votre programme. Il est également possible d’importer
certaines fonctions de la librairie en écrivant from « librairie » import « truc ».

Numpy est la librairie qui permet de créer et manipuler des matrices

simplement et avec efficacité. En Machine Learning, on insère le plus
souvent notre Dataset dans des matrices. Ainsi le calcul matriciel représente
l’essentiel du Machine Learning. Il est important de le comprendre, mais les
fonctions présentes dans Numpy font les calculs matriciels à notre place

Matplotlib est la librairie qui permet de visualiser nos Datasets, nos

fonctions, nos résultats sous forme de graphes, courbes et nuages de points.

Sklearn est la librairie qui contient toutes les fonctions de l’état de l’art du
Machine Learning. On y trouve les algorithmes les plus importants ainsi que
diverses fonctions de pre-processing.

La bibliothèque Keras permet d'interagir avec les algorithmes de réseau de

neurones. Elle est conçue pour permettre une expérimentation rapide avec
les réseaux de neurones profond, et elle se concentre sur son ergonomie, sa
modularité et ses capacités d’extension.

Est une librairie dédié pour les réseau de neurone, Cette bibliothèque
permet notamment d’entraîner et d’exécuter des réseaux de neurones
pour la classification de chiffres écrits à la main, la reconnaissance d’image,
les plongements de mots, les réseaux de neurones récurrents, les modèles
sequence-to-sequence pour la traduction automatique, ou encore le
traitement naturel du langage.

Concernant le code python pour les débutants voir le document suivant : Programmation Scientifique
avec Python

1
Université Batna2,
Module Deep Learning TP1 (Master 2 SDS) 2020/2021
Rappel : Les 4 notions clefs du Machine Learning
Le Machine Learning est un domaine vaste et complexe. Vous devez ainsi retenir 4 notions essentielles,
et vous verrez qu’elles vous suivront dans tous vos projets de Machine Learning et Deep Learning.

1. Le Dataset : En Machine Learning, tout démarre d’un Dataset qui contient nos données. Dans
l’apprentissage supervisé, le Dataset contient les questions (𝑦) et les réponses (x) au problème que la
machine doit résoudre.

2. Le modèle et ses paramètres : A partir de ce Dataset, on crée un modèle, qui n’est autre qu’une
fonction mathématique. Les coefficients de cette fonction sont les paramètres du modèle.

3. La Fonction Coût : Lorsqu’on teste notre modèle sur le Dataset, celui-ci nous donne des erreurs.
L’ensemble de ces erreurs, c’est ce qu’on appelle la Fonction Coût.

4. L’Algorithme d’apprentissage : L’idée centrale du Machine Learning, c’est de laisser la machine

trouver quels sont les paramètres de notre modèle qui minimisent la Fonction Coût.

Pour implémenter ces 4 étapes en python, nous devons suivre les étapes suivantes :

1- Préparer le DataSet. La machine reçoit des données caractérisées par des variables X (appelés
features) et annotées d’une variable y (appelé Label ou target).
2- Sélectionner quel type de modèle (ou l’estimateur) la machine doit apprendre, en précisant
les hyperparamètres du modèle.
Exemple en python : model = LinearRegression(……)

3- Entrainer le modèle sur les données X et Y (diviser en deux tableaux ou matrices Numpy),
exemple en python : model.fit(X,Y)
4- Evaluer le modèle ; model.score(X,Y)
5- Utilisé le modèle ; model.predict(x’)

2
Université Batna2,
Module Deep Learning TP1 (Master 2 SDS) 2020/2021
Exercice 1 : Développer un premier programme de Machine Learning (régression
linéaire)
Etape 1 : Importer les librairies

Commençons par ouvrir un nouveau Notebook dans Jupyter. Ensuite, il faut importer les librairies et
fonctions suivantes :

• Numpy pour manipuler notre Dataset en tant que matrice

• Matplotlib.pyplot pour visualiser nos données
• La fonction make_regression de Sklearn pour générer un nuage de point (ici on va simuler des
données)
• SGDRegressor (qui signifie Stochastic Gradient Descent Regressor) et qui contient le calcul de
la Fonction Coût, des gradients, de l’algorithme de minimisation.
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression
from sklearn.linear_model import SGDRegressor
Etape 2 : Créer un Dataset

Pour ce premier code, nous n’allons pas importer de données personnelles. Plutôt, nous allons générer
un tableau de données (𝒚,𝒛) aléatoires. Pour cela, la fonction make_regression() est très utile. La
fonction prend comme arguments le nombre d’échantillons à générer, le nombre de variables et le
bruit puis nous retourne deux vecteurs 𝒚 et 𝒛.

Pour maitriser l’aléatoire, on écrit la ligne np.random.seed(0). Finalement, pour visualiser nos données
on utilise la fonction plt.scatter(x, y).
np.random.seed(0)
x, y = make_regression(n_samples=100, n_features=1, noise=10)
plt.scatter(x, y)
Voici le résultat que vous devriez obtenir :

Etape 3 : Développer le modèle et l’entraîner

Il vous suffit de définir une variable model depuis le générateur SGDRegressor en entrant le nombre
d’itérations que le Gradient Descent doit effectuer ainsi que le Learning Rate. Une fois le modèle défini,
il vous faut l’entraîner. Pour cela, il suffit d’utiliser la fonction fit. Par exemple, entraînons notre modèle
sur 100 itérations avec un Learning rate (taux d’apprentissage) de 0.0001 :
model = SGDRegressor(max_iter=100, eta0=0.0001)
model.fit(x,y)
Nous pouvons maintenant observez la précision de notre modèle en utilisant la fonction score qui
calcule le coefficient de détermination entre le modèle et les valeurs 𝒛 de notre Dataset.

3
Université Batna2,
Module Deep Learning TP1 (Master 2 SDS) 2020/2021
On peut aussi utiliser notre modèle pour faire de nouvelles prédictions avec la fonction predict et tracer
ces résultats avec la fonction plt.plot :
print('Coeff R2 =', model.score(x, y))
plt.scatter(x, y)
plt.plot(x, model.predict(x), c='red', lw = 3)

Exercice 2 : Problème non-linéaire

Pour le nuage de point ci-dessous, il semblerait judicieux de développer un modèle polynômial de
degré 2.

En fait, le code que nous avons écrit pour la régression linéaire peut être utilisé pour des problèmes
bien plus complexes. Il suffit de générer des variables polynômiales dans notre Dataset en utilisant la
fonction PolynomialFeatures présente dans Sklearn.
from sklearn.preprocessing import PolynomialFeatures

Grâce au calcul matriciel (présent dans Numpy et Sklearn) la machine peut intégrer ces nouvelles
variables polynômiales sans changer son calcul ! Dans l’exemple ci-dessous, nous avons choisi d’ajouter
une variable polynômiale de degré 2 pour forcer la machine à développer un modèle qui affiche un
parabolique de 𝒛 en fonction de 𝒚.
np.random.seed(0)
# création du Dataset
x, y = make_regression(n_samples=100, n_features=1, noise=10)
y = y**2 # y ne varie plus linéairement selon x !
# On ajoute des variables polynômiales dans notre dataset
poly_features = PolynomialFeatures(degree=2, include_bias=False)
x = poly_features.fit_transform(x)
plt.scatter(x[:,0], y)
x.shape # la dimension de x: 100 lignes et 2 colonnes
…………
Compléter le code python ci-dessus pour entrainer le modèle et affiche la courbe en rouge

4
Université Batna2,
Module Deep Learning TP1 (Master 2 SDS) 2020/2021

Après l’entrainement→

Exercice 3
Réaliser en python la fonction qui calcule le quadratique moyenne la perte d'entropie croisée :

1
𝑓= ∑𝑛𝑖=0(𝑦𝑖 − 𝑥𝑖 )2 et 𝑔 = −[𝑦. log(𝑝) + (1 − 𝑦). log (1 − 𝑝)]
𝑛

où y est un indicateur binaire (0 ou 1) si l'étiquette de classe observée correspond à la classe

correcte et p est la probabilité prédite.