Symbolic AI: The key to the thinking machine

Effective error handling and debugging are essential for ensuring the robustness and reliability of any software system, while explainability is essential for understanding the underlying behavior of the system, especially in the context of AI-driven applications. By developing a system that is both transparent and interpretable, we can gain valuable insights into the performance of the NeSy engines and identify potential areas for improvement. Sequences offer a multitude of advantages in the realm of Expression objects, as they facilitate the creation of more sophisticated structural configurations.

In fact, rule-based AI systems are still very important in today’s applications. Many leading scientists believe that symbolic reasoning will continue to remain a very important component of artificial intelligence. 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.

If we open the outputs/engine.log file, we can see the dumped traces with all the prompts and results. Perhaps one of the most significant advantages of using neuro-symbolic programming is that it allows for a clear understanding of how well our LLMs comprehend simple operations. Specifically, we gain insight into whether and at what point they fail, enabling us to follow their StackTraces and pinpoint the failure points. In our case, neuro-symbolic programming enables us to debug the model predictions based on dedicated unit tests for simple operations.

The subsequent example illustrates the utilization of the & operator to compute the logical implication derived from the interaction of two distinct symbols. The SymbolicAI framework is designed to leverage multiple engines for a variety of operations. To fully utilize these capabilities, you may install additional dependencies or set up the optional API keys for specific engines like WolframAlpha, SerpApi, and others. In Figure 11 we conceptually outline the connection between the utilization of an LLM and its interact with other tools and solvers. Instructions and operations can be initiated by any user, pre-scripted knowledge base or learned meta agent. It holds not only the value itself, but metadata that guides its transformation and interpretation.

Google made a big one, too, which is what provides the information in the top box under your query when you search for something easy like the capital of Germany. These systems are essentially piles of nested if-then statements drawing conclusions about entities (human-readable concepts) and their relations (expressed in well understood semantics like X is-a man or X lives-in Acapulco). This research is also limited by current LLM’s capacity for reasoning and generalization. Although progress has been made, models are still prone to hallucinations and reasoning errors, especially when dealing with abstract, novel, or highly complex problem statements (Marcus, 2020).

You can access the Package Runner by using the symrun command in your terminal or PowerShell. This feature enables you to maintain highly efficient and context-thoughtful conversations with symsh, especially useful when dealing with large files where only a subset of content in specific locations within the file is relevant at any given moment. 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.

Stream expressions

Full logical expressivity means that LNNs support an expressive form of logic called first-order logic. This type of logic allows more kinds of knowledge to be represented understandably, with real values allowing representation of uncertainty. Many other approaches only support simpler forms of logic like propositional logic, or Horn clauses, or only approximate the behavior of first-order logic. 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 pattern property can be used to verify if the document has been loaded correctly. If the pattern is not found, the crawler will timeout and return an empty result. Alternatively, vector-based similarity search can be used to find similar nodes. Libraries such as Annoy, Faiss, or Milvus can be employed for searching in a vector space. In the illustrated example, all individual chunks are merged by clustering the information within each chunk.

