BP231021 | SandeeP R

II MCa
ELECTIVE V : DATA MINING TECHNIQUES
UNIT 2 - ASSOCIATION RULES

Problem solving based Association Rule Algorithms

Use any transaction dataset, and apply
i. Frequent set algorithm
ii. Apriori algorithm
iii. Partition Algorithm
iv. Pincer Search
v. Dynamic Itemset Counting
Generate association rules.
Record your inference about one algorithm over the other.
According to you, which algorithm do you consider to be efficient for the dataset you have
chosen.

1. FREQUENT SET ALGORITHM

from itertools import combinations

from collections import defaultdict
def generate_candidates(itemsets, k):
"""Generate candidate itemsets of size k."""
return set(
[frozenset(a.union(b)) for a in itemsets for b in itemsets if len(a.union(b)) == k]
)
def calculate_support(transactions, candidates):
"""Calculate the support count for candidate itemsets."""
support_count = defaultdict(int)
for transaction in transactions:
for candidate in candidates:
if candidate.issubset(transaction):
support_count[candidate] +=
return support_count
def frequent_set_algorithm(transactions, min_support):
"""Frequent Set Algorithm to find all frequent itemsets."""
 # Initialize variables
frequent_itemsets = {} # Dictionary to store itemsets with their support
k = 1 # Start with itemsets of size 1
current_itemsets = set(frozenset([item]) for transaction in transactions for item in
transaction)
while current_itemsets:
# Calculate support for the current itemsets
support_count = calculate_support(transactions, current_itemsets)
# Filter itemsets that meet the minimum support
current_frequent = {
itemset: count
for itemset, count in support_count.items()
if count >= min_support
}
# Add the frequent itemsets to the result
frequent_itemsets.update(current_frequent)
# Generate candidates for the next iteration (itemsets of size k+1)
k += 1
current_itemsets = generate_candidates(set(current_frequent.keys()), k)

return frequent_itemsets

# Example usage
if __name__ == "__main__":
# Example transactions
transactions = [
{"milk", "bread", "butter"},
{"beer", "bread", "butter"},
{"milk", "beer", "bread"},
{"milk", "bread", "butter", "beer"},
]

# Minimum support threshold

 min_support = 2

# Run the Frequent Set Algorithm

frequent_itemsets = frequent_set_algorithm(transactions, min_support)

# Print the results

print("Frequent Itemsets:")
for itemset, support in frequent_itemsets.items():
print(f"{set(itemset)}: {support}")

OUTPUT :

Frequent Itemsets:
{'butter'}: 3
{'milk'}: 3
{'bread'}: 4
{'beer'}: 3
{'butter', 'bread'}: 3
{'milk', 'butter'}: 2
{'milk', 'bread'}: 3
{'beer', 'butter'}: 2
{'beer', 'bread'}: 3
{'milk', 'beer'}: 2
{'milk', 'butter', 'bread'}: 2
{'beer', 'butter', 'bread'}: 2
{'milk', 'beer', 'bread'}: 2
 2. APRIORI ALGORITHM

from itertools import combinations

def generate_candidates(itemsets, k):

"""Generate candidate itemsets of size k."""
return set(
[frozenset(a.union(b)) for a in itemsets for b in itemsets if len(a.union(b)) == k]
)

def calculate_support(transactions, candidates):

"""Calculate support count for candidate itemsets."""
support_count = {itemset: 0 for itemset in candidates}
for transaction in transactions:
for candidate in candidates:
if candidate.issubset(transaction):
support_count[candidate] += 1
return support_count

def apriori(transactions, min_support):

"""Apriori Algorithm to find frequent itemsets."""
# Initialize variables
frequent_itemsets = {} # Store frequent itemsets with their support
k = 1 # Start with 1-itemsets
current_itemsets = set(frozenset([item]) for transaction in transactions for item in
transaction)

while current_itemsets:
# Calculate support for the current itemsets
support_count = calculate_support(transactions, current_itemsets)

# Filter itemsets based on the minimum support threshold

current_frequent = {
 itemset: count
for itemset, count in support_count.items()
if count >= min_support
}

# Add the frequent itemsets to the result

frequent_itemsets.update(current_frequent)

# Generate candidates for the next iteration (itemsets of size k+1)

k += 1
current_itemsets = generate_candidates(set(current_frequent.keys()), k)

return frequent_itemsets

# Example usage
if __name__ == "__main__":
# Example transactions
transactions = [
{"milk", "bread", "butter"},
{"beer", "bread", "butter"},
{"milk", "beer", "bread"},
{"milk", "bread", "butter", "beer"},
]

# Minimum support threshold

min_support = 2

# Run the Apriori Algorithm

