N_0 through BN_15 were generated by randomly connecting copies of the burglar alarm graph.

burgarly_20_0.4_0.3   pe/BN_0.xbif
burgarly_20_0.5_0.2   pe/BN_1.xbif
burgarly_20_0.7_0.2   pe/BN_2.xbif
burgarly_20_0.7_0.3   pe/BN_3.xbif
burgarly_20_0.9_0.5   pe/BN_4.xbif
burgarly_25_0.6_0.5   pe/BN_5.xbif
burgarly_25_0.9_0.6   pe/BN_6.xbif
burgarly_19_0.9_0.3   pe/BN_7.xbif
burgarly_20_0.6_0.1   pe/BN_8.xbif
burgarly_21_0.5_0.1   pe/BN_9.xbif
burgarly_17_0.7_0.2   pe/BN_10.xbif
burgarly_21_0.9_0.4   pe/BN_11.xbif
burgarly_18_0.9_0.1   pe/BN_12.xbif
burgarly_25_0.5_0.1   pe/BN_13.xbif
burgarly_23_0.4_0.3   pe/BN_14.xbif
burgarly_24_0.7_0.1   pe/BN_15.xbif


The burglar alarm network is as follows:

      earthquake   burglary
             /\     /
            /  \   /
           /    \ /
          V      V
announcement   alarm
                 |
                 V

To create these graphs, a fixed number of copies of the burglar alarm graph are created.  One by one, the graph copies are connected to each of the previously considered copies with some probability.  Each variable is then randomly set to be hidden or observed.

Psuedo code for the generation algorithm:

   Generate numberCopies burglary networks

   for i=1..numberCopies {
     for j=1..(i-1) {
       if (radom choice with edgeProbability) {
         add an edge from some variable in copy i to some variable in copy j
       }
     }
     Add an edge from copy i to some (k<i), ensures graph is connected
   }

   foreach variable {
     if (random choice with observationProbability) {
       set variable to observed
     }
     else {
       set variable to hidden
     }
   }

The graph names correspond to the parameters of the generation algorithm:
  burgarly_{numberCopies}_{edgeProbability}_{observationProbability}

------------------------------------------------------------------------------
------------------------------------------------------------------------------

BN_94 to BN_103 were randomly generated.

random/v2/random_53.xbif                          pe/BN_94.xbif
random/v2/random_53.xbif                          mpe/BN_95.xbif
random/v2/random_54.xbif                          pe/BN_96.xbif
random/v2/random_54.xbif                          mpe/BN_97.xbif
random/v2/random_57.xbif                          pe/BN_98.xbif
random/v2/random_57.xbif                          mpe/BN_99.xbif
random/v2/random_58.xbif                          pe/BN_100.xbif
random/v2/random_58.xbif                          mpe/BN_101.xbif
random/v2/random_76.xbif                          pe/BN_102.xbif
random/v2/random_76.xbif                          mpe/BN_103.xbif

The parameters of the graphs are as follows:

 Maximum indegree 3
 Variable state space of 2 to 4
 0.1 probability of nodes being observed
 Observations have a cardinality of 50

The edges are added to the graph with uniform probability over all possible vertex labeled DAGs that meet the criterion.  This is done using an MCMC chain of graphs.

This method was described in:

Jaime S. Ide and Fabio G. Cozman, Random generation of Bayesian networks,
Brazilian Symposium on Artificial Intellegence, Recife, Brazil, 2002

------------------------------------------------------------------------------
------------------------------------------------------------------------------

BN_20 through BN_29 are dynamic Bayesian networks unrolled a specified length.

multiStream_training.200                 pe/BN_20.xbif
multiStream_training.200                 mpe/BN_21.xbif
aurora_training.300                      pe/BN_22.xbif
aurora_training.300                      mpe/BN_23.xbif
aurora_decode.300                        pe/BN_24.xbif
aurora_decode.300                        mpe/BN_25.xbif
CHMM.200                                 pe/BN_26.xbif
CHMM.200                                 mpe/BN_27.xbif
WATER.0                                  pe/BN_28.xbif
WATER.0                                  mpe/BN_29.xbif


The graph multiStream_training is for training a speech recognition system using two asynchronous feature streams.  It was unrolled 200 times giving it a total of 203 frames.  This graph was based on one given in:

   Y. Zhang, Q. Diao, S. Huang, W. Hu, C. Bartels, and J. Bilmes. DBN based
   multi-stream models for speech. In Proc. ICASSP, Hong Kong, China, April 2003

The graph aurora_training is for training a speech recognition system a single feature stream, and aurora_decode is a recognition graph.  Both of these graphs were unrolled 300 times yielding 303 total frames.  These graphs were originally given in:

   J. Bilmes, G. Zweig, and et. al. Discriminatively structured dynamic graphical
   models for speech recognition. In In Final Report: JHU 2001 Summer Workshop,
   2001.

The next graph is a coupled Hidden Markov Model (CHMM) for an image processing task where each process is coupled to its neighboring processes (left and right).  It was unrolled to 202 frames.  The CHMM graph was created by Franz Pernkopf.

