On the Relative Expressiveness of Bayesian and Neural Networks

TL;DR

This paper compares the expressiveness of neural networks and Bayesian networks, showing neural networks are more expressive and proposing an augmentation to Bayesian networks to enhance their approximation capabilities.

Contribution

It identifies key differences in the functions computed by neural and Bayesian networks and introduces a testing operator to make Bayesian networks more universally approximating.

Findings

Neural networks are more expressive than Bayesian network queries.

A simple augmentation can make Bayesian networks universal approximators.

The proposed method enhances Bayesian networks' functional approximation capabilities.

Abstract

A neural network computes a function. A central property of neural networks is that they are "universal approximators:" for a given continuous function, there exists a neural network that can approximate it arbitrarily well, given enough neurons (and some additional assumptions). In contrast, a Bayesian network is a model, but each of its queries can be viewed as computing a function. In this paper, we identify some key distinctions between the functions computed by neural networks and those by marginal Bayesian network queries, showing that the former are more expressive than the latter. Moreover, we propose a simple augmentation to Bayesian networks (a testing operator), which enables their marginal queries to become "universal approximators."

Tables

Table 1. Table 1: Functions f 1 , … , f 5 subscript 𝑓 1 … subscript 𝑓 5 f_{1},\ldots,f_{5} and their TAC and AC approximations.

$i$	$f_i(x,y)$	learned TAC function	learned AC function
1
2
3
4
5

Table 2. Table 2: Functions g 1 subscript 𝑔 1 g_{1} and g 2 subscript 𝑔 2 g_{2} and their TAC approximations with increasing number of testing nodes.

$i$	$g_i(x,y)$	4-test TBN	8-test TBN	16-test TBN
1
2

Equations

$$\begin{array}[]{cc|c}U&X&\\ \hline\cr u&x&\theta_{x|u}\\ u&\bar{x}&\theta_{\bar{x}|u}\\ \hline\cr\bar{u}&x&\theta_{x|\bar{u}}\\ \bar{u}&\bar{x}&\theta_{\bar{x}|\bar{u}}\\ \end{array}$$

$$\begin{array}[]{cc|c|cc}U&X&&&\\ \hline\cr u&x&T_{u}&\theta^{+}_{x|u}&\theta^{-}_{x|u}\\ u&\bar{x}&&\theta^{+}_{\bar{x}|u}&\theta^{-}_{\bar{x}|u}\\ \hline\cr\bar{u}&x&T_{\bar{u}}&\theta^{+}_{x|\bar{u}}&\theta^{-}_{x|\bar{u}}\\ \bar{u}&\bar{x}&&\theta^{+}_{\bar{x}|\bar{u}}&\theta^{-}_{\bar{x}|\bar{u}}\\ \end{array}$$

$$\begin{array}[]{cc|c}U&X&\\ \hline\cr u&x&\theta^{+}_{x|u}\\ u&\bar{x}&\theta^{+}_{\bar{x}|u}\\ \hline\cr\bar{u}&x&\theta^{+}_{x|\bar{u}}\\ \bar{u}&\bar{x}&\theta^{+}_{\bar{x}|\bar{u}}\\ \end{array}\qquad\begin{array}[]{cc|c}U&X&\\ \hline\cr u&x&\theta^{+}_{x|u}\\ u&\bar{x}&\theta^{+}_{\bar{x}|u}\\ \hline\cr\bar{u}&x&\theta^{-}_{x|\bar{u}}\\ \bar{u}&\bar{x}&\theta^{-}_{\bar{x}|\bar{u}}\\ \end{array}\qquad\begin{array}[]{cc|c}U&X&\\ \hline\cr u&x&\theta^{-}_{x|u}\\ u&\bar{x}&\theta^{-}_{\bar{x}|u}\\ \hline\cr\bar{u}&x&\theta^{+}_{x|\bar{u}}\\ \bar{u}&\bar{x}&\theta^{+}_{\bar{x}|\bar{u}}\\ \end{array}\qquad\begin{array}[]{cc|c}U&X&\\ \hline\cr u&x&\theta^{-}_{x|u}\\ u&\bar{x}&\theta^{-}_{\bar{x}|u}\\ \hline\cr\bar{u}&x&\theta^{-}_{x|\bar{u}}\\ \bar{u}&\bar{x}&\theta^{-}_{\bar{x}|\bar{u}}\\ \end{array}$$

$$\begin{array}[]{cc|rl|rlrl}H&Y&&&\\ \hline\cr h&y&T_{h}=&t&\theta^{+}_{y|h}=&1&\theta^{-}_{y|h}=&0\\ h&\bar{y}&&&\theta^{+}_{\bar{y}|h}=&0&\theta^{-}_{\bar{y}|h}=&1\\ \hline\cr\bar{h}&y&T_{\bar{h}}=&1-t&\theta^{+}_{y|\bar{h}}=&0&\theta^{-}_{y|\bar{h}}=&1\\ \bar{h}&\bar{y}&&&\theta^{+}_{\bar{y}|\bar{h}}=&1&\theta^{-}_{\bar{y}|\bar{h}}=&0\\ \end{array}$$

$$\begin{array}[]{cc|c}X&S&\Theta_{S|x}\\ \hline\cr x_{1}&s&\lambda_{1}\\ x_{1}&\bar{s}&1-\lambda_{1}\\ \vdots&\vdots&\vdots\\ x_{k}&s&\lambda_{k}\\ x_{k}&\bar{s}&1-\lambda_{k}\\ \end{array}$$

$$\frac{P(x_1|s)}{P(x_1)}:\dots :\frac{P(x_k|s)}{P(x_k)}={\lambda }_1:\dots :{\lambda }_k.$$

