Di banyak perpustakaan jaringan saraf, ada 'lapisan embedding', seperti di Keras atau Lasagne .

Saya tidak yakin saya mengerti fungsinya, meskipun membaca dokumentasi. Misalnya, dalam dokumentasi Keras tertulis:

Ubah bilangan bulat positif (indeks) menjadi vektor padat ukuran tetap, misalnya. [[4], [20]] -> [[0,25, 0,1], [0,6, -0,2]]

Bisakah orang yang berpengetahuan luas menjelaskan apa fungsinya, dan kapan Anda akan menggunakannya?

EDIT: Mengenai menempelkan di dokumentasi, tidak ada banyak untuk menyisipkan dari dokumentasi, maka pertanyaan saya. Saya tidak mengerti transformasi yang dilakukannya, atau mengapa harus digunakan.

Bagaimanapun, ini adalah bagaimana hal itu dijelaskan dalam Keras:

Menanamkan

keras.layers.embeddings.Embedding (input_dim, output_dim, init = 'seragam', input_length = Tidak ada, bobot = Tidak ada, W_regularizer = Tidak Ada, W_regstraint = Tidak Ada, mask_zero = Salah) Ubah bilangan bulat positif (indeks) menjadi vektor padat dengan ukuran tetap misalnya. [[4], [20]] -> [[0,25, 0,1], [0,6, -0,2]]

Bentuk input: tensor 2D dengan bentuk: (nb_samples, sequence_length). Bentuk keluaran: tensor 3D dengan bentuk: (nb_samples, sequence_length, output_dim). Argumen:

input_dim: int> = 0. Ukuran kosakata, yaitu. 1 + indeks integer maksimum yang terjadi pada data input. output_dim: int> = 0. Dimensi embedding padat

Dan inilah bagaimana hal itu dijelaskan dalam Lasagne:

Lapisan untuk embeddings kata. Input harus berupa variabel Tensor tipe integer.

Parameter: masuk: turunan Layer atau tupel

Lapisan memberi makan ke lapisan ini, atau bentuk input yang diharapkan.

input_size: int

Jumlah pernikahan yang berbeda. Embedding terakhir akan memiliki indeks input_size - 1.

output_size: int

Ukuran masing-masing embedding.

W: Theano membagikan variabel, ekspresi, array numpy, atau callable

Nilai awal, ekspresi, atau initializer untuk embedding matrix. Ini harus berupa matriks dengan bentuk (input_size, output_size). Lihat lasagne.utils.create_param () untuk informasi lebih lanjut.

Contohnya

>>> from lasagne.layers import EmbeddingLayer, InputLayer, get_output
>>> import theano
>>> x = T.imatrix()
>>> l_in = InputLayer((3, ))
>>> W = np.arange(3*5).reshape((3, 5)).astype('float32')
>>> l1 = EmbeddingLayer(l_in, input_size=3, output_size=5, W=W)
>>> output = get_output(l1, x)
>>> f = theano.function([x], output)
>>> x_test = np.array([[0, 2], [1, 2]]).astype('int32')
>>> f(x_test) array([[[  0.,   1.,   2.,   3.,   4.],
                      [ 10.,  11.,  12.,  13.,  14.]],
                     [[  5.,   6.,   7.,   8.,   9.],
                      [ 10.,  11.,  12.,  13.,  14.]]], dtype=float32)

Hubungan dengan Word2Vec

==========================================

Word2Vec dalam gambar sederhana:

Penjelasan lebih mendalam:

Saya percaya ini terkait dengan inovasi Word2Vec baru-baru ini dalam pemrosesan bahasa alami. Secara kasar, Word2Vec berarti perbendaharaan kata kita terpisah dan kita akan mempelajari peta yang akan menyematkan setiap kata ke dalam ruang vektor berkelanjutan. Menggunakan representasi ruang vektor ini akan memungkinkan kita untuk memiliki representasi kata-kata kosa kata kita yang terdistribusi secara terus-menerus. Jika misalnya dataset kami terdiri dari n-gram, sekarang kami dapat menggunakan fitur kata kontinu untuk membuat representasi terdistribusi dari n-gram kami. Dalam proses pelatihan model bahasa kita akan belajar kata ini menanamkan peta. Harapannya adalah bahwa dengan menggunakan representasi berkelanjutan, embedding kami akan memetakan kata-kata yang mirip dengan daerah yang sama. Sebagai contoh dalam makalah tengara Terdistribusi Representasi Kata dan Frasa dan Komposisionalitasnya, amati dalam Tabel 6 dan 7 bahwa frasa tertentu memiliki frasa tetangga terdekat yang sangat baik dari sudut pandang semantik. Mengubah ke dalam ruang kontinu ini memungkinkan kita untuk menggunakan gagasan metrik persamaan berkesinambungan untuk mengevaluasi kualitas semantik dari embedding kita.

