tf.nn.embedding_lookup 函数有什么作用？
What does tf.nn.embedding_lookup function do?
tf.nn.embedding_lookup(params, ids, partition_strategy='mod', name=None)
我无法理解这个函数的职责。是不是像查找table？即return每个id对应的参数（in ids）？
例如，在 skip-gram 模型中，如果我们使用 tf.nn.embedding_lookup(embeddings, train_inputs)，那么对于每个 train_input 它找到对应的嵌入？
embedding_lookup 函数检索 params 张量的行。该行为类似于在 numpy 中使用数组索引。例如
matrix = np.random.random([1024, 64]) # 64-dimensional embeddings
ids = np.array([0, 5, 17, 33])
print matrix[ids] # prints a matrix of shape [4, 64]
params 参数也可以是张量列表，在这种情况下 ids 将分布在张量中。例如，给定一个包含 3 个张量 [2, 64] 的列表，默认行为是它们将表示 ids：[0, 3]、[1, 4]、[2, 5]。
partition_strategy 控制 ids 在列表中的分布方式。当矩阵可能太大而无法保持一个整体时，分区对于更大规模的问题很有用。
是的，这个函数很难理解，直到你明白了。
最简单的形式类似于tf.gather。它return根据ids指定的索引得到params的元素。
例如（假设您在 tf.InteractiveSession() 内）
params = tf.constant([10,20,30,40])
ids = tf.constant([0,1,2,3])
print tf.nn.embedding_lookup(params,ids).eval()
会return[10 20 30 40]，因为params的第一个元素（index 0）是10，params的第二个元素（index 1）是20，等等
同样，
params = tf.constant([10,20,30,40])
ids = tf.constant([1,1,3])
print tf.nn.embedding_lookup(params,ids).eval()
会 return [20 20 40].
但 embedding_lookup 远不止于此。 params 参数可以是张量的 列表 ，而不是单个张量。
params1 = tf.constant([1,2])
params2 = tf.constant([10,20])
ids = tf.constant([2,0,2,1,2,3])
result = tf.nn.embedding_lookup([params1, params2], ids)
在这种情况下，ids中指定的索引对应于根据分区策略的张量元素，其中默认分区策略是'mod'.
在'mod'策略中，索引0对应于列表中第一个张量的第一个元素。索引 1 对应于 second 张量的 first 元素。索引 2 对应于 third 张量的 first 元素，依此类推。简单地索引 i 对应于第 (i+1) 个张量的第一个元素，对于所有索引 0..(n-1)，假设参数是 n 个张量的列表。
现在，索引n不能对应张量n+1，因为列表params只包含n个张量。所以索引 n 对应于第一个张量的 second 元素。同样，索引n+1对应第二张量的第二个元素，以此类推
所以，在代码中
params1 = tf.constant([1,2])
params2 = tf.constant([10,20])
ids = tf.constant([2,0,2,1,2,3])
result = tf.nn.embedding_lookup([params1, params2], ids)
index 0对应第一个张量的第一个元素：1
index 1对应第二张量的第一个元素：10
index 2对应第一个张量的第二个元素：2
index 3对应第二张量的第二个元素：20
因此，结果将是：
[ 2 1 2 10 2 20]
添加到 Asher Stern 的回答中，
params 是
解释为大嵌入张量的分区。它可以是代表完整嵌入张量的单个张量，
或 X 张量的列表，除了第一维外都具有相同的形状，
表示分片嵌入张量。
写函数tf.nn.embedding_lookup是考虑到embedding(params)会很大。因此我们需要 partition_strategy.
另一种看待它的方法是，假设您将张量展平为一维数组，然后执行查找
（例如）Tensor0=[1,2,3]，Tensor1=[4,5,6]，Tensor2=[7,8,9]
展平后的张量如下
[1,4,7,2,5,8,3,6,9]
现在，当您查找 [0,3,4,1,7] 时，它将产生 [1,2,5,4,6]
(i,e) 例如，如果查找值为 7，并且我们有 3 个张量（或具有 3 行的张量），则
7 / 3 : (Reminder is 1, Quotient is 2) 所以 Tensor1 的第二个元素将被显示，即 6
当params张量为高维时，ids仅指顶层维度。也许这对大多数人来说是显而易见的，但我必须 运行 下面的代码才能理解：
embeddings = tf.constant([[[1,1],[2,2],[3,3],[4,4]],[[11,11],[12,12],[13,13],[14,14]],
[[21,21],[22,22],[23,23],[24,24]]])
ids=tf.constant([0,2,1])
embed = tf.nn.embedding_lookup(embeddings, ids, partition_strategy='div')
with tf.Session() as session:
result = session.run(embed)
print (result)
只是尝试 'div' 策略，对于一个张量，没有任何区别。
这是输出：
[[[ 1 1]
[ 2 2]
[ 3 3]
[ 4 4]]
[[21 21]
[22 22]
[23 23]
[24 24]]
[[11 11]
[12 12]
[13 13]
[14 14]]]
是的，tf.nn.embedding_lookup()函数的目的是在嵌入矩阵和[=89=中执行查找 ] 单词的嵌入（或简单地说，向量表示）。
一个简单的嵌入矩阵（形状：vocabulary_size x embedding_dimension）如下所示。 （即每个 word 将由数字的 vector 表示；因此得名 word2vec）
嵌入矩阵
the 0.418 0.24968 -0.41242 0.1217 0.34527 -0.044457 -0.49688 -0.17862
like 0.36808 0.20834 -0.22319 0.046283 0.20098 0.27515 -0.77127 -0.76804
between 0.7503 0.71623 -0.27033 0.20059 -0.17008 0.68568 -0.061672 -0.054638
did 0.042523 -0.21172 0.044739 -0.19248 0.26224 0.0043991 -0.88195 0.55184
just 0.17698 0.065221 0.28548 -0.4243 0.7499 -0.14892 -0.66786 0.11788
national -1.1105 0.94945 -0.17078 0.93037 -0.2477 -0.70633 -0.8649 -0.56118
day 0.11626 0.53897 -0.39514 -0.26027 0.57706 -0.79198 -0.88374 0.30119
country -0.13531 0.15485 -0.07309 0.034013 -0.054457 -0.20541 -0.60086 -0.22407
under 0.13721 -0.295 -0.05916 -0.59235 0.02301 0.21884 -0.34254 -0.70213
such 0.61012 0.33512 -0.53499 0.36139 -0.39866 0.70627 -0.18699 -0.77246
second -0.29809 0.28069 0.087102 0.54455 0.70003 0.44778 -0.72565 0.62309
我拆分了上面的嵌入矩阵，只加载了vocab中的词，这将是我们的词汇表和emb数组中的相应向量。
vocab = ['the','like','between','did','just','national','day','country','under','such','second']
emb = np.array([[0.418, 0.24968, -0.41242, 0.1217, 0.34527, -0.044457, -0.49688, -0.17862],
[0.36808, 0.20834, -0.22319, 0.046283, 0.20098, 0.27515, -0.77127, -0.76804],
[0.7503, 0.71623, -0.27033, 0.20059, -0.17008, 0.68568, -0.061672, -0.054638],
[0.042523, -0.21172, 0.044739, -0.19248, 0.26224, 0.0043991, -0.88195, 0.55184],
[0.17698, 0.065221, 0.28548, -0.4243, 0.7499, -0.14892, -0.66786, 0.11788],
[-1.1105, 0.94945, -0.17078, 0.93037, -0.2477, -0.70633, -0.8649, -0.56118],
[0.11626, 0.53897, -0.39514, -0.26027, 0.57706, -0.79198, -0.88374, 0.30119],
[-0.13531, 0.15485, -0.07309, 0.034013, -0.054457, -0.20541, -0.60086, -0.22407],
[ 0.13721, -0.295, -0.05916, -0.59235, 0.02301, 0.21884, -0.34254, -0.70213],
[ 0.61012, 0.33512, -0.53499, 0.36139, -0.39866, 0.70627, -0.18699, -0.77246 ],
[ -0.29809, 0.28069, 0.087102, 0.54455, 0.70003, 0.44778, -0.72565, 0.62309 ]])
emb.shape
# (11, 8)
在 TensorFlow 中嵌入查找
现在我们将了解如何对任意输入句子执行嵌入查找。
In [54]: from collections import OrderedDict
# embedding as TF tensor (for now constant; could be tf.Variable() during training)
In [55]: tf_embedding = tf.constant(emb, dtype=tf.float32)
# input for which we need the embedding
In [56]: input_str = "like the country"
# build index based on our `vocabulary`
In [57]: word_to_idx = OrderedDict({w:vocab.index(w) for w in input_str.split() if w in vocab})
# lookup in embedding matrix & return the vectors for the input words
In [58]: tf.nn.embedding_lookup(tf_embedding, list(word_to_idx.values())).eval()
Out[58]:
array([[ 0.36807999, 0.20834 , -0.22318999, 0.046283 , 0.20097999,
0.27515 , -0.77126998, -0.76804 ],
[ 0.41800001, 0.24968 , -0.41242 , 0.1217 , 0.34527001,
-0.044457 , -0.49687999, -0.17862 ],
[-0.13530999, 0.15485001, -0.07309 , 0.034013 , -0.054457 ,
-0.20541 , -0.60086 , -0.22407 ]], dtype=float32)
观察我们如何使用词汇表中的 单词索引 从我们的原始嵌入矩阵（带有单词）中获得 embeddings。
通常，这样的嵌入查找由第一层（称为 嵌入层）执行，然后将这些嵌入传递给 RNN/LSTM/GRU 层进行进一步处理。
旁注：通常词汇表也会有一个特殊的unk标记。因此，如果我们输入句子中的标记不存在于我们的词汇表中，那么对应于 unk 的索引将在嵌入矩阵中查找。
P.S. 请注意，embedding_dimension 是一个超参数，必须针对其应用进行调整，但流行的模型如 Word2Vec and GloVe 使用 300 维度向量来表示每个单词。
因为我也对这个功能感兴趣，所以我会给我两分钱。
我在 2D 情况下看到的方式就像矩阵乘法一样（很容易推广到其他维度）。
考虑一个有 N 个符号的词汇表。
然后，您可以将符号 x 表示为维度为 Nx1 的向量，单热编码。
但是您希望此符号的表示形式不是 Nx1 向量，而是维度 Mx1 的向量，称为 y。
所以，要将x变换成y，您可以使用和嵌入矩阵 E，维度 MxN：
y = E x.
这基本上就是 tf.nn.embedding_lookup(params, ids, ...) 正在做的事情，细微差别是 ids 只是一个代表位置的数字one-hot-encoded 向量中的 1 x.
这是一张描述嵌入查找过程的图片。
简而言之，它获取由 ID 列表指定的嵌入层的相应行，并将其作为张量提供。它是通过以下过程实现的。
- 定义占位符
lookup_ids = tf.placeholder([10])
- 定义一个嵌入层
embeddings = tf.Variable([100,10],...)
- 定义tensorflow操作
embed_lookup = tf.embedding_lookup(embeddings, lookup_ids)
- 通过运行
lookup = session.run(embed_lookup, feed_dict={lookup_ids:[95,4,14]}) 得到结果
tf.nn.embedding_lookup(params, ids, partition_strategy='mod', name=None)
我无法理解这个函数的职责。是不是像查找table？即return每个id对应的参数（in ids）？
例如，在 skip-gram 模型中，如果我们使用 tf.nn.embedding_lookup(embeddings, train_inputs)，那么对于每个 train_input 它找到对应的嵌入？
embedding_lookup 函数检索 params 张量的行。该行为类似于在 numpy 中使用数组索引。例如
matrix = np.random.random([1024, 64]) # 64-dimensional embeddings
ids = np.array([0, 5, 17, 33])
print matrix[ids] # prints a matrix of shape [4, 64]
params 参数也可以是张量列表，在这种情况下 ids 将分布在张量中。例如，给定一个包含 3 个张量 [2, 64] 的列表，默认行为是它们将表示 ids：[0, 3]、[1, 4]、[2, 5]。
partition_strategy 控制 ids 在列表中的分布方式。当矩阵可能太大而无法保持一个整体时，分区对于更大规模的问题很有用。
是的，这个函数很难理解，直到你明白了。
最简单的形式类似于tf.gather。它return根据ids指定的索引得到params的元素。
例如（假设您在 tf.InteractiveSession() 内）
params = tf.constant([10,20,30,40])
ids = tf.constant([0,1,2,3])
print tf.nn.embedding_lookup(params,ids).eval()
会return[10 20 30 40]，因为params的第一个元素（index 0）是10，params的第二个元素（index 1）是20，等等
同样，
params = tf.constant([10,20,30,40])
ids = tf.constant([1,1,3])
print tf.nn.embedding_lookup(params,ids).eval()
会 return [20 20 40].
但 embedding_lookup 远不止于此。 params 参数可以是张量的 列表 ，而不是单个张量。
params1 = tf.constant([1,2])
params2 = tf.constant([10,20])
ids = tf.constant([2,0,2,1,2,3])
result = tf.nn.embedding_lookup([params1, params2], ids)
在这种情况下，ids中指定的索引对应于根据分区策略的张量元素，其中默认分区策略是'mod'.
在'mod'策略中，索引0对应于列表中第一个张量的第一个元素。索引 1 对应于 second 张量的 first 元素。索引 2 对应于 third 张量的 first 元素，依此类推。简单地索引 i 对应于第 (i+1) 个张量的第一个元素，对于所有索引 0..(n-1)，假设参数是 n 个张量的列表。
现在，索引n不能对应张量n+1，因为列表params只包含n个张量。所以索引 n 对应于第一个张量的 second 元素。同样，索引n+1对应第二张量的第二个元素，以此类推
所以，在代码中
params1 = tf.constant([1,2])
params2 = tf.constant([10,20])
ids = tf.constant([2,0,2,1,2,3])
result = tf.nn.embedding_lookup([params1, params2], ids)
index 0对应第一个张量的第一个元素：1
index 1对应第二张量的第一个元素：10
index 2对应第一个张量的第二个元素：2
index 3对应第二张量的第二个元素：20
因此，结果将是：
[ 2 1 2 10 2 20]
添加到 Asher Stern 的回答中，
params 是
解释为大嵌入张量的分区。它可以是代表完整嵌入张量的单个张量，
或 X 张量的列表，除了第一维外都具有相同的形状，
表示分片嵌入张量。
写函数tf.nn.embedding_lookup是考虑到embedding(params)会很大。因此我们需要 partition_strategy.
另一种看待它的方法是，假设您将张量展平为一维数组，然后执行查找
（例如）Tensor0=[1,2,3]，Tensor1=[4,5,6]，Tensor2=[7,8,9]
展平后的张量如下 [1,4,7,2,5,8,3,6,9]
现在，当您查找 [0,3,4,1,7] 时，它将产生 [1,2,5,4,6]
(i,e) 例如，如果查找值为 7，并且我们有 3 个张量（或具有 3 行的张量），则
7 / 3 : (Reminder is 1, Quotient is 2) 所以 Tensor1 的第二个元素将被显示，即 6
当params张量为高维时，ids仅指顶层维度。也许这对大多数人来说是显而易见的，但我必须 运行 下面的代码才能理解：
embeddings = tf.constant([[[1,1],[2,2],[3,3],[4,4]],[[11,11],[12,12],[13,13],[14,14]],
[[21,21],[22,22],[23,23],[24,24]]])
ids=tf.constant([0,2,1])
embed = tf.nn.embedding_lookup(embeddings, ids, partition_strategy='div')
with tf.Session() as session:
result = session.run(embed)
print (result)
只是尝试 'div' 策略，对于一个张量，没有任何区别。
这是输出：
[[[ 1 1]
[ 2 2]
[ 3 3]
[ 4 4]]
[[21 21]
[22 22]
[23 23]
[24 24]]
[[11 11]
[12 12]
[13 13]
[14 14]]]
是的，tf.nn.embedding_lookup()函数的目的是在嵌入矩阵和[=89=中执行查找 ] 单词的嵌入（或简单地说，向量表示）。
一个简单的嵌入矩阵（形状：vocabulary_size x embedding_dimension）如下所示。 （即每个 word 将由数字的 vector 表示；因此得名 word2vec）
嵌入矩阵
the 0.418 0.24968 -0.41242 0.1217 0.34527 -0.044457 -0.49688 -0.17862
like 0.36808 0.20834 -0.22319 0.046283 0.20098 0.27515 -0.77127 -0.76804
between 0.7503 0.71623 -0.27033 0.20059 -0.17008 0.68568 -0.061672 -0.054638
did 0.042523 -0.21172 0.044739 -0.19248 0.26224 0.0043991 -0.88195 0.55184
just 0.17698 0.065221 0.28548 -0.4243 0.7499 -0.14892 -0.66786 0.11788
national -1.1105 0.94945 -0.17078 0.93037 -0.2477 -0.70633 -0.8649 -0.56118
day 0.11626 0.53897 -0.39514 -0.26027 0.57706 -0.79198 -0.88374 0.30119
country -0.13531 0.15485 -0.07309 0.034013 -0.054457 -0.20541 -0.60086 -0.22407
under 0.13721 -0.295 -0.05916 -0.59235 0.02301 0.21884 -0.34254 -0.70213
such 0.61012 0.33512 -0.53499 0.36139 -0.39866 0.70627 -0.18699 -0.77246
second -0.29809 0.28069 0.087102 0.54455 0.70003 0.44778 -0.72565 0.62309
我拆分了上面的嵌入矩阵，只加载了vocab中的词，这将是我们的词汇表和emb数组中的相应向量。
vocab = ['the','like','between','did','just','national','day','country','under','such','second']
emb = np.array([[0.418, 0.24968, -0.41242, 0.1217, 0.34527, -0.044457, -0.49688, -0.17862],
[0.36808, 0.20834, -0.22319, 0.046283, 0.20098, 0.27515, -0.77127, -0.76804],
[0.7503, 0.71623, -0.27033, 0.20059, -0.17008, 0.68568, -0.061672, -0.054638],
[0.042523, -0.21172, 0.044739, -0.19248, 0.26224, 0.0043991, -0.88195, 0.55184],
[0.17698, 0.065221, 0.28548, -0.4243, 0.7499, -0.14892, -0.66786, 0.11788],
[-1.1105, 0.94945, -0.17078, 0.93037, -0.2477, -0.70633, -0.8649, -0.56118],
[0.11626, 0.53897, -0.39514, -0.26027, 0.57706, -0.79198, -0.88374, 0.30119],
[-0.13531, 0.15485, -0.07309, 0.034013, -0.054457, -0.20541, -0.60086, -0.22407],
[ 0.13721, -0.295, -0.05916, -0.59235, 0.02301, 0.21884, -0.34254, -0.70213],
[ 0.61012, 0.33512, -0.53499, 0.36139, -0.39866, 0.70627, -0.18699, -0.77246 ],
[ -0.29809, 0.28069, 0.087102, 0.54455, 0.70003, 0.44778, -0.72565, 0.62309 ]])
emb.shape
# (11, 8)
在 TensorFlow 中嵌入查找
现在我们将了解如何对任意输入句子执行嵌入查找。
In [54]: from collections import OrderedDict
# embedding as TF tensor (for now constant; could be tf.Variable() during training)
In [55]: tf_embedding = tf.constant(emb, dtype=tf.float32)
# input for which we need the embedding
In [56]: input_str = "like the country"
# build index based on our `vocabulary`
In [57]: word_to_idx = OrderedDict({w:vocab.index(w) for w in input_str.split() if w in vocab})
# lookup in embedding matrix & return the vectors for the input words
In [58]: tf.nn.embedding_lookup(tf_embedding, list(word_to_idx.values())).eval()
Out[58]:
array([[ 0.36807999, 0.20834 , -0.22318999, 0.046283 , 0.20097999,
0.27515 , -0.77126998, -0.76804 ],
[ 0.41800001, 0.24968 , -0.41242 , 0.1217 , 0.34527001,
-0.044457 , -0.49687999, -0.17862 ],
[-0.13530999, 0.15485001, -0.07309 , 0.034013 , -0.054457 ,
-0.20541 , -0.60086 , -0.22407 ]], dtype=float32)
观察我们如何使用词汇表中的 单词索引 从我们的原始嵌入矩阵（带有单词）中获得 embeddings。
通常，这样的嵌入查找由第一层（称为 嵌入层）执行，然后将这些嵌入传递给 RNN/LSTM/GRU 层进行进一步处理。
旁注：通常词汇表也会有一个特殊的unk标记。因此，如果我们输入句子中的标记不存在于我们的词汇表中，那么对应于 unk 的索引将在嵌入矩阵中查找。
P.S. 请注意，embedding_dimension 是一个超参数，必须针对其应用进行调整，但流行的模型如 Word2Vec and GloVe 使用 300 维度向量来表示每个单词。
因为我也对这个功能感兴趣，所以我会给我两分钱。
我在 2D 情况下看到的方式就像矩阵乘法一样（很容易推广到其他维度）。
考虑一个有 N 个符号的词汇表。 然后，您可以将符号 x 表示为维度为 Nx1 的向量，单热编码。
但是您希望此符号的表示形式不是 Nx1 向量，而是维度 Mx1 的向量，称为 y。
所以，要将x变换成y，您可以使用和嵌入矩阵 E，维度 MxN：
y = E x.
这基本上就是 tf.nn.embedding_lookup(params, ids, ...) 正在做的事情，细微差别是 ids 只是一个代表位置的数字one-hot-encoded 向量中的 1 x.
这是一张描述嵌入查找过程的图片。
简而言之，它获取由 ID 列表指定的嵌入层的相应行，并将其作为张量提供。它是通过以下过程实现的。
- 定义占位符
lookup_ids = tf.placeholder([10]) - 定义一个嵌入层
embeddings = tf.Variable([100,10],...) - 定义tensorflow操作
embed_lookup = tf.embedding_lookup(embeddings, lookup_ids) - 通过运行
lookup = session.run(embed_lookup, feed_dict={lookup_ids:[95,4,14]})得到结果