fmot 3.16.0__tar.gz

fmot-3.16.0/LICENSE

@@ -0,0 +1 @@
+Copyright (c) 2024 Femtosense, Inc.

fmot-3.16.0/MANIFEST.in

@@ -0,0 +1,12 @@
+include NAME
+include LICENSE
+include *.yml
+include */VERSION
+include */ENV_REQUIREMENTS.sh
+include */PY_REQUIREMENTS
+include */*_REQUIREMENTS
+include pyproject.toml
+recursive-include * *.c
+exclude obfuscation_cfg.yaml
+exclude obfuscate.py
+include *.wav

fmot-3.16.0/NAME

@@ -0,0 +1 @@
+fmot

fmot-3.16.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: fmot
+Version: 3.16.0
+Summary: Femtosense Model Optimization Toolkit
+Home-page: https://github.com/femtosense/fmot
+Author: Femtosense
+Author-email: info@femtosense.ai
+Project-URL: Source, https://github.com/femtosense/fmot
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Cython
+Requires-Dist: torch>=1.12.1
+Requires-Dist: numpy>=2.0
+Requires-Dist: scipy<1.17
+Requires-Dist: python_speech_features
+Requires-Dist: tqdm
+Requires-Dist: networkx
+Requires-Dist: deprecation
+Requires-Dist: tabulate
+Requires-Dist: colorcet
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Requires-Dist: pyyaml
+Requires-Dist: ordered_set==4.1.0
+Requires-Dist: femtorun>=1.1.6
+Provides-Extra: onnx2fqir
+Requires-Dist: onnx; extra == "onnx2fqir"
+Requires-Dist: onnxruntime; extra == "onnx2fqir"
+Requires-Dist: tensorflow; extra == "onnx2fqir"
+Provides-Extra: tf
+Requires-Dist: tensorflow; extra == "tf"
+Requires-Dist: tf-keras; extra == "tf"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+![Build Status](https://codebuild.us-west-2.amazonaws.com/badges?uuid=eyJlbmNyeXB0ZWREYXRhIjoiRGpDOFpEOXF1M0prSy9OOVNkZ3F2NkRKM0NNMG8xbmpZU0hZdUp1ejhHOEswdDRhOEZOakMrdWZyaHp1WGVtQ1lVTStzRUpXaFlYeFZPSEJFd21NdjF3PSIsIml2UGFyYW1ldGVyU3BlYyI6InJZYzhuZ3d3a1FUUzBzM0kiLCJtYXRlcmlhbFNldFNlcmlhbCI6MX0%3D&branch=master)
+
+# fmot
+The Femtosense Model Optimization Toolkit (fmot) quantizes neural network models from PyTorch for deployment on Femtosense hardware.
+
+See the documentation at [fmot.femtosense.ai](fmot.femtosense.ai) for more details.
+

fmot-3.16.0/README.md

@@ -0,0 +1,7 @@
+![Build Status](https://codebuild.us-west-2.amazonaws.com/badges?uuid=eyJlbmNyeXB0ZWREYXRhIjoiRGpDOFpEOXF1M0prSy9OOVNkZ3F2NkRKM0NNMG8xbmpZU0hZdUp1ejhHOEswdDRhOEZOakMrdWZyaHp1WGVtQ1lVTStzRUpXaFlYeFZPSEJFd21NdjF3PSIsIml2UGFyYW1ldGVyU3BlYyI6InJZYzhuZ3d3a1FUUzBzM0kiLCJtYXRlcmlhbFNldFNlcmlhbCI6MX0%3D&branch=master)
+
+# fmot
+The Femtosense Model Optimization Toolkit (fmot) quantizes neural network models from PyTorch for deployment on Femtosense hardware.
+
+See the documentation at [fmot.femtosense.ai](fmot.femtosense.ai) for more details.
+

fmot-3.16.0/fmot/ENV_REQUIREMENTS.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+
+# You can put arbitrary shell commands in here.
+# Docker will also make use of these commands, so these must work in docker.
+# Think hard before introducing these kind of dependencies.
+
+function mac_install {
+    # install function for mac
+    # Check if already installed and install if not
+    brew list ${1} || brew install ${1}
+}
+
+function ubuntu_install {
+    # install function for mac
+    # Check if already installed and install if not
+    dpkg -s ${1} || apt-get install -y ${1}
+}
+
+# install packages. Unfortunately there is different method for each OS
+if [[ ${OSTYPE} == "linux"* ]]; then
+    DISTRO=$(awk -F= '/^ID=/{print $2}' /etc/os-release)
+
+    if [[ ${DISTRO} == *"ubuntu"* ]]; then :
+        # ==================== Ubuntu dependencies here ====================
+        # ubuntu_install htop
+        # ==================================================================
+
+    elif [[ ${DISTRO} == *"centos"* ]] ; then :
+        # ==================== CentOS dependencies here ====================
+        # yum install -y htop
+        # ==================================================================
+    fi
+
+elif [[ ${OSTYPE} == "darwin"* ]]; then :
+    # ==================== mac dependencies here =======================
+    # mac_install htop
+    # ==================================================================
+fi

fmot-3.16.0/fmot/ONNX2FQIR_REQUIREMENTS

@@ -0,0 +1,4 @@
+# tf2onnx @ git+https://github.com/femtosense/tensorflow-onnx@rp-fix-protobuf-version
+onnx
+onnxruntime
+tensorflow

fmot-3.16.0/fmot/PY_REQUIREMENTS

@@ -0,0 +1,15 @@
+Cython
+torch>=1.12.1 
+numpy>=2.0
+scipy<1.17
+python_speech_features
+tqdm
+networkx
+deprecation
+tabulate
+colorcet
+matplotlib
+pandas
+pyyaml
+ordered_set==4.1.0
+femtorun>=1.1.6

fmot-3.16.0/fmot/TF_REQUIREMENTS

@@ -0,0 +1,2 @@
+tensorflow
+tf-keras

fmot-3.16.0/fmot/VERSION

@@ -0,0 +1 @@
+3.16.0

fmot-3.16.0/fmot/__init__.py

@@ -0,0 +1,28 @@
+def _get_dir():
+    import pathlib
+
+    return pathlib.Path(__file__).parent.resolve()
+
+
+__version__ = (_get_dir() / "VERSION").read_text(encoding="utf-8").strip()
+
+import torch
+from . import torchscript_utils
+from . import configure
+from .configure import CONFIG, ROUND_CONFIG
+from . import nn
+from . import qat, utils, convert, tracing
+from ._open_docs import open_docs
+from ._supported_ops import supported_ops, conversion_branch
+from .convert.conversion_api import ConvertedModel
+from .convert.lut_registry import LUT_REGISTRY, register_lut, LUTConfig
+from .utils import save, load
+from .sparse import *
+from .beta import *
+from . import fqir
+from .stateful_sequencer import set_sequencer_p_inherit
+from .control import *
+from .functional import tag
+from . import precisions
+from .precisions import int24, int16, int8, Precision
+from .iospec import iospec_from_fqir

fmot-3.16.0/fmot/_open_docs.py

@@ -0,0 +1,17 @@
+import fmot
+import os
+import pathlib
+
+
+def open_docs():
+    fmot_path = pathlib.Path(fmot.__file__).parent.resolve().parent.resolve()
+    doc_path = os.path.join(fmot_path, "docs")
+    index_path = os.path.join(doc_path, "_build", "html", "index.html")
+    cwd = os.getcwd()
+    os.system(
+        f"cd {doc_path}; sphinx-apidoc -f . -o .; make clean html; cd {cwd}; open {index_path}"
+    )
+
+
+if __name__ == "__main__":
+    open_docs()

fmot-3.16.0/fmot/_supported_ops.py

@@ -0,0 +1,93 @@
+from fmot.convert.default_patchings import DEFAULT_PATCHINGS, PatchRule
+from fmot.convert.default_mappings import DEFAULT_MAPPINGS
+from fmot.convert.default_substitutions import DEFAULT_SUBSTITUTIONS
+from fmot.convert.lut_registry import LUT_REGISTRY
+import inspect
+from torch import nn
+import fmot
+import types
+
+
+def iter_nn_module_beneath_package(module: types.ModuleType, depth: int):
+    """Automatically yields all of the nn.Module layers under
+    a given package (e.g. fmot.nn)"""
+    assert isinstance(module, types.ModuleType)
+    for value in module.__dict__.values():
+        if isinstance(value, type) and issubclass(value, nn.Module):
+            yield value
+        # elif isinstance(value, types.ModuleType) and depth > 0:
+        #     if "fmot" in value.__file__:
+        #         for x in iter_nn_module_beneath_package(value, depth-1):
+        #             yield x
+
+
+def supported_ops():
+    """
+    Returns a list of supported operations.
+    """
+    sops = set()
+
+    # iterate over all of the substitutions
+    for m in DEFAULT_SUBSTITUTIONS:
+        # if m.__module__.startswith("torch"):
+        sops.add(m)
+
+    # iterate over all of the patchings, ensuring that there is an available mapping
+    for k, v in DEFAULT_PATCHINGS.items():
+        if isinstance(v, PatchRule):
+            patchings = v.options
+        else:
+            patchings = [v]
+        sops.add(k)
+
+    # iterate over all of the mappings, add mappings that start with builtin modules
+    for m in DEFAULT_MAPPINGS:
+        if m.__module__.startswith("torch"):
+            sops.add(m)
+        elif hasattr(m, "report_supported") and m.report_supported:
+            sops.add(m)
+
+    for m in iter_nn_module_beneath_package(fmot.nn, depth=3):
+        if hasattr(m, "report_supported") and m.report_supported:
+            sops.add(m)
+
+    for m in LUT_REGISTRY:
+        sops.add(m)
+
+    return list(sops)
+
+
+def typename(x):
+    if isinstance(x, type):
+        s = str(x)
+        return s.split("'")[1]
+    else:
+        return x
+
+
+def conversion_branch(op):
+    branch = [op]
+    if inspect.isfunction(op):
+        assert op.__module__ == "torch.nn.functional"
+        op = "F." + op.__name__
+        branch = [op]
+    elif type(op).__name__ == "builtin_function_or_method":
+        name = op.__name__
+        op = "aten::" + name
+        branch = ["torch." + name, op]
+    if op in DEFAULT_PATCHINGS:
+        op = DEFAULT_PATCHINGS[op]
+        if isinstance(op, PatchRule):
+            op = op.options[0]
+        branch += [op]
+    if op in DEFAULT_MAPPINGS:
+        op = DEFAULT_MAPPINGS[op]
+        branch += [op]
+    else:
+        branch += ["patched", "mapped"]
+    return " -> ".join([typename(n) for n in branch])
+
+
+if __name__ == "__main__":
+    print(list(iter_nn_module_beneath_package(fmot.nn, depth=3)))
+    # print(fmot.nn.__file__)

fmot-3.16.0/fmot/beta/__init__.py

@@ -0,0 +1,3 @@
+from .amp import optimize_mixed_precision
+from .quantize_part import quantize_part
+from .quant_error_visualizer import QuantizationErrorAnalyzer

fmot-3.16.0/fmot/beta/_quant_viz_example.py

@@ -0,0 +1,31 @@
+import torch
+from torch import nn
+import fmot
+from fmot.beta import QuantizationErrorAnalyzer
+
+if __name__ == "__main__":
+    model = nn.Sequential(
+        fmot.nn.TemporalConv1d(32, 64, kernel_size=1),
+        nn.ReLU(),
+        fmot.nn.TemporalConv1d(64, 64, kernel_size=3, groups=64),
+        nn.ReLU(),
+        fmot.nn.TemporalConv1d(64, 32, kernel_size=1),
+        fmot.nn.TemporalConv1d(32, 64, kernel_size=1),
+        nn.ReLU(),
+        fmot.nn.TemporalConv1d(64, 64, kernel_size=3, groups=64),
+        nn.ReLU(),
+        fmot.nn.TemporalConv1d(64, 32, kernel_size=1),
+        fmot.nn.TemporalConv1d(32, 64, kernel_size=1),
+        nn.ReLU(),
+        fmot.nn.TemporalConv1d(64, 64, kernel_size=3, groups=64),
+        nn.ReLU(),
+        fmot.nn.TemporalConv1d(64, 32, kernel_size=1),
+        nn.Sigmoid(),
+    )
+
+    cmodel = fmot.ConvertedModel(model, batch_dim=0, seq_dim=2)
+    cmodel.quantize([torch.randn(8, 32, 32) for _ in range(4)])
+
+    analyzer = QuantizationErrorAnalyzer(cmodel, (torch.randn(8, 32, 32),))
+    analyzer.plot_qsnr(show=True)
+    analyzer.plot_dynamic_range_utilization(show=True, fname="dyn_util.png")

fmot-3.16.0/fmot/beta/amp.py

@@ -0,0 +1,87 @@
+from fmot.exceptions import ConversionDependencyError
+from . import auto_multiprecision
+
+
+def optimize_mixed_precision(
+    cmodel,
+    objective,
+    eta,
+    inputs,
+    targets,
+    niter=1,
+    loss_type="polynomial",
+    device="cpu",
+    **kwargs
+):
+    r"""Heuristic search for an optimal mixed-precision configuration.
+
+    A mixed-precision configuration uses different integer bitwidths throughout
+    the model to reduce computational latency and energy when deployed in
+    hardware.
+
+    Args:
+        objective (callable): Objective function to co-minimize with energy.
+            Must have the signature :attr:`fn(output, target)` where
+            :attr:`output` is the model output and :attr:`target` is a
+            ground truth target. Must also return a single value.
+        eta (float): A hyperparameter between 0 and 1 to tune the relative weighting between
+            the objective function and energy minimization
+        inputs (list[Tensor] or list[tuple[Tensor]]): A set of inputs to the model.
+            If the model takes multiple inputs, :attr:`inputs` can be a list of tuples of
+            tensors, where each tuple holds a set of model inputs.
+        targets (list[Tensor]): A set of ground-truth targets; should be the same length and
+            1-to-1 with :attr:`inputs`. Used as the second argument to :attr:`objective`.
+        niter (int): Number of iterations of the optimization algorithm. Default is 1.
+        ramp_eta (bool): If true, :attr:`eta` will be linearly ramped over
+            the course of the :attr:`niter` repetitions. Default is True.
+        loss_type (str): :attr:`'polynomial'`, :attr:`'logarithmic'`, or
+            :attr:`'exponential'`. :attr:`polynomial` is the default. :attr:`logarithmic`
+            should be used for loss functions that are logarithmic with the model's
+            performance, such as cross-entropy, kl-divergence, and signal-to-noise-ratio.
+            :attr:`polynomial` should used if the loss function is linear or polynomial with
+            the model's performance, such as mean-squared-error, accuracy, F1, precision,
+            and recall.
+        num_inputs_per_step (int): number of inputs to use for each step of optimization.
+            Default is :attr:`None`, in which case the objective will be averaged on
+            all of the provided inputs and targets for each step of optimization. For
+            large models and/or large sets of inputs/targets, this can be prohibitively
+            slow, in which case a subset of the inputs/targets of size
+            :attr:`num_inputs_per_step` can be used.
+        device (str or :class:`torch.device`): Device that model is on. Default is 'cpu'.
+
+    The mixed-precision-optimization algorithm tries to co-minimize the objective
+    function with the model's energy. The overall objective is:
+
+    .. math::
+
+        C = (1-\eta)*\tilde{L}(y, \hat{y}) + \eta * \tilde{E}(model)
+
+    Here, :math:`\tilde{L}(y, \hat{y})` is the function provided as :attr:`objective`, normalized
+    and rescaled so that the most aggressively quantized version of the model gets a
+    value of 0 and the least aggressively quantized version of the model gets a value of
+    1. :math:`\tilde{E}(model)` is a rough energy estimate of the model's energy consumption,
+    rescaled between 0 and 1.
+
+    Mixed-precision-optimization will affect the model in-place, but the model can
+    always be reverted back by calling `modify_precision` or
+    calling mixed-precision-optimization again with different parameters.
+    """
+    if not cmodel.quantized:
+        raise ConversionDependencyError(
+            "Model must be quantized before optimizing mixed-precision config."
+            + " Call `.quantize()` first"
+        )
+    model, energy, loss = auto_multiprecision.optimize_mixed_precision(
+        cmodel,
+        cmodel,
+        objective=objective,
+        eta=eta,
+        inputs=inputs,
+        targets=targets,
+        niter=niter,
+        ramp_eta=True,
+        loss_type=loss_type,
+        device=device,
+        **kwargs
+    )
+    return energy, loss