SISTEM LOGIKA FUZZY

1. INSTALASI SOFWARE
Sistem yang digunakan ialah Python 2.7 dan paket yang dibutuhkan yaitu:
1. numpy
2. scipy
3. matplotlib
4. skfuzzy
Masukkan perintah berikut di baris perintah untuk menginstal perangkat lunak numpy,
scipy, dan matplotlib.
sudo apt-get update
sudo apt-get install python-numpy
Catatan : numpy mungkin sudah diinstal, jadi semua yang Kita lihat ketika perintah
ini dijalankan adalah bahwa versi terbaru diinstal.

sudo apt-get install python-scipy

sudo apt-get install python-matplotlib
Kita perlu mengkloning perangkat lunak dari situs web GitHub; namun, Kita
memerlukan aplikasi Git untuk melakukan ini. Jadi instal Git dengan memasukkan
perintah ini:
sudo apt-get install git
Setelah Git diinstal, Kita perlu mengkloning perangkat lunak dengan menggunakan
perintah ini:
sudo git clone https://github.com/scikit-fuzzy/scikit-fuzzy.git
Operasi kloning secara otomatis membuka ritsleting semua perangkat lunak skfuzzy
ke subdirektori baru bernama scikit-fuzzy, yang terletak di direktori home. Masukkan
perintah berikut untuk mengatur skfuzzy.
cd scikit-fuzzy
sudo python setup.py install
2. FLS Dasar

Rules

Crisp Inference Crisp

Fuzzifier Defuzzifier
Inputs Fuzzy Input Set Engine Fuzzy Output Set Outputs
 Komponen FLS utama :
 Fuzzifier : Proses di mana set data input dikumpulkan dan dikonversi ke set
fuzzy menggunakan variabel linguistik fuzzy di sebut fungsi keanggotaan.
 Aturan : Pengetahuan ahli dikumpulkan dan dikodifikasikan ke dalam mesin
inferensi.
 Mesin inferensi : Inferensi dihasilkan berdasarkan seperangkat aturan yang
diterapkan pada set fuzzy input.
 Defuzzifier : Keluaran yang dibuat berdasarkan keluaran himpunan fuzzy dari
mesin inferensi.

TABEL ALGORITMA FL
Langkah Nama Deskripsi
1 Inisialisasi Definisikan variabel dan istilah linguistic
2 Inisialisasi Membuat fungsi keanggotaan
3 Inisialisasi Membuat set aturan
Ubah data input menjadi set fuzzy menggunakan fungsi
4 Fuzzifikasi
keanggotaan
Mengevaluasi set fuzzy sesuai dengan aturan yang
5 Kesimpulan
ditetapkan
6 Pengumpulan Gabungkan hasil dari setiap evaluasi aturan
7 Defuzzifikasi Konversi fuzzy set ke nilai output yang memiliki nilai

3. Inisialisasi: Definisikan Variabel Linguistik Dan Ketentuan/Aturan

Program 5-1: Menggunakan FL untuk Menghitung Tip
Kita pertimbangkan dua input utama: kualitas makanan dan kualitas layanan. Mungkin
cara termudah dan paling jelas untuk mengklasifikasikan kualitas makanan adalah
dengan menggunakan ketentuan sebagai berikut :
 Sangat enak
 enak
 Buruk

Demikian juga, mengklasifikasikan kualitas layanan menggunakan istilah-istilah ini:

 Luar biasa
 Cocok/pantas
 Buruk

Jumlah tip juga tunduk pada istilah linguistik fuzzy. Ini adalah istilah yang digunakan
untuk jumlah tip:
 Rendah
 Sedang
  Tinggi

Harus ada skala numerik bagi pengguna untuk menilai kualitas layanan dan kualitas
makanan. Skala 0 hingga 10 baik untuk kebanyakan orang, di mana 0 adalah yang
terburuk dan 10 adalah yang terbaik. Output tip juga harus memiliki skala numerik.
Ini diatur pada 0 hingga 26 untuk mewakili skala yang sesuai untuk persentase tip
normal. Semua skala numerik ini mewakili input atau output renyah atau tidak fuzzy
untuk fungsi keanggotaan, yang akan dibahas pada bagian berikutnya.
4. Inisialisasi : Membuat Fungsi Keanggotaan
Fungsi keanggotaan digunakan dalam langkah fuzzifikasi FL dan defuzzifikasi.
Fungsi-fungsi ini memetakan nilai input non-fuzzy ke variabel linguistik fuzzy untuk
fuzzifikasi, dan memetakan variabel fuzzy ke nilai output non-fuzzy untuk
defuzzifikasi. Pada dasarnya, fungsi keanggotaan mengkuantifikasi istilah linguistik.

Gambar 1. Fungsi keanggotaan kualitas makanan

Gambar 2. Fungsi keanggotaan kualitas layanan.

