E.S.G.A.

E la Grande Ecole Administration Base de Données (ABD)

Code…

Equipe pédagogique
Administration Base de Données (ABD)

1
Titre du Cours : Introduction à l'Apprentissage Automatique

Description du Cours :

Ce cours présente les principes fondamentaux de l'apprentissage automatique, y compris les

concepts clés, les algorithmes et les applications. Les étudiants apprendront à concevoir,
implémenter et évaluer des modèles d'apprentissage automatique en utilisant diverses
techniques et outils.

Objectifs du Cours :

• Comprendre les principes de base de l'apprentissage automatique.

• Apprendre les différents algorithmes d'apprentissage automatique et leurs applications.
• Acquérir une expérience pratique en prétraitement des données et en évaluation des
modèles.
• Développer des compétences en implémentation de modèles d'apprentissage
automatique en utilisant des langages de programmation et des outils.

Plan du Cours :

Chapitre 1 : Introduction à l'Apprentissage Automatique

• Qu'est-ce que l'Apprentissage Automatique ?

• Histoire et évolution de l'Apprentissage Automatique
• Types d'apprentissage automatique (supervisé, non supervisé, apprentissage par
renforcement)
• Applications de l'Apprentissage Automatique

Chapitre 2 : Prétraitement des Données

• Comprendre les ensembles de données

• Nettoyage des données et gestion des valeurs manquantes
• Normalisation et standardisation des données
• Sélection et extraction des caractéristiques

Chapitre 3 : Apprentissage Supervisé

• Algorithmes de régression (régression linéaire, régression polynomiale)

• Algorithmes de classification (k-Nearest Neighbors, arbres de décision, forêts
aléatoires)
• Mesures d'évaluation des modèles (précision, rappel, F1-Score, courbe ROC-AUC)

Chapitre 4 : Apprentissage Non Supervisé

• Algorithmes de regroupement (K-Means, regroupement hiérarchique, DBSCAN)

• Techniques de réduction de dimensionnalité (PCA, t-SNE)
• Détection d'anomalies
Chapitre 5 : Réseaux de Neurones et Apprentissage Profond

• Introduction aux réseaux de neurones

• Bases de l'apprentissage profond
• Réseaux de neurones convolutionnels (CNN)
• Réseaux de neurones récurrents (RNN)
• Introduction aux frameworks (TensorFlow, Keras, PyTorch)

Chapitre 6 : Évaluation et Optimisation des Modèles

• Techniques de validation croisée

• Ajustement des hyperparamètres (Grid Search, Random Search)
• Sélection et comparaison des modèles
• Éviter le surapprentissage (overfitting) et le sous-apprentissage (underfitting)

Chapitre 7 : Sujets Avancés en Apprentissage Automatique

• Méthodes d'ensemble (Bagging, Boosting, Stacking)

• Notions de base de l'apprentissage par renforcement
• Apprentissage par transfert
• Considérations éthiques et équité dans l'apprentissage automatique

Chapitre 8 : Applications Pratiques et Projets

• Projets pratiques et études de cas

• Applications réelles (traitement du langage naturel, vision par ordinateur, analyse de
séries temporelles)
• Implémentation et déploiement de modèles d'apprentissage automatique

Méthodes d'Évaluation :

• Quiz et examens
• Devoirs et exercices pratiques
• Présentation finale du projet

Manuels Recommandés :

• "Pattern Recognition and Machine Learning" par Christopher M. Bishop

• "Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow" par Aurélien
Géron
• "Deep Learning" par Ian Goodfellow, Yoshua Bengio, et Aaron Courville
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Sommaire

Introduction .............................................................................................................................. iii

Chapitre 1 : Introduction à l’Apprentissage Automatique ......................................................... 1
Section 1 : Définition et principes fondamentaux.................................................................. 1
Section 2 : Histoire et évolution du Machine Learning ......................................................... 1
Section 3 : Les trois grands types d’apprentissage ................................................................ 2
Section 4 : Applications du Machine Learning ...................................................................... 5
Chapitre 2 : Prétraitement des Données ................................................................................... 10
Section 1 : Comprendre les ensembles de données ............................................................. 10
Section 2 : Nettoyage des données et gestion des valeurs manquantes ............................... 11
Section 3 : Normalisation et standardisation des données ................................................... 11
Section 4 : Sélection et extraction des caractéristiques ....................................................... 15
Chapitre 3 : Apprentissage Supervisé ...................................................................................... 21
Section 2 : Les algorithmes de régression............................................................................ 21
Section 3 : Les algorithmes de classification ....................................................................... 24
Chapitre 4 : Apprentissage Non Supervisé .............................................................................. 33
Section 1 : Les algorithmes de regroupement (Clustering) ................................................. 33
Section 2 : Les algorithmes de réduction de dimension ...................................................... 37
Section 3 : Évaluation des modèles non supervisés ............................................................. 39
Section 4 : Détection d’anomalies ....................................................................................... 40
Chapitre 5 : Réseaux de Neurones et Apprentissage Profond.................................................. 44
Section 1 : Introduction aux réseaux de neurones ............................................................... 44
Section 2 : Bases de l’apprentissage profond ...................................................................... 44
Section 3 : Réseaux de neurones convolutionnels (CNN) ................................................... 45
Section 4 : Réseaux de neurones récurrents (RNN)............................................................. 46
Section 5 : Introduction aux frameworks ............................................................................. 47
Chapitre 6 : Évaluation et Optimisation des Modèles ............................................................. 50
Section 1 : Techniques de validation croisée ....................................................................... 50
Section 2 : Ajustement des hyperparamètres ....................................................................... 51
Section 3 : Sélection et comparaison des modèles............................................................... 53
Section 4 : Surapprentissage et sous-apprentissage ............................................................. 53
Chapitre 7 : Sujets Avancés en Apprentissage Automatique ................................................... 56

i
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Section 1 : Méthodes d’ensemble (Ensemble Methods) ...................................................... 56

Section 2 : Notions de base de l’apprentissage par renforcement ....................................... 59
Section 3 : Apprentissage par transfert (Transfer Learning) ................................................ 61
Section 4 : Considérations éthiques et équité ...................................................................... 63
Chapitre 8 : Applications Pratiques et Projets.......................................................................... 67
Section 1 : Projets pratiques et études de cas ....................................................................... 67
Section 2 : Applications réelles ............................................................................................ 70
Section 3 : Implémentation et déploiement des modèles ..................................................... 72
Conclusion ............................................................................................................................... 75
Bibliographie.............................................................................................................................. a
Table des matières ...................................................................................................................... b

ii
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Introduction
L’apprentissage automatique est aujourd’hui au cœur des innovations technologiques et
scientifiques. Il permet aux machines d’apprendre à partir des données, de s’améliorer avec
l’expérience et de prendre des décisions sans être explicitement programmées pour chaque
tâche. Ce cours a pour objectif de donner aux étudiants une compréhension claire et progressive
des principes fondamentaux, des algorithmes essentiels et des applications pratiques de
l’apprentissage automatique.

Au fil des chapitres, les étudiants découvrent comment les données sont préparées, comment
les modèles sont construits et évalués, et comment les techniques avancées comme les réseaux
de neurones ou l’apprentissage par renforcement ouvrent de nouvelles perspectives.
L’approche pédagogique combine théorie, pratique et réflexion critique, afin de former des
compétences solides et transférables.

Ce cours ne se limite pas à l’aspect technique : il met également en lumière les enjeux éthiques
et sociétaux liés à l’utilisation de l’intelligence artificielle. Les étudiants sont ainsi encouragés
à développer une vision responsable et équilibrée de l’IA, en tenant compte des biais, de
l’équité et de la transparence.

Points clés de l’introduction

• Objectif principal : fournir une base solide en apprentissage automatique, de la théorie

aux applications.
• Approche progressive : commencer par les concepts fondamentaux, puis explorer des
méthodes avancées.
• Dimension pratique : inclure des exercices, des projets et des études de cas pour
appliquer les connaissances.
• Ouverture technologique : présenter les principaux frameworks et outils utilisés dans
le domaine.
• Réflexion éthique : sensibiliser aux enjeux de biais, d’équité et de responsabilité dans
l’IA.
• Perspective future : préparer les étudiants à contribuer à un domaine en constante
évolution et à fort impact.

Ce cours est conçu comme une porte d’entrée vers l’univers de l’intelligence artificielle. Il
offre aux étudiants les moyens de comprendre, d’expérimenter et d’appliquer l’apprentissage
automatique dans des contextes variés, tout en les préparant à relever les défis technologiques
et éthiques de demain.

iii
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Chapitre 1 : Introduction à l’Apprentissage Automatique

Section 1 : Définition et principes fondamentaux

L’apprentissage automatique (Machine Learning) est une discipline de l’intelligence

artificielle qui consiste à donner aux ordinateurs la capacité d’apprendre à partir de données.
Contrairement à la programmation classique où le développeur écrit des règles précises, le
Machine Learning repose sur des modèles statistiques et mathématiques qui découvrent
automatiquement des relations dans les données.

Un modèle de Machine Learning est une fonction ( f(x) ) qui prend des entrées (features) et
produit des sorties (labels ou prédictions). Ce modèle est entraîné sur un ensemble de
données d’apprentissage et évalué sur un ensemble de test pour vérifier sa capacité à
généraliser.

Analogie : C’est comme apprendre à cuisiner. Plutôt que de suivre une recette fixe, on goûte
plusieurs plats, on observe les ingrédients, et on finit par savoir préparer un plat similaire sans
avoir la recette exacte.

Illustration réelle : Un logiciel de reconnaissance faciale reçoit des milliers de photos de

visages avec leurs noms. Il apprend à associer les traits du visage à une identité. Lorsqu’on lui
présente une nouvelle photo, il peut prédire la personne correspondante.

Section 2 : Histoire et évolution du Machine Learning

Le Machine Learning est né dans les années 1950 avec les premiers travaux sur les neurones
artificiels. Voici les grandes étapes :

• Années 1950 : Alan Turing propose le test de Turing. Frank Rosenblatt invente le
perceptron, premier modèle de neurone artificiel.
• Années 1960-70 : développement des premiers algorithmes de classification comme
k-Nearest Neighbors.
• Années 1980-90 : essor des réseaux de neurones multicouches et des arbres de décision.
• Années 2000 : explosion des données et puissance de calcul, apparition des SVM
(Support Vector Machines) et Random Forest.

1
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

• Années 2010-2020 : révolution du Deep Learning grâce aux GPU et aux big data.
CNN et RNN deviennent incontournables.
• Aujourd’hui : le Machine Learning est utilisé partout : santé, finance, transport,
industrie, divertissement.

Analogie : C’est comme l’évolution des moyens de transport :

• Charrette (algorithmes simples).

• Voiture (modèles plus complexes).
• Avion (deep learning).

Illustration réelle : Courbe montrant l’évolution des performances des modèles en parallèle
avec la croissance des données disponibles (ex. ImageNet Challenge où les CNN ont surpassé
les humains en reconnaissance d’images).

Section 3 : Les trois grands types d’apprentissage

3.1 Apprentissage supervisé

L’apprentissage supervisé utilise des données étiquetées. Chaque exemple est associé à une
réponse connue. Le modèle apprend à prédire l’étiquette d’un nouvel exemple.

Algorithmes principaux et explications :

• Régression linéaire : prédit une valeur numérique en traçant une droite qui s’ajuste aux
données. Exemple : prédire le prix d’une maison en fonction de sa surface.
• Régression polynomiale : utilise une courbe plus complexe pour mieux représenter les
données. Exemple : prédire la croissance d’une population.
• k-Nearest Neighbors (k-NN) : classe un nouvel élément selon les catégories de ses
voisins les plus proches. Exemple : reconnaître un fruit selon sa couleur et sa forme.
• Arbres de décision : posent des questions successives (“taille > 1,70 m ?”) pour arriver
à une classe. Exemple : prédire si une personne est éligible à un prêt.
• Random Forest : combinent plusieurs arbres pour améliorer la précision. Exemple :
prédire la probabilité de défaut de paiement.
• Support Vector Machines (SVM) : séparent les classes avec une frontière optimale.
Exemple : distinguer spam et non spam.

2
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

• Réseaux de neurones supervisés : apprennent des relations complexes entre les

données. Exemple : reconnaissance d’images médicales.

Analogie : C’est comme un élève qui révise avec un corrigé : il apprend en comparant ses
réponses avec celles du professeur.

Illustration réelle : Graphique montrant une droite de régression ajustée à des points
représentant surface vs prix d’une maison.

3.2 Apprentissage non supervisé

L’apprentissage non supervisé utilise des données non étiquetées. Le modèle cherche des
structures cachées (groupes, motifs).

Algorithmes principaux et explications :

• K-Means : regroupe les données en k clusters selon leur proximité. Exemple :

