🤖 machine learning

DeepLog: A Software Framework for Modular Neurosymbolic AI

DeepLog is a modular neurosymbolic AI framework built on PyTorch that unifies diverse logic and deep learning paradigms by automatically compiling high-level specifications into optimized arithmetic circuits, thereby lowering the barrier for practitioners and providing a shared backend for developing new integration strategies.

Original authors: Robin Manhaeve, Stefano Colamonaco, Vincent Derkinderen, Rik Adriaensen, Lucas Van Praet, Luc De Raedt, Giuseppe Marra

Published 2026-05-12

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Robin Manhaeve, Stefano Colamonaco, Vincent Derkinderen, Rik Adriaensen, Lucas Van Praet, Luc De Raedt, Giuseppe Marra

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the world of Artificial Intelligence as a massive kitchen. Currently, there are two very different groups of chefs working in separate rooms:

The Deep Learning Chefs: They are experts at tasting and guessing. They use huge, complex machines (neural networks) to look at a picture of a cat and say, "I'm 90% sure that's a cat." They are great at pattern recognition but don't really understand rules.
The Symbolic Logic Chefs: They are experts at following strict recipes and rules. They know that "If it has whiskers and meows, it is a cat." They are great at reasoning but terrible at guessing when the data is messy or unclear.

For a long time, these two groups tried to work together, but they spoke different languages and used different tools. The result was a chaotic "alphabet soup" of different frameworks where every new project had to build its own kitchen from scratch. It was hard to compare them, and they often didn't fit together well.

Enter DeepLog: The Universal Kitchen Adapter

The paper introduces DeepLog, which acts like a universal adapter or a "master translator" for this kitchen. Its goal is to let the Deep Learning chefs and the Symbolic Logic chefs work together seamlessly without forcing them to abandon their favorite tools.

Here is how DeepLog works, using simple analogies:

1. The "Plug-and-Play" Modules

Think of Deep Learning models as pre-made appliances (like a toaster or a blender). In the past, if you wanted to add a logic rule to a toaster, you had to completely rebuild the toaster.

DeepLog introduces DeepLogModules. These are like smart adapters you can clip onto any appliance. They don't change how the appliance works, but they add a "label" that says, "This output is a probability," or "This input must follow a specific rule." Because of these labels, the system can automatically snap different appliances together. If you plug a "cat detector" into a "logic rule," DeepLog automatically builds the wiring needed to make them talk to each other.

2. The "Universal Translator" (The Alphabet Soup)

The paper mentions that there are dozens of different ways people try to combine logic and AI (the "alphabet soup"). Some use fuzzy math, some use probabilities, some use strict true/false logic.

DeepLog treats all of these different languages as just high-level instructions. It's like a translator that listens to a chef speaking French (DeepProbLog), another speaking Spanish (LTN), and a third speaking German (NeurASP). DeepLog translates all of them into the same underlying "recipe" (an optimized arithmetic circuit) that the computer can actually cook. This means researchers can swap one type of logic for another just by changing a setting, without rewriting their whole program.

3. The "High-Speed Express Lane" (GPU Acceleration)

Usually, when these two types of AI work together, the "logic" part runs on a slow, old-fashioned processor (the CPU), while the "guessing" part runs on a super-fast graphics card (the GPU). This is like having a Ferrari (the neural network) stuck in traffic behind a tractor (the logic solver). Every time they need to pass data back and forth, the Ferrari has to stop, causing a huge slowdown.

DeepLog moves everything onto the fast GPU. It turns the logic rules into a high-speed circuit that runs right alongside the neural network. The paper shows that this makes the system significantly faster—sometimes hundreds of times faster—than previous methods.

4. The "Factory" for New Ideas

For the developers building these systems, DeepLog acts like a Lego factory. Instead of building a new house from raw clay every time they want to test a new idea, they can use pre-made bricks (primitives) to snap together new combinations of logic and learning.

For example, if a researcher wants to test a new type of "fuzzy logic" (where things can be "sort of true"), they can just swap out the "fuzzy logic brick" in their factory setup. The rest of the system stays the same. This makes it much easier to experiment and compare different ideas quickly.

Summary

In short, DeepLog is a software framework that:

Unifies the chaotic "alphabet soup" of different AI logic systems into one standard language.
Automates the connection between neural networks and logic rules, so developers don't have to write messy "glue code."
Speeds things up by running everything on powerful GPUs instead of slow CPUs.
Makes life easier for both the people using these tools (by letting them plug logic into standard AI workflows) and the people building new tools (by giving them a shared, high-performance foundation).

The paper claims this allows researchers to stop reinventing the wheel and start focusing on solving actual problems, while making the whole process faster and more reliable.

Technical Summary: DeepLog – A Software Framework for Modular Neurosymbolic AI

