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

effspm/largehm/src/load_inst.cpp

@@ -0,0 +1,357 @@
+#include <iostream>
+#include <sstream>
+#include <algorithm>
+#include <fstream>
+#include <cmath>
+#include <ctime>
+
+#include "load_inst.hpp"
+#include "utility.hpp"
+#include "build_mdd.hpp"
+#include "freq_miner.hpp"
+
+namespace largehm {
+using namespace std;
+
+string out_file;
+string folder;
+
+bool b_disp       = false;
+bool b_write      = false;
+bool use_dic      = false;
+bool use_list     = false;
+bool just_build   = false;
+bool pre_pro      = false;
+bool itmset_exists = false;
+
+unsigned int M         = 0;
+unsigned int L         = 0;
+unsigned int mlim      = 0;
+unsigned int time_limit = 0;
+
+unsigned long long int N     = 0;
+unsigned long long int theta = 0;
+unsigned long long int E     = 0;
+
+clock_t start_time = 0;
+
+vector<vector<int>> items;
+
+vector<int> item_dic;
+vector<Pattern> DFS;
+vector<VPattern> VDFS;
+
+
+bool Load_instance(string& items_file, double thresh) {
+    // ─── 1) CLEAR ANY leftover state from a previous run ───
+    Tree.clear();
+    VTree.clear();
+    CTree.clear();
+    DFS.clear();
+    VDFS.clear();
+    item_dic.clear();
+    items.clear();
+
+    N = 0;
+    M = 0;
+    L = 0;
+    E = 0;
+    theta = 0;
+    itmset_exists = false;
+    // ────────────────────────────────────────────────────
+
+    clock_t kk = clock();
+
+    // Insert fresh dummy root node:
+	
+
+   
+
+    Tree.emplace_back(0, 0, 0);
+
+    if (!pre_pro) {
+        if (!Load_items(items_file))
+            return false;
+        DFS.reserve(L);
+        while (DFS.size() < L) {
+            DFS.emplace_back(-static_cast<int>(DFS.size()) - 1);
+        }
+        VDFS.reserve(L);
+        while (VDFS.size() < L) {
+            VDFS.emplace_back(static_cast<int>(VDFS.size()));
+        }
+        if (thresh < 1.0) {
+            theta = static_cast<unsigned long long>(ceil(thresh * N));
+        } else {
+            theta = static_cast<unsigned long long>(thresh);
+        }
+    }
+    else {
+        if (!Load_items(items_file))
+            return false;
+        if (thresh < 1.0) {
+            theta = static_cast<unsigned long long>(ceil(thresh * N));
+        } else {
+            theta = static_cast<unsigned long long>(thresh);
+        }
+    }
+
+    cout << "\nMDD Database built in " << give_time(clock() - kk) << " seconds\n\n";
+    cout << "Found " << N << " sequence, with max line len " << M
+         << ", and " << L << " items, and " << E << " enteries\n";
+    // cout << "Total Trie nodes: " << Tree.size()
+    //      << " Total CTree nodes: " << CTree.size()
+    //      << " Total VTree nodes: " << VTree.size() << endl;
+
+    return true;
+}
+
+
+bool Preprocess(string &inst, double thresh) {
+    vector<unsigned long long int> MN(100, 0);
+    vector<vector<bool>> ML(100, vector<bool>(1000000, false));
+
+    ifstream file(inst);
+    if (!file.good()) {
+        cout << "!!!!!! No such file exists: " << inst << " !!!!!!\n";
+        return false;
+    }
+
+    vector<unsigned long long int> freq(1000000, 0ULL);
+    vector<unsigned long long int> counted(1000000, 0ULL);
+
+    string line;
+    int ditem;
+    while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+        ++N;
+        if (N % 10000000 == 0)
+            cout << "N: " << N << endl;
+
+        istringstream word(line);
+        string itm;
+        int size_m = 0;
+        while (word >> itm) {
+            ++size_m;
+            ditem = stoi(itm);
+
+            if (ditem > 0)
+                itmset_exists = true;
+            else
+                ditem = -ditem;
+
+            if (size_m < (int)MN.size()) {
+                ++MN[size_m - 1];
+                if ((int)ML[size_m - 1].size() < ditem) {
+                    ML[size_m - 1].resize(ditem, false);
+                }
+                ML[size_m - 1][ditem - 1] = true;
+            }
+
+            if (L < static_cast<unsigned int>(ditem)) {
+                L = static_cast<unsigned int>(ditem);
+            }
+
+            if ((int)freq.size() < ditem) {
+                freq.resize(ditem, 0ULL);
+                counted.resize(ditem, 0ULL);
+            }
+            if (counted[ditem - 1] != N) {
+                ++freq[ditem - 1];
+                counted[ditem - 1] = N;
+            }
+        }
+        if (size_m > (int)M)
+            M = size_m;
+    }
+
+    if (thresh < 1.0) {
+        theta = static_cast<unsigned long long>(ceil(thresh * N));
+    } else {
+        theta = static_cast<unsigned long long>(thresh);
+    }
+
+    int real_L = 0;
+    item_dic.assign(L, -1);
+    vector<bool> item_in(L, false);
+    for (int i = 0; i < (int)L; ++i) {
+        if (freq[i] >= theta) {
+            item_dic[i] = ++real_L;
+            item_in[i] = true;
+        }
+    }
+
+    cout << "Original number of items: " << L << " Reduced to: " << real_L << endl;
+
+    unsigned long long int LpM = 1;
+    mlim = M;
+    int orgmlim = 0;
+    int ulim = min(1 + real_L / 4, 10);
+    unsigned long long int ml;
+
+    for (int i = 0; i + ulim < (int)MN.size() && i + ulim < (int)M; ++i) {
+        ml = 0;
+        for (int j = 0; j < (int)L; ++j) {
+            if (ML[i][j] && item_in[j])
+                ++ml;
+        }
+        LpM *= ml * (1 + itmset_exists);
+        cout << ml << " " << LpM << " " << MN[i] << endl;
+        if (LpM * ulim > MN[i]) {
+            orgmlim = i;
+            while (i + ulim - 1 < (int)MN.size() && i + ulim - 1 < (int)M) {
+                cout << (MN[i - 1] - MN[i + ulim - 1]) << " "
+                     << MN[i + ulim - 1] << endl;
+                if ((MN[i - 1] - MN[i + ulim - 1]) < MN[i + ulim - 1]
+                     && MN[i + ulim - 1] < 600000000) {
+                    mlim = i - 1;
+                    break;
+                }
+                ++i;
+            }
+            break;
+        }
+    }
+
+    cout << "M is: " << M << " Mlim is: " << mlim
+         << " ulim is: " << ulim
+         << " original mlim is: " << orgmlim
+         << " guess is: "
+         << round((log(N) - log(6)) / log(real_L)) << endl;
+
+    if (mlim < (int)M) {
+        for (int i = 0; i < real_L; ++i)
+            VDFS.emplace_back(i);
+    }
+
+    L = static_cast<unsigned int>(real_L);
+    N = 0;
+    M = 0;
+    return true;
+}
+
+
+bool Load_items_pre(string &inst_name) {
+    ifstream file(inst_name);
+    if (!file.good()) {
+        cout << "!!!!!! No such file exists: " << inst_name << " !!!!!!\n";
+        return false;
+    }
+
+    string line;
+    int ditem;
+    while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+        istringstream word(line);
+        string itm;
+        vector<int> temp_vec;
+        vector<int> temp_lim;
+        bool sgn = false;
+
+        // L is final from Preprocess
+        while (word >> itm) {
+            ditem = stoi(itm);
+            if (item_dic[std::abs(ditem) - 1] == -1) {
+                if (!sgn)
+                    sgn = (ditem < 0);
+                continue;
+            } else {
+                if (ditem > 0)
+                    ditem = item_dic[ditem - 1];
+                else
+                    ditem = -item_dic[-ditem - 1];
+            }
+            if (sgn) {
+                if (ditem > 0)
+                    ditem = -ditem;
+                sgn = false;
+            }
+            if (temp_vec.size() <= (size_t)mlim)
+                temp_vec.push_back(ditem);
+            else
+                temp_lim.push_back(ditem);
+        }
+
+        if (temp_vec.empty())
+            continue;
+
+        ++N;
+        if (N % 10000000 == 0)
+            cout << N << endl;
+
+        if (temp_vec.size() + temp_lim.size() > (size_t)M)
+            M = static_cast<unsigned int>(temp_vec.size() + temp_lim.size());
+
+        // ─── Ensure DFS/VDFS size before Build_MDD ───
+        while (DFS.size() < L)
+            DFS.emplace_back(-static_cast<int>(DFS.size()) - 1);
+        while (VDFS.size() < L)
+            VDFS.emplace_back(static_cast<int>(VDFS.size()));
+        // ──────────────────────────────────────────────
+
+        Build_MDD(temp_vec, temp_lim);
+    }
+
+    return true;
+}
+
+
+bool Load_items(string &inst_name) {
+	// std::cerr << "[SANITY] In Load_items: inst_name='"
+	// << inst_name << "'" << std::endl;
+    ifstream file(inst_name);
+    if (!file.good()) {
+        cout << "!!!!!! No such file exists: " << inst_name << " !!!!!!\n";
+        return false;
+    }
+
+    string line;
+    int ditem;
+    while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+        ++N;
+        if (N % 1000000 == 0)
+            cout << "Found " << N << " sequence, with max line len "
+                 << M << ", and " << L << " items, and " << E
+                 << " enteries\n";
+
+        istringstream word(line);
+        string itm;
+        vector<int> temp_vec;
+        vector<int> temp_lim;
+
+        while (word >> itm) {
+            ditem = stoi(itm);
+
+            if (ditem > 0)
+                itmset_exists = true;
+
+            if (L < static_cast<unsigned int>(std::abs(ditem))) {
+                L = static_cast<unsigned int>(std::abs(ditem));
+                // Immediately grow DFS/VDFS to handle new L
+                while (DFS.size() < L)
+                    DFS.emplace_back(-static_cast<int>(DFS.size()) - 1);
+                while (VDFS.size() < L)
+                    VDFS.emplace_back(static_cast<int>(VDFS.size()));
+            }
+
+            if (temp_vec.size() < (size_t)mlim)
+                temp_vec.push_back(ditem);
+            else
+                temp_lim.push_back(ditem);
+        }
+         E += static_cast<unsigned long long>(temp_vec.size() + temp_lim.size());
+        if (temp_vec.size() + temp_lim.size() > (size_t)M)
+            M = static_cast<unsigned int>(temp_vec.size() + temp_lim.size());
+
+        // ─── Ensure DFS/VDFS size before Build_MDD ───
+        while (DFS.size() < L)
+            DFS.emplace_back(-static_cast<int>(DFS.size()) - 1);
+        while (VDFS.size() < L)
+            VDFS.emplace_back(static_cast<int>(VDFS.size()));
+        // ──────────────────────────────────────────────
+
+        Build_MDD(temp_vec, temp_lim);
+    }
+
+    return true;
+}
+
+} // namespace largehm

