Un algorithme qui trouve les combinaisons de produits achetées ensemble en croisant des listes de tickets. Pour chaque produit, on note les tickets qui le contiennent ; le nombre de tickets communs à deux listes donne directement la fréquence de la paire. Simple, rapide, idéal pour repérer les duos à mettre en pack.
Chaque produit a sa fiche avec la liste des numéros de tickets où il apparaît. Pour savoir si pâtes et sauce tomate vont ensemble, on pose les deux fiches côte à côte et on compte les numéros communs.
Au lieu d'une liste de produits par ticket, on stocke une liste de tickets par produit : c'est le format vertical. On écarte les produits sous le support minimum.
L'intersection de deux listes donne les tickets qui contiennent les deux produits. Sa longueur est le support de la paire, sans relire les données.
Si la paire est fréquente, on croise son intersection avec la liste d'un troisième produit, et ainsi de suite. On s'arrête dès que l'intersection passe sous le seuil.
Une ligne par ticket et par produit acheté, 28 produits. On cherche les duos de produits à proposer en pack ou en offre « le deuxième à -50 % ».
Au seuil de 3 % des tickets, Eclat trouve 193 combinaisons fréquentes sur le jeu d'exemple. Sept paires ressortent nettement : bière et chips (lift de 4), pâtes et sauce tomate (3), fromage et vin rouge (2,6), café et biscuits (2,1). Après elles, le lift retombe près de 1.
Le lift dit si le duo est vraiment lié ; le nombre de tickets dit combien de clients le pack peut toucher. Pain et beurre ont un lift modeste (1,95) mais 781 tickets : c'est le duo au plus fort potentiel de volume.
Eclat sort des combinaisons fréquentes, pas des règles. Noms donnés pour R (arules) et pour la version Python écrite à la main.
Part minimale de tickets contenant la combinaison. Il conditionne à la fois le temps de calcul et le nombre de résultats. 3 % sur 4 000 tickets signifie au moins 120 tickets.
Taille maximale des combinaisons. Pour des packs, 2 ou 3 produits suffisent et le calcul est bien plus rapide.
Le support seul favorise les produits populaires : pain et eau minérale sortent ensemble par simple fréquence. Trier par lift, ou utiliser ruleInduction() en R pour transformer les combinaisons en règles.
# Packs promotionnels : Eclat en R
library(arules)
paniers <- read.transactions("tickets_caisse.csv", format = "single", sep = ",",
header = TRUE, cols = c("id_ticket", "produit"))
# Toutes les combinaisons présentes dans au moins 3 % des tickets
frequents <- eclat(paniers, parameter = list(supp = 0.03, maxlen = 3),
control = list(verbose = FALSE))
cat("Combinaisons fréquentes :", length(frequents), "\n")
# Paires de produits, avec leur lift : observé / attendu si les achats étaient indépendants
paires <- frequents[size(frequents) == 2]
quality(paires)$lift <- interestMeasure(paires, "lift", transactions = paniers)
inspect(head(sort(paires, by = "lift"), 8))# Packs promotionnels : Eclat en Python
import pandas as pd
tickets = pd.read_csv("tickets_caisse.csv")
n_tickets = tickets["id_ticket"].nunique()
support_min = 0.03 * n_tickets # au moins 3 % des tickets, soit 120
# Format vertical : pour chaque produit, l'ensemble des tickets qui le contiennent
listes = tickets.groupby("produit")["id_ticket"].apply(set)
candidats = sorted((p, t) for p, t in listes.items() if len(t) >= support_min)
def eclat(prefixe, candidats, resultats):
for i, (produit, tick) in enumerate(candidats):
motif = prefixe + [produit]
resultats.append((motif, len(tick)))
# Croiser les listes : l'intersection donne directement le support du motif agrandi
suite = [(q, tick & t) for q, t in candidats[i + 1:] if len(tick & t) >= support_min]
eclat(motif, suite, resultats)
resultats = []
eclat([], candidats, resultats)
print(len(resultats), "combinaisons fréquentes")
# Paires : lift = tickets observés / tickets attendus si les achats étaient indépendants
freq = listes.apply(len) / n_tickets
paires = pd.DataFrame([(" + ".join(m), n, n / n_tickets / freq[m].prod()) for m, n in resultats if len(m) == 2],
columns=["paire", "tickets", "lift"])
print(paires.sort_values("lift", ascending=False).head(8).round(2).to_string(index=False))Eclat signifie Equivalence CLAss Transformation. Les combinaisons qui partagent le même préfixe forment une classe d'équivalence, traitée indépendamment des autres. C'est ce qui permet d'explorer les combinaisons en profondeur et de paralléliser le calcul.
Apriori stocke les données ticket par ticket et les relit pour compter chaque niveau de combinaisons. Eclat stocke, pour chaque produit, la liste de ses tickets et obtient le support par intersection. Les combinaisons trouvées sont les mêmes, Eclat est généralement plus rapide.
Pas directement : il sort des combinaisons fréquentes avec leur support. On calcule ensuite les règles et leur confiance à partir de ces supports, par exemple avec ruleInduction() dans le package R arules.
Relit les tickets à chaque niveau pour compter les candidats. Plus lent, mais produit directement des règles avec confiance.
Voir la fiche → l'alternative par arbreCompresse les tickets dans un arbre. Plus économe en mémoire quand les produits fréquents sont nombreux.
Voir la fiche → quand l'ordre compteCherche les enchaînements d'achats ou de pages dans le temps, et non les produits d'un même panier.
Voir la fiche →Dataistudio forme les équipes au machine learning et à l'IA, sur des cas concrets.
Nous utilisons des cookies de mesure d'audience et de suivi publicitaire pour comprendre la fréquentation du site et l'efficacité de nos annonces. Rien n'est déposé sans votre accord. En savoir plus