Gambar 3. Fungsi Jumlah Keanggotaan

5. Visualisasi Fungsi Keanggotaan
Program Python utama juga berisi kode yang ditunjukkan pada Gambar. yang
seharusnya sangat membantu dalam memahami fungsi keanggotaan. Segmen kode
berikut menghasilkan angka-angka ini ketika keseluruhan program dijalankan.
# Visualize the membership functions
fig, (ax0, ax1, ax2) = plt.subplots(nrows=3, figsize=(8, 9))
ax0.plot(x_qual, qual_lo, 'b', linewidth=1.5, label='Bad')
ax0.plot(x_qual, qual_md, 'g', linewidth=1.5, label='Decent')
ax0.plot(x_qual, qual_hi, 'r', linewidth=1.5, label='Great')
ax0.set_title('Food quality')
ax0.legend()
ax1.plot(x_serv, serv_lo, 'b', linewidth=1.5, label='Poor')
ax1.plot(x_serv, serv_md, 'g', linewidth=1.5, label='Acceptable')
ax1.plot(x_serv, serv_hi, 'r', linewidth=1.5, label='Amazing')
ax1.set_title('Service quality')
ax1.legend()
ax2.plot(x_tip, tip_lo, 'b', linewidth=1.5, label='Low')
ax2.plot(x_tip, tip_md, 'g', linewidth=1.5, label='Medium')
ax2.plot(x_tip, tip_hi, 'r', linewidth=1.5, label='High')
ax2.set_title('Tip amount')
ax2.legend()
# Turn off top/right axes
for ax in (ax0, ax1, ax2):
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
plt.tight_layout()

Catatan : bahwa daftar segmen kode ini memerlukan inisialisasi tambahan sebelum
dapat dijalankan. bahwa kode tambahan ditampilkan dalam daftar segmen kode
berikutnya.

6. Inisialisasi: Membuat Set Aturan

Aturan yang diterapkan pada FLS ini, ialah:;
 jika makanannya buruk atau layanannya buruk, maka tipnya rendah
 jika layanannya pantai/cocok, maka tipnya sedang
 Jika makanannya sangat enak atau layanannya luar biasa, maka tipnya tinggi
Kode berikut adalah untuk menentukan rentang variabel input dan output dan fungsi
keanggotaan.
import numpy as np
import skfuzzy as fuzz
import matplotlib.pyplot as plt
# Generate universe variables
# * food quality and service on subjective ranges, 0 to 10
# * tip has a range of 0 to 25 in units of percentage points
 x_qual = np.arange(0, 11, 1)
x_serv = np.arange(0, 11, 1)
x_tip = np.arange(0, 26, 1)
# Generate fuzzy membership functions
qual_lo = fuzz.trimf(x_qual, [0, 0, 5])
qual_md = fuzz.trimf(x_qual, [0, 5, 10])
qual_hi = fuzz.trimf(x_qual, [5, 10, 10])
serv_lo = fuzz.trimf(x_serv, [0, 0, 5])
serv_md = fuzz.trimf(x_serv, [0, 5, 10])
serv_hi = fuzz.trimf(x_serv, [5, 10, 10])
tip_lo = fuzz.trimf(x_tip, [0, 0, 13])
tip_md = fuzz.trimf(x_tip, [0, 13, 25])
tip_hi = fuzz.trimf(x_tip, [13, 25, 25])

Untuk menguji algoritme, mari kita asumsikan bahwa kualitas makanan dihargai 6,5
dan layanan 9,8. Segmen kode berikut menghitung enam derajat keanggotaan untuk
setiap variabel input dan fungsi keanggotaan:
qual_level_lo = fuzz.interp_membership(x_qual, qual_lo, 6.5)
qual_level_md = fuzz.interp_membership(x_qual, qual_md, 6.5)
qual_level_hi = fuzz.interp_membership(x_qual, qual_hi, 6.5)
serv_level_lo = fuzz.interp_membership(x_serv, serv_lo, 9.8)
serv_level_md = fuzz.interp_membership(x_serv, serv_md, 9.8)
serv_level_hi = fuzz.interp_membership(x_serv, serv_hi, 9.8)

7. Kesimpulan: Mengevaluasi Fuzzy Set Menurut Set Aturan

Menerapkan if ... maka aturan inferensial agak mudah karena yang harus Kita lakukan
adalah fokus pada bagaimana istilah-istilah linguistik terkait. Misalnya, ini adalah
aturan 1. jika makanannya buruk atau layanannya buruk, maka tipnya akan rendah.
Menerapkan aturan 2 agak berbeda. Ini adalah aturan 2. Jika layanannya dapat
diterima/cocok, maka tipnya akan sedang.

Gambar 4. Fungsi keanggotaan layanan dan tip setelah aturan 2 diterapkan.

