BAB VII KESIMPULAN DAN SARAN
1. Diagram konteks
5.3 Implementasi Proses
5.3.1 Implementasi proses prediksi peserta
Proses prediksi peserta merupakan proses untuk mendapatkan jumlah peserta mata kuliah di masa depan dengan menggunakan data jumlah peserta pada masa lalu. Proses prediksi peserta diaplikasikan dengan menggunakan jaringan syaraf tiruan yang diterapkan dengan beberapa bentuk prosedur dan fungsi.
Proses prediksi peserta diterapkan menggunakan backpropagation yang merupakan metode pembelajaran terawasi pada jaringan syaraf tiruan. Backpropagation dapat memprediksi jumlah peserta mata kuliah melalui beberapa
78 langkah prosedur seperti yang ditunjukan pada gambar 5.2. Langkah utama yang dilakukan yakni dimulai dengan transformasi data, proses pelatihan, proses pengujian, dan transformasi ke data awal. Langkah-langkah tersebut diterapkan dengan beberapa fungsi yakni createWeight(), scale(), feedForward(),
prosesBackprop(), mse(), dan unscaleOutput(). Proses pelatihan untuk
mendapatkan bobot dilakukan secara berulang dan akan berhenti apabila telah mencapai batas jumlah epoch yang ditentukan atau nilai MSE (Mean Search Time) telah mencapai batas threshold yang ditentukan sebelumnya.
//jmlPattern = 3 //numInput = 4
// transformasi data pelatihan dataTrain pd range [0.1 - 0.9] data = scale(dataTrain, minDataTrain, maxDataTrain);
/*proses pelatihan untuk mendapatkan bobot*/
for e=1 to jmlEpoch do
//data nilai pada input layer
dataInput = data[e%jmlPattern];
//data nilai pada output layer
target = data[e%jmlPattern][numInput];
prosesBackprop(dataInput,target);
MSE = mse(target);
if( MSE < treshold){
break;
} }
/*proses pengujian*/
hasil = feedForward(ujiData);
//hasil ditransformasikan ke nilai awalnya
outHasil = unscaleOutput(hasil, minDataTrain, maxDataTrain);
Gambar 5.2 Algoritma proses prediksi peserta
1. createWeight()
Fungsi createWeight() merupakan fungsi yang digunakan untuk mendapatkan nilai bobot awal secara acak di setiap neuron pada masing-masing layer jaringan syaraf tiruan. Selain itu, fungsi ini juga memberi nilai -1 bobot pada bias. Nilai bobot sebelumnya diinisiasi dengan nilai 0 karna belum terjadi proses
79 pelatihan. Gambar 5.3 merupakan kode sumber fungsi createWeight() untuk mendapatkan nilai bobot awal.
public function createWeight(){
for($i=1; $i<$this->jmlLayer; $i++){
for($j=0; $j<$this->layersSize[$i]; $j++){
for($k=0; $k<$this->layersSize[$i-1]+1; $k++){
//pemberian nilai acak untuk bobot
$this->weight[$i][$j][$k] = $this->get_random();
}
//pemberian nilai acak untuk bobot pada bias
$this->weight[$i][$j][$this->layersSize[$i-1]] = -1; }
}
for($i=1; $i<$this->jmlLayer; $i++){
for($j=0; $j<$this->layersSize[$i]; $j++){
for($k=0; $k<$this->layersSize[$i-1]+1; $k++){
//bobot sebelumnya diset dengan nilai 0
$this->prevDwt[$i][$j][$k] = (double)0.0;
} }
} }
public function get_random(){
$randValue = LO + (HI - LO) * mt_rand(0, _RAND_MAX)/_RAND_MAX; return $randValue; //32767
}
Gambar 5.3 Kode sumber fungsi createWeight()
2. scale()
Fungsi scale() dipakai dalam mentransformasikan data pada range antara 0 hingga 1 karena akan digunakan dalam fungsi aktifasi sigmoid. Gambar 5.4 menunjukan proses transformasi data yang akan digunakan pada pelatihan.
80
public function scale($data, $min, $max){
//jumlah data pelatihan pertama
$numElem = count($data[0]); //4 $temp = 0.0;
for( $i=0; $i < $this->jmlPattern; $i++ ){
for($j=0; $j<$numElem; $j++){ $temp = (HI-LO)*(($data[$i][$j]-$min)/($max-$min))+LO; $data[$i][$j] = $temp; } } return $data; }
Gambar 5.4 Kode sumber fungsi scale()
3. feedForward()
Fungsi feedForward() merupakan fungsi yang dipakai untuk mendapatkan nilai output yang dihasilkan oleh fungsi aktifasi. Gambar 5.5 merupakan proses propagasi maju yang menghasilkan nilai output
public function feedForward($inputSource){ $sum = 0.0;
$numElem = count($inputSource); //4
//set nilai neuron input
for($i=0; $i<$numElem; $i++){
$this->output[0][$i] = $inputSource[$i]; }
for($i=1; $i<$this->jmlLayer; $i++){
for($j=0; $j<$this->layersSize[$i]; $j++){ $sum = 0.0;
for($k = 0;$k<$this->layersSize[$i-1]; $k++){
//jumlah perkalian nilai neuron dan bobot
$sum += $this->output[$i-1][$k] * $this->weight[$i][$j][$k]; }
//jumlahkan dengan bobot pada bias
$sum += $this->weight[$i][$j][$this->layersSize[$i-1]];
//nilai neuron pada hidden layer
$this->output[$i][$j] = $this->sigmoid($sum); }
}
}
public function sigmoid($x){
return (double)(1.0 / (1.0 + exp(-$x)));
}
81
4. prosesBackprop()
Fungsi prosesBackprop() merupakan fungsi yang digunakan untuk melatih bobot pada jaringan syaraf tiruan. Pada fungsi terbagi menjadi 2 metode di dalamnya yakni feed forward dan backward. Feed forward telah diterapkan pada fungsi feedForward(). Backward atau lebih dikenal dengan propagasi mundur merupakan metode untuk mendapatkan besar nilai galat atau error yang merupakan gambaran sejauh mana perbedaan dengan target. Nilai galat yang dihasilkan kemudian digunakan untuk mendapatkan perubahan bobot. Dengan menggunakan perubahan bobot tersebut maka dapat dihasilkan bobot baru untuk jaringan syaraf tiruan. Kode sumber fungsi prosesBackprop() ditunjukan pada gambar 5.6.
82 Gambar 5.6 Kode sumber fungsi prosesBackprop()
5. mse()
Fungsi mse() dipakai untuk menentukan besaran nilai MSE (Mean Search Time) yang digunakan untuk menghentikan proses pencarian bobot apabila
public function prosesBackprop($inputSource,$target){
/* --- Update the output values for each neuron */
$this->feedForward($inputSource);
$n = $this->jmlLayer;
for($i=0;$i<$this->layersSize[$n-1];$i++){
$y_out = $this->output[$n-1][$i];
//hitung delta pada output layer
$this->delta[$n-1][$i]= $y_out*(1-$y_out)*($target-$y_out);
}
for($i=$n-2;$i>0;$i--){
for($j=0; $j<$this->layersSize[$i]; $j++){
$d_net=0.0;
for($k=0; $k<$this->layersSize[$i+1]; $k++){
//hitung jumlahan delta dan bobot untuk hidden layer
$d_net += $this->delta[$i+1][$k]*$this->weight[$i+1][$k][$j];
}
$z_out = $this->output[$i][$j];
//hitung delta pada hidden layer
$this->delta[$i][$j] = $z_out*(1-$z_out)*$d_net;
}
}
//learning rate
$a = $this->lr;
for($i=1; $i<$n; $i++){
$jmlNrnPrv = $this->layersSize[$i-1];
for($j=0;$j<$this->layersSize[$i];$j++){
for($k=0; $k<$jmlNrnPrv; $k++){
//delta
$d = $this->delta[$i][$j];
//nilai neuron
$x = $this->output[$i-1][$k];
//hitung perubahan bobot
$this->prevDwt[$i][$j][$k] = $a*$d*$x;
//hitung nilai bobot baru
$this->weight[$i][$j][$k] += $this->prevDwt[$i][$j][$k];
}
//hitung perubahan bobot pada bias
$this->prevDwt[$i][$j][$jmlNrnPrv] = $a*$this->delta[$i][$j];
$delta_w = $this->prevDwt[$i][$j][$jmlNrnPrv];
//hitung nilai bobot baru pada bias
$this->weight[$i][$j][$jmlNrnPrv] += $delta_w;
}
} }
83 nilainya sudah melebihi threshold yang ditentukan. Gambar 5.7 menunjukan perhitungan nilai MSE.
public function mse($t){ $mse = 0;
$n = $this->jmlLayer;
for($i=0; $i<$this->layersSize[$n-1]; $i++){
$mse+=($t-$this->output[$n-1][$i])*($t-$this->output[$n-1][$i]);
}
$mse = $mse/2;
return $mse; }
Gambar 5.7 Kode sumber fungsi mse()
6. unscaleOutput()
Fungsi unscaleOutput() merupakan fungsi yang digunakan untuk mengembalikan hasil transformasi data ke bentuk asalnya. Gambar 5.8 merupakan bagaimana proses pengembalian transformasi data ke bentuk asalnya.
public function unscaleOutput($outputVector, $min, $max){ $temp=0.0;
$temp = ($max-$min) * (($outputVector - LO) / (HI-LO)) + $min ; $unscaledVector = $temp;
return $unscaledVector; }
Gambar 5.8 Kode sumber unscaleOutput() 5.3.2 Implementasi proses pembangkitan kelas
Proses pembangkitan kelas merupakan proses yang dilakukan untuk membuat kelas-kelas mata kuliah berdasarkan jumlah prediksi yang didapatkan. Kelas dibuat dengan beberapa aturan sesuai dengan jumlah peserta hasil prediksi dan batas jumlah kelas. Aturan tersebut terdiri dari 3 kondisi utama yakni apabila jumlah peserta prediksi kurang dari batas minimal kelas (i), jika lebih dari atau sama dengan batas minimal kelas dan kurang dari atau sama dengan batas
84 maksimal kelas (ii), dan jika lebih dari batas maksimal kelas (iii). Gambar 5.9 merupakan algoritma pembangkitan kelas.
//data prodi berdasarkan mata kuliah mkProdi = get_base_mkprodid_by_mkid(idmk);
kelas = array();
if pred_jml_peminat < bts_kls_min do
if sifat_makul = 'W' do
//set nama kelas dengan kode mata kuliah
nama_kelas = kd_mk;
//set jumlah peserta kelas dengan hasil prediksi
jumlah_per_kelas = pred_jml_peminat;
//set data kelas
kelas[] = daftarkanKelas(nama_kelas,jumlah_per_kelas);
else
kelas[] = null;
elseif pred_jml_peminat >= bts_kls_min
AND pred_jml_peminat <= bts_kls_max do
if makul_is_universal() OR count(mkProdi)==0 do
nama_kelas = kd_mk;
jumlah_per_kelas = pred_jml_peminat;
kelas[] = daftarkanKelas(nama_kelas,jumlah_per_kelas);
else
prodi_mk = mkProdi.prodi_kode;
for i=1 to count(mkProdi) do
prodi_mk .= mkProdi.prodi_kode;
nama_kelas = prodi_mk.'-'.kd_mk;
jumlah_per_kelas = pred_jml_peminat;
kelas[] = daftarkanKelas(nama_kelas,jumlah_per_kelas); else
//set batas maks kelas
a = bts_kls_max;
//set kode mata kuliah
b = kd_mk;
if makul_is_universal() do
prodi_mk = '';
is_universal = true;
kelas = klasifikasi(a, b, jml_porsi,prodi_mk,is_unvrsl);
else
if (count(mkProdi)>0) do
for i=1 to count(mkProdi) do prodi_mk = mkProdi.prodi_kode;
if i == 0 do
jml_porsi += mkProdi.sisa; is_universal = false;
kelas_temp = klasifikasi(a,b,jml_porsi,prodi_mk,is_unvrsl);
for j=1 to count(kelas_temp) do
kelas[] = kelas_temp[j];
else
prodi_mk = '';
is_universal = false;
kelas = klasifikasi(a,b,jml_porsi,prodi_mk,is_unvrsl);
85 Pada kondisi ketika jumlah peserta prediksi lebih dari batas maksimal kelas maka akan dibuat kelas paralel. Kelas paralel memiliki urutan abjad untuk membedakan masing-masing kelas. Pengimplementasian kelas ini diterapkan dengan memakai fungsi klasifikasi() seperti yang ditunjukan pada gambar 5.10.
function klasifikasi(bts_kls_max, kd_mk, jml_porsi, prodi_mk, is_unvrsl){
//hitung jumlah kelas dengan pembulatan ke atas
kelas_bagi = ceil(jml_porsi/bts_kls_max) ;
//hitung sisa
mod = jml_porsi % kelas_bagi;
for i=1 to kelas_bagi do
//hitung daya tampung kelas
jumlah_per_kelas = floor(jml_porsi / kelas_bagi); if mod > 0 AND i==1 do
jumlah_per_kelas = floor(jml_porsi / kelas_bagi)) + mod;
}
kelas_nama = '';
if is_unvrsl do
if kelas_bagi>1 do
kelas_nama = i+1;
//set nama kelas paralel dengan urutan angka
nama_kelas = kd_mk.'-'.kelas_nama;
else
if kelas_bagi>1 do
//set urutan abjad untuk nama kelas
kelas_nama = chr(i+65);
if prodi_mk == '' do
//set nama kelas paralel
nama_kelas = kd_mk.'-'.(kelas_nama!=''?kelas_nama:'');
else
kelas_nama!=''?kelas_nama.'-'.kd_mk:kd_mk;
//set nama kelas paralel
nama_kelas = prodi_mk.'-'.kelas_nama; //set data kelas
kelas[] = daftarkanKelas(nama_kelas,jumlah_per_kelas);
return kelas; }
Gambar 5.10 Kode sumber fungsi klasifikasi() 5.3.3 Implementasi proses pembuatan jadwal
Pembuatan jadwal mata kuliah hanya dapat dilakukan ketika telah terdapat kelas-kelas mata kuliah yang telah dilengkapi dengan dosen pengajarnya. Pembuatan jadwal mata kuliah ini diimplementasikan dengan menggunakan algoritma genetika. Untuk menghasilkan solusi jadwal mata kuliah, terdapat
86 beberapa fungsi yang harus dilalui diantaranya generate_population(),
update_population(), count_fitness(), roulette_wheel_selection(), crossover(),
mutation(), dan update_selection(). Gambar 5.11 merupakan proses-proses di
dalam algoritma genetika untuk mendapatkan jadwal mata kuliah.
for i=1 to jumlah_generasi do
if i == 0 do
//pembangkitan populasi pada generasi pertama
generate_population();
else
//pembaruan populasi
update_population();
//perhitungan nilai fitness
count_fitness(); //proses seleksi roulette_wheel_selection(); crossover(); mutation(); update_selection(); }
//pengambilan solusi dari hasil proses algoritma genetika solusi = get_solution();
Gambar 5.11 Algoritma proses pembuatan jadwal
1. generate_population()
Fungsi generate_population() merupakan fungsi yang digunakan untuk membuat populasi awal yang tersusun dari individu-individu pembentuk solusi yang layak atau telah sesuai dengan aturan umum yang telah ditetapkan. Gambar 5.12 menunjukan proses pembangkitan populasi. Fungsi ini akan mengeksekusi fungsi create_ind() untuk membentuk individu di dalam populasi.
public function generate_population(){
//data kelas
$this->kromosom = $this->create_information_class(); $this->populasi = array();
for ($i=0; $i < $this->post['jml_ind']; $i++) {
//pembuatan ind
$this->populasi[] = $this->create_ind();
} }
87 Fungsi create_ind() membuat individu sebagai pilihan solusi jadwal mata kuliah yang telah layak. Gambar 5.13 menunjukan proses pembuatan individu yang memenuhi aturan.
public function create_ind(){
// untuk menampung sejumlah ind yang mewakili jadwal
$ind = array();
// untuk mengelompokan kelas berdasar matakuliahnya.
$mkGrup = array();
// data grup waktu_id kelas berdasar makulnya.
$wktGrup = array();
// matriks data ruang, hari, dan waktu
$timeSpace = $this->timeSpace;
foreach ($this->kromosom as $key => $val) {
$arr_data = compact('timeSpace','ind','val','mkGrup','wktGrup');
//tiap gen diberi value ruang dan waktu
$ret_data = $this->get_feasible_ind($arr_data);
extract($ret_data);
}
return $ind; }
Gambar 5.13 Kode sumber fungsi create_ind()
2. update_population()
Fungsi update_population() merupakan fungsi untuk memperbarui populasi yang tersusun dari individu layak atau tidak melanggar aturan umum yang ditetapkan. Gambar 5.14 menunjukan proses pembaruan populasi.
public function update_population(){
$this->populasi = array();
//individu hasil proses genetika diperbaiki sesuai aturan umum
foreach ($this->populasi_baru as $key => $value) {
$this->populasi[] = $this->repairing_individu($value);
}
$this->populasi_baru = null; }
Gambar 5.14 Kode sumber fungsi update_population()
3. count_fitness()
Fungsi count_fitness() digunakan untuk menghitung nilai fitness pada suatu individu. Pada proses perhitungan nilai fitness dibagi dalam beberapa tahap
88 perhitungan nilai pelanggaran pada masing-masing aturan khusus. Gambar 5.15 merupakan proses penentuan nilai fitness pada masing-masing individu.
public function count_fitness(){
foreach ($this->populasi as $i => $ind) {
//hitung fitness aturan khusus ke-1
$fit1 = $this->fitness_klsmk_pilihan_wajib_not_sametime($ind);
//hitung fitness aturan khusus ke-2
$fit2 = $this->fitness_klsmk_on_ruangblokprodi($ind);
//hitung fitness aturan khusus ke-3
$fit3 = $this->fitness_klsmk_sepaket_max_8_sks_sehari($ind);
//hitung fitness aturan khusus ke-4
$fit4 = $this->fitness_kls_filled_min_prosen_capacity($ind);
//hitung fitness aturan khusus ke-5
$fit5 = $this->fitness_kls_dosen_choose_their_time($ind);
//total fitness aturan khusus
$totFitRule = $fit1+$fit2+$fit3+$fit4+$fit5;
//nilai fitness per individu
$fitness = 1-(($totFitRule) / 5);
//fitness ditambahkan pada data populasi
$this->populasi_breeding[$i]['fitness'] = $fitness;
//total fitness pada populasi
$this->total_fitness += $fitness;
} }
Gambar 5.15 Kode sumber fungsi count_fitness()
4. roulette_wheel_selection()
Fungsi roulette_wheel_selection() merupakan fungsi untuk melakukan seleksi terhadap individu pada populasi yang akan dipilih sebagai kandidat parent
crossover. Gambar 5.16 menunjukan proses seleksi menggunakan roulette wheel
selection. Pemilihan parent dilakukan secara acak dengan menggunakan nilai
89
public function roulette_wheel_selection(){
//populasi dari individu terpilih
$popBreeding = $this->popBreeding;
foreach ($popBreeding as $i => $value) {
//hitung probabilitas fitness
$prob = $value['fitness'] / $this->total_fitness;
$popBreeding[$i]['idx'] = $i;
$popBreeding[$i]['prob'] = round($prob,5);
//kondisi pembuatan range roulette pada nilai awal
if ($i == 0) {
$range[$i]['awal']=0;
}else{
$range[$i]['awal']=$range[($i-1)]['akhir']+0.00001;
}
//pembuatan rentangan roulette pada nilai akhir
$range[$i]['akhir']=$range[$i]['awal']+$popBreeding[$i]['prob'];
//set nilai acak
$random_number[$i] = mt_rand(0,100000)/100000;
}
$pick_individu = array();
foreach ($random_number as $i => $val) {
foreach ($range as $j => $vale) {
if ($val >= $vale['awal'] and $val <= $vale['akhir'] ) {
//proses roulette wheel
$pick_individu[] = $j;
}
}
}
for ($i=0; $i < $this->post['jml_individu']; $i++) {
//data populasi untuk breeding
$popBreedingSelected[] = $popBreeding[$pick_individu[$i]];
}
foreach ($popBreedingSelected as $i => $value) {
// nilai acak untuk crossover
$popBreedingSelected[$i]['val_random']=mt_rand(0,100000)/100000; }
// set total fitness 0 karna sudah digunakan
$this->total_fitness = 0;
//simpan data populasi breeding
$this->populasi_breeding_selected = $popBreedingSelected; }
Gambar 5.16 Kode sumber fungsi roulette_wheel_selection()
5. crossover()
Fungsi crossover() digunakan sebagai proses crossover atau pindah silang. Tiap individu yang terpilih sebagai parent dibangkitkan nilai acak yang kemudian dibandingkan dengan nilai Pc atau probabilitas crossover. Apabilai nilai acak tersebut lebih kecil atau sama dengan dari Pc maka parent akan mengalami pindah silang dan menghasilkan 2 offspring. Crossover yang digunakan adalah
2-90
point crossover dengan pemilihan titik pada gen ke-2 hingga ke-(n-1). Ketika
individu telah mengalami mutasi maka dilakukan pengecekan kembali pada masing-masing gen terhadap aturan umum untuk kemungkinan terjadi pelanggaran. Apabila terjadi pelanggaran terhadap aturan umum maka dilakukan perbaikan dengan cara mencari waktu dan ruang yang lain yang belum terpakai. Gambar 5.17 menunjukan proses crossover atau pindah silang.
public function crossover(){
$pop = array();
foreach ($this->populasi_breeding_selected as $key => $value) {
if ($value['val_random'] <= $this->pc) {
//populasi crossover
$pop[] = $value;
}
}
//hitung jumlah gen
$n_gen = count($pop[0]['arr_gen']);
//hitung jumlah individu
$n_ind = count($pop);
//set titik potong
$pointRandom = array(mt_rand(2,$n_gen-1), mt_rand(2,$n_gen-1) );
for ($i=0; $i < $n_ind-1 ; $i++) {
//proses breeding secara sekuensial
$this->build_offspring($pop[$i],$pop[$i+1],$pointRandom); }
//proses breeding sekuen terakhir
$this->build_offspring($pop[($n_ind-1)],$pop[0],$pointRandom); }
Gambar 5.17 Kode sumber fungsi crossover()
6. mutation()
Fungsi mutation() merupakan proses mutasi yang terjadi pada individu. Proses mutasi terjadi pada individu dengan cara membangkitkan nilai acak antara 0 dan 1 kemudian dibandingkan dengan Pm atau probabilitas mutasi, apabila nilai acak tersebut lebih kecil maka mutasi dilakukan pada individu tersebut. Ketika individu telah mengalami mutasi maka dilakukan pengecekan kembali pada masing-masing gen terhadap aturan umum untuk kemungkinan terjadi pelanggaran. Apabila terjadi pelanggaran terhadap aturan umum maka dilakukan perbaikan dengan cara mencari waktu dan ruang yang lain yang belum terpakai. Gambar 5.18 menunjukan proses mutasi pada individu.
91
public function mutation(){
foreach ($this->ind_breed as $key => $value) {
foreach ($value as $i => $item) {
if ($item['randvalmut'] < $this->pm) {
//proses mutasi pada offspring
$o = $this->mutasi_kromosom($item['offspring']);
//memperbarui offspring
$this->ind_breed[$key][$i]['offspring'] = $o
}
$this->ind_update_calon[] = $this->ind_breed[$key][$i];
}
}
$this->ind_breed = null; }
Gambar 5.18 Kode sumber fungsi mutation()
7. update_selection()
Fungsi update_selection() merupakan fungsi yang digunakan untuk memperbarui populasi. Populasi tersebut berasal dari offspring hasil crossover dan mutasi serta individu pada seleksi sebelum dilakukan breeding. Kemudian kumpulan individu tersebut diseleksi kembali menggunakan seleksi roulette wheel
selection dan menghasilkan individu untuk populasi pada generasi selanjutnya.
92
public function update_selection(){
$populasi_breeding = $this->populasi_breeding;
$this->populasi_breeding = array();
//data populasi hasil seleksi awal
foreach ($populasi_breeding as $key => $value) {
$this->populasi_breeding[] = array(
'fitness' => $value['fitness'],
'arr_gen' => $value['arr_gen']
);
}
//data populasi hasil mutasi
foreach ($this->individu_update_calon as $key => $value) {
$this->populasi_breeding[] = array(
'fitness' => $value['fitness'],
'arr_gen' => $value['offspring']
);
}
//hitung total fitness populasi hasil breeding
$this->total_fitness = $this->count_total_fitness_pop_breeding();
//proses seleksi kembali
$this->roulette_wheel_selection();
foreach ($this->populasi_breeding_selected as $key => $value) {
//populasi baru hasil breeding
$this->populasi_baru[] = $value['arr_gen'];
}
$this->individu_update_calon = null; }
Gambar 5.19 Kode sumber fungsi update_selection() 5.4 Implementasi Antarmuka
Implementasi antarmuka merupakan penerapan dari hasil rancangan antarmuka dengan menggunakan aplikasi berbasis web. Pada implementasi antarmuka ini terdiri dari implementasi halaman pengelolaan, halaman pengelolaan mata kuliah, halaman rekapitulasi jumlah peserta mata kuliah, halaman input proses prediksi, halaman prediksi jumlah peserta mata kuliah, halaman input pembangkitan kelas, halaman daftar kelas, halaman input proses penjadwalan, dan halaman jadwal mata kuliah.