Skip to content
GitLab
Explore
Sign in
Primary navigation
Search or go to…
Project
M
Machine_Learning
Manage
Activity
Members
Labels
Plan
Issues
Issue boards
Milestones
Wiki
Code
Merge requests
Repository
Branches
Commits
Tags
Repository graph
Compare revisions
Snippets
Deploy
Releases
Package registry
Model registry
Operate
Terraform modules
Monitor
Incidents
Analyze
Value stream analytics
Contributor analytics
Repository analytics
Model experiments
Help
Help
Support
GitLab documentation
Compare GitLab plans
GitLab community forum
Contribute to GitLab
Provide feedback
Terms and privacy
Keyboard shortcuts
?
Snippets
Groups
Projects
Show more breadcrumbs
Dellandrea Emmanuel
Machine_Learning
Commits
d20f423d
Commit
d20f423d
authored
5 months ago
by
Dellandrea Emmanuel
Browse files
Options
Downloads
Patches
Plain Diff
Create rn_regression-complet.py
parent
a9745490
No related branches found
No related tags found
No related merge requests found
Changes
1
Show whitespace changes
Inline
Side-by-side
Showing
1 changed file
TD/TD4/rn_regression-complet.py
+346
-0
346 additions, 0 deletions
TD/TD4/rn_regression-complet.py
with
346 additions
and
0 deletions
TD/TD4/rn_regression-complet.py
0 → 100644
+
346
−
0
View file @
d20f423d
import
matplotlib.pyplot
as
plt
import
numpy
as
np
def
lecture_donnees
(
nom_fichier
,
delimiteur
=
'
,
'
):
"""
Lit le fichier contenant les données et renvoiee les matrices correspondant
Parametres
----------
nom_fichier : nom du fichier contenant les données
delimiteur : caratère délimitant les colonne dans le fichier (
"
,
"
par défaut)
Retour
-------
x : matrice des données de dimension [N, nb_var]
d : matrice contenant les valeurs de la variable cible de dimension [N, nb_cible]
N : nombre d
'
éléments
nb_var : nombre de variables prédictives
nb_cible : nombre de variables cibles
"""
data
=
np
.
loadtxt
(
nom_fichier
,
delimiter
=
delimiteur
)
nb_cible
=
1
nb_var
=
data
.
shape
[
1
]
-
nb_cible
N
=
data
.
shape
[
0
]
x
=
data
[:,
:
nb_var
]
d
=
data
[:,
nb_var
:].
reshape
(
N
,
1
)
return
x
,
d
,
N
,
nb_var
,
nb_cible
def
normalisation
(
x
):
"""
Normalise les données par un centrage-réduction des variables prédictives
Parametres
----------
X : matrice des données de dimension [N, nb_var]
avec N : nombre d
'
éléments et nb_var : nombre de variables prédictives
Retour
-------
X_norm : matrice des données centrées-réduites de dimension [N, nb_var]
mu : moyenne des variables de dimension [1,nb_var]
sigma : écart-type des variables de dimension [1,nb_var]
"""
mu
=
np
.
mean
(
x
,
0
)
sigma
=
np
.
std
(
x
,
0
)
x_norm
=
(
x
-
mu
)
/
sigma
return
x_norm
,
mu
,
sigma
def
decoupage_donnees
(
x
,
d
,
prop_val
=
0.2
,
prop_test
=
0.2
):
"""
Découpe les données initiales en trois sous-ensembles distincts d
'
apprentissage, de validation et de test
Parametres
----------
x : matrice des données de dimension [N, nb_var]
d : matrice des valeurs cibles [N, nb_cible]
prop_val : proportion des données de validation sur l
'
ensemble des données (entre 0 et 1)
prop_test : proportion des données de test sur l
'
ensemble des données (entre 0 et 1)
avec N : nombre d
'
éléments, nb_var : nombre de variables prédictives, nb_cible : nombre de variables cibles
Retour
-------
x_app : matrice des données d
'
apprentissage
d_app : matrice des valeurs cibles d
'
apprentissage
x_val : matrice des données d
'
apprentissage
d_val : matrice des valeurs cibles d
'
apprentissage
x_test : matrice des données d
'
apprentissage
d_test : matrice des valeurs cibles d
'
apprentissage
"""
assert
prop_val
+
prop_test
<
1.0
N
=
x
.
shape
[
0
]
indices
=
np
.
arange
(
N
)
np
.
random
.
shuffle
(
indices
)
nb_val
=
int
(
N
*
prop_val
)
nb_test
=
int
(
N
*
prop_test
)
nb_app
=
N
-
nb_val
-
nb_test
x
=
x
[
indices
,:]
d
=
d
[
indices
,:]
x_app
=
x
[:
nb_app
,:]
d_app
=
d
[:
nb_app
,:]
x_val
=
x
[
nb_app
:
nb_app
+
nb_val
,:]
d_val
=
d
[
nb_app
:
nb_app
+
nb_val
,:]
x_test
=
x
[
N
-
nb_test
:,:]
d_test
=
d
[
N
-
nb_test
:,:]
return
x_app
,
d_app
,
x_val
,
d_val
,
x_test
,
d_test
def
calcule_cout_mse
(
y
,
d
):
"""
Calcule la valeur de la fonction cout MSE (moyenne des différences au carré)
Parametres
----------
y : matrice des données prédites
d : matrice des données réelles
Return
-------
cout : nombre correspondant à la valeur de la fonction cout (moyenne des différences au carré)
"""
N
=
y
.
shape
[
1
]
cout
=
np
.
square
(
y
-
d
).
sum
()
/
2
/
N
return
cout
def
passe_avant
(
x
,
W
,
b
,
activation
):
"""
Réalise une passe avant dans le réseau de neurones
Parametres
----------
x : matrice des entrées, de dimension nb_var x N
W : liste contenant les matrices des poids du réseau
b : liste contenant les matrices des biais du réseau
activation : liste contenant les fonctions d
'
activation des couches du réseau
avec N : nombre d
'
éléments, nb_var : nombre de variables prédictives
Return
-------
a : liste contenant les potentiels d
'
entrée des couches du réseau
h : liste contenant les sorties des couches du réseau
"""
h
=
[
x
]
a
=
[]
for
i
in
range
(
len
(
b
)):
a
.
append
(
W
[
i
].
dot
(
h
[
i
])
+
b
[
i
]
)
h
.
append
(
activation
[
i
](
a
[
i
])
)
return
a
,
h
def
passe_arriere
(
delta_h
,
a
,
h
,
W
,
activation
):
"""
Réalise une passe arrière dans le réseau de neurones (rétropropagation)
Parametres
----------
delta_h : matrice contenant les valeurs du gradient du coût par rapport à la sortie du réseau
a : liste contenant les potentiels d
'
entrée des couches du réseau
h : liste contenant les sorties des couches du réseau
W : liste contenant les matrices des poids du réseau
activation : liste contenant les fonctions d
'
activation des couches du réseau
Return
-------
delta_W : liste contenant les matrice des gradients des poids des couches du réseau
delta_b : liste contenant les matrice des gradients des biais des couches du réseau
"""
delta_b
=
[]
delta_W
=
[]
for
i
in
range
(
len
(
W
)
-
1
,
-
1
,
-
1
):
delta_a
=
delta_h
*
activation
[
i
](
a
[
i
],
True
)
delta_b
.
append
(
delta_a
.
mean
(
1
).
reshape
(
-
1
,
1
)
)
delta_W
.
append
(
delta_a
.
dot
(
h
[
i
].
T
)
)
delta_h
=
(
W
[
i
].
T
).
dot
(
delta_a
)
delta_b
=
delta_b
[::
-
1
]
delta_W
=
delta_W
[::
-
1
]
return
delta_W
,
delta_b
def
sigmoide
(
z
,
deriv
=
False
):
"""
Calcule la valeur de la fonction sigmoide ou de sa dérivée appliquée à z
Parametres
----------
z : peut être un scalaire ou une matrice
deriv : booléen. Si False renvoie la valeur de la fonction sigmoide, si True renvoie sa dérivée
Return
-------
s : valeur de la fonction sigmoide appliquée à z ou de sa dérivée. Même dimension que z
"""
s
=
1
/
(
1
+
np
.
exp
(
-
z
))
if
deriv
:
return
s
*
(
1
-
s
)
else
:
return
s
def
lineaire
(
z
,
deriv
=
False
):
"""
Calcule la valeur de la fonction linéaire ou de sa dérivée appliquée à z
Parametres
----------
z : peut être un scalaire ou une matrice
deriv : booléen. Si False renvoie la valeur de la fonction linéire, si True renvoie sa dérivée
Return
-------
s : valeur de la fonction linéaire appliquée à z ou de sa dérivée. Même dimension que z
"""
if
deriv
:
return
1
else
:
return
z
def
relu
(
z
,
deriv
=
False
):
"""
Calcule la valeur de la fonction relu ou de sa dérivée appliquée à z
Parametres
----------
z : peut être un scalaire ou une matrice
deriv : booléen. Si False renvoie la valeur de la fonction relu, si True renvoie sa dérivée
Return
-------
s : valeur de la fonction relu appliquée à z ou de sa dérivée. Même dimension que z
"""
r
=
np
.
zeros
(
z
.
shape
)
if
deriv
:
pos
=
np
.
where
(
z
>=
0
)
r
[
pos
]
=
1.0
return
r
else
:
return
np
.
maximum
(
r
,
z
)
# ===================== Partie 1: Lecture et normalisation des données =====================
print
(
"
Lecture des données ...
"
)
x
,
d
,
N
,
nb_var
,
nb_cible
=
lecture_donnees
(
"
food_truck.txt
"
)
# x, d, N, nb_var, nb_cible = lecture_donnees("houses.txt")
# Affichage des 10 premiers exemples du dataset
print
(
"
Affichage des 10 premiers exemples du dataset :
"
)
for
i
in
range
(
0
,
10
):
print
(
f
"
x =
{
x
[
i
,
:
]
}
, d =
{
d
[
i
]
}
"
)
# Normalisation des variables (centrage-réduction)
print
(
"
Normalisation des variables ...
"
)
x
,
mu
,
sigma
=
normalisation
(
x
)
dmax
=
d
.
max
()
d
=
d
/
dmax
# Découpage des données en sous-ensemble d'apprentissage, de validation et de test
x_app
,
d_app
,
x_val
,
d_val
,
x_test
,
d_test
=
decoupage_donnees
(
x
,
d
)
# ===================== Partie 2: Apprentissage =====================
# Choix du taux d'apprentissage et du nombre d'itérations
alpha
=
0.001
nb_iters
=
500
couts_apprentissage
=
np
.
zeros
(
nb_iters
)
couts_validation
=
np
.
zeros
(
nb_iters
)
# Dimensions du réseau
D_c
=
[
nb_var
,
5
,
10
,
nb_cible
]
# liste contenant le nombre de neurones pour chaque couche
activation
=
[
relu
,
sigmoide
,
lineaire
]
# liste contenant les fonctions d'activation des couches cachées et de la couche de sortie
# Initialisation aléatoire des poids du réseau
W
=
[]
b
=
[]
for
i
in
range
(
len
(
D_c
)
-
1
):
W
.
append
(
2
*
np
.
random
.
random
((
D_c
[
i
+
1
],
D_c
[
i
]))
-
1
)
b
.
append
(
np
.
zeros
((
D_c
[
i
+
1
],
1
)))
x_app
=
x_app
.
T
# Les données sont présentées en entrée du réseau comme des vecteurs colonnes
d_app
=
d_app
.
T
x_val
=
x_val
.
T
# Les données sont présentées en entrée du réseau comme des vecteurs colonnes
d_val
=
d_val
.
T
x_test
=
x_test
.
T
# Les données sont présentées en entrée du réseau comme des vecteurs colonnes
d_test
=
d_test
.
T
for
t
in
range
(
nb_iters
):
#############################################################################
# Passe avant : calcul de la sortie prédite y sur les données de validation #
#############################################################################
a
,
h
=
passe_avant
(
x_val
,
W
,
b
,
activation
)
y_val
=
h
[
-
1
]
# Sortie prédite
###############################################################################
# Passe avant : calcul de la sortie prédite y sur les données d'apprentissage #
###############################################################################
a
,
h
=
passe_avant
(
x_app
,
W
,
b
,
activation
)
y_app
=
h
[
-
1
]
# Sortie prédite
###########################################
# Calcul de la fonction perte de type MSE #
###########################################
couts_apprentissage
[
t
]
=
calcule_cout_mse
(
y_app
,
d_app
)
couts_validation
[
t
]
=
calcule_cout_mse
(
y_val
,
d_val
)
####################################
# Passe arrière : rétropropagation #
####################################
delta_h
=
(
y_app
-
d_app
)
# Pour la dernière couche
delta_W
,
delta_b
=
passe_arriere
(
delta_h
,
a
,
h
,
W
,
activation
)
#############################################
# Mise à jour des poids et des biais ##### #
#############################################
for
i
in
range
(
len
(
b
)
-
1
,
-
1
,
-
1
):
b
[
i
]
-=
alpha
*
delta_b
[
i
]
W
[
i
]
-=
alpha
*
delta_W
[
i
]
print
(
"
Coût final sur l
'
ensemble d
'
apprentissage :
"
,
couts_apprentissage
[
-
1
])
print
(
"
Coût final sur l
'
ensemble de validation :
"
,
couts_validation
[
-
1
])
# Affichage de l'évolution de la fonction de cout lors de la rétropropagation
plt
.
figure
(
0
)
plt
.
title
(
"
Evolution de le fonction de coût lors de la retropropagation
"
)
plt
.
plot
(
np
.
arange
(
couts_apprentissage
.
size
),
couts_apprentissage
,
label
=
"
Apprentissage
"
)
plt
.
plot
(
np
.
arange
(
couts_validation
.
size
),
couts_validation
,
label
=
"
Validation
"
)
plt
.
legend
(
loc
=
"
upper left
"
)
plt
.
xlabel
(
"
Nombre d
'
iterations
"
)
plt
.
ylabel
(
"
Coût
"
)
plt
.
show
()
# ===================== Partie 3: Evaluation sur l'ensemble de test =====================
#######################################################################
# Passe avant : calcul de la sortie prédite y sur les données de test #
#######################################################################
a
,
h
=
passe_avant
(
x_test
,
W
,
b
,
activation
)
y_test
=
h
[
-
1
]
# Sortie prédite
cout
=
calcule_cout_mse
(
y_test
,
d_test
)
print
(
"
Coût sur l
'
ensemble de test :
"
,
cout
)
This diff is collapsed.
Click to expand it.
Preview
0%
Loading
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Save comment
Cancel
Please
register
or
sign in
to comment