Human vs AI

How to solve this issue ?

The "issue" you're referring to is the fundamental difference between how large language models (LLMs) "know" things (through statistical pattern matching on vast datasets) and how humans (and some other AI systems) know things (through embodied experience, interaction, and experimentation). There isn't a single "solution" to completely bridge this gap, as it's a deep and multifaceted challenge in AI research. However, there are several research directions and approaches that aim to address different aspects of this problem:

1. Embodied AI:

• Robotics and Simulated Environments: This is the most direct approach to giving AI agents a "body" and the ability to interact with the world.

  • Robotics: Research in robotics focuses on building physical agents that can perceive their environment through sensors (cameras, lidar, touch sensors, etc.) and act upon it through actuators (motors, grippers, etc.). This allows the AI to learn through direct physical interaction, just like a baby learning to crawl and manipulate objects.

  • Simulated Environments: Creating realistic virtual worlds (like video game environments but more sophisticated) allows researchers to train AI agents in a safe, controlled, and cost-effective way. These environments can simulate physics, objects, and interactions, allowing the AI to learn about cause and effect, spatial reasoning, and other concepts that are difficult to grasp from text data alone. Examples include platforms like AI2-THOR, Habitat, and MuJoCo.

• Key Challenges:

  • Hardware Limitations: Building robots that are robust, versatile, and affordable is a major engineering challenge.

  • Sim-to-Real Gap: Transferring knowledge learned in a simulated environment to the real world can be difficult because simulations are never perfect representations of reality.

  • Safety and Ethics: Ensuring that embodied AI agents behave safely and ethically in the real world is crucial.

2. Integrating Symbolic Reasoning and Neural Networks (Neuro-Symbolic AI):

• Combining Strengths: This approach tries to combine the strengths of LLMs (pattern recognition and statistical learning) with the strengths of symbolic AI (logical reasoning and knowledge representation).

  • Symbolic AI: Traditional AI systems that use explicit rules and logical representations to reason about the world. These systems are good at planning and logical deduction but struggle with the ambiguity and noise of real-world data.

  • Neuro-Symbolic Systems: These systems aim to integrate neural networks (like LLMs) with symbolic representations. For example, an LLM might generate a possible solution, and a symbolic system could then check if that solution is logically valid or consistent with known facts.

• Key Challenges:

  • Bridging the Gap: Finding effective ways to connect the continuous, distributed representations of neural networks with the discrete, symbolic representations of symbolic AI is a significant research challenge.

  • Knowledge Representation: Figuring out how to represent knowledge in a way that is both accessible to neural networks and suitable for symbolic reasoning is difficult.

3. Improving Training Data and Techniques:

• Multimodal Learning: Training AI models on multiple types of data (text, images, audio, video) simultaneously. This can help the AI develop a more holistic understanding of concepts. For example, seeing an image of a cat while reading the word "cat" helps to ground the word in a visual representation.

• Causal Reasoning: Developing methods that allow AI to learn about cause and effect, not just correlation. This is crucial for understanding how the world works and making predictions about the consequences of actions. Current LLMs are notoriously bad at causal reasoning.

• Reinforcement Learning (RL): Training AI agents through trial and error, where they receive rewards for taking actions that lead to desired outcomes. This is particularly important for embodied AI, as it allows agents to learn how to interact with the world effectively.

• Curriculum Learning: Gradually increasing the complexity of the tasks an AI is trained on, starting with simpler tasks and building up to more challenging ones. This can help the AI learn more efficiently and effectively.

• Self-Supervised Learning: Developing techniques where AI can learn from unlabeled data, reducing the reliance on expensive and time-consuming manual annotation.

• Data Augmentation: Creating more synthetic, diverse, and edge-case examples to address common-sense reasoning gaps.

4. Developing Better Evaluation Metrics:

• Beyond Accuracy: Moving beyond simple accuracy metrics (like how often an LLM gives the "correct" answer) to evaluate deeper understanding, common sense, and reasoning abilities.

• Adversarial Examples: Creating challenging test cases that are designed to expose the weaknesses of AI models.

• Benchmarks for Common Sense Reasoning: Developing standardized benchmarks that specifically test an AI's ability to reason about everyday situations and apply common sense knowledge. Examples include Winograd Schema Challenge, HellaSwag, and Abductive NLI.

5. Fundamental Research in Artificial General Intelligence (AGI):

