da4ml 0.1.2__py3-none-any.whl → 0.2.1__py3-none-any.whl

da4ml/cmvm/fixed_variable.py

@@ -1,205 +0,0 @@
-from math import ceil, log2
-
-
-class Singleton(type):
-    _instances = {}
-
-    def __call__(cls, *args, **kwargs):
-        if cls not in cls._instances:
-            cls._instances[cls] = super().__call__(*args, **kwargs)
-        return cls._instances[cls]
-
-
-class Namer(metaclass=Singleton):
-    def __init__(self):
-        self._counters = {}
-        self._scope = 'global'
-
-    def set_scope(self, scope: str):
-        self._scope = scope
-
-    def tmp_scope(self):
-        _counters = self._counters
-        outer = self
-
-        class _Ctx:
-            def __enter__(self):
-                outer._counters = {}
-
-            def __exit__(self, *args) -> None:
-                outer._counters = _counters
-
-        return _Ctx()
-
-    def __call__(self, name: str, scope: str | None = None) -> str:
-        scope = self._scope if scope is None else scope
-        counters = self._counters.setdefault(scope, {})
-        if name not in counters:
-            counters[name] = -1
-        counters[name] += 1
-        return f'{name}{counters[name]}'
-
-
-class FixedVariable:
-    def __init__(
-        self,
-        int_min: int,
-        int_max: int,
-        shift: int,
-        symmetric: bool = False,
-        _depth: int = 0,
-        name: str = '',
-        _factor: int = 1,
-        _from: tuple['FixedVariable', 'FixedVariable'] | None = None,
-        namer=Namer(),
-    ):
-        self.int_min = int_min
-        self.int_max = int_max
-        self.shift = shift
-        self.symmetric = symmetric
-        self._depth = _depth
-        self.name = name
-        self._factor = _factor
-        self._from = _from
-        self.namer = namer
-
-        if self.int_min > self.int_max:
-            raise ValueError('int_min must be less than or equal to int_max')
-
-    @property
-    def k(self) -> int:
-        return int(self.min < 0)
-
-    @property
-    def b(self) -> int:
-        return ceil(log2(max(self.int_max + 1, -self.int_min)))
-
-    @property
-    def i(self) -> int:
-        return self.b - self.shift
-
-    @property
-    def min(self) -> float:
-        return self.int_min * 2.0 ** (-self.shift)
-
-    @property
-    def max(self) -> float:
-        return self.int_max * 2.0 ** (-self.shift)
-
-    def __str__(self) -> str:
-        s = '' if self.k else 'u'
-        p = f'{s}fixed({self.b+self.k}, {self.i+self.k})'
-        if self.int_min == self.int_max:
-            return f'{p}({self.min})'
-        return p
-
-    def __add__(self, other: 'FixedVariable|float'):
-        if other == 0:
-            return self
-        if not isinstance(other, FixedVariable):
-            return self + self.from_const(other, self.namer)
-
-        assert self.namer is other.namer, 'Namer must be the same'
-        shift = max(self.shift, other.shift)
-        _shift0, _shift1 = shift - self.shift, shift - other.shift
-        int_min = (self.int_min << _shift0) + (other.int_min << _shift1)
-        int_max = (self.int_max << _shift0) + (other.int_max << _shift1)
-
-        return FixedVariable(
-            int_min,
-            int_max,
-            shift,
-            symmetric=False,
-            _depth=max(self._depth, other._depth) + 1,
-            _from=(self, other),
-            _factor=1,
-            name=self.namer('v'),
-            namer=self.namer,
-        )
-
-    def __radd__(self, other: 'FixedVariable|float'):
-        return self + other
-
-    def __neg__(self):
-        return FixedVariable(
-            -self.int_max,
-            -self.int_min,
-            self.shift,
-            symmetric=False,
-            _depth=self._depth,
-            _from=self._from,
-            _factor=-self._factor,
-            name=self.name,
-            namer=self.namer,
-        )
-
-    def __sub__(self, other: 'FixedVariable'):
-        return self + (-other)
-
-    def __lshift__(self, other: int):
-        return FixedVariable(
-            self.int_min,
-            self.int_max,
-            self.shift - other,
-            False,
-            self._depth,
-            _from=self._from,
-            _factor=self._factor * 2**other,
-            name=self.name,
-            namer=self.namer,
-        )
-
-    def __rshift__(self, other: int):
-        return self << -other
-
-    def __mul__(self, other: float):
-        if other == 1:
-            return self
-        if other == -1:
-            return -self
-        if other == 0:
-            return self.from_const(0, self.namer)
-        assert log2(abs(other)) % 1 == 0
-        sign = -1 if other < 0 else 1
-        shift = int(log2(abs(other)))
-        return self << shift if sign == 1 else -self << shift
-
-    def __rmul__(self, other: float):
-        return self * other
-
-    def __repr__(self) -> str:
-        if self._factor == 1:
-            return self.__str__()
-        return f'({self._factor}) {self.__str__()}'
-
-    @classmethod
-    def from_nb_precision(cls, p, name: str | None = None, namer=Namer()):
-        name = Namer()('inp') if name is None else name
-        return cls(p.int_min, p.int_max, p.shift, p.symmetric, p._depth, name=name, namer=namer)
-
-    @classmethod
-    def from_const(cls, value: float, namer=Namer()):
-        if value == 0:
-            return cls(0, 0, 0, False, 0, '0', namer=namer)
-        _low, _high = -32, 32
-        while _high - _low > 1:
-            _mid = (_high + _low) // 2
-            _value = value * (2.0**_mid)
-            if _value == int(_value):
-                _high = _mid
-            else:
-                _low = _mid
-        _value = value * (2.0**_high)
-        shift = int(_high)
-        int_min = int_max = int(_value)
-        return cls(
-            int_max,
-            int_min,
-            shift,
-            symmetric=False,
-            _depth=0,
-            _from=None,
-            _factor=1,
-            name=str(value),
-            namer=namer,
-        )