Aturan 3 adalah yang terakhir diterapkan, Jika makanannya sangat enak atau
layanannya luar biasa, maka tipnya akan tinggi.

Operasi atau diterapkan untuk aturan 3, seperti halnya untuk aturan 1. Tetapi dalam
kasus ini, ada persimpangan pasti dengan fungsi keanggotaan yang hebat dan
menakjubkan. Gambar 5. menunjukkan fungsi keanggotaan makanan dan layanan
setelah flattop tetapi sebelum digabungkan.

Gambar 5. Fungsi Keanggotaan Makanan Dan Layanan Flattop

Gambar 6. menunjukkan fungsi keanggotaan yang hebat, luar biasa, dan tinggi.
Seharusnya tidak menjadi kejutan besar bahwa bentuknya kira-kira sama dengan
fungsi keanggotaan yang tidak dimodifikasi karena operasi atau perintah nilai
maksimum dan dua bentuk keanggotaan yang tidak dimodifikasi persis sama.
Bentuknya juga tetap tidak berubah setelah fungsi keanggotaan gabungan "anded"
dengan fungsi keanggotaan tip tinggi, meskipun rentang nilai sumbu x berubah
menjadi 0 hingga 25 untuk mengakomodasi kisaran tip, seperti yang dilakukan dengan
aturan sebelumnya, dan flattop wilayah mengembang sedikit karena ekspansi sumbu
x.

Gambar 6. Gabungan fungsi keanggotaan sangat enak, luar biasa, dan tinggi
 Segmen kode berikut menerapkan aturan dan menggabungkan fungsi keanggotaan.
Apply rule 1
# The 'or' operator means to take the maximum by using the
'np.max' function
active_rule1 = np.fmax(qual_level_lo, serv_level_lo)
# Next, flattop the corresponding output
# Combine with low tip membership function using `np.fmin`
tip_activation_lo = np.fmin(active_rule1, tip_lo) # Removed
entirely to 0
# Rule 2 connects acceptable service to medium tipping
# No flat topping needed as there is only one input membership
function
# However, the tip membership must be combined using an 'and'
or 'np.fmin' function
tip_activation_md = np.fmin(serv_level_md, tip_md)
# Rule 3 connects amazing service or great food with high
tipping
active_rule3 = np.fmax(qual_level_hi, serv_level_hi)
tip_activation_hi = np.fmin(active_rule3, tip_hi)

Pada titik ini, semua aturan telah diterapkan pada fungsi keanggotaan keluaran. Sekarang
tinggal menggabungkan semuanya. Dalam terminologi FL, ini dikenal sebagai agregasi, yang
merupakan langkah 6 dalam algoritma FLS.

8. Agregasi: Menggabungkan Hasil dari Setiap Evaluasi Aturan.

Agregasi biasanya dilakukan dengan menggunakan operator maksimum. Pernyataan
berikut melakukan agregasi:
# Aggregate all three output membership functions together
aggregated = np.fmax(tip_activation_lo, np.fmax(tip_
activation_md, tip_activation_hi))

9. Defuzzifikasi: Konversi Fuzzy Set ke Nilai Output

Defuzzifikasi adalah proses di mana kita kembali dari dunia fuzzy ke dunia nyata
dan menciptakan output yang dapat ditindaklanjuti. defuzzifikasi centroid adalah
metode yang paling umum digunakan karena sangat akurat. Ini menghitung pusat
daerah di bawah kurva dari fungsi keanggotaan. Hal ini dapat memerlukan proses
komputasi yang signifikan untuk fungsi keanggotaan yang kompleks. Cuplikan kode
berikut menghitung nilai defuzzifikasi centroid.
# Calculate defuzzified result
tip = fuzz.defuzz(x_tip, aggregated, 'centroid')
# This value is needed for the plot
tip_activation = fuzz.interp_membership(x_tip, aggregated, tip)

Bagian ini melengkapi proyek logika tip fuzzy. Yang tersisa untuk dilakukan adalah
memuat dan menjalankan kode berikut, yang dinamai tipping.py. Masukkan yang
berikut ini untuk menjalankan program:
 sudo python tipping.py

