Penjelasan terperinci tentang prinsip algoritma t-SNE dan pelaksanaan kod Python

Pembenaman jiran stokastik teragih-T (t-SNE) ialah algoritma pembelajaran mesin tanpa pengawasan untuk visualisasi yang menggunakan teknologi pengurangan dimensi bukan linear untuk cuba meminimumkan jumlah dimensi tinggi berdasarkan persamaan titik dan ciri data antara kebarangkalian bersyarat ini (atau persamaan) dalam ruang dimensi rendah untuk mewakili titik data dalam ruang dimensi rendah dengan sempurna.

Oleh itu, t-SNE pandai membenamkan data berdimensi tinggi dalam ruang berdimensi rendah dua atau tiga dimensi untuk visualisasi. Perlu diingatkan bahawa t-SNE menggunakan taburan berekor berat untuk mengira persamaan antara dua titik dalam ruang dimensi rendah dan bukannya taburan Gaussian, yang membantu menyelesaikan masalah kesesakan dan pengoptimuman. Dan outlier tidak menjejaskan t-SNE.

t-SNE langkah algoritma

1. Cari persamaan berpasangan antara titik bersebelahan dalam ruang dimensi tinggi.

2. Berdasarkan persamaan pasangan mata dalam ruang dimensi tinggi, petakan setiap titik dalam ruang dimensi tinggi kepada peta dimensi rendah.

3. Gunakan keturunan kecerunan berdasarkan perbezaan Kullback-Leibler (pebezaan KL) untuk mencari perwakilan data berdimensi rendah yang meminimumkan ketidakpadanan antara taburan kebarangkalian bersyarat.

4. Gunakan taburan Student-t untuk mengira persamaan antara dua titik dalam ruang dimensi rendah.

Kod Python untuk melaksanakan t-SNE pada set data MNIST

Modul import

# Importing Necessary Modules.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
from sklearn.preprocessing import StandardScaler

Baca data

# Reading the data using pandas
df = pd.read_csv('mnist_train.csv')

# print first five rows of df
print(df.head(4))

# save the labels into a variable l.
l = df['label']

# Drop the label feature and store the pixel data in d.
d = df.drop("label", axis = 1)

Pemprosesan data

# Data-preprocessing: Standardizing the data
from sklearn.preprocessing import StandardScaler

standardized_data = StandardScaler().fit_transform(data)
print(standardized_data.shape)

Output

# TSNE
# Picking the top 1000 points as TSNE
# takes a lot of time for 15K points
data_1000 = standardized_data[0:1000, :]
labels_1000 = labels[0:1000]

model = TSNE(n_components = 2, random_state = 0)
# configuring the parameters
# the number of components = 2
# default perplexity = 30
# default learning rate = 200
# default Maximum number of iterations
# for the optimization = 1000

tsne_data = model.fit_transform(data_1000)

# creating a new data frame which
# help us in plotting the result data
tsne_data = np.vstack((tsne_data.T, labels_1000)).T
tsne_df = pd.DataFrame(data = tsne_data,
columns =("Dim_1", "Dim_2", "label"))

# Plotting the result of tsne
sn.FacetGrid(tsne_df, hue ="label", size = 6).map(
plt.scatter, 'Dim_1', 'Dim_2').add_legend()

plt.show()

Atas ialah kandungan terperinci Penjelasan terperinci tentang prinsip algoritma t-SNE dan pelaksanaan kod Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!