# Bulanık Mantık: Kuram, Çıkarım, Kontrol ve Uygulamalar

> Bulanık kümelerden üyelik fonksiyonlarına, Mamdani ve Sugeno çıkarımından bulanık kontrole, kümelemeye, ANFIS ve tip-2 sistemlere kadar kuram ve uygulamayı birlikte ele alan ders notu.

- Author: Muhammet Ali Köker
- Language: tr
- Canonical: https://alikoker.com.tr/bulanik-mantik
- Translation: https://alikoker.com.tr/en/fuzzy-logic
- Published: 2022-02-25T00:00:00+03:00
- Modified: 2026-09-09T00:00:00+03:00
- Verified: 2026-09-09T00:00:00+03:00
- Type: article

### Giriş

Gerçek dünyadaki birçok kavram keskin sınırlara sahip değildir. Bir ortamın “sıcak”, bir aracın “hızlı”, bir riskin “yüksek”, bir projenin bütçesinin “yeterli” veya bir hizmetin “iyi” olduğu söylenebilir; fakat bu sözcüklerin sınırları çoğu zaman tek bir sayıyla ayrılmaz.

Klasik mantık ve klasik küme kuramı, üyeliği keskin biçimde ele alır:

```text
üye     → 1
üye değil → 0
```

Bulanık küme kuramında ise bir eleman bir kümeye belirli bir **üyelik derecesi** ile ait olabilir:

```text
0 ≤ μA(x) ≤ 1
```

Örneğin 26 °C'lik bir ortam:

```text
ılık kümesine 0.8
sıcak kümesine 0.4
```

derecesinde üye olarak modellenebilir.

Buradaki `0.4`, “havanın sıcak olma olasılığı %40'tır” anlamına gelmez. Değer, seçilen model içinde 26 °C'nin **“sıcak” kavramına ne ölçüde uyduğunu** gösterir.

Bu ayrım bulanık mantığın temelidir.

Bulanık mantık özellikle şu durumlarda kullanışlıdır:

- sınırlar keskin değilse,
- uzman bilgisi sözel kurallarla ifade edilebiliyorsa,
- sistemin tam matematiksel modeli zor veya pahalıysa,
- ölçümlerde ve kavramlarda belirsizlik varsa,
- insan karar biçimine yakın bir kural tabanı isteniyorsa,
- doğrusal olmayan bir giriş-çıkış ilişkisi yaklaşık olarak modellenmek isteniyorsa.

Ancak bulanık mantık bir “belirsizlik varsa her şeyi çözen” yöntem değildir. Üyelik fonksiyonlarının, kural tabanının, ölçeklerin ve çıkarım yönteminin nasıl seçildiği sistem davranışını doğrudan belirler.

Bu ders notunun amacı bulanık mantığı yalnızca tanımsal düzeyde değil, matematiksel temeli, çıkarım mekanizması, kontrol tasarımı ve güncel uygulama araçlarıyla birlikte açıklamaktır.

---

## 1. Tarihsel gelişim

Bulanık küme kuramının başlangıç noktası, Lotfi A. Zadeh'in 1965 yılında yayımladığı **“Fuzzy Sets”** makalesidir. Zadeh bu çalışmada bir kümeye üyeliğin yalnızca `0` veya `1` ile değil, `0` ile `1` arasındaki derecelerle temsil edilebileceği bir yapı tanımladı.

1965 tarihli çalışma:

> L. A. Zadeh, “Fuzzy Sets,” *Information and Control*, 8(3), 338-353, 1965.

Bulanık kümelerin temel matematiksel çerçevesini oluşturdu.

Daha sonra önemli gelişmeler geldi:

```text
1965 → Bulanık kümeler
1970 → Bulanık ortamda karar verme
1975 → Dilsel değişken ve yaklaşık akıl yürütme
1975 → Mamdani-Assilian bulanık denetleyici
1985 → Takagi-Sugeno sistem modeli
1993 → ANFIS / nöro-bulanık öğrenme
```

Bellman ve Zadeh 1970'te bulanık hedefler ve bulanık kısıtlarla karar vermeyi ele aldı.

Zadeh'in 1975'te yayımladığı **dilsel değişken** çalışmaları, “genç”, “çok sıcak”, “yaklaşık yüksek” gibi doğal dil ifadelerinin bulanık kümelerle matematiksel olarak temsil edilmesine temel oluşturdu.

Mamdani ve Assilian'ın 1975 tarihli çalışması ise uzman operatörün sözel kontrol kurallarını otomatik bir denetleyiciye dönüştürerek bulanık kontrolün mühendislik uygulamalarındaki önemini gösterdi.

1985'te Takagi ve Sugeno, sonuç kısmı sabit veya girişlerin fonksiyonu olan farklı bir bulanık modelleme yaklaşımı geliştirdi.

1993'te J.-S. R. Jang tarafından yayımlanan ANFIS çalışması, bulanık çıkarım sisteminin parametrelerini veriden öğrenebilen uyarlamalı ağ yaklaşımını ortaya koydu.

Bu tarihsel gelişim önemli bir düzeltmeyi gerektirir:

> Bulanık kümeler kuramı 1965'te yapay sinir ağlarının üzerine kurulmuş değildir.

Bulanık mantık ile yapay sinir ağlarının sistematik birleşimi daha sonraki **nöro-bulanık sistemler** içinde gelişmiştir.

---

## 2. Kesinlik, belirsizlik ve bulanıklık

Bilimsel modelleme geleneksel olarak kesin tanımlar kurmaya çalışır. Fakat gerçek dünya her zaman keskin sınırlardan oluşmaz.

Örneğin:

```text
Bir insan ne zaman uzundur?
Bir yol ne zaman kalabalıktır?
Bir sıcaklık ne zaman yüksektir?
Bir risk ne zaman kabul edilemezdir?
```

Bu soruların çoğuna tek bir evrensel eşik vermek zordur.

Örneğin:

```text
boy ≥ 170 cm → uzun
boy < 170 cm → kısa
```

şeklindeki klasik model matematiksel olarak nettir.

Fakat:

```text
169.999 cm → kısa
170.000 cm → uzun
```

sonucu günlük kavramsal kullanım açısından yapay bir sıçrama yaratır.

Bulanık yaklaşım sınırı yumuşatır:

```text
165 cm → uzun üyeliği 0.2
170 cm → uzun üyeliği 0.5
180 cm → uzun üyeliği 0.9
```

Burada üyelik değerleri model tasarımına bağlıdır.

Bulanık mantık, belirsizliği ortadan kaldırmak yerine onu **sayısal ve işlenebilir bir gösterime** dönüştürmeye çalışır.

---

## 3. Bulanıklık ile olasılık aynı şey değildir

Bu konu bulanık mantığın en sık karıştırılan kısmıdır.

### 3.1. Olasılık

Olasılık çoğunlukla bir olayın gerçekleşip gerçekleşmeyeceği hakkındaki belirsizliği ifade eder.

```text
Yarın yağmur yağma olasılığı = 0.30
```

Bu durumda olay:

```text
yağmur yağar
veya
yağmur yağmaz
```

şeklinde kesin bir sonuca sahiptir; belirsizlik olay gerçekleşmeden önceki bilgimizdedir.

### 3.2. Bulanıklık

Bulanıklık ise bir nesnenin veya durumun bir kavrama ne derece uyduğunu ifade eder.

```text
Bugünkü hava “serin” kümesine 0.30 üyedir.
```

Buradaki soru:

> Hava serin mi değil mi?

değil,

> Hava ne ölçüde serin?

sorusudur.

Özet:

| Kavram | Temel soru |
|---|---|
| Olasılık | Olay gerçekleşecek mi? |
| Bulanıklık | Durum kavrama ne ölçüde uyuyor? |

Bulanık üyelik derecesi olasılık değildir.

---

## 4. Klasik kümeler

Bir evrensel küme `X` ve onun alt kümesi `A` olsun.

Klasik kümede karakteristik fonksiyon:

```text
χA(x) = 1, x ∈ A
χA(x) = 0, x ∉ A
```

şeklindedir.

Örneğin “sıcak” kümesini:

```text
A = {x | x ≥ 30 °C}
```

olarak tanımlarsak:

```text
29.9 °C → 0
30.0 °C → 1
```

olur.

Matematiksel açıdan bu tanım nettir.

Ancak kavramların dereceli olduğu birçok gerçek dünya probleminde geçiş çok keskindir.

---

## 5. Bulanık kümeler

Bir bulanık küme `A`, evrensel kümedeki her elemana bir üyelik derecesi atayan üyelik fonksiyonuyla tanımlanır:

```text
μA : X → [0,1]
```

Burada:

```text
μA(x) = 0
```

elemanın kümeye hiç ait olmadığını,

```text
μA(x) = 1
```

tam üyeliği,

```text
0 < μA(x) < 1
```

ise kısmi üyeliği gösterir.

Bulanık küme sembolik olarak:

```text
A = {(x, μA(x)) | x ∈ X}
```

şeklinde ifade edilebilir.

Önemli nokta şudur:

> Üyelik derecesi nesnenin fiziksel özelliği değildir; seçilen kavramsal modelin parçasıdır.

Aynı sıcaklık değeri farklı bağlamlarda farklı üyelik fonksiyonlarına sahip olabilir.

Örneğin 28 °C:

```text
insan konforu açısından sıcak
endüstriyel fırın açısından soğuk
```

olarak modellenebilir.

---

## 6. Evrensel küme

Bir bulanık değişkenin çalıştığı değer aralığına **evrensel küme** veya **söylem evreni (universe of discourse)** denir.

Örneğin oda sıcaklığı:

```text
X = [0, 50] °C
```

aralığında ele alınabilir.

Araç hızı:

```text
X = [0, 200] km/h
```

olabilir.

Üyelik fonksiyonları bu aralık üzerinde tanımlanır.

Evrensel küme yanlış seçilirse, iyi tasarlanmış üyelik fonksiyonları ve kurallar bile beklenmeyen davranış üretebilir.

---

## 7. Üyelik fonksiyonu

Üyelik fonksiyonu, nicel giriş ile dilsel kavram arasındaki köprüdür.

Örneğin sıcaklık için:

```text
SOĞUK
ILIK
SICAK
```

bulanık kümeleri tanımlanabilir.

Her biri:

```text
μSOĞUK(T)
μILIK(T)
μSICAK(T)
```

fonksiyonuyla temsil edilir.

Aynı sıcaklık birden fazla kümeye aynı anda üye olabilir.

Örneğin:

```text
T = 24 °C

μSOĞUK(24) = 0.1
μILIK(24)  = 0.8
μSICAK(24) = 0.3
```

Bu örtüşme bulanık sistemin keskin eşikler yerine yumuşak geçişler üretmesini sağlar.

---

## 8. Üyelik fonksiyonlarının temel özellikleri

