Deep Learning: Self-Organizing Maps (aplikasi)

Deep Learning: Self-Organizing Maps (aplikasi)

Catatan penting : Jika pembaca benar-benar awam tentang apa itu Python, silakan klik artikel saya ini


Di artikel sebelumnya saya sudah bahas tentang salah satu teknik unsupervised deep learning yaitu SOM (self-organizing maps). Kali ini kita akan coba mengaplikasikan teori ini untuk membantu sektor perbankan dalam mendeteksi kecurangan aplikasi kartu kredit.

Perlu diingat bahwa teknik SOM bukanlah teknik yang paling akurat dalam aplikasi deteksi kecurangan aplikasi kartu kredit kali ini. Ada banyak teknik lain yang bisa dilakukan. Namun, kita akan memulainya dengan menggunakan SOM.

Data yang diambil merupakan data perbankan di negara Australia dengan sedikit penyesuaian untuk menjaga kerahasiaan data nasabah. Dataset yang kita gunakan ini didapatkan dari sebuah repository data untuk machine learning melalui link ini.

Sekilas tampilan datasetnya tampak sebagai berikut:

Ilustrasi dataset apikasi kartu kredit

Kita memiliki sekian banyak kolom dan baris, yaitu 16 kolom (mulai dari CustomerID hingga Class) dan 690 baris (690 nasabah).

Beberapa keterangan dari masing-masing kolom adalah sebagai berikut:

  • CustomerID : Adalah nomor identitas tiap nasabah.
  • A1-A14 : tidak diberi keterangan lebih lanjut dari sumbernya apa yang dimaksud dengan masing-masing kolom.
  • Class : Keterangan apakah aplikasi kartu kredit disetujui (1) atau tidak (0).
Tampilan keterangan kolom dari sumber dataset

Dalam aplikasi SOM kali ini, kita tidak perlu memahami nama dari masing-masing kolom (variabel), karena semua kolom nantinya akan digabungkan menjadi 2 kolom saja. Walau demikian, ada 2 kolom penting dalam penerapan SOM dalam konteks oendeteksian kecurangan aplikasi kartu kredit kali ini, yaitu kolom pertama (CustomerID) dan kolom terakhir (Class). Kolom pertama akan kita gunakan untuk mengetahui customers mana yang cenderung melakukan kecurangan. Kolom kedua akan kita gunakan untuk mencari hubungan antara customers yang melakukan kecurangan, dengan hasil keputusan aplikasi kartu kreditnya oleh pihak bank.

Sebelum kita mulai praktek cara membuat SOM untuk mendeteksi kecurangan aplikasi kartu kredit, silakan download datasetnya di link ini.

Setelah mengunduh (download) datasetnya, sekarang download library minisom (berupa script python) untuk melakukan proses SOM di python. Silakan download minisom di link ini. Setelah mengunduh minisom, silakan ekstrak filenya menggunakan winrar, winzip atau aplikasi serupa. Lalu tempatkan file minisom satu folder dengan dataset yang ingin diolah.


Bahasa Python

# Mengimpor library yang diperlukan
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Mengimpor dataset
dataset = pd.read_csv('Credit_Card_Applications.csv')
X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, -1].values

# Feature Scaling
from sklearn.preprocessing import MinMaxScaler
sc = MinMaxScaler(feature_range = (0, 1))
X = sc.fit_transform(X)

# Tentukan ukuran grid SOM
baris = 13
kolom = 10

# Proses training SOM
from minisom import MiniSom
som = MiniSom(x = baris, y = kolom, input_len = 15, sigma = 1.0, learning_rate = 0.5, random_seed = 2)
som.random_weights_init(X)
som.train_random(X, 1000)

# Memvisualisasikan hasilnya
plt.jet()
plt.pcolor(som.distance_map().T)
plt.colorbar()
markers = ['D', 'P']
colors = ['k', 'w']
for i, x in enumerate(X):
    koordinat = som.winner(x)
    plt.plot(koordinat[0] + 0.5,
         koordinat[1] + 0.5,
         markers[y[i]],
         markeredgecolor = colors[y[i]],
         markerfacecolor = 'None',
         markersize = 10,
         markeredgewidth = 2)