frequent_itemsets = apriori(transactions, min_support)

# Print the results

print("Frequent Itemsets:")
for itemset, support in frequent_itemsets.items():
print(f"{set(itemset)}: {support}")
OUTPUT :

Frequent Itemsets:
{'butter'}: 3
{'beer'}: 3
{'milk'}: 3
{'bread'}: 4
{'beer', 'butter'}: 2
{'butter', 'bread'}: 3
{'milk', 'beer'}: 2
{'beer', 'bread'}: 3
{'milk', 'butter'}: 2
{'milk', 'bread'}: 3
{'beer', 'butter', 'bread'}: 2
{'milk', 'beer', 'bread'}: 2
{'milk', 'butter', 'bread'}: 2
 3. PARTITION ALGORITHM

from itertools import combinations

from collections import defaultdict

# Helper function to generate candidate itemsets

def generate_candidates(itemsets, k):
return set(
[frozenset(a.union(b)) for a in itemsets for b in itemsets if len(a.union(b)) == k]
)

# Helper function to calculate support for itemsets in a partition

def calculate_support(transactions, candidates):
support_count = defaultdict(int)
for transaction in transactions:
for candidate in candidates:
if candidate.issubset(transaction):
support_count[candidate] += 1
return support_count

# Partition Algorithm implementation

def partition_algorithm(transactions, n_partitions, min_support):
# Phase I: Divide the transactions into n partitions
partition_size = len(transactions) // n_partitions
partitions = [
transactions[i * partition_size:(i + 1) * partition_size]
for i in range(n_partitions)
]
if len(transactions) % n_partitions != 0:
partitions[-1].extend(transactions[n_partitions * partition_size :]) # Handle leftover

# Phase I: Generate local frequent itemsets for each partition

local_frequent_itemsets = []
 for partition in partitions:
k=1
current_itemsets = set(frozenset([item]) for transaction in partition for item in
transaction)
partition_frequent = {}
while current_itemsets:
support_count = calculate_support(partition, current_itemsets)
frequent_itemsets = {
itemset: count
for itemset, count in support_count.items()
if count >= min_support
}
if not frequent_itemsets:
break
partition_frequent.update(frequent_itemsets)
k += 1
current_itemsets = generate_candidates(set(frequent_itemsets.keys()), k)
local_frequent_itemsets.append(partition_frequent)

# Merge Phase: Combine local frequent itemsets across partitions

global_candidates = defaultdict(int)
for partition_frequent in local_frequent_itemsets:
for itemset, count in partition_frequent.items():
global_candidates[itemset] += count

# Phase II: Validate global candidates with the entire dataset

final_support_count = calculate_support(transactions, set(global_candidates.keys()))
final_frequent_itemsets = {
itemset: count
for itemset, count in final_support_count.items()
if count >= min_support
}

return final_frequent_itemsets
# Example usage
if __name__ == "__main__":
# Example transactions
transactions = [
{"milk", "bread", "butter"},
{"beer", "bread", "butter"},
{"milk", "beer", "bread"},
{"milk", "bread", "butter", "beer"},
]

# Number of partitions
n_partitions = 2

# Minimum support threshold

min_support = 2

# Run the Partition Algorithm

frequent_itemsets = partition_algorithm(transactions, n_partitions, min_support)

# Print the results

print("Frequent Itemsets:", frequent_itemsets)

OUTPUT :

Frequent Itemsets: {frozenset({'butter', 'bread'}): 3, frozenset({'butter'}): 3,

frozenset({'milk'}): 3, frozenset({'bread'}): 4, frozenset({'milk', 'bread'}): 3,
frozenset({'beer', 'bread'}): 3, frozenset({'beer'}): 3, frozenset({'milk', 'beer', 'bread'}): 2,
frozenset({'milk', 'beer'}): 2}
 4. PINCER SEARCH ALGORITHM

from itertools import combinations

from collections import defaultdict

def generate_candidates(itemsets, k):

"""Generate candidate itemsets of size k."""
return set(
[frozenset(a.union(b)) for a in itemsets for b in itemsets if len(a.union(b)) == k]
)

def calculate_support(transactions, candidates):

"""Calculate the support of candidates in the transactions."""
support_count = defaultdict(int)
for transaction in transactions:
for candidate in candidates:
if candidate.issubset(transaction):
support_count[candidate] += 1
return support_count

def pincer_search(transactions, min_support):

"""Pincer-Search Algorithm implementation."""
# Initialize variables
frequent_itemsets = {} # Store frequent itemsets with their support
infrequent_itemsets = set() # Store infrequent itemsets
global_support = {} # Keep track of support for all itemsets

# Generate initial 1-item candidates