### 8.1. Dayanak — support

Bir bulanık kümenin üyeliğinin sıfırdan büyük olduğu bölgedir:

```text
support(A) = {x | μA(x) > 0}
```

### 8.2. Öz — core

Üyelik derecesinin `1` olduğu bölgedir:

```text
core(A) = {x | μA(x) = 1}
```

### 8.3. Sınır — boundary

Kısmi üyeliğin bulunduğu bölgedir:

```text
boundary(A) = {x | 0 < μA(x) < 1}
```

### 8.4. Yükseklik — height

Bir bulanık kümenin en büyük üyelik derecesidir:

```text
h(A) = sup μA(x)
```

Eğer:

```text
h(A) = 1
```

ise küme **normal** bulanık kümedir.

---

## 9. Üçgen üyelik fonksiyonu

En yaygın ve hesaplama açısından en basit fonksiyonlardan biridir.

Parametreler:

```text
a < b < c
```

olmak üzere:

```text
           0                       x ≤ a
μ(x) =     (x-a)/(b-a)             a < x ≤ b
           (c-x)/(c-b)             b < x < c
           0                       x ≥ c
```

şeklinde tanımlanır.

Grafik:

```text
μ
1          /
          /  
         /    
0 ______/_____________ x
       a   b    c
```

Avantajları:

- basit,
- hızlı,
- yorumlanabilir,
- gömülü sistemler için uygundur.

---

## 10. Yamuk üyelik fonksiyonu

Dört parametreyle tanımlanır:

```text
a ≤ b ≤ c ≤ d
```

Şekil:

```text
μ
1        ______
        /      
       /        
0 ____/_______________ x
     a b        c d
```

Özellikle bir kavramın belirli bir aralıkta tamamen geçerli kabul edildiği durumlarda kullanışlıdır.

Örneğin:

```text
“normal sıcaklık”
```

bir aralık boyunca üyelik `1` olacak şekilde modellenebilir.

---

## 11. Gauss üyelik fonksiyonu

Yumuşak ve türevlenebilir bir üyelik fonksiyonudur.

```text
μ(x) = exp(-0.5 * ((x-c)/σ)^2)
```

Burada:

```text
c → merkez
σ → yayılım
```

parametresidir.

Gauss fonksiyonları:

- pürüzsüz geçiş,
- optimizasyon,
- veriyle parametre öğrenme,
- nöro-bulanık sistemler

için elverişlidir.

---

## 12. Diğer üyelik fonksiyonları

Bulanık sistemlerde şu fonksiyonlar da kullanılabilir:

- sigmoid,
- S-eğrisi,
- Z-eğrisi,
- genelleştirilmiş çan,
- Pi-eğrisi,
- özel kullanıcı tanımlı fonksiyonlar.

Üyelik fonksiyonunun şekli problemin doğasına bağlıdır.

Önemli olan grafiksel estetik değil:

> giriş-çıkış davranışını doğru temsil etmesidir.

---

## 13. Üyelik fonksiyonu nasıl seçilir?

Üyelik fonksiyonları birkaç yöntemle belirlenebilir.

### Uzman bilgisi

Bir uzman:

```text
0-15 °C çok soğuk
10-25 °C soğuk
20-30 °C ılık
25-40 °C sıcak
```

gibi başlangıç aralıkları verebilir.

### Veri

Ölçüm verileri:

- kümeleme,
- optimizasyon,
- regresyon,
- nöro-bulanık öğrenme

ile üyelik fonksiyonu parametrelerini belirlemek için kullanılabilir.

### Hibrit yaklaşım

İlk yapı uzman tarafından belirlenir, ardından verilerle ayarlanır.

Bu çoğu mühendislik probleminde iyi bir dengedir.

---

## 14. Alfa kesimi

Bir bulanık kümenin belirli bir üyelik seviyesinin üzerindeki elemanları **α-kesimi** ile gösterilir:

```text
Aα = {x | μA(x) ≥ α}
```

Örneğin:

```text
α = 0.7
```

seçilirse yalnızca üyelik derecesi `0.7` ve üzerinde olan elemanlar alınır.

Alfa kesimleri bulanık kümeyi klasik kümeler dizisi şeklinde analiz etmeye yardımcı olur.

---

## 15. Bulanık sayı

Gerçek sayılar üzerinde tanımlanan, genellikle normal ve dışbükey olan bulanık kümeler **bulanık sayı** olarak kullanılabilir.

Örneğin:

```text
yaklaşık 100
```

kavramı:

```text
(90, 100, 110)
```

üçgen bulanık sayı ile temsil edilebilir.

Bu gösterim:

- maliyet,
- süre,
- tahmin,
- uzman değerlendirmesi,
- çok ölçütlü karar verme

gibi alanlarda kullanılır.

---

## 16. Dilsel değişken

Zadeh'in bulanık mantığa kazandırdığı temel kavramlardan biri **dilsel değişken (linguistic variable)** kavramıdır.

Sayısal değişken:

```text
Sıcaklık = 27.3 °C
```

Dilsel değişken:

```text
Sıcaklık = sıcak
```

olabilir.

Bir dilsel değişken için terim kümesi:

```text
T(Sıcaklık) = {
    çok soğuk,
    soğuk,
    ılık,
    sıcak,
    çok sıcak
}
```

şeklinde tanımlanabilir.

Her dilsel terim bir bulanık kümeye karşılık gelir.

---

## 17. Dilsel değiştiriciler

Doğal dilde:

```text
çok
biraz
oldukça
yaklaşık
değil
```

gibi sözcükler kavramın anlamını değiştirir.

Bulanık mantıkta bunlar **linguistic hedges** olarak modellenebilir.

Örneğin klasik bir yaklaşımda:

```text
μÇOK_SICAK(x) = μSICAK(x)^2
```

kullanılabilir.

Bu işlem düşük üyelikleri daha da düşürür ve “çok sıcak” kümesini daraltır.

Benzer şekilde:

```text
μBİRAZ_SICAK(x) = sqrt(μSICAK(x))
```

gibi genişletici işlemler kullanılabilir.

Bunlar zorunlu tanımlar değil, kullanılan bulanık dil modelinin bir parçasıdır.

---

## 18. Bulanık küme işlemleri

Klasik küme işlemleri bulanık kümelere genişletilebilir.

### Tümleyen

Standart tümleyen:

```text
μ¬A(x) = 1 - μA(x)
```

### Kesişim

Zadeh'in standart kesişimi:

```text
μA∩B(x) = min(μA(x), μB(x))
```

### Birleşim

Standart birleşim:

```text
μA∪B(x) = max(μA(x), μB(x))
```

Örneğin:

```text
μA(x) = 0.7
μB(x) = 0.4
```

ise:

```text
A AND B → min(0.7, 0.4) = 0.4
A OR B  → max(0.7, 0.4) = 0.7
NOT A   → 1 - 0.7 = 0.3
```

olur.

---

## 19. T-norm ve T-conorm

`min` ve `max` bulanık mantıktaki tek seçenek değildir.

Genel kesişim işlemleri **T-norm**, birleşim işlemleri ise **T-conorm / S-norm** ailesiyle ifade edilir.

Örnek T-normlar:

```text
minimum:
T(a,b) = min(a,b)

çarpım:
T(a,b) = a*b
```

Örnek S-normlar:

```text
maksimum:
S(a,b) = max(a,b)

olasılıksal toplam:
S(a,b) = a + b - a*b
```

Örneğin:

```text
a = 0.7
b = 0.4
```

için:

```text
min       = 0.4
product   = 0.28
max       = 0.7
probor    = 0.82
```

elde edilir.

İşleç seçimi kural ateşleme derecesini ve dolayısıyla sistem çıktısını değiştirir.

---

## 20. Bulanık ilişki

Klasik ilişkiler de üyelik derecelerine genişletilebilir.

Bir bulanık ilişki:

```text
R : X × Y → [0,1]
```

şeklinde tanımlanabilir.

Örneğin:

```text
“x, y'ye yakındır”
```

ifadesi iki değişken arasında dereceli ilişki olarak modellenebilir.

Bulanık ilişkiler:

- çıkarım,
- karar verme,
- örüntü eşleme,
- denetim

kuramında önemlidir.

---

## 21. Bulanık mantık ile çok değerli mantık ilişkisi

Klasik mantık:

```text
DOĞRU  = 1
YANLIŞ = 0
```

iki değer kullanır.

Bulanık mantıkta doğruluk derecesi:

```text
[0,1]
```

aralığında olabilir.

Örneğin:

```text
“hava sıcak”
```

önermesinin doğruluk derecesi `0.65` olarak modellenebilir.

Ancak bulanık mantığı yalnızca “çok değerli mantık” ile eşitlemek eksiktir.

Bulanık sistemler aynı zamanda:

- bulanık kümeler,
- dilsel değişkenler,
- üyelik fonksiyonları,
- çıkarım kuralları,
- yaklaşık akıl yürütme

ile birlikte ele alınır.

---

## 22. Bulanık çıkarım sistemi

Bir **bulanık çıkarım sistemi (Fuzzy Inference System — FIS)**, girişlerden bulanık kurallar aracılığıyla çıktı üreten yapıdır.

Genel akış:

```text
Kesin giriş
    ↓
Bulanıklaştırma
    ↓
Kural değerlendirme
    ↓
Çıkarım
    ↓
Kural sonuçlarının birleştirilmesi
    ↓
Durulaştırma
    ↓
Kesin çıktı
```

Klasik Mamdani sisteminde dört temel bileşen vardır:

1. Bulanıklaştırıcı
2. Bilgi / kural tabanı
3. Çıkarım motoru
4. Durulaştırıcı

Kaynak 2019 ders notlarında da aynı temel yapı kullanılmıştır.

---

## 23. Bulanıklaştırma

Bulanıklaştırma, kesin giriş değerinin ilgili bulanık kümelerdeki üyelik derecelerinin hesaplanmasıdır.

Örneğin:

```text
Sıcaklık = 27 °C
```

için:

```text
μILIK(27)  = 0.6
μSICAK(27) = 0.7
```

bulunabilir.

Girdi artık yalnızca:

```text
27
```

değildir.

Çıkarım sistemi açısından:

```text
27 °C → {ILIK:0.6, SICAK:0.7}
```

şeklinde temsil edilir.

---

## 24. Kural tabanı

Bulanık sistemin uzman bilgisini taşıyan kısmı kural tabanıdır.

Genel biçim:

```text
EĞER <öncül> İSE <sonuç>
```

Örnek:

```text
EĞER sıcaklık SICAK
VE nem YÜKSEK
İSE fan hızı HIZLI
```

Başka bir örnek:

```text
EĞER araç hızı YAVAŞ
VE hedefe uzaklık UZAK
İSE motor gücü ARTTIR
```

Kurallar sayısal model yerine uzman davranışını ifade edebilir.

