Chapitre 3 - Concepts de Base

Introduction
Dans ce chapitre, nous allons explorer les concepts fondamentaux du Machine Learning. Ces
notions sont essentielles pour comprendre comment les algorithmes de Machine Learning
fonctionnent et comment les utiliser efficacement.

1. Algorithmes et Modèles
Qu'est-ce qu'un Algorithme ?
Un algorithme est une série d'instructions précises permettant de résoudre un problème ou
de réaliser une tâche. Dans le contexte du Machine Learning, un algorithme prend des
données en entrée et les transforme pour produire des résultats ou des prédictions.

Qu'est-ce qu'un Modèle ?

Un modèle est le résultat de l'application d'un algorithme sur des données. Il représente la
"compréhension" de l'algorithme des données et peut être utilisé pour faire des prédictions
sur de nouvelles données. Par exemple, un modèle de régression linéaire pourrait être utilisé
pour prédire le prix d'une maison en fonction de ses caractéristiques (taille, emplacement,
etc.).

Exemples d'Algorithmes et de Modèles

Régression Linéaire : Utilisé pour prédire une valeur continue en fonction de variables
indépendantes.
K-Means Clustering : Utilisé pour regrouper des données non étiquetées en clusters.
Réseaux de Neurones : Utilisés pour des tâches complexes comme la reconnaissance
d'image et de voix.

2. Données et Prétraitement
Importance des Données
Les données sont au cœur du Machine Learning. La qualité et la quantité des données
disponibles affectent directement les performances des modèles. Il est crucial de collecter et
de préparer correctement les données avant de les utiliser pour entraîner un modèle.
Étapes de Prétraitement des Données
1. Collecte des Données : Rassembler les données à partir de diverses sources (bases de
données, fichiers CSV, API, etc.).
2. Nettoyage des Données : Supprimer ou corriger les données incorrectes, manquantes ou
dupliquées.
3. Transformation des Données : Convertir les données en un format approprié pour
l'algorithme (par exemple, normaliser les valeurs numériques, encoder les catégories).
4. Division des Données : Séparer les données en ensembles d'entraînement et de test pour
évaluer la performance du modèle.

Techniques de Prétraitement
Normalisation : Ajuster les valeurs des données pour qu'elles se situent dans une même
échelle.
Encodage : Convertir des données catégorielles en données numériques (par exemple,
utiliser le one-hot encoding).
Imputation : Remplacer les valeurs manquantes par des estimations (par exemple, la
moyenne ou la médiane).

Qu'est-ce que le One Hot Encoding ?

Introduction
Le One Hot Encoding est une technique de transformation des données utilisée en Machine
Learning pour convertir des variables catégorielles en un format numérique que les
algorithmes peuvent utiliser efficacement. Cette méthode est particulièrement utile lorsque
les données comprennent des caractéristiques qui prennent des valeurs discrètes, non
ordonnées, comme les couleurs, les pays ou les types de produits.

Pourquoi Utiliser le One Hot Encoding ?

Les algorithmes de Machine Learning fonctionnent mieux avec des données numériques
continues. Cependant, de nombreuses données réelles contiennent des variables
catégorielles. Par exemple, si une colonne d'un dataset contient les valeurs "Rouge", "Vert" et
"Bleu", il serait difficile pour un algorithme de traitement de comprendre et de traiter ces
chaînes de caractères. Le One Hot Encoding permet de résoudre ce problème en
convertissant ces catégories en une forme numérique binaire.

Comment Fonctionne le One Hot Encoding ?

Le principe du One Hot Encoding est de créer une colonne binaire (0 ou 1) pour chaque
catégorie possible de la variable. Voici un exemple illustratif :
Imaginons un dataset avec une colonne "Couleur" qui contient les valeurs suivantes :
"Rouge", "Vert", "Bleu".
Original :

Couleur
Rouge
Vert
Bleu
Rouge
Après application du One Hot Encoding, nous obtenons :
One Hot Encoded :

Rouge Vert Bleu

1 0 0
0 1 0
0 0 1
1 0 0
Chaque ligne du dataset initial est transformée en une combinaison de colonnes binaires, où
une seule des colonnes prend la valeur 1, indiquant la présence de cette catégorie.

Avantages du One Hot Encoding

