PyPI - bitsandbytes-cpu-fork - Versions diffs - 0.50.2.dev2__py3-none-win_amd64.whl → 0.50.2.dev4__py3-none-win_amd64.whl - Mend

bitsandbytes-cpu-fork 0.50.2.dev2__py3-none-win_amd64.whl → 0.50.2.dev4__py3-none-win_amd64.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (54) hide show

bitsandbytes/__init__.py +1 -1
bitsandbytes/__main__.py +4 -4
bitsandbytes/_cpu_caps.py +110 -0
bitsandbytes/_ops.py +526 -526
bitsandbytes/autograd/_functions.py +491 -491
bitsandbytes/backends/cpu/ops.py +805 -805
bitsandbytes/backends/cuda/ops.py +1212 -1212
bitsandbytes/backends/default/ops.py +632 -632
bitsandbytes/backends/hpu/ops.py +53 -53
bitsandbytes/backends/mps/ops.py +277 -277
bitsandbytes/backends/triton/kernels_4bit.py +583 -577
bitsandbytes/backends/triton/kernels_8bit_quant.py +195 -195
bitsandbytes/backends/triton/kernels_optim.py +1177 -1177
bitsandbytes/backends/triton/ops.py +304 -304
bitsandbytes/backends/utils.py +94 -94
bitsandbytes/backends/xpu/ops.py +305 -305
bitsandbytes/cextension.py +447 -405
bitsandbytes/cli.py +50 -50
bitsandbytes/consts.py +12 -12
bitsandbytes/cuda_specs.py +111 -111
bitsandbytes/detect_cpu.py +189 -189
bitsandbytes/diagnostics/cuda.py +193 -193
bitsandbytes/diagnostics/main.py +134 -134
bitsandbytes/diagnostics/utils.py +12 -12
bitsandbytes/disk_balancer.py +1276 -1224
bitsandbytes/efst.py +777 -0
bitsandbytes/functional.py +1836 -1836
bitsandbytes/gdn_cpu.py +616 -602
bitsandbytes/libbitsandbytes_cpu.dll +0 -0
bitsandbytes/nn/__init__.py +19 -19
bitsandbytes/nn/modules.py +1220 -1220
bitsandbytes/nn/parametrize.py +206 -206
bitsandbytes/optim/__init__.py +0 -4
bitsandbytes/optim/adagrad.py +187 -187
bitsandbytes/optim/adam.py +346 -346
bitsandbytes/optim/adamw.py +337 -337
bitsandbytes/optim/ademamix.py +410 -410
bitsandbytes/optim/lamb.py +190 -190
bitsandbytes/optim/lars.py +259 -259
bitsandbytes/optim/lion.py +266 -266
bitsandbytes/optim/optimizer.py +756 -756
bitsandbytes/optim/rmsprop.py +170 -170
bitsandbytes/optim/sgd.py +152 -152
bitsandbytes/torch_cpu_kit.py +468 -468
bitsandbytes/utils.py +208 -208
bitsandbytes_cpu_cli.py +1012 -949
{bitsandbytes_cpu_fork-0.50.2.dev2.dist-info → bitsandbytes_cpu_fork-0.50.2.dev4.dist-info}/METADATA +12 -4
bitsandbytes_cpu_fork-0.50.2.dev4.dist-info/RECORD +64 -0
{bitsandbytes_cpu_fork-0.50.2.dev2.dist-info → bitsandbytes_cpu_fork-0.50.2.dev4.dist-info}/licenses/LICENSE +21 -21
bitsandbytes/optim/adamw4bit.py +0 -183
bitsandbytes_cpu_fork-0.50.2.dev2.dist-info/RECORD +0 -63
{bitsandbytes_cpu_fork-0.50.2.dev2.dist-info → bitsandbytes_cpu_fork-0.50.2.dev4.dist-info}/WHEEL +0 -0
{bitsandbytes_cpu_fork-0.50.2.dev2.dist-info → bitsandbytes_cpu_fork-0.50.2.dev4.dist-info}/entry_points.txt +0 -0
{bitsandbytes_cpu_fork-0.50.2.dev2.dist-info → bitsandbytes_cpu_fork-0.50.2.dev4.dist-info}/top_level.txt +0 -0

