Cognitive Psychology Series Part 14: Computational & AI Models of Cognition

1. Cognitive Architectures

A cognitive architecture is a comprehensive computational framework that specifies the fixed structures and mechanisms underlying all human cognition. Unlike models that target a single phenomenon, architectures aim to account for the entire range of cognitive behavior -- memory, attention, learning, problem-solving, and language -- within a unified system.

1.1 ACT-R: Adaptive Control of Thought -- Rational

Developed by John Anderson at Carnegie Mellon University, ACT-R (Anderson, 1993, 2007) is arguably the most influential cognitive architecture in psychology. It models cognition as the interaction between a set of specialized modules, coordinated by a central production system.

Core modules of ACT-R:

Memory retrieval in ACT-R is governed by activation levels. Each chunk in declarative memory has an activation value that determines how quickly and reliably it can be retrieved. Activation depends on:

• Base-level activation: How frequently and recently the chunk has been used (follows a power law of practice/forgetting)
• Spreading activation: Associative boost from related chunks currently in use
• Retrieval threshold: Chunks below a minimum activation level cannot be retrieved

# Simplified ACT-R Memory Retrieval Simulation
import math
import random

class ACTRMemory:
    """
    Simulates ACT-R declarative memory retrieval.
    Activation = Base-Level + Spreading Activation + Noise
    """

    def __init__(self, decay=0.5, noise=0.25, threshold=-1.0):
        self.decay = decay          # d parameter (typically 0.5)
        self.noise = noise          # s parameter for logistic noise
        self.threshold = threshold  # retrieval threshold (tau)
        self.chunks = {}

    def add_chunk(self, name, presentations):
        """
        Add a memory chunk with its history of presentations.
        presentations: list of times (in seconds ago) when chunk was encountered.
        """
        self.chunks[name] = presentations

    def base_level_activation(self, name):
        """
        B_i = ln(sum(t_j^(-d))) for all presentation times t_j
        This captures the power law of practice and forgetting.
        """
        times = self.chunks[name]
        summation = sum(t ** (-self.decay) for t in times if t > 0)
        return math.log(max(summation, 1e-10))

    def retrieval_time(self, activation):
        """
        RT = F * e^(-f*A) where F and f are scaling parameters.
        Higher activation = faster retrieval.
        """
        F = 0.35  # latency factor
        f = 1.0   # latency exponent
        return F * math.exp(-f * activation)

    def attempt_retrieval(self, name, spreading_activation=0.0):
        """Attempt to retrieve a chunk. Returns (success, RT, activation)."""
        base = self.base_level_activation(name)
        # Add logistic noise
        noise_val = random.gauss(0, self.noise * math.pi / math.sqrt(3))
        activation = base + spreading_activation + noise_val

        if activation > self.threshold:
            rt = self.retrieval_time(activation)
            return True, rt, activation
        else:
            return False, None, activation

# Demonstrate: Well-practiced vs rarely-practiced memories
memory = ACTRMemory()

# A well-practiced fact (seen many times recently)
memory.add_chunk("capital_france", [10, 100, 500, 2000, 5000, 10000, 50000])
# A rarely-practiced fact (seen few times, long ago)
memory.add_chunk("capital_bhutan", [50000, 200000])

print("=== ACT-R Memory Retrieval Simulation ===\n")
for chunk_name, label in [("capital_france", "France's capital"),
                           ("capital_bhutan", "Bhutan's capital")]:
    base = memory.base_level_activation(chunk_name)
    successes = 0
    total_rt = 0
    trials = 100

    for _ in range(trials):
        success, rt, act = memory.attempt_retrieval(chunk_name)
        if success:
            successes += 1
            total_rt += rt

    avg_rt = (total_rt / successes * 1000) if successes > 0 else float('inf')
    print(f"{label}:")
    print(f"  Base-level activation: {base:.3f}")
    print(f"  Retrieval success: {successes}/{trials} ({successes}%)")
    print(f"  Average retrieval time: {avg_rt:.0f} ms")
    print()

1.2 SOAR: State, Operator, And Result

SOAR, developed by Allen Newell (1990) and continued by John Laird, is the other major cognitive architecture. While ACT-R emphasizes statistical optimization and neural plausibility, SOAR emphasizes problem-solving as the fundamental cognitive activity.

Core principles of SOAR:

• Problem spaces: All cognitive activity is formulated as search through a problem space (states, operators, goals)
• Universal subgoaling: When SOAR reaches an impasse (cannot decide which operator to apply), it automatically creates a subgoal to resolve the impasse -- this is how learning and reasoning emerge
• Chunking: When a subgoal is resolved, SOAR automatically creates a new production rule (chunk) that captures the solution, so the same impasse never occurs again -- this is learning
• Long-term memories: Procedural (production rules), semantic (general knowledge), and episodic (experience records)

1.3 Comparing ACT-R and SOAR

2. Connectionism & Neural Networks

2.1 Parallel Distributed Processing (McClelland & Rumelhart)

