Fuzzy System for Determining Project Priorities

A decision support system using Mamdani Fuzzy Inference to prioritize business project proposals based on Budget, Duration, and Strategic Business Impact.

Hardware & Tech Stack

Python numpy matplotlib Fuzzy Logic Mamdani FIS Decision Support Systems

Skills & Competencies

Knowledge Modeling Fuzzy Inference Rules Membership Functions Mamdani Defuzzification Centroid Method Analytical Decision Making

The Problem

Traditional project scoring methods rely on linear weighted scoring models. These models force project managers to assign arbitrary numerical values to highly subjective, non-linear variables—such as "strategic business impact" or "estimated complexity". This approach is prone to human bias, ignores data uncertainty, and fails to handle overlapping qualitative boundaries, leading to inconsistent prioritization schedules.

The Fuzzy Solution

By implementing a Mamdani Fuzzy Inference System, project metrics (Budget, Duration, and Impact) are converted into continuous degrees of membership across overlapping linguistic descriptors. A system of 18 logic rules resolves these values into a fuzzy output set. Numerical defuzzification via the Centroid Method calculates a final priority score (0-100), providing an objective and flexible decision tool.

Mathematical Membership Functions

Linguistic Input Math

Input parameters are fuzzified into partial membership states. For example, Budget (\(x\)) is mapped to a membership degree \(\mu(x) \in [0,1]\) across three sets:

Budget Low (Rendah): \[\mu_{\text{low}}(x) = \max\left(0, \min\left(\frac{30 - x}{20}, 1\right)\right)\]

Budget Medium (Sedang): \[\mu_{\text{mid}}(x) = \max\left(0, \min\left(\frac{x - 10}{20}, \frac{90 - x}{20}, 1\right)\right)\]

Defuzzification (Centroid Method)

The Mamdani output is defuzzified using the Center of Area (COA) / Centroid calculation to calculate a single crisp numerical score. This is computed by integrating the aggregated membership profile \(\mu_C(z)\) across the output domain:

\[ z_{\text{COA}} = \frac{\sum_{i=1}^{n} \mu_C(z_i) \cdot z_i}{\sum_{i=1}^{n} \mu_C(z_i)} \]

Where \(z_i\) spans the priority scale from 0 to 100 (discretized into 101 points), and \(\mu_C(z_i)\) represents the combined height profile of the aggregated fuzzy rules.

Live Interactive Fuzzy Logic Dashboard

Adjust the project parameters below to see fuzzification, active inference rules, output aggregation, and centroid defuzzification calculations update in real time.

Input Parameters & Fuzzification

Budget (Anggaran) 95

Duration (Durasi) 45 days

Business Impact (Pengaruh) 80

Mamdani FIS Output

Active Inference Rules

Output Aggregation & Centroid

Rendah

Sedang

Tinggi

Aggregated Output

Calculated Priority Score

48.33

Medium Priority

Python Implementation Source Code

Below is the core Mamdani Fuzzy Inference System algorithm implemented in Python using standard numerical array libraries, structured into logical blocks.

1. Libraries & Fuzzification Functions

This block imports mathematical array utilities and defines the membership functions for the three input criteria. Trapezoidal and triangular membership curves are calculated using linear slope equations, bounded between 0 and 1.

import numpy as np
import matplotlib.pyplot as plt

def fuzzifikasi_anggaran(x):
    rendah = max(0, min((30 - x) / 20, 1))
    sedang = max(0, min((x - 10) / 20, (90 - x) / 20, 1))
    tinggi = max(0, min((x - 70) / 20, 1))
    return {'rendah': rendah, 'sedang': sedang, 'tinggi': tinggi}

def fuzzifikasi_durasi(x):
    pendek = max(0, min((90 - x) / 60, 1))
    sedang = max(0, min((x - 30) / 60, (360 - x) / 90, 1))
    panjang = max(0, min((x - 270) / 90, 1))
    return {'pendek': pendek, 'sedang': sedang, 'panjang': panjang}

def fuzzifikasi_pengaruh(x):
    kecil = max(0, min((60 - x) / 40, 1))
    besar = max(0, min((x - 20) / 40, 1))
    return {'kecil': kecil, 'besar': besar}

2. Knowledge base & Mamdani Inference

This function runs the inference step using 18 linguistic rules. It applies Mamdani's min-operator to relate the active membership values of budget, duration, and business impact, accumulating the active rule strengths by taking the maximum strength for each output set.

def rule_inferensi(anggaran, durasi, pengaruh):
    rules = [
        ('rendah', 'panjang', 'kecil', 'rendah'),
        ('rendah', 'panjang', 'besar', 'rendah'),
        ('rendah', 'sedang', 'kecil', 'rendah'),
        ('rendah', 'sedang', 'besar', 'sedang'),
        ('rendah', 'pendek', 'kecil', 'sedang'),
        ('rendah', 'pendek', 'besar', 'sedang'),
        ('sedang', 'panjang', 'kecil', 'rendah'),
        ('sedang', 'panjang', 'besar', 'sedang'),
        ('sedang', 'sedang', 'kecil', 'sedang'),
        ('sedang', 'sedang', 'besar', 'sedang'),
        ('sedang', 'pendek', 'kecil', 'sedang'),
        ('sedang', 'pendek', 'besar', 'tinggi'),
        ('tinggi', 'panjang', 'kecil', 'sedang'),
        ('tinggi', 'panjang', 'besar', 'sedang'),
        ('tinggi', 'sedang', 'kecil', 'sedang'),
        ('tinggi', 'sedang', 'besar', 'tinggi'),
        ('tinggi', 'pendek', 'kecil', 'tinggi'),
        ('tinggi', 'pendek', 'besar', 'tinggi'),
    ]

    output = {'rendah': 0, 'sedang': 0, 'tinggi': 0}

    for rule in rules:
        a, b, c, z = rule
        if anggaran[a] and durasi[b] and pengaruh[c]:
            strength = min(anggaran[a], durasi[b], pengaruh[c])
            output[z] = max(output[z], strength)

    return output

3. Defuzzification (COA Centroid)

This function defuzzifies the accumulated output membership profiles using the center of gravity (centroid) equation. It discretizes the output priority domain (0-100) into 101 slices, aggregates the height slices, and computes the weighted average centroid value.

def defuzzifikasi(output):
    z_values = np.linspace(0, 100, 101)
    rendah = np.maximum(0, np.minimum(1, (40 - z_values) / 20))
    sedang = np.maximum(0, np.minimum((z_values - 20) / 20, np.minimum(1, (80 - z_values) / 20)))
    tinggi = np.maximum(0, np.minimum((z_values - 60) / 20, 1))

    aggregated = (
        np.fmax(np.fmin(output['rendah'], rendah),
        np.fmax(np.fmin(output['sedang'], sedang), np.fmin(output['tinggi'], tinggi)))
    )

    numerator = np.sum(aggregated * z_values)
    denominator = np.sum(aggregated)

    return numerator / denominator if denominator != 0 else 0

Academic Context & Comprehensive Report

Project Background

This project was developed as a case study for decision support modeling in business economics. Fuzzy logic provides a more realistic approximation of project feasibility by incorporating uncertainty rather than relying on strict, arbitrary weight calculations.

Authors: Muhammad Fitran Ramadhan (1103220156) & Muhammad Wira Al Fikri (1103223104), Class TK-46-05, School of Electrical Engineering.

📄

Access the complete academic report detailing formulas, membership functions, and business evaluation logic.

Open PDF Report

Explore the Codebase

Access the complete Python source code files, custom membership graph generators, and evaluation notebooks on GitHub.

Go to GitHub Repository