Project UAS Data Mining

Simulasi Klasifikasi Data PCA – Kmeans/FCM-ANN

Berlina Oktaviola 2011011220001

Noor Alfiadati Suryadi Putri 2011011220015
Praditya Eka Saputra 2211011110006

Program Studi Matematika, Fakultas Matematika dan Ilmu Pengetahuan Alam

Universitas Lambung Mangkurat

Abstrak

Klasterisasi adalah teknik penting dalam analisis data yang bertujuan untuk mengelompokkan
objek-objek berdasarkan kesamaan karakteristiknya. Dalam penelitian ini, kami
membandingkan dua pendekatan klasterisasi yang berbeda, yaitu metode K-Means dengan
RBF (Radial Basis Function) dan metode FCM (Fuzzy C-Means) dengan RBF. Metode K-
Means dengan RBF menggabungkan keunggulan K-Means dan RBF untuk meningkatkan
kinerja klasterisasi. Pendekatan ini menggunakan algoritma K-Means untuk menginisialisasi
pusat klaster awal, dan kemudian mengoptimalkan posisi pusat klaster menggunakan fungsi
dasar radial. Di sisi lain, metode FCM dengan RBF menggabungkan konsep keanggotaan
fuzzy dari FCM dengan fungsi dasar radial dari RBF. Metode ini memperkenalkan tingkat
keanggotaan yang mengukur sejauh mana objek terkait dengan masing-masing klaster, dan
menggunakan fungsi dasar radial untuk menghitung jarak objek-objek terhadap pusat klaster.
Untuk membandingkan kinerja kedua metode, kami melakukan eksperimen menggunakan
beberapa dataset yang berbeda yang umum digunakan. Namun, perlu diperhatikan bahwa
pilihan metode yang tepat tergantung pada sifat data yang dianalisis dan tujuan klasterisasi
yang diinginkan.

Kata kunci: Principal Component Analysis (PCA), K-Means, Fuzzy C-Means (FCM), Radial
Basis Function (RBF)
 Pendahuluan

Data mining merupakan proses penggalian pengetahuan yang dilakukan pada dataset
besar untuk mengidentifikasi pola, hubungan dan informasi yang berharga. Salah satu tugas
utama dalam data mining adalah klasifikasi yang memiliki tujuan untuk mengelompokkan
suatau data ke dalam kelas atau kategori yang sudah ditentukan berdasarkan atribut-atribut
yang ada.

Klasterisasi merupakan salah satu teknik penting dalam analisis data yang bertujuan
untuk mengelompokkan objek-objek berdasarkan kesamaan karakteristiknya. Metode
klasterisasi dapat digunakan dalam berbagai bidang, seperti ilmu komputer, bioinformatika,
pengenalan pola, dan analisis data lainnya. Dalam beberapa dekade terakhir, beberapa metode
klasterisasi telah dikembangkan dan digunakan secara luas.

Salah satu teknik yang bisa digunakan dalam pengenalan pola dan aplikasinya untuk
prediksi yaitu sistem Principal Component Analysis dan Artificial Neural Network (jaringan
saraf tiruan). Principal Component Analysis (PCA) adalah suatu teknik statistik yang secara
linear mengubah bentuk sekumpulan variabel asli menjadi kumpulan variabel yang lebih
kecil yangtidak berkorelasi yang dapat mevvakili informasi dari kumpulan variabel asli
(Dunteman. 1989:7). Sedangkan Neural Networks merupakan sebuah metode softcomputing
atau Data Mining yang banyak digunakan untuk melakukan pengklasifikasian dan prediksi.
Artificial Neural Networks (ANN) pertama kali dikembangkan oleh McCulloch dan Pitts
pada tahun 1943, dan sekarang ini telah banyak dikembangkan menjadi bentuk ANN yang
bermacam-macam (Musliyanto dan Defit, 2015).

Metode K-Means dengan RBF mengintegrasikan algoritma K-Means dengan

penggunaan fungsi dasar radial. Pendekatan ini menggunakan algoritma K-Means untuk
menginisialisasi pusat klaster awal, dan kemudian mengoptimalkan posisi pusat klaster
menggunakan fungsi dasar radial. Metode ini bertujuan untuk mengatasi masalah
konvergensi ke solusi lokal yang sering terjadi pada K-Means, sambil tetap mempertahankan
kemampuan RBF dalam menangani data dengan struktur non-linear.

Di sisi lain, metode FCM dengan RBF menggabungkan konsep keanggotaan fuzzy
dari FCM dengan penggunaan fungsi dasar radial. Metode ini memperkenalkan tingkat
keanggotaan yang mengukur sejauh mana objek terkait dengan masing-masing klaster, dan
menggunakan fungsi dasar radial untuk menghitung jarak objek-objek terhadap pusat klaster.
Pendekatan ini bertujuan untuk mengatasi ketidakpastian dalam klasterisasi dengan
memperkenalkan keanggotaan fuzzy.

Dalam konteks ini, perbandingan antara metode K-Means dengan RBF dan metode
FCM dengan RBF menjadi relevan untuk memahami kelebihan, kelemahan, dan kinerja
relatif dari kedua pendekatan tersebut dalam klasterisasi data. Perbandingan tersebut dapat
memberikan wawasan yang berharga bagi praktisi dan peneliti dalam memilih metode
klasterisasi yang sesuai dengan kebutuhan analisis data mereka. Dengan pemahaman yang
lebih baik tentang kinerja dan karakteristik kedua metode ini, dapat dikembangkan
pendekatan klasterisasi yang lebih efektif dan akurat untuk analisis data.

Metode

1. Clustering

Adapula Clustering yaitu suatu metode pengelompokan berdasarkan ukuran kedekatan

(kemiripan). Clustering berbeda dengan group, kalau group berarti kelompok yang memiliki
kondisi yang sama. Sedangkan cluster kelompoknya tidak harus sama, pengelompokan
didasarkan pada kedekatan dari suatu karakteristik sampel yang ada, salah satunya dengan
menggunakan rumus jarak Euclidean. Pengaplikasian cluster sangatlah banyak, hal ini
dikarenakan dalam mengidentifikasi suatu permasalahan atau pengambilan keputusan selalu
tidak sama persis akan tetapi cenderung memiliki kemiripan saja. Metode clustering pada
dasarnya mengoptimumkan pusat cluster (Centroid) (Kusumadewi, 2010). Beberapa metode
clustering yang sering digunakan antara lain yaitu :

1) Berbasis Metode Statistik seperti Hirarchical clustering method dan Non Hirarchical
clustering method,
2) Berbasis Fuzzy : Fuzzy C-Means,
3) Berbasis Neural Network : Kohonen SOM, LVQ, dan
4) Metode lain untuk optimasi centroid atau lebar cluster seperti Genetik Algoritma
(GA) (Satriyanto, 2015).
2. Principal Component Analysis (PCA)

Penelitian ini menggunakan data wine, mobil, iris, wholesale versi region dan wholesale
channel. Metode yang digunakan merupakan metode Principal Component Analysis (PCA),
Fuzzy C-Means, dan Artificial Neural Networks (ANN). Analisis Komponen Utama atau
Principal Component Analysis (PCA) merupakan suatu metode dalam menganalisis suatu
data multivariat yang digunakan untuk mengurangi dimensi dari dataset yang kompleks.
Metode ini menggunakan elemen perhitungan Matriks kovariansi, vector eigen serta
komponen utama. Metode PCA digunakan pada penelitian ini dikarenakan tujuan dari
penelitian ini adalah berusaha meringkas data dengan jumlah variabel yang lebih kecil.

3. Fuzzy C-Means (FCM)

Clustering dengan metode Fuzzy C-Means (FCM) didasarkan pada teori logika fuzzy,
diperkenalkan oleh Lotfi Zadeh (1965) dengan nama himpunan fuzzy (Fuzzy Set). Dalam
teori fuzzy, keanggotaan sebuah dinyatakan dengan derajat nilai keanggotaan yang jangkauan
nilainya 0 sampai 1. Nilai keanggotaan suatu data adalah 0 ketika sama sekali tidak menjadi
anggota, dan 1 jika menjadi anggota secara penuh dalam suatu himpunan. Semakin tinggi
nilai keanggotaannya maka semakin tinggi derajat keanggotaannya, begitu pula sebaliknya.
FCM merupakan versi fuzzy dari K-Means dengan berberapa modifikasi yang
menbedakannya dengan K-Means.
Asumsikan ada sejumlah data dalam set data 𝑋 yang berisi 𝑛 data yang dinotasikan 𝑋 =
{𝑥1 , 𝑥2 , … , 𝑥𝑛 } dimana setiap data mempunyai fitur 𝑥 dimensi : 𝑥𝑖1 , 𝑥𝑖2 , … , 𝑥𝑖𝑟 , dinotasikan
𝑥𝑖 = { 𝑥𝑖1 , 𝑥𝑖2 , … , 𝑥𝑖𝑟 }. Ada sejumlah cluster C dengan centroid 𝑐1 , 𝑐2 , … , 𝑐𝑘 , di mana k
adalah jumlah cluster. Setiap data mempunyai derajat keanggotaan pada setiap cluster,
dinyatakan dengan uij, dengan nilai diantara 0 dan 1, 𝑖 menyatakan data 𝑥𝑖 dan 𝑗 menyatakan
cluster 𝑐𝑗 . Jumlah nilai derajat keanggotaan setiap data xi selalu sama dengan 1, yang
diformulasikan dengan persamaan 1 :
𝑘

∑ 𝑢𝑖𝑗 = 1 (1)
𝑗=1

Dalam FCM setiap data juga menjadi anggota pada setiap cluster dengan derajat keanggotaan
𝑢𝑖𝑗 . Nilai derajat keanggotaan 𝑥𝑖 pada cluster 𝑐𝑗 , diformasikan pada persamaan 2.
−2
𝐷(𝑥𝑗 , 𝑐𝑗 ) 𝑤−1
(2)
𝑢𝑖𝑗 = −2
∑𝑘𝑖=1 𝐷(𝑥𝑖 , 𝑐𝑖 )𝑤−1
 Parameter 𝑐𝑗 adalah centroid kluster ke – 𝑗, 𝐷(𝑥𝑖 , 𝑐𝑗 ) adalah jarak antara data dengan centroid,
