Algorithme Apriori – Le.Labo.Data

L’algorithme Apriori est une méthode classique et influente utilisée en data mining pour découvrir des règles d’association intéressantes au sein de grands ensembles de données transactionnelles.

1 Principe Fondamental : La Propriété d’Anti-Monotonie du Support

Au cœur de l’efficacité de l’algorithme Apriori se trouve une propriété mathématique simple mais puissante : la propriété d’anti-monotonie du support. Comprenons ce qu’elle signifie et pourquoi elle est si cruciale.

Le support d’un ensemble d’articles (itemset) est simplement sa fréquence d’apparition dans l’ensemble des transactions. Un itemset est dit “fréquent” si son support est supérieur ou égal à un seuil minimum défini par l’utilisateur (minsup).

La propriété d’anti-monotonie du support stipule deux choses interdépendantes :

Si un ensemble d’articles (itemset) est fréquent, alors tous ses sous-ensembles doivent également être fréquents.
- Explication : Si un groupe d’articles apparaît souvent ensemble, il est logique que n’importe quelle partie de ce groupe apparaisse au moins aussi souvent, voire plus.
- Exemple concret : Si l’itemset {Pain, Lait, Beurre} est acheté 100 fois (et donc considéré comme fréquent avec un minsup de 50), alors l’itemset {Pain, Lait} doit avoir été acheté au moins 100 fois (il est impossible qu’il ait été acheté moins de fois, car chaque fois que {Pain, Lait, Beurre} est acheté, {Pain, Lait} l’est aussi). De même pour {Pain}, {Lait}, {Beurre}, {Pain, Beurre}, et {Lait, Beurre}.
Inversement (et c’est la clé pour l’élagage), si un itemset n’est pas fréquent, alors aucun de ses super-ensembles (ensembles plus grands le contenant) ne peut être fréquent.
- Explication : Si un petit groupe d’articles n’apparaît pas souvent ensemble, ajouter d’autres articles à ce groupe ne le rendra pas magiquement plus fréquent. Au contraire, sa fréquence ne pourra qu’être égale ou inférieure.
- Exemple concret : Si l’itemset {Couches, Bière} est acheté seulement 5 fois (et donc considéré comme non fréquent avec un minsup de 50), il est inutile de vérifier la fréquence de {Couches, Bière, Chips}. En effet, {Couches, Bière, Chips} ne peut pas apparaître plus de 5 fois, et sera donc également non fréquent.

1.1 Pourquoi cette propriété est-elle si importante ?

L’exploration de toutes les combinaisons possibles d’articles dans un grand ensemble de données est une tâche exponentiellement complexe. La propriété d’anti-monotonie permet à l’algorithme Apriori de réduire considérablement l’espace de recherche.

Au lieu de calculer le support de chaque itemset possible, l’algorithme peut : - Commencer par les itemsets de petite taille. - Éliminer (ou “élaguer” / “pruner”) de manière proactive tous les itemsets plus grands qui contiennent un sous-ensemble déjà identifié comme non fréquent.

Cette stratégie d’élagage est ce qui rend Apriori réalisable pour des ensembles de données de taille raisonnable, bien qu’il ait ses limites avec des données extrêmement volumineuses ou des seuils de support très bas.

2 Les Deux Grandes Étapes de l’Algorithme Apriori

L’algorithme Apriori fonctionne principalement en deux phases :

2.1 Phase 1 : Génération des Itemsets Fréquents

L’objectif est d’identifier tous les ensembles d’articles (itemsets) dont la fréquence d’apparition dépasse un seuil minimum défini, appelé support minimum (minsup).

Initialisation (k=1) :
- Scanner la base de données pour compter la fréquence de chaque article individuel.
- Les articles dont le support est $\ge$ minsup forment le premier ensemble d’itemsets fréquents, $L_1$.
Itérations (k > 1) : Pour chaque niveau k (taille de l’itemset) :
- a. Génération des Candidats ($C_k$) :
  - Générer des itemsets candidats de taille k, $C_k$, en combinant les itemsets fréquents de taille k-1 (de $L_{k-1}$) par une opération de jointure.