plt.show()

# Membuat index SOM dan diurutkan berdasarkan nilainya
indeks_som = np.concatenate(                                # perintah untuk menggabungkan 2 array (vektor) menjadi 1
    (som.distance_map().reshape(baris*kolom, 1),            # nilai dari variabel di dalam peta SOM
     np.arange(baris*kolom).reshape(baris*kolom, 1)),       # Membuat data dari 0 sampai ukuran baris*kolom (0,1,...,(baris*kolom-1))
    axis=1)                                                 # axis=1 adalah arah horizontal
indeks_som = indeks_som[indeks_som[:, 0].argsort()][::-1]   # mengurutkan dari kolom pertama (nilai peta SOM) dan mundur (reverse), jadi nilai terbesar menjadi paling atas

''' Penulisan ini
indeks_som = indeks_som[indeks_som[:, 0].argsort()][::-1]  

sama dengan

indeks_som = indeks_som[indeks_som[:, 0].argsort()]
indeks_som = indeks_som[::-1]
'''

# Menentukan berapa banyak cells sebagai outlier
use_threshold = True   # Kita set True untuk menggunakan threshold sebagai batas outliers
top_cells = 4          # 4 cell dengan ajrak terjauh sebagai batas outliers jika tidaka da yang melewati threshold
threshold = 0.9        # Gunakan nilai ini untuk menentukan batas threshold (jarak antar neuron)

# Mengambil indeks yang masuk kriteria threshold
idx = indeks_som[indeks_som[:, 0] > threshold, 1] if use_threshold else indeks_som[:top_cells, 1]

""" Penulisan ini
idx = helper[helper[:, 0] > threshold, 1] if use_threshold else helper[:top_cells, 1]

sama dengan 

if use_threshold:
    idx = helper[helper[:, 0] > threshold, 1]
else:
    idx = helper[:top_cells, 1]
"""

# Mencari data customer yang masuk ke index (idx)
result_map = []
mappings = som.win_map(X)
for i in range(baris):
    for j in range(kolom):
        if (i*kolom+j) in idx:                      # trik melakukan iterasi dari 0 - max(idx)
            if len(result_map) == 0:                # inisiasi pencarian customer   
                result_map = mappings[(i,j)]
            else:
                if len(mappings[(i,j)]) > 0:
                    result_map = np.concatenate((result_map, mappings[(i,j)]), axis=0)                
 
# Mendeteksi nasabah curang
frauds = sc.inverse_transform(result_map)

Penjelasan:

  • Line 2-4 mengimpor library yang diperlukan.
  • Line 7 mengimpor dataset. Jika kita lihat datasetnya, maka tampak sebagai berikut:
Tampilan dataset di spyder
  • Line 8 mendefinisikan X sebagai dataset yang kita analisis. Kita memerlukan semua kolom, kecuali kolom terakhir (Class).
  • Line 9 mendefinisikan y sebagai variabel dependen.

Perlu diingat, kita melakukan teknik unsupervised deep learning. Dengan demikian, kita hanya memerlukan X (variabel independen) dan tidak memerlukan y (variabel dependen). Kita tidak sedang mencari korelasi antara X dan y (seperti di supervised learning). Variabel y akan digunakan untuk menandai peta SOM.

  • Line 12 mengimpor library yang diperlukan untuk proses feature scaling. Kenapa kita memerlukan feature scaling? Karena jenis data dan skala di setiap kolom di dataset berbeda. Untuk penyeragaman, perlu kita lakukan feature scaling.
  • Line 13-14 adalah proses feature scaling. Untuk mereview materi ini, silakan baca artikel saya tentang feature scaling.
  • Line 17-18 menentukan ukuran dari peta SOM (baris x kolom). Kita gunakan formula 5*akar dari jumlah baris data = 5*sqrt(690) = 131. Dengan demikian, kita gunakan pendekatan 13 x 10 = 130. Mengapa menggunakan formula ini? Bisa dibaca kembali artikel saya sebelumnya yang membahas teori SOM.
  • Line 21 mengimpor library minisom. Perlu diingat bahwa file minisom.py harus diletakkan satu folder dengan dataset kita.