da4ml/cmvm/graph_compile.py

@@ -1,85 +0,0 @@
-import numpy as np
-
-from .balanced_reduction import balanced_reduction
-from .fixed_variable import FixedVariable
-from .nb_fixed_precision import NBFixedPrecision
-from .utils import DAState, OpCode
-
-
-def var_from_nb_var(op_codes: OpCode, nb_variables: list[NBFixedPrecision], bias_idx: int):
-    variables: list[FixedVariable] = []
-
-    i = 0
-    while i < len(op_codes) and op_codes[i].pos1 < 0:
-        op_code = op_codes[i]
-        pos0, pos1 = op_code.pos0, op_code.pos1
-        shift = op_code.shift0
-        if pos1 >= 0:
-            break
-        v = FixedVariable.from_nb_precision(nb_variables[pos0], name=f'inp[{pos0+bias_idx}]')
-        v._factor = 2.0**shift
-        variables.append(v)
-        i += 1
-
-    while i < len(op_codes):
-        op_code = op_codes[i]
-        pos0, pos1 = op_code.pos0, op_code.pos1
-        shift0, shift1 = op_code.shift0, op_code.shift1
-        sign0, sign1 = op_code.sign0, op_code.sign1
-        v0, v1 = variables[pos0], variables[pos1]
-        v = sign0 * (v0 << shift0) + sign1 * (v1 << shift1)
-        variables.append(v)
-        i += 1
-
-    return variables
-
-
-def gather_output_var_cumlist(state: DAState, variables: list[FixedVariable]):
-    n_out = state.kernel.shape[1]
-    cumlist = [[] for _ in range(n_out)]
-    csd = np.array(state.csd)
-    for di, do, shift in zip(*np.where(csd != 0)):
-        sign = csd[di, do, shift]
-        cumlist[do].append(sign * (variables[di] << shift))
-    return cumlist
-
-
-def graph_compile_states(states: list[list[DAState]], signed_balanced_reduction=True):
-    n_split_in = len(states)
-    n_split_out = len(states[0])
-    assert all(len(states[i]) == n_split_out for i in range(n_split_in))
-    kernel_shapes = np.empty((n_split_in, n_split_out, 2), dtype=np.int64)
-    for i, j in np.ndindex(n_split_in, n_split_out):
-        state = states[i][j]
-        kernel_shapes[i, j] = state.kernel.shape
-    assert np.all(np.std(kernel_shapes[:, :, 0], axis=1) == 0), 'Input kernel shapes must be the same'
-    assert np.all(np.std(kernel_shapes[:, :, 1], axis=0) == 0), 'Output kernel shapes must be the same'
-    n_in = kernel_shapes[:, 0, 0]
-    n_out = kernel_shapes[0, :, 1]
-    idx_in_biases = np.cumsum([0] + list(n_in[:-1]))
-    idx_out_biases = np.cumsum([0] + list(n_out[:-1]))
-
-    input_variables = []
-    idx_in_bias = 0
-    for i in range(n_split_in):
-        _state = states[i][0]
-        _n_in = n_in[i]
-        _vars = var_from_nb_var(_state.op_codes[:_n_in], _state.variables[:_n_in], idx_in_bias)
-        input_variables.append(_vars)
-        idx_in_bias += _state.kernel.shape[0]
-
-    output_variables = [[] for _ in range(np.sum(n_out))]
-    for i, j in np.ndindex(n_split_in, n_split_out):
-        state = states[i][j]
-        idx_in_bias = idx_in_biases[i]
-        idx_out_bias = idx_out_biases[j]
-        variables = var_from_nb_var(state.op_codes, state.variables, idx_in_bias)
-        _cumlist = gather_output_var_cumlist(state, variables)
-        for k, buf in enumerate(_cumlist):
-            output_variables[idx_out_bias + k].extend(buf)
-
-    _output_variables: list[FixedVariable] = [
-        balanced_reduction(buf, signed=signed_balanced_reduction) for buf in output_variables
-    ]  # type: ignore
-    input_variables = [v for vs in input_variables for v in vs]
-    return input_variables, _output_variables