sedangkan 𝑤 adalah bobot pangkat (weighting exponent) yang diperkenalkan dalam FCM. W
tidak memiliki ketetapan, biasanya 𝑤 > 1 dan umumnya diberi nilai 2. Nilai keanggotaan
tersebut disimpan dalam matriks fuzzy pseudo-partition berukuran 𝑁 × 𝑘, dimana baris
merupakan data, sedangkan kolom adalah nilai keanggotaan setiap cluster. Untuk menghitung
centroid pada cluster 𝑐𝑙 pada fitur 𝑗, digunakan persamaan 3.
𝑤
∑𝑁
𝑖=1(𝑢𝑖𝑗 ) 𝑥𝑖𝑗 (3)
𝑐𝑖𝑗 = 𝑤
∑𝑁
𝑖=1(𝑢𝑖𝑗 )

Secara prinsip, algoritma FCM banyak kesamaan dengan K-Means. Secara ringkas algoritma
clustering dengan menggunakan Fuzzy C-Means adalah sebagai berikut:
1) Inisialisasi : tentukan jumlah cluster ( 𝑘 > 2 ), tentukan bobot pangkat (𝑤 > 1), tentukan
jumlah maksimal iterasi, tentukan ambang batas perubahan nilai fungsi objektif (jika perlu
juga perubahan nilai centroid);
2) Berikan nilai awal pada matriks fuzzy pseudo-partition dengan syarat sama seperti pada
persamaan (1);
3) Hitung nilai centroid dari masing – masing cluster menggunakan persamaan (4);
4) Hitung kembali matriks fuzzy pseudo-partition (derajat keanggotaan setiap data pada setiap
cluster) menggunakan persamaan (3).
Ulangi langkah nomor 4 dan 5 selama syarat masih terpenuhi :
1) Apabila perubahan pada nila fungsi objektif masih di atas nilai ambang batas yang
ditentukan; atau
2) Perubahan pada nilai centroid masih di atas nilai ambang batas yang ditentukan; atau
3) Iterasi maksimal belum tercapai.

4. Artificial neural network (ANN)

Artificial neural network atau jaringan saraf tiruan adalah jaringan dari sekelompok unit
pemproses yang dimodelkan berdasarkan jaringan saraf manusia. ANN merupakan sistem
adaptif yang dapat mengubah strukturnya untuk memecahkan masalah berdasarkan informasi
eksternal maupun internal. Neuron-neuron dalam neural network disusun dalam grup, yang
disebut dengan layer (lapis). Pada dasarnya ANN terdiri dari 3 lapisan (layer), yaitu input
layer, process, dan output layer. Pada input layer berisi variabel data input, process layer
berisi langkah pengenalan objek dan output layer berisi hasil pengenalan suatu objek.
5. K-Means

K-Means adalah algoritma clustering untuk data mining yang diciptakan tahun 70-an dan
berguna untuk melakukan clustering secara unsupervised learning (pembelajaran tidak
terawasi) dalam kumpulan data berdasarkan parameter-parameter tertentu. K-Means
mengelompokkan objek menjad K-cluster.

Berikut adalah langkah-langkah dalam memproses algoritma K-means:

a. Tentukan jumlah k-cluster yang diinginkan,

b. Lakukan inisialisasi untuk menentukan pusat cluster,
c. Hitung centroid rata-rata dari data berdasarkan data keluarga yang bergabung pada
setiap cluster dengan persamaan

1 𝑀
𝐶𝑖𝑘 = ∑ 𝑋𝑗
𝑀 𝑗

d. Untuk tiap baris, tentukan pusat cluster yang terdekat. Untuk menghitung distance
atau jarak antara data dengan pusat cluster digunakan rumus Distance Euclidian

𝑛 2
𝐷(𝑋𝑖 , 𝐶𝑗 ) = ||𝑋𝑖 − 𝐶𝑗 || = √∑ |𝑥1𝑗 − 𝐶1𝑗 |
𝑗=1

e. Menentukan grup berdasarkan jarak terpendek,

f. Untuk tiap k-cluster, temukan centroid (means) dari cluster tersebut dan update
lokasi dari pusat cluster kedalam nilai centroid baru

1 𝑁𝑘
𝑀𝑘 = 𝑋 ∑ 𝑋𝑗𝑘
𝑁𝑘 𝑗=1

g. Ulangi langkah ketiga sampai e hingga batas nilai iterasi atau nilai tolerasnsi yang
ditentukan masih ada data yang berpindah.
6. Radia basis Function

Jaringan fungsi Radial Basis Function (RBF) yang merupakan alternatif dari jaringan
Multilayered Feedforward Neural (MFN) yang telah dikembangkan. Jaringan ini terdiri dari
3 layer yaitu input layer, hidden layer, dan output layer, dimana hanya memiliki satu unit
pada hidden layer. Jumlah hidden layer dari jaringan RBF adalah sejumlah input sampai 2
kali inputan. Fungsi aktivasi adalah fungsi basis dan fungsi linear pada lapisan output.
Jaringan ini telah banyak digunakan secara intensif. RBF merupakan fungsi tak linier
multidimesional yang tergantung pada jarak vektor input dan vektor center. RBF dengan
input berdimensi-m dan output berdimensi-n. Algoritma JST RBF adalah:

a. Menentukan pusat data dari data latih. Dalam menentukan pusat data dilakukan
dengan pengambilan nilai center secara acak diambil dari nilai inputan pada proses
pelatihan dan menggunakan algoritma clustering,
b. Menghitung jarak Eucledian

𝑝 2
‖𝑥𝑖 − 𝑥𝑘 ‖ = 𝐷𝑖,𝑘 = √∑ (𝑥𝑖,𝑗 − 𝑥𝑘,𝑗 )
𝑗=1

Dimana 𝑖, 𝑘 = 1,2 … … , 𝑛; 𝑗 = 1,2 … … . , 𝑝

c. Menghitung fungsi gaussian hasil aktivasi dengan fungsi basis radial dari jarak data
dikalikan 𝑏1;

2
𝜑𝑖,𝑘 = 𝑒 −(𝑏1∗𝐷𝑖,𝑘)

√−ln (0,5)
Dengan : 𝑏1 = 𝜎(𝑠𝑝𝑟𝑒𝑎𝑑), spread merupakan bilangan real positif

d. Menghitung bobot pelatihan dengan menggunakan persamaan

𝑤 = (𝐺 𝑇 𝐺)−1 𝐺 𝑇 𝑑

e. Menghitung output JST RBF dengan menggunakan persamaan

𝑦 = ∑ 𝜑𝑤 + 𝑏

f. Menghitung galat (error) antara output hasil pelatihan dengan target. Persamaannya
yaitu:

𝑒𝑟𝑟𝑜𝑟 = 𝑡𝑘 − 𝑦𝑘

Keterangan rumus:

𝑥𝑖 = 𝑣𝑒𝑘𝑡𝑜𝑟 𝑖𝑛𝑝𝑢𝑡 𝑑𝑎𝑡𝑎

𝑥𝑘 = 𝑣𝑒𝑘𝑡𝑜𝑟 𝑐𝑒𝑛𝑡𝑒𝑟

𝜑 = 𝑓𝑢𝑛𝑔𝑠𝑖 𝐺𝑎𝑢𝑠𝑠𝑖𝑎𝑛
 𝜎 = 𝑛𝑖𝑙𝑎𝑖 𝑠𝑝𝑟𝑒𝑎𝑑

𝑤 = 𝑛𝑖𝑙𝑎𝑖 𝑏𝑜𝑏𝑜𝑡

𝑏 = 𝑏𝑖𝑎𝑠

𝐺 = 𝑖𝑛𝑖𝑠𝑖𝑎𝑙𝑖𝑠𝑎𝑠𝑖 𝑛𝑖𝑙𝑎𝑖 𝐺𝑎𝑢𝑠𝑠𝑖𝑎𝑛(𝜑)

𝑑 = 𝑣𝑒𝑘𝑡𝑜𝑟 𝑡𝑎𝑟𝑔𝑒𝑡

𝑦 = 𝑜𝑢𝑡𝑝𝑢𝑡 𝑅𝐵𝐹

Simulasi dan Diskusi

A. DATA IRIS

Pada data iris terdapat 150 data yang memiliki 5 atribut lalu data dipisahkan dengan
atribut kelima merupakan target dari kelasnya. Lalu data dibagi menjadi data training dan
data testing dengan jumlah data training adalah 80% dari total data dan data testing sebanyak
20% dari total data. Dari 150 tersebut data training adalah data ke 1-120 dan data testing
adalah data ke 121-150. Karena jumlah Klas pada atribut kelima terdapat 3 klas maka target
data pada atribut kelima terbagi menjadi 3 klas.

Sukses Kmeans 1 2 3 4 5 6 7 8 9 10
Training (%) 100.00 100.00 94.167 100.00 100.00 98.333 100.00 99.167 100.00 100.00
Testing (%) 100.00 100.00 99.167 100.00 100.00 100.00 99.167 100.00 100.00 99.167
Rata Training (%) 99.167
Rata Testing (%) 99.750

Sukses FCM 1 2 3 4 5 6 7 8 9 10
Training (%) 98.333 99.167 99.167 98.333 98.333 94.167 98.333 99.167 99.167 93.333
Testing (%) 100.00 100.00 99.167 100.00 100.00 99.167 100.00 100.00 100.00 99.167
Rata Training (%) 97.750
Rata Testing (%) 99.833

Error Kmeans 1 2 3 4 5 6 7 8 9 10
Training (%) 0 0 5.833 0 0 1.667 0 0.833 0 0
Testing (%) 0 0 0.833 0 0 0 0.833 0 0 0.833
Rata Training (%) 0.833
Rata Testing (%) 0.250
 Error FCM 1 2 3 4 5 6 7 8 9 10
Training (%) 1.667 0.833 0.833 1.667 1.667 5.883 1.667 0.833 0.8330 6.667
Testing (%) 0 0 0 0 0 00.833 0 0 0 0.833
Rata Training (%) 2.250
Rata Testing (%) 0.167

gambar 1 Grafik IRIS Sukses K-Means gambar 2 Grafik IRIS Sukses FCM

gambar 3 Grafik IRIS error K-Means gambar 4 Grafik IRIS error FCM
 Dari hasil simulasi menggunakan 10 iterasi, pada proses K-Means didapatkan rata-rata
