da4ml 0.2.1__py3-none-any.whl → 0.3.0.post1__py3-none-any.whl

da4ml/converter/hgq2/replica.py

@@ -0,0 +1,383 @@
+import typing
+from collections.abc import Sequence
+from math import prod
+from typing import Any
+
+import hgq
+import keras
+import numpy as np
+from hgq.layers import (
+    QBatchNormalization,
+    QBatchNormDense,
+    QConv1D,
+    QConv2D,
+    QConv3D,
+    QDense,
+    QEinsumDense,
+    QEinsumDenseBatchnorm,
+    QSum,
+)
+from hgq.layers.core.base import MultipleQuantizers, Quantizer
+from hgq.quantizer.internal import FixedPointQuantizerBase
+from keras.layers import ReLU
+from keras.src.layers.pooling.base_global_pooling import BaseGlobalPooling
+from keras.src.layers.pooling.base_pooling import BasePooling
+from keras.src.ops.numpy import (
+    Add,
+    Concatenate,
+    Divide,
+    GetItem,
+    Moveaxis,
+    Multiply,
+    Ravel,
+    Repeat,
+    Reshape,
+    Subtract,
+    Sum,
+    Transpose,
+    TrueDivide,
+)
+
+from ...trace import FixedVariableArray
+from ...trace.ops import conv, einsum, pool, quantize, relu
+
+
+def mirror_quantizer(q: Quantizer, v: FixedVariableArray) -> FixedVariableArray:
+    q_internal: FixedPointQuantizerBase = q.quantizer
+    k, i, f = (np.array(x, dtype=np.int8)[0] for x in q_internal.kif)
+    round_mode, overflow_mode = q_internal.round_mode, q_internal.overflow_mode
+    return quantize(v, k, i, f, overflow_mode=overflow_mode, round_mode=round_mode)
+
+
+_registry: dict[type, 'type[MirrorOperationBase]'] = {}
+
+
+class MirrorOperationMeta(type):
+    def __new__(mcs, name: str, bases: tuple[type, ...], namespace: dict[str, typing.Any]):
+        cls = super().__new__(mcs, name, bases, namespace)
+        if name == 'MirrorOperationBase':
+            return cls
+
+        handles: type | tuple[type, ...] = namespace['handles']
+        if not isinstance(handles, tuple):
+            handles = (handles,)
+
+        for handle in handles:
+            _registry[handle] = cls  # type: ignore
+        return cls
+
+
+class MirrorOperationBase(metaclass=MirrorOperationMeta):
+    handles: tuple[type, ...] = ()
+
+    def __init__(self, layer: 'keras.Operation'):
+        assert isinstance(layer, self.handles)
+        self.op: Any = layer
+
+    def call(self, *args, **kwargs) -> tuple[FixedVariableArray, ...] | FixedVariableArray: ...
+
+    def __call__(self, *args, **kwargs) -> tuple[FixedVariableArray, ...]:
+        assert all(not isinstance(a, FixedVariableArray) for a in kwargs.values())
+        assert all(isinstance(a, FixedVariableArray) or isinstance(a, Sequence) for a in args)
+        inputs = args[0] if len(args) == 1 else args
+
+        if not isinstance(self.op, hgq.layers.QLayerBase):
+            r = self.call(*args, **kwargs)
+            return r if isinstance(r, tuple) else (r,)
+
+        layer: hgq.layers.QLayerBase = self.op
+        assert kwargs.pop('training', False) is False, 'Training mode is not supported in mirror operation'
+        assert kwargs.pop('mask', None) is None, 'Masking is not supported in mirror operation'
+
+        if layer.enable_iq:
+            if isinstance(inputs, Sequence):
+                assert isinstance(layer.iq, MultipleQuantizers)
+                inputs = tuple(mirror_quantizer(q, v) for q, v in zip(layer.iq.quantizers, inputs))
+            else:
+                assert isinstance(layer.iq, Quantizer), f'Expected iq to be a Quantizer, got {type(layer.iq)}'
+                inputs = mirror_quantizer(layer.iq, inputs)
+
+        outputs = self.call(inputs, **kwargs)
+
+        activation = getattr(layer, 'activation', keras.activations.linear)
+        if activation is not keras.activations.linear:
+            if activation is keras.activations.relu:
+                if isinstance(outputs, tuple):
+                    assert len(outputs) == 1, 'ReLU activation is expected to have a single output'
+                    outputs = (relu(outputs[0]),)
+                else:
+                    outputs = relu(outputs)
+            else:
+                raise NotImplementedError(f'Activation {activation} is not supported in mirror operation')
+
+        if layer.enable_oq:
+            if isinstance(outputs, tuple):
+                assert isinstance(layer.oq, MultipleQuantizers)
+                outputs = tuple(mirror_quantizer(q, v) for q, v in zip(layer.oq.quantizers, outputs))
+            else:
+                assert isinstance(layer.oq, Quantizer)
+                outputs = mirror_quantizer(layer.oq, outputs)
+
+        if isinstance(outputs, FixedVariableArray):
+            outputs = (outputs,)
+
+        return outputs
+
+
+class MirrorQuantizer(MirrorOperationBase):
+    handles = (Quantizer,)
+
+    def __init__(self, op: 'Quantizer'):
+        super().__init__(op)
+        assert isinstance(op.quantizer, FixedPointQuantizerBase)
+
+    def call(self, inputs: FixedVariableArray) -> FixedVariableArray:
+        return mirror_quantizer(self.op, inputs)
+
+
+class MirrorQDense(MirrorOperationBase):
+    handles = (QDense, QEinsumDense, QEinsumDenseBatchnorm, QBatchNormDense, QBatchNormalization, keras.layers.EinsumDense)
+
+    def call(self, inputs: FixedVariableArray) -> FixedVariableArray:
+        op = self.op
+        if isinstance(op, (QDense, QBatchNormDense)):
+            qkernel = op.qkernel
+            qbias = op.qbias
+            eq = '...c,cC->...C'
+        elif isinstance(op, (QEinsumDense, QEinsumDenseBatchnorm)):
+            qkernel = op.qkernel
+            qbias = op.qbias
+            eq = op.equation
+        elif isinstance(op, keras.layers.EinsumDense):
+            qkernel = op.kernel
+            qbias = op.bias
+            eq = op.equation
+        elif isinstance(op, QBatchNormalization):
+            qkernel, qbias = op.qscaler_and_qoffset
+            dim = inputs._vars.ndim
+            axis = op.axis
+            assert axis != 0, 'Cannot normalizing on batch axis'
+            axis -= 1
+            idx = ''.join(chr(ord('a') + i) for i in range(dim))
+            eq = f'...{idx},{idx[axis]}->...{idx}'
+        else:
+            raise TypeError(f'Unsupported layer type: {type(op)}')
+
+        qkernel = np.array(qkernel)
+        qbias = np.array(qbias) if qbias is not None else None
+        return (einsum(eq, inputs[None], qkernel) + qbias)[0]
+
+
+class MirrorQConv(MirrorOperationBase):
+    handles = (QConv1D, QConv2D, QConv3D)
+
+    def call(self, inputs: FixedVariableArray) -> FixedVariableArray:
+        layer: QConv1D | QConv2D | QConv3D = self.op
+        qkernel = np.array(layer.qkernel)
+        qbias = np.array(layer.qbias) if layer.qbias is not None else None
+        strides = layer.strides
+        padding = layer.padding
+        dilation_rate = layer.dilation_rate
+        groups = layer.groups
+
+        assert dilation_rate == 1 or all(d == 1 for d in dilation_rate), 'Dilation rate is not supported in mirror operation'
+        if layer.data_format == 'channels_first':
+            shape = (0,) + tuple(range(2, len(inputs.shape))) + (1,)
+            inputs = inputs.transpose(shape)
+
+        outputs = conv(inputs, qkernel, qbias, strides=strides, padding=padding, format=layer.data_format, groups=groups)
+
+        return outputs
+
+
+class MirrorReLU(MirrorOperationBase):
+    handles = (ReLU,)
+
+    def call(self, inputs: FixedVariableArray) -> FixedVariableArray:
+        return relu(inputs)
+
+
+class MirrorReshape(MirrorOperationBase):
+    handles = (keras.layers.Reshape, keras.layers.Flatten, Reshape, Ravel)
+
+    def call(self, inputs: FixedVariableArray) -> FixedVariableArray:
+        if isinstance(self.op, (keras.layers.Flatten, Ravel)):
+            return inputs.ravel()
+        elif isinstance(self.op, keras.layers.Reshape):
+            return inputs.reshape(self.op.target_shape)
+        elif isinstance(self.op, Reshape):
+            return inputs.reshape(self.op.newshape[1:])
+        else:
+            raise TypeError(f'Unsupported layer type: {type(self.op)}')
+
+
+class MirrorMerge(MirrorOperationBase):
+    handles = (keras.layers.Add, keras.layers.Concatenate, hgq.layers.QAdd)
+
+    def call(self, inputs: tuple[FixedVariableArray, FixedVariableArray]) -> FixedVariableArray:
+        op: keras.Operation = self.op
+        if isinstance(op, (keras.layers.Add, hgq.layers.QAdd)):
+            return inputs[0] + inputs[1]
+        elif isinstance(op, keras.layers.Concatenate):
+            axis = op.axis
+            data = np.concatenate([v._vars for v in inputs], axis=axis)
+            return FixedVariableArray(data, inputs[0].solver_options)
+        else:
+            raise TypeError(f'Unsupported layer type: {type(op)}')
+
+
+class MirrorPool(MirrorOperationBase):
+    handles = (
+        hgq.layers.QAvgPool1D,
+        hgq.layers.QAvgPool2D,
+        hgq.layers.QAvgPool3D,
+        hgq.layers.QMaxPool1D,
+        hgq.layers.QMaxPool2D,
+        hgq.layers.QMaxPool3D,
+        hgq.layers.QGlobalAveragePooling1D,
+        hgq.layers.QGlobalMaxPooling1D,
+        hgq.layers.QGlobalAveragePooling2D,
+        hgq.layers.QGlobalMaxPooling2D,
+        hgq.layers.QGlobalAveragePooling3D,
+        hgq.layers.QGlobalMaxPooling3D,
+        keras.layers.AveragePooling1D,
+        keras.layers.AveragePooling2D,
+        keras.layers.AveragePooling3D,
+        keras.layers.MaxPooling1D,
+        keras.layers.MaxPooling2D,
+        keras.layers.MaxPooling3D,
+        keras.layers.GlobalAveragePooling1D,
+        keras.layers.GlobalMaxPooling1D,
+        keras.layers.GlobalAveragePooling2D,
+        keras.layers.GlobalMaxPooling2D,
+        keras.layers.GlobalAveragePooling3D,
+        keras.layers.GlobalMaxPooling3D,
+    )
+
+    def call(self, inputs: FixedVariableArray) -> FixedVariableArray:
+        cname = self.op.__class__.__name__
+        if 'Max' in cname:
+            op = 'max'
+        else:
+            assert 'Average' in cname, f'Unsupported global pooling layer: {cname}'
+            op = 'avg'
+
+        data_format = self.op.data_format
+        if data_format == 'channels_first':
+            inputs = np.moveaxis(inputs, 1, -1)  # type: ignore
+
+        if isinstance(self.op, BaseGlobalPooling):
+            pool_dim = self.op.input_spec.ndim - 2  # type: ignore
+            axis = tuple(range(pool_dim))
+            keepdims = self.op.keepdims
+
+            if op == 'max':
+                out = np.amax(inputs, axis=axis, keepdims=keepdims)  # type: ignore
+            elif op == 'avg':
+                pool_size = prod(inputs.shape[:-1])
+                out = np.sum(inputs, axis=axis, keepdims=keepdims) / pool_size  # type: ignore
+        else:
+            assert isinstance(self.op, BasePooling), f'Unsupported pooling layer: {type(self.op)}'
+            pool_size = self.op.pool_size
+            strides = self.op.strides
+            padding = self.op.padding
+            pool_dim = len(pool_size)
+            out = pool(
+                inputs,
+                pool_size=pool_size,
+                strides=strides,
+                padding=padding,
+                pool_type=op,
+            )
+        if data_format == 'channels_first':
+            out = np.moveaxis(out, -1, 1)  # type: ignore
+
+        return out  # type: ignore
+
+
+class MirrorRepeatVector(MirrorOperationBase):
+    handles = (keras.layers.RepeatVector,)
+
+    def call(self, inputs: FixedVariableArray) -> FixedVariableArray:
+        layer: keras.layers.RepeatVector = self.op
+        if layer.n == 1:
+            return inputs
+        # return FixedVariableArray(np.repeat(inputs._vars, layer.n, axis=0), inputs.solver_options)
+        return np.repeat(inputs[None], layer.n, axis=0)[0]  # type: ignore
+
+
+class MirrorGetItem(MirrorOperationBase):
+    handles = (GetItem,)
+
+    def call(self, x: FixedVariableArray, key):
+        if isinstance(key, list):
+            key = tuple(key)
+        return x[None][key][0]
+
+
+class MirrorSum(MirrorOperationBase):
+    handles = (Sum,)
+
+    def call(self, x: FixedVariableArray, axis=None, keepdims=False):
+        return np.sum(x[None], axis=axis, keepdims=keepdims)[0]  # type: ignore
+
+
+class MirrorQSum(MirrorOperationBase):
+    handles = (QSum,)
+
+    def call(self, x: FixedVariableArray):
+        layer: QSum = self.op
+        axes, scale, keepdims = layer.axes, layer.scale, layer.keepdims
+        return np.sum(x[None], axis=axes, keepdims=keepdims)[0] * scale  # type: ignore
+
+
+class MirrorArithmetic(MirrorOperationBase):
+    handles = (Add, Subtract, Multiply, TrueDivide, Divide)
+
+    def call(self, x1: FixedVariableArray, x2: FixedVariableArray):
+        match self.op.__class__.__name__:
+            case 'Add':
+                return x1 + x2
+            case 'Subtract':
+                return x1 - x2
+            case 'Multiply':
+                return x1 * x2
+            case 'TrueDivide' | 'Divide':
+                return x1 / x2
+            case _:
+                raise TypeError(f'Unsupported arithmetic operation: {type(self.op)}')
+
+
+class MirrorConcatenate(MirrorOperationBase):
+    handles = (Concatenate,)
+
+    def call(self, xs: Sequence[FixedVariableArray]):
+        axis = self.op.axis
+        # return backend.numpy.concatenate(xs, axis=self.axis)
+        # return FixedVariableArray(np.concatenate([x._vars[None] for x in xs], axis=axis)[0], xs[0].solver_options)
+        return np.concatenate([x[None] for x in xs], axis=axis)[0]  # type: ignore
+
+
+class MirrorRepeat(MirrorOperationBase):
+    handles = (Repeat,)
+
+    def call(self, x: FixedVariableArray):
+        repeats, axis = self.op.repeats, self.op.axis
+        # return FixedVariableArray(np.repeat(x._vars[None], repeats, axis=axis)[0], x.solver_options)
+        return np.repeat(x[None], repeats, axis=axis)[0]  # type: ignore
+
+
+class MirrorTranspose(MirrorOperationBase):
+    handles = (Transpose,)
+
+    def call(self, x: FixedVariableArray):
+        axes = self.op.axes
+        return np.transpose(x, axes)  # type: ignore
+
+
+class MirrorMoveaxis(MirrorOperationBase):
+    handles = (Moveaxis,)
+
+    def call(self, x: FixedVariableArray):
+        source, destination = self.op.source, self.op.destination
+        return np.moveaxis(x[None], source, destination)[0]  # type: ignore

