A standard graphical model is static, with a separate set of parameters for each conditional distribution (in a directed acyclic graph) or factor (in a factor graph). There are extensions which allow parameter sharing, e.g. through time with dynamic Bayes nets, or in undirected graphical models such as Markov Networks which allow one to "instantiate" general "patterns" into multiple factors of the factor graph. Markov Networks can for example implement forms of recursively applied probabilistic rules. But they do not take advantage of distributed representations and other inductive biases of deep learning.

The inductive bias we are presenting here is that instead of separately defining specific factors in the factor graph (maybe each with a piece of neural network), each having its separate set of parameters, we would define generic factors, "schemas" or "factor templates". A schema, or generic factor is a reusable probabilistic relation, i.e., with argument variables which can be bound to instances (also discussed in (Rumelhart et al., 1986)).

A static instantiated rule is a thing like 'if John is hungry then he looks for food'. Instead, a more general rule is a thing like, 'for all X, if X is a human and X is hungry, then X looks for food' (with some probability). X can be bound to specific instances (or to other variables which may involve more constraints on the acceptable set).

In classical symbolic AI, we have unification mechanisms to match together variables, instances or expressions involving variables and instances, and thus keep track of how variables can ultimately be 'bound' to instances (or to variables with more constraints on their attributes), when exploring whether some schema can be applied to some objects (instances or more generic objects) with properties (constituting a database of entities).

The proposed inductive bias is also inspired by the presence of such a structure in the semantics of natural language and the way we tend to organize knowledge according to relations, e.g., in knowledge graphs. Natural language allows us to state rules involving variables and is not limited to making statements about specific instances.

Knowledge is generic and can be instantiated on different instances. The independent mechanisms (with separate parameters) which specify dependencies between variables are generic, i.e., they can be instantiated in many possible ways to specific sets of arguments with the appropriate types or constraints.

What this means in practice is that we do not need to hold in memory the full instantiated graph with all possible instances and all possible mechanisms relating them (or worse, all the generic factor instantiations that are compatible with the data, in a Bayesian posterior).

Instead, inference involves generating the needed pieces of the graph and even performing reasoning (i.e. deduction) at an abstract level, where nodes in the graph (random variables) stand not for instances but for sets of instances belonging to some category or satisfying some constraints.

Whereas one can unfold a recurrent neural network or a Bayesian network to obtain the fully instantiated graph, in the case we are talking about, similarly to a Markov network, it is generally not feasible to do that. It means that inference procedures always look at a small piece of the (partially) unfolded graph at a time and they can reason about how to combine these generic schemas without having to fully instantiate them with concrete instances or concrete objects in the world.

One way to think about this, inspired by how we do programming, is that we have functions with generic and possibly typed variables as arguments and we have instances on which a program is going to be applied. At any time (as you would have in Prolog), an inference engine must match the rules with the current instances (so the types and other constraints between arguments are respected) as well as other elements (such as what we are trying to achieve with this computation) in order to combine the appropriate computations.

It would make sense to think of such a computation controller, as an internal policy with attention and memory access as actions, to select which pieces of knowledge and which pieces of the short-term (and occasionally long-term) memory need to be combined in order to push new values in working memory.

An interesting outcome of such a representation is that one can apply the same knowledge (i.e knowledge specified by a schema which links multiple abstract entities together) to different instances (i.e different "object files" in cognitive psychology). For example, you can apply the same laws of physics to two different balls that are visually different (and maybe have different colors and masses).

This is also related to notions of arguments and indirection in programming. The power of such relational reasoning resides in its capacity to generate inferences and generalizations that are constrained by the roles that elements play, and the roles they can play may depend on the properties of these elements, but these schemas specify how entities can be related to each other in systematic (and possibly novel) ways.

In the limit, relational reasoning yields universal inductive generalization from a finite and often very small set of observed cases to a potentially infinite set of novel instances, so long as those instances can be described by attributes (specifying types) allowing to bound them to appropriate schemas.