Kita harus menutup setiap plot setelah tampaknya melanjutkan ke plo berikutnya.
tipping.py listing
import numpy as np
import skfuzzy as fuzz
import matplotlib.pyplot as plt
# Generate universe variables
# * Quality and service on subjective ranges [0, 10]
# * Tip has a range of [0, 25] in units of percentage points
x_qual = np.arange(0, 11, 1)
x_serv = np.arange(0, 11, 1)
x_tip = np.arange(0, 26, 1)
# Generate fuzzy membership functions
qual_lo = fuzz.trimf(x_qual, [0, 0, 5])
qual_md = fuzz.trimf(x_qual, [0, 5, 10])
qual_hi = fuzz.trimf(x_qual, [5, 10, 10])
serv_lo = fuzz.trimf(x_serv, [0, 0, 5])
serv_md = fuzz.trimf(x_serv, [0, 5, 10])
serv_hi = fuzz.trimf(x_serv, [5, 10, 10])
tip_lo = fuzz.trimf(x_tip, [0, 0, 13])
tip_md = fuzz.trimf(x_tip, [0, 13, 25])
tip_hi = fuzz.trimf(x_tip, [13, 25, 25])
# Visualize these universes and membership functions
fig, (ax0, ax1, ax2) = plt.subplots(nrows=3, figsize=(8, 9))
ax0.plot(x_qual, qual_lo, 'b', linewidth=1.5, label='Bad')
ax0.plot(x_qual, qual_md, 'g', linewidth=1.5, label='Decent')
ax0.plot(x_qual, qual_hi, 'r', linewidth=1.5, label='Great')
ax0.set_title('Food quality')
ax0.legend()
ax1.plot(x_serv, serv_lo, 'b', linewidth=1.5, label='Poor')
ax1.plot(x_serv, serv_md, 'g', linewidth=1.5,
label='Acceptable')
ax1.plot(x_serv, serv_hi, 'r', linewidth=1.5, label='Amazing')
ax1.set_title('Service quality')
ax1.legend()
ax2.plot(x_tip, tip_lo, 'b', linewidth=1.5, label='Low')
ax2.plot(x_tip, tip_md, 'g', linewidth=1.5, label='Medium')
ax2.plot(x_tip, tip_hi, 'r', linewidth=1.5, label='High')
ax2.set_title('Tip amount')
ax2.legend()
# Turn off top/right axes
for ax in (ax0, ax1, ax2):
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
plt.tight_layout()
plt.show()
# Calculate degrees of membership
# The exact values 6.5 and 9.8 do not exist on our universes
# Use fuzz.interp_membership to determine values
qual_level_lo = fuzz.interp_membership(x_qual, qual_lo, 6.5)
qual_level_md = fuzz.interp_membership(x_qual, qual_md, 6.5)
qual_level_hi = fuzz.interp_membership(x_qual, qual_hi, 6.5)
serv_level_lo = fuzz.interp_membership(x_serv, serv_lo, 9.8)
serv_level_md = fuzz.interp_membership(x_serv, serv_md, 9.8)
serv_level_hi = fuzz.interp_membership(x_serv, serv_hi, 9.8)
# Apply the rules, Rule 1 concerns bad food OR service.
# The OR operator means we take the maximum of these two.
active_rule1 = np.fmax(qual_level_lo, serv_level_lo)
# Now we apply this by clipping the top off the corresponding output
# membership function with `np.fmin`
tip_activation_lo = np.fmin(active_rule1, tip_lo) # removed
entirely to 0
# Rule 2 is a straight if ... then construction
# if acceptable service then medium tipping. This is an AND operator
# We take the minimum for an AND operator
tip_activation_md = np.fmin(serv_level_md, tip_md)
# For rule 3 we connect high service OR high food with high tipping
active_rule3 = np.fmax(qual_level_hi, serv_level_hi)
tip_activation_hi = np.fmin(active_rule3, tip_hi)
tip0 = np.zeros_like(x_tip)
# Visualize these rule applications
fig, ax0 = plt.subplots(figsize=(8, 3))
ax0.fill_between(x_tip, tip0, tip_activation_lo, facecolor='b',
alpha=0.7)
ax0.plot(x_tip, tip_lo, 'b', linewidth=0.5, linestyle='--', )
ax0.fill_between(x_tip, tip0, tip_activation_md, facecolor='g',
alpha=0.7)
ax0.plot(x_tip, tip_md, 'g', linewidth=0.5, linestyle='--')
ax0.fill_between(x_tip, tip0, tip_activation_hi, facecolor='r',
alpha=0.7)
ax0.plot(x_tip, tip_hi, 'r', linewidth=0.5, linestyle='--')
 ax0.set_title('Output membership activity')
# Turn off top/right axes
for ax in (ax0,):
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
plt.tight_layout()
plt.show()
# Aggregate all three output membership functions together
# This aggregation uses OR operators, hence the maximum is found
aggregated = np.fmax(tip_activation_lo, np.fmax(tip_activation_
md, tip_activation_hi))
# Calculate defuzzified result using the method of centroids
tip = fuzz.defuzz(x_tip, aggregated, 'centroid')
# display the tip percentage on the console
print tip
# Value needed for the next plot
tip_activation = fuzz.interp_membership(x_tip, aggregated, tip)
# Visualize the final results
fig, ax0 = plt.subplots(figsize=(8, 3))
ax0.plot(x_tip, tip_lo, 'b', linewidth=0.5, linestyle='--', )
ax0.plot(x_tip, tip_md, 'g', linewidth=0.5, linestyle='--')
ax0.plot(x_tip, tip_hi, 'r', linewidth=0.5, linestyle='--')
ax0.fill_between(x_tip, tip0, aggregated, facecolor='Orange',
alpha=0.7)
ax0.plot([tip, tip], [0, tip_activation], 'k', linewidth=1.5,
alpha=0.9)
ax0.set_title('Aggregated membership and result (line)')
# Turn off top/right axes
for ax in (ax0,):
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
plt.tight_layout()
plt.show()

