mspronesti / baylib

High-performance library for approximate inference on discrete Bayesian networks on GPU and CPU

baylib C++ library

Baylib is a parallel inference library for discrete Bayesian networks supporting approximate inference algorithms both in CPU and GPU.

Main features

Here's a list of the main requested features:

• Copy-On-Write semantics for the graph data structure, including the conditional probability table (CPT) of each node
• parallel implementation of the algorithms either using C++17 threads or GPGPUU optimization
• GPGPU optimization implemented with opencl, using boost compute and CUDA.
• template-based classes for probability format
• input compatibility with the XDSL format provided by the SMILE library
• cmake-based deployment

Currently supported algorithms

• Gibbs Sampling - C++11 threads
• Likelihood Weighting - C++11 threads
• Logic Sampling - GPGPU with boost compute
• Rejection Sampling - C++11 threads
• Adaptive importance sampling - C++11 threads, GPGPU with boost compute

algorithm	evidence	deterministic nodes	multi-threading	GPGPU-OpenCL	GPGPU - CUDA
gibbs sampling	✓	*	✓
likelihood weighting	✓	✓	✓		✓
logic sampling	✓	✓		✓	✓
rejection sampling	✓	✓	✓
adaptive importance sampling	✓	✓	✓	✓

*It's a very well-known limitation of the Gibbs sampling approach

Dependencies

• cmake >= 2.8
• boost >= 1.65
• libtbb
• [optional] ocl-icd-opencl
• [optional] mesa-opencl-icd

In order to use the cuda algorithms the system must be cuda compatible and the relative cuda toolkit must be installed.

Under Linux, you can install the required dependencies using the provided script install_dependencies.sh as follows

 cd scripts/
 chmod u+x install_dependencies.sh
./install_dependencies.sh

Install baylib

Using the cmake FetchContent directives you can directly setup baylib as follows

include(FetchContent)

FetchContent_Declare(
        baylib
        GIT_REPOSITORY https://github.com/mspronesti/baylib.git
)

FetchContent_MakeAvailable(baylib)
# create your executable 
# and whatever you need for
# your project ...
target_link_libraries(<your_executable> baylib)

Alternatively under Linux or MacOS, you can run the provided script install.sh as follows

cd scripts/
chmod u+x install.sh
sudo ./install.sh

another option for the script is running the following commands (assuming you're in the root of the project):

mkdir build
cd build
cmake ..
make
sudo make install

You can now include baylib in your projects.

In the latter two cases, make sure your CMakeLists.txt looks like this

find_package(baylib)
# create your executable 
# and whatever you need for
# your project ...
target_link_libraries(<your_executable> baylib)

Usage

Baylib allows performing approximate inference on Bayesian Networks loaded from xdsl files or created by hand (either using named nodes or numeric identifiers).

Have a look at examples for more.

External references

• copy-on-write
• gibbs sampling
• likelihood weighting
• likelihood weighting pseudo-code
• logic sampling
• rejection sampling pseudo-code
• adaptive importance sampling

baylib's Issues

terminate called after throwing an instance of 'std::future_error' what(): std::future_error: No associated state

compute_network_marginal_probabilities produces the following crash:

terminate called after throwing an instance of 'std::future_error'
  what():  std::future_error: No associated state

The issue can be reproduced assigning element 0 and 1 to results while running on the ventureBN.xdsl network. One of the two future<shared_ptr<bcvec>> is empty despite cnmp running correctly.

Convert CPT from file to algorithm format

The logic_sampling algorithm requires a specific format for the CPT:

in the image we can see an example taken from https://repo.bayesfusion.com/bayesbox.html, the CPT must be represented as a contiguous vector, the order in which the probabilities must be reported is by column, e.g. the set of related probabilities must be contiguous, the order in which the parents is presented is very important as it will be used to interpret the CPT vector.
From the image presented the derived CPT vector is:
{0.8, 0.2, 0.8, 0.2, 0.8, 0.2, 0.05, 0.095}
with the parents passed as:
{Increased_serum_calcium, Brain_Tumor}

condition should be pruned and reasserted before discarding it

Let X be a random variable of the Bayesian network.
Let P be the set of parents of X.
Let Y be a random variable not included in P.
From basic notions of conditional probability, P( X | P U Y) = P( X | P) therefore, if a condition contains couples node-state not being actual dependencies of X, I suggest pruning the condition before discarding it (the current assertion discards it once a non-parent is detected)

fix include protections according to new renaming

Consider using TBB to further parallelize std algorithms

To properly use TBB, install it with

sudo apt install libtbb-dev

(don't forget to add the above line to scripts/install_dependencies.sh).
Then add the following lines to baylib/CMakeLists.txt

find_package(TBB REQUIRED)
...
set(BAYLIB_REQUIRED_LIBS
     ...
     tbb
)

Continuous Integration testing reveals a deadlock for parallel executions of logic sampling

Gibbs Sampling doesn't work properly for large networks

Add synchronization wrapper to logic_sampling

logic_sampling should be wrapped into a packaged task with std::asych and std::promise for the graph parallelization step

add more example files to show library usage

add documentation (Doxygen)

First install flex and bison

sudo apt install flex
sudo apt install bison

then clone the official repository

git clone https://github.com/doxygen/doxygen.git
cd doxygen

build

mkdir build
cd build
cmake -G "Unix Makefiles" ..
make

and force a clean install of doxygen

sudo make install

Create a doc directory in the root of this project and run the following command to have a template of a doxygen configuration file

doxygen -g doxy-config

edit doxy-config with your favorite text editor (e.g. vi) to specify the value of the INPUT variable. For instance

INPUT                  = ../baylib \
                         ../baylib/graph \
                         ../baylib/inference \
                         ../baylib/network \
                         ../baylib/parser  \
                         ../baylib/probability \
                         ../baylib/tools \
                         ../baylib/tools/cow \
                         ../baylib/tools/gpu \
                         ../baylib/tools/random 

Eventually, run

doxygen doxy-config

to produce the documentation both in html and latex format.

`add_variable` must check if another node has an identical cpt

When adding a new variable, the add_variable method must check whether another node already has an identical cpt. If it the case, it must be assigned through copy-on-wright facilities

Parser is no longer compatible with bayesian_network

2 options:

• adapt previous parser to the new bn representation
• provide a constructor for bayesian_network receiving a file to perform this task

Don't forget to add tests.

migrate to a multiple CMake configuration for the project

OpenCL algorithms very rarely cause segfault

Very rarely opencl algorithms that use boost compute cause a segfault, I wasn't able to track down the leading cause as it happens with a very low probability and I didn't manage to reproduce it for now.
A minimal reproducible example is needed.

Consider migrating to boost::labeled_graph

boost::labeled_graph offers an easy and friendly infrastructure to better use labels on templated bayesian network.

typedef adjacency_list<
        listS,
        vecS,
        bidirectionalS,
        Vertex
> Graph;

typedef labeled_graph <Graph, Label> LabeledGraph;

GPU memory limitations might be problematic

Our logic sampling implementation is limited mainly by how much memory we can use on the GPU, a possible problem could arise when trying to use more memory than the device has available, the solution is to simply rerun the algorithm in separate instances and accumulate the results.

Implement a thread pool manager wrapper to schedule tasks

Segmentation fault (core dumped) on python binding of inference algorithms

I suspect I'm not using properly the following two macros:

• PYBIND11_OVERLOAD
• PYBIND11_OVERLOAD_PURE

I followed the official doc , yet it's not working