Cahier d'Exercices : Fouille de Données

(Data Mining)
Ce cahier d'exercices est conçu pour vous aider à consolider vos connaissances en Fouille
de Données. Il propose des questions de théorie, des exercices de calcul et des défis de
code, classés par niveau de difficulté (Facile, Moyen, Difficile). Chaque exercice est
accompagné d'une correction détaillée et d'explications pédagogiques pour faciliter votre
apprentissage.

Chapitre 0 : Introduction à la Fouille de Données

Exercices Faciles
Question 0.1 (Théorie) :
Définissez en une phrase ce qu'est la Fouille de Données (Data Mining).
Correction 0.1 :
La Fouille de Données est le processus de découverte de modèles intéressants, de
structures cachées et de connaissances exploitables à partir de vastes ensembles de
données.
Question 0.2 (Théorie) :
Citez les quatre étapes principales du Processus Global de Découverte de Connaissances
(KDD) dans l'ordre.
Correction 0.2 :
Les quatre étapes principales du processus KDD sont :
1. Préparation des données
2. Fouille de données
3. Évaluation
4. Présentation
Exercices Moyens
Question 0.3 (Théorie) :
Expliquez la différence fondamentale entre la Fouille de Données et les Algorithmes
d'Intelligence Artificielle en termes d'objectif principal.
Correction 0.3 :
La différence fondamentale réside dans leur objectif :
• La Fouille de Données cherche à comprendre ce qui s'est passé ou ce qui se passe dans
les données (approche descriptive et explicative, comme un
microscope). Les Algorithmes d'Intelligence Artificielle (en particulier le Machine
Learning) visent la prédiction et l'automatisation de tâches (approche prédictive et
prescriptive, comme un pilote automatique).
Question 0.4 (Théorie) :
Décrivez brièvement les quatre types de données (structurées, semi-structurées, non-
structurées, flux de données) et donnez un exemple concret pour chacun.
Correction 0.4 :
• Structurées : Données organisées en format tabulaire avec des schémas prédéfinis. Ex:
Une base de données SQL de clients avec des colonnes comme Nom , Prénom , Âge .
• Semi-structurées : Données qui ont une structure mais ne suivent pas un schéma
rigide. Ex: Un fichier XML ou JSON décrivant un produit, ou des données de graphes.
• Non-structurées : Données sans format prédéfini, difficiles à organiser en bases de
données relationnelles. Ex: Le texte d'un email, une image, un fichier audio ou vidéo.
• Flux de données : Données générées en continu et en temps réel, nécessitant un
traitement immédiat. Ex: Les données de capteurs IoT, les flux de vidéosurveillance, les
données de transactions boursières en direct.
Exercices Difficiles
Question 0.5 (Théorie) :
Le processus KDD est itératif. Expliquez pourquoi l'itération est cruciale et donnez un
exemple où l'on pourrait revenir à une étape précédente après l'évaluation.
Correction 0.5 :
L'itération est cruciale dans le processus KDD car la découverte de connaissances n'est pas
linéaire. Les résultats obtenus à une étape peuvent révéler des problèmes ou des
opportunités qui nécessitent de revoir les étapes précédentes. Par exemple, après l'étape
d'Évaluation, si les motifs découverts ne sont pas "intéressants" (parce qu'ils sont triviaux,
non exploitables, ou ne répondent pas à l'objectif initial), on pourrait être amené à revenir à
l'étape de Préparation des données pour :
• Sélectionner de nouvelles caractéristiques : Les caractéristiques initialement choisies
n'étaient peut-être pas suffisamment informatives.
• Appliquer de nouvelles transformations : Les données n'étaient peut-être pas sous
une forme optimale pour l'algorithme de fouille utilisé.
 • Gérer différemment les valeurs manquantes ou le bruit : Les méthodes initiales ont
pu introduire des biais ou masquer des motifs importants.
Ou même revenir à l'étape de Fouille de données pour essayer un algorithme différent ou
ajuster ses paramètres.
Question 0.6 (Théorie) :
Parmi les types de connaissances extraites, lequel serait le plus approprié pour détecter des
transactions bancaires frauduleuses et pourquoi ?
Correction 0.6 :
L'Analyse des valeurs aberrantes (Outliers) serait la plus appropriée pour détecter des
transactions bancaires frauduleuses.
Explication : La fraude bancaire se manifeste souvent par des comportements qui
s'écartent significativement de la norme (transactions inhabituelles en montant, lieu,
fréquence, etc.). Ces transactions sont par définition des "valeurs aberrantes" ou des
"anomalies" par rapport au comportement habituel d'un client. Les techniques d'analyse
des valeurs aberrantes sont spécifiquement conçues pour identifier ces points de données
rares et suspects, ce qui en fait l'approche la plus directe et efficace pour ce type de
problème.

Chapitre 1 : Fouille de Motifs Fréquents - Algorithme