segmenter des clients selon leurs habitudes d’achat.
• DBSCAN : détecte des groupes de densité et identifie les anomalies. Exemple : détecter
des fraudes bancaires.
• Regroupement hiérarchique : construit une hiérarchie de clusters. Exemple :
organiser des documents en catégories.
• PCA (Analyse en Composantes Principales) : réduit la dimensionnalité en conservant
l’essentiel de la variance. Exemple : compresser des images.
• t-SNE : visualise des données complexes en 2D ou 3D. Exemple : représenter des mots
dans un espace sémantique.
• Détection d’anomalies : identifie des points atypiques. Exemple : repérer des
transactions suspectes.

3
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme un explorateur qui découvre des tribus inconnues sans savoir à
l’avance qui elles sont.

Illustration réelle : Diagramme montrant des points regroupés en clusters par K-Means.

3.3 Apprentissage par renforcement

L’apprentissage par renforcement consiste à entraîner un agent à interagir avec un

environnement. Il reçoit des récompenses ou punitions selon ses actions.

Méthodes principales et explications :

• Q-Learning : apprend une table de valeurs Q pour choisir la meilleure action. Exemple
: un robot qui apprend à se déplacer.
• Deep Q-Networks (DQN) : utilisent des réseaux de neurones pour approximer la
fonction Q. Exemple : un agent qui joue à des jeux vidéo.
• Policy Gradient : optimisent directement la politique d’action. Exemple : un drone qui
apprend à voler.
• Actor-Critic : combinent une politique (actor) et une fonction de valeur (critic).
Exemple : un robot qui apprend à marcher.

4
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme dresser un chien : il apprend par essais et erreurs, récompensé par
des friandises.

Illustration réelle : Schéma montrant un agent dans un environnement de jeu vidéo recevant
des récompenses pour ses actions.

Section 4 : Applications du Machine Learning

Le Machine Learning est utilisé dans presque tous les domaines :

• Vision par ordinateur : reconnaissance faciale, détection d’objets, voitures

autonomes.
• Traitement du langage naturel (NLP) : traduction automatique, chatbots, analyse de
sentiments.
• Santé : diagnostic médical assisté, prédiction de maladies, analyse d’images médicales.
• Finance : détection de fraude, prévision des marchés, scoring de crédit.
• Industrie : maintenance prédictive, automatisation, optimisation de production.
• Transport : optimisation des trajets, systèmes de navigation intelligents.
• Divertissement : recommandations Netflix, Spotify, YouTube.

Analogie : C’est comme donner des super-pouvoirs aux ordinateurs : voir, lire,
comprendre, prédire et agir.

Illustration réelle : Capture d’écran d’une application de reconnaissance d’images qui

identifie automatiquement des objets dans une photo.

Exercice pratique :

Vous disposez d’un petit jeu de données contenant des fruits avec leurs caractéristiques :

Fruit Couleur Forme Étiquette

Pomme Rouge Ronde Pomme
Banane Jaune Longue Banane
Orange Orange Ronde Orange

5
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

1. Expliquez comment un algorithme d’apprentissage supervisé pourrait apprendre à

reconnaître ces fruits.
2. Listez les algorithmes possibles et expliquez leur fonctionnement.
3. Montrez comment il prédirait un nouveau fruit : “Jaune, Longue”.
4. Implémentez une solution simple en Python avec k-NN.

Solution pas à pas :

1. Explication générale

L’algorithme d’apprentissage supervisé reçoit les données avec leurs étiquettes. Il apprend les
relations entre les caractéristiques (couleur, forme) et les étiquettes (fruit).

• Rouge + Ronde → Pomme

• Jaune + Longue → Banane
• Orange + Ronde → Orange

Analogie : C’est comme un professeur qui montre des exemples corrigés à ses élèves.
L’élève comprend que “rouge et rond” correspond toujours à une pomme, et il peut appliquer
cette règle à de nouveaux cas.

Illustration réelle : Imaginez une application mobile qui scanne un fruit avec la caméra et
affiche son nom. Elle a été entraînée avec des milliers d’images de fruits étiquetés.

2. Algorithmes possibles et explications détaillées

• k-Nearest Neighbors (k-NN) : Compare un nouvel exemple avec les plus proches
voisins dans le dataset. Si la majorité des voisins sont des bananes, le nouvel exemple
est classé comme banane. Exemple réel : reconnaissance de chiffres manuscrits
(MNIST dataset).
• Arbre de décision : Pose des questions successives : “Couleur = Jaune ?” → Oui →
“Forme = Longue ?” → Oui → Banane. Exemple réel : prédire si un client est éligible
à un crédit bancaire.
• Support Vector Machines (SVM) : Trouve une frontière optimale qui sépare les
classes. Exemple réel : distinguer spam et non spam dans les emails.

6
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

• Régression logistique : Utilisée pour des problèmes de classification binaire (oui/non).

Exemple réel : prédire si un patient est malade ou non.

Analogie :

• k-NN : comme demander l’avis des voisins pour savoir si une maison est belle.
• Arbre de décision : comme jouer à 20 questions pour deviner un objet.
• SVM : comme tracer une ligne dans le sable pour séparer deux groupes d’enfants.
• Régression logistique : comme prendre une décision oui/non (acheter ou ne pas
acheter).

Illustration réelle : Graphiques montrant un arbre de décision, une frontière SVM, et des
clusters k-NN.

3. Prédiction du nouveau fruit “Jaune, Longue”

• k-NN : compare avec les voisins → Banane.

• Arbre de décision : “Couleur = Jaune ?” → Oui → “Forme = Longue ?” → Oui →
Banane.
• SVM : place le point dans la région “Banane”.
• Régression logistique : calcule une probabilité → 95 % Banane.

7
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme jouer au jeu des devinettes : “Si c’est jaune et long, c’est une
banane !”

Illustration réelle : Application de reconnaissance d’images qui identifie une banane à partir
d’une photo.

4. Code Python complet avec k-NN

import pandas as pd
from [Link] import KNeighborsClassifier

# Dataset
data = {
"Couleur": ["Rouge", "Jaune", "Orange"],
"Forme": ["Ronde", "Longue", "Ronde"],
"Fruit": ["Pomme", "Banane", "Orange"]
}
df = [Link](data)

# Encodage des variables catégorielles

df_encoded = pd.get_dummies(df[["Couleur", "Forme"]])
X = df_encoded
y = df["Fruit"]

# Modèle k-NN
model = KNeighborsClassifier(n_neighbors=1)
[Link](X, y)

# Nouveau fruit : Jaune, Longue

new_fruit = [Link]({"Couleur": ["Jaune"], "Forme": ["Longue"]})
new_fruit_encoded = pd.get_dummies(new_fruit)
new_fruit_encoded = new_fruit_encoded.reindex(columns=[Link], fill_value=0)

prediction = [Link](new_fruit_encoded)
print("Fruit prédit :", prediction[0])

Résultat :

Fruit prédit : Banane

8
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie finale : C’est comme un enfant qui a appris avec des exemples. Dès qu’il voit un
fruit jaune et long, il dit immédiatement “Banane !”.

Illustration réelle : Un système de caisse automatique dans un supermarché qui reconnaît les
fruits au scanner et affiche “Banane” sans que le client ait besoin de le préciser.

9
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Chapitre 2 : Prétraitement des Données

Section 1 : Comprendre les ensembles de données

Un ensemble de données (dataset) est la matière première du Machine Learning. Il s’agit

d’une table organisée où chaque ligne correspond à une observation (ex. un patient, une image,
un client) et chaque colonne correspond à une caractéristique (feature) (ex. âge, revenu,
couleur, taille).

Un dataset peut être petit (quelques dizaines de lignes) ou gigantesque (millions

d’observations). La qualité et la pertinence des données déterminent directement la
performance du modèle.

• Structure d’un dataset :

o Chaque ligne correspond à une observation (ex. un patient, une image, un
client).
o Chaque colonne correspond à une caractéristique (feature) (ex. âge, revenu,
couleur, taille).
o Une étiquette (label) peut être présente (dans le cas supervisé), indiquant la
réponse attendue (ex. “Fruit = Pomme”).
• Taille d’un dataset :
o Il peut être petit (quelques dizaines de lignes).
o Il peut être gigantesque (millions d’observations).
o Plus le dataset est grand et varié, plus le modèle peut apprendre de manière
robuste.
• Qualité des données :
o La qualité et la pertinence des données déterminent directement la performance
du modèle.
o Des données biaisées ou incomplètes produisent des modèles peu fiables.

Analogie : Un dataset est comme le registre d’une école : chaque élève est une ligne, chaque
colonne une information (nom, âge, notes). Si le registre est incomplet ou mal rempli, il sera
difficile d’évaluer correctement les élèves.

10
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Illustration réelle : Un fichier Excel contenant les informations de clients d’une banque :
colonnes “Nom”, “Âge”, “Revenu”, “Ville”. Chaque ligne correspond à un client.

Section 2 : Nettoyage des données et gestion des valeurs manquantes

Dans la réalité, les données sont rarement parfaites. On rencontre souvent :

• Valeurs manquantes : certaines cellules sont vides (ex. âge non renseigné).
• Doublons : une même personne apparaît deux fois.
• Incohérences : “M” et “Masculin” mélangés.
• Valeurs aberrantes : un revenu de 1 000 000 FCFA pour un étudiant.

Techniques de nettoyage :

• Supprimer les lignes trop incomplètes : si une observation manque trop

d’informations, elle est inutilisable.
• Remplacer les valeurs manquantes : par une moyenne, une médiane ou une valeur
par défaut.
• Uniformiser les formats : transformer “M” en “Masculin” pour éviter les
incohérences.
• Détecter et traiter les valeurs extrêmes : soit les corriger, soit les supprimer si elles
sont manifestement erronées.

Analogie : C’est comme corriger une copie d’examen : on complète les trous, on efface les
ratures, et on harmonise l’écriture pour que tout soit lisible.

Illustration réelle : Un dataset médical où certains patients n’ont pas renseigné leur âge. On
remplace les valeurs manquantes par la moyenne des âges des autres patients.

Section 3 : Normalisation et standardisation des données

3.1 Problème

Les variables peuvent avoir des échelles différentes. Exemple :

11
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

• Âge en années (20–60).

• Revenu en euros (2000–100000).

Si on ne les ajuste pas, les variables avec grandes valeurs dominent les calculs.

3.2 Normalisation

La normalisation ramène toutes les valeurs dans une plage fixe, généralement entre 0 et 1.

𝑥−𝑚𝑖𝑛
Formule : 𝑥_𝑛𝑜𝑟𝑚 = max − 𝑚𝑖𝑛

• min = valeur minimale de la colonne.

• max = valeur maximale de la colonne.
• x = valeur à normaliser.

On soustrait la valeur minimale pour ramener la plus petite valeur à 0. Ensuite, on divise par
l’écart entre max et min pour ramener la plus grande valeur à 1. Toutes les autres valeurs se
retrouvent proportionnellement entre 0 et 1.

Analogie : C’est comme mettre tous les coureurs sur la même ligne de départ : chacun
commence au même niveau, peu importe sa taille ou son poids.

Illustration réelle : Graphique montrant des revenus bruts (2000–100000) puis normalisés
entre 0 et 1 pour que chaque valeur soit comparable.

3.3 Standardisation

La standardisation consiste à centrer les données autour de la moyenne et à ajuster

l’écart-type.
𝑥−µ
Formule : 𝑥_𝑠𝑡𝑑 = 𝜎

• µ = moyenne de la colonne.
• σ = écart-type de la colonne.
• x = valeur à standardiser.

12
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

On soustrait la moyenne pour que la nouvelle moyenne soit 0. Ensuite, on divise par
l’écart-type pour que la dispersion des valeurs soit comparable.

Analogie : C’est comme ramener toutes les notes d’une classe autour de la moyenne pour
comparer équitablement les élèves.

Illustration réelle : Graphique montrant des notes brutes puis standardisées autour de la
moyenne.

3.4 L’écart-type : définition et rôle

3.4.1. Qu’est-ce que l’écart-type ?

L’écart-type est une mesure statistique qui indique à quel point les valeurs d’un ensemble
de données s’écartent de la moyenne.

• Si l’écart-type est petit, cela signifie que les valeurs sont proches de la moyenne.
• Si l’écart-type est grand, cela signifie que les valeurs sont dispersées, éloignées de la
moyenne.

En d’autres termes, l’écart-type mesure la dispersion ou la variabilité des données.

3.4.2. La formule de l’écart-type

Pour un ensemble de données 𝑥1 , 𝑥2 , 𝑥3 , . . . , 𝑥𝑛 :

1. On calcule la moyenne :

∑𝑛𝑖=1 𝑥𝑖
𝜇=
𝑛

2. On calcule l’écart de chaque valeur par rapport à la moyenne :

