Algoritma SOM (Self Organizing Maps) 2

Algoritma SOM (Self Organizing Maps) adalah salah satu algoritma berbasis jaringan saraf yang dapat digunakan untuk pengambilan keputusan. Contoh yang dibahas kali ini adalah mengenai penentuan penerimaan pengajuan kredit sepeda motor baru berdasarkan kelompok data yang sudah ada.
Inti perhitungan pada algoritma berbasis jaringan adalah untuk mencari bobot terbaik dari contoh / sampel data yang sudah ada. Karena hasil pada contoh data sudah diketahui, maka nilai bobot akan dihitung berdasarkan nilai hasil yang sudah tersedia, sampai ditemukan nilai bobot terbaik yang paling banyak cocok apabila dihitungkan kembali pada data awal. Kemudian nilai bobot tersebut dapat digunakan untuk menghitung data lain yang tidak diketahui hasilnya. Pada kasus ini, metode yang digunakan untuk mencari bobot terbaik adalah menggunakan metode PSO (Particle Swarm Optimization)
Berbeda dengan algoritma berbasis jaringan saraf sebelumnya yang hasil output pada contoh datanya sudah diketahui, algoritma ini tidak memerlukan nilai output pada data yang akan dipelajari, dan teknik ini dinamakan unsupervised learning. Algoritma ini akan menghasilkan representasi dari data input dengan dimensi rendah (biasanya 2 dimensi) kedalam sebuah ruang yang biasa disebut map. Jika algoritma berbasis jaringan saraf lainnya menggunakan teknik koreksi nilai kesalahan untuk mencocockan data dengan hasil akhir, maka algoritma ini menggunakan sistem saraf pusat dan melakukan update bobot pada saraf disekitar saraf pusat.

Diasumsikan ada 20 orang siswa, yaitu siswa A sampai dengan T
Masing-masing siswa memiliki rata-rata nilai IPA, IPS, dan Bahasa yang berbeda-beda
Diasumsikan data awal nilai siswa adalah sebagai berikut

Contoh data siswa adalah sebagai berikut:

Dim label(19) As String
For i As Integer = 0 To 19
	label(i) = "Siswa " & Chr(i + 65)
Next

Dim data As Double()() = {New Double() {50, 60, 70}, _
						  New Double() {65, 80, 73}, _
						  New Double() {72, 70, 65}, _
						  New Double() {83, 65, 80}, _
						  New Double() {40, 82, 73}, _
						  New Double() {95, 71, 85}, _
						  New Double() {60, 74, 96}, _
						  New Double() {75, 75, 92}, _
						  New Double() {83, 55, 70}, _
						  New Double() {91, 60, 65}, _
						  New Double() {92, 91, 55}, _
						  New Double() {76, 80, 59}, _
						  New Double() {75, 65, 74}, _
						  New Double() {74, 76, 89}, _
						  New Double() {63, 79, 69}, _
						  New Double() {58, 93, 76}, _
						  New Double() {82, 50, 80}, _
						  New Double() {81, 65, 88}, _
						  New Double() {76, 74, 70}, _
						  New Double() {77, 71, 55}}

Sebelum masuk kedalam langkah-langkah pembahasan algoritma, ada beberapa konstanta atau parameter yang harus diketahui, yaitu:
* Tentukan dimensi, yaitu jumlah bobot yang digunakan dalam masing-masing data
Diasumsikan dalam kasus ini, digunakan 3 buah bobot sesuai kolom kriteria yaitu jurusan IPA, jurusan IPS, jurusan Bahasa

Const dimensi As Integer = 3

* Tentukan ukuran map yang akan digunakan dalam pemetaan
Diasumsikan dalam kasus ini akan digunakan peta dengan ukuran 10 satuan

Const ukuranMap As Integer = 10

* Tentukan batas kesalahan minimal yang digunakan
Jika nilai kesalahan sudah lebih rendah dari batas kesalahan minimal ini, maka perhitungan akan dihentikan
Diasumsikan dalam kasus ini akan digunakan angka 0.00001 sebagai batas kesalahan minimal

Const batasKesalahanMinimal As Double = 0.00001

Langkah-langkah penggunaan algoritma ini adalah