sebesar 99,167% dan pada proses FCM didapatkan rata-rata sebesar 99.750% untuk data
trainingnya dan pada proses K-Means didapatkan rata-rata sebesar 97.750% dan pada proses
FCM didapatkan rata-rata sebesar 99.833% unutk data testing. Didapat perbandingan rata-
rata data training dari K-Means dan FCM sebesar 1,417% dan perbandingan rata-rata data
testing dari K-Means dan FCM sebesar 0,083% Dengan rata rata total error pada K-Means
sebesar 0,542% dan rata rata total error pada FCM sebesar 1,209%

B. DATA WINE

Pada data Wine terdapat 178 data yang memiliki 14 atribut lalu data dipisahkan dengan
atribut pertama merupakan target dari kelasnya. Lalu data dibagi menjadi data training dan
data testing dengan jumlah data training adalah 80% dari total data dan data testing sebanyak
20% dari total data. Dari 178 tersebut data training adalah data ke 1-136 dan data testing
adalah data ke 137-175. Karena jumlah Klas pada atribut pertama terdapat 3 klas maka target
data pada atribut pertama terbagi menjadi 3 klas.

Sukses Kmeans 1 2 3 4 5 6 7 8 9 10
Training (%) 97.794 99.265 100.00 99.265 97.059 98.529 100.00 98.529 97.794 99.265
Testing (%) 100.00 100.00 99.265 99.265 100.00 100.00 99.265 99.265 99.265 100
Rata Training (%) 98.750
Rata Testing (%) 99.632

Sukses FCM 1 2 3 4 5 6 7 8 9 10
Training (%) 98.529 98.529 99.265 99.265 99.265 97.794 97.794 97.794 99.265 98.529
Testing (%) 99.265 100.00 97.794 98.529 99.265 100.00 100.00 100.00 100.00 100.00
Rata Training (%) 98.603
Rata Testing (%) 99.485

Error Kmeans 1 2 3 4 5 6 7 8 9 10
Training (%) 2.206 0.735 0 0.735 2.941 1.471 0 1.471 2.206 0.735
Testing (%) 0 0 0.735 0.735 0 0 0.735 0.735 0.735 0
Rata Training (%) 1.250
Rata Testing (%) 0.368

Error FCM 1 2 3 4 5 6 7 8 9 10
Training (%) 1.471 1.471 0.735 0.735 0.735 2.206 2.206 2.206 0.735 1.471
 Testing (%) 0.735 0 2.206 1.471 0.735 0 0 0 0 0
Rata Training (%) 1.397
Rata Testing (%) 0.515

gambar 5 Grafik WINE Sukses K-Means gambar 6 Grafik WINE Sukses FCM

gambar 7 Grafik WINE error K-Means gambar 8 Grafik WINE error FCM

Dari hasil simulasi menggunakan 10 iterasi, pada proses K-Means didapatkan rata-rata
sebesar 98,750% dan pada proses FCM didapatkan rata-rata sebesar 99.632% untuk data
 trainingnya dan pada proses K-Means didapatkan rata-rata sebesar 98.603% dan pada proses
FCM didapatkan rata-rata sebesar 99.485% unutk data testing. Didapat perbandingan rata-
rata data training dari K-Means dan FCM sebesar 0,147% dan perbandingan rata-rata data
testing dari K-Means dan FCM sebesar 0,147 % Dengan rata rata total error pada K-Means
sebesar 0,809% dan rata rata total error pada FCM sebesar 0,956%

C. CAR DATA

Pada data Car evaluation terdapat 1728 data yang memiliki 7 atribut lalu data dipisahkan
dengan atribut pertama merupakan target dari kelasnya. Lalu data dibagi menjadi data
training dan data testing dengan jumlah data training adalah 80% dari total data dan data
testing sebanyak 20% dari total data. Dari 1728 tersebut data training adalah data ke 1-1383
dan data testing adalah data ke 1384-1728. Karena jumlah Klas pada atribut pertama terdapat
4 klas maka target data pada atribut pertama terbagi menjadi 4 klas.

Sukses Kmeans 1 2 3 4 5 6 7 8 9 10
Training (%) 100.00 100.00 100.00 100.00 100.00 100.00 100.00 100.00 100.00 100.00
Testing (%) 100.00 100.00 100.00 100.00 100.00 100.00 100.00 100.00 100.00 100
Rata Training (%) 100.00
Rata Testing (%) 100.00

Sukses FCM 1 2 3 4 5 6 7 8 9 10
Training (%) 100.00 100.00 100.00 100.00 100.00 100.00 100.00 100.00 100.00 100.00
Testing (%) 100.00 100.00 100.00 100.00 100.00 100.00 100.00 100.00 100.00 100.00
Rata Training (%) 100.00
Rata Testing (%) 100.00

Error Kmeans 1 2 3 4 5 6 7 8 9 10
Training (%) 0 0 0 0 0 0 0 0 0 0
Testing (%) 0 0 0 0 0 0 0 0 0 0
Rata Training (%) 0
Rata Testing (%) 0

Error FCM 1 2 3 4 5 6 7 8 9 10
Training (%) 0 0 0 0 0 0 0 0 0 0
Testing (%) 0 0 0 0 0 0 0 0 0 0
Rata Training (%) 0
Rata Testing (%) 0
 gambar 9 Grafik CAR Sukses K-Means gambar 10 Grafik CAR Sukses FCM

gambar 11 Grafik CAR error K-Means gambar 12 Grafik CAR error FCM

Dari hasil simulasi menggunakan 10 iterasi, pada proses K-Means didapatkan rata-rata
sebesar 100,00% dan pada proses FCM didapatkan rata-rata sebesar 100,00% untuk data
trainingnya dan pada proses K-Means didapatkan rata-rata sebesar 100,00% dan pada proses
FCM didapatkan rata-rata sebesar 100,00% unutk data testing. Didapat perbandingan rata-
rata data training dari K-Means dan FCM sebesar 0% dan perbandingan rata-rata data testing
dari K-Means dan FCM sebesar 0 % Dengan rata rata total error pada K-Means sebesar 0%
 dan rata rata total error pada FCM sebesar 0%. Karena variasi data yang kecil dan jumlah
data yang banyak dan yang mengakibatkan ketidaksuaian pada data sehingga mengakibatkan
proses K-Means dan FCM mendapatkan hasil 100% karena kemungkinan errornya akan
sangat kecil.

D. SALE DATA CHANNEL

Pada data Whosalse artibut Channel terdapat 440 data yang memiliki 8 atribut lalu data
dipisahkan dengan atribut pertama merupakan target dari kelasnya. Lalu data dibagi menjadi
data training dan data testing dengan jumlah data training adalah 80% dari total data dan data
testing sebanyak 20% dari total data. Dari 440 tersebut data training adalah data ke 1-352 dan
data testing adalah data ke 353-440. Karena jumlah Klas pada atribut pertama terdapat 2 klas
maka target data pada atribut pertama terbagi menjadi 2 klas.

Sukses Kmeans 1 2 3 4 5 6 7 8 9 10
Training (%) 97.443 95.455 98.011 94.318 96.023 97.443 94.886 97.159 95.171 97.159
Testing (%) 99.148 96.875 98.864 98.580 95.580 98.864 99.716 98.580 98.580 99.716
Rata Training (%) 96.307
Rata Testing (%) 98.750

Sukses FCM 1 2 3 4 5 6 7 8 9 10
Training (%) 98.580 99.432 98.580 98.864 98.864 98.864 99.716 99.432 99.148 96.307
Testing (%) 100.00 99.432 100.00 99.716 99.716 100.00 99.716 99.148 99.432 99.432
Rata Training (%) 98.778
Rata Testing (%) 99.659

Error Kmeans 1 2 3 4 5 6 7 8 9 10
Training (%) 2.557 4.545 1.989 5.682 3.977 2.557 5.114 2.841 4.829 2.841
Testing (%) 0.852 3.125 1.136 1.420 1.420 1.136 0.284 1.420 1.420 0.284
Rata Training (%) 3.693
Rata Testing (%) 1.250

Error FCM 1 2 3 4 5 6 7 8 9 10
Training (%) 1.420 0.568 1.420 1.136 1.136 1.136 0.284 0.568 0.852 3.693
Testing (%) 0 0.568 0 0.284 0.284 0 0.284 0.852 0.568 0.568
Rata Training (%) 1.222
Rata Testing (%) 0.341
 gambar 13 Grafik SALE VERSI CHANNEL gambar 14 Grafik SALE VERSI CHANNEL
Sukses K-Means Sukses FCM

gambar 15 Grafik SALE VERSI CHANNEL gambar 16 Grafik SALE VERSI CHANNEL
error K-Means error FCM

Dari hasil simulasi menggunakan 10 iterasi, pada proses K-Means didapatkan rata-rata
sebesar 96,307% dan pada proses FCM didapatkan rata-rata sebesar 98,778% untuk data
trainingnya dan pada proses K-Means didapatkan rata-rata sebesar 98,750% dan pada proses
FCM didapatkan rata-rata sebesar 99,659% unutk data testing. Didapat perbandingan rata-
rata data training dari K-Means dan FCM sebesar 2,471% dan perbandingan rata-rata data
 testing dari K-Means dan FCM sebesar 0,909% Dengan rata rata total error pada K-Means
sebesar 2,471% dan rata rata total error pada FCM sebesar 0,781%.

E. SALE DATA REGION

Pada data Whosalse artibut Region terdapat 440 data yang memiliki 8 atribut lalu data
dipisahkan dengan atribut kedua merupakan target dari kelasnya. Lalu data dibagi menjadi
data training dan data testing dengan jumlah data training adalah 80% dari total data dan data
testing sebanyak 20% dari total data. Dari 440 tersebut data training adalah data ke 1-352 dan
data testing adalah data ke 353-440. Karena jumlah Klas pada atribut kedua terdapat 3 klas
maka target data pada atribut kedua terbagi menjadi 3 klas.

Sukses Kmeans 1 2 3 4 5 6 7 8 9 10
Training (%) 96.875 99.716 100.00 99.716 97.443 98.864 95.171 98.011 100.00 98.580
Testing (%) 98.580 100.00 100.00 100.00 99.432 99.716 99.148 98.864 99.432 99.432
Rata Training (%) 98.438
Rata Testing (%) 99.460

