This document provides source code for an implementation of the fuzzy c-means clustering algorithm in Java. It includes: 1) An overview of the fuzzy c-means algorithm and its concepts 2) The Java source code for a basic fuzzy c-means clustering image processing task, including comments explaining the code 3) Initialization of parameters like the input image, number of clusters, maximum iterations, and more. 4) Main steps of the fuzzy c-means algorithm like calculating membership values, cluster centers, and objective function. 5) Checks for convergence and output of the cluster assignments.

1. Contoh Program Source Code /
Algoritma Fuzzy C-
Means FCM Java C++
Algoritma Fuzzy C-Means FCM Java C++
Fuzzy C-Means (FCM)
Fuzzy C-Means (FCM) adl salah satu algoritma fuzzy clustering. Fuzzy
C-Means (FCM) adl suatu teknik pengclusteran data yg keberadaan setiap
titik data dlm suatu cluster ditentukan oleh derajat keanggotaan. Teknik ini
pertama kali diperkenalkan oleh Jim Bezdek pd tahun 1981.
Konsep dasar FCM yaitu menentukan pusat cluster , yg akan
menandai lokasi rata-rata unt setiap cluster. dg cara memperbaiki pusat
cluster & derajat keanggotaan setiap titik data secara berulang, maka akan
dapat dilihat bahwa pusat cluster akan bergerak menuju lokasi yg tepat.
Perulangan ini didasarkan pd pada minimisasi fungsi obyektif yg
menggambarkan jarak dr titik data yg diberikan ke pusat cluster yg
terbobot oleh derajat keanggotaan titik data tsb.
Algoritma Fuzzy C-Means (FCM) Java C++
Algoritma Fuzzy C-Means FCM Java C++
Logika fuzzy pertama kali dikembangkan oleh Lot섙 A. Zadeh ,
seorang ilmuan Amerika Serikat berkebangsaan Iran dr universitas
California di Barkeley, melalui tulisannya pd tahun 1965.( Munir, R. 2005).
Fuzzy secara bahasa diartikan sbg kabur / samar-samar. Suatu nilai
dapat bernilai benar / salah secara bersamaan. dlm fuzzy dikenal derajat
keanggotaan yg memiliki rentang nilai 0 (nol) hingga 1(satu). Berbeda dg
himpunan tegas yg memiliki nilai 1 / 0 (ya / tidak).
Logika fuzzy adl suatu cara yg tepat unt memetakan suatu ruang
input kedalam suatu ruang output , mempunyai nilai kontinyu. Fuzzy
dinyatakan dlm derajat dr suatu keanggotaan & derajat dr kebenaran.
Oleh sebab itu sesuatu dapat dikatakan sebagian benar & sebagian salah
pd waktu yg sama (Kusumadewi. 2003).
Clustering
Clustering adl suatu metode pengelompokan berdasarkan ukuran
kedekatan (kemiripan).Clustering beda dg group, kalau group berarti
kelompok yg sama,kondisinya kalau tdk ya pasti bukan
kelompoknya.Tetapi kalau cluster tdk harus sama akan tetapi
pengelompokannya berdasarkan pd kedekatan dr suatu karakteristik
sample yg ada
Macam-macam metode clustering :
CARI TUTORIAL + SOURCE CODE
GIVE YOUR SUPPORT
6,1 rb orang menyukai ini. Jadilah yang
pertama di antara teman Anda.
Suka
ARTIKEL TERKAIT
.
LIST TUTORIAL
Berbasis Metode Statistikk
Algoritma Genetika TSP Dengan
Java
Tutorial Kriptogra섙 Dengan Java
C++
Naive Bayes Classi섙cation Visual
Basic
Kriptogra섙 Rijndael AES Java C++
Python
Pengenalan Wajah Dengan
Eigenface
Metode Secant C/C++ Java
PCA Pengenalan Wajah
Eigenface (Face Recognition)
Naive Bayes Classi섙cation Java
VB
Travelling Salesman problem
(TSP) C/C++
Algoritma Fuzzy C-Means FCM
Java C++
ACO
Adaboost
Adaptive Resonance Theory

2. Fuzzy C-Means
Fuzzy clustering adl proses menentukan derajat keanggotaan , &
kemudian memakainya dg memasukkannya kedalam elemen data
kedalam satu kelompok cluster / lebih.
Hal ini akan memberikan informasi kesamaan dr setiap objek. Satu dr
sekian banyaknya algoritma fuzzy clustering yg dipakai adl algoritma fuzzy
clustering c means. Vektor dr fuzzy clustering, V={v1, v2, v3,…, vc} ,
adl sebuah fungsi objektif yg di defenisikan dg derajat keanggotaan dr
data Xj & pusat cluster Vj .
Algoritma fuzzy clustering c means membagi data yg tersedia dr setiap
elemen data berhingga lalu memasukkannya kedalam bagian dr koleksi
cluster yg dipengaruhi oleh beberapa kriteria yg diberikan. Berikan satu
kumpulan data berhingga. X= {x1,…, xn } & pusat data.
Dimana μ ij adl derajat keanggotaan dr Xj & pusat cluster adl
sebuah bagian dr keanggotaan matriks [μ ij] . d2 adalahakar dr
Euclidean distance & m adl parameter fuzzy yg rata-rata derajat kekaburan
dr setiap data derajat keanggotaan tdk lebih besar dr 1,0 Ravichandran
(2009).
Output dr Fuzzy C-Means adl deretan pusat cluster & beberapa derajat
keanggotaan unt tiap-tiap titik data. Informasi ini dapat dipakai unt
membangun suatu fuzzy inference system .
Output dr FCM bukan adl fuzzy inference system, namun adl deretan
pusat cluster & beberapa derajat keanggotaan unt tiap-tiap titik data.
Informasi ini dapat dipakai unt membangun suatu fuzzy inference system.
Algoritma Fuzzy C-means clustering adl sbg berikut :
1. Menentukan:
Matriks X yg adl data yg akan dicluster, berukuran k x j, dg k =
jumlah data yg akan di-cluster & j = jumlah variabel/atribut (kriteria).
2. Menentukan :
a. Jumlah cluster yg akan dibentuk (n >c ≥ 2).
b. pembobot (w > 1) .
c. Maksimum iterasi (max n) .
Hirarchical clustering method : pd kasus unt
jumlah kelompok blm ditentukan terlebih dulu,
contoh data-data hasil survey kuisioner. Macam-
metode jenis ini: Single Lingkage,Complete
Linkage,Average Linkage dll.
Non Hirarchical clustering method : Jumlah
kelompok telah ditentukan terlebih dulu.Metode yg
dipakai : K-Means.
Berbasis Fuzzy : Fuzzy C­Means
Berbasis Neural Network : Kohonen SOM, LVQ
Metode lain unt optimasi centroid / lebar cluster : Genetik Algoritma (GA)
Advanced Encryption Standard
AES
Agglomerative Clustering
AHP
Analytical Hierarchy Process
ANFIS
ANN
Annealing
Ant Colony Optimization
Aplikasi n-Tier
Apriori
ARIMA (Box-Jenkins)
Aritmetika Modulo
ART
Arti섙cial Bee Colony (ABC)
Arti섙cial Neural Network
B-Tree
Backpropagation
Bacterial foraging optimization
algorithm (BFOA)
Bayesian Network
Bi-Polar Slope One
Biometrik
Bit-Plane Complexity
Blind signature
Blow섙sh
BPCS
Breadth-First Search ( BFS )
Brute Force
Buble Sort
Burrows Wheeler
Transformation
BWT
C-Means
C4.5
Caesar
CART (Classi섙cation And
Regression Trees)
Case Based Reasoning
CBR
Certainty Factor (CF)
Cipher
Cipher Block Chaining (CBC)
CISM
Clonal Selection
CLONALG
Clustering
COBIT