- b. Élagage (Pruning) :
  - Pour chaque candidat dans $C_k$, vérifier si tous ses sous-ensembles de taille k-1 sont présents dans $L_{k-1}$.
  - Si un candidat a un sous-ensemble de taille k-1 non fréquent, il est éliminé (propriété Apriori).
- c. Vérification du Support et Sélection ($L_k$) :
  - Pour les candidats restants, scanner la base de données pour compter leur support réel.
  - Ceux dont le support est $\ge$ minsup forment l’ensemble des itemsets fréquents de taille k, $L_k$.
Arrêt : Répéter l’étape 2 jusqu’à ce qu’aucun nouvel itemset fréquent ne puisse être généré ($L_k$ est vide).

2.2 Phase 2 : Génération des Règles d’Association

Une fois tous les itemsets fréquents identifiés :

Pour chaque itemset fréquent $L$ trouvé :
- Générer toutes les règles non vides possibles de la forme $X \Rightarrow (L-X)$, où $X$ est un sous-ensemble non vide de $L$.
Pour chaque règle générée, calculer sa confiance : confiance(X => Y) = support(X U Y) / support(X).
Conserver uniquement les règles dont la confiance est $\ge$ à un seuil minimum défini, appelé confiance minimale (minconf).

3 Exemple

Pour illustrer l’algorithme Apriori, considérons un petit ensemble de transactions d’un supermarché.

Données de Transactions :

Imaginons les 5 transactions suivantes :

ID Transaction	Articles Achetés
T1	{Pain, Lait, Oeufs}
T2	{Pain, Beurre}
T3	{Lait, Oeufs, Beurre}
T4	{Pain, Lait, Beurre}
T5	{Pain, Lait, Oeufs, Beurre}

Paramètres :

Support Minimum (minsup) = 3 (Un itemset doit apparaître dans au moins 3 transactions pour être considéré comme fréquent).
Confiance Minimale (minconf) = 0.7 (Une règle doit avoir une confiance d’au moins 70%).

3.1 Phase 1 : Génération des Itemsets Fréquents

Étape 1 : Calculer le support des itemsets de taille 1 ($L_1$)

On scanne les transactions pour compter la fréquence de chaque article :

Pain : 4
Lait : 4
Oeufs : 3
Beurre : 4

Tous les articles ont un support $\ge$ minsup (3). Donc, $L_1$ est : $L_1 = \{\{\text{Pain}\}(4), \{\text{Lait}\}(4), \{\text{Oeufs}\}(3), \{\text{Beurre}\}(4)\}$ (Le chiffre entre parenthèses indique le support)

Étape 2 : Générer les candidats de taille 2 ($C_2$) et calculer $L_2$

a. Génération des Candidats ($C_2$) : On combine les éléments de $L_1$ (jointure) : $C_2 = \{\{\text{Pain, Lait}\}, \{\text{Pain, Oeufs}\}, \{\text{Pain, Beurre}\}, \{\text{Lait, Oeufs}\}, \{\text{Lait, Beurre}\}, \{\text{Oeufs, Beurre}\}\}$
b. Élagage (Pruning) : Aucun élagage n’est nécessaire ici car tous les sous-ensembles de taille 1 (les articles individuels) sont dans $L_1$.
c. Vérification du Support et Sélection ($L_2$) : On scanne à nouveau les transactions pour compter le support des candidats de $C_2$.
- {Pain, Lait} : Apparaît dans T1, T4, T5 (Support = 3) $\rightarrow$ Fréquent
- {Pain, Oeufs} : Apparaît dans T1, T5 (Support = 2) $\rightarrow$ Non fréquent
- {Pain, Beurre} : Apparaît dans T2, T4, T5 (Support = 3) $\rightarrow$ Fréquent
- {Lait, Oeufs} : Apparaît dans T1, T3, T5 (Support = 3) $\rightarrow$ Fréquent
- {Lait, Beurre} : Apparaît dans T3, T4, T5 (Support = 3) $\rightarrow$ Fréquent
- {Oeufs, Beurre} : Apparaît dans T3, T5 (Support = 2) $\rightarrow$ Non fréquent

