Word to vec это

Как уже было сказано в прошлый раз, существует несколько видов преобразования слов в числа. Одним из таких NLP-методов является Word Embeddings. В этой статье рассмотрим наиболее популярную разновидность Word Embeddings – нейросеть Word2Vec.

Архитектура Word2Vec состоит из 3 слоев

Нейронная сеть Word2Vec имеет две реализации: Skip-gram и CBOW (Сontinuous bag-of-words). Skip-gram состоит из следующих трех слоев:

1. Входной слой, который принимает одно слово в формате one-hot, о котором говорилось тут. Суть one-hot encoding заключается в том, что слово кодируется бинарным вектором с одной единицей, которая представляет позицию слова в словаре:

   {шла, саша, по, шоссе} # словарь
   [1, 0, 0, 0] # шла
   [0, 1, 0, 0] # саша
   [0, 0, 1, 0] # по
   [0, 0, 0, 1] # шоссе
   

   Длина one-hot вектора равняется размеру словаря.

2. Слой Embedding, который представляет собой матрицу размером , где — размер словаря, — гиперпараметр, который подбирается эмпирически. В оригинальной статье в качестве размера P используется значение 300 [1].
3. Выходной слой с размером Nx1, где N — размер словаря. Это единственный слой, который имеет функцию активацию (softmax). Каждый из нейронов этого слоя выдает вероятность того, что входное слово принадлежит соответствующему контексту (другим словам).

Архитектура CBOW является зеркальным отражением Skip-gram, когда входной и выходной слой меняются местами: на вход подается контекст (множество слов), а модель предсказывает слово, подходящее этому контексту. Слой Embedding остается тем же.

Представление входного и выходного векторов через контекстное окно

После создания словаря необходимо выбрать входное слово и контекст к нему. Под контекстом подразумевается ближайшие слова, образованные в зависимости от размера контекстного окна. Например, есть предложение “Шла Саша по шоссе и сосала сушку”. Выбираем слово “шоссе” в качестве входного слова и окно с размером 2. Тогда имеем по два контекста слева и справа:

• (шоссе, и), (шоссе, сосала).
• (по, шоссе), (Саша, шоссе).

Число контекстных слов зависит от количества предложений и размера окна. Алгоритм word2vec ищет все предложения с входным словом и контекстом около него. Исходя из нашего предложения, можно составить входной и выходной векторы для одного слова:

{шла, саша, по, шоссе, и, сосала, сушку}
X_1 = [0, 0, 0, 1, 0, 0, 0] # входное слово “шоссе”
Y_1 = [0, 1, 1, 1, 1, 1, 0] # контекст (слова “шла” и “сушку” в него не входят)

Именно Y_1 является тем вектором, с которым сравниваются результаты выходного слоя.

Извлекаем из слоя Embedding только одну строку

Входной вектор (one-hot) умножается на матрицу Embedding, как это показано на рисунке ниже.

В итоге, из всей большой матрицы NxP выбирается только одна строка-вектор, которая и является векторным представлением слова (word embedding). Эта строка-вектор посылается на выходной слой, каждое соединение с нейроном которого имеет свои веса.

Выходной слой с функцией активацией softmax

Выходной слой содержит N нейронов с функцией активацией softmax, где N — размер словаря. Каждый нейрон соединен со слоем Emdedding. Рисунок ниже показывает эти соединения, где для нулевого нейрона показаны числовые значения весов.

Функция softmax вычисляется по следующей формуле:

   

Значение функции softmax – это вероятность того, что ответ правильный. Благодаря знаменателю, значения функции активации всех нейронов дадут в сумме 1.

Функция потерь считается вычисляется как

   

Минус стоит потому, что логарифм от чисел меньше 1 — отрицательный. На языке Python это может быть выражено следующим образом:

import np

L = np.sum(Y*np.log(Y_pred))

Эту функцию и нужно минимизировать, изменяя значения весов и матрицу Emdedding через алгоритм обратного распространения ошибки.

Дополнительные улучшения: Phrase Learning, Subsampling, Negative Sampling

Также авторы Word2Vec добавили некоторые улучшения в модель, а именно Phrase Learning, Subsampling и Negative Sampling, вместо которого можно использовать Hierarchical softmax. Рассмотрим эти инструменты подробнее.

Phrase Learning, означает, что некоторые слова стоит рассматривать вместе, например, “New_York”. Слово “New” в некоторых случаях может обозначать “новый”, но если “New” и “York” стоят вместе, то, скорее всего, имеется в виду “Нью-Йорк”. Также это поможет различать людей: “Петр_Сидоров” от “Петр_Козлов”.

Subsampling подразумевает избавление от слишком повторяющихся слов.a Предлоги, союзы могут быть в каждом контексте, но не раскрывать его смысл. Для каждого слова вычисляется вероятность того, что оно должно учитываться в обучении. Такая вероятность вычисляется следующим образом:

   

где — слово, а — частота встречаемости этого слова в корпусе. Таким образом, чем больше , тем выше вероятность того, что слово не имеет информативной ценности.

