如何使用词嵌入（即 Word2vec、GloVe 或 BERT）来计算一组 N 个词中最大的词相似度？

Question

我试图通过输入单词列表和 output 一个单词来计算语义相似度，这是列表中单词相似度最高的。

例如

如果我传入一个单词列表

words = ['portugal', 'spain', 'belgium', 'country', 'netherlands', 'italy']

它应该 output 我是这样的 -

['country']

Answer 1

首先，在 Google News 上训练的预训练 word2vec需要从https://drive.google.com/file/d/0B7XkCwpI5KDYNlNUTTlSS21pQmM/edit下载。

然后，单词嵌入之间的余弦相似度可以计算如下：

import gensim
import warnings
warnings.filterwarnings(action='ignore', category=UserWarning, module='gensim')
from gensim.models.keyedvectors import KeyedVectors
from numpy import dot
from numpy.linalg import norm

def cosine_sim(a,b):
    return dot(a, b)/(norm(a)*norm(b))

# load the w2v model
path_pretraind_model='./GoogleNews-vectors-negative300.bin/GoogleNews-vectors-negative300.bin'  #set as the path of pretraind model 
model = KeyedVectors.load_word2vec_format(path_pretraind_model, binary=True)


wlist = ['portugal', 'spain', 'belgium', 'country', 'netherlands', 'italy']
lenwlist=len(wlist)
avrsim=[]
#compute cosine similarity between each word in wlist with the other words in wlist  
for i in range(lenwlist):
    word=wlist[i]
    totalsim=0
    wordembed=model[word] 
    for j in range(lenwlist):
        if i!=j:
            word2embed=model[wlist[j]] 
            totalsim+=cosine_sim(wordembed, word2embed)
    avrsim.append(totalsim/ (lenwlist-1)) #add the average similarity between word and any other words in wlist   

index_min=avrsim.index(min(avrsim)) #get min similarity        
print(wlist[index_min])

如果你的意思是词嵌入之间的余弦相似度，那么“国家”与其他词的相似度最低。

Answer 2

手套嵌件

要加载预训练的 GloVe 嵌入，我们将使用名为 torchtext 的torchtext 。 它包含其他有用的处理文本的工具，我们将在课程后面看到。 torchtext GloVe 向量的文档位于： https://torchtext.readthedocs.io/en/latest/vocab.html#glove

首先加载一组 GloVe 嵌入。 第一次运行下面的代码时，Python 将下载一个包含预训练嵌入的大文件 (862MB)。

import torch
import torchtext

glove = torchtext.vocab.GloVe(name="6B", # trained on Wikipedia 2014 corpus of 6 billion words
                              dim=50)   # embedding size = 100

让我们看看“car”这个词的嵌入是什么样子的：

glove['cat']

tensor([ 0.4528, -0.5011, -0.5371, -0.0157, 0.2219, 0.5460, -0.6730, -0.6891, 0.6349, -0.1973, 0.3368, 0.7735, 0.9009, 0.3849, 0.3837, 0.2657, -0.0806, 0.6109, -1.2894, - 0.2231，-0.6158，0.2170，0.3561，0.4450，0.6089，-1.1633，-1.1579，0.3612，0.1047，0.1047，0.7832，1.4352，1.4352，0.4352，0.1863，0.1863，0.1863，0.2611，0.8328，0.8328，0.8328，-0.8328，-0.8328，-0.8328，-0.8328，-0.8328，-0.8328，-0.8328，-0.8328，-0.8328，-0.8328，-0.8328，-0.8328，-0.8328，0.8352 -0.0975, 0.4814, -0.4335, 0.6945, 0.9104, -0.2817, 0.4164, -1.2609, 0.7128, 0.2378])

它是一个尺寸为 (50,) 的火炬张量。 如果有的话，很难确定这个嵌入中的每个数字意味着什么。 但是，我们知道这个嵌入空间是有结构的。 也就是说，这个嵌入空间中的距离是有意义的。

测量距离

为了探索嵌入空间的结构，有必要引入距离的概念。 您可能已经熟悉欧几里得距离的概念。 两个向量 x=[x1,x2,...xn] 和 y=[y1,y2,...yn] 的欧几里得距离只是它们的差 x−y 的 2-范数。

PyTorch function torch.norm为我们计算向量的 2 范数，因此我们可以计算两个向量之间的欧几里得距离，如下所示：

x = glove['cat']
y = glove['dog']
torch.norm(y - x)

张量（1.8846）

余弦相似度是距离的另一种度量。 余弦相似度测量两个向量之间的角度，并且具有只考虑向量的方向而不考虑它们的大小的特性。 （接下来我们将使用这个属性 class。）

x = torch.tensor([1., 1., 1.]).unsqueeze(0)
y = torch.tensor([2., 2., 2.]).unsqueeze(0)
torch.cosine_similarity(x, y) # should be one

张量（[1.]）

余弦相似度是一种相似度度量而不是距离度量：相似度越大，词嵌入彼此之间就越“接近”。

x = glove['cat']
y = glove['dog']
torch.cosine_similarity(x.unsqueeze(0), y.unsqueeze(0))

张量（[0.9218]）

词相似度

现在我们在嵌入空间中有了距离的概念，我们可以讨论在嵌入空间中彼此“接近”的单词。 现在，让我们使用欧几里得距离来看看各种单词与“猫”这个词的接近程度。

word = 'cat'
other = ['dog', 'bike', 'kitten', 'puppy', 'kite', 'computer', 'neuron']
for w in other:
    dist = torch.norm(glove[word] - glove[w]) # euclidean distance
    print(w, float(dist))

狗 1.8846031427383423

自行车 5.048375129699707

小猫 3.5068609714508057

小狗 3.0644655227661133