da4ml/trace/__init__.py

@@ -1,6 +1,6 @@
 from .fixed_variable import HWConfig
-from .fixed_variable_array import FixedVariableArray
+from .fixed_variable_array import FixedVariableArray, FixedVariableArrayInput
 from .pipeline import to_pipeline
 from .tracer import comb_trace
 
-__all__ = ['to_pipeline', 'comb_trace', 'FixedVariableArray', 'HWConfig']
+__all__ = ['to_pipeline', 'comb_trace', 'FixedVariableArray', 'HWConfig', 'FixedVariableArrayInput']

da4ml/trace/fixed_variable.py

@@ -43,9 +43,9 @@ class FixedVariable:
     ) -> None:
         assert low <= high, f'low {low} must be less than high {high}'
 
-        if low == high:
+        if low == high and opr != 'new':
             opr = 'const'
-            _factor = 1.0
+            _factor = _factor
             _from = ()
 
         low, high, step = Decimal(low), Decimal(high), Decimal(step)
@@ -72,15 +72,21 @@ class FixedVariable:
         self.latency = _latency
         self.cost = _cost
 
+        # Update latency for constant variables to match the current variable for piplining
+
+        for v in self._from:
+            if v.opr == 'const':
+                v.latency = self.latency
+
     def get_cost_and_latency(self):
         if self.opr == 'const':
             return 0.0, 0.0
