Expert System Architecture & Development: Design, Lifecycle & Fuzzy Rules

TAKEAWAYS:

• Expert systems follow a four-layer architecture (user interface → knowledge base → inference engine → explanation module) where the inference engine uses forward/backward chaining to derive conclusions.
• The ES development lifecycle (ROMC approach) mirrors software engineering but emphasizes knowledge acquisition as the most critical and error-prone phase.
• Fuzzy expert systems extend classical ES by handling uncertainty via fuzzy rules (e.g., "IF temperature is slightly high THEN risk is moderate") and membership functions.
• Real-world applications include Ncell’s network fault diagnosis (rule-based ES) and Khalti’s fraud detection (fuzzy logic for transaction risk scoring).
• Common errors in ES development stem from incomplete knowledge bases, overfitting rules, or poor inference engine design (e.g., inefficient search in large rule sets).
• Group decision support systems (GDSS) integrate ES with collaborative tools (e.g., NEPSE’s committee-based stock approval systems) to reduce bias and improve consensus.

1. Expert System Architecture: The Four-Layer Model

Expert systems (ES) replicate human expertise in a domain by combining domain knowledge with logical reasoning. Their architecture is modular, ensuring separation of concerns. Below is the core four-layer structure, visualized as a pipeline:

flowchart LR
    A["User Interface (UI)"] -->|"Input: Queries/Observations"| B["Knowledge Base"]
    B -->|"Rules + Facts"| C["Inference Engine"]
    C -->|"Forward/Backward Chaining"| D["Explanation Module"]
    D -->|"Justification"| A

Key Components Explained

How It Works: A Worked Example

Scenario: Daraz’s customer service uses an ES to diagnose order delays.

1. Input: User reports "Order #12345 not delivered in 7 days."
2. Knowledge Base:
   • Rule 1: IF delivery_status = "shipped" AND tracking_last_seen = "Kathmandu" AND days_delayed > 5 THEN suspect: customs_hold.
   • Fact: tracking_last_seen = "Bhaktapur" (last update 6 days ago).
3. Inference Engine (Forward Chaining):
   • Checks Rule 1 → delivery_status = "shipped" (True), days_delayed = 6 (True), but tracking_last_seen = "Bhaktapur" (False).
   • Triggers Rule 2: IF tracking_last_seen ≠ destination AND days_delayed > 3 THEN suspect: lost_in_transit.
4. Output: "Your order is likely lost in transit between Bhaktapur and Kathmandu. Please contact support for a refund."

2. Expert System Development Lifecycle: The ROMC Approach

The ROMC model (Requirements → Design → Implementation → Maintenance) is tailored for ES development, with knowledge acquisition as the bottleneck. Below is the lifecycle with common pitfalls:

flowchart TD
    A["Requirements Analysis"] -->|"Define scope, users"| B["Design"]
    B -->|"Knowledge engineering"| C["Implementation"]
    C -->|"Prototyping"| D["Maintenance"]
    D -->|"Feedback loop"| A

Step-by-Step Breakdown

Worked Example: Developing an ES for Khalti Fraud Detection

1. Requirements:
   • Goal: Flag transactions with risk score > 0.8 (e.g., sudden large transfer to a new merchant).
   • Users: Khalti’s fraud team + merchants.
2. Design:
   • Knowledge Base:
     • Rule: IF (amount > 50,000 AND merchant_age_days < 30) THEN risk = "high".
     • Fact: user_location ≠ merchant_location (adds to risk).
3. Implementation:
   • Use forward chaining to evaluate every transaction in real-time.
   • Error Handling: If a rule fires but the user is a verified merchant, trigger a human review.
4. Maintenance:
   • Monthly updates: Add new fraud patterns (e.g., "IF IP_address = VPN THEN risk += 0.5").

3. Fuzzy Logic in Expert Systems: Handling Uncertainty

Classical ES use binary logic (True/False), but real-world data is often imprecise. Fuzzy logic extends ES by using degrees of truth (e.g., "slightly high," "very likely").

Key Concepts

1. Fuzzy Sets:
   • Replace crisp sets (e.g., "temperature > 30°C") with membership functions (e.g., "temperature is hot").
   • Visualized as a membership curve:

graph LR
    A["Temperature (°C)"] -->|"0.0"| B["Cold"]
    A -->|"0.5"| C["Warm"]
    A -->|"1.0"| D["Hot"]

2. Fuzzy Rules:

   • Format: IF <fuzzy condition> THEN <fuzzy action> [with weight].
   • Example (for a bank loan ES):
     • IF (income = "low") AND (credit_score = "poor") THEN loan_approval = "reject" [0.9].
     • IF (income = "medium") AND (credit_score = "fair") THEN loan_approval = "approve with conditions" [0.7].

