X-Git-Url: https://fleuret.org/cgi-bin/gitweb/gitweb.cgi?a=blobdiff_plain;f=mygpt.py;h=d1acf22b1a6359cf2ffc31fe2d0885306674d6e4;hb=ca56d3dfa53f3486da1d651f31f1e34ea0dc4652;hp=87071c36107bcc0f847293753f7e1eb8390d5e93;hpb=d22053eb84b067c04f4d5304cbbbbc962c540e72;p=mygptrnn.git diff --git a/mygpt.py b/mygpt.py index 87071c3..d1acf22 100755 --- a/mygpt.py +++ b/mygpt.py @@ -181,7 +181,7 @@ def nsum_shape(X, Y_init): class DumbRec(nn.Module): def __init__( self, - dim_in, + dim_model, dim_qk, dim_v, nb_heads, @@ -199,11 +199,11 @@ class DumbRec(nn.Module): self.k_star = randw(nb_lines, dim_qk) - self.w_qw = randw(nb_heads, dim_qk, dim_in) - self.w_qr = randw(nb_heads, dim_qk, dim_in) - # self.w_k = randw(nb_heads, dim_qk, dim_in) - self.w_v = randw(nb_heads, dim_v, dim_in) - self.w_o = randw(dim_v * nb_heads, dim_in) + self.w_qw = randw(nb_heads, dim_qk, dim_model) + self.w_qr = randw(nb_heads, dim_qk, dim_model) + # self.w_k = randw(nb_heads, dim_qk, dim_model) + self.w_v = randw(nb_heads, dim_v, dim_model) + self.w_o = randw(dim_v * nb_heads, dim_model) def reset_inner_loss(self): self.acc_attention = 0 @@ -310,7 +310,7 @@ class DumbRec(nn.Module): class KVRec(nn.Module): def __init__( self, - dim_in, + dim_model, dim_qk, dim_v, nb_heads, @@ -328,11 +328,11 @@ class KVRec(nn.Module): self.k_star = randw(nb_lines, dim_qk) - self.w_qw = randw(nb_heads, dim_qk, dim_in) - self.w_qr = randw(nb_heads, dim_qk, dim_in) - self.w_k = randw(nb_heads, dim_qk, dim_in) - self.w_v = randw(nb_heads, dim_v, dim_in) - self.w_o = randw(dim_v * nb_heads, dim_in) + self.w_qw = randw(nb_heads, dim_qk, dim_model) + self.w_qr = randw(nb_heads, dim_qk, dim_model) + self.w_k = randw(nb_heads, dim_qk, dim_model) + self.w_v = randw(nb_heads, dim_v, dim_model) + self.w_o = randw(dim_v * nb_heads, dim_model) def reset_inner_loss(self): self.acc_attention = 0 @@ -456,7 +456,7 @@ def moving_window(x, dim, win_dim, win_size): class Caterpillar(nn.Module): def __init__( self, - dim_in, + dim_model, dim_qk, dim_v, nb_heads, @@ -476,17 +476,17 @@ class Caterpillar(nn.Module): self.caterpillar_height = caterpillar_height self.attention_dropout = attention_dropout - self.w_G = randw(nb_heads, caterpillar_height, dim_in) + self.w_G = randw(nb_heads, caterpillar_height, dim_model) self.b_G = nn.Parameter( torch.full( (nb_heads, caterpillar_height), -math.log(caterpillar_height - 1) ) ) - self.w_K = randw(nb_heads, dim_qk, dim_in) - self.w_V = randw(nb_heads, dim_v, dim_in) - self.w_Q = randw(nb_heads, dim_qk, dim_in) - self.w_O = randw(dim_v * nb_heads, dim_in) + self.w_K = randw(nb_heads, dim_qk, dim_model) + self.w_V = randw(nb_heads, dim_v, dim_model) + self.w_Q = randw(nb_heads, dim_qk, dim_model) + self.w_O = randw(dim_v * nb_heads, dim_model) self.init_K_rec = randw(caterpillar_height, caterpillar_length, dim_qk) self.init_V_rec = randw(caterpillar_height, caterpillar_length, dim_v) @@ -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 up to CH 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 values + 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) @@ -591,7 +622,7 @@ class Caterpillar(nn.Module): class QKVAttention(nn.Module): def __init__( self, - dim_in, + dim_model, dim_qk, dim_v, nb_heads=1, @@ -607,10 +638,10 @@ class QKVAttention(nn.Module): self.attention_dropout = attention_dropout self.record_attention = False - self.w_q = randw(nb_heads, dim_qk, dim_in) - self.w_k = randw(nb_heads, dim_qk, dim_in) - self.w_v = randw(nb_heads, dim_v, dim_in) - self.w_o = randw(dim_v * nb_heads, dim_in) + self.w_q = randw(nb_heads, dim_qk, dim_model) + self.w_k = randw(nb_heads, dim_qk, dim_model) + self.w_v = randw(nb_heads, dim_v, dim_model) + self.w_o = randw(dim_v * nb_heads, dim_model) def forward(self, bs): x_q = bs.x @@ -714,7 +745,7 @@ class MyGPT(nn.Module): def attlayer(): if attention_layer == "mha": return QKVAttention( - dim_in=dim_model, + dim_model=dim_model, dim_qk=dim_keys, dim_v=dim_model // nb_heads, nb_heads=nb_heads, @@ -723,7 +754,7 @@ class MyGPT(nn.Module): ) elif attention_layer == "dumbrec": return DumbRec( - dim_in=dim_model, + dim_model=dim_model, dim_qk=dim_keys, dim_v=dim_rec_v, nb_heads=nb_heads, @@ -732,7 +763,7 @@ class MyGPT(nn.Module): ) elif attention_layer == "kvrec": return KVRec( - dim_in=dim_model, + dim_model=dim_model, dim_qk=dim_keys, dim_v=dim_rec_v, nb_heads=nb_heads, @@ -741,7 +772,7 @@ class MyGPT(nn.Module): ) elif attention_layer == "caterpillar": return Caterpillar( - dim_in=dim_model, + dim_model=dim_model, dim_qk=dim_keys, dim_v=dim_rec_v, nb_heads=nb_heads, @@ -881,7 +912,7 @@ if __name__ == "__main__": print("Basic check.") m = Caterpillar( - dim_in=4, + dim_model=4, dim_qk=3, dim_v=7, nb_heads=1,