Apa itu Embedding di Keras?

Dokumentasi Keras tidak jelas apa ini sebenarnya. Saya mengerti bahwa kita dapat menggunakan ini untuk memampatkan ruang fitur masukan menjadi yang lebih kecil. Tapi bagaimana ini dilakukan dari perspektif desain saraf? Apakah ini autoenocder, RBM?

Sejauh yang saya tahu, lapisan Embedding adalah perkalian matriks sederhana yang mengubah kata menjadi embeddings kata yang sesuai.

Bobot dari lapisan Embedding adalah bentuknya (vocabulary_size, embedding_dimension). Untuk setiap sampel pelatihan, masukannya adalah bilangan bulat, yang mewakili kata-kata tertentu. Bilangan bulat berada dalam kisaran ukuran kosakata. Layer Embedding mengubah setiap integer i menjadi baris ke-i dari matriks bobot embedding.

Untuk melakukan ini dengan cepat sebagai perkalian matriks, bilangan bulat masukan tidak disimpan sebagai daftar bilangan bulat tetapi sebagai matriks satu panas. Oleh karena itu, bentuk masukannya adalah (nb_words, vocabulary_size) dengan satu nilai bukan nol per baris. Jika Anda mengalikannya dengan bobot embedding, Anda akan mendapatkan output dalam bentuk

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

Jadi dengan perkalian matriks sederhana Anda mengubah semua kata dalam sampel menjadi embeddings kata yang sesuai.

The Keras Embeddinglapisan tidak melakukan setiap perkalian matriks tapi hanya:

1. membuat matriks bobot (vocabulary_size) x (embedding_dimension) dimensi

2. mengindeks matriks bobot ini

Itu selalu berguna untuk melihat kode sumber untuk memahami apa yang dilakukan kelas. Dalam hal ini, kita akan melihat class Embedding yang mewarisi dari lapisan dasar yang classdisebut Layer .

(1) - Membuat matriks bobot (vocabulary_size) x (embedding_dimension) dimensi:

Ini terjadi pada buildfungsi Embedding :

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

Jika Anda melihat Layer kelas dasar, Anda akan melihat bahwa fungsi di add_weightatas hanya membuat matriks bobot yang dapat dilatih (dalam hal ini dimensi (vocabulary_size) x (embedding_dimension) ):

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) - Mengindeks matriks bobot ini

Ini terjadi pada callfungsi Embedding :

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

Fungsi ini mengembalikan keluaran dari Embeddinglapisan K.gather(self.embeddings, inputs). Apa yang sebenarnya dilakukan oleh tf.keras.backend.gather adalah mengindeks matriks bobot self.embeddings(lihat buildfungsi di atas) sesuai dengan inputsyang seharusnya berupa daftar bilangan bulat positif.

Daftar ini dapat diambil misalnya jika Anda meneruskan input teks / kata Anda ke fungsi one_hot dari Keras yang mengkodekan teks ke dalam daftar indeks kata berukuran n (ini BUKAN satu encoding panas - lihat juga contoh ini untuk info lebih lanjut: https://machinelearningmastery.com/use-word-embedding-layers-deep-learning-keras/ ).

Oleh karena itu, itu saja. Tidak ada perkalian matriks.

Sebaliknya, yang Keras Embeddinglapisan hanya berguna karena persis menghindari melakukan perkalian matriks dan karena itu irit pada beberapa sumber daya komputasi.

Jika tidak, Anda bisa menggunakan lapisan Keras Dense (setelah Anda menyandikan data masukan Anda) untuk mendapatkan matriks bobot yang dapat dilatih (dari (vocabulary_size) dimensi x (embedding_dimension) ) dan kemudian cukup lakukan perkalian untuk mendapatkan keluaran yang akan tepat sama dengan output Embeddinglapisan.

Untuk lebih memahami fungsi apa pun, sebaiknya lihat kode sumbernya. Ini untuk Menyematkan Jadi pada dasarnya ini adalah tabel pencarian yang bisa dilatih.

Dalam Keras, yang Embeddinglapisan adalah TIDAK lapisan perkalian matriks sederhana, tetapi lapisan lihat tabel-up (lihat fungsi panggilan di bawah atau asli definisi ).

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

Apa yang dilakukannya adalah untuk memetakan setiap integer dikenal ndi inputssebuah vektor fitur dilatih W[n], yang dimensi adalah yang disebut tertanam panjang fitur.

Dengan kata sederhana (dari sudut pandang fungsionalitas), ini adalah encoder one-hot dan lapisan yang terhubung sepenuhnya . Bobot lapisan dapat dilatih.