UJIAN AKHIR SEMESTER 4

Data Warehouse Data Mining

Klasifikasi ANN/NEURAL NETWORK Dan Clustering KMEANS

Dosen Pembimbing :
Dr. Ionia Veritawati,S.Si.,M.T

Disusun Oleh :
Nur Ichsana Nawin Putri (4518210059)

FAKULTAS TEKNIK
JURUSAN TEKNIK INFORMATIKA
UNIVERSITAS PANCASILA
Metode Klasifikasi ANN

1. Konsep Metode Klasifikasi ANN dan Rumus

Artifical Neural Network itu proses kerja otak manusia. Dan mempunyai jumlah elemen
besar untuk diproses biar saling terhubung dan dapat bekerja secara parallel untuk
memecahkan suatu masalah. Jadi seperti sebuah system yang meniru seperti otak manusia
jadi otak manusia diibaratkan seperti mesin computer. Yang menerima kesalahan/eror.
Didalam ANN itu berisikan input,output,fungsi aktivasi. Jadi neural network itu dibangun
dari banyak unit/node yang dihubungkan ke link. ANN juga sebuah algoritma Pemrograman.
1. Proses kerjanya jaringan saraf di otak manusia
Neuron berfungsi sebagai memproses setiap informasi yang masuk. Satu neuron
memiliki 1 akson, dan minimal 1 dendrit. Setiap sel syaraf terhubung dengan syaraf
lain, jumlahnya mencapai sekitar 104 sinapsis. Bagian saraf otak itu ada
dendrit,akson,dan sinapsis.
2. Struktur ANN
Seperti dipenjelasan diatas kalau struktur ANN itu ada 3 yaitu input,ouput, dan fungsi
aktivasi. Proses yang ada di ANN dimulai dari input yang diterima oleh neuron
beserta dengan nilai bobot dari tiap-tiap input yang ada. Hasil yang dijumlahkan akan
diproses oleh fungsi aktivasi setiap neuron, dibandingkan hasil penjumlahan dengan
nilai ambang tertentu. Jika sudah aktif, neuron akan mengirimkan nilai output melalui
bobot-bobot outputnya ke semua neuron yang berhubungan dengannya. 
 2. Algoritma Klasifikasi ANN

Algoritma ANN itu ada Algoritma Backpropagation

1. Menyiapkan pola pelatihan

2. Mengatur Model ANN yang terdiri dari jumlah input neuron, hidden neuron dan output
neuron.
3. Setting learning rate (η) dan tingkat momentum (α).
4. Inisialisasi semua koneksi (Wij dan Wjk) dan bobot bias (θk dan θj) ke nilai acak.
5. Mengatur kesalahan minimum, E min.
6. Mulai pelatihan dengan cara menerapkan pola masukan satu per satu dan menyebarkan
melalui layer lalu menghitung kesalahan total.
7. Error Backpropagate melalui output dan hidden layer dan menyesuaikan bobot, Wjk dan
θk.
8. Error Backpropagate melalui lapisan tersembunyi dan input dan menyesuaikan bobot Wij
dan θj.
9. Periksa apakah ada Kesalahan

3. Codingan Klasifikasi ANN