Donc, $L_2$ est : $L_2 = \{\{\text{Pain, Lait}\}(3), \{\text{Pain, Beurre}\}(3), \{\text{Lait, Oeufs}\}(3), \{\text{Lait, Beurre}\}(3)\}$

Étape 3 : Générer les candidats de taille 3 ($C_3$) et calculer $L_3$

a. Génération des Candidats ($C_3$) : On combine les éléments de $L_2$ qui partagent $k-2$ (ici, 3-2=1) éléments communs.
- De {Pain, Lait} et {Pain, Beurre} $\rightarrow$ Candidat : {Pain, Lait, Beurre}
- De {Lait, Oeufs} et {Lait, Beurre} $\rightarrow$ Candidat : {Lait, Oeufs, Beurre} $C_3 = \{\{\text{Pain, Lait, Beurre}\}, \{\text{Lait, Oeufs, Beurre}\}\}$
b. Élagage (Pruning) : On vérifie si tous les sous-ensembles de taille 2 de chaque candidat sont dans $L_2$.
- Pour {Pain, Lait, Beurre} :
  - Sous-ensembles : {Pain, Lait} (dans $L_2$), {Pain, Beurre} (dans $L_2$), {Lait, Beurre} (dans $L_2$).
  - Tous les sous-ensembles sont fréquents $\rightarrow$ On conserve {Pain, Lait, Beurre}.
- Pour {Lait, Oeufs, Beurre} :
  - Sous-ensembles : {Lait, Oeufs} (dans $L_2$), {Lait, Beurre} (dans $L_2$), {Oeufs, Beurre} (pas dans $L_2$ car son support était 2).
  - Un sous-ensemble n’est pas fréquent $\rightarrow$ On élague {Lait, Oeufs, Beurre}. $C_3 \text{ (après élagage)} = \{\{\text{Pain, Lait, Beurre}\}\}$
c. Vérification du Support et Sélection ($L_3$) :
- {Pain, Lait, Beurre} : Apparaît dans T4, T5 (Support = 2) $\rightarrow$ Non fréquent

Donc, $L_3 = \{\}$ (ensemble vide).

Comme $L_3$ est vide, l’algorithme s’arrête pour la génération d’itemsets fréquents. Les itemsets fréquents sont ceux de $L_1$ et $L_2$.

3.2 Phase 2 : Génération des Règles d’Association

Nous utilisons les itemsets fréquents de $L_2$ pour générer des règles (ceux de $L_1$ ne produisent pas de règles $X \Rightarrow Y$ où $X$ et $Y$ sont non vides). Rappel : minconf = 0.7.

À partir de l’itemset fréquent {Pain, Lait} (Support=3)
- Règle : {Pain} $\Rightarrow$ {Lait}
  - Confiance = Support({Pain, Lait}) / Support({Pain}) = 3 / 4 = 0.75
  - $0.75 \ge 0.7 \rightarrow$ Conserver la règle.
- Règle : {Lait} $\Rightarrow$ {Pain}
  - Confiance = Support({Pain, Lait}) / Support({Lait}) = 3 / 4 = 0.75
  - $0.75 \ge 0.7 \rightarrow$ Conserver la règle.
À partir de l’itemset fréquent {Pain, Beurre} (Support=3)
- Règle : {Pain} $\Rightarrow$ {Beurre}
  - Confiance = Support({Pain, Beurre}) / Support({Pain}) = 3 / 4 = 0.75
  - $0.75 \ge 0.7 \rightarrow$ Conserver la règle.
