STT-tensorflow/tensorflow/lite/micro/CONTRIBUTING.md

• Contributing Guidelines
  • General Pull Request Guidelines
  • Guidelines for Specific Contribution Categories
    • Bug Fixes
    • Reference Kernel Implementations
    • Optimized Kernel Implementations
    • New Target / Platform / IDE / Examples
    • New Features
• Development Workflow Notes
  • Before submitting your PR
  • During the PR review
  • Reviewer notes
  • Python notes

Contributing Guidelines

We look forward to your contributions to the TensorFlow Lite Micro codebase and provide guidelines with the goal of enabling community contributions while still maintaining code health, maintainability, and consistency in style.

Please note that while these guidelines may seem onerous to some developers, they are derived from Google's software engineering best practices.

Before we describe project-specific guidelines, we recommend that external contributors read these tips from the Google Testing Blog:

• Code Health: Providing Context with Commit Messages and Bug Reports
• Code Health: Understanding Code In Review
• Code Health: Too Many Comments on Your Code Reviews?
• Code Health: To Comment or Not to Comment?

We also recommend that contributors take a look at the Tensorflow Contributing Guidelines.

General Pull Request Guidelines

We strongly recommend that contributors:

1. Initiate a conversation with the TFLM team via a TF Lite Micro Github issue as early as possible.

   • This enables us to give guidance on how to proceed, prevent duplicated effort and also point to alternatives as well as context if we are not able to accept a particular contribution at a given time.

   • Ideally, you should make an issue before starting to work on a pull request and provide context on both what you want to contribute and why.

2. Once step 1. is complete and it is determined that a PR from an external contributor is the way to go, please follow these guidelines from Google's Engineering Practices documentation:

   • Send Small Pull Requests

     • If a pull request is doing more than one thing, the reviewer will request that it be broken up into two or more PRs.

   • Write Good Pull Request Descriptions

     • We require that all PR descriptions link to the github issue created in step 1.

     • While github offers flexibility in linking commits and issues, we require that the PR description have a separate line with either Fixes #nn (if the PR fixes the issue) or Issue #nn if the PR addresses some aspect of an issue without fixing it.

     • We will be adding internal checks that automate this requirement by matching the PR description to the regexp: (Fixes|Issue) #

3. Unit tests are critical to a healthy codebase. PRs without tests should be the exception rather than the norm. And contributions to improve, simplify, or make the unit tests more exhaustive are welcome! Please refer to this guideline on how test code and writing small PRs should be reconciled.

Guidelines for Specific Contribution Categories

We provide some additional guidelines for different categories of contributions.

Bug Fixes

Pull requests that fix bugs are always welcome and often uncontroversial, unless there is a conflict between different requirements from the platform, or if fixing a bug needs a bigger architectural change.

1. Create a TF Lite Micro Github issue to determine the scope of the bug fix.
2. Send a PR (if that is determined to be the best path forward).
3. Bugfix PRs should be accompanied by a test case that fails prior to the fix and passes with the fix. This validates that the fix works as expected, and helps prevent future regressions.

Reference Kernel Implementations

Pull requests that port reference kernels from TF Lite Mobile to TF Lite Micro are welcome once we have enouch context from the contributor on why the additional kernel is needed.

1. Please create a TF Lite Micro Github issue before starting on any such PRs with as much context as possible, such as:

   • What is the model architecture?
   • What is the application that you are targetting?
   • What embedded target(s) are you planning to run on?
   • Motivate your use-case and the need for adding support for this additional OP.

2. In the interest of having small pull requests, limit each pull request to porting a single kernel (and the corresponding test).

3. TODO(b/165627437): Create and link to a guide to porting reference ops.

Optimized Kernel Implementations

In order to have the TFLM codebase be a central repository of optimized kernel implementations, we would like to make some improvements to the current infrastructure to enable adding and maintaining optimized kernel implementations in a scalable way.

Until that work is complete, we are requesting a pause on contributions that add new optimized kernel implementations. We plan to make these improvements by October 2020 and will provide additional guidelines at that time.