1. Simplicité et Efficacité : Facile à comprendre et à mettre en œuvre.
2. Compatibilité avec les Algorithmes : Convient à de nombreux algorithmes de Machine
Learning qui nécessitent des entrées numériques.
3. Préserve les Informations : Toutes les catégories originales sont conservées dans le
nouveau format.

Inconvénients du One Hot Encoding

1. Explosion Dimensionnelle : Si une variable catégorielle a un grand nombre de catégories
distinctes, le One Hot Encoding peut créer un nombre énorme de nouvelles colonnes, ce
qui peut rendre le modèle plus complexe et moins performant.
2. Redondance : Pour certaines méthodes, la transformation peut introduire de la
redondance, car l’information est dispersée sur plusieurs colonnes.
Mise en Œuvre du One Hot Encoding en Python
Voici un exemple de mise en œuvre du One Hot Encoding en Python à l'aide de la
bibliothèque pandas :

import pandas as pd

# Exemple de données
data = {'Couleur': ['Rouge', 'Vert', 'Bleu', 'Rouge']}
df = pd.DataFrame(data)

# Application du One Hot Encoding

one_hot_encoded_df = pd.get_dummies(df, columns=['Couleur'])

print(one_hot_encoded_df)

Sortie :

Couleur_Bleu Couleur_Rouge Couleur_Vert

0 0 1 0
1 0 0 1
2 1 0 0
3 0 1 0

Conclusion
Le One Hot Encoding est une méthode essentielle pour transformer des variables
catégorielles en données numériques que les algorithmes de Machine Learning peuvent
utiliser. Bien qu'il présente certains défis, notamment l'explosion dimensionnelle, ses
avantages en font une technique incontournable dans le prétraitement des données. En
utilisant des outils comme pandas, la mise en œuvre du One Hot Encoding devient simple et
rapide, permettant de se concentrer sur l'amélioration des modèles de Machine Learning.

3. Entraînement et Validation
Entraînement d'un Modèle
L'entraînement d'un modèle consiste à ajuster ses paramètres pour minimiser l'erreur sur les
données d'entraînement. Cela implique de faire passer les données à travers l'algorithme et
de mettre à jour les paramètres en fonction des erreurs commises.

Processus d'Entraînement
L'entraînement d'un modèle de Machine Learning est une étape cruciale où l'algorithme
apprend à partir des données pour faire des prédictions précises. Le processus
d'entraînement peut être divisé en plusieurs sous-étapes : initialisation, propagation avant,
calcul de l'erreur, et rétropropagation. Examinons chaque étape en détail.

1. Initialisation
La première étape de l'entraînement d'un modèle consiste à initialiser les paramètres du
modèle. Ces paramètres peuvent être des poids dans un réseau de neurones ou des
coefficients dans une régression linéaire. L'initialisation est souvent réalisée de manière
aléatoire ou à l'aide de méthodes spécifiques pour garantir un bon point de départ pour
l'apprentissage.

Exemple : Initialisation dans un Réseau de Neurones

import numpy as np

# Initialisation aléatoire des poids pour un réseau de neurones simple

weights = np.random.randn(input_size, output_size)

2. Propagation Avant dans un Réseau de Neurones

La propagation avant (ou forward propagation) est une étape fondamentale dans le
fonctionnement des réseaux de neurones. Elle consiste à faire passer les données d'entrée à
travers le réseau pour produire une sortie (prédiction). Cette opération se fait de manière
séquentielle, de la première couche (entrée) jusqu'à la dernière couche (sortie). Voici une
explication détaillée de cette étape, avec un exemple simple d'un réseau de neurones à deux
couches (une couche cachée et une couche de sortie).

Structure de Base d'un Réseau de Neurones

Un réseau de neurones est composé de :
1. Couches d'entrée : Reçoivent les données d'entrée.
2. Couches cachées : Effectuent des transformations intermédiaires sur les données.
3. Couche de sortie : Génère la sortie finale (prédiction).

Calcul dans une Neurone

