femtocrux 0.5.3__py3-none-any.whl → 0.6.1__py3-none-any.whl

femtocrux/VERSION

@@ -1 +1 @@
-0.5.3
+0.6.1

femtocrux/femtostack/__init__.py

@@ -0,0 +1,7 @@
+def _get_dir():
+    import pathlib
+
+    return pathlib.Path(__file__).parent.parent.resolve()
+
+
+__version__ = (_get_dir() / "VERSION").read_text(encoding="utf-8").strip()

femtocrux/femtostack/common/__init__.py

@@ -0,0 +1,10 @@
+"""
+ Copyright Femtosense 2024
+ 
+ By using this software package, you agree to abide by the terms and conditions
+ in the license agreement found at https://femtosense.ai/legal/eula/
+"""
+
+from .frontend import CompilerFrontend  # noqa: F401
+from .metrics import SimMetrics  # noqa: F401
+from .sim_io import IOConfig, SimIOWrapper  # noqa: F401

femtocrux/femtostack/common/frontend.py

@@ -0,0 +1,109 @@
+import numpy as np
+from .sim_io import SimIOWrapper
+import os
+from femtobehav.fasmir import FASMIR
+from femtobehav.sim import SimRunner
+import tempfile
+from typing import Tuple, Any
+import zipfile
+
+
+class CompilerFrontend:
+    """A generic compiler frontend, must be subclassed for each input IR/framework"""
+
+    def __init__(
+        self, input_ir: Any, fasmir: FASMIR = None, io_wrapper: SimIOWrapper = None
+    ):
+        self.input_ir = input_ir
+        self.fasmir = fasmir
+        self.io_wrapper = io_wrapper
+
+    @property
+    def is_compiled(self):
+        return self.fasmir is not None and self.io_wrapper is not None
+
+    def _compile(self, input_ir: Any, options: dict) -> Tuple[FASMIR, SimIOWrapper]:
+        """
+        Runs FM compiler to generate FASMIR, and encode io information in a
+        SimIOWrapper object.
+
+        Must be implemented for each frontend subclass.
+
+        Must return a tuple pair (FASMIR, SimIOWrapper)
+        """
+        raise NotImplementedError(
+            "Subclasses need to implement this based on their input ir"
+        )
+
+    def compile(self, options: dict = {}):
+        if not self.is_compiled:
+            self.fasmir, self.io_wrapper = self._compile(self.input_ir, options)
+
+    def dump_bitfile(self, encrypt: bool = True) -> bytes:
+        """Dumps a bitfile used to program the SPU."""
+        if not self.is_compiled:
+            raise RuntimeError("Model must be compiled before dumping bitfile")
+
+        with tempfile.TemporaryFile() as tmpfile:
+            with tempfile.TemporaryDirectory() as dirname:
+                # Dump memory files to a directory
+                runner = SimRunner(self.fasmir, data_dir=dirname, encrypt=encrypt)
+                runner.reset()
+                runner.finish()
+
+                # Archive the directory
+                with zipfile.ZipFile(
+                    tmpfile, mode="w", compression=zipfile.ZIP_DEFLATED
+                ) as archive:
+                    for relpath in os.listdir(dirname):
+                        abspath = os.path.join(dirname, relpath)
+                        archive.write(abspath, arcname=relpath)
+
+            # Read out the bytes in the archive
+            tmpfile.seek(0)
+            bitfile = tmpfile.read()
+
+        return bitfile
+
+    def _get_padded_len(self, fasmir: FASMIR, name: str):
+        try:
+            fasmir_var = fasmir.data_vars[name]
+        except KeyError:
+            raise ValueError(
+                "Failed to find FASMIR variable corresponding to name %s" % name
+            )
+        return fasmir_var.numpy.shape[0]
+
+    def run_behavioral_simulator(
+        self,
+        *args: np.ndarray,
+        input_period: float = None,
+        quantize_inputs=True,
+        dequantize_outputs=True,
+        **kwargs
+    ):
+        """
+        Runs the behavioral simulator and returns outputs and metrics.
+
+        Arguments:
+            args (np.ndarray): Input tensors to the simulator, as numpy arrays. Either
+                               floating-point or integer (see `quantize_inputs` for
+                               more detail on input datatypes).
+            input_period (float, optional): total simulation time.
+            quantize_inputs (bool, optional): If True, then floating-point inputs will
+                             be quantized to integer before passing into the simulator.
+                            Otherwise, the simulator expects that the inputs will
+                            already be in integer format. Default True.
+            dequantize_outputs (bool: optional): If True, the integer outputs from the
+                                simulator will be cast back to the original
+                                floating-point domain. Otherwise, the outputs will be
+                                returned as integers. Default True.
+
+        """
+        return self.io_wrapper.run(
+            *args,
+            input_period=input_period,
+            quantize_inputs=quantize_inputs,
+            dequantize_outputs=dequantize_outputs,
+            **kwargs
+        )

femtocrux/femtostack/common/metrics.py

