Neural-Symbolic Computing: An Effective Methodology for Principled Integration of Machine Learning and Reasoning

In plain words

Neural networks learn well from data, but the knowledge they hold is hard to read and their decisions are hard to explain. Symbolic AI uses explicit rules and logic, which people can read and check, but it is brittle. This paper is a survey of work that tries to combine the two, so that a system can learn from examples and still hold knowledge in a form people can inspect.

The survey sorts that work into four questions. How is logical knowledge written into a network? How is it learned, alone or together with data? How does the network reason with it? And how can the network's behaviour be turned back into readable rules or explanations? Most of the systems it describes come from other papers; this card does not add experiments of its own.

TL;DR

A survey of neural-symbolic computing, the line of work that puts logical knowledge inside neural networks. It covers how rules, formulas, tensors and temporal logic are encoded, how learning from data and logic is combined, how reasoning is done with networks, and how rules are extracted afterwards. It gives no new results, so use it as a map of methods and a list of open problems.

Problem

Deep networks reach high accuracy but offer little explanation of a decision §1. Symbolic systems give explicit knowledge and sound inference but are brittle §1. Deep learning usually needs large amounts of data, and symbolic knowledge can help when data is scarce §4.2. The paper argues that integrating the two in a principled way is needed for accountable and explainable AI §1. It treats the question as one of representation: which logic is encoded, and how learning, reasoning and extraction work on that encoding §1 §2.

Method

The paper does not propose a method. It is a survey, organised into four parts after the introduction and the background section §2:

1. Knowledge representation §3. Three groups: rule-based, formula-based and embedding-based. The rule-based group is then split into propositional logic §3.1.1, first-order logic §3.2 and temporal logic §3.3.
2. Learning §4: inductive logic programming (ILP), horizontal hybrid learning (knowledge plus data in one model) and vertical hybrid learning (a logic layer over a perception network) §4.1 §4.2 §4.3.
3. Reasoning §5: forward and backward chaining §5.1, approximate satisfiability §5.2 and relationship reasoning §5.3.
4. Explainability §6: knowledge extraction §6.1, natural-language explanation §6.2 and program synthesis §6.3.

Section 7 concludes §7. The paper gives no algorithm in pseudocode and no training procedure of its own. The schematic below only arranges the survey's four parts into one pipeline; it is not a procedure from the paper.

# Schematic of the survey's pipeline, not an algorithm from the paper
# Input:  knowledge base (rules or formulas), data set
# Output: trained network, reasoning answers, extracted rules

def neural_symbolic_pipeline(knowledge, data):
    # Encode symbolic knowledge as network structure or weights
    # [§3.1.1] [§3.1.2] [§3.2.2]
    network = encode(knowledge)

    # Learn from data while respecting the logic (learning with
    # logical constraints, or knowledge transfer)  [§4.2]
    network = train(network, data, constraints(knowledge))

    # Reason by feedforward inference, forward or backward chaining
    # [§5.1] [§5.2]
    answers = infer(network, queries)

    # Extract readable rules from the trained network  [§6.1]
    rules = extract_rules(network)

    return network, answers, rules

3. Knowledge representation

The core claim of the survey is that logical knowledge is represented in symbolic form, while learning and reasoning run in a neural network §1.

Rule-based (propositional) §3.1.1. Early work constrains the weights so that a feedforward pass imitates modus ponens §3.1.1. The knowledge base of the running example is:

\phi = \{\, A \leftarrow B \wedge C,\;\; B \leftarrow C \wedge \neg D \wedge E,\;\; D \leftarrow E \,\} eq. 1

• KBANN uses a stack of perceptrons, one per implication, to encode such rules §3.1.1 fig. 2.
• CILP generalises this with recurrent networks and bounded continuous units, and can learn with backpropagation and logic programs as background knowledge §3.1.1 §2.
• CILP++ handles first-order knowledge by turning examples and background knowledge into propositional clauses (bottom-clause propositionalisation), then encodes them as CILP does §3.1.1.