---

## 25. Öncül ve sonuç

Bir bulanık kural iki kısımdan oluşur.

### Öncül — antecedent

```text
EĞER sıcaklık SICAK VE nem YÜKSEK
```

### Sonuç — consequent

```text
İSE fan hızı HIZLI
```

Öncül, kuralın ne ölçüde etkin olduğunu belirler.

Sonuç ise etkinliğin çıktı uzayına nasıl aktarılacağını belirler.

---

## 26. Kural ateşleme derecesi

Örneğin:

```text
μSICAK(T) = 0.7
μYÜKSEK_NEM(H) = 0.4
```

ve AND işlemi `min` ise:

```text
w = min(0.7, 0.4)
w = 0.4
```

olur.

Bu değer kuralın **ateşleme derecesidir**.

Çarpım kullanılırsa:

```text
w = 0.7 * 0.4
w = 0.28
```

olur.

Dolayısıyla AND operatörü teknik bir ayrıntı değil, sistem davranışını etkileyen tasarım kararıdır.


---

## 27. Mamdani çıkarım sistemi

Mamdani tipi bulanık çıkarım, mühendislikte en bilinen yöntemlerden biridir.

1975'te E. H. Mamdani ve S. Assilian tarafından bir buhar makinesi denetimi bağlamında gösterilmiştir.

Mamdani kuralı tipik olarak şöyledir:

```text
EĞER x A ise
VE y B ise
İSE z C'dir
```

Burada:

```text
A, B → giriş bulanık kümeleri
C    → çıkış bulanık kümesi
```

olur.

Örneğin:

```text
EĞER bütçe YETERSİZ
İSE risk YÜKSEK
```

veya:

```text
EĞER sıcaklık SICAK
VE nem YÜKSEK
İSE fan hızı HIZLI
```

---

## 28. Mamdani çıkarımının aşamaları

Mamdani çıkarımı genel olarak şu sırayla yürütülür:

```text
1. Kesin girişleri al
2. Girişleri bulanıklaştır
3. Her kuralın ateşleme derecesini hesapla
4. Kural sonucuna implication uygula
5. Tüm kural çıktılarını birleştir
6. Birleşik bulanık çıktıyı durulaştır
```

Bu aşamalar tek tek incelenmelidir.

---

## 29. Mamdani implication

Bir kuralın ateşleme derecesi:

```text
w = 0.4
```

ve sonuç kümesi:

```text
HIZLI
```

olsun.

### Kesme — clipping

Klasik Mamdani yaklaşımında:

```text
μsonuç(z) = min(w, μHIZLI(z))
```

kullanılabilir.

Yani üyelik fonksiyonu `w` seviyesinde kesilir.

### Ölçekleme — scaling

Alternatif olarak:

```text
μsonuç(z) = w * μHIZLI(z)
```

kullanılabilir.

Bu durumda üyelik fonksiyonunun biçimi ölçeklenir.

Bu iki yöntem aynı sonucu üretmek zorunda değildir.

---

## 30. Kural sonuçlarının birleştirilmesi

Aynı çıktı değişkenini etkileyen birçok kural olabilir.

Örneğin:

```text
Kural 1 → HIZLI, derece 0.4
Kural 2 → ORTA, derece 0.7
Kural 3 → HIZLI, derece 0.2
```

Bu kural sonuçları tek bir çıktı bulanık kümesinde birleştirilir.

Yaygın toplama yöntemi:

```text
max
```

işlemidir.

Her çıktı noktası için:

```text
μagg(z) = max(μ1(z), μ2(z), ..., μn(z))
```

hesaplanır.

Bu işleme **aggregation** denir.

---

## 31. Durulaştırma

Mamdani çıkarımından sonra çıktı hâlâ bulanık kümedir.

Fiziksel sistem çoğu zaman kesin bir değer ister.

Örneğin:

```text
motor gücü = ?
fan PWM = ?
vana açıklığı = ?
yeşil ışık süresi = ?
```

Bulanık çıktıdan kesin sayı elde etme işlemine **durulaştırma (defuzzification)** denir.

---

## 32. Ağırlık merkezi yöntemi

En yaygın durulaştırma yöntemlerinden biri **centroid / center of gravity** yöntemidir.

Sürekli durumda:

```text
            ∫ z μ(z) dz
z* = -------------------------
             ∫ μ(z) dz
```

şeklindedir.

Bu, birleşik bulanık kümenin geometrik ağırlık merkezini verir.

Ayrık örnekleme kullanıldığında:

```text
            Σ zi μ(zi)
z* = -------------------------
             Σ μ(zi)
```

yaklaşımı kullanılabilir.

Kaynak ders notlarında da Mamdani örneklerinde ağırlık merkezi yöntemi kullanılmıştır.

---

## 33. Diğer durulaştırma yöntemleri

Centroid tek seçenek değildir.

### Bisector

Alanı iki eşit parçaya bölen nokta seçilir.

### Mean of Maximum — MOM

En yüksek üyelik derecesine sahip noktaların ortalaması alınır.

### Smallest of Maximum — SOM

Maksimum üyeliğe sahip en küçük değer seçilir.

### Largest of Maximum — LOM

Maksimum üyeliğe sahip en büyük değer seçilir.

Yöntem seçimi:

- hesaplama maliyeti,
- çıktı hassasiyeti,
- sistem davranışı,
- gerçek zaman gereksinimi

açısından değerlendirilmelidir.

---

## 34. Mamdani örneği: risk değerlendirmesi

Kaynak ders notlarındaki temel örneklerden biri proje riskidir.

Girdiler:

```text
Bütçe
Çalışan Sayısı
```

Çıktı:

```text
Risk
```

Dilsel kümeler:

```text
Bütçe:
YETERSİZ
SIKIŞIK
YETERLİ

Çalışan:
AZ
FAZLA

Risk:
DÜŞÜK
NORMAL
YÜKSEK
```

Örnek kurallar:

```text
EĞER bütçe YETERLİ
VEYA çalışan AZ
İSE risk DÜŞÜK

EĞER bütçe SIKIŞIK
VE çalışan FAZLA
İSE risk NORMAL

EĞER bütçe YETERSİZ
İSE risk YÜKSEK
```

Bir giriş çifti verildiğinde:

```text
Bütçe = 70
Çalışan = 45
```

her giriş ilgili üyelik fonksiyonlarında derecelendirilir.

Birden fazla kural aynı anda ateşlenebilir.

Bu özellik bulanık sistemin keskin karar tablosundan farkıdır.

---

## 35. Sugeno çıkarım sistemi

**Takagi-Sugeno-Kang (TSK)** yaklaşımında sonuç kısmı Mamdani'deki gibi bulanık çıktı kümesi olmak zorunda değildir.

Birinci derece Sugeno kuralı:

```text
EĞER x A
VE y B
İSE z = p*x + q*y + r
```

şeklinde olabilir.

Sıfırıncı derece Sugeno sisteminde:

```text
z = c
```

sabit bir sonuç kullanılır.

Örneğin:

```text
EĞER bütçe YETERSİZ
İSE risk = 90
```

gibi.

---

## 36. Sugeno çıktısının hesaplanması

Her kural için ateşleme derecesi:

```text
wi
```

ve kuralın kesin sonucu:

```text
zi
```

olsun.

Genel çıktı:

```text
             Σ wi * zi
z* = -------------------------
               Σ wi
```

ağırlıklı ortalama ile hesaplanır.

Örneğin:

```text
w1 = 0.1, z1 = 20
w2 = 0.2, z2 = 50
w3 = 0.5, z3 = 80
```

ise:

```text
z* =
(0.1*20 + 0.2*50 + 0.5*80)
/
(0.1 + 0.2 + 0.5)

= 65
```

olur.

Bu nedenle Sugeno sistemlerinde klasik Mamdani anlamında ayrı bir çıktı üyelik kümesi durulaştırma aşaması gerekmez.

---

## 37. Sıfırıncı ve birinci derece Sugeno

### Sıfırıncı derece

```text
IF x is A THEN z = c
```

Her sonuç sabittir.

Avantaj:

- basit,
- hızlı,
- gömülü sistem için elverişli.

### Birinci derece

```text
IF x is A AND y is B
THEN z = p*x + q*y + r
```

Çıkış, girişlerin doğrusal fonksiyonudur.

Bu yapı veri tabanlı sistem tanıma ve adaptif öğrenme için güçlüdür.

---

## 38. Mamdani ve Sugeno karşılaştırması

| Özellik | Mamdani | Sugeno |
|---|---|---|
| Kural sonucu | Bulanık küme | Sabit veya fonksiyon |
| Yorumlanabilirlik | Genellikle yüksek | Sonuç kısmı daha matematiksel |
| Durulaştırma | Gerekir | Ağırlıklı ortalama |
| Hesaplama | Daha ağır olabilir | Genellikle daha hızlı |
| Veriyle ayarlama | Mümkün | Özellikle elverişli |
| İnsan uzman kuralı | Çok doğal | Öncül doğal, sonuç matematiksel |
| Kontrol | Yaygın | Dinamik ve adaptif sistemlerde güçlü |

Mamdani “daha doğru”, Sugeno “daha hızlı” şeklinde evrensel bir hüküm kurulamaz.

Seçim problemin yapısına bağlıdır.

---

## 39. Tsukamoto çıkarımı

Mamdani ve Sugeno kadar yaygın anlatılmasa da başka bir yöntem **Tsukamoto** çıkarımıdır.

Tsukamoto sisteminde her kural sonucundaki bulanık kümenin monoton üyelik fonksiyonuna sahip olması gerekir.

Her kural:

```text
wi
```

ateşleme derecesinden bir kesin:

```text
zi
```

değeri üretir.

Son çıktı yine ağırlıklı ortalamaya benzer biçimde hesaplanır.

Tsukamoto yöntemi, Mamdani ile Sugeno arasında kavramsal bir ara yapı gibi düşünülebilir; ancak kullanım alanı daha sınırlıdır.

---

## 40. Çıkarım yönteminde tek bir doğru yoktur

Aynı:

- üyelik fonksiyonları,
- giriş değerleri,
- kural tabanı

kullanılsa bile:

```text
AND = min
```

yerine:

```text
AND = product
```

veya:

```text
implication = min
```

yerine:

```text
implication = product
```

kullanılması farklı sonuçlar üretebilir.

Aynı şekilde durulaştırma yönteminin değişmesi de çıktıyı değiştirir.

Dolayısıyla bir FIS:

> yalnızca kural listesinden ibaret değildir.

Tam tanımda en az şu kararlar vardır:

```text
giriş aralıkları
üyelik fonksiyonları
kural tabanı
AND yöntemi
OR yöntemi
implication
aggregation
durulaştırma
ölçekleme
```

---

## 41. Kural tabanı nasıl tasarlanır?