Penjelasan menggunakan kode Lasagne

Mari kita uraikan cuplikan kode Lasagna:

x = T.imatrix()

x adalah matriks bilangan bulat. Oke tidak masalah. Setiap kata dalam kosakata dapat diwakili bilangan bulat, atau enkode 1-hot sparse. Jadi, jika x adalah 2x2, kami memiliki dua titik data, masing-masing menjadi 2 gram.

l_in = InputLayer((3, ))

Lapisan input. Angka 3 mewakili ukuran kosa kata kami. Jadi kita punya kata-kata misalnya.$w_0, w_1, w_2$

W = np.arange(3*5).reshape((3, 5)).astype('float32')

Ini adalah matriks embedding kata kami. Ini adalah 3 baris dengan 5 kolom matriks dengan entri 0 hingga 14.

Hingga saat ini kami memiliki interpretasi berikut. Kosakata kami memiliki 3 kata dan kami akan menanamkan kata-kata kami ke dalam ruang vektor 5 dimensi. Sebagai contoh, kami dapat mewakili satu kata , dan kata lain dan kata lain , misalnya sebagai penyandian jarang panas. Kita dapat melihat matriks sebagai embedding kata-kata ini melalui perkalian matriks. Karenanya kata pertamaDemikian pula . $w_0 = (1,0,0)$$w_1 = (0, 1, 0)$$w_2 = (0, 0, 1)$$W$$w_0 \rightarrow w_0W = [0, 1, 2, 3, 4].$$w_1 \rightarrow w_1W = [5, 6, 7, 8, 9]$

Perlu dicatat, karena pengkodean jarang satu-panas yang kami gunakan, Anda juga melihat ini disebut sebagai pencarian tabel.

l1 = EmbeddingLayer(l_in, input_size=3, output_size=5, W=W)

Lapisan embedding

 output = get_output(l1, x)

Ekspresi simbolis Theano untuk embedding.

f = theano.function([x], output)

Fungsi theano yang menghitung embedding.

x_test = np.array([[0, 2], [1, 2]]).astype('int32')

Layak berhenti sejenak di sini untuk membahas apa sebenarnya arti x_test. Pemberitahuan pertama bahwa semua entri x_test ada di {0, 1, 2}, yaitu rentang (3). x_test memiliki 2 titik data. Datapoint pertama [0, 2] mewakili 2-gram dan datapoint kedua mewakili 2-gram .( w 1 , w 2$(w_0, w_2)$$(w_1, w_2)$

Kami ingin menyematkan 2-gram kami menggunakan layer embedding kata kami sekarang. Sebelum kita melakukan itu, mari kita pastikan kita sudah jelas tentang apa yang harus dikembalikan oleh fungsi embedding kita f. 2 gram setara dengan matriks [[1, 0, 0], [0, 0, 1]]. Menerapkan matriks penyematan W kami ke matriks jarang ini harus menghasilkan: [[0, 1, 2, 3, 4], [10, 11, 12, 13, 14]]. Catatan untuk mendapatkan perkalian matriks, kita harus menerapkan kata embedding matriks melalui perkalian kanan ke representasi matriks jarang 2-gram kami.$(w_0, w_2)$$W$

f(x_test) 

pengembalian:

          array([[[  0.,   1.,   2.,   3.,   4.],
                  [ 10.,  11.,  12.,  13.,  14.]],
                 [[  5.,   6.,   7.,   8.,   9.],
                  [ 10.,  11.,  12.,  13.,  14.]]], dtype=float32)

Untuk meyakinkan Anda bahwa 3 memang mewakili ukuran kosakata, coba masukkan matriks x_test = [[5, 0], [1, 2]]. Anda akan melihat bahwa ia memunculkan kesalahan mis-match matriks.

Dalam https://stackoverflow.com/questions/45649520/explain-with-example-how-embedding-layers-in-keras-works/ Saya mencoba menyiapkan contoh menggunakan 2 kalimat, keras's text_to_ berikutnyaences

'This is a text' --> [0 0 1 2 3 4]

dan lapisan embedding. Berdasarkan Bagaimana cara lapisan Keras 'Embedding' bekerja? layer embedding pertama-tama menginisialisasi vektor embedding secara acak dan kemudian menggunakan pengoptimal jaringan untuk memperbaruinya seperti yang akan dilakukan pada lapisan jaringan lain dengan keras.

[0 0 1 2 3 4] --> 
[-0.01494285, -0.007915  ,  0.01764857],
[-0.01494285, -0.007915  ,  0.01764857],
[-0.03019481, -0.02910612,  0.03518577],
[-0.0046863 ,  0.04763055, -0.02629668],
[ 0.02297204,  0.02146662,  0.03114786],
[ 0.01634104,  0.02296363, -0.02348827]

Di atas akan ada beberapa vektor embing awal untuk kalimat (maksimum) 6 kata dan output_dim dari 3.