Add a fluent builder API for creating compression specifications
without writing YAML strings. This is useful in scripts and
Jupyter notebooks.
Example usage:
spec = (compression.SpecBuilder()
.add_tensor(subgraph=0, tensor=2)
.with_lut(index_bitwidth=4)
.build())
BUG=#3125
Co-authored-by: suleshahid <110432064+suleshahid@users.noreply.github.com>
* Sync files related to Reverse_V2 from TFLite
#3110
* Added Reverse_V2 changes
BUG=fixes #3110
* Using stable_sort instead of sort & format fixes
* Replace std::stable_sort with qsort
* fix format issues
* fix format issues
* fix format issues
* Updated the changes as per the review
---------
Co-authored-by: suleshahid <110432064+suleshahid@users.noreply.github.com>
feat(python): add compression module to tflite_micro Python package
Integrate the TFLM compression tools into the tflite_micro Python
package, allowing users to compress models directly from Python code
that imports the package.
Usage:
from tflite_micro import compression
Details:
- Add compress_lib py_library target in compression BUILD
- Create compression package with __init__.py exposing public API
- Include compression module in Python package dependencies
- Add compression dependencies to wheel requirements
BUG=see description
Remove the test that incorrectly asserts the output tensor is
initially all zeros. The tensor is allocated from a shared memory
arena, and its initial state is not guaranteed to be zero. This
test eventually failed due to variations in memory allocation
during build and runtime; see the failed checks in #2945.
BUG=#2636
Remove the check for sparse tensors in the Python interpreter wrapper.
This fixes a broken build when TF_LITE_STATIC_MEMORY is set, which
should always be the case in TFLM. TfLiteTensor objects don't have a
.sparsity member when TF_LITE_STATIC_MEMORY is set, so this check
can't be made.
This prepares for an upcoming commit setting TF_LITE_STATIC_MEMORY
during Bazel builds. This hasn't caused build failures in Make builds,
which have always set TF_LITE_STATIC_MEMORY, because Make builds don't
build the Python interpreter wrapper.
BUG=#2636
Mark whl_test as size "large", so that it, and other tests of a
similar size, can be excluded with the --test_size_filters
option.
For even more convenience, provide a hook for developers to add
local .bazlerc-style defaults and configurations in
$root/bazelrc.local and ../$root/bazelrc.local.
This gives a convenient means of explicitly excluding whl_test
during local, incremental development runs of `bazel test ...`,
while not surprising users who don't opt in, and without
affecting CI.
whl_test's cached result is invalidated, and the test rerun,
following most git activity, because the git hash appears in the
Python package's version number. This combined with its long
runtime and network dependency makes it a nuisance when running
`bazel test ...` incrementally during development. Of course,
this test be run when developing changes that affect the package,
before pushing commits to main, and in CI.
BUG=see description
* ci(bazel): simplify scripts and configuration in advance of additions
Simplify the Bazel-related CI scripts and BUILD configuration in
preparation for adding several more for the compression feature.
- Move CC=clang to .bazelrc
- Define CXX in case it's already defined in the environment, in
which case it overrides deferring to CC
- Replace --repo_env, which doesn't affect build, with --action_env
- Move commented-out ubsan invocation to its own CI job. Since
ubsan was commented out, Bazel invocations have moved to their
own jobs so they can run in parallel.
- Consistently test all targets, `...`, since TFLM is no longer
confined to the tensorflow/lite/micro directory. Filter out
inappropriate new targets with no.san tags.
- Don't run `bazel build ...` before `bazel test ...`; the latter
already builds all non-test targets.
- Remove obsolete filter for `no_oss`, there were no more
`no_oss` tags in the tree.
- Stop using readable_run: it has diverged from its original
meaning and now only redirects stderr to stdout. This is not
needed.
BUG=see description
* refactor: clarify intention to run at top and test entire project
Clarify that the scripts run from the root directory of the
project by restoring the change of directory at the top of the
script, even though CI runs from the root directory of the
project.
Also clarify the intention that all tests in the project be run
by specifying `//...`, rather than `...`, which means all targets
at or below the working directory.
Remove micro_copts() by replacing every cc_* target that used
them with a tflm_cc_* equivalent, and setting those common copts
in one place, inside the tflm_cc_* macro.
This is the first of several commits introducing tflm_cc_* macros
in place of cc_binary, cc_library, and cc_test. Motivated by the
upcoming need to support conditional compilation, the objective
is to centralize build configuration rather than requiring (and
remembering that) each cc_* target in the project add the same
common attributes such as compiler options and select()ed
Alternatives such as setting global options on the command line
or in .bazelrc, even if simplified with a --config option, fail
to preserve flags and hooks for configuration in the case TFLM is
used as an external repository by an application project. Nor is
it easy in that case for individual targets to override an
otherwise global setting.
BUG=#2636
Numpy 2.0 will explicitly downcast now, which casues us to see a regerssion in the conversion for the audio model.
BUG=[361070678](https://b.corp.google.com/issues/361070678)
### Problem description:
In the original code, pointer arithmetic of gain_lut and the assignment of gain_lut[4 * interval + 3] could potentially lead to out-of-bounds array access.
On certain architectures (e.g., macOS ARM64), this out-of-bounds access causes the program to crash.
BUG=None, reported issue#2464
### Solution:
Increase the size of the gain_lut_storage array by 1 to provide an extra buffer and prevent overflow during the calculation within the loop.
### Risks and considerations:
Increasing the array size will slightly increase memory usage.
In extremely resource-constrained systems, alternative algorithm implementations may need to be considered.
The tensorflow-cpu package does not support MacOS or non-x86 hardware. Replacing the tensorflow-cpu python package requirement with the tensorflow meta package should enable the bazel build and the dependent python scripts to be used on those platforms.
BUG=#2367, #1781
The PythonOpsResolver and the utility TflmOpResolver are intended to support all built-in ops allow for models to be tested without code changes. This PR syncs those op resolvers with all available ops from the MicroMutableOpResolver, notably adding BatchMatMul and the Signal ops.
Additionaly, this PR sorts the list alphabetically for readability and adds an alias for the utility TflmOpResolver since it is used in both the benchmarking tool and the layer by layer debugging tool.
BUG=cleanup
The py_tflm_signal_library macro generates multiple targets, some of which are referenced by an internal subdirectory target. This PR adds a default visibility for the package for all targets to be visibile within the subpackage.
BUG=b/316963245
The targets for building the ops should depend on
"//third_party/tflite_micro/python/tflite_micro/signal/utils:util Instead of just their unit tests.
BUG=315941833
Pass a few environmental variables into the bazel build and test of the
tflite_micro package whl during the containerized build for PyPI. By default,
bazel cleans the environment.
Recent changes (presumably) to the package wrapt, installed as a dependency of
the package tensorflow, cause the containerized build of the package
tflite_micro for PyPI targeting Python 3.11 to fail. During wrapt's
installation, setuptools calls pathlib to determine the user's home directory.
pathlib tries HOME in the environment, but falls back on reading the Unix
password database for itself if necessary. This fallback is why
non-containerized environments don't exhibit the failure despite bazel cleaning
HOME from the environment. In the PyPI build container, however, the password
database doesn't contain the invoking user, and pathlib's fallback fails.
To fix, set HOME and pass it through to the action environment of the bazel
build and test. Also pass through a couple of other variables which were also
intended to affect the build and test (in minor ways, such as cache location
and cleaning up a warning).
BUG=fixes #2257
Add mechanism and scripts for building and uploading the Python distribution
package `tflite_micro` to PyPI. These scripts are intended mainly for use by CI
when generating packages for distribution via for PyPI, and won't be used by
most developers. Building a package for local use is still done via a normal
Bazel build.
Heavily comment the scripts with rationale and technical details of the
implementation.
Make significant updates to python/tflite_micro/README.md which explain
building, installing, and uploading the package to PyPI. Leave some cleanup of
the existing text for later.
Add a build setting `--//python/tflite_micro:compatibility_tag` for setting
:whl's platform compatibility tag. Unfortunately, it cannot derived
automatically from the execution environment by the current implementation of
@rules_python.
BUG=part of #1484
`Implementation preserve_all_tensors and getTensor features in TFLM interpreter`
[Design Doc](https://docs.google.com/document/d/13CB93tffg_dDnZYy1QkY3u88yJev4PtZeRY0MLH6n_w/edit?resourcekey=0-htWqjXWneKLXcD6o2SVNJw#heading=h.x9snb54sjlu9)
* PreserveAllTensors is a flag / option being added to the TFLM interpreter that guarantees that post invocation all tensors will be available post invocation with there data untouched.
* GetTensor() is an api being added to the interpreter that allows users to access any tensor in a model by providing the right index but this api is only available when the PreserveAllTensors flag is being used (all the data is guaranteed to be valid and untouched)
*additionally this cl adds functionality for users to instantiate MicroAllocators with LinearMemoryPlanners vs the the default GreedyMemoryPlanner for MicroAllocator create methods that don't currently take a MemoryPlanner as an input
[google3 cl](https://critique.corp.google.com/cl/543518092)
BUG=[b/288141725](https://b.corp.google.com/288141725)
`port c++ PCAN op to open source in tflm_signal`
-port PCAN op and corresponding to new open source location for C++
BUG=[b/294387385](https://b.corp.google.com/issues/294387385)
Add a Bazel target `//python/tflite_micro:whl.publish` that publishes the
Python distribution package to PyPI. Require an authorization token in
the environment. See code comments for usage.
BUG=part of #1484
Use Bazel's workspace status mechanism, designed for "stamping" builds with
identifying information from the build environment, to dynamically generate the
version label of the Python distribution package. Generate stamps when Bazel
runs via the --workspace_status_command option and command script. Then use
these stamps in the version label.
Guidelines for Python version labels are given in [PEP 440][]. TFLM does not
currently tag and publish what PEP 440 calls "final releases". Instead,
distribution packages will periodically be published from the tip of the main
branch, and users will be expected to use the latest version or pin to a
historical version of their choice. To facilitate such use, the build system
needs to generate a unique, ascending version label for each commit on the main
branch.
Guided by [PEP 440][], use developmental version labels of the form
*major[.minor].dev<time>*, for example:
0.dev20090103181505
Use a release segment with a major number of 0 (via the standard Bazel
BUILD_EMBED_LABEL stamp), because TFLM does not currently tag and publish
releases. This leaves room in the version space for making semver-style final
releases in the future. Add a developmental release segment with a date and
time stamp.
Packages should be traceable to the exact source from which they were built.
[PEP 440][] does not allow Git hashes in version labels published to PyPI;
however, the Git hash can be embedded in the package's runtime-visible
attribute `tflite_micro.__version__`, and in the package's description, which
is displayed on PyPI.
[PEP 440]: https://peps.python.org/pep-0440
BUG=part of #1484
Add the build configuration and integrated test to generate a Python
distribution package named `tflite_micro` for publishing the tflm interpreter
as a Python module with a native extension.
Use the build tools provided in @rules_python, augmented by a custom rule
`py_namespace` for the reasons documented in `python/py_namespace.bzl`.
Provide an integration test at `//python/tflite_micro:whl_test`. Use a .tflite
model copied from the hello_world example. (Copied to avoid creating a
dependency.)
BUG=part of #1484
Functionality to use the rest of the Signal Library OPs directly from python.
Test with `bazel run python/tflite_micro/signal:stacker_op_test` and `bazel run python/tflite_micro/signal:filter_bank_ops_test`
BUG=[287346710](http://b/287346710)
We this PR, you can use these ops directly from python, including in TF graphs.
Test with `bazel run python/tflite_micro/signal:framer_op_test`, etc.
BUG=[287346710](http://b/287346710)
Extends the Signal Library Delay OP to be usable from python.
Can test via `bazel run python/tflite_micro/signal:delay_op_test`
BUG=[287346710](http://b/287346710)
This PR adds additional FFT op functionality in the Signal library, namely adding the FFT Auto Scale operation.
Testing added in the original `fft_test.cc` and `fft_ops_test.py`.
BUG=[287346710](http://b/287346710)
`port c++ energy op to open source in tflm_signal`
-port energy op and corresponding to new open source location for C++
BUG=[b/289422411](https://b.corp.google.com/issues/289422411)
`port c++ stacker op to open source in tflm_signal`
-port stacker op and corresponding to new open source location for C++
BUG=[b/289298641](https://b.corp.google.com/issues/289298641)
`port c++ delay op to open source in tflm_signal`
-port delay op and corresponding to new open source location for C++
BUG=[b/289296081](https://b.corp.google.com/issues/289296081)
`port c++ Overlapp_Add op to open source in tflm_signal`
-port Overlapp_Add op and corresponding to new open source location for C++
BUG=[b/289291202](https://b.corp.google.com/issues/289291202)
`port c++ framer op to open source in tflm_signal`
-port framer op and corresponding to new open source location for C++
BUG=[b/288965505](https://b.corp.google.com/288965505)
This is needed to properly build all the ops together. Since we are calling into a singular utils function to load the ops, if it checks for any other ops, it would break before this.
Now we make it build all ops everytime utils.py is built.
BUG=[288938993](http://b/288938993)
Second OP for the TFLM Signal library, Real-Valued Fast Fourier Transform.
The RFFT OP provides three resolutions: `FLOAT, INT16, INT32`
Similar usage as to previous Window OP:
* `op_resolver.AddRfft()` (which will add all resolutions, and determine the type at runtime)
* `op_resolver.AddRfftFloat()`, `op_resolver.AddRfftInt16()`, `op_resolver.AddRfftInt32()` for a specific resolution type.
* or via python as can be seen in `fft_ops_test.py`
3 testing options are provided:
* Micro(C++): bazel run signal/micro/kernels:fft_test
* Tensorflow/Micro(Python): bazel run python/tflite_micro/signal:fft_ops_test
* Makefile(C++): make -f tensorflow/lite/micro/tools/make/Makefile test_kernel_fft_test
BUG=[287346710](http://b/287346710)
To package the module `runtime` as `tflite_micro.runtime`, put `runtime` under
a directory representing the Python namespace package `tflite_micro`. For
organization's sake, move it all to the top-level directory `python/`. Adjust
tests and docs to match.
Some code outside of the Python extension module has come to depend on
`python/tflite_micro:python_ops_resolver` as a replacement for
`all_ops_resolver` (e.g.:`t/l/m/integration_tests/seanet/add/integration_tests.cc`).
`python_ops_resolver` is intended to be a private implementation detail of the
Python extension module. For now, grandfather in the dependent code by updating
its references to the resolver's location; however, soon the dependent code
should be migrated away to a different resolver. (#2033,
https://issuetracker.google.com/286508251)
BUG=part of #1484
We have some name clash issues with the current Window OP name.
We will be changing it from "Window"->"SignalWindow" until the names clashes are resolved and revert back afterwards.
This is an internal implementation detail, so user level API has no change from current usage, i.e. still use (op_resolver.AddWindow() and window_op.window)
BUG=[286250473](http://b/286250473)
