|
import numpy as np |
|
import plotly.graph_objects as go |
|
import matplotlib.pyplot as plt |
|
|
|
from sklearn.datasets import load_digits |
|
from sklearn.preprocessing import MinMaxScaler |
|
|
|
from sklearn.decomposition import TruncatedSVD |
|
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis |
|
from sklearn.ensemble import RandomTreesEmbedding |
|
from sklearn.manifold import ( |
|
Isomap, |
|
LocallyLinearEmbedding, |
|
MDS, |
|
SpectralEmbedding, |
|
TSNE |
|
) |
|
from sklearn.neighbors import NeighborhoodComponentsAnalysis |
|
from sklearn.pipeline import make_pipeline |
|
|
|
import gradio as gr |
|
|
|
|
|
|
|
digits = load_digits(n_class=10) |
|
X, y = digits.data, digits.target |
|
|
|
algorithms = ['Linear Discriminant Analysis', |
|
't-SNE', |
|
'Truncated SVD', |
|
'Isomap', |
|
'Locally Linear Embedding', |
|
'Random Trees Embedding', |
|
'Spectral Embedding', |
|
'Neighborhood Component Analysis'] |
|
|
|
|
|
class UserInterface: |
|
def __init__(self): |
|
self.components = {} |
|
self.bindings = {} |
|
|
|
def add_component(self, name, component, kwargs={}): |
|
self.components[name] = component(**{'visible': False, **kwargs}) |
|
|
|
def all_components(self): |
|
return list(self.components.values()) |
|
|
|
def get(self, name): |
|
return self.components[name] |
|
|
|
def get_kwargs(self, args): |
|
return {k:v for k,v in zip(list(self.components.keys()), args)} |
|
|
|
def get_arg(self, name, args): |
|
idx = list(self.components.keys()).index(name) |
|
return args[idx] |
|
|
|
def add_updater(self, dest, srcs, conds): |
|
def fn(*args): |
|
truth_value = True |
|
for (src, cond) in zip(args, conds): |
|
truth_value = truth_value and (src == cond) |
|
|
|
return gr.update(visible=truth_value) |
|
|
|
for src in srcs: |
|
self.components[src].change(fn, inputs=[self.components[i] for i in srcs], outputs=self.components[dest]) |
|
|
|
def bind(self, dest, src, cond): |
|
all_srcs, all_conds = [src], [cond] |
|
|
|
if src in self.bindings: |
|
for sub_src, sub_cond in self.bindings[src]: |
|
all_srcs.append(sub_src) |
|
all_conds.append(sub_cond) |
|
|
|
self.add_updater(dest, all_srcs, all_conds) |
|
|
|
if dest not in self.bindings: self.bindings[dest] = [] |
|
for s, c in zip(all_srcs, all_conds): |
|
self.bindings[dest].append((s, c)) |
|
|
|
|
|
info = ''' |
|
# Giảm kích thước MNIST với học tập đa dạng |
|
|
|
Đây là minh chứng về cách có thể sử dụng một số kỹ thuật [học đa dạng](https://scikit-learn.org/stable/modules/manifold.html) để giảm số chiều của tập dữ liệu MNIST từ 784 chiều xuống chỉ còn 2 hoặc 3 chiều cho mục đích trực quan. |
|
|
|
Các kỹ thuật học đa dạng tìm cách tìm ra **biểu diễn chiều thấp** của dữ liệu đã cho sao cho các đặc tính nhất định được bảo toàn, chẳng hạn như cấu trúc cục bộ hoặc toàn cầu, khoảng cách lân cận, v.v. |
|
|
|
Tất cả các phương pháp được sử dụng ở đây đều **hoàn toàn không được giám sát**, ngoại trừ Phân tích phân biệt tuyến tính và Phân tích thành phần lân cận, |
|
|
|
sử dụng nhãn chữ số được cung cấp. Mỗi phương pháp đều có ưu điểm và nhược điểm. Sử dụng hộp thả xuống bên dưới để chọn một phương pháp, điều chỉnh các siêu tham số của chúng và xem chúng khác nhau như thế nào. |
|
''' |
|
|
|
with gr.Blocks(analytics_enabled=False,theme=gr.themes.Soft()) as demo: |
|
gr.Markdown(info) |
|
|
|
with gr.Row(): |
|
with gr.Column(): |
|
ui = UserInterface() |
|
ui.add_component('algorithm', gr.Dropdown, {'choices': algorithms, 'value': algorithms[0], 'label': 'Model', 'interactive': True, 'visible': True}) |
|
ui.add_component('n_components', gr.Radio, {'choices': ['2D', '3D'], 'value': '3D', 'label': 'Embedding dimensionality', 'visible': True}) |
|
|
|
ui.add_component('n_neighbors', gr.Slider, {'minimum': 6, 'maximum': 100, 'value': 30, 'step': 1, 'label': 'Number of neighbors'}) |
|
|
|
ui.add_component('tsne_perplexity', gr.Slider, {'minimum': 5, 'maximum': 50, 'value': 30, 'step': 1, 'label': 'Perplexity'}) |
|
ui.add_component('tsne_early_exaggeration', gr.Slider, {'minimum': 2, 'maximum': 100, 'value': 12, 'step': 1, 'label': 'Early Exaggeration'}) |
|
ui.add_component('tsne_n_iter', gr.Slider, {'minimum': 250, 'maximum': 2000, 'value': 1000, 'step': 1, 'label': 'Number of iterations'}) |
|
ui.add_component('tsne_learning_rate_dd', gr.Dropdown, {'choices': ['auto', 'float'], 'value': 'auto', 'label': 'Learning Rate', 'interactive': True}) |
|
ui.add_component('tsne_learning_rate_s', gr.Slider, {'minimum': 10, 'maximum': 2000, 'value': 100, 'step': 1, 'label': 'Learning Rate Value'}) |
|
|
|
ui.add_component('isomap_p', gr.Slider, {'minimum': 1, 'maximum': 10, 'value': 2, 'step': 1, 'label': 'Minkowski distance Lp'}) |
|
|
|
ui.add_component('lle_method', gr.Dropdown, {'choices': ['standard', 'hessian', 'modified', 'ltsa'], 'value': 'standard', 'label': 'Method', 'interactive': True}) |
|
|
|
ui.add_component('rte_n_estimators', gr.Slider, {'minimum': 1, 'maximum': 200, 'value': 100, 'step': 1, 'label': 'Number of estimators'}) |
|
ui.add_component('rte_max_depth', gr.Slider, {'minimum': 2, 'maximum': 50, 'value': 5, 'step': 1, 'label': 'Max depth'}) |
|
|
|
ui.add_component('se_affinity', gr.Dropdown, {'choices': ['rbf', 'nearest_neighbors'], 'value': 'nearest_neighbors', 'label': 'Affinity matrix calculation method', 'interactive': True}) |
|
ui.add_component('se_gamma', gr.Slider, {'minimum': 0.01, 'maximum': 10, 'value': 0.1, 'step': 0.05, 'label': 'Gamma'}) |
|
ui.add_component('se_n_neighbors', gr.Slider, {'minimum': 6, 'maximum': 1000, 'value': 30, 'step': 1, 'label': 'Number of neighbors'}) |
|
|
|
ui.add_component('nca_init', gr.Dropdown, {'choices': ['auto', 'pca', 'lda', 'identity', 'random'], 'value': 'auto', 'label': 'Initialization of the linear transformation', 'interactive': True}) |
|
ui.add_component('nca_max_iter', gr.Slider, {'minimum': 5, 'maximum': 100, 'value': 50, 'step': 1, 'label': 'Maximum number of iterations'}) |
|
|
|
|
|
|
|
|
|
ui.bind('tsne_early_exaggeration', 'algorithm', 't-SNE') |
|
ui.bind('tsne_perplexity', 'algorithm', 't-SNE') |
|
ui.bind('tsne_learning_rate_dd', 'algorithm', 't-SNE') |
|
ui.bind('tsne_learning_rate_s', 'tsne_learning_rate_dd', 'float') |
|
ui.bind('tsne_n_iter', 'algorithm', 't-SNE') |
|
|
|
ui.bind('n_neighbors', 'algorithm', 'Isomap') |
|
ui.bind('isomap_p', 'algorithm', 'Isomap') |
|
|
|
ui.bind('n_neighbors', 'algorithm', 'Locally Linear Embedding') |
|
ui.bind('lle_method', 'algorithm', 'Locally Linear Embedding') |
|
|
|
ui.bind('rte_n_estimators', 'algorithm', 'Random Trees Embedding') |
|
ui.bind('rte_max_depth', 'algorithm', 'Random Trees Embedding') |
|
|
|
ui.bind('se_affinity', 'algorithm', 'Spectral Embedding') |
|
ui.bind('se_n_neighbors', 'se_affinity', 'nearest_neighbors') |
|
ui.bind('se_gamma', 'se_affinity', 'rbf') |
|
|
|
ui.bind('nca_init', 'algorithm', 'Neighborhood Component Analysis') |
|
ui.bind('nca_max_iter', 'algorithm', 'Neighborhood Component Analysis') |
|
|
|
btn = gr.Button('Submit') |
|
|
|
with gr.Column(): |
|
plot = gr.Plot(label='') |
|
|
|
def create_plot(*args): |
|
kwargs = ui.get_kwargs(args) |
|
|
|
algorithm = kwargs['algorithm'] |
|
n_components = int(kwargs['n_components'][0]) |
|
|
|
model = None |
|
data = X |
|
|
|
if algorithm == 'Linear Discriminant Analysis': |
|
data = X.copy() |
|
data.flat[:: X.shape[1] + 1] += 0.01 |
|
model = LinearDiscriminantAnalysis() |
|
|
|
elif algorithm == 't-SNE': |
|
model = TSNE(n_jobs=-1) |
|
model.perplexity = kwargs['tsne_perplexity'] |
|
model.early_exaggeration = kwargs['tsne_early_exaggeration'] |
|
model.n_iter = kwargs['tsne_n_iter'] |
|
model.learning_rate = 'auto' if (kwargs['tsne_learning_rate_dd'] == 'auto') else kwargs['tsne_learning_rate_s'] |
|
|
|
elif algorithm == 'Truncated SVD': |
|
model = TruncatedSVD() |
|
|
|
elif algorithm == 'Isomap': |
|
model = Isomap(n_jobs=-1) |
|
model.n_neighbors = kwargs['n_neighbors'] |
|
model.p = kwargs['isomap_p'] |
|
|
|
elif algorithm == 'Locally Linear Embedding': |
|
model = LocallyLinearEmbedding(n_jobs=-1) |
|
model.n_neighbors = kwargs['n_neighbors'] |
|
model.method = kwargs['lle_method'] |
|
|
|
elif algorithm == 'Random Trees Embedding': |
|
model = make_pipeline(RandomTreesEmbedding(n_estimators=kwargs['rte_n_estimators'], max_depth=kwargs['rte_max_depth']), TruncatedSVD(n_components=n_components)) |
|
|
|
elif algorithm == 'Spectral Embedding': |
|
model = SpectralEmbedding(n_jobs=-1) |
|
model.affinity = kwargs['se_affinity'] |
|
model.gamma = kwargs['se_gamma'] |
|
model.n_neighbors = kwargs['se_n_neighbors'] |
|
|
|
elif algorithm == 'Neighborhood Component Analysis': |
|
model = NeighborhoodComponentsAnalysis() |
|
model.init = kwargs['nca_init'] |
|
model.max_iter = kwargs['nca_max_iter'] |
|
|
|
|
|
if algorithm != 'Random Trees Embedding': |
|
model.n_components = n_components |
|
|
|
projections = model.fit_transform(data, y) |
|
projections = MinMaxScaler().fit_transform(projections) |
|
|
|
fig = go.Figure() |
|
|
|
for digit in digits.target_names: |
|
subset = projections[y==digit] |
|
rgba = plt.cm.tab10(digit/10) |
|
color = f'rgba({rgba[0]}, {rgba[1]}, {rgba[2]}, 0.8)' |
|
if n_components == 2: |
|
fig.add_trace(go.Scatter(x=subset[:,0], y=subset[:,1], mode='text', text=str(digit), textfont={'size': 16, 'color': color})) |
|
elif n_components == 3: |
|
fig.add_trace(go.Scatter3d(x=subset[:,0], y=subset[:,1], z=subset[:,2], mode='text', text=str(digit), textfont={'size': 16, 'color': color})) |
|
|
|
fig.update_traces(showlegend=False) |
|
|
|
return fig |
|
|
|
btn.click(create_plot, ui.all_components(), plot) |
|
demo.load(create_plot, ui.all_components(), plot) |
|
|
|
demo.launch() |
|
|
