Discovering Association Rules Mining in R for Market Basket Analysis

You’ve probably heard the urban legend about the retail store that discovered, through data analysis, that men who bought diapers on a Friday night were also highly likely to buy beer. While the story’s accuracy is debated, the technique behind such a discovery is very real and incredibly powerful. It’s called Market Basket Analysis, and the algorithm that does the heavy lifting is known as Association Rule Mining. At its core, this is a method for finding hidden patterns and interesting relationships in large datasets.

Imagine you’re running an e-commerce site. Wouldn’t you love to know that customers who buy a specific laptop are also 70% likely to buy a particular wireless mouse? You could bundle them, create a “you might also like” recommendation, or even run a targeted ad. This is what association rules do. They are an unsupervised, non-linear algorithm-which is a fancy way of saying they don’t need pre-labeled data (unsupervised) and can find complex connections (non-linear) that simple correlation can’t. This post will explore what these rules are, how they are measured, and how you can start finding them yourself using the R programming language.

What exactly is an association rule? 🔗

An association rule is a simple “If-Then” statement. In data mining, we write this as {A} => {B}. This means that if item A is found in a transaction, it is likely that item B will also be found in that same transaction.

Let’s break down the two parts of the rule:

• Antecedent (the ‘If’): This is the item or set of items found in the basket. In our example, {A} is the antecedent. This could be {Diapers}.
• Consequent (the ‘Then’): This is the item or set of items that is frequently found *with* the antecedent. Here, {B} is the consequent. This would be {Beer}.

A rule can be more complex, like {Bread, Peanut Butter} => {Jelly}. Here, {Bread, Peanut Butter} is the antecedent, and {Jelly} is the consequent. The goal of association rule mining is to sift through millions of transactions to find the rules that are both frequent and reliable. But how do we measure “frequent” or “reliable”? We use three key metrics: Support, Confidence, and Lift.

The three pillars: How we measure a ‘good’ rule 🔗

Not all rules are created equal. Some are obvious, some are rare, and some are just plain misleading. To separate the gold from the gravel, we use three mathematical pillars to evaluate the strength and interest-level of each potential rule. Understanding these is the most important part of the entire process.

Support: How popular is the itemset? 🔗

Support is the most basic metric. It tells you the popularity of an itemset by measuring what fraction of *all* transactions contain that itemset. An “itemset” can be a single item like {Milk} or a combination like {Milk, Bread}.

The formula is simple: Support(A) = (Number of transactions containing A) / (Total number of transactions)

Example: If we have 1,000 total transactions in our store, and 100 of them contain {Bread, Milk}, the support for this itemset is:

Support({Bread, Milk}) = 100 / 1,000 = 0.1 (or 10%)

Support is used as a first-pass filter. If we set a “minimum support” threshold, we are telling the algorithm to ignore item combinations that are incredibly rare. Why? Because a rule based on two transactions out of a million is probably just random noise, not a stable pattern you can base a business strategy on.

Confidence: How likely is the ‘then’ part? 🔗

Confidence measures the reliability of the rule. It answers the question: “When a customer *already has* the antecedent (A) in their basket, what is the probability they *also* have the consequent (B)?”

The formula is: Confidence(A => B) = (Transactions containing both A and B) / (Transactions containing A)

Example: Let’s use our 1,000 transactions again.

• 100 transactions contain both {Bread, Milk}.
• 150 transactions contain {Bread} (with or without milk).

The confidence of the rule {Bread} => {Milk} would be: Confidence = 100 / 150 = 0.67 (or 67%)

This sounds great! It means 67% of people who buy bread also buy milk. This seems like an actionable rule. But there’s a trap. What if 80% of *all* customers who walk into your store buy milk, regardless of what else is in their basket? In that case, a 67% chance is actually *less* than average. This rule is misleading. This is why we need our third, and most important, metric.

Lift: How much better is the rule than random chance? 🔗

Lift is the true measure of a rule’s power. It tells you how much *more* likely a customer is to buy the consequent (B) when they have the antecedent (A), compared to just the normal popularity of B. It measures the degree of association by controlling for the baseline popularity of both items.

The formula is: Lift(A => B) = Confidence(A => B) / Support(B)

Let’s unpack this with our example:

• We know Confidence({Bread} => {Milk}) is 0.67.
• We need Support({Milk}). Let’s say 800 of our 1,000 transactions contain milk. So, Support({Milk}) = 800 / 1,000 = 0.8.

Now, let’s calculate the lift: Lift = 0.67 / 0.8 = 0.84

How do we interpret this?

• Lift = 1: The antecedent and consequent are perfectly independent. Buying bread has no effect whatsoever on buying milk. The rule is useless.
• Lift < 1 (like our 0.84): The items are *negatively* associated. This means customers who buy bread are *less* likely than average to buy milk. They might be substitutes.
• Lift > 1: The items are *positively* associated. This is what we’re looking for! A lift of 2.5 would mean that buying A makes a customer 2.5 times more likely to buy B.

Our rule with a lift of 0.84 is not just unhelpful; it’s actively misleading. We discovered that bread and milk are actually *substitutes* or just unrelated, despite the high confidence. Lift is the metric that finds the truly hidden, non-obvious patterns.

Finding the rules with the Apriori algorithm 🔗

So how does a computer sift through millions of transactions and billions of potential item combinations? Checking every single one would be impossible. The most popular method is the Apriori algorithm.

