Cognitive Psychology Series Part 6: Learning & Knowledge

1. Classical Conditioning

Classical conditioning — the simplest form of associative learning — remains one of the most important discoveries in the history of psychology. It explains everything from food aversions to phobias to the placebo effect.

1.1 Pavlov's Discovery

In the 1890s, Russian physiologist Ivan Pavlov was studying digestion in dogs when he noticed something unexpected: dogs began salivating not just when food was placed in their mouths but when they heard the laboratory assistant's footsteps approaching. This "psychic secretion" led Pavlov to systematically study the process we now call classical conditioning.

1.2 Key Phenomena

1.3 Biological Constraints on Learning

# Simulating Classical Conditioning: Rescorla-Wagner Model
# The most influential computational model of conditioning

class RescorlaWagnerModel:
    """
    The Rescorla-Wagner Model (1972):
    Change in association = learning_rate * (surprise)
    DeltaV = alpha * beta * (lambda - V_total)

    Key insight: learning is driven by PREDICTION ERROR -
    the discrepancy between what is expected and what occurs.
    This is the ancestor of modern reinforcement learning!
    """

    def __init__(self, alpha=0.3, beta=0.3, lambda_val=1.0):
        self.alpha = alpha      # CS salience (learning rate)
        self.beta = beta        # US intensity
        self.lambda_val = lambda_val  # Maximum conditioning
        self.associations = {}  # CS -> associative strength

    def trial(self, cs_list, us_present=True):
        """Run one conditioning trial."""
        lambda_val = self.lambda_val if us_present else 0.0

        # Calculate total prediction
        v_total = sum(self.associations.get(cs, 0.0) for cs in cs_list)

        # Prediction error (surprise signal)
        prediction_error = lambda_val - v_total

        # Update each CS
        updates = {}
        for cs in cs_list:
            if cs not in self.associations:
                self.associations[cs] = 0.0
            delta_v = self.alpha * self.beta * prediction_error
            self.associations[cs] += delta_v
            updates[cs] = delta_v

        return v_total, prediction_error, updates

    def run_experiment(self, name, phases):
        """Run a multi-phase conditioning experiment."""
        print(f"\n=== {name} ===")
        for phase_name, trials in phases:
            print(f"\n  Phase: {phase_name}")
            for trial_info in trials:
                cs_list, us_present, n_trials = trial_info
                for t in range(n_trials):
                    v, pe, updates = self.trial(cs_list, us_present)
                strengths = {cs: f"{v:.3f}"
                           for cs, v in self.associations.items()}
                print(f"    After {n_trials} trials of "
                      f"{'+'.join(cs_list)}{'->US' if us_present else '(no US)')}: "
                      f"{strengths}")

# Demonstrate key phenomena
model = RescorlaWagnerModel()
model.run_experiment("Basic Acquisition + Extinction", [
    ("Acquisition", [(['bell'], True, 10)]),
    ("Extinction", [(['bell'], False, 10)]),
])

# Blocking: prior learning blocks new learning
model2 = RescorlaWagnerModel()
model2.run_experiment("Kamin's Blocking Effect", [
    ("Phase 1: Condition A alone", [(['A'], True, 10)]),
    ("Phase 2: Condition A+B compound",  [(['A', 'B'], True, 10)]),
])
print("  B fails to gain associative strength because A")
print("  already fully predicts the US - no prediction error!")

2. Operant Conditioning

While classical conditioning involves learning associations between events in the environment, operant conditioning involves learning from the consequences of one's own behavior. If an action leads to a positive outcome, you're more likely to repeat it; if it leads to a negative outcome, you're less likely.

2.1 Thorndike & Skinner

Edward Thorndike's (1898) cats in puzzle boxes established the Law of Effect: behaviors followed by satisfying consequences are strengthened, while behaviors followed by annoying consequences are weakened. B.F. Skinner (1930s onward) refined this into a systematic science of behavior, introducing the Skinner box (operant chamber) and meticulously studying how different schedules of reinforcement shape behavior.

2.2 Reinforcement Schedules