k=1
current_itemsets = set(frozenset([item]) for transaction in transactions for item in
transaction)

while current_itemsets:
 # Calculate support for current candidates
support_count = calculate_support(transactions, current_itemsets)
global_support.update(support_count)

# Split into frequent and infrequent itemsets

current_frequent = {
itemset: count
for itemset, count in support_count.items()
if count >= min_support
}
frequent_itemsets.update(current_frequent)
infrequent_itemsets.update(
itemset for itemset, count in support_count.items() if count < min_support
)

# Check for termination: if no frequent itemsets, stop

if not current_frequent:
break

# Generate next candidates using frequent itemsets

k += 1
current_itemsets = generate_candidates(set(current_frequent.keys()), k)

# Prune candidates containing infrequent subsets

current_itemsets = {
candidate
for candidate in current_itemsets
if not any(subset in infrequent_itemsets for subset in combinations(candidate, k - 1))
}

return frequent_itemsets

# Example usage
if __name__ == "__main__":
 # Example transactions
transactions = [
{"milk", "bread", "butter"},
{"beer", "bread", "butter"},
{"milk", "beer", "bread"},
{"milk", "bread", "butter", "beer"},
]

# Minimum support threshold

min_support = 2

# Run the Pincer-Search Algorithm

frequent_itemsets = pincer_search(transactions, min_support)

# Print the results

print("Frequent Itemsets:")
for itemset, support in frequent_itemsets.items():
print(f"{set(itemset)}: {support}")

OUTPUT :

Frequent Itemsets:
{'butter'}: 3
{'milk'}: 3
{'bread'}: 4
{'beer'}: 3
{'butter', 'bread'}: 3
{'milk', 'butter'}: 2
{'milk', 'bread'}: 3
{'beer', 'butter'}: 2
{'beer', 'bread'}: 3
{'milk', 'beer'}: 2
{'milk', 'butter', 'bread'}: 2
{'beer', 'butter', 'bread'}: 2
{'milk', 'beer', 'bread'}:
5. DYNAMIC ITEMSET COUNTING

from itertools import combinations

def calculate_support(transactions, candidates):

"""Calculate the support count for a set of candidate itemsets."""
support_count = {itemset: 0 for itemset in candidates}
for transaction in transactions:
for candidate in candidates:
if candidate.issubset(transaction):
support_count[candidate] += 1
return support_count

def dic_algorithm(transactions, min_support):

"""Dynamic Itemset Counting (DIC) Algorithm."""
# Initialize variables
frequent_itemsets = {} # Store frequent itemsets with their support
k = 1 # Current size of itemsets
active_candidates = set(frozenset([item]) for transaction in transactions for item in
transaction)
inactive_candidates = set() # Itemsets to be activated later

while active_candidates:
# Calculate support for active candidates
support_count = calculate_support(transactions, active_candidates)

# Filter frequent itemsets from active candidates

current_frequent = {
itemset: count
for itemset, count in support_count.items()
if count >= min_support
}
 # Add the frequent itemsets to the results
frequent_itemsets.update(current_frequent)

# Move non-frequent active candidates to inactive

inactive_candidates.update(
itemset for itemset, count in support_count.items() if count < min_support
)

# Generate new candidates to activate dynamically

new_candidates = set()
for itemset in current_frequent:
for other in frequent_itemsets.keys():
if len(itemset.union(other)) == k + 1:
new_candidate = itemset.union(other)
if all(frozenset(subset) in frequent_itemsets for subset in
combinations(new_candidate, k)):
new_candidates.add(new_candidate)

# Activate new candidates

active_candidates = new_candidates
k += 1

return frequent_itemsets

# Example usage
if __name__ == "__main__":
# Example transactions
transactions = [
{"milk", "bread", "butter"},
{"beer", "bread", "butter"},
{"milk", "beer", "bread"},
{"milk", "bread", "butter", "beer"},
]
 # Minimum support threshold
min_support = 2

# Run the DIC Algorithm

frequent_itemsets = dic_algorithm(transactions, min_support)

# Print the results

print("Frequent Itemsets:")
for itemset, support in frequent_itemsets.items():
print(f"{set(itemset)}: {support}")

OUTPUT :
Frequent Itemsets:
{'butter'}: 3
{'beer'}: 3
{'milk'}: 3
{'bread'}: 4
{'butter', 'bread'}: 3
{'beer', 'butter'}: 2
{'beer', 'bread'}: 3
{'milk', 'butter'}: 2
{'milk', 'beer'}: 2
{'milk', 'bread'}: 3
{'beer', 'butter', 'bread'}: 2
{'milk', 'beer', 'bread'}: 2
{'milk', 'butter', 'bread'}: 2