1. /*
2. * To change this template, choose Tools | Templates
3. * and open the template in the editor.
4. */
5. package abppn;
6.  
7. import java.math.BigDecimal;
8. import java.text.DecimalFormat;
9.  
10. /**
11. *
12. * @author x86
13. */
14. public class BP {
15. // kondisi
16. double x[][];
17. // target
18. double t[];
19.
20. int unit_input;
21. int unit_hidden;
22. int unit_output;
23.
24. // learning rate
25. double alfa;
26. // maximum loop
27. int maxloop;
28. // target error
29. double ERR;
30. // last error
31. double ERX;
32.
33. // bobot input - hidden
34. double v[][];
35. // bobot bias - hidden
36. double v0[];
37. // bobot hidden - ouput
38. double w[][];
39. // bobot bias - output
40. double w0[];
41.
42. double MSE;
43.
44. int loop;
45. double hasil_mentah;
46. double hasil_akhir;
47.
48. void init_static(){
49. //double init_x[][] = {{0.5,1},{1,0.5},{1,1},{0.5,0.5}};
50. //double init_t[] = {1,1,0.5,0.5};
51. //double init_x[][] = {{-1,0,0,0},{-1,0,0,1},{-1,0,1,0},{-1,0,1,1},{-1,1,0,0},{-1,1,0,1},{-1,1,1,0},{-1,1,1,1},
{ 0,0,0,0},{ 0,0,0,1},{ 0,0,1,0},{ 0,0,1,1},{ 0,1,0,0},{ 0,1,0,1},{ 0,1,1,0},{ 0,1,1,1},{ 1,0,0,0},{ 1,0,0,1},
{ 1,0,1,0},{ 1,0,1,1},{ 1,1,0,0},{ 1,1,0,1},{ 1,1,1,0},{ 1,1,1,1}};
52. //double init_t[] = {1, 0, 1,-1, 1, 0, 1,-1, 1, 0, 1,-1, 1, 0, 1, 1, 1, 1, 1,-1, 1, 0, 1, 1};
53. double init_x[][] = {{0,0,0,0},{0,0,0,1},{0,0,1,0},{0,0,1,1},{0,1,0,0},{0,1,0,1},{0,1,1,0},{0,1,1,1},
{0.5,0,0,0},{0.5,0,0,1},{0.5,0,1,0},{0.5,0,1,1},{0.5,1,0,0},{0.5,1,0,1},{0.5,1,1,0},{0.5,1,1,1},{1,0,0,0},
{1,0,0,1},{1,0,1,0},{1,0,1,1},{1,1,0,0},{1,1,0,1},{1,1,1,0},{1,1,1,1}};
54. double init_t[] = {1,0.5,1,0,1,0.5,1,0,1,0.5,1,0,1,0.5,1,1,1,1,1,0,1,0.5,1,1};
55. int init_uinput = init_x[0].length;
56. int init_uhidden = 4;
57. int init_uoutput = 1;
58. double init_alfa = 1;
59. int init_maxloop = 10000;
60. double init_ERR = 0.01;
61. //double init_v[][] = {{0.9562,0.7762,0.1623,0.2886},{0.1962,0.6133,0.0311,0.9711}};
62. double init_v[][] = new double[init_uinput][init_uhidden];
63. for(int a=0; a<init_v.length; a++){
64. for(int b=0; b<init_v[0].length; b++){
65. init_v[a][b] = Math.random();
66. }
67. }
68. //double init_v0[] = {0.7496,0.3796,0.7256,0.1628};
69. double init_v0[] = new double[init_uhidden];
70. for(int a=0; a<init_v0.length; a++){
71. init_v0[a] = Math.random();
72. }
73. //double init_w[][] = {{0.2280,0.9585,0.6799,0.0550}};
74. double init_w[][] = new double[init_uoutput][init_uhidden];
75. for(int a=0; a<init_w.length; a++){
76. for(int b=0; b<init_w[0].length; b++){
77. init_w[a][b] = Math.random();
78. }
79. }
80. //double init_w0[] = {0.9505};
81. double init_w0[] = new double[init_uoutput];
82. for(int a=0; a<init_w0.length; a++){
83. init_w0[a] = Math.random();
84. }
85.
86. this.x = init_x;
87. this.t = init_t;
88. this.unit_input = init_uinput;
89. this.unit_hidden = init_uhidden;
90. this.unit_output = init_uoutput;
91. this.alfa = init_alfa;
92. this.maxloop = init_maxloop;
93. this.ERR = init_ERR;
94. this.v = init_v;
95. this.v0 = init_v0;
96. this.w = init_w;
97. this.w0 = init_w0;
98. }
99.
100. void init_dinamic(){
101. double init_x[][] = {{0,0,0,0},{0,0,0,1},{0,0,1,0},{0,0,1,1},{0,1,0,0},{0,1,0,1},{0,1,1,0},{0,1,1,1},
{0.5,0,0,0},{0.5,0,0,1},{0.5,0,1,0},{0.5,0,1,1},{0.5,1,0,0},{0.5,1,0,1},{0.5,1,1,0},{0.5,1,1,1},{1,0,0,0},
{1,0,0,1},{1,0,1,0},{1,0,1,1},{1,1,0,0},{1,1,0,1},{1,1,1,0},{1,1,1,1}};
102. double init_t[] = {1,0.5,1,0,1,0.5,1,0,1,0.5,1,0,1,0.5,1,1,1,1,1,0,1,0.5,1,1};
103. int init_uinput = init_x[0].length;
104. //int init_uhidden = 4;
105. int init_uoutput = 1;
106. //double init_alfa = 1;
107. //int init_maxloop = 10000;
108. //double init_ERR = 0.01;
109. //double init_v[][] = {{0.9562,0.7762,0.1623,0.2886},{0.1962,0.6133,0.0311,0.9711}};
110.
111. this.x = init_x;
112. this.t = init_t;
113. this.unit_input = init_uinput;
114. //this.unit_hidden = init_uhidden;
115. this.unit_output = init_uoutput;
116. //this.alfa = init_alfa;
117. //this.maxloop = init_maxloop;
118. //this.ERR = init_ERR;
119.
120.
121. double init_v[][] = new double[this.unit_input][this.unit_hidden];
122. for(int a=0; a<init_v.length; a++){
123. for(int b=0; b<init_v[0].length; b++){
124. init_v[a][b] = Math.random();
125. }
126. }
127. //double init_v0[] = {0.7496,0.3796,0.7256,0.1628};
128. double init_v0[] = new double[this.unit_hidden];
129. for(int a=0; a<init_v0.length; a++){
130. init_v0[a] = Math.random();
131. }
132. //double init_w[][] = {{0.2280,0.9585,0.6799,0.0550}};
133. double init_w[][] = new double[this.unit_output][this.unit_hidden];
134. for(int a=0; a<init_w.length; a++){
135. for(int b=0; b<init_w[0].length; b++){
136. init_w[a][b] = Math.random();
137. }
138. }
139. //double init_w0[] = {0.9505};
140. double init_w0[] = new double[this.unit_output];
141. for(int a=0; a<init_w0.length; a++){
142. init_w0[a] = Math.random();
143. }
144.
145. this.v = init_v;
146. this.v0 = init_v0;
147. this.w = init_w;
148. this.w0 = init_w0;
149. }
150.
151. void learn_static(){
152. double data[][] = this.x;
153. double target[] = this.t;
154. int jumlah_data = data.length;
155. int jumlah_input = this.unit_input;
156. int jumlah_hidden = this.unit_hidden;
157. int jumlah_output = this.unit_output;
158. // do it for learn
159. int loop = 0;
160. //this.maxloop = 1000;
161. //System.out.println(jumlah_hidden);
162. //System.out.println(this.v0.length);
163. //System.exit(0);
164.
165. do{
166. //System.out.println("Loop : "+loop);
167. //System.out.println("-----------");
168. // for all data
169. for(int h=0; h<jumlah_data; h++){
170. // hitung z_in dan z
171. double z[] = new double[jumlah_hidden];
172. for(int j=0; j<jumlah_hidden; j++){
173. //itung sigma xi vij
174. double z_in[] = new double[jumlah_hidden];
175. double jum_xv=0;
176. for(int i=0; i<jumlah_input; i++){
177. double tmp=x[h][i]*v[i][j];
178. jum_xv=jum_xv+tmp;
179. }
180. z_in[j] = v0[j]+jum_xv;
181. z[j] = aktivasi(z_in[j]);
182. //z[j] = 1/(1+(double)Math.exp(-z_in[j]));
183. //z[j] = (1-(double)Math.exp(-z_in[j]))/(1+(double)Math.exp(-z_in[j]));
184. // System.out.println("z["+j+"] = "+z[j]);
185. }
186.
187. //~ itung y_in dan y (output)
188. double y[] = new double[jumlah_output];
189. for(int k=0; k<jumlah_output; k++){
190. double y_in[] = new double[y.length];
191. double jum_zw=0;
192. for(int j=0; j<jumlah_hidden; j++){
193. double tmp=z[j]*w[k][j];
194. jum_zw=jum_zw+tmp;
195. }
196. y_in[k]=w0[k]+jum_zw;
197. y[k] = aktivasi(y_in[k]);
198. //y[k]=1/(1+(double)Math.exp(-y_in[k]));
199. //y[k]=(1-(double)Math.exp(-y_in[k]))/(1+(double)Math.exp(-y_in[k]));
200. //System.out.println("Math.exp("+-y_in[k]+") = "+Math.exp(-y_in[k]));
201. //System.out.println("y["+k+"] = "+y[k]);
202. }
203.
204. // hitung MSE
205. double sum_e = 0;
206. double Err_y[] = new double[jumlah_output];
207. for(int k=0; k<jumlah_output; k++){
208. //error otput
209. //Err_y[k]=(t[h]-y[k])*y[k]*(1-y[k]);
210. Err_y[k] = t[h]-y[k];
211. sum_e += Math.pow(Err_y[k],2);
212. }
213.
214. this.MSE = 0.5*sum_e;
215.
216. //ngitung delta bias dan delta bobot
217. double Aw[][] = new double[this.w.length][this.w[0].length];
218. double Aw0[] = new double[this.w0.length];
219. for(int k=0; k<jumlah_output; k++){
220. for(int j=0; j<jumlah_hidden; j++){
221. //delta bobot hO
222. Aw[k][j] = this.alfa * Err_y[k] * y[k] * z[j];
223. //delta bias hO
224. Aw0[k] = this.alfa * Err_y[k] * y[k];
225. }
226. }
227.
228. //ngitung delta bias dan delta bobot
229. double Err_in[] = new double[jumlah_hidden];
230. double Err_z[] = new double[jumlah_hidden];
231. double Av[][] = new double[this.v.length][this.v[0].length];
232. double Av0[] = new double[this.v0.length];
233. for(int j=0; j<jumlah_hidden; j++){
234. double tmp=0;
235. for(int k=0; k<jumlah_output; k++){
236. tmp = tmp + (Err_y[k]*this.w[k][j]);
237. }
238. // eror sebelum output / setelah hidden
239. Err_in[j]=tmp;
240. // eror hidden (t[h]-y[k])*y[k]*(1-y[k]);
241. Err_z[j]=Err_in[j]*(z[j])*(1-z[j]);
242.  
243. for(int i=0; i<jumlah_input; i++){
244. //delta bobot iH
245. Av[i][j]=this.alfa*Err_z[j]*this.x[h][i];
246. }
247. //delta bias hidden
248. Av0[j]=this.alfa*Err_z[j];
249. }
250.
251. //update bobot dan bias
252. //update bobot bias outpuut
253. for(int j=0; j<jumlah_hidden; j++){
254. for(int k=0; k<jumlah_output; k++){
255. this.w[k][j]=this.w[k][j]+Aw[k][j];
256. //this.w[k][j]=this.w[k][j]-Aw[k][j];
257. }
258. }
259. for(int k=0; k<jumlah_output; k++){
260. this.w0[k]=this.w0[k]+Aw0[k];
261. //this.w0[k]=this.w0[k]-Aw0[k];
262. }
263.  
264. //update bobot bias hidden
265. for(int i=0; i<jumlah_input; i++){
266. for(int j=0; j<jumlah_hidden; j++){
267. this.v[i][j]=this.v[i][j]+Av[i][j];
268. //this.v[i][j]=this.v[i][j]-Av[i][j];
269. }
270. }
271. for(int j=0; j<jumlah_hidden; j++){
272. this.v0[j]=this.v0[j]+Av0[j];
273. //this.v0[j]=this.v0[j]-Av0[j];
274. }
275. }
276. loop++;
277. //System.out.println("err : "+ERX);
278. }while(is_stop()>this.ERR && loop<this.maxloop);
279. this.loop = loop;
280. //System.out.println("err : "+this.MSE);
281. //System.out.println("loop : "+loop);
282. }
283.
284. double aktivasi(double inp){
285. return 1/(1+(double)Math.exp(-inp));
286. }
287.
288. //penentuan berhenti atau lanjut
289. double is_stop(){
290. int jumlah_input = this.unit_input;
291. int jumlah_hidden = this.unit_hidden;
292. int jumlah_output = this.unit_output;
293. int jumlah_data = this.x.length;
294. double akumY=0;
295.
296. //~ itung z_in dan z
297. for(int h=0; h<jumlah_data; h++){
298. double z[] = new double[jumlah_hidden];
299. for(int j=0; j<jumlah_hidden; j++){
300. //itung sigma xi vij
301. double z_in[] = new double[z.length];
302. double jum_xv=0;
303. for(int i=0; i<jumlah_input; i++){
304. double tmp=this.x[h][i]*this.v[i][j];
305. jum_xv=jum_xv+tmp;
306. }
307. z_in[j]=this.v0[j]+jum_xv;
308. z[j] = aktivasi(z_in[j]);
309. //z[j]=1/(1+(double)Math.exp(-z_in[j]));
310. //z[j]=(1-(double)Math.exp(-z_in[j]))/(1+(double)Math.exp(-z_in[j]));
311. //System.out.println(-z_in[j]);
312. }
313.  
314. //~ itung y_in dan y (output)
315. double y[] = new double[jumlah_output];
316. for(int k=0; k<jumlah_output; k++){
317. double y_in[] = new double[y.length];
318. double jum_zw=0;
319. for(int j=0; j<jumlah_hidden; j++){
320. double tmp=z[j]*this.w[k][j];
321. jum_zw=jum_zw+tmp;
322. }
323. y_in[k]=this.w0[k]+jum_zw;
324. y[k] = aktivasi(y_in[k]);
325. //y[k]=1/(1+(double)Math.exp(-y_in[k]));
326. //y[k]=(1-(double)Math.exp(-y_in[k]))/(1+(double)Math.exp(-y_in[k]));
327. //System.out.println("t[]-y = "+t);
328. akumY += Math.pow((t[h]-y[k]),2);
329. }
330. }
331. this.MSE = akumY/this.x[0].length;
332. return this.MSE;
333. }
334.
335. void test(double data[]){
336. int jumlah_input = this.unit_input;
337. int jumlah_hidden = this.unit_hidden;
338. int jumlah_output = this.unit_output;
339. double outt[] = this.t;
340.
341. //pada hidden
342. double z[] = new double[jumlah_hidden];
343. for(int j=0; j<jumlah_hidden; j++){
344. double z_in[] = new double[z.length];
345. double tmp = 0;
346. for(int i=0; i<data.length; i++){
347. tmp = tmp + (data[i] * this.v[i][j]);
348. }
349. z_in[j] = this.v0[j] + tmp;
350. z[j] = aktivasi(z_in[j]);
351. //z[j] = 1/(1+(double)Math.exp(-z_in[j]));
352. //z[j] = (1-(double)Math.exp(-z_in[j]))/(1+(double)Math.exp(-z_in[j]));
353. }
354.  
355. //pada ouotpr
356. double y[] = new double[jumlah_output];
357. for(int k=0; k<jumlah_output; k++){
358. double y_in[] = new double[y.length];
359. double tmp = 0;
360. for(int j=0; j<jumlah_hidden; j++){
361. tmp = tmp + z[j] * this.w[k][j];
362. }
363. y_in[k] = this.w0[k] + tmp;
364.  
365. y[k] = aktivasi(y_in[k]);
366. //y[k] = 1/(1+(double)Math.exp(-y_in[k]));
367. //y[k] = (1-(double)Math.exp(-y_in[k]))/(1+(double)Math.exp(-y_in[k]));
368. /*
369. if(y[k]<0.1){
370. y[k] = -1;
371. }else if(y[k]>0.1){
372. y[k] = 1;
373. }else{
374. y[k] = 0;
375. }
376. /*
377. if(y[k]>0)
378. y[k]=1;
379. else
380. y[k]=0;*/
381. double err_pad = this.MSE*this.x[0].length;
382. double hazil = 0;
383. if(y[k] < err_pad){
384. hazil = 0;
385. }else if(y[k]>(1-err_pad)){
386. hazil = 1;
387. }else{
388. hazil = 0.5;
389. }
390.
391. this.hasil_mentah = y[k];
392. this.hasil_akhir = hazil;
393. //System.out.println("Output "+y[k]);
394. }
395. }
396.
397. double double_format(double num, int len){
398. String format = "#.";
399. for(int a=0; a<len; a++){
400. format += "#";
401. }
402. DecimalFormat change = new DecimalFormat(format);
403. return Double.valueOf(change.format(num));
404. }
405.
406. String kesimpulan(double h){
407. String x = "";
408. switch(String.valueOf(h)){
409. case "0.0":
410. x = "Hard Contact Lenses";
411. break;
412. case "0.5":
413. x = "Soft Contact Lenses";
414. break;
415. case "1.0":
416. x = "No Contact Lenses";
417. break;
418. }
419. return x;
420. }
421. /*
422. public static void main(String haripinter[]){
423. BP BP = new BP();
424. BP.init_static();
425. BP.learn_static();
426. /*double ax[] = {0.5,0.5};
427. double bx[] = {0.5,1};
428. double cx[] = {1,0.5};
429. double dx[] = {1,1};
430. BP.test(ax);
431. BP.test(bx);
432. BP.test(cx);
433. BP.test(dx);*/
434.
435. //double xys[][] = {{-1,0,0,0},{-1,0,0,1},{-1,0,1,0},{-1,0,1,1},{-1,1,0,0},{-1,1,0,1},{-1,1,1,0},{-1,1,1,1},
{ 0,0,0,0},{ 0,0,0,1},{ 0,0,1,0},{ 0,0,1,1},{ 0,1,0,0},{ 0,1,0,1},{ 0,1,1,0},{ 0,1,1,1},{ 1,0,0,0},{ 1,0,0,1},
{ 1,0,1,0},{ 1,0,1,1},{ 1,1,0,0},{ 1,1,0,1},{ 1,1,1,0},{ 1,1,1,1}};//
436. /*
437. double xys[][] = {{0,0,0,0},{0,0,0,1},{0,0,1,0},{0,0,1,1},{0,1,0,0},{0,1,0,1},{0,1,1,0},{0,1,1,1},
{0.5,0,0,0},{0.5,0,0,1},{0.5,0,1,0},{0.5,0,1,1},{0.5,1,0,0},{0.5,1,0,1},{0.5,1,1,0},{0.5,1,1,1},{1,0,0,0},
{1,0,0,1},{1,0,1,0},{1,0,1,1},{1,1,0,0},{1,1,0,1},{1,1,1,0},{1,1,1,1}};
438. for(int a=0; a<xys.length; a++){
439. double inp[] = xys[a];
440. System.out.println(BP.t[a]);
441. BP.test(inp);
442. }
443. //BigDecimal k = new BigDecimal(Math.exp(10));
444.
445. //System.err.println(-1-(-1));
446. }*/

