Building DSS Systems: Models, Prototypes, and Evaluation

Key Concepts and Approaches to Building DSS

Model-Driven DSS

A Model-Driven DSS relies on mathematical, statistical, or simulation models to support decision-making. These models can be financial, optimization, or forecasting tools.

How It Works

1. Model Selection: Choose a model that fits the problem (e.g., linear programming for optimization, time-series analysis for forecasting).
2. Data Input: Feed relevant data into the model (e.g., sales data for forecasting).
3. Processing: The model processes the data to generate insights (e.g., predicting future sales).
4. Output: The results are presented to the decision-maker (e.g., a graph of projected sales).

Worked Example: Inventory Optimization for Daraz

Suppose Daraz wants to optimize inventory levels for a popular product. They use a linear programming model to minimize holding costs while ensuring stock availability.

Assumptions:

• Demand: 1000 units/month
• Holding cost: $2/unit/month
• Ordering cost: $50/order
• Lead time: 1 month

Objective Function: Minimize $Z=50\times \frac{D}{Q}+2\times \frac{Q}{2}$ Where:

• $D=1000$ (demand)
• $Q=$ order quantity

Solution: Using calculus or software (e.g., Excel Solver), we find the Economic Order Quantity (EOQ): $$Q^{\ast }=\sqrt{\frac{2\times 50\times 1000}{2}}=\sqrt{50,000}\approx 224\text{ units}$$

Output: Daraz should order 224 units every month to minimize costs.

Data-Driven DSS

A Data-Driven DSS relies on historical data and analytical tools (e.g., OLAP, data mining) to support decisions. It is commonly used in business intelligence.

How It Works

1. Data Collection: Gather data from databases, spreadsheets, or external sources (e.g., customer transactions).
2. Data Processing: Clean, transform, and aggregate data (e.g., using SQL or Python).
3. Analysis: Apply techniques like regression, clustering, or association rules.
4. Visualization: Present insights via dashboards or reports (e.g., sales trends).

Worked Example: Customer Segmentation for Ncell

Ncell wants to segment customers based on usage patterns to tailor promotions.

Data:

Step 1: Normalize Data Convert raw data to a comparable scale (e.g., using min-max normalization): $$\text{Normalized Calls}=\frac{\text{Calls}-\text{Min}}{\text{Max}-\text{Min}}$$

Step 2: Apply K-Means Clustering (K=2) Use Python or R to cluster customers into two groups:

• Cluster 1 (High Usage): C003 (500 min, 100 SMS, 5 GB)
• Cluster 2 (Low Usage): C001, C002

Output: Ncell can now target Cluster 1 with premium plans and Cluster 2 with budget offers.

Document-Driven DSS

A Document-Driven DSS organizes and retrieves unstructured data (e.g., emails, reports, legal documents) to aid decisions. It uses information retrieval and natural language processing (NLP).

How It Works

1. Document Storage: Store documents in a repository (e.g., PDFs, Word files).
2. Indexing: Create metadata or use NLP to extract keywords.
3. Query Processing: Allow users to search using keywords or questions.
4. Retrieval: Return relevant documents ranked by relevance.

Worked Example: Legal Case Research for a Law Firm

A law firm uses a Document-Driven DSS to find past judgments related to a new case.

Query: "Contract breach penalties in Nepal" Output: The system retrieves:

1. Supreme Court Judgment (2020) on breach clauses
2. Company Law Board rulings (2019) on penalties

Prototyping in DSS Development

Prototyping is an iterative process where a working model of the DSS is built, tested, and refined.

Steps in Prototyping

1. Requirements Gathering: Identify user needs (e.g., what decisions need support?).
2. Quick Design: Create a simple model or interface (e.g., Excel prototype).
3. User Testing: Get feedback and refine.
4. Iteration: Repeat until the DSS meets requirements.

Mermaid Diagram: Prototyping Cycle

flowchart LR
    A["Requirements"] --> B["Quick Design"]
    B --> C["User Testing"]
    C -->|"Feedback"| D["Refine"]
    D --> B

Worked Example: Prototyping a Loan Approval DSS for a Bank

A bank wants a DSS to approve loans based on credit scores and income.

Step 1: Excel Prototype

• Inputs: Credit score (0-850), Annual income ($).
• Rule: Approve if Credit Score > 650 AND Income > $30,000.

Step 2: User Feedback

• Users request additional factors (e.g., employment history).
• Update rule: Credit Score > 650 AND (Income > $30,000 OR Employment > 2 years).