(𝑥𝑖 −𝜇)

3. On élève ces écarts au carré pour éviter les valeurs négatives :

13
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

(𝑥𝑖 −𝜇)2

4. On calcule la moyenne des carrés des écarts (c’est la variance) :

𝑛
∑𝑖=1( 𝑥𝑖 − 𝜇)2
2
𝜎 =
𝑛

5. Enfin, on prend la racine carrée de la variance pour revenir à l’échelle des données :

𝜎 = √𝜎 2

3.4.3. Exemple numérique

Prenons les notes suivantes : 10, 12, 13, 15, 20.

1. Moyenne :

10 + 12 + 13 + 15 + 20
𝜇= = 14
5

2. Écarts à la moyenne :

• (10 – 14) = –4
• (12 – 14) = –2
• (13 – 14) = –1
• (15 – 14) = +1
• (20 – 14) = +6

3. Carrés des écarts :

• (–4)² = 16
• (–2)² = 4
• (–1)² = 1
• (+1)² = 1
• (+6)² = 36

4. Variance :

16 + 4 + 1 + 1 + 36 58
𝜎2 = = = 11,6
5 5

5. Écart-type :

𝜎 = √11,6 ≈ 3,4

Cela signifie que les notes s’écartent en moyenne de 3,4 points autour de la moyenne (14).

14
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie pour comprendre :

• Analogie scolaire : Imagine une classe où la moyenne des notes est 14.
o Si tous les élèves ont entre 13 et 15, l’écart-type est petit (les élèves sont
homogènes).
o Si certains ont 5 et d’autres 20, l’écart-type est grand (les élèves sont très
différents).
• Analogie sportive : Dans une course de 100 m, si tous les coureurs franchissent la ligne
entre 10,1 et 10,3 secondes, l’écart-type est petit. Mais si certains mettent 9,8 secondes
et d’autres 12 secondes, l’écart-type est grand.

Illustration réelle :

• Finance : L’écart-type est utilisé pour mesurer le risque d’un investissement.

o Si les rendements d’une action varient peu autour de la moyenne, l’écart-type
est faible → investissement stable.
o Si les rendements varient beaucoup, l’écart-type est élevé

Section 4 : Sélection et extraction des caractéristiques

Toutes les colonnes d’un dataset ne sont pas utiles.

• Sélection : garder les variables pertinentes (ex. âge, revenu) et supprimer les inutiles
(ex. numéro de dossier).
• Extraction : créer de nouvelles variables à partir des existantes (ex. taille + poids →
IMC).

15
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme préparer une recette : on choisit les bons ingrédients et parfois on
les transforme (farine + eau → pâte).

Illustration réelle : Dans un dataset de santé, on ajoute une colonne “IMC” calculée à partir
de “taille” et “poids”.

Exercice pratique :

On dispose du dataset suivant :

Nom Âge Revenu (FCFA) Ville

Alice 25 2500 Paris
Bob 3000 Lyon
Clara 30 100000 Marseille
David 28 2800 Paris

1. Identifiez les problèmes dans ce dataset.

2. Proposez une méthode pour gérer la valeur manquante.
3. Normalisez la colonne “Revenu” entre 0 et 1.
4. Créez une nouvelle caractéristique “Catégorie d’âge” (Jeune < 30, Adulte ≥ 30).

Solution :

1. Identifier les problèmes

• Âge de Bob manquant.

• Revenu de Clara très élevé (valeur extrême).

Code Python :

import pandas as pd

data = {
"Nom": ["Alice", "Bob", "Clara", "David"],
"Age": [25, None, 30, 28],

16
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

"Revenu": [2500, 3000, 100000, 2800],

"Ville": ["Paris", "Lyon", "Marseille", "Paris"]
}

df = [Link](data)
print([Link]()) # détecter les valeurs manquantes

Analogie : C’est comme vérifier les copies d’examen et repérer celles où une réponse est
manquante.

Illustration réelle : Un tableau Excel avec une cellule vide dans la colonne “Âge”.

2. Gérer la valeur manquante

Remplacer l’âge de Bob par la moyenne des autres (25+30+28)/3 = 27,7 ≈ 28.

Code Python :

df["Age"].fillna(df["Age"].mean(), inplace=True)
print(df)

17
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme remplir une case vide dans un formulaire avec une valeur moyenne
pour ne pas laisser de trou.

Illustration réelle : Un logiciel de gestion qui complète automatiquement les champs

manquants avec une valeur par défaut.

3. Normaliser la colonne “Revenu”

La normalisation est une étape cruciale pour mettre toutes les variables sur une même échelle.
Sans cela, une variable avec des valeurs très grandes (comme le revenu en euros) peut dominer
les calculs et fausser les résultats du modèle.

Formule de la normalisation :

𝑥 − 𝑚𝑖𝑛
𝑥𝑛𝑜𝑟𝑚 =
𝑚𝑎𝑥 − 𝑚𝑖𝑛

• x = valeur brute à normaliser.

• min = valeur minimale de la colonne.
• max = valeur maximale de la colonne.

Explication pas à pas :

1. On soustrait la valeur minimale pour ramener la plus petite valeur à 0.

2. On divise par l’écart entre max et min pour ramener la plus grande valeur à 1.
3. Toutes les autres valeurs se retrouvent proportionnellement entre 0 et 1.

Code Python :

python
df["Revenu_normalise"] = (df["Revenu"] - df["Revenu"].min()) / (df["Revenu"].max() -
df["Revenu"].min())
print(df[["Nom", "Revenu", "Revenu_normalise"]])

Résultats attendus :

• Alice : 0
• Bob : ≈ 0,005
• Clara : 1
• David : ≈ 0,003

18
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme mettre tous les joueurs sur le même terrain de football. Peu
importe qu’un joueur vienne d’un petit club ou d’un grand club, une fois sur le terrain, ils sont
comparés équitablement.

Illustration réelle : Imaginez un graphique où les revenus bruts (2000–100000) sont

transformés en valeurs entre 0 et 1. Cela permet de comparer un salarié moyen et un
millionnaire sur une même échelle sans que le millionnaire écrase les autres.

4. Créer une nouvelle caractéristique “Catégorie d’âge”

Les modèles de Machine Learning bénéficient souvent de variables dérivées. Ici, on peut
transformer la variable “Âge” en une catégorie qualitative : “Jeune” ou “Adulte”.

Règle de transformation :

• Si âge < 30 → Jeune.

• Si âge ≥ 30 → Adulte.

Code Python :

python
df["Categorie_age"] = df["Age"].apply(lambda x: "Jeune" if x < 30 else "Adulte")
print(df[["Nom", "Age", "Categorie_age"]])

Résultats attendus :

• Alice (25) → Jeune

• Bob (28) → Jeune
• Clara (30) → Adulte
• David (28) → Jeune

19
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme classer les élèves en deux groupes : les juniors et les seniors. Cela
simplifie la comparaison et permet d’adapter les analyses à chaque catégorie.

Illustration réelle : Un tableau médical qui regroupe les patients en catégories d’âge pour une
étude : “Jeunes” pour les moins de 30 ans, “Adultes” pour les 30 ans et plus. Cela permet de
comparer les comportements ou les risques selon les tranches d’âge.

20
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Chapitre 3 : Apprentissage Supervisé

L’apprentissage supervisé est une méthode d’apprentissage automatique où l’on fournit au
modèle des données étiquetées. Cela signifie que chaque exemple d’entraînement est
accompagné de la réponse correcte. Le modèle apprend à associer les caractéristiques (features)
aux étiquettes (labels) pour pouvoir prédire correctement de nouvelles données.

• Entrée (features) : les variables descriptives (ex. taille, poids, couleur).

• Sortie (label) : la réponse attendue (ex. fruit = pomme).
• Objectif : apprendre une fonction ( f(x) ) qui, à partir des entrées, prédit la sortie.

Analogie : C’est comme un élève qui révise avec un corrigé. On lui donne des exercices avec
les réponses. En comparant ses essais avec les corrections, il apprend à résoudre de nouveaux
exercices.

Illustration réelle : Un logiciel de reconnaissance d’images reçoit des milliers de photos de

chats et de chiens avec leurs étiquettes. Lorsqu’on lui présente une nouvelle photo, il peut
prédire si c’est un chat ou un chien.

Section 2 : Les algorithmes de régression

La régression est utilisée quand la sortie est une valeur numérique continue.

a) Régression linéaire

La régression linéaire cherche à modéliser la relation entre une variable indépendante (x) et
une variable dépendante (y) en traçant une droite qui s’ajuste au mieux aux données.

Formule : y=a*x+b

où (a) est la pente et (b) l’ordonnée à l’origine.

Cas d’usage

• Prédire le prix d’une maison en fonction de sa surface.

21
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

• Estimer le revenu en fonction du nombre d’années d’expérience.

• Prédire la consommation d’énergie en fonction de la température.

Exemple :

Dataset :

Surface (m²) Prix (FCFA)

50 150000
60 180000
80 240000
100 300000

Code Python :

import pandas as pd
from sklearn.linear_model import LinearRegression

X = [[50], [60], [80], [100]]

y = [150000, 180000, 240000, 300000]

model = LinearRegression()
[Link](X, y)

prediction = [Link]([[70]])
print("Prix prédit pour 70 m² :", prediction[0])

Résultat : environ 210000 FCFA.

Analogie : C’est comme tracer une ligne de tendance sur un graphique de notes scolaires
pour estimer la note d’un nouvel élève.

Illustration réelle : Graphique montrant les points (surface vs prix) et la droite de régression
passant au milieu des points.

b) Régression polynomiale

22
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

La régression polynomiale est une extension de la régression linéaire. Elle utilise une courbe
polynomiale pour mieux représenter les données lorsque la relation n’est pas linéaire.

Formule : y=a0+a1x+a2x2+...+anxn

Cas d’usage

• Prédire la croissance d’une population au fil du temps.

• Modéliser la trajectoire d’un objet en mouvement.
• Estimer la progression d’une maladie.

Exemple :

Dataset : années vs population.

Code Python :

import numpy as np
from [Link] import PolynomialFeatures
from sklearn.linear_model import LinearRegression

X = [Link]([1,2,3,4,5]).reshape(-1,1) # années
y = [Link]([100,150,300,600,1200]) # population

poly = PolynomialFeatures(degree=2)
X_poly = poly.fit_transform(X)

model = LinearRegression()
[Link](X_poly, y)

prediction = [Link]([Link]([[6]]))
print("Population prédite pour l'année 6 :", prediction[0])

Résultat : environ 2000 habitants.

23
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme dessiner une courbe qui suit les montagnes et vallées d’un paysage
au lieu d’une simple ligne droite.

Illustration réelle : Graphique montrant une courbe polynomiale épousant les points de
croissance.

Section 3 : Les algorithmes de classification

La classification est utilisée quand la sortie est une catégorie.

a) k-Nearest Neighbors (k-NN)

Le k-NN classe un nouvel élément selon les catégories de ses voisins les plus proches. On
calcule la distance entre le nouvel élément et les autres, puis on regarde la majorité des voisins.

Formule de distance euclidienne : d(x,y)=√∑(𝑥𝑖 − 𝑦𝑖)2

Cas d’usage

• Reconnaissance de chiffres manuscrits (MNIST dataset).

• Classification de fruits selon couleur et forme.
• Détection de maladies selon symptômes.

Exemple :

Dataset de fruits avec couleur et forme.

Code Python :

import pandas as pd
from [Link] import KNeighborsClassifier

data = {
"Couleur": ["Rouge", "Jaune", "Orange"],
"Forme": ["Ronde", "Longue", "Ronde"],
"Fruit": ["Pomme", "Banane", "Orange"]
}
df = [Link](data)

X = pd.get_dummies(df[["Couleur","Forme"]])
y = df["Fruit"]

model = KNeighborsClassifier(n_neighbors=1)
[Link](X, y)

new_fruit = [Link]({"Couleur":["Jaune"],"Forme":["Longue"]})
new_fruit_encoded = pd.get_dummies(new_fruit).reindex(columns=[Link], fill_value=0)

prediction = [Link](new_fruit_encoded)

24
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

print("Fruit prédit :", prediction[0])

Résultat : Banane.

Analogie : C’est comme demander l’avis des voisins pour savoir si une maison est belle.

Illustration réelle : Graphique montrant des points regroupés par proximité.

b) Arbres de décision

Les arbres de décision posent des questions successives (“Couleur = Jaune ?”) pour arriver à
une classe. Chaque nœud correspond à une condition, chaque feuille à une classe.

Cas d’usage

• Prédire si une personne est éligible à un prêt.

• Diagnostiquer une maladie selon les symptômes.
• Décider si un email est spam ou non.

Exemple :

Dataset : âge, revenu, prêt accordé.

Code Python :

