lOMoARcPSD|52714283

UNIT IV cognitive computing

computer science engineering (Mahatma Gandhi Institute of Technology)

Scan to open on Studocu

Studocu is not sponsored or endorsed by any college or university

Downloaded by Shreerupa Biswas ([email protected])
 lOMoARcPSD|52714283

UNIT IV
What Is Inductive Generalization?
Definition: The process of drawing general conclusions from specific instances.

Example:
You see three white swans → You generalize: "All swans are white"

This kind of learning is central to:

• Human cognition

• Scientific reasoning

• Machine learning

Formal models aim to explain:

• How much data is needed?

• Why do we prefer simpler explanations?

• What biases or constraints guide generalization?

Major Formal Models of Inductive Generalization

1. Classical Predicate Logic (Deductive Limitations)

While not inductive itself, classical logic forms the backdrop. Inductive reasoning is often not valid in strict
logic (because it’s uncertain), but formalizations try to overcome that.

2. Bayesian Models

Core Idea:

Generalization is probabilistic inference: What is the probability that a hypothesis is true given the
observed data?

Formula:

Bayes’ Theorem:

P(H∣D)=P(D∣H)⋅P(H)/P(D)

• H= Hypothesis (e.g., "All swans are white")

• D = Data (observed white swans)

• P(H∣D) = Posterior: probability of H given data

• P(H) = Prior: initial belief in H

• P(D∣H) = Likelihood: how likely data D is if H is true

Implication:

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

Bayesian models formalize how prior beliefs and new evidence interact to form generalizations.

3. The Size Principle (Tenenbaum & Griffiths)

Core Idea:

Smaller hypotheses (those that cover fewer possibilities) are more likely if they explain the data well.

Example:

If you see that all 3 observed animals are dalmatians, it's more likely you’re referring to "dalmatians" than
"all dogs" or "all animals".

This principle penalizes overly general hypotheses.

4. Algorithmic Learning Theory (Gold, 1967)

Core Idea:

Studies whether a learner can identify the correct rule (grammar, function, etc.) given infinite or finite data.

• Focuses on limit learning (learn the correct rule eventually)

• Doesn’t assume probabilities

• Useful in computational learning theory

Example:

Can a learner converge on the rule for even numbers if given the examples: 2, 4, 6...?

5. Concept Learning Models (e.g., Version Space - Mitchell)

Core Idea:

Learners maintain a set of hypotheses consistent with the observed data.

• General boundary: most general hypothesis still consistent

• Specific boundary: most specific hypothesis consistent

Learners narrow this "version space" as they see more examples.

6. Similarity-Based Generalization (Shepard, 1987)

Core Idea:

The likelihood of generalizing to a new instance depends on its similarity to observed examples.

Applications:

• Explains why we generalize from a robin to a sparrow but not to a penguin

7. Minimum Description Length (MDL)

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

Core Idea:

Prefer the simplest model that explains the data — in line with Occam’s Razor.

• A good generalization compresses the data well

• Used in model selection and learning theory

Comparison Table

Model Basis Key Concept Applications

Cognitive modeling, machine

Bayesian Inference Probability Updating beliefs with evidence
learning

Bayesian Preference for smaller Language learning,

Size Principle
simplification hypothesis classes categorization

Hypotheses narrowing via

Version Space Logical consistency Concept learning
consistency

Shepard’s Similarity
Psychometrics Similarity guides generalization Categorization, perception
Model

MDL Information theory Simplicity = fewer bits Model selection, compression

Algorithmic Learning
Computability Identifiability in the limit Theoretical computer science
Theory

Why Are These Models Important?

• Cognitive Science: Explains how humans learn categories, concepts, and causal rules.

• AI & ML: Underlies models like Naive Bayes, decision trees, and neural networks.

• Education & Psychology: Helps design better teaching methods and assessments.

• Philosophy of Science: Formalizes how scientific generalizations emerge.

Summary

Formal models of inductive generalization attempt to explain how systems (human or artificial) go from
specific data to general rules. Each model offers a different perspective:

• Bayesian models emphasize belief updates

• Size principle and MDL value simplicity

• Similarity models reflect psychological reality

• Version space and algorithmic theories provide structural or theoretical clarity

These models are foundational to understanding learning, reasoning, and intelligence.

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

1. Causality in Cognitive Computing

Formal Models:

• Bayesian Networks: Probabilistic graphical models that represent causal relationships between
variables. Key in modeling how humans infer causality from observations.

o Example: Judea Pearl’s work on do-calculus and structural causal models (SCMs).

• Granger Causality: Mostly used in time-series analysis to determine whether one variable predicts
another.