风筝 4.210376262664795

电脑 6.030652046203613

神经元 6.228669166564941

事实上，我们可以在整个词汇表中查找最接近嵌入空间中某个点的单词——例如，我们可以查找最接近另一个单词（如“cat”）的单词。

def print_closest_words(vec, n=5):
    dists = torch.norm(glove.vectors - vec, dim=1)     # compute distances to all words
    lst = sorted(enumerate(dists.numpy()), key=lambda x: x[1]) # sort by distance
    for idx, difference in lst[1:n+1]:                         # take the top n
        print(glove.itos[idx], difference)

print_closest_words(glove["cat"], n=10)

狗 1.8846031

兔子 2.4572797

猴子 2.8102052

猫 2.8972247

老鼠 2.9455352

野兽 2.9878407

怪物 3.0022194

宠物 3.0396757

蛇 3.0617998

小狗 3.0644655

print_closest_words(glove['nurse'])

医生 3.1274529

牙医 3.1306612

护士 3.26872

儿科医生 3.3212206

辅导员 3.3987114

print_closest_words(glove['computer'])

电脑 2.4362664

软件 2.926823

技术 3.190351

电子 3.5067408

计算 3.5999784

我们还可以查看哪些词最接近两个词的中点：

print_closest_words((glove['happy'] + glove['sad']) / 2)

快乐 1.9199749

感觉 2.3604643

抱歉 2.4984782

几乎没有 2.52593

想象一下 2.5652788

print_closest_words((glove['lake'] + glove['building']) / 2)

周边 3.0698414

附近 3.1112068

桥 3.1585503

沿 3.1610188

岸上 3.1618817

类比

GloVe 向量的一个令人惊讶的方面是嵌入空间中的方向可能是有意义的。 GloVe 向量的结构类似于这样的某些类比关系倾向于成立：

国王-男人+女人≈王后

print_closest_words(glove['king'] - glove['man'] + glove['woman'])

女王 2.8391209

王子 3.6610038

伊丽莎白 3.7152522

女儿 3.8317878

寡妇 3.8493774

我们得到合理的答案，例如“女王”、“王位”和我们现任女王的名字。

我们同样可以翻转类比：

print_closest_words(glove['queen'] - glove['woman'] + glove['man'])

国王 2.8391209

王子 3.2508988

皇冠 3.4485192

骑士 3.5587437

加冕礼 3.6198905

或者，沿着性别轴尝试不同但相关的类比：

print_closest_words(glove['king'] - glove['prince'] + glove['princess'])

女王 3.1845968

国王 3.9103293

新娘 4.285721

女士 4.299571

妹妹 4.421178

print_closest_words(glove['uncle'] - glove['man'] + glove['woman'])

祖母 2.323353

阿姨 2.3527892

孙女 2.3615322

女儿 2.4039288

大叔2.6026237

print_closest_words(glove['grandmother'] - glove['mother'] + glove['father'])

叔叔 2.0784423

父亲 2.0912483

孙子 2.2965577

侄子 2.353551

长者 2.4274695

print_closest_words(glove['old'] - glove['young'] + glove['father'])

父亲 4.0326614

儿子 4.4065413

祖父 4.51851

孙子 4.722089

女儿 4.786716

我们可以将嵌入移向“好”或“坏”的方向：

print_closest_words(glove['programmer'] - glove['bad'] + glove['good'])

多功能 4.381561

创意 4.5690007

企业家 4.6343737

启用 4.7177725

智能4.7349973

print_closest_words(glove['programmer'] - glove['good'] + glove['bad'])

黑客 3.8383653

故障 4.003873

发起人 4.041952

破解 4.047719

序列号 4.2250676

词向量中的偏差

机器学习模型有一种“公平”的感觉，因为模型在没有人工干预的情况下做出决策。 但是，模型可以并且确实可以学习训练数据中存在的任何偏差！

GloVe 向量似乎足够无害：它们只是某些嵌入空间中单词的表示。 即便如此，我们将展示 GloVe 向量的结构对它们所训练的文本中存在的日常偏差进行编码。

我们将从一个示例类比开始：

医生-男人+女人≈??

让我们使用 GloVe 向量来找到上述类比的答案：

print_closest_words(glove['doctor'] - glove['man'] + glove['woman'])

护士 3.1355345

怀孕 3.7805371

孩子 3.78347

女人 3.8643107

母亲 3.922231

医生-男人+女人≈护士的类比非常令人担忧。 只是为了验证，如果我们翻转性别术语，不会出现相同的结果：

print_closest_words(glove['doctor'] - glove['woman'] + glove['man'])

男人 3.9335632

同事 3.975502

他自己 3.9847782

兄弟3.9997008

另一个 4.029071

我们在其他职业中看到了类似类型的性别偏见。

print_closest_words(glove['programmer'] - glove['man'] + glove['woman'])

神童 3.6688528

心理治疗师 3.8069527

治疗师 3.8087194

介绍 3.9064546

瑞典出生 4.1178856

除了第一个结果之外，其他单词甚至都与编程无关，相比之下，如果我们翻转性别术语：我们会得到非常不同的结果：

print_closest_words(glove['programmer'] - glove['woman'] + glove['man'])

设置 4.002241

创新者 4.0661883

程序员 4.1729574

黑客 4.2256656

天才 4.3644104

以下是“工程师”的结果：

print_closest_words(glove['engineer'] - glove['man'] + glove['woman'])

技术员 3.6926973

机械师 3.9212747

先驱 4.1543956

开创先河 4.1880875

教育家 4.2264576

print_closest_words(glove['engineer'] - glove['woman'] + glove['man'])

建设者 4.3523865

机械师 4.402976

工程师 4.477985

工作 4.5281315

替换 4.600204