Kontrol Adaptif Berbasis
Kecerdasan Buatan: Fuzzy

Logika Klasik vs Logika Fuzzy

Membership Function: Mengukur Derajat Keanggotaan

Contoh Rule Base untuk Fuzzy PID (Error × ΔError → ΔKp)

NB=Negatif Besar, NM=Negatif Medium, NS=Negatif Kecil, ZE=Nol, PS=Positif Kecil, PM=Positif Medium, PB=Positif Besar

Metode Defuzzifikasi

Kasus 1: Manajemen Energi Smart Grid

Kasus 2: Kontrol Traffic di Koridor Kritis

import numpy as np
import matplotlib.pyplot as plt

# ==========================================
# FUZZY PID: KONTROL FREKUENSI SMART GRID
# Tanpa library eksternal — implementasi manual
# ==========================================

# === MEMBERSHIP FUNCTIONS ===
def trimf(x, a, b, c):
    """Triangular membership function"""
    return np.maximum(0, np.minimum((x-a)/(b-a+1e-10), (c-x)/(c-b+1e-10)))

def fuzzify_error(e):
    """Fuzzifikasi error frekuensi (range -3 Hz to +3 Hz)"""
    nb = trimf(e, -3, -3, -1.5)   # Negatif Besar
    ns = trimf(e, -3, -1.5, 0)     # Negatif Kecil
    ze = trimf(e, -1.0, 0, 1.0)    # Nol
    ps = trimf(e, 0, 1.5, 3)       # Positif Kecil
    pb = trimf(e, 1.5, 3, 3)       # Positif Besar
    return nb, ns, ze, ps, pb

def fuzzy_kp_tuner(e, de):
    """Fuzzy tuner untuk Kp berdasarkan error dan perubahan error"""
    nb_e, ns_e, ze_e, ps_e, pb_e = fuzzify_error(e)
    nb_d, ns_d, ze_d, ps_d, pb_d = fuzzify_error(de*5)   # scale de
    
    # Rule base (singleton output — Takagi-Sugeno)
    # Semakin besar error → Kp harus besar
    rules = {
        'NB_NB': min(nb_e, nb_d) * 3.0,
        'NB_ZE': min(nb_e, ze_d) * 2.5,
        'NS_NS': min(ns_e, ns_d) * 2.0,
        'ZE_ZE': min(ze_e, ze_d) * 1.0,   # near setpoint → Kp kecil
        'PS_PS': min(ps_e, ps_d) * 2.0,
        'PB_ZE': min(pb_e, ze_d) * 2.5,
        'PB_PB': min(pb_e, pb_d) * 3.0,
    }
    total_w  = sum(rules.values()) + 1e-10
    delta_Kp = sum(rules.values()) / total_w
    return np.clip(delta_Kp, 0.5, 3.5)

def fuzzy_ki_tuner(e):
    """Ki kecil saat error besar (hindari windup), besar saat error kecil"""
    nb_e, ns_e, ze_e, ps_e, pb_e = fuzzify_error(e)
    ki = (nb_e + pb_e) * 0.1 + (ns_e + ps_e) * 0.3 + ze_e * 0.6
    total = nb_e+pb_e+ns_e+ps_e+ze_e + 1e-10
    return np.clip(ki/total, 0.05, 0.8)

# === MODEL SISTEM: Load-Frequency Control ===
M=8; D=1.2; dt=0.05; T=80
t = np.arange(0, T, dt); N = len(t)

P_load = np.zeros(N)
P_load[int(5/dt):int(25/dt)]  = 0.4
P_load[int(30/dt):int(50/dt)] = -0.3
P_load[int(55/dt):]             = 0.6  # gangguan besar

def simulate(use_fuzzy):
    f = np.zeros(N); integral_e = 0; prev_e = 0
    Kp_hist = np.zeros(N); Ki_hist = np.zeros(N)
    for k in range(1, N):
        e = -f[k-1]
        de = (e - prev_e) / dt
        
        if use_fuzzy:
            Kp = fuzzy_kp_tuner(e, de)
            Ki = fuzzy_ki_tuner(e)
        else:
            Kp, Ki = 1.5, 0.3           # PID statis
        
        Kp_hist[k] = Kp; Ki_hist[k] = Ki
        integral_e = np.clip(integral_e + e*dt, -3, 3)
        P_gen = np.clip(Kp*e + Ki*integral_e, -1.5, 1.5)
        df = (P_gen - P_load[k] - D*f[k-1]) / M
        f[k] = f[k-1] + df*dt
        prev_e = e
    return f, Kp_hist, Ki_hist

f_static, Kp_s, _ = simulate(use_fuzzy=False)
f_fuzzy,  Kp_f, Ki_f = simulate(use_fuzzy=True)

# === PLOT ===
fig, axes = plt.subplots(3, 1, figsize=(12, 9))

axes[0].plot(t, f_static, 'tomato', lw=1.8, label='PID Statis (Kp=1.5, Ki=0.3)')
axes[0].plot(t, f_fuzzy,  'lime',   lw=2.0, label='Fuzzy PID (Kp,Ki adaptif)')
axes[0].axhline(0, color='orange', ls='--', lw=1.5, label='Target Δf=0')
axes[0].fill_between(t, -0.2, 0.2, alpha=0.07, color='lime')
axes[0].set_ylabel('Δf (Hz)')
axes[0].set_title('Smart Grid: Fuzzy PID vs PID Statis — Kontrol Frekuensi 50 Hz')
axes[0].legend(fontsize=9); axes[0].grid(alpha=0.3)

axes[1].plot(t, Kp_f, 'orange', lw=1.5, label='Kp Fuzzy (adaptif)')
axes[1].axhline(1.5, color='tomato', ls='--', lw=1.2, alpha=0.7, label='Kp Statis=1.5')
axes[1].set_ylabel('Nilai Kp')
axes[1].set_title('Kp Fuzzy: Naik Otomatis saat Gangguan Besar, Turun saat Stabil')
axes[1].legend(); axes[1].grid(alpha=0.3)

axes[2].plot(t, P_load, 'red', lw=1.5, label='Gangguan Beban')
axes[2].plot(t, Ki_f,   'cyan',lw=1.5, label='Ki Fuzzy')
axes[2].set_xlabel('Waktu (s)'); axes[2].set_ylabel('Nilai')
axes[2].set_title('Gangguan Beban vs Ki Fuzzy (Kecil saat Error Besar = Cegah Windup)')
axes[2].legend(); axes[2].grid(alpha=0.3)

plt.tight_layout(); plt.show()

print(f"Max |Δf| PID Statis : {np.max(np.abs(f_static)):.4f} Hz")
print(f"Max |Δf| Fuzzy PID  : {np.max(np.abs(f_fuzzy)):.4f} Hz")
print(f"RMSE PID Statis     : {np.sqrt(np.mean(f_static**2)):.4f} Hz")
print(f"RMSE Fuzzy PID      : {np.sqrt(np.mean(f_fuzzy**2)):.4f} Hz")
print(f"\n✅ Fuzzy PID tidak butuh model matematis sistem — hanya aturan linguistik!")