Mimicking the brain: Deep learning meets vector-symbolic AI

We hope this work also inspires a next generation of thinking and capabilities in AI. Deep learning has its discontents, and many of them look to other branches of AI when they hope for the future. Limitations were discovered in using simple first-order logic to reason about dynamic domains.

We investigate an unconventional direction of research that aims at converting neural networks, a class of distributed, connectionist, sub-symbolic models into a symbolic level with the ultimate goal of achieving AI interpretability and safety. It achieves a form of “symbolic disentanglement”, offering one solution to the important problem of disentangled representations and invariance. Basic computations of the network include predicting high-level objects and their properties from low-level objects and binding/aggregating relevant objects together. These computations operate at a more fundamental level than convolutions, capturing convolution as a special case while being significantly more general than it. All operations are executed in an input-driven fashion, thus sparsity and dynamic computation per sample are naturally supported, complementing recent popular ideas of dynamic networks and may enable new types of hardware accelerations.

Limitations and Challenges of Symbolic AI:

To explore how you can harness AI’s potential in your organization, consider enrolling in HBS Online’s AI Essentials for Business course. Throughout it, you’ll be introduced to industry experts at the forefront of AI who will share real-world examples that can help you lead your organization through a digital transformation. By targeting specific industry challenges—such as improving diagnostic accuracy and operational efficiency—VideaHealth illustrates how AI can complement human expertise and automate routine tasks.

This video shows a more sophisticated challenge, called CLEVRER, in which artificial intelligences had to answer questions about video sequences showing objects in motion. The video previews the sorts of questions that could be asked, and later parts of the video show how one AI converted the questions into machine-understandable form. If you ask it questions for which the knowledge is either missing or erroneous, it fails.

Being able to communicate in symbols is one of the main things that make us intelligent. Therefore, symbols have also played a crucial role in the creation of artificial intelligence. Critiques from outside of the field were primarily from philosophers, on intellectual grounds, but also from funding agencies, especially during the two AI winters. In contrast, a multi-agent system consists of multiple agents that communicate amongst themselves with some inter-agent communication language such as Knowledge Query and Manipulation Language (KQML). Advantages of multi-agent systems include the ability to divide work among the agents and to increase fault tolerance when agents are lost.

It inherits all the properties from the Symbol class and overrides the __call__ method to evaluate its expressions or values. All other expressions are derived from the Expression class, which also adds additional capabilities, such as the ability to fetch data from URLs, search on the internet, or open files. These operations are specifically separated from the Symbol class as they do not use the value attribute of the Symbol class. Operations are executed using the Symbol object’s value attribute, which contains the original data type converted into a string representation and sent to the engine for processing.

Fourth, the symbols and the links between them are transparent to us, and thus we will know what it has learned or not – which is the key for the security of an AI system. Last but not least, it is more friendly to unsupervised learning than DNN. We present the details of the model, the algorithm powering its automatic learning ability, and describe its usefulness in different use cases. The purpose of this paper is to generate broad interest to develop it within an open source project centered on the Deep Symbolic Network (DSN) model towards the development of general AI.

Alternatively, in complex perception problems, the set of rules needed may be too large for the AI system to handle. Deep learning is better suited for System 1 reasoning,  said Debu Chatterjee, head of AI, ML and analytics engineering at ServiceNow, referring to the paradigm developed by the psychologist Daniel Kahneman in his book Thinking Fast and Slow. These soft reads and writes form a bottleneck when implemented in the conventional von Neumann architectures (e.g., CPUs and GPUs), especially for AI models demanding over millions of memory entries. Thanks to the high-dimensional geometry of our resulting vectors, their real-valued components can be approximated by binary, or bipolar components, taking up less storage. More importantly, this opens the door for efficient realization using analog in-memory computing. The universe is written in the language of mathematics and its characters are triangles, circles, and other geometric objects.

Shell Command Tool

