Cognitive Systems: Architecture, Models & Human-Machine Interaction

TAKEAWAYS:

• Cognitive systems integrate perception, memory, reasoning, and action into unified architectures (e.g., Soar’s problem-space theory).
• Symbolic AI (e.g., ACT-R) models cognition as rule-based manipulation of mental symbols, while embodied cognition emphasizes physical interaction with the world.
• Hybrid systems (e.g., neural-symbolic AI) combine symbolic reasoning with sub-symbolic processing (e.g., neural networks) for robustness.
• Human-machine interaction leverages cognitive models to design intuitive interfaces (e.g., voice assistants like Siri use ACT-R-inspired parsing).
• Limitations: Symbolic systems struggle with uncertainty; embodied systems require real-time sensory feedback.
• Exam focus: Compare models (Soar vs. ACT-R), explain hybrid architectures, and link to real-world apps (e.g., Pathao’s route planning).

---

Core Concepts: What Is a Cognitive System?

A cognitive system is a computational or biological framework that mimics human cognition—perceiving, learning, reasoning, and acting in dynamic environments. It bridges psychology, neuroscience, and AI to explain how intelligence emerges from interactions between symbolic processing (rules/logic) and sub-symbolic processing (neural patterns).

1. Classical Cognitive Architectures

These are symbolic AI models that represent knowledge as discrete symbols (e.g., words, rules) and manipulate them via algorithms. Two foundational models:

A. Soar (State, Operator, And Result)

• How it works: Soar solves problems by exploring a search space as a state-space tree, where each node is a problem state and edges are operators (actions).

  • Problem-space theory: Intelligence arises from chunking (learning reusable rules) and universal subgoaling (breaking tasks into subproblems).
  • Memory: Divided into working memory (active goals) and long-term memory (rules/chunks).
  • Cycle:
    1. Input: Perceive the environment (e.g., a chessboard).
    2. Elaboration: Apply rules to generate candidate operators.
    3. Decision: Choose an operator (e.g., "move pawn to e4").
    4. Application: Execute the operator; update the state.
    5. Output: Produce a solution (e.g., a chess move) or subgoal.

• Visual: Soar’s Search Space

  graph TD
    A["Initial State\n(Chess: White to move)"] -->|"Operator 1: Move pawn"| B["State 1\n(Pawn at e4)"]
    A -->|"Operator 2: Move knight"| C["State 2\n(Knight at g1)"]
    B -->|"Operator 3: Castle"| D["State 3\n(King castled)"]
    C -->|"Operator 4: Capture"| E["State 4\n(Bishop taken)"]
    D --> F["Goal: Checkmate"]

  Explored path: A → B → D → F (highlighted in green/blue).

• Worked Example: Soar Solves the "Tower of Hanoi" Problem: Move 3 disks from peg A to C, using peg B as auxiliary, with rules:

  1. Only one disk at a time.
  2. Larger disks cannot be on top of smaller ones.

  Trace:

  | Step | State (Disks: A | B | C) | Operator Applied | New State | |------|------------------|-----------------------------|---------------------| | 1 | (3,2,1) | - | - | Move disk 1 (A→C) | (3,2) | - | (1) | | 2 | (3,2) | - | (1) | Move disk 2 (A→B) | (3) | (2) | (1) | | 3 | (3) | (2) | (1) | Move disk 1 (C→B) | (3) | (2,1) | - | | 4 | (3) | (2,1) | - | Move disk 3 (A→C) | - | (2,1) | (3) | | 5 | - | (2,1) | (3) | Move disk 1 (B→A) | (1) | (2) | (3) | | 6 | (1) | (2) | (3) | Move disk 2 (B→C) | (1) | - | (3,2) | | 7 | (1) | - | (3,2) | Move disk 1 (A→C) | - | - | (1,3,2) |

  Key Insight: Soar chunked the "move top disk" rule after Step 1, reusing it for Steps 5 and 7.

B. ACT-R (Adaptive Control of Thought-Rational)

• How it works: ACT-R models cognition as a rational analysis: humans optimize utility (goal achievement) under cognitive constraints (memory, time).

  • Memory: Declarative (facts, stored as chunks) and procedural (production rules).
  • Production System: IF [condition] THEN [action] rules fire when conditions match working memory.
  • Utility-Based Decision Making: Chooses actions that maximize expected utility (e.g., "spend 2 minutes to save 5 minutes later").

• Visual: ACT-R’s Memory Architecture

  classDiagram
    class WorkingMemory {
      +Goals
      +BaseLevelActivation
    }
    class DeclarativeMemory {
      +Chunks
      +Retrieval
    }
    class ProceduralMemory {
      +ProductionRules
      +UtilityCalculator
    }
    WorkingMemory --> DeclarativeMemory : "Retrieves chunks"
    WorkingMemory --> ProceduralMemory : "Fires rules"
    ProceduralMemory --> DeclarativeMemory : "Updates chunks"

• Worked Example: ACT-R Learns Multiplication Task: Learn to multiply 12 × 15. Trace:

  1. Initial State: Working memory has goal: multiply(12, 15).
  2. Rule Fires:

     IF goal is multiply(X, Y) AND X is base-10 digit AND Y is base-10 digit
     THEN retrieve chunk: multiply(10, 5) → 50
     

  3. Decomposition:
     • Break 12 × 15 into (10 + 2) × 15 → 10×15 + 2×15.
     • Retrieve chunks: 10×15 = 150, 2×15 = 30.
  4. Sum: 150 + 30 = 180. Base-Level Activation: The more often multiply(10, 5) is used, the faster it retrieves.

---

2. Embodied Cognition: Beyond Symbols

