Transformer - Pratica

SDPA

Scaled Dot-Product Attention. Il modello con una sola attention head dalla lezione sul Transformer.

Come mostrato sopra, generare più set di Q, K, V è MHA; generarne uno solo è SDPA.

![](/assets/images/Transformer 실습/2caaf910-d820-4ce6-a286-b6497e5928e9-image.png)

1
class ScaledDotProductAttention(nn.Module):
2
    """
3
    Struttura con una singola attention head.
4
    Input: vettore n-dimensionale dal risultato dell'embedding.
5

6
    Trova query, key, value ed esegue il calcolo dell'attention
7
    come mostrato nella formula sopra.
8

9
    Output: tensor con dimensione uguale alla dimensione del vettore value
10
    per n word vector.
11
    """
12
    def forward(self, Q, K, V, mask=None):
13
        d_K = K.size()[-1] # dimensione del key
14
        scores = Q.matmul(K.transpose(-2, -1)) / np.sqrt(d_K)
15
        if mask is not None:
16
            scores = scores.masked_fill(mask==0, -1e9)
17
        attention = F.softmax(scores,dim=-1)
18
        out = attention.matmul(V)
19
        return out,attention
20

21
# Demo run di scaled dot product attention
22

23
SPDA = ScaledDotProductAttention()
24
"""
25
n_batch: ci sono n_batch parole
26
d_K: dimensione del vettore key
27
d_V: dimensione del vettore Value
28
n_Q: numero di vettori Query
29
n_K: numero di vettori Key
30
n_V: numero di vettori Value
31
"""
32
n_batch, d_K, d_V = 3, 128, 256 # d_K(=d_Q) non deve essere uguale a d_V
33
n_Q, n_K, n_V = 30,50,50
34
Q = torch.rand(n_batch,n_Q,d_K)
35
K = torch.rand(n_batch,n_K,d_K)
36
V = torch.rand(n_batch,n_V,d_V)
37
out,attention = SPDA.forward(Q,K,V,mask=None)
38
def sh(x): return str(x.shape)[11:-1]
39
print ("SDPA: Q%s K%s V%s => out%s attention%s"%
40
       (sh(Q),sh(K),sh(V),sh(out),sh(attention)))

Come mostrato nella formula, le dimensioni di query e key sono $\mathbb{R}^{n\times d_K}$ . Ovvero, query e key devono avere la stessa dimensione perché l’operazione funzioni.

La dimensione del value è $\mathbb{R}^{n\times d_V}$ , ma in pratica si implementa uguale a query e key per comodità. Possono essere uguali.

Numero di Q, K, V

Con encoder e decoder

Guardando il codice, i vettori SPDA vengono generati come:

n_Q $\neq$ ( n_K = n_V)

V e K vengono dall’encoder, mentre il decoder crea Q dal proprio input, quindi i conteggi possono differire.

Questo è il caso più generale dato che presuppone encoder-decoder.

Lo scopo di SPDA diventa chiaro qui! Si vogliono codificare i vettori Query facendo riferimento ai vettori key e value.

Quindi i vettori di output di SPDA devono avere lo stesso numero dei vettori Query.

Per la self-attention

n_Q = n_V = n_K

Devono essere tutti uguali.

K.transpose(-2, -1)

I tensor PyTorch supportano il transpose in questo modo. Scambia le due dimensioni date come argomenti. Qui scambia l’ultima e la penultima dimensione.

torch.nn.Softmax()

Non sapevo cosa significasse dim = -1, quindi ho controllato la documentazione:

dim (int) - A dimension along which Softmax will be computed (so every slice along dim will sum to 1).

https://stackoverflow.com/questions/49036993/pytorch-softmax-what-dimension-to-use

Calcola la softmax lungo la dimensione specificata.

![](/assets/images/Transformer 실습/4a19b3f9-5b06-497f-84dd-b90f8839e484-image.png)

La definizione di softmax è come sopra, dove $x_j$ di j viene specificato tramite l’opzione dim.

Perché il codice SDPA funziona anche per MHA

L’istruttore ha detto che è grazie al “batch the multiplication.” Non sono del tutto sicuro di cosa intendesse.

La mia interpretazione: dato che SDPA è implementata tramite operazioni matriciali, funziona indipendentemente da quante dimensioni abbiano Q, K, V — basta far corrispondere i conteggi delle dimensioni.

MHA (Multi-Head Attention)

1
class MultiHeadedAttention(nn.Module):
2
    def __init__(self,d_feat=128,n_head=5,actv=F.relu,USE_BIAS=True,dropout_p=0.1,device=None):
3
        """
4
        :param d_feat: dimensione delle feature
5
        :param n_head: numero di head
6
        :param actv: attivazione dopo ogni layer lineare
7
        :param USE_BIAS: se usare il bias
8
        :param dropout_p: tasso di dropout
9
        :device: quale device usare (es., cuda:0)
10
        """
11
        super(MultiHeadedAttention,self).__init__()
12
        if (d_feat%n_head) != 0:
13
            raise ValueError("d_feat(%d) should be divisible by b_head(%d)"%(d_feat,n_head))
14
        self.d_feat = d_feat
15
        self.n_head = n_head
16
        self.d_head = self.d_feat // self.n_head
17
        self.actv = actv
18
        self.USE_BIAS = USE_BIAS
19
        self.dropout_p = dropout_p # prob. di azzeramento
20

21
        self.lin_Q = nn.Linear(self.d_feat,self.d_feat,self.USE_BIAS)
22
        self.lin_K = nn.Linear(self.d_feat,self.d_feat,self.USE_BIAS)
23
        self.lin_V = nn.Linear(self.d_feat,self.d_feat,self.USE_BIAS)