Bir bulanık kural tabanı genellikle üç kaynaktan oluşturulur.

### Uzman bilgisi

Operatör veya alan uzmanı doğrudan:

```text
EĞER hata büyük pozitif
VE hata artıyorsa
İSE kontrolü güçlü artır
```

gibi kurallar verir.

### Veri

Giriş-çıkış örnekleri incelenerek kurallar üretilebilir.

### Fiziksel bilgi

Sistemin bilinen yönü kuralların mantığını sınırlar.

Örneğin sıcaklık kontrolünde:

```text
oda zaten çok sıcaksa
ısıtıcı gücü artır
```

kuralı fiziksel olarak anlamsızdır.

---

## 42. Kural patlaması

Her giriş için çok sayıda üyelik fonksiyonu kullanıldığında kural sayısı hızla büyür.

Örneğin:

```text
3 giriş
her girişte 5 üyelik fonksiyonu
```

tam kombinasyon:

```text
5^3 = 125
```

kural üretir.

Altı giriş varsa:

```text
5^6 = 15,625
```

olur.

Bu durum **kural patlaması (rule explosion)** problemidir.

Çözüm yaklaşımları:

- daha az üyelik fonksiyonu,
- hiyerarşik FIS,
- seyrek kural tabanı,
- veriyle kural üretimi,
- özellik seçimi,
- birden fazla küçük FIS'in bağlanması.

Güncel araçlar bu amaçla FIS ağaçları gibi yapıları da desteklemektedir.

---

## 43. Kural ağırlığı

Her kural eşit güvenilirlikte olmayabilir.

Kural ağırlığı:

```text
0 ≤ wrule ≤ 1
```

şeklinde kullanılabilir.

Örneğin:

```text
EĞER titreşim YÜKSEK
İSE arıza riski YÜKSEK
Ağırlık = 0.9
```

Bir başka daha zayıf uzman kuralı:

```text
Ağırlık = 0.5
```

ile sisteme eklenebilir.

Ancak ağırlıkların rastgele verilmesi sistemi daha güvenilir yapmaz.

Ağırlıkların:

- uzman gerekçesi,
- veri,
- optimizasyon

ile desteklenmesi gerekir.

---

## 44. Ölçekleme faktörleri

Kontrol sistemlerinde fiziksel girişler çoğu zaman normalize edilir.

Örneğin:

```text
e gerçek hata
Ge giriş ölçekleme kazancı
```

olmak üzere:

```text
en = Ge * e
```

şeklinde normalize edilmiş giriş üretilebilir.

Benzer biçimde:

```text
Δen = Gde * Δe
Δu = Gdu * Δun
```

kullanılabilir.

Ölçekleme faktörleri bulanık kontrolörün kazançlarına benzer biçimde davranışı güçlü şekilde etkileyebilir.

---

## 45. Bulanık kontrol

Bir denetleyicinin amacı ölçülen sistem çıktısını istenen davranışa yönlendirmektir.

Klasik geri besleme:

```text
Referans r(t)
      ↓
     (-) ← y(t)
      ↓
Hata e(t)
      ↓
Denetleyici
      ↓
Kontrol u(t)
      ↓
Proses
      ↓
Çıkış y(t)
```

Bulanık denetleyicide klasik denetleyici bloğunun içinde kural tabanlı FIS bulunur.

---

## 46. Hata ve hata değişimi

Bulanık kontrol sistemlerinde çok yaygın iki giriş:

```text
e(k)  = r(k) - y(k)
```

ve:

```text
Δe(k) = e(k) - e(k-1)
```

şeklindedir.

Çıkış:

```text
u(k)
```

veya artımsal kontrol biçiminde:

```text
Δu(k) = u(k) - u(k-1)
```

olabilir.

Bu yapı kaynak ders notlarındaki sıcaklık kontrol örneğinde de kullanılmıştır.

---

## 47. Neden hata değişimi kullanılır?

Sadece hata büyüklüğü sistemin hareket yönünü söylemez.

Örneğin iki durumda da:

```text
e = +5
```

olsun.

Birinci durumda hata hızla azalıyor:

```text
Δe < 0
```

İkinci durumda hata büyüyor:

```text
Δe > 0
```

Aynı kontrol müdahalesi iki durumda uygun olmayabilir.

Bu nedenle:

```text
e
Δe
```

ikilisi sistemin hem konum hem eğilim bilgisini taşır.

---

## 48. Kontrol için dilsel kümeler

Hata ve hata değişimi için klasik bir terim kümesi:

```text
NB → Negative Big
NS → Negative Small
ZE → Zero
PS → Positive Small
PB → Positive Big
```

şeklinde olabilir.

Daha ayrıntılı sistem:

```text
NB
NM
NS
ZE
PS
PM
PB
```

yedi terim kullanabilir.

Fakat daha çok üyelik fonksiyonu her zaman daha iyi kontrol anlamına gelmez.

Üyelik sayısı arttıkça:

- kural sayısı,
- ayar karmaşıklığı,
- hesap yükü

artar.

---

## 49. Bulanık kontrol kuralı örneği

İşaret tanımına bağlı olarak örnek bir kural:

```text
EĞER hata PB
VE hata değişimi PS
İSE kontrol değişimi PB
```

olabilir.

Başka bir kural:

```text
EĞER hata ZE
VE hata değişimi ZE
İSE kontrol değişimi ZE
```

şeklindedir.

Ancak kural tablosu evrensel değildir.

Örneğin:

```text
e = referans - ölçüm
```

ile:

```text
e = ölçüm - referans
```

işaret tanımları ters kural tablosu gerektirir.

Bu nedenle hazır bir kural tablosunu bağlamdan koparıp kullanmak hatalıdır.

---

## 50. Bulanık kontrol ve on-off kontrol

On-off kontrol:

```text
e > 0 → tam güç
e < 0 → kapalı
```

gibi keskin davranabilir.

Histerezis eklenerek hızlı aç-kapa azaltılabilir.

Bulanık kontrol ise:

```text
biraz artır
orta artır
çok artır
sabit tut
biraz azalt
```

gibi kademeli davranış üretebilir.

Bu nedenle belirsiz ve doğrusal olmayan davranışlarda daha yumuşak kontrol elde edilebilir.

---

## 51. Bulanık kontrol ve PID

PID denetleyici:

```text
u(t) =
Kp*e(t)
+ Ki*∫e(t)dt
+ Kd*de(t)/dt
```

şeklinde çalışır.

PID:

- basit,
- iyi anlaşılmış,
- yaygın,
- analiz edilebilir,
- birçok proses için yeterlidir.

Bulanık kontrol:

- uzman bilgisi kullanabilir,
- doğrusal olmayan davranışı kolay temsil edebilir,
- tam matematiksel model gerektirmeyebilir.

Ancak:

> Bulanık kontrol PID'den otomatik olarak daha iyi değildir.

PID'in iyi çalıştığı basit bir proseste bulanık denetleyici gereksiz karmaşıklık oluşturabilir.

---

## 52. Bulanık PID

İki yaklaşım birlikte kullanılabilir.

Örneğin bulanık sistem:

```text
Kp
Ki
Kd
```

kazançlarını çalışma koşuluna göre ayarlayabilir.

Akış:

```text
e, Δe
  ↓
Bulanık ayarlayıcı
  ↓
Kp, Ki, Kd
  ↓
PID
  ↓
Proses
```

Bu yaklaşım **fuzzy PID / gain scheduling** türü denetleyicilerde kullanılır.

---

## 53. Kararlılık meselesi

Kaynak ders notlarında bulanık sistemlerin dezavantajları arasında kararlılık analizinin zorluğu belirtilmektedir.

Bu değerlendirme kısmen doğrudur.

Klasik PID gibi basit doğrusal sistemlerde analitik kararlılık yöntemleri daha doğrudandır.

Bulanık denetleyicilerde ise:

- çok sayıda kural,
- doğrusal olmayan yüzey,
- parçalı davranış

analizi zorlaştırabilir.

Ancak:

> “Bulanık sistemlerin kararlılığı analiz edilemez.”

ifadesi doğru değildir.

Lyapunov tabanlı yöntemler, sektör koşulları, LMI yaklaşımları ve Takagi-Sugeno model tabanlı kararlılık analizleri kullanılabilir.

---

## 54. Performans ölçütleri

Bir bulanık denetleyicinin iyi olup olmadığı yalnızca yüzey grafiğine bakılarak belirlenmemelidir.

Kontrol sisteminde şu ölçütler incelenebilir:

- yükselme zamanı,
- yerleşme zamanı,
- overshoot,
- undershoot,
- kalıcı durum hatası,
- integral mutlak hata,
- integral karesel hata,
- kontrol enerjisi,
- bozucu reddi,
- gürültü duyarlılığı.

Örnek:

```text
IAE = ∫ |e(t)| dt
```

ve:

```text
ISE = ∫ e(t)^2 dt
```

gibi ölçüler kullanılabilir.

---

## 55. Yüzey grafiği

İki girişli tek çıkışlı FIS için:

```text
z = F(x,y)
```

ilişkisi üç boyutlu yüzey olarak çizilebilir.

Bu grafik:

- kural tabanındaki süreksizlikleri,
- aşırı dik bölgeleri,
- beklenmeyen ters davranışı,
- kullanılmayan giriş bölgelerini,
- kontrol doygunluğunu

görmek için değerlidir.

Kaynak notlarda:

```text
bütçe
çalışan sayısı
risk
```

ve:

```text
hız
kuyruk uzunluğu
yeşil ışık süresi
```

örnekleri yüzey grafikleriyle incelenmiştir.

---

## 56. Trafik ışığı örneği

Kaynak ders notlarında iki girişli bir trafik ışığı örneği bulunmaktadır.

Girdiler:

```text
Ana yol ortalama hızı: [0,60] km/h
Yan yol kuyruk uzunluğu: [0,200] m
```

Çıktı:

```text
Yeşil ışık süresi: [0,90] s
```

Dilsel değerler:

```text
Hız:
YAVAŞ
NORMAL
HIZLI

Kuyruk:
AZ
NORMAL
ÇOK

Yeşil Süresi:
KISA
ORTA
UZUN
```

Örnek kurallar:

```text
EĞER hız HIZLI
İSE yeşil süre UZUN

EĞER hız NORMAL
VE kuyruk AZ
İSE yeşil süre KISA

EĞER hız NORMAL
VE kuyruk ÇOK
İSE yeşil süre UZUN
```

Bu örneğin asıl öğretici yönü tek bir sonuç değeri değil:

> kuralların birlikte oluşturduğu giriş-çıkış yüzeyidir.

---

## 57. Bahşiş örneği

Bulanık mantık öğretiminde sık kullanılan klasik problem:

```text
servis kalitesi
yemek kalitesi
→ bahşiş
```

şeklindedir.

Örneğin:

