t-SNE T-distributed Stochastic Neighbor Embedding

Pada bab sebelumnya, kita telah bahas mengenai PCA untuk reduksi dimensi atas sebuah dataset gambar tulisan angka berukuran 28 x 28 menjadi hanya berukuran 3 x 1 atau terdiri dari 3 nilai saja kemudian divisualisasikan kedalam plot 3 dimensi. Nah pembahasan selanjutnya berupa t-SNE.

t-Distributed Stochastic Neighbourh Embedding(t-SNE)

1. Merupakan Algoritme acak yang tidak diawasi – unsupervised yang hanya digunakan untuk visualisasi data!
2. Menerapkan teknik reduksi dimensi non-linier dengan fokus pada menjaga titik data yang sangat mirip berdekatan di ruang berdimensi lebih rendah.
3. Mempertahankan struktur lokal data menggunakan distribusi-t student untuk menghitung kesamaan antara dua titik di ruang berdimensi lebih rendah.
4. t-SNE menggunakan distribusi Student-t heavy-tailed untuk menghitung kemiripan antara dua titik dalam ruang berdimensi rendah daripada distribusi Gaussian, yang membantu mengatasi masalah kerumunan dan pengoptimalan.
5. Pencilan/outlier tidak memengaruhi t-SNE

T-distributed Stochastic Neighbor Embedding (t-SNE) adalah algoritma pembelajaran mesin tanpa pengawasan untuk visualisasi yang dikembangkan oleh Laurens van der Maaten dan Geoffrey Hinton.

Cara kerja t-SNE yaitu

Langkah 1: Temukan persamaan berpasangan antara titik-titik terdekat dalam ruang dimensi tinggi. t-SNE mengubah jarak Euclidean berdimensi tinggi antara titik data xᵢ dan xⱼ menjadi probabilitas bersyarat P (j | i).

• xᵢ akan memilih xⱼ sebagai tetangganya berdasarkan proporsi kepadatan probabilitasnya di bawah Gaussian yang berpusat pada titik xᵢ.
• σᵢ adalah varians dari Gaussian yang berpusat pada titik data xᵢ
• Kepadatan probabilitas sepasang titik sebanding dengan kesamaannya. Untuk titik data terdekat, p (j | i) akan relatif tinggi, dan untuk titik yang terpisah jauh, p (j | i) akan sangat kecil.
• Simetri probabilitas kondisional dalam ruang berdimensi tinggi untuk mendapatkan persamaan akhir dalam ruang berdimensi tinggi.
• Probabilitas bersyarat disimetri dengan rata-rata dua probabilitas, seperti yang ditunjukkan di bawah ini

Langkah 2: Petakan setiap titik dalam ruang dimensi tinggi ke peta berdimensi rendah berdasarkan kemiripan berpasangan titik-titik di ruang dimensi tinggi.

Peta dimensi rendah akan menjadi peta 2 dimensi atau 3 dimensi

• yᵢ dan yⱼ adalah pasangan berdimensi rendah dari titik data berdimensi tinggi xᵢ dan xⱼ.
• Kita akan menghitung probabilitas bersyarat q (j | i) mirip dengan P (j] i) yang berpusat di bawah Gaussian yang berpusat pada titik yᵢ dan kemudian mensimetri probabilitas tersebut.

Langkah 3: Temukan representasi data dimensi rendah yang meminimalkan ketidaksesuaian antara Pᵢⱼ dan qᵢⱼ menggunakan penurunan gradien berdasarkan divergensi Kullback-Leibler (KL Divergence)

• Pᵢ mewakili distribusi probabilitas bersyarat di atas semua titik data lainnya untuk titik xᵢ.
• Qᵢ mewakili distribusi probabilitas bersyarat di atas semua titik peta lainnya berdasarkan titik peta yᵢ

t-SNE mengoptimalkan titik-titik dalam ruang dimensi yang lebih rendah menggunakan penurunan gradien/gradient descent

Mengapa menggunakan divergence KL?

Ketika kita meminimalkan divergensi KL, maka q secara fisik identik dengan Pᵢⱼ, sehingga struktur data dalam ruang dimensi tinggi akan serupa dengan struktur data di ruang dimensi rendah.

Berdasarkan persamaan divergensi KL