This attribute makes it effective at tackling problems where logical rules are exceptionally complex, numerous, and ultimately impractical to code, like deciding how a single pixel in an image should be labeled. For example, the insurance industry manages a lot of unstructured linguistic data from a variety of formats. With expert.ai’s symbolic AI technology, organizations can easily extract key information from within these documents to facilitate policy reviews and risk assessments. This can reduce risk exposure as well as workflow redundancies, and enable the average underwriter to review upwards of four times as many claims. Known as symbolic approach, this method for NLP models can yield both lower computational costs as well as more insightful and accurate results.

If no default implementation or value is found, the method call will raise an exception. In the example above, the causal_expression method iteratively extracts information, enabling manual resolution or external solver usage. Embedded accelerators for LLMs will likely be ubiquitous in future computation platforms, including wearables, smartphones, tablets, and notebooks. These devices will incorporate models similar to GPT-3, ChatGPT, OPT, or Bloom. The metadata for the package includes version, name, description, and expressions. This class provides an easy and controlled way to manage the use of external modules in the user’s project, with main functions including the ability to install, uninstall, update, and check installed modules.

The line with get retrieves the original source based on the vector value of hello and uses ast to cast the value to a dictionary. For example, we can write a fuzzy comparison operation that can take in digits and strings alike and perform a semantic comparison. Often, these LLMs still fail to understand the semantic equivalence of tokens in digits vs. strings and provide incorrect answers. Using the Execute expression, we can evaluate our generated code, which takes in a symbol and tries to execute it. However, in the following example, the Try expression resolves the syntax error, and we receive a computed result. If the neural computation engine cannot compute the desired outcome, it will revert to the default implementation or default value.

The Import class will automatically handle the cloning of the repository and the installation of dependencies that are declared in the package.json and requirements.txt files of the repository. Note that the package.json file is automatically created when you use the Package Initializer tool (symdev) to create a new package. You now have a basic understanding of how to use the Package Runner provided to run packages and aliases from the command line.

The second AI summer: knowledge is power, 1978–1987

Once trained, the deep nets far outperform the purely symbolic AI at generating questions. It contained 100,000 computer-generated images of simple 3-D shapes (spheres, cubes, cylinders and so on). The challenge for any AI is to analyze these images and answer questions that require reasoning. Since some of the weaknesses of neural nets are the strengths of symbolic AI and vice versa, neurosymbolic AI would seem to offer a powerful new way forward. Roughly speaking, the hybrid uses deep nets to replace humans in building the knowledge base and propositions that symbolic AI relies on. It harnesses the power of deep nets to learn about the world from raw data and then uses the symbolic components to reason about it.

Let’s explore three real-world examples of companies powerfully leveraging AI. Companies like IBM are also pursuing how to extend these concepts to solve business symbolic ai example problems, said David Cox, IBM Director of MIT-IBM Watson AI Lab. Connect and share knowledge within a single location that is structured and easy to search.

But today, current AI systems have either learning capabilities or reasoning capabilities —  rarely do they combine both. Now, a Symbolic approach offer good performances in reasoning, is able to give explanations and can manipulate complex data structures, but it has generally serious difficulties in anchoring their symbols in the perceptive world. So, if you use unassisted machine learning techniques and spend three times the amount of money to train a statistical model than you otherwise would on language understanding, you may only get a five-percent improvement in your specific use cases. That’s usually when companies realize unassisted supervised learning techniques are far from ideal for this application. The harsh reality is you can easily spend more than $5 million building, training, and tuning a model. Language understanding models usually involve supervised learning, which requires companies to find huge amounts of training data for specific use cases.

The examples argument defines a list of demonstrations used to condition the neural computation engine, while the limit argument specifies the maximum number of examples returned, given that there are more results. The pre_processors argument accepts a list of PreProcessor objects for pre-processing input before it’s fed into the neural computation engine. The post_processors argument accepts a list of PostProcessor objects for post-processing output before returning it to the user.

Symbolic artificial intelligence is very convenient for settings where the rules are very clear cut,  and you can easily obtain input and transform it into symbols. In fact, rule-based systems still account for most computer programs today, including those used to create deep learning applications. For other AI programming languages see this list of programming languages for artificial intelligence. Currently, Python, a multi-paradigm programming language, is the most popular programming language, partly due to its extensive package library that supports data science, natural language processing, and deep learning.

