Nhúng trong Keras là gì?

Tài liệu của Keras không rõ đây thực sự là gì. Tôi hiểu rằng chúng ta có thể sử dụng điều này để nén không gian tính năng đầu vào thành một vùng nhỏ hơn. Nhưng điều này được thực hiện như thế nào từ quan điểm thiết kế thần kinh? Nó có phải là một mã tự động không, RBM?

Theo như tôi biết, lớp Nhúng là một phép nhân ma trận đơn giản để chuyển các từ thành các nhúng từ tương ứng của chúng.

Trọng lượng của lớp Nhúng có hình dạng (kích thước từ vựng, kích thước nhúng). Đối với mỗi mẫu đào tạo, đầu vào của nó là các số nguyên, đại diện cho các từ nhất định. Các số nguyên nằm trong phạm vi kích thước từ vựng. Lớp Nhúng biến đổi mỗi số nguyên i thành dòng thứ i của ma trận trọng số nhúng.

Để nhanh chóng thực hiện điều này dưới dạng phép nhân ma trận, các số nguyên đầu vào không được lưu trữ dưới dạng danh sách các số nguyên mà ở dạng ma trận một nóng. Do đó, hình dạng đầu vào là (nb_words, từ vựng_size) với một giá trị khác 0 trên mỗi dòng. Nếu bạn nhân giá trị này với trọng số nhúng, bạn sẽ có kết quả ở dạng

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

Vì vậy, với một phép nhân ma trận đơn giản, bạn chuyển đổi tất cả các từ trong một mẫu thành các từ nhúng tương ứng.

Các Keras Embeddinglớp không thực hiện bất kỳ phép nhân ma trận nhưng chỉ có nó:

1. tạo một ma trận trọng số của ( kích thước từ vựng) x ( kích thước_hấp_phí)

2. lập chỉ mục cho ma trận trọng số này

Luôn hữu ích khi xem mã nguồn để hiểu những gì một lớp làm. Trong trường hợp này, chúng ta sẽ xem xét phần class Nhúng kế thừa từ lớp cơ sở classđược gọi là Lớp .

(1) - Tạo ma trận trọng số của các thứ nguyên (từ vựng_size) x (embedding_dimension) :

Điều này đang xảy ra ở buildchức năng Nhúng :

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

Nếu bạn nhìn vào Layer lớp cơ sở, bạn sẽ thấy rằng hàm add_weighttrên chỉ đơn giản tạo ra một ma trận các trọng số có thể đào tạo (trong trường hợp này là (từ vựng_ kích thước) x (nhúng_dimension) kích thước):

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) - Lập chỉ mục ma trận trọng số này

Điều này đang xảy ra ở callchức năng Nhúng :

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

Hàm này trả về kết quả đầu ra của Embeddinglớp K.gather(self.embeddings, inputs). Những gì tf.keras.backend.gather làm chính xác là lập chỉ mục ma trận trọng số self.embeddings(xem buildhàm ở trên) theo inputsđó sẽ là danh sách các số nguyên dương.

Các danh sách này có thể được truy xuất, ví dụ: nếu bạn chuyển đầu vào văn bản / từ của mình vào hàm one_hot của Keras mã hóa văn bản thành danh sách chỉ mục từ có kích thước n (đây KHÔNG phải là một mã hóa nóng - hãy xem thêm ví dụ này để biết thêm thông tin: https://machinelearningmastery.com/use-word-embedding-layers-deep-learning-keras/ ).

Do đó, chỉ có vậy thôi. Không có phép nhân ma trận.

Ngược lại, các Keras Embeddinglớp chỉ hữu ích bởi vì chính xác nó tránh thực hiện một phép nhân ma trận và do đó nó economizes trên một số tài nguyên tính toán.

Nếu không, bạn chỉ có thể sử dụng lớp Keras Dense (sau khi bạn đã mã hóa dữ liệu đầu vào của mình) để nhận ma trận các trọng số có thể huấn luyện (của (từ vựng_size) x (embedding_dimension) ) và sau đó chỉ cần thực hiện phép nhân để nhận được kết quả chính xác tương tự với đầu ra của Embeddinglớp.

Để hiểu rõ hơn về bất kỳ chức năng nào, bạn nên xem mã nguồn. Đây là để nhúng Vì vậy, về cơ bản nó là một bảng tra cứu có thể đào tạo.

Trong Keras, Embeddinglớp là KHÔNG phải là lớp nhân ma trận đơn giản mà là lớp bảng tra cứu (xem hàm gọi bên dưới hoặc định nghĩa ban đầu ).

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

Những gì nó làm là ánh xạ từng số nguyên đã biết nvào inputsmột vectơ đặc trưng có thể đào tạoW[n] , có kích thước là chiều dài đối tượng được nhúng.

Nói cách đơn giản (từ quan điểm chức năng), nó là một bộ mã hóa một nóng và lớp kết nối đầy đủ . Trọng lượng lớp có thể đào tạo.