```text
EĞER servis KÖTÜ
VEYA yemek BAYAT
İSE bahşiş AZ

EĞER servis ORTA
İSE bahşiş ORTA

EĞER servis İYİ
VEYA yemek GÜZEL
İSE bahşiş YÜKSEK
```

Bu problem:

- üyelik fonksiyonu,
- OR işlemi,
- Mamdani çıkarımı,
- durulaştırma

kavramlarını göstermek için uygundur.

---

## 58. Çok girişli sistemler

Bir FIS:

```text
1 giriş → 1 çıkış
```

olmak zorunda değildir.

Örneğin:

```text
Girdiler:
toprak nemi
toprak sıcaklığı

Çıktılar:
motor çalışma süresi
motor devri
```

şeklinde bir sistem kurulabilir.

Kaynak 2019 notlarında da sıcaklık ve nem girişlerinden motor devri ve çalışma süresi üreten bir uygulama bulunmaktadır.

---

## 59. Çok çıkışlı sistemler

Birden fazla çıktı:

```text
F(x1, x2, ..., xn)
→ y1, y2, ..., ym
```

şeklinde üretilebilir.

Ancak sistem karmaşıklaştıkça:

- kural yorumlanabilirliği,
- kural sayısı,
- çıktı etkileşimleri

zorlaşabilir.

Bazen tek büyük çok çıkışlı sistem yerine birbirini besleyen küçük FIS'ler daha yönetilebilir olur.

---

## 60. Gerçek zamanlı gömülü uygulama

Kaynak ders notlarında MATLAB-Arduino bağlantısıyla:

```text
sıcaklık
nem
```

ölçülerek:

```text
motor PWM
motor çalışma süresi
```

üretilen bir örnek bulunmaktadır.

Gerçek zamanlı bir bulanık kontrol sisteminde tipik çevrim:

```text
Sensörleri oku
↓
Fiziksel birime ölçekle
↓
FIS'i değerlendir
↓
Çıkışı güvenli sınırla
↓
Aktüatöre uygula
↓
Bir sonraki örnekleme zamanını bekle
```

şeklindedir.

Burada yalnızca FIS değil:

- sensör kalibrasyonu,
- örnekleme zamanı,
- aktüatör doygunluğu,
- güvenlik sınırları,
- iletişim hataları

da sistem tasarımının parçasıdır.

---

## 61. Örnekleme zamanı

Dijital kontrol sisteminde:

```text
Ts
```

örnekleme periyodu kritik parametredir.

Çok yavaş örnekleme:

- gecikmeli kontrol,
- salınım,
- düşük bozucu reddi

üretebilir.

Aşırı hızlı örnekleme:

- gereksiz işlem yükü,
- sensör gürültüsüne hassasiyet

oluşturabilir.

Bulanık mantık kullanılması bu klasik kontrol mühendisliği problemini ortadan kaldırmaz.

---

## 62. Doygunluk ve sınırlar

Bir FIS:

```text
motor gücü = 130%
```

gibi fiziksel olarak uygulanamaz bir çıktı üretememelidir.

Aktüatör sınırı:

```text
0 ≤ PWM ≤ 255
```

ise çıktı buna göre sınırlandırılmalıdır.

Benzer şekilde girişlerin beklenen evrensel küme dışına çıkması da ele alınmalıdır.

Örneğin:

```text
beklenen sıcaklık = [-20,50]
ölçülen sıcaklık = 75
```

durumunda sistem davranışı önceden tanımlanmalıdır.

---

## 63. FIS tasarımının pratik sırası

Bir mühendislik problemi için iyi başlangıç sırası:

```text
1. Kontrol veya tahmin hedefini belirle
2. Girişleri seç
3. Çıkışları seç
4. Fiziksel aralıkları belirle
5. Ölçekleme yapısını tanımla
6. Dilsel terimleri belirle
7. Üyelik fonksiyonlarını oluştur
8. Kural tabanını kur
9. Çıkarım operatörlerini seç
10. Durulaştırma yöntemini seç
11. Yüzeyi incele
12. Simülasyon yap
13. Sınır durumlarını test et
14. Parametreleri ayarla
15. Gerçek sistemde doğrula
```

---

## 64. Üyelik fonksiyonu sayısı nasıl seçilir?

Üyelik sayısının artırılması modeli daha ayrıntılı hale getirir.

Fakat:

```text
çok fazla üyelik fonksiyonu
→ çok fazla kural
→ fazla parametre
→ daha zor ayar
→ olası aşırı uyum
```

oluşturabilir.

Başlangıç için birçok kontrol probleminde:

```text
3
5
7
```

gibi tek sayıda ve simetrik kümeler kullanılabilir.

Ancak bu bir yasa değildir.

Verinin veya prosesin yapısı asimetrik üyelikleri gerektirebilir.

---

## 65. Örtüşme

Komşu üyelik fonksiyonlarının örtüşmesi yumuşak geçiş sağlar.

Örneğin:

```text
SOĞUK
ILIK
SICAK
```

kümeleri birbirini hiç örtmezse sistem klasik eşik mantığına yaklaşır.

Aşırı örtüşme ise çok sayıda kuralın aynı anda yüksek derecede ateşlenmesine yol açabilir.

İyi örtüşme:

> giriş uzayında pürüzsüz fakat yeterince ayırt edici geçiş üretmelidir.

---

## 66. Kapsama

Her mümkün giriş değeri için en az bir anlamlı üyelik fonksiyonu etkin olmalıdır.

Örneğin:

```text
X = [0,100]
```

fakat üyelik fonksiyonları yalnızca:

```text
[0,30]
[40,60]
[70,100]
```

aralıklarını kapsıyorsa:

```text
30-40
60-70
```

bölgelerinde hiçbir kural ateşlenmeyebilir.

Bu tasarım hatasıdır.

---

## 67. Kural tutarlılığı

Çelişen kurallar olabilir:

```text
EĞER sıcaklık SICAK
İSE fan HIZLI
```

ve:

```text
EĞER sıcaklık SICAK
İSE fan YAVAŞ
```

İki kuralın aynı bağlamda geçerli olması sistem yüzeyinde beklenmeyen davranış üretebilir.

Çelişkiler:

- uzman görüşü farkı,
- yanlış kural,
- eksik bağlam,
- gereğinden az giriş

nedeniyle oluşabilir.

Kural denetimi tasarım sürecinin parçasıdır.

---

## 68. Kural tabanı eksikliği

Her giriş kombinasyonu için kural yazmak zorunlu değildir.

Kaynak notlarda da tüm olası kombinasyonların pratikte gerekli olmayabileceği vurgulanmaktadır.

Ancak eksik kural tabanı bilinçli olmalıdır.

Şu soru sorulmalıdır:

> Sistem kural tanımlanmamış bir bölgede çalışırsa ne olacak?

Bazı FIS uygulamalarında çıktı üretilemeyebilir veya varsayılan davranış oluşabilir.

Bu nedenle çalışma uzayı test edilmelidir.


---

## 69. Bulanık sistemler öğrenebilir mi?

Klasik, elle tasarlanmış Mamdani denetleyicide:

- üyelik fonksiyonlarını insan belirler,
- kuralları uzman yazar,
- parametreler sabit kalır.

Bu anlamda sistem **kendiliğinden öğrenmez**.

Ancak buradan:

> “Bulanık mantık sistemleri öğrenemez.”

sonucu çıkarılamaz.

Modern bulanık sistemlerde:

- üyelik parametreleri,
- Sugeno sonuç katsayıları,
- kural ağırlıkları,
- bazı durumlarda kural yapısı

veriden ayarlanabilir.

Bu alanın en bilinen örneklerinden biri ANFIS'tir.

---

## 70. ANFIS

**Adaptive-Network-Based Fuzzy Inference System (ANFIS)**, Sugeno tipi bulanık çıkarım sistemini uyarlamalı ağ yapısı içinde temsil eder.

Jang'ın 1993 tarihli çalışmasında sistem:

- insan bilgisini bulanık kurallar üzerinden,
- sayısal veriyi eğitim örnekleri üzerinden

bir araya getirebilen yapı olarak sunulmuştur.

Basit iki girişli Sugeno sistemi:

```text
Kural 1:
IF x is A1 AND y is B1
THEN f1 = p1*x + q1*y + r1

Kural 2:
IF x is A2 AND y is B2
THEN f2 = p2*x + q2*y + r2
```

şeklinde olsun.

ANFIS eğitim süreci:

```text
üyelik fonksiyonlarını
+
sonuç katsayılarını
```

veriye göre ayarlar.

---

## 71. ANFIS katmanları

Klasik ANFIS açıklamasında hesap şu katmanlarla görülebilir:

```text
Giriş
↓
Üyelik dereceleri
↓
Kural ateşleme dereceleri
↓
Normalize ateşleme dereceleri
↓
Sugeno sonuçları
↓
Toplam çıktı
```

Örneğin:

```text
w1 = μA1(x) * μB1(y)
w2 = μA2(x) * μB2(y)
```

ardından:

```text
w̄1 = w1 / (w1+w2)
w̄2 = w2 / (w1+w2)
```

ve:

```text
f = w̄1*f1 + w̄2*f2
```

hesaplanabilir.

---

## 72. Nöro-bulanık sistemlerin amacı

Sinir ağlarının güçlü yönü:

```text
veriden öğrenme
```

bulanık sistemlerin güçlü yönü ise:

```text
dilsel kural yapısı ve yorumlanabilirlik
```

olarak düşünülebilir.

Nöro-bulanık yaklaşımın hedefi:

```text
öğrenebilirlik
+
kural tabanlı temsil
```

özelliklerini birleştirmektir.

Ancak parametre sayısı büyüdükçe sistemin ilk baştaki insan yorumlanabilirliği azalabilir.

Bu nedenle “bulanık = her zaman açıklanabilir” varsayımı da dikkatle kullanılmalıdır.

---

## 73. Eğitim ve aşırı uyum

Veriyle üyelik fonksiyonu ayarlamak avantajlıdır.

Fakat klasik makine öğrenmesinde olduğu gibi:

- eğitim verisine aşırı uyum,
- dağılım değişimi,
- gürültüye uyum,
- zayıf genelleme

sorunları ortaya çıkabilir.

Veri tabanlı FIS tasarımında:

```text
eğitim
doğrulama
test
```

kümelerinin ayrılması gerekir.

---

## 74. Güncel MATLAB notu: ANFIS

2019 kaynak notlarından sonra MATLAB Fuzzy Logic Toolbox API'si önemli ölçüde değişmiştir.

2026 itibarıyla MathWorks:

```text
anfis
```

fonksiyonunu **“not recommended”** olarak işaretlemekte ve yeni geliştirmelerde:

```text
tunefis(... Method="anfis")
```

yaklaşımını önermektedir.

Eski kodu yeni projeye doğrudan taşımak yerine güncel API kontrol edilmelidir.