from [Link] import DecisionTreeClassifier

X = [[25,2500],[30,4000],[40,5000],[20,1000]]
y = ["Oui","Oui","Oui","Non"]

model = DecisionTreeClassifier()
[Link](X,y)

prediction = [Link]([[28,3000]])
print("Prêt accordé :", prediction[0])

25
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Résultat : Oui.

Analogie : C’est comme jouer à 20 questions pour deviner un objet.

Illustration réelle : Diagramme d’arbre avec branches “Âge > 25 ?”, “Revenu > 2000 ?”.

c) Random Forest

Le Random Forest combine plusieurs arbres de décision pour améliorer la précision. Chaque
arbre vote, et la majorité détermine la classe finale.

Cas d’usage

• Prédire la probabilité de défaut de paiement.

• Détection de fraude bancaire.
• Classification d’images.

Exemple :

Dataset : âge, revenu, historique de crédit.

Code Python :

from [Link] import RandomForestClassifier

X = [[25,2500],[30,4000],[40,5000],[20,1000]]
y = ["Oui","Oui","Oui","Non"]

model = RandomForestClassifier(n_estimators=10)
[Link](X,y)

prediction = [Link]([[28,3000]])
print("Prêt accordé :", prediction[0])

Résultat : Oui.

26
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme demander l’avis de plusieurs experts et prendre la décision

majoritaire.

Illustration réelle : Graphique montrant plusieurs arbres votant pour une décision finale.

d) Support Vector Machines (SVM)

Les SVM (Support Vector Machines) cherchent à séparer les classes en traçant une frontière
optimale. Cette frontière est appelée hyperplan. L’idée est de trouver l’hyperplan qui
maximise la marge, c’est-à-dire la distance entre la frontière et les points les plus proches de
chaque classe (appelés vecteurs de support).

Formellement, pour deux classes, le SVM cherche à résoudre :

1
min ∣∣ 𝑤 ∣∣2 sous contrainte que 𝑦𝑖 (𝑤 ⋅ 𝑥𝑖 + 𝑏) ≥ 1
2

où 𝑤 est le vecteur de poids, 𝑏 le biais, et 𝑦𝑖 les étiquettes (+1 ou –1).

Cas d’usage :

• Filtrage de spam : distinguer les emails “Spam” et “Non Spam”.

• Reconnaissance faciale : séparer les visages connus des inconnus.
• Classification médicale : prédire si un patient est malade ou non.

Exemple :

Supposons un dataset avec deux variables : longueur du texte et nombre de mots suspects.

Code Python :

python
from sklearn import svm

X = [[10,1],[20,5],[30,10],[40,15]] # longueur, mots suspects

y = ["Non Spam","Spam","Spam","Spam"]

27
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

model = [Link](kernel='linear')
[Link](X,y)

prediction = [Link]([[25,7]])
print("Email :", prediction[0])

Résultat : Spam.

Analogie : C’est comme tracer une ligne dans le sable pour séparer deux groupes d’enfants
qui jouent. On place la ligne de manière à ce qu’elle soit la plus éloignée possible des enfants
de chaque groupe, pour éviter toute confusion.

Illustration réelle : Un graphique montrant deux groupes de points (Spam vs Non Spam)
séparés par une ligne droite avec une marge maximale.

e) Réseaux de neurones supervisés

Les réseaux de neurones artificiels sont inspirés du cerveau humain. Ils sont constitués de
couches de neurones reliés entre eux. Chaque neurone reçoit des entrées, applique une
fonction d’activation, et transmet une sortie.

Formule d’un neurone :

𝑦 = 𝑓(∑𝑤𝑖 𝑥𝑖 + 𝑏)

où 𝑤𝑖 sont les poids, 𝑥𝑖 les entrées, 𝑏 le biais, et 𝑓 la fonction d’activation (sigmoïde, ReLU,
etc.).

Cas d’usage

• Reconnaissance d’images : identifier des objets dans des photos.

• Reconnaissance vocale : convertir la voix en texte.
• Traduction automatique : traduire une phrase d’une langue à une autre.

Exemple :

28
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Dataset : images de chiffres manuscrits (MNIST).

Code Python :

python
from sklearn.neural_network import MLPClassifier
from [Link] import load_digits
from sklearn.model_selection import train_test_split

digits = load_digits()
X_train, X_test, y_train, y_test = train_test_split([Link], [Link], test_size=0.3)

model = MLPClassifier(hidden_layer_sizes=(50,), max_iter=500)

[Link](X_train, y_train)

score = [Link](X_test, y_test)

print("Précision du réseau de neurones :", score)

Résultat : précision ≈ 95 %.

Analogie : C’est comme un cerveau artificiel qui apprend à reconnaître des motifs. Chaque
neurone est comme un petit “décideur” qui transmet son avis aux autres, et ensemble ils
prennent une décision finale.

Illustration réelle : Un schéma montrant une couche d’entrée (pixels d’une image), une
couche cachée (neurones intermédiaires), et une couche de sortie (chiffre reconnu).

4. Mesures d’évaluation des modèles

Évaluer un modèle est essentiel pour savoir s’il est fiable.

• Précision (Accuracy) : proportion de bonnes prédictions.

𝑁𝑜𝑚𝑏𝑟𝑒 𝑑𝑒 𝑝𝑟é𝑑𝑖𝑐𝑡𝑖𝑜𝑛𝑠 𝑐𝑜𝑟𝑟𝑒𝑐𝑡𝑒𝑠

𝐴𝑐𝑐𝑢𝑟𝑎𝑐𝑦 =
𝑁𝑜𝑚𝑏𝑟𝑒 𝑡𝑜𝑡𝑎𝑙 𝑑𝑒 𝑝𝑟é𝑑𝑖𝑐𝑡𝑖𝑜𝑛𝑠

29
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

• Rappel (Recall) : capacité à détecter tous les cas positifs.

𝑉𝑟𝑎𝑖𝑠 𝑝𝑜𝑠𝑖𝑡𝑖𝑓𝑠
𝑅𝑒𝑐𝑎𝑙𝑙 =
𝑉𝑟𝑎𝑖𝑠 𝑝𝑜𝑠𝑖𝑡𝑖𝑓𝑠 + 𝐹𝑎𝑢𝑥 𝑛é𝑔𝑎𝑡𝑖𝑓𝑠

• F1-Score : moyenne harmonique entre précision et rappel.

𝑃𝑟𝑒𝑐𝑖𝑠𝑖𝑜𝑛 ∗ 𝑅𝑒𝑐𝑎𝑙𝑙
𝐹1 = 2 ∗
𝑃𝑟𝑒𝑐𝑖𝑠𝑖𝑜𝑛 + 𝑅𝑒𝑐𝑎𝑙𝑙

• Courbe ROC-AUC : mesure la capacité du modèle à distinguer les classes.

Analogie : C’est comme évaluer un médecin :

• Précision = combien de diagnostics corrects.

• Rappel = combien de malades correctement identifiés.
• F1-Score = équilibre entre les deux.

Illustration réelle : Graphique ROC montrant la performance d’un modèle de classification.

Exercice pratique :

Énoncé : On dispose du dataset suivant :

Surface (m²) Prix (FCFA)

50 150000
60 180000
80 240000
100 300000

1. Utilisez une régression linéaire pour prédire le prix d’une maison de 70 m².
2. Évaluez la précision du modèle.
3. Expliquez le résultat avec une analogie.
4. Comparez avec un arbre de décision et un k-NN.

30
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Solution avec Python :

1. Régression linéaire

import pandas as pd
from sklearn.linear_model import LinearRegression

X = [[50], [60], [80], [100]]

y = [150000, 180000, 240000, 300000]

model = LinearRegression()
[Link](X, y)

prediction = [Link]([[70]])
print("Prix prédit pour 70 m² :", prediction[0])

Résultat : environ 210000 FCFA.

2. Évaluation du modèle

from [Link] import r2_score

y_pred = [Link](X)
score = r2_score(y, y_pred)
print("Score R² :", score)

Résultat : R² ≈ 0,99, excellente précision.

3. Comparaison avec un arbre de décision

from [Link] import DecisionTreeRegressor

tree = DecisionTreeRegressor()
[Link](X,y)

prediction_tree = [Link]([[70]])
print("Prix prédit par arbre de décision :", prediction_tree[0])

Résultat : environ 180000 FCFA (car l’arbre prend la valeur du voisinage le plus proche).

4. Comparaison avec k-NN

from [Link] import KNeighborsRegressor

knn = KNeighborsRegressor(n_neighbors=2)
[Link](X,y)

prediction_knn = [Link]([[70]])
print("Prix prédit par k-NN :", prediction_knn[0])

31
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Résultat : environ 210000 FCFA (moyenne des voisins 60 et 80).

Analogie finale

• La régression linéaire est comme tracer une ligne de tendance.

• L’arbre de décision est comme poser des questions successives et choisir une valeur
proche.
• Le k-NN est comme demander l’avis des voisins et prendre la moyenne.

Illustration réelle : Graphique comparant les trois méthodes sur le même dataset.

32
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Chapitre 4 : Apprentissage Non Supervisé

L’apprentissage non supervisé est une méthode où l’on entraîne un modèle sans lui fournir
de réponses (étiquettes). Contrairement à l’apprentissage supervisé, où chaque exemple est
accompagné d’une solution, ici le modèle doit découvrir par lui-même des structures cachées
dans les données.

• Pas d’étiquettes : on ne dit pas au modèle “ceci est un chat” ou “ceci est un chien”.
• Objectif : trouver des regroupements, des motifs ou des représentations utiles.
• Résultat : le modèle organise les données en catégories ou réduit leur complexité.

Analogie : C’est comme entrer dans une bibliothèque sans catalogue. Tu dois toi-même
regrouper les livres par thèmes (romans, sciences, histoire) en observant leurs contenus.

Illustration réelle : Un site de e-commerce qui regroupe automatiquement les clients en

segments (“acheteurs réguliers”, “nouveaux clients”, “clients premium”) sans qu’on lui ait
donné ces catégories.

Section 1 : Les algorithmes de regroupement (Clustering)

Le clustering consiste à regrouper des données similaires.

a) k-Means Clustering

Le k-Means est l’algorithme de clustering le plus connu. Il divise les données en (k) groupes
(clusters).

Étapes :

1. Choisir le nombre de clusters (k).

2. Placer aléatoirement (k) centres (appelés centroides).
3. Assigner chaque point au centre le plus proche.
4. Recalculer les centres comme la moyenne des points assignés.
5. Répéter jusqu’à stabilisation.

33
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Formule de distance euclidienne :

𝑑(𝑥, 𝑦) = √∑( 𝑥𝑖 − 𝑦𝑖 )2
𝑖=1

Cette formule calcule la distance entre deux points (x) et (y). Plus la distance est petite, plus
les points sont proches.

Cas d’usage

• Regrouper des clients selon leurs habitudes d’achat.

• Segmenter des documents par thèmes.
• Organiser des images par similarité.

Exemple :

Dataset : coordonnées de clients (âge, revenu).

Code Python :

import numpy as np
from [Link] import KMeans

X = [Link]([[25,2500],[30,4000],[40,5000],[20,1000],[35,4500],[50,8000]])

model = KMeans(n_clusters=2, random_state=0)

[Link](X)

print("Centres des clusters :", model.cluster_centers_)

print("Labels attribués :", model.labels_)

Résultat : deux groupes de clients (revenus faibles vs revenus élevés).

Analogie : C’est comme séparer les élèves en deux groupes : ceux qui ont de bonnes notes
et ceux qui ont des notes plus faibles.

34
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Illustration réelle : Graphique montrant deux nuages de points regroupés autour de leurs
centres.

b) Clustering hiérarchique

Le clustering hiérarchique construit une hiérarchie de groupes. On peut visualiser cela avec un
dendrogramme.

Étapes :

1. Chaque point commence comme un cluster individuel.

2. On fusionne les clusters les plus proches.
3. On répète jusqu’à obtenir un seul grand cluster.

Cas d’usage

• Regrouper des espèces animales selon leurs caractéristiques.

• Organiser des documents par similarité.
• Créer des taxonomies en biologie.

Exemple :

Code Python :

import numpy as np
from [Link] import linkage, dendrogram
import [Link] as plt

X = [Link]([[25,2500],[30,4000],[40,5000],[20,1000],[35,4500],[50,8000]])

Z = linkage(X, 'ward')
dendrogram(Z)
[Link]()

Résultat : un dendrogramme montrant les regroupements successifs.

35
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme un arbre généalogique qui montre comment les familles se
regroupent.

Illustration réelle : Un dendrogramme où les clients sont regroupés progressivement.

c) DBSCAN (Density-Based Spatial Clustering of Applications with Noise)

DBSCAN regroupe les points en fonction de leur densité.

• Les points dans une zone dense forment un cluster.

