Merge pull request #402 from saitiger/Apriori

Pushed solution for Apriori

Author: moe18

Problems/Apriori/Learn.md

@@ -0,0 +1,43 @@
+The **Apriori algorithm** is a method for **association rule mining**, used to discover frequent itemsets. 
+It follows a **"bottom-up" approach**, iteratively finding patterns by leveraging the 
+**anti-monotonicity principle**: *"If an itemset is infrequent, all its supersets must also be infrequent."*  
+
+## Algorithm Steps
+1. **Generate** candidate itemsets of size k
+2. **Count** occurrences in transactions (support)
+3. **Filter** by minimum support threshold
+4. **Repeat** for k+1 until no more frequent itemsets
+
+## Example Calculation
+
+### Input Data
+| Transaction | Items                      |
+|-------------|----------------------------|
+| 1           | Bread, Milk                |
+| 2           | Bread, Diaper, Beer        |
+| 3           | Milk, Diaper, Beer         |
+| 4           | Bread, Milk, Diaper        |
+| 5           | Bread, Milk, Cola          |
+
+### Parameters
+- `min_support = 0.6` (must appear in ≥3/5 transactions)
+
+### Step 1: Find Frequent 1-itemsets
+| Itemset | Count | Support | Frequent? |
+|---------|-------|---------|-----------|
+| Bread   | 4     | 4/5     | Yes       |
+| Milk    | 4     | 4/5     | Yes       |
+| Diaper  | 3     | 3/5     | Yes       |
+| Beer    | 2     | 2/5     | No        |
+| Cola    | 1     | 1/5     | No        |
+
+### Step 2: Generate and Test 2-itemsets
+| Itemset        | Count | Support | Frequent? |
+|----------------|-------|---------|-----------|
+| Bread, Milk    | 3     | 3/5     | Yes       |
+| Bread, Diaper  | 2     | 2/5     | No        |
+| Milk, Diaper   | 2     | 2/5     | No        |
+
+### Final Frequent Itemsets
+- **1-itemsets**: Bread, Milk, Diaper
+- **2-itemsets**: {Bread, Milk}

Problems/Apriori/solution.py