- Règle : {Beurre} $\Rightarrow$ {Pain}
  - Confiance = Support({Pain, Beurre}) / Support({Beurre}) = 3 / 4 = 0.75
  - $0.75 \ge 0.7 \rightarrow$ Conserver la règle.
À partir de l’itemset fréquent {Lait, Oeufs} (Support=3)
- Règle : {Lait} $\Rightarrow$ {Oeufs}
  - Confiance = Support({Lait, Oeufs}) / Support({Lait}) = 3 / 4 = 0.75
  - $0.75 \ge 0.7 \rightarrow$ Conserver la règle.
- Règle : {Oeufs} $\Rightarrow$ {Lait}
  - Confiance = Support({Lait, Oeufs}) / Support({Oeufs}) = 3 / 3 = 1.0
  - $1.0 \ge 0.7 \rightarrow$ Conserver la règle.
À partir de l’itemset fréquent {Lait, Beurre} (Support=3)
- Règle : {Lait} $\Rightarrow$ {Beurre}
  - Confiance = Support({Lait, Beurre}) / Support({Lait}) = 3 / 4 = 0.75
  - $0.75 \ge 0.7 \rightarrow$ Conserver la règle.
- Règle : {Beurre} $\Rightarrow$ {Lait}
  - Confiance = Support({Lait, Beurre}) / Support({Beurre}) = 3 / 4 = 0.75
  - $0.75 \ge 0.7 \rightarrow$ Conserver la règle.

Résultat : Règles d’Association Fortes Découvertes

Avec minsup = 3 et minconf = 0.7, les règles suivantes sont identifiées :

{Pain} $\Rightarrow$ {Lait} (Support=3, Confiance=0.75)
{Lait} $\Rightarrow$ {Pain} (Support=3, Confiance=0.75)
{Pain} $\Rightarrow$ {Beurre} (Support=3, Confiance=0.75)
{Beurre} $\Rightarrow$ {Pain} (Support=3, Confiance=0.75)
{Lait} $\Rightarrow$ {Oeufs} (Support=3, Confiance=0.75)
{Oeufs} $\Rightarrow$ {Lait} (Support=3, Confiance=1.0) (Règle la plus forte)
{Lait} $\Rightarrow$ {Beurre} (Support=3, Confiance=0.75)
{Beurre} $\Rightarrow$ {Lait} (Support=3, Confiance=0.75)