• Les points isolés sont considérés comme du bruit.

Formule clé : Un point appartient à un cluster si au moins MinPts voisins se trouvent dans un
rayon 𝜀.

Cas d’usage

• Détection de fraudes (points isolés).

• Analyse de données géographiques.
• Regroupement de capteurs dans un réseau.

Exemple :

Code Python :

from [Link] import DBSCAN

X = [Link]([[1,2],[2,2],[2,3],[8,7],[8,8],[25,80]])

model = DBSCAN(eps=3, min_samples=2)

labels = model.fit_predict(X)

print("Labels attribués :", labels)

Résultat : deux clusters + un point considéré comme bruit.

36
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme repérer les groupes d’élèves qui discutent ensemble et ignorer celui
qui est seul dans un coin.

Illustration réelle : Graphique montrant des clusters denses et des points isolés.

Section 2 : Les algorithmes de réduction de dimension

La réduction de dimension consiste à simplifier les données tout en gardant l’essentiel.

a) Analyse en composantes principales (ACP / PCA)

La PCA réduit le nombre de variables en créant de nouvelles variables appelées composantes

principales. Ces composantes capturent la variance maximale des données.

Formule :

On calcule la matrice de covariance :

1
𝐶= ∑(𝑥𝑖 − 𝜇)(𝑥𝑖 − 𝜇)𝑇
𝑛

Puis on trouve les vecteurs propres (directions principales) et valeurs propres (importance).

Cas d’usage :

• Réduire la dimension des images pour accélérer l’apprentissage.

• Visualiser des données complexes en 2D ou 3D.
• Éliminer les variables redondantes.

Exemple :

Code Python :

from [Link] import PCA

from [Link] import load_digits

digits = load_digits()
X = [Link]

pca = PCA(n_components=2)
X_reduced = pca.fit_transform(X)

print("Forme des données réduites :", X_reduced.shape)

Résultat : les données passent de 64 dimensions (pixels) à 2 dimensions.

37
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme résumer un livre en quelques phrases tout en gardant l’essentiel.

Illustration réelle : Graphique montrant les chiffres manuscrits projetés en 2D.

b) t-SNE (t-Distributed Stochastic Neighbor Embedding)

Le t-SNE est une méthode de réduction non linéaire. Il projette les données dans un espace de
faible dimension tout en préservant les relations de voisinage.

Cas d’usage :

• Visualiser des clusters complexes.

• Explorer des données de haute dimension.

Exemple :

Code Python :

from [Link] import TSNE

import [Link] as plt

X_embedded = TSNE(n_components=2).fit_transform(X[:500])

[Link](X_embedded[:,0], X_embedded[:,1])
[Link]()

Résultat : visualisation claire des regroupements.

38
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme dessiner une carte simplifiée d’une ville où les quartiers proches
restent proches.

Section 3 : Évaluation des modèles non supervisés

Évaluer un modèle non supervisé est plus difficile car il n’y a pas d’étiquettes pour comparer
les résultats. On utilise des mesures internes et des visualisations.

a) Indice de silhouette

Cet indice mesure à quel point les points d’un cluster sont cohésifs et bien séparés des autres
clusters.
𝑏−𝑎
Formule : 𝑆𝑖𝑙ℎ𝑜𝑢𝑒𝑡𝑡𝑒 = max (𝑎,𝑏)

• (a) = distance moyenne entre un point et les autres points de son cluster.
• (b) = distance moyenne entre ce point et les points du cluster le plus proche.

Valeurs possibles :

• proche de 1 → clusters bien séparés.

• proche de 0 → clusters qui se chevauchent.
• négatif → mauvais regroupement.

b) Inertie (k-Means)

L’inertie mesure la somme des distances des points à leur centre de cluster. Plus l’inertie est
faible, plus les clusters sont compacts.

Formule : 𝐼𝑛𝑒𝑟𝑡𝑖𝑒 = ∑𝑛𝑖=1 ∣∣ 𝑥𝑖 − 𝑐𝑙𝑎𝑏𝑒𝑙(𝑖) ∣∣2

Où 𝑐𝑙𝑎𝑏𝑒𝑙(𝑖) est le centre du cluster auquel appartient 𝑥𝑖 .

39
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme évaluer un groupe d’élèves : on regarde si les élèves d’un même
groupe se ressemblent et si les groupes sont bien distincts.

Illustration réelle : Un graphique de silhouette montrant la qualité des clusters.

Section 4 : Détection d’anomalies

L’apprentissage non supervisé est aussi utilisé pour détecter des anomalies, c’est-à-dire des
points qui ne ressemblent pas aux autres.

Une anomalie est un point isolé ou très éloigné des clusters principaux.

a) Algorithmes utilisés

• Isolation Forest : construit des arbres qui isolent les points. Les anomalies sont isolées
plus rapidement.
• One-Class SVM : apprend une frontière autour des données normales et considère les
points extérieurs comme anomalies.

b) Formule (Isolation Forest)

Chaque arbre sépare les données en sous-ensembles. La longueur moyenne du chemin pour
isoler un point est utilisée comme score d’anomalie.

𝐸(ℎ(𝑥))
−
𝑆𝑐𝑜𝑟𝑒(𝑥) = 2 𝑐(𝑛)

Où 𝐸(ℎ(𝑥)) est la longueur moyenne du chemin pour isoler 𝑥, et 𝑐(𝑛) est une constante de
normalisation.

Cas d’usage :

• Détection de fraude bancaire.

• Détection d’intrusions dans un réseau informatique.
• Détection de défauts dans une chaîne de production.

40
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Exemple :

Code Python :

import numpy as np
from [Link] import IsolationForest

X = [Link]([[10],[12],[11],[13],[100]]) # 100 est une anomalie

model = IsolationForest(contamination=0.2)
[Link](X)

predictions = [Link](X)
print("Résultats :", predictions)

Résultat : le point 100 est identifié comme anomalie.

Analogie : C’est comme repérer un élève qui a une note de 0 alors que tous les autres ont
entre 10 et 15.

Illustration réelle : Graphique montrant un nuage de points avec un point isolé loin des autres.

Exercice pratique :

On dispose du dataset suivant (âge, revenu) :

Âge Revenu (FCFA)

25 2500
30 4000
40 5000
20 1000
35 4500
50 8000
60 20000

41
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

1. Appliquez un clustering k-Means avec (k=2).

2. Visualisez les clusters.
3. Évaluez la qualité avec l’indice de silhouette.
4. Détectez les anomalies avec Isolation Forest.
5. Expliquez les résultats avec une analogie.

Solution avec Python :

import numpy as np
import [Link] as plt
from [Link] import KMeans
from [Link] import silhouette_score
from [Link] import IsolationForest

# Dataset
X = [Link]([[25,2500],[30,4000],[40,5000],[20,1000],[35,4500],[50,8000],[60,20000]])

# 1. Clustering k-Means
model = KMeans(n_clusters=2, random_state=0)
labels = model.fit_predict(X)
centers = model.cluster_centers_

# 2. Visualisation
[Link](X[:,0], X[:,1], c=labels)
[Link](centers[:,0], centers[:,1], c='red', marker='x')
[Link]("Âge")
[Link]("Revenu (FCFA)")
[Link]("Clustering k-Means")
[Link]()

# 3. Évaluation silhouette
score = silhouette_score(X, labels)
print("Indice de silhouette :", score)

# 4. Détection d'anomalies
iso = IsolationForest(contamination=0.2)
anomalies = iso.fit_predict(X)
print("Anomalies détectées :", anomalies)

Résultats attendus :

• Deux clusters : jeunes avec revenus faibles/moyens et plus âgés avec revenus élevés.
• Indice de silhouette positif (clusters bien séparés).
• Le point (60, 20000) est détecté comme anomalie.

42
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme séparer les clients d’un supermarché en deux catégories : ceux qui
achètent des produits bon marché et ceux qui achètent des produits premium. L’anomalie est
un client exceptionnel qui dépense énormément, très différent des autres.

Illustration réelle : Graphique montrant deux clusters distincts avec un point isolé.

43
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Chapitre 5 : Réseaux de Neurones et Apprentissage Profond

Section 1 : Introduction aux réseaux de neurones

Les réseaux de neurones artificiels sont inspirés du fonctionnement du cerveau humain. Dans
notre cerveau, les neurones biologiques reçoivent des signaux, les pondèrent, et transmettent
une réponse. Les réseaux artificiels imitent ce principe avec des neurones mathématiques
reliés en couches.

Chaque neurone artificiel reçoit des entrées (features), applique des poids pour mesurer leur
importance, ajoute un biais pour ajuster la décision, puis applique une fonction d’activation
pour produire une sortie.

Formule d’un neurone :

𝑛

𝑦 = 𝑓 (∑ 𝑤𝑖 ⋅ 𝑥𝑖 + 𝑏)
𝑖=1

• (x_i) = les entrées (par exemple, pixels d’une image).

• (w_i) = les poids (importance de chaque entrée).
• (b) = biais (ajustement).
• (f) = fonction d’activation (sigmoïde, ReLU, tanh).

Analogie : Imagine un élève qui reçoit plusieurs conseils (entrées). Il accorde plus ou moins
d’importance à chaque conseil (poids), ajoute son propre jugement (biais), puis prend une
décision finale (fonction d’activation).

Illustration réelle : Un schéma montrant une couche d’entrée (pixels), une couche cachée
(neurones intermédiaires), et une couche de sortie (classe prédite).

Section 2 : Bases de l’apprentissage profond

L’apprentissage profond (Deep Learning) est une extension des réseaux de neurones,
utilisant plusieurs couches cachées pour apprendre des représentations complexes.

44
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

a) Propagation avant (Forward Propagation)

Les données passent de la couche d’entrée à la couche de sortie en traversant les couches
cachées. Chaque neurone calcule sa sortie avec la formule précédente.

b) Rétropropagation (Backpropagation)

Le modèle ajuste ses poids en fonction de l’erreur commise.

Formule de mise à jour des poids :

∂𝐿
𝑤𝑛𝑒𝑤 = 𝑤𝑜𝑙𝑑 − 𝜂 ⋅
∂𝑤

• 𝐿= fonction de perte (erreur).

• 𝜂= taux d’apprentissage (learning rate).
∂𝐿
• = dérivée de la perte par rapport au poids.
∂𝑤

Analogie : C’est comme un élève qui corrige ses erreurs après avoir reçu la correction d’un
examen.

Illustration réelle : Un schéma montrant la propagation avant (calcul des sorties) et la

rétropropagation (ajustement des poids).

Section 3 : Réseaux de neurones convolutionnels (CNN)

Les CNN sont utilisés principalement pour les images. Un CNN applique des filtres (kernels)
sur l’image pour détecter des motifs (bords, textures, formes).

Formule de convolution :

𝑆(𝑖, 𝑗) = ∑ ∑ 𝐼(𝑖 + 𝑚, 𝑗 + 𝑛) ⋅ 𝐾(𝑚, 𝑛)

𝑛
𝑚

45
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

• 𝐼= image.
• 𝐾= filtre.
• 𝑆= sortie (feature map).

b) Cas d’usage

• Reconnaissance d’images (chats vs chiens).

• Détection d’objets.
• Vision par ordinateur (voitures autonomes).

Analogie : C’est comme passer une loupe sur une image pour repérer des détails précis.

Illustration réelle : Un schéma montrant une image, un filtre appliqué, et la carte de

caractéristiques produite.

Code Python (Keras) :

from [Link] import Sequential

from [Link] import Conv2D, MaxPooling2D, Flatten, Dense

model = Sequential([
Conv2D(32, (3,3), activation='relu', input_shape=(64,64,3)),
MaxPooling2D(pool_size=(2,2)),
Flatten(),
Dense(128, activation='relu'),
Dense(1, activation='sigmoid')
])

Section 4 : Réseaux de neurones récurrents (RNN)

Les RNN sont utilisés pour les données séquentielles (texte, séries temporelles). Un RNN garde
une mémoire des états précédents pour traiter des séquences.

Formule de mise à jour :

46
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

ℎ𝑡 = 𝑓(𝑊 ⋅ 𝑥𝑡 + 𝑈 ⋅ ℎ𝑡−1 + 𝑏)

• ℎ𝑡 = état caché à l’instant 𝑡.

• 𝑥𝑡 = entrée à l’instant 𝑡.
• ℎ𝑡−1= état précédent.
• 𝑊, 𝑈, 𝑏= paramètres du modèle.

Cas d’usage :

• Prédiction de mots dans une phrase.

• Traduction automatique.
• Analyse de séries temporelles (prévision météo).

Analogie : C’est comme un élève qui se souvient des phrases précédentes pour comprendre la
suite d’un texte.

Illustration réelle : Un schéma montrant une séquence de mots passant à travers un RNN.