Output: Final DSS integrates with the bank’s core system for automated approvals.

Evaluation of DSS

Evaluating a DSS ensures it meets user needs and performs effectively. Key methods include:

1. Sensitivity Analysis

Tests how changes in input data affect outputs. Used to identify critical variables.

Worked Example: Sensitivity Analysis for NEPSE Stock Predictions

A DSS predicts stock prices using a linear regression model: $$\text{Price}=50+2\times \text{Volume}-1\times \text{Interest Rate}$$

Scenario:

• Base case: Volume = 1000, Interest Rate = 5%
• Change Volume by ±10% → New Price = $70 or $30
• Change Interest Rate by ±1% → New Price = $48 or $52

Conclusion: Volume has a higher impact on price than interest rates.

2. User Acceptance Testing

Users test the DSS in real scenarios to check usability and effectiveness.

Worked Example: User Testing for eSewa’s Payment DSS

eSewa tests a new fraud-detection DSS with 50 users:

• Success Rate: 90% of fraud cases flagged correctly.
• False Positives: 5% (users complain about blocked legitimate transactions).
• Feedback: Simplify the alert system.

Output: eSewa refines the DSS to reduce false positives.

Comparison Table: DSS Approaches

In the Real World

1. Khalti’s Fraud Detection DSS

   • Idea Used: Data-Driven DSS with machine learning.
   • How: Analyzes transaction patterns (e.g., sudden large payments) to flag fraud. Uses anomaly detection to identify outliers.
   • Example: If a user suddenly transfers $10,000 (unusual for their history), the system sends an SMS alert: "This transaction seems unusual. Verify?"

2. Pathao’s Route Optimization DSS

   • Idea Used: Model-Driven DSS with graph theory.
   • How: Uses shortest-path algorithms (e.g., Dijkstra’s) to assign drivers to nearby riders, minimizing travel time.
   • Example: If Rider A is at Thapathali and Rider B at Garden of Dreams, Pathao’s DSS matches them to the same driver if the detour is <2 minutes.

3. NTC’s Network Traffic Management

   • Idea Used: Simulation Models (Model-Driven DSS).
   • How: Uses queueing theory to simulate call volumes and optimize base station placements.
   • Example: During Dashain, NTC’s DSS predicts a 30% increase in calls in Kathmandu. It pre-allocates spectrum to avoid congestion.

Exam Tip

This unit is heavily tested on:

1. Differentiating DSS types (model-driven vs. data-driven vs. document-driven). Expect short-answer questions like: "Which DSS approach would you use for analyzing customer reviews? Why?" Answer: Document-Driven DSS because reviews are unstructured text.

2. Prototyping steps. Be ready to describe the cycle in 3-4 points or draw a simple flowchart.

3. Evaluation methods. Know:

   • Sensitivity analysis = testing input changes.
   • User testing = real-world feedback. Expect a case study (e.g., "How would you evaluate a DSS for a Daraz warehouse?").

4. Worked examples. Always show calculations (e.g., EOQ, clustering steps) and link to real scenarios (e.g., Khalti fraud, Pathao routes).

Common Pitfalls:

• Confusing model-driven (mathematical) with data-driven (statistical).
• Forgetting to iterate in prototyping.
• Ignoring user feedback in evaluation.

Visuals

1. Decision Tree for Loan Approval (Model-Driven DSS)

graph TD
    A["Start"] --> B["Credit Score > 650?"]
    B -->|"Yes"| C["Income > 30k?"]
    B -->|"No"| D["Reject"]
    C -->|"Yes"| E["Approve"]
    C -->|"No"| F["Employment > 2 years?"]
    F -->|"Yes"| E
    F -->|"No"| D

2. Neural Network Layers (Data-Driven DSS for Fraud Detection)

graph TD
    A["Input Layer: Transaction Data"] --> B["Hidden Layer 1: 64 Neurons"]
    B --> C["Hidden Layer 2: 32 Neurons"]
    C --> D["Output Layer: Fraud Probability"]

3. Real Picture: eSewa Fraud Alert SMS

4. Mermaid Diagram: DSS Development Pipeline

flowchart LR
    A["Problem Identification"] --> B["Choose DSS Type"]
    B --> C["Data Collection"]
    C --> D["Model/Prototype Development"]
    D --> E["User Testing"]
    E -->|"Feedback"| F["Refinement"]
    F --> D
    D --> G["Deployment"]
    G --> H["Monitoring & Maintenance"]