¿Qué es una incrustación en Keras?

La documentación de Keras no está clara de qué es esto en realidad. Entiendo que podemos usar esto para comprimir el espacio de características de entrada en uno más pequeño. Pero, ¿cómo se hace esto desde la perspectiva del diseño neuronal? ¿Es un autoenocder, RBM?

Hasta donde yo sé, la capa de incrustación es una multiplicación de matriz simple que transforma las palabras en sus correspondientes incrustaciones de palabras.

Los pesos de la capa Embedding son de la forma (vocabulary_size, embedding_dimension). Para cada muestra de entrenamiento, su entrada son números enteros, que representan ciertas palabras. Los números enteros están en el rango del tamaño del vocabulario. La capa de incrustación transforma cada entero i en la i-ésima línea de la matriz de pesos de incrustación.

Para hacer esto rápidamente como una multiplicación de matrices, los enteros de entrada no se almacenan como una lista de enteros sino como una matriz de un solo uso. Por lo tanto, la forma de entrada es (nb_words, vocabulary_size) con un valor distinto de cero por línea. Si multiplica esto por los pesos de incrustación, obtiene el resultado en la forma

(nb_words, vocab_size) x (vocab_size, embedding_dim) = (nb_words, embedding_dim)

Entonces, con una simple multiplicación de matrices, transforma todas las palabras en una muestra en las incrustaciones de palabras correspondientes.

La Keras Embeddingcapa no está realizando ninguna multiplicación de matrices, pero solo:

1. crea una matriz de peso de (vocabulary_size) x (embedding_dimension) dimensiones

2. indexa esta matriz de ponderaciones

Siempre es útil echar un vistazo al código fuente para comprender lo que hace una clase. En este caso, veremos la class incrustación que hereda de la capa base classllamada Capa .

(1) - Creando una matriz de peso de (vocabulary_size) x (embedding_dimension) dimensiones:

Esto ocurre en la buildfunción de incrustación :

def build(self, input_shape):
    self.embeddings = self.add_weight(
        shape=(self.input_dim, self.output_dim),
        initializer=self.embeddings_initializer,
        name='embeddings',
        regularizer=self.embeddings_regularizer,
        constraint=self.embeddings_constraint,
        dtype=self.dtype)
    self.built = True

Si echa un vistazo a la capa de clase base , verá que la función add_weightanterior simplemente crea una matriz de pesos entrenables (en este caso de (vocabulary_size) x (embedding_dimension) dimensiones):

def add_weight(self,
               name,
               shape,
               dtype=None,
               initializer=None,
               regularizer=None,
               trainable=True,
               constraint=None):
    """Adds a weight variable to the layer.
    # Arguments
        name: String, the name for the weight variable.
        shape: The shape tuple of the weight.
        dtype: The dtype of the weight.
        initializer: An Initializer instance (callable).
        regularizer: An optional Regularizer instance.
        trainable: A boolean, whether the weight should
            be trained via backprop or not (assuming
            that the layer itself is also trainable).
        constraint: An optional Constraint instance.
    # Returns
        The created weight variable.
    """
    initializer = initializers.get(initializer)
    if dtype is None:
        dtype = K.floatx()
    weight = K.variable(initializer(shape),
                        dtype=dtype,
                        name=name,
                        constraint=constraint)
    if regularizer is not None:
        with K.name_scope('weight_regularizer'):
            self.add_loss(regularizer(weight))
    if trainable:
        self._trainable_weights.append(weight)
    else:
        self._non_trainable_weights.append(weight)
    return weight

(2) - Indexación de esta matriz de ponderaciones

Esto ocurre en la callfunción de incrustación :

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

Esta función devuelve la salida de la Embeddingcapa que es K.gather(self.embeddings, inputs). Lo que tf.keras.backend.gather hace exactamente es indexar la matriz de ponderaciones self.embeddings(ver la buildfunción anterior) de acuerdo con las inputsque deberían ser listas de enteros positivos.

Estas listas se pueden recuperar, por ejemplo, si pasa sus entradas de texto / palabras a la función one_hot de Keras, que codifica un texto en una lista de índices de palabras de tamaño n (esta NO es una codificación activa; consulte también este ejemplo para obtener más información: https://machinelearningmastery.com/use-word-embedding-layers-deep-learning-keras/ ).

Por tanto, eso es todo. No hay multiplicación de matrices.

Por el contrario, la Keras Embeddingcapa solo es útil porque evita exactamente realizar una multiplicación de matrices y, por lo tanto, economiza algunos recursos computacionales.

De lo contrario, podría usar una capa Keras Densa (después de haber codificado sus datos de entrada) para obtener una matriz de pesos entrenables (de (vocabulary_size) x (embedding_dimension) dimensiones) y luego simplemente hacer la multiplicación para obtener el resultado que será exactamente lo mismo con la salida de la Embeddingcapa.

Para comprender mejor cualquier función, es un buen hábito mirar el código fuente. Aquí está la incrustación. Básicamente, es una tabla de consulta entrenable.

En Keras, la Embeddingcapa NO es una simple capa de multiplicación de matrices, sino una capa de tabla de búsqueda (consulte la función de llamada a continuación o la definición original ).

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

Lo que hace es mapear cada uno de los números enteros conocidos nen inputsun vector de características entrenables W[n], cuya dimensión es la denominada longitud de características incrustadas.

En palabras simples (desde el punto de vista de la funcionalidad), es un codificador one-hot y una capa completamente conectada . Los pesos de las capas se pueden entrenar.