diff --git a/.github/linters/.python-lint b/.github/linters/.python-lint index dfd5982f9..2c02be588 100644 --- a/.github/linters/.python-lint +++ b/.github/linters/.python-lint @@ -7,9 +7,9 @@ ignored-classes = ModelProto max-line-length = 99 [DESIGN] max-locals=100 -max-statements=300 +max-statements=350 min-public-methods=1 -max-branches=100 +max-branches=120 max-module-lines=5000 max-args=20 max-returns=10 diff --git a/.github/workflows/linter.yml b/.github/workflows/linter.yml index c775a91b8..54ecfb116 100644 --- a/.github/workflows/linter.yml +++ b/.github/workflows/linter.yml @@ -3,9 +3,9 @@ name: Lint code on: push: - branches-ignore: [master] + branches-ignore: [main, master] pull_request: - branches-ignore: [master] + branches-ignore: [main, master] jobs: build: @@ -19,6 +19,18 @@ jobs: fetch-depth: 0 submodules: true + - name: Check source code files for Unicode and CRLF + run: | + set -e + find . -name 'distiller' -prune -o -type f -size +0c -regex '.*\.\(py\|yaml\|yml\|txt\|h\|c\|sh\)' -print0 | xargs -0 file | grep -P '^(?!.*ASCII)|CRLF' || exit 0 + exit 1 + + - name: Check shell scripts for x-bit + run: | + set -e + find . -name 'distiller' -prune -o -type f -name \*.sh \! -perm -1 -print0 | xargs -0 grep . || exit 0 + exit 1 + - name: Lint code uses: super-linter/super-linter/slim@v5 env: diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index e1201c36c..9e6f0ae13 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -1,140 +1,36 @@ --- -name: auto-testing +name: Trigger External Workflow + on: - pull_request: - branches: - - develop + pull_request_target: + types: [opened, edited, synchronize] jobs: - eval: - runs-on: self-hosted - timeout-minutes: 345600 + trigger_dispatch: + runs-on: ubuntu-latest steps: - - name: Checkout code - uses: actions/checkout@v2 - - name: Checkout PR - run: | - fork_repo=$(jq -r .pull_request.head.repo.clone_url $GITHUB_EVENT_PATH) - git clone $fork_repo --recursive - - name: Checkout synthesis - uses: actions/checkout@v2 - with: - repository: MaximIntegratedAI/ai8x-synthesis - ref: develop - path: ai8x-synthesis - - name: Setup Pyenv and Install Dependencies - uses: gabrielfalcao/pyenv-action@v13 - with: - default: 3.8.11 - - name: Create Venv - run: | - pyenv local 3.8.11 - python -m venv venv --prompt ai8x-training - - name: Activate Venv - run: source venv/bin/activate - - name: Install Dependencies - run: | - pip3 install -U pip wheel setuptools - pip3 install -r requirements-cu11.txt - - name: Create Evaluation Scripts - run: python ./regression/create_eval_script.py --testconf ./regression/test_config.yaml --testpaths ./regression/paths.yaml - - name: Run Evaluation Scripts - run: bash ./scripts/evaluation_file.sh - - name: Save Evaluation Log Files - run: cp -r /home/test/actions-runner/_work/ai8x-training/ai8x-training/logs/ /home/test/max7800x/evaluation_logs/ - - name: Evaluation Results - run: python ./regression/eval_pass_fail.py --testpaths ./regression/paths.yaml - - build: - runs-on: self-hosted - needs: [eval] - timeout-minutes: 345600 - steps: - - name: Checkout last-dev - uses: actions/checkout@v2 - with: - repository: MaximIntegratedAI/ai8x-training - ref: develop - submodules: recursive - - name: Setup Pyenv and Install Dependencies - uses: gabrielfalcao/pyenv-action@v13 - with: - default: 3.8.11 - - name: Create Venv - run: | - pyenv local 3.8.11 - python -m venv venv --prompt ai8x-training - - name: Activate Venv - run: source venv/bin/activate - - name: Install Dependencies + - name: Check repository run: | - pip3 install -U pip wheel setuptools - pip3 install -r requirements-cu11.txt - - name: Last Develop Check - run: python ./regression/last_dev.py --testconf ./regression/test_config.yaml --testpaths ./regression/paths.yaml + echo "IS_SPECIFIC_REPOSITORY=${{ github.repository == 'analogdevicesinc/ai8x-training' }}" >> $GITHUB_ENV + echo "IS_DEVELOP_BRANCH=${{ github.ref == 'refs/heads/develop' }}" >> $GITHUB_ENV - new-code: - runs-on: self-hosted - needs: [build] - timeout-minutes: 345600 - steps: - - name: Checkout code - uses: actions/checkout@v2 - - name: Checkout PR - run: | - fork_repo=$(jq -r .pull_request.head.repo.clone_url $GITHUB_EVENT_PATH) - git clone $fork_repo --recursive - - name: Setup Pyenv and Install Dependencies - uses: gabrielfalcao/pyenv-action@v13 - with: - default: 3.8.11 - - name: Create Venv - run: | - pyenv local 3.8.11 - python -m venv venv --prompt ai8x-training - - name: Activate Venv - run: source venv/bin/activate - - name: Install Dependencies - run: | - pip3 install -U pip wheel setuptools - pip3 install -r requirements-cu11.txt - - name: Create Test Script - run: python ./regression/create_test_script.py --testconf ./regression/test_config.yaml --testpaths ./regression/paths.yaml - - name: Run Training Scripts - run: bash /home/test/actions-runner/_work/ai8x-training/ai8x-training/scripts/output_file.sh - - name: Save Log Files - run: cp -r /home/test/actions-runner/_work/ai8x-training/ai8x-training/logs/ /home/test/max7800x/test_logs/$(date +%Y-%m-%d_%H-%M-%S) - - name: Save Test Scripts - run: cp -r /home/test/actions-runner/_work/ai8x-training/ai8x-training/scripts/output_file.sh /home/test/max7800x/test_scripts/ - - name: Create and run ONNX script - run: python ./regression/create_onnx_script.py --testconf ./regression/test_config.yaml --testpaths ./regression/paths.yaml + - name: Set up environment + if: env.IS_SPECIFIC_REPOSITORY == 'true' && env.IS_DEVELOP_BRANCH == 'true' + run: | + PR_Branch=${{ github.event.pull_request.head.ref }} + Repository=${{ github.event.pull_request.head.repo.full_name }} + PR_Number=${{ github.event.pull_request.number }} + PR_Sha=${{ github.event.pull_request.head.sha }} + echo "PR_Branch: $PR_Branch" + echo "Repository: $Repository" + echo "PR_Number: $PR_Number" + echo "PR_Sha: $PR_Sha" - test-results: - runs-on: self-hosted - needs: [new-code] - timeout-minutes: 345600 - steps: - - uses: actions/checkout@v2 - name: Checkout Test Code - with: - repository: MaximIntegratedAI/ai8x-training - ref: develop - submodules: recursive - - name: Setup Pyenv and Install Dependencies - uses: gabrielfalcao/pyenv-action@v13 - with: - default: 3.8.11 - - name: Create Venv - run: | - pyenv local 3.8.11 - python -m venv venv --prompt ai8x-training - - name: Activate Venv - run: source venv/bin/activate - - name: Install Dependencies - run: | - pip3 install -U pip wheel setuptools - pip3 install -r requirements-cu11.txt - - name: Log Diff - run: python ./regression/log_comparison.py --testconf ./regression/test_config.yaml --testpaths ./regression/paths.yaml - - name: Test Results - run: python ./regression/pass_fail.py --testconf ./regression/test_config.yaml --testpaths ./regression/paths.yaml + - name: Dispatch event + if: env.IS_SPECIFIC_REPOSITORY == 'true' && env.IS_DEVELOP_BRANCH == 'true' + run: | + curl -X POST \ + -H "Authorization: Bearer ${{ secrets.REGRESSION_TEST }}" \ + -H "Accept: application/vnd.github.v3+json" \ + "https://api.github.com/repos/MaximIntegratedAI/ai8x-regression/dispatches" \ + -d '{"event_type": "repo-pull-request", "client_payload": {"PR_Branch": "${{ github.event.pull_request.head.ref }}", "Repository": "${{ github.event.pull_request.head.repo.full_name }}","PR_Number": "${{ github.event.pull_request.number }}","PR_Sha": "${{ github.event.pull_request.head.sha }}" }' diff --git a/.gitignore b/.gitignore index c3e722ab8..061b59e12 100644 --- a/.gitignore +++ b/.gitignore @@ -2,14 +2,16 @@ *.mem *.prof /.mypy_cache/ +/.venv/ /.vscode/ **/build/ -/data/ +/data /latest_log_dir /latest_log_file /logs/ /ninja-python-distributions /pip-selfcheck.json +/pretrained/ /sensitivity.csv /sensitivity.png /tensorflow/ diff --git a/.gitmodules b/.gitmodules index d37537691..ecdf70507 100644 --- a/.gitmodules +++ b/.gitmodules @@ -2,6 +2,3 @@ path = distiller url = https://github.com/MaximIntegratedAI/distiller.git branch = pytorch-1.8 -[submodule "datasets/face_id/facenet_pytorch"] - path = datasets/face_id/facenet_pytorch - url = https://github.com/MaximIntegratedAI/facenet-pytorch.git diff --git a/.pylintrc b/.pylintrc index 7f3d5a3e7..26cbe5d6a 100644 --- a/.pylintrc +++ b/.pylintrc @@ -7,9 +7,9 @@ ignored-classes = ModelProto max-line-length = 99 [DESIGN] max-locals=100 -max-statements=300 +max-statements=350 min-public-methods=1 -max-branches=100 +max-branches=120 max-module-lines=5000 max-args=20 max-returns=10 diff --git a/.yamllint b/.yamllint index f893d85a1..3d75f8a4b 100644 --- a/.yamllint +++ b/.yamllint @@ -2,3 +2,6 @@ extends: default rules: line-length: {max: 1024} + new-lines: + type: platform + new-line-at-end-of-file: enable diff --git a/LICENSE.md b/LICENSE.md deleted file mode 100644 index e205efc25..000000000 --- a/LICENSE.md +++ /dev/null @@ -1,33 +0,0 @@ -# LICENSE - -Copyright (C) 2019-2023 Maxim Integrated Products, Inc., All rights Reserved. - -This software is protected by copyright laws of the United States and -of foreign countries. This material may also be protected by patent laws -and technology transfer regulations of the United States and of foreign -countries. This software is furnished under a license agreement and/or a -nondisclosure agreement and may only be used or reproduced in accordance -with the terms of those agreements. Dissemination of this information to -any party or parties not specified in the license agreement and/or -nondisclosure agreement is expressly prohibited. - -The above copyright notice and this permission notice shall be included -in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS -OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES -OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, -ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR -OTHER DEALINGS IN THE SOFTWARE. - -Except as contained in this notice, the name of Maxim Integrated -Products, Inc. shall not be used except as stated in the Maxim Integrated -Products, Inc. Branding Policy. - -The mere transfer of this software does not imply any licenses -of trade secrets, proprietary technology, copyrights, patents, -trademarks, maskwork rights, or any other form of intellectual -property whatsoever. Maxim Integrated Products, Inc. retains all -ownership rights. diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 000000000..261eeb9e9 --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/NOTICE.txt b/NOTICE.txt new file mode 100644 index 000000000..ede70ef8e --- /dev/null +++ b/NOTICE.txt @@ -0,0 +1,227 @@ +Copyright 2024 + +[OSPO_MAX78000_78002_Neural_Net_ML_ai8x-training : 2024.02.13] + +Phase: PRERELEASE +Distribution: OPENSOURCE + +Components: + +ppgan 2.0.0b0 : Apache License 2.0 +sgrvinod/a-PyTorch-Tutorial-to-Object-Detection 20200808-snapshot-43fd8be9 : MIT License +Licenses: + +Apache License 2.0 +(ppgan 2.0.0b0) + +Apache License +Version 2.0, January 2004 +========================= + + +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, and +distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by the copyright +owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all other entities +that control, are controlled by, or are under common control with that entity. +For the purposes of this definition, "control" means (i) the power, direct or +indirect, to cause the direction or management of such entity, whether by +contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the +outstanding shares, or (iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity exercising permissions +granted by this License. + +"Source" form shall mean the preferred form for making modifications, including +but not limited to software source code, documentation source, and configuration +files. + +"Object" form shall mean any form resulting from mechanical transformation or +translation of a Source form, including but not limited to compiled object code, +generated documentation, and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or Object form, made +available under the License, as indicated by a copyright notice that is included +in or attached to the work (an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object form, that is +based on (or derived from) the Work and for which the editorial revisions, +annotations, elaborations, or other modifications represent, as a whole, an +original work of authorship. For the purposes of this License, Derivative Works +shall not include works that remain separable from, or merely link (or bind by +name) to the interfaces of, the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including the original version +of the Work and any modifications or additions to that Work or Derivative Works +thereof, that is intentionally submitted to Licensor for inclusion in the Work by +the copyright owner or by an individual or Legal Entity authorized to submit on +behalf of the copyright owner. For the purposes of this definition, "submitted" +means any form of electronic, verbal, or written communication sent to the +Licensor or its representatives, including but not limited to communication on +electronic mailing lists, source code control systems, and issue tracking systems +that are managed by, or on behalf of, the Licensor for the purpose of discussing +and improving the Work, but excluding communication that is conspicuously marked +or otherwise designated in writing by the copyright owner as "Not a +Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of +whom a Contribution has been received by Licensor and subsequently incorporated +within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of this +License, each Contributor hereby grants to You a perpetual, worldwide, +non-exclusive, no-charge, royalty-free, irrevocable copyright license to +reproduce, prepare Derivative Works of, publicly display, publicly perform, +sublicense, and distribute the Work and such Derivative Works in Source or Object +form. + +3. Grant of Patent License. Subject to the terms and conditions of this License, +each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, +no-charge, royalty-free, irrevocable (except as stated in this section) patent +license to make, have made, use, offer to sell, sell, import, and otherwise +transfer the Work, where such license applies only to those patent claims +licensable by such Contributor that are necessarily infringed by their +Contribution(s) alone or by combination of their Contribution(s) with the Work to +which such Contribution(s) was submitted. If You institute patent litigation +against any entity (including a cross-claim or counterclaim in a lawsuit) +alleging that the Work or a Contribution incorporated within the Work constitutes +direct or contributory patent infringement, then any patent licenses granted to +You under this License for that Work shall terminate as of the date such +litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the Work or +Derivative Works thereof in any medium, with or without modifications, and in +Source or Object form, provided that You meet the following conditions: + + a. You must give any other recipients of the Work or Derivative Works a copy of + this License; and + + b. You must cause any modified files to carry prominent notices stating that + You changed the files; and + + c. You must retain, in the Source form of any Derivative Works that You + distribute, all copyright, patent, trademark, and attribution notices from + the Source form of the Work, excluding those notices that do not pertain to + any part of the Derivative Works; and + + d. If the Work includes a "NOTICE" text file as part of its distribution, then + any Derivative Works that You distribute must include a readable copy of the + attribution notices contained within such NOTICE file, excluding those + notices that do not pertain to any part of the Derivative Works, in at least + one of the following places: within a NOTICE text file distributed as part of + the Derivative Works; within the Source form or documentation, if provided + along with the Derivative Works; or, within a display generated by the + Derivative Works, if and wherever such third-party notices normally appear. + The contents of the NOTICE file are for informational purposes only and do + not modify the License. You may add Your own attribution notices within + Derivative Works that You distribute, alongside or as an addendum to the + NOTICE text from the Work, provided that such additional attribution notices + cannot be construed as modifying the License. + +You may add Your own copyright statement to Your modifications and may provide +additional or different license terms and conditions for use, reproduction, or +distribution of Your modifications, or for any such Derivative Works as a whole, +provided Your use, reproduction, and distribution of the Work otherwise complies +with the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, any +Contribution intentionally submitted for inclusion in the Work by You to the +Licensor shall be under the terms and conditions of this License, without any +additional terms or conditions. Notwithstanding the above, nothing herein shall +supersede or modify the terms of any separate license agreement you may have +executed with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade names, +trademarks, service marks, or product names of the Licensor, except as required +for reasonable and customary use in describing the origin of the Work and +reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or agreed to in +writing, Licensor provides the Work (and each Contributor provides its +Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, +either express or implied, including, without limitation, any warranties or +conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A +PARTICULAR PURPOSE. You are solely responsible for determining the +appropriateness of using or redistributing the Work and assume any risks +associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, whether in +tort (including negligence), contract, or otherwise, unless required by +applicable law (such as deliberate and grossly negligent acts) or agreed to in +writing, shall any Contributor be liable to You for damages, including any +direct, indirect, special, incidental, or consequential damages of any character +arising as a result of this License or out of the use or inability to use the +Work (including but not limited to damages for loss of goodwill, work stoppage, +computer failure or malfunction, or any and all other commercial damages or +losses), even if such Contributor has been advised of the possibility of such +damages. + +9. Accepting Warranty or Additional Liability. While redistributing the Work or +Derivative Works thereof, You may choose to offer, and charge a fee for, +acceptance of support, warranty, indemnity, or other liability obligations and/or +rights consistent with this License. However, in accepting such obligations, You +may act only on Your own behalf and on Your sole responsibility, not on behalf of +any other Contributor, and only if You agree to indemnify, defend, and hold each +Contributor harmless for any liability incurred by, or claims asserted against, +such Contributor by reason of your accepting any such warranty or additional +liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work + +To apply the Apache License to your work, attach the following boilerplate +notice, with the fields enclosed by brackets "[]" replaced with your own +identifying information. (Don't include the brackets!) The text should be +enclosed in the appropriate comment syntax for the file format. We also recommend +that a file or class name and description of purpose be included on the same +"printed page" as the copyright notice for easier identification within +third-party archives. + + Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, + Version 2.0 (the "License"); you may not use this file except in compliance + with the License. You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law + or agreed to in writing, software distributed under the License is + distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + KIND, either express or implied. See the License for the specific language + governing permissions and limitations under the License. + +--- + +MIT License +(sgrvinod/a-PyTorch-Tutorial-to-Object-Detection 20200808-snapshot-43fd8be9) + +The MIT License +=============== + +Copyright (c) 2019 Sagar Vinodababu + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in the +Software without restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the +Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +--- + diff --git a/README.md b/README.md index dbdf3c2eb..504b4cf5e 100644 --- a/README.md +++ b/README.md @@ -1,19 +1,19 @@ # ADI MAX78000/MAX78002 Model Training and Synthesis -October 23, 2023 +April 19, 2024 ADI’s MAX78000/MAX78002 project is comprised of five repositories: 1. **Start here**: - **[Top Level Documentation](https://github.com/MaximIntegratedAI/MaximAI_Documentation)** + **[Top Level Documentation](https://github.com/analogdevicesinc/MaximAI_Documentation)** 2. The software development kit (MSDK), which contains drivers and example programs ready to run on the evaluation kits (EVkit and Feather): - [Analog Devices MSDK](https://github.com/Analog-Devices-MSDK/msdk) + [Analog Devices MSDK](https://github.com/analogdevicesinc/msdk) 3. The training repository, which is used for deep learning *model development and training*: - [ai8x-training](https://github.com/MaximIntegratedAI/ai8x-training) **(described in this document)** + [ai8x-training](https://github.com/analogdevicesinc/ai8x-training) **(described in this document)** 4. The synthesis repository, which is used to *convert a trained model into C code* using the “izer” tool: - [ai8x-synthesis](https://github.com/MaximIntegratedAI/ai8x-synthesis) **(described in this document)** + [ai8x-synthesis](https://github.com/analogdevicesinc/ai8x-synthesis) **(described in this document)** 5. The reference design repository, which contains host applications and sample applications for reference designs such as [MAXREFDES178 (Cube Camera)](https://www.analog.com/en/design-center/reference-designs/maxrefdes178.html): - [refdes](https://github.com/MaximIntegratedAI/refdes) + [refdes](https://github.com/analogdevicesinc/MAX78xxx-RefDes) *Note: Examples for EVkits and Feather boards are part of the MSDK* _Open the `.md` version of this file in a markdown enabled viewer, for example Typora (). @@ -73,15 +73,15 @@ Limited support and advice for using other hardware and software combinations is **The only officially supported platforms for model training** are Ubuntu Linux 20.04 LTS and 22.04 LTS on amd64/x86_64, either the desktop or the [server version](https://ubuntu.com/download/server). -*Note that hardware acceleration using CUDA is not available in PyTorch for Raspberry Pi 4 and other aarch64/arm64 devices, even those running Ubuntu Linux 20.04/22.04. See also [Development on Raspberry Pi 4 and 400](https://github.com/MaximIntegratedAI/ai8x-synthesis/blob/develop/docs/RaspberryPi.md) (unsupported).* +*Note that hardware acceleration using CUDA is not available in PyTorch for Raspberry Pi 4 and other aarch64/arm64 devices, even those running Ubuntu Linux 20.04/22.04. See also [Development on Raspberry Pi 4 and 400](https://github.com/analogdevicesinc/ai8x-synthesis/blob/develop/docs/RaspberryPi.md) (unsupported).* This document also provides instructions for installing on RedHat Enterprise Linux / CentOS 8 with limited support. ##### Windows -On Windows 10 version 21H2 or newer, and Windows 11, after installing the Windows Subsystem for Linux (WSL2), Ubuntu Linux 20.04 or 22.04 can be used inside Windows with full CUDA acceleration, please see *[Windows Subsystem for Linux](https://github.com/MaximIntegratedAI/ai8x-synthesis/blob/develop/docs/WSL2.md).* For the remainder of this document, follow the steps for Ubuntu Linux. +On Windows 10 version 21H2 or newer, and Windows 11, after installing the Windows Subsystem for Linux (WSL2), Ubuntu Linux 20.04 or 22.04 can be used inside Windows with full CUDA acceleration, please see *[Windows Subsystem for Linux](https://github.com/analogdevicesinc/ai8x-synthesis/blob/develop/docs/WSL2.md).* For the remainder of this document, follow the steps for Ubuntu Linux. -If WSL2 is not available, it is also possible (but not recommended due to inherent compatibility issues and slightly degraded performance) to run this software natively on Windows. Please see *[Native Windows Installation](https://github.com/MaximIntegratedAI/ai8x-synthesis/blob/develop/docs/Windows.md)*. +If WSL2 is not available, it is also possible (but not recommended due to inherent compatibility issues and slightly degraded performance) to run this software natively on Windows. Please see *[Native Windows Installation](https://github.com/analogdevicesinc/ai8x-synthesis/blob/develop/docs/Windows.md)*. ##### macOS @@ -137,7 +137,7 @@ Ctrl+A,D to disconnect The following software is optional, and can be replaced with other similar software of the user’s choosing. 1. Code Editor - Visual Studio Code, or the VSCodium version, , with the “Remote - SSH” plugin; *to use Visual Studio Code on Windows as a full development environment (including debug), see * + Visual Studio Code, or the VSCodium version, , with the “Remote - SSH” plugin; *to use Visual Studio Code on Windows as a full development environment (including debug), see * Sublime Text, 2. Markdown Editor Typora, @@ -309,7 +309,7 @@ $ git config --global user.name "First Last" #### Nervana Distiller -[Nervana Distiller](https://github.com/MaximIntegratedAI/distiller) is automatically installed as a git sub-module with the other packages. Distiller is used for its scheduling and model export functionality. +[Nervana Distiller](https://github.com/analogdevicesinc/distiller) is automatically installed as a git sub-module with the other packages. Distiller is used for its scheduling and model export functionality. ### Upstream Code @@ -317,8 +317,8 @@ Change to the project root and run the following commands. Use your GitHub crede ```shell $ cd -$ git clone --recursive https://github.com/MaximIntegratedAI/ai8x-training.git -$ git clone --recursive https://github.com/MaximIntegratedAI/ai8x-synthesis.git +$ git clone --recursive https://github.com/analogdevicesinc/ai8x-training.git +$ git clone --recursive https://github.com/analogdevicesinc/ai8x-synthesis.git ``` #### Creating the Virtual Environment @@ -329,7 +329,7 @@ To create the virtual environment and install basic wheels: $ cd ai8x-training ``` -The default branch is “develop” which is updated most frequently. If you want to use the “master” branch instead, switch to “master” using `git checkout master`. +The default branch is “develop” which is updated most frequently. If you want to use the “main” branch instead, switch to “main” using `git checkout main`. If using pyenv, set the local directory to use Python 3.8.11. @@ -394,7 +394,7 @@ For all other systems, including macOS, and CUDA 10.2 on Linux: ##### Repository Branches -By default, the `develop` branch is checked out. This branch is the most frequently updated branch and it contains the latest improvements to the project. To switch to the main branch that is updated less frequently, but may be more stable, use the command `git checkout master`. +By default, the `develop` branch is checked out. This branch is the most frequently updated branch and it contains the latest improvements to the project. To switch to the main branch that is updated less frequently, but may be more stable, use the command `git checkout main`. ###### TensorFlow / Keras @@ -423,7 +423,7 @@ For minor updates, pull the latest code and install the updated wheels: ##### MSDK Updates -Please *also* update the MSDK or use the Maintenance Tool as documented in the [Analog Devices MSDK documentation](https://github.com/Analog-Devices-MSDK/msdk). The Maintenance Tool automatically updates the MSDK. +Please *also* update the MSDK or use the Maintenance Tool as documented in the [Analog Devices MSDK documentation](https://github.com/analogdevicesinc/msdk). The Maintenance Tool automatically updates the MSDK. ##### Python Version Updates @@ -481,7 +481,7 @@ $ cd $ cd ai8x-synthesis ``` -If you want to use the main branch, switch to “master” using the optional command `git checkout master`. +If you want to use the main branch, switch to “main” using the optional command `git checkout main`. If using pyenv, run: @@ -551,96 +551,18 @@ There are two ways to install the MSDK. #### Method 1: MSDK Installer -The [Analog Devices MSDK](https://github.com/Analog-Devices-MSDK/msdk) for MAX78000/MAX7802 is available via the installer links below. These installers require a GUI on your system. +An automatic installer is available for the MSDK. Instructions for downloading, installing, and getting started with the MSDK’s supported development environments are found in the [**MSDK User Guide**](https://analogdevicesinc.github.io/msdk/USERGUIDE/). -1. Download the MSDK installer for your operating system from one of the links below. - * [Windows](https://www.analog.com/en/design-center/evaluation-hardware-and-software/software/software-download?swpart=SFW0010820A) - * [Ubuntu Linux](https://www.analog.com/en/design-center/evaluation-hardware-and-software/software/software-download?swpart=SFW0018720A) - * [macOS](https://www.analog.com/en/design-center/evaluation-hardware-and-software/software/software-download?swpart=SFW0018610A) - -2. Run the installer executable. Note: On Linux, this may require making the file executable with the following command: - - ```bash - $ chmod +x MaximMicrosSDK_linux.run - ``` - -3. Follow the instructions in the installer to the component selection. - -4. Select the components to install. At _minimum_, the following components must be selected. This will enable command-line development. - - * GNU RISC-V Embedded GCC - * GNU Tools for ARM Embedded Processors - * Open On-Chip Debugger - * MSYS2 (only on Windows) - * Microcontrollers - * MAX78000 Resources - * MAX78002 Resources - * Product Libs - * CMSIS Core Libraries - * Miscellaneous Drivers - * Peripheral Drivers - -5. (Optional) Select the “Eclipse” and/or “Visual Studio Code Support” components to add support for those IDEs. - -6. Continue through the instructions to complete the installation of the MSDK. - -7. (macOS only) Install OpenOCD dependencies using [Homebrew](https://brew.sh/) - - ```shell - $ brew install libusb-compat libftdi hidapi libusb - ``` - -8. (Linux and macOS only) Add the location of the toolchain binaries to the system `PATH`. - - On Linux and macOS, copy the following contents into `~/.profile`... - On macOS, _also_ copy the following contents into `~/.zprofile`... - ...and change `MAXIM_PATH` to the installation location of the MSDK. - - ```shell - # MSDK location - MAXIM_PATH=$HOME/MaximSDK # Change me! - export MAXIM_PATH - - # Arm GCC -- adjust version number - ARMGCC_DIR=$MAXIM_PATH/Tools/GNUTools/12.3 - echo $PATH | grep -q -s "$ARMGCC_DIR/bin" - if [ $? -eq 1 ] ; then - PATH=$PATH:"$ARMGCC_DIR/bin" - export PATH - export ARMGCC_DIR - fi - - # RISC-V GCC -- adjust version number - RISCVGCC_DIR=$MAXIM_PATH/Tools/xPack/riscv-none-embed-gcc/12.3.0-2 - echo $PATH | grep -q -s "$RISCVGCC_DIR/bin" - if [ $? -eq 1 ] ; then -     PATH=$PATH:"$RISCVGCC_DIR/bin" -     export PATH -     export RISCVGCC_DIR - fi - - # OpenOCD - OPENOCD_DIR=$MAXIM_PATH/Tools/OpenOCD - echo $PATH | grep -q -s "$OPENOCD_DIR" - if [ $? -eq 1 ] ; then -     PATH=$PATH:$OPENOCD_DIR -     export PATH -     export OPENOCD_DIR - fi - ``` - - On Windows, this step is not necessary. However, “MaximSDK/Tools/MSYS2/msys.bat” file _must_ be used to launch the MSYS2 terminal for command-line development. - -Once the tools above have been installed, continue with [Final Check](#final-check). +After installation and setup, continue with the [Final Check](#final-check). #### Method 2: Manual Installation -The MAX78000/MAX78002 MSDK is available as a git repository. The repository contains all of the MSDK's components _except_ the Arm GCC, RISC-V GCC, and Make. These must be downloaded and installed manually. +The MSDK is also available as a [git repository](https://github.com/analogdevicesinc/msdk), which can be used to obtain the latest development resources. The repository contains all of the MSDK’s components _except_ the Arm GCC, RISC-V GCC, and Make. These can be downloaded and installed manually. 1. Clone the MSDK repository (recommendation: change to the *ai8x-synthesis* folder first): ```shell - $ git clone https://github.com/Analog-Devices-MSDK/msdk.git sdk + $ git clone https://github.com/analogdevicesinc/msdk.git sdk ``` 2. Download and install the Arm Embedded GNU Toolchain from [https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads](https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads). @@ -663,7 +585,7 @@ The MAX78000/MAX78002 MSDK is available as a git repository. The repository cont $ pacman -S --needed base filesystem msys2-runtime make ``` -5. Install packages for OpenOCD. OpenOCD binaries are available in the “openocd” sub-folder of the ai8x-synthesis repository. However, some additional dependencies are required on most systems. See [openocd/README.md](https://github.com/MaximIntegratedAI/ai8x-synthesis/blob/develop/openocd/README.md) for a list of packages to install, then return here to continue. +5. Install packages for OpenOCD. OpenOCD binaries are available in the “openocd” sub-folder of the ai8x-synthesis repository. However, some additional dependencies are required on most systems. See [openocd/README.md](https://github.com/analogdevicesinc/ai8x-synthesis/blob/develop/openocd/README.md) for a list of packages to install, then return here to continue. 6. Add the location of the toolchain binaries to the system path. @@ -816,7 +738,7 @@ The number of discarded pixels is network specific and dependent on pooling stri *Note: Streaming mode requires the use of [FIFOs](#fifos).* -For concrete examples on how to implement streaming mode with a camera, please see the [Camera Streaming Guide](https://github.com/MaximIntegratedAI/MaximAI_Documentation/blob/master/Guides/Camera_Streaming_Guide.md). +For concrete examples on how to implement streaming mode with a camera, please see the [Camera Streaming Guide](https://github.com/analogdevicesinc/MaximAI_Documentation/blob/main/Guides/Camera_Streaming_Guide.md). #### FIFOs @@ -1027,7 +949,7 @@ Because each processor has its own dedicated weight memory, this will introduce For each layer, a set of active processors must be specified. The number of input channels for the layer must be equal to, or be a multiple of, the active processors, and the input data for that layer must be located in data memory instances accessible to the selected processors. It is possible to specify a relative offset into the data memory instance that applies to all processors. -_Example:_ Assuming HWC data format, specifying the offset as 16384 bytes (or 0x4000) will cause processors 0-3 to read their input from the second half of data memory 0, processors 4-7 will read from the second half of data memory instance 1, etc. +_Example:_ Assuming HWC data format, specifying the offset as 16,384 bytes (or 0x4000) will cause processors 0-3 to read their input from the second half of data memory 0, processors 4-7 will read from the second half of data memory instance 1, etc. For most simple networks with limited data sizes, it is easiest to ping-pong between the first and second halves of the data memories – specify the data offset as 0 for the first layer, 0x4000 for the second layer, 0 for the third layer, etc. This strategy avoids overlapping inputs and outputs when a given processor is used in two consecutive layers. @@ -1144,7 +1066,7 @@ The MAX78000 hardware does not support arbitrary network parameters. Specificall * Streaming mode: - * When using data greater than 90×91 (8,192 pixels per channel in HWC mode), or 181×181 (32,768 pixels in CHW mode), and [Data Folding](#data-folding) techniques are not used, then `streaming` mode must be used. + * When using data greater than 8192 pixels per channel (approximately 90×90 when width = height) in HWC mode, or 32,768 pixels per channel (181×181 when width = height) in CHW mode, and [Data Folding](#data-folding) techniques are not used, then `streaming` mode must be used. * When using `streaming` mode, the product of any layer’s input width, input height, and input channels divided by 64 rounded up must not exceed 2^21: $width * height * ⌈\frac{channels}{64}⌉ < 2^{21}$; _width_ and _height_ must not exceed 1023. * Streaming is limited to 8 consecutive layers or fewer, and is limited to four FIFOs (up to 4 input channels in CHW and up to 16 channels in HWC format), see [FIFOs](#fifos). * For streaming layers, bias values may not be added correctly in all cases. @@ -1156,7 +1078,7 @@ The MAX78000 hardware does not support arbitrary network parameters. Specificall When using more than 64 input or output channels, weight memory is shared, and effective capacity decreases proportionally (for example, 128 input channels require twice as much space as 64 input channels, and a layer with both 128 input and 128 output channels requires four times as much space as a layer with only 64 input channels and 64 output channels). Weights must be arranged according to specific rules detailed in [Layers and Weight Memory](#layers-and-weight-memory). -* There are 16 instances of 32 KiB data memory ([for a total of 512 KiB](docs/AHBAddresses.md)). When not using streaming mode, any data channel (input, intermediate, or output) must completely fit into one memory instance. This limits the first-layer input to 181×181 pixels per channel in the CHW format. However, when using more than one input channel, the HWC format may be preferred, and all layer outputs are in HWC format as well. In those cases, it is required that four channels fit into a single memory instance — or 91×90 pixels per channel. +* There are 16 instances of 32 KiB data memory ([for a total of 512 KiB](docs/AHBAddresses.md)). When not using streaming mode, any data channel (input, intermediate, or output) must completely fit into one memory instance. This limits the first-layer input to 32,768 pixels per channel in the CHW format (181×181 when width = height). However, when using more than one input channel, the HWC format may be preferred, and all layer outputs are in HWC format as well. In those cases, it is required that four channels fit into a single memory instance — or 8192 pixels per channel (approximately 90×90 when width = height). Note that the first layer commonly creates a wide expansion (i.e., a large number of output channels) that needs to fit into data memory, so the input size limit is mostly theoretical. In many cases, [Data Folding](#data-folding) (distributing the input data across multiple channels) can effectively increase both the input dimensions as well as improve model performance. * The hardware supports 1D and 2D convolution layers, 2D transposed convolution layers (upsampling), element-wise addition, subtraction, binary OR, binary XOR as well as fully connected layers (`Linear`), which are implemented using 1×1 convolutions on 1×1 data: @@ -1164,7 +1086,7 @@ The MAX78000 hardware does not support arbitrary network parameters. Specificall * `Flatten` functionality is available to convert 2D input data for use by fully connected layers, see [Fully Connected Layers](#fully-connected-linear-layers). - * When “flattening” two-dimensional data, the input dimensions (C×H×W) must satisfy C×H×W ≤ 16384. Pooling cannot be used at the same time as flattening. + * When “flattening” two-dimensional data, the input dimensions (C×H×W) must satisfy C×H×W ≤ 16,384, and H×W ≤ 256. Pooling cannot be used at the same time as flattening. * Element-wise operators support from 2 up to 16 inputs. @@ -1241,7 +1163,7 @@ The MAX78002 hardware does not support arbitrary network parameters. Specificall * Streaming mode: - * When using data greater than 143×143 (20,480 pixels per channel in HWC mode), or 286×286 (81,920 pixels in CHW mode), and [Data Folding](#data-folding) techniques are not used, then `streaming` mode must be used. + * When using data greater than 20,480 pixels per channel in HWC mode (143×143 when height = width), or 81,920 pixels in CHW mode (286×286 when height = width), and [Data Folding](#data-folding) techniques are not used, then `streaming` mode must be used. * When using `streaming` mode, the product of any layer’s input width, input height, and input channels divided by 64 rounded up must not exceed 2^21: $width * height * ⌈\frac{channels}{64}⌉ < 2^{21}$; _width_ and _height_ must not exceed 2047. * Streaming is limited to 8 consecutive layers or fewer, and is limited to four FIFOs (up to 4 input channels in CHW and up to 16 channels in HWC format), see [FIFOs](#fifos). * Layers that use 1×1 kernels without padding are automatically replaced with equivalent layers that use 3×3 kernels with padding. @@ -1252,14 +1174,14 @@ The MAX78002 hardware does not support arbitrary network parameters. Specificall When using more than 64 input or output channels, weight memory is shared, and effective capacity decreases. Weights must be arranged according to specific rules detailed in [Layers and Weight Memory](#layers-and-weight-memory). -* The total of [1,280 KiB of data memory](docs/AHBAddresses.md) is split into 16 sections of 80 KiB each. When not using streaming mode, any data channel (input, intermediate, or output) must completely fit into one memory instance. This limits the first-layer input to 286×286 pixels per channel in the CHW format. However, when using more than one input channel, the HWC format may be preferred, and all layer outputs are in HWC format as well. In those cases, it is required that four channels fit into a single memory section — or 143×143 pixels per channel. +* The total of [1,280 KiB of data memory](docs/AHBAddresses.md) is split into 16 sections of 80 KiB each. When not using streaming mode, any data channel (input, intermediate, or output) must completely fit into one memory instance. This limits the first-layer input to 81,920 pixels per channel in CHW format (286×286 when height = width). However, when using more than one input channel, the HWC format may be preferred, and all layer outputs are in HWC format as well. In those cases, it is required that four channels fit into a single memory section — or 20,480 pixels per channel (143×143 when height = width). Note that the first layer commonly creates a wide expansion (i.e., a large number of output channels) that needs to fit into data memory, so the input size limit is mostly theoretical. In many cases, [Data Folding](#data-folding) (distributing the input data across multiple channels) can effectively increase both the input dimensions as well as improve model performance. * The hardware supports 1D and 2D convolution layers, 2D transposed convolution layers (upsampling), element-wise addition, subtraction, binary OR, binary XOR as well as fully connected layers (`Linear`), which are implemented using 1×1 convolutions on 1×1 data: * The maximum number of input neurons is 1024, and the maximum number of output neurons is 1024 (16 each per processor used). * `Flatten` functionality is available to convert 2D input data for use by fully connected layers, see [Fully Connected Layers](#fully-connected-linear-layers). - * When “flattening” two-dimensional data, the input dimensions (C×H×W) must satisfy C×H×W ≤ 16384. Pooling cannot be used at the same time as flattening. + * When “flattening” two-dimensional data, the input dimensions (C×H×W) must satisfy C×H×W ≤ 16,384, and H×W ≤ 256. Pooling cannot be used at the same time as flattening. * Element-wise operators support from 2 up to 16 inputs. * Element-wise operators can be chained in-flight with pooling and 2D convolution (where the order of pooling and element-wise operations can be swapped). * For convenience, a `Softmax` operator is supported in software. @@ -1282,7 +1204,7 @@ The MAX78002 hardware does not support arbitrary network parameters. Specificall m×n fully connected layers can be realized in hardware by “flattening” 2D input data of dimensions C×H×W into m=C×H×W channels of 1×1 input data. The hardware will produce n channels of 1×1 output data. When chaining multiple fully connected layers, the flattening step is omitted. The following picture shows 2D data, the equivalent flattened 1D data, and the output. -For MAX78000/MAX78002, the product C×H×W must not exceed 16384. +For MAX78000/MAX78002, the product C×H×W must not exceed 16,384. ![MLP](docs/MLP.png) @@ -1534,6 +1456,11 @@ The following table describes the most important command line arguments for `tra | `--nas` | Enable network architecture search | | | `--nas-policy` | Define NAS policy in YAML file | `--nas-policy nas/nas_policy.yaml` | | `--regression` | Select regression instead of classification (changes Loss function, and log output) | | +| `--dr` | Set target embedding dimensionality for dimensionality reduction |`--dr 64` | +| `--scaf-lr` | Initial learning rate for sub-center ArcFace loss optimizer | | +| `--scaf-scale` |Scale hyperparameter for sub-center ArcFace loss | | +| `--scaf-margin` |Margin hyperparameter for sub-center ArcFace loss | | +| `--backbone-checkpoint` |Path to checkpoint from which to load backbone weights | | | *Display and statistics* | | | | `--enable-tensorboard` | Enable logging to TensorBoard (default: disabled) | | | `--confusion` | Display the confusion matrix | | @@ -1552,6 +1479,7 @@ The following table describes the most important command line arguments for `tra | `--summary onnx_simplified` | Export trained model to simplified [ONNX](https://onnx.ai/) file (default name: model.onnx) | | | `--summary-filename` | Change the file name for the exported model | `--summary-filename mnist.onnx` | | `--save-sample` | Save data[index] from the test set to a NumPy pickle for use as sample data | `--save-sample 10` | +| `--slice-sample` | For models that require RGB input, when the sample from the dataset has additional channels, slice the sample into 3 channels | | #### ONNX Model Export @@ -2086,7 +2014,7 @@ While there can be multiple reasons for this, check two important settings that #### Introduction -The following chapter describes the neural architecture search (NAS) solution for MAX78000/MAX78002 as implemented in the [ai8x-training](https://github.com/MaximIntegratedAI/ai8x-training) repository. Details are provided about the NAS method, how to run existing NAS models in the repository, and how to define a new NAS model. +The following chapter describes the neural architecture search (NAS) solution for MAX78000/MAX78002 as implemented in the [ai8x-training](https://github.com/analogdevicesinc/ai8x-training) repository. Details are provided about the NAS method, how to run existing NAS models in the repository, and how to define a new NAS model. The intention of NAS is to find the best neural architecture for a given set of requirements by automating architecture engineering. NAS explores the search space automatically and returns an architecture that is hard to optimize further using human or “manual” design. Multiple different techniques are proposed in the literature for automated architecture search, including reinforcement-based and evolutionary-based solutions. @@ -2159,7 +2087,7 @@ The only model architecture implemented in this repository is the sequential mod nas_model -All required elastic search strategies are implemented in this [model file](https://github.com/MaximIntegratedAI/ai8x-training/blob/develop/models/ai85nasnet-sequential.py). +All required elastic search strategies are implemented in this [model file](https://github.com/analogdevicesinc/ai8x-training/blob/develop/models/ai85nasnet-sequential.py). A new model architecture can be implemented by implementing the `OnceForAllModel` interface. The new model class must implement the following: @@ -2286,7 +2214,7 @@ The following table describes the most important command line arguments for `ai8 ### YAML Network Description -The [quick-start guide](https://github.com/MaximIntegratedAI/MaximAI_Documentation/blob/master/Guides/YAML%20Quickstart.md) provides a short overview of the purpose and structure of the YAML network description file. +The [quick-start guide](https://github.com/analogdevicesinc/MaximAI_Documentation/blob/main/Guides/YAML%20Quickstart.md) provides a short overview of the purpose and structure of the YAML network description file. If `yamllint` is installed and available in the shell path, it is automatically run against the configuration file and all warnings and errors are reported. *Note: The name of the linter can be changed using the `--yamllint` command line argument.* @@ -3101,7 +3029,7 @@ To run another inference, ensure all quadrants are disabled (stopping the state The generated code is split between API code (in `cnn.c`) and data-dependent code in `main.c` or `main_riscv.c`. The data-dependent code is based on a known-answer test. The `main()` function shows the proper sequence of steps to load and configure the CNN accelerator, run it, unload it, and verify the result. `void load_input(void);` -Load the example input. This function can serve as a template for loading data into the CNN accelerator. Note that the clocks and power to the accelerator must be enabled first. If this is skipped, the device may appear to hang and the [recovery procedure](https://github.com/MaximIntegratedAI/MaximAI_Documentation/tree/master/MAX78000_Feather#how-to-unlock-a-max78000-that-can-no-longer-be-programmed) may have to be used. +Load the example input. This function can serve as a template for loading data into the CNN accelerator. Note that the clocks and power to the accelerator must be enabled first. If this is skipped, the device may appear to hang and the [recovery procedure](https://github.com/analogdevicesinc/MaximAI_Documentation/tree/main/MAX78000_Feather#how-to-unlock-a-max78000-that-can-no-longer-be-programmed) may have to be used. `int check_output(void);` This function verifies that the known-answer test works correctly in hardware (using the example input). This function is typically not needed in the final application. @@ -3295,7 +3223,7 @@ There can be many reasons why the known-answer test (KAT) fails for a given netw * For very short and small networks, disable the use of WFI (wait for interrupt) instructions while waiting for completion of the CNN computations by using the command line option `--no-wfi`. *Explanation: In these cases, the network terminates more quickly than the time it takes between testing for completion and executing the WFI instruction, so the WFI instruction is never interrupted and the code may appear to hang.* * The `--no-wfi` option can also be useful when trying to debug code, since the debugger loses connection when the device enters sleep mode using `__WFI()`. * By default, there is a two-second delay at the beginning of the code. This time allows the debugger to take control before the device enters any kind of sleep mode. `--no-wfi` disables sleep mode (see also the related information [above](#known-answer-test-kat-console-does-not-print-passfail)). The time delay can be modified using the `--debugwait` option. - If the delay is too short or skipped altogether, and the device does not wake at the end of execution, the device may appear to hang and the [recovery procedure](https://github.com/MaximIntegratedAI/MaximAI_Documentation/tree/master/MAX78000_Feather#how-to-unlock-a-max78000-that-can-no-longer-be-programmed) may have to be used in order to load new code or to debug code. + If the delay is too short or skipped altogether, and the device does not wake at the end of execution, the device may appear to hang and the [recovery procedure](https://github.com/analogdevicesinc/MaximAI_Documentation/tree/main/MAX78000_Feather#how-to-unlock-a-max78000-that-can-no-longer-be-programmed) may have to be used in order to load new code or to debug code. * For very large and deep networks, enable the boost power supply using the `--boost` command line option. On the EVkit, the boost supply is connected to port pin P2.5, so the command line option is `--boost 2.5`. * The default compiler optimization level is `-O2`, and incorrect code may be generated under rare circumstances. Lower the optimization level in the generated `Makefile` to `-O1`, clean (`make distclean && make clean`), and rebuild the project (`make`). If this solves the problem, one of the possible reasons is that code is missing the `volatile` keyword for certain variables. To permanently adjust the default compiler optimization level, modify `MXC_OPTIMIZE_CFLAGS` in `assets/embedded-ai85/templateMakefile` for Arm code and `assets/embedded-riscv-ai85/templateMakefile.RISCV` for RISC-V code. @@ -3320,7 +3248,13 @@ ERROR: Layer 6: 64 input channels (before flattening) using 1 pass, and 1 operan *In this example, each dimension was half the expected size, so the expected processor count was off by a factor of 4. To resolve the error, a properly dimensioned sample input had to be provided.* +##### “new-lines” Configuration File Parsing Error +```shell +ERROR: invalid config: option "type" of "new-lines" should be in ('unix', 'dos') +``` + +This message indicates that an outdated version of `yamllint` is installed in the search path. Either update `yamllint` to version 1.27.0 or later, or uninstall `yamllint`, or edit `.yamllint` to remove `new-lines: type: platform`, or use `--yamllint none`. #### Energy Measurement @@ -3330,16 +3264,18 @@ When running C code generated with `--energy`, the power display on the EVKit wi *Note: MAX78000 uses LED1 and LED2 to trigger power measurement via MAX32625 and MAX34417.* -See the [benchmarking guide](https://github.com/MaximIntegratedAI/MaximAI_Documentation/blob/master/Guides/MAX7800x%20Power%20Monitor%20and%20Energy%20Benchmarking%20Guide.pdf) for more information about benchmarking. +See the [benchmarking guide](https://github.com/analogdevicesinc/MaximAI_Documentation/blob/main/Guides/MAX7800x%20Power%20Monitor%20and%20Energy%20Benchmarking%20Guide.pdf) for more information about benchmarking. ## Further Information -Additional information about the evaluation kits, and the software development kit (MSDK) is available on the web at . +Additional information about the evaluation kits, and the software development kit (MSDK) is available on the web at . [AHB Addresses for MAX78000 and MAX78002](docs/AHBAddresses.md) +[Facial Recognition System](https://github.com/analogdevicesinc/ai8x-training/blob/develop/docs/FacialRecognitionSystem.md) + --- @@ -3356,7 +3292,7 @@ Code should not generate any warnings in any of the tools (some of the component (ai8x-synthesis) $ pip3 install flake8 pylint mypy isort ``` -The GitHub projects use the [GitHub Super-Linter](https://github.com/github/super-linter) to automatically verify push operations and pull requests. The Super-Linter can be installed locally using [podman](https://podman.io) (or Docker), see [installation instructions](https://github.com/github/super-linter/blob/master/docs/run-linter-locally.md). +The GitHub projects use the [GitHub Super-Linter](https://github.com/github/super-linter) to automatically verify push operations and pull requests. The Super-Linter can be installed locally using [podman](https://podman.io) (or Docker), see [installation instructions](https://github.com/github/super-linter/blob/main/docs/run-linter-locally.md). To run locally, create a clean copy of the repository and run the following command from the project directory (i.e., `ai8x-training` or `ai8x-synthesis`): ```shell @@ -3365,11 +3301,11 @@ $ podman run --rm -e RUN_LOCAL=true -e VALIDATE_MARKDOWN=false -e VALIDATE_PYTHO ### Submitting Changes -Do not try to push any changes into the master branch. Instead, create a fork and submit a pull request against the `develop` branch. The easiest way to do this is using a [graphical client](#additional-software) such as Fork or GitHub Desktop. +Do not try to push any changes into the main branch. Instead, create a fork and submit a pull request against the `develop` branch. The easiest way to do this is using a [graphical client](#additional-software) such as Fork or GitHub Desktop. *Note: After creating the fork, you must re-enable actions in the “Actions” tab of the repository on GitHub.* The following document has more information: - + --- diff --git a/README.pdf b/README.pdf index d83d8c355..0216a1d16 100644 Binary files a/README.pdf and b/README.pdf differ diff --git a/ai8x-training.code-workspace b/ai8x-training.code-workspace index a7a2729bf..ab28e7f30 100644 --- a/ai8x-training.code-workspace +++ b/ai8x-training.code-workspace @@ -5,12 +5,16 @@ } ], "settings": { - "python.pythonPath": "venv/bin/python", - "python.linting.flake8Enabled": true, - "python.linting.pylintArgs": [ - "--rcfile=.pylintrc" - ], "markdown.extension.toc.levels": "2..6", - "python.linting.mypyEnabled": true + "python.pythonPath": "venv/bin/python", + "git.ignoreLimitWarning": true, + "pylint.args": ["--rcfile=.pylintrc"] + }, + "extensions": { + "recommendations": [ + "ms-python.pylint", + "ms-python.flake8", + "ms-python.mypy-type-checker" + ] } } diff --git a/ai8x.py b/ai8x.py index fbe44ad75..282035a4f 100644 --- a/ai8x.py +++ b/ai8x.py @@ -1754,30 +1754,27 @@ def initiate_qat(m, qat_policy): """ Modify model `m` to start quantization aware training. """ - def _initiate_qat(m): - for attr_str in dir(m): - target_attr = getattr(m, attr_str) - if isinstance(target_attr, QuantizationAwareModule): - if 'shift_quantile' in qat_policy: - target_attr.init_module(qat_policy['weight_bits'], - qat_policy['weight_bits'], - True, qat_policy['shift_quantile']) - else: - target_attr.init_module(qat_policy['weight_bits'], - qat_policy['weight_bits'], True, 1.0) - if 'overrides' in qat_policy: - if attr_str in qat_policy['overrides']: - weight_field = qat_policy['overrides'][attr_str]['weight_bits'] - if 'shift_quantile' in qat_policy: - target_attr.init_module(weight_field, weight_field, - True, qat_policy['shift_quantile']) - else: - target_attr.init_module(weight_field, - weight_field, True, 1.0) - - setattr(m, attr_str, target_attr) - - m.apply(_initiate_qat) + if isinstance(m, nn.DataParallel): + m = m.module + + for name, module in m.named_modules(): + if isinstance(module, QuantizationAwareModule) and hasattr(module, 'weight_bits'): + if 'shift_quantile' in qat_policy: + module.init_module(qat_policy['weight_bits'], + qat_policy['weight_bits'], + True, qat_policy['shift_quantile']) + else: + module.init_module(qat_policy['weight_bits'], + qat_policy['weight_bits'], True, 1.0) + if 'overrides' in qat_policy: + if name in qat_policy['overrides']: + weight_field = qat_policy['overrides'][name]['weight_bits'] + if 'shift_quantile' in qat_policy: + module.init_module(weight_field, weight_field, + True, qat_policy['shift_quantile']) + else: + module.init_module(weight_field, + weight_field, True, 1.0) def update_model(m): diff --git a/ai8x_blocks.py b/ai8x_blocks.py index e95603675..fc2b314c7 100644 --- a/ai8x_blocks.py +++ b/ai8x_blocks.py @@ -1,6 +1,6 @@ ################################################################################################### # -# Copyright (C) 2020-2022 Maxim Integrated Products, Inc. All Rights Reserved. +# Copyright (C) 2020-2023 Maxim Integrated Products, Inc. All Rights Reserved. # # Maxim Integrated Products, Inc. Default Copyright Notice: # https://www.maximintegrated.com/en/aboutus/legal/copyrights.html @@ -116,6 +116,80 @@ def forward(self, x): # pylint: disable=arguments-differ return self.resid(y, x) +class ConvResidualBottleneck(nn.Module): + """ + AI8X module based on Residual Bottleneck Layer. + Depthwise convolution is replaced with standard convolution. + This module uses ReLU activation not ReLU6 as the original study suggests [1], + because of MAX7800X capabilities. + + Args: + in_channels: number of input channels + out_channels: number of output channels + expansion_factor: expansion_factor + stride: stirde size (default=1) + bias: determines if bias used at non-depthwise layers. + depthwise_bias: determines if bias used at depthwise layers. + + References: + [1] https://arxiv.org/pdf/1801.04381.pdf (MobileNetV2) + """ + def __init__(self, in_channels, out_channels, expansion_factor, stride=1, bias=False, + depthwise_bias=False, **kwargs): + super().__init__() + self.stride = stride + hidden_channels = int(round(in_channels * expansion_factor)) + if hidden_channels == in_channels: + self.conv1 = ai8x.Empty() + else: + self.conv1 = ai8x.FusedConv2dBNReLU(in_channels, hidden_channels, 1, padding=0, + bias=bias, **kwargs) + if stride == 1: + if depthwise_bias: + self.conv2 = ai8x.FusedConv2dBN(hidden_channels, out_channels, 3, + padding=1, stride=stride, + bias=depthwise_bias, **kwargs) + + else: + self.conv2 = ai8x.Conv2d(hidden_channels, out_channels, 3, + padding=1, stride=stride, + bias=depthwise_bias, **kwargs) + + else: + if depthwise_bias: + self.conv2 = ai8x.FusedMaxPoolConv2dBN(hidden_channels, + out_channels, 3, + padding=1, pool_size=stride, + pool_stride=stride, + bias=depthwise_bias, **kwargs) + + else: + self.conv2 = ai8x.FusedMaxPoolConv2d(hidden_channels, + out_channels, 3, + padding=1, pool_size=stride, + pool_stride=stride, + bias=depthwise_bias, **kwargs) + + if (stride == 1) and (in_channels == out_channels): + self.resid = ai8x.Add() + else: + self.resid = self.NoResidual() + + class NoResidual(nn.Module): + """ + Does nothing. + """ + def forward(self, *x): # pylint: disable=arguments-differ + """Forward prop""" + return x[0] + + def forward(self, x): # pylint: disable=arguments-differ + """Forward prop""" + y = self.conv1(x) + y = self.conv2(y) + return self.resid(y, x) + + class MBConvBlock(nn.Module): """Mobile Inverted Residual Bottleneck Block. diff --git a/attic/evaluate_cifar10_bias.sh b/attic/evaluate_cifar10_bias.sh deleted file mode 100755 index 525517bcc..000000000 --- a/attic/evaluate_cifar10_bias.sh +++ /dev/null @@ -1,2 +0,0 @@ -#!/bin/sh -python3 train.py --model ai84net5 --dataset CIFAR10 --confusion --evaluate --exp-load-weights-from ../ai8x-synthesis/trained/ai84-cifar10-bias.pth.tar -8 --use-bias "$@" diff --git a/attic/evaluate_fashionmnist.sh b/attic/evaluate_fashionmnist.sh deleted file mode 100755 index 52817f5b4..000000000 --- a/attic/evaluate_fashionmnist.sh +++ /dev/null @@ -1,2 +0,0 @@ -#!/bin/sh -python3 train.py --model ai84net5 --dataset FashionMNIST --confusion --evaluate --exp-load-weights-from ../ai8x-synthesis/trained/ai84-fashionmnist.pth.tar -8 "$@" diff --git a/attic/go_prune.sh b/attic/go_prune.sh deleted file mode 100755 index ce51cee9b..000000000 --- a/attic/go_prune.sh +++ /dev/null @@ -1,2 +0,0 @@ -#!/bin/sh -python3 train.py --epochs 300 --deterministic --compress prune.yaml --model ai84net5 --dataset FashionMNIST --confusion --resume-from logs/FashionMNIST/checkpoint.pth.tar "$@" diff --git a/attic/go_quantized.sh b/attic/go_quantized.sh deleted file mode 100755 index 917ba6095..000000000 --- a/attic/go_quantized.sh +++ /dev/null @@ -1,2 +0,0 @@ -#!/bin/sh -python3 train.py --epochs 200 --deterministic --compress quant_train_ai84.yaml --model ai84net5 --dataset FashionMNIST --confusion "$@" diff --git a/attic/inspect_ckpt.py b/attic/inspect_ckpt.py deleted file mode 100755 index 7acab898b..000000000 --- a/attic/inspect_ckpt.py +++ /dev/null @@ -1,80 +0,0 @@ -#!/usr/bin/env python3 -# -# Copyright (c) 2018 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# - -"""A small utility to inspect the contents of checkpoint files. - -Sometimes it is useful to look at the contents of a checkpoint file, and this utility is meant to help -with this. -By default this utility will print just the names and types of the keys it finds in the checkpoint -file. If the key type is simple (i.e. integer, float, or string), then the value is printed as well. - -You can also print the model keys (i.e. the names of the parameters tensors in the model), and the -weight tensor masks in the schedule). - -$ python3 inspect_ckpt.py checkpoint.pth.tar --model --schedule -""" -import argparse - -import torch - -import distiller -from distiller.apputils.checkpoint import get_contents_table -from tabulate import tabulate - - -def inspect_checkpoint(chkpt_file, args): - print("Inspecting checkpoint file: ", chkpt_file) - checkpoint = torch.load(chkpt_file, map_location='cpu') - - print(get_contents_table(checkpoint)) - - if 'extras' in checkpoint and checkpoint['extras']: - print("\nContents of Checkpoint['extras']:") - print(get_contents_table(checkpoint['extras'])) - - if args.model and "state_dict" in checkpoint: - print("\nModel keys (state_dict):\n{}".format(", ".join(list(checkpoint["state_dict"].keys())))) - if args.dump: - for i, k in enumerate(checkpoint["state_dict"].keys()): - print(k, "------------------------------------------") - print(checkpoint['state_dict'][k]) - - if args.schedule and "compression_sched" in checkpoint: - compression_sched = checkpoint["compression_sched"] - print("\nSchedule keys (compression_sched):\n{}\n".format("\n\t".join(list(compression_sched.keys())))) - sched_keys = [[k, type(compression_sched[k]).__name__] for k in compression_sched.keys()] - print(tabulate(sched_keys, headers=["Key", "Type"], tablefmt="fancy_grid")) - if "masks_dict" in checkpoint["compression_sched"]: - print("compression_sched[\"masks_dict\"] keys:\n{}".format(", ".join( - list(compression_sched["masks_dict"].keys())))) - - if args.thinning and "thinning_recipes" in checkpoint: - for recipe in checkpoint["thinning_recipes"]: - print(recipe) - - -if __name__ == '__main__': - torch.set_printoptions(threshold=10000000, linewidth=190) - - parser = argparse.ArgumentParser(description='Distiller checkpoint inspection') - parser.add_argument('chkpt_file', help='path to the checkpoint file') - parser.add_argument('-m', '--model', action='store_true', help='print the model keys') - parser.add_argument('-d', '--dump', action='store_true', help='dump values') - parser.add_argument('-s', '--schedule', action='store_true', help='print the schedule keys') - parser.add_argument('-t', '--thinning', action='store_true', help='print the thinning keys') - args = parser.parse_args() - inspect_checkpoint(args.chkpt_file, args) diff --git a/attic/logging.conf b/attic/logging.conf deleted file mode 100755 index 429419b05..000000000 --- a/attic/logging.conf +++ /dev/null @@ -1,54 +0,0 @@ -[formatters] -keys: simple, time_simple - -[handlers] -keys: console, file - -[loggers] -keys: root, app_cfg, distiller.thinning, apputils.model_summaries - -[formatter_simple] -format: %(message)s - -[formatter_time_simple] -format: %(asctime)s - %(message)s - -[handler_console] -class: StreamHandler -propagate: 0 -args: [] -formatter: simple - -[handler_file] -class: FileHandler -mode: 'w' -args=('%(logfilename)s', 'w') -formatter: time_simple - -[logger_root] -level: INFO -propagate: 1 -handlers: console, file - -[logger_app_cfg] -# Use this logger to log the application configuration and execution environment -level: DEBUG -qualname: app_cfg -propagate: 0 -handlers: file - -# Example of adding a module-specific logger -# Do not forget to add distiller.thinning to the list of keys in section [loggers] -[logger_distiller.thinning] -level: INFO -qualname: distiller.thinning -propagate: 0 -handlers: console, file - -# Example of adding a module-specific logger -# Do not forget to add apputils.model_summaries to the list of keys in section [loggers] -[logger_apputils.model_summaries] -level: INFO -qualname: apputils.model_summaries -propagate: 0 -handlers: console, file diff --git a/attic/post_train.yaml b/attic/post_train.yaml deleted file mode 100644 index ae2d5d6ef..000000000 --- a/attic/post_train.yaml +++ /dev/null @@ -1,13 +0,0 @@ ---- -quantizers: - post_train_quantizer: - class: PostTrainLinearQuantizer - bits_activations: 8 - bits_parameters: 8 - bits_accum: 32 - # SYMMETRIC, ASYMMETRIC_UNSIGNED, ASYMMETRIC_SIGNED - mode: SYMMETRIC - per_channel_wts: false - # NONE, AVG, N_STD - clip_acts: AVG - no_clip_layers: fc diff --git a/attic/post_train_ai84.yaml b/attic/post_train_ai84.yaml deleted file mode 100644 index 65c89f394..000000000 --- a/attic/post_train_ai84.yaml +++ /dev/null @@ -1,24 +0,0 @@ ---- -quantizers: - post_train_quantizer: - class: PostTrainLinearQuantizerAI84 - bits_activations: 8 - bits_parameters: 5 - bits_accum: 32 - # int8: true - scale_approx_mult_bits: 8 - # SYMMETRIC, ASYMMETRIC_UNSIGNED, ASYMMETRIC_SIGNED - mode: SYMMETRIC - per_channel_wts: false - # NONE, AVG, N_STD - # clip_acts: N_STD - # clip_n_stds: 3 - clip_acts: AVG - no_clip_layers: fc - global_scale: false - # global_sat_scale: 25.0 - overrides: - fc: - bits_weights: 8 - bits_bias: 8 - scale_approx_mult_bits: null diff --git a/attic/prune.yaml b/attic/prune.yaml deleted file mode 100644 index 91c081ab3..000000000 --- a/attic/prune.yaml +++ /dev/null @@ -1,33 +0,0 @@ ---- -version: 1 -pruners: - channel_pruner: - class: 'L1RankedStructureParameterPruner' - group_type: Channels - desired_sparsity: 0.35 - weights: [ - layer1.0.conv1.weight, - layer1.0.conv2.weight] - -extensions: - net_thinner: - class: 'FilterRemover' - thinning_func_str: remove_channels - arch: 'ai84net5' - dataset: 'FashionMNIST' - -lr_schedulers: - exp_finetuning_lr: - class: ExponentialLR - gamma: 0.95 - -policies: - - pruner: - instance_name: channel_pruner - epochs: [201] - - - lr_scheduler: - instance_name: exp_finetuning_lr - starting_epoch: 210 - ending_epoch: 300 - frequency: 1 diff --git a/attic/quant_train.yaml b/attic/quant_train.yaml deleted file mode 100644 index 8706373b6..000000000 --- a/attic/quant_train.yaml +++ /dev/null @@ -1,34 +0,0 @@ ---- -quantizers: - linear_quantizer: - class: QuantAwareTrainRangeLinearQuantizer - bits_weights: 8 - # Decay value for exponential moving average tracking of activation ranges - ema_decay: 0.999 - bits_activations: 8 - # bits_parameters: 8 - # bits_accum: 32 - # SYMMETRIC, ASYMMETRIC_UNSIGNED, ASYMMETRIC_SIGNED - mode: SYMMETRIC - per_channel_wts: false - # NONE, AVG, N_STD - # clip_acts: AVG - # no_clip_layers: fc - -lr_schedulers: - training_lr: - class: MultiStepLR - milestones: [100, 140, 170] - gamma: 0.1 - -policies: - - lr_scheduler: - instance_name: training_lr - starting_epoch: 0 - ending_epoch: 200 - frequency: 1 - - quantizer: - instance_name: linear_quantizer - starting_epoch: 0 - ending_epoch: 300 - frequency: 1 diff --git a/attic/quant_train_ai84.yaml b/attic/quant_train_ai84.yaml deleted file mode 100644 index 6bdd84ee0..000000000 --- a/attic/quant_train_ai84.yaml +++ /dev/null @@ -1,36 +0,0 @@ ---- -quantizers: - linear_quantizer: - class: QuantAwareTrainRangeLinearQuantizerAI84 - bits_weights: 8 - # Decay value for exponential moving average tracking of activation ranges - ema_decay: 0.999 - bits_activations: 8 - # bits_parameters: 8 - # bits_accum: 32 - # SYMMETRIC, ASYMMETRIC_UNSIGNED, ASYMMETRIC_SIGNED - mode: SYMMETRIC - per_channel_wts: false - # int8: true - scale_approx_mult_bits: 2 - # NONE, AVG, N_STD - # clip_acts: AVG - # no_clip_layers: fc - -lr_schedulers: - training_lr: - class: MultiStepLR - milestones: [100, 140, 170] - gamma: 0.1 - -policies: - - lr_scheduler: - instance_name: training_lr - starting_epoch: 0 - ending_epoch: 200 - frequency: 1 - - quantizer: - instance_name: linear_quantizer - starting_epoch: 0 - ending_epoch: 300 - frequency: 1 diff --git a/attic/quantize_cifar10.sh b/attic/quantize_cifar10.sh deleted file mode 100755 index e1f4d72d5..000000000 --- a/attic/quantize_cifar10.sh +++ /dev/null @@ -1,2 +0,0 @@ -#!/bin/sh -python3 train.py --model ai84net5 --dataset CIFAR10 --confusion --evaluate --qe --qe-config-file post_train_ai84.yaml --resume-from logs/CIFAR10/checkpoint.pth.tar -1 "$@" diff --git a/attic/quantize_fashionmnist.sh b/attic/quantize_fashionmnist.sh deleted file mode 100755 index 43b3ddae8..000000000 --- a/attic/quantize_fashionmnist.sh +++ /dev/null @@ -1,2 +0,0 @@ -#!/bin/sh -python3 train.py --model ai84net5 --dataset FashionMNIST --confusion --evaluate --qe --qe-config-file post_train_ai84.yaml --resume-from logs/FashionMNIST/checkpoint.pth.tar -1 "$@" diff --git a/attic/quantize_mnist.sh b/attic/quantize_mnist.sh deleted file mode 100755 index df24f09c2..000000000 --- a/attic/quantize_mnist.sh +++ /dev/null @@ -1,2 +0,0 @@ -#!/bin/sh -python3 train.py --model ai84net5 --dataset MNIST --confusion --evaluate --qe --qe-config-file post_train_ai84.yaml --resume-from logs/MNIST/checkpoint.pth.tar -1 "$@" diff --git a/attic/range_linear_ai84.py b/attic/range_linear_ai84.py deleted file mode 100644 index d83c3a870..000000000 --- a/attic/range_linear_ai84.py +++ /dev/null @@ -1,1302 +0,0 @@ -# -# Copyright (c) 2018 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# - -import torch.nn as nn -import argparse -from enum import Enum -from collections import OrderedDict -from functools import reduce, partial -import logging -import os -import distiller -import distiller.utils -from distiller.quantization.quantizer import Quantizer -from distiller.quantization.q_utils import get_tensor_max_abs, get_tensor_avg_max_abs, \ - get_tensor_mean_n_stds_max_abs, get_tensor_min_max, get_tensor_avg_min_max, \ - get_tensor_mean_n_stds_min_max, _prep_saturation_val_tensor, get_quantized_range, \ - linear_quantize_clamp, linear_dequantize, clamp, torch, LinearQuantizeSTE, \ - approx_scale_as_mult_and_shift -from distiller.utils import filter_kwargs -import distiller.modules -import yaml - - -msglogger = logging.getLogger() - - -def pow2_round(val, nbits): - # return 2 ** torch.log2(val.clamp(min=1)).round().clamp(max=nbits) - return val.clamp(min=1, max=2**nbits-1).round() - - -def linear_quantize_ai84(input, scale, zero_point, inplace=False): - if inplace: - input.mul_(scale).sub_(zero_point).round_() - return input - return torch.round(scale * input - zero_point) - - -def linear_quantize_clamp_ai84(input, scale, zero_point, clamp_min, clamp_max, inplace=False): - print(f'linear_quantize_clamp_ai84 scale={scale}, zp={zero_point}, min={clamp_min}, max={clamp_max}') - output = linear_quantize_ai84(input, scale, zero_point, inplace) - return clamp(output, clamp_min, clamp_max, inplace) - - -def symmetric_linear_quantization_params(num_bits, saturation_val): - is_scalar, sat_val = _prep_saturation_val_tensor(saturation_val) - - if any(sat_val < 0): - raise ValueError('Saturation value must be >= 0') - - # Leave one bit for sign - n = 2 ** (num_bits - 1) - 1 - - # If float values are all 0, we just want the quantized values to be 0 as well. So overriding the saturation - # value to 'n', so the scale becomes 1 - sat_val[sat_val == 0] = n - scale = n / sat_val - # scale = torch.round(n / sat_val) - # scale = 2 ** (torch.log2(sat_val).trunc().clamp(min=-1) + 1) - # scale = torch.ones_like(sat_val) - zero_point = torch.zeros_like(scale) - - if is_scalar: - # If input was scalar, return scalars - return scale.item(), zero_point.item() - return scale, zero_point - - -def asymmetric_linear_quantization_params(num_bits, saturation_min, saturation_max, - integral_zero_point=True, signed=False): - scalar_min, sat_min = _prep_saturation_val_tensor(saturation_min) - scalar_max, sat_max = _prep_saturation_val_tensor(saturation_max) - is_scalar = scalar_min and scalar_max - - if scalar_max and not scalar_min: - sat_max = sat_max.to(sat_min.device) - elif scalar_min and not scalar_max: - sat_min = sat_min.to(sat_max.device) - - if any(sat_min > sat_max): - raise ValueError('saturation_min must be smaller than saturation_max') - - n = 2 ** num_bits - 1 - - # Make sure 0 is in the range - sat_min = torch.min(sat_min, torch.zeros_like(sat_min)) - sat_max = torch.max(sat_max, torch.zeros_like(sat_max)) - - diff = sat_max - sat_min - # If float values are all 0, we just want the quantized values to be 0 as well. So overriding the saturation - # value to 'n', so the scale becomes 1 - diff[diff == 0] = n - - scale = torch.round(n / diff) - zero_point = scale * sat_min - if integral_zero_point: - zero_point = zero_point.round() - if signed: - zero_point += 2 ** (num_bits - 1) - if is_scalar: - return scale.item(), zero_point.item() - return scale, zero_point - - -def _enum_to_str(enum_val): - return str(enum_val).split('.')[1] - - -class LinearQuantAI84Mode(Enum): - SYMMETRIC = 1 - ASYMMETRIC_UNSIGNED = 2 - ASYMMETRIC_SIGNED = 3 - - -class ClipModeAI84(Enum): - NONE = 0 - AVG = 1 - N_STD = 2 - - -def quantize_clamp(input, clamp_min, clamp_max, inplace=False): - if inplace: - input.round_().clamp_(clamp_min, clamp_max) - return input - return torch.round(input).clamp(clamp_min, clamp_max) - - -def _verify_enum_value(val, enum_cls): - cls_name = enum_cls.__name__ - if isinstance(val, str): - try: - return enum_cls[val] - except KeyError: - raise ValueError("Input string '{0}' doesn't match any of the values of {1}: {2}" - .format(val, cls_name, [e.name for e in enum_cls])) - elif isinstance(val, enum_cls): - return val - else: - raise TypeError("Argument can be either a string or member of {0} (got {1})".format(cls_name, val)) - - -def verify_quant_mode(mode): - return _verify_enum_value(mode, LinearQuantAI84Mode) - - -def verify_clip_mode(mode): - return _verify_enum_value(mode, ClipModeAI84) - - -def _get_saturation_fn(quant_mode, clip_mode, num_stds): - if quant_mode == LinearQuantAI84Mode.SYMMETRIC: - fns = {ClipModeAI84.NONE: get_tensor_max_abs, - ClipModeAI84.AVG: get_tensor_avg_max_abs, - ClipModeAI84.N_STD: partial(get_tensor_mean_n_stds_max_abs, n_stds=num_stds)} - else: # Asymmetric mode - fns = {ClipModeAI84.NONE: get_tensor_min_max, - ClipModeAI84.AVG: get_tensor_avg_min_max, - ClipModeAI84.N_STD: partial(get_tensor_mean_n_stds_min_max, n_stds=num_stds)} - return fns[clip_mode] - - -def _get_quant_params_from_tensor(tensor, num_bits, mode, clip=ClipModeAI84.NONE, per_channel=False, num_stds=None, - scale_approx_mult_bits=None): - if per_channel and tensor.dim() not in [2, 4]: - raise ValueError('Per channel quantization possible only with 2D or 4D tensors (linear or conv layer weights)') - - if clip == ClipModeAI84.N_STD: - if per_channel: - raise ValueError('N_STD clipping not supported with per-channel quantization') - if num_stds is None: - raise ValueError('Clip mode set top N_STD but \'num_stds\' parameter not provided') - - dim = 0 if clip == ClipModeAI84.AVG or per_channel else None - sat_fn = _get_saturation_fn(mode, clip, num_stds) - if mode == LinearQuantAI84Mode.SYMMETRIC: - sat_val = sat_fn(tensor, dim) - scale, zp = symmetric_linear_quantization_params(num_bits, sat_val) - else: # Asymmetric mode - sat_min, sat_max = sat_fn(tensor, dim) - signed = mode == LinearQuantAI84Mode.ASYMMETRIC_SIGNED - scale, zp = asymmetric_linear_quantization_params(num_bits, sat_min, sat_max, signed=signed) - - if per_channel: - # Reshape scale and zero_points so they can be broadcast properly with the weight tensor - dims = [scale.shape[0]] + [1] * (tensor.dim() - 1) - scale = scale.view(dims) - zp = zp.view(dims) - - if scale_approx_mult_bits is not None: - # scale = approx_scale_as_mult_and_shift(scale, scale_approx_mult_bits) - scale = pow2_round(scale, scale_approx_mult_bits) - - return scale, zp - - -def _get_quant_params_from_model(sat_val, num_bits, mode, clip=ClipModeAI84.NONE, num_stds=None, - scale_approx_mult_bits=None): - if clip == ClipModeAI84.N_STD: - if num_stds is None: - raise ValueError('Clip mode set top N_STD but \'num_stds\' parameter not provided') - - if mode == LinearQuantAI84Mode.SYMMETRIC: - scale, zp = symmetric_linear_quantization_params(num_bits, sat_val) - else: - raise NotImplementedError('Only SYMMETRIC quantization mode is implemented') - - if scale_approx_mult_bits is not None: - # scale = approx_scale_as_mult_and_shift(scale, scale_approx_mult_bits) - scale = pow2_round(scale, scale_approx_mult_bits) - - return scale, zp - - -def _get_quant_params_from_stats_dict(stats, num_bits, mode, clip=ClipModeAI84.NONE, num_stds=None, - scale_approx_mult_bits=None): - if clip == ClipModeAI84.N_STD: - if num_stds is None: - raise ValueError('Clip mode set to N_STD but \'num_stds\' parameter not provided') - if num_stds <= 0: - raise ValueError('n_stds must be > 0, got {}'.format(num_stds)) - prefix = 'avg_' if clip == ClipModeAI84.AVG else '' - sat_min = torch.tensor(float(stats[prefix + 'min'])) - sat_max = torch.tensor(float(stats[prefix + 'max'])) - if clip == ClipModeAI84.N_STD: - mean = torch.tensor(float(stats['mean'])) - std = torch.tensor(float(stats['std'])) - sat_min = torch.max(sat_min, mean - num_stds * std) - sat_max = torch.min(sat_max, mean + num_stds * std) - if mode == LinearQuantAI84Mode.SYMMETRIC: - scale, zp = symmetric_linear_quantization_params(num_bits, torch.max(sat_min.abs_(), sat_max.abs_())) - else: - signed = mode == LinearQuantAI84Mode.ASYMMETRIC_SIGNED - scale, zp = asymmetric_linear_quantization_params(num_bits, sat_min, sat_max, signed=signed) - - if scale_approx_mult_bits is not None: - scale = approx_scale_as_mult_and_shift(scale, scale_approx_mult_bits) - - return scale, zp - - -############################################################################### -# Post Training -############################################################################### - - -def add_post_train_quant_ai84_args(argparser): - str_to_quant_mode_map = {'sym': LinearQuantAI84Mode.SYMMETRIC, - 'asym_s': LinearQuantAI84Mode.ASYMMETRIC_SIGNED, - 'asym_u': LinearQuantAI84Mode.ASYMMETRIC_UNSIGNED} - - str_to_clip_mode_map = {'none': ClipModeAI84.NONE, 'avg': ClipModeAI84.AVG, 'n_std': ClipModeAI84.N_STD} - - def from_dict(d, val_str): - try: - return d[val_str] - except KeyError: - raise argparse.ArgumentTypeError('Must be one of {0} (received {1})'.format(list(d.keys()), val_str)) - - linear_quant_mode_str = partial(from_dict, str_to_quant_mode_map) - clip_mode_str = partial(from_dict, str_to_clip_mode_map) - - group = argparser.add_argument_group('Arguments controlling quantization at evaluation time ' - '("post-training quantization")') - exc_group = group.add_mutually_exclusive_group() - exc_group.add_argument('--quantize-eval', '--qe', action='store_true', - help='Apply linear quantization to model before evaluation. Applicable only if ' - '--evaluate is also set') - exc_group.add_argument('--qe-calibration', type=distiller.utils.float_range_argparse_checker(exc_min=True), - metavar='PORTION_OF_TEST_SET', - help='Run the model in evaluation mode on the specified portion of the test dataset and ' - 'collect statistics. Ignores all other \'qe--*\' arguments') - group.add_argument('--qe-mode', '--qem', type=linear_quant_mode_str, default='sym', - help='Linear quantization mode. Choices: ' + ' | '.join(str_to_quant_mode_map.keys())) - group.add_argument('--qe-bits-acts', '--qeba', type=int, default=8, metavar='NUM_BITS', - help='Number of bits for quantization of activations') - group.add_argument('--qe-bits-wts', '--qebw', type=int, default=8, metavar='NUM_BITS', - help='Number of bits for quantization of weights') - group.add_argument('--qe-bits-accum', type=int, default=32, metavar='NUM_BITS', - help='Number of bits for quantization of the accumulator') - group.add_argument('--qe-clip-acts', '--qeca', type=clip_mode_str, default='none', - help='Activations clipping mode. Choices: ' + ' | '.join(str_to_clip_mode_map.keys())) - group.add_argument('--qe-clip-n-stds', type=float, - help='When qe-clip-acts is set to \'n_std\', this is the number of standard deviations to use') - group.add_argument('--qe-no-clip-layers', '--qencl', type=str, nargs='+', metavar='LAYER_NAME', default=[], - help='List of layer names for which not to clip activations. Applicable ' - 'only if --qe-clip-acts is not \'none\'') - group.add_argument('--qe-per-channel', '--qepc', action='store_true', - help='Enable per-channel quantization of weights (per output channel)') - group.add_argument('--qe-scale-approx-bits', '--qesab', type=int, metavar='NUM_BITS', - help='Enables scale factor approximation using integer multiply + bit shift, using ' - 'this number of bits the integer multiplier') - group.add_argument('--qe-stats-file', type=str, metavar='PATH', - help='Path to YAML file with calibration stats. If not given, dynamic quantization will ' - 'be run (Note that not all layer types are supported for dynamic quantization)') - group.add_argument('--qe-config-file', type=str, metavar='PATH', - help='Path to YAML file containing configuration for PostTrainLinearQuantizerAI84 (if present, ' - 'all other --qe* arguments are ignored)') - - -class RangeLinearQuantAI84Wrapper(nn.Module): - """ - Base class for module which wraps an existing module with linear range-base quantization functionality - - Args: - wrapped_module (torch.nn.Module): Module to be wrapped - num_bits_acts (int): Number of bits used for inputs and output quantization - num_bits_accum (int): Number of bits allocated for the accumulator of intermediate integer results - mode (LinearQuantAI84Mode): Quantization mode to use (symmetric / asymmetric-signed / unsigned) - clip_acts (ClipModeAI84): Activations clipping mode to use - activation_stats (dict): Dict containing activation stats, used for static calculation of quantization - parameters. Dict should be in the format exported by distiller.data_loggers.QuantCalibrationStatsCollector. - If None then parameters are calculated dynamically. - clip_n_stds (float): When clip_acts == ClipMode.N_STD, this is the number of standard deviations to use - scale_approx_mult_bits (int): If not None, scale factors will be approximated using an integer multiplication - followed by a bit-wise shift. This eliminates floating-point scale factors, replacing them with integer - calculations. - If None, scale factors will be kept in their original FP32 values. - """ - - def __init__(self, wrapped_module, num_bits_acts, num_bits_accum=32, mode=LinearQuantAI84Mode.SYMMETRIC, - clip_acts=ClipModeAI84.NONE, activation_stats=None, clip_n_stds=None, scale_approx_mult_bits=None): - super(RangeLinearQuantAI84Wrapper, self).__init__() - - self.wrapped_module = wrapped_module - self.num_bits_acts = num_bits_acts - self.num_bits_accum = num_bits_accum - self.mode = mode - self.clip_acts = clip_acts - self.clip_n_stds = clip_n_stds - self.scale_approx_mult_bits = scale_approx_mult_bits - - # Controls whether output is de-quantized at end of forward op. Meant as a debug / test flag only - # (note that if False, the quantized output will be returned, but without any quantization parameters, - # so other than inspecting the contents there's not much to do with it) - self._dequant_out = True - - signed = mode != LinearQuantAI84Mode.ASYMMETRIC_UNSIGNED - self.acts_min_q_val, self.acts_max_q_val = get_quantized_range(num_bits_acts, signed=signed) - # The accumulator is always signed - self.accum_min_q_val, self.accum_max_q_val = get_quantized_range(num_bits_accum, signed=True) - - if activation_stats: - self.preset_act_stats = True - self.num_inputs = 0 - for idx, stats in activation_stats['inputs'].items(): - self.num_inputs += 1 - scale, zp = _get_quant_params_from_stats_dict(stats, num_bits_acts, mode, clip_acts, clip_n_stds, - scale_approx_mult_bits) - prefix = 'in_{0}_'.format(idx) - self.register_buffer(prefix + 'scale', scale) - self.register_buffer(prefix + 'zero_point', zp) - - scale, zp = _get_quant_params_from_stats_dict(activation_stats['output'], num_bits_acts, mode, clip_acts, - clip_n_stds, scale_approx_mult_bits) - self.register_buffer('output_scale', scale) - self.register_buffer('output_zero_point', zp) - else: - self.preset_act_stats = False - - def inputs_scales(self): - for scale in self._inputs_qparam('scale'): - yield scale - - def inputs_zero_points(self): - for zp in self._inputs_qparam('zero_point'): - yield zp - - def _inputs_qparam(self, type_str): - if type_str not in ['scale', 'zero_point']: - raise ValueError('Unknown quantization parameter type') - if not self.preset_act_stats: - raise RuntimeError('Input quantization parameter iterators only available when activation stats were given') - for idx in range(self.num_inputs): - name = 'in_{0}_{1}'.format(idx, type_str) - yield getattr(self, name) - - def forward(self, *inputs): - if self.training: - raise RuntimeError(self.__class__.__name__ + " can only be used in eval mode") - device = inputs[0].device - for buffer_name, buffer in self._buffers.items(): - setattr(self, buffer_name, buffer.to(device)) - - in_scales, in_zero_points = self.get_inputs_quantization_params(*inputs) - - # Quantize inputs - inputs_q = [linear_quantize_clamp(input.data, scale, zp, - self.acts_min_q_val, self.acts_max_q_val, inplace=False) - for input, scale, zp in zip(inputs, in_scales, in_zero_points)] - - # Forward through wrapped module - accum = self.quantized_forward(*inputs_q) - - # Re-quantize accumulator to quantized output range - out_scale, out_zero_point = self.get_output_quantization_params(accum) - requant_scale, requant_zero_point = self.get_accum_to_output_re_quantization_params(out_scale, out_zero_point) - out_q = linear_quantize_clamp(accum.data, requant_scale, requant_zero_point, - self.acts_min_q_val, self.acts_max_q_val, inplace=True) - - if not self._dequant_out: - return torch.autograd.Variable(out_q) - - # De-quantize back to FP32 - out_f = linear_dequantize(out_q, out_scale, out_zero_point, inplace=True) - - return out_f - - def get_inputs_quantization_params(self, *inputs): - """ - Calculate input quantization parameters (scale and zero-point) - - Should be overridden by all subclasses - - :param inputs: Current input tensors passed to forward method - :return: Tuple of 2 lists - list of scales per input and list of zero-point per input - """ - raise NotImplementedError - - def quantized_forward(self, *inputs_q): - """ - Perform forward pass with quantized inputs and return quantized outputs - - :param inputs_q: Tensor (or list of tensors) with quantized input values - :return: Tensor with quantized output values - """ - raise NotImplementedError - - def get_output_quantization_params(self, accumulator): - """ - Calculate quantization parameters (scale and zero-point) for the output. - This is used for: - * Calculating the accumulator-to-output re-quantization parameters - (see get_accum_to_output_re_quantization_params) - * De-quantizing the output back to FP32 - - Should be overridden by all subclasses - - :param accumulator: Tensor with accumulator values - :return: Tuple of scale and zero-point - """ - raise NotImplementedError - - def get_accum_to_output_re_quantization_params(self, output_scale, output_zero_point): - """ - Calculate quantization parameters (scale and zero-point) for re-quantization, that is: - Converting the intermediate integer accumulator to the output range - - Should be overridden by all subclasses - - :param output_scale: Output scale factor - :param output_zero_point: Output zero-point - :return: Tuple of scale and zero-point - """ - raise NotImplementedError - - def extra_repr(self): - tmpstr = 'mode={0}, '.format(str(self.mode).split('.')[1]) - tmpstr += 'num_bits_acts={0}, num_bits_accum={1}, '.format(self.num_bits_acts, self.num_bits_accum) - tmpstr += 'clip_acts={0}, '.format(_enum_to_str(self.clip_acts)) - if self.clip_acts == ClipModeAI84.N_STD: - tmpstr += 'num_stds={} '.format(self.clip_n_stds) - tmpstr += 'scale_approx_mult_bits={}'.format(self.scale_approx_mult_bits) - tmpstr += '\npreset_activation_stats={0}'.format(self.preset_act_stats) - if self.preset_act_stats: - for idx, (in_scale, in_zp) in enumerate(zip(self.inputs_scales(), self.inputs_zero_points())): - tmpstr += '\nin_{i}_scale={sc}, in_{i}_zero_point={zp}'.format(i=idx, sc=in_scale.item(), - zp=in_zp.item()) - tmpstr += '\nout_scale={sc}, out_zero_point={zp}'.format(sc=self.output_scale.item(), - zp=self.output_zero_point.item()) - return tmpstr - - -class RangeLinearQuantAI84ParamLayerWrapper(RangeLinearQuantAI84Wrapper): - """ - Linear range-based quantization wrappers for layers with weights and bias (namely torch.nn.ConvNd and - torch.nn.Linear) - - Assume: - - x_q = round(scale_x * x_f) - zero_point_x - - Hence: - - x_f = 1/scale_x * x_q + zero_point_x - - (And the same for y_q, w_q and b_q) - - So, we get: (use "zp" as abbreviation for zero_point) - - y_f = x_f * w_f + b_f - - y_q = scale_y * y_f + zp_y = scale_y * (x_f * w_f + b_f) + zp_y = - - scale_y scale_x * scale_w - = ------------------- * ((x_q + zp_x) * (w_q + zp_w) + ------------------- * (b_q + zp_b)) + zp_y - scale_x * scale_w scale_b - - Args: - wrapped_module (torch.nn.Module): Module to be wrapped - num_bits_acts (int): Number of bits used for inputs and output quantization - num_bits_params (int): Number of bits used for parameters (weights and bias) quantization - num_bits_accum (int): Number of bits allocated for the accumulator of intermediate integer results - mode (LinearQuantAI84Mode): Quantization mode to use (symmetric / asymmetric-signed/unsigned) - clip_acts (ClipModeAI84): See RangeLinearQuantWrapper - per_channel_wts (bool): Enable quantization of weights using separate quantization parameters per - output channel - activation_stats (dict): See RangeLinearQuantWrapper - clip_n_stds (int): See RangeLinearQuantWrapper - scale_approx_mult_bits (int): See RangeLinearQuantWrapper - """ - def __init__(self, wrapped_module, num_bits_acts, num_bits_params, num_bits_accum=32, - mode=LinearQuantAI84Mode.SYMMETRIC, clip_acts=ClipModeAI84.NONE, per_channel_wts=False, activation_stats=None, - clip_n_stds=None, scale_approx_mult_bits=None, - global_scale=False, sat_val_scale=1.0, weight_stddev=None): - super(RangeLinearQuantAI84ParamLayerWrapper, self).__init__(wrapped_module, num_bits_acts, num_bits_accum, mode, - clip_acts, activation_stats, clip_n_stds, - scale_approx_mult_bits) - - if not isinstance(wrapped_module, (nn.Conv2d, nn.Linear)): - raise ValueError(self.__class__.__name__ + ' can wrap only Conv2D and Linear modules') - - self.num_bits_params = num_bits_params - self.per_channel_wts = per_channel_wts - - self.params_min_q_val, self.params_max_q_val = get_quantized_range( - num_bits_params, signed=mode != LinearQuantAI84Mode.ASYMMETRIC_UNSIGNED) - - # Quantize weights - overwrite FP32 weights - if not global_scale: - w_scale, w_zero_point = _get_quant_params_from_tensor(wrapped_module.weight, num_bits_params, self.mode, - per_channel=per_channel_wts) - scale = w_scale - else: - w_scale, w_zero_point = _get_quant_params_from_model(weight_stddev * sat_val_scale, - num_bits_params, self.mode) - # print('w_scale:', w_scale) - scale = w_scale - w_scale = torch.tensor(float(1.0)) - - self.register_buffer('w_scale', w_scale) - self.register_buffer('w_zero_point', w_zero_point) - linear_quantize_clamp_ai84(wrapped_module.weight.data, scale, self.w_zero_point, self.params_min_q_val, - self.params_max_q_val, inplace=True) - - device = self.w_scale.device - - if self.preset_act_stats: - self.in_0_scale = self.in_0_scale.to(device) - self.register_buffer('accum_scale', self.in_0_scale * self.w_scale) - if self.per_channel_wts: - self.accum_scale = self.accum_scale.squeeze(dim=-1) - else: - self.accum_scale = 1 - - # Quantize bias - self.has_bias = hasattr(wrapped_module, 'bias') and wrapped_module.bias is not None - if self.has_bias: - if self.preset_act_stats: - linear_quantize_clamp(wrapped_module.bias.data, self.accum_scale.squeeze(), 0, - self.accum_min_q_val, self.accum_max_q_val, inplace=True) - else: - if not global_scale: - b_scale, b_zero_point = _get_quant_params_from_tensor(wrapped_module.bias, num_bits_params, self.mode) - scale = b_scale - else: - b_scale, b_zero_point = _get_quant_params_from_model(weight_stddev * sat_val_scale, - num_bits_params, self.mode) - # print('b_scale:', b_scale) - scale = b_scale - b_scale = torch.tensor(float(1.0)) - - self.register_buffer('b_scale', b_scale) - self.register_buffer('b_zero_point', b_zero_point) - base_b_q = linear_quantize_clamp_ai84(wrapped_module.bias.data, scale, self.b_zero_point, - self.params_min_q_val, self.params_max_q_val) - # Dynamic ranges - save in auxiliary buffer, requantize each time based on dynamic input scale factor - self.register_buffer('base_b_q', base_b_q) - - def get_inputs_quantization_params(self, input): - if not self.preset_act_stats: - self.in_0_scale, self.in_0_zero_point = _get_quant_params_from_tensor( - input, self.num_bits_acts, self.mode, clip=self.clip_acts, - num_stds=self.clip_n_stds, scale_approx_mult_bits=self.scale_approx_mult_bits) - return [self.in_0_scale], [self.in_0_zero_point] - - def quantized_forward(self, input_q): - # See class documentation for quantized calculation details. - - if not self.preset_act_stats: - self.accum_scale = self.in_0_scale * self.w_scale - if self.per_channel_wts: - self.accum_scale = self.accum_scale.squeeze(dim=-1) - - if self.has_bias: - # Re-quantize bias to match x * w scale: b_q' = (in_scale * w_scale / b_scale) * (b_q + b_zero_point) - bias_requant_scale = self.accum_scale.squeeze() / self.b_scale - if self.scale_approx_mult_bits is not None: - bias_requant_scale = approx_scale_as_mult_and_shift(bias_requant_scale, self.scale_approx_mult_bits) - self.wrapped_module.bias.data = linear_quantize_clamp(self.base_b_q + self.b_zero_point, - bias_requant_scale, 0, - self.accum_min_q_val, self.accum_max_q_val) - - # Note the main terms within the summation is: - # (x_q + zp_x) * (w_q + zp_w) - # In a performance-optimized solution, we would expand the parentheses and perform the computation similar - # to what is described here: - # https://github.com/google/gemmlowp/blob/master/doc/low-precision.md#efficient-handling-of-offsets - # However, for now we're more concerned with simplicity rather than speed. So we'll just add the zero points - # to the input and weights and pass those to the wrapped model. Functionally, since at this point we're - # dealing solely with integer values, the results are the same either way. - - if self.mode != LinearQuantAI84Mode.SYMMETRIC: - input_q += self.in_0_zero_point - self.wrapped_module.weight.data += self.w_zero_point - - accum = self.wrapped_module.forward(input_q) - clamp(accum.data, self.accum_min_q_val, self.accum_max_q_val, inplace=True) - - if self.mode != LinearQuantAI84Mode.SYMMETRIC: - self.wrapped_module.weight.data -= self.w_zero_point - return accum - - def get_output_quantization_params(self, accumulator): - if self.preset_act_stats: - return self.output_scale, self.output_zero_point - - y_f = accumulator / self.accum_scale - return _get_quant_params_from_tensor(y_f, self.num_bits_acts, self.mode, clip=self.clip_acts, - num_stds=self.clip_n_stds, - scale_approx_mult_bits=self.scale_approx_mult_bits) - - def get_accum_to_output_re_quantization_params(self, output_scale, output_zero_point): - requant_scale = output_scale / self.accum_scale - if self.scale_approx_mult_bits is not None: - requant_scale = approx_scale_as_mult_and_shift(requant_scale, self.scale_approx_mult_bits) - return requant_scale, output_zero_point - - def extra_repr(self): - tmpstr = 'mode={0}, '.format(str(self.mode).split('.')[1]) - tmpstr += 'num_bits_acts={0}, num_bits_params={1}, num_bits_accum={2}, '.format(self.num_bits_acts, - self.num_bits_params, - self.num_bits_accum) - tmpstr += 'clip_acts={0}, '.format(_enum_to_str(self.clip_acts)) - if self.clip_acts == ClipModeAI84.N_STD: - tmpstr += 'num_stds={} '.format(self.clip_n_stds) - tmpstr += 'per_channel_wts={}, scale_approx_mult_bits={}'.format(self.per_channel_wts, - self.scale_approx_mult_bits) - tmpstr += '\npreset_activation_stats={0}'.format(self.preset_act_stats) - if self.per_channel_wts: - tmpstr += '\nw_scale=PerCh, w_zero_point=PerCh' - else: - tmpstr += '\nw_scale={0:.4f}, w_zero_point={1:.4f}'.format(self.w_scale.item(), self.w_zero_point.item()) - if self.preset_act_stats: - tmpstr += '\nin_scale={0:.4f}, in_zero_point={1:.4f}'.format(self.in_0_scale.item(), - self.in_0_zero_point.item()) - tmpstr += '\nout_scale={0:.4f}, out_zero_point={1:.4f}'.format(self.output_scale.item(), - self.output_zero_point.item()) - elif self.has_bias: - tmpstr += '\nbase_b_scale={0:.4f}, base_b_zero_point={1:.4f}'.format(self.b_scale.item(), - self.b_zero_point.item()) - return tmpstr - - -class NoStatsError(NotImplementedError): - pass - - -class RangeLinearQuantAI84ConcatWrapper(RangeLinearQuantAI84Wrapper): - def __init__(self, wrapped_module, num_bits_acts, mode=LinearQuantAI84Mode.SYMMETRIC, clip_acts=ClipModeAI84.NONE, - activation_stats=None, clip_n_stds=None, scale_approx_mult_bits=None): - if not isinstance(wrapped_module, distiller.modules.Concat): - raise ValueError(self.__class__.__name__ + ' can only wrap distiller.modules.Concat modules') - - if not activation_stats: - raise NoStatsError(self.__class__.__name__ + - ' must get activation stats, dynamic quantization not supported') - - super(RangeLinearQuantAI84ConcatWrapper, self).__init__(wrapped_module, num_bits_acts, mode=mode, - clip_acts=clip_acts, activation_stats=activation_stats, - clip_n_stds=clip_n_stds, - scale_approx_mult_bits=scale_approx_mult_bits) - - if self.preset_act_stats: - # For concatenation to make sense, we need to match all the inputs' scales, so we - # set a re-scale factor based on the preset output scale - for idx, in_scale in enumerate(self.inputs_scales()): - requant_scale = self.output_scale / in_scale - if self.scale_approx_mult_bits is not None: - requant_scale = approx_scale_as_mult_and_shift(requant_scale, self.scale_approx_mult_bits) - self.register_buffer('in_{0}_requant_scale'.format(idx), requant_scale) - - def inputs_requant_scales(self): - if not self.preset_act_stats: - raise RuntimeError('Input quantization parameter iterators only available when activation stats were given') - for idx in range(self.num_inputs): - name = 'in_{0}_requant_scale'.format(idx) - yield getattr(self, name) - - def get_inputs_quantization_params(self, *inputs): - return self.inputs_scales(), self.inputs_zero_points() - - def quantized_forward(self, *inputs_q): - # Re-quantize all inputs based to the same range (the output range) - inputs_re_q = [linear_quantize_clamp(input_q + zp, requant_scale, self.output_zero_point, - self.acts_min_q_val, self.acts_max_q_val, inplace=False) - for input_q, requant_scale, zp in zip(inputs_q, self.inputs_requant_scales(), - self.inputs_zero_points())] - return self.wrapped_module(*inputs_re_q) - - def get_output_quantization_params(self, accumulator): - return self.output_scale, self.output_zero_point - - def get_accum_to_output_re_quantization_params(self, output_scale, output_zero_point): - # Nothing to do here, since we already re-quantized in quantized_forward prior to the actual concatenation - return 1., 0. - - -class RangeLinearQuantAI84EltwiseAddWrapper(RangeLinearQuantAI84Wrapper): - def __init__(self, wrapped_module, num_bits_acts, mode=LinearQuantAI84Mode.SYMMETRIC, clip_acts=ClipModeAI84.NONE, - activation_stats=None, clip_n_stds=None, scale_approx_mult_bits=None): - if not isinstance(wrapped_module, distiller.modules.EltwiseAdd): - raise ValueError(self.__class__.__name__ + ' can only wrap distiller.modules.EltwiseAdd modules') - - if not activation_stats: - raise NoStatsError(self.__class__.__name__ + - ' must get activation stats, dynamic quantization not supported') - - super(RangeLinearQuantAI84EltwiseAddWrapper, self).__init__(wrapped_module, num_bits_acts, mode=mode, - clip_acts=clip_acts, activation_stats=activation_stats, - clip_n_stds=clip_n_stds, - scale_approx_mult_bits=scale_approx_mult_bits) - - if self.preset_act_stats: - # For addition to make sense, all input scales must match. So we set a re-scale factor according - # to the preset output scale - requant_scales = [self.output_scale / in_scale for in_scale in self.inputs_scales()] - if scale_approx_mult_bits is not None: - requant_scales = [approx_scale_as_mult_and_shift(requant_scale, scale_approx_mult_bits) - for requant_scale in requant_scales] - for idx, requant_scale in enumerate(requant_scales): - self.register_buffer('in_{0}_requant_scale'.format(idx), requant_scale) - - def inputs_requant_scales(self): - if not self.preset_act_stats: - raise RuntimeError('Input quantization parameter iterators only available when activation stats were given') - for idx in range(self.num_inputs): - name = 'in_{0}_requant_scale'.format(idx) - yield getattr(self, name) - - def get_inputs_quantization_params(self, *inputs): - return self.inputs_scales(), self.inputs_zero_points() - - def quantized_forward(self, *inputs_q): - # Re-scale inputs to the accumulator range - inputs_re_q = [linear_quantize_clamp(input_q + zp, requant_scale, 0, - self.accum_min_q_val, self.accum_max_q_val, inplace=False) - for input_q, requant_scale, zp in zip(inputs_q, self.inputs_requant_scales(), - self.inputs_zero_points())] - accum = self.wrapped_module(*inputs_re_q) - clamp(accum.data, self.accum_min_q_val, self.accum_max_q_val, inplace=True) - - return accum - - def get_output_quantization_params(self, accumulator): - return self.output_scale, self.output_zero_point - - def get_accum_to_output_re_quantization_params(self, output_scale, output_zero_point): - return 1., self.output_zero_point - - -class RangeLinearQuantAI84EltwiseMultWrapper(RangeLinearQuantAI84Wrapper): - def __init__(self, wrapped_module, num_bits_acts, mode=LinearQuantAI84Mode.SYMMETRIC, clip_acts=ClipModeAI84.NONE, - activation_stats=None, clip_n_stds=None, scale_approx_mult_bits=None): - if not isinstance(wrapped_module, distiller.modules.EltwiseMult): - raise ValueError(self.__class__.__name__ + ' can only wrap distiller.modules.EltwiseMult modules') - - if not activation_stats: - raise NoStatsError(self.__class__.__name__ + - ' must get activation stats, dynamic quantization not supported') - - super(RangeLinearQuantAI84EltwiseMultWrapper, self).__init__(wrapped_module, num_bits_acts, mode=mode, - clip_acts=clip_acts, activation_stats=activation_stats, - clip_n_stds=clip_n_stds, - scale_approx_mult_bits=scale_approx_mult_bits) - - if self.preset_act_stats: - self.register_buffer('accum_scale', reduce(lambda x, y: x * y, self.inputs_scales())) - - def get_inputs_quantization_params(self, *inputs): - return self.inputs_scales(), self.inputs_zero_points() - - def quantized_forward(self, *inputs_q): - if self.mode != LinearQuantAI84Mode.SYMMETRIC: - for input_q, zp in zip(inputs_q, self.inputs_zero_points()): - input_q += zp - - accum = self.wrapped_module(*inputs_q) - clamp(accum.data, self.accum_min_q_val, self.accum_max_q_val, inplace=True) - - return accum - - def get_output_quantization_params(self, accumulator): - return self.output_scale, self.output_zero_point - - def get_accum_to_output_re_quantization_params(self, output_scale, output_zero_point): - requant_scale = output_scale / self.accum_scale - if self.scale_approx_mult_bits is not None: - requant_scale = approx_scale_as_mult_and_shift(requant_scale, self.scale_approx_mult_bits) - return requant_scale, output_zero_point - - -class Int8Wrapper(nn.Module): - """ - A wrapper that replaces a module with a int8 precision version. - - Args: - module (nn.Module): The module to be replaced. - convert_input (:obj:`bool`, optional): Specifies whether an input conversion - to int8 is required for forward. Default: True. - return_fp32 (:obj:`bool`, optional): Specifies whether the output needs - to be converted back to fp32. Default: True. - """ - def __init__(self, module: nn.Module, convert_input=True, return_fp32=True): - super(Int8Wrapper, self).__init__() - self.wrapped_module = module.type(torch.float8) - self.return_fp32 = return_fp32 - self.convert_input_int8 = convert_input - - def forward(self, *input): - if self.convert_input_int8: - input = distiller.convert_tensors_recursively_to(input, dtype=torch.float8) - - result = self.wrapped_module(*input) - if self.return_fp32: - return distiller.convert_tensors_recursively_to(result, dtype=torch.float32) - - return result - - -class RangeLinearAI84EmbeddingWrapper(nn.Module): - def __init__(self, wrapped_module, num_bits, mode=LinearQuantAI84Mode.SYMMETRIC, stats=None): - if not isinstance(wrapped_module, nn.Embedding): - raise ValueError(self.__class__.__name__ + ' can only wrap torch.nn.Embedding modules') - - super(RangeLinearAI84EmbeddingWrapper, self).__init__() - - self.min_q_val, self.max_q_val = get_quantized_range(num_bits, - signed=mode != LinearQuantAI84Mode.ASYMMETRIC_UNSIGNED) - - if stats is None: - w_scale, w_zero_point = _get_quant_params_from_tensor(wrapped_module.weight, num_bits, self.mode) - else: - w_scale, w_zero_point = _get_quant_params_from_stats_dict(stats['output'], num_bits, mode) - - device = wrapped_module.weight.device - - self.register_buffer('w_scale', w_scale.to(device)) - self.register_buffer('w_zero_point', w_zero_point.to(device)) - linear_quantize_clamp(wrapped_module.weight.data, self.w_scale, self.w_zero_point, self.min_q_val, - self.max_q_val, inplace=True) - - self.wrapped_module = wrapped_module - - def forward(self, input): - out_q = self.wrapped_module(input) - out_f = linear_dequantize(out_q, self.w_scale, self.w_zero_point, inplace=True) - return out_f - - -class PostTrainLinearQuantizerAI84(Quantizer): - """ - Applies range-based linear quantization to a model. - This quantizer is expected to be executed at evaluation only, on a pre-trained model - Currently, the following Modules are supported: torch.nn.Conv2d, torch.nn.Linear - - Args: - model (torch.nn.Module): Model to be quantized - bits_activations/parameters/accum (int): Number of bits to be used when quantizing each tensor type - overrides (:obj:`OrderedDict`, optional): Overrides the layers quantization settings. - mode (LinearQuantAI84Mode): Quantization mode to use (symmetric / asymmetric-signed / unsigned) - clip_acts (ClipModeAI84): Activations clipping mode to use - no_clip_layers (list): List of fully-qualified layer names for which activations clipping should not be done. - A common practice is to not clip the activations of the last layer before softmax. - Applicable only if clip_acts is True. - per_channel_wts (bool): Enable quantization of weights using separate quantization parameters per - output channel - model_activation_stats (str / dict / OrderedDict): Either a path to activation stats YAML file, or a dictionary - containing the stats. The stats are used for static calculation of quantization parameters. - The dict should be in the format exported by distiller.data_loggers.QuantCalibrationStatsCollector. - If None then parameters are calculated dynamically. - int8 (bool): Set to True to convert modules to int8 precision. - clip_n_stds (float): When clip_acts == ClipModeAI84.N_STD, this is the number of standard deviations to use - scale_approx_mult_bits (int): If not None, scale factors will be approximated using an integer multiplication - followed by a bit-wise shift. This eliminates floating-point scale factors, replacing them with integer - calculations. - If None, scale factors will be kept in their original FP32 values. - Note: - If int8 is set to True, all the layers (except those overridden in `overrides`) will be converted - to int8 precision, regardless of bits_activations/parameters/accum. - """ - def __init__(self, model, bits_activations=8, bits_parameters=8, bits_accum=32, - overrides=None, mode=LinearQuantAI84Mode.SYMMETRIC, clip_acts=ClipModeAI84.NONE, no_clip_layers=None, - per_channel_wts=False, model_activation_stats=None, int8=False, clip_n_stds=None, - scale_approx_mult_bits=None, global_scale=False, sat_val_scale=1.0): - super(PostTrainLinearQuantizerAI84, self).__init__(model, bits_activations=bits_activations, - bits_weights=bits_parameters, bits_bias=bits_accum, - overrides=overrides, train_with_fp_copy=False) - - mode = verify_quant_mode(mode) - clip_acts = verify_clip_mode(clip_acts) - if clip_acts == ClipModeAI84.N_STD and clip_n_stds is None: - raise ValueError('clip_n_stds must not be None when clip_acts set to N_STD') - - if model_activation_stats is not None: - if isinstance(model_activation_stats, str): - if not os.path.isfile(model_activation_stats): - raise ValueError("Model activation stats file not found at: " + model_activation_stats) - msglogger.info('Loading activation stats from: ' + model_activation_stats) - with open(model_activation_stats, 'r') as stream: - model_activation_stats = distiller.utils.yaml_ordered_load(stream) - elif not isinstance(model_activation_stats, (dict, OrderedDict)): - raise TypeError('model_activation_stats must either be a string, a dict / OrderedDict or None') - - # Get min/max weight/bias from model - with torch.no_grad(): - self.weight_min = torch.tensor(float('inf')) - self.weight_max = torch.tensor(float('-inf')) - self.weight_count = torch.tensor(0, dtype=torch.int) - self.weight_sum = torch.tensor(0.0) - self.weight_stddev = torch.tensor(0.0) - - def traverse_pass1(m): - """ - Traverse model to build weight stats - """ - if isinstance(m, nn.Conv2d): - device = m.weight.device - self.weight_min = torch.min(torch.min(m.weight), self.weight_min.to(device)) - self.weight_max = torch.max(torch.max(m.weight), self.weight_max.to(device)) - self.weight_count = self.weight_count.to(device) - self.weight_sum = self.weight_sum.to(device) - self.weight_count += len(m.weight.flatten()) - self.weight_sum += m.weight.flatten().sum() - if hasattr(m, 'bias') and m.bias is not None: - self.weight_min = torch.min(torch.min(m.bias), self.weight_min) - self.weight_max = torch.max(torch.max(m.bias), self.weight_max) - self.weight_count += len(m.bias.flatten()) - self.weight_sum += m.bias.flatten().sum() - - def traverse_pass2(m): - """ - Traverse model to build weight stats - """ - if isinstance(m, nn.Conv2d): - self.weight_stddev += ((m.weight.flatten() - self.weight_mean) ** 2).sum() - if hasattr(m, 'bias') and m.bias is not None: - self.weight_stddev += ((m.bias.flatten() - self.weight_mean) ** 2).sum() - - model.apply(traverse_pass1) - - self.weight_mean = self.weight_sum / self.weight_count - - model.apply(traverse_pass2) - - self.weight_stddev = torch.sqrt(self.weight_stddev / self.weight_count) - - print(f"Total weights: {self.weight_count} --> min: {self.weight_min}, max: {self.weight_max}, " - f"stddev: {self.weight_stddev}") - - self.model.quantizer_metadata = {'type': type(self), - 'params': {'bits_activations': bits_activations, - 'bits_parameters': bits_parameters, - 'bits_accum': bits_accum, - 'mode': str(mode).split('.')[1], - 'clip_acts': _enum_to_str(clip_acts), - 'clip_n_stds': clip_n_stds, - 'no_clip_layers': no_clip_layers, - 'per_channel_wts': per_channel_wts, - 'int8': int8, - 'scale_approx_mult_bits': scale_approx_mult_bits, - 'global_scale': global_scale, - 'sat_val_scale': sat_val_scale}} - - def replace_param_layer(module, name, qbits_map, per_channel_wts=per_channel_wts, - mode=mode, int8=int8, scale_approx_mult_bits=scale_approx_mult_bits, - global_scale=global_scale, - weight_min=self.weight_min, weight_max=self.weight_max, - weight_stddev=self.weight_stddev): - if int8: - return Int8Wrapper(module) - norm_name = distiller.utils.normalize_module_name(name) - clip = self.clip_acts if norm_name not in self.no_clip_layers else ClipModeAI84.NONE - return RangeLinearQuantAI84ParamLayerWrapper(module, qbits_map[name].acts, qbits_map[name].wts, - num_bits_accum=self.bits_accum, mode=mode, clip_acts=clip, - per_channel_wts=per_channel_wts, - activation_stats=self.model_activation_stats.get(norm_name, None), - clip_n_stds=clip_n_stds, - scale_approx_mult_bits=scale_approx_mult_bits, - global_scale=global_scale, - sat_val_scale=sat_val_scale, - weight_stddev=weight_stddev) - - def replace_non_param_layer(wrapper_type, module, name, qbits_map, int8=int8, - scale_approx_mult_bits=scale_approx_mult_bits): - if int8: - return Int8Wrapper(module) - norm_name = distiller.utils.normalize_module_name(name) - clip = self.clip_acts if norm_name not in self.no_clip_layers else ClipModeAI84.NONE - try: - return wrapper_type(module, qbits_map[name].acts, mode=mode, clip_acts=clip, - activation_stats=self.model_activation_stats.get(norm_name, None), - clip_n_stds=clip_n_stds, scale_approx_mult_bits=scale_approx_mult_bits) - except NoStatsError: - msglogger.warning('WARNING: {0} - quantization of {1} without stats not supported. ' - 'Keeping the original FP32 module'.format(name, module.__class__.__name__)) - return module - - def replace_embedding(module, name, qbits_map, int8=int8): - if int8: - return Int8Wrapper(module, convert_input=False) - norm_name = distiller.utils.normalize_module_name(name) - return RangeLinearAI84EmbeddingWrapper(module, qbits_map[name].wts, mode=mode, - stats=self.model_activation_stats.get(norm_name, None)) - - self.clip_acts = clip_acts - self.no_clip_layers = no_clip_layers or [] - self.clip_n_stds = clip_n_stds - self.model_activation_stats = model_activation_stats or {} - self.bits_accum = bits_accum - self.mode = mode - # self.model = model - - self.replacement_factory[nn.Conv2d] = replace_param_layer - self.replacement_factory[nn.Linear] = replace_param_layer - - self.replacement_factory[distiller.modules.Concat] = partial( - replace_non_param_layer, RangeLinearQuantAI84ConcatWrapper) - self.replacement_factory[distiller.modules.EltwiseAdd] = partial( - replace_non_param_layer, RangeLinearQuantAI84EltwiseAddWrapper) - self.replacement_factory[distiller.modules.EltwiseMult] = partial( - replace_non_param_layer, RangeLinearQuantAI84EltwiseMultWrapper) - self.replacement_factory[nn.Embedding] = replace_embedding - - @classmethod - def from_args(cls, model, args): - """ - Returns an instance of PostTrainLinearQuantizerAI84 based on the set command-line arguments that are - given by add_post_train_quant_args() - """ - if args.qe_config_file: - return config_component_from_file_by_class(model, args.qe_config_file, - 'PostTrainLinearQuantizerAI84') - else: - return cls(model, - bits_activations=args.qe_bits_acts, - bits_parameters=args.qe_bits_wts, - bits_accum=args.qe_bits_accum, - mode=args.qe_mode, - clip_acts=args.qe_clip_acts, - no_clip_layers=args.qe_no_clip_layers, - per_channel_wts=args.qe_per_channel, - model_activation_stats=args.qe_stats_file, - clip_n_stds=args.qe_clip_n_stds, - scale_approx_mult_bits=args.qe_scale_approx_bits) - - -############################################################################### -# Quantization-aware training -############################################################################### - - -def update_ema(biased_ema, value, decay, step): - biased_ema = biased_ema * decay + (1 - decay) * value - unbiased_ema = biased_ema / (1 - decay ** step) # Bias correction - return biased_ema, unbiased_ema - - -def inputs_quantize_wrapped_forward(self, input): - input = self.inputs_quant(input) - return self.original_forward(input) - - -class FakeLinearQuantizationAI84(nn.Module): - def __init__(self, num_bits=8, mode=LinearQuantAI84Mode.SYMMETRIC, ema_decay=0.999, dequantize=True, inplace=False): - super(FakeLinearQuantizationAI84, self).__init__() - - self.num_bits = num_bits - self.mode = mode - self.dequantize = dequantize - self.inplace = inplace - - # We track activations ranges with exponential moving average, as proposed by Jacob et al., 2017 - # https://arxiv.org/abs/1712.05877 - # We perform bias correction on the EMA, so we keep both unbiased and biased values and the iterations count - # For a simple discussion of this see here: - # https://www.coursera.org/lecture/deep-neural-network/bias-correction-in-exponentially-weighted-averages-XjuhD - self.register_buffer('ema_decay', torch.tensor(ema_decay)) - self.register_buffer('tracked_min_biased', torch.zeros(1)) - self.register_buffer('tracked_min', torch.zeros(1)) - self.register_buffer('tracked_max_biased', torch.zeros(1)) - self.register_buffer('tracked_max', torch.zeros(1)) - self.register_buffer('iter_count', torch.zeros(1)) - self.register_buffer('scale', torch.ones(1)) - self.register_buffer('zero_point', torch.zeros(1)) - - def forward(self, input): - # We update the tracked stats only in training - # - # Due to the way DataParallel works, we perform all updates in-place so the "main" device retains - # its updates. (see https://pytorch.org/docs/stable/nn.html#dataparallel) - # However, as it is now, the in-place update of iter_count causes an error when doing - # back-prop with multiple GPUs, claiming a variable required for gradient calculation has been modified - # in-place. Not clear why, since it's not used in any calculations that keep a gradient. - # It works fine with a single GPU. TODO: Debug... - if self.training: - with torch.no_grad(): - current_min, current_max = get_tensor_min_max(input) - self.iter_count += 1 - self.tracked_min_biased.data, self.tracked_min.data = update_ema(self.tracked_min_biased.data, - current_min, self.ema_decay, - self.iter_count) - self.tracked_max_biased.data, self.tracked_max.data = update_ema(self.tracked_max_biased.data, - current_max, self.ema_decay, - self.iter_count) - - if self.mode == LinearQuantAI84Mode.SYMMETRIC: - max_abs = max(abs(self.tracked_min), abs(self.tracked_max)) - actual_min, actual_max = -max_abs, max_abs - if self.training: - self.scale.data, self.zero_point.data = symmetric_linear_quantization_params(self.num_bits, max_abs) - else: - actual_min, actual_max = self.tracked_min, self.tracked_max - signed = self.mode == LinearQuantAI84Mode.ASYMMETRIC_SIGNED - if self.training: - self.scale.data, self.zero_point.data = asymmetric_linear_quantization_params(self.num_bits, - self.tracked_min, - self.tracked_max, - signed=signed) - - input = clamp(input, actual_min.item(), actual_max.item(), False) - input = LinearQuantizeSTE.apply(input, self.scale, self.zero_point, self.dequantize, False) - - return input - - def extra_repr(self): - mode_str = str(self.mode).split('.')[1] - return 'mode={0}, num_bits={1}, ema_decay={2:.4f})'.format(mode_str, self.num_bits, self.ema_decay) - - -class FakeQuantizationAI84Wrapper(nn.Module): - def __init__(self, wrapped_module, num_bits, quant_mode, ema_decay): - super(FakeQuantizationAI84Wrapper, self).__init__() - self.wrapped_module = wrapped_module - self.fake_q = FakeLinearQuantizationAI84(num_bits, quant_mode, ema_decay, dequantize=True, - inplace=getattr(wrapped_module, 'inplace', False)) - - def forward(self, *input): - res = self.wrapped_module(*input) - res = self.fake_q(res) - return res - - -class QuantAwareTrainRangeLinearQuantizerAI84(Quantizer): - def __init__(self, model, optimizer=None, bits_activations=32, bits_weights=32, bits_bias=32, - overrides=None, mode=LinearQuantAI84Mode.SYMMETRIC, ema_decay=0.999, per_channel_wts=False, - quantize_inputs=True, num_bits_inputs=None): - super(QuantAwareTrainRangeLinearQuantizerAI84, self).__init__(model, optimizer=optimizer, - bits_activations=bits_activations, - bits_weights=bits_weights, - bits_bias=bits_bias, - overrides=overrides, - train_with_fp_copy=True) - - if isinstance(model, nn.DataParallel) and len(model.device_ids) > 1: - raise RuntimeError('QuantAwareTrainRangeLinearQuantizerAI84 currently does not support running with ' - 'multiple GPUs') - - mode = verify_quant_mode(mode) - - self.model.quantizer_metadata['params']['mode'] = str(mode).split('.')[1] - self.model.quantizer_metadata['params']['ema_decay'] = ema_decay - self.model.quantizer_metadata['params']['per_channel_wts'] = per_channel_wts - self.model.quantizer_metadata['params']['quantize_inputs'] = quantize_inputs - - # Keeping some parameters for input quantization - self.quantize_inputs = quantize_inputs - if num_bits_inputs is not None: - self.num_bits_inputs = num_bits_inputs - else: - self.num_bits_inputs = bits_activations - self.mode = mode - self.decay = ema_decay - self.per_channel_wts = per_channel_wts - - def linear_quantize_param(param_fp, param_meta): - m = param_meta.module - # We don't quantize the learned weights of embedding layers per-channel, because they're used - # as inputs in subsequent layers and we don't support per-channel activations quantization yet - perch = not isinstance(m, nn.Embedding) and per_channel_wts and param_fp.dim() in [2, 4] - - with torch.no_grad(): - scale, zero_point = _get_quant_params_from_tensor(param_fp, param_meta.num_bits, mode, - per_channel=perch) - setattr(m, param_meta.q_attr_name + '_scale', scale) - setattr(m, param_meta.q_attr_name + '_zero_point', zero_point) - out = LinearQuantizeSTE.apply(param_fp, scale, zero_point, True, False) - return out - - def activation_replace_fn(module, name, qbits_map): - bits_acts = qbits_map[name].acts - if bits_acts is None: - return module - return FakeQuantizationAI84Wrapper(module, bits_acts, mode, ema_decay) - - self.param_quantization_fn = linear_quantize_param - - self.activation_replace_fn = activation_replace_fn - self.replacement_factory[nn.ReLU] = self.activation_replace_fn - - def _prepare_model_impl(self): - super(QuantAwareTrainRangeLinearQuantizerAI84, self)._prepare_model_impl() - - if self.quantize_inputs: - if isinstance(self.model, nn.DataParallel): - m = self.model.module - else: - m = self.model - - m.inputs_quant = FakeLinearQuantizationAI84(self.num_bits_inputs, self.mode, self.decay, - dequantize=True, inplace=False) - m.__class__.original_forward = m.__class__.forward - m.__class__.forward = inputs_quantize_wrapped_forward - - # Prepare scale and zero point buffers in modules where parameters are being quantized - # We're calculating "dummy" scale and zero point just to get their dimensions - for ptq in self.params_to_quantize: - m = ptq.module - param_fp = getattr(m, ptq.fp_attr_name) - perch = not isinstance(m, nn.Embedding) and self.per_channel_wts and param_fp.dim() in [2, 4] - with torch.no_grad(): - scale, zero_point = _get_quant_params_from_tensor(param_fp, ptq.num_bits, self.mode, - per_channel=perch) - m.register_buffer(ptq.q_attr_name + '_scale', torch.ones_like(scale)) - m.register_buffer(ptq.q_attr_name + '_zero_point', torch.zeros_like(zero_point)) - - -def config_component_from_file_by_class(model, filename, class_name, **extra_args): - with open(filename, 'r') as stream: - msglogger.info('Reading configuration from: %s', filename) - try: - config_dict = distiller.utils.yaml_ordered_load(stream) - config_dict.pop('policies', None) - for section_name, components in config_dict.items(): - for component_name, user_args in components.items(): - if user_args['class'] == class_name: - msglogger.info( - 'Found component of class {0}: Name: {1} ; Section: {2}'.format(class_name, component_name, - section_name)) - user_args.update(extra_args) - return build_component(model, component_name, user_args) - raise ValueError( - 'Component of class {0} does not exist in configuration file {1}'.format(class_name, filename)) - except yaml.YAMLError: - print("\nFATAL parsing error while parsing the configuration file %s" % filename) - raise - - -def build_component(model, name, user_args, **extra_args): - # Instantiate component using the 'class' argument - class_name = user_args.pop('class') - try: - class_ = globals()[class_name] - except KeyError as ex: - raise ValueError("Class named '{0}' does not exist".format(class_name)) from ex - - # First we check that the user defined dict itself does not contain invalid args - valid_args, invalid_args = filter_kwargs(user_args, class_.__init__) - if invalid_args: - raise ValueError( - '{0} does not accept the following arguments: {1}'.format(class_name, list(invalid_args.keys()))) - - # Now we add some "hard-coded" args, which some classes may accept and some may not - # So then we filter again, this time ignoring any invalid args - valid_args.update(extra_args) - valid_args['model'] = model - valid_args['name'] = name - final_valid_args, _ = filter_kwargs(valid_args, class_.__init__) - instance = class_(**final_valid_args) - return instance diff --git a/attic/train_afsk.sh b/attic/train_afsk.sh deleted file mode 100755 index 087e31037..000000000 --- a/attic/train_afsk.sh +++ /dev/null @@ -1,2 +0,0 @@ -#!/bin/bash -python3 train.py --epochs 100 --deterministic --compress schedule-afsk.yaml --model ai85afsknet --dataset AFSK --confusion --device MAX78000 --embedding "$@" diff --git a/attic/train_cifar10_bias.sh b/attic/train_cifar10_bias.sh deleted file mode 100755 index 7d903bf79..000000000 --- a/attic/train_cifar10_bias.sh +++ /dev/null @@ -1,2 +0,0 @@ -#!/bin/sh -python3 train.py --epochs 200 --deterministic --compress schedule.yaml --model ai84net5 --dataset CIFAR10 --confusion --use-bias --param-hist "$@" diff --git a/datasets/aisegment.py b/datasets/aisegment.py index 2380736c9..c998c433f 100644 --- a/datasets/aisegment.py +++ b/datasets/aisegment.py @@ -1,10 +1,9 @@ ################################################################################################### # # Copyright (C) 2021-2023 Maxim Integrated Products, Inc. All Rights Reserved. +# Copyright (C) 2024 Analog Devices, Inc. All Rights Reserved. # -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# +# This software is proprietary to Analog Devices, Inc. and its licensors. ################################################################################################### """ Classes and functions used to create AISegment dataset. @@ -242,7 +241,8 @@ def __check_pkl_files_exist(self): if os.path.exists(self.processed_folder_path) and \ os.path.isdir(self.processed_folder_path): - pkl_files = [f for f in os.listdir(self.processed_folder_path) if f.endswith('.pkl')] + pkl_files = [f for f in sorted(os.listdir(self.processed_folder_path)) + if f.endswith('.pkl')] else: pkl_files = [] return len(pkl_files) > 0 diff --git a/datasets/cbm_dataframe_parser.py b/datasets/cbm_dataframe_parser.py new file mode 100644 index 000000000..7991dbc2a --- /dev/null +++ b/datasets/cbm_dataframe_parser.py @@ -0,0 +1,427 @@ +################################################################################################### +# +# Copyright (C) 2024 Analog Devices, Inc. All Rights Reserved. +# This software is proprietary to Analog Devices, Inc. and its licensors. +# +################################################################################################### +""" +Main classes and functions for Motor Data Dataset +""" +import math +import os +import pickle + +import numpy as np +import torch +from numpy.fft import fft +from torch.utils.data import Dataset + +import pandas as pd +import scipy + +from utils.dataloader_utils import makedir_exist_ok + + +class CbM_DataFrame_Parser(Dataset): # pylint: disable=too-many-instance-attributes + """ + The base dataset class for motor vibration data used in Condition Based Monitoring. + Includes main preprocessing functions. + Expects a dataframe with common_dataframe_columns. + """ + + common_dataframe_columns = ["file_identifier", "raw_data_vib_in_g", "sensor_sr_Hz", + "speed", "load", "label"] + + @staticmethod + def sliding_windows_1d(array, window_size, overlap_ratio): + """ + One dimensional array is windowed and returned + in window_size length according to overlap ratio. + """ + + window_overlap = math.ceil(window_size * overlap_ratio) + + slide_amount = window_size - window_overlap + num_of_windows = math.floor((len(array) - window_size) / slide_amount) + 1 + + result_list = np.zeros((num_of_windows, window_size)) + + for i in range(num_of_windows): + start_idx = slide_amount * i + end_idx = start_idx + window_size + result_list[i] = array[start_idx:end_idx] + + return result_list + + @staticmethod + def sliding_windows_on_columns_of_2d(array, window_size, overlap_ratio): + """ + Two dimensional array is windowed and returned + in window_size length according to overlap ratio. + """ + + array_len, num_of_cols = array.shape + + window_overlap = math.ceil(window_size * overlap_ratio) + slide_amount = window_size - window_overlap + num_of_windows = math.floor((array_len - window_size) / slide_amount) + 1 + + result_list = np.zeros((num_of_cols, num_of_windows, window_size)) + + for i in range(num_of_cols): + result_list[i, :, :] = CbM_DataFrame_Parser.sliding_windows_1d( + array[:, i], + window_size, overlap_ratio + ) + + return result_list + + @staticmethod + def split_file_raw_data(file_raw_data, file_raw_data_fs_in_Hz, duration_in_sec, overlap_ratio): + """ + Raw data is split into windowed data. + """ + + num_of_samples_per_window = int(file_raw_data_fs_in_Hz * duration_in_sec) + + sliding_windows = CbM_DataFrame_Parser.sliding_windows_on_columns_of_2d( + file_raw_data, + num_of_samples_per_window, + overlap_ratio + ) + + return sliding_windows + + def process_file_and_return_signal_windows(self, file_raw_data): + """ + Windowed signals are constructed from 2D raw data. + Fast Fourier Transform performed on these signals. + """ + + new_sampling_rate = int(self.selected_sensor_sr / self.downsampling_ratio) + + file_raw_data_sampled = scipy.signal.decimate(file_raw_data, + self.downsampling_ratio, axis=0) + + file_raw_data_windows = self.split_file_raw_data( + file_raw_data_sampled, + new_sampling_rate, + self.signal_duration_in_sec, + self.overlap_ratio + ) + + # First dimension: 3 + # Second dimension: number of windows + # Third dimension: Window for self.duration_in_sec. 1000 samples for default settings + num_features = file_raw_data_windows.shape[0] + num_windows = file_raw_data_windows.shape[1] + + fft_output_window_size = self.cnn_1dinput_len + + file_cnn_signals = np.zeros((num_features, num_windows, fft_output_window_size)) + + # Perform FFT on each window () for each feature + for window in range(num_windows): + for feature in range(num_features): + + signal_for_fft = file_raw_data_windows[feature, window, :] + + fft_out = abs(fft(signal_for_fft)) + fft_out = fft_out[:fft_output_window_size] + + fft_out[:self.num_start_zeros] = 0 + fft_out[-self.num_end_zeros:] = 0 + + file_cnn_signals[feature, window, :] = fft_out + + file_cnn_signals[:, window, :] = file_cnn_signals[:, window, :] / \ + np.sqrt(np.power(file_cnn_signals[:, window, :], 2).sum()) + + # Reshape from (num_features, num_windows, window_size) into: + # (num_windows, num_features, window_size) + file_cnn_signals = file_cnn_signals.transpose([1, 0, 2]) + + return file_cnn_signals + + def create_common_empty_df(self): + """ + Create empty dataframe + """ + df = pd.DataFrame(columns=self.common_dataframe_columns) + return df + + def __init__(self, root, d_type, + transform=None, + target_sampling_rate_Hz=2000, + signal_duration_in_sec=0.25, + overlap_ratio=0.75, + eval_mode=False, + label_as_signal=True, + random_or_speed_split=True, + speed_and_load_available=False, + num_end_zeros=10, + num_start_zeros=3, + train_ratio=0.8, + cnn_1dinput_len=256, + main_df=None + ): + + if d_type not in ('test', 'train'): + raise ValueError( + "d_type can only be set to 'test' or 'train'" + ) + + self.main_df = main_df + self.df_normals = self.main_df[main_df['label'] == 0] + self.df_anormals = self.main_df[main_df['label'] == 1] + + self.normal_speeds_Hz = list(set(self.df_normals['speed'])) + self.normal_speeds_Hz.sort() + self.normal_test_speeds = self.normal_speeds_Hz[1::5] + self.normal_train_speeds = list(set(self.normal_speeds_Hz) - set(self.normal_test_speeds)) + self.normal_train_speeds.sort() + + self.selected_sensor_sr = self.df_normals['sensor_sr_Hz'][0] + self.num_end_zeros = num_end_zeros + self.num_start_zeros = num_start_zeros + self.train_ratio = train_ratio + + self.root = root + self.d_type = d_type + self.transform = transform + + self.signal_duration_in_sec = signal_duration_in_sec + self.overlap_ratio = overlap_ratio + + self.eval_mode = eval_mode + self.label_as_signal = label_as_signal + + self.random_or_speed_split = random_or_speed_split + self.speed_and_load_available = speed_and_load_available + + self.num_of_features = 3 + + self.target_sampling_rate_Hz = target_sampling_rate_Hz + self.downsampling_ratio = round(self.selected_sensor_sr / + self.target_sampling_rate_Hz) + + self.cnn_1dinput_len = cnn_1dinput_len + + cnn_assert_message = "CNN input length is incorrect." + assert self.cnn_1dinput_len >= (self.target_sampling_rate_Hz * + self.signal_duration_in_sec)/2, cnn_assert_message + + if not isinstance(self.downsampling_ratio, int) or self.downsampling_ratio < 1: + raise ValueError( + "downsampling_ratio can only be set to an integer value greater than 0" + ) + + processed_folder = \ + os.path.join(root, self.__class__.__name__, 'processed') + + self.processed_folder = processed_folder + + makedir_exist_ok(self.processed_folder) + + self.specs_identifier = f'eval_mode_{self.eval_mode}_' + \ + f'label_as_signal_{self.label_as_signal}_' + \ + f'ds_{self.downsampling_ratio}_' + \ + f'dur_{self.signal_duration_in_sec}_' + \ + f'ovlp_ratio_{self.overlap_ratio}_' + \ + f'random_split_{self.random_or_speed_split}_' + + train_dataset_pkl_file_path = \ + os.path.join(self.processed_folder, f'train_{self.specs_identifier}.pkl') + + test_dataset_pkl_file_path = \ + os.path.join(self.processed_folder, f'test_{self.specs_identifier}.pkl') + + if self.d_type == 'train': + self.dataset_pkl_file_path = train_dataset_pkl_file_path + + elif self.d_type == 'test': + self.dataset_pkl_file_path = test_dataset_pkl_file_path + + self.signal_list = [] + self.lbl_list = [] + self.speed_list = [] + self.load_list = [] + + self.__create_pkl_files() + self.is_truncated = False + + def __create_pkl_files(self): + if os.path.exists(self.dataset_pkl_file_path): + + print('\nPickle files are already generated ...\n') + + (self.signal_list, self.lbl_list, self.speed_list, self.load_list) = \ + pickle.load(open(self.dataset_pkl_file_path, 'rb')) + return + + self.__gen_datasets() + + def normalize_signal(self, features): + """ + Normalize signal with Local Min Max Normalization + """ + # Normalize data: + for instance in range(features.shape[0]): + instance_max = np.max(features[instance, :, :], axis=1) + instance_min = np.min(features[instance, :, :], axis=1) + + for feature in range(features.shape[1]): + for signal in range(features.shape[2]): + features[instance, feature, signal] = ( + (features[instance, feature, signal] - instance_min[feature]) / + (instance_max[feature] - instance_min[feature]) + ) + + return features + + def __gen_datasets(self): + + train_features = [] + test_normal_features = [] + + train_speeds = [] + test_normal_speeds = [] + + train_loads = [] + test_normal_loads = [] + + for _, row in self.df_normals.iterrows(): + raw_data = row['raw_data_vib_in_g'] + cnn_signals = self.process_file_and_return_signal_windows(raw_data) + file_speed = row['speed'] + file_load = row['load'] + + if self.random_or_speed_split: + num_training = int(self.train_ratio * cnn_signals.shape[0]) + + for i in range(cnn_signals.shape[0]): + if i < num_training: + train_features.append(cnn_signals[i]) + train_speeds.append(file_speed) + train_loads.append(file_load) + else: + test_normal_features.append(cnn_signals[i]) + test_normal_speeds.append(file_speed) + test_normal_loads.append(file_load) + + else: + # split test-train using file identifiers and split + if file_speed in self.normal_train_speeds: + for i in range(cnn_signals.shape[0]): + train_features.append(cnn_signals[i]) + train_speeds.append(file_speed) + train_loads.append(file_load) + + else: # file_speed in normal_test_speeds + for i in range(cnn_signals.shape[0]): + test_normal_features.append(cnn_signals[i]) + test_normal_speeds.append(file_speed) + test_normal_loads.append(file_load) + + train_features = np.asarray(train_features) + test_normal_features = np.asarray(test_normal_features) + + anomaly_features = [] + test_anormal_speeds = [] + test_anormal_loads = [] + + for _, row in self.df_anormals.iterrows(): + raw_data = row['raw_data_vib_in_g'] + cnn_signals = self.process_file_and_return_signal_windows(raw_data) + file_speed = row['speed'] + file_load = row['load'] + + for i in range(cnn_signals.shape[0]): + anomaly_features.append(cnn_signals[i]) + test_anormal_speeds.append(file_speed) + test_anormal_loads.append(file_load) + + anomaly_features = np.asarray(anomaly_features) + + train_features = self.normalize_signal(train_features) + test_normal_features = self.normalize_signal(test_normal_features) + anomaly_features = self.normalize_signal(anomaly_features) + + # For eliminating filter effects + train_features[:, :, :self.num_start_zeros] = 0.5 + train_features[:, :, -self.num_end_zeros:] = 0.5 + + test_normal_features[:, :, :self.num_start_zeros] = 0.5 + test_normal_features[:, :, -self.num_end_zeros:] = 0.5 + + anomaly_features[:, :, :self.num_start_zeros] = 0.5 + anomaly_features[:, :, -self.num_end_zeros:] = 0.5 + + # ARRANGE TEST-TRAIN SPLIT AND LABELS + if self.d_type == 'train': + self.lbl_list = [train_features[i, :, :] for i in range(train_features.shape[0])] + self.signal_list = [torch.Tensor(label) for label in self.lbl_list] + self.lbl_list = list(self.signal_list) + self.speed_list = np.array(train_speeds) + self.load_list = np.array(train_loads) + + if not self.label_as_signal: + self.lbl_list = np.zeros([len(self.signal_list), 1]) + + elif self.d_type == 'test': + + # Testing in training phase includes only normal test samples + if not self.eval_mode: + test_data = test_normal_features + else: + test_data = np.concatenate((test_normal_features, anomaly_features), axis=0) + + self.lbl_list = [test_data[i, :, :] for i in range(test_data.shape[0])] + self.signal_list = [torch.Tensor(label) for label in self.lbl_list] + self.lbl_list = list(self.signal_list) + self.speed_list = np.concatenate((np.array(test_normal_speeds), + np.array(test_anormal_speeds))) + self.load_list = np.concatenate((np.array(test_normal_loads), + np.array(test_anormal_loads))) + + if not self.label_as_signal: + self.lbl_list = np.concatenate( + (np.zeros([len(test_normal_features), 1]), + np.ones([len(anomaly_features), 1])), axis=0) + # Save pickle file + pickle.dump((self.signal_list, self.lbl_list, self.speed_list, self.load_list), + open(self.dataset_pkl_file_path, 'wb')) + + def __len__(self): + if self.is_truncated: + return 1 + return len(self.signal_list) + + def __getitem__(self, index): + if index >= len(self): + raise IndexError + + if self.is_truncated: + index = 0 + + signal = self.signal_list[index] + lbl = self.lbl_list[index] + + if self.transform is not None: + signal = self.transform(signal) + + if self.label_as_signal: + lbl = self.transform(lbl) + + if not self.label_as_signal: + lbl = lbl.astype(np.long) + else: + lbl = lbl.numpy().astype(np.float32) + + if self.speed_and_load_available: + speed = self.speed_list[index] + load = self.load_list[index] + + return signal, lbl, speed, load + + return signal, lbl diff --git a/datasets/cifar.py b/datasets/cifar.py index 0663a2395..88469a2d9 100644 --- a/datasets/cifar.py +++ b/datasets/cifar.py @@ -1,13 +1,6 @@ -################################################################################################### # -# Copyright (C) 2018-2020 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -# -# Portions Copyright (c) 2018 Intel Corporation +# Copyright (c) 2018 Intel Corporation +# Portions Copyright (C) 2019-2023 Maxim Integrated Products, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/datasets/cifar100.py b/datasets/cifar100.py index aaef46b39..c41c60700 100644 --- a/datasets/cifar100.py +++ b/datasets/cifar100.py @@ -1,13 +1,6 @@ -################################################################################################### # -# Copyright (C) 2018-2020 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -# -# Portions Copyright (c) 2018 Intel Corporation +# Copyright (c) 2018 Intel Corporation +# Portions Copyright (C) 2019-2023 Maxim Integrated Products, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/datasets/face_id/README.md b/datasets/face_id/README.md deleted file mode 100644 index e14459abb..000000000 --- a/datasets/face_id/README.md +++ /dev/null @@ -1,41 +0,0 @@ -# FaceID Data Generation - -This folder contains scripts to generate data to train and test models for FaceID model using the following datasets: - - VGGFace-2: A large-scale face recognition dataset. [https://www.robots.ox.ac.uk/~vgg/data/](https://www.robots.ox.ac.uk/~vgg/data/) - - YouTubeFaces: A database of face videos designed for studying the problem of unconstrained face recognition. [https://www.cs.tau.ac.il/~wolf/ytfaces/](https://www.cs.tau.ac.il/~wolf/ytfaces/) - -## Dataset Generation - -### VGGFace-2 -**Warning:** The original dataset is about 40GB and the following scripts generate a new dataset with size of 183 GB. Be sure there is enough space on your hard drive before starting the execution. - -\ -Follow these steps for both train and test sets. -1. Download train and test the *VGG Face 2 Dataset* from [https://www.robots.ox.ac.uk/~vgg/data/](https://www.robots.ox.ac.uk/~vgg/data/) and extract the .tar.gz files. into the same folder. -2. Run gen_vggface2_embeddings.py: - ``` - python gen_vggface2_embeddings.py -r -d --type - ``` -3. Run merge_vggface2_dataset.py - ``` - python merge_vggface2_dataset.py -p --type - ``` - -### YouTubeFaces - -**Warning:** The original dataset is about 29GB and the following scripts generate a new dataset with size of 15 GB. Be sure there is enough space on your hard drive before starting the execution. - -\ -Follow these steps. -1. Download the dataset from [here](http://www.cslab.openu.ac.il/download/) and extract the tar.gz files. into the same folder. -2. Run gen_youtubefaces_embeddings.py: - ``` - python gen_youtubefaces_embeddings.py -r -d --type test - ``` -3. Run merge_youtubefaces_dataset.py - ``` - python merge_youtubefaces_dataset.py -p --type test - ``` - -**Note:** The default paths for generated dataset is set to AI8X_TRAINING_HOME/data so the data loaders can load them with default parameters. If the destination folder is changed, the ---data option should be added to the model training script. diff --git a/datasets/face_id/facenet_pytorch b/datasets/face_id/facenet_pytorch deleted file mode 160000 index c72fae839..000000000 --- a/datasets/face_id/facenet_pytorch +++ /dev/null @@ -1 +0,0 @@ -Subproject commit c72fae8398860d76a30f911cf944a9683bd14b21 diff --git a/datasets/face_id/gen_vggface2_embeddings.py b/datasets/face_id/gen_vggface2_embeddings.py deleted file mode 100755 index 95043a229..000000000 --- a/datasets/face_id/gen_vggface2_embeddings.py +++ /dev/null @@ -1,171 +0,0 @@ -#!/usr/bin/env python3 -################################################################################################### -# -# Copyright (C) 2020-2021 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -""" -Script to generate dataset for FaceID training and validation from VGGFace-2 dataset. -""" - -import argparse -import json -import os - -import numpy as np -import torch - -import scipy.ndimage -from facenet_pytorch import MTCNN, InceptionResnetV1 # pylint: disable=no-name-in-module -from matplotlib.image import imread - - -def generate_image(img, box, count): # pylint: disable=too-many-locals - """ - Generates images in size 120x160x3 that includes the detected face in the image. - - img, box are the original image and box. - count is how many pics you wanna generate - - box format: x1, y1, x3, y3 - """ - box[0] = np.max((box[0], 0)) - box[1] = np.max((box[1], 0)) - box[2] = np.min((box[2], img.shape[1])) - box[3] = np.min((box[3], img.shape[0])) - - factor = 1 - height = img.shape[0] - width = img.shape[1] - new_img = img - new_box = box - while True: - if height < 160 or width < 120: - factor += 1 - new_img = scipy.ndimage.zoom(img, [factor, factor, 1], order=1) - new_box = box * factor - height = new_img.shape[0] - width = new_img.shape[1] - else: - break - new_box = np.round(new_box).astype(np.int) - new_box_height = new_box[3] - new_box[1] - new_box_width = new_box[2] - new_box[0] - - scale_list = np.concatenate((np.arange(0.9, 0, -0.1), np.arange(0.09, 0, -0.02))) - ind = 0 - while (new_box_height > 160 or new_box_width > 120): - if ind < scale_list.size: - new_img = scipy.ndimage.zoom(img, [scale_list[ind], scale_list[ind], 1], order=1) - new_box = box * scale_list[ind] - new_box = np.round(new_box).astype(np.int) - new_box_height = new_box[3] - new_box[1] - new_box_width = new_box[2] - new_box[0] - ind += 1 - else: - pass - - min_x = np.max((0, new_box[0] - (120 - new_box_width))) - min_y = np.max((0, new_box[1] - (160 - new_box_height))) - max_x = np.min((new_box[0], width-120)) - max_y = np.min((new_box[1], height-160)) - - start_x = np.random.choice(np.arange(min_x, max_x+1), count, replace=True) - start_y = np.random.choice(np.arange(min_y, max_y+1), count, replace=True) - img_arr = [] - box_arr = [] - for i in range(count): - img_arr.append(new_img[start_y[i]:start_y[i]+160, start_x[i]:start_x[i]+120]) - temp_box = new_box.copy() - temp_box[0] -= start_x[i] - temp_box[2] -= start_x[i] - temp_box[1] -= start_y[i] - temp_box[3] -= start_y[i] - box_arr.append(temp_box) - new_img = img_arr - new_box = box_arr - return new_img, new_box, img, box - - -def main(source_path, dest_path): # pylint: disable=too-many-locals - """ - Main function to iterate over the images in the raw data and generate data samples - to train/test FaceID model. - """ - - device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') - print(f'Running on device: {device}') - - mtcnn = MTCNN( - image_size=80, margin=0, min_face_size=20, - thresholds=[0.6, 0.7, 0.7], factor=0.709, post_process=True, - device=device - ) - - resnet = InceptionResnetV1(pretrained='vggface2').eval().to(device) - - data_dir_list = os.listdir(source_path) - for i, folder in enumerate(data_dir_list): - if i % 10 == 0: - print(f'{i} of {len(data_dir_list)}') - folder_path = os.path.join(source_path, folder) - prcssd_folder_path = os.path.join(dest_path, folder) - if not os.path.exists(prcssd_folder_path): - os.makedirs(prcssd_folder_path) - else: - continue - embedding_dict = {} - for image in os.listdir(folder_path): - image_path = os.path.join(folder_path, image) - img = imread(image_path) - x_aligned, prob, box = mtcnn(img, return_prob=True) - if box is not None and prob > 0.9: - x_aligned = x_aligned[None, :] - x_aligned = x_aligned.to(device) - embeddings = resnet(x_aligned).detach().cpu() - embedding_list = embeddings.numpy().ravel().tolist() - img_arr, _, img, box = generate_image(img, box, 1) - for ind, new_img in enumerate(img_arr): - new_img_name = image+'_160_120_'+str(ind)+'.npy' - new_img_path = os.path.join(prcssd_folder_path, new_img_name) - np.save(new_img_path, new_img) - embedding_dict[new_img_name] = embedding_list - json_bin = json.dumps(embedding_dict) - with open( - os.path.join(prcssd_folder_path, 'embeddings.json'), - mode='w', - encoding='utf-8', - ) as out_file: - out_file.write(json_bin) - - -def parse_args(): - """Parses command line arguments""" - data_folder = os.path.abspath(__file__) - for _ in range(3): - data_folder = os.path.dirname(data_folder) - data_folder = os.path.join(data_folder, 'data') - - parser = argparse.ArgumentParser(description='Generate VGGFace-2 dataset to train/test \ - FaceID model.') - parser.add_argument('-r', '--raw', dest='raw_data_path', type=str, - default=os.path.join(data_folder, 'VGGFace-2', 'raw'), - help='Path to raw VGG-Face-2 dataset folder.') - parser.add_argument('-d', '--dest', dest='dest_data_path', type=str, - default=os.path.join(data_folder, 'VGGFace-2'), - help='Folder path to store processed data') - parser.add_argument('--type', dest='data_type', type=str, required=True, - help='Data type to generate (train/test)') - args = parser.parse_args() - - source_path = os.path.join(args.raw_data_path, args.data_type) - dest_path = os.path.join(args.dest_data_path, args.data_type, 'temp') - return source_path, dest_path - - -if __name__ == "__main__": - raw_data_path, dest_data_path = parse_args() - main(raw_data_path, dest_data_path) diff --git a/datasets/face_id/gen_youtubefaces_embeddings.py b/datasets/face_id/gen_youtubefaces_embeddings.py deleted file mode 100755 index 2d271c2c0..000000000 --- a/datasets/face_id/gen_youtubefaces_embeddings.py +++ /dev/null @@ -1,216 +0,0 @@ -#!/usr/bin/env python3 -################################################################################################### -# -# Copyright (C) 2020-2021 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -""" -Script to generate dataset for FaceID training and validation from YouTubeFaces dataset. -""" - -import argparse -import json -import os - -import numpy as np -import torch - -import scipy.ndimage -from facenet_pytorch import MTCNN, InceptionResnetV1 # pylint: disable=no-name-in-module -from matplotlib.image import imread - - -def generate_image(img, box, count): # pylint: disable=too-many-locals - """ - Generates images in size 120x160x3 that includes the detected face in the image. - - img, box are the original image and box. - count is how many pics you wanna generate - - box format: x1, y1, x3, y3 - """ - box[0] = np.max((box[0], 0)) - box[1] = np.max((box[1], 0)) - box[2] = np.min((box[2], img.shape[1])) - box[3] = np.min((box[3], img.shape[0])) - - factor = 1 - height = img.shape[0] - width = img.shape[1] - new_img = img - new_box = box - while True: - if height < 160 or width < 120: - factor += 1 - new_img = scipy.ndimage.zoom(img, [factor, factor, 1], order=1) - new_box = box * factor - height = new_img.shape[0] - width = new_img.shape[1] - else: - break - new_box = np.round(new_box).astype(np.int) - new_box_height = new_box[3] - new_box[1] - new_box_width = new_box[2] - new_box[0] - - scale_list = np.arange(0.9, 0, -0.1) - ind = 0 - while (new_box_height > 160 or new_box_width > 120): - new_img = scipy.ndimage.zoom(img, [scale_list[ind], scale_list[ind], 1], order=1) - new_box = box * scale_list[ind] - new_box = np.round(new_box).astype(np.int) - new_box_height = new_box[3] - new_box[1] - new_box_width = new_box[2] - new_box[0] - ind += 1 - - min_x = np.max((0, new_box[0] - (120 - new_box_width))) - min_y = np.max((0, new_box[1] - (160 - new_box_height))) - max_x = np.min((new_box[0], width-120)) - max_y = np.min((new_box[1], height-160)) - - start_x = np.random.choice(np.arange(min_x, max_x+1), count, replace=True) - start_y = np.random.choice(np.arange(min_y, max_y+1), count, replace=True) - img_arr = [] - box_arr = [] - for i in range(count): - img_arr.append(new_img[start_y[i]:start_y[i]+160, start_x[i]:start_x[i]+120]) - temp_box = new_box.copy() - temp_box[0] -= start_x[i] - temp_box[2] -= start_x[i] - temp_box[1] -= start_y[i] - temp_box[3] -= start_y[i] - box_arr.append(temp_box) - new_img = img_arr - new_box = box_arr - return new_img, new_box, img, box - - -def main(source_path, dest_path): - """ - Main function to iterate over the images in the raw data and generate data samples - to train/test FaceID model. - """ - - # img_dir = os.path.join(raw_data_path, 'aligned_images_DB') - frame_dir = os.path.join(source_path, 'frame_images_DB') - - if not os.path.exists(dest_path): - os.makedirs(dest_path) - - # set parameters - num_imgs_per_face = 1 - target_im_shape = (160, 120) - - # set device - device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') - print(f'Running on device: {device}') - - # create models - mtcnn = MTCNN( - image_size=80, margin=0, min_face_size=20, - thresholds=[0.6, 0.7, 0.7], factor=0.709, post_process=True, - device=device - ) - resnet = InceptionResnetV1(pretrained='vggface2').eval().to(device) - - # run models on the images - num_persons = 0 - num_faces = 0 - - embedding_dict = {} - subj_name_list = os.listdir(frame_dir) - - for f_n, face_file in enumerate(subj_name_list): - if (f_n % 100) == 0: - print(f'Subject {f_n} of {len(subj_name_list)}') - f_path = os.path.join(frame_dir, face_file) - if os.path.isfile(f_path): - if face_file.endswith('txt'): - with open(f_path, mode='r', encoding='utf-8') as file: - lines = file.readlines() - num_persons += 1 - for line in lines: - num_faces += 1 - img_name = line.split(',')[0] - subj_name, video_no, file_name = img_name.split('\\') - img_path = os.path.join(frame_dir, subj_name, video_no, file_name) - img = imread(img_path) - - x_aligned, _, _ = mtcnn(img, return_prob=True) - if x_aligned is not None: - aligned = x_aligned[None, :, :, :].to(device) - embedding = resnet(aligned).detach().cpu().numpy()[0] - - if subj_name not in embedding_dict: - embedding_dict[subj_name] = {} - subj_path = os.path.join(dest_path, subj_name) - if not os.path.exists(subj_path): - os.mkdir(subj_path) - if video_no not in embedding_dict[subj_name]: - embedding_dict[subj_name][video_no] = {} - video_path = os.path.join(dest_path, subj_name, video_no) - if not os.path.exists(video_path): - os.mkdir(video_path) - - embedding_dict[subj_name][video_no][file_name] = embedding.tolist() - x_aligned_int = x_aligned.cpu().numpy() - x_aligned_int -= np.min(x_aligned_int) - x_aligned_int /= np.max(x_aligned_int) - x_aligned_int = (255.0 * x_aligned_int).astype(np.uint8) - np.save(os.path.join(dest_path, subj_name, video_no, file_name), - x_aligned_int) - - rect = line.split(',')[2:6] - for i in range(4): - rect[i] = int(rect[i]) - - box = np.array([int(rect[0]) - int(rect[2])//2, - int(rect[1]) - int(rect[3])//2, - int(rect[0]) + int(rect[2])//2, - int(rect[1]) + int(rect[3])//2]) - - img_arr, _, img, box = generate_image(img, box, num_imgs_per_face) - for img_idx in range(num_imgs_per_face): - new_file_name = '_'.join([file_name, str(target_im_shape[0]), - str(target_im_shape[1]), str(img_idx)]) - cropped_im_path = os.path.join(dest_path, subj_name, video_no, - new_file_name) - np.save(cropped_im_path, img_arr[img_idx]) - - print(f'Number of People: {num_persons}') - print(f'Number of Faces: {num_faces}') - - # save embeddings to json file - with open(os.path.join(dest_path, 'embeddings.json'), mode='w', encoding='utf-8') as out_file: - json.dump(embedding_dict, out_file) - - -def parse_args(): - """Parses command line arguments""" - data_folder = os.path.abspath(__file__) - for _ in range(3): - data_folder = os.path.dirname(data_folder) - data_folder = os.path.join(data_folder, 'data') - - parser = argparse.ArgumentParser(description='Generate YouTubeFaces dataset to train/test \ - FaceID model.') - parser.add_argument('-r', '--raw', dest='raw_data_path', type=str, - default=os.path.join(data_folder, 'YouTubeFaces', 'raw'), - help='Path to raw YouTubeFaces dataset folder.') - parser.add_argument('-d', '--dest', dest='dest_data_path', type=str, - default=os.path.join(data_folder, 'YouTubeFaces'), - help='Folder path to store processed data') - parser.add_argument('--type', dest='data_type', type=str, required=True, - help='Data type to generate (train/test)') - args = parser.parse_args() - - source_path = args.raw_data_path - dest_path = os.path.join(args.dest_data_path, args.data_type, 'temp') - return source_path, dest_path - - -if __name__ == "__main__": - raw_data_path, dest_data_path = parse_args() - main(raw_data_path, dest_data_path) diff --git a/datasets/face_id/merge_vggface2_dataset.py b/datasets/face_id/merge_vggface2_dataset.py deleted file mode 100755 index 0db35b3a9..000000000 --- a/datasets/face_id/merge_vggface2_dataset.py +++ /dev/null @@ -1,104 +0,0 @@ -#!/usr/bin/env python3 -################################################################################################### -# -# Copyright (C) 2020-2023 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -""" -Script to merge VGGFace-2 data samples into more compact file series to effectively use during -FaceID model training. -""" - -import argparse -import json -import os -import pickle - -import numpy as np - - -def save_dataset(data, merged_data_path, part_no): - """ - Function to save merged file. - """ - merged_file_path = os.path.join(merged_data_path, f'whole_set_{part_no:02d}.pkl') - with open(merged_file_path, 'wb') as handle: - pickle.dump(data, handle, protocol=pickle.HIGHEST_PROTOCOL) - - -def main(data_path): # pylint: disable=too-many-locals - """ - Main function to iterate over the data samples to merge. - """ - img_size = (3, 160, 120) - - subj_list = sorted(os.listdir(os.path.join(data_path, 'temp'))) - part_no = 0 - dataset = {} - num_empty_subjs = 0 - - for i, subj in enumerate(subj_list): - if subj == 'merged': - print(f'Folder {subj} skipped') - continue - - if (i % 250) == 0: - print(f'{i} of {subj_list}') - if i > 0: - save_dataset(dataset, data_path, part_no) - dataset = {} - part_no += 1 - - if subj not in dataset: - dataset[subj] = {} - - subj_path = os.path.join(data_path, 'temp', subj) - if not os.path.isdir(subj_path): - continue - - if not os.listdir(subj_path): - print(f'Empty folder: {subj_path}') - num_empty_subjs += 1 - continue - - embedding_path = os.path.join(subj_path, 'embeddings.json') - with open(embedding_path, encoding='utf-8') as file: - embeddings = json.load(file) - - for img_name, emb in embeddings.items(): - img_path = os.path.join(subj_path, img_name) - img = np.load(img_path).transpose([2, 0, 1]) - - if img.shape == img_size: - if np.min(img) != np.max(img): - dataset[subj][img_name] = {'embedding': emb, 'img': img} - - if dataset: - save_dataset(dataset, data_path, part_no) - - -def parse_args(): - """Parses command line arguments""" - parser = argparse.ArgumentParser(description='Merge VGGFace-2 data samples to effectively use\ - during training/testing FaceID model.') - default_data_path = os.path.abspath(__file__) - for _ in range(3): - default_data_path = os.path.dirname(default_data_path) - default_data_path = os.path.join(default_data_path, 'data', 'VGGFace-2') - parser.add_argument('-p', '--data_path', dest='data_path', type=str, - default=default_data_path, - help='Folder path to processed data') - parser.add_argument('--type', dest='data_type', type=str, required=True, - help='Data type to generate (train/test)') - args = parser.parse_args() - - data_path = os.path.join(args.data_path, args.data_type) - return data_path - - -if __name__ == "__main__": - data_folder = parse_args() - main(data_folder) diff --git a/datasets/face_id/merge_youtubefaces_dataset.py b/datasets/face_id/merge_youtubefaces_dataset.py deleted file mode 100755 index a4eb1af5d..000000000 --- a/datasets/face_id/merge_youtubefaces_dataset.py +++ /dev/null @@ -1,99 +0,0 @@ -#!/usr/bin/env python3 -################################################################################################### -# -# Copyright (C) 2020-2023 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -""" -Script to merge YouTubeFaces data samples into more compact file series to effectively use during -FaceID model training. -""" - -import argparse -import json -import os -import pickle - -import numpy as np - - -def save_dataset(data, merged_data_path, part_no): - """ - Function to save merged file. - """ - merged_file_path = os.path.join(merged_data_path, f'whole_set_{part_no:02d}.pkl') - with open(merged_file_path, 'wb') as handle: - pickle.dump(data, handle, protocol=pickle.HIGHEST_PROTOCOL) - - -def main(data_path): # pylint: disable=too-many-locals - """ - Main function to iterate over the data samples to merge. - """ - img_size = (3, 160, 120) - - num_imgs_per_face = 1 - - dataset = {} - part_no = 0 - - embedding_path = os.path.join(data_path, 'temp', 'embeddings.json') - with open(embedding_path, encoding='utf-8') as file: - embeddings = json.load(file) - - for i, (subj, val) in enumerate(embeddings.items()): # pylint: disable=too-many-nested-blocks - if (i % 200) == 0: - print(f'{i} of {len(embeddings)}') - if i > 0: - save_dataset(dataset, data_path, part_no) - dataset = {} - part_no += 1 - - if subj not in dataset: - dataset[subj] = {} - for video_num, val2 in val.items(): - img_folder = os.path.join(data_path, 'temp', subj, str(video_num)) - - if video_num not in dataset[subj]: - dataset[subj][video_num] = {} - - for img_name, embedding in val2.items(): - for idx in range(num_imgs_per_face): - img_name = '_'.join([img_name, str(img_size[1]), str(img_size[2]), str(idx)]) - img_path = os.path.join(img_folder, '.'.join([img_name, 'npy'])) - img = np.load(img_path).transpose([2, 0, 1]) - - if img.shape == img_size: - if np.min(img) != np.max(img): - dataset[subj][video_num][img_name] = {'embedding': embedding, - 'img': img} - - if dataset: - save_dataset(dataset, data_path, part_no) - - -def parse_args(): - """Parses command line arguments""" - parser = argparse.ArgumentParser(description='Merge YouTubeFaces data samples to effectively\ - use during training/testing FaceID model.') - default_data_path = os.path.abspath(__file__) - for _ in range(3): - default_data_path = os.path.dirname(default_data_path) - default_data_path = os.path.join(default_data_path, 'data', 'YouTubeFaces') - parser.add_argument('-p', '--data_path', dest='data_path', type=str, - default=default_data_path, - help='Folder path to processed data') - parser.add_argument('--type', dest='data_type', type=str, required=True, - help='Data type to generate (train/test)') - args = parser.parse_args() - - data_path = os.path.join(args.data_path, args.data_type) - return data_path - - -if __name__ == "__main__": - data_folder = parse_args() - main(data_folder) diff --git a/datasets/faceid.py b/datasets/faceid.py deleted file mode 100644 index 3f0039750..000000000 --- a/datasets/faceid.py +++ /dev/null @@ -1,77 +0,0 @@ -################################################################################################### -# -# Copyright (C) 2019-2023 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -""" -Classes and functions used to utilize the Face ID dataset. -""" -import os - -from torchvision import transforms - -import ai8x -from datasets.vggface2 import VGGFace2Dataset -from datasets.youtube_faces import YouTubeFacesDataset - - -def faceid_get_datasets(data, load_train=True, load_test=True): - """ - Load the faceID dataset - - The dataset is loaded from the archive file, so the file is required for this version. - - The dataset consists of actually 2 different datasets, VGGFace2 for training and YouTubeFaces - for the test. The reason of this is proof-of-concept models are obtained by this way and the - losses At YTFaces are tracked for the sake of benchmarking. - - The images are all 3-color 160x120 sized and consist the face image. - """ - (data_dir, args) = data - - # These are hard coded for now, need to come from above in future. - train_resample_subj = 1 - train_resample_img_per_subj = 6 - test_resample_subj = 1 - test_resample_img_per_subj = 2 - train_data_dir = os.path.join(data_dir, 'VGGFace-2') - test_data_dir = os.path.join(data_dir, 'YouTubeFaces') - - transform = transforms.Compose([ - ai8x.normalize(args=args) - ]) - - if load_train: - train_dataset = VGGFace2Dataset(root_dir=train_data_dir, d_type='train', - transform=transform, - resample_subj=train_resample_subj, - resample_img_per_subj=train_resample_img_per_subj) - else: - train_dataset = None - - if load_test: - test_dataset = YouTubeFacesDataset(root_dir=test_data_dir, d_type='test', - transform=transform, - resample_subj=test_resample_subj, - resample_img_per_subj=test_resample_img_per_subj) - - if args.truncate_testset: - test_dataset.data = test_dataset.data[:1] # type: ignore # .data exists - else: - test_dataset = None - - return train_dataset, test_dataset - - -datasets = [ - { - 'name': 'FaceID', - 'input': (3, 160, 120), - 'output': ('id'), - 'regression': True, - 'loader': faceid_get_datasets, - }, -] diff --git a/datasets/imagenet.py b/datasets/imagenet.py index 36b69bcc4..a1185f4e1 100644 --- a/datasets/imagenet.py +++ b/datasets/imagenet.py @@ -1,13 +1,6 @@ -################################################################################################### # -# Copyright (C) 2018-2023 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -# -# Portions Copyright (c) 2018 Intel Corporation +# Copyright (c) 2018 Intel Corporation +# Portions Copyright (C) 2019-2023 Maxim Integrated Products, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/datasets/kws20.py b/datasets/kws20.py index 4215fac94..245450ede 100644 --- a/datasets/kws20.py +++ b/datasets/kws20.py @@ -1,13 +1,7 @@ -################################################################################################### # -# Copyright (C) 2019-2023 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -# -# Portions Copyright (c) 2018 Intel Corporation +# Copyright (c) 2018 Intel Corporation +# Portions Copyright (C) 2019-2023 Maxim Integrated Products, Inc. +# Portions Copyright (C) 2023-2024 Analog Devices, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -51,14 +45,14 @@ class KWS: Dataset, 1D folded. Args: - root (string): Root directory of dataset where ``KWS/processed/dataset.pt`` - exist. + root (string): Root directory of dataset where ``KWS/processed/dataset.pt`` exist. classes(array): List of keywords to be used. d_type(string): Option for the created dataset. ``train`` or ``test``. - n_augment(int, optional): Number of augmented samples added to the dataset from - each sample by random modifications, i.e. stretching, shifting and random noise. - transform (callable, optional): A function/transform that takes in an PIL image - and returns a transformed version. + transform (callable, optional): A function/transform that takes in a signal between [0, 1] + and returns a transformed version, suitable for ai8x training / evaluation. + quantization_scheme (dict, optional): Dictionary containing quantization scheme parameters. + If not provided, default values are used. + augmentation (dict, optional): Dictionary containing augmentation parameters. download (bool, optional): If true, downloads the dataset from the internet and puts it in root directory. If dataset is already downloaded, it is not downloaded again. @@ -93,15 +87,15 @@ def __init__(self, root, classes, d_type, t_type, transform=None, quantization_s self.__parse_augmentation(augmentation) if not self.save_unquantized: - self.data_file = 'dataset2.pt' + self.data_file = 'dataset.pt' else: self.data_file = 'unquantized.pt' if download: self.__download() - self.data, self.targets, self.data_type = torch.load(os.path.join( - self.processed_folder, self.data_file)) + self.data, self.targets, self.data_type, self.shift_limits = \ + torch.load(os.path.join(self.processed_folder, self.data_file)) print(f'\nProcessing {self.d_type}...') self.__filter_dtype() @@ -163,10 +157,6 @@ def __parse_augmentation(self, augmentation): print('No key `shift` in input augmentation dictionary! ' 'Using defaults: [Min:-0.1, Max: 0.1]') self.augmentation['shift'] = {'min': -0.1, 'max': 0.1} - if 'stretch' not in augmentation: - print('No key `stretch` in input augmentation dictionary! ' - 'Using defaults: [Min: 0.8, Max: 1.3]') - self.augmentation['stretch'] = {'min': 0.8, 'max': 1.3} def __download(self): @@ -370,23 +360,27 @@ def __filter_dtype(self): # take a copy of the original data and targets temporarily for validation set self.data_original = self.data.clone() self.targets_original = self.targets.clone() + self.data_type_original = self.data_type.clone() self.data = self.data[idx_to_select, :] self.targets = self.targets[idx_to_select, :] + self.data_type = self.data_type[idx_to_select, :] # append validation set to the training set if validation examples are explicitly included if self.d_type == 'train': - idx_to_select = (self.data_type == 2)[:, -1] + idx_to_select = (self.data_type_original == 2)[:, -1] if idx_to_select.sum() > 0: # if validation examples exist self.data = torch.cat((self.data, self.data_original[idx_to_select, :]), dim=0) self.targets = \ torch.cat((self.targets, self.targets_original[idx_to_select, :]), dim=0) + self.data_type = \ + torch.cat((self.data_type, self.data_type_original[idx_to_select, :]), dim=0) # indicate the list of validation indices to be used by distiller's dataloader self.valid_indices = range(set_size, set_size + idx_to_select.sum()) print(f'validation set: {idx_to_select.sum()} elements') del self.data_original del self.targets_original - del self.data_type + del self.data_type_original def __filter_classes(self): initial_new_class_label = len(self.class_dict) @@ -408,28 +402,63 @@ def __filter_classes(self): def __len__(self): return len(self.data) + def __reshape_audio(self, audio, row_len=128): + # add overlap if necessary later on + return torch.transpose(audio.reshape((-1, row_len)), 1, 0) + + def shift_and_noise_augment(self, audio, shift_limits): + """Augments audio by adding random shift and noise. + """ + random_noise_var_coeff = np.random.uniform(self.augmentation['noise_var']['min'], + self.augmentation['noise_var']['max']) + random_shift_sample = np.random.randint(shift_limits[0], shift_limits[1]) + + aug_audio = self.shift(audio, random_shift_sample) + aug_audio = self.add_quantized_white_noise(aug_audio, random_noise_var_coeff) + + return aug_audio + def __getitem__(self, index): - inp, target = self.data[index].type(torch.FloatTensor), int(self.targets[index]) + inp, target = self.data[index], int(self.targets[index]) + data_type, shift_limits = self.data_type[index], self.shift_limits[index] + + # apply dynamic shift and noise augmentation to training examples + if data_type == 0: + inp = self.shift_and_noise_augment(inp, shift_limits) + + # reshape to 2D + inp = self.__reshape_audio(inp) + + inp = inp.type(torch.FloatTensor) + if not self.save_unquantized: inp /= 256 if self.transform is not None: inp = self.transform(inp) + return inp, target @staticmethod def add_white_noise(audio, noise_var_coeff): - """Adds zero mean Gaussian noise to image with specified variance. + """Adds zero mean Gaussian noise to the audio with specified variance. """ coeff = noise_var_coeff * np.mean(np.abs(audio)) noisy_audio = audio + coeff * np.random.randn(len(audio)) return noisy_audio @staticmethod - def shift(audio, shift_sec, fs): + def add_quantized_white_noise(audio, noise_var_coeff): + """Adds zero mean Gaussian noise to the audio with specified variance. + """ + coeff = noise_var_coeff * torch.mean(torch.abs(audio.type(torch.float)-128)) + noise = (coeff * torch.randn(len(audio))).type(torch.int16) + return (audio + noise).clip(0, 255).type(torch.uint8) + + @staticmethod + def shift(audio, shift_sample): """Shifts audio. """ - shift_count = int(shift_sec * fs) - return np.roll(audio, shift_count) + return torch.roll(audio, shift_sample) @staticmethod def stretch(audio, rate=1): @@ -444,36 +473,6 @@ def stretch(audio, rate=1): return audio2 - def augment(self, audio, fs, verbose=False): - """Augments audio by adding random noise, shift and stretch ratio. - """ - random_noise_var_coeff = np.random.uniform(self.augmentation['noise_var']['min'], - self.augmentation['noise_var']['max']) - random_shift_time = np.random.uniform(self.augmentation['shift']['min'], - self.augmentation['shift']['max']) - random_stretch_coeff = np.random.uniform(self.augmentation['stretch']['min'], - self.augmentation['stretch']['max']) - - sox_effects = [["speed", str(random_stretch_coeff)], ["rate", str(fs)]] - aug_audio, _ = torchaudio.sox_effects.apply_effects_tensor( - torch.unsqueeze(torch.from_numpy(audio).float(), dim=0), fs, sox_effects) - aug_audio = aug_audio.numpy().squeeze() - aug_audio = self.shift(aug_audio, random_shift_time, fs) - aug_audio = self.add_white_noise(aug_audio, random_noise_var_coeff) - - if verbose: - print(f'random_noise_var_coeff: {random_noise_var_coeff:.2f}\nrandom_shift_time: \ - {random_shift_time:.2f}\nrandom_stretch_coeff: {random_stretch_coeff:.2f}') - return aug_audio - - def augment_multiple(self, audio, fs, n_augment, verbose=False): - """Calls `augment` function for n_augment times for given audio data. - Finally the original audio is added to have (n_augment+1) audio data. - """ - aug_audio = [self.augment(audio, fs, verbose=verbose) for i in range(n_augment)] - aug_audio.insert(0, audio) - return aug_audio - @staticmethod def compand(data, mu=255): """Compand the signal level to warp from Laplacian distribution to uniform distribution""" @@ -505,9 +504,59 @@ def quantize_audio(data, num_bits=8, compand=False, mu=255): q_data = np.clip(q_data, 0, max_val) return np.uint8(q_data) - def __gen_datasets(self, exp_len=16384, row_len=128, overlap_ratio=0): - print('Generating dataset from raw data samples for the first time. ') - print('This process will take significant time (~60 minutes)...') + def get_audio_endpoints(self, audio, fs): + """Future: May implement a method to detect the beginning & end of voice activity in audio. + Currently, it returns end points compatible with augmentation['shift'] values + """ + return int(-self.augmentation['shift']['min'] * fs), \ + int(len(audio) - self.augmentation['shift']['max'] * fs) + + def speed_augment(self, audio, fs, sample_no=0): + """Augments audio by randomly changing the speed of the audio. + The generated coefficient follows 0.9, 1.1, 0.95, 1.05... pattern + """ + speed_multiplier = 1.0 + 0.2 * (sample_no % 2 - 0.5) / (1 + sample_no // 2) + + sox_effects = [["speed", str(speed_multiplier)], ["rate", str(fs)]] + aug_audio, _ = torchaudio.sox_effects.apply_effects_tensor( + torch.unsqueeze(torch.from_numpy(audio).float(), dim=0), fs, sox_effects) + aug_audio = aug_audio.numpy().squeeze() + + return aug_audio, speed_multiplier + + def speed_augment_multiple(self, audio, fs, exp_len, n_augment): + """Calls `speed_augment` function for n_augment times for given audio data. + Finally the original audio is added to have (n_augment+1) audio data. + """ + aug_audio = [None] * (n_augment + 1) + aug_speed = np.ones((n_augment + 1,)) + shift_limits = np.zeros((n_augment + 1, 2)) + voice_begin_idx, voice_end_idx = self.get_audio_endpoints(audio, fs) + aug_audio[0] = audio + for i in range(n_augment): + aug_audio[i+1], aug_speed[i+1] = self.speed_augment(audio, fs, sample_no=i) + for i in range(n_augment + 1): + if len(aug_audio[i]) < exp_len: + aug_audio[i] = np.pad(aug_audio[i], (0, exp_len - len(aug_audio[i])), 'constant') + aug_begin_idx = voice_begin_idx * aug_speed[i] + aug_end_idx = voice_end_idx * aug_speed[i] + if aug_end_idx - aug_begin_idx <= exp_len: + # voice activity duration is shorter than the expected length + segment_begin = max(aug_end_idx, exp_len) - exp_len + segment_end = max(aug_end_idx, exp_len) + aug_audio[i] = aug_audio[i][segment_begin:segment_end] + shift_limits[i, 0] = -aug_begin_idx + (max(aug_end_idx, exp_len) - exp_len) + shift_limits[i, 1] = max(aug_end_idx, exp_len) - aug_end_idx + else: + # voice activity duraction is longer than the expected length + midpoint = (aug_begin_idx + aug_end_idx) // 2 + aug_audio[i] = aug_audio[i][midpoint - exp_len // 2: midpoint + exp_len // 2] + shift_limits[i, :] = [0, 0] + return aug_audio, shift_limits + + def __gen_datasets(self, exp_len=16384): + print('Generating dataset from raw data samples for the first time.') + print('This process may take a few minutes.') with warnings.catch_warnings(): warnings.simplefilter('error') @@ -515,12 +564,6 @@ def __gen_datasets(self, exp_len=16384, row_len=128, overlap_ratio=0): labels = [d for d in lst if os.path.isdir(os.path.join(self.raw_folder, d)) and d[0].isalpha()] - # PARAMETERS - overlap = int(np.ceil(row_len * overlap_ratio)) - num_rows = int(np.ceil(exp_len / (row_len - overlap))) - data_len = int((num_rows * row_len - (num_rows - 1) * overlap)) - print(f'data_len: {data_len}') - # show the size of dataset for each keyword print('------------- Label Size ---------------') for i, label in enumerate(labels): @@ -541,27 +584,36 @@ def __gen_datasets(self, exp_len=16384, row_len=128, overlap_ratio=0): for i, label in enumerate(labels): print(f'Processing the label: {label}. {i + 1} of {len(labels)}') record_list = sorted(os.listdir(os.path.join(self.raw_folder, label))) + record_len = len(record_list) + + # get the number testing samples for the class + test_count_class = 0 + for r, record_name in enumerate(record_list): + local_filename = os.path.join(label, record_name) + if local_filename in testing_set: + test_count_class += 1 + + # no augmentation for testing set, subtract them accordingly + number_of_total_samples = record_len * (self.augmentation['aug_num'] + 1) - \ + test_count_class * self.augmentation['aug_num'] - # dimension: row_length x number_of_rows if not self.save_unquantized: - data_in = np.empty(((self.augmentation['aug_num'] + 1) * len(record_list), - row_len, num_rows), dtype=np.uint8) + data_in = np.empty((number_of_total_samples, exp_len), dtype=np.uint8) else: - data_in = np.empty(((self.augmentation['aug_num'] + 1) * len(record_list), - row_len, num_rows), dtype=np.float32) - data_type = np.empty(((self.augmentation['aug_num'] + 1) * len(record_list), 1), - dtype=np.uint8) - # create data classes - data_class = np.full(((self.augmentation['aug_num'] + 1) * len(record_list), 1), i, - dtype=np.uint8) + data_in = np.empty((number_of_total_samples, exp_len), dtype=np.float32) + + data_type = np.empty((number_of_total_samples, 1), dtype=np.uint8) + data_shift_limits = np.empty((number_of_total_samples, 2), dtype=np.int16) + data_class = np.full((number_of_total_samples, 1), i, dtype=np.uint8) time_s = time.time() + sample_index = 0 for r, record_name in enumerate(record_list): local_filename = os.path.join(label, record_name) if r % 1000 == 0: - print(f'\t{r + 1} of {len(record_list)}') + print(f'\t{r + 1} of {record_len}') if local_filename in testing_set: d_typ = np.uint8(1) # test @@ -575,29 +627,28 @@ def __gen_datasets(self, exp_len=16384, row_len=128, overlap_ratio=0): record_pth = os.path.join(self.raw_folder, label, record_name) record, fs = librosa.load(record_pth, offset=0, sr=None) - audio_seq_list = self.augment_multiple(record, fs, - self.augmentation['aug_num']) - for n_a, audio_seq in enumerate(audio_seq_list): - # store set type: train, test or validate - data_type[(self.augmentation['aug_num'] + 1) * r + n_a, 0] = d_typ - - # Write audio 128x128=16384 samples without overlap - for n_r in range(num_rows): - start_idx = n_r * (row_len - overlap) - end_idx = start_idx + row_len - audio_chunk = audio_seq[start_idx:end_idx] - # pad zero if the length of the chunk is smaller than row_len - audio_chunk = np.pad(audio_chunk, [0, row_len - audio_chunk.size]) - # store input data after quantization - data_idx = (self.augmentation['aug_num'] + 1) * r + n_a - if not self.save_unquantized: - data_in[data_idx, :, n_r] = \ - KWS.quantize_audio(audio_chunk, - num_bits=self.quantization['bits'], - compand=self.quantization['compand'], - mu=self.quantization['mu']) - else: - data_in[data_idx, :, n_r] = audio_chunk + + # normalize dynamic range to [-1, +1] + record = record / np.max(np.abs(record)) + + if d_typ != 1: # training and validation examples get speed augmentation + no_augmentations = self.augmentation['aug_num'] + else: # test examples don't get speed augmentation + no_augmentations = 0 + + # apply speed augmentations and calculate shift limits + audio_seq_list, shift_limits = \ + self.speed_augment_multiple(record, fs, exp_len, no_augmentations) + + for local_id, audio_seq in enumerate(audio_seq_list): + data_in[sample_index] = \ + KWS.quantize_audio(audio_seq, + num_bits=self.quantization['bits'], + compand=self.quantization['compand'], + mu=self.quantization['mu']) + data_shift_limits[sample_index] = shift_limits[local_id] + data_type[sample_index] = d_typ + sample_index += 1 dur = time.time() - time_s print(f'Finished in {dur:.3f} seconds.') @@ -607,19 +658,30 @@ def __gen_datasets(self, exp_len=16384, row_len=128, overlap_ratio=0): data_in_all = data_in.copy() data_class_all = data_class.copy() data_type_all = data_type.copy() + data_shift_limits_all = data_shift_limits.copy() else: data_in_all = np.concatenate((data_in_all, data_in), axis=0) data_class_all = np.concatenate((data_class_all, data_class), axis=0) data_type_all = np.concatenate((data_type_all, data_type), axis=0) + data_shift_limits_all = \ + np.concatenate((data_shift_limits_all, data_shift_limits), axis=0) dur = time.time() - time_s print(f'Data concatenation finished in {dur:.3f} seconds.') data_in_all = torch.from_numpy(data_in_all) data_class_all = torch.from_numpy(data_class_all) data_type_all = torch.from_numpy(data_type_all) + data_shift_limits_all = torch.from_numpy(data_shift_limits_all) + + # apply static shift & noise augmentation for validation examples + for sample_index in range(data_in_all.shape[0]): + if data_type_all[sample_index] == 2: + data_in_all[sample_index] = \ + self.shift_and_noise_augment(data_in_all[sample_index], + data_shift_limits_all[sample_index]) - mfcc_dataset = (data_in_all, data_class_all, data_type_all) - torch.save(mfcc_dataset, os.path.join(self.processed_folder, self.data_file)) + raw_dataset = (data_in_all, data_class_all, data_type_all, data_shift_limits_all) + torch.save(raw_dataset, os.path.join(self.processed_folder, self.data_file)) print('Dataset created.') print(f'Training: {train_count}, Validation: {valid_count}, Test: {test_count}') @@ -665,7 +727,7 @@ def KWS_get_datasets(data, load_train=True, load_test=True, num_classes=6): else: raise ValueError(f'Unsupported num_classes {num_classes}') - augmentation = {'aug_num': 2, 'shift': {'min': -0.15, 'max': 0.15}, + augmentation = {'aug_num': 2, 'shift': {'min': -0.1, 'max': 0.1}, 'noise_var': {'min': 0, 'max': 1.0}} quantization_scheme = {'compand': False, 'mu': 10} diff --git a/datasets/mixedkws.py b/datasets/mixedkws.py index 0fc5f1f3c..5585729f3 100644 --- a/datasets/mixedkws.py +++ b/datasets/mixedkws.py @@ -1,13 +1,6 @@ -################################################################################################### # -# Copyright (C) 2021-2023 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -# -# Portions Copyright (c) 2018 Intel Corporation +# Copyright (c) 2018 Intel Corporation +# Portions Copyright (C) 2019-2023 Maxim Integrated Products, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/datasets/mnist.py b/datasets/mnist.py index ff598beda..0f5b17ad2 100644 --- a/datasets/mnist.py +++ b/datasets/mnist.py @@ -1,13 +1,6 @@ -################################################################################################### # -# Copyright (C) 2018-2020 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -# -# Portions Copyright (c) 2018 Intel Corporation +# Copyright (c) 2018 Intel Corporation +# Portions Copyright (C) 2019-2023 Maxim Integrated Products, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/datasets/msnoise.py b/datasets/msnoise.py index 25630bf6b..0b3bf3495 100644 --- a/datasets/msnoise.py +++ b/datasets/msnoise.py @@ -1,13 +1,7 @@ -################################################################################################### # -# Copyright (C) 2021-2023 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -# -# Portions Copyright (c) 2018 Intel Corporation +# Copyright (c) 2018 Intel Corporation +# Portions Copyright (C) 2019-2023 Maxim Integrated Products, Inc. +# Portions Copyright (C) 2023-2024 Analog Devices, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -51,6 +45,7 @@ class MSnoise: exist. classes(array): List of keywords to be used. d_type(string): Option for the created dataset. ``train`` or ``test``. + dataset_len(int): Dataset length to be returned. remove_unknowns (bool, optional): If true, unchosen classes are not gathered as the unknown class. transform (callable, optional): A function/transform that takes in an PIL image @@ -69,17 +64,23 @@ class MSnoise: 'CopyMachine': 6, 'Field': 7, 'Hallway': 8, 'Kitchen': 9, 'LivingRoom': 10, 'Metro': 11, 'Munching': 12, 'NeighborSpeaking': 13, 'Office': 14, 'Park': 15, 'Restaurant': 16, 'ShuttingDoor': 17, - 'Square': 18, 'SqueakyChair': 19, 'Station': 20, 'Traffic': 21, - 'Typing': 22, 'VacuumCleaner': 23, 'WasherDryer': 24, 'Washing': 25} + 'Square': 18, 'SqueakyChair': 19, 'Station': 20, 'TradeShow': 21, 'Traffic': 22, + 'Typing': 23, 'VacuumCleaner': 24, 'WasherDryer': 25, 'Washing': 26} - def __init__(self, root, classes, d_type, remove_unknowns=False, - transform=None, quantize=False, download=False): + def __init__(self, root, classes, d_type, dataset_len, exp_len=16384, fs=16000, + noise_time_step=0.25, remove_unknowns=False, transform=None, + quantize=False, download=False): self.root = root self.classes = classes self.d_type = d_type self.remove_unknowns = remove_unknowns self.transform = transform + self.dataset_len = dataset_len + self.exp_len = exp_len + self.fs = fs + self.noise_time_step = noise_time_step + self.noise_train_folder = os.path.join(self.raw_folder, 'noise_train') self.noise_test_folder = os.path.join(self.raw_folder, 'noise_test') self.url_train = \ @@ -88,16 +89,13 @@ def __init__(self, root, classes, d_type, remove_unknowns=False, 'https://api.github.com/repos/microsoft/MS-SNSD/contents/noise_test?ref=master' self.quantize = quantize - if self.quantize: - self.data_file = 'dataset_quantized.pt' - else: - self.data_file = 'dataset_unquantized.pt' - if download: self.__download() - self.data, self.targets, self.data_type = torch.load(os.path.join( - self.processed_folder, self.data_file)) + self.data, self.targets, self.data_type, self.rms_val = self.__gen_datasets() + + # rms values for each sample to be returned + self.rms = np.zeros(self.dataset_len) self.__filter_dtype() self.__filter_classes() @@ -108,24 +106,16 @@ def raw_folder(self): """ return os.path.join(self.root, self.__class__.__name__, 'raw') - @property - def processed_folder(self): - """Folder for the processed data. - """ - return os.path.join(self.root, self.__class__.__name__, 'processed') - def __download(self): - if self.__check_exists(): + if os.path.exists(self.raw_folder): return self.__makedir_exist_ok(self.noise_train_folder) self.__makedir_exist_ok(self.noise_test_folder) - self.__makedir_exist_ok(self.processed_folder) self.__download_raw(self.url_train) self.__download_raw(self.url_test) - self.__gen_datasets() def __download_raw(self, api_url): opener = urllib.request.build_opener() @@ -152,9 +142,6 @@ def __download_raw(self, api_url): print('Interrupted while downloading!') sys.exit() - def __check_exists(self): - return os.path.exists(os.path.join(self.processed_folder, self.data_file)) - def __makedir_exist_ok(self, dirpath): try: os.makedirs(dirpath) @@ -165,21 +152,25 @@ def __makedir_exist_ok(self, dirpath): raise def __filter_dtype(self): + if self.d_type == 'train': - idx_to_select = (self.data_type == 0)[:, -1] + bool_list = [i == 0 for i in self.data_type] + idx_to_select = [i for i, x in enumerate(bool_list) if x] elif self.d_type == 'test': - idx_to_select = (self.data_type == 1)[:, -1] + bool_list = [i == 1 for i in self.data_type] + idx_to_select = [i for i, x in enumerate(bool_list) if x] else: print(f'Unknown data type: {self.d_type}') return - print(self.data.shape) - self.data = self.data[idx_to_select, :] - self.targets = self.targets[idx_to_select, :] + self.data = [self.data[i] for i in idx_to_select] + self.targets = [self.targets[i] for i in idx_to_select] + self.rms_val = [self.rms_val[i] for i in idx_to_select] del self.data_type def __filter_classes(self): print('\n') + self.targets = np.array(self.targets) initial_new_class_label = len(self.class_dict) new_class_label = initial_new_class_label for c in self.classes: @@ -188,21 +179,22 @@ def __filter_classes(self): return # else: print(f'Class {c}, {self.class_dict[c]}') - num_elems = (self.targets == self.class_dict[c]).cpu().sum() - print(f'Number of elements in class {c}: {num_elems}') - self.targets[(self.targets == self.class_dict[c])] = new_class_label + bool_list = [self.class_dict[c] == i for i in self.targets] + idx = [i for i, x in enumerate(bool_list) if x] + self.targets[idx] = new_class_label + print(f'{c}: {new_class_label - initial_new_class_label}') new_class_label += 1 - num_elems = (self.targets < initial_new_class_label).cpu().sum() - print(f'Number of elements in class unknown: {num_elems}') self.targets[(self.targets < initial_new_class_label)] = new_class_label if self.remove_unknowns: - idx_to_remove = (self.targets == new_class_label)[:, -1] - idx_to_keep = torch.logical_not(idx_to_remove) - self.data = self.data[idx_to_keep, :] - self.targets = self.targets[idx_to_keep, :] - self.targets -= initial_new_class_label - print(np.unique(self.targets.data.cpu())) + bool_list = [i != new_class_label for i in self.targets] + idx_to_keep = [i for i, x in enumerate(bool_list) if x] + + self.data = [self.data[i] for i in idx_to_keep] + self.targets = [self.targets[i] for i in idx] + self.rms_val = [self.rms_val[i] for i in idx] + + self.targets = [target - initial_new_class_label for target in self.targets] print('\n') @staticmethod @@ -217,20 +209,36 @@ def quantize_audio(data, num_bits=8): return np.uint8(q_data) def __len__(self): - return len(self.data) + return self.dataset_len def __getitem__(self, index): - inp, target = self.data[index].type(torch.FloatTensor), int(self.targets[index]) + + rec_num = len(self.data) + + rnd_num = np.random.randint(0, rec_num) + self.rms[index] = self.rms_val[rnd_num] + + rec_len = len(self.data[rnd_num]) + + max_start_idx = rec_len - self.exp_len + start_idx = np.random.randint(0, max_start_idx) + end_idx = start_idx + self.exp_len + + inp = self.__reshape_audio(self.data[rnd_num][start_idx:end_idx]) + target = int(self.targets[rnd_num]) + if self.quantize: inp /= 256 if self.transform is not None: inp = self.transform(inp) return inp, target - def __gen_datasets(self, exp_len=16384, row_len=128, overlap_ratio=0, - noise_time_step=0.25, train_ratio=0.6): - print('Generating dataset from raw data samples for the first time. ') - print('Warning: This process could take 5-10 minutes!') + def __reshape_audio(self, audio, row_len=128): + + return torch.transpose(torch.tensor(audio.reshape((-1, row_len))), 1, 0) + + def __gen_datasets(self, exp_len=16384, row_len=128, overlap_ratio=0): + with warnings.catch_warnings(): warnings.simplefilter('error') @@ -260,76 +268,33 @@ def __gen_datasets(self, exp_len=16384, row_len=128, overlap_ratio=0, # Folders train_test_folders = [self.noise_train_folder, self.noise_test_folder] - # Determining the array sizes - num_seqs = 0 - for label in labels: - train_count = 0 - test_count = 0 - for folder in train_test_folders: - for record_name in os.listdir(folder): - if record_name.split('_')[0] in label: - record_path = os.path.join(folder, record_name) - record, fs = librosa.load(record_path, offset=0, sr=None) - rec_len = np.size(record) - max_start_time = ((rec_len / fs - 1) - - (rec_len / fs % noise_time_step)) - num_seqs += int(max_start_time / noise_time_step + 1) - print(f'Num sequences: {num_seqs}') - - # Creating the empty arrays - if self.quantize: - data_in = np.zeros((num_seqs, row_len, num_rows), dtype=np.uint8) - else: - data_in = np.zeros((num_seqs, row_len, num_rows), dtype=np.float32) - data_type = np.zeros((num_seqs, 1), dtype=np.uint8) - data_class = np.zeros((num_seqs, 1), dtype=np.uint8) + data_in = [] + data_type = [] + data_class = [] + rms_val = [] - data_idx = 0 for i, label in enumerate(labels): - print(f'Processing label:{label}') - train_count = 0 - test_count = 0 for folder in train_test_folders: for record_name in sorted(os.listdir(folder)): if record_name.split('_')[0] in label: - if hash(record_name) % 10 < 10*train_ratio: - d_type = np.uint8(0) # train+val - train_count += 1 - else: - d_type = np.uint8(1) # test - test_count += 1 record_path = os.path.join(folder, record_name) - record, fs = librosa.load(record_path, offset=0, sr=None) - rec_len = np.size(record) - max_start_time = \ - (rec_len / fs - 1) - (rec_len / fs % noise_time_step) - for start_time in np.arange(0, - int((max_start_time+noise_time_step)*fs), - int(noise_time_step*fs)): - end_time = start_time + fs - audio_seq = record[start_time:end_time] - data_type[data_idx, 0] = d_type - data_class[data_idx, 0] = i - for n_r in range(num_rows): - start_idx = n_r*(row_len - overlap) - end_idx = start_idx + row_len - audio_chunk = audio_seq[start_idx:end_idx] - audio_chunk = \ - np.pad(audio_chunk, [0, row_len-audio_chunk.size]) - if self.quantize: - data_in[data_idx, :, n_r] = \ - self.quantize_audio(audio_chunk) - else: - data_in[data_idx, :, n_r] = audio_chunk - data_idx += 1 - - data_in = torch.from_numpy(data_in) - data_class = torch.from_numpy(data_class) - data_type = torch.from_numpy(data_type) - - noise_dataset = (data_in, data_class, data_type) - torch.save(noise_dataset, os.path.join(self.processed_folder, self.data_file)) - print('Dataset created!') + record, _ = librosa.load(record_path, offset=0, sr=None) + + if self.quantize: + data_in.append(self.quantize_audio(record)) + else: + data_in.append(record) + + if folder == self.noise_train_folder: + data_type.append(0) # train + val + elif folder == self.noise_test_folder: + data_type.append(1) # test + + data_class.append(i) + rms_val.append(np.mean(record**2)**0.5) + + noise_dataset = (data_in, data_class, data_type, rms_val) + return noise_dataset def MSnoise_get_datasets(data, load_train=True, load_test=True): @@ -345,9 +310,11 @@ def MSnoise_get_datasets(data, load_train=True, load_test=True): classes = ['AirConditioner', 'AirportAnnouncements', 'Babble', 'Bus', 'CafeTeria', 'Car', - 'CopyMachine', 'Metro', - 'Office', 'Restaurant', 'ShuttingDoor', - 'Traffic', 'Typing', 'VacuumCleaner', 'Washing'] + 'CopyMachine', 'Field', 'Hallway', 'Kitchen', + 'LivingRoom', 'Metro', 'Munching', 'NeighborSpeaking', + 'Office', 'Park', 'Restaurant', 'ShuttingDoor', + 'Square', 'SqueakyChair', 'Station', 'Traffic', + 'Typing', 'VacuumCleaner', 'WasherDryer', 'Washing', 'TradeShow'] remove_unknowns = True transform = transforms.Compose([ @@ -356,14 +323,14 @@ def MSnoise_get_datasets(data, load_train=True, load_test=True): quantize = True if load_train: - train_dataset = MSnoise(root=data_dir, classes=classes, d_type='train', + train_dataset = MSnoise(root=data_dir, classes=classes, d_type='train', dataset_len=11005, remove_unknowns=remove_unknowns, transform=transform, quantize=quantize, download=True) else: train_dataset = None if load_test: - test_dataset = MSnoise(root=data_dir, classes=classes, d_type='test', + test_dataset = MSnoise(root=data_dir, classes=classes, d_type='test', dataset_len=11005, remove_unknowns=remove_unknowns, transform=transform, quantize=quantize, download=True) @@ -385,33 +352,27 @@ def MSnoise_get_unquantized_datasets(data, load_train=True, load_test=True): """ (data_dir, args) = data - # classes = ['AirConditioner', 'AirportAnnouncements', - # 'Babble', 'Bus', 'CafeTeria', 'Car', - # 'CopyMachine', 'Field', 'Hallway', 'Kitchen', - # 'LivingRoom', 'Metro', 'Munching', 'NeighborSpeaking', - # 'Office', 'Park', 'Restaurant', 'ShuttingDoor', - # 'Square', 'SqueakyChair', 'Station', 'Traffic', - # 'Typing', 'VacuumCleaner', 'WasherDryer', 'Washing'] - - classes = ['AirConditioner', - 'CafeTeria', 'Car', - 'CopyMachine', - 'Office', 'Restaurant', - 'Typing', 'VacuumCleaner', 'WasherDryer'] + classes = ['AirConditioner', 'AirportAnnouncements', + 'Babble', 'Bus', 'CafeTeria', 'Car', + 'CopyMachine', 'Field', 'Hallway', 'Kitchen', + 'LivingRoom', 'Metro', 'Munching', 'NeighborSpeaking', + 'Office', 'Park', 'Restaurant', 'ShuttingDoor', + 'Square', 'SqueakyChair', 'Station', 'Traffic', + 'Typing', 'VacuumCleaner', 'WasherDryer', 'Washing', 'TradeShow'] remove_unknowns = True transform = None quantize = False if load_train: - train_dataset = MSnoise(root=data_dir, classes=classes, d_type='train', + train_dataset = MSnoise(root=data_dir, classes=classes, d_type='train', dataset_len=11005, remove_unknowns=remove_unknowns, transform=transform, quantize=quantize, download=True) else: train_dataset = None if load_test: - test_dataset = MSnoise(root=data_dir, classes=classes, d_type='test', + test_dataset = MSnoise(root=data_dir, classes=classes, d_type='test', dataset_len=11005, remove_unknowns=remove_unknowns, transform=transform, quantize=quantize, download=True) diff --git a/datasets/samplemotordatalimerick.py b/datasets/samplemotordatalimerick.py new file mode 100644 index 000000000..900341bbf --- /dev/null +++ b/datasets/samplemotordatalimerick.py @@ -0,0 +1,432 @@ +################################################################################################### +# +# Copyright (C) 2024 Analog Devices, Inc. All Rights Reserved. +# This software is proprietary to Analog Devices, Inc. and its licensors. +# +################################################################################################### +""" +Classes and functions for the Sample Motor Data Limerick Dataset +https://github.com/analogdevicesinc/CbM-Datasets +""" +import os + +import numpy as np +import torch +from torchvision import transforms + +import git +import pandas as pd +from git.exc import GitCommandError + +import ai8x +from utils.dataloader_utils import makedir_exist_ok + +from .cbm_dataframe_parser import CbM_DataFrame_Parser + + +class SampleMotorDataLimerick(CbM_DataFrame_Parser): + """ + Sample motor data is collected using SpectraQuest Machinery Fault Simulator. + ADXL356 sensor data is used for vibration raw data. + For ADXL356 sensor, the sampling frequency was 20kHz and + data csv files recorded for 2 sec in X, Y and Z direction. + """ + + # Good Bearing, Good Shaft, Balanced Load and Well Aligned + healthy_file_identifier = '_GoB_GS_BaLo_WA_' + + num_end_zeros = 10 + num_start_zeros = 3 + + train_ratio = 0.8 + + def __init__(self, root, d_type, + transform, + target_sampling_rate_Hz, + signal_duration_in_sec, + overlap_ratio, + eval_mode, + label_as_signal, + random_or_speed_split, + speed_and_load_available, + num_end_zeros=num_end_zeros, + num_start_zeros=num_start_zeros, + train_ratio=train_ratio, + accel_in_second_dim=True, + download=True, + healthy_file_identifier=healthy_file_identifier, + cnn_1dinput_len=256): + + self.download = download + self.root = root + + if self.download: + self.__download() + + self.accel_in_second_dim = accel_in_second_dim + + self.processed_folder = \ + os.path.join(root, self.__class__.__name__, 'processed') + + self.healthy_file_identifier = healthy_file_identifier + self.target_sampling_rate_Hz = target_sampling_rate_Hz + self.signal_duration_in_sec = signal_duration_in_sec + main_df = self.gen_dataframe() + + super().__init__(root, + d_type=d_type, + transform=transform, + target_sampling_rate_Hz=target_sampling_rate_Hz, + signal_duration_in_sec=signal_duration_in_sec, + overlap_ratio=overlap_ratio, + eval_mode=eval_mode, + label_as_signal=label_as_signal, + random_or_speed_split=random_or_speed_split, + speed_and_load_available=speed_and_load_available, + num_end_zeros=num_end_zeros, + num_start_zeros=num_start_zeros, + train_ratio=train_ratio, + cnn_1dinput_len=cnn_1dinput_len, + main_df=main_df) + + def __download(self): + """ + Downloads Sample Motor Data Limerick dataset from: + https://github.com/analogdevicesinc/CbM-Datasets + """ + destination_folder = self.root + dataset_repository = 'https://github.com/analogdevicesinc/CbM-Datasets' + + makedir_exist_ok(destination_folder) + + try: + if not os.path.exists(os.path.join(destination_folder, 'SampleMotorDataLimerick')): + print('\nDownloading SampleMotorDataLimerick dataset from\n' + f'{dataset_repository}\n') + git.Repo.clone_from(dataset_repository, destination_folder) + + else: + print('\nSampleMotorDataLimerick dataset already downloaded...') + + except GitCommandError: + pass + + def parse_ADXL356C_and_return_common_df_row(self, file_full_path, sensor_sr_Hz, + speed=None, load=None, label=None): + """ + Dataframe parser for Sample Motor Data Limerick. + Reads csv files and returns file identifier, raw data, + sensor frequency, speed, load and label. + The aw data size must be consecutive and bigger than window size. + """ + df_raw = pd.read_csv(file_full_path, sep=';', header=None) + + df_raw.rename( + columns={0: 'Time', 1: 'Voltage_x', 2: 'Voltage_y', + 3: 'Voltage_z', 4: 'x', 5: 'y', 6: 'z'}, + inplace=True + ) + ss_vibr_x1 = df_raw.iloc[0]['x'] + ss_vibr_y1 = df_raw.iloc[0]['y'] + ss_vibr_z1 = df_raw.iloc[0]['z'] + df_raw["Acceleration_x (g)"] = 50 * (df_raw["Voltage_x"] - ss_vibr_x1) + df_raw["Acceleration_y (g)"] = 50 * (df_raw["Voltage_y"] - ss_vibr_y1) + df_raw["Acceleration_z (g)"] = 50 * (df_raw["Voltage_z"] - ss_vibr_z1) + + raw_data = df_raw[["Acceleration_x (g)", "Acceleration_y (g)", "Acceleration_z (g)"]] + raw_data = raw_data.to_numpy() + + window_size_assert_message = "CNN input length is incorrect." + assert self.signal_duration_in_sec <= (raw_data.shape[0] / + sensor_sr_Hz), window_size_assert_message + + return [os.path.basename(file_full_path).split('/')[-1], + raw_data, sensor_sr_Hz, speed, load, label] + + def __getitem__(self, index): + if self.accel_in_second_dim and not self.speed_and_load_available: + signal, lbl = super().__getitem__(index) # pylint: disable=unbalanced-tuple-unpacking + signal = torch.transpose(signal, 0, 1) + lbl = lbl.transpose() + return signal, lbl + if self.accel_in_second_dim and self.speed_and_load_available: + signal, lbl, speed, load = super().__getitem__(index) + signal = torch.transpose(signal, 0, 1) + lbl = lbl.transpose() + return signal, lbl, speed, load + return super().__getitem__(index) + + def gen_dataframe(self): + """ + Generate dataframes from csv files of Sample Motor Data Limerick + """ + file_name = f'{self.__class__.__name__}_dataframe.pkl' + df_path = \ + os.path.join(self.root, self.__class__.__name__, file_name) + + if os.path.isfile(df_path): + print(f'\nFile {file_name} already exists\n') + main_df = pd.read_pickle(df_path) + + return main_df + + print('\nGenerating data frame pickle files from the raw data \n') + + actual_root_dir = os.path.join(self.root, self.__class__.__name__, + "SpectraQuest_Rig_Data_Voyager_3/") + data_dir = os.path.join(actual_root_dir, 'Data_ADXL356C') + + if not os.path.isdir(data_dir): + print(f'\nDataset directory {data_dir} does not exist.\n') + return None + + with os.scandir(data_dir) as it: + if not any(it): + print(f'\nDataset directory {data_dir} is empty.\n') + return None + + rpm_prefixes = ('0600', '1200', '1800', '2400', '3000') + + sensor_sr_Hz = 20000 # Hz + + faulty_data_list = [] + healthy_data_list = [] + + df_normals = self.create_common_empty_df() + df_anormals = self.create_common_empty_df() + + for file in sorted(os.listdir(data_dir)): + full_path = os.path.join(data_dir, file) + speed = int(file.split("_")[0]) / 60 # Hz + load = int(file.split("_")[-1][0:2]) # LBS + + if any(file.startswith(rpm_prefix + self.healthy_file_identifier) + for rpm_prefix in rpm_prefixes): + healthy_row = self.parse_ADXL356C_and_return_common_df_row( + file_full_path=full_path, sensor_sr_Hz=sensor_sr_Hz, + speed=speed, + load=load, + label=0 + ) + healthy_data_list.append(healthy_row) + + else: + faulty_row = self.parse_ADXL356C_and_return_common_df_row( + file_full_path=full_path, sensor_sr_Hz=sensor_sr_Hz, + speed=speed, + load=load, + label=1 + ) + faulty_data_list.append(faulty_row) + + df_normals = pd.DataFrame(data=np.array(healthy_data_list, dtype=object), + columns=self.common_dataframe_columns) + + df_anormals = pd.DataFrame(data=np.array(faulty_data_list, dtype=object), + columns=self.common_dataframe_columns) + + main_df = pd.concat([df_normals, df_anormals], axis=0) + + makedir_exist_ok(self.processed_folder) + main_df.to_pickle(df_path) + + return main_df + + +def samplemotordatalimerick_get_datasets(data, load_train=True, load_test=True, + download=True, + signal_duration_in_sec=0.25, + overlap_ratio=0.75, + eval_mode=False, + label_as_signal=True, + random_or_speed_split=True, + speed_and_load_available=False, + accel_in_second_dim=True, + target_sampling_rate_Hz=2000, + cnn_1dinput_len=256): + """ + Returns Sample Motor Data Limerick Dataset + """ + (data_dir, args) = data + + if load_train: + train_transform = transforms.Compose([ + ai8x.normalize(args=args) + ]) + + train_dataset = SampleMotorDataLimerick(root=data_dir, d_type='train', + download=download, + transform=train_transform, + signal_duration_in_sec=signal_duration_in_sec, + overlap_ratio=overlap_ratio, + eval_mode=eval_mode, + label_as_signal=label_as_signal, + random_or_speed_split=random_or_speed_split, + speed_and_load_available=speed_and_load_available, + accel_in_second_dim=accel_in_second_dim, + target_sampling_rate_Hz=target_sampling_rate_Hz, + cnn_1dinput_len=cnn_1dinput_len) + + print(f'Train dataset length: {len(train_dataset)}\n') + else: + train_dataset = None + + if load_test: + test_transform = transforms.Compose([ + ai8x.normalize(args=args) + ]) + + test_dataset = SampleMotorDataLimerick(root=data_dir, d_type='test', + download=download, + transform=test_transform, + signal_duration_in_sec=signal_duration_in_sec, + overlap_ratio=overlap_ratio, + eval_mode=eval_mode, + label_as_signal=label_as_signal, + random_or_speed_split=random_or_speed_split, + speed_and_load_available=speed_and_load_available, + accel_in_second_dim=accel_in_second_dim, + target_sampling_rate_Hz=target_sampling_rate_Hz, + cnn_1dinput_len=cnn_1dinput_len) + + print(f'Test dataset length: {len(test_dataset)}\n') + else: + test_dataset = None + + return train_dataset, test_dataset + + +def samplemotordatalimerick_get_datasets_for_train(data, + load_train=True, + load_test=True): + """" + Returns Sample Motor Data Limerick Dataset For Training Mode + """ + + eval_mode = False # Test set includes validation normals + label_as_signal = True + + signal_duration_in_sec = 0.25 + overlap_ratio = 0.75 + + target_sampling_rate_Hz = 2000 + cnn_1dinput_len = 256 + + # ds_ratio = 10, sr: 20K / 10 = 2000, 0.25 sec window, fft input will have: 500 samples, + # fftout's first 256 samples will be used + # cnn input will have 256 samples + + accel_in_second_dim = True + + random_or_speed_split = True + speed_and_load_available = False + + return samplemotordatalimerick_get_datasets(data, load_train, load_test, + signal_duration_in_sec=signal_duration_in_sec, + overlap_ratio=overlap_ratio, + eval_mode=eval_mode, + label_as_signal=label_as_signal, + random_or_speed_split=random_or_speed_split, + speed_and_load_available=speed_and_load_available, + accel_in_second_dim=accel_in_second_dim, + target_sampling_rate_Hz=target_sampling_rate_Hz, + cnn_1dinput_len=cnn_1dinput_len) + + +def samplemotordatalimerick_get_datasets_for_eval_with_anomaly_label(data, + load_train=True, + load_test=True): + """" + Returns Sample Motor Data Limerick Dataset For Evaluation Mode + Label is anomaly status + """ + + eval_mode = True # Test set includes validation normals + label_as_signal = False + + signal_duration_in_sec = 0.25 + overlap_ratio = 0.75 + + target_sampling_rate_Hz = 2000 + cnn_1dinput_len = 256 + + # ds_ratio = 10, sr: 20K / 10 = 2000, 0.25 sec window, fft input will have: 500 samples, + # fftout's first 256 samples will be used + # cnn input will have 256 samples + + accel_in_second_dim = True + + random_or_speed_split = True + speed_and_load_available = False + + return samplemotordatalimerick_get_datasets(data, load_train, load_test, + signal_duration_in_sec=signal_duration_in_sec, + overlap_ratio=overlap_ratio, + eval_mode=eval_mode, + label_as_signal=label_as_signal, + random_or_speed_split=random_or_speed_split, + speed_and_load_available=speed_and_load_available, + accel_in_second_dim=accel_in_second_dim, + target_sampling_rate_Hz=target_sampling_rate_Hz, + cnn_1dinput_len=cnn_1dinput_len) + + +def samplemotordatalimerick_get_datasets_for_eval_with_signal(data, + load_train=True, + load_test=True): + """" + Returns Sample Motor Data Limerick Dataset For Evaluation Mode + Label is signal + """ + + eval_mode = True # Test set includes anormal samples as well as validation normals + label_as_signal = True + + signal_duration_in_sec = 0.25 + overlap_ratio = 0.75 + + target_sampling_rate_Hz = 2000 + cnn_1dinput_len = 256 + + # ds_ratio = 10, sr: 20K / 10 = 2000, 0.25 sec window, fft input will have: 500 samples, + # fftout's first 256 samples will be used + # cnn input will have 256 samples + + accel_in_second_dim = True + + random_or_speed_split = True + speed_and_load_available = False + + return samplemotordatalimerick_get_datasets(data, load_train, load_test, + signal_duration_in_sec=signal_duration_in_sec, + overlap_ratio=overlap_ratio, + eval_mode=eval_mode, + label_as_signal=label_as_signal, + random_or_speed_split=random_or_speed_split, + speed_and_load_available=speed_and_load_available, + accel_in_second_dim=accel_in_second_dim, + target_sampling_rate_Hz=target_sampling_rate_Hz, + cnn_1dinput_len=cnn_1dinput_len) + + +datasets = [ + { + 'name': 'SampleMotorDataLimerick_ForTrain', + 'input': (256, 3), + 'output': ('signal'), + 'regression': True, + 'loader': samplemotordatalimerick_get_datasets_for_train, + }, + { + 'name': 'SampleMotorDataLimerick_ForEvalWithAnomalyLabel', + 'input': (256, 3), + 'output': ('normal', 'anomaly'), + 'loader': samplemotordatalimerick_get_datasets_for_eval_with_anomaly_label, + }, + { + 'name': 'SampleMotorDataLimerick_ForEvalWithSignal', + 'input': (256, 3), + 'output': ('signal'), + 'loader': samplemotordatalimerick_get_datasets_for_eval_with_signal, + } +] diff --git a/datasets/signalmixer.py b/datasets/signalmixer.py new file mode 100644 index 000000000..68845f1ae --- /dev/null +++ b/datasets/signalmixer.py @@ -0,0 +1,136 @@ +# +# Copyright (c) 2018 Intel Corporation +# Portions Copyright (C) 2019-2023 Maxim Integrated Products, Inc. +# Portions Copyright (C) 2023-2024 Analog Devices, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +""" +Classes and functions used to create noisy keyword spotting dataset. +""" +import numpy as np +import torch + + +class signalmixer: + """ + Signal mixer dataloader to create datasets with specified + length using a noise dataset and a speech dataset and a specified SNR level. + + Args: + signal_dataset(object): KWS dataset object. + snr(int): SNR level to be created in the mixed dataset. + noise_kind(string): Noise kind that will be applied to the speech dataset. + noise_dataset(object, optional): MSnoise dataset object. + """ + + def __init__(self, signal_dataset, snr, noise_kind, noise_dataset=None): + + self.signal_data = signal_dataset.data + self.signal_targets = signal_dataset.targets + + if noise_kind != 'WhiteNoise': + self.noise_data = noise_dataset.data + self.noise_targets = noise_dataset.targets + + # using getitem to reach the noise test data + self.noise_dataset_float = next(iter(torch.utils.data.DataLoader( + noise_dataset, batch_size=noise_dataset.dataset_len)))[0] + + self.noise_rms = noise_dataset.rms + + self.snr = snr + self.noise_kind = noise_kind + + # using getitem to reach the speech test data + self.test_dataset_float = next(iter(torch.utils.data.DataLoader( + signal_dataset, batch_size=signal_dataset.data.shape[0])))[0] + + if noise_kind == 'WhiteNoise': + self.mixed_signal = self.white_noise_mixer() + else: + self.mixed_signal = self.snr_mixer() + + def __getitem__(self, index): + + inp = self.mixed_signal[index].type(torch.FloatTensor) + target = int(self.signal_targets[index]) + return inp, target + + def __len__(self): + return len(self.mixed_signal) + + def snr_mixer(self): + ''' creates mixed signal dataset using the SNR level and the noise dataset + ''' + clean = self.test_dataset_float + noise = self.noise_dataset_float + + idx = np.random.randint(0, noise.shape[0], clean.shape[0]) + noise = noise[idx] + rms_noise = self.noise_rms[idx] + + snr = self.snr + + rmsclean = torch.sqrt(torch.mean(clean.reshape( + clean.shape[0], -1)**2, 1, keepdims=True)).unsqueeze(1) + scalarclean = 1 / rmsclean + clean = clean * scalarclean + + scalarnoise = 1 / rms_noise.reshape(-1, 1, 1) + noise = noise * scalarnoise + + cleanfactor = 10**(snr/20) + noisyspeech = cleanfactor * clean + noise + noisyspeech = noisyspeech / (torch.tensor(scalarnoise) + cleanfactor * scalarclean) + + # 16384 --> (noisyspeech[0].shape[0])*(noisyspeech[0].shape[1]) + speech_shape = noisyspeech[0].shape[0]*noisyspeech[0].shape[1] + max_mixed = torch.max(abs(noisyspeech.reshape( + noisyspeech.shape[0], speech_shape)), 1, keepdims=True).values + + noisyspeech = noisyspeech * (1 / max_mixed).unsqueeze(1) + return noisyspeech + + def white_noise_mixer(self): + + '''creates mixed signal dataset using the SNR level and white noise + ''' + clean = self.test_dataset_float + snr = self.snr + + mean = 0 + std = 1 + noise = np.random.normal(mean, std, clean.shape) + noise = torch.tensor(noise, dtype=torch.float32) + + rmsclean = (torch.mean(clean.reshape( + clean.shape[0], -1)**2, 1, keepdims=True)**0.5).unsqueeze(1) + scalarclean = 1 / rmsclean + clean = clean * scalarclean + + rmsnoise = (torch.mean(noise.reshape( + noise.shape[0], -1)**2, 1, keepdims=True)**0.5).unsqueeze(1) + scalarnoise = 1 / rmsnoise + noise = noise * scalarnoise + + cleanfactor = 10**(snr/20) + noisyspeech = cleanfactor * clean + noise + noisyspeech = noisyspeech / (scalarnoise + cleanfactor * scalarclean) + + # scaling to ~[-1,1] + max_mixed = torch.max(abs(noisyspeech.reshape( + noisyspeech.shape[0], 16384)), 1, keepdims=True).values + noisyspeech = noisyspeech * (1 / max_mixed).unsqueeze(1) + + return noisyspeech diff --git a/datasets/speechcom.py b/datasets/speechcom.py index 18b6082c6..a6ad10da4 100644 --- a/datasets/speechcom.py +++ b/datasets/speechcom.py @@ -1,9 +1,9 @@ ################################################################################################### # # Copyright (C) 2019-2023 Maxim Integrated Products, Inc. All Rights Reserved. +# Copyright (C) 2024 Analog Devices, Inc. All Rights Reserved. # -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html +# This software is proprietary to Analog Devices, Inc. and its licensors. # ################################################################################################### """ @@ -102,7 +102,7 @@ def __gen_datasets(self): print('Generating dataset from raw data samples.') with warnings.catch_warnings(): warnings.simplefilter('error') - lst = os.listdir(self.raw_folder) + lst = sorted(os.listdir(self.raw_folder)) labels = [d for d in lst if os.path.isdir(os.path.join(self.raw_folder, d)) and d[0].isalpha()] train_images = [] @@ -113,8 +113,7 @@ def __gen_datasets(self): test_labels = [] for i, label in enumerate(labels): print(f'\tProcessing the label: {label}. {i+1} of {len(labels)}') - records = os.listdir(os.path.join(self.raw_folder, label)) - records = sorted(records) + records = sorted(os.listdir(os.path.join(self.raw_folder, label))) for record in records: record_pth = os.path.join(self.raw_folder, label, record) y, _ = librosa.load(record_pth, offset=0, sr=None) diff --git a/datasets/vggface2.py b/datasets/vggface2.py index 6f872f967..a36d258c1 100644 --- a/datasets/vggface2.py +++ b/datasets/vggface2.py @@ -1,6 +1,6 @@ ################################################################################################### # -# Copyright (C) 2019-2022 Maxim Integrated Products, Inc. All Rights Reserved. +# Copyright (C) 2019-2024 Maxim Integrated Products, Inc. All Rights Reserved. # # Maxim Integrated Products, Inc. Default Copyright Notice: # https://www.maximintegrated.com/en/aboutus/legal/copyrights.html @@ -10,80 +10,442 @@ VGGFace2: A Dataset for Recognising Faces across Pose and Age https://ieeexplore.ieee.org/abstract/document/8373813 """ + +import errno +import glob import os import pickle -import time import numpy as np import torch -from torch.utils import data +import torchvision.transforms.functional as FT +from torch.utils.data import Dataset +from torchvision import transforms + +import cv2 +import face_detection +import kornia.geometry.transform as GT +from PIL import Image +from skimage import transform as trans +from tqdm import tqdm + +import ai8x +from utils import augmentation_utils -class VGGFace2Dataset(data.Dataset): +class VGGFace2(Dataset): """ - VGGFace2: A Dataset for Recognising Faces across Pose and Age - https://ieeexplore.ieee.org/abstract/document/8373813 + VGGFace2 Dataset """ - def __init__( - self, - root_dir, - d_type, - transform=None, - resample_subj=1, - resample_img_per_subj=1, - ): - data_folder = os.path.join(root_dir, d_type) - assert os.path.isdir(data_folder), (f'No dataset at {data_folder}.' - ' Follow the steps at datasets/face_id/README.md') - - data_file_list = sorted([d for d in os.listdir(data_folder) if d.startswith('whole_set')]) - - self.sid_list = [] - self.embedding_list = [] - self.img_list = [] + def __init__(self, root_dir, d_type, mode, transform=None, + teacher_transform=None, img_size=(112, 112)): + + if d_type not in ('test', 'train'): + raise ValueError("d_type can only be set to 'test' or 'train'") + + if mode not in ('detection', 'identification', 'identification_dr'): + raise ValueError("mode can only be set to 'detection', 'identification'," + "or 'identification_dr'") + + self.root_dir = root_dir + self.d_type = d_type self.transform = transform + self.teacher_transform = teacher_transform + self.img_size = img_size + self.mode = mode + self.dataset_path = os.path.join(self.root_dir, "VGGFace-2") + self.__makedir_exist_ok(self.dataset_path) + self.count = 0 + self.tform = trans.SimilarityTransform() + self.src = np.array([ + [38.2946, 51.6963], + [73.5318, 51.5014], + [56.0252, 71.7366], + [41.5493, 92.3655], + [70.7299, 92.2041]], dtype=np.float32) + + self.__makedir_exist_ok(self.dataset_path) + self.__makedir_exist_ok(os.path.join(self.dataset_path, "processed")) + + if self.d_type in ('train', 'test'): + self.gt_path = os.path.join(self.dataset_path, "processed", + self.d_type+"_vggface2.pickle") + self.d_path = os.path.join(self.dataset_path, self.d_type) + if not os.path.exists(self.gt_path): + assert os.path.isdir(self.d_path), (f'No dataset at {self.d_path}.\n' + ' Please review the term and' + ' conditions at https://www.robots.ox.ac.uk/' + '~vgg/data/vgg_face2/ . Then, download the' + ' dataset and extract raw images to the' + ' train and test subfolders.\n' + ' Expected folder structure: \n' + ' - root_dir \n' + ' - VGGFace-2 \n' + ' - train \n' + ' - test \n') + + print("Extracting ground truth from the " + self.d_type + " set") + self.__extract_gt() + + f = open(self.gt_path, 'rb') + self.pickle_dict = pickle.load(f) + f.close() + + else: + print(f'Unknown data type: {self.d_type}') + return - subj_idx = 0 - n_elems = 0 + def __extract_gt(self): + """ + Extracts the ground truth from the dataset + """ + detector = face_detection.build_detector("RetinaNetResNet50", confidence_threshold=.5, + nms_iou_threshold=.4) + img_paths = list(glob.glob(os.path.join(self.d_path + '/**/', '*.jpg'), recursive=True)) + nf_number = 0 + words_count = 0 + pickle_dict = {key: [] for key in ["boxes", "landmarks", "img_list", "lbl_list"]} + pickle_dict["word2index"] = {} - t_start = time.time() - print('Data loading...') - for n_file, data_file in enumerate(data_file_list): - if ((n_file+1) % 5) == 0: - print(f'\t{n_file+1} of {len(data_file_list)}') - f_path = os.path.join(data_folder, data_file) + for jpg in tqdm(img_paths): + boxes = [] + image = cv2.imread(jpg) - with open(f_path, 'rb') as f: - x = pickle.load(f) + img_max = max(image.shape[0], image.shape[1]) + if img_max > 1320: + continue + bboxes, lndmrks = detector.batched_detect_with_landmarks(np.expand_dims(image, 0)) + bboxes = bboxes[0] + lndmrks = lndmrks[0] - for key in list(x)[::resample_subj]: - val = x[key] - for key2 in list(val)[::resample_img_per_subj]: - self.img_list.append(val[key2]['img']) - self.embedding_list.append(np.array(val[key2]['embedding']).astype(np.float32)) - self.sid_list.append(subj_idx) - n_elems += 1 - subj_idx += resample_subj + if (bboxes.shape[0] == 0) or (lndmrks.shape[0] == 0): + nf_number += 1 + continue - t_end = time.time() - print(f'{n_elems} of data samples loaded in {t_end-t_start:.4f} seconds.') + for box in bboxes: + box = np.clip(box[:4], 0, None) + boxes.append(box) - def __normalize_data(self, data_item): - data_item = data_item.astype(np.float32) - data_item /= 256 - return data_item + lndmrks = lndmrks[0] + + dir_name = os.path.dirname(jpg) + lbl = os.path.relpath(dir_name, self.d_path) + + if lbl not in pickle_dict["word2index"]: + pickle_dict["word2index"][lbl] = words_count + words_count += 1 + + pickle_dict["lbl_list"].append(lbl) + pickle_dict["boxes"].append(boxes) + pickle_dict["landmarks"].append(lndmrks) + pickle_dict["img_list"].append(os.path.relpath(jpg, self.dataset_path)) + if nf_number > 0: + print(f'Not found any faces in {nf_number} images ') + + with open(self.gt_path, 'wb') as f: + pickle.dump(pickle_dict, f) def __len__(self): - return len(self.img_list) + return len(self.pickle_dict["img_list"]) - 1 + + def __getitem__(self, index): + """ + Get the image and associated target according to the mode + """ + if index >= len(self): + raise IndexError + + if self.mode == 'detection': + return self.__getitem_detection(index) + + if self.mode == 'identification': + return self.__getitem_identification(index) + + if self.mode == 'identification_dr': + return self.__getitem_identification_dr(index) + + # Will never reached + return None + + def __getitem_detection(self, index): + """ + Get the image and associated target for face detection + """ + if torch.is_tensor(index): + index = index.tolist() + + img = Image.open(os.path.join(self.dataset_path, self.pickle_dict["img_list"][index])) + img = FT.to_tensor(img) - def __getitem__(self, idx): - embedding = self.embedding_list[idx] - embedding = np.expand_dims(embedding, 1) - embedding = np.expand_dims(embedding, 2) - embedding *= 6.0 + boxes = self.pickle_dict["boxes"][index] + boxes = torch.as_tensor(boxes, dtype=torch.float32) - inp = torch.tensor(self.__normalize_data(self.img_list[idx]), dtype=torch.float) + img, boxes = augmentation_utils.resize(img, boxes, + dims=(self.img_size[0], self.img_size[1])) + + labels = [1] * boxes.shape[0] + + if self.transform is not None: + img = self.transform(img) + + boxes = boxes.clamp_(min=0, max=1) + labels = torch.as_tensor(labels, dtype=torch.int64) + + return img, (boxes, labels) + + def __getitem_identification(self, index): + """ + Get the image and associated target for face identification + """ + if torch.is_tensor(index): + index = index.tolist() + + lbl = self.pickle_dict["lbl_list"][index] + lbl_index = self.pickle_dict["word2index"][lbl] + lbl_index = torch.tensor(lbl_index, dtype=torch.long) + box = self.pickle_dict["boxes"][index][0] + img = Image.open(os.path.join(self.dataset_path, self.pickle_dict["img_list"][index])) + img_A = img.copy() + + # Apply transformation to the image that will be aligned + if self.teacher_transform is not None: + img_A = self.teacher_transform(img_A) + + # Apply transformation to the image that will be cropped + if self.transform is not None: + img = self.transform(img) + + # Use landmarks to estimate affine transformation + landmark = self.pickle_dict["landmarks"][index] + self.tform.estimate(landmark, self.src) + A = self.tform.params[0:2, :] + A = torch.as_tensor(A, dtype=torch.float32) + A = A.unsqueeze(0) + + # Apply affine transformation to obtain aligned image + img_A = GT.warp_affine(img_A.unsqueeze(0), A, (self.img_size[0], self.img_size[1])) + img_A = img_A.squeeze(0) + + # Convert bounding box to square + height = box[3] - box[1] + width = box[2] - box[0] + max_dim = max(height, width) + box[0] = np.clip(box[0] - (max_dim - width) / 2, 0, img.shape[2]) + box[1] = np.clip(box[1] - (max_dim - height) / 2, 0, img.shape[1]) + box[2] = np.clip(box[2] + (max_dim - width) / 2, 0, img.shape[2]) + box[3] = np.clip(box[3] + (max_dim - height) / 2, 0, img.shape[1]) + + # Crop image with the square bounding box + img_C = FT.crop(img=img, top=int(box[1]), left=int(box[0]), + height=int(box[3]-box[1]), width=int(box[2]-box[0])) + + # Check if the cropped image is square, if not, pad it + _, h, w = img_C.shape + if w != h: + max_dim = max(w, h) + h_padding = (max_dim - h) / 2 + w_padding = (max_dim - w) / 2 + l_pad = w_padding if w_padding % 1 == 0 else w_padding+0.5 + t_pad = h_padding if h_padding % 1 == 0 else h_padding+0.5 + r_pad = w_padding if w_padding % 1 == 0 else w_padding-0.5 + b_pad = h_padding if h_padding % 1 == 0 else h_padding-0.5 + padding = (int(l_pad), int(t_pad), int(r_pad), int(b_pad)) + img_C = FT.pad(img_C, padding, 0, 'constant') + + # Resize cropped image to the desired size + img_C = FT.resize(img_C, (self.img_size[0], self.img_size[1])) + + # Concatenate images + concat_img = torch.cat((img_C, img_A), 0) + + return concat_img, lbl_index + + def __getitem_identification_dr(self, index): + """ + Get the image and associated target for dimensionality reduction + """ + if torch.is_tensor(index): + index = index.tolist() + + lbl = self.pickle_dict["lbl_list"][index] + lbl_index = self.pickle_dict["word2index"][lbl] + lbl_index = torch.tensor(lbl_index, dtype=torch.long) + img = Image.open(os.path.join(self.dataset_path, self.pickle_dict["img_list"][index])) + + # Apply transformation to the image that will be aligned if self.transform is not None: - inp = self.transform(inp) + img = self.transform(img) + + # Use landmarks to estimate affine transformation + landmark = self.pickle_dict["landmarks"][index] + self.tform.estimate(landmark, self.src) + A = self.tform.params[0:2, :] + A = torch.as_tensor(A, dtype=torch.float32) + A = A.unsqueeze(0) + + # Apply affine transformation to obtain aligned image + img = GT.warp_affine(img.unsqueeze(0), A, (self.img_size[0], self.img_size[1])) + img = img.squeeze(0) + + return img, lbl_index + + @staticmethod + def __makedir_exist_ok(dirpath): + """Make directory if not already exists + """ + try: + os.makedirs(dirpath) + except OSError as e: + if e.errno == errno.EEXIST: + pass + else: + raise + + @staticmethod + def collate_fn(batch): + """ + Since each image may have a different number of objects, we need a collate function + (to be passed to the DataLoader). + This describes how to combine these tensors of different sizes. We use lists. + :param batch: an iterable of N sets from __getitem__() + :return: a tensor of images, lists of varying-size tensors of bounding boxes and labels + """ + images = [] + boxes_and_labels = [] + + for b in batch: + images.append(b[0]) + boxes_and_labels.append(b[1]) + + images = torch.stack(images, dim=0) + return images, boxes_and_labels + + +def VGGFace2_FaceID_get_datasets(data, load_train=True, load_test=True, img_size=(112, 112)): + + """ Returns FaceID Dataset + """ + (data_dir, args) = data + + train_transform = transforms.Compose([ + transforms.ToTensor(), + transforms.RandomHorizontalFlip(p=0.5), + transforms.ColorJitter(brightness=(0.6, 1.4), saturation=(0.6, 1.4), + contrast=(0.6, 1.4), hue=(-0.4, 0.4)), + transforms.RandomErasing(p=0.1), + ai8x.normalize(args=args)]) + + teacher_transform = transforms.Compose([ + transforms.ToTensor(), + ai8x.normalize(args=args)]) + + if load_train: + + train_dataset = VGGFace2(root_dir=data_dir, d_type='train', mode='identification', + transform=train_transform, teacher_transform=teacher_transform, + img_size=img_size) + + print(f'Train dataset length: {len(train_dataset)}\n') + else: + train_dataset = None + + if load_test: + test_transform = transforms.Compose([transforms.ToTensor(), + ai8x.normalize(args=args)]) + + test_dataset = VGGFace2(root_dir=data_dir, d_type='test', mode='identification', + transform=test_transform, teacher_transform=teacher_transform, + img_size=img_size) + + print(f'Test dataset length: {len(test_dataset)}\n') + else: + test_dataset = None + + return train_dataset, test_dataset + + +def VGGFace2_FaceID_dr_get_datasets(data, load_train=True, load_test=True, img_size=(112, 112)): + + """ Returns FaceID Dataset for dimensionality reduction + """ + (data_dir, args) = data + + train_transform = transforms.Compose([ + transforms.ToTensor(), + transforms.RandomHorizontalFlip(p=0.5), + ai8x.normalize(args=args)]) + + if load_train: + + train_dataset = VGGFace2(root_dir=data_dir, d_type='train', mode='identification_dr', + transform=train_transform, img_size=img_size) + + print(f'Train dataset length: {len(train_dataset)}\n') + else: + train_dataset = None + + if load_test: + test_transform = transforms.Compose([transforms.ToTensor(), + ai8x.normalize(args=args)]) + + test_dataset = VGGFace2(root_dir=data_dir, d_type='test', mode='identification_dr', + transform=test_transform, img_size=img_size) + + print(f'Test dataset length: {len(test_dataset)}\n') + else: + test_dataset = None + + return train_dataset, test_dataset + + +def VGGFace2_Facedet_get_datasets(data, load_train=True, load_test=True, img_size=(224, 168)): + + """ Returns FaceDetection Dataset + """ + (data_dir, args) = data + + if load_train: + train_transform = transforms.Compose([ + ai8x.normalize(args=args)]) + + train_dataset = VGGFace2(root_dir=data_dir, d_type='train', mode='detection', + transform=train_transform, img_size=img_size) + + print(f'Train dataset length: {len(train_dataset)}\n') + else: + train_dataset = None + + if load_test: + test_transform = transforms.Compose([ai8x.normalize(args=args)]) + + test_dataset = VGGFace2(root_dir=data_dir, d_type='test', mode='detection', + transform=test_transform, img_size=img_size) + + print(f'Test dataset length: {len(test_dataset)}\n') + else: + test_dataset = None + + return train_dataset, test_dataset + - return inp, torch.tensor(embedding, dtype=torch.float) +datasets = [ + { + 'name': 'VGGFace2_FaceID', + 'input': (3, 112, 112), + 'output': ('id'), + 'loader': VGGFace2_FaceID_get_datasets, + }, + { + 'name': 'VGGFace2_FaceID_dr', + 'input': (3, 112, 112), + 'output': [*range(0, 8631, 1)], + 'loader': VGGFace2_FaceID_dr_get_datasets, + }, + { + 'name': 'VGGFace2_FaceDetection', + 'input': (3, 224, 168), + 'output': ([1]), + 'loader': VGGFace2_Facedet_get_datasets, + 'collate': VGGFace2.collate_fn + } +] diff --git a/datasets/vggface2_facedet.py b/datasets/vggface2_facedet.py deleted file mode 100644 index d63a4dc2b..000000000 --- a/datasets/vggface2_facedet.py +++ /dev/null @@ -1,214 +0,0 @@ -################################################################################################### -# -# Copyright (C) 2023 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -""" -VGGFace2: A Dataset for Recognising Faces across Pose and Age -https://ieeexplore.ieee.org/abstract/document/8373813 -""" - - -import errno -import glob -import os -import pickle - -import torch -from torch.utils.data import Dataset -from torchvision import transforms - -from PIL import Image -from tqdm import tqdm - -import ai8x -from datasets.face_id.facenet_pytorch import MTCNN - - -class VGGFace2_FaceDetectionDataset(Dataset): - """ - VGGFace2 Dataset for face detection - - MTCNN is used to extract the ground truth from the dataset as it provides - the ground truth for multiple faces in an image. - - GT Format: 0-3:Box Coordinates - - """ - def __init__(self, root_dir, d_type, transform=None, img_size=(224, 168)): - - if d_type not in ('test', 'train'): - raise ValueError("d_type can only be set to 'test' or 'train'") - - self.root_dir = root_dir - self.d_type = d_type - self.transform = transform - self.img_size = img_size - self.dataset_path = os.path.join(self.root_dir, "VGGFace-2") - self.__makedir_exist_ok(self.dataset_path) - self.__makedir_exist_ok(os.path.join(self.dataset_path, "processed")) - - if self.d_type in ('train', 'test'): - self.gt_path = os.path.join(self.dataset_path, "processed", self.d_type+"_gt.pickle") - self.d_path = os.path.join(self.dataset_path, self.d_type) - if not os.path.exists(self.gt_path): - assert os.path.isdir(self.d_path), (f'No dataset at {self.d_path}.\n' - ' Please review the term and' - ' conditions at https://www.robots.ox.ac.uk/' - '~vgg/data/vgg_face2/ . Then, download the' - ' dataset and extract raw images to the' - ' train and test subfolders.\n' - ' Expected folder structure: \n' - ' - root_dir \n' - ' - VGGFace-2 \n' - ' - train \n' - ' - test \n') - - print("Extracting ground truth from the " + self.d_type + " set") - self.__extract_gt() - - else: - print(f'Unknown data type: {self.d_type}') - return - - f = open(self.gt_path, 'rb') - self.pickle_dict = pickle.load(f) - f.close() - - def __extract_gt(self): - """ - Extracts the ground truth from the dataset - """ - mtcnn = MTCNN() - img_paths = list(glob.glob(os.path.join(self.d_path + '/**/', '*.jpg'), recursive=True)) - nf_number = 0 - pickle_dict = {key: [] for key in ["gt", "img_list"]} - - for jpg in tqdm(img_paths): - img = Image.open(jpg) - img = img.resize((self.img_size[1], self.img_size[0])) - # pylint: disable-next=unbalanced-tuple-unpacking - gt, _ = mtcnn.detect(img, landmarks=False) # type: ignore # returns tuple of 2 - - if gt is None or None in gt: - nf_number += 1 - continue - - pickle_dict["gt"].append(gt) - pickle_dict["img_list"].append(os.path.relpath(jpg, self.dataset_path)) - - if nf_number > 0: - print(f'Not found any faces in {nf_number} images ') - - with open(self.gt_path, 'wb') as f: - pickle.dump(pickle_dict, f) - - def __len__(self): - return len(self.pickle_dict["img_list"]) - 1 - - def __getitem__(self, index): - if index >= len(self): - raise IndexError - - if torch.is_tensor(index): - index = index.tolist() - - img = Image.open(os.path.join(self.dataset_path, self.pickle_dict["img_list"][index])) - - ground_truth = self.pickle_dict["gt"][index] - - lbls = [1] * ground_truth.shape[0] - if self.transform is not None: - img = self.transform(img) - for box in ground_truth: - box[0] = box[0] / self.img_size[1] - box[2] = box[2] / self.img_size[1] - box[1] = box[1] / self.img_size[0] - box[3] = box[3] / self.img_size[0] - - boxes = torch.as_tensor(ground_truth, dtype=torch.float32) - boxes = boxes.clamp_(min=0, max=1) - - labels = torch.as_tensor(lbls, dtype=torch.int64) - - return img, (boxes, labels) - - @staticmethod - def collate_fn(batch): - """ - Since each image may have a different number of objects, we need a collate function - (to be passed to the DataLoader). - This describes how to combine these tensors of different sizes. We use lists. - :param batch: an iterable of N sets from __getitem__() - :return: a tensor of images, lists of varying-size tensors of bounding boxes and labels - """ - images = [] - boxes_and_labels = [] - - for b in batch: - images.append(b[0]) - boxes_and_labels.append(b[1]) - - images = torch.stack(images, dim=0) - return images, boxes_and_labels - - @staticmethod - def __makedir_exist_ok(dirpath): - """Make directory if not already exists - """ - try: - os.makedirs(dirpath) - except OSError as e: - if e.errno == errno.EEXIST: - pass - else: - raise - - -def VGGFace2_Facedet_get_datasets(data, load_train=True, load_test=True, img_size=(224, 168)): - - """ Returns FaceDetection Dataset - """ - (data_dir, args) = data - - if load_train: - train_transform = transforms.Compose([ - transforms.ToTensor(), - transforms.Resize(img_size), - ai8x.normalize(args=args) - ]) - - train_dataset = VGGFace2_FaceDetectionDataset(root_dir=data_dir, d_type='train', - transform=train_transform, img_size=img_size) - - print(f'Train dataset length: {len(train_dataset)}\n') - else: - train_dataset = None - - if load_test: - test_transform = transforms.Compose([transforms.ToTensor(), - transforms.Resize(img_size), - ai8x.normalize(args=args)]) - - test_dataset = VGGFace2_FaceDetectionDataset(root_dir=data_dir, d_type='test', - transform=test_transform, img_size=img_size) - - print(f'Test dataset length: {len(test_dataset)}\n') - else: - test_dataset = None - - return train_dataset, test_dataset - - -datasets = [ - { - 'name': 'VGGFace2_FaceDetection', - 'input': (3, 224, 168), - 'output': ([1]), - 'loader': VGGFace2_Facedet_get_datasets, - 'collate': VGGFace2_FaceDetectionDataset.collate_fn - } -] diff --git a/datasets/youtube_faces.py b/datasets/youtube_faces.py deleted file mode 100644 index 6bf4bee58..000000000 --- a/datasets/youtube_faces.py +++ /dev/null @@ -1,91 +0,0 @@ -################################################################################################### -# -# Copyright (C) 2019-2022 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -""" -YouTube Faces Dataset -https://www.cs.tau.ac.il/~wolf/ytfaces/ -""" -import os -import pickle -import time - -import numpy as np -import torch -from torch.utils import data - - -class YouTubeFacesDataset(data.Dataset): - """ - YouTube Faces Dataset - https://www.cs.tau.ac.il/~wolf/ytfaces/ - """ - def __init__( - self, - root_dir, - d_type, - transform=None, - resample_subj=1, - resample_img_per_subj=1, - ): - data_folder = os.path.join(root_dir, d_type) - assert os.path.isdir(data_folder), (f'No dataset at {data_folder}.' - ' Follow the steps at datasets/face_id/README.md') - - data_file_list = sorted([d for d in os.listdir(data_folder) if d.startswith('whole_set')]) - - self.sid_list = [] - self.embedding_list = [] - self.img_list = [] - self.transform = transform - - subj_idx = 0 - n_elems = 0 - - t_start = time.time() - print('Data loading...') - for n_file, data_file in enumerate(data_file_list): - print(f'\t{n_file+1} of {len(data_file_list)}') - f_path = os.path.join(data_folder, data_file) - - with open(f_path, 'rb') as f: - x = pickle.load(f) - - for key in list(x)[::resample_subj]: - val = x[key] - for key2 in list(val)[::resample_img_per_subj]: - for key3 in list(val[key2]): - self.img_list.append(val[key2][key3]['img']) - self.embedding_list.append( - np.array(val[key2][key3]['embedding']).astype(np.float32) - ) - self.sid_list.append(subj_idx) - n_elems += 1 - subj_idx += resample_subj - - t_end = time.time() - print(f'{n_elems} of data samples loaded in {t_end-t_start:.4f} seconds.') - - def __normalize_data(self, data_item): - data_item = data_item.astype(np.float32) - data_item /= 256 - return data_item - - def __len__(self): - return len(self.img_list) - - def __getitem__(self, idx): - embedding = self.embedding_list[idx] - embedding = np.expand_dims(embedding, 1) - embedding = np.expand_dims(embedding, 2) - embedding *= 6.0 - - inp = torch.tensor(self.__normalize_data(self.img_list[idx]), dtype=torch.float) - if self.transform is not None: - inp = self.transform(inp) - - return inp, torch.tensor(embedding, dtype=torch.float) diff --git a/devices.py b/devices.py index ab72514a7..8693ea430 100644 --- a/devices.py +++ b/devices.py @@ -1,5 +1,5 @@ ################################################################################################### -# Copyright (C) Maxim Integrated Products, Inc. All Rights Reserved. +# Copyright (C) 2020-2023 Maxim Integrated Products, Inc. All Rights Reserved. # # Maxim Integrated Products, Inc. Default Copyright Notice: # https://www.maximintegrated.com/en/aboutus/legal/copyrights.html diff --git a/distiller b/distiller index 23c185fa3..0477a66ef 160000 --- a/distiller +++ b/distiller @@ -1 +1 @@ -Subproject commit 23c185fa37fada2ed47b6aa81cd3189932a150f5 +Subproject commit 0477a66ef0ace09f5572f27c0178ea422ed9bf4e diff --git a/docs/FacialRecognitionSystem.md b/docs/FacialRecognitionSystem.md new file mode 100644 index 000000000..b754ae7a1 --- /dev/null +++ b/docs/FacialRecognitionSystem.md @@ -0,0 +1,106 @@ +# Facial Recognition System + +This document aims to explain facial recognition applications for MAX7800x series microcontrollers. The facial recognition task consists of three main parts: face detection, face identification and dot product: + +- The face detection model detects faces in the captured image and extracts a rectangular sub-image containing only one face. +- The face Identification model identifies a person from their facial images by generating the embedding for a given face image. +- The dot product layer outputs the dot product representing the similarity between the embedding from the given image and embeddings in the database. + +Figure 1 depicts the facial recognition system sequential diagram. + + + +Figure 1. MAX7800x facial recognition system + +## Dataset + +The first step will be the dataset preparation. The dataset is VGGFace-2 [1]. +Please review the term and conditions at [VGGFace2](https://www.robots.ox.ac.uk/~vgg/data/vgg_face2/). Then, download the dataset and extract raw images to the train and test subfolders. + +Expected folder structure: + + - root_dir + - VGGFace-2 + - train + - test + +FaceID and Face Detection tasks share the same ground truth pickle, and it will be automatically generated when one of these tasks started. + +## Face Detection + +To be able to localize faces in a facial recognition system, a face detection algorithm is generally used in facial recognition systems. Face detection is an object detection problem that has various solutions in the literature. In this work, a face detection algorithm that will run on MAX7800x series microcontrollers with real-time performance was targeted. + +For the digit detection problem, previously, a TinySSD[2] based MAX7800x object detection algorithm was developed, named TinierSSD. The face detection model is a modified version of the digit detection model. The modification reduces the number of parameters and enables larger input sizes. + +To train the face detection model, `scripts/train_facedet_tinierssd.sh` can be used. + +## FaceID + +To train a FaceID model for MAX7800x microcontrollers, there are multiple steps. As the MAX7800x FaceID models will be trained in a knowledge distillation fashion, the first step will be downloading a backbone checkpoint for the teacher model. + +The suggested teacher model is IR-152, but the other teacher models defined in `model_irse_drl.py` may be used as well. Please review the terms and conditions at face.evoLVe[3] repository, and download the checkpoint according to your teacher model selection. + +By default, both `scripts/train_faceid_112.sh` and `scripts/train_mobilefacenet_112.sh` use `Backbone_IR_152_Epoch_112_Batch_2547328_Time_2019-07-13-02-59_checkpoint.pth` which needs to be placed in the folder `pretrained` in the root directory of the repository. This checkpoint can be found via the [Model Zoo](https://github.com/ZhaoJ9014/face.evoLVe?tab=readme-ov-file#Model-Zoo) section of the face.evoLVe repository under “IR-152”. + +There are two FaceID models, one for the MAX78000 and one for the MAX78002. The MAX78000 one is named `faceid_112`, and it is a relatively lightweight model. To enable more performance on MAX78002, a more complex model was developed, which is named `mobilefacenet_112`. To train the FaceID models, `scripts/train_faceid_112.sh` and `scripts/train_mobilefacenet_112.sh` scripts can be used, respectively. By using the `--backbone-checkpoint` argument, the path to the checkpoint can be changed. + +The training scripts will run the Dimensionality Reduction and Relation Based-Knowledge Knowledge Distillation steps automatically. A summary of Dimensionality Reduction and Relation-Based Knowledge Distillation can be found in the following sub-sections. + +### Dimensionality Reduction on the Teacher Model + +Reducing embedding dimensionality can greatly reduce the post-processing operations and memory usage for the facial recognition system. To achieve this, the teacher backbone will be frozen and two additional Conv1d layers will be added to the teacher models. These additions are called dimension reduction layers. For the example in the repository, the length of the embeddings produced by the teacher model is 512 and the optimum length for the student model is found to be 64. Still, other choices like 32, 128 or 256 can be examined for different application areas. A summary of the dimensionality reduction is shown in Figure 2, and dimension reduction layer details are shown in Table 1. + + + + +Figure 2. Dimensionality Reduction + + + +Table 1. Dimension Reduction Layers + +| Layer1 | Layer2 | +|--------------------------------------| ------------------------------------| +| Conv1d(In=512ch, Out=512Ch, Kernel=1)| Conv1d(In=512ch, Out=64Ch, Kernel=1)| +| BatchNorm1d(512) | BatchNorm1d(64) | +| PReLU(512) | | + + + +To train dimensionality reduction layers, the Sub-Center ArcFace loss is used. The SubCenterArcFace Loss was presented in the [4], and a summary of the training framework can be seen in Figure 3. This loss function uses cosine similarity as the distance metric, and in the framework embedding network is trained as a part of the classification problem. The Normalized Sub-Centers (also known as the prototypes) must be learned from zero as no model is available to extract embeddings at the beginning. + + + +Figure 3. Sub-Center ArcFace Loss[4] + +### Relation-Based Knowledge Distillation + +The knowledge distillation choice for the FaceID models is relation-based. The distillation loss is calculated as the MSE between teacher model and student model. + +To train the student FaceID models, no student loss is used, so the student weight is set to 0. + +Figure 4 visually represents the relation-based knowledge distillation. + + + +Figure 4. Relation-Based Knowledge Distillation[5] + + + +## Dot Product Layer + +The dot product layer weights will be populated with the embeddings that are generated by MAX7800x FaceID models. The outputs of the FaceID models are normalized at both inference and recording. Therefore, the result of the dot product layer equals cosine similarity. Using the cosine similarity as a distance metric, the image is identified as either one of the known subjects or “Unknown”, depending on the embedding distances. To record new people in the database, there are two options. The first one is using the Python scripts that are available with the SDK demos. The second option is to use a “record on hardware” mode which does not require any external connection. The second option is not available for all platforms, therefore please check the SDK demo README files. + + + +## References + +[1] [Cao, Qiong, et al. "Vggface2: A dataset for recognising faces across pose and age." 2018 13th IEEE international conference on automatic face & gesture recognition (FG 2018). IEEE, 2018.](https://arxiv.org/abs/1710.08092) + +[2] [A. Womg, M. J. Shafiee, F. Li and B. Chwyl, "Tiny SSD: A Tiny Single-Shot Detection Deep Convolutional Neural Network for Real-Time Embedded Object Detection," 2018 15th Conference on Computer and Robot Vision (CRV), Toronto, ON, Canada, 2018, pp. 95-101, doi: 10.1109/CRV.2018.00023.](https://ieeexplore.ieee.org/document/8575741) + +[3] [face.evoLVe, High-Performance Face Recognition Library on PaddlePaddle & PyTorch](https://github.com/ZhaoJ9014/face.evoLVe) + +[4] [Deng, Jiankang, et al. "Arcface: Additive angular margin loss for deep face recognition." Proceedings of the IEEE/CVF conference on computer vision and pattern recognition. 2019.](https://arxiv.org/abs/1801.07698) + +[5] [Gou, Jianping, et al. "Knowledge distillation: A survey." International Journal of Computer Vision 129 (2021): 1789-1819.](https://arxiv.org/abs/2006.05525) diff --git a/docs/Regression.md b/docs/Regression.md deleted file mode 100644 index cd298576a..000000000 --- a/docs/Regression.md +++ /dev/null @@ -1,37 +0,0 @@ -# Regression Test - -The regression test for the `ai8x-training` repository is tested when there is a pull request for the `develop` branch of `MaximIntegratedAI/ai8x-training` by triggering `test.yaml` GitHub actions. - -## Last Tested Code - -`last_dev.py` generates the log files for the last tested code. These log files are used for comparing the newly pushed code to check if there are any significant changes in the trained values. Tracking is done by checking the hash of the commit. - -## Creating Test Scripts - -The sample training scripts are under the `scripts` path. In order to create training scripts for regression tests, these scripts are rewritten by changing their epoch numbers by running `regression/create_test_script.py`. The aim of changing the epoch number is to keep the duration of the test under control. This epoch number is defined in `regression/test_config.yaml` for each model/dataset combination. Since the sizes of the models and the datasets vary, different epoch numbers can be defined for each of them in order to create a healthy test. If a new training script is added, the epoch number and threshold values must be defined in the `regression/test_config.yaml` file for the relevant model. - -## Comparing Log Files - -After running test scripts for newly pushed code, the log files are saved and compared to the last tested code’s log files by running `regression/log_comparison.py`, and the results are saved. - -## Pass-Fail Decision - -In the comparison, the test success criterion is that the difference does not exceed the threshold values defined in `regression/test_config.yaml` as a percentage. If all the training scripts pass the test, `pass_fail.py` completes with success. Otherwise, it fails and exits. - -## ONNX Export - -Scripts for ONNX export are created and run by running `create_onnx_scripts.py` by configuring `Onnx_Status: True` in `regression/test_config.yaml`. If it is set to `False`, ONNX export will be skipped. - -## Configuration - -In `regression/test_config.yaml`, the `Onnx_Status` and `Qat_Test` settings should be defined to `True` when ONNX export or QAT tests by using `policies/qat_policy.yaml` are desired. When `Qat_Test` is set to `False`, QAT will be done according to the main training script. All threshold values and test epoch numbers for each model/dataset combination are also configured in this file. In order to set up the test on a new system, `regression/paths.yaml` needs to be configured accordingly. - -## Setting Up Regression Test - -### GitHub Actions - -GitHub Actions is a continuous integration (CI) and continuous deployment (CD) platform provided by GitHub. It allows developers to automate various tasks, workflows, and processes directly within their GitHub repositories. A GitHub Workflow is an automated process defined using a YAML file that helps automate various tasks in a GitHub repository. - -In this project, with GitHub Actions, there is a 'test.yml' workflow that is triggered when a pull request is opened for the 'develop' branch of the 'MaximIntegratedAI/ai8x-training' repository. This workflow contains and runs the jobs and steps required for the regression test. Also, a self hosted GitHub Runner is used to run regression test actions in this workflow. In order to install GitHub Runner, go to Settings -> Actions -> Runners -> New self-hosted runner on GitHub. To learn more about GitHub Actions, see [GitHub Actions](https://docs.github.com/en/actions/quickstart). - -After installing and configuring a GitHub Runner in your local environment, configure it to start as a service during system startup in order to ensure that the self-hosted runner runs continuously and automatically. You can find more information about systemd services at [Systemd Services](https://linuxhandbook.com/create-systemd-services/). diff --git a/docs/RelationBasedKD.png b/docs/RelationBasedKD.png new file mode 100644 index 000000000..a32f42c52 Binary files /dev/null and b/docs/RelationBasedKD.png differ diff --git a/docs/SubCenterArcFaceLoss.png b/docs/SubCenterArcFaceLoss.png new file mode 100644 index 000000000..11581aa42 Binary files /dev/null and b/docs/SubCenterArcFaceLoss.png differ diff --git a/docs/dimensionreductionlayers.png b/docs/dimensionreductionlayers.png new file mode 100644 index 000000000..f7a0b2b4d Binary files /dev/null and b/docs/dimensionreductionlayers.png differ diff --git a/docs/facialrecognition.png b/docs/facialrecognition.png new file mode 100644 index 000000000..4ee5c8035 Binary files /dev/null and b/docs/facialrecognition.png differ diff --git a/losses/multiboxloss.py b/losses/multiboxloss.py index 5fba90a93..5b3e17e7f 100644 --- a/losses/multiboxloss.py +++ b/losses/multiboxloss.py @@ -1,18 +1,32 @@ -################################################################################################### # -# Copyright (C) 2022-2023 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -# Multi Box Loss code is from GitHub repo: -# https://github.com/sgrvinod/a-PyTorch-Tutorial-to-Object-Detection: # MIT License +# # Copyright (c) 2019 Sagar Vinodababu -# Codes slightly with few minor modifications +# Portions Copyright (C) 2022-2023 Maxim Integrated Products, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# Multi Box Loss code source: +# https://github.com/sgrvinod/a-PyTorch-Tutorial-to-Object-Detection +# """ - Multi-box Loss for Object Detection Models +Multi-box Loss for Object Detection Models """ import torch from torch import nn diff --git a/models/ai85net-autoencoder.py b/models/ai85net-autoencoder.py new file mode 100755 index 000000000..caa316d8c --- /dev/null +++ b/models/ai85net-autoencoder.py @@ -0,0 +1,180 @@ +################################################################################################### +# +# Copyright (C) 2024 Analog Devices, Inc. All Rights Reserved. +# This software is proprietary to Analog Devices, Inc. and its licensors. +# +################################################################################################### +""" +Auto Encoder Network +""" + +from torch import nn + +import ai8x + + +class CNN_BASE(nn.Module): + """ + Auto Encoder Network + """ + def __init__(self, + num_channels=3, # pylint: disable=unused-argument + bias=True, # pylint: disable=unused-argument + weight_init="kaiming", # pylint: disable=unused-argument + num_classes=0, # pylint: disable=unused-argument + **kwargs): # pylint: disable=unused-argument + super().__init__() + + def initWeights(self, weight_init="kaiming"): + """ + Auto Encoder Weight Initialization + """ + weight_init = weight_init.lower() + assert weight_init in ('kaiming', 'xavier', 'glorot') + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + if weight_init == "kaiming": + nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') + + elif weight_init in ('glorot', 'xavier'): + nn.init.xavier_uniform_(m.weight) + + elif isinstance(m, nn.ConvTranspose2d): + if weight_init == "kaiming": + nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') + + elif weight_init in ('glorot', 'xavier'): + nn.init.xavier_uniform_(m.weight) + + elif isinstance(m, nn.Linear): + if weight_init == "kaiming": + nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') + + elif weight_init in ('glorot', 'xavier'): + nn.init.xavier_uniform_(m.weight) + + +class AI85AutoEncoder(CNN_BASE): + """ + Neural Network that has depthwise convolutions to reduce input dimensions. + Filters work across individual axis data first. + Output of 1D Conv layer is then flattened before being fed to fully connected layers + Fully connected layers down sample the data to a bottleneck. This completes the encoder. + The decoder is then the same in reverse + + Input Shape: [BATCH_SZ, FFT_LEN, N_AXES] -> [BATCH_SZ, 256, 3] = [N, N_CHANNELS, SIGNAL_LEN] + """ + + def __init__(self, + num_channels=256, + dimensions=None, # pylint: disable=unused-argument + num_classes=1, # pylint: disable=unused-argument + n_axes=3, + bias=True, + weight_init="kaiming", + batchNorm=True, + bottleNeckDim=4, + **kwargs): + + super().__init__() + + print("Batchnorm setting in model = ", batchNorm) + + weight_init = weight_init.lower() + assert weight_init in ('kaiming', 'xavier', 'glorot') + + # Num channels is equal to the length of FFTs here + self.num_channels = num_channels + self.n_axes = n_axes + + S = 1 + P = 0 + + # ----- DECODER ----- # + # Kernel in 1st layer looks at 1 axis at a time. Output width = input width + n_in = num_channels + n_out = 128 + if batchNorm: + self.en_conv1 = ai8x.FusedConv1dBNReLU(n_in, n_out, 1, stride=S, padding=P, dilation=1, + bias=bias, batchnorm='Affine', **kwargs) + else: + self.en_conv1 = ai8x.FusedConv1dReLU(n_in, n_out, 1, stride=S, padding=P, dilation=1, + bias=bias, **kwargs) + self.layer1_n_in = n_in + self.layer1_n_out = n_out + + # Kernel in 2nd layer looks at 3 axes at once. Output Width = 1. Depth=n_out + n_in = n_out + n_out = 64 + if batchNorm: + self.en_conv2 = ai8x.FusedConv1dBNReLU(n_in, n_out, 3, stride=S, padding=P, dilation=1, + bias=bias, batchnorm='Affine', **kwargs) + else: + self.en_conv2 = ai8x.FusedConv1dReLU(n_in, n_out, 3, stride=S, padding=P, dilation=1, + bias=bias, **kwargs) + self.layer2_n_in = n_in + self.layer2_n_out = n_out + + n_in = n_out + n_out = 32 + self.en_lin1 = ai8x.FusedLinearReLU(n_in, n_out, bias=bias, **kwargs) + # ----- END OF DECODER ----- # + + # ---- BOTTLENECK ---- # + n_in = n_out + self.bottleNeckDim = bottleNeckDim + n_out = self.bottleNeckDim + self.en_lin2 = ai8x.Linear(n_in, n_out, bias=0, **kwargs) + # ---- END OF BOTTLENECK ---- # + + # ----- ENCODER ----- # + n_in = n_out + n_out = 32 + self.de_lin1 = ai8x.FusedLinearReLU(n_in, n_out, bias=bias, **kwargs) + + n_in = n_out + n_out = 96 + self.de_lin2 = ai8x.FusedLinearReLU(n_in, n_out, bias=bias, **kwargs) + + n_in = n_out + n_out = num_channels*n_axes + self.out_lin = ai8x.Linear(n_in, n_out, bias=0, **kwargs) + # ----- END OF ENCODER ----- # + + self.initWeights(weight_init) + + def forward(self, x, return_bottleneck=False): + """Forward prop""" + x = self.en_conv1(x) + x = self.en_conv2(x) + x = x.view(x.shape[0], x.shape[1]) + x = self.en_lin1(x) + x = self.en_lin2(x) + + if return_bottleneck: + return x + + x = self.de_lin1(x) + x = self.de_lin2(x) + x = self.out_lin(x) + x = x.view(x.shape[0], self.num_channels, self.n_axes) + + return x + + +def ai85autoencoder(pretrained=False, **kwargs): + """ + Constructs an Autoencoder model + """ + assert not pretrained + return AI85AutoEncoder(**kwargs) + + +models = [ + { + 'name': 'ai85autoencoder', + 'min_input': 1, + 'dim': 1, + } +] diff --git a/models/ai85net-bayer2rgbnet.py b/models/ai85net-bayer2rgbnet.py index 9ed812b3e..4d9f08ba1 100644 --- a/models/ai85net-bayer2rgbnet.py +++ b/models/ai85net-bayer2rgbnet.py @@ -6,6 +6,7 @@ ################################################################################################### """ Bayer to Rgb network for AI85 +PR for test """ from torch import nn diff --git a/models/ai85net-faceid_112.py b/models/ai85net-faceid_112.py new file mode 100644 index 000000000..eeb33e2bd --- /dev/null +++ b/models/ai85net-faceid_112.py @@ -0,0 +1,141 @@ +################################################################################################### +# +# Copyright (C) 2019-2023 Maxim Integrated Products, Inc. All Rights Reserved. +# +# Maxim Integrated Products, Inc. Default Copyright Notice: +# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html +# +################################################################################################### +""" +FaceID networks for MAX78000 + +""" +import torch.nn.functional as F +from torch import nn + +import ai8x +import ai8x_blocks + + +class AI85FaceIDNet_112(nn.Module): + """ + FaceID Network for MAX78000 with 112x112 input + """ + + def __init__( # pylint: disable=too-many-arguments + self, + pre_layer_stride, + bottleneck_settings, + last_layer_width, + emb_dimensionality, + num_classes=None, # pylint: disable=unused-argument + avg_pool_size=(7, 7), + num_channels=3, + dimensions=(112, 112), # pylint: disable=unused-argument + bias=False, + depthwise_bias=False, + reduced_depthwise_bias=False, + **kwargs + ): + super().__init__() + # bias = False due to streaming + self.pre_stage = ai8x.FusedConv2dReLU(num_channels, bottleneck_settings[0][1], 3, + padding=1, stride=pre_layer_stride, + bias=False, **kwargs) + # bias = False due to streaming + self.pre_stage_2 = ai8x.FusedMaxPoolConv2dReLU(bottleneck_settings[0][1], + bottleneck_settings[0][1], 3, padding=1, + stride=1, pool_size=2, pool_stride=2, + bias=False, **kwargs) + self.feature_stage = nn.ModuleList([]) + for setting in bottleneck_settings: + self._create_bottleneck_stage(setting, bias, depthwise_bias, + reduced_depthwise_bias, **kwargs) + + self.post_stage = ai8x.FusedConv2dReLU(bottleneck_settings[-1][2], last_layer_width, 1, + padding=0, stride=1, bias=False, **kwargs) + + self.pre_avg = ai8x.Conv2d(last_layer_width, last_layer_width, 3, padding=1, stride=1, + bias=False, **kwargs) + self.avg_pool = ai8x.AvgPool2d(avg_pool_size, stride=1) + self.linear = ai8x.Linear(last_layer_width, emb_dimensionality, bias=bias, **kwargs) + + def _create_bottleneck_stage(self, setting, bias, depthwise_bias, + reduced_depthwise_bias, **kwargs): + """Function to create bottlencek stage. Setting format is: + [num_repeat, in_channels, out_channels, stride, expansion_factor] + """ + stage = [] + + if setting[0] > 0: + stage.append(ai8x_blocks.ConvResidualBottleneck(in_channels=setting[1], + out_channels=setting[2], + stride=setting[3], + expansion_factor=setting[4], bias=bias, + depthwise_bias=depthwise_bias, + **kwargs)) + + for i in range(1, setting[0]): + if reduced_depthwise_bias: + stage.append(ai8x_blocks.ConvResidualBottleneck(in_channels=setting[2], + out_channels=setting[2], + stride=1, + expansion_factor=setting[4], + bias=bias, + depthwise_bias=(i % 2 == 0) and + depthwise_bias, **kwargs)) + else: + stage.append(ai8x_blocks.ConvResidualBottleneck(in_channels=setting[2], + out_channels=setting[2], + stride=1, + expansion_factor=setting[4], + bias=bias, + depthwise_bias=depthwise_bias, + **kwargs)) + + self.feature_stage.append(nn.Sequential(*stage)) + + def forward(self, x): # pylint: disable=arguments-differ + """Forward prop""" + if x.shape[1] == 6: + x = x[:, 0:3, :, :] + x = self.pre_stage(x) + x = self.pre_stage_2(x) + for stage in self.feature_stage: + x = stage(x) + x = self.post_stage(x) + x = self.pre_avg(x) + x = self.avg_pool(x) + x = x.view(x.size(0), -1) + x = self.linear(x) + x = F.normalize(x, p=2, dim=1) + return x + + +def ai85faceidnet_112(pretrained=False, **kwargs): + """ + Constructs a FaceIDNet_112 model. + """ + assert not pretrained + # settings for bottleneck stages in format + # [num_repeat, in_channels, out_channels, stride, expansion_factor] + bottleneck_settings = [ + [1, 32, 48, 2, 2], + [1, 48, 64, 2, 4], + [1, 64, 64, 1, 2], + [1, 64, 96, 2, 4], + [1, 96, 128, 1, 2] + ] + + return AI85FaceIDNet_112(pre_layer_stride=1, bottleneck_settings=bottleneck_settings, + last_layer_width=128, emb_dimensionality=64, avg_pool_size=(7, 7), + depthwise_bias=True, reduced_depthwise_bias=True, **kwargs) + + +models = [ + { + 'name': 'ai85faceidnet_112', + 'min_input': 1, + 'dim': 3, + } +] diff --git a/models/ai85net-kws20-nas.py b/models/ai85net-kws20-nas.py new file mode 100644 index 000000000..fa6d108aa --- /dev/null +++ b/models/ai85net-kws20-nas.py @@ -0,0 +1,107 @@ +################################################################################################### +# +# Copyright (C) 2023-2024 Analog Devices, Inc. All Rights Reserved. +# +# Analog Devices, Inc. Default Copyright Notice: +# https://www.analog.com/en/about-adi/legal-and-risk-oversight/intellectual-property/copyright-notice.html +# +################################################################################################### +# +# Copyright (C) 2021-2023 Maxim Integrated Products, Inc. All Rights Reserved. +# +# Maxim Integrated Products, Inc. Default Copyright Notice: +# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html +# +################################################################################################### +""" +Keyword spotting network for AI85 +""" +from torch import nn + +import ai8x + + +class AI85KWS20NetNAS(nn.Module): + """ + KWS20 NAS Audio net, found via Neural Architecture Search + It significantly outperforms earlier networks (v1, v2, v3), though with a higher + parameter count and slightly increased latency. + """ + + # num_classes = n keywords + 1 unknown + def __init__( + self, + num_classes=21, + num_channels=128, + dimensions=(128, 1), # pylint: disable=unused-argument + bias=True, + **kwargs + ): + super().__init__() + self.conv1_1 = ai8x.FusedConv1dBNReLU(num_channels, 128, 1, stride=1, padding=0, + bias=bias, batchnorm="NoAffine", **kwargs) + self.conv1_2 = ai8x.FusedConv1dBNReLU(128, 64, 3, stride=1, padding=1, + bias=bias, batchnorm="NoAffine", **kwargs) + self.conv1_3 = ai8x.FusedConv1dBNReLU(64, 128, 3, stride=1, padding=1, + bias=bias, batchnorm="NoAffine", **kwargs) + self.conv2_1 = ai8x.FusedMaxPoolConv1dBNReLU(128, 128, 3, stride=1, padding=1, + bias=bias, batchnorm="NoAffine", **kwargs) + self.conv2_2 = ai8x.FusedConv1dBNReLU(128, 64, 1, stride=1, padding=0, + bias=bias, batchnorm="NoAffine", **kwargs) + self.conv2_3 = ai8x.FusedConv1dBNReLU(64, 128, 1, stride=1, padding=0, + bias=bias, batchnorm="NoAffine", **kwargs) + self.conv3_1 = ai8x.FusedMaxPoolConv1dBNReLU(128, 128, 3, stride=1, padding=1, + bias=bias, batchnorm="NoAffine", **kwargs) + self.conv3_2 = ai8x.FusedConv1dBNReLU(128, 64, 5, stride=1, padding=2, + bias=bias, batchnorm="NoAffine", **kwargs) + self.conv4_1 = ai8x.FusedMaxPoolConv1dBNReLU(64, 128, 5, stride=1, padding=2, + bias=bias, batchnorm="NoAffine", **kwargs) + self.conv4_2 = ai8x.FusedConv1dBNReLU(128, 128, 1, stride=1, padding=0, + bias=bias, batchnorm="NoAffine", **kwargs) + self.conv5_1 = ai8x.FusedMaxPoolConv1dBNReLU(128, 128, 5, stride=1, padding=2, + bias=bias, batchnorm="NoAffine", **kwargs) + self.conv5_2 = ai8x.FusedConv1dBNReLU(128, 64, 3, stride=1, padding=1, + bias=bias, batchnorm="NoAffine", **kwargs) + self.conv6_1 = ai8x.FusedMaxPoolConv1dBNReLU(64, 64, 5, stride=1, padding=2, + bias=bias, batchnorm="NoAffine", **kwargs) + self.conv6_2 = ai8x.FusedConv1dBNReLU(64, 128, 1, stride=1, padding=0, + bias=bias, batchnorm="NoAffine", **kwargs) + self.fc = ai8x.Linear(512, num_classes, bias=bias, wide=True, **kwargs) + + def forward(self, x): # pylint: disable=arguments-differ + """Forward prop""" + # Run CNN + x = self.conv1_1(x) + x = self.conv1_2(x) + x = self.conv1_3(x) + x = self.conv2_1(x) + x = self.conv2_2(x) + x = self.conv2_3(x) + x = self.conv3_1(x) + x = self.conv3_2(x) + x = self.conv4_1(x) + x = self.conv4_2(x) + x = self.conv5_1(x) + x = self.conv5_2(x) + x = self.conv6_1(x) + x = self.conv6_2(x) + x = x.view(x.size(0), -1) + x = self.fc(x) + return x + + +def ai85kws20netnas(pretrained=False, **kwargs): + """ + Constructs a AI85KWS20NetNAS model. + """ + assert not pretrained + return AI85KWS20NetNAS(**kwargs) + + +models = [ + { + 'name': 'ai85kws20netnas', + 'min_input': 1, + 'dim': 1, + }, +] diff --git a/models/ai85net-tinierssd-face.py b/models/ai85net-tinierssd-face.py index 10402780c..37ebeec75 100644 --- a/models/ai85net-tinierssd-face.py +++ b/models/ai85net-tinierssd-face.py @@ -1,15 +1,30 @@ -################################################################################################### # -# Copyright (C) 2023 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -# detect_objects function is adopted from: GitHub repository: -# https://github.com/sgrvinod/a-PyTorch-Tutorial-to-Object-Detection: # MIT License +# # Copyright (c) 2019 Sagar Vinodababu -################################################################################################### +# Portions Copyright (C) 2023 Maxim Integrated Products, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy of +# this software and associated documentation files (the "Software"), to deal in +# the Software without restriction, including without limitation the rights to +# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +# of the Software, and to permit persons to whom the Software is furnished to do +# so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# detect_objects function is adopted from +# https://github.com/sgrvinod/a-PyTorch-Tutorial-to-Object-Detection +# """ Tiny SSD (Single Shot Detector) Variant Model for Face Detection """ diff --git a/models/ai85net-tinierssd.py b/models/ai85net-tinierssd.py index d593ddfc8..bd6ce2681 100644 --- a/models/ai85net-tinierssd.py +++ b/models/ai85net-tinierssd.py @@ -1,15 +1,30 @@ -################################################################################################### # -# Copyright (C) 2022-2023 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -# detect_objects function is adopted from: GitHub repository: -# https://github.com/sgrvinod/a-PyTorch-Tutorial-to-Object-Detection: # MIT License +# # Copyright (c) 2019 Sagar Vinodababu -################################################################################################### +# Portions Copyright (C) 2022-2023 Maxim Integrated Products, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy of +# this software and associated documentation files (the "Software"), to deal in +# the Software without restriction, including without limitation the rights to +# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +# of the Software, and to permit persons to whom the Software is furnished to do +# so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# detect_objects function is adopted from +# https://github.com/sgrvinod/a-PyTorch-Tutorial-to-Object-Detection +# """ Tiny SSD (Single Shot Detector) Variant Model """ diff --git a/models/ai87net-mobilefacenet_112.py b/models/ai87net-mobilefacenet_112.py new file mode 100644 index 000000000..c039d1e3e --- /dev/null +++ b/models/ai87net-mobilefacenet_112.py @@ -0,0 +1,140 @@ +################################################################################################### +# +# Copyright (C) 2023 Maxim Integrated Products, Inc. All Rights Reserved. +# +# Maxim Integrated Products, Inc. Default Copyright Notice: +# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html +# +################################################################################################### +""" +MobileFaceNet [1] network implementation for MAX78002. + +[1] Chen, Sheng, et al. "Mobilefacenets: Efficient cnns for accurate real-time face verification +on mobile devices." Biometric Recognition: 13th Chinese Conference, CCBR 2018, Urumqi, China, +August 11-12, 2018, Proceedings 13. Springer International Publishing, 2018. +""" +import torch.nn.functional as F +from torch import nn + +import ai8x +import ai8x_blocks + + +class AI87MobileFaceNet(nn.Module): + """ + MobileFaceNet for MAX78002 + """ + def __init__( # pylint: disable=too-many-arguments + self, + pre_layer_stride, + bottleneck_settings, + last_layer_width, + emb_dimensionality, + num_classes=None, # pylint: disable=unused-argument + avg_pool_size=(7, 7), + num_channels=3, + dimensions=(112, 112), # pylint: disable=unused-argument + bias=False, + depthwise_bias=False, + reduced_depthwise_bias=False, + **kwargs + ): + super().__init__() + + # bias = False due to streaming + self.pre_stage = ai8x.FusedConv2dReLU(num_channels, bottleneck_settings[0][1], 3, + padding=1, stride=pre_layer_stride, + bias=False, **kwargs) + + self.dwise = ai8x.FusedMaxPoolDepthwiseConv2dReLU(64, 64, 3, padding=1, stride=1, + pool_size=2, pool_stride=2, + bias=depthwise_bias, **kwargs) + self.feature_stage = nn.ModuleList([]) + for setting in bottleneck_settings: + self._create_bottleneck_stage(setting, bias, depthwise_bias, + reduced_depthwise_bias, **kwargs) + + self.post_stage = ai8x.FusedConv2dReLU(bottleneck_settings[-1][2], last_layer_width, 1, + padding=0, stride=1, bias=False, **kwargs) + self.classifier = ai8x.FusedAvgPoolConv2d(last_layer_width, emb_dimensionality, + 1, padding=0, stride=1, pool_size=avg_pool_size, + pool_stride=1, bias=False, wide=False, + **kwargs) + + def _create_bottleneck_stage(self, setting, bias, depthwise_bias, + reduced_depthwise_bias, **kwargs): + """Function to create bottlencek stage. Setting format is: + [num_repeat, in_channels, out_channels, stride, expansion_factor] + """ + stage = [] + + if setting[0] > 0: + stage.append(ai8x_blocks.ResidualBottleneck(in_channels=setting[1], + out_channels=setting[2], + stride=setting[3], + expansion_factor=setting[4], + bias=bias, depthwise_bias=depthwise_bias, + **kwargs)) + + for i in range(1, setting[0]): + if reduced_depthwise_bias: + stage.append(ai8x_blocks.ResidualBottleneck(in_channels=setting[2], + out_channels=setting[2], + stride=1, + expansion_factor=setting[4], + bias=bias, + depthwise_bias=(i % 2 == 0) and + depthwise_bias, **kwargs)) + else: + stage.append(ai8x_blocks.ResidualBottleneck(in_channels=setting[2], + out_channels=setting[2], + stride=1, + expansion_factor=setting[4], + bias=bias, + depthwise_bias=depthwise_bias, + **kwargs)) + + self.feature_stage.append(nn.Sequential(*stage)) + + def forward(self, x): # pylint: disable=arguments-differ + """Forward prop""" + if x.shape[1] == 6: + x = x[:, 0:3, :, :] + x = self.pre_stage(x) + x = self.dwise(x) + for stage in self.feature_stage: + x = stage(x) + x = self.post_stage(x) + x = self.classifier(x) + x = F.normalize(x, p=2, dim=1) + x = x.squeeze() + return x + + +def ai87netmobilefacenet_112(pretrained=False, **kwargs): + """ + Constructs a MobileFaceNet model. + """ + assert not pretrained + # settings for bottleneck stages in format + # [num_repeat, in_channels, out_channels, stride, expansion_factor] + bottleneck_settings = [ + [5, 64, 64, 2, 2], + [1, 64, 128, 2, 4], + [6, 128, 128, 1, 2], + [1, 128, 128, 2, 4], + [2, 128, 128, 1, 2] + ] + + return AI87MobileFaceNet(pre_layer_stride=1, bottleneck_settings=bottleneck_settings, + last_layer_width=128, emb_dimensionality=64, avg_pool_size=(7, 7), + depthwise_bias=True, reduced_depthwise_bias=True, **kwargs) + + +models = [ + { + 'name': 'ai87netmobilefacenet_112', + 'min_input': 1, + 'dim': 3, + }, +] diff --git a/models/model_irse_drl.py b/models/model_irse_drl.py new file mode 100644 index 000000000..d50774f44 --- /dev/null +++ b/models/model_irse_drl.py @@ -0,0 +1,420 @@ +################################################################################################### +# +# Copyright (c) 2020 PaddlePaddle Authors. +# Portions Copyright (c) 2019 Jian Zhao +# Portions Copyright (C) 2023-2024 Maxim Integrated Products, Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +################################################################################################### +""" +FaceID Teacher Model to be used for Knowledge Distillation +See https://github.com/analogdevicesinc/ai8x-training/blob/develop/docs/FacialRecognitionSystem.md +""" +import sys +from collections import namedtuple + +import torch +import torch.nn.functional as F +import torchvision.transforms.functional as FT +from torch import nn + + +class DRL(nn.Module): + """ + Dimensionality reduction layers + Expects unnormalized 512 embeddings from the Teacher Model + """ + def __init__( + self, + dimensionality, + bias=True, + ): + super().__init__() + self.conv1 = nn.Conv1d(512, 512, 1, padding=0, bias=bias) + self.BN1 = nn.BatchNorm1d(512) + self.PRelu1 = nn.PReLU(512) + self.conv2 = nn.Conv1d(512, dimensionality, 1, padding=0, bias=bias) + self.BN2 = nn.BatchNorm1d(dimensionality) + + def forward(self, x): # pylint: disable=arguments-differ + """Forward prop""" + x = torch.unsqueeze(x, 2) + x = self.conv1(x) + x = self.BN1(x) + x = self.PRelu1(x) + x = self.conv2(x) + x = self.BN2(x) + x = torch.squeeze(x, 2) + return x + + +class Ensemble(nn.Module): + """ + Ensemble of Teacher and DRL + """ + def __init__(self, resnet, drl): + super().__init__() + self.resnet = resnet + self.DRL = drl + self.Teacher_mode = False + + def forward(self, x): + """Forward prop""" + if x.shape[1] == 6: + if not self.Teacher_mode: + self.Teacher_mode = True + x = x[:, 3:, :, :] + x_flip = FT.hflip(x) + x = torch.cat((x, x_flip), 0) + x = self.resnet(x) + x = self.DRL(x) + if self.Teacher_mode: + x = x[:x.shape[0]//2] + x[x.shape[0]//2:] # Flip fusion + x = F.normalize(x, p=2, dim=1) + return x + + +class Flatten(nn.Module): + """Flattens the input""" + def forward(self, x): + """Forward prop""" + return x.view(x.size(0), -1) + + +def l2_norm(x, axis=1): + """l2 norm""" + norm = torch.norm(x, 2, axis, True) + output = torch.div(x, norm) + return output + + +class SEModule(nn.Module): + """ + SEModule + """ + def __init__(self, channels, reduction): + super().__init__() + self.avg_pool = nn.AdaptiveAvgPool2d(1) + self.fc1 = nn.Conv2d( + channels, channels // reduction, kernel_size=1, padding=0, bias=False) + + nn.init.xavier_uniform_(self.fc1.weight.data) + + self.relu = nn.ReLU(inplace=True) + self.fc2 = nn.Conv2d( + channels // reduction, channels, kernel_size=1, padding=0, bias=False) + + self.sigmoid = nn.Sigmoid() + + def forward(self, x): + """Forward prop""" + module_input = x + x = self.avg_pool(x) + x = self.fc1(x) + x = self.relu(x) + x = self.fc2(x) + x = self.sigmoid(x) + + return module_input * x + + +class bottleneck_IR(nn.Module): + """ + IR bottleneck module + """ + def __init__(self, in_channel, depth, stride): + super().__init__() + if in_channel == depth: + self.shortcut_layer = nn.MaxPool2d(1, stride) + else: + self.shortcut_layer = nn.Sequential( + nn.Conv2d(in_channel, depth, (1, 1), stride, bias=False), nn.BatchNorm2d(depth)) + self.res_layer = nn.Sequential( + nn.BatchNorm2d(in_channel), + nn.Conv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False), nn.PReLU(depth), + nn.Conv2d(depth, depth, (3, 3), stride, 1, bias=False), nn.BatchNorm2d(depth)) + + def forward(self, x): + """Forward prop""" + shortcut = self.shortcut_layer(x) + res = self.res_layer(x) + + return res + shortcut + + +class bottleneck_IR_SE(nn.Module): + """ + IR bottleneck module with SE + """ + def __init__(self, in_channel, depth, stride): + super().__init__() + if in_channel == depth: + self.shortcut_layer = nn.MaxPool2d(1, stride) + else: + self.shortcut_layer = nn.Sequential( + nn.Conv2d(in_channel, depth, (1, 1), stride, bias=False), + nn.BatchNorm2d(depth)) + self.res_layer = nn.Sequential( + nn.BatchNorm2d(in_channel), + nn.Conv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False), + nn.PReLU(depth), + nn.Conv2d(depth, depth, (3, 3), stride, 1, bias=False), + nn.BatchNorm2d(depth), + SEModule(depth, 16) + ) + + def forward(self, x): + """Forward prop""" + shortcut = self.shortcut_layer(x) + res = self.res_layer(x) + + return res + shortcut + + +class Bottleneck(namedtuple('Block', ['in_channel', 'depth', 'stride'])): + '''A named tuple describing a ResNet block.''' + + +def get_block(in_channel, depth, num_units, stride=2): + """Creates a bottleneck block.""" + return [Bottleneck(in_channel, depth, stride)] + [Bottleneck(depth, depth, 1) + for i in range(num_units - 1)] + + +def get_blocks(num_layers): + """Creates the block architecture for the given model.""" + if num_layers == 50: + blocks = [ + get_block(in_channel=64, depth=64, num_units=3), + get_block(in_channel=64, depth=128, num_units=4), + get_block(in_channel=128, depth=256, num_units=14), + get_block(in_channel=256, depth=512, num_units=3) + ] + elif num_layers == 100: + blocks = [ + get_block(in_channel=64, depth=64, num_units=3), + get_block(in_channel=64, depth=128, num_units=13), + get_block(in_channel=128, depth=256, num_units=30), + get_block(in_channel=256, depth=512, num_units=3) + ] + elif num_layers == 152: + blocks = [ + get_block(in_channel=64, depth=64, num_units=3), + get_block(in_channel=64, depth=128, num_units=8), + get_block(in_channel=128, depth=256, num_units=36), + get_block(in_channel=256, depth=512, num_units=3) + ] + + return blocks + + +class Backbone(nn.Module): + """ + Constructs a backbone with the given parameters. + """ + def __init__(self, input_size, num_layers, mode='ir'): + super().__init__() + assert input_size[0] in [112, 224], "input_size should be [112, 112] or [224, 224]" + assert num_layers in [50, 100, 152], "num_layers should be 50, 100 or 152" + assert mode in ['ir', 'ir_se'], "mode should be ir or ir_se" + blocks = get_blocks(num_layers) + if mode == 'ir': + unit_module = bottleneck_IR + elif mode == 'ir_se': + unit_module = bottleneck_IR_SE + self.input_layer = nn.Sequential(nn.Conv2d(3, 64, (3, 3), 1, 1, bias=False), + nn.BatchNorm2d(64), + nn.PReLU(64)) + if input_size[0] == 112: + # Dropout is set to 0, due to the train.py structure + self.output_layer = nn.Sequential(nn.BatchNorm2d(512), + nn.Dropout(p=0), + Flatten(), + nn.Linear(512 * 7 * 7, 512), + nn.BatchNorm1d(512)) + else: + self.output_layer = nn.Sequential(nn.BatchNorm2d(512), + nn.Dropout(p=0), + Flatten(), + nn.Linear(512 * 14 * 14, 512), + nn.BatchNorm1d(512)) + + modules = [] + for block in blocks: + for bottleneck in block: + modules.append( + unit_module(bottleneck.in_channel, + bottleneck.depth, + bottleneck.stride)) + self.body = nn.Sequential(*modules) + + self._initialize_weights() + + def forward(self, x): + """Forward prop""" + x = self.input_layer(x) + x = self.body(x) + x = self.output_layer(x) + return x + + def _initialize_weights(self): + """Initializes the weights.""" + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.xavier_uniform_(m.weight.data) + if m.bias is not None: + m.bias.data.zero_() + elif isinstance(m, nn.BatchNorm2d): + m.weight.data.fill_(1) + m.bias.data.zero_() + elif isinstance(m, nn.BatchNorm1d): + m.weight.data.fill_(1) + m.bias.data.zero_() + elif isinstance(m, nn.Linear): + nn.init.xavier_uniform_(m.weight.data) + if m.bias is not None: + m.bias.data.zero_() + + +def create_model(input_size=(112, 112), # pylint: disable=unused-argument + dimensionality=64, + backbone_checkpoint=None, + model_name="ir", model_size=152, **kwargs): + """ + Model + DRL constructor + """ + model = Backbone(input_size, model_size, model_name) + if backbone_checkpoint is not None: + try: + model.load_state_dict(torch.load(backbone_checkpoint, + map_location=torch.device('cpu'))) + except FileNotFoundError: + print(f'Backbone checkpoint {backbone_checkpoint} not found. Please follow the ' + 'instructions in docs/FacialRecognitionSystem.md, section ## FaceID, ' + 'to download the backbone checkpoint.', + file=sys.stderr) + sys.exit(1) + for param in model.parameters(): + param.requires_grad = False + drl = DRL(dimensionality) + ensemble = Ensemble(model, drl) + + return ensemble + + +def ir_50(input_size=(112, 112), # pylint: disable=unused-argument + dimensionality=64, + backbone_checkpoint=None, **kwargs): + """ + Constructs a ir-50 model. + """ + model = create_model(input_size, dimensionality, backbone_checkpoint, "ir", 50) + + return model + + +def ir_101(input_size=(112, 112), # pylint: disable=unused-argument + dimensionality=64, + backbone_checkpoint=None, **kwargs): + """ + Constructs a ir-101 model. + """ + model = create_model(input_size, dimensionality, backbone_checkpoint, "ir", 100) + + return model + + +def ir_152(input_size=(112, 112), # pylint: disable=unused-argument + dimensionality=64, + backbone_checkpoint=None, **kwargs): + """ + Constructs a ir-152 model. + """ + model = create_model(input_size, dimensionality, backbone_checkpoint, "ir", 152) + + return model + + +def ir_se_50(input_size=(112, 112), # pylint: disable=unused-argument + dimensionality=64, + backbone_checkpoint=None, **kwargs): + """ + Constructs a ir_se-50 model. + """ + model = create_model(input_size, dimensionality, backbone_checkpoint, "ir_se", 50) + + return model + + +def ir_se_101(input_size=(112, 112), # pylint: disable=unused-argument + dimensionality=64, + backbone_checkpoint=None, **kwargs): + """ + Constructs a ir_se-101 model. + """ + model = create_model(input_size, dimensionality, backbone_checkpoint, "ir_se", 100) + + return model + + +def ir_se_152(input_size=(112, 112), # pylint: disable=unused-argument + dimensionality=64, + backbone_checkpoint=None, **kwargs): + """ + Constructs a ir_se-152 model. + """ + model = create_model(input_size, dimensionality, backbone_checkpoint, "ir_se", 152) + + return model + + +models = [ + { + 'name': 'ir_50', + 'min_input': 1, + 'dim': 2, + 'dr': True, + }, + { + 'name': 'ir_101', + 'min_input': 1, + 'dim': 2, + 'dr': True, + }, + { + 'name': 'ir_152', + 'min_input': 1, + 'dim': 2, + 'dr': True, + }, + { + 'name': 'ir_se_50', + 'min_input': 1, + 'dim': 2, + 'dr': True, + }, + { + 'name': 'ir_se_101', + 'min_input': 1, + 'dim': 2, + 'dr': True, + }, + { + 'name': 'ir_se_152', + 'min_input': 1, + 'dim': 2, + 'dr': True, + }, + +] diff --git a/nnplot.py b/nnplot.py index ca8ca040c..709849c37 100644 --- a/nnplot.py +++ b/nnplot.py @@ -1,11 +1,27 @@ -################################################################################################### # -# Copyright (C) 2018-2023 Maxim Integrated Products, Inc. All Rights Reserved. +# MIT License # -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html +# Copyright (c) 2018 Dabi Ahn +# Portions Copyright (C) 2018-2023 Maxim Integrated Products, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy of +# this software and associated documentation files (the "Software"), to deal in +# the Software without restriction, including without limitation the rights to +# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +# of the Software, and to permit persons to whom the Software is furnished to do +# so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. # -################################################################################################### """ Graphical output routines """ diff --git a/notebooks/AutoEncoder_Evaluation.ipynb b/notebooks/AutoEncoder_Evaluation.ipynb new file mode 100755 index 000000000..c836cf67f --- /dev/null +++ b/notebooks/AutoEncoder_Evaluation.ipynb @@ -0,0 +1,576 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "###################################################################################################\n", + "#\n", + "# Copyright (C) 2024 Analog Devices, Inc. All Rights Reserved.\n", + "# This software is proprietary and confidential to Analog Devices, Inc. and its licensors.\n", + "#\n", + "###################################################################################################\n", + "\"\"\"\n", + "For more details about the dataset, data loader, model and training,\n", + "please see the following documentation:\n", + "https://github.com/analogdevicesinc/MaximAI_Documentation/blob/master/Guides/MAX78000%20Motor%20Monitoring%20Case%20Study%20with%20SampleMotorDataLimerick%20Dataset.pdf\n", + "\"\"\"\n", + "import os\n", + "import sys\n", + "\n", + "import numpy as np\n", + "import torch\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "sys.path.append(os.path.dirname(os.getcwd()))\n", + "sys.path.append(os.path.join(os.path.dirname(os.getcwd()), 'models'))\n", + "\n", + "from datasets import samplemotordatalimerick\n", + "\n", + "ai85net_autoencoder = __import__(\"ai85net-autoencoder\")\n", + "\n", + "import parse_qat_yaml\n", + "import ai8x\n", + "\n", + "from torch.utils import data\n", + "\n", + "from distiller import apputils\n", + "\n", + "import seaborn as sns\n", + "\n", + "from statistics import mean\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from utils import autoencoder_eval_utils as utilsV5\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "directory = os.getcwd()\n", + "training_dir = os.path.abspath(os.path.join(directory, os.pardir))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Configuring device: MAX78000, simulate=False.\n" + ] + } + ], + "source": [ + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "data_path = os.path.join(training_dir, 'data')\n", + "simulate = False\n", + "\n", + "class Args:\n", + " def __init__(self, act_mode_8bit):\n", + " self.act_mode_8bit = act_mode_8bit\n", + " self.truncate_testset = False\n", + "\n", + "args = Args(act_mode_8bit=simulate)\n", + "\n", + "ai8x.set_device(device=85, simulate=simulate, round_avg=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "SampleMotorDataLimerick dataset already downloaded...\n", + "\n", + "SampleMotorDataLimerick_dataframe.pkl file already exists\n", + "\n", + "\n", + "Pickle files are already generated ...\n", + "\n", + "Train dataset length: 230\n", + "\n", + "\n", + "SampleMotorDataLimerick dataset already downloaded...\n", + "\n", + "SampleMotorDataLimerick_dataframe.pkl file already exists\n", + "\n", + "\n", + "Pickle files are already generated ...\n", + "\n", + "Test dataset length: 3540\n", + "\n" + ] + } + ], + "source": [ + "# Generate Dataset For Evaluation\n", + "train_set, test_set = samplemotordatalimerick.samplemotordatalimerick_get_datasets_for_eval_with_anomaly_label((data_path, args), load_train=True, load_test=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 32\n", + "train_dataloader = data.DataLoader(train_set, batch_size=batch_size, shuffle=True)\n", + "test_dataloader = data.DataLoader(test_set, batch_size=batch_size, shuffle=True)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1. Load Trained AE" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batchnorm setting in model = True\n", + "\n", + "Number of Model Weights: 136640\n", + "Number of Model Bias: 544\n", + "\n" + ] + } + ], + "source": [ + "model = ai85net_autoencoder.ai85autoencoder()\n", + "_ = utilsV5.calc_model_size(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Change this checkpoint file path with your own trained one\n", + "checkpoint_path = os.path.abspath(os.path.join(training_dir, os.pardir, 'ai8x-synthesis', 'trained', 'ai85-autoencoder-samplemotordatalimerick-qat.pth.tar'))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'start_epoch': 200, 'weight_bits': 8, 'shift_quantile': 0.995}\n", + "Configuring device: MAX78000, simulate=False.\n" + ] + } + ], + "source": [ + "qat_yaml_file_used_in_training = os.path.join(training_dir, 'policies', 'qat_policy_autoencoder.yaml')\n", + "\n", + "qat_policy = parse_qat_yaml.parse(qat_yaml_file_used_in_training)\n", + "\n", + "ai8x.set_device(85, simulate, False)\n", + "\n", + "# Fuse the BN parameters into conv layers before Quantization Aware Training (QAT)\n", + "ai8x.fuse_bn_layers(model)\n", + "\n", + "# Switch model from unquantized to quantized for QAT\n", + "ai8x.initiate_qat(model, qat_policy)\n", + "\n", + "model = apputils.load_lean_checkpoint(model, checkpoint_path, model_device=device)\n", + "ai8x.update_model(model)\n", + "\n", + "model = model.to(device)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualizing whether trained model has good separation the latent space" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "230\n" + ] + } + ], + "source": [ + "train_base_tuple = utilsV5.extract_reconstructions_losses(model, train_dataloader, device)\n", + "train_base_reconstructions, train_base_losses, train_base_inputs, train_base_labels = \\\n", + " train_base_tuple\n", + " \n", + " \n", + "print(len(train_base_losses))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3540\n" + ] + } + ], + "source": [ + "test_base_tuple = utilsV5.extract_reconstructions_losses(model, test_dataloader, device)\n", + "test_base_reconstructions, test_base_losses, test_base_inputs, test_base_labels = \\\n", + " test_base_tuple\n", + " \n", + "print(len(test_base_losses))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.08606820548770566" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mean(test_base_losses)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "60\n" + ] + } + ], + "source": [ + "normal_test_sample_idxs = [test_item_idx for test_item_idx, test_item in enumerate(test_set) if test_item[1] == 0]\n", + "normal_test_samples = torch.utils.data.Subset(test_set, normal_test_sample_idxs)\n", + "normal_test_samples_loader = torch.utils.data.DataLoader(normal_test_samples, batch_size=batch_size)\n", + "print(len(normal_test_sample_idxs))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.027154843012491863, 0.01931905746459961, 0.022384484608968098, 0.027895212173461914, 0.02215234438578288, 0.02309735616048177, 0.01860976219177246, 0.0230864683787028, 0.022903998692830402, 0.02098989486694336, 0.017391522725423176, 0.02986884117126465, 0.025111277898152668, 0.026648998260498047, 0.0289913813273112, 0.028342485427856445, 0.02594900131225586, 0.023530244827270508, 0.02023140589396159, 0.023876508076985676, 0.025062402089436848, 0.03147419293721517, 0.026927073796590168, 0.02293237050374349, 0.02016894022623698, 0.03138017654418945, 0.029456456502278645, 0.02879174550374349, 0.03609673182169596, 0.042246739069620766, 0.011744022369384766, 0.014452854792277018, 0.01569652557373047, 0.0213166077931722, 0.024822314580281574, 0.02770860989888509, 0.0341958204905192, 0.02867404619852702, 0.026907602945963543, 0.025069236755371094, 0.018611669540405273, 0.021029233932495117, 0.010935386021931967, 0.012288649876912435, 0.01129762331644694, 0.011835495630900065, 0.011105537414550781, 0.014148712158203125, 0.018083969751993816, 0.017012675603230793, 0.017467419306437176, 0.021580616633097332, 0.02849753697713216, 0.025730212529500324, 0.01306001345316569, 0.01197377840677897, 0.0089109738667806, 0.011348247528076172, 0.01638944943745931, 0.022724707921346027]\n" + ] + } + ], + "source": [ + "normal_base_output = utilsV5.extract_reconstructions_losses(model, normal_test_samples_loader, device)\n", + " \n", + "test_base_normal_reconstructions, test_base_normal_losses, \\\n", + "test_base_normal_inputs, test_base_normal_labels = normal_base_output\n", + "\n", + "print(test_base_normal_losses)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3480\n" + ] + } + ], + "source": [ + "anormal_test_sample_idxs = [test_item_idx for test_item_idx, test_item in enumerate(test_set) if test_item[1] == 1]\n", + "print(len(anormal_test_sample_idxs))\n", + "\n", + "anormal_test_samples = torch.utils.data.Subset(test_set, anormal_test_sample_idxs)\n", + "anormal_test_samples_loader = torch.utils.data.DataLoader(anormal_test_samples, batch_size=batch_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "anormal_base_output = utilsV5.extract_reconstructions_losses(model, anormal_test_samples_loader, device)\n", + " \n", + "test_base_anormal_reconstructions, test_base_anormal_losses, \\\n", + "test_base_anormal_inputs, test_base_anormal_labels = anormal_base_output" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **2. Determine Reconst. Err. Threshold:** Using 100% percentile on base model" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "60% percentile threshold: 0.0167\n", + "65% percentile threshold: 0.0177\n", + "70% percentile threshold: 0.0190\n", + "75% percentile threshold: 0.0201\n", + "80% percentile threshold: 0.0209\n", + "85% percentile threshold: 0.0223\n", + "90% percentile threshold: 0.0235\n", + "95% percentile threshold: 0.0250\n", + "99% percentile threshold: 0.0271\n", + "100% percentile threshold: 0.0357\n" + ] + } + ], + "source": [ + "percentiles = [60, 65, 70, 75, 80, 85, 90, 95, 99, 100]\n", + "thresholds = np.percentile(train_base_losses, percentiles)\n", + "\n", + "for idx, threshold in enumerate(thresholds):\n", + " print(f'{percentiles[idx]}% percentile threshold: {threshold:.4f}')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.01594951049141262" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from statistics import mean\n", + "mean(train_base_losses)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.022111524475945367" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mean(test_base_normal_losses)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "60" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(test_base_normal_losses)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F1: 0.9934, BalancedAccuracy: 0.6167, FPRate: 0.7667, Precision: 0.9870, TPRate (Recall): 1.0000, Accuracy: 0.9870, TRAIN-SET Accuracy: 0.6000\n", + "F1: 0.9939, BalancedAccuracy: 0.6417, FPRate: 0.7167, Precision: 0.9878, TPRate (Recall): 1.0000, Accuracy: 0.9879, TRAIN-SET Accuracy: 0.6478\n", + "F1: 0.9943, BalancedAccuracy: 0.6667, FPRate: 0.6667, Precision: 0.9886, TPRate (Recall): 1.0000, Accuracy: 0.9887, TRAIN-SET Accuracy: 0.7000\n", + "F1: 0.9944, BalancedAccuracy: 0.6750, FPRate: 0.6500, Precision: 0.9889, TPRate (Recall): 1.0000, Accuracy: 0.9890, TRAIN-SET Accuracy: 0.7478\n", + "F1: 0.9947, BalancedAccuracy: 0.6917, FPRate: 0.6167, Precision: 0.9895, TPRate (Recall): 1.0000, Accuracy: 0.9895, TRAIN-SET Accuracy: 0.8000\n", + "F1: 0.9951, BalancedAccuracy: 0.7330, FPRate: 0.5333, Precision: 0.9909, TPRate (Recall): 0.9994, Accuracy: 0.9904, TRAIN-SET Accuracy: 0.8478\n", + "F1: 0.9960, BalancedAccuracy: 0.7912, FPRate: 0.4167, Precision: 0.9929, TPRate (Recall): 0.9991, Accuracy: 0.9921, TRAIN-SET Accuracy: 0.9000\n", + "F1: 0.9961, BalancedAccuracy: 0.8078, FPRate: 0.3833, Precision: 0.9934, TPRate (Recall): 0.9989, Accuracy: 0.9924, TRAIN-SET Accuracy: 0.9478\n", + "F1: 0.9953, BalancedAccuracy: 0.8724, FPRate: 0.2500, Precision: 0.9957, TPRate (Recall): 0.9948, Accuracy: 0.9907, TRAIN-SET Accuracy: 0.9870\n", + "F1: 0.9834, BalancedAccuracy: 0.9672, FPRate: 0.0333, Precision: 0.9994, TPRate (Recall): 0.9678, Accuracy: 0.9678, TRAIN-SET Accuracy: 1.0000\n" + ] + } + ], + "source": [ + "# Calculating performance metrics with respect to changing thresholds\n", + "F1s, BalancedAccuracies, FPRs, Recalls = utilsV5.sweep_performance_metrics(thresholds, train_base_tuple, test_base_tuple)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Reconstruction Loss (RL)')" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 2))\n", + "\n", + "plt.xlim([0, 0.3])\n", + "\n", + "sns.histplot(test_base_anormal_losses, element=\"step\", label='RL for Anomalies in Test Set', kde=True)\n", + "sns.histplot(test_base_normal_losses, element=\"step\", label='RL for Unseen Normals in Test Set', kde=True)\n", + "sns.histplot(train_base_losses, element=\"step\", label='RL for Normals in Training Set', kde=True)\n", + "\n", + "plt.legend(prop={'size': 9}, loc='best')\n", + "plt.xlabel('Reconstruction Loss (RL)')" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "utilsV5.plot_all_metrics(F1s=F1s, BalancedAccuracies=BalancedAccuracies, FPRs=FPRs, Recalls=Recalls, percentiles=percentiles)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.11 ('venv': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.11" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "f94e0c326c22ca109c8d98fac0e773823a480a04f73c52ef704532a18e9d37e9" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/Bayer2RGB_Evaluation.ipynb b/notebooks/Bayer2RGB_Evaluation.ipynb index 24059aec0..c793e444f 100644 --- a/notebooks/Bayer2RGB_Evaluation.ipynb +++ b/notebooks/Bayer2RGB_Evaluation.ipynb @@ -22,8 +22,10 @@ "source": [ "###################################################################################################\n", "#\n", - "# Copyright © 2023 Analog Devices, Inc. All Rights Reserved.\n", - "# This software is proprietary and confidential to Analog Devices, Inc. and its licensors.\n", + "# Copyright (C) 2023-2024 Analog Devices, Inc. All Rights Reserved.\n", + "#\n", + "# Analog Devices, Inc. Default Copyright Notice:\n", + "# https://www.analog.com/en/about-adi/legal-and-risk-oversight/intellectual-property/copyright-notice.html\n", "#\n", "###################################################################################################import cv2\n", "import importlib\n", diff --git a/notebooks/KWS_Noise_Evaluation.ipynb b/notebooks/KWS_Noise_Evaluation.ipynb new file mode 100644 index 000000000..934c52387 --- /dev/null +++ b/notebooks/KWS_Noise_Evaluation.ipynb @@ -0,0 +1,868 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Automated Evaluation for KWS Under Different Noise Scenarios\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using this notebook, you can test previously trained KWS models under various noise types at desired SNR levels. You'll need:\n", + "- the trained model's checkpoint file\n", + "- a list specifying the types of noise\n", + "- a list specifying the SNR levels.\n", + "\n", + "This notebook uses the signalmixer data loader to mix the KWS and specified noise data, and creates a mixed dataset using the specified SNR level. The notebook performs the evaluation on these mixed datasets and creates comparison plots for different types of models." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "###################################################################################################\n", + "#\n", + "# Copyright (C) 2023-2024 Analog Devices, Inc. All Rights Reserved.\n", + "#\n", + "# Analog Devices, Inc. Default Copyright Notice:\n", + "# https://www.analog.com/en/about-adi/legal-and-risk-oversight/intellectual-property/copyright-notice.html\n", + "#\n", + "###################################################################################################\n", + "#\n", + "# Copyright (C) 2022-2023 Maxim Integrated Products, Inc. All Rights Reserved.\n", + "#\n", + "# Maxim Integrated Products, Inc. Default Copyright Notice:\n", + "# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html\n", + "#\n", + "###################################################################################################\n", + "\n", + "import os\n", + "import sys\n", + "\n", + "import numpy as np\n", + "import torch\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import torchnet.meter as tnt\n", + "from collections import OrderedDict\n", + "import importlib\n", + "from torchvision import transforms\n", + "\n", + "sys.path.append(os.path.join(os.getcwd(), '..'))\n", + "sys.path.append(os.path.join(os.getcwd(), '..', 'models'))\n", + "sys.path.append(os.path.join(os.getcwd(), '..', 'datasets'))\n", + "\n", + "from types import SimpleNamespace\n", + "\n", + "import ai8x\n", + "\n", + "import msnoise\n", + "from signalmixer import signalmixer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 1: Initialize and load the model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, set the checkpoint path and the corresponding model name. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "trained_checkpoint_path = os.path.join('..', '..', 'ai8x-synthesis', 'trained', 'ai85-kws20_nas-qat8.pth.tar')\n", + "mod = importlib.import_module(\"ai85net-kws20-nas\")\n", + "model_file = \"ai85net-kws20-nas\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Working with device: cuda\n", + "Configuring device: MAX78000, simulate=False.\n" + ] + } + ], + "source": [ + "dataset = importlib.import_module(\"kws20\")\n", + "\n", + "classes = ['up', 'down', 'left', 'right', 'stop', 'go', 'yes', 'no', 'on', 'off', 'one',\n", + " 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'zero', 'unknown']\n", + "\n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "print(\"Working with device:\", device)\n", + "\n", + "ai8x.set_device(device=85, simulate=False, round_avg=False)\n", + "qat_policy = {'start_epoch': 10, 'weight_bits': 8, 'bias_bits': 8}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "model = mod.AI85KWS20NetNAS(num_classes=len(classes), num_channels=128, dimensions=(128, 1), bias=True, \n", + " quantize_activation=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "checkpoint = torch.load(trained_checkpoint_path)\n", + "\n", + "state_dict = checkpoint['state_dict']\n", + "new_state_dict = OrderedDict()\n", + "for k, v in state_dict.items():\n", + " if k.startswith('module.'):\n", + " k = k[7:]\n", + " new_state_dict[k] = v\n", + "checkpoint['state_dict'] = new_state_dict\n", + "\n", + "ai8x.fuse_bn_layers(model)\n", + "ai8x.initiate_qat(model, qat_policy)\n", + "model.load_state_dict(checkpoint['state_dict'], strict=False)\n", + "\n", + "ai8x.update_model(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 2: Set up the test set and evaluation parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, load the KWS test set, specify the noise list and the SNR level list. \n", + "\n", + "Note: Noise types should be picked from the available classes within the MSnoise dataset (`datasets/msnoise.py`)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Processing test...\n", + "test set: 11005 elements\n", + "Class up (# 31): 425 elements\n", + "Class down (# 5): 406 elements\n", + "Class left (# 15): 412 elements\n", + "Class right (# 23): 396 elements\n", + "Class stop (# 27): 411 elements\n", + "Class go (# 11): 402 elements\n", + "Class yes (# 34): 419 elements\n", + "Class no (# 19): 405 elements\n", + "Class on (# 21): 396 elements\n", + "Class off (# 20): 402 elements\n", + "Class one (# 22): 399 elements\n", + "Class two (# 30): 424 elements\n", + "Class three (# 28): 405 elements\n", + "Class four (# 10): 400 elements\n", + "Class five (# 7): 445 elements\n", + "Class six (# 26): 394 elements\n", + "Class seven (# 24): 406 elements\n", + "Class eight (# 6): 408 elements\n", + "Class nine (# 18): 408 elements\n", + "Class zero (# 35): 418 elements\n", + "Class UNKNOWN: 2824 elements\n" + ] + } + ], + "source": [ + "sn = SimpleNamespace()\n", + "sn.truncate_testset = False\n", + "sn.act_mode_8bit = False\n", + "\n", + "data_path = '/data'\n", + "\n", + "_, test_dataset = dataset.KWS_20_get_datasets( (data_path, sn), load_train=False, load_test=True)\n", + "\n", + "originals = list(range(0, len(test_dataset), 3))\n", + "test_dataset.data = test_dataset.data[originals]\n", + "test_dataset.targets = test_dataset.targets[originals]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "noise_list = ['AirConditioner',\n", + " 'AirportAnnouncements',\n", + " 'Babble',\n", + " 'CopyMachine',\n", + " 'Munching',\n", + " 'NeighborSpeaking',\n", + " 'ShuttingDoor',\n", + " 'Typing',\n", + " 'VacuumCleaner',\n", + " 'TradeShow',\n", + " 'WhiteNoise']" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "snr_list = [-5, 0, 5, 10, 15, 20]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 3: Define functions to evaluate the model under different SNR levels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the `evaluate`, `snr_testing` and `benchmark` functions, you can evaluate the trained model under different SNR levels.\n", + "\n", + "- The `evaluate` function evaluates the model under the specified SNR level and noise type.\n", + "- The `snr_testing` function executes a loop over the SNR list. It calls the `evaluate` function for each SNR level, for the specified noise type.\n", + "- The `benchmark` function executes a loop over the list of noise types. It calls the `snr_testing` function for each type of noise." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def evaluate(db = None, noise = False, noise_type = None):\n", + "\n", + " if (noise == True) and (noise_type == None):\n", + " print('Noise type is not specified. Noise will not be applied.')\n", + " noise = False\n", + "\n", + " model.eval()\n", + " model.to(device) \n", + " classerr = tnt.ClassErrorMeter(accuracy=True, topk=(1, min(len(classes), 5)))\n", + "\n", + " transform = transforms.Compose([\n", + " ai8x.normalize(args=sn)\n", + " ])\n", + " \n", + " if noise:\n", + " if (noise_type == 'WhiteNoise'):\n", + "\n", + " mixed_signals = signalmixer(test_dataset, snr = db, noise_type = noise_type, noise_dataset = None)\n", + " mixed_signals_loader = torch.utils.data.DataLoader(mixed_signals, batch_size = 256)\n", + "\n", + " else:\n", + " noise_dataset = msnoise.MSnoise(root = data_path, classes = [noise_type], d_type = 'test', dataset_len = 11005, remove_unknowns=True,\n", + " transform=None, quantize=False, download=False)\n", + "\n", + " mixed_signals = signalmixer(test_dataset, snr = db, noise_type = noise_type, noise_dataset = noise_dataset)\n", + " mixed_signals_loader = torch.utils.data.DataLoader(mixed_signals, batch_size = 256)\n", + " else:\n", + " mixed_signals_loader = torch.utils.data.DataLoader(test_dataset, batch_size = 256)\n", + " \n", + " with torch.no_grad():\n", + " for batch_idx, (inputs, targets) in enumerate(mixed_signals_loader):\n", + " inputs = inputs.to(device)\n", + " targets = targets.to(device)\n", + " outputs = model(inputs)\n", + " classerr.add(outputs, targets)\n", + "\n", + " print(\"Batch: [\",batch_idx*256 ,\"/\", len(test_dataset),\"]\")\n", + " acc = classerr.value()[0]\n", + " print(\"Accuracy: \", acc)\n", + " \n", + " print(\"Total Accuracy: \", acc)\n", + " return acc" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def snr_testing(snr_list = None, noise_type = None, noise = False):\n", + "\n", + " # raw test set evaluation\n", + " if noise == False:\n", + " db = None\n", + " noise_type = None\n", + " accuracies = np.zeros(1)\n", + " accuracies[0] = evaluate(db, noise, noise_type)\n", + "\n", + " # noisy test set evaluation\n", + " else:\n", + " accuracies = np.zeros(len(snr_list))\n", + "\n", + " for idx, db in enumerate(snr_list):\n", + " print(\"Evaluating SNR levels of\", db)\n", + " accuracies[idx] = evaluate(db, noise, noise_type)\n", + "\n", + " return accuracies" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def benchmark(noise_list = None, snr_list = None):\n", + "\n", + " if noise_list == None:\n", + " print('Noise type is not specified. Noise will not be applied.')\n", + " noise = False\n", + " snr_list = None\n", + " else:\n", + " noise = True\n", + " if snr_list == None:\n", + " print('Using default values for SNR levels: [-5, 20] dB.')\n", + " snr_list = range(-5, 20)\n", + "\n", + " if noise:\n", + "\n", + " accuracies = np.zeros((len(noise_list) + 1, len(snr_list)))\n", + "\n", + " for idx, n in enumerate(noise_list):\n", + " print(f'{n} Noise Evaluation')\n", + " accuracies[idx] = snr_testing(snr_list, noise_type = n, noise = noise)\n", + "\n", + " accuracies[-1] = snr_testing(noise = False)\n", + "\n", + " return accuracies " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "accuracies_nas = benchmark(noise_list = noise_list, snr_list = snr_list)\n", + "accuracies = [accuracies_nas]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Optional Step: Adding different models for comparison" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- v3 Model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "trained_checkpoint_path = os.path.join('..', '..', 'ai8x-synthesis', 'trained', 'ai85-kws20_v3-qat8.pth.tar') \n", + "mod = importlib.import_module(\"ai85net-kws20-v3\")\n", + "model_file = \"ai85net-kws20-v3\"\n", + "\n", + "checkpoint = torch.load(trained_checkpoint_path)\n", + "\n", + "model = mod.AI85KWS20Netv3(num_classes=len(classes), num_channels=128, dimensions=(128, 1), bias=False, \n", + " quantize_activation=False)\n", + "\n", + "state_dict = checkpoint['state_dict']\n", + "new_state_dict = OrderedDict()\n", + "for k, v in state_dict.items():\n", + " if k.startswith('module.'):\n", + " k = k[7:]\n", + " new_state_dict[k] = v\n", + "checkpoint['state_dict'] = new_state_dict\n", + "\n", + "ai8x.fuse_bn_layers(model)\n", + "ai8x.initiate_qat(model, qat_policy)\n", + "model.load_state_dict(checkpoint['state_dict'], strict=False)\n", + "\n", + "ai8x.update_model(model)\n", + "\n", + "accuracies_v3 = benchmark(noise_list = noise_list, snr_list = snr_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- v2 Model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "trained_checkpoint_path = os.path.join('..', '..', 'ai8x-synthesis', 'trained', 'ai85-kws20_v2-qat8.pth.tar')\n", + "mod = importlib.import_module(\"ai85net-kws20-v2\")\n", + "model_file = \"ai85net-kws20-v2\"\n", + "\n", + "checkpoint = torch.load(trained_checkpoint_path)\n", + "\n", + "model = mod.AI85KWS20Netv2(num_classes=len(classes), num_channels=128, dimensions=(128, 1), bias=False, \n", + " quantize_activation=False)\n", + "\n", + "state_dict = checkpoint['state_dict']\n", + "new_state_dict = OrderedDict()\n", + "for k, v in state_dict.items():\n", + " if k.startswith('module.'):\n", + " k = k[7:]\n", + " new_state_dict[k] = v\n", + "checkpoint['state_dict'] = new_state_dict\n", + "\n", + "ai8x.fuse_bn_layers(model)\n", + "ai8x.initiate_qat(model, qat_policy)\n", + "model.load_state_dict(checkpoint['state_dict'], strict=False)\n", + "\n", + "ai8x.update_model(model)\n", + "\n", + "accuracies_v2 = benchmark(noise_list = noise_list, snr_list = snr_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "accuracies = [accuracies_nas, accuracies_v2, accuracies_v3]\n", + "model_files = [\"ai85net-kws20-nas\", \"ai85net-kws20-v2\", \"ai85net-kws20-v3\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 4: Comparing noise types (for specified models)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can create data frames to examine the results of evaluation. Using the data frame, you can create plots to compare noise types for each model." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "accs = []\n", + "for model_name, model_acc in enumerate(accuracies):\n", + " csv = {}\n", + "\n", + " for idx, i in enumerate(noise_list):\n", + " csv[i] = model_acc[idx]\n", + " \n", + " csv_list = []\n", + " csv_list.append(['raw', 'None', model_acc[-1][0]])\n", + "\n", + " for i in csv.keys():\n", + " for idx, j in enumerate(csv[i]):\n", + " csv_list.append([i, snr_list[idx], j])\n", + "\n", + " df = pd.DataFrame(csv_list, columns = ['Type', 'SNR (dB)', f'{model_files[model_name]}'])\n", + " \n", + " accs.append(df)\n", + "\n", + "for i in accs:\n", + " df[i.columns[-1]] = i[i.columns[-1]]" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TypeSNR (dB)ai85net-kws20-v3ai85net-kws20-nasai85net-kws20-v2
0rawNone89.86099894.14009391.550831
1AirConditioner-534.72335839.76560433.878441
2AirConditioner056.14608966.77568859.798310
3AirConditioner571.95421181.79340477.541564
4AirConditioner1081.33006389.56118885.799945
..................
62WhiteNoise071.49086984.65521980.703189
63WhiteNoise582.12046990.02453087.135459
64WhiteNoise1086.94467292.50477089.533933
65WhiteNoise1588.77078293.62224091.142001
66WhiteNoise2088.68901693.97656091.196511
\n", + "

67 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " Type SNR (dB) ai85net-kws20-v3 ai85net-kws20-nas \\\n", + "0 raw None 89.860998 94.140093 \n", + "1 AirConditioner -5 34.723358 39.765604 \n", + "2 AirConditioner 0 56.146089 66.775688 \n", + "3 AirConditioner 5 71.954211 81.793404 \n", + "4 AirConditioner 10 81.330063 89.561188 \n", + ".. ... ... ... ... \n", + "62 WhiteNoise 0 71.490869 84.655219 \n", + "63 WhiteNoise 5 82.120469 90.024530 \n", + "64 WhiteNoise 10 86.944672 92.504770 \n", + "65 WhiteNoise 15 88.770782 93.622240 \n", + "66 WhiteNoise 20 88.689016 93.976560 \n", + "\n", + " ai85net-kws20-v2 \n", + "0 91.550831 \n", + "1 33.878441 \n", + "2 59.798310 \n", + "3 77.541564 \n", + "4 85.799945 \n", + ".. ... \n", + "62 80.703189 \n", + "63 87.135459 \n", + "64 89.533933 \n", + "65 91.142001 \n", + "66 91.196511 \n", + "\n", + "[67 rows x 5 columns]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_values(model_num):\n", + "\n", + " accuracies_values = {}\n", + "\n", + " for noise in noise_list:\n", + " acc_list = []\n", + " for idx, i in enumerate(df['Type'].values[1:]): \n", + " if i == noise:\n", + " acc_list.append(df[model_num][1:][idx+1])\n", + " accuracies_values[noise] = acc_list\n", + "\n", + " return accuracies_values" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for model_num in df.columns[2:]:\n", + " accuracies_values = plot_values(model_num)\n", + " plt.figure()\n", + " plt.grid(visible=True, which='major', color='#300000', linestyle='-')\n", + " plt.minorticks_on()\n", + " plt.grid(visible=True, which='minor', color='#900000', linestyle=':')\n", + " for noise in noise_list:\n", + " plt.title(f'Accuracy Test on model {model_num}')\n", + " plt.xlabel('SNR (dB)')\n", + " plt.ylabel('Accuracy (%)')\n", + " plt.plot(snr_list, accuracies_values[noise])\n", + "\n", + " plt.legend(noise_list, bbox_to_anchor=(1.05, 0.75),\n", + " loc='upper left', borderaxespad=0.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 5: Comparing different models (for specified noise types)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also see the comparison between each model for each noise type separately." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "acc_list = []\n", + "for model_num in df.columns[2:]:\n", + " acc_list.append(plot_values(model_num))\n", + " \n", + "for noise in noise_list:\n", + " plt.figure()\n", + " plt.grid(visible=True, which='major', color='#300000', linestyle='-')\n", + " plt.minorticks_on()\n", + " plt.grid(visible=True, which='minor', color='#900000', linestyle=':')\n", + " plt.title(f'{noise} - Accuracy Test')\n", + " plt.xlabel('SNR (dB)')\n", + " plt.ylabel('Accuracy (%)')\n", + " for model in acc_list:\n", + " plt.plot(snr_list , model[noise])\n", + " plt.legend(df.columns[2:], bbox_to_anchor=(1.05, 0.75),\n", + " loc='upper left', borderaxespad=0.)\n", + " \n", + " # you can remove the break to see all noise type comparisons\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Optional Step: Export to CSV" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You may also export the evaluation data to CSV files using the data frames calculated above. If the current model file is already in the CSV file, accuracies will not be added to the CSV file. Otherwise, the current accuracy results will be added to the CSV file as a new column.\n", + "\n", + "Note: Please make sure that you test the same noise types for the same SNR levels for all of the models." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "if os.path.exists('KWS_snr_test.csv'):\n", + " current = pd.read_csv('KWS_snr_test.csv', decimal=',', sep=';')\n", + " if model_file in current.columns:\n", + " print(f'This model file ({model_file}) already exists!')\n", + " else:\n", + " current[model_file] = list(df[model_file].values)\n", + " current.to_csv('KWS_snr_test.csv', sep=';', decimal=',', index=False)\n", + "\n", + "else:\n", + " df.to_csv('KWS_snr_test.csv', sep=';', decimal=',', index=False)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.11" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/parsecmd.py b/parsecmd.py index 1920a49a0..6f0690dbb 100644 --- a/parsecmd.py +++ b/parsecmd.py @@ -1,15 +1,6 @@ -################################################################################################### -# -# Copyright (C) 2019-2023 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -# -# Portions Copyright (c) 2018 Intel Corporation # # Copyright (c) 2018 Intel Corporation +# Portions Copyright (C) 2019-2023 Maxim Integrated Products, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -76,6 +67,17 @@ def get_parser(model_names, dataset_names): parser.add_argument('--avg-pool-rounding', action='store_true', default=False, help='when simulating, use "round()" in AvgPool operations ' '(default: use "floor()")') + parser.add_argument('--dr', type=int, default=None, + help='Embedding dimensionality for dimensionality' + 'reduction (default: None)') + parser.add_argument('--scaf-margin', default=28.6, + type=float, help='Margin hyperparameter' + 'for Sub-center ArcFace Loss') + parser.add_argument('--scaf-scale', default=64, + type=int, help='Scale hyperparameter for Sub-center ArcFace Loss') + parser.add_argument('--backbone-checkpoint', type=str, default=None, metavar='PATH', + help='path to checkpoint from which to load' + 'backbone weights (default: None)') parser.add_argument('--copy-output-folder', type=str, default=None, metavar='PATH', help='Path to copy output folder (default: None)') parser.add_argument('--kd-relationbased', action='store_true', default=False, @@ -104,6 +106,10 @@ def get_parser(model_names, dataset_names): help='optimizer for training (default: SGD)') optimizer_args.add_argument('--lr', '--learning-rate', type=float, metavar='LR', help='initial learning rate') + optimizer_args.add_argument('--scaf-lr', default=1e-4, + type=float, metavar='SCAF_LR', + help='initial learning rate for Sub-center' + 'ArcFace Loss optimizer') optimizer_args.add_argument('--momentum', default=0.9, type=float, metavar='M', help='momentum') optimizer_args.add_argument('--weight-decay', '--wd', default=1e-4, type=float, @@ -135,6 +141,9 @@ def get_parser(model_names, dataset_names): help='save as CSVs with the given prefix during evaluation') mgroup.add_argument('--save-sample', dest='generate_sample', type=int, help='save the sample at given index as NumPy sample data') + parser.add_argument('--slice-sample', action='store_true', default=False, + help='for models that require RGB input, when the sample from the dataset ' + 'has additional channels, slice the sample into 3 channels') parser.add_argument('--shap', default=0, type=int, help='select # of images from the test set and plot SHAP after evaluation') parser.add_argument('--activation-stats', '--act-stats', nargs='+', metavar='PHASE', diff --git a/policies/qat_policy_autoencoder.yaml b/policies/qat_policy_autoencoder.yaml new file mode 100755 index 000000000..ff3c17aac --- /dev/null +++ b/policies/qat_policy_autoencoder.yaml @@ -0,0 +1,4 @@ +--- +start_epoch: 200 +weight_bits: 8 +shift_quantile: 0.995 diff --git a/policies/qat_policy_faceid_112.yaml b/policies/qat_policy_faceid_112.yaml new file mode 100644 index 000000000..a40fdeaea --- /dev/null +++ b/policies/qat_policy_faceid_112.yaml @@ -0,0 +1,17 @@ +--- +start_epoch: 25 +weight_bits: 4 +shift_quantile: 0.6 +overrides: + pre_stage: + weight_bits: 8 + pre_stage_2: + weight_bits: 8 + feature_stage.1.0.conv2: + weight_bits: 2 + feature_stage.2.0.conv2: + weight_bits: 2 + feature_stage.4.0.conv2: + weight_bits: 2 + linear: + weight_bits: 8 diff --git a/policies/qat_policy_mobilefacenet_112.yaml b/policies/qat_policy_mobilefacenet_112.yaml new file mode 100644 index 000000000..f8a4e6247 --- /dev/null +++ b/policies/qat_policy_mobilefacenet_112.yaml @@ -0,0 +1,3 @@ +--- +start_epoch: 25 +weight_bits: 8 diff --git a/policies/schedule-faceid_112.yaml b/policies/schedule-faceid_112.yaml new file mode 100644 index 000000000..6d36bb38e --- /dev/null +++ b/policies/schedule-faceid_112.yaml @@ -0,0 +1,13 @@ +--- +lr_schedulers: + training_lr: + class: MultiStepLR + milestones: [10, 15, 20, 25, 40, 50, 60] + gamma: 0.5 + +policies: + - lr_scheduler: + instance_name: training_lr + starting_epoch: 0 + ending_epoch: 80 + frequency: 1 diff --git a/policies/schedule-mobilefacenet_112.yaml b/policies/schedule-mobilefacenet_112.yaml new file mode 100644 index 000000000..5959971ff --- /dev/null +++ b/policies/schedule-mobilefacenet_112.yaml @@ -0,0 +1,13 @@ +--- +lr_schedulers: + training_lr: + class: MultiStepLR + milestones: [10, 15, 20, 25, 26, 28, 30, 32, 34] + gamma: 0.5 + +policies: + - lr_scheduler: + instance_name: training_lr + starting_epoch: 0 + ending_epoch: 35 + frequency: 1 diff --git a/pyproject.toml b/pyproject.toml index f4273ad5e..5ba5cae57 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ target-version = ['py36'] [tool.codespell] count = '' -ignore-words-list = 'nervana,cconfiguration' +ignore-words-list = 'nervana,cconfiguration,anormal' quiet-level = 3 skip = '*.dasm,*.map,./.mypy_cache,./venv,./.git,./distiller,./data,./datasets/face_id/facenet_pytorch/dependencies,./super-linter.log' ignore-regex = '^\s+"image/png".*$' diff --git a/regression/create_eval_script.py b/regression/create_eval_script.py deleted file mode 100644 index 7ff2ebd2d..000000000 --- a/regression/create_eval_script.py +++ /dev/null @@ -1,65 +0,0 @@ -################################################################################################### -# -# Copyright (C) 2023 Analog Devices, Inc. All Rights Reserved. -# This software is proprietary to Analog Devices, Inc. and its licensors. -# -################################################################################################### -""" -Create training bash scripts for test -""" -import argparse -import os - -import yaml - - -def joining(lst): - """ - Join list based on the ' ' delimiter - """ - join_str = ' '.join(lst) - return join_str - - -parser = argparse.ArgumentParser() -parser.add_argument('--testconf', help='Enter the config file for the test', required=True) -parser.add_argument('--testpaths', help='Enter the paths for the test', required=True) -args = parser.parse_args() -yaml_path = args.testconf -test_path = args.testpaths - -# Open the YAML file -with open(yaml_path, 'r', encoding='utf-8') as yaml_file: - # Load the YAML content into a Python dictionary - config = yaml.safe_load(yaml_file) - -with open(test_path, 'r', encoding='utf-8') as path_file: - # Load the YAML content into a Python dictionary - pathconfig = yaml.safe_load(path_file) - -# Folder containing the files to be concatenated -script_path = pathconfig["script_path"] - -# Output file name and path -output_file_path = pathconfig["output_file_path_evaluation"] - -# Loop through all files in the folder -with open(output_file_path, "w", encoding='utf-8') as evaluate_file: - for filename in os.listdir(script_path): - # Check if the file is a text file - if filename.startswith("evaluate"): - # Open the file and read its contents - with open(os.path.join(script_path, filename), encoding='utf-8') as input_file: - contents = input_file.read() - temp = contents.split() - temp.insert(1, "\n") - - i = temp.index("--exp-load-weights-from") - temp[i+1] = temp[i+1][1:] - - temp.insert(-1, "--name " + filename[9:-3]) - temp.insert(-1, "--data /data_ssd") - - temp.append(" \n") - contents = joining(temp) - evaluate_file.write(contents) diff --git a/regression/create_onnx_script.py b/regression/create_onnx_script.py deleted file mode 100644 index 9bb96e66b..000000000 --- a/regression/create_onnx_script.py +++ /dev/null @@ -1,127 +0,0 @@ -################################################################################################### -# -# Copyright (C) 2023 Analog Devices, Inc. All Rights Reserved. -# This software is proprietary and confidential to Analog Devices, Inc. and its licensors. -# -################################################################################################### -""" -Create onnx bash scripts for test -""" -import argparse -import datetime -import os -import subprocess -import sys - -import yaml - - -def joining(lst): - """ - Join list based on the ' ' delimiter - """ - joined_str = ' '.join(lst) - return joined_str - - -def time_stamp(): - """ - Take time stamp as string - """ - time = str(datetime.datetime.now()) - time = time.replace(' ', '.') - time = time.replace(':', '.') - return time - - -parser = argparse.ArgumentParser() -parser.add_argument('--testconf', help='Enter the config file for the test', required=True) -parser.add_argument('--testpaths', help='Enter the paths for the test', required=True) -args = parser.parse_args() -yaml_path = args.testconf -test_path = args.testpaths - -# Open the YAML file -with open(yaml_path, 'r', encoding='utf-8') as yaml_file: - # Load the YAML content into a Python dictionary - config = yaml.safe_load(yaml_file) - -with open(test_path, 'r', encoding='utf-8') as path_file: - # Load the YAML content into a Python dictionary - pathconfig = yaml.safe_load(path_file) - -if not config["Onnx_Status"]: - sys.exit(1) - -folder_path = pathconfig["folder_path"] -output_file_path = pathconfig["output_file_path_onnx"] -train_path = pathconfig["train_path"] - -logs_list = os.path.join(folder_path, sorted(os.listdir(folder_path))[-1]) - -models = [] -datasets = [] -devices = [] -model_paths = [] -bias = [] -tar_names = [] - - -with open(output_file_path, "w", encoding='utf-8') as onnx_scripts: - with open(train_path, "r", encoding='utf-8') as input_file: - contents = input_file.read() - lines = contents.split("#!/bin/sh ") - lines = lines[1:] - contents_t = contents.split() - - j = [i+1 for i in range(len(contents_t)) if contents_t[i] == '--model'] - for index in j: - models.append(contents_t[index]) - - j = [i+1 for i in range(len(contents_t)) if contents_t[i] == '--dataset'] - for index in j: - datasets.append(contents_t[index]) - - j = [i+1 for i in range(len(contents_t)) if contents_t[i] == '--device'] - for index in j: - devices.append(contents_t[index]) - - for i, line in enumerate(lines): - if "--use-bias" in line: - bias.append("--use-bias") - else: - bias.append("") - - for file_p in sorted(os.listdir(logs_list)): - temp_path = os.path.join(logs_list, file_p) - for temp_file in sorted(os.listdir(temp_path)): - if temp_file.endswith("_checkpoint.pth.tar"): - temp = os.path.join(temp_path, temp_file) - model_paths.append(temp) - tar_names.append(temp_file) - - for i, (model, dataset, bias_value, device_name) in enumerate( - zip(models, datasets, bias, devices) - ): - for tar in model_paths: - element = tar.split('-') - modelsearch = element[-4][3:] - datasearch = element[-3].split('_')[0] - if datasearch == dataset.split('_')[0] and modelsearch == model: - tar_path = tar - timestamp = time_stamp() - temp = ( - f"python train.py " - f"--model {model} " - f"--dataset {dataset} " - f"--evaluate " - f"--exp-load-weights-from {tar_path} " - f"--device {device_name} " - f"--summary onnx " - f"--summary-filename {model}_{dataset}_{timestamp}_onnx " - f"{bias_value}\n" - ) - onnx_scripts.write(temp) -cmd_command = "bash " + output_file_path - -subprocess.run(cmd_command, shell=True, check=True) diff --git a/regression/create_test_script.py b/regression/create_test_script.py deleted file mode 100644 index 7c3f4a5a0..000000000 --- a/regression/create_test_script.py +++ /dev/null @@ -1,110 +0,0 @@ -################################################################################################### -# -# Copyright (C) 2023 Analog Devices, Inc. All Rights Reserved. -# This software is proprietary and confidential to Analog Devices, Inc. and its licensors. -# -################################################################################################### -""" -Create training bash scripts for test -""" -import argparse -import os - -import yaml - - -def joining(lst): - """ - Join list based on the ' ' delimiter - """ - join_str = ' '.join(lst) - return join_str - - -parser = argparse.ArgumentParser() -parser.add_argument('--testconf', help='Enter the config file for the test', required=True) -parser.add_argument('--testpaths', help='Enter the paths for the test', required=True) -args = parser.parse_args() -yaml_path = args.testconf -test_path = args.testpaths - -# Open the YAML file -with open(yaml_path, 'r', encoding='utf-8') as yaml_file: - # Load the YAML content into a Python dictionary - config = yaml.safe_load(yaml_file) - -with open(test_path, 'r', encoding='utf-8') as path_file: - # Load the YAML content into a Python dictionary - pathconfig = yaml.safe_load(path_file) - -# Folder containing the files to be concatenated -script_path = pathconfig["script_path"] -# Output file name and path -output_file_path = pathconfig["output_file_path"] - -# global log_file_names -log_file_names = [] - -# Loop through all files in the folder -with open(output_file_path, "w", encoding='utf-8') as output_file: - for filename in os.listdir(script_path): - # Check if the file is a text file - if filename.startswith("train"): - # Open the file and read its contents - with open(os.path.join(script_path, filename), encoding='utf-8') as input_file: - contents = input_file.read() - - temp = contents.split() - temp.insert(1, "\n") - i = temp.index('--epochs') - j = temp.index('--model') - k = temp.index('--dataset') - - if config["Qat_Test"]: - if '--qat-policy' in temp: - x = temp.index('--qat-policy') - temp[x+1] = "policies/qat_policy.yaml" - else: - temp.insert(-1, ' --qat-policy policies/qat_policy.yaml') - - log_model = temp[j+1] - log_data = temp[k+1] - - if log_model == "ai87imageneteffnetv2": - num = temp.index("--batch-size") - temp[num+1] = "128" - - log_name = temp[j+1] + '-' + temp[k+1] - log_file_names.append(filename[:-3]) - - if log_data == "FaceID": - continue - - if log_data == "VGGFace2_FaceDetection": - continue - - try: - temp[i+1] = str(config[log_data][log_model]["epoch"]) - except KeyError: - print(f"\033[93m\u26A0\033[0m Warning: {temp[j+1]} model is" + - " missing information in test configuration files.") - continue - - if '--deterministic' not in temp: - temp.insert(-1, '--deterministic') - - temp.insert(-1, '--name ' + log_name) - - try: - path_data = config[log_data]["datapath"] - temp[i+1] = str(config[log_data][log_model]["epoch"]) - except KeyError: - print(f"\033[93m\u26A0\033[0m Warning: {temp[j+1]} model is" + - " missing information in test configuration files.") - continue - - temp.insert(-1, '--data ' + path_data) - temp.append("\n") - - contents = joining(temp) - output_file.write(contents) diff --git a/regression/eval_pass_fail.py b/regression/eval_pass_fail.py deleted file mode 100644 index 0de504ea7..000000000 --- a/regression/eval_pass_fail.py +++ /dev/null @@ -1,46 +0,0 @@ -################################################################################################### -# -# Copyright (C) 2023 Analog Devices, Inc. All Rights Reserved. -# This software is proprietary to Analog Devices, Inc. and its licensors. -# -################################################################################################### -""" -Check the test results -""" -import argparse -import os - -import yaml - -parser = argparse.ArgumentParser() -parser.add_argument('--testpaths', help='Enter the paths for the test', required=True) -args = parser.parse_args() -test_path = args.testpaths - -# Open the YAML file -with open(test_path, 'r', encoding='utf-8') as path_file: - # Load the YAML content into a Python dictionary - pathconfig = yaml.safe_load(path_file) - -eval_path = pathconfig["eval_path"] -eval_file = os.listdir(eval_path)[-1] -directory_path = os.path.join(eval_path, eval_file) -passed = [] -failed = [] - -for filename in sorted(os.listdir(directory_path)): - path = os.path.join(directory_path, filename) - file_path = os.path.join(path, os.listdir(path)[0]) - with open(file_path, 'r', encoding='utf-8') as file: - content = file.read() - if "Loss" in content: - pass_file = filename.split("___")[0] - passed.append(f"\033[32m\u2714\033[0m Evaluation test passed for {pass_file}.") - else: - fail_file = filename.split("___")[0] - failed.append(f"\033[31m\u2718\033[0m Evaluation test failed for {fail_file}.") - -for filename in failed: - print(filename) -for filename in passed: - print(filename) diff --git a/regression/last_dev.py b/regression/last_dev.py deleted file mode 100644 index fa8565663..000000000 --- a/regression/last_dev.py +++ /dev/null @@ -1,160 +0,0 @@ -################################################################################################### -# -# Copyright (C) 2023 Analog Devices, Inc. All Rights Reserved. -# This software is proprietary and confidential to Analog Devices, Inc. and its licensors. -# -################################################################################################### -""" -Create the last developed code logs for base testing source -""" -import argparse -import datetime -import os -import subprocess - -import requests -import yaml - - -def joining(lst): - """ - Join based on the ' ' delimiter - """ - join_str = ' '.join(lst) - return join_str - - -parser = argparse.ArgumentParser() -parser.add_argument('--testconf', help='Enter the config file for the test', required=True) -parser.add_argument('--testpaths', help='Enter the paths for the test', required=True) -args = parser.parse_args() -yaml_path = args.testconf -test_path = args.testpaths - -# Open the YAML file -with open(yaml_path, 'r', encoding='utf-8') as yaml_file: - # Load the YAML content into a Python dictionary - config = yaml.safe_load(yaml_file) - -with open(test_path, 'r', encoding='utf-8') as path_file: - # Load the YAML content into a Python dictionary - pathconfig = yaml.safe_load(path_file) - -# Folder containing the files to be concatenated -script_path = pathconfig["script_path_dev"] -# Output file name and path -output_file_path = pathconfig["output_file_path_dev"] - -# global log_file_names -log_file_names = [] - - -def dev_scripts(script_pth, output_file_pth): - """ - Create training scripts for the last developed code - """ - with open(output_file_pth, "w", encoding='utf-8') as output_file: - for filename in os.listdir(script_pth): - # Check if the file is a text file - if filename.startswith("train"): - # Open the file and read its contents - with open(os.path.join(script_path, filename), encoding='utf-8') as input_file: - contents = input_file.read() - - temp = contents.split() - temp.insert(1, "\n") - i = temp.index('--epochs') - j = temp.index('--model') - k = temp.index('--dataset') - - if config["Qat_Test"]: - if '--qat-policy' in temp: - x = temp.index('--qat-policy') - temp[x+1] = "policies/qat_policy.yaml" - else: - temp.insert(-1, ' --qat-policy policies/qat_policy.yaml') - - log_model = temp[j+1] - log_data = temp[k+1] - - if log_model == "ai87imageneteffnetv2": - num = temp.index("--batch-size") - temp[num+1] = "128" - - log_name = temp[j+1] + '-' + temp[k+1] - log_file_names.append(filename[:-3]) - - if log_data == "FaceID": - continue - if log_data == "VGGFace2_FaceDetection": - continue - if log_data == "ai85tinierssdface": - continue - - try: - temp[i+1] = str(config[log_data][log_model]["epoch"]) - except KeyError: - print(f"\033[93m\u26A0\033[0m Warning: {temp[j+1]} model is" + - " missing information in test configuration files.") - continue - - if '--deterministic' not in temp: - temp.insert(-1, '--deterministic') - - temp.insert(-1, '--name ' + log_name) - - try: - path_data = config[log_data]["datapath"] - temp[i+1] = str(config[log_data][log_model]["epoch"]) - except KeyError: - print(f"\033[93m\u26A0\033[0m Warning: {temp[j+1]} model is" + - " missing information in test configuration files.") - continue - - temp.insert(-1, '--data ' + path_data) - temp.append("\n") - contents = joining(temp) - output_file.write(contents) - - -def dev_checkout(): - """ - Checkout the last developed code - """ - repository = 'MaximIntegratedAI/ai8x-training' - branch = 'develop' - - # Send a GET request to the GitHub API to retrieve the commit data - url = f'https://api.github.com/repos/{repository}/commits?sha={branch}' - response = requests.get(url) - - if response.status_code == 200: - commit_hash = response.json()[0]['sha'] - print(f"The hash of the last commit in the '{branch}' branch is: {commit_hash}") - else: - print(f"Failed to retrieve commit information. Status code: {response.status_code}") - - commit_num_path = pathconfig['commit_num_path'] - - try: - with open(commit_num_path, "r", encoding='utf-8') as file: - saved_commit_hash = file.read().strip() - except FileNotFoundError: - saved_commit_hash = "" - - if commit_hash != saved_commit_hash: - with open(commit_num_path, "w", encoding='utf-8') as file: - file.write(commit_hash) - dev_scripts(script_path, output_file_path) - cmd_command = "bash " + output_file_path - subprocess.run(cmd_command, shell=True, check=True) - - source_path = pathconfig["source_path"] - destination_path = os.path.join( - pathconfig["destination_path"], - datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S") - ) - subprocess.run(['/bin/mv', source_path, destination_path], check=True) - - -dev_checkout() diff --git a/regression/log_comparison.py b/regression/log_comparison.py deleted file mode 100644 index 5e3e70f9a..000000000 --- a/regression/log_comparison.py +++ /dev/null @@ -1,215 +0,0 @@ -################################################################################################### -# -# Copyright (C) 2023 Analog Devices, Inc. All Rights Reserved. -# This software is proprietary and confidential to Analog Devices, Inc. and its licensors. -# -################################################################################################### -""" -Compare log files of the pulled code and the last developed -""" -import argparse -import datetime -import os -import sys - -import yaml -from tabulate import tabulate - -parser = argparse.ArgumentParser() -parser.add_argument('--testconf', help='Enter the config file for the test', required=True) -parser.add_argument('--testpaths', help='Enter the paths for the test', required=True) -args = parser.parse_args() -yaml_path = args.testconf -test_path = args.testpaths - -# Open the YAML file -with open(yaml_path, 'r', encoding='utf-8') as yaml_file: - # Load the YAML content into a Python dictionary - config = yaml.safe_load(yaml_file) - -with open(test_path, 'r', encoding='utf-8') as path_file: - # Load the YAML content into a Python dictionary - pathconfig = yaml.safe_load(path_file) - - -def compare_logs(old_log, new_log, output_name, output_pth): - """ - Take diff top1 of log files of the pulled code and the last developed - """ - header = ["Epoch number", "Top1 Diff(%)", "Top5 Diff(%)"] - header_map = ["Epoch number", "mAP Diff(%)"] - - word = 'Best' - word2 = 'Top1' - word3 = 'mAP' - ex_list = [False] - - with open(new_log, 'r', encoding='utf-8') as f2: - file2_content = f2.read() - log_name = new_log.split('/')[-1].split('___')[0] - - if word2 not in file2_content and word3 not in file2_content: - print(f"\033[31m\u2718\033[0m {log_name} does not have any trained results." - " There is an error in training.") - ex_list.append(True) - - if all(ex_list): - print("\033[31m Cancelling github actions.") - sys.exit(1) - - with open(old_log, 'r', encoding='utf-8') as f1, open(new_log, 'r', encoding='utf-8') as f2: - file1_content = f1.readlines() - file2_content = f2.readlines() - - log1_list = [] - log2_list = [] - mAP_list1 = [] - mAP_list2 = [] - - word = 'Best' - word2 = 'Top1' - word3 = 'mAP' - map_value = False - - for line in file1_content: - if word in line and word2 in line: - lst = line.split() - log1_list.append(lst[5:]) - map_value = False - elif word in line and word3 in line: - lst = line.split() - mAP_list1.append(lst[5:7]) - map_value = True - - for line in file2_content: - if word in line and word2 in line: - lst = line.split() - log2_list.append(lst[5:]) - map_value = False - elif word in line and word3 in line: - lst = line.split() - mAP_list2.append(lst[5:7]) - map_value = True - - epoch_num_top = min(len(log1_list), len(log2_list)) - epoch_num_map = min(len(mAP_list1), len(mAP_list2)) - - log1_list = log1_list[:epoch_num_top] - log2_list = log2_list[:epoch_num_top] - mAP_list1 = mAP_list1[:epoch_num_map] - mAP_list2 = mAP_list2[:epoch_num_map] - - top1 = [] - map_list = [] - - if not map_value: - i = 0 - for (list1, list2) in zip(log1_list, log2_list): - if float(list1[1]) == 0: - print("Top1 value of " + output_name + " is 0.00.") - list1[1] = 0.000001 - i = i+1 - if '[Top1:' in list2: - top1_diff = ((float(list2[1])-float(list1[1]))/float(list1[1]))*100 - top1.append([i]) - top1[i-1].append(top1_diff) - - if 'Top5:' in list2: - top5_diff = ((float(list2[3])-float(list1[3]))/float(list1[1]))*100 - top1[i-1].append(top5_diff) - - output_path_2 = os.path.join(output_pth, (output_name + '.txt')) - with open(output_path_2, "w", encoding='utf-8') as output_file: - output_file.write(tabulate(top1, headers=header)) - - if map_value: - i = 0 - for (map1, map2) in zip(mAP_list1, mAP_list2): - if float(map1[1]) == 0: - print(f"Map value of {output_name} is 0.00 at epoch {i}.") - map1[1] = 0.000001 - i = i+1 - if '[mAP:' in map2: - map_diff = ((float(map2[1])-float(map1[1]))/float(map1[1]))*100 - map_list.append([i]) - map_list[i-1].append(map_diff) - - output_path_2 = os.path.join(output_pth, (output_name + '.txt')) - with open(output_path_2, "w", encoding='utf-8') as output_file: - output_file.write(tabulate(map_list, headers=header_map)) - return map_value - - -def log_path_list(path): - """ - Create log names - """ - lst = [] - for file in sorted(os.listdir(path)): - lst.append(file.split("___")[0]) - return lst - - -log_new = pathconfig["log_new"] -log_old = pathconfig["log_old"] -script_path = pathconfig["script_path_log"] - -time = str(datetime.datetime.now()) -time = time.replace(' ', '.') -time = time.replace(':', '.') -output_path = pathconfig["output_path"] + '/' + str(time) - -os.mkdir(output_path) - -loglist = sorted(os.listdir(log_new)) -loglist_old = sorted(os.listdir(log_old)) -old_logs_path = log_old + loglist_old[-1] -new_logs_path = log_new + loglist[-1] - -new_log_list = log_path_list(new_logs_path) -old_log_list = log_path_list(old_logs_path) - -with open(script_path, 'r', encoding='utf-8') as f: - scripts_t = f.read() - scripts = scripts_t.split(' ') -name_indices = [i+1 for i, x in enumerate(scripts) if x == "--name"] -values = [scripts[j] for j in name_indices] - -ex_list2 = [False] -for log in values: - if log not in new_log_list: - print(f"\033[31m\u2718\033[0m {log} does not have any trained log file." - " There is an error in training.") - ex_list2.append(True) - -if all(ex_list2): - print("\033[31m Cancelling github actions.") - sys.exit(1) - -not_found_model = [] -map_value_list = {} - -for files_new in sorted(os.listdir(new_logs_path)): - files_new_temp = files_new.split("___")[0] - if files_new_temp not in old_log_list: - not_found_model.append(files_new_temp + " not found in last developed log files.") - for files_old in sorted(os.listdir(old_logs_path)): - files_old_temp = files_old.split("___")[0] - if files_old_temp == files_new_temp: - - old_path = os.path.join(old_logs_path, files_old) - new_path = os.path.join(new_logs_path, files_new) - - old_files = sorted(os.listdir(old_path)) - new_files = sorted(os.listdir(new_path)) - - old_log_file = [file for file in old_files if file.endswith(".log")][0] - new_log_file = [file for file in new_files if file.endswith(".log")][0] - - old_path_log = os.path.join(old_path, old_log_file) - new_path_log = os.path.join(new_path, new_log_file) - - map_value_list[files_new_temp] = compare_logs( - old_path_log, new_path_log, files_new, output_path - ) - break diff --git a/regression/pass_fail.py b/regression/pass_fail.py deleted file mode 100644 index cdb93a779..000000000 --- a/regression/pass_fail.py +++ /dev/null @@ -1,107 +0,0 @@ -################################################################################################### -# -# Copyright (C) 2023 Analog Devices, Inc. All Rights Reserved. -# This software is proprietary and confidential to Analog Devices, Inc. and its licensors. -# -################################################################################################### -""" -Check the test results -""" -import argparse -import os -import sys - -import yaml -from log_comparison import map_value_list, not_found_model - -parser = argparse.ArgumentParser() -parser.add_argument('--testconf', help='Enter the config file for the test', required=True) -parser.add_argument('--testpaths', help='Enter the paths for the test', required=True) -args = parser.parse_args() -yaml_path = args.testconf -test_path = args.testpaths - -# Open the YAML file -with open(yaml_path, 'r', encoding='utf-8') as yaml_file: - # Load the YAML content into a Python dictionary - config = yaml.safe_load(yaml_file) - -with open(test_path, 'r', encoding='utf-8') as path_file: - # Load the YAML content into a Python dictionary - pathconfig = yaml.safe_load(path_file) - -log_path = pathconfig["log_path"] -log_path = os.path.join(log_path, sorted(os.listdir(log_path))[-1]) - - -def check_top_value(diff_file, threshold, map_value): - """ - Compare Top1 value with threshold - """ - if not map_value: - with open(diff_file, 'r', encoding='utf-8') as f: - model_name = diff_file.split('/')[-1].split('___')[0] - # Read all lines in the diff_file - lines = f.readlines() - # Extract the last line and convert it to a float - top1 = lines[-1].split() - try: - epoch_num = int(top1[0]) - except ValueError: - print(f"\033[31m\u2718\033[0m Test failed for {model_name}: " - f"Cannot convert {top1[0]} to an epoch number.") - return False - top1_diff = float(top1[1]) - - if top1_diff < threshold: - print(f"\033[31m\u2718\033[0m Test failed for {model_name} since" - f" Top1 value changed {top1_diff} % at {epoch_num}th epoch.") - return False - print(f"\033[32m\u2714\033[0m Test passed for {model_name} since" - f" Top1 value changed {top1_diff} % at {epoch_num}th epoch.") - return True - - with open(diff_file, 'r', encoding='utf-8') as f: - model_name = diff_file.split('/')[-1].split('___')[0] - # Read all lines in the diff_file - lines = f.readlines() - # Extract the last line and convert it to a float - top1 = lines[-1].split() - try: - epoch_num = int(top1[0]) - except ValueError: - print(f"\033[31m\u2718\033[0m Test failed for {model_name}: " - f"Cannot convert {top1[0]} to an epoch number.") - return False - top1_diff = float(top1[1]) - # top5_diff = float(top1[2]) - - if top1_diff < threshold: - print(f"\033[31m\u2718\033[0m Test failed for {model_name} since" - f" mAP value changed {top1_diff} % at {epoch_num}th epoch.") - return False - print(f"\033[32m\u2714\033[0m Test passed for {model_name} since" - f" mAP value changed {top1_diff} % at {epoch_num}th epoch.") - return True - - -passing = [] -for item in not_found_model: - print("\033[93m\u26A0\033[0m " + "Warning: " + item) - -for logs in sorted(os.listdir(log_path)): - log_name = (logs.split("___"))[0] - log_model = log_name.split("-")[0] - log_data = log_name.split("-")[1] - - if log_data in config and log_model in config[log_data]: - threshold_temp = float(config[f'{log_data}'][f'{log_model}']['threshold']) - else: - threshold_temp = 0 - logs = os.path.join(log_path, str(logs)) - map_val = map_value_list[log_name] - passing.append(check_top_value(logs, threshold_temp, map_val)) - -if not all(passing): - print("\033[31mOne or more tests did not pass. Cancelling github actions.") - sys.exit(1) diff --git a/regression/paths.yaml b/regression/paths.yaml deleted file mode 100644 index 4b51d0980..000000000 --- a/regression/paths.yaml +++ /dev/null @@ -1,33 +0,0 @@ ---- -# Create_onnx_script.py - -folder_path: /home/test/max7800x/test_logs/ -output_file_path_onnx: ./scripts/onnx_scripts.sh -train_path: /home/test/max7800x/test_scripts/output_file.sh - -# create_test_script.py - -script_path: ./scripts -output_file_path: ./scripts/output_file.sh -output_file_path_evaluation: ./scripts/evaluation_file.sh - -# last_dev.py - -script_path_dev: /home/test/max7800x/last_developed/last_dev_source/scripts -output_file_path_dev: /home/test/max7800x/last_developed/dev_scripts/last_dev_train.sh -source_path: /home/test/actions-runner/_work/ai8x-training/ai8x-training/logs/ -destination_path: /home/test/max7800x/last_developed/dev_logs/ -local_path: /home/test/max7800x/last_developed/last_dev_source/ -commit_num_path: /home/test/max7800x/last_developed/commit_number.txt - -# log_comparison.py - -log_new: /home/test/max7800x/test_logs/ -log_old: /home/test/max7800x/last_developed/dev_logs/ -script_path_log: /home/test/max7800x/test_scripts/output_file.sh -output_path: /home/test/max7800x/log_diff/ - -# pass_fail.py - -log_path: /home/test/max7800x/log_diff -eval_path: /home/test/max7800x/evaluation_logs/ diff --git a/regression/test_config.yaml b/regression/test_config.yaml deleted file mode 100644 index 856b584f3..000000000 --- a/regression/test_config.yaml +++ /dev/null @@ -1,99 +0,0 @@ ---- -Onnx_Status: true -Qat_Test: false -AISegment_352: - datapath: /data_ssd - ai85unetlarge: - threshold: -5 - epoch: 15 -CamVid_s352_c3: - datapath: /data_ssd - ai85unetlarge: - threshold: -5 - epoch: 15 -cats_vs_dogs: - datapath: /data_ssd - ai85cdnet: - threshold: -5 - epoch: 15 -CIFAR10: - datapath: "/data_ssd" - ai85nascifarnet: - threshold: -5 - epoch: 15 - ai85net6: - threshold: -5 - epoch: 15 - ai85squeezenet: - threshold: -5 - epoch: 15 -CIFAR100: - datapath: "/data_ssd" - ai85simplenet: - threshold: -5 - epoch: 15 - ai85nascifarnet: - threshold: -5 - epoch: 15 - ai87effnetv2: - threshold: -5 - epoch: 15 - ai87netmobilenetv2cifar100_m0_5: - threshold: -5 - epoch: 15 - ai87netmobilenetv2cifar100_m0_75: - threshold: -5 - epoch: 15 - ai85ressimplenet: - threshold: -5 - epoch: 15 - ai85simplenetwide2x: - threshold: -5 - epoch: 15 -ImageNet: - datapath: "/data_ssd" - ai87imageneteffnetv2: - threshold: -5 - epoch: 15 -ImageNet_Bayer: - datapath: "/data_ssd" - bayer2rgbnet: - threshold: -5 - epoch: 15 -KWS_20: - datapath: "/data_ssd" - ai85kws20net: - threshold: -5 - epoch: 15 - ai85kws20netv2: - threshold: -5 - epoch: 15 - ai85kws20netv3: - threshold: -5 - epoch: 15 - ai87kws20netv3: - threshold: -5 - epoch: 15 -MNIST: - datapath: "/data_ssd" - ai85netextrasmall: - threshold: -5 - epoch: 15 - ai85net5: - threshold: -500 - epoch: 15 -SVHN_74: - datapath: "/data_ssd" - ai85tinierssd: - threshold: -500 - epoch: 15 -PascalVOC_2007_2012_256_320_augmented: - datapath: "/data_ssd" - ai87fpndetector: - threshold: -500 - epoch: 15 -Kinetics400: - datapath: "/data_ssd" - ai85actiontcn: - threshold: -500 - epoch: 15 diff --git a/requirements-cu11.txt b/requirements-cu11.txt index d7790e764..90d038a5c 100644 --- a/requirements-cu11.txt +++ b/requirements-cu11.txt @@ -1,22 +1,3 @@ -numpy>=1.22,<1.23 -PyYAML>=5.1.1 -scipy>=1.3.0 -librosa>=0.7.2 -Pillow>=7 -shap>=0.34.0 -tk>=0.1.0 https://download.pytorch.org/whl/cu111/torch-1.8.1%2Bcu111-cp38-cp38-linux_x86_64.whl -torchaudio==0.8.1 https://download.pytorch.org/whl/cu111/torchvision-0.9.1%2Bcu111-cp38-cp38-linux_x86_64.whl -tensorboard>=2.9.0,<2.10.0 -protobuf>=3.20.1,<4.0 -numba<0.50.0 -opencv-python>=4.4.0 -h5py>=3.7.0 -torchmetrics==0.6.0 -pycocotools==2.0.6 -albumentations>=1.3.0 -pytube>=12.1.3 -pyffmpeg==2.0 -GitPython>=3.1.18 --e distiller +-r requirements.txt diff --git a/requirements-win-cu11.txt b/requirements-win-cu11.txt index 4f3e8b48b..716c30e0b 100644 --- a/requirements-win-cu11.txt +++ b/requirements-win-cu11.txt @@ -1,22 +1,3 @@ -numpy>=1.22,<1.23 -PyYAML>=5.1.1 -scipy>=1.3.0 -librosa>=0.7.2 -Pillow>=7 -shap>=0.34.0 -tk>=0.1.0 https://download.pytorch.org/whl/cu111/torch-1.8.1%2Bcu111-cp38-cp38-win_amd64.whl -torchaudio==0.8.1 https://download.pytorch.org/whl/cu111/torchvision-0.9.1%2Bcu111-cp38-cp38-win_amd64.whl -tensorboard>=2.9.0,<2.10.0 -protobuf>=3.20.1,<4.0 -numba<0.50.0 -opencv-python>=4.4.0 -h5py>=3.7.0 -torchmetrics==0.6.0 -pycocotools==2.0.6 -albumentations>=1.3.0 -pytube>=12.1.3 -pyffmpeg==2.0 -GitPython>=3.1.18 --e distiller +-r requirements.txt diff --git a/requirements.txt b/requirements.txt index bb7a713bb..aa5726440 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,22 +1,27 @@ -numpy>=1.22,<1.23 -PyYAML>=5.1.1 -scipy>=1.3.0 -librosa>=0.7.2 -Pillow>=7 -shap>=0.34.0 -tk>=0.1.0 torch==1.8.1 torchaudio==0.8.1 torchvision==0.9.1 -tensorboard>=2.9.0,<2.10.0 -protobuf>=3.20.1,<4.0 +GitPython>=3.1.18 +Pillow>=7 +PyYAML>=5.1.1 +albumentations>=1.3.0 +faiss-cpu==1.7.4 +face-detection==0.2.2 +h5py>=3.7.0 +imutils==0.5.4 +kornia==0.6.8 +librosa>=0.7.2 numba<0.50.0 +numpy>=1.22,<1.23 opencv-python>=4.4.0 -h5py>=3.7.0 -torchmetrics==0.6.0 -pycocotools==2.0.6 -albumentations>=1.3.0 -pytube>=12.1.3 +protobuf>=3.20.1,<4.0 +pycocotools==2.0.7 pyffmpeg==2.0 -GitPython>=3.1.18 +pytorch-metric-learning==2.3.0 +pytube>=12.1.3 +scipy>=1.3.0 +shap>=0.34.0 +tensorboard>=2.9.0,<2.10.0 +tk>=0.1.0 +torchmetrics==0.6.0 -e distiller diff --git a/sample.py b/sample.py index 21e0cc63e..c1616e497 100644 --- a/sample.py +++ b/sample.py @@ -19,6 +19,7 @@ def generate( outputs, # pylint: disable=unused-argument dataset_name, search=False, # pylint: disable=unused-argument + slice_sample=False, ): """ Save the element `index` from the `inputs` batch to a file named "sample_`dataset_name`.npy". @@ -33,6 +34,8 @@ def generate( print(f'==> Saving sample at index {index} to {sample_name}.npy') x = inputs[index].cpu().numpy().astype('int64') + if slice_sample: + x = x[0:3, :, :] x = np.clip(x, -128, 127) np.save(sample_name, x, allow_pickle=False, fix_imports=False) diff --git a/scripts/evaluate_autoencoder.sh b/scripts/evaluate_autoencoder.sh new file mode 100755 index 000000000..592e9f0af --- /dev/null +++ b/scripts/evaluate_autoencoder.sh @@ -0,0 +1,2 @@ +#!/bin/sh +python train.py --deterministic --model ai85autoencoder --dataset SampleMotorDataLimerick_ForEvalWithSignal --regression --device MAX78000 --qat-policy policies/qat_policy_autoencoder.yaml --use-bias --evaluate --exp-load-weights-from ../ai8x-synthesis/trained/ai85-autoencoder-samplemotordatalimerick-qat-q.pth.tar -8 --print-freq 1 "$@" diff --git a/scripts/evaluate_cifar100_effnet2.sh b/scripts/evaluate_cifar100_effnet2.sh index 1f7cdeac7..1eb9f36f3 100755 --- a/scripts/evaluate_cifar100_effnet2.sh +++ b/scripts/evaluate_cifar100_effnet2.sh @@ -1,2 +1,2 @@ #!/bin/sh -python train.py --model ai87effnetv2 --dataset CIFAR100 --evaluate --device MAX78000 --exp-load-weights-from ../ai8x-synthesis/trained/ai87-cifar100-effnet2-qat8-q.pth.tar -8 --use-bias "$@" +python train.py --model ai87effnetv2 --dataset CIFAR100 --evaluate --device MAX78002 --exp-load-weights-from ../ai8x-synthesis/trained/ai87-cifar100-effnet2-qat8-q.pth.tar -8 --use-bias "$@" diff --git a/scripts/evaluate_cifar100_mobilenet_v2_0.5.sh b/scripts/evaluate_cifar100_mobilenet_v2_0.5.sh index 6d6e20f25..87c4a529c 100755 --- a/scripts/evaluate_cifar100_mobilenet_v2_0.5.sh +++ b/scripts/evaluate_cifar100_mobilenet_v2_0.5.sh @@ -1,2 +1,2 @@ #!/bin/sh -python train.py --model ai87netmobilenetv2cifar100_m0_5 --dataset CIFAR100 --evaluate --device MAX78000 --exp-load-weights-from ../ai8x-synthesis/trained/ai87-cifar100-mobilenet-v2-0.5-qat8-q.pth.tar -8 --use-bias "$@" +python train.py --model ai87netmobilenetv2cifar100_m0_5 --dataset CIFAR100 --evaluate --device MAX78002 --exp-load-weights-from ../ai8x-synthesis/trained/ai87-cifar100-mobilenet-v2-0.5-qat8-q.pth.tar -8 --use-bias "$@" diff --git a/scripts/evaluate_cifar100_mobilenet_v2_0.75.sh b/scripts/evaluate_cifar100_mobilenet_v2_0.75.sh index b1d3ec88f..54c94a5fc 100755 --- a/scripts/evaluate_cifar100_mobilenet_v2_0.75.sh +++ b/scripts/evaluate_cifar100_mobilenet_v2_0.75.sh @@ -1,2 +1,2 @@ #!/bin/sh -python train.py --model ai87netmobilenetv2cifar100_m0_75 --dataset CIFAR100 --evaluate --device MAX78000 --exp-load-weights-from ../ai8x-synthesis/trained/ai87-cifar100-mobilenet-v2-0.75-qat8-q.pth.tar -8 --use-bias "$@" +python train.py --model ai87netmobilenetv2cifar100_m0_75 --dataset CIFAR100 --evaluate --device MAX78002 --exp-load-weights-from ../ai8x-synthesis/trained/ai87-cifar100-mobilenet-v2-0.75-qat8-q.pth.tar -8 --use-bias "$@" diff --git a/scripts/evaluate_cifar10_1x1.sh b/scripts/evaluate_cifar10_1x1.sh deleted file mode 100755 index 46f27ae79..000000000 --- a/scripts/evaluate_cifar10_1x1.sh +++ /dev/null @@ -1,2 +0,0 @@ -#!/bin/sh -python train.py --model ai85net6 --dataset CIFAR10 --confusion --evaluate --device MAX78000 --exp-load-weights-from ../ai8x-synthesis/trained/ai85-cifar10-1x1.pth.tar -8 "$@" diff --git a/scripts/evaluate_faceid.sh b/scripts/evaluate_faceid.sh deleted file mode 100755 index c12272e99..000000000 --- a/scripts/evaluate_faceid.sh +++ /dev/null @@ -1,2 +0,0 @@ -#!/bin/sh -python train.py --model ai85faceidnet --dataset FaceID --regression --evaluate --exp-load-weights-from ../ai8x-synthesis/trained/ai85-faceid-qat8-q.pth.tar -8 --device MAX78000 "$@" diff --git a/scripts/evaluate_faceid_112.sh b/scripts/evaluate_faceid_112.sh new file mode 100755 index 000000000..c3ff45b6a --- /dev/null +++ b/scripts/evaluate_faceid_112.sh @@ -0,0 +1,2 @@ +#!/bin/sh +python train.py --model ai85faceidnet_112 --dataset VGGFace2_FaceID --kd-student-wt 0 --kd-distill-wt 1 --kd-teacher ir_152 --kd-resume pretrained/ir152_dim64/best.pth.tar --kd-relationbased --evaluate --device MAX78000 --exp-load-weights-from ../ai8x-synthesis/trained/ai85-faceid_112-qat-q.pth.tar -8 --use-bias --save-sample 10 --slice-sample "$@" diff --git a/scripts/evaluate_imagenet_effnet2.sh b/scripts/evaluate_imagenet_effnet2.sh index aa6161718..4eec90836 100755 --- a/scripts/evaluate_imagenet_effnet2.sh +++ b/scripts/evaluate_imagenet_effnet2.sh @@ -1,2 +1,2 @@ #!/bin/sh -python train.py --model ai87imageneteffnetv2 --dataset ImageNet --evaluate --device MAX78002 --exp-load-weights-from ../ai8x-synthesis/trained/ai87-imagenet-effnet2-q.pth.tar -8 --use-bias "$@" +python train.py --model ai87imageneteffnetv2 --dataset ImageNet --evaluate --device MAX78002 --exp-load-weights-from ../ai8x-synthesis/trained/ai87-imagenet-effnet2-q.pth.tar -8 --use-bias --qat-policy policies/qat_policy_imagenet.yaml "$@" diff --git a/scripts/evaluate_kws20_nas.sh b/scripts/evaluate_kws20_nas.sh new file mode 100755 index 000000000..d615245fe --- /dev/null +++ b/scripts/evaluate_kws20_nas.sh @@ -0,0 +1,2 @@ +#!/bin/sh +python train.py --model ai85kws20netnas --use-bias --dataset KWS_20 --confusion --evaluate --exp-load-weights-from ../ai8x-synthesis/trained/ai85-kws20_nas-qat8-q.pth.tar -8 --device MAX78000 "$@" diff --git a/scripts/evaluate_mobilefacenet_112.sh b/scripts/evaluate_mobilefacenet_112.sh new file mode 100755 index 000000000..332e2b938 --- /dev/null +++ b/scripts/evaluate_mobilefacenet_112.sh @@ -0,0 +1,2 @@ +#!/bin/sh +python train.py --model ai87netmobilefacenet_112 --dataset VGGFace2_FaceID --kd-student-wt 0 --kd-distill-wt 1 --kd-teacher ir_152 --kd-resume pretrained/ir152_dim64/best.pth.tar --kd-relationbased --evaluate --device MAX78002 --exp-load-weights-from ../ai8x-synthesis/trained/ai87-mobilefacenet-112-qat-q.pth.tar -8 --use-bias --save-sample 10 --slice-sample "$@" diff --git a/scripts/train_autoencoder.sh b/scripts/train_autoencoder.sh new file mode 100755 index 000000000..98de12d61 --- /dev/null +++ b/scripts/train_autoencoder.sh @@ -0,0 +1,2 @@ +#!/bin/sh +python train.py --deterministic --regression --print-freq 1 --epochs 400 --optimizer Adam --lr 0.001 --wd 0 --model ai85autoencoder --use-bias --dataset SampleMotorDataLimerick_ForTrain --device MAX78000 --batch-size 32 --validation-split 0 --show-train-accuracy full --qat-policy policies/qat_policy_autoencoder.yaml "$@" diff --git a/scripts/train_facedet_tinierssd.sh b/scripts/train_facedet_tinierssd.sh index 94ebd2549..d3c67f68f 100755 --- a/scripts/train_facedet_tinierssd.sh +++ b/scripts/train_facedet_tinierssd.sh @@ -1,2 +1,2 @@ #!/bin/sh -python train.py --deterministic --print-freq 1 --epochs 3 --optimizer Adam --lr 1e-3 --wd 5e-4 --model ai85tinierssdface --use-bias --momentum 0.9 --dataset VGGFace2_FaceDetection --device MAX78000 --obj-detection --obj-detection-params parameters/obj_detection_params_facedet.yaml --batch-size 100 --qat-policy policies/qat_policy_facedet.yaml --validation-split 0.1 "$@" +python train.py --deterministic --print-freq 100 --epochs 3 --optimizer Adam --lr 1e-3 --wd 5e-4 --model ai85tinierssdface --use-bias --momentum 0.9 --dataset VGGFace2_FaceDetection --device MAX78000 --obj-detection --obj-detection-params parameters/obj_detection_params_facedet.yaml --batch-size 100 --qat-policy policies/qat_policy_facedet.yaml --validation-split 0.1 "$@" diff --git a/scripts/train_faceid.sh b/scripts/train_faceid.sh deleted file mode 100755 index 1465c8b5d..000000000 --- a/scripts/train_faceid.sh +++ /dev/null @@ -1,2 +0,0 @@ -#!/bin/sh -python train.py --epochs 100 --optimizer Adam --lr 0.001 --wd 0 --deterministic --compress policies/schedule-faceid.yaml --model ai85faceidnet --dataset FaceID --batch-size 100 --device MAX78000 --regression --print-freq 250 "$@" diff --git a/scripts/train_faceid_112.sh b/scripts/train_faceid_112.sh new file mode 100755 index 000000000..ef54f1b7c --- /dev/null +++ b/scripts/train_faceid_112.sh @@ -0,0 +1,3 @@ +#!/bin/sh +python train.py --epochs 4 --optimizer Adam --lr 0.001 --scaf-lr 1e-2 --scaf-scale 32 --copy-output-folder pretrained/ir152_dim64 --wd 5e-4 --deterministic --workers 8 --qat-policy None --model ir_152 --dr 64 --backbone-checkpoint pretrained/Backbone_IR_152_Epoch_112_Batch_2547328_Time_2019-07-13-02-59_checkpoint.pth --use-bias --dataset VGGFace2_FaceID_dr --batch-size 64 --device MAX78000 --validation-split 0 --print-freq 250 "$@" || exit 1 +python train.py --epochs 80 --optimizer Adam --lr 0.001 --compress policies/schedule-faceid_112.yaml --kd-student-wt 0 --kd-distill-wt 1 --qat-policy policies/qat_policy_faceid_112.yaml --model ai85faceidnet_112 --kd-teacher ir_152 --kd-resume pretrained/ir152_dim64/best.pth.tar --kd-relationbased --wd 0 --deterministic --workers 8 --use-bias --dataset VGGFace2_FaceID --batch-size 256 --device MAX78000 --print-freq 100 --validation-split 0 "$@" diff --git a/scripts/train_kws20_nas.sh b/scripts/train_kws20_nas.sh new file mode 100755 index 000000000..fe68123ce --- /dev/null +++ b/scripts/train_kws20_nas.sh @@ -0,0 +1,2 @@ +#!/bin/sh +python train.py --epochs 200 --optimizer Adam --lr 0.001 --wd 0 --deterministic --qat-policy policies/qat_policy_late_kws20.yaml --compress policies/schedule_kws20.yaml --model ai85kws20netnas --use-bias --dataset KWS_20 --confusion --device MAX78000 "$@" diff --git a/scripts/train_mobilefacenet_112.sh b/scripts/train_mobilefacenet_112.sh new file mode 100755 index 000000000..a00fe7c69 --- /dev/null +++ b/scripts/train_mobilefacenet_112.sh @@ -0,0 +1,3 @@ +#!/bin/sh +python train.py --epochs 4 --optimizer Adam --lr 0.001 --scaf-lr 1e-2 --scaf-scale 32 --copy-output-folder pretrained/ir152_dim64 --wd 5e-4 --deterministic --workers 8 --qat-policy None --model ir_152 --dr 64 --backbone-checkpoint pretrained/Backbone_IR_152_Epoch_112_Batch_2547328_Time_2019-07-13-02-59_checkpoint.pth --use-bias --dataset VGGFace2_FaceID_dr --batch-size 64 --device MAX78000 --validation-split 0 --print-freq 250 "$@" || exit 1 +python train.py --epochs 35 --optimizer Adam --lr 0.001 --compress policies/schedule-mobilefacenet_112.yaml --kd-student-wt 0 --kd-distill-wt 1 --qat-policy policies/qat_policy_mobilefacenet_112.yaml --model ai87netmobilefacenet_112 --kd-teacher ir_152 --kd-resume pretrained/ir152_dim64/best.pth.tar --kd-relationbased --wd 0 --deterministic --workers 8 --use-bias --dataset VGGFace2_FaceID --batch-size 100 --device MAX78002 --validation-split 0 --print-freq 100 "$@" diff --git a/train.py b/train.py index 26742cabf..c05e90814 100644 --- a/train.py +++ b/train.py @@ -1,16 +1,7 @@ #!/usr/bin/env python3 -################################################################################################### # -# Copyright (C) 2019-2023 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -# -################################################################################################### -# pyright: reportMissingModuleSource=false, reportGeneralTypeIssues=false -# pyright: reportOptionalSubscript=false -# -# Portions Copyright (c) 2018 Intel Corporation +# Copyright (c) 2018 Intel Corporation +# Portions Copyright (C) 2019-2024 Maxim Integrated Products, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -24,8 +15,9 @@ # See the License for the specific language governing permissions and # limitations under the License. # - -"""This is an example application for compressing image classification models. +# pyright: reportMissingModuleSource=false, reportGeneralTypeIssues=false +# pyright: reportOptionalSubscript=false +"""This is the example training application for MAX7800x. The application borrows its main flow code from torchvision's ImageNet classification training sample application (https://github.com/pytorch/examples/tree/master/imagenet). @@ -103,6 +95,11 @@ RecordsActivationStatsCollector, SummaryActivationStatsCollector, collectors_context) from distiller.quantization.range_linear import PostTrainLinearQuantizer +from pytorch_metric_learning import losses as pml_losses +from pytorch_metric_learning import testers +from pytorch_metric_learning.distances import CosineSimilarity +from pytorch_metric_learning.utils.accuracy_calculator import AccuracyCalculator +from pytorch_metric_learning.utils.inference import CustomKNN from torchmetrics.detection.map import MAP as MeanAveragePrecision # pylint: enable=no-name-in-module @@ -341,6 +338,7 @@ def main(): # We can optionally resume from a checkpoint optimizer = None + loss_optimizer = None if args.resumed_checkpoint_path: update_old_model_params(args.resumed_checkpoint_path, model) if qat_policy is not None: @@ -395,6 +393,28 @@ def main(): alpha=obj_detection_params['multi_box_loss']['alpha'], neg_pos_ratio=obj_detection_params['multi_box_loss'] ['neg_pos_ratio'], device=args.device).to(args.device) + + elif args.dr: + + criterion = pml_losses.SubCenterArcFaceLoss(num_classes=args.num_classes, + embedding_size=args.dr, + margin=args.scaf_margin, + scale=args.scaf_scale) + if args.resumed_checkpoint_path: + checkpoint = torch.load(args.resumed_checkpoint_path, + map_location=lambda storage, loc: storage) + criterion.W = checkpoint['extras']['loss_weights'] + criterion = criterion.to(args.device) + + loss_optimizer = torch.optim.Adam(criterion.parameters(), lr=args.scaf_lr) + if args.resumed_checkpoint_path: + loss_optimizer.load_state_dict(checkpoint['extras']['loss_optimizer_state_dict']) + + distance_fn = CosineSimilarity() + custom_knn = CustomKNN(distance_fn, batch_size=args.batch_size) + accuracy_calculator = AccuracyCalculator(knn_func=custom_knn, + include=("precision_at_1",), k=1) + else: if not args.regression: if 'weight' in selected_source: @@ -438,22 +458,14 @@ def main(): args.sensitivity_range[2]) return sensitivity_analysis(model, criterion, test_loader, pylogger, args, sensitivities) - if args.evaluate: - msglogger.info('Dataset sizes:\n\ttest=%d', len(test_loader.sampler)) - return evaluate_model(model, criterion, test_loader, pylogger, activations_collectors, - args, compression_scheduler) - - assert train_loader and val_loader - msglogger.info('Dataset sizes:\n\ttraining=%d\n\tvalidation=%d\n\ttest=%d', - len(train_loader.sampler), len(val_loader.sampler), len(test_loader.sampler)) - if args.compress: # The main use-case for this sample application is CNN compression. Compression # requires a compression schedule configuration file in YAML. compression_scheduler = distiller.file_config(model, optimizer, args.compress, compression_scheduler, (start_epoch-1) - if args.resumed_checkpoint_path else None) + if args.resumed_checkpoint_path + else None, loss_optimizer) elif compression_scheduler is None: compression_scheduler = distiller.CompressionScheduler(model) @@ -483,7 +495,8 @@ def main(): dlw = distiller.DistillationLossWeights(args.kd_distill_wt, args.kd_student_wt, args.kd_teacher_wt) if args.kd_relationbased: - args.kd_policy = kd_relationbased.RelationBasedKDPolicy(model, teacher, dlw) + args.kd_policy = kd_relationbased.RelationBasedKDPolicy(model, teacher, + dlw, args.act_mode_8bit) else: args.kd_policy = distiller.KnowledgeDistillationPolicy(model, teacher, args.kd_temp, dlw) @@ -522,6 +535,15 @@ def main(): args.epochs) create_nas_kd_policy(model, compression_scheduler, start_epoch, kd_end_epoch, args) + if args.evaluate: + msglogger.info('Dataset sizes:\n\ttest=%d', len(test_loader.sampler)) + return evaluate_model(model, criterion, test_loader, pylogger, activations_collectors, + args, compression_scheduler) + + assert train_loader and val_loader + msglogger.info('Dataset sizes:\n\ttraining=%d\n\tvalidation=%d\n\ttest=%d', + len(train_loader.sampler), len(val_loader.sampler), len(test_loader.sampler)) + vloss = 10**6 for epoch in range(start_epoch, ending_epoch): # pylint: disable=unsubscriptable-object @@ -535,6 +557,14 @@ def main(): # Update the optimizer to reflect fused batchnorm layers optimizer = ai8x.update_optimizer(model, optimizer) + # Update the compression scheduler to reflect the updated optimizer + for ep, _ in enumerate(compression_scheduler.policies): + for pol in compression_scheduler.policies[ep]: + for attr_key in dir(pol): + attr = getattr(pol, attr_key) + if hasattr(attr, 'optimizer'): + attr.optimizer = optimizer + # Switch model from unquantized to quantized for QAT ai8x.initiate_qat(model, qat_policy) @@ -557,7 +587,8 @@ def main(): # Train for one epoch with collectors_context(activations_collectors["train"]) as collectors: train(train_loader, model, criterion, optimizer, epoch, compression_scheduler, - loggers=all_loggers, args=args) + loggers=all_loggers, args=args, loss_optimizer=loss_optimizer) + # distiller.log_weights_sparsity(model, epoch, loggers=all_loggers) distiller.log_activation_statistics(epoch, "train", loggers=all_tbloggers, collector=collectors["sparsity"]) @@ -584,8 +615,11 @@ def main(): checkpoint_name = f'nas_stg{stage}_lev{level}' with collectors_context(activations_collectors["valid"]) as collectors: - top1, top5, vloss, mAP = validate(val_loader, model, criterion, [pylogger], - args, epoch, tflogger) + if not args.dr: + top1, top5, vloss, mAP = validate(val_loader, model, criterion, [pylogger], + args, epoch, tflogger) + else: + top1, top5, vloss, mAP = scaf_test(val_loader, model, accuracy_calculator) distiller.log_activation_statistics(epoch, "valid", loggers=all_tbloggers, collector=collectors["sparsity"]) save_collectors_data(collectors, msglogger.logdir) @@ -596,7 +630,7 @@ def main(): if not args.regression: stats = ('Performance/Validation/', OrderedDict([('Loss', vloss), ('Top1', top1)])) - if args.num_classes > 5: + if args.num_classes > 5 and not args.dr: stats[1]['Top5'] = top5 else: stats = ('Performance/Validation/', OrderedDict([('Loss', vloss), @@ -621,6 +655,9 @@ def main(): is_best = False checkpoint_extras = {'current_top1': top1, 'current_mAP': mAP} + if args.dr: + checkpoint_extras['loss_weights'] = criterion.W + checkpoint_extras['loss_optimizer_state_dict'] = loss_optimizer.state_dict() apputils.save_checkpoint(epoch, args.cnn, model, optimizer=optimizer, scheduler=compression_scheduler, extras=checkpoint_extras, @@ -631,7 +668,8 @@ def main(): compression_scheduler.on_epoch_end(epoch, optimizer) # Finally run results on the test set - test(test_loader, model, criterion, [pylogger], activations_collectors, args=args) + if not args.dr: + test(test_loader, model, criterion, [pylogger], activations_collectors, args=args) if args.copy_output_folder: msglogger.info('Copying output folder to: %s', args.copy_output_folder) @@ -664,6 +702,9 @@ def create_model(supported_models, dimensions, args, mode='default'): if not Model: raise RuntimeError("Model " + args.kd_teacher + " not found\n") + if args.dr and ('dr' not in module or not module['dr']): + raise ValueError("Dimensionality reduction is not supported for this model") + # Set model parameters if args.act_mode_8bit: weight_bits = 8 @@ -684,6 +725,12 @@ def create_model(supported_models, dimensions, args, mode='default'): model_args["bias_bits"] = bias_bits model_args["quantize_activation"] = quantize_activation + if args.dr: + model_args["dimensionality"] = args.dr + + if args.backbone_checkpoint: + model_args["backbone_checkpoint"] = args.backbone_checkpoint + if args.obj_detection: model_args["device"] = args.device @@ -729,7 +776,7 @@ def create_nas_kd_policy(model, compression_scheduler, epoch, next_state_start_e def train(train_loader, model, criterion, optimizer, epoch, - compression_scheduler, loggers, args): + compression_scheduler, loggers, args, loss_optimizer=None): """Training loop for one epoch.""" losses = OrderedDict([(OVERALL_LOSS_KEY, tnt.AverageValueMeter()), (OBJECTIVE_LOSS_KEY, tnt.AverageValueMeter())]) @@ -823,7 +870,7 @@ def train(train_loader, model, criterion, optimizer, epoch, loss = criterion(output, target) # TODO Early exit mechanism for Object Detection case is NOT implemented yet - if not args.obj_detection and not args.kd_relationbased: + if not args.obj_detection and not args.dr and not args.kd_relationbased: if not args.earlyexit_lossweights: # Measure accuracy if the conditions are set. For `Last Batch` only accuracy # calculation last two batches are used as the last batch might include just a few @@ -868,11 +915,16 @@ def train(train_loader, model, criterion, optimizer, epoch, # Compute the gradient and do SGD step optimizer.zero_grad() + if args.dr: + loss_optimizer.zero_grad() + loss.backward() if compression_scheduler: compression_scheduler.before_parameter_optimization(epoch, train_step, steps_per_epoch, optimizer) optimizer.step() + if args.dr: + loss_optimizer.step() if compression_scheduler: compression_scheduler.on_minibatch_end(epoch, train_step, steps_per_epoch, optimizer) @@ -946,6 +998,23 @@ def update_bn_stats(train_loader, model, args): _ = model(inputs) +def get_all_embeddings(dataset, model): + """Get all embeddings from the test set""" + tester = testers.BaseTester() + return tester.get_all_embeddings(dataset, model) + + +def scaf_test(val_loader, model, accuracy_calculator): + """Perform test for SCAF""" + test_embeddings, test_labels = get_all_embeddings(val_loader.dataset, model) + test_labels = test_labels.squeeze(1) + accuracies = accuracy_calculator.get_accuracy( + test_embeddings, test_labels, None, None, True + ) + msglogger.info('Test set accuracy (Precision@1) = %f', accuracies['precision_at_1']) + return accuracies["precision_at_1"], 0, 0, 0 + + def validate(val_loader, model, criterion, loggers, args, epoch=-1, tflogger=None): """Model validation""" if epoch > -1: @@ -1192,7 +1261,8 @@ def save_tensor(t, f, regression=True): target /= 128. if args.generate_sample is not None and args.act_mode_8bit and not sample_saved: - sample.generate(args.generate_sample, inputs, target, output, args.dataset, False) + sample.generate(args.generate_sample, inputs, target, output, + args.dataset, False, args.slice_sample) sample_saved = True if args.csv_prefix is not None: diff --git a/train_all_models.sh b/train_all_models.sh index 5b23dcac5..18fef7f0b 100755 --- a/train_all_models.sh +++ b/train_all_models.sh @@ -33,8 +33,11 @@ echo "-----------------------------" echo "Training kws20_v3 model" scripts/train_kws20_v3.sh "$@" echo "-----------------------------" -echo "Training faceid model" -scripts/train_faceid.sh "$@" +echo "Training faceid_112 model" +scripts/train_faceid_112.sh "$@" +echo "-----------------------------" +echo "Training mobilefacenet_112 model" +scripts/train_mobilefacenet_112.sh "$@" echo "-----------------------------" echo "Training unet model" scripts/train_camvid_unet.sh "$@" @@ -53,3 +56,9 @@ scripts/train_facedet_tinierssd.sh "$@" echo "-----------------------------" echo "Training Bayer2RGB debayerization model" scripts/train_bayer2rgb_imagenet.sh "$@" +echo "-----------------------------" +echo "Training kws20_nas model" +scripts/train_kws20_nas.sh "$@" +echo "-----------------------------" +echo "Training Auto Encoder model" +scripts/train_autoencoder.sh "$@" diff --git a/utils/augmentation_utils.py b/utils/augmentation_utils.py index 6635cadfd..60df39f6e 100644 --- a/utils/augmentation_utils.py +++ b/utils/augmentation_utils.py @@ -1,19 +1,33 @@ -################################################################################################### # -# Copyright (C) 2023 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -################################################################################################### - -# -# GitHub repo for the below helper methods: -# https://github.com/sgrvinod/a-PyTorch-Tutorial-to-Object-Detection: # MIT License +# # Copyright (c) 2019 Sagar Vinodababu - -# Some augmentation functions below have been adapted from -# From https://github.com/amdegroot/ssd.pytorch/blob/master/utils/augmentations.py +# Copyright (c) 2017 Max deGroot, Ellis Brown +# Portions Copyright (C) 2023 Maxim Integrated Products, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# Helper methods originate from: +# https://github.com/sgrvinod/a-PyTorch-Tutorial-to-Object-Detection +# Some augmentation functions have been adapted from: +# https://github.com/amdegroot/ssd.pytorch/blob/master/utils/augmentations.py +# """ Some utility functions for Augmentation Tasks """ import random diff --git a/utils/autoencoder_eval_utils.py b/utils/autoencoder_eval_utils.py new file mode 100755 index 000000000..bb2660f8a --- /dev/null +++ b/utils/autoencoder_eval_utils.py @@ -0,0 +1,263 @@ +################################################################################################### +# +# Copyright (C) 2023 Analog Devices, Inc. All Rights Reserved. +# This software is proprietary to Analog Devices, Inc. and its licensors. +# +################################################################################################### +""" Some utility functions for AutoEncoder Models """ +import numpy as np +import torch +from torch import nn + +import matplotlib.pyplot as plt +import seaborn as sns + +sns.set_style("white") + + +DECAY_FACTOR = 1 + + +def calc_model_size(model): + """ + Returns the model's weight anf bias number. + """ + model.eval() + num_weights = 0 + num_bias = 0 + for name, param in model.named_parameters(): + if param.requires_grad: + if name.endswith('weight'): + num_weights += np.prod(param.size()) + elif name.endswith('bias'): + num_bias += np.prod(param.size()) + + print(f'\nNumber of Model Weights: {num_weights}') + print(f'Number of Model Bias: {num_bias}\n') + return num_weights, num_bias + + +def extract_reconstructions_losses(model, dataloader, device): + """ + Calculates and returns reconstructed signal reconstruction loss, input signals + and latent space representations for autoencoder model. + """ + model.eval() + loss_fn = nn.MSELoss(reduce=False) + losses = [] + reconstructions = [] + inputs = [] + labels = [] + + with torch.no_grad(): + for tup in dataloader: + if len(tup) == 2: + signal, label = tup + elif len(tup) == 3: + signal, label, _ = tup + elif len(tup) == 4: + signal, label, _, _ = tup + + signal = signal.to(device) + label = label.type(torch.long).to(device) + + inputs.append(signal) + labels.append(label) + + model_out = model(signal) + if isinstance(model_out, tuple): + model_out = model_out[0] + + loss = loss_fn(model_out, signal) + loss_numpy = loss.cpu().detach().numpy() + decay_vector = np.array([DECAY_FACTOR**i for i in range(loss_numpy.shape[2])]) + decay_vector = np.tile(decay_vector, (loss_numpy.shape[0], loss_numpy.shape[1], 1)) + + decayed_loss = loss_numpy * decay_vector + losses.extend(decayed_loss.mean(axis=(1, 2))) + reconstructions.append(model_out) + + return reconstructions, losses, inputs, labels + + +def plot_all_metrics(F1s, BalancedAccuracies, FPRs, Recalls, percentiles): + """ + F1, Balanced Accuracy, False Positive Rate metrics are plotted with respect to + threshold decided according to percentiles of training loss in percentile list. + """ + fontsize = 22 + linewidth = 4 + + fig, axs = plt.subplots(1, 4, figsize=(36, 11)) + + axs[0].plot(percentiles, F1s, '-o', linewidth=linewidth) + for i, xy in enumerate(zip(percentiles, F1s)): # pylint: disable=unused-variable + axs[0].annotate(f"{xy[1]: .3f}", xy=xy, fontsize=fontsize - 2) + + axs[0].grid() + + axs[0].set_title('\nF1 Score on Testset\n\n', fontsize=fontsize + 4, color='#0070C0') + axs[0].tick_params(axis='both', which='both', labelsize=fontsize) + axs[0].legend(("F1 Score",), loc='lower left', fontsize=fontsize - 2) + + axs[1].plot(percentiles, BalancedAccuracies, '-o', linewidth=linewidth) + for i, xy in enumerate(zip(percentiles, BalancedAccuracies)): + axs[1].annotate(f"{xy[1]: .3f}", xy=xy, fontsize=fontsize - 2) + + axs[1].grid() + + axs[1].set_title('\nBalanced Accuracy ((TPRate + TNRate) / 2) on Testset\n\n', + fontsize=fontsize + 4, color='#0070C0') + axs[1].tick_params(axis='both', which='both', labelsize=fontsize) + axs[1].legend(("Balanced Acc.",), loc='lower left', fontsize=fontsize - 2) + + axs[2].plot(percentiles, FPRs, '-o', linewidth=linewidth) + for i, xy in enumerate(zip(percentiles, FPRs)): + axs[2].annotate(f"{xy[1]: .3f}", xy=xy, fontsize=fontsize - 2) + + axs[2].grid() + axs[2].set_title('\nFalse Positive Rate on Testset\n\n', + fontsize=fontsize + 4, color='#0070C0') + axs[2].tick_params(axis='both', which='both', labelsize=fontsize) + axs[2].legend(("FPRate",), loc='lower left', fontsize=fontsize - 2) + + axs[3].plot(percentiles, Recalls, '-o', linewidth=linewidth) + for i, xy in enumerate(zip(percentiles, Recalls)): + axs[3].annotate(f"{xy[1]: .3f}", xy=xy, fontsize=fontsize - 2) + + axs[3].grid() + axs[3].set_title('\nTrue Positive Rate on Testset\n\n', fontsize=fontsize + 4, color='#0070C0') + axs[3].tick_params(axis='both', which='both', labelsize=fontsize) + axs[3].legend(("Recall",), loc='lower left', fontsize=fontsize - 2) + + fig.supxlabel('\nReconstruction Loss distribution percentile of training samples (%)', + fontsize=fontsize + 4) + + plt.tight_layout() + plt.show() + + +def sweep_performance_metrics(thresholds, train_tuple, test_tuple): + """ + F1s, BalancedAccuracies, FPRs, Recalls are calculated + and returned based on different thresholds. + """ + + train_reconstructions, train_losses, \ + train_inputs, train_labels = train_tuple # pylint: disable=unused-variable + test_reconstructions, test_losses, \ + test_inputs, test_labels = test_tuple # pylint: disable=unused-variable + + FPRs = [] + F1s = [] + BalancedAccuracies = [] + Recalls = [] + + for threshold in thresholds: + FPRate, _, Recall, Precision, Accuracy, F1, BalancedAccuracy = calc_ae_perf_metrics( + test_reconstructions, + test_inputs, + test_labels, + threshold=threshold, + print_all=False + ) + + _, _, _, _, AccuracyTrain, _, _ = calc_ae_perf_metrics( + train_reconstructions, + train_inputs, + train_labels, + threshold=threshold, + print_all=False + ) + + F1s.append(F1.item()) + BalancedAccuracies.append(BalancedAccuracy.item()) + FPRs.append(FPRate.item()) + Recalls.append(Recall.item()) + + print(f"F1: {F1: .4f}, BalancedAccuracy: {BalancedAccuracy: .4f}, " + f"FPRate: {FPRate: .4f}, Precision: {Precision: .4f}, TPRate (Recall): " + f"{Recall: .4f}, Accuracy: {Accuracy: .4f}, " + f"TRAIN-SET Accuracy: {AccuracyTrain: .4f}") + + return F1s, BalancedAccuracies, FPRs, Recalls + + +def calc_ae_perf_metrics(reconstructions, inputs, labels, threshold, print_all=True): + """ + False Positive Rate, TNRate, Recall, Precision, Accuracy, F1, BalancedAccuracy + metrics of AutoEncoder are calculated and returned. + """ + + loss_fn = nn.MSELoss(reduce=False) + FP = 0 + FN = 0 + TP = 0 + TN = 0 + + Recall = -1 + Precision = -1 + Accuracy = -1 + F1 = -1 + FPRate = -1 + + BalancedAccuracy = -1 + TNRate = -1 # specificity (SPC), selectivity + + for i, inputs_batch in enumerate(inputs): + label_batch = labels[i] + reconstructions_batch = reconstructions[i] + # inputs_batch = inputs[i] + + loss = loss_fn(reconstructions_batch, inputs_batch) + + # Loss Decay + loss_numpy = loss.cpu().detach().numpy() + decay_vector = np.array([DECAY_FACTOR**i for i in range(loss_numpy.shape[2])]) + decay_vector = np.tile(decay_vector, (loss_numpy.shape[0], loss_numpy.shape[1], 1)) + decayed_loss = loss_numpy * decay_vector + decayed_loss = torch.Tensor(decayed_loss).to(label_batch.device) + + loss_batch = decayed_loss.mean(dim=(1, 2)) + prediction_batch = loss_batch > threshold + + TN += torch.sum(torch.logical_and(torch.logical_not(prediction_batch), + torch.squeeze(torch.logical_not(label_batch)))) + TP += torch.sum(torch.logical_and((prediction_batch), + torch.squeeze(label_batch))) + FN += torch.sum(torch.logical_and(torch.logical_not(prediction_batch), + torch.squeeze(label_batch))) + FP += torch.sum(torch.logical_and((prediction_batch), + torch.squeeze(torch.logical_not(label_batch)))) + + if TP + FN != 0: + Recall = TP / (TP + FN) + + if TP + FP != 0: + Precision = TP / (TP + FP) + + Accuracy = (TP + TN) / (TP + TN + FP + FN) + + if (TN + FP) != 0: + FPRate = FP / (TN + FP) + TNRate = TN / (TN + FP) + + if Precision + Recall != 0: + F1 = 2 * (Precision * Recall) / (Precision + Recall) + + BalancedAccuracy = (Recall + TNRate) / 2 + + if print_all: + print(f"TP: {TP}") + print(f"FP: {FP}") + print(f"TN: {TN}") + print(f"FN: {FN}") + print(f"FPRate: {FPRate}") + print(f"TNRate = Specificity: {TNRate}") + print(f"TPRate (Recall): {Recall}") + print(f"Precision: {Precision}") + print(f"Accuracy: {Accuracy}") + print(f"F1: {F1}") + print(f"BalancedAccuracy: {BalancedAccuracy}") + + return FPRate, TNRate, Recall, Precision, Accuracy, F1, BalancedAccuracy diff --git a/utils/dataloader_utils.py b/utils/dataloader_utils.py new file mode 100644 index 000000000..33adca3e4 --- /dev/null +++ b/utils/dataloader_utils.py @@ -0,0 +1,22 @@ +################################################################################################### +# +# Copyright (C) 2024 Analog Devices, Inc. All Rights Reserved. +# This software is proprietary to Analog Devices, Inc. and its licensors. +# +################################################################################################### +"""Data loader utils functions""" +import errno +import os + + +def makedir_exist_ok(dirpath): + """ + Creates directory path + """ + try: + os.makedirs(dirpath) + except OSError as e: + if e.errno == errno.EEXIST: + pass + else: + raise diff --git a/utils/kd_relationbased.py b/utils/kd_relationbased.py index 7ade8c293..ed6c721b3 100644 --- a/utils/kd_relationbased.py +++ b/utils/kd_relationbased.py @@ -1,15 +1,6 @@ -################################################################################################### -# -# Copyright (C) 2023 Analog Devices, Inc. All Rights Reserved. -# -# Analog Devices, Inc. Default Copyright Notice: -# https://www.analog.com/en/about-adi/legal-and-risk-oversight/intellectual-property/copyright-notice.html -# -################################################################################################### -# -# Portions Copyright (c) 2018 Intel Corporation # # Copyright (c) 2018 Intel Corporation +# Portions Copyright (C) 2023 Analog Devices, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -23,7 +14,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # - """ Relation based Knowledge Distillation Policy""" from collections import namedtuple @@ -43,7 +33,7 @@ class RelationBasedKDPolicy(ScheduledTrainingPolicy): the distiller's ScheduledTrainingPolicy class. """ def __init__(self, student_model, teacher_model, - loss_weights=DistillationLossWeights(0.5, 0.5, 0)): + loss_weights=DistillationLossWeights(0.5, 0.5, 0), act_mode_8bit=False): super().__init__() self.student = student_model @@ -53,6 +43,7 @@ def __init__(self, student_model, teacher_model, self.loss_wts = loss_weights self.distillation_loss = nn.MSELoss() self.overall_loss = None + self.act_mode_8bit = act_mode_8bit # Active is always true, because test will be based on the overall loss and it will be # realized outside of the epoch loop @@ -75,6 +66,8 @@ def forward(self, *inputs): self.teacher_output = self.teacher(*inputs) out = self.student(*inputs) + if self.act_mode_8bit: + out /= 128. self.student_output = out.clone() return out diff --git a/utils/object_detection_utils.py b/utils/object_detection_utils.py index ff2cc2a73..9f42c2855 100644 --- a/utils/object_detection_utils.py +++ b/utils/object_detection_utils.py @@ -1,17 +1,30 @@ -################################################################################################### # -# Copyright (C) 2022-2023 Maxim Integrated Products, Inc. All Rights Reserved. -# -# Maxim Integrated Products, Inc. Default Copyright Notice: -# https://www.maximintegrated.com/en/aboutus/legal/copyrights.html -################################################################################################### -# -# GitHub repo for the following helper methods: -# https://github.com/sgrvinod/a-PyTorch-Tutorial-to-Object-Detection: # MIT License +# # Copyright (c) 2019 Sagar Vinodababu - -# Code slightly modified +# Portions Copyright (C) 2022-2023 Maxim Integrated Products, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy of +# this software and associated documentation files (the "Software"), to deal in +# the Software without restriction, including without limitation the rights to +# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +# of the Software, and to permit persons to whom the Software is furnished to do +# so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# GitHub repo for the following helper methods +# https://github.com/sgrvinod/a-PyTorch-Tutorial-to-Object-Detection +# """ Utility functions for Object Detection Tasks """ import torch