4. Uraian Domain Implementasi

Pada Jurnal Kedua dapat di Implementasi Menggunakan Artifical Neuron Network untuk
mengetahui perkiraan hasil dari Ujian Kompetensi Kebidanan di Akademi Kebidanan
Dehasen Bengkulu. Dari hasil klasifikasi tersebut dapat diidentifikasikan melalui teknik uji
dari matlab.
 Dari hasil diatas implementasi bisa dijelaskan :

1. Menentukan pola/jumlah nya

2. Proses berapa banyak pengjuian nya
3. Hasil akhir pengujian nya paling banyak 70%

5. Data Yang Diolah

Disini kita menggunakan jurnal pertama , Yang akan kita lakukan adalah pengolahan data
agar menghasilkan atau dapat tercapai secara maksimal. Ada beberapa tahap untuk pengolahan
data dan ini langkah-langkah seperti Cleaning data,Data Transformation,Pembagian Data.

Kita pertama akan menjelaskan Cleaning Data jadi di penelitian kita menggunakan teknik
yang dinamakan missing value/nilainya hilang untuk sebuah cleaning data. Namun data yang
didapatkan dipenelitian ini ada 1221 record, tapi tidak semua data bisa dipakai yang masih
memerlukan cleaning karena beberapa record yang tidak di berisikan transaksi trading melainkan
berisikan laporan sejumlah dividend yang ada setiap tahunnya. Cara mengatasi terjadinya
missing value/nilainya hilang dengan cara memperbaikin data secara manual dengan cara
menghilangkan record/jumlahnya yang berisikan catetan dividend. Setelah udah diproses
cleaning data atau pembersihan data, data yang siap digunakan berjumlah 1215 record.