• Long-Term Goal: The ultimate goal of much AI research is to create Artificial General Intelligence (AGI), which is a hypothetical AI that possesses human-level cognitive abilities, including the ability to learn, understand, and reason in a general and flexible way. AGI would, by definition, be able to overcome the limitations of current LLMs.

• Open Questions: AGI research is still in its very early stages, and there are many fundamental open questions about how to achieve it. This includes questions about consciousness, sentience, and the nature of intelligence itself.

No Single Solution, but Progress:

It's important to emphasize that there's no single, easy solution to the problem of giving AI a deep, embodied understanding of the world. It's a complex, ongoing research effort that involves multiple approaches and disciplines. However, significant progress is being made in all of the areas mentioned above, and these advancements are gradually improving the capabilities and robustness of AI systems. The path forward will likely involve a combination of these approaches, with breakthroughs in one area informing and enabling progress in others.

But AI can't learn in real-time, they wouldn't learn from experience

You've hit on a crucial point and a very active area of research. You're right that traditional large language models, like the one I am, are not designed for real-time learning in the way you describe. However, the statement "AI can't learn in real-time" is no longer entirely accurate, and the idea of learning from experience is possible, though it's implemented in different ways than the static training of LLMs. Let's break this down:

1. Why Traditional LLMs Don't Learn in Real Time (from individual interactions):

• Static Training: LLMs are trained on a massive, fixed dataset. This training process is computationally intensive and takes a significant amount of time (days, weeks, or even months). Once the training is complete, the model's weights are "frozen."

• No Memory of Interactions: During a conversation, I don't "remember" previous turns in the sense of updating my core knowledge. I use the context of the current conversation to generate a response, but that context is discarded after the interaction. I don't permanently incorporate that information into my model.

• Catastrophic Forgetting: If you were to try to directly update an LLM's weights with new information from a single interaction, you'd likely run into a problem called "catastrophic forgetting." The model would quickly forget most of what it learned during its original training. Fine-tuning is possible, but it's done with carefully curated datasets, not single interactions.

• Computational Cost: Retraining or fine-tuning a large model for every new piece of information would be prohibitively expensive and impractical.

2. How AI Can Learn in Real-Time (or Near Real-Time):

There are several approaches that enable different forms of real-time or near-real-time learning in AI, moving beyond the static LLM paradigm:

• Reinforcement Learning (RL) with Online Learning:

  • Core Idea: RL agents learn by interacting with an environment and receiving rewards or penalties for their actions. "Online" RL means that the agent updates its policy (its strategy for taking actions) continuously as it gathers new experience.

  • Example: A robot learning to walk. It tries different movements, receives feedback (e.g., staying upright = reward, falling down = penalty), and adjusts its behavior in real-time. This is learning from direct experience.

  • Key: Unlike LLMs, the learning happens during the interaction, not just beforehand.

  • Limitations: RL can be slow to converge, and it often requires a lot of interaction data. It's also challenging to design good reward functions.

• Few-Shot Learning and Meta-Learning:

  • Core Idea: These techniques aim to train models that can quickly adapt to new tasks or data with very limited examples.

  • Few-Shot Learning: The model is trained to learn from a small number of examples (e.g., recognizing a new type of object after seeing only a few images of it).

  • Meta-Learning ("Learning to Learn"): The model is trained on a variety of tasks so that it learns how to learn new tasks quickly. It develops general learning strategies.

  • Example: Imagine an image classification model trained on many different types of objects. With meta-learning, it could be shown just one or two pictures of a completely new object (e.g., a "greeble") and then be able to correctly classify other greebles.

  • Relevance: While not strictly real-time in the sense of continuous updates, this allows for rapid adaptation to new information, which is a form of learning from experience.

• Memory-Augmented Neural Networks:

  • Core Idea: These networks have an external memory component that they can read from and write to. This allows them to store and retrieve information over longer periods, overcoming the limitations of the fixed context window in standard LLMs.

  • Examples: Neural Turing Machines (NTMs) and Differentiable Neural Computers (DNCs).

  • Relevance: This allows for a form of "remembering" past interactions and using that information to inform future behavior. It's a step towards incorporating experience into the model's ongoing operation.