Negative Sampling необходим для уменьшения вычислительных затрат на обучение. Выходной слой имеет размерность N, равный размеру словаря. Если словарь содержит миллион слов, то и обновлять веса для каждого нейрона слишком затратно. Поэтому обновление весов можно осуществлять только для контекстных слов и 5-6 слов, которые не совпадают с контекстом (для большого датасета можно ограничиться 2-3). Кроме того, Negative sampling можно заменить на Hierarchical softmax, который разворачивает сеть в бинарное дерево, обновляя весов вместо весов.

В следующей статье расскажем о том, как обучить модель Word2Vec с примерами кода на Python. Еще больше подробностей о NLP-задачах в реальных проектах Data Science вы узнаете на наших курсах в лицензированном учебном центре обучения и повышения квалификации ИТ-специалистов в Москве.

Источники

https://arxiv.org/abs/1310.4546

Статья рассказывает об алгоритмах word2vec, на выходе которых получаются векторные представления слов. Векторы слов лежат в основе многих систем обработки естественного языка (NLP), захлестнувших современный мир (Amazon Alexa, Google translate и т.д.). 

Векторные представления слов: все дело в контексте

Давайте же погрузимся в тему. Слова-векторы (word vectors) — это численные представления слов, сохраняющие семантическую связь между ними. Например, для вектора cat (кошка) одним из наиболее близких будет слово dog (собака). Однако векторное представление слова pencil (карандаш) будет достаточно сильно отличаться от вектора cat. Эта схожесть обусловлена частотой встречаемости двух слов (т.е. [cat, dog] или [cat, pencil]) в одном контексте. Рассмотрим следующее предложение:

Думаю, не стоит объяснять, какое слово в этом предложении не подходит (очевидно, что это pencil). Как мы понимаем, что оно не подходит? С произношением все в порядке, с грамматикой все в порядке, тогда что же не так? Все дело в контексте, pencil не подходит по смыслу. Этот пример должен убедить вас в важности контекста. Алгоритмы word2vec используют контекст, чтобы сформировать численные представления слов, поэтому слова, используемые в одном и том же контексте, имеют похожие векторы.

Чтобы понять, как word2vec применяется в реальных проектах, попробуем следующее. Зайдем на google scholar и поищем там связанные с NLP задачи (например, вопросно-ответные системы, чат-боты, машинный перевод и прочее). Отфильтруем документы, опубликованные после 2013 года, когда появились методы word2vec. Если посчитать отношение количества статей, в которых рассказывается об использовании векторных представлений слов, к общему количеству статей, то получится довольно большое число.

Векторные представления слов используются во многих областях:

• Моделирование языков;
• Чат-боты;
• Машинный перевод;
• Вопросно-ответные системы;
• …и многое другое.

Вы можете заметить, что все современные приложения NLP основываются на алгоритмах word2vec. Давайте обсудим, как же можно улучшить существующие модели векторными представлениями слов. Они позволяют нам отобразить семантически сходные слова в близкие друг другу вектора в некоторой модели, в то время как далекие по смыслу слова будут выглядеть по-разному. Это желаемое свойство модели, которое приведет к лучшему результату.

Процесс создания векторов слов

Теперь, обладая интуитивным пониманием, мы первым делом обсудим общие принципы действия алгоритмов word2vec, а более детально рассмотрим их позднее. Чтобы обучить выборку слов без заранее размеченных данных, сначала нам нужно решить несколько задач:

1. Создать кортежи данных в формате [входное слово, выходное слово], каждое слово представлено в виде двоичного вектора длины n, где i-ое значение кодируется единицей на i-ой позиции и нулями на всех остальных (one-hot кодировка);
2. Создать модель, которая на вход и выход получает one-hot векторы;
3. Определить функцию потерь, предсказывающую верное слово, чтобы оптимизировать модель;
4. Определить качество модели, убедившись, что похожие слова имеют похожие векторные представления.

Как вы видите, процедура не очень сложная. В следующем разделе мы займемся каждым из шагов детально.

Создание структурированных данных из исходного текста

Возьмем такой пример:

The cat pushed the glass off the table.

Нужные нам данные будут получаться так. Каждая скобка обозначает единичное контекстное окно. Синее поле обозначает входной one-hot вектор (целевое слово), красное поле — выходной one-hot вектор (любое слово в контекстном окне за исключением целевого слова, так называемое контекстное слово). Из одного контекстного окна получаются два элемента данных (на одно целевое слово приходится два соседних). Размер окна обычно определяется пользователем. Чем больше размер контекстного окна, тем лучше наша модель, но это влияет на время выполнения алгоритма. Не надо путать целевое слово с целевыми данными, это совершенно разные вещи.

Определение embedding layer и нейросети

Наша нейросеть будет обучаться на входных данных, которые мы задали выше. Нам потребуется следующее:

• набор входных one-hot векторов;
• набор выходных one-hot векторов (после обучения);
• embedding layer;
• нейросеть.

Не беспокойтесь, если вы пока не понимаете, как работают два последних компонента. Мы рассмотрим их подробнее.

Embedding layer

Начнем с embedding layer. Он хранит вектора всех слов в словаре. Представьте себе огромную матрицу размера [число слов в словаре x размерность пространства сжатого векторного представления слов]). Эта размерность (embedding size) является настраиваемым параметром. Чем она больше, тем лучше модель (но по достижении определенного embedding size вы не получите большой прирост производительности). Эта гигантская матрица инициализируется случайным образом (как и нейросеть) и настраивается бит за битом в процессе оптимизации. Выглядит это так:

Нейронная сеть

Последний кирпичик нашей модели — нейронная сеть. В процессе обучения нейросеть получает входной вектор и пытается предсказать результат в виде распределения вероятностей слова быть в контексте входного слова на множестве всех слов (также его можно интерпретировать как линейную комбинацию one-hot кодировок этих слов). Затем с помощью функции потерь мы штрафуем модель за неправильную классификацию и награждаем за верную. Сейчас мы ограничимся обработкой одного входа и одного выхода за раз. В реальных проектах данные обрабатываются батчами (то есть группами; например, по 64 элемента). Опишем процесс обучения в общих чертах:

1. Для данного введенного слова (целевого слова) найдем соответствующий вектор из embedding layer;
2. Скормим этот вектор нашей нейросети, затем попытаемся предсказать правильное выходное (контекстное) слово;
3. Сравнив предсказанное слово и то слово, которое на самом деле находится в контекстном окне, вычислим функцию потерь;
4. Используя функцию потерь вместе со стохастическим градиентным спуском, оптимизируем нейросеть и embedding layer.

Нужно заметить, что при вычислении предсказания мы используем функцию softmax, чтобы нормализовать прогнозы до допустимого распределения вероятностей.

Собираем все вместе

Зная все детали алгоритма word2vec, мы можем собрать все воедино. После обучения модели нам остается только сохранить embedding layer на диске, после чего мы можем наслаждаться векторами с сохраненной семантикой в любое время. Вот так выглядит общая картина:

Эта модель известна как skip-gram алгоритм, это один из алгоритмов word2vec, на нем мы и сфокусируемся. Другой алгоритм известен как “непрерывный мешок со словами” (continuous bag-of-words model, CBOW).

Функция потерь: оптимизируем модель

Мы не обсудили одну из ключевых деталей — функцию потерь. Стандартная функция перекрестной энтропии (softmax cross entropy loss) является хорошим решением для задач классификации. Но для модели word2vec использование этой функции не является практичным, как например для более простой задачи вроде анализа тональности, где есть только два выходных варианта: положительный и отрицательный. В реальной задаче обработки слов, где их число может измеряться миллиардами, размер словаря запросто может вырасти до 100,000 значений или даже больше, что значительно усложняет вычисление softmax-нормализации. Это связано с тем, что для полного вычисления softmax требуется рассчитать потери в кросс-энтропии по всем выходным узлам.

Поэтому мы будем использовать более изящную альтернативу под названием sampled softmax loss функция. У нее есть ряд отличий от стандартной перекрестной энтропии.

Сначала мы вычисляем функцию перекрестной энтропии между истинным значением контекстного слова для заданного целевого слова и значением предсказанного слова, соответствующего истинному значению контекстного слова. Затем мы добавим кросс-энтропийную потерю k негативных семплов (целевое слово + слово вне контекстного окна), которые мы отбирали в соответствии с некоторым распределением шума.

Функция потерь определяется следующим образом:

SigmoidCrossEntropy это ошибка, которую мы можем определить на одном выходном узле независимо от остальных. Это идеальное решение нашей проблемы, когда словарь становится слишком большим. Не будем вдаваться в детали этой функции. Вам необязательно понимать, как именно она реализована, поскольку в TensorFlow эта функция встроенная, но стоит понять, что такое k, что это за параметр. Самое важное  —  это что sampled softmax loss вычисляет ошибку, рассматривая два типа объектов:

• индекс правильного контекстного слова в предсказанном векторе (индекс слова в контекстном окне);
• k индексов шумовых слов.

Мы проиллюстрируем это примером. Тут k = 1 (cat + glass):

Реализация на TensorFlow: skip-gram алгоритм

В этом разделе мы соберем все части воедино и попробуем реализовать наш алгоритм. Код доступен тут. В этой секции мы займемся следующим:

• генератор данных;
• skip-gram модель (на TensorFlow);
• запуск skip-gram алгоритма.

Генерация данных

Мы не будем углубляться в код детально, так как уже обсудили внутренние механизмы генерации данных. Просто опишем наши действия на Python:

def generate_batch(batch_size, window_size):
  global data_index 
    
  # two numpy arras to hold target words (batch)
  # and context words (labels)
  batch = np.ndarray(shape=(batch_size), dtype=np.int32)
  labels = np.ndarray(shape=(batch_size, 1), dtype=np.int32)
    
  # span defines the total window size
  span = 2 * window_size + 1 
    
  # The buffer holds the data contained within the span
  queue = collections.deque(maxlen=span)
  
  # Fill the buffer and update the data_index
  for _ in range(span):
    queue.append(data[data_index])
    data_index = (data_index + 1) % len(data)
  

  for i in range(batch_size // (2*window_size)):
    k=0
    # Avoid the target word itself as a prediction
    for j in list(range(window_size))+list(range(window_size+1,2*window_size+1)):
      batch[i * (2*window_size) + k] = queue[window_size]
      labels[i * (2*window_size) + k, 0] = queue[j]
      k += 1 
    
    # Everytime we read num_samples data points, update the queue
    queue.append(data[data_index])
    
    # If end is reached, circle back to the beginning
    data_index = (data_index + np.random.randint(window_size)) % len(data)
    
  return batch, labels

Определим skip-gram модель

Сначала мы определим некоторые гиперпараметры:

batch_size = 128 
embedding_size = 64 
window_size = 4 
num_sampled = 32 # Number of negative examples to sample.

batch_size устанавливает количество элементов данных, которые мы обрабатываем в данный момент времени. embedding_size  это длина вектора. Гиперпараметр window_size определяет размер контекстного окна. Наконец, num_sampled  — число негативных семплов в функции потерь (k). Теперь мы определим входные и выходные данные:

tf.reset_default_graph() 
# Training input data (target word IDs). 
train_dataset = tf.placeholder(tf.int32, shape=[batch_size])

# Training input label data (context word IDs) 
train_labels = tf.placeholder(tf.int32, shape=[batch_size, 1])

train_dataset принимает на вход список идентификаторов слов batch_size, который представляет выбранный набор целевых слов. train_labels представляет собой список batch_size
соответствующих контекстных слов для выбранных целевых слов.

Затем мы определяем параметры нейронной сети:

################################################
#            Model variables                   #
################################################

# Embedding layer
embeddings = tf.Variable(tf.random_uniform([vocabulary_size, embedding_size], -1.0, 1.0))

# Neural network weights and biases
softmax_weights = tf.Variable(
    tf.truncated_normal([vocabulary_size, embedding_size],
                        stddev=0.1 / math.sqrt(embedding_size))
)
softmax_biases = tf.Variable(tf.random_uniform([vocabulary_size],-0.01,0.01))

Embedding layer в TensorFlow определяется переменной embeddings, веса — переменной softmax_weights, параметры сдвига — softmax_biases.

Соединим embedding layer и нейросеть, чтобы оптимизировать результат:

# Look up embeddings for a batch of inputs. 
embed = tf.nn.embedding_lookup(embeddings, train_dataset)

Функция tf.nn.embedding_lookup принимает на вход embedding layer и набор идентификаторов слов (train_dataset), а на выходе выдает соответствующие вектора.

Теперь настало время функции  sampled softmax loss:

################################################ 
#              Computes loss                   # 
################################################ 
loss = tf.reduce_mean(tf.nn.sampled_softmax_loss( weights=softmax_weights, biases=softmax_biases, inputs=embed, labels=train_labels, num_sampled=num_sampled, num_classes=vocabulary_size) )

Здесь tf.nn.sampled_softmax_loss получает на вход набор весов (softmax_weights), сдвигов (softmax_biases), полученный в предыдущей функции набор векторов embed, идентификаторы верных контекстных слов (train_labels), количество шумовых семплов (num_sampled) и размер словаря (vocabulary_size).  
Оптимизируем функцию потерь по параметрам embedding layer и нейросети:

################################################ 
#                 Optimization                 # 
################################################ 
optimizer = tf.train.AdamOptimizer(0.001).minimize(loss)

Нормируем embedding layer:

################################################ 
#                For evaluation                # ################################################ 
norm = tf.sqrt(tf.reduce_sum(tf.square(embeddings), 1, keepdims=True)) 
normalized_embeddings = embeddings / norm

Запускаем код

Как же мы запустим нашу TensorFlow модель? Для начала определим session и инициализируем все переменные случайным образом.

num_steps = 250001 
session = tf.InteractiveSession() 
# Initialize the variables in the graph
tf.global_variables_initializer().run() 
print('Initialized') 
average_loss = 0

Теперь в течение заранее определенного числа шагов мы формируем группы данных: целевые слова (batch_data) и контекстные слова (batch_labels):

for step in range(num_steps): 
    # Generate a single batch of data
    batch_data, batch_labels = generate_batch( batch_size, window_size)

Затем для каждой сгенерированной группы мы оптимизируем embedding layer и нейронную сеть с помощью session.run([optimize, loss],…). Также мы вычислим ошибку, чтобы убедиться, что она уменьшается.

 # Optimize the embedding layer and neural network
    # compute loss
    feed_dict = {train_dataset : batch_data, train_labels : batch_labels}
    _, l = session.run([optimizer, loss], feed_dict=feed_dict)

Каждые пять тысяч шагов мы печатаем на экране среднюю ошибку:

  if (step+1) % 5000 == 0:
      if step > 0:
        average_loss = average_loss / 5000

      print('Average loss at step %d: %f' % (step+1, average_loss))
      average_loss = 0

И вот мы получаем вектора, которые позже используем для визуализации определенных слов:

sg_embeddings = normalized_embeddings.eval() 
session.close()

Если мы визуализируем результат с помощью какого-нибудь алгоритма вроде t-SNE, получим следующее:

Как можно заметить, слова, относящиеся к кошкам, находятся в определенной области (cat, kitten, cats, wildcat), а слова, относящиеся к собакам, находятся в другой области (dog, dogs, wolf). Слова между этими областями (например, animal или pet) по смыслу относятся и к кошкам, и к собакам, что нам и требовалось.

Заключение

Вот мы и подошли к концу. Векторные представления слов  — это очень мощный инструмент, который помогает улучшать современные модели машинного обучения. Мы научились генерировать данные и разобрались в базовых принципах работы word2vec. Затем мы обсудили skip-gram алгоритм и реализовали его на TensorFlow. В довершение ко всему мы визуализировали наши векторные представления и убедились, что семантическая составляющая действительно сохраняется. Надеюсь, эта статья была для вас полезной.

Оригинал — Thushan Ganegedara, перевод — Станислава Рунова.

From Wikipedia, the free encyclopedia

Word2vec is a technique for natural language processing (NLP) published in 2013. The word2vec algorithm uses a neural network model to learn word associations from a large corpus of text. Once trained, such a model can detect synonymous words or suggest additional words for a partial sentence. As the name implies, word2vec represents each distinct word with a particular list of numbers called a vector. The vectors are chosen carefully such that they capture the semantic and syntactic qualities of words; as such, a simple mathematical function (cosine similarity) can indicate the level of semantic similarity between the words represented by those vectors.

Approach[edit]

Word2vec is a group of related models that are used to produce word embeddings. These models are shallow, two-layer neural networks that are trained to reconstruct linguistic contexts of words. Word2vec takes as its input a large corpus of text and produces a vector space, typically of several hundred dimensions, with each unique word in the corpus being assigned a corresponding vector in the space.

Word2vec can utilize either of two model architectures to produce these distributed representations of words: continuous bag-of-words (CBOW) or continuous skip-gram. In both architectures, word2vec considers both individual words and a sliding window of context words surrounding individual words as it iterates over the entire corpus. In the continuous bag-of-words architecture, the model predicts the current word from the window of surrounding context words. The order of context words does not influence prediction (bag-of-words assumption). In the continuous skip-gram architecture, the model uses the current word to predict the surrounding window of context words.^[1][2] The skip-gram architecture weighs nearby context words more heavily than more distant context words. According to the authors’ note,^[3] CBOW is faster while skip-gram does a better job for infrequent words.

After the model has trained, the learned word embeddings are positioned in the vector space such that words that share common contexts in the corpus — that is, words that are semantically and syntactically similar — are located close to one another in the space.^[1] More dissimilar words are located farther from one another in the space.^[1]

This occurs because words which influence relative word probabilities in similar ways will have learned similar embeddings once the model has finished. For example, consider the CBOW framework, which can be thought of as a ‘fill in the blank’ task. The learned embedding for a word will represent the way in which, when that word appears in a context window, it influences the relative probabilities of other words appearing in the ‘blank,’ or the position at the center of the context window. Therefore, words which are semantically similar should influence these probabilities in similar ways, because semantically similar words should be used in similar contexts.

History[edit]

Word2vec was created, patented,^[4] and published in 2013 by a team of researchers led by Tomas Mikolov at Google over two papers.^[1][2] Other researchers helped analyse and explain the algorithm.^[5] Embedding vectors created using the Word2vec algorithm have some advantages compared to earlier algorithms^{[1][further explanation needed]} such as latent semantic analysis.

By 2022, the Word2vec approach was described as «dated», with transformer models being regarded as the state of the art in NLP.^[6]

Parameterization[edit]

Results of word2vec training can be sensitive to parametrization. The following are some important parameters in word2vec training.

Training algorithm[edit]

A Word2vec model can be trained with hierarchical softmax and/or negative sampling. To approximate the conditional log-likelihood a model seeks to maximize, the hierarchical softmax method uses a Huffman tree to reduce calculation. The negative sampling method, on the other hand, approaches the maximization problem by minimizing the log-likelihood of sampled negative instances. According to the authors, hierarchical softmax works better for infrequent words while negative sampling works better for frequent words and better with low dimensional vectors.^[3] As training epochs increase, hierarchical softmax stops being useful.^[7]

Sub-sampling[edit]

High-frequency and low-frequency words often provide little information. Words with a frequency above a certain threshold, or below a certain threshold, may be subsampled or removed to speed up training.^[8]

Dimensionality[edit]

Quality of word embedding increases with higher dimensionality. But after reaching some point, marginal gain diminishes.^[1] Typically, the dimensionality of the vectors is set to be between 100 and 1,000.

Context window[edit]

The size of the context window determines how many words before and after a given word are included as context words of the given word. According to the authors’ note, the recommended value is 10 for skip-gram and 5 for CBOW.^[3]

Extensions[edit]

There are a variety of extensions to word2vec.

doc2vec[edit]

doc2vec, generates distributed representations of variable-length pieces of texts, such as sentences, paragraphs, or entire documents.^[9][10] doc2vec has been implemented in the C, Python and Java/Scala tools (see below), with the Java and Python versions also supporting inference of document embeddings on new, unseen documents.

doc2vec estimates the distributed representations of documents much like how word2vec estimates representations of words: doc2vec utilizes either of two model architectures, both of which are allegories to the architectures used in word2vec. The first, Distributed Memory Model of Paragraph Vectors (PV-DM), is identical to CBOW other than it also provides a unique document identifier as a piece of additional context. The second architecture, Distributed Bag of Words version of Paragraph Vector (PV-DBOW), is identical to the skip-gram model except that it attempts to predict the window of surrounding context words from the paragraph identifier instead of the current word.^[9]

doc2vec also has the ability to capture the semantic ‘meanings’ for additional pieces of  ‘context’ around words; doc2vec can estimate the semantic embeddings for speakers or speaker attributes, groups, and periods of time. For example, doc2vec has been used to estimate the political positions of political parties in various Congresses and Parliaments in the U.S. and U.K.,^[11] respectively, and various governmental institutions.^[12]

top2vec[edit]

Another extension of word2vec is top2vec, which leverages both document and word embeddings to estimate distributed representations of topics.^[13][14] top2vec takes document embeddings learned from a doc2vec model and reduces them into a lower dimension (typically using UMAP). The space of documents is then scanned using HDBSCAN,^[15] and clusters of similar documents are found. Next, the centroid of documents identified in a cluster is considered to be that cluster’s topic vector. Finally, top2vec searches the semantic space for word embeddings located near to the topic vector to ascertain the ‘meaning’ of the topic.^[13] The word with embeddings most similar to the topic vector might be assigned as the topic’s title, whereas far away word embeddings may be considered unrelated.

As opposed to other topic models such as LDA, top2vec provides canonical ‘distance’ metrics between two topics, or between a topic and another embeddings (word, document, or otherwise). Together with results from HDBSCAN, users can generate topic hierarchies, or groups of related topics and subtopics.

Furthermore, a user can use the results of top2vec to infer the topics of out-of-sample documents. After inferring the embedding for a new document, must only search the space of topics for the closest topic vector.

BioVectors[edit]

An extension of word vectors for n-grams in biological sequences (e.g. DNA, RNA, and proteins) for bioinformatics applications has been proposed by Asgari and Mofrad.^[16] Named bio-vectors (BioVec) to refer to biological sequences in general with protein-vectors (ProtVec) for proteins (amino-acid sequences) and gene-vectors (GeneVec) for gene sequences, this representation can be widely used in applications of machine learning in proteomics and genomics. The results suggest that BioVectors can characterize biological sequences in terms of biochemical and biophysical interpretations of the underlying patterns.^[16] A similar variant, dna2vec, has shown that there is correlation between Needleman–Wunsch similarity score and cosine similarity of dna2vec word vectors.^[17]

Radiology and intelligent word embeddings (IWE)[edit]

An extension of word vectors for creating a dense vector representation of unstructured radiology reports has been proposed by Banerjee et al.^[18] One of the biggest challenges with Word2vec is how to handle unknown or out-of-vocabulary (OOV) words and morphologically similar words. If the Word2vec model has not encountered a particular word before, it will be forced to use a random vector, which is generally far from its ideal representation. This can particularly be an issue in domains like medicine where synonyms and related words can be used depending on the preferred style of radiologist, and words may have been used infrequently in a large corpus.

IWE combines Word2vec with a semantic dictionary mapping technique to tackle the major challenges of information extraction from clinical texts, which include ambiguity of free text narrative style, lexical variations, use of ungrammatical and telegraphic phases, arbitrary ordering of words, and frequent appearance of abbreviations and acronyms. Of particular interest, the IWE model (trained on the one institutional dataset) successfully translated to a different institutional dataset which demonstrates good generalizability of the approach across institutions.

Analysis[edit]

The reasons for successful word embedding learning in the word2vec framework are poorly understood. Goldberg and Levy point out that the word2vec objective function causes words that occur in similar contexts to have similar embeddings (as measured by cosine similarity) and note that this is in line with J. R. Firth’s distributional hypothesis. However, they note that this explanation is «very hand-wavy» and argue that a more formal explanation would be preferable.^[5]

Levy et al. (2015)^[19] show that much of the superior performance of word2vec or similar embeddings in downstream tasks is not a result of the models per se, but of the choice of specific hyperparameters. Transferring these hyperparameters to more ‘traditional’ approaches yields similar performances in downstream tasks. Arora et al. (2016)^[20] explain word2vec and related algorithms as performing inference for a simple generative model for text, which involves a random walk generation process based upon loglinear topic model. They use this to explain some properties of word embeddings, including their use to solve analogies.

Preservation of semantic and syntactic relationships[edit]

The word embedding approach is able to capture multiple different degrees of similarity between words. Mikolov et al. (2013)^[21] found that semantic and syntactic patterns can be reproduced using vector arithmetic. Patterns such as «Man is to Woman as Brother is to Sister» can be generated through algebraic operations on the vector representations of these words such that the vector representation of «Brother» — «Man» + «Woman» produces a result which is closest to the vector representation of «Sister» in the model. Such relationships can be generated for a range of semantic relations (such as Country–Capital) as well as syntactic relations (e.g. present tense–past tense).

This facet of word2vec has been exploited in a variety of other contexts. For example, word2vec has been used to map a vector space of words in one language to a vector space constructed from another language. Relationships between translated words in both spaces can be used to assist with machine translation of new words.^[22]

Assessing the quality of a model[edit]

Mikolov et al. (2013)^[1] develop an approach to assessing the quality of a word2vec model which draws on the semantic and syntactic patterns discussed above. They developed a set of 8,869 semantic relations and 10,675 syntactic relations which they use as a benchmark to test the accuracy of a model. When assessing the quality of a vector model, a user may draw on this accuracy test which is implemented in word2vec,^[23] or develop their own test set which is meaningful to the corpora which make up the model. This approach offers a more challenging test than simply arguing that the words most similar to a given test word are intuitively plausible.^[1]

Parameters and model quality[edit]

The use of different model parameters and different corpus sizes can greatly affect the quality of a word2vec model. Accuracy can be improved in a number of ways, including the choice of model architecture (CBOW or Skip-Gram), increasing the training data set, increasing the number of vector dimensions, and increasing the window size of words considered by the algorithm. Each of these improvements comes with the cost of increased computational complexity and therefore increased model generation time.^[1]

In models using large corpora and a high number of dimensions, the skip-gram model yields the highest overall accuracy, and consistently produces the highest accuracy on semantic relationships, as well as yielding the highest syntactic accuracy in most cases. However, the CBOW is less computationally expensive and yields similar accuracy results.^[1]

Overall, accuracy increases with the number of words used and the number of dimensions. Mikolov et al.^[1] report that doubling the amount of training data results in an increase in computational complexity equivalent to doubling the number of vector dimensions.

Altszyler and coauthors (2017) studied Word2vec performance in two semantic tests for different corpus size.^[24] They found that Word2vec has a steep learning curve, outperforming another word-embedding technique, latent semantic analysis (LSA), when it is trained with medium to large corpus size (more than 10 million words). However, with a small training corpus, LSA showed better performance. Additionally they show that the best parameter setting depends on the task and the training corpus. Nevertheless, for skip-gram models trained in medium size corpora, with 50 dimensions, a window size of 15 and 10 negative samples seems to be a good parameter setting.

See also[edit]

References[edit]

External links[edit]

• Wikipedia2Vec[1] (introduction)

Implementations[edit]

• C
• C#
• Python (Spark)
• Python (TensorFlow)
• Python (Gensim)
• Java/Scala
• R

Векторное представление слов (англ. word embedding) — общее название для различных подходов к моделированию языка и обучению представлений в обработке естественного языка, направленных на сопоставление словам из некоторого словаря векторов небольшой размерности.

One-hot encoding

Пусть число различных слов равно . Сопоставим слову с номером вектор длины , в котором -тая координата равна единице, а все остальные — нулям (рис. 1). Недостатком one-hot encoding является то, что по векторным представлениям нельзя судить о схожести смысла слов. Также вектора имеют очень большой размер, из-за чего их неэффективно хранить в памяти.

word2vec

word2vec — способ построения сжатого пространства векторов слов, использующий нейронные сети. Принимает на вход большой текстовый корпус и сопоставляет каждому слову вектор. Сначала он создает словарь, а затем вычисляет векторное представление слов. Векторное представление основывается на контекстной близости: слова, встречающиеся в тексте рядом с одинаковыми словами (а следовательно, имеющие схожий смысл) (рис. 2), в векторном представлении имеют высокое косинусное сходство (англ. cosine similarity):

В word2vec существуют две основных модели обучения: Skip-gram (рис. 3) и CBOW (англ. Continuous Bag of Words) (рис. 4). В модели Skip-gram по слову предсказываются слова из его контекста, а в модели CBOW по контексту подбирается наиболее вероятное слово. На выходном слое используется функция или его вариация, чтобы получить на выходе распределение вероятности каждого слова. В обеих моделях входные и выходные слова подаются в one-hot encoding, благодаря чему при умножении на матрицу , соединяющую входной и скрытый слои, происходит выбор одной строки . Размерность является гиперпараметром алгоритма, а обученная матрица — выходом, так как ее строки содержат векторные представления слов.

Для ускорения обучения моделей Skip-gram и CBOW используются модификации , такие как иерархический и negative sampling, позволяющие вычислять распределение вероятностей быстрее, чем за линейное время от размера словаря.

fastText

Недостатком word2vec является то, что с его помощью не могут быть представлены слова, не встречающиеся в обучающей выборке. fastText решает эту проблему с помощью -грамм символов. Например, -граммами для слова яблоко являются ябл, бло, лок, око. Модель fastText строит векторные представления -грамм, а векторным представлением слова является сумма векторных представлений всех его -грамм. Части слов с большой вероятностью встречаются и в других словах, что позволяет выдавать векторные представления и для редких слов.

Примеры кода с использованием библиотеки Gensim

Загрузка предобученной модели русского корпуса

import gensim
import gensim.downloader as download_api
russian_model = download_api.load('word2vec-ruscorpora-300')

# Выведем первые 10 слов корпуса.
# В модели "word2vec-ruscorpora-300" после слова указывается часть речи: NOUN (существительное), ADJ (прилагательное) и так далее.
# Но существуют также предоубученные модели без разделения слов по частям речи, смотри репозиторий
list(russian_model.vocab.keys())[:10]
# ['весь_DET', 'человек_NOUN', 'мочь_VERB', 'год_NOUN', 'сказать_VERB', 'время_NOUN', 'говорить_VERB', 'становиться_VERB', 'знать_VERB', 'самый_DET']
 
# Поиск наиболее близких по смыслу слов.
russian_model.most_similar('кошка_NOUN')
#  [('кот_NOUN', 0.7570087909698486), ('котенок_NOUN', 0.7261239290237427), ('собака_NOUN', 0.6963180303573608),
#  ('мяукать_VERB', 0.6411399841308594), ('крыса_NOUN', 0.6355636119842529), ('собачка_NOUN', 0.6092042922973633),
#  ('щенок_NOUN', 0.6028496026992798), ('мышь_NOUN', 0.5975362062454224), ('пес_NOUN', 0.5956044793128967),
#  ('кошечка_NOUN', 0.5920293927192688)]

# Вычисление сходства слов
russian_model.similarity('мужчина_NOUN', 'женщина_NOUN')
# 0.85228276

# Поиск лишнего слова
russian_model.doesnt_match('завтрак_NOUN хлопья_NOUN обед_NOUN ужин_NOUN'.split())
# хлопья_NOUN

# Аналогия: Женщина + (Король - Мужчина) = Королева
russian_model.most_similar(positive=['король_NOUN','женщина_NOUN'], negative=['мужчина_NOUN'], topn=1)
# [('королева_NOUN', 0.7313904762268066)]

# Аналогия: Франция = Париж + (Германия - Берлин)
russian_model.most_similar(positive=['париж_NOUN','германия_NOUN'], negative=['берлин_NOUN'], topn=1)
# [('франция_NOUN', 0.8673800230026245)]

Обучение модели word2vec и fastText на текстовом корпусе

from gensim.models.word2vec import Word2Vec
from gensim.models.fasttext import FastText
import gensim.downloader as download_api

# Скачаем небольшой текстовый корпус (32 Мб) и откроем его как итерируемый набор предложений: iterable(list(string))
# В этом текстовом корпусе часть речи для слов не указывается
corpus = download_api.load('text8')

# Обучим модели word2vec и fastText
word2vec_model = Word2Vec(corpus, size=100, workers=4)
fastText_model = FastText(corpus, size=100, workers=4)

word2vec_model.most_similar('car')[:3]
# [('driver', 0.8033335208892822), ('motorcycle', 0.7368553876876831), ('cars', 0.7001584768295288)]
 
fastText_model.most_similar('car')[:3]
# [('lcar', 0.8733218908309937), ('boxcar', 0.8559106588363647), ('ccar', 0.8268736004829407)]

ELMO

ELMO — это многослойная двунаправленная рекуррентная нейронная сеть c LSTM (рис. 5).
При использовании word2vec или fastText не учитывается семантическая неоднозначность слов.
Так, word2vec назначает слову один вектор независимо от контекста.
ELMO решает эту проблему. В основе стоит идея использовать скрытые состояния языковой модели многослойной LSTM.

Было замечено, что нижние слои сети отвечают за синтаксис и грамматику, а верхние — за смысл слов.
Пусть даны токены , на которые поделено предложение. Будем считать логарифм правдоподобия метки слова в обоих направлениях, учитывая контекст слева и контекст справа, то есть на основании данных от начала строки до текущего символа и данных от текущего символа и до конца строки.
Таким образом, модель предсказывает вероятность следующего токена с учетом истории.

Пусть есть слоев сети. Входные и выходные данные будем представлять в виде векторов, кодируя слова. Тогда каждый результирующий вектор будем считать на основании множества:

.

Здесь — входящий токен, а и — скрытые слои в одном и в другом направлении.

Тогда результат работы ELMO будет представлять из себя выражение:
.

Обучаемый общий масштабирующий коэффициент регулирует то, как могут отличаться друг от друга по норме векторные представления слов.

Коэффициенты — это обучаемые параметры, нормализованные функцией .

Модель применяют дообучая ее: изначально берут предобученную ELMO, а затем корректируют и под конкретную задачу. Тогда вектор, который подается в используемую модель для обучения, будет представлять собой взвешенную сумму значений этого векторах на всех скрытых слоях ELMO.

На данный момент предобученную модель ELMO можно загрузить и использовать в языке программирования Python.

BERT

BERT — это многослойный двунаправленный кодировщик Transformer. В данной архитектуре (рис. 6) используется двунаправленное самовнимание (англ. self-attention).
Модель используется в совокупности с некоторым классификатором, на вход которого подается результат работы BERT — векторное представление входных данных.
В основе обучения модели лежат две идеи.

Первая заключается в том, чтобы заменить слов масками и обучить сеть предсказывать эти слова.

Второй трюк состоит в том, чтобы дополнительно научить BERT определять, может ли одно предложение идти после другого.

Точно так же, как и в обычном трансформере, BERT принимает на вход последовательность слов, которая затем продвигается вверх по стеку энкодеров.
Каждый слой энкодера применяет самовнимание и передает результаты в сеть прямого распространения, после чего направляет его следующему энкодеру.

Для каждой позиции на выход подается вектор размерностью ( в базовой модели).
Этот вектор может быть использован как входной вектор для классификатора.

Bert поддерживается в качестве модели в языке Python, которую можно загрузить.

См. также

• Обработка естественного языка

Источники информации

• Word embedding — статья о векторных представлениях в английской Википедии
• (YouTube) Обработка естественного языка — лекция на русском Даниила Полыковского в курсе Техносферы
• (YouTube) Word Vector Representations: word2vec — лекция на английском в Стэнфордском Университете
• word2vec article — оригинальная статья по word2vec от Томаса Миколова
• word2vec code — исходный код word2vec на Google Code
• Gensim tutorial on word2vec — небольшое руководство по работе с word2vec в библиотеке Gensim
• Gensim documentation on fastText — документация по fastText в библиотеке Gensim
• Gensim Datasets — репозиторий предобученных моделей для библиотеки Gensim
• fastText — NLP библиотека от Facebook
• fastText article — оригинальная статья по fastText от Piotr Bojanowski
• RusVectōrēs — онлайн сервис для работы с семантическими отношениями русского языка
• Cornell univerity arxiv — оригинальная статья про Bert
• Cornell univerity arxiv — оригинальная статья с описанием ELMO