Introducción a la autoatención y la escritura de códigos.

autoatención

---

Arquitectura de autoatención

La forma en que funciona la autoatención es ingresar una fila de vectores y generar una fila de vectores.

El vector de salida tiene en cuenta la información de todos los vectores de entrada.

• La atención propia se puede superponer muchas veces.
  
  Las capas totalmente conectadas (FC) y la atención propia se pueden usar indistintamente.

1. La autoatención procesa la información de toda la Secuencia
2. FC's Network, enfocándose en el manejo de consultas desde una determinada ubicación

El proceso de Auto-Atención

• Una de sus arquitecturas es así, la salida es una fila de $b$ es$a$ se calcula y se emite.

• $b^1$ se considera$a^1,a^2,a^3,a^{}$generado después de${}^{4\; .}$

• $b^2,b^3,b^4$ también considere$a^1,a^2,a^3,a^4$ , sus principios de cálculo son los mismos.

  Calcula la correlación de dos vectores de entrada

• Dos métodos de cálculo comunes: producto escalar y aditivo

• Entre ellos, en el primer método, primero deje que estos dos vectores se multipliquen por un W (estos dos w son diferentes, uno es peso_q, el otro es peso_k), y obtenga respectivamente q, kq, $q,k$ , y luego realiza el producto interno para obtener una puntuación$a_{yo,}$Indica el cálculo de $a_{}y{un}_{}$de relevancia

• Después $a^1$ minuto suma$a^2,a^3,a^4$ Calcula la similitud$a^1$ objetivo$q^1$ minuto suma$a^2,a^3,a^{}$k2, k3, k4 de 4 k^{2},k^{3},k${}^{^}$ {4}$k^2,k^3,k^4$ Haz el producto interior para llamar la atención scorce$a_{1,}$, $a_{1,}$, $a_{1,}$, a 1 a^{1} también se calculará en la operación real$a^1$ similitud contigo mismo.