Although operating with 256,000 noisy nanoscale phase-change memristive devices, there was just a 2.7 percent accuracy drop compared to the conventional software realizations in high precision. To better simulate how the human brain makes decisions, we’ve combined the strengths of symbolic AI and neural networks. This approach is highly interpretable as the reasoning process can be traced back to the logical rules used.

Next, we could recursively repeat this process on each summary node, building a hierarchical clustering structure. Since each Node resembles a summarized subset of the original information, we can use the summary as an index. The resulting tree can then be used to navigate and retrieve the original information, transforming the large data stream problem into a search problem. If a constraint is not satisfied, the implementation will utilize the specified default fallback or default value.

All of this is encoded as a symbolic program in a programming language a computer can understand. One of the main stumbling blocks of symbolic AI, or GOFAI, was the difficulty of revising beliefs once they were encoded in a rules engine. Expert systems are monotonic; that is, the more rules you add, the more knowledge is encoded in the system, but additional rules can’t undo old knowledge. Monotonic basically means one direction; i.e. when one thing goes up, another thing goes up. But the benefits of deep learning and neural networks are not without tradeoffs.

• Please refer to the comments in the code for more detailed explanations of how each method of the Import class works.
• If the neural computation engine cannot compute the desired outcome, it will revert to the default implementation or default value.
• Python includes a read-eval-print loop, functional elements such as higher-order functions, and object-oriented programming that includes metaclasses.
• Symbolic AI’s role in industrial automation highlights its practical application in AI Research and AI Applications, where precise rule-based processes are essential.