Apriori
Exercices Faciles
Question 1.1 (Théorie) :
Définissez les termes "Itemset", "Itemset fréquent", "Support" et "Confiance" dans le
contexte des règles d'association.
Correction 1.1 :
• Itemset : Un ensemble d'un ou plusieurs articles (produits, services) qui peuvent
apparaître ensemble dans une transaction.
• Itemset fréquent : Un itemset dont la fréquence d'apparition dans l'ensemble des
transactions est supérieure ou égale à un seuil minimum prédéfini (le minsup ).
• Support (d'une règle A ⇒ B) : La proportion de transactions qui contiennent à la fois
l'itemset A et l'itemset B. Il mesure la popularité de l'ensemble {A, B}.
• Confiance (d'une règle A ⇒ B) : La probabilité que l'itemset B soit présent dans une
transaction, sachant que l'itemset A est déjà présent. Il mesure la fiabilité de la règle.
Question 1.2 (Théorie) :
Quel est le principe fondamental sur lequel repose l'algorithme Apriori ?
Correction 1.2 :
L'algorithme Apriori repose sur la propriété anti-monotone (ou "Apriori property") : Si un
itemset est fréquent, alors tous ses sous-ensembles sont également fréquents.
Inversement, si un itemset n'est pas fréquent, aucun de ses sur-ensembles ne peut l'être. Ce
principe permet de réduire considérablement l'espace de recherche des itemsets fréquents.
Exercices Moyens
Question 1.3 (Calcul) :
Considérez la base de transactions suivante et un minsup = 0.5 :
Transaction ID Articles
T1 {A, B, C}
T2 {A, C}
T3 {A, D}
T4 {B, E, F}
T5 {B, C, F}

Calculez le support des itemsets suivants :

1. {A}
2. {B}
3. {C}
4. {A, C}
5. {B, C}
Correction 1.3 :
Nombre total de transactions N = 5 .
1. Support({A}) : A apparaît dans T1, T2, T3 (3 transactions). Support({A}) = 3/5 = 0.6
2. Support({B}) : B apparaît dans T1, T4, T5 (3 transactions). Support({B}) = 3/5 = 0.6
3. Support({C}) : C apparaît dans T1, T2, T5 (3 transactions). Support({C}) = 3/5 = 0.6
4. Support({A, C}) : {A, C} apparaît dans T1, T2 (2 transactions). Support({A, C}) = 2/5 = 0.4
 5. Support({B, C}) : {B, C} apparaît dans T1, T5 (2 transactions). Support({B, C}) = 2/5 = 0.4
Question 1.4 (Calcul) :
En utilisant les supports calculés précédemment et un minconf = 0.7 , évaluez la confiance
des règles d'association suivantes :
1. {A} ⇒ {C}
2. {C} ⇒ {A}
3. {B} ⇒ {C}
Indiquez si ces règles sont considérées comme "intéressantes" selon le minconf .
Correction 1.4 :
1. {A} ⇒ {C} :
Confiance({A} ⇒ {C}) = Support({A, C}) / Support({A}) = 0.4 / 0.6 = 2/3 ≈ 0.667
0.667 < 0.7 , donc la règle n'est pas intéressante.
2. {C} ⇒ {A} :
Confiance({C} ⇒ {A}) = Support({A, C}) / Support({C}) = 0.4 / 0.6 = 2/3 ≈ 0.667
0.667 < 0.7 , donc la règle n'est pas intéressante.
3. {B} ⇒ {C} :
Confiance({B} ⇒ {C}) = Support({B, C}) / Support({B}) = 0.4 / 0.6 = 2/3 ≈ 0.667
0.667 < 0.7 , donc la règle n'est pas intéressante.
Exercices Difficiles
Question 1.5 (Algorithme & Code) :
Étant donné la base de transactions suivante et un minsup = 0.6 :
Transaction ID Articles
T1 {Lait, Pain, Bière}
T2 {Lait, Pain, Couches}
T3 {Lait, Bière, Couches}
T4 {Pain, Bière, Couches}
T5 {Lait, Pain, Bière, Couches}

1. Appliquez manuellement l'algorithme Apriori pour trouver tous les itemsets fréquents.
 2. Ensuite, générez toutes les règles d'association "intéressantes" avec un minconf = 0.7 .
3. Implémentez une fonction Python qui prend une liste de transactions et min_support et
retourne les itemsets fréquents. Testez-la avec l'exemple ci-dessus.
Correction 1.5 :
Partie 1 : Application manuelle de l'algorithme Apriori
Nombre total de transactions N = 5 . minsup = 0.6 (donc un itemset est fréquent s'il apparaît
au moins 0.6 * 5 = 3 fois).
Étape 1 : Génération des 1-itemsets fréquents (L1)
Itemset Count Support Fréquent (Support ≥
0.6)
{Lait} 4 0.8 Oui
{Pain} 4 0.8 Oui
{Bière} 4 0.8 Oui
{Couches} 4 0.8 Oui

L1 = {{Lait}, {Pain}, {Bière}, {Couches}}

Étape 2 : Génération des 2-itemsets candidats (C2) à partir de L1
Combinaisons de 2 éléments de L1 : {Lait, Pain}, {Lait, Bière}, {Lait, Couches}, {Pain, Bière},
{Pain, Couches}, {Bière, Couches}.
Comptage et filtrage des 2-itemsets fréquents (L2)
Itemset Count Support Fréquent (Support ≥
0.6)
{Lait, Pain} 3 0.6 Oui
{Lait, Bière} 3 0.6 Oui
{Lait, Couches} 3 0.6 Oui
{Pain, Bière} 3 0.6 Oui
{Pain, Couches} 3 0.6 Oui
{Bière, Couches} 3 0.6 Oui
L2 = {{Lait, Pain}, {Lait, Bière}, {Lait, Couches}, {Pain, Bière}, {Pain, Couches}, {Bière, Couches}}
Étape 3 : Génération des 3-itemsets candidats (C3) à partir de L2
Les itemsets de L2 sont combinés pour former des candidats de taille 3. Seuls les itemsets
dont tous les sous-ensembles de taille 2 sont dans L2 sont considérés.
• {Lait, Pain, Bière} (sous-ensembles {Lait, Pain}, {Lait, Bière}, {Pain, Bière} sont tous dans
L2) → Candidat
• {Lait, Pain, Couches} (sous-ensembles {Lait, Pain}, {Lait, Couches}, {Pain, Couches} sont
tous dans L2) → Candidat
• {Lait, Bière, Couches} (sous-ensembles {Lait, Bière}, {Lait, Couches}, {Bière, Couches}
sont tous dans L2) → Candidat
• {Pain, Bière, Couches} (sous-ensembles {Pain, Bière}, {Pain, Couches}, {Bière, Couches}
sont tous dans L2) → Candidat
Comptage et filtrage des 3-itemsets fréquents (L3)
Itemset Count Support Fréquent (Support ≥
0.6)
{Lait, Pain, Bière} 2 0.4 Non
{Lait, Pain, Couches} 2 0.4 Non
{Lait, Bière, Couches} 2 0.4 Non
{Pain, Bière, Couches} 2 0.4 Non

L3 = {} (aucun 3-itemset n'est fréquent)

L'algorithme s'arrête car L3 est vide.
Itemsets fréquents finaux :
L1 = {{Lait}, {Pain}, {Bière}, {Couches}}
L2 = {{Lait, Pain}, {Lait, Bière}, {Lait, Couches}, {Pain, Bière}, {Pain, Couches}, {Bière, Couches}}
Partie 2 : Génération des règles d'association intéressantes ( minconf = 0.7 )
Nous allons générer des règles à partir des itemsets fréquents de L2. Pour chaque itemset
fréquent {X, Y}, nous testons X ⇒ Y et Y ⇒ X.
• Itemset {Lait, Pain} (Support = 0.6)
• {Lait} ⇒ {Pain} : Confiance = Support({Lait, Pain}) / Support({Lait}) = 0.6 / 0.8 = 0.75 .
Intéressante (0.75 ≥ 0.7)
 • {Pain} ⇒ {Lait} : Confiance = Support({Lait, Pain}) / Support({Pain}) = 0.6 / 0.8 = 0.75 .
Intéressante (0.75 ≥ 0.7)
• Itemset {Lait, Bière} (Support = 0.6)
• {Lait} ⇒ {Bière} : Confiance = Support({Lait, Bière}) / Support({Lait}) = 0.6 / 0.8 = 0.75 .
Intéressante (0.75 ≥ 0.7)
• {Bière} ⇒ {Lait} : Confiance = Support({Lait, Bière}) / Support({Bière}) = 0.6 / 0.8 = 0.75 .
Intéressante (0.75 ≥ 0.7)
• Itemset {Lait, Couches} (Support = 0.6)
• {Lait} ⇒ {Couches} : Confiance = Support({Lait, Couches}) / Support({Lait}) = 0.6 / 0.8 = 0.75 .
Intéressante (0.75 ≥ 0.7)
• {Couches} ⇒ {Lait} : Confiance = Support({Lait, Couches}) / Support({Couches}) = 0.6 / 0.8 =
0.75 . Intéressante (0.75 ≥ 0.7)
• Itemset {Pain, Bière} (Support = 0.6)
• {Pain} ⇒ {Bière} : Confiance = Support({Pain, Bière}) / Support({Pain}) = 0.6 / 0.8 = 0.75 .
Intéressante (0.75 ≥ 0.7)
• {Bière} ⇒ {Pain} : Confiance = Support({Pain, Bière}) / Support({Bière}) = 0.6 / 0.8 = 0.75 .
Intéressante (0.75 ≥ 0.7)
• Itemset {Pain, Couches} (Support = 0.6)
• {Pain} ⇒ {Couches} : Confiance = Support({Pain, Couches}) / Support({Pain}) = 0.6 / 0.8 = 0.75 .
Intéressante (0.75 ≥ 0.7)
• {Couches} ⇒ {Pain} : Confiance = Support({Pain, Couches}) / Support({Couches}) = 0.6 / 0.8 =
0.75 . Intéressante (0.75 ≥ 0.7)
• Itemset {Bière, Couches} (Support = 0.6)
• {Bière} ⇒ {Couches} : Confiance = Support({Bière, Couches}) / Support({Bière}) = 0.6 / 0.8 =
0.75 . Intéressante (0.75 ≥ 0.7)
• {Couches} ⇒ {Bière} : Confiance = Support({Bière, Couches}) / Support({Couches}) = 0.6 / 0.8 =
0.75 . Intéressante (0.75 ≥ 0.7)
Toutes les règles générées à partir de L2 sont intéressantes avec un minconf = 0.7 .
Partie 3 : Implémentation Python de l'algorithme Apriori
Python
from itertools import combinations
from collections import defaultdict

def apriori_freq_itemsets(transactions, min_support):

# Convertir les transactions en ensembles pour faciliter les opérations
transactions_sets = [set(t) for t in transactions]
num_transactions = len(transactions)

# Étape 1: Générer les 1-itemsets et filtrer les fréquents

item_counts = defaultdict(int)
for t in transactions_sets:
for item in t:
item_counts[frozenset([item])] += 1

L = {1: {itemset: count / num_transactions for itemset, count in item_counts

k = 2
while True:
# Générer les candidats Ck à partir de Lk-1
Ck = set()
prev_freq_itemsets = list(L[k-1].keys())
for i in range(len(prev_freq_itemsets)):
for j in range(i + 1, len(prev_freq_itemsets)):
union = prev_freq_itemsets[i].union(prev_freq_itemsets[j])
if len(union) == k:
# Vérifier la propriété anti-monotone (tous les sous-ensemb
is_candidate = True
for subset in combinations(union, k - 1):
if frozenset(subset) not in L[k-1]:
is_candidate = False
break
if is_candidate:
[Link](union)

if not Ck:
break

# Comptage des supports pour Ck

candidate_counts = defaultdict(int)
for t in transactions_sets:
for candidate in Ck:
if [Link](t):
candidate_counts[candidate] += 1

# Filtrage des itemsets fréquents Lk

Lk = {itemset: count / num_transactions for itemset, count in candidate_

if not Lk:
break

L[k] = Lk
k += 1
 all_freq_itemsets = {}
for k_level_itemsets in [Link]():
all_freq_itemsets.update(k_level_itemsets)

return all_freq_itemsets

# Exemple de test
transactions_example = [
["Lait", "Pain", "Bière"],
["Lait", "Pain", "Couches"],
["Lait", "Bière", "Couches"],
["Pain", "Bière", "Couches"],
["Lait", "Pain", "Bière", "Couches"]
]
min_support_example = 0.6

print("Itemsets fréquents (Apriori) :")

result_apriori = apriori_freq_itemsets(transactions_example, min_support_example
for itemset, support in result_apriori.items():
print(f" {set(itemset)}: {support:.2f}")

Explication du code :
1. apriori_freq_itemsets(transactions, min_support) : La fonction principale prend une liste
de transactions et le support minimum.
2. transactions_sets : Convertit chaque transaction en set pour des vérifications
d'inclusion plus efficaces ( issubset ).
3. Initialisation L[1] : Calcule le support de chaque 1-itemset et ne garde que ceux qui
sont fréquents.
4. Boucle while True : Itère pour trouver les itemsets fréquents de taille k=2 , k=3 , etc.
5. Génération des candidats Ck : Pour générer les candidats de taille k à partir des
itemsets fréquents de taille k-1 , on combine chaque paire d'itemsets de L[k-1] qui
partagent k-2 éléments. Ensuite, on applique la propriété anti-monotone : on vérifie
que tous les sous-ensembles de taille k-1 du candidat sont bien dans L[k-1] . Si ce n'est
pas le cas, le candidat ne peut pas être fréquent et est ignoré.
6. Comptage et Filtrage Lk : Pour chaque candidat, on parcourt toutes les transactions
pour compter son apparition. Seuls les candidats dont le support est supérieur ou égal
à min_support sont ajoutés à L[k] .
7. Condition d'arrêt : La boucle s'arrête lorsque aucun nouvel itemset fréquent n'est
trouvé ( Lk est vide).
8. all_freq_itemsets : Rassemble tous les itemsets fréquents trouvés à chaque niveau k .
Chapitre 2 : Arbres de Décision (ID3/C4.5)
Exercices Faciles
Question 2.1 (Théorie) :
Dans un arbre de décision, que représente un nœud interne, une branche et une feuille ?
Correction 2.1 :
• Un nœud interne représente un test sur une caractéristique (attribut) des données.
• Une branche représente une des valeurs possibles de l'attribut testé par le nœud
parent.
• Une feuille (ou nœud terminal) représente la classe prédite ou la valeur de régression
finale.
Question 2.2 (Théorie) :
Quel est l'objectif principal de l'algorithme ID3 lors du choix de l'attribut à chaque étape de
construction de l'arbre ?
Correction 2.2 :
L'objectif principal de l'algorithme ID3 est de choisir l'attribut qui maximise le Gain
d'information. Cela signifie choisir l'attribut qui réduit le plus l'incertitude (entropie) de
l'ensemble de données, permettant ainsi de mieux séparer les classes.
Exercices Moyens
Question 2.3 (Calcul) :
Considérez un ensemble de données S avec 10 instances, dont 7 appartiennent à la classe
"Oui" et 3 à la classe "Non". Calculez l'entropie de cet ensemble S .
Correction 2.3 :
Formule de l'Entropie : Entropie(S) = - p/(p+n) * log2(p/(p+n)) - n/(p+n) * log2(n/(p+n))
Ici, p = 7 (Oui) et n = 3 (Non), donc p+n = 10 .
Entropie(S) = - (7/10) * log2(7/10) - (3/10) * log2(3/10)
Entropie(S) = - 0.7 * log2(0.7) - 0.3 * log2(0.3)
log2(0.7) ≈ -0.51457
log2(0.3) ≈ -1.73697
Entropie(S) = - 0.7 * (-0.51457) - 0.3 * (-1.73697)
Entropie(S) = 0.3602 + 0.5211
Entropie(S) ≈ 0.8813
L'entropie de cet ensemble est d'environ 0.8813.
Question 2.4 (Théorie) :
Listez deux avantages et deux inconvénients majeurs des arbres de décision.
Correction 2.4 :
Avantages :
1. Interprétabilité ("boîte blanche") : Les arbres de décision sont faciles à comprendre
et à visualiser, ce qui permet d'expliquer les décisions prises par le modèle.
2. Peu de préparation des données : Ils ne nécessitent généralement pas de
normalisation ou de mise à l'échelle des données, et peuvent gérer des données
catégorielles et numériques.
Inconvénients :
1. Sur-apprentissage (Overfitting) : Les arbres de décision peuvent devenir très
complexes et mémoriser le bruit dans les données d'entraînement, ce qui réduit leur
capacité à généraliser sur de nouvelles données.
2. Instabilité : Un petit changement dans les données d'entraînement peut entraîner la
construction d'un arbre de décision complètement différent.
Exercices Difficiles
Question 2.5 (Calcul & Algorithme) :
Considérez le jeu de données simplifié suivant pour prédire si un client achètera un produit
(Oui/Non) :
ID Âge Revenu Étudiant Achète
1 Jeune Élevé Non Non
2 Jeune Élevé Oui Oui
3 Moyen Élevé Non Oui
4 Senior Moyen Non Oui
5 Senior Faible Oui Oui
6 Senior Faible Non Non
7 Moyen Faible Oui Oui
8 Jeune Moyen Non Non
 9 Jeune Faible Oui Oui
10 Senior Moyen Oui Oui

1. Calculez l'entropie de l'ensemble de données S pour la variable "Achète".

2. Calculez le Gain d'information pour l'attribut "Étudiant".
3. Quel attribut choisiriez-vous comme nœud racine si vous deviez choisir entre "Âge",
"Revenu" et "Étudiant" en vous basant uniquement sur le Gain d'information (sans faire
tous les calculs, mais en expliquant la démarche) ?
Correction 2.5 :
Partie 1 : Entropie de l'ensemble de données S pour "Achète"
Comptons les classes pour "Achète" :
• "Oui" : 7 instances (ID 2, 3, 4, 5, 7, 9, 10)
• "Non" : 3 instances (ID 1, 6, 8)
Total N = 10 .
Entropie(S) = - (7/10) * log2(7/10) - (3/10) * log2(3/10)
Entropie(S) ≈ 0.8813 (calculé à la Question 2.3)
Partie 2 : Gain d'information pour l'attribut "Étudiant"
L'attribut "Étudiant" a deux valeurs : "Oui" et "Non".
• Quand Étudiant = "Oui" : (Instances 2, 5, 7, 9, 10) → 5 instances
• Achète = "Oui" : 5
• Achète = "Non" : 0
Entropie(S_Oui) = - (5/5) * log2(5/5) - (0/5) * log2(0/5) = -1 * log2(1) - 0 = 0 (Un ensemble pur a
une entropie de 0)
• Quand Étudiant = "Non" : (Instances 1, 3, 4, 6, 8) → 5 instances
• Achète = "Oui" : 2 (ID 3, 4)
• Achète = "Non" : 3 (ID 1, 6, 8)
Entropie(S_Non) = - (2/5) * log2(2/5) - (3/5) * log2(3/5)
Entropie(S_Non) = - 0.4 * log2(0.4) - 0.6 * log2(0.6)
log2(0.4) ≈ -1.3219
log2(0.6) ≈ -0.7369
Entropie(S_Non) = - 0.4 * (-1.3219) - 0.6 * (-0.7369)
 Entropie(S_Non) = 0.52876 + 0.44214
Entropie(S_Non) ≈ 0.9709
Maintenant, calculons l'entropie conditionnelle I(Étudiant) :
I(Étudiant) = (5/10) * Entropie(S_Oui) + (5/10) * Entropie(S_Non)
I(Étudiant) = 0.5 * 0 + 0.5 * 0.9709 = 0.48545
Enfin, le Gain d'information pour "Étudiant" :
Gain(S, Étudiant) = Entropie(S) - I(Étudiant)
Gain(S, Étudiant) = 0.8813 - 0.48545 ≈ 0.39585
Partie 3 : Choix de l'attribut racine
Pour choisir l'attribut racine, nous devrions calculer le Gain d'information pour chaque
attribut ("Âge", "Revenu", "Étudiant") et sélectionner celui qui a le Gain le plus élevé. Le
Gain d'information mesure la réduction de l'incertitude. Un attribut qui sépare mieux les
classes (rend les sous-ensembles plus purs) aura un Gain d'information plus élevé.
Dans cet exemple, l'attribut "Étudiant" a une valeur de Gain d'information de 0.39585 . Si
les Gains pour "Âge" et "Revenu" étaient inférieurs à cette valeur, "Étudiant" serait choisi
comme nœud racine. La démarche consiste à :
1. Calculer l'entropie de l'ensemble de données parent.
2. Pour chaque valeur de l'attribut candidat, calculer l'entropie du sous-ensemble
correspondant.
3. Calculer l'entropie conditionnelle de l'attribut.
4. Calculer le Gain d'information en soustrayant l'entropie conditionnelle de l'entropie
parent.
5. Choisir l'attribut avec le Gain d'information maximal.
Question 2.6 (Code) :
Utilisez la bibliothèque scikit-learn pour créer un arbre de décision sur le jeu de données
"Jouer au Tennis" (simplifié) que nous avons vu dans la synthèse. Affichez la prédiction
pour un nouveau cas : Ciel='Soleil', Température='Doux', Humidité='Faible' .
Python
from [Link] import DecisionTreeClassifier
from [Link] import LabelEncoder
import numpy as np

# Données d'entraînement (simplifiées pour l'exemple)

# Ciel, Température, Humidité, Jouer
data = [Link]([
 ['Soleil', 'Chaud', 'Forte', 'Non'],
['Soleil', 'Chaud', 'Forte', 'Non'],
['Couvert', 'Chaud', 'Faible', 'Oui'],
['Pluie', 'Doux', 'Faible', 'Oui'],
['Pluie', 'Froid', 'Faible', 'Oui'],
['Pluie', 'Froid', 'Forte', 'Non'],
['Couvert', 'Froid', 'Forte', 'Oui'],
['Soleil', 'Doux', 'Forte', 'Non'],
['Soleil', 'Froid', 'Faible', 'Oui'],
['Pluie', 'Doux', 'Faible', 'Oui'],
['Soleil', 'Doux', 'Faible', 'Oui'],
['Couvert', 'Doux', 'Forte', 'Oui'],
['Couvert', 'Chaud', 'Faible', 'Oui'],
['Pluie', 'Doux', 'Forte', 'Non']
])

X_raw = data[:, :3] # Attributs: Ciel, Température, Humidité

y = data[:, 3] # Classe: Jouer

# Encodage des attributs catégoriels en numérique

encoders = []
X_encoded = [Link]((len(X_raw), X_raw.shape[1]), dtype=int)
for i in range(X_raw.shape[1]):
le = LabelEncoder()
X_encoded[:, i] = le.fit_transform(X_raw[:, i])
[Link](le)

# Création et entraînement du classifieur d'arbre de décision

# Utilisation de 'entropy' pour simuler ID3/C4.5
clf = DecisionTreeClassifier(criterion='entropy', random_state=42)
[Link](X_encoded, y)

# Nouveau cas à prédire

nouveau_cas_raw = ['Soleil', 'Doux', 'Faible']

# Encodage du nouveau cas avec les mêmes encodeurs

nouveau_cas_encoded = []
for i, val in enumerate(nouveau_cas_raw):
nouveau_cas_encoded.append(encoders[i].transform([val])[0])

# Prédiction
prediction = [Link]([nouveau_cas_encoded])[0]
print(f"Pour un ciel '{nouveau_cas_raw[0]}', une température '{nouveau_cas_raw[1

Correction 2.6 :
Le code ci-dessus utilise LabelEncoder pour convertir les attributs catégoriels (comme
'Soleil', 'Chaud') en valeurs numériques, ce qui est nécessaire pour scikit-learn . Ensuite, un
DecisionTreeClassifier est entraîné avec le critère entropy (correspondant à l'Information
Gain utilisé par ID3/C4.5). Enfin, le nouveau cas est encodé de la même manière et la
prédiction est affichée.
Résultat attendu :
Pour un ciel 'Soleil', une température 'Doux' et une humidité 'Faible', la prédiction est : Oui

Chapitre 3 : Apprentissage par Ensemble (Ensemble

Learning)
Exercices Faciles
Question 3.1 (Théorie) :
Quel est le principe général de l'apprentissage par ensemble ?
Correction 3.1 :
Le principe général de l'apprentissage par ensemble est de combiner les prédictions de
plusieurs modèles d'apprentissage individuels (souvent appelés "apprenants faibles") pour
obtenir un modèle global plus robuste, plus précis et plus généralisable ("apprenant fort").
L'idée est que la sagesse collective de plusieurs modèles est supérieure à celle d'un seul.
Question 3.2 (Théorie) :
Citez deux types d'approches d'apprentissage par ensemble.
Correction 3.2 :
Deux types d'approches d'apprentissage par ensemble sont :
1. Bagging (ex: Random Forest)
2. Boosting (ex: AdaBoost)
Exercices Moyens
Question 3.3 (Théorie) :
Comparez le Bagging et le Boosting en termes d'objectif principal (réduction de biais ou
variance) et de la manière dont les modèles sont entraînés (parallèle ou séquentiel).
Correction 3.3 :
Caractéristique Bagging (ex: Random Forest) Boosting (ex: AdaBoost)
Objectif Réduire la variance (anti- Réduire le biais (anti-
overfitting) underfitting)
 Modèles entraînés en parallèle Modèles entraînés
Entraînement sur des sous-échantillons séquentiellement, chaque
bootstrapés nouveau modèle corrige les
erreurs du précédent

Question 3.4 (Théorie) :

Expliquez brièvement le concept de "bootstrap" dans le contexte du Bagging.
Correction 3.4 :
Le "bootstrap" est une technique d'échantillonnage avec remplacement. Dans le contexte
du Bagging, cela signifie que pour entraîner chaque modèle individuel de l'ensemble, on
crée un nouvel ensemble de données d'entraînement en tirant aléatoirement des
observations de l'ensemble de données original, avec la possibilité de sélectionner la
même observation plusieurs fois. Chaque modèle est ainsi entraîné sur un sous-ensemble
légèrement différent des données, ce qui introduit de la diversité et aide à réduire la
variance de l'ensemble final.
Exercices Difficiles
Question 3.5 (Calcul & Théorie) :
Dans le cadre d'AdaBoost, si un classifieur h_t a une erreur ε_t = 0.2 et un autre classifieur
h_s a une erreur ε_s = 0.4 , lequel aura un poids α plus élevé et pourquoi ? Calculez ces
poids.
Correction 3.5 :
La formule du poids d'un classifieur dans AdaBoost est : α_t = 0.5 * log((1 - ε_t) / ε_t) .
Un classifieur avec une erreur plus faible (plus performant) aura un poids α plus élevé, car
le terme (1 - ε_t) / ε_t sera plus grand, et donc son logarithme sera plus grand.
• Pour h_t avec ε_t = 0.2 :
α_t = 0.5 * log((1 - 0.2) / 0.2) = 0.5 * log(0.8 / 0.2) = 0.5 * log(4)
log(4) ≈ 1.386 (logarithme naturel)
α_t ≈ 0.5 * 1.386 = 0.693
• Pour h_s avec ε_s = 0.4 :
α_s = 0.5 * log((1 - 0.4) / 0.4) = 0.5 * log(0.6 / 0.4) = 0.5 * log(1.5)
log(1.5) ≈ 0.405
α_s ≈ 0.5 * 0.405 = 0.2025
Comme prévu, α_t (0.693) est plus élevé que α_s (0.2025) . Le classifieur h_t avec l'erreur la
plus faible aura un poids plus important dans la décision finale de l'ensemble.
Question 3.6 (Code) :
En utilisant scikit-learn , entraînez un RandomForestClassifier et un AdaBoostClassifier sur un
jeu de données synthétique. Comparez leurs scores de précision sur un ensemble de test.
(Vous pouvez réutiliser le code de la synthèse).
Python
from [Link] import RandomForestClassifier, AdaBoostClassifier
from [Link] import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from [Link] import make_classification

# Génération de données synthétiques pour l'exemple

# n_samples: nombre d'échantillons
# n_features: nombre total de caractéristiques
# n_informative: nombre de caractéristiques informatives (utiles pour la classi
# n_redundant: nombre de caractéristiques redondantes (corrélées à d'autres info
# random_state: pour la reproductibilité
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_re

# Division des données en ensembles d'entraînement et de test

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_

print("Entraînement et évaluation des modèles d'ensemble :\n")

# ----- BAGGING : Random Forest -----

# n_estimators: nombre d'arbres dans la forêt
# max_depth: profondeur maximale de chaque arbre
rf = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42)
[Link](X_train, y_train)
print(f"Précision (Accuracy) du Random Forest: {[Link](X_test, y_test):.4f}")

# ----- BOOSTING : AdaBoost -----

# estimator: l'apprenant faible (ici, un arbre de décision de profondeur 1 - stu
# n_estimators: nombre d'apprenants faibles
# algorithm: algorithme utilisé (SAMME pour les classes discrètes)
ada = AdaBoostClassifier(estimator=DecisionTreeClassifier(max_depth=1),
n_estimators=50, algorithm="SAMME", random_state=42)
[Link](X_train, y_train)
print(f"Précision (Accuracy) de l'AdaBoost: {[Link](X_test, y_test):.4f}")

Correction 3.6 :
Le code utilise make_classification pour générer un jeu de données binaire synthétique. Il
divise ensuite les données en ensembles d'entraînement et de test. Deux modèles
d'ensemble sont entraînés :
 • RandomForestClassifier (Bagging) avec 100 arbres de profondeur maximale 10.
• AdaBoostClassifier (Boosting) avec 50 arbres de décision de profondeur 1 (stumps)
comme apprenants faibles.
Les scores de précision sont ensuite affichés pour chaque modèle sur l'ensemble de test.
Les résultats peuvent varier légèrement en fonction de la version de scikit-learn et du
random_state , mais généralement, les modèles d'ensemble devraient montrer de bonnes
performances.
Exemple de sortie (les valeurs peuvent varier) :
Plain Text
Entraînement et évaluation des modèles d'ensemble :

Précision (Accuracy) du Random Forest: 0.9033

Précision (Accuracy) de l'AdaBoost: 0.8600

Chapitre 4 : Réseaux de Neurones Convolutifs (CNN)

Exercices Faciles
Question 4.1 (Théorie) :
Pourquoi les Réseaux de Neurones Convolutifs (CNN) sont-ils préférables aux Réseaux de
Neurones Artificiels (ANN) classiques pour le traitement des images ? Citez deux raisons
principales.
Correction 4.1 :
Deux raisons principales sont :
1. Gestion du nombre de paramètres : Les CNN réduisent considérablement le nombre
de paramètres par rapport aux ANN pour les images, grâce au partage de poids et à
l'utilisation de filtres locaux, évitant ainsi l'explosion du nombre de poids.
2. Préservation de la structure spatiale : Les CNN exploitent la structure 2D (ou 3D) des
images via l'opération de convolution, ce qui permet de conserver les relations de
voisinage entre les pixels, contrairement à l'aplatissement des images en vecteurs pour
les ANN.
Question 4.2 (Théorie) :
Décrivez brièvement l'opération de convolution dans un CNN.
Correction 4.2 :
L'opération de convolution consiste à faire "glisser" un petit filtre (ou noyau) sur l'image
d'entrée. À chaque position, le filtre effectue une multiplication élément par élément avec
la région correspondante de l'image, puis somme les résultats pour produire une seule
valeur dans la carte de caractéristiques (feature map). Ce processus permet d'extraire des
motifs locaux comme les bords ou les textures.
Exercices Moyens
Question 4.3 (Théorie) :
Expliquez le rôle de la couche de Pooling (sous-échantillonnage) et de la couche
d'Activation (ReLU) dans une architecture CNN typique.
Correction 4.3 :
• Couche de Pooling : Son rôle est de réduire la dimension spatiale des cartes de
caractéristiques (par exemple, en prenant le maximum ou la moyenne d'une petite
région). Cela permet de réduire le nombre de paramètres et de calculs, de rendre le
modèle plus robuste aux petites variations de position des motifs (invariance de
translation), et d'éviter le sur-apprentissage.
• Couche d'Activation (ReLU) : Elle introduit de la non-linéarité dans le réseau. Sans
fonctions d'activation non linéaires, un réseau de neurones ne pourrait apprendre que
des relations linéaires, limitant considérablement sa capacité à modéliser des données
complexes. ReLU ( max(0, x) ) est populaire pour sa simplicité et son efficacité à résoudre
le problème du gradient évanescent.
Question 4.4 (Théorie) :
Décrivez l'effet d'un noyau de détection de contours comme [[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]]
lorsqu'il est appliqué à une image.
Correction 4.4 :
Ce noyau est un filtre passe-haut qui amplifie les différences d'intensité entre les pixels
voisins. Lorsque ce filtre est convolué avec une image :
• Les zones uniformes (où les pixels voisins ont des valeurs très similaires) donneront
une valeur proche de zéro, car les valeurs positives et négatives du filtre s'annuleront
mutuellement.
• Les contours (où il y a des changements brusques d'intensité, comme le passage d'une
zone claire à une zone sombre) produiront des valeurs très positives ou très négatives.
Le pixel central sera fortement pondéré par 8, tandis que ses voisins seront soustraits,
ce qui mettra en évidence la transition et donc le bord.
En résumé, il permet de faire ressortir les bords et les détails fins de l'image.
Exercices Difficiles
Question 4.5 (Algorithme & Code) :
Décrivez l'architecture d'un CNN simple pour la classification d'images (par exemple,
MNIST ou CIFAR-10) en listant les types de couches dans l'ordre et en expliquant
brièvement le rôle de chaque type de couche. Ensuite, écrivez le code TensorFlow/Keras
pour construire cette architecture.
Correction 4.5 :
Description de l'architecture CNN simple :
Une architecture CNN typique pour la classification d'images suit un schéma de blocs
répétés de couches de convolution et de pooling, suivis de couches denses pour la
classification finale.
1. Couche de Convolution (Conv2D) : C'est la première couche qui reçoit l'image
d'entrée. Elle applique un ensemble de filtres pour extraire des caractéristiques de bas
niveau (bords, textures). L'activation ReLU est souvent utilisée après la convolution
pour introduire la non-linéarité.
2. Couche de Pooling (MaxPooling2D) : Réduit la dimension spatiale de la carte de
caractéristiques générée par la couche de convolution. Cela aide à rendre le modèle
plus robuste aux petites variations de position et à réduire le nombre de paramètres.
3. Blocs Répétés (Conv2D + MaxPooling2D) : Ces deux types de couches sont souvent
répétés plusieurs fois, avec un nombre croissant de filtres dans les couches de
convolution, pour extraire des caractéristiques de plus en plus complexes et abstraites.
4. Couche Flatten : Après les blocs convolutifs et de pooling, les cartes de caractéristiques
2D (ou 3D) sont "aplaties" en un vecteur unidimensionnel. Cette étape est nécessaire
pour connecter les couches convolutives aux couches denses traditionnelles.
5. Couches Denses (Dense / Fully Connected) : Ce sont des couches de neurones
classiques qui reçoivent le vecteur de caractéristiques aplati. Elles apprennent des
combinaisons complexes de ces caractéristiques pour effectuer la classification finale.
Une activation ReLU est généralement utilisée pour les couches intermédiaires, et une
activation softmax pour la couche de sortie afin d'obtenir des probabilités pour chaque
classe.
Code TensorFlow/Keras :
Python
import tensorflow as tf
from [Link] import layers, models

def build_simple_cnn(input_shape, num_classes):

 model = [Link]([
# Bloc 1: Convolution et Pooling
layers.Conv2D(32, (3, 3), activation='relu', input_shape=input_shape), #
layers.MaxPooling2D((2, 2)), # Pooling 2x2

# Bloc 2: Convolution et Pooling

layers.Conv2D(64, (3, 3), activation='relu'), # 64 filtres 3x3, activati
layers.MaxPooling2D((2, 2)), # Pooling 2x2

# Bloc 3: Convolution (optionnel, peut être répété plus de fois)

layers.Conv2D(64, (3, 3), activation='relu'), # 64 filtres 3x3, activati

# Aplatissement pour les couches denses

[Link](),

# Couches Denses pour la classification

[Link](64, activation='relu'), # Couche dense avec 64 neurones et
[Link](num_classes, activation='softmax') # Couche de sortie avec
])

# Compilation du modèle
[Link](optimizer='adam',
loss='sparse_categorical_crossentropy', # Adapté pour les labe
metrics=['accuracy'])

return model

# Exemple d'utilisation pour des images 32x32 RVB (comme CIFAR-10) et 10 classes
input_shape_example = (32, 32, 3) # Hauteur, Largeur, Canaux (RVB)
num_classes_example = 10

cnn_model = build_simple_cnn(input_shape_example, num_classes_example)

cnn_model.summary()

# Pour l'entraînement, il faudrait charger des données (ex: CIFAR-10)

# (train_images, train_labels), (test_images, test_labels) = [Link].c
# cnn_model.fit(train_images, train_labels, epochs=10, validation_data=(test_ima

Explication du code :
1. La fonction build_simple_cnn prend input_shape (dimensions de l'image d'entrée) et
num_classes (nombre de catégories à prédire).
2. Elle utilise l'API Sequential de Keras pour empiler les couches.
3. layers.Conv2D : Définit une couche de convolution. Le premier argument est le nombre
de filtres, le second est la taille du noyau (ici 3x3). activation='relu' applique la fonction
d'activation ReLU. input_shape est spécifié uniquement pour la première couche.
 4. layers.MaxPooling2D : Réduit la taille spatiale. (2,2) signifie que la taille est divisée par 2
en hauteur et en largeur.
5. [Link]() : Convertit la sortie 2D/3D des couches convolutives en un vecteur 1D.
6. [Link] : Couches entièrement connectées. La dernière couche a num_classes
neurones et une activation softmax pour la classification multi-classes, donnant des
probabilités pour chaque classe.
7. [Link] : Configure le processus d'apprentissage avec un optimiseur ( adam ),
une fonction de perte ( sparse_categorical_crossentropy pour les labels entiers) et des
métriques ( accuracy ).
8. [Link]() : Affiche un résumé du modèle, y compris le nombre de paramètres
pour chaque couche, ce qui est utile pour comprendre la complexité du modèle.

Chapitre 5 : Synthèse des Indicateurs de Performance

Exercices Faciles
Question 5.1 (Théorie) :
Dans une matrice de confusion, que signifient les termes VP, FP, FN et VN ?
Correction 5.1 :
• VP (Vrais Positifs) : Le modèle a correctement prédit la classe positive.
• FP (Faux Positifs) : Le modèle a prédit la classe positive alors que la classe réelle était
négative (erreur de type I).
• FN (Faux Négatifs) : Le modèle a prédit la classe négative alors que la classe réelle était
positive (erreur de type II).
• VN (Vrais Négatifs) : Le modèle a correctement prédit la classe négative.
Question 5.2 (Théorie) :
Quelle métrique est la plus appropriée pour évaluer un modèle de régression ?
Correction 5.2 :
L'Erreur Quadratique Moyenne (Mean Squared Error - MSE) est une métrique très
courante et appropriée pour évaluer un modèle de régression.
Exercices Moyens
Question 5.3 (Calcul) :
Un modèle de classification a produit la matrice de confusion suivante :
 Prédit/Réel Positif (Prédit) Négatif (Prédit)
Positif (Réel) 80 20
Négatif (Réel) 10 90

Calculez la Précision (Accuracy), le Rappel (Recall) et la Précision (Precision) de ce modèle.

Correction 5.3 :
À partir de la matrice de confusion :
• VP = 80
• FN = 20
• FP = 10
• VN = 90
Total des instances = VP + FN + FP + VN = 80 + 20 + 10 + 90 = 200
1. Précision (Accuracy) :
Accuracy = (VP + VN) / Total = (80 + 90) / 200 = 170 / 200 = 0.85
2. Rappel (Recall / Sensibilité) :
Recall = VP / (VP + FN) = 80 / (80 + 20) = 80 / 100 = 0.80
3. Précision (Precision) :
Precision = VP / (VP + FP) = 80 / (80 + 10) = 80 / 90 ≈ 0.889
Question 5.4 (Théorie) :
Dans quel scénario le F1-Score est-il une métrique plus pertinente que la Précision
(Accuracy) simple, et pourquoi ?
Correction 5.4 :
Le F1-Score est une métrique plus pertinente que la Précision (Accuracy) simple dans les
scénarios où les classes sont déséquilibrées.
Explication : Lorsque l'une des classes est beaucoup plus fréquente que l'autre (par
exemple, 95% de classe négative et 5% de classe positive), un modèle peut atteindre une
très haute précision (Accuracy) en classifiant simplement toutes les instances comme
appartenant à la classe majoritaire. Cependant, ce modèle serait très mauvais pour
détecter la classe minoritaire, qui est souvent la classe d'intérêt (ex: détection de maladies
rares, fraude). Le F1-Score est la moyenne harmonique de la Précision et du Rappel, et il
pénalise fortement les modèles qui ont de faibles valeurs pour l'une ou l'autre de ces
métriques. Il fournit donc une mesure plus équilibrée de la performance du modèle sur les
deux classes, en particulier la classe minoritaire.
Exercices Difficiles
Question 5.5 (Calcul & Théorie) :
Un modèle de détection de fraude bancaire a été évalué. Sur 1000 transactions, 50 étaient
réellement frauduleuses. Le modèle a identifié 40 transactions comme frauduleuses, dont
35 étaient effectivement frauduleuses. Calculez la Précision (Accuracy), le Rappel (Recall),
la Précision (Precision) et le F1-Score. Discutez de la métrique la plus importante pour ce
cas et pourquoi.
Correction 5.5 :
Commençons par construire la matrice de confusion :
• Total transactions = 1000
• Réellement frauduleuses (Positif Réel) = 50
• Réellement non-frauduleuses (Négatif Réel) = 1000 - 50 = 950
• Modèle a identifié 40 comme frauduleuses (Positif Prédit).
• Parmi ces 40, 35 étaient réellement frauduleuses (VP = 35).
• Donc, 40 - 35 = 5 étaient des faux positifs (FP = 5).
• Puisque 35 des 50 frauduleuses ont été détectées, 50 - 35 = 15 n'ont pas été détectées
(FN = 15).
• Les non-frauduleuses correctement identifiées (VN) = Total non-frauduleuses - FP = 950
- 5 = 945.
Matrice de Confusion :
Prédit/Réel Frauduleux (Prédit) Non-Frauduleux (Prédit)
Frauduleux (Réel) VP = 35 FN = 15
Non-Frauduleux (Réel) FP = 5 VN = 945

Maintenant, calculons les métriques :

1. Précision (Accuracy) :
Accuracy = (VP + VN) / Total = (35 + 945) / 1000 = 980 / 1000 = 0.98 (ou 98%)
2. Rappel (Recall / Sensibilité) :
Recall = VP / (VP + FN) = 35 / (35 + 15) = 35 / 50 = 0.70 (ou 70%)
 3. Précision (Precision) :
Precision = VP / (VP + FP) = 35 / (35 + 5) = 35 / 40 = 0.875 (ou 87.5%)
4. F1-Score :
F1-Score = 2 * (Precision * Recall) / (Precision + Recall) = 2 * (0.875 * 0.70) / (0.875 + 0.70)
F1-Score = 2 * 0.6125 / 1.575 = 1.225 / 1.575 ≈ 0.7778
Discussion sur la métrique la plus importante :
Dans un cas de détection de fraude bancaire, la métrique la plus importante est
généralement le Rappel (Recall), suivie de près par le F1-Score.
• Pourquoi le Rappel est crucial ? Un faible Rappel signifie que le modèle manque un
grand nombre de transactions frauduleuses réelles (beaucoup de Faux Négatifs). Dans
le contexte bancaire, manquer une fraude peut entraîner des pertes financières
importantes pour la banque et ses clients. Il est souvent préférable de générer quelques
Faux Positifs (signaler à tort une transaction légitime comme frauduleuse, ce qui peut
être corrigé par une vérification manuelle) plutôt que de manquer une fraude réelle.
• Pourquoi le F1-Score est également important ? Bien que le Rappel soit primordial,
un modèle qui maximise le Rappel à tout prix pourrait générer un nombre inacceptable
de Faux Positifs (faible Précision), ce qui rendrait le système impraticable en raison du
coût des vérifications manuelles. Le F1-Score offre un bon équilibre entre le Rappel et la
Précision, et est donc une métrique robuste pour évaluer la performance globale dans
des jeux de données déséquilibrés comme la détection de fraude.
L'Accuracy (98%) est très élevée ici, mais elle est trompeuse en raison du fort déséquilibre
des classes (seulement 5% de fraudes). Elle ne reflète pas la capacité réelle du modèle à
détecter les fraudes.
Ce cahier d'exercices devrait vous fournir une excellente préparation pour votre examen de
Fouille de Données. N'hésitez pas à refaire les exercices de calcul et à expérimenter avec le
code pour bien maîtriser les concepts.