-        if self.opr in ('vadd', 'cadd'):
+        if self.opr in ('vadd', 'cadd', 'min', 'max'):
             adder_size = self.hwconf.adder_size
             carry_size = self.hwconf.carry_size
             latency_cutoff = self.hwconf.latency_cutoff
 
-            if self.opr == 'vadd':
+            if self.opr in ('min', 'max', 'vadd'):
                 assert len(self._from) == 2
                 v0, v1 = self._from
                 int0, int1 = v0.qint, v1.qint
@@ -89,8 +95,6 @@ class FixedVariable:
             else:
                 assert len(self._from) == 1
                 assert self._data is not None, 'cadd must have data'
-                # int0 = self._from[0].qint
-                # int1 = QInterval(float(self._data), float(self._data), float(self.step))
                 _f = _const_f(self._data)
                 _cost = float(ceil(log2(abs(self._data) + Decimal(2) ** -_f))) + _f
                 base_latency = self._from[0].latency
@@ -138,6 +142,12 @@ class FixedVariable:
         k = self.low < 0
         return k, i, f
 
+    @classmethod
+    def from_const(cls, const: float | Decimal, hwconf: HWConfig, latency: float, _factor: float | Decimal):
+        f = _const_f(const)
+        step = Decimal(2) ** -f
+        return cls(const, const, step, hwconf=hwconf, opr='const', _factor=_factor, latency=latency)
+
     def __repr__(self) -> str:
         if self._factor == 1:
             return f'FixedVariable({self.low}, {self.high}, {self.step})'