Apriori works on a simple principle: “If an itemset is frequent, then all of its subsets must also be frequent.” This allows it to “prune” the search tree dramatically.

Think of it like sifting for gold with screens of decreasing size:

1. Pass 1: The algorithm scans all transactions and finds the support for every *single item*. It throws away all items that don’t meet our minimum support threshold. (e.g., if “caviar” only appeared twice, it’s discarded).
2. Pass 2: It combines *only* the frequent items from Pass 1 into pairs (e.g., {Bread, Milk}). It then scans the data again to find the support for these pairs, discarding all pairs that are too rare.
3. Pass 3: It combines the frequent *pairs* into triplets (e.g., {Bread, Milk, Diapers}) and checks their support.

It continues this “bottom-up” process until it has a list of all *frequent itemsets*. Only then does it go through this list and generate rules (like {Bread, Milk} => {Diapers}) and calculate their confidence and lift.

Let’s get practical: Mining rules in R 🔗

This is all great in theory, but let’s see how it works in practice. The R programming language is fantastic for data analysis and has a powerful package specifically for this task.

Step 1: Installing your tools 🔗

First, you need to install two key packages. The arules package contains the Apriori algorithm and data structures, and arulesViz is a companion package for visualizing the rules you find.

install.packages("arules") install.packages("arulesViz")

Once installed, you need to load them into your R session:

library(arules) library(arulesViz)

Step 2: Loading the data 🔗

The arules package conveniently comes with a built-in dataset called Groceries. This is a perfect dataset for learning as it contains 9,835 transactions from a real grocery store over a 30-day period. It is stored in a special ‘transactions’ format, which is basically a list of items for each transaction.

Let’s load and inspect it:

# Load the dataset data("Groceries") # Look at its structure summary(Groceries) # Look at the first 5 transactions inspect(head(Groceries, 5))

The summary() will tell you it’s a transactions object with 9,835 rows (transactions) and 169 columns (unique items). The inspect() command will show you the items in the first five baskets, e.g.:

 items 1 {citrus fruit, semi-finished bread, margarine, ready soups} 2 {tropical fruit, yogurt, coffee} 3 {whole milk} 4 {pip fruit, yogurt, cream cheese, meat spreads} 5 {other vegetables, whole milk, condensed milk, long life bakery product}

Step 3: Running the Apriori algorithm 🔗

Now for the main event. We use the apriori() function. The most important part is the parameter argument, where we set our minimum thresholds for support and confidence. We can also set a minlen to avoid simple rules.

Setting these thresholds is an art. If support is too high, we’ll only find obvious rules (like {Milk} => {Bread}). If it’s too low, we’ll be flooded with thousands of rare rules. Let’s start with a low support (0.001, or about 10 transactions) and a modest confidence (0.25).

# Run the Apriori algorithm rules <- apriori(Groceries, parameter = list(support = 0.001, confidence = 0.25, minlen = 2)) # See how many rules we found summary(rules)

This will output a summary, telling you it generated a set of rules (e.g., "set of 463 rules").

Step 4: Inspecting and understanding the rules 🔗

We have 463 rules, but which ones are *good*? We need to sort them. The best way to find interesting patterns is to sort by lift.

# Sort the rules by lift in descending order rules_sorted <- sort(rules, by = "lift", decreasing = TRUE) # Inspect the top 10 rules inspect(head(rules_sorted, 10))

Now you'll see a list of the most "interesting" rules in your dataset. The output will look something like this (Note: your exact rules may vary slightly):

 lhs rhs support confidence lift [1] {citrus fruit, root vegetables} => {other vegetables} 0.00305033 0.4615385 2.384711 [2] {tropical fruit, root vegetables} => {other vegetables} 0.00366039 0.4444444 2.296472 [3] {beef, root vegetables} => {other vegetables} 0.00264361 0.4193548 2.166880 ...

Let's interpret that first rule:

• Rule: {citrus fruit, root vegetables} => {other vegetables}
• Support (0.003): This combination appears in about 0.3% of all baskets (around 30 transactions). It's not common, but it's not a one-off.
• Confidence (0.46): 46% of customers who bought *both* citrus fruit and root vegetables *also* bought other vegetables.
• Lift (2.38): This is the key. This combination is 2.38 times *more likely* to occur than by random chance. This is a strong, actionable insight!

This rule suggests a "healthy-eater" or "home-cook" persona. As a store manager, you could now create a "Fresh Produce" bundle, place these items near each other, or send a coupon for "other vegetables" to anyone who buys citrus and root veggies.

Association rule mining is a foundational technique in data science for a reason. It's a relatively simple and transparent way to move beyond simple averages and find the hidden connections that drive real-world behavior. The tools in R make this power accessible to anyone willing to explore their data. The real skill, however, lies not just in running the code, but in interpreting the metrics and turning a rule into a smart business decision.

What do you think? What other industries, besides retail or e-commerce, could benefit from discovering hidden association rules? If you found a rule with very high support and confidence, but a lift of just 1.01, would you consider it an important rule? Why or why not?

References

1. https://towardsdatascience.com/association-rules-2-key-concepts-support-confidence-and-lift-90403198d0c
2. https://en.wikipedia.org/wiki/Apriori_algorithm
3. https://cran.r-project.org/web/packages/arules/vignettes/arules.pdf
4. https://www.datacamp.com/community/tutorials/association-rule-mining-r