da4ml 0.3.2__tar.gz → 0.3.3__tar.gz

{da4ml-0.3.2/src/da4ml.egg-info → da4ml-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: da4ml
-Version: 0.3.2
+Version: 0.3.3
 Summary: Digital Arithmetic for Machine Learning
 Author-email: Chang Sun <chsun@cern.ch>
 License: GNU Lesser General Public License v3 (LGPLv3)

{da4ml-0.3.2 → da4ml-0.3.3}/src/da4ml/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.2'
-__version_tuple__ = version_tuple = (0, 3, 2)
+__version__ = version = '0.3.3'
+__version_tuple__ = version_tuple = (0, 3, 3)
 
-__commit_id__ = commit_id = 'g01e84ad19'
+__commit_id__ = commit_id = 'g87b111b38'

{da4ml-0.3.2 → da4ml-0.3.3}/src/da4ml/codegen/cpp/cpp_codegen.py

@@ -46,7 +46,7 @@ def ssa_gen(sol: Solution, print_latency: bool, typestr_fn: Callable[[bool | int
         match op.opcode:
             case -1:
                 # Input marker
-                val = f'inp[{ops[op.id0].id0}]'
+                val = f'inp[{op.id0}]'
             case 0 | 1:
                 # Common a+/-b<<shift op
                 ref1 = f'bit_shift<{op.data}>(v{op.id1})' if op.data != 0 else f'v{op.id1}'

da4ml-0.3.3/src/da4ml/codegen/cpp/source/binder_util.hh

@@ -0,0 +1,50 @@
+#pragma once
+#include <cstddef>
+
+#ifdef _OPENMP
+#include <algorithm>
+#include <omp.h>
+constexpr bool _openmp = true;
+#else
+constexpr bool _openmp = false;
+#endif
+
+template <typename CONFIG_T, typename T> void _inference(T *c_inp, T *c_out, size_t n_samples) {
+    typename CONFIG_T::inp_t in_fixed_buf[CONFIG_T::N_inp];
+    typename CONFIG_T::out_t out_fixed_buf[CONFIG_T::N_out];
+
+    for (size_t i = 0; i < n_samples; ++i) {
+        size_t offset_in = i * CONFIG_T::N_inp;
+        size_t offset_out = i * CONFIG_T::N_out;
+        for (size_t j = 0; j < CONFIG_T::N_inp; ++j) {
+            in_fixed_buf[j] = c_inp[offset_in + j];
+        }
+
+        CONFIG_T::f(in_fixed_buf, out_fixed_buf);
+
+        for (size_t j = 0; j < CONFIG_T::N_out; ++j) {
+            c_out[offset_out + j] = out_fixed_buf[j];
+        }
+    }
+}
+
+template <typename CONFIG_T, typename T> void batch_inference(T *c_inp, T *c_out, size_t n_samples) {
+#ifdef _OPENMP
+    size_t n_max_threads = omp_get_max_threads();
+    size_t n_samples_per_thread = std::max<size_t>(n_samples / n_max_threads, 32);
+    size_t n_thread = n_samples / n_samples_per_thread;
+    n_thread += (n_samples % n_samples_per_thread) ? 1 : 0;
+
+#pragma omp parallel for num_threads(n_thread) schedule(static)
+    for (size_t i = 0; i < n_thread; ++i) {
+        size_t start = i * n_samples_per_thread;
+        size_t end = std::min<size_t>(start + n_samples_per_thread, n_samples);
+        size_t n_samples_this_thread = end - start;
+        size_t offset_in = start * CONFIG_T::N_inp;
+        size_t offset_out = start * CONFIG_T::N_out;
+        _inference<CONFIG_T, T>(&c_inp[offset_in], &c_out[offset_out], n_samples_this_thread);
+    }
+#else
+    _inference<CONFIG_T, T>(c_inp, c_out, n_samples);
+#endif
+}

{da4ml-0.3.2 → da4ml-0.3.3}/src/da4ml/codegen/cpp/source/vitis_bitshift.hh

@@ -1,14 +1,16 @@
 #pragma once
-#include "ap_types/ap_fixed.h"
+#include "ap_fixed.h"
 
-template <int s, int b, int i, ap_q_mode Q, ap_o_mode O, int N> ap_fixed<b, i + s> bit_shift(ap_fixed<b, i, Q, O, N> x) {
+template <int s, int b, int i, ap_q_mode Q, ap_o_mode O, int N>
+ap_fixed<b, i + s> bit_shift(ap_fixed<b, i, Q, O, N> x) {
 #pragma HLS INLINE
     ap_fixed<b, i + s> r;
     r.range() = x.range();
     return r;
 };
 
-template <int s, int b, int i, ap_q_mode Q, ap_o_mode O, int N> ap_ufixed<b, i + s> bit_shift(ap_ufixed<b, i, Q, O, N> x) {
+template <int s, int b, int i, ap_q_mode Q, ap_o_mode O, int N>
+ap_ufixed<b, i + s> bit_shift(ap_ufixed<b, i, Q, O, N> x) {
 #pragma HLS INLINE
     ap_ufixed<b, i + s> r;
     r.range() = x.range();

{da4ml-0.3.2 → da4ml-0.3.3}/src/da4ml/converter/hgq2/parser.py

@@ -6,8 +6,8 @@ import keras
 import numpy as np
 from keras import KerasTensor, Operation
 
-from ...trace import FixedVariableArray, HWConfig, comb_trace
-from ...trace.fixed_variable_array import FixedVariableArrayInput
+from ...trace import FixedVariableArray, FixedVariableArrayInput, HWConfig, comb_trace
+from ...trace.fixed_variable import FixedVariable
 from .replica import _registry
 
 
@@ -55,6 +55,8 @@ def replace_tensors(tensor_map: dict[KerasTensor, FixedVariableArray], obj: Any)
 def _flatten_arr(args: Any) -> FixedVariableArray:
     if isinstance(args, FixedVariableArray):
         return np.ravel(args)  # type: ignore
+    if isinstance(args, FixedVariable):
+        return FixedVariableArray(np.array([args]))
     if not isinstance(args, Sequence):
         return None  # type: ignore
     args = [_flatten_arr(a) for a in args]

{da4ml-0.3.2 → da4ml-0.3.3}/src/da4ml/trace/fixed_variable.py

@@ -265,6 +265,10 @@ class FixedVariable:
     def __sub__(self, other: 'FixedVariable|int|float|Decimal'):
         return self + (-other)
 
+    def __truediv__(self, other: 'int|float|Decimal'):
+        assert not isinstance(other, FixedVariable), 'Division by variable is not supported'
+        return self * (1 / other)
+
     def __mul__(self, other: 'FixedVariable|int|float|Decimal') -> 'FixedVariable':
         if other == 0:
             return FixedVariable(0, 0, 1, hwconf=self.hwconf, opr='const')

{da4ml-0.3.2 → da4ml-0.3.3}/src/da4ml/trace/fixed_variable_array.py

@@ -164,6 +164,10 @@ class FixedVariableArray:
         latency: NDArray[np.floating] | float = 0.0,
         solver_options: dict[str, Any] | None = None,
     ):
+        mask = k + i + f <= 0
+        k = np.where(mask, 0, k)
+        i = np.where(mask, 0, i)
+        f = np.where(mask, 0, f)
         step = 2.0**-f
         _high = 2.0**i
         high, low = _high - step, -_high * k

{da4ml-0.3.2 → da4ml-0.3.3}/src/da4ml/trace/ops/reduce_utils.py

@@ -99,7 +99,7 @@ def reduce(operator: Callable[[T, T], T], x: TA, axis: int | Sequence[int] | Non
     r = _arr.reshape(target_shape)  # type: ignore
 
     if isinstance(x, FixedVariableArray):
-        ret = FixedVariableArray(r, solver_config)
-        if ret.size == 1 and not keepdims:
-            return ret.ravel()[0]  # type: ignore
+        r = FixedVariableArray(r, solver_config)
+        if r.size == 1 and not keepdims:
+            return r.ravel()[0]  # type: ignore
     return r if r.size > 1 or keepdims else r.ravel()[0]  # type: ignore

{da4ml-0.3.2 → da4ml-0.3.3/src/da4ml.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: da4ml
-Version: 0.3.2
+Version: 0.3.3
 Summary: Digital Arithmetic for Machine Learning
 Author-email: Chang Sun <chsun@cern.ch>
 License: GNU Lesser General Public License v3 (LGPLv3)

da4ml-0.3.2/src/da4ml/codegen/cpp/source/binder_util.hh

@@ -1,56 +0,0 @@
-#pragma once
-#include <cstddef>
-
-#ifdef _OPENMP
-#include <algorithm>
-#include <omp.h>
-constexpr bool _openmp = true;
-#else
-constexpr bool _openmp = false;
-#endif
-
-template <typename CONFIG_T, typename T> void _inference(T *c_inp, T *c_out, size_t n_samples)
-{
-    typename CONFIG_T::inp_t in_fixed_buf[CONFIG_T::N_inp];
-    typename CONFIG_T::out_t out_fixed_buf[CONFIG_T::N_out];
-
-    for(size_t i = 0; i < n_samples; ++i)
-        {
-            size_t offset_in = i * CONFIG_T::N_inp;
-            size_t offset_out = i * CONFIG_T::N_out;
-            for(size_t j = 0; j < CONFIG_T::N_inp; ++j)
-                {
-                    in_fixed_buf[j] = c_inp[offset_in + j];
-                }
-
-            CONFIG_T::f(in_fixed_buf, out_fixed_buf);
-
-            for(size_t j = 0; j < CONFIG_T::N_out; ++j)
-                {
-                    c_out[offset_out + j] = out_fixed_buf[j];
-                }
-        }
-}
-
-template <typename CONFIG_T, typename T> void batch_inference(T *c_inp, T *c_out, size_t n_samples)
-{
-#ifdef _OPENMP
-    size_t n_max_threads = omp_get_max_threads();
-    size_t n_samples_per_thread = std::max<size_t>(n_samples / n_max_threads, 32);
-    size_t n_thread = n_samples / n_samples_per_thread;
-    n_thread += (n_samples % n_samples_per_thread) ? 1 : 0;
-
-#pragma omp parallel for num_threads(n_thread) schedule(static)
-    for(size_t i = 0; i < n_thread; ++i)
-        {
-            size_t start = i * n_samples_per_thread;
-            size_t end = std::min<size_t>(start + n_samples_per_thread, n_samples);
-            size_t n_samples_this_thread = end - start;
-            size_t offset_in = start * CONFIG_T::N_inp;
-            size_t offset_out = start * CONFIG_T::N_out;
-            _inference<CONFIG_T, T>(&c_inp[offset_in], &c_out[offset_out], n_samples_this_thread);
-        }
-#else
-    _inference<CONFIG_T, T>(c_inp, c_out, n_samples);
-#endif
-}