@@ -185,7 +195,9 @@ class FixedVariable:
             hwconf=self.hwconf,
         )
 
-    def _const_add(self, other: float | Decimal):
+    def _const_add(self, other: float | Decimal | None):
+        if other is None:
+            return self
         if not isinstance(other, (int, float, Decimal)):
             other = float(other)  # direct numpy to decimal raises error
         other = Decimal(other)
@@ -222,7 +234,7 @@ class FixedVariable:
         other: 'float|Decimal',
     ):
         if other == 0:
-            return FixedVariable(0, 0, 1, hwconf=self.hwconf)
+            return FixedVariable(0, 0, 1, hwconf=self.hwconf, opr='const')
 
         assert log2(abs(other)) % 1 == 0, 'Only support pow2 multiplication'
 
@@ -267,7 +279,7 @@ class FixedVariable:
             i = ceil(log2(val + step)) if not i else i
             eps = step / 2 if round_mode == 'RND' else 0
             val = (floor(val / step + eps) * step) % (Decimal(2) ** i)
-            return FixedVariable(val, val, step, hwconf=self.hwconf)
+            return FixedVariable(val, val, step, hwconf=self.hwconf, opr='const')
 
         step = max(Decimal(2) ** -f, self.step) if f is not None else self.step
         if step > self.step and round_mode == 'RND':
