From b22210b3eb0940c9cb5f9f29af6ede69204d78cf Mon Sep 17 00:00:00 2001 From: =?utf8?q?Fran=C3=A7ois=20Fleuret?= Date: Sat, 6 Jan 2024 12:16:36 +0100 Subject: [PATCH] Update. --- mygpt.py | 41 ++++++++++++++++++++++++++++++++++++----- 1 file changed, 36 insertions(+), 5 deletions(-) diff --git a/mygpt.py b/mygpt.py index 87071c3..daaec01 100755 --- a/mygpt.py +++ b/mygpt.py @@ -519,14 +519,23 @@ class Caterpillar(nn.Module): if bs.init_cache: self.rec_V = X.new_zeros(N, CH, T, DV) - self.rec_V[:, :, t0 - CL : t0] = self.init_V_rec[None, :, :, :] self.rec_K = X.new_zeros(N, CH, T, DK) + # We start the recurrent sequences with optimizable + # initial values. No idea if it helps. + self.rec_V[:, :, t0 - CL : t0] = self.init_V_rec[None, :, :, :] self.rec_K[:, :, t0 - CL : t0] = self.init_K_rec[None, :, :, :] + self.cache_Y = X.new_zeros(N, T, Dout) ###################################################################### # Compute the recurrent state + # This is the Gating sequence that modulates if they key and + # values should be stored in one of the CH pairs of the + # current stack. The CH gating values are independent, which + # means that the same thing could be stored multiple times or + # not at all + G = ( torch.einsum("ntc,hec->nhet", X, self.w_G) + self.b_G[None, :, :, None] ).sigmoid() @@ -534,6 +543,8 @@ class Caterpillar(nn.Module): V = torch.einsum("ntc,hdc->nhtd", X, self.w_V) K = torch.einsum("ntc,hdc->nhtd", X, self.w_K) + # We prepare the arguments for the parallel scan + A = 1 - G.sum(1) gated_V = torch.einsum("nhet,nhtd->netd", G, V) gated_K = torch.einsum("nhet,nhtd->netd", G, K) @@ -541,6 +552,11 @@ class Caterpillar(nn.Module): init_rec_V = self.rec_V[:, :, t0 - CL : t0] init_rec_K = self.rec_K[:, :, t0 - CL : t0] + # Here there is a trick: The parallel scan operates with a + # period of L, so we split the sequence indexing in two axes, + # the second of size CL, and run the parallel scan using the + # other alone as the sequence index. + A = A.unflatten(2, (-1, CL)) gated_V = gated_V.unflatten(2, (-1, CL)) gated_K = gated_K.unflatten(2, (-1, CL)) @@ -548,6 +564,8 @@ class Caterpillar(nn.Module): next_V = pscan_dim(A, gated_V, init_rec_V, dim=2) next_K = pscan_dim(A, gated_K, init_rec_K, dim=2) + # Put back the sequence index + self.rec_V[:, :, t0:t1] = next_V.flatten(2, 3) self.rec_K[:, :, t0:t1] = next_K.flatten(2, 3) @@ -556,30 +574,43 @@ class Caterpillar(nn.Module): Q = torch.einsum("ntc,hdc->nhtd", X, self.w_Q) - uv = moving_window( + # We build tensors NxHxTxFxL where N is the sample index, H + # the head, T the time, F the row in the caterpillar, and L + # the column in the caterpillar + + windowed_V = moving_window( self.rec_V[:, :, t0 - CL + 1 : t1], dim=2, win_dim=3, win_size=CL ) - uk = moving_window( + windowed_K = moving_window( self.rec_K[:, :, t0 - CL + 1 : t1], dim=2, win_dim=3, win_size=CL ) + # We have an attention score for each of the CHxCL value + ar = torch.einsum( "nhtd,nftld->nhtfl", Q, - uk, + windowed_K, ) / math.sqrt(DK) + # softmax can operate only on one dimension, hence the + # flattening + ar = ar.flatten(3).softmax(dim=3).view(ar.size()) ar = F.dropout(ar, self.attention_dropout, self.training) + # Compute the output for each head, flatten to concatenate + Y = torch.einsum( "nhtfl,nftld->nthd", ar, - uv, + windowed_V, ).flatten(2) + # Compute the final output + self.cache_Y[:, t0:t1] = Y @ self.w_O return BracketedSequence(self.cache_Y, t0, t1 - t0, bs.init_cache) -- 2.39.5