There are two forms of knowledge representation we have discussed: declarative knowledge or hypotheses, i.e., that can be verbalized (e.g. of facts, hypotheses, explicit causal dependencies, etc), and inference machinery used to reason with these pieces of knowledge.

Standard graphical models only represent the declarative knowledge and typically require expensive but generic iterative computations (such as Monte-Carlo Markov chains) to perform approximate inference. However, brains need fast inference, and most of the advances made with deep learning concern such learned fast inference computations.

Doing inference using only the declarative knowledge (the graphical model) is very flexible (any question of the form "predict some variables given other variables or imagined interventions" can be answered) but also very slow. In general, searching for a good configuration of the values of top-level variables which is consistent with the given context is computationally intractable. However, different approximations can be made which trade-off computational cost for quality of the solutions found.

This difference could also be an important ingredient of the difference between system 1 (fast and parallel approximate and inflexible inference) and system 2 (slower and sequential but more flexible inference).

We also know that after system 2 has been called upon to deal with novel situations repeatedly, the brain tends to bake these patterns of response in habitual system 1 circuits which can do the inference job faster and more accurately but have lost some flexibility. When a new rule is introduced, the system 2 is flexible enough to handle it and slow inference needs to be called upon again.

Neuroscientists have also accumulated evidence that the hippocampus is involved in replaying sequences (from memory or imagination) for consolidation into cortex so that they can be presumably committed to cortical long-term memory and fast inference.

In a clock-based segmentation, the boundaries between discrete time steps are spaced equally. In an event-based segmentation, the boundaries depend on the state of the environment, resulting in dynamic duration of intervals. Our brains seem to segment streams of sensory inputs into meaningful representations of variable-length episodes and events.

The detection of a relevant event in the temporal stream triggers information processing of the event. The psychological reality of event-based segmentation can be illustrated through a familiar phenomenon. Consider the experience of traveling from one location to another, such as from home to office.

If the route is unfamiliar, as when one first starts a new job, the trip is confusing and lengthy, but as one gains more experience following the route, one has the sense that the trip becomes shorter. One explanation for this phenomenon is as follows.

On an unfamiliar route, the orienting mechanism that detects novel events is triggered for a large number of such events over the course of the trip. In contrast, few novel events occur on a familiar route. If our perception of time is event-based, meaning that higher centers of cognition count the number of events occurring in a temporal window, not the number of milliseconds, then one will have the sense that a familiar trip is shorter than an unfamiliar trip.

Event segmentation allows functional representations that support temporal reasoning, an ability that arguably relies on neural circuits to encode and retrieve information to and from memory. Indeed, faced with a task, our brains appear to easily and selectively pluck context-relevant past information from memory, enabling both powerful multi-scale associations as well as flexible computations to relate temporally distant events.

As we argue here, the ability of the brain to efficiently segment sensory inputs into events, and the ability to selectively recall information from the distant past based on the current context helps to efficiently propagate information (such as credit assignment or causal dependencies) over long time spans. Both at the cognitive and at the physiological levels, there is evidence of information "routing" mechanisms that enable this efficient propagation of information, although they are far from being sufficiently understood.

Relevant Causal Chains tend to be sparse. Our next inductive bias is almost a consequence of the biases on causal variables and the bias on the sparsity of the factor graph for the joint distribution between high-level variables. Causal chains used to perform learning (to imagine counterfactuals and to propagate and assign credit) or inference (to obtain explanations or plans for achieving some goal) are broken down into short causal chains of events which may be far in time but linked by the top-level factor graph over semantic variables.

At least at a conscious level, humans are not able to reason about many such events at a time, due to the limitations on short-term memory and the bottleneck of conscious processing. Hence it is plausible that humans would exploit an assumption on temporal dependencies in the data: that the most relevant ones only involve short dependency chains, or a small-depth graph of direct dependencies. Depth here refers to the longest path in the relevant graph of dependencies between events.

What we showed earlier (Ke et al., 2018; Kerg et al., 2020) is that this prior assumption is the strongest ingredient to mitigate the issue of vanishing gradients that occurs when trying to learn long-term dependencies.