The connectionist approach, championed by James McClelland and David Rumelhart in their landmark 1986 PDP volumes, models cognition as the emergent behavior of large networks of simple, neuron-like processing units connected by weighted links.

Key properties of connectionist networks:

• Distributed representations: A concept is not stored in a single unit but as a pattern of activation across many units. "Dog" might activate units for {furry, four-legged, barks, pet} -- overlapping with "cat" on some units but not others
• Parallel processing: All units update simultaneously, unlike the serial production-firing of ACT-R
• Graceful degradation: Damage to a few units reduces performance gradually rather than catastrophically -- much like brain damage
• Learning from examples: Networks learn by adjusting connection weights based on experience, not by being explicitly programmed with rules

2.2 Backpropagation & Learning

Backpropagation (Rumelhart, Hinton, & Williams, 1986) is the learning algorithm that made multi-layer neural networks practical. It works by propagating error signals backward through the network, adjusting connection weights to minimize the discrepancy between the network's output and the desired output.

# Simple Neural Network: Learning XOR (a classic connectionist demonstration)
import math
import random

class SimpleNeuralNet:
    """
    A minimal 2-layer neural network that learns XOR.
    XOR cannot be solved by a single-layer perceptron (Minsky & Papert, 1969),
    but can be solved with a hidden layer -- demonstrating the power of
    multi-layer networks and backpropagation.
    """

    def __init__(self, input_size=2, hidden_size=4, output_size=1, lr=0.5):
        self.lr = lr
        # Initialize weights randomly
        self.w_ih = [[random.uniform(-1, 1) for _ in range(input_size)]
                      for _ in range(hidden_size)]
        self.b_h = [random.uniform(-1, 1) for _ in range(hidden_size)]
        self.w_ho = [[random.uniform(-1, 1) for _ in range(hidden_size)]
                      for _ in range(output_size)]
        self.b_o = [random.uniform(-1, 1) for _ in range(output_size)]

    def sigmoid(self, x):
        return 1 / (1 + math.exp(-max(-500, min(500, x))))

    def forward(self, inputs):
        # Hidden layer
        self.hidden = []
        for j in range(len(self.w_ih)):
            z = sum(inputs[i] * self.w_ih[j][i] for i in range(len(inputs)))
            self.hidden.append(self.sigmoid(z + self.b_h[j]))

        # Output layer
        self.output = []
        for j in range(len(self.w_ho)):
            z = sum(self.hidden[i] * self.w_ho[j][i] for i in range(len(self.hidden)))
            self.output.append(self.sigmoid(z + self.b_o[j]))

        return self.output

    def train(self, inputs, targets):
        self.forward(inputs)

        # Output layer error
        output_deltas = []
        for j in range(len(self.output)):
            error = targets[j] - self.output[j]
            output_deltas.append(error * self.output[j] * (1 - self.output[j]))

        # Hidden layer error (backpropagation)
        hidden_deltas = []
        for j in range(len(self.hidden)):
            error = sum(output_deltas[k] * self.w_ho[k][j] for k in range(len(output_deltas)))
            hidden_deltas.append(error * self.hidden[j] * (1 - self.hidden[j]))

        # Update weights
        for j in range(len(self.w_ho)):
            for i in range(len(self.hidden)):
                self.w_ho[j][i] += self.lr * output_deltas[j] * self.hidden[i]
            self.b_o[j] += self.lr * output_deltas[j]

        for j in range(len(self.w_ih)):
            for i in range(len(inputs)):
                self.w_ih[j][i] += self.lr * hidden_deltas[j] * inputs[i]
            self.b_h[j] += self.lr * hidden_deltas[j]

# Train on XOR
random.seed(42)
net = SimpleNeuralNet(input_size=2, hidden_size=4, output_size=1, lr=2.0)
xor_data = [([0,0], [0]), ([0,1], [1]), ([1,0], [1]), ([1,1], [0])]

print("=== Neural Network Learning XOR ===")
print("(Minsky & Papert proved single-layer nets CANNOT learn XOR)")
print("(Backpropagation with hidden layer CAN)\n")

for epoch in range(5000):
    for inputs, targets in xor_data:
        net.train(inputs, targets)

print("After 5000 epochs of training:")
for inputs, targets in xor_data:
    output = net.forward(inputs)
    print(f"  Input: {inputs} -> Output: {output[0]:.4f} (Target: {targets[0]})")

2.3 The Symbolic vs Subsymbolic Debate

The tension between symbolic (rule-based) and subsymbolic (connectionist) approaches has been one of the most productive debates in cognitive science:

3. Bayesian Models of Cognition

3.1 Rational Analysis

Bayesian models approach cognition from the top down: rather than asking "what mechanism produces this behavior?" they ask "what is the optimal behavior given the structure of the environment?" This approach, formalized by John Anderson (1990) as rational analysis and extended by researchers like Tom Griffiths, Josh Tenenbaum, and Noah Goodman, treats the mind as an approximate Bayesian inference engine.

Bayes' theorem is the mathematical foundation:

P(hypothesis | data) = P(data | hypothesis) x P(hypothesis) / P(data)