Gambar 7. adalah tampilan pertama yang ditunjukkan pada monitor. Ini menunjukkan
ketiga fungsi keanggotaan: kualitas makanan, kualitas layanan, dan jumlah tip.
 Gambar 7. Tiga fungsi keanggotaan

Gambar 8. Fungsi keanggotaan setelah aturan aplikasi

Gambar 9. menunjukkan tampilan berikutnya: hasil agregasi pos untuk semua fungsi
keanggotaan yang diproses. Selain itu, ada garis yang menunjukkan output crisp untuk
persentase tip yang dihasilkan dari proses defuzzifikasi.
 Gambar 9. Posting Hasil Agregasi Dan Defuzzifikasi

Gambar 10. menunjukkan tampilan teks untuk persentase tip, yang berasal dari
pernyataan dalam program.

Program 5-2: Modifikasi ke Program tipping.py

Pada bagian ini, saya membahas modifikasi pada program Python untuk membuatnya
lebih mudah digunakan dan secara signifikan lebih portabel. Modifikasi utama adalah
untuk menanyakan pengguna tentang kualitas makanan dan layanan, daripada
memiliki nilai statis, yang merupakan kasus untuk proyek awal. Modifikasi ini cukup
mudah dan terdiri dari menciptakan dua variabel untuk menahan tingkat kualitas
makanan dan layanan, dan dua pernyataan masukan untuk memasukkan data ke dalam
program. Kode tambahan atau yang dimodifikasi adalah sebagai berikut:
food_qual = raw_input('Rate the food quality, 0 to 10')
service_qual = raw_input('Rate the service quality, 0 to 10')
qual_level_lo = fuzz.interp_membership(x_qual, qual_lo,
float(food_qual))
qual_level_md = fuzz.interp_membership(x_qual, qual_md,
float(food_qual))
qual_level_hi = fuzz.interp_membership(x_qual, qual_hi,
float(food_qual))
 serv_level_lo = fuzz.interp_membership(x_serv, serv_lo,
float(service_qual))
serv_level_md = fuzz.interp_membership(x_serv, serv_md,
float(service_qual))
serv_level_hi = fuzz.interp_membership(x_serv, serv_hi,
float(service_qual))

Kode yang dimodifikasi ini membantu mendorong pengguna untuk memasukkan

peringkat kualitas makanan dan layanan.Modifikasi kedua adalah membuat seluruh
sistem sepenuhnya portabel, agak mirip dengan konfigurasi game Nim yang dibahas
pada bab sebelumnya. Saya akan menggunakan layar LCD untuk menunjukkan
permintaan pengguna untuk memasukkan makanan dan peringkat kualitas layanan,
dan kemudian menunjukkan persentase tip yang dihasilkan.

Program 5-3: Sistem Pemanasan dan Pendinginan FLS

Pertimbangkan sistem pemanas, ventilasi, dan pendingin (HVAC) yang, praktisnya,
adalah pompa panas yang berfungsi sebagai AC atau pemanas.

Heat/cool
Command
Target room No change
temperature FLS Heat Pump Room

Room Temperature

Gambar 11. Sistem loop tertutup HVAC

Mari tentukan suhu (t) sebagai variabel input yang asli untuk mewakili suhu ruangan
yang sedang dipanaskan atau didinginkan. Umumnya, orang menggunakan istilah
panas dan dingin sebagai kualifikasi suhu kamar. Istilah-istilah ini, serta yang terkait,
dapat dikembangkan menjadi seperangkat istilah linguistik.

T(t) = { cold, comfortable, hot }

Ekspresi ini untuk T (t) mewakili fungsi dekomposisi untuk variabel input t. Setiap
anggota set dekomposisi linguistik ini mewakili atau dikaitkan dengan kisaran suhu
numerik. Misalnya, dingin bisa berkisar antara 40 ° F hingga 60 ° F, sedangkan panas
mungkin berkisar 70 ° F hingga 90 ° F. Istilah linguistik lain dapat dengan mudah
mengisi rentang intervensi jika diputuskan bahwa 20 ° F adalah nilai interval yang
sesuai.
 Gambar 12. Fungsi keanggotaan suhu kamar dan target

Dalam hal ini, suhu kamar apa pun dapat dimiliki oleh satu atau dua kelompok,
tergantung pada nilainya. Gambar 13. menunjukkan bahwa suhu ruangan 65 ° F
memiliki nilai keanggotaan 0,5 dalam fungsi keanggotaan yang nyaman, serta 0,5
dalam fungsi keanggotaan dingin. Suhu kamar tepatnya 70 ° F memiliki nilai
keanggotaan 1,0 dan hanya dalam fungsi keanggotaan yang nyaman.