• Counterfactual Models: Analyze “what if” scenarios to model human reasoning about alternate
outcomes.

Applications in Cognitive Computing:

• Decision making under uncertainty

• Modeling human reasoning in AI agents

• Language understanding (e.g., cause-effect relationships in text)

2. Categorization
Formal Models:

• Prototype Theory (Rosch): Categories are formed around an idealized "average" or central
tendency.

• Exemplar Theory (Nosofsky): Categories are represented by specific remembered instances.

• Bayesian Models of Categorization: Treat category learning as probabilistic inference.

• Connectionist/Neural Models: Use neural networks to simulate category learning and

generalization.

Applications:

• Object recognition

• Natural language processing (semantic categorization)

• Adaptive learning systems (e.g., personalized education)

3. Similarity
Formal Models:

• Geometric Models: Objects represented as points in a multidimensional space; similarity is

inversely related to distance (e.g., Euclidean, cosine).

• Tversky’s Contrast Model: Similarity as a function of shared and distinctive features (asymmetric
and context-sensitive).

• Transformational Models: Similarity measured by the complexity of transforming one

representation into another.

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

Applications:

• Case-based reasoning

• Information retrieval and recommender systems

• Conceptual clustering

Integration in Cognitive Computing

Modern cognitive systems often integrate these models to simulate or support human-like reasoning:

• Causal reasoning + similarity in analogical reasoning systems.

• Categorization + similarity in concept learning and knowledge representation.

• Causality + categorization in scientific discovery models or hypothesis generation systems.

Example: Intelligent Medical Diagnosis System

Imagine a cognitive system that assists doctors by diagnosing diseases based on patient symptoms.

Step 1: Categorization

The system needs to determine what kind of condition a patient might have.

• Input: A patient has symptoms like fever, cough, and shortness of breath.

• Process: The system compares these symptoms to known categories (e.g., flu, COVID-19,
pneumonia).

• Model Used: A Bayesian model of categorization computes the probability of each disease
category given the observed symptoms.

Step 2: Similarity

The system then looks for similar past cases to refine its decision or suggest a treatment.

• Model Used: Exemplar-based similarity model compares the current patient to a database of
previous patients.

• Distance Metric: Euclidean or cosine similarity on a feature space (e.g., symptom severity, age,
comorbidities).

If the current patient is highly similar to past COVID-19 patients who responded well to Treatment X, that
recommendation is surfaced.

Step 3: Causality

Now, the system reasons about causal relationships to avoid bad decisions.

• Model Used: Causal Bayesian network that understands:

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

o Virus → Inflammation → Lung damage

o Medication → Reduced inflammation → Improved outcomes

The system may simulate counterfactuals:

• What if the patient had been vaccinated?

• Would the outcome change if a different treatment were used?

This avoids recommending treatments that merely correlate with recovery but don’t cause it.

Integration

• Categorization helps narrow down what disease class we're dealing with.

• Similarity offers personalized insights based on comparable cases.

• Causality ensures that the recommendations are not just correlative, but grounded in why
something works.

What Is Analogy in Cognitive Terms?

An analogy is a mapping of knowledge from one domain (the source) to another (the target) based on
structural similarities, not just superficial features.

“The atom is like a solar system.”

(Electrons orbit the nucleus like planets orbit the sun.)

This helps us reason about something unfamiliar (atoms) by comparing it to something more familiar (solar
systems).

In Cognitive Computing: Why Analogy Matters

Key Role in Problem Solving

• When faced with a new problem, an intelligent system can retrieve a past problem that has a
similar structure and transfer the solution.

• This mirrors how humans use analogical reasoning.

Applications

• Case-Based Reasoning (CBR) systems: Solve new problems by adapting solutions from previous
similar cases.

• Automated Theorem Provers: Use analogies between mathematical structures to generate proofs.

• AI tutoring systems: Use analogies to explain abstract concepts (e.g., electricity as water flow).

• Design and creativity tools: Help generate innovative ideas by analogy (e.g., bio-inspired design:
Velcro from burrs).

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

Formal Models of Analogy in AI

1. Structure-Mapping Theory (Gentner, 1983)

• Focuses on relational similarity rather than superficial features.

• An analogy is valid if it preserves systematic correspondences between relationships in source and

target domains.

Source: The heart pumps blood through vessels.

Target: A pump pushes water through pipes.

Mapping:
Heart → Pump
Blood → Water
Blood vessels → Pipes

2. MAC/FAC Model (Forbes & Gentner)

• Two-stage process:

o MAC (Many Are Called): Uses quick, surface-level similarity to filter possible analogs.

o FAC (Few Are Chosen): Uses deeper, structural comparisons.