The WATER graph is a DBN for monitoring the biological processes of a water purification plant.  In this case the DBN was not unrolled, giving only the two frames defined by the template.  This graph was given in:

   X. Boyen and D. Koller.  Tractable inference for complex stochastic
   processes.  In Proceedings of the 14th Conference on Uncertainty in
   Artificial Intelligence (UAI), 1998.


---------------------------------------------------
---------------------------------------------------


Networks:
--------


BN_30 to BN_41:
---------------

Each of these networks arranges nodes in a grid-like pattern. 
These networks were developed at the University of Washington 
and used in experimental results from [1]. The networks listed 
below go from easiest to most difficult. For the P(e) and MPE
queries the evidence nodes and their observed values were chosen 
uniformly randomly.

[1] Tian Sang, Paul Beame, and Henry Kautz. Solving Bayesian 
Networks by Weighted Model Counting. Proceedings of the Twentieth 
National Conference on Artificial Intelligence (AAAI-05). 
Pages 475-482. Volume 1. 2005.


BN_42 to BN_46:
--------------

Each of these networks is formed from an ISCAS 85 circuit [1] by 
putting a uniform distribution on inputs. For the P(e) and MPE
queries the evidence nodes and their observed values were
chosen uniformly randomly.

[1] F. Brglez and H. Fujiwara. A neutral netlist of 10 combinatorial
benchmark circuits and a target translator in fortran. In 
Proceedings of the IEEE International Symposium on Circuits and
Systems, June 1985.



BN_47 to BN_68:
--------------

Each of these networks is formed from an ISCAS 89 circuit [1] by 
removing flip-flops in a standard way and putting a uniform 
distribution on inputs. For the P(e) and MPE queries the evidence 
nodes and their observed values were chosen uniformly randomly.

[1] F. Brglez, D. Bryant and K. Kozminski. Combinational Profiles
of Sequential Benchmark Circuits. In Proceedings of the IEEE 
International Symposium on Circuits and Systems, 1989, pp 1929-1934.


BN_69 to BN_77:
--------------

Each of these networks is an instance of a genetic linkage analysis 
problem. They are publicly available in a different format from 
Superlink's website [1]. These networks were created from the other 
format (Superlink) using the method discussed in [2]. This model is 
appropriate for P(e).

[1] Superlink's web site, http://bioinfo.cs.technion.ac.il/superlink/

[2] Fishelson, M. and Geiger, D. Exact Genetic Linkage Computations 
for General Pedigrees. Bioinformatics, 2002; 18 Suppl. 1: S189-S198.

BN_78 to BN_93:
--------------

These are medical diagnosis networks derived from the Computer-Based
Patient Care Simulation system, and based on INTERNIST-1 and Quick
Medical Reference (QMR) expert systems [1]. The nodes in CPCS networks
correspond to diseases and findings. Representing it as a belief network
requires some symplifying assumptions: conditional independencies of
findings given diseases, noisy-OR dependencies between diseases and
findings and marginal independencies of diseases. For the P(e) and MPE
queries the evidence nodes and their observed values were chosen 
uniformly randomly.


[1] M. Pradhan, G. Provan, B. Middleton and M. Henrion. Knowledge
engineering for large belief networks. In Proceedings of Tenth
Conference on Uncertainty in Artificial Intelligence (UAI-94).

5/14/09: Note that Joris Mooij states that the original networks can
be found at:

https://mulcyber.toulouse.inra.fr/scm/viewvc.php/ergo/?root=costfunctionlib&pathrev=51


BN_104 to BN_113:
----------------

The structure of these networks corresponds to a directed partial k-tree 
with clique size k=24 (40% of the edges were deleted while maintaining 
the graph connectivity). All nodes are bi-valued. For each CPT, 75% of 
its entries were randomly set to either 0 or 1. The remaining 25% of the
entries were generated uniformly randomly in the range (0,1). For the 
P(e) and MPE queries the evidence nodes and their observed values were 
chosen uniformly randomly.

BN_114 to BN_125:
----------------

The structure of these networks is identical to BN_104--BN_113, except
that for each CPT all entries were generated uniformly randomly in the 
range (0,1). For the P(e) and MPE queries the evidence nodes and their 
observed values were chosen uniformly randomly.


BN_126 to BN_134:
----------------

These are random coding networks from the class of linear block codes.
They can be represented as four-layer belief networks. The second and
third layer correspond to input information bits and parity check
bits respectively. Each parity check bit represents a XOR function
of input bits. Input and parity check nodes are binary while the output
nodes are real-valued. Each layer has the same number of nodes because
a code rate of R=K/N=1/2 is used, where K is the number of input bits
and N is the number of transmitted bits. 

Given a number of input bits (K=128), number of parents (P=4) for each 
XOR bit and channel noise variance (sigma=0.40), a coding network
structure is generated by randomly picking parents for each XOR node.
Then, an input signal is simulated by a assuming a uniform random 
distribution of information bits, the corresponding values of the parity
check bits are computed, and an assignment to the output nodes is 
generated by assuming adding a Gaussian noise to each information and 
parity check bit. The decoding algorithm takes as input the coding 
network and the observed real-valued output assignment and recovers the
original input bit vector by computing an MPE tuple, as discussed in [1]. 


[1] K. Kask and R. Dechter. Mini-bucket heuristics for improved search.
In Proceedings of Uncertainty in Artificial Intelligence (UAI-99). 1999