x-transformers 1.30.23__py3-none-any.whl → 1.31.1__py3-none-any.whl

x_transformers/x_transformers.py

@@ -93,6 +93,9 @@ def l2norm(t, groups = 1):
     t = F.normalize(t, p = 2, dim = -1)
     return rearrange(t, '... g d -> ... (g d)')
 
+def softclamp(t, value):
+    return (t / value).tanh() * value
+
 def pad_at_dim(t, pad: Tuple[int, int], dim = -1, value = 0.):
     if pad == (0, 0):
         return t
@@ -560,22 +563,34 @@ class Scale(Module):
         return (scale_fn(out[0]), *out[1:])
 
 class LayerNorm(Module):
-    def __init__(self, dim):
+    def __init__(
+        self,
+        dim,
+        unit_offset = 0.
+    ):
         """
         bias-less layernorm has been shown to be more stable. most newer models have moved towards rmsnorm, also bias-less
         """
         super().__init__()
+        self.unit_offset = unit_offset
+
+        self.ln = nn.LayerNorm(dim, elementwise_affine = False)
         self.gamma = nn.Parameter(torch.ones(dim))
-        self.register_buffer("beta", torch.zeros(dim))
+        nn.init.constant_(self.gamma, 1. - unit_offset)
 
-    def forward(self, x):
-        return F.layer_norm(x, x.shape[-1:], self.gamma, self.beta)
+        self.register_buffer('beta', torch.zeros(dim), persistent = False)
 
-if version.parse(torch.__version__) >= version.parse('2.1.0'):
-    LayerNorm = partial(nn.LayerNorm, bias = False)
+    def forward(self, x):
+        normed = self.ln(x)
+        gamma = self.gamma + self.unit_offset
+        return normed * gamma
 
 class AdaptiveLayerNorm(Module):
-    def __init__(self, dim, dim_condition = None):
+    def __init__(
+        self,
+        dim,
+        dim_condition = None
+    ):
         super().__init__()
         dim_condition = default(dim_condition, dim)
 
@@ -590,25 +605,43 @@ class AdaptiveLayerNorm(Module):
         return normed * (gamma + 1.)
 
 class ScaleNorm(Module):
-    def __init__(self, dim):
+    def __init__(
+        self,
+        dim,
+        unit_offset = 0.
+    ):
         super().__init__()
+        self.unit_offset = unit_offset
         self.scale = dim ** 0.5
-        self.g = nn.Parameter(torch.ones(1))
+
+        self.g = nn.Parameter(torch.zeros(1))
+        nn.init.constant_(self.g, 1. - unit_offset)
 
     def forward(self, x):
-        return F.normalize(x, dim = -1) * self.scale * self.g
+        return F.normalize(x, dim = -1) * self.scale * (self.g + self.unit_offset)
 
 class RMSNorm(Module):
-    def __init__(self, dim):
+    def __init__(
+        self,
+        dim,
+        unit_offset = 0.
+    ):
         super().__init__()
+        self.unit_offset = unit_offset
         self.scale = dim ** 0.5
-        self.g = nn.Parameter(torch.ones(dim))
+
+        self.g = nn.Parameter(torch.zeros(dim))
+        nn.init.constant_(self.g, 1. - unit_offset)
 
     def forward(self, x):
-        return F.normalize(x, dim = -1) * self.scale * self.g
+        return F.normalize(x, dim = -1) * self.scale * (self.g + self.unit_offset)
 
 class AdaptiveRMSNorm(Module):
-    def __init__(self, dim, dim_condition = None):
+    def __init__(
+        self,
+        dim,
+        dim_condition = None
+    ):
         super().__init__()
         self.scale = dim ** 0.5
         dim_condition = default(dim_condition, dim)
@@ -622,7 +655,11 @@ class AdaptiveRMSNorm(Module):
         return normed * self.scale * (gamma + 1.)
 
 class SimpleRMSNorm(Module):
-    def __init__(self, dim):
+    def __init__(
+        self,
+        dim,
+        **kwargs
+    ):
         super().__init__()
         self.scale = dim ** 0.5
 
@@ -696,10 +733,19 @@ class ShiftTokens(Module):
 # post branch operator
 
 class LayerScale(Module):
-    def __init__(self, fn: Module, dim, init_value = 0.):
+    def __init__(
+        self,
+        fn: Module,
+        dim,
+        init_value = 0.,
+        unit_offset = 0.
+    ):
         super().__init__()
+        self.unit_offset = unit_offset
+
         self.fn = fn
-        self.gamma = nn.Parameter(torch.ones(dim) * init_value)
+        self.gamma = nn.Parameter(torch.zeros(dim))
+        nn.init.constant_(self.gamma, init_value - unit_offset)
 
     def forward(self, x, **kwargs):
         out = self.fn(x, **kwargs)
@@ -711,7 +757,13 @@ class LayerScale(Module):
         return out * self.gamma, *rest
 
 class AdaptiveLayerScale(Module):
-    def __init__(self, fn: Module, dim, dim_condition = None, init_bias_value = -2.):
+    def __init__(
+        self,
+        fn: Module,
+        dim,
+        dim_condition = None,
+        init_bias_value = -2.
+    ):
         super().__init__()
         self.fn = fn
 