effspm/largehm/src/load_inst.hpp

@@ -0,0 +1,64 @@
+#ifndef LARGEHM_LOAD_INST_HPP
+#define LARGEHM_LOAD_INST_HPP
+
+#include <string>
+#include <vector>
+#include <fstream>
+#include <ctime>     // for clock_t
+
+// We need Pattern and VPattern, so include freq_miner.hpp here:
+#include "freq_miner.hpp"
+
+namespace largehm {
+
+//
+// ─── Globals & Function Prototypes ───────────────────────────────────────────
+//
+
+// Output/folder:
+extern std::string out_file;
+extern std::string folder;
+
+// Flags:
+extern bool b_disp;
+extern bool b_write;
+extern bool use_dic;
+extern bool use_list;
+extern bool just_build;
+extern bool pre_pro;
+extern bool itmset_exists;
+
+// Database statistics:
+extern unsigned int M;
+extern unsigned int L;
+extern unsigned int mlim;
+extern unsigned int time_limit;
+
+extern unsigned long long int N;
+extern unsigned long long int theta;
+extern unsigned long long int E;
+
+// Timing:
+extern clock_t start_time;
+
+// In‐memory sequences (only if “in‐memory” mode):
+extern std::vector<std::vector<int>> items;
+
+// Preprocessing dictionary (maps original → compressed IDs):
+extern std::vector<int> item_dic;
+
+// DFS stacks used by the miner (Pattern / VPattern):
+extern std::vector<Pattern>   DFS;
+extern std::vector<VPattern>  VDFS;
+
+// Internal loader functions:
+bool Load_items_pre(std::string &inst_name);
+bool Load_items(std::string &inst_name);
+bool Preprocess(std::string &inst, double thresh);
+
+// Main entry‐point for loading & building the MDD:
+bool Load_instance(std::string &items_file, double thresh);
+
+} // namespace largehm
+
+#endif // LARGEHM_LOAD_INST_HPP