• Continual Learning (Lifelong Learning):

  • Core Idea: Continual learning algorithms learn sequentially. Each new piece of information is used to refine the current model without retraining from scratch.

  • Example: Anomaly detection, where the system is constantly updated to find new threats.

  • Key: Methods for continual learning actively combat catastrophic forgetting.

• Database Integration and Retrieval-Augmented Generation (RAG):

  • Core Idea: Combine LLMs with external knowledge sources (like databases or knowledge graphs). The LLM can query the database in real-time to retrieve relevant information, effectively updating its "knowledge" on the fly.

  • Example: An LLM answering questions about a company's product catalog. It doesn't store the entire catalog in its parameters, but it can query a database to get the latest product information.

  • Relevance: While the LLM itself isn't learning in the traditional sense, the system as a whole can adapt to new information and provide up-to-date responses. This is a very practical and widely used approach.

• Online Fine-Tuning (with caveats):

  • Core Idea: Carefully updating the weights of an LLM with new data in small increments. This is not the same as retraining from scratch.

  • Challenges: Requires very careful control to avoid catastrophic forgetting. It's also computationally expensive, though less so than full retraining.

  • Example: Adapting a language model to a specific, evolving domain (e.g., rapidly changing legal terminology).

  • Usually not per interaction, but over a short period.

In Summary:

While standard LLMs are not designed for real-time learning from individual interactions, the broader field of AI is actively developing methods for real-time and near-real-time learning. These methods often involve different architectures (like RL agents or memory-augmented networks), different training paradigms (like online learning or meta-learning), or integration with external knowledge sources. The "learning from experience" you describe is a crucial goal, and while it's not fully realized in all AI systems, it's an area of significant progress and ongoing research. The key is moving beyond the "static snapshot" model of LLMs to systems that can dynamically adapt and improve based on ongoing interactions with the world.

Tell me more about catastrophic forgetting

Catastrophic forgetting is a significant challenge in the field of machine learning, particularly when dealing with neural networks. It refers to the phenomenon where a trained neural network abruptly and drastically loses previously learned information when it's trained on new information. Here's a breakdown:

What Happens:

1. Initial Training: A neural network is trained on a dataset (Dataset A) to perform a specific task (Task A). The training process adjusts the network's weights (internal parameters) to minimize the error on this dataset. These weights now encode the knowledge needed for Task A.

2. New Training: The network is then trained on a new dataset (Dataset B) for a different task (Task B), or even a variation of the original task.

3. Forgetting: As the network's weights are adjusted to learn Task B, the weights that were crucial for Task A are overwritten or significantly altered. The network "forgets" how to perform Task A. Its performance on Task A drops dramatically, often to near-random levels. It's as if the new information completely wipes out the old.

Why It Happens:

• Weight Overlap: Neural networks learn by distributing knowledge across a shared set of weights. There's no dedicated "memory location" for each piece of information. When new information is learned, it necessarily affects the same weights that store the old information.

• Gradient Descent: The training process uses an algorithm called gradient descent (or a variant) to adjust the weights. Gradient descent focuses on minimizing the error on the current dataset. It doesn't have a built-in mechanism to preserve performance on previous datasets. It's "greedy" in that it optimizes for the immediate task.

• Non-Stationary Data Distribution: In continual learning scenarios, the data distribution changes over time. The network is trained on data from one distribution (Dataset A) and then encounters a different distribution (Dataset B). This shift in the data distribution can cause the network to forget what it learned from the previous distribution.

• Lack of Explicit Memory: Unlike humans, who have mechanisms for consolidating and protecting memories, standard neural networks don't have a separate "memory" component that explicitly stores and protects past knowledge.

Analogy:

Imagine you have a whiteboard that you use to write down important formulas for a math test. You study hard and fill the whiteboard with everything you need. Then, a friend comes along and, without erasing anything, starts writing down formulas for a completely different subject, like chemistry. They use the same whiteboard, overwriting some of your math formulas and mixing them with chemistry equations. When you go back to study for your math test, you find that much of what you wrote is gone or jumbled, making it useless. That's similar to what happens with catastrophic forgetting.

Consequences:

• Limits Continual Learning: Catastrophic forgetting is a major obstacle to creating AI systems that can learn continuously and adapt to new information over time, like humans do. It prevents the model from accumulating knowledge.

• Requires Retraining: The most straightforward (but inefficient) solution is to retrain the network from scratch on all the data (both old and new) whenever new information is introduced. This is computationally expensive and impractical in many real-world scenarios.