@@ -0,0 +1,184 @@
+import numpy as np
+import tabulate
+from collections import defaultdict
+from typing import List, Union, Dict
+
+PREFIXES = {
+    1e-15: "f",
+    1e-12: "p",
+    1e-9: "n",
+    1e-6: "µ",
+    1e-3: "m",
+    1: "",
+    1e3: "k",
+    1e6: "M",
+    1e9: "G",
+}
+
+
+def to_sci(x):
+    """Convert a float to a scientific-prefix formatted string
+
+    e.g. 0.004531 -> '4.531 m'
+    """
+    ks = np.array(list(PREFIXES.keys()))
+    ks_cut = ks[ks <= np.abs(x)]
+    if len(ks_cut) > 0:
+        k = np.max(ks[ks <= x])
+        pref = PREFIXES[k]
+        x = x / k
+        return f"{x:.3g} {pref}"
+    else:
+        return f"{x:.3g} "
+
+
+def _merge_dicts(dicts: List[dict]):
+    """Merges list of dicts into dict of lists"""
+    output = defaultdict(list)
+    for d in dicts:
+        for k, v in d.items():
+            output[k].append(v)
+    for k, v in output.items():
+        if isinstance(v[0], dict):
+            output[k] = _merge_dicts(v)
+    return dict(output)
+
+
+ALLOWED_KEYS = [
+    "Dynamic Energy/Frame (J)",
+    "Total Energy/Frame (J)",
+    "Latency (s)",
+    "Static Energy/Frame (J)",
+    "Memory",
+    "Frames Simulated",
+    "Power (W)",
+]
+
+
+class SimMetrics:
+    """
+    Object storing hardware simulator metrics.
+
+    Arguments:
+        metrics (list[dict] or dict[list]): measured metrics per batch
+            from simulator
+        dt (float, optional): total duration of the simulation, in seconds.
+            If not provided, will use the total active time of the sim, but this will
+            overlook the time spent sleeping.
+
+    Attributes:
+        total_energy: average total energy in Joules
+        total_active_time: average time spent processing in seconds
+        latency_per_frame: active time divided by the number of processed
+            input frames
+        power: average power consumption, in Watts
+
+        metrics: detailed metrics dictionary
+
+    """
+
+    def __init__(
+        self,
+        metrics: Union[List[Dict[str, float]], Dict[str, List[float]]],
+        dt=None,
+        reduction_mode: str = "mean",
+    ):
+        if isinstance(metrics, list):
+            metrics = _merge_dicts(metrics)
+
+        for k in list(metrics.keys()):
+            if k not in ALLOWED_KEYS:
+                metrics.pop(k)
+
+        self.metrics = metrics
+        self.dt = dt
+
+        self.reduction_mode = reduction_mode
+        if reduction_mode == "mean":
+            self.reduce = np.mean
+        elif reduction_mode == "sum":
+            self.reduce = np.sum
+
+    @property
+    def num_frames(self):
+        return self.reduce(self.metrics["Frames Simulated"])
+
+    @property
+    def total_energy(self):
+        return self.reduce(self.metrics["Total Energy/Frame (J)"]) * self.num_frames
+
+    @property
+    def total_dynamic_energy(self):
+        return self.reduce(self.metrics["Dynamic Energy/Frame (J)"]) * self.num_frames
+
+    @property
+    def total_static_energy(self):
+        return self.reduce(self.metrics["Static Energy/Frame (J)"]) * self.num_frames
+
+    @property
+    def total_active_time(self):
+        return self.reduce(self.metrics["Latency (s)"]) * self.num_frames
+
+    @property
+    def latency(self):
+        return self.reduce(self.metrics["Latency (s)"])
+
+    @property
+    def total_time(self):
+        if self.dt is not None:
+            dt = self.dt * self.metrics["Frames Simulated"][0]
+            return max(dt, self.total_active_time)
+        else:
+            return self.total_active_time
+
+    @property
+    def power(self):
+        return self.reduce(self.metrics["Power (W)"])
+
+    def performance_report(self):
+        report = [
+            ["total energy", f"{to_sci(self.total_energy)}J"],
+            ["total dynamic energy", f"{to_sci(self.total_dynamic_energy)}J"],
+            ["total static energy", f"{to_sci(self.total_static_energy)}J"],
+            ["power", f"{to_sci(self.power)}W"],
+            ["total active time", f"{to_sci(self.total_active_time)}s"],
+            ["total time", f"{to_sci(self.total_time)}s"],
+            ["latency/frame", f"{to_sci(self.latency)}s"],
+        ]
+        output = tabulate.tabulate(report)
+        return output
+
+    def memory_report(self):
+        mem = self.metrics["Memory"]
+
+        out = {}
+        for mem_type in ["Data Mem", "Instr Mem", "Table Mem"]:
+            k = f"{mem_type} (B)"
+            out[mem_type] = {
+                "Used": int(mem["Used"][k][0]),
+                "Capacity": int(mem["Capacity"][k][0]),
+            }
+
+        full_names = {
+            "Data Mem": "Data Memory",
+            "Instr Mem": "Instruction Memory",
+            "Table Mem": "Table Memory",
+        }
+
+        report = [["Memory Type", "Used", "Capacity", "Percentage"]]
+        for key, name in full_names.items():
+            used = out[key]["Used"]
+            cap = out[key]["Capacity"]
+            pct = 100 * used / cap
+            report.append([name, f"{to_sci(used)}B", f"{to_sci(cap)}B", f"{pct:.1f}%"])
+        return tabulate.tabulate(report, headers="firstrow")
+
+    def __repr__(self):
+        perf = self.performance_report()
+        mem = self.memory_report()
+        output = f"Behavioral Simulator Metrics, {self.reduction_mode} over batches"
+        output += f"\n\n{perf}"
+        output += f"\n\n{mem}"
+
+        output = ("-" * 60 + "\n") + output + ("\n" + "-" * 60)
+        return output