@@ -0,0 +1,135 @@
+import itertools
+from collections import defaultdict
+
+def apriori(transactions, min_support=0.5, max_length=None):
+    """
+    Min Support : Minimum frequency threshold for an itemset to be considered frequent
+    Max Length : Limits the maximum size of the frequent itemsets
+    """
+    if not transactions:
+        raise ValueError("Transaction list cannot be empty")
+    if not 0 < min_support <= 1:
+        raise ValueError("Minimum support must be between 0 and 1")
+    
+    num_transactions = len(transactions)
+    min_support_count = min_support * num_transactions
+    
+    item_counts = defaultdict(int)
+    for transaction in transactions:
+        for item in transaction:
+            item_counts[frozenset([item])] += 1
+    
+    frequent_itemsets = {itemset: count for itemset, count in item_counts.items() 
+                         if count >= min_support_count}
+    
+    k = 1  # Current itemset size
+    all_frequent_itemsets = dict(frequent_itemsets)
+    
+    while frequent_itemsets and (max_length is None or k < max_length):
+        k += 1
+        candidates = generate_candidates(frequent_itemsets.keys(), k)
+        
+        candidate_counts = defaultdict(int)
+        for transaction in transactions:
+            transaction_set = frozenset(transaction)
+            for candidate in candidates:
+                if candidate.issubset(transaction_set):
+                    candidate_counts[candidate] += 1
+        
+        frequent_itemsets = {itemset: count for itemset, count in candidate_counts.items()
+                            if count >= min_support_count}
+        
+        all_frequent_itemsets.update(frequent_itemsets)
+    
+    return {itemset: count / num_transactions for itemset, count in all_frequent_itemsets.items()}
+
+def generate_candidates(prev_frequent_itemsets, k):
+    candidates = set()
+    prev_frequent_list = sorted(list(prev_frequent_itemsets), key=lambda x: sorted(x))
+    
+    for i in range(len(prev_frequent_list)):
+        for j in range(i + 1, len(prev_frequent_list)):
+            itemset1 = prev_frequent_list[i]
+            itemset2 = prev_frequent_list[j]
+            
+            if k > 2:
+                if sorted(itemset1)[:-1] != sorted(itemset2)[:-1]:
+                    continue
+            
+            new_candidate = itemset1 | itemset2
+            if len(new_candidate) == k:
+                candidates.add(new_candidate)
+    
+    return candidates
+
+def test_apriori():
+    transactions1 = [{'bread', 'milk'}, 
+                     {'bread', 'diaper', 'beer', 'eggs'}, 
+                     {'milk', 'diaper', 'beer', 'cola'}, 
+                     {'bread', 'milk', 'diaper', 'beer'}, 
+                     {'bread', 'milk', 'diaper', 'cola'}]
+    
+    result1 = apriori(transactions1, min_support=0.6)
+    expected1 = {
+        frozenset({'bread'}): 0.8,
+        frozenset({'milk'}): 0.8,
+        frozenset({'diaper'}): 0.8,
+        frozenset({'bread', 'milk'}): 0.6,
+        frozenset({'milk', 'diaper'}): 0.6,
+        frozenset({'bread', 'diaper'}): 0.6
+    }
+    assert set(result1.keys()) == set(expected1.keys()), "Test Case 1 Failed"
+    assert all(abs(result1[k] - expected1[k]) < 0.001 for k in expected1), "Test Case 1 Failed"
+
+    transactions2 = [{'a', 'b'}, {'c', 'd'}, {'e', 'f'}, {'g', 'h'}]
+    result2 = apriori(transactions2, min_support=0.5)
+    expected2 = {}  # No itemset appears in at least 2 transactions
+    assert set(result2.keys()) == set(expected2.keys()), "Test Case 2 Failed"
+
+    transactions3 = [{'a', 'b', 'c', 'd'}, {'a', 'b', 'c', 'd'}, {'a', 'b', 'c', 'd'}]
+    result3 = apriori(transactions3, min_support=0.5, max_length=2)
+    expected3 = {
+        frozenset({'a'}): 1.0,
+        frozenset({'b'}): 1.0,
+        frozenset({'c'}): 1.0,
+        frozenset({'d'}): 1.0,
+        frozenset({'a', 'b'}): 1.0,
+        frozenset({'a', 'c'}): 1.0,
+        frozenset({'a', 'd'}): 1.0,
+        frozenset({'b', 'c'}): 1.0,
+        frozenset({'b', 'd'}): 1.0,
+        frozenset({'c', 'd'}): 1.0
+    }
+    assert set(result3.keys()) == set(expected3.keys()), "Test Case 3 Failed"
+    
+    try:
+        apriori([], min_support=0.5)
+        assert False, "Test Case 4 Failed: Should raise ValueError"
+    except ValueError:
+        pass
+
+    transactions5 = [
+        {'apple', 'banana', 'orange'},
+        {'apple', 'banana', 'grape'},
+        {'apple', 'orange', 'grape'},
+        {'banana', 'orange', 'grape'},
+        {'apple', 'banana', 'orange', 'grape'}
+    ]
+    result5 = apriori(transactions5, min_support=0.6)
+    expected5 = {
+        frozenset({'apple'}): 0.8,
+        frozenset({'banana'}): 0.8,
+        frozenset({'orange'}): 0.8,
+        frozenset({'grape'}): 0.8,
+        frozenset({'apple', 'banana'}): 0.6,
+        frozenset({'apple', 'orange'}): 0.6,
+        frozenset({'apple', 'grape'}): 0.6,
+        frozenset({'banana', 'orange'}): 0.6,
+        frozenset({'banana', 'grape'}): 0.6,
+        frozenset({'orange', 'grape'}): 0.6
+    }
+    assert set(result5.keys()) == set(expected5.keys()), "Test Case 5 Failed"
+
+if __name__ == "__main__":
+    test_apriori()
+    print("All Test Cases Passed!")