3. d. Kriteria penghentian/treshold ( ɛ = nilai positif yg sangat kecil).
e. Menentukan fungsi obyektif awal ( P0 ).
3. Membentuk matriks partisi awal U (derajat keanggotaan dlm
cluster) dg ukuran k x i; matriks partisi biasanya dibuat acak, , dg k =
jumlah data yg akan di-cluster & i = jumlah cluster
4. Hitung pusat cluster ( V ) unt setiap cluster, memakai rumus :
Keterangan :
Vij = pusat cluster pd cluster ke-i & atribut ke-j.
μik = data partisi (pada matriks U) pd cluster ke-i & data
ke-k.
Xk j = data (pada matriks U) pd atribut ke-j & data ke-k.
w = pembobot.
5. Hitung nilai obyektif ( Pn ) dg rumus :
Keterangan :
μik = data partisi (pada matriks U) pd cluster ke-i & data
ke-k.
dik = fungsi ukuran jarak unt jarak Euclidean pd pusat
cluster ke-i & data ke-k.
w = pembobot.
Pn = nilai obyektif pd iterasi ke-n.
6. Perbaiki derajat keanggotaan setiap data pd setiap cluster (perbaiki
matriks partisi)
dengan :
Keterangan :
μik = data partisi (pada matriks U) pd pusat cluster ke-i
& data ke-k.
dik = fungsi ukuran jarak unt jarak Euclidean pd pusat
cluster ke-i & data ke-k.
djk = fungsi ukuran jarak unt jarak Euclidean pd pusat
cluster ke-j & data ke-k.
w = pembobot.
Xkj = data (pada matriks U) pd atribut ke-j & data ke-k.
7. Menghentikan iterasi jika pusat cluster V tdk berubah. Alternatif
kriteria penghentian adalah jika perubahan nilai error kurang dr treshold
Conjugate Gradient
CRC
Cyclic Redundancy Code
Data Encryption Standard ( DES )
Data Mining
DCPChiper
Delta Rule
Deteksi Mata
Deteksi Wajah
Digital Signal Processing (DSP)
Digital Signature
Dijkstra
Discrete Cosine Transform (DCT)
Discrete Wavelet Transform
Djikstra
DTW
Dynamic Source Routing
ECDSA
Eigenface
Elgamal
Elliptic Curve Cryptography
(ECC)
Enkripsi Dekripsi
Enterprise Resource Planning
ERP
Euclid
Expectation Maximization
Extendible Hashing
Face Detection
Face Extractor
Face Recognition
Facebook
Fast Data Encipherment ( FEAL )
FCFS
FCM
Filterbank
Fireꍹ‫ﵑ‬y FA
First Come First Server
Fisherface
Floyd Warshall
Forecasting
Forward Chaining
FP-Growth
Fuzzy
Fuzzy ART
Fuzzy C-Means