• If you would like to have an exception to this pause, with the understanding that your optimized kernels will break as we improve the underlying framework, then please send an email to the SIG Micro email group to figure out a middle ground.

• Every optimized kernel directory must have a README.md with the github IDs of the maintainers and any other relevant documentation. PRs that add maintainers to the existing optimized kernels are always welcome.

New Target / Platform / IDE / Examples

As discussed in the SIG-micro Aug 12, 2020 meeting, we are currently pausing accepting pull requests that add new targets, platforms, IDE integration or examples while we revisit some of the infrastructure to enable us to make this process easier and more scalable.

In the meantime, snapshotting and/or forking the tensorflow repo could be a viable way to prototype platform support.

Having said that, we still invite TF Lite Micro Github issues on this topic as we would like to enable such integration in the future.

New Features

As discussed in the SIG-micro Aug 12, 2020 meeting, we are currently pausing accepting pull requests that add new features while we revisit some of the infrastructure to enable us to make this process easier and more scalable.

Having said that, we still invite feature requests via TF Lite Micro Github issues to determine if the requested feature aligns with the TFLM roadmap.

Development Workflow Notes

Before submitting your PR

1. Run in-place clang-format on all the files that are modified in your git tree with

   clang-format -i -style=google `git ls-files -m | grep "\.cc"`
   clang-format -i -style=google `git ls-files -m | grep "\.h"`
   

2. Make sure your code is lint-free.

   Get a copy of cpplint

   Run cpplint.py on all modified files in your git tree:

   cpplint.py `git ls-files -m`
   

3. Run all the tests for x86, and any other platform that you are modifying.

   tensorflow/lite/micro/tools/make/tools/ci_build/test_x86.sh
   

   Please check the READMEs in the optimized kernel directories for specific instructions.

4. Sometimes, bugs are caught by the address sanitizer that can go unnoticed via the Makefile. To run a test with the address sanitizer, use the following command (replace micro_interpreter_test with the target that you want to test:

   CC=clang BAZEL_COMPILER=llvm bazel run --copt=-DADDRESS_SANITIZER \
   --copt=-fsanitize=address --linkopt=-fsanitize=address \
   tensorflow/lite/micro:micro_interpreter_test
   

During the PR review

1. Do not change the git version history.

   • Always merge upstream/master (do not rebase) and no force-pushes please.

   • Having an extra merge commit it ok as the github review tool handles that gracefully.

   Assuming that you forked tensorflow and added a remote called upstream with:

   git remote add upstream https://github.com/tensorflow/tensorflow.git

   Fetch the latest changes from upstream and merge into your local branch.

   git fetch upstream
   git merge upstream/master
   

   In case of a merge conflict, resolve via:

   git mergetool
   
   # Use your favorite diff tools (e.g. meld) to resolve the conflicts.
   
   git add <files that were manually resolved>
   
   git commit
   

2. If a force push seems to be the only path forward, please stop and let your PR reviewer know before force pushing. We will attempt to do the merge for you. This will also help us better understand in what conditions a force-push may be unavoidable.

Reviewer notes

• GIthub CLI can be useful to quickly checkout a PR to test locally.

  gh pr checkout <PR number>

• Google engineers on the Tensorflow team will have the permissions to push edits to most PRs. This can be useful to make some small fixes as a result of errors due to internal checks that are not easily reproducible via github.

  One example of this is this comment.

  And a sketch of the steps:

  git remote add <remote_name> git@github.com:<PR author>/tensorflow.git
  git fetch <remote_name>
  
  git checkout -b <local-branch-name> <remote_name>/<PR branch name>
  
  # make changes and commit to local branch
  
  # push changes to remove branch
  
  git push <remote_name> <PR branch name>
  
  # remove the temp remote to clean up your git environment.
  
  git remote rm <remote_name>
  

Python notes

Most PRs for TensorFlow Lite Micro will be C++ only. Adding some notes on Python that can be expanded and improved as necessary.

• TensorFlow guide for Python development

• yapf should be used for formatting.

  yapf log_parser.py -i --style='{based_on_style: pep8, indent_width: 2}'