Kedua kita akan menjelaskan Data Transformation/Data transformasi jadi di data

transformasi ini kita menggunakan normalisasi, kenapa pakai cara normalisasi? Karena dapat
memudahkan kita untuk mengolah data agar lebih cepat. Dan dipenelitian ini kita menggunakan
normalisasi dengan z-score transformation yaitu metode menggunakan sampel dalam satu sel
data.

Ketiga kita menjelaskan pembagian data didalam penelitian ini pembagian data dibagi
menjadi dua yaitu training dan data testing. Data dibagi menjadi 2 dengan pembagian70:30 yaitu
850 record digunakan sebagai data training (4 januari 2010 – 26 juni 2013) dan 365 record data
sebagai data testing (26 juni 2013 – 30 desember 2014).
 6. Konsep dari teknik evaluasi

Kita menggunakan Jurnal Pertama, kita menggunakan konsep proses evaluasi cross
validation. Dengan cara menguji model yang terbentuk dengan data secara acak yang dipisahkan
dengan mengunakan 10 folds cross validation. Untuk pengukuran akurasi akan menggunakan
Root Mean Squared Error dan Normalized Mean Absolute Error , diprediksi yang dianggap
secara optimal untuk terbentuknya dengan cara algoritma SVM dan ANN.

7. Hasil evaluasi dan analisa

