├── .gitignore
├── tests
    ├── __init__.py
    ├── test_data.csv
    └── test_kmeans.py
├── data_contoh.csv
├── kmeans.py
└── RBF11.py


/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | 


--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
1 | from test_kmeans import *
2 | 


--------------------------------------------------------------------------------
/tests/test_data.csv:
--------------------------------------------------------------------------------
1 | 2002.08.19,17:38,1.801000,1.801700,1.801000,1.801600,0
2 | 2002.08.19,17:53,1.801800,1.801800,1.801700,1.801700,0
3 | 


--------------------------------------------------------------------------------
/tests/test_kmeans.py:
--------------------------------------------------------------------------------
 1 | import unittest
 2 | 
 3 | import kmeans
 4 | 
 5 | class KMeansTest(unittest.TestCase):
 6 | 
 7 | 
 8 |     def test_baca_file(self):
 9 |         expected = [[1.8015, 1.8015, 1.8015, 1.8015],
10 |                     [1.8018, 1.8018, 1.8017, 1.8017]]
11 |         results = kmeans.baca_file('tests/test_data.csv')
12 |         self.assertTrue(expected, results)
13 | 
14 | 


--------------------------------------------------------------------------------
/data_contoh.csv:
--------------------------------------------------------------------------------
 1 | 2002.08.19,17:38,1.801000,1.801700,1.801000,1.801600,0
 2 | 2002.08.19,17:39,1.801500,1.801500,1.801500,1.801500,0
 3 | 2002.08.19,17:41,1.801700,1.801700,1.801500,1.801500,0
 4 | 2002.08.19,17:42,1.801600,1.801700,1.801600,1.801700,0
 5 | 2002.08.19,17:45,1.801500,1.801600,1.801500,1.801600,0
 6 | 2002.08.19,17:48,1.801600,1.802100,1.801500,1.802100,0
 7 | 2002.08.19,17:49,1.801900,1.802500,1.801900,1.802300,0
 8 | 2002.08.19,17:50,1.802200,1.802200,1.801500,1.801500,0
 9 | 2002.08.19,17:52,1.801700,1.801900,1.801600,1.801700,0
10 | 2002.08.19,17:53,1.801800,1.801800,1.801700,1.801700,0
11 | 


--------------------------------------------------------------------------------
/kmeans.py:
--------------------------------------------------------------------------------
  1 | #-------------------------------------------------------------------------------
  2 | # Name:        module1
  3 | # Purpose:
  4 | #
  5 | # Author:      LiaAmai
  6 | #
  7 | # Created:     14/12/2015
  8 | # Copyright:   (c) LiaAmai 2015
  9 | # Licence:     <your licence>
 10 | #-------------------------------------------------------------------------------
 11 | import csv
 12 | import numpy as np
 13 | import random as rand
 14 | 
 15 | 
 16 | def baca_file(filename):
 17 |     data = []
 18 |     with open(filename, 'rb') as csvfile:
 19 |         for rows in csv.reader(csvfile):
 20 |             fixed_data = map(float, rows[2:6])
 21 |             data.append(fixed_data);
 22 | 
 23 |     return data;
 24 | 
 25 | 
 26 | def centroid_awal(data, k):
 27 |     """
 28 |     mengambil secara acak data sebanyak jlh kluster(k)
 29 |     """
 30 |     return np.array(rand.sample(data, k))
 31 | 
 32 | def jarak(v1, v2):
 33 |     """
 34 |     menghitung jarak dengan euclidean distance
 35 |     v1 dan v2 adalah data vektornya
 36 |     """
 37 |     return np.sqrt(sum(np.power(v1 - v2, 2)))
 38 | 
 39 | def pembagian_kelas(data, centroids):
 40 |     """
 41 |     membagi kelas, yg memiliki jarak terkecil akan masuk ke k kluster
 42 |     """
 43 |     k, dim = centroids.shape
 44 |     clusters = list()
 45 |     clusters = []
 46 |     for i in xrange(k):
 47 |         clusters.append([])
 48 |     for elemen in data:
 49 |         min_dist = 1000
 50 |         min_index = 0  # index terdekat centroid
 51 |         for index, centroid in enumerate(centroids):
 52 |             this_dist = jarak(elemen, centroid)
 53 |             #jika jarak sekarang lebih kecil dari min_dist maka min_dist = this_dist
 54 |             if this_dist < min_dist:
 55 |                 min_dist = this_dist
 56 |                 min_index = index
 57 |         clusters[min_index].append(elemen)
 58 |     return np.array(clusters)
 59 | 
 60 | #menghitung nilai centroid
 61 | def mean(vector):
 62 |     """
 63 |     menghitung nilai rata-rata anggota setiap kluster
 64 |     yang hasilnya akan jadi centroid baru di iterasi selanjutnya
 65 |     """
 66 |     return np.mean(vector, axis=0)
 67 | 
 68 | #mengganti centroid
 69 | def ubah_centroid(clusters):
 70 |     """
 71 |     mengganti centroid lama dengan centroid baru
 72 |     """
 73 |     centroids = []
 74 |     for cluster in clusters:
 75 |         centroids.append(mean(cluster))
 76 |     return np.array(centroids)
 77 | 
 78 | #untuk mengecek apakah centroid berubah atau tidak
 79 | def centroid_baru(last_centroids, centroids):
 80 |     """
 81 |     jika centroid berubah
 82 |     """
 83 |     return (np.sort(last_centroids) == np.sort(centroids)).all()
 84 | 
 85 | #kmean : jika centroid sudah sama, maka last centroid adalah centroid terakhir
 86 | def kmeans(data, k):
 87 |     last_centroids = centroid_awal(data, k)
 88 |     #print "\ncentroid awal : \n"
 89 |     #print last_centroids
 90 |     clusters = pembagian_kelas(data, last_centroids)
 91 |     centroids = ubah_centroid(clusters)
 92 |     while not centroid_baru(last_centroids, centroids):
 93 |         clusters = pembagian_kelas(data, centroids)
 94 |         last_centroids = centroids
 95 |         centroids = ubah_centroid(clusters)
 96 | 
 97 |     #print "\npembagian kelas: \n"
 98 |     #print clusters
 99 |     print "centroid: \n",centroids