@@ -281,6 +293,10 @@ class FixedVariable:
                 low = Decimal(0)
                 high = _high
         _factor = self._factor
+
+        if self.low == low and self.high == high and self.step == step:
+            return self
+
         return FixedVariable(
             low,
             high,
@@ -301,7 +317,7 @@ class FixedVariable:
         round_mode: str = 'TRN',
     ):
         overflow_mode, round_mode = overflow_mode.upper(), round_mode.upper()
-        assert overflow_mode in ('WRAP', 'SAT')
+        assert overflow_mode in ('WRAP', 'SAT', 'SAT_SM')
         assert round_mode in ('TRN', 'RND')
 
         _k, _i, _f = self.kif
@@ -312,13 +328,20 @@ class FixedVariable:
         if f < _f and round_mode == 'RND':
             return (self + 2.0 ** (-f - 1)).quantize(k, i, f, overflow_mode, 'TRN')
 
+        if overflow_mode in ('SAT', 'SAT_SM'):
+            step = Decimal(2) ** -f
+            _high = Decimal(2) ** i
+            high = _high - step
+            low = -_high * k if overflow_mode == 'SAT' else -high * k
+            return self.max_of(low).min_of(high).quantize(k, i, f, 'WRAP', round_mode)
+
         if self.low == self.high:
             val = self.low
             step = Decimal(2) ** -f
             _high = Decimal(2) ** i
             high, low = _high - step, -_high * k
             val = (floor(val / step) * step - low) % (2 * _high) + low