Gambar 13. HVAC mengontrol fungsi keanggotaan

Berikut ini adalah beberapa contoh aturan untuk menentukan perintah kontrol
berdasarkan suhu ruangan dan target.
 jika (suhu kamar dingin) dan (suhu target nyaman), maka perintahnya adalah
panas.
 jika (suhu kamar panas) dan (suhu target nyaman), maka perintahnya dingin.
 jika (suhu kamar nyaman) dan (suhu target nyaman), maka perintahnya tidak
berubah

Ada enam aturan yang diperlukan untuk mengakomodasi semua kombinasi suhu ruang
berpotongan dan istilah linguistik suhu target yang memerlukan tindakan. Aturan
untuk tidak ada perubahan diabaikan. Ini aturannya.
 jika suhu kamar dingin dan suhu target nyaman, maka suhu perintah adalah
panas.
 jika suhu kamar dingin dan suhu target panas, maka perintahnya adalah panas
  jika suhu kamar nyaman dan suhu target dingin, maka perintahnya dingin.
 jika suhu kamar nyaman dan suhu target adalah panas, maka perintahnya adalah
panas
 jika suhu kamar panas dan suhu target dingin, maka perintahnya dingin
 jika suhu kamar panas dan suhu target nyaman, maka perintahnya dingin

10. Fuzzifikasi
Segmen kode berikut ini mengatur rentang variabel input dan fungsi keanggotaan.
import numpy as np
import skfuzzy as fuzz
# Generate universe variables
# * room and target temperature range is 50 to 90
# * same for the output control variable
x_room_temp = np.arange(50, 91, 1)
x_target_temp = np.arange(50, 91, 1)
x_control_temp = np.arange(50, 91, 1)
# Generate fuzzy membership functions
room_temp_lo = fuzz.trimf(x_qual, [50, 50, 70])
room_temp_md = fuzz.trimf(x_qual, [50, 70, 90])
room_temp_hi = fuzz.trimf(x_qual, [70, 90, 90])
target_temp_lo = fuzz.trimf(x_serv, [50, 50, 70])
target_temp_md = fuzz.trimf(x_serv, [50, 70, 90])
target_temp_hi = fuzz.trimf(x_serv, [50, 90, 90])
control_temp_lo = fuzz.trimf(x_tip, [50, 50, 70])
control_temp_md = fuzz.trimf(x_tip, [50, 70, 90])
control_temp_hi = fuzz.trimf(x_tip, [70, 90, 90])

Langkah selanjutnya dalam algoritma adalah untuk menentukan nilai fuzzified

berdasarkan nilai untuk suhu ruangan dan target. Dalam proyek ini, pengguna
diminta untuk memasukkan kedua nilai. Dalam sistem kontrol FL kata nyata, suhu
target diatur secara manual, sementara ruangan suhu ditentukan dengan sensor.
Namun, untuk mempermudah, kedua input diatur secara manual. Kode berikut
menerima input pengguna dan menghilangkan input tersebut:

# Get user inputs

room_temp = raw_input('Enter room temperature 50 to 90')
target_temp = raw_input('Enter target temperature 50 to 90')
# Calculate degrees of membership
room_temp_level_lo = fuzz.interp_membership(x_room_temp,
room_temp_lo, float(room_temp))
room_temp_level_md = fuzz.interp_membership(x_room_temp,
room_temp_md, float(room_temp))
room_temp_level_hi = fuzz.interp_membership(x_room_temp,
room_temp_hi, float(room_temp))
 target_temp_level_lo = fuzz.interp_membership(x_target_temp,
target_temp_lo, float(target_temp))
target_temp_level_md = fuzz.interp_membership(x_target_temp,
target_temp_md, float(target_temp))
target_temp_level_hi = fuzz.interp_membership(x_target_temp,
Target_temp_hi, float(target_temp))

Sekarang ke langkah inferensi di mana semua aturan diterapkan dan fungsi keanggotaan
digabungkan.