We believe that 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 Package Initializer creates the package in the .symai/packages/ directory in your home directory (~/.symai/packages//). Within the created package you will see the package.json config file defining the new package metadata and symrun entry point and offers the declared expression types to the Import class. In this work, we approach KBQA with the basic premise that if we can correctly translate the natural language questions into an abstract form that captures the question’s conceptual meaning, we can reason over existing knowledge to answer complex questions. Table 1 illustrates the kinds of questions NSQA can handle and the form of reasoning required to answer different questions.

The resulting measure, i.e., the success rate of the model prediction, can then be used to evaluate their performance and hint at undesired flaws or biases. We are aware that not all errors are as simple as the syntax error example shown, which can be resolved automatically. Many errors occur due to semantic misconceptions, requiring contextual information. We are exploring more sophisticated error handling mechanisms, including the use of streams and clustering to resolve errors in a hierarchical, contextual manner. It is also important to note that neural computation engines need further improvements to better detect and resolve errors. Acting as a container for information required to define a specific operation, the Prompt class also serves as the base class for all other Prompt classes.

The technology actually dates back to the 1950s, says expert.ai’s Luca Scagliarini, but was considered old-fashioned by the 1990s when demand for procedural knowledge of sensory and motor processes was all the rage. Now that AI is tasked with higher-order systems and data management, the capability to engage in logical thinking and knowledge representation is cool again. By enabling sentence subtraction and dynamic casting within SymbolicAI, we utilize the generalization capability of NeSy engines to manipulate and refine text-based data, creating more meaningful and contextually relevant outcomes. The integration of dynamic casting with Symbol objects in our API allows the users to perform operations between Symbol objects and various data types, such as strings, integers, floats, lists, etc. without compromising on readability or simplicity. The aspect-oriented programming paradigm offers a functional approach for extending or modifying the behavior of functions or methods without altering their code directly. This adheres to the principles of modularity and separation of concerns, as it allows for the isolation of specific functionalities while maintaining the original function’s core purpose.

Further Reading on Symbolic AI

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. Contrasting Symbolic AI with Neural Networks offers insights into the diverse approaches within AI. In Symbolic AI, Knowledge Representation is essential for storing and manipulating information.

SPPL is different from most probabilistic programming languages, as SPPL only allows users to write probabilistic programs for which it can automatically deliver exact probabilistic inference results. SPPL also makes it possible for users to check how fast inference will be, and therefore avoid writing slow programs. In summary, Stream expressions offer the advantage of processing large data streams in a more efficient and organized manner, while also enabling the integration with other expressions like Sequence and Cluster expressions. These combinations allow for a more effective approach to handling context limitations, promoting the extraction of meaningful information and improving the overall performance of the framework.

For more details, refer to the ”Local Neuro-Symbolic Engine” section in the documentation., or with engines powered by external APIs such as OpenAI’s API, additional installation steps are required. In practice, consider the Expression class, which extends the functionality of ‘Symbol‘. When composing a Sequence of Expression objects, we are effectively composing operations in a predetermined order. In this section, we address the limitations of SymbolicAI and the future directions we are focusing on.

This article was written to answer the question, “what is symbolic artificial intelligence.” Looking to enhance your understanding of the world of AI? Looking ahead, Symbolic AI’s role in the broader AI landscape remains significant. Ongoing research and development milestones in AI, particularly in integrating Symbolic AI with other AI algorithms like neural networks, continue to expand its capabilities and applications. Symbolic AI has numerous applications, from Cognitive Computing in healthcare to AI Research in academia.

Its ability to process and apply complex sets of rules and logic makes it indispensable in various domains, complementing other AI methodologies like Machine Learning and Deep Learning. MIT researchers have developed a new artificial intelligence programming language that can assess the fairness of algorithms more exactly, and more quickly, than available alternatives. One of the fundamental aspects of the SymbolicAI API is being able to generate code.

Operations

Another concern is how to assess the disentanglement of evaluations of models on downstream tasks, to avoid testing on training samples, especially for closed-source solutions like GPT. Analogous to the Python object type, the base type of SymbolicAI is a symbol represented through its name equivalent base type Symbol. All other subtypes, such as Expression and its derivatives, are analogous to their mathematical namesakes, representing expressions or units that can be further evaluated and simplified. These subtypes inherit from Symbol the base attributes, primitive operators, and helper methods. Furthermore, each Symbol object contains valued and vector-valued representations, obtained through value and embedding attributes. The latter, in particular, serve as a means to attribute a symbol’s current context, akin to embedding text and storing it as a PyTorch tensor (Paszke et al., 2019) or NumPy array (Harris et al., 2020).

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.

Notably, deep learning algorithms are opaque, and figuring out how they work perplexes even their creators. Deep neural networks are also very suitable for reinforcement learning, AI models that develop their behavior through numerous trial and error. This is the kind of AI that masters complicated games such as Go, StarCraft, and Dota. Symbolic AI involves the explicit embedding of human knowledge and behavior rules into computer programs.

• This will be then sent as a string representation to the engines to execute the needed operations.
• This can hinder trust and adoption in sensitive applications where interpretability of predictions is important.
• A key component of the system architecture for all expert systems is the knowledge base, which stores facts and rules for problem-solving.[51]

  The simplest approach for an expert system knowledge base is simply a collection or network of production rules.

• One of the most prominent illustrations of this concept is exhibited by Word2Vec (Mikolov et al., 2013).

SymbolicAI allows the creation of entire workflows, such as writing scientific papers. The following example defines a Paper expression that takes in a sequence of expressions which are executed in sequentially. The Method expression contains a Source expression, which addresses the code base of the actual method of the paper.

The output of a classifier (let’s say we’re dealing with an image recognition algorithm that tells us whether we’re looking at a pedestrian, a stop sign, a traffic lane line or a moving semi-truck), can trigger business logic that reacts to each classification. Although current execution cycles are slow and error-prone, we expect to see further performance gains through improved operating system level optimizations, dedicated GPU-centric hardware refinement, and improved software interoperability. We believe that modern programming paradigms should natively support probabilistic concepts and provide a boilerplate-free set of features for constructing and evaluating generative computational graphs. This includes but is not limited to compositional, parallelizable, and simulation-based executions with polymorphic and self-referential structures.

This design pattern evaluates expressions in a lazy manner, meaning the expression is only evaluated when its result is needed. It is an essential feature that allows us to chain complex expressions together. We will now demonstrate how we define our Symbolic API, which is based on object-oriented and compositional design patterns. The Symbol class serves as the base class for all functional operations, and in the context of symbolic programming (fully resolved expressions), we refer to it as a terminal symbol. The Symbol class contains helpful operations that can be interpreted as expressions to manipulate its content and evaluate new Symbols.

For instance, two representations may address the same topic, such as the problem description and its respective solution, however, when measuring their similarity we obtain similarity scores of ∼70%similar-toabsentpercent70\sim 70\%∼ 70 %. We normalize this by subtracting an inherent baseline and randomness effect, however, to ensure a more holistic and robust measurement we would need a significantly larger amount of baselines and experiments. Since we were very limited in the availability of development resources, and some presented models are only addressable through costly API walls.

As a result, our approach works to enable active and transparent flow control of these generative processes. 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. To that end, we propose Object-Oriented Deep Learning, a novel computational paradigm of deep learning that adopts interpretable “objects/symbols” as a basic representational atom instead of N-dimensional tensors (as in traditional “feature-oriented” deep learning). 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.

Similarly, Allen’s temporal interval algebra is a simplification of reasoning about time and Region Connection Calculus is a simplification of reasoning about spatial relationships. Qualitative simulation, such as Benjamin Kuipers’s QSIM,[88] approximates human reasoning about naive physics, such as what happens when we heat a liquid in a pot on the stove. We expect it to heat and possibly boil over, even though we may not know its temperature, its boiling point, or other details, such as atmospheric pressure.

Operations then return one or multiple new objects, which primarily consist of new symbols but may include other types as well. Polymorphism plays a crucial role in operations, allowing them to be applied to various data types such as strings, integers, floats, and lists, with different behaviors based on the object instance. Symbolic reasoning uses formal languages and logical rules to represent knowledge, enabling tasks such as planning, problem-solving, and understanding causal relationships. While symbolic reasoning systems excel in tasks requiring explicit reasoning, they fall short in tasks demanding pattern recognition or generalization, like image recognition or natural language processing.

Subclassing the Symbol class allows for the creation of contextualized operations with unique constraints and prompt designs by simply overriding the relevant methods. However, it is recommended to subclass the Expression class for additional functionality. The AMR is aligned to the terms used in the knowledge graph using entity linking and relation linking modules and is then transformed to a logic representation.5 This logic representation is submitted to the LNN. LNN performs necessary reasoning such as type-based and geographic reasoning to eventually return the answers for the given question. 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.

Central to our solution is a method to define and measure the orchestration of interactions between symbolic and sub-symbolic systems, and the level at which instructions are formulated for effective control and task execution. New deep learning approaches based on Transformer models have now eclipsed these earlier symbolic AI approaches and attained state-of-the-art performance in natural language processing. However, Transformer models are opaque and do not yet produce human-interpretable semantic representations for sentences and documents. Instead, they produce task-specific vectors where the meaning of the vector components is opaque. 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.

We chose to focus on KBQA because such tasks truly demand advanced reasoning such as multi-hop, quantitative, geographic, and temporal reasoning. Natural language processing focuses on treating language as data to perform tasks such https://chat.openai.com/ as identifying topics without necessarily understanding the intended meaning. Natural language understanding, in contrast, constructs a meaning representation and uses that for further processing, such as answering questions.

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. In the following example, we create a news summary expression that crawls the given URL and streams the site content through multiple expressions. The Trace expression allows us to follow the StackTrace of the operations and observe which operations are currently being executed.

There have been several efforts to create complicated symbolic AI systems that encompass the multitudes of rules of certain domains. Called expert systems, these symbolic AI models use hardcoded knowledge and rules to tackle complicated tasks such as medical diagnosis. But they require a huge amount of effort by domain experts and software engineers and only work in very narrow use cases. As soon as you generalize the problem, there will be an explosion of new rules to add (remember the cat detection problem?), which will require more human labor. OOP languages allow you to define classes, specify their properties, and organize them in hierarchies.

Lastly, the decorator_kwargs argument passes additional arguments from the decorator kwargs, which are streamlined towards the neural computation engine and other engines. The main goal of our framework is to enable reasoning capabilities on top of the statistical inference of Language Models (LMs). As a result, our Symbol objects offers operations to perform deductive reasoning expressions.

The following section demonstrates that most operations in symai/core.py are derived from the more general few_shot decorator. The metadata for the package includes version, name, description, and expressions. If the alias specified cannot be found in the alias file, the Package Runner will attempt to run the command as a package. If the package is not found or an error occurs during execution, an appropriate error message will be displayed. The Package Runner is a command-line tool that allows you to run packages via alias names. It provides a convenient way to execute commands or functions defined in packages.

Lastly, symbolic AI struggles with real-world data’s unpredictability and variability. These challenges have led to the employment of statistical learning methodologies, like deep learning (Alom et al., 2018), which are more adept at managing noise and uncertain information through vector-valued representations. In SymbolicAI, operators are overloaded to facilitate transformations of Symbol objects. These operator primitives employ dynamic casting to assure type compatibility, simplifying declarations. Consequently, Symbol objects can be easily manipulated through type specific attributions or symbolically evaluated by the NeSy engine.

During the first AI summer, many people thought that machine intelligence could be achieved in just a few years. By the mid-1960s neither useful natural language translation systems nor autonomous tanks had been created, and a dramatic backlash set in. One of the keys to symbolic AI’s success is the way it functions within a rules-based environment. Typical AI models tend to drift from their original intent as new data influences changes in the algorithm. Scagliarini says the rules of symbolic AI resist drift, so models can be created much faster and with far less data to begin with, and then require less retraining once they enter production environments. 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.

The conjecture behind the DSN model is that any type of real world objects sharing enough common features are mapped into human brains as a symbol. Those symbols are connected by links, representing the composition, correlation, causality, or other relationships between them, forming a deep, hierarchical symbolic network structure. Powered by such a structure, the DSN model is expected to learn like humans, because of its unique characteristics.

Its ability to process complex rules and logic makes it ideal for fields requiring precision and explainability, such as legal and financial domains. Symbolic AI’s logic-based approach contrasts with Neural Networks, which are pivotal in Deep Learning and Machine Learning. Neural Networks learn from data patterns, evolving through AI Research and applications.

Time periods and titles are drawn from Henry Kautz’s 2020 AAAI Robert S. Engelmore Memorial Lecture[17] and the Chat PG longer Wikipedia article on the History of AI, with dates and titles differing slightly for increased clarity.

Symbolic Artificial Intelligence, or AI for short, is like a really smart robot that follows a bunch of rules to solve problems. In Symbolic AI, we teach the computer lots of rules and how to use them to figure things out, just like you learn rules in school to solve math problems. This way of using rules in AI has been around for a long time and is really important for understanding how computers can be smart. Error from approximate probabilistic inference is tolerable in many AI applications. But it is undesirable to have inference errors corrupting results in socially impactful applications of AI, such as automated decision-making, and especially in fairness analysis.

• Lastly, with sufficient data, we could fine-tune methods to extract information or build knowledge graphs using natural language.
• For rapid, dynamic adaptations or prototyping, we can swiftly integrate user-desired behavior into existing prompts.

) operator.