-            return FixedVariable(val, val, step, hwconf=self.hwconf)
+            return FixedVariable(val, val, step, hwconf=self.hwconf, opr='const')
 
         # TODO: corner cases exists (e.g., overflow to negative, or negative overflow to high value)
         # bit-exactness will be lost in these cases, but they should never happen (quantizers are used in a weird way)
@@ -327,17 +350,20 @@ class FixedVariable:
         k = min(k, _k) if i >= _i else k
         i = min(i, _i)
 
-        step = max(Decimal(2) ** -f, self.step)
+        if i + k + f <= 0:
+            return FixedVariable(0, 0, 1, hwconf=self.hwconf, opr='const')
+
+        step = Decimal(2) ** -f
 
         low = -k * Decimal(2) ** i
+
         high = Decimal(2) ** i - step
         _low, _high = self.low, self.high
 
         if _low >= low and _high <= high:
             low, high = _low, _high
-
-        if low > high:
-            return FixedVariable(0, 0, 1, hwconf=self.hwconf)
+            low = floor(low / step) * step
+            high = ceil(high / step) * step
 
         return FixedVariable(
             low,
@@ -345,7 +371,7 @@ class FixedVariable:
             step,
             _from=(self,),
             _factor=abs(self._factor),
-            opr='wrap' if overflow_mode == 'WRAP' else 'sat',
+            opr='wrap',
             latency=self.latency,
             hwconf=self.hwconf,
         )
@@ -356,3 +382,136 @@ class FixedVariable:
         _high = Decimal(2) ** i
         low, high = k * _high, _high - step
         return cls(low, high, step, **kwargs)
