Add GFD mining #465

AntonChern · 2024-09-25T05:18:47Z

This PR implements an algorithm for mining graph functional dependencies based on article "Discovering Graph Functional Dependencies" by Fan Wenfei, Hu Chunming, Liu Xueli, and Lu Ping. Algorithm, given an input graph, returns a set of dependencies satisfied on this graph. The algorithm also has two configurable parameters: k is the maximum number of vertices in the pattern of the mined dependency and sigma is its minimum frequency.
In addition, the PR implements the ability to run the algorithm in Python, and also contains examples of its use.

github-actions

clang-tidy made some suggestions

There were too many comments to post at once. Showing the first 25 out of 29. Check the log or trigger a new build to see more.

src/core/algorithms/gfd/gfd_miner.cpp

github-actions

clang-tidy made some suggestions

src/core/algorithms/gfd/gfd_miner.cpp

src/python_bindings/gfd/bind_gfd_mining.cpp

src/tests/test_gfd_mining.cpp

src/core/algorithms/gfd/gfd_miner.h

src/core/algorithms/gfd/gfd_miner.cpp

src/tests/test_gfd_mining.cpp

src/core/algorithms/gfd/gfd_miner.cpp

xJoskiy · 2024-10-08T16:12:46Z

src/core/algorithms/gfd/gfd_miner.cpp

+        : query_(query_), iso_(iso_), res_(res_) {}
+
+    template <typename CorrespondenceMap1To2, typename CorrespondenceMap2To1>
+    bool operator()(CorrespondenceMap1To2 f, CorrespondenceMap2To1) const {


Second parameter is not used

Boost Graph Library requires such syntax from callback function. Unfortunately, if I change the function signature, the code will not compile

src/core/algorithms/gfd/gfd_miner.cpp

xJoskiy · 2024-10-08T17:02:08Z

Add PR description

github-actions

clang-tidy made some suggestions

src/core/algorithms/gfd/gfd_miner.cpp

src/tests/test_gfd_mining.cpp

src/core/algorithms/gfd/gfd_miner.cpp

xJoskiy · 2024-10-09T19:02:21Z

You are doing great! Please don't forget to notify when you are done with changes requested. Also please mark conversations if they are resolved

src/python_bindings/gfd/bind_gfd_mining.cpp

src/core/algorithms/gfd/gfd_miner.cpp

src/tests/test_gfd_mining.cpp

src/core/algorithms/gfd/gfd_miner.cpp

xJoskiy · 2024-10-27T21:30:21Z

src/core/algorithms/gfd/gfd_miner.cpp

+            Token name_token = Token(i, name.first);
+            for (auto& value : name.second) {
+                Token value_token = Token(-1, value);
+                result.push_back(Literal(name_token, value_token));


result.reserve(name.second.size() * attrs_info.at(label).size())

Unfortunately, name.second can have different number of values, depending on name.first. The reserve may not work correctly.

src/core/algorithms/gfd/gfd_miner.cpp

src/python_bindings/bindings.cpp

src/core/algorithms/gfd/gfd_miner.cpp

github-actions

clang-tidy made some suggestions

src/core/algorithms/gfd/gfd.cpp

src/core/algorithms/gfd/gfd_miner.cpp

src/tests/test_gfd_mining.cpp

vs9h

I looked through the pull request a bit and left comments on the things that caught my eye.

It would be nice if you try to improve the code yourself some more. It might be helpful to read google's coding style, which we try to follow.

Also you can use some tools. For example, cppcheck can point out errors and possible improvements

src/core/algorithms/gfd/gfd_miner.cpp

src/core/algorithms/gfd/gfd_miner.h

src/core/algorithms/gfd/gfd_miner.cpp

vs9h · 2024-11-27T19:00:13Z

src/core/algorithms/gfd/gfd_miner.cpp

+class CompareCallback {
+private:
+    graph_t const& query_;
+    Embedding& iso_;
+    bool& res_;
+
+public:
+    CompareCallback(graph_t const& query, Embedding& iso, bool& res)
+        : query_(query), iso_(iso), res_(res) {}
+
+    template <typename CorrespondenceMap1To2, typename CorrespondenceMap2To1>
+    bool operator()(CorrespondenceMap1To2 f, CorrespondenceMap2To1) const {
+        BGL_FORALL_VERTICES_T(u, query_, graph_t) {
+            iso_.emplace(u, get(f, u));
+        }
+        res_ = true;
+        return false;
+    }
+};
+
+struct VCompare {
+    graph_t const& query;
+    graph_t const& graph;
+
+    bool operator()(vertex_t const& fr, vertex_t const& to) const {
+        return query[fr].attributes.at("label") == graph[to].attributes.at("label");
+    }
+};
+
+struct ECompare {
+    graph_t const& query;
+    graph_t const& graph;
+
+    bool operator()(edge_t const& fr, edge_t const& to) const {
+        return query[fr].label == graph[to].label;
+    }
+};


Can we use lambdas instead of these structs?
Define them directly where you need them.

Unfortunately, the boost graph library requires exactly this structure for the code to work correctly.

Unfortunately, the boost graph library requires exactly this structure for the code to work correctly.

Are you sure about that? Cause this works fine with lambdas: https://godbolt.org/z/63ooq15nG

src/python_bindings/gfd/bind_gfd_mining.h

src/tests/test_gfd_mining.cpp

src/core/algorithms/gfd/gfd_miner.h

src/core/algorithms/gfd/gfd.h

src/core/algorithms/gfd/gfd_miner.cpp

xJoskiy · 2024-12-03T14:26:37Z

src/core/algorithms/gfd/gfd.h

    std::string ToString();
-};
+};