da4ml/cmvm/nb_fixed_precision.py

@@ -1,98 +0,0 @@
-from math import ceil, log2
-
-from numba import int32
-from numba import types as nb_types
-from numba.experimental import jitclass
-
-spec = [
-    ('int_min', int32),
-    ('int_max', int32),
-    ('shift', int32),
-    ('symmetric', nb_types.boolean),
-    ('_depth', int32),
-]
-
-
-@jitclass(spec=spec)  # type: ignore
-class NBFixedPrecision:
-    def __init__(
-        self,
-        int_min: int,
-        int_max: int,
-        shift: int,
-        symmetric: bool = False,
-        _depth: int = 0,
-    ):
-        self.int_min = int_min
-        self.int_max = int_max
-        self.shift = shift
-        self.symmetric = symmetric
-        self._depth = _depth
-
-        if self.int_min > self.int_max:
-            raise ValueError('int_min must be less than or equal to int_max')
-
-    @property
-    def k(self) -> int:
-        return int(self.min < 0)
-
-    @property
-    def b(self) -> int:
-        return ceil(log2(max(self.int_max + 1, -self.int_min)))
-
-    @property
-    def i(self) -> int:
-        return self.b - self.shift
-
-    @property
-    def min(self) -> float:
-        return self.int_min * 2.0 ** (-self.shift)
-
-    @property
-    def max(self) -> float:
-        return self.int_max * 2.0 ** (-self.shift)
-
-    def __str__(self) -> str:
-        s = '' if self.k else 'u'
-        p = f'ap_{s}fixed({self.b+self.k}, {self.i+self.k})'
-        if self.int_min == self.int_max:
-            return f'{p}({self.min})'
-        return p
-
-    def __add__(self, other: 'NBFixedPrecision'):
-        shift = max(self.shift, other.shift)
-        _shift0, _shift1 = shift - self.shift, shift - other.shift
-        int_min = (self.int_min << _shift0) + (other.int_min << _shift1)
-        int_max = (self.int_max << _shift0) + (other.int_max << _shift1)
-
-        return NBFixedPrecision(
-            int_min,
-            int_max,
-            shift,
-            False,
-            max(self._depth, other._depth) + 1,
-        )
-
-    def __neg__(self):
-        return NBFixedPrecision(
-            -self.int_max,
-            -self.int_min,
-            self.shift,
-            False,
-            self._depth,
-        )
-
-    def __sub__(self, other: 'NBFixedPrecision'):
-        return self + (-other)
-
-    def __lshift__(self, other: int):
-        return NBFixedPrecision(
-            self.int_min,
-            self.int_max,
-            self.shift - other,
-            False,
-            self._depth,
-        )
-
-    def __rshift__(self, other: int):
-        return self << -other