11. Kesimpulan
Segmen kode berikut menerapkan enam aturan dan menggabungkan semua fungsi
keanggotaan:
# Apply rule 1: if room_temp is cold and target temp is
comfortable then command is heat
# The 'and' operator means to take the minimum by using the
'np.fmin' function
active_rule1 = np.fmin(room_temp_level_lo, target_temp_level_md)
# Combine with hi control membership function using `np.fmin`
control_activation_1 = np.fmin(active_rule1, control_temp_hi)
# Next go through all five remaining rules
#Apply rule 2: if room_temp is cold and target temp is hot then
command is heat
active_rule2 = np.fmin(room_temp_level_lo, target_temp_level_hi)
# Combine with hi control membership function using `np.fmin`
control_activation_2 = np.fmin(active_rule2, control_temp_hi)
#Apply rule 3: if room_temp is comfortable and target temp is
cold then command is cool
active_rule3 = np.fmin(room_temp_level_md, target_temp_level_lo)
# Combine with lo control membership function using `np.fmin`
control_activation_3 = np.fmin(active_rule3, control_temp_lo)
#Apply rule 4: if room_temp is comfortable and target temp is
heat then command is heat
active_rule4 = np.fmin(room_temp_level_md, target_temp_level_hi)
# Combine with hi control membership function using `np.fmin`
control_activation_4 = np.fmin(active_rule4, control_temp_hi)
#Apply rule 5: if room_temp is hot and target temp is cold then
command is cool
active_rule5 = np.fmin(room_temp_level_hi, target_temp_level_lo)
# Combine with lo control membership function using `np.fmin`
control_activation_5 = np.fmin(active_rule5, control_temp_lo)
#Apply rule 6: if room_temp is hot and target temp is
comfortable then command is cool
 active_rule6 = np.fmin(room_temp_level_hi, target_temp_level_md)
# Combine with lo control membership function using `np.fmin`
control_activation_6 = np.fmin(active_rule6, control_temp_lo)

Bagian ini membahas penerapan aturan dan menggabungkan set. Langkah

selanjutnya adalah agregasi.

12. Pengumpulan
Pernyataan agregasi panjang karena enam nilai aktivasi kontrol.

aggregated = np.fmax(control_activation_1, control_activation_2,

control_activation_3, control_activation_4,
control_activation_5, control_activation_6)

13. Defuzzifikasi
Metode centroid akan diterapkan untuk proyek ini seperti yang dilakukan untuk
proyek sebelumnya.

# Calculate defuzzified result using the method of centroids

control_value = fuzz.defuzz(x_control_temp, aggregated,
'centroid')

print control_value

Berikut ini adalah daftar lengkap untuk program hvac.py.

import numpy as np
import skfuzzy as fuzz
# Generate universe variables
# * room and target temperature range is 50 to 90
# * same for the output control variable
x_room_temp = np.arange(50, 91, 1)
x_target_temp = np.arange(50, 91, 1)
x_control_temp = np.arange(50, 91, 1)
# Generate fuzzy membership functions
room_temp_lo = fuzz.trimf(x_room_temp, [50, 50, 70])
room_temp_md = fuzz.trimf(x_room_temp, [50, 70, 90])
room_temp_hi = fuzz.trimf(x_room_temp, [70, 90, 90])
target_temp_lo = fuzz.trimf(x_target_temp, [50, 50, 70])
target_temp_md = fuzz.trimf(x_target_temp, [50, 70, 90])
target_temp_hi = fuzz.trimf(x_target_temp, [50, 90, 90])
control_temp_lo = fuzz.trimf(x_control_temp,[50, 50, 70])
control_temp_md = fuzz.trimf(x_control_temp,[50, 70, 90])
control_temp_hi = fuzz.trimf(x_control_temp,[70, 90, 90])
# Get user inputs
room_temp = raw_input('Enter room temperature 50 to 90: ')
target_temp = raw_input('Enter target temperature 50 to 90: ')
# Calculate degrees of membership
room_temp_level_lo = fuzz.interp_membership(x_room_temp,
room_temp_lo, float(room_temp))
room_temp_level_md = fuzz.interp_membership(x_room_temp,
room_temp_md, float(room_temp))
room_temp_level_hi = fuzz.interp_membership(x_room_temp,
room_temp_hi, float(room_temp))
target_temp_level_lo = fuzz.interp_membership(x_target_temp,
target_temp_lo, float(target_temp))
target_temp_level_md = fuzz.interp_membership(x_target_temp,
target_temp_md, float(target_temp))
target_temp_level_hi = fuzz.interp_membership(x_target_temp,
target_temp_hi, float(target_temp))
# Apply all six rules
# rule 1: if room_temp is cold and target temp is comfortable
then command is heat
active_rule1 = np.fmin(room_temp_level_lo, target_temp_level_md)
control_activation_1 = np.fmin(active_rule1, control_temp_hi)
# rule 2: if room_temp is cold and target temp is hot then
command is heat
active_rule2 = np.fmin(room_temp_level_lo, target_temp_level_hi)
control_activation_2 = np.fmin(active_rule2, control_temp_hi)
# rule 3: if room_temp is comfortable and target temp is cold
then command is cool
active_rule3 = np.fmin(room_temp_level_md, target_temp_level_lo)
control_activation_3 = np.fmin(active_rule3, control_temp_lo)
# rule 4: if room_temp is comfortable and target temp is heat
then command is heat
active_rule4 = np.fmin(room_temp_level_md, target_temp_level_hi)
control_activation_4 = np.fmin(active_rule4, control_temp_hi)
# rule 5: if room_temp is hot and target temp is cold then
command is cool
active_rule5 = np.fmin(room_temp_level_hi, target_temp_level_lo)
control_activation_5 = np.fmin(active_rule5, control_temp_lo)
# rule 6: if room_temp is hot and target temp is comfortable then
command is cool
active_rule6 = np.fmin(room_temp_level_hi, target_temp_level_md)
control_activation_6 = np.fmin(active_rule6, control_temp_lo)
# Aggregate all six output membership functions together
# Combine outputs to ease the complexity as fmax() only as two
args
 c1 = np.fmax(control_activation1, control_activation2)
