effspm 0.2.2__tar.gz → 0.2.6__tar.gz

effspm-0.2.6/MANIFEST.in

@@ -0,0 +1,5 @@
+include LICENSE
+include README.md
+include pyproject.toml
+include setup.py
+recursive-include effspm *.hpp

{effspm-0.2.2/effspm.egg-info → effspm-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: effspm
-Version: 0.2.2
+Version: 0.2.6
 Summary: Prefix‑Projection and other sequential pattern mining algorithms
 Author: Yeswanth Vootla
 Author-email: yeshu999 <vootlayeswanth20@gmail.com>

effspm-0.2.6/effspm/__init__.py

@@ -0,0 +1,11 @@
+
+from ._effspm import PrefixProjection, HTMiner, LargeHTMiner, BTMiner, LargeBTMiner, LargePrefixProjection
+
+__all__ = [
+    "PrefixProjection",
+    "HTMiner",
+    "LargeHTMiner",
+    "BTMiner",
+    "LargeBTMiner",
+    "LargePrefixProjection",
+]

{effspm-0.2.2 → effspm-0.2.6}/effspm/_effspm.cpp

@@ -403,71 +403,103 @@ std::cout << " total patterns = "
 // );
 
 
+
 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 ────────────────────────────
+        [](py::object data,
+           double minsup,
+           unsigned int time_limit,
+           bool preproc,
+           bool use_dic,
+           bool verbose,
+           const std::string &out_file)
         {
-            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";
+            // 0) Set global flags and timers
+            largebm::time_limit = time_limit;
+            largebm::pre_pro    = preproc;
+            largebm::use_dic    = use_dic;
+            largebm::use_list   = false;         // large‑mode → always MDD
+            largebm::b_disp     = verbose;
+            largebm::b_write    = !out_file.empty();
+            largebm::out_file   = out_file;
+            largebm::just_build = false;
+
+            // 0.1) Clear any leftover data/state from previous runs
+            largebm::items.clear();
+            largebm::item_dic.clear();
+            largebm::inv_item_dic.clear();
+            largebm::Tree.clear();
+            largebm::DFS.clear();
+            largebm::ClearCollected();
+
+            // 1) Load sequences (either from filename or from Python list)
+            if (py::isinstance<py::str>(data)) {
+                // ─────────── FILE‑BASED MODE ───────────
+                std::string path = data.cast<std::string>();
+                if (!largebm::Load_instance(path, minsup))
+                    throw std::runtime_error("Failed to load file: " + path);
 
-        largebm::ClearCollected();
-        largebm::start_time = std::clock();
+            } else {
+                // ────────── IN‑MEMORY MODE ──────────
+                auto seqs = data.cast<std::vector<std::vector<int>>>();
+                largebm::items = std::move(seqs);
+                largebm::N     = largebm::items.size();
 
-        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>>>());
-           
-        }
+                // 1.1) Compute basic DB statistics (M, E, L) and absolute support θ
+                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);
+
+                // 1.2) Initialize DFS buffer (size = L)
+                largebm::DFS.reserve(largebm::L);
+                for (unsigned int i = 0; i < largebm::L; ++i)
+                    largebm::DFS.emplace_back(-static_cast<int>(i) - 1);
+
+                // 1.3) Build the MDD “Tree”
+                // Insert one dummy root node (item=0, freq=0, anct=0)
+                largebm::Tree.emplace_back(0, 0, 0);
+                for (auto &seq : largebm::items)
+                    largebm::Build_MDD(const_cast<std::vector<int>&>(seq));
+            }
 
-        largebm::Freq_miner();
+            // 2) Rebuild inverse‑dictionary from fresh item_dic
+            {
+                std::vector<int> inv(largebm::item_dic.size() + 1);
+                for (int old = 1; old <= static_cast<int>(largebm::item_dic.size()); ++old) {
+                    int cid = largebm::item_dic[old - 1];
+                    if (cid > 0) inv[cid] = old;
+                }
+                largebm::inv_item_dic = std::move(inv);
+            }
 
-        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")   = ""
-);
+            // 3) Start timing and run the miner
+            largebm::start_time = std::clock();
+            largebm::Freq_miner();
+
+            // 4) Collect results and elapsed time
+            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,

{effspm-0.2.2 → effspm-0.2.6}/effspm/freq_miner.hpp