100 |     return centroids
101 | 
102 | def main():
103 |     direktori = str(raw_input("Masukkan nama data dengan direktorinya: "))
104 |     num_input_layer = int(input("masukan jumlah layer input (input nodes): " ))
105 |     num_hidden_layer = int(input("masukan jumlah layer tersembunyi (hidden nodes): " ))
106 |     num_output_layer = int(input("masukan jumlah layer output (output nodes): " ))
107 | 
108 |     #jlh kluster
109 |     data = baca_file(direktori)
110 |     k = num_hidden_layer
111 |     kmeans(data,k)
112 | 
113 | 
114 | if __name__ == '__main__':
115 |     main()
116 | 
117 | 
118 | 


--------------------------------------------------------------------------------
/RBF11.py:
--------------------------------------------------------------------------------
  1 | #-------------------------------------------------------------------------------
  2 | # Name:        module1
  3 | # Purpose:
  4 | #
  5 | # Author:      LiaAmai
  6 | #
  7 | # Created:     18/12/2015
  8 | # Copyright:   (c) LiaAmai 2015
  9 | # Licence:     <your licence>
 10 | #-------------------------------------------------------------------------------
 11 | 
 12 | #-------------------------------------------------------------------------------
 13 | # Name:        module1
 14 | # Purpose:
 15 | #
 16 | # Author:      LiaAmai
 17 | #
 18 | # Created:     18/12/2015
 19 | # Copyright:   (c) LiaAmai 2015
 20 | # Licence:     <your licence>
 21 | #-------------------------------------------------------------------------------
 22 | import random
 23 | import math
 24 | from kmeans import kmeans,baca_file
 25 | import numpy as np
 26 | np.seterr(divide='ignore', invalid='ignore')
 27 | 
 28 | class RadialNet():
 29 |     def __init__(self,JumlahInput,JumlahHidden,JumlahOutput):
 30 |         self.JumlahInput = JumlahInput
 31 |         self.JumlahHidden = JumlahHidden
 32 |         self.JumlahOutput = JumlahOutput
 33 |         self.inputs = [0 for i in range(JumlahInput-1)]
 34 |         self.centroids = [0 for i in range(JumlahHidden-1) for j in range(JumlahInput-1)]
 35 |         self.widths = [1 for i in range(JumlahHidden)]
 36 |         self.ihBobot = [0 for i in range(JumlahInput) for j in range(JumlahHidden)]
 37 |         self.hBias = [0 for i in range(JumlahHidden-1)]
 38 |         self.hoBobot = self.makematrix(JumlahHidden, JumlahOutput)
 39 |         self.oBias = [0 for i in range(JumlahOutput)]
 40 |         self.hOutputs = [0 for i in range(JumlahHidden-1)]
 41 |         self.outputs = [0 for i in range(JumlahOutput-1)]
 42 | 
 43 |     def makematrix(self, rows, cols):
 44 |         result = [[0 for j in range(cols)] for i in range(rows)]
 45 |         return result
 46 | 
 47 |     def RBF(self, data, jumlahIterasi):
 48 |         print "Mencari data centroid sebanyak",self.JumlahHidden,"buah\n"
 49 |         centroid = self.HitungCentroid(data,k)
 50 | 
 51 |         print "Mencari nilai width untuk masing-masing Hidden Nodes\n"
 52 |         width = self.HitungWidth(centroid)
 53 |         print width,"\n"
 54 | 
 55 |         jumlahBobot = (self.JumlahHidden * self.JumlahInput) + self.JumlahOutput
 56 |         print "Menentukan nilai bobot dan nilai bias sebanyak",jumlahBobot,"buah\n"
 57 |         bobot = self.inisialisasiBobot()
 58 |         print "\n",bobot
 59 | 
 60 | 
 61 |     def HitungCentroid(self, data,k):
 62 |         self.centroids = kmeans(data,k)
 63 |         return self.centroids
 64 | 
 65 |     def HitungWidth(self,centroids):
 66 |         jumlahJarak = 0.0
 67 |         ct = 0
 68 |         for i in range(len(centroids)-2):
 69 |             j=i+1
 70 |             for j in range(len(centroids)-1):
 71 |                 jarak = self.jarakEuclidean(centroids[i], centroids[j], len(centroids[i]))
 72 |                 jumlahJarak += jarak
 73 |                 ct += 1
 74 | 
 75 |         ratarataJarak = jumlahJarak/ct
 76 |         width = ratarataJarak
 77 |         #print "Width rata-rata yang akan digunakan adalah: ",width
 78 |         for i in range(len(self.widths)-1):
 79 |             self.widths[i] = width
 80 |         return self.widths
 81 | 
 82 |     def getBobot(self):
 83 |         numWts = (self.JumlahHidden * self.JumlahOutput) + self.JumlahOutput
 84 |         result = [0 for i in range(numWts)]
 85 |         k = 0
 86 |         for i in range(self.JumlahHidden-1):
 87 |           for j in range(self.JumlahOutput-1):
 88 |             result[k] = self.hoBobot[i][j]
 89 |             k += 1
 90 |         for i in range(self.JumlahOutput-1):
 91 |           result[k] = self.oBias[i]
 92 |           k += 1
 93 |         return result
 94 | 
 95 |     def inisialisasiBobot(self):
 96 |         numWts = (self.JumlahHidden * self.JumlahOutput) + self.JumlahOutput
 97 |         wts = [0 for i in range(numWts)]
 98 |         lo = -0.01
 99 |         hi = 0.01