24
        self.lin_O = nn.Linear(self.d_feat,self.d_feat,self.USE_BIAS)
25

26
        self.dropout = nn.Dropout(p=self.dropout_p)
27

28
    def forward(self,Q,K,V,mask=None):
29
        """
30
        :param Q: [n_batch, n_Q, d_feat]
31
        :param K: [n_batch, n_K, d_feat]
32
        :param V: [n_batch, n_V, d_feat] <= n_K e n_V devono essere uguali
33
        :param mask:
34
        """
35
        n_batch = Q.shape[0]
36
        Q_feat = self.lin_Q(Q)
37
        K_feat = self.lin_K(K)
38
        V_feat = self.lin_V(V)
39
        # Q_feat: [n_batch, n_Q, d_feat]
40
        # K_feat: [n_batch, n_K, d_feat]
41
        # V_feat: [n_batch, n_V, d_feat]
42

43
        # Split multi-head di Q, K e V (d_feat = n_head*d_head)
44
        """
45
        Si dividono Q, K, V. Per esempio, (100,) diventa (10,10).
46
        Qui d_feat viene diviso in n_head parti di dimensione d_head.
47
        """
48
        Q_split = Q_feat.view(n_batch, -1, self.n_head, self.d_head).permute(0, 2, 1, 3)
49
        K_split = K_feat.view(n_batch, -1, self.n_head, self.d_head).permute(0, 2, 1, 3)
50
        V_split = V_feat.view(n_batch, -1, self.n_head, self.d_head).permute(0, 2, 1, 3)
51
        # Q_split: [n_batch, n_head, n_Q, d_head]
52
        # K_split: [n_batch, n_head, n_K, d_head]
53
        # V_split: [n_batch, n_head, n_V, d_head]
54

55
        # Multi-Headed Attention
56
        d_K = K.size()[-1] # dimensione del key
57
        scores = torch.matmul(Q_split, K_split.permute(0, 1, 3, 2)) / np.sqrt(d_K)
58
        if mask is not None:
59
            scores = scores.masked_fill(mask==0,-1e9)
60
        attention = torch.softmax(scores,dim=-1)
61
        x_raw = torch.matmul(self.dropout(attention),V_split) # dropout NON menzionato nel paper
62
        # attention: [n_batch, n_head, n_Q, n_K]
63
        # x_raw: [n_batch, n_head, n_Q, d_head]
64

65
        # Reshape di x
66
        x_rsh1 = x_raw.permute(0,2,1,3).contiguous()
67
        # x_rsh1: [n_batch, n_Q, n_head, d_head]
68
        """
69
        Si unisce il tensor che era stato diviso in n_head parti di dimensione d_head.
70
        n_head * d_head = d_feat, quindi si usa d_feat direttamente.
71
        """
72
        x_rsh2 = x_rsh1.view(n_batch,-1,self.d_feat)
73
        # x_rsh2: [n_batch, n_Q, d_feat]
74

75
        # Lineare
76
        x = self.lin_O(x_rsh2)
77
        # x: [n_batch, n_Q, d_feat]
78
        out = {'Q_feat':Q_feat,'K_feat':K_feat,'V_feat':V_feat,
79
               'Q_split':Q_split,'K_split':K_split,'V_split':V_split,
80
               'scores':scores,'attention':attention,
81
               'x_raw':x_raw,'x_rsh1':x_rsh1,'x_rsh2':x_rsh2,'x':x}
82
        return out
83

84
# Layer Self-Attention
85
"""
86
n_batch: prendi 128 parole per batch dai dati di training.
87
n_src: entrano n_src parole = elabora n_src elementi della sequenza contemporaneamente.
88
d_feat: dimensione delle feature
89
n_head: quante head per la multi-head attention
90
"""
91
n_batch = 128
92
n_src   = 32
93
d_feat  = 200
94
n_head  = 5
95
src = torch.rand(n_batch,n_src,d_feat)
96
self_attention = MultiHeadedAttention(
97
    d_feat=d_feat,n_head=n_head,actv=F.relu,USE_BIAS=True,dropout_p=0.1,device=device)
98

99
# Essendo self attention, Q, K, V hanno tutti la stessa dimensione
100
out = self_attention.forward(src,src,src,mask=None)
101

102
Q_feat,K_feat,V_feat = out['Q_feat'],out['K_feat'],out['V_feat']
103
Q_split,K_split,V_split = out['Q_split'],out['K_split'],out['V_split']
104
scores,attention = out['scores'],out['attention']
105
x_raw,x_rsh1,x_rsh2,x = out['x_raw'],out['x_rsh1'],out['x_rsh2'],out['x']

$head_{\color{red}i} = \text{Attention}(Q {\color{green}W}^Q_{\color{red}i},K {\color{green}W}^K_{\color{red}i}, V {\color{green}W}^V_{\color{red}i})$

Il paper non include dropout. Ma in pratica, il dropout viene usato in tutti i layer di attention, quindi è incluso qui.
L’MHA originale crea k header separati e aggrega i risultati dopo.
- L’implementazione reale divide in k parti all’inizio ed esegue lo Scaled Dot-Product.
- Quindi d_feat deve essere divisibile per n_head.

torch.Tensor.permute

Stessa funzionalità di transpose. La differenza è che transpose scambia solo due dimensioni, mentre permute funziona su tutte le dimensioni.

Conclusioni

Può essere leggermente confuso, quindi riassumendo:

n_Q $\neq$ ( n_K = n_V)
d_Q = d_K

Perché vale #1:

Key e Value vengono dall’encoder.
La Query è l’input ricevuto dal decoder.

Perché vale #2:

Query e Key devono essere moltiplicati internamente per l’attention, quindi servono la stessa dimensione.
La dimensione del Value può differire da entrambe.