One of Skinner's most important discoveries was that the schedule on which reinforcement is delivered has a dramatic effect on the pattern and persistence of behavior:

2.3 Punishment & Its Limits

While reinforcement teaches what to do, punishment teaches what not to do — but it does so imperfectly. Research has consistently shown that punishment has significant limitations:

• Suppresses but doesn't eliminate: Punishment reduces behavior only while the punishing agent is present; behavior often returns when surveillance stops
• Emotional side effects: Punishment generates fear, anxiety, and aggression — which can interfere with learning
• Doesn't teach alternatives: Punishment tells you what NOT to do but not what TO do
• Models aggression: Physical punishment teaches children that aggression is an acceptable way to solve problems (Bandura's modeling research)

3. Observational Learning

3.1 Bandura's Social Learning Theory

Albert Bandura demonstrated that learning doesn't require direct experience or reinforcement — we can learn by watching others. This observational learning (or modeling) bridged behaviorism and cognitive psychology by showing that internal cognitive processes mediate between observation and behavior.

Bandura identified four processes necessary for observational learning:

1. Attention: You must notice and attend to the model's behavior
2. Retention: You must encode and remember the behavior in memory
3. Reproduction: You must have the physical/cognitive ability to perform the behavior
4. Motivation: You must have a reason to reproduce the behavior (reinforcement, either direct or vicarious)

3.2 Mirror Neurons

In the 1990s, Giacomo Rizzolatti's team discovered mirror neurons in the macaque premotor cortex — neurons that fire both when the monkey performs an action and when it observes another performing the same action. Similar mirror-like activity has been found in humans using fMRI.

4. Schemas & Knowledge Organization

As learning accumulates, knowledge must be organized into structures that allow efficient storage, retrieval, and application. The concept of the schema is central to understanding how knowledge is organized in the mind.

4.1 Schema Theory

A schema is a cognitive framework — a structured cluster of knowledge about a concept, event, or category that organizes information and guides expectations. The concept was introduced by Frederic Bartlett (1932) in his landmark study of memory.

4.2 Scripts & Mental Models

A script (Schank & Abelson, 1977) is a special type of schema that represents a stereotyped sequence of events — like going to a restaurant, visiting a doctor, or attending a lecture. Scripts allow us to navigate familiar situations efficiently by providing default expectations.

Mental models (Johnson-Laird, 1983) are dynamic internal representations that simulate the structure and behavior of systems in the world. Unlike static schemas, mental models can be "run" mentally to predict outcomes — like when you imagine what will happen if you push a domino or when you reason about a mechanical device.

4.3 Declarative vs Procedural Knowledge

John Anderson's ACT-R theory distinguishes between two fundamental types of knowledge that interact during learning:

# Modeling Knowledge Compilation (ACT-R inspired)
# Declarative -> Procedural knowledge transformation

class SkillAcquisition:
    """
    Anderson's three-stage theory of skill acquisition:
    1. Cognitive (declarative) - slow, deliberate, error-prone
    2. Associative - procedures being compiled, fewer errors
    3. Autonomous - fast, automatic, minimal attention needed
    """

    def __init__(self, skill_name):
        self.skill = skill_name
        self.practice_trials = 0
        self.stage = 'cognitive'
        self.speed = 100.0      # Arbitrary time units
        self.error_rate = 0.40  # 40% errors initially
        self.automaticity = 0.0 # 0 to 1

    def practice(self, n_trials=1):
        """
        Power Law of Practice: T = a * N^(-b)
        Performance improves as a power function of practice.
        """
        import math

        for _ in range(n_trials):
            self.practice_trials += 1
            n = self.practice_trials

            # Power law of practice (Newell & Rosenbloom, 1981)
            self.speed = 100.0 * (n ** -0.4)
            self.error_rate = max(0.02, 0.40 * (n ** -0.5))
            self.automaticity = min(1.0, 1 - math.exp(-n / 50))

            # Determine stage
            if self.automaticity < 0.3:
                self.stage = 'cognitive'
            elif self.automaticity < 0.7:
                self.stage = 'associative'
            else:
                self.stage = 'autonomous'

    def display_learning_curve(self):
        """Show the power law of practice in action."""
        print(f"=== Skill Acquisition: {self.skill} ===")
        print(f"{'Trials':<10}{'Speed':<10}{'Errors':<10}"
              f"{'Auto.':<10}{'Stage':<15}")
        print("-" * 55)

        checkpoints = [1, 5, 10, 25, 50, 100, 200, 500]
        self.practice_trials = 0
        self.speed = 100.0
        self.error_rate = 0.40
        self.automaticity = 0.0

        for target in checkpoints:
            while self.practice_trials < target:
                self.practice(1)
            print(f"{self.practice_trials:<10}{self.speed:<10.1f}"
                  f"{self.error_rate:<10.3f}{self.automaticity:<10.2f}"
                  f"{self.stage:<15}")

        print(f"\nKey insight: improvement follows the POWER LAW -")
        print(f"rapid gains early, then diminishing returns.")
        print(f"This is one of the most robust laws in psychology!")

driving = SkillAcquisition("Car Driving")
driving.display_learning_curve()

5. Skill Acquisition & Expertise

5.1 Automaticity

Automaticity is the end state of extensive practice: a skill that was once slow, effortful, and attention-demanding becomes fast, effortless, and automatic. Automatic processes have four defining characteristics (Shiffrin & Schneider, 1977):

• Fast: Execute much more quickly than controlled processes
• Parallel: Can run alongside other processes without interference
• Effortless: Require minimal attention or working memory
• Involuntary: Difficult to suppress once triggered (Stroop effect!)

5.2 Deliberate Practice & Expertise Development

K. Anders Ericsson's research on expertise development showed that world-class performance in any domain typically requires approximately 10,000 hours of deliberate practice (not just any practice). Deliberate practice has specific characteristics:

5.3 Near vs Far Transfer

Transfer is the ability to apply learning from one context to another. It is arguably the most important — and most elusive — goal of education.

6. Metacognition & Self-Regulated Learning

6.1 Flavell's Framework

Metacognition — "thinking about thinking" — was introduced by John Flavell in 1979. It encompasses both metacognitive knowledge (what you know about your own cognition) and metacognitive regulation (how you control your cognitive processes).

6.2 Self-Regulated Learning

Zimmerman's model of self-regulated learning (SRL) describes a cyclical process through which learners take active control of their own learning:

1. Forethought Phase: Set goals, plan strategies, activate prior knowledge, build self-efficacy
2. Performance Phase: Execute strategies, self-monitor, maintain focus, use help-seeking
3. Reflection Phase: Evaluate outcomes, attribute causes (effort vs. ability), adjust strategies

# Self-Regulated Learning System
# Demonstrates metacognitive monitoring and strategy selection

class SelfRegulatedLearner:
    """
    Models a self-regulated learner who monitors comprehension,
    selects strategies, and adjusts based on performance.
    """

    def __init__(self, name):
        self.name = name
        self.knowledge = {}
        self.strategies = {
            'retrieval_practice': {'effectiveness': 0.85, 'effort': 'high'},
            'spaced_practice': {'effectiveness': 0.80, 'effort': 'medium'},
            'interleaving': {'effectiveness': 0.75, 'effort': 'high'},
            'elaboration': {'effectiveness': 0.70, 'effort': 'medium'},
            're_reading': {'effectiveness': 0.30, 'effort': 'low'},
            'highlighting': {'effectiveness': 0.20, 'effort': 'low'},
        }
        self.study_log = []

    def assess_knowledge(self, topic, confidence):
        """
        Metacognitive monitoring: assess current understanding.
        Calibration = alignment between confidence and actual knowledge.
        """
        self.knowledge[topic] = {
            'confidence': confidence,  # 0-1
            'actual': None,            # Set after testing
        }
        return confidence

    def select_strategy(self, topic):
        """
        Strategy selection based on metacognitive knowledge.
        Good learners match strategy to task demands.
        """
        confidence = self.knowledge.get(topic, {}).get('confidence', 0)

        if confidence < 0.3:
            # Low confidence: need deep processing
            strategy = 'elaboration'
        elif confidence < 0.6:
            # Moderate: retrieval practice most effective
            strategy = 'retrieval_practice'
        elif confidence < 0.8:
            # Good: interleave with other topics
            strategy = 'interleaving'
        else:
            # High: spaced review to maintain
            strategy = 'spaced_practice'

        eff = self.strategies[strategy]['effectiveness']
        print(f"  Strategy selected: {strategy} "
              f"(effectiveness: {eff:.0%})")
        return strategy

    def study_session(self, topics):
        """Run a complete self-regulated study session."""
        print(f"=== Study Session for {self.name} ===\n")

        # Phase 1: Forethought
        print("Phase 1: FORETHOUGHT (Planning)")
        print("  Setting goals and assessing current knowledge...")
        for topic, confidence in topics:
            self.assess_knowledge(topic, confidence)
            print(f"  - {topic}: confidence = {confidence:.0%}")

        # Sort by confidence (study weakest first)
        sorted_topics = sorted(topics, key=lambda x: x[1])
        print(f"\n  Study order (weakest first): "
              f"{[t[0] for t in sorted_topics]}")

        # Phase 2: Performance
        print(f"\nPhase 2: PERFORMANCE (Studying)")
        for topic, confidence in sorted_topics:
            print(f"\n  Studying: {topic}")
            strategy = self.select_strategy(topic)
            self.study_log.append({
                'topic': topic,
                'strategy': strategy,
                'initial_confidence': confidence
            })

        # Phase 3: Reflection
        print(f"\nPhase 3: REFLECTION (Evaluation)")
        print("  Comparing strategies used:")
        for entry in self.study_log:
            eff = self.strategies[entry['strategy']]['effectiveness']
            print(f"  - {entry['topic']}: used {entry['strategy']} "
                  f"(eff: {eff:.0%})")

        # Metacognitive reflection
        poor_strategies = [e for e in self.study_log
                          if self.strategies[e['strategy']]
                          ['effectiveness'] < 0.4]
        if poor_strategies:
            print(f"\n  Warning: Low-effectiveness strategies detected!")
            print(f"  Consider switching to retrieval practice or spacing.")

learner = SelfRegulatedLearner("Alex")
learner.study_session([
    ("Classical Conditioning", 0.7),
    ("Operant Schedules", 0.3),
    ("Bandura's Theory", 0.5),
    ("Metacognition", 0.2),
])

6.3 Cognitive Tutors & Educational Technology

John Anderson's ACT-R cognitive tutors translate cognitive theory directly into educational technology. These systems model the learner's knowledge state in real-time using production rules, identify misconceptions, and provide targeted instruction.

Exercises & Self-Assessment

Conclusion & Next Steps

In this exploration of learning and knowledge, we've traced the full arc from the simplest associative mechanisms to the most sophisticated metacognitive strategies. Here are the key takeaways:

• Classical conditioning teaches associations between events, driven by prediction error (Rescorla-Wagner model), constrained by biological preparedness, and central to understanding phobias, addictions, and the placebo effect
• Operant conditioning shapes behavior through consequences, with reinforcement schedules powerfully determining response patterns — from slot machine addiction to effective teaching strategies
• Observational learning (Bandura) demonstrates that learning doesn't require direct experience or reinforcement — we learn by watching others, mediated by attention, retention, reproduction, and motivation
• Schemas organize knowledge into structures that guide perception, memory, and expectations — but also distort memories and create stereotypes (Bartlett's "War of the Ghosts")
• Skill acquisition follows the power law: rapid initial improvement gives way to diminishing returns, as declarative knowledge compiles into automatic procedural knowledge
• Deliberate practice, not mere experience, is the key to expertise — requiring targeted challenges, immediate feedback, and metacognitive monitoring
• Metacognition is the master skill: knowing how to monitor, evaluate, and regulate your own learning is what separates effective learners from ineffective ones