Cet exemple montre comment Apriori, en utilisant la propriété d’anti-monotonie pour l’élagage, peut découvrir des relations intéressantes dans les données transactionnelles. Par exemple, la règle {Oeufs} \Rightarrow \{\text{Lait}\}$ avec une confiance de 1.0 indique que chaque fois que des oeufs sont achetés (dans notre petit jeu de données et avec notreminsup`), du lait est également acheté.

4 Mise en oeuvre sous Python

Pour implémenter l’algorithme Apriori en Python, la bibliothèque mlxtend (machine learning extensions) est une excellente option. Elle fournit des implémentations efficaces des algorithmes d’extraction de motifs fréquents et de génération de règles d’association.

Si vous ne l’avez pas encore installée, vous pouvez le faire avec pip :

Code

pip install mlxtend

Reprenons les données de notre exemple précédent :

# Install mlxtend
import pandas as pd
from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import apriori, association_rules

# Données de transactions de l'exemple
dataset = [['Pain', 'Lait', 'Oeufs'],
           ['Pain', 'Beurre'],
           ['Lait', 'Oeufs', 'Beurre'],
           ['Pain', 'Lait', 'Beurre'],
           ['Pain', 'Lait', 'Oeufs', 'Beurre']]

# 1. Préparation des données
# mlxtend attend les données sous forme d'un DataFrame booléen où chaque colonne est un item
# et chaque ligne une transaction. Les valeurs sont True si l'item est dans la transaction, False sinon.

te = TransactionEncoder()
te_ary = te.fit(dataset).transform(dataset)
df_transactions = pd.DataFrame(te_ary, columns=te.columns_)

print("--- DataFrame des Transactions Encodées ---")
print(df_transactions)

Code

# 2. Application de l'algorithme Apriori pour trouver les itemsets fréquents
# Nous utilisons le même min_support que dans l'exemple manuel (3 transactions sur 5 = 0.6)
# Cependant, l'algorithme Apriori de mlxtend attend un min_support relatif (entre 0 et 1).
# minsup_count = 3
# total_transactions = 5
# min_support_relative = minsup_count / total_transactions # 3/5 = 0.6

min_support_val = 0.6 # Correspond à 3 transactions

frequent_itemsets = apriori(df_transactions, min_support=min_support_val, use_colnames=True)

print("\n--- Itemsets Fréquents (minsup = 0.6) ---")
print(frequent_itemsets)

# 3. Génération des règles d'association
# Nous utilisons la même min_confidence que dans l'exemple manuel (0.7)

rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.7)

print("\n--- Règles d'Association (minconf = 0.7) ---")
# Affichons les colonnes les plus pertinentes
print(rules[['antecedents', 'consequents', 'support', 'confidence', 'lift']])

# Vous pouvez trier les règles par lift ou confiance pour voir les plus intéressantes
print("\n--- Règles triées par Lift ---")
print(rules.sort_values(by='lift', ascending=False)[['antecedents', 'consequents', 'support', 'confidence', 'lift']])

Explication du code :

Importations : Nous importons pandas pour la manipulation de données, TransactionEncoder pour transformer notre liste de listes en un format binaire adapté, et apriori et association_rules de mlxtend.
Préparation des Données :
- dataset : Notre liste de transactions.
- TransactionEncoder() : Cet objet va transformer les données. fit() apprend tous les items uniques, et transform() crée un tableau NumPy booléen.
- pd.DataFrame(...) : Nous convertissons ce tableau en DataFrame pandas, ce qui est le format attendu par mlxtend. Les colonnes sont les items et les valeurs sont True ou False.
Trouver les Itemsets Fréquents :
- apriori(df_transactions, min_support=0.6, use_colnames=True) :
  - Le premier argument est notre DataFrame encodé.
  - min_support=0.6 : C’est notre seuil de support minimum. Dans notre exemple manuel, minsup était de 3 transactions. Comme il y a 5 transactions au total, le support relatif est $3/5 = 0.6$.
  - use_colnames=True : Permet d’avoir les noms des items dans le résultat plutôt que des indices de colonnes.
- Le résultat frequent_itemsets est un DataFrame listant les itemsets fréquents et leur support.
Générer les Règles d’Association :
- association_rules(frequent_itemsets, metric="confidence", min_threshold=0.7) :
  - Le premier argument est le DataFrame des itemsets fréquents.
  - metric="confidence" : Spécifie que nous voulons filtrer les règles en fonction de la confiance.
  - min_threshold=0.7 : C’est notre seuil de confiance minimum, correspondant au minconf de 0.7 de notre exemple.
- Le résultat rules est un DataFrame contenant les règles générées avec plusieurs métriques utiles (support, confidence, lift, leverage, conviction).

En exécutant ce code, vous devriez obtenir des résultats cohérents avec ceux que nous avons calculés manuellement dans la section “Exemple”, ce qui valide à la fois notre compréhension et l’implémentation.

5 Mise en oeuvre sous R

Pour implémenter l’algorithme Apriori en R, nous utiliserons la bibliothèque arules, qui est l’une des bibliothèques les plus populaires et les plus complètes pour l’analyse des règles d’association.

Si vous ne l’avez pas encore installée, vous pouvez le faire avec :

Code

# install.packages("arules")
# install.packages("arulesViz") # Pour la visualisation (optionnel)

# Charger les bibliothèques
library(arules)
library(arulesViz) # Optionnel pour la visualisation

Reprenons les données de notre exemple précédent :

# Données de transactions de l'exemple
transactions_list <- list(
  c("Pain", "Lait", "Oeufs"),
  c("Pain", "Beurre"),
  c("Lait", "Oeufs", "Beurre"),
  c("Pain", "Lait", "Beurre"),
  c("Pain", "Lait", "Oeufs", "Beurre")
)

# 1. Préparation des données
# arules attend les données sous forme d'objet "transactions"
transactions <- as(transactions_list, "transactions")

print("--- Transactions ---")
inspect(transactions)

# 2. Application de l'algorithme Apriori pour trouver les itemsets fréquents
# Nous utilisons le même min_support que dans l'exemple manuel (3 transactions sur 5 = 0.6)

min_support_val <- 0.6 # Correspond à 3 transactions

frequent_itemsets <- apriori(transactions, parameter = list(support = min_support_val, target = "frequent itemsets"))

print("\n--- Itemsets Fréquents (minsup = 0.6) ---")
inspect(frequent_itemsets)

# 3. Génération des règles d'association
# Nous utilisons la même min_confidence que dans l'exemple manuel (0.7)

rules <- association_rules <- apriori(transactions, parameter = list(support = min_support_val, confidence = 0.7, target = "rules"))

print("\n--- Règles d'Association (minconf = 0.7) ---")
inspect(rules)

# Vous pouvez trier les règles par lift ou confiance pour voir les plus intéressantes
print("\n--- Règles triées par Lift ---")
inspect(sort(rules, by = "lift", decreasing = TRUE))

6 Avantages et Inconvenients

6.1 Avantages d’Apriori

Simple à comprendre et à implémenter.
Utilise efficacement la propriété d’anti-monotonie pour réduire l’espace de recherche.

6.2 Inconvénients d’Apriori

Peut être coûteux sur de grands jeux de données :
- Génération potentiellement massive d’ensembles candidats.
- Nécessite de multiples scans de la base de données.

7 Exercices

Exercise 1 (Application Manuelle d’Apriori) Considérez la base de données de transactions suivante :

ID Transaction	Articles Achetés
T1	{Pommes, Bananes, Lait}
T2	{Bananes, Pain}
T3	{Pommes, Lait, Pain}
T4	{Pommes, Bananes, Pain}
T5	{Bananes, Lait, Pain}
T6	{Pommes, Lait}

Python
R

Code

# Données pour l'exercice 2
dataset_ex2 = [
    {'Pommes', 'Bananes', 'Lait'},
    {'Bananes', 'Pain'},
    {'Pommes', 'Lait', 'Pain'},
    {'Pommes', 'Bananes', 'Pain'},
    {'Bananes', 'Lait', 'Pain'},
    {'Pommes', 'Lait'}
]

Code

# Données pour l'exercice 2
dataset_ex2 <- list(
  c("Pommes", "Bananes", "Lait"),
  c("Bananes", "Pain"),
  c("Pommes", "Lait", "Pain"),
  c("Pommes", "Bananes", "Pain"),
  c("Bananes", "Lait", "Pain"),
  c("Pommes", "Lait")
)

Tâches :

En utilisant un support minimum (minsup) de 3 (ou 50% car il y a 6 transactions), appliquez manuellement l’algorithme Apriori pour trouver tous les itemsets fréquents. Montrez chaque étape :
- Calcul de $L_1$.
- Génération des candidats $C_2$, élagage (si applicable), et calcul de $L_2$.
- Génération des candidats $C_3$, élagage (si applicable), et calcul de $L_3$.
- Continuez jusqu’à ce qu’aucun nouvel itemset fréquent ne soit trouvé.
Une fois les itemsets fréquents trouvés, générez toutes les règles d’association possibles à partir de l’itemset fréquent de taille maximale que vous avez trouvé.
Calculez la confiance pour chaque règle générée à l’étape 2.
Si la confiance minimale (minconf) est de 0.7 (ou 70%), quelles règles sont conservées ?

Exercise 2 (Implémentation avec Python et mlxtend) Utilisez le même jeu de données de transactions que l’Exercice précédent.

Tâches :

Préparez les données : Utilisez TransactionEncoder de mlxtend pour transformer dataset_ex2 en un DataFrame booléen approprié.
Trouvez les itemsets fréquents : Utilisez la fonction apriori de mlxtend avec :
- Un min_support de 0.5 (ce qui correspond à 3 transactions sur 6).
- Assurez-vous d’utiliser use_colnames=True.
- Affichez le DataFrame des itemsets fréquents.
Générez les règles d’association : Utilisez la fonction association_rules de mlxtend sur les itemsets fréquents trouvés à l’étape précédente avec :
- Une métrique de confidence.
- Un min_threshold de 0.7.
Affichez les règles : Affichez les colonnes antecedents, consequents, support, confidence, et lift des règles générées.
Comparez : Les itemsets fréquents et les règles trouvées avec mlxtend correspondent-ils à vos résultats manuels de l’Exercice 1 ?

Exercise 3 (Analyse et Interprétation des Règles) Considérez le jeu de données de transactions suivant, représentant les achats de cours en ligne :

Python
R

Code

# Données pour l'exercice 3
dataset_ex3 = [
    {'Python', 'Data Science', 'Machine Learning'},
    {'Python', 'Web Development'},
    {'Data Science', 'Machine Learning', 'SQL'},
    {'Python', 'Data Science'},
    {'Web Development', 'JavaScript'},
    {'Python', 'Machine Learning', 'SQL'},
    {'Data Science', 'SQL'},
    {'Python', 'Web Development', 'JavaScript'},
    {'Python', 'Data Science', 'Machine Learning', 'SQL'},
    {'Web Development', 'CSS'}
]

Code

# Données pour l'exercice 3
dataset_ex3 <- list(
  c("Python", "Data Science", "Machine Learning"),
  c("Python", "Web Development"),
  c("Data Science", "Machine Learning", "SQL"),
  c("Python", "Data Science"),
  c("Web Development", "JavaScript"),
  c("Python", "Machine Learning", "SQL"),
  c("Data Science", "SQL"),
  c("Python", "Web Development", "JavaScript"),
  c("Python", "Data Science", "Machine Learning", "SQL"),
  c("Web Development", "CSS")
)

Tâches :

En utilisant Python et mlxtend :
- Trouvez les itemsets fréquents avec un min_support de 0.3 (30%).
- Générez les règles d’association avec une min_confidence de 0.6 (60%).
Analysez les règles générées :
- Identifiez les 3 règles ayant le lift le plus élevé. Que signifient ces règles ? Sont-elles surprenantes ?
- Identifiez les 3 règles ayant la confiance la plus élevée. Que vous apprennent-elles ?
- Y a-t-il des règles qui vous semblent particulièrement intéressantes ou actionnables d’un point de vue marketing (par exemple, pour créer des “bundles” de cours) ?
Expérimentez avec les seuils :
- Ré-exécutez l’analyse en augmentant min_support à 0.4. Combien de règles obtenez-vous ? Qu’est-ce que cela implique ?
- Ré-exécutez l’analyse (avec min_support initial de 0.3) mais en augmentant min_confidence à 0.8. Comment cela affecte-t-il le nombre et la nature des règles ?
Discussion :
- Si vous deviez recommander un nouveau cours à un étudiant qui vient de s’inscrire au cours “Python”, quelle règle(s) utiliseriez-vous pour appuyer votre recommandation ?
- La règle {Data Science} => {Machine Learning} a une confiance élevée. Est-ce suffisant pour conclure que la plupart des étudiants intéressés par la Data Science s’inscrivent aussi au Machine Learning, ou d’autres facteurs pourraient-ils jouer un rôle ?

Copyright

2025 W. Toussile