1. Lakukan inisialisasi map dan bobot yang digunakan

Dim som As New Map(dimensi, ukuranMap)

* Skrip tersebut akan melakukan inisialisasi pada Class Map. Class ini berisi tentang variabel dan fungsi-fungsi yang digunakan untuk melakukan dekomposisi. Deklarasi Class Map adalah sebagai berikut:

Public Class Map
	Private outputs As Saraf(,)     ' daftar bobot dari masing-masing saraf output
	Private iterasi As Integer      ' indeks iterasi yang sedang berjalan
	Private ukuranMap As Integer    ' ukuran dari grid output
	Private dimensi As Integer      ' jumlah dimensi input, menentukan ukuran bobot pada masing-masing saraf output
	Private rnd As New Random(4)

	Private daftarLabel As New List(Of String)()
	Private daftarInput As New List(Of Double())()

	Public Sub New(dimensi As Integer, ukuranMap As Integer)
		Me.ukuranMap = ukuranMap
		Me.dimensi = dimensi

		'Lakukan inisialisasi bobot output dengan nilai acak antara 0 sampai dengan 1
		outputs = New Saraf(ukuranMap - 1, ukuranMap - 1) {}
		For i As Integer = 0 To ukuranMap - 1
			For j As Integer = 0 To ukuranMap - 1
				outputs(i, j) = New Saraf(i, j, ukuranMap)
				outputs(i, j).bobot = New Double(dimensi - 1) {}
				For k As Integer = 0 To dimensi - 1
					outputs(i, j).bobot(k) = rnd.NextDouble()
				Next
			Next
		Next
	End Sub
	
	. . .
End Class

2. Lakukan proses pengelompokan data menggunakan algoritma ini
Penjelasan lebih detail tentang fungsi ini dapat dilihat pada penjelasan skrip dibawah ini (poin 2a – 2c)

som.ProsesPerhitungan(data, label, batasKesalahanMinimal)

Memasuki proses perhitungan pada fungsi prosesPerhitungan

2a. Lakukan proses penampungan data ke dalam variabel lokal

For i As Integer = 0 To data.Length - 1
	daftarLabel.Add(label(i))
	daftarInput.Add(data(i))
Next

2b. Lakukan normalisasi input jika diperlukan
Dalam kasus ini setiap data akan dibagi dengan jumlah dari setiap kolom

For j As Integer = 0 To dimensi - 1
	Dim total As Double = 0
	For i As Integer = 0 To daftarInput.Count - 1
		total += daftarInput(i)(j)
	Next
	Dim rata2 As Double = total / daftarInput.Count
	For i As Integer = 0 To daftarInput.Count - 1
		daftarInput(i)(j) = daftarInput(i)(j) / rata2
	Next
Next

2c. Lakukan proses perhitungan selama ditemukan nilai kesalahan yang lebih dari nilai batas kesalahan minimal (poin 2c1 – 2c3)

Dim nilaiKesalahan As Double = Double.MaxValue
While nilaiKesalahan > batasKesalahanMinimal
	nilaiKesalahan = 0
	. . .

2c1. Masukkan semua data input sebagai data latih

Dim daftarTrainingSet As New List(Of Double())()
For Each input As Double() In daftarInput
	daftarTrainingSet.Add(input)
Next

2c2. Lakukan perhitungan sebanyak jumlah data input (poin 2c2a – 2c2e)

For idxInput As Integer = 0 To daftarInput.Count - 1
. . .

2c2a. Tentukan data input secara acak

Dim input As Double() = daftarTrainingSet(rnd.[Next](daftarInput.Count - idxInput))

2c2b. Hitung saraf output pemenang untuk input data ini
Penjelasan lebih detail tentang fungsi ini dapat dilihat pada penjelasan skrip dibawah ini

Dim sarafPemenang As Saraf = HitungSarafOutputPemenang(input)

* Skrip tersebut akan melakukan inisialisasi pada Class Saraf. Class ini berisi tentang variabel dan fungsi-fungsi yang digunakan untuk melakukan dekomposisi. Deklarasi Class Saraf adalah sebagai berikut:

Public Class Saraf
	Public bobot As Double()        ' bobot saraf
	Public koordinatX As Integer    ' koordinat sumbu x pada map
	Public koordinatY As Integer    ' koordinat sumbu y pada map
	Private ukuranMap As Integer    ' digunakan untuk menghitung radius kekuatan (Strength) terhadap saraf disekitar
	Private nf As Double            ' digunakan untuk menghitung radius kekuatan (Strength) terhadap saraf disekitar

	Public Sub New(koordinatX As Integer, koordinatY As Integer, ukuranMap As Integer)
		Me.koordinatX = koordinatX
		Me.koordinatY = koordinatY
		Me.ukuranMap = ukuranMap
		nf = 1000 / Math.Log(ukuranMap)
	End Sub
	
	. . .
End Class

* Gunakan fungsi ini untuk mencari saraf output pemenang sebagai saraf pusat
Hitung jarak Euclidean antara data input dan bobot output
Kemudian cari saraf dengan nilai jarak paling minimal

Public Function HitungSarafOutputPemenang(input As Double()) As Saraf
	Dim sarafPemenang As Saraf = Nothing
	Dim minJarak As Double = Double.MaxValue

	'Lakukan perhitungan pada setiap map
	For i As Integer = 0 To ukuranMap - 1
		For j As Integer = 0 To ukuranMap - 1
			'Hitung jarak Euclidean antara data input dan bobot output
			Dim totalJarak As Double = 0
			For k As Integer = 0 To input.Length - 1
				totalJarak += Math.Pow((input(k) - outputs(i, j).bobot(k)), 2)
			Next
			Dim jarak As Double = Math.Sqrt(totalJarak)

			'Jika nilai jarak ini merupakan jarak yang paling minimal, 
			'maka ambil saraf ini sebagai saraf pemenang
			If jarak < minJarak Then
				minJarak = jarak
				sarafPemenang = outputs(i, j)
			End If
		Next
	Next
	Return sarafPemenang
End Function

2c2c. Lakukan perhitungan bobot pada masing-masing map
Gunakan saraf pemenang sebagai saraf inti, dan lakukan update bobot pada saraf disekitar saraf pemenang
Kemudian hitung nilai kesalahan dari bobot tersebut

Dim tmpNilaiKesalahan As Double = 0
For i As Integer = 0 To ukuranMap - 1
	For j As Integer = 0 To ukuranMap - 1
		tmpNilaiKesalahan += outputs(i, j).UpdateBobot(input, sarafPemenang, iterasi)
	Next
Next

* Gunakan fungsi ini untuk melakukan update nilai bobot pada saraf terpilih

Public Function UpdateBobot(input As Double(), sarafPemenang As Saraf, iterasi As Integer) As Double
	Dim totalBobot As Double = 0
	For i As Integer = 0 To bobot.Length - 1
		Dim delta As Double = rasioPembelajaran(iterasi) * nilaiGauss(sarafPemenang, iterasi) * (input(i) - bobot(i))
		bobot(i) += delta
		totalBobot += delta
	Next
	Return totalBobot / bobot.Length
End Function

2c2d. Tambahkan nilai kesalahan dengan rata-rata nilai kesalahan bobot tersebut.

nilaiKesalahan += Math.Abs(tmpNilaiKesalahan / (ukuranMap * ukuranMap))

2c2e. Hilangkan data input yang sudah dihitung agar tidak terpilih lagi

daftarTrainingSet.Remove(input)

2c3. Langkah opsional: tulis nilai kesalahan setiap 100 kali perulangan

If iterasi Mod 100 = 0 Then
	Console.WriteLine("Iterasi " & (iterasi).ToString.PadRight(4) & ", nilai kesalahan " & nilaiKesalahan.ToString("0.0000000"))
End If

Hasil akhir adalah: (klik untuk perbesar gambar)

Contoh modul / source code dalam bahasa VB (Visual Basic) dapat didownload disini:

Jika membutuhkan jasa kami dalam pembuatan program, keterangan selanjutnya dapat dilihat di Fasilitas dan Harga
Jika ada yang kurang paham dengan langkah-langkah algoritma diatas, silahkan berikan komentar Anda.
Selamat mencoba.