Автор|Марцелл Рубен Компилировать|ВКонтакте Источник | К науке о данных
Когда вы слышите слова «чай» и «кофе», что вы думаете об этих двух словах? Может быть, вы бы сказали, что это все напитки с определенным содержанием кофеина. Дело в том, что мы можем легко понять, что эти два слова связаны. Однако, когда мы скормили компьютеру слова «чай» и «кофе», он не смог распознать связь между этими двумя словами так же хорошо, как мы.
Слова — это не то, что компьютеры понимают естественным образом. Чтобы компьютер понял значение слова, слово должно быть закодировано в числовой форме. Здесь на помощь приходят вложения слов.
Встраивание слов — это метод, обычно используемый при обработке естественного языка для преобразования слов в числовые значения в виде векторов. Эти векторы будут занимать пространство вложения с определенным количеством измерений.
Если два слова имеют схожий контекст, скажем, «чай» и «кофе», то эти два слова будут близки друг к другу в пространстве вложения и более удалены от других слов с разными контекстами «Далеко».
В этом посте я покажу вам шаг за шагом, как визуализировать встраивание слов. Поскольку цель этой статьи не в том, чтобы подробно объяснить основную теорию встраивания слов, вы можете больше узнать об этой теории в этой статье и в этой статье.
Чтобы визуализировать встраивание слов, мы будем использовать распространенные методы уменьшения размерности, такие как PCA и t-SNE. Чтобы сопоставить слова с векторными представлениями в пространстве вложений, мы используем предварительно обученные вложения слов GloVe.
Загрузите предварительно обученную модель встраивания слов
Перед визуализацией встраивания слов обычно нам нужно сначала обучить модель. Однако обучение встраиванию слов требует значительных вычислительных ресурсов. Поэтому обычно используются предварительно обученные модели встраивания слов. Он содержит слова в пространстве вложения и связанные с ними векторные представления.
GloVe — это популярная предварительно обученная модель встраивания слов, разработанная исследователями из Стэнфорда помимо word2vec, разработанного Google. В этой статье реализованы предварительно обученные встраивания слов GloVe, которые вы можете скачать здесь.
НЛП.Стэнфорд.Количество/проектов/км…
В то же время мы можем использовать библиотеку Gensim для загрузки предварительно обученной модели встраивания слов. Библиотеку можно установить с помощью команды pip, как показано ниже.
pip install gensim
В качестве первого шага нам нужно преобразовать формат файла GloVe в формат файла word2vec. С форматом файла word2vec мы можем использовать библиотеку Gensim для загрузки предварительно обученной модели встраивания слов в память. Поскольку для загрузки этого файла каждый раз при вызове этой команды требуется некоторое время, было бы лучше, если бы у вас был отдельный файл Python только для этой цели.
import pickle
from gensim.test.utils import datapath, get_tmpfile
from gensim.models import KeyedVectors
from gensim.scripts.glove2word2vec import glove2word2vec
glove_file = datapath('C:/Users/Desktop/glove.6B.100d.txt')
word2vec_glove_file = get_tmpfile("glove.6B.100d.word2vec.txt")
glove2word2vec(glove_file, word2vec_glove_file)
model = KeyedVectors.load_word2vec_format(word2vec_glove_file)
filename = 'glove2word2vec_model.sav'
pickle.dump(model, open(filename, 'wb'))
Создайте входные слова и сгенерируйте похожие слова
Теперь, когда у нас есть файл Python для загрузки предварительно обученной модели, мы можем вызвать его в другом файле Python, чтобы сгенерировать наиболее похожие слова на основе входных слов. Входное слово может быть любым.
После ввода слова следующим шагом будет создание кода для его чтения. Затем нам нужно указать количество похожих слов для каждого входного слова, сгенерированного моделью. Наконец, мы сохраняем результаты для похожих слов в списке. Ниже приведен код для достижения этого.
import pickle
filename = 'glove2word2vec_model.sav'
model = pickle.load(open(filename, 'rb'))
def append_list(sim_words, words):
list_of_words = []
for i in range(len(sim_words)):
sim_words_list = list(sim_words[i])
sim_words_list.append(words)
sim_words_tuple = tuple(sim_words_list)
list_of_words.append(sim_words_tuple)
return list_of_words
input_word = 'school'
user_input = [x.strip() for x in input_word.split(',')]
result_word = []
for words in user_input:
sim_words = model.most_similar(words, topn = 5)
sim_words = append_list(sim_words, words)
result_word.extend(sim_words)
similar_word = [word[0] for word in result_word]
similarity = [word[1] for word in result_word]
similar_word.extend(user_input)
labels = [word[2] for word in result_word]
label_dict = dict([(y,x+1) for x,y in enumerate(set(labels))])
color_map = [label_dict[x] for x in labels]
В качестве примера предположим, что мы хотим найти разницу между "school«5 наиболее похожих слов, связанных. Следовательно,»school" будет нашим входным словом. Наш результат *'college', 'школы', «элементарно», 'ученики', и'ученик'*.
Встраивание Visual Word на основе PCA
Теперь у нас есть входное слово и сгенерированные на его основе похожие слова. Теперь пришло время визуализировать их в пространстве встраивания.
В предварительно обученной модели каждое слово может быть отображено в пространстве вложения с векторным представлением. Однако вложения слов имеют высокую размерность, что означает, что слова не могут быть визуализированы.
Такие методы, как анализ основных компонентов (PCA), обычно используются для уменьшения размерности встраивания слов. В двух словах, PCA — это метод извлечения признаков, который объединяет переменные, а затем удаляет наименее важные переменные, сохраняя ценные части переменных. Если вы хотите углубиться в PCA, я рекомендую эту статью.
к data science.com/ah-one-stop-…
С помощью PCA мы можем визуализировать встраивание слов в 2D или 3D, поэтому давайте создадим код для визуализации встраивания слов, используя модель, которую мы вызвали в блоке кода выше. В приведенном ниже коде показана только 3D-визуализация. Для визуализации PCA в 2D применяются лишь незначительные изменения. Вы можете найти части, которые необходимо изменить, в разделе комментариев кода.
import plotly
import numpy as np
import plotly.graph_objs as go
from sklearn.decomposition import PCA
def display_pca_scatterplot_3D(model, user_input=None, words=None, label=None, color_map=None, topn=5, sample=10):
if words == None:
if sample > 0:
words = np.random.choice(list(model.vocab.keys()), sample)
else:
words = [ word for word in model.vocab ]
word_vectors = np.array([model[w] for w in words])
three_dim = PCA(random_state=0).fit_transform(word_vectors)[:,:3]
# 对于2D，将three_dim变量改为two_dim，如下所示:
# two_dim = PCA(random_state=0).fit_transform(word_vectors)[:,:2]
data = []
count = 0
for i in range (len(user_input)):
trace = go.Scatter3d(
x = three_dim[count:count+topn,0],
y = three_dim[count:count+topn,1],
z = three_dim[count:count+topn,2],
text = words[count:count+topn],
name = user_input[i],
textposition = "top center",
textfont_size = 20,
mode = 'markers+text',
marker = {
'size': 10,
'opacity': 0.8,
'color': 2
}
)
#对于2D，不是使用go.Scatter3d，我们需要用go.Scatter并删除变量z。另外，不要使用变量three_dim，而是使用前面声明的变量(例如two_dim)
data.append(trace)
count = count+topn
trace_input = go.Scatter3d(
x = three_dim[count:,0],
y = three_dim[count:,1],
z = three_dim[count:,2],
text = words[count:],
name = 'input words',
textposition = "top center",
textfont_size = 20,
mode = 'markers+text',
marker = {
'size': 10,
'opacity': 1,
'color': 'black'
}
)
# 对于2D，不是使用go.Scatter3d，我们需要用go.Scatter并删除变量z。另外，不要使用变量three_dim，而是使用前面声明的变量(例如two_dim)
data.append(trace_input)
# 配置布局
layout = go.Layout(
margin = {'l': 0, 'r': 0, 'b': 0, 't': 0},
showlegend=True,
legend=dict(
x=1,
y=0.5,
font=dict(
family="Courier New",
size=25,
color="black"
)),
font = dict(
family = " Courier New ",
size = 15),
autosize = False,
width = 1000,
height = 1000
)
plot_figure = go.Figure(data = data, layout = layout)
plot_figure.show()
display_pca_scatterplot_3D(model, user_input, similar_word, labels, color_map)
В качестве примера предположим, что мы хотим связать 5 наиболее похожих слов со словами «мяч», «школа» и «еда». Ниже приведен пример 2D-визуализации.
Ниже приведена 3D-визуализация того же набора слов.
Визуально мы теперь можем видеть закономерности в пространстве, занимаемом этими словами. Слова, связанные со словом «мяч», близки друг к другу, потому что имеют схожий контекст. В то же время расстояния между их словами, относящимися к «школе» и «еде», еще больше варьировались в зависимости от их контекста.
Встраивание визуального слова на основе t-SNE
Помимо PCA, другим широко используемым методом уменьшения размерности является t-распределенное стохастическое встраивание окрестности (t-SNE). Разница между PCA и t-SNE заключается в их основном методе уменьшения размерности.
PCA — это метод уменьшения линейной размерности. Линейно сопоставляет данные в многомерном пространстве с низкоразмерным пространством, максимизируя дисперсию данных. Между тем, t-SNE — это метод нелинейного уменьшения размерности. Алгоритм использует t-SNE для вычисления сходства в высоко- и низкоразмерных пространствах. Во-вторых, используйте метод оптимизации, такой как градиентный спуск, чтобы свести к минимуму разницу сходства в двух пространствах.
Код визуализации для встраивания слов с помощью t-SNE очень похож на код PCA. В приведенном ниже коде показана только 3D-визуализация. Чтобы визуализировать t-SNE в 2D, необходимо внести лишь незначительные изменения. Вы можете найти части, которые необходимо изменить, в разделе комментариев кода.
import plotly
import numpy as np
import plotly.graph_objs as go
from sklearn.manifold import TSNE
def display_tsne_scatterplot_3D(model, user_input=None, words=None, label=None, color_map=None, perplexity = 0, learning_rate = 0, iteration = 0, topn=5, sample=10):
if words == None:
if sample > 0:
words = np.random.choice(list(model.vocab.keys()), sample)
else:
words = [ word for word in model.vocab ]
word_vectors = np.array([model[w] for w in words])
three_dim = TSNE(n_components = 3, random_state=0, perplexity = perplexity, learning_rate = learning_rate, n_iter = iteration).fit_transform(word_vectors)[:,:3]
# 对于2D，将three_dim变量改为two_dim，如下所示:
# two_dim = TSNE(n_components = 2, random_state=0, perplexity = perplexity, learning_rate = learning_rate, n_iter = iteration).fit_transform(word_vectors)[:,:2]
data = []
count = 0
for i in range (len(user_input)):
trace = go.Scatter3d(
x = three_dim[count:count+topn,0],
y = three_dim[count:count+topn,1],
z = three_dim[count:count+topn,2],
text = words[count:count+topn],
name = user_input[i],
textposition = "top center",
textfont_size = 20,
mode = 'markers+text',
marker = {
'size': 10,
'opacity': 0.8,
'color': 2
}
)
# 对于2D，不是使用go.Scatter3d，我们需要用go.Scatter并删除变量z。另外，不要使用变量three_dim，而是使用前面声明的变量(例如two_dim)
data.append(trace)
count = count+topn
trace_input = go.Scatter3d(
x = three_dim[count:,0],
y = three_dim[count:,1],
z = three_dim[count:,2],
text = words[count:],
name = 'input words',
textposition = "top center",
textfont_size = 20,
mode = 'markers+text',
marker = {
'size': 10,
'opacity': 1,
'color': 'black'
}
)
# 对于2D，不是使用go.Scatter3d，我们需要用go.Scatter并删除变量z。另外，不要使用变量three_dim，而是使用前面声明的变量(例如two_dim)
data.append(trace_input)
# 配置布局
layout = go.Layout(
margin = {'l': 0, 'r': 0, 'b': 0, 't': 0},
showlegend=True,
legend=dict(
x=1,
y=0.5,
font=dict(
family="Courier New",
size=25,
color="black"
)),
font = dict(
family = " Courier New ",
size = 15),
autosize = False,
width = 1000,
height = 1000
)
plot_figure = go.Figure(data = data, layout = layout)
plot_figure.show()
display_tsne_scatterplot_3D(model, user_input, similar_word, labels, color_map, 5, 500, 10000)
Ниже показан тот же пример, что и в визуализации PCA, визуализация 5 наиболее похожих слов, связанных со словами «мяч», «школа» и «еда».
Ниже приведена 3D-визуализация того же набора слов.
То же, что и PCA, обратите внимание, что слова с похожим контекстом расположены близко друг к другу, а слова с разным контекстом - дальше друг от друга.
Создайте веб-приложение для визуализации встраивания слов
На данный момент мы успешно создали скрипт Python для встраивания слов в 2D или 3D с помощью PCA или t-SNE. Затем мы можем создать скрипт Python для создания веб-приложения для лучшего взаимодействия с пользователем.
Это веб-приложение позволяет нам визуализировать встраивание слов с большим количеством функциональных возможностей и интерактивности. Например, пользователь может ввести свои собственные входные слова или выбрать первые n наиболее похожих слов, связанных с каждым входным словом, которое будет возвращено.
Веб-приложения можно создавать с помощью Dash или Streamlit. В этой статье я покажу вам, как создать простое интерактивное веб-приложение для визуализации вложений слов Streamlit.
Во-первых, мы возьмем весь созданный ранее код Python и поместим его в скрипт Python. Далее мы можем начать создавать несколько пользовательских входных параметров следующим образом:
-
Технология уменьшения размерности, пользователи могут выбрать использование PCA или t-SNE. Поскольку есть только два варианта, мы можем использовать свойство selectbox в Streamlit.
-
Измерение визуализации, в котором пользователь может выбрать встраивание слов в двухмерное или трехмерное отображение. Как и раньше, мы можем использовать свойство selectbox.
-
Введите слова. Это параметр пользовательского ввода, который просит пользователя ввести желаемое слово ввода, например «мяч», «школа» и «еда». Поэтому мы можем использовать атрибут text_input.
-
Top-n наиболее похожих слов, где пользователю необходимо указать количество похожих слов, которые будут возвращены для каждого входного слова. Потому что мы можем выбрать любое число.
Далее нам нужно рассмотреть параметры, которые появятся, когда мы решим использовать t-SNE. В t-SNE мы можем настроить некоторые параметры, чтобы получить наилучшие результаты визуализации. Этими параметрами являются сложность, скорость обучения и количество итераций оптимизации. Поэтому в каждом случае, позволяющего пользователю указывать оптимальные значения этих параметров, не существует.
Поскольку мы используем обучение Scikit, мы можем обратиться к документации, чтобы узнать значения по умолчанию для этих параметров. Значение недоумения по умолчанию — 30, но мы можем настроить это значение в диапазоне от 5 до 50. Значение скорости обучения по умолчанию — 300, но мы можем настроить это значение в диапазоне от 10 до 1000. Наконец, значение по умолчанию для количества итераций равно 1000, но мы можем изменить это значение до 250. Мы можем использовать свойство слайдера для создания этих значений параметров.
import streamlit as st
dim_red = st.sidebar.selectbox(
'Select dimension reduction method',
('PCA','TSNE'))
dimension = st.sidebar.selectbox(
"Select the dimension of the visualization",
('2D', '3D'))
user_input = st.sidebar.text_input("Type the word that you want to investigate. You can type more than one word by separating one word with other with comma (,)",'')
top_n = st.sidebar.slider('Select the amount of words associated with the input words you want to visualize ',
5, 100, (5))
annotation = st.sidebar.radio(
"Enable or disable the annotation on the visualization",
('On', 'Off'))
if dim_red == 'TSNE':
perplexity = st.sidebar.slider('Adjust the perplexity. The perplexity is related to the number of nearest neighbors that is used in other manifold learning algorithms. Larger datasets usually require a larger perplexity',
5, 50, (30))
learning_rate = st.sidebar.slider('Adjust the learning rate',
10, 1000, (200))
iteration = st.sidebar.slider('Adjust the number of iteration',
250, 100000, (1000))
Теперь мы рассмотрели все части, необходимые для создания нашего веб-приложения. Наконец, мы можем упаковать эти вещи в полный скрипт, как показано ниже.
import plotly
import plotly.graph_objs as go
import numpy as np
import pickle
import streamlit as st
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
filename = 'glove2word2vec_model.sav'
model = pickle.load(open(filename, 'rb'))
def append_list(sim_words, words):
list_of_words = []
for i in range(len(sim_words)):
sim_words_list = list(sim_words[i])
sim_words_list.append(words)
sim_words_tuple = tuple(sim_words_list)
list_of_words.append(sim_words_tuple)
return list_of_words
def display_scatterplot_3D(model, user_input=None, words=None, label=None, color_map=None, annotation='On', dim_red = 'PCA', perplexity = 0, learning_rate = 0, iteration = 0, topn=0, sample=10):
if words == None:
if sample > 0:
words = np.random.choice(list(model.vocab.keys()), sample)
else:
words = [ word for word in model.vocab ]
word_vectors = np.array([model[w] for w in words])
if dim_red == 'PCA':
three_dim = PCA(random_state=0).fit_transform(word_vectors)[:,:3]
else:
three_dim = TSNE(n_components = 3, random_state=0, perplexity = perplexity, learning_rate = learning_rate, n_iter = iteration).fit_transform(word_vectors)[:,:3]
color = 'blue'
quiver = go.Cone(
x = [0,0,0],
y = [0,0,0],
z = [0,0,0],
u = [1.5,0,0],
v = [0,1.5,0],
w = [0,0,1.5],
anchor = "tail",
colorscale = [[0, color] , [1, color]],
showscale = False
)
data = [quiver]
count = 0
for i in range (len(user_input)):
trace = go.Scatter3d(
x = three_dim[count:count+topn,0],
y = three_dim[count:count+topn,1],
z = three_dim[count:count+topn,2],
text = words[count:count+topn] if annotation == 'On' else '',
name = user_input[i],
textposition = "top center",
textfont_size = 30,
mode = 'markers+text',
marker = {
'size': 10,
'opacity': 0.8,
'color': 2
}
)
data.append(trace)
count = count+topn
trace_input = go.Scatter3d(
x = three_dim[count:,0],
y = three_dim[count:,1],
z = three_dim[count:,2],
text = words[count:],
name = 'input words',
textposition = "top center",
textfont_size = 30,
mode = 'markers+text',
marker = {
'size': 10,
'opacity': 1,
'color': 'black'
}
)
data.append(trace_input)
# 配置布局
layout = go.Layout(
margin = {'l': 0, 'r': 0, 'b': 0, 't': 0},
showlegend=True,
legend=dict(
x=1,
y=0.5,
font=dict(
family="Courier New",
size=25,
color="black"
)),
font = dict(
family = " Courier New ",
size = 15),
autosize = False,
width = 1000,
height = 1000
)
plot_figure = go.Figure(data = data, layout = layout)
st.plotly_chart(plot_figure)
def horizontal_bar(word, similarity):
similarity = [ round(elem, 2) for elem in similarity ]
data = go.Bar(
x= similarity,
y= word,
orientation='h',
text = similarity,
marker_color= 4,
textposition='auto')
layout = go.Layout(
font = dict(size=20),
xaxis = dict(showticklabels=False, automargin=True),
yaxis = dict(showticklabels=True, automargin=True,autorange="reversed"),
margin = dict(t=20, b= 20, r=10)
)
plot_figure = go.Figure(data = data, layout = layout)
st.plotly_chart(plot_figure)
def display_scatterplot_2D(model, user_input=None, words=None, label=None, color_map=None, annotation='On', dim_red = 'PCA', perplexity = 0, learning_rate = 0, iteration = 0, topn=0, sample=10):
if words == None:
if sample > 0:
words = np.random.choice(list(model.vocab.keys()), sample)
else:
words = [ word for word in model.vocab ]
word_vectors = np.array([model[w] for w in words])
if dim_red == 'PCA':
two_dim = PCA(random_state=0).fit_transform(word_vectors)[:,:2]
else:
two_dim = TSNE(random_state=0, perplexity = perplexity, learning_rate = learning_rate, n_iter = iteration).fit_transform(word_vectors)[:,:2]
data = []
count = 0
for i in range (len(user_input)):
trace = go.Scatter(
x = two_dim[count:count+topn,0],
y = two_dim[count:count+topn,1],
text = words[count:count+topn] if annotation == 'On' else '',
name = user_input[i],
textposition = "top center",
textfont_size = 20,
mode = 'markers+text',
marker = {
'size': 15,
'opacity': 0.8,
'color': 2
}
)
data.append(trace)
count = count+topn
trace_input = go.Scatter(
x = two_dim[count:,0],
y = two_dim[count:,1],
text = words[count:],
name = 'input words',
textposition = "top center",
textfont_size = 20,
mode = 'markers+text',
marker = {
'size': 25,
'opacity': 1,
'color': 'black'
}
)
data.append(trace_input)
# 配置布局
layout = go.Layout(
margin = {'l': 0, 'r': 0, 'b': 0, 't': 0},
showlegend=True,
hoverlabel=dict(
bgcolor="white",
font_size=20,
font_family="Courier New"),
legend=dict(
x=1,
y=0.5,
font=dict(
family="Courier New",
size=25,
color="black"
)),
font = dict(
family = " Courier New ",
size = 15),
autosize = False,
width = 1000,
height = 1000
)
plot_figure = go.Figure(data = data, layout = layout)
st.plotly_chart(plot_figure)
dim_red = st.sidebar.selectbox(
'Select dimension reduction method',
('PCA','TSNE'))
dimension = st.sidebar.selectbox(
"Select the dimension of the visualization",
('2D', '3D'))
user_input = st.sidebar.text_input("Type the word that you want to investigate. You can type more than one word by separating one word with other with comma (,)",'')
top_n = st.sidebar.slider('Select the amount of words associated with the input words you want to visualize ',
5, 100, (5))
annotation = st.sidebar.radio(
"Enable or disable the annotation on the visualization",
('On', 'Off'))
if dim_red == 'TSNE':
perplexity = st.sidebar.slider('Adjust the perplexity. The perplexity is related to the number of nearest neighbors that is used in other manifold learning algorithms. Larger datasets usually require a larger perplexity',
5, 50, (30))
learning_rate = st.sidebar.slider('Adjust the learning rate',
10, 1000, (200))
iteration = st.sidebar.slider('Adjust the number of iteration',
250, 100000, (1000))
else:
perplexity = 0
learning_rate = 0
iteration = 0
if user_input == '':
similar_word = None
labels = None
color_map = None
else:
user_input = [x.strip() for x in user_input.split(',')]
result_word = []
for words in user_input:
sim_words = model.most_similar(words, topn = top_n)
sim_words = append_list(sim_words, words)
result_word.extend(sim_words)
similar_word = [word[0] for word in result_word]
similarity = [word[1] for word in result_word]
similar_word.extend(user_input)
labels = [word[2] for word in result_word]
label_dict = dict([(y,x+1) for x,y in enumerate(set(labels))])
color_map = [label_dict[x] for x in labels]
st.title('Word Embedding Visualization Based on Cosine Similarity')
st.header('This is a web app to visualize the word embedding.')
st.markdown('First, choose which dimension of visualization that you want to see. There are two options: 2D and 3D.')
st.markdown('Next, type the word that you want to investigate. You can type more than one word by separating one word with other with comma (,).')
st.markdown('With the slider in the sidebar, you can pick the amount of words associated with the input word you want to visualize. This is done by computing the cosine similarity between vectors of words in embedding space.')
st.markdown('Lastly, you have an option to enable or disable the text annotation in the visualization.')
if dimension == '2D':
st.header('2D Visualization')
st.write('For more detail about each point (just in case it is difficult to read the annotation), you can hover around each points to see the words. You can expand the visualization by clicking expand symbol in the top right corner of the visualization.')
display_pca_scatterplot_2D(model, user_input, similar_word, labels, color_map, annotation, dim_red, perplexity, learning_rate, iteration, top_n)
else:
st.header('3D Visualization')
st.write('For more detail about each point (just in case it is difficult to read the annotation), you can hover around each points to see the words. You can expand the visualization by clicking expand symbol in the top right corner of the visualization.')
display_pca_scatterplot_3D(model, user_input, similar_word, labels, color_map, annotation, dim_red, perplexity, learning_rate, iteration, top_n)
st.header('The Top 5 Most Similar Words for Each Input')
count=0
for i in range (len(user_input)):
st.write('The most similar words from '+str(user_input[i])+' are:')
horizontal_bar(similar_word[count:count+5], similarity[count:count+5])
count = count+top_n
Теперь веб-приложение можно запустить с помощью командной строки Conda. В командной строке перейдите в каталог скрипта Python и введите следующую команду:
$ streamlit run your_script_name.py
Затем автоматически откроется окно браузера, в котором вы сможете получить локальный доступ к своему веб-приложению. Ниже приведен снимок того, что вы можете делать с веб-приложением.
это все! Вы создали простое веб-приложение с большим количеством интерактивных функций для визуализации встраивания слов с помощью PCA или t-SNE.
Если вы хотите увидеть полный код визуализации встраивания слова, вы можете получить к нему доступ на моей странице GitHub.
Оригинальная ссылка:к data science.com/visualizing…
Добро пожаловать на сайт блога Panchuang AI:panchuang.net/
sklearn машинное обучение китайские официальные документы:sklearn123.com/
Добро пожаловать на станцию сводки ресурсов блога Panchuang:docs.panchuang.net/