$$\theta_{x|{\bf u}}=\left\{\begin{array}[]{ll}\theta^{+}_{x|{\bf u}}&\mbox{if ${\cal P}^{\star}({\bf u})\geq T_{X|{\bf u}}$}\\ \theta^{-}_{x|{\bf u}}&\mbox{otherwise.}\end{array}\right.$$

$$f(x,T)=\left\{\begin{tabular}[]{rl}$\theta^{+}$&\mbox{if $x\geq T$}\\ $\theta^{-}$&\mbox{otherwise.}\end{tabular}\right.$$

$$\theta_{y\mid{\bf y},i}=\left\{\begin{tabular}[]{rl}1&\mbox{if ${\bf y}$ sets variable $Y_{i}$ to value $y$}\\ 0&\mbox{otherwise}\end{tabular}\right.$$

$$\begin{array}[]{cc|rl|rlrl}Z&Y_{i}&&&\\ \hline\cr z&y_{i}&T_{z}=&f^{-1}(\frac{i}{N})&\theta^{+}_{y_{i}|z}=&1&\theta^{-}_{y_{i}|z}=&0\\ z&\bar{y}_{i}&&&\theta^{+}_{\bar{y}_{i}|z}=&0&\theta^{-}_{\bar{y}_{i}|z}=&1\\ \hline\cr\bar{z}&y_{i}&T_{\bar{z}}=&1-f^{-1}(\frac{i}{N})&\theta^{+}_{y_{i}|\bar{z}}=&0&\theta^{-}_{y_{i}|\bar{z}}=&1\\ \bar{z}&\bar{y}_{i}&&&\theta^{+}_{\bar{y}_{i}|\bar{z}}=&1&\theta^{-}_{\bar{y}_{i}|\bar{z}}=&0\\ \end{array}$$

$$\begin{array}[]{cc|cc}Z&Y_{i}&&\\ \hline\cr z&y_{i}&\theta_{y_{i}|z}=&1\\ z&\bar{y}_{i}&\theta_{\bar{y}_{i}|z}=&0\\ \hline\cr\bar{z}&y_{i}&\theta_{y_{i}|\bar{z}}=&1\\ \bar{z}&\bar{y}_{i}&\theta_{\bar{y}_{i}|\bar{z}}=&0\\ \end{array}\qquad\qquad\begin{array}[]{cc|cc}Z&Y_{i}&&\\ \hline\cr z&y_{i}&\theta_{y_{i}|z}=&0\\ z&\bar{y}_{i}&\theta_{\bar{y}_{i}|z}=&1\\ \hline\cr\bar{z}&y_{i}&\theta_{y_{i}|\bar{z}}=&0\\ \bar{z}&\bar{y}_{i}&\theta_{\bar{y}_{i}|\bar{z}}=&1\\ \end{array}$$

$${\mathcal{P}}^{\star }(y)$$

$$f(\lambda )=a\lambda +bF(\lambda )=\frac{a\lambda +b}{c\lambda +d}$$

$$f({\lambda }_1,{\lambda }_2)=a{\lambda }_1{\lambda }_2+b{\lambda }_1+c{\lambda }_2+dF({\lambda }_1,{\lambda }_2)=\frac{a{\lambda }_1{\lambda }_2+b{\lambda }_1+c{\lambda }_2+d}{e{\lambda }_1{\lambda }_2+f{\lambda }_1+g{\lambda }_2+h}$$

$$P^{\star }(q)=\sum _I{C}_I\prod _{i\in I}{\lambda }_i.$$

$$P^{\star }(\mathbf{x})$$

$$P^{\star}(q)=\sum_{I}C_{I,r}\prod_{i\in I}\lambda_{i},\mbox{ for vectors $\lambda_{1},\ldots,\lambda_{n}$ in region $r$.}$$

$${\theta }_{x|\mathbf{u}}$$

$${\tau }_{\mathbf{u}}$$

$$\frac{1}{N}\sum _{i=1}^N(TAC({\lambda }_i)-y_i{)}^2.$$

$${\theta }_x=\frac{1}{1+\exp \{-{\tau }_x\}}{\theta }_{\bar{x}}=\frac{\exp \{-{\tau }_x\}}{1+\exp \{-{\tau }_x\}}$$

Full text

1 Introduction

The field of artificial intelligence (AI) has seen two major milestones throughout its history. Shortly after the field was born in the 1950s, the focus turned to symbolic, model-based approaches, which were premised on the need to represent and reason with domain knowledge, and exemplified by the use of logic to represent such knowledge [23]. In the 1980s, the focus turned to probabilistic, model-based approaches, as exemplified by Bayesian networks and probabilistic graphical models more generally (first major milestone) [28]. Starting in the 1990s, and as data became abundant, these probabilistic models provided the foundation for much of the research in machine learning, where models were learned either generatively or discriminatively from data. Recently, the field shifted its focus to numeric, function-based approaches, as exemplified by neural networks, which are trained discriminatively using labeled data (deep learning, second major milestone) [13, 15, 1, 31, 32, 24]. Perhaps the biggest surprise with the second milestone is the extent to which certain tasks, associated with perception or limited forms of cognition, can be approximated using functions (i.e., neural networks) that are learned purely from labeled data, without the need for modeling or reasoning [11].

While this evolution of the field has increased our abilities, the emerging techniques have been pursued by somewhat independent research communities. The price has been a lack of enough integration and fusion of the various methods, which hinders the realization of their collective benefits. Logic provides a rich framework for representing knowledge in the form of domain constraints and comes with profound reasoning mechanisms. Probabilistic graphical models excel at capturing uncertainty, causal knowledge, and independence information. Both of these frameworks provide a foundation for capturing domain knowledge of various types and for reasoning with such knowledge. Neural networks are effective function approximators, allowing one to approximate specific and narrow tasks by simply fitting a complex function (i.e., deep neural network) to data in the form of input-output pairs—again, without the need for modeling or reasoning.

Each of these frameworks has its shortcomings though. Symbolic models are too coarse to capture certain phenomena and, in their pure form, miss out on exploiting data and the wealth of information it may contain. Probabilistic graphical models, in their generative form, address this limitation especially when they integrate symbolic knowledge. However, in their discriminative form, these models have been outperformed by neural networks as a realization of the function-based approach to AI. While most of the recent success in AI has been due to neural networks, we are now starting to realize their limits too: they are data hungry, may not generalize beyond the given data, can be quite brittle, and pose challenges for explanation and verification. Interestingly, it is these shortcomings that models, whether symbolic or probabilistic, can help alleviate.

Hence, a key challenge and opportunity for AI today lies in fusing these approaches to realize their collective benefits.111We distinguish between integration and fusion. Integration may refer to an intelligent agent architecture in which the components are based on different approaches, but work together to complement each other. Fusion may refer to a model-based approach that is empowered by functions, or a function-based approach that is empowered by models. Our focus in this paper is on fusion, particularly the empowerment of function-based approaches with domain knowledge (i.e., models). We take some initial steps towards this goal in this paper by showing how models can empower the function-based approach to AI. We focus on probabilistic graphical models in the form of Bayesian networks, but our interest is ultimately in models that combine probabilistic and symbolic knowledge; see, e.g., [34, 19, 29, 14, 26]. We start with a set of observations that are known in the literature but that together lead to a dilemma. Our main contribution is a resolution to this dilemma, which we argue has major implications on the quest of fusing model-based and function-based approaches to AI.

Our observations are as follows. First, a query posed to a Bayesian network model can be viewed as inducing (and evaluating) a function, which can be represented using an Arithmetic Circuit (AC) [9, 5]. Next, Bayesian network queries (and, hence, ACs) can be trained discriminatively using labeled data and gradient descent methods, leading to a realization of the function-based approach currently practiced using neural networks—except that a neural network represents only one function, while a Bayesian network represents many functions (one for each query). Finally, the functions induced by Bayesian network queries can integrate background knowledge of various forms, suggesting a more principled, if not more sophisticated, function-based approach compared to neural networks. Now the dilemma: recent developments in AI indicate that neural networks outperform Bayesian networks, and probabilistic graphical models more generally, as a realization of the function-based approach, despite the ability of the latter to integrate background knowledge into the learned functions.

Our first contribution towards resolving this dilemma is highlighting the following observation: Bayesian and neural networks induce classes of functions that differ in expressiveness. It is known that neural networks are universal approximators, which means they can approximate any function to an arbitrary small error. However, the functions induced by marginal Bayesian network queries are less expressive as they correspond to multi-linear functions or quotients of such functions (this is also known but was never discussed in this context). Our second contribution: We address this expressiveness gap by proposing a simple extension to Bayesian networks and showing that this extension can also induce functions that are universal approximators. When the newly induced functions are represented by circuits and trained using labeled data, we obtain a function-based approach that is as expressive as neural networks, but that can also integrate the knowledge embodied in a Bayesian network. In other words, we can now synthesize function structures from models and then learn their parameters from labeled data. The resulting function-based approach can therefore benefit from what models have to offer: less dependence on data, improved generality and robustness, better prospects for explainability and the potential for more direct formal guarantees on behavior.

This paper is structured as follows. We review in Section 2 the class of functions induced by neural and Bayesian networks, while identifying the corresponding gap in expressiveness. We then propose a new class of Bayesian networks in Section 3, Testing Bayesian Networks (TBNs), whose queries can be computed using Testing Arithmetic Circuits (TACs) that we discuss in Section 4. We show in Section 5 that these functions are universal approximators and reveal their specific functional form in Section 6. We then show some experimental results in Section 7 and conclude in Section 8. The appendices include the method we used to train TACs from labeled data, the full proof of the universal approximation theorem, and an algorithm for compiling TBN queries into TACs.

2 Technical Background

We next review the class of functions represented by neural networks. We also highlight previous results, allowing us to view Bayesian network queries as inducing and evaluating functions. The goal is to pinpoint an expressiveness gap between the two classes of functions, which we address in Section 3.

2.1 Neural Networks as Functions

A (feedforward) neural network is a directed acyclic graph (DAG); see Figure 1(a). The roots of the DAG are the neural network inputs, call them $X_{1},\ldots,X_{n}$. The leaves of the DAG are the neural network outputs, call them $Y_{1},\ldots,Y_{m}$. Each node in the DAG is called a neuron and contains an activation function $\sigma$; see Figure 1(b). Each edge $I$ in the DAG has a weight $w$ attached to it. The weights of a neural network are its parameters, which are learned from data. Consider a neuron with activation function $\sigma$, inputs $I_{i}$ and corresponding weights $w_{i}$. The output of this neuron is simply $\sigma(\sum_{i}w_{i}\cdot I_{i})$. Thus, one can compute the output $Y_{j}$ of a neural network by simply evaluating neurons, parents before children, which can be done in time linear in the neural network size.

To simplify the discussion, we will assume that a neural network has a single output $Y$. Hence, a neural network represents a function $Y=f(X_{1},\ldots,X_{n})$. A key question here relates to the class of functions that can be represented, or approximated well, by neural networks that use a certain class of activation functions. One example is the sigmoid activation function; see Figure 2. A neural network with only sigmoid activation functions can approximate any continuous function to within an arbitrary error.222A shallow neural network with a single hidden layer is sufficient for universal approximation, but may require exponentially many neurons. A deep neural network may be more succinct for this purpose though. Such neural networks are called universal approximators of continuous functions [16, 7, 22]. Most of the recent neural networks are based on the ReLU activation function, which is simpler than the sigmoid; see Figure 2. Neural networks with ReLUs are also universal approximators of continuous functions [22].

2.2 Bayesian Network Queries as Functions

A Bayesian network is a directed acyclic graph (DAG), where each node is associated with a conditional probability table (CPT). The CPT for node $X$ with parents ${\bf U}$ contains a parameter $\theta_{x|{\bf u}}\in[0,1]$ for each state $x$ of node $X$ and state ${\bf u}$ of parents ${\bf U}$, such that $\sum_{x}\theta_{x|{\bf u}}=1$. A Bayesian network specifies a unique probability distribution over its nodes [28].

Consider now a Bayesian network, some evidence ${\bf e}$ on variables ${\bf E}$ (e.g., symptoms), and let $Y$ be a query variable (e.g., a disease). The probability ${P}(y,{\bf e})$ can be viewed as the output of a function $f({\bf E})$ that maps evidence ${\bf e}$ into a number in $[0,1]$. The function inputs are discrete values of variables ${\bf E}$, but can be continuous values in $[0,1]$ if one uses soft evidence [3] (universal approximation results for neural networks assume that inputs/outputs are in $[0,1]$).

The function $f({\bf E})$ can be represented by an Arithmetic Circuit (AC) containing only multipliers and adders [9, 5]; see Figure 3. Classical inference algorithms for Bayesian networks implicitly construct and evaluate this circuit on the fly [10, Chapter 12], while other approaches explicitly construct this circuit through a compilation process [9, 10]. Consider now the function corresponding to a Bayesian network query ${P}(\alpha)$. It is known that this function is multi-linear (more on this later), regardless of the query $\alpha$ and the underlying Bayesian network [9, 10].333The conditional probability ${P}(\alpha|{\bf e})$ is the quotient of two multi-linear functions. Hence, the functions induced by Bayesian network queries (and ACs) are less expressive than the ones represented by neural networks. This explains why a Bayesian network that is trained discriminatively using labeled data may not outperform a neural network trained on the same data. This is particularly so when the data is generated by a function that is not multi-linear.

Here is our major insight for addressing this expressiveness gap, which is based on a simple but consequential observation. It is known that if each activation function of a neural network is a polynomial, then the neural network can only represent polynomials [22]. Moreover, neural networks with linear activation functions can only represent linear functions. Consider now the ReLU activation function $\sigma(x)=\max(0,x)$, which leads to a universal approximator. This function equals 0 if $x<0$ and equals $x$ otherwise; see Figure 2. Hence, it is two linear functions augmented with a simple test, $x<0,$ for selecting one of them. What this tells us is that we can turn ACs into universal approximators by only augmenting them with testing units. We show this later, leading to Testing Arithmetic Circuits (TACs). In fact, the notion of testing can be integrated directly into Bayesian networks, leading to Testing Bayesian Networks (TBNs). A TAC computes a TBN query, just like an AC computes a Bayesian network query.

3 Testing Bayesian Networks

The concept of a Testing Bayesian Network (TBN) is relatively simple. In a nutshell: it is a Bayesian network whose CPTs are selected dynamically based on the given evidence.

Consider a Bayesian network that contains a binary node $X$ having a single binary parent $U$. The CPT for node $X$ contains one distribution on $X$ for each state $u$ of its parent:

[TABLE]

In a TBN, node $X$ may be testing. In this case, we need two distributions on $X$ for each state $u$ of its parent. Moreover, we need a threshold for each state $u$, which is used to select one of these distributions:

[TABLE]

The selection of distributions utilizes the posterior on parent $U$ given evidence on $X$’s ancestors. For parent state $u$, the selected distribution on $X$ is $(\theta^{+}_{x|u},\theta^{+}_{\bar{x}|u})$ if the posterior on $u$ is $\geq T_{u}$; otherwise, it is $(\theta^{-}_{x|u},\theta^{-}_{\bar{x}|u})$. For parent state $\bar{u}$, the distribution is $(\theta^{+}_{x|\bar{u}},\theta^{+}_{\bar{x}|\bar{u}})$ if the posterior on $\bar{u}$ is $\geq T_{\bar{u}}$; otherwise, it is $(\theta^{-}_{x|\bar{u}},\theta^{-}_{\bar{x}|\bar{u}})$. Thus, the CPT for node $X$ is determined dynamically based on the two thresholds and the posterior over parent $U$, leading to one of the following four CPTs:444In general, testing can take other forms such as $>T$, $\leq T$ or $<T$.

[TABLE]

In general, if the parents of testing node $X$ have $n$ states, the selection process may yield $2^{n}$ distinct CPTs. We will now give two illustrative examples of TBNs before we define their syntax and semantics formally.

Consider Figure 4, where all nodes are binary. Node $Y$ is testing and has the following testing CPT:

[TABLE]

Suppose now we have evidence ${\bf e}=x_{1},x_{2},x_{3}$, which pertains to the ancestors of testing node $Y$. In this example, the selected CPT for node $Y$ will be based on the tests ${P}(h\mid{\bf e})\geq T_{h}$ and ${P}(\bar{h}\mid{\bf e})>T_{\bar{h}}$. For parent state $h$, the selected distribution on $(y,\bar{y})$ is $(1,0)$ if ${P}(h\mid{\bf e})\geq T_{h}=t$; otherwise, it is $(0,1)$. For parent state $\bar{h}$, the selected distribution on $(y,\bar{y})$ is $(0,1)$ if ${P}(\bar{h}\mid{\bf e})>T_{\bar{h}}=1-t$; otherwise, it is $(1,0)$.

Nodes $X_{1},X_{2},X_{3}$ and $H$ can be viewed as the basis of a noisy-or classifier as in [35]. That is, we classify an instance $x_{1},x_{2},x_{3}$ positively iff ${P}(h|x_{1},x_{2},x_{3})\geq t$, where $t$ is the classification threshold. The TBN in Figure 4 can then be viewed as implementing this classifier since ${P}(y|x_{1},x_{2},x_{3})=1$ if instance $x_{1},x_{2},x_{3}$ is positive, and ${P}(y|x_{1},x_{2},x_{3})=0$ if the instance is negative.

More generally, we may have multiple testing nodes in a TBN. Figure 4 depicts a TBN with two testing nodes, $B$ and $D$, where all variables are binary. In a classical Bayesian network, we need $18$ parameters to fully specify the network: $2$ for $A$, $4$ for each of $B,C$ and $8$ for $D$. For the TBN, we need $30$ parameters: $4$ additional parameters for $B$ and $8$ additional parameters for $D$. We also need $2$ thresholds for $B$ and $4$ thresholds for $D$.

From now on, we will use BN to denote a classical Bayesian network and TBN for a testing one.

3.1 TBN Syntax

A TBN is a directed acyclic graph (DAG) with two types of nodes: regular and testing, each having a conditional probability table (CPT). Root nodes are always regular. Consider a node $X$ with parents ${\bf U}$.

• –

If $X$ is a regular node, its CPT is said to be regular and has a parameter $\theta_{x|{\bf u}}\in[0,1]$ for each state $x$ of node $X$ and state ${\bf u}$ of its parents ${\bf U}$, such that $\sum_{x}\theta_{x|{\bf u}}=1$ (these are the CPTs used in BNs).

• –

If $X$ is a testing node, its CPT is said to be testing and has a threshold $T_{X|{\bf u}}\in[0,1]$ for each state ${\bf u}$ of parents ${\bf U}$. It also has two parameters $\theta^{+}_{x|{\bf u}}\in[0,1]$ and $\theta^{-}_{x|{\bf u}}\in[0,1]$ for each state $x$ of node $X$ and state ${\bf u}$ of its parents ${\bf U}$, such that $\sum_{x}\theta^{+}_{x|{\bf u}}=1$ and $\sum_{x}\theta^{-}_{x|{\bf u}}=1$.

The parameters of a regular CPT are said to be static and the ones for a testing CPT are said to be dynamic.

Consider a node that has $m$ states and its parents have $n$ states. If the node is regular, its CPT will have $m\cdot n$ static parameters. If it is a testing node, its CPT will have $n$ thresholds and $2\cdot m\cdot n$ dynamic parameters. As we shall discuss later, the thresholds and parameters of a TBN can be learned discriminatively from labeled data (as in deep learning).

3.2 TBN Semantics

A testing CPT corresponds to a set of regular CPTs, one of which is selected based on the given evidence. Once a regular CPT is selected from each testing CPT, the TBN transforms into a BN. In other words, a TBN over DAG $G$ represents a set of BNs over DAG $G$, one of which is selected based on the given evidence. It is this selection process that determines the semantics of TBNs. We define this process next based on soft evidence, which includes hard evidence as a special case.555[6] used soft evidence on root nodes only, which is sufficient for the universal approximation theorem.

Soft evidence on a variable $X$ with states $x_{1},\ldots,x_{k}$ is specified using likelihood ratios $\lambda_{1},\ldots,\lambda_{k}$ [28]. Without loss of generality, we require $\lambda_{1}+\ldots+\lambda_{k}=1$ so $\lambda_{i}=1$ corresponds to hard evidence ${X\!=\!x_{i}}$. Moreover, when node $X$ is binary, soft evidence reduces to a single number $\lambda_{x}\in[0,1]$ since $\lambda_{\bar{x}}=1-\lambda_{x}$.

We will emulate soft evidence by hard evidence on an auxiliary, binary child $S$ with the following CPT:

[TABLE]

We can now take ${P}(.|s)$ as the result of asserting soft evidence on node $X$ since

[TABLE]

Let ${\bf s}$ denote all available soft evidence. We will use ${\cal P}^{\star}(.)$ to denote the conditional distribution ${P}(.|{\bf s})$ and $P^{\star}(.)$ to denote the joint distribution ${P}(.,{\bf s})$.

We now show how a TBN can be converted into a BN, thereby defining the semantics of TBNs. We start with an empty BN and traverse the TBN nodes, parents before children. Suppose we are visiting TBN node $X$ with parents ${\bf U}$. If node $X$ is regular, we add it to the BN as a child of nodes ${\bf U}$, while copying its regular CPT to the BN. If node $X$ is testing, we first use the partially constructed BN to compute the posterior ${\cal P}^{\star}({\bf U})$ using soft evidence on the ancestors of node $X$. Using this posterior, we then select a regular CPT for node $X$ from its testing CPT, e.g., as follows:666The selection can be based on other tests such as ${\cal P}^{\star}({\bf u})>T_{X|{\bf u}}$, ${\cal P}^{\star}({\bf u})\leq T_{X|{\bf u}}$ or ${\cal P}^{\star}({\bf u})<T_{X|{\bf u}}$.

[TABLE]

We finally add node $X$ to the BN as a child of nodes ${\bf U}$ and copy its selected, regular CPT to the BN.

After visiting all nodes in the TBN, the constructed BN will have the same structure as the TBN. We can now use this BN to answer queries using all available evidence, as is normally done.

The dependence of selection on only ancestral evidence is not strictly needed and can sometimes be easily relaxed, but this makes the semantics of TBNs less transparent. We prefer simplicity for now given that this is all we need for our main result on universal approximation.777The dependence of CPT selection on only ancestral evidence can be limiting practically though since not all TBN queries can fully benefit from the power of CPT selection. In the extreme case of evidence laying below testing nodes in a TBN, CPT selection will not be impacted by the available evidence. CPT selection can be easily made to depend on more evidence, beyond ancestral, as long as it does not lead to selection ambiguities (i.e., the selection of one CPT impacting the selection of another). Resolving such potential ambiguities, however, requires a more thorough treatment.

4 Testing Arithmetic Circuits

A Testing Arithmetic Circuit (TAC) is an Arithmetic Circuit (AC) that includes testing units. A testing unit has two inputs, $x$ and $T$, and two parameters, $\theta^{+}$ and $\theta^{-}$. Its output is computed as follows:888A testing unit may employ other tests such as $x>T$, $x\leq T$ or $x<T$.

[TABLE]

Just like an AC computes a BN query (see Figure 3), a TAC computes a TBN query. C provides an algorithm for compiling a TAC that computes a given TBN query.

This algorithm was used to compile the TAC in Figure 5(b), which has four testing units and computes a query on the TBN in Figure 5(a). The TAC inputs $(\lambda_{a},\lambda_{\bar{a}})$ and $(\lambda_{c},\lambda_{\bar{c}})$ represent soft evidence on nodes $A$ and $C$, respectively. Its outputs $P^{\star}(b)$ and $P^{\star}(\bar{b})$ represent the marginal distribution on node $B$. All other TAC inputs correspond to TBN parameters and thresholds: $2$ static parameters for node $A$, $4$ static parameters for node $C$, in addition to $8$ dynamic parameters and $2$ thresholds for node $B$.

As discussed earlier, TBNs are motivated by the recent success of neural networks in learning functions from labeled data. When using a neural network in this context, the function structure is usually handcrafted while its parameters are learned using gradient descent methods. While neural networks have been very successful in this context, they have also been subject to scrutiny due to their opaqueness and inability to integrate domain knowledge in a principled manner. Opaqueness makes neural networks hard to explain and verify. The inability to integrate domain knowledge diminishes their robustness and implies that we may need a massive amount of data to train them successfully.

The structure of a function computed by a TBN query is compiled from the TBN. This structure takes the form of a TAC, which parameters and thresholds can be learned from labeled data using gradient descent methods. The advantage of compiling a function structure from a model, in contrast to handcrafting it, is that we can integrate some forms of background knowledge into the function. For example, all the independence assumptions encoded by the TBN will be respected by the compiled TAC, regardless of how we train it. Moreover, some TBN parameters may already be known and these will be carried into the compiled TAC, without the need to train them from data, therefore reducing the dependence on data. This particularly includes $0/1$ parameters, which correspond to logical domain constraints. Finally, since a TAC is compiled from a TBN, one stands a better chance at explaining and verifying the TAC behavior. One must note though that the expressiveness of a TAC is mandated by the underlying TBN query so it cannot be arbitrarily controlled, as in handcrafted neural networks. We discuss this issue in the next two sections.

5 Expressiveness of TBN Queries and TACs

A central concept relating to expressiveness is that of universal approximation. Consider the class of continuous functions $f(x_{1},\ldots,x_{n})$ from $[0,1]^{n}$ to $[0,1]$. A representation is said to be a universal approximator if it can approximate any function in this class to an arbitrary small error. As mentioned earlier, neural networks with appropriate activation functions are universal approximators.

TBN queries and, hence, TACs are also universal approximators. The following theorem shows this for continuous and monotonic functions $f(x)$. The general (and slightly more involved) case of multivariate, non-monotonic functions is delegated to B.

Theorem 1

Given a continuous, monotonic function $f(x)$ from $[0,1]$ to $[0,1]$ and error $\varepsilon$, there exists a TBN that contains $O(\lceil\frac{1}{\varepsilon}\rceil)$ nodes and that satisfies the following. The TBN contains two binary nodes, $Z$ and $Y$, such that if $x$ is the soft evidence on node $Z$, then $|{\cal P}^{\star}(y)-f(x)\leq\varepsilon|$.

• Proof

Our constructive proof is based on [18] and uses the TBN in Figure 6(a). The TBN has regular nodes $Z,Y$ and $I$, which are discrete. Nodes $Z$ and $Y$ are binary with states $z,\bar{z}$ and $y,\bar{y}$. Node $I$ has values $1,\ldots,N$ and controls the quality of approximation (better approximation for larger $N$). The TBN has testing nodes ${\bf Y}=Y_{1},\ldots,Y_{N}$, which are binary with states $y_{i},\bar{y}_{i}$. The TBN query is to compute the probability of ${Y\!=\!y}$ given soft evidence on node $Z$. The TAC in Figure 6(b) computes this query.

Nodes $Z$ and $I$ have uniform priors. Node $Y$ has the following CPT:

[TABLE]

That is, node $Y$ is equivalent to node $Y_{i}$ when $I=i$. The testing CPT for node $Y_{i}$ is as follows:999We assume, without loss of generality, that $f(0)=0$ and $f(1)=1$.

[TABLE]

Given soft evidence $\lambda_{z}=x$ on node $Z$, the posterior marginal ${\cal P}^{\star}(z)$ is then $x$. We can now select a regular CPT for each testing node $Y_{i}$, which must be one of101010The used tests are ${\cal P}^{\star}(z)\geq T_{z}$ and ${\cal P}^{\star}(\bar{z})>T_{\bar{z}}$. We have ${\cal P}^{\star}(z)\geq T_{z}$ iff $1-{\cal P}^{\star}(z)\leq 1-T_{z}$ iff ${\cal P}^{\star}(\bar{z})\leq T_{\bar{z}}$.

[TABLE]

In either case, $Y_{i}$ will no longer depend on $Z$, leading to the BN structure in Figure 6(c). Using $\theta_{y_{i}}$ to denote $\theta_{y_{i}|z}=\theta_{y_{i}|\bar{z}}$, and noting that ${\cal P}^{\star}(y)=P(y)$ in the selected BN, we get:

[TABLE]

Intuitively, each node $Y_{i}$ is either activated ($\theta_{y_{i}}=1$) or de-activated ($\theta_{y_{i}}=0$), where ${\cal P}^{\star}(y)$ is the proportion of activated nodes. Moreover, by choice of thresholds $T_{z}$ and $T_{\bar{z}}$, as $x$ increases, more nodes $Y_{i}$ get activated. In fact, exactly $\lfloor N\cdot f(x)\rfloor$ are activated, leading to ${\cal P}^{\star}(y)=\frac{1}{N}\lfloor N\cdot f(x)\rfloor$ and $|f(x)-{\cal P}^{\star}(y)|\leq\varepsilon$.   $\Box$

6 The Functional Form of TACs

Consider a TBN that contains some binary nodes, $E_{1},\ldots,E_{n},Q$. Soft evidence on nodes $E_{i}$ corresponds to a vector $\lambda_{1},\ldots,\lambda_{n}$ in $[0,1]^{n}$. Hence, a query that asks for the probability of ${Q\!=\!q}$ given soft evidence will then correspond to a function that maps $[0,1]^{n}$ into $[0,1]$. In Section 5 and B, we provided a universal approximation theorem, showing how each continuous function from $[0,1]^{n}$ into $[0,1]$ can be approximated to an arbitrary error by a TBN query. The construction used a TBN and query that are based on the given function and error. In practice though, the TBN and query are mandated by modeling and task considerations, which may restrict the class of functions that can be learned from data. We next show, however, that regardless of the TBN and query, the induced function must be piecewise multi-linear.

Definition 1

We say that function $f(\lambda_{1},\ldots,\lambda_{n})$ is multi-linear if it has the form $\sum_{I\subseteq\{1,\ldots,n\}}C_{I}\prod_{i\in I}\lambda_{i}$ for some constants $C_{I}$. We say it is linear if it has the form $C_{0}+\sum_{i=1}^{n}C_{i}\lambda_{i}$ for some constants $C_{i}$.

For example, $f(\lambda_{1},\lambda_{2})=a\lambda_{1}\lambda_{2}+b\lambda_{1}+c\lambda_{2}+d$ is multi-linear and $f(\lambda_{1},\lambda_{2})=a\lambda_{1}+b\lambda_{2}+c$ is linear.

We will next illustrate the functional form of BN and TBN queries using concrete examples, then follow by the formal results. We will start by assuming only one evidence node $E$ with soft evidence $\lambda\in[0,1]$. Consider now the following queries:

• —

$f(\lambda)$: the joint probability of ${Q\!=\!q}$ and evidence $\lambda$, $P^{\star}(q)$.

• —

$F(\lambda)$: the conditional probability of ${Q\!=\!q}$ given evidence $\lambda$, ${\cal P}^{\star}(q)$.

Figure 7(a) depicts these functions for a BN $E\rightarrow T\rightarrow Q$ with some arbitrary parameters. Figure 7(b) depicts these functions for a TBN with the same structure, but where node $T$ is testing (again, the parameters and thresholds are arbitrary). For the BN, $f(\lambda)$ is a linear function and $F(\lambda)$ is a quotient of two linear functions. For the TBN, $f(\lambda)$ is a piecewise linear function and $F(\lambda)$ is a piecewise quotient of two linear functions.

More precisely, for BNs with one evidence node, these functions have the following form [2, 17, 20, 8]:

[TABLE]

where the constants $a,b,c,d$ depend only on the BN parameters. For TBNs with one evidence node, the input space $[0,1]$ is partitioned into regions, where functions $f$ and $F$ take the above form but with different constants in each region; see Figure 7(b).

Suppose we now have two evidence nodes $E_{1}$ and $E_{2}$ with soft evidence $\lambda_{1}$ and $\lambda_{2}$. For TBNs, the input space $[0,1]\times[0,1]$ is partitioned into two-dimensional regions. The functional form in each region is:

[TABLE]

Figure 8 depicts examples of $F(\lambda_{1},\lambda_{2})$ corresponding to BN and TBN queries (only one region for the BN).

We now have the following result, showing that BN queries compute multi-linear functions.

Theorem 2

Consider a BN that contains some binary nodes $E_{1},\ldots,E_{n},Q$ and let $\lambda_{1},\ldots,\lambda_{n}$ denote a soft evidence vector on nodes $E_{1},\ldots,E_{n}$. There are constants $C_{I}$ for $I\subseteq\{1,\ldots,n\}$ such that

[TABLE]

• Proof

Consider an instantiation ${\bf x}$ over all network variables. We write ${\bf x}\models x{\bf u}$ to mean that instantiation ${\bf x}$ sets variable $X$ and its parents ${\bf U}$ to $x$ and ${\bf u}$. Let $I^{+}$ be the indices $i$ of evidence variables $E_{i}$ set positively by ${\bf x}$, and let $I^{-}$ be the indices $i$ of evidence variables $E_{i}$ set negatively by ${\bf x}$. We have:

[TABLE]

where $D^{{\bf x}}_{I}$ is either [math], $P({\bf x})=\prod_{{\bf x}\models x{\bf u}}\theta_{x|{\bf u}}$ or $-P({\bf x})$. Hence, $P^{\star}({\bf x})$ is a multi-linear function. Since $P^{\star}(q)=\sum_{{\bf x}\models q}P^{\star}({\bf x})$, it follows that $P^{\star}(q)$ is also multi-linear as it is the sum of multi-linear functions.   $\Box$

The following result shows that TBN queries compute piecewise multi-linear functions.

Theorem 3

Consider a TBN that contains some binary nodes $E_{1},\ldots,E_{n},Q$ and let $\lambda_{1},\ldots,\lambda_{n}$ denote a soft evidence vector on nodes $E_{1},\ldots,E_{n}$. The space $[0,1]^{n}$ can be partitioned into a finite set of regions $R$ that satisfy the following. For each region $r\in R$, there are constants $C_{I,r}$ for $I\subseteq\{1,\ldots,n\}$ such that

[TABLE]

• Proof

For a given soft evidence vector $\lambda_{1},\ldots,\lambda_{n}$, the TBN selects a unique set of CPTs, leading to the selection of a unique BN. There is a finite number of possible selections that a TBN can make, leading to a finite number of BNs. Hence, the soft evidence space of $[0,1]^{n}$ can be partitioned into a finite set of regions $R$, with each region $r\in R$ leading to a unique BN. By Theorem 2, $P^{\star}(q)$ takes the form in Theorem 3.   $\Box$

While TBN queries represent piecewise multi-linear functions, neural networks with ReLU activation functions represent piecewise linear functions [27, 25]. Moreover, there has been work on bounding the number of regions for such functions, depending on the size and depth of neural networks, e.g., [27, 25, 30, 33].

A TBN query can induce different piecewise functions, depending on the TBN parameters and thresholds that are specified or learned from data (Figures 8(b) and 8(d) depict two functions induced by the same TBN query). In particular, these functions may have regions that differ in their nature and count, which impacts how well the learned function fits the training data.

Definition 2

For a piecewise function, the number of regions is called the function granularity. For a TBN query, the query granularity is the maximum granularity attained by any function inducible by that query.

The granularity of a TBN query—and, to an extent, its expressiveness—depends on the location of evidence, query, and testing nodes. For example, in Figure 9, evidence $\lambda_{2}$ on node $E_{2}$ does not impact CPT selection at testing node $Q$ since $E_{2}$ is not an ancestor of $Q$. Hence, the regions are one-dimensional, across evidence $\lambda_{1}$. Contrast this with the TBN query in Figure 8(c). In this case, CPT selection is impacted by evidence on both $E_{1}$ and $E_{2}$, leading to two-dimensional regions as in Figures 8(b) and 8(d).

For completeness, we close this section by the following immediate result.

Theorem 4

The function computed by a neural network with ReLU and step activation functions can be computed by a TAC with size proportional to the neural network size.111111The resulting TAC may have negative parameters and thresholds.

• Proof

A testing unit $f(x,T)$ with parameters $\theta^{+}=1$ and $\theta^{-}=0$ corresponds to a step activation function with threshold $T$. Moreover, such a testing unit can emulate a ReLU $g(x)$ as follows: $g(x)=x\cdot f(x,0)=\max(0,x)$. A neuron with a linear activation function can be simulated by an AC using multipliers and adders. A neuron with a ReLU or step activation functions can be simulated by a TAC using the above AC and the TAC fragment of the activation function.   $\Box$

7 Generalized CPT Selection

TBNs get their expressiveness from the ability to select CPTs based on the available evidence. Selecting CPTs based on threshold tests, e.g., ${\cal P}^{\star}({\bf u})\geq T_{X|{\bf u}}$, is both simple and sufficient for universal approximation. However, one can employ more general and refined selection schemes, which can also facilitate the learning of TAC parameters and thresholds using gradient descent methods. For example, one can use a sigmoid function to select CPTs based on the following equations; see Figure 10:

[TABLE]

Here, $\gamma$ is a meta-parameter that controls the sigmoid slope and $\tau_{\bf u}\in[0,1]$. As $\gamma$ tends to $\infty$, this selection scheme tends towards implementing a threshold test. Moreover, as $\gamma$ tends to [math], the selection tends towards a fixed CPT as in BNs. Threshold tests select a CPT for node $X$ from a finite set of $2^{n}$ different CPTs, where $n$ is the number of states for parents ${\bf U}$. However, the sigmoid selects a weighted average of these CPTs, which is another CPT.121212If $P_{1}(X)$ and $P_{2}(X)$ are distributions, and if $\tau\in[0,1]$, then ${P}(X)=\tau\cdot P_{1}(X)+(1-\tau)\cdot P_{2}(X)$ is also a distribution. The TAC compilation algorithm in C can easily accommodate this more general selection scheme, leading to TACs with sigmoid units that replace testing units.

We next show some results on training TACs to approximate functions using labeled data and gradient descent. We considered the TBN in Figure 8(c), except that we used four testing nodes, $T_{1},\ldots,T_{4}$. We compiled a TAC assuming $E_{1}$ and $E_{2}$ are evidence nodes and $Q$ is the query node.131313The TAC computes the conditional probability of ${Q\!=\!q}$ given soft evidence, ${\cal P}^{\star}(q)$. We then generated labeled data from the following continuous functions, which are visualized in the first column of Table 1.

1. $f_{1}(x,y)=\sin\left(\pi(1-x)(1-y)\right)$
2. $f_{2}(x,y)=\sin\left(\frac{\pi}{2}\cdot(2-x-y)\right)$
3. $f_{3}(x,y)=\frac{1}{2}\cdot e^{-5\cdot(x-\frac{1}{2})^{2}-5\cdot(y-\frac{1}{2})^{2}}$
4. $f_{4}(x,y)=\left(1+e^{-32(y-\frac{1}{2})}\right)^{-1}$
5. $f_{5}(x,y)=\frac{1}{2}\cdot xy(x+y)$

For each one of these functions, each mapping values from $[0,1]^{2}$ to $[0,1]$, we selected data examples $(x,y)$ by dissecting the input space into a $32\times 32$ grid and then recording the resulting values of $f(x,y)$ as labels. We then trained the TAC on this data using TensorFlow by minimizing mean-squared error as described in A.

The second column of Table 1 depicts the TAC approximations of these functions. The TAC approximates well all functions except for $f_{4}$, which is a sigmoid function with a steep slope. For comparison, we also depict the AC approximations of these functions in the third column of Table 1. Since ACs can only represent multi-linear functions or their quotients, we see that only function $f_{5}$ is approximated well. Moreover, the AC approximation of function $f_{4}$ is worse than the TAC approximation (the AC effectively learns a plane).

We now consider two additional functions that are visualized in the first column of Table 2:

1. $g_{1}(x,y)=\frac{1}{2}+\frac{1}{2}\sin(2\pi x)$
2. $g_{2}(x,y)=e^{\sin(\pi(x+y))-1}$

We approximated these functions using the same TBN query in Figure 8(c), but increased the number of testing nodes from $4$ to $8$ and finally to $16$. As the number of testing nodes increased, so did the number of sigmoid units in the compiled TACs. The TAC approximations are depicted in the 2nd, 3rd and 4th columns of Table 2. As we increase the number of sigmoid units in the compiled TACs, we expect their expressiveness to also increase, leading to better approximations. This expectation is confirmed by Table 2.

8 Conclusion

We considered the relative expressiveness of Bayesian and neural networks. Neural networks are “universal approximators” of continuous functions, whereas marginal Bayesian network queries correspond to multi-linear functions (joint queries) or their quotients (conditional queries). We proposed Testing Bayesian Networks (TBN) whose marginal queries are also “universal approximators,” and Testing Arithmetic Circuits (TAC) for computing these queries. Moreover, we showed that marginal TBN queries and their TACs represent piecewise multi-linear functions, while highlighting that neural networks with ReLU activation functions represent piecewise linear functions. Finally, we generalized the concept of CPT selection that is responsible for the expressiveness of TBNs, which facilitated their training using gradient descent.

TBNs and TACs move us a step forward towards fusing model-based and function-based approaches to AI. In particular, they provide a framework for integrating background knowledge into expressive functions that can be learned from labeled data. This can contribute to learning more robust functions based on less data, and to verifying, interpreting and explaining learned functions.

Acknowledgments

We thank Yujia Shen, Andy Shih, and Yaacov Tarko for comments and discussions on this paper. This work has been partially supported by NSF grant #IIS-1514253, ONR grant #N00014-18-1-2561 and DARPA XAI grant #N66001-17-2-4032.

Appendix A Training TACs

We implemented a training algorithm for TACs using TensorFlow, which is based on a symbolic representation of the loss function to be minimized. In this tool, gradients are computed automatically and an optimizer (e.g., gradient descent method) can be used to minimize the given loss function. Using TensorFlow terminology, we assume training data with real-valued features in $[0,1]$ and real-valued labels in $[0,1]$.

TAC inputs assert soft evidence while the TAC output computes the conditional probability of some variable $Q$ given soft evidence. The goal is to learn TAC parameters and thresholds that minimize the difference between TAC outputs and the labels of corresponding training examples. We used mean squared error as our loss function:

[TABLE]

We have $N$ training examples, with the $i$-th example consisting of input vector $\lambda_{i}$ and label $y_{i}$. $TAC(\lambda_{i})$ is the TAC output under input vector $\lambda_{i}$. It is the result of normalizing two TAC nodes for $P^{\star}(q)$ and $P^{\star}(\bar{q})$. Since the parameters of our TAC are probabilities, we use a logistic function to represent them:

[TABLE]

and optimize instead the real-valued meta-parameters $\tau_{x}$. Our training algorithm assumed TACs with sigmoid selection units as given by Equation 1 (we used $\gamma=16$).141414Testing units (see Section 4) are challenging for gradient descent methods as they are not differentiable at $x=T$ and have a zero gradient everywhere else (with respect to input $x$). Finally, while our description of the training algorithm is based on binary variables, the treatment applies directly to multi-valued variables too.

Appendix B Universal Approximation Theorem

We next extend Theorem 1 of Section 5 to non-monotonic functions and then to multivariate functions.

Figure 11(b) depicts a non-monotonic function $f(x)$ from $[0,1]$ to $[0,1]$. To approximate $f(x)$ with a TBN, we first split our function into monotonic pieces as shown in the figure (we used vertical dotted lines to mark the points where the sign of the first derivative $\frac{df}{dx}$ changes).

Consider now the TBN of Figure 12 that approximates this non-monotonic function using the TBN in Figure 6(a) for approximating monotonic functions as a building block (for clarity, in Figure 12, we do not draw node $Z$ on which soft evidence is asserted). Each of the three sub-networks enclosed in a box approximates each of the three monotonic components of our function $f(x)$. Let $a,b$ and $c$ denote the three components, and let $T_{ab}$ and $T_{bc}$ denote the values of $x$ at the two borders. We have a chain of nodes $Y_{a}\to Y_{b}\to Y_{c}$ at the bottom of our network. Node $Y_{a}$ simply copies the value of its parent (its CPT is an equivalence constraint). Node $Y_{b}$ will either copy the value of $Y_{a}$ or the value of its component $b$, depending on whether the input $x$ is below or above the threshold $T_{ab}$. Node $Y_{c}$ will either copy the value of $Y_{b}$ or the value of its component $c$, depending on whether the input $x$ is below are above the threshold $T_{bc}$. Testing nodes $Y^{\prime}_{b}$ and $Y^{\prime}_{c}$ perform these threshold tests and select CPTs that clamp themselves to a particular value, which determines where $Y_{b}$ and $Y_{c}$ copy their values from. This sequence of threshold tests will, given an input $x$, select the approximation of $f(x)$ from the appropriate component, which is finally the probability of $Y_{c}.$ The size of this construction is linear in the number of times the sign of the first derivative changes.

The generalization to multivariate functions is analogous to the approximation of functions using “ridge” and “bump” functions; see, e.g., [18, 21]. First, we use our construction for approximating a univariate function as a building block to approximate a function $f(x_{1},x_{2})$ over two variables. In particular, we construct a TBN for $N$ univariate functions $f_{x_{2}}(x_{1})=f(x_{1},x_{2})$ for $N$ values of $x_{2}$ from [math] to $1$. As we did previously for approximating non-monotonic univariate functions by pieces, we construct a chain of these $N$ TBNs and copy the output of the appropriate component based on the input value of $x_{2}$. To approximate a function $f(x_{1},\ldots,x_{n})$ over $n$ variables, we construct $N$ TBNs that approximate functions $f_{n}(x_{1},\ldots,x_{n-1})$ over $n-1$ variables, and then perform a similar construction.

The error in the approximation can be improved arbitrarily by increasing $N$ (under some assumptions, i.e., the change in $f$ is bounded for small changes in the input). Moreover, this construction is exponential in the number of input variables $n$. Related constructions for showing neural networks (with one or two hidden layers) are “universal approximators” are also exponential in the dimension of the function.

Appendix C Compiling TBN Queries into TACs

A BN query can be compiled into an AC; see Figure 3. Similarly, a TBN query can be compiled into a TAC; see Figure 5. Compiling an AC can be done by keeping a symbolic trace of an elimination algorithm as described in [10, Chapter 12]. We next provide an algorithm for compiling a TAC by keeping a symbolic trace of the factor elimination algorithm described in [10, Chapter 7]. The algorithm assumes TBNs with threshold-based selection, but can be easily adjusted to handle sigmoid-based selection.

C.1 Factor Elimination

A factor $f({\bf X})$ is a mapping from instantiations ${\bf x}$ into positive, real numbers. Factor elimination is a variation on variable elimination [36, 12], in which factors are systematically eliminated according to the following process. Consider a factor $f({\bf X})$, where variables ${\bf Y}\subseteq{\bf X}$ appear only in this factor. To eliminate this factor, we simply sum-out variables ${\bf Y}$ from the factor, leading to $\sum_{\bf Y}f({\bf X})$, and then multiply the result by some other factor.151515Summing-out and multiplication are standard operations on factors; see, e.g., [10, Chapter 6]. We can use this method to compute the marginal on any query variable $Q$ in a BN. We start with the network CPTs as our initial factors. We then identify a factor that contains $Q$ and call it the root factor. We successively eliminate all factors, one by one, except for the root factor. At this point, we are left with a single factor $f({\bf Z},Q)$, where $g(Q)=\sum_{\bf Z}f({\bf Z},Q)$ is the marginal on $Q$. Any elimination order works, but the specific order used impacts the algorithm’s complexity.

We can assert soft evidence $(\lambda_{1},\ldots,\lambda_{k})$ on a variable $X$ by adjusting its CPT as follows. The entry of each row corresponding to value $x_{i}$ of $X$ is multiplied by $\lambda_{i}$. If we have evidence, the computed factor $g(Q)$ needs to be normalized to obtain the posterior distribution on variable $Q$.

C.2 Symbolic Factor Elimination

A TBN query can be compiled into a TAC by keeping a symbolic trace of the factor elimination algorithm. This requires working with symbolic factors, whose entries are circuit nodes instead of numbers, and is analogous to compiling a BN into an AC by keeping a symbolic trace of elimination algorithms [4, 10]. We next illustrate these concepts by providing an example of compiling an AC for a BN query. We then show how the technique can be extended to compiling TACs, also using a concrete example. We then follow by a formal statement of the compilation algorithm and its complexity.

Consider a BN over binary variables $A,B,C$ with edges $A\to B$ and $A\to C$ and the following CPTs.

[TABLE]

[TABLE]

[TABLE]

Suppose we have soft evidence on variables $A$ and $C$ and want to compile an AC that computes the marginal $(P^{\star}(b),P^{\star}(\bar{b}))$. We start with the following CPTs that incorporate evidence (we use ${+(n_{1},n_{2})}$ and ${*(n_{1},n_{2})}$ to denote sum and product circuit nodes with $n_{1}$ and $n_{2}$ as their children).

[TABLE]

[TABLE]

[TABLE]

Our root factor is $\Theta_{B|A}$. We will eliminate factor $\Theta_{C|A}$ first. Summing out variable $C$ from the factor gives

[TABLE]

Multiplying the result by factor $\Theta_{A}$, we get

[TABLE]

Our set of factors are now

[TABLE]

[TABLE]

Eliminating the recently constructed factor, we now have

[TABLE]

Summing out variable $A$ gives

[TABLE]

We have now compiled a circuit whose outputs, $n_{15}$ and $n_{16}$, give the marginal for variable $B$; see Figure 13. The inputs to this circuits are the vectors $(\lambda_{a},\lambda_{\bar{a}})$ and $(\lambda_{c},\lambda_{\bar{c}})$ representing soft evidence, in addition to network parameters. Dividing nodes $n_{15}$ and $n_{16}$ by their sum yields the posterior $({\cal P}^{\star}(b),{\cal P}^{\star}(\bar{b}))$.

One can prune the Bayesian network before compiling an AC. In particular, one can successively remove leaf variables as long as they are not query or evidence variables.

C.3 Compiling TACs via Symbolic Factor Elimination

Beyond sum and product nodes, TACs also use testing nodes ${[p\geq t\>?\>n^{+}:n^{-}]}$, which pass through the value of $n^{+}$ if $p\geq t$ and the value of $n^{-}$ otherwise (like a multiplexer).

Compiling TACs is similar to compiling ACs but requires two phases. In the first phase, we select CPTs for all testing nodes that are relevant to the query. In the second phase, we perform classical inference as in the previous example. The selection phase converts testing CPTs into regular CPTs using an operation called flattening. The flattening of a CPT for variable $X$ involves only its ancestral CPTs. In particular, before the CPT for variable $X$ is flattened, all its ancestral CPTs must be flattened and eliminated.

Consider our earlier example over binary variables $A,B,C$ with edges $A\to B$ and $A\to C$, and suppose now that variable $B$ is testing. We have soft evidence on variables $A$ and $C$ and want to compile a TAC that computes the marginal $(P^{\star}(b),P^{\star}(\bar{b}))$.

Selection Phase As we want to flatten the CPT for variable $B$, the CPT for variable $C$ is irrelevant, so we start with the following CPTs.

[TABLE]

[TABLE]

The CPT for variable $A$ is regular so it is notated as usual. The CPT for variable $B$ is testing so it is notated differently. The second column is empty initially but will contain TAC nodes when factors are multiplied into the CPT. The third column contains thresholds and dynamic parameters and is kept until the CPT is flattened (i.e., converted into a regular CPT).

We first eliminate the CPT for variable $A$. No variables are summed out in this case, so we just multiply this CPT by the testing CPT for variable $B$, leading to

[TABLE]

If we define a new TAC node $n_{3}={+(n_{1},n_{2})}$, then $n_{1}/n_{3}$ and $n_{2}/n_{3}$ represent the posterior on variable $A$, which is what we need to flatten the CPT for variable $B$ as follows161616More generally: after flattening and eliminating all ancestral CPTs of a variable $X$, the CPT for $X$ will contain the marginal on its parents given evidence on its ancestors. This marginal is all we needed to select a CPT for variable $X$, whether we are using threshold-based or sigmoid-based selection.

[TABLE]

This is a regular CPT since each entry is a circuit node. This finishes the selection phase, leading to the partial TAC in Figure 14(a). We are now ready for the inference phase.

Inference Phase Our CPTs are now all regular

[TABLE]

[TABLE]

[TABLE]

Inference can proceed as in the previous section: eliminate factor $\Theta_{C|A}$ then factor $\Theta_{A}$. To eliminate factor $\Theta_{C|A}$, we sum-out variable $C$ from the factor leading to

[TABLE]

We then multiply the above factor by factor $\Theta_{A}$. Our new set of factors is

[TABLE]

[TABLE]

To eliminate the last constructed factor, we just multiply it by the factor for variable $B$, leading to

[TABLE]

Summing-out variable $A$, we now have the final factor

[TABLE]

We now have a TAC whose two outputs, $n_{20}$ and $n_{21}$, compute the marginal $(P^{\star}(b),P^{\star}(\bar{b}))$; see Figure 14(b). Normalizing the circuit outputs gives the posterior $({\cal P}^{\star}(b),{\cal P}^{\star}(\bar{b}))$.

C.4 The Compilation Algorithm

We now provide a more formal description of the compilation algorithm.

Testing CPTs A testing CPT for node $X$ with parents ${\bf U}$ will initially have rows of the following form:

[TABLE]

When factors are multiplied into this testing CPT, its rows will have the following form

[TABLE]

where $n$ is a TAC node. When the CPT is flattened (see below), its rows will have the following form

[TABLE]

where $n$ and $m$ are TAC nodes. It is now a regular CPT since the entry in each row is a testing TAC node.

Pseudocode To compile a TBN query into a TAC ($Q$ is the query node):

Pruning. Repeatedly remove a leaf TBN node if it is not an evidence or query node. 2. 2.

Initialization. Replace each TBN parameter and threshold by a corresponding TAC node. 3. 3.

Entering Evidence. If a node $X$ has soft evidence and $k$ values, construct TAC nodes for $\lambda_{1},\ldots,\lambda_{k}$ and multiply each row in the CPT of $X$ by $\lambda_{i}$ if the row corresponds to value $x_{i}$. 4. 4.

Selection Phase. Visit testing nodes $X$, ancestors before descendants.

1. (a)

Let $\Sigma$ be the set of CPTs for $X$ and its ancestors (ancestral CPTs must be regular at this point). 2. (b)

Eliminate all factors from $\Sigma$ except the CPT for node $X$. 3. (c)

Flatten the CPT for node $X$ with parents ${\bf U}$ as follows:

1. i.

Create a TAC node $n=\sum_{\bf u}n_{\bf u}$, where $n_{\bf u}$ is the TAC node in some CPT row for state ${\bf u}$.171717CPT rows for the same instantiation ${\bf u}$ of parents ${\bf U}$ must have the same TAC node (represents the marginal on state ${\bf u}$). 2. ii.

Replace each CPT row

[TABLE]

by

[TABLE]

(the CPT for node $X$ is now regular). 5. 5.

Inference Phase.

1. (a)

Let $\Sigma$ be the set of all TBN CPTs (whether initially regular or flattened). 2. (b)

Let $f$ be a factor in $\Sigma$ that includes query node $Q$. 3. (c)

Eliminate all factors in $\Sigma$ except for factor $f$. 4. (d)

Return $\sum_{\bf Z}f$, where ${\bf Z}$ are the variables of factor $f$ except $Q$.

Entries of the returned factor will contain TAC outputs, which compute the marginal $P^{\star}(Q)$. Normalizing these outputs gives the posterior ${\cal P}^{\star}(Q)$.

The Order of Eliminating Factors The factor elimination algorithm is an abstraction of the jointree algorithm [10, Chapter 7]. In particular, a message sent by the jointree algorithm from cluster $i$ to cluster $j$ can be interpreted as eliminating the factor at cluster $i$, leading to its multiplication by the factor at cluster $j$. Hence, the order in which factors are eliminated can be set using a jointree, which also determines the complexity of factor elimination. To eliminate a set of factors $\Sigma$ except for some factor $f\in\Sigma$, we first assign each factor $g\in\Sigma$ to some jointree cluster that contains the variables of factor $g$. If multiple factors are assigned to the same cluster, we view this as one factor corresponding to their product. We next designate the cluster $r$ containing factor $f$ as the root cluster. We finally eliminate factors as follows. We only eliminate a factor if it is attached to a leaf cluster $i\neq r$, multiplying it into its neighboring factor (cluster $i$ is also removed). The process terminates when we are left with the root cluster $r$. Using a binary jointree with $n$ clusters and width $w$, the time and space complexity of factor elimination is $O(n\exp(w))$.181818A jointree is binary if each cluster has at most three neighbors. The width of a jointree is the size of its largest cluster $-1$. See [10, Chapter 7] for details.

Complexity The elimination of factors in Steps 4b and 5c can be implemented using the same jointree, constructed for the TBN produced by Step 1. Given a binary jointree with $n$ clusters and width $w$, the time and space complexity of compiling a TAC (the selection and inference phases) is then $O(m\cdot n\exp(w))$, where $m$ is the number of testing nodes. This can be improved if one uses a different jointree for each iteration of the selection phase since each of these iterations involves a subset of the TBN that may be less connected.

Unique Nodes The described algorithm may construct equivalent TAC nodes. To avoid this, we maintain a unique-node table, which stores each constructed TAC node with a key based on its type and its children’s identities. Before a new node is constructed, the table is checked if an equivalent node was constructed earlier. If the test succeeds, the node is used. Otherwise, a new node is constructed and added to the table.

Sigmoid Selection The algorithm can be slightly adjusted to compile TBNs that employ other CPT selection mechanisms, as long as the selection process requires only the posterior on parents (sigmoid selection satisfies this property). We just adjust the operation of CPT flattening to construct and add the desired selection nodes instead of testing nodes.