Section 5 : Introduction aux frameworks

Pour implémenter des réseaux de neurones, on utilise des frameworks spécialisés :

• TensorFlow : puissant et flexible, utilisé en recherche et production.

• Keras : interface simple, construite sur TensorFlow.
• PyTorch : très populaire en recherche, syntaxe intuitive.

Exemple avec Keras :

from [Link] import Sequential

from [Link] import Dense

model = Sequential([
Dense(10, activation='relu', input_shape=(5,)),
Dense(1, activation='sigmoid')
])

47
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

[Link](optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

Exercice pratique :

Construisons un réseau de neurones pour reconnaître les chiffres manuscrits (dataset MNIST).

Étape 1 : Charger les données

from [Link] import mnist

from [Link] import to_categorical

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape((60000, 28*28)).astype('float32') / 255

X_test = X_test.reshape((10000, 28*28)).astype('float32') / 255

y_train = to_categorical(y_train)
y_test = to_categorical(y_test)s

Étape 2 : Construire le réseau

from [Link] import Sequential

from [Link] import Dense

model = Sequential([
Dense(128, activation='relu', input_shape=(28*28,)),
Dense(10, activation='softmax')
])

Étape 3 : Compiler et entraîner

[Link](optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

history = [Link](X_train, y_train, epochs=5, batch_size=128, validation_split=0.1)

Étape 4 : Évaluer le modèle

test_loss, test_acc = [Link](X_test, y_test)

print("Précision sur les données de test :", test_acc)

Résultat attendu : une précision autour de 97 %.

Étape 5 : Interprétation et analogie

Le réseau de neurones a appris à reconnaître les chiffres manuscrits en ajustant ses poids.

48
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme un élève qui s’entraîne à lire des écritures manuscrites. Au début, il
fait des erreurs, mais après avoir vu des milliers d’exemples, il devient capable de reconnaître
presque tous les chiffres correctement.

49
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Chapitre 6 : Évaluation et Optimisation des Modèles

Construire un modèle d’apprentissage automatique est une étape importante, mais ce n’est pas
suffisant. Un modèle peut sembler performant sur les données d’entraînement et pourtant
échouer sur de nouvelles données. C’est pourquoi il faut évaluer sa performance et optimiser
ses paramètres.

Analogie : Imagine un élève qui révise pour un examen. Il ne suffit pas de réussir les exercices
du manuel : il faut vérifier ses réponses avec différents tests, ajuster sa méthode de travail, et
éviter de trop mémoriser les exemples (surapprentissage) ou de rester trop superficiel
(sous-apprentissage).

Section 1 : Techniques de validation croisée

La validation croisée est une méthode pour tester la robustesse d’un modèle. On divise les
données en plusieurs sous-ensembles (appelés folds). Le modèle est entraîné sur certains folds
et testé sur les autres. On répète l’opération plusieurs fois et on calcule la moyenne des
performances.

Formule

𝑘
1
𝑆𝑐𝑜𝑟𝑒 = ∑ 𝑃𝑒𝑟𝑓𝑜𝑟𝑚𝑎𝑛𝑐 𝑒𝑖
𝑘
𝑖=1

Cela signifie que l’on calcule la performance sur chaque fold, puis on fait la moyenne.

Exemple pratique :

Prenons le dataset Iris (classification de fleurs).

# Importer les bibliothèques nécessaires

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from [Link] import load_iris

50
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

# Charger le dataset Iris

X, y = load_iris(return_X_y=True)

# Créer un modèle de régression logistique

model = LogisticRegression(max_iter=200)

# Appliquer une validation croisée à 5 folds

scores = cross_val_score(model, X, y, cv=5)

# Afficher les résultats

print("Scores de validation croisée :", scores)
print("Score moyen :", [Link]())

Commentaires :

• cv=5 signifie que les données sont divisées en 5 sous-ensembles.

• Le modèle est entraîné 5 fois et testé 5 fois.
• On obtient 5 scores, puis on calcule la moyenne.

Résultat attendu : un score moyen autour de 95 %.

Analogie : C’est comme un élève qui révise avec 5 séries de questions différentes pour
s’assurer qu’il est prêt à affronter n’importe quel examen.

Section 2 : Ajustement des hyperparamètres

Les hyperparamètres sont des paramètres fixés avant l’entraînement (par exemple,
profondeur d’un arbre, nombre de neurones, taux d’apprentissage).

a) Grid Search

On teste toutes les combinaisons possibles d’hyperparamètres.

b) Random Search

51
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

On teste des combinaisons aléatoires.

c) Formule (Grid Search)

Si on a 𝑛hyperparamètres avec 𝑚valeurs chacun, le nombre total de combinaisons est :

𝐶𝑜𝑚𝑏𝑖𝑛𝑎𝑖𝑠𝑜𝑛𝑠 = 𝑚𝑛

Exemple :

Optimisation d’un SVM sur le dataset Iris.

# Importer les bibliothèques nécessaires

from sklearn.model_selection import GridSearchCV
from [Link] import SVC

# Charger le dataset Iris

X, y = load_iris(return_X_y=True)

# Définir la grille de paramètres à tester

param_grid = {'C':[0.1,1,10], 'kernel':['linear','rbf']}

# Créer un GridSearchCV
grid = GridSearchCV(SVC(), param_grid, cv=3)

# Entraîner le modèle avec toutes les combinaisons

[Link](X,y)

# Afficher les meilleurs paramètres et le meilleur score

print("Meilleurs paramètres :", grid.best_params_)
print("Meilleur score :", grid.best_score_)

Commentaires :

• C est un hyperparamètre qui contrôle la régularisation.

• kernel définit la fonction utilisée par le SVM (linéaire ou gaussienne).
• Le Grid Search teste toutes les combinaisons possibles.

Résultat attendu : meilleurs paramètres autour de C=1, kernel=rbf.

52
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme essayer toutes les recettes possibles pour trouver la meilleure façon
de cuisiner un plat.

Section 3 : Sélection et comparaison des modèles

Il existe plusieurs modèles (régression, arbres, réseaux de neurones). On doit choisir celui qui
convient le mieux.

Critères de comparaison :

• Précision : taux de bonnes prédictions.

• Temps d’entraînement : rapidité du modèle.
• Complexité : difficulté à comprendre et à expliquer.
• Interprétabilité : capacité à expliquer les décisions du modèle.

Analogie : C’est comme choisir un moyen de transport : la voiture est rapide mais coûteuse, le
vélo est lent mais économique, le train est équilibré.

Section 4 : Surapprentissage et sous-apprentissage

a) Surapprentissage (Overfitting)

53
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Le modèle apprend trop bien les données d’entraînement et échoue sur les nouvelles données.

b) Sous-apprentissage (Underfitting)

Le modèle est trop simple et ne capture pas la complexité des données.

Illustration réelle :

• Surapprentissage : une courbe qui colle trop aux points d’entraînement.

• Sous-apprentissage : une ligne droite qui ne reflète pas la tendance réelle.

c) Solutions

• Surapprentissage : régularisation, dropout, plus de données.

• Sous-apprentissage : modèle plus complexe, plus de caractéristiques.

Exercice pratique :

On dispose du dataset Iris (fleurs). L’objectif est de :

1. Entraîner un modèle de classification (SVM).

2. Évaluer avec validation croisée.
3. Optimiser les hyperparamètres avec Grid Search.
4. Comparer les résultats.
5. Expliquer avec une analogie.

Solution :

# Importer les bibliothèques nécessaires

from [Link] import load_iris
from [Link] import SVC
from sklearn.model_selection import cross_val_score, GridSearchCV

# Charger le dataset Iris

X, y = load_iris(return_X_y=True)

54
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

# 1. Entraîner un modèle SVM

model = SVC()

# 2. Validation croisée à 5 folds

scores = cross_val_score(model, X, y, cv=5)
print("Scores de validation croisée :", scores)
print("Score moyen :", [Link]())

# 3. Optimisation des hyperparamètres avec Grid Search

param_grid = {'C':[0.1,1,10], 'kernel':['linear','rbf']}
grid = GridSearchCV(SVC(), param_grid, cv=3)
[Link](X,y)

print("Meilleurs paramètres :", grid.best_params_)

print("Meilleur score :", grid.best_score_)

Commentaires :

• On commence par un modèle simple (SVM).

• On évalue avec validation croisée pour éviter le surapprentissage.
• On optimise les hyperparamètres avec Grid Search.
• On compare les résultats pour choisir la meilleure configuration.

Résultats attendus :

• Score moyen de validation croisée autour de 95 %.

• Meilleurs paramètres trouvés par Grid Search (par ex. C=1, kernel=rbf).

Analogie : C’est comme un élève qui révise avec plusieurs méthodes (validation croisée),
ajuste sa stratégie (hyperparamètres), et choisit la meilleure technique pour réussir son examen
(sélection du modèle).

55
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Chapitre 7 : Sujets Avancés en Apprentissage Automatique

Ce chapitre est consacré aux techniques avancées qui permettent de dépasser les limites des
modèles classiques. On y découvre des méthodes puissantes comme les méthodes d’ensemble,
l’apprentissage par renforcement, l’apprentissage par transfert, et enfin les
considérations éthiques.

Analogie : C’est comme passer du vélo à la voiture : les bases du déplacement sont les mêmes,
mais les outils sont plus sophistiqués et permettent d’aller plus loin, plus vite et avec plus de
confort.

Illustration réelle : Un schéma montrant un étudiant qui passe des bases (livres scolaires) aux
outils avancés (laboratoire, logiciels, projets réels).

Section 1 : Méthodes d’ensemble (Ensemble Methods)

Les méthodes d’ensemble combinent plusieurs modèles pour obtenir de meilleures

performances qu’un seul modèle.

a) Bagging (Bootstrap Aggregating)

On entraîne plusieurs modèles sur des sous-ensembles de données obtenus par tirage aléatoire
avec remise. Les prédictions sont ensuite combinées.

Formule :
𝑛
1
𝑃𝑟𝑒𝑑𝑖𝑐𝑡𝑖𝑜𝑛 = ∑ 𝑀𝑜𝑑𝑒 𝑙𝑖 (𝑥)
𝑛
𝑖=1

Exemple : Random Forest sur Iris

from [Link] import load_iris

from [Link] import RandomForestClassifier
from sklearn.model_selection import cross_val_score

56
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

# Charger le dataset Iris

X, y = load_iris(return_X_y=True)

# Créer un modèle Random Forest basé sur Bagging

rf = RandomForestClassifier(n_estimators=100, random_state=42)

# Évaluer avec validation croisée

scores = cross_val_score(rf, X, y, cv=5)
print("Scores de validation croisée :", scores)
print("Score moyen :", [Link]())

Commentaires :

• Chaque arbre voit un sous-ensemble différent des données.

• Le vote majoritaire donne une prédiction robuste.

Analogie : C’est comme demander l’avis de 100 médecins et prendre la majorité de leurs
recommandations.

Illustration réelle : Un diagramme montrant plusieurs arbres de décision votant ensemble pour
une prédiction finale.

b) Boosting

On entraîne des modèles successifs. Chaque nouveau modèle se concentre sur les erreurs du
précédent.

Formule (AdaBoost pondération) :

𝑤𝑡+1 (𝑖) = 𝑤𝑡 (𝑖) ⋅ 𝑒 𝛼𝑡 ⋅𝐼(𝑦𝑖 ≠ℎ𝑡(𝑥𝑖 ))

Exemple : AdaBoost sur Iris

from [Link] import AdaBoostClassifier

from [Link] import DecisionTreeClassifier

57
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

from sklearn.model_selection import cross_val_score

# Créer un modèle AdaBoost avec des arbres faibles

ada = AdaBoostClassifier(
base_estimator=DecisionTreeClassifier(max_depth=1),
n_estimators=50,
random_state=42
)

# Évaluer avec validation croisée

scores = cross_val_score(ada, X, y, cv=5)
print("Scores AdaBoost :", scores)
print("Score moyen AdaBoost :", [Link]())

Commentaires :

• Les exemples difficiles reçoivent plus de poids.

• AdaBoost est efficace sur des données simples.

Analogie : C’est comme un élève qui corrige ses erreurs à chaque révision, en mettant plus
d’attention sur les questions qu’il a ratées.

Illustration réelle : Un schéma montrant une série d’arbres corrigeant progressivement les
erreurs des précédents.

c) Stacking

On combine plusieurs modèles différents et un méta-modèle apprend à utiliser leurs

prédictions.

Exemple : Stacking sur Iris

from [Link] import StackingClassifier

from sklearn.linear_model import LogisticRegression
from [Link] import SVC
from sklearn.model_selection import cross_val_score

58
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

# Définir les modèles de base

base_estimators = [
('lr', LogisticRegression(max_iter=200)),
('svc', SVC(probability=True))
]