Dari hasil ini kita menggunakan jurnal pertama, jadi hasil penelitian ini dari algoritma ANN
harus melakukan proses seperti : Inisialisasi Parameter Learning_rate dan Momentum, Penentuan
Hidden Layer Size, Eksperimen.

Pertama kita menjelaskan inisialisasi parameter learning rate dan momentum, jadi ini kita
menentukan parameternya di learning rate dan momentum, jika sudah mendapatkan
parameternya maka hasil nya akan optimal. Di Nilai parameter Trining Cycle ditetapkan default
yaitu 500, untuk nilai parameter learning-rate di tetapkan range 0.1 – 0.7 dan range yang sama
akan digunakan untuk nilai parameter momentum 0.1 – 0.7 dengan hidden layer adalah 1. Untuk
optimasi parameter pada Rapidminer menggunakan operator Optimize Parameters, nilai untuk
max generations adalah 50, Tournament fraction adalah 0.25 dan crossover prob adalah 0.9,
Population sebanyak 5.

Kedua kita menjelaskan penentuan hidden layer size, di artificial neural network memiliki 3
layer, pertama layer input,hidden layer,layer output. Metode ini menggunakan algoritma back
propagation neural network. Didalam penelitian ini menggunakan 2 teknik untuk menentukan
hidden layer yaitu Kolmogorov teorema: Satu hidden layer dan 2N +1 hidden neuron cukup
untuk N masukan (Siti Mariyam Hj Syamsuddin, 2004). , Jumlah hidden node dipilih
sembarang.