Bayesian models have successfully explained a wide range of phenomena: how children learn word meanings from ambiguous data, how people make causal judgments, how perception resolves ambiguity, and why memory follows particular forgetting curves (the rational analysis of memory shows that forgetting curves are optimal responses to the statistical structure of the environment).

3.2 The Bayesian Brain Hypothesis

The Bayesian brain hypothesis proposes that the brain fundamentally operates as a Bayesian inference machine -- constantly computing probability distributions over hypotheses about the state of the world. Perception, for example, is not a passive recording of sensory input but an active process of inference: the brain combines sensory data (likelihood) with prior expectations (priors) to compute the most probable interpretation (posterior).

4. Predictive Processing

4.1 The Free Energy Principle (Karl Friston)

Predictive processing, most ambitiously developed by Karl Friston, proposes that the brain is fundamentally a prediction machine. Rather than passively processing sensory input bottom-up, the brain continuously generates top-down predictions about what sensory signals it expects -- and only processes the prediction errors (the mismatches between prediction and reality).

Friston's free energy principle (FEP) provides the mathematical foundation. It states that biological systems minimize variational free energy -- a quantity closely related to surprise. Living organisms cannot afford to be constantly surprised by their environment; they must maintain their internal states within a viable range. They accomplish this in two ways:

4.2 Active Inference and the Unification of Perception and Action

Active inference is one of the most radical implications of predictive processing. It proposes that perception and action are not fundamentally different processes -- both are ways of minimizing prediction error. Perception adjusts internal models to match sensory data; action adjusts the world to match internal predictions.

Predictive processing provides elegant accounts of diverse phenomena:

• Attention: Precision-weighting of prediction errors (attending to something means increasing the gain on its prediction errors)
• Learning: Updating the generative model to make better predictions
• Psychosis: Abnormal precision-weighting -- hallucinations may result from over-weighted priors, delusions from failure to update models
• Autism: Possibly reduced influence of priors, leading to hyper-sensitivity to sensory details

5. Embodied & Situated Cognition

The embodied cognition movement challenges the classical computational view that cognition is abstract symbol manipulation that happens to run on a biological substrate. Instead, it argues that cognition is fundamentally shaped by the body's interactions with the environment.

The 4E framework captures the key dimensions:

6. Human vs AI Cognition

6.1 Where AI Exceeds Humans

6.2 Where Humans Exceed AI

6.3 Deep Learning & Cognitive Plausibility

The rise of deep learning -- neural networks with many layers -- and particularly transformer architectures (Vaswani et al., 2017) that power large language models (LLMs) has reignited fundamental questions about the relationship between artificial and human cognition.

Arguments for cognitive plausibility:

• Deep neural networks learn hierarchical representations that resemble the visual cortex's hierarchy (Yamins et al., 2014)
• LLMs produce text that is often indistinguishable from human writing
• Transformer attention mechanisms bear some resemblance to human selective attention
• These systems exhibit emergent abilities (in-context learning, chain-of-thought reasoning) not explicitly trained

Arguments against cognitive plausibility:

• LLMs require vastly more training data than children need to acquire language
• They lack sensory grounding -- they process text tokens, not embodied experience
• They do not have goals, motivation, or phenomenal experience
• They fail at tasks that require genuine causal or physical reasoning
• The "Chinese Room" argument (Searle, 1980): syntax is not semantics -- manipulating symbols according to rules is not the same as understanding their meaning

7. The Future of Computational Cognitive Science

Computational cognitive science stands at an extraordinary crossroads. Several emerging directions promise to reshape our understanding of mind and intelligence:

Perhaps the most profound question is whether the tools we build to model the mind will ultimately teach us what consciousness is -- or whether they will reveal the limits of computation in capturing what it means to be a thinking, feeling, experiencing being. Either answer would transform our understanding of ourselves.

Exercises & Self-Assessment

Conclusion: Series Finale

In this final installment of our Cognitive Psychology Series, we have explored how the theories and findings from the preceding thirteen parts can be formalized, tested, and extended through computational modeling. Here are the key takeaways:

• Cognitive architectures like ACT-R and SOAR provide unified frameworks for modeling the full range of human cognition, from memory retrieval to problem-solving, with precise quantitative predictions
• Connectionist networks demonstrate that complex cognitive behavior can emerge from simple neuron-like units learning from experience, challenging the need for explicit rules
• Bayesian models show that many aspects of cognition can be understood as optimal (or near-optimal) statistical inference, connecting perception, memory, and learning under a unified mathematical framework
• Predictive processing and the free energy principle offer a grand unifying theory of brain function -- the brain as a prediction machine that minimizes surprise
• Embodied cognition reminds us that mind is not disembodied computation but is deeply shaped by the body and its interactions with the world
• The comparison between human and AI cognition reveals profound differences despite surface similarities, particularly in common-sense reasoning, few-shot learning, and genuine understanding
• The future lies in integration: neurosymbolic AI, developmental approaches, and cognitive digital twins that bridge artificial and human intelligence