c2 = np.fmax(control_activation3, control_activation4)
c3 = np.fmax(control_activation5, control_activation6)
c4 = np.fmax(c2,c3)
aggregated = np.fmax(c1, c4)
# Calculate defuzzified result using the method of centroids
control_value = fuzz.defuzz(x_control_temp, aggregated,
'centroid')
# Display the crisp output value
print control_value

14. Menguji Program Kontrol

Perhatikan suhu dengan tKita bintang (*) sedikit bergeser karena metode
defuzzifikasi kesalahan ketika suhu cocok dan berada di ekstrem dari rentang
variabel.
 Nilai perintah sekitar 65 hingga 75 berarti tidak ada perubahan
 Nilai perintah sekitar 82 hingga 83 berarti pemanasan diperlukan
 Nilai perintah sekitar 56 hingga 65 berarti pendinginan itu wajib

Program 5-4: Modifikasi ke Program HVAC

Untuk Program ini, saya membuat modifikasi sederhana pada program kontrol: satu
dari tiga LED menyala, berdasarkan apakah pemanasan, pendinginan, atau tidak ada
perubahan ditentukan dari input pengguna. Kode berikut ditambahkan ke daftar
sebelumnya, kecuali impor tambahan dan pernyataan konfigurasi harus ditempatkan
pada awal program, seperti yang saya lakukan dengan program sebelumnya yang
menggunakan LED. Saya memberikan komentar yang menunjukkan pin GPIO yang
digunakan dalam modifikasi ini. Mereka adalah yang sama yang digunakan dalam
permainan prs.py, jadi gunakan diagram interkoneksi LED yang ditunjukkan dalam
proyek itu.

# Include the following at the beginning of the hvac.py program

import RPi.GPIO as GPIO
import time
# Setup GPIO pins
# Set the BCM mode
GPIO.setmode(GPIO.BCM)
# Outputs
GPIO.setup( 4, GPIO.OUT) # heat command
GPIO.setup(17, GPIO.OUT) # cool command
GPIO.setup(27, GPIO.OUT) # no change command
# Ensure all LEDs are off to start
GPIO.output( 4, GPIO.LOW)
GPIO.output(17, GPIO.LOW)
GPIO.output(27, GPIO.LOW)
 # The following should be appended to the existing code
if control_value > 65 and control_value < 75: # no change
GPIO.output(27, GPIO.HIGH)
time.sleep(5)
GPIO.output(27, GPIO.LOW)
elif control_value > 82 and control_value < 84: # heat
GPIO.output(4, GPIO.HIGH)
time.sleep(5)
GPIO.output(4, GPIO.LOW)
elif control_value > 56 and control_value < 68: # cool
GPIO.output(17, GPIO.HIGH)
time.sleep(5)
GPIO.output(17, GPIO.LOW)
else:
print 'strange value calculated'
# This next statement used in debugging phase
print 'Thats all folks'
KESIMPULAN
Fokus pada bab ini mengenai logika fuzzy, yang merupakan pendekatan yang
sangat cerdas untuk menangani nilai-nilai non-tepat yang ada di hampir setiap situasi
manusia. Bab ini memiliki Programnstrasi yang sangat rinci, termasuk algoritma
tujuh langkah untuk mengembangkan sistem logika fuzzy (FLS).
Programnstrasi pertama menunjukkan bagaimana menghitung tip berdasarkan
kualitas makanan dan kualitas layanan. Algoritma tujuh langkah menghasilkan
sebuah program yang dengan cepat menghitung persentase tip berdasarkan peringkat
pengguna. Saya bahkan menyarankan cara untuk membuat proyek ini sepenuhnya
portabel.
Programnstrasi kedua agak lebih teknis daripada yang pertama. Ini melibatkan
menciptakan sistem kontrol FL pemanas dan pendingin. Jenis sistem ini tersedia
secara komersial di produk-produk HVAC. Bahkan, satu produsen mengiklankan
bahwa sistemnya menggunakan logika fuzzy. Memang, proyek bab ini adalah versi
yang diperkecil dari sistem HVAC komersial, tetapi tetap menggabungkan semua
bagian penting dari FLS.