Ketiga kita menjelaskan ekperimen, dipenelitian ini input layer ada 4 atributmya ada
high,low,close,open. sedangkan hidden layer pemilihan jumlah neuron dengan menggunakan 3,
9, dan 15 node dan layer output menggunakan 1 atribut yaitu nilai close. Jika menentukan input
layer,hidden layer, dan output layer. Dari hasil yang kita dapatkan kombinasi optimasi parameter
yang berjumlah 44 pada parameter learning-rate dan momentum akan diujikan pada masing-
masing hidden layer yang sudah ditentukan pada 3 neuron (hidden layer default), 9 neuron dan
15 neuron. Seperti gambar dibawah ini
8. Kesimpulan

Jadi dari jurnal kedua dapat disimpulkan bahwa algoritma backpropagation dalam
prediksi hasil ujian kompetensi kebidanan menggunakan data input dan data output.
Sedangkan dari Jurnal pertama menggunakan metode algoritma ANN/ algoritma
backpropagation dapat memprediksi harga saham di Bank BRI.

9. Daftar Pustaka ANN

1. Umaidah,Yuyun(2018), PENERAPAN ALGORITMA ARTIFICIAL NEURAL NETWORK

DALAM PREDIKSI HARGA SAHAM LQ45 PT. BANK RAKYAT INDONESIA, TBK
:UNISKA,No.1,Hal 64
2. Arius Satoni Kurniawansyah(2018), IMPLEMENTASI METODE ARTIFICIAL NEURAL
NETWORK DALAM MEMPREDIKSI HASIl UJIAN KOMPETENSI KEBIDANAN
(STUDI KASUS: AKADEMI KEBIDANAN DEHASEN BENGKULU), Volume V Nomor
1 ,Hal 44
Metode Clustering K-Means
1. Konsep Dasar dari Metode

Algoritma K-means diartikan sebagain  pusat nya cluster dari cluster yang menjadikan rata-

