Trong nhiều thư viện mạng thần kinh, có 'các lớp nhúng', như trong Keras hoặc Lasagne .

Tôi không chắc chắn tôi hiểu chức năng của nó, mặc dù đọc tài liệu. Ví dụ, trong tài liệu Keras có ghi:

Biến các số nguyên dương (chỉ mục) thành các vectơ mật độ có kích thước cố định, ví dụ. [[4], [20]] -> [[0,25, 0,1], [0,6, -0,2]]

Một người có kiến ​​thức có thể giải thích những gì nó làm, và khi nào bạn sẽ sử dụng nó?

EDIT: Liên quan đến dán trong tài liệu, không có nhiều để dán từ tài liệu, do đó câu hỏi của tôi. Tôi không hiểu sự biến đổi của nó, cũng như tại sao nó nên được sử dụng.

Dù sao, đây là cách nó được giải thích trong Keras:

Nhúng

keras.layers.embeddings.Embpping (input_dim, output_dim, init = 'thống nhất', input_length = Không, weights = Không, W_THERizer = Không, W_constraint = Không, mask_zero = Sai) Biến các số nguyên dương (chỉ mục) , ví dụ. [[4], [20]] -> [[0,25, 0,1], [0,6, -0,2]]

Hình dạng đầu vào: 2D tenor có hình dạng: (nb_samples, Sequ_length). Hình dạng đầu ra: Tenor 3D có hình dạng: (nb_samples, Sequ_length, output_dim). Tranh luận:

input_dim: int> = 0. Kích thước của từ vựng, nghĩa là. 1 + chỉ số nguyên tối đa xảy ra trong dữ liệu đầu vào. output_dim: int> = 0. Kích thước của nhúng dày đặc

Và đây là cách nó được giải thích ở Lasagne:

Một lớp cho các từ nhúng. Đầu vào phải là một biến số kiểu số nguyên.

Tham số: đến: một thể hiện lớp hoặc một tuple

Lớp cho ăn vào lớp này, hoặc hình dạng đầu vào dự kiến.

input_size: int

Số lượng nhúng khác nhau. Lần nhúng cuối cùng sẽ có chỉ số input_size - 1.

đầu ra_size: int

Kích thước của mỗi lần nhúng.

W: Theano chia sẻ biến, biểu thức, mảng numpy hoặc có thể gọi được

Giá trị ban đầu, biểu thức hoặc bộ khởi tạo cho ma trận nhúng. Đây phải là một ma trận có hình dạng (input_size, output_size). Xem lasagne.utils.create_param () để biết thêm thông tin.

Ví dụ

>>> 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)

Liên quan đến Word2Vec

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

Word2Vec trong một bức tranh đơn giản:

Giải thích sâu hơn:

Tôi tin rằng nó liên quan đến sự đổi mới của Word2Vec gần đây trong xử lý ngôn ngữ tự nhiên. Roughly, Word2Vec có nghĩa là vốn từ vựng của chúng tôi rời rạc và chúng tôi sẽ tìm hiểu một bản đồ sẽ nhúng từng từ vào một không gian vectơ liên tục. Sử dụng biểu diễn không gian vectơ này sẽ cho phép chúng ta có một biểu diễn liên tục, phân tán các từ vựng của chúng ta. Ví dụ: nếu tập dữ liệu của chúng tôi bao gồm n-gram, thì bây giờ chúng tôi có thể sử dụng các tính năng từ liên tục của chúng tôi để tạo ra một đại diện phân tán của n-gram. Trong quá trình đào tạo một mô hình ngôn ngữ, chúng ta sẽ tìm hiểu bản đồ nhúng từ này. Hy vọng là bằng cách sử dụng một đại diện liên tục, việc nhúng của chúng tôi sẽ ánh xạ các từ tương tự đến các khu vực tương tự. Ví dụ: trong bài viết mang tính bước ngoặt Đại diện phân phối của từ và cụm từ và thành phần của chúng, quan sát trong Bảng 6 và 7 rằng các cụm từ nhất định có các cụm từ lân cận gần nhất rất tốt theo quan điểm ngữ nghĩa. Chuyển đổi vào không gian liên tục này cho phép chúng tôi sử dụng các khái niệm số liệu tương tự liên tục để đánh giá chất lượng ngữ nghĩa của việc nhúng.