# Définir le méta-modèle
stack = StackingClassifier(
estimators=base_estimators,
final_estimator=RandomForestClassifier(n_estimators=50),
cv=5
)

# Évaluer avec validation croisée

scores = cross_val_score(stack, X, y, cv=5)
print("Scores Stacking :", scores)
print("Score moyen Stacking :", [Link]())

Commentaires :

• Les modèles de base donnent des prédictions.

• Le méta-modèle combine ces prédictions.

Analogie : C’est comme une équipe composée de spécialistes différents (médecin, ingénieur,
avocat) qui donnent chacun leur avis, puis un chef d’équipe prend la décision finale.

Illustration réelle : Un schéma montrant plusieurs modèles de base envoyant leurs résultats à
un modèle final qui prend la décision.

Section 2 : Notions de base de l’apprentissage par renforcement

a) Concepts clés

• Agent : prend des décisions.

• Environnement : le monde dans lequel l’agent agit.

59
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

• État : la situation actuelle.

• Action : ce que l’agent peut faire.
• Récompense : feedback positif ou négatif.

b) Formule (Q-Learning)

𝑄(𝑠, 𝑎) = 𝑄(𝑠, 𝑎) + 𝛼 ⋅ [𝑟 + 𝛾 ⋅ max

′
𝑄(𝑠 ′ , 𝑎′ ) − 𝑄(𝑠, 𝑎)]
𝑎

Exemple : Labyrinthe simple

import numpy as np

# Définir les états et actions

states = [0,1,2,3] # 4 cases
actions = [0,1] # gauche ou droite

# Initialiser la table Q
Q = [Link]((len(states), len(actions)))

# Paramètres
alpha = 0.1 # taux d'apprentissage
gamma = 0.9 # facteur de discount
episodes = 100

# Simulation simple
for ep in range(episodes):
state = 0
while state < 3:
action = [Link](actions)
if action == 1: # aller à droite
next_state = state + 1
reward = 1 if next_state == 3 else 0
else: # aller à gauche
next_state = max(0, state - 1)
reward = 0
# Mise à jour Q
Q[state, action] = Q[state, action] + alpha * (
reward + gamma * [Link](Q[next_state]) - Q[state, action]
)
state = next_state

print("Table Q après apprentissage :\n", Q)

Commentaires :

• L’agent apprend à atteindre l’état final (3).

• La table Q contient les valeurs des actions.

60
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme un enfant qui apprend à traverser un labyrinthe en essayant différentes
directions et en recevant des points quand il trouve la sortie.

Illustration réelle : Un schéma montrant un agent dans un labyrinthe recevant des

récompenses en atteignant la sortie.

Section 3 : Apprentissage par transfert (Transfer Learning)

L’apprentissage par transfert consiste à réutiliser un modèle pré-entraîné sur un grand

dataset pour l’adapter à une nouvelle tâche. Cela permet de gagner du temps et d’améliorer les
performances, surtout quand on dispose de peu de données.

Analogie : C’est comme un étudiant qui a appris le français et qui utilise ses connaissances
pour apprendre l’espagnol plus rapidement. Les bases (grammaire, vocabulaire) sont
transférées, et il ne reste qu’à adapter les détails.

Illustration réelle : Imagine un chirurgien qui a appris à opérer le cœur. Lorsqu’il doit opérer
les poumons, il ne repart pas de zéro : il transfère ses connaissances médicales générales et
adapte ses gestes.

Exemple : Utiliser VGG16 pour CIFAR-10

61
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

from [Link] import VGG16

from [Link] import Sequential
from [Link] import Dense, Flatten
from [Link] import cifar10

# Charger le dataset CIFAR-10 (images de 32x32 pixels)

(X_train, y_train), (X_test, y_test) = cifar10.load_data()

# Normaliser les données

X_train = X_train.astype('float32') / 255
X_test = X_test.astype('float32') / 255

# Charger VGG16 pré-entraîné sur ImageNet

base_model = VGG16(weights='imagenet', include_top=False, input_shape=(32,32,3))

# Construire un modèle avec VGG16 comme base

model = Sequential([
base_model,
Flatten(),
Dense(64, activation='relu'),
Dense(10, activation='softmax') # 10 classes de CIFAR-10
])

# Compiler le modèle
[Link](optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy']
)

# Entraîner le modèle
history = [Link](X_train, y_train, epochs=3, batch_size=64, validation_split=0.1)

Commentaires :

• VGG16 est pré-entraîné sur ImageNet (millions d’images).

• On ajoute des couches pour adapter à CIFAR-10.
• Le modèle bénéficie des connaissances acquises sur ImageNet.

62
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Illustration réelle : Un schéma montrant un réseau pré-entraîné (VGG16) utilisé comme

“fondation”, sur lequel on ajoute des couches spécifiques pour une nouvelle tâche.

Section 4 : Considérations éthiques et équité

a) Biais des données

Un modèle peut reproduire des discriminations si les données d’entraînement sont biaisées.

Exemple : Un algorithme de recrutement qui favorise les hommes parce que les données
historiques contiennent plus de CV masculins.

Analogie : C’est comme un professeur qui corrige les copies en fonction de ses préjugés : le
résultat est injuste.

Illustration réelle : Un graphique montrant deux groupes (hommes/femmes) avec des scores
différents à cause d’un biais dans les données.

b) Transparence

Il est important d’expliquer les décisions des modèles (Explainable AI).

Exemple : Dans la santé, un médecin doit comprendre pourquoi un modèle prédit une maladie.

63
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme un juge qui doit justifier son verdict.

Illustration réelle : Un schéma montrant un modèle complexe avec une “boîte noire” et des
outils d’explication qui éclairent ses décisions.

c) Équité

Les modèles doivent éviter de défavoriser certains groupes.

Exemple : Un modèle de crédit qui refuse systématiquement les demandes d’un quartier
défavorisé.

Analogie : C’est comme une banque qui juge les clients uniquement sur leur adresse, sans
regarder leur situation réelle.

Illustration réelle : Un diagramme montrant une balance de justice, avec des données
équilibrées d’un côté et biaisées de l’autre.

Exercice pratique :

On dispose du dataset Iris. L’objectif est de :

64
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

1. Comparer un modèle simple (régression logistique) avec une méthode d’ensemble

(Random Forest).
2. Évaluer les performances avec validation croisée.
3. Optimiser les hyperparamètres de la Random Forest.
4. Interpréter les résultats avec une analogie et une illustration réelle.

Solution :

from [Link] import load_iris

from sklearn.model_selection import cross_val_score, GridSearchCV
from sklearn.linear_model import LogisticRegression
from [Link] import RandomForestClassifier

# Charger le dataset Iris

X, y = load_iris(return_X_y=True)

# 1. Modèle simple : Régression logistique

log_model = LogisticRegression(max_iter=200)
log_scores = cross_val_score(log_model, X, y, cv=5)
print("Score moyen Régression Logistique :", log_scores.mean())

# 2. Méthode d'ensemble : Random Forest

rf_model = RandomForestClassifier()
rf_scores = cross_val_score(rf_model, X, y, cv=5)
print("Score moyen Random Forest :", rf_scores.mean())

# 3. Optimisation des hyperparamètres de la Random Forest

param_grid = {'n_estimators':[10,50,100], 'max_depth':[None,5,10]}
grid = GridSearchCV(RandomForestClassifier(), param_grid, cv=3)
[Link](X,y)

print("Meilleurs paramètres Random Forest :", grid.best_params_)

print("Meilleur score Random Forest :", grid.best_score_)

Commentaires :

• La régression logistique est un modèle simple et interprétable.

• La Random Forest combine plusieurs arbres pour plus de robustesse.
• Le Grid Search optimise le nombre d’arbres et la profondeur.

Résultats attendus :

• La Random Forest obtient un score légèrement supérieur à la régression logistique.

• Les meilleurs paramètres sont souvent n_estimators=100 et max_depth=None.

65
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie : C’est comme comparer un seul médecin (régression logistique) avec une équipe de
médecins (Random Forest). L’équipe donne généralement un meilleur diagnostic car elle
combine plusieurs avis.

Illustration réelle : Un schéma montrant un médecin seul face à un patient, puis une équipe
de médecins discutant ensemble pour donner un diagnostic plus fiable.

66
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Chapitre 8 : Applications Pratiques et Projets

Après avoir étudié les concepts théoriques et les algorithmes, il est essentiel de voir comment
l’apprentissage automatique s’applique dans le monde réel. Ce chapitre met l’accent sur les
projets pratiques, les applications industrielles et la mise en production des modèles.

Analogie : C’est comme apprendre à conduire : après avoir étudié le code de la route et la
mécanique, il faut monter dans la voiture et rouler sur de vraies routes.

Illustration réelle : Un schéma montrant le cycle complet : données → modèle → évaluation

→ déploiement → utilisation réelle.

Section 1 : Projets pratiques et études de cas

a) Projet de classification d’images

• Objectif : reconnaître des objets (ex. chats vs chiens).

• Étapes : collecte des données, prétraitement, entraînement d’un CNN, évaluation,
déploiement.

Exemple Python (CNN simple sur MNIST) :

from [Link] import mnist

from [Link] import Sequential
from [Link] import Conv2D, MaxPooling2D, Flatten, Dense
from [Link] import to_categorical

# Charger les données MNIST

(X_train, y_train), (X_test, y_test) = mnist.load_data()

# Reshape et normaliser
X_train = X_train.reshape(-1,28,28,1).astype('float32')/255
X_test = X_test.reshape(-1,28,28,1).astype('float32')/255

# Encoder les labels

67
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

y_train = to_categorical(y_train)
y_test = to_categorical(y_test)

# Construire un CNN simple

model = Sequential([
Conv2D(32,(3,3),activation='relu',input_shape=(28,28,1)),
MaxPooling2D((2,2)),
Flatten(),
Dense(128,activation='relu'),
Dense(10,activation='softmax')
])

[Link](optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])
[Link](X_train,y_train,epochs=3,batch_size=128,validation_split=0.1)

Commentaires :

• Le CNN apprend à reconnaître les chiffres manuscrits.

• On peut adapter ce projet pour des images de chats et chiens.

Illustration réelle : Un schéma montrant des images de chiffres manuscrits passant dans un
CNN et produisant une prédiction.

b) Projet de traitement du langage naturel (NLP)

• Objectif : analyser des textes (ex. sentiment d’un tweet).

• Étapes : nettoyage du texte, vectorisation, entraînement d’un modèle, évaluation.

Exemple Python (analyse de sentiment avec Naive Bayes) :

from sklearn.feature_extraction.text import CountVectorizer

from sklearn.naive_bayes import MultinomialNB
from [Link] import make_pipeline

# Exemple de dataset

68
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

texts = ["J'adore ce film", "Ce produit est horrible", "Très bon service", "Je déteste cette
expérience"]
labels = [1,0,1,0] # 1 = positif, 0 = négatif

# Construire un pipeline
model = make_pipeline(CountVectorizer(), MultinomialNB())

# Entraîner
[Link](texts, labels)

# Tester
print([Link](["Ce restaurant est excellent"]))
print([Link](["Je n'aime pas ce livre"]))

Commentaires :

• Le modèle apprend à distinguer les phrases positives et négatives.

• On peut l’appliquer à des milliers de tweets ou avis clients.

Illustration réelle : Un schéma montrant des phrases passant dans un modèle qui les classe en
“positif” ou “négatif”.

c) Projet d’analyse de séries temporelles

• Objectif : prédire des valeurs futures (ex. prix du pétrole, météo).

• Étapes : collecte des données, transformation en séquences, entraînement d’un RNN ou
LSTM.

Exemple Python (prévision simple avec LSTM) :

import numpy as np
from [Link] import Sequential
from [Link] import LSTM, Dense

# Exemple de données séquentielles

X = [Link]([[i,i+1,i+2] for i in range(100)])

69
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

y = [Link]([i+3 for i in range(100)])

# Reshape pour LSTM

X = [Link](([Link][0],[Link][1],1))

# Construire un LSTM
model = Sequential([
LSTM(50, activation='relu', input_shape=(3,1)),
Dense(1)
])

[Link](optimizer='adam', loss='mse')
[Link](X,y,epochs=200,verbose=0)

# Prédire
print("Prédiction pour [97,98,99] :", [Link]([Link]([[[97],[98],[99]]])))

Commentaires :

• Le LSTM apprend à prédire la valeur suivante d’une séquence.

• On peut l’appliquer à des données financières ou météorologiques.

Illustration réelle : Un graphique montrant une série temporelle avec une courbe prédite par
le modèle.

Section 2 : Applications réelles

a) Traitement du langage naturel

• Chatbots, traduction automatique, analyse de sentiment.

• Exemple réel : assistants virtuels comme Copilot ou Siri.

70
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Illustration réelle : Un schéma montrant un utilisateur posant une question et un chatbot