---

## 75. Bulanık C-Ortalamalar

**Fuzzy C-Means (FCM)**, klasik k-means yaklaşımının bulanık üyelik kullanan kümeleme biçimidir.

K-means'te bir örnek:

```text
yalnızca bir kümeye
```

atanır.

FCM'de aynı örnek:

```text
Küme 1 → 0.7
Küme 2 → 0.3
```

üyeliğine sahip olabilir.

Bu yaklaşım sınırları doğal olarak örtüşen veri kümelerinde yararlıdır.

FCM'nin temel fikirleri Dunn'ın 1973 çalışmasına, yaygın algoritmik biçimi ise Bezdek ve çalışma arkadaşlarının çalışmalarına dayanır.

---

## 76. FCM amaç fonksiyonu

FCM'nin klasik amaç fonksiyonu:

```text
Jm =
Σ_i Σ_j uij^m ||xi - cj||²
```

şeklindedir.

Burada:

```text
uij → i. örneğin j. kümeye üyeliği
m   → bulanıklık katsayısı
cj  → küme merkezi
```

olarak düşünülebilir.

Klasik k-means'ten farklı olarak:

```text
Σ_j uij = 1
```

olmak üzere üyelikler derecelidir.

---

## 77. FCM nerede kullanılabilir?

- görüntü segmentasyonu,
- sensör verisi gruplama,
- örüntü tanıma,
- müşteri segmentasyonu,
- arıza durumlarını gruplama,
- FIS için üyelik fonksiyonu başlangıcı oluşturma.

Ancak FCM:

- küme sayısını baştan ister,
- aykırı değerlere duyarlı olabilir,
- başlangıç koşullarından etkilenebilir.

---

## 78. Bulanık karar verme

Bellman ve Zadeh'in 1970 tarihli çalışması, hedeflerin ve kısıtların kesin sınırlar yerine bulanık kümelerle ifade edildiği karar problemlerini ele almıştır.

Örneğin:

```text
maliyet düşük olsun
performans yüksek olsun
risk kabul edilebilir olsun
```

ifadelerinin her biri bir üyelik fonksiyonuyla modellenebilir.

Bir karar alternatifinin toplam uygunluğu:

```text
hedefler
∩
kısıtlar
```

üzerinden değerlendirilebilir.

---

## 79. Çok ölçütlü bulanık karar verme

Gerçek karar problemlerinde şu tür kavramlar vardır:

```text
çok önemli
orta derecede önemli
yaklaşık iyi
düşük riskli
yüksek maliyetli
```

Bunların kesin sayılara çevrilmesi her zaman kolay değildir.

Bulanık çok ölçütlü karar verme yöntemleri:

- Fuzzy AHP,
- Fuzzy TOPSIS,
- bulanık ağırlıklı toplam,
- bulanık uzlaşma yöntemleri

gibi yaklaşımlarla kullanılabilir.

Ancak yöntem adının başına “fuzzy” eklenmesi kararın nesnel olduğu anlamına gelmez.

Üyelik fonksiyonu ve uzman değerlendirmeleri hâlâ varsayımlar içerir.

---

## 80. Tip-1 ve Tip-2 bulanık kümeler

Bu notun şimdiye kadarki bölümleri **Tip-1 bulanık kümeleri** anlatmaktadır.

Tip-1 sistemde:

```text
x → tek bir üyelik derecesi
```

atanır.

Örneğin:

```text
μSICAK(27) = 0.65
```

Fakat şu soru ortaya çıkabilir:

> `0.65` değerinin kendisinden ne kadar eminiz?

**Tip-2 bulanık kümeler**, üyelik derecesindeki belirsizliği de modellemek için geliştirilmiştir.

---

## 81. Aralık Tip-2 bulanık küme

Aralık Tip-2 sistemde bir giriş için üyelik tek sayı yerine aralık olabilir.

Örneğin:

```text
μSICAK(27) ∈ [0.55, 0.75]
```

Bu aralık:

- farklı uzman görüşleri,
- sensör belirsizliği,
- değişen çalışma koşulları,
- üyelik fonksiyonu belirsizliği

gibi durumları temsil edebilir.

Üst ve alt üyelik fonksiyonu arasındaki bölge:

```text
Footprint of Uncertainty — FOU
```

olarak adlandırılır.

---

## 82. Tip-2 sistemlerin bedeli

Tip-2 bulanık sistemler daha fazla belirsizlik modelleyebilir.

Fakat:

- hesaplama daha karmaşıktır,
- tip indirgeme gerekir,
- parametre sayısı artar,
- ayar daha zordur.

Dolayısıyla Tip-2 sistem:

> Tip-1 sistemden otomatik olarak daha iyidir.

denemez.

Ek belirsizliği modellemenin performans kazancı sağlaması gerekir.

---

## 83. Type reduction

Tip-2 çıkarım sonucu doğrudan kesin sayıya çevrilmeden önce genellikle **type reduction** aşamasından geçer.

Yaygın yöntemler arasında:

- Karnik-Mendel,
- Enhanced Karnik-Mendel,
- IASC,
- EIASC

bulunur.

Güncel MATLAB Fuzzy Logic Toolbox aralık Tip-2 Mamdani ve Sugeno sistemlerini desteklemektedir.

---

## 84. Bulanık mantık ve yapay zekâ

Bulanık mantık yapay zekânın tarihsel sembolik ve yaklaşık akıl yürütme araçlarından biridir.

Özellikle:

```text
uzman bilgisi
+
dilsel kurallar
+
sayısal ölçümler
```

arasında köprü kurar.

Modern yapay zekâda bulanık mantık:

- karar desteği,
- kontrol,
- açıklanabilir model,
- hibrit sinir ağı sistemleri,
- belirsiz sınıflandırma,
- veri kümeleri arasındaki yumuşak sınırlar

gibi alanlarda kullanılabilir.

---

## 85. Bulanık mantık ile makine öğrenmesi farkı

Klasik bulanık sistem:

```text
insan tanımlı üyelikler
+
insan tanımlı kurallar
```

üzerinden davranabilir.

Makine öğrenmesi ise çoğunlukla:

```text
veri
+
kayıp fonksiyonu
+
optimizasyon
```

üzerinden model parametrelerini öğrenir.

Bulanık sistem:

- çok az veriyle kurulabilir,
- uzman bilgisi kullanabilir,
- yapısal olarak yorumlanabilir olabilir.

Makine öğrenmesi:

- yüksek boyutlu örüntülerde güçlüdür,
- insanın kural yazmasının zor olduğu ilişkileri öğrenebilir.

Hibrit sistemler iki yaklaşımı birleştirebilir.

---

## 86. Bulanık mantık ile olasılıksal modeller

Bulanık ve olasılıksal modeller rakip olmak zorunda değildir.

Bir sistemde aynı anda:

```text
ölçüm belirsizliği → olasılıksal
kavramsal belirsizlik → bulanık
```

olabilir.

Örneğin sensör ölçüm hatası:

```text
T ~ Normal(25, 0.5²)
```

ile modellenirken:

```text
“sıcak” kavramı
```

bulanık üyelik fonksiyonuyla temsil edilebilir.

Bu iki belirsizlik türünü ayırmak modelleme açısından önemlidir.

---

## 87. Bulanık mantık ne zaman uygundur?

Şu koşullar güçlü işarettir:

- uzman kuralları sözel ifade edebiliyor,
- sistem doğrusal değil,
- kesin eşikler yapay davranış üretiyor,
- tam fiziksel model kurmak zor,
- yorumlanabilir kontrol yüzeyi isteniyor,
- düşük hesap yüküyle yaklaşık çözüm gerekli.

---

## 88. Ne zaman uygun olmayabilir?

Aşağıdaki durumlarda başka yöntem daha iyi olabilir:

- sistemin doğru ve basit matematiksel modeli mevcutsa,
- güçlü analitik kontrol yöntemi kolay uygulanabiliyorsa,
- milyonlarca boyutlu karmaşık algı problemi varsa,
- kuralların yazılması imkânsızsa,
- üyelik fonksiyonları tamamen keyfî kalıyorsa,
- güvenlik kritik kanıt için biçimsel garanti gerekiyorsa.

Örneğin görüntüde nesne tanıma problemi için elle binlerce bulanık kural yazmak modern derin öğrenmeye göre çoğu zaman uygun değildir.

---

## 89. Avantajlar

Bulanık sistemlerin güçlü tarafları:

1. Keskin olmayan kavramları doğal biçimde ifade eder.
2. Uzman bilgisini doğrudan kural tabanına aktarabilir.
3. Doğrusal olmayan giriş-çıkış ilişkileri oluşturabilir.
4. Karmaşık sistemlerde tam matematiksel model gereksinimini azaltabilir.
5. Küçük sistemlerde düşük hesap yüküyle çalışabilir.
6. Kurallar incelenebilir olduğu için yorumlanabilirlik sağlayabilir.
7. Sensör verisi ile sözel bilgiyi aynı sistemde birleştirebilir.
8. Kontrol, tahmin, karar ve sınıflandırma için kullanılabilir.

---

## 90. Sınırlamalar

1. Üyelik fonksiyonlarının seçimi öznel olabilir.
2. Kural tabanı uzman kalitesine bağlı olabilir.
3. Giriş sayısı arttıkça kural patlaması oluşabilir.
4. Kararlılık ve performans kanıtı klasik doğrusal denetleyiciye göre daha zor olabilir.
5. Yanlış ölçekleme iyi görünen kuralları bozabilir.
6. Yorumlanabilirlik çok büyük kural tabanlarında kaybolabilir.
7. Veriyle ayarlanan sistem aşırı uyum gösterebilir.
8. Bulanık üyeliklerin fiziksel anlamı yanlış yorumlanabilir.
9. Olasılık ve üyelik derecesi karıştırılabilir.

---

## 91. “Matematiksel modele ihtiyaç duymaz” ifadesi

Bu ifade kaynak ders notlarında avantaj olarak yer almaktadır; ancak dikkatle okunmalıdır.

Daha doğru ifade:

> Bulanık kontrol, bazı problemlerde ayrıntılı bir analitik proses modeli olmadan, uzman kurallarıyla kontrol tasarımını mümkün kılabilir.

Bu:

> Matematiksel düşünmeye veya sistem modeline hiç gerek yoktur.

anlamına gelmez.

Şunlar hâlâ bilinmelidir:

- giriş aralıkları,
- fiziksel sınırlar,
- dinamik davranış,
- örnekleme,
- gecikmeler,
- kararlılık,
- güvenlik limitleri.

---

## 92. İnsan düşünmesine benzerlik

Bulanık mantık:

```text
az
orta
çok
yaklaşık
sıcak
yavaş
yüksek risk
```

gibi ifadeleri işlemeye uygundur.