4. |Pn - Pn-1| < ɛ . Alternatif adl ketika perulangan melebihi maksimum
iterasi ( n > max n) . Jika iterasi blm berhenti, kembali ke langkah 4.
8. Jika iterasi berhenti, ditentukan cluster dr tiap-tiap data . Cluster dipilih
berdasarkan nilai matriks partisi terbesar.
CONTOH PROGRAM
JAVA : Contoh Program Algoritma Fuzzy C-Means
(FCM)
Berikut ini adalah contoh penerapan program implementasi algoritma
fuzzy c-means dengan menggunakan bahasa pemrograman Java.
Source Code Java
1. import java.awt.Point;
2. import java.awt.image.ColorModel;
3. import java.awt.image.DataBuffer;
4. import java.awt.image.Raster;
5. import java.awt.image.SampleModel;
6. import java.awt.image.WritableRaster;
7. import java.util.Random;
8. import javax.media.jai.PlanarImage;
9. import javax.media.jai.TiledImage;
10. import com.sun.media.jai.codecimpl.util.RasterFactory;
11. import common.ImageProcessingTask;
12.
13. /**
14. * This class implements a basic Fuzzy C‐Means clustering
algorithm as an
15. * image processing task.
16. */
17. public class FuzzyCMeansImageClustering extends
ImageProcessingTask
18. {
19. // A copy of the input image.
20. private PlanarImage pInput;
21. // The input image dimensions.
22. private int width,height,numBands;
23. // Some clustering parameters.
24. private int maxIterations,numClusters;
25. // The FCM additional parameters and membership function
values.
26. private float fuzziness; // "m"
27. private float[][][] membership;
28. // The iteration counter will be global so we can get its
value on the
29. // middle of the clustering process.
30. private int iteration;
31. // A metric of clustering "quality", called "j" as in the
equations.
32. private double j = Float.MAX_VALUE;
33. // A small value, if the difference of the cluster
"quality" does not
34. // changes beyond this value, we consider the clustering
converged.
35. private double epsilon;
36. // This flag will be true when the clustering has finished.
37. private boolean hasFinished = false;
38. private long position;
39. // The cluster centers.
Gauss-Jordan
Gaussian
Generate & Test
Genetika
Graph Coloring
greedy
Green Computing
Guaranteed Scheduling (GS)
Haar Cascade Classi섙er
Hash
Hash Satu Arah
Hidden Markov Model (HMM)
Histogram Equalization
Hopcroft Tarjan Planarity
Hopcroft–Karp
Hop섙eld
Hu㗊喟man
Hybrid
ID3 (Iterative Dichotomiser 3)
Identity Based Encryption
image processing
Implementasi
Independent Component
Analysis (ICA)
Iris Recognition
IS Strategic Planning
Jaringan Syaraf Tiruan (JST)
Josephus Problem
JST
K-means
K-Nearest Neighbors (KNN)
KASUMI
knowledge management
Kohonen
kriptogra섙
Kruskal
Latent Semantic Indexing
Least Signi섙cant Bit (LSB)
Linear Programming
Linked List
Logika Fuzzy
LOKI
LOOK
Low Bit Coding
LSB
LSI
Mac

5. 40. private float[][] clusterCenters;
41. // A big array with all the input data and a small one for
a single pixel.
42. private int[] inputData;
43. private float[] aPixel;
44. // A big array with the output data (cluster indexes).
45. private short[][] outputData;
46.
47. /**
48. * The constructor for the class, which sets the input
image, the number of
49. * desired clusters, the maximum number of iterations, the
fuzziness ("m"
50. * value) and a value that will be used to decide whether
the convergence
51. * has stopped. It also allocates the required memory.
52. */
53. public FuzzyCMeansImageClustering(PlanarImage pInput,int
numClusters,int maxIterations,
54. float fuzziness,double
epsilon)
55. {
56. this.pInput = pInput;
57. // Get the image dimensions.
58. width = pInput.getWidth();
59. height = pInput.getHeight();
60. numBands = pInput.getSampleModel().getNumBands();
61. // Get some clustering parameters.
62. this.numClusters = numClusters;
63. this.maxIterations = maxIterations;
64. this.fuzziness = fuzziness;
65. this.epsilon = epsilon;
66. iteration = 0;
67. // We need arrays to store the clusters' centers,
validity tags and membership values.
68. clusterCenters = new float[numClusters][numBands];
69. membership = new float[width][height][numClusters];
70. // Gets the raster for the input image.
71. Raster raster = pInput.getData();
72. // Gets the whole image data on memory. Get memory for a
single pixel too.
73. inputData = new int[width*height*numBands];
74. aPixel = new float[numBands];
75. // Gets memory for the output data (cluster indexes).
76. outputData = new short[width][height];
77. raster.getPixels(0,0,width,height,inputData);
78. // Initialize the membership functions randomly.
79. Random generator = new Random(); // easier to debug if a
seed is used
80. // For each data point (in the membership function table)
81. for(int h=0;h<height;h++)
82. for(int w=0;w<width;w++)
83. {
84. // For each cluster's membership assign a random
value.
85. float sum = 0f;
86. for(int c=0;c<numClusters;c++)
87. {
88. membership[w][h][c] = 0.01f+generator.nextFloat();
89. sum += membership[w][h][c];
90. }
Maksimum Likelihood
Mamdani
MANET
MDF
Mel-frequency Cepstrum
Coe▢톌cients (MFCC)
Metode Fisherface
Metode Gra섙k
metode LSB
Metode Mamdani
Metode Secant
MFCC
Minimax
Minimum Spanning Tree
mobile
Mobile Ad hoc Network
Modi섙ed Direction Feature
Monte Carlo
MTVRP
Naive Bayes
Naive Bayes Classi섙er
negascout
Neural Network
Newton Raphson
One Way Hash
Online Learning
Open Shortest Path First
Open System Interconnection
Optimasi
OS X
OSI
OSPF
Otsu
Pagerank
Parity Coding
Particle Swarm Optimization
(PSO)
Pattern Recognition
PCA
Pemrograman Linear
Pencarian Akar
Pencarian Jalur Terpendek
Pencarian Linear
Pencocokan Sidik Jari
Pengenalan Iris Mata
Pengenalan Objeck
Pengenalan Pola

6. 91. // Normalize so the sum of MFs for a particular data
point will be equal to 1.
92. for(int c=0;c<numClusters;c++) membership[w][h][c] /=
sum;
93. }
94. // Initialize the global position value.
95. position = 0;
96. }
97.
98. /**
99. * This method performs the bulk of the processing. It runs
the classic
100. * Fuzzy C‐Means clustering algorithm:
101. */
102. public void run()
103. {
104. double lastJ;
105. // Calculate the initial objective function just for
kicks.
106. lastJ = calculateObjectiveFunction();
107. // Do all required iterations (until the clustering
converges)
108. for(iteration=0;iteration<maxIterations;iteration++)
109. {
110. // Calculate cluster centers from MFs.
111. calculateClusterCentersFromMFs();
112. // Then calculate the MFs from the cluster centers !
113. calculateMFsFromClusterCenters();
114. // Then see how our objective function is going.
115. j = calculateObjectiveFunction();
116. if (Math.abs(lastJ‐j) < epsilon) break;
117. lastJ = j;
118. } // end of the iterations loop.
119. hasFinished = true;
120. // Means that all calculations are done, too.
121. position = getSize();
122. }
123.
124. /**
125. * This method calculates the cluster centers from the
membership
126. * functions.
127. */
128. private void calculateClusterCentersFromMFs()
129. {
130. float top,bottom;
131. // For each band and cluster
132. for(int b=0;b<numBands;b++)
133. for(int c=0;c<numClusters;c++)
134. {
135. // For all data points calculate the top and bottom
parts of the equation.
136. top = bottom = 0;
137. for(int h=0;h<height;h++)
138. for(int w=0;w<width;w++)
139. {
140. // Index will help locate the pixel data
position.
141. int index = (h*width+w)*numBands;
142. top += Math.pow(membership[w][h]
[c],fuzziness)*inputData[index+b];
Pengenalan Suara
Pengenalan Ucapan
Pengenalan Wajah
Pengolahan Citra
Pengolahan Citra Digital
Pengukuran Garis-Garis Telapak
Tangan
Penjadwalan
Penjadwalan CPU
Peramalan
Perataan Histogram
Perceptron
Persamaan Linier
Pewarnaan Graf
Pewarnaan Simpul Graph
Pohon Hu㗊喟man
Prim
Principal Component Analisys
Quantum
Random Waypoint
RC4
RC6
real time tracking
Recognition
Recurrent Neural Network
Recursive Best First Search
(RBFS)
Recursive Large First
Recursive Largest First
Region of Interest (ROI)
Rijndael
Risk Management
RLF
RMSE
RNN
Root Mean square Error
RSA
RWP
SAFER
Secant
Secret Sharing Scheme
Secure And Fast Encryption
Routine (SAFER)
Self Organizing Map (SOM)
Semut
SHA (Secure Hash Algorithm)
SHA-256
Sidik Jari

7. .
143. bottom += Math.pow(membership[w][h]
[c],fuzziness);
144. }
145. // Calculate the cluster center.
146. clusterCenters[c][b] = top/bottom;
147. // Upgrade the position vector (batch).
148. position += width*height;
149. }
150. }
151.
152. /**
153. * This method calculates the membership functions from the
cluster
154. * centers.
155. */
156. private void calculateMFsFromClusterCenters()
157. {
158. float sumTerms;
159. // For each cluster and data point
160. for(int c=0;c<numClusters;c++)
161. for(int h=0;h<height;h++)
162. for(int w=0;w<width;w++)
163. {
164. // Get a pixel (as a single array).
165. int index = (h*width+w)*numBands;
166. for(int b=0;b<numBands;b++)
167. aPixel[b] = inputData[index+b];
168. // Top is the distance of this data point to the
cluster being read.
169. float top = calcDistance(aPixel,clusterCenters[c]);
170. // Bottom is the sum of distances from this data
point to all clusters.
171. sumTerms = 0f;
172. for(int ck=0;ck<numClusters;ck++)
173. {
174. float thisDistance =
calcDistance(aPixel,clusterCenters[ck]);
175. sumTerms += Math.pow(top/thisDistance,
(2f/(fuzziness‐1f)));
176. }
177. // Then the MF can be calculated as...
178. membership[w][h][c] =
179. (float)(1f/sumTerms);
180. // Upgrade the position vector (batch).
181. position += (numBands+numClusters);
182. }
183. }
184.
185. /*
186. * This method calculates the objective function ("j") which
reflects the
187. * quality of the clustering.
188. */
189. private double calculateObjectiveFunction()
190. {
191. double j = 0;
192. // For all data values and clusters
193. for(int h=0;h<height;h++)
194. for(int w=0;w<width;w++)
195. for(int c=0;c<numClusters;c++)
196. {
Simulated Annealing
SISP
Sistem Biometrika
Sistem Veri섙kasi Biometrik
Slope One
Slope One predictors
sorting
Source Code
Spanning Tree
Speech
Speech Recognition
Steganogra섙
Steganography
Stream Cipher
Support Vector Machine (SVM)
Tabu Search
Tanda Tangan Digital
Technopreneurship
Teorema Bayes
Thresholding
Transformasi Burrows Wheeler
Transformasi Fourier
Transformasi Wavelet Diskrit
Transformasi Wavelet Kontinu
Traveling Salesman Problem
Travelling Salesman (TSP)
Travelling Salesman problem
TSP
Tsukamoto
Two섙sh
Vernam Cipher
Video Encryption Algorithm
(VEA)
Video Watermarking
Vigenere Cipher
Viola Jones
Voice Recognition
Watermarking
WDM
Web Service
Weighted Slope One
Welch dan Powell
Welsh Powell
WMS

8. 197. // Get the current pixel data.
198. int index = (h*width+w)*numBands;
199. for(int b=0;b<numBands;b++)
200. aPixel[b] = inputData[index+b];
201. // Calculate the distance between a pixel and a
cluster center.
202. float distancePixelToCluster =
calcDistance(aPixel,clusterCenters[c]);
203. j += distancePixelToCluster*Math.pow(membership[w]
[h][c],fuzziness);
204. // Upgrade the position vector (batch).
205. position += (2*numBands);
206. }
207. return j;
208. }
209.
210. /**
211. * This method calculates the Euclidean distance between two
N‐dimensional
212. * vectors.
213. */
214. private float calcDistance(float[] a1,float[] a2)
215. {
216. float distance = 0f;
217. for(int e=0;e<a1.length;e++) distance += (a1[e]‐a2[e])*
(a1[e]‐a2[e]);
218. return (float)Math.sqrt(distance);
219. }
220.
221. /**
222. * This method returns the estimated size (steps) for this
task.
223. */
224. public long getSize()
225. {
226. // Return the estimated size for this task:
227. return (long)maxIterations* // The maximum number of
iterations times
228. (
229. (numClusters*width*height*(2*numBands))+ // Step 0
of method run()
230. (width*height*numBands*numClusters)+ // Step 1 of
method run()
231. (numClusters*width*height*(numBands+numClusters))+
// Step 2 of run()
232. (numClusters*width*height*(2*numBands)) // Step 3
of method run()
233. );
234. }
235.
236. /**
237. * This method returns a measure of the progress of the
algorithm.
238. */
239. public long getPosition()
240. {
241. return position;
242. }
243.
244. /**
245. * This method returns true if the clustering has finished.
246. */
247. public boolean isFinished()