+
+    def msb_mux(self, a: 'FixedVariable', b: 'FixedVariable', qint: tuple[Decimal, Decimal, Decimal] | None = None):
+        assert isinstance(a, FixedVariable) and isinstance(b, FixedVariable), 'msb_mux requires two FixedVariables'
+        if self._factor < 0:
+            return (-self).msb_mux(b, a, qint)
+
+        if a._factor < 0:
+            qint = (-qint[1], -qint[0], qint[2]) if qint else None
+            return -(self.msb_mux(-a, -b, qint=qint))
+
+        _factor = a._factor
+
+        if qint is None:
+            qint = (min(a.low, b.low), max(a.high, b.high), min(a.step, b.step))
+
+        dlat, dcost = cost_add(a.qint, b.qint, 0, False, self.hwconf.adder_size, self.hwconf.carry_size)
+        return FixedVariable(
+            *qint,
+            _from=(self, a, b),
+            _factor=_factor,
+            opr='msb_mux',
+            latency=max(a.latency, b.latency, self.latency) + dlat,
+            hwconf=self.hwconf,
+            cost=dcost,
+        )
+
+    def max_of(self, other):
+        if other == 0:
+            return self.relu()
+        if other == -float('inf'):
+            return self
+        if other == float('inf'):
+            raise ValueError('Cannot apply max_of with inf')
+        if not isinstance(other, FixedVariable):
+            other = FixedVariable.from_const(other, hwconf=self.hwconf, latency=self.latency, _factor=abs(self._factor))
+
+        if self.low >= other.high:
+            return self
+        if self.high <= other.low:
+            return other
+
+        qint = (max(self.low, other.low), max(self.high, other.high), min(self.step, other.step))
+        return (self - other).msb_mux(other, self, qint=qint)
+
+    def min_of(self, other):
+        if other == 0:
+            return (-self).relu()
+        if other == float('inf'):
+            return self
+        if other == -float('inf'):
+            raise ValueError('Cannot apply min_of with -inf')
+        if not isinstance(other, FixedVariable):
+            other = FixedVariable.from_const(other, hwconf=self.hwconf, latency=self.latency, _factor=(self._factor))
+
+        if self.high <= other.low:
+            return self
+        if self.low >= other.high:
+            return other
+
+        qint = (min(self.low, other.low), min(self.high, other.high), min(self.step, other.step))
+        return (self - other).msb_mux(self, other, qint=qint)
+
+
+class FixedVariableInput(FixedVariable):
+    def __init__(
+        self,
+        latency: float | None = None,
+        hwconf=HWConfig(-1, -1, -1),
+    ) -> None:
+        self.low = Decimal(1e10)
+        self.high = Decimal(-1e10)
+        self.step = Decimal(1e10)
+        self._factor = Decimal(1)
+        self._from: tuple[FixedVariable, ...] = ()
+        self.opr = 'new'
+        self._data = None
+        self.id = uuid4()
+        self.hwconf = hwconf
+
+        self.latency = latency if latency is not None else 0.0
+        self.cost = 0.0
+
+    def __add__(self, other):
+        raise ValueError('Cannot operate on unquantized input variable')
+
+    def __sub__(self, other):
+        raise ValueError('Cannot operate on unquantized input variable')
+
+    def __neg__(self):
+        raise ValueError('Cannot negate unquantized input variable')
+
+    def relu(self, *args, **kwargs):
+        raise ValueError('Cannot apply relu on unquantized input variable')
+
+    def max_of(self, other):
+        raise ValueError('Cannot apply max_of on unquantized input variable')
+
+    def min_of(self, other):
+        raise ValueError('Cannot apply min_of on unquantized input variable')
+
+    def quantize(
+        self,
+        k: int | bool,
+        i: int,
+        f: int,
+        overflow_mode: str = 'WRAP',
+        round_mode: str = 'TRN',
+    ):
+        assert overflow_mode == 'WRAP'
+
+        if k + i + f <= 0:
+            return FixedVariable(0, 0, 1, hwconf=self.hwconf, opr='const')
+
+        if round_mode == 'RND':
+            return (self.quantize(k, i, f + 1) + 2.0 ** (-f - 1)).quantize(k, i, f, overflow_mode, 'TRN')
+
+        step = Decimal(2) ** -f
+        _high = Decimal(2) ** i
+        low, high = -_high * k, _high - step
+        self.high = max(self.high, high)
+        self.low = min(self.low, low)
+        self.step = min(self.step, step)
+
+        return FixedVariable(
+            low,
+            high,
+            step,
+            _from=(self,),
+            _factor=self._factor,
+            opr='wrap',
+            latency=self.latency,
+            hwconf=self.hwconf,
+        )