• The ID is for instance used in core.py decorators to address where to send the zero/few-shot statements using the class EngineRepository.
• These operator primitives employ dynamic casting to assure type compatibility, simplifying declarations.
• Constraint solvers perform a more limited kind of inference than first-order logic.

For example, they require very large datasets to work effectively, entailing that they are slow to learn even when such datasets are available. You can foun additiona information about ai customer service and artificial intelligence and NLP. 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.

Our model builds an object-based scene representation and translates sentences into executable, symbolic programs. To bridge the learning of two modules, we use a neuro-symbolic reasoning module that executes these programs on the latent scene representation. Analog to the human concept learning, given the parsed program, the perception module learns visual concepts based on the language description of the object being referred to. Meanwhile, the learned visual concepts facilitate learning new words and parsing new sentences. We use curriculum learning to guide searching over the large compositional space of images and language.

Our thanks are equally extended to Gary Marcus, whose stimulating discussions sparked numerous innovative ideas incorporated into our framework. Finally, we also wish to express our concern about recent economic trends in the deep-tech industry, where we observe AI-related concentration of data and resources, coupled with a tendency towards closed-source practices. We strongly advocate for increased transparency and exchange of ideas to ensure a diverse and collective growth in our socio-economic landscape. In our evaluation of Figure 5 we conclude with the cumulative score, for the following base performance criteria. Opposing Chomsky’s views that a human is born with Universal Grammar, a kind of knowledge, John Locke[1632–1704] postulated that mind is a blank slate or tabula rasa. The grandfather of AI, Thomas Hobbes said — Thinking is manipulation of symbols and Reasoning is computation.

