eclat changes

Author: jideoyelayo1

examples/EclatExample.cpp

@@ -22,26 +22,23 @@ void testEclat() {
     Eclat eclat(min_support);
 
     // Run Eclat algorithm
-    std::vector<std::set<int>> frequent_itemsets = eclat.run(transactions);
+    std::vector<std::vector<int>> frequent_itemsets = eclat.run(transactions);
 
     // Get support counts
     auto support_counts = eclat.get_support_counts();
 
     // Display frequent itemsets and their support counts
     std::cout << "Frequent Itemsets:\n";
     for (const auto& itemset : frequent_itemsets) {
-        std::string itemset_str;
+        std::cout << "Itemset: { ";
         for (int item : itemset) {
-            itemset_str += std::to_string(item) + " ";
+            std::cout << item << " ";
         }
-        std::string key = eclat.itemset_to_string(itemset);
-        int support = support_counts[key];
-        std::cout << "Itemset: {" << itemset_str << "} - Support: " << support << "\n";
+        std::cout << "} - Support: " << support_counts.at(itemset) << "\n";
     }
-
 }
 
-int main(){
+int main() {
     testEclat();
     return 0;
-}
+}

ml_library_include/ml/association/Eclat.hpp

@@ -1,19 +1,17 @@
 #ifndef ECLAT_HPP
 #define ECLAT_HPP
 
-#include <unordered_map>
-#include <unordered_set>
+#include <map>
 #include <vector>
-#include <set>
 #include <algorithm>
-#include <functional>
 #include <iostream>
 #include <string>
 #include <cmath>
+#include <stdexcept>
 
 /**
  * @file Eclat.hpp
- * @brief Implementation of the Eclat algorithm for frequent itemset mining.
+ * @brief Optimized Implementation of the Eclat algorithm for frequent itemset mining.
  */
 
 /**
@@ -31,38 +29,31 @@ class Eclat {
     /**
      * @brief Runs the Eclat algorithm on the provided dataset.
      * @param transactions A vector of transactions, each transaction is a vector of items.
-     * @return A vector of frequent itemsets, where each itemset is represented as a set of items.
+     * @return A vector of frequent itemsets, where each itemset is represented as a vector of items.
      */
-    std::vector<std::set<int>> run(const std::vector<std::vector<int>>& transactions);
+    std::vector<std::vector<int>> run(const std::vector<std::vector<int>>& transactions);
 
     /**
      * @brief Gets the support counts for all frequent itemsets found.
-     * @return An unordered_map where keys are itemsets (as strings) and values are support counts.
+     * @return A map where keys are itemsets (as vectors) and values are support counts.
      */
-    std::unordered_map<std::string, int> get_support_counts() const;
-    /**
-     * @brief Converts an itemset to a string representation for use as a key.
-     * @param itemset The itemset to convert.
-     * @return A string representation of the itemset.
-     */
-    std::string itemset_to_string(const std::set<int>& itemset) const;
+    std::map<std::vector<int>, int> get_support_counts() const;
 
 private:
     /**
      * @brief Recursively mines frequent itemsets using the Eclat algorithm.
      * @param prefix The current itemset prefix.
      * @param items A vector of items to consider.
-     * @param tid_sets A map from items to their transaction ID sets.
+     * @param tid_sets A map from items to their transaction ID vectors.
      */
-    void eclat_recursive(const std::set<int>& prefix,
+    void eclat_recursive(const std::vector<int>& prefix,
                          const std::vector<int>& items,
-                         const std::unordered_map<int, std::unordered_set<int>>& tid_sets);
-
+                         const std::map<int, std::vector<int>>& tid_sets);
 
     double min_support; ///< Minimum support threshold.
     int min_support_count; ///< Minimum support count (absolute number of transactions).
     int total_transactions; ///< Total number of transactions.
-    std::unordered_map<std::string, int> support_counts; ///< Support counts for itemsets.
+    std::map<std::vector<int>, int> support_counts; ///< Support counts for itemsets.
 };
 
 Eclat::Eclat(double min_support)
@@ -72,18 +63,23 @@ Eclat::Eclat(double min_support)
     }
 }
 