• Jika Pᵢⱼ besar, maka kita membutuhkan nilai yang besar untuk qᵢⱼ untuk merepresentasikan titik-titik lokal dengan kemiripan yang lebih tinggi.
• Jika Pᵢⱼ kecil, maka kita membutuhkan nilai yang lebih kecil untuk qᵢⱼ untuk merepresentasikan titik-titik lokal yang berjauhan

Langkah 4: Gunakan distribusi Student-t untuk menghitung kesamaan antara dua titik di ruang berdimensi rendah

t-SNE menggunakan distribusi Student-t heavy-tailed dengan satu derajat kebebasan untuk menghitung kesamaan antara dua titik dalam ruang berdimensi rendah daripada distribusi Gaussian.

Distribusi-T menciptakan distribusi probabilitas titik dalam ruang dimensi yang lebih rendah, dan ini membantu mengurangi masalah kerumunan data.

Implementasi t-SNE menggunakan sklearn

Mari kita pahami beberapa parameter penting untuk TSNE yang dapat kita gunakan

• n_components: Dimensi ruang yang akan kita gunakan, ini adalah dimensi yang lebih rendah yang kita inginkan untuk mengonversi data berdimensi tinggi. Nilai defaultnya adalah 2 untuk ruang 2 dimensi.
• Perplexity: perplexity terkait dengan jumlah tetangga terdekat yang digunakan dalam algoritma t-SNE. Kumpulan data yang lebih besar biasanya membutuhkan kebingungan yang lebih besar. perplexity dapat memiliki nilai antara 5 dan 50. Nilai defaultnya adalah 30.
• n_iter: Jumlah iterasi maksimum untuk pengoptimalan. Harus minimal 250 dan nilai defaultnya adalah 1000

Kalian butuh sklearn, matplotlib serta numpy dan pandas,  adapun dataset yang digunakan sama seperti di PCA yaitu untuk visualisasikan citra tulisan tangan berukuran 28 x 28. Kalian pelajari saja bab PCA tersebut.

Kalian download dulu saja dataset MNIST nya

import time
import numpy as np
import pandas as pd
(X_train, y_train) , (X_test, y_test) = mnist.load_data()

Oiya, saya pakai X_train dan y_train agar terlihat jelas nantinya, langkah selanjutnya import sklearn dan melakukan flattening X. Saya gunakan n_components=3 agar mudah divisualisasikan 3 dimensi terlihat keren saja sih!

from sklearn.manifold import TSNE

img_cols = 28 #ukuran gambar
img_rows = 28

X_train_reshape = X_train.reshape(X_train.shape[0], img_rows*img_cols)

model = TSNE(n_components=3, perplexity = 50,random_state=0)
tsne_data = model.fit_transform(X_train_reshape)

Proses diatas sangat lama lho! jadi tungguin saja, kemudian langkah selanjutnya yaitu melakukan visualisasi data kedalam 3 dimensi. Yuk pakai matplotlib

from matplotlib import pyplot as plt
import pandas as pd

nama_sumbu = ['x', 'y','z']

pca_df = pd.DataFrame(data = tsne_data, 
                      columns = nama_sumbu)
pca_df['label'] = y_train

targets = [0,1,2,3,4,5,6,7,8,9,10]
colors=['yellow', 'black', 'cyan', 'green', 'blue', 'red', 'brown','crimson', 'gold', 'indigo']

x = nama_sumbu[0]
y = nama_sumbu[1]
z = nama_sumbu[2]

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')


for target, color in zip(targets,colors):
    index = pca_df['label'] == target
    ax.scatter(pca_df.loc[index, x], 
               pca_df.loc[index, y],
               pca_df.loc[index, z],
               c = color,
               s = 10)

ax.legend(targets)
ax.grid()
ax.set_xlabel(x)
ax.set_ylabel(y)
ax.set_zlabel(z)
ax.set_title('High dimension data with TSNE, perplexity 50')

Berikut tampilan hasil t-SNE dengan perplexity =30

semakin besar nilai perplexity maka akan semakin jelas jarak yang terpisah, namun prosesnya menjadi lama!

Berikut tampilan hasil t-SNE dengan perplexity = 50

Bagaimana menurut kalian mengenai visualisasi non linear data menggunakan t-SNE?