da4ml/cmvm/scoring.py

@@ -1,55 +0,0 @@
-from numba import njit
-
-from .nb_fixed_precision import NBFixedPrecision
-
-
-def py_resource_scorer(p1, p2) -> float:
-    b0, b1 = p1.b, p2.b
-    f1, f2 = p1.shift, p2.shift
-    pl0, pl1 = -f1, -f2
-    ph0, ph1 = pl0 + b0, pl1 + b1
-    pl, pL = (pl0, pl1) if pl0 < pl1 else (pl1, pl0)
-    ph, pH = (ph0, ph1) if ph0 < ph1 else (ph1, ph0)
-
-    return ph - pL
-
-
-def py_latency_scorer(p1, p2) -> float:
-    return -float(abs(p1._depth - p2._depth))
-
-
-def py_scorer(p1, p2, dshift: int = 0, dsign: int = 0) -> float:
-    p2 = p2 << dshift
-    rs = py_resource_scorer(p1, p2)
-    ls = py_latency_scorer(p1, p2)
-    score = rs + ls
-    return score
-
-
-@njit
-def resource_scorer(p1: NBFixedPrecision, p2: NBFixedPrecision) -> float:
-    b0, b1 = p1.b, p2.b
-    f1, f2 = p1.shift, p2.shift
-    pl0, pl1 = -f1, -f2
-    ph0, ph1 = pl0 + b0, pl1 + b1
-    pl, pL = (pl0, pl1) if pl0 < pl1 else (pl1, pl0)
-    ph, pH = (ph0, ph1) if ph0 < ph1 else (ph1, ph0)
-
-    return ph - pL
-    n_full = max(0, ph - pL)
-
-    return n_full**2 / (pH - pl)
-
-
-@njit
-def latency_scorer(p1: NBFixedPrecision, p2: NBFixedPrecision) -> float:
-    return -float(abs(p1._depth - p2._depth))
-
-
-@njit
-def scorer(p1: NBFixedPrecision, p2: NBFixedPrecision, dshift: int, dsign: int) -> float:
-    p2 = p2 << dshift
-    rs = resource_scorer(p1, p2)
-    ls = latency_scorer(p1, p2)
-    score = rs + ls
-    return score

da4ml/cmvm/utils.py

@@ -1,5 +0,0 @@
-from collections import namedtuple
-
-DAState = namedtuple('DAState', ['csd', 'variables', 'op_codes', 'pairs', 'score', 'kernel'])
-Score = namedtuple('Score', ['potential', 'realized', 'lost', 'value'])
-OpCode = namedtuple('OPCode', ['pos0', 'pos1', 'shift0', 'shift1', 'sign0', 'sign1'])

da4ml-0.1.2.dist-info/METADATA