3. Analogical Constraint Mapping Engine (ACME)

• Uses parallel distributed processing (neural networks) to find and evaluate analogical mappings.

Human-Like Problem Solving via Analogy

Example:

Problem: A doctor wants to remove a tumor without harming healthy tissue.

• Analogical Source: A general wants to capture a fortress without destroying the roads.

• Solution: Break the army into small groups that converge from multiple directions.

The doctor applies the same idea: use low-intensity rays from multiple angles so they converge on the
tumor but don’t harm surrounding tissue.

This is a classic example from Gick & Holyoak (1980s) showing how analogies guide creative problem
solving.

In Cognitive Computing Architectures

• ACT-R: Uses analogy to model human memory and problem solving by retrieving similar past
experiences.

• SOAR: Uses analogy in chunking and subgoal creation.

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

MAC/FAC

MAC/FAC is a two-stage model for retrieving analogies from memory, based on structure-mapping theory.

1. MAC Stage – Many Are Called

• This stage uses a fast, shallow match to retrieve candidate analogs from long-term memory.

• The system compares the surface features (e.g., objects, labels, roles) using vector-based
similarity.

• Goal: Narrow down thousands of possible analogs to a small shortlist (maybe 5–10).

Analogy: Like Googling based on keywords — fast but not always deep.

2. FAC Stage – Few Are Chosen

• This is the deep, slow, structural comparison stage.

• Uses Structure-Mapping Engine (SME) to compare relational structure between source and target
domains.

• The FAC stage picks the analog that best preserves relationships and systematicity (interconnected
relations).

Analogy: Like a human deeply analyzing a few results from the search to pick the best match.

Why Use Two Stages?

The human mind can't afford to do deep comparisons on every past memory—it’s computationally
expensive.
MAC/FAC offers a cognitively plausible solution:

• Be fast and approximate to get a shortlist (MAC).

• Then be slow and precise to choose the best (FAC).

Example Scenario

Imagine a cognitive assistant trying to help with a new engineering problem involving heat transfer.

• MAC Stage: Scans memory and finds past cases involving fluid flow, electrical resistance, and
thermal conduction (all share surface-level terms like “flow” or “transfer”).

• FAC Stage: Evaluates which of these domains shares deep structural relations with the new
problem.

o It might find that electrical resistance is structurally most similar (Ohm’s law and Fourier’s
law are analogous).

The assistant now suggests an analogical solution based on electrical systems to solve a heat transfer
problem.

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

Cognitive Realism

• MAC/FAC models how people intuitively retrieve analogies: we don’t immediately go for the best
analog—we approximate first, then refine.

• This model has inspired systems in:

o Design (e.g., analogical design tools)

o Education (teaching via analogies)

o Cognitive architectures (like Companions and SME-based systems)

Cognitive Development & Child Concept Acquisition

Concept acquisition is a core part of a child's cognitive development—it refers to how children form
mental categories and understandings of the world (e.g., what a “dog” is, what “fairness” means, etc.).

What Are Concepts?

Concepts are mental representations that categorize objects, events, or ideas based on shared features.

• Concrete concepts: “Dog”, “Chair”, “Apple”

• Abstract concepts: “Justice”, “Friendship”, “Number”

Children gradually move from simple perceptual groupings to more abstract and symbolic categories.