By beginning a command with a special character (“, ‘, or `), symsh will treat the command as a query for a language model. We provide a set of useful tools that demonstrate how to interact with our framework and enable package manage. You can access these apps by calling the sym+ command in your terminal or PowerShell. As ‘common sense’ AI matures, it will be possible to use it for better customer support, business intelligence, medical informatics, advanced discovery, and much more. Symbolic artificial intelligence, also known as Good, Old-Fashioned AI (GOFAI), was the dominant paradigm in the AI community from the post-War era until the late 1980s.

It is used to manage expression loading from packages and accesses the respective metadata from the package.json. If your command contains a pipe (|), the shell will treat the text after the pipe as the name of a file to add it to the conversation. The shell command in symsh also has the capability to interact with files using the pipe (|) operator. It operates like a Unix-like pipe but with a few enhancements due to the neuro-symbolic nature of symsh. 2) The two problems may overlap, and solving one could lead to solving the other, since a concept that helps explain a model will also help it recognize certain patterns in data using fewer examples.

It is an essential feature that allows us to chain complex expressions together. Numerous helpful expressions can be imported from the symai.components file. Additionally, the API performs dynamic https://chat.openai.com/ casting when data types are combined with a Symbol object. If an overloaded operation of the Symbol class is employed, the Symbol class can automatically cast the second object to a Symbol.

Stream expressions

The key AI programming language in the US during the last symbolic AI boom period was LISP. LISP is the second oldest programming language after FORTRAN and was created in 1958 by John McCarthy. LISP provided the first read-eval-print loop to support rapid program development.

Neural networks are almost as old as symbolic AI, but they were largely dismissed because they were inefficient and required compute resources that weren’t available at the time. In the past decade, thanks to the large availability of data and processing power, deep learning has gained popularity and has pushed past symbolic AI systems. In contrast to the US, in Europe the key AI programming language during that same period was Prolog. Prolog provided a built-in store of facts and clauses that could be queried by a read-eval-print loop. The store could act as a knowledge base and the clauses could act as rules or a restricted form of logic.

Now researchers and enterprises are looking for ways to bring neural networks and symbolic AI techniques together. In general, language model techniques are expensive and complicated because they were designed for different types of problems and generically assigned to the semantic space. Techniques like BERT, for instance, are based on an approach that works better for facial recognition or image recognition than on language and semantics. Fortunately, symbolic approaches can address these statistical shortcomings for language understanding. They are resource efficient, reusable, and inherently understand the many nuances of language.

To detect conceptual misalignments, we can use a chain of neuro-symbolic operations and validate the generative process. Although not a perfect solution, as the verification might also be error-prone, it provides a principled way to detect conceptual flaws and biases in our LLMs. As long as our goals can be expressed through natural language, LLMs can be used for neuro-symbolic computations. Consequently, we develop operations that manipulate these symbols to construct new symbols.

These model-based techniques are not only cost-prohibitive, but also require hard-to-find data scientists to build models from scratch for specific use cases like cognitive processing automation (CPA). Deploying them monopolizes your resources, from finding and employing data scientists to purchasing and maintaining resources like GPUs, high-performance computing technologies, and even quantum computing methods. We’ve relied on the brain’s high-dimensional circuits and the unique mathematical properties of high-dimensional spaces. Specifically, we wanted to combine the learning representations that neural networks create with the compositionality of symbol-like entities, represented by high-dimensional and distributed vectors. The idea is to guide a neural network to represent unrelated objects with dissimilar high-dimensional vectors.

However, contemporary DRL systems inherit a number of shortcomings from the current generation of deep learning techniques. For example, they require very large datasets to work effectively, entailing that they are slow to learn even when such datasets are available. Moreover, they lack the ability to reason on an abstract level, which makes it difficult to implement high-level cognitive functions such as transfer learning, analogical reasoning, and hypothesis-based reasoning. Finally, their operation is largely opaque to humans, rendering them unsuitable for domains in which verifiability is important. In this paper, we propose an end-to-end reinforcement learning architecture comprising a neural back end and a symbolic front end with the potential to overcome each of these shortcomings.

Marvin Minsky first proposed frames as a way of interpreting common visual situations, such as an office, and Roger Schank extended this idea to scripts for common routines, such as dining out. Cyc has attempted to capture useful common-sense knowledge and has “micro-theories” to handle particular kinds of domain-specific reasoning. Symbolic AI-driven chatbots exemplify the application of AI algorithms in customer service, showcasing the integration of AI Research findings into real-world AI Applications. In Symbolic AI, Knowledge Representation is essential for storing and manipulating information. It is crucial in areas like AI History and development, where representing complex AI Research and AI Applications accurately is vital. At the heart of Symbolic AI lie key concepts such as Logic Programming, Knowledge Representation, and Rule-Based AI.

The tremendous success of deep learning systems is forcing researchers to examine the theoretical principles that underlie how deep nets learn. Researchers are uncovering the connections between deep nets and principles in physics and mathematics. Such causal and counterfactual reasoning about things that are changing with time is extremely difficult for today’s deep neural networks, which mainly excel at discovering static patterns in data, Kohli says. The team solved the first problem by using a number of convolutional neural networks, a type of deep net that’s optimized for image recognition. In this case, each network is trained to examine an image and identify an object and its properties such as color, shape and type (metallic or rubber). On the other hand, learning from raw data is what the other parent does particularly well.

They are not nearly as adept at language understanding as symbolic AI is. For example, it works well for computer vision applications of image recognition or object detection. The ultimate goal, though, is to create intelligent machines able to solve a wide range of problems by reusing knowledge and being able to generalize in predictable and systematic ways. Such machine intelligence would be far superior to the current machine learning algorithms, typically aimed at specific narrow domains.

This implies that we can gather data from API interactions while delivering the requested responses. For rapid, dynamic adaptations or prototyping, we can swiftly integrate user-desired behavior into existing prompts. Moreover, we can log user queries and model predictions to make them accessible for post-processing. Consequently, we can enhance and tailor the model’s responses based on real-world data. Since our approach is to divide and conquer complex problems, we can create conceptual unit tests and target very specific and tractable sub-problems.

For example, Figure 3 shows the steps of geographic reasoning performed by LNN using manually encoded axioms and DBpedia Knowledge Graph to return an answer. A second flaw in symbolic reasoning is that the computer itself doesn’t know what the symbols mean; i.e. they are not necessarily linked to any other representations of the world in a non-symbolic way. Again, this stands in contrast to neural nets, which can link symbols to vectorized representations of the data, which are in turn just translations of raw sensory data.

In the example below, we demonstrate how to use an Output expression to pass a handler function and access the model’s input prompts and predictions. These can be utilized for data collection and subsequent fine-tuning stages. The handler function supplies a dictionary and presents keys for input and output values. The content can then be sent to a data pipeline for additional processing. In the following example, we create a news summary expression that crawls the given URL and streams the site content through multiple expressions.

Japan championed Prolog for its Fifth Generation Project, intending to build special hardware for high performance. Similarly, LISP machines were built to run LISP, but as the second AI boom turned to bust these companies could not compete with new workstations that could now run LISP or Prolog natively at comparable speeds. The rule-based nature of Symbolic AI aligns with the increasing focus on ethical AI and compliance, essential in AI Research and AI Applications. Symbolic AI offers clear advantages, including its ability to handle complex logic systems and provide explainable AI decisions.

In the emulated duckling example, the AI doesn’t know whether a pyramid and cube are similar, because a pyramid doesn’t exist in the knowledge base. To reason effectively, therefore, symbolic AI needs large knowledge bases that have been painstakingly built using human expertise. We believe that Chat GPT LLMs, as neuro-symbolic computation engines, enable a new class of applications, complete with tools and APIs that can perform self-analysis and self-repair. We eagerly anticipate the future developments this area will bring and are looking forward to receiving your feedback and contributions.

The prepare and forward methods have a signature variable called argument which carries all necessary pipeline relevant data. As previously mentioned, we can create contextualized prompts to define the behavior of operations on our neural engine. However, this limits the available context size due to GPT-3 Davinci’s context length constraint of 4097 tokens. This issue can be addressed using the Stream processing expression, which opens a data stream and performs chunk-based operations on the input stream.

Its ability to process complex rules and logic makes it ideal for fields requiring precision and explainability, such as legal and financial domains. Imagine a business where decisions are powered by intelligent systems that predict trends, optimize operations, and automate tasks. This isn’t a distant vision—it’s the reality of artificial intelligence (AI) in business today.

Say you have a picture of your cat and want to create a program that can detect images that contain your cat. You create a rule-based program that takes new images as inputs, compares the pixels to the original cat image, and responds by saying whether your cat is in those images. Using OOP, you can create extensive and complex symbolic AI programs that perform various tasks. The automated theorem provers discussed below can prove theorems in first-order logic. Horn clause logic is more restricted than first-order logic and is used in logic programming languages such as Prolog. Extensions to first-order logic include temporal logic, to handle time; epistemic logic, to reason about agent knowledge; modal logic, to handle possibility and necessity; and probabilistic logics to handle logic and probability together.

So the main challenge, when we think about GOFAI and neural nets, is how to ground symbols, or relate them to other forms of meaning that would allow computers to map the changing raw sensations of the world to symbols and then reason about them. You can foun additiona information about ai customer service and artificial intelligence and NLP. Semantic networks, conceptual graphs, frames, and logic are all approaches to modeling knowledge such as domain knowledge, problem-solving knowledge, and the semantic meaning of language. DOLCE is an example of an upper ontology that can be used for any domain while WordNet is a lexical resource that can also be viewed as an ontology.

The Trace expression allows us to follow the StackTrace of the operations and observe which operations are currently being executed. If we open the outputs/engine.log file, we can see the dumped traces with all the prompts and results. SymbolicAI’s API closely follows best practices and ideas from PyTorch, allowing the creation of complex expressions by combining multiple expressions as a computational graph. It is called by the __call__ method, which is inherited from the Expression base class. The __call__ method evaluates an expression and returns the result from the implemented forward method. This design pattern evaluates expressions in a lazy manner, meaning the expression is only evaluated when its result is needed.