Sukses FCM 1 2 3 4 5 6 7 8 9 10
Training (%) 99.148 98.864 98.296 99.432 99.432 98.580 100.00 99.148 100.00 98.864
Testing (%) 99.716 99.432 99.432 99.432 99.432 99.148 100.00 99.148 100.00 99.148
Rata Training (%) 99.176
Rata Testing (%) 99.489

Error Kmeans 1 2 3 4 5 6 7 8 9 10
Training (%) 3.125 0.284 0 0.284 2.557 1.136 4.829 1.989 0 1.420
Testing (%) 1.420 0 0 0 0.568 0.284 0.852 1.136 0.568 0.568
Rata Training (%) 1.562
Rata Testing (%) 0.540

Error FCM 1 2 3 4 5 6 7 8 9 10
Training (%) 0.852 1.136 1.704 0.568 0.568 1.420 0 0.852 0 1.136
Testing (%) 0.284 0.568 0.568 0.568 0.568 0.568 0 0.852 0 0.852
Rata Training (%) 0.824
Rata Testing (%) 0.511
 gambar 17 Grafik SALE VERSI REGION gambar 18 Grafik SALE VERSI REGION
Sukses K-Means Sukses FCM

gambar 19 Grafik SALE VERSI REGION gambar 20 Grafik SALE VERSI REGION
error K-Means error FCM

Dari hasil simulasi menggunakan 10 iterasi, pada proses K-Means didapatkan rata-rata
sebesar 98,438% dan pada proses FCM didapatkan rata-rata sebesar 99,176% untuk data
trainingnya dan pada proses K-Means didapatkan rata-rata sebesar 99,460% dan pada proses
FCM didapatkan rata-rata sebesar 99,489% unutk data testing. Didapat perbandingan rata-
rata data training dari K-Means dan FCM sebesar 0,738% dan perbandingan rata-rata data
 testing dari K-Means dan FCM sebesar 0,029% Dengan rata rata total error pada K-Means
sebesar 1,051% dan rata rata total error pada FCM sebesar 0,667%.

F. Tabel PCA

PCA
No Dataset Kmeans FCM
Train (%) Error (%) Test (%) Error (%) Train (%) Error (%) Test (%) Error (%)
1 Iris 99.167 0.833 99.750 0.250 97.750 2.250 99.833 0.167
2 Wine 98.750 1.250 99.632 0.368 98.603 1.397 99.485 0.515
3 Car 100.00 0 100.0 0 100.00 0 100.00 0
4 Sale 96.307 3.693 98.750 1.250 98.778 1.222 99.659 0.341
Channel
5 Sale 98.438 1.562 99.460 0.540 99.176 0.824 99.489 0.511
Region

Pada proses K-Means hasil rata-rata dari persentase data training adalah 98,532% dan
hasil rata-rata dari persentase data testing adalah 99,518% dan Pada proses FCM rata-rata
dari persentase data training adalah 98,861% dan hasil rata-rata dari persentase data testing
adalah 99,693%

Untuk kesuluruhan data, Metode FCM lebih unggul daripada metode k-means karena
kemampuannya untuk menangani ketidakpastian atau ambiguitas dalam klasterisasi data.
Metode FCM memperkenalkan konsep keanggotaan fuzzy, yang memungkinkan setiap objek
data untuk memiliki tingkat keanggotaan yang berbeda terhadap setiap klaster. dilihat dari
persentasenya walaupun dengan selisih yang tidak terlalu jauh FCM mendapatkan hasil yang
lebih baik daripada K-Means.
Daftar Pustaka

Iskandar, Iwan., & Resdifa, Eza. (2019). Penerapan Metode Radial Basis Function Dengan
Jumlah Center Dinamis Untuk Klasifikasi Serangan Jaringan Komputer. Jurnal CorelT, 5(1),
78-85.

Ristyawan, Aidina, Kusrini, & Andi Sunyoto. (2015). Pemanfaatan Algoritma FCM Dalam
Pengelompokan Kinerja Akademik Mahasiswa. Yogyakarta.

Mitchell, T. M. (1997). Machine Learning. Pittsburgh.

IRIS DATA: https://archive.ics.uci.edu/dataset/53/iris

WINE DATA: https://archive.ics.uci.edu/dataset/109/wine
CAR EVALUATE DATA: https://archive.ics.uci.edu/dataset/19/car+evaluation
WHOLE SALE DATA: https://archive.ics.uci.edu/dataset/292/wholesale+customers
Lampiran

A. DATA IRIS K-Means

clc
clear all
close all

dataAsli=load('IRISDATA.txt');

for iter=1:10
%pengacakan data
acak=randperm(size(dataAsli,1));
dataXY=dataAsli(acak,:);

%Pemisahan data dari targetnya

data=dataXY(:,1:4);
dataT=dataXY(:,5);

% Proses normalisasi
[M,N] = size(data);
mn = mean(data,1);
data = data - repmat(mn,M,1);

fprintf('------------------------------------------\n');
fprintf('Proses mereduksi variabel input dengan PCA\n')
fprintf('------------------------------------------\n');
% Mencari matriks covarian

Cx = (1/(M-1))*data'*data;

% Menghitung vektor eigen dan nilai eigen

[PC V]=eig(Cx);
V = diag(V);

sumV=sum(V(:));
persen=(V/sumV)*100;
sum1=0;
jumPC=0;
for i=1:3
sum1=sum1+persen(i);
fprintf('PC ke %4.0f : %8.4f persen \n',i,persen(i));
PCsom(:,i)=PC(:,i);
jumPC=jumPC+1;
end
fprintf('Kumulatif keragaman : %8.4f persen \n',sum1);
 % Data hasil PCA