@@ -1182,6 +1234,7 @@ class AttentionLayers(Module):
         use_adaptive_layernorm = False,
         use_adaptive_rmsnorm = False,
         use_adaptive_layerscale = False, # paired with use_adaptive_layernorm for ada-ln-zero from DiT paper
+        norm_add_unit_offset = False,
         dim_condition = None,
         adaptive_condition_mlp = False,
         adaptive_condition_mlp_expansion = 4,
@@ -1215,6 +1268,7 @@ class AttentionLayers(Module):
         scale_residual_constant = 1.,
         shift_tokens = 0,
         sandwich_norm = False,
+        softclamp_output_value: float | None = None,
         resi_dual = False,
         resi_dual_scale = 1.,
         zero_init_branch_output = False,
@@ -1315,6 +1369,10 @@ class AttentionLayers(Module):
 
         norm_fn = partial(norm_class, dim)
 
+        if not norm_need_condition and norm_add_unit_offset:
+            # researcher Ohad Rubin shares in a blog post by adding an offset to gammas and betas, they can be subjected to weight decay safely
+            norm_fn = partial(norm_fn, unit_offset = 1.)
+
         self.norm_need_condition = norm_need_condition
         self.dim_condition = dim_condition
 
@@ -1345,6 +1403,9 @@ class AttentionLayers(Module):
 
         self.post_branch_fn_needs_condition = post_branch_fn_needs_condition
 
+        if not post_branch_fn_needs_condition and norm_add_unit_offset:
+            post_branch_fn = partial(post_branch_fn, unit_offset = 1.)
+
         # setup mlp for conditioning
 
         self.need_condition = norm_need_condition or post_branch_fn_needs_condition
@@ -1421,6 +1482,11 @@ class AttentionLayers(Module):
 
         shift_tokens = cast_tuple(shift_tokens, len(layer_types))
 
+        # optional soft clamping just before the final norm
+        # used in gemma 2
+
+        self.softclamp_output_value = softclamp_output_value
+
         # whether it has post norm
 
         self.final_norm = norm_fn() if pre_norm or resi_dual else nn.Identity()
@@ -1652,6 +1718,9 @@ class AttentionLayers(Module):
         if return_hiddens:
             layer_hiddens.append(x)
 
+        if exists(self.softclamp_output_value):
+            x = softclamp(x, self.softclamp_output_value)
+
         final_norm = self.final_norm
 
         if self.need_condition:

{x_transformers-1.30.23.dist-info → x_transformers-1.31.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: x-transformers
-Version: 1.30.23
+Version: 1.31.1
 Summary: X-Transformers - Pytorch
 Home-page: https://github.com/lucidrains/x-transformers
 Author: Phil Wang

{x_transformers-1.30.23.dist-info → x_transformers-1.31.1.dist-info}/RECORD

@@ -4,11 +4,11 @@ x_transformers/autoregressive_wrapper.py,sha256=uX8Mb0zLsQrZECt_9UGt35g7tC05Rk3n
 x_transformers/continuous.py,sha256=WO52n9lFAXv5-SGadi2cApGF8dkouN8QSTEOuC7erj8,6180
 x_transformers/dpo.py,sha256=LjvWgCkqTl-UuehrzQ8nkX5guLr4whYwsmm7SKSwdls,3450
 x_transformers/nonautoregressive_wrapper.py,sha256=ys_p8obc7lTeeodCqvkRKxOXQ1C9T3j5Jwr-JbVgnXk,10432
-x_transformers/x_transformers.py,sha256=tZixUvlsaEj3CpB49KLDOJ2BwYSPjdWotDUjB9Rbf7g,74213
+x_transformers/x_transformers.py,sha256=EehddXNWxU7NEqD8t76ekev__cCJ-F3J1oZjAD9PGa8,75806
 x_transformers/xl_autoregressive_wrapper.py,sha256=DCx4n0_c1tFai4nOqaWVnqx2p9eutsZsDMiMP1ckxNU,4117
 x_transformers/xval.py,sha256=QE1ltYZTR_eGgIHPP2BrMWVWVLqMW-OpDZh87BSmQEg,8563
-x_transformers-1.30.23.dist-info/LICENSE,sha256=As9u198X-U-vph5noInuUfqsAG2zX_oXPHDmdjwlPPY,1066
-x_transformers-1.30.23.dist-info/METADATA,sha256=LM8Y0bkOF259zCn_FE2A-Uw5Yjr8YrqCKNYuW4DqtQY,662
-x_transformers-1.30.23.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-x_transformers-1.30.23.dist-info/top_level.txt,sha256=hO6KGpFuGucRNEtRfme4A_rGcM53AKwGP7RVlRIxS5Q,15
-x_transformers-1.30.23.dist-info/RECORD,,
+x_transformers-1.31.1.dist-info/LICENSE,sha256=As9u198X-U-vph5noInuUfqsAG2zX_oXPHDmdjwlPPY,1066
+x_transformers-1.31.1.dist-info/METADATA,sha256=FWASwgSjICfN3sak8Itwh41R-g2sT_wzhBm0RA3vPzA,661
+x_transformers-1.31.1.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+x_transformers-1.31.1.dist-info/top_level.txt,sha256=hO6KGpFuGucRNEtRfme4A_rGcM53AKwGP7RVlRIxS5Q,15
+x_transformers-1.31.1.dist-info/RECORD,,

{x_transformers-1.30.23.dist-info → x_transformers-1.31.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.0)
+Generator: setuptools (70.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any