répondant automatiquement.

b) Vision par ordinateur

• Reconnaissance faciale, détection d’objets, voitures autonomes.

• Exemple réel : systèmes de sécurité qui reconnaissent les visages.

Illustration réelle : Un schéma montrant une caméra détectant des visages et les identifiant.

c) Analyse de séries temporelles

• Prévision économique, météo, santé.

• Exemple réel : prédiction de la demande énergétique.

71
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Illustration réelle : Un graphique montrant la consommation d’énergie prédite par un modèle.

Section 3 : Implémentation et déploiement des modèles

a) Étapes

1. Prétraitement des données.

2. Entraînement du modèle.
3. Évaluation.
4. Déploiement (API, application web).

b) Exemple : Déploiement avec Flask

from flask import Flask, request, jsonify

import joblib

# Charger un modèle entraîné

model = [Link]("iris_model.pkl")

app = Flask(__name__)

@[Link]('/predict', methods=['POST'])
def predict():
data = [Link]['features']
prediction = [Link]([data])
return jsonify({'prediction': int(prediction[0])})

if __name__ == '__main__':
[Link](debug=True)

Commentaires :

• Le modèle est exposé via une API.

• On peut l’utiliser dans une application web ou mobile.

72
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Illustration réelle : Un schéma montrant un utilisateur envoyant des données à une API et
recevant une prédiction.

Exercice pratique :

Construisez un projet complet de classification d’images (MNIST) :

1. Charger les données.

2. Construire un CNN.
3. Évaluer le modèle.
4. Déployer le modèle avec Flask.

(Nous avons déjà vu les étapes 1–3 plus haut. L’étape 4 montre le déploiement.)

Dans ce chapitre, nous avons vu :

• Comment réaliser des projets pratiques (images, texte, séries temporelles).

• Les applications réelles de l’IA (NLP, vision, prévisions).
• Comment déployer un modèle pour qu’il soit utilisé dans le monde réel.

73
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Analogie finale : C’est comme construire une maison : on ne se contente pas des plans
(théorie), on assemble les briques (projets pratiques), on installe l’électricité et l’eau
(applications réelles), puis on ouvre la porte pour y vivre (déploiement).

Illustration finale : Un schéma montrant le cycle complet de l’IA : données → modèle →

évaluation → déploiement → utilisation réelle.

74
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Conclusion
Ce parcours à travers l’apprentissage automatique a permis de construire une compréhension
progressive, allant des fondements théoriques aux applications pratiques et aux enjeux
éthiques. Les étudiants ont découvert non seulement les algorithmes et les techniques, mais
aussi la manière dont ces outils transforment la recherche, l’industrie et la société.

L’apprentissage automatique n’est pas une discipline figée : c’est un domaine en constante
évolution, où chaque avancée ouvre de nouvelles perspectives. En maîtrisant les concepts vus
dans ce cours, les étudiants disposent désormais d’une base solide pour explorer des projets
plus complexes, contribuer à des innovations et réfléchir aux implications de leurs choix
technologiques.

Au-delà des formules et des modèles, ce cours a insisté sur l’importance de l’esprit critique, de
l’expérimentation et de la responsabilité. L’IA n’est pas seulement une question de
performance technique : elle doit être conçue et utilisée avec équité, transparence et sens
éthique.

Points clés à retenir

• Fondements solides : compréhension des types d’apprentissage (supervisé, non

supervisé, par renforcement) et des algorithmes essentiels.
• Pratique appliquée : mise en œuvre de projets concrets en vision par ordinateur,
traitement du langage naturel et analyse de séries temporelles.
• Optimisation et rigueur : maîtrise des techniques d’évaluation, de validation croisée
et d’ajustement des hyperparamètres.
• Ouverture avancée : exploration des méthodes d’ensemble, du transfert de
connaissances et des réseaux profonds.
• Responsabilité sociale : prise en compte des biais, de l’équité et de la transparence
dans la conception des modèles.
• Perspective future : l’apprentissage automatique est un champ dynamique, offrant des
opportunités de recherche et d’innovation dans presque tous les secteurs.

En conclusion, ce cours a été conçu comme un voyage progressif : partir des bases, construire
des compétences pratiques, explorer des techniques avancées et réfléchir aux enjeux éthiques.
Les étudiants sont désormais mieux préparés à appliquer l’IA dans des contextes réels, à
poursuivre leurs apprentissages et à contribuer de manière responsable au développement
de cette discipline en pleine expansion.

75
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Bibliographie
Ouvrages fondamentaux

• Bishop, C. M. (2006). Pattern Recognition and Machine Learning. Springer. Référence

incontournable pour les bases mathématiques et statistiques de l’apprentissage
automatique.
• Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep Learning. MIT Press Ouvrage
fondateur sur les réseaux de neurones et l’apprentissage profond.

Manuels pratiques

• Géron, A. (2019). Hands-On Machine Learning with Scikit-Learn, Keras, and

TensorFlow. O’Reilly Media. Guide pratique pour implémenter des modèles avec
Python et les principaux frameworks.
• Raschka, S., & Mirjalili, V. (2020). Python Machine Learning. Packt Publishing.
Manuel orienté vers la programmation et l’expérimentation avec des exemples
concrets.

Lectures complémentaires

• Hastie, T., Tibshirani, R., & Friedman, J. (2009). The Elements of Statistical Learning.
Springer. Approche statistique avancée des modèles d’apprentissage.
• Sutton, R. S., & Barto, A. G. (2018). Reinforcement Learning: An Introduction. MIT
Press. Référence pour comprendre les bases et applications de l’apprentissage par
renforcement.
• Mitchell, T. M. (1997). Machine Learning. McGraw-Hill. Texte classique qui introduit
les concepts fondamentaux de manière accessible.
• Russell, S., & Norvig, P. (2021). Artificial Intelligence: A Modern Approach. Pearson.
Ouvrage généraliste sur l’IA, incluant l’apprentissage automatique dans un cadre plus
large.

Points clés de la bibliographie

• Équilibre entre théorie et pratique : des ouvrages mathématiques et des manuels

orientés programmation.
• Couverture complète : apprentissage supervisé, non supervisé, profond et par
renforcement.
• Dimension critique : ressources sur les biais, l’équité et la responsabilité en IA.
• Ouverture internationale : références utilisées dans les meilleures universités (MIT,
Stanford, etc.).

a
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Table des matières

Sommaire .................................................................................................................................... i
Introduction .............................................................................................................................. iii
Chapitre 1 : Introduction à l’Apprentissage Automatique ......................................................... 1
Section 1 : Définition et principes fondamentaux.................................................................. 1
Section 2 : Histoire et évolution du Machine Learning ......................................................... 1
Section 3 : Les trois grands types d’apprentissage ................................................................ 2
3.1 Apprentissage supervisé ............................................................................................... 2
3.2 Apprentissage non supervisé ........................................................................................ 3
3.3 Apprentissage par renforcement .................................................................................. 4
Section 4 : Applications du Machine Learning ...................................................................... 5
Exercice pratique : ............................................................................................................. 5
Solution pas à pas : ............................................................................................................ 6
Chapitre 2 : Prétraitement des Données ................................................................................... 10
Section 1 : Comprendre les ensembles de données ............................................................. 10
Section 2 : Nettoyage des données et gestion des valeurs manquantes ............................... 11
Techniques de nettoyage : ................................................................................................ 11
Section 3 : Normalisation et standardisation des données ................................................... 11
3.1 Problème .................................................................................................................... 11
3.2 Normalisation ............................................................................................................. 12
3.3 Standardisation ........................................................................................................... 12
3.4 L’écart-type : définition et rôle .................................................................................. 13
3.4.1. Qu’est-ce que l’écart-type ? ................................................................................... 13
3.4.2. La formule de l’écart-type ..................................................................................... 13
Section 4 : Sélection et extraction des caractéristiques ....................................................... 15
Exercice pratique : ........................................................................................................... 16
Solution : .......................................................................................................................... 16
Chapitre 3 : Apprentissage Supervisé ...................................................................................... 21
Section 2 : Les algorithmes de régression............................................................................ 21
a) Régression linéaire ....................................................................................................... 21
b) Régression polynomiale .............................................................................................. 22
Section 3 : Les algorithmes de classification ....................................................................... 24
a) k-Nearest Neighbors (k-NN) ....................................................................................... 24

b
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

b) Arbres de décision ....................................................................................................... 25

c) Random Forest ............................................................................................................. 26
d) Support Vector Machines (SVM) ................................................................................ 27
e) Réseaux de neurones supervisés .................................................................................. 28
Exercice pratique : ........................................................................................................... 30
Solution avec Python : ..................................................................................................... 31
Chapitre 4 : Apprentissage Non Supervisé .............................................................................. 33
Section 1 : Les algorithmes de regroupement (Clustering) ................................................. 33
a) k-Means Clustering ...................................................................................................... 33
b) Clustering hiérarchique................................................................................................ 35
c) DBSCAN (Density-Based Spatial Clustering of Applications with Noise) ................ 36
Section 2 : Les algorithmes de réduction de dimension ...................................................... 37
a) Analyse en composantes principales (ACP / PCA) ..................................................... 37
b) t-SNE (t-Distributed Stochastic Neighbor Embedding) .............................................. 38
Section 3 : Évaluation des modèles non supervisés ............................................................. 39
a) Indice de silhouette ...................................................................................................... 39
b) Inertie (k-Means) ......................................................................................................... 39
Section 4 : Détection d’anomalies ....................................................................................... 40
a) Algorithmes utilisés ..................................................................................................... 40
b) Formule (Isolation Forest) ........................................................................................... 40
Exercice pratique : ........................................................................................................... 41
Solution avec Python : ..................................................................................................... 42
Chapitre 5 : Réseaux de Neurones et Apprentissage Profond.................................................. 44
Section 1 : Introduction aux réseaux de neurones ............................................................... 44
Section 2 : Bases de l’apprentissage profond ...................................................................... 44
a) Propagation avant (Forward Propagation) ................................................................... 45
b) Rétropropagation (Backpropagation) .......................................................................... 45
Section 3 : Réseaux de neurones convolutionnels (CNN) ................................................... 45
Section 4 : Réseaux de neurones récurrents (RNN)............................................................. 46
Section 5 : Introduction aux frameworks ............................................................................. 47
Exercice pratique : ........................................................................................................... 48
Chapitre 6 : Évaluation et Optimisation des Modèles ............................................................. 50
Section 1 : Techniques de validation croisée ....................................................................... 50

c
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

Section 2 : Ajustement des hyperparamètres ....................................................................... 51

Section 3 : Sélection et comparaison des modèles............................................................... 53
Critères de comparaison :................................................................................................. 53
Section 4 : Surapprentissage et sous-apprentissage ............................................................. 53
a) Surapprentissage (Overfitting) ..................................................................................... 53
b) Sous-apprentissage (Underfitting) ............................................................................... 54
c) Solutions ...................................................................................................................... 54
Solution : .......................................................................................................................... 54
Chapitre 7 : Sujets Avancés en Apprentissage Automatique ................................................... 56
Section 1 : Méthodes d’ensemble (Ensemble Methods) ...................................................... 56
a) Bagging (Bootstrap Aggregating) ................................................................................ 56
b) Boosting ....................................................................................................................... 57
c) Stacking ....................................................................................................................... 58
Section 2 : Notions de base de l’apprentissage par renforcement ....................................... 59
a) Concepts clés ............................................................................................................... 59
b) Formule (Q-Learning) ................................................................................................. 60
Section 3 : Apprentissage par transfert (Transfer Learning) ................................................ 61
Section 4 : Considérations éthiques et équité ...................................................................... 63
a) Biais des données ......................................................................................................... 63
b) Transparence ................................................................................................................ 63
c) Équité ........................................................................................................................... 64
Exercice pratique : ........................................................................................................... 64
Solution : .......................................................................................................................... 65
Chapitre 8 : Applications Pratiques et Projets.......................................................................... 67
Section 1 : Projets pratiques et études de cas ....................................................................... 67
a) Projet de classification d’images ................................................................................. 67
b) Projet de traitement du langage naturel (NLP) ............................................................ 68
c) Projet d’analyse de séries temporelles ......................................................................... 69
Section 2 : Applications réelles ............................................................................................ 70
a) Traitement du langage naturel...................................................................................... 70
c) Analyse de séries temporelles ...................................................................................... 71
Section 3 : Implémentation et déploiement des modèles ..................................................... 72
a) Étapes ........................................................................................................................... 72

d
E.S.G.A.E la Grande Ecole Administration Base de Données (ABD)

b) Exemple : Déploiement avec Flask ............................................................................. 72

Exercice pratique : ........................................................................................................... 73
Conclusion ............................................................................................................................... 75
Bibliographie.............................................................................................................................. a