Cálculo de matrices de pesos en el codificador basado en la atención de Deep Learning NLP

Question

En la página 4 de este trabajo de investigación titulado A Neural Attention Model for Sentence Summarization se menciona el codificador basado en la atención se determina mediante la siguiente fórmula :

donde las dimensiones de las matrices de pesos son las siguientes : P es H×(CD) , F es H × V , G es D × V . También se menciona en la línea 2 de las ecuaciones anteriores que la variable p es proporcional a exp(x × P × y) que parece indicar la aplicación del exponente natural y la multiplicación de las 3 matrices. Dicho esto, tengo 2 preguntas principales.

1.¿Cómo puede el x y P en la ecuación de exp(x × P × y) realizan la multiplicación matricial entre sí, ya que x tiene la dimensión de 1 × (HM) y P tiene la dimensión de H × (CD) ? La columna de x no coincide con la fila P ¿no significa eso que la multiplicación de matrices no es posible? ¿O es que las operaciones de x y P ¿no se refiere a la de una multiplicación de matrices?

2.He intentado comprobar el código fuente aquí y no pude encontrar la variable que se refiere a P variable de peso que figura en el artículo. Los siguientes son el fragmento del código del codificador basado en la atención :

function encoder.build_attnbow_model(opt, data)
   print("Encoder model: BoW + Attention")

   local D2 = opt.bowDim
   local N = opt.window
   local V = #data.title_data.dict.index_to_symbol
   local V2 = #data.article_data.dict.index_to_symbol

   -- Article Embedding.
   local article_lookup = nn.LookupTable(V2, D2)()

   -- Title Embedding.
   local title_lookup = nn.LookupTable(V, D2)()

   -- Size Lookup
   local size_lookup = nn.Identity()()

   -- Ignore size lookup to make NNGraph happy.
   local article_context = nn.SelectTable(1)({article_lookup, size_lookup})

   -- Pool article
   local pad = (opt.attenPool - 1) / 2
   local article_match = article_context

   -- Title context embedding.
   local title_context = nn.View(D2, 1)(
      nn.Linear(N * D2, D2)(nn.View(N * D2)(title_lookup)))

   -- Attention layer. Distribution over article.
   local dot_article_context = nn.MM()({article_match,
                                        title_context})

   -- Compute the attention distribution.
   local non_linearity = nn.SoftMax()
   local attention = non_linearity(nn.Sum(3)(dot_article_context))

   local process_article =
      nn.Sum(2)(nn.SpatialSubSampling(1, 1, opt.attenPool)(
                   nn.SpatialZeroPadding(0, 0, pad, pad)(
                      nn.View(1, -1, D2):setNumInputDims(2)(article_context))))

   -- Apply attention to the subsampled article.
   local mout = nn.Linear(D2, D2)(
      nn.Sum(3)(nn.MM(true, false)(
                   {process_article,
                    nn.View(-1, 1):setNumInputDims(1)(attention)})))

   -- Apply attention
   local encoder_mlp = nn.gModule({article_lookup, size_lookup, title_lookup},
      {mout})

   encoder_mlp:cuda()
   encoder_mlp.lookup = article_lookup.data.module
   encoder_mlp.title_lookup = title_lookup.data.module
   return encoder_mlp
end

Basándome en el fragmento anterior, creo que la función :

 local dot_article_context = nn.MM()({article_match,
                                        title_context})

calcular el resultado de p mediante la introducción de x donde x es article match y yc para title_context y no hay participación de P matriz de pesos en absoluto. Creo que no he entendido bien el concepto de cómputo del codificador basado en la atención, y si es así, ¿podría alguien aclararme qué parte del código realiza realmente el cómputo de la matriz de pesos? p ?

Gracias de antemano.

Answer 1

1.Si he entendido bien, x puede formarse como un M×H matriz, P es H×(CD) , y es (CD)×1 entonces exp(x×P×y) daría un M×1 que se utiliza como probabilidad no normalizada para cada palabra.

2.Parece dot_article_context es el resultado de x×P×y y attention (que se obtiene aplicando softmax a dot_article_context ) es la probabilidad p . Mi suposición es que el código utiliza el mismo valor opt.bowDim para D y H y el P matriz de pesos se codifica aquí:

-- Title context embedding.
local title_context = nn.View(D2, 1)(
   nn.Linear(N * D2, D2)(nn.View(N * D2)(title_lookup)))

en la capa lineal nn.Linear(N * D2, D2) donc title_context debe ser el resultado de P×y . En este caso, el cálculo P×y primero en lugar de x×P es más eficiente ya que x×P dará una matriz más grande.