projPC = data*PCsom;
% Proyeksi data
pseudoinv=pinv(PCsom);
dataProj=projPC*pseudoinv;
dataP=dataProj+repmat(mn,M,1);
% Menghitung error
error=((abs(data-dataP))/data)*100;
rataerror=abs(mean(mean(error)));
fprintf('Rata-rata error pada PCA :%8.4f persen
\n',rataerror);

dataP=projPC;
%Proses Klustering kmeans
p=3;
[I C]=kmeans(dataP,p);
dataKlas=[dataP, I];

for i=1:p
jumKlas (i)=0;
for j=1:size(data, 1)
if I(j)==i
jumKlas(i)=jumKlas(i)+1;
else
jumKlas(i)=jumKlas(i);
end
end
end
jumKlas

% Pembagian data training dan testing

D_train=dataKlas(1:120,1:3);
T_train=dataKlas(1:120,4);

% Algoritma Radial Basis Function

% Proses Training
sigma2=0.5;
jumC=p;
m=size(D_train,1);
% menghitung matriks gaussian
for j = 1 : jumC
for k = 1 : m
hitung = norm(D_train(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhi(j, k) = 0;
else
sumPhi(j, k) = (hitung + sigma2) ^ (1 / (1 -
m));
end
 end
end

% Perhitungan bobot RBF

invPhi=pinv(sumPhi');
Ti=full(ind2vec(T_train'));
W=invPhi*Ti';
Yakt=W'*sumPhi;

% Klasifikasi
for i=1:size(Yakt,2)
[Dmaxt(i,:),Idxt(i,:)]=max(Yakt(:,i));
end
T=I(1:120); % dari kmeans

err=0;
for i=1:size(D_train,1)

if Idxt(i)~=T(i)
err=err+1;
else
err=err;
end
end
err;
trError(iter)= sum(err);
PersenErrorTraining(iter)=(trError(iter)/m)*100
PersenKlasTraining(iter)=(abs(1-(trError(iter)/m)))*100

% Proses Testing
% data testing misalkan : data
D_test=dataKlas(121:150,1:3);
T_test=dataKlas(121:150,4);
mt=size(D_test,1);
for j = 1 : jumC
for k = 1 : mt
hitungts = norm(D_test(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhits(j, k) = 0;
else
sumPhits(j, k) = (hitungts + sigma2) ^ (1 / (1
- m));
end
end

end
Yaktts=W'*sumPhits;

for i=1:size(Yaktts,2)
 [Dmaxtts(i,:),Idxtts(i,:)]=max(Yaktts(:,i));
end

hasil=[Idxtts, T_test];

errts=0;
for i=1:mt

if Idxtts(i)~=T_test(i)
errts=errts+1;
else
errts=errts;
end
end
errts

tsError(iter)= sum(errts);
PersenErrorTesting(iter)=(tsError(iter)/m)*100;
PersenKlasTesting(iter)=(abs(1-(tsError(iter)/m)))*100;

end
tabel=[PersenErrorTraining;PersenKlasTraining; ...
PersenErrorTesting;PersenKlasTesting]'

ratarata= mean(tabel)

x=1:10
figure(1)
plot(x,PersenErrorTraining,'-*',x,PersenErrorTesting,'-o')
title('Perbandingan Error Training dan Testing')
legend('Error','True Class')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([-5 20])

x=1:10
figure(2)
plot(x,PersenKlasTraining,'-*',x,PersenKlasTesting,'-o')
title('Perbandingan Persen Training dan Testing')
legend('Training','Testing')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([90 110])
B. DATA IRIS FCM

clc
clear all
close all

dataAsli=load('IRISDATA.txt');

for iter=1:10
%pengacakan data
acak=randperm(size(dataAsli,1));
dataXY=dataAsli(acak,:);

%Pemisahan data dari targetnya

data=dataXY(:,1:4);
dataT=dataXY(:,5);

% Proses normalisasi
[M,N] = size(data);
mn = mean(data,1);
data = data - repmat(mn,M,1);

fprintf('------------------------------------------\n');
fprintf('Proses mereduksi variabel input dengan PCA\n')
fprintf('------------------------------------------\n');
% Mencari matriks covarian

Cx = (1/(M-1))*data'*data;

% Menghitung vektor eigen dan nilai eigen

[PC V]=eig(Cx);
V = diag(V);

sumV=sum(V(:));
persen=(V/sumV)*100;
sum1=0;
jumPC=0;
for i=1:3
sum1=sum1+persen(i);
fprintf('PC ke %4.0f : %8.4f persen \n',i,persen(i));
PCsom(:,i)=PC(:,i);
jumPC=jumPC+1;
end
fprintf('Kumulatif keragaman : %8.4f persen \n',sum1);

% Data hasil PCA

projPC = data*PCsom;
% Proyeksi data
 pseudoinv=pinv(PCsom);
dataProj=projPC*pseudoinv;
dataP=dataProj+repmat(mn,M,1);
% Menghitung error
error=((abs(data-dataP))/data)*100;
rataerror=abs(mean(mean(error)));
fprintf('Rata-rata error pada PCA :%8.4f persen
\n',rataerror);

dataP=projPC;

%Klustering Fuzzy C Mean

p=3;
[C,U,obj_fcn] = fcm(dataP,p);
[Cmax, I]=max(U);
dataKlas=[dataP, I'];

for i=1:p
jumKlas (i)=0;
for j=1:size(data, 1)
if I(j)==i
jumKlas(i)=jumKlas(i)+1;
else
jumKlas(i)=jumKlas(i);
end
end
end
jumKlas

% Pembagian data training dan testing

D_train=dataKlas(1:120,1:3);
T_train=dataKlas(1:120,4);

% Algoritma Radial Basis Function

% Proses Training
sigma2=0.5;
jumC=p;
m=size(D_train,1);
% menghitung matriks gaussian
for j = 1 : jumC
for k = 1 : m
hitung = norm(D_train(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhi(j, k) = 0;
else
sumPhi(j, k) = (hitung + sigma2) ^ (1 / (1 -
m));
end
end
 end

% Perhitungan bobot RBF

invPhi=pinv(sumPhi');
Ti=full(ind2vec(T_train'));
W=invPhi*Ti';
Yakt=W'*sumPhi;

% Klasifikasi
for i=1:size(Yakt,2)
[Dmaxt(i,:),Idxt(i,:)]=max(Yakt(:,i));
end
T=I(1:120); % dari kmeans

err=0;
for i=1:size(D_train,1)

if Idxt(i)~=T(i)
err=err+1;
else
err=err;
end
end
err;
trError(iter)= sum(err);
PersenErrorTraining(iter)=(trError(iter)/m)*100
PersenKlasTraining(iter)=(abs(1-(trError(iter)/m)))*100

% Proses Testing
% data testing misalkan : data
D_test=dataKlas(121:150,1:3);
T_test=dataKlas(121:150,4);
mt=size(D_test,1);
for j = 1 : jumC
for k = 1 : mt
hitungts = norm(D_test(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhits(j, k) = 0;
else
sumPhits(j, k) = (hitungts + sigma2) ^ (1 / (1
- m));
end
end

end
Yaktts=W'*sumPhits;

for i=1:size(Yaktts,2)
[Dmaxtts(i,:),Idxtts(i,:)]=max(Yaktts(:,i));
 end

hasil=[Idxtts, T_test];

errts=0;
for i=1:mt

if Idxtts(i)~=T_test(i)
errts=errts+1;
else
errts=errts;
end
end
errts

tsError(iter)= sum(errts);
PersenErrorTesting(iter)=(tsError(iter)/m)*100;
PersenKlasTesting(iter)=(abs(1-(tsError(iter)/m)))*100;

end
tabel=[PersenErrorTraining;PersenKlasTraining; ...
PersenErrorTesting;PersenKlasTesting]'

ratarata= mean(tabel)

x=1:10
figure(1)
plot(x,PersenErrorTraining,'-*',x,PersenErrorTesting,'-o')
title('Perbandingan Error Training dan Testing')
legend('Error','True Class')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([-5 20])

x=1:10
figure(2)
plot(x,PersenKlasTraining,'-*',x,PersenKlasTesting,'-o')
title('Perbandingan Persen Training dan Testing')
legend('Training','Testing')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([90 110])
C. WINE DATA K-Means

clc
clear all
close all

dataAsli=load('wine.data.txt');

for iter=1:10
%pengacakan data
acak=randperm(size(dataAsli,1));
dataXY=dataAsli(acak,:);

%Pemisahan data dari targetnya

data=dataXY(:,2:14);
dataT=dataXY(:,1);

% Proses normalisasi
[M,N] = size(data);
mn = mean(data,1);
data = data - repmat(mn,M,1);

fprintf('------------------------------------------\n');
fprintf('Proses mereduksi variabel input dengan PCA\n')
fprintf('------------------------------------------\n');
% Mencari matriks covarian

Cx = (1/(M-1))*data'*data;

% Menghitung vektor eigen dan nilai eigen

[PC V]=eig(Cx);
V = diag(V);

sumV=sum(V(:));
persen=(V/sumV)*100;
sum1=0;
jumPC=0;
for i=1:3
sum1=sum1+persen(i);
fprintf('PC ke %4.0f : %8.4f persen \n',i,persen(i));
PCsom(:,i)=PC(:,i);
jumPC=jumPC+1;
end
fprintf('Kumulatif keragaman : %8.4f persen \n',sum1);
% Data hasil PCA
projPC = data*PCsom;
% Proyeksi data
pseudoinv=pinv(PCsom);
dataProj=projPC*pseudoinv;
 dataP=dataProj+repmat(mn,M,1);
% Menghitung error
error=((abs(data-dataP))/data)*100;
rataerror=abs(mean(mean(error)));
fprintf('Rata-rata error pada PCA :%8.4f persen
\n',rataerror);

dataP=projPC;
%Proses Klustering kmeans
p=3;
[I C]=kmeans(dataP,p);
dataKlas=[dataP, I];

for i=1:p
jumKlas (i)=0;
for j=1:size(data, 1)
if I(j)==i
jumKlas(i)=jumKlas(i)+1;
else
jumKlas(i)=jumKlas(i);
end
end
end
jumKlas

% Pembagian data training dan testing

D_train=dataKlas(1:136,1:3);
T_train=dataKlas(1:136,4);

% Algoritma Radial Basis Function

% Proses Training
sigma2=0.5; %spread
jumC=p;
m=size(D_train,1);
% menghitung matriks gaussian
for j = 1 : jumC
for k = 1 : m
hitung = norm(D_train(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhi(j, k) = 0;
else
sumPhi(j, k) = (hitung + sigma2) ^ (1 / (1 -
m));
end
end
end

% Perhitungan bobot RBF

invPhi=pinv(sumPhi');
 Ti=full(ind2vec(T_train'));
W=invPhi*Ti';
Yakt=W'*sumPhi;

% Klasifikasi
for i=1:size(Yakt,2)
[Dmaxt(i,:),Idxt(i,:)]=max(Yakt(:,i));
end
T=I(1:136); % dari kmeans
% hasil=[Idxt, T];

err=0;
for i=1:size(D_train,1)

if Idxt(i)~=T(i)
err=err+1;
else
err=err;
end
end
err;
trError(iter)= sum(err);
PersenErrorTraining(iter)=(trError(iter)/m)*100
PersenKlasTraining(iter)=(abs(1-(trError(iter)/m)))*100

% Proses Testing
% data testing misalkan : data
D_test=dataKlas(137:178,1:3);
T_test=dataKlas(137:178,4);
mt=size(D_test,1);
for j = 1 : jumC
for k = 1 : mt
hitungts = norm(D_test(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhits(j, k) = 0;
else
sumPhits(j, k) = (hitungts + sigma2) ^ (1 / (1
- m));
end
end

end
Yaktts=W'*sumPhits;

for i=1:size(Yaktts,2)
[Dmaxtts(i,:),Idxtts(i,:)]=max(Yaktts(:,i));
end

hasil=[Idxtts, T_test];
 errts=0;
for i=1:mt

if Idxtts(i)~=T_test(i)
errts=errts+1;
else
errts=errts;
end
end
errts

tsError(iter)= sum(errts);
PersenErrorTesting(iter)=(tsError(iter)/m)*100;
PersenKlasTesting(iter)=(abs(1-(tsError(iter)/m)))*100;

end
tabel=[PersenErrorTraining;PersenKlasTraining; ...
PersenErrorTesting;PersenKlasTesting]'

ratarata= mean(tabel)

x=1:10
figure(1)
plot(x,PersenErrorTraining,'-*',x,PersenErrorTesting,'-o')
title('Perbandingan Error Training dan Testing')
legend('Error','True Class')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([-5 20])

x=1:10
figure(2)
plot(x,PersenKlasTraining,'-*',x,PersenKlasTesting,'-o')
title('Perbandingan Persen Training dan Testing')
legend('Training','Testing')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([90 110])
D. WINE DATA FCM

clc
clear all
close all

dataAsli=load('wine.data.txt');

for iter=1:10
%pengacakan data
acak=randperm(size(dataAsli,1));
dataXY=dataAsli(acak,:);

%Pemisahan data dari targetnya

data=dataXY(:,2:14);
dataT=dataXY(:,1);

% Proses normalisasi
[M,N] = size(data);
mn = mean(data,1);
data = data - repmat(mn,M,1);

fprintf('------------------------------------------\n');
fprintf('Proses mereduksi variabel input dengan PCA\n')
fprintf('------------------------------------------\n');
% Mencari matriks covarian

Cx = (1/(M-1))*data'*data;

% Menghitung vektor eigen dan nilai eigen

[PC V]=eig(Cx);
V = diag(V);

sumV=sum(V(:));
persen=(V/sumV)*100;
sum1=0;
jumPC=0;
for i=1:3
sum1=sum1+persen(i);
fprintf('PC ke %4.0f : %8.4f persen \n',i,persen(i));
PCsom(:,i)=PC(:,i);
jumPC=jumPC+1;
end
fprintf('Kumulatif keragaman : %8.4f persen \n',sum1);
% Data hasil PCA
projPC = data*PCsom;
% Proyeksi data
pseudoinv=pinv(PCsom);
dataProj=projPC*pseudoinv;
 dataP=dataProj+repmat(mn,M,1);
% Menghitung error
error=((abs(data-dataP))/data)*100;
rataerror=abs(mean(mean(error)));
fprintf('Rata-rata error pada PCA :%8.4f persen
\n',rataerror);

dataP=projPC;

%Klustering Fuzzy C Mean

p=3;
[C,U,obj_fcn] = fcm(dataP,p);
[Cmax, I]=max(U);
dataKlas=[dataP, I'];

for i=1:p
jumKlas (i)=0;
for j=1:size(data, 1)
if I(j)==i
jumKlas(i)=jumKlas(i)+1;
else
jumKlas(i)=jumKlas(i);
end
end
end
jumKlas

% Pembagian data training dan testing

D_train=dataKlas(1:136,1:3);
T_train=dataKlas(1:136,4);

% Algoritma Radial Basis Function

% Proses Training
sigma2=0.5;
jumC=p;
m=size(D_train,1);
% menghitung matriks gaussian
for j = 1 : jumC
for k = 1 : m
hitung = norm(D_train(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhi(j, k) = 0;
else
sumPhi(j, k) = (hitung + sigma2) ^ (1 / (1 -
m));
end
end
end
 % Perhitungan bobot RBF
invPhi=pinv(sumPhi');
Ti=full(ind2vec(T_train'));
W=invPhi*Ti';
Yakt=W'*sumPhi;

% Klasifikasi
for i=1:size(Yakt,2)
[Dmaxt(i,:),Idxt(i,:)]=max(Yakt(:,i));
end
T=I(1:136); % dari kmeans

err=0;
for i=1:size(D_train,1)

if Idxt(i)~=T(i)
err=err+1;
else
err=err;
end
end
err;
trError(iter)= sum(err);
PersenErrorTraining(iter)=(trError(iter)/m)*100
PersenKlasTraining(iter)=(abs(1-(trError(iter)/m)))*100

% Proses Testing
% data testing misalkan : data
D_test=dataKlas(137:178,1:3);
T_test=dataKlas(137:178,4);
mt=size(D_test,1);
for j = 1 : jumC
for k = 1 : mt
hitungts = norm(D_test(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhits(j, k) = 0;
else
sumPhits(j, k) = (hitungts + sigma2) ^ (1 / (1
- m));
end
end

end
Yaktts=W'*sumPhits;

for i=1:size(Yaktts,2)
[Dmaxtts(i,:),Idxtts(i,:)]=max(Yaktts(:,i));
end
 hasil=[Idxtts, T_test];

errts=0;
for i=1:mt

if Idxtts(i)~=T_test(i)
errts=errts+1;
else
errts=errts;
end
end
errts

tsError(iter)= sum(errts);
PersenErrorTesting(iter)=(tsError(iter)/m)*100;
PersenKlasTesting(iter)=(abs(1-(tsError(iter)/m)))*100;

end
tabel=[PersenErrorTraining;PersenKlasTraining; ...
PersenErrorTesting;PersenKlasTesting]'

ratarata= mean(tabel)

x=1:10
figure(1)
plot(x,PersenErrorTraining,'-*',x,PersenErrorTesting,'-o')
title('Perbandingan Error Training dan Testing')
legend('Error','True Class')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([-5 20])

x=1:10
figure(2)
plot(x,PersenKlasTraining,'-*',x,PersenKlasTesting,'-o')
title('Perbandingan Persen Training dan Testing')
legend('Training','Testing')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([90 110])
E. CAR DATA K-Means

clc
clear all
close all

dataAsli=load('cardatanew.txt');

for iter=1:10
%pengacakan data
acak=randperm(size(dataAsli,1));
dataXY=dataAsli(acak,:);

%Pemisahan data dari targetnya

data=dataXY(:,1:6);
dataT=dataXY(:,7);

% Proses normalisasi
[M,N] = size(data);
mn = mean(data,1);
data = data - repmat(mn,M,1);

fprintf('------------------------------------------\n');
fprintf('Proses mereduksi variabel input dengan PCA\n')
fprintf('------------------------------------------\n');
% Mencari matriks covarian
%
Cx = (1/(M-1))*data'*data;

% Menghitung vektor eigen dan nilai eigen

[PC V]=eig(Cx);
V = diag(V);
% V=V/M
sumV=sum(V(:));
persen=(V/sumV)*100;
sum1=0;
jumPC=0;
for i=1:4
sum1=sum1+persen(i);
fprintf('PC ke %4.0f : %8.4f persen \n',i,persen(i));
PCsom(:,i)=PC(:,i);
jumPC=jumPC+1;
end
fprintf('Kumulatif keragaman : %8.4f persen \n',sum1);
% Data hasil PCA
projPC = data*PCsom;
% Proyeksi data
pseudoinv=pinv(PCsom);
dataProj=projPC*pseudoinv;
 dataP=dataProj+repmat(mn,M,1);
% Menghitung error
error=((abs(data-dataP))/data)*100;
rataerror=abs(mean(mean(error)));
fprintf('Rata-rata error pada PCA :%8.4f persen
\n',rataerror);

dataP=projPC;
%Proses Klustering kmeans
p=4;
[I C]=kmeans(dataP,p);
dataKlas=[dataP, I];

for i=1:p
jumKlas (i)=0;
for j=1:size(data, 1)
if I(j)==i
jumKlas(i)=jumKlas(i)+1;
else
jumKlas(i)=jumKlas(i);
end
end
end
jumKlas

% Pembagian data training dan testing

D_train=dataKlas(1:1382,1:4);
T_train=dataKlas(1:1382,5);

% Algoritma Radial Basis Function

% Proses Training
sigma2=0.5;
jumC=p;
m=size(D_train,1);
% menghitung matriks gaussian
for j = 1 : jumC
for k = 1 : m
hitung = norm(D_train(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhi(j, k) = 0;
else
sumPhi(j, k) = (hitung + sigma2) ^ (1 / (1 -
m));
end
end
end

% Perhitungan bobot RBF

invPhi=pinv(sumPhi');
 Ti=full(ind2vec(T_train'));
W=invPhi*Ti';
Yakt=W'*sumPhi;

% Klasifikasi
for i=1:size(Yakt,2)
[Dmaxt(i,:),Idxt(i,:)]=max(Yakt(:,i));
end
T=I(1:1382); % dari kmeans

err=0;
for i=1:size(D_train,1)

if Idxt(i)~=T(i)
err=err+1;
else
err=err;
end
end
err;
trError(iter)= sum(err);
PersenErrorTraining(iter)=(trError(iter)/m)*100
PersenKlasTraining(iter)=(abs(1-(trError(iter)/m)))*100

% Proses Testing
% data testing misalkan : data
D_test=dataKlas(1383:1728,1:4);
T_test=dataKlas(1383:1728,5);
mt=size(D_test,1);
for j = 1 : jumC
for k = 1 : mt
hitungts = norm(D_test(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhits(j, k) = 0;
else
sumPhits(j, k) = (hitungts + sigma2) ^ (1 / (1
- m));
end
end

end
Yaktts=W'*sumPhits;

for i=1:size(Yaktts,2)
[Dmaxtts(i,:),Idxtts(i,:)]=max(Yaktts(:,i));
end

hasil=[Idxtts, T_test];
 errts=0;
for i=1:mt

if Idxtts(i)~=T_test(i)
errts=errts+1;
else
errts=errts;
end
end
errts

tsError(iter)= sum(errts);
PersenErrorTesting(iter)=(tsError(iter)/m)*100;
PersenKlasTesting(iter)=(abs(1-(tsError(iter)/m)))*100;

end
tabel=[PersenErrorTraining;PersenKlasTraining; ...
PersenErrorTesting;PersenKlasTesting]'

ratarata= mean(tabel)
x=1:10
figure(1)
plot(x,PersenErrorTraining,'-*',x,PersenErrorTesting,'-o')
title('Perbandingan Error Training dan Testing')
legend('Error','True Class')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([-5 20])

x=1:10
figure(2)
plot(x,PersenKlasTraining,'-*',x,PersenKlasTesting,'-o')
title('Perbandingan Persen Training dan Testing')
legend('Training','Testing')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([90 110])
F. CAR DATA FCM

clc
clear all
close all

dataAsli=load('cardatanew.txt');

for iter=1:10
%pengacakan data
acak=randperm(size(dataAsli,1));
dataXY=dataAsli(acak,:);

%Pemisahan data dari targetnya

data=dataXY(:,1:6);
dataT=dataXY(:,7);

% Proses normalisasi
[M,N] = size(data);
mn = mean(data,1);
data = data - repmat(mn,M,1);

fprintf('------------------------------------------\n');
fprintf('Proses mereduksi variabel input dengan PCA\n')
fprintf('------------------------------------------\n');
% Mencari matriks covarian
%
Cx = (1/(M-1))*data'*data;

% Menghitung vektor eigen dan nilai eigen

[PC V]=eig(Cx);
V = diag(V);
% V=V/M
sumV=sum(V(:));
persen=(V/sumV)*100;
sum1=0;
jumPC=0;
for i=1:4
sum1=sum1+persen(i);
fprintf('PC ke %4.0f : %8.4f persen \n',i,persen(i));
PCsom(:,i)=PC(:,i);
jumPC=jumPC+1;
end
 fprintf('Kumulatif keragaman : %8.4f persen \n',sum1);
% Data hasil PCA
projPC = data*PCsom;
% Proyeksi data
pseudoinv=pinv(PCsom);
dataProj=projPC*pseudoinv;
dataP=dataProj+repmat(mn,M,1);
% Menghitung error
error=((abs(data-dataP))/data)*100;
rataerror=abs(mean(mean(error)));
fprintf('Rata-rata error pada PCA :%8.4f persen
\n',rataerror);

dataP=projPC;

%Klustering Fuzzy C Mean

p=4;
[C,U,obj_fcn] = fcm(dataP,p);
[Cmax, I]=max(U);
dataKlas=[dataP, I'];

for i=1:p
jumKlas (i)=0;
for j=1:size(data, 1)
if I(j)==i
jumKlas(i)=jumKlas(i)+1;
else
jumKlas(i)=jumKlas(i);
end
end
end
jumKlas

% Pembagian data training dan testing

D_train=dataKlas(1:1382,1:4);
T_train=dataKlas(1:1382,5);

% Algoritma Radial Basis Function

% Proses Training
sigma2=0.5;
jumC=p;
m=size(D_train,1);
% menghitung matriks gaussian
for j = 1 : jumC
for k = 1 : m
hitung = norm(D_train(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhi(j, k) = 0;
else
 sumPhi(j, k) = (hitung + sigma2) ^ (1 / (1 -
m));
end
end
end

% Perhitungan bobot RBF

invPhi=pinv(sumPhi');
Ti=full(ind2vec(T_train'));
W=invPhi*Ti';
Yakt=W'*sumPhi;

% Klasifikasi
for i=1:size(Yakt,2)
[Dmaxt(i,:),Idxt(i,:)]=max(Yakt(:,i));
end
T=I(1:1382); % dari kmeans

err=0;
for i=1:size(D_train,1)

if Idxt(i)~=T(i)
err=err+1;
else
err=err;
end
end
err;
trError(iter)= sum(err);
PersenErrorTraining(iter)=(trError(iter)/m)*100
PersenKlasTraining(iter)=(abs(1-(trError(iter)/m)))*100

% Proses Testing
% data testing misalkan : data
D_test=dataKlas(1383:1728,1:4);
T_test=dataKlas(1383:1728,5);
mt=size(D_test,1);
for j = 1 : jumC
for k = 1 : mt
hitungts = norm(D_test(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhits(j, k) = 0;
else
sumPhits(j, k) = (hitungts + sigma2) ^ (1 / (1
- m));
end
end

end
 Yaktts=W'*sumPhits;

for i=1:size(Yaktts,2)
[Dmaxtts(i,:),Idxtts(i,:)]=max(Yaktts(:,i));
end

hasil=[Idxtts, T_test];

errts=0;
for i=1:mt

if Idxtts(i)~=T_test(i)
errts=errts+1;
else
errts=errts;
end
end
errts

tsError(iter)= sum(errts);
PersenErrorTesting(iter)=(tsError(iter)/m)*100;
PersenKlasTesting(iter)=(abs(1-(tsError(iter)/m)))*100;

end
tabel=[PersenErrorTraining;PersenKlasTraining; ...
PersenErrorTesting;PersenKlasTesting]'

ratarata= mean(tabel)
x=1:10
figure(1)
plot(x,PersenErrorTraining,'-*',x,PersenErrorTesting,'-o')
title('Perbandingan Error Training dan Testing')
legend('Error','True Class')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([-5 20])

x=1:10
figure(2)
plot(x,PersenKlasTraining,'-*',x,PersenKlasTesting,'-o')
title('Perbandingan Persen Training dan Testing')
legend('Training','Testing')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([90 110])
G. SALE DATA VERSI CHANNEL K-Means

clc
clear all
close all

dataAsli=load('wholesaledata.txt');

for iter=1:10
%pengacakan data
acak=randperm(size(dataAsli,1));
dataXY=dataAsli(acak,:);

%Pemisahan data dari targetnya

data=dataXY(:,3:8);
dataT=dataXY(:,1);

% Proses normalisasi
[M,N] = size(data);
mn = mean(data,1);
data = data - repmat(mn,M,1);

fprintf('------------------------------------------\n');
fprintf('Proses mereduksi variabel input dengan PCA\n')
fprintf('------------------------------------------\n');
% Mencari matriks covarian
Cx = (1/(M-1))*data'*data;

% Menghitung vektor eigen dan nilai eigen

[PC V]=eig(Cx);
V = diag(V);
sumV=sum(V(:));
persen=(V/sumV)*100;
sum1=0;
jumPC=0;
for i=1:2
sum1=sum1+persen(i);
fprintf('PC ke %4.0f : %8.4f persen \n',i,persen(i));
PCsom(:,i)=PC(:,i);
jumPC=jumPC+1;
end
fprintf('Kumulatif keragaman : %8.4f persen \n',sum1);
% Data hasil PCA
 projPC = data*PCsom;
% Proyeksi data
pseudoinv=pinv(PCsom);
dataProj=projPC*pseudoinv;
dataP=dataProj+repmat(mn,M,1);
% Menghitung error
error=((abs(data-dataP))/data)*100;
rataerror=abs(mean(mean(error)));
fprintf('Rata-rata error pada PCA :%8.4f persen
\n',rataerror);

dataP=projPC;
%Proses Klustering kmeans
p=2;
[I C]=kmeans(dataP,p);
dataKlas=[dataP, I];

for i=1:p
jumKlas (i)=0;
for j=1:size(data, 1)
if I(j)==i
jumKlas(i)=jumKlas(i)+1;
else
jumKlas(i)=jumKlas(i);
end
end
end
jumKlas

% Pembagian data training dan testing

D_train=dataKlas(1:352,1:2);
T_train=dataKlas(1:352,3);

% Algoritma Radial Basis Function

% Proses Training
sigma2=0.5;
jumC=p;
m=size(D_train,1);
% menghitung matriks gaussian
for j = 1 : jumC
for k = 1 : m
hitung = norm(D_train(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhi(j, k) = 0;
else
sumPhi(j, k) = (hitung + sigma2) ^ (1 / (1 -
m));
end
end
 end

% Perhitungan bobot RBF

invPhi=pinv(sumPhi');
Ti=full(ind2vec(T_train'));
W=invPhi*Ti';
Yakt=W'*sumPhi;

% Klasifikasi
for i=1:size(Yakt,2)
[Dmaxt(i,:),Idxt(i,:)]=max(Yakt(:,i));
end
T=I(1:352); % dari kmeans

err=0;
for i=1:size(D_train,1)

if Idxt(i)~=T(i)
err=err+1;
else
err=err;
end
end
err;
trError(iter)= sum(err);
PersenErrorTraining(iter)=(trError(iter)/m)*100
PersenKlasTraining(iter)=(abs(1-(trError(iter)/m)))*100

% Proses Testing
% data testing misalkan : data
D_test=dataKlas(353:440,1:2);
T_test=dataKlas(353:440,3);
mt=size(D_test,1);
for j = 1 : jumC
for k = 1 : mt
hitungts = norm(D_test(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhits(j, k) = 0;
else
sumPhits(j, k) = (hitungts + sigma2) ^ (1 / (1
- m));
end
end

end
Yaktts=W'*sumPhits;

for i=1:size(Yaktts,2)
[Dmaxtts(i,:),Idxtts(i,:)]=max(Yaktts(:,i));
 end

hasil=[Idxtts, T_test];

errts=0;
for i=1:mt

if Idxtts(i)~=T_test(i)
errts=errts+1;
else
errts=errts;
end
end
errts

tsError(iter)= sum(errts);
PersenErrorTesting(iter)=(tsError(iter)/m)*100;
PersenKlasTesting(iter)=(abs(1-(tsError(iter)/m)))*100;

end
tabel=[PersenErrorTraining;PersenKlasTraining; ...
PersenErrorTesting;PersenKlasTesting]'

ratarata= mean(tabel)
x=1:10
figure(1)
plot(x,PersenErrorTraining,'-*',x,PersenErrorTesting,'-o')
title('Perbandingan Error Training dan Testing')
legend('Error','True Class')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([-5 20])

x=1:10
figure(2)
plot(x,PersenKlasTraining,'-*',x,PersenKlasTesting,'-o')
title('Perbandingan Persen Training dan Testing')
legend('Training','Testing')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([90 110])
H. SALE DATA VERSI CHANNEL FCM

clc
clear all
close all

dataAsli=load('wholesaledata.txt');

for iter=1:10
%pengacakan data
acak=randperm(size(dataAsli,1));
dataXY=dataAsli(acak,:);

%Pemisahan data dari targetnya

data=dataXY(:,3:8);
dataT=dataXY(:,1);

% Proses normalisasi
[M,N] = size(data);
mn = mean(data,1);
data = data - repmat(mn,M,1);

fprintf('------------------------------------------\n');
fprintf('Proses mereduksi variabel input dengan PCA\n')
fprintf('------------------------------------------\n');
% Mencari matriks covarian
Cx = (1/(M-1))*data'*data;
% Menghitung vektor eigen dan nilai eigen
[PC V]=eig(Cx);
V = diag(V);

sumV=sum(V(:));
persen=(V/sumV)*100;
sum1=0;
jumPC=0;
for i=1:2
sum1=sum1+persen(i);
fprintf('PC ke %4.0f : %8.4f persen \n',i,persen(i));
PCsom(:,i)=PC(:,i);
jumPC=jumPC+1;
end
fprintf('Kumulatif keragaman : %8.4f persen \n',sum1);
% Data hasil PCA
projPC = data*PCsom;
% Proyeksi data
pseudoinv=pinv(PCsom);
dataProj=projPC*pseudoinv;
dataP=dataProj+repmat(mn,M,1);
% Menghitung error
 error=((abs(data-dataP))/data)*100;
rataerror=abs(mean(mean(error)));
fprintf('Rata-rata error pada PCA :%8.4f persen
\n',rataerror);

dataP=projPC;

%Klustering Fuzzy C Mean

p=2;
[C,U,obj_fcn] = fcm(dataP,p);
[Cmax, I]=max(U);
dataKlas=[dataP, I'];

for i=1:p
jumKlas (i)=0;
for j=1:size(data, 1)
if I(j)==i
jumKlas(i)=jumKlas(i)+1;
else
jumKlas(i)=jumKlas(i);
end
end
end
jumKlas

% Pembagian data training dan testing

D_train=dataKlas(1:352,1:2);
T_train=dataKlas(1:352,3);

% Algoritma Radial Basis Function

% Proses Training
sigma2=0.5;
jumC=p;
m=size(D_train,1);
% menghitung matriks gaussian
for j = 1 : jumC
for k = 1 : m
hitung = norm(D_train(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhi(j, k) = 0;
else
sumPhi(j, k) = (hitung + sigma2) ^ (1 / (1 -
m));
end
end
end

% Perhitungan bobot RBF

invPhi=pinv(sumPhi');
 Ti=full(ind2vec(T_train'));
W=invPhi*Ti';
Yakt=W'*sumPhi;

% Klasifikasi
for i=1:size(Yakt,2)
[Dmaxt(i,:),Idxt(i,:)]=max(Yakt(:,i));
end
T=I(1:352); % dari kmeans

err=0;
for i=1:size(D_train,1)

if Idxt(i)~=T(i)
err=err+1;
else
err=err;
end
end
err;
trError(iter)= sum(err);
PersenErrorTraining(iter)=(trError(iter)/m)*100
PersenKlasTraining(iter)=(abs(1-(trError(iter)/m)))*100

% Proses Testing
% data testing misalkan : data
D_test=dataKlas(353:440,1:2);
T_test=dataKlas(353:440,3);
mt=size(D_test,1);
for j = 1 : jumC
for k = 1 : mt
hitungts = norm(D_test(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhits(j, k) = 0;
else
sumPhits(j, k) = (hitungts + sigma2) ^ (1 / (1
- m));
end
end

end
Yaktts=W'*sumPhits;

for i=1:size(Yaktts,2)
[Dmaxtts(i,:),Idxtts(i,:)]=max(Yaktts(:,i));
end

hasil=[Idxtts, T_test];
 errts=0;
for i=1:mt

if Idxtts(i)~=T_test(i)
errts=errts+1;
else
errts=errts;
end
end
errts

tsError(iter)= sum(errts);
PersenErrorTesting(iter)=(tsError(iter)/m)*100;
PersenKlasTesting(iter)=(abs(1-(tsError(iter)/m)))*100;

end
tabel=[PersenErrorTraining;PersenKlasTraining; ...
PersenErrorTesting;PersenKlasTesting]'

ratarata= mean(tabel)
x=1:10
figure(1)
plot(x,PersenErrorTraining,'-*',x,PersenErrorTesting,'-o')
title('Perbandingan Error Training dan Testing')
legend('Error','True Class')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([-5 20])

x=1:10
figure(2)
plot(x,PersenKlasTraining,'-*',x,PersenKlasTesting,'-o')
title('Perbandingan Persen Training dan Testing')
legend('Training','Testing')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([90 110])
I. SALE DATA VERSI REGION K-Means

clc
clear all
close all

dataAsli=load('wholesaledata.txt');

for iter=1:10
%pengacakan data
acak=randperm(size(dataAsli,1));
dataXY=dataAsli(acak,:);

%Pemisahan data dari targetnya

data=dataXY(:,3:8);
dataT=dataXY(:,2);

% Proses normalisasi
[M,N] = size(data);
mn = mean(data,1);
data = data - repmat(mn,M,1);

fprintf('------------------------------------------\n');
fprintf('Proses mereduksi variabel input dengan PCA\n')
fprintf('------------------------------------------\n');
% Mencari matriks covarian
Cx = (1/(M-1))*data'*data;

% Menghitung vektor eigen dan nilai eigen

[PC V]=eig(Cx);
V = diag(V);
sumV=sum(V(:));
persen=(V/sumV)*100;
sum1=0;
jumPC=0;
for i=1:3
sum1=sum1+persen(i);
fprintf('PC ke %4.0f : %8.4f persen \n',i,persen(i));
PCsom(:,i)=PC(:,i);
jumPC=jumPC+1;
end
fprintf('Kumulatif keragaman : %8.4f persen \n',sum1);
% Data hasil PCA
projPC = data*PCsom;
% Proyeksi data
pseudoinv=pinv(PCsom);
dataProj=projPC*pseudoinv;
dataP=dataProj+repmat(mn,M,1);
% Menghitung error
 error=((abs(data-dataP))/data)*100;
rataerror=abs(mean(mean(error)));
fprintf('Rata-rata error pada PCA :%8.4f persen
\n',rataerror);

dataP=projPC;
%Proses Klustering kmeans
p=3;
[I C]=kmeans(dataP,p);
dataKlas=[dataP, I];

for i=1:p
jumKlas (i)=0;
for j=1:size(data, 1)
if I(j)==i
jumKlas(i)=jumKlas(i)+1;
else
jumKlas(i)=jumKlas(i);
end
end
end
jumKlas

% Pembagian data training dan testing

D_train=dataKlas(1:352,1:3);
T_train=dataKlas(1:352,4);

% Algoritma Radial Basis Function

% Proses Training
sigma2=0.5;
jumC=p;
m=size(D_train,1);
% menghitung matriks gaussian
for j = 1 : jumC
for k = 1 : m
hitung = norm(D_train(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhi(j, k) = 0;
else
sumPhi(j, k) = (hitung + sigma2) ^ (1 / (1 -
m));
end
end
end

% Perhitungan bobot RBF

invPhi=pinv(sumPhi');
Ti=full(ind2vec(T_train'));
W=invPhi*Ti';
 Yakt=W'*sumPhi;

% Klasifikasi
for i=1:size(Yakt,2)
[Dmaxt(i,:),Idxt(i,:)]=max(Yakt(:,i));
end
T=I(1:352); % dari kmeans

err=0;
for i=1:size(D_train,1)

if Idxt(i)~=T(i)
err=err+1;
else
err=err;
end
end
err;
trError(iter)= sum(err);
PersenErrorTraining(iter)=(trError(iter)/m)*100
PersenKlasTraining(iter)=(abs(1-(trError(iter)/m)))*100

% Proses Testing
% data testing misalkan : data
D_test=dataKlas(353:440,1:3);
T_test=dataKlas(353:440,4);
mt=size(D_test,1);
for j = 1 : jumC
for k = 1 : mt
hitungts = norm(D_test(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhits(j, k) = 0;
else
sumPhits(j, k) = (hitungts + sigma2) ^ (1 / (1
- m));
end
end

end
Yaktts=W'*sumPhits;

for i=1:size(Yaktts,2)
[Dmaxtts(i,:),Idxtts(i,:)]=max(Yaktts(:,i));
end

hasil=[Idxtts, T_test];

errts=0;
for i=1:mt
 if Idxtts(i)~=T_test(i)
errts=errts+1;
else
errts=errts;
end
end
errts

tsError(iter)= sum(errts);
PersenErrorTesting(iter)=(tsError(iter)/m)*100;
PersenKlasTesting(iter)=(abs(1-(tsError(iter)/m)))*100;

end
tabel=[PersenErrorTraining;PersenKlasTraining; ...
PersenErrorTesting;PersenKlasTesting]'

ratarata= mean(tabel)
x=1:10
figure(1)
plot(x,PersenErrorTraining,'-*',x,PersenErrorTesting,'-o')
title('Perbandingan Error Training dan Testing')
legend('Error','True Class')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([-5 20])

x=1:10
figure(2)
plot(x,PersenKlasTraining,'-*',x,PersenKlasTesting,'-o')
title('Perbandingan Persen Training dan Testing')
legend('Training','Testing')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([90 110])
J. SALE DATA VERSI REGION FCM

clc
clear all
close all

dataAsli=load('wholesaledata.txt');

for iter=1:10
%pengacakan data
acak=randperm(size(dataAsli,1));
dataXY=dataAsli(acak,:);

%Pemisahan data dari targetnya

data=dataXY(:,3:8);
dataT=dataXY(:,2);

% Proses normalisasi
[M,N] = size(data);
mn = mean(data,1);
data = data - repmat(mn,M,1);

fprintf('------------------------------------------\n');
fprintf('Proses mereduksi variabel input dengan PCA\n')
fprintf('------------------------------------------\n');
% Mencari matriks covarian
Cx = (1/(M-1))*data'*data;

% Menghitung vektor eigen dan nilai eigen

[PC V]=eig(Cx);
V = diag(V);
sumV=sum(V(:));
persen=(V/sumV)*100;
sum1=0;
jumPC=0;
for i=1:3
sum1=sum1+persen(i);
fprintf('PC ke %4.0f : %8.4f persen \n',i,persen(i));
PCsom(:,i)=PC(:,i);
jumPC=jumPC+1;
end
fprintf('Kumulatif keragaman : %8.4f persen \n',sum1);
% Data hasil PCA
projPC = data*PCsom;
% Proyeksi data
pseudoinv=pinv(PCsom);
dataProj=projPC*pseudoinv;
 dataP=dataProj+repmat(mn,M,1);
% Menghitung error
error=((abs(data-dataP))/data)*100;
rataerror=abs(mean(mean(error)));
fprintf('Rata-rata error pada PCA :%8.4f persen
\n',rataerror);

dataP=projPC;

%Klustering Fuzzy C Mean

p=3;
[C,U,obj_fcn] = fcm(dataP,p);
[Cmax, I]=max(U);
dataKlas=[dataP, I'];

for i=1:p
jumKlas (i)=0;
for j=1:size(data, 1)
if I(j)==i
jumKlas(i)=jumKlas(i)+1;
else
jumKlas(i)=jumKlas(i);
end
end
end
jumKlas

% Pembagian data training dan testing

D_train=dataKlas(1:352,1:3);
T_train=dataKlas(1:352,4);

% Algoritma Radial Basis Function

% Proses Training
sigma2=0.5;
jumC=p;
m=size(D_train,1);
% menghitung matriks gaussian
for j = 1 : jumC
for k = 1 : m
hitung = norm(D_train(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhi(j, k) = 0;
else
sumPhi(j, k) = (hitung + sigma2) ^ (1 / (1 -
m));
end
end
end
 % Perhitungan bobot RBF
invPhi=pinv(sumPhi');
Ti=full(ind2vec(T_train'));
W=invPhi*Ti';
Yakt=W'*sumPhi;

% Klasifikasi
for i=1:size(Yakt,2)
[Dmaxt(i,:),Idxt(i,:)]=max(Yakt(:,i));
end
T=I(1:352); % dari kmeans

err=0;
for i=1:size(D_train,1)

if Idxt(i)~=T(i)
err=err+1;
else
err=err;
end
end
err;
trError(iter)= sum(err);
PersenErrorTraining(iter)=(trError(iter)/m)*100
PersenKlasTraining(iter)=(abs(1-(trError(iter)/m)))*100

% Proses Testing
% data testing misalkan : data
D_test=dataKlas(353:440,1:3);
T_test=dataKlas(353:440,4);
mt=size(D_test,1);
for j = 1 : jumC
for k = 1 : mt
hitungts = norm(D_test(k, :) - C(j, :))^2;
if (hitung + sigma2) < eps
sumPhits(j, k) = 0;
else
sumPhits(j, k) = (hitungts + sigma2) ^ (1 / (1
- m));
end
end

end
Yaktts=W'*sumPhits;

for i=1:size(Yaktts,2)
[Dmaxtts(i,:),Idxtts(i,:)]=max(Yaktts(:,i));
end
 hasil=[Idxtts, T_test];

errts=0;
for i=1:mt

if Idxtts(i)~=T_test(i)
errts=errts+1;
else
errts=errts;
end
end
errts

tsError(iter)= sum(errts);
PersenErrorTesting(iter)=(tsError(iter)/m)*100;
PersenKlasTesting(iter)=(abs(1-(tsError(iter)/m)))*100;

end
tabel=[PersenErrorTraining;PersenKlasTraining; ...
PersenErrorTesting;PersenKlasTesting]'

ratarata= mean(tabel)
x=1:10
figure(1)
plot(x,PersenErrorTraining,'-*',x,PersenErrorTesting,'-o')
title('Perbandingan Error Training dan Testing')
legend('Error','True Class')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([-5 20])

x=1:10
figure(2)
plot(x,PersenKlasTraining,'-*',x,PersenKlasTesting,'-o')
title('Perbandingan Persen Training dan Testing')
legend('Training','Testing')
grid on
xlabel('Iterasi')
ylabel('Persen')
ylim([90 110])