Add blank line at the end. Also applies to other files

I think the CI check complains when I do this

src/core/algorithms/gfd/gfd_miner.cpp

examples/basic/mining_gfd/mining_gfd1.py

examples/basic/mining_gfd/mining_gfd2.py

src/core/algorithms/gfd/gfd.cpp

src/core/algorithms/gfd/gfd_miner.cpp

github-actions

clang-tidy made some suggestions

src/tests/all_paths.cpp

Add class for GFD miner

Add minimal GFD and GFD with multiple conclusion tests

Added two examples with searching for dependencies in small graphs.

xJoskiy · 2024-12-12T12:21:51Z

graph_descriptor.h structures and aliases should not be in global namespace, add them to gfd namespace

xJoskiy · 2024-12-12T13:44:51Z

Change commit name Correct changes to previous algorithms so it's clear, what was changed

xJoskiy · 2024-12-12T11:40:19Z

src/core/algorithms/gfd/gfd.h

+// Defines a specific attribute of the pattern.
+// The first element is the index of the vertex,
+// the second is the name of the attribute.
+// An alias for user convenience.
 using Token = std::pair<int, std::string>;


Are indexes supposed to have negative values?

Yes, I encode the constant token with the value -1

src/core/algorithms/gfd/gfd.h

src/core/algorithms/gfd/gfd_miner.h

src/core/algorithms/gfd/comparator.cpp

src/core/algorithms/gfd/comparator.h

xJoskiy · 2024-12-12T12:31:39Z

src/core/algorithms/gfd/gfd.cpp

+class CmpCallback {
+private:
+    bool& res_;
+
+public:
+    CmpCallback(bool& res) : res_(res) {}
+
+    template <typename CorrespondenceMap1To2, typename CorrespondenceMap2To1>
+    bool operator()(CorrespondenceMap1To2, CorrespondenceMap2To1) const {
+        res_ = true;
+        return false;
+    }
+};
+
+struct VCmp {
+    graph_t const& lhs;
+    graph_t const& rhs;
+
+    bool operator()(vertex_t const& fr, vertex_t const& to) const {
+        return lhs[fr].attributes.at("label") == rhs[to].attributes.at("label");
+    }
+};
+
+struct ECmp {
+    graph_t const& lhs;
+    graph_t const& rhs;
+
+    bool operator()(edge_t const& fr, edge_t const& to) const {
+        return lhs[fr].label == rhs[to].label;
+    }
+};
+
+bool IsSub(graph_t const& query, graph_t const& graph) {
+    bool result = false;
+    VCmp vcmp = {query, graph};
+    ECmp ecmp = {query, graph};
+    CmpCallback callback(result);
+    boost::property_map<graph_t, boost::vertex_index_t>::type query_index_map =
+            get(boost::vertex_index, query);
+    boost::property_map<graph_t, boost::vertex_index_t>::type graph_index_map =
+            get(boost::vertex_index, graph);
+    std::vector<vertex_t> query_vertex_order = vertex_order_by_mult(query);
+    boost::vf2_subgraph_iso(query, graph, callback, query_index_map, graph_index_map,
+                            query_vertex_order, ecmp, vcmp);
+    return result;
+}
+
+}  // namespace