Chaque neurone dans une couche reçoit des entrées, applique une fonction de pondération
(poids), ajoute un biais, et passe le résultat à travers une fonction d'activation pour produire
une sortie.
Rôle du Biais dans les Réseaux de Neurones
Le biais (ou bias en anglais) est un paramètre additionnel dans un neurone d'un réseau de
neurones qui permet d'ajuster la sortie du neurone indépendamment des valeurs des
entrées. Son rôle est crucial pour assurer que les modèles de Machine Learning puissent
s'adapter de manière flexible aux données et capturer des tendances complexes.
1. Décalage de la Fonction d'Activation
Le biais permet de décaler la fonction d'activation du neurone. Sans le biais, un neurone
activé par une fonction linéaire (comme dans une régression linéaire) ou non linéaire
(comme une sigmoïde) serait toujours contraint de passer par l'origine (point où toutes les
entrées sont zéro). Le biais permet de déplacer la courbe de la fonction d'activation vers le
haut ou vers le bas, permettant ainsi de mieux modéliser les données.
2. Augmentation de la Flexibilité du Modèle
En ajoutant un biais, le neurone peut mieux s'adapter aux données. Cela est
particulièrement utile lorsque les données ne sont pas centrées autour de l'origine. Par
exemple, dans une classification binaire avec une fonction sigmoïde, le biais permet de
contrôler le seuil à partir duquel une entrée est classée dans une catégorie ou une autre.
3. Amélioration de la Capacité d'Apprentissage
Le biais permet aux réseaux de neurones d'apprendre des relations complexes dans les
données. Sans biais, la capacité d'un modèle à apprendre et à généraliser serait réduite, car
il serait limité à des fonctions passant par l'origine. Le biais offre une dimension
supplémentaire d'ajustement, rendant le modèle plus robuste et efficace.

Formule de Calcul
Pour un neurone ( j ) dans une couche donnée :
n
zj = ∑ w ij x i + b j
i=1

a j = f (z j )

zj : somme pondérée des entrées

w ij : poids appliqué à l'entrée xi

xi : valeur de l'entrée i

bj : biais du neurone j

f : fonction d'activation
aj : sortie du neurone j

Étapes de la Propagation Avant

 1. Initialisation des Entrées : Les données d'entrée sont fournies à la première couche du
réseau.
2. Calcul des Sommes Pondérées et Applications des Fonctions d'Activation :
Chaque neurone de chaque couche (à partir de la première couche cachée) calcule la
somme pondérée de ses entrées, ajoute le biais, et applique la fonction d'activation.
3. Transmission de la Sortie : La sortie de chaque neurone devient l'entrée de la couche
suivante.
4. Production de la Sortie Finale : La dernière couche produit la prédiction finale du réseau.
Created with AIMONEYGEN.COM - "Visit GPTS Collection "

Qu'est-ce qu'une Fonction d'Activation ?

Une fonction d'activation est une fonction mathématique utilisée dans les réseaux de
neurones pour introduire de la non-linéarité dans le modèle. Cette non-linéarité permet au
réseau de neurones de modéliser des relations complexes et de résoudre des problèmes non
linéaires. Sans fonction d'activation, un réseau de neurones se comporterait simplement
comme un modèle de régression linéaire, incapable de capturer les complexités des
données.

Rôle de la Fonction d'Activation

Non-linéarité : Elle permet au réseau de capturer des relations non linéaires entre les
variables d'entrée et de sortie.
Transformation : Elle transforme la sortie linéaire d'un neurone (la somme pondérée des
entrées) en une forme non linéaire.
Normalisation : Certaines fonctions d'activation (comme la sigmoïde) normalisent la
sortie dans une plage spécifique (par exemple, entre 0 et 1).

Types de Fonctions d'Activation

Il existe plusieurs types de fonctions d'activation couramment utilisées dans les réseaux de
neurones, chacune avec ses propres caractéristiques et applications.

1. Fonction Sigmoïde (Sigmoid)

La fonction sigmoïde transforme la sortie dans une plage de 0 à 1.
1
σ(z) =
1+e −z

Avantages :
Sortie normalisée entre 0 et 1.
 Bonne pour les modèles où une probabilité est nécessaire.
Inconvénients :
Problème de gradient évanescent (les gradients deviennent très petits pour des valeurs
extrêmes de ). z

2. Fonction Tangente Hyperbolique (Tanh)

La fonction Tanh transforme la sortie dans une plage de -1 à 1.
z −z
e −e
tanh(z) =
e z +e −z

Avantages :
Centrée autour de zéro, ce qui peut améliorer la convergence du modèle.
Sortie normalisée entre -1 et 1.
Inconvénients :
Problème de gradient évanescent, bien que moins sévère que la sigmoïde.

3. Rectified Linear Unit (ReLU)