100 |         for i in range(len(wts)):
101 |           wts[i] = (hi - lo) * random.uniform(-1.0,5.0) + lo
102 |         self.setBobot(wts)
103 |         result = self.getBobot()
104 |         for i in range(self.JumlahHidden-1):
105 |             for j in range(self.JumlahOutput):
106 |                 self.hoBobot[i][j] = result[i]
107 |                 self.oBias[j] = result[i]
108 |         return self.hoBobot, self.oBias
109 | 
110 | 
111 |     def setBobot(self, bobot):
112 |         k = 0
113 |         for i in range(self.JumlahHidden-1):
114 |             for j in range(self.JumlahOutput-1):
115 |                 self.hoBobot[i][j] = bobot[k]
116 |                 k += 1
117 |         for i in range(self.JumlahOutput-1):
118 |           self.oBias[i] = bobot[i]
119 |           k += 1
120 | 
121 |     def HitungNilaiOutput(self,nilaiInput):
122 |         for i in range(len(nilaiInput)):
123 |             self.inputs[i] = nilaiInput[i]
124 | 
125 |         #nilai output pada hidden node
126 |         for j in range(self.JumlahHidden-1):
127 |             d = self.jarakEuclidean(self.inputs, self.centroids[j], len(self.inputs))
128 |             r = float(-1.0 * (d*d)/(2*self.widths[j] * self.widths[j]))
129 |             g = math.exp(r)
130 |             self.hOutputs[j] = g
131 | 
132 |         #hitung nilai sementara dgn cara perkalian antara nilai output pd hidden node dgn matriks bobot pd hidden node
133 |         nilaiOutputSementara = [0 for i in range(self.JumlahOutput - 1)]
134 |         for k in range(self.JumlahOutput - 1):
135 |             for j in range(self.JumlahHidden - 1):
136 |                 nilaiOutputSementara[k] = float(nilaiOutputSementara[k]) + (self.hOutputs[j] * self.hoBobot[j][k])
137 | 
138 |         #tambahkan nilai bias pada nilai sementara
139 |         for k in range(self.JumlahOutput - 1):
140 |             nilaiOutputSementara[k] = self.oBias[k]
141 | 
142 |         #hitung nilai akhir dgn menggunakan metode softmax
143 |         #1.cari nilai terbesar dari output sementara
144 |         maks = nilaiOutputSementara[0]
145 |         for i in range(len(nilaiOutputSementara)-1):
146 |             if nilaiOutputSementara[i] > maks:
147 |                 maks = nilaiOutputSementara
148 | 
149 |         #2.Tentukan faktor skala, yaitu junlah dari konstanta e dipangkatkan (setiap nilai dikurangi nilai terbesar)
150 |         skala = 0.0
151 |         for i in range(len(nilaiOutputSementara)-1):
152 |             skala += math.exp(nilaiOutputSementara[i] - maks)
153 | 
154 |         """
155 |         3. Nilai akhir adalah nilai output sementara dibagi dengan faktor skala
156 |         Sehingga jumlah semua nilai pada nilai output adalah 1
157 |         """
158 |         nilaiOutputAkhir = [0 for i in range(len(nilaiOutputSementara)-1)]
159 |         for i in range(len(nilaiOutputSementara)-1):
160 |             nilaiOutputAkhir[i] = math.exp(nilaiOutputSementara[i] - maks)/skala
161 | 
162 |         for i in range(len(nilaiOutputAkhir)):
163 |             self.outputs[i] = nilaiOutputAkhir[i]
164 | 
165 |         nilaiAkhir = [0 for i in range(self.JumlahOutput - 1)]
166 |         for i in range(len(self.outputs)):
167 |             nilaiAkhir[i] = nilaiOutputAkhir[i]
168 |             return nilaiAkhir
169 | 
170 |     def MeanSquaredError(self,data,bobot):
171 |         self.setBobot(bobot)
172 |         nilaiInput = [0 for i in range(self.JumlahInput)]
173 |         nilaiOutput = [0 for i in range(self.JumlahOutput)]
174 |         hasil = 0.0
175 |         for i in range(len(data)-1):
176 | 
177 |             for j in range(self.JumlahInput):
178 |                 nilaiInput[j] = data[i][j]
179 | 
180 |             for j in range(self.JumlahOutput):
181 |                 nilaiOutput[j] = data[i][j+self.JumlahInput]
182 | 
183 |             dataKolomHasil = self.HitungNilaiOutput(nilaiInput)
184 |             for j in range(len(dataKolomHasil) - 1):
185 |                 hasil +=((dataKolomHasil[j] - nilaiOutput[j]) * (dataKolomHasil[j] - nilaiOutput[j]))
186 |         return hasil/len(data)
187 | 
188 |     def jarakEuclidean(self, dataPertama, dataKedua, JumlahData):
189 |         jumlah = 0.0
190 |         for i in range(JumlahData - 1):
191 |             delta = (dataPertama[i] - dataKedua[i]) * (dataPertama[i] - dataKedua[i])
192 |             jumlah += delta
193 |         return math.sqrt(jumlah)
194 | 
195 | 
196 | 
197 | direktori_trainData = str(raw_input("Masukkan nama data latih dengan direktorinya: "))
198 | #direktori_testData = str(raw_input("Masukkan nama data test dengan direktorinya: "))
199 | num_input_layer = int(input("masukan jumlah layer input (input nodes): " ))
200 | num_hidden_layer = int(input("masukan jumlah layer tersembunyi (hidden nodes): " ))
201 | num_output_layer = int(input("masukan jumlah layer output (output nodes): " ))
202 | 
203 | #jlh kluster
204 | k = num_hidden_layer
205 | #ambil data awal
206 | trainData = baca_file(direktori_trainData)
207 | #testData = baca_file(direktori_testData)
208 | 
209 | 
210 | print "\nCreating a ",num_input_layer,"-input, ",num_hidden_layer,"-hidden, ",num_output_layer,"-output neural network\n"
211 | nn = RadialNet(num_input_layer, num_hidden_layer, num_output_layer)
212 | maxEpochs = 100
213 | print "Setting maxEpochs = " + str(maxEpochs)
214 | 
215 | print "Hitung Nilai Output\n"
216 | nn.HitungNilaiOutput(trainData)
217 | #print "\nBeginning training using random guesses"
218 | #nn.RBF(trainData, maxEpochs)
219 | 
220 | 
221 | 
222 | 
223 | 
224 | 
225 | 
226 | 
227 | 
228 | 
229 | 
230 | 
231 | 
232 | 
233 | 
234 | 


--------------------------------------------------------------------------------