Classical models assume disembodied reasoning, but embodied cognition argues that intelligence depends on:

• Physical interaction with the environment (e.g., a robot navigating obstacles).
• Sensory-motor grounding (e.g., understanding "red" via visual experience).
• Dynamic systems (e.g., a bee’s dance communicates location via movement).

A. Key Principles

B. Example: Robot Navigation (Embodied AI)

Scenario: A robot in Kathmandu’s Thamel must navigate to a café while avoiding pedestrians.

• Classical Approach (Soar/ACT-R):
  • Represent the map as symbols (e.g., NODE("Thamel", [NODE("Café", distance=500m)])).
  • Use rules: IF at_intersection AND goal_is_café THEN turn_left.
  • Problem: Fails if a pedestrian blocks the path (no sensory feedback).
• Embodied Approach:
  • Sensors: Lidar detects pedestrians; cameras recognize traffic lights.
  • Reactive Behavior:

    flowchart LR
      A["Lidar detects\npedestrian"] --> B["Trigger\navoidance rule"]
      B --> C["Adjust path\nright"]
      C --> D["Update\ninternal map"]
      D --> E["Continue to\ncafé"]

  • Advantage: Adapts to real-time changes (e.g., a sudden protest blocking the street).

---

3. Hybrid Cognitive Systems: Symbolic + Sub-Symbolic

Modern AI combines symbolic reasoning (logic, rules) with sub-symbolic processing (neural networks, fuzzy logic). Examples:

• Neural-Symbolic AI: Uses neural networks to ground symbols in sensory data (e.g., a robot’s "chair" concept learned from images).
• Case-Based Reasoning (CBR): Solves new problems by adapting solutions to similar past cases (e.g., a doctor diagnosing a patient based on past cases).

A. Neural-Symbolic Example: Image Captioning

Task: Generate a caption for an image of a "dog playing frisbee."

1. Sub-Symbolic (CNN): Extracts features (edges, colors, shapes) from the image.
2. Symbolic (ACT-R): Uses rules like:

   IF object_type = "dog" AND action = "catch" AND object = "frisbee"
   THEN generate_caption("A dog is catching a frisbee.")
   

3. Hybrid Output: Combines visual features with linguistic rules.

B. Worked Example: Hybrid Loan Approval System (Nepalese Bank)

Scenario: A bank uses a hybrid system to approve loans.

• Sub-Symbolic (Neural Network):
  • Input: Applicant’s credit score, income, loan history (encoded as vectors).
  • Output: Probability of default (e.g., 0.8 for "high risk").
• Symbolic (Rules):
  • IF probability_of_default > 0.7 AND income < 50,000 THEN reject.
  • IF probability_of_default < 0.3 AND collateral_exists THEN approve.
• Hybrid Decision:
  • Applicant A: Default probability = 0.6, income = 40,000 → Rejected (rule fires).
  • Applicant B: Default probability = 0.2, has land → Approved.

---

## In the Real World

1. Pathao’s Route Planning (Embodied + Symbolic Hybrid)

   • Embodied: Uses real-time GPS, traffic data, and rider locations (sub-symbolic).
   • Symbolic: Applies rules like:

     IF traffic_jam_detected AND rider_is_premium THEN reroute_via_alternative_path.
     

   • Result: Faster, adaptive routes than pure symbolic GPS.

2. eSewa’s Fraud Detection (Neural-Symbolic AI)

   • Sub-Symbolic: Neural networks analyze transaction patterns (e.g., sudden large payments).
   • Symbolic: Rules flag transactions if:

     IF amount > 50,000 AND location != user’s_home_district THEN alert_fraud.
     

3. Ncell’s Chatbot (ACT-R-Inspired)

   • Memory: Stores common customer queries as chunks (e.g., "balance inquiry").
   • Production Rules:

     IF user_says("balance") THEN retrieve_chunk("balance") → respond_with_balance.
     

   • Learning: Improves responses as it processes more queries (chunking).

---

Comparisons: Soar vs. ACT-R vs. Embodied Systems

---

## Exam Tip

1. Define Clearly:

   • Start answers with: "A cognitive system is a framework that integrates [perception, memory, reasoning, action] to achieve intelligent behavior, modeled after human cognition."
   • For Soar/ACT-R: Always mention problem-space or chunking in your definition.

2. Diagrams Are Mandatory:

   • Draw state-space trees for Soar (label explored vs. unexplored paths).
   • Use flowcharts for ACT-R’s production system cycle.
   • For embodied systems, sketch a robot with sensors → controller → actuators.

3. Compare Models:

   • Soar = Problem-solving (e.g., puzzles, games).
   • ACT-R = Human-like learning (e.g., memory, decision-making).
   • Embodied = Real-world interaction (e.g., robots, self-driving cars).
   • Hybrid = Best of both (e.g., AI assistants, fraud detection).

4. Link to Nepal:

   • Nepalese Banks: Use hybrid systems for loan approval (symbolic rules + neural risk assessment).
   • Traffic Management (NTC): Embodied systems could optimize signal timings based on real-time sensor data.
   • e-Governance (eSewa): ACT-R-like chunking for common query responses.

5. Avoid Common Mistakes:

   • ❌ "Soar uses neural networks." → Wrong: Soar is purely symbolic.
   • ❌ "ACT-R is only for robots." → Wrong: It models human cognition too.
   • ✅ Focus on how each model processes information (symbols vs. data vs. sensory input).

---

Pro Tip: For numerical questions (e.g., "Calculate the utility in ACT-R"), assume small numbers (e.g., 2–3 chunks) and show every step of the retrieval/decision process. Examiners reward trace tables like the Hanoi example above.