effspm/largehm/src/main.cpp

@@ -0,0 +1,95 @@
+#include <iostream>
+#include <time.h>
+#include <string.h>
+#include <string>
+#include "load_inst.hpp"
+#include "build_mdd.hpp"
+#include "utility.hpp"
+#include "freq_miner.hpp"
+
+
+using namespace std;
+
+string out_file;
+
+bool  b_disp = 0,
+      b_write = 0,
+      use_dic = 0,
+      use_list = 0,      // <-- Add this
+	 just_build = 0,
+    pre_pro = 1;
+
+unsigned int time_limit = 10 * 3600;
+
+clock_t start_time;
+
+string folder;
+
+int main(int argc, char* argv[]) {
+		
+	string VV, attr;
+
+	double thresh = 0;
+	for (int i = 1; i<argc; i++) {
+		if (argv[i][0] != '-' || isdigit(argv[i][1]))
+			continue;
+		else if (strcmp(argv[i], "-thr") == 0)
+			thresh = stod(argv[i + 1]);
+		else if (strcmp(argv[i], "-file") == 0)
+			VV = argv[i + 1];
+		else if (strcmp(argv[i], "-time") == 0)
+			time_limit = stoi(argv[i + 1]);
+		else if (strcmp(argv[i], "-jbuild") == 0)
+			just_build = 1;
+		else if (strcmp(argv[i], "-folder") == 0)
+			folder = argv[i + 1];
+		else if (strcmp(argv[i], "-npre") == 0)
+			pre_pro = 0;
+		else if (strcmp(argv[i], "-dic") == 0)
+			use_dic = 1;
+		else if (strcmp(argv[i], "-out") == 0) {
+			if (i + 1 == argc || argv[i + 1][0] == '-')
+				b_disp = 1;
+			else if (argv[i + 1][0] == '+') {
+				b_disp = 1;
+				b_write = 1;
+				if (strlen(argv[i + 1]) > 1) {
+					out_file = argv[i + 1];
+					out_file = out_file.substr(1, out_file.size() - 1);
+				}
+				else
+					out_file = VV;
+			}
+			else {
+				b_write = 1;
+				out_file = argv[i + 1];
+			}
+		}
+
+		else
+			cout << "Command " << argv[i] << " not recognized and skipped.\n";
+	}
+
+
+
+    cout << "\n********************** " << VV << "**********************\n";
+
+	string item_file = VV;
+
+	cout << "loading instances...\n";
+
+	start_time = clock();
+
+	if (!largehm::Load_instance(item_file, thresh)) {
+if (!largehm::just_build && largehm::give_time(clock() - largehm::start_time) < largehm::time_limit) {
+    largehm::Freq_miner();
+    if (largehm::give_time(clock() - largehm::start_time) >= largehm::time_limit)
+        std::cout << "TIME LIMIT REACHED\n";
+    std::cout << "Mining Complete\n\nFound a total of " << largehm::num_patt << " patterns\n";    
+    std::cout << "\nTotal CPU time " << largehm::give_time(clock() - largehm::start_time) << " seconds\n\n";
+}
+
+
+	return 0;
+}
+}