Problem Statement
The current landscape of Neurosymbolic AI (NeSy) is characterized as an "alphabet soup" of disconnected paradigms and frameworks. Existing systems typically focus on specific semantic interpretations (e.g., fuzzy vs. probabilistic), integration strategies (e.g., loss-based regularization vs. architectural incorporation), or symbolic front-ends (e.g., first-order logic vs. logic programming). These differences are often treated as fundamental rather than alternative instantiations, resulting in non-interoperable frameworks. Consequently, there is a lack of cross-paradigm software tools, which hinders systematic comparison and cumulative progress. Furthermore, most existing NeSy systems employ monolithic designs that replace standard machine learning workflows, and their symbolic components are often implemented on the CPU, creating performance bottlenecks due to data transfer and synchronization issues with GPU-accelerated neural modules.

Methodology
DeepLog addresses these challenges by functioning as an operational neurosymbolic framework that unifies logic and deep learning within standard PyTorch workflows. It is based on the DeepLog abstract neurosymbolic machine, which serves as a semantic intermediate representation separating front-end symbolic languages from back-end execution strategies.

The methodology relies on three core technical mechanisms:

Symbolically Annotated Modules: DeepLog extends standard PyTorch modules into DeepLogModules. These modules are augmented with symbolic annotations on their inputs and outputs, represented as SymTensors (N-dimensional tensors associated with symbolic expressions). These annotations specify the semantic role of each tensor (e.g., Boolean, probability, fuzzy score), enabling automatic composition, validation, and transformation of heterogeneous components.
Modular Composition and Compilation: The framework treats logic as composable modules. It supports sequential composition (analogous to torch.nn.Sequential) and automatic wiring of directed acyclic graphs based on symbolic dependencies. A compiler-style factory automatically translates high-level specifications (expressed in the DeepLog language) into optimized arithmetic circuits. This allows users to switch between semantics (e.g., probabilistic vs. fuzzy tracks) simply by changing the underlying logic track in the DeepLog Library.
GPU-Accelerated Execution: Unlike many systems that offload symbolic reasoning to the CPU, DeepLog implements both neural and symbolic components on the GPU. It leverages the KLay package for efficient circuit evaluation and utilizes specialized circuit backends (e.g., sentential decision diagrams) to enforce structural properties like determinism and decomposability.

Key Contributions
The paper presents the implementation of DeepLog with the following specific contributions:

Universal Backend: It acts as a universal backend capable of emulating a wide range of systems in the neurosymbolic "alphabet soup," allowing for the reconstruction of diverse approaches with minimal code.
Out-of-the-Box GPU Acceleration: It provides high-performance execution for both neural and symbolic components, eliminating the CPU-GPU data transfer bottleneck common in hybrid systems.
Modularity: It offers automatic module composition, enabling the construction of complex neurosymbolic models from heterogeneous components without fragile glue code.
Integration: It integrates seamlessly with modern ML software (PyTorch), allowing practitioners to selectively integrate symbolic reasoning into existing pipelines without replacing established workflows.

Results
The paper provides empirical evidence of DeepLog's performance advantages, specifically in the MNIST-Addition task. Comparative results (Table 1) demonstrate that DeepLog with GPU acceleration significantly outperforms both CPU-based DeepLog and the standard DeepProbLog (DPL) system.

For a single query involving 1 digit, DeepLog GPU achieved an inference time of $5.62 \times 10^{-7}$ seconds, compared to $1.09 \times 10^{-5}$ seconds for DeepLog CPU and $6.14 \times 10^{-3}$ seconds for DPL CPU.
The performance gap widens as complexity increases; for 4 digits, DeepLog GPU maintains a time of $5.40 \times 10^{-2}$ seconds, whereas DeepLog CPU rises to $1.96 \times 10^{-1}$ seconds, and DPL CPU fails to complete the task within the reported timeframe.

Significance and Claims
The authors claim that DeepLog serves as a "universal backend" that lowers the barrier for machine learning practitioners by treating logic as composable modules within familiar PyTorch environments. Simultaneously, it provides neurosymbolic developers with a shared, high-performance basis for prototyping new integration strategies. By consolidating essential components from existing approaches and offering primitives for new designs, DeepLog aims to facilitate the comparison of different paradigms and accelerate cumulative progress in the field. The framework is designed to be non-intrusive, supporting both lightweight integration of symbolic constraints and the development of new languages and inference paradigms on a unified architecture.

Future Work
The authors identify several directions for future development, primarily focusing on the automation of more aggressive circuit-level optimizations. While the current framework supports multiple compilation strategies, future work aims to incorporate systematic optimization techniques, such as structure-aware rewritings and the fusion of aggregation and inference, to further reduce manual engineering effort and improve scalability. Additionally, the authors plan to explore alternative inference mechanisms, such as sampling, beyond the current circuit-based approach.