La fonction ReLU est définie comme la valeur maximale entre 0 et l'entrée.
ReLU(z) = max(0, z)

Avantages :
Simplicité et efficacité computationnelle.
Résout le problème de gradient évanescent en partie.
Inconvénients :
Problème de neurones morts (si un neurone sort constamment des valeurs négatives, il
peut cesser de contribuer à l'apprentissage).

4. Leaky ReLU
Une variante de ReLU qui permet un petit gradient pour les valeurs négatives.
Leaky ReLU(z) = max(αz, z)

Où est un petit nombre (souvent

α 0.01).
Avantages :
 Atténue le problème des neurones morts.
Inconvénients :
L'ajout d'un paramètre supplémentaire ( ).α

5. Softmax
La fonction Softmax est utilisée dans les couches de sortie des réseaux de neurones pour les
problèmes de classification multi-classes. Elle transforme un vecteur de valeurs en un
vecteur de probabilités.
z
e i

Sof tmax(z i ) = zj
∑ e
j

Avantages :
Interprétation directe en termes de probabilités.
Inconvénients :
Sensible aux grandes valeurs dans les entrées.

Exemple de Fonctions d'Activation en Python

Voici un exemple de fonctions d'activation en Python :

import numpy as np

def sigmoid(z):
return 1 / (1 + np.exp(-z))

def tanh(z):
return np.tanh(z)

def relu(z):
return np.maximum(0, z)

def leaky_relu(z, alpha=0.01):

return np.where(z > 0, z, alpha * z)

def softmax(z):
exp_z = np.exp(z - np.max(z)) # stabilité numérique
return exp_z / np.sum(exp_z, axis=0)

Conclusion
Les fonctions d'activation jouent un rôle crucial dans les réseaux de neurones en
introduisant de la non-linéarité, en normalisant les sorties et en permettant aux modèles de
capturer des relations complexes dans les données. Choisir la bonne fonction d'activation
dépend du problème spécifique à résoudre et de la structure du réseau de neurones utilisé.
En comprenant leurs avantages et inconvénients, vous serez mieux équipé pour concevoir et
entraîner des réseaux de neurones efficaces.

Exemple de Propagation Avant

Considérons un réseau de neurones avec :
2 neurones dans la couche d'entrée
3 neurones dans une couche cachée
1 neurone dans la couche de sortie

Initialisation
Supposons les entrées x1 et .x2

Couche Cachée
Chaque neurone de la couche cachée reçoit x1 et ., calcule la somme pondérée, ajoute un
x2

biais, et applique une fonction d'activation (f ) (par exemple, la fonction sigmoïde).

(1) (1) (1) (1)
z = w x1 + w x2 + b
1 11 21 1

(1) (1)
a = f (z )
1 1

Où représente le poids du neurone de la couche cachée pour l'entrée , et

w
(1)

ij
j i b
(1)

représente le biais de ce neurone.

Couche de Sortie
Le neurone de la couche de sortie reçoit les sorties de la couche cachée, calcule la somme
pondérée, ajoute un biais, et applique une fonction d'activation.
(2) (2) (1) (2) (1) (2) (1) (2)
z = w a + w a + w a + b
1 11 1 21 2 31 3 1

(2) (2)
a = f (z )
1 1

Où représente le poids du neurone de la couche de sortie pour la sortie de la couche

w
(2)

ij
j

cachée, et représente le biais de ce neurone.

b
(2)

Illustrations et Code Python

Schéma Simplifié

Input Layer (2 neurones) -> Hidden Layer (3 neurones) -> Output Layer (1 neurone)
Exemple de Code Python
import numpy as np

# Fonction d'activation (sigmoïde)

def sigmoid(z):
return 1 / (1 + np.exp(-z))

# Données d'entrée
X = np.array([0.5, 0.1])

# Poids et biais de la couche cachée

W_hidden = np.array([
[0.2, 0.8],
[0.5, 0.1],
[0.9, 0.4],
])
b_hidden = np.array([0.1, 0.2, 0.3])

# Propagation avant pour la couche cachée

z_hidden = np.dot(W_hidden, X) + b_hidden
a_hidden = sigmoid(z_hidden)

# Poids et biais de la couche de sortie

W_output = np.array([0.3, 0.6, 0.9])
b_output = 0.4

# Propagation avant pour la couche de sortie

z_output = np.dot(W_output, a_hidden) + b_output
a_output = sigmoid(z_output)

print(f'Sortie finale : {a_output}')

Conclusion
La propagation avant dans un réseau de neurones consiste à faire passer les données
d'entrée à travers les différentes couches du réseau, en appliquant des transformations
(somme pondérée + biais + fonction d'activation) pour chaque neurone, jusqu'à obtenir la
sortie finale. Cette étape est essentielle pour comprendre comment les réseaux de neurones
font des prédictions et constitue la base de l'entraînement des modèles de Machine
Learning.

3. Calcul de l'Erreur
Une fois que les prédictions sont générées, l'erreur est calculée en comparant les prédictions
aux valeurs réelles. L'erreur est une mesure de la précision du modèle et est utilisée pour
ajuster les paramètres du modèle.
Exemple : Calcul de l'Erreur avec la MSE (Mean Squared Error)
def calculate_error(y_true, y_pred):
return np.mean((y_true - y_pred) ** 2)

4. Rétropropagation (Backward Propagation)

La rétropropagation est le processus par lequel l'erreur calculée est utilisée pour mettre à
jour les paramètres du modèle afin de minimiser cette erreur. Ce processus implique le calcul
du gradient de l'erreur par rapport à chaque paramètre, et l'utilisation de ces gradients pour
ajuster les paramètres dans la direction qui réduit l'erreur.

Exemple : Rétropropagation dans une Régression Linéaire

def backward_propagation(X, y_true, y_pred, weights, learning_rate):
gradient = -2 * np.dot(X.T, (y_true - y_pred)) / y_true.size
weights -= learning_rate * gradient
return weights

5. Itération du Processus
Le processus d'entraînement est itératif. Les étapes de propagation avant, calcul de l'erreur,
et rétropropagation sont répétées plusieurs fois sur l'ensemble des données d'entraînement
pour améliorer progressivement les performances du modèle. Chaque cycle complet à
travers les données est appelé une époque (epoch).

Exemple : Entraînement d'un Modèle de Régression Linéaire

def train_model(X, y, weights, learning_rate, epochs):
for epoch in range(epochs):
y_pred = forward_propagation(X, weights)
error = calculate_error(y, y_pred)
weights = backward_propagation(X, y, y_pred, weights, learning_rate)
print(f'Epoch {epoch+1}, Error: {error}')
return weights

# Paramètres d'entraînement
learning_rate = 0.01
epochs = 1000

# Entraînement du modèle
trained_weights = train_model(X_train, y_train, weights, learning_rate, epochs)

Conclusion
Le processus d'entraînement d'un modèle de Machine Learning implique plusieurs étapes
clés : initialisation, propagation avant, calcul de l'erreur, rétropropagation, et itération.
Chacune de ces étapes joue un rôle crucial dans l'apprentissage du modèle et son
amélioration au fil du temps. En suivant ce processus, un modèle peut apprendre à faire des
prédictions précises à partir des données.
En comprenant et en maîtrisant ces concepts, vous serez mieux préparé pour entraîner des
modèles de Machine Learning et optimiser leurs performances.

Validation d'un Modèle

La validation consiste à évaluer les performances du modèle sur un ensemble de données
différent de celui utilisé pour l'entraînement. Cela permet de s'assurer que le modèle
généralise bien et n'est pas simplement adapté aux données d'entraînement.

Techniques de Validation
Validation Croisée : Diviser les données en k sous-ensembles et entraîner le modèle k
fois, en utilisant chaque sous-ensemble comme ensemble de test une fois.
Ensemble d'Entraînement/Test : Séparer les données en deux parties, une pour
l'entraînement et une pour le test.

Évaluation des Performances

Utiliser des métriques spécifiques pour mesurer les performances du modèle :
Précision : Proportion des prédictions correctes.
Rappel : Proportion des vraies positives parmi toutes les positives.
F1-Score : Moyenne harmonique de la précision et du rappel.

Conclusion
Comprendre les concepts de base du Machine Learning est crucial pour pouvoir appliquer
efficacement des algorithmes et des modèles aux données. Ce chapitre a couvert les notions
essentielles d'algorithmes et de modèles, l'importance des données et du prétraitement,
ainsi que le processus d'entraînement et de validation. Avec ces bases, vous serez prêt à
explorer des algorithmes plus complexes et à développer des modèles performants.