Have not done

src/core/algorithms/gfd/gfd.cpp

src/core/algorithms/gfd/gfd_miner.cpp

xJoskiy · 2024-12-13T17:11:17Z

src/core/algorithms/gfd/gfd_miner.cpp

+        std::vector<Literal> premises = {};
+        Gfd gfd = {pattern, premises, conclusion};
+        if (Validate(graph, gfd, embeddings, sigma)) {
+            rules.push_back({{}, l});


To avoid unnecessary temporary object creation

Suggested change

rules.push_back({{}, l});

rules.emplace_back({}, l);

Consider everywhere else

the suggested line gives a compiler error:
no matching function for call to ‘std::vector<std::pair<std::vector<std::pair<std::pair<int, std::__cxx11::basic_string >, std::pair<int, std::__cxx11::basic_string > > >, std::pair<std::pair<int, std::__cxx11::basic_string >, std::pair<int, std::__cxx11::basic_string > > > >::emplace_back(, gfd::Literal&)’

ol-imorozko

Will review gfd_miner.cpp tomorrow (:

ol-imorozko · 2024-12-17T18:18:01Z

src/core/algorithms/gfd/comparator.cpp

+
+bool ContainsLiteral(std::vector<Literal> const& literals, Literal const& l) {
+    auto check = [&l](auto const& cur_lit) { return CompareLiterals(cur_lit, l); };
+    return std::any_of(literals.begin(), literals.end(), check);


Suggested change

return std::any_of(literals.begin(), literals.end(), check);

return std::ranges::any_of(literals, check);

More cleaner this way, gets rid of .begin()/.end() boilerplate

ol-imorozko · 2024-12-17T18:20:48Z

src/core/algorithms/gfd/comparator.cpp

+        return false;
+    }
+    auto check = [&rhs](auto const& cur_lit) { return ContainsLiteral(rhs, cur_lit); };
+    return std::all_of(lhs.begin(), lhs.end(), check);


Suggested change

return std::all_of(lhs.begin(), lhs.end(), check);

return std::ranges::all_of(lhs, check);

ol-imorozko · 2024-12-17T18:28:47Z

src/core/algorithms/gfd/gfd.cpp


+#include <algorithm>


#include <algorithm> is not used in this file

ol-imorozko · 2024-12-17T18:37:28Z

src/core/algorithms/gfd/gfd.cpp

+class CmpCallback {
+private:
+    bool& res_;
+
+public:
+    CmpCallback(bool& res) : res_(res) {}
+
+    template <typename CorrespondenceMap1To2, typename CorrespondenceMap2To1>
+    bool operator()(CorrespondenceMap1To2, CorrespondenceMap2To1) const {
+        res_ = true;
+        return false;
+    }
+};


Using references as fields is not a good sign in any code.
Here we pass this FunctionObject to boost::vf2_subgraph_iso as a callback that will be called with operator() and set local variable bool result = false; to true.

Can't we just pass simple lambda to it then?
Like

bool result = false; auto callback = [&result](auto, auto) { result = true; return false; } //... boost::vf2_subgraph_iso(query, graph, callback, //... //... return result;

ol-imorozko · 2024-12-17T18:42:15Z

src/core/algorithms/gfd/gfd.cpp

+struct VCmp {
+    graph_t const& lhs;
+    graph_t const& rhs;
+
+    bool operator()(vertex_t const& fr, vertex_t const& to) const {
+        return lhs[fr].attributes.at("label") == rhs[to].attributes.at("label");
+    }
+};
+
+struct ECmp {
+    graph_t const& lhs;
+    graph_t const& rhs;
+
+    bool operator()(edge_t const& fr, edge_t const& to) const {
+        return lhs[fr].label == rhs[to].label;
+    }
+};


That is slighty better because we use const references as fields, but still, why don't just use lambdas?

auto vertex_cmp = [&query, &graph](vertex_t const& fr, vertex_t const& to) { return query[fr].attributes.at("label") == graph[to].attributes.at("label"); };; auto edge_cmp = [&query, &graph](edge_t const& fr, edge_t const& to) { return query[fr].label == graph[to].label; }; //pass vertex_cmp and edge_cmp to boost::vf2_subgraph_iso

ol-imorozko · 2024-12-17T18:43:59Z

src/core/algorithms/gfd/gfd.cpp

+bool Gfd::operator!=(Gfd const& gfd) const {
+    return !(*this == gfd);
+}


Since you've defined operator==, this code can be easily generated by compiler. Put that in .h file:

bool operator==(const Gfd& gfd) const; bool operator!=(const Gfd& gfd) const = default;

and remove manual implementation

src/core/algorithms/gfd/gfd.h

ol-imorozko · 2024-12-18T10:34:13Z

src/core/algorithms/gfd/gfd_miner.cpp

+using Info = std::map<std::string, std::set<std::string>>;
+
+void NextSubset(std::vector<std::size_t>& indices, std::size_t const border) {
+    if (indices.at(0) == border - indices.size()) {


Suggested change

if (indices.at(0) == border - indices.size()) {

if (indices.empty() || indices[0] == border - indices.size()) {

ol-imorozko · 2024-12-18T10:34:30Z

src/core/algorithms/gfd/gfd_miner.cpp

+
+void NextSubset(std::vector<std::size_t>& indices, std::size_t const border) {
+    if (indices.at(0) == border - indices.size()) {
+        indices = {};


Suggested change

indices = {};

indices.clear();

ol-imorozko · 2024-12-18T10:35:15Z

src/core/algorithms/gfd/gfd_miner.cpp

+    std::size_t index = 0;
+    for (int i = static_cast<int>(indices.size()) - 1; i >= 0; --i) {
+        if (indices.at(i) != border - indices.size() + static_cast<std::size_t>(i)) {
+            index = static_cast<std::size_t>(i);
+            break;
+        }
+    }
+    indices.at(index)++;
+    for (std::size_t i = index + 1; i < indices.size(); ++i) {
+        indices.at(i) = indices.at(index) + i - index;
+    }


we can refactor that as one loop without static_cast's:

std::size_t i = indices.size(); while (i > 0) { --i; if (indices[i] < border - indices.size() + i) { ++indices[i]; for (std::size_t j = i + 1; j < indices.size(); ++j) { indices[j] = indices[j - 1] + 1; } return; } }

probably, I'm not sure whether we need to execute second loop if we failed to find index in the first one

ol-imorozko · 2024-12-18T10:39:05Z

src/core/algorithms/gfd/gfd_miner.cpp

+}
+
+template <typename T>
+std::vector<std::vector<T>> GetSubsets(std::vector<T> const& elements, std::size_t const n) {


Suggested change

std::vector<std::vector<T>> GetSubsets(std::vector<T> const& elements, std::size_t const n) {

std::vector<std::vector<T>> GetSubsets(std::vector<T> const& elements, std::size_t n) {

Const here does nothing

ol-imorozko · 2024-12-18T10:39:24Z

src/core/algorithms/gfd/gfd_miner.cpp

+    if (elements.size() < n) {
+        return {};
+    }
+    std::vector<std::vector<T>> result = {};


just

Suggested change

std::vector<std::vector<T>> result = {};

std::vector<std::vector<T>> result;

is enough

ol-imorozko · 2024-12-18T13:37:16Z

src/core/algorithms/gfd/gfd_miner.cpp

+        std::vector<graph_t> new_patterns = {};
+        std::vector<Embeddings> new_embeddings_set = {};
+        std::vector<Rules> new_forbidden_rules_set = {};


Suggested change

std::vector<graph_t> new_patterns = {};

std::vector<Embeddings> new_embeddings_set = {};

std::vector<Rules> new_forbidden_rules_set = {};

std::vector<graph_t> new_patterns;

std::vector<Embeddings> new_embeddings_set;

std::vector<Rules> new_forbidden_rules_set;

ol-imorozko · 2024-12-18T13:38:10Z

src/core/algorithms/gfd/gfd_miner.cpp

+        patterns = new_patterns;
+        embeddings_set = new_embeddings_set;
+        forbidden_rules_set = new_forbidden_rules_set;


Suggested change

patterns = new_patterns;

embeddings_set = new_embeddings_set;

forbidden_rules_set = new_forbidden_rules_set;

patterns = std:move(new_patterns);

embeddings_set = std:move(new_embeddings_set);

forbidden_rules_set = std::move(new_forbidden_rules_set);

ol-imorozko · 2024-12-18T13:40:40Z

src/tests/test_gfd_mining.cpp

+    static std::unique_ptr<algos::GfdMiner> CreateGfdMiningInstance(
+            std::filesystem::path const& graph_path, TestConfig const& gfdConfig) {
+        StdParamsMap option_map = {{config::names::kGraphData, graph_path},
+                                   {config::names::kGfdK, gfdConfig.k},
+                                   {config::names::kGfdSigma, gfdConfig.sigma}};
+        return algos::CreateAndLoadAlgorithm<GfdMiner>(option_map);
+    }
+};
+


Avoid code duplication, here you can add an additional helper to execute and compare:

static void ExecuteAndCompare(const std::unique_ptr<algos::GfdMiner>& algorithm, const std::vector<Gfd>& expected_gfds) { algorithm->Execute(); const auto gfd_list = algorithm->GfdList(); ASSERT_EQ(expected_gfds.size(), gfd_list.size()); ASSERT_THAT(gfd_list, ::testing::ElementsAreArray(expected_gfds)); }

Also we can use matcher ::testing::ElementsAreArray instead of manually comparing them with ASSERT_TRUE(x == y) in a loop

ol-imorozko · 2024-12-18T13:44:03Z

src/tests/test_gfd_mining.cpp

+    std::unique_ptr<algos::GfdMiner> algorithm =
+            CreateGfdMiningInstance(graph_path, {.k = 2, .sigma = 3});
+    algorithm->Execute();
+    std::vector<Gfd> gfd_list = algorithm->GfdList();
+    algorithm = CreateGfdMiningInstance(graph_path, {.k = 3, .sigma = 3});
+    algorithm->Execute();
+    std::size_t expected_size = gfd_list.size();
+    gfd_list = algorithm->GfdList();
+    ASSERT_EQ(expected_size, gfd_list.size());
+    for (std::size_t index = 0; index < gfd_list.size(); ++index) {
+        ASSERT_TRUE(gfds.at(index) == gfd_list.at(index));
+    }


Why do we call CreateGfdMiningInstance and Execute two times in a row?
Should't this be just

Suggested change

std::unique_ptr<algos::GfdMiner> algorithm =

CreateGfdMiningInstance(graph_path, {.k = 2, .sigma = 3});

algorithm->Execute();

std::vector<Gfd> gfd_list = algorithm->GfdList();

algorithm = CreateGfdMiningInstance(graph_path, {.k = 3, .sigma = 3});

algorithm->Execute();

std::size_t expected_size = gfd_list.size();

gfd_list = algorithm->GfdList();

ASSERT_EQ(expected_size, gfd_list.size());

for (std::size_t index = 0; index < gfd_list.size(); ++index) {

ASSERT_TRUE(gfds.at(index) == gfd_list.at(index));

}

std::unique_ptr<algos::GfdMiner> algorithm = CreateGfdMiningInstance(graph_path, {.k = 2, .sigma = 3});

ExecuteAndCompare(algorithm, expected_gfds);

?

ol-imorozko · 2024-12-18T13:45:57Z

src/tests/test_gfd_mining.cpp

+    std::unique_ptr<algos::GfdMiner> algorithm =
+            CreateGfdMiningInstance(graph_path, {.k = 2, .sigma = 3});
+    algorithm->Execute();
+    std::vector<Gfd> gfd_list = algorithm->GfdList();
+    std::size_t expected_size = 1;
+    ASSERT_EQ(expected_size, gfd_list.size());
+    for (std::size_t index = 0; index < gfd_list.size(); ++index) {
+        ASSERT_TRUE(gfds.at(index) == gfd_list.at(index));
+    }


Same thing with all other tests:

Suggested change

std::unique_ptr<algos::GfdMiner> algorithm =

CreateGfdMiningInstance(graph_path, {.k = 2, .sigma = 3});

algorithm->Execute();

std::vector<Gfd> gfd_list = algorithm->GfdList();

std::size_t expected_size = 1;

ASSERT_EQ(expected_size, gfd_list.size());

for (std::size_t index = 0; index < gfd_list.size(); ++index) {

ASSERT_TRUE(gfds.at(index) == gfd_list.at(index));

}

std::unique_ptr<algos::GfdMiner> algorithm = CreateGfdMiningInstance(graph_path, {.k = 2, .sigma = 3});

ExecuteAndCompare(algorithm, gfds);

github-actions bot reviewed Sep 25, 2024

View reviewed changes

AntonChern force-pushed the gfd branch from 0f5bb57 to 415de17 Compare October 1, 2024 07:52

github-actions bot reviewed Oct 1, 2024

View reviewed changes

AntonChern force-pushed the gfd branch 2 times, most recently from c3eeecf to a59e3cc Compare October 3, 2024 08:42

xJoskiy suggested changes Oct 6, 2024

View reviewed changes

xJoskiy suggested changes Oct 7, 2024

View reviewed changes

xJoskiy suggested changes Oct 8, 2024

View reviewed changes

AntonChern force-pushed the gfd branch from a59e3cc to f998fa9 Compare October 9, 2024 17:03

github-actions bot reviewed Oct 9, 2024

View reviewed changes

src/core/algorithms/gfd/gfd_miner.cpp Outdated Show resolved Hide resolved

src/tests/test_gfd_mining.cpp Outdated Show resolved Hide resolved

xJoskiy reviewed Oct 9, 2024

View reviewed changes

src/core/algorithms/gfd/gfd_miner.cpp Outdated Show resolved Hide resolved

AntonChern force-pushed the gfd branch 2 times, most recently from 60aeadc to 9ce90a3 Compare October 16, 2024 15:46

AntonChern requested a review from xJoskiy October 16, 2024 15:47

xJoskiy suggested changes Oct 24, 2024

View reviewed changes

xJoskiy suggested changes Oct 26, 2024

View reviewed changes

xJoskiy suggested changes Oct 27, 2024

View reviewed changes

xJoskiy suggested changes Nov 2, 2024

View reviewed changes

src/core/algorithms/gfd/gfd_miner.cpp Outdated Show resolved Hide resolved

src/core/algorithms/gfd/gfd_miner.cpp Outdated Show resolved Hide resolved

src/python_bindings/bindings.cpp Outdated Show resolved Hide resolved

src/core/algorithms/gfd/gfd_miner.cpp Outdated Show resolved Hide resolved

xJoskiy reviewed Nov 3, 2024

View reviewed changes

src/core/algorithms/gfd/gfd_miner.cpp Outdated Show resolved Hide resolved

src/core/algorithms/gfd/gfd_miner.cpp Show resolved Hide resolved

xJoskiy reviewed Nov 3, 2024

View reviewed changes

src/core/algorithms/gfd/gfd_miner.cpp Outdated Show resolved Hide resolved

AntonChern force-pushed the gfd branch 2 times, most recently from 11d6a2e to 13b76ae Compare November 5, 2024 16:38

xJoskiy suggested changes Nov 6, 2024

View reviewed changes

xJoskiy reviewed Nov 7, 2024

View reviewed changes

src/core/algorithms/gfd/gfd_miner.cpp Outdated Show resolved Hide resolved

AntonChern force-pushed the gfd branch from 13b76ae to b610124 Compare November 13, 2024 16:25

github-actions bot reviewed Nov 13, 2024

View reviewed changes

AntonChern force-pushed the gfd branch from b610124 to 174ee2c Compare November 13, 2024 17:05

AntonChern force-pushed the gfd branch 2 times, most recently from 44b4271 to b6e4f89 Compare November 27, 2024 17:23

vs9h requested changes Nov 27, 2024

View reviewed changes

xJoskiy suggested changes Dec 3, 2024

View reviewed changes

xJoskiy reviewed Dec 3, 2024

View reviewed changes

src/core/algorithms/gfd/gfd_miner.cpp Outdated Show resolved Hide resolved

xJoskiy reviewed Dec 3, 2024

View reviewed changes

src/core/algorithms/gfd/gfd_miner.cpp Outdated Show resolved Hide resolved

xJoskiy reviewed Dec 3, 2024

View reviewed changes

src/core/algorithms/gfd/gfd_miner.cpp Outdated Show resolved Hide resolved

xJoskiy reviewed Dec 3, 2024

View reviewed changes

src/core/algorithms/gfd/gfd_miner.cpp Outdated Show resolved Hide resolved

xJoskiy reviewed Dec 3, 2024

View reviewed changes

src/core/algorithms/gfd/gfd_miner.cpp Outdated Show resolved Hide resolved

xJoskiy reviewed Dec 3, 2024

View reviewed changes

src/core/algorithms/gfd/gfd_miner.cpp Outdated Show resolved Hide resolved

xJoskiy suggested changes Dec 4, 2024

View reviewed changes

xJoskiy reviewed Dec 7, 2024

View reviewed changes

src/core/algorithms/gfd/gfd_miner.cpp Outdated Show resolved Hide resolved

AntonChern force-pushed the gfd branch from b6e4f89 to c3eb76d Compare December 11, 2024 15:29

github-actions bot reviewed Dec 11, 2024

View reviewed changes

src/tests/all_paths.cpp Outdated Show resolved Hide resolved

Correct changes to previous algorithms

e7fe7bf

AntonChern force-pushed the gfd branch 3 times, most recently from 69c2d3f to 10ff8ca Compare December 11, 2024 17:14

AntonChern added 4 commits December 11, 2024 20:40

Add GFD mining

0f45663

Add class for GFD miner

Add tests for GFD mining

4c6e530

Add minimal GFD and GFD with multiple conclusion tests

Add python bindings for GFD mining

76b49cf

Add examples for GFD mining

b1a77f0

Added two examples with searching for dependencies in small graphs.

AntonChern force-pushed the gfd branch from 10ff8ca to b1a77f0 Compare December 11, 2024 17:41

xJoskiy suggested changes Dec 12, 2024

View reviewed changes

xJoskiy reviewed Dec 13, 2024

View reviewed changes

ol-imorozko requested changes Dec 17, 2024

View reviewed changes

ol-imorozko requested changes Dec 18, 2024

View reviewed changes

	return std::any_of(literals.begin(), literals.end(), check);
	return std::ranges::any_of(literals, check);

	return std::all_of(lhs.begin(), lhs.end(), check);
	return std::ranges::all_of(lhs, check);

	if (indices.at(0) == border - indices.size()) {
	if (indices.empty() \|\| indices[0] == border - indices.size()) {

	std::vector<std::vector<T>> GetSubsets(std::vector<T> const& elements, std::size_t const n) {
	std::vector<std::vector<T>> GetSubsets(std::vector<T> const& elements, std::size_t n) {

	std::vector<std::vector<T>> result = {};
	std::vector<std::vector<T>> result;


		#include <algorithm>

Add GFD mining #465

Are you sure you want to change the base?

Add GFD mining #465

Conversation

AntonChern commented Sep 25, 2024 • edited Loading

github-actions bot left a comment

Choose a reason for hiding this comment

github-actions bot left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

xJoskiy commented Oct 8, 2024

github-actions bot left a comment

Choose a reason for hiding this comment

xJoskiy commented Oct 9, 2024

Choose a reason for hiding this comment

Choose a reason for hiding this comment

github-actions bot left a comment

Choose a reason for hiding this comment

vs9h left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

github-actions bot left a comment

Choose a reason for hiding this comment

xJoskiy commented Dec 12, 2024

xJoskiy commented Dec 12, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

xJoskiy Dec 13, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ol-imorozko left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AntonChern commented Sep 25, 2024 •

edited

Loading

xJoskiy commented Dec 12, 2024 •

edited

Loading

xJoskiy Dec 13, 2024 •

edited

Loading