bitsandbytes/optim/lion.py CHANGED Viewed

@@ -1,266 +1,266 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-from bitsandbytes.optim.optimizer import Optimizer1State
-class Lion(Optimizer1State):
-    def __init__(
-        self,
-        params,
-        lr=1e-4,
-        betas=(0.9, 0.99),
-        weight_decay=0,
-        optim_bits=32,
-        args=None,
-        min_8bit_size=4096,
-        is_paged=False,
-    ):
-        """
-        Base Lion optimizer.
-        Arguments:
-            params (`torch.tensor`):
-                The input parameters to optimize.
-            lr (`float`, defaults to 1e-4):
-                The learning rate.
-            betas (`tuple(float, float)`, defaults to (0.9, 0.999)):
-                The beta values are the decay rates of the first and second-order moment of the optimizer.
-            weight_decay (`float`, defaults to 0):
-                The weight decay value for the optimizer.
-            optim_bits (`int`, defaults to 32):
-                The number of bits of the optimizer state.
-            args (`object`, defaults to `None`):
-                An object with additional arguments.
-            min_8bit_size (`int`, defaults to 4096):
-                The minimum number of elements of the parameter tensors for 8-bit optimization.
-            is_paged (`bool`, defaults to `False`):
-                Whether the optimizer is a paged optimizer or not.
-        """
-        super().__init__(
-            "lion",
-            params,
-            lr,
-            betas,
-            0.0,
-            weight_decay,
-            optim_bits,
-            args,
-            min_8bit_size,
-            is_paged=is_paged,
-        )
-class Lion8bit(Optimizer1State):
-    def __init__(
-        self,
-        params,
-        lr=1e-4,
-        betas=(0.9, 0.99),
-        weight_decay=0,
-        args=None,
-        min_8bit_size=4096,
-        is_paged=False,
-    ):
-        """
-        8-bit Lion optimizer.
-        Arguments:
-            params (`torch.tensor`):
-                The input parameters to optimize.
-            lr (`float`, defaults to 1e-4):
-                The learning rate.
-            betas (`tuple(float, float)`, defaults to (0.9, 0.999)):
-                The beta values are the decay rates of the first and second-order moment of the optimizer.
-            weight_decay (`float`, defaults to 0):
-                The weight decay value for the optimizer.
-            args (`object`, defaults to `None`):
-                An object with additional arguments.
-            min_8bit_size (`int`, defaults to 4096):
-                The minimum number of elements of the parameter tensors for 8-bit optimization.
-            is_paged (`bool`, defaults to `False`):
-                Whether the optimizer is a paged optimizer or not.
-        """
-        super().__init__(
-            "lion",
-            params,
-            lr,
-            betas,
-            0.0,
-            weight_decay,
-            8,
-            args,
-            min_8bit_size,
-            is_paged=is_paged,
-        )
-class Lion32bit(Optimizer1State):
-    def __init__(
-        self,
-        params,
-        lr=1e-4,
-        betas=(0.9, 0.99),
-        weight_decay=0,
-        args=None,
-        min_8bit_size=4096,
-        is_paged=False,
-    ):
-        """
-        32-bit Lion optimizer.
-        Arguments:
-            params (`torch.tensor`):
-                The input parameters to optimize.
-            lr (`float`, defaults to 1e-4):
-                The learning rate.
-            betas (`tuple(float, float)`, defaults to (0.9, 0.999)):
-                The beta values are the decay rates of the first and second-order moment of the optimizer.
-            weight_decay (`float`, defaults to 0):
-                The weight decay value for the optimizer.
-            args (`object`, defaults to `None`):
-                An object with additional arguments.
-            min_8bit_size (`int`, defaults to 4096):
-                The minimum number of elements of the parameter tensors for 8-bit optimization.
-            is_paged (`bool`, defaults to `False`):
-                Whether the optimizer is a paged optimizer or not.
-        """
-        super().__init__(
-            "lion",
-            params,
-            lr,
-            betas,
-            0.0,
-            weight_decay,
-            32,
-            args,
-            min_8bit_size,
-            is_paged=is_paged,
-        )
-class PagedLion(Optimizer1State):
-    def __init__(
-        self,
-        params,
-        lr=1e-4,
-        betas=(0.9, 0.99),
-        weight_decay=0,
-        optim_bits=32,
-        args=None,
-        min_8bit_size=4096,
-    ):
-        """
-        Paged Lion optimizer.
-        Arguments:
-            params (`torch.tensor`):
-                The input parameters to optimize.
-            lr (`float`, defaults to 1e-4):
-                The learning rate.
-            betas (`tuple(float, float)`, defaults to (0.9, 0.999)):
-                The beta values are the decay rates of the first and second-order moment of the optimizer.
-            weight_decay (`float`, defaults to 0):
-                The weight decay value for the optimizer.
-            optim_bits (`int`, defaults to 32):
-                The number of bits of the optimizer state.
-            args (`object`, defaults to `None`):
-                An object with additional arguments.
-            min_8bit_size (`int`, defaults to 4096):
-                The minimum number of elements of the parameter tensors for 8-bit optimization.
-        """
-        super().__init__(
-            "lion",
-            params,
-            lr,
-            betas,
-            0.0,
-            weight_decay,
-            optim_bits,
-            args,
-            min_8bit_size,
-            is_paged=True,
-        )
-class PagedLion8bit(Optimizer1State):
-    def __init__(
-        self,
-        params,
-        lr=1e-4,
-        betas=(0.9, 0.99),
-        weight_decay=0,
-        args=None,
-        min_8bit_size=4096,
-    ):
-        """
-        Paged 8-bit Lion optimizer.
-        Arguments:
-            params (`torch.tensor`):
-                The input parameters to optimize.
-            lr (`float`, defaults to 1e-4):
-                The learning rate.
-            betas (`tuple(float, float)`, defaults to (0.9, 0.999)):
-                The beta values are the decay rates of the first and second-order moment of the optimizer.
-            weight_decay (`float`, defaults to 0):
-                The weight decay value for the optimizer.
-            args (`object`, defaults to `None`):
-                An object with additional arguments.
-            min_8bit_size (`int`, defaults to 4096):
-                The minimum number of elements of the parameter tensors for 8-bit optimization.
-        """
-        super().__init__(
-            "lion",
-            params,
-            lr,
-            betas,
-            0.0,
-            weight_decay,
-            8,
-            args,
-            min_8bit_size,
-            is_paged=True,
-        )
-class PagedLion32bit(Optimizer1State):
-    def __init__(
-        self,
-        params,
-        lr=1e-4,
-        betas=(0.9, 0.99),
-        weight_decay=0,
-        args=None,
-        min_8bit_size=4096,
-    ):
-        """
-        Paged 32-bit Lion optimizer.
-        Arguments:
-            params (`torch.tensor`):
-                The input parameters to optimize.
-            lr (`float`, defaults to 1e-4):
-                The learning rate.
-            betas (`tuple(float, float)`, defaults to (0.9, 0.999)):
-                The beta values are the decay rates of the first and second-order moment of the optimizer.
-            weight_decay (`float`, defaults to 0):
-                The weight decay value for the optimizer.
-            args (`object`, defaults to `None`):
-                An object with additional arguments.
-            min_8bit_size (`int`, defaults to 4096):
-                The minimum number of elements of the parameter tensors for 8-bit optimization.
-        """
-        super().__init__(
-            "lion",
-            params,
-            lr,
-            betas,
-            0.0,
-            weight_decay,
-            32,
-            args,
-            min_8bit_size,
-            is_paged=True,
-        )
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+from bitsandbytes.optim.optimizer import Optimizer1State
+class Lion(Optimizer1State):
+    def __init__(
+        self,
+        params,
+        lr=1e-4,
+        betas=(0.9, 0.99),
+        weight_decay=0,
+        optim_bits=32,
+        args=None,
+        min_8bit_size=4096,
+        is_paged=False,
+    ):
+        """
+        Base Lion optimizer.
+        Arguments:
+            params (`torch.tensor`):
+                The input parameters to optimize.
+            lr (`float`, defaults to 1e-4):
+                The learning rate.
+            betas (`tuple(float, float)`, defaults to (0.9, 0.999)):
+                The beta values are the decay rates of the first and second-order moment of the optimizer.
+            weight_decay (`float`, defaults to 0):
+                The weight decay value for the optimizer.
+            optim_bits (`int`, defaults to 32):
+                The number of bits of the optimizer state.
+            args (`object`, defaults to `None`):
+                An object with additional arguments.
+            min_8bit_size (`int`, defaults to 4096):
+                The minimum number of elements of the parameter tensors for 8-bit optimization.
+            is_paged (`bool`, defaults to `False`):
+                Whether the optimizer is a paged optimizer or not.
+        """
+        super().__init__(
+            "lion",
+            params,
+            lr,
+            betas,
+            0.0,
+            weight_decay,
+            optim_bits,
+            args,
+            min_8bit_size,
+            is_paged=is_paged,
+        )
+class Lion8bit(Optimizer1State):
+    def __init__(
+        self,
+        params,
+        lr=1e-4,
+        betas=(0.9, 0.99),
+        weight_decay=0,
+        args=None,
+        min_8bit_size=4096,
+        is_paged=False,
+    ):
+        """
+        8-bit Lion optimizer.
+        Arguments:
+            params (`torch.tensor`):
+                The input parameters to optimize.
+            lr (`float`, defaults to 1e-4):
+                The learning rate.
+            betas (`tuple(float, float)`, defaults to (0.9, 0.999)):
+                The beta values are the decay rates of the first and second-order moment of the optimizer.
+            weight_decay (`float`, defaults to 0):
+                The weight decay value for the optimizer.
+            args (`object`, defaults to `None`):
+                An object with additional arguments.
+            min_8bit_size (`int`, defaults to 4096):
+                The minimum number of elements of the parameter tensors for 8-bit optimization.
+            is_paged (`bool`, defaults to `False`):
+                Whether the optimizer is a paged optimizer or not.
+        """
+        super().__init__(
+            "lion",
+            params,
+            lr,
+            betas,
+            0.0,
+            weight_decay,
+            8,
+            args,
+            min_8bit_size,
+            is_paged=is_paged,
+        )
+class Lion32bit(Optimizer1State):
+    def __init__(
+        self,
+        params,
+        lr=1e-4,
+        betas=(0.9, 0.99),
+        weight_decay=0,
+        args=None,
+        min_8bit_size=4096,
+        is_paged=False,
+    ):
+        """
+        32-bit Lion optimizer.
+        Arguments:
+            params (`torch.tensor`):
+                The input parameters to optimize.
+            lr (`float`, defaults to 1e-4):
+                The learning rate.
+            betas (`tuple(float, float)`, defaults to (0.9, 0.999)):
+                The beta values are the decay rates of the first and second-order moment of the optimizer.
+            weight_decay (`float`, defaults to 0):
+                The weight decay value for the optimizer.
+            args (`object`, defaults to `None`):
+                An object with additional arguments.
+            min_8bit_size (`int`, defaults to 4096):
+                The minimum number of elements of the parameter tensors for 8-bit optimization.
+            is_paged (`bool`, defaults to `False`):
+                Whether the optimizer is a paged optimizer or not.
+        """
+        super().__init__(
+            "lion",
+            params,
+            lr,
+            betas,
+            0.0,
+            weight_decay,
+            32,
+            args,
+            min_8bit_size,
+            is_paged=is_paged,
+        )
+class PagedLion(Optimizer1State):
+    def __init__(
+        self,
+        params,
+        lr=1e-4,
+        betas=(0.9, 0.99),
+        weight_decay=0,
+        optim_bits=32,
+        args=None,
+        min_8bit_size=4096,
+    ):
+        """
+        Paged Lion optimizer.
+        Arguments:
+            params (`torch.tensor`):
+                The input parameters to optimize.
+            lr (`float`, defaults to 1e-4):
+                The learning rate.
+            betas (`tuple(float, float)`, defaults to (0.9, 0.999)):
+                The beta values are the decay rates of the first and second-order moment of the optimizer.
+            weight_decay (`float`, defaults to 0):
+                The weight decay value for the optimizer.
+            optim_bits (`int`, defaults to 32):
+                The number of bits of the optimizer state.
+            args (`object`, defaults to `None`):
+                An object with additional arguments.
+            min_8bit_size (`int`, defaults to 4096):
+                The minimum number of elements of the parameter tensors for 8-bit optimization.
+        """
+        super().__init__(
+            "lion",
+            params,
+            lr,
+            betas,
+            0.0,
+            weight_decay,
+            optim_bits,
+            args,
+            min_8bit_size,
+            is_paged=True,
+        )
+class PagedLion8bit(Optimizer1State):
+    def __init__(
+        self,
+        params,
+        lr=1e-4,
+        betas=(0.9, 0.99),
+        weight_decay=0,
+        args=None,
+        min_8bit_size=4096,
+    ):
+        """
+        Paged 8-bit Lion optimizer.
+        Arguments:
+            params (`torch.tensor`):
+                The input parameters to optimize.
+            lr (`float`, defaults to 1e-4):
+                The learning rate.
+            betas (`tuple(float, float)`, defaults to (0.9, 0.999)):
+                The beta values are the decay rates of the first and second-order moment of the optimizer.
+            weight_decay (`float`, defaults to 0):
+                The weight decay value for the optimizer.
+            args (`object`, defaults to `None`):
+                An object with additional arguments.
+            min_8bit_size (`int`, defaults to 4096):
+                The minimum number of elements of the parameter tensors for 8-bit optimization.
+        """
+        super().__init__(
+            "lion",
+            params,
+            lr,
+            betas,
+            0.0,
+            weight_decay,
+            8,
+            args,
+            min_8bit_size,
+            is_paged=True,
+        )
+class PagedLion32bit(Optimizer1State):
+    def __init__(
+        self,
+        params,
+        lr=1e-4,
+        betas=(0.9, 0.99),
+        weight_decay=0,
+        args=None,
+        min_8bit_size=4096,
+    ):
+        """
+        Paged 32-bit Lion optimizer.
+        Arguments:
+            params (`torch.tensor`):
+                The input parameters to optimize.
+            lr (`float`, defaults to 1e-4):
+                The learning rate.
+            betas (`tuple(float, float)`, defaults to (0.9, 0.999)):
+                The beta values are the decay rates of the first and second-order moment of the optimizer.
+            weight_decay (`float`, defaults to 0):
+                The weight decay value for the optimizer.
+            args (`object`, defaults to `None`):
+                An object with additional arguments.
+            min_8bit_size (`int`, defaults to 4096):
+                The minimum number of elements of the parameter tensors for 8-bit optimization.
+        """
+        super().__init__(
+            "lion",
+            params,
+            lr,
+            betas,
+            0.0,
+            weight_decay,
+            32,
+            args,
+            min_8bit_size,
+            is_paged=True,
+        )