@@ -1,122 +0,0 @@
-Metadata-Version: 2.4
-Name: da4ml
-Version: 0.1.2
-Summary: Digital Arithmetic for Machine Learning
-Author-email: Chang Sun <chsun@cern.ch>
-License: GNU Lesser General Public License v3 (LGPLv3)
-Project-URL: repository, https://github.com/calad0i/da4ml
-Keywords: CMVM,distributed arithmetic,hls4ml,MCM,subexpression elimination
-Classifier: Development Status :: 4 - Beta
-Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: llvmlite>=0.43
-Requires-Dist: numba>=0.60
-Dynamic: license-file
-
-# da4ml: Distributed Arithmetic for Machine Learning
-
-This project performs Constant Matrix-Vector Multiplication (CMVM) with Distributed Arithmetic (DA) for Machine Learning (ML) on a Field Programmable Gate Arrays (FPGAs).
-
-CMVM optimization is done through greedy CSE of two-term subexpressions, with possible Delay Constraints (DC). The optimization is done in jitted Python (Numba), and a list of optimized operations is generated as traced Python code.
-
-At the moment, the project only generates Vitis HLS C++ code for the FPGA implementation of the optimized CMVM kernel. HDL code generation is planned for the future. Currently, the major use of this repository is through the `distributed_arithmetic` strategy in the [`hls4ml`](https://github.com/fastmachinelearning/hls4ml/) project.
-
-
-## Installation
-
-The project is available on PyPI and can be installed with pip:
-
-```bash
-pip install da4ml
-```
-
-Notice that `numba>=6.0.0` is required for the project to work. The project does not work with `python<3.10`. If the project fails to compile, try upgrading `numba` and `llvmlite` to the latest versions.
-
-## `hls4ml`
-
-The major use of this project is through the `distributed_arithmetic` strategy in the `hls4ml`:
-
-```python
-model_hls = hls4ml.converters.convert_from_keras_model(
-    model,
-    hls_config={
-        'Model': {
-            ...
-            'Strategy': 'distributed_arithmetic',
-        },
-        ...
-    },
-    ...
-)
-```
-Currently, `Dense/Conv1D/Conv2D` layers are supported for both `io_parallel` and `io_stream` dataflows. However, notice that distributed arithmetic implies `reuse_factor=1`, as the whole kernel is implemented in combinational logic.
-
-### Notice
-
-Currently, only the `da4ml-v2` branch of `hls4ml` supports the `distributed_arithmetic` strategy. The `da4ml-v2` branch is not yet merged into the `main` branch of `hls4ml`, so you need to install it from the GitHub repository.
-
-## Direct Usage
-
-If you want to use it directly, you can use the `da4ml.api.fn_from_kernel` function, which creates a Python function from a 2x2 kernel `float[n_in, n_out]` and its corresponding code. The function signature is:
-
-```python
-def fn_from_kernel(
-    kernel: np.ndarray,
-    signs: list[bool],
-    bits: list[int],
-    int_bits: list[int],
-    symmetrics: list[bool],
-    depths: list[int] | None = None,
-    n_beams: int = 1,
-    dc: int | None = None,
-    n_inp_max: int = -1,
-    n_out_max: int = -1,
-    codegen_backend: PyCodegenBackend = PyCodegenBackend(),
-    signed_balanced_reduction: bool = True,
-) -> tuple[Callable[[list[T]], list[T]], str]:
-    """Compile a CMVM operation, with the constant kernel, into a function with only accumulation/subtraction/shift operations.
-
-    Parameters
-    ----------
-    kernel : np.ndarray
-        The kernel to compile. Must be of shape (n_inp, n_out).
-    signs : list[bool]
-        If the input is signed. Must be of length n_inp.
-    bits : list[int]
-        The bitwidth of the inputs. Must be of length n_inp.
-    int_bits : list[int]
-        The number of integer bits in the inputs (incl. sign bit!). Must be of length n_inp.
-    symmetrics : list[bool]
-        If the input is symmetricly quantized. Must be of length n_inp.
-    depths : list[int]|None, optional
-        The depth associated with each input. Must be of length n_inp. Defaults to [0]*n_inp.
-    n_beams : int, optional
-        Number of beams to use in beam search. Defaults to 1. (Currently disabled!)
-    dc : int | None, optional
-        Delay constraint. Not implemented yet. Defaults to None.
-    n_inp_max : int, optional
-        Number of inputs to process in one block. Defaults to -1 (no limit). Decrease to improve performance, but result will be less optimal.
-    n_out_max : int, optional
-        Number of outputs to process in one block. Defaults to -1 (no limit). Decrease to improve performance, but result will be less optimal.
-    codegen_backend : PyCodegenBackend, optional
-        The codegen backend to be used. Defaults to PyCodegenBackend().
-    signed_balanced_reduction : bool, optional
-        If the reduction tree should isolate the plus and minus terms. Set to False to improve latency. Defaults to True.
-
-    Returns
-    -------
-    tuple[Callable[[list[T]], list[T]], str]
-        fn : Callable[[list[T]], list[T]]
-            The compiled python function. It takes a list of inputs and returns a list of outputs with only accumulation/subtraction/powers of 2 operations.
-        fn_str : str
-            The code of the compiled function, depending on the codegen_backend used.
-    """
-```

da4ml-0.1.2.dist-info/RECORD

@@ -1,18 +0,0 @@
-da4ml/__init__.py,sha256=kkpf91aU4n9MMsX63Me90mo_0JSQyU3N-vhgTIrjkT0,437
-da4ml/_version.py,sha256=bSmADqydH8nBu-J4lG8UVuR7hnU_zcwhnSav2oQ0W0A,511
-da4ml/cmvm/__init__.py,sha256=UUnJxtZGQpqVWKT_djuPr7CqyiWlUrmKoyAvH7f4-q8,848
-da4ml/cmvm/api.py,sha256=G7YZ1n32EaYzsahSUwB-0vvRZt1Q11idShhn735vDCM,3461
-da4ml/cmvm/balanced_reduction.py,sha256=fDKaRIY4WkRo3s5dGWeWmylDgjMD-hr1-tpdwu7EL6Y,1533
-da4ml/cmvm/cmvm.py,sha256=4RN6sKLNxybHZcBoUkw4MBluLZoEhAArutt8BE5NCNE,10689
-da4ml/cmvm/codegen.py,sha256=w_1xR36Oxwb-1XivFwjQ_n2uRw-abjwzjOhwARg_93k,6088
-da4ml/cmvm/csd.py,sha256=k-9k0CigqnvyrgtXzBvKLZ32FdwWUE_EhAlXkK6Mlxk,1988
-da4ml/cmvm/fixed_variable.py,sha256=APPT2EN7hOwjHIaD5JdOpd7riGUpmtXUJ6QaAnE1cjw,5753
-da4ml/cmvm/graph_compile.py,sha256=bODuY7DAi-9L-ZleAzK0szZDrEH4Ljq2ocINUHXD588,3322
-da4ml/cmvm/nb_fixed_precision.py,sha256=M2bnflNNOGLgUsI0QGlF2noT5ZJD-2bU2dZ3lw8GZvM,2457
-da4ml/cmvm/scoring.py,sha256=EUREpoyQHUe-vpRat_JjRD73uQhD0dOhnG2D3opazwQ,1375
-da4ml/cmvm/utils.py,sha256=Svp82TOtpNOtKfXlCkijq7DBSbMEqyWoY2PAYVhXXQY,288
-da4ml-0.1.2.dist-info/licenses/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-da4ml-0.1.2.dist-info/METADATA,sha256=YirD1SJdRbYNKdbY68TWtacjfs-bUrcWIbQBdoIIaYw,5507
-da4ml-0.1.2.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-da4ml-0.1.2.dist-info/top_level.txt,sha256=N0tnKVwRqFiffFdeAzCgFq71hUNySh5-ITbNd6-R58Q,6
-da4ml-0.1.2.dist-info/RECORD,,