rata point dari cluster  tersebut. Penerapan algoritma k-Means, misalkan diberikan sekumpulan
data X = {x1, x2, …,xn} dimana xi = (xi1, xi2, …, xin) adalah ystem dalam ruang real Rn, maka
algoritma k-Means menyusun partisi X  sejumlah k cluster (a priori). Jadi
setiap  klaster memiliki titik tengah yang merupakan nilai rata rata/mean dari data-
data  klaster itu. Tahap awalnya, algoritma k-Means memilih secara acak k buah obyek
sebagai titik tengah dalam data. Kemudian, jarak antara obyek dan titik tengah dihitung
menggunakan metode Euclidian distance. Algoritma k-Means secara iterative meningkatkan
variasi nilai dalam dalam tiap tiap klaster dimana obyek ditempatkan dalam kelompok yang
terdekat, dihitung dari titik tengah klaster. Dan metode K-means disebut metode yang tertua di
Clustering. Titik tengah yang baru ditentukan apabila semua data udah ditempatkan
dalam cluster  terdekat. Dalam proses penentuan ini titik tengah dan penempatan data
cluster diulangi sampai nilai titik tengah dari semua cluster yang terbentuk tidak dapat berubah
lagi atau sudah tetap.

2. Algoritma Metode Clustering K-Means

1. Ditentukan jumlah kelompok
2. Diarahkan data ke dalam kelompok secara acak
3. Hitung pusat kelompok rata-rata dari data yang ada di setiap kelompok
4. Diarahkan ke setiap data ke rata-rata terdekat.
 3. Kodingan K-Means C++

#include<iostream.h> #include<conio.h> void

main() t2=0;
{ //calculating new mean
int i1,i2,i3,t1,t2; for(t1=0;t1<i2;t1++)
{
int k0[10]; int k1[10]; int k2[10]; t2=t2+k1[t1];
}
cout<<"\nEnter 10 numbers:\n"; m1=t2/i2;
for(i1=0;i1<10;i1++)
{ t2=0;
cin>>k0[i1]; for(t1=0;t1<i3;t1++)
} {
t2=t2+k2[t1];
}
//initial means int m1; m2=t2/i3;
int m2;
//printing clusters
cout<<"\n Enter initial mean 1:"; cin>>m1; cout<<"\nCluster 1:";
cout<<"\n Enter initial mean 2:"; cin>>m2; for(t1=0;t1<i2;t1++)
{
int om1,om2;//old means do cout<<k1[t1]<<" ";
{ }
cout<<"\nm1="<<m1;
//saving old means om1=m1;
om2=m2;
cout<<"\nCluster 2:";
for(t1=0;t1<i3;t1++)
//creating clusters i1=i2=i3=0;
{
for(i1=0;i1<10;i1++)
{ cout<<k2[t1]<<" ";
//calculating distance to means t1=k0[i1]-m1; }
if(t1<0){t1=-t1;} cout<<"\nm2="<<m2;

t2=k0[i1]-m2; if(t2<0){t2=-t2;} cout<<"\n";

if(t1<t2) }while(m1!=om1&&m2!=om2);
{
//near to first mean k1[i2]=k0[i1]; i2++; cout<<"\n Clusters created";
} //ending getch();
else
{
//near to second mean k2[i3]=k0[i1];
}
i3++;
}

}
 4. Uraian Domain Implementasi

Pada Jurnal Pertama dapat di Implementasi Menggunakan K-Means

Implementasi Algoritma Proses Pengolahan Data b. Implementasi Algoritma K-Means c.
Implementasi Algoritma Proses Clustering d. Implementasi Algoritma Proses Pengujian
5. Data Yang Diolah

Data yang diperoleh adalah data Penjualan ada beberapa tahap pengumpulan data seperti data
sekunder,data primer.

Disini tahap data primer tahap yang memerlukan interaksi langsung dengan pihak eksekutif
CV. Alfa Fresh dengan cara melakukan wawancara yang bertujuan untuk mendapatkan informasi
dan data. Dan yang kedua tahap data sekunder memerlukan tahap sumber yang ada, seperti
jurnal, buku-buku ataupun dokumen yang erat kaitannya dengan objek permasalahan untuk
menjadi refrensi dan acuan dalam penulisan, seperti sumber cv. Alfa fresh yang sangat
membutuhkan

6. Konsep dari teknik evaluasi

Ditahap ini Sebuah pengelompokkan, seberapa baik kita memproses pengelompokkan dan
kualitas kelompok yang terbentuk. beberapa macam ukuran ketepatan untuk mengetahui
bagusnya suatu kelompok. satu ukuran ketepatan yang dapat digunakan sebagai menentukan
ketepatan pengelompokkan deret waktu dengan metode silhouette coefficient.

7. Hasil evaluasi dan analisa

Analisa yang dilakuan dengan memilih satu dari ketujuh inputan yang dimasukkan dengan
melihat nilai silhouette coefficien yang terbaik. Semua jumlah cluster yang dimasukkan untuk
cluster yang berjumlah 3 memiliki nilai silhouette coefficien yang paling mendekati nilai Si= 1,
yaitu dengan nilai 0,108690751. Dan dibagi menjadi 3 titik yaitu :

1. Hasil perhitungan di cluster 1, terlihat karakteristik mahasiswa pada cluster 1

didominasi oleh mahasiswa dengan jalur masuk perguruan tinggi melalui Minat dan
Kemampuan.
Cluster 1 terdiri dari 21 mahasiswa, dengan ciri-ciri dibawah ini:
a. Jalur masuk perguruan tinggi :
1) Minat dan kemampuan : 9 mahasiswa
2) UB IV : 7 mahasiswa
3) Jalur Prestasi Non Akademik : 5 mahasiswa
b. Pendapatan orang tua :
1) ≤1jt : 2 mhs
2) >1jt s/d ≤2jt : 2 mhs
3) >2jt s/d ≤3jt : 3 mhs
4) >3t s/d ≤4jt : 2 mhs
5) >4jt s/d ≤5jt : 2 mhs
6) >6jt s/d ≤7jt : 2 mhs
 7) >7jt s/d ≤8jt : 2 mhs