9. 248. {
249. return (position == getSize());
250. }
251.
252. /**
253. * This method will return a rank image, i.e. an image which
pixels are
254. * the cluster centers of the Nth best choice for the
classification.
255. */
256. public TiledImage getRankedImage(int rank)
257. {
258. // Create a SampleModel for the output data (same number
of bands as the input image).
259. SampleModel sampleModel =
260.
RasterFactory.createBandedSampleModel(DataBuffer.TYPE_INT,wid
th,height,numBands);
261. // Create a WritableRaster using that sample model.
262. WritableRaster raster =
263. RasterFactory.createWritableRaster(sampleModel,new
Point(0,0));
264. // A pixel array will contain all bands for a specific
x,y.
265. int[] pixelArray = new int[numBands];
266. // For all pixels in the image...
267. for(int h=0;h<height;h++)
268. for(int w=0;w<width;w++)
269. {
270. // Get the class (cluster center) for that pixel with
the specified rank.
271. int aCluster = getRankedIndex(membership[w][h],rank);
272. // Fill the array with that cluster center.
273. for(int band=0;band<numBands;band++) pixelArray[band]
= (int)clusterCenters[aCluster][band];
274. // Put it on the raster.
275. raster.setPixel(w,h,pixelArray);
276. }
277. // Set the raster on the output image.
278. TiledImage pOutput = new TiledImage(pInput,false);
279. pOutput.setData(raster);
280. return pOutput;
281. }
282.
283. /**
284. * This method will return a membership function image, i.e.
285. */
286. public TiledImage getRankedMFImage(int rank)
287. {
288. // Create a SampleModel for the output data (1 band
only).
289. SampleModel sampleModel =
290.
RasterFactory.createBandedSampleModel(DataBuffer.TYPE_BYTE,
291. width,height,1);
292. // Create a compatible ColorModel.
293. ColorModel colorModel =
PlanarImage.createColorModel(sampleModel);
294. // Create a WritableRaster.
295. WritableRaster raster =
296. RasterFactory.createWritableRaster(sampleModel,new
Point(0,0));
297. // For all pixels in the image...