Tampilannya isi dari file minisom.py ini tampak sebagai berikut:

Tampilan dari file minisom.py

Kita juga bisa melihat class Minisom yang berada di dalam file minisom.py. Degan demikian, kita juga bisa melihat method apa yang bisa kita pakai di class Minisom. Tampilan beberapa methods di class Minisom tampak sebagai berikut:

Beebrapa methods yang bisa dipakai di class Minisom
  • Line 22 mendefinisikan variabel (object) dengan nama som. Variabel ini akan menjadi variabel bagi fungsi SOM kita. Untuk menggunakan fitur SOM kita gunakan class Minisom. Beberapa parameter yang diperlukan adalah x yang merupakan jumlah baris untuk peta SOM, y yang merupakan jumlah kolom untuk peta SOM, input_len yang merupakan jumlah kolom dari dataset X yang kita miliki, sigma yang merupakan parameter fungsi persebaran tetangga dari BMU (best matching unit), learning_rate yang merupakan parameter kecepatan pembelajaran neuron kita, dan yang terakhir random_seed agar mendapatkan hasil yang konsisten. Angka random_seed ini bebas, namun untuk pembahasan kali ini kita pilih angka 2.
  • Line 23 adalah menentukan nilai bobot SOM secara random. Untuk bisa melakukan ini kita gunakan method random_weights_init untuk variabel X.
  • Line 24 mulai melakukan training terhadap metode SOM kita. Untuk bisa melakukannya kita gunakan method train_random. Parameter yang diperlukan adalah dataset yang ingin ditrain yaitu X, dan jumlah iterasi. Untuk pembahasan kali ini kita pilih jumlah iterasi training 1000 kali.
  • Line 27-41 adalah perintah untuk visualisasi hasil peta SOM kita.
  • Line 27 adalah pemilihan warna untuk plot kita. Kita bisa memilih berbagai macam warna, tentunya selera orang berbeda-beda. Ada beberapa fungsi yang bisa dicoba, antara lain autumn, bone, cool, copper, gray, hot, hsv, inferno, jet, plasma, spring dll. Untuk pembahasan kali ini kita pilih jet.
  • Line 28 adalah memunculkan peta SOM, di mana setiap kotak (cell) adalah representasi normalisasi jarak antara neuron dengan tetangganya. Untuk bisa melakukannya kita gunakan method som.distance_map(). Jika kita hanya mengeksekusi som.distance_map() maka ia akan memberikan vektor jarak antar neuron di peta SOM. Jangan lupa untuk melakukan tranpose karena hasil dari method ini akan membalik kolom menjadi baris, dan baris menjadi kolom.

Jika dieksekusi line 28, hasilnya tampak sebagai berikut:

Hasil peta SOM

Bagaimana membaca peta di atas? tentu saja sulit, karena tidak ada petunjuk sama sekali. Kita hanya melihat perbedaan warna mulai dari biru, kuning, hingga merah. Untuk bisa mempermudah membaca peta di atas, kita tambahkan legenda.

  • Line 29 menambahkan legenda untuk tampilan peta SOM. Sekarang tampilannya menjadi seperti ini:
Hasil SOM dengan legenda

Legenda di peta SOM di atas menunjukkan kadar (intensitas) seberapa jauh jarak MID (mean interneuron distance). Jarak yang ditunjukkan di peta adalah jarak hasil normalisasi. Artinya jaraknya sudah diskalakan (rescaled) dengan rentang antara 0-1.

Semakin merah warnanya (merah kehitaman dengan nilai mendekati 1), maka jarak antara neuron tersebut dengan tetangganya semakin jauh. Jika dianalogikan seperti sebuah rumah yang hampir bahkan tidak memiliki tetangga. Rumah ini hanya berdiri sendiri. Kalaupun ada tetangga, paling dekat jaraknya mungkin 1 km.