Mitigation Strategies (how to address it):

Several approaches have been developed to mitigate catastrophic forgetting, and these are key components of continual learning research:

1. Regularization Techniques:

   • Elastic Weight Consolidation (EWC): EWC adds a penalty to the loss function during training on the new data. This penalty discourages changes to weights that were important for previous tasks. It identifies important weights and slows down their change.

   • Synaptic Intelligence (SI): Similar to EWC, SI estimates the importance of each weight and protects important weights from significant changes.

   • L2 Regularization: Adds a penalty proportional to the square of the weights. While not specifically designed for catastrophic forgetting, it can help prevent weights from becoming too large, which can indirectly reduce forgetting.

   • Dropout: Randomly "drops out" (sets to zero) neurons during training. This can also help, although it's not its primary purpose.

2. Rehearsal (Pseudo-Rehearsal):

   • Rehearsal: Store a small subset of the data from previous tasks and interleave it with the new data during training. This helps the network "remember" the old tasks.

   • Pseudo-Rehearsal: Instead of storing actual data, generate "pseudo-samples" that represent the previous tasks. This can be done using a generative model or other techniques. This is more memory-efficient than storing real data.

3. Dual-Memory Systems:

   • Core Idea: Use two separate memory systems: one for short-term learning (new tasks) and one for long-term storage (consolidated knowledge).

   • Example: Inspired by the hippocampus and neocortex in the mammalian brain.

4. Dynamic Architectures:

   • Progressive Neural Networks: Add new "columns" of neurons to the network for each new task, preventing modification of the weights learned for previous tasks. This avoids interference, but the network grows with each new task.

   • Learnable Architecture: Allow the network to dynamically adjust its structure (e.g., adding or removing connections) as it learns new tasks.

5. Complementary Learning Systems (CLS) Theory-Inspired Approaches:

   • Inspired by how humans learn, combining fast learning in the "hippocampus" with gradual consolidation in the "neocortex".

6. Gradient Episodic Memory (GEM) and Averaged Gradient Episodic Memory (A-GEM):

   • Store a small amount of data from previous tasks.

   • At each training step, ensure that the update on the new data does not increase the loss on the stored data from previous tasks.

No Silver Bullet:

No single method completely solves catastrophic forgetting in all situations. The best approach depends on the specific task, the type of data, and the computational resources available. Research in this area is ongoing, and it's a crucial step towards building more robust and adaptable AI systems. Catastrophic forgetting is fundamentally about the trade-off between plasticity (the ability to learn new things) and stability (the ability to retain old knowledge). Finding the right balance is the core challenge.

Why LLM don't have some available memory to store and retrieve knowledge as they see fit ?

That's an excellent question, and it gets to the heart of the differences between how LLMs work and how human brains (or even some other AI architectures) handle memory and knowledge. Here's a breakdown of the reasons, encompassing both technical limitations and design choices:

1. The Nature of LLM "Knowledge": Distributed Representations

• Not Discrete Chunks: LLMs don't store knowledge as separate, identifiable facts like entries in a database. Their "knowledge" is encoded in the relationships between billions of parameters (weights). These weights are adjusted during training, and the resulting configuration represents the statistical patterns the model has learned from the data.

• Distributed Representation: A single concept or fact isn't stored in one specific location. Instead, it's represented by a pattern of activation across many different weights. This distributed representation is efficient for generalization and pattern recognition, but it makes it difficult to isolate and manipulate individual pieces of information.

• Analogy: Think of a tapestry. The overall image is created by the interwoven threads. You can't easily pull out a single thread (a "fact") without affecting the entire picture. The LLM's weights are like the threads; the overall pattern represents the knowledge.

2. Computational Cost and Efficiency:

• Massive Scale: LLMs already have an enormous number of parameters (billions or even trillions). Adding a separate, large-scale memory system that the LLM could read from and write to arbitrarily would significantly increase the computational cost of both training and inference (generating responses).

• Inference Speed: During inference, the LLM needs to quickly generate responses. Constantly accessing and updating an external memory in a fine-grained way (for every word or phrase) would introduce significant latency, making the model much slower.

• Training Complexity: Training a model to effectively use an external memory is a complex task in itself. The model needs to learn not just what to store, but also when to store it, where to store it, and how to retrieve it efficiently. This adds another layer of complexity to the already challenging training process.