10. 298. for(int h=0;h<height;h++)
299. for(int w=0;w<width;w++)
300. {
301. // Get the membership function (considering the rank)
for that pixel.
302. int aCluster = (int)(255*getRankedMF(membership[w]
[h],rank));
303. // Put it on the raster.
304. raster.setPixel(w,h,new int[]{aCluster});
305. }
306. // Set the raster on the output image.
307. TiledImage pOutput = new
TiledImage(0,0,width,height,0,0,sampleModel,colorModel);
308. pOutput.setData(raster);
309. return pOutput;
310. }
311.
312. /**
313. * This method returns the ranked index of a cluster from an
array
314. * containing the membership functions.
315. */
316. private int getRankedIndex(float[] data,int rank)
317. {
318. // Create temporary arrays for the indexes and the data.
319. int[] indexes = new int[data.length];
320. float[] tempData = new float[data.length];
321. // Fill those arrays.
322. for(int i=0;i<indexes.length;i++)
323. {
324. indexes[i] = i;
325. tempData[i] = data[i];
326. }
327. // Sort both arrays together, using data as the sorting
key.
328. for(int i=0;i<indexes.length‐1;i++)
329. for(int j=i;j<indexes.length;j++)
330. {
331. if (tempData[i] < tempData[j])
332. {
333. int tempI= indexes[i];
334. indexes[i] = indexes[j];
335. indexes[j] = tempI;
336. float tempD = tempData[i];
337. tempData[i] = tempData[j];
338. tempData[j] = tempD;
339. }
340. }
341. // Return the cluster index for the rank we want.
342. return indexes[rank];
343. }
344.
345. /**
346. * This method returns the ranked membership function of a
cluster
347. */
348. private float getRankedMF(float[] data,int rank)
349. {
350. // Create temporary arrays for the indexes and the data.
351. int[] indexes = new int[data.length];
352. float[] tempData = new float[data.length];

11. 353. // Fill those arrays.
354. for(int i=0;i<indexes.length;i++)
355. {
356. indexes[i] = i;
357. tempData[i] = data[i];
358. }
359. // Sort both arrays together, using data as the sorting
key.
360. for(int i=0;i<indexes.length‐1;i++)
361. for(int j=i;j<indexes.length;j++)
362. {
363. if (tempData[i] < tempData[j])
364. {
365. int tempI= indexes[i];
366. indexes[i] = indexes[j];
367. indexes[j] = tempI;
368. float tempD = tempData[i];
369. tempData[i] = tempData[j];
370. tempData[j] = tempD;
371. }
372. }
373. // Return the cluster index for the rank we want.
374. return tempData[rank];
375. }
376.
377. /**
378. * This method returns the Partition Coefficient measure of
cluster validity
379. */
380. public double getPartitionCoefficient()
381. {
382. double pc = 0;
383. // For all data values and clusters
384. for(int h=0;h<height;h++)
385. for(int w=0;w<width;w++)
386. for(int c=0;c<numClusters;c++)
387. pc += membership[w][h][c]*membership[w][h][c];
388. pc = pc/(height*width);
389. return pc;
390. }
391.
392. /**
393. * This method returns the Partition Entropy measure of
cluster validity
394. */
395. public double getPartitionEntropy()
396. {
397. double pe = 0;
398. // For all data values and clusters
399. for(int h=0;h<height;h++)
400. for(int w=0;w<width;w++)
401. for(int c=0;c<numClusters;c++)
402. pe += membership[w][h][c]*Math.log(membership[w][h]
[c]);
403. pe = ‐pe/(height*width);
404. return pe;
405. }
406.
407. /**
408. * This method returns the Compactness and Separation
measure of cluster validity

12. C++ : Contoh Program Algoritma Fuzzy C-Means
(FCM)
Berikut ini adalah contoh penerapan program implementasi algoritma
fuzzy c-means dengan menggunakan bahasa pemrograman C++.
FCM.C
409. */
410. public double getCompactnessAndSeparation()
411. {
412. double cs = 0;
413. // For all data values and clusters
414. for(int h=0;h<height;h++)
415. for(int w=0;w<width;w++)
416. {
417. // Get the current pixel data.
418. int index = (h*width+w)*numBands;
419. for(int b=0;b<numBands;b++)
420. aPixel[b] = inputData[index+b];
421. for(int c=0;c<numClusters;c++)
422. {
423. // Calculate the distance between a pixel and a
cluster center.
424. float distancePixelToCluster =
calcSquaredDistance(aPixel,clusterCenters[c]);
425. cs += membership[w][h][c]*membership[w][h][c]*
426.
distancePixelToCluster*distancePixelToCluster;
427. }
428. }
429. cs /= (height*width);
430. // Calculate minimum distance between ALL clusters
431. float minDist = Float.MAX_VALUE;
432. for(int c1=0;c1<numClusters‐1;c1++)
433. for(int c2=c1+1;c2<numClusters;c2++)
434. {
435. float distance =
calcSquaredDistance(clusterCenters[c1],clusterCenters[c2]);
436. minDist = Math.min(minDist,distance);
437. }
438. cs = cs/(minDist*minDist);
439. return cs;
440. }
441.
442. /**
443. * This method calculates the squared distance between two
N‐dimensional
444. */
445. private float calcSquaredDistance(float[] a1,float[] a2)
446. {
447. float distance = 0f;
448. for(int e=0;e<a1.length;e++) distance += (a1[e]‐a2[e])*
(a1[e]‐a2[e]);
449. return (float)distance;
450. }
451.
452. }
453.