Semakin biru warnanya (biru kehitaman dengan nilai mendekati 0), maka jarak antara neuron tersebut dengan tetangganya semakin dekat. Kita analogikan rumah dengan banyak tetangga. Semakin mendekati nol, maka rumah ini dengan tetangganya saling menempel satu sama lain.

Lalu bagaimana cara mendeteksi kecurangan? Kita bisa melihatnya melalui peta SOM di atas. Kecurangan diartikan bahwa data tersebut memiliki pola yang berbeda, bahkan jauh berbeda dibandingkan dengan data yang lain. Penelitian di beberapa jurnal ilmiah menggunakan outliers sebagai indikator untuk mendeteksi anomali (kecurangan). Dengan demikian, kita bisa menggunakan outliers (cells di peta SOM yang memiliki jarak terjauh dengan nilai mendekati 1) sebagai neurons yang terindikasi adanya anomali (kecurangan).

Untuk bisa lebih jelas lagi kita mendeteksi kecurangan, maka bisa kita berikan tanda tambahan (markers).

Kita akan menggunakan variabel y yang sudah kita definisikan di line 9. Variabel ini menunjukkan apakah aplikasi kartu kredit nasabah diterima (1) atau tidak (0). Kita akan gunakan nilai 0 untuk marker berwarna hitam, dan nilai 1 untuk amrker berwarna putih.

  • Line 30 menyiapkan 2 markers, yaitu tanda diamond (‘D’) dan tanda plus (‘P’). Untuk bisa melakukannya kita gunakan method markers.
  • Line 31 menyiapkan 2 warna untuk markers di line 30. Kita siapkan warna hitam (‘k’) dan putih (‘w’).
  • Line 32-40 merupakan proses iterasi semua cells yang ada di peta SOM. kita gunakan fungsi enumerate. Dengan enumerate, kita tidak hanya bisa melakukan iterasi tapi juga mendapatkan indeksnya. For i, x (x kecil bukan kapital) artinya melakukan iterasi mulai dari indeks (kita sebut dengan i) untuk baris ke i (kita sebut dengan x). Jadi i adalah nama index untuk urutan barisnya (nasabah x urutan ke-i).
  • Line 33 mendefinisikan variabel (object) koordinat sebagai winner (pemenang node). Dalam teori SOM disebut dengan istilah BMU (best matching unit). Variabel koordinat akan memberikan koordinat neuron di peta SOM untuk setiap nasabah ke x.
  • Line 34-40 adalah memberikan marker dan beberapa parameter seperti koordinat tengah (kita tambahkan + 0.5 agar tepat di tengah), ketebalan, dan lain-lain.
  • Line 41 adalah perintah untuk menunjukkan plotnya. Jika dieksekusi, maka tampilan plotnya adalah sebagai berikut:
Peta akhir SOM dengan beberapa markers

Melalui peta di atas, kita bisa melihat bahwa cell yang berwarna merah hitam adalah cell dengan potensi fraud yang sangat tinggi. Dengan adanya markers kita bisa tahu bahwa markers tanda plus berwarna positif menunjukkan nasabah yang diterima aplikasi kartu kreditnya. Sekarang ada kombinasi warna putih yang berada di cell merah hitam di koordinat (7,7) , di mana ini harus dilakukan kroscek lebih jauh lagi.