Giải thích sử dụng mã Lasagne

Hãy chia nhỏ đoạn mã Lasagne:

x = T.imatrix()

x là ma trận các số nguyên. Ổn không có vấn đề. Mỗi từ trong từ vựng có thể được biểu diễn bằng một số nguyên hoặc mã hóa thưa thớt 1 nóng. Vì vậy, nếu x là 2x2, chúng ta có hai điểm dữ liệu, mỗi điểm là 2 gram.

l_in = InputLayer((3, ))

Lớp đầu vào. 3 đại diện cho kích thước của từ vựng của chúng tôi. Vì vậy, chúng tôi có các từ chẳng hạn.$w_0, w_1, w_2$

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

Đây là ma trận nhúng từ của chúng tôi. Đó là một ma trận 3 hàng 5 cột với các mục từ 0 đến 14.

Cho đến bây giờ chúng tôi có giải thích sau đây. Từ vựng của chúng tôi có 3 từ và chúng tôi sẽ nhúng các từ của chúng tôi vào không gian vectơ 5 chiều. Ví dụ: chúng tôi có thể đại diện cho một từ và một từ khác và từ khác , ví dụ như mã hóa thưa thớt nóng. Chúng ta có thể xem ma trận khi nhúng các từ này thông qua phép nhân ma trận. Do đó, từ đầu tiênTương tự . $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]$

Cần lưu ý, do mã hóa thưa thớt một nóng mà chúng tôi đang sử dụng, bạn cũng thấy điều này được gọi là tra cứu bảng.

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

Lớp nhúng

 output = get_output(l1, x)

Biểu tượng Theano tượng trưng cho nhúng.

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

Hàm Theano tính toán nhúng.

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

Thật đáng để dừng lại ở đây để thảo luận về chính xác x_test có nghĩa là gì. Đầu tiên lưu ý rằng tất cả các mục x_test nằm trong {0, 1, 2}, tức là phạm vi (3). x_test có 2 datapoint. Điểm dữ liệu đầu tiên [0, 2] đại diện cho 2 gram và điểm dữ liệu thứ hai đại diện cho 2 gram .$(w_0, w_2)$$(w_1, w_2)$

Chúng tôi muốn nhúng 2 gram của chúng tôi bằng cách sử dụng lớp nhúng từ của chúng tôi bây giờ. Trước khi chúng tôi làm điều đó, hãy chắc chắn rằng chúng tôi rõ ràng về những gì sẽ được trả về bởi chức năng nhúng của chúng tôi f. 2 gram tương đương với ma trận [[1, 0, 0], [0, 0, 1]]. Áp dụng ma trận nhúng W của chúng tôi cho ma trận thưa thớt này sẽ mang lại: [[0, 1, 2, 3, 4], [10, 11, 12, 13, 14]]. Lưu ý để có phép nhân ma trận, chúng ta phải áp dụng ma trận nhúng từ thông qua phép nhân phải cho biểu diễn ma trận thưa thớt của 2 gram.$(w_0, w_2)$$W$

f(x_test) 

trả về:

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

Để thuyết phục bạn rằng 3 thực sự đại diện cho kích thước từ vựng, hãy thử nhập một ma trận x_test = [[5, 0], [1, 2]]. Bạn sẽ thấy rằng nó gây ra lỗi khớp ma trận.

Trong https://stackoverflow.com/questions/45649520/explain-with-example-how-embpping-layers-in-keras-works/ Tôi đã cố gắng chuẩn bị một ví dụ bằng cách sử dụng 2 câu, các văn bản của keras_to_fterences

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

và nhúng lớp. Dựa trên lớp Keras 'Nhúng' hoạt động như thế nào? lớp nhúng trước tiên khởi tạo vector nhúng một cách ngẫu nhiên và sau đó sử dụng trình tối ưu hóa mạng để cập nhật nó tương tự như nó sẽ làm với bất kỳ lớp mạng nào khác trong máy ảnh.

[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]

Trên đây sẽ là một số vectơ nhúng ban đầu cho một câu (tối đa) 6 từ và output_dim là 3.