8) >8jt s/d ≤9jt : 1 mhs
9) >10jt : 5 mhs
c. Dengan rata-rata nilai IPK : 2.731

2. Hasil perhitungan di cluster 2, terlihat bahwa karakteristik mahasiswa pada cluster 2

tidak ada jalur masuk perguruan tinggi yang mendominasi.
Cluster 2 terdiri dari 7 mahasiswa, dengan deskripsi sebagai berikut :
a. Jalur masuk perguruan tinggi :
1) Kemitraan Instansi : 2 mhs
2) Kemitraan Daerah : 2 mhs
3) Alih Program : 2 mhs
4) Program Khusus Penyandang Disabilitas : 1 mhs
b. Dari pendapatan orang tua :
1) ≤1jt : 1 mhs
2) >1jt s/d ≤2jt : 1 mhs
3) >2jt s/d ≤3jt : 1 mhs
4) >3t s/d ≤4jt : 1 mhs
5) >10jt : 3 mhs
c. Dengan rata-rata nilai IPK : 2.8775

3. Hasil perhitungan di cluster 3, terlihat karakteristik mahasiswa pada cluster 3

terdiri dari mahasiswa yang masuk melalui jalur Reguler dan Jalur Prestasi
Akademik.
Cluster 3 terdiri dari 40 mahasiswa, dengan deskripsi sebagai berikut :
a. Jalur masuk perguruan tinggi :
1) Jalur Prestasi Akademik: 20 mhs
2) Reguler : 20 mhs
b. Dari pendapatan orang tua :
1) ≤1jt : 8 mhs
2) >1jt s/d ≤2jt : 5 mhs
3) >2jt s/d ≤3jt : 6 mhs
4) >3t s/d ≤4jt : 4 mhs
5) >4jt s/d ≤5jt : 4 mhs
6) >5jt s/d ≤6jt : 1 mhs
7) >6jt s/d ≤7jt : 3 mhs
8) >7jt s/d ≤8jt : 3 mhs
9) >8jt s/d ≤9jt : 1 mhs
10) >9jt s/d ≤10jt : 2 mhs
11) >10jt : 3 mhs
c. Dengan rata-rata nilai IPK : 3.471
8. Kesimpulan

jadi kesimpulannya dari Algoritma K-Means adalah dari kinerja akademik mahasiswa
adalah
1. Dari hasil 7 kali pengujian terhadap jumlah titik pusat dengan nilai 3, 4, 5, 6, 7, 8 dan 9
titik pusat, yang berjumlah 3 memiliki nilai silhouette coefficien yang paling mendekati
nilai Si= 1, yaitu dengan nilai 0,108690751.
2. Setelah proses pengolahan data, hasil clustering menunjukkan pendapatan orang tua
tidak dipengaruhi tingkatnya kinerja didalam bidang akademik mahasiswa.
3. Nilai akademis mahasiswa yang masuk perguruan tinggi ada 2 tahapan yaitu jalur
reguler dan jalur prestasi akademik mempunyai nilai IPK rata-rata tertinggi.

9. Daftar Pustaka

1. Fajar Nur Rohmat Fauzan Jaya Aziz1 , Budi Darma Setiawan2 , Issa Arwani3.(2018). Implementasi
Algoritma K-Means untuk Klasterisasi Kinerja Akademik Mahasiswa. Vol. 2, No. 6. Hal 9.
2. Cipta Nandita Putri1, Rika Sadariawati, S.E., M.Si. 2 , M. Aris Ganiardi, S.Si., M.T.3.(2018).
IMPLEMENTASI ALGORITMA K-MEANS UNTUK CLUSTERING DATA PENJUALANAN PADA CV. ALFA
FRESH.Hal 7

Reference dari ANN Dan K-means

1. @ankurm. 2015. Implementation Of K-Means Algorithm In C++.
2. https://socs.binus.ac.id/2017/03/09/clustering/
3. https://medium.com/@16611092/penerapan-artificial-neural-network-ann-dalam-r-
715c23808f28
4. https://frendypratamablog.wordpress.com/2018/01/03/makalah-neural-network/
5. elangsakti.com/2014/01/java-contoh-script-backpropagation-jst.html