• Futuro posterior $a_{1,},a_{1,}$, $a_{1,}$, $a_{1,}$, obtenga un 1 , 1 ′ a^{'}_{1,1} después de una capa soft-max$a_{1,1}^{{}^{}}$ $a_{1,2}^{{}^{}}$…
  

• Luego pon $a^1$ a$a^{}$Cada vector de${}^4$$W^v$ obtiene un nuevo vector, obtiene respectivamente$v^1,v^2,v^3,v^4$

• A continuación, $v^1$ a$v^4$ , cada vector se multiplica por la puntuación de Atención y luego se suma para obtener$b^1$
  $$b^1=\underset{i}{}{a}_{1,yo}^{{}^{}}{v}^i$$

• Teoría, $a^2,a^3,a^4$ también hacemos la misma operación para obtener$b^2,b^3,b^4$ .

ángulo de la matriz

Cada vector de entrada generará un conjunto de $q^{yo},k^{yo},v^i$

Por lo tanto, cada uno de nosotros $a^{salí}$ multiplicado por un$w^{matriz\; q}$ , puede obtener la matriz Q haciendo la multiplicación de matrices, y cada columna de la matriz Q es cada entrada$a^i$的$q^{yo}$ _

Del mismo modo cada grupo $k^{yo},v^i$ también se puede calcular con una matriz,

sabemos que cada atención$a_{yo,}$Representa qiq^{i} de la i-ésima entrada$q^{}$kjk^{j}${}^{de\; i}$ y la j-ésima entrada$k^j$ producto interno.

Luego, estos cuatro pasos se pueden obtener multiplicando la matriz y el vector.

Además, podemos calcular toda la atención y obtener$A^{{}^{\prime }}$

mientras$b^1$ es usando$v^i$ lado izquierdo$A^{{}^{conseguir}}$ ,

revisar

Figura (15)

• I es la entrada de autoatención, y la entrada de autoatención es una fila de vectores, que se juntan como columnas de la matriz.
• La entrada se multiplica por tres matrices $$w^q,w^k,w^v$$ obtiene Q, K, V.
• A continuación, Q se multiplica por la transposición de K para obtener la matriz A y, después del procesamiento softmax, $A^{{}^{\prime }}$ , y luego a la izquierda multiplicado por V para obtener Salida.
• Por lo tanto, el único parámetro a aprender en autoatención es la matriz W, que es la parte que requiere entrenar la red.

---

ejemplo de código

El ejemplo se divide en los siguientes pasos:

1. listo para entrar
2. Inicializar pesos
3. Exportar representación de clave, consulta y valor
4. Cálculo de puntuaciones de atención
5. Calcular softmax
6. Multiplique las puntuaciones de atención por el valor
7. Sume los valores ponderados para obtener la salida

Suponiendo entrada:

    Input 1: [1, 0, 1, 0]     
    Input 2: [0, 2, 0, 2]  
    Input 3: [1, 1, 1, 1]

Parámetros de inicialización

Dado que nuestra entrada son tres vectores de 4 dimensiones, la figura (15) debe multiplicarse por W desde la izquierda, y la dimensión de W se establece en (4,3),

$$w^k,w^q,w^v$$ son w_key, w_query, w_value respectivamente.

   x = [
    [1,0,1,0], # 输入1
    [0,2,0,2], #输入2
    [1,1,1,1], #输入3
    ]
    x = torch.tensor(x,dtype=torch.float32)
    # 初始化权重
    w_key = [
        [0, 0, 1],
        [1, 1, 0],
        [0, 1, 0],
        [1, 1, 0]
        ]
    w_query = [
        [1, 0, 1],
        [1, 0, 0],
        [0, 0, 1],
        [0, 1, 1]
        ]
    w_value = [
        [0, 2, 0],
        [0, 3, 0],
        [1, 0, 3],
        [1, 1, 0]
        ]
    # 转化成tensor数据类型
    w_key = torch.tensor(w_key,dtype=torch.float32)
    w_query = torch.tensor(w_query, dtype=torch.float32)
    w_value = torch.tensor(w_value, dtype=torch.float32)

Ver QKV

querys = torch.tensor(np.dot(x,w_query),dtype=torch.float32)

keys = torch.tensor(np.dot(x,w_key) ,dtype=torch.float32)

calcular la atención

# get attention scorce
attention_scores = torch.tensor(np.dot(querys,keys.T))

procesamiento softmax

# 计算soft-max
attention_scores_softmax = torch.tensor( softmax(attention_scores,dim=-1) )

Multiplique las puntuaciones de atención por el valor

weight_values = values[:,None] * attention_scores_softmax.T[:,:,None]

Sume los valores ponderados para obtener la salida

outputs = weight_values.sum(dim=0)

código de prueba

import torch
import numpy as np
from torch.nn.functional import softmax
def preData():
    #
    x = [
    [1,0,1,0], # 输入1
    [0,2,0,2], #输入2
    [1,1,1,1], #输入3
    ]
    x = torch.tensor(x,dtype=torch.float32)
    # 初始化权重
    w_key = [
        [0, 0, 1],
        [1, 1, 0],
        [0, 1, 0],
        [1, 1, 0]
        ]
    w_query = [
        [1, 0, 1],
        [1, 0, 0],
        [0, 0, 1],
        [0, 1, 1]
        ]
    w_value = [
        [0, 2, 0],
        [0, 3, 0],
        [1, 0, 3],
        [1, 1, 0]
        ]
    # 转化成tensor数据类型
    w_key = torch.tensor(w_key,dtype=torch.float32)
    w_query = torch.tensor(w_query, dtype=torch.float32)
    w_value = torch.tensor(w_value, dtype=torch.float32)

    # get K, Q,V

    keys = torch.tensor(np.dot(x,w_key) ,dtype=torch.float32)
    querys = torch.tensor(np.dot(x,w_query),dtype=torch.float32)
    values = torch.tensor(np.dot(x,w_value),dtype=torch.float32)

    # get attention scorce
    attention_scores = torch.tensor(np.dot(querys,keys.T))
    print(attention_scores)
    # 计算soft-max
    attention_scores_softmax = torch.tensor( softmax(attention_scores,dim=-1) )
    print(values.shape)
    weight_values = values[:,None] * attention_scores_softmax.T[:,:,None]
    outputs = weight_values.sum(dim=0)
    return outputs

if __name__ == "__main__" :
    b = preData()
    print(b)

referencia

• fuente de código