Formula-based (propositional) §3.1.2. Each formula gets a weight. The formulas are encoded as symmetric, energy-based networks, usually restricted Boltzmann machines (RBMs) as the building block, so that satisfying more formulas means lower energy §3.1.2.

• Penalty logic builds a higher-order Hopfield-type network. Inference is difficult, and turning the higher-order energy into a quadratic form is possible but expensive §3.1.2 fig. 3.
• Confidence rules encode propositional formulas in RBMs and deep belief networks, where inference and learning are easier §3.1.2 fig. 3.
• The partition function of these networks cannot be computed analytically. A sum-product approach may help, but the paper says it is not yet clear how to apply it to RBMs §3.1.2.

First-order (propositionalisation) §3.2.1. A first-order knowledge base is converted into a propositional one that keeps entailment, so that propositional encodings apply. Bottom clauses are popular because their literals become data features with a semantic meaning §3.2.1. Its disadvantages: function symbols give infinitely many ground terms, and the method produces many irrelevant clauses §3.2.1.

First-order (tensorisation) §3.2.2. Symbols become real-valued tensors. Constants are one-hot vectors (first-order tensors). Predicates and functions are matrices or higher-order tensors §3.2.2. Training is distance learning by backpropagation, and most work targets relational predicates §3.2.2. Logic Tensor Networks (LTN) extend Neural Tensor Networks to whole formulas §3.2.2 fig. 4.

Temporal logic §3.3. CTLK uses ensembles of recurrent networks with a single hidden layer of semi-linear neurons to compute a fixed-point semantics of temporal rules §3.3. Sequential Connectionist Temporal Logic extends CILP to NARX networks §3.3. Neural-Symbolic Cognitive Agents use recurrent structures of temporal RBMs §3.3. The Tensor Product Recurrent Network is named for temporal relational knowledge in question answering §3.3. The evolution of knowledge and learning over time is shown in fig. 1 §2.

4. Learning

Inductive logic programming §4.1. Bottom-up methods extract specific clauses from examples and then generalise, which fits propositionalisation. CILP++ and CRILP (RBMs plus bottom clauses) are the examples given; the paper says both learn at the propositional level, producing large networks §4.1. Top-down methods start from general clauses and specialise them, replacing logical operators by differentiable ones:

• Neural Logic Programming uses TensorLog-style differentiable inference. A conjunction's confidence is a product and a disjunction's is a sum §4.1.
• Differentiable ILP (∂ILP) generates rules from templates whose weights are learned, with a loss between actual and forward-chained conclusions §4.1.
• Neural Theorem Prover extends backward chaining to be differentiable and learns latent predicates through their distributed representations §4.1.
• Neural Logic Machines learn the relation between predicates directly: input tensors hold facts and output tensors hold new facts §4.1.

Horizontal hybrid learning §4.2. Logical rules or formulas are combined with data during training. Logic is encoded as controlled parameters, which the paper calls learning with logical constraints §4.2. Two further mechanisms are named: knowledge transfer from a related domain, and self-transfer by symbolic-knowledge distillation, where rules extracted from a teacher network regularise a student network in the same domain §4.2.

Vertical hybrid learning §4.3. A logic network sits on top of a deep network to reason over its learned abstractions, which can make the system explain itself §4.3. One example fixes a Fast R-CNN perception part and trains a Logic Tensor Network for relations between object parts §4.3. In DeepProbLog, network outputs act as neural predicates inside ProbLog, and learning is end to end §4.3.

5. Reasoning

Forward and backward chaining §5.1. Both are implemented in general by feedforward inference §5.1. Forward chaining: ∂ILP applies one differentiable step per clause, and NLM uses networks as a differentiable forward chain §5.1. Backward chaining: TensorLog implements it with networks as symbols, and NTP builds a network recursively with AND and OR operators §5.1. The paper says goal-directed reasoning is considerably harder in networks than forward reasoning §5.1.

Approximate satisfiability §5.2. Exact reasoning that maximises satisfiability is NP-hard §5.2. LTNs are trained to approximate the best satisfiability, so inference is feedforward §5.2. Penalty logic links violation minimisation to energy minimisation §5.2. Confidence rules link sampling in RBMs to the search for satisfying assignments and give a measure of the network's confidence in its answers §5.2.

