python - 串联嵌入层

我正在尝试创建一个以单词为输入的模型。这些词大多数都在手套词向量集中（〜50000）。但是，某些常用词不是（〜1000）。问题是，如何连接以下两个嵌入层以创建一个巨型Embedding查找表？

trained_em = Embedding(50000, 50,
                       weights=np.array([word2glove[w] for w in words_in_glove]),
                       trainable=False)
untrained_em = Embedding(1000, 50)

据我了解，这些只是两个具有相同维数的查找表。因此，我希望有一种方法可以堆叠这两个查找表。

编辑1：
我刚刚意识到，这可能不仅仅是堆叠Embedding图层，因为输入序列将是0-50999中的数字。但是，上面的untrained_em仅期望来自0-999的数字。因此，可能需要其他解决方案。

编辑2：
这是我期望在表示嵌入的numpy数组中执行的操作：

np.random.seed(42) # Set seed for reproducibility
pretrained = np.random.randn(15,3)
untrained = np.random.randn(5,3)
final_embedding = np.vstack([pretrained, untrained])

word_idx = [2, 5, 19]
np.take(final_embedding, word_idx, axis=0)

我相信最后一点可以通过keras.backend.gather来完成，但是不确定如何将它们放在一起。

最佳答案

原来，我需要实现一个自定义层。这是通过调整原始的Embedding类实现的。

此类中显示的两个最重要的部分是self.embeddings = K.concatenate([fixed_weight, variable_weight], axis=0)和out = K.gather(self.embeddings, inputs)。希望第一个可以自我解释，而第二个可以从input表中选择相关的embeddings行。

但是，在我正在处理的特定应用程序中，事实证明，使用Embedding层而不是修改后的层，效果更好。也许是因为学习率太高。经过更多的实验后，我将对此进行报告。

from keras.engine.topology import Layer
import keras.backend as K
from keras import initializers
import numpy as np

class Embedding2(Layer):

    def __init__(self, input_dim, output_dim, fixed_weights, embeddings_initializer='uniform',
                 input_length=None, **kwargs):
        kwargs['dtype'] = 'int32'
        if 'input_shape' not in kwargs:
            if input_length:
                kwargs['input_shape'] = (input_length,)
            else:
                kwargs['input_shape'] = (None,)
        super(Embedding2, self).__init__(**kwargs)

        self.input_dim = input_dim
        self.output_dim = output_dim
        self.embeddings_initializer = embeddings_initializer
        self.fixed_weights = fixed_weights
        self.num_trainable = input_dim - len(fixed_weights)
        self.input_length = input_length

    def build(self, input_shape, name='embeddings'):
        initializer = initializers.get(self.embeddings_initializer)
        shape1 = (self.num_trainable, self.output_dim)
        variable_weight = K.variable(initializer(shape1), dtype=K.floatx(), name=name+'_var')

        fixed_weight = K.variable(self.fixed_weights, name=name+'_fixed')


        self._trainable_weights.append(variable_weight)
        self._non_trainable_weights.append(fixed_weight)

        self.embeddings = K.concatenate([fixed_weight, variable_weight], axis=0)

        self.built = True

    def call(self, inputs):
        if K.dtype(inputs) != 'int32':
            inputs = K.cast(inputs, 'int32')
        out = K.gather(self.embeddings, inputs)
        return out

    def compute_output_shape(self, input_shape):
        if not self.input_length:
            input_length = input_shape[1]
        else:
            input_length = self.input_length
        return (input_shape[0], input_length, self.output_dim)

关于python - 串联嵌入层，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/46032700/