quantizers 1.0.1__tar.gz → 1.1.0__tar.gz

{quantizers-1.0.1 → quantizers-1.1.0}/.pre-commit-config.yaml

@@ -1,15 +1,12 @@
 exclude: '\.svg$|ap_types/|_version.py'
 
 repos:
-- repo: https://github.com/hhatto/autopep8
-  rev: v2.3.1
+- repo: https://github.com/astral-sh/ruff-pre-commit
+  rev: v0.8.2
   hooks:
-  - id: autopep8
-    language_version: python3
-    args: ['--max-line-length=65535',
-           '--ignore=E731,E402',
-           '--in-place',
-           ]
+    - id: ruff
+      args: [--fix]
+    - id: ruff-format
 
 - repo: https://github.com/pre-commit/pre-commit-hooks
   rev: v4.6.0
@@ -36,12 +33,6 @@ repos:
   - id: pyupgrade
     args: ["--py310-plus"]
 
-- repo: https://github.com/PyCQA/isort
-  rev: 5.13.2
-  hooks:
-  - id: isort
-    args: ['--line-length=65535']
-
 - repo: https://github.com/pre-commit/mirrors-clang-format
   rev: v18.1.8
   hooks:

{quantizers-1.0.1/src/quantizers.egg-info → quantizers-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantizers
-Version: 1.0.1
+Version: 1.1.0
 Author-email: Chang Sun <chsun@cern.ch>
 License: GNU Lesser General Public License v3 (LGPLv3)
 Project-URL: repository, https://github.com/calad0i/quantizers

{quantizers-1.0.1 → quantizers-1.1.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quantizers"
-version = "1.0.1"
+version = "1.1.0"
 authors = [{ name = "Chang Sun", email = "chsun@cern.ch" }]
 description = ""
 readme = "README.md"
@@ -70,3 +70,28 @@ addopts = "--import-mode=importlib --cov=src/quantizers --cov-report=xml --cov-r
 
 [tool.coverage.run]
 omit = ["*/_version.py"]
+
+[tool.coverage.report]
+exclude_lines = ['pragma: no cover', 'if TYPE_CHECKING:']
+
+[tool.ruff]
+include = ["src/**/*.py"]
+
+line-length = 130
+indent-width = 4
+
+target-version = "py310"
+
+[tool.ruff.format]
+quote-style = "single"
+indent-style = "space"
+skip-magic-trailing-comma = false
+docstring-code-format = true
+docstring-code-line-length = 130
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "F401"]
+ignore = ["E501", "F403", "F405"]
+explicit-preview-rules = true
+fixable = ["ALL"]
+unfixable = []

{quantizers-1.0.1 → quantizers-1.1.0}/src/quantizers/__init__.py

@@ -2,3 +2,5 @@ from .binary import *
 from .fixed_point import *
 from .minifloat import *
 from .stateful_quantizers import BinaryQ, FixedQ, MinifloatQ, TernaryQ
+
+__all__ = ['BinaryQ', 'FixedQ', 'MinifloatQ', 'TernaryQ']

{quantizers-1.0.1 → quantizers-1.1.0}/src/quantizers/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.0.1'
-__version_tuple__ = version_tuple = (1, 0, 1)
+__version__ = version = '1.1.0'
+__version_tuple__ = version_tuple = (1, 1, 0)

quantizers-1.1.0/src/quantizers/binary/__init__.py

@@ -0,0 +1,4 @@
+from .binary_ops import binary_quantize, ternary_quantize
+from .binary_ops_np import binary_quantize_np, ternary_quantize_np
+
+__all__ = ['binary_quantize', 'ternary_quantize', 'binary_quantize_np', 'ternary_quantize_np']

quantizers-1.0.1/src/quantizers/binary/binary_ops.py → quantizers-1.1.0/src/quantizers/binary/_binary_ops.py

@@ -1,28 +1,27 @@
 from keras import ops
-from keras.api.random import SeedGenerator
 
 
 @ops.custom_gradient
-def binary_quantize(x):
-    r = ops.where(x > 0, 1., -1.)
+def _binary_quantize(x):
+    r = ops.where(x > 0, 1.0, -1.0)
 
     def grad(*args, upstream=None):
         if upstream is None:
             (upstream,) = args
         dy = upstream
-        return dy * (1. - ops.tanh(x)**2)  # type: ignore
+        return dy * (1.0 - ops.tanh(x) ** 2)  # type: ignore
 
     return ops.stop_gradient(r), grad
 
 
 @ops.custom_gradient
-def ternary_quantize(x):
-    r = ops.where(x > 0.5, 1., ops.where(x < -0.5, -1., 0.))
+def _ternary_quantize(x):
+    r = ops.where(x > 0.5, 1.0, ops.where(x < -0.5, -1.0, 0.0))
 
     def grad(*args, upstream=None):
         if upstream is None:
             (upstream,) = args
         dy = upstream
-        return dy * (1. - ops.tanh(x)**2)  # type: ignore
+        return dy * (1.0 - ops.tanh(x) ** 2)  # type: ignore
 
     return ops.stop_gradient(r), grad

quantizers-1.1.0/src/quantizers/binary/binary_ops.py

@@ -0,0 +1,10 @@
+def binary_quantize(x):
+    from ._binary_ops import _binary_quantize
+
+    return _binary_quantize(x)
+
+
+def ternary_quantize(x):
+    from ._binary_ops import _ternary_quantize
+
+    return _ternary_quantize(x)

quantizers-1.1.0/src/quantizers/binary/binary_ops_np.py

@@ -0,0 +1,9 @@
+import numpy as np
+
+
+def binary_quantize_np(x):
+    return np.where(x > 0, 1.0, -1.0)
+
+
+def ternary_quantize_np(x):
+    return np.where(x > 0.5, 1.0, np.where(x < -0.5, -1.0, 0.0))

quantizers-1.1.0/src/quantizers/fixed_point/__init__.py

@@ -0,0 +1,4 @@
+from .fixed_point_ops import get_fixed_quantizer
+from .fixed_point_ops_np import get_fixed_quantizer_np
+
+__all__ = ['get_fixed_quantizer', 'get_fixed_quantizer_np']

quantizers-1.0.1/src/quantizers/fixed_point/fixed_point_ops.py → quantizers-1.1.0/src/quantizers/fixed_point/_fixed_point_ops.py

@@ -1,15 +1,14 @@
 from collections.abc import Callable
-from functools import singledispatch
 from typing import Any, TypeVar
 
 import keras
 from keras import ops
 from keras.api.random import SeedGenerator
+from numpy.typing import ArrayLike
 
 round_mode_registry: dict[str, Callable[[Any, bool | None], Any]] = {}
 round_mode_registry_scaled: dict[str, Callable[[Any, Any, bool | None, SeedGenerator | None], Any]] = {}
 saturation_mode_registry: dict[str, Callable[[Any, Any, Any, Any, bool | None], Any]] = {}
-from numpy.typing import ArrayLike
 
 T = TypeVar('T', bound=ArrayLike)
 
@@ -24,10 +23,11 @@ def _clip(x, min_value, max_value):
         if upstream is None:
             (upstream,) = args
         dy = upstream
-        dx = ops.where(~(mask1 | mask2), dy, 0.)
-        dmax = ops.where(mask1, dy, 0.)
-        dmin = ops.where(mask2, dy, 0.)
+        dx = ops.where(~(mask1 | mask2), dy, 0.0)
+        dmax = ops.where(mask1, dy, 0.0)
+        dmin = ops.where(mask2, dy, 0.0)
         return dx, dmin, dmax
+
     return r, grad
 
 
@@ -37,7 +37,7 @@ def rnd_mode(names: str | list[str] | tuple[str, ...]):
     def inner(func):
         @keras.ops.custom_gradient
         def inner_wrapper(x, f):
-            scale = 2.**f
+            scale = 2.0**f
             sx = x * scale
             sxq = func(sx)
             xq = sxq / scale
@@ -48,8 +48,9 @@ def rnd_mode(names: str | list[str] | tuple[str, ...]):
                     (upstream,) = args
                 dy = upstream
                 dx = dy
-                df = - ops.log(2.) * delta * dy  # type: ignore
+                df = -ops.log(2.0) * delta * dy  # type: ignore
                 return dx, df
+
             return ops.stop_gradient(xq), grad
 
         @keras.ops.custom_gradient
@@ -61,6 +62,7 @@ def rnd_mode(names: str | list[str] | tuple[str, ...]):
                     (upstream,) = args
                 dy = upstream
                 return dy
+
             return ops.stop_gradient(r), grad
 
         def wrapper(x, f, training=None, seed_gen=None):  # type: ignore
@@ -80,6 +82,7 @@ def rnd_mode(names: str | list[str] | tuple[str, ...]):
         round_mode_registry[func.__name__.upper()] = ste_wrapper
 
         return ste_wrapper
+
     return inner
 
 
@@ -136,6 +139,7 @@ def sat_mode(name: str | list | tuple):
             saturation_mode_registry[name] = func
         saturation_mode_registry[func.__name__.upper()] = func
         return func
+
     return inner
 
 
@@ -146,14 +150,14 @@ def wrap(x, k, i, f, training=None):
 
     xs = x
     bk = i + k
-    bias = k * 2.**(bk - 1)
-    return ((xs + bias) % (2.**bk) - bias)
+    bias = k * 2.0 ** (bk - 1)
+    return (xs + bias) % (2.0**bk) - bias
 
 
 @sat_mode('SAT')
 def sat(x, k, i, f, training=None):
-    f_eps = 2.**(-f)
-    __max = 2.**i
+    f_eps = 2.0 ** (-f)
+    __max = 2.0**i
     _max = __max - f_eps
     _min = -__max * k
     r = _clip(x, _min, _max)
@@ -162,8 +166,8 @@ def sat(x, k, i, f, training=None):
 
 @sat_mode('SAT_SYM')
 def sat_sym(x, k, i, f, training=None):
-    f_eps = 2.**(-f)
-    _max = 2.**i - f_eps
+    f_eps = 2.0 ** (-f)
+    _max = 2.0**i - f_eps
     _min = -_max * k
     r = _clip(x, _min, _max)
     return r
@@ -173,8 +177,8 @@ def sat_sym(x, k, i, f, training=None):
 def wrap_sm_fn(x, k, i, f, training=None, quant_fn: Callable = lambda x: x):
     # x=ops.round(x*2.**f)
     # High and low bounds are reflective. When overflows, can be less trash than WARP but still more trash than SAT.
-    eps = 2.**-f
-    high = 2.**i - eps
+    eps = 2.0**-f
+    high = 2.0**i - eps
     low = -(high + eps) * k
     interval = 2 ** (i + k)
     c1 = ((x) / interval) % 2 >= 1  # type: ignore
@@ -189,7 +193,9 @@ def wrap_sm_fn(x, k, i, f, training=None, quant_fn: Callable = lambda x: x):
     return mapped
 
 
-def get_fixed_quantizer(round_mode: str = 'TRN', overflow_mode: str = 'WRAP') -> Callable[[T, Any, Any, Any, bool | None, SeedGenerator | None], T]:
+def _get_fixed_quantizer(
+    round_mode: str = 'TRN', overflow_mode: str = 'WRAP'
+) -> Callable[[T, Any, Any, Any, bool | None, SeedGenerator | None], T]:
     """Get a stateless fixed-point quantizer given the round and overflow mode.
     The quantizer is differentiable w.r.t. to the input and f, also i if using saturation overflow mode.
 
@@ -200,13 +206,13 @@ def get_fixed_quantizer(round_mode: str = 'TRN', overflow_mode: str = 'WRAP') ->
     overflow_mode = overflow_mode.upper()
     round_fn_scaled = round_mode_registry_scaled.get(round_mode, None)
     if round_fn_scaled is None:
-        raise ValueError(f"Unknown rounding mode: {round_mode}")  # pragma: no cover
+        raise ValueError(f'Unknown rounding mode: {round_mode}')
     sat_fn = saturation_mode_registry.get(overflow_mode, None)
     if sat_fn is None:
-        raise ValueError(f"Unknown saturation mode: {overflow_mode}")  # pragma: no cover
+        raise ValueError(f'Unknown saturation mode: {overflow_mode}')
 
     if overflow_mode == 'WRAP_SM':
-        assert round_mode in ('RND', 'RND_CONV'), "WRAP_SM only supports RND and RND_CONV rounding modes in this implementation."
+        assert round_mode in ('RND', 'RND_CONV'), 'WRAP_SM only supports RND and RND_CONV rounding modes in this implementation.'
 
     def quantizer(x: T, k: T, i: T, f: T, training: bool | None = None, seed_gen: SeedGenerator | None = None) -> T:
         """Stateless fixed-point quantizer.
@@ -220,8 +226,10 @@ def get_fixed_quantizer(round_mode: str = 'TRN', overflow_mode: str = 'WRAP') ->
         i = ops.stop_gradient(ops.maximum(i, -f)) + (i - ops.stop_gradient(i))  # type: ignore
 
         if overflow_mode == 'WRAP_SM':
+
             def rnd_fn_wrapped(x):
                 return round_fn_scaled(x, f, training, seed_gen)
+
             return wrap_sm_fn(x, k, i, f, training, rnd_fn_wrapped)  # type: ignore
 
         # Workaround for gradient computation around 0.
@@ -233,6 +241,7 @@ def get_fixed_quantizer(round_mode: str = 'TRN', overflow_mode: str = 'WRAP') ->
         if overflow_mode == 'WRAP':
             x = sat_fn(x, k, i, f, training)
         return x
+
     return quantizer
 
 
@@ -240,7 +249,7 @@ def get_fixed_quantizer(round_mode: str = 'TRN', overflow_mode: str = 'WRAP') ->
 def register_stochastic_rounding():
     @keras.ops.custom_gradient
     def stochastic_scaled(x, f, noise):
-        scale = 2.**f
+        scale = 2.0**f
         sx = x * scale
         sxq = ops.floor(sx + noise)
         xq = sxq / scale
@@ -251,8 +260,9 @@ def register_stochastic_rounding():
                 (upstream,) = args
             dy = upstream
             dx = dy
-            df = - ops.log(2.) * delta * dy  # type: ignore
+            df = -ops.log(2.0) * delta * dy  # type: ignore
             return dx, df, None
+
         return ops.stop_gradient(xq), grad
 
     rnd_scaled = round_mode_registry_scaled['RND']

quantizers-1.1.0/src/quantizers/fixed_point/fixed_point_ops.py

@@ -0,0 +1,22 @@
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from numpy.typing import ArrayLike
+
+if TYPE_CHECKING:
+    from keras.api.random import SeedGenerator
+T = TypeVar('T', bound=ArrayLike)
+
+
+def get_fixed_quantizer(
+    round_mode: str = 'TRN', overflow_mode: str = 'WRAP'
+) -> Callable[[T, Any, Any, Any, bool | None, 'SeedGenerator | None'], T]:
+    """Get a stateless fixed-point quantizer given the round and overflow mode.
+    The quantizer is differentiable w.r.t. to the input and f, also i if using saturation overflow mode.
+
+    Args:
+        round_mode: round mode, one of
+    """
+    from ._fixed_point_ops import _get_fixed_quantizer
+
+    return _get_fixed_quantizer(round_mode, overflow_mode)

{quantizers-1.0.1 → quantizers-1.1.0}/src/quantizers/fixed_point/fixed_point_ops_np.py

@@ -2,7 +2,6 @@ from collections.abc import Callable
 from typing import Any, TypeVar
 
 import numpy as np
-from numpy.typing import ArrayLike
 
 round_mode_registry_np: dict[str, Callable[[Any, bool | None], Any]] = {}
 round_mode_registry_scaled_np: dict[str, Callable[[Any, Any, bool | None], Any]] = {}
@@ -16,7 +15,7 @@ def rnd_mode_np(names: str | list[str] | tuple[str, ...]):
 
     def inner(func):
         def wrapper(x, f, training=None, seed_gen=None):
-            scale = 2.**f
+            scale = 2.0**f
             sx = x * scale
             sxq = func(sx)
             xq = sxq / scale
@@ -33,6 +32,7 @@ def rnd_mode_np(names: str | list[str] | tuple[str, ...]):
         round_mode_registry_np[func.__name__.upper()] = func
 
         return func
+
     return inner
 
 
@@ -83,6 +83,7 @@ def sat_mode_np(name: str | list | tuple):
             saturation_mode_registry_np[name] = func
         saturation_mode_registry_np[func.__name__.upper()] = func
         return func
+
     return inner
 
 
@@ -90,14 +91,14 @@ def sat_mode_np(name: str | list | tuple):
 def wrap(x, k, i, f, training=None):
     xs = x
     bk = i + k
-    bias = k * 2.**(bk - 1)
-    return ((xs + bias) % (2.**bk) - bias)
+    bias = k * 2.0 ** (bk - 1)
+    return (xs + bias) % (2.0**bk) - bias
 
 
 @sat_mode_np('SAT')
 def sat(x, k, i, f, training=None):
-    f_eps = 2.**(-f)
-    __max = 2.**i
+    f_eps = 2.0 ** (-f)
+    __max = 2.0**i
     _max = __max - f_eps
     _min = -__max * k
     return np.clip(x, _min, _max)
@@ -105,16 +106,16 @@ def sat(x, k, i, f, training=None):
 
 @sat_mode_np('SAT_SYM')
 def sat_sym(x, k, i, f, training=None):
-    f_eps = 2.**(-f)
-    _max = 2.**i - f_eps
+    f_eps = 2.0 ** (-f)
+    _max = 2.0**i - f_eps
     _min = -_max * k
     return np.clip(x, _min, _max)
 
 
 @sat_mode_np('WRAP_SM')
 def wrap_sm_fn(x, k, i, f, training=None, quant_fn: Callable = lambda x: x):
-    eps = 2.**-f
-    high = 2.**i - eps
+    eps = 2.0**-f
+    high = 2.0**i - eps
     low = -(high + eps) * k
     interval = 2 ** (i + k)
     c1 = ((x) / interval) % 2 >= 1
@@ -136,22 +137,24 @@ def get_fixed_quantizer_np(round_mode: str = 'TRN', overflow_mode: str = 'WRAP')
 
     round_fn_scaled = round_mode_registry_scaled_np.get(round_mode, None)
     if round_fn_scaled is None:
-        raise ValueError(f"Unknown rounding mode: {round_mode}")  # pragma: no cover
+        raise ValueError(f'Unknown rounding mode: {round_mode}')
     sat_fn = saturation_mode_registry_np.get(overflow_mode, None)
     if sat_fn is None:
-        raise ValueError(f"Unknown saturation mode: {overflow_mode}")  # pragma: no cover
+        raise ValueError(f'Unknown saturation mode: {overflow_mode}')
 
     if overflow_mode == 'WRAP_SM':
-        assert round_mode in ('RND', 'RND_CONV'), "WRAP_SM only supports RND and RND_CONV rounding modes in this implementation."
+        assert round_mode in ('RND', 'RND_CONV'), 'WRAP_SM only supports RND and RND_CONV rounding modes in this implementation.'
 
     def quantizer(x: T, k: T, i: T, f: T, training: bool | None = False, seed_gen: None = None) -> np.ndarray:
-        assert not training, "Training mode not supported in numpy implementation."
+        assert not training, 'Training mode not supported in numpy implementation.'
 
         _i = np.maximum(i, -f)
 
         if overflow_mode == 'WRAP_SM':
+
             def rnd_fn_wrapped(x):
                 return round_fn_scaled(x, f, training)
+
             return wrap_sm_fn(x, k, _i, f, training, rnd_fn_wrapped)
 
         if overflow_mode != 'WRAP':
@@ -160,4 +163,5 @@ def get_fixed_quantizer_np(round_mode: str = 'TRN', overflow_mode: str = 'WRAP')
         if overflow_mode == 'WRAP':
             x = sat_fn(x, k, _i, f, training)
         return x
+
     return quantizer

quantizers-1.1.0/src/quantizers/minifloat/__init__.py

@@ -0,0 +1,4 @@
+from .float_point_ops import float_decompose, float_quantize
+from .float_point_ops_np import float_decompose_np, float_quantize_np
+
+__all__ = ['float_quantize', 'float_decompose', 'float_quantize_np', 'float_decompose_np']

quantizers-1.0.1/src/quantizers/minifloat/float_point_ops.py → quantizers-1.1.0/src/quantizers/minifloat/_float_point_ops.py

@@ -1,21 +1,20 @@
-import numpy as np
 from keras import ops
 
 
 @ops.custom_gradient
-def float_quantize(x, m, e, e0=0.):
-    '''Quantize an array to floatlet (m mantissa bits, excl. sign bit, e exponent bits) format. Tentative gradient impl.'''
+def _float_quantize(x, m, e, e0=0.0):
+    """Quantize an array to floatlet (m mantissa bits, excl. sign bit, e exponent bits) format. Tentative gradient impl."""
     m = m + 1
     eps = 1e-7
 
     e_req = ops.floor(ops.log2(ops.abs(x) + eps))  # type: ignore
-    _e_high = ops.maximum(2.**(e - 1), 1.)
+    _e_high = ops.maximum(2.0 ** (e - 1), 1.0)
     e_low, e_high = -_e_high + e0 + 1, _e_high + e0 - 1  # type: ignore
     e_act = ops.clip(e_req, e_low, e_high)
-    scale = 2.**(e_act - m + 1)
+    scale = 2.0 ** (e_act - m + 1)
     sig = x / scale
     qsig = ops.round(sig)
-    _sig_high = 2.**m
+    _sig_high = 2.0**m
     _sig_high = ops.where(e_high != e_act, _sig_high, _sig_high - 1)
     clip_sig = ops.clip(qsig, -_sig_high, _sig_high)  # type: ignore
     qx = clip_sig * scale
@@ -26,31 +25,32 @@ def float_quantize(x, m, e, e0=0.):
         dy = upstream
         mask_e = e_req != e_act
         mask_m = e_req <= e_high  # type: ignore
-        dm = ops.where(mask_m, scale * (sig - qsig) * dy * ops.log(2.), 0.)
-        d_exp = ops.where(mask_e, (x - qx) * dy * ops.log(2.), 0.)
-        de = d_exp * ops.log(2.) * _e_high  # type: ignore
+        dm = ops.where(mask_m, scale * (sig - qsig) * dy * ops.log(2.0), 0.0)
+        d_exp = ops.where(mask_e, (x - qx) * dy * ops.log(2.0), 0.0)
+        de = d_exp * ops.log(2.0) * _e_high  # type: ignore
         de0 = ops.where(e_req > e_high, d_exp, -d_exp)  # type: ignore
         return dy, dm, de, de0
 
     return ops.stop_gradient(qx), grad
 
 
-def float_decompose(x, m, e, e0=0):
-    '''Quantize an array to floatlet (m mantissa bits, excl. sign bit, e exponent bits) format. Tentative gradient impl.'''
+def _float_decompose(x, m, e, e0=0):
+    """Quantize an array to floatlet (m mantissa bits, excl. sign bit, e exponent bits) format. Tentative gradient impl."""
+
     m = m + 1
     eps = 1e-7
 
     e_req = ops.floor(ops.log2(ops.abs(x) + eps))  # type: ignore
-    _e_high = 2.**(e - 1)
+    _e_high = 2.0 ** (e - 1)
     e_low, e_high = -_e_high + e0, _e_high + e0 - 1
     e_act = ops.clip(e_req, e_low + 1, e_high)
-    scale = 2.**(e_act - m + 1)
+    scale = 2.0 ** (e_act - m + 1)
     sig = x / scale
     qsig = ops.round(sig)
-    cond = (e_act != e_high) & (ops.abs(qsig) == 2.**m)
+    cond = (e_act != e_high) & (ops.abs(qsig) == 2.0**m)
     e_act = ops.where(cond, e_act + 1, e_act)  # type: ignore
-    qsig = ops.where(cond, qsig / 2., qsig)  # type: ignore
-    r_mantissa_bound = 2 - 2.**(-m + 1)
-    r_mantissa = ops.clip(qsig * 2.**(-m + 1), -r_mantissa_bound, r_mantissa_bound)
+    qsig = ops.where(cond, qsig / 2.0, qsig)  # type: ignore
+    r_mantissa_bound = 2 - 2.0 ** (-m + 1)
+    r_mantissa = ops.clip(qsig * 2.0 ** (-m + 1), -r_mantissa_bound, r_mantissa_bound)
     r_exponent = e_act
     return r_mantissa, r_exponent

quantizers-1.1.0/src/quantizers/minifloat/float_point_ops.py

@@ -0,0 +1,12 @@
+def float_quantize(x, m, e, e0=0.0):
+    """Quantize an array to floatlet (m mantissa bits, excl. sign bit, e exponent bits) format. Tentative gradient impl."""
+    from ._float_point_ops import _float_quantize
+
+    return _float_quantize(x, m, e, e0)
+
+
+def float_decompose(x, m, e, e0=0):
+    """Quantize an array to floatlet (m mantissa bits, excl. sign bit, e exponent bits) format. Tentative gradient impl."""
+    from ._float_point_ops import _float_decompose
+
+    return _float_decompose(x, m, e, e0)

{quantizers-1.0.1 → quantizers-1.1.0}/src/quantizers/minifloat/float_point_ops_np.py

@@ -1,19 +1,19 @@
 import numpy as np
 
 
-def float_quantize_np(x, m, e, e0=0.):
-    '''Quantize an array to floatlet (m mantissa bits, excl. sign bit, e exponent bits) format. Tentative gradient impl.'''
+def float_quantize_np(x, m, e, e0=0.0):
+    """Quantize an array to floatlet (m mantissa bits, excl. sign bit, e exponent bits) format. Tentative gradient impl."""
     m = m + 1
     eps = 1e-7
 
     e_req = np.floor(np.log2(np.abs(x) + eps))  # type: ignore
-    _e_high = np.maximum(2.**(e - 1), 1.)
+    _e_high = np.maximum(2.0 ** (e - 1), 1.0)
     e_low, e_high = -_e_high + e0 + 1, _e_high + e0 - 1  # type: ignore
     e_act = np.clip(e_req, e_low, e_high)
-    scale = 2.**(e_act - m + 1)
+    scale = 2.0 ** (e_act - m + 1)
     sig = x / scale
     qsig = np.round(sig)
-    _sig_high = 2.**m
+    _sig_high = 2.0**m
     _sig_high = np.where(e_high != e_act, _sig_high, _sig_high - 1)
     clip_sig = np.clip(qsig, -_sig_high, _sig_high)  # type: ignore
     qx = clip_sig * scale
@@ -22,21 +22,21 @@ def float_quantize_np(x, m, e, e0=0.):
 
 
 def float_decompose_np(x, m, e, e0=0):
-    '''Quantize an array to floatlet (m mantissa bits, excl. sign bit, e exponent bits) format. Tentative gradient impl.'''
+    """Quantize an array to floatlet (m mantissa bits, excl. sign bit, e exponent bits) format. Tentative gradient impl."""
     m = m + 1
     eps = 1e-7
 
     e_req = np.floor(np.log2(np.abs(x) + eps))  # type: ignore
-    _e_high = 2.**(e - 1)
+    _e_high = 2.0 ** (e - 1)
     e_low, e_high = -_e_high + e0, _e_high + e0 - 1
     e_act = np.clip(e_req, e_low + 1, e_high)
-    scale = 2.**(e_act - m + 1)
+    scale = 2.0 ** (e_act - m + 1)
     sig = x / scale
     qsig = np.round(sig)
-    cond = (e_act != e_high) & (np.abs(qsig) == 2.**m)
+    cond = (e_act != e_high) & (np.abs(qsig) == 2.0**m)
     e_act = np.where(cond, e_act + 1, e_act)  # type: ignore
-    qsig = np.where(cond, qsig / 2., qsig)  # type: ignore
-    r_mantissa_bound = 2 - 2.**(-m + 1)
-    r_mantissa = np.clip(qsig * 2.**(-m + 1), -r_mantissa_bound, r_mantissa_bound)
+    qsig = np.where(cond, qsig / 2.0, qsig)  # type: ignore
+    r_mantissa_bound = 2 - 2.0 ** (-m + 1)
+    r_mantissa = np.clip(qsig * 2.0 ** (-m + 1), -r_mantissa_bound, r_mantissa_bound)
     r_exponent = e_act
     return r_mantissa, r_exponent

{quantizers-1.0.1 → quantizers-1.1.0}/src/quantizers/stateful_quantizers.py

@@ -18,12 +18,10 @@ class BinaryQ:
     """Stateful binary quantizer."""
 
     @overload
-    def __call__(self, x: T) -> np.ndarray:
-        ...  # pragma: no cover
+    def __call__(self, x: T) -> np.ndarray: ...
 
     @overload
-    def __call__(self, x: Any) -> Any:
-        ...  # pragma: no cover
+    def __call__(self, x: Any) -> Any: ...
 
     def __call__(self, x):
         use_numpy = not is_tensor(x)
@@ -40,12 +38,10 @@ class TernaryQ:
     """Stateful ternary quantizer."""
 
     @overload
-    def __call__(self, x: T) -> np.ndarray:
-        ...  # pragma: no cover
+    def __call__(self, x: T) -> np.ndarray: ...
 
     @overload
-    def __call__(self, x: Any) -> Any:
-        ...  # pragma: no cover
+    def __call__(self, x: Any) -> Any: ...
 
     def __call__(self, x):
         use_numpy = not is_tensor(x)
@@ -83,12 +79,10 @@ class FixedQ:
         self.overflow = overflow
 
     @overload
-    def __call__(self, x: T) -> np.ndarray:
-        ...  # pragma: no cover
+    def __call__(self, x: T) -> np.ndarray: ...
 
     @overload
-    def __call__(self, x: Any) -> Any:
-        ...  # pragma: no cover
+    def __call__(self, x: Any) -> Any: ...
 
     def __call__(self, x):
         use_numpy = not is_tensor(x)
@@ -123,12 +117,10 @@ class MinifloatQ:
         self.exponent_bias = exponent_bias
 
     @overload
-    def __call__(self, x: T) -> np.ndarray:
-        ...  # pragma: no cover
+    def __call__(self, x: T) -> np.ndarray: ...
 
     @overload
-    def __call__(self, x: Any) -> Any:
-        ...  # pragma: no cover
+    def __call__(self, x: Any) -> Any: ...
 
     def __call__(self, x):
         s, e, e0 = float(self.significant), float(self.exponent), float(self.exponent_bias)

{quantizers-1.0.1 → quantizers-1.1.0/src/quantizers.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantizers
-Version: 1.0.1
+Version: 1.1.0
 Author-email: Chang Sun <chsun@cern.ch>
 License: GNU Lesser General Public License v3 (LGPLv3)
 Project-URL: repository, https://github.com/calad0i/quantizers

{quantizers-1.0.1 → quantizers-1.1.0}/src/quantizers.egg-info/SOURCES.txt

@@ -15,12 +15,15 @@ src/quantizers.egg-info/dependency_links.txt
 src/quantizers.egg-info/requires.txt
 src/quantizers.egg-info/top_level.txt
 src/quantizers/binary/__init__.py
+src/quantizers/binary/_binary_ops.py
 src/quantizers/binary/binary_ops.py
 src/quantizers/binary/binary_ops_np.py
 src/quantizers/fixed_point/__init__.py
+src/quantizers/fixed_point/_fixed_point_ops.py
 src/quantizers/fixed_point/fixed_point_ops.py
 src/quantizers/fixed_point/fixed_point_ops_np.py
 src/quantizers/minifloat/__init__.py
+src/quantizers/minifloat/_float_point_ops.py
 src/quantizers/minifloat/float_point_ops.py
 src/quantizers/minifloat/float_point_ops_np.py
 test/test_quantizer_match.py

{quantizers-1.0.1 → quantizers-1.1.0}/test/test_quantizer_match.py

@@ -18,7 +18,7 @@ def register_cpp():
 
 @pytest.fixture(scope='session')
 def data():
-    arr = np.random.randint(-2.**15, 2.**15, 1000) * 2.**-8
+    arr = np.random.randint(-2**15, 2**15, 1000) * 2.**-8
     return ops.array(arr.astype(np.float32))
 
 
@@ -69,6 +69,7 @@ def test_fixed_quantizer_forward(fixed_round_mode, fixed_overflow_mode, k, b, i,
             pytest.skip('WRAP_SM only supports RND-like rounding')
 
     fixed_q = FixedQ(W, I, k, fixed_round_mode, fixed_overflow_mode)
+    print(fixed_q)
 
     arr_py_fixed_np = np.array(fixed_q(np.array(data)))
     arr_py_fixed = np.array(fixed_q(data))
@@ -91,8 +92,10 @@ def test_fixed_quantizer_forward(fixed_round_mode, fixed_overflow_mode, k, b, i,
 @pytest.mark.parametrize('E0', [0, 3, 5])
 def test_minifloat_quantizer_forward(M, E, E0, data, register_cpp):
 
-    arr_py_float = np.array(MinifloatQ(M, E, E0)(data))
-    arr_py_float_np = np.array(MinifloatQ(M, E, E0)(np.array(data)))
+    q = MinifloatQ(M, E, E0)
+    print(q)
+    arr_py_float = np.array(q(data))
+    arr_py_float_np = np.array(q(np.array(data)))
     assert np.all(arr_py_float_np == arr_py_float), 'numpy / keras implementation inconsistent'
 
     arr_c_float = c_quantize_float(data, M, E, E0)
@@ -144,8 +147,10 @@ def test_fixed_float_mult(fixed_round_mode, fixed_overflow_mode, k, i, f, M, E,
 
 
 def test_binary(data, register_cpp):
-    arr_py_binary = BinaryQ()(data)
-    arr_py_binary_np = np.array(BinaryQ()(np.array(data)))
+    q = BinaryQ()
+    print(q)
+    arr_py_binary = q(data)
+    arr_py_binary_np = np.array(q(np.array(data)))
     assert np.all(arr_py_binary_np == arr_py_binary), 'numpy / keras implementation inconsistent'
 
     arr_c_binary = c_quantize_binary(data)
@@ -161,8 +166,10 @@ def test_binary(data, register_cpp):
 
 
 def test_ternary(data, register_cpp):
-    arr_py_ternary = TernaryQ()(data)
-    arr_py_ternary_np = np.array(TernaryQ()(np.array(data)))
+    q = TernaryQ()
+    print(q)
+    arr_py_ternary = q(data)
+    arr_py_ternary_np = np.array(q(np.array(data)))
     assert np.all(arr_py_ternary_np == arr_py_ternary), 'numpy / keras implementation inconsistent'
 
     arr_c_ternary = c_quantize_ternary(data)

{quantizers-1.0.1 → quantizers-1.1.0}/test/test_stateless_quantizer.py

@@ -6,7 +6,7 @@ import numpy as np
 import pytest
 
 from quantizers import binary_quantize, float_decompose, float_decompose_np, float_quantize, get_fixed_quantizer, ternary_quantize
-from quantizers.fixed_point.fixed_point_ops import round_mode_registry
+from quantizers.fixed_point._fixed_point_ops import round_mode_registry
 
 
 @pytest.fixture(scope='module')

quantizers-1.0.1/src/quantizers/binary/__init__.py

@@ -1,9 +0,0 @@
-from .binary_ops_np import binary_quantize_np, ternary_quantize_np
-
-try:
-    from .binary_ops import binary_quantize, ternary_quantize
-except ImportError:
-    binary_quantize = binary_quantize_np
-    ternary_quantize = ternary_quantize_np
-
-__all__ = ['binary_quantize', 'ternary_quantize', 'binary_quantize_np', 'ternary_quantize_np']

quantizers-1.0.1/src/quantizers/binary/binary_ops_np.py

@@ -1,9 +0,0 @@
-import numpy as np
-
-
-def binary_quantize_np(x):
-    return np.where(x > 0, 1., -1.)
-
-
-def ternary_quantize_np(x):
-    return np.where(x > 0.5, 1., np.where(x < -0.5, -1., 0.))

quantizers-1.0.1/src/quantizers/fixed_point/__init__.py

@@ -1,8 +0,0 @@
-from .fixed_point_ops_np import get_fixed_quantizer_np
-
-try:
-    from .fixed_point_ops import get_fixed_quantizer
-except ImportError:
-    get_fixed_quantizer = get_fixed_quantizer_np
-
-__all__ = ['get_fixed_quantizer', 'get_fixed_quantizer_np']

quantizers-1.0.1/src/quantizers/minifloat/__init__.py

@@ -1,9 +0,0 @@
-from .float_point_ops_np import float_decompose_np, float_quantize_np
-
-try:
-    from .float_point_ops import float_decompose, float_quantize
-except ImportError:
-    float_quantize = float_quantize_np
-    float_decompose = float_decompose_np
-
-__all__ = ['float_quantize', 'float_decompose', 'float_quantize_np', 'float_decompose_np']