In broad AI, systems are engineered to handle a range of tasks with a high degree of autonomy, utilizing sensory input, accumulated experiences, and previously developed skills. Over time, it aims to develop the ability to autonomously generate its own plans, efficiently schedule tasks and subtasks, and carefully select the most suitable tools for each task. Our protocol lays the groundwork for this agent to learn and expand its base set of capabilities (Amaro et al., 2023), moving towards more sophisticated, self-referential orchestration of multi-step tasks. We’ve already noticed that research is shifting towards this type of methodology (Yuan et al., 2024).

If you want to add your project, feel free to message us on Twitter at @SymbolicAPI or via Discord. This command will clone the module from the given GitHub repository (ExtensityAI/symask in this case), install symbolic ai examples any dependencies, and expose the module’s classes for use in your project. You now have a basic understanding of how to use the Package Runner provided to run packages and aliases from the command line.

However, the key distinction lies in the fact that we operate within the natural language domain, as opposed to a vector space. Consequently, this grants us the capability to conduct arithmetic on words, sentences, paragraphs, and the like, while simultaneously validating the outcomes in a human-readable format. A computational graph in the SymbolicAI framework is an assembly of interconnected Symbol objects, each encapsulating a unit of data and the operations that can be performed on it.

The sub-symbolic framework, rooted in neural network paradigms, began with pioneering works such as the perceptron (McCulloch & Pitts, 1943), with the first hardware implementation quickly following (Rosenblatt, 1958). Fast-forward, contemporary frameworks achieve a significant leap with the introduction of the Transformer architecture (Vaswani et al., 2017), which underpins most of today’s LLMs. These LLMs demonstrate exceptional capabilities in in-context learning, a method popularized by the likes of GPT-3 (Brown et al., 2020), where models improve task performance through natural language instruction and examples provided directly in the input prompt. While in-context learning bypasses the need for explicit retraining, it demands meticulous prompt design to steer models towards desired behaviors.