13. Source Code C++
1. #define MAX_DATA_POINTS 10000
2. #define MAX_CLUSTER 100
3. #define MAX_DATA_DIMENSION 5
4. #include <math.h>
5. #include <stdio.h>
6. #include <stdlib.h>
7. #include <string.h>
8.
9. int num_data_points;
10. int num_clusters;
11. int num_dimensions;
12. double low_high[MAX_DATA_DIMENSION][2];
13. double degree_of_memb[MAX_DATA_POINTS][MAX_CLUSTER];
14. double epsilon;
15. double fuzziness;
16. double data_point[MAX_DATA_POINTS][MAX_DATA_DIMENSION];
17. double cluster_centre[MAX_CLUSTER][MAX_DATA_DIMENSION];
18.
19. int
20. init(char *fname) {
21. int i, j, r, rval;
22. FILE *f;
23. double s;
24. if ((f = fopen(fname, "r")) == NULL) {
25. printf("Gagal membuka file input.");
26. return ‐1;
27. }
28. fscanf(f, "%d %d %d", &num_data_points, &num_clusters,
&num_dimensions);
29. if (num_clusters > MAX_CLUSTER) {
30. printf("Jumlah cluster harus < %dn", MAX_CLUSTER);
31. goto failure;
32. }
33. if (num_data_points > MAX_DATA_POINTS) {
34. printf("Jumlah titik data harus < %dn",
MAX_DATA_POINTS);
35. goto failure;
36. }
37. if (num_dimensions > MAX_DATA_DIMENSION) {
38. printf("Jumlah dimensi harus >= 1.0 and < %dn",
39. MAX_DATA_DIMENSION);
40. goto failure;
41. }
42. fscanf(f, "%lf", &fuzziness);
43. if (fuzziness <= 1.0) {
44. printf("Koefisien Fuzzyness harus > 1.0n");
45. goto failure;
46. }
47. fscanf(f, "%lf", &epsilon);
48. if (epsilon <= 0.0 || epsilon > 1.0) {
49. printf("Kriteria terminasi harus > 0.0 and <=
1.0n");
50. goto failure;
51. }
52. for (i = 0; i < num_data_points; i) {
53. for (j = 0; j < num_dimensions; j) {
54. fscanf(f, "%lf", &data_point[i][j]);

14. 55. if (data_point[i][j] < low_high[j][0])
56. low_high[j][0] = data_point[i][j];
57. if (data_point[i][j] > low_high[j][1])
58. low_high[j][1] = data_point[i][j];
59. }
60. }
61. for (i = 0; i < num_data_points; i) {
62. s = 0.0;
63. r = 100;
64. for (j = 1; j < num_clusters; j) {
65. rval = rand() % (r 1);
66. r ‐= rval;
67. degree_of_memb[i][j] = rval / 100.0;
68. s = degree_of_memb[i][j];
69. }
70. degree_of_memb[i][0] = 1.0 ‐ s;
71. }
72. fclose(f);
73. return 0;
74. failure:
75. fclose(f);
76. exit(1);
77. }
78.
79. int
80. calculate_centre_vectors() {
81. int i, j, k;
82. double numerator, denominator;
83. double t[MAX_DATA_POINTS][MAX_CLUSTER];
84. for (i = 0; i < num_data_points; i) {
85. for (j = 0; j < num_clusters; j) {
86. t[i][j] = pow(degree_of_memb[i][j], fuzziness);
87. }
88. }
89. for (j = 0; j < num_clusters; j) {
90. for (k = 0; k < num_dimensions; k) {
91. numerator = 0.0;
92. denominator = 0.0;
93. for (i = 0; i < num_data_points; i) {
94. numerator = t[i][j] * data_point[i][k];
95. denominator = t[i][j];
96. }
97. cluster_centre[j][k] = numerator / denominator;
98. }
99. }
100. return 0;
101. }
102.
103. double
104. get_norm(int i, int j) {
105. int k;
106. double sum = 0.0;
107. for (k = 0; k < num_dimensions; k) {
108. sum = pow(data_point[i][k] ‐ cluster_centre[j][k],
2);
109. }
110. return sqrt(sum);
111. }
112.

15. 113. double
114. get_new_value(int i, int j) {
115. int k;
116. double t, p, sum;
117. sum = 0.0;
118. p = 2 / (fuzziness ‐ 1);
119. for (k = 0; k < num_clusters; k) {
120. t = get_norm(i, j) / get_norm(i, k);
121. t = pow(t, p);
122. sum = t;
123. }
124. return 1.0 / sum;
125. }
126.
127. double
128. update_degree_of_membership() {
129. int i, j;
130. double new_uij;
131. double max_diff = 0.0, diff;
132. for (j = 0; j < num_clusters; j) {
133. for (i = 0; i < num_data_points; i) {
134. new_uij = get_new_value(i, j);
135. diff = new_uij ‐ degree_of_memb[i][j];
136. if (diff > max_diff)
137. max_diff = diff;
138. degree_of_memb[i][j] = new_uij;
139. }
140. }
141. return max_diff;
142. }
143.
144. int
145. fcm(char *fname) {
146. double max_diff;
147. init(fname);
148. do {
149. calculate_centre_vectors();
150. max_diff = update_degree_of_membership();
151. } while (max_diff > epsilon);
152. return 0;
153. }
154.
155. int
156. gnuplot_membership_matrix() {
157. int i, j, cluster;
158. char fname[100];
159. double highest;
160. FILE * f[MAX_CLUSTER];
161. if (num_dimensions != 2) {
162. printf("Merencanakan cluster hanya bekerja
ketikan");
163. printf("jumlah dimensi adl dua. Ini akan membuatn");
164. printf("plot dua dimensi poin klaster.n");
165. exit(1);
166. }
167. for (j = 0; j < num_clusters; j) {
168. sprintf(fname, "cluster.%d", j);
169. if ((f[j] = fopen(fname, "w")) == NULL) {
170. printf("Tidak dapat membuat %sn", fname);

16. 171. for (i = 0; i < j; i) {
172. fclose(f[i]);
173. sprintf(fname, "cluster.%d", i);
174. remove(fname);
175. }
176. return ‐1;
177. }
178. fprintf(f[j], "#Titik data unt klaster: %dn", j);
179. }
180. for (i = 0; i < num_data_points; i) {
181. cluster = 0;
182. highest = 0.0;
183. for (j = 0; j < num_clusters; j) {
184. if (degree_of_memb[i][j] > highest) {
185. highest = degree_of_memb[i][j];
186. cluster = j;
187. }
188. }
189. fprintf(f[cluster], "%lf %lfn", data_point[i][0],
data_point[i][1]);
190. }
191. for (j = 0; j < num_clusters; j) {
192. fclose(f[j]);
193. }
194. if ((f[0] = fopen("gnuplot.script", "w")) == NULL) {
195. printf("Tidak dapat membuat gnuplot.script.n");
196. for (i = 0; i < j; i) {
197. fclose(f[i]);
198. sprintf(fname, "cluster.%d", i);
199. remove(fname);
200. }
201. return ‐1;
202. }
203. fprintf(f[0], "set terminal png mediumn");
204. fprintf(f[0], "set output "cluster_plot.png"n");
205. fprintf(f[0], "set title "FCM clustering"n");
206. fprintf(f[0], "set xlabel "x‐coordinate"n");
207. fprintf(f[0], "set ylabel "y‐coordinate"n");
208. fprintf(f[0], "set xrange [%lf : %lf]n", low_high[0][0],
low_high[0][1]);
209. fprintf(f[0], "set yrange [%lf : %lf]n", low_high[1][0],
low_high[1][1]);
210. fprintf(f[0],
211. "plot 'cluster.0' using 1:2 with points pt 7 ps 1
lc 1 notitle");
212. for (j = 1; j < num_clusters; j) {
213. sprintf(fname, "cluster.%d", j);
214. fprintf(f[0],
215. ",n'%s' using 1:2 with points pt 7 ps 1
lc %d notitle",
216. fname, j 1);
217. }
218. fprintf(f[0], "n");
219. fclose(f[0]);
220. return 0;
221. }
222.
223. void
224. print_data_points(char *fname) {
225. int i, j;
226. FILE *f;

17. 227. if (fname == NULL)
228. f = stdout;
229. else if ((f = fopen(fname, "w")) == NULL) {
230. printf("Cannot create output file.n");
231. exit(1);
232. }
233. fprintf(f, "Data points:n");
234. for (i = 0; i < num_data_points; i) {
235. printf("Data[%d]: ", i);
236. for (j = 0; j < num_dimensions; j) {
237. printf("%.5lf ", data_point[i][j]);
238. }
239. printf("n");
240. }
241. if (fname == NULL)
242. fclose(f);
243. }
244.
245. void
246. print_membership_matrix(char *fname) {
247. int i, j;
248. FILE *f;
249. if (fname == NULL)
250. f = stdout;
251. else if ((f = fopen(fname, "w")) == NULL) {
252. printf("Cannot create output file.n");
253. exit(1);
254. }
255. fprintf(f, "Membership matrix:n");
256. for (i = 0; i < num_data_points; i) {
257. fprintf(f, "Data[%d]: ", i);
258. for (j = 0; j < num_clusters; j) {
259. fprintf(f, "%lf ", degree_of_memb[i][j]);
260. }
261. fprintf(f, "n");
262. }
263. if (fname == NULL)
264. fclose(f);
265. }
266.
267. int
268. main(int argc, char **argv) {
269. printf
270. ("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐n");
271. if (argc != 2) {
272. printf("USAGE: fcm <input file>n");
273. exit(1);
274. }
275. fcm(argv[1]);
276. printf("Jumlah titik data: %dn", num_data_points);
277. printf("Jumlah cluster: %dn", num_clusters);
278. printf("Jumlah dimensi data titik: %dn",
num_dimensions);
279. printf("Margin akurasi: %lfn", epsilon);
280. print_membership_matrix("membership.matrix");
281. gnuplot_membership_matrix();
282. printf
283. ("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐n");

18. gen.c
Source Code C++
284. printf("Program berhasil dijalankan...n");
285. printf("Menyimpan matriks keanggotaan dlm file
'membership.matrix'nn");
286. printf("Jika poin di bidang (2 dimensi)n");
287. printf("script gnuplot dihasilkan dlm file
'gnuplot.script', andn");
288. printf("data gnuplot dlm file klaster.[0]... nn");
289. printf
290. ("Proses 'gnuplot.script' to generate graph:
'cluster_plot.png'nn");
291. printf
292. ("CATATAN: Sementara menghasilkan data gnuplot,
unt masing‐masing titik datan");
293. printf("cluster yg sesuai adl salah satu yg memiliki
tertinggin");
294. printf("derajat keanggotaan ditemukan di
'membership.matrix'.n");
295. printf
296. ("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐n");
297. return 0;
298. }
299.
1. /**
2. * Ini menghasilkan data unt menguji algoritma FCM.
3. */
4. #include <math.h>
5. #include <stdio.h>
6. #include <stdlib.h>
7. #include <string.h>
8.
9. /* Jumlah maksimum cluster diperbolehkan oleh implementasi
ini. */
10. #define MAX_CLUSTER 100
11.
12. /* Jumlah maksimum titik data yg harus dihasilkan. */
13. #define MAX_DATA 10000
14.
15. /* Jumlah maksimum dimensi dr data titik. */
16. #define MAX_DATA_DIMENSION 5
17.
18. int main(int argc, char **argv) {
19. int n, c, d, i, j;
20. int l[MAX_DATA_DIMENSION], h[MAX_DATA_DIMENSION];
21. double epsilon, m;
22. FILE *f;
23. if (argc != 2) {
24. printf("memakai: gen <filename>n");
25. exit(1);
26. }
27. printf("nProgram ini menghasilkan titik data acakn");
28. printf("untuk menguji algoritma FCM.nn");
29. do {
30. printf("Masukkan jumlah titik data.n");
31. printf("Nilai harus >= 1 & < %d: ", MAX_DATA);
HOME JASA PROGRAMMER HARGA ORDER ABOUT TUTORIAL

19. 32. if (scanf("%d", &n) == EOF)
33. continue;
34. } while (n < 1 || n > MAX_DATA);
35. do {
36. printf("Masukkan jumlah cluster.n");
37. printf("Nilai harus >= 2 and < %d: ", MAX_CLUSTER);
38. if (scanf("%d", &c) == EOF)
39. continue;
40. } while (c < 2 || c > MAX_CLUSTER);
41. do {
42. printf("asukkan kriteria terminasi (epsilon).n");
43. printf("Nilai harus >= 0.0 & <= 1.0: ");
44. if (scanf("%lf", &epsilon) == EOF)
45. continue;
46. } while (epsilon < 0 || epsilon > 1.0);
47. do {
48. printf("Masukkan koefisien fuzzyness.n");
49. printf("Nilai harus > 1.0: ");
50. if (scanf("%lf", &m) == EOF)
51. continue;
52. } while (m <= 1.0);
53. do {
54. printf("Masukkan jumlah dimensi.n");
55. printf("Nilai harus >= 1 & < %d: ", MAX_DATA_DIMENSION);
56. if (scanf("%d", &d) == EOF)
57. continue;
58. } while (d < 1 || d > MAX_DATA_DIMENSION);
59. printf("nProgram ini akan menghasilkan acak titik data dg
memakain");
60. printf("terendah & tertinggi nilai diperbolehkan unt dimensi
tertentu.n");
61. printf("Nilai tertinggi harus lebih besar dr nilai
terendahn");
62. printf("untuk dimensi tertentu.n");
63. for (i = 0; i < d; i) {
64. do {
65. printf("Masukkan nilai terendah unt dimensi [%d]: ", i);
66. if (scanf("%d", &l[i]) == EOF)
67. continue;
68. printf("Masukkan nilai tertinggi unt dimensi[%d]: ", i);
69. if (scanf("%d", &h[i]) == EOF)
70. continue;
71. } while (l[i] >= h[i]);
72. }
73.
74. if ((f = fopen(argv[1], "w")) == NULL) {
75. printf("Gagal membuat file data baru bernama %sn",
argv[1]);
76. exit(1);
77. }
78. fprintf(f, "%d %d %dn", n, c, d);
79. fprintf(f, "%lf %lfn", m, epsilon);
80. for (i = 0; i < n; i) {
81. for (j = 0; j < d; j) {
82. fprintf(f, "%d ", (rand() % (h[j] ‐ l[j] + 1)) + l[j]);
83. }
84. fprintf(f, "n");
85. }
86. fclose(f);
87. return 0;
4
Suka
1

20. POSTING LEBIH BARU POSTING LAMA
Konsultasi Gratis
Jika ada yang ingin di tanyakan, Kamu bisa melakukan konsultasi
gratis kepada team metode-algoritma.com melalui form di bawah.
Mohon isi email dengan benar, karena hasil konsultasi akan di
kirimkan ke email kamu.
Name: *
E­Mail: *
Subject: *
Message: *
Send message!
All fields marked with * are required.
Metode Algoritma
Email: metodealgoritma@yahoo.co.id
Indonesia
Mampang Raya XII No. 30 A
Jakarta, Indonesia
sms :(+62) 85625 49338
Singapore
238B Thomson Road #17-00 Tower B
Novena Square Singapore
sms :(+65) 6415 3540
Company
Tentang Kami
Fakta serta Figur
Mengapa memilih kami
Model Pengerjaan Aplikasi
Model Konsultasi
Prosedur serta Proses kerjasama
Pertanyaan serta Jawaban
Persetujuan
88. }
89.

21. Testimonials
Contact
Sitemap
Blog
Tutorial + Source Code
Service
Jasa murah programmer : pembuatan program untuk umum dan mahasiswa ( Tesis, Skripsi, Tugas Akhir )
JAKARTA BANDUNG SURABAYA YOGYAKARTA MALANG PALEMBANG SEMARANG MEDAN BOGOR BALI DENPASAR LAMPUNG SOLO
SURABAYA BANDUNG
Portfolio
Implementasi Algoritma
Steganogra섙 Kriptogra섙
Watermaking Keamanan Data
Pengenalan Objek Wajah Suara
Wavelet Quantization
Implentasi Model Forecasting
Implementasi Data Minging
Kecerdasan Buatan (AI)
Decision Support Systems
Sistem Ahli (ES)
Implementasi Shortest Path
Mikrotik serta Robotika
Networking Keamanan Jaringan
Histogram Pemetaan
Mobile Expert System
Dan lainnya
Technology
C# .Net
PHP
AS3
Java
Delphi
Matlab
Objective C
Visual Basic
iOS
Android
Blackberry
Symbian OS
Windows Phone
Copyright © 2013 metode-algoritma.com Allright Reserved|about|sitemap|