3. Fuzzy Inference System (FIS):

   • Steps:
     1. Fuzzification: Convert crisp input (e.g., income = 25,000) to membership values.
     2. Rule Evaluation: Apply rules to get weighted outputs.
     3. Aggregation: Combine outputs (e.g., max, sum).
     4. Defuzzification: Convert fuzzy output to a crisp decision (e.g., "approve 60%").

Worked Example: NTC’s Network Fault ES with Fuzzy Logic

Scenario: NTC uses an ES to diagnose signal drop in Pokhara.

1. Input: signal_strength = -85dBm, user_complaints = 12/hour.
2. Fuzzification:
   • signal_strength:
     • "Weak" (membership = 0.8),
     • "Strong" (membership = 0.2).
   • user_complaints:
     • "Low" (0.3),
     • "High" (0.7).
3. Rules:
   • IF (signal_strength = "Weak") AND (complaints = "High") THEN fault_severity = "critical" [0.9].
4. Output:
   • Aggregated severity = 0.8 * 0.7 * 0.9 = 0.504 → Defuzzified to "critical".
   • Action: "Dispatch technician to tower #45 immediately."

4. Types of Fuzzy Expert Systems

5. Sources of Errors in Expert System Development

Errors in ES development typically stem from knowledge gaps or design flaws. Below is a root-cause analysis with real-world examples:

6. Group Decision Support Systems (GDSS) and Expert Systems

GDSS integrates multiple stakeholders (e.g., NEPSE’s committee) with ES to improve consensus. Key features:

• Anonymity: Reduces bias (e.g., junior employees in NTC can flag issues).
• Structured Debate: Uses voting rules (e.g., Borda count) + ES recommendations.
• Parallel Processing: ES pre-processes data (e.g., "This stock has 80% growth potential") before human review.

Example: NEPSE’s IPO Approval System

1. ES evaluates company financials → flags "high-risk" IPOs.
2. Committee votes anonymously via GDSS.
3. Final decision combines ES score (60%) + committee consensus (40%).

In the Real World

1. Ncell’s Network Fault Diagnosis ES

   • Idea Used: Rule-based ES with forward chaining.
   • How: Technicians input symptoms (e.g., "no signal in Chitwan"). The ES cross-references 1,200+ rules (e.g., "IF tower_power < 50% AND rain = TRUE THEN suspect: lightning_damage") to suggest fixes. Saves 40% troubleshooting time.

2. Khalti’s Fraud Detection with Fuzzy Logic

   • Idea Used: Fuzzy rules for risk scoring.
   • How: A transaction from a new merchant for ₹50,000 triggers:
     • IF (merchant_age = "new") AND (amount = "large") THEN risk = "high" [0.85].
     • IF (user_location = merchant_location) THEN risk -= 0.3.
     • Final risk = 0.55 → Manual review. Reduces false positives by 60%.

3. Pathao’s Driver-Bike Matching ES

   • Idea Used: Constraint satisfaction (a type of ES).
   • How: The ES matches drivers to rides based on:
     • IF (bike_fuel = "low") AND (distance > 10km) THEN penalty = 0.5.
     • IF (driver_rating > 4.5) THEN priority = "high".
     • Result: 25% faster assignments in Kathmandu traffic.

Exam Tip

1. Architecture Questions:

   • Always draw the four-layer diagram and label each component’s role.
   • For fuzzy ES, show a membership function and a rule evaluation table.

2. Development Lifecycle (ROMC):

   • Weigh knowledge acquisition as the most critical phase (30% of marks).
   • Mention prototyping and expert validation as key steps.

3. Error Analysis:

   • Link errors to real-world examples (e.g., "Incomplete knowledge base → Ncell ES misses rare faults").
   • Use bullet points for causes/mitigations (examiners love structured answers).

4. Fuzzy Logic:

   • Define membership functions clearly (e.g., "triangle," "trapezoid").
   • For inference, show one rule’s evaluation with numbers (e.g., "IF A=0.7 AND B=0.6 THEN output=min(0.7,0.6)=0.6").

5. GDSS:

   • Compare with individual ES: GDSS adds anonymity and structured debate.
   • Example: "NEPSE uses GDSS to combine ES financial analysis with committee ethics checks."

Final Visual Summary:

mindmap
  root((Expert System Architecture))
    Layers
      User Interface
      Knowledge Base
        Rules
        Facts
      Inference Engine
        Forward Chaining
        Backward Chaining
      Explanation Module
    Development
      ROMC
        Requirements
        Design
        Implementation
        Maintenance
    Fuzzy Logic
      Membership Functions
      Fuzzy Rules
      Defuzzification
    Errors
      Incomplete Knowledge
      Overfitting
      Inefficient Search
    Real-World
      Ncell Fault ES
      Khalti Fraud ES
      Pathao Matching ES