femtocrux/femtostack/common/sim_io.py

@@ -0,0 +1,470 @@
+import numpy as np
+from femtobehav.fasmir import FASMIR
+from femtobehav.sim import SimRunner
+
+# from femtobehav.sim.runner import _yamlify_nested_dict
+from collections import defaultdict
+from typing import List, Dict, Union
+import yaml
+
+
+class Quantizer:
+    """Converts a floating-point input to integer
+
+    Arguments:
+        precision (str): Output integer precision; 'i8' or 'STD' for int-8,
+            'i16' or 'DBL' for int-16
+        scale (float): scale value, a positive real number
+        zero_point (int): zero-point, an integer
+    """
+
+    def __init__(self, precision: str, scale: float, zero_point: int = 0):
+        if precision.upper() == "STD":
+            precision = "i8"
+        elif precision.upper() == "DBL":
+            precision = "i16"
+
+        assert precision in ["i8", "i16"]
+        self.scale = scale
+        self.zero_point = zero_point
+        self.precision = precision
+
+    def __call__(self, x: np.ndarray) -> np.ndarray:
+        if self.precision == "i8":
+            bits = 8
+            dtype = np.int8
+        else:
+            bits = 16
+            dtype = np.int16
+
+        lims = -(2 ** (bits - 1)), 2 ** (bits - 1) - 1
+        y = np.round(x / self.scale + self.zero_point)
+        y = np.clip(y, *lims).astype(dtype)
+        return y
+
+
+def _force_ints(x):
+    """
+    GRPC turns everything to floats on the way in
+    cast to int, see if it matches, get angry otherwise
+    takes the place of a quantizer, but does nothing
+    """
+    x_int = x.astype(int)
+    if not (x == x_int).all():
+        raise ValueError("trying to pass float into simulator without quantization")
+    return x_int
+
+
+class DeQuantizer:
+    """Converts from integer to floating-point
+
+    Arguments:
+        precision (str): Output integer precision; 'i8' or 'STD' for int-8,
+            'i16' or 'DBL' for int-16
+        scale (float): scale value, a positive real number
+        zero_point (int): zero-point, an integer
+
+    Returns:
+        a numpy array of precision float32
+    """
+
+    def __init__(self, scale: float, zero_point: int = 0):
+        self.scale = scale
+        self.zero_point = zero_point
+
+    def __call__(self, x: np.ndarray) -> np.ndarray:
+        y = (x.astype(np.float32) - self.zero_point) * self.scale
+        return y
+
+
+class Padder:
+    """Applies padding to a single axis of a tensor
+
+    Arguments:
+        name (str): the input name, for error handling
+        true_length (int): length of the axis before padding; the original
+            length in the high-level IR
+        padded_length (int): length of the axis after padding; padding
+            the result of the compiler fitting variables into integer multiples
+            of the word-size
+        axis (int, default -1): axis to apply padding to
+    """
+
+    def __init__(self, name: str, true_length: int, padded_length: int, axis: int = -1):
+        self.name = name
+        self.true_length = true_length
+        self.padded_length = padded_length
+        self.axis = axis
+
+    def __call__(self, x: np.ndarray) -> np.ndarray:
+        # Verify the input shape
+        input_len = x.shape[self.axis]
+        expected_len = self.true_length
+        if input_len != expected_len:
+            raise ValueError(
+                "Received unexpected shape for input %s. "
+                "Expected a vector of length %d. (Received: %d)"
+                % (self.name, expected_len, input_len)
+            )
+
+        assert x.shape[self.axis] == self.true_length
+        p_shp = list(x.shape)
+        p_shp[self.axis] = self.padded_length - self.true_length
+        x = np.concatenate([x, np.zeros(p_shp, dtype=x.dtype)], axis=self.axis)
+        return x
+
+
+class DePadder:
+    """Removes padding from a single axis of a tensor
+
+    Arguments:
+        true_length (int): length of the axis before padding; the original
+            length in the high-level IR
+        padded_length (int): length of the axis after padding; padding
+            the result of the compiler fitting variables into integer multiples
+            of the word-size
+        axis (int, default -1): axis to apply padding to
+    """
+
+    def __init__(self, true_length: int, padded_length: int, axis: int = -1):
+        self.true_length = true_length
+        self.padded_length = padded_length
+        self.axis = axis
+
+    def __call__(self, x: np.ndarray) -> np.ndarray:
+        assert x.shape[self.axis] == self.padded_length
+        ndim = x.ndim
+        slicers = [slice(0, None, 1)] * ndim
+        slicers[self.axis] = slice(0, self.true_length, 1)
+        y = x[tuple(slicers)]
+        return y
+
+
+def _standardize_dim(d, ndim):
+    if d is not None:
+        return d % ndim
+    return d
+
+
+class BatchSlicer:
+    """Converts input multidimensional tensor into slices that iterate
+    over batch and sequential dimensions
+    """
+
+    def __init__(self, batch_dim=None, seq_dim=None):
+        self.batch_dim = batch_dim
+        self.seq_dim = seq_dim
+
+    def __call__(self, x: np.ndarray) -> List[List[np.ndarray]]:
+        # first, standardize the input to shape (batch, time, features)
+        # inserting unary dims if needed
+
+        # handle negatively indexed dimensions
+        ndim = x.ndim
+        batch_dim, seq_dim = map(
+            lambda u: _standardize_dim(u, ndim), [self.batch_dim, self.seq_dim]
+        )
+
+        # expand dims as needed
+        if batch_dim is None:
+            if seq_dim is None:
+                x = np.expand_dims(x, axis=[0, 1])
+                batch_dim = 0
+                seq_dim = 1
+            else:
+                x = np.expand_dims(x, axis=0)
+                batch_dim = 0
+                seq_dim += 1
+        elif seq_dim is None:
+            x = np.expand_dims(x, axis=0)
+            seq_dim = 0
+            batch_dim += 1
+
+        feature_dim = set((0, 1, 2))
+        feature_dim.remove(batch_dim)
+        feature_dim.remove(seq_dim)
+        feature_dim = list(feature_dim)[0]
+
+        # apply transposes
+        x = np.transpose(x, [batch_dim, seq_dim, feature_dim])
+
+        # convert to List[array( time, feature )]:
+        out = [batch for batch in x]
+        return out
+
+
+def _get_btf(batch_dim, seq_dim):
+    ndim = 1 + int(batch_dim is not None) + int(seq_dim is not None)
+    batch_dim = _standardize_dim(batch_dim, ndim)
+    seq_dim = _standardize_dim(seq_dim, ndim)
+
+    feat_dim = set(range(ndim))
+    if batch_dim is not None:
+        feat_dim.remove(batch_dim)
+    if seq_dim is not None:
+        feat_dim.remove(seq_dim)
+    feat_dim = list(feat_dim)[0]
+
+    return batch_dim, seq_dim, feat_dim
+
+
+def _get_inverse_perm(perm):
+    out = [None] * len(perm)
+    for i, p in enumerate(perm):
+        out[p] = i
+    return out
+
+
+def _inv_transpose(x, forward_perm):
+    inverse_perm = _get_inverse_perm(forward_perm)
+    return np.transpose(x, inverse_perm)
+
+
+class BatchStacker:
+    """Converts a list of list of tensors into a single tensor,
+    given the desired batch/seq dim ordering
+    """
+
+    def __init__(self, batch_dim=None, seq_dim=None):
+        self.batch_dim = batch_dim
+        self.seq_dim = seq_dim
+
+    def __call__(self, x: List[np.ndarray]) -> np.ndarray:
+        x = np.stack([batch for batch in x], 0)
+
+        batch_dim, seq_dim, feat_dim = _get_btf(self.batch_dim, self.seq_dim)
+
+        if batch_dim is not None:
+            if seq_dim is not None:
+                return _inv_transpose(x, [batch_dim, seq_dim, feat_dim])
+            else:
+                x = np.squeeze(x, 1)
+                return _inv_transpose(x, [batch_dim, feat_dim])
+        else:
+            if seq_dim is not None:
+                x = np.squeeze(x, 0)
+                return _inv_transpose(x, [seq_dim, feat_dim])
+            else:
+                return x[0, 0]
+
+
+class IOConfig:
+    """
+    TODO: documentation here
+
+    recommended to use the get_input_io and get_output_io factory methods
+    instead of constructing from init.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        quantizer: Union[Quantizer, DeQuantizer] = None,
+        padder: Union[Padder, DePadder] = None,
+        stacker: BatchStacker = None,
+        slicer: BatchSlicer = None,
+    ):
+        self.name = name
+        self.quantizer = quantizer
+        self.padder = padder
+        self.stacker = stacker
+        self.slicer = slicer
+
+    @classmethod
+    def get_input_io(
+        cls,
+        name: str,
+        precision: str,
+        scale: float = None,
+        zero_point: int = None,
+        feature_len: int = None,
+        padded_feature_len: int = None,
+        batch_dim: int = None,
+        seq_dim: int = None,
+    ):
+        """
+        Creates an IO pipeline of:
+            Quantize -> Pad -> Slice
+        """
+
+        batch_dim, seq_dim, feat_dim = _get_btf(batch_dim, seq_dim)
+
+        # get input quantizer
+        if (scale is not None) or (zero_point is not None):
+            if scale is None:
+                scale = 1
+            if zero_point is None:
+                zero_point = 0
+            quantizer = Quantizer(precision, scale, zero_point)
+        else:
+            quantizer = None
+
+        # get input padder
+        if (feature_len is not None) and (padded_feature_len is not None):
+            padder = Padder(name, feature_len, padded_feature_len, axis=feat_dim)
+        else:
+            padder = None
+
+        # get input slicer
+        slicer = BatchSlicer(batch_dim, seq_dim)
+
+        return cls(name, quantizer, padder, slicer=slicer)
+
+    @classmethod
+    def get_output_io(
+        cls,
+        name: str,
+        scale: float = None,
+        zero_point: int = None,
+        feature_len: int = None,
+        padded_feature_len: int = None,
+        batch_dim: int = None,
+        seq_dim: int = None,
+    ):
+        """
+        Creates an IO pipeline of:
+            Stack -> DeQuantize -> DePad
+        """
+        batch_dim, seq_dim, feat_dim = _get_btf(batch_dim, seq_dim)
+
+        # get stacker
+        stacker = BatchStacker(batch_dim, seq_dim)
+
+        # get dequantizer
+        if (scale is not None) or (zero_point is not None):
+            if scale is None:
+                scale = 1
+            if zero_point is None:
+                zero_point = 0
+            quantizer = DeQuantizer(scale, zero_point)
+        else:
+            quantizer = None
+
+        # get de-padder
+        if (feature_len is not None) and (padded_feature_len is not None):
+            padder = DePadder(feature_len, padded_feature_len, feat_dim)
+        else:
+            padder = None
+
+        return cls(name, quantizer, padder, stacker=stacker)
+
+    def __call__(
+        self, x: Union[np.ndarray, List[List[np.ndarray]]], quant=True
+    ) -> Union[np.ndarray, List[List[np.ndarray]]]:
+        if self.stacker is not None:
+            x = self.stacker(x)
+
+        if not quant:  # GRPC workaround
+            x = _force_ints(x)
+        elif quant and self.quantizer is not None:
+            x = self.quantizer(x)
+
+        if self.padder is not None:
+            x = self.padder(x)
+        if self.slicer is not None:
+            x = self.slicer(x)
+
+        return x
+
+
+class SimIOWrapper:
+    """
+    Wraps execution of a SimRunner with IOConfigs
+    """
+
+    def __init__(self, fasmir: FASMIR):
+        self.input_configs: List[IOConfig] = []
+        self.output_configs: List[IOConfig] = []
+        self.fasmir = fasmir
+
+    def add_input(self, cfg: IOConfig):
+        self.input_configs.append(cfg)
+
+    def add_output(self, cfg: IOConfig):
+        self.output_configs.append(cfg)
+
+    def _preprocess_inputs(self, *args: np.ndarray, quant=True):
+        # Verify the number of inputs
+        num_inputs = len(args)
+        expected_num_inputs = len(self.input_configs)
+        if num_inputs != expected_num_inputs:
+            raise ValueError(
+                "Unexpected number of inputs.\nExpected: %s\nGot: %s"
+                % (num_inputs, expected_num_inputs)
+            )
+        assert len(args) == len(self.input_configs)
+
+        # Assign each input to a config
+        inputs: Dict[str, List[np.ndarray]] = {}
+        for arg, cfg in zip(args, self.input_configs):
+            inputs[cfg.name] = cfg(arg, quant=quant)
+
+        return inputs
+
+    def _postprocess_outputs(
+        self, outputs: Dict[str, List[np.ndarray]], quant=True
+    ) -> List[np.ndarray]:
+        post_outputs = []
+        for cfg in self.output_configs:
+            pre_out = outputs[cfg.name]
+            post_outputs.append(cfg(pre_out, quant=quant))
+        return post_outputs
+
+    def _run_sim_once(self, inputs: Dict[str, np.ndarray], input_period=None, **kwargs):
+        runner = SimRunner(self.fasmir, **kwargs)
+        runner.reset()
+        outputs, __, __ = runner.run(inputs)
+        metrics = runner.get_metrics(input_period, concise=True, as_yamlable=True)
+        runner.finish()
+        return outputs, metrics
+
+    def run(
+        self,
+        *args,
+        input_period=None,
+        quantize_inputs=True,
+        dequantize_outputs=True,
+        **kwargs
+    ):
+        inputs = self._preprocess_inputs(*args, quant=quantize_inputs)
+
+        B = None
+        for x in inputs.values():
+            b = len(x)
+            if B is None:
+                B = b
+            assert b == B, "Provided inputs did not have matching batch-sizes"
+
+        outputs = defaultdict(list)
+        metrics = []
+
+        for b in range(B):
+            input_b = {}
+            for k, v in inputs.items():
+                input_b[k] = v[b]
+                output_b, metric_b = self._run_sim_once(
+                    input_b, input_period=input_period, **kwargs
+                )
+                metrics.append(metric_b)
+                for k, v in output_b.items():
+                    outputs[k].append(v)
+
+        # clean up output formatting
+        outputs = self._postprocess_outputs(outputs, quant=dequantize_outputs)
+
+        # warn the user that batches aren't really supported for metrics purposes
+        # want to put the WARNING in first, so it shows up at the top
+        if B > 1:
+            ret_metrics = {
+                "WARNING": "simulation was over a batch:"
+                + "metrics here are only for the first batch element"
+            }
+            for k, v in metrics[0].items():
+                ret_metrics[k] = v
+        else:
+            ret_metrics = metrics[0]
+
+        # turn the dict into a yaml
+        metrics_str = yaml.dump(ret_metrics, sort_keys=False)
+
+        return outputs, metrics_str

femtocrux/femtostack/tflite_api/__init__.py

@@ -0,0 +1,6 @@
+"""
+ Copyright Femtosense 2024
+ 
+ By using this software package, you agree to abide by the terms and conditions
+ in the license agreement found at https://femtosense.ai/legal/eula/
+"""

femtocrux/femtostack/tflite_api/tflite_frontend.py

@@ -0,0 +1,6 @@
+from femtocrux.femtostack.common import CompilerFrontend
+
+
+class TFLiteCompiler(CompilerFrontend):
+    def __init__(self, *args, **kwargs):
+        raise ValueError("TFLiteCompiler deprecated in this release")

femtocrux/femtostack/torch_api/frontend.py

@@ -0,0 +1,136 @@
+from fmot import ConvertedModel
+from fmot.fqir import GraphProto
+from femtocrux.femtostack.common import CompilerFrontend, SimIOWrapper, IOConfig
+from femtomapper import MapperConf, Mapper, MapperState
+from femtobehav.fasmir import FASMIR
+import torch
+from typing import Tuple
+
+
+def _compile_fqir(graph: GraphProto, options: dict) -> FASMIR:
+    mapper_conf = MapperConf(**options)
+    mapper = Mapper(mapper_conf)
+    mapper_state = MapperState(fqir=graph)
+
+    # compile:
+    mapper_state = mapper.do(mapper_state)
+
+    # extract fasmir
+    fasmir = mapper_state.fasmir
+    return fasmir
+
+
+class TorchCompiler(CompilerFrontend):
+    def __init__(self, graph: GraphProto, batch_dim: int = None, seq_dim: int = None):
+        assert isinstance(graph, GraphProto)
+
+        super().__init__(input_ir=graph)
+        self.batch_dim = batch_dim
+        self.seq_dim = seq_dim
+
+    def _compile(
+        self, input_ir: GraphProto, options: dict
+    ) -> Tuple[FASMIR, SimIOWrapper]:
+        fasmir = _compile_fqir(input_ir, options)
+        wrapper = self._get_fqir_iowrapper(input_ir, fasmir)
+        return fasmir, wrapper
+
+    def _get_fqir_iowrapper(self, graph: GraphProto, fasmir: FASMIR) -> SimIOWrapper:
+        wrapper = SimIOWrapper(fasmir)
+        arith: GraphProto = graph.subgraphs["ARITH"]
+
+        # add input io
+        for x in arith.inputs:
+            name = x.name
+
+            # get quantization config
+            scale = 2**x.quanta
+            zp = 0
+
+            if x.dtype.endswith("8"):
+                prec = "i8"
+            else:
+                prec = "i16"
+
+            # get padding config
+            true_len = x.shape[0]
+            padded_len = fasmir.data_vars[name].numpy.shape[0]
+
+            # add input to wrapper
+            wrapper.add_input(
+                IOConfig.get_input_io(
+                    name,
+                    prec,
+                    scale=scale,
+                    zero_point=zp,
+                    feature_len=true_len,
+                    padded_feature_len=padded_len,
+                    batch_dim=self.batch_dim,
+                    seq_dim=self.seq_dim,
+                )
+            )
+
+        # add output io
+        for x in arith.outputs:
+            name = x.name
+
+            # get quantization config
+            scale = 2**x.quanta
+            zp = 0
+
+            # get padding config
+            true_len = x.shape[0]
+            padded_len = self._get_padded_len(fasmir, name)
+
+            # add input to wrapper
+            wrapper.add_output(
+                IOConfig.get_output_io(
+                    name,
+                    scale=scale,
+                    zero_point=zp,
+                    feature_len=true_len,
+                    padded_feature_len=padded_len,
+                    batch_dim=self.batch_dim,
+                    seq_dim=self.seq_dim,
+                )
+            )
+
+        # done!
+        return wrapper
+
+    @classmethod
+    def from_fqir(cls, graph: GraphProto, batch_dim: int = None, seq_dim: int = None):
+        assert isinstance(graph, GraphProto)
+        return cls(graph, batch_dim, seq_dim)
+
+    @classmethod
+    def from_converted_model(
+        cls,
+        model: ConvertedModel,
+        batch_dim: int = None,
+        seq_dim: int = None,
+        experimental_tracing=False,
+    ):
+        assert isinstance(model, ConvertedModel)
+        graph = model.trace(experimental_hybrid_tracing=experimental_tracing)
+        return cls(graph, batch_dim, seq_dim)
+
+    @classmethod
+    def from_torch_module(
+        cls,
+        module: torch.nn.Module,
+        calibration_data,
+        precision: str = "double",
+        batch_dim: int = None,
+        seq_dim: int = None,
+        experimental_tracing=False,
+        conversion_kwargs: dict = {},
+    ):
+        cmodel = ConvertedModel(
+            module, precision, batch_dim=batch_dim, seq_dim=seq_dim, **conversion_kwargs
+        )
+        cmodel.quantize(calibration_data)
+
+        return TorchCompiler.from_converted_model(
+            cmodel, batch_dim, seq_dim, experimental_tracing
+        )

femtocrux/grpc/compiler_service_pb2_grpc.py

@@ -6,10 +6,10 @@ import warnings
 import compiler_service_pb2 as compiler__service__pb2
 from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
 
-GRPC_GENERATED_VERSION = '1.64.1'
+GRPC_GENERATED_VERSION = '1.65.1'
 GRPC_VERSION = grpc.__version__
-EXPECTED_ERROR_RELEASE = '1.65.0'
-SCHEDULED_RELEASE_DATE = 'June 25, 2024'
+EXPECTED_ERROR_RELEASE = '1.66.0'
+SCHEDULED_RELEASE_DATE = 'August 6, 2024'
 _version_not_supported = False
 
 try:

femtocrux/server/server.py

@@ -7,9 +7,9 @@ import logging
 import pickle
 import sys
 
-from femtostack.common import CompilerFrontend
-from femtostack.tflite_api.tflite_frontend import TFLiteCompiler
-from femtostack.torch_api.frontend import TorchCompiler
+from femtocrux.femtostack.common import CompilerFrontend
+from femtocrux.femtostack.tflite_api.tflite_frontend import TFLiteCompiler
+from femtocrux.femtostack.torch_api.frontend import TorchCompiler
 
 from femtocrux.server.exceptions import format_exception, format_exception_from_exc
 from femtocrux.util.utils import (
@@ -173,7 +173,7 @@ class CompileServicer(cs_pb2_grpc.CompileServicer):
             # Respond with output data
             yield cs_pb2.simulation_output(
                 data=[numpy_to_ndarray(x) for x in outputs],
-                report=metrics.performance_report(),
+                report=metrics,
                 status=cs_pb2.status(success=True),
             )
 

{femtocrux-0.5.3.dist-info → femtocrux-0.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: femtocrux
-Version: 0.5.3
+Version: 0.6.1
 Summary: Femtosense Compiler
 Home-page: https://github.com/femtosense/femtocrux
 Author: Femtosense

femtocrux-0.6.1.dist-info/RECORD

@@ -0,0 +1,30 @@
+femtocrux/ENV_REQUIREMENTS.sh,sha256=t_O1B4hJAMgxvH9gwp1qls6eVFmhSYBJe64KmuK_H-4,1389
+femtocrux/PY_REQUIREMENTS,sha256=lELTbw5r4KCzeFn0TjLp0QpbOuHnl4XjGKwyL9yVBrc,285
+femtocrux/VERSION,sha256=h7JBsnXFkWlIRlYOmHn1DJ2jFQ-FTv2r14LFOXcvMDM,6
+femtocrux/__init__.py,sha256=yIWd9I2PEXCn_PKIILAN3mkWeTf0tgtVualeTIHNxfQ,342
+femtocrux/version.py,sha256=uNg2kHxQo6oUN1ah7s9_85rCZVRoTHGPD1GAQPZW4lw,164
+femtocrux/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+femtocrux/client/client.py,sha256=PNaXL_XTe_7_r14WWKmp1RnvAW-kvYzDXcimseA8sEo,22726
+femtocrux/femtostack/__init__.py,sha256=75hXE1ODNiLmiFrkEtfVfhA3O0ZVH-Ub0KoXdJu3n5g,171
+femtocrux/femtostack/common/__init__.py,sha256=Ig25arHQZ05IiLWSlkgR9EmvguEsa5bZF8V8YapobzY,343
+femtocrux/femtostack/common/frontend.py,sha256=OutJsOvALoY5xdf7Je2ixYE1iuf7BrtacwXoaBaFV9c,4069
+femtocrux/femtostack/common/metrics.py,sha256=gmy30EmDI2XkM-Kh_j8fifPQpyM2O1y_cGBMb9SJt_I,5324
+femtocrux/femtostack/common/sim_io.py,sha256=sqU_qaR1pTfmNQfU_ns3w5bxJWhEKzEgUouLCvljHcw,14401
+femtocrux/femtostack/tflite_api/__init__.py,sha256=SKq1KoXWRNMGQSf9RqBa5BUY-0JCMLW4T_UZmJJBSlE,186
+femtocrux/femtostack/tflite_api/tflite_frontend.py,sha256=CsvurJ2RJPnUgjfwQ8ru6jL5sNmb-AbTF1TIwZuHuBY,210
+femtocrux/femtostack/torch_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+femtocrux/femtostack/torch_api/frontend.py,sha256=-12zz0NpvQgpPNqBMg7EJQdomtRJPNffrVKC6rBqfBE,4064
+femtocrux/grpc/__init__.py,sha256=uiMHQt5I2eAKJqI3Zh0h1Gm7cmPR4PbaGS71nCJQCGw,169
+femtocrux/grpc/compiler_service_pb2.py,sha256=Fu4wOuUsu4lN1Ig3GacvuzYJ7MPRq-hTbqSzrCDqRAc,4460
+femtocrux/grpc/compiler_service_pb2_grpc.py,sha256=Sat3uoVCwQIEVx99aYTD2YExn5G4bF9Lhv3QCGgxQtM,8738
+femtocrux/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+femtocrux/server/exceptions.py,sha256=lI6n471n5QKf5G3aL_1kuBVEItD-jBgithVVpPDwNYc,609
+femtocrux/server/healthcheck.py,sha256=ehqAwnv0D0zpy-AUZAPwv8rp874DZCwUmP8nzdXzZvI,1565
+femtocrux/server/server.py,sha256=fpwL1GtFvdw7E0inkMDbDKd-Hu3QAuEgvlqFP7vtZhY,7928
+femtocrux/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+femtocrux/util/utils.py,sha256=FZ8cssDom4B3FDbVU_ew4Cf3wOWjo2w1jwcbnLzoYnM,1003
+femtocrux-0.6.1.dist-info/LICENSE,sha256=eN9ZI1xHjUmFvN3TEeop5kBGXRUBfbsl55KBNBYYFqI,36
+femtocrux-0.6.1.dist-info/METADATA,sha256=Vy_KiaSGwAXRK7LMcO9lR5ha4VGq7d5fkEFOEQ4P8sk,3561
+femtocrux-0.6.1.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+femtocrux-0.6.1.dist-info/top_level.txt,sha256=BkTttlioC3je__8577wxRieZqY3Abu7FOOdMnmYbcNI,10
+femtocrux-0.6.1.dist-info/RECORD,,

{femtocrux-0.5.3.dist-info → femtocrux-0.6.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.3.0)
+Generator: setuptools (71.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

femtocrux-0.5.3.dist-info/RECORD

@@ -1,21 +0,0 @@
-femtocrux/ENV_REQUIREMENTS.sh,sha256=t_O1B4hJAMgxvH9gwp1qls6eVFmhSYBJe64KmuK_H-4,1389
-femtocrux/PY_REQUIREMENTS,sha256=lELTbw5r4KCzeFn0TjLp0QpbOuHnl4XjGKwyL9yVBrc,285
-femtocrux/VERSION,sha256=J-z_H82vZatGwbuZwQctbRNKDo3Zfdlc-ohpa57UU7I,6
-femtocrux/__init__.py,sha256=yIWd9I2PEXCn_PKIILAN3mkWeTf0tgtVualeTIHNxfQ,342
-femtocrux/version.py,sha256=uNg2kHxQo6oUN1ah7s9_85rCZVRoTHGPD1GAQPZW4lw,164
-femtocrux/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-femtocrux/client/client.py,sha256=PNaXL_XTe_7_r14WWKmp1RnvAW-kvYzDXcimseA8sEo,22726
-femtocrux/grpc/__init__.py,sha256=uiMHQt5I2eAKJqI3Zh0h1Gm7cmPR4PbaGS71nCJQCGw,169
-femtocrux/grpc/compiler_service_pb2.py,sha256=Fu4wOuUsu4lN1Ig3GacvuzYJ7MPRq-hTbqSzrCDqRAc,4460
-femtocrux/grpc/compiler_service_pb2_grpc.py,sha256=SgL_HC0nLzuwjpm8U6CdRPb2sJjVOLQrhKHpp0D-gHk,8737
-femtocrux/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-femtocrux/server/exceptions.py,sha256=lI6n471n5QKf5G3aL_1kuBVEItD-jBgithVVpPDwNYc,609
-femtocrux/server/healthcheck.py,sha256=ehqAwnv0D0zpy-AUZAPwv8rp874DZCwUmP8nzdXzZvI,1565
-femtocrux/server/server.py,sha256=tmXVleZQB59oFzdmut3na4NnDvr0gmxphXF3N3MQx6I,7919
-femtocrux/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-femtocrux/util/utils.py,sha256=FZ8cssDom4B3FDbVU_ew4Cf3wOWjo2w1jwcbnLzoYnM,1003
-femtocrux-0.5.3.dist-info/LICENSE,sha256=eN9ZI1xHjUmFvN3TEeop5kBGXRUBfbsl55KBNBYYFqI,36
-femtocrux-0.5.3.dist-info/METADATA,sha256=xWND9JZM8p1LP2H7tfbmd5hF0GvZicv09dRdOKSKTEg,3561
-femtocrux-0.5.3.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
-femtocrux-0.5.3.dist-info/top_level.txt,sha256=BkTttlioC3je__8577wxRieZqY3Abu7FOOdMnmYbcNI,10
-femtocrux-0.5.3.dist-info/RECORD,,