effspm/largehm/src/utility.cpp

@@ -0,0 +1,38 @@
+#include "utility.hpp"
+#include "build_mdd.hpp"
+#include "load_inst.hpp"
+#include <iostream>
+namespace largehm {
+	std::vector<std::vector<int>> collected;
+bool check_parent(unsigned long long int cur_anct, unsigned long long int str_pnt, unsigned long long int start, vector<unsigned long long int>& strpnt_vec) {
+
+	vector<unsigned long long int> ancestors;
+	
+	while (abs(Tree[cur_anct].itmset) > abs(Tree[str_pnt].itmset)) {
+		if (Tree[cur_anct].item > 0)
+			ancestors.push_back(cur_anct);
+		cur_anct = Tree[cur_anct].anct;
+	}
+
+	if (abs(Tree[cur_anct].itmset) == abs(Tree[str_pnt].itmset))
+		return 1;
+	else {
+		for (vector<unsigned long long int>::reverse_iterator it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
+			for (unsigned int i = start; i < strpnt_vec.size(); ++i) {
+				if (strpnt_vec[i] == *it)
+					return 1;
+			}
+		}
+	}
+
+	return 0;
+
+}
+
+
+
+// float give_time(clock_t kk) {
+// 	float ll = ((float)kk) / CLOCKS_PER_SEC;
+// 	return ll;
+// }
+}

effspm/largehm/src/utility.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <vector>
+#include <time.h>
+#include <string>
+#include "build_mdd.hpp"
+
+namespace largehm {
+using namespace std;
+
+  extern std::vector<std::vector<int>> collected;
+
+  // Helpers to clear and fetch collected patterns from Python:
+  inline void ClearCollected() {
+    collected.clear();
+  }
+  inline const std::vector<std::vector<int>>& GetCollected() {
+    return collected;
+  }
+
+  // A small timer helper:
+  inline float give_time(clock_t kk) {
+    float ll = ((float)kk) / CLOCKS_PER_SEC;
+    return ll;
+  }
+bool check_parent(unsigned long long int cur_anct, unsigned long long int str_pnt, unsigned long long int start, vector<unsigned long long int>& strpnt_vec);
+
+
+}