-std::vector<std::set<int>> Eclat::run(const std::vector<std::vector<int>>& transactions) {
+std::vector<std::vector<int>> Eclat::run(const std::vector<std::vector<int>>& transactions) {
     total_transactions = static_cast<int>(transactions.size());
     min_support_count = static_cast<int>(std::ceil(min_support * total_transactions));
 
-    // Map each item to its TID set
-    std::unordered_map<int, std::unordered_set<int>> item_tidsets;
+    // Map each item to its TID vector
+    std::map<int, std::vector<int>> item_tidsets;
     for (int tid = 0; tid < total_transactions; ++tid) {
         for (int item : transactions[tid]) {
-            item_tidsets[item].insert(tid);
+            item_tidsets[item].push_back(tid);
         }
     }
 
+    // Sort TID vectors
+    for (auto& [item, tids] : item_tidsets) {
+        std::sort(tids.begin(), tids.end());
+    }
+
     // Filter items that meet the minimum support
     std::vector<int> frequent_items;
     for (const auto& [item, tidset] : item_tidsets) {
@@ -97,64 +93,51 @@ std::vector<std::set<int>> Eclat::run(const std::vector<std::vector<int>>& trans
 
     // Initialize support counts for single items
     for (int item : frequent_items) {
-        std::set<int> itemset = {item};
-        std::string itemset_str = itemset_to_string(itemset);
-        support_counts[itemset_str] = static_cast<int>(item_tidsets[item].size());
+        std::vector<int> itemset = {item};
+        support_counts[itemset] = static_cast<int>(item_tidsets[item].size());
     }
 
     // Start recursive mining
     eclat_recursive({}, frequent_items, item_tidsets);
 
     // Collect frequent itemsets from support counts
-    std::vector<std::set<int>> frequent_itemsets;
-    for (const auto& [itemset_str, count] : support_counts) {
+    std::vector<std::vector<int>> frequent_itemsets;
+    for (const auto& [itemset, count] : support_counts) {
         if (count >= min_support_count) {
-            // Convert string back to itemset
-            std::set<int> itemset;
-            size_t pos = 0;
-            std::string token;
-            std::string s = itemset_str;
-            while ((pos = s.find(',')) != std::string::npos) {
-                token = s.substr(0, pos);
-                itemset.insert(std::stoi(token));
-                s.erase(0, pos + 1);
-            }
-            itemset.insert(std::stoi(s));
             frequent_itemsets.push_back(itemset);
         }
     }
 
     return frequent_itemsets;
 }
 
-void Eclat::eclat_recursive(const std::set<int>& prefix,
+void Eclat::eclat_recursive(const std::vector<int>& prefix,
                             const std::vector<int>& items,
-                            const std::unordered_map<int, std::unordered_set<int>>& tid_sets) {
+                            const std::map<int, std::vector<int>>& tid_sets) {
     size_t n = items.size();
     for (size_t i = 0; i < n; ++i) {
         int item = items[i];
-        std::set<int> new_prefix = prefix;
-        new_prefix.insert(item);
-        std::string itemset_str = itemset_to_string(new_prefix);
+        std::vector<int> new_prefix = prefix;
+        new_prefix.push_back(item);
 
         // Update support counts
         int support = static_cast<int>(tid_sets.at(item).size());
-        support_counts[itemset_str] = support;
+        support_counts[new_prefix] = support;
 
         // Generate new combinations
         std::vector<int> remaining_items;
-        std::unordered_map<int, std::unordered_set<int>> new_tid_sets;
+        std::map<int, std::vector<int>> new_tid_sets;
 
         for (size_t j = i + 1; j < n; ++j) {
             int next_item = items[j];
 
             // Intersect TID sets
-            std::unordered_set<int> intersect_tid_set;
+            std::vector<int> intersect_tid_set;
             const auto& tid_set1 = tid_sets.at(item);
             const auto& tid_set2 = tid_sets.at(next_item);
             std::set_intersection(tid_set1.begin(), tid_set1.end(),
                                   tid_set2.begin(), tid_set2.end(),
-                                  std::inserter(intersect_tid_set, intersect_tid_set.begin()));
+                                  std::back_inserter(intersect_tid_set));
 
             if (static_cast<int>(intersect_tid_set.size()) >= min_support_count) {
                 remaining_items.push_back(next_item);
@@ -169,19 +152,8 @@ void Eclat::eclat_recursive(const std::set<int>& prefix,
     }
 }
 
-std::unordered_map<std::string, int> Eclat::get_support_counts() const {
+std::map<std::vector<int>, int> Eclat::get_support_counts() const {
     return support_counts;
 }
 
-std::string Eclat::itemset_to_string(const std::set<int>& itemset) const {
-    std::string s;
-    for (auto it = itemset.begin(); it != itemset.end(); ++it) {
-        s += std::to_string(*it);
-        if (std::next(it) != itemset.end()) {
-            s += ",";
-        }
-    }
-    return s;
-}
-
 #endif // ECLAT_HPP

tests/association/EclatTest.cpp

@@ -1,10 +1,8 @@
 #include "../../ml_library_include/ml/association/Eclat.hpp"
 #include <iostream>
 #include <vector>
-#include <set>
 #include <cassert>
 #include <string>
-#include "../TestUtils.hpp"
 
 int main() {
     // Sample dataset with transactions
@@ -27,13 +25,13 @@ int main() {
     Eclat eclat(min_support);
 
     // Run Eclat algorithm to obtain frequent itemsets
-    std::vector<std::set<int>> frequent_itemsets = eclat.run(transactions);
+    std::vector<std::vector<int>> frequent_itemsets = eclat.run(transactions);
 
     // Get support counts
     auto support_counts = eclat.get_support_counts();
 
     // Expected frequent itemsets for validation (sample expected output)
-    std::vector<std::set<int>> expected_frequent_itemsets = {
+    std::vector<std::vector<int>> expected_frequent_itemsets = {
         {1, 2}, {2, 3}, {1, 3}, {1, 2, 3}
         // Add other expected itemsets based on expected results for the given min_support
     };
@@ -47,16 +45,14 @@ int main() {
     // Display the results for verification
     std::cout << "Frequent Itemsets:\n";
     for (const auto& itemset : frequent_itemsets) {
-        std::string itemset_str;
+        std::cout << "Itemset: { ";
         for (int item : itemset) {
-            itemset_str += std::to_string(item) + " ";
+            std::cout << item << " ";
         }
-        std::string key = eclat.itemset_to_string(itemset);
-        int support = support_counts[key];
-        std::cout << "Itemset: {" << itemset_str << "} - Support: " << support << "\n";
+        std::cout << "} - Support: " << support_counts.at(itemset) << "\n";
 
         // Verify support is above the minimum support threshold
-        double support_ratio = static_cast<double>(support) / transactions.size();
+        double support_ratio = static_cast<double>(support_counts.at(itemset)) / transactions.size();
         assert(support_ratio >= min_support && "Frequent itemset does not meet minimum support threshold.");
     }