Peta di atas menunjukkan bahwa ada nasabah di sana (ditandai dengan adanya markers di cell ini. Kita juga patut mencurigai cells lain berwarna merah yang juga diapprove aplikasi kartu kreditnya oleh pihak bank.

Walau kita bisa mendeteksi adanya kecurangan secara visual, kita belum selesai. Kita baru bermain secara visual saja. Kita belum bisa mengetahui siapa nasabah yang benar-benar curang. Kita ingin tahu CustomerID dari nasabah yang curang ini. Untuk bisa melakukannya, maka kita lakukan analisis lebih lanjut.

  • Line 44-48 adalah beberapa tahapan untuk mencari indeks di peta SOM yang patut dicurigai. Kita definisikan variabel dengan nama indeks_som. Penjelasan dari setiap line ada di komentar (setelah tanda # untuk setiap line-nya).

Jika line 44-47 dieksekusi maka hasilnya sebagai berikut:

Nilai jarak untuk setiap indeks di peta SOM.

Tabel di atas menunjukkan nilai jarak untuk setiap cell nya, di mana kita urutkan sesuai indeksnya (mulai dari cell ke 0 sampai 129).

Jika di visualisasi SOM di tahapan sebelumnya jarak setiap neuronnya digambarkan melalui sebuah peta SOM, kali ini jaraknya dijabarkan dalam bentuk tabel.

  • Jika line 48 dieksekusi maka tampilannya sebagai berikut:
Nilai jarak untuk setiap indeks di peta SOM. diurutkan dari besar ke kecil.

Sekarang kita sudah mendapatkan nilai jarak dari besar ke kecil. Dengan demikian menjadi lebih mudah bagi kita untuk mendeteksi siapa nasabah yang curang.

  • Line 50-57 adalah penjelasan (berupa docstring – tanda ”’) tentang cara penulisan yang ebrbeda namun memberikan hasil yang sama (suplemen bagi pembaca yang belum begitu familiar dengan style penulisan di python.
  • Line 60-62 menentukan berapa banyak cells yang menjadi outliers. Penjelasannya ada di setiap lines.
  • Line 65 mengambil indeks yang masuk sebagai outliers. Bisa dikatakan kita mengambil data nasabah yang terduga menjadi outliers.
  • Line 67-76 adalah penjelasan mirip seperti line 50-57.
  • Line 79 mendefinisikan variabel results_map sebagai wadah dari semua nasabah yang curang. Kita definisikan sebagai sebuah list kosong.
  • Line 80 mendefinisikan variabel mapping sebagai wadah dari semua data nasabah yang masuk ke peta SOM (sebagai winning nodes).
  • Line 81-88 adalah proses iterasi untuk memasukkan nasabah outliers saja ke dalam results_map.

Jika kita buka variabel results_map, maka tampilan datanya sebagai berikut:

Hasil results_map

Bisa dilihat kita berhasil mendeteksi 8 nasabah (indeks 0-7). Ketika salah satu nasabah kita klik, maka muncul semua kolom nasabah yang ia miliki (dalam bentuk horisontal).

Sekarang kita bisa dengan mudah mengidentifikasi CustomerID dengan cara melakukan inverse (proses balik feature scaling).

  • Line 91 melakukan inverse transform untuk bisa membaca kembali tabel hasil deteksi sesuai skala awal. Kita definisikan variabel dengan nama frauds untuk bisa melihat siapa saja nasabah yang curang.

Jika dieksekusi maka hasilnya sebagai berikut:

List nasabah yang terindikasi curang

Sekarang kita sudah memiliki 8 nasabah yang terindikasi melakukan kecurangan saat membuat aplikasi kartu kredit. Dengan demikian, kita bisa melakukan investigasi lebih lanjut kepada 8 nasabah ini.

Tentu saja, masih banyak hal yang bisa kita lakukan dengan dataset ini. Jika pembaca ingin melakukan analisis lebih jauh lagi, bisa melakukannya dengan mencari hubungan antara nasabah yang curang dengan keputusan aplikasi kartu kreditnya apakah ditolak atau tidak. Variabel mana yang paling berperan dalam proses ini? Mana bobot yang paling besar? Dan masih banyak lagi.

Saya harap pembaca bisa mendapatkan gambaran aplikasi dari teknik SOM. Tentunya ini hanyalah sebagai latihan kecil, dan pembaca bisa menggunakan teknik SOM ini untuk mendeteksi anomali dengan dataset yang jauh lebih besar di luar sana.

Pembaca bisa belajar teknik AI lainnya dengan membaca artikel-artikel saya sebelumnya. Jika ada pertanyaan silakan tulis di bagian komentar.

Semoga bermanfaat dan tetap semangat belajar AI!

Terima kasih

Bagikan artikel ini:

Leave a Reply

avatar
  Subscribe  
Notify of