Key Stages in Concept Acquisition (Piaget's Theory-Inspired)

1. Sensorimotor Stage (0–2 years)

• Infants learn through sensory experiences and motor actions

• Begin to form basic object categories

o E.g., Recognize "ball" as different from "bottle"

• Object permanence develops (understanding that things continue to exist even when out of sight)

2. Preoperational Stage (2–7 years)

• Rapid development of symbolic thought and language

• Concepts are formed based on perceptual features (e.g., shape, color)

• Overgeneralization is common:

o Calling all four-legged animals “dogs”

• Start forming categories but struggle with hierarchical or logical grouping

3. Concrete Operational Stage (7–11 years)

• Begin to understand logical relationships and class inclusion

o Realize that "dogs" are part of the broader category "animals"

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

• Grasp of conservation, number, length, and volume

• Can sort and classify with multiple criteria (e.g., by color and size)

4. Formal Operational Stage (12+ years)

• Capable of abstract reasoning and hypothetical thinking

• Understand abstract concepts (e.g., democracy, algebraic variables)

• Concepts become more nuanced and context-aware

Theories of Concept Acquisition

1. Prototype Theory (Eleanor Rosch)

• Children learn typical examples first (e.g., robin = bird)

• Concepts are built around central “prototypes”, not strict definitions

2. Exemplar Theory

• Children store and compare specific examples

• New stimuli are categorized based on similarity to known instances

3. Theory-Theory

• Children act like "little scientists", forming and testing intuitive theories

o E.g., They may believe “things that move are alive” and refine this with experience

• Concept learning is tied to causal reasoning

4. Nativist View (e.g., Chomsky, Spelke)

• Some core concepts may be innate (e.g., object, number, agent)

• Experience triggers or shapes these pre-existing cognitive structures

5. Constructivist View (Piaget, Vygotsky)

• Emphasizes active exploration and interaction with the environment

• Vygotsky adds the importance of social interaction and language in shaping conceptual
development

Mechanisms That Drive Concept Acquisition

Mechanism Description Example

Perceptual Grouping round red objects as

Grouping based on visual features
Categorization "balls"

Learning “cat” helps distinguish it

Language Labels help reinforce category boundaries
from “dog”

Analogical Reasoning Mapping relationships across domains "The heart is like a pump"

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

Mechanism Description Example

Memory and attention help in forming and Inhibiting wrong labels like “cow”
Executive Function
refining categories for a horse

Pointing and naming by adults

Social Learning Imitating and learning from caregivers
shapes concepts

Example: How a Child Learns the Concept "Bird"

1. Perceptual: Notices things that fly and have feathers

2. Labeling: Hears "bird" when shown a robin

3. Generalization: Applies "bird" to other flying creatures (sometimes incorrectly to bats)

4. Correction: Learns birds have beaks, lay eggs—refines understanding

5. Hierarchical Learning: Understands "robin" is a kind of "bird", which is a kind of "animal"

Disorders and Concept Acquisition

• Children with ASD (Autism Spectrum Disorder) may form concepts differently, focusing on details

• Those with language delays may struggle with abstraction and category formation

Educational Implications

• Use rich, varied examples for concept teaching

• Emphasize language use in categorization

• Use hands-on experiences and social interaction

• Start with prototypical examples and gradually introduce exceptions

Summary

Concept acquisition in children is a gradual, interactive process shaped by:

• Cognitive development stages

• Sensory experiences

• Language and social interaction

• Concept learning theories (prototype, exemplar, theory-theory)

Understanding how children build concepts helps in education, language development, and AI systems
inspired by human cognition.

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

What is ACT-R?
ACT-R is a cognitive architecture — a theory and simulation framework of how the human mind works. It
was developed by John R. Anderson and colleagues at Carnegie Mellon University. The goal of ACT-R is to
understand and simulate the underlying mechanisms of human cognition, such as learning, problem-
solving, decision-making, and memory.

ACT-R aims to model the way people think, using a modular system that mimics how our brains process
and store information.

Core Architecture

ACT-R is built around a few key components:

1. Modular Structure

ACT-R is composed of multiple modules, each simulating a part of the brain:

• Visual module: processes what we see

• Manual module: handles motor actions (e.g., pressing keys)

• Auditory module: processes sounds

• Goal module: keeps track of current goals

• Declarative memory module: stores facts

• Procedural module: manages rules and decision-making

Each module has a buffer, which serves as a temporary memory store — similar to short-term memory.

2. Memory Systems

ACT-R divides memory into two types:

a. Declarative Memory

• Stores facts and experiences (e.g., “Paris is the capital of France”).

• Information is stored as chunks (structured units of knowledge).

• Retrieval is based on activation, which depends on usage frequency and context.

b. Procedural Memory

• Contains production rules (condition-action pairs).

• Rules are matched against the current situation and fire when their conditions are met.

• Used to perform reasoning and decision-making.

3. Production System

This is the "engine" of ACT-R.

• A central mechanism that selects and executes production rules.

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

• Each rule has:

o A condition: checks the state of buffers.

o An action: updates the system (e.g., move a goal, recall a memory).

• Only one rule fires at a time — making ACT-R a serial processor at the core.

4. Buffers

Think of buffers as communication windows between the central processor and the modules.

• Each module has a buffer that holds a single chunk of information.

• The procedural module reads from these buffers and uses that data to trigger rules.

5. Timing and Learning

ACT-R is used to model timing data like:

• Reaction times

• Task performance over time

• Learning curves

Learning mechanisms include:

• Chunk learning: adding new information to declarative memory.

• Production compilation: combining multiple steps into a single, faster rule.

• Activation-based retrieval: information becomes easier to retrieve the more often it's used.

Example Use Case

Typing a word:

1. Goal: Type the word "cat".

2. ACT-R activates visual and goal modules to get the letters.

3. Manual module plans key presses.

4. Production rules select which key to press.

5. Buffers coordinate information between modules.

Applications

ACT-R is widely used in:

• Cognitive psychology (to simulate human behavior in experiments)

• Human-Computer Interaction (HCI) (to predict how users interact with systems)

• Education (modeling how students learn)

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

• Usability testing (predicting how long a task will take)

Brain-Inspired Design

ACT-R also draws inspiration from neuroscience:

• Each module is loosely mapped to a brain region.

• For example:

o Visual module ↔ Occipital lobe

o Goal module ↔ Prefrontal cortex

o Declarative memory ↔ Temporal lobe (hippocampus)

This makes it a biologically plausible model of human cognition.

Summary Table

Component Description

Declarative Memory Stores knowledge as facts (chunks)

Procedural Memory Stores rules (productions) for behavior

Modules Specialized sub-systems (vision, goals, motor, etc.)

Buffers Hold current active information from each module

Production System Selects and executes rules based on buffer contents

Learning Mechanisms Activation, chunking, compilation

What is SOAR?
SOAR (pronounced "soar") is a general cognitive architecture designed to model intelligent behavior —
reasoning, learning, and problem-solving — in a way that mimics human cognition.

Originally developed in the early 1980s by John Laird, Allen Newell, and Paul Rosenbloom, SOAR is built
around the idea of a unified theory of cognition — a framework that can explain and simulate a broad
spectrum of mental activities, from perception to decision-making.

Big Picture: SOAR as a Problem Solver

At its core, SOAR is a goal-oriented problem solver. It works by:

1. Trying to achieve goals.

2. Breaking them down into subgoals.

3. Using rules (productions) to choose actions.

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

4. Learning new knowledge from experience.

Core Components of SOAR

1. Working Memory (WM)

• Holds the current state of the system.

• Contains objects, goals, perceptions, etc.

• Updated constantly as actions are taken.

2. Long-Term Memory (LTM)

Divided into three parts:

• Procedural Memory: Stores production rules (if-then rules).

• Semantic Memory: General facts and knowledge.

• Episodic Memory: Specific experiences from the past.

SOAR primarily uses procedural memory — its core reasoning mechanism is built around production rules.

3. Production Rules (IF-THEN Rules)

• These are condition-action pairs.

• When conditions in working memory match, the corresponding actions are applied.

• Drive all behavior — everything SOAR does is triggered by these rules.

Example:

IF the goal is to navigate AND there’s a door ahead

THEN move through the door

4. Decision Cycle

SOAR follows a decision cycle for processing:

text

Input → Elaboration → Proposal → Decision → Application → Output

• Input: Takes in perceptual information.

• Elaboration: Applies production rules to build new knowledge.

• Proposal: Generates possible actions.

• Decision: Selects the best action.

• Application: Executes the selected action.

• Output: Produces external behavior (e.g., movement or speech).

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

5. Subgoaling and Impasses

When SOAR doesn’t know what to do next (an impasse), it:

• Creates a subgoal to resolve the impasse.

• Solves the subgoal using the same decision-making process.

• Learns from the experience.

This process is recursive — subgoals can spawn further subgoals.

6. Learning: Chunking

SOAR’s primary learning mechanism is called chunking:

• After solving a subgoal, SOAR stores a new rule (a chunk) that allows it to solve similar problems
faster in the future.

• Over time, SOAR becomes more efficient.

Example:

• First time: "If X happens, figure out how to do Y" → forms a subgoal.

• Next time: SOAR recalls the rule directly.

7. Symbolic Representation

SOAR is a symbolic system — it manipulates symbols rather than using numerical weights (like neural
networks).

• Human-like abstraction and reasoning.

• Can model planning, conversation, spatial navigation, and more.

Example Use Case

Scenario: A robot is trying to find an object in a house.

1. The goal is to find the object.

2. SOAR checks memory and perceives the environment.

3. It uses rules to plan: "If room A is empty, go to room B."

4. It enters room B and finds the object.

5. SOAR learns a new rule: “If searching for object X, check room B first.”

Applications

SOAR has been used in:

• Military simulations (e.g., pilot and tank simulations)

• Robotics

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

• Video games (e.g., agents that learn and adapt)

• Cognitive modeling

• Virtual humans and chatbots

Brain-Inspired & Symbolic Design

While not strictly neural, SOAR is inspired by cognitive psychology:

• Subgoals ↔ Human problem solving

• Chunking ↔ Learning by experience

• Decision cycle ↔ Deliberative thinking

Summary Table

Component Description

Working Memory Current knowledge (goals, perceptions, state)

Procedural Memory Rules used for reasoning (if-then productions)

Chunking Main learning mechanism (learn new rules from goals)

Subgoaling Automatic strategy to resolve uncertainty (impasses)

Decision Cycle Loop that handles input → action → learning

SOAR vs ACT-R (Quick Contrast)

Feature SOAR ACT-R

Focus Problem-solving & general cognition Cognitive psychology modeling

Learning Chunking Chunking, production compilation

Memory Types Procedural, semantic, episodic Declarative and procedural

Parallelism Single production fires per cycle Single production, with modular buffers

Applications Robotics, AI agents, simulations HCI, cognitive modeling, experiments

What is OpenCog?
OpenCog is an open-source cognitive architecture aimed at achieving AGI — intelligence that is flexible,
adaptable, and human-like across many domains.

Originally developed by Ben Goertzel and colleagues, OpenCog integrates multiple AI approaches:

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

• Symbolic reasoning

• Neural networks

• Probabilistic logic

• Evolutionary learning

• Natural language processing

It’s designed to simulate human-like thinking, not just task-specific behavior.

Core Components of OpenCog

OpenCog is a modular system with several core components working together. Here's a breakdown:

1. AtomSpace (The Brain of OpenCog)

AtomSpace is a hypergraph-based knowledge base — everything OpenCog "knows" is stored here.

• Atoms: Units of knowledge (concepts, rules, perceptions, emotions).

• Links: Relationships between atoms (e.g., inheritance, similarity).

• Each atom has a truth value (confidence & strength) and attention value.

Think of it as a giant, structured memory: a semantic network that stores facts, goals, actions, etc.

Example:

InheritanceLink(Dog, Animal)

EvaluationLink(HasColor, Dog, Brown)

This means "a Dog is an Animal" and "Dog has the color Brown".

2. PLN (Probabilistic Logic Networks)

A probabilistic reasoning system that handles uncertain and incomplete knowledge.

• Works with truth values (not just true/false).

• Can infer facts like:

o "If most mammals have hearts, and dogs are mammals → dogs probably have hearts."

Useful for reasoning with real-world ambiguity.

3. MOSES (Meta-Optimizing Semantic Evolutionary Search)

An evolutionary program learning system.

• Learns new procedures and rules by evolving and selecting programs.

• Like Genetic Programming, but optimized for symbolic logic.

Example: Given data about plant growth, MOSES could evolve a rule like:

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

IF sunlight > 6 hrs AND water = adequate THEN plant_grows_well = true

4. Natural Language Processing (NLP)

OpenCog includes tools for:

• Parsing natural language into structured meaning representations.

• Connecting words and sentences to AtomSpace concepts.

• Enabling dialogue agents and language understanding.

5. Attention Allocation

Inspired by human cognitive focus.

• Assigns "attention" to important atoms in AtomSpace.

• Ensures the system works on relevant concepts, not just everything.

Think of it as an artificial version of mental focus.

6. OpenPsi / CogEmotions

Models motivation, emotions, and drives (inspired by Psi theory and psychology).

• Gives the system goals, desires, or internal states.

• Guides decision-making (e.g., avoid pain, seek rewards).

Example: Reasoning About Animals

Let’s say AtomSpace has this knowledge:

InheritanceLink(Dog, Mammal)

InheritanceLink(Mammal, Animal)

EvaluationLink(HasPart, Dog, Tail)

You ask: "Does a dog have a part?"

OpenCog (via PLN) could:

• Recognize "Dog → Mammal → Animal"

• Apply transitive inheritance and part knowledge

• Infer: "Yes, Dog has parts like Tail"

Example: Chatbot with OpenCog

Using AtomSpace + NLP + PLN, a chatbot can:

1. Parse “What is a dog?”

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

2. Map “dog” to a concept in AtomSpace.

3. Retrieve facts: “Dog is a mammal”, “Dog has tail”, etc.

4. Formulate a response like:

“A dog is a mammal that typically has a tail.”

Application Example: Sophia the Robot

OpenCog powers aspects of Sophia, the humanoid robot from Hanson Robotics.

• Sophia uses AtomSpace for her memory.

• PLN helps her reason about human conversation.

• MOSES is used for evolving behavioral rules.

• OpenPsi helps model emotional responses.

Comparison with Other Architectures

Feature OpenCog ACT-R / SOAR

Goal General intelligence (AGI) Cognitive task modeling

Memory Model AtomSpace (graph-based) Declarative/Procedural rules

Learning Style Evolutionary (MOSES), symbolic Rule-based chunking

Reasoning Probabilistic logic (PLN) Symbolic production rules

NLP Integration Built-in NLP to AtomSpace External modules (if any)

Flexibility High (multi-domain reasoning) Moderate (task-focused)

Use Cases

• General AI research

• Educational AI tutors

• Robotics (e.g., Sophia)

• Natural language chatbots

• Commonsense reasoning

• AGI experimentation platforms

Summary

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

Component Description

AtomSpace Knowledge base (hypergraph of concepts, facts, actions, goals)

PLN Probabilistic reasoning under uncertainty

MOSES Learns new behaviors through evolutionary programming

NLP Parses and understands natural language

Attention System Focuses resources on relevant information

OpenPsi Models emotional and motivational drives

What is CopyCat?
CopyCat is a cognitive model developed in the late 1980s and 1990s by Douglas Hofstadter, Melanie
Mitchell, and others at Indiana University.

It was built to explore how humans perceive patterns, make analogies, and exhibit flexible, context-
sensitive reasoning — especially in ambiguous or creative tasks.

CopyCat is not focused on problem-solving like SOAR or OpenCog, but on fluid, emergent thinking —
modeling how people "see" analogies.

The Famous CopyCat Task

CopyCat was designed for a very specific but powerful type of problem:

"If A → B, then what is C → ?"

Example:

abc : abd :: ijk : ?

Most people would intuitively answer: “ijl”

Why? Because:

• In abc → abd, the last letter c was changed to d (i.e., next letter).

• So in ijk, the last letter k becomes l.

But this process involves:

• Pattern recognition

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

• Contextual judgment

• Creative rule inference

...which is what CopyCat models.

Architecture Overview

CopyCat’s architecture is inspired by the mind’s fluidity, using a society of agents metaphor, not a central
decision-maker.

Core Components:

Component Role

Workspace Visual representation of the problem, like a mental canvas

Slipnet Semantic network of concepts, with activations

Codelets Mini-processes that explore possibilities

Coderack Scheduler that runs codelets probabilistically

Temperature Controls randomness and flexibility (high temp = chaos)

1. Workspace

This is like short-term memory — a visual/structural layout of the strings (e.g., abc, abd, ijk) and any
discovered groupings, mappings, or relationships.

2. Slipnet

A semantic network of concepts relevant to the domain:

• Letters (a, b, c, ..., z)

• Relations like "successor", "predecessor", "left", "right", "group"

• Connections like "a is before b", or "increment means go to next letter"

Each concept has an activation level, which rises/falls depending on context.

3. Codelets

Tiny agents that do small tasks like:

• Propose a grouping (e.g., "ab" is a pair)

• Suggest a mapping (e.g., “c → d” = successor)

• Build a rule (e.g., "change last letter to next")

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

Thousands of codelets run in parallel, influencing the system incrementally.

No master planner — just many small interactions that lead to emergent understanding.

4. Coderack

A place where codelets wait and compete to run.

• Uses a probabilistic selection: codelets with higher urgency or relevance are more likely to run.

• Encourages diversity and creativity — a kind of computational brainstorming.

5. Temperature

Represents uncertainty and randomness in the system:

• High temperature → more exploratory, chaotic.

• Low temperature → more focused, stable.

As promising patterns are found, temperature drops, stabilizing the solution.

How CopyCat Solves the Analogy

Let’s walk through:

Problem:

abc → abd

ijk → ?

Step-by-step:

1. Initialize workspace with abc, abd, ijk.

2. Codelets explore abc → abd: notice “c” changed to “d” → "successor" concept activated in Slipnet.

3. Mapping: c → d activates idea of changing final letter to its successor.

4. Apply same mapping to ijk: k → l.

5. Candidate solution: ijl

6. Temperature drops as consistent analogy is found.

7. System stabilizes on ijl.

And just like a human, it could have considered other weird options (like changing all letters), but based
on context, it settles on the simplest elegant transformation.

Other Example

abc → abd

xyz → ?

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

Now the mapping is trickier — some people answer xya, or xy{next of z}.

CopyCat could:

• Try successor of z → might hit boundary (since z is end of alphabet)

• Propose different groupings or mappings

• Explore multiple directions before converging

Applications of CopyCat

Though it's not a general-purpose AI, CopyCat is inspirational and foundational for:

• Modeling creativity and analogy-making

• Understanding cognitive flexibility

• Designing adaptive AI systems with no hard-coded logic

• Inspiring modern neuro-symbolic AI hybrids

Comparison to Other Architectures

Feature CopyCat SOAR / ACT-R / OpenCog

Focus Analogy, pattern recognition Problem-solving / general cognition

Learning Emergent, not stored as rules Chunking / rule creation

Control Mechanism Codelets + temperature (fluid) Central decision cycle

Representation Workspace + Slipnet (symbolic) Memory buffers or knowledge graphs

Intelligence Type Fluid, flexible, creative Structured, rule-based, procedural

Summary

Component Description

Slipnet Concept network (letters, relationships, similarity)

Workspace Visual structure of the current problem

Codelets Small, stochastic agents exploring the space

Coderack Pool of waiting codelets, randomly activated

Temperature Measures chaos → determines flexibility vs commitment

Would you like:

• A visual diagram of how CopyCat works?

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

• A simple Python re-creation of the abc analogy task?

• A look at CopyCat’s spiritual successor, Metacat?

What Are Memory Networks?

Memory Networks (MemNNs), introduced by Facebook AI Research in 2014 (by Jason Weston et al.), are
neural network architectures enhanced with a long-term memory component that the network can read
from and write to.

Their purpose is to store and retrieve facts and reason over them to produce answers — especially in
question-answering (QA) and dialogue systems.

Think of them as a hybrid between neural nets and a searchable memory bank.

Core Idea

Standard Neural Networks:

• Great at recognizing patterns.

• Poor at remembering long-term context or specific facts.

Memory Networks:

• Augment the network with a readable/writable memory.

• Can store facts like "Mary went to the kitchen."

• Can retrieve them later when answering "Where is Mary?"

Architecture Overview

A Memory Network typically consists of:

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

Component Description

Input feature map (I) Converts raw input (e.g., sentence) into internal representation

General memory (M) Stores facts or context information

Generalization module (G) Updates memory based on new input

Output feature map (O) Uses memory to generate intermediate representation

Response module (R) Produces final output (e.g., answer)

Flow in a QA Task

Let’s walk through a simple example:

Example:

Input (Story):

markdown

1. Mary went to the kitchen.

2. John went to the garden.

3. Mary picked up the apple.

Question:

Where is Mary?

Step-by-Step:

1. Store Facts in Memory:

o Memory contains all 3 statements as vectors.

2. Input Question:

o The question is embedded: Q = "Where is Mary?"

3. Match Against Memory:

o The model attends to the most relevant memories (e.g., sentence 1).

o It uses similarity or relevance scoring (dot-product, cosine, etc.).

4. Extract Answer:

o Based on relevant facts, the network outputs:

"kitchen"

Iterative Reasoning (Hops)

Memory Networks can do multi-step reasoning, also known as hops.

Example: Chained Reasoning

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

Story:

1. Mary went to the kitchen.

2. Mary got the milk.

3. Mary went to the office.

Question: Where is the milk?

Reasoning Path:

• First hop: Find where Mary got the milk → sentence 2.

• Second hop: Trace where Mary went after → sentence 3.

• Answer: office

This is a form of transitive inference, and it’s a big deal in NLP tasks!

Types of Memory Networks

1. Original Memory Networks (Weston et al., 2014)

• Used discrete symbolic memory

• Required supervision at each step (e.g., which memory lines are relevant)

2. End-to-End Memory Networks (Sukhbaatar et al., 2015)

• Trained entirely with gradient descent (no supervision needed)

• Soft attention over memory (differentiable)

3. Key-Value Memory Networks

• Stores memory in (key, value) pairs

• Better for structured reasoning (e.g., "Mary" as key, "kitchen" as value)

Example Dataset: bAbI Tasks

Memory Networks were evaluated using bAbI, a set of synthetic QA tasks like:

• Single supporting fact

• Two/three-step reasoning

• Yes/No questions

• Counting and list-based reasoning

These tasks test logic, deduction, and memory usage.

Applications

• Question Answering Systems (e.g., SQuAD, HotPotQA)

• Dialog Agents (retrieving context from long conversations)

Downloaded by Shreerupa Biswas ([email protected])

 lOMoARcPSD|52714283

• Reading Comprehension

• Recommendation systems (storing and referencing user preferences)

• Knowledge-based reasoning

Comparison with Other Architectures

Feature Memory Networks Transformer (e.g., BERT) RNN / LSTM

Memory Explicit, structured memory Implicit attention over input Implicit memory via state

Reasoning Steps Multi-hop possible Limited unless externally guided Sequential reasoning only

Training Supervised / End-to-end Pretrained, fine-tuned Trained end-to-end

Interpretability High (visible memory access) Medium Low

Summary

Component Role

Memory Stores facts or knowledge as vectors

Input Encodes the question or input

Attention Finds relevant memory entries (multi-hop if needed)

Output Combines memory info to generate answer

Want to:

• See a code example of a memory network in PyTorch or TensorFlow?

• Compare it with Transformers with memory (e.g., Longformer, Memformer)?

• Understand how it's used in real-world AI assistants?

Downloaded by Shreerupa Biswas ([email protected])