@@ -3,6 +3,8 @@
 #include "load_inst.hpp"
 #include <cstdlib> 
 #include <cmath> 
+#include <cstddef>  // for std::size_t
+
 using namespace std;
 void Freq_miner();
 void Out_patt(std::vector<int>& seq, unsigned int freq);
@@ -22,7 +24,8 @@ public:
 
 	Pattern(vector<int>& _seq, int item) {
 		seq.reserve(_seq.size());
-		for (int i = 0; i < _seq.size(); ++i)
+		for (std::size_t i = 0; i < _seq.size(); ++i)
+
 			seq.push_back(_seq[i]);
 		seq.push_back(item);
 		freq = 0;

{effspm-0.2.2 → effspm-0.2.6}/effspm/htminer/src/load_inst.cpp

@@ -106,6 +106,8 @@ bool Load_instance(std::string& items_file, double thresh) {
         //           << "  M=" << M << "  L=" << L << "  E=" << E << std::endl;
     }
 
+	
+
     std::cout << "\nMDD Database built in " << give_time(std::clock() - kk) << " seconds\n\n";
     std::cout << "Found " << N << " sequence, with max line len " << M
               << ", and " << L << " items, and " << E << " enteries\n";

{effspm-0.2.2 → effspm-0.2.6}/effspm/largebm/src/freq_miner.cpp

@@ -1,5 +1,3 @@
-// File: effspm/largebm/src/freq_miner.cpp
-
 #include <vector>
 #include <algorithm>
 #include <iostream>
@@ -27,16 +25,25 @@ namespace largebm {
     Pattern _patt;
 
     void Freq_miner() {
+        // ─── RESET per‐run state ──────────────────────────────────────
+        collected.clear();
+        num_patt = 0;
+        // Ensure DFS has at least L entries (so DFS[i] is valid for 0..L-1)
+        if (static_cast<int>(DFS.size()) < static_cast<int>(L)) {
+            DFS.resize(L); 
+        }
+        // ─────────────────────────────────────────────────────────────
+
         std::vector<int> list;
 
         if (use_list) {
-            // List-based routine
+            // List‐based routine
             std::vector<int> empty_pref;
             Freq_miner_list(items, empty_pref, theta, collected);
             return;
         }
 
-        // MDD-based initialization
+        // MDD‐based initialization
         for (int i = 0; i < static_cast<int>(L); ++i) {
             if (DFS[i].freq >= theta) {
                 list.push_back(-i - 1);
@@ -301,13 +308,13 @@ namespace largebm {
                       return std::abs(a.first) < std::abs(b.first);
                   });
 
-        // 4) depth-first enumerate them
+        // 4) depth‐first enumerate them
         for (auto const& pr : cand) {
             int item = pr.first;
             prefix.push_back(item);
 
             if (use_dic) {
-                // “un-compress” each pattern back to original IDs
+                // “un‐compress” each pattern back to original IDs
                 std::vector<int> unmapped;
                 unmapped.reserve(prefix.size());
                 for (int cid : prefix) {

{effspm-0.2.2 → effspm-0.2.6}/effspm/largebm/src/load_inst.cpp

@@ -1,16 +1,17 @@
-// ───── effspm/largebm/src/load_inst.cpp ─────────────────────────────
+
 #include <sstream>
 #include <algorithm>
 #include <cmath>
 #include <ctime>
+#include <iostream>      // for std::cout, std::endl
 #include <fstream>
 #include <vector>
 #include <string>
 
-#include "load_inst.hpp"    // header with global declarations
-#include "build_mdd.hpp"    // Arc & global Tree definitions
-#include "utility.hpp"      // give_time()
-#include "freq_miner.hpp"   // Pattern class
+#include "load_inst.hpp"
+#include "build_mdd.hpp"
+#include "utility.hpp"
+#include "freq_miner.hpp"
 
 namespace largebm {
 
@@ -29,20 +30,16 @@ std::clock_t        start_time = 0;
 
 std::vector<int>              item_dic;
 std::vector<Pattern>          DFS;
-std::vector<std::vector<int>> items;       // list‐mode working DB
-std::vector<std::vector<int>> collected;   // patterns for Python
+std::vector<std::vector<int>> items;
+std::vector<std::vector<int>> collected;
 std::vector<int>              inv_item_dic;
+
 std::string out_file, folder;
-void ClearCollected()                            { collected.clear(); }
-const std::vector<std::vector<int>>& GetCollected() { return collected; }
 
 // ───────────── helper for list‐mode DB build ─────────────────────
-static void Load_items_list(const std::string& fname)
-{
+static void Load_items_list(const std::string& fname) {
     std::ifstream in(fname);
-    if (!in.good()) {
-        return;
-    }
+    if (!in.good()) return;
     std::string line;
     while (std::getline(in, line)) {
         std::istringstream iss(line);
@@ -50,39 +47,39 @@ static void Load_items_list(const std::string& fname)
         int x;
         while (iss >> x) {
             int a = std::abs(x);
-            if (a < 1 || a > static_cast<int>(item_dic.size())) {
-                continue;
-            }
-            if (item_dic[a - 1] == -1) {
-                continue;
-            }
+            if (a < 1 || a > static_cast<int>(item_dic.size())) continue;
+            if (item_dic[a - 1] == -1) continue;
             seq.push_back(x);
         }
-        if (!seq.empty()) {
-            items.push_back(std::move(seq));
-        }
+        if (!seq.empty()) items.push_back(std::move(seq));
     }
 }
 
 // ─────────────── main loader ─────────────────────────────────────
-bool Load_instance(const std::string& items_file, double minsup)
-{
+bool Load_instance(const std::string& items_file, double minsup) {
+    // reset state
+    N = L = num_nodes = theta = M = E = 0;
     start_time = std::clock();
 
-    if (use_list)
-    {
-        if (!Preprocess(items_file, minsup)) {
-            return false;
-        }
+    DFS.clear();
+    Tree.clear();
+    items.clear();
+    collected.clear();
+    item_dic.clear();
+    inv_item_dic.clear();
+    itmset_exists = false;
+
+    std::clock_t kk = start_time;
+    Tree.emplace_back(0, 0, 0);  // root
 
+    if (use_list) {
+        if (!Preprocess(items_file, minsup)) return false;
         inv_item_dic.assign(L + 1, 0);
         for (int old = 1; old <= static_cast<int>(item_dic.size()); ++old) {
             int cid = item_dic[old - 1];
             if (cid > 0) inv_item_dic[cid] = old;
         }
-
         Load_items_list(items_file);
-
         N = items.size();
         theta = (minsup < 1.0)
                 ? static_cast<unsigned long long>(std::ceil(minsup * N))
@@ -90,29 +87,39 @@ bool Load_instance(const std::string& items_file, double minsup)
         return true;
     }
 
-    std::clock_t kk = std::clock();
-    Tree.clear();
-    Tree.emplace_back(0, 0, 0);  // root node
-
+    // MDD build mode
     if (pre_pro) {
-        if (!Preprocess(items_file, minsup)) {
-            return false;
-        }
+        if (!Preprocess(items_file, minsup)) return false;
+        std::cout << "\nPreprocess done in "
+                  << give_time(std::clock() - kk)
+                  << " seconds\n\n";
+        DFS.clear();
+        DFS.reserve(L);
+        for (unsigned int i = 0; i < L; ++i)
+            DFS.emplace_back(-int(i) - 1);
+        kk = std::clock();
         Load_items_pre(items_file);
     } else {
+        if (!Preprocess(items_file, 0.0)) return false;
+        kk = std::clock();
         Load_items(items_file);
     }
 
+    std::cout << "\nMDD Database built in "
+              << give_time(std::clock() - kk)
+              << " seconds\n\n";
+    std::cout << "Found " << N
+              << " sequences, with max line len " << M
+              << ", and " << L << " items, and " << E << " entries\n";
+    std::cout << "Total MDD nodes: " << Tree.size() << std::endl;
+
     return true;
 }
 
 // ────────────── Preprocess (list mode) ───────────────────────────
-bool Preprocess(const std::string& inst, double thresh)
-{
+bool Preprocess(const std::string& inst, double thresh) {
     std::ifstream file(inst);
-    if (!file.good()) {
-        return false;
-    }
+    if (!file.good()) return false;
 
     std::vector<unsigned long long> freq(1000000);
     std::vector<unsigned long long> counted(1000000, 0);
@@ -154,9 +161,7 @@ bool Preprocess(const std::string& inst, double thresh)
 // Load_items_pre: MDD insert from file
 void Load_items_pre(const std::string& inst_name) {
     std::ifstream file(inst_name);
-    if (!file.good()) {
-        return;
-    }
+    if (!file.good()) return;
 
     std::string line;
     while (std::getline(file, line)) {
@@ -166,11 +171,7 @@ void Load_items_pre(const std::string& inst_name) {
         bool sgn = false;
         while (word >> itm) {
             int ditem;
-            try {
-                ditem = std::stoi(itm);
-            } catch (...) {
-                continue;
-            }
+            try { ditem = std::stoi(itm); } catch (...) { continue; }
             int absidx = std::abs(ditem) - 1;
             if (absidx < 0 || absidx >= static_cast<int>(item_dic.size())) {
                 if (!sgn && ditem < 0) sgn = true;
@@ -180,23 +181,13 @@ void Load_items_pre(const std::string& inst_name) {
                 if (!sgn && ditem < 0) sgn = true;
                 continue;
             }
-            if (ditem > 0) {
-                ditem = item_dic[ditem - 1];
-                itmset_exists = true;
-            } else {
-                ditem = -item_dic[-ditem - 1];
-            }
-            if (sgn) {
-                if (ditem > 0) ditem = -ditem;
-                sgn = false;
-            }
+            if (ditem > 0) { ditem = item_dic[ditem - 1]; itmset_exists = true; }
+            else { ditem = -item_dic[-ditem - 1]; }
+            if (sgn) { if (ditem > 0) ditem = -ditem; sgn = false; }
             temp_vec.push_back(ditem);
         }
-        if (temp_vec.empty()) {
-            continue;
-        }
-
-        N++;
+        if (temp_vec.empty()) continue;
+        ++N;
         M = std::max<unsigned>(M, temp_vec.size());
         Build_MDD(temp_vec);
     }
@@ -205,9 +196,7 @@ void Load_items_pre(const std::string& inst_name) {
 // Load_items: full MDD build
 bool Load_items(const std::string& inst_name) {
     std::ifstream file(inst_name);
-    if (!file.good()) {
-        return false;
-    }
+    if (!file.good()) return false;
 
     std::string line;
     while (std::getline(file, line)) {
@@ -217,19 +206,25 @@ bool Load_items(const std::string& inst_name) {
         std::vector<int> temp_vec;
         while (word >> itm) {
             int ditem;
-            try {
-                ditem = std::stoi(itm);
-            } catch (...) {
-                continue;
-            }
+            try { ditem = std::stoi(itm); } catch (...) { continue; }
             if (ditem > 0) itmset_exists = true;
-            L = std::max(L, static_cast<unsigned>(std::abs(ditem)));
+            unsigned int ad = static_cast<unsigned int>(std::abs(ditem));
+            if (L < ad) {
+                L = ad;
+                DFS.reserve(L);
+                while (DFS.size() < L)
+                    DFS.emplace_back(-int(DFS.size()) - 1);
+            }
             temp_vec.push_back(ditem);
         }
-        M = std::max<unsigned>(M, temp_vec.size());
+        if (temp_vec.size() > M) M = temp_vec.size();
         Build_MDD(temp_vec);
     }
     return true;
 }
 
+void ClearCollected()   { collected.clear(); }
+const std::vector<std::vector<int>>& GetCollected() { return collected; }
+
 } // namespace largebm
+

{effspm-0.2.2 → effspm-0.2.6}/effspm/largehm/src/build_mdd.cpp

@@ -11,6 +11,7 @@ std::vector<largehm::CArc>      largehm::CTree;
 #include <iostream>
 #include <cmath>           // for std::abs
 #include <unordered_map>
+#include <cstdint>         // for std::uint64_t
 #include "load_inst.hpp"
 #include "freq_miner.hpp"
 #include "utility.hpp"
@@ -23,8 +24,8 @@ namespace largehm {
 void Build_MDD(std::vector<int>& items, std::vector<int>& items_lim) {
     // SANITY CHECK: show sizes before building
     
-    std::unordered_map<int, unsigned long long int> ancest_map;
-    unsigned long long int last_arc = 0;
+    std::unordered_map<int, std::uint64_t> ancest_map;
+    std::uint64_t last_arc = 0;
     int itmset = 0;
 
     // Insert each prefix item as an arc
@@ -43,9 +44,9 @@ void Build_MDD(std::vector<int>& items, std::vector<int>& items_lim) {
 // ─── Add_arc: insert a single “item” into the MDD under parent last_arc. ──────
 //
 int Add_arc(int item,
-            unsigned long long int last_arc,
+            std::uint64_t last_arc,
             int& itmset,
-            std::unordered_map<int, unsigned long long int>& ancest_map)
+            std::unordered_map<int, std::uint64_t>& ancest_map)
 {
     // Ensure DFS is at least size |item|
     size_t needed = static_cast<size_t>(std::abs(item));
@@ -67,7 +68,7 @@ int Add_arc(int item,
         ++itmset;
     }
 
-    unsigned long long int last_sibl = Tree[last_arc].chld;
+    std::uint64_t last_sibl = Tree[last_arc].chld;
     if (last_sibl == 0) {
         // No child yet: create a new Arc
         Tree.emplace_back(item, itmset, anct);
@@ -98,7 +99,7 @@ int Add_arc(int item,
     }
     ++Tree[last_sibl].freq;
     ancest_map[std::abs(item)] = last_sibl;
-    return last_sibl;
+    return static_cast<int>(last_sibl);
 }
 
 
@@ -106,8 +107,8 @@ int Add_arc(int item,
 // ─── Add_vec: attach the “items_lim” vector as children/vertical arcs ─────────
 //
 void Add_vec(std::vector<int>& items_lim,
-             std::unordered_map<int, unsigned long long int>& ancest_map,
-             unsigned long long int last_arc,
+             std::unordered_map<int, std::uint64_t>& ancest_map,
+             std::uint64_t last_arc,
              int itmset)
 {
     // Ensure VDFS and DFS are at least size L
@@ -131,7 +132,7 @@ void Add_vec(std::vector<int>& items_lim,
 
     // If this node has positive itmset (>0) or no CTree child yet, create first child entry
     if (Tree[last_arc].itmset > 0 || Tree[last_arc].chld == 0) {
-        std::vector<unsigned long long int> ancest(L + 1, 0ULL);
+        std::vector<std::uint64_t> ancest(L + 1, 0ULL);
         for (auto& kv : ancest_map) {
             ancest[kv.first - 1] = kv.second;
             counted[kv.first - 1] = true;

{effspm-0.2.2 → effspm-0.2.6}/effspm/largehm/src/freq_miner.cpp

@@ -1,12 +1,16 @@
+
+#include <cstdint>
+#include <vector>
+
 #include <iostream>
 #include <time.h>
-#include <vector>        // for std::vector
+      // for std::vector
 #include <cmath>         // for std::ceil
 
 #include "freq_miner.hpp"
 #include "build_mdd.hpp"
 #include "utility.hpp"
-
+std::vector<std::uint64_t> ancest_base;
 namespace largehm {
 
 void Out_patt(std::vector<int>& seq, unsigned int freq);
@@ -14,7 +18,7 @@ void Extend_patt(Pattern& _patt);
 void Mine_vec(unsigned long long int seq_ID,
               int pos,
               int num_found,
-              std::vector<unsigned long long int>& ancest,
+             
               std::vector<int>& items,
               unsigned long long int inod,
               int sgn);
@@ -27,7 +31,7 @@ std::vector<bool> slist;
 std::vector<Pattern> pot_patt;
 std::vector<VPattern> pot_vpatt;
 std::vector<unsigned long long int> last_strpnt;
-std::vector<unsigned long long int> ancest_base;
+
 std::vector<int> DFS_numfound;
 
 Pattern _patt;
@@ -354,13 +358,13 @@ void Extend_patt(Pattern& _pattern) {
 }
 
 
-void Mine_vec(unsigned long long int seq_ID, 
-              int pos, 
-              int num_found, 
-              std::vector<unsigned long long int>& ancest, 
-              std::vector<int>& items, 
-              unsigned long long int pnt, 
-              int sgn) 
+void Mine_vec(std::uint64_t seq_ID,
+              int pos,
+              int num_found,
+              std::vector<std::uint64_t>& ancest,
+              std::vector<int>& items,
+              std::uint64_t pnt,
+              int sgn)
 {
     std::vector<bool> found(L + L * (ilist_nempty ? 1 : 0), false);