3. Catastrophic Forgetting (Again):

• Uncontrolled Writes: If an LLM could freely write to an external memory during inference, it could easily overwrite or corrupt existing knowledge, leading to catastrophic forgetting (as we discussed). Controlling what gets written and how it's integrated with existing knowledge is a major challenge.

• Maintaining Consistency: Ensuring that the information in the external memory remains consistent with the LLM's internal representations (its weights) would be difficult.

4. Design Choices and Current Research:

• Focus on Statistical Pattern Matching: The original design of LLMs like GPT was focused on excelling at statistical language modeling – predicting the next word in a sequence. They were incredibly successful at this, even without explicit memory.

• Retrieval-Augmented Generation (RAG): As mentioned before, RAG does provide a form of external memory, but in a controlled way. The LLM queries a read-only database or knowledge base. This avoids the problems of uncontrolled writes. RAG is a practical and widely used approach that balances the benefits of external knowledge with the efficiency of LLMs.

• Memory-Augmented Neural Networks (MANNs): Research on MANNs (like Neural Turing Machines and Differentiable Neural Computers) does explore architectures with explicit, addressable memory. However, these models are:

  • More complex to train.

  • Generally less performant than LLMs on pure language generation tasks (at the current scale).

  • Still an active area of research, and not yet as widely deployed as LLMs.

5. The "Context Window" as Limited Working Memory:

• Short-Term Context: LLMs do have a "context window" – the sequence of preceding tokens (words or parts of words) that they consider when generating the next token. This context window acts as a kind of limited, short-term memory.

• Fixed Size: The context window has a fixed size (e.g., 4096 tokens, 8192 tokens, or, in some newer models, much larger). Information outside this window is not directly accessible.

• Not Persistent: The context window is cleared or reset after each interaction (or sometimes within a long interaction). It doesn't provide long-term storage.

In Summary:

LLMs don't have a freely accessible, writable external memory primarily because their knowledge is encoded in a distributed, implicit way within their weights, and adding such a memory would introduce significant computational and design challenges. While RAG provides a practical way to access external knowledge, and MANNs explore more direct memory mechanisms, the core architecture of LLMs is fundamentally different from systems with explicit, addressable memory. The trade-off is between the efficiency and generalization power of LLMs and the ability to store and manipulate specific pieces of information in a more structured way. The field is actively exploring how to get the best of both worlds.

Tell me more about Memory-Augmented Neural Networks (MANNs)

Memory-Augmented Neural Networks (MANNs) represent a fascinating class of neural network architectures that aim to bridge the gap between the connectionist approach of standard neural networks and the symbolic processing capabilities of traditional computer architectures. They do this by incorporating an external memory component that the network can read from and write to. This is in contrast to standard neural networks (including LLMs) where "memory" is implicitly encoded in the weights and activations.

Here's a detailed look at MANNs:

Key Concepts:

• External Memory: The defining feature of MANNs is an external memory bank. This is a separate module from the main network (often called the "controller"). Think of it like RAM in a computer, but accessible to the neural network.

• Controller: This is a neural network (often a recurrent neural network like an LSTM, or a feedforward network) that acts as the "brain" of the system. It receives input, interacts with the memory, and produces output.

• Read and Write Operations: The controller learns to perform read and write operations on the external memory.

  • Read: The controller generates "read heads" that can focus on specific locations in memory and retrieve the information stored there.

  • Write: The controller generates "write heads" that can modify the contents of memory locations. This allows the network to store information for later use.

• Differentiable Operations: Crucially, the read and write operations are differentiable. This means that the entire system (controller + memory) can be trained end-to-end using gradient descent, just like a standard neural network. This is a key innovation that allows the network to learn how to use the memory effectively.

• Addressing Mechanisms: MANNs use various addressing mechanisms to determine which memory locations to read from or write to. These mechanisms are also learned during training:

  • Content-Based Addressing: The controller can access memory locations based on the similarity between a query vector (generated by the controller) and the content of the memory locations. This is like searching for a specific piece of information.

  • Location-Based Addressing: The controller can access memory locations based on their position in the memory matrix. This is like accessing elements in an array by their index. MANNs often combine content-based and location-based addressing.

Prominent MANN Architectures:

1. Neural Turing Machines (NTMs):

   • Introduced by Graves et al. (2014), NTMs were one of the first and most influential MANN architectures.

   • The controller is typically an LSTM or feedforward network.

   • The memory is a matrix of memory locations.

   • NTMs use a combination of content-based and location-based addressing. The read/write heads produce "attention weights" that specify how much to focus on each memory location.

   • The location-based addressing allows for shifting the focus along the memory, similar to a Turing machine's tape head.

2. Differentiable Neural Computers (DNCs):

   • Introduced by Graves et al. (2016), DNCs are an evolution of NTMs.

   • DNCs have a more sophisticated memory addressing mechanism that allows for more flexible memory allocation and usage.

   • Key features include:

     • Dynamic Memory Allocation: DNCs can allocate new memory locations as needed, rather than having a fixed-size memory.

     • Temporal Linkage: DNCs can keep track of the order in which memory locations were written to, allowing them to retrieve sequences of information.

     • Usage Vector: Keeps a record of which memory location are free.

   • DNCs have shown strong performance on tasks requiring complex reasoning and memory manipulation.

How MANNs Learn to Use Memory:

The remarkable thing about MANNs is that they are not explicitly programmed to use the memory in a specific way. Instead, they learn how to use the memory through the process of training (usually with backpropagation through time).

1. Input: The network receives an input.

2. Controller Processing: The controller processes the input and its internal state.

3. Memory Interaction: Based on its internal state and the input, the controller generates read and write heads.

   • Read Heads: The read heads access information from the memory.

   • Write Heads: The write heads modify the contents of the memory.

4. Output: The controller combines the information retrieved from memory with its internal state to produce an output.

5. Gradient Descent: The entire process (input -> controller -> memory -> output) is differentiable. The network's weights (in both the controller and the read/write mechanisms) are adjusted using gradient descent to minimize the error between the network's output and the desired output.

6. Emergent strategies Through this process the network can learn complex strategies like counting, storing and retreving sequences, etc.

Advantages of MANNs:

• Long-Term Dependencies: MANNs can store and retrieve information over much longer time scales than standard recurrent networks (like LSTMs), which suffer from the vanishing gradient problem.

• Algorithmic Learning: MANNs have shown the ability to learn simple algorithms, such as copying, sorting, and recalling sequences. This suggests that they can learn more structured and symbolic representations than standard neural networks.

• One-Shot Learning: Because they can store information in memory, MANNs can potentially learn new concepts from very few examples (one-shot learning).

• Generalization: MANNs often generalize better to new inputs that are longer or more complex than those seen during training.

Disadvantages and Challenges:

• Training Complexity: MANNs are more complex to train than standard neural networks. They require careful tuning of hyperparameters and can be sensitive to initialization.

• Computational Cost: The memory operations (especially the attention mechanisms) can be computationally expensive, although often still less costly than very large LLMs.

• Interpretability: Understanding exactly how a MANN is using its memory can be difficult. The learned memory access patterns are often complex and not easily interpretable by humans.

• Scalability: While DNCs improved upon NTMs in terms of scalability, scaling MANNs to the size of modern LLMs remains a challenge.

Applications:

• Algorithmic Tasks: Copying, sorting, recalling sequences, learning simple programs.

• Question Answering: Storing and retrieving facts to answer questions.

• Reinforcement Learning: Maintaining a memory of past experiences to improve decision-making.

• Natural Language Processing: Potentially useful for tasks requiring long-range dependencies and reasoning, although LLMs currently dominate most NLP benchmarks.

• Graph Reasoning: DNCs have been successfully applied to tasks involving graph-structured data.

Relationship to LLMs:

MANNs and LLMs represent different approaches to building intelligent systems. LLMs excel at statistical pattern matching and generating fluent text, while MANNs are designed for more structured reasoning and memory manipulation. There is ongoing research into combining the strengths of both approaches. For example, you could imagine an LLM using a MANN as a kind of "external reasoning module" to handle tasks requiring more explicit memory and algorithmic processing. Retrieval-Augmented Generation (RAG) is a more practical, currently used approach that gives LLMs access to external knowledge.

In conclusion, Memory-Augmented Neural Networks are a powerful and promising area of research that explores how neural networks can learn to use external memory to perform complex tasks. While they haven't yet achieved the widespread adoption of LLMs, they offer a different path towards building more general and capable AI systems. They represent a step towards bridging the gap between neural networks and symbolic AI.