effspm 0.1.12__cp313-cp313-macosx_10_13_universal2.whl → 0.2.2__cp313-cp313-macosx_10_13_universal2.whl

effspm/__init__.py

@@ -1,3 +1,3 @@
-from ._effspm import PrefixProjection, BTMiner
-
-__all__ = ['PrefixProjection', 'BTMiner']
+# effspm/__init__.py
+from ._effspm import PrefixProjection, LargePrefixProjection, BTMiner ,LargeBTMiner,LargeHTMiner,HTMiner
+__all__ = ["PrefixProjection", "LargePrefixProjection", "BTMiner","LargeBTMiner","LargeHTMiner","HTMiner"]

effspm/_effspm.cpp

@@ -1,5 +1,10 @@
+// _effspm.cpp
+
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
+namespace py = pybind11;
+#include <iostream>
+
 
 // PrefixProjection headers
 #include "freq_miner.hpp"
@@ -12,12 +17,35 @@
 #include "btminer/src/utility.hpp"
 #include "btminer/src/build_mdd.hpp"
 
-namespace py = pybind11;
+// HTMiner (wrapped in its own namespace in source files)
+#include "htminer/src/build_mdd.hpp"    // ← ensure HTMiner MDD builder is available
+#include "htminer/src/freq_miner.hpp"
+#include "htminer/src/load_inst.hpp"
+#include "htminer/src/utility.hpp"
+
+
+#include "largepp/src/freq_miner.hpp"
+#include "largepp/src/load_inst.hpp"
+#include "largepp/src/utility.hpp"
+
+#include "largebm/src/freq_miner.hpp"
+#include "largebm/src/load_inst.hpp"
+#include "largebm/src/utility.hpp"
+#include "largebm/src/build_mdd.hpp"
+
+#include "largehm/src/freq_miner.hpp"
+#include "largehm/src/load_inst.hpp"
+#include "largehm/src/utility.hpp"
+#include "largehm/src/build_mdd.hpp"
+
+
 
 PYBIND11_MODULE(_effspm, m) {
-    m.doc() = "Unified SPM library: PrefixProjection, BTMiner, and more";
+    m.doc() = "Unified SPM library: PrefixProjection, BTMiner, HTMiner";
 
+    // ─────────────────────────────────────────────────────────────
     // PrefixProjection
+    // ─────────────────────────────────────────────────────────────
     m.def("PrefixProjection",
         [](py::object data,
            double minsup,
@@ -76,15 +104,17 @@ PYBIND11_MODULE(_effspm, m) {
             return out;
         },
         py::arg("data"),
-        py::arg("minsup") = 0.01,
+        py::arg("minsup")     = 0.01,
         py::arg("time_limit") = 36000,
-        py::arg("preproc") = false,
-        py::arg("use_dic") = false,
-        py::arg("verbose") = false,
-        py::arg("out_file") = ""
+        py::arg("preproc")    = false,
+        py::arg("use_dic")    = false,
+        py::arg("verbose")    = false,
+        py::arg("out_file")   = ""
     );
 
+    // ─────────────────────────────────────────────────────────────
     // BTMiner
+    // ─────────────────────────────────────────────────────────────
     m.def("BTMiner",
         [](py::object data,
            double minsup,
@@ -143,11 +173,405 @@ PYBIND11_MODULE(_effspm, m) {
             return out;
         },
         py::arg("data"),
-        py::arg("minsup") = 0.01,
+        py::arg("minsup")     = 0.01,
         py::arg("time_limit") = 36000,
-        py::arg("preproc") = false,
-        py::arg("use_dic") = false,
-        py::arg("verbose") = false,
-        py::arg("out_file") = ""
+        py::arg("preproc")    = false,
+        py::arg("use_dic")    = false,
+        py::arg("verbose")    = false,
+        py::arg("out_file")   = ""
     );
-}
+
+// ─────────────────────────────────────────────────────────────
+// HTMiner
+// ─────────────────────────────────────────────────────────────
+m.def("HTMiner",
+        [](py::object data,
+           double minsup, unsigned int time_limit,
+           bool preproc, bool use_dic,
+           bool verbose, const std::string &out_file)
+        {
+            // 1) set HTMiner globals (declared in htminer/src/utility.hpp)
+            htminer::time_limit = time_limit;
+            htminer::pre_pro    = preproc;
+            htminer::use_dic    = use_dic;
+            htminer::just_build = false;         // or true if you want “build only”
+            htminer::use_list   = false;         // HTMiner always uses MDD‐based mode
+            htminer::b_disp     = verbose;
+            htminer::b_write    = !out_file.empty();
+            htminer::out_file   = out_file;
+            htminer::ClearCollected();           // clear any leftover patterns
+            htminer::start_time = std::clock();
+
+            // 2) load sequences (either from filename or from Python list)
+            if (py::isinstance<py::str>(data)) {
+                std::string path = data.cast<std::string>();
+                if (!htminer::Load_instance(path, minsup))
+                    throw std::runtime_error("Failed to load file: " + path);
+            } else {
+                auto seqs = data.cast<std::vector<std::vector<int>>>();
+                htminer::items = std::move(seqs);
+                htminer::N = htminer::items.size();
+
+                // compute L (max item ID), M (max sequence length), E (total entries)
+                int max_id = 0;
+                htminer::M = 0;
+                htminer::E = 0;
+                for (auto &seq : htminer::items) {
+                    htminer::M = std::max<unsigned int>(htminer::M, seq.size());
+                    for (int x : seq)
+                        max_id = std::max(max_id, std::abs(x));
+                    htminer::E += seq.size();
+                }
+                htminer::L = max_id;
+                htminer::theta = (minsup < 1.0) 
+                                  ? static_cast<unsigned long long>(std::ceil(minsup * htminer::N))
+                                  : static_cast<unsigned long long>(minsup);
+
+                // build empty DFS stack (size L) as HTMiner expects
+                htminer::DFS.clear();
+                htminer::DFS.reserve(htminer::L);
+                for (unsigned int i = 0; i < static_cast<unsigned int>(htminer::L); ++i)
+                    htminer::DFS.emplace_back(-static_cast<int>(i) - 1);
+
+                // initialize VDFS if HTMiner needs it
+                htminer::VDFS.clear();
+                htminer::VDFS.resize(htminer::L);
+            }
+
+            // 3) run the mining algorithm
+            htminer::Freq_miner();
+
+            // std::cout << "[HTMiner] dumping all collected patterns:\n";
+            // for (size_t i = 0; i < htminer::collectedPatterns.size(); ++i) {
+            //     const auto &seq = htminer::collectedPatterns[i];
+            //     std::cout << "Pattern " << i << ": { ";
+            //     for (int x : seq) {
+            //          std::cout << x << " ";
+            //         }
+            //         std::cout << "}\n";
+//}
+std::cout << " total patterns = "
+          << htminer::collectedPatterns.size() << "\n";
+// ─────────────────────────────────────────────────
+
+            // 4) return patterns + elapsed time
+            py::dict out;
+            out["patterns"] = htminer::GetCollected();
+            out["time"]     = htminer::give_time(std::clock() - htminer::start_time);
+            return out;
+        },
+        py::arg("data"),
+        py::arg("minsup")     = 0.01,
+        py::arg("time_limit") = 36000,
+        py::arg("preproc")    = false,
+        py::arg("use_dic")    = false,
+        py::arg("verbose")    = false,
+        py::arg("out_file")   = ""
+    );
+
+    m.def("LargePrefixProjection",
+    [](py::object data,
+       double minsup,
+       unsigned int time_limit,
+       bool preproc,
+       bool use_dic,
+       bool verbose,
+       const std::string &out_file)
+    {
+        largepp::time_limit = time_limit;
+        largepp::pre_pro    = preproc;
+        largepp::use_dic    = use_dic;
+        largepp::use_list   = true;          // ← key difference
+        largepp::b_disp     = verbose;
+        largepp::b_write    = !out_file.empty();
+        largepp::out_file   = out_file;
+        largepp::just_build = false;  
+
+        largepp::ClearCollected();
+        largepp::start_time = std::clock();
+        std::string fname = data.cast<std::string>();
+        /* 1) load instance (py list or filename) */
+        if (py::isinstance<py::str>(data))
+            
+            largepp::Load_instance(fname, minsup);
+        else
+            largepp::Load_py(data, minsup);          // helper you’ll expose
+        
+        std::vector<unsigned long long> dbg;
+
+
+        
+
+
+
+        largepp::Freq_miner();
+
+        py::dict out;
+        out["patterns"] = largepp::GetCollected();
+        out["time"]     = largepp::give_time(std::clock() - largepp::start_time);
+        return out;
+    },
+    py::arg("data"),
+    py::arg("minsup")     = 0.01,
+    py::arg("time_limit") = 36000,
+    py::arg("preproc")    = false,
+    py::arg("use_dic")    = false,
+    py::arg("verbose")    = false,
+    py::arg("out_file")   = ""
+);
+
+// ─────────────────────────────────────────────────────────────
+// LargeBTMiner  -- Python wrapper for the largebm implementation
+// ─────────────────────────────────────────────────────────────
+// m.def(
+//     "LargeBTMiner",
+//     [](py::object        data,
+//        double            minsup ,
+//        unsigned int      time_limit,
+//        bool              preproc ,
+//        bool              use_dic,
+//        bool              verbose,
+//        const std::string &out_file ) 
+//     {
+//         /* 1) Global flags */
+//         largebm::time_limit = time_limit;
+//         largebm::pre_pro    = preproc;
+//         largebm::use_dic    = use_dic;
+//         largebm::use_list   = false;          // large-mode → always MDD
+//         largebm::just_build = false;
+//         largebm::b_disp     = verbose;
+//         largebm::b_write    = !out_file.empty();
+//         largebm::out_file   = out_file;
+
+//         /* 2) Reset per-run state */
+//         largebm::ClearCollected();
+//         largebm::start_time = std::clock();
+
+//         /* 3) Load the DB (file path or in-memory list<list<int>>) */
+//         if (py::isinstance<py::str>(data)) {
+//             std::string path = data.cast<std::string>();
+//             if (!largebm::Load_instance(path, minsup))
+//                 throw std::runtime_error("Failed to load file: " + path);
+//         } else {
+//             // In-memory sequences
+//             largebm::items = std::move(data.cast<std::vector<std::vector<int>>>());
+//             largebm::N     = static_cast<unsigned int>(largebm::items.size());
+
+//             /* -- basic stats -- */
+//             int max_id = 0;
+//             largebm::M = 0;
+//             largebm::E = 0;
+//             for ( auto &seq : largebm::items) {
+//                 largebm::M = std::max<unsigned int>(largebm::M,
+//                                                     static_cast<unsigned int>(seq.size()));
+//                 largebm::E += static_cast<unsigned long long>(seq.size());
+//                 for (int x : seq) max_id = std::max(max_id, std::abs(x));
+//             }
+//             largebm::L     = static_cast<unsigned int>(max_id);
+//             largebm::theta = (minsup < 1.0)
+//                                ? static_cast<unsigned long long>(std::ceil(minsup * largebm::N))
+//                                : static_cast<unsigned long long>(minsup);
+
+//             /* -- DFS buffer (size = L) -- */
+//             largebm::DFS.clear();
+//             largebm::DFS.reserve(largebm::L);
+//             for (unsigned int i = 0; i < largebm::L; ++i)
+//                 largebm::DFS.emplace_back(-static_cast<int>(i) - 1);
+
+//             /* -- Build the MDD -- */
+//             largebm::Tree.clear();
+//             largebm::Tree.emplace_back(0, 0, 0);              // dummy root
+//             for ( auto &seq : largebm::items)
+//                 largebm::Build_MDD(seq);
+//         }
+
+//         /* 4) Mine and return results */
+//         largebm::Freq_miner();
+
+//         py::dict out;
+//         out["patterns"] = largebm::GetCollected();
+//         out["time"]     = largebm::give_time(std::clock() - largebm::start_time);
+//         return out;
+//     },
+//     py::arg("data"),
+//     py::arg("minsup")     = 0.01,
+//     py::arg("time_limit") = 36000,
+//     py::arg("preproc")    = false,
+//     py::arg("use_dic")    = false,
+//     py::arg("verbose")    = false,
+//     py::arg("out_file")   = ""
+// );
+
+
+m.def("LargeBTMiner",
+    [](py::object data,
+       double minsup,
+       unsigned int time_limit,
+       bool preproc,
+       bool use_dic,
+       bool verbose,
+       const std::string &out_file)
+    {
+        largebm::time_limit = time_limit;
+        largebm::pre_pro    = preproc;
+        largebm::use_dic    = use_dic;
+        largebm::use_list   = false;         // <-- switch into “large” mode
+        largebm::b_disp     = verbose;
+        largebm::b_write    = !out_file.empty();
+        largebm::out_file   = out_file;
+        largebm::just_build = false;
+
+        // ── Build the inverse‐dictionary here ────────────────────────────
+        {
+            std::vector<int> local_inv( largebm::item_dic.size() + 1 );
+            for (int old = 1; old <= (int)largebm::item_dic.size(); ++old) {
+                int cid = largebm::item_dic[old - 1];
+                if (cid > 0)
+                    local_inv[cid] = old;
+            }
+            largebm::inv_item_dic = std::move(local_inv);
+        }
+        // ─std::cerr << "inv_item_dic size=" << largebm::inv_item_dic.size() << "\n";
+          for (size_t i = 0; i < largebm::inv_item_dic.size(); ++i) {
+        //std::cerr << i << "→" << largebm::inv_item_dic[i] << "  ";
+    }
+    std::cerr << "\n";
+
+        largebm::ClearCollected();
+        largebm::start_time = std::clock();
+
+        if (py::isinstance<py::str>(data)) {
+            // load from filename
+            std::string path = data.cast<std::string>();
+            if (!largebm::Load_instance(path, minsup))
+                throw std::runtime_error("Failed to load file: " + path);
+        }
+        else {
+            // load from in‐memory sequences
+            largebm::items = std::move(data.cast<std::vector<std::vector<int>>>());
+           
+        }
+
+        largebm::Freq_miner();
+
+        py::dict out;
+        out["patterns"] = largebm::GetCollected();
+        out["time"]     = largebm::give_time(std::clock() - largebm::start_time);
+        return out;
+    },
+    py::arg("data"),
+    py::arg("minsup")     = 0.01,
+    py::arg("time_limit") = 36000,
+    py::arg("preproc")    = false,
+    py::arg("use_dic")    = false,
+    py::arg("verbose")    = false,
+    py::arg("out_file")   = ""
+);
+
+m.def("LargeHTMiner",
+    [](py::object data,
+       double minsup,
+       unsigned int time_limit,
+       bool preproc,
+       bool use_dic,
+       bool verbose,
+       const std::string &out_file)
+    {
+        // 0) Set global flags and timers:
+        largehm::time_limit = time_limit;
+        largehm::pre_pro    = preproc;
+        largehm::use_dic    = use_dic;
+        largehm::use_list   = true;     // force in‐memory mode
+        largehm::b_disp     = verbose;
+        largehm::b_write    = !out_file.empty();
+        largehm::out_file   = out_file;
+        largehm::just_build = false;
+
+        largehm::ClearCollected();
+        largehm::start_time = std::clock();
+
+        if (py::isinstance<py::str>(data)) {
+            // ───────────── FILE‐BASED MODE ─────────────
+            // Force mlim so that every item lands in temp_vec (never temp_lim):
+            largehm::mlim = UINT_MAX;
+
+            std::string path = data.cast<std::string>();
+            if (! largehm::Load_instance(path, minsup))
+                throw std::runtime_error("Failed to load file: " + path);
+        }
+        else {
+            // ───────────── IN‐MEMORY MODE ─────────────
+            auto seqs = data.cast<std::vector<std::vector<int>>>();
+            largehm::items = std::move(seqs);
+            largehm::N     = largehm::items.size();
+
+            // 1) Compute L = maximum absolute item ID
+            int max_id = 0;
+            for (auto &seq : largehm::items)
+                for (int x : seq)
+                    max_id = std::max(max_id, std::abs(x));
+            largehm::L = static_cast<unsigned int>(max_id);
+
+            // 2) Compute theta as absolute support threshold
+            largehm::theta = (minsup < 1.0)
+                               ? static_cast<unsigned long long>(std::ceil(minsup * largehm::N))
+                               : static_cast<unsigned long long>(minsup);
+
+            // 3) Initialize DFS (size = L)
+            largehm::DFS.clear();
+            largehm::DFS.reserve(largehm::L);
+            for (unsigned int i = 0; i < largehm::L; ++i)
+                largehm::DFS.emplace_back(-static_cast<int>(i) - 1);
+
+            // 4) Compute M (max sequence length) and E (total entries)
+            largehm::M = 0;
+            largehm::E = 0;
+            for (auto &seq : largehm::items) {
+                largehm::M = std::max<unsigned int>(
+                    largehm::M, static_cast<unsigned int>(seq.size()));
+                largehm::E += seq.size();
+            }
+
+            // 5) ─── Build the MDD “manually” ───
+            largehm::Tree.clear();
+            largehm::VTree.clear();
+            largehm::CTree.clear();
+
+            // Insert exactly one dummy root node (chld=0, sibl=0, freq=0):
+            largehm::Tree.emplace_back(0,0,0);
+
+            // For each sequence “seq”, insert into MDD by placing a single −1 sentinel:
+            for (auto &seq : largehm::items) {
+                // Copy the item IDs:
+                std::vector<int> temp_vec = seq;
+                // Only a single “−1” is needed to force the suffix insertion:
+                std::vector<int> temp_lim(1, -1);
+
+                largehm::Build_MDD(temp_vec, temp_lim);
+            }
+
+            
+        }
+
+        // 6) Run the frequency miner (Tree is now properly built):
+        largehm::Freq_miner();
+
+        // 7) Return results to Python:
+        py::dict out;
+        out["patterns"] = largehm::GetCollected();
+        out["time"]     = largehm::give_time(std::clock() - largehm::start_time);
+        return out;
+    },
+    py::arg("data"),
+    py::arg("minsup")     = 0.01,
+    py::arg("time_limit") = 36000,
+    py::arg("preproc")    = false,
+    py::arg("use_dic")    = false,
+    py::arg("verbose")    = false,
+    py::arg("out_file")   = ""
+);
+
+
+
+
+}

effspm/btminer/src/freq_miner.cpp

@@ -156,6 +156,9 @@ void Extend_patt(Pattern _patt) {
 }
 
 void Out_patt(std::vector<int>& seq, int freq) {
+    
+    btminer::collected.push_back(seq);   // make pattern visible to Python
+
     std::ofstream file_o;
     if (b_write) file_o.open(out_file, std::ios::app);
 

effspm/btminer/src/load_inst.cpp

@@ -18,6 +18,7 @@ using namespace std;
 
 extern int num_nodes, cur_node;
 
+
 map<string, int> item_map;
 map<int, string> item_map_rev;
 vector<int> freq;
@@ -27,6 +28,9 @@ void Load_items_pre(string& inst_name);
 bool Load_items(string& inst_name);
 bool Preprocess(string& inst, double thresh);
 
+
+
+
 bool Load_instance(string& items_file, double thresh) {
     clock_t kk = clock();
     Tree.emplace_back(0, 0, 0);

effspm/btminer/src/load_inst.hpp

@@ -20,4 +20,6 @@ extern int N, M, L, theta, num_nodes, M_mult, N_mult, time_limit, cur_node;
 
 extern clock_t start_time;
 
+
+
 } // namespace btminer

effspm/btminer/src/utility.cpp

@@ -5,63 +5,61 @@
 
 namespace btminer {
 
-// === Global Variables ===
-bool use_dic = false; 
+// ─── Global definitions ──────────────────────────────────────────
+bool use_dic   = false;
 std::vector<std::vector<int>> items;
-bool use_list = false;
+bool use_list  = false;
 bool just_build = false;
-int E = 0, M = 0, N = 0, L = 0, theta = 0;
+int  E = 0, M = 0, N = 0, L = 0, theta = 0;
 std::vector<Pattern> DFS;
-clock_t start_time;
+clock_t start_time = 0;
 bool b_disp = false, b_write = false;
 std::string out_file;
 
-bool pre_pro = true;
-int N_mult = 1, M_mult = 1;
-int time_limit = 30 * 3600;
+bool pre_pro   = true;
+int  N_mult    = 1, M_mult   = 1;
+int  time_limit = 30 * 3600;
 
-// === Function Definitions ===
+// buffer of mined patterns returned to Python
+std::vector<std::vector<int>> collected;
 
-int find_ID(std::vector<int>& vec, int itm) {
+void ClearCollected()                       { collected.clear(); }
+const std::vector<std::vector<int>>& GetCollected() { return collected; }
+
+// ─── Utility functions ───────────────────────────────────────────
+int find_ID(std::vector<int>& vec, int itm)
+{
     int plc = 0;
-    while (plc < vec.size() && vec[plc] != itm)
-        ++plc;
-    return (plc == vec.size()) ? -1 : plc;
+    while (plc < static_cast<int>(vec.size()) && vec[plc] != itm) ++plc;
+    return (plc == static_cast<int>(vec.size())) ? -1 : plc;
 }
 
-bool check_parent(int cur_arc, int str_pnt, int start, std::vector<int>& strpnt_vec) {
+bool check_parent(int cur_arc, int str_pnt, int start,
+                  std::vector<int>& strpnt_vec)
+{
     std::vector<int> ancestors;
     int cur_anct = Tree[cur_arc].anct;
 
     while (Tree[cur_anct].itmset > Tree[str_pnt].itmset) {
-        if (Tree[cur_anct].item > 0)
-            ancestors.push_back(cur_anct);
+        if (Tree[cur_anct].item > 0) ancestors.push_back(cur_anct);
         cur_anct = Tree[cur_anct].anct;
     }
+    if (Tree[cur_anct].itmset == Tree[str_pnt].itmset) return true;
 
-    if (Tree[cur_anct].itmset == Tree[str_pnt].itmset)
-        return true;
-
-    for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
-        for (int i = start; i < strpnt_vec.size(); ++i) {
-            if (strpnt_vec[i] == *it)
-                return true;
-        }
-    }
+    for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it)
+        for (int i = start; i < static_cast<int>(strpnt_vec.size()); ++i)
+            if (strpnt_vec[i] == *it) return true;
 
     return false;
 }
 
-bool find_pnt(Arc* pnt, std::vector<Arc*>& vec, int pos) {
-    for (size_t i = pos; i < vec.size(); ++i) {
-        if (vec[i] == pnt)
-            return true;
-    }
+bool find_pnt(Arc* pnt, std::vector<Arc*>& vec, int pos)
+{
+    for (size_t i = pos; i < vec.size(); ++i)
+        if (vec[i] == pnt) return true;
     return false;
 }
 
-float give_time(clock_t kk) {
-    return static_cast<float>(kk) / CLOCKS_PER_SEC;
-}
+double give_time(clock_t kk) { return double(kk) / CLOCKS_PER_SEC; }
 
 } // namespace btminer

effspm/btminer/src/utility.hpp

@@ -12,11 +12,11 @@ namespace btminer {
 // === Utility function declarations ===
 bool find_pnt(Arc* pnt, std::vector<Arc*>& vec, int pos);
 int find_ID(std::vector<int>& vec, int itm);
-float give_time(clock_t kk);
+double give_time(clock_t kk);
 bool check_parent(int cur_arc, int str_pnt, int start, std::vector<int>& strpnt_vec);
 
 // === Global variables (DECLARATIONS ONLY) ===
-extern std::vector<std::vector<int>> items;
+
 extern bool use_list;
 extern bool just_build;
 extern int E, M, N, L, theta;
@@ -27,18 +27,14 @@ extern std::string out_file;
 extern bool pre_pro;
 extern int N_mult, M_mult;
 extern int time_limit;
+extern std::vector<std::vector<int>> items;
 
-// === Python-friendly accessors ===
-inline void ClearCollected() {
-    DFS.clear();
-}
+ extern std::vector<std::vector<int>> collected;
+
+void ClearCollected();
+const std::vector<std::vector<int>>& GetCollected();
 
-inline std::vector<std::vector<int>> GetCollected() {
-    std::vector<std::vector<int>> patterns;
-    for (const auto& p : DFS) {
-        patterns.push_back(p.seq);
-    }
-    return patterns;
 }
 
-} // namespace btminer
+
+// namespace btminer