Relationship reasoning §5.3. Answers are found by searching for the query with the highest grounding score in a relational embedding §5.3. Deep networks are also used for visual relational reasoning §5.3.

6. Explainability

Knowledge extraction §6.1. Rule-extraction methods were judged on four criteria: accuracy, fidelity, consistency and comprehensibility §6.1. Global combinatorial search does not scale to current networks §6.1. The newer approach either extracts rules from specific modules or from specific layers §6.1. Pulling conjunctive clauses out of the first layer of a deep belief network is reported to work well and quickly. Higher layers lose accuracy when treated the same way §6.1. Soft-logic rules can be extracted from a trained deep network §6.1. Temporal rules can also be extracted §6.1.

Natural-language explanation §6.2. A deep network can be coupled with a sequence model to produce natural-language knowledge §6.2. Relational knowledge can be extracted by running a trained embedding network on text §6.2.

Program synthesis §6.3. Neuro-symbolic program synthesis builds a program incrementally from input-output samples, using a neural network over a domain-specific language. The tree structure of the network gives the explanation §6.3.

The summary of techniques across the four parts is a landscape page included as a PDF after §7. It has no number and no caption, and it marks each method under the headings representation, learning, reasoning and explainability [summary page after §7].

Hyperparameters

Not applicable: the paper runs no experiments and states no training hyperparameters. The only numbered equation is eq. 1, a rule set with no parameters. Weights and thresholds appear only in the descriptions of cited systems, with no values given §3.1.1 fig. 2 fig. 3.

Results

No results of its own. The paper reports no benchmark numbers, tables or ablations. Its claims of effectiveness rest on the cited systems, which it does not reproduce §1 §5.2. Qualitative statements the paper makes:

Paper vs code

No official code. The paper has no code link and no project page. The GitHub repository search for "neural-symbolic computing" returned four repositories, none by the authors. The search for "garcez neural-symbolic" returned none. This is a survey, so it has no implementation to compare against.

Pitfalls

• Survey, not a method. Nothing here is a complete procedure an agent can implement. Each subsection names approaches whose details live in the cited papers, which this card does not reproduce.
• No numbers. The abstract's word "effective" refers to the cited systems, not to experiments in this paper. Do not quote a performance figure from this card.
• Citation key ambiguity. The key Son_2018 is cited for confidence rules §3.1.2, for knowledge transfer §4.2 and for rule extraction from deep belief networks §6.1. Its bibliography entry is titled "Deep Logic Networks: Inserting and Extracting Knowledge From Deep Belief Networks". Check the original before citing any one of these claims.
• Unsupported sentence. The NP-hardness of exact reasoning is stated without a citation §5.2.
• Ambiguous sentence. §4.1 says CILP++ was used "to construct CILP++". The intended subject is unclear. Read it as the CILP++ system, from its own description in §3.1.1.
• Partition function is unresolved. Formula-based RBM methods do not have an analytic partition function. The paper says it is unclear whether the sum-product fix applies to RBMs §3.1.2.
• Propositionalisation scales badly. Function symbols give infinitely many ground terms, and many clauses are irrelevant §3.2.1. The paper says CILP++ and CRILP produce very large networks §4.1.
• Goal-directed reasoning is hard. The paper says backward chaining is considerably harder in networks than forward chaining §5.1.
• Rule extraction is layer-sensitive. Extraction from the first layer of a deep belief network works, and higher layers lose accuracy §6.1.
• Figures are not reproduced. Figure 1 to Figure 4 are described above. The landscape summary is a PDF page and is not reproduced here.

Lineage

• Builds on: KBANN §3.1.1, CILP §3.1.1, penalty logic §3.1.2, confidence rules §3.1.2, TensorLog §5.1 and Logic Tensor Networks §3.2.2, each described by name only. No arXiv ids are given in the paper text.
• Compared against: not stated. The paper does not compare methods experimentally.
• Superseded by: not stated.
• Related on this wiki: 2012.05876, a 2020 position paper on the same field. It is not a lineage link.