reorganize repo

Author: mwien

README.md

@@ -1,19 +1,29 @@
-# The Clique-Picking Algorithm
+# Clique-Picking
 
-This repository countains multiple implementations of the Clique-Picking algorithm that we have proposed at AAAI 2021 [1] for counting the  number of Markov equivalent DAGs in polynomial time. 
-Moreover, we give implementations of the polynomial-time algorithm for uniformly sampling a DAG from a Markov Equivalence Class, which we refined in [2]. See also chapter 5 of my thesis [3]. 
+This repository provides functionality for working with CPDAGs, which are graphs representing Markov equivalence classes (MEC) of DAGs common in causal discovery. Currently, it focuses mostly on algorithms for counting, sampling and listing the DAGs in the MEC represented by a given CPDAG based on my [PhD thesis](https://mwien.github.io/thesis.pdf). 
 
-1. Marcel Wienöbst, Max Bannach, and Maciej Liśkiewicz: *Polynomial-Time Algorithms for Counting and Sampling Markov Equivalent DAGs* (AAAI 2021) [arXiv version](https://arxiv.org/abs/2012.09679)
-2. Marcel Wienöbst, Max Bannach, and Maciej Liśkiewicz: *Polynomial-Time Algorithms for Counting and Sampling Markov Equivalent DAGs with Applications* [(JMLR)](https://www.jmlr.org/papers/v24/22-0495.html)
-3. Marcel Wienöbst: *Algorithms for Markov Equivalence* [(PhD Thesis)](https://mwien.github.io/thesis.pdf)
+The algorithms are implemented in Rust and exposed via an Python wrapper available as Pypi package ```cliquepicking```. An R wrapper is planned.
+
+## Installation
+
+The python package can be installed with
+```
+pip install cliquepicking
+```
 
-## Implementations
+For more detailed documentation, see the README in the ```cliquepicking_python``` folder. 
 
-We provide the following implementations:
+## Roadmap
 
-- ```aaai_experiments/``` contains the original C++ implementation and experiments from the AAAI 2021 conference paper (only counting is implemented here)
-- ```cliquepicking_julia/``` contains the subsequent Julia code additionally provides a sampling algorithm
-- ```cliquepicking_rs/``` contains a recent Rust implementation for counting and sampling, which is cleaner and slightly more efficient (worst-case n^3)
-- ```cliquepicking_python/``` contains a Python wrapper for the Rust implementation. You can install and use the Python implementation easily via ```pip install cliquepicking```.
+The goal is to implement further algorithms from [3], such as those for MPDAGs. Feature requests are welcome. 
+
+## References
+The repository contains an implementation of the Clique-Picking algorithm proposed at AAAI 2021 [1] for counting the  number of Markov equivalent DAGs in polynomial time. 
+Moreover, it provides implementations of the polynomial-time algorithm for uniformly sampling a DAG from a Markov Equivalence Class, which were refined in [2]. See also Chapter 5 of [3]. 
+
+1. Marcel Wienöbst, Max Bannach, and Maciej Liśkiewicz: *Polynomial-Time Algorithms for Counting and Sampling Markov Equivalent DAGs* (AAAI 2021) [arXiv version](https://arxiv.org/abs/2012.09679)
+2. Marcel Wienöbst, Max Bannach, and Maciej Liśkiewicz: *Polynomial-Time Algorithms for Counting and Sampling Markov Equivalent DAGs with Applications* [(JMLR)](https://www.jmlr.org/papers/v24/22-0495.html)
+3. Marcel Wienöbst: *Algorithms for Markov Equivalence* [(PhD Thesis)](https://mwien.github.io/thesis.pdf)
 
-Brief examples of how to install and use the implementations are given in the subdirectories.
+## Prototypes
+The prototypes directory contains code I wrote in the context of the papers [1] and [2], which is not maintained anymore. 

cliquepicking_python/examples/count_from_file.py

@@ -0,0 +1,17 @@
+import cliquepicking as cp
+
+# DISCLAIMER: I currently use this for some basic profiling
+# file reading is hacky
+
+filename = "../prototypes/aaai_experiments/instances/peo-4/peo-n=4096-4-nr=1.gr"
+with open(filename, "r") as file:
+    next(file)
+    next(file)
+    input = [tuple(map(int, line.split())) for line in file]
+    cpdag = []
+    for pair in input:
+        cpdag.append((pair[0], pair[1]))
+        cpdag.append((pair[1], pair[0]))
+    print(cp.mec_size(cpdag))
+    sampler = cp.MecSampler(cpdag)
+    print(len(sampler.sample_dag()))

cliquepicking_python/examples/example.py

@@ -0,0 +1,34 @@
+import cliquepicking as cp
+import networkx as nx
+
+G = nx.DiGraph()
+G.add_edge(0, 1)
+G.add_edge(1, 0)
+G.add_edge(0, 2)
+G.add_edge(2, 0)
+G.add_edge(1, 2)
+G.add_edge(2, 1)
+G.add_edge(1, 3)
+G.add_edge(3, 1)
+G.add_edge(1, 4)
+G.add_edge(4, 1)
+G.add_edge(1, 5)
+G.add_edge(5, 1)
+G.add_edge(2, 3)
+G.add_edge(3, 2)
+G.add_edge(2, 4)
+G.add_edge(4, 2)
+G.add_edge(2, 5)
+G.add_edge(5, 2)
+G.add_edge(3, 4)
+G.add_edge(4, 3)
+G.add_edge(4, 5)
+G.add_edge(5, 4)
+print(cp.mec_size(list(G.edges)))
+
+sampler = cp.MecSampler(list(G.edges))
+for _ in range(5):
+    print(nx.DiGraph(sampler.sample_dag()))
+
+for _ in range(5):
+    print(sampler.sample_order())

prototypes/README.md

@@ -0,0 +1,12 @@
+# Prototypes
+
+This directory contains prototypes, which I implemented for [1] and [2]. More precisely:
+
+
+- ```aaai_experiments/``` contains the original C++ implementation and experiments from the AAAI 2021 conference paper (only counting is implemented here)
+- ```cliquepicking_julia/``` contains the subsequent Julia code additionally provides a sampling algorithm
+
+This code is not maintained anymore and is also slower than the Python wrapped Rust code in this repository.
+
+1. Marcel Wienöbst, Max Bannach, and Maciej Liśkiewicz: *Polynomial-Time Algorithms for Counting and Sampling Markov Equivalent DAGs* (AAAI 2021) [arXiv version](https://arxiv.org/abs/2012.09679)
+2. Marcel Wienöbst, Max Bannach, and Maciej Liśkiewicz: *Polynomial-Time Algorithms for Counting and Sampling Markov Equivalent DAGs with Applications* [(JMLR)](https://www.jmlr.org/papers/v24/22-0495.html)