diff --git "a/x_transformer_1_27_16.py" "b/x_transformer_1_27_16.py"
new file mode 100644--- /dev/null
+++ "b/x_transformer_1_27_16.py"
@@ -0,0 +1,4175 @@
+r'''############################################################################
+#===============================================================================
+#
+# X Trasformer Module
+#
+# x-transformers code With useful modifications
+#
+# Version 1.27.16
+#
+# Original source code courtesy of lucidrains
+# https://github.com/lucidrains/x-transformers
+#
+# Source code retrieved on 02/20/2024
+#
+# Project Los Angeles
+# Tegridy Code 2024
+#
+#===============================================================================
+#
+# Critical dependencies
+#
+# !pip install torch
+# !pip install einops
+# !pip install matplotlib
+#
+#===============================================================================
+'''
+
+################################################################################
+
+################################################################################
+# Code for x-transformers Python module attend.py
+################################################################################
+
+from functools import partial
+from typing import Optional, Tuple
+
+import torch
+from torch import nn, einsum, Tensor
+import torch.nn.functional as F
+
+from collections import namedtuple
+from functools import wraps
+from packaging import version
+from dataclasses import dataclass
+
+from einops import rearrange, repeat
+
+# constants
+
+@dataclass
+class Intermediates:
+    qk_similarities: Optional[Tensor] = None
+    pre_softmax_attn: Optional[Tensor] = None
+    post_softmax_attn: Optional[Tensor] = None
+    cached_kv: Optional[Tuple[Tensor, Tensor]] = None
+
+    def to_tuple(self):
+        return (self.qk_similarities, self.pre_softmax_attn, self.post_softmax_attn)
+
+# helpers
+
+def exists(val):
+    return val is not None
+
+def default(val, d):
+    return val if exists(val) else d
+
+def compact(arr):
+    return [*filter(exists, arr)]
+
+def once(fn):
+    called = False
+    @wraps(fn)
+    def inner(x):
+        nonlocal called
+        if called:
+            return
+        called = True
+        return fn(x)
+    return inner
+
+print_once = once(print)
+
+# functions for creating causal mask
+# need a special one for onnx cpu (no support for .triu)
+
+def create_causal_mask(i, j, device):
+    return torch.ones((i, j), device = device, dtype = torch.bool).triu(j - i + 1)
+
+def onnx_create_causal_mask(i, j, device):
+    r = torch.arange(i, device = device)
+    causal_mask = rearrange(r, 'i -> i 1') < rearrange(r, 'j -> 1 j')
+    causal_mask = F.pad(causal_mask, (j - i, 0), value = False)
+    return causal_mask
+
+# main class
+
+class Attend(nn.Module):
+    def __init__(
+        self,
+        *,
+        dropout = 0.,
+        causal = False,
+        heads = None,
+        talking_heads = False,
+        sparse_topk = None,
+        scale = None,
+        qk_norm = False,
+        flash = False,
+        add_zero_kv = False,
+        onnxable = False,
+        sdp_kwargs: dict = dict(
+            enable_flash = True,
+            enable_math = True,
+            enable_mem_efficient = True
+        )
+    ):
+        super().__init__()
+        self.scale = scale
+        self.qk_norm = qk_norm
+
+        self.causal = causal
+        self.create_causal_mask = onnx_create_causal_mask if onnxable else create_causal_mask
+
+        self.attn_fn = partial(F.softmax, dtype = torch.float32) if not qk_norm else F.softmax
+
+        self.dropout = dropout
+        self.attn_dropout = nn.Dropout(dropout)
+
+        # talking heads
+
+        assert not (flash and talking_heads), 'talking heads not compatible with flash attention'
+
+        self.talking_heads = talking_heads
+        if talking_heads:
+            self.pre_softmax_talking_heads = nn.Conv2d(heads, heads, 1, bias = False)
+            self.post_softmax_talking_heads = nn.Conv2d(heads, heads, 1, bias = False)
+
+        # sparse topk
+
+        assert not (flash and sparse_topk), 'sparse topk not compatible with flash attention'
+        self.sparse_topk = sparse_topk
+
+        # add a key / value token composed of zeros
+        # in case this helps controlling outliers, proposed by https://www.evanmiller.org/attention-is-off-by-one.html
+
+        self.add_zero_kv = add_zero_kv
+
+        # flash attention
+
+        self.flash = flash
+        assert not (flash and version.parse(torch.__version__) < version.parse('2.0.0')), 'in order to use flash attention, you must be using pytorch 2.0 or above'
+
+        self.sdp_kwargs = sdp_kwargs
+
+    def flash_attn(
+        self,
+        q, k, v,
+        mask = None,
+        attn_bias = None
+    ):
+        batch, heads, q_len, _, k_len, is_cuda, device = *q.shape, k.shape[-2], q.is_cuda, q.device
+
+        # Recommended for multi-query single-key-value attention by Tri Dao
+        # kv shape torch.Size([1, 512, 64]) -> torch.Size([1, 8, 512, 64])
+
+        if k.ndim == 3:
+            k = repeat(k, 'b ... -> b h ...', h = q.shape[1])
+
+        if v.ndim == 3:
+            v = repeat(v, 'b ... -> b h ...', h = q.shape[1])
+
+        # handle scale - by default they scale by dim_head ** -0.5, but need to take care if using cosine sim attention
+
+        if self.qk_norm:
+            default_scale = q.shape[-1] ** -0.5
+            q = q * (self.scale / default_scale)
+
+        # Check if mask exists and expand to compatible shape
+        # The mask is B L, so it would have to be expanded to B H N L
+
+        causal = self.causal
+
+        # in the case of kv caching with one token (q_len == 1), just turn off causal masking
+        # in speculative decoding, this may go up to 5-6, so right aligned causal mask will be needed there
+
+        if q_len == 1 and causal:
+            causal = False
+
+        # expand key padding mask
+
+        if exists(mask):
+            assert mask.ndim == 4
+            mask = mask.expand(batch, heads, q_len, k_len)
+
+        # handle kv cache - this should be bypassable in updated flash attention 2
+
+        if k_len > q_len and causal:
+            causal_mask = self.create_causal_mask(q_len, k_len, device = device)
+            if not exists(mask):
+                mask = ~causal_mask
+            else:
+                mask = mask & ~causal_mask
+            causal = False
+
+        # manually handle causal mask, if another mask was given
+
+        row_is_entirely_masked = None
+
+        if exists(mask) and causal:
+            causal_mask = self.create_causal_mask(q_len, k_len, device = device)
+            mask = mask & ~causal_mask
+
+            # protect against an entire row being masked out
+
+            row_is_entirely_masked = ~mask.any(dim = -1)
+            mask[..., 0] = mask[..., 0] | row_is_entirely_masked
+
+            causal = False
+
+        # handle alibi positional bias
+        # convert from bool to float
+
+        if exists(attn_bias):
+            attn_bias = rearrange(attn_bias, 'h i j -> 1 h i j').expand(batch, heads, -1, -1)
+
+            # if mask given, the mask would already contain the causal mask from above logic
+            # otherwise, if no mask given but still causal, mask out alibi positional bias to a large negative number
+
+            mask_value = -torch.finfo(q.dtype).max
+
+            if exists(mask):
+                attn_bias = attn_bias.masked_fill(~mask, mask_value // 2)
+            elif causal:
+                causal_mask = self.create_causal_mask(q_len, k_len, device = device)
+                attn_bias = attn_bias.masked_fill(causal_mask, mask_value // 2)
+                causal = False
+
+            # scaled_dot_product_attention handles attn_mask either as bool or additive bias
+            # make it an additive bias here
+
+            mask = attn_bias
+
+        # pytorch 2.0 flash attn: q, k, v, mask, dropout, causal, softmax_scale
+
+        with torch.backends.cuda.sdp_kernel(**self.sdp_kwargs):
+            out = F.scaled_dot_product_attention(
+                q, k, v,
+                attn_mask = mask,
+                dropout_p = self.dropout if self.training else 0., 
+                is_causal = causal
+            )
+
+        # for a row that is entirely masked out, should zero out the output of that row token
+
+        if exists(row_is_entirely_masked):
+            out = out.masked_fill(row_is_entirely_masked[..., None], 0.)
+
+        return out, Intermediates()
+
+    def forward(
+        self,
+        q, k, v,
+        mask = None,
+        attn_bias = None,
+        prev_attn = None
+    ):
+        """
+        einstein notation
+        b - batch
+        h - heads
+        n, i, j - sequence length (base sequence length, source, target)
+        d - feature dimension
+        """
+
+        n, heads, kv_heads, device = q.shape[-2], q.shape[1], k.shape[1], q.device
+
+        scale = default(self.scale, q.shape[-1] ** -0.5)
+
+        causal = self.causal
+
+        # handle kv cached decoding
+
+        if n == 1 and causal:
+            causal = False
+
+        # handle grouped multi-query attention
+
+        if kv_heads == 1:
+            k, v = map(lambda t: rearrange(t, 'b 1 n d -> b n d'), (k, v))
+        elif kv_heads < heads:
+            k, v = map(lambda t: repeat(t, 'b kvh n d -> b (r kvh) n d', r = heads // kv_heads), (k, v))
+
+        # handle zero kv, as means for allowing network to attend to nothing
+
+        if self.add_zero_kv:
+            k, v = map(lambda t: F.pad(t, (0, 0, 1, 0), value = 0.), (k, v))
+
+            if exists(mask):
+                mask = F.pad(mask, (1, 0), value = True)
+
+            if exists(attn_bias):
+                attn_bias = F.pad(attn_bias, (1, 0), value = 0.)
+
+        if self.flash:
+            assert not exists(prev_attn), 'residual attention not compatible with flash attention'
+            return self.flash_attn(q, k, v, mask = mask, attn_bias = attn_bias)
+
+        kv_einsum_eq = 'b j d' if k.ndim == 3 else 'b h j d'
+
+        dots = einsum(f'b h i d, {kv_einsum_eq} -> b h i j', q, k) * scale
+
+        if exists(prev_attn):
+            dots = dots + prev_attn
+
+        qk_similarities = dots.clone()
+
+        if self.talking_heads:
+            dots = self.pre_softmax_talking_heads(dots)
+
+        if exists(attn_bias):
+            dots = dots + attn_bias
+
+        i, j, dtype = *dots.shape[-2:], dots.dtype
+
+        mask_value = -torch.finfo(dots.dtype).max
+
+        if exists(self.sparse_topk) and self.sparse_topk < j:
+            top_values, _ = dots.topk(self.sparse_topk, dim = -1)
+            sparse_topk_mask = dots < top_values[..., -1:]
+            mask = (mask & sparse_topk_mask) if exists(mask) else sparse_topk_mask
+
+        if exists(mask):
+            dots = dots.masked_fill(~mask, mask_value)
+
+        if causal:
+            causal_mask = self.create_causal_mask(i, j, device = device)
+            dots = dots.masked_fill(causal_mask, mask_value)
+
+        pre_softmax_attn = dots.clone()
+
+        attn = self.attn_fn(dots, dim = -1)
+        attn = attn.type(dtype)
+
+        post_softmax_attn = attn.clone()
+
+        attn = self.attn_dropout(attn)
+
+        if self.talking_heads:
+            attn = self.post_softmax_talking_heads(attn)
+
+        out = einsum(f'b h i j, {kv_einsum_eq} -> b h i d', attn, v)
+
+        intermediates = Intermediates(
+            qk_similarities = qk_similarities,
+            pre_softmax_attn = pre_softmax_attn,
+            post_softmax_attn = post_softmax_attn
+        )
+
+        return out, intermediates
+
+################################################################################
+
+################################################################################
+# Code for x-transformers Python module x_transformers.py
+################################################################################
+
+import math
+from random import random
+from typing import Dict
+from packaging import version
+
+import torch
+from torch import nn, einsum, Tensor
+import torch.nn.functional as F
+from torch.cuda.amp import autocast
+
+from functools import partial, wraps
+from collections import namedtuple
+from dataclasses import dataclass
+from typing import List, Callable, Optional, Union
+
+from einops import rearrange, repeat, reduce, pack, unpack
+from einops.layers.torch import Rearrange
+
+# constants
+
+DEFAULT_DIM_HEAD = 64
+
+@dataclass
+class LayerIntermediates:
+    hiddens:            Optional[List[Tensor]] = None   # all hiddens, before the final norm (in pre-norm architecture)
+    last_hidden:        Optional[Tensor] = None         # very last hidden after all attention layers, after the final norm
+    attn_intermediates: Optional[List[Intermediates]] = None
+    layer_hiddens:      Optional[List[Tensor]] = None
+    attn_z_loss:        Optional[Tensor] = None
+    mems:               Optional[Tensor] = None
+    memory_tokens:      Optional[Tensor] = None
+
+# helpers
+
+def exists(val):
+    return val is not None
+
+def default(val, d):
+    if exists(val):
+        return val
+    return d() if callable(d) else d
+
+def cast_tuple(val, depth):
+    return val if isinstance(val, tuple) else (val,) * depth
+
+def divisible_by(num, den):
+    return (num % den) == 0
+
+def maybe(fn):
+    @wraps(fn)
+    def inner(x, *args, **kwargs):
+        if not exists(x):
+            return x
+        return fn(x, *args, **kwargs)
+    return inner
+
+def at_most_one_of(*bools):
+    return sum(map(int, bools)) <= 1
+
+class always():
+    def __init__(self, val):
+        self.val = val
+    def __call__(self, *args, **kwargs):
+        return self.val
+
+class not_equals():
+    def __init__(self, val):
+        self.val = val
+    def __call__(self, x, *args, **kwargs):
+        return x != self.val
+
+class equals():
+    def __init__(self, val):
+        self.val = val
+    def __call__(self, x, *args, **kwargs):
+        return x == self.val
+
+def Sequential(*modules):
+    return nn.Sequential(*filter(exists, modules))
+
+# tensor helpers
+
+def max_neg_value(tensor):
+    return -torch.finfo(tensor.dtype).max
+
+def l2norm(t, groups = 1):
+    t = rearrange(t, '... (g d) -> ... g d', g = groups)
+    t = F.normalize(t, p = 2, dim = -1)
+    return rearrange(t, '... g d -> ... (g d)')
+
+def pad_at_dim(t, pad, dim = -1, value = 0.):
+    dims_from_right = (- dim - 1) if dim < 0 else (t.ndim - dim - 1)
+    zeros = ((0, 0) * dims_from_right)
+    return F.pad(t, (*zeros, *pad), value = value)
+
+def or_reduce(masks):
+    head, *body = masks
+    for rest in body:
+        head = head | rest
+    return head
+
+# auxiliary loss helpers
+
+def calc_z_loss(
+    pre_softmax_attns: List[Tensor],
+    mask = None,
+    weight = 1.
+):
+    # the same loss applied to the mixture of experts router logits in https://arxiv.org/abs/2202.08906
+    # in the paper, in a tiny footnote, they mention using it on attention logits with stabilizing effects
+    # also used in PaLM as one of the measures
+
+    lse = 0.
+
+    for attn in pre_softmax_attns:
+        lse = lse + attn.logsumexp(dim = -1)
+
+    loss = torch.square(lse)
+    loss = reduce(loss, 'b h n -> b n', 'sum')
+
+    if not exists(mask):
+        return loss.mean() * weight
+
+    loss = loss[mask].sum() / mask.sum().clamp(min = 1e-5)
+    return loss * weight
+
+# init helpers
+
+def init_zero_(layer):
+    nn.init.constant_(layer.weight, 0.)
+    if exists(layer.bias):
+        nn.init.constant_(layer.bias, 0.)
+
+# keyword argument helpers
+
+def pick_and_pop(keys, d):
+    values = list(map(lambda key: d.pop(key), keys))
+    return dict(zip(keys, values))
+
+def group_dict_by_key(cond, d):
+    return_val = [dict(),dict()]
+    for key in d.keys():
+        match = bool(cond(key))
+        ind = int(not match)
+        return_val[ind][key] = d[key]
+    return (*return_val,)
+
+def string_begins_with(prefix, str):
+    return str.startswith(prefix)
+
+def group_by_key_prefix(prefix, d):
+    return group_dict_by_key(partial(string_begins_with, prefix), d)
+
+def groupby_prefix_and_trim(prefix, d):
+    kwargs_with_prefix, kwargs = group_dict_by_key(partial(string_begins_with, prefix), d)
+    kwargs_without_prefix = dict(map(lambda x: (x[0][len(prefix):], x[1]), tuple(kwargs_with_prefix.items())))
+    return kwargs_without_prefix, kwargs
+
+# structured dropout, more effective than traditional attention dropouts
+
+def dropout_seq(seq, mask, dropout):
+    b, n, *_, device = *seq.shape, seq.device
+    logits = torch.randn(b, n, device = device)
+
+    if exists(mask):
+        mask_value = max_neg_value(logits)
+        logits = logits.masked_fill(~mask, mask_value)
+
+    keep_prob = 1. - dropout
+    num_keep = max(1,  int(keep_prob * n))
+    keep_indices = logits.topk(num_keep, dim = 1).indices
+
+    batch_indices = torch.arange(b, device = device)
+    batch_indices = rearrange(batch_indices, 'b -> b 1')
+
+    seq = seq[batch_indices, keep_indices]
+
+    if exists(mask):
+        seq_counts = mask.sum(dim = -1)
+        seq_keep_counts = torch.ceil(seq_counts * keep_prob).int()
+        keep_mask = torch.arange(num_keep, device = device) < rearrange(seq_keep_counts, 'b -> b 1')
+
+        mask = mask[batch_indices, keep_indices] & keep_mask
+
+    return seq, mask
+
+# activations
+
+class ReluSquared(nn.Module):
+    def forward(self, x):
+        return F.relu(x) ** 2
+
+# embedding
+
+class TokenEmbedding(nn.Module):
+    def __init__(self, dim, num_tokens, l2norm_embed = False):
+        super().__init__()
+        self.l2norm_embed = l2norm_embed
+        self.emb = nn.Embedding(num_tokens, dim)
+
+    def forward(self, x):
+        token_emb = self.emb(x.long())
+        return l2norm(token_emb) if self.l2norm_embed else token_emb
+
+# positional embeddings
+
+class AbsolutePositionalEmbedding(nn.Module):
+    def __init__(self, dim, max_seq_len, l2norm_embed = False):
+        super().__init__()
+        self.scale = dim ** -0.5 if not l2norm_embed else 1.
+        self.max_seq_len = max_seq_len
+        self.l2norm_embed = l2norm_embed
+        self.emb = nn.Embedding(max_seq_len, dim)
+
+    def forward(self, x, pos = None, seq_start_pos = None):
+        seq_len, device = x.shape[1], x.device
+        assert seq_len <= self.max_seq_len, f'you are passing in a sequence length of {seq_len} but your absolute positional embedding has a max sequence length of {self.max_seq_len}'
+
+        if not exists(pos):
+            pos = torch.arange(seq_len, device = device)
+
+        if exists(seq_start_pos):
+            pos = (pos - seq_start_pos[..., None]).clamp(min = 0)
+
+        pos_emb = self.emb(pos)
+        pos_emb = pos_emb * self.scale
+        return l2norm(pos_emb) if self.l2norm_embed else pos_emb
+
+class ScaledSinusoidalEmbedding(nn.Module):
+    def __init__(self, dim, theta = 10000):
+        super().__init__()
+        assert divisible_by(dim, 2)
+        self.scale = nn.Parameter(torch.ones(1) * dim ** -0.5)
+
+        half_dim = dim // 2
+        freq_seq = torch.arange(half_dim).float() / half_dim
+        inv_freq = theta ** -freq_seq
+        self.register_buffer('inv_freq', inv_freq, persistent = False)
+
+    def forward(self, x, pos = None, seq_start_pos = None):
+        seq_len, device = x.shape[1], x.device
+
+        if not exists(pos):
+            pos = torch.arange(seq_len, device = device)
+
+        if exists(seq_start_pos):
+            pos = pos - seq_start_pos[..., None]
+
+        emb = einsum('i, j -> i j', pos, self.inv_freq)
+        emb = torch.cat((emb.sin(), emb.cos()), dim = -1)
+        return emb * self.scale
+
+class RelativePositionBias(nn.Module):
+    def __init__(self, scale, causal = False, num_buckets = 32, max_distance = 128, heads = 8):
+        super().__init__()
+        self.scale = scale
+        self.causal = causal
+        self.num_buckets = num_buckets
+        self.max_distance = max_distance
+        self.relative_attention_bias = nn.Embedding(num_buckets, heads)
+
+    @staticmethod
+    def _relative_position_bucket(relative_position, causal = True, num_buckets = 32, max_distance = 128):
+        ret = 0
+        n = -relative_position
+        if not causal:
+            num_buckets //= 2
+            ret += (n < 0).long() * num_buckets
+            n = torch.abs(n)
+        else:
+            n = torch.max(n, torch.zeros_like(n))
+
+        max_exact = num_buckets // 2
+        is_small = n < max_exact
+
+        val_if_large = max_exact + (
+            torch.log(n.float() / max_exact) / math.log(max_distance / max_exact) * (num_buckets - max_exact)
+        ).long()
+        val_if_large = torch.min(val_if_large, torch.full_like(val_if_large, num_buckets - 1))
+
+        ret += torch.where(is_small, n, val_if_large)
+        return ret
+
+    @property
+    def device(self):
+        return next(self.parameters()).device
+
+    def forward(self, i, j):
+        device = self.device
+        q_pos = torch.arange(j - i, j, dtype = torch.long, device = device)
+        k_pos = torch.arange(j, dtype = torch.long, device = device)
+        rel_pos = k_pos[None, :] - q_pos[:, None]
+        rp_bucket = self._relative_position_bucket(rel_pos, causal = self.causal, num_buckets = self.num_buckets, max_distance = self.max_distance)
+        values = self.relative_attention_bias(rp_bucket)
+        bias = rearrange(values, 'i j h -> h i j')
+        return bias * self.scale
+
+class DynamicPositionBias(nn.Module):
+    def __init__(self, dim, *, heads, depth, log_distance = False, norm = False):
+        super().__init__()
+        assert depth >= 1, 'depth for dynamic position bias MLP must be greater or equal to 1'
+        self.log_distance = log_distance
+
+        self.mlp = nn.ModuleList([])
+
+        self.mlp.append(Sequential(
+            nn.Linear(1, dim),
+            LayerNorm(dim) if norm else None,
+            nn.SiLU()
+        ))
+
+        for _ in range(depth - 1):
+            self.mlp.append(Sequential(
+                nn.Linear(dim, dim),
+                nn.LayerNorm(dim) if norm else None,
+                nn.SiLU()
+            ))
+
+        self.mlp.append(nn.Linear(dim, heads))
+
+    @property
+    def device(self):
+        return next(self.parameters()).device
+
+    def forward(self, i, j):
+        assert i == j
+        n, device = j, self.device
+
+        # get the (n x n) matrix of distances
+        seq_arange = torch.arange(n, device = device)
+        context_arange = torch.arange(n, device = device)
+        indices = rearrange(seq_arange, 'i -> i 1') - rearrange(context_arange, 'j -> 1 j')
+        indices += (n - 1)
+
+        # input to continuous positions MLP
+        pos = torch.arange(-n + 1, n, device = device).float()
+        pos = rearrange(pos, '... -> ... 1')
+
+        if self.log_distance:
+            pos = torch.sign(pos) * torch.log(pos.abs() + 1)  # log of distance is sign(rel_pos) * log(abs(rel_pos) + 1)
+
+        for layer in self.mlp:
+            pos = layer(pos)
+
+        # get position biases        
+        bias = pos[indices]
+        bias = rearrange(bias, 'i j h -> h i j')
+        return bias
+
+class AlibiPositionalBias(nn.Module):
+    def __init__(self, heads, total_heads, **kwargs):
+        super().__init__()
+        self.heads = heads
+        self.total_heads = total_heads
+
+        slopes = Tensor(self._get_slopes(heads))
+        slopes = rearrange(slopes, 'h -> h 1 1')
+        self.register_buffer('slopes', slopes, persistent = False)
+        self.register_buffer('bias', None, persistent = False)
+    
+    def get_bias(self, i, j, device):
+        i_arange = torch.arange(j - i, j, device = device)
+        j_arange = torch.arange(j, device = device)
+        bias = -torch.abs(rearrange(j_arange, 'j -> 1 1 j') - rearrange(i_arange, 'i -> 1 i 1'))
+        return bias
+
+    @staticmethod
+    def _get_slopes(heads):
+        def get_slopes_power_of_2(n):
+            start = (2**(-2**-(math.log2(n)-3)))
+            ratio = start
+            return [start*ratio**i for i in range(n)]
+
+        if math.log2(heads).is_integer():
+            return get_slopes_power_of_2(heads)
+
+        closest_power_of_2 = 2 ** math.floor(math.log2(heads))
+        return get_slopes_power_of_2(closest_power_of_2) + get_slopes_power_of_2(2 * closest_power_of_2)[0::2][:heads-closest_power_of_2]
+
+    @property
+    def device(self):
+        return next(self.buffers()).device
+
+    def forward(self, i, j):
+        h, device = self.total_heads, self.device
+
+        if exists(self.bias) and self.bias.shape[-1] >= j and self.bias.shape[-2] >= i:
+            return self.bias[..., -i:, -j:]
+
+        bias = self.get_bias(i, j, device)
+        bias = bias * self.slopes
+
+        num_heads_unalibied = h - bias.shape[0]
+        bias = pad_at_dim(bias, (0, num_heads_unalibied), dim = 0)
+        self.register_buffer('bias', bias, persistent = False)
+
+        return self.bias
+
+class RotaryEmbedding(nn.Module):
+    def __init__(
+        self,
+        dim,
+        use_xpos = False,
+        scale_base = 512,
+        interpolation_factor = 1.,
+        base = 10000,
+        base_rescale_factor = 1.
+    ):
+        super().__init__()
+        # proposed by reddit user bloc97, to rescale rotary embeddings to longer sequence length without fine-tuning
+        # has some connection to NTK literature
+        # https://www.reddit.com/r/LocalLLaMA/comments/14lz7j5/ntkaware_scaled_rope_allows_llama_models_to_have/
+        base *= base_rescale_factor ** (dim / (dim - 2))
+
+        inv_freq = 1. / (base ** (torch.arange(0, dim, 2).float() / dim))
+        self.register_buffer('inv_freq', inv_freq)
+
+        assert interpolation_factor >= 1.
+        self.interpolation_factor = interpolation_factor
+
+        if not use_xpos:
+            self.register_buffer('scale', None)
+            return
+
+        scale = (torch.arange(0, dim, 2) + 0.4 * dim) / (1.4 * dim)
+
+        self.scale_base = scale_base
+        self.register_buffer('scale', scale)
+
+    def forward_from_seq_len(self, seq_len):
+        device = self.inv_freq.device
+
+        t = torch.arange(seq_len, device = device)
+        return self.forward(t)
+
+    @autocast(enabled = False)
+    def forward(self, t):
+        max_pos = t.max()+1
+
+        freqs = torch.einsum('i , j -> i j', t.type_as(self.inv_freq), self.inv_freq) / self.interpolation_factor
+        freqs = torch.cat((freqs, freqs), dim = -1)
+
+        if not exists(self.scale):
+            return freqs, 1.
+
+        power = (t - (max_pos // 2)) / self.scale_base
+        scale = self.scale ** rearrange(power, 'n -> n 1')
+        scale = torch.cat((scale, scale), dim = -1)
+
+        return freqs, scale
+
+
+def rotate_half(x):
+    x = rearrange(x, '... (j d) -> ... j d', j = 2)
+    x1, x2 = x.unbind(dim = -2)
+    return torch.cat((-x2, x1), dim = -1)
+
+@autocast(enabled = False)
+def apply_rotary_pos_emb(t, freqs, scale = 1):
+    rot_dim, seq_len = freqs.shape[-1], t.shape[-2]
+    freqs = freqs[-seq_len:, :]
+    scale = scale[-seq_len:, :] if isinstance(scale, torch.Tensor) else scale
+
+    if t.ndim == 4 and freqs.ndim == 3:
+        freqs = rearrange(freqs, 'b n d -> b 1 n d')
+
+    # partial rotary embeddings, Wang et al. GPT-J
+    t, t_unrotated = t[..., :rot_dim], t[..., rot_dim:]
+    t = (t * freqs.cos() * scale) + (rotate_half(t) * freqs.sin() * scale)
+    return torch.cat((t, t_unrotated), dim = -1)
+
+# norms
+
+class Scale(nn.Module):
+    def __init__(self, value, fn):
+        super().__init__()
+        self.value = value
+        self.fn = fn
+
+    def forward(self, x, **kwargs):
+        out = self.fn(x, **kwargs)
+        scale_fn = lambda t: t * self.value
+
+        if not isinstance(out, tuple):
+            return scale_fn(out)
+
+        return (scale_fn(out[0]), *out[1:])
+
+class ScaleNorm(nn.Module):
+    def __init__(self, dim, eps = 1e-5):
+        super().__init__()
+        self.eps = eps
+        self.g = nn.Parameter(torch.ones(1) * (dim ** -0.5))
+
+    def forward(self, x):
+        norm = torch.norm(x, dim = -1, keepdim = True)
+        return x / norm.clamp(min = self.eps) * self.g
+
+class LayerNorm(nn.Module):
+    def __init__(self, dim):
+        """
+        bias-less layernorm has been shown to be more stable. most newer models have moved towards rmsnorm, also bias-less
+        """
+        super().__init__()
+        self.gamma = nn.Parameter(torch.ones(dim))
+        self.register_buffer("beta", torch.zeros(dim))
+
+    def forward(self, x):
+        return F.layer_norm(x, x.shape[-1:], self.gamma, self.beta)
+
+if version.parse(torch.__version__) >= version.parse('2.1.0'):
+    LayerNorm = partial(nn.LayerNorm, bias = False)
+
+class RMSNorm(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.scale = dim ** 0.5
+        self.g = nn.Parameter(torch.ones(dim))
+
+    def forward(self, x):
+        return F.normalize(x, dim = -1) * self.scale * self.g
+
+class SimpleRMSNorm(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.scale = dim ** 0.5
+
+    def forward(self, x):
+        return F.normalize(x, dim = -1) * self.scale
+
+# residual and residual gates
+
+class Residual(nn.Module):
+    def __init__(self, dim, scale_residual = False, scale_residual_constant = 1.):
+        super().__init__()
+        self.residual_scale = nn.Parameter(torch.ones(dim)) if scale_residual else None
+        self.scale_residual_constant = scale_residual_constant
+
+    def forward(self, x, residual):
+        if exists(self.residual_scale):
+            residual = residual * self.residual_scale
+
+        if self.scale_residual_constant != 1:
+            residual = residual * self.scale_residual_constant
+
+        return x + residual
+
+class GRUGating(nn.Module):
+    def __init__(self, dim, scale_residual = False, **kwargs):
+        super().__init__()
+        self.gru = nn.GRUCell(dim, dim)
+        self.residual_scale = nn.Parameter(torch.ones(dim)) if scale_residual else None
+
+    def forward(self, x, residual):
+        if exists(self.residual_scale):
+            residual = residual * self.residual_scale
+
+        gated_output = self.gru(
+            rearrange(x, 'b n d -> (b n) d'),
+            rearrange(residual, 'b n d -> (b n) d')
+        )
+
+        return gated_output.reshape_as(x)
+
+# token shifting
+
+def shift(t, amount, mask = None):
+    if amount == 0:
+        return t
+    else:
+        amount = min(amount, t.shape[1])
+
+    if exists(mask):
+        t = t.masked_fill(~mask[..., None], 0.)
+
+    return pad_at_dim(t, (amount, -amount), dim = - 2, value = 0.)
+
+class ShiftTokens(nn.Module):
+    def __init__(self, shifts, fn):
+        super().__init__()
+        self.fn = fn
+        self.shifts = tuple(shifts)
+
+    def forward(self, x, **kwargs):
+        mask = kwargs.get('mask', None)
+        shifts = self.shifts
+        segments = len(shifts)
+        feats_per_shift = x.shape[-1] // segments
+        splitted = x.split(feats_per_shift, dim = -1)
+        segments_to_shift, rest = splitted[:segments], splitted[segments:]
+        segments_to_shift = list(map(lambda args: shift(*args, mask = mask), zip(segments_to_shift, shifts)))
+        x = torch.cat((*segments_to_shift, *rest), dim = -1)
+        return self.fn(x, **kwargs)
+
+# feedforward
+
+class GLU(nn.Module):
+    def __init__(
+        self,
+        dim_in,
+        dim_out,
+        activation: Callable,
+        mult_bias = False
+    ):
+        super().__init__()
+        self.act = activation
+        self.proj = nn.Linear(dim_in, dim_out * 2)
+        self.mult_bias = nn.Parameter(torch.ones(dim_out)) if mult_bias else 1.
+
+    def forward(self, x):
+        x, gate = self.proj(x).chunk(2, dim = -1)
+        return x * self.act(gate) * self.mult_bias
+
+class FeedForward(nn.Module):
+    def __init__(
+        self,
+        dim,
+        dim_out = None,
+        mult = 4,
+        glu = False,
+        glu_mult_bias = False,
+        swish = False,
+        relu_squared = False,
+        post_act_ln = False,
+        dropout = 0.,
+        no_bias = False,
+        zero_init_output = False
+    ):
+        super().__init__()
+        inner_dim = int(dim * mult)
+        dim_out = default(dim_out, dim)
+
+        if relu_squared:
+            activation = ReluSquared()
+        elif swish:
+            activation = nn.SiLU()
+        else:
+            activation = nn.GELU()
+
+        if glu:
+            project_in = GLU(dim, inner_dim, activation, mult_bias = glu_mult_bias)
+        else:
+            project_in = nn.Sequential(
+                nn.Linear(dim, inner_dim, bias = not no_bias),
+                activation
+            )
+
+        self.ff = Sequential(
+            project_in,
+            LayerNorm(inner_dim) if post_act_ln else None,
+            nn.Dropout(dropout),
+            nn.Linear(inner_dim, dim_out, bias = not no_bias)
+        )
+
+        # init last linear layer to 0
+        if zero_init_output:
+            init_zero_(self.ff[-1])
+
+    def forward(self, x):
+        return self.ff(x)
+
+# attention. it is all we need
+
+class Attention(nn.Module):
+    def __init__(
+        self,
+        dim,
+        dim_head = DEFAULT_DIM_HEAD,
+        dim_context = None,
+        heads = 8,
+        causal = False,
+        flash = False,
+        talking_heads = False,
+        head_scale = False,
+        sparse_topk = None,
+        num_mem_kv = 0,
+        dropout = 0.,
+        on_attn = False,
+        gate_value_heads = False,
+        swiglu_values = False,
+        gate_values = False,
+        zero_init_output = False,
+        max_attend_past = None,
+        qk_norm = False,
+        qk_norm_groups = 1,
+        qk_norm_scale = 10,
+        qk_norm_dim_scale = False,
+        one_kv_head = False,
+        kv_heads = None,
+        shared_kv = False,
+        value_dim_head = None,
+        tensor_product = False,      # https://arxiv.org/abs/2208.06061
+        add_zero_kv = False,         # same as add_zero_attn in pytorch
+        rotary_embed_values = False,
+        onnxable = False
+    ):
+        super().__init__()
+        dim_kv = default(dim_context, dim)
+
+        self.scale = dim_head ** -0.5
+
+        self.heads = heads
+        self.causal = causal
+        self.max_attend_past = max_attend_past
+
+        assert not (exists(kv_heads) and one_kv_head), 'either attn_one_kv_head is set to True (in which case kv_heads is set to 1), or attn_kv_heads is set, but not both'
+
+        value_dim_head = default(value_dim_head, dim_head)
+        kv_heads = default(kv_heads, heads)
+
+        kv_heads = 1 if one_kv_head else kv_heads
+        assert divisible_by(heads, kv_heads)
+
+        self.kv_heads = kv_heads
+
+        q_dim = dim_head * heads
+        k_dim = dim_head * kv_heads
+        v_dim = value_dim_head * kv_heads
+        out_dim = value_dim_head * heads
+
+        self.to_q = nn.Linear(dim, q_dim, bias = False)
+        self.to_k = nn.Linear(dim_kv, k_dim, bias = False)
+
+        # shared key / values, for further memory savings during inference
+        assert not (shared_kv and value_dim_head != dim_head), 'key and value head dimensions must be equal for shared key / values'
+        self.to_v = nn.Linear(dim_kv, v_dim, bias = False) if not shared_kv else None
+
+        # relations projection from tp-attention
+        self.to_r = nn.Linear(dim, v_dim, bias = False) if tensor_product else None
+
+        # add GLU gating for aggregated values, from alphafold2
+        self.to_v_gate = None
+        if gate_values:
+            self.to_v_gate = nn.Linear(dim, out_dim)
+            self.to_v_gate_activation = F.silu if swiglu_values else F.sigmoid
+            nn.init.constant_(self.to_v_gate.weight, 0)
+            nn.init.constant_(self.to_v_gate.bias, 10)
+
+        # add per head gating of the output values, from 'Attend to nothing' paper
+        self.to_v_head_gate = None
+        if gate_value_heads:
+            self.to_v_head_gate = nn.Linear(dim, heads)
+            nn.init.constant_(self.to_v_head_gate.weight, 0)
+            nn.init.constant_(self.to_v_head_gate.bias, 10)
+
+        # cosine sim attention
+        self.qk_norm = qk_norm
+        self.qk_norm_groups = qk_norm_groups
+        self.qk_norm_scale = qk_norm_scale
+
+        # whether to use the rmsnorm (equivalent to cosine sim attention when scale is equal to 1) - https://arxiv.org/abs/2302.05442
+        self.qk_norm_dim_scale = qk_norm_dim_scale
+
+        self.qk_norm_q_scale = self.qk_norm_k_scale = 1
+        if qk_norm and qk_norm_dim_scale:
+            self.qk_norm_q_scale = nn.Parameter(torch.ones(heads, 1, dim_head))
+            self.qk_norm_k_scale = nn.Parameter(torch.ones(heads, 1, dim_head))
+
+        assert (not qk_norm) or divisible_by(dim_head, qk_norm_groups), 'dimension per attention head must be divisible by the qk norm groups'
+        assert not (qk_norm and (dim_head // qk_norm_groups) <= 2), 'the group dimension may be too small (2 was too small in my tests, but 4 still works, surprisingly)'
+
+        # attend class - includes core attention algorithm + talking heads
+
+        self.attend = Attend(
+            heads = heads,
+            causal = causal,
+            talking_heads = talking_heads,
+            dropout = dropout,
+            sparse_topk = sparse_topk,
+            qk_norm = qk_norm,
+            scale = qk_norm_scale if qk_norm else self.scale,
+            add_zero_kv = add_zero_kv,
+            flash = flash,
+            onnxable = onnxable
+        )
+
+        # head scaling
+        self.head_scale = head_scale
+        if head_scale:
+            self.head_scale_params = nn.Parameter(torch.ones(1, heads, 1, 1))
+
+        # explicit topk sparse attention
+        self.sparse_topk = sparse_topk
+
+        # add memory key / values
+        self.num_mem_kv = num_mem_kv
+        if num_mem_kv > 0:
+            self.mem_k = nn.Parameter(torch.randn(kv_heads, num_mem_kv, dim_head))
+            self.mem_v = nn.Parameter(torch.randn(kv_heads, num_mem_kv, dim_head))
+
+        # attention on attention
+        self.attn_on_attn = on_attn
+        self.to_out = nn.Sequential(nn.Linear(out_dim, dim * 2, bias = False), nn.GLU()) if on_attn else nn.Linear(out_dim, dim, bias = False)
+
+        # whether to rotate positions into values, for absolute positions in addition to relative
+        self.rotary_embed_values = rotary_embed_values
+
+        # init output projection 0
+        if zero_init_output:
+            init_zero_(self.to_out)
+
+    def forward(
+        self,
+        x,
+        context = None,
+        mask = None,
+        context_mask = None,
+        attn_mask = None,
+        rel_pos = None,
+        rotary_pos_emb = None,
+        prev_attn = None,
+        mem = None,
+        mem_mask = None,
+        return_intermediates = False,
+        cache: Optional[Intermediates] = None,
+    ):
+        b, n, h, kv_h, head_scale, device, has_context = x.shape[0], x.shape[1], self.heads, self.kv_heads, self.head_scale, x.device, exists(context)
+
+        kv_input = default(context, x)
+
+        q_input = x
+        k_input = kv_input
+        v_input = kv_input
+        r_input = x
+
+        if exists(mem):
+            k_input, mem_packed_shape = pack([mem, k_input], 'b * d')
+            v_input, _ = pack([mem, v_input], 'b * d')
+
+        q = self.to_q(q_input)
+        k = self.to_k(k_input)
+        v = self.to_v(v_input) if exists(self.to_v) else k
+        r = self.to_r(r_input) if exists(self.to_r) else None
+
+        q = rearrange(q, 'b n (h d) -> b h n d', h = h)
+
+        k, v, r = map(lambda t: maybe(rearrange)(t, 'b n (h d) -> b h n d', h = kv_h), (k, v, r))
+
+        if exists(cache) and not has_context:
+            ck, cv = cache.cached_kv
+
+            if exists(mem):
+                mk, k = unpack(k, mem_packed_shape, 'b h * d')
+                mv, v = unpack(v, mem_packed_shape, 'b h * d')
+
+            k = torch.cat((ck, k), dim = -2)
+            v = torch.cat((cv, v), dim = -2)
+
+            if exists(mem):
+                k = torch.cat((mk, k), dim = -2)
+                v = torch.cat((mv, v), dim = -2)
+
+        if return_intermediates:
+            mem_len = mem.shape[-2] if exists(mem) else 0
+            cached_kv = (k[..., mem_len:, :], v[..., mem_len:, :])
+
+        if self.qk_norm:
+            qk_l2norm = partial(l2norm, groups = self.qk_norm_groups)
+            q, k = map(qk_l2norm, (q, k))
+            scale = self.qk_norm_scale
+
+            q = q * self.qk_norm_q_scale
+            k = k * self.qk_norm_k_scale
+
+        if exists(rotary_pos_emb) and not has_context:
+            freqs, xpos_scale = rotary_pos_emb
+            q_xpos_scale, k_xpos_scale = (xpos_scale, xpos_scale ** -1.) if exists(xpos_scale) else (1., 1.)
+
+            q = apply_rotary_pos_emb(q, freqs, q_xpos_scale)
+            k = apply_rotary_pos_emb(k, freqs, k_xpos_scale)
+
+            if self.rotary_embed_values:
+                v = apply_rotary_pos_emb(v, freqs, k_xpos_scale)
+
+        input_mask = context_mask
+
+        if not exists(input_mask) and not has_context:
+            input_mask = mask
+
+            if (exists(input_mask) or exists(mem_mask)) and exists(mem):
+                seq_len, mem_len = n, mem.shape[-2]
+
+                if not exists(mem_mask):
+                    input_mask = pad_at_dim(input_mask, (mem_len, 0), dim = -1, value = True)
+                elif not exists(input_mask):
+                    input_mask = pad_at_dim(mem_mask, (0, seq_len), dim = -1, value = True)
+                else:
+                    input_mask = torch.cat((mem_mask, input_mask), dim = -1)
+
+        if self.num_mem_kv > 0:
+            mem_k, mem_v = map(lambda t: repeat(t, 'h n d -> b h n d', b = b), (self.mem_k, self.mem_v))
+
+            if self.qk_norm:
+                mem_k = l2norm(mem_k)
+                mem_k = mem_k * self.qk_norm_k_scale
+
+            k = torch.cat((mem_k, k), dim = -2)
+            v = torch.cat((mem_v, v), dim = -2)
+
+            if exists(input_mask):
+                input_mask = pad_at_dim(input_mask, (self.num_mem_kv, 0), dim = -1, value = True)
+
+        i, j = map(lambda t: t.shape[-2], (q, k))
+
+        # determine masking
+
+        mask_value = max_neg_value(q)
+        masks = []
+        final_attn_mask = None
+
+        if exists(input_mask):
+            input_mask = rearrange(input_mask, 'b j -> b 1 1 j')
+            masks.append(~input_mask)
+
+        if exists(attn_mask):
+            assert 2 <= attn_mask.ndim <= 4, 'attention mask must have greater than 2 dimensions but less than or equal to 4'
+            if attn_mask.ndim == 2:
+                attn_mask = rearrange(attn_mask, 'i j -> 1 1 i j')
+            elif attn_mask.ndim == 3:
+                attn_mask = rearrange(attn_mask, 'h i j -> 1 h i j')
+            masks.append(~attn_mask)
+
+        if exists(self.max_attend_past):
+            range_q = torch.arange(j - i, j, device = device)
+            range_k = torch.arange(j, device = device)
+            dist = rearrange(range_q, 'i -> 1 1 i 1') - rearrange(range_k, 'j -> 1 1 1 j')
+            max_attend_past_mask = dist > self.max_attend_past
+            masks.append(max_attend_past_mask)
+
+        if len(masks) > 0:
+            final_attn_mask = ~or_reduce(masks)
+
+        # prepare relative positional bias, if needed
+
+        attn_bias = None
+        if exists(rel_pos):
+            attn_bias = rel_pos(i, j)
+
+        # attention is all we need
+
+        out, intermediates = self.attend(
+            q, k, v,
+            mask = final_attn_mask,
+            attn_bias = attn_bias,
+            prev_attn = prev_attn
+        )
+
+        # https://arxiv.org/abs/2208.06061 proposes to add a residual for better gradients
+
+        if exists(r):
+            out = out * r + out
+
+        # normformer scaling of heads
+
+        if head_scale:
+            out = out * self.head_scale_params
+
+        # per head gating, from https://arxiv.org/abs/2306.12929
+
+        if exists(self.to_v_head_gate):
+            head_gate = self.to_v_head_gate(x)
+            out = out * rearrange(head_gate, 'b n h -> b h n 1').sigmoid()
+
+        # merge heads
+
+        out = rearrange(out, 'b h n d -> b n (h d)')
+
+        # alphafold2 styled gating of the values
+
+        if exists(self.to_v_gate):
+            gates = self.to_v_gate(x)
+            out = out * self.to_v_gate_activation(gates)
+
+        # combine the heads
+
+        out = self.to_out(out)
+
+        if exists(mask):
+            mask = rearrange(mask, 'b n -> b n 1')
+            out = out.masked_fill(~mask, 0.)
+
+        if not return_intermediates:
+            return out
+
+        intermediates.cached_kv = cached_kv
+
+        return out, intermediates
+
+class AttentionLayers(nn.Module):
+    def __init__(
+        self,
+        dim,
+        depth,
+        heads = 8,
+        causal = False,
+        cross_attend = False,
+        only_cross = False,
+        use_scalenorm = False,
+        use_rmsnorm = False,
+        use_simple_rmsnorm = False,
+        alibi_pos_bias = False,
+        alibi_num_heads = None,
+        rel_pos_bias = False,
+        rel_pos_num_buckets = 32,
+        rel_pos_max_distance = 128,
+        dynamic_pos_bias = False,
+        dynamic_pos_bias_log_distance = False,
+        dynamic_pos_bias_mlp_depth = 2,
+        dynamic_pos_bias_norm = False,
+        rotary_pos_emb = False,
+        rotary_emb_dim = None,
+        rotary_xpos = False,
+        rotary_interpolation_factor = 1.,
+        rotary_xpos_scale_base = 512,
+        rotary_base_rescale_factor = 1.,
+        custom_layers = None,
+        sandwich_coef = None,
+        par_ratio = None,
+        weight_tie_layers = False,   # Albert - https://arxiv.org/abs/1909.11942
+        layers_execute_order = None, # generalizes weight tying, can do arbitrary layer execution orders
+        residual_attn = False,
+        cross_residual_attn = False,
+        macaron = False,
+        pre_norm = True,
+        pre_norm_has_final_norm = True,
+        gate_residual = False,
+        scale_residual = False,
+        scale_residual_constant = 1.,
+        shift_tokens = 0,
+        sandwich_norm = False,
+        resi_dual = False,
+        resi_dual_scale = 1.,
+        zero_init_branch_output = False,
+        layer_dropout = 0.,
+        cross_attn_tokens_dropout = 0.,
+        disable_abs_pos_emb = None,
+        **kwargs
+    ):
+        super().__init__()
+        rotary_pos_emb = rotary_pos_emb or rotary_xpos
+
+        ff_kwargs, kwargs = groupby_prefix_and_trim('ff_', kwargs)
+        attn_kwargs, kwargs = groupby_prefix_and_trim('attn_', kwargs)
+        cross_attn_kwargs, kwargs = groupby_prefix_and_trim('cross_attn_', kwargs)
+
+        dim_head = attn_kwargs.get('dim_head', DEFAULT_DIM_HEAD)
+
+        self.dim = dim
+        self.depth = depth
+        self.causal = causal
+        self.layers = nn.ModuleList([])
+
+        self.disable_abs_pos_emb = default(disable_abs_pos_emb, (rel_pos_bias or rotary_pos_emb))
+
+        rotary_emb_dim = max(default(rotary_emb_dim, dim_head // 2), 32)
+
+        assert not (rotary_xpos and not causal), 'rotary xpos is not compatible with bidirectional attention'
+        self.rotary_pos_emb = RotaryEmbedding(rotary_emb_dim, use_xpos = rotary_xpos, scale_base = rotary_xpos_scale_base, interpolation_factor = rotary_interpolation_factor, base_rescale_factor = rotary_base_rescale_factor) if rotary_pos_emb else None
+
+        assert not (alibi_pos_bias and rel_pos_bias), 'you can only choose Alibi positional bias or T5 relative positional bias, not both'
+        assert rel_pos_num_buckets <= rel_pos_max_distance, 'number of relative position buckets must be less than the relative position max distance'
+
+        # relative positional bias
+
+        flash_attn = attn_kwargs.get('flash', False)
+        assert (int(rel_pos_bias) + int(dynamic_pos_bias) + int(alibi_pos_bias)) <= 1, 'you can only choose up to one of t5, alibi, or dynamic positional bias'
+
+        self.rel_pos = None
+        if rel_pos_bias:
+            assert not flash_attn, 'flash attention not compatible with t5 relative positional bias'
+            self.rel_pos = RelativePositionBias(scale = dim_head ** 0.5, causal = causal, heads = heads, num_buckets = rel_pos_num_buckets, max_distance = rel_pos_max_distance)
+        elif dynamic_pos_bias:
+            assert not flash_attn, 'flash attention not compatible with dynamic positional bias'
+            self.rel_pos = DynamicPositionBias(dim = dim // 4, heads = heads, log_distance = dynamic_pos_bias_log_distance, depth = dynamic_pos_bias_mlp_depth, norm = dynamic_pos_bias_norm)
+        elif alibi_pos_bias:
+            alibi_num_heads = default(alibi_num_heads, heads)
+            assert alibi_num_heads <= heads, 'number of ALiBi heads must be less than the total number of heads'
+            self.rel_pos = AlibiPositionalBias(heads = alibi_num_heads, total_heads = heads)
+
+        assert (int(sandwich_norm) + int(resi_dual)) <= 1, 'either sandwich norm or resiDual is selected, but not both'
+        assert not (not pre_norm and sandwich_norm), 'sandwich norm cannot be used when not using prenorm'
+
+        if resi_dual:
+            pre_norm = False
+
+        self.pre_norm = pre_norm
+        self.sandwich_norm = sandwich_norm
+
+        self.resi_dual = resi_dual
+        assert 0 < resi_dual_scale <= 1., 'resiDual prenorm residual must be scaled by a factor greater than 0 and less than or equal to 1.'
+        self.resi_dual_scale = resi_dual_scale
+
+        self.residual_attn = residual_attn
+        self.cross_residual_attn = cross_residual_attn
+        assert not (flash_attn and (residual_attn or cross_residual_attn)), 'flash attention is not compatible with residual attention'
+
+        self.cross_attend = cross_attend
+
+        assert (int(use_scalenorm) + int(use_rmsnorm) + int(use_simple_rmsnorm)) <= 1, 'you can only use either scalenorm, rmsnorm, or simple rmsnorm'
+
+        if use_scalenorm:
+            norm_class = ScaleNorm
+        elif use_rmsnorm:
+            norm_class = RMSNorm
+        elif use_simple_rmsnorm:
+            norm_class = SimpleRMSNorm
+        else:
+            norm_class = LayerNorm
+
+        norm_fn = partial(norm_class, dim)
+
+        if cross_attend and not only_cross:
+            default_block = ('a', 'c', 'f')
+        elif cross_attend and only_cross:
+            default_block = ('c', 'f')
+        else:
+            default_block = ('a', 'f')
+
+        if macaron:
+            default_block = ('f',) + default_block
+
+        # zero init
+
+        if zero_init_branch_output:
+            attn_kwargs = {**attn_kwargs, 'zero_init_output':  True}
+            ff_kwargs = {**ff_kwargs, 'zero_init_output':  True}
+
+        # setup weight tying, which is a special case of `layer_execute_order`
+
+        assert not (weight_tie_layers and any([*map(exists, (custom_layers, par_ratio, sandwich_coef))]))
+
+        if weight_tie_layers:
+            assert not exists(layers_execute_order)
+            layers_execute_order = tuple(range(len(default_block))) * depth
+            depth = 1
+
+        # calculate layer block order
+
+        if exists(custom_layers):
+            layer_types = custom_layers
+        elif exists(par_ratio):
+            par_depth = depth * len(default_block)
+            assert 1 < par_ratio <= par_depth, 'par ratio out of range'
+            default_block = tuple(filter(not_equals('f'), default_block))
+            par_attn  = par_depth // par_ratio
+            depth_cut = par_depth * 2 // 3  # 2 / 3 attention layer cutoff suggested by PAR paper
+            par_width = (depth_cut + depth_cut // par_attn) // par_attn
+            assert len(default_block) <= par_width, 'default block is too large for par_ratio'
+            par_block = default_block + ('f',) * (par_width - len(default_block))
+            par_head = par_block * par_attn
+            layer_types = par_head + ('f',) * (par_depth - len(par_head))
+        elif exists(sandwich_coef):
+            assert sandwich_coef > 0 and sandwich_coef <= depth, 'sandwich coefficient should be less than the depth'
+            layer_types = ('a',) * sandwich_coef + default_block * (depth - sandwich_coef) + ('f',) * sandwich_coef
+        else:
+            layer_types = default_block * depth
+
+        self.layer_types = layer_types
+        self.layers_execute_order = default(layers_execute_order, tuple(range(len(layer_types))))
+
+        assert all([i < len(self.layer_types) for i in self.layers_execute_order])
+
+        self.num_attn_layers = len(list(filter(equals('a'), layer_types)))
+
+        # stochastic depth
+
+        self.layer_dropouts = cast_tuple(layer_dropout, len(layer_types))
+
+        # structured dropout for cross attending
+
+        self.cross_attn_tokens_dropout = cross_attn_tokens_dropout
+
+        # calculate token shifting
+
+        shift_tokens = cast_tuple(shift_tokens, len(layer_types))
+
+        # whether it has post norm
+
+        self.final_norm = norm_fn() if pre_norm or resi_dual else nn.Identity()
+
+        # iterate and construct layers
+
+        for ind, (layer_type, layer_shift_tokens) in enumerate(zip(self.layer_types, shift_tokens)):
+            is_last_layer = ind == (len(self.layer_types) - 1)
+
+            if layer_type == 'a':
+                layer = Attention(dim, heads = heads, causal = causal, **attn_kwargs)
+            elif layer_type == 'c':
+                layer = Attention(dim, heads = heads, **{**attn_kwargs, **cross_attn_kwargs})
+            elif layer_type == 'f':
+                layer = FeedForward(dim, **ff_kwargs)
+                layer = layer if not macaron else Scale(0.5, layer)
+            else:
+                raise Exception(f'invalid layer type {layer_type}')
+
+            if layer_shift_tokens > 0:
+                shift_range_upper = layer_shift_tokens + 1
+                shift_range_lower = -layer_shift_tokens if not causal else 0
+                layer = ShiftTokens(range(shift_range_lower, shift_range_upper), layer)
+
+            residual_fn = GRUGating if gate_residual else Residual
+            residual = residual_fn(dim, scale_residual = scale_residual, scale_residual_constant = scale_residual_constant)
+
+            pre_branch_norm = norm_fn() if pre_norm else None
+            post_branch_norm = norm_fn() if sandwich_norm else None
+            post_main_norm = norm_fn() if not pre_norm else None
+
+            norms = nn.ModuleList([
+                pre_branch_norm,
+                post_branch_norm,
+                post_main_norm
+            ])
+
+            self.layers.append(nn.ModuleList([
+                norms,
+                layer,
+                residual
+            ]))
+
+    def forward(
+        self,
+        x,
+        context = None,
+        mask = None,
+        context_mask = None,
+        attn_mask = None,
+        self_attn_kv_mask = None,
+        mems = None,
+        mem_masks = None,
+        seq_start_pos: Optional[Tensor] = None,
+        cache: Optional[LayerIntermediates] = None,
+        cache_age = 1,
+        return_hiddens = False,
+        rotary_pos_emb = None
+    ):
+        assert not (self.cross_attend ^ exists(context)), 'context must be passed in if cross_attend is set to True'
+
+        # initialize accums
+
+        hiddens = []
+        layer_hiddens = []
+        intermediates = []
+
+        prev_attn = None
+        prev_cross_attn = None
+
+        mems = mems.copy() if exists(mems) else [None] * self.num_attn_layers
+        mem_masks = mem_masks.copy() if exists(mem_masks) else [None] * self.num_attn_layers
+
+        # handle left padded sequences
+
+        if exists(seq_start_pos):
+            seq_arange = torch.arange(x.shape[-2], device = x.device, dtype = torch.long)
+            left_pad_mask = seq_arange >= seq_start_pos[..., None]
+
+            if exists(self_attn_kv_mask):
+                self_attn_kv_mask = self_attn_kv_mask & left_pad_mask
+            else:
+                self_attn_kv_mask = left_pad_mask
+
+        # rotary positions
+
+        if not exists(rotary_pos_emb) and exists(self.rotary_pos_emb):
+            maybe_mem = mems[0] # todo - handle edge case where different layers get different memory lengths. don't think this will ever come up but who knows
+            mem_len = maybe_mem.shape[1] if exists(maybe_mem) else 0
+
+            pos = torch.arange(x.shape[1] + mem_len, device = x.device) - mem_len
+            rotary_pos_emb = self.rotary_pos_emb(pos)
+
+        # assume cached key / values
+
+        attn_cache = []
+
+        if exists(cache):
+            assert not self.training and self.causal and not any([*map(exists, (mask, attn_mask))])
+
+            if cache_age > 0:
+                x = x[:, -cache_age:] # for spec decoding, may be greater than 1
+
+            attn_cache = cache.attn_intermediates
+
+        iter_attn_cache = iter(attn_cache)
+
+        # outer residual - for resiDual paper
+
+        outer_residual = x * self.resi_dual_scale
+
+        # get layers to be executed
+
+        layer_variables = (
+            self.layer_types,
+            self.layers,
+            self.layer_dropouts
+        )
+
+        layer_variables = tuple(tuple(layer_variable[i] for i in self.layers_execute_order) for layer_variable in layer_variables)
+
+        # go through the attention and feedforward layers
+
+        for ind, (layer_type, (norm, block, residual_fn), layer_dropout) in enumerate(zip(*layer_variables)):
+            is_last = ind == (len(self.layers) - 1)
+
+            if self.training and layer_dropout > 0. and random() < layer_dropout:
+                continue
+
+            if layer_type == 'a':
+                if return_hiddens:
+                    hiddens.append(x)
+
+                layer_mem = mems.pop(0) if mems else None
+                layer_mem_mask = mem_masks.pop(0) if mem_masks else None
+
+            if layer_type == 'c':
+                if self.training and self.cross_attn_tokens_dropout > 0.:
+                    context, context_mask = dropout_seq(context, context_mask, self.cross_attn_tokens_dropout)
+
+            inner_residual = x
+
+            if return_hiddens:
+                layer_hiddens.append(x)
+
+            pre_norm, post_branch_norm, post_main_norm = norm
+
+            if exists(pre_norm):
+                x = pre_norm(x)
+
+                if layer_type == 'a' and exists(layer_mem):
+                    layer_mem = pre_norm(layer_mem)
+
+            if layer_type == 'a':
+                out, inter = block(x, mask = mask, context_mask = self_attn_kv_mask, attn_mask = attn_mask, rel_pos = self.rel_pos, rotary_pos_emb = rotary_pos_emb, prev_attn = prev_attn, cache = next(iter_attn_cache, None), mem = layer_mem, mem_mask = layer_mem_mask, return_intermediates = True)
+            elif layer_type == 'c':
+                out, inter = block(x, context = context, mask = mask, context_mask = context_mask, prev_attn = prev_cross_attn, cache = next(iter_attn_cache, None), return_intermediates = True)
+            elif layer_type == 'f':
+                out = block(x)
+
+            if self.resi_dual:
+                outer_residual = outer_residual + out * self.resi_dual_scale
+
+            if exists(post_branch_norm):
+                out = post_branch_norm(out)
+
+            x = residual_fn(out, inner_residual)
+
+            if layer_type in ('a', 'c') and return_hiddens:
+                intermediates.append(inter)
+
+            if layer_type == 'a' and self.residual_attn:
+                prev_attn = inter.pre_softmax_attn
+            elif layer_type == 'c' and self.cross_residual_attn:
+                prev_cross_attn = inter.pre_softmax_attn
+
+            if exists(post_main_norm):
+                x = post_main_norm(x)
+
+        if return_hiddens:
+            layer_hiddens.append(x)
+
+        if self.resi_dual:
+            x = x + self.final_norm(outer_residual)
+        else:
+            x = self.final_norm(x)
+
+        if not return_hiddens:
+            return x
+
+        intermediates = LayerIntermediates(
+            hiddens = hiddens,
+            last_hidden = x,
+            attn_intermediates = intermediates,
+            layer_hiddens = layer_hiddens,
+        )
+
+        return x, intermediates
+
+class Encoder(AttentionLayers):
+    def __init__(self, **kwargs):
+        assert 'causal' not in kwargs, 'cannot set causality on encoder'
+        super().__init__(causal = False, **kwargs)
+
+class Decoder(AttentionLayers):
+    def __init__(self, **kwargs):
+        assert 'causal' not in kwargs, 'cannot set causality on decoder'
+        super().__init__(causal = True, **kwargs)
+
+class PrefixDecoder(AttentionLayers):
+    def __init__(self, **kwargs):
+        assert 'causal' not in kwargs, 'cannot set causality on decoder'
+        super().__init__(causal = False, **kwargs)
+
+    def forward(
+        self,
+        x,
+        *args,
+        attn_mask = None,
+        prefix_attn_len = None,
+        **kwargs
+    ):
+        b, n, device = x.shape[0], x.shape[1], x.device
+        causal_mask = torch.ones((n, n), device = device, dtype = torch.bool).triu(1)
+
+        forwarded_mask = ~causal_mask
+
+        if exists(prefix_attn_len):
+            if isinstance(prefix_attn_len, int):
+                prefix_attn_len = torch.full((b,), prefix_attn_len, device = device)
+
+            prefix_mask = torch.arange(n, device = device) < rearrange(prefix_attn_len, 'b -> b 1 1 1')
+            forwarded_mask = forwarded_mask | prefix_mask
+
+        if exists(attn_mask):
+            forwarded_mask = forwarded_mask & attn_mask
+
+        return super().forward(x, *args, attn_mask = forwarded_mask, **kwargs)
+
+class CrossAttender(AttentionLayers):
+    def __init__(self, **kwargs):
+        super().__init__(cross_attend = True, only_cross = True, **kwargs)
+
+class ViTransformerWrapper(nn.Module):
+    def __init__(
+        self,
+        *,
+        image_size,
+        patch_size,
+        attn_layers: Encoder,
+        channels = 3,
+        num_classes = None,
+        post_emb_norm = False,
+        num_register_tokens = 0,
+        emb_dropout = 0.
+    ):
+        super().__init__()
+        assert divisible_by(image_size, patch_size), 'image dimensions must be divisible by the patch size'
+        dim = attn_layers.dim
+        num_patches = (image_size // patch_size) ** 2
+        patch_dim = channels * patch_size ** 2
+
+        self.patch_size = patch_size
+
+        self.pos_embedding = nn.Parameter(torch.randn(1, num_patches, dim))
+
+        has_register_tokens = num_register_tokens > 0
+        self.has_register_tokens = has_register_tokens
+
+        if has_register_tokens:
+            self.register_tokens = nn.Parameter(torch.randn(num_register_tokens, dim))
+
+        self.patch_to_embedding = nn.Sequential(
+            LayerNorm(patch_dim),
+            nn.Linear(patch_dim, dim),
+            LayerNorm(dim)
+        )
+
+        self.post_emb_norm = LayerNorm(dim) if post_emb_norm else nn.Identity()
+        self.dropout = nn.Dropout(emb_dropout)
+
+        self.attn_layers = attn_layers
+
+        self.mlp_head = nn.Linear(dim, num_classes) if exists(num_classes) else nn.Identity()
+
+    def forward(
+        self,
+        img,
+        return_embeddings = False,
+        return_logits_and_embeddings = False
+    ):
+        b, p = img.shape[0], self.patch_size
+
+        x = rearrange(img, 'b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = p, p2 = p)
+        x = self.patch_to_embedding(x)
+        n = x.shape[1]
+
+        x = x + self.pos_embedding[:, :n]
+
+        x = self.post_emb_norm(x)
+        x = self.dropout(x)
+
+        if self.has_register_tokens:
+            r = repeat(self.register_tokens, 'n d -> b n d', b = b)
+            x, ps = pack((x, r), 'b * d')
+
+        embed = self.attn_layers(x)
+
+        if self.has_register_tokens:
+            embed, _ = unpack(embed, ps, 'b * d')
+
+        assert at_most_one_of(return_embeddings, return_logits_and_embeddings)
+
+        if not exists(self.mlp_head) or return_embeddings:
+            return embed
+
+        pooled = embed.mean(dim = -2)
+        logits = self.mlp_head(pooled)
+
+        if not return_logits_and_embeddings:
+            return logits
+
+        return logits, embed
+
+class TransformerWrapper(nn.Module):
+    def __init__(
+        self,
+        *,
+        num_tokens,
+        max_seq_len,
+        attn_layers: AttentionLayers,
+        embed_num_tokens: Dict[str, int] = dict(),
+        emb_dim = None,
+        max_mem_len = 0,
+        shift_mem_down = 0,
+        emb_dropout = 0.,
+        post_emb_norm = False,
+        num_memory_tokens = None,
+        memory_tokens_interspersed_every = None,
+        tie_embedding = False,
+        logits_dim = None,
+        use_abs_pos_emb = True,
+        scaled_sinu_pos_emb = False,
+        l2norm_embed = False,
+        emb_frac_gradient = 1., # GLM-130B and Cogview successfully used this, set at 0.1
+        attn_z_loss_weight = 1e-4,
+    ):
+        super().__init__()
+
+        dim = attn_layers.dim
+        emb_dim = default(emb_dim, dim)
+        self.emb_dim = emb_dim
+        self.num_tokens = num_tokens
+
+        self.max_seq_len = max_seq_len
+        self.max_mem_len = max_mem_len
+        self.shift_mem_down = shift_mem_down
+
+        self.l2norm_embed = l2norm_embed
+        self.token_emb = TokenEmbedding(emb_dim, num_tokens, l2norm_embed = l2norm_embed)
+
+        no_abs_pos_emb = max_seq_len == 0 or not (use_abs_pos_emb and not attn_layers.disable_abs_pos_emb)
+
+        if no_abs_pos_emb:
+            self.pos_emb = always(0)
+        elif scaled_sinu_pos_emb:
+            self.pos_emb = ScaledSinusoidalEmbedding(emb_dim)
+        else:
+            self.pos_emb = AbsolutePositionalEmbedding(emb_dim, max_seq_len, l2norm_embed = l2norm_embed)
+
+        # additional embeddings - say type embedding from BERT
+
+        self.embeds = None
+
+        if len(embed_num_tokens) > 0:
+            self.embeds = nn.ModuleDict({f'{name}_embed': nn.Embedding(num_tokens, emb_dim) for name, num_tokens in embed_num_tokens.items()})
+
+        # fraction of the gradient that should go to the embedding, https://arxiv.org/abs/2105.13290
+
+        self.emb_frac_gradient = emb_frac_gradient
+
+        self.post_emb_norm = LayerNorm(emb_dim) if post_emb_norm else nn.Identity()
+        self.emb_dropout = nn.Dropout(emb_dropout)
+
+        self.project_emb = nn.Linear(emb_dim, dim) if emb_dim != dim else nn.Identity()
+        self.attn_layers = attn_layers
+
+        self.init_()
+
+        logits_dim = default(logits_dim, num_tokens)
+        self.to_logits = nn.Linear(dim, logits_dim, bias = False) if not tie_embedding else lambda t: t @ self.token_emb.emb.weight.t()
+
+        # memory tokens (like [cls]) from Memory Transformers paper
+
+        num_memory_tokens = default(num_memory_tokens, 0)
+        self.num_memory_tokens = num_memory_tokens
+        if num_memory_tokens > 0:
+            self.memory_tokens = nn.Parameter(torch.randn(num_memory_tokens, dim))
+
+        self.memory_tokens_interspersed_every = memory_tokens_interspersed_every
+
+        # whether can do cached kv decoding
+
+        self.can_cache_kv = self.num_memory_tokens == 0
+        self.can_cache_kv_outside_max_seq_len = no_abs_pos_emb
+
+    def init_(self):
+        if self.l2norm_embed:
+            nn.init.normal_(self.token_emb.emb.weight, std = 1e-5)
+            if not isinstance(self.pos_emb, always):
+                nn.init.normal_(self.pos_emb.emb.weight, std = 1e-5)
+            return
+
+        nn.init.kaiming_normal_(self.token_emb.emb.weight)
+
+    def forward(
+        self,
+        x,
+        return_embeddings = False,
+        return_logits_and_embeddings = False,
+        return_intermediates = False,
+        mask = None,
+        return_mems = False,
+        return_attn = False,
+        mems = None,
+        mem_masks = None,
+        pos = None,
+        prepend_embeds = None,
+        prepend_mask = None,
+        embed_ids: Dict[str, Tensor] = dict(),
+        sum_embeds = None,
+        return_attn_z_loss = False,
+        attn_z_loss_weight = 1e-4,
+        seq_start_pos = None,
+        cache: Optional[LayerIntermediates] = None,
+        **kwargs
+    ):
+        b, n, device, num_mems, has_memory_tokens, emb_frac_gradient = x.shape[0], x.shape[1], x.device, self.num_memory_tokens, self.num_memory_tokens > 0, self.emb_frac_gradient
+        return_hiddens = return_mems | return_attn | return_intermediates | return_attn_z_loss
+
+        # absolute positional embedding
+
+        external_pos_emb = exists(pos) and pos.dtype != torch.long
+        pos_emb = self.pos_emb(x, pos = pos, seq_start_pos = seq_start_pos) if not external_pos_emb else pos
+        x = self.token_emb(x) + pos_emb
+
+        # add additional embeddings
+
+        if exists(self.embeds):
+            assert len(embed_ids) == len(self.embeds)
+
+            for name, embed_id in embed_ids.items():
+                embed_key = f'{name}_embed'
+
+                assert embed_key in self.embeds
+                embed = self.embeds[embed_key](embed_id)
+
+                x = x + embed
+
+        # for summing embeddings passed externally - needs this for self-conditioning in non-autoregressive training
+
+        if exists(sum_embeds):
+            x = x + sum_embeds
+
+        # post embedding norm, purportedly leads to greater stabilization
+
+        x = self.post_emb_norm(x)
+
+        # whether to append embeds, as in PaLI, for image embeddings
+
+        if exists(prepend_embeds):
+            prepend_seq, prepend_dim = prepend_embeds.shape[1:]
+            assert prepend_dim == x.shape[-1], 'prepended embeddings need to have same dimensions as text model dimensions'
+
+            x = torch.cat((prepend_embeds, x), dim = -2)
+
+            if exists(prepend_mask) or exists(mask):
+                mask = default(mask, lambda: torch.ones((b, n), device = device, dtype = torch.bool))
+                prepend_mask = default(prepend_mask, lambda: torch.ones((b, prepend_seq), device = device, dtype = torch.bool))
+
+                mask = torch.cat((prepend_mask, mask), dim = -1)
+
+        # whether to reduce the gradient going to the embedding, from cogview paper, corroborated by GLM-130B model
+
+        if emb_frac_gradient < 1:
+            assert emb_frac_gradient > 0
+            x = x * emb_frac_gradient + x.detach() * (1 - emb_frac_gradient)
+
+        # embedding dropout
+
+        x = self.emb_dropout(x)
+
+        x = self.project_emb(x)
+
+        if has_memory_tokens:
+            mem_every = self.memory_tokens_interspersed_every
+
+            if exists(mem_every):
+                assert mem_every > 0
+                assert isinstance(self.attn_layers, Decoder), 'only for decoder'
+                next_seq_len = math.ceil(n / mem_every) * mem_every
+
+                x = pad_at_dim(x, (0, next_seq_len - n), dim = -2, value = 0.)
+                x = rearrange(x, 'b (n m) d -> (b n) m d', m = mem_every)
+
+            mem = repeat(self.memory_tokens, 'n d -> b n d', b = x.shape[0])
+            x, mem_packed_shape = pack((mem, x), 'b * d')
+
+            # auto-handle masking after appending memory tokens
+            if not exists(mem_every) and exists(mask):
+                mask = pad_at_dim(mask, (num_mems, 0), dim = -1, value = True)
+
+            if exists(mem_every):
+                x = rearrange(x, '(b n) m d -> b (n m) d', b = b)
+
+        if self.shift_mem_down and exists(mems):
+            mems_l, mems_r = mems[:self.shift_mem_down], mems[self.shift_mem_down:]
+            mems = [*mems_r, *mems_l]
+
+        x, intermediates = self.attn_layers(x, mask = mask, mems = mems, mem_masks = mem_masks, cache = cache, return_hiddens = True, seq_start_pos = seq_start_pos, **kwargs)
+
+        if has_memory_tokens:
+            if exists(mem_every):
+                x = rearrange(x, 'b (n m) d -> (b n) m d', m = (mem_every + num_mems))
+
+            mem, x = unpack(x, mem_packed_shape, 'b * d')
+
+            intermediates.memory_tokens = mem
+
+            if exists(mem_every):
+                x = rearrange(x, '(b n) m d -> b (n m) d', b = b)
+
+            x = x[:, :n]
+
+        if return_logits_and_embeddings:
+            out = (self.to_logits(x), x)
+        elif return_embeddings:
+            out = x
+        else:
+            out = self.to_logits(x)
+
+        if return_attn_z_loss:
+            pre_softmax_attns = list(map(lambda t: t.pre_softmax_attn, intermediates.attn_intermediates))
+            intermediates.attn_z_loss = calc_z_loss(pre_softmax_attns, weight = attn_z_loss_weight)
+            return_intermediates = True
+
+        if return_mems:
+            hiddens = intermediates.hiddens
+            new_mems = list(map(lambda pair: torch.cat(pair, dim = -2), zip(mems, hiddens))) if exists(mems) else hiddens
+            new_mems = list(map(lambda t: t[..., -self.max_mem_len:, :].detach(), new_mems))
+
+            if not return_intermediates:
+                return out, new_mems
+
+            intermediates.mems = new_mems
+
+        if return_intermediates:
+            return out, intermediates
+
+        if return_attn:
+            attn_maps = list(map(lambda t: t.post_softmax_attn, intermediates.attn_intermediates))
+            return out, attn_maps
+
+        return out
+
+class XTransformer(nn.Module):
+    def __init__(
+        self,
+        *,
+        dim,
+        tie_token_emb = False,
+        ignore_index = -100,
+        pad_value = 0,
+        cross_attn_tokens_dropout = 0.,
+        **kwargs
+    ):
+        super().__init__()
+        enc_kwargs, kwargs = groupby_prefix_and_trim('enc_', kwargs)
+        dec_kwargs, kwargs = groupby_prefix_and_trim('dec_', kwargs)
+
+        assert 'dim' not in enc_kwargs and 'dim' not in dec_kwargs, 'dimension of either encoder or decoder must be set with `dim` keyword'
+        enc_transformer_kwargs = pick_and_pop(['num_tokens', 'max_seq_len'], enc_kwargs)
+        enc_transformer_kwargs['emb_dropout'] = enc_kwargs.pop('emb_dropout', 0)
+        enc_transformer_kwargs['num_memory_tokens'] = enc_kwargs.pop('num_memory_tokens', None)
+        enc_transformer_kwargs['scaled_sinu_pos_emb'] = enc_kwargs.pop('scaled_sinu_pos_emb', False)
+        enc_transformer_kwargs['use_abs_pos_emb'] = enc_kwargs.pop('use_abs_pos_emb', True)
+
+        dec_transformer_kwargs = pick_and_pop(['num_tokens', 'max_seq_len'], dec_kwargs)
+        dec_transformer_kwargs['emb_dropout'] = dec_kwargs.pop('emb_dropout', 0)
+        dec_transformer_kwargs['scaled_sinu_pos_emb'] = dec_kwargs.pop('scaled_sinu_pos_emb', False)
+        dec_transformer_kwargs['use_abs_pos_emb'] = dec_kwargs.pop('use_abs_pos_emb', True)
+
+        self.cross_attn_tokens_dropout = cross_attn_tokens_dropout  # how many tokens from the encoder to dropout when cross attending from decoder - seen in a couple papers, including Perceiver AR - this will also be very effective regularization when cross attending to very long memories
+
+        self.encoder = TransformerWrapper(
+            **enc_transformer_kwargs,
+            attn_layers = Encoder(dim = dim, **enc_kwargs)
+        )
+
+        self.decoder = TransformerWrapper(
+            **dec_transformer_kwargs,
+            attn_layers = Decoder(dim = dim, cross_attend = True, **dec_kwargs)
+        )
+
+        if tie_token_emb:
+            self.decoder.token_emb = self.encoder.token_emb
+
+        self.decoder = AutoregressiveWrapper(self.decoder, ignore_index=ignore_index, pad_value=pad_value)
+
+    @torch.no_grad()
+    def generate(self, seq_in, seq_out_start, seq_len, mask = None, attn_mask = None, **kwargs):
+        encodings = self.encoder(seq_in, mask = mask, attn_mask = attn_mask, return_embeddings = True)
+        return self.decoder.generate(seq_out_start, seq_len, context = encodings, context_mask = mask, **kwargs)
+
+    def forward(self, src, tgt, mask = None, attn_mask = None, src_prepend_embeds = None):
+
+        enc = self.encoder(src, mask = mask, attn_mask = attn_mask, prepend_embeds = src_prepend_embeds, return_embeddings = True)
+
+        if exists(src_prepend_embeds) and exists(mask):
+            mask = pad_at_dim(mask, (src_prepend_embeds.shape[-2], 0), dim = -1, value = True)
+
+        if self.training and self.cross_attn_tokens_dropout > 0:
+            enc, mask = dropout_seq(enc, mask, self.cross_attn_tokens_dropout)
+
+        out = self.decoder(tgt, context = enc, context_mask = mask)
+        return out
+
+################################################################################
+
+################################################################################
+# Code for x-transformers Python module continuous.py
+################################################################################
+
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+from einops import pack, repeat, unpack
+
+# helper functions
+
+def exists(val):
+    return val is not None
+
+def default(val, d):
+    if exists(val):
+        return val
+    return d() if callable(d) else d
+
+# main classes
+
+class ContinuousTransformerWrapper(nn.Module):
+    def __init__(
+        self,
+        *,
+        max_seq_len,
+        attn_layers: AttentionLayers,
+        dim_in = None,
+        dim_out = None,
+        emb_dim = None,
+        max_mem_len = 0,
+        num_memory_tokens = None,
+        post_emb_norm = False,
+        emb_dropout = 0.,
+        use_abs_pos_emb = True,
+        scaled_sinu_pos_emb = False
+    ):
+        super().__init__()
+        dim = attn_layers.dim
+
+        self.max_seq_len = max_seq_len
+
+        self.max_mem_len = max_mem_len
+
+        if not (use_abs_pos_emb and not attn_layers.disable_abs_pos_emb):
+            self.pos_emb = always(0)
+        elif scaled_sinu_pos_emb:
+            self.pos_emb = ScaledSinusoidalEmbedding(dim)
+        else:
+            self.pos_emb = AbsolutePositionalEmbedding(dim, max_seq_len)
+
+        self.post_emb_norm = LayerNorm(dim) if post_emb_norm else nn.Identity()
+        self.emb_dropout = nn.Dropout(emb_dropout)
+
+        # memory tokens
+
+        num_memory_tokens = default(num_memory_tokens, 0)
+        self.has_memory_tokens = num_memory_tokens > 0
+
+        if num_memory_tokens > 0:
+            self.memory_tokens = nn.Parameter(torch.randn(num_memory_tokens, dim))
+
+        # attention layers
+
+        self.attn_layers = attn_layers
+
+        # project in and out
+
+        self.project_in = nn.Linear(dim_in, dim, bias = False) if exists(dim_in) else nn.Identity()
+        self.project_out = nn.Linear(dim, dim_out, bias = False) if exists(dim_out) else nn.Identity()
+
+    def forward(
+        self,
+        x,
+        return_embeddings = False,
+        return_intermediates = False,
+        return_mems = False,
+        mask = None,
+        return_attn = False,
+        mems = None,
+        mem_masks = None,
+        pos = None,
+        prepend_embeds = None,
+        prepend_mask = None,
+        **kwargs
+    ):
+        batch, seq, device = *x.shape[:2], x.device
+
+        x = self.project_in(x)
+        x = x + self.pos_emb(x, pos = pos)
+
+        x = self.post_emb_norm(x)
+
+        # memory tokens
+
+        if self.has_memory_tokens:
+            m = repeat(self.memory_tokens, 'm d -> b m d', b = batch)
+            x, mem_ps = pack([m, x], 'b * d')
+
+            if exists(mask):
+                num_mems = m.shape[-2]
+                mask = pad_at_dim(mask, (num_mems, 0), dim = -1, value = True)
+
+        # whether to append embeds, as in PaLI, for image embeddings
+
+        if exists(prepend_embeds):
+            prepend_seq, prepend_dim = prepend_embeds.shape[1:]
+
+            assert prepend_dim == x.shape[-1], 'prepended embeddings need to have same dimensions as model dimensions'
+
+            x = torch.cat((prepend_embeds, x), dim = -2)
+
+            if exists(prepend_mask) or exists(mask):
+                mask = default(mask, lambda: torch.ones((batch, seq), device = device, dtype = torch.bool))
+                prepend_mask = default(prepend_mask, lambda: torch.ones((batch, prepend_seq), device = device, dtype = torch.bool))
+
+                mask = torch.cat((prepend_mask, mask), dim = -1)
+
+        x = self.emb_dropout(x)
+
+        # attention layers
+
+        x, intermediates = self.attn_layers(x, mask = mask, mems = mems, mem_masks = mem_masks, return_hiddens = True, **kwargs)
+
+        # splice out memory tokens
+
+        if self.has_memory_tokens:
+            m, x = unpack(x, mem_ps, 'b * d')
+            intermediates.memory_tokens = m
+
+        out = self.project_out(x) if not return_embeddings else x
+
+        if return_intermediates:
+            return out, intermediates
+
+        if return_mems:
+            hiddens = intermediates.hiddens
+            new_mems = list(map(lambda t: t[..., -self.max_mem_len:, :].detach(), hiddens))
+            return out, new_mems
+
+        if return_attn:
+            attn_maps = list(map(lambda t: t.post_softmax_attn, intermediates.attn_intermediates))
+            return out, attn_maps
+
+        return out
+
+class ContinuousAutoregressiveWrapper(nn.Module):
+    def __init__(
+        self,
+        net: ContinuousTransformerWrapper,
+        ignore_index = -100,
+        pad_value = 0,
+        loss_fn = nn.MSELoss(reduction = 'none')
+    ):
+        super().__init__()
+        self.net = net
+        self.max_seq_len = net.max_seq_len
+        self.loss_fn = loss_fn
+
+    @torch.no_grad()
+    def generate(self, start_tokens, seq_len, **kwargs):
+        device = start_tokens.device
+        was_training = self.net.training
+        num_dims = len(start_tokens.shape)
+
+        assert num_dims >= 2, 'number of dimensions of your start tokens must be greater or equal to 2'
+
+        if num_dims == 2:
+            start_tokens = start_tokens[None, :]        
+
+        b, t, _, device = *start_tokens.shape, start_tokens.device
+
+        self.net.eval()
+        out = start_tokens
+
+        for _ in range(seq_len):
+            x = out[:, -self.max_seq_len:]
+
+            last = self.net(x, **kwargs)[:, -1:]
+            out = torch.cat((out, last), dim = -2)
+
+        out = out[:, t:]
+
+        if num_dims == 2:
+            out = out.squeeze(0)
+
+        self.net.train(was_training)
+        return out
+
+    def forward(self, x, **kwargs):
+        inp, target = x[:, :-1], x[:, 1:]
+
+        assert 'prepend_embeds' not in kwargs
+
+        mask = kwargs.get('mask', None)
+        if exists(mask) and mask.shape[1] == x.shape[1]:
+            mask = mask[:, :-1]
+            kwargs['mask'] = mask
+
+        out = self.net(inp, **kwargs)
+
+        loss = self.loss_fn(out, target)
+
+        if exists(mask):
+            assert loss.ndim > 1, 'loss should not be reduced if mask is passed in'
+            loss = loss[mask]
+
+        return loss.mean()
+
+################################################################################
+
+################################################################################
+# Code for x-transformers Python module dpo.py
+################################################################################
+
+from copy import deepcopy
+
+import torch
+from torch.nn import Module
+import torch.nn.functional as F
+
+from einops import rearrange
+
+# helper functions
+
+def exists(v):
+    return v is not None
+
+def freeze_all_layers_(module):
+    for param in module.parameters():
+        param.requires_grad = False
+
+def log_prob_from_model_and_seq(model, seq):
+    logits = model(seq)
+    log_prob = logits.log_softmax(dim = -1)
+    indices = rearrange(seq, '... -> ... 1')
+    log_probs = log_prob.gather(-1, indices)
+    return rearrange(log_probs, '... 1 -> ...')
+
+def masked_mean(log_probs, mask = None):
+    if not exists(mask):
+        return log_probs.mean(dim = -1)
+
+    log_probs = log_probs.masked_fill(~mask, 0.)
+    num = log_probs.sum(dim = -1)
+    den = mask.sum(dim = -1)
+    return num / den.clamp(min = 1e-5)
+
+def maybe_and_mask(*masks):
+    masks = [*filter(exists, masks)]
+    if len(masks) == 0:
+        return None
+
+    mask, *rest_masks = masks
+    for rest_mask in rest_masks:
+        mask = mask & rest_mask
+
+    return mask
+
+# main class
+
+class DPO(Module):
+    def __init__(
+        self,
+        model: TransformerWrapper,
+        *,
+        beta = 0.1,
+        pad_id = None
+    ):
+        super().__init__()
+        self.policy_model = model
+
+        self.ref_model = deepcopy(model)
+        freeze_all_layers_(self.ref_model)
+
+        self.beta = beta
+        self.pad_id = pad_id
+
+    def parameters(self):
+        return self.policy_model.parameters()
+
+    def forward(
+        self,
+        preferred_seq,
+        unpreferred_seq,
+        *,
+        prompt_mask,
+        preferred_seq_mask = None,
+        unpreferred_seq_mask = None,
+    ):
+        assert preferred_seq.ndim == 2
+        assert preferred_seq.shape == unpreferred_seq.shape
+
+        if exists(self.pad_id):
+            if not exists(preferred_seq_mask):
+                preferred_seq_mask = preferred_seq != self.pad_id
+
+            if not exists(unpreferred_seq_mask):
+                unpreferred_seq_mask = unpreferred_seq != self.pad_id
+
+        """
+        Following Appendix B in https://arxiv.org/abs/2305.18290
+        """
+
+        with torch.no_grad():
+            self.ref_model.eval()
+            ref_preferred_logprob = log_prob_from_model_and_seq(self.ref_model, preferred_seq)
+            ref_unpreferred_logprob = log_prob_from_model_and_seq(self.ref_model, unpreferred_seq)
+
+        policy_preferred_logprob = log_prob_from_model_and_seq(self.policy_model, preferred_seq)
+        policy_unpreferred_logprob = log_prob_from_model_and_seq(self.policy_model, unpreferred_seq)
+
+        # masked mean of log probs
+
+        preferred_seq_mask = maybe_and_mask(~prompt_mask, preferred_seq_mask)
+        unpreferred_seq_mask = maybe_and_mask(~prompt_mask, unpreferred_seq_mask)
+
+        ref_preferred_logprob, policy_preferred_logprob = map(lambda t: masked_mean(t, preferred_seq_mask), (ref_preferred_logprob, policy_preferred_logprob))
+        ref_unpreferred_logprob, policy_unpreferred_logprob = map(lambda t: masked_mean(t, unpreferred_seq_mask), (ref_unpreferred_logprob, policy_unpreferred_logprob))
+
+        # main dpo formula
+
+        policy_logratios = policy_preferred_logprob - policy_unpreferred_logprob
+        ref_logratios = ref_preferred_logprob - ref_unpreferred_logprob
+
+        losses = -F.logsigmoid(self.beta * (policy_logratios - ref_logratios))
+
+        return losses.mean()
+
+################################################################################
+
+################################################################################
+# Code for x-transformers Python module nonautoregressive_wrapper.py
+################################################################################
+
+import math
+from random import random
+from contextlib import nullcontext
+from collections import namedtuple
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from einops import rearrange, repeat, pack, unpack
+
+from typing import Optional
+
+# constants
+
+Losses = namedtuple('Losses', ['loss', 'generator_loss', 'critic_loss'])
+
+# helper functions
+
+def exists(val):
+    return val is not None
+
+def default(val, d):
+    return val if exists(val) else d
+
+# sampling helpers
+
+def top_k(logits, thres = 0.9):
+    k = math.ceil((1 - thres) * logits.shape[-1])
+    val, ind = logits.topk(k, dim = -1)
+    probs = torch.full_like(logits, float('-inf'))
+    probs.scatter_(2, ind, val)
+    return probs
+
+def log(t, eps = 1e-10):
+    return torch.log(t + eps)
+
+def gumbel_noise(t):
+    noise = torch.zeros_like(t).uniform_(0, 1)
+    return -log(-log(noise))
+
+def gumbel_sample(t, temperature = 1., dim = -1):
+    return ((t / max(temperature, 1e-10)) + gumbel_noise(t)).argmax(dim = dim)
+
+# prob helpers
+
+def sample_prob(prob):
+    return random() < prob
+
+def coin_flip():
+    return sample_prob(0.5)
+
+# tensor helpers
+
+def get_mask_subset_prob(mask, prob, min_mask = 0):
+    batch, seq, device = *mask.shape, mask.device
+    num_to_mask = (mask.sum(dim = -1, keepdim = True) * prob).clamp(min = min_mask)
+    logits = torch.rand((batch, seq), device = device)
+    logits = logits.masked_fill(~mask, -1)
+
+    randperm = logits.argsort(dim = -1).float()
+
+    num_padding = (~mask).sum(dim = -1, keepdim = True)
+    randperm -= num_padding
+
+    subset_mask = randperm < num_to_mask
+    subset_mask.masked_fill_(~mask, False)
+    return subset_mask
+
+# schedules
+
+def linear_schedule(t):
+    return 1 - t
+
+def cosine_schedule(t):
+    """ https://arxiv.org/abs/2202.04200 """
+    return torch.cos(t * math.pi / 2)
+
+# self token critic
+# inspired by Nijkamp et al. - https://aclanthology.org/2021.naacl-main.409/
+
+class SelfCritic(nn.Module):
+    def __init__(self, net):
+        super().__init__()
+        self.net = net
+
+        dim = net.attn_layers.dim
+        self.to_logits = nn.Linear(dim, 1)
+
+    def forward(self, x):
+        embed = self.net(x, return_embeddings = True)
+        return self.to_logits(embed)
+
+class NonAutoregressiveWrapper(nn.Module):
+    """
+    https://arxiv.org/abs/1904.09324
+    https://arxiv.org/abs/2202.04200
+    """
+
+    def __init__(
+        self,
+        net,
+        *,
+        mask_id,
+        steps = 18,
+        self_cond = False,
+        self_cond_train_prob = 0.75,
+        no_replace_prob = 0.15,          # which percentage of the tokens masked will stay the same, done in original MLM paper
+        random_token_prob = 0.1,         # which percentage of tokens to be replaced with random token, done in original MLM paper
+        schedule = 'linear',
+        can_mask_prev_unmasked = False,  # when unmasking, whether it can remask previously unmasked
+        token_critic: Optional[TransformerWrapper] = None,
+        self_token_critic = False,
+        critic_loss_weight = 1.
+    ):
+        super().__init__()
+        assert not (self_token_critic and exists(token_critic))
+
+        self.net = net
+
+        dim = net.emb_dim
+        self.dim = dim
+        self.num_tokens = net.num_tokens
+
+        self.mask_id = mask_id
+
+        # afaict, maskgit paper did not do this
+        # but may help for self conditioning, as used successfully in original BERT
+
+        self.no_replace_prob = no_replace_prob
+        self.random_token_prob = random_token_prob
+
+        self.max_seq_len = net.max_seq_len
+        self.steps = steps
+
+        if callable(schedule):
+            self.schedule_fn = schedule
+        if schedule == 'linear':
+            self.schedule_fn = linear_schedule
+        elif schedule == 'cosine':
+            self.schedule_fn = cosine_schedule
+        else:
+            raise ValueError(f'invalid schedule {schedule}')
+
+        self.can_mask_prev_unmasked = can_mask_prev_unmasked
+
+        # self conditioning
+
+        self.self_cond = self_cond
+
+        if self_cond:
+            self.null_embed = nn.Parameter(torch.randn(dim))
+            self.to_self_cond = nn.Linear(dim, dim, bias = False) if self_cond else None
+            self.self_cond_train_prob = self_cond_train_prob
+
+        # token critic
+
+        self.token_critic = token_critic
+
+        if self_token_critic:
+            self.token_critic = SelfCritic(net)
+
+        self.critic_loss_weight = critic_loss_weight
+
+    @torch.no_grad()
+    def generate(
+        self,
+        batch_size = None,
+        start_temperature = 1.,
+        filter_thres = 0.7,
+        noise_level_scale = 1.,
+        **kwargs
+    ):
+        sample_one = not exists(batch_size)
+        batch_size = default(batch_size, 1)
+
+        device = next(self.net.parameters()).device
+
+        was_training = self.training
+        self.eval()
+
+        times = torch.linspace(0., 1., self.steps + 1)
+
+        # sequence starts off as all masked
+
+        shape = (batch_size, self.max_seq_len)
+
+        seq = torch.full(shape, self.mask_id, device = device)
+        mask = torch.full(shape, True, device = device)
+
+        # slowly demask
+
+        all_mask_num_tokens = (self.schedule_fn(times[1:]) * self.max_seq_len).long()
+
+        # self conditioning
+
+        has_self_cond = self.self_cond
+        last_embed = self.null_embed if has_self_cond else None
+
+        for mask_num_tokens, steps_until_x0 in zip(all_mask_num_tokens.tolist(), reversed(range(self.steps))):
+
+            self_cond = self.to_self_cond(last_embed) if has_self_cond else None
+
+            logits, embeds = self.net(
+                seq,
+                sum_embeds = self_cond,
+                return_logits_and_embeddings = True,
+                **kwargs
+            )
+
+            if has_self_cond:
+                last_embed = embeds
+
+            if exists(filter_thres):
+                logits = top_k(logits, filter_thres)
+
+            annealing_scale = steps_until_x0 / self.steps
+            temperature = start_temperature * annealing_scale
+
+            probs = (logits / max(temperature, 1e-3)).softmax(dim = -1)
+
+            sampled_ids = gumbel_sample(logits, temperature = max(temperature, 1e-3))
+
+            seq = torch.where(mask, sampled_ids, seq)
+
+            if exists(self.token_critic):
+                scores = self.token_critic(seq)
+                scores = rearrange(scores, 'b n 1 -> b n')
+                scores = scores + noise_level_scale * gumbel_noise(scores) * annealing_scale
+            else:
+                scores = 1 - logits.softmax(dim = -1)
+                scores = scores.gather(2, rearrange(sampled_ids, 'b n -> b n 1'))
+                scores = rearrange(scores, 'b n 1 -> b n')
+
+            if mask_num_tokens == 0:
+                pass
+
+            if not self.can_mask_prev_unmasked:
+                scores = scores.masked_fill(~mask, -torch.finfo(scores.dtype).max)
+
+            mask_indices = scores.topk(mask_num_tokens, dim = -1).indices
+            mask = torch.zeros_like(scores, dtype = torch.bool).scatter(1, mask_indices, True)
+            seq = seq.masked_fill(mask, self.mask_id)
+
+        self.train(was_training)
+
+        if sample_one:
+            seq = rearrange(seq, '1 n -> n')
+
+        return seq
+
+    def forward(
+        self,
+        x,
+        only_train_generator = False,
+        only_train_critic = False,
+        generator_sample_temperature = None,
+        **kwargs
+    ):
+        b, n, device = *x.shape, x.device
+        assert n == self.max_seq_len
+
+        orig_seq = x.clone()
+
+        rand_times = torch.empty(b, device = device).uniform_(0, 1)
+        batched_randperm = torch.rand((b, n), device = device).argsort(dim = -1).float()
+
+        rand_probs = self.schedule_fn(rand_times)
+        num_tokens_mask = (rand_probs * n).clamp(min = 1.)
+        mask = batched_randperm < rearrange(num_tokens_mask, 'b -> b 1')
+
+        # to ensure all tokens produce embeddings, instead of just the ones with [mask] input, as done in seminal BERT MLM paper
+        # potentially needed for self-conditioning (on embedding) to work well
+
+        replace_mask_id_mask = mask.clone()
+        frac_seq_left = 1.
+
+        if self.no_replace_prob > 0. and coin_flip():
+            frac_seq_left -= self.no_replace_prob
+
+            no_replace_prob_mask = get_mask_subset_prob(mask, self.no_replace_prob)
+            replace_mask_id_mask &= ~no_replace_prob_mask
+
+        if self.random_token_prob > 0. and coin_flip():
+            random_token_prob_mask = get_mask_subset_prob(replace_mask_id_mask, self.random_token_prob * frac_seq_left)
+            random_tokens = torch.randint(0, self.num_tokens, (b, n), device = device)
+
+            x = torch.where(random_token_prob_mask, random_tokens, x)
+            replace_mask_id_mask &= ~random_token_prob_mask
+
+        masked = torch.where(replace_mask_id_mask, self.mask_id, x)
+
+        # self conditioning
+
+        if self.self_cond:
+            self_cond = self.null_embed
+
+            if sample_prob(self.self_cond_train_prob):
+                with torch.no_grad():
+                    self_cond = self.net(masked, return_embeddings = True, **kwargs).detach()
+
+            kwargs.update(sum_embeds = self.to_self_cond(self_cond))
+
+        # logits
+
+        context = torch.no_grad if only_train_critic else nullcontext
+
+        with context():
+            logits = self.net(masked, **kwargs)
+
+        # cross entropy loss
+
+        loss = F.cross_entropy(
+            logits[mask],
+            orig_seq[mask]
+        )
+
+        if not exists(self.token_critic) or only_train_generator:
+            return Losses(loss, loss, None)
+
+        sampled_ids = gumbel_sample(logits, temperature = default(generator_sample_temperature, random()))
+        generated = torch.where(mask, sampled_ids, orig_seq)
+
+        critic_logits = self.token_critic(generated)
+        critic_labels = (sampled_ids != orig_seq).float()
+
+        critic_loss = F.binary_cross_entropy_with_logits(
+            rearrange(critic_logits, '... 1 -> ...'),
+            critic_labels
+        )
+
+        # determine losses to be returned based on what researcher wants to train
+
+        if only_train_critic:
+            total_loss = critic_loss
+            loss = None
+        else:
+            total_loss = loss + critic_loss * self.critic_loss_weight
+
+        return Losses(total_loss, loss,  critic_loss)
+
+################################################################################
+
+################################################################################
+# Code for x-transformers Python module autoregressive_wrapper.py
+################################################################################
+
+from math import ceil, log
+from typing import Optional, Union, Tuple, Callable
+
+import torch
+from torch import nn, Tensor
+from torch.nn import Module
+import torch.nn.functional as F
+
+from einops import rearrange, pack, unpack
+
+def exists(val):
+    return val is not None
+
+def default(val, d):
+    return val if exists(val) else d
+
+def identity(t, *args, **kwargs):
+    return t
+
+def cast_tuple(t, length = 1):
+    return t if isinstance(t, tuple) else (t,) * length
+
+def eval_decorator(fn):
+    def inner(self, *args, **kwargs):
+        was_training = self.training
+        self.eval()
+        out = fn(self, *args, **kwargs)
+        self.train(was_training)
+        return out
+    return inner
+
+# for variable lengthed prefixes
+
+def align_right(t, lens, pad_id = 0):
+    batch, seq_len, device, dtype = *t.shape, t.device, t.dtype
+
+    assert lens.ndim == 1 and lens.shape[0] == batch
+    assert lens.amax() <= seq_len
+
+    pad_lens = seq_len - lens
+    max_pad_len = pad_lens.amax()
+
+    batch_arange = torch.arange(batch, device = device, dtype = torch.long)[..., None]
+    prompt_len_arange = torch.arange(seq_len, device = device, dtype = torch.long)
+
+    t = F.pad(t, (max_pad_len, 0), value = 0)
+    offset = max_pad_len - pad_lens
+
+    aligned = t[batch_arange, prompt_len_arange + offset[..., None]]
+    return aligned
+
+# nucleus
+
+def top_p(logits, thres = 0.9):
+    sorted_logits, sorted_indices = torch.sort(logits, descending = True)
+    cum_probs = torch.cumsum(F.softmax(sorted_logits, dim = -1), dim = -1)
+
+    sorted_indices_to_remove = cum_probs > thres
+    sorted_indices_to_remove = F.pad(sorted_indices_to_remove, (1, -1), value = False)
+
+    sorted_logits[sorted_indices_to_remove] = float('-inf')
+    return sorted_logits.scatter(1, sorted_indices, sorted_logits)
+
+# topk
+
+def top_k(logits, frac_num_tokens = 0.1, k = None):
+    num_tokens = logits.shape[-1]
+
+    k = default(k, ceil(frac_num_tokens * num_tokens))
+    k = min(k, num_tokens)
+
+    val, ind = torch.topk(logits, k)
+    probs = torch.full_like(logits, float('-inf'))
+    probs.scatter_(1, ind, val)
+    return probs
+
+# top_a
+
+def top_a(logits, min_p_pow = 2.0, min_p_ratio = 0.02):
+    probs = F.softmax(logits, dim = -1)
+    max_probs = torch.amax(probs, dim = -1, keepdim = True)
+    limit = torch.pow(max_probs, min_p_pow) * min_p_ratio
+    return torch.where(probs < limit, float('-inf'), logits)
+
+# contrastive decoding function
+
+def contrastive_decode_fn(
+    expert_logits,
+    amateur_logits,
+    alpha = 0.1,
+    beta = 0.5
+):
+    """
+    Appendix A Algorithm 2
+    https://arxiv.org/abs/2309.09117
+    """
+
+    cutoff = log(alpha) + expert_logits.amax(dim = -1, keepdim = True)
+    diffs = (1 + beta) * expert_logits - beta * amateur_logits
+    contrastive_decode_logits = diffs.masked_fill(expert_logits < cutoff, -torch.finfo(expert_logits.dtype).max)
+    return contrastive_decode_logits
+
+# autoregressive wrapper class
+
+class AutoregressiveWrapper(Module):
+    def __init__(
+        self,
+        net,
+        ignore_index = -100,
+        pad_value = 0,
+        mask_prob = 0.,
+        add_attn_z_loss = False
+    ):
+        super().__init__()
+        self.pad_value = pad_value
+        self.ignore_index = ignore_index
+
+        self.net = net
+        self.max_seq_len = net.max_seq_len
+
+        # paper shows masking (MLM) in conjunction with autoregressive decoder-only training leads to big improvements https://arxiv.org/abs/2210.13432
+        assert mask_prob < 1.
+        self.mask_prob = mask_prob
+
+        # whether to add router z-loss
+        self.add_attn_z_loss = add_attn_z_loss
+
+    @torch.no_grad()
+    @eval_decorator
+    def generate(
+        self,
+        prompts,
+        seq_len,
+        eos_token = None,
+        temperature = 1.,
+        prompt_lens: Optional[Tensor] = None,
+        filter_logits_fn: Callable = top_k,
+        restrict_to_max_seq_len = True,
+        amateur_model: Optional[Union[Module, Tuple[Module]]] = None,
+        filter_kwargs: dict = dict(),
+        contrastive_decode_kwargs: Union[dict, Tuple[dict]] = dict(
+            beta = 0.5,
+            alpha = 0.1
+        ),
+        cache_kv = False,
+        verbose=True,
+        return_prime=False,
+        **kwargs
+    ):
+        max_seq_len, greedy, device = self.max_seq_len, temperature == 0., prompts.device
+
+        prompts, ps = pack([prompts], '* n')
+
+        b, t = prompts.shape
+
+        # handle variable lengthed prompts (prefixes)
+
+        seq_start_pos = None
+        if exists(prompt_lens):
+            prompts = align_right(prompts, prompt_lens, pad_id = self.pad_value)
+            seq_start_pos = t - prompt_lens
+
+        # output from which sampled tokens appended to
+
+        out = prompts
+
+        if verbose:
+          print("Generating sequence of max length:", seq_len)
+
+        # kv caches
+
+        cache = None
+
+        # if doing contrastive decoding, turn off filter automatically
+
+        if exists(amateur_model):
+            amateur_model = cast_tuple(amateur_model)
+            contrastive_decode_kwargs = cast_tuple(contrastive_decode_kwargs)
+
+            assert len(amateur_model) == len(contrastive_decode_kwargs)
+
+            amateur_caches = [None] * len(amateur_model)
+            filter_logits_fn = identity
+
+            for i, module in enumerate(amateur_model):
+                if isinstance(module, AutoregressiveWrapper):
+                    amateur_model[i] = module.net
+
+                module.eval()
+
+        # sampling up to seq_len
+
+        
+
+        for sl in range(seq_len):
+          
+          try:
+
+            if restrict_to_max_seq_len:
+                max_len_exceeded = out.shape[-1] > max_seq_len
+
+                assert not (cache_kv and max_len_exceeded and not self.net.can_cache_kv_outside_max_seq_len), 'the network cannot use cached key values when decoding outside the max sequence length. most likely because you are using absolute positional embeeding. you can switch to rotary embeddings to resolve this issue'
+
+                x = out[:, -max_seq_len:]
+
+                if exists(cache):
+                    for inter in cache.attn_intermediates:
+                        inter.cached_kv = [t[..., -(max_seq_len - 1):, :] for t in inter.cached_kv]
+
+            logits, new_cache = self.net(
+                x,
+                return_intermediates = True,
+                cache = cache,
+                seq_start_pos = seq_start_pos,
+                **kwargs
+            )
+
+            if cache_kv and self.net.can_cache_kv:
+                cache = new_cache
+
+            logits = logits[:, -1]
+
+            # handle contrastive decoding, Li et al.
+            # https://arxiv.org/abs/2210.15097
+
+            if exists(amateur_model):
+                for i, (amateur, amateur_cache, amateur_contrastive_decode_kwargs) in enumerate(zip(amateur_model, amateur_caches, contrastive_decode_kwargs)):
+                    amateur_logits, next_amateur_cache = amateur(
+                        x,
+                        return_intermediates = True,
+                        cache = amateur_cache,
+                        seq_start_pos = seq_start_pos,
+                        **kwargs
+                    )
+
+                    amateur_logits = amateur_logits[:, -1]
+
+                    assert amateur_logits.shape == logits.shape, 'logits dimension are not the same between amateur and expert model'
+                    logits = contrastive_decode_fn(logits, amateur_logits, **amateur_contrastive_decode_kwargs)
+
+                    if cache_kv and amateur.can_cache_kv:
+                        amateur_caches[i] = next_amateur_cache
+
+            # filter by top_k, top_p (nucleus), top_a, or custom
+
+            if greedy:
+                sample = logits.argmax(dim = -1, keepdim = True)
+            else:
+                filtered_logits = filter_logits_fn(logits, **filter_kwargs)
+                probs = F.softmax(filtered_logits / temperature, dim=-1)
+                sample = torch.multinomial(probs, 1)
+
+            # concat sample
+
+            out = torch.cat((out, sample), dim=-1)
+
+            if verbose:
+              if sl % 32 == 0:
+                print(sl, '/', seq_len)
+
+            if not exists(eos_token):
+                continue
+
+            is_eos_tokens = (out == eos_token)
+
+            if is_eos_tokens.any(dim = -1).all():
+              if verbose: 
+                print('Model called the end of sequence at:', sl, '/', seq_len)
+              break
+
+          except KeyboardInterrupt:
+            print('Stopping generation...')
+            break
+          
+          except Exception as e:
+            print('Error:', e)
+            break
+
+        if exists(eos_token):
+            # mask out everything after the eos tokens
+            shifted_is_eos_tokens = F.pad(is_eos_tokens, (1, -1))
+            mask = shifted_is_eos_tokens.float().cumsum(dim = -1) >= 1
+            out = out.masked_fill(mask, self.pad_value)
+
+        if return_prime:
+          return out[:, :]
+        
+        else:
+          return out[:, t:]
+
+        # out, = unpack(out, ps, '* n')
+
+        # return out
+
+    def compute_accuracy(self, logits, labels): 
+        out = torch.argmax(logits, dim=-1) 
+        out = out.flatten() 
+        labels = labels.flatten() 
+
+        mask = (labels != self.ignore_index) # can also be self.pad_value (your choice)
+        out = out[mask] 
+        labels = labels[mask] 
+
+        num_right = (out == labels)
+        num_right = torch.sum(num_right).type(torch.float32)
+
+        acc = num_right / len(labels) 
+        return acc
+
+    def forward(self, x, return_outputs = False, **kwargs):
+        seq, ignore_index, add_attn_z_loss = x.shape[1], self.ignore_index, self.add_attn_z_loss
+
+        inp, target = x[:, :-1], x[:, 1:]
+        inp = torch.where(inp == ignore_index, self.pad_value, inp)
+
+        if self.mask_prob > 0.:
+            rand = torch.randn(inp.shape, device = x.device)
+            rand[:, 0] = -torch.finfo(rand.dtype).max # first token should not be masked out
+            num_mask = min(int(seq * self.mask_prob), seq - 1)
+            indices = rand.topk(num_mask, dim = -1).indices
+            mask = ~torch.zeros_like(inp).scatter(1, indices, 1.).bool()
+            kwargs.update(self_attn_kv_mask = mask)
+
+        logits, cache = self.net(
+            inp,
+            return_intermediates = True,
+            return_attn_z_loss = add_attn_z_loss,
+            **kwargs
+        )
+
+        acc = self.compute_accuracy(logits, target)
+
+        loss = F.cross_entropy(
+            rearrange(logits, 'b n c -> b c n'),
+            target,
+            ignore_index = ignore_index
+        )
+
+        if add_attn_z_loss:
+            loss = loss + cache.attn_z_loss
+
+        if not return_outputs:
+            return loss, acc
+
+        return loss, acc, (logits, cache)
+
+################################################################################
+
+################################################################################
+# Code for x-transformers Python module xl_autoregressive_wrapper.py
+################################################################################
+
+from math import ceil
+
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+from einops import rearrange, pack, unpack
+
+# helper functions
+
+def exists(val):
+    return val is not None
+
+def divisible_by(numer, denom):
+    return (numer % denom) == 0 
+
+# xl autoregressive wrapper class
+
+class XLAutoregressiveWrapper(nn.Module):
+    def __init__(
+        self,
+        net,
+        ignore_index = -100,
+        pad_value = 0
+    ):
+        super().__init__()
+        self.pad_value = pad_value
+        self.ignore_index = ignore_index
+
+        self.net = net
+        self.max_seq_len = net.max_seq_len
+
+    @torch.no_grad()
+    @eval_decorator
+    def generate(
+        self,
+        start_tokens,
+        seq_len,
+        eos_token = None,
+        temperature = 1.,
+        filter_logits_fn = top_k,
+        filter_thres = 0.9,
+        mems = None,
+        **kwargs
+    ):
+        device, max_seq_len = start_tokens.device, self.max_seq_len
+
+        start_tokens, ps = pack([start_tokens], '* n')
+
+        b, t = start_tokens.shape
+
+        *all_leading_tokens, _ = start_tokens.split(max_seq_len, dim = -1)
+
+        # catch the memory up to the current segment
+
+        for leading_tokens in all_leading_tokens:
+            _, mems = self.net(
+                leading_tokens,
+                mems = mems,
+                return_mems = True,
+                **kwargs
+            )
+
+        # now start sampling from the current segment
+
+        curr_pos = len(all_leading_tokens) * max_seq_len
+        curr_mems = mems
+
+        cache = None
+        out = start_tokens
+
+        for _ in range(seq_len):
+            curr_segment_len = out.shape[-1]
+            is_last_segment_tokens = divisible_by(curr_segment_len, max_seq_len)
+
+            x = out[:, curr_pos:]
+
+            logits, cache = self.net(
+                x,
+                mems = curr_mems,
+                cache = cache,
+                return_mems = True,
+                return_intermediates = True,
+                **kwargs
+            )
+
+            mems = cache.mems
+
+            logits = logits[:, -1]
+            filtered_logits = filter_logits_fn(logits, thres = filter_thres)
+            probs = F.softmax(filtered_logits / temperature, dim=-1)
+
+            sample = torch.multinomial(probs, 1)
+
+            if is_last_segment_tokens:
+                curr_pos = curr_segment_len
+                curr_mems = mems
+
+            out = torch.cat((out, sample), dim=-1)
+
+            if exists(eos_token):
+                is_eos_tokens = (out == eos_token)
+
+                if is_eos_tokens.any(dim = -1).all():
+                    # mask out everything after the eos tokens
+                    shifted_is_eos_tokens = F.pad(is_eos_tokens, (1, -1))
+                    mask = shifted_is_eos_tokens.float().cumsum(dim = -1) >= 1
+                    out = out.masked_fill(mask, self.pad_value)
+                    break
+
+        out = out[:, t:]
+
+        out, = unpack(out, ps, '* n')
+
+        return out
+
+    def forward(
+        self,
+        x,
+        mems = None,
+        **kwargs
+    ):
+        ignore_index, max_seq_len = self.ignore_index, self.max_seq_len
+
+        x, labels = x[:, :-1], x[:, 1:]
+
+        seq_len = x.shape[1]
+
+        # prepare chunks
+
+        split_x = x.split(max_seq_len, dim = -1)
+        split_labels = labels.split(max_seq_len, dim = -1)
+        loss_weights = tuple(map(lambda t: t.shape[-1] / seq_len, split_x))
+
+        # go through each chunk and derive weighted losses
+
+        total_loss = 0.        
+
+        for chunk, chunk_labels, loss_weight in zip(split_x, split_labels, loss_weights):
+
+            logits, mems = self.net(
+                chunk,
+                mems = mems,
+                return_mems = True,
+                **kwargs
+            )
+
+            loss = F.cross_entropy(
+                rearrange(logits, 'b n c -> b c n'),
+                chunk_labels,
+                ignore_index = ignore_index
+            )
+
+            total_loss = total_loss + loss * loss_weight
+
+        return total_loss
+
+################################################################################
+
+################################################################################
+# Code for x-transformers Python module xval.py
+################################################################################
+
+"""
+regular transformer with discrete tokens, but continuous for number
+generalizes better for arithmetic
+https://arxiv.org/abs/2310.02989
+"""
+
+import torch
+from torch import nn, Tensor
+import torch.nn.functional as F
+
+from typing import Callable
+from collections import namedtuple
+
+from einops import rearrange
+from einops.layers.torch import Rearrange
+
+# constants
+
+LossBreakdown = namedtuple('LossBreakdown', ['cross_entropy_loss', 'numerical_mse_loss'])
+
+GenerateReturn = namedtuple('GenerateReturn', ['sampled_token_ids', 'sampled_numbers', 'is_number_mask'])
+
+# helper functions
+
+def exists(val):
+    return val is not None
+
+def default(val, d):
+    if exists(val):
+        return val
+    return d() if callable(d) else d
+
+# main classes
+
+class XValTransformerWrapper(nn.Module):
+    def __init__(
+        self,
+        *,
+        num_tokens,
+        max_seq_len,
+        numerical_token_id,
+        attn_layers: AttentionLayers,
+        emb_dim = None,
+        logits_dim = None,
+        tie_embedding = False,
+        max_mem_len = 0,
+        num_memory_tokens = None,
+        emb_dropout = 0.,
+        use_abs_pos_emb = True,
+        scaled_sinu_pos_emb = False
+    ):
+        super().__init__()
+        dim = attn_layers.dim
+        emb_dim = default(emb_dim, dim)
+
+        self.emb_dim = emb_dim
+        self.token_emb = TokenEmbedding(emb_dim, num_tokens)
+
+        self.numerical_token_id = numerical_token_id
+
+        self.max_seq_len = max_seq_len
+
+        self.max_mem_len = max_mem_len
+
+        if not (use_abs_pos_emb and not attn_layers.disable_abs_pos_emb):
+            self.pos_emb = always(0)
+        elif scaled_sinu_pos_emb:
+            self.pos_emb = ScaledSinusoidalEmbedding(dim)
+        else:
+            self.pos_emb = AbsolutePositionalEmbedding(dim, max_seq_len)
+
+        self.emb_dropout = nn.Dropout(emb_dropout)
+
+        # memory tokens
+
+        num_memory_tokens = default(num_memory_tokens, 0)
+        self.has_memory_tokens = num_memory_tokens > 0
+
+        if num_memory_tokens > 0:
+            self.memory_tokens = nn.Parameter(torch.randn(num_memory_tokens, dim))
+
+        # attention layers
+
+        self.attn_layers = attn_layers
+
+        # to logits
+
+        logits_dim = default(logits_dim, num_tokens)
+        self.to_logits = nn.Linear(dim, logits_dim) if not tie_embedding else lambda t: t @ self.token_emb.emb.weight.t()
+
+        self.to_numerical_output = nn.Sequential(
+            nn.Linear(dim, 1),
+            Rearrange('... 1 -> ...')
+        )
+
+    def forward(
+        self,
+        x: Tensor,
+        x_num: Tensor,
+        return_embeddings = False,
+        return_intermediates = False,
+        return_mems = False,
+        mask = None,
+        return_attn = False,
+        mems = None,
+        pos = None,
+        prepend_embeds = None,
+        **kwargs
+    ):
+        assert x.shape == x_num.shape
+
+        batch = x.shape[0]
+
+        is_number_mask = x == self.numerical_token_id
+
+        x = self.token_emb(x)
+
+        scale = torch.where(is_number_mask, x_num, 1.)
+        scale = rearrange(scale, '... -> ... 1')
+
+        x = x * scale
+
+        x = x + self.pos_emb(x, pos = pos)
+
+        # memory tokens
+
+        if self.has_memory_tokens:
+            m = repeat(self.memory_tokens, 'm d -> b m d', b = batch)
+            x, mem_ps = pack([m, x], 'b * d')
+
+            if exists(mask):
+                num_mems = m.shape[-2]
+                mask = pad_at_dim(mask, (num_mems, 0), dim = -1, value = True)
+
+        # whether to append embeds, as in PaLI, for image embeddings
+
+        if exists(prepend_embeds):
+            _, prepend_dim = prepend_embeds.shape[1:]
+            assert prepend_dim == x.shape[-1], 'prepended embeddings need to have same dimensions as model dimensions'
+
+            x = torch.cat((prepend_embeds, x), dim = -2)
+
+        x = self.emb_dropout(x)
+
+        # attention layers
+
+        x, intermediates = self.attn_layers(x, mask = mask, mems = mems, return_hiddens = True, **kwargs)
+
+        # splice out memory tokens
+
+        if self.has_memory_tokens:
+            m, x = unpack(x, mem_ps, 'b * d')
+            intermediates.memory_tokens = m
+
+        if not return_embeddings:
+            logits = self.to_logits(x)
+            numerical_pred = self.to_numerical_output(x)
+            out = (logits, numerical_pred)
+        else:
+            out = x
+
+        if return_intermediates:
+            return out, intermediates
+
+        if return_mems:
+            hiddens = intermediates.hiddens
+            new_mems = list(map(lambda t: t[..., -self.max_mem_len:, :].detach(), hiddens))
+            return out, new_mems
+
+        if return_attn:
+            attn_maps = list(map(lambda t: t.post_softmax_attn, intermediates.attn_intermediates))
+            return out, attn_maps
+
+        return out
+
+class XValAutoregressiveWrapper(nn.Module):
+    def __init__(
+        self,
+        net: XValTransformerWrapper,
+        ignore_index = -100,
+        pad_value = 0,
+        numerical_loss_weight = 1.
+    ):
+        super().__init__()
+        self.net = net
+        self.max_seq_len = net.max_seq_len
+        self.numerical_loss_weight = numerical_loss_weight
+        self.ignore_index = ignore_index
+
+    @torch.no_grad()
+    def generate(
+        self,
+        start_tokens: Tensor,
+        start_numbers: Tensor,
+        seq_len,
+        filter_logits_fn: Callable = top_k,
+        filter_kwargs: dict = dict(),
+        temperature = 1.,
+        **kwargs
+    ):
+        device = start_tokens.device
+        was_training = self.net.training
+        num_dims = len(start_tokens.shape)
+
+        assert num_dims >= 2, 'number of dimensions of your start tokens must be greater or equal to 2'
+        assert start_tokens.shape == start_numbers.shape
+
+        b, t, device = *start_tokens.shape, start_tokens.device
+
+        self.net.eval()
+        out = start_tokens
+        num_out = start_numbers
+
+        for _ in range(seq_len):
+            x = out[:, -self.max_seq_len:]
+            x_num = num_out[:, -self.max_seq_len:]
+
+            logits, numerical_pred = self.net(x, x_num, **kwargs)
+
+            last_logits = logits[:, -1]
+            last_num_pred = numerical_pred[:, -1:]
+
+            filtered_logits = filter_logits_fn(last_logits, **filter_kwargs)
+
+            probs = F.softmax(filtered_logits / temperature, dim=-1)
+
+            sample = torch.multinomial(probs, 1)
+
+            out = torch.cat((out, sample), dim = -1)
+            num_out = torch.cat((num_out, last_num_pred), dim = -1)
+
+        out = out[:, t:]
+        num_out = num_out[:, t:]
+
+        is_number = out == self.net.numerical_token_id
+        num_out = torch.where(is_number, num_out, float('nan'))
+
+        self.net.train(was_training)
+        return GenerateReturn(out, num_out, is_number)
+
+    def forward(
+        self,
+        x: Tensor,
+        x_num: Tensor,
+        return_loss_breakdown = False,
+        **kwargs
+    ):
+        inp, target = x[:, :-1], x[:, 1:]
+        x_num_inp, x_num_target = x_num[:, :-1], x_num[:, 1:]
+
+        mask = kwargs.get('mask', None)
+        if exists(mask) and mask.shape[1] == x.shape[1]:
+            mask = mask[:, :-1]
+            kwargs['mask'] = mask
+
+        logits, numerical_pred = self.net(inp, x_num_inp, **kwargs)
+
+        logits = rearrange(logits, 'b n c -> b c n')
+
+        cross_entropy_loss = F.cross_entropy(logits, target, reduction = 'none', ignore_index = self.ignore_index)
+
+        target_mask = target != self.ignore_index
+
+        numerical_mse_loss = F.mse_loss(numerical_pred, x_num_target, reduction = 'none')
+
+        numerical_mse_loss = numerical_mse_loss * target_mask
+
+        loss = cross_entropy_loss + numerical_mse_loss * self.numerical_loss_weight
+
+        if exists(mask):
+            loss = loss[mask]
+
+        loss = loss.mean()
+
+        if not return_loss_breakdown:
+            return loss
+
+        return loss, LossBreakdown(cross_entropy_loss, numerical_mse_loss)
+
+################################################################################
+
+################################################################################
+# Code for instantiating, saving and loading a simple model
+################################################################################
+
+import os
+import importlib
+
+#===============================================================================
+
+def instantiate_x_transformer_model(max_seq_len,
+                                    num_tokens,
+                                    dim=1024,
+                                    depth=4,
+                                    heads=8,
+                                    attn_flash=True,
+                                    ignore_index=-1,
+                                    verbose=True):
+    if verbose:
+      print('=' * 70)
+      print('Instantiating x-transformer model...')
+
+    model = TransformerWrapper(
+                                num_tokens = num_tokens,
+                                max_seq_len = max_seq_len,
+                                attn_layers = Decoder(
+                                                      dim = dim, 
+                                                      depth = depth, 
+                                                      heads = heads, 
+                                                      attn_flash = attn_flash
+                                                      )
+                              )
+
+    model = AutoregressiveWrapper(model, 
+                                  ignore_index=ignore_index
+                                  )
+
+    if torch.cuda.is_available():
+      model.cuda()
+    else:
+      model.cpu()
+
+    if verbose:
+      print('Done!')
+      print('=' * 70)
+
+    return model
+
+#===============================================================================
+
+def save_x_transformer_model(model,
+                              number_of_tokens,
+                              max_seq_len,
+                              dim=1024, 
+                              depth=4, 
+                              heads=8,
+                              ignore_index=-1,
+                              use_flash_attn=True,
+                              batch_size=4,
+                              grad_acc_rate=4,
+                              learning_rate=1e-4,
+                              num_epochs=1,
+                              num_steps=1,
+                              loss=0,
+                              accuracy=1,
+                              checkpoint_dir='./',
+                              checkpoint_name='model_checkpoint',
+                              verbose=True
+                            ):
+    
+    if verbose:
+      print('=' * 70)
+      print('Saving x-transformer model...')
+
+    checkpoint_full_name = ''
+    checkpoint_full_name += checkpoint_name + '_' 
+    checkpoint_full_name += str(num_epochs) + '_epochs_'
+    checkpoint_full_name += str(num_steps) + '_steps_'
+    checkpoint_full_name += str(loss) + '_loss_'
+    checkpoint_full_name += str(accuracy) + '_acc'
+    checkpoint_full_name += '.pth'
+
+    checkpoint_full_path_and_name = os.path.join(checkpoint_dir, checkpoint_full_name)
+
+#===============================================================================
+
+    torch.save({
+        'model_state_dict': model.state_dict(),
+        'class_name': model.__class__.__name__,
+        'class_module': model.__class__.__module__,
+        'num_tokens': number_of_tokens,
+        'max_seq_len': max_seq_len,
+        'attn_layers': {
+            'dim': dim,
+            'depth': depth,
+            'heads': heads,
+            'attn_flash': use_flash_attn
+            },
+        'batch_size': batch_size,
+        'grad_acc_rate': grad_acc_rate,
+        'learning_rate': learning_rate,
+        'ignore_index': ignore_index,
+        'num_epochs': num_epochs,
+        'num_steps': num_steps,
+        'loss': loss,
+        'accuracy': accuracy
+    }, checkpoint_full_path_and_name
+)
+
+    if verbose:
+      print('Done!')
+      print('=' * 70)
+      print('Saved model name:', checkpoint_full_name)
+      print('=' * 70)
+
+#===============================================================================
+
+def load_x_transformer_model(checkpoint_file_path,
+                             verbose=True
+                             ):
+    
+    if verbose:
+      print('=' * 70)
+      print('Loading x-transformer model...')
+
+    checkpoint = torch.load(checkpoint_file_path)
+    module = importlib.import_module(checkpoint['class_module'])
+    class_ = getattr(module, checkpoint['class_name'])
+    attn_layers = Decoder(**checkpoint['attn_layers'])
+    transformer_model = TransformerWrapper(num_tokens=checkpoint['num_tokens'],
+                                          max_seq_len=checkpoint['max_seq_len'],
+                                          attn_layers=attn_layers)
+    model = class_(transformer_model, ignore_index=checkpoint['ignore_index'])
+    model.load_state_dict(checkpoint['model_state_dict'])
+
+    if torch.cuda.is_available():
+      model.cuda()
+    else:
+      model.cpu()
+
+    if verbose:
+      print('Done!')
+      print('=' * 70)
+      print('Model stats:')
+      print('Number of tokens:', checkpoint['num_tokens'])
+      print('Ignore index:', checkpoint['ignore_index'])
+      print('Max sequence length::', checkpoint['max_seq_len'])
+      print('Dimension:', checkpoint['attn_layers']['dim'])
+      print('Depth:', checkpoint['attn_layers']['depth'])
+      print('Number of heads:', checkpoint['attn_layers']['heads'])
+      print('Flash attention:', checkpoint['attn_layers']['attn_flash'])
+      print('Training batch size', checkpoint['batch_size'])
+      print('Training gradient accumulation rate:', checkpoint['grad_acc_rate'])
+      print('Training learining rate:', checkpoint['learning_rate'])
+      print('Number of training epochs:', checkpoint['num_epochs'])
+      print('Number of training steps:', checkpoint['num_steps'])
+      print('Model loss:', checkpoint['loss'])
+      print('Model accuracy:', checkpoint['accuracy'])
+      print('=' * 70)
+
+      return model
+
+################################################################################
+
+def generate_from_x_transformer_model(model=None, 
+                                      num_tokens_to_generate=32,
+                                      prime_tokens_list=[0],
+                                      return_prime=False,
+                                      batch_size=1,
+                                      temperature=0.9,
+                                      precision='bfloat16',
+                                      device='cuda',
+                                      verbose=True
+                                      ):
+  
+    if model is not None:
+    
+      device_options = ['cuda', 'cpu', 'cuda:0']
+      
+      if device not in device_options or not torch.cuda.is_available():
+        device_type = 'cpu'
+      else:
+        device_type = device
+      
+      precision_options = ['float32', 'bfloat16', 'float16']
+
+      if precision == 'bfloat16' and device_type != 'cpu' and not torch.cuda.is_bf16_supported():
+        precision = 'float16'
+
+      if precision in precision_options:
+        ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[precision]
+      else:
+        ptdtype = torch.bfloat16
+
+      ctx = torch.amp.autocast(device_type=device_type, dtype=ptdtype)
+
+      model.to(device_type)
+
+      model.eval()
+
+      if verbose:
+        print('=' * 70)
+        print('Generation information')
+        print('=' * 70)
+        print('Device:', device)
+        print('Precision:', precision)
+        print('=' * 70)
+        print('Prime tokens sample:', prime_tokens_list[:10])
+        print('=' * 70)
+        print('Model will generate', batch_size, 'batches', num_tokens_to_generate, 'tokens each', )
+        print('Total number of tokens to generate:', num_tokens_to_generate * batch_size)
+        print('=' * 70)
+        print('Model temeperature', temperature)
+        print('=' * 70)
+
+      input = torch.tensor([prime_tokens_list] * batch_size, dtype=torch.long, device=device_type)
+
+      with ctx:
+        out = model.generate(input,
+                              num_tokens_to_generate,
+                              temperature=temperature,
+                              return_prime=return_prime,
+                              verbose=verbose
+                            )
+      if verbose:  
+        print('=' * 70)
+        print('Done!')
+        print('=' * 70)
+
+      return out.tolist()
+    
+    else:
+      print('=' * 70)
+      print('Please check the model!')
+      print('=' * 70)
+
+################################################################################
+
+from torch.utils.data import Dataset
+
+class X_Transformer_Dataset(Dataset):
+    def __init__(self, data, seq_len, batch_size):
+        super().__init__()
+        self.data = data
+        self.seq_len = seq_len
+        self.batch_size = batch_size
+
+    def __getitem__(self, index):
+
+        full_seq = torch.Tensor(self.data[index][:self.seq_len+1]).long()
+
+        return full_seq.cuda()
+
+    def __len__(self):
+        return (len(self.data) // self.batch_size) * self.batch_size
+
+################################################################################
+
+import tqdm
+import pickle
+import matplotlib.pyplot as plt
+
+#===============================================================================
+
+def save_data(data, filename):
+    with open(filename, 'wb') as f:
+      pickle.dump(data, f)
+
+def cycle_train_data(loader):
+    while True:
+        for data in loader:
+            yield data
+
+def default_output_func(output):
+    print(output)
+
+#===============================================================================
+
+def train_x_transformer_model(model,
+                              model_sequence_length,
+                              model_number_of_tokens,
+                              model_name,
+                              training_data,
+                              model_ignore_index=-1,
+                              model_dimension=1024,
+                              model_depth=4,
+                              model_number_of_heads=8,
+                              model_uses_flash_attention=True,
+                              training_data_batch_size=1,
+                              training_learning_rate=1e-4,
+                              accumulate_gradients_every=4,
+                              number_of_training_epochs=1,
+                              validate_every=100,
+                              save_every=500,
+                              generate_every=100,
+                              generate_length=100,
+                              generate_num_prime_tokens=512,
+                              generate_output_custom_func=default_output_func,
+                              print_stats_every=20,
+                              device='cuda',
+                              precision='float16',
+                              clip_grad_norm_value=1.0,
+                              scaler_enabled=True,
+                              save_directory='./',
+                              plot_statistics=True,
+                              verbose=True
+                              ):
+
+    #===========================================================================
+
+    device_options = ['cuda', 'cpu', 'cuda:0']
+    
+    if device not in device_options or not torch.cuda.is_available():
+      device_type = 'cpu'
+    else:
+      device_type = device
+    
+    precision_options = ['float32', 'bfloat16', 'float16']
+
+    if precision == 'bfloat16' and device_type != 'cpu' and not torch.cuda.is_bf16_supported():
+      precision = 'float16'
+
+    if precision in precision_options:
+      ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[precision]
+    else:
+      ptdtype = torch.bfloat16
+
+    ctx = torch.amp.autocast(device_type=device_type, dtype=ptdtype)
+
+    model.to(device_type)
+
+    optim = torch.optim.Adam(model.parameters(), lr=training_learning_rate)
+
+    scaler = torch.cuda.amp.GradScaler(enabled=scaler_enabled)
+
+    #===========================================================================
+
+    train_losses = []
+    val_losses = []
+
+    train_accs = []
+    val_accs = []
+
+    nsteps = 0
+
+    for ep in range(number_of_training_epochs):
+
+      print('=' * 70)
+      print('Epoch #', ep)
+      print('=' * 70)
+
+      random.shuffle(training_data)
+
+      train_dataset = X_Transformer_Dataset(training_data, model_sequence_length, training_data_batch_size)
+      val_dataset   = X_Transformer_Dataset(training_data, model_sequence_length, training_data_batch_size)
+      train_loader  = cycle_train_data(DataLoader(train_dataset, batch_size = training_data_batch_size))
+      val_loader    = cycle_train_data(DataLoader(val_dataset, batch_size = training_data_batch_size))
+
+      NUM_BATCHES = len(training_data) // training_data_batch_size // accumulate_gradients_every
+
+      for i in tqdm.tqdm(range(NUM_BATCHES), mininterval=10., desc='Training'):
+          model.train()
+
+          for __ in range(accumulate_gradients_every):
+              with ctx:
+                  loss, acc = model(next(train_loader))
+              loss = loss / accumulate_gradients_every
+              scaler.scale(loss).backward(torch.ones(loss.shape).cuda())
+
+          if i % print_stats_every == 0:
+              print(f'Training loss: {loss.mean().item() * accumulate_gradients_every}')
+              print(f'Training acc: {acc.mean().item()}')
+
+          train_losses.append(loss.mean().item() * accumulate_gradients_every)
+          train_accs.append(acc.mean().item())
+
+          scaler.unscale_(optim)
+          torch.nn.utils.clip_grad_norm_(model.parameters(), clip_grad_norm_value)
+          scaler.step(optim)
+          scaler.update()
+          optim.zero_grad(set_to_none=True)
+
+          nsteps += 1
+
+          if i % validate_every == 0:
+            model.eval()
+            with torch.no_grad():
+              with ctx:
+                val_loss, val_acc = model(next(val_loader))
+
+                print(f'Validation loss: {val_loss.mean().item()}')
+                print(f'Validation acc: {val_acc.mean().item()}')
+
+                val_losses.append(val_loss.mean().item())
+                val_accs.append(val_acc.mean().item())
+
+                if plot_statistics:
+
+                  print('Plotting training loss graph...')
+
+                  tr_loss_list = train_losses
+                  plt.plot([i for i in range(len(tr_loss_list))] ,tr_loss_list, 'b')
+                  plt.show()
+                  plt.close()
+                  print('Done!')
+
+                  print('Plotting training acc graph...')
+
+                  tr_loss_list = train_accs
+                  plt.plot([i for i in range(len(tr_loss_list))] ,tr_loss_list, 'b')
+                  plt.show()
+                  plt.close()
+                  print('Done!')
+
+                  print('Plotting validation loss graph...')
+                  tr_loss_list = val_losses
+                  plt.plot([i for i in range(len(tr_loss_list))] ,tr_loss_list, 'b')
+                  plt.show()
+                  plt.close()
+                  print('Done!')
+
+                  print('Plotting validation acc graph...')
+                  tr_loss_list = val_accs
+                  plt.plot([i for i in range(len(tr_loss_list))] ,tr_loss_list, 'b')
+                  plt.show()
+                  plt.close()
+                  print('Done!')
+          
+          #=====================================================================
+
+          if i % generate_every == 0:
+            model.eval()
+
+            inp = random.choice(val_dataset)[:generate_num_prime_tokens]
+
+            print(inp)
+
+            with ctx:
+
+                sample = model.generate(inp[None, ...], generate_length)
+
+            generate_output_custom_func(sample.tolist())
+
+          #=====================================================================
+
+          if i % save_every == 0:
+
+              print('Saving model progress. Please wait...')
+              print('model_checkpoint_' + str(nsteps) + '_steps_' + str(round(float(train_losses[-1]), 4)) + '_loss_' + str(round(float(train_accs[-1]), 4)) + '_acc.pth')
+
+              fname = save_directory+'/model_checkpoint_' + str(nsteps) + '_steps_' + str(round(float(train_losses[-1]), 4)) + '_loss_' + str(round(float(train_accs[-1]), 4)) + '_acc.pth'
+
+              save_x_transformer_model(model, 
+                                       checkpoint_dir=save_directory, 
+                                       checkpoint_name=model_name,
+                                       number_of_tokens=model_number_of_tokens,
+                                       ignore_index=model_ignore_index,
+                                       max_seq_len=model_sequence_length,
+                                       dim=model_dimension,
+                                       depth=model_depth,
+                                       heads=model_number_of_heads,
+                                       use_flash_attn=model_uses_flash_attention,
+                                       batch_size=training_data_batch_size,
+                                       grad_acc_rate=accumulate_gradients_every,
+                                       learning_rate=training_learning_rate,
+                                       num_epochs=number_of_training_epochs,
+                                       num_steps=nsteps,
+                                       loss=str(round(float(train_losses[-1]), 4)),
+                                       accuracy=str(round(float(train_accs[-1]), 4)),
+                                       verbose=verbose)
+
+              data = [train_losses, train_accs, val_losses, val_accs]
+
+              save_data(data, save_directory+'losses_accuracies.pickle')
+
+              print('Done!')
+
+    #===========================================================================
+
+    print('Saving model progress. Please wait...')
+    print('model_checkpoint_' + str(nsteps) + '_steps_' + str(round(float(train_losses[-1]), 4)) + '_loss_' + str(round(float(train_accs[-1]), 4)) + '_acc.pth')
+
+    fname = save_directory+'model_checkpoint_' + str(nsteps) + '_steps_' + str(round(float(train_losses[-1]), 4)) + '_loss_' + str(round(float(train_accs[-1]), 4)) + '_acc.pth'
+
+    torch.save(model.state_dict(), fname)
+
+    print('Done!')
+
+    data = [train_losses, train_accs, val_losses, val_accs]
+
+    save_data(data, save_directory+'losses_accuracies')
+
+    # Save training loss graph
+
+    plt.plot([i for i in range(len(train_losses))] ,train_losses, 'b')
+    plt.savefig(save_directory+'training_loss_graph.png')
+    plt.close()
+    print('Done!')
+
+    # Save training acc graph
+
+    plt.plot([i for i in range(len(train_accs))] ,train_accs, 'b')
+    plt.savefig(save_directory+'training_accuracy_graph.png')
+    plt.close()
+    print('Done!')
+
+    # Save validation loss graph
+
+    plt.plot([i for i in range(len(val_losses))] ,val_losses, 'b')
+    plt.savefig(save_directory+'validation_loss_graph.png')
+    plt.close()
+    print('Done!')
+
+    # Save validation acc graph
+
+    plt.plot([i for i in range(len(val_accs))] ,val_accs, 'b')
+    plt.savefig(save_directory+'validation_accuracy_graph.png')
+    plt.close()
+    print('Done!')
+    
+################################################################################
+
+# This is the end of x-transformer Python module
+################################################################################
\ No newline at end of file