Bu yönüyle insanın sözel karar kurallarına benzer bir temsil sağlar.

Ancak:

> Bulanık mantık insan beyninin gerçek çalışma modeli olarak kanıtlanmıştır.

denemez.

Bu bir mühendislik modelidir.

İnsan bilişi:

- olasılıksal akıl yürütme,
- sembolik işlem,
- öğrenme,
- hafıza,
- algı,
- sezgi

gibi çok daha geniş süreçler içerir.

---

## 93. Bulanık mantık ve açıklanabilirlik

Küçük bir sistemde:

```text
EĞER sıcaklık yüksek
VE nem yüksek
İSE fan çok hızlı
```

kuralı oldukça anlaşılırdır.

Bu nedenle bulanık sistemler açıklanabilir yapay zekâ için yararlı olabilir.

Fakat yüzlerce giriş ve binlerce kural içeren sistemde açıklanabilirlik azalır.

Açıklanabilirlik:

```text
kural sayısı
üyelik fonksiyonlarının anlamlılığı
çıktı yüzeyinin sadeliği
```

ile birlikte değerlendirilmelidir.

---

## 94. Kritik sistemlerde bulanık kontrol

Bulanık denetleyiciler:

- otomotiv,
- endüstriyel kontrol,
- robotik,
- enerji,
- ulaşım

gibi alanlarda kullanılabilir.

Kritik sistemde yalnızca simülasyonda iyi çalışması yeterli değildir.

Şunlar incelenmelidir:

```text
normal çalışma
sınır koşulu
sensör arızası
aktüatör doygunluğu
gürültü
gecikme
haberleşme kaybı
beklenmeyen giriş
```

Bulanık mantık güvenlik mühendisliğinin yerine geçmez.

---

## 95. Doğrulama

Bulanık sistem için sistematik doğrulama yapılmalıdır.

### Kapsama testi

Tüm giriş uzayında çıktı var mı?

### Monotonluk testi

Fiziksel olarak artması gereken yerde çıktı azalıyor mu?

### Sınır testi

Üyelik sınırlarında ani davranış var mı?

### Kural testi

Her kural beklenen bölgede ateşleniyor mu?

### Yüzey testi

Beklenmeyen çıkıntı veya çukur var mı?

### Zaman alanı testi

Kontrol sistemi gerçek dinamikte kararlı mı?

---

## 96. Duyarlılık analizi

Üyelik fonksiyonunun bir parametresini küçük miktarda değiştirin:

```text
a → a + δ
```

ve sistem çıktısındaki değişimi ölçün.

Aynı işlem:

- kural ağırlıkları,
- ölçekleme kazançları,
- durulaştırma yöntemi

için yapılabilir.

Çok küçük parametre değişikliğinde çok büyük çıktı değişiyorsa sistem kırılgan olabilir.

---

## 97. Monte Carlo ve senaryo testi

Girişler gerçek sistemde gürültülü ise rastgele örneklemelerle test yapılabilir.

Örneğin:

```text
T = 25 ± sensör gürültüsü
Nem = 60 ± sensör gürültüsü
```

binlerce örnek için FIS çalıştırılır.

Şunlar gözlenebilir:

- çıktı dağılımı,
- sınır aşımı,
- kontrol salınımı,
- en kötü durum.

Bu yaklaşım bulanık mantığın kendisi olasılık olmasa da sistem doğrulamasında olasılıksal test kullanımına örnektir.

---

## 98. Güncel MATLAB Fuzzy Logic Toolbox

2019 ders notlarında şu eski API ailesi kullanılmaktadır:

```text
newfis
addvar
addmf
addrule
FIS structure
```

Bu kodlar tarihsel öğrenme açısından değerlidir; ancak yeni MATLAB sürümlerinde doğrudan esas alınmamalıdır.

Güncel nesne tabanlı yapı:

```text
mamfis
sugfis
mamfistype2
sugfistype2
addInput
addOutput
addMF
addRule
evalfis
```

fonksiyonlarını kullanır.

MathWorks belgelerine göre R2024b itibarıyla `evalfis` gibi ana işlevlerde eski FIS structure desteği kaldırılmıştır.

---

## 99. Güncel MATLAB ile basit Mamdani örneği

Aşağıdaki yapı güncel nesne tabanlı API'yi gösterir:

```matlab
fis = mamfis(Name="tip");

fis = addInput(fis,[0 10],Name="service");
fis = addMF(fis,"service","trapmf",[0 0 2 4],Name="poor");
fis = addMF(fis,"service","trimf",[2 5 8],Name="average");
fis = addMF(fis,"service","trapmf",[6 8 10 10],Name="good");

fis = addInput(fis,[0 10],Name="food");
fis = addMF(fis,"food","trapmf",[0 0 2 4],Name="bad");
fis = addMF(fis,"food","trapmf",[6 8 10 10],Name="good");

fis = addOutput(fis,[0 30],Name="tip");
fis = addMF(fis,"tip","trimf",[0 5 10],Name="low");
fis = addMF(fis,"tip","trimf",[10 15 20],Name="medium");
fis = addMF(fis,"tip","trimf",[20 25 30],Name="high");

rules = [
    "If service is poor or food is bad then tip is low"
    "If service is average then tip is medium"
    "If service is good or food is good then tip is high"
];

fis = addRule(fis,rules);

result = evalfis(fis,[8 7]);
```

Bu örneğin amacı MATLAB öğretmek değil, 2019'daki yapının güncel API'deki karşılığını göstermektir.

---

## 100. MATLAB'de FIS davranışını inceleme

Güncel araçlarda:

```matlab
showrule(fis)
```

kuralları,

```matlab
plotmf(fis,"input",1)
```

üyelik fonksiyonlarını,

```matlab
gensurf(fis)
```

giriş-çıkış yüzeyini incelemek için kullanılabilir.

`evalfis` yalnızca kesin çıktıyı değil, seçeneklere göre ara çıkarım sonuçlarını da sağlayabilir.

Bu özellik hata ayıklamada değerlidir.

---

## 101. Güncel dağıtım olanakları

Güncel Fuzzy Logic Toolbox:

- MATLAB,
- Simulink,
- C/C++ kod üretimi,
- IEC 61131-3 Structured Text,
- Tip-1 FIS,
- Aralık Tip-2 FIS,
- FIS ağaçları

gibi kullanım ve dağıtım olanakları sağlar.

Bu, bulanık mantığın yalnızca eğitim amaçlı MATLAB arayüzüyle sınırlı olmadığını gösterir.

---

## 102. Saf yazılımla bulanık sistem

Bulanık çıkarım sistemi için özel bir kütüphane zorunlu değildir.

Basit bir Mamdani sistem şu bileşenlerle doğrudan yazılabilir:

```text
membership(x)
min / max
rule evaluation
aggregation
centroid
```

Örneğin bir üçgen üyelik fonksiyonu Python benzeri sözde kodla:

```python
def trimf(x, a, b, c):
    if x <= a or x >= c:
        return 0.0
    if x <= b:
        return (x - a) / (b - a)
    return (c - x) / (c - b)
```

şeklinde uygulanabilir.

Üretimde:

- sıfıra bölme,
- eşit parametreler,
- sınır davranışı,
- kayan nokta hassasiyeti

gibi ayrıntılar ayrıca ele alınmalıdır.

---

## 103. Hesap maliyeti

Küçük Mamdani sistemi gömülü işlemci üzerinde oldukça ucuz olabilir.

Maliyet yaklaşık olarak:

```text
üyelik fonksiyonu sayısı
+
ateşlenen kural sayısı
+
çıktı örnekleme çözünürlüğü
```

ile artar.

Sugeno sistemi özellikle sonucu ağırlıklı ortalamayla hesapladığı için birçok gerçek zamanlı uygulamada daha düşük maliyetli olabilir.

---

## 104. Sabit nokta uygulaması

Kaynakları sınırlı mikrodenetleyicide kayan nokta yerine sabit nokta aritmetiği kullanılabilir.

Örneğin üyelik:

```text
0.0 ... 1.0
```

yerine:

```text
0 ... 255
```

aralığında temsil edilebilir.

Bu durumda:

```text
min
max
çarpım
ağırlıklı ortalama
```

işlemleri ölçeklendirilmiş tamsayılarla uygulanabilir.

Ancak taşma ve kuantalama hataları analiz edilmelidir.

---

## 105. Tasarım hataları

Sık görülen hatalar:

1. Olasılık ile üyelik derecesini karıştırmak.
2. Evrensel kümeyi fiziksel aralığa göre seçmemek.
3. Üyelik fonksiyonları arasında boşluk bırakmak.
4. Gereğinden fazla üyelik fonksiyonu kullanmak.
5. Kural tabanındaki işaret yönünü ters kurmak.
6. Yalnızca tek örnekte sistemi değerlendirmek.
7. Yüzey grafiğini incelememek.
8. Sensör gürültüsünü dikkate almamak.
9. Aktüatör sınırlarını FIS'e bırakmak.
10. “Bulanık sistem insan gibi düşünür” varsayımı yapmak.
11. Eski MATLAB API'sini yeni sürümlerde doğrudan kullanmak.
12. Öğrenilmiş FIS'i doğrulama verisi olmadan kabul etmek.

---

## 106. Bulanık mantık için pratik mühendislik modeli

Bir problem için şu akış kullanılabilir:

```text
Problem
↓
Kesin eşik gerçekten sorun mu?
↓
Dilsel değişkenler tanımlanabilir mi?
↓
Giriş ve çıkışları seç
↓
Evrensel kümeleri belirle
↓
Üyelik fonksiyonlarını kur
↓
Uzman / veri ile kuralları oluştur
↓
Mamdani / Sugeno seç
↓
Çıkarım operatörlerini belirle
↓
Yüzey analizi
↓
Simülasyon
↓
Performans ölçümü
↓
Duyarlılık ve sınır testleri
↓
Gerçek sistem doğrulaması
```

---

## 107. Uygulama çalışması 1 — sıcaklık üyelikleri

Aralık:

```text
0-50 °C
```

olmak üzere:

```text
SOĞUK
ILIK
SICAK
```

üç üyelik fonksiyonu tasarlayın.

Şunları hesaplayın:

```text
10
20
25
30
40 °C
```

değerlerinin her kümeye üyelik derecelerini.

Ardından üyeliklerin toplamının neden zorunlu olarak `1` olmak zorunda olmadığını açıklayın.

---

## 108. Uygulama çalışması 2 — olasılık farkı

Şu iki ifadeyi matematiksel olarak ayırın:

```text
Yarın yağmur yağma olasılığı 0.7.
```

```text
Bugünkü hava “yağmurlu” kavramına 0.7 üyedir.
```

İki `0.7` değerinin neden aynı anlamı taşımadığını açıklayın.

---

## 109. Uygulama çalışması 3 — Mamdani

Girdiler:

```text
Sıcaklık: [0,50]
Nem: [0,100]
```

Çıktı:

```text
Fan: [0,100]
```

üçer dilsel değer oluşturun.

En az dokuz kural yazın.

Ardından:

```text
T = 32 °C
Nem = 75%
```

için:

1. bulanıklaştırma,
2. kural ateşleme,
3. implication,
4. aggregation,
5. centroid

aşamalarını elle hesaplayın.

---

## 110. Uygulama çalışması 4 — Sugeno

Aynı problemi sıfırıncı derece Sugeno sistemine dönüştürün.

Çıkış sabitleri:

```text
YAVAŞ = 20
ORTA  = 50
HIZLI = 90
```

olarak verilsin.

Mamdani ve Sugeno sonuçlarını karşılaştırın.

---

## 111. Uygulama çalışması 5 — kontrol

Bir DC motor hız kontrolü için:

```text
e(k)
Δe(k)
```

girişlerini,

```text
ΔPWM
```

çıkışını kullanın.

Beş üyelik fonksiyonu:

```text
NB
NS
ZE
PS
PB
```

tanımlayın.

Kural tablosunu fiziksel işaret tanımınıza göre oluşturun.

Daha sonra step response üzerinde:

- overshoot,
- yerleşme zamanı,
- kalıcı hata

ölçün.

---

## 112. Uygulama çalışması 6 — PID karşılaştırması

Aynı proses için:

1. PID,
2. Mamdani bulanık kontrol,
3. bulanık ayarlı PID

tasarlayın.

Aynı bozucu altında:

```text
IAE
ISE
overshoot
settling time
```

ölçülerini karşılaştırın.

Sonucu “fuzzy daha iyi” varsayımıyla değil ölçümle verin.

---

## 113. Uygulama çalışması 7 — risk modeli

Girdiler:

```text
Bütçe
Personel
Takvim baskısı
```

Çıktı:

```text
Proje riski
```

olsun.

Uzman kurallarıyla bir Mamdani sistem kurun.

Sonra aynı veri kümesiyle Sugeno sistemi oluşturun.

Şunları karşılaştırın:

- yorumlanabilirlik,
- hata,
- hesaplama süresi,
- kural sayısı.

---

## 114. Uygulama çalışması 8 — FCM

İki boyutlu sentetik veri üretin.

Klasik k-means ve Fuzzy C-Means uygulayın.

Kümelerin sınırındaki örnekler için:

```text
k-means etiketi
FCM üyelikleri
```

sonuçlarını karşılaştırın.

---

## 115. Uygulama çalışması 9 — ANFIS

Doğrusal olmayan:

```text
y = sin(x1) + 0.5*x2²
```

gibi bir fonksiyondan veri üretin.

Sugeno FIS'i veriyle ayarlayın.

Eğitim ve doğrulama hatalarını ayrı izleyin.

Üyelik fonksiyonu sayısı artırıldığında:

- eğitim hatası,
- doğrulama hatası,
- kural sayısı

nasıl değişiyor inceleyin.

---

## 116. Uygulama çalışması 10 — Tip-2

Aynı sıcaklık terimi için üç uzman farklı sınırlar versin.

Örneğin “SICAK” başlangıcı:

```text
Uzman A → 25 °C
Uzman B → 27 °C
Uzman C → 29 °C
```

Bu belirsizliği:

1. tek Tip-1 üyelik fonksiyonuyla,
2. Aralık Tip-2 üyelik fonksiyonuyla

modelleyin.

İki sistemin kontrol çıktısını sensör gürültüsü altında karşılaştırın.

---

## 117. Kısa başvuru özeti

Bir bulanık sistem tasarlarken şu soruları sorun:

```text
1. Bulanıklık gerçekten problemde var mı?
2. Üyelik derecesini olasılıkla karıştırıyor muyum?
3. Evrensel kümeler fiziksel olarak doğru mu?
4. Dilsel terimler anlamlı mı?
5. Üyelik fonksiyonları tüm çalışma alanını kapsıyor mu?
6. Örtüşme yeterli mi?
7. Kural tabanı tutarlı mı?
8. Mamdani mi Sugeno mu daha uygun?
9. AND/OR/implication/aggregation seçimleri belli mi?
10. Durulaştırma yöntemi uygun mu?
11. Yüzey fiziksel beklentiyle uyumlu mu?
12. Sınır durumları test edildi mi?
13. Gürültü ve sensör hatası değerlendirildi mi?
14. Performans sayısal olarak ölçüldü mü?
15. Gerçek sistemde güvenlik sınırları FIS dışında da uygulanıyor mu?
```

---

## 118. Sonuç

Bulanık mantığın özü:

```text
keskin sınır
yerine
dereceli üyelik
```

kullanmaktır.

Fakat gerçek bir bulanık sistem yalnızca `0` ile `1` arasında sayı vermekten ibaret değildir.

Tam mühendislik zinciri:

```text
Kavramsal belirsizlik
↓
Dilsel değişken
↓
Üyelik fonksiyonu
↓
Bulanıklaştırma
↓
EĞER-İSE kuralları
↓
Çıkarım
↓
Birleştirme
↓
Durulaştırma
↓
Kesin çıktı
↓
Doğrulama
```

şeklindedir.

Bulanık mantığın tarihsel değeri, matematiksel olarak kesin olmayan kavramları hesaplanabilir hale getirmesidir.

Mühendislik değeri ise özellikle:

- uzman bilgisi,
- doğrusal olmayan davranış,
- yumuşak geçiş,
- yaklaşık modelleme

gerektiren problemlerde ortaya çıkar.

Ancak üyelik fonksiyonları ve kurallar yalnızca sezgiyle oluşturulup doğrulanmadan kullanılırsa, bulanık sistem “insana yakın” görünmesine rağmen kötü bir denetleyici olabilir.

Bu nedenle iyi bulanık mantık uygulaması:

> **bulanıklığı kabul eder; tasarımı bulanık bırakmaz.**

---

## Kaynakça

İlk yayın tarihinden sonra yayımlanan kaynaklar, metnin Eylül 2026 güncellemesinde teknik doğrulama ve güncel araç/standart bilgisini tamamlamak için kullanılmıştır.

### Temel çalışmalar

1. **Zadeh, L. A.** “Fuzzy Sets.” *Information and Control*, 8(3), 338-353, 1965.  
   DOI: https://doi.org/10.1016/S0019-9958(65)90241-X

2. **Bellman, R. E.; Zadeh, L. A.** “Decision-Making in a Fuzzy Environment.” *Management Science*, 17(4), B141-B164, 1970.  
   DOI: https://doi.org/10.1287/mnsc.17.4.B141

3. **Zadeh, L. A.** “The Concept of a Linguistic Variable and Its Application to Approximate Reasoning—I.” *Information Sciences*, 8(3), 199-249, 1975.  
   DOI: https://doi.org/10.1016/0020-0255(75)90036-5

4. **Mamdani, E. H.; Assilian, S.** “An Experiment in Linguistic Synthesis with a Fuzzy Logic Controller.” *International Journal of Man-Machine Studies*, 7(1), 1-13, 1975.  
   DOI: https://doi.org/10.1016/S0020-7373(75)80002-2

5. **Takagi, T.; Sugeno, M.** “Fuzzy Identification of Systems and Its Applications to Modeling and Control.” *IEEE Transactions on Systems, Man, and Cybernetics*, SMC-15(1), 116-132, 1985.  
   DOI: https://doi.org/10.1109/TSMC.1985.6313399

6. **Jang, J.-S. R.** “ANFIS: Adaptive-Network-Based Fuzzy Inference System.” *IEEE Transactions on Systems, Man, and Cybernetics*, 23(3), 665-685, 1993.  
   DOI: https://doi.org/10.1109/21.256541

7. **Dunn, J. C.** “A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters.” *Journal of Cybernetics*, 3(3), 32-57, 1973.  
   DOI: https://doi.org/10.1080/01969727308546046

8. **Bezdek, J. C.; Ehrlich, R.; Full, W.** “FCM: The Fuzzy C-Means Clustering Algorithm.” *Computers & Geosciences*, 10(2-3), 191-203, 1984.  
   DOI: https://doi.org/10.1016/0098-3004(84)90020-7

9. **Mendel, J. M.; John, R. I. B.** “Type-2 Fuzzy Sets Made Simple.” *IEEE Transactions on Fuzzy Systems*, 10(2), 117-127, 2002.  
   DOI: https://doi.org/10.1109/91.995115

### Kitaplar

10. **Ross, T. J.** *Fuzzy Logic with Engineering Applications.* Wiley.

11. **Klir, G. J.; Yuan, B.** *Fuzzy Sets and Fuzzy Logic: Theory and Applications.* Prentice Hall.

12. **Jang, J.-S. R.; Sun, C.-T.; Mizutani, E.** *Neuro-Fuzzy and Soft Computing.* Prentice Hall.

13. **Zimmermann, H.-J.** *Fuzzy Set Theory—and Its Applications.* Springer.

### Güncel teknik belgeler

14. **MathWorks.** *Fuzzy Logic Toolbox Documentation.*  
    https://www.mathworks.com/help/fuzzy/

15. **MathWorks.** `mamfis` — Mamdani fuzzy inference system.  
    https://www.mathworks.com/help/fuzzy/mamfis.html

16. **MathWorks.** `evalfis` — Evaluate fuzzy inference system.  
    https://www.mathworks.com/help/fuzzy/mamfis.evalfis.html

17. **MathWorks.** `mamfistype2` — Interval type-2 Mamdani fuzzy inference system.  
    https://www.mathworks.com/help/fuzzy/mamfistype2.html

18. **MathWorks.** `anfis` / `tunefis` migration guidance, R2026a documentation.  
    https://www.mathworks.com/help/fuzzy/anfis.html

### Kaynak ders içeriği

19. **AKÜ Teknoloji Fakültesi, Mekatronik Mühendisliği — Bulanık Mantık ile Kontrol ders içerikleri, 2019.**  
    2019 tarihli ders içerikleri; Mamdani/Sugeno örnekleri, sıcaklık kontrolü, trafik ışığı, çok çıkışlı FIS ve MATLAB-Arduino uygulamaları için tarihsel ders kaynağıdır. Yazılım arayüzlerine ilişkin güncel ayrıntılar Eylül 2026 belgeleriyle ayrıca doğrulanmıştır.

## Bu Çalışmaya Atıf

Köker, M. A. (2022). Bulanık Mantık: Kuram, Çıkarım, Kontrol ve Uygulamalar. alikoker.com.tr. https://alikoker.com.tr/bulanik-mantik

- BibTeX: https://alikoker.com.tr/bulanik-mantik.bib
- RIS: https://alikoker.com.tr/bulanik-mantik.ris
- CSL-JSON: https://alikoker.com.tr/bulanik-mantik.csl.json